Debian Codegraph @

llvm/test/Transforms/LoopInterchange/reductions-non-wrapped-operations.ll

raw
1 ; RUN: opt < %s -passes=loop-interchange -cache-line-size=64 -pass-remarks-output=%t -disable-output \
2 ; RUN: -verify-dom-info -verify-loop-info -verify-loop-lcssa
3 ; RUN: FileCheck -input-file=%t %s
4
5 ; Check that interchanging the loops is legal for the bitwise-or reduction.
6 ;
7 ; int b_or = 0;
8 ; for (int i = 0; i < 2; i++)
9 ; for (int j = 0; j < 2; j++)
10 ; b_or |= A[j][i];
11
12 ; CHECK: --- !Pass
13 ; CHECK-NEXT: Pass: loop-interchange
14 ; CHECK-NEXT: Name: Interchanged
15 ; CHECK-NEXT: Function: reduction_or
16 define void @reduction_or(ptr %A) {
17 entry:
18 br label %for.i.header
19
20 for.i.header:
21 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
22 %or.i = phi i32 [ 0, %entry ], [ %or.i.lcssa, %for.i.latch ]
23 br label %for.j
24
25 for.j:
26 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
27 %or.j = phi i32 [ %or.i, %for.i.header ], [ %or.j.next, %for.j ]
28 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
29 %a = load i32, ptr %idx, align 4
30 %or.j.next = or i32 %or.j, %a
31 %j.inc = add i32 %j, 1
32 %cmp.j = icmp slt i32 %j.inc, 2
33 br i1 %cmp.j, label %for.j, label %for.i.latch
34
35 for.i.latch:
36 %or.i.lcssa = phi i32 [ %or.j.next, %for.j ]
37 %i.inc = add i32 %i, 1
38 %cmp.i = icmp slt i32 %i.inc, 2
39 br i1 %cmp.i, label %for.i.header, label %exit
40
41 exit:
42 ret void
43 }
44
45
46 ; Check that interchanging the loops is legal for the bitwise-and reduction.
47 ;
48 ; int b_and = -1;
49 ; for (int i = 0; i < 2; i++)
50 ; for (int j = 0; j < 2; j++)
51 ; b_and &= A[j][i];
52
53 ; CHECK: --- !Pass
54 ; CHECK-NEXT: Pass: loop-interchange
55 ; CHECK-NEXT: Name: Interchanged
56 ; CHECK-NEXT: Function: reduction_and
57 define void @reduction_and(ptr %A) {
58 entry:
59 br label %for.i.header
60
61 for.i.header:
62 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
63 %and.i = phi i32 [ -1, %entry ], [ %and.i.lcssa, %for.i.latch ]
64 br label %for.j
65
66 for.j:
67 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
68 %and.j = phi i32 [ %and.i, %for.i.header ], [ %and.j.next, %for.j ]
69 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
70 %a = load i32, ptr %idx, align 4
71 %and.j.next = and i32 %and.j, %a
72 %j.inc = add i32 %j, 1
73 %cmp.j = icmp slt i32 %j.inc, 2
74 br i1 %cmp.j, label %for.j, label %for.i.latch
75
76 for.i.latch:
77 %and.i.lcssa = phi i32 [ %and.j.next, %for.j ]
78 %i.inc = add i32 %i, 1
79 %cmp.i = icmp slt i32 %i.inc, 2
80 br i1 %cmp.i, label %for.i.header, label %exit
81
82 exit:
83 ret void
84 }
85
86
87 ; Check that interchanging the loops is legal for the bitwise-xor reduction.
88 ;
89 ; int b_xor = 0;
90 ; for (int i = 0; i < 2; i++)
91 ; for (int j = 0; j < 2; j++)
92 ; b_xor ^= A[j][i];
93
94 ; CHECK: --- !Pass
95 ; CHECK-NEXT: Pass: loop-interchange
96 ; CHECK-NEXT: Name: Interchanged
97 ; CHECK-NEXT: Function: reduction_xor
98 define void @reduction_xor(ptr %A) {
99 entry:
100 br label %for.i.header
101
102 for.i.header:
103 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
104 %xor.i = phi i32 [ 0, %entry ], [ %xor.i.lcssa, %for.i.latch ]
105 br label %for.j
106
107 for.j:
108 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
109 %xor.j = phi i32 [ %xor.i, %for.i.header ], [ %xor.j.next, %for.j ]
110 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
111 %a = load i32, ptr %idx, align 4
112 %xor.j.next = xor i32 %xor.j, %a
113 %j.inc = add i32 %j, 1
114 %cmp.j = icmp slt i32 %j.inc, 2
115 br i1 %cmp.j, label %for.j, label %for.i.latch
116
117 for.i.latch:
118 %xor.i.lcssa = phi i32 [ %xor.j.next, %for.j ]
119 %i.inc = add i32 %i, 1
120 %cmp.i = icmp slt i32 %i.inc, 2
121 br i1 %cmp.i, label %for.i.header, label %exit
122
123 exit:
124 ret void
125 }
126
127
128 ; Check that interchanging the loops is legal for the signed-minimum reduction.
129 ;
130 ; int smin = init;
131 ; for (int i = 0; i < 2; i++)
132 ; for (int j = 0; j < 2; j++)
133 ; smin = (A[j][i] < smin) ? A[j][i] : smin;
134
135 ; CHECK: --- !Pass
136 ; CHECK-NEXT: Pass: loop-interchange
137 ; CHECK-NEXT: Name: Interchanged
138 ; CHECK-NEXT: Function: reduction_smin
139 define void @reduction_smin(ptr %A, i32 %init) {
140 entry:
141 br label %for.i.header
142
143 for.i.header:
144 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
145 %smin.i = phi i32 [ %init, %entry ], [ %smin.i.lcssa, %for.i.latch ]
146 br label %for.j
147
148 for.j:
149 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
150 %smin.j = phi i32 [ %smin.i, %for.i.header ], [ %smin.j.next, %for.j ]
151 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
152 %a = load i32, ptr %idx, align 4
153 %cmp = icmp slt i32 %a, %smin.j
154 %smin.j.next = select i1 %cmp, i32 %a, i32 %smin.j
155 %j.inc = add i32 %j, 1
156 %cmp.j = icmp slt i32 %j.inc, 2
157 br i1 %cmp.j, label %for.j, label %for.i.latch
158
159 for.i.latch:
160 %smin.i.lcssa = phi i32 [ %smin.j.next, %for.j ]
161 %i.inc = add i32 %i, 1
162 %cmp.i = icmp slt i32 %i.inc, 2
163 br i1 %cmp.i, label %for.i.header, label %exit
164
165 exit:
166 ret void
167 }
168
169
170 ; Check that interchanging the loops is legal for the signed-maximum reduction.
171 ;
172 ; int smax = init;
173 ; for (int i = 0; i < 2; i++)
174 ; for (int j = 0; j < 2; j++)
175 ; smax = (A[j][i] > smax) ? A[j][i] : smax;
176
177 ; CHECK: --- !Pass
178 ; CHECK-NEXT: Pass: loop-interchange
179 ; CHECK-NEXT: Name: Interchanged
180 ; CHECK-NEXT: Function: reduction_smax
181 define void @reduction_smax(ptr %A, i32 %init) {
182 entry:
183 br label %for.i.header
184
185 for.i.header:
186 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
187 %smax.i = phi i32 [ %init, %entry ], [ %smax.i.lcssa, %for.i.latch ]
188 br label %for.j
189
190 for.j:
191 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
192 %smax.j = phi i32 [ %smax.i, %for.i.header ], [ %smax.j.next, %for.j ]
193 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
194 %a = load i32, ptr %idx, align 4
195 %cmp = icmp sgt i32 %a, %smax.j
196 %smax.j.next = select i1 %cmp, i32 %a, i32 %smax.j
197 %j.inc = add i32 %j, 1
198 %cmp.j = icmp slt i32 %j.inc, 2
199 br i1 %cmp.j, label %for.j, label %for.i.latch
200
201 for.i.latch:
202 %smax.i.lcssa = phi i32 [ %smax.j.next, %for.j ]
203 %i.inc = add i32 %i, 1
204 %cmp.i = icmp slt i32 %i.inc, 2
205 br i1 %cmp.i, label %for.i.header, label %exit
206
207 exit:
208 ret void
209 }
210
211
212 ; Check that interchanging the loops is legal for the unsigned-minimum reduction.
213 ;
214 ; unsigned umin = init;
215 ; for (int i = 0; i < 2; i++)
216 ; for (int j = 0; j < 2; j++)
217 ; umin = (A[j][i] < umin) ? A[j][i] : umin;
218
219 ; CHECK: --- !Pass
220 ; CHECK-NEXT: Pass: loop-interchange
221 ; CHECK-NEXT: Name: Interchanged
222 ; CHECK-NEXT: Function: reduction_umin
223 define void @reduction_umin(ptr %A, i32 %init) {
224 entry:
225 br label %for.i.header
226
227 for.i.header:
228 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
229 %umin.i = phi i32 [ %init, %entry ], [ %umin.i.lcssa, %for.i.latch ]
230 br label %for.j
231
232 for.j:
233 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
234 %umin.j = phi i32 [ %umin.i, %for.i.header ], [ %umin.j.next, %for.j ]
235 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
236 %a = load i32, ptr %idx, align 4
237 %cmp = icmp ult i32 %a, %umin.j
238 %umin.j.next = select i1 %cmp, i32 %a, i32 %umin.j
239 %j.inc = add i32 %j, 1
240 %cmp.j = icmp slt i32 %j.inc, 2
241 br i1 %cmp.j, label %for.j, label %for.i.latch
242
243 for.i.latch:
244 %umin.i.lcssa = phi i32 [ %umin.j.next, %for.j ]
245 %i.inc = add i32 %i, 1
246 %cmp.i = icmp slt i32 %i.inc, 2
247 br i1 %cmp.i, label %for.i.header, label %exit
248
249 exit:
250 ret void
251 }
252
253
254 ; Check that interchanging the loops is legal for the unsigned-maximum reduction.
255 ;
256 ; unsigned umax = 0;
257 ; for (int i = 0; i < 2; i++)
258 ; for (int j = 0; j < 2; j++)
259 ; smax = (A[j][i] > smax) ? A[j][i] : smax;
260
261 ; CHECK: --- !Pass
262 ; CHECK-NEXT: Pass: loop-interchange
263 ; CHECK-NEXT: Name: Interchanged
264 ; CHECK-NEXT: Function: reduction_umax
265 define void @reduction_umax(ptr %A) {
266 entry:
267 br label %for.i.header
268
269 for.i.header:
270 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
271 %umax.i = phi i32 [ 0, %entry ], [ %umax.i.lcssa, %for.i.latch ]
272 br label %for.j
273
274 for.j:
275 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
276 %umax.j = phi i32 [ %umax.i, %for.i.header ], [ %umax.j.next, %for.j ]
277 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
278 %a = load i32, ptr %idx, align 4
279 %cmp = icmp ugt i32 %a, %umax.j
280 %umax.j.next = select i1 %cmp, i32 %a, i32 %umax.j
281 %j.inc = add i32 %j, 1
282 %cmp.j = icmp slt i32 %j.inc, 2
283 br i1 %cmp.j, label %for.j, label %for.i.latch
284
285 for.i.latch:
286 %umax.i.lcssa = phi i32 [ %umax.j.next, %for.j ]
287 %i.inc = add i32 %i, 1
288 %cmp.i = icmp slt i32 %i.inc, 2
289 br i1 %cmp.i, label %for.i.header, label %exit
290
291 exit:
292 ret void
293 }
294
295
296 ; Check that interchanging the loops is legal for the any-of reduction.
297 ;
298 ; int any_of = 0;
299 ; for (int i = 0; i < 2; i++)
300 ; for (int j = 0; j < 2; j++)
301 ; any_of = (A[j][i] == 42) ? 1 : any_of;
302
303 ; CHECK: --- !Pass
304 ; CHECK-NEXT: Pass: loop-interchange
305 ; CHECK-NEXT: Name: Interchanged
306 ; CHECK-NEXT: Function: reduction_anyof
307 define void @reduction_anyof(ptr %A) {
308 entry:
309 br label %for.i.header
310
311 for.i.header:
312 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
313 %anyof.i = phi i32 [ 0, %entry ], [ %anyof.i.lcssa, %for.i.latch ]
314 br label %for.j
315
316 for.j:
317 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
318 %anyof.j = phi i32 [ %anyof.i, %for.i.header ], [ %anyof.j.next, %for.j ]
319 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
320 %a = load i32, ptr %idx, align 4
321 %cmp = icmp eq i32 %a, 42
322 %anyof.j.next = select i1 %cmp, i32 1, i32 %anyof.j
323 %j.inc = add i32 %j, 1
324 %cmp.j = icmp slt i32 %j.inc, 2
325 br i1 %cmp.j, label %for.j, label %for.i.latch
326
327 for.i.latch:
328 %anyof.i.lcssa = phi i32 [ %anyof.j.next, %for.j ]
329 %i.inc = add i32 %i, 1
330 %cmp.i = icmp slt i32 %i.inc, 2
331 br i1 %cmp.i, label %for.i.header, label %exit
332
333 exit:
334 ret void
335 }