[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