[llvm-branch-commits] [llvm] 59560e8 - [SimplifyCFG] FoldBranchToCommonDest(): temporairly put back restrictions on liveout uses of bonus instructions (PR48450)
Roman Lebedev via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Mon Dec 14 09:19:51 PST 2020
Author: Roman Lebedev
Date: 2020-12-14T20:14:31+03:00
New Revision: 59560e85897afc50090b6c3d920bacfd28b49d06
URL: https://github.com/llvm/llvm-project/commit/59560e85897afc50090b6c3d920bacfd28b49d06
DIFF: https://github.com/llvm/llvm-project/commit/59560e85897afc50090b6c3d920bacfd28b49d06.diff
LOG: [SimplifyCFG] FoldBranchToCommonDest(): temporairly put back restrictions on liveout uses of bonus instructions (PR48450)
Even though d38205144febf4dc42c9270c6aa3d978f1ef65e1 was mostly a correct
fix for the external non-PHI users, it's not a *generally* correct fix,
because the 'placeholder' values in those trivial PHI's we create
shouldn't be *always* 'undef', but the PHI itself for the backedges,
else we end up with wrong value, as the `@pr48450_2` test shows.
But we can't just do that, because we can't check that the PHI
can be it's own incoming value when coming from certain predecessor,
because we don't have a dominator tree.
So until we can address this correctness problem properly,
ensure that we don't perform the transformation
if there are such problematic external uses.
Making dominator tree available there is going to be involved,
since `-simplifycfg` pass currently does not preserve/update domtree...
Added:
Modified:
llvm/lib/Transforms/Utils/SimplifyCFG.cpp
llvm/test/Transforms/LoopUnroll/peel-loop-inner.ll
llvm/test/Transforms/SimplifyCFG/fold-branch-to-common-dest.ll
Removed:
################################################################################
diff --git a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
index 8f0ed2c46207..691f59f0704d 100644
--- a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
+++ b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
@@ -2710,66 +2710,6 @@ static bool extractPredSuccWeights(BranchInst *PBI, BranchInst *BI,
}
}
-/// Given \p BB block, for each instruction in said block, insert trivial
-/// (single value) PHI nodes into each successor block of \p BB block, and
-/// rewrite all the the non-PHI (or PHI uses not in successors of \p BB block)
-/// uses of instructions of \p BB block to use newly-inserted PHI nodes.
-/// NOTE: even though it would be correct to not deal with multi-predecessor
-/// successor blocks, or uses within the \p BB block, we may be dealing
-/// with an unreachable IR, where many invariants don't hold...
-static void FormTrivialSSAPHI(BasicBlock *BB) {
- SmallSetVector<BasicBlock *, 16> Successors(succ_begin(BB), succ_end(BB));
-
- // Process instructions in reverse order. There is no correctness reason for
- // that order, but it allows us to consistently insert new PHI nodes
- // at the top of blocks, while maintaining their relative order.
- for (Instruction &DefInstr : make_range(BB->rbegin(), BB->rend())) {
- SmallVector<std::reference_wrapper<Use>, 16> UsesToRewrite;
-
- // Cache which uses we'll want to rewrite.
- copy_if(DefInstr.uses(), std::back_inserter(UsesToRewrite),
- [BB, &DefInstr, &Successors](Use &U) {
- auto *User = cast<Instruction>(U.getUser());
- auto *UserBB = User->getParent();
- // Generally, ignore users in the same block as the instruction
- // itself, unless the use[r] either comes before, or is [by] the
- // instruction itself, which means we are in an unreachable IR.
- if (UserBB == BB)
- return !DefInstr.comesBefore(User);
- // Otherwise, rewrite all non-PHI users,
- // or PHI users in non-successor blocks.
- return !isa<PHINode>(User) || !Successors.contains(UserBB);
- });
-
- // So, do we have uses to rewrite?
- if (UsesToRewrite.empty())
- continue; // Check next remaining instruction.
-
- SSAUpdater SSAUpdate;
- SSAUpdate.Initialize(DefInstr.getType(), DefInstr.getName());
-
- // Create a new PHI node in each successor block.
- // WARNING: the iteration order is externally-observable,
- // and therefore must be stable!
- for (BasicBlock *Successor : Successors) {
- IRBuilder<> Builder(&Successor->front());
- auto *PN = Builder.CreatePHI(DefInstr.getType(), pred_size(Successor),
- DefInstr.getName());
- // By default, have an 'undef' incoming value for each predecessor.
- for (BasicBlock *PredsOfSucc : predecessors(Successor))
- PN->addIncoming(UndefValue::get(DefInstr.getType()), PredsOfSucc);
- // .. but receive the correct value when coming from the right block.
- PN->setIncomingValueForBlock(BB, &DefInstr);
- // And make note of that PHI.
- SSAUpdate.AddAvailableValue(Successor, PN);
- }
-
- // And finally, rewrite all the problematic uses to use the new PHI nodes.
- while (!UsesToRewrite.empty())
- SSAUpdate.RewriteUseAfterInsertions(UsesToRewrite.pop_back_val());
- }
-}
-
/// If this basic block is simple enough, and if a predecessor branches to us
/// and one of our successors, fold the block into the predecessor and use
/// logical operations to pick the right destination.
@@ -2853,6 +2793,22 @@ bool llvm::FoldBranchToCommonDest(BranchInst *BI, MemorySSAUpdater *MSSAU,
return Changed;
}
+ // Also, for now, all liveout uses of bonus instructions must be in PHI nodes
+ // in successor blocks as incoming values from the bonus instructions's block,
+ // otherwise we'll fail to update them.
+ // FIXME: We could lift this restriction, but we need to form PHI nodes and
+ // rewrite offending uses, but we can't do that without having a domtree.
+ if (any_of(*BB, [BB](Instruction &I) {
+ return any_of(I.uses(), [BB](Use &U) {
+ auto *User = cast<Instruction>(U.getUser());
+ if (User->getParent() == BB)
+ return false; // Not an external use.
+ auto *PN = dyn_cast<PHINode>(User);
+ return !PN || PN->getIncomingBlock(U) != BB;
+ });
+ }))
+ return Changed;
+
// Cond is known to be a compare or binary operator. Check to make sure that
// neither operand is a potentially-trapping constant expression.
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Cond->getOperand(0)))
@@ -2939,11 +2895,6 @@ bool llvm::FoldBranchToCommonDest(BranchInst *BI, MemorySSAUpdater *MSSAU,
PBI->swapSuccessors();
}
- // Ensure that the bonus instructions are *only* used by the PHI nodes,
- // because the successor basic block is about to get a new predecessor
- // and non-PHI uses will become invalid.
- FormTrivialSSAPHI(BB);
-
BasicBlock *UniqueSucc =
BI->isConditional()
? (PBI->getSuccessor(0) == BB ? TrueDest : FalseDest)
@@ -2988,15 +2939,33 @@ bool llvm::FoldBranchToCommonDest(BranchInst *BI, MemorySSAUpdater *MSSAU,
PredBlock->getInstList().insert(PBI->getIterator(), NewBonusInst);
NewBonusInst->takeName(&BonusInst);
BonusInst.setName(BonusInst.getName() + ".old");
- BonusInst.replaceUsesWithIf(NewBonusInst, [BB](Use &U) {
- auto *User = cast<Instruction>(U.getUser());
- // Ignore the original bonus instructions themselves.
- if (User->getParent() == BB)
- return false;
- // Otherwise, we've got a PHI node. Don't touch incoming values
- // for same block as the bonus instruction itself.
- return cast<PHINode>(User)->getIncomingBlock(U) != BB;
- });
+ BonusInst.replaceUsesWithIf(
+ NewBonusInst, [BB, BI, UniqueSucc, PredBlock](Use &U) {
+ auto *User = cast<Instruction>(U.getUser());
+ // Ignore non-external uses of bonus instructions.
+ if (User->getParent() == BB) {
+ assert(!isa<PHINode>(User) &&
+ "Non-external users are never PHI instructions.");
+ return false;
+ }
+ (void)BI;
+ assert(isa<PHINode>(User) && "All external users must be PHI's.");
+ auto *PN = cast<PHINode>(User);
+ assert(is_contained(successors(BB), User->getParent()) &&
+ "All external users must be in successors of BB.");
+ assert((PN->getIncomingBlock(U) == BB ||
+ PN->getIncomingBlock(U) == PredBlock) &&
+ "The incoming block for that incoming value external use "
+ "must be either the original block with bonus instructions, "
+ "or the new predecessor block.");
+ // UniqueSucc is the block for which we change it's predecessors,
+ // so it is the only block in which we'll need to update PHI nodes.
+ if (User->getParent() != UniqueSucc)
+ return false;
+ // Update the incoming value for the new predecessor.
+ return PN->getIncomingBlock(U) ==
+ (BI->isConditional() ? PredBlock : BB);
+ });
}
// Now that the Cond was cloned into the predecessor basic block,
diff --git a/llvm/test/Transforms/LoopUnroll/peel-loop-inner.ll b/llvm/test/Transforms/LoopUnroll/peel-loop-inner.ll
index 8d89053c96f1..b294558f1d47 100644
--- a/llvm/test/Transforms/LoopUnroll/peel-loop-inner.ll
+++ b/llvm/test/Transforms/LoopUnroll/peel-loop-inner.ll
@@ -7,10 +7,13 @@ define void @basic(i32 %K, i32 %N) {
; CHECK-NEXT: br label [[OUTER:%.*]]
; CHECK: outer:
; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[I_INC:%.*]], [[OUTER_BACKEDGE:%.*]] ]
-; CHECK-NEXT: [[CMP_INNER_PEEL8:%.*]] = icmp sgt i32 [[K:%.*]], 3
+; CHECK-NEXT: [[CMP_INNER_PEEL:%.*]] = icmp sgt i32 [[K:%.*]], 1
+; CHECK-NEXT: br i1 [[CMP_INNER_PEEL]], label [[INNER_PEEL2:%.*]], label [[OUTER_BACKEDGE]]
+; CHECK: inner.peel2:
+; CHECK-NEXT: [[CMP_INNER_PEEL8:%.*]] = icmp sgt i32 [[K]], 3
; CHECK-NEXT: br i1 [[CMP_INNER_PEEL8]], label [[INNER:%.*]], label [[OUTER_BACKEDGE]]
; CHECK: inner:
-; CHECK-NEXT: [[J:%.*]] = phi i32 [ [[J_INC:%.*]], [[INNER]] ], [ 3, [[OUTER]] ]
+; CHECK-NEXT: [[J:%.*]] = phi i32 [ [[J_INC:%.*]], [[INNER]] ], [ 3, [[INNER_PEEL2]] ]
; CHECK-NEXT: [[J_INC]] = add nuw nsw i32 [[J]], 1
; CHECK-NEXT: [[CMP_INNER:%.*]] = icmp slt i32 [[J_INC]], [[K]]
; CHECK-NEXT: br i1 [[CMP_INNER]], label [[INNER]], label [[OUTER_BACKEDGE]], [[LOOP0:!llvm.loop !.*]]
diff --git a/llvm/test/Transforms/SimplifyCFG/fold-branch-to-common-dest.ll b/llvm/test/Transforms/SimplifyCFG/fold-branch-to-common-dest.ll
index 557f47ee4dcf..549c4d884d14 100644
--- a/llvm/test/Transforms/SimplifyCFG/fold-branch-to-common-dest.ll
+++ b/llvm/test/Transforms/SimplifyCFG/fold-branch-to-common-dest.ll
@@ -245,10 +245,11 @@ define void @one_pred_with_extra_op_liveout(i8 %v0, i8 %v1) {
; CHECK-LABEL: @one_pred_with_extra_op_liveout(
; CHECK-NEXT: pred:
; CHECK-NEXT: [[C0:%.*]] = icmp eq i8 [[V0:%.*]], 0
+; CHECK-NEXT: br i1 [[C0]], label [[DISPATCH:%.*]], label [[FINAL_RIGHT:%.*]]
+; CHECK: dispatch:
; CHECK-NEXT: [[V1_ADJ:%.*]] = add i8 [[V0]], [[V1:%.*]]
; CHECK-NEXT: [[C1:%.*]] = icmp eq i8 [[V1_ADJ]], 0
-; CHECK-NEXT: [[OR_COND:%.*]] = and i1 [[C0]], [[C1]]
-; CHECK-NEXT: br i1 [[OR_COND]], label [[FINAL_LEFT:%.*]], label [[FINAL_RIGHT:%.*]]
+; CHECK-NEXT: br i1 [[C1]], label [[FINAL_LEFT:%.*]], label [[FINAL_RIGHT]]
; CHECK: final_left:
; CHECK-NEXT: call void @sideeffect0()
; CHECK-NEXT: call void @use8(i8 [[V1_ADJ]])
@@ -276,10 +277,11 @@ define void @one_pred_with_extra_op_liveout_multiuse(i8 %v0, i8 %v1) {
; CHECK-LABEL: @one_pred_with_extra_op_liveout_multiuse(
; CHECK-NEXT: pred:
; CHECK-NEXT: [[C0:%.*]] = icmp eq i8 [[V0:%.*]], 0
+; CHECK-NEXT: br i1 [[C0]], label [[DISPATCH:%.*]], label [[FINAL_RIGHT:%.*]]
+; CHECK: dispatch:
; CHECK-NEXT: [[V1_ADJ:%.*]] = add i8 [[V0]], [[V1:%.*]]
; CHECK-NEXT: [[C1:%.*]] = icmp eq i8 [[V1_ADJ]], 0
-; CHECK-NEXT: [[OR_COND:%.*]] = and i1 [[C0]], [[C1]]
-; CHECK-NEXT: br i1 [[OR_COND]], label [[FINAL_LEFT:%.*]], label [[FINAL_RIGHT:%.*]]
+; CHECK-NEXT: br i1 [[C1]], label [[FINAL_LEFT:%.*]], label [[FINAL_RIGHT]]
; CHECK: final_left:
; CHECK-NEXT: call void @sideeffect0()
; CHECK-NEXT: call void @use8(i8 [[V1_ADJ]])
@@ -313,10 +315,11 @@ define void @one_pred_with_extra_op_liveout_distant_phi(i8 %v0, i8 %v1) {
; CHECK-NEXT: br i1 [[C0]], label [[PRED:%.*]], label [[LEFT_END:%.*]]
; CHECK: pred:
; CHECK-NEXT: [[C1:%.*]] = icmp eq i8 [[V1:%.*]], 0
+; CHECK-NEXT: br i1 [[C1]], label [[DISPATCH:%.*]], label [[FINAL_RIGHT:%.*]]
+; CHECK: dispatch:
; CHECK-NEXT: [[V2_ADJ:%.*]] = add i8 [[V0]], [[V1]]
; CHECK-NEXT: [[C2:%.*]] = icmp eq i8 [[V2_ADJ]], 0
-; CHECK-NEXT: [[OR_COND:%.*]] = and i1 [[C1]], [[C2]]
-; CHECK-NEXT: br i1 [[OR_COND]], label [[FINAL_LEFT:%.*]], label [[FINAL_RIGHT:%.*]]
+; CHECK-NEXT: br i1 [[C2]], label [[FINAL_LEFT:%.*]], label [[FINAL_RIGHT]]
; CHECK: final_left:
; CHECK-NEXT: call void @sideeffect0()
; CHECK-NEXT: call void @use8(i8 [[V2_ADJ]])
@@ -465,10 +468,11 @@ define void @one_pred_with_extra_op_eexternally_used_only(i8 %v0, i8 %v1) {
; CHECK-LABEL: @one_pred_with_extra_op_eexternally_used_only(
; CHECK-NEXT: pred:
; CHECK-NEXT: [[C0:%.*]] = icmp eq i8 [[V0:%.*]], 0
+; CHECK-NEXT: br i1 [[C0]], label [[DISPATCH:%.*]], label [[FINAL_RIGHT:%.*]]
+; CHECK: dispatch:
; CHECK-NEXT: [[V1_ADJ:%.*]] = add i8 [[V0]], [[V1:%.*]]
; CHECK-NEXT: [[C1:%.*]] = icmp eq i8 [[V1]], 0
-; CHECK-NEXT: [[OR_COND:%.*]] = and i1 [[C0]], [[C1]]
-; CHECK-NEXT: br i1 [[OR_COND]], label [[FINAL_LEFT:%.*]], label [[FINAL_RIGHT:%.*]]
+; CHECK-NEXT: br i1 [[C1]], label [[FINAL_LEFT:%.*]], label [[FINAL_RIGHT]]
; CHECK: final_left:
; CHECK-NEXT: call void @sideeffect0()
; CHECK-NEXT: call void @use8(i8 [[V1_ADJ]])
@@ -496,10 +500,11 @@ define void @one_pred_with_extra_op_externally_used_only_multiuse(i8 %v0, i8 %v1
; CHECK-LABEL: @one_pred_with_extra_op_externally_used_only_multiuse(
; CHECK-NEXT: pred:
; CHECK-NEXT: [[C0:%.*]] = icmp eq i8 [[V0:%.*]], 0
+; CHECK-NEXT: br i1 [[C0]], label [[DISPATCH:%.*]], label [[FINAL_RIGHT:%.*]]
+; CHECK: dispatch:
; CHECK-NEXT: [[V1_ADJ:%.*]] = add i8 [[V0]], [[V1:%.*]]
; CHECK-NEXT: [[C1:%.*]] = icmp eq i8 [[V1]], 0
-; CHECK-NEXT: [[OR_COND:%.*]] = and i1 [[C0]], [[C1]]
-; CHECK-NEXT: br i1 [[OR_COND]], label [[FINAL_LEFT:%.*]], label [[FINAL_RIGHT:%.*]]
+; CHECK-NEXT: br i1 [[C1]], label [[FINAL_LEFT:%.*]], label [[FINAL_RIGHT]]
; CHECK: final_left:
; CHECK-NEXT: call void @sideeffect0()
; CHECK-NEXT: call void @use8(i8 [[V1_ADJ]])
@@ -638,10 +643,11 @@ define void @one_pred_with_extra_op_externally_used_only_after_cond_distant_phi(
; CHECK-NEXT: br i1 [[C0]], label [[PRED:%.*]], label [[LEFT_END:%.*]]
; CHECK: pred:
; CHECK-NEXT: [[C1:%.*]] = icmp eq i8 [[V1:%.*]], 0
+; CHECK-NEXT: br i1 [[C1]], label [[DISPATCH:%.*]], label [[FINAL_RIGHT:%.*]]
+; CHECK: dispatch:
; CHECK-NEXT: [[C3:%.*]] = icmp eq i8 [[V3:%.*]], 0
; CHECK-NEXT: [[V2_ADJ:%.*]] = add i8 [[V4:%.*]], [[V5:%.*]]
-; CHECK-NEXT: [[OR_COND:%.*]] = and i1 [[C1]], [[C3]]
-; CHECK-NEXT: br i1 [[OR_COND]], label [[FINAL_LEFT:%.*]], label [[FINAL_RIGHT:%.*]]
+; CHECK-NEXT: br i1 [[C3]], label [[FINAL_LEFT:%.*]], label [[FINAL_RIGHT]]
; CHECK: final_left:
; CHECK-NEXT: call void @sideeffect0()
; CHECK-NEXT: call void @use8(i8 [[V2_ADJ]])
@@ -733,26 +739,20 @@ define void @pr48450() {
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FOR_BODY:%.*]]
; CHECK: for.body:
-; CHECK-NEXT: [[COUNTDOWN:%.*]] = phi i16 [ 128, [[ENTRY:%.*]] ], [ [[DEC2:%.*]], [[FOR_BODYTHREAD_PRE_SPLIT:%.*]] ]
+; CHECK-NEXT: [[COUNTDOWN:%.*]] = phi i16 [ 128, [[ENTRY:%.*]] ], [ [[DEC:%.*]], [[FOR_BODYTHREAD_PRE_SPLIT:%.*]] ]
; CHECK-NEXT: [[C:%.*]] = call i1 @gen1()
; CHECK-NEXT: br i1 [[C]], label [[FOR_INC:%.*]], label [[IF_THEN:%.*]]
; CHECK: for.inc:
-; CHECK-NEXT: [[DOTOLD:%.*]] = add i16 [[COUNTDOWN]], -1
-; CHECK-NEXT: [[DOTOLD3:%.*]] = icmp eq i16 [[COUNTDOWN]], 0
-; CHECK-NEXT: br i1 [[DOTOLD3]], label [[IF_END_LOOPEXIT:%.*]], label [[FOR_BODYTHREAD_PRE_SPLIT]]
+; CHECK-NEXT: [[DEC]] = add i16 [[COUNTDOWN]], -1
+; CHECK-NEXT: [[CMP_NOT:%.*]] = icmp eq i16 [[COUNTDOWN]], 0
+; CHECK-NEXT: br i1 [[CMP_NOT]], label [[IF_END_LOOPEXIT:%.*]], label [[FOR_BODYTHREAD_PRE_SPLIT]]
; CHECK: if.then:
; CHECK-NEXT: [[C2:%.*]] = call i1 @gen1()
-; CHECK-NEXT: [[C2_NOT:%.*]] = xor i1 [[C2]], true
-; CHECK-NEXT: [[DEC:%.*]] = add i16 [[COUNTDOWN]], -1
-; CHECK-NEXT: [[CMP_NOT:%.*]] = icmp eq i16 [[COUNTDOWN]], 0
-; CHECK-NEXT: [[OR_COND:%.*]] = or i1 [[C2_NOT]], [[CMP_NOT]]
-; CHECK-NEXT: br i1 [[OR_COND]], label [[IF_END_LOOPEXIT]], label [[FOR_BODYTHREAD_PRE_SPLIT]]
+; CHECK-NEXT: br i1 [[C2]], label [[FOR_INC]], label [[IF_END_LOOPEXIT]]
; CHECK: for.bodythread-pre-split:
-; CHECK-NEXT: [[DEC2]] = phi i16 [ [[DOTOLD]], [[FOR_INC]] ], [ [[DEC]], [[IF_THEN]] ]
; CHECK-NEXT: call void @sideeffect0()
; CHECK-NEXT: br label [[FOR_BODY]]
; CHECK: if.end.loopexit:
-; CHECK-NEXT: [[DEC1:%.*]] = phi i16 [ undef, [[IF_THEN]] ], [ [[DOTOLD]], [[FOR_INC]] ]
; CHECK-NEXT: ret void
;
entry:
@@ -785,23 +785,18 @@ define void @pr48450_2(i1 %enable_loopback) {
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FOR_BODY:%.*]]
; CHECK: for.body:
-; CHECK-NEXT: [[COUNTDOWN:%.*]] = phi i16 [ 128, [[ENTRY:%.*]] ], [ [[DEC2:%.*]], [[FOR_BODYTHREAD_PRE_SPLIT:%.*]] ]
+; CHECK-NEXT: [[COUNTDOWN:%.*]] = phi i16 [ 128, [[ENTRY:%.*]] ], [ [[DEC:%.*]], [[FOR_BODYTHREAD_PRE_SPLIT:%.*]] ]
; CHECK-NEXT: [[C:%.*]] = call i1 @gen1()
; CHECK-NEXT: br i1 [[C]], label [[FOR_INC:%.*]], label [[IF_THEN:%.*]]
; CHECK: for.inc:
-; CHECK-NEXT: [[DOTOLD:%.*]] = add i16 [[COUNTDOWN]], -1
-; CHECK-NEXT: [[DOTOLD3:%.*]] = icmp eq i16 [[COUNTDOWN]], 0
-; CHECK-NEXT: br i1 [[DOTOLD3]], label [[IF_END_LOOPEXIT:%.*]], label [[FOR_BODYTHREAD_PRE_SPLIT]]
+; CHECK-NEXT: [[DEC]] = add i16 [[COUNTDOWN]], -1
+; CHECK-NEXT: [[CMP_NOT:%.*]] = icmp eq i16 [[COUNTDOWN]], 0
+; CHECK-NEXT: br i1 [[CMP_NOT]], label [[IF_END_LOOPEXIT:%.*]], label [[FOR_BODYTHREAD_PRE_SPLIT]]
; CHECK: if.then:
; CHECK-NEXT: [[C2:%.*]] = call i1 @gen1()
-; CHECK-NEXT: [[C2_NOT:%.*]] = xor i1 [[C2]], true
-; CHECK-NEXT: [[DEC:%.*]] = add i16 [[COUNTDOWN]], -1
-; CHECK-NEXT: [[CMP_NOT:%.*]] = icmp eq i16 [[COUNTDOWN]], 0
-; CHECK-NEXT: [[OR_COND:%.*]] = or i1 [[C2_NOT]], [[CMP_NOT]]
-; CHECK-NEXT: br i1 [[OR_COND]], label [[IF_END_LOOPEXIT]], label [[FOR_BODYTHREAD_PRE_SPLIT]]
+; CHECK-NEXT: br i1 [[C2]], label [[FOR_INC]], label [[IF_END_LOOPEXIT]]
; CHECK: for.bodythread-pre-split:
-; CHECK-NEXT: [[DEC2]] = phi i16 [ undef, [[FOR_BODYTHREAD_PRE_SPLIT_LOOPBACK:%.*]] ], [ [[DOTOLD]], [[FOR_INC]] ], [ [[DEC]], [[IF_THEN]] ]
-; CHECK-NEXT: [[SHOULD_LOOPBACK:%.*]] = phi i1 [ true, [[FOR_INC]] ], [ false, [[FOR_BODYTHREAD_PRE_SPLIT_LOOPBACK]] ], [ true, [[IF_THEN]] ]
+; CHECK-NEXT: [[SHOULD_LOOPBACK:%.*]] = phi i1 [ true, [[FOR_INC]] ], [ false, [[FOR_BODYTHREAD_PRE_SPLIT_LOOPBACK:%.*]] ]
; CHECK-NEXT: [[DO_LOOPBACK:%.*]] = and i1 [[SHOULD_LOOPBACK]], [[ENABLE_LOOPBACK:%.*]]
; CHECK-NEXT: call void @sideeffect0()
; CHECK-NEXT: br i1 [[DO_LOOPBACK]], label [[FOR_BODYTHREAD_PRE_SPLIT_LOOPBACK]], label [[FOR_BODY]]
@@ -809,7 +804,6 @@ define void @pr48450_2(i1 %enable_loopback) {
; CHECK-NEXT: call void @sideeffect0()
; CHECK-NEXT: br label [[FOR_BODYTHREAD_PRE_SPLIT]]
; CHECK: if.end.loopexit:
-; CHECK-NEXT: [[DEC1:%.*]] = phi i16 [ undef, [[IF_THEN]] ], [ [[DOTOLD]], [[FOR_INC]] ]
; CHECK-NEXT: ret void
;
entry:
More information about the llvm-branch-commits
mailing list