[AddressLowering] Handle unowned copies.

Lower the `strong_copy_unowned_value` and `unowned_copy_value` to
`load_unowned` and `store_unowned` respectively.

Author: nate-chandler

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -3483,6 +3483,14 @@ class UseRewriter : SILInstructionVisitor<UseRewriter> {
     pass.deleter.forceDelete(sei);
   }
 
+  void visitStrongCopyUnownedValueInst(StrongCopyUnownedValueInst *scuvi) {
+    auto sourceAddr = addrMat.materializeAddress(use->get());
+    SILValue value =
+        builder.createLoadUnowned(scuvi->getLoc(), sourceAddr, IsNotTake);
+    scuvi->replaceAllUsesWith(value);
+    pass.deleter.forceDelete(scuvi);
+  }
+
   void visitStrongCopyWeakValueInst(StrongCopyWeakValueInst *scwvi) {
     auto sourceAddr = addrMat.materializeAddress(use->get());
     SILValue value =
@@ -4103,6 +4111,15 @@ class DefRewriter : SILInstructionVisitor<DefRewriter> {
     rewriteUnconditionalCheckedCastInst(uncondCheckedCast, pass);
   }
 
+  void visitUnownedCopyValueInst(UnownedCopyValueInst *uci) {
+    auto &storage = pass.valueStorageMap.getStorage(uci);
+    auto destAddr = addrMat.recursivelyMaterializeStorage(
+        storage, /*intoPhiOperand=*/false);
+
+    builder.createStoreUnowned(uci->getLoc(), uci->getOperand(), destAddr,
+                               IsInitialization);
+  }
+
   void visitWeakCopyValueInst(WeakCopyValueInst *wcsvi) {
     auto &storage = pass.valueStorageMap.getStorage(wcsvi);
     auto destAddr = addrMat.recursivelyMaterializeStorage(

test/SILOptimizer/address_lowering.sil

@@ -2720,6 +2720,7 @@ bb0(%instance : @owned $T):
   %retval = tuple ()
   return %retval : $()
 }
+
 // CHECK-LABEL: sil [ossa] @test_yield_1_two_values : {{.*}} {
 // CHECK:         tuple_element_addr
 // CHECK:         tuple_element_addr

test/SILOptimizer/address_lowering_objc.sil

@@ -0,0 +1,40 @@
+// RUN: %target-sil-opt -address-lowering -enable-sil-opaque-values -emit-sorted-sil -module-name Swift -sil-verify-all %s | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Builtin
+
+typealias AnyObject = Builtin.AnyObject
+
+// The module name must be Swift so that declarations like Error are parsed as the correct loadable type.
+
+struct UnownedBox<T : AnyObject> {
+  unowned var value: T
+}
+
+// CHECK-LABEL: sil [ossa] @test_strong_copy_unowned_value : {{.*}} {
+// CHECK:       bb0([[INSTANCE_ADDR:%[^,]+]] :
+// CHECK:         [[FIELD_ADDR:%[^,]+]] = struct_element_addr [[INSTANCE_ADDR]]
+// CHECK:         [[OWNED_VALUE:%[^,]+]] = load_unowned [[FIELD_ADDR]]
+// CHECK:         return [[OWNED_VALUE]]
+// CHECK-LABEL: } // end sil function 'test_strong_copy_unowned_value'
+sil [ossa] @test_strong_copy_unowned_value : $@convention(thin) <T where T : AnyObject> (@in_guaranteed UnownedBox<T>) -> @owned T {
+bb0(%instance : @guaranteed $UnownedBox<T>):
+  %unowned_value = struct_extract %instance : $UnownedBox<T>, #UnownedBox.value
+  %owned_value = strong_copy_unowned_value %unowned_value : $@sil_unowned T
+  return %owned_value : $T
+}
+
+// CHECK-LABEL: sil [ossa] @test_unowned_copy_value : {{.*}} {
+// CHECK:       bb0([[INSTANCE_OUT:%[^,]+]] : {{.*}}, [[OWNED_VALUE:%[^,]+]] :
+// CHECK:         [[FIELD_ADDR:%[^,]+]] = struct_element_addr [[INSTANCE_OUT]]
+// CHECK:         store_unowned [[OWNED_VALUE]] to [init] [[FIELD_ADDR]]
+// CHECK:         destroy_value [[OWNED_VALUE]]
+// CHECK-LABEL: } // end sil function 'test_unowned_copy_value'
+sil [ossa] @test_unowned_copy_value : $@convention(thin) <T where T : AnyObject> (@owned T) -> @out UnownedBox<T> {
+bb0(%owned_value : @owned $T):
+  %unowned_value = unowned_copy_value %owned_value : $T
+  destroy_value %owned_value : $T
+  %instance = struct $UnownedBox<T> (%unowned_value : $@sil_unowned T)
+  return %instance : $UnownedBox<T>
+}