1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
// RUN: %empty-directory(%t)
// RUN: %target-build-swift-dylib(%t/%target-library-name(PrintShims)) %S/../../Inputs/print-shims.swift -module-name PrintShims -emit-module -emit-module-path %t/PrintShims.swiftmodule
// RUN: %target-codesign %t/%target-library-name(PrintShims)
// RUN: %target-build-swift -g -parse-sil %s -emit-ir -I %t -L %t -lPrintShim | %FileCheck %s --check-prefix=CHECK-LL
// RUN: %target-build-swift -g -parse-sil %s -module-name main -o %t/main -I %t -L %t -lPrintShims %target-rpath(%t)
// RUN: %target-codesign %t/main
// RUN: %target-run %t/main %t/%target-library-name(PrintShims) | %FileCheck %s
// REQUIRES: executable_test
// REQUIRES: swift_test_mode_optimize_none
// REQUIRES: concurrency
// REQUIRES: concurrency_runtime
// UNSUPPORTED: back_deployment_runtime
import Builtin
import Swift
import PrintShims
import _Concurrency
sil public_external @printGeneric : $@convention(thin) <T> (@in_guaranteed T) -> ()
struct A1 {
let b: () -> ()
}
struct A2<T> {
let a: T
}
class A3 {}
sil_vtable A3 {}
sil @printA2AtA3 : $@convention(thin) (A2<A3>) -> () {
entry(%value : $A2<A3>):
%addr = alloc_stack $A2<A3>
store %value to %addr : $*A2<A3>
%printGeneric = function_ref @printGeneric : $@convention(thin) <T> (@in_guaranteed T) -> ()
%result = apply %printGeneric<A2<A3>>(%addr) : $@convention(thin) <T> (@in_guaranteed T) -> ()
dealloc_stack %addr : $*A2<A3>
return %result : $()
}
// CHECK-LL: @amethodTu =
// CHECK-LL: @repoTu =
// CHECK-LL: define{{( dllexport)?}}{{( protected)?}} swift{{(tail)?}}cc void @amethod(
sil @amethod : $@async @convention(method) (@in_guaranteed A2<A3>) -> (@owned A1, @error Error) {
entry(%a2_at_a3_addr : $*A2<A3>):
%a2_at_a3 = load %a2_at_a3_addr : $*A2<A3>
%printA2AtA3 = function_ref @printA2AtA3 : $@convention(thin) (A2<A3>) -> ()
%partiallyApplied = partial_apply [callee_guaranteed] %printA2AtA3(%a2_at_a3) : $@convention(thin) (A2<A3>) -> ()
%result = struct $A1 ( %partiallyApplied : $@callee_guaranteed () -> () )
return %result : $A1
}
// CHECK-LL: define{{( dllexport)?}}{{( protected)?}} swift{{(tail)?}}cc void @repo(
// CHECK-LL: define internal swift{{(tail)?}}cc void @"$s7amethodTA"(
sil @repo : $@async @convention(thin) (@in_guaranteed A2<A3>) -> @owned @async @callee_guaranteed () -> (@owned A1, @error Error) {
bb0(%0 : $*A2<A3>):
%1 = load %0 : $*A2<A3>
%2 = alloc_stack $A2<A3>
store %1 to %2 : $*A2<A3>
%4 = function_ref @amethod : $@async @convention(method) (@in_guaranteed A2<A3>) -> (@owned A1, @error Error)
%5 = partial_apply [callee_guaranteed] %4(%2) : $@async @convention(method) (@in_guaranteed A2<A3>) -> (@owned A1, @error Error)
dealloc_stack %2 : $*A2<A3>
return %5 : $@async @callee_guaranteed () -> (@owned A1, @error Error)
}
sil @test_case : $@convention(thin) @async () -> () {
%a3 = alloc_ref $A3
%a2 = struct $A2<A3> (%a3 : $A3)
%a2_addr = alloc_stack $A2<A3>
store %a2 to %a2_addr : $*A2<A3>
%callee = function_ref @repo : $@async @convention(thin) (@in_guaranteed A2<A3>) -> @owned @async @callee_guaranteed () -> (@owned A1, @error Error)
%partiallyApplied = apply %callee(%a2_addr) : $@async @convention(thin) (@in_guaranteed A2<A3>) -> @owned @async @callee_guaranteed () -> (@owned A1, @error Error)
try_apply %partiallyApplied() : $@async @callee_guaranteed () -> (@owned A1, @error Error), normal bb_success, error bb_error
bb_success(%value : $A1):
%value_addr = alloc_stack $A1
store %value to %value_addr : $*A1
%printGeneric = function_ref @printGeneric : $@convention(thin) <T> (@in_guaranteed T) -> ()
%result = apply %printGeneric<A1>(%value_addr) : $@convention(thin) <T> (@in_guaranteed T) -> () // CHECK: A1(b: (Function))
%closure = struct_extract %value : $A1, #A1.b
%closure_result = apply %closure() : $@callee_guaranteed () -> () // CHECK: A2<A3>(a: main.A3)
dealloc_stack %value_addr : $*A1
br bb_finish
bb_error(%error : $Error):
br bb_finish
bb_finish:
dealloc_stack %a2_addr : $*A2<A3>
%void = tuple()
return %void : $()
}
// Defined in _Concurrency
sil @$ss13_runAsyncMainyyyyYaKcF : $@convention(thin) (@guaranteed @async @callee_guaranteed () -> @error Error) -> ()
sil @no_throw_to_throw_think : $@convention(thin) @async (@guaranteed @async @callee_guaranteed () -> ()) -> @error Error {
bb0(%0 :$@async @callee_guaranteed () -> ()):
%void = apply %0() : $@async @callee_guaranteed () -> ()
return %void : $()
}
// main
sil @main : $@convention(c) () -> Int32 {
%test_case_nothrow = function_ref @test_case : $@convention(thin) @async () -> ()
%thick_test_case = thin_to_thick_function %test_case_nothrow : $@convention(thin) @async () -> () to $@callee_guaranteed @async () -> ()
%thunk = function_ref @no_throw_to_throw_think : $@convention(thin) @async (@guaranteed @async @callee_guaranteed () -> ()) -> @error Error
%throwing = partial_apply [callee_guaranteed] %thunk(%thick_test_case) : $@convention(thin) @async (@guaranteed @async @callee_guaranteed () -> ()) -> @error Error
%runAsyncMain = function_ref @$ss13_runAsyncMainyyyyYaKcF : $@convention(thin) (@guaranteed @async @callee_guaranteed () -> @error Error) -> ()
%result = apply %runAsyncMain(%throwing) : $@convention(thin) (@guaranteed @async @callee_guaranteed () -> @error Error) -> ()
%out_literal = integer_literal $Builtin.Int32, 0
%out = struct $Int32 (%out_literal : $Builtin.Int32)
return %out : $Int32
}
|
