[LAA] LLE 3/6: Rename InterestingDependence to Dependences, NFC

[anemet]

Summary

We now collect all types of dependences including lexically forward
deps not just "interesting" ones.

[rengolin]

Mechanical change to a better name. LGTM.

[hfinkel]

LGTM.

include/llvm/Analysis/LoopAccessAnalysis.h

enum DepType {
       // We couldn't determine the direction or the distance.
       Unknown,
       // Lexically forward.
       //
       // FIXME: If we only have loop-independent forward dependences (e.g. a
       // read and write of A[i]), LAA will locally deem the dependence "safe"
       // without querying the MemoryDepChecker.  Therefore we can miss
       // enumerating loop-independent forward dependences in
-      // getInterestingDependences.  Note that as soon as there are different
+      // getDependences.  Note that as soon as there are different
       // indices used to access the same array, the MemoryDepChecker *is*
       // queried and the dependence list is complete.
       Forward,
       // Forward, but if vectorized, is likely to prevent store-to-load
       // forwarding.
       ForwardButPreventsForwarding,
       // Lexically backward.
       Backward,
struct Dependence {
     DepType Type;
 
     Dependence(unsigned Source, unsigned Destination, DepType Type)
         : Source(Source), Destination(Destination), Type(Type) {}
 
     /// \brief Dependence types that don't prevent vectorization.
     static bool isSafeForVectorization(DepType Type);
 
-    /// \brief Dependence types that can be queried from the analysis.
-    static bool isInterestingDependence(DepType Type);
-
     /// \brief Lexically backward dependence types.
     bool isPossiblyBackward() const;
 
     /// \brief Print the dependence.  \p Instr is used to map the instruction
     /// indices to instructions.
     void print(raw_ostream &OS, unsigned Depth,
                const SmallVectorImpl<Instruction *> &Instrs) const;
   };
 
   MemoryDepChecker(ScalarEvolution *Se, const Loop *L)
       : SE(Se), InnermostLoop(L), AccessIdx(0),
         ShouldRetryWithRuntimeCheck(false), SafeForVectorization(true),
-        RecordInterestingDependences(true) {}
+        RecordDependences(true) {}
 
