[LoopInterchange] Prevent interchange if one index is constant and the other has loop carried dependence

Consider the following loop from
llvm#54176

  for (int j = 1; j < M; j++)
    for (int i = 1; i < N; i++) {
      aa[1][j-1] += bb[i][j];
      cc[i][j] = aa[1][j];
    }

Loops should not be interchanged in this case as it will change the
cc array results.

Author: ShivaChen

llvm/include/llvm/Analysis/DependenceAnalysis.h

@@ -306,9 +306,9 @@ namespace llvm {
     /// The flag PossiblyLoopIndependent should be set by the caller
     /// if it appears that control flow can reach from Src to Dst
     /// without traversing a loop back edge.
-    std::unique_ptr<Dependence> depends(Instruction *Src,
-                                        Instruction *Dst,
-                                        bool PossiblyLoopIndependent);
+    std::unique_ptr<Dependence> depends(Instruction *Src, Instruction *Dst,
+                                        bool PossiblyLoopIndependent,
+                                        bool *HasConstantIndex = nullptr);
 
     /// getSplitIteration - Give a dependence that's splittable at some
     /// particular level, return the iteration that should be used to split

llvm/lib/Analysis/DependenceAnalysis.cpp

@@ -3588,7 +3588,7 @@ bool DependenceInfo::invalidate(Function &F, const PreservedAnalyses &PA,
 // up to date with respect to this routine.
 std::unique_ptr<Dependence>
 DependenceInfo::depends(Instruction *Src, Instruction *Dst,
-                        bool PossiblyLoopIndependent) {
+                        bool PossiblyLoopIndependent, bool *HasConstantIndex) {
   if (Src == Dst)
     PossiblyLoopIndependent = false;
 
@@ -3674,6 +3674,9 @@ DependenceInfo::depends(Instruction *Src, Instruction *Dst,
     LLVM_DEBUG(dbgs() << "\tclass = " << Pair[P].Classification << "\n");
     LLVM_DEBUG(dbgs() << "\tloops = ");
     LLVM_DEBUG(dumpSmallBitVector(Pair[P].Loops));
+    if (HasConstantIndex)
+      if (isa<SCEVConstant>(Pair[P].Src) || isa<SCEVConstant>(Pair[P].Dst))
+        *HasConstantIndex = true;
   }
 
   SmallBitVector Separable(Pairs);

llvm/lib/Transforms/Scalar/LoopInterchange.cpp

@@ -117,11 +117,12 @@ static bool populateDependencyMatrix(CharMatrix &DepMatrix, unsigned Level,
       std::vector<char> Dep;
       Instruction *Src = cast<Instruction>(*I);
       Instruction *Dst = cast<Instruction>(*J);
+      bool HasConstantIndex = false;
       // Ignore Input dependencies.
       if (isa<LoadInst>(Src) && isa<LoadInst>(Dst))
         continue;
       // Track Output, Flow, and Anti dependencies.
-      if (auto D = DI->depends(Src, Dst, true)) {
+      if (auto D = DI->depends(Src, Dst, true, &HasConstantIndex)) {
         assert(D->isOrdered() && "Expected an output, flow or anti dep.");
         // If the direction vector is negative, normalize it to
         // make it non-negative.
@@ -150,6 +151,13 @@ static bool populateDependencyMatrix(CharMatrix &DepMatrix, unsigned Level,
               Direction = '=';
             else
               Direction = '*';
+
+            // Bail out if there is constant index and the other has loop
+            // carried dependence.
+            if (HasConstantIndex && (Direction == '>' || Direction == '<')) {
+              dbgs() << "Has Constant Index and loop carried dependence\n";
+              return false;
+            }
             Dep.push_back(Direction);
           }
         }

llvm/test/Transforms/LoopInterchange/pr54176.ll

@@ -6,13 +6,16 @@
 @cc = global [1024 x [128 x float]] zeroinitializer, align 4
 
 
+;; Loops should not be interchanged in this case as it will change the
+;; cc array results.
+;;
 ;;  for (int j = 1; j < M; j++)
 ;;    for (int i = 1; i < N; i++) {
 ;;      aa[1][j-1] += bb[i][j];
 ;;      cc[i][j] = aa[1][j];
 ;;    }
 
-; CHECK: Loops interchanged.
+; CHECK-NOT: Loops interchanged.
 
 define void @pr54176() {
 entry: