[LoopInterchange] Swap Src and Dst to get distance without normalize

Author: ShivaChen

llvm/lib/Transforms/Scalar/LoopInterchange.cpp

@@ -20,6 +20,7 @@
 #include "llvm/Analysis/DependenceAnalysis.h"
 #include "llvm/Analysis/LoopCacheAnalysis.h"
 #include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/LoopIterator.h"
 #include "llvm/Analysis/LoopNestAnalysis.h"
 #include "llvm/Analysis/LoopPass.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
@@ -84,13 +85,16 @@ static void printDepMatrix(CharMatrix &DepMatrix) {
 
 static bool populateDependencyMatrix(CharMatrix &DepMatrix, unsigned Level,
                                      Loop *L, DependenceInfo *DI,
-                                     ScalarEvolution *SE) {
+                                     ScalarEvolution *SE, LoopInfo *LI) {
   using ValueVector = SmallVector<Value *, 16>;
 
   ValueVector MemInstr;
 
-  // For each block.
-  for (BasicBlock *BB : L->blocks()) {
+  // Traverse blocks in fixed RPOT order, regardless of their storage in the
+  // loop info, as it may be arbitrary.
+  LoopBlocksRPO RPOT(L);
+  RPOT.perform(LI);
+  for (BasicBlock *BB : RPOT) {
     // Scan the BB and collect legal loads and stores.
     for (Instruction &I : *BB) {
       if (!isa<Instruction>(I))
@@ -115,18 +119,14 @@ static bool populateDependencyMatrix(CharMatrix &DepMatrix, unsigned Level,
   for (I = MemInstr.begin(), IE = MemInstr.end(); I != IE; ++I) {
     for (J = I, JE = MemInstr.end(); J != JE; ++J) {
       std::vector<char> Dep;
-      Instruction *Src = cast<Instruction>(*I);
-      Instruction *Dst = cast<Instruction>(*J);
+      Instruction *Src = cast<Instruction>(*J);
+      Instruction *Dst = cast<Instruction>(*I);
       // 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)) {
         assert(D->isOrdered() && "Expected an output, flow or anti dep.");
-        // If the direction vector is negative, normalize it to
-        // make it non-negative.
-        if (D->normalize(SE))
-          LLVM_DEBUG(dbgs() << "Negative dependence vector normalized.\n");
         LLVM_DEBUG(StringRef DepType =
                        D->isFlow() ? "flow" : D->isAnti() ? "anti" : "output";
                    dbgs() << "Found " << DepType
@@ -438,7 +438,7 @@ struct LoopInterchange {
     CharMatrix DependencyMatrix;
     Loop *OuterMostLoop = *(LoopList.begin());
     if (!populateDependencyMatrix(DependencyMatrix, LoopNestDepth,
-                                  OuterMostLoop, DI, SE)) {
+                                  OuterMostLoop, DI, SE, LI)) {
       LLVM_DEBUG(dbgs() << "Populating dependency matrix failed\n");
       return false;
     }

llvm/test/Transforms/LoopInterchange/interchange-s231.ll

@@ -11,7 +11,7 @@
 ;;        aa[j][i] = aa[j - 1][i] + bb[j][i];
 
 ; CHECK: Processing InnerLoopId = 2 and OuterLoopId = 1
-; CHECK: Not interchanging loops. Cannot prove legality.
+; CHECK: Loops interchanged.
 
 define float @s231() {
 entry:

llvm/test/Transforms/LoopInterchange/pr56275.ll

@@ -21,20 +21,14 @@ target triple = "aarch64-unknown-linux-gnu"
 define void @test1(ptr noalias noundef %a, ptr noalias noundef %b, ptr noalias noundef %c) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    br label [[LOOP2_HEADER_PREHEADER:%.*]]
-; CHECK:       loop1.header.preheader:
 ; CHECK-NEXT:    br label [[LOOP1_HEADER:%.*]]
 ; CHECK:       loop1.header:
-; CHECK-NEXT:    [[I2:%.*]] = phi i64 [ [[I2_INC:%.*]], [[LOOP1_LATCH:%.*]] ], [ 1, [[LOOP1_HEADER_PREHEADER:%.*]] ]
+; CHECK-NEXT:    [[I2:%.*]] = phi i64 [ 1, [[ENTRY:%.*]] ], [ [[I2_INC:%.*]], [[LOOP1_LATCH:%.*]] ]
 ; CHECK-NEXT:    [[I2_ST:%.*]] = add i64 [[I2]], 1
 ; CHECK-NEXT:    [[I2_LD:%.*]] = add i64 [[I2]], 0
-; CHECK-NEXT:    br label [[LOOP2_HEADER_SPLIT1:%.*]]
-; CHECK:       loop2.header.preheader:
 ; CHECK-NEXT:    br label [[LOOP2_HEADER:%.*]]
 ; CHECK:       loop2.header:
-; CHECK-NEXT:    [[I1:%.*]] = phi i64 [ [[TMP0:%.*]], [[LOOP2_HEADER_SPLIT:%.*]] ], [ 1, [[LOOP2_HEADER_PREHEADER]] ]
-; CHECK-NEXT:    br label [[LOOP1_HEADER_PREHEADER]]
-; CHECK:       loop2.header.split1:
+; CHECK-NEXT:    [[I1:%.*]] = phi i64 [ 1, [[LOOP1_HEADER]] ], [ [[I1_INC:%.*]], [[LOOP2_HEADER]] ]
 ; CHECK-NEXT:    [[I1_ST:%.*]] = add i64 [[I1]], 0
 ; CHECK-NEXT:    [[I1_LD:%.*]] = add i64 [[I1]], 0
 ; CHECK-NEXT:    [[A_ST:%.*]] = getelementptr inbounds [64 x i32], ptr [[A:%.*]], i64 [[I1_ST]], i64 [[I2_ST]]
@@ -45,17 +39,13 @@ define void @test1(ptr noalias noundef %a, ptr noalias noundef %b, ptr noalias n
 ; CHECK-NEXT:    store i32 [[B_VAL]], ptr [[A_ST]], align 4
 ; CHECK-NEXT:    [[A_VAL:%.*]] = load i32, ptr [[A_LD]], align 4
 ; CHECK-NEXT:    store i32 [[A_VAL]], ptr [[C_ST]], align 4
-; CHECK-NEXT:    [[I1_INC:%.*]] = add nuw nsw i64 [[I1]], 1
+; CHECK-NEXT:    [[I1_INC]] = add nuw nsw i64 [[I1]], 1
 ; CHECK-NEXT:    [[LOOP2_EXITCOND_NOT:%.*]] = icmp eq i64 [[I1_INC]], 63
-; CHECK-NEXT:    br label [[LOOP1_LATCH]]
-; CHECK:       loop2.header.split:
-; CHECK-NEXT:    [[TMP0]] = add nuw nsw i64 [[I1]], 1
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[TMP0]], 63
-; CHECK-NEXT:    br i1 [[TMP1]], label [[EXIT:%.*]], label [[LOOP2_HEADER]]
+; CHECK-NEXT:    br i1 [[LOOP2_EXITCOND_NOT]], label [[LOOP1_LATCH]], label [[LOOP2_HEADER]]
 ; CHECK:       loop1.latch:
 ; CHECK-NEXT:    [[I2_INC]] = add nuw nsw i64 [[I2]], 1
 ; CHECK-NEXT:    [[LOOP1_EXITCOND_NOT:%.*]] = icmp eq i64 [[I2_INC]], 63
-; CHECK-NEXT:    br i1 [[LOOP1_EXITCOND_NOT]], label [[LOOP2_HEADER_SPLIT]], label [[LOOP1_HEADER]]
+; CHECK-NEXT:    br i1 [[LOOP1_EXITCOND_NOT]], label [[EXIT:%.*]], label [[LOOP1_HEADER]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;