[AddressLowering] Addr'd some unconditional_casts.

All checked casts are emitted as unconditional_checked_cast
instructions.  More than just the instructions which produce or consume
an opaque value must be rewritten as unconditional_checked_cast_addr
instructions.  In particular, all those instructions for which
canIRGenUseScalarCheckedCastInstructions returns false must be rewritten
as unconditional_checked_cast_addr instructions.

Note the instructions to rewrite like that while visiting values and
then rewrite them near the end of rewriting.

Author: nate-chandler

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -419,6 +419,10 @@ struct AddressLoweringState {
   // parameters are rewritten.
   SmallBlotSetVector<FullApplySite, 16> indirectApplies;
 
+  // unconditional_checked_cast instructions of loadable type which need to be
+  // rewritten.
+  SmallVector<UnconditionalCheckedCastInst *, 2> nonopaqueResultUCCs;
+
   // All function-exiting terminators (return or throw instructions).
   SmallVector<TermInst *, 8> exitingInsts;
 
@@ -639,8 +643,18 @@ void OpaqueValueVisitor::checkForIndirectApply(FullApplySite applySite) {
 
 /// If `value` is address-only, add it to the `valueStorageMap`.
 void OpaqueValueVisitor::visitValue(SILValue value) {
-  if (!value->getType().isObject()
-      || !value->getType().isAddressOnly(*pass.function)) {
+  if (!value->getType().isObject())
+    return;
+  if (!value->getType().isAddressOnly(*pass.function)) {
+    if (auto *ucci = dyn_cast<UnconditionalCheckedCastInst>(value)) {
+      if (ucci->getSourceLoweredType().isAddressOnly(*pass.function))
+        return;
+      if (!canIRGenUseScalarCheckedCastInstructions(
+              pass.function->getModule(), ucci->getSourceFormalType(),
+              ucci->getTargetFormalType())) {
+        pass.nonopaqueResultUCCs.push_back(ucci);
+      }
+    }
     return;
   }
   if (pass.valueStorageMap.contains(value)) {
@@ -3354,6 +3368,39 @@ static void rewriteIndirectApply(FullApplySite apply,
   }
 }
 
+static void rewriteNonopaqueUnconditionalCheckedCast(
+    UnconditionalCheckedCastInst *uncondCheckedCast,
+    AddressLoweringState &pass) {
+  auto loc = uncondCheckedCast->getLoc();
+  SILValue srcVal = uncondCheckedCast->getOperand();
+  auto srcType = srcVal->getType();
+  auto destType = uncondCheckedCast->getType();
+  assert(srcType.isLoadable(*pass.function));
+  assert(!destType.isAddressOnly(*pass.function));
+
+  // Create a stack temporary to store the source
+  auto builder = pass.getBuilder(uncondCheckedCast->getIterator());
+  SILValue srcAddr = builder.createAllocStack(loc, srcType);
+  builder.createStore(loc, srcVal, srcAddr,
+                      srcType.isTrivial(*pass.function)
+                          ? StoreOwnershipQualifier::Trivial
+                          : StoreOwnershipQualifier::Init);
+  SILValue destAddr = builder.createAllocStack(loc, destType);
+  builder.createUnconditionalCheckedCastAddr(loc, srcAddr, srcType.getASTType(),
+                                             destAddr, destType.getASTType());
+
+  auto afterBuilder =
+      pass.getBuilder(uncondCheckedCast->getNextInstruction()->getIterator());
+  auto *load = afterBuilder.createLoad(loc, destAddr,
+                                       destType.isTrivial(*pass.function)
+                                           ? LoadOwnershipQualifier::Trivial
+                                           : LoadOwnershipQualifier::Take);
+  uncondCheckedCast->replaceAllUsesWith(load);
+  pass.deleter.forceDelete(uncondCheckedCast);
+  afterBuilder.createDeallocStack(loc, destAddr);
+  afterBuilder.createDeallocStack(loc, srcAddr);
+}
+
 static void rewriteFunction(AddressLoweringState &pass) {
   // During rewriting, storage references are stable.
   pass.valueStorageMap.setStable();
@@ -3402,6 +3449,10 @@ static void rewriteFunction(AddressLoweringState &pass) {
     }
   }
 
+  for (auto *ucci : pass.nonopaqueResultUCCs) {
+    rewriteNonopaqueUnconditionalCheckedCast(ucci, pass);
+  }
+
   // Rewrite this function's return value now that all opaque values within the
   // function are rewritten. This still depends on a valid ValueStorage
   // projection operands.

test/SILOptimizer/address_lowering.sil

@@ -1763,6 +1763,39 @@ bb0(%0 : @guaranteed $T):
   return %6 : $U
 }
 
+// Verify lowering of unconditional_checked_cast not involving address-only
+// values.
+// CHECK-LABEL: sil hidden [ossa] @test_unconditional_checked_cast4 : {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[SRC:%[^,]+]] :
+// CHECK:         [[SRC_ADDR:%[^,]+]] = alloc_stack $AnyObject
+// CHECK:         store [[SRC]] to [init] [[SRC_ADDR]] : $*AnyObject
+// CHECK:         [[DEST_ADDR:%[^,]+]] = alloc_stack $@thick any AnyObject.Type
+// CHECK:         unconditional_checked_cast_addr AnyObject in [[SRC_ADDR]] {{.*}} to @thick any AnyObject.Type in [[DEST_ADDR]]
+// CHECK:         load [trivial] [[DEST_ADDR]] : $*@thick any AnyObject.Type
+// CHECK-LABEL: } // end sil function 'test_unconditional_checked_cast4'
+sil hidden [ossa] @test_unconditional_checked_cast4 : $@convention(thin) (@owned AnyObject) -> () {
+entry(%instance : @owned $AnyObject):
+  %casted = unconditional_checked_cast %instance : $AnyObject to any AnyObject.Type
+  %retval = tuple ()
+  return %retval : $()
+}
+
+// Verify lowering of unconditional_checked_cast that involves address-only
+// values and also non-address-only values which on its own requires lowering
+// to unconditional_checked_cast_addr.
+// CHECK-LABEL: sil [ossa] @test_unconditional_checked_cast5 : {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[SRC_ADDR:%[^,]+]] :
+// CHECK:         [[DEST_ADDR:%[^,]+]] = alloc_stack $@thick any AnyObject.Type
+// CHECK:         unconditional_checked_cast_addr T in [[SRC_ADDR]] {{.*}} to @thick any AnyObject.Type in [[DEST_ADDR]]
+// CHECK:         load [trivial] [[DEST_ADDR]] : $*@thick any AnyObject.Type
+// CHECK-LABEL: } // end sil function 'test_unconditional_checked_cast5'
+sil [ossa] @test_unconditional_checked_cast5 : $@convention(thin) <T> (@in T) -> () {
+entry(%instance : @owned $T):
+  %casted = unconditional_checked_cast %instance : $T to any AnyObject.Type
+  %retval = tuple ()
+  return %retval : $()
+}
+
 // CHECK-LABEL: sil [ossa] @yield_two : {{.*}} {
 // CHECK:         tuple_element_addr
 // CHECK:         tuple_element_addr

test/SILOptimizer/opaque_values_Onone.swift

@@ -180,3 +180,35 @@ func give_a_generic_tuple<This>(of ty: This.Type) -> (This, This)
 func get_a_generic_tuple<This>(ty: This.Type) {
   let p = give_a_generic_tuple(of: ty)
 }
+
+// CHECK-LABEL: sil hidden @castAnyObjectToMeta {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[SRC:%[^,]+]] :
+// CHECK:         [[SRC_ADDR:%[^,]+]] = alloc_stack $AnyObject
+// CHECK:         store [[SRC]] to [[SRC_ADDR]]
+// CHECK:         [[DEST_ADDR:%[^,]+]] = alloc_stack $@thick any AnyObject.Type
+// CHECK:         unconditional_checked_cast_addr AnyObject in [[SRC_ADDR]] {{.*}} to @thick any AnyObject.Type in [[DEST_ADDR]]
+// CHECK:         [[DEST:%[^,]+]] = load [[DEST_ADDR]]
+// CHECK:         dealloc_stack [[DEST_ADDR]]
+// CHECK:         dealloc_stack [[SRC_ADDR]]
+// CHECK:         return [[DEST]]
+// CHECK-LABEL: } // end sil function 'castAnyObjectToMeta'
+@_silgen_name("castAnyObjectToMeta")
+func castAnyObjectToMeta(_ ao: any AnyObject) -> AnyObject.Type {
+  ao as! AnyObject.Type
+}
+
+// CHECK-LABEL: sil hidden @castGenericToMeta : {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[SRC:%[^,]+]] :
+// CHECK:         [[SRC_ADDR:%[^,]+]] = alloc_stack $T
+// CHECK:         copy_addr [[SRC]] to [init] [[SRC_ADDR]]
+// CHECK:         [[DEST_ADDR:%[^,]+]] = alloc_stack $@thick any AnyObject.Type
+// CHECK:         unconditional_checked_cast_addr T in [[SRC_ADDR]] {{.*}} to @thick any AnyObject.Type in [[DEST_ADDR]]
+// CHECK:         [[DEST:%[^,]+]] = load [[DEST_ADDR]]
+// CHECK:         dealloc_stack [[DEST_ADDR]]
+// CHECK:         dealloc_stack [[SRC_ADDR]]
+// CHECK:         return [[DEST]]
+// CHECK-LABEL: } // end sil function 'castGenericToMeta'
+@_silgen_name("castGenericToMeta")
+func castGenericToMeta<T>(_ t: T) -> AnyObject.Type {
+  t as! AnyObject.Type
+}