mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
ae9f2e25ae
Enable SIL parsing and SIL serialization of semantics. We add one more field to SILFunctionLayout for semantics. We should refactor handling of attributes at SIL level, right now they are in SILFunction as bool or std::string and in SIL serializer as a 1-bit field or an ID field. rdar://17525564 Swift SVN r19434
1220 lines
47 KiB
Plaintext
1220 lines
47 KiB
Plaintext
sil_stage raw // CHECK: sil_stage raw
|
|
|
|
import Builtin
|
|
import Swift
|
|
import Foundation
|
|
|
|
// Test SIL Global variable.
|
|
// CHECK-NOT: sil_global private @globalinit_token0 : $Builtin.Word
|
|
sil_global private @globalinit_token0 : $Builtin.Word
|
|
|
|
// CHECK-NOT: sil_global public @public_global : $Builtin.Word
|
|
sil_global public @public_global : $Builtin.Word
|
|
|
|
var staticProp: Int = 0
|
|
sil @globalinit_func0 : $@thin () -> ()
|
|
|
|
// We should not serialize this since it references the private variable globalinit_token0.
|
|
// CHECK-NOT: sil public_external @_TFV18lazy_global_access4Type10staticPropSia : $@thin () -> Builtin.RawPointer {
|
|
sil @_TFV18lazy_global_access4Type10staticPropSia : $@thin () -> Builtin.RawPointer {
|
|
bb0:
|
|
%0 = builtin_function_ref "once" : $@thin (Builtin.RawPointer, @owned @callee_owned () -> ()) -> ()
|
|
%1 = sil_global_addr @globalinit_token0 : $*Builtin.Word
|
|
%2 = address_to_pointer %1 : $*Builtin.Word to $Builtin.RawPointer
|
|
%3 = function_ref @globalinit_func0 : $@thin () -> ()
|
|
%4 = thin_to_thick_function %3 : $@thin () -> () to $@callee_owned () -> ()
|
|
%5 = apply %0(%2, %4) : $@thin (Builtin.RawPointer, @owned @callee_owned () -> ()) -> ()
|
|
%6 = global_addr #staticProp : $*Int
|
|
%7 = address_to_pointer %6 : $*Int to $Builtin.RawPointer
|
|
return %7 : $Builtin.RawPointer
|
|
}
|
|
|
|
// This references a public global so we *SHOULD* derserialize this.
|
|
// CHECK-LABEL: sil public_external @_TFV18lazy_global_access4Type10staticPropSia_public : $@thin () -> Builtin.RawPointer {
|
|
sil @_TFV18lazy_global_access4Type10staticPropSia_public : $@thin () -> Builtin.RawPointer {
|
|
bb0:
|
|
%0 = builtin_function_ref "once" : $@thin (Builtin.RawPointer, @owned @callee_owned () -> ()) -> ()
|
|
// CHECK: sil_global_addr @public_global : $*Builtin.Word
|
|
%1 = sil_global_addr @public_global : $*Builtin.Word
|
|
// CHECK: unchecked_addr_cast {{%.*}} : $*Builtin.Word to $*Builtin.RawPointer
|
|
%a = unchecked_addr_cast %1 : $*Builtin.Word to $*Builtin.RawPointer
|
|
%2 = address_to_pointer %a : $*Builtin.RawPointer to $Builtin.RawPointer
|
|
%3 = function_ref @globalinit_func0 : $@thin () -> ()
|
|
%4 = thin_to_thick_function %3 : $@thin () -> () to $@callee_owned () -> ()
|
|
%5 = apply %0(%2, %4) : $@thin (Builtin.RawPointer, @owned @callee_owned () -> ()) -> ()
|
|
%6 = global_addr #staticProp : $*Int
|
|
%7 = address_to_pointer %6 : $*Int to $Builtin.RawPointer
|
|
return %7 : $Builtin.RawPointer
|
|
}
|
|
|
|
// Type references
|
|
|
|
// Some cyclic type references between SIL function bodies.
|
|
class Class1 {
|
|
var a : Class2
|
|
init()
|
|
}
|
|
class Class2 {
|
|
var b : Class1
|
|
init()
|
|
}
|
|
|
|
// Instructions
|
|
|
|
// CHECK-LABEL: sil public_external @test1 : $@thin () -> ()
|
|
sil @test1 : $@thin () -> () {
|
|
bb0: // CHECK: bb0:
|
|
%0 = tuple () // CHECK: %0 = tuple ()
|
|
br bb1 // CHECK: br bb1
|
|
bb1:
|
|
%b = alloc_box $Int
|
|
%c = integer_literal $Builtin.Word, 1
|
|
// CHECK: alloc_array $String, %{{.*}} : $Builtin.Word
|
|
%d = alloc_array $String, %c : $Builtin.Word
|
|
return %0 : $() // CHECK: return %0 : $()
|
|
}
|
|
|
|
// Forward referenced values.
|
|
// CHECK-LABEL: sil public_external @test2 : $@thin (Int) -> ()
|
|
sil @test2 : $@thin (Int) -> () {
|
|
// CHECK: bb1:
|
|
// CHECK: %2 = tuple ()
|
|
// CHECK: br bb2
|
|
// CHECK: bb2:
|
|
// FIXME: should be %2
|
|
// CHECK: return %{{.*}} : $()
|
|
bb0(%0 : $Int):
|
|
br bb2
|
|
bb1:
|
|
// Forward reference MRVs.
|
|
store %0 to %6#1 : $*Int
|
|
strong_release %6#0 : $Builtin.NativeObject
|
|
|
|
return %5 : $()
|
|
bb2:
|
|
%5 = tuple ()
|
|
%6 = alloc_box $Int
|
|
br bb1
|
|
}
|
|
|
|
// CHECK-LABEL: @named_tuple : $@thin () -> (Builtin.Word, Builtin.Word)
|
|
sil @named_tuple : $@thin () -> (Builtin.Word, Builtin.Word) {
|
|
%0 = integer_literal $Builtin.Word, 42
|
|
// CHECK: integer_literal $Builtin.Word, 42
|
|
%9 = tuple $(Builtin.Word, Builtin.Word) (%0, %0)
|
|
%10 = return %9 : $(Builtin.Word, Builtin.Word)
|
|
}
|
|
|
|
sil @return_int : $@thin (Int) -> Int { // CHECK-LABEL: $@thin (Int) -> Int {
|
|
bb0(%0 : $Int): // CHECK: bb0(%0 : $Int):
|
|
// CHECK: alloc_stack $Int
|
|
// CHECK: store
|
|
%1 = alloc_stack $Int
|
|
store %0 to %1#1 : $*Int
|
|
%3 = load %1#1 : $*Int
|
|
dealloc_stack %1#0 : $*@local_storage Int
|
|
return %3 : $Int // CHECK: return {{.*}} : $Int
|
|
}
|
|
|
|
// CHECK-LABEL: @call_fn_pointer : $@thin (() -> Int) -> Int {
|
|
sil @call_fn_pointer : $@thin (() -> Int) -> Int {
|
|
bb0(%0 : $() -> Int):
|
|
%1 = alloc_stack $() -> Int
|
|
store %0 to %1#1 : $*() -> Int
|
|
%3 = load %1#1 : $*() -> Int
|
|
strong_retain %3 : $() -> Int
|
|
// CHECK: strong_retain %{{.*}} : $() -> Int
|
|
%5 = apply %3() : $() -> Int
|
|
// CHECK: apply %{{.*}}() : $() -> Int
|
|
%6 = load %1#1 : $*() -> Int
|
|
strong_release %3 : $() -> Int
|
|
// CHECK: strong_release {{.*}} : $() -> Int
|
|
dealloc_stack %1#0 : $*@local_storage () -> Int
|
|
return %5 : $Int // CHECK: return %{{.*}} : $Int
|
|
}
|
|
|
|
sil @return_constant : $@thin () -> Int { // CHECK-LABEL: @return_constant
|
|
bb0: // CHECK: bb0:
|
|
// CHECK: function_ref @_TFSi25convertFromIntegerLiteralfMSiFT3valBi64__Si : $@thin (Builtin.Word, @thin Int.Type) -> Int
|
|
%1 = function_ref @_TFSi25convertFromIntegerLiteralfMSiFT3valBi64__Si : $@thin (Builtin.Word, @thin Int.Type) -> Int
|
|
|
|
// CHECK: metatype $@thin Int.Type
|
|
%2 = metatype $@thin Int.Type
|
|
|
|
// CHECK: integer_literal $Builtin.Word, 1
|
|
%3 = integer_literal $Builtin.Word, 1
|
|
|
|
// CHECK: apply
|
|
%4 = apply %1(%3, %2) : $@thin (Builtin.Word, @thin Int.Type) -> Int
|
|
// CHECK: return
|
|
%5 = return %4 : $Int
|
|
}
|
|
|
|
sil @_TFSi25convertFromIntegerLiteralfMSiFT3valBi64__Si : $@thin (Builtin.Word, @thin Int.Type) -> Int
|
|
|
|
// Parse SIL generated from the following swift program:
|
|
// func x(a : Bool) -> Int { if a { return 4 } else {return 5} }
|
|
sil @_TFSb13getLogicValuefRSbFT_Bi1_ : $@cc(method) @thin (@inout Bool) -> Builtin.Int1
|
|
sil @_TFSi33_convertFromBuiltinIntegerLiteralfMSiFT3valBi128__Si : $@thin (Builtin.Int128, @thin Int.Type) -> Int
|
|
|
|
|
|
protocol P {
|
|
func doIt()
|
|
}
|
|
|
|
// CHECK-LABEL: @existentials : $@thin (@in P) -> () {
|
|
sil @existentials : $@thin (@in P) -> () {
|
|
bb0(%0 : $*P):
|
|
%1 = project_existential %0 : $*P to $*@sil_self P // CHECK: project_existential %0
|
|
|
|
// CHECK: protocol_method {{.*}} : $*P, #P.doIt!1
|
|
%2 = protocol_method %0 : $*P, #P.doIt!1 : <Self : P> inout Self -> () -> (), $@cc(witness_method) (@inout @sil_self P) -> ()
|
|
// CHECK: apply
|
|
%3 = apply %2(%1) : $@cc(witness_method) (@inout @sil_self P) -> ()
|
|
%4 = tuple () // CHECK: tuple ()
|
|
%5 = destroy_addr %0 : $*P // CHECK: destroy_addr %0 : $*P
|
|
%6 = return %4 : $() // CHECK: return
|
|
}
|
|
|
|
|
|
class C {
|
|
func doIt() {}
|
|
}
|
|
|
|
class D : C {
|
|
override func doIt() {
|
|
super.doIt()
|
|
}
|
|
}
|
|
|
|
// CHECK-LABEL: @classes : $@thin () -> () {
|
|
sil @classes : $@thin () -> () {
|
|
bb0:
|
|
// CHECK: %0 = alloc_ref $C
|
|
%C = alloc_ref $C
|
|
// CHECK: unchecked_ref_cast %0 : $C to $Builtin.NativeObject
|
|
%1 = unchecked_ref_cast %C : $C to $Builtin.NativeObject
|
|
// CHECK: unchecked_ref_cast %0 : $C to $Builtin.UnknownObject
|
|
%O = unchecked_ref_cast %C : $C to $Builtin.UnknownObject
|
|
|
|
// CHECK: class_method {{.*}} : $C, #C.doIt!1
|
|
%2 = class_method %C : $C, #C.doIt!1 : C -> () -> (), $@cc(method) @thin (@owned C) -> ()
|
|
|
|
// CHECK: alloc_ref $D
|
|
%D = alloc_ref $D
|
|
|
|
// CHECK: upcast {{.*}} : $D to $C
|
|
%a = upcast %D : $D to $C
|
|
|
|
// CHECK: unconditional_checked_cast {{.*}} : $C to $D
|
|
%5 = unconditional_checked_cast %C : $C to $D
|
|
%6 = tuple ()
|
|
%7 = return %6 : $()
|
|
}
|
|
|
|
// Generated from:
|
|
// func archetype_member_ref<T : Runcible>(x: T) {
|
|
// x.free_method()
|
|
// var u = x.associated_method()
|
|
// T.static_method()
|
|
// }
|
|
|
|
protocol Runcible {
|
|
var free:Int { get }
|
|
|
|
func free_method() -> Int
|
|
class func static_method()
|
|
}
|
|
|
|
//sil @_TF4arch20archetype_member_refUS_8Runcible___FT1xQ__T_ : $@thin <T : Runcible> (T) -> () {
|
|
//bb0(%0 : $*T):
|
|
//%1 = witness_method $*T, #Runcible.free_method!1 : $@cc(method) (@inout T) -> Int
|
|
//%2 = apply %1(%0) : $@cc(method) ((), @inout T) -> Int
|
|
//%3 = alloc_stack $@thick T.U.Type
|
|
//%4 = witness_method $*T, #Runcible.associated_method!1 : $@cc(method) (@inout T) -> @thick T.U.Type
|
|
//%5 = apply %4(%0) : $@cc(method) ((), @inout T) -> @thick T.U.Type
|
|
//%6 = store %5 to %3#1 : $*@thick T.U.Type
|
|
//%7 = metatype $@thick T.Type
|
|
//%8 = witness_method [volatile] $*T, #Runcible.static_method!1 : $(@thick T.Type) -> ()
|
|
//%9 = apply %8(%7) : $((), @thick T.Type) -> ()
|
|
//%10 = dealloc_stack %3#0 : $*@local_storage @thick T.U.Type
|
|
//%11 = tuple ()
|
|
//%12 = destroy_addr %0 : $*T
|
|
//%13 = return %11 : $()
|
|
//}
|
|
|
|
protocol Bendable { }
|
|
|
|
// CHECK-LABEL: $@thin (@out Runcible, @in protocol<Bendable, Runcible>) -> ()
|
|
sil @_TF4todo18erasure_from_protoFT1xPS_8RuncibleS_8Bendable__PS0__ : $@thin (@out Runcible, @in protocol<Bendable, Runcible>) -> () {
|
|
bb0(%0 : $*Runcible, %1 : $*protocol<Bendable, Runcible>):
|
|
// CHECK: alloc_box
|
|
%2 = alloc_box $protocol<Bendable, Runcible>
|
|
// CHECK: copy_addr [take] {{.*}} to [initialization] {{.*}} : $*protocol<Bendable, Runcible>
|
|
%3 = copy_addr [take] %1 to [initialization] %2#1 : $*protocol<Bendable, Runcible>
|
|
// CHECK: alloc_stack
|
|
%4 = alloc_stack $protocol<Bendable, Runcible>
|
|
// CHECK: copy_addr {{.*}} to [initialization] {{.*}} : $*protocol<Bendable, Runcible>
|
|
%5 = copy_addr %2#1 to [initialization] %4#1 : $*protocol<Bendable, Runcible>
|
|
// CHECK: upcast_existential [take] {{.*}} : $*protocol<Bendable, Runcible> to {{.*}} : $*Runcible
|
|
%6 = upcast_existential [take] %4#1 : $*protocol<Bendable, Runcible> to %0 : $*Runcible
|
|
%7 = tuple ()
|
|
// CHECK: destroy_addr
|
|
%8 = destroy_addr %4#1 : $*protocol<Bendable, Runcible>
|
|
// CHECK: dealloc_stack
|
|
%9 = dealloc_stack %4#0 : $*@local_storage protocol<Bendable, Runcible>
|
|
%10 = strong_release %2#0 : $Builtin.NativeObject
|
|
// CHECK: return
|
|
%11 = return %7 : $()
|
|
}
|
|
|
|
@class_protocol protocol ClassBound {
|
|
func classBoundMethod()
|
|
}
|
|
|
|
// CHECK-LABEL: @_TF4todo18class_bound_methodFT1xPS_10ClassBound__T_ : $@thin (@owned ClassBound) -> ()
|
|
sil @_TF4todo18class_bound_methodFT1xPS_10ClassBound__T_ : $@thin (@owned ClassBound) -> () {
|
|
bb0(%0 : $ClassBound):
|
|
%1 = alloc_box $ClassBound
|
|
%2 = store %0 to %1#1 : $*ClassBound
|
|
%3 = load %1#1 : $*ClassBound
|
|
%4 = strong_retain %3 : $ClassBound // CHECK: strong_retain
|
|
// CHECK: project_existential_ref {{%.*}} : $ClassBound to $@sil_self ClassBound
|
|
%5 = project_existential_ref %3 : $ClassBound to $@sil_self ClassBound
|
|
// CHECK: protocol_method
|
|
%6 = protocol_method %3 : $ClassBound, #ClassBound.classBoundMethod!1 : <Self : ClassBound> Self -> () -> (), $@cc(witness_method) (@sil_self ClassBound) -> ()
|
|
%7 = apply %6(%5) : $@cc(witness_method) (@sil_self ClassBound) -> ()
|
|
%8 = tuple ()
|
|
%9 = strong_release %1#0 : $Builtin.NativeObject
|
|
%10 = return %8 : $()
|
|
}
|
|
|
|
struct Val {
|
|
}
|
|
|
|
//sil @_TFV4todo3ValCfMS0_FT_S0_ : $@thin (@thin Val.Type) -> Val {
|
|
//bb0(%0 : $@thin Val.Type):
|
|
//%1 = alloc_stack $Val
|
|
//%3 = load %1#1 : $*Val
|
|
//%4 = return %3 : $Val
|
|
//}
|
|
|
|
class Ref {
|
|
}
|
|
struct Aleph {
|
|
var a:Ref
|
|
var b:Val
|
|
}
|
|
|
|
// CHECK-LABEL: @_TFV6struct5AlephCfMS0_FT1aCS_3Ref1bVS_3Val_S0_ : $@thin (Ref, Val, @thin Aleph.Type) -> Aleph
|
|
sil @_TFV6struct5AlephCfMS0_FT1aCS_3Ref1bVS_3Val_S0_ : $@thin (Ref, Val, @thin Aleph.Type) -> Aleph {
|
|
bb0(%0 : $Ref, %1 : $Val, %2 : $@thin Aleph.Type):
|
|
// CHECK: struct $Aleph ({{%.*}} : $Ref, {{%.*}} : $Val)
|
|
%3 = struct $Aleph (%0 : $Ref, %1 : $Val)
|
|
%4 = return %3 : $Aleph // CHECK: return
|
|
}
|
|
|
|
// CHECK-LABEL: @_TFV6struct5AlephCfMS0_FT_S0_ : $@thin (@thin Aleph.Type) -> Aleph
|
|
sil @_TFV6struct5AlephCfMS0_FT_S0_ : $@thin (@thin Aleph.Type) -> Aleph {
|
|
bb0(%0 : $@thin Aleph.Type):
|
|
%1 = tuple ()
|
|
%2 = alloc_box $Aleph // CHECK: alloc_box
|
|
// CHECK: struct_element_addr {{.*}} : $*Aleph, #Aleph.a
|
|
%5 = struct_element_addr %2#1 : $*Aleph, #Aleph.a
|
|
%6 = load %5 : $*Ref
|
|
%8 = strong_release %6 : $Ref
|
|
%14 = load %2#1 : $*Aleph
|
|
// CHECK: struct_extract {{%.*}} : $Aleph, #Aleph.a
|
|
%15 = struct_extract %14 : $Aleph, #Aleph.a
|
|
%16 = strong_retain %15 : $Ref
|
|
%17 = strong_release %2#0 : $Builtin.NativeObject
|
|
%18 = return %14 : $Aleph
|
|
}
|
|
|
|
enum Beth {
|
|
case EmptyCase
|
|
case DataCase(Int)
|
|
}
|
|
|
|
// CHECK-LABEL: @test_union_empty_case : $@thin () -> Beth {
|
|
sil @test_union_empty_case : $@thin () -> Beth {
|
|
bb0:
|
|
// CHECK: %0 = enum $Beth, #Beth.EmptyCase!enumelt
|
|
%0 = enum $Beth, #Beth.EmptyCase!enumelt
|
|
return %0 : $Beth
|
|
}
|
|
|
|
// CHECK-LABEL: @test_union_data_case : $@thin (Int) -> Beth {
|
|
sil @test_union_data_case : $@thin Int -> Beth {
|
|
bb0(%0 : $Int):
|
|
// CHECK: %1 = enum $Beth, #Beth.DataCase!enumelt.1, %0 : $Int
|
|
%1 = enum $Beth, #Beth.DataCase!enumelt.1, %0 : $Int
|
|
return %1 : $Beth
|
|
}
|
|
|
|
protocol Q {}
|
|
|
|
enum Gimel {
|
|
case EmptyCase
|
|
case DataCase(Q)
|
|
}
|
|
|
|
// CHECK-LABEL: @test_union_addr_empty_case : $@thin (@out Gimel) -> () {
|
|
sil @test_union_addr_empty_case : $@thin (@out Gimel) -> () {
|
|
bb0(%0 : $*Gimel):
|
|
// CHECK: inject_enum_addr {{%.*}} : $*Gimel, #Gimel.EmptyCase!enumelt
|
|
inject_enum_addr %0 : $*Gimel, #Gimel.EmptyCase!enumelt
|
|
%t = tuple ()
|
|
return %t : $()
|
|
}
|
|
|
|
// CHECK-LABEL: @test_union_addr_data_case : $@thin (@out Gimel, @in Q) -> () {
|
|
sil @test_union_addr_data_case : $@thin (@out Gimel, @in Q) -> () {
|
|
bb0(%0 : $*Gimel, %1 : $*Q):
|
|
// CHECK: {{%.*}} = init_enum_data_addr {{%.*}} : $*Gimel, #Gimel.DataCase!enumelt.1
|
|
%p = init_enum_data_addr %0 : $*Gimel, #Gimel.DataCase!enumelt.1
|
|
copy_addr [take] %1 to [initialization] %p : $*Q
|
|
inject_enum_addr %0 : $*Gimel, #Gimel.DataCase!enumelt.1
|
|
%t = tuple ()
|
|
return %t : $()
|
|
}
|
|
|
|
sil @_TF5tuple5floatFT1xSf_T_ : $@thin (Float32) -> ()
|
|
sil @_TF5tuple5tupleFT_TSiSf_ : $@thin () -> (Int, Float32)
|
|
|
|
// CHECK-LABEL: @_TF5tuple13tuple_elementFT1xTSiSf__T_ : $@thin (Int, Float) -> ()
|
|
sil @_TF5tuple13tuple_elementFT1xTSiSf__T_ : $@thin (Int, Float) -> () {
|
|
bb0(%0 : $Int, %1 : $Float32):
|
|
%2 = alloc_box $(Int, Float32)
|
|
%3 = tuple (%0 : $Int, %1 : $Float32)
|
|
%4 = store %3 to %2#1 : $*(Int, Float32)
|
|
// CHECK: tuple_element_addr {{%.*}}#{{.*}} : $*(Int, Float), 0
|
|
%6 = tuple_element_addr %2#1 : $*(Int, Float), 0
|
|
%7 = load %6 : $*Int
|
|
// CHECK: tuple_element_addr {{%.*}}#{{.*}} : $*(Int, Float), 1
|
|
%10 = tuple_element_addr %2#1 : $*(Int, Float), 1
|
|
%11 = load %10 : $*Float32
|
|
// CHECK: function_ref
|
|
%14 = function_ref @_TF5tuple5tupleFT_TSiSf_ : $@thin () -> (Int, Float32)
|
|
// CHECK: apply
|
|
%15 = apply %14() : $@thin () -> (Int, Float32)
|
|
// CHECK: function_ref
|
|
%19 = function_ref @_TF5tuple5floatFT1xSf_T_ : $@thin (Float32) -> ()
|
|
// CHECK: tuple_extract {{%.*}} : $(Int, Float), 1
|
|
%17 = tuple_extract %15 : $(Int, Float), 1
|
|
// CHECK: apply
|
|
%24 = apply %19(%17) : $@thin (Float32) -> ()
|
|
%25 = tuple ()
|
|
%26 = strong_release %2#0 : $Builtin.NativeObject
|
|
%27 = return %25 : $()
|
|
}
|
|
|
|
class M {
|
|
var member : Int
|
|
init()
|
|
}
|
|
|
|
// CHECK-LABEL: @_TFC3ref1C3foofS0_FT1xSi_T_ : $@cc(method) @thin (Int, M) -> ()
|
|
sil @_TFC3ref1C3foofS0_FT1xSi_T_ : $@cc(method) @thin (Int, M) -> () {
|
|
bb0(%0 : $Int, %1 : $M):
|
|
%2 = alloc_box $Int
|
|
%3 = store %0 to %2#1 : $*Int
|
|
%4 = alloc_box $M
|
|
%5 = store %1 to %4#1 : $*M
|
|
%6 = load %2#1 : $*Int
|
|
%7 = load %4#1 : $*M
|
|
%8 = strong_retain %7 : $M
|
|
// CHECK: ref_element_addr {{%.*}} : $M, #M.member
|
|
%9 = ref_element_addr %7 : $M, #M.member
|
|
%10 = store %6 to %9 : $*Int
|
|
%11 = strong_release %7 : $M
|
|
%12 = tuple ()
|
|
%13 = strong_release %4#0 : $Builtin.NativeObject
|
|
%14 = strong_release %2#0 : $Builtin.NativeObject
|
|
%15 = return %12 : $()
|
|
}
|
|
|
|
class B { }
|
|
class E : B { }
|
|
|
|
// CHECK-LABEL: @_TF4null3isaFT1bCS_1B_Sb : $@thin (B) -> Builtin.Int1
|
|
sil @_TF4null3isaFT1bCS_1B_Sb : $@thin (B) -> Builtin.Int1 {
|
|
bb0(%0 : $B):
|
|
%1 = alloc_box $B
|
|
%2 = store %0 to %1#1 : $*B
|
|
%3 = load %1#1 : $*B
|
|
%4 = strong_retain %3 : $B
|
|
checked_cast_br %3 : $B to $E, yes, no // CHECK: checked_cast_br
|
|
yes(%5 : $E):
|
|
%y = integer_literal $Builtin.Int1, 1
|
|
br isa(%y : $Builtin.Int1)
|
|
no:
|
|
%n = integer_literal $Builtin.Int1, 0
|
|
br isa(%n : $Builtin.Int1)
|
|
isa(%6 : $Builtin.Int1):
|
|
%7 = strong_release %3 : $B
|
|
%8 = strong_release %1#0 : $Builtin.NativeObject
|
|
%9 = return %6 : $Builtin.Int1
|
|
}
|
|
|
|
sil @_TF7literal8literalsFT_T_ : $@thin () -> ()
|
|
|
|
sil @_TFSd31_convertFromBuiltinFloatLiteralfMSdFT5valueBf64__Sd : $@thin (Builtin.FPIEEE64, @thin Float64.Type) -> Float64
|
|
sil @_TFSS32_convertFromBuiltinStringLiteralfMSSFT5valueBp8byteSizeBi64_7isASCIIBi1__SS : $@thin (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> String
|
|
|
|
// CHECK-LABEL: @_TF5index5gep64FT1pBp1iBi64__Bp : $@thin (Builtin.RawPointer, Builtin.Word) -> Builtin.RawPointer {
|
|
sil @_TF5index5gep64FT1pBp1iBi64__Bp : $@thin (Builtin.RawPointer, Builtin.Word) -> Builtin.RawPointer {
|
|
bb0(%0 : $Builtin.RawPointer, %1 : $Builtin.Word):
|
|
%2 = alloc_box $Builtin.RawPointer
|
|
%3 = alloc_box $Builtin.Word
|
|
%4 = store %0 to %2#1 : $*Builtin.RawPointer
|
|
%5 = store %1 to %3#1 : $*Builtin.Word
|
|
%7 = load %2#1 : $*Builtin.RawPointer
|
|
%8 = load %3#1 : $*Builtin.Word
|
|
// CHECK: index_raw_pointer {{%.*}} : $Builtin.RawPointer, {{%.*}} : $Builtin.Word
|
|
%9 = index_raw_pointer %7 : $Builtin.RawPointer, %8 : $Builtin.Word
|
|
%10 = strong_release %3#0 : $Builtin.NativeObject
|
|
%11 = strong_release %2#0 : $Builtin.NativeObject
|
|
%12 = return %9 : $Builtin.RawPointer
|
|
}
|
|
|
|
var x : Int = 0
|
|
sil @global_callee : $@thin (Builtin.Int128, @thin Int.Type) -> Int
|
|
|
|
// CHECK-LABEL: @global_code : $@thin () -> ()
|
|
sil @global_code : $@thin () -> () {
|
|
bb0:
|
|
// CHECK: global_addr #x : $*Int
|
|
%0 = global_addr #x : $*Int
|
|
%1 = function_ref @global_callee : $@thin (Builtin.Int128, @thin Int.Type) -> Int
|
|
%2 = metatype $@thin Int.Type
|
|
%3 = integer_literal $Builtin.Int128, 0 // CHECK: integer_literal $Builtin.Int128, 0
|
|
%4 = apply %1(%3, %2) : $@thin (Builtin.Int128, @thin Int.Type) -> Int
|
|
%5 = store %4 to %0 : $*Int
|
|
%6 = tuple ()
|
|
%7 = return %6 : $()
|
|
}
|
|
|
|
protocol SomeProtocol {
|
|
}
|
|
class SomeClass : SomeProtocol {
|
|
}
|
|
class SomeSubclass : SomeClass {}
|
|
|
|
// CHECK-LABEL: @test_class_metatype : $@thin (SomeClass, SomeSubclass) -> (@thick SomeClass.Type, @thick SomeClass.Type) {
|
|
sil @test_class_metatype : $@thin (SomeClass, SomeSubclass) -> (@thick SomeClass.Type, @thick SomeClass.Type) {
|
|
bb0(%0 : $SomeClass, %1 : $SomeSubclass):
|
|
%2 = alloc_box $SomeClass
|
|
%3 = alloc_box $SomeSubclass
|
|
%4 = store %0 to %2#1 : $*SomeClass
|
|
%5 = store %1 to %3#1 : $*SomeSubclass
|
|
%7 = load %2#1 : $*SomeClass
|
|
// CHECK: strong_retain %{{.*}} : $SomeClass
|
|
%8 = strong_retain %7 : $SomeClass
|
|
// CHECK: value_metatype $@thick SomeClass.Type, {{%.*}} : $SomeClass
|
|
%9 = value_metatype $@thick SomeClass.Type, %7 : $SomeClass
|
|
%11 = load %3#1 : $*SomeSubclass
|
|
%12 = strong_retain %11 : $SomeSubclass
|
|
// CHECK: value_metatype $@thick SomeSubclass.Type, {{%.*}} : $SomeSubclass
|
|
%13 = value_metatype $@thick SomeSubclass.Type, %11 : $SomeSubclass
|
|
// CHECK: upcast %{{.*}} : $@thick SomeSubclass.Type to $@thick SomeClass.Type
|
|
%14 = upcast %13 : $@thick SomeSubclass.Type to $@thick SomeClass.Type
|
|
// CHECK: tuple (%{{.*}} : $@thick SomeClass.Type, %{{.*}} : $@thick SomeClass.Type)
|
|
%15 = tuple (%9 : $@thick SomeClass.Type, %14 : $@thick SomeClass.Type)
|
|
%16 = strong_release %11 : $SomeSubclass
|
|
%17 = strong_release %7 : $SomeClass
|
|
%18 = strong_release %3#0 : $Builtin.NativeObject
|
|
%19 = strong_release %2#0 : $Builtin.NativeObject
|
|
%20 = return %15 : $(@thick SomeClass.Type, @thick SomeClass.Type)
|
|
}
|
|
|
|
// CHECK-LABEL: @test_existential_metatype : $@thin (@in SomeProtocol) -> @thick SomeProtocol.Type {
|
|
sil @test_existential_metatype : $@thin (@in SomeProtocol) -> @thick SomeProtocol.Type {
|
|
bb0(%0 : $*SomeProtocol):
|
|
%1 = alloc_box $SomeProtocol
|
|
// CHECK: copy_addr [take] %0 to [initialization] %1#1 : $*SomeProtocol
|
|
%2 = copy_addr [take] %0 to [initialization] %1#1 : $*SomeProtocol
|
|
// CHECK: alloc_stack
|
|
%4 = alloc_stack $SomeProtocol
|
|
// CHECK: copy_addr %1#1 to [initialization] %{{.*}}#1 : $*SomeProtocol
|
|
%5 = copy_addr %1#1 to [initialization] %4#1 : $*SomeProtocol
|
|
// CHECK: existential_metatype $@thick SomeProtocol.Type, {{%.*}} : $*SomeProtocol
|
|
%6 = existential_metatype $@thick SomeProtocol.Type, %4#1 : $*SomeProtocol
|
|
%7 = destroy_addr %4#1 : $*SomeProtocol
|
|
%8 = dealloc_stack %4#0 : $*@local_storage SomeProtocol
|
|
%9 = strong_release %1#0 : $Builtin.NativeObject
|
|
%10 = return %6 : $@thick SomeProtocol.Type
|
|
}
|
|
|
|
// CHECK-LABEL: sil public_external @test_unreachable
|
|
sil @test_unreachable : $@thin () -> () {
|
|
bb0:
|
|
unreachable
|
|
// CHECK: unreachable
|
|
}
|
|
|
|
// CHECK-LABEL: @test_unowned_retain : $@thin (SomeClass) -> () {
|
|
sil @test_unowned_retain : $@thin (SomeClass) -> () {
|
|
bb0(%0 : $SomeClass):
|
|
%1 = ref_to_unowned %0 : $SomeClass to $@sil_unowned SomeClass
|
|
// CHECK: ref_to_unowned %0 : $SomeClass to $@sil_unowned SomeClass
|
|
%2 = unowned_retain %1 : $@sil_unowned SomeClass
|
|
// CHECK: unowned_retain %1 : $@sil_unowned SomeClass
|
|
%3 = unowned_release %1 : $@sil_unowned SomeClass
|
|
// CHECK: unowned_release %1 : $@sil_unowned SomeClass
|
|
%4 = unowned_to_ref %1 : $@sil_unowned SomeClass to $SomeClass
|
|
// CHECK: unowned_to_ref %1 : $@sil_unowned SomeClass to $SomeClass
|
|
%5 = tuple ()
|
|
%6 = return %5 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil public_external @test_basic_block_arguments
|
|
sil @test_basic_block_arguments : $@thin (Builtin.Int1) -> Builtin.Word {
|
|
bb0(%0 : $Builtin.Int1):
|
|
// CHECK: cond_br
|
|
cond_br %0, bb1, bb2
|
|
bb1:
|
|
%2 = integer_literal $Builtin.Word, 5
|
|
br bb3(%2 : $Builtin.Word)
|
|
//CHECK: br bb3(%2 : $Builtin.Word)
|
|
bb2:
|
|
%4 = integer_literal $Builtin.Word, 6
|
|
br bb3(%4 : $Builtin.Word)
|
|
//CHECK: br bb3(%4 : $Builtin.Word)
|
|
bb3(%6 : $Builtin.Word):
|
|
//CHECK: bb3(%6 : $Builtin.Word)
|
|
return %6 : $Builtin.Word
|
|
}
|
|
|
|
// CHECK-LABEL: sil public_external @test_cond_branch_basic_block_args
|
|
sil @test_cond_branch_basic_block_args : $@thin (Int, Builtin.Int1) -> Int {
|
|
bb0(%0 : $Int, %1 : $Builtin.Int1):
|
|
cond_br %1, bb1(%0 : $Int), bb2(%0 : $Int)
|
|
// CHECK: cond_br %1, bb1(%0 : $Int), bb2(%0 : $Int)
|
|
bb1(%3 : $Int):
|
|
br bb3 (%3 : $Int)
|
|
bb2(%2 : $Int):
|
|
br bb3(%2 : $Int)
|
|
bb3(%4 : $Int):
|
|
return %4 : $Int
|
|
}
|
|
|
|
class Bas : NSObject {
|
|
var strRealProp : String
|
|
init()
|
|
}
|
|
sil @test_autorelease_return : $@cc(objc_method) @thin (Bas) -> NSString
|
|
sil @test_super_method : $@cc(method) @thin (Bas) -> Bas
|
|
|
|
sil @swift_StringToNSString : $@thin (@inout String) -> @owned NSString
|
|
sil @_TFSSCfMSSFT_SS : $@thin (@thin String.Type) -> String
|
|
|
|
// CHECK-LABEL: sil public_external @test_builtin_func_ref
|
|
sil @test_builtin_func_ref : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 {
|
|
bb0(%0 : $Builtin.Int1, %1 : $Builtin.Int1):
|
|
%2 = alloc_box $Builtin.Int1
|
|
%3 = alloc_box $Builtin.Int1
|
|
store %0 to %2#1 : $*Builtin.Int1
|
|
store %1 to %3#1 : $*Builtin.Int1
|
|
// CHECK: builtin_function_ref "cmp_eq_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1
|
|
%7 = builtin_function_ref "cmp_eq_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1
|
|
%8 = load %2#1 : $*Builtin.Int1
|
|
%9 = load %3#1 : $*Builtin.Int1
|
|
%10 = apply %7(%8, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1
|
|
strong_release %3#0 : $Builtin.NativeObject
|
|
strong_release %2#0 : $Builtin.NativeObject
|
|
return %10 : $Builtin.Int1
|
|
}
|
|
|
|
// CHECK-LABEL: sil public_external @test_dealloc_ref
|
|
sil @test_dealloc_ref : $@thin () -> () {
|
|
bb0:
|
|
%0 = alloc_ref $Class1
|
|
// CHECK: dealloc_ref %{{.*}} : $Class1
|
|
dealloc_ref %0 : $Class1
|
|
%2 = tuple ()
|
|
return %2 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil public_external @test_dealloc_box
|
|
sil @test_dealloc_box : $@thin () -> () {
|
|
bb0:
|
|
%0 = alloc_box $Class1
|
|
dealloc_box $Class1, %0#0 : $Builtin.NativeObject
|
|
%2 = tuple ()
|
|
return %2 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: @closure_test
|
|
sil @takes_closure : $@thin (@callee_owned () -> ()) -> ()
|
|
sil @closure0 : $@thin (Builtin.NativeObject, @inout Int) -> ()
|
|
|
|
sil @closure_test : $@thin () -> () {
|
|
bb0:
|
|
%0 = alloc_box $Int // users: %10, %8, %8, %7, %4
|
|
|
|
%5 = function_ref @takes_closure : $@thin (@callee_owned () -> ()) -> ()
|
|
%6 = function_ref @closure0 : $@thin (Builtin.NativeObject, @inout Int) -> ()
|
|
strong_retain %0#0 : $Builtin.NativeObject
|
|
//%8 = partial_apply %6(%0#0, %0#1) : $@thin (Builtin.NativeObject, @inout Int) -> ()
|
|
//%9 = apply %5(%8) : $@thin (@callee_owned () -> ()) -> ()
|
|
//strong_release %0#0 : $Builtin.NativeObject
|
|
|
|
%11 = tuple ()
|
|
return %11 : $()
|
|
}
|
|
|
|
@class_protocol protocol ClassP {}
|
|
|
|
enum MaybePair {
|
|
case Neither
|
|
case Left(Int)
|
|
}
|
|
|
|
sil @_TF6switch1aFT_T_ : $@thin () -> ()
|
|
sil @_TF6switch1bFT_T_ : $@thin () -> ()
|
|
sil @_TF6switch1cFT_T_ : $@thin () -> ()
|
|
|
|
// CHECK-LABEL: sil public_external @test_switch_union : $@thin (MaybePair) -> ()
|
|
sil @test_switch_union : $@thin (MaybePair) -> () {
|
|
bb0(%0 : $MaybePair):
|
|
%1 = alloc_box $MaybePair
|
|
store %0 to %1#1 : $*MaybePair
|
|
%3 = load %1#1 : $*MaybePair
|
|
%4 = tuple ()
|
|
// CHECK: switch_enum %{{.*}} : $MaybePair, case #MaybePair.Neither!enumelt: bb{{.*}}, case #MaybePair.Left!enumelt.1: bb
|
|
switch_enum %3 : $MaybePair, case #MaybePair.Neither!enumelt: bb1, case #MaybePair.Left!enumelt.1: bb3
|
|
|
|
bb1:
|
|
br bb2
|
|
|
|
bb2:
|
|
%7 = function_ref @_TF6switch1aFT_T_ : $@thin () -> ()
|
|
%8 = apply %7() : $@thin () -> ()
|
|
br bb5 // CHECK: br
|
|
|
|
bb3(%10 : $Int):
|
|
// CHECK: unchecked_enum_data {{%.*}} : $MaybePair, #MaybePair.Left!enumelt.1
|
|
%x = unchecked_enum_data %3 : $MaybePair, #MaybePair.Left!enumelt.1
|
|
br bb4(%x : $Int)
|
|
|
|
bb4(%y : $Int):
|
|
%12 = function_ref @_TF6switch1bFT_T_ : $@thin () -> ()
|
|
%13 = apply %12() : $@thin () -> ()
|
|
br bb5 // CHECK: br
|
|
|
|
bb5:
|
|
%15 = function_ref @_TF6switch1cFT_T_ : $@thin () -> ()
|
|
%16 = apply %15() : $@thin () -> ()
|
|
strong_release %1#0 : $Builtin.NativeObject
|
|
%18 = tuple ()
|
|
return %18 : $() // CHECK: return
|
|
}
|
|
|
|
enum MaybeAddressOnlyPair {
|
|
case Neither
|
|
case Left(Q)
|
|
}
|
|
|
|
// CHECK-LABEL: sil public_external @test_switch_union_addr : $@thin (@in MaybeAddressOnlyPair) -> ()
|
|
sil @test_switch_union_addr : $@thin (@in MaybeAddressOnlyPair) -> () {
|
|
bb0(%0 : $*MaybeAddressOnlyPair):
|
|
// CHECK: switch_enum_addr [[ENUM:%.*]] : $*MaybeAddressOnlyPair, case #MaybeAddressOnlyPair.Neither!enumelt: bb{{.*}}, case #MaybeAddressOnlyPair.Left!enumelt.1: bb
|
|
switch_enum_addr %0 : $*MaybeAddressOnlyPair, case #MaybeAddressOnlyPair.Neither!enumelt: bb1, case #MaybeAddressOnlyPair.Left!enumelt.1: bb2
|
|
|
|
bb1:
|
|
br bb3
|
|
|
|
bb2:
|
|
// CHECK: unchecked_take_enum_data_addr [[ENUM]] : $*MaybeAddressOnlyPair, #MaybeAddressOnlyPair.Left!enumelt.1
|
|
%q = unchecked_take_enum_data_addr %0 : $*MaybeAddressOnlyPair, #MaybeAddressOnlyPair.Left!enumelt.1
|
|
br bb3
|
|
|
|
bb3:
|
|
%t = tuple ()
|
|
return %t : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil public_external @test_switch_int : $@thin (Builtin.Word) -> ()
|
|
sil @test_switch_int : $@thin (Builtin.Word) -> () {
|
|
bb0(%0 : $Builtin.Word):
|
|
// CHECK: switch_int %{{.*}} : $Builtin.Word, case 1: bb1, case 2: bb2
|
|
switch_int %0 : $Builtin.Word, case 1: bb1, case 2: bb2
|
|
|
|
bb1:
|
|
%7 = function_ref @_TF6switch1aFT_T_ : $@thin () -> () // CHECK: function_ref
|
|
%8 = apply %7() : $@thin () -> ()
|
|
br bb3
|
|
|
|
bb2:
|
|
%12 = function_ref @_TF6switch1bFT_T_ : $@thin () -> () // CHECK: function_ref
|
|
%13 = apply %12() : $@thin () -> ()
|
|
br bb3
|
|
|
|
bb3:
|
|
%18 = tuple ()
|
|
return %18 : $() // CHECK: return
|
|
}
|
|
|
|
class ConcreteClass : ClassP {
|
|
}
|
|
struct Spoon : Bendable {
|
|
}
|
|
|
|
// CHECK-LABEL: sil public_external @test_init_existential : $@thin (@out Bendable, Spoon) -> ()
|
|
sil @test_init_existential : $@thin (@out Bendable, Spoon) -> () {
|
|
bb0(%0 : $*Bendable, %1 : $Spoon):
|
|
%2 = alloc_box $Spoon
|
|
store %1 to %2#1 : $*Spoon
|
|
// CHECK: init_existential %{{.*}} : $*Bendable, $*Spoon
|
|
%4 = init_existential %0 : $*Bendable, $*Spoon
|
|
// CHECK: deinit_existential %{{.*}} : $*Bendable
|
|
deinit_existential %0 : $*Bendable
|
|
%5 = load %2#1 : $*Spoon
|
|
store %5 to %4 : $*Spoon
|
|
strong_release %2#0 : $Builtin.NativeObject
|
|
%8 = tuple ()
|
|
return %8 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil public_external @test_existential_ref : $@thin (ConcreteClass) -> ClassP
|
|
sil @test_existential_ref : $@thin (ConcreteClass) -> ClassP {
|
|
bb0(%0 : $ConcreteClass):
|
|
%1 = alloc_box $ConcreteClass
|
|
store %0 to %1#1 : $*ConcreteClass
|
|
%3 = load %1#1 : $*ConcreteClass
|
|
strong_retain %3 : $ConcreteClass
|
|
// CHECK: init_existential_ref %{{.*}} : $ConcreteClass, $ClassP
|
|
%5 = init_existential_ref %3 : $ConcreteClass, $ClassP
|
|
strong_release %1#0 : $Builtin.NativeObject
|
|
return %5 : $ClassP
|
|
}
|
|
|
|
sil @test_assign : $@thin (Int, @inout Int) -> () { // CHECK-LABEL: sil public_external @test_assign
|
|
bb0(%0 : $Int, %1 : $*Int):
|
|
assign %0 to %1 : $*Int // CHECK: assign
|
|
unreachable
|
|
}
|
|
|
|
// CHECK-LABEL: sil public_external @test_transparent : $@thin () -> () {
|
|
sil @test_transparent : $@thin () -> () {
|
|
bb0:
|
|
// CHECK: function_ref
|
|
// CHECK: apply [transparent]
|
|
%0 = function_ref @classes : $@thin () -> ()
|
|
%1 = apply [transparent] %0() : $@thin () -> ()
|
|
%2 = tuple ()
|
|
%3 = return %2 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: [noinline] @noinline_callee
|
|
sil [noinline] @noinline_callee : $@thin () -> Int {
|
|
bb0:
|
|
%0 = function_ref @_TFSi33_convertFromBuiltinIntegerLiteralfMSiFBi2048_Si : $@thin (Builtin.Int2048, @thin Int.Type) -> Int
|
|
%1 = metatype $@thin Int.Type
|
|
%2 = integer_literal $Builtin.Int2048, 0
|
|
%3 = apply [transparent] %0(%2, %1) : $@thin (Builtin.Int2048, @thin Int.Type) -> Int
|
|
return %3 : $Int
|
|
}
|
|
sil [transparent] @_TFSi33_convertFromBuiltinIntegerLiteralfMSiFBi2048_Si : $@thin (Builtin.Int2048, @thin Int.Type) -> Int
|
|
|
|
// CHECK-LABEL: [semantics "foo"] @test_semantics : $@thin () -> ()
|
|
sil [semantics "foo"] @test_semantics : $@thin () -> () {
|
|
bb0:
|
|
%2 = tuple ()
|
|
%3 = return %2 : $()
|
|
}
|
|
|
|
sil @takes_unnamed_closure : $@thin (@callee_owned () -> Int) -> @callee_owned () -> @callee_owned () -> Int
|
|
|
|
sil @takes_int64_float32 : $@thin (Int, Float32) -> ()
|
|
|
|
// CHECK-LABEL: sil public_external @test_partial_apply : $@thin (Float) -> @callee_owned (Int) -> () {
|
|
sil @test_partial_apply : $@thin Float32 -> @callee_owned Int -> () {
|
|
bb0(%0 : $Float32):
|
|
%1 = function_ref @takes_int64_float32 : $@thin (Int, Float) -> ()
|
|
// CHECK: partial_apply %{{.*}}(%{{.*}}) : $@thin (Int, Float) -> ()
|
|
%2 = partial_apply %1(%0) : $@thin (Int, Float) -> ()
|
|
%3 = return %2 : $@callee_owned Int -> ()
|
|
}
|
|
|
|
class X {
|
|
@objc func f() { }
|
|
}
|
|
|
|
// CHECK-LABEL: sil public_external @test_dynamic_lookup_br : $@thin (AnyObject) -> ()
|
|
sil @test_dynamic_lookup_br : $@thin (AnyObject) -> () {
|
|
bb0(%0 : $AnyObject):
|
|
%1 = alloc_box $AnyObject
|
|
store %0 to %1#1 : $*AnyObject
|
|
%3 = alloc_box $Optional<() -> ()>
|
|
%4 = load %1#1 : $*AnyObject
|
|
strong_retain %4 : $AnyObject
|
|
// CHECK: project_existential_ref %{{.*}} : $AnyObject to $@sil_self AnyObject
|
|
%6 = project_existential_ref %4 : $AnyObject to $@sil_self AnyObject
|
|
%7 = unchecked_ref_cast %6 : $@sil_self AnyObject to $Builtin.UnknownObject
|
|
// CHECK: dynamic_method_br %{{.*}} : $Builtin.UnknownObject, #X.f!1.foreign, bb{{.*}}, bb{{.*}}
|
|
dynamic_method_br %7 : $Builtin.UnknownObject, #X.f!1.foreign, bb1, bb2
|
|
bb1(%z : $@cc(objc_method) @thin (Builtin.UnknownObject) -> ()):
|
|
br bb3
|
|
|
|
bb2:
|
|
br bb3
|
|
|
|
bb3:
|
|
%28 = tuple ()
|
|
return %28 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil public_external @test_mark_fn_escape
|
|
sil @test_mark_fn_escape : $@thin () -> () {
|
|
%b = alloc_box $Int
|
|
%c = alloc_box $Int
|
|
|
|
//mark_function_escape %b#1 : $*Int
|
|
//mark_function_escape %b#1 : $*Int, %c#1 : $*Int
|
|
|
|
%28 = tuple ()
|
|
return %28 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil public_external @test_copy_release_value
|
|
sil @test_copy_release_value : $@thin (X) -> (X) {
|
|
bb0(%0 : $X):
|
|
retain_value %0 : $X
|
|
release_value %0 : $X
|
|
autorelease_value %0 : $X
|
|
return %0 : $X
|
|
// CHECK: retain_value [[T0:%.*]] : $X
|
|
// CHECK-NEXT: release_value [[T0]] : $X
|
|
// CHECK-NEXT: autorelease_value [[T0]] : $X
|
|
// CHECK-NEXT: return [[T0]] : $X
|
|
}
|
|
|
|
@public func serialize_all() {
|
|
}
|
|
|
|
// CHECK: sil public_external @cond_fail_test : $@thin (Builtin.Int1) -> () {
|
|
sil @cond_fail_test : $@thin Builtin.Int1 -> () {
|
|
entry(%0 : $Builtin.Int1):
|
|
// CHECK: cond_fail %0 : $Builtin.Int1
|
|
cond_fail %0 : $Builtin.Int1
|
|
%1 = tuple ()
|
|
return %1 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil public_external @block_storage_type
|
|
sil @block_storage_type : $@thin Int -> @cc(cdecl) @objc_block () -> () {
|
|
entry(%0 : $Int):
|
|
// CHECK: [[STORAGE:%.*]] = alloc_stack $@block_storage Int
|
|
%s = alloc_stack $@block_storage Int
|
|
// CHECK: [[PROJECT:%.*]] = project_block_storage [[STORAGE]]#1 : $*@block_storage Int
|
|
%c = project_block_storage %s#1 : $*@block_storage Int
|
|
// CHECK: store %0 to [[PROJECT]]
|
|
store %0 to %c : $*Int
|
|
// CHECK: [[FUNC:%.*]] = function_ref
|
|
%f = function_ref @block_invoke : $@thin @cc(cdecl) (@inout @block_storage Int) -> ()
|
|
// CHECK: [[BLOCK:%.*]] = init_block_storage_header [[STORAGE]]#1 : $*@block_storage Int, invoke [[FUNC]] : $@cc(cdecl) @thin (@inout @block_storage Int) -> (), type $@cc(cdecl) @objc_block () -> ()
|
|
%b = init_block_storage_header %s#1 : $*@block_storage Int, invoke %f : $@thin @cc(cdecl) (@inout @block_storage Int) -> (), type $@cc(cdecl) @objc_block () -> ()
|
|
// CHECK: dealloc_stack [[STORAGE]]#0 : $*@local_storage @block_storage Int
|
|
dealloc_stack %s#0 : $*@local_storage @block_storage Int
|
|
// CHECK: return [[BLOCK]] : $@cc(cdecl) @objc_block () -> ()
|
|
return %b : $@cc(cdecl) @objc_block () -> ()
|
|
}
|
|
|
|
@class_protocol protocol SomeClassProtocol {}
|
|
|
|
// CHECK-LABEL: sil public_external @metatype_to_object
|
|
// CHECK: {{%.*}} = objc_metatype_to_object {{%.*}} : $@objc_metatype SomeClass.Type to $AnyObject
|
|
// CHECK: {{%.*}} = objc_existential_metatype_to_object {{%.*}} : $@objc_metatype SomeClassProtocol.Type to $AnyObject
|
|
sil @metatype_to_object : $@thin (@objc_metatype SomeClass.Type, @objc_metatype SomeClassProtocol.Type) -> @owned (AnyObject, AnyObject) {
|
|
entry(%a : $@objc_metatype SomeClass.Type, %b : $@objc_metatype SomeClassProtocol.Type):
|
|
%x = objc_metatype_to_object %a : $@objc_metatype SomeClass.Type to $AnyObject
|
|
%y = objc_existential_metatype_to_object %b : $@objc_metatype SomeClassProtocol.Type to $AnyObject
|
|
%z = tuple (%x : $AnyObject, %y : $AnyObject)
|
|
return %z : $(AnyObject, AnyObject)
|
|
}
|
|
|
|
// CHECK-LABEL: sil public_external @bitcasts : $@thin (@owned Class1) -> @owned (Class2, Int) {
|
|
// CHECK-NEXT: bb0(%0 : $Class1):
|
|
// CHECK-NEXT: %1 = unchecked_ref_bit_cast %0 : $Class1 to $Class2
|
|
// CHECK-NEXT: %2 = unchecked_trivial_bit_cast %0 : $Class1 to $Int
|
|
// CHECK-NEXT: %3 = tuple (%1 : $Class2, %2 : $Int)
|
|
// CHECK-NEXT: return %3 : $(Class2, Int)
|
|
sil @bitcasts : $@thin (@owned Class1) -> @owned (Class2, Int) {
|
|
entry(%0 : $Class1):
|
|
%1 = unchecked_ref_bit_cast %0 : $Class1 to $Class2
|
|
%2 = unchecked_trivial_bit_cast %0 : $Class1 to $Int
|
|
%3 = tuple (%1 : $Class2, %2 : $Int)
|
|
return %3 : $(Class2, Int)
|
|
}
|
|
|
|
@objc protocol ObjCProto {}
|
|
|
|
// CHECK-LABEL: sil public_external @protocol_conversion
|
|
sil @protocol_conversion : $@thin () -> @owned Protocol {
|
|
entry:
|
|
// CHECK: {{%.*}} = objc_protocol #ObjCProto : $Protocol
|
|
%p = objc_protocol #ObjCProto : $Protocol
|
|
return %p : $Protocol
|
|
}
|
|
|
|
sil @block_invoke : $@thin @cc(cdecl) (@inout @block_storage Int) -> ()
|
|
|
|
|
|
// rdar://15351123
|
|
// CHECK-LABEL: @test_forward_ref
|
|
sil @test_forward_ref : $@thin (UInt8, UInt8) -> UInt8
|
|
|
|
// CHECK-LABEL: sil public_external @partial_apply : $@thin (@thin (@out Int, Int) -> (), Int) -> Int {
|
|
// CHECK: [[PA:%.*]] = partial_apply {{%.*}}({{%.*}}) : $@thin (@out Int, Int) -> ()
|
|
// CHECK: apply [[PA]]({{%.*}}) : $@callee_owned (@out Int) -> ()
|
|
sil @partial_apply : $@thin (@thin (@out Int, Int) -> (), Int) -> Int {
|
|
entry(%f : $@thin (@out Int, Int) -> (), %x : $Int):
|
|
%p = partial_apply %f(%x) : $@thin (@out Int, Int) -> ()
|
|
%i = alloc_stack $Int
|
|
%z = apply %p(%i#1) : $@callee_owned (@out Int) -> ()
|
|
%y = load %i#1 : $*Int
|
|
dealloc_stack %i#0 : $*@local_storage Int
|
|
return %y : $Int
|
|
}
|
|
|
|
// Make sure we serialize the body of closure even without -sil-serialize-all.
|
|
// CHECK_DECL-LABEL: @partial_apply_with_closure
|
|
sil [transparent] @partial_apply_with_closure : $@thin (@owned @callee_owned () -> Bool, @owned String, CString, Int64) -> () {
|
|
bb0(%0 : $@callee_owned () -> Bool, %1 : $String, %2 : $CString, %3 : $Int64):
|
|
%17 = function_ref @closure_body : $@thin (CString, CString, Int64) -> ()
|
|
// CHECK_DECL: function_ref @closure_body
|
|
%18 = partial_apply %17(%2, %3) : $@thin (CString, CString, Int64) -> ()
|
|
// CHECK_DECL: partial_apply
|
|
%30 = tuple ()
|
|
return %30 : $()
|
|
}
|
|
|
|
sil shared @closure_body : $@thin (CString, CString, Int64) -> () {
|
|
bb0(%0 : $CString, %1 : $CString, %2 : $Int64):
|
|
%3 = function_ref @assert_fail : $@thin (CString, CString, Int64) -> ()
|
|
%4 = apply %3(%0, %1, %2) : $@thin (CString, CString, Int64) -> ()
|
|
%5 = tuple ()
|
|
return %5 : $()
|
|
}
|
|
|
|
// CHECK_DECL-LABEL: @closure_body : $@thin (CString, CString, Int64) -> () {
|
|
// CHECK_DECL: function_ref @assert_fail
|
|
|
|
sil @assert_fail : $@thin (CString, CString, Int64) -> ()
|
|
|
|
// rdar: 15893086
|
|
struct GenericStruct<T> {
|
|
var x : T
|
|
}
|
|
|
|
// CHECK-LABEL: @extract_generic_struct
|
|
sil @extract_generic_struct : $@thin GenericStruct<Int64> -> Int64 {
|
|
entry(%0 : $GenericStruct<Int64>):
|
|
// CHECK: %1 = struct_extract %0 : $GenericStruct<Int64>, #GenericStruct.x
|
|
%1 = struct_extract %0 : $GenericStruct<Int64>, #GenericStruct.x
|
|
// CHECK: return %1 : $Int64
|
|
return %1 : $Int64
|
|
}
|
|
|
|
class Foo {
|
|
subscript (x: Int, y: Int) -> Int { get set }
|
|
var x: Int
|
|
var y: Int
|
|
init()
|
|
}
|
|
|
|
// CHECK-LABEL: sil @_TFC3tmp3Foog9subscriptFT1xSi1ySi_Si : $@cc(method) @thin (Int, Int, Foo) -> Int
|
|
// CHECK_DECL-LABEL: sil @_TFC3tmp3Foog9subscriptFT1xSi1ySi_Si : $@cc(method) @thin (Int, Int, Foo) -> Int{{$}}
|
|
sil @_TFC3tmp3Foog9subscriptFT1xSi1ySi_Si : $@cc(method) @thin (Int, Int, Foo) -> Int {
|
|
bb0(%0 : $Int, %1 : $Int, %2 : $Foo):
|
|
%3 = tuple ()
|
|
%4 = alloc_stack $Int // var x // users: %17, %6
|
|
%5 = alloc_stack $Int // var y // users: %16, %7
|
|
store %0 to %4#1 : $*Int
|
|
store %1 to %5#1 : $*Int
|
|
%8 = alloc_stack $Foo // var self // users: %15, %14, %9
|
|
store %2 to %8#1 : $*Foo
|
|
%10 = metatype $@thin Int.Type
|
|
%12 = integer_literal $Builtin.Word, 0 // user: %13
|
|
%13 = struct $Int (%12 : $Builtin.Word) // user: %18
|
|
destroy_addr %8#1 : $*Foo
|
|
dealloc_stack %8#0 : $*@local_storage Foo
|
|
dealloc_stack %5#0 : $*@local_storage Int
|
|
dealloc_stack %4#0 : $*@local_storage Int
|
|
return %13 : $Int
|
|
}
|
|
|
|
// CHECK-LABEL: sil @_TFC3tmp3Foos9subscriptFT1xSi1ySi_Si : $@cc(method) @thin (Int, Int, Int, Foo) -> ()
|
|
// CHECK_DECL-LABEL: sil @_TFC3tmp3Foos9subscriptFT1xSi1ySi_Si : $@cc(method) @thin (Int, Int, Int, Foo) -> (){{$}}
|
|
sil @_TFC3tmp3Foos9subscriptFT1xSi1ySi_Si : $@cc(method) @thin (Int, Int, Int, Foo) -> () {
|
|
bb0(%0 : $Int, %1 : $Int, %2 : $Int, %3 : $Foo):
|
|
%4 = alloc_stack $Int // var value // users: %16, %5
|
|
store %0 to %4#1 : $*Int
|
|
%6 = alloc_stack $Int // var x // users: %15, %8
|
|
%7 = alloc_stack $Int // var y // users: %14, %9
|
|
store %1 to %6#1 : $*Int
|
|
store %2 to %7#1 : $*Int
|
|
%10 = alloc_stack $Foo // var self // users: %13, %12, %11
|
|
store %3 to %10#1 : $*Foo
|
|
destroy_addr %10#1 : $*Foo
|
|
dealloc_stack %10#0 : $*@local_storage Foo
|
|
dealloc_stack %7#0 : $*@local_storage Int
|
|
dealloc_stack %6#0 : $*@local_storage Int
|
|
dealloc_stack %4#0 : $*@local_storage Int
|
|
%17 = tuple () // user: %18
|
|
return %17 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil_vtable Foo {
|
|
// CHECK: #Foo.subscript!getter.1: _TFC3tmp3Foog9subscriptFT1xSi1ySi_Si
|
|
// CHECK: #Foo.subscript!setter.1: _TFC3tmp3Foos9subscriptFT1xSi1ySi_Si
|
|
// CHECK: }
|
|
// CHECK_DECL-LABEL: sil_vtable Foo {
|
|
// CHECK_DECL: #Foo.subscript!getter.1: _TFC3tmp3Foog9subscriptFT1xSi1ySi_Si
|
|
// CHECK_DECL: #Foo.subscript!setter.1: _TFC3tmp3Foos9subscriptFT1xSi1ySi_Si
|
|
// CHECK_DECL: }
|
|
sil_vtable Foo {
|
|
#Foo.subscript!getter.1: _TFC3tmp3Foog9subscriptFT1xSi1ySi_Si
|
|
#Foo.subscript!setter.1: _TFC3tmp3Foos9subscriptFT1xSi1ySi_Si
|
|
}
|
|
|
|
protocol AssocReqt {
|
|
func requiredMethod()
|
|
}
|
|
|
|
struct ConformingAssoc : AssocReqt {
|
|
func requiredMethod()
|
|
}
|
|
|
|
sil @_TFV14witness_tables15ConformingAssoc14requiredMethodfS0_FT_T_ : $@cc(method) @thin (ConformingAssoc) -> () {
|
|
bb0(%0 : $ConformingAssoc):
|
|
debug_value %0 : $ConformingAssoc
|
|
%2 = tuple ()
|
|
return %2 : $()
|
|
}
|
|
|
|
sil @_TTWV14witness_tables15ConformingAssocS_9AssocReqtS_FS1_14requiredMethodU_fRQPS1_FT_T_ : $@cc(witness_method) @thin (@inout ConformingAssoc) -> () {
|
|
bb0(%0 : $*ConformingAssoc):
|
|
%1 = load %0 : $*ConformingAssoc
|
|
%2 = function_ref @_TFV14witness_tables15ConformingAssoc14requiredMethodfS0_FT_T_ : $@cc(method) @thin (ConformingAssoc) -> ()
|
|
%3 = apply %2(%1) : $@cc(method) @thin (ConformingAssoc) -> ()
|
|
return %3 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil_witness_table public_external ConformingAssoc: AssocReqt module
|
|
// CHECK: #AssocReqt.requiredMethod!1: @_TTWV14witness_tables15ConformingAssocS_9AssocReqtS_FS1_14requiredMethodU_fRQPS1_FT_T_
|
|
// CHECK: }
|
|
sil_witness_table ConformingAssoc: AssocReqt module def_basic {
|
|
method #AssocReqt.requiredMethod!1: @_TTWV14witness_tables15ConformingAssocS_9AssocReqtS_FS1_14requiredMethodU_fRQPS1_FT_T_
|
|
}
|
|
|
|
protocol AnyProtocol {
|
|
typealias AssocType
|
|
typealias AssocWithReqt : AssocReqt
|
|
func assocTypesMethod(x: AssocType, y: AssocWithReqt)
|
|
class func staticMethod(x: Self)
|
|
}
|
|
class SomeAssoc {
|
|
}
|
|
protocol InheritedProtocol1 : AnyProtocol {
|
|
func inheritedMethod()
|
|
}
|
|
struct InheritedConformance : InheritedProtocol1 {
|
|
typealias AssocType = SomeAssoc
|
|
typealias AssocWithReqt = ConformingAssoc
|
|
func assocTypesMethod(x: SomeAssoc, y: ConformingAssoc)
|
|
static func staticMethod(x: InheritedConformance)
|
|
func inheritedMethod()
|
|
}
|
|
|
|
// CHECK-LABEL: sil_witness_table public_external InheritedConformance: InheritedProtocol1 module
|
|
// CHECK: base_protocol AnyProtocol: InheritedConformance: AnyProtocol module
|
|
// CHECK: }
|
|
sil_witness_table InheritedConformance: InheritedProtocol1 module witness_tables {
|
|
base_protocol AnyProtocol: InheritedConformance: AnyProtocol module witness_tables
|
|
}
|
|
|
|
// CHECK-LABEL: sil_witness_table public_external InheritedConformance: AnyProtocol module
|
|
// CHECK: associated_type AssocType: SomeAssoc
|
|
// CHECK: associated_type_protocol (AssocWithReqt: AssocReqt): ConformingAssoc: AssocReqt module
|
|
// CHECK: }
|
|
sil_witness_table InheritedConformance: AnyProtocol module witness_tables {
|
|
associated_type AssocType: SomeAssoc
|
|
associated_type_protocol (AssocWithReqt: AssocReqt): ConformingAssoc: AssocReqt module witness_tables
|
|
}
|
|
|
|
sil [transparent] @_TF9def_basic13serialize_allFT_T_ : $@thin () -> () {
|
|
bb0:
|
|
%0 = function_ref @_TFV18lazy_global_access4Type10staticPropSia_public : $@thin () -> Builtin.RawPointer
|
|
%1 = function_ref @_TFV18lazy_global_access4Type10staticPropSia : $@thin () -> Builtin.RawPointer
|
|
%2 = function_ref @test1 : $@thin () -> ()
|
|
%4 = function_ref @test2 : $@thin (Int) -> ()
|
|
%6 = function_ref @named_tuple : $@thin () -> (Builtin.Word, Builtin.Word)
|
|
%9 = function_ref @return_int : $@thin (Int) -> Int
|
|
%11 = function_ref @call_fn_pointer : $@thin (() -> Int) -> Int
|
|
%13 = function_ref @return_constant : $@thin () -> Int
|
|
%23 = function_ref @existentials : $@thin (@in P) -> ()
|
|
%25 = function_ref @classes : $@thin () -> ()
|
|
%27 = function_ref @_TF4todo18erasure_from_protoFT1xPS_8RuncibleS_8Bendable__PS0__ : $@thin (@out Runcible, @in protocol<Bendable, Runcible>) -> ()
|
|
%29 = function_ref @_TF4todo18class_bound_methodFT1xPS_10ClassBound__T_ : $@thin (@owned ClassBound) -> ()
|
|
%31 = function_ref @_TFV6struct5AlephCfMS0_FT1aCS_3Ref1bVS_3Val_S0_ : $@thin (Ref, Val, @thin Aleph.Type) -> Aleph
|
|
%33 = function_ref @_TFV6struct5AlephCfMS0_FT_S0_ : $@thin (@thin Aleph.Type) -> Aleph
|
|
%35 = function_ref @test_union_empty_case : $@thin () -> Beth
|
|
%37 = function_ref @test_union_data_case : $@thin Int -> Beth
|
|
%39 = function_ref @test_union_addr_empty_case : $@thin (@out Gimel) -> ()
|
|
%41 = function_ref @test_union_addr_data_case : $@thin (@out Gimel, @in Q) -> ()
|
|
%43 = function_ref @_TF5tuple5floatFT1xSf_T_ : $@thin (Float32) -> ()
|
|
%45 = function_ref @_TF5tuple5tupleFT_TSiSf_ : $@thin () -> (Int, Float32)
|
|
%47 = function_ref @_TF5tuple13tuple_elementFT1xTSiSf__T_ : $@thin (Int, Float32) -> ()
|
|
%49 = function_ref @_TFC3ref1C3foofS0_FT1xSi_T_ : $@cc(method) @thin (Int, M) -> ()
|
|
%51 = function_ref @_TF4null3isaFT1bCS_1B_Sb : $@thin (B) -> Builtin.Int1
|
|
%53 = function_ref @_TFSd31_convertFromBuiltinFloatLiteralfMSdFT5valueBf64__Sd : $@thin (Builtin.FPIEEE64, @thin Float64.Type) -> Float64
|
|
%55 = function_ref @_TFSS32_convertFromBuiltinStringLiteralfMSSFT5valueBp8byteSizeBi64_7isASCIIBi1__SS : $@thin (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> String
|
|
%57 = function_ref @_TF7literal8literalsFT_T_ : $@thin () -> ()
|
|
%59 = function_ref @_TF5index5gep64FT1pBp1iBi64__Bp : $@thin (Builtin.RawPointer, Builtin.Word) -> Builtin.RawPointer
|
|
%60 = function_ref @global_code : $@thin () -> ()
|
|
%63 = function_ref @test_class_metatype : $@thin (SomeClass, SomeSubclass) -> (@thick SomeClass.Type, @thick SomeClass.Type)
|
|
%67 = function_ref @test_existential_metatype : $@thin (@in SomeProtocol) -> @thick SomeProtocol.Type
|
|
%69 = function_ref @test_unreachable : $@thin () -> ()
|
|
%71 = function_ref @test_unowned_retain : $@thin (SomeClass) -> ()
|
|
%73 = function_ref @test_basic_block_arguments : $@thin (Builtin.Int1) -> Builtin.Word
|
|
%75 = function_ref @test_cond_branch_basic_block_args : $@thin (Int, Builtin.Int1) -> Int
|
|
|
|
%77 = function_ref @test_autorelease_return : $@cc(objc_method) @thin (Bas) -> NSString
|
|
%79 = function_ref @test_super_method : $@cc(method) @thin (Bas) -> Bas
|
|
%81 = function_ref @test_builtin_func_ref : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1
|
|
%83 = function_ref @test_dealloc_ref : $@thin () -> ()
|
|
%85 = function_ref @test_dealloc_box : $@thin () -> ()
|
|
%87 = function_ref @closure_test : $@thin () -> ()
|
|
%97 = function_ref @test_switch_union : $@thin (MaybePair) -> ()
|
|
%99 = function_ref @test_switch_union_addr : $@thin (@in MaybeAddressOnlyPair) -> ()
|
|
%101 = function_ref @test_switch_int : $@thin (Builtin.Word) -> ()
|
|
%103 = function_ref @test_init_existential : $@thin (@out Bendable, Spoon) -> ()
|
|
%105 = function_ref @test_existential_ref : $@thin (ConcreteClass) -> ClassP
|
|
|
|
%107 = function_ref @test_assign : $@thin (Int, @inout Int) -> ()
|
|
%109 = function_ref @test_transparent : $@thin () -> ()
|
|
%130 = function_ref @noinline_callee : $@thin () -> Int
|
|
%131 = function_ref @test_semantics : $@thin () -> ()
|
|
%111 = function_ref @test_partial_apply : $@thin Float32 -> @callee_owned Int -> ()
|
|
%113 = function_ref @test_dynamic_lookup_br : $@thin (AnyObject) -> ()
|
|
%115 = function_ref @test_mark_fn_escape : $@thin () -> ()
|
|
%117 = function_ref @test_copy_release_value : $@thin (X) -> (X)
|
|
%118 = function_ref @cond_fail_test : $@thin Builtin.Int1 -> ()
|
|
|
|
%124 = function_ref @block_storage_type : $@thin Int -> @cc(cdecl) @objc_block () -> ()
|
|
%125 = function_ref @metatype_to_object : $@thin (@objc_metatype SomeClass.Type, @objc_metatype SomeClassProtocol.Type) -> @owned (AnyObject, AnyObject)
|
|
%127 = function_ref @bitcasts : $@thin (@owned Class1) -> @owned (Class2, Int)
|
|
%126 = function_ref @protocol_conversion : $@thin () -> @owned Protocol
|
|
%120 = function_ref @test_forward_ref : $@thin (UInt8, UInt8) -> UInt8
|
|
%121 = function_ref @partial_apply : $@thin (@thin (@out Int, Int) -> (), Int) -> Int
|
|
%122 = function_ref @partial_apply_with_closure : $@thin (@owned @callee_owned () -> Bool, @owned String, CString, Int64) -> ()
|
|
%123 = function_ref @extract_generic_struct : $@thin GenericStruct<Int64> -> Int64
|
|
|
|
%119 = tuple ()
|
|
return %119 : $()
|
|
}
|
|
|