diff --git a/llvm/lib/Transforms/Scalar/LoopInterchange.cpp b/llvm/lib/Transforms/Scalar/LoopInterchange.cpp
--- a/llvm/lib/Transforms/Scalar/LoopInterchange.cpp
+++ b/llvm/lib/Transforms/Scalar/LoopInterchange.cpp
@@ -258,16 +258,16 @@
 // if the direction matrix, after the same permutation is applied to its
 // columns, has no ">" direction as the leftmost non-"=" direction in any row.
 static bool isLegalToInterChangeLoops(CharMatrix &DepMatrix,
-                                      unsigned InnerLoopId,
-                                      unsigned OuterLoopId) {
+                                      unsigned InnerLoopId) {
   unsigned NumRows = DepMatrix.size();
   // For each row check if it is valid to interchange.
   for (unsigned Row = 0; Row < NumRows; ++Row) {
     char InnerDep = DepMatrix[Row][InnerLoopId];
-    char OuterDep = DepMatrix[Row][OuterLoopId];
+    char OuterDep = DepMatrix[Row][InnerLoopId - 1];
     if (InnerDep == '*' || OuterDep == '*')
       return false;
-    if (!validDepInterchange(DepMatrix, Row, OuterLoopId, InnerDep, OuterDep))
+    if (!validDepInterchange(DepMatrix, Row, InnerLoopId - 1, InnerDep,
+                             OuterDep))
       return false;
   }
   return true;
@@ -332,8 +332,7 @@
       : OuterLoop(Outer), InnerLoop(Inner), SE(SE), ORE(ORE) {}
 
   /// Check if the loops can be interchanged.
-  bool canInterchangeLoops(unsigned InnerLoopId, unsigned OuterLoopId,
-                           CharMatrix &DepMatrix);
+  bool canInterchangeLoops(unsigned InnerLoopId, CharMatrix &DepMatrix);
 
   /// Check if the loop structure is understood. We do not handle triangular
   /// loops for now.
@@ -379,8 +378,7 @@
       : OuterLoop(Outer), InnerLoop(Inner), SE(SE), ORE(ORE) {}
 
   /// Check if the loop interchange is profitable.
-  bool isProfitable(unsigned InnerLoopId, unsigned OuterLoopId,
-                    CharMatrix &DepMatrix);
+  bool isProfitable(unsigned InnerLoopId, CharMatrix &DepMatrix);
 
 private:
   int getInstrOrderCost();
@@ -516,8 +514,8 @@
     unsigned SelecLoopId = selectLoopForInterchange(LoopList);
     // Move the selected loop outwards to the best possible position.
     for (unsigned i = SelecLoopId; i > 0; i--) {
-      bool Interchanged =
-          processLoop(LoopList, i, i - 1, LoopNestExit, DependencyMatrix);
+      bool Interchanged = processLoop(LoopList[i], LoopList[i - 1], i,
+                                      LoopNestExit, DependencyMatrix);
       if (!Interchanged)
         return Changed;
       // Loops interchanged reflect the same in LoopList
@@ -534,22 +532,20 @@
     return Changed;
   }
 
-  bool processLoop(LoopVector LoopList, unsigned InnerLoopId,
-                   unsigned OuterLoopId, BasicBlock *LoopNestExit,
+  bool processLoop(Loop *InnerLoop, Loop *OuterLoop, unsigned InnerLoopId,
+                   BasicBlock *LoopNestExit,
                    std::vector<std::vector<char>> &DependencyMatrix) {
-    LLVM_DEBUG(dbgs() << "Processing Inner Loop Id = " << InnerLoopId
-                      << " and OuterLoopId = " << OuterLoopId << "\n");
-    Loop *InnerLoop = LoopList[InnerLoopId];
-    Loop *OuterLoop = LoopList[OuterLoopId];
+    LLVM_DEBUG(dbgs() << "Processing InnerLoopId = " << InnerLoopId
+                      << " and OuterLoopId = " << InnerLoopId - 1 << "\n");
 
     LoopInterchangeLegality LIL(OuterLoop, InnerLoop, SE, ORE);
-    if (!LIL.canInterchangeLoops(InnerLoopId, OuterLoopId, DependencyMatrix)) {
+    if (!LIL.canInterchangeLoops(InnerLoopId, DependencyMatrix)) {
       LLVM_DEBUG(dbgs() << "Not interchanging loops. Cannot prove legality.\n");
       return false;
     }
     LLVM_DEBUG(dbgs() << "Loops are legal to interchange\n");
     LoopInterchangeProfitability LIP(OuterLoop, InnerLoop, SE, ORE);
-    if (!LIP.isProfitable(InnerLoopId, OuterLoopId, DependencyMatrix)) {
+    if (!LIP.isProfitable(InnerLoopId, DependencyMatrix)) {
       LLVM_DEBUG(dbgs() << "Interchanging loops not profitable.\n");
       return false;
     }
@@ -952,11 +948,10 @@
 }
 
 bool LoopInterchangeLegality::canInterchangeLoops(unsigned InnerLoopId,
-                                                  unsigned OuterLoopId,
                                                   CharMatrix &DepMatrix) {
-  if (!isLegalToInterChangeLoops(DepMatrix, InnerLoopId, OuterLoopId)) {
+  if (!isLegalToInterChangeLoops(DepMatrix, InnerLoopId)) {
     LLVM_DEBUG(dbgs() << "Failed interchange InnerLoopId = " << InnerLoopId
-                      << " and OuterLoopId = " << OuterLoopId
+                      << " and OuterLoopId = " << InnerLoopId - 1
                       << " due to dependence\n");
     ORE->emit([&]() {
       return OptimizationRemarkMissed(DEBUG_TYPE, "Dependence",
@@ -1087,7 +1082,6 @@
 }
 
 static bool isProfitableForVectorization(unsigned InnerLoopId,
-                                         unsigned OuterLoopId,
                                          CharMatrix &DepMatrix) {
   // TODO: Improve this heuristic to catch more cases.
   // If the inner loop is loop independent or doesn't carry any dependency it is
@@ -1096,7 +1090,7 @@
     if (Row[InnerLoopId] != 'S' && Row[InnerLoopId] != 'I')
       return false;
     // TODO: We need to improve this heuristic.
-    if (Row[OuterLoopId] != '=')
+    if (Row[InnerLoopId - 1] != '=')
       return false;
   }
   // If outer loop has dependence and inner loop is loop independent then it is
@@ -1106,7 +1100,6 @@
 }
 
 bool LoopInterchangeProfitability::isProfitable(unsigned InnerLoopId,
-                                                unsigned OuterLoopId,
                                                 CharMatrix &DepMatrix) {
   // TODO: Add better profitability checks.
   // e.g
@@ -1123,7 +1116,7 @@
 
   // It is not profitable as per current cache profitability model. But check if
   // we can move this loop outside to improve parallelism.
-  if (isProfitableForVectorization(InnerLoopId, OuterLoopId, DepMatrix))
+  if (isProfitableForVectorization(InnerLoopId, DepMatrix))
     return true;
 
   ORE->emit([&]() {
diff --git a/llvm/test/Transforms/LoopInterchange/interchange-flow-dep-outer.ll b/llvm/test/Transforms/LoopInterchange/interchange-flow-dep-outer.ll
--- a/llvm/test/Transforms/LoopInterchange/interchange-flow-dep-outer.ll
+++ b/llvm/test/Transforms/LoopInterchange/interchange-flow-dep-outer.ll
@@ -21,10 +21,10 @@
 ;;    fn2(T[k]);
 ;;  }
 
-; CHECK: Processing Inner Loop Id = 2 and OuterLoopId = 1
+; CHECK: Processing InnerLoopId = 2 and OuterLoopId = 1
 ; CHECK: Loops interchanged.
 
-; CHECK: Processing Inner Loop Id = 1 and OuterLoopId = 0
+; CHECK: Processing InnerLoopId = 1 and OuterLoopId = 0
 ; CHECK: Not interchanging loops. Cannot prove legality.
 
 @T = internal global [100 x double] zeroinitializer, align 4
diff --git a/llvm/test/Transforms/LoopInterchange/not-interchanged-loop-nest-3.ll b/llvm/test/Transforms/LoopInterchange/not-interchanged-loop-nest-3.ll
--- a/llvm/test/Transforms/LoopInterchange/not-interchanged-loop-nest-3.ll
+++ b/llvm/test/Transforms/LoopInterchange/not-interchanged-loop-nest-3.ll
@@ -13,10 +13,10 @@
 ;;      for(int k=0;k<100;k++)
 ;;        D[i][k][j] = D[i][k][j]+t;
 
-; CHECK: Processing Inner Loop Id = 2 and OuterLoopId = 1
+; CHECK: Processing InnerLoopId = 2 and OuterLoopId = 1
 ; CHECK: Loops interchanged.
 
-; CHECK: Processing Inner Loop Id = 1 and OuterLoopId = 0
+; CHECK: Processing InnerLoopId = 1 and OuterLoopId = 0
 ; CHECK: Interchanging loops not profitable.
 
 define void @interchange_08(i32 %t){