[LoopInterchange] Update the direction of undistributed loop to EQ

This commit enables loop-interchange for the case in #71519.
With the loop-interchange, the case can be vectorized.

  for (int nl = 0; nl < 10000000/256; nl++) // Level 1
    for (int i = 0; i < 256; ++i)           // Level 2
      for (int j = 1; j < 256; j++)         // Level 3
        aa[j][i] = aa[j - 1][i] + bb[j][i];

The case can't be interchanged without normalizaion.
normalizaion didn't occur because the direction of level 1 loop dependence
between aa[j][i] and aa[j - 1][i] is default value '*'.

By scanning SCEV form of the pointer of aa[j][i] and aa[j - 1][i], the pass
and determine the IV of loop 1(nl) didn't affect the value of aa[j][i] and
aa[j - 1][i]. And then updating the direction of loop 1 to '=' to enable
the normalization.

Author: ShivaChen

llvm/lib/Transforms/Scalar/LoopInterchange.cpp

@@ -117,8 +117,45 @@ static void dumpDirection(raw_ostream &OS, std::vector<Dependence::DVEntry> &DV,
   OS << "]\n";
 }
 
+// Get the Loops will affect Expr result.
+static void getAffectedLoop(const SCEV *Expr, SmallBitVector &Loops,
+                            ScalarEvolution *SE) {
+  const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(Expr);
+  if (!AddRec)
+    return;
+
+  Loops.set(AddRec->getLoop()->getLoopDepth());
+  const SCEV *Start = AddRec->getStart();
+  const SCEV *Step = AddRec->getStepRecurrence(*SE);
+  getAffectedLoop(Start, Loops, SE);
+  getAffectedLoop(Step, Loops, SE);
+}
+
+// Update the Direction of undistributed loop to EQ.
+static void
+updateUndistributedLoopDirection(std::vector<Dependence::DVEntry> &DV,
+                                 unsigned Levels, ScalarEvolution *SE,
+                                 Instruction *Src, Instruction *Dst) {
+  SmallBitVector DistributedLoops(Levels + 1);
+  Value *SrcPtr = getLoadStorePointerOperand(Src);
+  Value *DstPtr = getLoadStorePointerOperand(Dst);
+  const SCEV *SrcSCEV = SE->getSCEV(SrcPtr);
+  const SCEV *DstSCEV = SE->getSCEV(DstPtr);
+  getAffectedLoop(SrcSCEV, DistributedLoops, SE);
+  getAffectedLoop(DstSCEV, DistributedLoops, SE);
+  for (unsigned II = 1; II < Levels; ++II)
+    // Set the direction of the loop to EQ if the loop won't affect the
+    // SCEV of Src and Dst.
+    if (!DistributedLoops.test(II)) {
+      dbgs() << "Set level " << II << " loop direction to =\n";
+      DV[II - 1].Direction = Dependence::DVEntry::EQ;
+    }
+}
+
 static bool normalize(std::vector<Dependence::DVEntry> &DV, unsigned Levels,
-                      ScalarEvolution *SE) {
+                      ScalarEvolution *SE, Instruction *Src, Instruction *Dst) {
+  updateUndistributedLoopDirection(DV, Levels, SE, Src, Dst);
+
   if (!isDirectionNegative(DV, Levels))
     return false;
 
@@ -189,7 +226,7 @@ static bool populateDependencyMatrix(CharMatrix &DepMatrix, unsigned Level,
           DV[II - 1].Direction = D->getDirection(II);
         // If the direction vector is negative, normalize it to
         // make it non-negative.
-        if (normalize(DV, Levels, SE))
+        if (normalize(DV, Levels, SE, Src, Dst))
           LLVM_DEBUG(dbgs() << "Negative dependence vector normalized.\n");
         LLVM_DEBUG(StringRef DepType =
                        D->isFlow() ? "flow" : D->isAnti() ? "anti" : "output";

llvm/test/Transforms/LoopInterchange/pr71519.ll

@@ -5,12 +5,24 @@
 @aa = global [256 x [256 x float]] zeroinitializer, align 64
 @bb = global [256 x [256 x float]] zeroinitializer, align 64
 
-;;  for (int nl = 0; nl < 10000000/256; nl++)
-;;    for (int i = 0; i < 256; ++i)
-;;      for (int j = 1; j < 256; j++)
+;; This test check that the direction of level 1 loop dependence between
+;; aa[j][i] and aa[j - 1][i] will be set to '=' instead of default '*'.
+;; Because level 1 loop IV(nl) won't affect the value of aa[j][i] and
+;; aa[j - 1][i].
+;; By setting to '=' will enable normalize and legalize the interchange.
+;;
+;;  for (int nl = 0; nl < 10000000/256; nl++) // Level 1
+;;    for (int i = 0; i < 256; ++i)           // Level 2
+;;      for (int j = 1; j < 256; j++)         // Level 3
 ;;        aa[j][i] = aa[j - 1][i] + bb[j][i];
 
-; CHECK: Not interchanging loops. Cannot prove legality.
+; CHECK: Set level 1 loop direction to =
+; CHECK: Before normalizing negative direction vectors:
+; CHECK:  [= = >]
+; CHECK: After normalizing negative direction vectors:
+; CGECK:  [= = <]
+; CHECK: Negative dependence vector normalized.
+; CHECK: Loops interchanged.
 
 define float @s231() {
 entry: