Merge pull request swiftlang#65566 from nate-chandler/rdar108745323/2

[SemanticARCOpts] Check uses in moved load range.

Author: nate-chandler

lib/SILOptimizer/SemanticARC/LoadCopyToLoadBorrowOpt.cpp

@@ -140,9 +140,15 @@ class StorageGuaranteesLoadVisitor
       SmallVector<BeginAccessInst *, 16> foundBeginAccess;
       LinearLifetimeChecker checker(&ctx.getDeadEndBlocks());
       SILValue introducerValue = liveRange.getIntroducer().value;
-      if (!checker.usesNotContainedWithinLifetime(introducerValue,
-                                                  liveRange.getDestroyingUses(),
-                                                  *wellBehavedWrites)) {
+      SmallVector<Operand *, 4> consumingUses;
+      for (auto *op : liveRange.getDestroyingUses()) {
+        consumingUses.push_back(op);
+      }
+      for (auto *op : liveRange.getUnknownConsumingUses()) {
+        consumingUses.push_back(op);
+      }
+      if (!checker.usesNotContainedWithinLifetime(
+              introducerValue, consumingUses, *wellBehavedWrites)) {
         return answer(true);
       }
 
@@ -368,7 +374,8 @@ bool SemanticARCOptVisitor::performLoadCopyToLoadBorrowOptimization(
   // Then check if our address is ever written to. If it is, then we cannot use
   // the load_borrow because the stored value may be released during the loaded
   // value's live range.
-  if (isWrittenTo(ctx, li, lr))
+  if (isWrittenTo(ctx, li, lr) ||
+      (li != original && isWrittenTo(ctx, li, OwnershipLiveRange(li))))
     return false;
 
   // Ok, we can perform our optimization. Convert the load [copy] into a

lib/SILOptimizer/SemanticARC/OwnershipLiveRange.h

@@ -109,6 +109,10 @@ class LLVM_LIBRARY_VISIBILITY OwnershipLiveRange {
 
   ArrayRef<Operand *> getDestroyingUses() const { return destroyingUses; }
 
+  ArrayRef<Operand *> getUnknownConsumingUses() const {
+    return unknownConsumingUses;
+  }
+
 private:
   struct OperandToUser;
 

test/SILOptimizer/semantic-arc-opts-loadcopy-to-loadborrow.sil

@@ -1601,3 +1601,39 @@ bb0:
   %retval = tuple ()
   return %retval : $()
 }
+
+// CHECK-LABEL: sil [ossa] @load_take_between_load_copy_and_move_inout : {{.*}} {
+// CHECK:         load [copy]
+// CHECK-LABEL: } // end sil function 'load_take_between_load_copy_and_move_inout'
+sil [ossa] @load_take_between_load_copy_and_move_inout : $@convention(thin) (@inout C) -> () {
+entry(%addr : $*C):
+    %v1 = load [copy] %addr : $*C
+    %v2 = load [take] %addr : $*C
+    %m1 = move_value [lexical] %v1 : $C
+    destroy_value %m1 : $C
+    store %v2 to [init] %addr : $*C
+    %retval = tuple ()
+    return %retval : $()
+}
+
+// CHECK-LABEL: sil [ossa] @load_take_between_load_copy_and_move_stack : {{.*}} {
+// CHECK:         load [copy]
+// CHECK-LABEL: } // end sil function 'load_take_between_load_copy_and_move_stack'
+sil [ossa] @load_take_between_load_copy_and_move_stack : $@convention(thin) () -> () {
+entry:
+    %addr = alloc_stack $C
+    %getC = function_ref @getC : $@convention(thin) () -> (@owned C)
+    %stored = apply %getC() : $@convention(thin) () -> (@owned C)
+    store %stored to [init] %addr : $*C
+
+    %v1 = load [copy] %addr : $*C
+    %v2 = load [take] %addr : $*C
+    %m1 = move_value [lexical] %v1 : $C
+    destroy_value %m1 : $C
+    store %v2 to [init] %addr : $*C
+
+    destroy_addr %addr : $*C
+    dealloc_stack %addr : $*C
+    %retval = tuple ()
+    return %retval : $()
+}