[AddressLowering] Handle unchecked to loadable.

When casting via unchecked_bitwise_cast, if the destination type is
loadable, don't mark the value it produces rewritten--that value is not
one that AddressLowering is tracking.  Instead, replace its copy_value
uses with load [copy] uses of the address the rewritten instruction
produces.

Author: nate-chandler

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -2776,7 +2776,20 @@ class UseRewriter : SILInstructionVisitor<UseRewriter> {
         uncheckedCastInst->getLoc(), srcAddr,
         uncheckedCastInst->getType().getAddressType());
 
-    markRewritten(uncheckedCastInst, destAddr);
+    if (uncheckedCastInst->getType().isAddressOnly(*pass.function)) {
+      markRewritten(uncheckedCastInst, destAddr);
+      return;
+    }
+
+    // For loadable cast destination type, replace copies with load copies.
+    if (Operand *use = uncheckedCastInst->getSingleUse()) {
+      if (auto *cvi = dyn_cast<CopyValueInst>(use->getUser())) {
+        auto *load = builder.createLoad(cvi->getLoc(), destAddr,
+                                        LoadOwnershipQualifier::Copy);
+        cvi->replaceAllUsesWith(load);
+        pass.deleter.forceDelete(cvi);
+      }
+    }
   }
 
   void visitUnconditionalCheckedCastInst(

test/SILOptimizer/opaque_values_Onone_stdlib.swift

@@ -50,3 +50,23 @@ func getRawPointer<T>(to value: T) -> Builtin.RawPointer {
 func getUnprotectedRawPointer<T>(to value: T) -> Builtin.RawPointer {
   return Builtin.unprotectedAddressOfBorrow(value)
 }
+
+// CHECK-LABEL: sil hidden @getBridgeObject : {{.*}} {
+// CHECK:         [[OBJECT_ADDR:%[^,]+]] = unchecked_addr_cast {{%[^,]+}} : $*T to $*Builtin.BridgeObject
+// CHECK:         [[OBJECT:%[^,]+]] = load [[OBJECT_ADDR]]
+// CHECK:         return [[OBJECT]]
+// CHECK-LABEL: } // end sil function 'getBridgeObject'
+@_silgen_name("getBridgeObject")
+func toObject<T>(_ object: inout T) -> Builtin.BridgeObject {
+  Builtin.reinterpretCast(object)
+}
+
+// CHECK-LABEL: sil hidden @getAnotherType : {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[RETADDR:%[^,]+]] : $*U, {{%[^,]+}} : $*T, {{%[^,]+}} : $@thick U.Type):
+// CHECK:         [[OTHER_TY_ADDR:%[^,]+]] = unchecked_addr_cast {{%[^,]+}} : $*T to $*U
+// CHECK:         copy_addr [[OTHER_TY_ADDR]] to [init] [[RETADDR]] : $*U
+// CHECK-LABEL: } // end sil function 'getAnotherType'
+@_silgen_name("getAnotherType")
+func getAnotherType<T, U>(_ object: inout T, to ty: U.Type) -> U {
+  Builtin.reinterpretCast(object)
+}