This is an archive of the discontinued LLVM Phabricator instance.

Differential D102928

[unroll] Use SCEV to evaluate branch conditions in cost model
AbandonedPublic

Authored by reames on May 21 2021, 9:15 AM.

Details

Reviewers
mkazantsev
dalegr
Summary

The current full unroll cost model does a symbolic evaluation of the loop up to a fixed limit. That symbolic evaluation currently simplifies to constants, but I'm planning to extend that to using SimplifyInstruction infrastructure in the near future. This patch uses the simplified operands (at this point constants), and asks SCEV to prove a condition. SCEV can use a mix of induction reasoning, and (most relevantly) dominating branch conditions.

With the constant domain, this is a bit hard to exercise. I mostly split it into it's own patch for ease of review - it becomes more useful once we have symbolic evaluation on the value domain. (Forthcoming.)

Diff Detail

Event Timeline

reames created this revision.May 21 2021, 9:15 AM
Herald added subscribers: javed.absar, zzheng, bollu and 2 others. · View Herald TranscriptMay 21 2021, 9:15 AM
reames requested review of this revision.May 21 2021, 9:15 AM
Herald added a project: Restricted Project. · View Herald TranscriptMay 21 2021, 9:15 AM
Harbormaster completed remote builds in B105654: Diff 347053.May 21 2021, 9:47 AM
reames mentioned this in D102934: [unroll] Use value domain for symbolic execution based cost model.May 21 2021, 10:20 AM
reames updated this revision to Diff 347076.May 21 2021, 10:33 AM

Rebase over D102934 so that it's easier to see why this is useful from the test changes.

reames added a parent revision: D102934: [unroll] Use value domain for symbolic execution based cost model.May 21 2021, 10:33 AM
reames mentioned this in rG317c105c6a44: precommit tests for D102934 and D102928.May 21 2021, 10:59 AM
reames updated this revision to Diff 347085.May 21 2021, 11:05 AM

Rebase over landed tests

Harbormaster completed remote builds in B105676: Diff 347085.May 21 2021, 1:22 PM
mkazantsev added inline comments.May 23 2021, 8:19 PM
llvm/test/Transforms/LoopUnroll/unroll-cost-symbolic-execute.ll
809

I like the change, but the results like this scare me a lot. Is this really what we want to see in code?

mkazantsev added inline comments.May 23 2021, 8:27 PM
llvm/test/Transforms/LoopUnroll/unroll-cost-symbolic-execute.ll
809

Ah, it's dead code... Nvm then.

mkazantsev accepted this revision.May 26 2021, 5:52 AM

LGTM, but mind that maybe we'll have to downgrade isKnownPredicateAt to isKnownPredicate if it harms the CT.

This revision is now accepted and ready to land.May 26 2021, 5:52 AM
reames mentioned this in rG9cc2181ec388: [unroll] Use value domain for symbolic execution based cost model.May 26 2021, 8:41 AM
reames abandoned this revision.Sun, Nov 26, 11:50 AM

Closing stale phabricator review. No longer actively working on this, if someone wants to pick it up, feel free.

Herald added a project: Restricted Project. · View Herald TranscriptSun, Nov 26, 11:50 AM
Herald added a subscriber: StephenFan. · View Herald Transcript

Revision Contents

PathSize
llvm/
lib/
Transforms/
Scalar/
33 lines
test/
Transforms/
LoopUnroll/
326 lines

Diff 347076

llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp

