This is an archive of the discontinued LLVM Phabricator instance.

Differential D143705

[LoopBoundSplit] Delete redundant loop guard
AbandonedPublic

Authored by Allen on Feb 10 2023, 12:37 AM.

Details

Reviewers
jaykang10
mkazantsev
reames
sanwou01
wwei
efriedma
Summary

This changes try to remove the redundant loop guard,

For example, it transforms left code to right code:
```
    newbound = min(n, c)                    newbound = min(n, c)
    while(iv < newbound) {                  while(iv < newbound) {
       A                                      A
       B                                      B
       C                                      C
     }                                      }
     if (iv != n) {
        while (iv < n) {                    while (iv < n) {
           A                                  A
           C                                  C
         }                                  }
     }
```

Depand on D102234

Diff Detail

Event Timeline

Allen created this revision.Feb 10 2023, 12:37 AM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 10 2023, 12:37 AM
Herald added subscribers: StephenFan, hiraditya. · View Herald Transcript
Allen requested review of this revision.Feb 10 2023, 12:37 AM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 10 2023, 12:37 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Allen mentioned this in D102234: [SimpleLoopBoundSplit] Split Bound of Loop which has conditional branch with IV.Feb 10 2023, 12:40 AM
Harbormaster completed remote builds in B212966: Diff 496354.Feb 10 2023, 1:45 AM
mkazantsev added a comment.EditedFeb 12 2023, 10:46 PM

The loops in form that are depicted here are not while (cond) {...} loops. They are do - while loops, and for them what you are doing is wrong.

What you are actually proposing is turn

newbound = min(n, c)
if (iv < newbound) {
  do {
    A
    B
    C
  } while (iv < newbound)
}
if (iv != n) {
  do {
    A
    B
    C
  } while (iv < n)
}

into

newbound = min(n, c)
if (iv < newbound) {
  do {
    A
    B
    C
  } while (iv < newbound)
}
do {
  A
  B
  C
} while (iv < n)

which is wrong when newbound = n.

mkazantsev requested changes to this revision.Feb 12 2023, 11:00 PM

This is wrong when new bound = original bound.

This revision now requires changes to proceed.Feb 12 2023, 11:00 PM
Allen abandoned this revision.Feb 13 2023, 12:41 AM

Thanks @mkazantsev for correcting

Revision Contents

PathSize
llvm/
lib/
Transforms/
Scalar/
55 lines
test/
Transforms/
LoopBoundSplit/
12 lines
21 lines
56 lines

Diff 496354

