Skip to content

Commit 19a1103

Browse files
fhahnfhahn
committed
Revert "Limit to at least one loop-invariant accesses."
This reverts commit b89010a. Revert "[LAA] Check accesses don't overlap early to determine NoDep (llvm#92307)" This reverts commit 1b377db.
1 parent b89010a commit 19a1103

File tree

6 files changed

+140
-322
lines changed

6 files changed

+140
-322
lines changed

‎llvm/lib/Analysis/LoopAccessAnalysis.cpp

Lines changed: 4 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -213,7 +213,9 @@ getStartAndEndForAccess(const Loop *Lp, const SCEV *PtrExpr, Type *AccessTy,
213213

214214
if (SE->isLoopInvariant(PtrExpr, Lp)) {
215215
ScStart = ScEnd = PtrExpr;
216-
} else if (auto *AR = dyn_cast<SCEVAddRecExpr>(PtrExpr)) {
216+
} else {
217+
const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(PtrExpr);
218+
assert(AR && "Invalid addrec expression");
217219
const SCEV *Ex = PSE.getBackedgeTakenCount();
218220

219221
ScStart = AR->getStart();
@@ -232,9 +234,7 @@ getStartAndEndForAccess(const Loop *Lp, const SCEV *PtrExpr, Type *AccessTy,
232234
ScStart = SE->getUMinExpr(ScStart, ScEnd);
233235
ScEnd = SE->getUMaxExpr(AR->getStart(), ScEnd);
234236
}
235-
} else
236-
return {SE->getCouldNotCompute(), SE->getCouldNotCompute()};
237-
237+
}
238238
assert(SE->isLoopInvariant(ScStart, Lp) && "ScStart needs to be invariant");
239239
assert(SE->isLoopInvariant(ScEnd, Lp)&& "ScEnd needs to be invariant");
240240

@@ -256,9 +256,6 @@ void RuntimePointerChecking::insert(Loop *Lp, Value *Ptr, const SCEV *PtrExpr,
256256
bool NeedsFreeze) {
257257
const auto &[ScStart, ScEnd] =
258258
getStartAndEndForAccess(Lp, PtrExpr, AccessTy, PSE);
259-
assert(!isa<SCEVCouldNotCompute>(ScStart) &&
260-
!isa<SCEVCouldNotCompute>(ScEnd) &&
261-
"must be able to compute both start and end expressions");
262259
Pointers.emplace_back(Ptr, ScStart, ScEnd, WritePtr, DepSetId, ASId, PtrExpr,
263260
NeedsFreeze);
264261
}
@@ -1990,25 +1987,6 @@ getDependenceDistanceStrideAndSize(
19901987
InnermostLoop))
19911988
return MemoryDepChecker::Dependence::IndirectUnsafe;
19921989

1993-
// Check if we can prove that Sink only accesses memory after Src's end or
1994-
// vice versa.
1995-
if (SE.isLoopInvariant(Src, InnermostLoop) || SE.isLoopInvariant(Sink, InnermostLoop)) {
1996-
const auto &[SrcStart, SrcEnd] =
1997-
getStartAndEndForAccess(InnermostLoop, Src, ATy, PSE);
1998-
const auto &[SinkStart, SinkEnd] =
1999-
getStartAndEndForAccess(InnermostLoop, Sink, BTy, PSE);
2000-
2001-
if (!isa<SCEVCouldNotCompute>(SrcStart) &&
2002-
!isa<SCEVCouldNotCompute>(SrcEnd) &&
2003-
!isa<SCEVCouldNotCompute>(SinkStart) &&
2004-
!isa<SCEVCouldNotCompute>(SinkEnd)) {
2005-
if (SE.isKnownPredicate(CmpInst::ICMP_ULE, SrcEnd, SinkStart))
2006-
return MemoryDepChecker::Dependence::NoDep;
2007-
if (SE.isKnownPredicate(CmpInst::ICMP_ULE, SinkEnd, SrcStart))
2008-
return MemoryDepChecker::Dependence::NoDep;
2009-
}
2010-
}
2011-
20121990
// Need accesses with constant strides and the same direction. We don't want
20131991
// to vectorize "A[B[i]] += ..." and similar code or pointer arithmetic that
20141992
// could wrap in the address space.

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

