Merge pull request #61924 from nate-chandler/opaque-values/2/20221103

[OpaqueValues] Handled more instructions.

Author: nate-chandler

lib/SILGen/SILGenEpilog.cpp

@@ -132,7 +132,7 @@ static SILValue buildReturnValue(SILGenFunction &SGF, SILLocation loc,
 
   auto fnConv = SGF.F.getConventions();
   if (!fnConv.useLoweredAddresses()) {
-    // In opaque-values code, nested @out enums are not flattened.  Reconstruct
+    // In opaque-values code, nested @out tuples are not flattened.  Reconstruct
     // nested tuples.
     auto resultType = SGF.F.getLoweredType(SGF.F.mapTypeIntoContext(
         fnConv.getSILResultType(SGF.getTypeExpansionContext())));

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -2618,6 +2618,11 @@ class UseRewriter : SILInstructionVisitor<UseRewriter> {
     vmi->setOperand(opAddr);
   }
 
+  void visitExistentialMetatypeInst(ExistentialMetatypeInst *emi) {
+    SILValue opAddr = addrMat.materializeAddress(use->get());
+    emi->setOperand(opAddr);
+  }
+
   void visitAddressOfBorrowBuiltinInst(BuiltinInst *bi, bool stackProtected) {
     SILValue value = bi->getOperand(0);
     SILValue addr = pass.valueStorageMap.getStorage(value).storageAddress;
@@ -2746,6 +2751,21 @@ class UseRewriter : SILInstructionVisitor<UseRewriter> {
 
   void emitExtract(SingleValueInstruction *extractInst);
 
+  void visitSelectEnumInst(SelectEnumInst *sei) {
+    SmallVector<std::pair<EnumElementDecl *, SILValue>> caseValues;
+    for (unsigned index = 0, count = sei->getNumCases(); index < count;
+         ++index) {
+      caseValues.push_back(sei->getCase(index));
+    }
+
+    SILValue opAddr = addrMat.materializeAddress(use->get());
+    SILValue addr =
+        builder.createSelectEnumAddr(sei->getLoc(), opAddr, sei->getType(),
+                                     sei->getDefaultResult(), caseValues);
+    sei->replaceAllUsesWith(addr);
+    pass.deleter.forceDelete(sei);
+  }
+
   // Extract from an opaque struct.
   void visitStructExtractInst(StructExtractInst *extractInst);
 
@@ -2776,7 +2796,26 @@ 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);
+        return;
+      }
+    }
+    SILValue load =
+        builder.emitLoadBorrowOperation(uncheckedCastInst->getLoc(), destAddr);
+    uncheckedCastInst->replaceAllUsesWith(load);
+    pass.deleter.forceDelete(uncheckedCastInst);
+    emitEndBorrows(load);
   }
 
   void visitUnconditionalCheckedCastInst(

test/SILOptimizer/address_lowering.sil

@@ -1340,6 +1340,23 @@ exit_error(%47 : @owned $any Error):
   throw %47 : $any Error
 }
 
+// CHECK-LABEL: sil [ossa] @selecteroo : $@convention(thin) <T> () -> () {
+// CHECK:         [[ADDR:%[^,]+]] = alloc_stack $Optional<T>
+// CHECK:         apply undef<T>([[ADDR]]) : $@convention(thin) <τ_0_0> () -> @out Optional<τ_0_0>
+// CHECK:         select_enum_addr [[ADDR]] : $*Optional<T>, case #Optional.some!enumelt: {{%[^,]+}}, default {{%[^,]+}} : $Builtin.Int1
+// CHECK:         dealloc_stack [[ADDR]] : $*Optional<T>
+// CHECK-LABEL: } // end sil function 'selecteroo'
+sil [ossa] @selecteroo : $@convention(thin) <T> () -> () {
+bb0:
+  %11 = apply undef<T>() : $@convention(thin) <τ_0_0> () -> @out Optional<τ_0_0>
+  %12 = integer_literal $Builtin.Int1, -1
+  %13 = integer_literal $Builtin.Int1, 0
+  %14 = select_enum %11 : $Optional<T>, case #Optional.some!enumelt: %12, default %13 : $Builtin.Int1
+  destroy_value %11 : $Optional<T>
+  %retval = tuple ()
+  return %retval : $()
+} // end sil function '$ss17FixedWidthIntegerPsEyxSgSScfC'
+
 sil hidden [ossa] @testBeginApplyDeadYield : $@convention(thin) <T> (@guaranteed TestGeneric<T>) -> () {
 bb0(%0 : @guaranteed $TestGeneric<T>):
   %2 = class_method %0 : $TestGeneric<T>, #TestGeneric.borrowedGeneric!read : <T> (TestGeneric<T>) -> () -> (), $@yield_once @convention(method) <τ_0_0> (@guaranteed TestGeneric<τ_0_0>) -> @yields @in_guaranteed τ_0_0
@@ -1554,6 +1571,53 @@ bb0(%0 : @guaranteed $T, %1 : $@thick U.Type):
   return %6 : $U
 }
 
