Temporary fix for OSSA RAUW utilities.

This fix unblocks unrelated optimizer commits. A unit test will be
introduced with those commits.

The RAUW utility does not correctly handle reborrows. It is in the
middle of being rewritten. For now, simply bail out since this isn't
an important case to optimize.

Author: atrick

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 {