[SSADestroyHoisting] Bitcasts obstruct folding.

Make loads and copy_addrs of casts of the underlying storage barriers to
folding.  Destroying the target address may not be equivalent to
destroying the source address: for example, if the target address is a
generic and the source address is AnyObject, specialization may turn the
generic into a trivial type; the destruction of that trivial type fails
to destroy the original stored AnyObject, resulting in a leak.

Author: nate-chandler

lib/SILOptimizer/Transforms/SSADestroyHoisting.cpp

@@ -786,8 +786,15 @@ bool HoistDestroys::checkFoldingBarrier(
   SILValue address;
   if (auto *load = dyn_cast<LoadInst>(instruction)) {
     auto loadee = load->getOperand();
-    auto accessPath = AccessPath::compute(loadee);
-    if (accessPath.getStorage().hasIdenticalStorage(storage)) {
+    auto relativeAccessStorage = RelativeAccessStorageWithBase::compute(loadee);
+    if (relativeAccessStorage.getStorage().hasIdenticalStorage(storage)) {
+      // If the access path from the loaded address to its root storage involves
+      // a (layout non-equivalent) typecast--a load [take] of the casted address
+      // would not be equivalent to a load [copy] followed by a destroy_addr of
+      // the corresponding uncast projection--the truncated portion might have
+      // refcounted components.
+      if (relativeAccessStorage.cast == AccessStorageCast::Type)
+        return true;
       if (load->getOwnershipQualifier() == LoadOwnershipQualifier::Copy) {
         address = loadee;
         loads.push_back(load);
@@ -798,8 +805,15 @@ bool HoistDestroys::checkFoldingBarrier(
     }
   } else if (auto *copy = dyn_cast<CopyAddrInst>(instruction)) {
     auto source = copy->getSrc();
-    auto accessPath = AccessPath::compute(source);
-    if (accessPath.getStorage().hasIdenticalStorage(storage)) {
+    auto relativeAccessStorage = RelativeAccessStorageWithBase::compute(source);
+    if (relativeAccessStorage.getStorage().hasIdenticalStorage(storage)) {
+      // If the access path from the copy_addr'd address to its root storage
+      // involves a (layout non-equivalent) typecast--a copy_addr [take] of the
+      // casted address would not be equivalent to a copy_addr followed by a
+      // destroy_addr of the corresponding uncast projection--the truncated
+      // portion might have refcounted components.
+      if (relativeAccessStorage.cast == AccessStorageCast::Type)
+        return true;
       address = source;
       copies.push_back(copy);
     }

test/SILOptimizer/hoist_destroy_addr.sil

@@ -7,6 +7,8 @@ sil_stage canonical
 
 import Builtin
 
+typealias AnyObject = Builtin.AnyObject
+
 class X {
 }
 
@@ -390,7 +392,8 @@ entry(%addr : $*X, %instance : @owned $X):
 // CHECK-LABEL: sil [ossa] @hoist_upto_address_to_pointer_use : {{.*}} {
 // CHECK:         address_to_pointer
 // CHECK:         pointer_to_address
-// CHECK:         load [take]
+// CHECK:         load [copy]
+// CHECK:         destroy_addr
 // CHECK:         tuple
 // CHECK-LABEL: } // end sil function 'hoist_upto_address_to_pointer_use'
 sil [ossa] @hoist_upto_address_to_pointer_use : $@convention(thin) (@in X) -> (@owned X) {
@@ -795,3 +798,40 @@ entry(%instance : @owned $(X, I)):
     %retval = tuple (%copy : $(X, I), %i_2 : $I)
     return %retval : $((X, I), I)
 }
+
+// Don't fold a destroy_addr of underlying storage into the copy_addr of a
+// bitcast of that address.
+//
+// CHECK-LABEL: sil [ossa] @nofold_destroy_addr_original_into_copy_addr_cast : {{.*}} {
+// CHECK:         copy_addr {{%[^,]+}}
+// CHECK:         destroy_addr
+// CHECK-LABEL: } // end sil function 'nofold_destroy_addr_original_into_copy_addr_cast'
+sil [ossa] @nofold_destroy_addr_original_into_copy_addr_cast : $@convention(thin) <T> (@owned AnyObject) -> @out T {
+entry(%out : $*T, %instance : @owned $AnyObject):
+    %addr = alloc_stack $AnyObject
+    store %instance to [init] %addr : $*AnyObject
+    %cast_addr = unchecked_addr_cast %addr : $*AnyObject to $*T
+    copy_addr %cast_addr to [initialization] %out : $*T
+    destroy_addr %addr : $*AnyObject
+    dealloc_stack %addr : $*AnyObject
+    %retval = tuple ()
+    return %retval : $()
+}
+
+// Don't fold a destroy_addr of underlying storage into the load [copy] of a 
+// bitcast of that address.
+//
+// CHECK-LABEL: sil [ossa] @nofold_destroy_addr_original_into_load_cast : {{.*}} {
+// CHECK:         load [copy]
+// CHECK:         destroy_addr
+// CHECK-LABEL: } // end sil function 'nofold_destroy_addr_original_into_load_cast'
+sil [ossa] @nofold_destroy_addr_original_into_load_cast : $@convention(thin) (@owned AnyObject) -> @owned X {
+entry(%instance : @owned $AnyObject):
+    %addr = alloc_stack $AnyObject
+    store %instance to [init] %addr : $*AnyObject
+    %cast_addr = unchecked_addr_cast %addr : $*AnyObject to $*X
+    %cast = load [copy] %cast_addr : $*X
+    destroy_addr %addr : $*AnyObject
+    dealloc_stack %addr : $*AnyObject
+    return %cast : $X
+}