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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
// RUN: %target-sil-opt -sil-print-debuginfo -enable-sil-verify-all -deadobject-elim %s | %FileCheck %s
// Linux doesn't have the same symbol name for _ArrayBuffer, which is part of
// the ObjC runtime interop. Use `_ContiguousArrayBuffer instead.
// REQUIRES: objc_interop
import Swift
import Builtin
//////////
// Data //
//////////
class TrivialDestructor {
var int : Builtin.Int32
var ptr : Builtin.NativeObject
init()
deinit { }
}
// Remove a dead array.
// rdar://20980377 Add dead array elimination to DeadObjectElimination
// Swift._allocateUninitializedArray <A> (Builtin.Word) -> (Swift.Array<A>, Builtin.RawPointer)
sil [_semantics "array.uninitialized_intrinsic"] @allocArray : $@convention(thin) <τ_0_0> (Builtin.Word) -> @owned (Array<τ_0_0>, Builtin.RawPointer)
sil [_semantics "array.uninitialized"] @adoptStorageSpecializedForInt : $@convention(method) (@guaranteed _ContiguousArrayStorage<Int>, Builtin.Word, @thin Array<Int>.Type) -> (@owned Array<Int>, UnsafeMutablePointer<Int>)
sil [_semantics "array.finalize_intrinsic"] @finalize : $@convention(thin) (@owned Array<Int>) -> @owned Array<Int>
// CHECK-LABEL: sil [ossa] @deadarrayWithAdoptStorage : $@convention(thin) () -> () {
// CHECK-NOT: apply
// CHECK: } // end sil function 'deadarrayWithAdoptStorage'
sil [ossa] @deadarrayWithAdoptStorage : $@convention(thin) () -> () {
bb0:
%0 = integer_literal $Builtin.Word, 3
%6 = alloc_ref [tail_elems $Int * %0 : $Builtin.Word] $_ContiguousArrayStorage<Int>
%7 = metatype $@thin Array<Int>.Type
%8 = function_ref @adoptStorageSpecializedForInt : $@convention(method) (@guaranteed _ContiguousArrayStorage<Int>, Builtin.Word, @thin Array<Int>.Type) -> (@owned Array<Int>, UnsafeMutablePointer<Int>)
%9 = apply %8(%6, %0, %7) : $@convention(method) (@guaranteed _ContiguousArrayStorage<Int>, Builtin.Word, @thin Array<Int>.Type) -> (@owned Array<Int>, UnsafeMutablePointer<Int>)
(%10, %11) = destructure_tuple %9 : $(Array<Int>, UnsafeMutablePointer<Int>)
%f = function_ref @finalize : $@convention(thin) (@owned Array<Int>) -> @owned Array<Int>
%a = apply %f(%10) : $@convention(thin) (@owned Array<Int>) -> @owned Array<Int>
fix_lifetime %a : $Array<Int>
destroy_value %a : $Array<Int>
dealloc_ref %6 : $_ContiguousArrayStorage<Int>
%9999 = tuple()
return %9999 : $()
}
// CHECK-LABEL: sil [ossa] @deadarray :
// CHECK-NOT: apply
// CHECK-NOT: store
// CHECK-LABEL: } // end sil function 'deadarray'
sil [ossa] @deadarray : $@convention(thin) (@owned TrivialDestructor) -> () {
bb0(%0 : @owned $TrivialDestructor):
%copy0 = copy_value %0 : $TrivialDestructor
%2 = integer_literal $Builtin.Word, 2
%3 = function_ref @allocArray : $@convention(thin) <τ_0_0> (Builtin.Word) -> @owned (Array<τ_0_0>, Builtin.RawPointer)
%4 = apply %3<TrivialDestructor>(%2) : $@convention(thin) <τ_0_0> (Builtin.Word) -> @owned (Array<τ_0_0>, Builtin.RawPointer)
(%5, %6) = destructure_tuple %4 : $(Array<TrivialDestructor>, Builtin.RawPointer)
%7 = pointer_to_address %6 : $Builtin.RawPointer to [strict] $*TrivialDestructor
store %0 to [init] %7 : $*TrivialDestructor
%9 = integer_literal $Builtin.Word, 1
%10 = index_addr %7 : $*TrivialDestructor, %9 : $Builtin.Word
store %copy0 to [init] %10 : $*TrivialDestructor
destroy_value %5 : $Array<TrivialDestructor>
%18 = tuple ()
return %18 : $()
}
// CHECK-LABEL: sil [ossa] @not_all_paths_release_the_dead_array :
// CHECK-NOT: apply
//} // end sil function 'not_all_paths_release_the_dead_array'
sil [ossa] @not_all_paths_release_the_dead_array : $@convention(thin) (@owned TrivialDestructor) -> () {
bb0(%0 : @owned $TrivialDestructor):
%2 = integer_literal $Builtin.Word, 2
// function_ref Swift._allocateUninitializedArray <A> (Builtin.Word) -> (Swift.Array<A>, Builtin.RawPointer)
%3 = function_ref @allocArray : $@convention(thin) <τ_0_0> (Builtin.Word) -> @owned (Array<τ_0_0>, Builtin.RawPointer)
%4 = apply %3<TrivialDestructor>(%2) : $@convention(thin) <τ_0_0> (Builtin.Word) -> @owned (Array<τ_0_0>, Builtin.RawPointer)
(%5, %6) = destructure_tuple %4 : $(Array<TrivialDestructor>, Builtin.RawPointer)
cond_br undef, bb1, bb2
bb1:
unreachable
bb2:
%7 = pointer_to_address %6 : $Builtin.RawPointer to [strict] $*TrivialDestructor
store %0 to [init] %7 : $*TrivialDestructor
destroy_value %5 : $Array<TrivialDestructor>
%18 = tuple ()
return %18 : $()
}
// CHECK-LABEL: sil [ossa] @tuple_extract_in_different_block :
// CHECK-NOT: apply
// CHECK-LABEL: } // end sil function 'tuple_extract_in_different_block'
sil [ossa] @tuple_extract_in_different_block : $@convention(thin) (@owned TrivialDestructor) -> () {
bb0(%0 : @owned $TrivialDestructor):
%2 = integer_literal $Builtin.Word, 2
// function_ref Swift._allocateUninitializedArray <A> (Builtin.Word) -> (Swift.Array<A>, Builtin.RawPointer)
%3 = function_ref @allocArray : $@convention(thin) <τ_0_0> (Builtin.Word) -> @owned (Array<τ_0_0>, Builtin.RawPointer)
%4 = apply %3<TrivialDestructor>(%2) : $@convention(thin) <τ_0_0> (Builtin.Word) -> @owned (Array<τ_0_0>, Builtin.RawPointer)
br bb1
bb1:
(%5, %6) = destructure_tuple %4 : $(Array<TrivialDestructor>, Builtin.RawPointer)
%7 = pointer_to_address %6 : $Builtin.RawPointer to [strict] $*TrivialDestructor
store %0 to [init] %7 : $*TrivialDestructor
destroy_value %5 : $Array<TrivialDestructor>
%18 = tuple ()
return %18 : $()
}
// CHECK-LABEL: sil [ossa] @release_dead_array_on_two_branches :
// CHECK-NOT: apply
// CHECK-LABEL: } // end sil function 'release_dead_array_on_two_branches'
sil [ossa] @release_dead_array_on_two_branches : $@convention(thin) (@owned TrivialDestructor, @owned TrivialDestructor) -> () {
bb0(%0 : @owned $TrivialDestructor, %1 : @owned $TrivialDestructor):
%2 = integer_literal $Builtin.Word, 2
// function_ref Swift._allocateUninitializedArray <A> (Builtin.Word) -> (Swift.Array<A>, Builtin.RawPointer)
%3 = function_ref @allocArray : $@convention(thin) <τ_0_0> (Builtin.Word) -> @owned (Array<τ_0_0>, Builtin.RawPointer)
%4 = apply %3<TrivialDestructor>(%2) : $@convention(thin) <τ_0_0> (Builtin.Word) -> @owned (Array<τ_0_0>, Builtin.RawPointer)
(%5, %6) = destructure_tuple %4 : $(Array<TrivialDestructor>, Builtin.RawPointer)
%7 = pointer_to_address %6 : $Builtin.RawPointer to [strict] $*TrivialDestructor
cond_br undef, bb1, bb2
bb1:
store %0 to [init] %7 : $*TrivialDestructor
destroy_value %1 : $TrivialDestructor
destroy_value %5 : $Array<TrivialDestructor>
br bb3
bb2:
store %1 to [init] %7 : $*TrivialDestructor
destroy_value %0 : $TrivialDestructor
destroy_value %5 : $Array<TrivialDestructor>
br bb3
bb3:
%18 = tuple ()
return %18 : $()
}
// CHECK-LABEL: sil [ossa] @dead_array_in_single_cycle_loop
// CHECK-NOT: apply
// CHECK-LABEL: } // end sil function 'dead_array_in_single_cycle_loop'
sil [ossa] @dead_array_in_single_cycle_loop : $@convention(thin) (@guaranteed TrivialDestructor) -> () {
bb0(%0 : @guaranteed $TrivialDestructor):
br bb1
bb1:
%2 = integer_literal $Builtin.Word, 2
%3 = function_ref @allocArray : $@convention(thin) <τ_0_0> (Builtin.Word) -> @owned (Array<τ_0_0>, Builtin.RawPointer)
%4 = apply %3<TrivialDestructor>(%2) : $@convention(thin) <τ_0_0> (Builtin.Word) -> @owned (Array<τ_0_0>, Builtin.RawPointer)
(%5, %6) = destructure_tuple %4 : $(Array<TrivialDestructor>, Builtin.RawPointer)
%7 = pointer_to_address %6 : $Builtin.RawPointer to [strict] $*TrivialDestructor
%copy0 = copy_value %0 : $TrivialDestructor
store %copy0 to [init] %7 : $*TrivialDestructor
destroy_value %5 : $Array<TrivialDestructor>
cond_br undef, bb3, bb2
bb3:
br bb1
bb2:
%18 = tuple ()
return %18 : $()
}
|
