81cbb73fbf59ddfda57fcd57eec77c87270f4103
[lldb.git] / llvm / test / Transforms / Inline / always-inline.ll
1 ; RUN: opt < %s -inline-threshold=0 -always-inline -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-CALL
2 ;
3 ; Ensure the threshold has no impact on these decisions.
4 ; RUN: opt < %s -inline-threshold=20000000 -always-inline -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-CALL
5 ; RUN: opt < %s -inline-threshold=-20000000 -always-inline -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-CALL
6 ;
7 ; The new pass manager doesn't re-use any threshold based infrastructure for
8 ; the always inliner, but test that we get the correct result. The new PM
9 ; always inliner also doesn't support inlining call-site alwaysinline
10 ; annotations. It isn't clear that this is a reasonable use case for
11 ; 'alwaysinline'.
12 ; RUN: opt < %s -passes=always-inline -S | FileCheck %s --check-prefix=CHECK
13
14 define internal i32 @inner1() alwaysinline {
15 ; CHECK-NOT: @inner1(
16   ret i32 1
17 }
18 define i32 @outer1() {
19 ; CHECK-LABEL: @outer1(
20 ; CHECK-NOT: call
21 ; CHECK: ret
22
23    %r = call i32 @inner1()
24    ret i32 %r
25 }
26
27 ; The always inliner can't DCE arbitrary internal functions. PR2945
28 define internal i32 @pr2945() nounwind {
29 ; CHECK-LABEL: @pr2945(
30   ret i32 0
31 }
32
33 define internal void @inner2(i32 %N) alwaysinline {
34 ; CHECK-NOT: @inner2(
35   %P = alloca i32, i32 %N
36   ret void
37 }
38 define void @outer2(i32 %N) {
39 ; The always inliner (unlike the normal one) should be willing to inline
40 ; a function with a dynamic alloca into one without a dynamic alloca.
41 ; rdar://6655932
42 ;
43 ; CHECK-LABEL: @outer2(
44 ; CHECK-NOT: call void @inner2
45 ; CHECK-NOT: call void @inner2
46 ; CHECK: ret void
47
48   call void @inner2( i32 %N )
49   ret void
50 }
51
52 declare i32 @a() returns_twice
53 declare i32 @b() returns_twice
54
55 ; Cannot alwaysinline when that would introduce a returns_twice call.
56 define internal i32 @inner3() alwaysinline {
57 ; CHECK-LABEL: @inner3(
58 entry:
59   %call = call i32 @a() returns_twice
60   %add = add nsw i32 1, %call
61   ret i32 %add
62 }
63 define i32 @outer3() {
64 entry:
65 ; CHECK-LABEL: @outer3(
66 ; CHECK-NOT: call i32 @a
67 ; CHECK: ret
68
69   %call = call i32 @inner3()
70   %add = add nsw i32 1, %call
71   ret i32 %add
72 }
73
74 define internal i32 @inner4() alwaysinline returns_twice {
75 ; CHECK-NOT: @inner4(
76 entry:
77   %call = call i32 @b() returns_twice
78   %add = add nsw i32 1, %call
79   ret i32 %add
80 }
81
82 define i32 @outer4() {
83 entry:
84 ; CHECK-LABEL: @outer4(
85 ; CHECK: call i32 @b()
86 ; CHECK: ret
87
88   %call = call i32 @inner4() returns_twice
89   %add = add nsw i32 1, %call
90   ret i32 %add
91 }
92
93 ; We can't inline this even though it has alwaysinline!
94 define internal i32 @inner5(i8* %addr) alwaysinline {
95 ; CHECK-LABEL: @inner5(
96 entry:
97   indirectbr i8* %addr, [ label %one, label %two ]
98
99 one:
100   ret i32 42
101
102 two:
103   ret i32 44
104 }
105 define i32 @outer5(i32 %x) {
106 ; CHECK-LABEL: @outer5(
107 ; CHECK: call i32 @inner5
108 ; CHECK: ret
109
110   %cmp = icmp slt i32 %x, 42
111   %addr = select i1 %cmp, i8* blockaddress(@inner5, %one), i8* blockaddress(@inner5, %two)
112   %call = call i32 @inner5(i8* %addr)
113   ret i32 %call
114 }
115
116 ; We alwaysinline a function that call itself recursively.
117 define internal void @inner6(i32 %x) alwaysinline {
118 ; CHECK-LABEL: @inner6(
119 entry:
120   %icmp = icmp slt i32 %x, 0
121   br i1 %icmp, label %return, label %bb
122
123 bb:
124   %sub = sub nsw i32 %x, 1
125   call void @inner6(i32 %sub)
126   ret void
127
128 return:
129   ret void
130 }
131 define void @outer6() {
132 ; CHECK-LABEL: @outer6(
133 ; CHECK: call void @inner6(i32 42)
134 ; CHECK: ret
135
136 entry:
137   call void @inner6(i32 42)
138   ret void
139 }
140
141 ; This is not an alwaysinline function and is actually external.
142 define i32 @inner7() {
143 ; CHECK-LABEL: @inner7(
144   ret i32 1
145 }
146 define i32 @outer7() {
147 ; CHECK-CALL-LABEL: @outer7(
148 ; CHECK-CALL-NOT: call
149 ; CHECK-CALL: ret
150
151    %r = call i32 @inner7() alwaysinline
152    ret i32 %r
153 }
154
155 define internal float* @inner8(float* nocapture align 128 %a) alwaysinline {
156 ; CHECK-NOT: @inner8(
157   ret float* %a
158 }
159 define float @outer8(float* nocapture %a) {
160 ; CHECK-LABEL: @outer8(
161 ; CHECK-NOT: call float* @inner8
162 ; CHECK: ret
163
164   %inner_a = call float* @inner8(float* %a)
165   %f = load float, float* %inner_a, align 4
166   ret float %f
167 }
168
169
170 ; The 'inner9*' and 'outer9' functions are designed to check that we remove
171 ; a function that is inlined by the always inliner even when it is used by
172 ; a complex constant expression prior to being inlined.
173
174 ; The 'a' function gets used in a complex constant expression that, despite
175 ; being constant folded, means it isn't dead. As a consequence it shouldn't be
176 ; deleted. If it is, then the constant expression needs to become more complex
177 ; to accurately test this scenario.
178 define internal void @inner9a(i1 %b) alwaysinline {
179 ; CHECK-LABEL: @inner9a(
180 entry:
181   ret void
182 }
183
184 define internal void @inner9b(i1 %b) alwaysinline {
185 ; CHECK-NOT: @inner9b(
186 entry:
187   ret void
188 }
189
190 declare void @dummy9(i1 %b)
191
192 define void @outer9() {
193 ; CHECK-LABEL: @outer9(
194 entry:
195   ; First we use @inner9a in a complex constant expression that may get folded
196   ; but won't get removed, and then we call it which will get inlined. Despite
197   ; this the function can't be deleted because of the constant expression
198   ; usage.
199   %sink = alloca i1
200   store volatile i1 icmp eq (i64 ptrtoint (void (i1)* @inner9a to i64), i64 ptrtoint(void (i1)* @dummy9 to i64)), i1* %sink
201 ; CHECK: store volatile
202   call void @inner9a(i1 false)
203 ; CHECK-NOT: call void @inner9a
204
205   ; Next we call @inner9b passing in a constant expression. This constant
206   ; expression will in fact be removed by inlining, so we should also be able
207   ; to delete the function.
208   call void @inner9b(i1 icmp eq (i64 ptrtoint (void (i1)* @inner9b to i64), i64 ptrtoint(void (i1)* @dummy9 to i64)))
209 ; CHECK-NOT: @inner9b
210
211   ret void
212 ; CHECK: ret void
213 }
214
215 ; The 'inner10' and 'outer10' functions test a frustrating consequence of the
216 ; current 'alwaysinline' semantic model. Because such functions are allowed to
217 ; be external functions, it may be necessary to both inline all of their uses
218 ; and leave them in the final output. These tests can be removed if and when
219 ; we restrict alwaysinline further.
220 define void @inner10() alwaysinline {
221 ; CHECK-LABEL: @inner10(
222 entry:
223   ret void
224 }
225
226 define void @outer10() {
227 ; CHECK-LABEL: @outer10(
228 entry:
229   call void @inner10()
230 ; CHECK-NOT: call void @inner10
231
232   ret void
233 ; CHECK: ret void
234 }
235
236 ; The 'inner11' and 'outer11' functions test another dimension of non-internal
237 ; functions with alwaysinline. These functions use external linkages that we can
238 ; actually remove safely and so we should.
239 define linkonce void @inner11a() alwaysinline {
240 ; CHECK-NOT: @inner11a(
241 entry:
242   ret void
243 }
244
245 define available_externally void @inner11b() alwaysinline {
246 ; CHECK-NOT: @inner11b(
247 entry:
248   ret void
249 }
250
251 define void @outer11() {
252 ; CHECK-LABEL: @outer11(
253 entry:
254   call void @inner11a()
255   call void @inner11b()
256 ; CHECK-NOT: call void @inner11a
257 ; CHECK-NOT: call void @inner11b
258
259   ret void
260 ; CHECK: ret void
261 }
262
263 ; The 'inner12' and 'outer12' functions test that we don't remove functions
264 ; which are part of a comdat group even if they otherwise seem dead.
265 $comdat12 = comdat any
266
267 define linkonce void @inner12() alwaysinline comdat($comdat12) {
268 ; CHECK-LABEL: @inner12(
269   ret void
270 }
271
272 define void @outer12() comdat($comdat12) {
273 ; CHECK-LABEL: @outer12(
274 entry:
275   call void @inner12()
276 ; CHECK-NOT: call void @inner12
277
278   ret void
279 ; CHECK: ret void
280 }
281
282 ; The 'inner13*' and 'outer13' functions test that we do remove functions
283 ; which are part of a comdat group where all of the members are removed during
284 ; always inlining.
285 $comdat13 = comdat any
286
287 define linkonce void @inner13a() alwaysinline comdat($comdat13) {
288 ; CHECK-NOT: @inner13a(
289   ret void
290 }
291
292 define linkonce void @inner13b() alwaysinline comdat($comdat13) {
293 ; CHECK-NOT: @inner13b(
294   ret void
295 }
296
297 define void @outer13() {
298 ; CHECK-LABEL: @outer13(
299 entry:
300   call void @inner13a()
301   call void @inner13b()
302 ; CHECK-NOT: call void @inner13a
303 ; CHECK-NOT: call void @inner13b
304
305   ret void
306 ; CHECK: ret void
307 }
308
309 define void @inner14() readnone nounwind {
310 ; CHECK: define void @inner14
311   ret void
312 }
313
314 define void @outer14() {
315 ; CHECK: call void @inner14
316   call void @inner14()
317   ret void
318 }