Merge pull request #67660 from nate-chandler/opaque-values/20230801/2/rewrite_consuming_uses_last

[AddressLowering] Rewrite lifetime-ends last.

Author: nate-chandler

lib/SIL/IR/SILInstruction.cpp

@@ -26,6 +26,7 @@
 #include "swift/SIL/SILDebugScope.h"
 #include "swift/SIL/SILModule.h"
 #include "swift/SIL/SILVisitor.h"
+#include "swift/SIL/Test.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -120,6 +121,15 @@ void SILInstruction::moveBefore(SILInstruction *Later) {
   SILBasicBlock::moveInstruction(this, Later);
 }
 
+namespace swift::test {
+FunctionTest MoveBeforeTest("instruction-move-before",
+                            [](auto &function, auto &arguments, auto &test) {
+                              auto *inst = arguments.takeInstruction();
+                              auto *other = arguments.takeInstruction();
+                              inst->moveBefore(other);
+                            });
+} // end namespace swift::test
+
 /// Unlink this instruction from its current basic block and insert it into
 /// the basic block that Earlier lives in, right after Earlier.
 void SILInstruction::moveAfter(SILInstruction *Earlier) {

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -4169,19 +4169,19 @@ static void rewriteFunction(AddressLoweringState &pass) {
 
     // Collect end_borrows and rewrite them last so that when rewriting other
     // users the lifetime ends of a borrow introducer can be used.
-    StackList<EndBorrowInst *> endBorrows(pass.function);
+    StackList<Operand *> lifetimeEndingUses(pass.function);
     SmallPtrSet<Operand *, 8> originalUses;
     SmallVector<Operand *, 8> uses(valueDef->getUses());
     for (auto *oper : uses) {
       originalUses.insert(oper);
-      if (auto *ebi = dyn_cast<EndBorrowInst>(oper->getUser())) {
-        endBorrows.push_back(ebi);
+      if (oper->isLifetimeEnding()) {
+        lifetimeEndingUses.push_back(oper);
         continue;
       }
       UseRewriter::rewriteUse(oper, pass);
     }
-    for (auto *ebi : endBorrows) {
-      UseRewriter::rewriteUse(&ebi->getOperandRef(), pass);
+    for (auto *oper : lifetimeEndingUses) {
+      UseRewriter::rewriteUse(oper, pass);
     }
     // Rewrite every new use that was added.
     uses.clear();

test/SILOptimizer/address_lowering_preprocessed.sil

@@ -0,0 +1,38 @@
+// RUN: %empty-directory(%t) 
+// RUN: %target-sil-opt -test-runner -address-lowering -enable-sil-opaque-values -emit-sorted-sil -sil-verify-none %s > %t/out.sil
+// RUN: %target-sil-opt -emit-sorted-sil -sil-verify-all %t/out.sil | %FileCheck %s
+
+import Builtin
+import Swift
+import SwiftShims
+
+struct Box<T> {
+    var _value : T
+}
+
+// Verify that the isCopyValue assertion in
+// AddressMaterialization::materializeDefProjection is not triggered.  This is
+// possible because the destroy_value is rewritten last.  Rewriting it last
+// enables the lifetime analysis done in isStoreCopy to remain valid until the
+// lifetime-ending uses are rewritten.
+// CHECK-LABEL: sil [ossa] @destroy_before_copy_in_use_list : {{.*}} {
+// CHECK:       bb0([[T:%[^,]+]] : $*T, [[BOX:%[^,]+]] :
+// CHECK:         [[FIELD_ADDR:%[^,]+]] = struct_element_addr [[BOX]] : {{.*}}, #Box._value
+// CHECK:         copy_addr [[T]] to [[FIELD_ADDR]]
+// CHECK:         [[RETVAL:%[^,]+]] = tuple ()
+// CHECK:         destroy_addr [[T]]
+// CHECK:         return [[RETVAL]]
+// CHECK-LABEL: } // end sil function 'destroy_before_copy_in_use_list'
+sil [ossa] @destroy_before_copy_in_use_list : $@convention(thin) <T> (@in T, @inout Box<T>) -> () {
+bb0(%t : @owned $T, %box : $*Box<T>):
+  // The destroy_value appears first in the textual SIL in order to be first in
+  // the use list.  Before running AddressLowering, it's sunk to after the
+  // end_access.
+  test_specification "instruction-move-before @instruction @instruction[+5]"
+  destroy_value %t : $T
+  %copy = copy_value %t : $T
+  %field_addr = struct_element_addr %box : $*Box<T>, #Box._value
+  store %copy to [assign] %field_addr : $*T
+  %retval = tuple ()
+  return %retval : $()
+}