Lines changed: 10 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -117,8 +117,16 @@ exit:
117117
; CHECK-LABEL: function 'neg_dist_dep_type_size_equivalence':
118118
; CHECK-NEXT: loop:
119119
; CHECK-NEXT: Report: unsafe dependent memory operations in loop.
120-
; CHECK-NEXT: Backward loop carried data dependence that prevents store-to-load forwarding.
120+
; CHECK-NEXT: Unknown data dependence.
121121
; CHECK-NEXT: Dependences:
122+
; CHECK-NEXT: Unknown:
123+
; CHECK-NEXT: %ld.f64 = load double, ptr %gep.iv, align 8 ->
124+
; CHECK-NEXT: store i32 %ld.i64.i32, ptr %gep.iv.n.i64, align 8
125+
; CHECK-EMPTY:
126+
; CHECK-NEXT: Unknown:
127+
; CHECK-NEXT: %ld.i64 = load i64, ptr %gep.iv, align 8 ->
128+
; CHECK-NEXT: store i32 %ld.i64.i32, ptr %gep.iv.n.i64, align 8
129+
; CHECK-EMPTY:
122130
; CHECK-NEXT: BackwardVectorizableButPreventsForwarding:
123131
; CHECK-NEXT: %ld.f64 = load double, ptr %gep.iv, align 8 ->
124132
; CHECK-NEXT: store double %val, ptr %gep.iv.101.i64, align 8
@@ -129,7 +137,7 @@ exit:
129137
; CHECK-EMPTY:
130138
; CHECK-NEXT: Unknown:
131139
; CHECK-NEXT: store double %val, ptr %gep.iv.101.i64, align 8 ->
132-
; CHECK-NEXT: store i32 %ld.i64.i32, ptr %gep.iv.n.i64, align 8
140+
; CHECK-NEXT: store i32 %ld.i64.i32, ptr %gep.iv.n.i64, align 8
133141
; CHECK-EMPTY:
134142
; CHECK-NEXT: Run-time memory checks:
135143
; CHECK-NEXT: Grouped accesses:

‎llvm/test/Analysis/LoopAccessAnalysis/invariant-dependence-before.ll

