[llvm-branch-commits] [llvm] [LoopInterchange] Add tests for loop metadata, debug info, and IV updates (NFC) (PR #235891)

Ryotaro Kasuga via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Sun Nov 22 07:22:10 PST 2026


https://github.com/kasuga-fj updated https://github.com/llvm/llvm-project/pull/235891

>From 9cb272b8c08d6bda13b037091718361bd5f9df95 Mon Sep 17 00:00:00 2001
From: Ryotaro Kasuga <ryotaro.kasuga at gmail.com>
Date: Sun, 25 Oct 2026 08:15:22 +0900
Subject: [PATCH] [LoopInterchange] Add tests for loop metadata, debug info,
 and IV updates (NFC)

Add test cases to ensure that later patches correctly handle the
following:

- Loop metadata and branch weights on the latches.
- Debug records that refer to the outer IVs.
- Various forms of IVs, e.g., pointer IVs, non-constant steps, and start
  values computed in the outer loop.
- Code in the outer loop but outside the inner loop that uses the outer
  IVs.
- Interchanging the same pair of loops twice.

Part of #235496

Co-Authored-By: Claude Opus 5.5 <noreply at anthropic.com>
---
 .../LoopInterchange/debuginfo-outer-iv.ll     | 195 ++++++++++
 .../induction-variable-update.ll              | 277 ++++++++++++++
 .../interchange-same-loops-twice.ll           |  94 +++++
 .../LoopInterchange/loop-metadata.ll          | 339 ++++++++++++++++++
 .../LoopInterchange/outer-level-code.ll       | 287 +++++++++++++++
 5 files changed, 1192 insertions(+)
 create mode 100644 llvm/test/Transforms/LoopInterchange/debuginfo-outer-iv.ll
 create mode 100644 llvm/test/Transforms/LoopInterchange/induction-variable-update.ll
 create mode 100644 llvm/test/Transforms/LoopInterchange/interchange-same-loops-twice.ll
 create mode 100644 llvm/test/Transforms/LoopInterchange/loop-metadata.ll
 create mode 100644 llvm/test/Transforms/LoopInterchange/outer-level-code.ll

diff --git a/llvm/test/Transforms/LoopInterchange/debuginfo-outer-iv.ll b/llvm/test/Transforms/LoopInterchange/debuginfo-outer-iv.ll
new file mode 100644
index 00000000000000..c80c3c3f39e536
--- /dev/null
+++ b/llvm/test/Transforms/LoopInterchange/debuginfo-outer-iv.ll
@@ -0,0 +1,195 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals all --version 6
+; RUN: opt < %s -passes=loop-interchange -loop-interchange-profitabilities=ignore -S | FileCheck %s
+
+; Check how the debug records that refer to the outer induction variable, or to
+; the values in the outer loop, and the debug locations of the latch branches
+; are handled when the loops are interchanged.
+
+; The debug records are in the outer loop header and the outer loop latch.
+define void @f(ptr %A, i64 %n) !dbg !5 {
+; CHECK-LABEL: define void @f(
+; CHECK-SAME: ptr [[A:%.*]], i64 [[N:%.*]]) !dbg [[DBG4:![0-9]+]] {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[INNER_HEADER_PREHEADER:.*]]
+; CHECK:       [[OUTER_HEADER_PREHEADER:.*]]:
+; CHECK-NEXT:    br label %[[OUTER_HEADER:.*]]
+; CHECK:       [[OUTER_HEADER]]:
+; CHECK-NEXT:    [[I:%.*]] = phi i64 [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ], [ 0, %[[OUTER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:      #dbg_value(i64 [[I]], [[META8:![0-9]+]], !DIExpression(), [[META13:![0-9]+]])
+; CHECK-NEXT:    [[I_MUL:%.*]] = mul nuw nsw i64 [[I]], 2
+; CHECK-NEXT:      #dbg_value(i64 [[I_MUL]], [[META10:![0-9]+]], !DIExpression(), [[META13]])
+; CHECK-NEXT:    [[N_ADD:%.*]] = add i64 [[N]], 1
+; CHECK-NEXT:      #dbg_value(i64 [[N_ADD]], [[META11:![0-9]+]], !DIExpression(), [[META13]])
+; CHECK-NEXT:    br label %[[INNER_HEADER_SPLIT1:.*]]
+; CHECK:       [[INNER_HEADER_PREHEADER]]:
+; CHECK-NEXT:    br label %[[INNER_HEADER:.*]]
+; CHECK:       [[INNER_HEADER]]:
+; CHECK-NEXT:    [[J:%.*]] = phi i64 [ [[TMP0:%.*]], %[[INNER_HEADER_SPLIT:.*]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[OUTER_HEADER_PREHEADER]]
+; CHECK:       [[INNER_HEADER_SPLIT1]]:
+; CHECK-NEXT:      #dbg_value(i64 [[J]], [[META12:![0-9]+]], !DIExpression(), [[META14:![0-9]+]])
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [512 x i64], ptr [[A]], i64 [[J]], i64 [[I_MUL]]
+; CHECK-NEXT:    store i64 [[N_ADD]], ptr [[GEP]], align 8
+; CHECK-NEXT:    [[J_NEXT:%.*]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], 256
+; CHECK-NEXT:    br label %[[OUTER_LATCH]], !dbg [[DBG15:![0-9]+]]
+; CHECK:       [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT:    [[TMP0]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[TMP0]], 256
+; CHECK-NEXT:    br i1 [[TMP1]], label %[[EXIT:.*]], label %[[INNER_HEADER]], !dbg [[DBG15]]
+; CHECK:       [[OUTER_LATCH]]:
+; CHECK-NEXT:      #dbg_value(i64 [[I]], [[META8]], !DIExpression(DW_OP_plus_uconst, 1), [[META13]])
+; CHECK-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_NEXT]], 256
+; CHECK-NEXT:    br i1 [[EC_I]], label %[[INNER_HEADER_SPLIT]], label %[[OUTER_HEADER]], !dbg [[DBG16:![0-9]+]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %outer.header
+
+outer.header:
+  %i = phi i64 [ 0, %entry ], [ %i.next, %outer.latch ]
+    #dbg_value(i64 %i, !9, !DIExpression(), !14)
+  %i.mul = mul nuw nsw i64 %i, 2
+    #dbg_value(i64 %i.mul, !10, !DIExpression(), !14)
+  %n.add = add i64 %n, 1
+    #dbg_value(i64 %n.add, !11, !DIExpression(), !14)
+  br label %inner.header
+
+inner.header:
+  %j = phi i64 [ 0, %outer.header ], [ %j.next, %inner.header ]
+    #dbg_value(i64 %j, !12, !DIExpression(), !15)
+  %gep = getelementptr inbounds [512 x i64], ptr %A, i64 %j, i64 %i.mul
+  store i64 %n.add, ptr %gep, align 8
+  %j.next = add nuw nsw i64 %j, 1
+  %ec.j = icmp eq i64 %j.next, 256
+  br i1 %ec.j, label %outer.latch, label %inner.header, !dbg !16
+
+outer.latch:
+    #dbg_value(i64 %i, !9, !DIExpression(DW_OP_plus_uconst, 1), !14)
+  %i.next = add nuw nsw i64 %i, 1
+  %ec.i = icmp eq i64 %i.next, 256
+  br i1 %ec.i, label %exit, label %outer.header, !dbg !17
+
+exit:
+  ret void
+}
+
+; The debug records are in the inner loop preheader. One of them refers to a PHI
+; node that has the same incoming value from all the edges.
+define void @g(ptr %A, i1 %c) !dbg !18 {
+; CHECK-LABEL: define void @g(
+; CHECK-SAME: ptr [[A:%.*]], i1 [[C:%.*]]) !dbg [[DBG17:![0-9]+]] {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[INNER_PREHEADER:.*]]
+; CHECK:       [[OUTER_HEADER_PREHEADER:.*]]:
+; CHECK-NEXT:      #dbg_value(i64 [[I_MUL:%.*]], [[META20:![0-9]+]], !DIExpression(), [[META21:![0-9]+]])
+; CHECK-NEXT:    br label %[[OUTER_HEADER:.*]]
+; CHECK:       [[OUTER_HEADER]]:
+; CHECK-NEXT:    [[I:%.*]] = phi i64 [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ], [ 0, %[[OUTER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:      #dbg_value(i64 [[I]], [[META19:![0-9]+]], !DIExpression(), [[META21]])
+; CHECK-NEXT:    [[I_MUL]] = mul nuw nsw i64 [[I]], 2
+; CHECK-NEXT:    br i1 [[C]], label %[[INNER_HEADER_SPLIT1:.*]], label %[[INNER_HEADER_SPLIT1]]
+; CHECK:       [[INNER_PREHEADER]]:
+; CHECK-NEXT:    br label %[[INNER_HEADER:.*]]
+; CHECK:       [[INNER_HEADER]]:
+; CHECK-NEXT:    [[J:%.*]] = phi i64 [ 0, %[[INNER_PREHEADER]] ], [ [[TMP0:%.*]], %[[INNER_HEADER_SPLIT:.*]] ]
+; CHECK-NEXT:    br label %[[OUTER_HEADER_PREHEADER]]
+; CHECK:       [[INNER_HEADER_SPLIT1]]:
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [512 x i64], ptr [[A]], i64 [[J]], i64 [[I_MUL]]
+; CHECK-NEXT:    store i64 0, ptr [[GEP]], align 8
+; CHECK-NEXT:    [[J_NEXT:%.*]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], 256
+; CHECK-NEXT:    br label %[[OUTER_LATCH]]
+; CHECK:       [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT:    [[TMP0]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[TMP0]], 256
+; CHECK-NEXT:    br i1 [[TMP1]], label %[[EXIT:.*]], label %[[INNER_HEADER]]
+; CHECK:       [[OUTER_LATCH]]:
+; CHECK-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_NEXT]], 256
+; CHECK-NEXT:    br i1 [[EC_I]], label %[[INNER_HEADER_SPLIT]], label %[[OUTER_HEADER]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %outer.header
+
+outer.header:
+  %i = phi i64 [ 0, %entry ], [ %i.next, %outer.latch ]
+  br i1 %c, label %inner.preheader, label %inner.preheader
+
+inner.preheader:
+  %i.phi = phi i64 [ %i, %outer.header ], [ %i, %outer.header ]
+    #dbg_value(i64 %i.phi, !19, !DIExpression(), !21)
+  %i.mul = mul nuw nsw i64 %i.phi, 2
+    #dbg_value(i64 %i.mul, !20, !DIExpression(), !21)
+  br label %inner.header
+
+inner.header:
+  %j = phi i64 [ 0, %inner.preheader ], [ %j.next, %inner.header ]
+  %gep = getelementptr inbounds [512 x i64], ptr %A, i64 %j, i64 %i.mul
+  store i64 0, ptr %gep, align 8
+  %j.next = add nuw nsw i64 %j, 1
+  %ec.j = icmp eq i64 %j.next, 256
+  br i1 %ec.j, label %outer.latch, label %inner.header
+
+outer.latch:
+  %i.next = add nuw nsw i64 %i, 1
+  %ec.i = icmp eq i64 %i.next, 256
+  br i1 %ec.i, label %exit, label %outer.header
+
+exit:
+  ret void
+}
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!2, !3}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C11, file: !1, producer: "clang", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug)
+!1 = !DIFile(filename: "test.c", directory: "/")
+!2 = !{i32 2, !"Dwarf Version", i32 5}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 1, type: !6, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !8)
+!6 = !DISubroutineType(types: !7)
+!7 = !{null}
+!8 = !{!9, !10, !11, !12}
+!9 = !DILocalVariable(name: "i", scope: !5, file: !1, line: 2, type: !13)
+!10 = !DILocalVariable(name: "i2", scope: !5, file: !1, line: 3, type: !13)
+!11 = !DILocalVariable(name: "m", scope: !5, file: !1, line: 4, type: !13)
+!12 = !DILocalVariable(name: "j", scope: !5, file: !1, line: 5, type: !13)
+!13 = !DIBasicType(name: "long", size: 64, encoding: DW_ATE_signed)
+!14 = !DILocation(line: 2, column: 3, scope: !5)
+!15 = !DILocation(line: 5, column: 5, scope: !5)
+!16 = !DILocation(line: 5, column: 7, scope: !5)
+!17 = !DILocation(line: 2, column: 5, scope: !5)
+!18 = distinct !DISubprogram(name: "g", scope: !1, file: !1, line: 11, type: !6, scopeLine: 11, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !22)
+!19 = !DILocalVariable(name: "i", scope: !18, file: !1, line: 12, type: !13)
+!20 = !DILocalVariable(name: "i2", scope: !18, file: !1, line: 13, type: !13)
+!21 = !DILocation(line: 12, column: 3, scope: !18)
+!22 = !{!19, !20}
+;.
+; CHECK: [[META0:![0-9]+]] = distinct !DICompileUnit(language: DW_LANG_C11, file: [[META1:![0-9]+]], producer: "clang", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug)
+; CHECK: [[META1]] = !DIFile(filename: "{{.*}}test.c", directory: {{.*}})
+; CHECK: [[META2:![0-9]+]] = !{i32 2, !"Dwarf Version", i32 5}
+; CHECK: [[META3:![0-9]+]] = !{i32 2, !"Debug Info Version", i32 3}
+; CHECK: [[DBG4]] = distinct !DISubprogram(name: "f", scope: [[META1]], file: [[META1]], line: 1, type: [[META5:![0-9]+]], scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: [[META0]], retainedNodes: [[META7:![0-9]+]])
+; CHECK: [[META5]] = !DISubroutineType(types: [[META6:![0-9]+]])
+; CHECK: [[META6]] = !{null}
+; CHECK: [[META7]] = !{[[META8]], [[META10]], [[META11]], [[META12]]}
+; CHECK: [[META8]] = !DILocalVariable(name: "i", scope: [[DBG4]], file: [[META1]], line: 2, type: [[META9:![0-9]+]])
+; CHECK: [[META9]] = !DIBasicType(name: "long", size: 64, encoding: DW_ATE_signed)
+; CHECK: [[META10]] = !DILocalVariable(name: "i2", scope: [[DBG4]], file: [[META1]], line: 3, type: [[META9]])
+; CHECK: [[META11]] = !DILocalVariable(name: "m", scope: [[DBG4]], file: [[META1]], line: 4, type: [[META9]])
+; CHECK: [[META12]] = !DILocalVariable(name: "j", scope: [[DBG4]], file: [[META1]], line: 5, type: [[META9]])
+; CHECK: [[META13]] = !DILocation(line: 2, column: 3, scope: [[DBG4]])
+; CHECK: [[META14]] = !DILocation(line: 5, column: 5, scope: [[DBG4]])
+; CHECK: [[DBG15]] = !DILocation(line: 5, column: 7, scope: [[DBG4]])
+; CHECK: [[DBG16]] = !DILocation(line: 2, column: 5, scope: [[DBG4]])
+; CHECK: [[DBG17]] = distinct !DISubprogram(name: "g", scope: [[META1]], file: [[META1]], line: 11, type: [[META5]], scopeLine: 11, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: [[META0]], retainedNodes: [[META18:![0-9]+]])
+; CHECK: [[META18]] = !{[[META19]], [[META20]]}
+; CHECK: [[META19]] = !DILocalVariable(name: "i", scope: [[DBG17]], file: [[META1]], line: 12, type: [[META9]])
+; CHECK: [[META20]] = !DILocalVariable(name: "i2", scope: [[DBG17]], file: [[META1]], line: 13, type: [[META9]])
+; CHECK: [[META21]] = !DILocation(line: 12, column: 3, scope: [[DBG17]])
+;.
diff --git a/llvm/test/Transforms/LoopInterchange/induction-variable-update.ll b/llvm/test/Transforms/LoopInterchange/induction-variable-update.ll
new file mode 100644
index 00000000000000..7c8bc568065933
--- /dev/null
+++ b/llvm/test/Transforms/LoopInterchange/induction-variable-update.ll
@@ -0,0 +1,277 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
+; RUN: opt < %s -passes=loop-interchange -loop-interchange-profitabilities=ignore -S | FileCheck %s
+
+; Check how the induction variables are handled when the loops are
+; interchanged.
+
+; The inner loop has a pointer induction variable.
+;
+; for (i = 0; i < 256; i++) {
+;   char *p = base;
+;   for (j = 0; j < 256; j++, p += 8)
+;     A[j][i] = p;
+; }
+;
+define void @pointer_induction(ptr %A, ptr %base) {
+; CHECK-LABEL: define void @pointer_induction(
+; CHECK-SAME: ptr [[A:%.*]], ptr [[BASE:%.*]]) {
+; CHECK-NEXT:  [[INNER_HEADER_PREHEADER:.*]]:
+; CHECK-NEXT:    br label %[[INNER_HEADER:.*]]
+; CHECK:       [[INNER_HEADER]]:
+; CHECK-NEXT:    [[I:%.*]] = phi i64 [ 0, %[[INNER_HEADER_PREHEADER]] ], [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ]
+; CHECK-NEXT:    br label %[[OUTER_HEADER_PREHEADER:.*]]
+; CHECK:       [[OUTER_HEADER_PREHEADER]]:
+; CHECK-NEXT:    [[J:%.*]] = phi i64 [ 0, %[[INNER_HEADER]] ], [ [[J_NEXT:%.*]], %[[OUTER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    [[P:%.*]] = phi ptr [ [[BASE]], %[[INNER_HEADER]] ], [ [[TMP0:%.*]], %[[OUTER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [256 x ptr], ptr [[A]], i64 [[J]], i64 [[I]]
+; CHECK-NEXT:    store ptr [[P]], ptr [[GEP]], align 8
+; CHECK-NEXT:    [[J_NEXT]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[TMP0]] = getelementptr inbounds i8, ptr [[P]], i64 8
+; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], 256
+; CHECK-NEXT:    br i1 [[EC_J]], label %[[OUTER_LATCH]], label %[[OUTER_HEADER_PREHEADER]]
+; CHECK:       [[OUTER_LATCH]]:
+; CHECK-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_NEXT]], 256
+; CHECK-NEXT:    br i1 [[EC_I]], label %[[EXIT:.*]], label %[[INNER_HEADER]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %outer.header
+
+outer.header:
+  %i = phi i64 [ 0, %entry ], [ %i.next, %outer.latch ]
+  br label %inner.header
+
+inner.header:
+  %j = phi i64 [ 0, %outer.header ], [ %j.next, %inner.header ]
+  %p = phi ptr [ %base, %outer.header ], [ %p.next, %inner.header ]
+  %gep = getelementptr inbounds [256 x ptr], ptr %A, i64 %j, i64 %i
+  store ptr %p, ptr %gep, align 8
+  %j.next = add nuw nsw i64 %j, 1
+  %p.next = getelementptr inbounds i8, ptr %p, i64 8
+  %ec.j = icmp eq i64 %j.next, 256
+  br i1 %ec.j, label %outer.latch, label %inner.header
+
+outer.latch:
+  %i.next = add nuw nsw i64 %i, 1
+  %ec.i = icmp eq i64 %i.next, 256
+  br i1 %ec.i, label %exit, label %outer.header
+
+exit:
+  ret void
+}
+
+; The step of an induction variable of the inner loop is not a constant, and it
+; is computed in the outer loop header.
+;
+; for (i = 0; i < 256; i++) {
+;   step = s << 1;
+;   for (j = 0, k = 0; j < 256; j++, k += step)
+;     A[j][i] = k;
+; }
+;
+define void @non_constant_step(ptr %A, i64 %s) {
+; CHECK-LABEL: define void @non_constant_step(
+; CHECK-SAME: ptr [[A:%.*]], i64 [[S:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[INNER_HEADER_PREHEADER:.*]]
+; CHECK:       [[OUTER_HEADER_PREHEADER:.*]]:
+; CHECK-NEXT:    br label %[[OUTER_HEADER:.*]]
+; CHECK:       [[OUTER_HEADER]]:
+; CHECK-NEXT:    [[I:%.*]] = phi i64 [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ], [ 0, %[[OUTER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    [[STEP:%.*]] = shl i64 [[S]], 1
+; CHECK-NEXT:    br label %[[INNER_HEADER_SPLIT1:.*]]
+; CHECK:       [[INNER_HEADER_PREHEADER]]:
+; CHECK-NEXT:    br label %[[INNER_HEADER:.*]]
+; CHECK:       [[INNER_HEADER]]:
+; CHECK-NEXT:    [[J:%.*]] = phi i64 [ [[TMP1:%.*]], %[[INNER_HEADER_SPLIT:.*]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    [[K:%.*]] = phi i64 [ [[TMP0:%.*]], %[[INNER_HEADER_SPLIT]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[OUTER_HEADER_PREHEADER]]
+; CHECK:       [[INNER_HEADER_SPLIT1]]:
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [256 x i64], ptr [[A]], i64 [[J]], i64 [[I]]
+; CHECK-NEXT:    store i64 [[K]], ptr [[GEP]], align 4
+; CHECK-NEXT:    [[J_NEXT:%.*]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[K_NEXT:%.*]] = add i64 [[K]], [[STEP]]
+; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], 256
+; CHECK-NEXT:    br label %[[OUTER_LATCH]]
+; CHECK:       [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT:    [[STEP_LCSSA:%.*]] = phi i64 [ [[STEP]], %[[OUTER_LATCH]] ]
+; CHECK-NEXT:    [[TMP0]] = add i64 [[K]], [[STEP_LCSSA]]
+; CHECK-NEXT:    [[TMP1]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[TMP1]], 256
+; CHECK-NEXT:    br i1 [[TMP2]], label %[[EXIT:.*]], label %[[INNER_HEADER]]
+; CHECK:       [[OUTER_LATCH]]:
+; CHECK-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_NEXT]], 256
+; CHECK-NEXT:    br i1 [[EC_I]], label %[[INNER_HEADER_SPLIT]], label %[[OUTER_HEADER]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %outer.header
+
+outer.header:
+  %i = phi i64 [ 0, %entry ], [ %i.next, %outer.latch ]
+  %step = shl i64 %s, 1
+  br label %inner.header
+
+inner.header:
+  %j = phi i64 [ 0, %outer.header ], [ %j.next, %inner.header ]
+  %k = phi i64 [ 0, %outer.header ], [ %k.next, %inner.header ]
+  %gep = getelementptr inbounds [256 x i64], ptr %A, i64 %j, i64 %i
+  store i64 %k, ptr %gep, align 4
+  %j.next = add nuw nsw i64 %j, 1
+  %k.next = add i64 %k, %step
+  %ec.j = icmp eq i64 %j.next, 256
+  br i1 %ec.j, label %outer.latch, label %inner.header
+
+outer.latch:
+  %i.next = add nuw nsw i64 %i, 1
+  %ec.i = icmp eq i64 %i.next, 256
+  br i1 %ec.i, label %exit, label %outer.header
+
+exit:
+  ret void
+}
+
+; The start value of an induction variable of the inner loop is computed in the
+; outer loop header, but it doesn't depend on the outer loop.
+;
+; for (i = 0; i < 256; i++) {
+;   start = s + 1;
+;   for (j = 0, k = start; j < 256; j++, k++)
+;     A[j][i] = k;
+; }
+;
+define void @start_computed_in_outer_header(ptr %A, i64 %s) {
+; CHECK-LABEL: define void @start_computed_in_outer_header(
+; CHECK-SAME: ptr [[A:%.*]], i64 [[S:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*]]:
+; CHECK-NEXT:    br label %[[OUTER_HEADER:.*]]
+; CHECK:       [[OUTER_HEADER]]:
+; CHECK-NEXT:    [[I:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ]
+; CHECK-NEXT:    [[START:%.*]] = add i64 [[S]], 1
+; CHECK-NEXT:    br label %[[INNER_HEADER:.*]]
+; CHECK:       [[INNER_HEADER]]:
+; CHECK-NEXT:    [[J:%.*]] = phi i64 [ 0, %[[OUTER_HEADER]] ], [ [[J_NEXT:%.*]], %[[INNER_HEADER]] ]
+; CHECK-NEXT:    [[K:%.*]] = phi i64 [ [[START]], %[[OUTER_HEADER]] ], [ [[K_NEXT:%.*]], %[[INNER_HEADER]] ]
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [256 x i64], ptr [[A]], i64 [[J]], i64 [[I]]
+; CHECK-NEXT:    store i64 [[K]], ptr [[GEP]], align 4
+; CHECK-NEXT:    [[J_NEXT]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[K_NEXT]] = add i64 [[K]], 1
+; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], 256
+; CHECK-NEXT:    br i1 [[EC_J]], label %[[OUTER_LATCH]], label %[[INNER_HEADER]]
+; CHECK:       [[OUTER_LATCH]]:
+; CHECK-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_NEXT]], 256
+; CHECK-NEXT:    br i1 [[EC_I]], label %[[EXIT:.*]], label %[[OUTER_HEADER]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %outer.header
+
+outer.header:
+  %i = phi i64 [ 0, %entry ], [ %i.next, %outer.latch ]
+  %start = add i64 %s, 1
+  br label %inner.header
+
+inner.header:
+  %j = phi i64 [ 0, %outer.header ], [ %j.next, %inner.header ]
+  %k = phi i64 [ %start, %outer.header ], [ %k.next, %inner.header ]
+  %gep = getelementptr inbounds [256 x i64], ptr %A, i64 %j, i64 %i
+  store i64 %k, ptr %gep, align 4
+  %j.next = add nuw nsw i64 %j, 1
+  %k.next = add i64 %k, 1
+  %ec.j = icmp eq i64 %j.next, 256
+  br i1 %ec.j, label %outer.latch, label %inner.header
+
+outer.latch:
+  %i.next = add nuw nsw i64 %i, 1
+  %ec.i = icmp eq i64 %i.next, 256
+  br i1 %ec.i, label %exit, label %outer.header
+
+exit:
+  ret void
+}
+
+; The induction variables %x and %y are not used. %y is used only by the update
+; of %x, and the update of %y doesn't use %y itself. When the dead induction
+; variables are deleted, deleting %x also deletes %y.
+;
+; for (i = 0; i < 256; i++)
+;   for (j = 0, x = 0, y = 0, z = 0; j < 256; j++) {
+;     A[j][i] = 0;
+;     x = y + 1;
+;     y = z + 1;
+;     z = z + 1;
+;   }
+;
+define void @dead_induction_deleted_with_another(ptr %A) {
+; CHECK-LABEL: define void @dead_induction_deleted_with_another(
+; CHECK-SAME: ptr [[A:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[INNER_HEADER_PREHEADER:.*]]
+; CHECK:       [[OUTER_HEADER_PREHEADER:.*]]:
+; CHECK-NEXT:    br label %[[OUTER_HEADER:.*]]
+; CHECK:       [[OUTER_HEADER]]:
+; CHECK-NEXT:    [[I:%.*]] = phi i64 [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ], [ 0, %[[OUTER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[INNER_HEADER_SPLIT1:.*]]
+; CHECK:       [[INNER_HEADER_PREHEADER]]:
+; CHECK-NEXT:    br label %[[INNER_HEADER:.*]]
+; CHECK:       [[INNER_HEADER]]:
+; CHECK-NEXT:    [[J:%.*]] = phi i64 [ [[TMP2:%.*]], %[[INNER_HEADER_SPLIT:.*]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    [[X:%.*]] = phi i64 [ [[TMP1:%.*]], %[[INNER_HEADER_SPLIT]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    [[Y:%.*]] = phi i64 [ [[TMP0:%.*]], %[[INNER_HEADER_SPLIT]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    [[Z:%.*]] = phi i64 [ [[TMP0]], %[[INNER_HEADER_SPLIT]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[OUTER_HEADER_PREHEADER]]
+; CHECK:       [[INNER_HEADER_SPLIT1]]:
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [256 x i32], ptr [[A]], i64 [[J]], i64 [[I]]
+; CHECK-NEXT:    store i32 0, ptr [[GEP]], align 4
+; CHECK-NEXT:    [[X_NEXT:%.*]] = add i64 [[Y]], 1
+; CHECK-NEXT:    [[Z_NEXT:%.*]] = add i64 [[Z]], 1
+; CHECK-NEXT:    [[J_NEXT:%.*]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], 256
+; CHECK-NEXT:    br label %[[OUTER_LATCH]]
+; CHECK:       [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT:    [[TMP0]] = add i64 [[Z]], 1
+; CHECK-NEXT:    [[TMP1]] = add i64 [[Y]], 1
+; CHECK-NEXT:    [[TMP2]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 [[TMP2]], 256
+; CHECK-NEXT:    br i1 [[TMP3]], label %[[EXIT:.*]], label %[[INNER_HEADER]]
+; CHECK:       [[OUTER_LATCH]]:
+; CHECK-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_NEXT]], 256
+; CHECK-NEXT:    br i1 [[EC_I]], label %[[INNER_HEADER_SPLIT]], label %[[OUTER_HEADER]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %outer.header
+
+outer.header:
+  %i = phi i64 [ 0, %entry ], [ %i.next, %outer.latch ]
+  br label %inner.header
+
+inner.header:
+  %j = phi i64 [ 0, %outer.header ], [ %j.next, %inner.header ]
+  %x = phi i64 [ 0, %outer.header ], [ %x.next, %inner.header ]
+  %y = phi i64 [ 0, %outer.header ], [ %z.next, %inner.header ]
+  %z = phi i64 [ 0, %outer.header ], [ %z.next, %inner.header ]
+  %gep = getelementptr inbounds [256 x i32], ptr %A, i64 %j, i64 %i
+  store i32 0, ptr %gep, align 4
+  %x.next = add i64 %y, 1
+  %z.next = add i64 %z, 1
+  %j.next = add nuw nsw i64 %j, 1
+  %ec.j = icmp eq i64 %j.next, 256
+  br i1 %ec.j, label %outer.latch, label %inner.header
+
+outer.latch:
+  %i.next = add nuw nsw i64 %i, 1
+  %ec.i = icmp eq i64 %i.next, 256
+  br i1 %ec.i, label %exit, label %outer.header
+
+exit:
+  ret void
+}
diff --git a/llvm/test/Transforms/LoopInterchange/interchange-same-loops-twice.ll b/llvm/test/Transforms/LoopInterchange/interchange-same-loops-twice.ll
new file mode 100644
index 00000000000000..6b8b7ad23fd199
--- /dev/null
+++ b/llvm/test/Transforms/LoopInterchange/interchange-same-loops-twice.ll
@@ -0,0 +1,94 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
+; RUN: opt < %s -passes=loop-interchange -loop-interchange-profitabilities=ignore -S | FileCheck %s
+
+; The trip count of the innermost loop depends on the outermost loop. The pair of
+; the middle and the innermost loops is considered for interchange twice.
+;
+; for (i = 0; i < 3; i++)
+;   for (j = 0; j < 2; j++) {
+;     i2 = i * 2;
+;     for (k = 0; k != i2 % 4 + 2; k++)
+;       A[i][j][k] = 0;
+;   }
+;
+
+define void @f(ptr %A) {
+; CHECK-LABEL: define void @f(
+; CHECK-SAME: ptr [[A:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*]]:
+; CHECK-NEXT:    br label %[[L1_HEADER:.*]]
+; CHECK:       [[L1_HEADER]]:
+; CHECK-NEXT:    [[I:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[I_NEXT:%.*]], %[[L1_LATCH:.*]] ]
+; CHECK-NEXT:    br label %[[L3_HEADER_PREHEADER:.*]]
+; CHECK:       [[L2_HEADER_PREHEADER:.*]]:
+; CHECK-NEXT:    br label %[[L2_HEADER:.*]]
+; CHECK:       [[L2_HEADER]]:
+; CHECK-NEXT:    [[J:%.*]] = phi i64 [ [[J_NEXT:%.*]], %[[L2_LATCH:.*]] ], [ 0, %[[L2_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    [[I_MUL:%.*]] = mul nsw i64 [[I]], 2
+; CHECK-NEXT:    br label %[[L3_HEADER_SPLIT1:.*]]
+; CHECK:       [[L3_HEADER_PREHEADER]]:
+; CHECK-NEXT:    br label %[[L3_HEADER:.*]]
+; CHECK:       [[L3_HEADER]]:
+; CHECK-NEXT:    [[K:%.*]] = phi i64 [ [[TMP2:%.*]], %[[L3_HEADER_SPLIT:.*]] ], [ 0, %[[L3_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[L2_HEADER_PREHEADER]]
+; CHECK:       [[L3_HEADER_SPLIT1]]:
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [6 x [6 x [6 x i32]]], ptr [[A]], i64 0, i64 [[I]], i64 [[J]], i64 [[K]]
+; CHECK-NEXT:    store i32 0, ptr [[GEP]], align 4
+; CHECK-NEXT:    [[I_REM:%.*]] = urem i64 [[I_MUL]], 4
+; CHECK-NEXT:    [[K_BOUND:%.*]] = add nuw nsw i64 [[I_REM]], 2
+; CHECK-NEXT:    [[K_NEXT:%.*]] = add nuw nsw i64 [[K]], 1
+; CHECK-NEXT:    [[EC_K:%.*]] = icmp eq i64 [[K_NEXT]], [[K_BOUND]]
+; CHECK-NEXT:    br label %[[L2_LATCH]]
+; CHECK:       [[L3_HEADER_SPLIT]]:
+; CHECK-NEXT:    [[I_MUL_LCSSA:%.*]] = phi i64 [ [[I_MUL]], %[[L2_LATCH]] ]
+; CHECK-NEXT:    [[TMP0:%.*]] = urem i64 [[I_MUL_LCSSA]], 4
+; CHECK-NEXT:    [[TMP1:%.*]] = add nuw nsw i64 [[TMP0]], 2
+; CHECK-NEXT:    [[TMP2]] = add nuw nsw i64 [[K]], 1
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 [[TMP2]], [[TMP1]]
+; CHECK-NEXT:    br i1 [[TMP3]], label %[[L1_LATCH]], label %[[L3_HEADER]]
+; CHECK:       [[L2_LATCH]]:
+; CHECK-NEXT:    [[J_NEXT]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], 2
+; CHECK-NEXT:    br i1 [[EC_J]], label %[[L3_HEADER_SPLIT]], label %[[L2_HEADER]]
+; CHECK:       [[L1_LATCH]]:
+; CHECK-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_NEXT]], 3
+; CHECK-NEXT:    br i1 [[EC_I]], label %[[EXIT:.*]], label %[[L1_HEADER]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %l1.header
+
+l1.header:
+  %i = phi i64 [ 0, %entry ], [ %i.next, %l1.latch ]
+  br label %l2.header
+
+l2.header:
+  %j = phi i64 [ 0, %l1.header ], [ %j.next, %l2.latch ]
+  %i.mul = mul nsw i64 %i, 2
+  br label %l3.header
+
+l3.header:
+  %k = phi i64 [ 0, %l2.header ], [ %k.next, %l3.header ]
+  %gep = getelementptr inbounds [6 x [6 x [6 x i32]]], ptr %A, i64 0, i64 %i, i64 %j, i64 %k
+  store i32 0, ptr %gep, align 4
+  %i.rem = urem i64 %i.mul, 4
+  %k.bound = add nuw nsw i64 %i.rem, 2
+  %k.next = add nuw nsw i64 %k, 1
+  %ec.k = icmp eq i64 %k.next, %k.bound
+  br i1 %ec.k, label %l2.latch, label %l3.header
+
+l2.latch:
+  %j.next = add nuw nsw i64 %j, 1
+  %ec.j = icmp eq i64 %j.next, 2
+  br i1 %ec.j, label %l1.latch, label %l2.header
+
+l1.latch:
+  %i.next = add nuw nsw i64 %i, 1
+  %ec.i = icmp eq i64 %i.next, 3
+  br i1 %ec.i, label %exit, label %l1.header
+
+exit:
+  ret void
+}
diff --git a/llvm/test/Transforms/LoopInterchange/loop-metadata.ll b/llvm/test/Transforms/LoopInterchange/loop-metadata.ll
new file mode 100644
index 00000000000000..3e23a345bb9e4e
--- /dev/null
+++ b/llvm/test/Transforms/LoopInterchange/loop-metadata.ll
@@ -0,0 +1,339 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals all --version 6
+; RUN: opt < %s -passes=loop-interchange -loop-interchange-profitabilities=ignore -S | FileCheck %s
+
+; Check how the loop metadata and the branch weights attached to the latches
+; are handled when the loops are interchanged.
+
+; The inner loop is annotated with llvm.loop.parallel_accesses, and the outer
+; loop is annotated with llvm.loop.unroll.disable.
+;
+; for (i = 0; i < 256; i++)    // llvm.loop.unroll.disable
+;   for (j = 0; j < 256; j++)  // llvm.loop.parallel_accesses
+;     A[j][i] = 0;
+;
+define void @loop_id(ptr %A) {
+; CHECK-LABEL: define void @loop_id(
+; CHECK-SAME: ptr [[A:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[INNER_HEADER_PREHEADER:.*]]
+; CHECK:       [[OUTER_HEADER_PREHEADER:.*]]:
+; CHECK-NEXT:    br label %[[OUTER_HEADER:.*]]
+; CHECK:       [[OUTER_HEADER]]:
+; CHECK-NEXT:    [[I:%.*]] = phi i64 [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ], [ 0, %[[OUTER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[INNER_HEADER_SPLIT1:.*]]
+; CHECK:       [[INNER_HEADER_PREHEADER]]:
+; CHECK-NEXT:    br label %[[INNER_HEADER:.*]]
+; CHECK:       [[INNER_HEADER]]:
+; CHECK-NEXT:    [[J:%.*]] = phi i64 [ [[TMP0:%.*]], %[[INNER_HEADER_SPLIT:.*]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[OUTER_HEADER_PREHEADER]]
+; CHECK:       [[INNER_HEADER_SPLIT1]]:
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [256 x i32], ptr [[A]], i64 [[J]], i64 [[I]]
+; CHECK-NEXT:    store i32 0, ptr [[GEP]], align 4, !llvm.access.group [[ACC_GRP0:![0-9]+]]
+; CHECK-NEXT:    [[J_NEXT:%.*]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], 256
+; CHECK-NEXT:    br label %[[OUTER_LATCH]]
+; CHECK:       [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT:    [[TMP0]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[TMP0]], 256
+; CHECK-NEXT:    br i1 [[TMP1]], label %[[EXIT:.*]], label %[[INNER_HEADER]], !llvm.loop [[LOOP1:![0-9]+]]
+; CHECK:       [[OUTER_LATCH]]:
+; CHECK-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_NEXT]], 256
+; CHECK-NEXT:    br i1 [[EC_I]], label %[[INNER_HEADER_SPLIT]], label %[[OUTER_HEADER]], !llvm.loop [[LOOP3:![0-9]+]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %outer.header
+
+outer.header:
+  %i = phi i64 [ 0, %entry ], [ %i.next, %outer.latch ]
+  br label %inner.header
+
+inner.header:
+  %j = phi i64 [ 0, %outer.header ], [ %j.next, %inner.header ]
+  %gep = getelementptr inbounds [256 x i32], ptr %A, i64 %j, i64 %i
+  store i32 0, ptr %gep, align 4, !llvm.access.group !4
+  %j.next = add nuw nsw i64 %j, 1
+  %ec.j = icmp eq i64 %j.next, 256
+  br i1 %ec.j, label %outer.latch, label %inner.header, !llvm.loop !2
+
+outer.latch:
+  %i.next = add nuw nsw i64 %i, 1
+  %ec.i = icmp eq i64 %i.next, 256
+  br i1 %ec.i, label %exit, label %outer.header, !llvm.loop !0
+
+exit:
+  ret void
+}
+
+; The successors of the latches are in different orders.
+;
+; for (i = 0; i < 128; i++)    // branch weights: backedge 127, exit 1
+;   for (j = 0; j < 64; j++)   // branch weights: exit 1, backedge 63
+;     A[j][i] = 0;
+;
+define void @branch_weights(ptr %A) {
+; CHECK-LABEL: define void @branch_weights(
+; CHECK-SAME: ptr [[A:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[INNER_HEADER_PREHEADER:.*]]
+; CHECK:       [[OUTER_HEADER_PREHEADER:.*]]:
+; CHECK-NEXT:    br label %[[OUTER_HEADER:.*]]
+; CHECK:       [[OUTER_HEADER]]:
+; CHECK-NEXT:    [[I:%.*]] = phi i64 [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ], [ 0, %[[OUTER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[INNER_HEADER_SPLIT1:.*]]
+; CHECK:       [[INNER_HEADER_PREHEADER]]:
+; CHECK-NEXT:    br label %[[INNER_HEADER:.*]]
+; CHECK:       [[INNER_HEADER]]:
+; CHECK-NEXT:    [[J:%.*]] = phi i64 [ [[TMP0:%.*]], %[[INNER_HEADER_SPLIT:.*]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[OUTER_HEADER_PREHEADER]]
+; CHECK:       [[INNER_HEADER_SPLIT1]]:
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [128 x i32], ptr [[A]], i64 [[J]], i64 [[I]]
+; CHECK-NEXT:    store i32 0, ptr [[GEP]], align 4
+; CHECK-NEXT:    [[J_NEXT:%.*]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], 64
+; CHECK-NEXT:    br label %[[OUTER_LATCH]]
+; CHECK:       [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT:    [[TMP0]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[TMP0]], 64
+; CHECK-NEXT:    br i1 [[TMP1]], label %[[EXIT:.*]], label %[[INNER_HEADER]], !prof [[PROF5:![0-9]+]]
+; CHECK:       [[OUTER_LATCH]]:
+; CHECK-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT:    [[EC_I:%.*]] = icmp ne i64 [[I_NEXT]], 128
+; CHECK-NEXT:    br i1 [[EC_I]], label %[[OUTER_HEADER]], label %[[INNER_HEADER_SPLIT]], !prof [[PROF6:![0-9]+]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %outer.header
+
+outer.header:
+  %i = phi i64 [ 0, %entry ], [ %i.next, %outer.latch ]
+  br label %inner.header
+
+inner.header:
+  %j = phi i64 [ 0, %outer.header ], [ %j.next, %inner.header ]
+  %gep = getelementptr inbounds [128 x i32], ptr %A, i64 %j, i64 %i
+  store i32 0, ptr %gep, align 4
+  %j.next = add nuw nsw i64 %j, 1
+  %ec.j = icmp eq i64 %j.next, 64
+  br i1 %ec.j, label %outer.latch, label %inner.header, !prof !5
+
+outer.latch:
+  %i.next = add nuw nsw i64 %i, 1
+  %ec.i = icmp ne i64 %i.next, 128
+  br i1 %ec.i, label %outer.header, label %exit, !prof !6
+
+exit:
+  ret void
+}
+
+; The latch of the inner loop has explicitly unknown branch weights.
+;
+; for (i = 0; i < 128; i++)    // branch weights: exit 1, backedge 127
+;   for (j = 0; j < 64; j++)   // branch weights: unknown
+;     A[j][i] = 0;
+;
+define void @unknown_branch_weights(ptr %A) {
+; CHECK-LABEL: define void @unknown_branch_weights(
+; CHECK-SAME: ptr [[A:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[INNER_HEADER_PREHEADER:.*]]
+; CHECK:       [[OUTER_HEADER_PREHEADER:.*]]:
+; CHECK-NEXT:    br label %[[OUTER_HEADER:.*]]
+; CHECK:       [[OUTER_HEADER]]:
+; CHECK-NEXT:    [[I:%.*]] = phi i64 [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ], [ 0, %[[OUTER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[INNER_HEADER_SPLIT1:.*]]
+; CHECK:       [[INNER_HEADER_PREHEADER]]:
+; CHECK-NEXT:    br label %[[INNER_HEADER:.*]]
+; CHECK:       [[INNER_HEADER]]:
+; CHECK-NEXT:    [[J:%.*]] = phi i64 [ [[TMP0:%.*]], %[[INNER_HEADER_SPLIT:.*]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[OUTER_HEADER_PREHEADER]]
+; CHECK:       [[INNER_HEADER_SPLIT1]]:
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [128 x i32], ptr [[A]], i64 [[J]], i64 [[I]]
+; CHECK-NEXT:    store i32 0, ptr [[GEP]], align 4
+; CHECK-NEXT:    [[J_NEXT:%.*]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], 64
+; CHECK-NEXT:    br label %[[OUTER_LATCH]]
+; CHECK:       [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT:    [[TMP0]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[TMP0]], 64
+; CHECK-NEXT:    br i1 [[TMP1]], label %[[EXIT:.*]], label %[[INNER_HEADER]], !prof [[PROF7:![0-9]+]]
+; CHECK:       [[OUTER_LATCH]]:
+; CHECK-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_NEXT]], 128
+; CHECK-NEXT:    br i1 [[EC_I]], label %[[INNER_HEADER_SPLIT]], label %[[OUTER_HEADER]], !prof [[PROF8:![0-9]+]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %outer.header
+
+outer.header:
+  %i = phi i64 [ 0, %entry ], [ %i.next, %outer.latch ]
+  br label %inner.header
+
+inner.header:
+  %j = phi i64 [ 0, %outer.header ], [ %j.next, %inner.header ]
+  %gep = getelementptr inbounds [128 x i32], ptr %A, i64 %j, i64 %i
+  store i32 0, ptr %gep, align 4
+  %j.next = add nuw nsw i64 %j, 1
+  %ec.j = icmp eq i64 %j.next, 64
+  br i1 %ec.j, label %outer.latch, label %inner.header, !prof !7
+
+outer.latch:
+  %i.next = add nuw nsw i64 %i, 1
+  %ec.i = icmp eq i64 %i.next, 128
+  br i1 %ec.i, label %exit, label %outer.header, !prof !8
+
+exit:
+  ret void
+}
+
+; Only the latch of the inner loop has branch weights.
+;
+; for (i = 0; i < 128; i++)    // no branch weights
+;   for (j = 0; j < 64; j++)   // branch weights: exit 1, backedge 63
+;     A[j][i] = 0;
+;
+define void @branch_weights_on_one_latch(ptr %A) {
+; CHECK-LABEL: define void @branch_weights_on_one_latch(
+; CHECK-SAME: ptr [[A:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[INNER_HEADER_PREHEADER:.*]]
+; CHECK:       [[OUTER_HEADER_PREHEADER:.*]]:
+; CHECK-NEXT:    br label %[[OUTER_HEADER:.*]]
+; CHECK:       [[OUTER_HEADER]]:
+; CHECK-NEXT:    [[I:%.*]] = phi i64 [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ], [ 0, %[[OUTER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[INNER_HEADER_SPLIT1:.*]]
+; CHECK:       [[INNER_HEADER_PREHEADER]]:
+; CHECK-NEXT:    br label %[[INNER_HEADER:.*]]
+; CHECK:       [[INNER_HEADER]]:
+; CHECK-NEXT:    [[J:%.*]] = phi i64 [ [[TMP0:%.*]], %[[INNER_HEADER_SPLIT:.*]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[OUTER_HEADER_PREHEADER]]
+; CHECK:       [[INNER_HEADER_SPLIT1]]:
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [128 x i32], ptr [[A]], i64 [[J]], i64 [[I]]
+; CHECK-NEXT:    store i32 0, ptr [[GEP]], align 4
+; CHECK-NEXT:    [[J_NEXT:%.*]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], 64
+; CHECK-NEXT:    br label %[[OUTER_LATCH]]
+; CHECK:       [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT:    [[TMP0]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[TMP0]], 64
+; CHECK-NEXT:    br i1 [[TMP1]], label %[[EXIT:.*]], label %[[INNER_HEADER]], !prof [[PROF5]]
+; CHECK:       [[OUTER_LATCH]]:
+; CHECK-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_NEXT]], 128
+; CHECK-NEXT:    br i1 [[EC_I]], label %[[INNER_HEADER_SPLIT]], label %[[OUTER_HEADER]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %outer.header
+
+outer.header:
+  %i = phi i64 [ 0, %entry ], [ %i.next, %outer.latch ]
+  br label %inner.header
+
+inner.header:
+  %j = phi i64 [ 0, %outer.header ], [ %j.next, %inner.header ]
+  %gep = getelementptr inbounds [128 x i32], ptr %A, i64 %j, i64 %i
+  store i32 0, ptr %gep, align 4
+  %j.next = add nuw nsw i64 %j, 1
+  %ec.j = icmp eq i64 %j.next, 64
+  br i1 %ec.j, label %outer.latch, label %inner.header, !prof !5
+
+outer.latch:
+  %i.next = add nuw nsw i64 %i, 1
+  %ec.i = icmp eq i64 %i.next, 128
+  br i1 %ec.i, label %exit, label %outer.header
+
+exit:
+  ret void
+}
+
+; The function has profile data.
+;
+; for (i = 0; i < 128; i++)    // branch weights: backedge 127, exit 1
+;   for (j = 0; j < 64; j++)   // branch weights: exit 1, backedge 63
+;     A[j][i] = 0;
+;
+define void @profiled_branch_weights(ptr %A) !prof !9 {
+; CHECK-LABEL: define void @profiled_branch_weights(
+; CHECK-SAME: ptr [[A:%.*]]) !prof [[PROF9:![0-9]+]] {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[INNER_HEADER_PREHEADER:.*]]
+; CHECK:       [[OUTER_HEADER_PREHEADER:.*]]:
+; CHECK-NEXT:    br label %[[OUTER_HEADER:.*]]
+; CHECK:       [[OUTER_HEADER]]:
+; CHECK-NEXT:    [[I:%.*]] = phi i64 [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ], [ 0, %[[OUTER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[INNER_HEADER_SPLIT1:.*]]
+; CHECK:       [[INNER_HEADER_PREHEADER]]:
+; CHECK-NEXT:    br label %[[INNER_HEADER:.*]]
+; CHECK:       [[INNER_HEADER]]:
+; CHECK-NEXT:    [[J:%.*]] = phi i64 [ [[TMP0:%.*]], %[[INNER_HEADER_SPLIT:.*]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[OUTER_HEADER_PREHEADER]]
+; CHECK:       [[INNER_HEADER_SPLIT1]]:
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [128 x i32], ptr [[A]], i64 [[J]], i64 [[I]]
+; CHECK-NEXT:    store i32 0, ptr [[GEP]], align 4
+; CHECK-NEXT:    [[J_NEXT:%.*]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], 64
+; CHECK-NEXT:    br label %[[OUTER_LATCH]]
+; CHECK:       [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT:    [[TMP0]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[TMP0]], 64
+; CHECK-NEXT:    br i1 [[TMP1]], label %[[EXIT:.*]], label %[[INNER_HEADER]], !prof [[PROF5]]
+; CHECK:       [[OUTER_LATCH]]:
+; CHECK-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT:    [[EC_I:%.*]] = icmp ne i64 [[I_NEXT]], 128
+; CHECK-NEXT:    br i1 [[EC_I]], label %[[OUTER_HEADER]], label %[[INNER_HEADER_SPLIT]], !prof [[PROF6]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %outer.header
+
+outer.header:
+  %i = phi i64 [ 0, %entry ], [ %i.next, %outer.latch ]
+  br label %inner.header
+
+inner.header:
+  %j = phi i64 [ 0, %outer.header ], [ %j.next, %inner.header ]
+  %gep = getelementptr inbounds [128 x i32], ptr %A, i64 %j, i64 %i
+  store i32 0, ptr %gep, align 4
+  %j.next = add nuw nsw i64 %j, 1
+  %ec.j = icmp eq i64 %j.next, 64
+  br i1 %ec.j, label %outer.latch, label %inner.header, !prof !5
+
+outer.latch:
+  %i.next = add nuw nsw i64 %i, 1
+  %ec.i = icmp ne i64 %i.next, 128
+  br i1 %ec.i, label %outer.header, label %exit, !prof !6
+
+exit:
+  ret void
+}
+
+!0 = distinct !{!0, !1}
+!1 = !{!"llvm.loop.unroll.disable"}
+!2 = distinct !{!2, !3}
+!3 = !{!"llvm.loop.parallel_accesses", !4}
+!4 = distinct !{}
+!5 = !{!"branch_weights", i32 1, i32 63}
+!6 = !{!"branch_weights", i32 127, i32 1}
+!7 = !{!"unknown", !"test"}
+!8 = !{!"branch_weights", i32 1, i32 127}
+!9 = !{!"function_entry_count", i64 100}
+;.
+; CHECK: [[ACC_GRP0]] = distinct !{}
+; CHECK: [[LOOP1]] = distinct !{[[LOOP1]], [[META2:![0-9]+]]}
+; CHECK: [[META2]] = !{!"llvm.loop.parallel_accesses", [[ACC_GRP0]]}
+; CHECK: [[LOOP3]] = distinct !{[[LOOP3]], [[META4:![0-9]+]]}
+; CHECK: [[META4]] = !{!"llvm.loop.unroll.disable"}
+; CHECK: [[PROF5]] = !{!"branch_weights", i32 1, i32 63}
+; CHECK: [[PROF6]] = !{!"branch_weights", i32 127, i32 1}
+; CHECK: [[PROF7]] = !{!"unknown", !"test"}
+; CHECK: [[PROF8]] = !{!"branch_weights", i32 1, i32 127}
+; CHECK: [[PROF9]] = !{!"function_entry_count", i64 100}
+;.
diff --git a/llvm/test/Transforms/LoopInterchange/outer-level-code.ll b/llvm/test/Transforms/LoopInterchange/outer-level-code.ll
new file mode 100644
index 00000000000000..8d7bdb5158c680
--- /dev/null
+++ b/llvm/test/Transforms/LoopInterchange/outer-level-code.ll
@@ -0,0 +1,287 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
+; RUN: opt < %s -passes=loop-interchange -loop-interchange-profitabilities=ignore -S | FileCheck %s
+; RUN: opt < %s -passes='print<scalar-evolution>,loop(loop-interchange),verify<scalar-evolution>' \
+; RUN:     -loop-interchange-profitabilities=ignore -disable-output
+
+; Check how the code placed in the outer loop but outside the inner loop is
+; handled when the loops are interchanged. The second RUN line checks that the
+; cached SCEV results (populated by print<scalar-evolution> beforehand) are
+; invalidated properly.
+
+; The outer header computes a value from the outer induction variable, which is
+; used in the inner loop.
+;
+; for (i = 0; i < 256; i++) {
+;   i2 = i * 2;
+;   for (j = 0; j < 256; j++)
+;     A[j][i2] = 0;
+; }
+;
+define void @outer_header_uses_outer_iv(ptr %A) {
+; CHECK-LABEL: define void @outer_header_uses_outer_iv(
+; CHECK-SAME: ptr [[A:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[INNER_HEADER_PREHEADER:.*]]
+; CHECK:       [[OUTER_HEADER_PREHEADER:.*]]:
+; CHECK-NEXT:    br label %[[OUTER_HEADER:.*]]
+; CHECK:       [[OUTER_HEADER]]:
+; CHECK-NEXT:    [[I:%.*]] = phi i64 [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ], [ 0, %[[OUTER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    [[I_MUL:%.*]] = mul nuw nsw i64 [[I]], 2
+; CHECK-NEXT:    br label %[[INNER_HEADER_SPLIT1:.*]]
+; CHECK:       [[INNER_HEADER_PREHEADER]]:
+; CHECK-NEXT:    br label %[[INNER_HEADER:.*]]
+; CHECK:       [[INNER_HEADER]]:
+; CHECK-NEXT:    [[J:%.*]] = phi i64 [ [[TMP0:%.*]], %[[INNER_HEADER_SPLIT:.*]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[OUTER_HEADER_PREHEADER]]
+; CHECK:       [[INNER_HEADER_SPLIT1]]:
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [512 x i32], ptr [[A]], i64 [[J]], i64 [[I_MUL]]
+; CHECK-NEXT:    store i32 0, ptr [[GEP]], align 4
+; CHECK-NEXT:    [[J_NEXT:%.*]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], 256
+; CHECK-NEXT:    br label %[[OUTER_LATCH]]
+; CHECK:       [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT:    [[TMP0]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[TMP0]], 256
+; CHECK-NEXT:    br i1 [[TMP1]], label %[[EXIT:.*]], label %[[INNER_HEADER]]
+; CHECK:       [[OUTER_LATCH]]:
+; CHECK-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_NEXT]], 256
+; CHECK-NEXT:    br i1 [[EC_I]], label %[[INNER_HEADER_SPLIT]], label %[[OUTER_HEADER]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %outer.header
+
+outer.header:
+  %i = phi i64 [ 0, %entry ], [ %i.next, %outer.latch ]
+  %i.mul = mul nuw nsw i64 %i, 2
+  br label %inner.header
+
+inner.header:
+  %j = phi i64 [ 0, %outer.header ], [ %j.next, %inner.header ]
+  %gep = getelementptr inbounds [512 x i32], ptr %A, i64 %j, i64 %i.mul
+  store i32 0, ptr %gep, align 4
+  %j.next = add nuw nsw i64 %j, 1
+  %ec.j = icmp eq i64 %j.next, 256
+  br i1 %ec.j, label %outer.latch, label %inner.header
+
+outer.latch:
+  %i.next = add nuw nsw i64 %i, 1
+  %ec.i = icmp eq i64 %i.next, 256
+  br i1 %ec.i, label %exit, label %outer.header
+
+exit:
+  ret void
+}
+
+; The outer latch computes a value from the outer induction variable, which is
+; used after the loop nest.
+;
+; for (i = 0; i < 256; i++) {
+;   for (j = 0; j < 256; j++)
+;     A[j][i] = 0;
+;   res = i * 7;
+; }
+; return res;
+;
+define i64 @outer_latch_uses_outer_iv(ptr %A) {
+; CHECK-LABEL: define i64 @outer_latch_uses_outer_iv(
+; CHECK-SAME: ptr [[A:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[INNER_HEADER_PREHEADER:.*]]
+; CHECK:       [[OUTER_HEADER_PREHEADER:.*]]:
+; CHECK-NEXT:    br label %[[OUTER_HEADER:.*]]
+; CHECK:       [[OUTER_HEADER]]:
+; CHECK-NEXT:    [[I:%.*]] = phi i64 [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ], [ 0, %[[OUTER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[INNER_HEADER_SPLIT1:.*]]
+; CHECK:       [[INNER_HEADER_PREHEADER]]:
+; CHECK-NEXT:    br label %[[INNER_HEADER:.*]]
+; CHECK:       [[INNER_HEADER]]:
+; CHECK-NEXT:    [[J:%.*]] = phi i64 [ [[TMP1:%.*]], %[[INNER_HEADER_SPLIT:.*]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[OUTER_HEADER_PREHEADER]]
+; CHECK:       [[INNER_HEADER_SPLIT1]]:
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [256 x i32], ptr [[A]], i64 [[J]], i64 [[I]]
+; CHECK-NEXT:    store i32 0, ptr [[GEP]], align 4
+; CHECK-NEXT:    [[J_NEXT:%.*]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], 256
+; CHECK-NEXT:    br label %[[OUTER_LATCH]]
+; CHECK:       [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT:    [[TMP0:%.*]] = phi i64 [ [[I_MUL:%.*]], %[[OUTER_LATCH]] ]
+; CHECK-NEXT:    [[TMP1]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[TMP1]], 256
+; CHECK-NEXT:    br i1 [[TMP2]], label %[[EXIT:.*]], label %[[INNER_HEADER]]
+; CHECK:       [[OUTER_LATCH]]:
+; CHECK-NEXT:    [[I_MUL]] = mul nuw nsw i64 [[I]], 7
+; CHECK-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_NEXT]], 256
+; CHECK-NEXT:    br i1 [[EC_I]], label %[[INNER_HEADER_SPLIT]], label %[[OUTER_HEADER]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    [[RES:%.*]] = phi i64 [ [[TMP0]], %[[INNER_HEADER_SPLIT]] ]
+; CHECK-NEXT:    ret i64 [[RES]]
+;
+entry:
+  br label %outer.header
+
+outer.header:
+  %i = phi i64 [ 0, %entry ], [ %i.next, %outer.latch ]
+  br label %inner.header
+
+inner.header:
+  %j = phi i64 [ 0, %outer.header ], [ %j.next, %inner.header ]
+  %gep = getelementptr inbounds [256 x i32], ptr %A, i64 %j, i64 %i
+  store i32 0, ptr %gep, align 4
+  %j.next = add nuw nsw i64 %j, 1
+  %ec.j = icmp eq i64 %j.next, 256
+  br i1 %ec.j, label %outer.latch, label %inner.header
+
+outer.latch:
+  %i.mul = mul nuw nsw i64 %i, 7
+  %i.next = add nuw nsw i64 %i, 1
+  %ec.i = icmp eq i64 %i.next, 256
+  br i1 %ec.i, label %exit, label %outer.header
+
+exit:
+  %res = phi i64 [ %i.mul, %outer.latch ]
+  ret i64 %res
+}
+
+; The terminator of the outer header depends on the outer induction variable.
+;
+; for (i = 0; i < 256; i++) {
+;   if (i == 5)
+;     goto inner_preheader;
+;   else
+;     goto inner_preheader;
+; inner_preheader:
+;   for (j = 0; j < 256; j++)
+;     A[j][i] = 0;
+; }
+;
+define void @outer_header_branch_uses_outer_iv(ptr %A) {
+; CHECK-LABEL: define void @outer_header_branch_uses_outer_iv(
+; CHECK-SAME: ptr [[A:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[INNER_PREHEADER:.*]]
+; CHECK:       [[OUTER_HEADER_PREHEADER:.*]]:
+; CHECK-NEXT:    br label %[[OUTER_HEADER:.*]]
+; CHECK:       [[OUTER_HEADER]]:
+; CHECK-NEXT:    [[I:%.*]] = phi i64 [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ], [ 0, %[[OUTER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    [[C:%.*]] = icmp eq i64 [[I]], 5
+; CHECK-NEXT:    br i1 [[C]], label %[[INNER_HEADER_SPLIT1:.*]], label %[[INNER_HEADER_SPLIT1]]
+; CHECK:       [[INNER_PREHEADER]]:
+; CHECK-NEXT:    br label %[[INNER_HEADER:.*]]
+; CHECK:       [[INNER_HEADER]]:
+; CHECK-NEXT:    [[J:%.*]] = phi i64 [ 0, %[[INNER_PREHEADER]] ], [ [[TMP0:%.*]], %[[INNER_HEADER_SPLIT:.*]] ]
+; CHECK-NEXT:    br label %[[OUTER_HEADER_PREHEADER]]
+; CHECK:       [[INNER_HEADER_SPLIT1]]:
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [256 x i32], ptr [[A]], i64 [[J]], i64 [[I]]
+; CHECK-NEXT:    store i32 0, ptr [[GEP]], align 4
+; CHECK-NEXT:    [[J_NEXT:%.*]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], 256
+; CHECK-NEXT:    br label %[[OUTER_LATCH]]
+; CHECK:       [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT:    [[TMP0]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[TMP0]], 256
+; CHECK-NEXT:    br i1 [[TMP1]], label %[[EXIT:.*]], label %[[INNER_HEADER]]
+; CHECK:       [[OUTER_LATCH]]:
+; CHECK-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_NEXT]], 256
+; CHECK-NEXT:    br i1 [[EC_I]], label %[[INNER_HEADER_SPLIT]], label %[[OUTER_HEADER]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %outer.header
+
+outer.header:
+  %i = phi i64 [ 0, %entry ], [ %i.next, %outer.latch ]
+  %c = icmp eq i64 %i, 5
+  br i1 %c, label %inner.preheader, label %inner.preheader
+
+inner.preheader:
+  br label %inner.header
+
+inner.header:
+  %j = phi i64 [ 0, %inner.preheader ], [ %j.next, %inner.header ]
+  %gep = getelementptr inbounds [256 x i32], ptr %A, i64 %j, i64 %i
+  store i32 0, ptr %gep, align 4
+  %j.next = add nuw nsw i64 %j, 1
+  %ec.j = icmp eq i64 %j.next, 256
+  br i1 %ec.j, label %outer.latch, label %inner.header
+
+outer.latch:
+  %i.next = add nuw nsw i64 %i, 1
+  %ec.i = icmp eq i64 %i.next, 256
+  br i1 %ec.i, label %exit, label %outer.header
+
+exit:
+  ret void
+}
+
+; The outer header computes a value from the outer induction variable that SCEV
+; cannot analyze, which is used in the inner loop.
+;
+; for (i = 0; i < 256; i++) {
+;   x = i ^ 5;
+;   for (j = 0; j < 256; j++)
+;     A[j][i] = x;
+; }
+;
+define void @outer_header_scev_unknown_uses_outer_iv(ptr %A) {
+; CHECK-LABEL: define void @outer_header_scev_unknown_uses_outer_iv(
+; CHECK-SAME: ptr [[A:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[INNER_HEADER_PREHEADER:.*]]
+; CHECK:       [[OUTER_HEADER_PREHEADER:.*]]:
+; CHECK-NEXT:    br label %[[OUTER_HEADER:.*]]
+; CHECK:       [[OUTER_HEADER]]:
+; CHECK-NEXT:    [[I:%.*]] = phi i64 [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ], [ 0, %[[OUTER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    [[I_XOR:%.*]] = xor i64 [[I]], 5
+; CHECK-NEXT:    br label %[[INNER_HEADER_SPLIT1:.*]]
+; CHECK:       [[INNER_HEADER_PREHEADER]]:
+; CHECK-NEXT:    br label %[[INNER_HEADER:.*]]
+; CHECK:       [[INNER_HEADER]]:
+; CHECK-NEXT:    [[J:%.*]] = phi i64 [ [[TMP0:%.*]], %[[INNER_HEADER_SPLIT:.*]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT:    br label %[[OUTER_HEADER_PREHEADER]]
+; CHECK:       [[INNER_HEADER_SPLIT1]]:
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [256 x i64], ptr [[A]], i64 [[J]], i64 [[I]]
+; CHECK-NEXT:    store i64 [[I_XOR]], ptr [[GEP]], align 8
+; CHECK-NEXT:    [[J_NEXT:%.*]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], 256
+; CHECK-NEXT:    br label %[[OUTER_LATCH]]
+; CHECK:       [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT:    [[TMP0]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[TMP0]], 256
+; CHECK-NEXT:    br i1 [[TMP1]], label %[[EXIT:.*]], label %[[INNER_HEADER]]
+; CHECK:       [[OUTER_LATCH]]:
+; CHECK-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
+; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_NEXT]], 256
+; CHECK-NEXT:    br i1 [[EC_I]], label %[[INNER_HEADER_SPLIT]], label %[[OUTER_HEADER]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %outer.header
+
+outer.header:
+  %i = phi i64 [ 0, %entry ], [ %i.next, %outer.latch ]
+  %i.xor = xor i64 %i, 5
+  br label %inner.header
+
+inner.header:
+  %j = phi i64 [ 0, %outer.header ], [ %j.next, %inner.header ]
+  %gep = getelementptr inbounds [256 x i64], ptr %A, i64 %j, i64 %i
+  store i64 %i.xor, ptr %gep, align 8
+  %j.next = add nuw nsw i64 %j, 1
+  %ec.j = icmp eq i64 %j.next, 256
+  br i1 %ec.j, label %outer.latch, label %inner.header
+
+outer.latch:
+  %i.next = add nuw nsw i64 %i, 1
+  %ec.i = icmp eq i64 %i.next, 256
+  br i1 %ec.i, label %exit, label %outer.header
+
+exit:
+  ret void
+}



More information about the llvm-branch-commits mailing list