Merge pull request #41450 from atrick/rauw-fix-rebase

Temporary fix for OSSA RAUW utilities.

Author: nate-chandler

lib/SIL/Utils/OwnershipUtils.cpp

@@ -90,6 +90,9 @@ bool swift::canOpcodeForwardOwnedValues(Operand *use) {
 // Skip over nested borrow scopes. Their scope-ending instructions are their use
 // points. Transitively find all nested scope-ending instructions by looking
 // through nested reborrows. Nested reborrows are not use points.
+//
+// FIXME: handle inner reborrows, which aren't dominated by
+// guaranteedValue. Audit all users to handle reborrows.
 bool swift::findInnerTransitiveGuaranteedUses(
   SILValue guaranteedValue, SmallVectorImpl<Operand *> *usePoints) {
 
@@ -183,13 +186,18 @@ bool swift::findInnerTransitiveGuaranteedUses(
       break;
     }
     case OperandOwnership::Borrow:
-      // FIXME: visitExtendedScopeEndingUses can't return false here once dead
+      // FIXME: Use visitExtendedScopeEndingUses and audit all clients to handle
+      // reborrows.
+      //
+      // FIXME: visit[Extended]ScopeEndingUses can't return false here once dead
       // borrows are disallowed.
-      if (!BorrowingOperand(use).visitExtendedScopeEndingUses(
-            [&](Operand *endUse) {
-              leafUse(endUse);
-              return true;
-            })) {
+      if (!BorrowingOperand(use).visitScopeEndingUses([&](Operand *endUse) {
+            if (endUse->getOperandOwnership() == OperandOwnership::Reborrow) {
+              foundPointerEscape = true;
+            }
+            leafUse(endUse);
+            return true;
+          })) {
         // Special case for dead borrows. This is dangerous because clients
         // don't expect a begin_borrow to be in the use list.
         leafUse(use);

lib/SILOptimizer/Utils/OwnershipOptUtils.cpp

@@ -392,18 +392,27 @@ bool OwnershipRAUWHelper::hasValidRAUWOwnership(SILValue oldValue,
 static bool canFixUpOwnershipForRAUW(SILValue oldValue, SILValue newValue,
                                      OwnershipFixupContext &context) {
   switch (oldValue.getOwnershipKind()) {
-  case OwnershipKind::Guaranteed:
+  case OwnershipKind::Guaranteed: {
     // Check that the old lifetime can be extended and record the necessary
     // book-keeping in the OwnershipFixupContext.
     context.clear();
 
     // Check that no transitive uses have a PointerEscape, and record the leaf
     // uses for liveness extension.
-    if (!findExtendedTransitiveGuaranteedUses(oldValue,
-                                              context.guaranteedUsePoints))
+    //
+    // FIXME: Use findExtendedTransitiveGuaranteedUses and switch the
+    // implementation of borrowCopyOverGuaranteedUses to
+    // GuaranteedOwnershipExtension.  Utils then, reborrows are considered
+    // pointer escapes, causing findTransitiveGuaranteedUses to return false. So
+    // they can be ignored.
+    auto visitReborrow = [&](Operand *reborrow) {};
+    if (!findTransitiveGuaranteedUses(oldValue, context.guaranteedUsePoints,
+                                      visitReborrow)) {
       return false;
+    }
     return OwnershipRAUWHelper::hasValidRAUWOwnership(
         oldValue, newValue, context.guaranteedUsePoints);
+  }
   default: {
     SmallVector<Operand *, 8> ownedUsePoints;
     // If newValue is lexical, find the uses of oldValue so that it can be

test/SILOptimizer/cse_ossa_nontrivial.sil

@@ -609,10 +609,15 @@ struct RecurStruct {
 }
 
 // Test to make sure we do not crash on a use after free when the branch instructions in bb1 and bb2 are deleted
+//
+// FIXME: Fix OwnershipRAUW to handle guaranteed uses of the old CSE'd
+// value that are reborrows. The reborrowed uses are not dominated by
+// the old value, but they are still within the new values borrow scope.
+//
 // CHECK-LABEL: sil [ossa] @test_useafterfreeinrauw :
 // CHECK: bb0
 // CHECK: struct_extract
-// CHECK-NOT: struct_extract
+// FIXME-CHECK-NOT: struct_extract
 // CHECK: cond_br
 // CHECK-LABEL: } // end sil function 'test_useafterfreeinrauw'
 sil [ossa] @test_useafterfreeinrauw : $@convention(thin) (@guaranteed RecurStruct) -> @owned NonTrivialStruct {