| // RUN: %target-sil-opt -enable-sil-verify-all -wmo -performance-constant-propagation -simplify-cfg -sil-combine -jumpthread-simplify-cfg -sil-combine -devirtualizer -generic-specializer %s | %FileCheck %s |
| // |
| // <rdar://problem/46322928> Failure to devirtualize a protocol method applied to an opened existential blocks implemention of |
| // DataProtocol. |
| sil_stage canonical |
| |
| import Builtin |
| import Swift |
| import SwiftShims |
| |
| public protocol HasFoo { |
| func foo() |
| } |
| |
| @inline(never) func testHasFoo<T>(_ t: T) |
| |
| struct S1<T> { |
| init(_: T) |
| } |
| |
| extension S1 : HasFoo where T == UInt8 { |
| func foo() |
| } |
| |
| // ConstantPropagation converts checked_cast_addr to unconditional_checked_cast_addr. |
| // SimplifyCFG removes the trivial branch. |
| // SILCombine replaces the unconditional_checked_cast_addr with init_existential_addr + copy_addr |
| // and simplifies the switch condition. |
| // JumpThreadSimplifyCFG eliminates the dead switch condition. |
| // SILCombine specializes the witness_method instruction to S1<UInt8>. |
| // Devirtualization replaces the witness invocation with a direct call. |
| // |
| // CHECK-LABEL: sil shared [noinline] @testSpecializedS1 : $@convention(thin) (S1<UInt8>) -> () { |
| // CHECK: bb0(%0 : $S1<UInt8>): |
| // CHECK: [[EXIS:%.*]] = alloc_stack $HasFoo |
| // CHECK: [[S1:%.*]] = alloc_stack $S1<UInt8> |
| // CHECK: store %0 to [[S1]] : $*S1<UInt8> |
| // CHECK: [[OPT:%.*]] = alloc_stack $Optional<HasFoo> |
| // CHECK: [[INIT_DATA:%.*]] = init_enum_data_addr [[OPT]] : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| // CHECK: [[EXIS_ADDR:%.*]] = init_existential_addr [[INIT_DATA]] : $*HasFoo, $S1<UInt8> |
| // CHECK: copy_addr [take] [[S1]] to [initialization] [[EXIS_ADDR]] : $*S1<UInt8> |
| // CHECK: inject_enum_addr [[OPT]] : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| // CHECK: [[DATA:%.*]] = unchecked_take_enum_data_addr [[OPT]] : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| // CHECK: copy_addr [take] [[DATA]] to [initialization] [[EXIS]] : $*HasFoo |
| // CHECK: [[OPEN_EXIS_ADDR:%.*]] = open_existential_addr immutable_access [[EXIS]] : $*HasFoo to $*@opened("4E16CBC0-FD9F-11E8-A311-D0817AD9F6DD") HasFoo |
| // CHECK: [[OPEN_ADDR:%.*]] = unchecked_addr_cast [[OPEN_EXIS_ADDR]] : $*@opened("4E16CBC0-FD9F-11E8-A311-D0817AD9F6DD") HasFoo to $*S1<UInt8> |
| // CHECK: [[F:%.*]] = function_ref @witnessS1 : $@convention(witness_method: HasFoo) (@in_guaranteed S1<UInt8>) -> () |
| // CHECK: apply [[F]]([[OPEN_ADDR]]) : $@convention(witness_method: HasFoo) (@in_guaranteed S1<UInt8>) -> () |
| // CHECK-LABEL: } // end sil function 'testSpecializedS1' |
| sil shared [noinline] @testSpecializedS1 : $@convention(thin) (S1<UInt8>) -> () { |
| bb0(%0 : $S1<UInt8>): |
| debug_value %0 : $S1<UInt8>, let, name "t", argno 1 |
| debug_value %0 : $S1<UInt8>, let, name "t", argno 1 |
| %3 = alloc_stack $HasFoo |
| %4 = alloc_stack $S1<UInt8> |
| store %0 to %4 : $*S1<UInt8> |
| %6 = alloc_stack $Optional<HasFoo> |
| %7 = init_enum_data_addr %6 : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| checked_cast_addr_br take_always S1<UInt8> in %4 : $*S1<UInt8> to HasFoo in %7 : $*HasFoo, bb1, bb2 |
| |
| bb1: |
| inject_enum_addr %6 : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| br bb3 |
| |
| bb2: |
| inject_enum_addr %6 : $*Optional<HasFoo>, #Optional.none!enumelt |
| br bb3 |
| |
| bb3: |
| switch_enum_addr %6 : $*Optional<HasFoo>, case #Optional.some!enumelt.1: bb4, case #Optional.none!enumelt: bb5 |
| |
| bb4: |
| %14 = unchecked_take_enum_data_addr %6 : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| copy_addr [take] %14 to [initialization] %3 : $*HasFoo |
| dealloc_stack %6 : $*Optional<HasFoo> |
| dealloc_stack %4 : $*S1<UInt8> |
| %18 = open_existential_addr immutable_access %3 : $*HasFoo to $*@opened("4E16CBC0-FD9F-11E8-A311-D0817AD9F6DD") HasFoo |
| %19 = witness_method $@opened("4E16CBC0-FD9F-11E8-A311-D0817AD9F6DD") HasFoo, #HasFoo.foo!1 : <Self where Self : HasFoo> (Self) -> () -> (), %18 : $*@opened("4E16CBC0-FD9F-11E8-A311-D0817AD9F6DD") HasFoo : $@convention(witness_method: HasFoo) <τ_0_0 where τ_0_0 : HasFoo> (@in_guaranteed τ_0_0) -> () |
| %20 = apply %19<@opened("4E16CBC0-FD9F-11E8-A311-D0817AD9F6DD") HasFoo>(%18) : $@convention(witness_method: HasFoo) <τ_0_0 where τ_0_0 : HasFoo> (@in_guaranteed τ_0_0) -> () |
| destroy_addr %3 : $*HasFoo |
| br bb6 |
| |
| bb5: |
| destroy_addr %6 : $*Optional<HasFoo> |
| dealloc_stack %6 : $*Optional<HasFoo> |
| dealloc_stack %4 : $*S1<UInt8> |
| br bb6 |
| |
| bb6: |
| dealloc_stack %3 : $*HasFoo |
| %28 = tuple () |
| return %28 : $() |
| } |
| |
| // CHECK-LABEL: sil shared [noinline] @testSpecializedS1Negative : $@convention(thin) (S1<Int8>) -> () { |
| // CHECK: bb0(%0 : $S1<Int8>): |
| // CHECK: [[EXIS:%.*]] = alloc_stack $HasFoo |
| // CHECK: [[VAL:%.*]] = alloc_stack $S1<Int8> |
| // CHECK: store %0 to [[VAL]] : $*S1<Int8> |
| // CHECK: [[OPT:%.*]] = alloc_stack $Optional<HasFoo> |
| // CHECK: [[IEDA:%.*]] = init_enum_data_addr [[OPT]] : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| // CHECK: checked_cast_addr_br take_always S1<Int8> in [[VAL]] : $*S1<Int8> to HasFoo in [[IEDA]] : $*HasFoo, bb1, bb2 |
| // bbs... |
| // CHECK: switch_enum_addr [[OPT]] : $*Optional<HasFoo>, case #Optional.some!enumelt.1: bb4, case #Optional.none!enumelt: bb5 |
| // bbs... |
| // CHECK: [[UNWRAP:%.*]] = unchecked_take_enum_data_addr [[OPT]] : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| // CHECK: copy_addr [take] [[UNWRAP]] to [initialization] [[EXIS]] : $*HasFoo |
| // CHECK: [[OPEN:%.*]] = open_existential_addr immutable_access [[EXIS]] : $*HasFoo to $*@opened("4E16CBC0-FD9F-11E8-A311-D0817AD9F6DD") HasFoo |
| // CHECK: [[WM:%.*]] = witness_method $@opened("4E16CBC0-FD9F-11E8-A311-D0817AD9F6DD") HasFoo, #HasFoo.foo!1 : <Self where Self : HasFoo> (Self) -> () -> (), [[OPEN]] : $*@opened("4E16CBC0-FD9F-11E8-A311-D0817AD9F6DD") HasFoo : $@convention(witness_method: HasFoo) <τ_0_0 where τ_0_0 : HasFoo> (@in_guaranteed τ_0_0) -> () |
| // CHECK: apply [[WM]]<@opened("4E16CBC0-FD9F-11E8-A311-D0817AD9F6DD") HasFoo>([[OPEN]]) : $@convention(witness_method: HasFoo) <τ_0_0 where τ_0_0 : HasFoo> (@in_guaranteed τ_0_0) -> () |
| // CHECK-LABEL: } // end sil function 'testSpecializedS1Negative' |
| sil shared [noinline] @testSpecializedS1Negative : $@convention(thin) (S1<Int8>) -> () { |
| bb0(%0 : $S1<Int8>): |
| debug_value %0 : $S1<Int8>, let, name "t", argno 1 |
| debug_value %0 : $S1<Int8>, let, name "t", argno 1 |
| %3 = alloc_stack $HasFoo |
| %4 = alloc_stack $S1<Int8> |
| store %0 to %4 : $*S1<Int8> |
| %6 = alloc_stack $Optional<HasFoo> |
| %7 = init_enum_data_addr %6 : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| checked_cast_addr_br take_always S1<Int8> in %4 : $*S1<Int8> to HasFoo in %7 : $*HasFoo, bb1, bb2 |
| |
| bb1: |
| inject_enum_addr %6 : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| br bb3 |
| |
| bb2: |
| inject_enum_addr %6 : $*Optional<HasFoo>, #Optional.none!enumelt |
| br bb3 |
| |
| bb3: |
| switch_enum_addr %6 : $*Optional<HasFoo>, case #Optional.some!enumelt.1: bb4, case #Optional.none!enumelt: bb5 |
| |
| bb4: |
| %14 = unchecked_take_enum_data_addr %6 : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| copy_addr [take] %14 to [initialization] %3 : $*HasFoo |
| dealloc_stack %6 : $*Optional<HasFoo> |
| dealloc_stack %4 : $*S1<Int8> |
| %18 = open_existential_addr immutable_access %3 : $*HasFoo to $*@opened("4E16CBC0-FD9F-11E8-A311-D0817AD9F6DD") HasFoo |
| %19 = witness_method $@opened("4E16CBC0-FD9F-11E8-A311-D0817AD9F6DD") HasFoo, #HasFoo.foo!1 : <Self where Self : HasFoo> (Self) -> () -> (), %18 : $*@opened("4E16CBC0-FD9F-11E8-A311-D0817AD9F6DD") HasFoo : $@convention(witness_method: HasFoo) <τ_0_0 where τ_0_0 : HasFoo> (@in_guaranteed τ_0_0) -> () |
| %20 = apply %19<@opened("4E16CBC0-FD9F-11E8-A311-D0817AD9F6DD") HasFoo>(%18) : $@convention(witness_method: HasFoo) <τ_0_0 where τ_0_0 : HasFoo> (@in_guaranteed τ_0_0) -> () |
| destroy_addr %3 : $*HasFoo |
| br bb6 |
| |
| bb5: |
| destroy_addr %6 : $*Optional<HasFoo> |
| dealloc_stack %6 : $*Optional<HasFoo> |
| dealloc_stack %4 : $*S1<Int8> |
| br bb6 |
| |
| bb6: |
| dealloc_stack %3 : $*HasFoo |
| %28 = tuple () |
| return %28 : $() |
| } |
| |
| struct S2<T> { |
| init(_: T) {} |
| } |
| |
| protocol P {} |
| |
| extension S2 : HasFoo where T : P { |
| func foo() {} |
| } |
| |
| struct IsP : P {} |
| |
| // CHECK-LABEL: sil shared [noinline] @testSpecializedS2 : $@convention(thin) (S2<IsP>) -> () { |
| // CHECK: bb0(%0 : $S2<IsP>): |
| // CHECK: [[EXIS:%.*]] = alloc_stack $HasFoo |
| // CHECK: [[S2:%.*]] = alloc_stack $S2<IsP> |
| // CHECK: store %0 to [[S2]] : $*S2<IsP> |
| // CHECK: [[OPT:%.*]] = alloc_stack $Optional<HasFoo> |
| // CHECK: [[INIT_DATA:%.*]] = init_enum_data_addr [[OPT]] : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| // CHECK: [[EXIS_ADDR:%.*]] = init_existential_addr [[INIT_DATA]] : $*HasFoo, $S2<IsP> |
| // CHECK: copy_addr [take] [[S2]] to [initialization] [[EXIS_ADDR]] : $*S2<IsP> |
| // CHECK: inject_enum_addr [[OPT]] : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| // CHECK: [[DATA:%.*]] = unchecked_take_enum_data_addr [[OPT]] : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| // CHECK: copy_addr [take] [[DATA]] to [initialization] [[EXIS]] : $*HasFoo |
| // CHECK: [[OPEN_EXIS_ADDR:%.*]] = open_existential_addr immutable_access [[EXIS]] : $*HasFoo to $*@opened("4E16D1CE-FD9F-11E8-A311-D0817AD9F6DD") HasFoo |
| // CHECK: [[OPEN_ADDR:%.*]] = unchecked_addr_cast [[OPEN_EXIS_ADDR]] : $*@opened("4E16D1CE-FD9F-11E8-A311-D0817AD9F6DD") HasFoo to $*S2<IsP> |
| // CHECK: [[F:%.*]] = function_ref @$s9witnessS24main3IsPV_Tg5 : $@convention(witness_method: HasFoo) (S2<IsP>) -> () |
| // CHECK: [[ARG:%.*]] = load [[OPEN_ADDR]] : $*S2<IsP> |
| // CHECK: apply [[F]]([[ARG]]) : $@convention(witness_method: HasFoo) (S2<IsP>) -> () |
| // CHECK-LABEL: } // end sil function 'testSpecializedS2' |
| sil shared [noinline] @testSpecializedS2 : $@convention(thin) (S2<IsP>) -> () { |
| bb0(%0 : $S2<IsP>): |
| debug_value %0 : $S2<IsP>, let, name "t", argno 1 |
| debug_value %0 : $S2<IsP>, let, name "t", argno 1 |
| %3 = alloc_stack $HasFoo |
| %4 = alloc_stack $S2<IsP> |
| store %0 to %4 : $*S2<IsP> |
| %6 = alloc_stack $Optional<HasFoo> |
| %7 = init_enum_data_addr %6 : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| checked_cast_addr_br take_always S2<IsP> in %4 : $*S2<IsP> to HasFoo in %7 : $*HasFoo, bb1, bb2 |
| |
| bb1: |
| inject_enum_addr %6 : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| br bb3 |
| |
| bb2: |
| inject_enum_addr %6 : $*Optional<HasFoo>, #Optional.none!enumelt |
| br bb3 |
| |
| bb3: |
| switch_enum_addr %6 : $*Optional<HasFoo>, case #Optional.some!enumelt.1: bb4, case #Optional.none!enumelt: bb5 |
| |
| bb4: |
| %14 = unchecked_take_enum_data_addr %6 : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| copy_addr [take] %14 to [initialization] %3 : $*HasFoo |
| dealloc_stack %6 : $*Optional<HasFoo> |
| dealloc_stack %4 : $*S2<IsP> |
| %18 = open_existential_addr immutable_access %3 : $*HasFoo to $*@opened("4E16D1CE-FD9F-11E8-A311-D0817AD9F6DD") HasFoo |
| %19 = witness_method $@opened("4E16D1CE-FD9F-11E8-A311-D0817AD9F6DD") HasFoo, #HasFoo.foo!1 : <Self where Self : HasFoo> (Self) -> () -> (), %18 : $*@opened("4E16D1CE-FD9F-11E8-A311-D0817AD9F6DD") HasFoo : $@convention(witness_method: HasFoo) <τ_0_0 where τ_0_0 : HasFoo> (@in_guaranteed τ_0_0) -> () |
| %20 = apply %19<@opened("4E16D1CE-FD9F-11E8-A311-D0817AD9F6DD") HasFoo>(%18) : $@convention(witness_method: HasFoo) <τ_0_0 where τ_0_0 : HasFoo> (@in_guaranteed τ_0_0) -> () |
| destroy_addr %3 : $*HasFoo |
| br bb6 |
| |
| bb5: |
| destroy_addr %6 : $*Optional<HasFoo> |
| dealloc_stack %6 : $*Optional<HasFoo> |
| dealloc_stack %4 : $*S2<IsP> |
| br bb6 |
| |
| bb6: |
| dealloc_stack %3 : $*HasFoo |
| %28 = tuple () |
| return %28 : $() |
| } |
| |
| class C { |
| init() {} |
| } |
| |
| struct S3<T> { |
| init(_: T) {} |
| } |
| |
| extension S3 : HasFoo where T : AnyObject { |
| func foo() {} |
| } |
| |
| // CHECK-LABEL: sil shared [noinline] @testSpecializedS3 : $@convention(thin) (S3<C>) -> () { |
| // CHECK: bb0(%0 : $S3<C>): |
| // CHECK: [[EXIS:%.*]] = alloc_stack $HasFoo |
| // CHECK: [[S3:%.*]] = alloc_stack $S3<C> |
| // CHECK: store %0 to [[S3]] : $*S3<C> |
| // CHECK: [[OPT:%.*]] = alloc_stack $Optional<HasFoo> |
| // CHECK: [[INIT_DATA:%.*]] = init_enum_data_addr [[OPT]] : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| // CHECK: [[EXIS_ADDR:%.*]] = init_existential_addr [[INIT_DATA]] : $*HasFoo, $S3<C> |
| // CHECK: copy_addr [take] [[S3]] to [initialization] [[EXIS_ADDR]] : $*S3<C> |
| // CHECK: inject_enum_addr [[OPT]] : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| // CHECK: [[DATA:%.*]] = unchecked_take_enum_data_addr [[OPT]] : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| // CHECK: copy_addr [take] [[DATA]] to [initialization] [[EXIS]] : $*HasFoo |
| // CHECK: [[OPEN_EXIS_ADDR:%.*]] = open_existential_addr immutable_access [[EXIS]] : $*HasFoo to $*@opened("4E16D5E8-FD9F-11E8-A311-D0817AD9F6DD") HasFoo |
| // CHECK: [[OPEN_ADDR:%.*]] = unchecked_addr_cast [[OPEN_EXIS_ADDR]] : $*@opened("4E16D5E8-FD9F-11E8-A311-D0817AD9F6DD") HasFoo to $*S3<C> |
| // CHECK: [[F:%.*]] = function_ref @$s9witnessS34main1CC_Tg5 : $@convention(witness_method: HasFoo) (S3<C>) -> () |
| // CHECK: [[ARG:%.*]] = load [[OPEN_ADDR]] : $*S3<C> |
| // CHECK: apply [[F]]([[ARG]]) : $@convention(witness_method: HasFoo) (S3<C>) -> () |
| // CHECK-LABEL: } // end sil function 'testSpecializedS3' |
| sil shared [noinline] @testSpecializedS3 : $@convention(thin) (S3<C>) -> () { |
| bb0(%0 : $S3<C>): |
| debug_value %0 : $S3<C>, let, name "t", argno 1 |
| debug_value %0 : $S3<C>, let, name "t", argno 1 |
| %3 = alloc_stack $HasFoo |
| %4 = alloc_stack $S3<C> |
| store %0 to %4 : $*S3<C> |
| %6 = alloc_stack $Optional<HasFoo> |
| %7 = init_enum_data_addr %6 : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| checked_cast_addr_br take_always S3<C> in %4 : $*S3<C> to HasFoo in %7 : $*HasFoo, bb1, bb2 |
| |
| bb1: |
| inject_enum_addr %6 : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| br bb3 |
| |
| bb2: |
| inject_enum_addr %6 : $*Optional<HasFoo>, #Optional.none!enumelt |
| br bb3 |
| |
| bb3: |
| switch_enum_addr %6 : $*Optional<HasFoo>, case #Optional.some!enumelt.1: bb4, case #Optional.none!enumelt: bb5 |
| |
| bb4: |
| %14 = unchecked_take_enum_data_addr %6 : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| copy_addr [take] %14 to [initialization] %3 : $*HasFoo |
| dealloc_stack %6 : $*Optional<HasFoo> |
| dealloc_stack %4 : $*S3<C> |
| %18 = open_existential_addr immutable_access %3 : $*HasFoo to $*@opened("4E16D5E8-FD9F-11E8-A311-D0817AD9F6DD") HasFoo |
| %19 = witness_method $@opened("4E16D5E8-FD9F-11E8-A311-D0817AD9F6DD") HasFoo, #HasFoo.foo!1 : <Self where Self : HasFoo> (Self) -> () -> (), %18 : $*@opened("4E16D5E8-FD9F-11E8-A311-D0817AD9F6DD") HasFoo : $@convention(witness_method: HasFoo) <τ_0_0 where τ_0_0 : HasFoo> (@in_guaranteed τ_0_0) -> () |
| %20 = apply %19<@opened("4E16D5E8-FD9F-11E8-A311-D0817AD9F6DD") HasFoo>(%18) : $@convention(witness_method: HasFoo) <τ_0_0 where τ_0_0 : HasFoo> (@in_guaranteed τ_0_0) -> () |
| destroy_addr %3 : $*HasFoo |
| br bb6 |
| |
| bb5: |
| destroy_addr %6 : $*Optional<HasFoo> |
| dealloc_stack %6 : $*Optional<HasFoo> |
| dealloc_stack %4 : $*S3<C> |
| br bb6 |
| |
| bb6: |
| dealloc_stack %3 : $*HasFoo |
| %28 = tuple () |
| return %28 : $() |
| } |
| |
| class SubC : C {} |
| |
| struct S4<T> { |
| init(_: T) {} |
| } |
| |
| extension S4 : HasFoo where T : C { |
| func foo() {} |
| } |
| |
| // CHECK-LABEL: sil shared [noinline] @testSpecializedS4 : $@convention(thin) (S4<SubC>) -> () { |
| // CHECK: bb0(%0 : $S4<SubC>): |
| // CHECK: [[EXIS:%.*]] = alloc_stack $HasFoo |
| // CHECK: [[S3:%.*]] = alloc_stack $S4<SubC> |
| // CHECK: store %0 to [[S3]] : $*S4<SubC> |
| // CHECK: [[OPT:%.*]] = alloc_stack $Optional<HasFoo> |
| // CHECK: [[INIT_DATA:%.*]] = init_enum_data_addr [[OPT]] : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| // CHECK: [[EXIS_ADDR:%.*]] = init_existential_addr [[INIT_DATA]] : $*HasFoo, $S4<SubC> |
| // CHECK: copy_addr [take] [[S3]] to [initialization] [[EXIS_ADDR]] : $*S4<SubC> |
| // CHECK: inject_enum_addr [[OPT]] : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| // CHECK: [[DATA:%.*]] = unchecked_take_enum_data_addr [[OPT]] : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| // CHECK: copy_addr [take] [[DATA]] to [initialization] [[EXIS]] : $*HasFoo |
| // CHECK: [[OPEN_EXIS_ADDR:%.*]] = open_existential_addr immutable_access [[EXIS]] : $*HasFoo to $*@opened("4E16E402-FD9F-11E8-A311-D0817AD9F6DD") HasFoo |
| // CHECK: [[OPEN_ADDR:%.*]] = unchecked_addr_cast [[OPEN_EXIS_ADDR]] : $*@opened("4E16E402-FD9F-11E8-A311-D0817AD9F6DD") HasFoo to $*S4<SubC> |
| // CHECK: [[F:%.*]] = function_ref @$s9witnessS44main4SubCC_Tg5 : $@convention(witness_method: HasFoo) (S4<SubC>) -> () |
| // CHECK: [[ARG:%.*]] = load [[OPEN_ADDR]] : $*S4<SubC> |
| // CHECK: apply [[F]]([[ARG]]) : $@convention(witness_method: HasFoo) (S4<SubC>) -> () |
| // CHECK: } // end sil function 'testSpecializedS4' |
| sil shared [noinline] @testSpecializedS4 : $@convention(thin) (S4<SubC>) -> () { |
| bb0(%0 : $S4<SubC>): |
| debug_value %0 : $S4<SubC>, let, name "t", argno 1 |
| debug_value %0 : $S4<SubC>, let, name "t", argno 1 |
| %3 = alloc_stack $HasFoo |
| %4 = alloc_stack $S4<SubC> |
| store %0 to %4 : $*S4<SubC> |
| %6 = alloc_stack $Optional<HasFoo> |
| %7 = init_enum_data_addr %6 : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| checked_cast_addr_br take_always S4<SubC> in %4 : $*S4<SubC> to HasFoo in %7 : $*HasFoo, bb1, bb2 |
| |
| bb1: |
| inject_enum_addr %6 : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| br bb3 |
| |
| bb2: |
| inject_enum_addr %6 : $*Optional<HasFoo>, #Optional.none!enumelt |
| br bb3 |
| |
| bb3: |
| switch_enum_addr %6 : $*Optional<HasFoo>, case #Optional.some!enumelt.1: bb4, case #Optional.none!enumelt: bb5 |
| |
| bb4: |
| %14 = unchecked_take_enum_data_addr %6 : $*Optional<HasFoo>, #Optional.some!enumelt.1 |
| copy_addr [take] %14 to [initialization] %3 : $*HasFoo |
| dealloc_stack %6 : $*Optional<HasFoo> |
| dealloc_stack %4 : $*S4<SubC> |
| %18 = open_existential_addr immutable_access %3 : $*HasFoo to $*@opened("4E16E402-FD9F-11E8-A311-D0817AD9F6DD") HasFoo |
| %19 = witness_method $@opened("4E16E402-FD9F-11E8-A311-D0817AD9F6DD") HasFoo, #HasFoo.foo!1 : <Self where Self : HasFoo> (Self) -> () -> (), %18 : $*@opened("4E16E402-FD9F-11E8-A311-D0817AD9F6DD") HasFoo : $@convention(witness_method: HasFoo) <τ_0_0 where τ_0_0 : HasFoo> (@in_guaranteed τ_0_0) -> () |
| %20 = apply %19<@opened("4E16E402-FD9F-11E8-A311-D0817AD9F6DD") HasFoo>(%18) : $@convention(witness_method: HasFoo) <τ_0_0 where τ_0_0 : HasFoo> (@in_guaranteed τ_0_0) -> () |
| destroy_addr %3 : $*HasFoo |
| br bb6 |
| |
| bb5: |
| destroy_addr %6 : $*Optional<HasFoo> |
| dealloc_stack %6 : $*Optional<HasFoo> |
| dealloc_stack %4 : $*S4<SubC> |
| br bb6 |
| |
| bb6: |
| dealloc_stack %3 : $*HasFoo |
| %28 = tuple () |
| return %28 : $() |
| } |
| |
| |
| sil private [transparent] [thunk] @witnessS1 : $@convention(witness_method: HasFoo) (@in_guaranteed S1<UInt8>) -> () { |
| bb0(%0 : $*S1<UInt8>): |
| %1 = tuple () |
| return %1 : $() |
| } |
| |
| |
| sil private [transparent] [thunk] @witnessS2 : $@convention(witness_method: HasFoo) <τ_0_0 where τ_0_0 : P> (@in_guaranteed S2<τ_0_0>) -> () { |
| bb0(%0 : $*S2<τ_0_0>): |
| %1 = tuple () |
| return %1 : $() |
| } |
| |
| sil private [transparent] [thunk] @witnessS3 : $@convention(witness_method: HasFoo) <τ_0_0 where τ_0_0 : AnyObject> (@in_guaranteed S3<τ_0_0>) -> () { |
| bb0(%0 : $*S3<τ_0_0>): |
| %1 = tuple () |
| return %1 : $() |
| } |
| |
| sil private [transparent] [thunk] @witnessS4 : $@convention(witness_method: HasFoo) <τ_0_0 where τ_0_0 : C> (@in_guaranteed S4<τ_0_0>) -> () { |
| bb0(%0 : $*S4<τ_0_0>): |
| %1 = tuple () |
| return %1 : $() |
| } |
| |
| sil_vtable C {} |
| |
| sil_vtable SubC {} |
| |
| sil_witness_table hidden <T where T == UInt8> S1<T>: HasFoo module tot { |
| method #HasFoo.foo!1: <Self where Self : HasFoo> (Self) -> () -> () : @witnessS1 |
| } |
| |
| sil_witness_table hidden <T where T : P> S2<T>: HasFoo module tot { |
| method #HasFoo.foo!1: <Self where Self : HasFoo> (Self) -> () -> () : @witnessS2 |
| conditional_conformance (T: P): dependent |
| } |
| |
| sil_witness_table hidden IsP: P module tot { |
| } |
| |
| sil_witness_table hidden <T where T : AnyObject> S3<T>: HasFoo module tot { |
| method #HasFoo.foo!1: <Self where Self : HasFoo> (Self) -> () -> () : @witnessS3 |
| } |
| |
| sil_witness_table hidden <T where T : C> S4<T>: HasFoo module tot { |
| method #HasFoo.foo!1: <Self where Self : HasFoo> (Self) -> () -> () : @witnessS4 |
| } |