llvm/lib/Transforms/Scalar/LoopBoundSplit.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
// | if.then.BB | | | // | if.then.BB | | |
// +--------------------+ | | // +--------------------+ | |
// | | | // | | |
// +--------v-----------<---/ | // +--------v-----------<---/ |
// | latch >----------/ // | latch >----------/
// | with newbound | // | with newbound |
// +--------------------+ // +--------------------+
// | // |
// | /----------------\
// +--------v----v------+ |
// | header2 |---\ |
// | conditional branch | | |
// |with false condition| | |
// +--------------------+ | |
// | | |
// +--------v-----------+ | |
// | if.then.BB2 | | |
// +--------------------+ | |
// | | |
// +--------v-----------<---/ |
// | latch2 >----------/
// | with org bound |
// +--------v-----------+
// |
// +--------v-----------+ // +--------v-----------+
// | preheader2 |--------------\ // | exit |
// | if (AddRec i != | | // +--------------------+
// | org bound) | |
// +--------------------+ |
// | /----------------\ |
// +--------v----v------+ | |
// | header2 |---\ | |
// | conditional branch | | | |
// |with false condition| | | |
// +--------------------+ | | |
// | | | |
// +--------v-----------+ | | |
// | if.then.BB2 | | | |
// +--------------------+ | | |
// | | | |
// +--------v-----------<---/ | |
// | latch2 >----------/ |
// | with org bound | |
// +--------v-----------+ |
// | |
// | +---------------+ |
// +--> exit <-------/
// +---------------+
// Let's create post loop. // Let's create post loop.
SmallVector<BasicBlock *, 8> PostLoopBlocks; SmallVector<BasicBlock *, 8> PostLoopBlocks;
Loop *PostLoop; Loop *PostLoop;
ValueToValueMapTy VMap; ValueToValueMapTy VMap;
BasicBlock *PreHeader = L.getLoopPreheader(); BasicBlock *PreHeader = L.getLoopPreheader();
BasicBlock *SplitLoopPH = SplitEdge(PreHeader, L.getHeader(), &DT, &LI); BasicBlock *SplitLoopPH = SplitEdge(PreHeader, L.getHeader(), &DT, &LI);
PostLoop = cloneLoopWithPreheader(L.getExitBlock(), SplitLoopPH, &L, VMap, PostLoop = cloneLoopWithPreheader(L.getExitBlock(), SplitLoopPH, &L, VMap,
Show All 29 Lines
continue; continue;
const SCEVAddRecExpr *PhiSCEV = dyn_cast<SCEVAddRecExpr>(SE.getSCEV(&PN)); const SCEVAddRecExpr *PhiSCEV = dyn_cast<SCEVAddRecExpr>(SE.getSCEV(&PN));
if (PhiSCEV && ExitingCond.NonPHIAddRecValue == if (PhiSCEV && ExitingCond.NonPHIAddRecValue ==
PN.getIncomingValueForBlock(L.getLoopLatch())) PN.getIncomingValueForBlock(L.getLoopLatch()))
ExitingCondLCSSAPhi = LCSSAPhi; ExitingCondLCSSAPhi = LCSSAPhi;
} }
// Add conditional branch to check we can skip post-loop in its preheader.
Instruction *OrigBI = PostLoopPreHeader->getTerminator();
ICmpInst::Predicate Pred = ICmpInst::ICMP_NE;
Value *Cond =
Builder.CreateICmp(Pred, ExitingCondLCSSAPhi, ExitingCond.BoundValue);
Builder.CreateCondBr(Cond, PostLoop->getHeader(), PostLoop->getExitBlock());
OrigBI->eraseFromParent();
// Create new loop bound and add it into preheader of pre-loop. // Create new loop bound and add it into preheader of pre-loop.
const SCEV *NewBoundSCEV = ExitingCond.BoundSCEV; const SCEV *NewBoundSCEV = ExitingCond.BoundSCEV;
const SCEV *SplitBoundSCEV = SplitCandidateCond.BoundSCEV; const SCEV *SplitBoundSCEV = SplitCandidateCond.BoundSCEV;
NewBoundSCEV = ICmpInst::isSigned(ExitingCond.Pred) NewBoundSCEV = ICmpInst::isSigned(ExitingCond.Pred)
? SE.getSMinExpr(NewBoundSCEV, SplitBoundSCEV) ? SE.getSMinExpr(NewBoundSCEV, SplitBoundSCEV)
: SE.getUMinExpr(NewBoundSCEV, SplitBoundSCEV); : SE.getUMinExpr(NewBoundSCEV, SplitBoundSCEV);
SCEVExpander Expander( SCEVExpander Expander(
Show All 31 Lines
// Create LCSSA phi node for incoming value. // Create LCSSA phi node for incoming value.
PHINode *LCSSAPhi = PHINode *LCSSAPhi =
Builder.CreatePHI(PN.getType(), 1, PN.getName() + ".lcssa"); Builder.CreatePHI(PN.getType(), 1, PN.getName() + ".lcssa");
LCSSAPhi->setDebugLoc(PN.getDebugLoc()); LCSSAPhi->setDebugLoc(PN.getDebugLoc());
LCSSAPhi->addIncoming(IncomingValue, PN.getIncomingBlock(i)); LCSSAPhi->addIncoming(IncomingValue, PN.getIncomingBlock(i));
// Replace pre-loop's exiting block by post-loop's preheader. // Replace pre-loop's exiting block by post-loop's preheader.
PN.setIncomingBlock(i, PostLoopPreHeader); PN.setIncomingBlock(i, PostLoop->getExitingBlock());
// Replace incoming value by LCSSAPhi. // Replace incoming value by LCSSAPhi.
PN.setIncomingValue(i, LCSSAPhi); PN.setIncomingValue(i, LCSSAPhi);
// Add a new incoming value with post-loop's exiting block.
PN.addIncoming(VMap[IncomingValue], PostLoop->getExitingBlock());
} }
} }
} }
// Update dominator tree. // Update dominator tree.
DT.changeImmediateDominator(PostLoopPreHeader, L.getExitingBlock()); DT.changeImmediateDominator(PostLoopPreHeader, L.getExitingBlock());
DT.changeImmediateDominator(PostLoop->getExitBlock(), PostLoopPreHeader); DT.changeImmediateDominator(PostLoop->getExitBlock(), PostLoop->getExitingBlock());
// Invalidate cached SE information. // Invalidate cached SE information.
SE.forgetLoop(&L); SE.forgetLoop(&L);
// Canonicalize loops. // Canonicalize loops.
simplifyLoop(&L, &DT, &LI, &SE, nullptr, nullptr, true); simplifyLoop(&L, &DT, &LI, &SE, nullptr, nullptr, true);
simplifyLoop(PostLoop, &DT, &LI, &SE, nullptr, nullptr, true); simplifyLoop(PostLoop, &DT, &LI, &SE, nullptr, nullptr, true);
Show All 25 Lines

llvm/test/Transforms/LoopBoundSplit/bug-loop-bound-split-phi-in-exit-block.ll

