Debian Codegraph @

llvm/test/Transforms/LoopInterchange/fp-reductions.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 the loops aren't exchanged if there is a reduction of
6 ; non-reassociative floating-point addition.
7 ;
8 ; float sum = 0;
9 ; for (int i = 0; i < 2; i++)
10 ; for (int j = 0; j < 2; j++)
11 ; sum += A[j][i];
12
13 ; CHECK: --- !Missed
14 ; CHECK-NEXT: Pass: loop-interchange
15 ; CHECK-NEXT: Name: UnsupportedPHIOuter
16 ; CHECK-NEXT: Function: reduction_fadd
17 define void @reduction_fadd(ptr %A) {
18 entry:
19 br label %for.i.header
20
21 for.i.header:
22 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
23 %sum.i = phi float [ 0.0, %entry ], [ %sum.i.lcssa, %for.i.latch ]
24 br label %for.j
25
26 for.j:
27 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
28 %sum.j = phi float [ %sum.i, %for.i.header ], [ %sum.j.next, %for.j ]
29 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
30 %a = load float, ptr %idx, align 4
31 %sum.j.next = fadd float %sum.j, %a
32 %j.inc = add i32 %j, 1
33 %cmp.j = icmp slt i32 %j.inc, 2
34 br i1 %cmp.j, label %for.j, label %for.i.latch
35
36 for.i.latch:
37 %sum.i.lcssa = phi float [ %sum.j.next, %for.j ]
38 %i.inc = add i32 %i, 1
39 %cmp.i = icmp slt i32 %i.inc, 2
40 br i1 %cmp.i, label %for.i.header, label %exit
41
42 exit:
43 ret void
44 }
45
46 ; Check that the interchange is legal if the floating-point addition is marked
47 ; as reassoc.
48 ;
49 ; CHECK: --- !Pass
50 ; CHECK-NEXT: Pass: loop-interchange
51 ; CHECK-NEXT: Name: Interchanged
52 ; CHECK-NEXT: Function: reduction_reassoc_fadd
53 define void @reduction_reassoc_fadd(ptr %A) {
54 entry:
55 br label %for.i.header
56
57 for.i.header:
58 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
59 %sum.i = phi float [ 0.0, %entry ], [ %sum.i.lcssa, %for.i.latch ]
60 br label %for.j
61
62 for.j:
63 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
64 %sum.j = phi float [ %sum.i, %for.i.header ], [ %sum.j.next, %for.j ]
65 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
66 %a = load float, ptr %idx, align 4
67 %sum.j.next = fadd reassoc float %sum.j, %a
68 %j.inc = add i32 %j, 1
69 %cmp.j = icmp slt i32 %j.inc, 2
70 br i1 %cmp.j, label %for.j, label %for.i.latch
71
72 for.i.latch:
73 %sum.i.lcssa = phi float [ %sum.j.next, %for.j ]
74 %i.inc = add i32 %i, 1
75 %cmp.i = icmp slt i32 %i.inc, 2
76 br i1 %cmp.i, label %for.i.header, label %exit
77
78 exit:
79 ret void
80 }
81
82 ; FIXME: Is it really legal to interchange the loops when
83 ; both reassoc and ninf are set?
84 ; Check that the interchange is legal if the floating-point addition is marked
85 ; as reassoc.
86 ;
87 ; CHECK: --- !Pass
88 ; CHECK-NEXT: Pass: loop-interchange
89 ; CHECK-NEXT: Name: Interchanged
90 ; CHECK-NEXT: Function: reduction_reassoc_ninf_fadd
91 define void @reduction_reassoc_ninf_fadd(ptr %A) {
92 entry:
93 br label %for.i.header
94
95 for.i.header:
96 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
97 %sum.i = phi float [ 0.0, %entry ], [ %sum.i.lcssa, %for.i.latch ]
98 br label %for.j
99
100 for.j:
101 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
102 %sum.j = phi float [ %sum.i, %for.i.header ], [ %sum.j.next, %for.j ]
103 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
104 %a = load float, ptr %idx, align 4
105 %sum.j.next = fadd reassoc ninf float %sum.j, %a
106 %j.inc = add i32 %j, 1
107 %cmp.j = icmp slt i32 %j.inc, 2
108 br i1 %cmp.j, label %for.j, label %for.i.latch
109
110 for.i.latch:
111 %sum.i.lcssa = phi float [ %sum.j.next, %for.j ]
112 %i.inc = add i32 %i, 1
113 %cmp.i = icmp slt i32 %i.inc, 2
114 br i1 %cmp.i, label %for.i.header, label %exit
115
116 exit:
117 ret void
118 }
119
120 ; Check that the loops aren't exchanged if there is a reduction of
121 ; non-reassociative floating-point multiplication.
122 ;
123 ; float prod = 1;
124 ; for (int i = 0; i < 2; i++)
125 ; for (int j = 0; j < 2; j++)
126 ; prod *= A[j][i];
127
128 ; CHECK: --- !Missed
129 ; CHECK-NEXT: Pass: loop-interchange
130 ; CHECK-NEXT: Name: UnsupportedPHIOuter
131 ; CHECK-NEXT: Function: reduction_fmul
132 define void @reduction_fmul(ptr %A) {
133 entry:
134 br label %for.i.header
135
136 for.i.header:
137 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
138 %prod.i = phi float [ 1.0, %entry ], [ %prod.i.lcssa, %for.i.latch ]
139 br label %for.j
140
141 for.j:
142 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
143 %prod.j = phi float [ %prod.i, %for.i.header ], [ %prod.j.next, %for.j ]
144 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
145 %a = load float, ptr %idx, align 4
146 %prod.j.next = fmul float %prod.j, %a
147 %j.inc = add i32 %j, 1
148 %cmp.j = icmp slt i32 %j.inc, 2
149 br i1 %cmp.j, label %for.j, label %for.i.latch
150
151 for.i.latch:
152 %prod.i.lcssa = phi float [ %prod.j.next, %for.j ]
153 %i.inc = add i32 %i, 1
154 %cmp.i = icmp slt i32 %i.inc, 2
155 br i1 %cmp.i, label %for.i.header, label %exit
156
157 exit:
158 ret void
159 }
160
161 ; Check that the interchange is legal if the floating-point multiplication is
162 ; marked as reassoc.
163 ;
164 ; CHECK: --- !Pass
165 ; CHECK-NEXT: Pass: loop-interchange
166 ; CHECK-NEXT: Name: Interchanged
167 ; CHECK-NEXT: Function: reduction_reassoc_fmul
168 define void @reduction_reassoc_fmul(ptr %A) {
169 entry:
170 br label %for.i.header
171
172 for.i.header:
173 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
174 %prod.i = phi float [ 1.0, %entry ], [ %prod.i.lcssa, %for.i.latch ]
175 br label %for.j
176
177 for.j:
178 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
179 %prod.j = phi float [ %prod.i, %for.i.header ], [ %prod.j.next, %for.j ]
180 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
181 %a = load float, ptr %idx, align 4
182 %prod.j.next = fmul reassoc float %prod.j, %a
183 %j.inc = add i32 %j, 1
184 %cmp.j = icmp slt i32 %j.inc, 2
185 br i1 %cmp.j, label %for.j, label %for.i.latch
186
187 for.i.latch:
188 %prod.i.lcssa = phi float [ %prod.j.next, %for.j ]
189 %i.inc = add i32 %i, 1
190 %cmp.i = icmp slt i32 %i.inc, 2
191 br i1 %cmp.i, label %for.i.header, label %exit
192
193 exit:
194 ret void
195 }
196
197 ; Check that the loops aren't exchanged if there is a reduction of
198 ; non-reassociative floating-point fmuladd.
199 ;
200 ; float fmuladd = 0;
201 ; for (int i = 0; i < 2; i++)
202 ; for (int j = 0; j < 2; j++)
203 ; fmuladd += A[j][i] * B[j][i];
204
205 ; CHECK: --- !Missed
206 ; CHECK-NEXT: Pass: loop-interchange
207 ; CHECK-NEXT: Name: UnsupportedPHIOuter
208 ; CHECK-NEXT: Function: reduction_fmuladd
209 define void @reduction_fmuladd(ptr %A, ptr %B) {
210 entry:
211 br label %for.i.header
212
213 for.i.header:
214 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
215 %fmuladd.i = phi float [ 1.0, %entry ], [ %fmuladd.i.lcssa, %for.i.latch ]
216 br label %for.j
217
218 for.j:
219 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
220 %fmuladd.j = phi float [ %fmuladd.i, %for.i.header ], [ %fmuladd.j.next, %for.j ]
221 %idx.a = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
222 %idx.b = getelementptr inbounds [2 x [2 x i32]], ptr %B, i32 0, i32 %j, i32 %i
223 %a = load float, ptr %idx.a, align 4
224 %b = load float, ptr %idx.b, align 4
225 %fmuladd.j.next = call float @llvm.fmuladd.f32(float %a, float %b, float %fmuladd.j)
226 %j.inc = add i32 %j, 1
227 %cmp.j = icmp slt i32 %j.inc, 2
228 br i1 %cmp.j, label %for.j, label %for.i.latch
229
230 for.i.latch:
231 %fmuladd.i.lcssa = phi float [ %fmuladd.j.next, %for.j ]
232 %i.inc = add i32 %i, 1
233 %cmp.i = icmp slt i32 %i.inc, 2
234 br i1 %cmp.i, label %for.i.header, label %exit
235
236 exit:
237 ret void
238 }
239
240 ; Check that the interchange is legal if the floating-point fmuladd is marked
241 ; as reassoc.
242 ;
243 ; CHECK: --- !Pass
244 ; CHECK-NEXT: Pass: loop-interchange
245 ; CHECK-NEXT: Name: Interchanged
246 ; CHECK-NEXT: Function: reduction_reassoc_fmuladd
247 define void @reduction_reassoc_fmuladd(ptr %A, ptr %B) {
248 entry:
249 br label %for.i.header
250
251 for.i.header:
252 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
253 %fmuladd.i = phi float [ 1.0, %entry ], [ %fmuladd.i.lcssa, %for.i.latch ]
254 br label %for.j
255
256 for.j:
257 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
258 %fmuladd.j = phi float [ %fmuladd.i, %for.i.header ], [ %fmuladd.j.next, %for.j ]
259 %idx.a = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
260 %idx.b = getelementptr inbounds [2 x [2 x i32]], ptr %B, i32 0, i32 %j, i32 %i
261 %a = load float, ptr %idx.a, align 4
262 %b = load float, ptr %idx.b, align 4
263 %fmuladd.j.next = call reassoc float @llvm.fmuladd.f32(float %a, float %b, float %fmuladd.j)
264 %j.inc = add i32 %j, 1
265 %cmp.j = icmp slt i32 %j.inc, 2
266 br i1 %cmp.j, label %for.j, label %for.i.latch
267
268 for.i.latch:
269 %fmuladd.i.lcssa = phi float [ %fmuladd.j.next, %for.j ]
270 %i.inc = add i32 %i, 1
271 %cmp.i = icmp slt i32 %i.inc, 2
272 br i1 %cmp.i, label %for.i.header, label %exit
273
274 exit:
275 ret void
276 }
277
278 ; Check that interchanging the loops is legal for the reassociative
279 ; floating-point minimum.
280 ;
281 ; float fmin = init;
282 ; for (int i = 0; i < 2; i++)
283 ; for (int j = 0; j < 2; j++)
284 ; fmin = (A[j][i] < fmin) ? A[j][i] : fmin;
285
286 ; CHECK: --- !Pass
287 ; CHECK-NEXT: Pass: loop-interchange
288 ; CHECK-NEXT: Name: Interchanged
289 ; CHECK-NEXT: Function: reduction_fmin
290 define void @reduction_fmin(ptr %A, float %init) {
291 entry:
292 br label %for.i.header
293
294 for.i.header:
295 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
296 %fmin.i = phi float [ %init, %entry ], [ %fmin.i.lcssa, %for.i.latch ]
297 br label %for.j
298
299 for.j:
300 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
301 %fmin.j = phi float [ %fmin.i, %for.i.header ], [ %fmin.j.next, %for.j ]
302 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
303 %a = load float, ptr %idx, align 4
304 %cmp = fcmp nnan nsz olt float %a, %fmin.j
305 %fmin.j.next = select nnan nsz i1 %cmp, float %a, float %fmin.j
306 %j.inc = add i32 %j, 1
307 %cmp.j = icmp slt i32 %j.inc, 2
308 br i1 %cmp.j, label %for.j, label %for.i.latch
309
310 for.i.latch:
311 %fmin.i.lcssa = phi float [ %fmin.j.next, %for.j ]
312 %i.inc = add i32 %i, 1
313 %cmp.i = icmp slt i32 %i.inc, 2
314 br i1 %cmp.i, label %for.i.header, label %exit
315
316 exit:
317 ret void
318 }
319
320
321 ; Check that interchanging the loops is legal for the floating-point
322 ; llvm.minimumnum.
323 ;
324 ; CHECK: --- !Pass
325 ; CHECK-NEXT: Pass: loop-interchange
326 ; CHECK-NEXT: Name: Interchanged
327 ; CHECK-NEXT: Function: reduction_fmininumnum
328 define void @reduction_fmininumnum(ptr %A, float %init) {
329 entry:
330 br label %for.i.header
331
332 for.i.header:
333 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
334 %fmin.i = phi float [ %init, %entry ], [ %fmin.i.lcssa, %for.i.latch ]
335 br label %for.j
336
337 for.j:
338 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
339 %fmin.j = phi float [ %fmin.i, %for.i.header ], [ %fmin.j.next, %for.j ]
340 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
341 %a = load float, ptr %idx, align 4
342 %fmin.j.next = call float @llvm.minimumnum.f32(float %a, float %fmin.j)
343 %j.inc = add i32 %j, 1
344 %cmp.j = icmp slt i32 %j.inc, 2
345 br i1 %cmp.j, label %for.j, label %for.i.latch
346
347 for.i.latch:
348 %fmin.i.lcssa = phi float [ %fmin.j.next, %for.j ]
349 %i.inc = add i32 %i, 1
350 %cmp.i = icmp slt i32 %i.inc, 2
351 br i1 %cmp.i, label %for.i.header, label %exit
352
353 exit:
354 ret void
355 }
356
357 ; Check that interchanging the loops is legal for the reassociative
358 ; floating-point maximum.
359 ;
360 ; float fmax = init;
361 ; for (int i = 0; i < 2; i++)
362 ; for (int j = 0; j < 2; j++)
363 ; fmax = (A[j][i] > fmax) ? A[j][i] : fmax;
364
365 ; CHECK: --- !Pass
366 ; CHECK-NEXT: Pass: loop-interchange
367 ; CHECK-NEXT: Name: Interchanged
368 ; CHECK-NEXT: Function: reduction_fmax
369 define void @reduction_fmax(ptr %A, float %init) {
370 entry:
371 br label %for.i.header
372
373 for.i.header:
374 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
375 %fmax.i = phi float [ %init, %entry ], [ %fmax.i.lcssa, %for.i.latch ]
376 br label %for.j
377
378 for.j:
379 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
380 %fmax.j = phi float [ %fmax.i, %for.i.header ], [ %fmax.j.next, %for.j ]
381 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
382 %a = load float, ptr %idx, align 4
383 %cmp = fcmp nnan nsz ogt float %a, %fmax.j
384 %fmax.j.next = select nnan nsz i1 %cmp, float %a, float %fmax.j
385 %j.inc = add i32 %j, 1
386 %cmp.j = icmp slt i32 %j.inc, 2
387 br i1 %cmp.j, label %for.j, label %for.i.latch
388
389 for.i.latch:
390 %fmax.i.lcssa = phi float [ %fmax.j.next, %for.j ]
391 %i.inc = add i32 %i, 1
392 %cmp.i = icmp slt i32 %i.inc, 2
393 br i1 %cmp.i, label %for.i.header, label %exit
394
395 exit:
396 ret void
397 }
398
399 ; Check that interchanging the loops is legal for the floating-point
400 ; llvm.maximumnum.
401
402 ; CHECK: --- !Pass
403 ; CHECK-NEXT: Pass: loop-interchange
404 ; CHECK-NEXT: Name: Interchanged
405 ; CHECK-NEXT: Function: reduction_fmaxinumnum
406 define void @reduction_fmaxinumnum(ptr %A, float %init) {
407 entry:
408 br label %for.i.header
409
410 for.i.header:
411 %i = phi i32 [ 0, %entry ], [ %i.inc, %for.i.latch ]
412 %fmax.i = phi float [ %init, %entry ], [ %fmax.i.lcssa, %for.i.latch ]
413 br label %for.j
414
415 for.j:
416 %j = phi i32 [ 0, %for.i.header ], [ %j.inc, %for.j ]
417 %fmax.j = phi float [ %fmax.i, %for.i.header ], [ %fmax.j.next, %for.j ]
418 %idx = getelementptr inbounds [2 x [2 x i32]], ptr %A, i32 0, i32 %j, i32 %i
419 %a = load float, ptr %idx, align 4
420 %fmax.j.next = call float @llvm.maximumnum.f32(float %a, float %fmax.j)
421 %j.inc = add i32 %j, 1
422 %cmp.j = icmp slt i32 %j.inc, 2
423 br i1 %cmp.j, label %for.j, label %for.i.latch
424
425 for.i.latch:
426 %fmax.i.lcssa = phi float [ %fmax.j.next, %for.j ]
427 %i.inc = add i32 %i, 1
428 %cmp.i = icmp slt i32 %i.inc, 2
429 br i1 %cmp.i, label %for.i.header, label %exit
430
431 exit:
432 ret void
433 }
434
435 declare float @llvm.fmuladd.f32(float %a, float %b, float %c)
436 declare float @llvm.minimumnum.f32(float %a, float %b)
437 declare float @llvm.maximumnum.f32(float %a, float %b)