1 ; RUN: llc < %s -asm-verbose=false -disable-block-placement -verify-machineinstrs | FileCheck %s
2 ; RUN: llc < %s -asm-verbose=false -verify-machineinstrs | FileCheck -check-prefix=OPT %s
4 ; Test the CFG stackifier pass.
6 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
7 target triple = "wasm32-unknown-unknown"
9 declare void @something()
11 ; Test that loops are made contiguous, even in the presence of split backedges.
17 ; CHECK-NEXT: i32.ge_s
33 define void @test0(i32 %n) {
38 %i = phi i32 [ 0, %entry ], [ %i.next, %back ]
39 %i.next = add i32 %i, 1
41 %c = icmp slt i32 %i.next, %n
42 br i1 %c, label %back, label %exit
48 call void @something()
52 ; Same as test0, but the branch condition is reversed.
58 ; CHECK-NEXT: i32.ge_s
74 define void @test1(i32 %n) {
79 %i = phi i32 [ 0, %entry ], [ %i.next, %back ]
80 %i.next = add i32 %i, 1
82 %c = icmp sge i32 %i.next, %n
83 br i1 %c, label %exit, label %back
89 call void @something()
93 ; Test that a simple loop is handled as expected.
98 ; CHECK: br_if {{[^,]*}}, 0{{$}}
100 ; CHECK: br_if ${{[0-9]+}}, 0{{$}}
106 ; OPT: br_if {{[^,]*}}, 0{{$}}
108 ; OPT: br_if ${{[0-9]+}}, 0{{$}}
111 define void @test2(double* nocapture %p, i32 %n) {
113 %cmp.4 = icmp sgt i32 %n, 0
114 br i1 %cmp.4, label %for.body.preheader, label %for.end
120 %i.05 = phi i32 [ %inc, %for.body ], [ 0, %for.body.preheader ]
121 %arrayidx = getelementptr inbounds double, double* %p, i32 %i.05
122 %0 = load double, double* %arrayidx, align 8
123 %mul = fmul double %0, 3.200000e+00
124 store double %mul, double* %arrayidx, align 8
125 %inc = add nuw nsw i32 %i.05, 1
126 %exitcond = icmp eq i32 %inc, %n
127 br i1 %exitcond, label %for.end.loopexit, label %for.body
136 ; CHECK-LABEL: doublediamond:
138 ; CHECK-NEXT: block{{$}}
139 ; CHECK: br_if ${{[^,]*}}, 0{{$}}
142 ; CHECK-NEXT: end_block{{$}}
144 ; CHECK: br_if ${{[^,]*}}, 0{{$}}
147 ; CHECK-NEXT: end_block{{$}}
149 ; CHECK-NEXT: end_block{{$}}
150 ; CHECK: return ${{[0-9]+}}{{$}}
151 ; OPT-LABEL: doublediamond:
153 ; OPT-NEXT: block{{$}}
154 ; OPT: br_if ${{[^,]*}}, 0{{$}}
156 ; OPT: br_if ${{[^,]*}}, 0{{$}}
160 ; OPT: return ${{[0-9]+}}{{$}}
161 define i32 @doublediamond(i32 %a, i32 %b, i32* %p) {
163 %c = icmp eq i32 %a, 0
164 %d = icmp eq i32 %b, 0
165 store volatile i32 0, i32* %p
166 br i1 %c, label %true, label %false
168 store volatile i32 1, i32* %p
171 store volatile i32 2, i32* %p
172 br i1 %d, label %ft, label %ff
174 store volatile i32 3, i32* %p
177 store volatile i32 4, i32* %p
180 store volatile i32 5, i32* %p
184 ; CHECK-LABEL: triangle:
186 ; CHECK: br_if $1, 0{{$}}
188 ; CHECK: return ${{[0-9]+}}{{$}}
189 ; OPT-LABEL: triangle:
191 ; OPT: br_if $1, 0{{$}}
193 ; OPT: return ${{[0-9]+}}{{$}}
194 define i32 @triangle(i32* %p, i32 %a) {
196 %c = icmp eq i32 %a, 0
197 store volatile i32 0, i32* %p
198 br i1 %c, label %true, label %exit
200 store volatile i32 1, i32* %p
203 store volatile i32 2, i32* %p
207 ; CHECK-LABEL: diamond:
210 ; CHECK: br_if $1, 0{{$}}
214 ; CHECK: return ${{[0-9]+}}{{$}}
215 ; OPT-LABEL: diamond:
218 ; OPT: br_if {{[^,]*}}, 0{{$}}
222 ; OPT: return ${{[0-9]+}}{{$}}
223 define i32 @diamond(i32* %p, i32 %a) {
225 %c = icmp eq i32 %a, 0
226 store volatile i32 0, i32* %p
227 br i1 %c, label %true, label %false
229 store volatile i32 1, i32* %p
232 store volatile i32 2, i32* %p
235 store volatile i32 3, i32* %p
239 ; CHECK-LABEL: single_block:
241 ; CHECK: return $pop{{[0-9]+}}{{$}}
242 ; OPT-LABEL: single_block:
244 ; OPT: return $pop{{[0-9]+}}{{$}}
245 define i32 @single_block(i32* %p) {
247 store volatile i32 0, i32* %p
251 ; CHECK-LABEL: minimal_loop:
254 ; CHECK: i32.store $discard=, 0($0), $pop{{[0-9]+}}{{$}}
257 ; OPT-LABEL: minimal_loop:
260 ; OPT: i32.store $discard=, 0($0), $pop{{[0-9]+}}{{$}}
263 define i32 @minimal_loop(i32* %p) {
265 store volatile i32 0, i32* %p
268 store volatile i32 1, i32* %p
272 ; CHECK-LABEL: simple_loop:
276 ; CHECK: br_if $pop{{[0-9]+}}, 0{{$}}
277 ; CHECK-NEXT: end_loop{{$}}
278 ; CHECK: return ${{[0-9]+}}{{$}}
279 ; OPT-LABEL: simple_loop:
283 ; OPT: br_if {{[^,]*}}, 0{{$}}
284 ; OPT-NEXT: end_loop{{$}}
285 ; OPT: return ${{[0-9]+}}{{$}}
286 define i32 @simple_loop(i32* %p, i32 %a) {
288 %c = icmp eq i32 %a, 0
289 store volatile i32 0, i32* %p
292 store volatile i32 1, i32* %p
293 br i1 %c, label %loop, label %exit
295 store volatile i32 2, i32* %p
299 ; CHECK-LABEL: doubletriangle:
301 ; CHECK: br_if $0, 0{{$}}
303 ; CHECK: br_if $1, 0{{$}}
306 ; CHECK: return ${{[0-9]+}}{{$}}
307 ; OPT-LABEL: doubletriangle:
309 ; OPT: br_if $0, 0{{$}}
311 ; OPT: br_if $1, 0{{$}}
314 ; OPT: return ${{[0-9]+}}{{$}}
315 define i32 @doubletriangle(i32 %a, i32 %b, i32* %p) {
317 %c = icmp eq i32 %a, 0
318 %d = icmp eq i32 %b, 0
319 store volatile i32 0, i32* %p
320 br i1 %c, label %true, label %exit
322 store volatile i32 2, i32* %p
323 br i1 %d, label %tt, label %tf
325 store volatile i32 3, i32* %p
328 store volatile i32 4, i32* %p
331 store volatile i32 5, i32* %p
335 ; CHECK-LABEL: ifelse_earlyexits:
338 ; CHECK: br_if $0, 0{{$}}
341 ; CHECK: br_if $1, 0{{$}}
343 ; CHECK: return ${{[0-9]+}}{{$}}
344 ; OPT-LABEL: ifelse_earlyexits:
347 ; OPT: br_if {{[^,]*}}, 0{{$}}
348 ; OPT: br_if $1, 1{{$}}
352 ; OPT: return ${{[0-9]+}}{{$}}
353 define i32 @ifelse_earlyexits(i32 %a, i32 %b, i32* %p) {
355 %c = icmp eq i32 %a, 0
356 %d = icmp eq i32 %b, 0
357 store volatile i32 0, i32* %p
358 br i1 %c, label %true, label %false
360 store volatile i32 1, i32* %p
363 store volatile i32 2, i32* %p
364 br i1 %d, label %ft, label %exit
366 store volatile i32 3, i32* %p
369 store volatile i32 4, i32* %p
373 ; CHECK-LABEL: doublediamond_in_a_loop:
378 ; CHECK: br_if $0, 0{{$}}
382 ; CHECK: br_if $1, 0{{$}}
388 ; CHECK-NEXT: end_loop{{$}}
389 ; OPT-LABEL: doublediamond_in_a_loop:
394 ; OPT: br_if {{[^,]*}}, 0{{$}}
396 ; OPT: br_if {{[^,]*}}, 0{{$}}
399 ; OPT-NEXT: end_block{{$}}
402 ; OPT-NEXT: end_block{{$}}
404 ; OPT-NEXT: end_block{{$}}
407 ; OPT-NEXT: end_loop{{$}}
408 define i32 @doublediamond_in_a_loop(i32 %a, i32 %b, i32* %p) {
412 %c = icmp eq i32 %a, 0
413 %d = icmp eq i32 %b, 0
414 store volatile i32 0, i32* %p
415 br i1 %c, label %true, label %false
417 store volatile i32 1, i32* %p
420 store volatile i32 2, i32* %p
421 br i1 %d, label %ft, label %ff
423 store volatile i32 3, i32* %p
426 store volatile i32 4, i32* %p
429 store volatile i32 5, i32* %p
433 ; Test that nested loops are handled.
435 ; CHECK-LABEL: test3:
438 ; CHECK-NEXT: .LBB{{[0-9]+}}_{{[0-9]+}}:
443 ; OPT-NEXT: .LBB{{[0-9]+}}_{{[0-9]+}}:
446 define void @test3(i32 %w) {
448 br i1 undef, label %outer.ph, label %exit
454 %tobool = icmp eq i32 undef, 0
455 br i1 %tobool, label %inner, label %unreachable
461 %c = icmp eq i32 undef, %w
462 br i1 %c, label %if.end, label %inner
472 ; Test switch lowering and block placement.
474 ; CHECK-LABEL: test4:
475 ; CHECK-NEXT: .param i32{{$}}
477 ; CHECK-NEXT: block{{$}}
478 ; CHECK-NEXT: block{{$}}
479 ; CHECK: br_if $pop{{[0-9]*}}, 0{{$}}
480 ; CHECK-NEXT: block{{$}}
481 ; CHECK: br_if $pop{{[0-9]*}}, 0{{$}}
482 ; CHECK: br_if $pop{{[0-9]*}}, 2{{$}}
483 ; CHECK-NEXT: .LBB13_3:
484 ; CHECK-NEXT: end_block{{$}}
485 ; CHECK-NEXT: return{{$}}
486 ; CHECK-NEXT: .LBB13_4:
487 ; CHECK: br_if $pop{{[0-9]*}}, 1{{$}}
488 ; CHECK: br_if $pop{{[0-9]*}}, 0{{$}}
489 ; CHECK-NEXT: return{{$}}
490 ; CHECK-NEXT: .LBB13_7:
491 ; CHECK-NEXT: end_block{{$}}
492 ; CHECK-NEXT: return{{$}}
493 ; CHECK-NEXT: .LBB13_8:
494 ; CHECK-NEXT: end_block{{$}}
495 ; CHECK-NEXT: return{{$}}
497 ; OPT-NEXT: .param i32{{$}}
499 ; OPT-NEXT: block{{$}}
500 ; OPT-NEXT: block{{$}}
501 ; OPT: br_if $pop{{[0-9]*}}, 0{{$}}
502 ; OPT-NEXT: block{{$}}
503 ; OPT: br_if $pop{{[0-9]*}}, 0{{$}}
504 ; OPT: br_if $pop{{[0-9]*}}, 2{{$}}
505 ; OPT-NEXT: .LBB13_3:
506 ; OPT-NEXT: end_block{{$}}
507 ; OPT-NEXT: return{{$}}
508 ; OPT-NEXT: .LBB13_4:
509 ; OPT: br_if $pop{{[0-9]*}}, 1{{$}}
510 ; OPT: br_if $pop{{[0-9]*}}, 0{{$}}
511 ; OPT-NEXT: return{{$}}
512 ; OPT-NEXT: .LBB13_7:
513 ; OPT-NEXT: end_block{{$}}
514 ; OPT-NEXT: return{{$}}
515 ; OPT-NEXT: .LBB13_8:
516 ; OPT-NEXT: end_block{{$}}
517 ; OPT-NEXT: return{{$}}
518 define void @test4(i32 %t) {
520 switch i32 %t, label %default [
540 ; Test a case where the BLOCK needs to be placed before the LOOP in the
543 ; CHECK-LABEL: test5:
545 ; CHECK-NEXT: block{{$}}
546 ; CHECK-NEXT: loop{{$}}
547 ; CHECK: br_if {{[^,]*}}, 2{{$}}
548 ; CHECK: br_if {{[^,]*}}, 0{{$}}
549 ; CHECK-NEXT: end_loop{{$}}
551 ; CHECK-NEXT: .LBB14_4:
555 ; OPT-NEXT: block{{$}}
556 ; OPT-NEXT: loop{{$}}
557 ; OPT: br_if {{[^,]*}}, 2{{$}}
558 ; OPT: br_if {{[^,]*}}, 0{{$}}
559 ; OPT-NEXT: end_loop{{$}}
561 ; OPT-NEXT: .LBB14_4:
563 define void @test5(i1 %p, i1 %q) {
568 store volatile i32 0, i32* null
569 br i1 %p, label %more, label %alt
572 store volatile i32 1, i32* null
573 br i1 %q, label %header, label %return
576 store volatile i32 2, i32* null
580 store volatile i32 3, i32* null
584 ; Test an interesting case of a loop with multiple exits, which
585 ; aren't to layout successors of the loop, and one of which is to a successors
586 ; which has another predecessor.
588 ; CHECK-LABEL: test6:
590 ; CHECK-NEXT: block{{$}}
591 ; CHECK-NEXT: block{{$}}
592 ; CHECK-NEXT: loop{{$}}
594 ; CHECK: br_if {{[^,]*}}, 3{{$}}
596 ; CHECK: br_if {{[^,]*}}, 2{{$}}
598 ; CHECK: br_if {{[^,]*}}, 0{{$}}
599 ; CHECK-NEXT: end_loop{{$}}
602 ; CHECK-NEXT: .LBB15_5:
603 ; CHECK-NEXT: end_block{{$}}
606 ; CHECK-NEXT: end_block{{$}}
611 ; OPT-NEXT: block{{$}}
612 ; OPT-NEXT: block{{$}}
613 ; OPT-NEXT: loop{{$}}
615 ; OPT: br_if {{[^,]*}}, 3{{$}}
617 ; OPT: br_if {{[^,]*}}, 2{{$}}
619 ; OPT: br_if {{[^,]*}}, 0{{$}}
620 ; OPT-NEXT: end_loop{{$}}
623 ; OPT-NEXT: .LBB15_5:
624 ; OPT-NEXT: end_block{{$}}
627 ; OPT-NEXT: end_block{{$}}
630 define void @test6(i1 %p, i1 %q) {
635 store volatile i32 0, i32* null
636 br i1 %p, label %more, label %second
639 store volatile i32 1, i32* null
640 br i1 %q, label %evenmore, label %first
643 store volatile i32 1, i32* null
644 br i1 %q, label %header, label %return
647 store volatile i32 2, i32* null
651 store volatile i32 3, i32* null
655 store volatile i32 4, i32* null
659 ; Test a case where there are multiple backedges and multiple loop exits
660 ; that end in unreachable.
662 ; CHECK-LABEL: test7:
664 ; CHECK-NEXT: loop{{$}}
667 ; CHECK: br_if {{[^,]*}}, 0{{$}}
669 ; CHECK: br_if {{[^,]*}}, 1{{$}}
672 ; CHECK-NEXT: .LBB16_4:
673 ; CHECK-NEXT: end_block{{$}}
675 ; CHECK: br_if {{[^,]*}}, 0{{$}}
676 ; CHECK-NEXT: end_loop{{$}}
681 ; OPT-NEXT: loop{{$}}
685 ; OPT: br_if {{[^,]*}}, 0{{$}}
687 ; OPT: br_if {{[^,]*}}, 1{{$}}
690 ; OPT-NEXT: .LBB16_4:
691 ; OPT-NEXT: end_block{{$}}
693 ; OPT: br_if {{[^,]*}}, 0{{$}}
694 ; OPT-NEXT: end_loop{{$}}
697 define void @test7(i1 %tobool2, i1 %tobool9) {
699 store volatile i32 0, i32* null
703 store volatile i32 1, i32* null
704 br i1 %tobool2, label %l1, label %l0
707 store volatile i32 2, i32* null
708 br i1 %tobool9, label %loop, label %u0
711 store volatile i32 3, i32* null
712 br i1 %tobool9, label %loop, label %u1
715 store volatile i32 4, i32* null
719 store volatile i32 5, i32* null
723 ; Test an interesting case using nested loops and switches.
725 ; CHECK-LABEL: test8:
727 ; CHECK-NEXT: loop{{$}}
728 ; CHECK-NEXT: block{{$}}
730 ; CHECK: br_if {{[^,]*}}, 0{{$}}
732 ; CHECK: br_if {{[^,]*}}, 1{{$}}
733 ; CHECK-NEXT: .LBB17_3:
734 ; CHECK-NEXT: end_block{{$}}
735 ; CHECK-NEXT: loop{{$}}
736 ; CHECK-NEXT: br_if {{[^,]*}}, 0{{$}}
737 ; CHECK-NEXT: br 2{{$}}
738 ; CHECK-NEXT: .LBB17_4:
741 ; OPT-NEXT: loop{{$}}
742 ; OPT-NEXT: block{{$}}
744 ; OPT: br_if {{[^,]*}}, 0{{$}}
746 ; OPT: br_if {{[^,]*}}, 1{{$}}
747 ; OPT-NEXT: .LBB17_3:
748 ; OPT-NEXT: end_block{{$}}
749 ; OPT-NEXT: loop{{$}}
750 ; OPT-NEXT: br_if {{[^,]*}}, 0{{$}}
751 ; OPT-NEXT: br 2{{$}}
752 ; OPT-NEXT: .LBB17_4:
753 define i32 @test8() {
758 br i1 undef, label %bb2, label %bb3
761 switch i8 undef, label %bb1 [
766 switch i8 undef, label %bb1 [
771 ; Test an interesting case using nested loops that share a bottom block.
773 ; CHECK-LABEL: test9:
775 ; CHECK-NEXT: loop{{$}}
777 ; CHECK: br_if {{[^,]*}}, 1{{$}}
778 ; CHECK-NEXT: .LBB18_2:
779 ; CHECK-NEXT: loop{{$}}
783 ; CHECK: br_if {{[^,]*}}, 0{{$}}
785 ; CHECK: br_if {{[^,]*}}, 1{{$}}
786 ; CHECK-NEXT: br 3{{$}}
787 ; CHECK-NEXT: .LBB18_4:
788 ; CHECK-NEXT: end_block{{$}}
790 ; CHECK: br_if {{[^,]*}}, 0{{$}}
791 ; CHECK-NEXT: br 2{{$}}
792 ; CHECK-NEXT: .LBB18_5:
797 ; OPT-NEXT: loop{{$}}
799 ; OPT: br_if {{[^,]*}}, 1{{$}}
800 ; OPT-NEXT: .LBB18_2:
801 ; OPT-NEXT: loop{{$}}
805 ; OPT: br_if {{[^,]*}}, 0{{$}}
807 ; OPT: br_if {{[^,]*}}, 1{{$}}
808 ; OPT-NEXT: br 3{{$}}
809 ; OPT-NEXT: .LBB18_4:
810 ; OPT-NEXT: end_block{{$}}
812 ; OPT: br_if {{[^,]*}}, 0{{$}}
813 ; OPT-NEXT: br 2{{$}}
814 ; OPT-NEXT: .LBB18_5:
818 define void @test9() {
820 store volatile i32 0, i32* null
824 store volatile i32 1, i32* null
825 %call4 = call i1 @a()
826 br i1 %call4, label %header2, label %end
829 store volatile i32 2, i32* null
831 br i1 %call, label %if.then, label %if.else
834 store volatile i32 3, i32* null
835 %call3 = call i1 @a()
836 br i1 %call3, label %header2, label %header
839 store volatile i32 4, i32* null
840 %call2 = call i1 @a()
841 br i1 %call2, label %header2, label %header
844 store volatile i32 5, i32* null
848 ; Test an interesting case involving nested loops sharing a loop bottom,
849 ; and loop exits to a block with unreachable.
851 ; CHECK-LABEL: test10:
853 ; CHECK-NEXT: loop{{$}}
855 ; CHECK: br_if {{[^,]*}}, 0{{$}}
856 ; CHECK-NEXT: .LBB19_2:
857 ; CHECK-NEXT: block{{$}}
858 ; CHECK-NEXT: loop{{$}}
861 ; CHECK-NEXT: loop{{$}}
863 ; CHECK: br_if {{[^,]*}}, 5{{$}}
865 ; CHECK: tableswitch {{[^,]*}}, 0, 0, 1, 5, 2, 4{{$}}
866 ; CHECK-NEXT: .LBB19_5:
867 ; CHECK-NEXT: end_loop{{$}}
868 ; CHECK-NEXT: end_loop{{$}}
869 ; CHECK-NEXT: return{{$}}
870 ; CHECK-NEXT: .LBB19_6:
871 ; CHECK-NEXT: end_block{{$}}
874 ; CHECK-NEXT: .LBB19_7:
877 ; OPT-NEXT: loop{{$}}
879 ; OPT: br_if {{[^,]*}}, 0{{$}}
880 ; OPT-NEXT: .LBB19_2:
881 ; OPT-NEXT: block{{$}}
882 ; OPT-NEXT: loop{{$}}
885 ; OPT-NEXT: loop{{$}}
887 ; OPT: br_if {{[^,]*}}, 5{{$}}
889 ; OPT: tableswitch {{[^,]*}}, 0, 0, 1, 5, 2, 4{{$}}
890 ; OPT-NEXT: .LBB19_5:
891 ; OPT-NEXT: end_loop{{$}}
892 ; OPT-NEXT: end_loop{{$}}
893 ; OPT-NEXT: return{{$}}
894 ; OPT-NEXT: .LBB19_6:
895 ; OPT-NEXT: end_block{{$}}
898 ; OPT-NEXT: .LBB19_7:
899 define void @test10() {
904 %tmp = phi i32 [ 2, %bb0 ], [ 3, %bb3 ]
905 %tmp3 = phi i32 [ undef, %bb0 ], [ %tmp11, %bb3 ]
906 %tmp4 = icmp eq i32 %tmp3, 0
907 br i1 %tmp4, label %bb4, label %bb2
913 %tmp11 = phi i32 [ 1, %bb5 ], [ 0, %bb2 ]
917 %tmp6 = phi i32 [ %tmp9, %bb5 ], [ 4, %bb1 ]
918 %tmp7 = phi i32 [ %tmp6, %bb5 ], [ %tmp, %bb1 ]
922 %tmp9 = phi i32 [ %tmp6, %bb5 ], [ %tmp7, %bb4 ]
923 switch i32 %tmp9, label %bb2 [
934 ; Test a CFG DAG with interesting merging.
936 ; CHECK-LABEL: test11:
938 ; CHECK-NEXT: block{{$}}
939 ; CHECK-NEXT: block{{$}}
940 ; CHECK-NEXT: block{{$}}
941 ; CHECK-NEXT: br_if {{[^,]*}}, 0{{$}}
942 ; CHECK-NEXT: block{{$}}
944 ; CHECK: br_if {{[^,]*}}, 0{{$}}
946 ; CHECK: br_if {{[^,]*}}, 2{{$}}
947 ; CHECK-NEXT: .LBB20_3:
948 ; CHECK-NEXT: end_block{{$}}
951 ; CHECK-NEXT: .LBB20_4:
952 ; CHECK-NEXT: end_block{{$}}
954 ; CHECK: br_if {{[^,]*}}, 2{{$}}
956 ; CHECK: br_if {{[^,]*}}, 1{{$}}
957 ; CHECK-NEXT: .LBB20_6:
958 ; CHECK-NEXT: end_block{{$}}
961 ; CHECK-NEXT: .LBB20_7:
962 ; CHECK-NEXT: end_block{{$}}
965 ; CHECK-NEXT: .LBB20_8:
966 ; CHECK-NEXT: end_block{{$}}
971 ; OPT-NEXT: block{{$}}
972 ; OPT-NEXT: br_if $0, 0{{$}}
973 ; OPT-NEXT: block{{$}}
975 ; OPT: br_if $0, 0{{$}}
977 ; OPT: br_if $0, 2{{$}}
978 ; OPT-NEXT: .LBB20_3:
979 ; OPT-NEXT: end_block{{$}}
982 ; OPT-NEXT: .LBB20_4:
983 ; OPT-NEXT: end_block{{$}}
987 ; OPT: br_if $pop9, 0{{$}}
990 ; OPT-NEXT: .LBB20_6:
991 ; OPT-NEXT: end_block{{$}}
993 ; OPT: br_if $0, 0{{$}}
996 ; OPT-NEXT: .LBB20_8:
997 ; OPT-NEXT: end_block{{$}}
1000 define void @test11() {
1002 store volatile i32 0, i32* null
1003 br i1 undef, label %bb1, label %bb4
1005 store volatile i32 1, i32* null
1006 br i1 undef, label %bb3, label %bb2
1008 store volatile i32 2, i32* null
1009 br i1 undef, label %bb3, label %bb7
1011 store volatile i32 3, i32* null
1014 store volatile i32 4, i32* null
1015 br i1 undef, label %bb8, label %bb5
1017 store volatile i32 5, i32* null
1018 br i1 undef, label %bb6, label %bb7
1020 store volatile i32 6, i32* null
1023 store volatile i32 7, i32* null
1026 store volatile i32 8, i32* null
1030 ; CHECK-LABEL: test12:
1032 ; CHECK-NEXT: loop{{$}}
1035 ; CHECK-NEXT: block{{$}}
1036 ; CHECK-NEXT: block{{$}}
1037 ; CHECK: br_if {{[^,]*}}, 0{{$}}
1039 ; CHECK: br_if {{[^,]*}}, 2{{$}}
1041 ; CHECK: br_if {{[^,]*}}, 2{{$}}
1042 ; CHECK-NEXT: br 1{{$}}
1043 ; CHECK-NEXT: .LBB21_4:
1044 ; CHECK-NEXT: end_block{{$}}
1046 ; CHECK: br_if {{[^,]*}}, 1{{$}}
1048 ; CHECK: br_if {{[^,]*}}, 1{{$}}
1049 ; CHECK-NEXT: .LBB21_6:
1050 ; CHECK-NEXT: end_block{{$}}
1051 ; CHECK-NEXT: return{{$}}
1052 ; CHECK-NEXT: .LBB21_7:
1053 ; CHECK-NEXT: end_block{{$}}
1056 ; CHECK-NEXT: .LBB21_8:
1057 ; OPT-LABEL: test12:
1059 ; OPT-NEXT: loop{{$}}
1062 ; OPT-NEXT: block{{$}}
1063 ; OPT-NEXT: block{{$}}
1064 ; OPT: br_if {{[^,]*}}, 0{{$}}
1066 ; OPT: br_if {{[^,]*}}, 2{{$}}
1068 ; OPT: br_if {{[^,]*}}, 2{{$}}
1069 ; OPT-NEXT: br 1{{$}}
1070 ; OPT-NEXT: .LBB21_4:
1071 ; OPT-NEXT: end_block{{$}}
1073 ; OPT: br_if {{[^,]*}}, 1{{$}}
1075 ; OPT: br_if {{[^,]*}}, 1{{$}}
1076 ; OPT-NEXT: .LBB21_6:
1077 ; OPT-NEXT: end_block{{$}}
1078 ; OPT-NEXT: return{{$}}
1079 ; OPT-NEXT: .LBB21_7:
1080 ; OPT-NEXT: end_block{{$}}
1083 ; OPT-NEXT: .LBB21_8:
1084 define void @test12(i8* %arg) {
1089 %tmp = phi i32 [ 0, %bb ], [ %tmp5, %bb4 ]
1090 %tmp2 = getelementptr i8, i8* %arg, i32 %tmp
1091 %tmp3 = load i8, i8* %tmp2
1092 switch i8 %tmp3, label %bb7 [
1100 %tmp5 = add i32 %tmp, 1
1107 ; A block can be "branched to" from another even if it is also reachable via
1108 ; fallthrough from the other. This would normally be optimized away, so use
1109 ; optnone to disable optimizations to test this case.
1111 ; CHECK-LABEL: test13:
1112 ; CHECK-NEXT: local i32{{$}}
1114 ; CHECK: br_if $pop4, 0{{$}}
1115 ; CHECK-NEXT: return{{$}}
1116 ; CHECK-NEXT: .LBB22_2:
1117 ; CHECK-NEXT: end_block{{$}}
1119 ; CHECK-NEXT: br_if $0, 0{{$}}
1121 ; CHECK-NEXT: end_block{{$}}
1123 ; CHECK: br_if $pop6, 0{{$}}
1124 ; CHECK-NEXT: end_block{{$}}
1125 ; CHECK-NEXT: unreachable{{$}}
1126 ; OPT-LABEL: test13:
1127 ; OPT-NEXT: local i32{{$}}
1129 ; OPT: br_if $pop4, 0{{$}}
1130 ; OPT-NEXT: return{{$}}
1131 ; OPT-NEXT: .LBB22_2:
1132 ; OPT-NEXT: end_block{{$}}
1134 ; OPT-NEXT: br_if $0, 0{{$}}
1136 ; OPT-NEXT: end_block{{$}}
1138 ; OPT: br_if $pop6, 0{{$}}
1139 ; OPT-NEXT: end_block{{$}}
1140 ; OPT-NEXT: unreachable{{$}}
1141 define void @test13() noinline optnone {
1143 br i1 undef, label %bb5, label %bb2
1147 br i1 undef, label %bb3, label %bb4
1151 %tmp = phi i1 [ false, %bb2 ], [ false, %bb3 ]
1152 br i1 %tmp, label %bb1, label %bb1
1157 ; Test a case with a single-block loop that has another loop
1158 ; as a successor. The end_loop for the first loop should go
1159 ; before the loop for the second.
1161 ; CHECK-LABEL: test14:
1162 ; CHECK-NEXT: local i32{{$}}
1163 ; CHECK-NEXT: i32.const $0=, 0{{$}}
1164 ; CHECK-NEXT: .LBB23_1:{{$}}
1165 ; CHECK-NEXT: loop{{$}}
1166 ; CHECK-NEXT: br_if $0, 0{{$}}
1167 ; CHECK-NEXT: .LBB23_2:{{$}}
1168 ; CHECK-NEXT: end_loop{{$}}
1169 ; CHECK-NEXT: loop{{$}}
1170 ; CHECK-NEXT: br_if $0, 0{{$}}
1171 ; CHECK-NEXT: end_loop{{$}}
1172 ; CHECK-NEXT: return{{$}}
1173 define void @test14() {
1178 %tmp = bitcast i1 undef to i1
1179 br i1 %tmp, label %bb3, label %bb1
1185 br i1 undef, label %bb7, label %bb48
1188 br i1 undef, label %bb12, label %bb12
1191 br i1 undef, label %bb17, label %bb17
1194 br i1 undef, label %bb22, label %bb22
1197 br i1 undef, label %bb27, label %bb27
1200 br i1 undef, label %bb30, label %bb30
1203 br i1 undef, label %bb35, label %bb35
1206 br i1 undef, label %bb38, label %bb38
1209 br i1 undef, label %bb48, label %bb48
1212 %tmp49 = bitcast i1 undef to i1
1213 br i1 %tmp49, label %bb3, label %bb50