Show All 20 Lines
; CHECK: cond.end: ; CHECK: cond.end:
; CHECK-NEXT: [[CALL:%.*]] = call i16 @foo() ; CHECK-NEXT: [[CALL:%.*]] = call i16 @foo()
; CHECK-NEXT: [[ADD]] = add nuw nsw i16 [[I]], 1 ; CHECK-NEXT: [[ADD]] = add nuw nsw i16 [[I]], 1
; CHECK-NEXT: [[CMP2:%.*]] = icmp ult i16 [[I]], 3 ; CHECK-NEXT: [[CMP2:%.*]] = icmp ult i16 [[I]], 3
; CHECK-NEXT: br i1 [[CMP2]], label [[FOR_BODY]], label [[ENTRY_SPLIT_SPLIT:%.*]] ; CHECK-NEXT: br i1 [[CMP2]], label [[FOR_BODY]], label [[ENTRY_SPLIT_SPLIT:%.*]]
; CHECK: entry.split.split: ; CHECK: entry.split.split:
; CHECK-NEXT: [[CALL_LCSSA_LCSSA:%.*]] = phi i16 [ [[CALL]], [[COND_END]] ] ; CHECK-NEXT: [[CALL_LCSSA_LCSSA:%.*]] = phi i16 [ [[CALL]], [[COND_END]] ]
; CHECK-NEXT: [[I_LCSSA:%.*]] = phi i16 [ [[ADD]], [[COND_END]] ] ; CHECK-NEXT: [[I_LCSSA:%.*]] = phi i16 [ [[ADD]], [[COND_END]] ]
; CHECK-NEXT: [[TMP0:%.*]] = icmp ne i16 [[I_LCSSA]], 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:%.*]] ; CHECK-NEXT: br label [[FOR_BODY_SPLIT:%.*]]
; CHECK: for.body.split: ; CHECK: for.body.split:
; CHECK-NEXT: [[I_SPLIT:%.*]] = phi i16 [ [[ADD_SPLIT:%.*]], [[COND_END_SPLIT:%.*]] ], [ [[I_LCSSA]], [[FOR_BODY_SPLIT_PREHEADER]] ] ; CHECK-NEXT: [[I_SPLIT:%.*]] = phi i16 [ [[I_LCSSA]], [[ENTRY_SPLIT_SPLIT]] ], [ [[ADD_SPLIT:%.*]], [[COND_END_SPLIT:%.*]] ]
; CHECK-NEXT: [[CMP1_SPLIT:%.*]] = icmp ult i16 [[I_SPLIT]], 3 ; CHECK-NEXT: [[CMP1_SPLIT:%.*]] = icmp ult i16 [[I_SPLIT]], 3
; CHECK-NEXT: br i1 false, label [[COND_TRUE_SPLIT:%.*]], label [[COND_FALSE_SPLIT:%.*]] ; CHECK-NEXT: br i1 false, label [[COND_TRUE_SPLIT:%.*]], label [[COND_FALSE_SPLIT:%.*]]
; CHECK: cond.false.split: ; CHECK: cond.false.split:
; CHECK-NEXT: br label [[COND_END_SPLIT]] ; CHECK-NEXT: br label [[COND_END_SPLIT]]
; CHECK: cond.true.split: ; CHECK: cond.true.split:
; CHECK-NEXT: br label [[COND_END_SPLIT]] ; CHECK-NEXT: br label [[COND_END_SPLIT]]
; CHECK: cond.end.split: ; CHECK: cond.end.split:
; CHECK-NEXT: [[CALL_SPLIT:%.*]] = call i16 @foo() ; CHECK-NEXT: [[CALL_SPLIT:%.*]] = call i16 @foo()
; CHECK-NEXT: [[ADD_SPLIT]] = add nuw nsw i16 [[I_SPLIT]], 1 ; CHECK-NEXT: [[ADD_SPLIT]] = add nuw nsw i16 [[I_SPLIT]], 1
; CHECK-NEXT: [[CMP2_SPLIT:%.*]] = icmp ult i16 [[I_SPLIT]], 11 ; CHECK-NEXT: [[CMP2_SPLIT:%.*]] = icmp ult i16 [[I_SPLIT]], 11
; CHECK-NEXT: br i1 [[CMP2_SPLIT]], label [[FOR_BODY_SPLIT]], label [[END_LOOPEXIT:%.*]] ; CHECK-NEXT: br i1 [[CMP2_SPLIT]], label [[FOR_BODY_SPLIT]], label [[END:%.*]]
; CHECK: end.loopexit:
; CHECK-NEXT: [[CALL_LCSSA_PH:%.*]] = phi i16 [ [[CALL_SPLIT]], [[COND_END_SPLIT]] ]
; CHECK-NEXT: br label [[END]]
; CHECK: end: ; CHECK: end:
; CHECK-NEXT: [[CALL_LCSSA:%.*]] = phi i16 [ [[CALL_LCSSA_LCSSA]], [[ENTRY_SPLIT_SPLIT]] ], [ [[CALL_LCSSA_PH]], [[END_LOOPEXIT]] ] ; CHECK-NEXT: [[CALL_LCSSA:%.*]] = phi i16 [ [[CALL_LCSSA_LCSSA]], [[COND_END_SPLIT]] ]
; CHECK-NEXT: ret i16 [[CALL_LCSSA]] ; CHECK-NEXT: ret i16 [[CALL_LCSSA]]
; ;
entry: entry:
br label %for.body br label %for.body
for.body: ; preds = %entry, %cond.end for.body: ; preds = %entry, %cond.end
%i = phi i16 [ 0, %entry ], [ %add, %cond.end ] %i = phi i16 [ 0, %entry ], [ %add, %cond.end ]
%cmp1 = icmp ult i16 %i, 3 %cmp1 = icmp ult i16 %i, 3
Show All 19 Lines

llvm/test/Transforms/LoopBoundSplit/bug51866.ll