Show First 20 Lines • Show All 574 Lines • ▼ Show 20 Lines for (unsigned Idx = 0; Idx != BBWorklist.size(); ++Idx) {
return dyn_cast<Constant>(V); return dyn_cast<Constant>(V);
}; };
// Add in the live successors by first checking whether we have terminator // Add in the live successors by first checking whether we have terminator
// that may be simplified based on the values simplified by this call. // that may be simplified based on the values simplified by this call.
BasicBlock *KnownSucc = nullptr; BasicBlock *KnownSucc = nullptr;
if (BranchInst *BI = dyn_cast<BranchInst>(TI)) { if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
if (BI->isConditional()) { if (BI->isConditional()) {
if (auto *SimpleCond = getSimplifiedConstant(BI->getCondition())) { auto evaluateCondition = [&](Value *Cond) -> Optional<bool> {
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: invalid case style for variable 'evaluateCondition' [readability-identifier-naming]
not useful

Lint: Pre-merge checks: clang-tidy: warning: invalid case style for variable 'evaluateCondition' [readability…
if (SimplifiedValues.count(Cond))
Cond = SimplifiedValues[Cond];
// Just take the first successor if condition is undef // Just take the first successor if condition is undef
if (isa<UndefValue>(SimpleCond)) if (isa<UndefValue>(Cond))
KnownSucc = BI->getSuccessor(0); return true;
else if (ConstantInt *SimpleCondVal = if (auto *CI = dyn_cast<ConstantInt>(Cond))
dyn_cast<ConstantInt>(SimpleCond)) return !CI->isZero();
KnownSucc = BI->getSuccessor(SimpleCondVal->isZero() ? 1 : 0);
} auto *ICI = dyn_cast<ICmpInst>(Cond);
if (!ICI)
return None;
Value *LHS = ICI->getOperand(0);
if (SimplifiedValues.count(LHS))
LHS = SimplifiedValues[LHS];
Value *RHS = ICI->getOperand(1);
if (SimplifiedValues.count(RHS))
RHS = SimplifiedValues[RHS];
if (!SE.isSCEVable(RHS->getType()))
return None;
return SE.evaluatePredicateAt(ICI->getPredicate(),
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-            return SE.evaluatePredicateAt(ICI->getPredicate(),
-                                          SE.getSCEV(LHS),
+            return SE.evaluatePredicateAt(ICI->getPredicate(), SE.getSCEV(LHS),
Lint: Pre-merge checks: clang-format: please reformat the code ``` - return SE.evaluatePredicateAt(ICI…
SE.getSCEV(LHS),
SE.getSCEV(RHS), BI);
};
if (auto Opt = evaluateCondition(BI->getCondition()))
KnownSucc = BI->getSuccessor(*Opt ? 0 : 1);
} }
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { } else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
if (auto *SimpleCond = getSimplifiedConstant(SI->getCondition())) { if (auto *SimpleCond = getSimplifiedConstant(SI->getCondition())) {
// Just take the first successor if condition is undef // Just take the first successor if condition is undef
if (isa<UndefValue>(SimpleCond)) if (isa<UndefValue>(SimpleCond))
KnownSucc = SI->getSuccessor(0); KnownSucc = SI->getSuccessor(0);
else if (ConstantInt *SimpleCondVal = else if (ConstantInt *SimpleCondVal =
dyn_cast<ConstantInt>(SimpleCond)) dyn_cast<ConstantInt>(SimpleCond))
▲ Show 20 Lines • Show All 894 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopUnroll/unroll-cost-symbolic-execute.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -loop-unroll -S -unroll-threshold=120 < %s | FileCheck %s ; RUN: opt -loop-unroll -S -unroll-threshold=120 < %s | FileCheck %s
define i32 @test_both(i32 %limit) { define i32 @test_both(i32 %limit) {
; CHECK-LABEL: @test_both( ; CHECK-LABEL: @test_both(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[LOOP_GUARD:%.*]] = icmp sge i32 [[LIMIT:%.*]], 0 ; CHECK-NEXT: [[LOOP_GUARD:%.*]] = icmp sge i32 [[LIMIT:%.*]], 0
; CHECK-NEXT: br i1 [[LOOP_GUARD]], label [[LOOP_PREHEADER:%.*]], label [[FAILURE:%.*]] ; CHECK-NEXT: br i1 [[LOOP_GUARD]], label [[LOOP_PREHEADER:%.*]], label [[FAILURE:%.*]]
; CHECK: loop.preheader: ; CHECK: loop.preheader:
; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop: ; CHECK: loop:
; CHECK-NEXT: [[SUM:%.*]] = phi i32 [ [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ], [ 0, [[LOOP_PREHEADER]] ] ; CHECK-NEXT: [[IS_POSITIVE:%.*]] = icmp sge i32 [[LIMIT]], 0
; CHECK-NEXT: [[IV:%.*]] = phi i32 [ [[IV_NEXT:%.*]], [[BACKEDGE]] ], [ 0, [[LOOP_PREHEADER]] ] ; CHECK-NEXT: br i1 [[IS_POSITIVE]], label [[BACKEDGE:%.*]], label [[IF_FALSE:%.*]]
; CHECK-NEXT: [[SUB:%.*]] = sub i32 [[LIMIT]], [[SUM]]
; CHECK-NEXT: [[IS_POSITIVE:%.*]] = icmp sge i32 [[SUB]], 0
; CHECK-NEXT: br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label [[IF_FALSE:%.*]]
; CHECK: if.false: ; CHECK: if.false:
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE]] ; CHECK-NEXT: br label [[BACKEDGE]]
; CHECK: backedge: ; CHECK: backedge:
; CHECK-NEXT: [[SUM_NEXT]] = add i32 [[SUM]], [[SUB]] ; CHECK-NEXT: br i1 true, label [[BACKEDGE_1:%.*]], label [[IF_FALSE_1:%.*]]
; CHECK-NEXT: [[IV_NEXT]] = add i32 [[IV]], 1
; CHECK-NEXT: [[LOOP_COND:%.*]] = icmp ne i32 [[IV]], 8
; CHECK-NEXT: br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
; CHECK: done:
; CHECK-NEXT: [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]], [[BACKEDGE]] ]
; CHECK-NEXT: ret i32 [[SUM_NEXT_LCSSA]]
; CHECK: failure: ; CHECK: failure:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; CHECK: if.false.1:
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE_1]]
; CHECK: backedge.1:
; CHECK-NEXT: br i1 true, label [[BACKEDGE_2:%.*]], label [[IF_FALSE_2:%.*]]
; CHECK: if.false.2:
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE_2]]
; CHECK: backedge.2:
; CHECK-NEXT: br i1 true, label [[BACKEDGE_3:%.*]], label [[IF_FALSE_3:%.*]]
; CHECK: if.false.3:
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE_3]]
; CHECK: backedge.3:
; CHECK-NEXT: br i1 true, label [[BACKEDGE_4:%.*]], label [[IF_FALSE_4:%.*]]
; CHECK: if.false.4:
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE_4]]
; CHECK: backedge.4:
; CHECK-NEXT: br i1 true, label [[BACKEDGE_5:%.*]], label [[IF_FALSE_5:%.*]]
; CHECK: if.false.5:
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE_5]]
; CHECK: backedge.5:
; CHECK-NEXT: br i1 true, label [[BACKEDGE_6:%.*]], label [[IF_FALSE_6:%.*]]
; CHECK: if.false.6:
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE_6]]
; CHECK: backedge.6:
; CHECK-NEXT: br i1 true, label [[BACKEDGE_7:%.*]], label [[IF_FALSE_7:%.*]]
; CHECK: if.false.7:
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE_7]]
; CHECK: backedge.7:
; CHECK-NEXT: br i1 true, label [[BACKEDGE_8:%.*]], label [[IF_FALSE_8:%.*]]
; CHECK: if.false.8:
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE_8]]
; CHECK: backedge.8:
; CHECK-NEXT: ret i32 [[LIMIT]]
; ;
entry: entry:
%loop_guard = icmp sge i32 %limit, 0 %loop_guard = icmp sge i32 %limit, 0
br i1 %loop_guard, label %loop, label %failure br i1 %loop_guard, label %loop, label %failure
loop: ; preds = %backedge, %entry loop: ; preds = %backedge, %entry
%sum = phi i32 [ 0, %entry ], [ %sum.next, %backedge ] %sum = phi i32 [ 0, %entry ], [ %sum.next, %backedge ]
%iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ] %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
Show All 35 Lines
define i32 @test_dom_condition(i32 %limit) { define i32 @test_dom_condition(i32 %limit) {
; CHECK-LABEL: @test_dom_condition( ; CHECK-LABEL: @test_dom_condition(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[LOOP_GUARD:%.*]] = icmp sge i32 [[LIMIT:%.*]], 0 ; CHECK-NEXT: [[LOOP_GUARD:%.*]] = icmp sge i32 [[LIMIT:%.*]], 0
; CHECK-NEXT: br i1 [[LOOP_GUARD]], label [[LOOP_PREHEADER:%.*]], label [[FAILURE:%.*]] ; CHECK-NEXT: br i1 [[LOOP_GUARD]], label [[LOOP_PREHEADER:%.*]], label [[FAILURE:%.*]]
; CHECK: loop.preheader: ; CHECK: loop.preheader:
; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop: ; CHECK: loop:
; CHECK-NEXT: [[SUM:%.*]] = phi i32 [ [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ], [ 0, [[LOOP_PREHEADER]] ] ; CHECK-NEXT: [[IS_POSITIVE:%.*]] = icmp sle i32 0, [[LIMIT]]
; CHECK-NEXT: [[IV:%.*]] = phi i32 [ [[IV_NEXT:%.*]], [[BACKEDGE]] ], [ 0, [[LOOP_PREHEADER]] ] ; CHECK-NEXT: br i1 [[IS_POSITIVE]], label [[BACKEDGE:%.*]], label [[IF_FALSE:%.*]]
; CHECK-NEXT: [[SUB:%.*]] = sub i32 0, [[SUM]]
; CHECK-NEXT: [[IS_POSITIVE:%.*]] = icmp sle i32 [[SUB]], [[LIMIT]]
; CHECK-NEXT: br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label [[IF_FALSE:%.*]]
; CHECK: if.false: ; CHECK: if.false:
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE]] ; CHECK-NEXT: br label [[BACKEDGE]]
; CHECK: backedge: ; CHECK: backedge:
; CHECK-NEXT: [[SUM_NEXT]] = add i32 [[SUM]], [[SUB]] ; CHECK-NEXT: [[IS_POSITIVE_1:%.*]] = icmp sle i32 0, [[LIMIT]]
; CHECK-NEXT: [[IV_NEXT]] = add i32 [[IV]], 1 ; CHECK-NEXT: br i1 [[IS_POSITIVE_1]], label [[BACKEDGE_1:%.*]], label [[IF_FALSE_1:%.*]]
; CHECK-NEXT: [[LOOP_COND:%.*]] = icmp ne i32 [[IV]], 8
; CHECK-NEXT: br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
; CHECK: done:
; CHECK-NEXT: [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]], [[BACKEDGE]] ]
; CHECK-NEXT: ret i32 [[SUM_NEXT_LCSSA]]
; CHECK: failure: ; CHECK: failure:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; CHECK: if.false.1:
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE_1]]
; CHECK: backedge.1:
; CHECK-NEXT: [[IS_POSITIVE_2:%.*]] = icmp sle i32 0, [[LIMIT]]
; CHECK-NEXT: br i1 [[IS_POSITIVE_2]], label [[BACKEDGE_2:%.*]], label [[IF_FALSE_2:%.*]]
; CHECK: if.false.2:
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE_2]]
; CHECK: backedge.2:
; CHECK-NEXT: [[IS_POSITIVE_3:%.*]] = icmp sle i32 0, [[LIMIT]]
; CHECK-NEXT: br i1 [[IS_POSITIVE_3]], label [[BACKEDGE_3:%.*]], label [[IF_FALSE_3:%.*]]
; CHECK: if.false.3:
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE_3]]
; CHECK: backedge.3:
; CHECK-NEXT: [[IS_POSITIVE_4:%.*]] = icmp sle i32 0, [[LIMIT]]
; CHECK-NEXT: br i1 [[IS_POSITIVE_4]], label [[BACKEDGE_4:%.*]], label [[IF_FALSE_4:%.*]]
; CHECK: if.false.4:
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE_4]]
; CHECK: backedge.4:
; CHECK-NEXT: [[IS_POSITIVE_5:%.*]] = icmp sle i32 0, [[LIMIT]]
; CHECK-NEXT: br i1 [[IS_POSITIVE_5]], label [[BACKEDGE_5:%.*]], label [[IF_FALSE_5:%.*]]
; CHECK: if.false.5:
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE_5]]
; CHECK: backedge.5:
; CHECK-NEXT: [[IS_POSITIVE_6:%.*]] = icmp sle i32 0, [[LIMIT]]
; CHECK-NEXT: br i1 [[IS_POSITIVE_6]], label [[BACKEDGE_6:%.*]], label [[IF_FALSE_6:%.*]]
; CHECK: if.false.6:
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE_6]]
; CHECK: backedge.6:
; CHECK-NEXT: [[IS_POSITIVE_7:%.*]] = icmp sle i32 0, [[LIMIT]]
; CHECK-NEXT: br i1 [[IS_POSITIVE_7]], label [[BACKEDGE_7:%.*]], label [[IF_FALSE_7:%.*]]
; CHECK: if.false.7:
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE_7]]
; CHECK: backedge.7:
; CHECK-NEXT: [[IS_POSITIVE_8:%.*]] = icmp sle i32 0, [[LIMIT]]
; CHECK-NEXT: br i1 [[IS_POSITIVE_8]], label [[BACKEDGE_8:%.*]], label [[IF_FALSE_8:%.*]]
; CHECK: if.false.8:
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: call void @foo()
; CHECK-NEXT: br label [[BACKEDGE_8]]
; CHECK: backedge.8:
; CHECK-NEXT: ret i32 0
; ;
entry: entry:
%loop_guard = icmp sge i32 %limit, 0 %loop_guard = icmp sge i32 %limit, 0
br i1 %loop_guard, label %loop, label %failure br i1 %loop_guard, label %loop, label %failure
loop: ; preds = %backedge, %entry loop: ; preds = %backedge, %entry
%sum = phi i32 [ 0, %entry ], [ %sum.next, %backedge ] %sum = phi i32 [ 0, %entry ], [ %sum.next, %backedge ]
%iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ] %iv = phi i32 [ 0, %entry ], [ %iv.next, %backedge ]
▲ Show 20 Lines • Show All 245 Lines • ▼ Show 20 Lines
done: ; preds = %backedge done: ; preds = %backedge
%sum.next.lcssa = phi i32 [ %sum.next, %backedge ] %sum.next.lcssa = phi i32 [ %sum.next, %backedge ]
ret i32 %sum.next.lcssa ret i32 %sum.next.lcssa
failure: failure:
unreachable unreachable
} }
declare void @foo() declare void @foo()
mkazantsevUnsubmitted
Not Done
ReplyInline Actions

I like the change, but the results like this scare me a lot. Is this really what we want to see in code?

mkazantsev: I like the change, but the results like this scare me a lot. Is this really what we want to see…
mkazantsevUnsubmitted
Not Done
ReplyInline Actions

Ah, it's dead code... Nvm then.

mkazantsev: Ah, it's dead code... Nvm then.