   /// \brief Register the location (instructions are given increasing numbers)
   /// of a write access.
   void addAccess(StoreInst *SI) {
     Value *Ptr = SI->getPointerOperand();
     Accesses[MemAccessInfo(Ptr, true)].push_back(AccessIdx);
     InstMap.push_back(SI);
     ++AccessIdx;
public:
   /// \brief The maximum number of bytes of a vector register we can vectorize
   /// the accesses safely with.
   unsigned getMaxSafeDepDistBytes() { return MaxSafeDepDistBytes; }
 
   /// \brief In same cases when the dependency check fails we can still
   /// vectorize the loop with a dynamic array access check.
   bool shouldRetryWithRuntimeCheck() { return ShouldRetryWithRuntimeCheck; }
 
-  /// \brief Returns the interesting dependences.  If null is returned we
-  /// exceeded the MaxInterestingDependence threshold and this information is
-  /// not available.
-  const SmallVectorImpl<Dependence> *getInterestingDependences() const {
-    return RecordInterestingDependences ? &InterestingDependences : nullptr;
+  /// \brief Returns the memory dependences.  If null is returned we exceeded
+  /// the MaxDependences threshold and this information is not
+  /// available.
+  const SmallVectorImpl<Dependence> *getDependences() const {
+    return RecordDependences ? &Dependences : nullptr;
   }
 
-  void clearInterestingDependences() { InterestingDependences.clear(); }
+  void clearDependences() { Dependences.clear(); }
 
   /// \brief The vector of memory access instructions.  The indices are used as
   /// instruction identifiers in the Dependence class.
   const SmallVectorImpl<Instruction *> &getMemoryInstructions() const {
     return InstMap;
   }
 
   /// \brief Find the set of instructions that read or write via \p Ptr.
private:
   /// \brief If we see a non-constant dependence distance we can still try to
   /// vectorize this loop with runtime checks.
   bool ShouldRetryWithRuntimeCheck;
 
   /// \brief No memory dependence was encountered that would inhibit
   /// vectorization.
   bool SafeForVectorization;
 
-  //// \brief True if InterestingDependences reflects the dependences in the
-  //// loop.  If false we exceeded MaxInterestingDependence and
-  //// InterestingDependences is invalid.
-  bool RecordInterestingDependences;
-
-  /// \brief Interesting memory dependences collected during the analysis as
-  /// defined by isInterestingDependence.  Only valid if
-  /// RecordInterestingDependences is true.
-  SmallVector<Dependence, 8> InterestingDependences;
+  //// \brief True if Dependences reflects the dependences in the
+  //// loop.  If false we exceeded MaxDependences and
+  //// Dependences is invalid.
+  bool RecordDependences;
+
+  /// \brief Memory dependences collected during the analysis.  Only valid if
+  /// RecordDependences is true.
+  SmallVector<Dependence, 8> Dependences;
 
   /// \brief Check whether there is a plausible dependence between the two
   /// accesses.
   ///
   /// Access \p A must happen before \p B in program order. The two indices
   /// identify the index into the program order map.
   ///
   /// This function checks  whether there is a plausible dependence (or the

lib/Analysis/LoopAccessAnalysis.cpp

static cl::opt<unsigned> MemoryCheckMergeThreshold(
     "memory-check-merge-threshold", cl::Hidden,
     cl::desc("Maximum number of comparisons done when trying to merge "
              "runtime memory checks. (default = 100)"),
     cl::init(100));
 
 /// Maximum SIMD width.
 const unsigned VectorizerParams::MaxVectorWidth = 64;
 
-/// \brief We collect interesting dependences up to this threshold.
-static cl::opt<unsigned> MaxInterestingDependence(
-    "max-interesting-dependences", cl::Hidden,
-    cl::desc("Maximum number of interesting dependences collected by "
+/// \brief We collect dependences up to this threshold.
+static cl::opt<unsigned>
+    MaxDependences("max-dependences", cl::Hidden,
+                   cl::desc("Maximum number of dependences collected by "
                             "loop-access analysis (default = 100)"),
                    cl::init(100));
 
 bool VectorizerParams::isInterleaveForced() {
   return ::VectorizationInterleave.getNumOccurrences() > 0;
 }
 
 void LoopAccessReport::emitAnalysis(const LoopAccessReport &Message,
                                     const Function *TheFunction,
                                     const Loop *TheLoop,
public:
   ///
   /// Note that this can later be cleared if we retry memcheck analysis without
   /// dependency checking (i.e. ShouldRetryWithRuntimeCheck).
   bool isDependencyCheckNeeded() { return !CheckDeps.empty(); }
 
   /// We decided that no dependence analysis would be used.  Reset the state.
   void resetDepChecks(MemoryDepChecker &DepChecker) {
     CheckDeps.clear();
-    DepChecker.clearInterestingDependences();
+    DepChecker.clearDependences();
   }
 
   MemAccessInfoSet &getDependenciesToCheck() { return CheckDeps; }
 
 private:
   typedef SetVector<MemAccessInfo> PtrAccessSet;
 
   /// \brief Go over all memory access and check whether runtime pointer checks
bool MemoryDepChecker::Dependence::isSafeForVectorization(DepType Type) {
   case ForwardButPreventsForwarding:
   case Backward:
   case BackwardVectorizableButPreventsForwarding:
     return false;
   }
   llvm_unreachable("unexpected DepType!");
 }
 
-bool MemoryDepChecker::Dependence::isInterestingDependence(DepType Type) {
-  return Type != NoDep;
-}
-
 bool MemoryDepChecker::Dependence::isPossiblyBackward() const {
   switch (Type) {
   case NoDep:
   case Forward:
   case ForwardButPreventsForwarding:
     return false;
 
   case Unknown:
while (AI != AE) {
             assert(*I1 != *I2);
             if (*I1 > *I2)
               std::swap(A, B);
 
             Dependence::DepType Type =
                 isDependent(*A.first, A.second, *B.first, B.second, Strides);
             SafeForVectorization &= Dependence::isSafeForVectorization(Type);
 
-            // Gather dependences unless we accumulated MaxInterestingDependence
+            // Gather dependences unless we accumulated MaxDependences
             // dependences.  In that case return as soon as we find the first
             // unsafe dependence.  This puts a limit on this quadratic
             // algorithm.
-            if (RecordInterestingDependences) {
-              if (Dependence::isInterestingDependence(Type))
-                InterestingDependences.push_back(
-                    Dependence(A.second, B.second, Type));
-
-              if (InterestingDependences.size() >= MaxInterestingDependence) {
-                RecordInterestingDependences = false;
-                InterestingDependences.clear();
+            if (RecordDependences) {
+              if (Type != Dependence::NoDep)
+                Dependences.push_back(Dependence(A.second, B.second, Type));
+
+              if (Dependences.size() >= MaxDependences) {
+                RecordDependences = false;
+                Dependences.clear();
                 DEBUG(dbgs() << "Too many dependences, stopped recording\n");
               }
             }
-            if (!RecordInterestingDependences && !SafeForVectorization)
+            if (!RecordDependences && !SafeForVectorization)
               return false;
           }
         ++OI;
       }
       AI++;
     }
   }
 
-  DEBUG(dbgs() << "Total Interesting Dependences: "
-               << InterestingDependences.size() << "\n");
+  DEBUG(dbgs() << "Total Dependences: " << Dependences.size() << "\n");
   return SafeForVectorization;
 }
 
 SmallVector<Instruction *, 4>
 MemoryDepChecker::getInstructionsForAccess(Value *Ptr, bool isWrite) const {
   MemAccessInfo Access(Ptr, isWrite);
   auto &IndexVector = Accesses.find(Access)->second;
 
if (PtrRtChecking.Need)
       OS.indent(Depth) << "Memory dependences are safe with run-time checks\n";
     else
       OS.indent(Depth) << "Memory dependences are safe\n";
   }
 
   if (Report)
     OS.indent(Depth) << "Report: " << Report->str() << "\n";
 
-  if (auto *InterestingDependences = DepChecker.getInterestingDependences()) {
-    OS.indent(Depth) << "Interesting Dependences:\n";
-    for (auto &Dep : *InterestingDependences) {
+  if (auto *Dependences = DepChecker.getDependences()) {
+    OS.indent(Depth) << "Dependences:\n";
+    for (auto &Dep : *Dependences) {
       Dep.print(OS, Depth + 2, DepChecker.getMemoryInstructions());
       OS << "\n";
     }
   } else
-    OS.indent(Depth) << "Too many interesting dependences, not recorded\n";
+    OS.indent(Depth) << "Too many dependences, not recorded\n";
 
   // List the pair of accesses need run-time checks to prove independence.
   PtrRtChecking.print(OS, Depth);
   OS << "\n";
 
   OS.indent(Depth) << "Store to invariant address was "
                    << (StoreToLoopInvariantAddress ? "" : "not ")
                    << "found in loop.\n";

lib/Transforms/Scalar/LoopDistribute.cpp

public:
 
   typedef SmallVector<Entry, 8> AccessesType;
 
   AccessesType::const_iterator begin() const { return Accesses.begin(); }
   AccessesType::const_iterator end() const { return Accesses.end(); }
 
   MemoryInstructionDependences(
       const SmallVectorImpl<Instruction *> &Instructions,
-      const SmallVectorImpl<Dependence> &InterestingDependences) {
+      const SmallVectorImpl<Dependence> &Dependences) {
     Accesses.append(Instructions.begin(), Instructions.end());
 
     DEBUG(dbgs() << "Backward dependences:\n");
-    for (auto &Dep : InterestingDependences)
+    for (auto &Dep : Dependences)
       if (Dep.isPossiblyBackward()) {
         // Note that the designations source and destination follow the program
         // order, i.e. source is always first.  (The direction is given by the
         // DepType.)
         ++Accesses[Dep.Source].NumUnsafeDependencesStartOrEnd;
         --Accesses[Dep.Destination].NumUnsafeDependencesStartOrEnd;
 
         DEBUG(Dep.print(dbgs(), 2, Instructions));
bool processLoop(Loop *L) {
     const LoopAccessInfo &LAI = LAA->getInfo(L, ValueToValueMap());
 
     // Currently, we only distribute to isolate the part of the loop with
     // dependence cycles to enable partial vectorization.
     if (LAI.canVectorizeMemory()) {
       DEBUG(dbgs() << "Skipping; memory operations are safe for vectorization");
       return false;
     }
-    auto *InterestingDependences =
-        LAI.getDepChecker().getInterestingDependences();
-    if (!InterestingDependences || InterestingDependences->empty()) {
+    auto *Dependences = LAI.getDepChecker().getDependences();
+    if (!Dependences || Dependences->empty()) {
       DEBUG(dbgs() << "Skipping; No unsafe dependences to isolate");
       return false;
     }
 
     InstPartitionContainer Partitions(L, LI, DT);
 
     // First, go through each memory operation and assign them to consecutive
     // partitions (the order of partitions follows program order).  Put those
bool processLoop(Loop *L) {
     //  Store3  -'                    -1                       1->0
     //  Load4                          0                       0
     //
     // NumUnsafeDependencesActive > 0 indicates this situation and in this case
     // we just keep assigning to the same cyclic partition until
     // NumUnsafeDependencesActive reaches 0.
     const MemoryDepChecker &DepChecker = LAI.getDepChecker();
     MemoryInstructionDependences MID(DepChecker.getMemoryInstructions(),
-                                     *InterestingDependences);
+                                     *Dependences);
 
     int NumUnsafeDependencesActive = 0;
     for (auto &InstDep : MID) {
       Instruction *I = InstDep.Inst;
       // We update NumUnsafeDependencesActive post-instruction, catch the
       // start of a dependence directly via NumUnsafeDependencesStartOrEnd.
       if (NumUnsafeDependencesActive ||
           InstDep.NumUnsafeDependencesStartOrEnd > 0)

test/Analysis/LoopAccessAnalysis/forward-loop-carried.ll

 ; 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: 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

test/Analysis/LoopAccessAnalysis/forward-loop-independent.ll

 ;     A[i] = 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* noalias %A, i32* noalias %B, i32* noalias %C, i64 %N) {
 
-; CHECK: Interesting Dependences:
+; CHECK: Dependences:
 ; CHECK-NEXT:   Forward:
 ; CHECK-NEXT:       store i32 %b_p1, i32* %Aidx, align 4 ->
 ; CHECK-NEXT:       %a = load i32, i32* %Aidx, align 4
 ; CHECK:        ForwardButPreventsForwarding:
 ; CHECK-NEXT:       store i32 %b_p2, i32* %Aidx_next, align 4 ->
 ; CHECK-NEXT:       %a = load i32, i32* %Aidx, align 4
 ; CHECK:        Forward:
 ; CHECK-NEXT:       store i32 %b_p2, i32* %Aidx_next, align 4 ->

test/Analysis/LoopAccessAnalysis/pointer-with-unknown-bounds.ll

 ; RUN: opt -loop-accesses -analyze < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ; We shouldn't quit the analysis if we encounter a pointer without known
 ; bounds *unless* we actually need to emit a memcheck for it.  (We only
 ; compute bounds for SCEVAddRecs so A[i*i] is deemed not having known bounds.)
 ;
 ; for (i = 0; i < 20; ++i)
 ;   A[i*i] *= 2;
 
 ; CHECK: for.body:
 ; CHECK:     Report: unsafe dependent memory operations in loop
 ; CHECK-NOT: Report: cannot identify array bounds
-; CHECK:     Interesting Dependences:
+; CHECK:     Dependences:
 ; CHECK:       Unknown:
 ; CHECK:           %loadA = load i16, i16* %arrayidxA, align 2 ->
 ; CHECK:           store i16 %mul, i16* %arrayidxA, align 2
 
 define void @f(i16* %a) {
 entry:
   br label %for.body
 

test/Analysis/LoopAccessAnalysis/resort-to-memchecks-only.ll

 ; RUN: opt -loop-accesses -analyze < %s | FileCheck %s
 
 ; We give up analyzing the dependences in this loop due to non-constant
 ; distance between A[i+offset] and A[i] and add memchecks to prove
-; independence.  Make sure that no interesting dependences are reported in
+; independence.  Make sure that no dependences are reported in
 ; this case.
 ;
 ;   for (i = 0; i < n; i++)
 ;    A[i + offset] = A[i] * B[i] * C[i];
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 ; CHECK: Memory dependences are safe with run-time checks
-; CHECK-NEXT: Interesting Dependences:
+; CHECK-NEXT: Dependences:
 ; CHECK-NEXT: Run-time memory checks:
 ; CHECK-NEXT: 0:
 ; CHECK-NEXT: Comparing group
 ; CHECK-NEXT:   %arrayidxA2 = getelementptr inbounds i16, i16* %a, i64 %idx
 ; CHECK-NEXT: Against group
 ; CHECK-NEXT:   %arrayidxA = getelementptr inbounds i16, i16* %a, i64 %indvar
 
 @B = common global i16* null, align 8

test/Analysis/LoopAccessAnalysis/safe-no-checks.ll

 ; RUN: opt -basicaa -loop-accesses -analyze < %s | FileCheck %s
 
 ; If the arrays don't alias this loop is safe with no memchecks:
 ;   for (i = 0; i < n; i++)
 ;    A[i] = A[i+1] * B[i] * C[i];
 
 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: 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,
                i16* noalias %c) {

test/Analysis/LoopAccessAnalysis/stride-access-dependence.ll

 ; RUN: opt -loop-accesses -analyze < %s | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
 
 ; Following cases are no dependence.
 
 ; void nodep_Read_Write(int *A) {
 ;   int *B = A + 1;
 ;   for (unsigned i = 0; i < 1024; i+=3)
 ;     B[i] = A[i] + 1;
 ; }
 
 ; CHECK: function 'nodep_Read_Write':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Memory dependences are safe
-; CHECK-NEXT:     Interesting Dependences:
+; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:     Run-time memory checks:
 
 define void @nodep_Read_Write(i32* nocapture %A) {
 entry:
   %add.ptr = getelementptr inbounds i32, i32* %A, i64 1
   br label %for.body
 
 for.cond.cleanup:                                 ; preds = %for.body

 ;   }
 ;   
 ;   return sum;
 ; }
 
 ; CHECK: function 'nodep_Write_Read':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Memory dependences are safe
-; CHECK-NEXT:     Interesting Dependences:
+; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:     Run-time memory checks:
 
 define i32 @nodep_Write_Read(i32* nocapture %A) {
 entry:
   br label %for.body
 
 for.cond.cleanup:                                 ; preds = %for.body
   ret i32 %add3

 ;     A[i] = i;
 ;     A[i+1] = i+1;
 ;   }
 ; }
 
 ; CHECK: function 'nodep_Write_Write':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Memory dependences are safe
-; CHECK-NEXT:     Interesting Dependences:
+; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:     Run-time memory checks:
 
 define void @nodep_Write_Write(i32* nocapture %A) {
 entry:
   br label %for.body
 
 for.cond.cleanup:                                 ; preds = %for.body
   ret void

 ; void unsafe_Read_Write(int *A) {
 ;   for (unsigned i = 0; i < 1024; i+=3)
 ;     A[i+3] = A[i] + 1;
 ; }
 
 ; CHECK: function 'unsafe_Read_Write':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
-; CHECK-NEXT:     Interesting Dependences:
+; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:      Backward:
 ; CHECK-NEXT:           %0 = load i32, i32* %arrayidx, align 4 -> 
 ; CHECK-NEXT:           store i32 %add, i32* %arrayidx3, align 4
 
 define void @unsafe_Read_Write(i32* nocapture %A) {
 entry:
   br label %for.body
 

 ;   }
 ;
 ;   return sum;
 ; }
 
 ; CHECK: function 'unsafe_Write_Read':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
-; CHECK-NEXT:     Interesting Dependences:
+; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:      Backward:
 ; CHECK-NEXT:           store i32 %0, i32* %arrayidx, align 4 ->
 ; CHECK-NEXT:           %1 = load i32, i32* %arrayidx2, align 4
 
 define i32 @unsafe_Write_Read(i32* nocapture %A) {
 entry:
   br label %for.body
 

 ;     A[i] = i;
 ;     A[i+2] = i+1;
 ;   }
 ; }
 
 ; CHECK: function 'unsafe_Write_Write':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
-; CHECK-NEXT:     Interesting Dependences:
+; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:      Backward:
 ; CHECK-NEXT:           store i32 %0, i32* %arrayidx, align 4 ->
 ; CHECK-NEXT:           store i32 %2, i32* %arrayidx3, align 4
 
 define void @unsafe_Write_Write(i32* nocapture %A) {
 entry:
   br label %for.body
 

 ;   int *B = A + 4;
 ;   for (unsigned i = 0; i < 1024; i+=2)
 ;     B[i] = A[i] + 1;
 ; }
 
 ; CHECK: function 'vectorizable_Read_Write':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Memory dependences are safe
-; CHECK-NEXT:     Interesting Dependences:
+; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:       BackwardVectorizable:
 ; CHECK-NEXT:           %0 = load i32, i32* %arrayidx, align 4 ->
 ; CHECK-NEXT:           store i32 %add, i32* %arrayidx2, align 4
 
 define void @vectorizable_Read_Write(i32* nocapture %A) {
 entry:
   %add.ptr = getelementptr inbounds i32, i32* %A, i64 4
   br label %for.body

 ;   }
 ;   
 ;   return sum;
 ; }
 
 ; CHECK: function 'vectorizable_Write_Read':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Memory dependences are safe
-; CHECK-NEXT:     Interesting Dependences:
+; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:       BackwardVectorizable:
 ; CHECK-NEXT:           store i32 %0, i32* %arrayidx, align 4 ->
 ; CHECK-NEXT:           %1 = load i32, i32* %arrayidx2, align 4
 
 define i32 @vectorizable_Write_Read(i32* nocapture %A) {
 entry:
   %add.ptr = getelementptr inbounds i32, i32* %A, i64 4
   br label %for.body

 ;     A[i] = i;
 ;     B[i] = i+1;
 ;   }
 ; }
 
 ; CHECK: function 'vectorizable_Write_Write':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Memory dependences are safe
-; CHECK-NEXT:     Interesting Dependences:
+; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:       BackwardVectorizable:
 ; CHECK-NEXT:           store i32 %0, i32* %arrayidx, align 4 -> 
 ; CHECK-NEXT:           store i32 %2, i32* %arrayidx2, align 4
 
 define void @vectorizable_Write_Write(i32* nocapture %A) {
 entry:
   %add.ptr = getelementptr inbounds i32, i32* %A, i64 4
   br label %for.body

 ; }
 
 ; FIXME: This case looks like previous case @vectorizable_Read_Write. It sould
 ; be vectorizable.
 
 ; CHECK: function 'vectorizable_unscaled_Read_Write':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
-; CHECK-NEXT:     Interesting Dependences:
+; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:       BackwardVectorizableButPreventsForwarding:
 ; CHECK-NEXT:           %2 = load i32, i32* %arrayidx, align 4 ->
 ; CHECK-NEXT:           store i32 %add, i32* %arrayidx2, align 4
 
 define void @vectorizable_unscaled_Read_Write(i32* nocapture %A) {
 entry:
   %0 = bitcast i32* %A to i8*
   %add.ptr = getelementptr inbounds i8, i8* %0, i64 14

 ;   }
 ; 
 ;   return sum;
 ; }
 
 ; CHECK: for function 'vectorizable_unscaled_Write_Read':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Memory dependences are safe
-; CHECK-NEXT:     Interesting Dependences:
+; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:       BackwardVectorizable:
 ; CHECK-NEXT:           store i32 %2, i32* %arrayidx, align 4 -> 
 ; CHECK-NEXT:           %3 = load i32, i32* %arrayidx2, align 4
 
 define i32 @vectorizable_unscaled_Write_Read(i32* nocapture %A) {
 entry:
   %0 = bitcast i32* %A to i8*
   %add.ptr = getelementptr inbounds i8, i8* %0, i64 17

 ;   int *B = (int *)((char *)A + 11);
 ;   for (unsigned i = 0; i < 1024; i+=2)
 ;     B[i] = A[i] + 1;
 ; }
 
 ; CHECK: function 'unsafe_unscaled_Read_Write':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
-; CHECK-NEXT:     Interesting Dependences:
+; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:       Backward:
 ; CHECK-NEXT:           %2 = load i32, i32* %arrayidx, align 4 -> 
 ; CHECK-NEXT:           store i32 %add, i32* %arrayidx2, align 4
 
 define void @unsafe_unscaled_Read_Write(i32* nocapture %A) {
 entry:
   %0 = bitcast i32* %A to i8*
   %add.ptr = getelementptr inbounds i8, i8* %0, i64 11
for.body:                                         ; preds = %entry, %for.body
   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2
   %cmp = icmp ult i64 %indvars.iv.next, 1024
   br i1 %cmp, label %for.body, label %for.cond.cleanup
 }
 
 ; CHECK: function 'unsafe_unscaled_Read_Write2':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
-; CHECK-NEXT:     Interesting Dependences:
+; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:       Backward:
 ; CHECK-NEXT:           %2 = load i32, i32* %arrayidx, align 4 -> 
 ; CHECK-NEXT:           store i32 %add, i32* %arrayidx2, align 4
 
 ; void unsafe_unscaled_Read_Write2(int *A) {
 ;   int *B = (int *)((char *)A + 1);
 ;   for (unsigned i = 0; i < 1024; i+=2)
 ;     B[i] = A[i] + 1;

 ;   }
 ; }
 ;
 ; The access (2) has overlaps with (1) and (3).
 
 ; CHECK: function 'interleaved_stores':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
-; CHECK-NEXT:     Interesting Dependences:
+; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:       Backward:
 ; CHECK-NEXT:           store i32 %4, i32* %arrayidx5, align 4 -> 
 ; CHECK-NEXT:           store i32 %4, i32* %arrayidx9, align 4
 ; CHECK:       Backward:
 ; CHECK-NEXT:           store i32 %2, i32* %arrayidx2, align 4 -> 
 ; CHECK-NEXT:           store i32 %4, i32* %arrayidx5, align 4
 
 define void @interleaved_stores(i32* nocapture %A) {

test/Analysis/LoopAccessAnalysis/underlying-objects-2.ll

 ; memchecks (that is what LAA does after encountering a case of non-constant
 ; distance).
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 ; CHECK: for_j.body:
 ; CHECK-NEXT: Report: unsafe dependent memory operations in loop
-; CHECK-NEXT: Interesting Dependences:
+; CHECK-NEXT: Dependences:
 ; CHECK-NEXT: Backward:
 ; CHECK-NEXT: %loadB = load i8, i8* %gepB, align 1 ->
 ; CHECK-NEXT: store i8 2, i8* %gepB_plus_one, align 1
 
 define void @f(i8** noalias %A, i8* noalias %B, i64 %N) {
 for_i.preheader:
   %prev_0 = load i8*, i8** %A, align 8
   br label %for_i.body

test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks.ll

 ; RUN: opt -loop-accesses -analyze < %s | FileCheck %s
 
 ; Analyze this loop:
 ;   for (i = 0; i < n; i++)
 ;    A[i + 1] = A[i] * B[i] * C[i];
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 ; CHECK: Report: unsafe dependent memory operations in loop
-; CHECK-NEXT: Interesting Dependences:
+; CHECK-NEXT: Dependences:
 ; CHECK-NEXT:   Backward:
 ; CHECK-NEXT:     %loadA = load i16, i16* %arrayidxA, align 2 ->
 ; CHECK-NEXT:     store i16 %mul1, i16* %arrayidxA_plus_2, align 2
 ; CHECK: Run-time memory checks:
 ; CHECK-NEXT: 0:
 ; CHECK-NEXT: Comparing group
 ; CHECK-NEXT:   %arrayidxA = getelementptr inbounds i16, i16* %a, i64 %storemerge3
 ; CHECK-NEXT:   %arrayidxA_plus_2 = getelementptr inbounds i16, i16* %a, i64 %add