Skip to content

Commit 540d6ab

Browse files
artagnonartagnon
committed
[LAA] Pre-commit tests exercising different types
Pre-commit tests exercising different types of source/sink in depend_diff_types.ll, in preparation to weaken the HasSameSize check in LoopAccessAnalysis.
1 parent 440a4de commit 540d6ab

File tree

1 file changed

+240
-0
lines changed

1 file changed

+240
-0
lines changed

‎llvm/test/Analysis/LoopAccessAnalysis/depend_diff_types.ll

Lines changed: 240 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -262,3 +262,243 @@ loop:
262262
exit:
263263
ret void
264264
}
265+
266+
; The type-size of the source is different from that of the sink,
267+
; and the dependence distance is 10.
268+
; TODO: Relax the HasSameSize check; the strided accesses are
269+
; independent, as determined by both the source size and the sink size.
270+
; This test should report no dependencies.
271+
define void @different_type_sizes_strided_accesses_independent(ptr %dst) {
272+
; CHECK-LABEL: 'different_type_sizes_strided_accesses_independent'
273+
; CHECK-NEXT: loop:
274+
; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
275+
; CHECK-NEXT: Unknown data dependence.
276+
; CHECK-NEXT: Dependences:
277+
; CHECK-NEXT: Unknown:
278+
; CHECK-NEXT: store i16 0, ptr %gep.iv, align 2 ->
279+
; CHECK-NEXT: store i8 1, ptr %gep.10.iv, align 1
280+
; CHECK-EMPTY:
281+
; CHECK-NEXT: Run-time memory checks:
282+
; CHECK-NEXT: Grouped accesses:
283+
; CHECK-EMPTY:
284+
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
285+
; CHECK-NEXT: SCEV assumptions:
286+
; CHECK-EMPTY:
287+
; CHECK-NEXT: Expressions re-written:
288+
;
289+
entry:
290+
%gep.10 = getelementptr nuw i8, ptr %dst, i64 10
291+
br label %loop
292+
293+
loop:
294+
%iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
295+
%gep.iv = getelementptr i8, ptr %dst, i64 %iv
296+
store i16 0, ptr %gep.iv
297+
%gep.10.iv = getelementptr i8, ptr %gep.10, i64 %iv
298+
store i8 1, ptr %gep.10.iv
299+
%iv.next = add i64 %iv, 8
300+
%ec = icmp eq i64 %iv.next, 64
301+
br i1 %ec, label %exit, label %loop
302+
303+
exit:
304+
ret void
305+
}
306+
307+
; Variant of the above, where the source size forbids strided access
308+
; independence.
309+
; TODO: Relax the HasSameSize check; this test should report a backward
310+
; loop-carried dependence.
311+
define void @different_type_sizes_strided_accesses_dependent(ptr %dst) {
312+
; CHECK-LABEL: 'different_type_sizes_strided_accesses_dependent'
313+
; CHECK-NEXT: loop:
314+
; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
315+
; CHECK-NEXT: Unknown data dependence.
316+
; CHECK-NEXT: Dependences:
317+
; CHECK-NEXT: Unknown:
318+
; CHECK-NEXT: store i64 0, ptr %gep.iv, align 4 ->
319+
; CHECK-NEXT: store i8 1, ptr %gep.10.iv, align 1
320+
; CHECK-EMPTY:
321+
; CHECK-NEXT: Run-time memory checks:
322+
; CHECK-NEXT: Grouped accesses:
323+
; CHECK-EMPTY:
324+
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
325+
; CHECK-NEXT: SCEV assumptions:
326+
; CHECK-EMPTY:
327+
; CHECK-NEXT: Expressions re-written:
328+
;
329+
entry:
330+
%gep.10 = getelementptr nuw i8, ptr %dst, i64 10
331+
br label %loop
332+
333+
loop:
334+
%iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
335+
%gep.iv = getelementptr i8, ptr %dst, i64 %iv
336+
store i64 0, ptr %gep.iv
337+
%gep.10.iv = getelementptr i8, ptr %gep.10, i64 %iv
338+
store i8 1, ptr %gep.10.iv
339+
%iv.next = add i64 %iv, 8
340+
%ec = icmp eq i64 %iv.next, 64
341+
br i1 %ec, label %exit, label %loop
342+
343+
exit:
344+
ret void
345+
}
346+
347+
; Source type-size differs from that of the sink, but when
348+
; determining backward dependence, only the source size
349+
; is relevant.
350+
; TODO: Relax the HasSameSize check; this test should report
351+
; BackwardVectorizable.
352+
define void @different_type_sizes_source_size_backwardvectorizible(ptr %dst) {
353+
; CHECK-LABEL: 'different_type_sizes_source_size_backwardvectorizible'
354+
; CHECK-NEXT: loop:
355+
; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
356+
; CHECK-NEXT: Unknown data dependence.
357+
; CHECK-NEXT: Dependences:
358+
; CHECK-NEXT: Unknown:
359+
; CHECK-NEXT: store i16 0, ptr %gep.iv, align 2 ->
360+
; CHECK-NEXT: store i32 1, ptr %gep.10.iv, align 4
361+
; CHECK-EMPTY:
362+
; CHECK-NEXT: Run-time memory checks:
363+
; CHECK-NEXT: Grouped accesses:
364+
; CHECK-EMPTY:
365+
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
366+
; CHECK-NEXT: SCEV assumptions:
367+
; CHECK-EMPTY:
368+
; CHECK-NEXT: Expressions re-written:
369+
;
370+
entry:
371+
%gep.10 = getelementptr nuw i8, ptr %dst, i64 10
372+
br label %loop
373+
374+
loop:
375+
%iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
376+
%gep.iv = getelementptr i8, ptr %dst, i64 %iv
377+
store i16 0, ptr %gep.iv
378+
%gep.10.iv = getelementptr i8, ptr %gep.10, i64 %iv
379+
store i32 1, ptr %gep.10.iv
380+
%iv.next = add i64 %iv, 8
381+
%ec = icmp eq i64 %iv.next, 64
382+
br i1 %ec, label %exit, label %loop
383+
384+
exit:
385+
ret void
386+
}
387+
388+
; Source type-size differs from that of the sink, and when
389+
; determining forward dependence, the source size can
390+
; prevent forwarding.
391+
define void @different_type_sizes_forward(ptr %dst) {
392+
; CHECK-LABEL: 'different_type_sizes_forward'
393+
; CHECK-NEXT: loop:
394+
; CHECK-NEXT: Memory dependences are safe
395+
; CHECK-NEXT: Dependences:
396+
; CHECK-NEXT: Forward:
397+
; CHECK-NEXT: store i32 0, ptr %gep.10.iv, align 4 ->
398+
; CHECK-NEXT: store i16 1, ptr %gep.iv, align 2
399+
; CHECK-EMPTY:
400+
; CHECK-NEXT: Run-time memory checks:
401+
; CHECK-NEXT: Grouped accesses:
402+
; CHECK-EMPTY:
403+
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
404+
; CHECK-NEXT: SCEV assumptions:
405+
; CHECK-EMPTY:
406+
; CHECK-NEXT: Expressions re-written:
407+
;
408+
entry:
409+
%gep.10 = getelementptr nuw i8, ptr %dst, i64 10
410+
br label %loop
411+
412+
loop:
413+
%iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
414+
%gep.10.iv = getelementptr i8, ptr %gep.10, i64 %iv
415+
store i32 0, ptr %gep.10.iv
416+
%gep.iv = getelementptr i8, ptr %dst, i64 %iv
417+
store i16 1, ptr %gep.iv
418+
%iv.next = add i64 %iv, 8
419+
%ec = icmp eq i64 %iv.next, 64
420+
br i1 %ec, label %exit, label %loop
421+
422+
exit:
423+
ret void
424+
}
425+
426+
; Same as the above, but here, the store size should not prevent
427+
; ld->st forwarding.
428+
; TODO: Relax the HasSameSize check; this test should report a
429+
; forward dependence.
430+
define void @different_type_sizes_store_size_cannot_prevent_forwarding(ptr %A, ptr noalias %B) {
431+
; CHECK-LABEL: 'different_type_sizes_store_size_cannot_prevent_forwarding'
432+
; CHECK-NEXT: loop:
433+
; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
434+
; CHECK-NEXT: Forward loop carried data dependence that prevents store-to-load forwarding.
435+
; CHECK-NEXT: Dependences:
436+
; CHECK-NEXT: ForwardButPreventsForwarding:
437+
; CHECK-NEXT: store i32 0, ptr %gep.A, align 4 ->
438+
; CHECK-NEXT: %l = load i16, ptr %gep.A.1, align 2
439+
; CHECK-EMPTY:
440+
; CHECK-NEXT: Run-time memory checks:
441+
; CHECK-NEXT: Grouped accesses:
442+
; CHECK-EMPTY:
443+
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
444+
; CHECK-NEXT: SCEV assumptions:
445+
; CHECK-EMPTY:
446+
; CHECK-NEXT: Expressions re-written:
447+
;
448+
entry:
449+
%A.1 = getelementptr i32, ptr %A, i64 1
450+
br label %loop
451+
452+
loop:
453+
%iv = phi i64 [ 1022, %entry ], [ %iv.next, %loop ]
454+
%gep.A = getelementptr inbounds i32, ptr %A, i64 %iv
455+
store i32 0, ptr %gep.A
456+
%gep.A.1 = getelementptr i32, ptr %A.1, i64 %iv
457+
%l = load i16, ptr %gep.A.1
458+
store i16 %l, ptr %B
459+
%iv.next = add nsw i64 %iv, -1
460+
%cmp = icmp eq i64 %iv, 0
461+
br i1 %cmp, label %exit, label %loop
462+
463+
exit:
464+
ret void
465+
}
466+
467+
; Same as the above, but here, the load size prevents
468+
; ld->st forwarding.
469+
define void @different_type_sizes_load_size_prevents_forwarding(ptr %A, ptr noalias %B) {
470+
; CHECK-LABEL: 'different_type_sizes_load_size_prevents_forwarding'
471+
; CHECK-NEXT: loop:
472+
; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
473+
; CHECK-NEXT: Forward loop carried data dependence that prevents store-to-load forwarding.
474+
; CHECK-NEXT: Dependences:
475+
; CHECK-NEXT: ForwardButPreventsForwarding:
476+
; CHECK-NEXT: store i16 0, ptr %gep.A, align 2 ->
477+
; CHECK-NEXT: %l = load i32, ptr %gep.A.1, align 4
478+
; CHECK-EMPTY:
479+
; CHECK-NEXT: Run-time memory checks:
480+
; CHECK-NEXT: Grouped accesses:
481+
; CHECK-EMPTY:
482+
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
483+
; CHECK-NEXT: SCEV assumptions:
484+
; CHECK-EMPTY:
485+
; CHECK-NEXT: Expressions re-written:
486+
;
487+
entry:
488+
%A.1 = getelementptr i32, ptr %A, i64 1
489+
br label %loop
490+
491+
loop:
492+
%iv = phi i64 [ 1022, %entry ], [ %iv.next, %loop ]
493+
%gep.A = getelementptr inbounds i32, ptr %A, i64 %iv
494+
store i16 0, ptr %gep.A
495+
%gep.A.1 = getelementptr i32, ptr %A.1, i64 %iv
496+
%l = load i32, ptr %gep.A.1
497+
store i32 %l, ptr %B
498+
%iv.next = add nsw i64 %iv, -1
499+
%cmp = icmp eq i64 %iv, 0
500+
br i1 %cmp, label %exit, label %loop
501+
502+
exit:
503+
ret void
504+
}

0 commit comments

Comments
 (0)