llvm-project

1
; RUN: opt %loadNPMPolly -polly-stmt-granularity=bb "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines
2
;
3
; Do not remove the scalar value write of %i.trunc in inner.for.
4
; It is used by body.
5
; %i.trunc is synthesizable in inner.for, so some code might think it is
6
; synthesizable everywhere such that no scalar write would be needed.
7
;
8
; Note that -polly-simplify rightfully removes %inner.cond. It should
9
; not have been added to the instruction list in the first place.
10
;
11
define void @func(i32 %n, ptr noalias nonnull %A) {
12
entry:
13
  br label %for
14

15
for:
16
  %j = phi i32 [0, %entry], [%j.inc, %inc]
17
  %j.cmp = icmp slt i32 %j, %n
18
  %zero = sext i32 0 to i64
19
  br i1 %j.cmp, label %inner.for, label %exit
20

21

22
    ; This loop has some unusual properties:
23
    ; * It has a known iteration count (1), therefore SCoP-compatible.
24
    ; * %i.trunc is synthesizable within the loop ({1,+,1}<%while.body>).
25
    ; * %i.trunc is not synthesizable outside of the loop, because its value is
26
    ;   unknown when exiting.
27
    ;   (should be 1, but ScalarEvolution currently seems unable to derive that)
28
    ;
29
    ; ScalarEvolution currently seems to not able to handle the %zero.
30
    ; If it becomes more intelligent, there might be other such loop constructs.
31
    inner.for:
32
      %i = phi i64 [%zero, %for], [%i.inc, %inner.for]
33
      %i.inc = add nuw nsw i64 %i, 1
34
      %i.trunc = trunc i64 %i.inc to i32
35
      %i.and = and i32 %i.trunc, 6
36
      %inner.cond = icmp eq i32 %i.and, 0
37
      br i1 %inner.cond, label %body, label %inner.for
38

39
    body:
40
      store i32 %i.trunc, ptr %A
41
      br label %inc
42

43

44
inc:
45
  %j.inc = add nuw nsw i32 %j, 1
46
  br label %for
47

48
exit:
49
  br label %return
50

51
return:
52
  ret void
53
}
54

55

56
; CHECK:      After accesses {
57
; CHECK-NEXT:     Stmt_inner_for
58
; CHECK-NEXT:             MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 1]
59
; CHECK-NEXT:                 [n] -> { Stmt_inner_for[i0, i1] -> MemRef_i_trunc[] };
60
; CHECK-NEXT:     Stmt_body
61
; CHECK-NEXT:             MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
62
; CHECK-NEXT:                 [n] -> { Stmt_body[i0] -> MemRef_A[0] };
63
; CHECK-NEXT:             ReadAccess :=       [Reduction Type: NONE] [Scalar: 1]
64
; CHECK-NEXT:                 [n] -> { Stmt_body[i0] -> MemRef_i_trunc[] };
65
; CHECK-NEXT: }
66