xref: /llvm-project/llvm/test/Analysis/DependenceAnalysis/ExactSIV.ll (revision 46f9cddfd7e40998422d1e34a3f1193210ee2fb8) 
1; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
2; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
3; RUN: | 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"
6target triple = "x86_64-apple-macosx10.6.0"
7
8
9;;  for (long unsigned i = 0; i < 10; i++) {
10;;    A[i + 10] = i;
11;;    *B++ = A[2*i + 1];
12
13define void @exact0(ptr %A, ptr %B) nounwind uwtable ssp {
14; CHECK-LABEL: 'exact0'
15; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
16; CHECK-NEXT:    da analyze - none!
17; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
18; CHECK-NEXT:    da analyze - flow [<=|<]!
19; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
20; CHECK-NEXT:    da analyze - confused!
21; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
22; CHECK-NEXT:    da analyze - none!
23; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
24; CHECK-NEXT:    da analyze - confused!
25; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
26; CHECK-NEXT:    da analyze - none!
27;
28entry:
29  br label %for.body
30
31for.body:                                         ; preds = %entry, %for.body
32  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
33  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
34  %conv = trunc i64 %i.02 to i32
35  %add = add i64 %i.02, 10
36  %arrayidx = getelementptr inbounds i32, ptr %A, i64 %add
37  store i32 %conv, ptr %arrayidx, align 4
38  %mul = shl i64 %i.02, 1
39  %add13 = or disjoint i64 %mul, 1
40  %arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %add13
41  %0 = load i32, ptr %arrayidx2, align 4
42  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
43  store i32 %0, ptr %B.addr.01, align 4
44  %inc = add i64 %i.02, 1
45  %exitcond = icmp ne i64 %inc, 10
46  br i1 %exitcond, label %for.body, label %for.end
47
48for.end:                                          ; preds = %for.body
49  ret void
50}
51
52
53;;  for (long unsigned i = 0; i < 10; i++) {
54;;    A[4*i + 10] = i;
55;;    *B++ = A[2*i + 1];
56
57define void @exact1(ptr %A, ptr %B) nounwind uwtable ssp {
58; CHECK-LABEL: 'exact1'
59; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
60; CHECK-NEXT:    da analyze - none!
61; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx3, align 4
62; CHECK-NEXT:    da analyze - none!
63; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
64; CHECK-NEXT:    da analyze - confused!
65; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx3, align 4 --> Dst: %0 = load i32, ptr %arrayidx3, align 4
66; CHECK-NEXT:    da analyze - none!
67; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx3, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
68; CHECK-NEXT:    da analyze - confused!
69; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
70; CHECK-NEXT:    da analyze - none!
71;
72entry:
73  br label %for.body
74
75for.body:                                         ; preds = %entry, %for.body
76  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
77  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
78  %conv = trunc i64 %i.02 to i32
79  %mul = shl i64 %i.02, 2
80  %add = add i64 %mul, 10
81  %arrayidx = getelementptr inbounds i32, ptr %A, i64 %add
82  store i32 %conv, ptr %arrayidx, align 4
83  %mul1 = shl i64 %i.02, 1
84  %add23 = or disjoint i64 %mul1, 1
85  %arrayidx3 = getelementptr inbounds i32, ptr %A, i64 %add23
86  %0 = load i32, ptr %arrayidx3, align 4
87  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
88  store i32 %0, ptr %B.addr.01, align 4
89  %inc = add i64 %i.02, 1
90  %exitcond = icmp ne i64 %inc, 10
91  br i1 %exitcond, label %for.body, label %for.end
92
93for.end:                                          ; preds = %for.body
94  ret void
95}
96
97
98;;  for (long unsigned i = 0; i < 10; i++) {
99;;    A[6*i] = i;
100;;    *B++ = A[i + 60];
101
102define void @exact2(ptr %A, ptr %B) nounwind uwtable ssp {
103; CHECK-LABEL: 'exact2'
104; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
105; CHECK-NEXT:    da analyze - none!
106; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
107; CHECK-NEXT:    da analyze - none!
108; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
109; CHECK-NEXT:    da analyze - confused!
110; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
111; CHECK-NEXT:    da analyze - none!
112; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
113; CHECK-NEXT:    da analyze - confused!
114; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
115; CHECK-NEXT:    da analyze - none!
116;
117entry:
118  br label %for.body
119
120for.body:                                         ; preds = %entry, %for.body
121  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
122  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
123  %conv = trunc i64 %i.02 to i32
124  %mul = mul i64 %i.02, 6
125  %arrayidx = getelementptr inbounds i32, ptr %A, i64 %mul
126  store i32 %conv, ptr %arrayidx, align 4
127  %add = add i64 %i.02, 60
128  %arrayidx1 = getelementptr inbounds i32, ptr %A, i64 %add
129  %0 = load i32, ptr %arrayidx1, align 4
130  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
131  store i32 %0, ptr %B.addr.01, align 4
132  %inc = add i64 %i.02, 1
133  %exitcond = icmp ne i64 %inc, 10
134  br i1 %exitcond, label %for.body, label %for.end
135
136for.end:                                          ; preds = %for.body
137  ret void
138}
139
140
141;;  for (long unsigned i = 0; i <= 10; i++) {
142;;    A[6*i] = i;
143;;    *B++ = A[i + 60];
144
145define void @exact3(ptr %A, ptr %B) nounwind uwtable ssp {
146; CHECK-LABEL: 'exact3'
147; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
148; CHECK-NEXT:    da analyze - none!
149; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
150; CHECK-NEXT:    da analyze - flow [>]!
151; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
152; CHECK-NEXT:    da analyze - confused!
153; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
154; CHECK-NEXT:    da analyze - none!
155; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
156; CHECK-NEXT:    da analyze - confused!
157; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
158; CHECK-NEXT:    da analyze - none!
159;
160entry:
161  br label %for.body
162
163for.body:                                         ; preds = %entry, %for.body
164  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
165  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
166  %conv = trunc i64 %i.02 to i32
167  %mul = mul i64 %i.02, 6
168  %arrayidx = getelementptr inbounds i32, ptr %A, i64 %mul
169  store i32 %conv, ptr %arrayidx, align 4
170  %add = add i64 %i.02, 60
171  %arrayidx1 = getelementptr inbounds i32, ptr %A, i64 %add
172  %0 = load i32, ptr %arrayidx1, align 4
173  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
174  store i32 %0, ptr %B.addr.01, align 4
175  %inc = add i64 %i.02, 1
176  %exitcond = icmp ne i64 %inc, 11
177  br i1 %exitcond, label %for.body, label %for.end
178
179for.end:                                          ; preds = %for.body
180  ret void
181}
182
183
184;;  for (long unsigned i = 0; i < 12; i++) {
185;;    A[6*i] = i;
186;;    *B++ = A[i + 60];
187
188define void @exact4(ptr %A, ptr %B) nounwind uwtable ssp {
189; CHECK-LABEL: 'exact4'
190; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
191; CHECK-NEXT:    da analyze - none!
192; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
193; CHECK-NEXT:    da analyze - flow [>]!
194; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
195; CHECK-NEXT:    da analyze - confused!
196; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
197; CHECK-NEXT:    da analyze - none!
198; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
199; CHECK-NEXT:    da analyze - confused!
200; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
201; CHECK-NEXT:    da analyze - none!
202;
203entry:
204  br label %for.body
205
206for.body:                                         ; preds = %entry, %for.body
207  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
208  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
209  %conv = trunc i64 %i.02 to i32
210  %mul = mul i64 %i.02, 6
211  %arrayidx = getelementptr inbounds i32, ptr %A, i64 %mul
212  store i32 %conv, ptr %arrayidx, align 4
213  %add = add i64 %i.02, 60
214  %arrayidx1 = getelementptr inbounds i32, ptr %A, i64 %add
215  %0 = load i32, ptr %arrayidx1, align 4
216  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
217  store i32 %0, ptr %B.addr.01, align 4
218  %inc = add i64 %i.02, 1
219  %exitcond = icmp ne i64 %inc, 12
220  br i1 %exitcond, label %for.body, label %for.end
221
222for.end:                                          ; preds = %for.body
223  ret void
224}
225
226
227;;  for (long unsigned i = 0; i <= 12; i++) {
228;;    A[6*i] = i;
229;;    *B++ = A[i + 60];
230
231define void @exact5(ptr %A, ptr %B) nounwind uwtable ssp {
232; CHECK-LABEL: 'exact5'
233; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
234; CHECK-NEXT:    da analyze - none!
235; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
236; CHECK-NEXT:    da analyze - flow [=>|<]!
237; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
238; CHECK-NEXT:    da analyze - confused!
239; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
240; CHECK-NEXT:    da analyze - none!
241; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
242; CHECK-NEXT:    da analyze - confused!
243; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
244; CHECK-NEXT:    da analyze - none!
245;
246entry:
247  br label %for.body
248
249for.body:                                         ; preds = %entry, %for.body
250  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
251  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
252  %conv = trunc i64 %i.02 to i32
253  %mul = mul i64 %i.02, 6
254  %arrayidx = getelementptr inbounds i32, ptr %A, i64 %mul
255  store i32 %conv, ptr %arrayidx, align 4
256  %add = add i64 %i.02, 60
257  %arrayidx1 = getelementptr inbounds i32, ptr %A, i64 %add
258  %0 = load i32, ptr %arrayidx1, align 4
259  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
260  store i32 %0, ptr %B.addr.01, align 4
261  %inc = add i64 %i.02, 1
262  %exitcond = icmp ne i64 %inc, 13
263  br i1 %exitcond, label %for.body, label %for.end
264
265for.end:                                          ; preds = %for.body
266  ret void
267}
268
269
270;;  for (long unsigned i = 0; i < 18; i++) {
271;;    A[6*i] = i;
272;;    *B++ = A[i + 60];
273
274define void @exact6(ptr %A, ptr %B) nounwind uwtable ssp {
275; CHECK-LABEL: 'exact6'
276; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
277; CHECK-NEXT:    da analyze - none!
278; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
279; CHECK-NEXT:    da analyze - flow [=>|<]!
280; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
281; CHECK-NEXT:    da analyze - confused!
282; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
283; CHECK-NEXT:    da analyze - none!
284; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
285; CHECK-NEXT:    da analyze - confused!
286; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
287; CHECK-NEXT:    da analyze - none!
288;
289entry:
290  br label %for.body
291
292for.body:                                         ; preds = %entry, %for.body
293  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
294  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
295  %conv = trunc i64 %i.02 to i32
296  %mul = mul i64 %i.02, 6
297  %arrayidx = getelementptr inbounds i32, ptr %A, i64 %mul
298  store i32 %conv, ptr %arrayidx, align 4
299  %add = add i64 %i.02, 60
300  %arrayidx1 = getelementptr inbounds i32, ptr %A, i64 %add
301  %0 = load i32, ptr %arrayidx1, align 4
302  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
303  store i32 %0, ptr %B.addr.01, align 4
304  %inc = add i64 %i.02, 1
305  %exitcond = icmp ne i64 %inc, 18
306  br i1 %exitcond, label %for.body, label %for.end
307
308for.end:                                          ; preds = %for.body
309  ret void
310}
311
312
313;;  for (long unsigned i = 0; i <= 18; i++) {
314;;    A[6*i] = i;
315;;    *B++ = A[i + 60];
316
317define void @exact7(ptr %A, ptr %B) nounwind uwtable ssp {
318; CHECK-LABEL: 'exact7'
319; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
320; CHECK-NEXT:    da analyze - none!
321; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
322; CHECK-NEXT:    da analyze - flow [*|<]!
323; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
324; CHECK-NEXT:    da analyze - confused!
325; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
326; CHECK-NEXT:    da analyze - none!
327; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
328; CHECK-NEXT:    da analyze - confused!
329; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
330; CHECK-NEXT:    da analyze - none!
331;
332entry:
333  br label %for.body
334
335for.body:                                         ; preds = %entry, %for.body
336  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
337  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
338  %conv = trunc i64 %i.02 to i32
339  %mul = mul i64 %i.02, 6
340  %arrayidx = getelementptr inbounds i32, ptr %A, i64 %mul
341  store i32 %conv, ptr %arrayidx, align 4
342  %add = add i64 %i.02, 60
343  %arrayidx1 = getelementptr inbounds i32, ptr %A, i64 %add
344  %0 = load i32, ptr %arrayidx1, align 4
345  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
346  store i32 %0, ptr %B.addr.01, align 4
347  %inc = add i64 %i.02, 1
348  %exitcond = icmp ne i64 %inc, 19
349  br i1 %exitcond, label %for.body, label %for.end
350
351for.end:                                          ; preds = %for.body
352  ret void
353}
354
355
356;;  for (long unsigned i = 0; i < 10; i++) {
357;;    A[-6*i] = i;
358;;    *B++ = A[-i - 60];
359
360define void @exact8(ptr %A, ptr %B) nounwind uwtable ssp {
361; CHECK-LABEL: 'exact8'
362; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
363; CHECK-NEXT:    da analyze - none!
364; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
365; CHECK-NEXT:    da analyze - none!
366; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
367; CHECK-NEXT:    da analyze - confused!
368; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
369; CHECK-NEXT:    da analyze - none!
370; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
371; CHECK-NEXT:    da analyze - confused!
372; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
373; CHECK-NEXT:    da analyze - none!
374;
375entry:
376  br label %for.body
377
378for.body:                                         ; preds = %entry, %for.body
379  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
380  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
381  %conv = trunc i64 %i.02 to i32
382  %mul = mul i64 %i.02, -6
383  %arrayidx = getelementptr inbounds i32, ptr %A, i64 %mul
384  store i32 %conv, ptr %arrayidx, align 4
385  %sub1 = sub i64 -60, %i.02
386  %arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %sub1
387  %0 = load i32, ptr %arrayidx2, align 4
388  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
389  store i32 %0, ptr %B.addr.01, align 4
390  %inc = add i64 %i.02, 1
391  %exitcond = icmp ne i64 %inc, 10
392  br i1 %exitcond, label %for.body, label %for.end
393
394for.end:                                          ; preds = %for.body
395  ret void
396}
397
398
399;;  for (long unsigned i = 0; i <= 10; i++) {
400;;    A[-6*i] = i;
401;;    *B++ = A[-i - 60];
402
403define void @exact9(ptr %A, ptr %B) nounwind uwtable ssp {
404; CHECK-LABEL: 'exact9'
405; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
406; CHECK-NEXT:    da analyze - none!
407; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
408; CHECK-NEXT:    da analyze - flow [>]!
409; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
410; CHECK-NEXT:    da analyze - confused!
411; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
412; CHECK-NEXT:    da analyze - none!
413; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
414; CHECK-NEXT:    da analyze - confused!
415; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
416; CHECK-NEXT:    da analyze - none!
417;
418entry:
419  br label %for.body
420
421for.body:                                         ; preds = %entry, %for.body
422  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
423  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
424  %conv = trunc i64 %i.02 to i32
425  %mul = mul i64 %i.02, -6
426  %arrayidx = getelementptr inbounds i32, ptr %A, i64 %mul
427  store i32 %conv, ptr %arrayidx, align 4
428  %sub1 = sub i64 -60, %i.02
429  %arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %sub1
430  %0 = load i32, ptr %arrayidx2, align 4
431  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
432  store i32 %0, ptr %B.addr.01, align 4
433  %inc = add i64 %i.02, 1
434  %exitcond = icmp ne i64 %inc, 11
435  br i1 %exitcond, label %for.body, label %for.end
436
437for.end:                                          ; preds = %for.body
438  ret void
439}
440
441
442;;  for (long unsigned i = 0; i < 12; i++) {
443;;    A[-6*i] = i;
444;;    *B++ = A[-i - 60];
445
446define void @exact10(ptr %A, ptr %B) nounwind uwtable ssp {
447; CHECK-LABEL: 'exact10'
448; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
449; CHECK-NEXT:    da analyze - none!
450; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
451; CHECK-NEXT:    da analyze - flow [>]!
452; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
453; CHECK-NEXT:    da analyze - confused!
454; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
455; CHECK-NEXT:    da analyze - none!
456; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
457; CHECK-NEXT:    da analyze - confused!
458; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
459; CHECK-NEXT:    da analyze - none!
460;
461entry:
462  br label %for.body
463
464for.body:                                         ; preds = %entry, %for.body
465  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
466  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
467  %conv = trunc i64 %i.02 to i32
468  %mul = mul i64 %i.02, -6
469  %arrayidx = getelementptr inbounds i32, ptr %A, i64 %mul
470  store i32 %conv, ptr %arrayidx, align 4
471  %sub1 = sub i64 -60, %i.02
472  %arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %sub1
473  %0 = load i32, ptr %arrayidx2, align 4
474  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
475  store i32 %0, ptr %B.addr.01, align 4
476  %inc = add i64 %i.02, 1
477  %exitcond = icmp ne i64 %inc, 12
478  br i1 %exitcond, label %for.body, label %for.end
479
480for.end:                                          ; preds = %for.body
481  ret void
482}
483
484
485;;  for (long unsigned i = 0; i <= 12; i++) {
486;;    A[-6*i] = i;
487;;    *B++ = A[-i - 60];
488
489define void @exact11(ptr %A, ptr %B) nounwind uwtable ssp {
490; CHECK-LABEL: 'exact11'
491; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
492; CHECK-NEXT:    da analyze - none!
493; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
494; CHECK-NEXT:    da analyze - flow [=>|<]!
495; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
496; CHECK-NEXT:    da analyze - confused!
497; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
498; CHECK-NEXT:    da analyze - none!
499; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
500; CHECK-NEXT:    da analyze - confused!
501; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
502; CHECK-NEXT:    da analyze - none!
503;
504entry:
505  br label %for.body
506
507for.body:                                         ; preds = %entry, %for.body
508  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
509  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
510  %conv = trunc i64 %i.02 to i32
511  %mul = mul i64 %i.02, -6
512  %arrayidx = getelementptr inbounds i32, ptr %A, i64 %mul
513  store i32 %conv, ptr %arrayidx, align 4
514  %sub1 = sub i64 -60, %i.02
515  %arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %sub1
516  %0 = load i32, ptr %arrayidx2, align 4
517  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
518  store i32 %0, ptr %B.addr.01, align 4
519  %inc = add i64 %i.02, 1
520  %exitcond = icmp ne i64 %inc, 13
521  br i1 %exitcond, label %for.body, label %for.end
522
523for.end:                                          ; preds = %for.body
524  ret void
525}
526
527
528;;  for (long unsigned i = 0; i < 18; i++) {
529;;    A[-6*i] = i;
530;;    *B++ = A[-i - 60];
531
532define void @exact12(ptr %A, ptr %B) nounwind uwtable ssp {
533; CHECK-LABEL: 'exact12'
534; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
535; CHECK-NEXT:    da analyze - none!
536; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
537; CHECK-NEXT:    da analyze - flow [=>|<]!
538; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
539; CHECK-NEXT:    da analyze - confused!
540; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
541; CHECK-NEXT:    da analyze - none!
542; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
543; CHECK-NEXT:    da analyze - confused!
544; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
545; CHECK-NEXT:    da analyze - none!
546;
547entry:
548  br label %for.body
549
550for.body:                                         ; preds = %entry, %for.body
551  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
552  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
553  %conv = trunc i64 %i.02 to i32
554  %mul = mul i64 %i.02, -6
555  %arrayidx = getelementptr inbounds i32, ptr %A, i64 %mul
556  store i32 %conv, ptr %arrayidx, align 4
557  %sub1 = sub i64 -60, %i.02
558  %arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %sub1
559  %0 = load i32, ptr %arrayidx2, align 4
560  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
561  store i32 %0, ptr %B.addr.01, align 4
562  %inc = add i64 %i.02, 1
563  %exitcond = icmp ne i64 %inc, 18
564  br i1 %exitcond, label %for.body, label %for.end
565
566for.end:                                          ; preds = %for.body
567  ret void
568}
569
570
571;;  for (long unsigned i = 0; i <= 18; i++) {
572;;    A[-6*i] = i;
573;;    *B++ = A[-i - 60];
574
575define void @exact13(ptr %A, ptr %B) nounwind uwtable ssp {
576; CHECK-LABEL: 'exact13'
577; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
578; CHECK-NEXT:    da analyze - none!
579; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
580; CHECK-NEXT:    da analyze - flow [*|<]!
581; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
582; CHECK-NEXT:    da analyze - confused!
583; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
584; CHECK-NEXT:    da analyze - none!
585; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
586; CHECK-NEXT:    da analyze - confused!
587; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
588; CHECK-NEXT:    da analyze - none!
589;
590entry:
591  br label %for.body
592
593for.body:                                         ; preds = %entry, %for.body
594  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
595  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
596  %conv = trunc i64 %i.02 to i32
597  %mul = mul i64 %i.02, -6
598  %arrayidx = getelementptr inbounds i32, ptr %A, i64 %mul
599  store i32 %conv, ptr %arrayidx, align 4
600  %sub1 = sub i64 -60, %i.02
601  %arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %sub1
602  %0 = load i32, ptr %arrayidx2, align 4
603  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
604  store i32 %0, ptr %B.addr.01, align 4
605  %inc = add i64 %i.02, 1
606  %exitcond = icmp ne i64 %inc, 19
607  br i1 %exitcond, label %for.body, label %for.end
608
609for.end:                                          ; preds = %for.body
610  ret void
611}
612