|
150
|
1 ; RUN: opt -S -codegenprepare -disable-complex-addr-modes=false -addr-sink-new-phis=true -addr-sink-new-select=true %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-YES
|
|
|
2 ; RUN: opt -S -codegenprepare -disable-complex-addr-modes=false -addr-sink-new-phis=false -addr-sink-new-select=true %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NO
|
|
|
3 target datalayout =
|
|
|
4 "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
|
|
|
5 target triple = "x86_64-unknown-linux-gnu"
|
|
|
6
|
|
|
7 ; Can we sink for different base if there is no phi for base?
|
|
252
|
8 define i32 @test1(i1 %cond, ptr %b1, ptr %b2) {
|
|
150
|
9 ; CHECK-LABEL: @test1
|
|
|
10 entry:
|
|
252
|
11 %a1 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
150
|
12 br i1 %cond, label %if.then, label %fallthrough
|
|
|
13
|
|
|
14 if.then:
|
|
252
|
15 %a2 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
150
|
16 br label %fallthrough
|
|
|
17
|
|
|
18 fallthrough:
|
|
|
19 ; CHECK-YES: sunk_phi
|
|
|
20 ; CHECK-NO-LABEL: fallthrough:
|
|
|
21 ; CHECK-NO: phi
|
|
|
22 ; CHECK-NO-NEXT: load
|
|
252
|
23 %c = phi ptr [%a1, %entry], [%a2, %if.then]
|
|
|
24 %v = load i32, ptr %c, align 4
|
|
150
|
25 ret i32 %v
|
|
|
26 }
|
|
|
27
|
|
|
28 ; Can we sink for different base if there is phi for base?
|
|
252
|
29 define i32 @test2(i1 %cond, ptr %b1, ptr %b2) {
|
|
150
|
30 ; CHECK-LABEL: @test2
|
|
|
31 entry:
|
|
252
|
32 %a1 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
150
|
33 br i1 %cond, label %if.then, label %fallthrough
|
|
|
34
|
|
|
35 if.then:
|
|
252
|
36 %a2 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
150
|
37 br label %fallthrough
|
|
|
38
|
|
|
39 fallthrough:
|
|
|
40 ; CHECK: getelementptr inbounds i8, {{.+}} 40
|
|
252
|
41 %b = phi ptr [%b1, %entry], [%b2, %if.then]
|
|
|
42 %c = phi ptr [%a1, %entry], [%a2, %if.then]
|
|
|
43 %v = load i32, ptr %c, align 4
|
|
150
|
44 ret i32 %v
|
|
|
45 }
|
|
|
46
|
|
|
47 ; Can we sink for different base if there is phi for base but not valid one?
|
|
252
|
48 define i32 @test3(i1 %cond, ptr %b1, ptr %b2) {
|
|
150
|
49 ; CHECK-LABEL: @test3
|
|
|
50 entry:
|
|
252
|
51 %a1 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
150
|
52 br i1 %cond, label %if.then, label %fallthrough
|
|
|
53
|
|
|
54 if.then:
|
|
252
|
55 %a2 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
150
|
56 br label %fallthrough
|
|
|
57
|
|
|
58 fallthrough:
|
|
|
59 ; CHECK-YES: sunk_phi
|
|
|
60 ; CHECK-NO-LABEL: fallthrough:
|
|
|
61 ; CHECK-NO: phi
|
|
|
62 ; CHECK-NO: phi
|
|
|
63 ; CHECK-NO-NEXT: load
|
|
252
|
64 %b = phi ptr [%b2, %entry], [%b1, %if.then]
|
|
|
65 %c = phi ptr [%a1, %entry], [%a2, %if.then]
|
|
|
66 %v = load i32, ptr %c, align 4
|
|
150
|
67 ret i32 %v
|
|
|
68 }
|
|
|
69
|
|
|
70 ; Can we sink for different base if both addresses are in the same block?
|
|
252
|
71 define i32 @test4(i1 %cond, ptr %b1, ptr %b2) {
|
|
150
|
72 ; CHECK-LABEL: @test4
|
|
|
73 entry:
|
|
252
|
74 %a1 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
|
75 %a2 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
150
|
76 br i1 %cond, label %if.then, label %fallthrough
|
|
|
77
|
|
|
78 if.then:
|
|
|
79 br label %fallthrough
|
|
|
80
|
|
|
81 fallthrough:
|
|
|
82 ; CHECK-YES: sunk_phi
|
|
|
83 ; CHECK-NO-LABEL: fallthrough:
|
|
|
84 ; CHECK-NO: phi
|
|
|
85 ; CHECK-NO-NEXT: load
|
|
252
|
86 %c = phi ptr [%a1, %entry], [%a2, %if.then]
|
|
|
87 %v = load i32, ptr %c, align 4
|
|
150
|
88 ret i32 %v
|
|
|
89 }
|
|
|
90
|
|
|
91 ; Can we sink for different base if there is phi for base?
|
|
|
92 ; Both addresses are in the same block.
|
|
252
|
93 define i32 @test5(i1 %cond, ptr %b1, ptr %b2) {
|
|
150
|
94 ; CHECK-LABEL: @test5
|
|
|
95 entry:
|
|
252
|
96 %a1 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
|
97 %a2 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
150
|
98 br i1 %cond, label %if.then, label %fallthrough
|
|
|
99
|
|
|
100 if.then:
|
|
|
101 br label %fallthrough
|
|
|
102
|
|
|
103 fallthrough:
|
|
|
104 ; CHECK: getelementptr inbounds i8, {{.+}} 40
|
|
252
|
105 %b = phi ptr [%b1, %entry], [%b2, %if.then]
|
|
|
106 %c = phi ptr [%a1, %entry], [%a2, %if.then]
|
|
|
107 %v = load i32, ptr %c, align 4
|
|
150
|
108 ret i32 %v
|
|
|
109 }
|
|
|
110
|
|
|
111 ; Can we sink for different base if there is phi for base but not valid one?
|
|
|
112 ; Both addresses are in the same block.
|
|
252
|
113 define i32 @test6(i1 %cond, ptr %b1, ptr %b2) {
|
|
150
|
114 ; CHECK-LABEL: @test6
|
|
|
115 entry:
|
|
252
|
116 %a1 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
|
117 %a2 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
150
|
118 br i1 %cond, label %if.then, label %fallthrough
|
|
|
119
|
|
|
120 if.then:
|
|
|
121 br label %fallthrough
|
|
|
122
|
|
|
123 fallthrough:
|
|
|
124 ; CHECK-YES: sunk_phi
|
|
|
125 ; CHECK-NO-LABEL: fallthrough:
|
|
|
126 ; CHECK-NO: phi
|
|
|
127 ; CHECK-NO-NEXT: phi
|
|
|
128 ; CHECK-NO-NEXT: load
|
|
252
|
129 %b = phi ptr [%b2, %entry], [%b1, %if.then]
|
|
|
130 %c = phi ptr [%a1, %entry], [%a2, %if.then]
|
|
|
131 %v = load i32, ptr %c, align 4
|
|
150
|
132 ret i32 %v
|
|
|
133 }
|
|
|
134
|
|
|
135 ; case with a loop. No phi node.
|
|
252
|
136 define i32 @test7(i32 %N, i1 %cond, ptr %b1, ptr %b2) {
|
|
150
|
137 ; CHECK-LABEL: @test7
|
|
|
138 entry:
|
|
252
|
139 %a1 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
150
|
140 br label %loop
|
|
|
141
|
|
|
142 loop:
|
|
|
143 ; CHECK-LABEL: loop:
|
|
|
144 ; CHECK-YES: sunk_phi
|
|
|
145 %iv = phi i32 [0, %entry], [%iv.inc, %fallthrough]
|
|
252
|
146 %c3 = phi ptr [%a1, %entry], [%c, %fallthrough]
|
|
150
|
147 br i1 %cond, label %if.then, label %fallthrough
|
|
|
148
|
|
|
149 if.then:
|
|
252
|
150 %a2 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
150
|
151 br label %fallthrough
|
|
|
152
|
|
|
153 fallthrough:
|
|
|
154 ; CHECK-YES: sunk_phi
|
|
|
155 ; CHECK-NO-LABEL: fallthrough:
|
|
|
156 ; CHECK-NO: phi
|
|
|
157 ; CHECK-NO-NEXT: load
|
|
252
|
158 %c = phi ptr [%c3, %loop], [%a2, %if.then]
|
|
|
159 %v = load volatile i32, ptr %c, align 4
|
|
150
|
160 %iv.inc = add i32 %iv, 1
|
|
|
161 %cmp = icmp slt i32 %iv.inc, %N
|
|
|
162 br i1 %cmp, label %loop, label %exit
|
|
|
163
|
|
|
164 exit:
|
|
|
165 ret i32 %v
|
|
|
166 }
|
|
|
167
|
|
|
168 ; case with a loop. There is phi node.
|
|
252
|
169 define i32 @test8(i32 %N, i1 %cond, ptr %b1, ptr %b2) {
|
|
150
|
170 ; CHECK-LABEL: @test8
|
|
|
171 entry:
|
|
252
|
172 %a1 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
150
|
173 br label %loop
|
|
|
174
|
|
|
175 loop:
|
|
|
176 %iv = phi i32 [0, %entry], [%iv.inc, %fallthrough]
|
|
252
|
177 %c3 = phi ptr [%a1, %entry], [%c, %fallthrough]
|
|
|
178 %b3 = phi ptr [%b1, %entry], [%b, %fallthrough]
|
|
150
|
179 br i1 %cond, label %if.then, label %fallthrough
|
|
|
180
|
|
|
181 if.then:
|
|
252
|
182 %a2 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
150
|
183 br label %fallthrough
|
|
|
184
|
|
|
185 fallthrough:
|
|
|
186 ; CHECK: getelementptr inbounds i8, {{.+}} 40
|
|
252
|
187 %c = phi ptr [%c3, %loop], [%a2, %if.then]
|
|
|
188 %b = phi ptr [%b3, %loop], [%b2, %if.then]
|
|
|
189 %v = load volatile i32, ptr %c, align 4
|
|
150
|
190 %iv.inc = add i32 %iv, 1
|
|
|
191 %cmp = icmp slt i32 %iv.inc, %N
|
|
|
192 br i1 %cmp, label %loop, label %exit
|
|
|
193
|
|
|
194 exit:
|
|
|
195 ret i32 %v
|
|
|
196 }
|
|
|
197
|
|
|
198 ; case with a loop. There is phi node but it does not fit.
|
|
252
|
199 define i32 @test9(i32 %N, i1 %cond, ptr %b1, ptr %b2) {
|
|
150
|
200 ; CHECK-LABEL: @test9
|
|
|
201 entry:
|
|
252
|
202 %a1 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
150
|
203 br label %loop
|
|
|
204
|
|
|
205 loop:
|
|
|
206 ; CHECK-LABEL: loop:
|
|
|
207 ; CHECK-YES: sunk_phi
|
|
|
208 %iv = phi i32 [0, %entry], [%iv.inc, %fallthrough]
|
|
252
|
209 %c3 = phi ptr [%a1, %entry], [%c, %fallthrough]
|
|
|
210 %b3 = phi ptr [%b1, %entry], [%b2, %fallthrough]
|
|
150
|
211 br i1 %cond, label %if.then, label %fallthrough
|
|
|
212
|
|
|
213 if.then:
|
|
252
|
214 %a2 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
150
|
215 br label %fallthrough
|
|
|
216
|
|
|
217 fallthrough:
|
|
|
218 ; CHECK-YES: sunk_phi
|
|
|
219 ; CHECK-NO-LABEL: fallthrough:
|
|
|
220 ; CHECK-NO: phi
|
|
|
221 ; CHECK-NO-NEXT: phi
|
|
|
222 ; CHECK-NO-NEXT: load
|
|
252
|
223 %c = phi ptr [%c3, %loop], [%a2, %if.then]
|
|
|
224 %b = phi ptr [%b3, %loop], [%b2, %if.then]
|
|
|
225 %v = load volatile i32, ptr %c, align 4
|
|
150
|
226 %iv.inc = add i32 %iv, 1
|
|
|
227 %cmp = icmp slt i32 %iv.inc, %N
|
|
|
228 br i1 %cmp, label %loop, label %exit
|
|
|
229
|
|
|
230 exit:
|
|
|
231 ret i32 %v
|
|
|
232 }
|
|
|
233
|
|
|
234 ; Case through a loop. No phi node.
|
|
252
|
235 define i32 @test10(i32 %N, i1 %cond, ptr %b1, ptr %b2) {
|
|
150
|
236 ; CHECK-LABEL: @test10
|
|
|
237 entry:
|
|
252
|
238 %a1 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
150
|
239 br i1 %cond, label %if.then, label %fallthrough
|
|
|
240
|
|
|
241 if.then:
|
|
252
|
242 %a2 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
150
|
243 br label %fallthrough
|
|
|
244
|
|
|
245 fallthrough:
|
|
|
246 ; CHECK-YES: sunk_phi
|
|
|
247 ; CHECK-NO-LABEL: fallthrough:
|
|
|
248 ; CHECK-NO-NEXT: phi
|
|
|
249 ; CHECK-NO-NEXT: br
|
|
252
|
250 %c = phi ptr [%a1, %entry], [%a2, %if.then]
|
|
150
|
251 br label %loop
|
|
|
252
|
|
|
253 loop:
|
|
|
254 %iv = phi i32 [0, %fallthrough], [%iv.inc, %loop]
|
|
|
255 %iv.inc = add i32 %iv, 1
|
|
|
256 %cmp = icmp slt i32 %iv.inc, %N
|
|
|
257 br i1 %cmp, label %loop, label %exit
|
|
|
258
|
|
|
259 exit:
|
|
|
260 ; CHECK-YES: sunkaddr
|
|
252
|
261 %v = load volatile i32, ptr %c, align 4
|
|
150
|
262 ret i32 %v
|
|
|
263 }
|
|
|
264
|
|
|
265 ; Case through a loop. There is a phi.
|
|
252
|
266 define i32 @test11(i32 %N, i1 %cond, ptr %b1, ptr %b2) {
|
|
150
|
267 ; CHECK-LABEL: @test11
|
|
|
268 entry:
|
|
252
|
269 %a1 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
150
|
270 br i1 %cond, label %if.then, label %fallthrough
|
|
|
271
|
|
|
272 if.then:
|
|
252
|
273 %a2 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
150
|
274 br label %fallthrough
|
|
|
275
|
|
|
276 fallthrough:
|
|
|
277 ; CHECK: phi
|
|
|
278 ; CHECK: phi
|
|
|
279 ; CHECK: br
|
|
252
|
280 %c = phi ptr [%a1, %entry], [%a2, %if.then]
|
|
|
281 %b = phi ptr [%b1, %entry], [%b2, %if.then]
|
|
150
|
282 br label %loop
|
|
|
283
|
|
|
284 loop:
|
|
|
285 %iv = phi i32 [0, %fallthrough], [%iv.inc, %loop]
|
|
|
286 %iv.inc = add i32 %iv, 1
|
|
|
287 %cmp = icmp slt i32 %iv.inc, %N
|
|
|
288 br i1 %cmp, label %loop, label %exit
|
|
|
289
|
|
|
290 exit:
|
|
|
291 ; CHECK: sunkaddr
|
|
252
|
292 %v = load volatile i32, ptr %c, align 4
|
|
150
|
293 ret i32 %v
|
|
|
294 }
|
|
|
295
|
|
|
296 ; Complex case with address value from previous iteration.
|
|
252
|
297 define i32 @test12(i32 %N, i1 %cond, ptr %b1, ptr %b2, ptr %b3) {
|
|
150
|
298 ; CHECK-LABEL: @test12
|
|
|
299 entry:
|
|
252
|
300 %a1 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
150
|
301 br label %loop
|
|
|
302
|
|
|
303 loop:
|
|
|
304 ; CHECK-LABEL: loop:
|
|
|
305 ; CHECK-YES: sunk_phi
|
|
|
306 ; CHECK-NO: phi
|
|
|
307 ; CHECK-NO-NEXT: phi
|
|
|
308 ; CHECK-NO-NEXT: phi
|
|
|
309 ; CHECK-NO-NEXT: br
|
|
|
310 %iv = phi i32 [0, %entry], [%iv.inc, %backedge]
|
|
252
|
311 %c3 = phi ptr [%a1, %entry], [%c, %backedge]
|
|
|
312 %b4 = phi ptr [%b1, %entry], [%b5, %backedge]
|
|
150
|
313 br i1 %cond, label %if.then, label %fallthrough
|
|
|
314
|
|
|
315 if.then:
|
|
252
|
316 %a2 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
150
|
317 br label %fallthrough
|
|
|
318
|
|
|
319 fallthrough:
|
|
|
320 ; CHECK-LABEL: fallthrough:
|
|
|
321 ; CHECK-YES: sunk_phi
|
|
|
322 ; CHECK-NO: phi
|
|
|
323 ; CHECK-NO-NEXT: phi
|
|
|
324 ; CHECK-NO-NEXT: load
|
|
252
|
325 %c = phi ptr [%c3, %loop], [%a2, %if.then]
|
|
|
326 %b6 = phi ptr [%b4, %loop], [%b2, %if.then]
|
|
|
327 %v = load volatile i32, ptr %c, align 4
|
|
|
328 %a4 = getelementptr inbounds i64, ptr %b4, i64 5
|
|
150
|
329 %cmp = icmp slt i32 %iv, 20
|
|
|
330 br i1 %cmp, label %backedge, label %if.then.2
|
|
|
331
|
|
|
332 if.then.2:
|
|
|
333 br label %backedge
|
|
|
334
|
|
|
335 backedge:
|
|
252
|
336 %b5 = phi ptr [%b4, %fallthrough], [%b6, %if.then.2]
|
|
150
|
337 %iv.inc = add i32 %iv, 1
|
|
|
338 %cmp2 = icmp slt i32 %iv.inc, %N
|
|
|
339 br i1 %cmp2, label %loop, label %exit
|
|
|
340
|
|
|
341 exit:
|
|
|
342 ret i32 %v
|
|
|
343 }
|
|
|
344
|
|
|
345 %struct.S = type {i32, i32}
|
|
|
346 ; Case with index
|
|
252
|
347 define i32 @test13(i1 %cond, ptr %b1, ptr %b2, i64 %Index) {
|
|
150
|
348 ; CHECK-LABEL: @test13
|
|
|
349 entry:
|
|
252
|
350 %a1 = getelementptr inbounds %struct.S, ptr %b1, i64 %Index, i32 1
|
|
150
|
351 br i1 %cond, label %if.then, label %fallthrough
|
|
|
352
|
|
|
353 if.then:
|
|
|
354 %i2 = mul i64 %Index, 2
|
|
252
|
355 %a2 = getelementptr inbounds %struct.S, ptr %b2, i64 %Index, i32 1
|
|
150
|
356 br label %fallthrough
|
|
|
357
|
|
|
358 fallthrough:
|
|
|
359 ; CHECK-YES: sunk_phi
|
|
|
360 ; CHECK-NO-LABEL: fallthrough:
|
|
|
361 ; CHECK-NO-NEXT: phi
|
|
|
362 ; CHECK-NO-NEXT: load
|
|
252
|
363 %a = phi ptr [%a1, %entry], [%a2, %if.then]
|
|
|
364 %v = load i32, ptr %a, align 4
|
|
150
|
365 ret i32 %v
|
|
|
366 }
|
|
|
367
|
|
|
368 ; Select of Select case.
|
|
252
|
369 define i64 @test14(i1 %c1, i1 %c2, ptr %b1, ptr %b2, ptr %b3) {
|
|
150
|
370 ; CHECK-LABEL: @test14
|
|
|
371 entry:
|
|
|
372 ; CHECK-LABEL: entry:
|
|
252
|
373 %g1 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
|
374 %g2 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
|
375 %g3 = getelementptr inbounds i64, ptr %b3, i64 5
|
|
|
376 %s1 = select i1 %c1, ptr %g1, ptr %g2
|
|
|
377 %s2 = select i1 %c2, ptr %s1, ptr %g3
|
|
150
|
378 ; CHECK: sunkaddr
|
|
252
|
379 %v = load i64 , ptr %s2, align 8
|
|
150
|
380 ret i64 %v
|
|
|
381 }
|
|
|
382
|
|
|
383 ; Select of Phi case.
|
|
252
|
384 define i64 @test15(i1 %c1, i1 %c2, ptr %b1, ptr %b2, ptr %b3) {
|
|
150
|
385 ; CHECK-LABEL: @test15
|
|
|
386 entry:
|
|
252
|
387 %g1 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
|
388 %g2 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
|
389 %g3 = getelementptr inbounds i64, ptr %b3, i64 5
|
|
150
|
390 br i1 %c1, label %if.then, label %fallthrough
|
|
|
391
|
|
|
392 if.then:
|
|
|
393 br label %fallthrough
|
|
|
394
|
|
|
395 fallthrough:
|
|
|
396 ; CHECK-LABEL: fallthrough:
|
|
252
|
397 %p1 = phi ptr [%g1, %entry], [%g2, %if.then]
|
|
|
398 %s1 = select i1 %c2, ptr %p1, ptr %g3
|
|
150
|
399 ; CHECK-YES: sunkaddr
|
|
|
400 ; CHECK-NO: phi
|
|
|
401 ; CHECK-NO-NEXT: select
|
|
|
402 ; CHECK-NO-NEXT: load
|
|
252
|
403 %v = load i64 , ptr %s1, align 8
|
|
150
|
404 ret i64 %v
|
|
|
405 }
|
|
|
406
|
|
|
407 ; Select of Phi case. Phi exists
|
|
252
|
408 define i64 @test16(i1 %c1, i1 %c2, ptr %b1, ptr %b2, ptr %b3) {
|
|
150
|
409 ; CHECK-LABEL: @test16
|
|
|
410 entry:
|
|
252
|
411 %g1 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
|
412 %g2 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
|
413 %g3 = getelementptr inbounds i64, ptr %b3, i64 5
|
|
150
|
414 br i1 %c1, label %if.then, label %fallthrough
|
|
|
415
|
|
|
416 if.then:
|
|
|
417 br label %fallthrough
|
|
|
418
|
|
|
419 fallthrough:
|
|
|
420 ; CHECK-LABEL: fallthrough:
|
|
252
|
421 %p = phi ptr [%b1, %entry], [%b2, %if.then]
|
|
|
422 %p1 = phi ptr [%g1, %entry], [%g2, %if.then]
|
|
|
423 %s1 = select i1 %c2, ptr %p1, ptr %g3
|
|
150
|
424 ; CHECK: sunkaddr
|
|
252
|
425 %v = load i64 , ptr %s1, align 8
|
|
150
|
426 ret i64 %v
|
|
|
427 }
|
|
|
428
|
|
|
429 ; Phi of Select case.
|
|
252
|
430 define i64 @test17(i1 %c1, i1 %c2, ptr %b1, ptr %b2, ptr %b3) {
|
|
150
|
431 ; CHECK-LABEL: @test17
|
|
|
432 entry:
|
|
252
|
433 %g1 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
|
434 %g2 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
|
435 %g3 = getelementptr inbounds i64, ptr %b3, i64 5
|
|
|
436 %s1 = select i1 %c2, ptr %g1, ptr %g2
|
|
150
|
437 br i1 %c1, label %if.then, label %fallthrough
|
|
|
438
|
|
|
439 if.then:
|
|
|
440 br label %fallthrough
|
|
|
441
|
|
|
442 fallthrough:
|
|
|
443 ; CHECK-LABEL: fallthrough:
|
|
252
|
444 %p1 = phi ptr [%s1, %entry], [%g3, %if.then]
|
|
150
|
445 ; CHECK-YES: sunkaddr
|
|
|
446 ; CHECK-NO: phi
|
|
|
447 ; CHECK-NO-NEXT: load
|
|
252
|
448 %v = load i64 , ptr %p1, align 8
|
|
150
|
449 ret i64 %v
|
|
|
450 }
|
|
|
451
|
|
|
452 ; The same two addr modes by different paths
|
|
252
|
453 define i32 @test18(i1 %cond1, i1 %cond2, ptr %b1, ptr %b2) {
|
|
150
|
454 ; CHECK-LABEL: @test18
|
|
|
455 entry:
|
|
252
|
456 %g1 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
150
|
457 br i1 %cond1, label %if.then1, label %if.then2
|
|
|
458
|
|
|
459 if.then1:
|
|
252
|
460 %g2 = getelementptr inbounds i64, ptr %b1, i64 5
|
|
150
|
461 br label %fallthrough
|
|
|
462
|
|
|
463 if.then2:
|
|
|
464 br i1 %cond2, label %fallthrough, label %if.then3
|
|
|
465
|
|
|
466 if.then3:
|
|
|
467 br label %fallthrough
|
|
|
468
|
|
|
469 fallthrough:
|
|
|
470 ; CHECK-YES: sunk_phi
|
|
|
471 ; CHECK-NO-LABEL: fallthrough:
|
|
|
472 ; CHECK-NO: phi
|
|
|
473 ; CHECK-NO-NEXT: load
|
|
252
|
474 %c = phi ptr [%g2, %if.then1], [%g1, %if.then2], [%g1, %if.then3]
|
|
|
475 %v1 = load i32, ptr %c, align 4
|
|
|
476 %g1_1 = getelementptr inbounds i64, ptr %b2, i64 5
|
|
|
477 %v2 = load i32, ptr %g1_1, align 4
|
|
150
|
478 %v = add i32 %v1, %v2
|
|
|
479 ret i32 %v
|
|
|
480 }
|
|
|
481
|
|
|
482 ; Different types but null is the first?
|
|
|
483 define i32 @test19(i1 %cond1, i1 %cond2, i64* %b2, i8* %b1) {
|
|
|
484 ; CHECK-LABEL: @test19
|
|
|
485 entry:
|
|
|
486 %g1 = getelementptr inbounds i64, i64* %b2, i64 5
|
|
|
487 %bc1 = bitcast i64* %g1 to i32*
|
|
|
488 br i1 %cond1, label %if.then1, label %if.then2
|
|
|
489
|
|
|
490 if.then1:
|
|
|
491 %g2 = getelementptr inbounds i8, i8* %b1, i64 40
|
|
|
492 %bc2 = bitcast i8* %g2 to i32*
|
|
|
493 br label %fallthrough
|
|
|
494
|
|
|
495 if.then2:
|
|
|
496 %bc1_1 = bitcast i64* %g1 to i32*
|
|
|
497 br i1 %cond2, label %fallthrough, label %if.then3
|
|
|
498
|
|
|
499 if.then3:
|
|
|
500 %g3 = getelementptr inbounds i64, i64* null, i64 5
|
|
|
501 %bc1_2 = bitcast i64* %g3 to i32*
|
|
|
502 br label %fallthrough
|
|
|
503
|
|
|
504 fallthrough:
|
|
|
505 ; CHECK-NOT: sunk_phi
|
|
|
506 %c = phi i32* [%bc2, %if.then1], [%bc1_1, %if.then2], [%bc1_2, %if.then3]
|
|
|
507 %v1 = load i32, i32* %c, align 4
|
|
|
508 %g1_1 = getelementptr inbounds i64, i64* %b2, i64 5
|
|
|
509 %bc1_1_1 = bitcast i64* %g1_1 to i32*
|
|
|
510 %v2 = load i32, i32* %bc1_1_1, align 4
|
|
|
511 %v = add i32 %v1, %v2
|
|
|
512 ret i32 %v
|
|
|
513 }
|
