xref: /llvm-project/llvm/test/Analysis/DependenceAnalysis/Coupled.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 int i = 0; i < 50; i++) {
10;;    A[i][i] = i;
11;;    *B++ = A[i + 10][i + 9];
12
13define void @couple0(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
14; CHECK-LABEL: 'couple0'
15; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx1, align 4 --> Dst: store i32 %conv, ptr %arrayidx1, align 4
16; CHECK-NEXT:    da analyze - none!
17; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
18; CHECK-NEXT:    da analyze - none!
19; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx1, 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 %arrayidx4, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
22; CHECK-NEXT:    da analyze - none!
23; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, 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  %arrayidx1 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
36  store i32 %conv, ptr %arrayidx1, align 4
37  %add = add nsw i64 %i.02, 9
38  %add2 = add nsw i64 %i.02, 10
39  %arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %add2, i64 %add
40  %0 = load i32, ptr %arrayidx4, align 4
41  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
42  store i32 %0, ptr %B.addr.01, align 4
43  %inc = add nsw i64 %i.02, 1
44  %exitcond = icmp ne i64 %inc, 50
45  br i1 %exitcond, label %for.body, label %for.end
46
47for.end:                                          ; preds = %for.body
48  ret void
49}
50
51
52;;  for (long int i = 0; i < 50; i++) {
53;;    A[i][i] = i;
54;;    *B++ = A[i + 9][i + 9];
55
56define void @couple1(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
57; CHECK-LABEL: 'couple1'
58; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx1, align 4 --> Dst: store i32 %conv, ptr %arrayidx1, align 4
59; CHECK-NEXT:    da analyze - none!
60; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
61; CHECK-NEXT:    da analyze - consistent flow [-9]!
62; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx1, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
63; CHECK-NEXT:    da analyze - confused!
64; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
65; CHECK-NEXT:    da analyze - none!
66; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
67; CHECK-NEXT:    da analyze - confused!
68; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
69; CHECK-NEXT:    da analyze - none!
70;
71entry:
72  br label %for.body
73
74for.body:                                         ; preds = %entry, %for.body
75  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
76  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
77  %conv = trunc i64 %i.02 to i32
78  %arrayidx1 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
79  store i32 %conv, ptr %arrayidx1, align 4
80  %add = add nsw i64 %i.02, 9
81  %add2 = add nsw i64 %i.02, 9
82  %arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %add2, i64 %add
83  %0 = load i32, ptr %arrayidx4, align 4
84  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
85  store i32 %0, ptr %B.addr.01, align 4
86  %inc = add nsw i64 %i.02, 1
87  %exitcond = icmp ne i64 %inc, 50
88  br i1 %exitcond, label %for.body, label %for.end
89
90for.end:                                          ; preds = %for.body
91  ret void
92}
93
94
95;;  for (long int i = 0; i < 50; i++) {
96;;    A[3*i - 6][3*i - 6] = i;
97;;    *B++ = A[i][i];
98
99define void @couple2(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
100; CHECK-LABEL: 'couple2'
101; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: store i32 %conv, ptr %arrayidx3, align 4
102; CHECK-NEXT:    da analyze - none!
103; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: %0 = load i32, ptr %arrayidx5, align 4
104; CHECK-NEXT:    da analyze - flow [*|<]!
105; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
106; CHECK-NEXT:    da analyze - confused!
107; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx5, align 4 --> Dst: %0 = load i32, ptr %arrayidx5, align 4
108; CHECK-NEXT:    da analyze - none!
109; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx5, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
110; CHECK-NEXT:    da analyze - confused!
111; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
112; CHECK-NEXT:    da analyze - none!
113;
114entry:
115  br label %for.body
116
117for.body:                                         ; preds = %entry, %for.body
118  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
119  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
120  %conv = trunc i64 %i.02 to i32
121  %mul = mul nsw i64 %i.02, 3
122  %sub = add nsw i64 %mul, -6
123  %mul1 = mul nsw i64 %i.02, 3
124  %sub2 = add nsw i64 %mul1, -6
125  %arrayidx3 = getelementptr inbounds [100 x i32], ptr %A, i64 %sub2, i64 %sub
126  store i32 %conv, ptr %arrayidx3, align 4
127  %arrayidx5 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
128  %0 = load i32, ptr %arrayidx5, align 4
129  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
130  store i32 %0, ptr %B.addr.01, align 4
131  %inc = add nsw i64 %i.02, 1
132  %exitcond = icmp ne i64 %inc, 50
133  br i1 %exitcond, label %for.body, label %for.end
134
135for.end:                                          ; preds = %for.body
136  ret void
137}
138
139
140;;  for (long int i = 0; i < 50; i++) {
141;;    A[3*i - 6][3*i - 5] = i;
142;;    *B++ = A[i][i];
143
144define void @couple3(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
145; CHECK-LABEL: 'couple3'
146; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: store i32 %conv, ptr %arrayidx3, align 4
147; CHECK-NEXT:    da analyze - none!
148; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: %0 = load i32, ptr %arrayidx5, align 4
149; CHECK-NEXT:    da analyze - none!
150; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
151; CHECK-NEXT:    da analyze - confused!
152; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx5, align 4 --> Dst: %0 = load i32, ptr %arrayidx5, align 4
153; CHECK-NEXT:    da analyze - none!
154; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx5, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
155; CHECK-NEXT:    da analyze - confused!
156; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
157; CHECK-NEXT:    da analyze - none!
158;
159entry:
160  br label %for.body
161
162for.body:                                         ; preds = %entry, %for.body
163  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
164  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
165  %conv = trunc i64 %i.02 to i32
166  %mul = mul nsw i64 %i.02, 3
167  %sub = add nsw i64 %mul, -5
168  %mul1 = mul nsw i64 %i.02, 3
169  %sub2 = add nsw i64 %mul1, -6
170  %arrayidx3 = getelementptr inbounds [100 x i32], ptr %A, i64 %sub2, i64 %sub
171  store i32 %conv, ptr %arrayidx3, align 4
172  %arrayidx5 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
173  %0 = load i32, ptr %arrayidx5, align 4
174  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
175  store i32 %0, ptr %B.addr.01, align 4
176  %inc = add nsw i64 %i.02, 1
177  %exitcond = icmp ne i64 %inc, 50
178  br i1 %exitcond, label %for.body, label %for.end
179
180for.end:                                          ; preds = %for.body
181  ret void
182}
183
184
185;;  for (long int i = 0; i < 50; i++) {
186;;    A[3*i - 6][3*i - n] = i;
187;;    *B++ = A[i][i];
188
189define void @couple4(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
190; CHECK-LABEL: 'couple4'
191; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx4, align 4 --> Dst: store i32 %conv, ptr %arrayidx4, align 4
192; CHECK-NEXT:    da analyze - none!
193; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx4, align 4 --> Dst: %0 = load i32, ptr %arrayidx6, align 4
194; CHECK-NEXT:    da analyze - flow [*|<]!
195; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx4, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
196; CHECK-NEXT:    da analyze - confused!
197; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx6, align 4 --> Dst: %0 = load i32, ptr %arrayidx6, align 4
198; CHECK-NEXT:    da analyze - none!
199; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx6, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
200; CHECK-NEXT:    da analyze - confused!
201; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
202; CHECK-NEXT:    da analyze - none!
203;
204entry:
205  br label %for.body
206
207for.body:                                         ; preds = %entry, %for.body
208  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
209  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
210  %conv = trunc i64 %i.02 to i32
211  %mul = mul nsw i64 %i.02, 3
212  %conv1 = sext i32 %n to i64
213  %sub = sub nsw i64 %mul, %conv1
214  %mul2 = mul nsw i64 %i.02, 3
215  %sub3 = add nsw i64 %mul2, -6
216  %arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %sub3, i64 %sub
217  store i32 %conv, ptr %arrayidx4, align 4
218  %arrayidx6 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
219  %0 = load i32, ptr %arrayidx6, align 4
220  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
221  store i32 %0, ptr %B.addr.01, align 4
222  %inc = add nsw i64 %i.02, 1
223  %exitcond = icmp ne i64 %inc, 50
224  br i1 %exitcond, label %for.body, label %for.end
225
226for.end:                                          ; preds = %for.body
227  ret void
228}
229
230
231;;  for (long int i = 0; i < 50; i++) {
232;;    A[3*i - n + 1][3*i - n] = i;
233;;    *B++ = A[i][i];
234
235define void @couple5(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
236; CHECK-LABEL: 'couple5'
237; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx5, align 4 --> Dst: store i32 %conv, ptr %arrayidx5, align 4
238; CHECK-NEXT:    da analyze - none!
239; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx5, align 4 --> Dst: %0 = load i32, ptr %arrayidx7, align 4
240; CHECK-NEXT:    da analyze - none!
241; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx5, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
242; CHECK-NEXT:    da analyze - confused!
243; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx7, align 4 --> Dst: %0 = load i32, ptr %arrayidx7, align 4
244; CHECK-NEXT:    da analyze - none!
245; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx7, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
246; CHECK-NEXT:    da analyze - confused!
247; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
248; CHECK-NEXT:    da analyze - none!
249;
250entry:
251  br label %for.body
252
253for.body:                                         ; preds = %entry, %for.body
254  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
255  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
256  %conv = trunc i64 %i.02 to i32
257  %mul = mul nsw i64 %i.02, 3
258  %conv1 = sext i32 %n to i64
259  %sub = sub nsw i64 %mul, %conv1
260  %mul2 = mul nsw i64 %i.02, 3
261  %conv3 = sext i32 %n to i64
262  %sub4 = sub nsw i64 %mul2, %conv3
263  %add = add nsw i64 %sub4, 1
264  %arrayidx5 = getelementptr inbounds [100 x i32], ptr %A, i64 %add, i64 %sub
265  store i32 %conv, ptr %arrayidx5, align 4
266  %arrayidx7 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
267  %0 = load i32, ptr %arrayidx7, align 4
268  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
269  store i32 %0, ptr %B.addr.01, align 4
270  %inc = add nsw i64 %i.02, 1
271  %exitcond = icmp ne i64 %inc, 50
272  br i1 %exitcond, label %for.body, label %for.end
273
274for.end:                                          ; preds = %for.body
275  ret void
276}
277
278
279;;  for (long int i = 0; i < 50; i++) {
280;;    A[i][3*i - 6] = i;
281;;    *B++ = A[i][i];
282
283define void @couple6(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
284; CHECK-LABEL: 'couple6'
285; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx1, align 4 --> Dst: store i32 %conv, ptr %arrayidx1, align 4
286; CHECK-NEXT:    da analyze - none!
287; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx3, align 4
288; CHECK-NEXT:    da analyze - flow [=|<]!
289; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx1, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
290; CHECK-NEXT:    da analyze - confused!
291; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx3, align 4 --> Dst: %0 = load i32, ptr %arrayidx3, align 4
292; CHECK-NEXT:    da analyze - none!
293; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx3, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
294; CHECK-NEXT:    da analyze - confused!
295; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
296; CHECK-NEXT:    da analyze - none!
297;
298entry:
299  br label %for.body
300
301for.body:                                         ; preds = %entry, %for.body
302  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
303  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
304  %conv = trunc i64 %i.02 to i32
305  %mul = mul nsw i64 %i.02, 3
306  %sub = add nsw i64 %mul, -6
307  %arrayidx1 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %sub
308  store i32 %conv, ptr %arrayidx1, align 4
309  %arrayidx3 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
310  %0 = load i32, ptr %arrayidx3, align 4
311  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
312  store i32 %0, ptr %B.addr.01, align 4
313  %inc = add nsw i64 %i.02, 1
314  %exitcond = icmp ne i64 %inc, 50
315  br i1 %exitcond, label %for.body, label %for.end
316
317for.end:                                          ; preds = %for.body
318  ret void
319}
320
321
322;;  for (long int i = 0; i < 50; i++) {
323;;    A[i][3*i - 5] = i;
324;;    *B++ = A[i][i];
325
326define void @couple7(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
327; CHECK-LABEL: 'couple7'
328; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx1, align 4 --> Dst: store i32 %conv, ptr %arrayidx1, align 4
329; CHECK-NEXT:    da analyze - none!
330; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx3, align 4
331; CHECK-NEXT:    da analyze - none!
332; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx1, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
333; CHECK-NEXT:    da analyze - confused!
334; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx3, align 4 --> Dst: %0 = load i32, ptr %arrayidx3, align 4
335; CHECK-NEXT:    da analyze - none!
336; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx3, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
337; CHECK-NEXT:    da analyze - confused!
338; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
339; CHECK-NEXT:    da analyze - none!
340;
341entry:
342  br label %for.body
343
344for.body:                                         ; preds = %entry, %for.body
345  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
346  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
347  %conv = trunc i64 %i.02 to i32
348  %mul = mul nsw i64 %i.02, 3
349  %sub = add nsw i64 %mul, -5
350  %arrayidx1 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %sub
351  store i32 %conv, ptr %arrayidx1, align 4
352  %arrayidx3 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
353  %0 = load i32, ptr %arrayidx3, align 4
354  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
355  store i32 %0, ptr %B.addr.01, align 4
356  %inc = add nsw i64 %i.02, 1
357  %exitcond = icmp ne i64 %inc, 50
358  br i1 %exitcond, label %for.body, label %for.end
359
360for.end:                                          ; preds = %for.body
361  ret void
362}
363
364
365;;  for (long int i = 0; i <= 15; i++) {
366;;    A[3*i - 18][3 - i] = i;
367;;    *B++ = A[i][i];
368
369define void @couple8(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
370; CHECK-LABEL: 'couple8'
371; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %conv, ptr %arrayidx2, align 4
372; CHECK-NEXT:    da analyze - none!
373; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
374; CHECK-NEXT:    da analyze - none!
375; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
376; CHECK-NEXT:    da analyze - confused!
377; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
378; CHECK-NEXT:    da analyze - none!
379; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
380; CHECK-NEXT:    da analyze - confused!
381; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
382; CHECK-NEXT:    da analyze - none!
383;
384entry:
385  br label %for.body
386
387for.body:                                         ; preds = %entry, %for.body
388  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
389  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
390  %conv = trunc i64 %i.02 to i32
391  %sub = sub nsw i64 3, %i.02
392  %mul = mul nsw i64 %i.02, 3
393  %sub1 = add nsw i64 %mul, -18
394  %arrayidx2 = getelementptr inbounds [100 x i32], ptr %A, i64 %sub1, i64 %sub
395  store i32 %conv, ptr %arrayidx2, align 4
396  %arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
397  %0 = load i32, ptr %arrayidx4, align 4
398  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
399  store i32 %0, ptr %B.addr.01, align 4
400  %inc = add nsw i64 %i.02, 1
401  %exitcond = icmp ne i64 %inc, 16
402  br i1 %exitcond, label %for.body, label %for.end
403
404for.end:                                          ; preds = %for.body
405  ret void
406}
407
408
409;;  for (long int i = 0; i <= 15; i++) {
410;;    A[3*i - 18][2 - i] = i;
411;;    *B++ = A[i][i];
412
413define void @couple9(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
414; CHECK-LABEL: 'couple9'
415; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %conv, ptr %arrayidx2, align 4
416; CHECK-NEXT:    da analyze - none!
417; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
418; CHECK-NEXT:    da analyze - none!
419; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
420; CHECK-NEXT:    da analyze - confused!
421; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
422; CHECK-NEXT:    da analyze - none!
423; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
424; CHECK-NEXT:    da analyze - confused!
425; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
426; CHECK-NEXT:    da analyze - none!
427;
428entry:
429  br label %for.body
430
431for.body:                                         ; preds = %entry, %for.body
432  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
433  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
434  %conv = trunc i64 %i.02 to i32
435  %sub = sub nsw i64 2, %i.02
436  %mul = mul nsw i64 %i.02, 3
437  %sub1 = add nsw i64 %mul, -18
438  %arrayidx2 = getelementptr inbounds [100 x i32], ptr %A, i64 %sub1, i64 %sub
439  store i32 %conv, ptr %arrayidx2, align 4
440  %arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
441  %0 = load i32, ptr %arrayidx4, align 4
442  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
443  store i32 %0, ptr %B.addr.01, align 4
444  %inc = add nsw i64 %i.02, 1
445  %exitcond = icmp ne i64 %inc, 16
446  br i1 %exitcond, label %for.body, label %for.end
447
448for.end:                                          ; preds = %for.body
449  ret void
450}
451
452
453;;  for (long int i = 0; i <= 15; i++) {
454;;    A[3*i - 18][6 - i] = i;
455;;    *B++ = A[i][i];
456
457define void @couple10(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
458; CHECK-LABEL: 'couple10'
459; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %conv, ptr %arrayidx2, align 4
460; CHECK-NEXT:    da analyze - none!
461; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
462; CHECK-NEXT:    da analyze - flow [>]!
463; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
464; CHECK-NEXT:    da analyze - confused!
465; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
466; CHECK-NEXT:    da analyze - none!
467; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
468; CHECK-NEXT:    da analyze - confused!
469; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
470; CHECK-NEXT:    da analyze - none!
471;
472entry:
473  br label %for.body
474
475for.body:                                         ; preds = %entry, %for.body
476  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
477  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
478  %conv = trunc i64 %i.02 to i32
479  %sub = sub nsw i64 6, %i.02
480  %mul = mul nsw i64 %i.02, 3
481  %sub1 = add nsw i64 %mul, -18
482  %arrayidx2 = getelementptr inbounds [100 x i32], ptr %A, i64 %sub1, i64 %sub
483  store i32 %conv, ptr %arrayidx2, align 4
484  %arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
485  %0 = load i32, ptr %arrayidx4, align 4
486  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
487  store i32 %0, ptr %B.addr.01, align 4
488  %inc = add nsw i64 %i.02, 1
489  %exitcond = icmp ne i64 %inc, 16
490  br i1 %exitcond, label %for.body, label %for.end
491
492for.end:                                          ; preds = %for.body
493  ret void
494}
495
496
497;;  for (long int i = 0; i <= 15; i++) {
498;;    A[3*i - 18][18 - i] = i;
499;;    *B++ = A[i][i];
500
501define void @couple11(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
502; CHECK-LABEL: 'couple11'
503; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %conv, ptr %arrayidx2, align 4
504; CHECK-NEXT:    da analyze - none!
505; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
506; CHECK-NEXT:    da analyze - flow [=|<] splitable!
507; CHECK-NEXT:    da analyze - split level = 1, iteration = 9!
508; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
509; CHECK-NEXT:    da analyze - confused!
510; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
511; CHECK-NEXT:    da analyze - none!
512; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
513; CHECK-NEXT:    da analyze - confused!
514; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
515; CHECK-NEXT:    da analyze - none!
516;
517entry:
518  br label %for.body
519
520for.body:                                         ; preds = %entry, %for.body
521  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
522  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
523  %conv = trunc i64 %i.02 to i32
524  %sub = sub nsw i64 18, %i.02
525  %mul = mul nsw i64 %i.02, 3
526  %sub1 = add nsw i64 %mul, -18
527  %arrayidx2 = getelementptr inbounds [100 x i32], ptr %A, i64 %sub1, i64 %sub
528  store i32 %conv, ptr %arrayidx2, align 4
529  %arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
530  %0 = load i32, ptr %arrayidx4, align 4
531  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
532  store i32 %0, ptr %B.addr.01, align 4
533  %inc = add nsw i64 %i.02, 1
534  %exitcond = icmp ne i64 %inc, 16
535  br i1 %exitcond, label %for.body, label %for.end
536
537for.end:                                          ; preds = %for.body
538  ret void
539}
540
541
542;;  for (long int i = 0; i <= 12; i++) {
543;;    A[3*i - 18][22 - i] = i;
544;;    *B++ = A[i][i];
545
546define void @couple12(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
547; CHECK-LABEL: 'couple12'
548; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %conv, ptr %arrayidx2, align 4
549; CHECK-NEXT:    da analyze - none!
550; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
551; CHECK-NEXT:    da analyze - flow [<] splitable!
552; CHECK-NEXT:    da analyze - split level = 1, iteration = 11!
553; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
554; CHECK-NEXT:    da analyze - confused!
555; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
556; CHECK-NEXT:    da analyze - none!
557; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
558; CHECK-NEXT:    da analyze - confused!
559; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
560; CHECK-NEXT:    da analyze - none!
561;
562entry:
563  br label %for.body
564
565for.body:                                         ; preds = %entry, %for.body
566  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
567  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
568  %conv = trunc i64 %i.02 to i32
569  %sub = sub nsw i64 22, %i.02
570  %mul = mul nsw i64 %i.02, 3
571  %sub1 = add nsw i64 %mul, -18
572  %arrayidx2 = getelementptr inbounds [100 x i32], ptr %A, i64 %sub1, i64 %sub
573  store i32 %conv, ptr %arrayidx2, align 4
574  %arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
575  %0 = load i32, ptr %arrayidx4, align 4
576  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
577  store i32 %0, ptr %B.addr.01, align 4
578  %inc = add nsw i64 %i.02, 1
579  %exitcond = icmp ne i64 %inc, 13
580  br i1 %exitcond, label %for.body, label %for.end
581
582for.end:                                          ; preds = %for.body
583  ret void
584}
585
586
587;;  for (long int i = 0; i < 12; i++) {
588;;    A[3*i - 18][22 - i] = i;
589;;    *B++ = A[i][i];
590
591define void @couple13(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
592; CHECK-LABEL: 'couple13'
593; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %conv, ptr %arrayidx2, align 4
594; CHECK-NEXT:    da analyze - none!
595; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
596; CHECK-NEXT:    da analyze - none!
597; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
598; CHECK-NEXT:    da analyze - confused!
599; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
600; CHECK-NEXT:    da analyze - none!
601; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
602; CHECK-NEXT:    da analyze - confused!
603; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
604; CHECK-NEXT:    da analyze - none!
605;
606entry:
607  br label %for.body
608
609for.body:                                         ; preds = %entry, %for.body
610  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
611  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
612  %conv = trunc i64 %i.02 to i32
613  %sub = sub nsw i64 22, %i.02
614  %mul = mul nsw i64 %i.02, 3
615  %sub1 = add nsw i64 %mul, -18
616  %arrayidx2 = getelementptr inbounds [100 x i32], ptr %A, i64 %sub1, i64 %sub
617  store i32 %conv, ptr %arrayidx2, align 4
618  %arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
619  %0 = load i32, ptr %arrayidx4, align 4
620  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
621  store i32 %0, ptr %B.addr.01, align 4
622  %inc = add nsw i64 %i.02, 1
623  %exitcond = icmp ne i64 %inc, 12
624  br i1 %exitcond, label %for.body, label %for.end
625
626for.end:                                          ; preds = %for.body
627  ret void
628}
629
630;;  for (long int i = 0; i < 100; i++) {
631;;    A[3*i - 18][18 - i][i] = i;
632;;    *B++ = A[i][i][i];
633
634define void @couple14(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
635; CHECK-LABEL: 'couple14'
636; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: store i32 %conv, ptr %arrayidx3, align 4
637; CHECK-NEXT:    da analyze - none!
638; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: %0 = load i32, ptr %arrayidx6, align 4
639; CHECK-NEXT:    da analyze - flow [=|<]!
640; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
641; CHECK-NEXT:    da analyze - confused!
642; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx6, align 4 --> Dst: %0 = load i32, ptr %arrayidx6, align 4
643; CHECK-NEXT:    da analyze - none!
644; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx6, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
645; CHECK-NEXT:    da analyze - confused!
646; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
647; CHECK-NEXT:    da analyze - none!
648;
649entry:
650  br label %for.body
651
652for.body:                                         ; preds = %entry, %for.body
653  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
654  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
655  %conv = trunc i64 %i.02 to i32
656  %sub = sub nsw i64 18, %i.02
657  %mul = mul nsw i64 %i.02, 3
658  %sub1 = add nsw i64 %mul, -18
659  %arrayidx3 = getelementptr inbounds [100 x [100 x i32]], ptr %A, i64 %sub1, i64 %sub, i64 %i.02
660  store i32 %conv, ptr %arrayidx3, align 4
661  %arrayidx6 = getelementptr inbounds [100 x [100 x i32]], ptr %A, i64 %i.02, i64 %i.02, i64 %i.02
662  %0 = load i32, ptr %arrayidx6, align 4
663  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
664  store i32 %0, ptr %B.addr.01, align 4
665  %inc = add nsw i64 %i.02, 1
666  %exitcond = icmp ne i64 %inc, 100
667  br i1 %exitcond, label %for.body, label %for.end
668
669for.end:                                          ; preds = %for.body
670  ret void
671}
672
673
674;;  for (long int i = 0; i < 100; i++) {
675;;    A[3*i - 18][22 - i][i] = i;
676;;    *B++ = A[i][i][i];
677
678define void @couple15(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
679; CHECK-LABEL: 'couple15'
680; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: store i32 %conv, ptr %arrayidx3, align 4
681; CHECK-NEXT:    da analyze - none!
682; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: %0 = load i32, ptr %arrayidx6, align 4
683; CHECK-NEXT:    da analyze - none!
684; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
685; CHECK-NEXT:    da analyze - confused!
686; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx6, align 4 --> Dst: %0 = load i32, ptr %arrayidx6, align 4
687; CHECK-NEXT:    da analyze - none!
688; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx6, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
689; CHECK-NEXT:    da analyze - confused!
690; CHECK-NEXT:  Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
691; CHECK-NEXT:    da analyze - none!
692;
693entry:
694  br label %for.body
695
696for.body:                                         ; preds = %entry, %for.body
697  %i.02 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
698  %B.addr.01 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
699  %conv = trunc i64 %i.02 to i32
700  %sub = sub nsw i64 22, %i.02
701  %mul = mul nsw i64 %i.02, 3
702  %sub1 = add nsw i64 %mul, -18
703  %arrayidx3 = getelementptr inbounds [100 x [100 x i32]], ptr %A, i64 %sub1, i64 %sub, i64 %i.02
704  store i32 %conv, ptr %arrayidx3, align 4
705  %arrayidx6 = getelementptr inbounds [100 x [100 x i32]], ptr %A, i64 %i.02, i64 %i.02, i64 %i.02
706  %0 = load i32, ptr %arrayidx6, align 4
707  %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.01, i64 1
708  store i32 %0, ptr %B.addr.01, align 4
709  %inc = add nsw i64 %i.02, 1
710  %exitcond = icmp ne i64 %inc, 100
711  br i1 %exitcond, label %for.body, label %for.end
712
713for.end:                                          ; preds = %for.body
714  ret void
715}
716
717;;  for(int i = 0; i < N; i+=1) {
718;;    A[M*N*i] = 1;
719;;    for(int j = 0; j < M; j+=1)
720;;      A[M*N + M*i + j] = 2;
721
722define void @couple_weakzerosiv(ptr noalias nocapture %A, i64 %N, i64 %M) {
723; CHECK-LABEL: 'couple_weakzerosiv'
724; CHECK-NEXT:  Src: store i32 1, ptr %arrayidx.us, align 4 --> Dst: store i32 1, ptr %arrayidx.us, align 4
725; CHECK-NEXT:    da analyze - none!
726; CHECK-NEXT:  Src: store i32 1, ptr %arrayidx.us, align 4 --> Dst: store i32 2, ptr %arrayidx9.us, align 4
727; CHECK-NEXT:    da analyze - output [p>]!
728; CHECK-NEXT:  Src: store i32 2, ptr %arrayidx9.us, align 4 --> Dst: store i32 2, ptr %arrayidx9.us, align 4
729; CHECK-NEXT:    da analyze - none!
730;
731entry:
732  %cmp29 = icmp sgt i64 %N, 0
733  br i1 %cmp29, label %for.body.lr.ph, label %for.cond.cleanup
734
735for.body.lr.ph:                                   ; preds = %entry
736  %mul = mul nsw i64 %M, %N
737  br label %for.body.us
738
739for.body.us:                                      ; preds = %for.body.lr.ph, %for.cond.cleanup4.loopexit.us
740  %i.030.us = phi i64 [ %add12.us, %for.cond.cleanup4.loopexit.us ], [ 0, %for.body.lr.ph ]
741  %mul1.us = mul nsw i64 %i.030.us, %mul
742  %arrayidx.us = getelementptr inbounds i32, ptr %A, i64 %mul1.us
743  store i32 1, ptr %arrayidx.us, align 4
744  %mul6.us = mul nsw i64 %i.030.us, %M
745  %add.us = add i64 %mul6.us, %mul
746  br label %for.body5.us
747
748for.body5.us:                                     ; preds = %for.body5.us, %for.body.us
749  %j.028.us = phi i64 [ 0, %for.body.us ], [ %add10.us, %for.body5.us ]
750  %add8.us = add i64 %add.us, %j.028.us
751  %arrayidx9.us = getelementptr inbounds i32, ptr %A, i64 %add8.us
752  store i32 2, ptr %arrayidx9.us, align 4
753  %add10.us = add nuw nsw i64 %j.028.us, 1
754  %exitcond.us = icmp eq i64 %add10.us, %M
755  br i1 %exitcond.us, label %for.cond.cleanup4.loopexit.us, label %for.body5.us
756
757for.cond.cleanup4.loopexit.us:                    ; preds = %for.body5.us
758  %add12.us = add nuw nsw i64 %i.030.us, 1
759  %exitcond31.us = icmp eq i64 %add12.us, %N
760  br i1 %exitcond31.us, label %for.cond.cleanup, label %for.body.us
761
762for.cond.cleanup:                                 ; preds = %for.cond.cleanup4.loopexit.us, %entry
763  ret void
764}
765