[llvm-branch-commits] [llvm] [LoopInterchange] Require loop control values to be expandable in the outer preheader (PR #235894)
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/235894
>From 41289cae04c8a850c15be202c03cf5387ae1d69b Mon Sep 17 00:00:00 2001
From: Ryotaro Kasuga <ryotaro.kasuga at gmail.com>
Date: Sun, 25 Oct 2026 08:07:04 +0900
Subject: [PATCH] [LoopInterchange] Require loop control values to be
expandable in the outer preheader
This patch slightly changes the legality check in preparation for later
patches. Specifically:
- Loops whose inner IVs have initial values that are outer loop
invariant but neither constants nor instructions (e.g., function
arguments) become interchange candidates.
- Loops where the BTC of the inner loop is computed inside the outer
loop (more precisely, cannot be expanded in the outer loop preheader)
are no longer candidates.
As far as I tried, this change doesn't affect most cases.
Part of #235496
Co-Authored-By: Claude Opus 5.5 <noreply at anthropic.com>
---
.../lib/Transforms/Scalar/LoopInterchange.cpp | 86 +++++++++++++------
.../induction-variable-update.ll | 31 ++++---
...op-control-available-in-outer-preheader.ll | 52 +++++------
3 files changed, 106 insertions(+), 63 deletions(-)
diff --git a/llvm/lib/Transforms/Scalar/LoopInterchange.cpp b/llvm/lib/Transforms/Scalar/LoopInterchange.cpp
index b99829dd0d8917..a6302c2034bf69 100644
--- a/llvm/lib/Transforms/Scalar/LoopInterchange.cpp
+++ b/llvm/lib/Transforms/Scalar/LoopInterchange.cpp
@@ -48,6 +48,7 @@
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/Transforms/Utils/LoopUtils.h"
+#include "llvm/Transforms/Utils/ScalarEvolutionExpander.h"
#include <cassert>
#include <cstdint>
#include <utility>
@@ -437,6 +438,8 @@ class LoopInterchangeLegality {
/// loops for now.
bool isLoopStructureUnderstood();
+ bool isLoopControlAvailableInOuterPreheader();
+
bool currentLimitations();
const SmallPtrSetImpl<PHINode *> &getOuterInnerReductions() const {
@@ -521,6 +524,9 @@ class LoopInterchangeLegality {
/// Set of inner loop induction PHIs
SmallVector<PHINode *, 8> InnerLoopInductions;
+ /// Set of outer loop induction PHIs
+ SmallVector<PHINode *, 8> OuterLoopInductions;
+
/// Hold instructions that have nuw/nsw flags and involved in reductions,
/// like integer addition/multiplication. Those flags must be dropped when
/// interchanging the loops.
@@ -996,29 +1002,7 @@ bool LoopInterchangeLegality::tightlyNested(Loop *OuterLoop, Loop *InnerLoop) {
}
bool LoopInterchangeLegality::isLoopStructureUnderstood() {
- BasicBlock *InnerLoopPreheader = InnerLoop->getLoopPreheader();
- for (PHINode *InnerInduction : InnerLoopInductions) {
- unsigned Num = InnerInduction->getNumOperands();
- for (unsigned i = 0; i < Num; ++i) {
- Value *Val = InnerInduction->getOperand(i);
- if (isa<Constant>(Val))
- continue;
- Instruction *I = dyn_cast<Instruction>(Val);
- if (!I)
- return false;
- // TODO: Handle triangular loops.
- // e.g. for(int i=0;i<N;i++)
- // for(int j=i;j<N;j++)
- unsigned IncomBlockIndx = PHINode::getIncomingValueNumForOperand(i);
- if (InnerInduction->getIncomingBlock(IncomBlockIndx) ==
- InnerLoopPreheader &&
- !OuterLoop->isLoopInvariant(I)) {
- return false;
- }
- }
- }
-
- // TODO: Handle triangular loops of another form.
+ // TODO: Handle triangular loops.
// e.g. for(int i=0;i<N;i++)
// for(int j=0;j<i;j++)
// or,
@@ -1088,6 +1072,40 @@ bool LoopInterchangeLegality::isLoopStructureUnderstood() {
return true;
}
+/// Check if the backedge-taken counts of both loops and the start and step
+/// values of their induction variables are available in the preheader of the
+/// outer loop. In particular, this rejects loops whose iteration space depends
+/// on the outer loop.
+///
+/// TODO: Handle triangular loops.
+/// e.g. for(int i=0;i<N;i++)
+/// for(int j=i;j<N;j++)
+bool LoopInterchangeLegality::isLoopControlAvailableInOuterPreheader() {
+ SCEVExpander Expander(*SE, "loop-interchange");
+ auto IsAvailable = [&](const SCEV *S) {
+ return SE->isAvailableAtLoopEntry(S, OuterLoop) &&
+ Expander.isSafeToExpand(S);
+ };
+
+ for (Loop *L : {OuterLoop, InnerLoop}) {
+ const SCEV *BTC = SE->getBackedgeTakenCount(L);
+ if (isa<SCEVCouldNotCompute>(BTC) || !IsAvailable(BTC))
+ return false;
+ }
+
+ for (PHINode *PHI :
+ concat<PHINode *>(OuterLoopInductions, InnerLoopInductions)) {
+ const auto *AR = cast<SCEVAddRecExpr>(SE->getSCEV(PHI));
+ Value *Start =
+ PHI->getIncomingValueForBlock(AR->getLoop()->getLoopPreheader());
+ if (!OuterLoop->isLoopInvariant(Start) ||
+ !IsAvailable(AR->getStepRecurrence(*SE)))
+ return false;
+ }
+
+ return true;
+}
+
// If SV is a LCSSA PHI node with a single incoming value, return the incoming
// value.
static Value *followLCSSA(Value *SV) {
@@ -1362,11 +1380,10 @@ bool LoopInterchangeLegality::checkInductionsAndReductions(Loop *OuterLoop) {
for (PHINode &PHI : CurLoop->getHeader()->phis()) {
InductionDescriptor ID;
if (InductionDescriptor::isInductionPHI(&PHI, CurLoop, SE, ID)) {
- if (CurLoop == InnerLoop) {
- const SCEV *Step = ID.getStep();
- if (!SE->isLoopInvariant(Step, OuterLoop))
- return false;
- InnerLoopInductions.push_back(&PHI);
+ if (CurLoop == OuterLoop || CurLoop == InnerLoop) {
+ auto &Inductions =
+ CurLoop == OuterLoop ? OuterLoopInductions : InnerLoopInductions;
+ Inductions.push_back(&PHI);
}
continue;
}
@@ -1518,6 +1535,19 @@ bool LoopInterchangeLegality::currentLimitations() {
if (!InnerLoopHeaderSuccs.insert(Succ).second)
return true;
+ if (!isLoopControlAvailableInOuterPreheader()) {
+ LLVM_DEBUG(dbgs() << "Loop control values are not available in the outer "
+ "loop preheader.\n");
+ ORE->emit([&]() {
+ return OptimizationRemarkMissed(DEBUG_TYPE, "UnsupportedLoopControl",
+ InnerLoop->getStartLoc(),
+ InnerLoop->getHeader())
+ << "Values that control the iterations of the loops are not "
+ "available before the outer loop.";
+ });
+ return true;
+ }
+
return false;
}
diff --git a/llvm/test/Transforms/LoopInterchange/induction-variable-update.ll b/llvm/test/Transforms/LoopInterchange/induction-variable-update.ll
index 7c8bc568065933..025bd943c9bc5c 100644
--- a/llvm/test/Transforms/LoopInterchange/induction-variable-update.ll
+++ b/llvm/test/Transforms/LoopInterchange/induction-variable-update.ll
@@ -15,24 +15,35 @@
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: [[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: [[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: [[J:%.*]] = phi i64 [ [[TMP1:%.*]], %[[INNER_HEADER_SPLIT:.*]] ], [ 0, %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT: [[P:%.*]] = phi ptr [ [[TMP0:%.*]], %[[INNER_HEADER_SPLIT]] ], [ [[BASE]], %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT: br label %[[OUTER_HEADER_PREHEADER]]
+; CHECK: [[INNER_HEADER_SPLIT1]]:
; 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: [[J_NEXT:%.*]] = add nuw nsw i64 [[J]], 1
+; CHECK-NEXT: [[P_NEXT:%.*]] = 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-NEXT: br label %[[OUTER_LATCH]]
+; CHECK: [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT: [[TMP0]] = getelementptr inbounds i8, ptr [[P]], i64 8
+; 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 %[[EXIT:.*]], label %[[INNER_HEADER]]
+; CHECK-NEXT: br i1 [[EC_I]], label %[[INNER_HEADER_SPLIT]], label %[[OUTER_HEADER]]
; CHECK: [[EXIT]]:
; CHECK-NEXT: ret void
;
diff --git a/llvm/test/Transforms/LoopInterchange/loop-control-available-in-outer-preheader.ll b/llvm/test/Transforms/LoopInterchange/loop-control-available-in-outer-preheader.ll
index e5c83f21d299e4..9669d4aef0f6b5 100644
--- a/llvm/test/Transforms/LoopInterchange/loop-control-available-in-outer-preheader.ll
+++ b/llvm/test/Transforms/LoopInterchange/loop-control-available-in-outer-preheader.ll
@@ -1,7 +1,9 @@
; 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 -verify-scev -S | FileCheck %s
-; The start value of the inner induction variable is a function argument.
+; The start value of the inner induction variable is a function argument, which
+; is available in the preheader of the outer loop. Therefore the loops can be
+; interchanged.
;
; for (i = 0; i < 256; i++)
; for (j = s; j < s + 256; j++)
@@ -10,24 +12,34 @@
define void @inner_iv_start_is_argument(ptr %A, i64 %s) {
; CHECK-LABEL: define void @inner_iv_start_is_argument(
; CHECK-SAME: ptr [[A:%.*]], i64 [[S:%.*]]) {
-; CHECK-NEXT: [[ENTRY:.*]]:
+; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[END:%.*]] = add nsw i64 [[S]], 256
+; 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 [ 0, %[[ENTRY]] ], [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ]
+; 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 [ [[S]], %[[OUTER_HEADER]] ], [ [[J_NEXT:%.*]], %[[INNER_HEADER]] ]
+; CHECK-NEXT: [[J:%.*]] = phi i64 [ [[TMP0:%.*]], %[[INNER_HEADER_SPLIT:.*]] ], [ [[S]], %[[INNER_HEADER_PREHEADER]] ]
+; CHECK-NEXT: br label %[[OUTER_HEADER_PREHEADER]]
+; CHECK: [[INNER_HEADER_SPLIT1]]:
; CHECK-NEXT: [[IDX:%.*]] = sub nsw i64 [[J]], [[S]]
; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [256 x i32], ptr [[A]], i64 [[IDX]], i64 [[I]]
; CHECK-NEXT: store i32 0, ptr [[GEP]], align 4
-; CHECK-NEXT: [[J_NEXT]] = add nsw i64 [[J]], 1
+; CHECK-NEXT: [[J_NEXT:%.*]] = add nsw i64 [[J]], 1
; CHECK-NEXT: [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], [[END]]
-; CHECK-NEXT: br i1 [[EC_J]], label %[[OUTER_LATCH]], label %[[INNER_HEADER]]
+; CHECK-NEXT: br label %[[OUTER_LATCH]]
+; CHECK: [[INNER_HEADER_SPLIT]]:
+; CHECK-NEXT: [[TMP0]] = add nsw i64 [[J]], 1
+; CHECK-NEXT: [[TMP1:%.*]] = icmp eq i64 [[TMP0]], [[END]]
+; 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 %[[EXIT:.*]], label %[[OUTER_HEADER]]
+; CHECK-NEXT: br i1 [[EC_I]], label %[[INNER_HEADER_SPLIT]], label %[[OUTER_HEADER]]
; CHECK: [[EXIT]]:
; CHECK-NEXT: ret void
;
@@ -58,7 +70,8 @@ exit:
}
; The trip count of the inner loop is computed in the outer loop header by an
-; instruction that SCEV cannot analyze.
+; instruction that SCEV cannot analyze. It is not available in the preheader of
+; the outer loop, so the loops are not interchanged.
;
; for (i = 0; i < 256; i++) {
; bound = 500 % -200;
@@ -69,34 +82,23 @@ exit:
define void @inner_trip_count_in_outer_header(ptr %A) {
; CHECK-LABEL: define void @inner_trip_count_in_outer_header(
; CHECK-SAME: ptr [[A:%.*]]) {
-; CHECK-NEXT: [[ENTRY:.*:]]
-; CHECK-NEXT: br label %[[INNER_HEADER_PREHEADER:.*]]
-; CHECK: [[OUTER_HEADER_PREHEADER:.*]]:
+; CHECK-NEXT: [[ENTRY:.*]]:
; 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:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[I_NEXT:%.*]], %[[OUTER_LATCH:.*]] ]
; CHECK-NEXT: [[BOUND:%.*]] = srem i64 500, -200
-; 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: [[J:%.*]] = phi i64 [ 0, %[[OUTER_HEADER]] ], [ [[J_NEXT:%.*]], %[[INNER_HEADER]] ]
; 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: [[J_NEXT]] = add nuw nsw i64 [[J]], 1
; CHECK-NEXT: [[EC_J:%.*]] = icmp eq i64 [[J_NEXT]], [[BOUND]]
-; CHECK-NEXT: br label %[[OUTER_LATCH]]
-; CHECK: [[INNER_HEADER_SPLIT]]:
-; CHECK-NEXT: [[BOUND_LCSSA:%.*]] = phi i64 [ [[BOUND]], %[[OUTER_LATCH]] ]
-; CHECK-NEXT: [[TMP0]] = add nuw nsw i64 [[J]], 1
-; CHECK-NEXT: [[TMP1:%.*]] = icmp eq i64 [[TMP0]], [[BOUND_LCSSA]]
-; CHECK-NEXT: br i1 [[TMP1]], label %[[EXIT:.*]], label %[[INNER_HEADER]]
+; 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 %[[INNER_HEADER_SPLIT]], label %[[OUTER_HEADER]]
+; CHECK-NEXT: br i1 [[EC_I]], label %[[EXIT:.*]], label %[[OUTER_HEADER]]
; CHECK: [[EXIT]]:
; CHECK-NEXT: ret void
;
More information about the llvm-branch-commits
mailing list