[llvm] [LoopBoundSplit] Preserve the original exit predicate for post-loop entry (PR #231029)

Yunus Ozen via llvm-commits llvm-commits at lists.llvm.org
Sun Oct 11 12:51:34 PDT 2026


https://github.com/ozenyunus35 created https://github.com/llvm/llvm-project/pull/231029

## Problem

Related to #229652.

LoopBoundSplit uses `icmp ne` when checking whether the post-loop should execute. This can change the meaning of the original loop exit condition and produce incorrect results.

## Changes

- Preserve the original exit predicate.
- Invert the predicate when required by the loop's exit direction.
- Use the appropriate LCSSA value for the comparison.
- Preserve the existing conditions under which LoopBoundSplit transforms loops.

## Testing

- Added four regression cases in `post-loop-entry-cond.ll`.
- Verified that the new tests fail before the fix and pass afterward.
- Tested six loop shapes across input lengths 0–239, with no mismatches after the fix.
- Verified that the five reproducers associated with #221604 retain their original behavior.
- Ran the LoopBoundSplit, PhaseOrdering, and LoopIdiom test suites: 252 passed, 53 unsupported, 0 failed.
- Formatting checks passed.

Full `check-llvm` was not run.

## Related Work

PR #221604 addresses additional unsupported loop forms. This change focuses on preserving the original exit condition without expanding the set of loops eligible for transformation.

## AI Assistance

Claude Code assisted with investigation, implementation, and testing.

>From 922d0936e2f966e2784d2be8fdf748923ea281d1 Mon Sep 17 00:00:00 2001
From: Yunus Emre Ozen <94426948+ozenyunus35 at users.noreply.github.com>
Date: Sun, 11 Oct 2026 19:14:56 +0300
Subject: [PATCH 1/2] [LoopBoundSplit] Check the original exit condition before
 the post-loop

The preheader of the post-loop decided whether to enter it by checking
that the induction variable is not equal to the original bound. That
does not match the exiting condition of the original loop: when the
loop runs once although its bound is already reached (e.g. `%iv + 1 <u
%len` with %len = 0), or when the induction variable passes the bound,
the post-loop was entered although the original loop would have
exited, and it ran additional iterations.

Check the exiting condition of the original loop with the original
bound instead, on the value it compares in the last iteration of the
pre-loop, and invert it if the loop exits when the condition is true.

Fixes #229652.

Assisted-by: Claude Code
---
 llvm/lib/Transforms/Scalar/LoopBoundSplit.cpp |  39 +-
 .../bug-loop-bound-split-phi-in-exit-block.ll |   3 +-
 .../Transforms/LoopBoundSplit/bug51866.ll     |   3 +-
 .../LoopBoundSplit/loop-bound-split.ll        |  18 +-
 .../LoopBoundSplit/post-loop-entry-cond.ll    | 377 ++++++++++++++++++
 5 files changed, 406 insertions(+), 34 deletions(-)
 create mode 100644 llvm/test/Transforms/LoopBoundSplit/post-loop-entry-cond.ll

diff --git a/llvm/lib/Transforms/Scalar/LoopBoundSplit.cpp b/llvm/lib/Transforms/Scalar/LoopBoundSplit.cpp
index 2f40cbd2d8be3..7437f9fd9cd9c 100644
--- a/llvm/lib/Transforms/Scalar/LoopBoundSplit.cpp
+++ b/llvm/lib/Transforms/Scalar/LoopBoundSplit.cpp
@@ -34,8 +34,6 @@ struct ConditionInfo {
   CmpPredicate Pred = ICmpInst::BAD_ICMP_PREDICATE;
   /// AddRec llvm value
   Value *AddRecValue = nullptr;
-  /// Non PHI AddRec llvm value
-  Value *NonPHIAddRecValue = nullptr;
   /// Bound llvm value
   Value *BoundValue = nullptr;
   /// AddRec SCEV
@@ -116,12 +114,6 @@ static bool hasProcessableCondition(const Loop &L, ScalarEvolution &SE,
   if (!Cond.AddRecSCEV)
     return false;
 
-  // If the induction variable is a PHI node, the value from the backedge is
-  // used instead.
-  Cond.NonPHIAddRecValue = Cond.AddRecValue;
-  if (auto *PN = dyn_cast<PHINode>(Cond.AddRecValue))
-    Cond.NonPHIAddRecValue = PN->getIncomingValueForBlock(L.getLoopLatch());
-
   // The BoundSCEV should be evaluated at loop entry.
   Cond.BoundSCEV = BoundSCEV;
   if (!SE.isAvailableAtLoopEntry(Cond.BoundSCEV, &L))
@@ -353,7 +345,8 @@ static bool splitLoopBound(Loop &L, DominatorTree &DT, LoopInfo &LI,
   // Replace exit branch target of pre-loop by post-loop's preheader.
   // Note: update the branch here after calling cloneLoopWithPreheader()
   // to keep the IR valid.
-  if (L.getExitBlock() == ExitingCond.BI->getSuccessor(0))
+  bool ExitsOnTrue = L.getExitBlock() == ExitingCond.BI->getSuccessor(0);
+  if (ExitsOnTrue)
     ExitingCond.BI->setSuccessor(0, PostLoopPreHeader);
   else
     ExitingCond.BI->setSuccessor(1, PostLoopPreHeader);
@@ -365,7 +358,6 @@ static bool splitLoopBound(Loop &L, DominatorTree &DT, LoopInfo &LI,
 #endif
   // Update phi nodes in header of post-loop.
   bool isExitingLatch = L.getExitingBlock() == L.getLoopLatch();
-  Value *ExitingCondLCSSAPhi = nullptr;
   for (PHINode &PN : L.getHeader()->phis()) {
     // Create LCSSA phi node in preheader of post-loop.
     PHINode *LCSSAPhi =
@@ -380,27 +372,22 @@ static bool splitLoopBound(Loop &L, DominatorTree &DT, LoopInfo &LI,
     // Update the start value of phi node in post-loop with the LCSSA phi node.
     PHINode *PostLoopPN = cast<PHINode>(VMap[&PN]);
     PostLoopPN->setIncomingValueForBlock(PostLoopPreHeader, LCSSAPhi);
-
-    // Find PHI with exiting condition from pre-loop. The PHI should be
-    // SCEVAddRecExpr and have same incoming value from backedge with
-    // ExitingCond.
-    //
-    // TODO: Separate SCEV queries from PHI node updates.
-    if (!SE.isSCEVable(PN.getType()))
-      continue;
-
-    const SCEVAddRecExpr *PhiSCEV = dyn_cast<SCEVAddRecExpr>(SE.getSCEV(&PN));
-    if (PhiSCEV && ExitingCond.NonPHIAddRecValue ==
-                       PN.getIncomingValueForBlock(L.getLoopLatch()))
-      ExitingCondLCSSAPhi = LCSSAPhi;
   }
 
   // Add conditional branch to check we can skip post-loop in its preheader,
-  // and update DT.
+  // and update DT. The post-loop runs only if the original loop would not have
+  // exited either, so check the original exiting condition with the original
+  // bound.
   Instruction *OrigBI = PostLoopPreHeader->getTerminator();
-  ICmpInst::Predicate Pred = ICmpInst::ICMP_NE;
+  PHINode *ExitingAddRecLCSSA =
+      Builder.CreatePHI(ExitingCond.AddRecValue->getType(), 1,
+                        ExitingCond.AddRecValue->getName() + ".lcssa");
+  ExitingAddRecLCSSA->addIncoming(ExitingCond.AddRecValue, L.getExitingBlock());
+  ICmpInst::Predicate Pred = ExitingCond.Pred;
+  if (ExitsOnTrue)
+    Pred = ICmpInst::getInversePredicate(Pred);
   Value *Cond =
-      Builder.CreateICmp(Pred, ExitingCondLCSSAPhi, ExitingCond.BoundValue);
+      Builder.CreateICmp(Pred, ExitingAddRecLCSSA, ExitingCond.BoundValue);
   Builder.CreateCondBr(Cond, PostLoop->getHeader(), PostLoop->getExitBlock());
   OrigBI->eraseFromParent();
   DT.changeImmediateDominator(PostLoop->getExitBlock(), PostLoopPreHeader);
diff --git a/llvm/test/Transforms/LoopBoundSplit/bug-loop-bound-split-phi-in-exit-block.ll b/llvm/test/Transforms/LoopBoundSplit/bug-loop-bound-split-phi-in-exit-block.ll
index f4c8c8af68127..0021e53761f1d 100644
--- a/llvm/test/Transforms/LoopBoundSplit/bug-loop-bound-split-phi-in-exit-block.ll
+++ b/llvm/test/Transforms/LoopBoundSplit/bug-loop-bound-split-phi-in-exit-block.ll
@@ -26,7 +26,8 @@ define i16 @test_int() {
 ; CHECK:       entry.split.split:
 ; CHECK-NEXT:    [[CALL_LCSSA_LCSSA:%.*]] = phi i16 [ [[CALL]], [[COND_END]] ]
 ; CHECK-NEXT:    [[I_LCSSA:%.*]] = phi i16 [ [[ADD]], [[COND_END]] ]
-; CHECK-NEXT:    [[TMP0:%.*]] = icmp ne i16 [[I_LCSSA]], 11
+; CHECK-NEXT:    [[I_LCSSA1:%.*]] = phi i16 [ [[I]], [[COND_END]] ]
+; CHECK-NEXT:    [[TMP0:%.*]] = icmp ult i16 [[I_LCSSA1]], 11
 ; CHECK-NEXT:    br i1 [[TMP0]], label [[FOR_BODY_SPLIT_PREHEADER:%.*]], label [[END:%.*]]
 ; CHECK:       for.body.split.preheader:
 ; CHECK-NEXT:    br label [[FOR_BODY_SPLIT:%.*]]
diff --git a/llvm/test/Transforms/LoopBoundSplit/bug51866.ll b/llvm/test/Transforms/LoopBoundSplit/bug51866.ll
index dacea3366e480..a6e0fb1ff2dad 100644
--- a/llvm/test/Transforms/LoopBoundSplit/bug51866.ll
+++ b/llvm/test/Transforms/LoopBoundSplit/bug51866.ll
@@ -36,7 +36,8 @@ define void @test() {
 ; CHECK-NEXT:    [[I_1_LCSSA:%.*]] = phi i16 [ [[I_1]], [[FOR_COND]] ]
 ; CHECK-NEXT:    [[I_2_LCSSA:%.*]] = phi i16 [ [[I_2]], [[FOR_COND]] ]
 ; CHECK-NEXT:    [[I_3_LCSSA:%.*]] = phi i16 [ [[I_3]], [[FOR_COND]] ]
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp ne i16 [[I_0_LCSSA]], 10
+; CHECK-NEXT:    [[I_0_LCSSA1:%.*]] = phi i16 [ [[I_0]], [[FOR_COND]] ]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ne i16 [[I_0_LCSSA1]], 10
 ; CHECK-NEXT:    br i1 [[TMP1]], label [[FOR_COND_SPLIT_PREHEADER:%.*]], label [[FOR_END:%.*]]
 ; CHECK:       for.cond.split.preheader:
 ; CHECK-NEXT:    br label [[FOR_COND_SPLIT:%.*]]
diff --git a/llvm/test/Transforms/LoopBoundSplit/loop-bound-split.ll b/llvm/test/Transforms/LoopBoundSplit/loop-bound-split.ll
index 433b0f051598e..c67513c39e7b4 100644
--- a/llvm/test/Transforms/LoopBoundSplit/loop-bound-split.ll
+++ b/llvm/test/Transforms/LoopBoundSplit/loop-bound-split.ll
@@ -82,7 +82,8 @@ define void @umax_variable_split_loop_bound_and_exit_cond_inc_with_sgt(i64 %a, p
 ; CHECK-NEXT:    br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]]
 ; CHECK:       loop.ph.split.split:
 ; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[TMP0:%.*]] = icmp ne i64 [[IV_LCSSA]], [[N]]
+; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
+; CHECK-NEXT:    [[TMP0:%.*]] = icmp sle i64 [[INC_LCSSA]], [[N]]
 ; CHECK-NEXT:    br i1 [[TMP0]], label [[LOOP_SPLIT_PREHEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.split.preheader:
 ; CHECK-NEXT:    br label [[LOOP_SPLIT:%.*]]
@@ -163,7 +164,8 @@ define void @constant_split_loop_bound_and_exit_cond_inc_with_sgt(ptr noalias %s
 ; CHECK-NEXT:    br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]]
 ; CHECK:       loop.ph.split.split:
 ; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[TMP0:%.*]] = icmp ne i64 [[IV_LCSSA]], [[N]]
+; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
+; CHECK-NEXT:    [[TMP0:%.*]] = icmp sle i64 [[INC_LCSSA]], [[N]]
 ; CHECK-NEXT:    br i1 [[TMP0]], label [[LOOP_SPLIT_PREHEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.split.preheader:
 ; CHECK-NEXT:    br label [[LOOP_SPLIT:%.*]]
@@ -291,7 +293,8 @@ define void @constant_split_loop_bound_and_exit_cond_inc_with_eq(ptr noalias %sr
 ; CHECK-NEXT:    br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]]
 ; CHECK:       loop.ph.split.split:
 ; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp ne i64 [[IV_LCSSA]], [[N]]
+; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ne i64 [[INC_LCSSA]], [[N]]
 ; CHECK-NEXT:    br i1 [[TMP1]], label [[LOOP_SPLIT_PREHEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.split.preheader:
 ; CHECK-NEXT:    br label [[LOOP_SPLIT:%.*]]
@@ -420,7 +423,8 @@ define void @constant_split_loop_bound_and_exit_cond_inc_with_sge(ptr noalias %s
 ; CHECK-NEXT:    br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]]
 ; CHECK:       loop.ph.split.split:
 ; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp ne i64 [[IV_LCSSA]], [[N]]
+; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp slt i64 [[INC_LCSSA]], [[N]]
 ; CHECK-NEXT:    br i1 [[TMP1]], label [[LOOP_SPLIT_PREHEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.split.preheader:
 ; CHECK-NEXT:    br label [[LOOP_SPLIT:%.*]]
@@ -549,7 +553,8 @@ define void @constant_split_loop_bound_and_exit_cond_inc_with_step_is_not_one(pt
 ; CHECK-NEXT:    br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]]
 ; CHECK:       loop.ph.split.split:
 ; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp ne i64 [[IV_LCSSA]], [[N]]
+; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp sle i64 [[INC_LCSSA]], [[N]]
 ; CHECK-NEXT:    br i1 [[TMP1]], label [[LOOP_SPLIT_PREHEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.split.preheader:
 ; CHECK-NEXT:    br label [[LOOP_SPLIT:%.*]]
@@ -900,7 +905,8 @@ define void @constant_split_loop_bound_and_exit_cond_inc_with_sgt_and_is_not_sce
 ; CHECK:       loop.ph.split.split:
 ; CHECK-NEXT:    [[IS_NOT_SCEVABLE_PHI_LCSSA:%.*]] = phi double [ 1.000000e+00, [[FOR_INC]] ]
 ; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[TMP0:%.*]] = icmp ne i64 [[IV_LCSSA]], [[N]]
+; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
+; CHECK-NEXT:    [[TMP0:%.*]] = icmp sle i64 [[INC_LCSSA]], [[N]]
 ; CHECK-NEXT:    br i1 [[TMP0]], label [[LOOP_SPLIT_PREHEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.split.preheader:
 ; CHECK-NEXT:    br label [[LOOP_SPLIT:%.*]]
diff --git a/llvm/test/Transforms/LoopBoundSplit/post-loop-entry-cond.ll b/llvm/test/Transforms/LoopBoundSplit/post-loop-entry-cond.ll
new file mode 100644
index 0000000000000..a8eb09b09f69d
--- /dev/null
+++ b/llvm/test/Transforms/LoopBoundSplit/post-loop-entry-cond.ll
@@ -0,0 +1,377 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
+; RUN: opt -passes=loop-bound-split -S < %s | FileCheck %s
+
+; The post-loop must only be entered if the original loop would not have exited
+; after the last iteration of the pre-loop, so its preheader has to check the
+; original exiting condition with the original bound. Checking that the
+; induction variable is not equal to the bound enters the post-loop when the
+; loop runs once although its bound is already reached, e.g. for %len = 0.
+
+; The loop from the issue: continue while the increment is below the bound.
+define i8 @exit_cond_inc_ult(i8 %len) {
+; CHECK-LABEL: define i8 @exit_cond_inc_ult(
+; CHECK-SAME: i8 [[LEN:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[ENTRY_SPLIT:.*]]
+; CHECK:       [[ENTRY_SPLIT]]:
+; CHECK-NEXT:    [[TMP0:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[LEN]], i8 1)
+; CHECK-NEXT:    [[NEW_BOUND:%.*]] = call i8 @llvm.umin.i8(i8 [[TMP0]], i8 10)
+; CHECK-NEXT:    br label %[[LOOP:.*]]
+; CHECK:       [[LOOP]]:
+; CHECK-NEXT:    [[IV:%.*]] = phi i8 [ 0, %[[ENTRY_SPLIT]] ], [ [[INC:%.*]], %[[LATCH:.*]] ]
+; CHECK-NEXT:    [[COUNT:%.*]] = phi i8 [ 0, %[[ENTRY_SPLIT]] ], [ [[COUNT_NEXT:%.*]], %[[LATCH]] ]
+; CHECK-NEXT:    [[SPLIT:%.*]] = icmp ult i8 [[IV]], 10
+; CHECK-NEXT:    br i1 true, label %[[THEN:.*]], label %[[ELSE:.*]]
+; CHECK:       [[THEN]]:
+; CHECK-NEXT:    [[A:%.*]] = add i8 [[COUNT]], 1
+; CHECK-NEXT:    br label %[[MERGE:.*]]
+; CHECK:       [[ELSE]]:
+; CHECK-NEXT:    [[B:%.*]] = add i8 [[COUNT]], 1
+; CHECK-NEXT:    br label %[[MERGE]]
+; CHECK:       [[MERGE]]:
+; CHECK-NEXT:    [[COUNT_NEXT]] = phi i8 [ [[A]], %[[THEN]] ], [ [[B]], %[[ELSE]] ]
+; CHECK-NEXT:    br label %[[LATCH]]
+; CHECK:       [[LATCH]]:
+; CHECK-NEXT:    [[INC]] = add nuw i8 [[IV]], 1
+; CHECK-NEXT:    [[C:%.*]] = icmp ult i8 [[INC]], [[NEW_BOUND]]
+; CHECK-NEXT:    br i1 [[C]], label %[[LOOP]], label %[[ENTRY_SPLIT_SPLIT:.*]]
+; CHECK:       [[ENTRY_SPLIT_SPLIT]]:
+; CHECK-NEXT:    [[COUNT_NEXT_LCSSA_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
+; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i8 [ [[INC]], %[[LATCH]] ]
+; CHECK-NEXT:    [[COUNT_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
+; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i8 [ [[INC]], %[[LATCH]] ]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i8 [[INC_LCSSA]], [[LEN]]
+; CHECK-NEXT:    br i1 [[TMP1]], label %[[LOOP_SPLIT_PREHEADER:.*]], label %[[EXIT:.*]]
+; CHECK:       [[LOOP_SPLIT_PREHEADER]]:
+; CHECK-NEXT:    br label %[[LOOP_SPLIT:.*]]
+; CHECK:       [[LOOP_SPLIT]]:
+; CHECK-NEXT:    [[IV_SPLIT:%.*]] = phi i8 [ [[INC_SPLIT:%.*]], %[[LATCH_SPLIT:.*]] ], [ [[IV_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
+; CHECK-NEXT:    [[COUNT_SPLIT:%.*]] = phi i8 [ [[COUNT_NEXT_SPLIT:%.*]], %[[LATCH_SPLIT]] ], [ [[COUNT_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
+; CHECK-NEXT:    [[SPLIT_SPLIT:%.*]] = icmp ult i8 [[IV_SPLIT]], 10
+; CHECK-NEXT:    br i1 false, label %[[THEN_SPLIT:.*]], label %[[ELSE_SPLIT:.*]]
+; CHECK:       [[ELSE_SPLIT]]:
+; CHECK-NEXT:    [[B_SPLIT:%.*]] = add i8 [[COUNT_SPLIT]], 1
+; CHECK-NEXT:    br label %[[MERGE_SPLIT:.*]]
+; CHECK:       [[THEN_SPLIT]]:
+; CHECK-NEXT:    [[A_SPLIT:%.*]] = add i8 [[COUNT_SPLIT]], 1
+; CHECK-NEXT:    br label %[[MERGE_SPLIT]]
+; CHECK:       [[MERGE_SPLIT]]:
+; CHECK-NEXT:    [[COUNT_NEXT_SPLIT]] = phi i8 [ [[A_SPLIT]], %[[THEN_SPLIT]] ], [ [[B_SPLIT]], %[[ELSE_SPLIT]] ]
+; CHECK-NEXT:    br label %[[LATCH_SPLIT]]
+; CHECK:       [[LATCH_SPLIT]]:
+; CHECK-NEXT:    [[INC_SPLIT]] = add nuw i8 [[IV_SPLIT]], 1
+; CHECK-NEXT:    [[C_SPLIT:%.*]] = icmp ult i8 [[INC_SPLIT]], [[LEN]]
+; CHECK-NEXT:    br i1 [[C_SPLIT]], label %[[LOOP_SPLIT]], label %[[EXIT_LOOPEXIT:.*]]
+; CHECK:       [[EXIT_LOOPEXIT]]:
+; CHECK-NEXT:    [[COUNT_NEXT_LCSSA_PH:%.*]] = phi i8 [ [[COUNT_NEXT_SPLIT]], %[[LATCH_SPLIT]] ]
+; CHECK-NEXT:    br label %[[EXIT]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    [[COUNT_NEXT_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT_LCSSA_LCSSA]], %[[ENTRY_SPLIT_SPLIT]] ], [ [[COUNT_NEXT_LCSSA_PH]], %[[EXIT_LOOPEXIT]] ]
+; CHECK-NEXT:    ret i8 [[COUNT_NEXT_LCSSA]]
+;
+entry:
+  br label %loop
+
+loop:
+  %iv = phi i8 [ 0, %entry ], [ %inc, %latch ]
+  %count = phi i8 [ 0, %entry ], [ %count.next, %latch ]
+  %split = icmp ult i8 %iv, 10
+  br i1 %split, label %then, label %else
+
+then:
+  %a = add i8 %count, 1
+  br label %merge
+
+else:
+  %b = add i8 %count, 1
+  br label %merge
+
+merge:
+  %count.next = phi i8 [ %a, %then ], [ %b, %else ]
+  br label %latch
+
+latch:
+  %inc = add nuw i8 %iv, 1
+  %c = icmp ult i8 %inc, %len
+  br i1 %c, label %loop, label %exit
+
+exit:
+  ret i8 %count.next
+}
+
+; The loop exits when the condition is true.
+define i8 @exit_on_true_cond(i8 %len) {
+; CHECK-LABEL: define i8 @exit_on_true_cond(
+; CHECK-SAME: i8 [[LEN:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[ENTRY_SPLIT:.*]]
+; CHECK:       [[ENTRY_SPLIT]]:
+; CHECK-NEXT:    [[TMP0:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[LEN]], i8 1)
+; CHECK-NEXT:    [[NEW_BOUND:%.*]] = call i8 @llvm.umin.i8(i8 [[TMP0]], i8 10)
+; CHECK-NEXT:    br label %[[LOOP:.*]]
+; CHECK:       [[LOOP]]:
+; CHECK-NEXT:    [[IV:%.*]] = phi i8 [ 0, %[[ENTRY_SPLIT]] ], [ [[INC:%.*]], %[[LATCH:.*]] ]
+; CHECK-NEXT:    [[COUNT:%.*]] = phi i8 [ 0, %[[ENTRY_SPLIT]] ], [ [[COUNT_NEXT:%.*]], %[[LATCH]] ]
+; CHECK-NEXT:    [[SPLIT:%.*]] = icmp ult i8 [[IV]], 10
+; CHECK-NEXT:    br i1 true, label %[[THEN:.*]], label %[[ELSE:.*]]
+; CHECK:       [[THEN]]:
+; CHECK-NEXT:    [[A:%.*]] = add i8 [[COUNT]], 1
+; CHECK-NEXT:    br label %[[MERGE:.*]]
+; CHECK:       [[ELSE]]:
+; CHECK-NEXT:    [[B:%.*]] = add i8 [[COUNT]], 1
+; CHECK-NEXT:    br label %[[MERGE]]
+; CHECK:       [[MERGE]]:
+; CHECK-NEXT:    [[COUNT_NEXT]] = phi i8 [ [[A]], %[[THEN]] ], [ [[B]], %[[ELSE]] ]
+; CHECK-NEXT:    br label %[[LATCH]]
+; CHECK:       [[LATCH]]:
+; CHECK-NEXT:    [[INC]] = add nuw i8 [[IV]], 1
+; CHECK-NEXT:    [[C:%.*]] = icmp uge i8 [[INC]], [[NEW_BOUND]]
+; CHECK-NEXT:    br i1 [[C]], label %[[ENTRY_SPLIT_SPLIT:.*]], label %[[LOOP]]
+; CHECK:       [[ENTRY_SPLIT_SPLIT]]:
+; CHECK-NEXT:    [[COUNT_NEXT_LCSSA_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
+; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i8 [ [[INC]], %[[LATCH]] ]
+; CHECK-NEXT:    [[COUNT_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
+; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i8 [ [[INC]], %[[LATCH]] ]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i8 [[INC_LCSSA]], [[LEN]]
+; CHECK-NEXT:    br i1 [[TMP1]], label %[[LOOP_SPLIT_PREHEADER:.*]], label %[[EXIT:.*]]
+; CHECK:       [[LOOP_SPLIT_PREHEADER]]:
+; CHECK-NEXT:    br label %[[LOOP_SPLIT:.*]]
+; CHECK:       [[LOOP_SPLIT]]:
+; CHECK-NEXT:    [[IV_SPLIT:%.*]] = phi i8 [ [[INC_SPLIT:%.*]], %[[LATCH_SPLIT:.*]] ], [ [[IV_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
+; CHECK-NEXT:    [[COUNT_SPLIT:%.*]] = phi i8 [ [[COUNT_NEXT_SPLIT:%.*]], %[[LATCH_SPLIT]] ], [ [[COUNT_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
+; CHECK-NEXT:    [[SPLIT_SPLIT:%.*]] = icmp ult i8 [[IV_SPLIT]], 10
+; CHECK-NEXT:    br i1 false, label %[[THEN_SPLIT:.*]], label %[[ELSE_SPLIT:.*]]
+; CHECK:       [[ELSE_SPLIT]]:
+; CHECK-NEXT:    [[B_SPLIT:%.*]] = add i8 [[COUNT_SPLIT]], 1
+; CHECK-NEXT:    br label %[[MERGE_SPLIT:.*]]
+; CHECK:       [[THEN_SPLIT]]:
+; CHECK-NEXT:    [[A_SPLIT:%.*]] = add i8 [[COUNT_SPLIT]], 1
+; CHECK-NEXT:    br label %[[MERGE_SPLIT]]
+; CHECK:       [[MERGE_SPLIT]]:
+; CHECK-NEXT:    [[COUNT_NEXT_SPLIT]] = phi i8 [ [[A_SPLIT]], %[[THEN_SPLIT]] ], [ [[B_SPLIT]], %[[ELSE_SPLIT]] ]
+; CHECK-NEXT:    br label %[[LATCH_SPLIT]]
+; CHECK:       [[LATCH_SPLIT]]:
+; CHECK-NEXT:    [[INC_SPLIT]] = add nuw i8 [[IV_SPLIT]], 1
+; CHECK-NEXT:    [[C_SPLIT:%.*]] = icmp uge i8 [[INC_SPLIT]], [[LEN]]
+; CHECK-NEXT:    br i1 [[C_SPLIT]], label %[[EXIT_LOOPEXIT:.*]], label %[[LOOP_SPLIT]]
+; CHECK:       [[EXIT_LOOPEXIT]]:
+; CHECK-NEXT:    [[COUNT_NEXT_LCSSA_PH:%.*]] = phi i8 [ [[COUNT_NEXT_SPLIT]], %[[LATCH_SPLIT]] ]
+; CHECK-NEXT:    br label %[[EXIT]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    [[COUNT_NEXT_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT_LCSSA_LCSSA]], %[[ENTRY_SPLIT_SPLIT]] ], [ [[COUNT_NEXT_LCSSA_PH]], %[[EXIT_LOOPEXIT]] ]
+; CHECK-NEXT:    ret i8 [[COUNT_NEXT_LCSSA]]
+;
+entry:
+  br label %loop
+
+loop:
+  %iv = phi i8 [ 0, %entry ], [ %inc, %latch ]
+  %count = phi i8 [ 0, %entry ], [ %count.next, %latch ]
+  %split = icmp ult i8 %iv, 10
+  br i1 %split, label %then, label %else
+
+then:
+  %a = add i8 %count, 1
+  br label %merge
+
+else:
+  %b = add i8 %count, 1
+  br label %merge
+
+merge:
+  %count.next = phi i8 [ %a, %then ], [ %b, %else ]
+  br label %latch
+
+latch:
+  %inc = add nuw i8 %iv, 1
+  %c = icmp uge i8 %inc, %len
+  br i1 %c, label %exit, label %loop
+
+exit:
+  ret i8 %count.next
+}
+
+; A signed bound; the loop runs once for any negative %len.
+define i8 @exit_cond_inc_slt(i8 %len) {
+; CHECK-LABEL: define i8 @exit_cond_inc_slt(
+; CHECK-SAME: i8 [[LEN:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[ENTRY_SPLIT:.*]]
+; CHECK:       [[ENTRY_SPLIT]]:
+; CHECK-NEXT:    [[SMAX:%.*]] = call i8 @llvm.smax.i8(i8 [[LEN]], i8 1)
+; CHECK-NEXT:    [[TMP0:%.*]] = add nsw i8 [[SMAX]], -1
+; CHECK-NEXT:    [[NEW_BOUND:%.*]] = call i8 @llvm.smin.i8(i8 [[TMP0]], i8 10)
+; CHECK-NEXT:    br label %[[LOOP:.*]]
+; CHECK:       [[LOOP]]:
+; CHECK-NEXT:    [[IV:%.*]] = phi i8 [ 0, %[[ENTRY_SPLIT]] ], [ [[INC:%.*]], %[[LATCH:.*]] ]
+; CHECK-NEXT:    [[COUNT:%.*]] = phi i8 [ 0, %[[ENTRY_SPLIT]] ], [ [[COUNT_NEXT:%.*]], %[[LATCH]] ]
+; CHECK-NEXT:    [[SPLIT:%.*]] = icmp slt i8 [[IV]], 10
+; CHECK-NEXT:    br i1 true, label %[[THEN:.*]], label %[[ELSE:.*]]
+; CHECK:       [[THEN]]:
+; CHECK-NEXT:    [[A:%.*]] = add i8 [[COUNT]], 1
+; CHECK-NEXT:    br label %[[MERGE:.*]]
+; CHECK:       [[ELSE]]:
+; CHECK-NEXT:    [[B:%.*]] = add i8 [[COUNT]], 1
+; CHECK-NEXT:    br label %[[MERGE]]
+; CHECK:       [[MERGE]]:
+; CHECK-NEXT:    [[COUNT_NEXT]] = phi i8 [ [[A]], %[[THEN]] ], [ [[B]], %[[ELSE]] ]
+; CHECK-NEXT:    br label %[[LATCH]]
+; CHECK:       [[LATCH]]:
+; CHECK-NEXT:    [[INC]] = add nsw i8 [[IV]], 1
+; CHECK-NEXT:    [[C:%.*]] = icmp slt i8 [[INC]], [[NEW_BOUND]]
+; CHECK-NEXT:    br i1 [[C]], label %[[LOOP]], label %[[ENTRY_SPLIT_SPLIT:.*]]
+; CHECK:       [[ENTRY_SPLIT_SPLIT]]:
+; CHECK-NEXT:    [[COUNT_NEXT_LCSSA_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
+; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i8 [ [[INC]], %[[LATCH]] ]
+; CHECK-NEXT:    [[COUNT_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
+; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i8 [ [[INC]], %[[LATCH]] ]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp slt i8 [[INC_LCSSA]], [[LEN]]
+; CHECK-NEXT:    br i1 [[TMP1]], label %[[LOOP_SPLIT_PREHEADER:.*]], label %[[EXIT:.*]]
+; CHECK:       [[LOOP_SPLIT_PREHEADER]]:
+; CHECK-NEXT:    br label %[[LOOP_SPLIT:.*]]
+; CHECK:       [[LOOP_SPLIT]]:
+; CHECK-NEXT:    [[IV_SPLIT:%.*]] = phi i8 [ [[INC_SPLIT:%.*]], %[[LATCH_SPLIT:.*]] ], [ [[IV_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
+; CHECK-NEXT:    [[COUNT_SPLIT:%.*]] = phi i8 [ [[COUNT_NEXT_SPLIT:%.*]], %[[LATCH_SPLIT]] ], [ [[COUNT_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
+; CHECK-NEXT:    [[SPLIT_SPLIT:%.*]] = icmp slt i8 [[IV_SPLIT]], 10
+; CHECK-NEXT:    br i1 false, label %[[THEN_SPLIT:.*]], label %[[ELSE_SPLIT:.*]]
+; CHECK:       [[ELSE_SPLIT]]:
+; CHECK-NEXT:    [[B_SPLIT:%.*]] = add i8 [[COUNT_SPLIT]], 1
+; CHECK-NEXT:    br label %[[MERGE_SPLIT:.*]]
+; CHECK:       [[THEN_SPLIT]]:
+; CHECK-NEXT:    [[A_SPLIT:%.*]] = add i8 [[COUNT_SPLIT]], 1
+; CHECK-NEXT:    br label %[[MERGE_SPLIT]]
+; CHECK:       [[MERGE_SPLIT]]:
+; CHECK-NEXT:    [[COUNT_NEXT_SPLIT]] = phi i8 [ [[A_SPLIT]], %[[THEN_SPLIT]] ], [ [[B_SPLIT]], %[[ELSE_SPLIT]] ]
+; CHECK-NEXT:    br label %[[LATCH_SPLIT]]
+; CHECK:       [[LATCH_SPLIT]]:
+; CHECK-NEXT:    [[INC_SPLIT]] = add nsw i8 [[IV_SPLIT]], 1
+; CHECK-NEXT:    [[C_SPLIT:%.*]] = icmp slt i8 [[INC_SPLIT]], [[LEN]]
+; CHECK-NEXT:    br i1 [[C_SPLIT]], label %[[LOOP_SPLIT]], label %[[EXIT_LOOPEXIT:.*]]
+; CHECK:       [[EXIT_LOOPEXIT]]:
+; CHECK-NEXT:    [[COUNT_NEXT_LCSSA_PH:%.*]] = phi i8 [ [[COUNT_NEXT_SPLIT]], %[[LATCH_SPLIT]] ]
+; CHECK-NEXT:    br label %[[EXIT]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    [[COUNT_NEXT_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT_LCSSA_LCSSA]], %[[ENTRY_SPLIT_SPLIT]] ], [ [[COUNT_NEXT_LCSSA_PH]], %[[EXIT_LOOPEXIT]] ]
+; CHECK-NEXT:    ret i8 [[COUNT_NEXT_LCSSA]]
+;
+entry:
+  br label %loop
+
+loop:
+  %iv = phi i8 [ 0, %entry ], [ %inc, %latch ]
+  %count = phi i8 [ 0, %entry ], [ %count.next, %latch ]
+  %split = icmp slt i8 %iv, 10
+  br i1 %split, label %then, label %else
+
+then:
+  %a = add i8 %count, 1
+  br label %merge
+
+else:
+  %b = add i8 %count, 1
+  br label %merge
+
+merge:
+  %count.next = phi i8 [ %a, %then ], [ %b, %else ]
+  br label %latch
+
+latch:
+  %inc = add nsw i8 %iv, 1
+  %c = icmp slt i8 %inc, %len
+  br i1 %c, label %loop, label %exit
+
+exit:
+  ret i8 %count.next
+}
+
+; The exiting condition compares the induction variable itself rather than
+; its increment.
+define i8 @exit_cond_iv_ult(i8 %len) {
+; CHECK-LABEL: define i8 @exit_cond_iv_ult(
+; CHECK-SAME: i8 [[LEN:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br label %[[ENTRY_SPLIT:.*]]
+; CHECK:       [[ENTRY_SPLIT]]:
+; CHECK-NEXT:    [[NEW_BOUND:%.*]] = call i8 @llvm.umin.i8(i8 [[LEN]], i8 10)
+; CHECK-NEXT:    br label %[[LOOP:.*]]
+; CHECK:       [[LOOP]]:
+; CHECK-NEXT:    [[IV:%.*]] = phi i8 [ 0, %[[ENTRY_SPLIT]] ], [ [[INC:%.*]], %[[LATCH:.*]] ]
+; CHECK-NEXT:    [[COUNT:%.*]] = phi i8 [ 0, %[[ENTRY_SPLIT]] ], [ [[COUNT_NEXT:%.*]], %[[LATCH]] ]
+; CHECK-NEXT:    [[SPLIT:%.*]] = icmp ult i8 [[IV]], 10
+; CHECK-NEXT:    br i1 true, label %[[THEN:.*]], label %[[ELSE:.*]]
+; CHECK:       [[THEN]]:
+; CHECK-NEXT:    [[A:%.*]] = add i8 [[COUNT]], 1
+; CHECK-NEXT:    br label %[[MERGE:.*]]
+; CHECK:       [[ELSE]]:
+; CHECK-NEXT:    [[B:%.*]] = add i8 [[COUNT]], 1
+; CHECK-NEXT:    br label %[[MERGE]]
+; CHECK:       [[MERGE]]:
+; CHECK-NEXT:    [[COUNT_NEXT]] = phi i8 [ [[A]], %[[THEN]] ], [ [[B]], %[[ELSE]] ]
+; CHECK-NEXT:    br label %[[LATCH]]
+; CHECK:       [[LATCH]]:
+; CHECK-NEXT:    [[INC]] = add nuw i8 [[IV]], 1
+; CHECK-NEXT:    [[C:%.*]] = icmp ult i8 [[IV]], [[NEW_BOUND]]
+; CHECK-NEXT:    br i1 [[C]], label %[[LOOP]], label %[[ENTRY_SPLIT_SPLIT:.*]]
+; CHECK:       [[ENTRY_SPLIT_SPLIT]]:
+; CHECK-NEXT:    [[COUNT_NEXT_LCSSA_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
+; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i8 [ [[INC]], %[[LATCH]] ]
+; CHECK-NEXT:    [[COUNT_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
+; CHECK-NEXT:    [[IV_LCSSA1:%.*]] = phi i8 [ [[IV]], %[[LATCH]] ]
+; CHECK-NEXT:    [[TMP0:%.*]] = icmp ult i8 [[IV_LCSSA1]], [[LEN]]
+; CHECK-NEXT:    br i1 [[TMP0]], label %[[LOOP_SPLIT_PREHEADER:.*]], label %[[EXIT:.*]]
+; CHECK:       [[LOOP_SPLIT_PREHEADER]]:
+; CHECK-NEXT:    br label %[[LOOP_SPLIT:.*]]
+; CHECK:       [[LOOP_SPLIT]]:
+; CHECK-NEXT:    [[IV_SPLIT:%.*]] = phi i8 [ [[INC_SPLIT:%.*]], %[[LATCH_SPLIT:.*]] ], [ [[IV_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
+; CHECK-NEXT:    [[COUNT_SPLIT:%.*]] = phi i8 [ [[COUNT_NEXT_SPLIT:%.*]], %[[LATCH_SPLIT]] ], [ [[COUNT_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
+; CHECK-NEXT:    [[SPLIT_SPLIT:%.*]] = icmp ult i8 [[IV_SPLIT]], 10
+; CHECK-NEXT:    br i1 false, label %[[THEN_SPLIT:.*]], label %[[ELSE_SPLIT:.*]]
+; CHECK:       [[ELSE_SPLIT]]:
+; CHECK-NEXT:    [[B_SPLIT:%.*]] = add i8 [[COUNT_SPLIT]], 1
+; CHECK-NEXT:    br label %[[MERGE_SPLIT:.*]]
+; CHECK:       [[THEN_SPLIT]]:
+; CHECK-NEXT:    [[A_SPLIT:%.*]] = add i8 [[COUNT_SPLIT]], 1
+; CHECK-NEXT:    br label %[[MERGE_SPLIT]]
+; CHECK:       [[MERGE_SPLIT]]:
+; CHECK-NEXT:    [[COUNT_NEXT_SPLIT]] = phi i8 [ [[A_SPLIT]], %[[THEN_SPLIT]] ], [ [[B_SPLIT]], %[[ELSE_SPLIT]] ]
+; CHECK-NEXT:    br label %[[LATCH_SPLIT]]
+; CHECK:       [[LATCH_SPLIT]]:
+; CHECK-NEXT:    [[INC_SPLIT]] = add nuw i8 [[IV_SPLIT]], 1
+; CHECK-NEXT:    [[C_SPLIT:%.*]] = icmp ult i8 [[IV_SPLIT]], [[LEN]]
+; CHECK-NEXT:    br i1 [[C_SPLIT]], label %[[LOOP_SPLIT]], label %[[EXIT_LOOPEXIT:.*]]
+; CHECK:       [[EXIT_LOOPEXIT]]:
+; CHECK-NEXT:    [[COUNT_NEXT_LCSSA_PH:%.*]] = phi i8 [ [[COUNT_NEXT_SPLIT]], %[[LATCH_SPLIT]] ]
+; CHECK-NEXT:    br label %[[EXIT]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    [[COUNT_NEXT_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT_LCSSA_LCSSA]], %[[ENTRY_SPLIT_SPLIT]] ], [ [[COUNT_NEXT_LCSSA_PH]], %[[EXIT_LOOPEXIT]] ]
+; CHECK-NEXT:    ret i8 [[COUNT_NEXT_LCSSA]]
+;
+entry:
+  br label %loop
+
+loop:
+  %iv = phi i8 [ 0, %entry ], [ %inc, %latch ]
+  %count = phi i8 [ 0, %entry ], [ %count.next, %latch ]
+  %split = icmp ult i8 %iv, 10
+  br i1 %split, label %then, label %else
+
+then:
+  %a = add i8 %count, 1
+  br label %merge
+
+else:
+  %b = add i8 %count, 1
+  br label %merge
+
+merge:
+  %count.next = phi i8 [ %a, %then ], [ %b, %else ]
+  br label %latch
+
+latch:
+  %inc = add nuw i8 %iv, 1
+  %c = icmp ult i8 %iv, %len
+  br i1 %c, label %loop, label %exit
+
+exit:
+  ret i8 %count.next
+}

>From 730ee729dc9f08623080844334de4a4181220086 Mon Sep 17 00:00:00 2001
From: Yunus Emre Ozen <94426948+ozenyunus35 at users.noreply.github.com>
Date: Sun, 11 Oct 2026 19:49:58 +0300
Subject: [PATCH 2/2] [LoopBoundSplit] Keep the loop forms the pass transforms
 unchanged

The previous commit also removed the lookup of the header PHI that
carries the exiting condition, and the computation of its value from
the backedge. For loop forms the pass does not support, such as a
recurrence of another loop or a non-header PHI, these assert today.
Without them the pass split such loops and generated wrong code.

Restore both, so the change is limited to the check in the preheader
of the post-loop: it is done on the existing LCSSA PHI of the exiting
value, or on the PHI itself when the latch tests the PHI rather than its
value from the backedge.

Assisted-by: Claude Code
---
 llvm/lib/Transforms/Scalar/LoopBoundSplit.cpp | 42 +++++++++++++++----
 .../Transforms/LoopBoundSplit/bug51866.ll     |  3 +-
 .../LoopBoundSplit/loop-bound-split.ll        | 18 +++-----
 .../LoopBoundSplit/post-loop-entry-cond.ll    | 15 +++----
 4 files changed, 48 insertions(+), 30 deletions(-)

diff --git a/llvm/lib/Transforms/Scalar/LoopBoundSplit.cpp b/llvm/lib/Transforms/Scalar/LoopBoundSplit.cpp
index 7437f9fd9cd9c..8a4a7aba68789 100644
--- a/llvm/lib/Transforms/Scalar/LoopBoundSplit.cpp
+++ b/llvm/lib/Transforms/Scalar/LoopBoundSplit.cpp
@@ -34,6 +34,8 @@ struct ConditionInfo {
   CmpPredicate Pred = ICmpInst::BAD_ICMP_PREDICATE;
   /// AddRec llvm value
   Value *AddRecValue = nullptr;
+  /// Non PHI AddRec llvm value
+  Value *NonPHIAddRecValue = nullptr;
   /// Bound llvm value
   Value *BoundValue = nullptr;
   /// AddRec SCEV
@@ -114,6 +116,12 @@ static bool hasProcessableCondition(const Loop &L, ScalarEvolution &SE,
   if (!Cond.AddRecSCEV)
     return false;
 
+  // If the induction variable is a PHI node, the value from the backedge is
+  // used instead.
+  Cond.NonPHIAddRecValue = Cond.AddRecValue;
+  if (auto *PN = dyn_cast<PHINode>(Cond.AddRecValue))
+    Cond.NonPHIAddRecValue = PN->getIncomingValueForBlock(L.getLoopLatch());
+
   // The BoundSCEV should be evaluated at loop entry.
   Cond.BoundSCEV = BoundSCEV;
   if (!SE.isAvailableAtLoopEntry(Cond.BoundSCEV, &L))
@@ -358,6 +366,7 @@ static bool splitLoopBound(Loop &L, DominatorTree &DT, LoopInfo &LI,
 #endif
   // Update phi nodes in header of post-loop.
   bool isExitingLatch = L.getExitingBlock() == L.getLoopLatch();
+  Value *ExitingCondLCSSAPhi = nullptr;
   for (PHINode &PN : L.getHeader()->phis()) {
     // Create LCSSA phi node in preheader of post-loop.
     PHINode *LCSSAPhi =
@@ -372,22 +381,41 @@ static bool splitLoopBound(Loop &L, DominatorTree &DT, LoopInfo &LI,
     // Update the start value of phi node in post-loop with the LCSSA phi node.
     PHINode *PostLoopPN = cast<PHINode>(VMap[&PN]);
     PostLoopPN->setIncomingValueForBlock(PostLoopPreHeader, LCSSAPhi);
+
+    // Find PHI with exiting condition from pre-loop. The PHI should be
+    // SCEVAddRecExpr and have same incoming value from backedge with
+    // ExitingCond.
+    //
+    // TODO: Separate SCEV queries from PHI node updates.
+    if (!SE.isSCEVable(PN.getType()))
+      continue;
+
+    const SCEVAddRecExpr *PhiSCEV = dyn_cast<SCEVAddRecExpr>(SE.getSCEV(&PN));
+    if (PhiSCEV && ExitingCond.NonPHIAddRecValue ==
+                       PN.getIncomingValueForBlock(L.getLoopLatch()))
+      ExitingCondLCSSAPhi = LCSSAPhi;
   }
 
   // Add conditional branch to check we can skip post-loop in its preheader,
   // and update DT. The post-loop runs only if the original loop would not have
   // exited either, so check the original exiting condition with the original
-  // bound.
+  // bound on the value it tests in the last iteration of the pre-loop. If the
+  // latch tests the PHI rather than its value from the backedge, that is the
+  // PHI itself instead of ExitingCondLCSSAPhi.
   Instruction *OrigBI = PostLoopPreHeader->getTerminator();
-  PHINode *ExitingAddRecLCSSA =
-      Builder.CreatePHI(ExitingCond.AddRecValue->getType(), 1,
-                        ExitingCond.AddRecValue->getName() + ".lcssa");
-  ExitingAddRecLCSSA->addIncoming(ExitingCond.AddRecValue, L.getExitingBlock());
+  Value *ExitingValue = ExitingCondLCSSAPhi;
+  if (ExitingCondLCSSAPhi && isExitingLatch &&
+      isa<PHINode>(ExitingCond.AddRecValue)) {
+    PHINode *PNLCSSA =
+        Builder.CreatePHI(ExitingCond.AddRecValue->getType(), 1,
+                          ExitingCond.AddRecValue->getName() + ".lcssa");
+    PNLCSSA->addIncoming(ExitingCond.AddRecValue, L.getExitingBlock());
+    ExitingValue = PNLCSSA;
+  }
   ICmpInst::Predicate Pred = ExitingCond.Pred;
   if (ExitsOnTrue)
     Pred = ICmpInst::getInversePredicate(Pred);
-  Value *Cond =
-      Builder.CreateICmp(Pred, ExitingAddRecLCSSA, ExitingCond.BoundValue);
+  Value *Cond = Builder.CreateICmp(Pred, ExitingValue, ExitingCond.BoundValue);
   Builder.CreateCondBr(Cond, PostLoop->getHeader(), PostLoop->getExitBlock());
   OrigBI->eraseFromParent();
   DT.changeImmediateDominator(PostLoop->getExitBlock(), PostLoopPreHeader);
diff --git a/llvm/test/Transforms/LoopBoundSplit/bug51866.ll b/llvm/test/Transforms/LoopBoundSplit/bug51866.ll
index a6e0fb1ff2dad..dacea3366e480 100644
--- a/llvm/test/Transforms/LoopBoundSplit/bug51866.ll
+++ b/llvm/test/Transforms/LoopBoundSplit/bug51866.ll
@@ -36,8 +36,7 @@ define void @test() {
 ; CHECK-NEXT:    [[I_1_LCSSA:%.*]] = phi i16 [ [[I_1]], [[FOR_COND]] ]
 ; CHECK-NEXT:    [[I_2_LCSSA:%.*]] = phi i16 [ [[I_2]], [[FOR_COND]] ]
 ; CHECK-NEXT:    [[I_3_LCSSA:%.*]] = phi i16 [ [[I_3]], [[FOR_COND]] ]
-; CHECK-NEXT:    [[I_0_LCSSA1:%.*]] = phi i16 [ [[I_0]], [[FOR_COND]] ]
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp ne i16 [[I_0_LCSSA1]], 10
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ne i16 [[I_0_LCSSA]], 10
 ; CHECK-NEXT:    br i1 [[TMP1]], label [[FOR_COND_SPLIT_PREHEADER:%.*]], label [[FOR_END:%.*]]
 ; CHECK:       for.cond.split.preheader:
 ; CHECK-NEXT:    br label [[FOR_COND_SPLIT:%.*]]
diff --git a/llvm/test/Transforms/LoopBoundSplit/loop-bound-split.ll b/llvm/test/Transforms/LoopBoundSplit/loop-bound-split.ll
index c67513c39e7b4..4312ef144ee98 100644
--- a/llvm/test/Transforms/LoopBoundSplit/loop-bound-split.ll
+++ b/llvm/test/Transforms/LoopBoundSplit/loop-bound-split.ll
@@ -82,8 +82,7 @@ define void @umax_variable_split_loop_bound_and_exit_cond_inc_with_sgt(i64 %a, p
 ; CHECK-NEXT:    br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]]
 ; CHECK:       loop.ph.split.split:
 ; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[TMP0:%.*]] = icmp sle i64 [[INC_LCSSA]], [[N]]
+; CHECK-NEXT:    [[TMP0:%.*]] = icmp sle i64 [[IV_LCSSA]], [[N]]
 ; CHECK-NEXT:    br i1 [[TMP0]], label [[LOOP_SPLIT_PREHEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.split.preheader:
 ; CHECK-NEXT:    br label [[LOOP_SPLIT:%.*]]
@@ -164,8 +163,7 @@ define void @constant_split_loop_bound_and_exit_cond_inc_with_sgt(ptr noalias %s
 ; CHECK-NEXT:    br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]]
 ; CHECK:       loop.ph.split.split:
 ; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[TMP0:%.*]] = icmp sle i64 [[INC_LCSSA]], [[N]]
+; CHECK-NEXT:    [[TMP0:%.*]] = icmp sle i64 [[IV_LCSSA]], [[N]]
 ; CHECK-NEXT:    br i1 [[TMP0]], label [[LOOP_SPLIT_PREHEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.split.preheader:
 ; CHECK-NEXT:    br label [[LOOP_SPLIT:%.*]]
@@ -293,8 +291,7 @@ define void @constant_split_loop_bound_and_exit_cond_inc_with_eq(ptr noalias %sr
 ; CHECK-NEXT:    br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]]
 ; CHECK:       loop.ph.split.split:
 ; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp ne i64 [[INC_LCSSA]], [[N]]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ne i64 [[IV_LCSSA]], [[N]]
 ; CHECK-NEXT:    br i1 [[TMP1]], label [[LOOP_SPLIT_PREHEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.split.preheader:
 ; CHECK-NEXT:    br label [[LOOP_SPLIT:%.*]]
@@ -423,8 +420,7 @@ define void @constant_split_loop_bound_and_exit_cond_inc_with_sge(ptr noalias %s
 ; CHECK-NEXT:    br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]]
 ; CHECK:       loop.ph.split.split:
 ; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp slt i64 [[INC_LCSSA]], [[N]]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp slt i64 [[IV_LCSSA]], [[N]]
 ; CHECK-NEXT:    br i1 [[TMP1]], label [[LOOP_SPLIT_PREHEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.split.preheader:
 ; CHECK-NEXT:    br label [[LOOP_SPLIT:%.*]]
@@ -553,8 +549,7 @@ define void @constant_split_loop_bound_and_exit_cond_inc_with_step_is_not_one(pt
 ; CHECK-NEXT:    br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]]
 ; CHECK:       loop.ph.split.split:
 ; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp sle i64 [[INC_LCSSA]], [[N]]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp sle i64 [[IV_LCSSA]], [[N]]
 ; CHECK-NEXT:    br i1 [[TMP1]], label [[LOOP_SPLIT_PREHEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.split.preheader:
 ; CHECK-NEXT:    br label [[LOOP_SPLIT:%.*]]
@@ -905,8 +900,7 @@ define void @constant_split_loop_bound_and_exit_cond_inc_with_sgt_and_is_not_sce
 ; CHECK:       loop.ph.split.split:
 ; CHECK-NEXT:    [[IS_NOT_SCEVABLE_PHI_LCSSA:%.*]] = phi double [ 1.000000e+00, [[FOR_INC]] ]
 ; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
-; CHECK-NEXT:    [[TMP0:%.*]] = icmp sle i64 [[INC_LCSSA]], [[N]]
+; CHECK-NEXT:    [[TMP0:%.*]] = icmp sle i64 [[IV_LCSSA]], [[N]]
 ; CHECK-NEXT:    br i1 [[TMP0]], label [[LOOP_SPLIT_PREHEADER:%.*]], label [[EXIT:%.*]]
 ; CHECK:       loop.split.preheader:
 ; CHECK-NEXT:    br label [[LOOP_SPLIT:%.*]]
diff --git a/llvm/test/Transforms/LoopBoundSplit/post-loop-entry-cond.ll b/llvm/test/Transforms/LoopBoundSplit/post-loop-entry-cond.ll
index a8eb09b09f69d..dd65efac0d7db 100644
--- a/llvm/test/Transforms/LoopBoundSplit/post-loop-entry-cond.ll
+++ b/llvm/test/Transforms/LoopBoundSplit/post-loop-entry-cond.ll
@@ -37,15 +37,14 @@ define i8 @exit_cond_inc_ult(i8 %len) {
 ; CHECK-NEXT:    br i1 [[C]], label %[[LOOP]], label %[[ENTRY_SPLIT_SPLIT:.*]]
 ; CHECK:       [[ENTRY_SPLIT_SPLIT]]:
 ; CHECK-NEXT:    [[COUNT_NEXT_LCSSA_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
-; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i8 [ [[INC]], %[[LATCH]] ]
-; CHECK-NEXT:    [[COUNT_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
 ; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i8 [ [[INC]], %[[LATCH]] ]
+; CHECK-NEXT:    [[COUNT_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i8 [[INC_LCSSA]], [[LEN]]
 ; CHECK-NEXT:    br i1 [[TMP1]], label %[[LOOP_SPLIT_PREHEADER:.*]], label %[[EXIT:.*]]
 ; CHECK:       [[LOOP_SPLIT_PREHEADER]]:
 ; CHECK-NEXT:    br label %[[LOOP_SPLIT:.*]]
 ; CHECK:       [[LOOP_SPLIT]]:
-; CHECK-NEXT:    [[IV_SPLIT:%.*]] = phi i8 [ [[INC_SPLIT:%.*]], %[[LATCH_SPLIT:.*]] ], [ [[IV_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
+; CHECK-NEXT:    [[IV_SPLIT:%.*]] = phi i8 [ [[INC_SPLIT:%.*]], %[[LATCH_SPLIT:.*]] ], [ [[INC_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
 ; CHECK-NEXT:    [[COUNT_SPLIT:%.*]] = phi i8 [ [[COUNT_NEXT_SPLIT:%.*]], %[[LATCH_SPLIT]] ], [ [[COUNT_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
 ; CHECK-NEXT:    [[SPLIT_SPLIT:%.*]] = icmp ult i8 [[IV_SPLIT]], 10
 ; CHECK-NEXT:    br i1 false, label %[[THEN_SPLIT:.*]], label %[[ELSE_SPLIT:.*]]
@@ -129,15 +128,14 @@ define i8 @exit_on_true_cond(i8 %len) {
 ; CHECK-NEXT:    br i1 [[C]], label %[[ENTRY_SPLIT_SPLIT:.*]], label %[[LOOP]]
 ; CHECK:       [[ENTRY_SPLIT_SPLIT]]:
 ; CHECK-NEXT:    [[COUNT_NEXT_LCSSA_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
-; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i8 [ [[INC]], %[[LATCH]] ]
-; CHECK-NEXT:    [[COUNT_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
 ; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i8 [ [[INC]], %[[LATCH]] ]
+; CHECK-NEXT:    [[COUNT_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i8 [[INC_LCSSA]], [[LEN]]
 ; CHECK-NEXT:    br i1 [[TMP1]], label %[[LOOP_SPLIT_PREHEADER:.*]], label %[[EXIT:.*]]
 ; CHECK:       [[LOOP_SPLIT_PREHEADER]]:
 ; CHECK-NEXT:    br label %[[LOOP_SPLIT:.*]]
 ; CHECK:       [[LOOP_SPLIT]]:
-; CHECK-NEXT:    [[IV_SPLIT:%.*]] = phi i8 [ [[INC_SPLIT:%.*]], %[[LATCH_SPLIT:.*]] ], [ [[IV_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
+; CHECK-NEXT:    [[IV_SPLIT:%.*]] = phi i8 [ [[INC_SPLIT:%.*]], %[[LATCH_SPLIT:.*]] ], [ [[INC_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
 ; CHECK-NEXT:    [[COUNT_SPLIT:%.*]] = phi i8 [ [[COUNT_NEXT_SPLIT:%.*]], %[[LATCH_SPLIT]] ], [ [[COUNT_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
 ; CHECK-NEXT:    [[SPLIT_SPLIT:%.*]] = icmp ult i8 [[IV_SPLIT]], 10
 ; CHECK-NEXT:    br i1 false, label %[[THEN_SPLIT:.*]], label %[[ELSE_SPLIT:.*]]
@@ -222,15 +220,14 @@ define i8 @exit_cond_inc_slt(i8 %len) {
 ; CHECK-NEXT:    br i1 [[C]], label %[[LOOP]], label %[[ENTRY_SPLIT_SPLIT:.*]]
 ; CHECK:       [[ENTRY_SPLIT_SPLIT]]:
 ; CHECK-NEXT:    [[COUNT_NEXT_LCSSA_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
-; CHECK-NEXT:    [[IV_LCSSA:%.*]] = phi i8 [ [[INC]], %[[LATCH]] ]
-; CHECK-NEXT:    [[COUNT_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
 ; CHECK-NEXT:    [[INC_LCSSA:%.*]] = phi i8 [ [[INC]], %[[LATCH]] ]
+; CHECK-NEXT:    [[COUNT_LCSSA:%.*]] = phi i8 [ [[COUNT_NEXT]], %[[LATCH]] ]
 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp slt i8 [[INC_LCSSA]], [[LEN]]
 ; CHECK-NEXT:    br i1 [[TMP1]], label %[[LOOP_SPLIT_PREHEADER:.*]], label %[[EXIT:.*]]
 ; CHECK:       [[LOOP_SPLIT_PREHEADER]]:
 ; CHECK-NEXT:    br label %[[LOOP_SPLIT:.*]]
 ; CHECK:       [[LOOP_SPLIT]]:
-; CHECK-NEXT:    [[IV_SPLIT:%.*]] = phi i8 [ [[INC_SPLIT:%.*]], %[[LATCH_SPLIT:.*]] ], [ [[IV_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
+; CHECK-NEXT:    [[IV_SPLIT:%.*]] = phi i8 [ [[INC_SPLIT:%.*]], %[[LATCH_SPLIT:.*]] ], [ [[INC_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
 ; CHECK-NEXT:    [[COUNT_SPLIT:%.*]] = phi i8 [ [[COUNT_NEXT_SPLIT:%.*]], %[[LATCH_SPLIT]] ], [ [[COUNT_LCSSA]], %[[LOOP_SPLIT_PREHEADER]] ]
 ; CHECK-NEXT:    [[SPLIT_SPLIT:%.*]] = icmp slt i8 [[IV_SPLIT]], 10
 ; CHECK-NEXT:    br i1 false, label %[[THEN_SPLIT:.*]], label %[[ELSE_SPLIT:.*]]



More information about the llvm-commits mailing list