From 26abcb32772f9d7a198612a9d1ac5f437a3f8da1 Mon Sep 17 00:00:00 2001
From: Adam Nemet <anemet@apple.com>
Date: Tue, 3 Nov 2015 20:13:23 +0000
Subject: [PATCH] [LAA] LLE 1/6: Expose Forward dependences

Summary:
Before this change, we didn't use to collect forward dependences since
none of the current clients (LV, LDist) required them.

The motivation to also collect forward dependences is a new pass
LoopLoadElimination (LLE) which discovers store-to-load forwarding
opportunities across the loop's backedge.  The pass uses both lexically
forward or backward loop-carried dependences to detect these
opportunities.

The new pass also analyzes loop-independent (forward) dependences since
they can conflict with the loop-carried dependences in terms of how the
data flows through memory.

The newly added test only covers loop-carried forward dependences
because loop-independent ones are currently categorized as NoDep.  The
next patch will fix this.

The two patches were tested together for compile-time regression.  None
found in LNT/SPEC.

Note that with this change LAA provides all dependences rather than just
"interesting" ones.  A subsequent NFC patch will remove the now trivial
isInterestingDependence and rename the APIs.

Reviewers: hfinkel

Subscribers: jmolloy, rengolin, llvm-commits

Differential Revision: http://reviews.llvm.org/D13254

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@251972 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Analysis/LoopAccessAnalysis.cpp           | 14 +-----
 .../forward-loop-carried.ll                   | 44 +++++++++++++++++++
 .../LoopAccessAnalysis/safe-no-checks.ll      |  8 ++++
 3 files changed, 53 insertions(+), 13 deletions(-)
 create mode 100644 test/Analysis/LoopAccessAnalysis/forward-loop-carried.ll

diff --git a/lib/Analysis/LoopAccessAnalysis.cpp b/lib/Analysis/LoopAccessAnalysis.cpp
index 25025db0527..b4b646f8144 100644
--- a/lib/Analysis/LoopAccessAnalysis.cpp
+++ b/lib/Analysis/LoopAccessAnalysis.cpp
@@ -911,19 +911,7 @@ bool MemoryDepChecker::Dependence::isSafeForVectorization(DepType Type) {
 }
 
 bool MemoryDepChecker::Dependence::isInterestingDependence(DepType Type) {
-  switch (Type) {
-  case NoDep:
-  case Forward:
-    return false;
-
-  case BackwardVectorizable:
-  case Unknown:
-  case ForwardButPreventsForwarding:
-  case Backward:
-  case BackwardVectorizableButPreventsForwarding:
-    return true;
-  }
-  llvm_unreachable("unexpected DepType!");
+  return Type != NoDep;
 }
 
 bool MemoryDepChecker::Dependence::isPossiblyBackward() const {
diff --git a/test/Analysis/LoopAccessAnalysis/forward-loop-carried.ll b/test/Analysis/LoopAccessAnalysis/forward-loop-carried.ll
new file mode 100644
index 00000000000..138762c2a66
--- /dev/null
+++ b/test/Analysis/LoopAccessAnalysis/forward-loop-carried.ll
@@ -0,0 +1,44 @@
+; RUN: opt -loop-accesses -analyze < %s | FileCheck %s
+
+;   for (unsigned i = 0; i < 100; i++) {
+;     A[i+8] = B[i] + 2;
+;     C[i] = A[i] * 2;
+;   }
+
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+
+define void @f(i32* %A, i32* %B, i32* %C, i64 %N) {
+
+; CHECK: Interesting Dependences:
+; CHECK-NEXT: Forward:
+; CHECK-NEXT:   store i32 %a_p1, i32* %Aidx_ahead, align 4 ->
+; CHECK-NEXT:   %a = load i32, i32* %Aidx, align 4
+
+entry:
+  br label %for.body
+
+for.body:                                         ; preds = %for.body, %entry
+  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+
+  %idx = add nuw nsw i64 %indvars.iv, 8
+
+  %Aidx_ahead = getelementptr inbounds i32, i32* %A, i64 %idx
+  %Bidx = getelementptr inbounds i32, i32* %B, i64 %indvars.iv
+  %Cidx = getelementptr inbounds i32, i32* %C, i64 %indvars.iv
+  %Aidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
+
+  %b = load i32, i32* %Bidx, align 4
+  %a_p1 = add i32 %b, 2
+  store i32 %a_p1, i32* %Aidx_ahead, align 4
+
+  %a = load i32, i32* %Aidx, align 4
+  %c = mul i32 %a, 2
+  store i32 %c, i32* %Cidx, align 4
+
+  %exitcond = icmp eq i64 %indvars.iv.next, %N
+  br i1 %exitcond, label %for.end, label %for.body
+
+for.end:                                          ; preds = %for.body
+  ret void
+}
diff --git a/test/Analysis/LoopAccessAnalysis/safe-no-checks.ll b/test/Analysis/LoopAccessAnalysis/safe-no-checks.ll
index fa70c024a9c..069135e8525 100644
--- a/test/Analysis/LoopAccessAnalysis/safe-no-checks.ll
+++ b/test/Analysis/LoopAccessAnalysis/safe-no-checks.ll
@@ -7,7 +7,15 @@
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
+; Check the loop-carried forward anti-dep between the load of A[i+1] and the
+; store of A[i];
+
 ; CHECK: Memory dependences are safe{{$}}
+; CHECK-NEXT: Interesting Dependences:
+; CHECK-NEXT:   Forward:
+; CHECK-NEXT:     %loadA_plus_2 = load i16, i16* %arrayidxA_plus_2, align 2 ->
+; CHECK-NEXT:     store i16 %mul1, i16* %arrayidxA, align 2
+
 
 define void @f(i16* noalias %a,
                i16* noalias %b,
-- 
2.34.1