Lines changed: 48 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -4,8 +4,13 @@
44
define void @test_invar_dependence_before_positive_strided_access_1(ptr %a) {
55
; CHECK-LABEL: 'test_invar_dependence_before_positive_strided_access_1'
66
; CHECK-NEXT: loop:
7-
; CHECK-NEXT: Memory dependences are safe
7+
; 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
8+
; CHECK-NEXT: Unknown data dependence.
89
; CHECK-NEXT: Dependences:
10+
; CHECK-NEXT: Unknown:
11+
; CHECK-NEXT: %l = load i32, ptr %a, align 4 ->
12+
; CHECK-NEXT: store i32 %l, ptr %gep, align 4
13+
; CHECK-EMPTY:
914
; CHECK-NEXT: Run-time memory checks:
1015
; CHECK-NEXT: Grouped accesses:
1116
; CHECK-EMPTY:
@@ -34,8 +39,13 @@ exit:
3439
define void @test_invar_dependence_before_positive_strided_access_2(ptr %a) {
3540
; CHECK-LABEL: 'test_invar_dependence_before_positive_strided_access_2'
3641
; CHECK-NEXT: loop:
37-
; CHECK-NEXT: Memory dependences are safe
42+
; 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
43+
; CHECK-NEXT: Unknown data dependence.
3844
; CHECK-NEXT: Dependences:
45+
; CHECK-NEXT: Unknown:
46+
; CHECK-NEXT: %l = load i32, ptr %gep, align 4 ->
47+
; CHECK-NEXT: store i32 %l, ptr %a, align 4
48+
; CHECK-EMPTY:
3949
; CHECK-NEXT: Run-time memory checks:
4050
; CHECK-NEXT: Grouped accesses:
4151
; CHECK-EMPTY:
@@ -134,8 +144,13 @@ exit:
134144
define void @test_invar_dependence_before_positive_strided_access_1_different_access_sizes(ptr %a) {
135145
; CHECK-LABEL: 'test_invar_dependence_before_positive_strided_access_1_different_access_sizes'
136146
; CHECK-NEXT: loop:
137-
; CHECK-NEXT: Memory dependences are safe
147+
; 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
148+
; CHECK-NEXT: Unknown data dependence.
138149
; CHECK-NEXT: Dependences:
150+
; CHECK-NEXT: Unknown:
151+
; CHECK-NEXT: %l = load i32, ptr %a, align 4 ->
152+
; CHECK-NEXT: store i8 %t, ptr %gep, align 1
153+
; CHECK-EMPTY:
139154
; CHECK-NEXT: Run-time memory checks:
140155
; CHECK-NEXT: Grouped accesses:
141156
; CHECK-EMPTY:
@@ -201,8 +216,13 @@ exit:
201216
define void @test_invar_dependence_before_negative_strided_access_1(ptr %a) {
202217
; CHECK-LABEL: 'test_invar_dependence_before_negative_strided_access_1'
203218
; CHECK-NEXT: loop:
204-
; CHECK-NEXT: Memory dependences are safe
219+
; 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
220+
; CHECK-NEXT: Unknown data dependence.
205221
; CHECK-NEXT: Dependences:
222+
; CHECK-NEXT: Unknown:
223+
; CHECK-NEXT: %l = load i32, ptr %a, align 4 ->
224+
; CHECK-NEXT: store i32 %l, ptr %gep, align 4
225+
; CHECK-EMPTY:
206226
; CHECK-NEXT: Run-time memory checks:
207227
; CHECK-NEXT: Grouped accesses:
208228
; CHECK-EMPTY:
@@ -231,8 +251,13 @@ exit:
231251
define void @test_invar_dependence_before_negative_strided_access_2(ptr %a) {
232252
; CHECK-LABEL: 'test_invar_dependence_before_negative_strided_access_2'
233253
; CHECK-NEXT: loop:
234-
; CHECK-NEXT: Memory dependences are safe
254+
; 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
255+
; CHECK-NEXT: Unknown data dependence.
235256
; CHECK-NEXT: Dependences:
257+
; CHECK-NEXT: Unknown:
258+
; CHECK-NEXT: %l = load i32, ptr %gep, align 4 ->
259+
; CHECK-NEXT: store i32 %l, ptr %a, align 4
260+
; CHECK-EMPTY:
236261
; CHECK-NEXT: Run-time memory checks:
237262
; CHECK-NEXT: Grouped accesses:
238263
; CHECK-EMPTY:
@@ -332,8 +357,13 @@ exit:
332357
define void @test_both_invar_before_1(ptr %a) {
333358
; CHECK-LABEL: 'test_both_invar_before_1'
334359
; CHECK-NEXT: loop:
335-
; CHECK-NEXT: Memory dependences are safe
360+
; 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
361+
; CHECK-NEXT: Unknown data dependence.
336362
; CHECK-NEXT: Dependences:
363+
; CHECK-NEXT: Unknown:
364+
; CHECK-NEXT: %l = load i32, ptr %a, align 4 ->
365+
; CHECK-NEXT: store i32 %l, ptr %gep.off, align 4
366+
; CHECK-EMPTY:
337367
; CHECK-NEXT: Run-time memory checks:
338368
; CHECK-NEXT: Grouped accesses:
339369
; CHECK-EMPTY:
@@ -361,8 +391,13 @@ exit:
361391
define void @test_both_invar_before_2(ptr %a) {
362392
; CHECK-LABEL: 'test_both_invar_before_2'
363393
; CHECK-NEXT: loop:
364-
; CHECK-NEXT: Memory dependences are safe
394+
; 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
395+
; CHECK-NEXT: Unknown data dependence.
365396
; CHECK-NEXT: Dependences:
397+
; CHECK-NEXT: Unknown:
398+
; CHECK-NEXT: %l = load i32, ptr %gep.off, align 4 ->
399+
; CHECK-NEXT: store i32 %l, ptr %a, align 4
400+
; CHECK-EMPTY:
366401
; CHECK-NEXT: Run-time memory checks:
367402
; CHECK-NEXT: Grouped accesses:
368403
; CHECK-EMPTY:
@@ -723,8 +758,13 @@ exit:
723758
define void @test_invar_vector_dependence_before_positive_strided_access_1(ptr %a) {
724759
; CHECK-LABEL: 'test_invar_vector_dependence_before_positive_strided_access_1'
725760
; CHECK-NEXT: loop:
726-
; CHECK-NEXT: Memory dependences are safe
761+
; 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
762+
; CHECK-NEXT: Unknown data dependence.
727763
; CHECK-NEXT: Dependences:
764+
; CHECK-NEXT: Unknown:
765+
; CHECK-NEXT: %l = load <4 x i8>, ptr %a, align 4 ->
766+
; CHECK-NEXT: store i32 0, ptr %gep, align 4
767+
; CHECK-EMPTY:
728768
; CHECK-NEXT: Run-time memory checks:
729769
; CHECK-NEXT: Grouped accesses:
730770
; CHECK-EMPTY:

‎llvm/test/Analysis/LoopAccessAnalysis/loop-invariant-dep-with-backedge-taken-count.ll

Lines changed: 12 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -7,8 +7,13 @@
77
define void @test_distance_greater_than_BTC_100(ptr %a) {
88
; CHECK-LABEL: 'test_distance_greater_than_BTC_100'
99
; CHECK-NEXT: loop:
10-
; CHECK-NEXT: Memory dependences are safe
10+
; 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
11+
; CHECK-NEXT: Unknown data dependence.
1112
; CHECK-NEXT: Dependences:
13+
; CHECK-NEXT: Unknown:
14+
; CHECK-NEXT: %l = load i32, ptr %gep.x, align 4 ->
15+
; CHECK-NEXT: store i32 %l, ptr %gep, align 4
16+
; CHECK-EMPTY:
1217
; CHECK-NEXT: Run-time memory checks:
1318
; CHECK-NEXT: Grouped accesses:
1419
; CHECK-EMPTY:
@@ -107,8 +112,13 @@ exit:
107112
define void @test_distance_greater_than_BTC_10000(ptr %a) {
108113
; CHECK-LABEL: 'test_distance_greater_than_BTC_10000'
109114
; CHECK-NEXT: loop:
110-
; CHECK-NEXT: Memory dependences are safe
115+
; 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
116+
; CHECK-NEXT: Unknown data dependence.
111117
; CHECK-NEXT: Dependences:
118+
; CHECK-NEXT: Unknown:
119+
; CHECK-NEXT: %l = load i32, ptr %gep.x, align 4 ->
120+
; CHECK-NEXT: store i32 %l, ptr %gep, align 4
121+
; CHECK-EMPTY:
112122
; CHECK-NEXT: Run-time memory checks:
113123
; CHECK-NEXT: Grouped accesses:
114124
; CHECK-EMPTY:

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

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -45,8 +45,13 @@ exit:
4545
define void @different_non_constant_strides_known_backward_distance_larger_than_trip_count(ptr %A) {
4646
; CHECK-LABEL: 'different_non_constant_strides_known_backward_distance_larger_than_trip_count'
4747
; CHECK-NEXT: loop:
48-
; CHECK-NEXT: Memory dependences are safe
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.
4950
; 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:
5055
; CHECK-NEXT: Run-time memory checks:
5156
; CHECK-NEXT: Grouped accesses:
5257
; CHECK-EMPTY:

0 commit comments

Comments
 (0)