Show All 30 Lines
; CHECK-NEXT: [[INC_0]] = add nuw nsw i16 [[I_0]], 1 ; CHECK-NEXT: [[INC_0]] = add nuw nsw i16 [[I_0]], 1
; CHECK-NEXT: [[INC_2]] = add nuw nsw i16 [[I_2]], 2 ; CHECK-NEXT: [[INC_2]] = add nuw nsw i16 [[I_2]], 2
; CHECK-NEXT: br label [[FOR_COND]] ; CHECK-NEXT: br label [[FOR_COND]]
; CHECK: entry.split.split: ; CHECK: entry.split.split:
; CHECK-NEXT: [[I_0_LCSSA:%.*]] = phi i16 [ [[I_0]], [[FOR_COND]] ] ; CHECK-NEXT: [[I_0_LCSSA:%.*]] = phi i16 [ [[I_0]], [[FOR_COND]] ]
; CHECK-NEXT: [[I_1_LCSSA:%.*]] = phi i16 [ [[I_1]], [[FOR_COND]] ] ; 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_2_LCSSA:%.*]] = phi i16 [ [[I_2]], [[FOR_COND]] ]
; CHECK-NEXT: [[I_3_LCSSA:%.*]] = phi i16 [ [[I_3]], [[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: br i1 [[TMP1]], label [[FOR_COND_SPLIT_PREHEADER:%.*]], label [[FOR_END:%.*]]
; CHECK: for.cond.split.preheader:
; CHECK-NEXT: br label [[FOR_COND_SPLIT:%.*]] ; CHECK-NEXT: br label [[FOR_COND_SPLIT:%.*]]
; CHECK: for.cond.split: ; CHECK: for.cond.split:
; CHECK-NEXT: [[I_0_SPLIT:%.*]] = phi i16 [ [[INC_0_SPLIT:%.*]], [[FOR_INC_SPLIT:%.*]] ], [ [[I_0_LCSSA]], [[FOR_COND_SPLIT_PREHEADER]] ] ; CHECK-NEXT: [[I_0_SPLIT:%.*]] = phi i16 [ [[I_0_LCSSA]], [[ENTRY_SPLIT_SPLIT]] ], [ [[INC_0_SPLIT:%.*]], [[FOR_INC_SPLIT:%.*]] ]
; CHECK-NEXT: [[I_1_SPLIT:%.*]] = phi i16 [ [[INC_0_SPLIT]], [[FOR_INC_SPLIT]] ], [ [[I_1_LCSSA]], [[FOR_COND_SPLIT_PREHEADER]] ] ; CHECK-NEXT: [[I_1_SPLIT:%.*]] = phi i16 [ [[I_1_LCSSA]], [[ENTRY_SPLIT_SPLIT]] ], [ [[INC_0_SPLIT]], [[FOR_INC_SPLIT]] ]
; CHECK-NEXT: [[I_2_SPLIT:%.*]] = phi i16 [ [[INC_2_SPLIT:%.*]], [[FOR_INC_SPLIT]] ], [ [[I_2_LCSSA]], [[FOR_COND_SPLIT_PREHEADER]] ] ; CHECK-NEXT: [[I_2_SPLIT:%.*]] = phi i16 [ [[I_2_LCSSA]], [[ENTRY_SPLIT_SPLIT]] ], [ [[INC_2_SPLIT:%.*]], [[FOR_INC_SPLIT]] ]
; CHECK-NEXT: [[I_3_SPLIT:%.*]] = phi i16 [ 30, [[FOR_INC_SPLIT]] ], [ [[I_3_LCSSA]], [[FOR_COND_SPLIT_PREHEADER]] ] ; CHECK-NEXT: [[I_3_SPLIT:%.*]] = phi i16 [ [[I_3_LCSSA]], [[ENTRY_SPLIT_SPLIT]] ], [ 30, [[FOR_INC_SPLIT]] ]
; CHECK-NEXT: [[EXITCOND_NOT_SPLIT:%.*]] = icmp eq i16 [[I_0_SPLIT]], 10 ; CHECK-NEXT: [[EXITCOND_NOT_SPLIT:%.*]] = icmp eq i16 [[I_0_SPLIT]], 10
; CHECK-NEXT: br i1 [[EXITCOND_NOT_SPLIT]], label [[FOR_END_LOOPEXIT:%.*]], label [[FOR_BODY_SPLIT:%.*]] ; CHECK-NEXT: br i1 [[EXITCOND_NOT_SPLIT]], label [[FOR_END:%.*]], label [[FOR_BODY_SPLIT:%.*]]
; CHECK: for.body.split: ; CHECK: for.body.split:
; CHECK-NEXT: [[CMP1_SPLIT:%.*]] = icmp ult i16 [[I_0_SPLIT]], 5 ; CHECK-NEXT: [[CMP1_SPLIT:%.*]] = icmp ult i16 [[I_0_SPLIT]], 5
; CHECK-NEXT: [[ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds [10 x i16], ptr @B, i16 0, i16 [[I_0_SPLIT]] ; CHECK-NEXT: [[ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds [10 x i16], ptr @B, i16 0, i16 [[I_0_SPLIT]]
; CHECK-NEXT: [[TMP2:%.*]] = load i16, ptr [[ARRAYIDX_SPLIT]], align 1 ; CHECK-NEXT: [[TMP1:%.*]] = load i16, ptr [[ARRAYIDX_SPLIT]], align 1
; CHECK-NEXT: br i1 false, label [[IF_THEN_SPLIT:%.*]], label [[IF_ELSE_SPLIT:%.*]] ; CHECK-NEXT: br i1 false, label [[IF_THEN_SPLIT:%.*]], label [[IF_ELSE_SPLIT:%.*]]
; CHECK: if.else.split: ; CHECK: if.else.split:
; CHECK-NEXT: call void @bar(i16 [[TMP2]], i16 [[I_3_SPLIT]]) ; CHECK-NEXT: call void @bar(i16 [[TMP1]], i16 [[I_3_SPLIT]])
; CHECK-NEXT: br label [[FOR_INC_SPLIT]] ; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: if.then.split: ; CHECK: if.then.split:
; CHECK-NEXT: call void @foo(i16 [[TMP2]], i16 [[I_3_SPLIT]]) ; CHECK-NEXT: call void @foo(i16 [[TMP1]], i16 [[I_3_SPLIT]])
; CHECK-NEXT: br label [[FOR_INC_SPLIT]] ; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: for.inc.split: ; CHECK: for.inc.split:
; CHECK-NEXT: [[INC_0_SPLIT]] = add nuw nsw i16 [[I_0_SPLIT]], 1 ; CHECK-NEXT: [[INC_0_SPLIT]] = add nuw nsw i16 [[I_0_SPLIT]], 1
; CHECK-NEXT: [[INC_2_SPLIT]] = add nuw nsw i16 [[I_2_SPLIT]], 2 ; CHECK-NEXT: [[INC_2_SPLIT]] = add nuw nsw i16 [[I_2_SPLIT]], 2
; CHECK-NEXT: br label [[FOR_COND_SPLIT]] ; CHECK-NEXT: br label [[FOR_COND_SPLIT]]
; CHECK: for.end.loopexit:
; CHECK-NEXT: br label [[FOR_END]]
; CHECK: for.end: ; CHECK: for.end:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
br label %for.cond br label %for.cond
for.cond: ; preds = %for.inc, %entry for.cond: ; preds = %for.inc, %entry
%i.0 = phi i16 [ 0, %entry ], [ %inc.0, %for.inc ] %i.0 = phi i16 [ 0, %entry ], [ %inc.0, %for.inc ]
Show All 31 Lines

llvm/test/Transforms/LoopBoundSplit/loop-bound-split.ll

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
; CHECK: if.else: ; CHECK: if.else:
; CHECK-NEXT: br label [[FOR_INC]] ; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: for.inc: ; CHECK: for.inc:
; CHECK-NEXT: [[INC]] = add nuw nsw i64 [[IV]], 1 ; CHECK-NEXT: [[INC]] = add nuw nsw i64 [[IV]], 1
; CHECK-NEXT: [[COND:%.*]] = icmp sgt i64 [[INC]], [[NEW_BOUND]] ; CHECK-NEXT: [[COND:%.*]] = icmp sgt i64 [[INC]], [[NEW_BOUND]]
; CHECK-NEXT: br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]] ; CHECK-NEXT: br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]]
; CHECK: loop.ph.split.split: ; CHECK: loop.ph.split.split:
; CHECK-NEXT: [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ] ; CHECK-NEXT: [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
; CHECK-NEXT: [[TMP0:%.*]] = icmp ne 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:%.*]] ; CHECK-NEXT: br label [[LOOP_SPLIT:%.*]]
; CHECK: loop.split: ; CHECK: loop.split:
; CHECK-NEXT: [[IV_SPLIT:%.*]] = phi i64 [ [[INC_SPLIT:%.*]], [[FOR_INC_SPLIT:%.*]] ], [ [[IV_LCSSA]], [[LOOP_SPLIT_PREHEADER]] ] ; CHECK-NEXT: [[IV_SPLIT:%.*]] = phi i64 [ [[INC_SPLIT:%.*]], [[FOR_INC_SPLIT:%.*]] ], [ [[IV_LCSSA]], [[LOOP_PH_SPLIT_SPLIT]] ]
; CHECK-NEXT: [[CMP_SPLIT:%.*]] = icmp ult i64 [[IV_SPLIT]], [[B]] ; CHECK-NEXT: [[CMP_SPLIT:%.*]] = icmp ult i64 [[IV_SPLIT]], [[B]]
; CHECK-NEXT: br i1 false, label [[IF_THEN_SPLIT:%.*]], label [[IF_ELSE_SPLIT:%.*]] ; CHECK-NEXT: br i1 false, label [[IF_THEN_SPLIT:%.*]], label [[IF_ELSE_SPLIT:%.*]]
; CHECK: if.else.split: ; CHECK: if.else.split:
; CHECK-NEXT: br label [[FOR_INC_SPLIT]] ; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: if.then.split: ; CHECK: if.then.split:
; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]] ; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]]
; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4 ; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]] ; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]]
; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4 ; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: br label [[FOR_INC_SPLIT]] ; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: for.inc.split: ; CHECK: for.inc.split:
; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 1 ; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 1
; CHECK-NEXT: [[COND_SPLIT:%.*]] = icmp sgt i64 [[INC_SPLIT]], [[N]] ; CHECK-NEXT: [[COND_SPLIT:%.*]] = icmp sgt i64 [[INC_SPLIT]], [[N]]
; CHECK-NEXT: br i1 [[COND_SPLIT]], label [[EXIT_LOOPEXIT:%.*]], label [[LOOP_SPLIT]] ; CHECK-NEXT: br i1 [[COND_SPLIT]], label [[EXIT:%.*]], label [[LOOP_SPLIT]]
; CHECK: exit.loopexit:
; CHECK-NEXT: br label [[EXIT]]
; CHECK: exit: ; CHECK: exit:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
loop.ph: loop.ph:
%b = call i64 @llvm.umax.i64(i64 %a, i64 1) %b = call i64 @llvm.umax.i64(i64 %a, i64 1)
br label %loop br label %loop
loop: loop:
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
; CHECK: if.else: ; CHECK: if.else:
; CHECK-NEXT: br label [[FOR_INC]] ; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: for.inc: ; CHECK: for.inc:
; CHECK-NEXT: [[INC]] = add nuw nsw i64 [[IV]], 1 ; CHECK-NEXT: [[INC]] = add nuw nsw i64 [[IV]], 1
; CHECK-NEXT: [[COND:%.*]] = icmp sgt i64 [[INC]], [[NEW_BOUND]] ; CHECK-NEXT: [[COND:%.*]] = icmp sgt i64 [[INC]], [[NEW_BOUND]]
; CHECK-NEXT: br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]] ; CHECK-NEXT: br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]]
; CHECK: loop.ph.split.split: ; CHECK: loop.ph.split.split:
; CHECK-NEXT: [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ] ; CHECK-NEXT: [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
; CHECK-NEXT: [[TMP0:%.*]] = icmp ne 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:%.*]] ; CHECK-NEXT: br label [[LOOP_SPLIT:%.*]]
; CHECK: loop.split: ; CHECK: loop.split:
; CHECK-NEXT: [[IV_SPLIT:%.*]] = phi i64 [ [[INC_SPLIT:%.*]], [[FOR_INC_SPLIT:%.*]] ], [ [[IV_LCSSA]], [[LOOP_SPLIT_PREHEADER]] ] ; CHECK-NEXT: [[IV_SPLIT:%.*]] = phi i64 [ [[INC_SPLIT:%.*]], [[FOR_INC_SPLIT:%.*]] ], [ [[IV_LCSSA]], [[LOOP_PH_SPLIT_SPLIT]] ]
; CHECK-NEXT: [[CMP_SPLIT:%.*]] = icmp ult i64 [[IV_SPLIT]], 10 ; CHECK-NEXT: [[CMP_SPLIT:%.*]] = icmp ult i64 [[IV_SPLIT]], 10
; CHECK-NEXT: br i1 false, label [[IF_THEN_SPLIT:%.*]], label [[IF_ELSE_SPLIT:%.*]] ; CHECK-NEXT: br i1 false, label [[IF_THEN_SPLIT:%.*]], label [[IF_ELSE_SPLIT:%.*]]
; CHECK: if.else.split: ; CHECK: if.else.split:
; CHECK-NEXT: br label [[FOR_INC_SPLIT]] ; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: if.then.split: ; CHECK: if.then.split:
; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]] ; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]]
; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4 ; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]] ; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]]
; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4 ; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: br label [[FOR_INC_SPLIT]] ; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: for.inc.split: ; CHECK: for.inc.split:
; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 1 ; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 1
; CHECK-NEXT: [[COND_SPLIT:%.*]] = icmp sgt i64 [[INC_SPLIT]], [[N]] ; CHECK-NEXT: [[COND_SPLIT:%.*]] = icmp sgt i64 [[INC_SPLIT]], [[N]]
; CHECK-NEXT: br i1 [[COND_SPLIT]], label [[EXIT_LOOPEXIT:%.*]], label [[LOOP_SPLIT]] ; CHECK-NEXT: br i1 [[COND_SPLIT]], label [[EXIT:%.*]], label [[LOOP_SPLIT]]
; CHECK: exit.loopexit:
; CHECK-NEXT: br label [[EXIT]]
; CHECK: exit: ; CHECK: exit:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
loop.ph: loop.ph:
br label %loop br label %loop
loop: loop:
%iv = phi i64 [ %inc, %for.inc ], [ 0, %loop.ph ] %iv = phi i64 [ %inc, %for.inc ], [ 0, %loop.ph ]
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines
; CHECK: if.else: ; CHECK: if.else:
; CHECK-NEXT: br label [[FOR_INC]] ; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: for.inc: ; CHECK: for.inc:
; CHECK-NEXT: [[INC]] = add nuw nsw i64 [[IV]], 1 ; CHECK-NEXT: [[INC]] = add nuw nsw i64 [[IV]], 1
; CHECK-NEXT: [[COND:%.*]] = icmp eq i64 [[INC]], [[NEW_BOUND]] ; CHECK-NEXT: [[COND:%.*]] = icmp eq i64 [[INC]], [[NEW_BOUND]]
; CHECK-NEXT: br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]] ; CHECK-NEXT: br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]]
; CHECK: loop.ph.split.split: ; CHECK: loop.ph.split.split:
; CHECK-NEXT: [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ] ; CHECK-NEXT: [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
; 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:%.*]] ; CHECK-NEXT: br label [[LOOP_SPLIT:%.*]]
; CHECK: loop.split: ; CHECK: loop.split:
; CHECK-NEXT: [[IV_SPLIT:%.*]] = phi i64 [ [[INC_SPLIT:%.*]], [[FOR_INC_SPLIT:%.*]] ], [ [[IV_LCSSA]], [[LOOP_SPLIT_PREHEADER]] ] ; CHECK-NEXT: [[IV_SPLIT:%.*]] = phi i64 [ [[INC_SPLIT:%.*]], [[FOR_INC_SPLIT:%.*]] ], [ [[IV_LCSSA]], [[LOOP_PH_SPLIT_SPLIT]] ]
; CHECK-NEXT: [[CMP_SPLIT:%.*]] = icmp ult i64 [[IV_SPLIT]], 10 ; CHECK-NEXT: [[CMP_SPLIT:%.*]] = icmp ult i64 [[IV_SPLIT]], 10
; CHECK-NEXT: br i1 false, label [[IF_THEN_SPLIT:%.*]], label [[IF_ELSE_SPLIT:%.*]] ; CHECK-NEXT: br i1 false, label [[IF_THEN_SPLIT:%.*]], label [[IF_ELSE_SPLIT:%.*]]
; CHECK: if.else.split: ; CHECK: if.else.split:
; CHECK-NEXT: br label [[FOR_INC_SPLIT]] ; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: if.then.split: ; CHECK: if.then.split:
; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]] ; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]]
; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4 ; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]] ; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]]
; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4 ; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: br label [[FOR_INC_SPLIT]] ; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: for.inc.split: ; CHECK: for.inc.split:
; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 1 ; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 1
; CHECK-NEXT: [[COND_SPLIT:%.*]] = icmp eq i64 [[INC_SPLIT]], [[N]] ; CHECK-NEXT: [[COND_SPLIT:%.*]] = icmp eq i64 [[INC_SPLIT]], [[N]]
; CHECK-NEXT: br i1 [[COND_SPLIT]], label [[EXIT_LOOPEXIT:%.*]], label [[LOOP_SPLIT]] ; CHECK-NEXT: br i1 [[COND_SPLIT]], label [[EXIT:%.*]], label [[LOOP_SPLIT]]
; CHECK: exit.loopexit:
; CHECK-NEXT: br label [[EXIT]]
; CHECK: exit: ; CHECK: exit:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
loop.ph: loop.ph:
br label %loop br label %loop
loop: loop:
%iv = phi i64 [ %inc, %for.inc ], [ 0, %loop.ph ] %iv = phi i64 [ %inc, %for.inc ], [ 0, %loop.ph ]
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
; CHECK: if.else: ; CHECK: if.else:
; CHECK-NEXT: br label [[FOR_INC]] ; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: for.inc: ; CHECK: for.inc:
; CHECK-NEXT: [[INC]] = add nuw nsw i64 [[IV]], 1 ; CHECK-NEXT: [[INC]] = add nuw nsw i64 [[IV]], 1
; CHECK-NEXT: [[COND:%.*]] = icmp sge i64 [[INC]], [[NEW_BOUND]] ; CHECK-NEXT: [[COND:%.*]] = icmp sge i64 [[INC]], [[NEW_BOUND]]
; CHECK-NEXT: br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]] ; CHECK-NEXT: br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]]
; CHECK: loop.ph.split.split: ; CHECK: loop.ph.split.split:
; CHECK-NEXT: [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ] ; CHECK-NEXT: [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
; 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:%.*]] ; CHECK-NEXT: br label [[LOOP_SPLIT:%.*]]
; CHECK: loop.split: ; CHECK: loop.split:
; CHECK-NEXT: [[IV_SPLIT:%.*]] = phi i64 [ [[INC_SPLIT:%.*]], [[FOR_INC_SPLIT:%.*]] ], [ [[IV_LCSSA]], [[LOOP_SPLIT_PREHEADER]] ] ; CHECK-NEXT: [[IV_SPLIT:%.*]] = phi i64 [ [[INC_SPLIT:%.*]], [[FOR_INC_SPLIT:%.*]] ], [ [[IV_LCSSA]], [[LOOP_PH_SPLIT_SPLIT]] ]
; CHECK-NEXT: [[CMP_SPLIT:%.*]] = icmp ult i64 [[IV_SPLIT]], 10 ; CHECK-NEXT: [[CMP_SPLIT:%.*]] = icmp ult i64 [[IV_SPLIT]], 10
; CHECK-NEXT: br i1 false, label [[IF_THEN_SPLIT:%.*]], label [[IF_ELSE_SPLIT:%.*]] ; CHECK-NEXT: br i1 false, label [[IF_THEN_SPLIT:%.*]], label [[IF_ELSE_SPLIT:%.*]]
; CHECK: if.else.split: ; CHECK: if.else.split:
; CHECK-NEXT: br label [[FOR_INC_SPLIT]] ; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: if.then.split: ; CHECK: if.then.split:
; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]] ; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]]
; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4 ; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]] ; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]]
; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4 ; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: br label [[FOR_INC_SPLIT]] ; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: for.inc.split: ; CHECK: for.inc.split:
; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 1 ; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 1
; CHECK-NEXT: [[COND_SPLIT:%.*]] = icmp sge i64 [[INC_SPLIT]], [[N]] ; CHECK-NEXT: [[COND_SPLIT:%.*]] = icmp sge i64 [[INC_SPLIT]], [[N]]
; CHECK-NEXT: br i1 [[COND_SPLIT]], label [[EXIT_LOOPEXIT:%.*]], label [[LOOP_SPLIT]] ; CHECK-NEXT: br i1 [[COND_SPLIT]], label [[EXIT:%.*]], label [[LOOP_SPLIT]]
; CHECK: exit.loopexit:
; CHECK-NEXT: br label [[EXIT]]
; CHECK: exit: ; CHECK: exit:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
loop.ph: loop.ph:
br label %loop br label %loop
loop: loop:
%iv = phi i64 [ %inc, %for.inc ], [ 0, %loop.ph ] %iv = phi i64 [ %inc, %for.inc ], [ 0, %loop.ph ]
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
; CHECK: if.else: ; CHECK: if.else:
; CHECK-NEXT: br label [[FOR_INC]] ; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: for.inc: ; CHECK: for.inc:
; CHECK-NEXT: [[INC]] = add nuw nsw i64 [[IV]], 2 ; CHECK-NEXT: [[INC]] = add nuw nsw i64 [[IV]], 2
; CHECK-NEXT: [[COND:%.*]] = icmp sgt i64 [[INC]], [[NEW_BOUND]] ; CHECK-NEXT: [[COND:%.*]] = icmp sgt i64 [[INC]], [[NEW_BOUND]]
; CHECK-NEXT: br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]] ; CHECK-NEXT: br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]]
; CHECK: loop.ph.split.split: ; CHECK: loop.ph.split.split:
; CHECK-NEXT: [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ] ; CHECK-NEXT: [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
; 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:%.*]] ; CHECK-NEXT: br label [[LOOP_SPLIT:%.*]]
; CHECK: loop.split: ; CHECK: loop.split:
; CHECK-NEXT: [[IV_SPLIT:%.*]] = phi i64 [ [[INC_SPLIT:%.*]], [[FOR_INC_SPLIT:%.*]] ], [ [[IV_LCSSA]], [[LOOP_SPLIT_PREHEADER]] ] ; CHECK-NEXT: [[IV_SPLIT:%.*]] = phi i64 [ [[INC_SPLIT:%.*]], [[FOR_INC_SPLIT:%.*]] ], [ [[IV_LCSSA]], [[LOOP_PH_SPLIT_SPLIT]] ]
; CHECK-NEXT: [[CMP_SPLIT:%.*]] = icmp ult i64 [[IV_SPLIT]], 10 ; CHECK-NEXT: [[CMP_SPLIT:%.*]] = icmp ult i64 [[IV_SPLIT]], 10
; CHECK-NEXT: br i1 false, label [[IF_THEN_SPLIT:%.*]], label [[IF_ELSE_SPLIT:%.*]] ; CHECK-NEXT: br i1 false, label [[IF_THEN_SPLIT:%.*]], label [[IF_ELSE_SPLIT:%.*]]
; CHECK: if.else.split: ; CHECK: if.else.split:
; CHECK-NEXT: br label [[FOR_INC_SPLIT]] ; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: if.then.split: ; CHECK: if.then.split:
; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]] ; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]]
; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4 ; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]] ; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]]
; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4 ; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: br label [[FOR_INC_SPLIT]] ; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: for.inc.split: ; CHECK: for.inc.split:
; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 2 ; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 2
; CHECK-NEXT: [[COND_SPLIT:%.*]] = icmp sgt i64 [[INC_SPLIT]], [[N]] ; CHECK-NEXT: [[COND_SPLIT:%.*]] = icmp sgt i64 [[INC_SPLIT]], [[N]]
; CHECK-NEXT: br i1 [[COND_SPLIT]], label [[EXIT_LOOPEXIT:%.*]], label [[LOOP_SPLIT]] ; CHECK-NEXT: br i1 [[COND_SPLIT]], label [[EXIT:%.*]], label [[LOOP_SPLIT]]
; CHECK: exit.loopexit:
; CHECK-NEXT: br label [[EXIT]]
; CHECK: exit: ; CHECK: exit:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
loop.ph: loop.ph:
br label %loop br label %loop
loop: loop:
%iv = phi i64 [ %inc, %for.inc ], [ 0, %loop.ph ] %iv = phi i64 [ %inc, %for.inc ], [ 0, %loop.ph ]
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines
; CHECK-NEXT: br label [[FOR_INC]] ; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: for.inc: ; CHECK: for.inc:
; CHECK-NEXT: [[INC]] = add nuw nsw i64 [[IV]], 1 ; CHECK-NEXT: [[INC]] = add nuw nsw i64 [[IV]], 1
; CHECK-NEXT: [[COND:%.*]] = icmp sgt i64 [[INC]], [[NEW_BOUND]] ; CHECK-NEXT: [[COND:%.*]] = icmp sgt i64 [[INC]], [[NEW_BOUND]]
; CHECK-NEXT: br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]] ; CHECK-NEXT: br i1 [[COND]], label [[LOOP_PH_SPLIT_SPLIT:%.*]], label [[LOOP]]
; CHECK: loop.ph.split.split: ; CHECK: loop.ph.split.split:
; CHECK-NEXT: [[IS_NOT_SCEVABLE_PHI_LCSSA:%.*]] = phi double [ 1.000000e+00, [[FOR_INC]] ] ; 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: [[IV_LCSSA:%.*]] = phi i64 [ [[INC]], [[FOR_INC]] ]
; CHECK-NEXT: [[TMP0:%.*]] = icmp ne 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:%.*]] ; CHECK-NEXT: br label [[LOOP_SPLIT:%.*]]
; CHECK: loop.split: ; CHECK: loop.split:
; CHECK-NEXT: [[IS_NOT_SCEVABLE_PHI_SPLIT:%.*]] = phi double [ 1.000000e+00, [[FOR_INC_SPLIT:%.*]] ], [ [[IS_NOT_SCEVABLE_PHI_LCSSA]], [[LOOP_SPLIT_PREHEADER]] ] ; CHECK-NEXT: [[IS_NOT_SCEVABLE_PHI_SPLIT:%.*]] = phi double [ 1.000000e+00, [[FOR_INC_SPLIT:%.*]] ], [ [[IS_NOT_SCEVABLE_PHI_LCSSA]], [[LOOP_PH_SPLIT_SPLIT]] ]
; CHECK-NEXT: [[IV_SPLIT:%.*]] = phi i64 [ [[INC_SPLIT:%.*]], [[FOR_INC_SPLIT]] ], [ [[IV_LCSSA]], [[LOOP_SPLIT_PREHEADER]] ] ; CHECK-NEXT: [[IV_SPLIT:%.*]] = phi i64 [ [[INC_SPLIT:%.*]], [[FOR_INC_SPLIT]] ], [ [[IV_LCSSA]], [[LOOP_PH_SPLIT_SPLIT]] ]
; CHECK-NEXT: [[CMP_SPLIT:%.*]] = icmp ult i64 [[IV_SPLIT]], 10 ; CHECK-NEXT: [[CMP_SPLIT:%.*]] = icmp ult i64 [[IV_SPLIT]], 10
; CHECK-NEXT: br i1 false, label [[IF_THEN_SPLIT:%.*]], label [[IF_ELSE_SPLIT:%.*]] ; CHECK-NEXT: br i1 false, label [[IF_THEN_SPLIT:%.*]], label [[IF_ELSE_SPLIT:%.*]]
; CHECK: if.else.split: ; CHECK: if.else.split:
; CHECK-NEXT: br label [[FOR_INC_SPLIT]] ; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: if.then.split: ; CHECK: if.then.split:
; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]] ; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]]
; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4 ; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]] ; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]]
; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4 ; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: br label [[FOR_INC_SPLIT]] ; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: for.inc.split: ; CHECK: for.inc.split:
; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 1 ; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 1
; CHECK-NEXT: [[COND_SPLIT:%.*]] = icmp sgt i64 [[INC_SPLIT]], [[N]] ; CHECK-NEXT: [[COND_SPLIT:%.*]] = icmp sgt i64 [[INC_SPLIT]], [[N]]
; CHECK-NEXT: br i1 [[COND_SPLIT]], label [[EXIT_LOOPEXIT:%.*]], label [[LOOP_SPLIT]] ; CHECK-NEXT: br i1 [[COND_SPLIT]], label [[EXIT:%.*]], label [[LOOP_SPLIT]]
; CHECK: exit.loopexit:
; CHECK-NEXT: br label [[EXIT]]
; CHECK: exit: ; CHECK: exit:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
loop.ph: loop.ph:
br label %loop br label %loop
loop: loop:
%is_not_scevable_phi = phi double [ 1.0, %for.inc ], [ 2.0, %loop.ph ] %is_not_scevable_phi = phi double [ 1.0, %for.inc ], [ 2.0, %loop.ph ]
Show All 24 Lines