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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
| ; RUN: opt < %s -inline-threshold=0 -always-inline -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-CALL
;
; Ensure the threshold has no impact on these decisions.
; RUN: opt < %s -inline-threshold=20000000 -always-inline -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-CALL
; RUN: opt < %s -inline-threshold=-20000000 -always-inline -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-CALL
;
; The new pass manager doesn't re-use any threshold based infrastructure for
; the always inliner, but test that we get the correct result. The new PM
; always inliner also doesn't support inlining call-site alwaysinline
; annotations. It isn't clear that this is a reasonable use case for
; 'alwaysinline'.
; RUN: opt < %s -passes=always-inline -S | FileCheck %s --check-prefix=CHECK
define internal i32 @inner1() alwaysinline {
; CHECK-NOT: @inner1(
ret i32 1
}
define i32 @outer1() {
; CHECK-LABEL: @outer1(
; CHECK-NOT: call
; CHECK: ret
%r = call i32 @inner1()
ret i32 %r
}
; The always inliner can't DCE arbitrary internal functions. PR2945
define internal i32 @pr2945() nounwind {
; CHECK-LABEL: @pr2945(
ret i32 0
}
define internal void @inner2(i32 %N) alwaysinline {
; CHECK-NOT: @inner2(
%P = alloca i32, i32 %N
ret void
}
define void @outer2(i32 %N) {
; The always inliner (unlike the normal one) should be willing to inline
; a function with a dynamic alloca into one without a dynamic alloca.
; rdar://6655932
;
; CHECK-LABEL: @outer2(
; CHECK-NOT: call void @inner2
; CHECK-NOT: call void @inner2
; CHECK: ret void
call void @inner2( i32 %N )
ret void
}
declare i32 @a() returns_twice
declare i32 @b() returns_twice
; Cannot alwaysinline when that would introduce a returns_twice call.
define internal i32 @inner3() alwaysinline {
; CHECK-LABEL: @inner3(
entry:
%call = call i32 @a() returns_twice
%add = add nsw i32 1, %call
ret i32 %add
}
define i32 @outer3() {
entry:
; CHECK-LABEL: @outer3(
; CHECK-NOT: call i32 @a
; CHECK: ret
%call = call i32 @inner3()
%add = add nsw i32 1, %call
ret i32 %add
}
define internal i32 @inner4() alwaysinline returns_twice {
; CHECK-NOT: @inner4(
entry:
%call = call i32 @b() returns_twice
%add = add nsw i32 1, %call
ret i32 %add
}
define i32 @outer4() {
entry:
; CHECK-LABEL: @outer4(
; CHECK: call i32 @b()
; CHECK: ret
%call = call i32 @inner4() returns_twice
%add = add nsw i32 1, %call
ret i32 %add
}
; We can't inline this even though it has alwaysinline!
define internal i32 @inner5(i8* %addr) alwaysinline {
; CHECK-LABEL: @inner5(
entry:
indirectbr i8* %addr, [ label %one, label %two ]
one:
ret i32 42
two:
ret i32 44
}
define i32 @outer5(i32 %x) {
; CHECK-LABEL: @outer5(
; CHECK: call i32 @inner5
; CHECK: ret
%cmp = icmp slt i32 %x, 42
%addr = select i1 %cmp, i8* blockaddress(@inner5, %one), i8* blockaddress(@inner5, %two)
%call = call i32 @inner5(i8* %addr)
ret i32 %call
}
; We alwaysinline a function that call itself recursively.
define internal void @inner6(i32 %x) alwaysinline {
; CHECK-LABEL: @inner6(
entry:
%icmp = icmp slt i32 %x, 0
br i1 %icmp, label %return, label %bb
bb:
%sub = sub nsw i32 %x, 1
call void @inner6(i32 %sub)
ret void
return:
ret void
}
define void @outer6() {
; CHECK-LABEL: @outer6(
; CHECK: call void @inner6(i32 42)
; CHECK: ret
entry:
call void @inner6(i32 42)
ret void
}
; This is not an alwaysinline function and is actually external.
define i32 @inner7() {
; CHECK-LABEL: @inner7(
ret i32 1
}
define i32 @outer7() {
; CHECK-CALL-LABEL: @outer7(
; CHECK-CALL-NOT: call
; CHECK-CALL: ret
%r = call i32 @inner7() alwaysinline
ret i32 %r
}
define internal float* @inner8(float* nocapture align 128 %a) alwaysinline {
; CHECK-NOT: @inner8(
ret float* %a
}
define float @outer8(float* nocapture %a) {
; CHECK-LABEL: @outer8(
; CHECK-NOT: call float* @inner8
; CHECK: ret
%inner_a = call float* @inner8(float* %a)
%f = load float, float* %inner_a, align 4
ret float %f
}
; The 'inner9*' and 'outer9' functions are designed to check that we remove
; a function that is inlined by the always inliner even when it is used by
; a complex constant expression prior to being inlined.
; The 'a' function gets used in a complex constant expression that, despite
; being constant folded, means it isn't dead. As a consequence it shouldn't be
; deleted. If it is, then the constant expression needs to become more complex
; to accurately test this scenario.
define internal void @inner9a(i1 %b) alwaysinline {
; CHECK-LABEL: @inner9a(
entry:
ret void
}
define internal void @inner9b(i1 %b) alwaysinline {
; CHECK-NOT: @inner9b(
entry:
ret void
}
declare void @dummy9(i1 %b)
define void @outer9() {
; CHECK-LABEL: @outer9(
entry:
; First we use @inner9a in a complex constant expression that may get folded
; but won't get removed, and then we call it which will get inlined. Despite
; this the function can't be deleted because of the constant expression
; usage.
%sink = alloca i1
store volatile i1 icmp eq (i64 ptrtoint (void (i1)* @inner9a to i64), i64 ptrtoint(void (i1)* @dummy9 to i64)), i1* %sink
; CHECK: store volatile
call void @inner9a(i1 false)
; CHECK-NOT: call void @inner9a
; Next we call @inner9b passing in a constant expression. This constant
; expression will in fact be removed by inlining, so we should also be able
; to delete the function.
call void @inner9b(i1 icmp eq (i64 ptrtoint (void (i1)* @inner9b to i64), i64 ptrtoint(void (i1)* @dummy9 to i64)))
; CHECK-NOT: @inner9b
ret void
; CHECK: ret void
}
; The 'inner10' and 'outer10' functions test a frustrating consquence of the
; current 'alwaysinline' semantic model. Because such functions are allowed to
; be external functions, it may be necessary to both inline all of their uses
; and leave them in the final output. These tests can be removed if and when
; we restrict alwaysinline further.
define void @inner10() alwaysinline {
; CHECK-LABEL: @inner10(
entry:
ret void
}
define void @outer10() {
; CHECK-LABEL: @outer10(
entry:
call void @inner10()
; CHECK-NOT: call void @inner10
ret void
; CHECK: ret void
}
; The 'inner11' and 'outer11' functions test another dimension of non-internal
; functions with alwaysinline. These functions use external linkages that we can
; actually remove safely and so we should.
define linkonce void @inner11a() alwaysinline {
; CHECK-NOT: @inner11a(
entry:
ret void
}
define available_externally void @inner11b() alwaysinline {
; CHECK-NOT: @inner11b(
entry:
ret void
}
define void @outer11() {
; CHECK-LABEL: @outer11(
entry:
call void @inner11a()
call void @inner11b()
; CHECK-NOT: call void @inner11a
; CHECK-NOT: call void @inner11b
ret void
; CHECK: ret void
}
; The 'inner12' and 'outer12' functions test that we don't remove functions
; which are part of a comdat group even if they otherwise seem dead.
$comdat12 = comdat any
define linkonce void @inner12() alwaysinline comdat($comdat12) {
; CHECK-LABEL: @inner12(
ret void
}
define void @outer12() comdat($comdat12) {
; CHECK-LABEL: @outer12(
entry:
call void @inner12()
; CHECK-NOT: call void @inner12
ret void
; CHECK: ret void
}
; The 'inner13*' and 'outer13' functions test that we do remove functions
; which are part of a comdat group where all of the members are removed during
; always inlining.
$comdat13 = comdat any
define linkonce void @inner13a() alwaysinline comdat($comdat13) {
; CHECK-NOT: @inner13a(
ret void
}
define linkonce void @inner13b() alwaysinline comdat($comdat13) {
; CHECK-NOT: @inner13b(
ret void
}
define void @outer13() {
; CHECK-LABEL: @outer13(
entry:
call void @inner13a()
call void @inner13b()
; CHECK-NOT: call void @inner13a
; CHECK-NOT: call void @inner13b
ret void
; CHECK: ret void
}
define void @inner14() readnone nounwind {
; CHECK: define void @inner14
ret void
}
define void @outer14() {
; CHECK: call void @inner14
call void @inner14()
ret void
}
|