1; RUN: llc < %s -asm-verbose=false -disable-block-placement | FileCheck %s
2; RUN: llc < %s -asm-verbose=false | FileCheck -check-prefix=OPT %s
3
4; Test the CFG stackifier pass.
5
6target datalayout = "e-p:32:32-i64:64-n32:64-S128"
7target triple = "wasm32-unknown-unknown"
8
9declare void @something()
10
11; Test that loops are made contiguous, even in the presence of split backedges.
12
13; CHECK-LABEL: test0:
14; CHECK: loop
15; CHECK: i32.add
16; CHECK-NOT: br
17; CHECK: br_if
18; CHECK-NOT: br
19; CHECK: call
20; CHECK: br BB0_1{{$}}
21; CHECK: return{{$}}
22; OPT-LABEL: test0:
23; OPT: loop
24; OPT: i32.add
25; OPT-NOT: br
26; OPT: br_if
27; OPT-NOT: br
28; OPT: call
29; OPT: br BB0_1{{$}}
30; OPT: return{{$}}
31define void @test0(i32 %n) {
32entry:
33  br label %header
34
35header:
36  %i = phi i32 [ 0, %entry ], [ %i.next, %back ]
37  %i.next = add i32 %i, 1
38
39  %c = icmp slt i32 %i.next, %n
40  br i1 %c, label %back, label %exit
41
42exit:
43  ret void
44
45back:
46  call void @something()
47  br label %header
48}
49
50; Same as test0, but the branch condition is reversed.
51
52; CHECK-LABEL: test1:
53; CHECK: loop
54; CHECK: i32.add
55; CHECK-NOT: br
56; CHECK: br_if
57; CHECK-NOT: br
58; CHECK: call
59; CHECK: br BB1_1{{$}}
60; CHECK: return{{$}}
61; OPT-LABEL: test1:
62; OPT: loop
63; OPT: i32.add
64; OPT-NOT: br
65; OPT: br_if
66; OPT-NOT: br
67; OPT: call
68; OPT: br BB1_1{{$}}
69; OPT: return{{$}}
70define void @test1(i32 %n) {
71entry:
72  br label %header
73
74header:
75  %i = phi i32 [ 0, %entry ], [ %i.next, %back ]
76  %i.next = add i32 %i, 1
77
78  %c = icmp sge i32 %i.next, %n
79  br i1 %c, label %exit, label %back
80
81exit:
82  ret void
83
84back:
85  call void @something()
86  br label %header
87}
88
89; Test that a simple loop is handled as expected.
90
91; CHECK-LABEL: test2:
92; CHECK: block BB2_2{{$}}
93; CHECK: br_if {{[^,]*}}, BB2_2{{$}}
94; CHECK: BB2_1:
95; CHECK: br_if ${{[0-9]+}}, BB2_1{{$}}
96; CHECK: BB2_2:
97; CHECK: return{{$}}
98; OPT-LABEL: test2:
99; OPT: block BB2_2{{$}}
100; OPT: br_if {{[^,]*}}, BB2_2{{$}}
101; OPT: BB2_1:
102; OPT: br_if ${{[0-9]+}}, BB2_1{{$}}
103; OPT: BB2_2:
104; OPT: return{{$}}
105define void @test2(double* nocapture %p, i32 %n) {
106entry:
107  %cmp.4 = icmp sgt i32 %n, 0
108  br i1 %cmp.4, label %for.body.preheader, label %for.end
109
110for.body.preheader:
111  br label %for.body
112
113for.body:
114  %i.05 = phi i32 [ %inc, %for.body ], [ 0, %for.body.preheader ]
115  %arrayidx = getelementptr inbounds double, double* %p, i32 %i.05
116  %0 = load double, double* %arrayidx, align 8
117  %mul = fmul double %0, 3.200000e+00
118  store double %mul, double* %arrayidx, align 8
119  %inc = add nuw nsw i32 %i.05, 1
120  %exitcond = icmp eq i32 %inc, %n
121  br i1 %exitcond, label %for.end.loopexit, label %for.body
122
123for.end.loopexit:
124  br label %for.end
125
126for.end:
127  ret void
128}
129
130; CHECK-LABEL: doublediamond:
131; CHECK: block BB3_5{{$}}
132; CHECK: block BB3_2{{$}}
133; CHECK: br_if $0, BB3_2{{$}}
134; CHECK: block BB3_4{{$}}
135; CHECK: br_if $1, BB3_4{{$}}
136; CHECK: br BB3_5{{$}}
137; CHECK: BB3_4:
138; CHECK: BB3_5:
139; CHECK: return ${{[0-9]+}}{{$}}
140; OPT-LABEL: doublediamond:
141; OPT: block BB3_5{{$}}
142; OPT: block BB3_4{{$}}
143; OPT: br_if {{[^,]*}}, BB3_4{{$}}
144; OPT: block BB3_3{{$}}
145; OPT: br_if {{[^,]*}}, BB3_3{{$}}
146; OPT: br BB3_5{{$}}
147; OPT: BB3_4:
148; OPT: BB3_5:
149; OPT: return ${{[0-9]+}}{{$}}
150define i32 @doublediamond(i32 %a, i32 %b, i32* %p) {
151entry:
152  %c = icmp eq i32 %a, 0
153  %d = icmp eq i32 %b, 0
154  store volatile i32 0, i32* %p
155  br i1 %c, label %true, label %false
156true:
157  store volatile i32 1, i32* %p
158  br label %exit
159false:
160  store volatile i32 2, i32* %p
161  br i1 %d, label %ft, label %ff
162ft:
163  store volatile i32 3, i32* %p
164  br label %exit
165ff:
166  store volatile i32 4, i32* %p
167  br label %exit
168exit:
169  store volatile i32 5, i32* %p
170  ret i32 0
171}
172
173; CHECK-LABEL: triangle:
174; CHECK: block BB4_2{{$}}
175; CHECK: br_if $1, BB4_2{{$}}
176; CHECK: BB4_2:
177; CHECK: return ${{[0-9]+}}{{$}}
178; OPT-LABEL: triangle:
179; OPT: block BB4_2{{$}}
180; OPT: br_if $1, BB4_2{{$}}
181; OPT: BB4_2:
182; OPT: return ${{[0-9]+}}{{$}}
183define i32 @triangle(i32* %p, i32 %a) {
184entry:
185  %c = icmp eq i32 %a, 0
186  store volatile i32 0, i32* %p
187  br i1 %c, label %true, label %exit
188true:
189  store volatile i32 1, i32* %p
190  br label %exit
191exit:
192  store volatile i32 2, i32* %p
193  ret i32 0
194}
195
196; CHECK-LABEL: diamond:
197; CHECK: block BB5_3{{$}}
198; CHECK: block BB5_2{{$}}
199; CHECK: br_if $1, BB5_2{{$}}
200; CHECK: br BB5_3{{$}}
201; CHECK: BB5_2:
202; CHECK: BB5_3:
203; CHECK: return ${{[0-9]+}}{{$}}
204; OPT-LABEL: diamond:
205; OPT: block BB5_3{{$}}
206; OPT: block BB5_2{{$}}
207; OPT: br_if {{[^,]*}}, BB5_2{{$}}
208; OPT: br BB5_3{{$}}
209; OPT: BB5_2:
210; OPT: BB5_3:
211; OPT: return ${{[0-9]+}}{{$}}
212define i32 @diamond(i32* %p, i32 %a) {
213entry:
214  %c = icmp eq i32 %a, 0
215  store volatile i32 0, i32* %p
216  br i1 %c, label %true, label %false
217true:
218  store volatile i32 1, i32* %p
219  br label %exit
220false:
221  store volatile i32 2, i32* %p
222  br label %exit
223exit:
224  store volatile i32 3, i32* %p
225  ret i32 0
226}
227
228; CHECK-LABEL: single_block:
229; CHECK-NOT: br
230; CHECK: return $pop{{[0-9]+}}{{$}}
231; OPT-LABEL: single_block:
232; OPT-NOT: br
233; OPT: return $pop{{[0-9]+}}{{$}}
234define i32 @single_block(i32* %p) {
235entry:
236  store volatile i32 0, i32* %p
237  ret i32 0
238}
239
240; CHECK-LABEL: minimal_loop:
241; CHECK-NOT: br
242; CHECK: BB7_1:
243; CHECK: i32.store $discard=, 0($0), $pop{{[0-9]+}}{{$}}
244; CHECK: br BB7_1{{$}}
245; CHECK: BB7_2:
246; OPT-LABEL: minimal_loop:
247; OPT-NOT: br
248; OPT: BB7_1:
249; OPT: i32.store $discard=, 0($0), $pop{{[0-9]+}}{{$}}
250; OPT: br BB7_1{{$}}
251; OPT: BB7_2:
252define i32 @minimal_loop(i32* %p) {
253entry:
254  store volatile i32 0, i32* %p
255  br label %loop
256loop:
257  store volatile i32 1, i32* %p
258  br label %loop
259}
260
261; CHECK-LABEL: simple_loop:
262; CHECK-NOT: br
263; CHECK: BB8_1:
264; CHECK: loop BB8_2{{$}}
265; CHECK: br_if $pop{{[0-9]+}}, BB8_1{{$}}
266; CHECK: BB8_2:
267; CHECK: return ${{[0-9]+}}{{$}}
268; OPT-LABEL: simple_loop:
269; OPT-NOT: br
270; OPT: BB8_1:
271; OPT: loop BB8_2{{$}}
272; OPT: br_if {{[^,]*}}, BB8_1{{$}}
273; OPT: BB8_2:
274; OPT: return ${{[0-9]+}}{{$}}
275define i32 @simple_loop(i32* %p, i32 %a) {
276entry:
277  %c = icmp eq i32 %a, 0
278  store volatile i32 0, i32* %p
279  br label %loop
280loop:
281  store volatile i32 1, i32* %p
282  br i1 %c, label %loop, label %exit
283exit:
284  store volatile i32 2, i32* %p
285  ret i32 0
286}
287
288; CHECK-LABEL: doubletriangle:
289; CHECK: block BB9_4{{$}}
290; CHECK: br_if $0, BB9_4{{$}}
291; CHECK: block BB9_3{{$}}
292; CHECK: br_if $1, BB9_3{{$}}
293; CHECK: BB9_3:
294; CHECK: BB9_4:
295; CHECK: return ${{[0-9]+}}{{$}}
296; OPT-LABEL: doubletriangle:
297; OPT: block BB9_4{{$}}
298; OPT: br_if $0, BB9_4{{$}}
299; OPT: block BB9_3{{$}}
300; OPT: br_if $1, BB9_3{{$}}
301; OPT: BB9_3:
302; OPT: BB9_4:
303; OPT: return ${{[0-9]+}}{{$}}
304define i32 @doubletriangle(i32 %a, i32 %b, i32* %p) {
305entry:
306  %c = icmp eq i32 %a, 0
307  %d = icmp eq i32 %b, 0
308  store volatile i32 0, i32* %p
309  br i1 %c, label %true, label %exit
310true:
311  store volatile i32 2, i32* %p
312  br i1 %d, label %tt, label %tf
313tt:
314  store volatile i32 3, i32* %p
315  br label %tf
316tf:
317  store volatile i32 4, i32* %p
318  br label %exit
319exit:
320  store volatile i32 5, i32* %p
321  ret i32 0
322}
323
324; CHECK-LABEL: ifelse_earlyexits:
325; CHECK: block BB10_4{{$}}
326; CHECK: block BB10_2{{$}}
327; CHECK: br_if $0, BB10_2{{$}}
328; CHECK: br BB10_4{{$}}
329; CHECK: BB10_2:
330; CHECK: br_if $1, BB10_4{{$}}
331; CHECK: BB10_4:
332; CHECK: return ${{[0-9]+}}{{$}}
333; OPT-LABEL: ifelse_earlyexits:
334; OPT: block BB10_4{{$}}
335; OPT: block BB10_3{{$}}
336; OPT: br_if {{[^,]*}}, BB10_3{{$}}
337; OPT: br_if $1, BB10_4{{$}}
338; OPT: br BB10_4{{$}}
339; OPT: BB10_3:
340; OPT: BB10_4:
341; OPT: return ${{[0-9]+}}{{$}}
342define i32 @ifelse_earlyexits(i32 %a, i32 %b, i32* %p) {
343entry:
344  %c = icmp eq i32 %a, 0
345  %d = icmp eq i32 %b, 0
346  store volatile i32 0, i32* %p
347  br i1 %c, label %true, label %false
348true:
349  store volatile i32 1, i32* %p
350  br label %exit
351false:
352  store volatile i32 2, i32* %p
353  br i1 %d, label %ft, label %exit
354ft:
355  store volatile i32 3, i32* %p
356  br label %exit
357exit:
358  store volatile i32 4, i32* %p
359  ret i32 0
360}
361
362; CHECK-LABEL: doublediamond_in_a_loop:
363; CHECK: BB11_1:
364; CHECK: loop            BB11_7{{$}}
365; CHECK: block           BB11_6{{$}}
366; CHECK: block           BB11_3{{$}}
367; CHECK: br_if           $0, BB11_3{{$}}
368; CHECK: br              BB11_6{{$}}
369; CHECK: BB11_3:
370; CHECK: block           BB11_5{{$}}
371; CHECK: br_if           $1, BB11_5{{$}}
372; CHECK: br              BB11_6{{$}}
373; CHECK: BB11_5:
374; CHECK: BB11_6:
375; CHECK: br              BB11_1{{$}}
376; CHECK: BB11_7:
377; OPT-LABEL: doublediamond_in_a_loop:
378; OPT: BB11_1:
379; OPT: loop            BB11_7{{$}}
380; OPT: block           BB11_6{{$}}
381; OPT: block           BB11_5{{$}}
382; OPT: br_if           {{[^,]*}}, BB11_5{{$}}
383; OPT: block           BB11_4{{$}}
384; OPT: br_if           {{[^,]*}}, BB11_4{{$}}
385; OPT: br              BB11_6{{$}}
386; OPT: BB11_4:
387; OPT: br              BB11_6{{$}}
388; OPT: BB11_5:
389; OPT: BB11_6:
390; OPT: br              BB11_1{{$}}
391; OPT: BB11_7:
392define i32 @doublediamond_in_a_loop(i32 %a, i32 %b, i32* %p) {
393entry:
394  br label %header
395header:
396  %c = icmp eq i32 %a, 0
397  %d = icmp eq i32 %b, 0
398  store volatile i32 0, i32* %p
399  br i1 %c, label %true, label %false
400true:
401  store volatile i32 1, i32* %p
402  br label %exit
403false:
404  store volatile i32 2, i32* %p
405  br i1 %d, label %ft, label %ff
406ft:
407  store volatile i32 3, i32* %p
408  br label %exit
409ff:
410  store volatile i32 4, i32* %p
411  br label %exit
412exit:
413  store volatile i32 5, i32* %p
414  br label %header
415}
416
417; Test that nested loops are handled.
418
419declare void @bar()
420
421define void @test3(i32 %w)  {
422entry:
423  br i1 undef, label %outer.ph, label %exit
424
425outer.ph:
426  br label %outer
427
428outer:
429  %tobool = icmp eq i32 undef, 0
430  br i1 %tobool, label %inner, label %unreachable
431
432unreachable:
433  unreachable
434
435inner:
436  %c = icmp eq i32 undef, %w
437  br i1 %c, label %if.end, label %inner
438
439exit:
440  ret void
441
442if.end:
443  call void @bar()
444  br label %outer
445}
446