Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

lib/SILOptimizer/Transforms/CopyPropagation.cpp

@@ -617,7 +617,9 @@ void CopyPropagation::run() {
   // Canonicalize all owned defs.
   while (!defWorklist.ownedValues.empty()) {
     SILValue def = defWorklist.ownedValues.pop_back_val();
-    canonicalizer.canonicalizeValueLifetime(def);
+    auto canonicalized = canonicalizer.canonicalizeValueLifetime(def);
+    if (!canonicalized)
+      continue;
     // Copies of borrowed values may be dead.
     if (auto *inst = def->getDefiningInstruction())
       deleter.trackIfDead(inst);

lib/SILOptimizer/Utils/InstructionDeleter.cpp

@@ -10,10 +10,11 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "swift/SILOptimizer/Utils/InstructionDeleter.h"
 #include "swift/SIL/SILFunction.h"
+#include "swift/SIL/Test.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 +61,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))
@@ -289,6 +305,22 @@ bool InstructionDeleter::deleteIfDead(SILInstruction *inst, bool fixLifetime) {
   return false;
 }
 
+namespace swift::test {
+// Arguments:
+// - instruction: the instruction to delete
+// Dumps:
+// - the function
+static FunctionTest DeleterDeleteIfDeadTest(
+    "deleter-delete-if-dead", [](auto &function, auto &arguments, auto &test) {
+      auto *inst = arguments.takeInstruction();
+      InstructionDeleter deleter;
+      llvm::dbgs() << "Deleting-if-dead " << *inst;
+      auto deleted = deleter.deleteIfDead(inst);
+      llvm::dbgs() << "deleteIfDead returned " << deleted << "\n";
+      function.dump();
+    });
+} // namespace swift::test
+
 void InstructionDeleter::forceDeleteAndFixLifetimes(SILInstruction *inst) {
   SILFunction *fun = inst->getFunction();
   bool preserveDebugInfo =

test/SILOptimizer/copy_propagation.sil

@@ -16,6 +16,10 @@ class C {
   var a: Builtin.Int64
 }
 
+struct MOS : ~Copyable {
+  deinit {}
+}
+
 sil [ossa] @dummy : $@convention(thin) () -> ()
 sil [ossa] @barrier : $@convention(thin) () -> ()
 sil [ossa] @getOwnedC : $@convention(thin) () -> (@owned C)
@@ -26,6 +30,7 @@ sil [ossa] @takeOwnedCAndGuaranteedC : $@convention(thin) (@owned C, @guaranteed
 sil [ossa] @takeGuaranteedC : $@convention(thin) (@guaranteed C) -> ()
 sil [ossa] @borrowB : $@convention(thin) (@guaranteed B) -> ()
 sil [ossa] @takeGuaranteedAnyObject : $@convention(thin) (@guaranteed AnyObject) -> ()
+sil [ossa] @getMOS : $() -> (@owned MOS)
 
 // -O hoists the destroy
 //
@@ -1047,3 +1052,23 @@ entry(%instance : @owned $C):
   %retval = tuple ()
   return %retval : $()
 }
+
+// CHECK-LABEL: sil [ossa] @dontShortenDeadMoveOnlyLifetime : {{.*}} {
+// CHECK:         [[GET:%[^,]+]] = function_ref @getMOS
+// CHECK:         [[BARRIER:%[^,]+]] = function_ref @barrier
+// CHECK:         [[MOS:%[^,]+]] = apply [[GET]]()
+// CHECK:         [[MOV:%[^,]+]] = move_value [lexical] [[MOS]]
+// CHECK:         apply [[BARRIER]]()
+// CHECK:         destroy_value [[MOV]]
+// CHECK-LABEL: } // end sil function 'dontShortenDeadMoveOnlyLifetime'
+sil [ossa] @dontShortenDeadMoveOnlyLifetime : $@convention(thin) () -> () {
+  %get = function_ref @getMOS : $@convention(thin) () -> (@owned MOS)
+  %barrier = function_ref @barrier : $@convention(thin) () -> ()
+  %mos = apply %get() : $@convention(thin) () -> (@owned MOS)
+  // Note: This must be lexical so that it doesn't get eliminated as redundant.
+  %mov = move_value [lexical] %mos : $MOS
+  apply %barrier() : $@convention(thin) () -> ()
+  destroy_value %mov : $MOS
+  %retval = tuple ()
+  return %retval : $()
+}

test/SILOptimizer/instruction_deleter.sil

@@ -0,0 +1,30 @@
+// RUN: %target-sil-opt -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 : $()
+}