1; REQUIRES: asserts
2
3; RUN: opt -loop-vectorize -debug-only=loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -prefer-inloop-reductions -enable-interleaved-mem-accesses=true -enable-masked-interleaved-mem-accesses -disable-output %s 2>&1 | FileCheck %s
4
5target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
6
7; Tests for printing VPlans.
8
9define void @print_call_and_memory(i64 %n, float* noalias %y, float* noalias %x) nounwind uwtable {
10; CHECK-LABEL: Checking a loop in 'print_call_and_memory'
11; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
12; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
13; CHECK-EMPTY:
14; CHECK-NEXT: <x1> vector loop: {
15; CHECK-NEXT: for.body:
16; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
17; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<0>, ir<1>
18; CHECK-NEXT:   CLONE ir<%arrayidx> = getelementptr ir<%y>, vp<[[STEPS]]>
19; CHECK-NEXT:   WIDEN ir<%lv> = load ir<%arrayidx>
20; CHECK-NEXT:   WIDEN-CALL ir<%call> = call @llvm.sqrt.f32(ir<%lv>)
21; CHECK-NEXT:   CLONE ir<%arrayidx2> = getelementptr ir<%x>, vp<[[STEPS]]>
22; CHECK-NEXT:   WIDEN store ir<%arrayidx2>, ir<%call>
23; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
24; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
25; CHECK-NEXT: No successors
26; CHECK-NEXT: }
27; CHECK-NEXT: No successors
28; CHECK-NEXT: }
29;
30entry:
31  %cmp6 = icmp sgt i64 %n, 0
32  br i1 %cmp6, label %for.body, label %for.end
33
34for.body:                                         ; preds = %entry, %for.body
35  %iv = phi i64 [ %iv.next, %for.body ], [ 0, %entry ]
36  %arrayidx = getelementptr inbounds float, float* %y, i64 %iv
37  %lv = load float, float* %arrayidx, align 4
38  %call = tail call float @llvm.sqrt.f32(float %lv) nounwind readnone
39  %arrayidx2 = getelementptr inbounds float, float* %x, i64 %iv
40  store float %call, float* %arrayidx2, align 4
41  %iv.next = add i64 %iv, 1
42  %exitcond = icmp eq i64 %iv.next, %n
43  br i1 %exitcond, label %for.end, label %for.body
44
45for.end:                                          ; preds = %for.body, %entry
46  ret void
47}
48
49define void @print_widen_gep_and_select(i64 %n, float* noalias %y, float* noalias %x, float* %z) nounwind uwtable {
50; CHECK-LABEL: Checking a loop in 'print_widen_gep_and_select'
51; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
52; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
53; CHECK-EMPTY:
54; CHECK-NEXT: <x1> vector loop: {
55; CHECK-NEXT: for.body:
56; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
57; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi %iv.next, 0
58; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<0>, ir<1>
59; CHECK-NEXT:   WIDEN-GEP Inv[Var] ir<%arrayidx> = getelementptr ir<%y>, ir<%iv>
60; CHECK-NEXT:   WIDEN ir<%lv> = load ir<%arrayidx>
61; CHECK-NEXT:   WIDEN ir<%cmp> = icmp ir<%arrayidx>, ir<%z>
62; CHECK-NEXT:   WIDEN-SELECT ir<%sel> = select ir<%cmp>, ir<1.000000e+01>, ir<2.000000e+01>
63; CHECK-NEXT:   WIDEN ir<%add> = fadd ir<%lv>, ir<%sel>
64; CHECK-NEXT:   CLONE ir<%arrayidx2> = getelementptr ir<%x>, vp<[[STEPS]]>
65; CHECK-NEXT:   WIDEN store ir<%arrayidx2>, ir<%add>
66; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
67; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
68; CHECK-NEXT: No successors
69; CHECK-NEXT: }
70; CHECK-NEXT: No successors
71; CHECK-NEXT: }
72;
73entry:
74  %cmp6 = icmp sgt i64 %n, 0
75  br i1 %cmp6, label %for.body, label %for.end
76
77for.body:                                         ; preds = %entry, %for.body
78  %iv = phi i64 [ %iv.next, %for.body ], [ 0, %entry ]
79  %arrayidx = getelementptr inbounds float, float* %y, i64 %iv
80  %lv = load float, float* %arrayidx, align 4
81  %cmp = icmp eq float* %arrayidx, %z
82  %sel = select i1 %cmp, float 10.0, float 20.0
83  %add = fadd float %lv, %sel
84  %arrayidx2 = getelementptr inbounds float, float* %x, i64 %iv
85  store float %add, float* %arrayidx2, align 4
86  %iv.next = add i64 %iv, 1
87  %exitcond = icmp eq i64 %iv.next, %n
88  br i1 %exitcond, label %for.end, label %for.body
89
90for.end:                                          ; preds = %for.body, %entry
91  ret void
92}
93
94define float @print_reduction(i64 %n, float* noalias %y) {
95; CHECK-LABEL: Checking a loop in 'print_reduction'
96; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
97; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
98; CHECK-EMPTY:
99; CHECK-NEXT: <x1> vector loop: {
100; CHECK-NEXT: for.body:
101; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
102; CHECK-NEXT:   WIDEN-REDUCTION-PHI ir<%red> = phi ir<0.000000e+00>, ir<%red.next>
103; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<0>, ir<1>
104; CHECK-NEXT:   CLONE ir<%arrayidx> = getelementptr ir<%y>, vp<[[STEPS]]>
105; CHECK-NEXT:   WIDEN ir<%lv> = load ir<%arrayidx>
106; CHECK-NEXT:   REDUCE ir<%red.next> = ir<%red> + fast reduce.fadd (ir<%lv>)
107; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
108; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
109; CHECK-NEXT: No successors
110; CHECK-NEXT: }
111; CHECK-NEXT: No successors
112; CHECK-NEXT: }
113;
114entry:
115  br label %for.body
116
117for.body:                                         ; preds = %entry, %for.body
118  %iv = phi i64 [ %iv.next, %for.body ], [ 0, %entry ]
119  %red = phi float [ %red.next, %for.body ], [ 0.0, %entry ]
120  %arrayidx = getelementptr inbounds float, float* %y, i64 %iv
121  %lv = load float, float* %arrayidx, align 4
122  %red.next = fadd fast float %lv, %red
123  %iv.next = add i64 %iv, 1
124  %exitcond = icmp eq i64 %iv.next, %n
125  br i1 %exitcond, label %for.end, label %for.body
126
127for.end:                                          ; preds = %for.body, %entry
128  ret float %red.next
129}
130
131define void @print_replicate_predicated_phi(i64 %n, i64* %x) {
132; CHECK-LABEL: Checking a loop in 'print_replicate_predicated_phi'
133; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
134; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
135; CHECK-EMPTY:
136; CHECK-NEXT: <x1> vector loop: {
137; CHECK-NEXT: for.body:
138; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
139; CHECK-NEXT:   WIDEN-INDUCTION %i = phi 0, %i.next
140; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<0>, ir<1>
141; CHECK-NEXT:   WIDEN ir<%cmp> = icmp ir<%i>, ir<5>
142; CHECK-NEXT: Successor(s): if.then
143; CHECK-EMPTY:
144; CHECK-NEXT: if.then:
145; CHECK-NEXT: Successor(s): pred.udiv
146; CHECK-EMPTY:
147; CHECK-NEXT: <xVFxUF> pred.udiv: {
148; CHECK-NEXT:   pred.udiv.entry:
149; CHECK-NEXT:     BRANCH-ON-MASK ir<%cmp>
150; CHECK-NEXT:   Successor(s): pred.udiv.if, pred.udiv.continue
151; CHECK-NEXT:   CondBit: ir<%cmp>
152; CHECK-EMPTY:
153; CHECK-NEXT:   pred.udiv.if:
154; CHECK-NEXT:     REPLICATE ir<%tmp4> = udiv ir<%n>, vp<[[STEPS]]> (S->V)
155; CHECK-NEXT:   Successor(s): pred.udiv.continue
156; CHECK-EMPTY:
157; CHECK-NEXT:   pred.udiv.continue:
158; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%tmp4>
159; CHECK-NEXT:   No successors
160; CHECK-NEXT: }
161; CHECK-NEXT: Successor(s): if.then.0
162; CHECK-EMPTY:
163; CHECK-NEXT: if.then.0:
164; CHECK-NEXT: Successor(s): for.inc
165; CHECK-EMPTY:
166; CHECK-NEXT: for.inc:
167; CHECK-NEXT:   EMIT vp<[[NOT:%.+]]> = not ir<%cmp>
168; CHECK-NEXT:   BLEND %d = ir<0>/vp<[[NOT]]> vp<[[PRED]]>/ir<%cmp>
169; CHECK-NEXT:   CLONE ir<%idx> = getelementptr ir<%x>, vp<[[STEPS]]>
170; CHECK-NEXT:   WIDEN store ir<%idx>, ir<%d>
171; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
172; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
173; CHECK-NEXT: No successors
174; CHECK-NEXT: }
175; CHECK-NEXT: No successors
176; CHECK-NEXT: }
177;
178entry:
179  br label %for.body
180
181for.body:                                         ; preds = %for.inc, %entry
182  %i = phi i64 [ 0, %entry ], [ %i.next, %for.inc ]
183  %cmp = icmp ult i64 %i, 5
184  br i1 %cmp, label %if.then, label %for.inc
185
186if.then:                                          ; preds = %for.body
187  %tmp4 = udiv i64 %n, %i
188  br label %for.inc
189
190for.inc:                                          ; preds = %if.then, %for.body
191  %d = phi i64 [ 0, %for.body ], [ %tmp4, %if.then ]
192  %idx = getelementptr i64, i64* %x, i64 %i
193  store i64 %d, i64* %idx
194  %i.next = add nuw nsw i64 %i, 1
195  %cond = icmp slt i64 %i.next, %n
196  br i1 %cond, label %for.body, label %for.end
197
198for.end:                                          ; preds = %for.inc
199  ret void
200}
201
202@AB = common global [1024 x i32] zeroinitializer, align 4
203@CD = common global [1024 x i32] zeroinitializer, align 4
204
205define void @print_interleave_groups(i32 %C, i32 %D) {
206; CHECK-LABEL: Checking a loop in 'print_interleave_groups'
207; CHECK:       VPlan 'Initial VPlan for VF={4},UF>=1' {
208; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
209; CHECK-EMPTY:
210; CHECK-NEXT: <x1> vector loop: {
211; CHECK-NEXT:  for.body:
212; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
213; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<0>, ir<4>
214; CHECK-NEXT:   CLONE ir<%gep.AB.0> = getelementptr ir<@AB>, ir<0>, vp<[[STEPS]]>
215; CHECK-NEXT:   INTERLEAVE-GROUP with factor 4 at %AB.0, ir<%gep.AB.0>
216; CHECK-NEXT:     ir<%AB.0> = load from index 0
217; CHECK-NEXT:     ir<%AB.1> = load from index 1
218; CHECK-NEXT:     ir<%AB.3> = load from index 3
219; CHECK-NEXT:   CLONE ir<%iv.plus.3> = add vp<[[STEPS]]>, ir<3>
220; CHECK-NEXT:   WIDEN ir<%add> = add ir<%AB.0>, ir<%AB.1>
221; CHECK-NEXT:   CLONE ir<%gep.CD.3> = getelementptr ir<@CD>, ir<0>, ir<%iv.plus.3>
222; CHECK-NEXT:   INTERLEAVE-GROUP with factor 4 at <badref>, ir<%gep.CD.3>
223; CHECK-NEXT:     store ir<%add> to index 0
224; CHECK-NEXT:     store ir<1> to index 1
225; CHECK-NEXT:     store ir<2> to index 2
226; CHECK-NEXT:     store ir<%AB.3> to index 3
227; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
228; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
229; CHECK-NEXT: No successors
230; CHECK-NEXT: }
231; CHECK-NEXT: No successors
232; CHECK-NEXT: }
233;
234entry:
235  br label %for.body
236
237for.body:
238  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
239  %gep.AB.0= getelementptr inbounds [1024 x i32], [1024 x i32]* @AB, i64 0, i64 %iv
240  %AB.0 = load i32, i32* %gep.AB.0, align 4
241  %iv.plus.1 = add i64 %iv, 1
242  %gep.AB.1 = getelementptr inbounds [1024 x i32], [1024 x i32]* @AB, i64 0, i64 %iv.plus.1
243  %AB.1 = load i32, i32* %gep.AB.1, align 4
244  %iv.plus.2 = add i64 %iv, 2
245  %iv.plus.3 = add i64 %iv, 3
246  %gep.AB.3 = getelementptr inbounds [1024 x i32], [1024 x i32]* @AB, i64 0, i64 %iv.plus.3
247  %AB.3 = load i32, i32* %gep.AB.3, align 4
248  %add = add nsw i32 %AB.0, %AB.1
249  %gep.CD.0 = getelementptr inbounds [1024 x i32], [1024 x i32]* @CD, i64 0, i64 %iv
250  store i32 %add, i32* %gep.CD.0, align 4
251  %gep.CD.1 = getelementptr inbounds [1024 x i32], [1024 x i32]* @CD, i64 0, i64 %iv.plus.1
252  store i32 1, i32* %gep.CD.1, align 4
253  %gep.CD.2 = getelementptr inbounds [1024 x i32], [1024 x i32]* @CD, i64 0, i64 %iv.plus.2
254  store i32 2, i32* %gep.CD.2, align 4
255  %gep.CD.3 = getelementptr inbounds [1024 x i32], [1024 x i32]* @CD, i64 0, i64 %iv.plus.3
256  store i32 %AB.3, i32* %gep.CD.3, align 4
257  %iv.next = add nuw nsw i64 %iv, 4
258  %cmp = icmp slt i64 %iv.next, 1024
259  br i1 %cmp, label %for.body, label %for.end
260
261for.end:
262  ret void
263}
264
265define float @print_fmuladd_strict(float* %a, float* %b, i64 %n) {
266; CHECK-LABEL: Checking a loop in 'print_fmuladd_strict'
267; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
268; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
269; CHECK-EMPTY:
270; CHECK-NEXT: <x1> vector loop: {
271; CHECK-NEXT: for.body:
272; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
273; CHECK-NEXT:   WIDEN-REDUCTION-PHI ir<%sum.07> = phi ir<0.000000e+00>, ir<%muladd>
274; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<0>, ir<1>
275; CHECK-NEXT:   CLONE ir<%arrayidx> = getelementptr ir<%a>, vp<[[STEPS]]>
276; CHECK-NEXT:   WIDEN ir<%l.a> = load ir<%arrayidx>
277; CHECK-NEXT:   CLONE ir<%arrayidx2> = getelementptr ir<%b>, vp<[[STEPS]]>
278; CHECK-NEXT:   WIDEN ir<%l.b> = load ir<%arrayidx2>
279; CHECK-NEXT:   EMIT vp<[[FMUL:%.]]> = fmul nnan ninf nsz ir<%l.a> ir<%l.b>
280; CHECK-NEXT:   REDUCE ir<[[MULADD:%.+]]> = ir<%sum.07> + nnan ninf nsz reduce.fadd (vp<[[FMUL]]>)
281; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
282; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
283; CHECK-NEXT:   No successors
284; CHECK-NEXT: }
285
286entry:
287  br label %for.body
288
289for.body:
290  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
291  %sum.07 = phi float [ 0.000000e+00, %entry ], [ %muladd, %for.body ]
292  %arrayidx = getelementptr inbounds float, float* %a, i64 %iv
293  %l.a = load float, float* %arrayidx, align 4
294  %arrayidx2 = getelementptr inbounds float, float* %b, i64 %iv
295  %l.b = load float, float* %arrayidx2, align 4
296  %muladd = tail call nnan ninf nsz float @llvm.fmuladd.f32(float %l.a, float %l.b, float %sum.07)
297  %iv.next = add nuw nsw i64 %iv, 1
298  %exitcond.not = icmp eq i64 %iv.next, %n
299  br i1 %exitcond.not, label %for.end, label %for.body
300
301for.end:
302  ret float %muladd
303}
304
305define void @debug_loc_vpinstruction(i32* nocapture %asd, i32* nocapture %bsd) !dbg !5 {
306; CHECK-LABEL: Checking a loop in 'debug_loc_vpinstruction'
307; CHECK:    VPlan 'Initial VPlan for VF={4},UF>=1' {
308; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
309; CHECK-EMPTY:
310; CHECK-NEXT: <x1> vector loop: {
311; CHECK-NEXT:  loop:
312; CHECK-NEXT:    EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
313; CHECK-NEXT:    vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<0>, ir<1>
314; CHECK-NEXT:    CLONE ir<%isd> = getelementptr ir<%asd>, vp<[[STEPS]]>
315; CHECK-NEXT:    WIDEN ir<%lsd> = load ir<%isd>
316; CHECK-NEXT:    WIDEN ir<%psd> = add ir<%lsd>, ir<23>
317; CHECK-NEXT:    WIDEN ir<%cmp1> = icmp ir<%lsd>, ir<100>
318; CHECK-NEXT:  Successor(s): check
319; CHECK-EMPTY:
320; CHECK-NEXT:  check:
321; CHECK-NEXT:    WIDEN ir<%cmp2> = icmp ir<%lsd>, ir<200>
322; CHECK-NEXT:  Successor(s): if.then
323; CHECK-EMPTY:
324; CHECK-NEXT:  if.then:
325; CHECK-NEXT:    EMIT vp<[[NOT1:%.+]]> = not ir<%cmp1>, !dbg /tmp/s.c:5:3
326; CHECK-NEXT:    EMIT vp<[[SEL1:%.+]]> = select vp<[[NOT1]]> ir<%cmp2> ir<false>, !dbg /tmp/s.c:5:21
327; CHECK-NEXT:    EMIT vp<[[OR1:%.+]]> = or vp<[[SEL1]]> ir<%cmp1>
328; CHECK-NEXT:  Successor(s): pred.sdiv
329; CHECK-EMPTY:
330; CHECK-NEXT:  <xVFxUF> pred.sdiv: {
331; CHECK-NEXT:    pred.sdiv.entry:
332; CHECK-NEXT:      BRANCH-ON-MASK vp<[[OR1]]>
333; CHECK-NEXT:    Successor(s): pred.sdiv.if, pred.sdiv.continue
334; CHECK-NEXT:    CondBit: vp<[[OR1]]> (if.then)
335; CHECK-EMPTY:
336; CHECK-NEXT:    pred.sdiv.if:
337; CHECK-NEXT:      REPLICATE ir<%sd1> = sdiv ir<%psd>, ir<%lsd> (S->V)
338; CHECK-NEXT:    Successor(s): pred.sdiv.continue
339; CHECK-EMPTY:
340; CHECK-NEXT:    pred.sdiv.continue:
341; CHECK-NEXT:      PHI-PREDICATED-INSTRUCTION vp<[[PHI:%.+]]> = ir<%sd1>
342; CHECK-NEXT:    No successors
343; CHECK-NEXT:  }
344; CHECK-NEXT:  Successor(s): if.then.0
345; CHECK-EMPTY:
346; CHECK-NEXT:  if.then.0:
347; CHECK-NEXT:  Successor(s): if.end
348; CHECK-EMPTY:
349; CHECK-NEXT:  if.end:
350; CHECK-NEXT:    EMIT vp<[[NOT2:%.+]]> = not ir<%cmp2>
351; CHECK-NEXT:    EMIT vp<[[SEL2:%.+]]> = select vp<[[NOT1]]> vp<[[NOT2]]> ir<false>
352; CHECK-NEXT:    BLEND %ysd.0 = vp<[[PHI]]>/vp<[[OR1]]> ir<%psd>/vp<[[SEL2]]>
353; CHECK-NEXT:    WIDEN store ir<%isd>, ir<%ysd.0>
354; CHECK-NEXT:    EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
355; CHECK-NEXT:    EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
356; CHECK-NEXT:  No successors
357; CHECK-NEXT:}
358; CHECK-NEXT:No successors
359; CHECK-NEXT:}
360;
361entry:
362  br label %loop
363
364loop:
365  %iv = phi i64 [ 0, %entry ], [ %iv.next, %if.end ]
366  %isd = getelementptr inbounds i32, i32* %asd, i64 %iv
367  %lsd = load i32, i32* %isd, align 4
368  %psd = add nsw i32 %lsd, 23
369  %cmp1 = icmp slt i32 %lsd, 100
370  br i1 %cmp1, label %if.then, label %check, !dbg !7
371
372check:
373  %cmp2 = icmp sge i32 %lsd, 200
374  br i1 %cmp2, label %if.then, label %if.end, !dbg !8
375
376if.then:
377  %sd1 = sdiv i32 %psd, %lsd
378  br label %if.end
379
380if.end:
381  %ysd.0 = phi i32 [ %sd1, %if.then ], [ %psd, %check ]
382  store i32 %ysd.0, i32* %isd, align 4
383  %iv.next = add nuw nsw i64 %iv, 1
384  %exitcond = icmp eq i64 %iv.next, 128
385  br i1 %exitcond, label %exit, label %loop
386
387exit:
388  ret void
389}
390
391declare float @llvm.sqrt.f32(float) nounwind readnone
392declare float @llvm.fmuladd.f32(float, float, float)
393
394!llvm.dbg.cu = !{!0}
395!llvm.module.flags = !{!3, !4}
396
397!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: true, runtimeVersion: 0, emissionKind: NoDebug, enums: !2)
398!1 = !DIFile(filename: "/tmp/s.c", directory: "/tmp")
399!2 = !{}
400!3 = !{i32 2, !"Debug Info Version", i32 3}
401!4 = !{i32 7, !"PIC Level", i32 2}
402!5 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 4, type: !6, scopeLine: 4, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !2)
403!6 = !DISubroutineType(types: !2)
404!7 = !DILocation(line: 5, column: 3, scope: !5)
405!8 = !DILocation(line: 5, column: 21, scope: !5)
406