Merge pull request #26898 from gottesmm/pr-ec34aef279bb7b977ac23243588bb03b3f435c62

Author: swift-ci

lib/SILOptimizer/Mandatory/SemanticARCOpts.cpp

@@ -280,7 +280,11 @@ static bool canHandleOperand(SILValue operand, SmallVectorImpl<SILValue> &out) {
     return false;
 
   /// TODO: Add support for begin_borrow, load_borrow.
-  return all_of(out, [](SILValue v) { return isa<SILFunctionArgument>(v); });
+  auto canHandleValue = [](SILValue v) -> bool {
+    return isa<SILFunctionArgument>(v) || isa<LoadBorrowInst>(v) ||
+           isa<BeginBorrowInst>(v);
+  };
+  return all_of(out, canHandleValue);
 }
 
 // Eliminate a copy of a borrowed value, if:
@@ -328,6 +332,9 @@ bool SemanticARCOptVisitor::performGuaranteedCopyValueOptimization(CopyValueInst
   // make sure all of them are destroy_value. For our non-destroying
   // instructions, make sure that they accept a guaranteed value. After that,
   // make sure that our destroys are within the lifetime of our borrowed values.
+  //
+  // TODO: Change isConsumed to return branch propagated users for destroys, so
+  // we do not need to construct another array.
   SmallVector<DestroyValueInst *, 16> destroys;
   SmallVector<SILInstruction *, 16> guaranteedForwardingInsts;
   if (isConsumed(cvi, destroys, &guaranteedForwardingInsts))
@@ -339,11 +346,38 @@ bool SemanticARCOptVisitor::performGuaranteedCopyValueOptimization(CopyValueInst
   // post-dominated by the end_borrow set. If they do not, then the
   // copy_value is lifetime extending the guaranteed value, we can not
   // eliminate it.
-  //
-  // TODO: When we support begin_borrow/load_borrow a linear linfetime
-  // check will be needed here.
-  assert(all_of(borrowIntroducers,
-                [](SILValue v) { return isa<SILFunctionArgument>(v); }));
+  {
+    SmallVector<BranchPropagatedUser, 8> destroysForLinearLifetimeCheck(
+        destroys.begin(), destroys.end());
+    SmallVector<BranchPropagatedUser, 8> endBorrowInsts;
+    SmallPtrSet<SILBasicBlock *, 4> visitedBlocks;
+    for (SILValue v : borrowIntroducers) {
+      if (isa<SILFunctionArgument>(v)) {
+        continue;
+      }
+
+      SWIFT_DEFER {
+        endBorrowInsts.clear();
+        visitedBlocks.clear();
+      };
+
+      if (auto *lbi = dyn_cast<LoadBorrowInst>(v)) {
+        llvm::copy(lbi->getEndBorrows(), std::back_inserter(endBorrowInsts));
+      } else if (auto *bbi = dyn_cast<BeginBorrowInst>(v)) {
+        llvm::copy(bbi->getEndBorrows(), std::back_inserter(endBorrowInsts));
+      } else {
+        llvm_unreachable("Unhandled borrow introducer?!");
+      }
+
+      // Make sure that our destroys are properly nested within our end
+      // borrows. Otherwise, we can not optimize.
+      auto result = valueHasLinearLifetime(
+          v, endBorrowInsts, destroysForLinearLifetimeCheck, visitedBlocks,
+          getDeadEndBlocks(), ownership::ErrorBehaviorKind::ReturnFalse);
+      if (result.getFoundError())
+        return false;
+    }
+  }
 
   // Otherwise, we know that our copy_value/destroy_values are all completely
   // within the guaranteed value scope. First delete the destroys/copies.

test/SILOptimizer/semantic-arc-opts.sil

@@ -10,12 +10,15 @@ import Builtin
 
 sil @guaranteed_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
 sil @owned_user : $@convention(thin) (@owned Builtin.NativeObject) -> ()
+sil @get_owned_obj : $@convention(thin) () -> @owned Builtin.NativeObject
 
 struct NativeObjectPair {
   var obj1 : Builtin.NativeObject
   var obj2 : Builtin.NativeObject
 }
 
+sil @get_nativeobject_pair : $@convention(thin) () -> @owned NativeObjectPair
+
 class Klass {}
 
 struct MyInt {
@@ -702,3 +705,74 @@ bb1:
   return %9999 : $()
 }
 
+// CHECK-LABEL: sil [ossa] @begin_borrow_simple : $@convention(thin) () -> () {
+// CHECK-NOT: copy_value
+// CHECK: } // end sil function 'begin_borrow_simple'
+sil [ossa] @begin_borrow_simple : $@convention(thin) () -> () {
+bb0:
+  %0 = function_ref @get_nativeobject_pair : $@convention(thin) () -> @owned NativeObjectPair
+  %1 = apply %0() : $@convention(thin) () -> @owned NativeObjectPair
+  %2 = begin_borrow %1 : $NativeObjectPair
+  %3 = struct_extract %2 : $NativeObjectPair, #NativeObjectPair.obj1
+  %4 = copy_value %3 : $Builtin.NativeObject
+  %5 = function_ref @guaranteed_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+  apply %5(%4) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+  destroy_value %4 : $Builtin.NativeObject
+  end_borrow %2 : $NativeObjectPair
+  destroy_value %1 : $NativeObjectPair
+  %9999 = tuple()
+  return %9999 : $()
+}
+
+// CHECK-LABEL: sil [ossa] @begin_borrow_fail : $@convention(thin) () -> () {
+// CHECK: copy_value
+// CHECK: } // end sil function 'begin_borrow_fail'
+sil [ossa] @begin_borrow_fail : $@convention(thin) () -> () {
+bb0:
+  %0 = function_ref @get_nativeobject_pair : $@convention(thin) () -> @owned NativeObjectPair
+  %1 = apply %0() : $@convention(thin) () -> @owned NativeObjectPair
+  %2 = begin_borrow %1 : $NativeObjectPair
+  %3 = struct_extract %2 : $NativeObjectPair, #NativeObjectPair.obj1
+  %4 = copy_value %3 : $Builtin.NativeObject
+  %5 = function_ref @guaranteed_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+  apply %5(%4) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+  end_borrow %2 : $NativeObjectPair
+  destroy_value %4 : $Builtin.NativeObject
+  destroy_value %1 : $NativeObjectPair
+  %9999 = tuple()
+  return %9999 : $()
+}
+
+// CHECK-LABEL: sil [ossa] @load_borrow_simple : $@convention(thin) (@in NativeObjectPair) -> () {
+// CHECK-NOT: copy_value
+// CHECK: } // end sil function 'load_borrow_simple'
+sil [ossa] @load_borrow_simple : $@convention(thin) (@in NativeObjectPair) -> () {
+bb0(%0 : $*NativeObjectPair):
+  %2 = load_borrow %0 : $*NativeObjectPair
+  %3 = struct_extract %2 : $NativeObjectPair, #NativeObjectPair.obj1
+  %4 = copy_value %3 : $Builtin.NativeObject
+  %5 = function_ref @guaranteed_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+  apply %5(%4) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+  destroy_value %4 : $Builtin.NativeObject
+  end_borrow %2 : $NativeObjectPair
+  destroy_addr %0 : $*NativeObjectPair
+  %9999 = tuple()
+  return %9999 : $()
+}
+
+// CHECK-LABEL: sil [ossa] @load_borrow_fail : $@convention(thin) (@in NativeObjectPair) -> () {
+// CHECK: copy_value
+// CHECK: } // end sil function 'load_borrow_fail'
+sil [ossa] @load_borrow_fail : $@convention(thin) (@in NativeObjectPair) -> () {
+bb0(%0 : $*NativeObjectPair):
+  %2 = load_borrow %0 : $*NativeObjectPair
+  %3 = struct_extract %2 : $NativeObjectPair, #NativeObjectPair.obj1
+  %4 = copy_value %3 : $Builtin.NativeObject
+  %5 = function_ref @guaranteed_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+  apply %5(%4) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+  end_borrow %2 : $NativeObjectPair
+  destroy_value %4 : $Builtin.NativeObject
+  destroy_addr %0 : $*NativeObjectPair
+  %9999 = tuple()
+  return %9999 : $()
+}