1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
2; RUN: opt -S -passes=loop-vectorize -force-vector-width=4 -force-vector-interleave=1 < %s 2>&1 | FileCheck %s
3
4target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
5
6; Check that the vectorizer identifies the %p.09 phi,
7; as an induction variable, despite the potential overflow
8; due to the truncation from 32bit to 8bit.
9; SCEV will detect the pattern "sext(trunc(%p.09)) + %step"
10; and generate the required runtime checks under which
11; we can assume no overflow. We check here that we generate
12; exactly two runtime checks:
13; 1) an overflow check:
14;    {0,+,(trunc i32 %step to i8)}<%for.body> Added Flags: <nssw>
15; 2) an equality check verifying that the step of the induction
16;    is equal to sext(trunc(step)):
17;    Equal predicate: %step == (sext i8 (trunc i32 %step to i8) to i32)
18;
19; See also pr30654.
20;
21; int a[N];
22; void doit1(int n, int step) {
23;   int i;
24;   char p = 0;
25;   for (i = 0; i < n; i++) {
26;      a[i] = p;
27;      p = p + step;
28;   }
29; }
30;
31
32@a = common local_unnamed_addr global [250 x i32] zeroinitializer, align 16
33
34; Function Attrs: norecurse nounwind uwtable
35define void @doit1(i32 %n, i32 %step) local_unnamed_addr {
36; CHECK-LABEL: @doit1(
37; CHECK-NEXT:  entry:
38; CHECK-NEXT:    [[CMP7:%.*]] = icmp sgt i32 [[N:%.*]], 0
39; CHECK-NEXT:    br i1 [[CMP7]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_END:%.*]]
40; CHECK:       for.body.preheader:
41; CHECK-NEXT:    [[WIDE_TRIP_COUNT:%.*]] = zext i32 [[N]] to i64
42; CHECK-NEXT:    [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[WIDE_TRIP_COUNT]], 4
43; CHECK-NEXT:    br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_SCEVCHECK:%.*]]
44; CHECK:       vector.scevcheck:
45; CHECK-NEXT:    [[TMP0:%.*]] = add nsw i64 [[WIDE_TRIP_COUNT]], -1
46; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[STEP:%.*]] to i8
47; CHECK-NEXT:    [[TMP2:%.*]] = sub i8 0, [[TMP1]]
48; CHECK-NEXT:    [[TMP3:%.*]] = icmp slt i8 [[TMP1]], 0
49; CHECK-NEXT:    [[TMP4:%.*]] = select i1 [[TMP3]], i8 [[TMP2]], i8 [[TMP1]]
50; CHECK-NEXT:    [[TMP5:%.*]] = trunc i64 [[TMP0]] to i8
51; CHECK-NEXT:    [[MUL:%.*]] = call { i8, i1 } @llvm.umul.with.overflow.i8(i8 [[TMP4]], i8 [[TMP5]])
52; CHECK-NEXT:    [[MUL_RESULT:%.*]] = extractvalue { i8, i1 } [[MUL]], 0
53; CHECK-NEXT:    [[MUL_OVERFLOW:%.*]] = extractvalue { i8, i1 } [[MUL]], 1
54; CHECK-NEXT:    [[TMP7:%.*]] = sub i8 0, [[MUL_RESULT]]
55; CHECK-NEXT:    [[TMP8:%.*]] = icmp slt i8 [[MUL_RESULT]], 0
56; CHECK-NEXT:    [[TMP9:%.*]] = icmp sgt i8 [[TMP7]], 0
57; CHECK-NEXT:    [[TMP10:%.*]] = select i1 [[TMP3]], i1 [[TMP9]], i1 [[TMP8]]
58; CHECK-NEXT:    [[TMP14:%.*]] = or i1 [[TMP10]], [[MUL_OVERFLOW]]
59; CHECK-NEXT:    [[TMP11:%.*]] = icmp ugt i64 [[TMP0]], 255
60; CHECK-NEXT:    [[TMP12:%.*]] = icmp ne i8 [[TMP1]], 0
61; CHECK-NEXT:    [[TMP13:%.*]] = and i1 [[TMP11]], [[TMP12]]
62; CHECK-NEXT:    [[TMP15:%.*]] = or i1 [[TMP14]], [[TMP13]]
63; CHECK-NEXT:    [[TMP17:%.*]] = sext i8 [[TMP1]] to i32
64; CHECK-NEXT:    [[IDENT_CHECK:%.*]] = icmp ne i32 [[STEP]], [[TMP17]]
65; CHECK-NEXT:    [[TMP18:%.*]] = or i1 [[TMP15]], [[IDENT_CHECK]]
66; CHECK-NEXT:    br i1 [[TMP18]], label [[SCALAR_PH]], label [[VECTOR_PH:%.*]]
67; CHECK:       vector.ph:
68; CHECK-NEXT:    [[N_MOD_VF:%.*]] = urem i64 [[WIDE_TRIP_COUNT]], 4
69; CHECK-NEXT:    [[N_VEC:%.*]] = sub i64 [[WIDE_TRIP_COUNT]], [[N_MOD_VF]]
70; CHECK-NEXT:    [[CAST_CRD:%.*]] = trunc i64 [[N_VEC]] to i32
71; CHECK-NEXT:    [[IND_END:%.*]] = mul i32 [[CAST_CRD]], [[STEP]]
72; CHECK-NEXT:    [[DOTSPLATINSERT:%.*]] = insertelement <4 x i32> poison, i32 [[STEP]], i32 0
73; CHECK-NEXT:    [[DOTSPLAT:%.*]] = shufflevector <4 x i32> [[DOTSPLATINSERT]], <4 x i32> poison, <4 x i32> zeroinitializer
74; CHECK-NEXT:    [[TMP19:%.*]] = mul <4 x i32> <i32 0, i32 1, i32 2, i32 3>, [[DOTSPLAT]]
75; CHECK-NEXT:    [[INDUCTION:%.*]] = add <4 x i32> zeroinitializer, [[TMP19]]
76; CHECK-NEXT:    [[TMP20:%.*]] = mul i32 [[STEP]], 4
77; CHECK-NEXT:    [[DOTSPLATINSERT2:%.*]] = insertelement <4 x i32> poison, i32 [[TMP20]], i32 0
78; CHECK-NEXT:    [[DOTSPLAT3:%.*]] = shufflevector <4 x i32> [[DOTSPLATINSERT2]], <4 x i32> poison, <4 x i32> zeroinitializer
79; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
80; CHECK:       vector.body:
81; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
82; CHECK-NEXT:    [[VEC_IND:%.*]] = phi <4 x i32> [ [[INDUCTION]], [[VECTOR_PH]] ], [ [[VEC_IND_NEXT:%.*]], [[VECTOR_BODY]] ]
83; CHECK-NEXT:    [[TMP21:%.*]] = add i64 [[INDEX]], 0
84; CHECK-NEXT:    [[TMP22:%.*]] = getelementptr inbounds [250 x i32], [250 x i32]* @a, i64 0, i64 [[TMP21]]
85; CHECK-NEXT:    [[TMP23:%.*]] = getelementptr inbounds i32, i32* [[TMP22]], i32 0
86; CHECK-NEXT:    [[TMP24:%.*]] = bitcast i32* [[TMP23]] to <4 x i32>*
87; CHECK-NEXT:    store <4 x i32> [[VEC_IND]], <4 x i32>* [[TMP24]], align 4
88; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 4
89; CHECK-NEXT:    [[VEC_IND_NEXT]] = add <4 x i32> [[VEC_IND]], [[DOTSPLAT3]]
90; CHECK-NEXT:    [[TMP25:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]]
91; CHECK-NEXT:    br i1 [[TMP25]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP0:![0-9]+]]
92; CHECK:       middle.block:
93; CHECK-NEXT:    [[CMP_N:%.*]] = icmp eq i64 [[WIDE_TRIP_COUNT]], [[N_VEC]]
94; CHECK-NEXT:    br i1 [[CMP_N]], label [[FOR_END_LOOPEXIT:%.*]], label [[SCALAR_PH]]
95; CHECK:       scalar.ph:
96; CHECK-NEXT:    [[BC_RESUME_VAL:%.*]] = phi i64 [ [[N_VEC]], [[MIDDLE_BLOCK]] ], [ 0, [[FOR_BODY_PREHEADER]] ], [ 0, [[VECTOR_SCEVCHECK]] ]
97; CHECK-NEXT:    [[BC_RESUME_VAL1:%.*]] = phi i32 [ [[IND_END]], [[MIDDLE_BLOCK]] ], [ 0, [[FOR_BODY_PREHEADER]] ], [ 0, [[VECTOR_SCEVCHECK]] ]
98; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
99; CHECK:       for.body:
100; CHECK-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_BODY]] ], [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ]
101; CHECK-NEXT:    [[P_09:%.*]] = phi i32 [ [[ADD:%.*]], [[FOR_BODY]] ], [ [[BC_RESUME_VAL1]], [[SCALAR_PH]] ]
102; CHECK-NEXT:    [[SEXT:%.*]] = shl i32 [[P_09]], 24
103; CHECK-NEXT:    [[CONV:%.*]] = ashr exact i32 [[SEXT]], 24
104; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [250 x i32], [250 x i32]* @a, i64 0, i64 [[INDVARS_IV]]
105; CHECK-NEXT:    store i32 [[CONV]], i32* [[ARRAYIDX]], align 4
106; CHECK-NEXT:    [[ADD]] = add nsw i32 [[CONV]], [[STEP]]
107; CHECK-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 1
108; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], [[WIDE_TRIP_COUNT]]
109; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_END_LOOPEXIT]], label [[FOR_BODY]], !llvm.loop [[LOOP2:![0-9]+]]
110; CHECK:       for.end.loopexit:
111; CHECK-NEXT:    br label [[FOR_END]]
112; CHECK:       for.end:
113; CHECK-NEXT:    ret void
114;
115entry:
116  %cmp7 = icmp sgt i32 %n, 0
117  br i1 %cmp7, label %for.body.preheader, label %for.end
118
119for.body.preheader:
120  %wide.trip.count = zext i32 %n to i64
121  br label %for.body
122
123for.body:
124  %indvars.iv = phi i64 [ %indvars.iv.next, %for.body ], [ 0, %for.body.preheader ]
125  %p.09 = phi i32 [ %add, %for.body ], [ 0, %for.body.preheader ]
126  %sext = shl i32 %p.09, 24
127  %conv = ashr exact i32 %sext, 24
128  %arrayidx = getelementptr inbounds [250 x i32], [250 x i32]* @a, i64 0, i64 %indvars.iv
129  store i32 %conv, i32* %arrayidx, align 4
130  %add = add nsw i32 %conv, %step
131  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
132  %exitcond = icmp eq i64 %indvars.iv.next, %wide.trip.count
133  br i1 %exitcond, label %for.end.loopexit, label %for.body
134
135for.end.loopexit:
136  br label %for.end
137
138for.end:
139  ret void
140}
141
142; Same as above, but for checking the SCEV "zext(trunc(%p.09)) + %step".
143; Here we expect the following two predicates to be added for runtime checking:
144; 1) {0,+,(trunc i32 %step to i8)}<%for.body> Added Flags: <nusw>
145; 2) Equal predicate: %step == (sext i8 (trunc i32 %step to i8) to i32)
146;
147; int a[N];
148; void doit2(int n, int step) {
149;   int i;
150;   unsigned char p = 0;
151;   for (i = 0; i < n; i++) {
152;      a[i] = p;
153;      p = p + step;
154;   }
155; }
156;
157
158
159; Function Attrs: norecurse nounwind uwtable
160define void @doit2(i32 %n, i32 %step) local_unnamed_addr  {
161; CHECK-LABEL: @doit2(
162; CHECK-NEXT:  entry:
163; CHECK-NEXT:    [[CMP7:%.*]] = icmp sgt i32 [[N:%.*]], 0
164; CHECK-NEXT:    br i1 [[CMP7]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_END:%.*]]
165; CHECK:       for.body.preheader:
166; CHECK-NEXT:    [[WIDE_TRIP_COUNT:%.*]] = zext i32 [[N]] to i64
167; CHECK-NEXT:    [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[WIDE_TRIP_COUNT]], 4
168; CHECK-NEXT:    br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_SCEVCHECK:%.*]]
169; CHECK:       vector.scevcheck:
170; CHECK-NEXT:    [[TMP0:%.*]] = add nsw i64 [[WIDE_TRIP_COUNT]], -1
171; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[STEP:%.*]] to i8
172; CHECK-NEXT:    [[TMP2:%.*]] = sub i8 0, [[TMP1]]
173; CHECK-NEXT:    [[TMP3:%.*]] = icmp slt i8 [[TMP1]], 0
174; CHECK-NEXT:    [[TMP4:%.*]] = select i1 [[TMP3]], i8 [[TMP2]], i8 [[TMP1]]
175; CHECK-NEXT:    [[TMP5:%.*]] = trunc i64 [[TMP0]] to i8
176; CHECK-NEXT:    [[MUL:%.*]] = call { i8, i1 } @llvm.umul.with.overflow.i8(i8 [[TMP4]], i8 [[TMP5]])
177; CHECK-NEXT:    [[MUL_RESULT:%.*]] = extractvalue { i8, i1 } [[MUL]], 0
178; CHECK-NEXT:    [[MUL_OVERFLOW:%.*]] = extractvalue { i8, i1 } [[MUL]], 1
179; CHECK-NEXT:    [[TMP7:%.*]] = sub i8 0, [[MUL_RESULT]]
180; CHECK-NEXT:    [[TMP9:%.*]] = icmp ugt i8 [[TMP7]], 0
181; CHECK-NEXT:    [[TMP10:%.*]] = select i1 [[TMP3]], i1 [[TMP9]], i1 false
182; CHECK-NEXT:    [[TMP14:%.*]] = or i1 [[TMP10]], [[MUL_OVERFLOW]]
183; CHECK-NEXT:    [[TMP11:%.*]] = icmp ugt i64 [[TMP0]], 255
184; CHECK-NEXT:    [[TMP12:%.*]] = icmp ne i8 [[TMP1]], 0
185; CHECK-NEXT:    [[TMP13:%.*]] = and i1 [[TMP11]], [[TMP12]]
186; CHECK-NEXT:    [[TMP15:%.*]] = or i1 [[TMP14]], [[TMP13]]
187; CHECK-NEXT:    [[TMP17:%.*]] = sext i8 [[TMP1]] to i32
188; CHECK-NEXT:    [[IDENT_CHECK:%.*]] = icmp ne i32 [[STEP]], [[TMP17]]
189; CHECK-NEXT:    [[TMP18:%.*]] = or i1 [[TMP15]], [[IDENT_CHECK]]
190; CHECK-NEXT:    br i1 [[TMP18]], label [[SCALAR_PH]], label [[VECTOR_PH:%.*]]
191; CHECK:       vector.ph:
192; CHECK-NEXT:    [[N_MOD_VF:%.*]] = urem i64 [[WIDE_TRIP_COUNT]], 4
193; CHECK-NEXT:    [[N_VEC:%.*]] = sub i64 [[WIDE_TRIP_COUNT]], [[N_MOD_VF]]
194; CHECK-NEXT:    [[CAST_CRD:%.*]] = trunc i64 [[N_VEC]] to i32
195; CHECK-NEXT:    [[IND_END:%.*]] = mul i32 [[CAST_CRD]], [[STEP]]
196; CHECK-NEXT:    [[DOTSPLATINSERT:%.*]] = insertelement <4 x i32> poison, i32 [[STEP]], i32 0
197; CHECK-NEXT:    [[DOTSPLAT:%.*]] = shufflevector <4 x i32> [[DOTSPLATINSERT]], <4 x i32> poison, <4 x i32> zeroinitializer
198; CHECK-NEXT:    [[TMP19:%.*]] = mul <4 x i32> <i32 0, i32 1, i32 2, i32 3>, [[DOTSPLAT]]
199; CHECK-NEXT:    [[INDUCTION:%.*]] = add <4 x i32> zeroinitializer, [[TMP19]]
200; CHECK-NEXT:    [[TMP20:%.*]] = mul i32 [[STEP]], 4
201; CHECK-NEXT:    [[DOTSPLATINSERT2:%.*]] = insertelement <4 x i32> poison, i32 [[TMP20]], i32 0
202; CHECK-NEXT:    [[DOTSPLAT3:%.*]] = shufflevector <4 x i32> [[DOTSPLATINSERT2]], <4 x i32> poison, <4 x i32> zeroinitializer
203; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
204; CHECK:       vector.body:
205; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
206; CHECK-NEXT:    [[VEC_IND:%.*]] = phi <4 x i32> [ [[INDUCTION]], [[VECTOR_PH]] ], [ [[VEC_IND_NEXT:%.*]], [[VECTOR_BODY]] ]
207; CHECK-NEXT:    [[TMP21:%.*]] = add i64 [[INDEX]], 0
208; CHECK-NEXT:    [[TMP22:%.*]] = getelementptr inbounds [250 x i32], [250 x i32]* @a, i64 0, i64 [[TMP21]]
209; CHECK-NEXT:    [[TMP23:%.*]] = getelementptr inbounds i32, i32* [[TMP22]], i32 0
210; CHECK-NEXT:    [[TMP24:%.*]] = bitcast i32* [[TMP23]] to <4 x i32>*
211; CHECK-NEXT:    store <4 x i32> [[VEC_IND]], <4 x i32>* [[TMP24]], align 4
212; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 4
213; CHECK-NEXT:    [[VEC_IND_NEXT]] = add <4 x i32> [[VEC_IND]], [[DOTSPLAT3]]
214; CHECK-NEXT:    [[TMP25:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]]
215; CHECK-NEXT:    br i1 [[TMP25]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP3:![0-9]+]]
216; CHECK:       middle.block:
217; CHECK-NEXT:    [[CMP_N:%.*]] = icmp eq i64 [[WIDE_TRIP_COUNT]], [[N_VEC]]
218; CHECK-NEXT:    br i1 [[CMP_N]], label [[FOR_END_LOOPEXIT:%.*]], label [[SCALAR_PH]]
219; CHECK:       scalar.ph:
220; CHECK-NEXT:    [[BC_RESUME_VAL:%.*]] = phi i64 [ [[N_VEC]], [[MIDDLE_BLOCK]] ], [ 0, [[FOR_BODY_PREHEADER]] ], [ 0, [[VECTOR_SCEVCHECK]] ]
221; CHECK-NEXT:    [[BC_RESUME_VAL1:%.*]] = phi i32 [ [[IND_END]], [[MIDDLE_BLOCK]] ], [ 0, [[FOR_BODY_PREHEADER]] ], [ 0, [[VECTOR_SCEVCHECK]] ]
222; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
223; CHECK:       for.body:
224; CHECK-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_BODY]] ], [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ]
225; CHECK-NEXT:    [[P_09:%.*]] = phi i32 [ [[ADD:%.*]], [[FOR_BODY]] ], [ [[BC_RESUME_VAL1]], [[SCALAR_PH]] ]
226; CHECK-NEXT:    [[CONV:%.*]] = and i32 [[P_09]], 255
227; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [250 x i32], [250 x i32]* @a, i64 0, i64 [[INDVARS_IV]]
228; CHECK-NEXT:    store i32 [[CONV]], i32* [[ARRAYIDX]], align 4
229; CHECK-NEXT:    [[ADD]] = add nsw i32 [[CONV]], [[STEP]]
230; CHECK-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 1
231; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], [[WIDE_TRIP_COUNT]]
232; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_END_LOOPEXIT]], label [[FOR_BODY]], !llvm.loop [[LOOP4:![0-9]+]]
233; CHECK:       for.end.loopexit:
234; CHECK-NEXT:    br label [[FOR_END]]
235; CHECK:       for.end:
236; CHECK-NEXT:    ret void
237;
238entry:
239  %cmp7 = icmp sgt i32 %n, 0
240  br i1 %cmp7, label %for.body.preheader, label %for.end
241
242for.body.preheader:
243  %wide.trip.count = zext i32 %n to i64
244  br label %for.body
245
246for.body:
247  %indvars.iv = phi i64 [ %indvars.iv.next, %for.body ], [ 0, %for.body.preheader ]
248  %p.09 = phi i32 [ %add, %for.body ], [ 0, %for.body.preheader ]
249  %conv = and i32 %p.09, 255
250  %arrayidx = getelementptr inbounds [250 x i32], [250 x i32]* @a, i64 0, i64 %indvars.iv
251  store i32 %conv, i32* %arrayidx, align 4
252  %add = add nsw i32 %conv, %step
253  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
254  %exitcond = icmp eq i64 %indvars.iv.next, %wide.trip.count
255  br i1 %exitcond, label %for.end.loopexit, label %for.body
256
257for.end.loopexit:
258  br label %for.end
259
260for.end:
261  ret void
262}
263
264; Here we check that the same phi scev analysis would fail
265; to create the runtime checks because the step is not invariant.
266; As a result vectorization will fail.
267;
268; int a[N];
269; void doit3(int n, int step) {
270;   int i;
271;   char p = 0;
272;   for (i = 0; i < n; i++) {
273;      a[i] = p;
274;      p = p + step;
275;      step += 2;
276;   }
277; }
278;
279
280
281; Function Attrs: norecurse nounwind uwtable
282define void @doit3(i32 %n, i32 %step) local_unnamed_addr {
283; CHECK-LABEL: @doit3(
284; CHECK-NEXT:  entry:
285; CHECK-NEXT:    [[CMP9:%.*]] = icmp sgt i32 [[N:%.*]], 0
286; CHECK-NEXT:    br i1 [[CMP9]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_END:%.*]]
287; CHECK:       for.body.preheader:
288; CHECK-NEXT:    [[WIDE_TRIP_COUNT:%.*]] = zext i32 [[N]] to i64
289; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
290; CHECK:       for.body:
291; CHECK-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_BODY]] ], [ 0, [[FOR_BODY_PREHEADER]] ]
292; CHECK-NEXT:    [[P_012:%.*]] = phi i32 [ [[ADD:%.*]], [[FOR_BODY]] ], [ 0, [[FOR_BODY_PREHEADER]] ]
293; CHECK-NEXT:    [[STEP_ADDR_010:%.*]] = phi i32 [ [[ADD3:%.*]], [[FOR_BODY]] ], [ [[STEP:%.*]], [[FOR_BODY_PREHEADER]] ]
294; CHECK-NEXT:    [[SEXT:%.*]] = shl i32 [[P_012]], 24
295; CHECK-NEXT:    [[CONV:%.*]] = ashr exact i32 [[SEXT]], 24
296; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [250 x i32], [250 x i32]* @a, i64 0, i64 [[INDVARS_IV]]
297; CHECK-NEXT:    store i32 [[CONV]], i32* [[ARRAYIDX]], align 4
298; CHECK-NEXT:    [[ADD]] = add nsw i32 [[CONV]], [[STEP_ADDR_010]]
299; CHECK-NEXT:    [[ADD3]] = add nsw i32 [[STEP_ADDR_010]], 2
300; CHECK-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 1
301; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], [[WIDE_TRIP_COUNT]]
302; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_END_LOOPEXIT:%.*]], label [[FOR_BODY]]
303; CHECK:       for.end.loopexit:
304; CHECK-NEXT:    br label [[FOR_END]]
305; CHECK:       for.end:
306; CHECK-NEXT:    ret void
307;
308entry:
309  %cmp9 = icmp sgt i32 %n, 0
310  br i1 %cmp9, label %for.body.preheader, label %for.end
311
312for.body.preheader:
313  %wide.trip.count = zext i32 %n to i64
314  br label %for.body
315
316for.body:
317  %indvars.iv = phi i64 [ %indvars.iv.next, %for.body ], [ 0, %for.body.preheader ]
318  %p.012 = phi i32 [ %add, %for.body ], [ 0, %for.body.preheader ]
319  %step.addr.010 = phi i32 [ %add3, %for.body ], [ %step, %for.body.preheader ]
320  %sext = shl i32 %p.012, 24
321  %conv = ashr exact i32 %sext, 24
322  %arrayidx = getelementptr inbounds [250 x i32], [250 x i32]* @a, i64 0, i64 %indvars.iv
323  store i32 %conv, i32* %arrayidx, align 4
324  %add = add nsw i32 %conv, %step.addr.010
325  %add3 = add nsw i32 %step.addr.010, 2
326  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
327  %exitcond = icmp eq i64 %indvars.iv.next, %wide.trip.count
328  br i1 %exitcond, label %for.end.loopexit, label %for.body
329
330for.end.loopexit:
331  br label %for.end
332
333for.end:
334  ret void
335}
336
337
338; Lastly, we also check the case where we can tell at compile time that
339; the step of the induction is equal to sext(trunc(step)), in which case
340; we don't have to check this equality at runtime (we only need the
341; runtime overflow check). Therefore only the following overflow predicate
342; will be added for runtime checking:
343; {0,+,%cstep}<%for.body> Added Flags: <nssw>
344;
345; a[N];
346; void doit4(int n, char cstep) {
347;   int i;
348;   char p = 0;
349;   int istep = cstep;
350;  for (i = 0; i < n; i++) {
351;      a[i] = p;
352;      p = p + istep;
353;   }
354; }
355
356
357; Function Attrs: norecurse nounwind uwtable
358define void @doit4(i32 %n, i8 signext %cstep) local_unnamed_addr {
359; CHECK-LABEL: @doit4(
360; CHECK-NEXT:  entry:
361; CHECK-NEXT:    [[CONV:%.*]] = sext i8 [[CSTEP:%.*]] to i32
362; CHECK-NEXT:    [[CMP10:%.*]] = icmp sgt i32 [[N:%.*]], 0
363; CHECK-NEXT:    br i1 [[CMP10]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_END:%.*]]
364; CHECK:       for.body.preheader:
365; CHECK-NEXT:    [[WIDE_TRIP_COUNT:%.*]] = zext i32 [[N]] to i64
366; CHECK-NEXT:    [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[WIDE_TRIP_COUNT]], 4
367; CHECK-NEXT:    br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_SCEVCHECK:%.*]]
368; CHECK:       vector.scevcheck:
369; CHECK-NEXT:    [[TMP0:%.*]] = add nsw i64 [[WIDE_TRIP_COUNT]], -1
370; CHECK-NEXT:    [[TMP1:%.*]] = sub i8 0, [[CSTEP]]
371; CHECK-NEXT:    [[TMP2:%.*]] = icmp slt i8 [[CSTEP]], 0
372; CHECK-NEXT:    [[TMP3:%.*]] = select i1 [[TMP2]], i8 [[TMP1]], i8 [[CSTEP]]
373; CHECK-NEXT:    [[TMP4:%.*]] = trunc i64 [[TMP0]] to i8
374; CHECK-NEXT:    [[MUL:%.*]] = call { i8, i1 } @llvm.umul.with.overflow.i8(i8 [[TMP3]], i8 [[TMP4]])
375; CHECK-NEXT:    [[MUL_RESULT:%.*]] = extractvalue { i8, i1 } [[MUL]], 0
376; CHECK-NEXT:    [[MUL_OVERFLOW:%.*]] = extractvalue { i8, i1 } [[MUL]], 1
377; CHECK-NEXT:    [[TMP6:%.*]] = sub i8 0, [[MUL_RESULT]]
378; CHECK-NEXT:    [[TMP7:%.*]] = icmp slt i8 [[MUL_RESULT]], 0
379; CHECK-NEXT:    [[TMP8:%.*]] = icmp sgt i8 [[TMP6]], 0
380; CHECK-NEXT:    [[TMP9:%.*]] = select i1 [[TMP2]], i1 [[TMP8]], i1 [[TMP7]]
381; CHECK-NEXT:    [[TMP13:%.*]] = or i1 [[TMP9]], [[MUL_OVERFLOW]]
382; CHECK-NEXT:    [[TMP10:%.*]] = icmp ugt i64 [[TMP0]], 255
383; CHECK-NEXT:    [[TMP11:%.*]] = icmp ne i8 [[CSTEP]], 0
384; CHECK-NEXT:    [[TMP12:%.*]] = and i1 [[TMP10]], [[TMP11]]
385; CHECK-NEXT:    [[TMP14:%.*]] = or i1 [[TMP13]], [[TMP12]]
386; CHECK-NEXT:    br i1 [[TMP14]], label [[SCALAR_PH]], label [[VECTOR_PH:%.*]]
387; CHECK:       vector.ph:
388; CHECK-NEXT:    [[N_MOD_VF:%.*]] = urem i64 [[WIDE_TRIP_COUNT]], 4
389; CHECK-NEXT:    [[N_VEC:%.*]] = sub i64 [[WIDE_TRIP_COUNT]], [[N_MOD_VF]]
390; CHECK-NEXT:    [[CAST_CRD:%.*]] = trunc i64 [[N_VEC]] to i32
391; CHECK-NEXT:    [[IND_END:%.*]] = mul i32 [[CAST_CRD]], [[CONV]]
392; CHECK-NEXT:    [[DOTSPLATINSERT:%.*]] = insertelement <4 x i32> poison, i32 [[CONV]], i32 0
393; CHECK-NEXT:    [[DOTSPLAT:%.*]] = shufflevector <4 x i32> [[DOTSPLATINSERT]], <4 x i32> poison, <4 x i32> zeroinitializer
394; CHECK-NEXT:    [[TMP16:%.*]] = mul <4 x i32> <i32 0, i32 1, i32 2, i32 3>, [[DOTSPLAT]]
395; CHECK-NEXT:    [[INDUCTION:%.*]] = add <4 x i32> zeroinitializer, [[TMP16]]
396; CHECK-NEXT:    [[TMP17:%.*]] = mul i32 [[CONV]], 4
397; CHECK-NEXT:    [[DOTSPLATINSERT2:%.*]] = insertelement <4 x i32> poison, i32 [[TMP17]], i32 0
398; CHECK-NEXT:    [[DOTSPLAT3:%.*]] = shufflevector <4 x i32> [[DOTSPLATINSERT2]], <4 x i32> poison, <4 x i32> zeroinitializer
399; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
400; CHECK:       vector.body:
401; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
402; CHECK-NEXT:    [[VEC_IND:%.*]] = phi <4 x i32> [ [[INDUCTION]], [[VECTOR_PH]] ], [ [[VEC_IND_NEXT:%.*]], [[VECTOR_BODY]] ]
403; CHECK-NEXT:    [[TMP18:%.*]] = add i64 [[INDEX]], 0
404; CHECK-NEXT:    [[TMP19:%.*]] = getelementptr inbounds [250 x i32], [250 x i32]* @a, i64 0, i64 [[TMP18]]
405; CHECK-NEXT:    [[TMP20:%.*]] = getelementptr inbounds i32, i32* [[TMP19]], i32 0
406; CHECK-NEXT:    [[TMP21:%.*]] = bitcast i32* [[TMP20]] to <4 x i32>*
407; CHECK-NEXT:    store <4 x i32> [[VEC_IND]], <4 x i32>* [[TMP21]], align 4
408; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 4
409; CHECK-NEXT:    [[VEC_IND_NEXT]] = add <4 x i32> [[VEC_IND]], [[DOTSPLAT3]]
410; CHECK-NEXT:    [[TMP22:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]]
411; CHECK-NEXT:    br i1 [[TMP22]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP5:![0-9]+]]
412; CHECK:       middle.block:
413; CHECK-NEXT:    [[CMP_N:%.*]] = icmp eq i64 [[WIDE_TRIP_COUNT]], [[N_VEC]]
414; CHECK-NEXT:    br i1 [[CMP_N]], label [[FOR_END_LOOPEXIT:%.*]], label [[SCALAR_PH]]
415; CHECK:       scalar.ph:
416; CHECK-NEXT:    [[BC_RESUME_VAL:%.*]] = phi i64 [ [[N_VEC]], [[MIDDLE_BLOCK]] ], [ 0, [[FOR_BODY_PREHEADER]] ], [ 0, [[VECTOR_SCEVCHECK]] ]
417; CHECK-NEXT:    [[BC_RESUME_VAL1:%.*]] = phi i32 [ [[IND_END]], [[MIDDLE_BLOCK]] ], [ 0, [[FOR_BODY_PREHEADER]] ], [ 0, [[VECTOR_SCEVCHECK]] ]
418; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
419; CHECK:       for.body:
420; CHECK-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_BODY]] ], [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ]
421; CHECK-NEXT:    [[P_011:%.*]] = phi i32 [ [[ADD:%.*]], [[FOR_BODY]] ], [ [[BC_RESUME_VAL1]], [[SCALAR_PH]] ]
422; CHECK-NEXT:    [[SEXT:%.*]] = shl i32 [[P_011]], 24
423; CHECK-NEXT:    [[CONV2:%.*]] = ashr exact i32 [[SEXT]], 24
424; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [250 x i32], [250 x i32]* @a, i64 0, i64 [[INDVARS_IV]]
425; CHECK-NEXT:    store i32 [[CONV2]], i32* [[ARRAYIDX]], align 4
426; CHECK-NEXT:    [[ADD]] = add nsw i32 [[CONV2]], [[CONV]]
427; CHECK-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 1
428; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], [[WIDE_TRIP_COUNT]]
429; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_END_LOOPEXIT]], label [[FOR_BODY]], !llvm.loop [[LOOP6:![0-9]+]]
430; CHECK:       for.end.loopexit:
431; CHECK-NEXT:    br label [[FOR_END]]
432; CHECK:       for.end:
433; CHECK-NEXT:    ret void
434;
435entry:
436  %conv = sext i8 %cstep to i32
437  %cmp10 = icmp sgt i32 %n, 0
438  br i1 %cmp10, label %for.body.preheader, label %for.end
439
440for.body.preheader:
441  %wide.trip.count = zext i32 %n to i64
442  br label %for.body
443
444for.body:
445  %indvars.iv = phi i64 [ %indvars.iv.next, %for.body ], [ 0, %for.body.preheader ]
446  %p.011 = phi i32 [ %add, %for.body ], [ 0, %for.body.preheader ]
447  %sext = shl i32 %p.011, 24
448  %conv2 = ashr exact i32 %sext, 24
449  %arrayidx = getelementptr inbounds [250 x i32], [250 x i32]* @a, i64 0, i64 %indvars.iv
450  store i32 %conv2, i32* %arrayidx, align 4
451  %add = add nsw i32 %conv2, %conv
452  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
453  %exitcond = icmp eq i64 %indvars.iv.next, %wide.trip.count
454  br i1 %exitcond, label %for.end.loopexit, label %for.body
455
456for.end.loopexit:
457  br label %for.end
458
459for.end:
460  ret void
461}
462