| blob | 9567b6b793239ca6d2ccc0eb2912d74f62aa9b8b |
1 ; RUN: opt -passes='loop(simple-loop-unswitch<nontrivial>),verify<loops>' -S < %s | FileCheck %s
2 ; RUN: opt -passes='loop-mssa(simple-loop-unswitch<nontrivial>),verify<loops>' -S -verify-memoryssa < %s | FileCheck %s
4 declare i32 @a()
5 declare i32 @b()
6 declare i32 @c()
7 declare i32 @d()
9 declare void @sink1(i32)
10 declare void @sink2(i32)
12 declare i1 @cond()
13 declare i32 @cond.i32()
15 ; Negative test: we cannot unswitch convergent calls.
16 define void @test_no_unswitch_convergent(ptr %ptr, i1 %cond) {
17 ; CHECK-LABEL: @test_no_unswitch_convergent(
18 entry:
19 br label %loop_begin
20 ; CHECK-NEXT: entry:
21 ; CHECK-NEXT: br label %loop_begin
22 ;
23 ; We shouldn't have unswitched into any other block either.
24 ; CHECK-NOT: br i1 %cond
26 loop_begin:
27 br i1 %cond, label %loop_a, label %loop_b
28 ; CHECK: loop_begin:
29 ; CHECK-NEXT: br i1 %cond, label %loop_a, label %loop_b
31 loop_a:
32 call i32 @a() convergent
33 br label %loop_latch
35 loop_b:
36 call i32 @b()
37 br label %loop_latch
39 loop_latch:
40 %v = load i1, ptr %ptr
41 br i1 %v, label %loop_begin, label %loop_exit
43 loop_exit:
44 ret void
45 }
47 ; Negative test: we cannot unswitch noduplicate calls.
48 define void @test_no_unswitch_noduplicate(ptr %ptr, i1 %cond) {
49 ; CHECK-LABEL: @test_no_unswitch_noduplicate(
50 entry:
51 br label %loop_begin
52 ; CHECK-NEXT: entry:
53 ; CHECK-NEXT: br label %loop_begin
54 ;
55 ; We shouldn't have unswitched into any other block either.
56 ; CHECK-NOT: br i1 %cond
58 loop_begin:
59 br i1 %cond, label %loop_a, label %loop_b
60 ; CHECK: loop_begin:
61 ; CHECK-NEXT: br i1 %cond, label %loop_a, label %loop_b
63 loop_a:
64 call i32 @a() noduplicate
65 br label %loop_latch
67 loop_b:
68 call i32 @b()
69 br label %loop_latch
71 loop_latch:
72 %v = load i1, ptr %ptr
73 br i1 %v, label %loop_begin, label %loop_exit
75 loop_exit:
76 ret void
77 }
79 declare i32 @__CxxFrameHandler3(...)
81 ; Negative test: we cannot unswitch when tokens are used across blocks as we
82 ; might introduce PHIs.
83 define void @test_no_unswitch_cross_block_token(ptr %ptr, i1 %cond) nounwind personality ptr @__CxxFrameHandler3 {
84 ; CHECK-LABEL: @test_no_unswitch_cross_block_token(
85 entry:
86 br label %loop_begin
87 ; CHECK-NEXT: entry:
88 ; CHECK-NEXT: br label %loop_begin
89 ;
90 ; We shouldn't have unswitched into any other block either.
91 ; CHECK-NOT: br i1 %cond
93 loop_begin:
94 br i1 %cond, label %loop_a, label %loop_b
95 ; CHECK: loop_begin:
96 ; CHECK-NEXT: br i1 %cond, label %loop_a, label %loop_b
98 loop_a:
99 call i32 @a()
100 br label %loop_cont
102 loop_b:
103 call i32 @b()
104 br label %loop_cont
106 loop_cont:
107 invoke i32 @a()
108 to label %loop_latch unwind label %loop_catch
110 loop_latch:
111 br label %loop_begin
113 loop_catch:
114 %catch = catchswitch within none [label %loop_catch_latch, label %loop_exit] unwind to caller
116 loop_catch_latch:
117 %catchpad_latch = catchpad within %catch []
118 catchret from %catchpad_latch to label %loop_begin
120 loop_exit:
121 %catchpad_exit = catchpad within %catch []
122 catchret from %catchpad_exit to label %exit
124 exit:
125 ret void
126 }
129 ; Non-trivial loop unswitching where there are two distinct trivial conditions
130 ; to unswitch within the loop.
131 define i32 @test1(ptr %ptr, i1 %cond1, i1 %cond2) {
132 ; CHECK-LABEL: @test1(
133 entry:
134 br label %loop_begin
135 ; CHECK-NEXT: entry:
136 ; CHECK-NEXT: br i1 %cond1, label %entry.split.us, label %entry.split
138 loop_begin:
139 br i1 %cond1, label %loop_a, label %loop_b
141 loop_a:
142 call i32 @a()
143 br label %latch
144 ; The 'loop_a' unswitched loop.
145 ;
146 ; CHECK: entry.split.us:
147 ; CHECK-NEXT: br label %loop_begin.us
148 ;
149 ; CHECK: loop_begin.us:
150 ; CHECK-NEXT: br label %loop_a.us
151 ;
152 ; CHECK: loop_a.us:
153 ; CHECK-NEXT: call i32 @a()
154 ; CHECK-NEXT: br label %latch.us
155 ;
156 ; CHECK: latch.us:
157 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
158 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin.us, label %loop_exit.split.us
159 ;
160 ; CHECK: loop_exit.split.us:
161 ; CHECK-NEXT: br label %loop_exit
163 loop_b:
164 br i1 %cond2, label %loop_b_a, label %loop_b_b
165 ; The second unswitched condition.
166 ;
167 ; CHECK: entry.split:
168 ; CHECK-NEXT: br i1 %cond2, label %entry.split.split.us, label %entry.split.split
170 loop_b_a:
171 call i32 @b()
172 br label %latch
173 ; The 'loop_b_a' unswitched loop.
174 ;
175 ; CHECK: entry.split.split.us:
176 ; CHECK-NEXT: br label %loop_begin.us1
177 ;
178 ; CHECK: loop_begin.us1:
179 ; CHECK-NEXT: br label %loop_b.us
180 ;
181 ; CHECK: loop_b.us:
182 ; CHECK-NEXT: br label %loop_b_a.us
183 ;
184 ; CHECK: loop_b_a.us:
185 ; CHECK-NEXT: call i32 @b()
186 ; CHECK-NEXT: br label %latch.us2
187 ;
188 ; CHECK: latch.us2:
189 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
190 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin.us1, label %loop_exit.split.split.us
191 ;
192 ; CHECK: loop_exit.split.split.us:
193 ; CHECK-NEXT: br label %loop_exit.split
195 loop_b_b:
196 call i32 @c()
197 br label %latch
198 ; The 'loop_b_b' unswitched loop.
199 ;
200 ; CHECK: entry.split.split:
201 ; CHECK-NEXT: br label %loop_begin
202 ;
203 ; CHECK: loop_begin:
204 ; CHECK-NEXT: br label %loop_b
205 ;
206 ; CHECK: loop_b:
207 ; CHECK-NEXT: br label %loop_b_b
208 ;
209 ; CHECK: loop_b_b:
210 ; CHECK-NEXT: call i32 @c()
211 ; CHECK-NEXT: br label %latch
212 ;
213 ; CHECK: latch:
214 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
215 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin, label %loop_exit.split.split
216 ;
217 ; CHECK: loop_exit.split.split:
218 ; CHECK-NEXT: br label %loop_exit.split
220 latch:
221 %v = load i1, ptr %ptr
222 br i1 %v, label %loop_begin, label %loop_exit
224 loop_exit:
225 ret i32 0
226 ; CHECK: loop_exit.split:
227 ; CHECK-NEXT: br label %loop_exit
228 ;
229 ; CHECK: loop_exit:
230 ; CHECK-NEXT: ret
231 }
233 define i32 @test2(ptr %ptr, i1 %cond1, ptr %a.ptr, ptr %b.ptr, ptr %c.ptr) {
234 ; CHECK-LABEL: @test2(
235 entry:
236 br label %loop_begin
237 ; CHECK-NEXT: entry:
238 ; CHECK-NEXT: br i1 %cond1, label %entry.split.us, label %entry.split
240 loop_begin:
241 %v = load i1, ptr %ptr
242 br i1 %cond1, label %loop_a, label %loop_b
244 loop_a:
245 %a = load i32, ptr %a.ptr
246 %ac = load i32, ptr %c.ptr
247 br i1 %v, label %loop_begin, label %loop_exit
248 ; The 'loop_a' unswitched loop.
249 ;
250 ; CHECK: entry.split.us:
251 ; CHECK-NEXT: br label %loop_begin.us
252 ;
253 ; CHECK: loop_begin.us:
254 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
255 ; CHECK-NEXT: br label %loop_a.us
256 ;
257 ; CHECK: loop_a.us:
258 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
259 ; CHECK-NEXT: %[[AC:.*]] = load i32, ptr %c.ptr
260 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin.backedge.us, label %loop_exit.split.us
261 ;
262 ; CHECK: loop_exit.split.us:
263 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A]], %loop_a.us ]
264 ; CHECK-NEXT: %[[AC_LCSSA:.*]] = phi i32 [ %[[AC]], %loop_a.us ]
265 ; CHECK-NEXT: br label %loop_exit
267 loop_b:
268 %b = load i32, ptr %b.ptr
269 %bc = load i32, ptr %c.ptr
270 br i1 %v, label %loop_begin, label %loop_exit
271 ; The 'loop_b' unswitched loop.
272 ;
273 ; CHECK: entry.split:
274 ; CHECK-NEXT: br label %loop_begin
275 ;
276 ; CHECK: loop_begin:
277 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
278 ; CHECK-NEXT: br label %loop_b
279 ;
280 ; CHECK: loop_b:
281 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
282 ; CHECK-NEXT: %[[BC:.*]] = load i32, ptr %c.ptr
283 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin.backedge, label %loop_exit.split
284 ;
285 ; CHECK: loop_exit.split:
286 ; CHECK-NEXT: %[[B_LCSSA:.*]] = phi i32 [ %[[B]], %loop_b ]
287 ; CHECK-NEXT: %[[BC_LCSSA:.*]] = phi i32 [ %[[BC]], %loop_b ]
288 ; CHECK-NEXT: br label %loop_exit
290 loop_exit:
291 %ab.phi = phi i32 [ %a, %loop_a ], [ %b, %loop_b ]
292 %c.phi = phi i32 [ %ac, %loop_a ], [ %bc, %loop_b ]
293 %result = add i32 %ab.phi, %c.phi
294 ret i32 %result
295 ; CHECK: loop_exit:
296 ; CHECK-NEXT: %[[AB_PHI:.*]] = phi i32 [ %[[B_LCSSA]], %loop_exit.split ], [ %[[A_LCSSA]], %loop_exit.split.us ]
297 ; CHECK-NEXT: %[[C_PHI:.*]] = phi i32 [ %[[BC_LCSSA]], %loop_exit.split ], [ %[[AC_LCSSA]], %loop_exit.split.us ]
298 ; CHECK-NEXT: %[[RESULT:.*]] = add i32 %[[AB_PHI]], %[[C_PHI]]
299 ; CHECK-NEXT: ret i32 %[[RESULT]]
300 }
302 ; Test a non-trivial unswitch of an exiting edge to an exit block with other
303 ; in-loop predecessors.
304 define i32 @test3a(ptr %ptr, i1 %cond1, ptr %a.ptr, ptr %b.ptr) {
305 ; CHECK-LABEL: @test3a(
306 entry:
307 br label %loop_begin
308 ; CHECK-NEXT: entry:
309 ; CHECK-NEXT: br i1 %cond1, label %entry.split.us, label %entry.split
311 loop_begin:
312 %v = load i1, ptr %ptr
313 %a = load i32, ptr %a.ptr
314 br i1 %cond1, label %loop_exit, label %loop_b
315 ; The 'loop_exit' clone.
316 ;
317 ; CHECK: entry.split.us:
318 ; CHECK-NEXT: br label %loop_begin.us
319 ;
320 ; CHECK: loop_begin.us:
321 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
322 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
323 ; CHECK-NEXT: br label %loop_exit.split.us
324 ;
325 ; CHECK: loop_exit.split.us:
326 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A]], %loop_begin.us ]
327 ; CHECK-NEXT: br label %loop_exit
329 loop_b:
330 %b = load i32, ptr %b.ptr
331 br i1 %v, label %loop_begin, label %loop_exit
332 ; The 'loop_b' unswitched loop.
333 ;
334 ; CHECK: entry.split:
335 ; CHECK-NEXT: br label %loop_begin
336 ;
337 ; CHECK: loop_begin:
338 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
339 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
340 ; CHECK-NEXT: br label %loop_b
341 ;
342 ; CHECK: loop_b:
343 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
344 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin, label %loop_exit.split
345 ;
346 ; CHECK: loop_exit.split:
347 ; CHECK-NEXT: %[[B_LCSSA:.*]] = phi i32 [ %[[B]], %loop_b ]
348 ; CHECK-NEXT: br label %loop_exit
350 loop_exit:
351 %ab.phi = phi i32 [ %a, %loop_begin ], [ %b, %loop_b ]
352 ret i32 %ab.phi
353 ; CHECK: loop_exit:
354 ; CHECK-NEXT: %[[AB_PHI:.*]] = phi i32 [ %[[B_LCSSA]], %loop_exit.split ], [ %[[A_LCSSA]], %loop_exit.split.us ]
355 ; CHECK-NEXT: ret i32 %[[AB_PHI]]
356 }
358 ; Test a non-trivial unswitch of an exiting edge to an exit block with other
359 ; in-loop predecessors. This is the same as @test3a but with the reversed order
360 ; of successors so that the exiting edge is *not* the cloned edge.
361 define i32 @test3b(ptr %ptr, i1 %cond1, ptr %a.ptr, ptr %b.ptr) {
362 ; CHECK-LABEL: @test3b(
363 entry:
364 br label %loop_begin
365 ; CHECK-NEXT: entry:
366 ; CHECK-NEXT: br i1 %cond1, label %entry.split.us, label %entry.split
368 loop_begin:
369 %v = load i1, ptr %ptr
370 %a = load i32, ptr %a.ptr
371 br i1 %cond1, label %loop_b, label %loop_exit
372 ; The 'loop_b' unswitched loop.
373 ;
374 ; CHECK: entry.split.us:
375 ; CHECK-NEXT: br label %loop_begin.us
376 ;
377 ; CHECK: loop_begin.us:
378 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
379 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
380 ; CHECK-NEXT: br label %loop_b.us
381 ;
382 ; CHECK: loop_b.us:
383 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
384 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin.us, label %loop_exit.split.us
385 ;
386 ; CHECK: loop_exit.split.us:
387 ; CHECK-NEXT: %[[B_LCSSA:.*]] = phi i32 [ %[[B]], %loop_b.us ]
388 ; CHECK-NEXT: br label %loop_exit
390 loop_b:
391 %b = load i32, ptr %b.ptr
392 br i1 %v, label %loop_begin, label %loop_exit
393 ; The original loop, now non-looping due to unswitching..
394 ;
395 ; CHECK: entry.split:
396 ; CHECK-NEXT: br label %loop_begin
397 ;
398 ; CHECK: loop_begin:
399 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
400 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
401 ; CHECK-NEXT: br label %loop_exit.split
402 ;
403 ; CHECK: loop_exit.split:
404 ; CHECK-NEXT: br label %loop_exit
406 loop_exit:
407 %ab.phi = phi i32 [ %b, %loop_b ], [ %a, %loop_begin ]
408 ret i32 %ab.phi
409 ; CHECK: loop_exit:
410 ; CHECK-NEXT: %[[AB_PHI:.*]] = phi i32 [ %[[A]], %loop_exit.split ], [ %[[B_LCSSA]], %loop_exit.split.us ]
411 ; CHECK-NEXT: ret i32 %[[AB_PHI]]
412 }
414 ; Test a non-trivial unswitch of an exiting edge to an exit block with no other
415 ; in-loop predecessors.
416 define void @test4a(ptr %ptr, i1 %cond1, ptr %a.ptr, ptr %b.ptr) {
417 ; CHECK-LABEL: @test4a(
418 entry:
419 br label %loop_begin
420 ; CHECK-NEXT: entry:
421 ; CHECK-NEXT: br i1 %cond1, label %entry.split.us, label %entry.split
423 loop_begin:
424 %v = load i1, ptr %ptr
425 %a = load i32, ptr %a.ptr
426 br i1 %cond1, label %loop_exit1, label %loop_b
427 ; The 'loop_exit' clone.
428 ;
429 ; CHECK: entry.split.us:
430 ; CHECK-NEXT: br label %loop_begin.us
431 ;
432 ; CHECK: loop_begin.us:
433 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
434 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
435 ; CHECK-NEXT: br label %loop_exit1.split.us
436 ;
437 ; CHECK: loop_exit1.split.us:
438 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A]], %loop_begin.us ]
439 ; CHECK-NEXT: br label %loop_exit1
441 loop_b:
442 %b = load i32, ptr %b.ptr
443 br i1 %v, label %loop_begin, label %loop_exit2
444 ; The 'loop_b' unswitched loop.
445 ;
446 ; CHECK: entry.split:
447 ; CHECK-NEXT: br label %loop_begin
448 ;
449 ; CHECK: loop_begin:
450 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
451 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
452 ; CHECK-NEXT: br label %loop_b
453 ;
454 ; CHECK: loop_b:
455 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
456 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin, label %loop_exit2
458 loop_exit1:
459 %a.phi = phi i32 [ %a, %loop_begin ]
460 call void @sink1(i32 %a.phi)
461 ret void
462 ; CHECK: loop_exit1:
463 ; CHECK-NEXT: call void @sink1(i32 %[[A_LCSSA]])
464 ; CHECK-NEXT: ret void
466 loop_exit2:
467 %b.phi = phi i32 [ %b, %loop_b ]
468 call void @sink2(i32 %b.phi)
469 ret void
470 ; CHECK: loop_exit2:
471 ; CHECK-NEXT: %[[B_LCSSA:.*]] = phi i32 [ %[[B]], %loop_b ]
472 ; CHECK-NEXT: call void @sink2(i32 %[[B_LCSSA]])
473 ; CHECK-NEXT: ret void
474 }
476 ; Test a non-trivial unswitch of an exiting edge to an exit block with no other
477 ; in-loop predecessors. This is the same as @test4a but with the edges reversed
478 ; so that the exiting edge is *not* the cloned edge.
479 define void @test4b(ptr %ptr, i1 %cond1, ptr %a.ptr, ptr %b.ptr) {
480 ; CHECK-LABEL: @test4b(
481 entry:
482 br label %loop_begin
483 ; CHECK-NEXT: entry:
484 ; CHECK-NEXT: br i1 %cond1, label %entry.split.us, label %entry.split
486 loop_begin:
487 %v = load i1, ptr %ptr
488 %a = load i32, ptr %a.ptr
489 br i1 %cond1, label %loop_b, label %loop_exit1
490 ; The 'loop_b' clone.
491 ;
492 ; CHECK: entry.split.us:
493 ; CHECK-NEXT: br label %loop_begin.us
494 ;
495 ; CHECK: loop_begin.us:
496 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
497 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
498 ; CHECK-NEXT: br label %loop_b.us
499 ;
500 ; CHECK: loop_b.us:
501 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
502 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin.us, label %loop_exit2.split.us
503 ;
504 ; CHECK: loop_exit2.split.us:
505 ; CHECK-NEXT: %[[B_LCSSA:.*]] = phi i32 [ %[[B]], %loop_b.us ]
506 ; CHECK-NEXT: br label %loop_exit2
508 loop_b:
509 %b = load i32, ptr %b.ptr
510 br i1 %v, label %loop_begin, label %loop_exit2
511 ; The 'loop_exit' unswitched path.
512 ;
513 ; CHECK: entry.split:
514 ; CHECK-NEXT: br label %loop_begin
515 ;
516 ; CHECK: loop_begin:
517 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
518 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
519 ; CHECK-NEXT: br label %loop_exit1
521 loop_exit1:
522 %a.phi = phi i32 [ %a, %loop_begin ]
523 call void @sink1(i32 %a.phi)
524 ret void
525 ; CHECK: loop_exit1:
526 ; CHECK-NEXT: %[[A_PHI:.*]] = phi i32 [ %[[A]], %loop_begin ]
527 ; CHECK-NEXT: call void @sink1(i32 %[[A_PHI]])
528 ; CHECK-NEXT: ret void
530 loop_exit2:
531 %b.phi = phi i32 [ %b, %loop_b ]
532 call void @sink2(i32 %b.phi)
533 ret void
534 ; CHECK: loop_exit2:
535 ; CHECK-NEXT: call void @sink2(i32 %[[B_LCSSA]])
536 ; CHECK-NEXT: ret void
537 }
539 ; Test a non-trivial unswitch of an exiting edge to an exit block with no other
540 ; in-loop predecessors. This is the same as @test4a but with a common merge
541 ; block after the independent loop exits. This requires a different structural
542 ; update to the dominator tree.
543 define void @test4c(ptr %ptr, i1 %cond1, ptr %a.ptr, ptr %b.ptr) {
544 ; CHECK-LABEL: @test4c(
545 entry:
546 br label %loop_begin
547 ; CHECK-NEXT: entry:
548 ; CHECK-NEXT: br i1 %cond1, label %entry.split.us, label %entry.split
550 loop_begin:
551 %v = load i1, ptr %ptr
552 %a = load i32, ptr %a.ptr
553 br i1 %cond1, label %loop_exit1, label %loop_b
554 ; The 'loop_exit' clone.
555 ;
556 ; CHECK: entry.split.us:
557 ; CHECK-NEXT: br label %loop_begin.us
558 ;
559 ; CHECK: loop_begin.us:
560 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
561 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
562 ; CHECK-NEXT: br label %loop_exit1.split.us
563 ;
564 ; CHECK: loop_exit1.split.us:
565 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A]], %loop_begin.us ]
566 ; CHECK-NEXT: br label %loop_exit1
568 loop_b:
569 %b = load i32, ptr %b.ptr
570 br i1 %v, label %loop_begin, label %loop_exit2
571 ; The 'loop_b' unswitched loop.
572 ;
573 ; CHECK: entry.split:
574 ; CHECK-NEXT: br label %loop_begin
575 ;
576 ; CHECK: loop_begin:
577 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
578 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
579 ; CHECK-NEXT: br label %loop_b
580 ;
581 ; CHECK: loop_b:
582 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
583 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin, label %loop_exit2
585 loop_exit1:
586 %a.phi = phi i32 [ %a, %loop_begin ]
587 call void @sink1(i32 %a.phi)
588 br label %exit
589 ; CHECK: loop_exit1:
590 ; CHECK-NEXT: call void @sink1(i32 %[[A_LCSSA]])
591 ; CHECK-NEXT: br label %exit
593 loop_exit2:
594 %b.phi = phi i32 [ %b, %loop_b ]
595 call void @sink2(i32 %b.phi)
596 br label %exit
597 ; CHECK: loop_exit2:
598 ; CHECK-NEXT: %[[B_LCSSA:.*]] = phi i32 [ %[[B]], %loop_b ]
599 ; CHECK-NEXT: call void @sink2(i32 %[[B_LCSSA]])
600 ; CHECK-NEXT: br label %exit
602 exit:
603 ret void
604 ; CHECK: exit:
605 ; CHECK-NEXT: ret void
606 }
608 ; Test that we can unswitch a condition out of multiple layers of a loop nest.
609 define i32 @test5(ptr %ptr, i1 %cond1, ptr %a.ptr, ptr %b.ptr) {
610 ; CHECK-LABEL: @test5(
611 entry:
612 br label %loop_begin
613 ; CHECK-NEXT: entry:
614 ; CHECK-NEXT: br i1 %cond1, label %loop_begin.split.us, label %entry.split
615 ;
616 ; CHECK: entry.split:
617 ; CHECK-NEXT: br label %loop_begin
618 ;
619 ; CHECK: loop_begin:
620 ; CHECK-NEXT: br label %loop_begin.split
622 loop_begin:
623 br label %inner_loop_begin
625 inner_loop_begin:
626 %v = load i1, ptr %ptr
627 %a = load i32, ptr %a.ptr
628 br i1 %cond1, label %loop_exit, label %inner_loop_b
629 ; The 'loop_exit' clone.
630 ;
631 ; CHECK: loop_begin.split.us:
632 ; CHECK-NEXT: br label %inner_loop_begin.us
633 ;
634 ; CHECK: inner_loop_begin.us:
635 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
636 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
637 ; CHECK-NEXT: br label %loop_exit.loopexit.split.us
638 ;
639 ; CHECK: loop_exit.loopexit.split.us:
640 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A]], %inner_loop_begin.us ]
641 ; CHECK-NEXT: br label %loop_exit
643 inner_loop_b:
644 %b = load i32, ptr %b.ptr
645 br i1 %v, label %inner_loop_begin, label %loop_latch
646 ; The 'inner_loop_b' unswitched loop.
647 ;
648 ; CHECK: loop_begin.split:
649 ; CHECK-NEXT: br label %inner_loop_begin
650 ;
651 ; CHECK: inner_loop_begin:
652 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
653 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
654 ; CHECK-NEXT: br label %inner_loop_b
655 ;
656 ; CHECK: inner_loop_b:
657 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
658 ; CHECK-NEXT: br i1 %[[V]], label %inner_loop_begin, label %loop_latch
660 loop_latch:
661 %b.phi = phi i32 [ %b, %inner_loop_b ]
662 %v2 = load i1, ptr %ptr
663 br i1 %v2, label %loop_begin, label %loop_exit
664 ; CHECK: loop_latch:
665 ; CHECK-NEXT: %[[B_INNER_LCSSA:.*]] = phi i32 [ %[[B]], %inner_loop_b ]
666 ; CHECK-NEXT: %[[V2:.*]] = load i1, ptr %ptr
667 ; CHECK-NEXT: br i1 %[[V2]], label %loop_begin, label %loop_exit.loopexit1
669 loop_exit:
670 %ab.phi = phi i32 [ %a, %inner_loop_begin ], [ %b.phi, %loop_latch ]
671 ret i32 %ab.phi
672 ; CHECK: loop_exit.loopexit:
673 ; CHECK-NEXT: br label %loop_exit
674 ;
675 ; CHECK: loop_exit.loopexit1:
676 ; CHECK-NEXT: %[[B_LCSSA:.*]] = phi i32 [ %[[B_INNER_LCSSA]], %loop_latch ]
677 ; CHECK-NEXT: br label %loop_exit
678 ;
679 ; CHECK: loop_exit:
680 ; CHECK-NEXT: %[[AB_PHI:.*]] = phi i32 [ %[[A_LCSSA]], %loop_exit.loopexit ], [ %[[B_LCSSA]], %loop_exit.loopexit1 ]
681 ; CHECK-NEXT: ret i32 %[[AB_PHI]]
682 }
684 ; Test that we can unswitch a condition where we end up only cloning some of
685 ; the nested loops and needing to delete some of the nested loops.
686 define i32 @test6(ptr %ptr, i1 %cond1, ptr %a.ptr, ptr %b.ptr) {
687 ; CHECK-LABEL: @test6(
688 entry:
689 br label %loop_begin
690 ; CHECK-NEXT: entry:
691 ; CHECK-NEXT: br i1 %cond1, label %entry.split.us, label %entry.split
693 loop_begin:
694 %v = load i1, ptr %ptr
695 br i1 %cond1, label %loop_a, label %loop_b
697 loop_a:
698 br label %loop_a_inner
700 loop_a_inner:
701 %va = load i1, ptr %ptr
702 %a = load i32, ptr %a.ptr
703 br i1 %va, label %loop_a_inner, label %loop_a_inner_exit
705 loop_a_inner_exit:
706 %a.lcssa = phi i32 [ %a, %loop_a_inner ]
707 br label %latch
708 ; The 'loop_a' cloned loop.
709 ;
710 ; CHECK: entry.split.us:
711 ; CHECK-NEXT: br label %loop_begin.us
712 ;
713 ; CHECK: loop_begin.us:
714 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
715 ; CHECK-NEXT: br label %loop_a.us
716 ;
717 ; CHECK: loop_a.us:
718 ; CHECK-NEXT: br label %loop_a_inner.us
719 ;
720 ; CHECK: loop_a_inner.us
721 ; CHECK-NEXT: %[[VA:.*]] = load i1, ptr %ptr
722 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
723 ; CHECK-NEXT: br i1 %[[VA]], label %loop_a_inner.us, label %loop_a_inner_exit.us
724 ;
725 ; CHECK: loop_a_inner_exit.us:
726 ; CHECK-NEXT: %[[A_INNER_LCSSA:.*]] = phi i32 [ %[[A]], %loop_a_inner.us ]
727 ; CHECK-NEXT: br label %latch.us
728 ;
729 ; CHECK: latch.us:
730 ; CHECK-NEXT: %[[A_PHI:.*]] = phi i32 [ %[[A_INNER_LCSSA]], %loop_a_inner_exit.us ]
731 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin.us, label %loop_exit.split.us
732 ;
733 ; CHECK: loop_exit.split.us:
734 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A_PHI]], %latch.us ]
735 ; CHECK-NEXT: br label %loop_exit
737 loop_b:
738 br label %loop_b_inner
740 loop_b_inner:
741 %vb = load i1, ptr %ptr
742 %b = load i32, ptr %b.ptr
743 br i1 %vb, label %loop_b_inner, label %loop_b_inner_exit
745 loop_b_inner_exit:
746 %b.lcssa = phi i32 [ %b, %loop_b_inner ]
747 br label %latch
749 latch:
750 %ab.phi = phi i32 [ %a.lcssa, %loop_a_inner_exit ], [ %b.lcssa, %loop_b_inner_exit ]
751 br i1 %v, label %loop_begin, label %loop_exit
752 ; The 'loop_b' unswitched loop.
753 ;
754 ; CHECK: entry.split:
755 ; CHECK-NEXT: br label %loop_begin
756 ;
757 ; CHECK: loop_begin:
758 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
759 ; CHECK-NEXT: br label %loop_b
760 ;
761 ; CHECK: loop_b:
762 ; CHECK-NEXT: br label %loop_b_inner
763 ;
764 ; CHECK: loop_b_inner
765 ; CHECK-NEXT: %[[VB:.*]] = load i1, ptr %ptr
766 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
767 ; CHECK-NEXT: br i1 %[[VB]], label %loop_b_inner, label %loop_b_inner_exit
768 ;
769 ; CHECK: loop_b_inner_exit:
770 ; CHECK-NEXT: %[[B_INNER_LCSSA:.*]] = phi i32 [ %[[B]], %loop_b_inner ]
771 ; CHECK-NEXT: br label %latch
772 ;
773 ; CHECK: latch:
774 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin, label %loop_exit.split
775 ;
776 ; CHECK: loop_exit.split:
777 ; CHECK-NEXT: %[[B_LCSSA:.*]] = phi i32 [ %[[B_INNER_LCSSA]], %latch ]
778 ; CHECK-NEXT: br label %loop_exit
780 loop_exit:
781 %ab.lcssa = phi i32 [ %ab.phi, %latch ]
782 ret i32 %ab.lcssa
783 ; CHECK: loop_exit:
784 ; CHECK-NEXT: %[[AB_PHI:.*]] = phi i32 [ %[[B_LCSSA]], %loop_exit.split ], [ %[[A_LCSSA]], %loop_exit.split.us ]
785 ; CHECK-NEXT: ret i32 %[[AB_PHI]]
786 }
788 ; Test that when unswitching a deeply nested loop condition in a way that
789 ; produces a non-loop clone that can reach multiple exit blocks which are part
790 ; of different outer loops we correctly divide the cloned loop blocks between
791 ; the outer loops based on reachability.
792 define i32 @test7a(ptr %ptr, ptr %cond.ptr, ptr %a.ptr, ptr %b.ptr) {
793 ; CHECK-LABEL: @test7a(
794 entry:
795 br label %loop_begin
796 ; CHECK-NEXT: entry:
797 ; CHECK-NEXT: br label %loop_begin
799 loop_begin:
800 %a = load i32, ptr %a.ptr
801 br label %inner_loop_begin
802 ; CHECK: loop_begin:
803 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
804 ; CHECK-NEXT: br label %inner_loop_begin
806 inner_loop_begin:
807 %a.phi = phi i32 [ %a, %loop_begin ], [ %a2, %inner_inner_loop_exit ]
808 %cond = load i1, ptr %cond.ptr
809 %b = load i32, ptr %b.ptr
810 br label %inner_inner_loop_begin
811 ; CHECK: inner_loop_begin:
812 ; CHECK-NEXT: %[[A_INNER_PHI:.*]] = phi i32 [ %[[A]], %loop_begin ], [ %[[A2:.*]], %inner_inner_loop_exit ]
813 ; CHECK-NEXT: %[[COND:.*]] = load i1, ptr %cond.ptr
814 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
815 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %[[COND]]
816 ; CHECK-NEXT: br i1 %[[FROZEN]], label %inner_loop_begin.split.us, label %inner_loop_begin.split
818 inner_inner_loop_begin:
819 %v1 = load i1, ptr %ptr
820 br i1 %v1, label %inner_inner_loop_a, label %inner_inner_loop_b
822 inner_inner_loop_a:
823 %v2 = load i1, ptr %ptr
824 br i1 %v2, label %loop_exit, label %inner_inner_loop_c
826 inner_inner_loop_b:
827 %v3 = load i1, ptr %ptr
828 br i1 %v3, label %inner_inner_loop_exit, label %inner_inner_loop_c
830 inner_inner_loop_c:
831 %v4 = load i1, ptr %ptr
832 br i1 %v4, label %inner_loop_exit, label %inner_inner_loop_d
834 inner_inner_loop_d:
835 br i1 %cond, label %inner_loop_exit, label %inner_inner_loop_begin
836 ; The cloned copy that always exits with the adjustments required to fix up
837 ; loop exits.
838 ;
839 ; CHECK: inner_loop_begin.split.us:
840 ; CHECK-NEXT: br label %inner_inner_loop_begin.us
841 ;
842 ; CHECK: inner_inner_loop_begin.us:
843 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
844 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_a.us, label %inner_inner_loop_b.us
845 ;
846 ; CHECK: inner_inner_loop_b.us:
847 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
848 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_exit.split.us, label %inner_inner_loop_c.us.loopexit
849 ;
850 ; CHECK: inner_inner_loop_a.us:
851 ; CHECK-NEXT: %[[A_NEW_LCSSA:.*]] = phi i32 [ %[[A_INNER_PHI]], %inner_inner_loop_begin.us ]
852 ; CHECK-NEXT: %[[B_NEW_LCSSA:.*]] = phi i32 [ %[[B]], %inner_inner_loop_begin.us ]
853 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
854 ; CHECK-NEXT: br i1 %[[V]], label %loop_exit.split.us, label %inner_inner_loop_c.us
855 ;
856 ; CHECK: inner_inner_loop_c.us.loopexit:
857 ; CHECK-NEXT: br label %inner_inner_loop_c.us
858 ;
859 ; CHECK: inner_inner_loop_c.us:
860 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
861 ; CHECK-NEXT: br i1 %[[V]], label %inner_loop_exit.loopexit.split.us, label %inner_inner_loop_d.us
862 ;
863 ; CHECK: inner_inner_loop_d.us:
864 ; CHECK-NEXT: br label %inner_loop_exit.loopexit.split
865 ;
866 ; CHECK: inner_inner_loop_exit.split.us:
867 ; CHECK-NEXT: br label %inner_inner_loop_exit
868 ;
869 ; CHECK: loop_exit.split.us:
870 ; CHECK-NEXT: %[[A_LCSSA_US:.*]] = phi i32 [ %[[A_NEW_LCSSA]], %inner_inner_loop_a.us ]
871 ; CHECK-NEXT: %[[B_LCSSA_US:.*]] = phi i32 [ %[[B_NEW_LCSSA]], %inner_inner_loop_a.us ]
872 ; CHECK-NEXT: br label %loop_exit
873 ;
874 ; CHECK: inner_loop_exit.loopexit.split.us:
875 ; CHECK-NEXT: br label %inner_loop_exit.loopexit
876 ;
877 ; The original copy that continues to loop.
878 ;
879 ; CHECK: inner_loop_begin.split:
880 ; CHECK-NEXT: br label %inner_inner_loop_begin
881 ;
882 ; CHECK: inner_inner_loop_begin:
883 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
884 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_a, label %inner_inner_loop_b
885 ;
886 ; CHECK: inner_inner_loop_a:
887 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
888 ; CHECK-NEXT: br i1 %[[V]], label %loop_exit.split, label %inner_inner_loop_c
889 ;
890 ; CHECK: inner_inner_loop_b:
891 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
892 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_exit.split, label %inner_inner_loop_c
893 ;
894 ; CHECK: inner_inner_loop_c:
895 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
896 ; CHECK-NEXT: br i1 %[[V]], label %inner_loop_exit.loopexit.split, label %inner_inner_loop_d
897 ;
898 ; CHECK: inner_inner_loop_d:
899 ; CHECK-NEXT: br label %inner_inner_loop_begin
900 ;
901 ; CHECK: inner_inner_loop_exit.split:
902 ; CHECK-NEXT: br label %inner_inner_loop_exit
904 inner_inner_loop_exit:
905 %a2 = load i32, ptr %a.ptr
906 %v5 = load i1, ptr %ptr
907 br i1 %v5, label %inner_loop_exit, label %inner_loop_begin
908 ; CHECK: inner_inner_loop_exit:
909 ; CHECK-NEXT: %[[A2]] = load i32, ptr %a.ptr
910 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
911 ; CHECK-NEXT: br i1 %[[V]], label %inner_loop_exit.loopexit1, label %inner_loop_begin
913 inner_loop_exit:
914 br label %loop_begin
915 ; CHECK: inner_loop_exit.loopexit.split:
916 ; CHECK-NEXT: br label %inner_loop_exit.loopexit
917 ;
918 ; CHECK: inner_loop_exit.loopexit:
919 ; CHECK-NEXT: br label %inner_loop_exit
920 ;
921 ; CHECK: inner_loop_exit.loopexit1:
922 ; CHECK-NEXT: br label %inner_loop_exit
923 ;
924 ; CHECK: inner_loop_exit:
925 ; CHECK-NEXT: br label %loop_begin
927 loop_exit:
928 %a.lcssa = phi i32 [ %a.phi, %inner_inner_loop_a ]
929 %b.lcssa = phi i32 [ %b, %inner_inner_loop_a ]
930 %result = add i32 %a.lcssa, %b.lcssa
931 ret i32 %result
932 ; CHECK: loop_exit.split:
933 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A_INNER_PHI]], %inner_inner_loop_a ]
934 ; CHECK-NEXT: %[[B_LCSSA:.*]] = phi i32 [ %[[B]], %inner_inner_loop_a ]
935 ; CHECK-NEXT: br label %loop_exit
936 ;
937 ; CHECK: loop_exit:
938 ; CHECK-NEXT: %[[A_PHI:.*]] = phi i32 [ %[[A_LCSSA]], %loop_exit.split ], [ %[[A_LCSSA_US]], %loop_exit.split.us ]
939 ; CHECK-NEXT: %[[B_PHI:.*]] = phi i32 [ %[[B_LCSSA]], %loop_exit.split ], [ %[[B_LCSSA_US]], %loop_exit.split.us ]
940 ; CHECK-NEXT: %[[RESULT:.*]] = add i32 %[[A_PHI]], %[[B_PHI]]
941 ; CHECK-NEXT: ret i32 %[[RESULT]]
942 }
944 ; Same pattern as @test7a but here the original loop becomes a non-loop that
945 ; can reach multiple exit blocks which are part of different outer loops.
946 define i32 @test7b(ptr %ptr, ptr %cond.ptr, ptr %a.ptr, ptr %b.ptr) {
947 ; CHECK-LABEL: @test7b(
948 entry:
949 br label %loop_begin
950 ; CHECK-NEXT: entry:
951 ; CHECK-NEXT: br label %loop_begin
953 loop_begin:
954 %a = load i32, ptr %a.ptr
955 br label %inner_loop_begin
956 ; CHECK: loop_begin:
957 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
958 ; CHECK-NEXT: br label %inner_loop_begin
960 inner_loop_begin:
961 %a.phi = phi i32 [ %a, %loop_begin ], [ %a2, %inner_inner_loop_exit ]
962 %cond = load i1, ptr %cond.ptr
963 %b = load i32, ptr %b.ptr
964 br label %inner_inner_loop_begin
965 ; CHECK: inner_loop_begin:
966 ; CHECK-NEXT: %[[A_INNER_PHI:.*]] = phi i32 [ %[[A]], %loop_begin ], [ %[[A2:.*]], %inner_inner_loop_exit ]
967 ; CHECK-NEXT: %[[COND:.*]] = load i1, ptr %cond.ptr
968 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
969 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %[[COND]]
970 ; CHECK-NEXT: br i1 %[[FROZEN]], label %inner_loop_begin.split.us, label %inner_loop_begin.split
972 inner_inner_loop_begin:
973 %v1 = load i1, ptr %ptr
974 br i1 %v1, label %inner_inner_loop_a, label %inner_inner_loop_b
976 inner_inner_loop_a:
977 %v2 = load i1, ptr %ptr
978 br i1 %v2, label %loop_exit, label %inner_inner_loop_c
980 inner_inner_loop_b:
981 %v3 = load i1, ptr %ptr
982 br i1 %v3, label %inner_inner_loop_exit, label %inner_inner_loop_c
984 inner_inner_loop_c:
985 %v4 = load i1, ptr %ptr
986 br i1 %v4, label %inner_loop_exit, label %inner_inner_loop_d
988 inner_inner_loop_d:
989 br i1 %cond, label %inner_inner_loop_begin, label %inner_loop_exit
990 ; The cloned copy that continues looping.
991 ;
992 ; CHECK: inner_loop_begin.split.us:
993 ; CHECK-NEXT: br label %inner_inner_loop_begin.us
994 ;
995 ; CHECK: inner_inner_loop_begin.us:
996 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
997 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_a.us, label %inner_inner_loop_b.us
998 ;
999 ; CHECK: inner_inner_loop_b.us:
1000 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1001 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_exit.split.us, label %inner_inner_loop_c.us
1002 ;
1003 ; CHECK: inner_inner_loop_a.us:
1004 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1005 ; CHECK-NEXT: br i1 %[[V]], label %loop_exit.split.us, label %inner_inner_loop_c.us
1006 ;
1007 ; CHECK: inner_inner_loop_c.us:
1008 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1009 ; CHECK-NEXT: br i1 %[[V]], label %inner_loop_exit.loopexit.split.us, label %inner_inner_loop_d.us
1010 ;
1011 ; CHECK: inner_inner_loop_d.us:
1012 ; CHECK-NEXT: br label %inner_inner_loop_begin.us
1013 ;
1014 ; CHECK: inner_inner_loop_exit.split.us:
1015 ; CHECK-NEXT: br label %inner_inner_loop_exit
1016 ;
1017 ; CHECK: loop_exit.split.us:
1018 ; CHECK-NEXT: %[[A_LCSSA_US:.*]] = phi i32 [ %[[A_INNER_PHI]], %inner_inner_loop_a.us ]
1019 ; CHECK-NEXT: %[[B_LCSSA_US:.*]] = phi i32 [ %[[B]], %inner_inner_loop_a.us ]
1020 ; CHECK-NEXT: br label %loop_exit
1021 ;
1022 ; CHECK: inner_loop_exit.loopexit.split.us:
1023 ; CHECK-NEXT: br label %inner_loop_exit.loopexit
1024 ;
1025 ; The original copy that now always exits and needs adjustments for exit
1026 ; blocks.
1027 ;
1028 ; CHECK: inner_loop_begin.split:
1029 ; CHECK-NEXT: br label %inner_inner_loop_begin
1030 ;
1031 ; CHECK: inner_inner_loop_begin:
1032 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1033 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_a, label %inner_inner_loop_b
1034 ;
1035 ; CHECK: inner_inner_loop_a:
1036 ; CHECK-NEXT: %[[A_NEW_LCSSA:.*]] = phi i32 [ %[[A_INNER_PHI]], %inner_inner_loop_begin ]
1037 ; CHECK-NEXT: %[[B_NEW_LCSSA:.*]] = phi i32 [ %[[B]], %inner_inner_loop_begin ]
1038 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1039 ; CHECK-NEXT: br i1 %[[V]], label %loop_exit.split, label %inner_inner_loop_c
1040 ;
1041 ; CHECK: inner_inner_loop_b:
1042 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1043 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_exit.split, label %inner_inner_loop_c.loopexit
1044 ;
1045 ; CHECK: inner_inner_loop_c.loopexit:
1046 ; CHECK-NEXT: br label %inner_inner_loop_c
1047 ;
1048 ; CHECK: inner_inner_loop_c:
1049 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1050 ; CHECK-NEXT: br i1 %[[V]], label %inner_loop_exit.loopexit.split, label %inner_inner_loop_d
1051 ;
1052 ; CHECK: inner_inner_loop_d:
1053 ; CHECK-NEXT: br label %inner_loop_exit.loopexit.split
1054 ;
1055 ; CHECK: inner_inner_loop_exit.split:
1056 ; CHECK-NEXT: br label %inner_inner_loop_exit
1058 inner_inner_loop_exit:
1059 %a2 = load i32, ptr %a.ptr
1060 %v5 = load i1, ptr %ptr
1061 br i1 %v5, label %inner_loop_exit, label %inner_loop_begin
1062 ; CHECK: inner_inner_loop_exit:
1063 ; CHECK-NEXT: %[[A2]] = load i32, ptr %a.ptr
1064 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1065 ; CHECK-NEXT: br i1 %[[V]], label %inner_loop_exit.loopexit1, label %inner_loop_begin
1067 inner_loop_exit:
1068 br label %loop_begin
1069 ; CHECK: inner_loop_exit.loopexit.split:
1070 ; CHECK-NEXT: br label %inner_loop_exit.loopexit
1071 ;
1072 ; CHECK: inner_loop_exit.loopexit:
1073 ; CHECK-NEXT: br label %inner_loop_exit
1074 ;
1075 ; CHECK: inner_loop_exit.loopexit1:
1076 ; CHECK-NEXT: br label %inner_loop_exit
1077 ;
1078 ; CHECK: inner_loop_exit:
1079 ; CHECK-NEXT: br label %loop_begin
1081 loop_exit:
1082 %a.lcssa = phi i32 [ %a.phi, %inner_inner_loop_a ]
1083 %b.lcssa = phi i32 [ %b, %inner_inner_loop_a ]
1084 %result = add i32 %a.lcssa, %b.lcssa
1085 ret i32 %result
1086 ; CHECK: loop_exit.split:
1087 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A_NEW_LCSSA]], %inner_inner_loop_a ]
1088 ; CHECK-NEXT: %[[B_LCSSA:.*]] = phi i32 [ %[[B_NEW_LCSSA]], %inner_inner_loop_a ]
1089 ; CHECK-NEXT: br label %loop_exit
1090 ;
1091 ; CHECK: loop_exit:
1092 ; CHECK-NEXT: %[[A_PHI:.*]] = phi i32 [ %[[A_LCSSA]], %loop_exit.split ], [ %[[A_LCSSA_US]], %loop_exit.split.us ]
1093 ; CHECK-NEXT: %[[B_PHI:.*]] = phi i32 [ %[[B_LCSSA]], %loop_exit.split ], [ %[[B_LCSSA_US]], %loop_exit.split.us ]
1094 ; CHECK-NEXT: %[[RESULT:.*]] = add i32 %[[A_PHI]], %[[B_PHI]]
1095 ; CHECK-NEXT: ret i32 %[[RESULT]]
1096 }
1098 ; Test that when the exit block set of an inner loop changes to start at a less
1099 ; high level of the loop nest we correctly hoist the loop up the nest.
1100 define i32 @test8a(ptr %ptr, ptr %cond.ptr, ptr %a.ptr, ptr %b.ptr) {
1101 ; CHECK-LABEL: @test8a(
1102 entry:
1103 br label %loop_begin
1104 ; CHECK-NEXT: entry:
1105 ; CHECK-NEXT: br label %loop_begin
1107 loop_begin:
1108 %a = load i32, ptr %a.ptr
1109 br label %inner_loop_begin
1110 ; CHECK: loop_begin:
1111 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1112 ; CHECK-NEXT: br label %inner_loop_begin
1114 inner_loop_begin:
1115 %a.phi = phi i32 [ %a, %loop_begin ], [ %a2, %inner_inner_loop_exit ]
1116 %cond = load i1, ptr %cond.ptr
1117 %b = load i32, ptr %b.ptr
1118 br label %inner_inner_loop_begin
1119 ; CHECK: inner_loop_begin:
1120 ; CHECK-NEXT: %[[A_INNER_PHI:.*]] = phi i32 [ %[[A]], %loop_begin ], [ %[[A2:.*]], %inner_inner_loop_exit ]
1121 ; CHECK-NEXT: %[[COND:.*]] = load i1, ptr %cond.ptr
1122 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
1123 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %[[COND]]
1124 ; CHECK-NEXT: br i1 %[[FROZEN]], label %inner_loop_begin.split.us, label %inner_loop_begin.split
1126 inner_inner_loop_begin:
1127 %v1 = load i1, ptr %ptr
1128 br i1 %v1, label %inner_inner_loop_a, label %inner_inner_loop_b
1130 inner_inner_loop_a:
1131 %v2 = load i1, ptr %ptr
1132 br i1 %v2, label %inner_inner_loop_latch, label %inner_loop_exit
1134 inner_inner_loop_b:
1135 br i1 %cond, label %inner_inner_loop_latch, label %inner_inner_loop_exit
1137 inner_inner_loop_latch:
1138 br label %inner_inner_loop_begin
1139 ; The cloned region is now an exit from the inner loop.
1140 ;
1141 ; CHECK: inner_loop_begin.split.us:
1142 ; CHECK-NEXT: %[[A_INNER_INNER_LCSSA:.*]] = phi i32 [ %[[A_INNER_PHI]], %inner_loop_begin ]
1143 ; CHECK-NEXT: br label %inner_inner_loop_begin.us
1144 ;
1145 ; CHECK: inner_inner_loop_begin.us:
1146 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1147 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_a.us, label %inner_inner_loop_b.us
1148 ;
1149 ; CHECK: inner_inner_loop_b.us:
1150 ; CHECK-NEXT: br label %inner_inner_loop_latch.us
1151 ;
1152 ; CHECK: inner_inner_loop_a.us:
1153 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1154 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_latch.us, label %inner_loop_exit.loopexit.split.us
1155 ;
1156 ; CHECK: inner_inner_loop_latch.us:
1157 ; CHECK-NEXT: br label %inner_inner_loop_begin.us
1158 ;
1159 ; CHECK: inner_loop_exit.loopexit.split.us:
1160 ; CHECK-NEXT: %[[A_INNER_LCSSA_US:.*]] = phi i32 [ %[[A_INNER_INNER_LCSSA]], %inner_inner_loop_a.us ]
1161 ; CHECK-NEXT: br label %inner_loop_exit.loopexit
1162 ;
1163 ; The original region exits the loop earlier.
1164 ;
1165 ; CHECK: inner_loop_begin.split:
1166 ; CHECK-NEXT: br label %inner_inner_loop_begin
1167 ;
1168 ; CHECK: inner_inner_loop_begin:
1169 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1170 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_a, label %inner_inner_loop_b
1171 ;
1172 ; CHECK: inner_inner_loop_a:
1173 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1174 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_latch, label %inner_loop_exit.loopexit.split
1175 ;
1176 ; CHECK: inner_inner_loop_b:
1177 ; CHECK-NEXT: br label %inner_inner_loop_exit
1178 ;
1179 ; CHECK: inner_inner_loop_latch:
1180 ; CHECK-NEXT: br label %inner_inner_loop_begin
1182 inner_inner_loop_exit:
1183 %a2 = load i32, ptr %a.ptr
1184 %v4 = load i1, ptr %ptr
1185 br i1 %v4, label %inner_loop_exit, label %inner_loop_begin
1186 ; CHECK: inner_inner_loop_exit:
1187 ; CHECK-NEXT: %[[A2]] = load i32, ptr %a.ptr
1188 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1189 ; CHECK-NEXT: br i1 %[[V]], label %inner_loop_exit.loopexit1, label %inner_loop_begin
1191 inner_loop_exit:
1192 %v5 = load i1, ptr %ptr
1193 br i1 %v5, label %loop_exit, label %loop_begin
1194 ; CHECK: inner_loop_exit.loopexit.split:
1195 ; CHECK-NEXT: %[[A_INNER_LCSSA:.*]] = phi i32 [ %[[A_INNER_PHI]], %inner_inner_loop_a ]
1196 ; CHECK-NEXT: br label %inner_loop_exit.loopexit
1197 ;
1198 ; CHECK: inner_loop_exit.loopexit:
1199 ; CHECK-NEXT: %[[A_INNER_US_PHI:.*]] = phi i32 [ %[[A_INNER_LCSSA]], %inner_loop_exit.loopexit.split ], [ %[[A_INNER_LCSSA_US]], %inner_loop_exit.loopexit.split.us ]
1200 ; CHECK-NEXT: br label %inner_loop_exit
1201 ;
1202 ; CHECK: inner_loop_exit.loopexit1:
1203 ; CHECK-NEXT: %[[A_INNER_LCSSA2:.*]] = phi i32 [ %[[A_INNER_PHI]], %inner_inner_loop_exit ]
1204 ; CHECK-NEXT: br label %inner_loop_exit
1205 ;
1206 ; CHECK: inner_loop_exit:
1207 ; CHECK-NEXT: %[[A_INNER_PHI:.*]] = phi i32 [ %[[A_INNER_LCSSA2]], %inner_loop_exit.loopexit1 ], [ %[[A_INNER_US_PHI]], %inner_loop_exit.loopexit ]
1208 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1209 ; CHECK-NEXT: br i1 %[[V]], label %loop_exit, label %loop_begin
1211 loop_exit:
1212 %a.lcssa = phi i32 [ %a.phi, %inner_loop_exit ]
1213 ret i32 %a.lcssa
1214 ; CHECK: loop_exit:
1215 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A_INNER_PHI]], %inner_loop_exit ]
1216 ; CHECK-NEXT: ret i32 %[[A_LCSSA]]
1217 }
1219 ; Same pattern as @test8a but where the original loop looses an exit block and
1220 ; needs to be hoisted up the nest.
1221 define i32 @test8b(ptr %ptr, ptr %cond.ptr, ptr %a.ptr, ptr %b.ptr) {
1222 ; CHECK-LABEL: @test8b(
1223 entry:
1224 br label %loop_begin
1225 ; CHECK-NEXT: entry:
1226 ; CHECK-NEXT: br label %loop_begin
1228 loop_begin:
1229 %a = load i32, ptr %a.ptr
1230 br label %inner_loop_begin
1231 ; CHECK: loop_begin:
1232 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1233 ; CHECK-NEXT: br label %inner_loop_begin
1235 inner_loop_begin:
1236 %a.phi = phi i32 [ %a, %loop_begin ], [ %a2, %inner_inner_loop_exit ]
1237 %cond = load i1, ptr %cond.ptr
1238 %b = load i32, ptr %b.ptr
1239 br label %inner_inner_loop_begin
1240 ; CHECK: inner_loop_begin:
1241 ; CHECK-NEXT: %[[A_INNER_PHI:.*]] = phi i32 [ %[[A]], %loop_begin ], [ %[[A2:.*]], %inner_inner_loop_exit ]
1242 ; CHECK-NEXT: %[[COND:.*]] = load i1, ptr %cond.ptr
1243 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
1244 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %[[COND]]
1245 ; CHECK-NEXT: br i1 %[[FROZEN]], label %inner_loop_begin.split.us, label %inner_loop_begin.split
1247 inner_inner_loop_begin:
1248 %v1 = load i1, ptr %ptr
1249 br i1 %v1, label %inner_inner_loop_a, label %inner_inner_loop_b
1251 inner_inner_loop_a:
1252 %v2 = load i1, ptr %ptr
1253 br i1 %v2, label %inner_inner_loop_latch, label %inner_loop_exit
1255 inner_inner_loop_b:
1256 br i1 %cond, label %inner_inner_loop_exit, label %inner_inner_loop_latch
1258 inner_inner_loop_latch:
1259 br label %inner_inner_loop_begin
1260 ; The cloned region is similar to before but with one earlier exit.
1261 ;
1262 ; CHECK: inner_loop_begin.split.us:
1263 ; CHECK-NEXT: br label %inner_inner_loop_begin.us
1264 ;
1265 ; CHECK: inner_inner_loop_begin.us:
1266 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1267 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_a.us, label %inner_inner_loop_b.us
1268 ;
1269 ; CHECK: inner_inner_loop_b.us:
1270 ; CHECK-NEXT: br label %inner_inner_loop_exit.split.us
1271 ;
1272 ; CHECK: inner_inner_loop_a.us:
1273 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1274 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_latch.us, label %inner_loop_exit.loopexit.split.us
1275 ;
1276 ; CHECK: inner_inner_loop_latch.us:
1277 ; CHECK-NEXT: br label %inner_inner_loop_begin.us
1278 ;
1279 ; CHECK: inner_inner_loop_exit.split.us:
1280 ; CHECK-NEXT: br label %inner_inner_loop_exit
1281 ;
1282 ; CHECK: inner_loop_exit.loopexit.split.us:
1283 ; CHECK-NEXT: %[[A_INNER_LCSSA_US:.*]] = phi i32 [ %[[A_INNER_PHI]], %inner_inner_loop_a.us ]
1284 ; CHECK-NEXT: br label %inner_loop_exit.loopexit
1285 ;
1286 ; The original region is now an exit in the preheader.
1287 ;
1288 ; CHECK: inner_loop_begin.split:
1289 ; CHECK-NEXT: %[[A_INNER_INNER_LCSSA:.*]] = phi i32 [ %[[A_INNER_PHI]], %inner_loop_begin ]
1290 ; CHECK-NEXT: br label %inner_inner_loop_begin
1291 ;
1292 ; CHECK: inner_inner_loop_begin:
1293 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1294 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_a, label %inner_inner_loop_b
1295 ;
1296 ; CHECK: inner_inner_loop_a:
1297 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1298 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_latch, label %inner_loop_exit.loopexit.split
1299 ;
1300 ; CHECK: inner_inner_loop_b:
1301 ; CHECK-NEXT: br label %inner_inner_loop_latch
1302 ;
1303 ; CHECK: inner_inner_loop_latch:
1304 ; CHECK-NEXT: br label %inner_inner_loop_begin
1306 inner_inner_loop_exit:
1307 %a2 = load i32, ptr %a.ptr
1308 %v4 = load i1, ptr %ptr
1309 br i1 %v4, label %inner_loop_exit, label %inner_loop_begin
1310 ; CHECK: inner_inner_loop_exit:
1311 ; CHECK-NEXT: %[[A2]] = load i32, ptr %a.ptr
1312 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1313 ; CHECK-NEXT: br i1 %[[V]], label %inner_loop_exit.loopexit1, label %inner_loop_begin
1315 inner_loop_exit:
1316 %v5 = load i1, ptr %ptr
1317 br i1 %v5, label %loop_exit, label %loop_begin
1318 ; CHECK: inner_loop_exit.loopexit.split:
1319 ; CHECK-NEXT: %[[A_INNER_LCSSA:.*]] = phi i32 [ %[[A_INNER_INNER_LCSSA]], %inner_inner_loop_a ]
1320 ; CHECK-NEXT: br label %inner_loop_exit.loopexit
1321 ;
1322 ; CHECK: inner_loop_exit.loopexit:
1323 ; CHECK-NEXT: %[[A_INNER_US_PHI:.*]] = phi i32 [ %[[A_INNER_LCSSA]], %inner_loop_exit.loopexit.split ], [ %[[A_INNER_LCSSA_US]], %inner_loop_exit.loopexit.split.us ]
1324 ; CHECK-NEXT: br label %inner_loop_exit
1325 ;
1326 ; CHECK: inner_loop_exit.loopexit1:
1327 ; CHECK-NEXT: %[[A_INNER_LCSSA2:.*]] = phi i32 [ %[[A_INNER_PHI]], %inner_inner_loop_exit ]
1328 ; CHECK-NEXT: br label %inner_loop_exit
1329 ;
1330 ; CHECK: inner_loop_exit:
1331 ; CHECK-NEXT: %[[A_INNER_PHI:.*]] = phi i32 [ %[[A_INNER_LCSSA2]], %inner_loop_exit.loopexit1 ], [ %[[A_INNER_US_PHI]], %inner_loop_exit.loopexit ]
1332 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1333 ; CHECK-NEXT: br i1 %[[V]], label %loop_exit, label %loop_begin
1335 loop_exit:
1336 %a.lcssa = phi i32 [ %a.phi, %inner_loop_exit ]
1337 ret i32 %a.lcssa
1338 ; CHECK: loop_exit:
1339 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A_INNER_PHI]], %inner_loop_exit ]
1340 ; CHECK-NEXT: ret i32 %[[A_LCSSA]]
1341 }
1343 ; Test for when unswitching produces a clone of an inner loop but
1344 ; the clone no longer has an exiting edge *at all* and loops infinitely.
1345 ; Because it doesn't ever exit to the outer loop it is no longer an inner loop
1346 ; but needs to be hoisted up the nest to be a top-level loop.
1347 define i32 @test9a(ptr %ptr, ptr %cond.ptr, ptr %a.ptr, ptr %b.ptr) {
1348 ; CHECK-LABEL: @test9a(
1349 entry:
1350 br label %loop_begin
1351 ; CHECK-NEXT: entry:
1352 ; CHECK-NEXT: br label %loop_begin
1354 loop_begin:
1355 %b = load i32, ptr %b.ptr
1356 %cond = load i1, ptr %cond.ptr
1357 br label %inner_loop_begin
1358 ; CHECK: loop_begin:
1359 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
1360 ; CHECK-NEXT: %[[COND:.*]] = load i1, ptr %cond.ptr
1361 ; CHECK-NEXT: br i1 %[[COND]], label %loop_begin.split.us, label %loop_begin.split
1363 inner_loop_begin:
1364 %a = load i32, ptr %a.ptr
1365 br i1 %cond, label %inner_loop_latch, label %inner_loop_exit
1367 inner_loop_latch:
1368 call void @sink1(i32 %b)
1369 br label %inner_loop_begin
1370 ; The cloned inner loop ends up as an infinite loop and thus being a top-level
1371 ; loop with the preheader as an exit block of the outer loop.
1372 ;
1373 ; CHECK: loop_begin.split.us
1374 ; CHECK-NEXT: %[[B_LCSSA:.*]] = phi i32 [ %[[B]], %loop_begin ]
1375 ; CHECK-NEXT: br label %inner_loop_begin.us
1376 ;
1377 ; CHECK: inner_loop_begin.us:
1378 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1379 ; CHECK-NEXT: br label %inner_loop_latch.us
1380 ;
1381 ; CHECK: inner_loop_latch.us:
1382 ; CHECK-NEXT: call void @sink1(i32 %[[B_LCSSA]])
1383 ; CHECK-NEXT: br label %inner_loop_begin.us
1384 ;
1385 ; The original loop becomes boring non-loop code.
1386 ;
1387 ; CHECK: loop_begin.split
1388 ; CHECK-NEXT: br label %inner_loop_begin
1389 ;
1390 ; CHECK: inner_loop_begin:
1391 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1392 ; CHECK-NEXT: br label %inner_loop_exit
1394 inner_loop_exit:
1395 %a.inner_lcssa = phi i32 [ %a, %inner_loop_begin ]
1396 %v = load i1, ptr %ptr
1397 br i1 %v, label %loop_begin, label %loop_exit
1398 ; CHECK: inner_loop_exit:
1399 ; CHECK-NEXT: %[[A_INNER_LCSSA:.*]] = phi i32 [ %[[A]], %inner_loop_begin ]
1400 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1401 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin, label %loop_exit
1403 loop_exit:
1404 %a.lcssa = phi i32 [ %a.inner_lcssa, %inner_loop_exit ]
1405 ret i32 %a.lcssa
1406 ; CHECK: loop_exit:
1407 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A_INNER_LCSSA]], %inner_loop_exit ]
1408 ; CHECK-NEXT: ret i32 %[[A_LCSSA]]
1409 }
1411 ; The same core pattern as @test9a, but instead of the cloned loop becoming an
1412 ; infinite loop, the original loop has its only exit unswitched and the
1413 ; original loop becomes infinite and must be hoisted out of the loop nest.
1414 define i32 @test9b(ptr %ptr, ptr %cond.ptr, ptr %a.ptr, ptr %b.ptr) {
1415 ; CHECK-LABEL: @test9b(
1416 entry:
1417 br label %loop_begin
1418 ; CHECK-NEXT: entry:
1419 ; CHECK-NEXT: br label %loop_begin
1421 loop_begin:
1422 %b = load i32, ptr %b.ptr
1423 %cond = load i1, ptr %cond.ptr
1424 br label %inner_loop_begin
1425 ; CHECK: loop_begin:
1426 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
1427 ; CHECK-NEXT: %[[COND:.*]] = load i1, ptr %cond.ptr
1428 ; CHECK-NEXT: br i1 %[[COND]], label %loop_begin.split.us, label %loop_begin.split
1430 inner_loop_begin:
1431 %a = load i32, ptr %a.ptr
1432 br i1 %cond, label %inner_loop_exit, label %inner_loop_latch
1434 inner_loop_latch:
1435 call void @sink1(i32 %b)
1436 br label %inner_loop_begin
1437 ; The cloned inner loop becomes a boring non-loop.
1438 ;
1439 ; CHECK: loop_begin.split.us
1440 ; CHECK-NEXT: br label %inner_loop_begin.us
1441 ;
1442 ; CHECK: inner_loop_begin.us:
1443 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1444 ; CHECK-NEXT: br label %inner_loop_exit.split.us
1445 ;
1446 ; CHECK: inner_loop_exit.split.us
1447 ; CHECK-NEXT: %[[A_INNER_LCSSA_US:.*]] = phi i32 [ %[[A]], %inner_loop_begin.us ]
1448 ; CHECK-NEXT: br label %inner_loop_exit
1449 ;
1450 ; The original loop becomes an infinite loop and thus a top-level loop with the
1451 ; preheader as an exit block for the outer loop.
1452 ;
1453 ; CHECK: loop_begin.split
1454 ; CHECK-NEXT: %[[B_LCSSA:.*]] = phi i32 [ %[[B]], %loop_begin ]
1455 ; CHECK-NEXT: br label %inner_loop_begin
1456 ;
1457 ; CHECK: inner_loop_begin:
1458 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1459 ; CHECK-NEXT: br label %inner_loop_latch
1460 ;
1461 ; CHECK: inner_loop_latch:
1462 ; CHECK-NEXT: call void @sink1(i32 %[[B_LCSSA]])
1463 ; CHECK-NEXT: br label %inner_loop_begin
1465 inner_loop_exit:
1466 %a.inner_lcssa = phi i32 [ %a, %inner_loop_begin ]
1467 %v = load i1, ptr %ptr
1468 br i1 %v, label %loop_begin, label %loop_exit
1469 ; CHECK: inner_loop_exit:
1470 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1471 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin, label %loop_exit
1473 loop_exit:
1474 %a.lcssa = phi i32 [ %a.inner_lcssa, %inner_loop_exit ]
1475 ret i32 %a.lcssa
1476 ; CHECK: loop_exit:
1477 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A_INNER_LCSSA_US]], %inner_loop_exit ]
1478 ; CHECK-NEXT: ret i32 %[[A_LCSSA]]
1479 }
1481 ; Test that requires re-forming dedicated exits for the cloned loop.
1482 define i32 @test10a(ptr %ptr, i1 %cond, ptr %a.ptr) {
1483 ; CHECK-LABEL: @test10a(
1484 entry:
1485 br label %loop_begin
1486 ; CHECK-NEXT: entry:
1487 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %cond
1488 ; CHECK-NEXT: br i1 %[[FROZEN]], label %entry.split.us, label %entry.split
1490 loop_begin:
1491 %a = load i32, ptr %a.ptr
1492 %v1 = load i1, ptr %ptr
1493 br i1 %v1, label %loop_a, label %loop_b
1495 loop_a:
1496 %v2 = load i1, ptr %ptr
1497 br i1 %v2, label %loop_exit, label %loop_begin
1499 loop_b:
1500 br i1 %cond, label %loop_exit, label %loop_begin
1501 ; The cloned loop with one edge as a direct exit.
1502 ;
1503 ; CHECK: entry.split.us:
1504 ; CHECK-NEXT: br label %loop_begin.us
1505 ;
1506 ; CHECK: loop_begin.us:
1507 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1508 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1509 ; CHECK-NEXT: br i1 %[[V]], label %loop_a.us, label %loop_b.us
1510 ;
1511 ; CHECK: loop_b.us:
1512 ; CHECK-NEXT: %[[A_LCSSA_B:.*]] = phi i32 [ %[[A]], %loop_begin.us ]
1513 ; CHECK-NEXT: br label %loop_exit.split.us
1514 ;
1515 ; CHECK: loop_a.us:
1516 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1517 ; CHECK-NEXT: br i1 %[[V]], label %loop_exit.split.us.loopexit, label %loop_begin.backedge.us
1518 ;
1519 ; CHECK: loop_begin.backedge.us:
1520 ; CHECK-NEXT: br label %loop_begin.us
1521 ;
1522 ; CHECK: loop_exit.split.us.loopexit:
1523 ; CHECK-NEXT: %[[A_LCSSA_A:.*]] = phi i32 [ %[[A]], %loop_a.us ]
1524 ; CHECK-NEXT: br label %loop_exit
1525 ;
1526 ; CHECK: loop_exit.split.us:
1527 ; CHECK-NEXT: %[[A_PHI_US:.*]] = phi i32 [ %[[A_LCSSA_B]], %loop_b.us ], [ %[[A_LCSSA_A]], %loop_exit.split.us.loopexit ]
1528 ; CHECK-NEXT: br label %loop_exit
1530 ; The original loop without one 'loop_exit' edge.
1531 ;
1532 ; CHECK: entry.split:
1533 ; CHECK-NEXT: br label %loop_begin
1534 ;
1535 ; CHECK: loop_begin:
1536 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1537 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1538 ; CHECK-NEXT: br i1 %[[V]], label %loop_a, label %loop_b
1539 ;
1540 ; CHECK: loop_a:
1541 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1542 ; CHECK-NEXT: br i1 %[[V]], label %loop_exit.split, label %loop_begin.backedge
1543 ;
1544 ; CHECK: loop_begin.backedge:
1545 ; CHECK-NEXT: br label %loop_begin
1546 ;
1547 ; CHECK: loop_b:
1548 ; CHECK-NEXT: br label %loop_begin.backedge
1549 ;
1550 ; CHECK: loop_exit.split:
1551 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A]], %loop_a ]
1552 ; CHECK-NEXT: br label %loop_exit
1554 loop_exit:
1555 %a.lcssa = phi i32 [ %a, %loop_a ], [ %a, %loop_b ]
1556 ret i32 %a.lcssa
1557 ; CHECK: loop_exit:
1558 ; CHECK-NEXT: %[[A_PHI:.*]] = phi i32 [ %[[A_LCSSA]], %loop_exit.split ], [ %[[A_PHI_US]], %loop_exit.split.us ]
1559 ; CHECK-NEXT: ret i32 %[[A_PHI]]
1560 }
1562 ; Test that requires re-forming dedicated exits for the original loop.
1563 define i32 @test10b(ptr %ptr, i1 %cond, ptr %a.ptr) {
1564 ; CHECK-LABEL: @test10b(
1565 entry:
1566 br label %loop_begin
1567 ; CHECK-NEXT: entry:
1568 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %cond
1569 ; CHECK-NEXT: br i1 %[[FROZEN]], label %entry.split.us, label %entry.split
1571 loop_begin:
1572 %a = load i32, ptr %a.ptr
1573 %v1 = load i1, ptr %ptr
1574 br i1 %v1, label %loop_a, label %loop_b
1576 loop_a:
1577 %v2 = load i1, ptr %ptr
1578 br i1 %v2, label %loop_begin, label %loop_exit
1580 loop_b:
1581 br i1 %cond, label %loop_begin, label %loop_exit
1582 ; The cloned loop without one of the exits.
1583 ;
1584 ; CHECK: entry.split.us:
1585 ; CHECK-NEXT: br label %loop_begin.us
1586 ;
1587 ; CHECK: loop_begin.us:
1588 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1589 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1590 ; CHECK-NEXT: br i1 %[[V]], label %loop_a.us, label %loop_b.us
1591 ;
1592 ; CHECK: loop_b.us:
1593 ; CHECK-NEXT: br label %loop_begin.backedge.us
1594 ;
1595 ; CHECK: loop_a.us:
1596 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1597 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin.backedge.us, label %loop_exit.split.us
1598 ;
1599 ; CHECK: loop_begin.backedge.us:
1600 ; CHECK-NEXT: br label %loop_begin.us
1601 ;
1602 ; CHECK: loop_exit.split.us:
1603 ; CHECK-NEXT: %[[A_LCSSA_US:.*]] = phi i32 [ %[[A]], %loop_a.us ]
1604 ; CHECK-NEXT: br label %loop_exit
1606 ; The original loop without one 'loop_exit' edge.
1607 ;
1608 ; CHECK: entry.split:
1609 ; CHECK-NEXT: br label %loop_begin
1610 ;
1611 ; CHECK: loop_begin:
1612 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1613 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1614 ; CHECK-NEXT: br i1 %[[V]], label %loop_a, label %loop_b
1615 ;
1616 ; CHECK: loop_a:
1617 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1618 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin.backedge, label %loop_exit.split.loopexit
1619 ;
1620 ; CHECK: loop_begin.backedge:
1621 ; CHECK-NEXT: br label %loop_begin
1622 ;
1623 ; CHECK: loop_b:
1624 ; CHECK-NEXT: %[[A_LCSSA_B:.*]] = phi i32 [ %[[A]], %loop_begin ]
1625 ; CHECK-NEXT: br label %loop_exit.split
1626 ;
1627 ; CHECK: loop_exit.split.loopexit:
1628 ; CHECK-NEXT: %[[A_LCSSA_A:.*]] = phi i32 [ %[[A]], %loop_a ]
1629 ; CHECK-NEXT: br label %loop_exit.split
1630 ;
1631 ; CHECK: loop_exit.split:
1632 ; CHECK-NEXT: %[[A_PHI_SPLIT:.*]] = phi i32 [ %[[A_LCSSA_B]], %loop_b ], [ %[[A_LCSSA_A]], %loop_exit.split.loopexit ]
1633 ; CHECK-NEXT: br label %loop_exit
1635 loop_exit:
1636 %a.lcssa = phi i32 [ %a, %loop_a ], [ %a, %loop_b ]
1637 ret i32 %a.lcssa
1638 ; CHECK: loop_exit:
1639 ; CHECK-NEXT: %[[A_PHI:.*]] = phi i32 [ %[[A_PHI_SPLIT]], %loop_exit.split ], [ %[[A_LCSSA_US]], %loop_exit.split.us ]
1640 ; CHECK-NEXT: ret i32 %[[A_PHI]]
1641 }
1643 ; Check that if a cloned inner loop after unswitching doesn't loop and directly
1644 ; exits even an outer loop, we don't add the cloned preheader to the outer
1645 ; loop and do add the needed LCSSA phi nodes for the new exit block from the
1646 ; outer loop.
1647 define i32 @test11a(ptr %ptr, ptr %cond.ptr, ptr %a.ptr, ptr %b.ptr) {
1648 ; CHECK-LABEL: @test11a(
1649 entry:
1650 br label %loop_begin
1651 ; CHECK-NEXT: entry:
1652 ; CHECK-NEXT: br label %loop_begin
1654 loop_begin:
1655 %b = load i32, ptr %b.ptr
1656 %v1 = load i1, ptr %ptr
1657 br i1 %v1, label %loop_latch, label %inner_loop_ph
1658 ; CHECK: loop_begin:
1659 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
1660 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1661 ; CHECK-NEXT: br i1 %[[V]], label %loop_latch, label %inner_loop_ph
1663 inner_loop_ph:
1664 %cond = load i1, ptr %cond.ptr
1665 br label %inner_loop_begin
1666 ; CHECK: inner_loop_ph:
1667 ; CHECK-NEXT: %[[COND:.*]] = load i1, ptr %cond.ptr
1668 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %[[COND]]
1669 ; CHECK-NEXT: br i1 %[[FROZEN]], label %inner_loop_ph.split.us, label %inner_loop_ph.split
1671 inner_loop_begin:
1672 call void @sink1(i32 %b)
1673 %a = load i32, ptr %a.ptr
1674 br i1 %cond, label %loop_exit, label %inner_loop_a
1676 inner_loop_a:
1677 %v2 = load i1, ptr %ptr
1678 br i1 %v2, label %inner_loop_exit, label %inner_loop_begin
1679 ; The cloned path doesn't actually loop and is an exit from the outer loop as
1680 ; well.
1681 ;
1682 ; CHECK: inner_loop_ph.split.us:
1683 ; CHECK-NEXT: %[[B_LCSSA:.*]] = phi i32 [ %[[B]], %inner_loop_ph ]
1684 ; CHECK-NEXT: br label %inner_loop_begin.us
1685 ;
1686 ; CHECK: inner_loop_begin.us:
1687 ; CHECK-NEXT: call void @sink1(i32 %[[B_LCSSA]])
1688 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1689 ; CHECK-NEXT: br label %loop_exit.loopexit.split.us
1690 ;
1691 ; CHECK: loop_exit.loopexit.split.us:
1692 ; CHECK-NEXT: %[[A_INNER_LCSSA_US:.*]] = phi i32 [ %[[A]], %inner_loop_begin.us ]
1693 ; CHECK-NEXT: br label %loop_exit.loopexit
1694 ;
1695 ; The original remains a loop losing the exit edge.
1696 ;
1697 ; CHECK: inner_loop_ph.split:
1698 ; CHECK-NEXT: br label %inner_loop_begin
1699 ;
1700 ; CHECK: inner_loop_begin:
1701 ; CHECK-NEXT: call void @sink1(i32 %[[B]])
1702 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1703 ; CHECK-NEXT: br label %inner_loop_a
1704 ;
1705 ; CHECK: inner_loop_a:
1706 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1707 ; CHECK-NEXT: br i1 %[[V]], label %inner_loop_exit, label %inner_loop_begin
1709 inner_loop_exit:
1710 %a.inner_lcssa = phi i32 [ %a, %inner_loop_a ]
1711 %v3 = load i1, ptr %ptr
1712 br i1 %v3, label %loop_latch, label %loop_exit
1713 ; CHECK: inner_loop_exit:
1714 ; CHECK-NEXT: %[[A_INNER_LCSSA:.*]] = phi i32 [ %[[A]], %inner_loop_a ]
1715 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1716 ; CHECK-NEXT: br i1 %[[V]], label %loop_latch, label %loop_exit.loopexit1
1718 loop_latch:
1719 br label %loop_begin
1720 ; CHECK: loop_latch:
1721 ; CHECK-NEXT: br label %loop_begin
1723 loop_exit:
1724 %a.lcssa = phi i32 [ %a, %inner_loop_begin ], [ %a.inner_lcssa, %inner_loop_exit ]
1725 ret i32 %a.lcssa
1726 ; CHECK: loop_exit.loopexit:
1727 ; CHECK-NEXT: br label %loop_exit
1728 ;
1729 ; CHECK: loop_exit.loopexit1:
1730 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A_INNER_LCSSA]], %inner_loop_exit ]
1731 ; CHECK-NEXT: br label %loop_exit
1732 ;
1733 ; CHECK: loop_exit:
1734 ; CHECK-NEXT: %[[A_PHI:.*]] = phi i32 [ %[[A_INNER_LCSSA_US]], %loop_exit.loopexit ], [ %[[A_LCSSA]], %loop_exit.loopexit1 ]
1735 ; CHECK-NEXT: ret i32 %[[A_PHI]]
1736 }
1738 ; Check that if the original inner loop after unswitching doesn't loop and
1739 ; directly exits even an outer loop, we remove the original preheader from the
1740 ; outer loop and add needed LCSSA phi nodes for the new exit block from the
1741 ; outer loop.
1742 define i32 @test11b(ptr %ptr, ptr %cond.ptr, ptr %a.ptr, ptr %b.ptr) {
1743 ; CHECK-LABEL: @test11b(
1744 entry:
1745 br label %loop_begin
1746 ; CHECK-NEXT: entry:
1747 ; CHECK-NEXT: br label %loop_begin
1749 loop_begin:
1750 %b = load i32, ptr %b.ptr
1751 %v1 = load i1, ptr %ptr
1752 br i1 %v1, label %loop_latch, label %inner_loop_ph
1753 ; CHECK: loop_begin:
1754 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
1755 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1756 ; CHECK-NEXT: br i1 %[[V]], label %loop_latch, label %inner_loop_ph
1758 inner_loop_ph:
1759 %cond = load i1, ptr %cond.ptr
1760 br label %inner_loop_begin
1761 ; CHECK: inner_loop_ph:
1762 ; CHECK-NEXT: %[[COND:.*]] = load i1, ptr %cond.ptr
1763 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %[[COND]]
1764 ; CHECK-NEXT: br i1 %[[FROZEN]], label %inner_loop_ph.split.us, label %inner_loop_ph.split
1766 inner_loop_begin:
1767 call void @sink1(i32 %b)
1768 %a = load i32, ptr %a.ptr
1769 br i1 %cond, label %inner_loop_a, label %loop_exit
1771 inner_loop_a:
1772 %v2 = load i1, ptr %ptr
1773 br i1 %v2, label %inner_loop_exit, label %inner_loop_begin
1774 ; The cloned path continues to loop without the exit out of the entire nest.
1775 ;
1776 ; CHECK: inner_loop_ph.split.us:
1777 ; CHECK-NEXT: br label %inner_loop_begin.us
1778 ;
1779 ; CHECK: inner_loop_begin.us:
1780 ; CHECK-NEXT: call void @sink1(i32 %[[B]])
1781 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1782 ; CHECK-NEXT: br label %inner_loop_a.us
1783 ;
1784 ; CHECK: inner_loop_a.us:
1785 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1786 ; CHECK-NEXT: br i1 %[[V]], label %inner_loop_exit.split.us, label %inner_loop_begin.us
1787 ;
1788 ; CHECK: inner_loop_exit.split.us:
1789 ; CHECK-NEXT: %[[A_INNER_LCSSA_US:.*]] = phi i32 [ %[[A]], %inner_loop_a.us ]
1790 ; CHECK-NEXT: br label %inner_loop_exit
1791 ;
1792 ; The original remains a loop losing the exit edge.
1793 ;
1794 ; CHECK: inner_loop_ph.split:
1795 ; CHECK-NEXT: %[[B_LCSSA:.*]] = phi i32 [ %[[B]], %inner_loop_ph ]
1796 ; CHECK-NEXT: br label %inner_loop_begin
1797 ;
1798 ; CHECK: inner_loop_begin:
1799 ; CHECK-NEXT: call void @sink1(i32 %[[B_LCSSA]])
1800 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1801 ; CHECK-NEXT: br label %loop_exit.loopexit
1803 inner_loop_exit:
1804 %a.inner_lcssa = phi i32 [ %a, %inner_loop_a ]
1805 %v3 = load i1, ptr %ptr
1806 br i1 %v3, label %loop_latch, label %loop_exit
1807 ; CHECK: inner_loop_exit:
1808 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1809 ; CHECK-NEXT: br i1 %[[V]], label %loop_latch, label %loop_exit.loopexit1
1811 loop_latch:
1812 br label %loop_begin
1813 ; CHECK: loop_latch:
1814 ; CHECK-NEXT: br label %loop_begin
1816 loop_exit:
1817 %a.lcssa = phi i32 [ %a, %inner_loop_begin ], [ %a.inner_lcssa, %inner_loop_exit ]
1818 ret i32 %a.lcssa
1819 ; CHECK: loop_exit.loopexit:
1820 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A]], %inner_loop_begin ]
1821 ; CHECK-NEXT: br label %loop_exit
1822 ;
1823 ; CHECK: loop_exit.loopexit1:
1824 ; CHECK-NEXT: %[[A_LCSSA_US:.*]] = phi i32 [ %[[A_INNER_LCSSA_US]], %inner_loop_exit ]
1825 ; CHECK-NEXT: br label %loop_exit
1826 ;
1827 ; CHECK: loop_exit:
1828 ; CHECK-NEXT: %[[A_PHI:.*]] = phi i32 [ %[[A_LCSSA]], %loop_exit.loopexit ], [ %[[A_LCSSA_US]], %loop_exit.loopexit1 ]
1829 ; CHECK-NEXT: ret i32 %[[A_PHI]]
1830 }
1832 ; Like test11a, but checking that when the whole thing is wrapped in yet
1833 ; another loop, we correctly attribute the cloned preheader to that outermost
1834 ; loop rather than only handling the case where the preheader is not in any loop
1835 ; at all.
1836 define i32 @test12a(ptr %ptr, ptr %cond.ptr, ptr %a.ptr, ptr %b.ptr) {
1837 ; CHECK-LABEL: @test12a(
1838 entry:
1839 br label %loop_begin
1840 ; CHECK-NEXT: entry:
1841 ; CHECK-NEXT: br label %loop_begin
1843 loop_begin:
1844 br label %inner_loop_begin
1845 ; CHECK: loop_begin:
1846 ; CHECK-NEXT: br label %inner_loop_begin
1848 inner_loop_begin:
1849 %b = load i32, ptr %b.ptr
1850 %v1 = load i1, ptr %ptr
1851 br i1 %v1, label %inner_loop_latch, label %inner_inner_loop_ph
1852 ; CHECK: inner_loop_begin:
1853 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
1854 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1855 ; CHECK-NEXT: br i1 %[[V]], label %inner_loop_latch, label %inner_inner_loop_ph
1857 inner_inner_loop_ph:
1858 %cond = load i1, ptr %cond.ptr
1859 br label %inner_inner_loop_begin
1860 ; CHECK: inner_inner_loop_ph:
1861 ; CHECK-NEXT: %[[COND:.*]] = load i1, ptr %cond.ptr
1862 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %[[COND]]
1863 ; CHECK-NEXT: br i1 %[[FROZEN]], label %inner_inner_loop_ph.split.us, label %inner_inner_loop_ph.split
1865 inner_inner_loop_begin:
1866 call void @sink1(i32 %b)
1867 %a = load i32, ptr %a.ptr
1868 br i1 %cond, label %inner_loop_exit, label %inner_inner_loop_a
1870 inner_inner_loop_a:
1871 %v2 = load i1, ptr %ptr
1872 br i1 %v2, label %inner_inner_loop_exit, label %inner_inner_loop_begin
1873 ; The cloned path doesn't actually loop and is an exit from the outer loop as
1874 ; well.
1875 ;
1876 ; CHECK: inner_inner_loop_ph.split.us:
1877 ; CHECK-NEXT: %[[B_LCSSA:.*]] = phi i32 [ %[[B]], %inner_inner_loop_ph ]
1878 ; CHECK-NEXT: br label %inner_inner_loop_begin.us
1879 ;
1880 ; CHECK: inner_inner_loop_begin.us:
1881 ; CHECK-NEXT: call void @sink1(i32 %[[B_LCSSA]])
1882 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1883 ; CHECK-NEXT: br label %inner_loop_exit.loopexit.split.us
1884 ;
1885 ; CHECK: inner_loop_exit.loopexit.split.us:
1886 ; CHECK-NEXT: %[[A_INNER_INNER_LCSSA_US:.*]] = phi i32 [ %[[A]], %inner_inner_loop_begin.us ]
1887 ; CHECK-NEXT: br label %inner_loop_exit.loopexit
1888 ;
1889 ; The original remains a loop losing the exit edge.
1890 ;
1891 ; CHECK: inner_inner_loop_ph.split:
1892 ; CHECK-NEXT: br label %inner_inner_loop_begin
1893 ;
1894 ; CHECK: inner_inner_loop_begin:
1895 ; CHECK-NEXT: call void @sink1(i32 %[[B]])
1896 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1897 ; CHECK-NEXT: br label %inner_inner_loop_a
1898 ;
1899 ; CHECK: inner_inner_loop_a:
1900 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1901 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_exit, label %inner_inner_loop_begin
1903 inner_inner_loop_exit:
1904 %a.inner_inner_lcssa = phi i32 [ %a, %inner_inner_loop_a ]
1905 %v3 = load i1, ptr %ptr
1906 br i1 %v3, label %inner_loop_latch, label %inner_loop_exit
1907 ; CHECK: inner_inner_loop_exit:
1908 ; CHECK-NEXT: %[[A_INNER_INNER_LCSSA:.*]] = phi i32 [ %[[A]], %inner_inner_loop_a ]
1909 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1910 ; CHECK-NEXT: br i1 %[[V]], label %inner_loop_latch, label %inner_loop_exit.loopexit1
1912 inner_loop_latch:
1913 br label %inner_loop_begin
1914 ; CHECK: inner_loop_latch:
1915 ; CHECK-NEXT: br label %inner_loop_begin
1917 inner_loop_exit:
1918 %a.inner_lcssa = phi i32 [ %a, %inner_inner_loop_begin ], [ %a.inner_inner_lcssa, %inner_inner_loop_exit ]
1919 %v4 = load i1, ptr %ptr
1920 br i1 %v4, label %loop_begin, label %loop_exit
1921 ; CHECK: inner_loop_exit.loopexit:
1922 ; CHECK-NEXT: br label %inner_loop_exit
1923 ;
1924 ; CHECK: inner_loop_exit.loopexit1:
1925 ; CHECK-NEXT: %[[A_INNER_LCSSA:.*]] = phi i32 [ %[[A_INNER_INNER_LCSSA]], %inner_inner_loop_exit ]
1926 ; CHECK-NEXT: br label %inner_loop_exit
1927 ;
1928 ; CHECK: inner_loop_exit:
1929 ; CHECK-NEXT: %[[A_INNER_PHI:.*]] = phi i32 [ %[[A_INNER_INNER_LCSSA_US]], %inner_loop_exit.loopexit ], [ %[[A_INNER_LCSSA]], %inner_loop_exit.loopexit1 ]
1930 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1931 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin, label %loop_exit
1933 loop_exit:
1934 %a.lcssa = phi i32 [ %a.inner_lcssa, %inner_loop_exit ]
1935 ret i32 %a.lcssa
1936 ; CHECK: loop_exit:
1937 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A_INNER_PHI]], %inner_loop_exit ]
1938 ; CHECK-NEXT: ret i32 %[[A_LCSSA]]
1939 }
1941 ; Like test11b, but checking that when the whole thing is wrapped in yet
1942 ; another loop, we correctly sink the preheader to the outermost loop rather
1943 ; than only handling the case where the preheader is completely removed from
1944 ; a loop.
1945 define i32 @test12b(ptr %ptr, ptr %cond.ptr, ptr %a.ptr, ptr %b.ptr) {
1946 ; CHECK-LABEL: @test12b(
1947 entry:
1948 br label %loop_begin
1949 ; CHECK-NEXT: entry:
1950 ; CHECK-NEXT: br label %loop_begin
1952 loop_begin:
1953 br label %inner_loop_begin
1954 ; CHECK: loop_begin:
1955 ; CHECK-NEXT: br label %inner_loop_begin
1957 inner_loop_begin:
1958 %b = load i32, ptr %b.ptr
1959 %v1 = load i1, ptr %ptr
1960 br i1 %v1, label %inner_loop_latch, label %inner_inner_loop_ph
1961 ; CHECK: inner_loop_begin:
1962 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
1963 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1964 ; CHECK-NEXT: br i1 %[[V]], label %inner_loop_latch, label %inner_inner_loop_ph
1966 inner_inner_loop_ph:
1967 %cond = load i1, ptr %cond.ptr
1968 br label %inner_inner_loop_begin
1969 ; CHECK: inner_inner_loop_ph:
1970 ; CHECK-NEXT: %[[COND:.*]] = load i1, ptr %cond.ptr
1971 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %[[COND]]
1972 ; CHECK-NEXT: br i1 %[[FROZEN]], label %inner_inner_loop_ph.split.us, label %inner_inner_loop_ph.split
1974 inner_inner_loop_begin:
1975 call void @sink1(i32 %b)
1976 %a = load i32, ptr %a.ptr
1977 br i1 %cond, label %inner_inner_loop_a, label %inner_loop_exit
1979 inner_inner_loop_a:
1980 %v2 = load i1, ptr %ptr
1981 br i1 %v2, label %inner_inner_loop_exit, label %inner_inner_loop_begin
1982 ; The cloned path continues to loop without the exit out of the entire nest.
1983 ;
1984 ; CHECK: inner_inner_loop_ph.split.us:
1985 ; CHECK-NEXT: br label %inner_inner_loop_begin.us
1986 ;
1987 ; CHECK: inner_inner_loop_begin.us:
1988 ; CHECK-NEXT: call void @sink1(i32 %[[B]])
1989 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
1990 ; CHECK-NEXT: br label %inner_inner_loop_a.us
1991 ;
1992 ; CHECK: inner_inner_loop_a.us:
1993 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
1994 ; CHECK-NEXT: br i1 %[[V]], label %inner_inner_loop_exit.split.us, label %inner_inner_loop_begin.us
1995 ;
1996 ; CHECK: inner_inner_loop_exit.split.us:
1997 ; CHECK-NEXT: %[[A_INNER_INNER_LCSSA_US:.*]] = phi i32 [ %[[A]], %inner_inner_loop_a.us ]
1998 ; CHECK-NEXT: br label %inner_inner_loop_exit
1999 ;
2000 ; The original remains a loop losing the exit edge.
2001 ;
2002 ; CHECK: inner_inner_loop_ph.split:
2003 ; CHECK-NEXT: %[[B_LCSSA:.*]] = phi i32 [ %[[B]], %inner_inner_loop_ph ]
2004 ; CHECK-NEXT: br label %inner_inner_loop_begin
2005 ;
2006 ; CHECK: inner_inner_loop_begin:
2007 ; CHECK-NEXT: call void @sink1(i32 %[[B_LCSSA]])
2008 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
2009 ; CHECK-NEXT: br label %inner_loop_exit.loopexit
2011 inner_inner_loop_exit:
2012 %a.inner_inner_lcssa = phi i32 [ %a, %inner_inner_loop_a ]
2013 %v3 = load i1, ptr %ptr
2014 br i1 %v3, label %inner_loop_latch, label %inner_loop_exit
2015 ; CHECK: inner_inner_loop_exit:
2016 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2017 ; CHECK-NEXT: br i1 %[[V]], label %inner_loop_latch, label %inner_loop_exit.loopexit1
2019 inner_loop_latch:
2020 br label %inner_loop_begin
2021 ; CHECK: inner_loop_latch:
2022 ; CHECK-NEXT: br label %inner_loop_begin
2024 inner_loop_exit:
2025 %a.inner_lcssa = phi i32 [ %a, %inner_inner_loop_begin ], [ %a.inner_inner_lcssa, %inner_inner_loop_exit ]
2026 %v4 = load i1, ptr %ptr
2027 br i1 %v4, label %loop_begin, label %loop_exit
2028 ; CHECK: inner_loop_exit.loopexit:
2029 ; CHECK-NEXT: %[[A_INNER_LCSSA:.*]] = phi i32 [ %[[A]], %inner_inner_loop_begin ]
2030 ; CHECK-NEXT: br label %inner_loop_exit
2031 ;
2032 ; CHECK: inner_loop_exit.loopexit1:
2033 ; CHECK-NEXT: %[[A_INNER_LCSSA_US:.*]] = phi i32 [ %[[A_INNER_INNER_LCSSA_US]], %inner_inner_loop_exit ]
2034 ; CHECK-NEXT: br label %inner_loop_exit
2035 ;
2036 ; CHECK: inner_loop_exit:
2037 ; CHECK-NEXT: %[[A_INNER_PHI:.*]] = phi i32 [ %[[A_INNER_LCSSA]], %inner_loop_exit.loopexit ], [ %[[A_INNER_LCSSA_US]], %inner_loop_exit.loopexit1 ]
2038 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2039 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin, label %loop_exit
2041 loop_exit:
2042 %a.lcssa = phi i32 [ %a.inner_lcssa, %inner_loop_exit ]
2043 ret i32 %a.lcssa
2044 ; CHECK: loop_exit:
2045 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A_INNER_PHI]], %inner_loop_exit ]
2046 ; CHECK-NEXT: ret i32 %[[A_LCSSA]]
2047 }
2049 ; Test where the cloned loop has an inner loop that has to be traversed to form
2050 ; the cloned loop, and where this inner loop has multiple blocks, and where the
2051 ; exiting block that connects the inner loop to the cloned loop is not the header
2052 ; block. This ensures that we correctly handle interesting corner cases of
2053 ; traversing back to the header when establishing the cloned loop.
2054 define i32 @test13a(ptr %ptr, i1 %cond, ptr %a.ptr, ptr %b.ptr) {
2055 ; CHECK-LABEL: @test13a(
2056 entry:
2057 br label %loop_begin
2058 ; CHECK-NEXT: entry:
2059 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %cond
2060 ; CHECK-NEXT: br i1 %[[FROZEN]], label %entry.split.us, label %entry.split
2062 loop_begin:
2063 %a = load i32, ptr %a.ptr
2064 %v1 = load i1, ptr %ptr
2065 br i1 %v1, label %loop_a, label %loop_b
2067 loop_a:
2068 %v2 = load i1, ptr %ptr
2069 br i1 %v2, label %loop_exit, label %loop_latch
2071 loop_b:
2072 %b = load i32, ptr %b.ptr
2073 br i1 %cond, label %loop_b_inner_ph, label %loop_exit
2075 loop_b_inner_ph:
2076 br label %loop_b_inner_header
2078 loop_b_inner_header:
2079 %v3 = load i1, ptr %ptr
2080 br i1 %v3, label %loop_b_inner_latch, label %loop_b_inner_body
2082 loop_b_inner_body:
2083 %v4 = load i1, ptr %ptr
2084 br i1 %v4, label %loop_b_inner_latch, label %loop_b_inner_exit
2086 loop_b_inner_latch:
2087 br label %loop_b_inner_header
2089 loop_b_inner_exit:
2090 br label %loop_latch
2092 loop_latch:
2093 br label %loop_begin
2094 ; The cloned loop contains an inner loop within it.
2095 ;
2096 ; CHECK: entry.split.us:
2097 ; CHECK-NEXT: br label %loop_begin.us
2098 ;
2099 ; CHECK: loop_begin.us:
2100 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
2101 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2102 ; CHECK-NEXT: br i1 %[[V]], label %loop_a.us, label %loop_b.us
2103 ;
2104 ; CHECK: loop_b.us:
2105 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
2106 ; CHECK-NEXT: br label %loop_b_inner_ph.us
2107 ;
2108 ; CHECK: loop_b_inner_ph.us:
2109 ; CHECK-NEXT: br label %loop_b_inner_header.us
2110 ;
2111 ; CHECK: loop_b_inner_header.us:
2112 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2113 ; CHECK-NEXT: br i1 %[[V]], label %loop_b_inner_latch.us, label %loop_b_inner_body.us
2114 ;
2115 ; CHECK: loop_b_inner_body.us:
2116 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2117 ; CHECK-NEXT: br i1 %[[V]], label %loop_b_inner_latch.us, label %loop_b_inner_exit.us
2118 ;
2119 ; CHECK: loop_b_inner_exit.us:
2120 ; CHECK-NEXT: br label %loop_latch.us
2121 ;
2122 ; CHECK: loop_b_inner_latch.us:
2123 ; CHECK-NEXT: br label %loop_b_inner_header.us
2124 ;
2125 ; CHECK: loop_a.us:
2126 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2127 ; CHECK-NEXT: br i1 %[[V]], label %loop_exit.split.us, label %loop_latch.us
2128 ;
2129 ; CHECK: loop_latch.us:
2130 ; CHECK-NEXT: br label %loop_begin.us
2131 ;
2132 ; CHECK: loop_exit.split.us:
2133 ; CHECK-NEXT: %[[A_LCSSA_US:.*]] = phi i32 [ %[[A]], %loop_a.us ]
2134 ; CHECK-NEXT: br label %loop_exit
2135 ;
2136 ; And the original loop no longer contains an inner loop.
2137 ;
2138 ; CHECK: entry.split:
2139 ; CHECK-NEXT: br label %loop_begin
2140 ;
2141 ; CHECK: loop_begin:
2142 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
2143 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2144 ; CHECK-NEXT: br i1 %[[V]], label %loop_a, label %loop_b
2145 ;
2146 ; CHECK: loop_a:
2147 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2148 ; CHECK-NEXT: br i1 %[[V]], label %loop_exit.split.loopexit, label %loop_latch
2149 ;
2150 ; CHECK: loop_b:
2151 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
2152 ; CHECK-NEXT: br label %loop_exit.split
2153 ;
2154 ; CHECK: loop_latch:
2155 ; CHECK-NEXT: br label %loop_begin
2157 loop_exit:
2158 %lcssa = phi i32 [ %a, %loop_a ], [ %b, %loop_b ]
2159 ret i32 %lcssa
2160 ; CHECK: loop_exit.split.loopexit:
2161 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A]], %loop_a ]
2162 ; CHECK-NEXT: br label %loop_exit.split
2163 ;
2164 ; CHECK: loop_exit.split:
2165 ; CHECK-NEXT: %[[AB_PHI:.*]] = phi i32 [ %[[B]], %loop_b ], [ %[[A_LCSSA]], %loop_exit.split.loopexit ]
2166 ; CHECK-NEXT: br label %loop_exit
2167 ;
2168 ; CHECK: loop_exit:
2169 ; CHECK-NEXT: %[[AB_PHI_US:.*]] = phi i32 [ %[[AB_PHI]], %loop_exit.split ], [ %[[A_LCSSA_US]], %loop_exit.split.us ]
2170 ; CHECK-NEXT: ret i32 %[[AB_PHI_US]]
2171 }
2173 ; Test where the original loop has an inner loop that has to be traversed to
2174 ; rebuild the loop, and where this inner loop has multiple blocks, and where
2175 ; the exiting block that connects the inner loop to the original loop is not
2176 ; the header block. This ensures that we correctly handle interesting corner
2177 ; cases of traversing back to the header when re-establishing the original loop
2178 ; still exists after unswitching.
2179 define i32 @test13b(ptr %ptr, i1 %cond, ptr %a.ptr, ptr %b.ptr) {
2180 ; CHECK-LABEL: @test13b(
2181 entry:
2182 br label %loop_begin
2183 ; CHECK-NEXT: entry:
2184 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %cond
2185 ; CHECK-NEXT: br i1 %[[FROZEN]], label %entry.split.us, label %entry.split
2187 loop_begin:
2188 %a = load i32, ptr %a.ptr
2189 %v1 = load i1, ptr %ptr
2190 br i1 %v1, label %loop_a, label %loop_b
2192 loop_a:
2193 %v2 = load i1, ptr %ptr
2194 br i1 %v2, label %loop_exit, label %loop_latch
2196 loop_b:
2197 %b = load i32, ptr %b.ptr
2198 br i1 %cond, label %loop_exit, label %loop_b_inner_ph
2200 loop_b_inner_ph:
2201 br label %loop_b_inner_header
2203 loop_b_inner_header:
2204 %v3 = load i1, ptr %ptr
2205 br i1 %v3, label %loop_b_inner_latch, label %loop_b_inner_body
2207 loop_b_inner_body:
2208 %v4 = load i1, ptr %ptr
2209 br i1 %v4, label %loop_b_inner_latch, label %loop_b_inner_exit
2211 loop_b_inner_latch:
2212 br label %loop_b_inner_header
2214 loop_b_inner_exit:
2215 br label %loop_latch
2217 loop_latch:
2218 br label %loop_begin
2219 ; The cloned loop doesn't contain an inner loop.
2220 ;
2221 ; CHECK: entry.split.us:
2222 ; CHECK-NEXT: br label %loop_begin.us
2223 ;
2224 ; CHECK: loop_begin.us:
2225 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
2226 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2227 ; CHECK-NEXT: br i1 %[[V]], label %loop_a.us, label %loop_b.us
2228 ;
2229 ; CHECK: loop_b.us:
2230 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
2231 ; CHECK-NEXT: br label %loop_exit.split.us
2232 ;
2233 ; CHECK: loop_a.us:
2234 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2235 ; CHECK-NEXT: br i1 %[[V]], label %loop_exit.split.us.loopexit, label %loop_latch.us
2236 ;
2237 ; CHECK: loop_latch.us:
2238 ; CHECK-NEXT: br label %loop_begin.us
2239 ;
2240 ; CHECK: loop_exit.split.us.loopexit:
2241 ; CHECK-NEXT: %[[A_LCSSA_US:.*]] = phi i32 [ %[[A]], %loop_a.us ]
2242 ; CHECK-NEXT: br label %loop_exit.split.us
2243 ;
2244 ; CHECK: loop_exit.split.us:
2245 ; CHECK-NEXT: %[[AB_PHI_US:.*]] = phi i32 [ %[[B]], %loop_b.us ], [ %[[A_LCSSA_US]], %loop_exit.split.us.loopexit ]
2246 ; CHECK-NEXT: br label %loop_exit
2247 ;
2248 ; But the original loop contains an inner loop that must be traversed.;
2249 ;
2250 ; CHECK: entry.split:
2251 ; CHECK-NEXT: br label %loop_begin
2252 ;
2253 ; CHECK: loop_begin:
2254 ; CHECK-NEXT: %[[A:.*]] = load i32, ptr %a.ptr
2255 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2256 ; CHECK-NEXT: br i1 %[[V]], label %loop_a, label %loop_b
2257 ;
2258 ; CHECK: loop_a:
2259 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2260 ; CHECK-NEXT: br i1 %[[V]], label %loop_exit.split, label %loop_latch
2261 ;
2262 ; CHECK: loop_b:
2263 ; CHECK-NEXT: %[[B:.*]] = load i32, ptr %b.ptr
2264 ; CHECK-NEXT: br label %loop_b_inner_ph
2265 ;
2266 ; CHECK: loop_b_inner_ph:
2267 ; CHECK-NEXT: br label %loop_b_inner_header
2268 ;
2269 ; CHECK: loop_b_inner_header:
2270 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2271 ; CHECK-NEXT: br i1 %[[V]], label %loop_b_inner_latch, label %loop_b_inner_body
2272 ;
2273 ; CHECK: loop_b_inner_body:
2274 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2275 ; CHECK-NEXT: br i1 %[[V]], label %loop_b_inner_latch, label %loop_b_inner_exit
2276 ;
2277 ; CHECK: loop_b_inner_latch:
2278 ; CHECK-NEXT: br label %loop_b_inner_header
2279 ;
2280 ; CHECK: loop_b_inner_exit:
2281 ; CHECK-NEXT: br label %loop_latch
2282 ;
2283 ; CHECK: loop_latch:
2284 ; CHECK-NEXT: br label %loop_begin
2286 loop_exit:
2287 %lcssa = phi i32 [ %a, %loop_a ], [ %b, %loop_b ]
2288 ret i32 %lcssa
2289 ; CHECK: loop_exit.split:
2290 ; CHECK-NEXT: %[[A_LCSSA:.*]] = phi i32 [ %[[A]], %loop_a ]
2291 ; CHECK-NEXT: br label %loop_exit
2292 ;
2293 ; CHECK: loop_exit:
2294 ; CHECK-NEXT: %[[AB_PHI:.*]] = phi i32 [ %[[A_LCSSA]], %loop_exit.split ], [ %[[AB_PHI_US]], %loop_exit.split.us ]
2295 ; CHECK-NEXT: ret i32 %[[AB_PHI]]
2296 }
2298 define i32 @test20(ptr %var, i32 %cond1, i32 %cond2) {
2299 ; CHECK-LABEL: @test20(
2300 entry:
2301 br label %loop_begin
2302 ; CHECK-NEXT: entry:
2303 ; CHECK-NEXT: switch i32 %cond2, label %[[ENTRY_SPLIT_EXIT:.*]] [
2304 ; CHECK-NEXT: i32 0, label %[[ENTRY_SPLIT_A:.*]]
2305 ; CHECK-NEXT: i32 1, label %[[ENTRY_SPLIT_A]]
2306 ; CHECK-NEXT: i32 13, label %[[ENTRY_SPLIT_B:.*]]
2307 ; CHECK-NEXT: i32 2, label %[[ENTRY_SPLIT_A]]
2308 ; CHECK-NEXT: i32 42, label %[[ENTRY_SPLIT_C:.*]]
2309 ; CHECK-NEXT: ]
2311 loop_begin:
2312 %var_val = load i32, ptr %var
2313 switch i32 %cond2, label %loop_exit [
2314 i32 0, label %loop_a
2315 i32 1, label %loop_a
2316 i32 13, label %loop_b
2317 i32 2, label %loop_a
2318 i32 42, label %loop_c
2319 ]
2321 loop_a:
2322 call i32 @a()
2323 br label %loop_latch
2324 ; Unswitched 'a' loop.
2325 ;
2326 ; CHECK: [[ENTRY_SPLIT_A]]:
2327 ; CHECK-NEXT: br label %[[LOOP_BEGIN_A:.*]]
2328 ;
2329 ; CHECK: [[LOOP_BEGIN_A]]:
2330 ; CHECK-NEXT: %{{.*}} = load i32, ptr %var
2331 ; CHECK-NEXT: br label %[[LOOP_A:.*]]
2332 ;
2333 ; CHECK: [[LOOP_A]]:
2334 ; CHECK-NEXT: call i32 @a()
2335 ; CHECK-NEXT: br label %[[LOOP_LATCH_A:.*]]
2336 ;
2337 ; CHECK: [[LOOP_LATCH_A]]:
2338 ; CHECK: br label %[[LOOP_BEGIN_A]]
2340 loop_b:
2341 call i32 @b()
2342 br label %loop_latch
2343 ; Unswitched 'b' loop.
2344 ;
2345 ; CHECK: [[ENTRY_SPLIT_B]]:
2346 ; CHECK-NEXT: br label %[[LOOP_BEGIN_B:.*]]
2347 ;
2348 ; CHECK: [[LOOP_BEGIN_B]]:
2349 ; CHECK-NEXT: %{{.*}} = load i32, ptr %var
2350 ; CHECK-NEXT: br label %[[LOOP_B:.*]]
2351 ;
2352 ; CHECK: [[LOOP_B]]:
2353 ; CHECK-NEXT: call i32 @b()
2354 ; CHECK-NEXT: br label %[[LOOP_LATCH_B:.*]]
2355 ;
2356 ; CHECK: [[LOOP_LATCH_B]]:
2357 ; CHECK: br label %[[LOOP_BEGIN_B]]
2359 loop_c:
2360 call i32 @c() noreturn nounwind
2361 br label %loop_latch
2362 ; Unswitched 'c' loop.
2363 ;
2364 ; CHECK: [[ENTRY_SPLIT_C]]:
2365 ; CHECK-NEXT: br label %[[LOOP_BEGIN_C:.*]]
2366 ;
2367 ; CHECK: [[LOOP_BEGIN_C]]:
2368 ; CHECK-NEXT: %{{.*}} = load i32, ptr %var
2369 ; CHECK-NEXT: br label %[[LOOP_C:.*]]
2370 ;
2371 ; CHECK: [[LOOP_C]]:
2372 ; CHECK-NEXT: call i32 @c()
2373 ; CHECK-NEXT: br label %[[LOOP_LATCH_C:.*]]
2374 ;
2375 ; CHECK: [[LOOP_LATCH_C]]:
2376 ; CHECK: br label %[[LOOP_BEGIN_C]]
2378 loop_latch:
2379 br label %loop_begin
2381 loop_exit:
2382 %lcssa = phi i32 [ %var_val, %loop_begin ]
2383 ret i32 %lcssa
2384 ; Unswitched exit edge (no longer a loop).
2385 ;
2386 ; CHECK: [[ENTRY_SPLIT_EXIT]]:
2387 ; CHECK-NEXT: br label %loop_begin
2388 ;
2389 ; CHECK: loop_begin:
2390 ; CHECK-NEXT: %[[V:.*]] = load i32, ptr %var
2391 ; CHECK-NEXT: br label %loop_exit
2392 ;
2393 ; CHECK: loop_exit:
2394 ; CHECK-NEXT: %[[LCSSA:.*]] = phi i32 [ %[[V]], %loop_begin ]
2395 ; CHECK-NEXT: ret i32 %[[LCSSA]]
2396 }
2398 ; Negative test: we do not switch when the loop contains unstructured control
2399 ; flows as it would significantly complicate the process as novel loops might
2400 ; be formed, etc.
2401 define void @test_no_unswitch_unstructured_cfg(ptr %ptr, i1 %cond) {
2402 ; CHECK-LABEL: @test_no_unswitch_unstructured_cfg(
2403 entry:
2404 br label %loop_begin
2406 loop_begin:
2407 br i1 %cond, label %loop_left, label %loop_right
2409 loop_left:
2410 %v1 = load i1, ptr %ptr
2411 br i1 %v1, label %loop_right, label %loop_merge
2413 loop_right:
2414 %v2 = load i1, ptr %ptr
2415 br i1 %v2, label %loop_left, label %loop_merge
2417 loop_merge:
2418 %v3 = load i1, ptr %ptr
2419 br i1 %v3, label %loop_latch, label %loop_exit
2421 loop_latch:
2422 br label %loop_begin
2424 loop_exit:
2425 ret void
2426 }
2428 ; A test reduced out of 403.gcc with interesting nested loops that trigger
2429 ; multiple unswitches. A key component of this test is that there are multiple
2430 ; paths to reach an inner loop after unswitching, and one of them is via the
2431 ; predecessors of the unswitched loop header. That can allow us to find the loop
2432 ; through multiple different paths.
2433 define void @test21(i1 %a, i1 %b) {
2434 ; CHECK-LABEL: @test21(
2435 bb:
2436 br label %bb3
2437 ; CHECK-NOT: br i1 %a
2438 ;
2439 ; CHECK: %[[FROZEN:.+]] = freeze i1 %a
2440 ; CHECK-NEXT: br i1 %[[FROZEN]], label %[[BB_SPLIT_US:.*]], label %[[BB_SPLIT:.*]]
2441 ;
2442 ; CHECK-NOT: br i1 %a
2443 ; CHECK-NOT: br i1 %b
2444 ;
2445 ; CHECK: [[BB_SPLIT]]:
2446 ; CHECK: br i1 %b
2447 ;
2448 ; CHECK-NOT: br i1 %a
2449 ; CHECK-NOT: br i1 %b
2451 bb3:
2452 %tmp1.0 = phi i32 [ 0, %bb ], [ %tmp1.3, %bb23 ]
2453 br label %bb7
2455 bb7:
2456 %tmp.0 = phi i1 [ true, %bb3 ], [ false, %bb19 ]
2457 %tmp1.1 = phi i32 [ %tmp1.0, %bb3 ], [ %tmp1.2.lcssa, %bb19 ]
2458 br i1 %tmp.0, label %bb11.preheader, label %bb23
2460 bb11.preheader:
2461 br i1 %a, label %bb19, label %bb14.lr.ph
2463 bb14.lr.ph:
2464 br label %bb14
2466 bb14:
2467 %tmp2.02 = phi i32 [ 0, %bb14.lr.ph ], [ 1, %bb14 ]
2468 br i1 %b, label %bb11.bb19_crit_edge, label %bb14
2470 bb11.bb19_crit_edge:
2471 %split = phi i32 [ %tmp2.02, %bb14 ]
2472 br label %bb19
2474 bb19:
2475 %tmp1.2.lcssa = phi i32 [ %split, %bb11.bb19_crit_edge ], [ %tmp1.1, %bb11.preheader ]
2476 %tmp21 = icmp eq i32 %tmp1.2.lcssa, 0
2477 br i1 %tmp21, label %bb23, label %bb7
2479 bb23:
2480 %tmp1.3 = phi i32 [ %tmp1.2.lcssa, %bb19 ], [ %tmp1.1, %bb7 ]
2481 br label %bb3
2482 }
2484 ; A test reduced out of 400.perlbench that when unswitching the `%stop`
2485 ; condition clones a loop nest outside of a containing loop. This excercises a
2486 ; different cloning path from our other test cases and in turn verifying the
2487 ; resulting structure can catch any failures to correctly clone these nested
2488 ; loops.
2489 declare void @f()
2490 declare void @g()
2491 declare i32 @h(i32 %arg)
2492 define void @test22(i32 %arg) {
2493 ; CHECK-LABEL: define void @test22(
2494 entry:
2495 br label %loop1.header
2497 loop1.header:
2498 %stop = phi i1 [ true, %loop1.latch ], [ false, %entry ]
2499 %i = phi i32 [ %i.lcssa, %loop1.latch ], [ %arg, %entry ]
2500 ; CHECK: %[[I:.*]] = phi i32 [ %{{.*}}, %loop1.latch ], [ %arg, %entry ]
2501 br i1 %stop, label %loop1.exit, label %loop1.body.loop2.ph
2502 ; CHECK: br i1 %stop, label %loop1.exit, label %loop1.body.loop2.ph
2504 loop1.body.loop2.ph:
2505 br label %loop2.header
2506 ; Just check that the we unswitched the key condition and that leads to the
2507 ; inner loop header.
2508 ;
2509 ; CHECK: loop1.body.loop2.ph:
2510 ; CHECK-NEXT: br i1 %stop, label %[[SPLIT_US:.*]], label %[[SPLIT:.*]]
2511 ;
2512 ; CHECK: [[SPLIT_US]]:
2513 ; CHECK-NEXT: br label %[[LOOP2_HEADER_US:.*]]
2514 ;
2515 ; CHECK: [[LOOP2_HEADER_US]]:
2516 ; CHECK-NEXT: %{{.*}} = phi i32 [ %[[I]], %[[SPLIT_US]] ]
2517 ;
2518 ; CHECK: [[SPLIT]]:
2519 ; CHECK-NEXT: br label %[[LOOP2_HEADER:.*]]
2520 ;
2521 ; CHECK: [[LOOP2_HEADER]]:
2522 ; CHECK-NEXT: %{{.*}} = phi i32 [ %[[I]], %[[SPLIT]] ]
2524 loop2.header:
2525 %i.inner = phi i32 [ %i, %loop1.body.loop2.ph ], [ %i.next, %loop2.latch ]
2526 br label %loop3.header
2528 loop3.header:
2529 %sw = call i32 @h(i32 %i.inner)
2530 switch i32 %sw, label %loop3.exit [
2531 i32 32, label %loop3.header
2532 i32 59, label %loop2.latch
2533 i32 36, label %loop1.latch
2534 ]
2536 loop2.latch:
2537 %i.next = add i32 %i.inner, 1
2538 br i1 %stop, label %loop2.exit, label %loop2.header
2540 loop1.latch:
2541 %i.lcssa = phi i32 [ %i.inner, %loop3.header ]
2542 br label %loop1.header
2544 loop3.exit:
2545 call void @f()
2546 ret void
2548 loop2.exit:
2549 call void @g()
2550 ret void
2552 loop1.exit:
2553 call void @g()
2554 ret void
2555 }
2557 ; Test that when we are unswitching and need to rebuild the loop block set we
2558 ; correctly skip past inner loops. We want to use the inner loop to efficiently
2559 ; skip whole subregions of the outer loop blocks but just because the header of
2560 ; the outer loop is also the preheader of an inner loop shouldn't confuse this
2561 ; walk.
2562 define void @test23(i1 %arg, ptr %ptr) {
2563 ; CHECK-LABEL: define void @test23(
2564 entry:
2565 br label %outer.header
2566 ; CHECK: entry:
2567 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %arg
2568 ; CHECK-NEXT: br i1 %[[FROZEN]],
2569 ;
2570 ; Just verify that we unswitched the correct bits. We should call `@f` twice in
2571 ; one unswitch and `@f` and then `@g` in the other.
2572 ; CHECK: call void
2573 ; CHECK-SAME: @f
2574 ; CHECK: call void
2575 ; CHECK-SAME: @f
2576 ;
2577 ; CHECK: call void
2578 ; CHECK-SAME: @f
2579 ; CHECK: call void
2580 ; CHECK-SAME: @g
2582 outer.header:
2583 br label %inner.header
2585 inner.header:
2586 call void @f()
2587 br label %inner.latch
2589 inner.latch:
2590 %inner.cond = load i1, ptr %ptr
2591 br i1 %inner.cond, label %inner.header, label %outer.body
2593 outer.body:
2594 br i1 %arg, label %outer.body.left, label %outer.body.right
2596 outer.body.left:
2597 call void @f()
2598 br label %outer.latch
2600 outer.body.right:
2601 call void @g()
2602 br label %outer.latch
2604 outer.latch:
2605 %outer.cond = load i1, ptr %ptr
2606 br i1 %outer.cond, label %outer.header, label %exit
2608 exit:
2609 ret void
2610 }
2612 ; Non-trivial loop unswitching where there are two invariant conditions, but the
2613 ; second one is only in the cloned copy of the loop after unswitching.
2614 define i32 @test24(ptr %ptr, i1 %cond1, i1 %cond2) {
2615 ; CHECK-LABEL: @test24(
2616 entry:
2617 br label %loop_begin
2618 ; CHECK-NEXT: entry:
2619 ; CHECK-NEXT: br i1 %cond1, label %entry.split.us, label %entry.split
2621 loop_begin:
2622 br i1 %cond1, label %loop_a, label %loop_b
2624 loop_a:
2625 br i1 %cond2, label %loop_a_a, label %loop_a_c
2626 ; The second unswitched condition.
2627 ;
2628 ; CHECK: entry.split.us:
2629 ; CHECK-NEXT: br i1 %cond2, label %entry.split.us.split.us, label %entry.split.us.split
2631 loop_a_a:
2632 call i32 @a()
2633 br label %latch
2634 ; The 'loop_a_a' unswitched loop.
2635 ;
2636 ; CHECK: entry.split.us.split.us:
2637 ; CHECK-NEXT: br label %loop_begin.us.us
2638 ;
2639 ; CHECK: loop_begin.us.us:
2640 ; CHECK-NEXT: br label %loop_a.us.us
2641 ;
2642 ; CHECK: loop_a.us.us:
2643 ; CHECK-NEXT: br label %loop_a_a.us.us
2644 ;
2645 ; CHECK: loop_a_a.us.us:
2646 ; CHECK-NEXT: call i32 @a()
2647 ; CHECK-NEXT: br label %latch.us.us
2648 ;
2649 ; CHECK: latch.us.us:
2650 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2651 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin.us.us, label %loop_exit.split.us.split.us
2652 ;
2653 ; CHECK: loop_exit.split.us.split.us:
2654 ; CHECK-NEXT: br label %loop_exit.split
2656 loop_a_c:
2657 call i32 @c()
2658 br label %latch
2659 ; The 'loop_a_c' unswitched loop.
2660 ;
2661 ; CHECK: entry.split.us.split:
2662 ; CHECK-NEXT: br label %loop_begin.us
2663 ;
2664 ; CHECK: loop_begin.us:
2665 ; CHECK-NEXT: br label %loop_a.us
2666 ;
2667 ; CHECK: loop_a.us:
2668 ; CHECK-NEXT: br label %loop_a_c.us
2669 ;
2670 ; CHECK: loop_a_c.us:
2671 ; CHECK-NEXT: call i32 @c()
2672 ; CHECK-NEXT: br label %latch
2673 ;
2674 ; CHECK: latch.us:
2675 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2676 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin.us, label %loop_exit.split.us.split
2677 ;
2678 ; CHECK: loop_exit.split.us.split:
2679 ; CHECK-NEXT: br label %loop_exit.split
2681 loop_b:
2682 call i32 @b()
2683 br label %latch
2684 ; The 'loop_b' unswitched loop.
2685 ;
2686 ; CHECK: entry.split:
2687 ; CHECK-NEXT: br label %loop_begin
2688 ;
2689 ; CHECK: loop_begin:
2690 ; CHECK-NEXT: br label %loop_b
2691 ;
2692 ; CHECK: loop_b:
2693 ; CHECK-NEXT: call i32 @b()
2694 ; CHECK-NEXT: br label %latch
2695 ;
2696 ; CHECK: latch:
2697 ; CHECK-NEXT: %[[V:.*]] = load i1, ptr %ptr
2698 ; CHECK-NEXT: br i1 %[[V]], label %loop_begin, label %loop_exit.split
2699 ;
2700 ; CHECK: loop_exit.split:
2701 ; CHECK-NEXT: br label %loop_exit
2703 latch:
2704 %v = load i1, ptr %ptr
2705 br i1 %v, label %loop_begin, label %loop_exit
2707 loop_exit:
2708 ret i32 0
2709 ; CHECK: loop_exit:
2710 ; CHECK-NEXT: ret
2711 }
2713 ; Non-trivial partial loop unswitching of an invariant input to an 'or'.
2714 define i32 @test25(ptr %ptr, i1 %cond) {
2715 ; CHECK-LABEL: @test25(
2716 entry:
2717 br label %loop_begin
2718 ; CHECK-NEXT: entry:
2719 ; CHECK-NEXT: [[FROZEN:%.+]] = freeze i1 %cond
2720 ; CHECK-NEXT: br i1 [[FROZEN]], label %entry.split.us, label %entry.split
2722 loop_begin:
2723 %v1 = load i1, ptr %ptr
2724 %cond_or = or i1 %v1, %cond
2725 br i1 %cond_or, label %loop_a, label %loop_b
2727 loop_a:
2728 call i32 @a()
2729 br label %latch
2730 ; The 'loop_a' unswitched loop.
2731 ;
2732 ; CHECK: entry.split.us:
2733 ; CHECK-NEXT: br label %loop_begin.us
2734 ;
2735 ; CHECK: loop_begin.us:
2736 ; CHECK-NEXT: br label %loop_a.us
2737 ;
2738 ; CHECK: loop_a.us:
2739 ; CHECK-NEXT: call i32 @a()
2740 ; CHECK-NEXT: br label %latch.us
2741 ;
2742 ; CHECK: latch.us:
2743 ; CHECK-NEXT: %[[V2_US:.*]] = load i1, ptr %ptr
2744 ; CHECK-NEXT: br i1 %[[V2_US]], label %loop_begin.us, label %loop_exit.split.us
2745 ;
2746 ; CHECK: loop_exit.split.us:
2747 ; CHECK-NEXT: br label %loop_exit
2749 loop_b:
2750 call i32 @b()
2751 br label %latch
2752 ; The original loop.
2753 ;
2754 ; CHECK: entry.split:
2755 ; CHECK-NEXT: br label %loop_begin
2756 ;
2757 ; CHECK: loop_begin:
2758 ; CHECK-NEXT: %[[V1:.*]] = load i1, ptr %ptr
2759 ; CHECK-NEXT: %[[OR:.*]] = or i1 %[[V1]], false
2760 ; CHECK-NEXT: br i1 %[[OR]], label %loop_a, label %loop_b
2761 ;
2762 ; CHECK: loop_a:
2763 ; CHECK-NEXT: call i32 @a()
2764 ; CHECK-NEXT: br label %latch
2765 ;
2766 ; CHECK: loop_b:
2767 ; CHECK-NEXT: call i32 @b()
2768 ; CHECK-NEXT: br label %latch
2770 latch:
2771 %v2 = load i1, ptr %ptr
2772 br i1 %v2, label %loop_begin, label %loop_exit
2773 ; CHECK: latch:
2774 ; CHECK-NEXT: %[[V2:.*]] = load i1, ptr %ptr
2775 ; CHECK-NEXT: br i1 %[[V2]], label %loop_begin, label %loop_exit.split
2777 loop_exit:
2778 ret i32 0
2779 ; CHECK: loop_exit.split:
2780 ; CHECK-NEXT: br label %loop_exit
2781 ;
2782 ; CHECK: loop_exit:
2783 ; CHECK-NEXT: ret
2784 }
2786 ; Non-trivial partial loop unswitching of multiple invariant inputs to an `and`
2787 ; chain.
2788 define i32 @test26(ptr %ptr1, ptr %ptr2, ptr %ptr3, i1 %cond1, i1 %cond2, i1 %cond3) {
2789 ; CHECK-LABEL: @test26(
2790 entry:
2791 br label %loop_begin
2792 ; CHECK-NEXT: entry:
2793 ; CHECK-NEXT: [[C3_FR:%.+]] = freeze i1 %cond3
2794 ; CHECK-NEXT: [[C1_FR:%.+]] = freeze i1 %cond1
2795 ; CHECK-NEXT: %[[INV_AND:.*]] = and i1 [[C3_FR]], [[C1_FR]]
2796 ; CHECK-NEXT: br i1 %[[INV_AND]], label %entry.split, label %entry.split.us
2798 loop_begin:
2799 %v1 = load i1, ptr %ptr1
2800 %v2 = load i1, ptr %ptr2
2801 %cond_and1 = and i1 %v1, %cond1
2802 %cond_or1 = or i1 %v2, %cond2
2803 %cond_and2 = and i1 %cond_and1, %cond_or1
2804 %cond_and3 = and i1 %cond_and2, %cond3
2805 br i1 %cond_and3, label %loop_a, label %loop_b
2806 ; The 'loop_b' unswitched loop.
2807 ;
2808 ; CHECK: entry.split.us:
2809 ; CHECK-NEXT: br label %loop_begin.us
2810 ;
2811 ; CHECK: loop_begin.us:
2812 ; CHECK-NEXT: br label %loop_b.us
2813 ;
2814 ; CHECK: loop_b.us:
2815 ; CHECK-NEXT: call i32 @b()
2816 ; CHECK-NEXT: br label %latch.us
2817 ;
2818 ; CHECK: latch.us:
2819 ; CHECK-NEXT: %[[V3_US:.*]] = load i1, ptr %ptr3
2820 ; CHECK-NEXT: br i1 %[[V3_US]], label %loop_begin.us, label %loop_exit.split.us
2821 ;
2822 ; CHECK: loop_exit.split.us:
2823 ; CHECK-NEXT: br label %loop_exit
2825 ; The original loop.
2826 ;
2827 ; CHECK: entry.split:
2828 ; CHECK-NEXT: br label %loop_begin
2829 ;
2830 ; CHECK: loop_begin:
2831 ; CHECK-NEXT: %[[V1:.*]] = load i1, ptr %ptr1
2832 ; CHECK-NEXT: %[[V2:.*]] = load i1, ptr %ptr2
2833 ; CHECK-NEXT: %[[AND1:.*]] = and i1 %[[V1]], true
2834 ; CHECK-NEXT: %[[OR1:.*]] = or i1 %[[V2]], %cond2
2835 ; CHECK-NEXT: %[[AND2:.*]] = and i1 %[[AND1]], %[[OR1]]
2836 ; CHECK-NEXT: %[[AND3:.*]] = and i1 %[[AND2]], true
2837 ; CHECK-NEXT: br i1 %[[AND3]], label %loop_a, label %loop_b
2839 loop_a:
2840 call i32 @a()
2841 br label %latch
2842 ; CHECK: loop_a:
2843 ; CHECK-NEXT: call i32 @a()
2844 ; CHECK-NEXT: br label %latch
2846 loop_b:
2847 call i32 @b()
2848 br label %latch
2849 ; CHECK: loop_b:
2850 ; CHECK-NEXT: call i32 @b()
2851 ; CHECK-NEXT: br label %latch
2853 latch:
2854 %v3 = load i1, ptr %ptr3
2855 br i1 %v3, label %loop_begin, label %loop_exit
2856 ; CHECK: latch:
2857 ; CHECK-NEXT: %[[V3:.*]] = load i1, ptr %ptr3
2858 ; CHECK-NEXT: br i1 %[[V3]], label %loop_begin, label %loop_exit.split
2860 loop_exit:
2861 ret i32 0
2862 ; CHECK: loop_exit.split:
2863 ; CHECK-NEXT: br label %loop_exit
2864 ;
2865 ; CHECK: loop_exit:
2866 ; CHECK-NEXT: ret
2867 }
2869 ; Non-trivial partial loop unswitching of multiple invariant inputs to an `or`
2870 ; chain. Basically an inverted version of corresponding `and` test (test26).
2871 define i32 @test27(ptr %ptr1, ptr %ptr2, ptr %ptr3, i1 %cond1, i1 %cond2, i1 %cond3) {
2872 ; CHECK-LABEL: @test27(
2873 entry:
2874 br label %loop_begin
2875 ; CHECK-NEXT: entry:
2876 ; CHECK-NEXT: [[C3_FR:%.+]] = freeze i1 %cond3
2877 ; CHECK-NEXT: [[C1_FR:%.+]] = freeze i1 %cond1
2878 ; CHECK-NEXT: %[[INV_OR:.*]] = or i1 [[C3_FR]], [[C1_FR]]
2879 ; CHECK-NEXT: br i1 %[[INV_OR]], label %entry.split.us, label %entry.split
2881 loop_begin:
2882 %v1 = load i1, ptr %ptr1
2883 %v2 = load i1, ptr %ptr2
2884 %cond_or1 = or i1 %v1, %cond1
2885 %cond_and1 = and i1 %v2, %cond2
2886 %cond_or2 = or i1 %cond_or1, %cond_and1
2887 %cond_or3 = or i1 %cond_or2, %cond3
2888 br i1 %cond_or3, label %loop_b, label %loop_a
2889 ; The 'loop_b' unswitched loop.
2890 ;
2891 ; CHECK: entry.split.us:
2892 ; CHECK-NEXT: br label %loop_begin.us
2893 ;
2894 ; CHECK: loop_begin.us:
2895 ; CHECK-NEXT: br label %loop_b.us
2896 ;
2897 ; CHECK: loop_b.us:
2898 ; CHECK-NEXT: call i32 @b()
2899 ; CHECK-NEXT: br label %latch.us
2900 ;
2901 ; CHECK: latch.us:
2902 ; CHECK-NEXT: %[[V3_US:.*]] = load i1, ptr %ptr3
2903 ; CHECK-NEXT: br i1 %[[V3_US]], label %loop_begin.us, label %loop_exit.split.us
2904 ;
2905 ; CHECK: loop_exit.split.us:
2906 ; CHECK-NEXT: br label %loop_exit
2908 ; The original loop.
2909 ;
2910 ; CHECK: entry.split:
2911 ; CHECK-NEXT: br label %loop_begin
2912 ;
2913 ; CHECK: loop_begin:
2914 ; CHECK-NEXT: %[[V1:.*]] = load i1, ptr %ptr1
2915 ; CHECK-NEXT: %[[V2:.*]] = load i1, ptr %ptr2
2916 ; CHECK-NEXT: %[[OR1:.*]] = or i1 %[[V1]], false
2917 ; CHECK-NEXT: %[[AND1:.*]] = and i1 %[[V2]], %cond2
2918 ; CHECK-NEXT: %[[OR2:.*]] = or i1 %[[OR1]], %[[AND1]]
2919 ; CHECK-NEXT: %[[OR3:.*]] = or i1 %[[OR2]], false
2920 ; CHECK-NEXT: br i1 %[[OR3]], label %loop_b, label %loop_a
2922 loop_a:
2923 call i32 @a()
2924 br label %latch
2925 ; CHECK: loop_a:
2926 ; CHECK-NEXT: call i32 @a()
2927 ; CHECK-NEXT: br label %latch
2929 loop_b:
2930 call i32 @b()
2931 br label %latch
2932 ; CHECK: loop_b:
2933 ; CHECK-NEXT: call i32 @b()
2934 ; CHECK-NEXT: br label %latch
2936 latch:
2937 %v3 = load i1, ptr %ptr3
2938 br i1 %v3, label %loop_begin, label %loop_exit
2939 ; CHECK: latch:
2940 ; CHECK-NEXT: %[[V3:.*]] = load i1, ptr %ptr3
2941 ; CHECK-NEXT: br i1 %[[V3]], label %loop_begin, label %loop_exit.split
2943 loop_exit:
2944 ret i32 0
2945 ; CHECK: loop_exit.split:
2946 ; CHECK-NEXT: br label %loop_exit
2947 ;
2948 ; CHECK: loop_exit:
2949 ; CHECK-NEXT: ret
2950 }
2952 ; Non-trivial unswitching of a switch.
2953 define i32 @test28(ptr %ptr, i32 %cond) {
2954 ; CHECK-LABEL: @test28(
2955 entry:
2956 br label %loop_begin
2957 ; CHECK-NEXT: entry:
2958 ; CHECK-NEXT: switch i32 %cond, label %[[ENTRY_SPLIT_LATCH:.*]] [
2959 ; CHECK-NEXT: i32 0, label %[[ENTRY_SPLIT_A:.*]]
2960 ; CHECK-NEXT: i32 1, label %[[ENTRY_SPLIT_B:.*]]
2961 ; CHECK-NEXT: i32 2, label %[[ENTRY_SPLIT_C:.*]]
2962 ; CHECK-NEXT: ]
2964 loop_begin:
2965 switch i32 %cond, label %latch [
2966 i32 0, label %loop_a
2967 i32 1, label %loop_b
2968 i32 2, label %loop_c
2969 ]
2971 loop_a:
2972 call i32 @a()
2973 br label %latch
2974 ; Unswitched 'a' loop.
2975 ;
2976 ; CHECK: [[ENTRY_SPLIT_A]]:
2977 ; CHECK-NEXT: br label %[[LOOP_BEGIN_A:.*]]
2978 ;
2979 ; CHECK: [[LOOP_BEGIN_A]]:
2980 ; CHECK-NEXT: br label %[[LOOP_A:.*]]
2981 ;
2982 ; CHECK: [[LOOP_A]]:
2983 ; CHECK-NEXT: call i32 @a()
2984 ; CHECK-NEXT: br label %[[LOOP_LATCH_A:.*]]
2985 ;
2986 ; CHECK: [[LOOP_LATCH_A]]:
2987 ; CHECK-NEXT: %[[V_A:.*]] = load i1, ptr %ptr
2988 ; CHECK: br i1 %[[V_A]], label %[[LOOP_BEGIN_A]], label %[[LOOP_EXIT_A:.*]]
2989 ;
2990 ; CHECK: [[LOOP_EXIT_A]]:
2991 ; CHECK-NEXT: br label %loop_exit
2993 loop_b:
2994 call i32 @b()
2995 br label %latch
2996 ; Unswitched 'b' loop.
2997 ;
2998 ; CHECK: [[ENTRY_SPLIT_B]]:
2999 ; CHECK-NEXT: br label %[[LOOP_BEGIN_B:.*]]
3000 ;
3001 ; CHECK: [[LOOP_BEGIN_B]]:
3002 ; CHECK-NEXT: br label %[[LOOP_B:.*]]
3003 ;
3004 ; CHECK: [[LOOP_B]]:
3005 ; CHECK-NEXT: call i32 @b()
3006 ; CHECK-NEXT: br label %[[LOOP_LATCH_B:.*]]
3007 ;
3008 ; CHECK: [[LOOP_LATCH_B]]:
3009 ; CHECK-NEXT: %[[V_B:.*]] = load i1, ptr %ptr
3010 ; CHECK: br i1 %[[V_B]], label %[[LOOP_BEGIN_B]], label %[[LOOP_EXIT_B:.*]]
3011 ;
3012 ; CHECK: [[LOOP_EXIT_B]]:
3013 ; CHECK-NEXT: br label %loop_exit
3015 loop_c:
3016 call i32 @c()
3017 br label %latch
3018 ; Unswitched 'c' loop.
3019 ;
3020 ; CHECK: [[ENTRY_SPLIT_C]]:
3021 ; CHECK-NEXT: br label %[[LOOP_BEGIN_C:.*]]
3022 ;
3023 ; CHECK: [[LOOP_BEGIN_C]]:
3024 ; CHECK-NEXT: br label %[[LOOP_C:.*]]
3025 ;
3026 ; CHECK: [[LOOP_C]]:
3027 ; CHECK-NEXT: call i32 @c()
3028 ; CHECK-NEXT: br label %[[LOOP_LATCH_C:.*]]
3029 ;
3030 ; CHECK: [[LOOP_LATCH_C]]:
3031 ; CHECK-NEXT: %[[V_C:.*]] = load i1, ptr %ptr
3032 ; CHECK: br i1 %[[V_C]], label %[[LOOP_BEGIN_C]], label %[[LOOP_EXIT_C:.*]]
3033 ;
3034 ; CHECK: [[LOOP_EXIT_C]]:
3035 ; CHECK-NEXT: br label %loop_exit
3037 latch:
3038 %v = load i1, ptr %ptr
3039 br i1 %v, label %loop_begin, label %loop_exit
3040 ; Unswitched the 'latch' only loop.
3041 ;
3042 ; CHECK: [[ENTRY_SPLIT_LATCH]]:
3043 ; CHECK-NEXT: br label %[[LOOP_BEGIN_LATCH:.*]]
3044 ;
3045 ; CHECK: [[LOOP_BEGIN_LATCH]]:
3046 ; CHECK-NEXT: br label %[[LOOP_LATCH_LATCH:.*]]
3047 ;
3048 ; CHECK: [[LOOP_LATCH_LATCH]]:
3049 ; CHECK-NEXT: %[[V_LATCH:.*]] = load i1, ptr %ptr
3050 ; CHECK: br i1 %[[V_LATCH]], label %[[LOOP_BEGIN_LATCH]], label %[[LOOP_EXIT_LATCH:.*]]
3051 ;
3052 ; CHECK: [[LOOP_EXIT_LATCH]]:
3053 ; CHECK-NEXT: br label %loop_exit
3055 loop_exit:
3056 ret i32 0
3057 ; CHECK: loop_exit:
3058 ; CHECK-NEXT: ret i32 0
3059 }
3061 ; A test case designed to exercise unusual properties of switches: they
3062 ; can introduce multiple edges to successors. These need lots of special case
3063 ; handling as they get collapsed in many cases (domtree, the unswitch itself)
3064 ; but not in all cases (the PHI node operands).
3065 define i32 @test29(i32 %arg) {
3066 ; CHECK-LABEL: @test29(
3067 entry:
3068 br label %header
3069 ; CHECK-NEXT: entry:
3070 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i32 %arg
3071 ; CHECK-NEXT: switch i32 %[[FROZEN]], label %[[ENTRY_SPLIT_C:.*]] [
3072 ; CHECK-NEXT: i32 0, label %[[ENTRY_SPLIT_A:.*]]
3073 ; CHECK-NEXT: i32 1, label %[[ENTRY_SPLIT_A]]
3074 ; CHECK-NEXT: i32 2, label %[[ENTRY_SPLIT_B:.*]]
3075 ; CHECK-NEXT: i32 3, label %[[ENTRY_SPLIT_C]]
3076 ; CHECK-NEXT: ]
3078 header:
3079 %tmp = call i32 @d()
3080 %cmp1 = icmp eq i32 %tmp, 0
3081 ; We set up a chain through all the successors of the switch that doesn't
3082 ; involve the switch so that we can have interesting PHI nodes in them.
3083 br i1 %cmp1, label %body.a, label %dispatch
3085 dispatch:
3086 ; Switch with multiple successors. We arrange the last successor to be the
3087 ; default to make the test case easier to read. This has a duplicate edge
3088 ; both to the default destination (which is completely superfluous but
3089 ; technically valid IR) and to a regular successor.
3090 switch i32 %arg, label %body.c [
3091 i32 0, label %body.a
3092 i32 1, label %body.a
3093 i32 2, label %body.b
3094 i32 3, label %body.c
3095 ]
3097 body.a:
3098 %tmp.a.phi = phi i32 [ 0, %header ], [ %tmp, %dispatch ], [ %tmp, %dispatch ]
3099 %tmp.a = call i32 @a()
3100 %tmp.a.sum = add i32 %tmp.a.phi, %tmp.a
3101 br label %body.b
3102 ; Unswitched 'a' loop.
3103 ;
3104 ; CHECK: [[ENTRY_SPLIT_A]]:
3105 ; CHECK-NEXT: br label %[[HEADER_A:.*]]
3106 ;
3107 ; CHECK: [[HEADER_A]]:
3108 ; CHECK-NEXT: %[[TMP_A:.*]] = call i32 @d()
3109 ; CHECK-NEXT: %[[CMP1_A:.*]] = icmp eq i32 %[[TMP_A]], 0
3110 ; CHECK-NEXT: br i1 %[[CMP1_A]], label %[[BODY_A_A:.*]], label %[[DISPATCH_A:.*]]
3111 ;
3112 ; CHECK: [[DISPATCH_A]]:
3113 ; CHECK-NEXT: br label %[[BODY_A_A]]
3114 ;
3115 ; CHECK: [[BODY_A_A]]:
3116 ; CHECK-NEXT: %[[TMP_A_PHI_A:.*]] = phi i32 [ 0, %[[HEADER_A]] ], [ %[[TMP_A]], %[[DISPATCH_A]] ]
3117 ; CHECK-NEXT: %[[TMP_A_A:.*]] = call i32 @a()
3118 ; CHECK-NEXT: %[[TMP_A_SUM_A:.*]] = add i32 %[[TMP_A_PHI_A]], %[[TMP_A_A]]
3119 ; CHECK-NEXT: br label %[[BODY_B_A:.*]]
3120 ;
3121 ; CHECK: [[BODY_B_A]]:
3122 ; CHECK-NEXT: %[[TMP_B_PHI_A:.*]] = phi i32 [ %[[TMP_A_SUM_A]], %[[BODY_A_A]] ]
3123 ; CHECK-NEXT: %[[TMP_B_A:.*]] = call i32 @b()
3124 ; CHECK-NEXT: %[[TMP_B_SUM_A:.*]] = add i32 %[[TMP_B_PHI_A]], %[[TMP_B_A]]
3125 ; CHECK-NEXT: br label %[[BODY_C_A:.*]]
3126 ;
3127 ; CHECK: [[BODY_C_A]]:
3128 ; CHECK-NEXT: %[[TMP_C_PHI_A:.*]] = phi i32 [ %[[TMP_B_SUM_A]], %[[BODY_B_A]] ]
3129 ; CHECK-NEXT: %[[TMP_C_A:.*]] = call i32 @c()
3130 ; CHECK-NEXT: %[[TMP_C_SUM_A:.*]] = add i32 %[[TMP_C_PHI_A]], %[[TMP_C_A]]
3131 ; CHECK-NEXT: br label %[[LATCH_A:.*]]
3132 ;
3133 ; CHECK: [[LATCH_A]]:
3134 ; CHECK-NEXT: %[[CMP2_A:.*]] = icmp slt i32 %[[TMP_C_SUM_A]], 42
3135 ; CHECK: br i1 %[[CMP2_A]], label %[[HEADER_A]], label %[[LOOP_EXIT_A:.*]]
3136 ;
3137 ; CHECK: [[LOOP_EXIT_A]]:
3138 ; CHECK-NEXT: %[[LCSSA_A:.*]] = phi i32 [ %[[TMP_C_SUM_A]], %[[LATCH_A]] ]
3139 ; CHECK-NEXT: br label %exit
3141 body.b:
3142 %tmp.b.phi = phi i32 [ %tmp, %dispatch ], [ %tmp.a.sum, %body.a ]
3143 %tmp.b = call i32 @b()
3144 %tmp.b.sum = add i32 %tmp.b.phi, %tmp.b
3145 br label %body.c
3146 ; Unswitched 'b' loop.
3147 ;
3148 ; CHECK: [[ENTRY_SPLIT_B]]:
3149 ; CHECK-NEXT: br label %[[HEADER_B:.*]]
3150 ;
3151 ; CHECK: [[HEADER_B]]:
3152 ; CHECK-NEXT: %[[TMP_B:.*]] = call i32 @d()
3153 ; CHECK-NEXT: %[[CMP1_B:.*]] = icmp eq i32 %[[TMP_B]], 0
3154 ; CHECK-NEXT: br i1 %[[CMP1_B]], label %[[BODY_A_B:.*]], label %[[DISPATCH_B:.*]]
3155 ;
3156 ; CHECK: [[DISPATCH_B]]:
3157 ; CHECK-NEXT: br label %[[BODY_B_B:.*]]
3158 ;
3159 ; CHECK: [[BODY_A_B]]:
3160 ; CHECK-NEXT: %[[TMP_A_PHI_B:.*]] = phi i32 [ 0, %[[HEADER_B]] ]
3161 ; CHECK-NEXT: %[[TMP_A_B:.*]] = call i32 @a()
3162 ; CHECK-NEXT: %[[TMP_A_SUM_B:.*]] = add i32 %[[TMP_A_PHI_B]], %[[TMP_A_B]]
3163 ; CHECK-NEXT: br label %[[BODY_B_B:.*]]
3164 ;
3165 ; CHECK: [[BODY_B_B]]:
3166 ; CHECK-NEXT: %[[TMP_B_PHI_B:.*]] = phi i32 [ %[[TMP_B]], %[[DISPATCH_B]] ], [ %[[TMP_A_SUM_B]], %[[BODY_A_B]] ]
3167 ; CHECK-NEXT: %[[TMP_B_B:.*]] = call i32 @b()
3168 ; CHECK-NEXT: %[[TMP_B_SUM_B:.*]] = add i32 %[[TMP_B_PHI_B]], %[[TMP_B_B]]
3169 ; CHECK-NEXT: br label %[[BODY_C_B:.*]]
3170 ;
3171 ; CHECK: [[BODY_C_B]]:
3172 ; CHECK-NEXT: %[[TMP_C_PHI_B:.*]] = phi i32 [ %[[TMP_B_SUM_B]], %[[BODY_B_B]] ]
3173 ; CHECK-NEXT: %[[TMP_C_B:.*]] = call i32 @c()
3174 ; CHECK-NEXT: %[[TMP_C_SUM_B:.*]] = add i32 %[[TMP_C_PHI_B]], %[[TMP_C_B]]
3175 ; CHECK-NEXT: br label %[[LATCH_B:.*]]
3176 ;
3177 ; CHECK: [[LATCH_B]]:
3178 ; CHECK-NEXT: %[[CMP2_B:.*]] = icmp slt i32 %[[TMP_C_SUM_B]], 42
3179 ; CHECK: br i1 %[[CMP2_B]], label %[[HEADER_B]], label %[[LOOP_EXIT_B:.*]]
3180 ;
3181 ; CHECK: [[LOOP_EXIT_B]]:
3182 ; CHECK-NEXT: %[[LCSSA_B:.*]] = phi i32 [ %[[TMP_C_SUM_B]], %[[LATCH_B]] ]
3183 ; CHECK-NEXT: br label %[[EXIT_SPLIT:.*]]
3185 body.c:
3186 %tmp.c.phi = phi i32 [ %tmp, %dispatch ], [ %tmp, %dispatch ], [ %tmp.b.sum, %body.b ]
3187 %tmp.c = call i32 @c()
3188 %tmp.c.sum = add i32 %tmp.c.phi, %tmp.c
3189 br label %latch
3190 ; Unswitched 'c' loop.
3191 ;
3192 ; CHECK: [[ENTRY_SPLIT_C]]:
3193 ; CHECK-NEXT: br label %[[HEADER_C:.*]]
3194 ;
3195 ; CHECK: [[HEADER_C]]:
3196 ; CHECK-NEXT: %[[TMP_C:.*]] = call i32 @d()
3197 ; CHECK-NEXT: %[[CMP1_C:.*]] = icmp eq i32 %[[TMP_C]], 0
3198 ; CHECK-NEXT: br i1 %[[CMP1_C]], label %[[BODY_A_C:.*]], label %[[DISPATCH_C:.*]]
3199 ;
3200 ; CHECK: [[DISPATCH_C]]:
3201 ; CHECK-NEXT: br label %[[BODY_C_C:.*]]
3202 ;
3203 ; CHECK: [[BODY_A_C]]:
3204 ; CHECK-NEXT: %[[TMP_A_PHI_C:.*]] = phi i32 [ 0, %[[HEADER_C]] ]
3205 ; CHECK-NEXT: %[[TMP_A_C:.*]] = call i32 @a()
3206 ; CHECK-NEXT: %[[TMP_A_SUM_C:.*]] = add i32 %[[TMP_A_PHI_C]], %[[TMP_A_C]]
3207 ; CHECK-NEXT: br label %[[BODY_B_C:.*]]
3208 ;
3209 ; CHECK: [[BODY_B_C]]:
3210 ; CHECK-NEXT: %[[TMP_B_PHI_C:.*]] = phi i32 [ %[[TMP_A_SUM_C]], %[[BODY_A_C]] ]
3211 ; CHECK-NEXT: %[[TMP_B_C:.*]] = call i32 @b()
3212 ; CHECK-NEXT: %[[TMP_B_SUM_C:.*]] = add i32 %[[TMP_B_PHI_C]], %[[TMP_B_C]]
3213 ; CHECK-NEXT: br label %[[BODY_C_C:.*]]
3214 ;
3215 ; CHECK: [[BODY_C_C]]:
3216 ; CHECK-NEXT: %[[TMP_C_PHI_C:.*]] = phi i32 [ %[[TMP_C]], %[[DISPATCH_C]] ], [ %[[TMP_B_SUM_C]], %[[BODY_B_C]] ]
3217 ; CHECK-NEXT: %[[TMP_C_C:.*]] = call i32 @c()
3218 ; CHECK-NEXT: %[[TMP_C_SUM_C:.*]] = add i32 %[[TMP_C_PHI_C]], %[[TMP_C_C]]
3219 ; CHECK-NEXT: br label %[[LATCH_C:.*]]
3220 ;
3221 ; CHECK: [[LATCH_C]]:
3222 ; CHECK-NEXT: %[[CMP2_C:.*]] = icmp slt i32 %[[TMP_C_SUM_C]], 42
3223 ; CHECK: br i1 %[[CMP2_C]], label %[[HEADER_C]], label %[[LOOP_EXIT_C:.*]]
3224 ;
3225 ; CHECK: [[LOOP_EXIT_C]]:
3226 ; CHECK-NEXT: %[[LCSSA_C:.*]] = phi i32 [ %[[TMP_C_SUM_C]], %[[LATCH_C]] ]
3227 ; CHECK-NEXT: br label %[[EXIT_SPLIT]]
3229 latch:
3230 %cmp2 = icmp slt i32 %tmp.c.sum, 42
3231 br i1 %cmp2, label %header, label %exit
3233 exit:
3234 %lcssa.phi = phi i32 [ %tmp.c.sum, %latch ]
3235 ret i32 %lcssa.phi
3236 ; CHECK: [[EXIT_SPLIT]]:
3237 ; CHECK-NEXT: %[[EXIT_PHI1:.*]] = phi i32 [ %[[LCSSA_C]], %[[LOOP_EXIT_C]] ], [ %[[LCSSA_B]], %[[LOOP_EXIT_B]] ]
3238 ; CHECK-NEXT: br label %exit
3240 ; CHECK: exit:
3241 ; CHECK-NEXT: %[[EXIT_PHI2:.*]] = phi i32 [ %[[EXIT_PHI1]], %[[EXIT_SPLIT]] ], [ %[[LCSSA_A]], %[[LOOP_EXIT_A]] ]
3242 ; CHECK-NEXT: ret i32 %[[EXIT_PHI2]]
3243 }
3245 ; Similar to @test29 but designed to have one of the duplicate edges be
3246 ; a loop exit edge as those can in some cases be special. Among other things,
3247 ; this includes an LCSSA phi with multiple entries despite being a dedicated
3248 ; exit block.
3249 define i32 @test30(i32 %arg) {
3250 ; CHECK-LABEL: define i32 @test30(
3251 entry:
3252 br label %header
3253 ; CHECK-NEXT: entry:
3254 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i32 %arg
3255 ; CHECK-NEXT: switch i32 %[[FROZEN]], label %[[ENTRY_SPLIT_EXIT:.*]] [
3256 ; CHECK-NEXT: i32 -1, label %[[ENTRY_SPLIT_EXIT]]
3257 ; CHECK-NEXT: i32 0, label %[[ENTRY_SPLIT_A:.*]]
3258 ; CHECK-NEXT: i32 1, label %[[ENTRY_SPLIT_B:.*]]
3259 ; CHECK-NEXT: i32 2, label %[[ENTRY_SPLIT_B]]
3260 ; CHECK-NEXT: ]
3262 header:
3263 %tmp = call i32 @d()
3264 %cmp1 = icmp eq i32 %tmp, 0
3265 br i1 %cmp1, label %body.a, label %dispatch
3267 dispatch:
3268 switch i32 %arg, label %loop.exit1 [
3269 i32 -1, label %loop.exit1
3270 i32 0, label %body.a
3271 i32 1, label %body.b
3272 i32 2, label %body.b
3273 ]
3275 body.a:
3276 %tmp.a.phi = phi i32 [ 0, %header ], [ %tmp, %dispatch ]
3277 %tmp.a = call i32 @a()
3278 %tmp.a.sum = add i32 %tmp.a.phi, %tmp.a
3279 br label %body.b
3280 ; Unswitched 'a' loop.
3281 ;
3282 ; CHECK: [[ENTRY_SPLIT_A]]:
3283 ; CHECK-NEXT: br label %[[HEADER_A:.*]]
3284 ;
3285 ; CHECK: [[HEADER_A]]:
3286 ; CHECK-NEXT: %[[TMP_A:.*]] = call i32 @d()
3287 ; CHECK-NEXT: %[[CMP1_A:.*]] = icmp eq i32 %[[TMP_A]], 0
3288 ; CHECK-NEXT: br i1 %[[CMP1_A]], label %[[BODY_A_A:.*]], label %[[DISPATCH_A:.*]]
3289 ;
3290 ; CHECK: [[DISPATCH_A]]:
3291 ; CHECK-NEXT: br label %[[BODY_A_A]]
3292 ;
3293 ; CHECK: [[BODY_A_A]]:
3294 ; CHECK-NEXT: %[[TMP_A_PHI_A:.*]] = phi i32 [ 0, %[[HEADER_A]] ], [ %[[TMP_A]], %[[DISPATCH_A]] ]
3295 ; CHECK-NEXT: %[[TMP_A_A:.*]] = call i32 @a()
3296 ; CHECK-NEXT: %[[TMP_A_SUM_A:.*]] = add i32 %[[TMP_A_PHI_A]], %[[TMP_A_A]]
3297 ; CHECK-NEXT: br label %[[BODY_B_A:.*]]
3298 ;
3299 ; CHECK: [[BODY_B_A]]:
3300 ; CHECK-NEXT: %[[TMP_B_PHI_A:.*]] = phi i32 [ %[[TMP_A_SUM_A]], %[[BODY_A_A]] ]
3301 ; CHECK-NEXT: %[[TMP_B_A:.*]] = call i32 @b()
3302 ; CHECK-NEXT: %[[TMP_B_SUM_A:.*]] = add i32 %[[TMP_B_PHI_A]], %[[TMP_B_A]]
3303 ; CHECK-NEXT: br label %[[LATCH_A:.*]]
3304 ;
3305 ; CHECK: [[LATCH_A]]:
3306 ; CHECK-NEXT: %[[CMP2_A:.*]] = icmp slt i32 %[[TMP_B_SUM_A]], 42
3307 ; CHECK: br i1 %[[CMP2_A]], label %[[HEADER_A]], label %[[LOOP_EXIT_A:.*]]
3308 ;
3309 ; CHECK: [[LOOP_EXIT_A]]:
3310 ; CHECK-NEXT: %[[LCSSA_A:.*]] = phi i32 [ %[[TMP_B_SUM_A]], %[[LATCH_A]] ]
3311 ; CHECK-NEXT: br label %loop.exit2
3313 body.b:
3314 %tmp.b.phi = phi i32 [ %tmp, %dispatch ], [ %tmp, %dispatch ], [ %tmp.a.sum, %body.a ]
3315 %tmp.b = call i32 @b()
3316 %tmp.b.sum = add i32 %tmp.b.phi, %tmp.b
3317 br label %latch
3318 ; Unswitched 'b' loop.
3319 ;
3320 ; CHECK: [[ENTRY_SPLIT_B]]:
3321 ; CHECK-NEXT: br label %[[HEADER_B:.*]]
3322 ;
3323 ; CHECK: [[HEADER_B]]:
3324 ; CHECK-NEXT: %[[TMP_B:.*]] = call i32 @d()
3325 ; CHECK-NEXT: %[[CMP1_B:.*]] = icmp eq i32 %[[TMP_B]], 0
3326 ; CHECK-NEXT: br i1 %[[CMP1_B]], label %[[BODY_A_B:.*]], label %[[DISPATCH_B:.*]]
3327 ;
3328 ; CHECK: [[DISPATCH_B]]:
3329 ; CHECK-NEXT: br label %[[BODY_B_B]]
3330 ;
3331 ; CHECK: [[BODY_A_B]]:
3332 ; CHECK-NEXT: %[[TMP_A_PHI_B:.*]] = phi i32 [ 0, %[[HEADER_B]] ]
3333 ; CHECK-NEXT: %[[TMP_A_B:.*]] = call i32 @a()
3334 ; CHECK-NEXT: %[[TMP_A_SUM_B:.*]] = add i32 %[[TMP_A_PHI_B]], %[[TMP_A_B]]
3335 ; CHECK-NEXT: br label %[[BODY_B_B:.*]]
3336 ;
3337 ; CHECK: [[BODY_B_B]]:
3338 ; CHECK-NEXT: %[[TMP_B_PHI_B:.*]] = phi i32 [ %[[TMP_B]], %[[DISPATCH_B]] ], [ %[[TMP_A_SUM_B]], %[[BODY_A_B]] ]
3339 ; CHECK-NEXT: %[[TMP_B_B:.*]] = call i32 @b()
3340 ; CHECK-NEXT: %[[TMP_B_SUM_B:.*]] = add i32 %[[TMP_B_PHI_B]], %[[TMP_B_B]]
3341 ; CHECK-NEXT: br label %[[LATCH_B:.*]]
3342 ;
3343 ; CHECK: [[LATCH_B]]:
3344 ; CHECK-NEXT: %[[CMP2_B:.*]] = icmp slt i32 %[[TMP_B_SUM_B]], 42
3345 ; CHECK: br i1 %[[CMP2_B]], label %[[HEADER_B]], label %[[LOOP_EXIT_B:.*]]
3346 ;
3347 ; CHECK: [[LOOP_EXIT_B]]:
3348 ; CHECK-NEXT: %[[LCSSA_B:.*]] = phi i32 [ %[[TMP_B_SUM_B]], %[[LATCH_B]] ]
3349 ; CHECK-NEXT: br label %[[LOOP_EXIT2_SPLIT:.*]]
3351 latch:
3352 %cmp2 = icmp slt i32 %tmp.b.sum, 42
3353 br i1 %cmp2, label %header, label %loop.exit2
3355 loop.exit1:
3356 %l1.phi = phi i32 [ %tmp, %dispatch ], [ %tmp, %dispatch ]
3357 br label %exit
3358 ; Unswitched 'exit' loop.
3359 ;
3360 ; CHECK: [[ENTRY_SPLIT_EXIT]]:
3361 ; CHECK-NEXT: br label %[[HEADER_EXIT:.*]]
3362 ;
3363 ; CHECK: [[HEADER_EXIT]]:
3364 ; CHECK-NEXT: %[[TMP_EXIT:.*]] = call i32 @d()
3365 ; CHECK-NEXT: %[[CMP1_EXIT:.*]] = icmp eq i32 %[[TMP_EXIT]], 0
3366 ; CHECK-NEXT: br i1 %[[CMP1_EXIT]], label %[[BODY_A_EXIT:.*]], label %[[DISPATCH_EXIT:.*]]
3367 ;
3368 ; CHECK: [[DISPATCH_EXIT]]:
3369 ; CHECK-NEXT: %[[TMP_LCSSA:.*]] = phi i32 [ %[[TMP_EXIT]], %[[HEADER_EXIT]] ]
3370 ; CHECK-NEXT: br label %loop.exit1
3371 ;
3372 ; CHECK: [[BODY_A_EXIT]]:
3373 ; CHECK-NEXT: %[[TMP_A_PHI_EXIT:.*]] = phi i32 [ 0, %[[HEADER_EXIT]] ]
3374 ; CHECK-NEXT: %[[TMP_A_EXIT:.*]] = call i32 @a()
3375 ; CHECK-NEXT: %[[TMP_A_SUM_EXIT:.*]] = add i32 %[[TMP_A_PHI_EXIT]], %[[TMP_A_EXIT]]
3376 ; CHECK-NEXT: br label %[[BODY_B_EXIT:.*]]
3377 ;
3378 ; CHECK: [[BODY_B_EXIT]]:
3379 ; CHECK-NEXT: %[[TMP_B_PHI_EXIT:.*]] = phi i32 [ %[[TMP_A_SUM_EXIT]], %[[BODY_A_EXIT]] ]
3380 ; CHECK-NEXT: %[[TMP_B_EXIT:.*]] = call i32 @b()
3381 ; CHECK-NEXT: %[[TMP_B_SUM_EXIT:.*]] = add i32 %[[TMP_B_PHI_EXIT]], %[[TMP_B_EXIT]]
3382 ; CHECK-NEXT: br label %[[LATCH_EXIT:.*]]
3383 ;
3384 ; CHECK: [[LATCH_EXIT]]:
3385 ; CHECK-NEXT: %[[CMP2_EXIT:.*]] = icmp slt i32 %[[TMP_B_SUM_EXIT]], 42
3386 ; CHECK: br i1 %[[CMP2_EXIT]], label %[[HEADER_EXIT]], label %[[LOOP_EXIT_EXIT:.*]]
3387 ;
3388 ; CHECK: loop.exit1:
3389 ; CHECK-NEXT: %[[L1_PHI:.*]] = phi i32 [ %[[TMP_LCSSA]], %[[DISPATCH_EXIT]] ]
3390 ; CHECK-NEXT: br label %exit
3391 ;
3392 ; CHECK: [[LOOP_EXIT_EXIT]]:
3393 ; CHECK-NEXT: %[[L2_PHI:.*]] = phi i32 [ %[[TMP_B_SUM_EXIT]], %[[LATCH_EXIT]] ]
3394 ; CHECK-NEXT: br label %[[LOOP_EXIT2_SPLIT]]
3396 loop.exit2:
3397 %l2.phi = phi i32 [ %tmp.b.sum, %latch ]
3398 br label %exit
3399 ; CHECK: [[LOOP_EXIT2_SPLIT]]:
3400 ; CHECK-NEXT: %[[LOOP_EXIT_PHI1:.*]] = phi i32 [ %[[L2_PHI]], %[[LOOP_EXIT_EXIT]] ], [ %[[LCSSA_B]], %[[LOOP_EXIT_B]] ]
3401 ; CHECK-NEXT: br label %loop.exit2
3402 ;
3403 ; CHECK: loop.exit2:
3404 ; CHECK-NEXT: %[[LOOP_EXIT_PHI2:.*]] = phi i32 [ %[[LOOP_EXIT_PHI1]], %[[LOOP_EXIT2_SPLIT]] ], [ %[[LCSSA_A]], %[[LOOP_EXIT_A]] ]
3405 ; CHECK-NEXT: br label %exit
3407 exit:
3408 %l.phi = phi i32 [ %l1.phi, %loop.exit1 ], [ %l2.phi, %loop.exit2 ]
3409 ret i32 %l.phi
3410 ; CHECK: exit:
3411 ; CHECK-NEXT: %[[EXIT_PHI:.*]] = phi i32 [ %[[L1_PHI]], %loop.exit1 ], [ %[[LOOP_EXIT_PHI2]], %loop.exit2 ]
3412 ; CHECK-NEXT: ret i32 %[[EXIT_PHI]]
3413 }
3415 ; Unswitch will not actually change the loop nest from:
3416 ; A < B < C
3417 define void @hoist_inner_loop0() {
3418 ; CHECK-LABEL: define void @hoist_inner_loop0(
3419 entry:
3420 br label %a.header
3421 ; CHECK: entry:
3422 ; CHECK-NEXT: br label %a.header
3424 a.header:
3425 br label %b.header
3426 ; CHECK: a.header:
3427 ; CHECK-NEXT: br label %b.header
3429 b.header:
3430 %v1 = call i1 @cond()
3431 br label %c.header
3432 ; CHECK: b.header:
3433 ; CHECK-NEXT: %v1 = call i1 @cond()
3434 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %v1
3435 ; CHECK-NEXT: br i1 %[[FROZEN]], label %[[B_HEADER_SPLIT_US:.*]], label %[[B_HEADER_SPLIT:.*]]
3436 ;
3437 ; CHECK: [[B_HEADER_SPLIT_US]]:
3438 ; CHECK-NEXT: br label %[[C_HEADER_US:.*]]
3439 ;
3440 ; CHECK: [[C_HEADER_US]]:
3441 ; CHECK-NEXT: call i32 @c()
3442 ; CHECK-NEXT: br label %[[B_LATCH_SPLIT_US:.*]]
3443 ;
3444 ; CHECK: [[B_LATCH_SPLIT_US]]:
3445 ; CHECK-NEXT: br label %b.latch
3446 ;
3447 ; CHECK: [[B_HEADER_SPLIT]]:
3448 ; CHECK-NEXT: br label %c.header
3450 c.header:
3451 call i32 @c()
3452 br i1 %v1, label %b.latch, label %c.latch
3453 ; CHECK: c.header:
3454 ; CHECK-NEXT: call i32 @c()
3455 ; CHECK-NEXT: br label %c.latch
3457 c.latch:
3458 %v2 = call i1 @cond()
3459 br i1 %v2, label %c.header, label %b.latch
3460 ; CHECK: c.latch:
3461 ; CHECK-NEXT: %v2 = call i1 @cond()
3462 ; CHECK-NEXT: br i1 %v2, label %c.header, label %[[B_LATCH_SPLIT:.*]]
3464 b.latch:
3465 %v3 = call i1 @cond()
3466 br i1 %v3, label %b.header, label %a.latch
3467 ; CHECK: [[B_LATCH_SPLIT]]:
3468 ; CHECK-NEXT: br label %b.latch
3469 ;
3470 ; CHECK: b.latch:
3471 ; CHECK-NEXT: %v3 = call i1 @cond()
3472 ; CHECK-NEXT: br i1 %v3, label %b.header, label %a.latch
3474 a.latch:
3475 br label %a.header
3476 ; CHECK: a.latch:
3477 ; CHECK-NEXT: br label %a.header
3479 exit:
3480 ret void
3481 ; CHECK: exit:
3482 ; CHECK-NEXT: ret void
3483 }
3485 ; Unswitch will transform the loop nest from:
3486 ; A < B < C
3487 ; into
3488 ; A < (B, C)
3489 define void @hoist_inner_loop1(ptr %ptr) {
3490 ; CHECK-LABEL: define void @hoist_inner_loop1(
3491 entry:
3492 br label %a.header
3493 ; CHECK: entry:
3494 ; CHECK-NEXT: br label %a.header
3496 a.header:
3497 %x.a = load i32, ptr %ptr
3498 br label %b.header
3499 ; CHECK: a.header:
3500 ; CHECK-NEXT: %x.a = load i32, ptr %ptr
3501 ; CHECK-NEXT: br label %b.header
3503 b.header:
3504 %x.b = load i32, ptr %ptr
3505 %v1 = call i1 @cond()
3506 br label %c.header
3507 ; CHECK: b.header:
3508 ; CHECK-NEXT: %x.b = load i32, ptr %ptr
3509 ; CHECK-NEXT: %v1 = call i1 @cond()
3510 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %v1
3511 ; CHECK-NEXT: br i1 %[[FROZEN]], label %[[B_HEADER_SPLIT_US:.*]], label %[[B_HEADER_SPLIT:.*]]
3512 ;
3513 ; CHECK: [[B_HEADER_SPLIT_US]]:
3514 ; CHECK-NEXT: br label %[[C_HEADER_US:.*]]
3515 ;
3516 ; CHECK: [[C_HEADER_US]]:
3517 ; CHECK-NEXT: call i32 @c()
3518 ; CHECK-NEXT: br label %[[B_LATCH_US:.*]]
3519 ;
3520 ; CHECK: [[B_LATCH_US]]:
3521 ; CHECK-NEXT: br label %b.latch
3522 ;
3523 ; CHECK: [[B_HEADER_SPLIT]]:
3524 ; CHECK-NEXT: %[[X_B_LCSSA:.*]] = phi i32 [ %x.b, %b.header ]
3525 ; CHECK-NEXT: br label %c.header
3527 c.header:
3528 call i32 @c()
3529 br i1 %v1, label %b.latch, label %c.latch
3530 ; CHECK: c.header:
3531 ; CHECK-NEXT: call i32 @c()
3532 ; CHECK-NEXT: br label %c.latch
3534 c.latch:
3535 ; Use values from other loops to check LCSSA form.
3536 store i32 %x.a, ptr %ptr
3537 store i32 %x.b, ptr %ptr
3538 %v2 = call i1 @cond()
3539 br i1 %v2, label %c.header, label %a.exit.c
3540 ; CHECK: c.latch:
3541 ; CHECK-NEXT: store i32 %x.a, ptr %ptr
3542 ; CHECK-NEXT: store i32 %[[X_B_LCSSA]], ptr %ptr
3543 ; CHECK-NEXT: %v2 = call i1 @cond()
3544 ; CHECK-NEXT: br i1 %v2, label %c.header, label %a.exit.c
3546 b.latch:
3547 %v3 = call i1 @cond()
3548 br i1 %v3, label %b.header, label %a.exit.b
3549 ; CHECK: b.latch:
3550 ; CHECK-NEXT: %v3 = call i1 @cond()
3551 ; CHECK-NEXT: br i1 %v3, label %b.header, label %a.exit.b
3553 a.exit.c:
3554 br label %a.latch
3555 ; CHECK: a.exit.c
3556 ; CHECK-NEXT: br label %a.latch
3558 a.exit.b:
3559 br label %a.latch
3560 ; CHECK: a.exit.b:
3561 ; CHECK-NEXT: br label %a.latch
3563 a.latch:
3564 br label %a.header
3565 ; CHECK: a.latch:
3566 ; CHECK-NEXT: br label %a.header
3568 exit:
3569 ret void
3570 ; CHECK: exit:
3571 ; CHECK-NEXT: ret void
3572 }
3574 ; Unswitch will transform the loop nest from:
3575 ; A < B < C
3576 ; into
3577 ; (A < B), C
3578 define void @hoist_inner_loop2(ptr %ptr) {
3579 ; CHECK-LABEL: define void @hoist_inner_loop2(
3580 entry:
3581 br label %a.header
3582 ; CHECK: entry:
3583 ; CHECK-NEXT: br label %a.header
3585 a.header:
3586 %x.a = load i32, ptr %ptr
3587 br label %b.header
3588 ; CHECK: a.header:
3589 ; CHECK-NEXT: %x.a = load i32, ptr %ptr
3590 ; CHECK-NEXT: br label %b.header
3592 b.header:
3593 %x.b = load i32, ptr %ptr
3594 %v1 = call i1 @cond()
3595 br label %c.header
3596 ; CHECK: b.header:
3597 ; CHECK-NEXT: %x.b = load i32, ptr %ptr
3598 ; CHECK-NEXT: %v1 = call i1 @cond()
3599 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %v1
3600 ; CHECK-NEXT: br i1 %[[FROZEN]], label %[[B_HEADER_SPLIT_US:.*]], label %[[B_HEADER_SPLIT:.*]]
3601 ;
3602 ; CHECK: [[B_HEADER_SPLIT_US]]:
3603 ; CHECK-NEXT: br label %[[C_HEADER_US:.*]]
3604 ;
3605 ; CHECK: [[C_HEADER_US]]:
3606 ; CHECK-NEXT: call i32 @c()
3607 ; CHECK-NEXT: br label %[[B_LATCH_US:.*]]
3608 ;
3609 ; CHECK: [[B_LATCH_US]]:
3610 ; CHECK-NEXT: br label %b.latch
3611 ;
3612 ; CHECK: [[B_HEADER_SPLIT]]:
3613 ; CHECK-NEXT: %[[X_A_LCSSA:.*]] = phi i32 [ %x.a, %b.header ]
3614 ; CHECK-NEXT: %[[X_B_LCSSA:.*]] = phi i32 [ %x.b, %b.header ]
3615 ; CHECK-NEXT: br label %c.header
3617 c.header:
3618 call i32 @c()
3619 br i1 %v1, label %b.latch, label %c.latch
3620 ; CHECK: c.header:
3621 ; CHECK-NEXT: call i32 @c()
3622 ; CHECK-NEXT: br label %c.latch
3624 c.latch:
3625 ; Use values from other loops to check LCSSA form.
3626 store i32 %x.a, ptr %ptr
3627 store i32 %x.b, ptr %ptr
3628 %v2 = call i1 @cond()
3629 br i1 %v2, label %c.header, label %exit
3630 ; CHECK: c.latch:
3631 ; CHECK-NEXT: store i32 %[[X_A_LCSSA]], ptr %ptr
3632 ; CHECK-NEXT: store i32 %[[X_B_LCSSA]], ptr %ptr
3633 ; CHECK-NEXT: %v2 = call i1 @cond()
3634 ; CHECK-NEXT: br i1 %v2, label %c.header, label %exit
3636 b.latch:
3637 %v3 = call i1 @cond()
3638 br i1 %v3, label %b.header, label %a.latch
3639 ; CHECK: b.latch:
3640 ; CHECK-NEXT: %v3 = call i1 @cond()
3641 ; CHECK-NEXT: br i1 %v3, label %b.header, label %a.latch
3643 a.latch:
3644 br label %a.header
3645 ; CHECK: a.latch:
3646 ; CHECK-NEXT: br label %a.header
3648 exit:
3649 ret void
3650 ; CHECK: exit:
3651 ; CHECK-NEXT: ret void
3652 }
3654 ; Same as @hoist_inner_loop2 but with a nested loop inside the hoisted loop.
3655 ; Unswitch will transform the loop nest from:
3656 ; A < B < C < D
3657 ; into
3658 ; (A < B), (C < D)
3659 define void @hoist_inner_loop3(ptr %ptr) {
3660 ; CHECK-LABEL: define void @hoist_inner_loop3(
3661 entry:
3662 br label %a.header
3663 ; CHECK: entry:
3664 ; CHECK-NEXT: br label %a.header
3666 a.header:
3667 %x.a = load i32, ptr %ptr
3668 br label %b.header
3669 ; CHECK: a.header:
3670 ; CHECK-NEXT: %x.a = load i32, ptr %ptr
3671 ; CHECK-NEXT: br label %b.header
3673 b.header:
3674 %x.b = load i32, ptr %ptr
3675 %v1 = call i1 @cond()
3676 br label %c.header
3677 ; CHECK: b.header:
3678 ; CHECK-NEXT: %x.b = load i32, ptr %ptr
3679 ; CHECK-NEXT: %v1 = call i1 @cond()
3680 ; CHECK-NEXT: %[[FROZEN:.+]] = freeze i1 %v1
3681 ; CHECK-NEXT: br i1 %[[FROZEN]], label %[[B_HEADER_SPLIT_US:.*]], label %[[B_HEADER_SPLIT:.*]]
3682 ;
3683 ; CHECK: [[B_HEADER_SPLIT_US]]:
3684 ; CHECK-NEXT: br label %[[C_HEADER_US:.*]]
3685 ;
3686 ; CHECK: [[C_HEADER_US]]:
3687 ; CHECK-NEXT: call i32 @c()
3688 ; CHECK-NEXT: br label %[[B_LATCH_US:.*]]
3689 ;
3690 ; CHECK: [[B_LATCH_US]]:
3691 ; CHECK-NEXT: br label %b.latch
3692 ;
3693 ; CHECK: [[B_HEADER_SPLIT]]:
3694 ; CHECK-NEXT: %[[X_A_LCSSA:.*]] = phi i32 [ %x.a, %b.header ]
3695 ; CHECK-NEXT: %[[X_B_LCSSA:.*]] = phi i32 [ %x.b, %b.header ]
3696 ; CHECK-NEXT: br label %c.header
3698 c.header:
3699 call i32 @c()
3700 br i1 %v1, label %b.latch, label %c.body
3701 ; CHECK: c.header:
3702 ; CHECK-NEXT: call i32 @c()
3703 ; CHECK-NEXT: br label %c.body
3705 c.body:
3706 %x.c = load i32, ptr %ptr
3707 br label %d.header
3708 ; CHECK: c.body:
3709 ; CHECK-NEXT: %x.c = load i32, ptr %ptr
3710 ; CHECK-NEXT: br label %d.header
3712 d.header:
3713 ; Use values from other loops to check LCSSA form.
3714 store i32 %x.a, ptr %ptr
3715 store i32 %x.b, ptr %ptr
3716 store i32 %x.c, ptr %ptr
3717 %v2 = call i1 @cond()
3718 br i1 %v2, label %d.header, label %c.latch
3719 ; CHECK: d.header:
3720 ; CHECK-NEXT: store i32 %[[X_A_LCSSA]], ptr %ptr
3721 ; CHECK-NEXT: store i32 %[[X_B_LCSSA]], ptr %ptr
3722 ; CHECK-NEXT: store i32 %x.c, ptr %ptr
3723 ; CHECK-NEXT: %v2 = call i1 @cond()
3724 ; CHECK-NEXT: br i1 %v2, label %d.header, label %c.latch
3726 c.latch:
3727 %v3 = call i1 @cond()
3728 br i1 %v3, label %c.header, label %exit
3729 ; CHECK: c.latch:
3730 ; CHECK-NEXT: %v3 = call i1 @cond()
3731 ; CHECK-NEXT: br i1 %v3, label %c.header, label %exit
3733 b.latch:
3734 %v4 = call i1 @cond()
3735 br i1 %v4, label %b.header, label %a.latch
3736 ; CHECK: b.latch:
3737 ; CHECK-NEXT: %v4 = call i1 @cond()
3738 ; CHECK-NEXT: br i1 %v4, label %b.header, label %a.latch
3740 a.latch:
3741 br label %a.header
3742 ; CHECK: a.latch:
3743 ; CHECK-NEXT: br label %a.header
3745 exit:
3746 ret void
3747 ; CHECK: exit:
3748 ; CHECK-NEXT: ret void
3749 }
3751 ; This test is designed to exercise checking multiple remaining exits from the
3752 ; loop being unswitched.
3753 ; Unswitch will transform the loop nest from:
3754 ; A < B < C < D
3755 ; into
3756 ; A < B < (C, D)
3757 define void @hoist_inner_loop4() {
3758 ; CHECK-LABEL: define void @hoist_inner_loop4(
3759 entry:
3760 br label %a.header
3761 ; CHECK: entry:
3762 ; CHECK-NEXT: br label %a.header
3764 a.header:
3765 br label %b.header
3766 ; CHECK: a.header:
3767 ; CHECK-NEXT: br label %b.header
3769 b.header:
3770 br label %c.header
3771 ; CHECK: b.header:
3772 ; CHECK-NEXT: br label %c.header
3774 c.header:
3775 %v1 = call i1 @cond()
3776 br label %d.header
3777 ; CHECK: c.header:
3778 ; CHECK-NEXT: %v1 = call i1 @cond()
3779 ; CHECK-NEXT: [[FROZEN:%.+]] = freeze i1 %v1
3780 ; CHECK-NEXT: br i1 [[FROZEN]], label %[[C_HEADER_SPLIT_US:.*]], label %[[C_HEADER_SPLIT:.*]]
3781 ;
3782 ; CHECK: [[C_HEADER_SPLIT_US]]:
3783 ; CHECK-NEXT: br label %[[D_HEADER_US:.*]]
3784 ;
3785 ; CHECK: [[D_HEADER_US]]:
3786 ; CHECK-NEXT: call i32 @d()
3787 ; CHECK-NEXT: br label %[[C_LATCH_US:.*]]
3788 ;
3789 ; CHECK: [[C_LATCH_US]]:
3790 ; CHECK-NEXT: br label %c.latch
3791 ;
3792 ; CHECK: [[C_HEADER_SPLIT]]:
3793 ; CHECK-NEXT: br label %d.header
3795 d.header:
3796 call i32 @d()
3797 br i1 %v1, label %c.latch, label %d.exiting1
3798 ; CHECK: d.header:
3799 ; CHECK-NEXT: call i32 @d()
3800 ; CHECK-NEXT: br label %d.exiting1
3802 d.exiting1:
3803 %v2 = call i1 @cond()
3804 br i1 %v2, label %d.exiting2, label %a.latch
3805 ; CHECK: d.exiting1:
3806 ; CHECK-NEXT: %v2 = call i1 @cond()
3807 ; CHECK-NEXT: br i1 %v2, label %d.exiting2, label %a.latch
3809 d.exiting2:
3810 %v3 = call i1 @cond()
3811 br i1 %v3, label %d.exiting3, label %loopexit.d
3812 ; CHECK: d.exiting2:
3813 ; CHECK-NEXT: %v3 = call i1 @cond()
3814 ; CHECK-NEXT: br i1 %v3, label %d.exiting3, label %loopexit.d
3816 d.exiting3:
3817 %v4 = call i1 @cond()
3818 br i1 %v4, label %d.latch, label %b.latch
3819 ; CHECK: d.exiting3:
3820 ; CHECK-NEXT: %v4 = call i1 @cond()
3821 ; CHECK-NEXT: br i1 %v4, label %d.latch, label %b.latch
3823 d.latch:
3824 br label %d.header
3825 ; CHECK: d.latch:
3826 ; CHECK-NEXT: br label %d.header
3828 c.latch:
3829 %v5 = call i1 @cond()
3830 br i1 %v5, label %c.header, label %loopexit.c
3831 ; CHECK: c.latch:
3832 ; CHECK-NEXT: %v5 = call i1 @cond()
3833 ; CHECK-NEXT: br i1 %v5, label %c.header, label %loopexit.c
3835 b.latch:
3836 br label %b.header
3837 ; CHECK: b.latch:
3838 ; CHECK-NEXT: br label %b.header
3840 a.latch:
3841 br label %a.header
3842 ; CHECK: a.latch:
3843 ; CHECK-NEXT: br label %a.header
3845 loopexit.d:
3846 br label %exit
3847 ; CHECK: loopexit.d:
3848 ; CHECK-NEXT: br label %exit
3850 loopexit.c:
3851 br label %exit
3852 ; CHECK: loopexit.c:
3853 ; CHECK-NEXT: br label %exit
3855 exit:
3856 ret void
3857 ; CHECK: exit:
3858 ; CHECK-NEXT: ret void
3859 }
3861 ; Unswitch will transform the loop nest from:
3862 ; A < B < C < D
3863 ; into
3864 ; A < ((B < C), D)
3865 define void @hoist_inner_loop5(ptr %ptr) {
3866 ; CHECK-LABEL: define void @hoist_inner_loop5(
3867 entry:
3868 br label %a.header
3869 ; CHECK: entry:
3870 ; CHECK-NEXT: br label %a.header
3872 a.header:
3873 %x.a = load i32, ptr %ptr
3874 br label %b.header
3875 ; CHECK: a.header:
3876 ; CHECK-NEXT: %x.a = load i32, ptr %ptr
3877 ; CHECK-NEXT: br label %b.header
3879 b.header:
3880 %x.b = load i32, ptr %ptr
3881 br label %c.header
3882 ; CHECK: b.header:
3883 ; CHECK-NEXT: %x.b = load i32, ptr %ptr
3884 ; CHECK-NEXT: br label %c.header
3886 c.header:
3887 %x.c = load i32, ptr %ptr
3888 %v1 = call i1 @cond()
3889 br label %d.header
3890 ; CHECK: c.header:
3891 ; CHECK-NEXT: %x.c = load i32, ptr %ptr
3892 ; CHECK-NEXT: %v1 = call i1 @cond()
3893 ; CHECK-NEXT: [[FROZEN:%.+]] = freeze i1 %v1
3894 ; CHECK-NEXT: br i1 [[FROZEN]], label %[[C_HEADER_SPLIT_US:.*]], label %[[C_HEADER_SPLIT:.*]]
3895 ;
3896 ; CHECK: [[C_HEADER_SPLIT_US]]:
3897 ; CHECK-NEXT: br label %[[D_HEADER_US:.*]]
3898 ;
3899 ; CHECK: [[D_HEADER_US]]:
3900 ; CHECK-NEXT: call i32 @d()
3901 ; CHECK-NEXT: br label %[[C_LATCH_US:.*]]
3902 ;
3903 ; CHECK: [[C_LATCH_US]]:
3904 ; CHECK-NEXT: br label %c.latch
3905 ;
3906 ; CHECK: [[C_HEADER_SPLIT]]:
3907 ; CHECK-NEXT: %[[X_B_LCSSA:.*]] = phi i32 [ %x.b, %c.header ]
3908 ; CHECK-NEXT: %[[X_C_LCSSA:.*]] = phi i32 [ %x.c, %c.header ]
3909 ; CHECK-NEXT: br label %d.header
3911 d.header:
3912 call i32 @d()
3913 br i1 %v1, label %c.latch, label %d.latch
3914 ; CHECK: d.header:
3915 ; CHECK-NEXT: call i32 @d()
3916 ; CHECK-NEXT: br label %d.latch
3918 d.latch:
3919 ; Use values from other loops to check LCSSA form.
3920 store i32 %x.a, ptr %ptr
3921 store i32 %x.b, ptr %ptr
3922 store i32 %x.c, ptr %ptr
3923 %v2 = call i1 @cond()
3924 br i1 %v2, label %d.header, label %a.latch
3925 ; CHECK: d.latch:
3926 ; CHECK-NEXT: store i32 %x.a, ptr %ptr
3927 ; CHECK-NEXT: store i32 %[[X_B_LCSSA]], ptr %ptr
3928 ; CHECK-NEXT: store i32 %[[X_C_LCSSA]], ptr %ptr
3929 ; CHECK-NEXT: %v2 = call i1 @cond()
3930 ; CHECK-NEXT: br i1 %v2, label %d.header, label %a.latch
3932 c.latch:
3933 %v3 = call i1 @cond()
3934 br i1 %v3, label %c.header, label %b.latch
3935 ; CHECK: c.latch:
3936 ; CHECK-NEXT: %v3 = call i1 @cond()
3937 ; CHECK-NEXT: br i1 %v3, label %c.header, label %b.latch
3939 b.latch:
3940 br label %b.header
3941 ; CHECK: b.latch:
3942 ; CHECK-NEXT: br label %b.header
3944 a.latch:
3945 br label %a.header
3946 ; CHECK: a.latch:
3947 ; CHECK-NEXT: br label %a.header
3949 exit:
3950 ret void
3951 ; CHECK: exit:
3952 ; CHECK-NEXT: ret void
3953 }
3955 define void @hoist_inner_loop_switch(ptr %ptr) {
3956 ; CHECK-LABEL: define void @hoist_inner_loop_switch(
3957 entry:
3958 br label %a.header
3959 ; CHECK: entry:
3960 ; CHECK-NEXT: br label %a.header
3962 a.header:
3963 %x.a = load i32, ptr %ptr
3964 br label %b.header
3965 ; CHECK: a.header:
3966 ; CHECK-NEXT: %x.a = load i32, ptr %ptr
3967 ; CHECK-NEXT: br label %b.header
3969 b.header:
3970 %x.b = load i32, ptr %ptr
3971 %v1 = call i32 @cond.i32()
3972 br label %c.header
3973 ; CHECK: b.header:
3974 ; CHECK-NEXT: %x.b = load i32, ptr %ptr
3975 ; CHECK-NEXT: %v1 = call i32 @cond.i32()
3976 ; CHECK-NEXT: [[FROZEN:%.+]] = freeze i32 %v1
3977 ; CHECK-NEXT: switch i32 [[FROZEN]], label %[[B_HEADER_SPLIT:.*]] [
3978 ; CHECK-NEXT: i32 1, label %[[B_HEADER_SPLIT_US:.*]]
3979 ; CHECK-NEXT: i32 2, label %[[B_HEADER_SPLIT_US]]
3980 ; CHECK-NEXT: i32 3, label %[[B_HEADER_SPLIT_US]]
3981 ; CHECK-NEXT: ]
3982 ;
3983 ; CHECK: [[B_HEADER_SPLIT_US]]:
3984 ; CHECK-NEXT: br label %[[C_HEADER_US:.*]]
3985 ;
3986 ; CHECK: [[C_HEADER_US]]:
3987 ; CHECK-NEXT: call i32 @c()
3988 ; CHECK-NEXT: br label %[[B_LATCH_US:.*]]
3989 ;
3990 ; CHECK: [[B_LATCH_US]]:
3991 ; CHECK-NEXT: br label %b.latch
3992 ;
3993 ; CHECK: [[B_HEADER_SPLIT]]:
3994 ; CHECK-NEXT: %[[X_A_LCSSA:.*]] = phi i32 [ %x.a, %b.header ]
3995 ; CHECK-NEXT: %[[X_B_LCSSA:.*]] = phi i32 [ %x.b, %b.header ]
3996 ; CHECK-NEXT: br label %c.header
3998 c.header:
3999 call i32 @c()
4000 switch i32 %v1, label %c.latch [
4001 i32 1, label %b.latch
4002 i32 2, label %b.latch
4003 i32 3, label %b.latch
4004 ]
4005 ; CHECK: c.header:
4006 ; CHECK-NEXT: call i32 @c()
4007 ; CHECK-NEXT: br label %c.latch
4009 c.latch:
4010 ; Use values from other loops to check LCSSA form.
4011 store i32 %x.a, ptr %ptr
4012 store i32 %x.b, ptr %ptr
4013 %v2 = call i1 @cond()
4014 br i1 %v2, label %c.header, label %exit
4015 ; CHECK: c.latch:
4016 ; CHECK-NEXT: store i32 %[[X_A_LCSSA]], ptr %ptr
4017 ; CHECK-NEXT: store i32 %[[X_B_LCSSA]], ptr %ptr
4018 ; CHECK-NEXT: %v2 = call i1 @cond()
4019 ; CHECK-NEXT: br i1 %v2, label %c.header, label %exit
4021 b.latch:
4022 %v3 = call i1 @cond()
4023 br i1 %v3, label %b.header, label %a.latch
4024 ; CHECK: b.latch:
4025 ; CHECK-NEXT: %v3 = call i1 @cond()
4026 ; CHECK-NEXT: br i1 %v3, label %b.header, label %a.latch
4028 a.latch:
4029 br label %a.header
4030 ; CHECK: a.latch:
4031 ; CHECK-NEXT: br label %a.header
4033 exit:
4034 ret void
4035 ; CHECK: exit:
4036 ; CHECK-NEXT: ret void
4037 }
4039 ; A devilish pattern. This is a crafty, crafty test case designed to risk
4040 ; creating indirect cycles with trivial and non-trivial unswitching. The inner
4041 ; loop has a switch with a trivial exit edge that can be unswitched, but the
4042 ; rest of the switch cannot be unswitched because its cost is too high.
4043 ; However, the unswitching of the trivial edge creates a new switch in the
4044 ; outer loop. *This* switch isn't trivial, but has a low cost to unswitch. When
4045 ; we unswitch this switch from the outer loop, we will remove it completely and
4046 ; create a clone of the inner loop on one side. This clone will then again be
4047 ; viable for unswitching the inner-most loop. This lets us check that the
4048 ; unswitching doesn't end up cycling infinitely even when the cycle is
4049 ; indirect and due to revisiting a loop after cloning.
4050 define void @test31(i32 %arg) {
4051 ; CHECK-LABEL: define void @test31(
4052 entry:
4053 br label %outer.header
4054 ; CHECK-NEXT: entry:
4055 ; CHECK-NEXT: switch i32 %arg, label %[[ENTRY_SPLIT:.*]] [
4056 ; CHECK-NEXT: i32 1, label %[[ENTRY_SPLIT_US:.*]]
4057 ; CHECK-NEXT: i32 2, label %[[ENTRY_SPLIT_US]]
4058 ; CHECK-NEXT: ]
4059 ;
4060 ; CHECK: [[ENTRY_SPLIT_US]]:
4061 ; CHECK-NEXT: switch i32 %arg, label %[[ENTRY_SPLIT_US_SPLIT:.*]] [
4062 ; CHECK-NEXT: i32 1, label %[[ENTRY_SPLIT_US_SPLIT_US:.*]]
4063 ; CHECK-NEXT: ]
4065 outer.header:
4066 br label %inner.header
4068 inner.header:
4069 switch i32 %arg, label %inner.loopexit1 [
4070 i32 1, label %inner.body1
4071 i32 2, label %inner.body2
4072 ]
4074 inner.body1:
4075 %a = call i32 @a()
4076 br label %inner.latch
4077 ; The (super convoluted) fully unswitched loop around `@a`.
4078 ;
4079 ; CHECK: [[ENTRY_SPLIT_US_SPLIT_US]]:
4080 ; CHECK-NEXT: br label %[[OUTER_HEADER_US_US:.*]]
4081 ;
4082 ; CHECK: [[OUTER_HEADER_US_US]]:
4083 ; CHECK-NEXT: br label %[[OUTER_HEADER_SPLIT_US_US:.*]]
4084 ;
4085 ; CHECK: [[OUTER_LATCH_US_US:.*]]:
4086 ; CHECK-NEXT: %[[OUTER_COND_US_US:.*]] = call i1 @cond()
4087 ; CHECK-NEXT: br i1 %[[OUTER_COND_US_US]], label %[[OUTER_HEADER_US_US]], label %[[EXIT_SPLIT_US_SPLIT_US:.*]]
4088 ;
4089 ; CHECK: [[OUTER_HEADER_SPLIT_US_US]]:
4090 ; CHECK-NEXT: br label %[[OUTER_HEADER_SPLIT_SPLIT_US_US_US:.*]]
4091 ;
4092 ; CHECK: [[INNER_LOOPEXIT2_US_US:.*]]:
4093 ; CHECK-NEXT: br label %[[OUTER_LATCH_US_US]]
4094 ;
4095 ; CHECK: [[OUTER_HEADER_SPLIT_SPLIT_US_US_US]]:
4096 ; CHECK-NEXT: br label %[[INNER_HEADER_US_US_US:.*]]
4097 ;
4098 ; CHECK: [[INNER_HEADER_US_US_US]]:
4099 ; CHECK-NEXT: br label %[[INNER_BODY1_US_US_US:.*]]
4100 ;
4101 ; CHECK: [[INNER_BODY1_US_US_US]]:
4102 ; CHECK-NEXT: %[[A:.*]] = call i32 @a()
4103 ; CHECK-NEXT: br label %[[INNER_LATCH_US_US_US:.*]]
4104 ;
4105 ; CHECK: [[INNER_LATCH_US_US_US]]:
4106 ; CHECK-NEXT: %[[PHI_A:.*]] = phi i32 [ %[[A]], %[[INNER_BODY1_US_US_US]] ]
4107 ; CHECK-NEXT: call void @sink1(i32 0)
4108 ; CHECK-NEXT: call void @sink1(i32 0)
4109 ; CHECK-NEXT: call void @sink1(i32 0)
4110 ; CHECK-NEXT: call void @sink1(i32 0)
4111 ; CHECK-NEXT: call void @sink1(i32 0)
4112 ; CHECK-NEXT: call void @sink1(i32 0)
4113 ; CHECK-NEXT: call void @sink1(i32 0)
4114 ; CHECK-NEXT: call void @sink1(i32 0)
4115 ; CHECK-NEXT: call void @sink1(i32 0)
4116 ; CHECK-NEXT: call void @sink1(i32 0)
4117 ; CHECK-NEXT: call void @sink1(i32 %[[PHI_A]])
4118 ; CHECK-NEXT: %[[INNER_COND_US_US_US:.*]] = call i1 @cond()
4119 ; CHECK-NEXT: br i1 %[[INNER_COND_US_US_US]], label %[[INNER_HEADER_US_US_US]], label %[[INNER_LOOPEXIT2_SPLIT_US_US_US:.*]]
4120 ;
4121 ; CHECK: [[INNER_LOOPEXIT2_SPLIT_US_US_US]]:
4122 ; CHECK-NEXT: br label %[[INNER_LOOPEXIT2_US_US]]
4123 ;
4124 ; CHECK: [[EXIT_SPLIT_US_SPLIT_US]]:
4125 ; CHECK-NEXT: br label %[[EXIT_SPLIT_US:.*]]
4128 inner.body2:
4129 %b = call i32 @b()
4130 br label %inner.latch
4131 ; The fully unswitched loop around `@b`.
4132 ;
4133 ; CHECK: [[ENTRY_SPLIT_US_SPLIT]]:
4134 ; CHECK-NEXT: br label %[[OUTER_HEADER_US:.*]]
4135 ;
4136 ; CHECK: [[OUTER_HEADER_US]]:
4137 ; CHECK-NEXT: br label %[[OUTER_HEADER_SPLIT_US:.*]]
4138 ;
4139 ; CHECK: [[INNER_HEADER_US:.*]]:
4140 ; CHECK-NEXT: br label %[[INNER_BODY2_US:.*]]
4141 ;
4142 ; CHECK: [[INNER_BODY2_US]]:
4143 ; CHECK-NEXT: %[[B:.*]] = call i32 @b()
4144 ; CHECK-NEXT: br label %[[INNER_LATCH_US:.*]]
4145 ;
4146 ; CHECK: [[INNER_LATCH_US]]:
4147 ; CHECK-NEXT: call void @sink1(i32 0)
4148 ; CHECK-NEXT: call void @sink1(i32 0)
4149 ; CHECK-NEXT: call void @sink1(i32 0)
4150 ; CHECK-NEXT: call void @sink1(i32 0)
4151 ; CHECK-NEXT: call void @sink1(i32 0)
4152 ; CHECK-NEXT: call void @sink1(i32 0)
4153 ; CHECK-NEXT: call void @sink1(i32 0)
4154 ; CHECK-NEXT: call void @sink1(i32 0)
4155 ; CHECK-NEXT: call void @sink1(i32 0)
4156 ; CHECK-NEXT: call void @sink1(i32 0)
4157 ; CHECK-NEXT: call void @sink1(i32 %[[B]])
4158 ; CHECK-NEXT: %[[INNER_COND_US:.*]] = call i1 @cond()
4159 ; CHECK-NEXT: br i1 %[[INNER_COND_US]], label %[[INNER_HEADER_US]], label %[[INNER_LOOPEXIT2_SPLIT_US:.*]]
4160 ;
4161 ; CHECK: [[INNER_LOOPEXIT2_SPLIT_US]]:
4162 ; CHECK-NEXT: br label %[[INNER_LOOPEXIT2_US:.*]]
4163 ;
4164 ; CHECK: [[OUTER_LATCH_US:.*]]:
4165 ; CHECK-NEXT: %[[OUTER_COND_US:.*]] = call i1 @cond()
4166 ; CHECK-NEXT: br i1 %[[OUTER_COND_US]], label %[[OUTER_HEADER_US]], label %[[EXIT_SPLIT_US_SPLIT:.*]]
4167 ;
4168 ; CHECK: [[OUTER_HEADER_SPLIT_US]]:
4169 ; CHECK-NEXT: br label %[[OUTER_HEADER_SPLIT_SPLIT_US:.*]]
4170 ;
4171 ; CHECK: [[OUTER_HEADER_SPLIT_SPLIT_US]]:
4172 ; CHECK-NEXT: br label %[[INNER_HEADER_US]]
4173 ;
4174 ; CHECK: [[INNER_LOOPEXIT2_US]]:
4175 ; CHECK-NEXT: br label %[[OUTER_LATCH_US]]
4176 ;
4177 ; CHECK: [[EXIT_SPLIT_US]]:
4178 ; CHECK-NEXT: br label %exit
4180 inner.latch:
4181 %phi = phi i32 [ %a, %inner.body1 ], [ %b, %inner.body2 ]
4182 ; Make 10 junk calls here to ensure we're over the "50" cost threshold of
4183 ; non-trivial unswitching for this inner switch.
4184 call void @sink1(i32 0)
4185 call void @sink1(i32 0)
4186 call void @sink1(i32 0)
4187 call void @sink1(i32 0)
4188 call void @sink1(i32 0)
4189 call void @sink1(i32 0)
4190 call void @sink1(i32 0)
4191 call void @sink1(i32 0)
4192 call void @sink1(i32 0)
4193 call void @sink1(i32 0)
4194 call void @sink1(i32 %phi)
4195 %inner.cond = call i1 @cond()
4196 br i1 %inner.cond, label %inner.header, label %inner.loopexit2
4198 inner.loopexit1:
4199 br label %outer.latch
4200 ; The unswitched `loopexit1` path.
4201 ;
4202 ; CHECK: [[ENTRY_SPLIT]]:
4203 ; CHECK-NEXT: br label %[[OUTER_HEADER:.*]]
4204 ;
4205 ; CHECK: outer.header:
4206 ; CHECK-NEXT: br label %inner.loopexit1
4207 ;
4208 ; CHECK: inner.loopexit1:
4209 ; CHECK-NEXT: br label %outer.latch
4210 ;
4211 ; CHECK: outer.latch:
4212 ; CHECK-NEXT: %outer.cond = call i1 @cond()
4213 ; CHECK-NEXT: br i1 %outer.cond, label %outer.header, label %[[EXIT_SPLIT:.*]]
4214 ;
4215 ; CHECK: [[EXIT_SPLIT]]:
4216 ; CHECK-NEXT: br label %exit
4218 inner.loopexit2:
4219 br label %outer.latch
4221 outer.latch:
4222 %outer.cond = call i1 @cond()
4223 br i1 %outer.cond, label %outer.header, label %exit
4225 exit:
4226 ret void
4227 ; CHECK: exit:
4228 ; CHECK-NEXT: ret void
4229 }
4231 ; Non-trivial partial loop unswitching of multiple invariant inputs to an `and`
4232 ; chain (select version).
4233 define i32 @test32(ptr %ptr1, ptr %ptr2, ptr %ptr3, i1 %cond1, i1 %cond2) {
4234 ; CHECK-LABEL: @test32(
4235 entry:
4236 br label %loop_begin
4237 ; CHECK-NEXT: entry:
4238 ; CHECK-NEXT: [[C2_FR:%.+]] = freeze i1 %cond2
4239 ; CHECK-NEXT: [[C1_FR:%.+]] = freeze i1 %cond1
4240 ; CHECK-NEXT: %[[INV_AND:.*]] = and i1 [[C2_FR]], [[C1_FR]]
4241 ; CHECK-NEXT: br i1 %[[INV_AND]], label %entry.split, label %entry.split.us
4243 loop_begin:
4244 %v1 = load i1, ptr %ptr1
4245 %v2 = load i1, ptr %ptr2
4246 %cond_and1 = select i1 %v1, i1 %cond1, i1 false
4247 %cond_and2 = select i1 %cond_and1, i1 %cond2, i1 false
4248 br i1 %cond_and2, label %loop_a, label %loop_b
4249 ; The 'loop_b' unswitched loop.
4250 ;
4251 ; CHECK: entry.split.us:
4252 ; CHECK-NEXT: br label %loop_begin.us
4253 ;
4254 ; CHECK: loop_begin.us:
4255 ; CHECK-NEXT: %[[V2_US]] = load i1, ptr %ptr2, align 1
4256 ; CHECK-NEXT: br label %loop_b.us
4257 ;
4258 ; CHECK: loop_b.us:
4259 ; CHECK-NEXT: call i32 @b()
4260 ; CHECK-NEXT: br label %latch.us
4261 ;
4262 ; CHECK: latch.us:
4263 ; CHECK-NEXT: %[[V3_US:.*]] = load i1, ptr %ptr3, align 1
4264 ; CHECK-NEXT: br i1 %[[V3_US]], label %loop_begin.us, label %loop_exit.split.us
4265 ;
4266 ; CHECK: loop_exit.split.us:
4267 ; CHECK-NEXT: br label %loop_exit
4269 ; The original loop.
4270 ;
4271 ; CHECK: entry.split:
4272 ; CHECK-NEXT: br label %loop_begin
4273 ;
4274 ; CHECK: loop_begin:
4275 ; CHECK-NEXT: %[[V1:.*]] = load i1, ptr %ptr1
4276 ; CHECK-NEXT: %[[V2:.*]] = load i1, ptr %ptr2
4277 ; CHECK-NEXT: %[[AND1:.*]] = select i1 %[[V1]], i1 true, i1 false
4278 ; CHECK-NEXT: %[[AND2:.*]] = select i1 %[[AND1]], i1 true, i1 false
4279 ; CHECK-NEXT: br i1 %[[AND2]], label %loop_a, label %loop_b
4281 loop_a:
4282 call i32 @a()
4283 br label %latch
4284 ; CHECK: loop_a:
4285 ; CHECK-NEXT: call i32 @a()
4286 ; CHECK-NEXT: br label %latch
4288 loop_b:
4289 call i32 @b()
4290 br label %latch
4291 ; CHECK: loop_b:
4292 ; CHECK-NEXT: call i32 @b()
4293 ; CHECK-NEXT: br label %latch
4295 latch:
4296 %v3 = load i1, ptr %ptr3
4297 br i1 %v3, label %loop_begin, label %loop_exit
4298 ; CHECK: latch:
4299 ; CHECK-NEXT: %[[V3:.*]] = load i1, ptr %ptr3, align 1
4300 ; CHECK-NEXT: br i1 %[[V3]], label %loop_begin, label %loop_exit.split
4302 loop_exit:
4303 ret i32 0
4304 ; CHECK: loop_exit.split:
4305 ; CHECK-NEXT: br label %loop_exit
4306 ;
4307 ; CHECK: loop_exit:
4308 ; CHECK-NEXT: ret
4309 }
4311 ; Non-trivial partial loop unswitching of multiple invariant inputs to an `or`
4312 ; chain (select version).
4313 define i32 @test33(ptr %ptr1, ptr %ptr2, ptr %ptr3, i1 %cond1, i1 %cond2) {
4314 ; CHECK-LABEL: @test33(
4315 entry:
4316 br label %loop_begin
4317 ; CHECK-NEXT: entry:
4318 ; CHECK-NEXT: [[C2_FR:%.+]] = freeze i1 %cond2
4319 ; CHECK-NEXT: [[C1_FR:%.+]] = freeze i1 %cond1
4320 ; CHECK-NEXT: %[[INV_OR:.*]] = or i1 [[C2_FR]], [[C1_FR]]
4321 ; CHECK-NEXT: br i1 %[[INV_OR]], label %entry.split.us, label %entry.split
4323 loop_begin:
4324 %v1 = load i1, ptr %ptr1
4325 %v2 = load i1, ptr %ptr2
4326 %cond_and1 = select i1 %v1, i1 true, i1 %cond1
4327 %cond_and2 = select i1 %cond_and1, i1 true, i1 %cond2
4328 br i1 %cond_and2, label %loop_b, label %loop_a
4329 ; The 'loop_b' unswitched loop.
4330 ;
4331 ; CHECK: entry.split.us:
4332 ; CHECK-NEXT: br label %loop_begin.us
4333 ;
4334 ; CHECK: loop_begin.us:
4335 ; CHECK-NEXT: %[[V2_US]] = load i1, ptr %ptr2, align 1
4336 ; CHECK-NEXT: br label %loop_b.us
4337 ;
4338 ; CHECK: loop_b.us:
4339 ; CHECK-NEXT: call i32 @b()
4340 ; CHECK-NEXT: br label %latch.us
4341 ;
4342 ; CHECK: latch.us:
4343 ; CHECK-NEXT: %[[V3_US:.*]] = load i1, ptr %ptr3, align 1
4344 ; CHECK-NEXT: br i1 %[[V3_US]], label %loop_begin.us, label %loop_exit.split.us
4345 ;
4346 ; CHECK: loop_exit.split.us:
4347 ; CHECK-NEXT: br label %loop_exit
4349 ; The original loop.
4350 ;
4351 ; CHECK: entry.split:
4352 ; CHECK-NEXT: br label %loop_begin
4353 ;
4354 ; CHECK: loop_begin:
4355 ; CHECK-NEXT: %[[V1:.*]] = load i1, ptr %ptr1
4356 ; CHECK-NEXT: %[[V2:.*]] = load i1, ptr %ptr2
4357 ; CHECK-NEXT: %[[AND1:.*]] = select i1 %[[V1]], i1 true, i1 false
4358 ; CHECK-NEXT: %[[AND2:.*]] = select i1 %[[AND1]], i1 true, i1 false
4359 ; CHECK-NEXT: br i1 %[[AND2]], label %loop_b, label %loop_a
4361 loop_a:
4362 call i32 @a()
4363 br label %latch
4364 ; CHECK: loop_a:
4365 ; CHECK-NEXT: call i32 @a()
4366 ; CHECK-NEXT: br label %latch
4368 loop_b:
4369 call i32 @b()
4370 br label %latch
4371 ; CHECK: loop_b:
4372 ; CHECK-NEXT: call i32 @b()
4373 ; CHECK-NEXT: br label %latch
4375 latch:
4376 %v3 = load i1, ptr %ptr3
4377 br i1 %v3, label %loop_begin, label %loop_exit
4378 ; CHECK: latch:
4379 ; CHECK-NEXT: %[[V3:.*]] = load i1, ptr %ptr3, align 1
4380 ; CHECK-NEXT: br i1 %[[V3]], label %loop_begin, label %loop_exit.split
4382 loop_exit:
4383 ret i32 0
4384 ; CHECK: loop_exit.split:
4385 ; CHECK-NEXT: br label %loop_exit
4386 ;
4387 ; CHECK: loop_exit:
4388 ; CHECK-NEXT: ret
4389 }