+// There's only one use and it's a copy, just rewrite it as a load [copy].
+// CHECK-LABEL: sil hidden [ossa] @test_unchecked_bitwise_cast_to_loadable :
+// CHECK:       {{bb[0-9]+}}([[ADDR_IN:%[^,]+]] : $*T):
+// CHECK:         [[STACK:%[^,]+]] = alloc_stack $T
+// CHECK:         copy_addr [[ADDR_IN]] to [init] [[STACK]]
+// CHECK:         [[STACK_AS_CLASS:%[^,]+]] = unchecked_addr_cast [[STACK]] : $*T to $*Klass
+// CHECK:         [[KLASS:%[^,]+]] = load [copy] [[STACK_AS_CLASS]]
+// CHECK:         destroy_addr [[STACK]]
+// CHECK:         dealloc_stack [[STACK]]
+// CHECK:         return [[KLASS]]
+// CHECK-LABEL: } // end sil function 'test_unchecked_bitwise_cast_to_loadable'
+sil hidden [ossa] @test_unchecked_bitwise_cast_to_loadable : $@convention(thin) <T> (@in_guaranteed T) -> @owned Klass {
+bb0(%instance : @guaranteed $T):
+  %copy = copy_value %instance : $T
+  %unowned_klass = unchecked_bitwise_cast %copy : $T to $Klass
+  %klass = copy_value %unowned_klass : $Klass
+  destroy_value %copy : $T
+  return %klass : $Klass
+}
+
+// There is more than one use of the unchecked_addr_cast.  The value should be
+// load_borrow'd and uses of the original should be uses of that load.
+// CHECK-LABEL: sil hidden [ossa] @test_unchecked_bitwise_cast_to_loadable_multiuse : {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[INSTANCE:%[^,]+]] : $*T):
+// CHECK:         [[STACK:%[^,]+]] = alloc_stack $T
+// CHECK:         copy_addr [[INSTANCE]] to [init] [[STACK]]
+// CHECK:         [[STACK_AS_CLASS:%[^,]+]] = unchecked_addr_cast [[STACK]] : $*T to $*Klass
+// CHECK:         [[BORROWED_KLASS:%[^,]+]] = load_borrow [[STACK_AS_CLASS]]
+// CHECK:         [[KLASS_TO_RETURN:%[^,]+]] = copy_value [[BORROWED_KLASS]]
+// CHECK:         [[KLASS_TO_DESTROY:%[^,]+]] = copy_value [[BORROWED_KLASS]]
+// CHECK:         end_borrow [[BORROWED_KLASS]]
+// CHECK:         destroy_value [[KLASS_TO_DESTROY]]
+// CHECK:         destroy_addr [[STACK]]
+// CHECK:         dealloc_stack [[STACK]]
+// CHECK:         return [[KLASS_TO_RETURN]]
+// CHECK-LABEL: } // end sil function 'test_unchecked_bitwise_cast_to_loadable_multiuse'
+sil hidden [ossa] @test_unchecked_bitwise_cast_to_loadable_multiuse : $@convention(thin) <T> (@in_guaranteed T) -> @owned Klass {
+bb0(%instance : @guaranteed $T):
+  %copy = copy_value %instance : $T
+  %unowned_klass = unchecked_bitwise_cast %copy : $T to $Klass
+  %klass = copy_value %unowned_klass : $Klass
+  %klass2 = copy_value %unowned_klass : $Klass
+  destroy_value %klass2 : $Klass
+  destroy_value %copy : $T
+  return %klass : $Klass
+}
+
 // CHECK-LABEL: sil hidden [ossa] @test_unconditional_checked_cast1 : $@convention(thin) <T> (Builtin.Int64) -> @out T {
 // CHECK: bb0(%0 : $*T, %1 : $Builtin.Int64):
 // CHECK:   [[INT:%.*]] = alloc_stack $Builtin.Int64

test/SILOptimizer/opaque_values_Onone_stdlib.swift

@@ -1,10 +1,32 @@
-// RUN: %target-swift-frontend -parse-stdlib -enable-experimental-move-only -module-name main -enable-sil-opaque-values -parse-as-library -emit-sil -Onone %s | %FileCheck %s
+// RUN: %target-swift-frontend -parse-stdlib -enable-experimental-move-only -module-name Swift -enable-sil-opaque-values -parse-as-library -emit-sil -Onone %s | %FileCheck %s
 
 // Like opaque_values_Onone.swift but for code that needs to be compiled with 
 // -parse-stdlib.
 
-class X {}
+precedencegroup AssignmentPrecedence { assignment: true }
+precedencegroup CastingPrecedence {}
+
+public protocol _ObjectiveCBridgeable {}
 
+public protocol _ExpressibleByBuiltinBooleanLiteral {
+  init(_builtinBooleanLiteral value: Builtin.Int1)
+}
+struct Bool : _ExpressibleByBuiltinBooleanLiteral {
+  var _value: Builtin.Int1
+  @_silgen_name("Bool_init_noargs")
+  init()
+  init(_ v: Builtin.Int1) { self._value = v }
+  init(_ value: Bool) { self = value }
+  init(_builtinBooleanLiteral value: Builtin.Int1) {
+    self._value = value
+  }
+}
+
+@_silgen_name("typeof")
+@_semantics("typechecker.type(of:)")
+public func type<T, Metatype>(of value: T) -> Metatype
+
+class X {}
 func consume(_ x : __owned X) {}
 
 func foo(@_noImplicitCopy _ x: __owned X) {
@@ -50,3 +72,28 @@ 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)
+}
+
+@_silgen_name("isOfTypeOfAnyObjectType")
+func isOfTypeOfAnyObjectType(fromAny any: Any) -> Bool {
+  type(of: any) is Builtin.AnyObject.Type
+}