Skip to content

Commit 53a1ea4

Browse files
fhahnfhahn
committed
!fixup Update and merge.
1 parent bcb8853 commit 53a1ea4

File tree

2 files changed

+42
-80
lines changed

2 files changed

+42
-80
lines changed

‎llvm/lib/Analysis/LoopAccessAnalysis.cpp

Lines changed: 6 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1934,7 +1934,7 @@ struct DepDistanceStrideAndSizeInfo {
19341934
};
19351935
} // namespace
19361936

1937-
// Get the dependence distance, stride, type size and whether it is a write for
1937+
// Get the dependence distance, strides, type size and whether it is a write for
19381938
// the dependence between A and B. Returns a DepType, if we can prove there's
19391939
// no dependence or the analysis fails. Outlined to lambda to limit he scope
19401940
// of various temporary variables, like A/BPtr, StrideA/BPtr and others.
@@ -2035,7 +2035,7 @@ MemoryDepChecker::Dependence::DepType MemoryDepChecker::isDependent(
20352035

20362036
uint64_t CommonStride = StrideA == StrideB ? StrideA : 0;
20372037
if (isa<SCEVCouldNotCompute>(Dist)) {
2038-
FoundNonConstantDistanceDependence = true;
2038+
FoundNonConstantDistanceDependence |= CommonStride;
20392039
LLVM_DEBUG(dbgs() << "LAA: Dependence because of uncomputable distance.\n");
20402040
return Dependence::Unknown;
20412041
}
@@ -2086,7 +2086,7 @@ MemoryDepChecker::Dependence::DepType MemoryDepChecker::isDependent(
20862086
// since a forward dependency will allow vectorization using any width.
20872087
if (IsTrueDataDependence && EnableForwardingConflictDetection) {
20882088
if (!C) {
2089-
FoundNonConstantDistanceDependence = true;
2089+
FoundNonConstantDistanceDependence |= CommonStride;
20902090
return Dependence::Unknown;
20912091
}
20922092
if (!HasSameSize ||
@@ -2103,22 +2103,20 @@ MemoryDepChecker::Dependence::DepType MemoryDepChecker::isDependent(
21032103
}
21042104

21052105
if (!SE.isKnownPositive(Dist)) {
2106-
if (!C)
2107-
FoundNonConstantDistanceDependence = true;
2106+
FoundNonConstantDistanceDependence |= !C && CommonStride;
21082107
return Dependence::Unknown;
21092108
}
21102109

21112110
if (!HasSameSize) {
21122111
LLVM_DEBUG(dbgs() << "LAA: ReadWrite-Write positive dependency with "
21132112
"different type sizes\n");
2114-
if (!C)
2115-
FoundNonConstantDistanceDependence = true;
2113+
FoundNonConstantDistanceDependence |= !C && CommonStride;
21162114
return Dependence::Unknown;
21172115
}
21182116

21192117
if (!C) {
21202118
LLVM_DEBUG(dbgs() << "LAA: Dependence because of non-constant distance\n");
2121-
FoundNonConstantDistanceDependence = true;
2119+
FoundNonConstantDistanceDependence |= CommonStride;
21222120
return Dependence::Unknown;
21232121
}
21242122

‎llvm/test/Analysis/LoopAccessAnalysis/non-constant-strides-backward.ll

Lines changed: 36 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -8,21 +8,15 @@ declare void @llvm.assume(i1)
88
define void @different_non_constant_strides_known_backward(ptr %A) {
99
; CHECK-LABEL: 'different_non_constant_strides_known_backward'
1010
; CHECK-NEXT: loop:
11-
; CHECK-NEXT: Memory dependences are safe with run-time checks
11+
; 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
12+
; CHECK-NEXT: Unknown data dependence.
1213
; CHECK-NEXT: Dependences:
14+
; CHECK-NEXT: Unknown:
15+
; CHECK-NEXT: %l = load i32, ptr %gep, align 4 ->
16+
; CHECK-NEXT: store i32 %add, ptr %gep.mul.2, align 4
17+
; CHECK-EMPTY:
1318
; CHECK-NEXT: Run-time memory checks:
14-
; CHECK-NEXT: Check 0:
15-
; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
16-
; CHECK-NEXT: %gep.mul.2 = getelementptr inbounds i32, ptr %A, i64 %iv.mul.2
17-
; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
18-
; CHECK-NEXT: %gep = getelementptr inbounds i32, ptr %A, i64 %iv
1919
; CHECK-NEXT: Grouped accesses:
20-
; CHECK-NEXT: Group [[GRP1]]:
21-
; CHECK-NEXT: (Low: %A High: (2044 + %A))
22-
; CHECK-NEXT: Member: {%A,+,8}<nuw><%loop>
23-
; CHECK-NEXT: Group [[GRP2]]:
24-
; CHECK-NEXT: (Low: %A High: (1024 + %A))
25-
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop>
2620
; CHECK-EMPTY:
2721
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
2822
; CHECK-NEXT: SCEV assumptions:
@@ -51,21 +45,15 @@ exit:
5145
define void @different_non_constant_strides_known_backward_distance_larger_than_trip_count(ptr %A) {
5246
; CHECK-LABEL: 'different_non_constant_strides_known_backward_distance_larger_than_trip_count'
5347
; CHECK-NEXT: loop:
54-
; CHECK-NEXT: Memory dependences are safe with run-time checks
48+
; 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
49+
; CHECK-NEXT: Unknown data dependence.
5550
; CHECK-NEXT: Dependences:
51+
; CHECK-NEXT: Unknown:
52+
; CHECK-NEXT: %l = load i32, ptr %gep, align 4 ->
53+
; CHECK-NEXT: store i32 %add, ptr %gep.mul.2, align 4
54+
; CHECK-EMPTY:
5655
; CHECK-NEXT: Run-time memory checks:
57-
; CHECK-NEXT: Check 0:
58-
; CHECK-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
59-
; CHECK-NEXT: %gep.mul.2 = getelementptr inbounds i32, ptr %A.1024, i64 %iv.mul.2
60-
; CHECK-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
61-
; CHECK-NEXT: %gep = getelementptr inbounds i32, ptr %A, i64 %iv
6256
; CHECK-NEXT: Grouped accesses:
63-
; CHECK-NEXT: Group [[GRP3]]:
64-
; CHECK-NEXT: (Low: (1024 + %A)<nuw> High: (3068 + %A))
65-
; CHECK-NEXT: Member: {(1024 + %A)<nuw>,+,8}<nuw><%loop>
66-
; CHECK-NEXT: Group [[GRP4]]:
67-
; CHECK-NEXT: (Low: %A High: (1024 + %A)<nuw>)
68-
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop>
6957
; CHECK-EMPTY:
7058
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
7159
; CHECK-NEXT: SCEV assumptions:
@@ -95,21 +83,15 @@ exit:
9583
define void @different_non_constant_strides_known_backward_min_distance_16(ptr %A) {
9684
; CHECK-LABEL: 'different_non_constant_strides_known_backward_min_distance_16'
9785
; CHECK-NEXT: loop:
98-
; CHECK-NEXT: Memory dependences are safe with run-time checks
86+
; 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
87+
; CHECK-NEXT: Unknown data dependence.
9988
; CHECK-NEXT: Dependences:
89+
; CHECK-NEXT: Unknown:
90+
; CHECK-NEXT: %l = load i32, ptr %gep, align 4 ->
91+
; CHECK-NEXT: store i32 %add, ptr %gep.mul.2, align 4
92+
; CHECK-EMPTY:
10093
; CHECK-NEXT: Run-time memory checks:
101-
; CHECK-NEXT: Check 0:
102-
; CHECK-NEXT: Comparing group ([[GRP5:0x[0-9a-f]+]]):
103-
; CHECK-NEXT: %gep.mul.2 = getelementptr inbounds i32, ptr %A.16, i64 %iv.mul.2
104-
; CHECK-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
105-
; CHECK-NEXT: %gep = getelementptr inbounds i32, ptr %A, i64 %iv
10694
; CHECK-NEXT: Grouped accesses:
107-
; CHECK-NEXT: Group [[GRP5]]:
108-
; CHECK-NEXT: (Low: (16 + %A)<nuw> High: (2060 + %A))
109-
; CHECK-NEXT: Member: {(16 + %A)<nuw>,+,8}<nuw><%loop>
110-
; CHECK-NEXT: Group [[GRP6]]:
111-
; CHECK-NEXT: (Low: %A High: (1024 + %A))
112-
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop>
11395
; CHECK-EMPTY:
11496
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
11597
; CHECK-NEXT: SCEV assumptions:
@@ -139,21 +121,15 @@ exit:
139121
define void @different_non_constant_strides_known_backward_min_distance_15(ptr %A) {
140122
; CHECK-LABEL: 'different_non_constant_strides_known_backward_min_distance_15'
141123
; CHECK-NEXT: loop:
142-
; CHECK-NEXT: Memory dependences are safe with run-time checks
124+
; 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
125+
; CHECK-NEXT: Unknown data dependence.
143126
; CHECK-NEXT: Dependences:
127+
; CHECK-NEXT: Unknown:
128+
; CHECK-NEXT: %l = load i32, ptr %gep, align 4 ->
129+
; CHECK-NEXT: store i32 %add, ptr %gep.mul.2, align 4
130+
; CHECK-EMPTY:
144131
; CHECK-NEXT: Run-time memory checks:
145-
; CHECK-NEXT: Check 0:
146-
; CHECK-NEXT: Comparing group ([[GRP7:0x[0-9a-f]+]]):
147-
; CHECK-NEXT: %gep.mul.2 = getelementptr inbounds i32, ptr %A.15, i64 %iv.mul.2
148-
; CHECK-NEXT: Against group ([[GRP8:0x[0-9a-f]+]]):
149-
; CHECK-NEXT: %gep = getelementptr inbounds i32, ptr %A, i64 %iv
150132
; CHECK-NEXT: Grouped accesses:
151-
; CHECK-NEXT: Group [[GRP7]]:
152-
; CHECK-NEXT: (Low: (15 + %A)<nuw> High: (2059 + %A))
153-
; CHECK-NEXT: Member: {(15 + %A)<nuw>,+,8}<nuw><%loop>
154-
; CHECK-NEXT: Group [[GRP8]]:
155-
; CHECK-NEXT: (Low: %A High: (1024 + %A))
156-
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop>
157133
; CHECK-EMPTY:
158134
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
159135
; CHECK-NEXT: SCEV assumptions:
@@ -183,21 +159,15 @@ exit:
183159
define void @different_non_constant_strides_known_backward_min_distance_8(ptr %A) {
184160
; CHECK-LABEL: 'different_non_constant_strides_known_backward_min_distance_8'
185161
; CHECK-NEXT: loop:
186-
; CHECK-NEXT: Memory dependences are safe with run-time checks
162+
; 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
163+
; CHECK-NEXT: Unknown data dependence.
187164
; CHECK-NEXT: Dependences:
165+
; CHECK-NEXT: Unknown:
166+
; CHECK-NEXT: %l = load i32, ptr %gep, align 4 ->
167+
; CHECK-NEXT: store i32 %add, ptr %gep.mul.2, align 4
168+
; CHECK-EMPTY:
188169
; CHECK-NEXT: Run-time memory checks:
189-
; CHECK-NEXT: Check 0:
190-
; CHECK-NEXT: Comparing group ([[GRP9:0x[0-9a-f]+]]):
191-
; CHECK-NEXT: %gep.mul.2 = getelementptr inbounds i32, ptr %A.8, i64 %iv.mul.2
192-
; CHECK-NEXT: Against group ([[GRP10:0x[0-9a-f]+]]):
193-
; CHECK-NEXT: %gep = getelementptr inbounds i32, ptr %A, i64 %iv
194170
; CHECK-NEXT: Grouped accesses:
195-
; CHECK-NEXT: Group [[GRP9]]:
196-
; CHECK-NEXT: (Low: (8 + %A)<nuw> High: (2052 + %A))
197-
; CHECK-NEXT: Member: {(8 + %A)<nuw>,+,8}<nuw><%loop>
198-
; CHECK-NEXT: Group [[GRP10]]:
199-
; CHECK-NEXT: (Low: %A High: (1024 + %A))
200-
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop>
201171
; CHECK-EMPTY:
202172
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
203173
; CHECK-NEXT: SCEV assumptions:
@@ -227,21 +197,15 @@ exit:
227197
define void @different_non_constant_strides_known_backward_min_distance_3(ptr %A) {
228198
; CHECK-LABEL: 'different_non_constant_strides_known_backward_min_distance_3'
229199
; CHECK-NEXT: loop:
230-
; CHECK-NEXT: Memory dependences are safe with run-time checks
200+
; 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
201+
; CHECK-NEXT: Unknown data dependence.
231202
; CHECK-NEXT: Dependences:
203+
; CHECK-NEXT: Unknown:
204+
; CHECK-NEXT: %l = load i32, ptr %gep, align 4 ->
205+
; CHECK-NEXT: store i32 %add, ptr %gep.mul.2, align 4
206+
; CHECK-EMPTY:
232207
; CHECK-NEXT: Run-time memory checks:
233-
; CHECK-NEXT: Check 0:
234-
; CHECK-NEXT: Comparing group ([[GRP11:0x[0-9a-f]+]]):
235-
; CHECK-NEXT: %gep.mul.2 = getelementptr inbounds i32, ptr %A.3, i64 %iv.mul.2
236-
; CHECK-NEXT: Against group ([[GRP12:0x[0-9a-f]+]]):
237-
; CHECK-NEXT: %gep = getelementptr inbounds i32, ptr %A, i64 %iv
238208
; CHECK-NEXT: Grouped accesses:
239-
; CHECK-NEXT: Group [[GRP11]]:
240-
; CHECK-NEXT: (Low: (3 + %A)<nuw> High: (2047 + %A))
241-
; CHECK-NEXT: Member: {(3 + %A)<nuw>,+,8}<nuw><%loop>
242-
; CHECK-NEXT: Group [[GRP12]]:
243-
; CHECK-NEXT: (Low: %A High: (1024 + %A))
244-
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop>
245209
; CHECK-EMPTY:
246210
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
247211
; CHECK-NEXT: SCEV assumptions:

0 commit comments

Comments
 (0)