[AddrLowering] Copy for out-of-range guar stores.

When a copy_value's only use is a store, in some cases, as an
optimization, creating a copy_addr can be skipped.  Whether a value is
such a copy_value is determined by the isStoreCopy predicate.

If the operand of the copy_value is a guaranteed value and any of its
guaranteed roots have live ranges which the store is outside of, skip
this optimization and create the copy_addr.

Author: nate-chandler

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -361,13 +361,28 @@ static bool isStoreCopy(SILValue value) {
     SmallVector<SILValue, 4> roots;
     findGuaranteedReferenceRoots(source, /*lookThroughNestedBorrows=*/true,
                                  roots);
-    if (llvm::any_of(roots, [](SILValue root) {
-      // Handle forwarding phis conservatively rather than recursing.
-      if (SILArgument::asPhi(root) && !BorrowedValue(root))
-        return true;
-
-      return isa<BeginApplyInst>(root->getDefiningInstruction());
-    })) {
+    SSAPrunedLiveness liveness;
+    if (llvm::any_of(roots, [&liveness, storeInst](SILValue root) {
+          // Handle forwarding phis conservatively rather than recursing.
+          if (SILArgument::asPhi(root) && !BorrowedValue(root))
+            return true;
+
+          if (isa<BeginApplyInst>(root->getDefiningInstruction())) {
+            return true;
+          }
+          liveness.initializeDef(root);
+          auto summary = liveness.computeSimple();
+          if (summary.addressUseKind != AddressUseKind::NonEscaping) {
+            return true;
+          }
+          if (summary.innerBorrowKind != InnerBorrowKind::Contained) {
+            return true;
+          }
+          if (!liveness.isWithinBoundary(storeInst)) {
+            return true;
+          }
+          return false;
+        })) {
       return false;
     }
   }

test/SILOptimizer/address_lowering.sil

@@ -1858,6 +1858,29 @@ entry:
   return %retval : $()
 }
 
+// CHECK-LABEL: sil [ossa] @testCopyValue1StoreExtractAfterDestroyAggregate : {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[ADDR:%[^,]+]] :
+// CHECK:         [[INSTANCE_ADDR:%[^,]+]] = alloc_stack $Pair<T>
+// CHECK:         [[COPY_ADDR:%[^,]+]] = alloc_stack $T
+// CHECK:         apply undef<T>([[INSTANCE_ADDR]])
+// CHECK:         [[X_ADDR:%[^,]+]] = struct_element_addr [[INSTANCE_ADDR]]{{.*}}, #Pair.x
+// CHECK:         copy_addr [[X_ADDR]] to [init] [[COPY_ADDR]]
+// CHECK:         destroy_addr [[INSTANCE_ADDR]]
+// CHECK:         copy_addr [take] [[COPY_ADDR]] to [[ADDR]]
+// CHECK-LABEL: } // end sil function 'testCopyValue1StoreExtractAfterDestroyAggregate'
+sil [ossa] @testCopyValue1StoreExtractAfterDestroyAggregate : $@convention(thin) <T> (@inout T) -> () {
+entry(%addr : $*T):
+    %instance = apply undef<T>() : $@convention(thin) <Tee> () -> @out Pair<Tee>
+    %lifetime = begin_borrow %instance : $Pair<T>
+    %x = struct_extract %lifetime : $Pair<T>, #Pair.x
+    %copy = copy_value %x : $T
+    end_borrow %lifetime : $Pair<T>
+    destroy_value %instance : $Pair<T>
+    store %copy to [assign] %addr : $*T
+    %retval = tuple ()
+    return %retval : $()
+}
+
 // CHECK-LABEL: sil hidden [ossa] @testOpaqueYield :
 // CHECK: bb0(%0 : @guaranteed $TestGeneric<T>):
 // CHECK:   [[REF:%.*]] = ref_element_addr %0 : $TestGeneric<T>, #TestGeneric.borrowedGeneric