Debian Codegraph @

llvm/test/Transforms/TailCallElim/basic.ll

raw
1 ; RUN: opt < %s -passes=tailcallelim -verify-dom-info -S | FileCheck %s
2
3 declare void @noarg()
4 declare void @use(ptr)
5 declare void @use_nocapture(ptr nocapture)
6 declare void @use2_nocapture(ptr nocapture, ptr nocapture)
7
8 ; Trivial case. Mark @noarg with tail call.
9 define void @test0() {
10 ; CHECK: tail call void @noarg()
11 call void @noarg()
12 ret void
13 }
14
15 ; Make sure that we do not do TRE if pointer to local stack
16 ; escapes through function call.
17 define i32 @test1() {
18 ; CHECK: i32 @test1()
19 ; CHECK-NEXT: alloca
20 %A = alloca i32 ; <ptr> [#uses=2]
21 store i32 5, ptr %A
22 call void @use(ptr %A)
23 ; CHECK: call i32 @test1
24 %X = call i32 @test1() ; <i32> [#uses=1]
25 ret i32 %X
26 }
27
28 ; This function contains intervening instructions which should be moved out of the way
29 define i32 @test2(i32 %X) {
30 ; CHECK: i32 @test2
31 ; CHECK-NOT: call
32 ; CHECK: ret i32
33 entry:
34 %tmp.1 = icmp eq i32 %X, 0 ; <i1> [#uses=1]
35 br i1 %tmp.1, label %then.0, label %endif.0
36 then.0: ; preds = %entry
37 %tmp.4 = add i32 %X, 1 ; <i32> [#uses=1]
38 ret i32 %tmp.4
39 endif.0: ; preds = %entry
40 %tmp.10 = add i32 %X, -1 ; <i32> [#uses=1]
41 %tmp.8 = call i32 @test2(i32 %tmp.10) ; <i32> [#uses=1]
42 %DUMMY = add i32 %X, 1 ; <i32> [#uses=0]
43 ret i32 %tmp.8
44 }
45
46 ; Though this case seems to be fairly unlikely to occur in the wild, someone
47 ; plunked it into the demo script, so maybe they care about it.
48 define i32 @test3(i32 %c) {
49 ; CHECK: i32 @test3
50 ; CHECK: tailrecurse:
51 ; CHECK: %ret.tr = phi i32 [ poison, %entry ], [ %current.ret.tr, %else ]
52 ; CHECK: %ret.known.tr = phi i1 [ false, %entry ], [ true, %else ]
53 ; CHECK: else:
54 ; CHECK-NOT: call
55 ; CHECK: %current.ret.tr = select i1 %ret.known.tr, i32 %ret.tr, i32 0
56 ; CHECK-NOT: ret
57 ; CHECK: return:
58 ; CHECK: %current.ret.tr1 = select i1 %ret.known.tr, i32 %ret.tr, i32 0
59 ; CHECK: ret i32 %current.ret.tr1
60 entry:
61 %tmp.1 = icmp eq i32 %c, 0 ; <i1> [#uses=1]
62 br i1 %tmp.1, label %return, label %else
63 else: ; preds = %entry
64 %tmp.5 = add i32 %c, -1 ; <i32> [#uses=1]
65 %tmp.3 = call i32 @test3(i32 %tmp.5) ; <i32> [#uses=0]
66 ret i32 0
67 return: ; preds = %entry
68 ret i32 0
69 }
70
71 ; Make sure that a nocapture pointer does not stop adding a tail call marker to
72 ; an unrelated call and additionally that we do not mark the nocapture call with
73 ; a tail call.
74 ;
75 ; rdar://14324281
76 define void @test4() {
77 ; CHECK: void @test4
78 ; CHECK-NOT: tail call void @use_nocapture
79 ; CHECK: tail call void @noarg()
80 ; CHECK: ret void
81 %a = alloca i32
82 call void @use_nocapture(ptr %a)
83 call void @noarg()
84 ret void
85 }
86
87 ; Make sure that we do not perform TRE even with a nocapture use. This is due to
88 ; bad codegen caused by PR962.
89 ;
90 ; rdar://14324281.
91 define ptr @test5(ptr nocapture %A, i1 %cond) {
92 ; CHECK: ptr @test5
93 ; CHECK-NOT: tailrecurse:
94 ; CHECK: ret ptr null
95 %B = alloca i32
96 br i1 %cond, label %cond_true, label %cond_false
97 cond_true:
98 call ptr @test5(ptr %B, i1 false)
99 ret ptr null
100 cond_false:
101 call void @use2_nocapture(ptr %A, ptr %B)
102 call void @noarg()
103 ret ptr null
104 }
105
106 ; PR14143: Make sure that we do not mark functions with nocapture allocas with tail.
107 ;
108 ; rdar://14324281.
109 define void @test6(ptr %a, ptr %b) {
110 ; CHECK-LABEL: @test6(
111 ; CHECK-NOT: tail call
112 ; CHECK: ret void
113 %c = alloca [100 x i8], align 16
114 call void @use2_nocapture(ptr %b, ptr %c)
115 ret void
116 }
117
118 ; PR14143: Make sure that we do not mark functions with nocapture allocas with tail.
119 ;
120 ; rdar://14324281
121 define void @test7(ptr %a, ptr %b) nounwind uwtable {
122 entry:
123 ; CHECK-LABEL: @test7(
124 ; CHECK-NOT: tail call
125 ; CHECK: ret void
126 %c = alloca [100 x i8], align 16
127 call void @use2_nocapture(ptr %c, ptr %a)
128 call void @use2_nocapture(ptr %b, ptr %c)
129 ret void
130 }
131
132 ; If we have a mix of escaping captured/non-captured allocas, ensure that we do
133 ; not do anything including marking callsites with the tail call marker.
134 ;
135 ; rdar://14324281.
136 define ptr @test8(ptr nocapture %A, i1 %cond) {
137 ; CHECK: ptr @test8
138 ; CHECK-NOT: tailrecurse:
139 ; CHECK-NOT: tail call
140 ; CHECK: ret ptr null
141 %B = alloca i32
142 %B2 = alloca i32
143 br i1 %cond, label %cond_true, label %cond_false
144 cond_true:
145 call void @use(ptr %B2)
146 call ptr @test8(ptr %B, i1 false)
147 ret ptr null
148 cond_false:
149 call void @use2_nocapture(ptr %A, ptr %B)
150 call void @noarg()
151 ret ptr null
152 }
153
154 ; Don't tail call if a byval arg is captured.
155 define void @test9(ptr byval(i32) %a) {
156 ; CHECK-LABEL: define void @test9(
157 ; CHECK: {{^ *}}call void @use(
158 call void @use(ptr %a)
159 ret void
160 }
161
162 %struct.X = type { ptr }
163
164 declare void @ctor(ptr)
165 define void @test10(ptr noalias sret(%struct.X) %agg.result, i1 zeroext %b) {
166 ; CHECK-LABEL: @test10
167 entry:
168 %x = alloca %struct.X, align 8
169 br i1 %b, label %if.then, label %if.end
170
171 if.then: ; preds = %entry
172 call void @ctor(ptr %agg.result)
173 ; CHECK: tail call void @ctor
174 br label %return
175
176 if.end:
177 call void @ctor(ptr %x)
178 ; CHECK: call void @ctor
179 br label %return
180
181 return:
182 ret void
183 }
184
185 declare void @test11_helper1(ptr nocapture, ptr)
186 declare void @test11_helper2(ptr)
187 define void @test11() {
188 ; CHECK-LABEL: @test11
189 ; CHECK-NOT: tail
190 %a = alloca ptr
191 %b = alloca i8
192 call void @test11_helper1(ptr %a, ptr %b) ; a = &b
193 %c = load ptr, ptr %a
194 call void @test11_helper2(ptr %c)
195 ; CHECK: call void @test11_helper2
196 ret void
197 }
198
199 ; PR25928
200 define void @test12() {
201 entry:
202 ; CHECK-LABEL: @test12
203 ; CHECK: {{^ *}} call void undef(ptr undef) [ "foo"(ptr %e) ]
204 %e = alloca i8
205 call void undef(ptr undef) [ "foo"(ptr %e) ]
206 unreachable
207 }
208
209 %struct.foo = type { [10 x i32] }
210
211 ; If an alloca is passed byval it is not a use of the alloca or an escape
212 ; point, and both calls below can be marked tail.
213 define void @test13() {
214 ; CHECK-LABEL: @test13
215 ; CHECK: tail call void @bar(ptr byval(%struct.foo) %f)
216 ; CHECK: tail call void @bar(ptr byval(%struct.foo) null)
217 entry:
218 %f = alloca %struct.foo
219 call void @bar(ptr byval(%struct.foo) %f)
220 call void @bar(ptr byval(%struct.foo) null)
221 ret void
222 }
223
224 ; A call which passes a byval parameter using byval can be marked tail.
225 define void @test14(ptr byval(%struct.foo) %f) {
226 ; CHECK-LABEL: @test14
227 ; CHECK: tail call void @bar
228 entry:
229 call void @bar(ptr byval(%struct.foo) %f)
230 ret void
231 }
232
233 ; If a byval parameter is copied into an alloca and passed byval the call can
234 ; be marked tail.
235 define void @test15(ptr byval(%struct.foo) %f) {
236 ; CHECK-LABEL: @test15
237 ; CHECK: tail call void @bar
238 entry:
239 %agg.tmp = alloca %struct.foo
240 call void @llvm.memcpy.p0.p0.i64(ptr %agg.tmp, ptr %f, i64 40, i1 false)
241 call void @bar(ptr byval(%struct.foo) %agg.tmp)
242 ret void
243 }
244
245 declare void @bar(ptr byval(%struct.foo))
246 declare void @llvm.memcpy.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1)