1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
2; RUN: opt < %s -loop-deletion -S | FileCheck %s
3; RUN: opt < %s -passes='loop(loop-deletion)' -S | FileCheck %s
4
5; The idea is that we know that %is.positive is true on the 1st iteration,
6; it means that we can evaluate %merge.phi = %sub on the 1st iteration,
7; and therefore prove that %sum.next = %sum + %sub = %sum + %limit - %sum = %limit,
8; and predicate is false.
9
10; TODO: We can break the backedge here.
11define i32 @test_ne(i32 %limit) {
12; CHECK-LABEL: @test_ne(
13; CHECK-NEXT:  entry:
14; CHECK-NEXT:    [[LOOP_GUARD:%.*]] = icmp sgt i32 [[LIMIT:%.*]], 0
15; CHECK-NEXT:    br i1 [[LOOP_GUARD]], label [[LOOP_PREHEADER:%.*]], label [[FAILURE:%.*]]
16; CHECK:       loop.preheader:
17; CHECK-NEXT:    br label [[LOOP:%.*]]
18; CHECK:       loop:
19; CHECK-NEXT:    [[SUM:%.*]] = phi i32 [ [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ], [ 0, [[LOOP_PREHEADER]] ]
20; CHECK-NEXT:    [[SUB:%.*]] = sub i32 [[LIMIT]], [[SUM]]
21; CHECK-NEXT:    [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
22; CHECK-NEXT:    br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label [[IF_FALSE:%.*]]
23; CHECK:       if.false:
24; CHECK-NEXT:    br label [[BACKEDGE]]
25; CHECK:       backedge:
26; CHECK-NEXT:    [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [ [[SUB]], [[LOOP]] ]
27; CHECK-NEXT:    [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
28; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ne i32 [[SUM_NEXT]], [[LIMIT]]
29; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
30; CHECK:       done:
31; CHECK-NEXT:    [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]], [[BACKEDGE]] ]
32; CHECK-NEXT:    ret i32 [[SUM_NEXT_LCSSA]]
33; CHECK:       failure:
34; CHECK-NEXT:    unreachable
35;
36entry:
37  %loop_guard = icmp sgt i32 %limit, 0
38  br i1 %loop_guard, label %loop, label %failure
39
40loop:                                             ; preds = %backedge, %entry
41  %sum = phi i32 [ 0, %entry ], [ %sum.next, %backedge ]
42  %sub = sub i32 %limit, %sum
43  %is.positive = icmp sgt i32 %sub, 0
44  br i1 %is.positive, label %backedge, label %if.false
45
46if.false:                                         ; preds = %loop
47  br label %backedge
48
49backedge:                                         ; preds = %if.false, %loop
50  %merge.phi = phi i32 [ 0, %if.false ], [ %sub, %loop ]
51  %sum.next = add i32 %sum, %merge.phi
52  %loop.cond = icmp ne i32 %sum.next, %limit
53  br i1 %loop.cond, label %loop, label %done
54
55done:                                             ; preds = %backedge
56  %sum.next.lcssa = phi i32 [ %sum.next, %backedge ]
57  ret i32 %sum.next.lcssa
58
59failure:
60  unreachable
61}
62
63; TODO: We can break the backedge here.
64define i32 @test_slt(i32 %limit) {
65; CHECK-LABEL: @test_slt(
66; CHECK-NEXT:  entry:
67; CHECK-NEXT:    [[LOOP_GUARD:%.*]] = icmp sgt i32 [[LIMIT:%.*]], 0
68; CHECK-NEXT:    br i1 [[LOOP_GUARD]], label [[LOOP_PREHEADER:%.*]], label [[FAILURE:%.*]]
69; CHECK:       loop.preheader:
70; CHECK-NEXT:    br label [[LOOP:%.*]]
71; CHECK:       loop:
72; CHECK-NEXT:    [[SUM:%.*]] = phi i32 [ [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ], [ 0, [[LOOP_PREHEADER]] ]
73; CHECK-NEXT:    [[SUB:%.*]] = sub i32 [[LIMIT]], [[SUM]]
74; CHECK-NEXT:    [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
75; CHECK-NEXT:    br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label [[IF_FALSE:%.*]]
76; CHECK:       if.false:
77; CHECK-NEXT:    br label [[BACKEDGE]]
78; CHECK:       backedge:
79; CHECK-NEXT:    [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [ [[SUB]], [[LOOP]] ]
80; CHECK-NEXT:    [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
81; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp slt i32 [[SUM_NEXT]], [[LIMIT]]
82; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
83; CHECK:       done:
84; CHECK-NEXT:    [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]], [[BACKEDGE]] ]
85; CHECK-NEXT:    ret i32 [[SUM_NEXT_LCSSA]]
86; CHECK:       failure:
87; CHECK-NEXT:    unreachable
88;
89entry:
90  %loop_guard = icmp sgt i32 %limit, 0
91  br i1 %loop_guard, label %loop, label %failure
92
93loop:                                             ; preds = %backedge, %entry
94  %sum = phi i32 [ 0, %entry ], [ %sum.next, %backedge ]
95  %sub = sub i32 %limit, %sum
96  %is.positive = icmp sgt i32 %sub, 0
97  br i1 %is.positive, label %backedge, label %if.false
98
99if.false:                                         ; preds = %loop
100  br label %backedge
101
102backedge:                                         ; preds = %if.false, %loop
103  %merge.phi = phi i32 [ 0, %if.false ], [ %sub, %loop ]
104  %sum.next = add i32 %sum, %merge.phi
105  %loop.cond = icmp slt i32 %sum.next, %limit
106  br i1 %loop.cond, label %loop, label %done
107
108done:                                             ; preds = %backedge
109  %sum.next.lcssa = phi i32 [ %sum.next, %backedge ]
110  ret i32 %sum.next.lcssa
111
112failure:
113  unreachable
114}
115
116; TODO: We can break the backedge here.
117define i32 @test_ult(i32 %limit) {
118; CHECK-LABEL: @test_ult(
119; CHECK-NEXT:  entry:
120; CHECK-NEXT:    [[LOOP_GUARD:%.*]] = icmp sgt i32 [[LIMIT:%.*]], 0
121; CHECK-NEXT:    br i1 [[LOOP_GUARD]], label [[LOOP_PREHEADER:%.*]], label [[FAILURE:%.*]]
122; CHECK:       loop.preheader:
123; CHECK-NEXT:    br label [[LOOP:%.*]]
124; CHECK:       loop:
125; CHECK-NEXT:    [[SUM:%.*]] = phi i32 [ [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ], [ 0, [[LOOP_PREHEADER]] ]
126; CHECK-NEXT:    [[SUB:%.*]] = sub i32 [[LIMIT]], [[SUM]]
127; CHECK-NEXT:    [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
128; CHECK-NEXT:    br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label [[IF_FALSE:%.*]]
129; CHECK:       if.false:
130; CHECK-NEXT:    br label [[BACKEDGE]]
131; CHECK:       backedge:
132; CHECK-NEXT:    [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [ [[SUB]], [[LOOP]] ]
133; CHECK-NEXT:    [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
134; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ult i32 [[SUM_NEXT]], [[LIMIT]]
135; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
136; CHECK:       done:
137; CHECK-NEXT:    [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]], [[BACKEDGE]] ]
138; CHECK-NEXT:    ret i32 [[SUM_NEXT_LCSSA]]
139; CHECK:       failure:
140; CHECK-NEXT:    unreachable
141;
142entry:
143  %loop_guard = icmp sgt i32 %limit, 0
144  br i1 %loop_guard, label %loop, label %failure
145
146loop:                                             ; preds = %backedge, %entry
147  %sum = phi i32 [ 0, %entry ], [ %sum.next, %backedge ]
148  %sub = sub i32 %limit, %sum
149  %is.positive = icmp sgt i32 %sub, 0
150  br i1 %is.positive, label %backedge, label %if.false
151
152if.false:                                         ; preds = %loop
153  br label %backedge
154
155backedge:                                         ; preds = %if.false, %loop
156  %merge.phi = phi i32 [ 0, %if.false ], [ %sub, %loop ]
157  %sum.next = add i32 %sum, %merge.phi
158  %loop.cond = icmp ult i32 %sum.next, %limit
159  br i1 %loop.cond, label %loop, label %done
160
161done:                                             ; preds = %backedge
162  %sum.next.lcssa = phi i32 [ %sum.next, %backedge ]
163  ret i32 %sum.next.lcssa
164
165failure:
166  unreachable
167}
168
169; TODO: We can break the backedge here.
170define i32 @test_sgt(i32 %limit) {
171; CHECK-LABEL: @test_sgt(
172; CHECK-NEXT:  entry:
173; CHECK-NEXT:    [[LOOP_GUARD:%.*]] = icmp sgt i32 [[LIMIT:%.*]], 0
174; CHECK-NEXT:    br i1 [[LOOP_GUARD]], label [[LOOP_PREHEADER:%.*]], label [[FAILURE:%.*]]
175; CHECK:       loop.preheader:
176; CHECK-NEXT:    br label [[LOOP:%.*]]
177; CHECK:       loop:
178; CHECK-NEXT:    [[SUM:%.*]] = phi i32 [ [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ], [ 0, [[LOOP_PREHEADER]] ]
179; CHECK-NEXT:    [[SUB:%.*]] = sub i32 [[LIMIT]], [[SUM]]
180; CHECK-NEXT:    [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
181; CHECK-NEXT:    br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label [[IF_FALSE:%.*]]
182; CHECK:       if.false:
183; CHECK-NEXT:    br label [[BACKEDGE]]
184; CHECK:       backedge:
185; CHECK-NEXT:    [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [ [[SUB]], [[LOOP]] ]
186; CHECK-NEXT:    [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
187; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp sgt i32 [[SUM_NEXT]], [[LIMIT]]
188; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
189; CHECK:       done:
190; CHECK-NEXT:    [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]], [[BACKEDGE]] ]
191; CHECK-NEXT:    ret i32 [[SUM_NEXT_LCSSA]]
192; CHECK:       failure:
193; CHECK-NEXT:    unreachable
194;
195entry:
196  %loop_guard = icmp sgt i32 %limit, 0
197  br i1 %loop_guard, label %loop, label %failure
198
199loop:                                             ; preds = %backedge, %entry
200  %sum = phi i32 [ 0, %entry ], [ %sum.next, %backedge ]
201  %sub = sub i32 %limit, %sum
202  %is.positive = icmp sgt i32 %sub, 0
203  br i1 %is.positive, label %backedge, label %if.false
204
205if.false:                                         ; preds = %loop
206  br label %backedge
207
208backedge:                                         ; preds = %if.false, %loop
209  %merge.phi = phi i32 [ 0, %if.false ], [ %sub, %loop ]
210  %sum.next = add i32 %sum, %merge.phi
211  %loop.cond = icmp sgt i32 %sum.next, %limit
212  br i1 %loop.cond, label %loop, label %done
213
214done:                                             ; preds = %backedge
215  %sum.next.lcssa = phi i32 [ %sum.next, %backedge ]
216  ret i32 %sum.next.lcssa
217
218failure:
219  unreachable
220}
221
222; TODO: We can break the backedge here.
223define i32 @test_ugt(i32 %limit) {
224; CHECK-LABEL: @test_ugt(
225; CHECK-NEXT:  entry:
226; CHECK-NEXT:    [[LOOP_GUARD:%.*]] = icmp sgt i32 [[LIMIT:%.*]], 0
227; CHECK-NEXT:    br i1 [[LOOP_GUARD]], label [[LOOP_PREHEADER:%.*]], label [[FAILURE:%.*]]
228; CHECK:       loop.preheader:
229; CHECK-NEXT:    br label [[LOOP:%.*]]
230; CHECK:       loop:
231; CHECK-NEXT:    [[SUM:%.*]] = phi i32 [ [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ], [ 0, [[LOOP_PREHEADER]] ]
232; CHECK-NEXT:    [[SUB:%.*]] = sub i32 [[LIMIT]], [[SUM]]
233; CHECK-NEXT:    [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
234; CHECK-NEXT:    br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label [[IF_FALSE:%.*]]
235; CHECK:       if.false:
236; CHECK-NEXT:    br label [[BACKEDGE]]
237; CHECK:       backedge:
238; CHECK-NEXT:    [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [ [[SUB]], [[LOOP]] ]
239; CHECK-NEXT:    [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
240; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ugt i32 [[SUM_NEXT]], [[LIMIT]]
241; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
242; CHECK:       done:
243; CHECK-NEXT:    [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]], [[BACKEDGE]] ]
244; CHECK-NEXT:    ret i32 [[SUM_NEXT_LCSSA]]
245; CHECK:       failure:
246; CHECK-NEXT:    unreachable
247;
248entry:
249  %loop_guard = icmp sgt i32 %limit, 0
250  br i1 %loop_guard, label %loop, label %failure
251
252loop:                                             ; preds = %backedge, %entry
253  %sum = phi i32 [ 0, %entry ], [ %sum.next, %backedge ]
254  %sub = sub i32 %limit, %sum
255  %is.positive = icmp sgt i32 %sub, 0
256  br i1 %is.positive, label %backedge, label %if.false
257
258if.false:                                         ; preds = %loop
259  br label %backedge
260
261backedge:                                         ; preds = %if.false, %loop
262  %merge.phi = phi i32 [ 0, %if.false ], [ %sub, %loop ]
263  %sum.next = add i32 %sum, %merge.phi
264  %loop.cond = icmp ugt i32 %sum.next, %limit
265  br i1 %loop.cond, label %loop, label %done
266
267done:                                             ; preds = %backedge
268  %sum.next.lcssa = phi i32 [ %sum.next, %backedge ]
269  ret i32 %sum.next.lcssa
270
271failure:
272  unreachable
273}
274
275; TODO: We can break the backedge here.
276define i32 @test_multiple_pred(i32 %limit) {
277; CHECK-LABEL: @test_multiple_pred(
278; CHECK-NEXT:  entry:
279; CHECK-NEXT:    [[LOOP_GUARD:%.*]] = icmp sgt i32 [[LIMIT:%.*]], 0
280; CHECK-NEXT:    br i1 [[LOOP_GUARD]], label [[LOOP_PREHEADER:%.*]], label [[FAILURE:%.*]]
281; CHECK:       loop.preheader:
282; CHECK-NEXT:    br label [[LOOP:%.*]]
283; CHECK:       loop:
284; CHECK-NEXT:    [[SUM:%.*]] = phi i32 [ [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ], [ 0, [[LOOP_PREHEADER]] ]
285; CHECK-NEXT:    [[SUB:%.*]] = sub i32 [[LIMIT]], [[SUM]]
286; CHECK-NEXT:    [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
287; CHECK-NEXT:    br i1 [[IS_POSITIVE]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]]
288; CHECK:       if.true:
289; CHECK-NEXT:    switch i32 [[LIMIT]], label [[FAILURE_LOOPEXIT:%.*]] [
290; CHECK-NEXT:    i32 100, label [[BACKEDGE]]
291; CHECK-NEXT:    i32 200, label [[BACKEDGE]]
292; CHECK-NEXT:    ]
293; CHECK:       if.false:
294; CHECK-NEXT:    br label [[BACKEDGE]]
295; CHECK:       backedge:
296; CHECK-NEXT:    [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [ [[SUB]], [[IF_TRUE]] ], [ [[SUB]], [[IF_TRUE]] ]
297; CHECK-NEXT:    [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
298; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ne i32 [[SUM_NEXT]], [[LIMIT]]
299; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
300; CHECK:       done:
301; CHECK-NEXT:    [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]], [[BACKEDGE]] ]
302; CHECK-NEXT:    ret i32 [[SUM_NEXT_LCSSA]]
303; CHECK:       failure.loopexit:
304; CHECK-NEXT:    br label [[FAILURE]]
305; CHECK:       failure:
306; CHECK-NEXT:    unreachable
307;
308entry:
309  %loop_guard = icmp sgt i32 %limit, 0
310  br i1 %loop_guard, label %loop, label %failure
311
312loop:                                             ; preds = %backedge, %entry
313  %sum = phi i32 [ 0, %entry ], [ %sum.next, %backedge ]
314  %sub = sub i32 %limit, %sum
315  %is.positive = icmp sgt i32 %sub, 0
316  br i1 %is.positive, label %if.true, label %if.false
317
318if.true:
319  switch i32 %limit, label %failure [
320  i32 100, label %backedge
321  i32 200, label %backedge
322  ]
323
324if.false:                                         ; preds = %loop
325  br label %backedge
326
327backedge:
328  %merge.phi = phi i32 [ 0, %if.false ], [ %sub, %if.true ], [ %sub, %if.true ]
329  %sum.next = add i32 %sum, %merge.phi
330  %loop.cond = icmp ne i32 %sum.next, %limit
331  br i1 %loop.cond, label %loop, label %done
332
333done:                                             ; preds = %backedge
334  %sum.next.lcssa = phi i32 [ %sum.next, %backedge ]
335  ret i32 %sum.next.lcssa
336
337failure:
338  unreachable
339}
340
341; TODO: We can break the backedge here.
342define i32 @test_ne_const() {
343; CHECK-LABEL: @test_ne_const(
344; CHECK-NEXT:  entry:
345; CHECK-NEXT:    br label [[LOOP:%.*]]
346; CHECK:       loop:
347; CHECK-NEXT:    [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ]
348; CHECK-NEXT:    [[SUB:%.*]] = sub i32 4, [[SUM]]
349; CHECK-NEXT:    [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
350; CHECK-NEXT:    br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label [[IF_FALSE:%.*]]
351; CHECK:       if.false:
352; CHECK-NEXT:    br label [[BACKEDGE]]
353; CHECK:       backedge:
354; CHECK-NEXT:    [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [ [[SUB]], [[LOOP]] ]
355; CHECK-NEXT:    [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
356; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ne i32 [[SUM_NEXT]], 4
357; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
358; CHECK:       done:
359; CHECK-NEXT:    [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]], [[BACKEDGE]] ]
360; CHECK-NEXT:    ret i32 [[SUM_NEXT_LCSSA]]
361; CHECK:       failure:
362; CHECK-NEXT:    unreachable
363;
364entry:
365
366  br label %loop
367
368loop:                                             ; preds = %backedge, %entry
369  %sum = phi i32 [ 0, %entry ], [ %sum.next, %backedge ]
370  %sub = sub i32 4, %sum
371  %is.positive = icmp sgt i32 %sub, 0
372  br i1 %is.positive, label %backedge, label %if.false
373
374if.false:                                         ; preds = %loop
375  br label %backedge
376
377backedge:                                         ; preds = %if.false, %loop
378  %merge.phi = phi i32 [ 0, %if.false ], [ %sub, %loop ]
379  %sum.next = add i32 %sum, %merge.phi
380  %loop.cond = icmp ne i32 %sum.next, 4
381  br i1 %loop.cond, label %loop, label %done
382
383done:                                             ; preds = %backedge
384  %sum.next.lcssa = phi i32 [ %sum.next, %backedge ]
385  ret i32 %sum.next.lcssa
386
387failure:
388  unreachable
389}
390
391; TODO: We can break the backedge here.
392define i32 @test_slt_const() {
393; CHECK-LABEL: @test_slt_const(
394; CHECK-NEXT:  entry:
395; CHECK-NEXT:    br label [[LOOP:%.*]]
396; CHECK:       loop:
397; CHECK-NEXT:    [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ]
398; CHECK-NEXT:    [[SUB:%.*]] = sub i32 4, [[SUM]]
399; CHECK-NEXT:    [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
400; CHECK-NEXT:    br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label [[IF_FALSE:%.*]]
401; CHECK:       if.false:
402; CHECK-NEXT:    br label [[BACKEDGE]]
403; CHECK:       backedge:
404; CHECK-NEXT:    [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [ [[SUB]], [[LOOP]] ]
405; CHECK-NEXT:    [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
406; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp slt i32 [[SUM_NEXT]], 4
407; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
408; CHECK:       done:
409; CHECK-NEXT:    [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]], [[BACKEDGE]] ]
410; CHECK-NEXT:    ret i32 [[SUM_NEXT_LCSSA]]
411; CHECK:       failure:
412; CHECK-NEXT:    unreachable
413;
414entry:
415
416  br label %loop
417
418loop:                                             ; preds = %backedge, %entry
419  %sum = phi i32 [ 0, %entry ], [ %sum.next, %backedge ]
420  %sub = sub i32 4, %sum
421  %is.positive = icmp sgt i32 %sub, 0
422  br i1 %is.positive, label %backedge, label %if.false
423
424if.false:                                         ; preds = %loop
425  br label %backedge
426
427backedge:                                         ; preds = %if.false, %loop
428  %merge.phi = phi i32 [ 0, %if.false ], [ %sub, %loop ]
429  %sum.next = add i32 %sum, %merge.phi
430  %loop.cond = icmp slt i32 %sum.next, 4
431  br i1 %loop.cond, label %loop, label %done
432
433done:                                             ; preds = %backedge
434  %sum.next.lcssa = phi i32 [ %sum.next, %backedge ]
435  ret i32 %sum.next.lcssa
436
437failure:
438  unreachable
439}
440
441; TODO: We can break the backedge here.
442define i32 @test_ult_const() {
443; CHECK-LABEL: @test_ult_const(
444; CHECK-NEXT:  entry:
445; CHECK-NEXT:    br label [[LOOP:%.*]]
446; CHECK:       loop:
447; CHECK-NEXT:    [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ]
448; CHECK-NEXT:    [[SUB:%.*]] = sub i32 4, [[SUM]]
449; CHECK-NEXT:    [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
450; CHECK-NEXT:    br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label [[IF_FALSE:%.*]]
451; CHECK:       if.false:
452; CHECK-NEXT:    br label [[BACKEDGE]]
453; CHECK:       backedge:
454; CHECK-NEXT:    [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [ [[SUB]], [[LOOP]] ]
455; CHECK-NEXT:    [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
456; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ult i32 [[SUM_NEXT]], 4
457; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
458; CHECK:       done:
459; CHECK-NEXT:    [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]], [[BACKEDGE]] ]
460; CHECK-NEXT:    ret i32 [[SUM_NEXT_LCSSA]]
461; CHECK:       failure:
462; CHECK-NEXT:    unreachable
463;
464entry:
465
466  br label %loop
467
468loop:                                             ; preds = %backedge, %entry
469  %sum = phi i32 [ 0, %entry ], [ %sum.next, %backedge ]
470  %sub = sub i32 4, %sum
471  %is.positive = icmp sgt i32 %sub, 0
472  br i1 %is.positive, label %backedge, label %if.false
473
474if.false:                                         ; preds = %loop
475  br label %backedge
476
477backedge:                                         ; preds = %if.false, %loop
478  %merge.phi = phi i32 [ 0, %if.false ], [ %sub, %loop ]
479  %sum.next = add i32 %sum, %merge.phi
480  %loop.cond = icmp ult i32 %sum.next, 4
481  br i1 %loop.cond, label %loop, label %done
482
483done:                                             ; preds = %backedge
484  %sum.next.lcssa = phi i32 [ %sum.next, %backedge ]
485  ret i32 %sum.next.lcssa
486
487failure:
488  unreachable
489}
490
491; TODO: We can break the backedge here.
492define i32 @test_sgt_const() {
493; CHECK-LABEL: @test_sgt_const(
494; CHECK-NEXT:  entry:
495; CHECK-NEXT:    br label [[LOOP:%.*]]
496; CHECK:       loop:
497; CHECK-NEXT:    [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ]
498; CHECK-NEXT:    [[SUB:%.*]] = sub i32 4, [[SUM]]
499; CHECK-NEXT:    [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
500; CHECK-NEXT:    br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label [[IF_FALSE:%.*]]
501; CHECK:       if.false:
502; CHECK-NEXT:    br label [[BACKEDGE]]
503; CHECK:       backedge:
504; CHECK-NEXT:    [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [ [[SUB]], [[LOOP]] ]
505; CHECK-NEXT:    [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
506; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp sgt i32 [[SUM_NEXT]], 4
507; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
508; CHECK:       done:
509; CHECK-NEXT:    [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]], [[BACKEDGE]] ]
510; CHECK-NEXT:    ret i32 [[SUM_NEXT_LCSSA]]
511; CHECK:       failure:
512; CHECK-NEXT:    unreachable
513;
514entry:
515
516  br label %loop
517
518loop:                                             ; preds = %backedge, %entry
519  %sum = phi i32 [ 0, %entry ], [ %sum.next, %backedge ]
520  %sub = sub i32 4, %sum
521  %is.positive = icmp sgt i32 %sub, 0
522  br i1 %is.positive, label %backedge, label %if.false
523
524if.false:                                         ; preds = %loop
525  br label %backedge
526
527backedge:                                         ; preds = %if.false, %loop
528  %merge.phi = phi i32 [ 0, %if.false ], [ %sub, %loop ]
529  %sum.next = add i32 %sum, %merge.phi
530  %loop.cond = icmp sgt i32 %sum.next, 4
531  br i1 %loop.cond, label %loop, label %done
532
533done:                                             ; preds = %backedge
534  %sum.next.lcssa = phi i32 [ %sum.next, %backedge ]
535  ret i32 %sum.next.lcssa
536
537failure:
538  unreachable
539}
540
541; TODO: We can break the backedge here.
542define i32 @test_ugt_const() {
543; CHECK-LABEL: @test_ugt_const(
544; CHECK-NEXT:  entry:
545; CHECK-NEXT:    br label [[LOOP:%.*]]
546; CHECK:       loop:
547; CHECK-NEXT:    [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ]
548; CHECK-NEXT:    [[SUB:%.*]] = sub i32 4, [[SUM]]
549; CHECK-NEXT:    [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
550; CHECK-NEXT:    br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label [[IF_FALSE:%.*]]
551; CHECK:       if.false:
552; CHECK-NEXT:    br label [[BACKEDGE]]
553; CHECK:       backedge:
554; CHECK-NEXT:    [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [ [[SUB]], [[LOOP]] ]
555; CHECK-NEXT:    [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
556; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ugt i32 [[SUM_NEXT]], 4
557; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
558; CHECK:       done:
559; CHECK-NEXT:    [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]], [[BACKEDGE]] ]
560; CHECK-NEXT:    ret i32 [[SUM_NEXT_LCSSA]]
561; CHECK:       failure:
562; CHECK-NEXT:    unreachable
563;
564entry:
565
566  br label %loop
567
568loop:                                             ; preds = %backedge, %entry
569  %sum = phi i32 [ 0, %entry ], [ %sum.next, %backedge ]
570  %sub = sub i32 4, %sum
571  %is.positive = icmp sgt i32 %sub, 0
572  br i1 %is.positive, label %backedge, label %if.false
573
574if.false:                                         ; preds = %loop
575  br label %backedge
576
577backedge:                                         ; preds = %if.false, %loop
578  %merge.phi = phi i32 [ 0, %if.false ], [ %sub, %loop ]
579  %sum.next = add i32 %sum, %merge.phi
580  %loop.cond = icmp ugt i32 %sum.next, 4
581  br i1 %loop.cond, label %loop, label %done
582
583done:                                             ; preds = %backedge
584  %sum.next.lcssa = phi i32 [ %sum.next, %backedge ]
585  ret i32 %sum.next.lcssa
586
587failure:
588  unreachable
589}
590
591; TODO: We can break the backedge here.
592define i32 @test_multiple_pred_const() {
593; CHECK-LABEL: @test_multiple_pred_const(
594; CHECK-NEXT:  entry:
595; CHECK-NEXT:    br label [[LOOP:%.*]]
596; CHECK:       loop:
597; CHECK-NEXT:    [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ]
598; CHECK-NEXT:    [[SUB:%.*]] = sub i32 4, [[SUM]]
599; CHECK-NEXT:    [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
600; CHECK-NEXT:    br i1 [[IS_POSITIVE]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]]
601; CHECK:       if.true:
602; CHECK-NEXT:    switch i32 4, label [[FAILURE:%.*]] [
603; CHECK-NEXT:    i32 100, label [[BACKEDGE]]
604; CHECK-NEXT:    i32 200, label [[BACKEDGE]]
605; CHECK-NEXT:    ]
606; CHECK:       if.false:
607; CHECK-NEXT:    br label [[BACKEDGE]]
608; CHECK:       backedge:
609; CHECK-NEXT:    [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [ [[SUB]], [[IF_TRUE]] ], [ [[SUB]], [[IF_TRUE]] ]
610; CHECK-NEXT:    [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
611; CHECK-NEXT:    [[LOOP_COND:%.*]] = icmp ne i32 [[SUM_NEXT]], 4
612; CHECK-NEXT:    br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
613; CHECK:       done:
614; CHECK-NEXT:    [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]], [[BACKEDGE]] ]
615; CHECK-NEXT:    ret i32 [[SUM_NEXT_LCSSA]]
616; CHECK:       failure:
617; CHECK-NEXT:    unreachable
618;
619entry:
620
621  br label %loop
622
623loop:                                             ; preds = %backedge, %entry
624  %sum = phi i32 [ 0, %entry ], [ %sum.next, %backedge ]
625  %sub = sub i32 4, %sum
626  %is.positive = icmp sgt i32 %sub, 0
627  br i1 %is.positive, label %if.true, label %if.false
628
629if.true:
630  switch i32 4, label %failure [
631  i32 100, label %backedge
632  i32 200, label %backedge
633  ]
634
635if.false:                                         ; preds = %loop
636  br label %backedge
637
638backedge:
639  %merge.phi = phi i32 [ 0, %if.false ], [ %sub, %if.true ], [ %sub, %if.true ]
640  %sum.next = add i32 %sum, %merge.phi
641  %loop.cond = icmp ne i32 %sum.next, 4
642  br i1 %loop.cond, label %loop, label %done
643
644done:                                             ; preds = %backedge
645  %sum.next.lcssa = phi i32 [ %sum.next, %backedge ]
646  ret i32 %sum.next.lcssa
647
648failure:
649  unreachable
650}
651