This is an archive of the discontinued LLVM Phabricator instance.

Differential D69689

[SimplifyCFG] Use a (trivially) dominanting widenable branch to remove later slow path blocks
ClosedPublic

Authored by reames on Oct 31 2019, 4:28 PM.

Details

Reviewers
apilipenko
fedor.sergeev
Commits
rG6ff439b57f0f: [SimplifyCFG] Use a (trivially) dominanting widenable branch to remove later…
Summary

This transformation is a variation on the GuardWidening transformation we have checked in as it's own pass. Instead of focusing on merge (i.e. hoisting and simplifying) two widenable branches, this transform makes the observation that simply removing a second slowpath block (by reusing an existing one) is often a very useful canonicalization. This may lead to later merging, or may not. This is a useful generalization when the intermediate block has loads whose dereferenceability is hard to establish.

As noted in the patch, this can be generalized further. I'd like to get this in, and then iterate on top if that's okay with reviewers.

Diff Detail

Event Timeline

reames created this revision.Oct 31 2019, 4:28 PM
Herald added a project: Restricted Project. · View Herald TranscriptOct 31 2019, 4:28 PM
Herald added subscribers: bollu, hiraditya, mcrosier. · View Herald Transcript
apilipenko added inline comments.Oct 31 2019, 5:36 PM
llvm/lib/Transforms/Utils/SimplifyCFG.cpp
3234–3252

This can be structured better. First, you need NoSideEffects(*BI->getParent()) for both of the cases, so it can be turned into an early return check. And second, these cases seem to differ only by successor index. Factor out a lambda and call it for 0 and 1?

reames marked an inline comment as done.Nov 1 2019, 3:18 PM
reames added inline comments.
llvm/lib/Transforms/Utils/SimplifyCFG.cpp
3234–3252

The use of the lambda here is important. I only want to evaluate the expensive predicate if both of the cheap ones have passed.

As for the second point, possible. I played with a couple and nothing really seemed cleaner, but I can give it another attempt.

apilipenko accepted this revision.Nov 1 2019, 7:49 PM
apilipenko added inline comments.
llvm/lib/Transforms/Utils/SimplifyCFG.cpp
3234–3252

Ah, makes sense. May be a comment explaining the use of the lambda then?

This revision is now accepted and ready to land.Nov 1 2019, 7:49 PM
Closed by commit rG6ff439b57f0f: [SimplifyCFG] Use a (trivially) dominanting widenable branch to remove later… (authored by reames). · Explain WhyNov 4 2019, 11:07 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
lib/
Transforms/
Utils/
48 lines
test/
Transforms/
SimplifyCFG/
316 lines

Diff 227746

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

Show All 18 Lines
#include "llvm/ADT/SetVector.h" #include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Statistic.h" #include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Analysis/AssumptionCache.h" #include "llvm/Analysis/AssumptionCache.h"
#include "llvm/Analysis/ConstantFolding.h" #include "llvm/Analysis/ConstantFolding.h"
#include "llvm/Analysis/EHPersonalities.h" #include "llvm/Analysis/EHPersonalities.h"
#include "llvm/Analysis/GuardUtils.h"
#include "llvm/Analysis/InstructionSimplify.h" #include "llvm/Analysis/InstructionSimplify.h"
#include "llvm/Analysis/MemorySSA.h" #include "llvm/Analysis/MemorySSA.h"
#include "llvm/Analysis/MemorySSAUpdater.h" #include "llvm/Analysis/MemorySSAUpdater.h"
#include "llvm/Analysis/TargetTransformInfo.h" #include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/Analysis/ValueTracking.h" #include "llvm/Analysis/ValueTracking.h"
#include "llvm/IR/Attributes.h" #include "llvm/IR/Attributes.h"
#include "llvm/IR/BasicBlock.h" #include "llvm/IR/BasicBlock.h"
#include "llvm/IR/CFG.h" #include "llvm/IR/CFG.h"
▲ Show 20 Lines • Show All 3,172 Lines • ▼ Show 20 Linesstatic bool mergeConditionalStores(BranchInst *PBI, BranchInst *QBI,
bool Changed = false; bool Changed = false;
for (auto *Address : CommonAddresses) for (auto *Address : CommonAddresses)
Changed |= mergeConditionalStoreToAddress( Changed |= mergeConditionalStoreToAddress(
PTB, PFB, QTB, QFB, PostBB, Address, InvertPCond, InvertQCond, DL, TTI); PTB, PFB, QTB, QFB, PostBB, Address, InvertPCond, InvertQCond, DL, TTI);
return Changed; return Changed;
} }
/// If the previous block ended with a widenable branch, determine if reusing
/// the target block is profitable and legal. This will have the effect of
/// "widening" PBI, but doesn't require us to reason about hosting safety.
static bool tryWidenCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI) {
// TODO: This can be generalized in two important ways:
// 1) We can allow phi nodes in IfFalseBB and simply reuse all the input
// values from the PBI edge.
// 2) We can sink side effecting instructions into BI's fallthrough
// successor provided they doesn't contribute to computation of
// BI's condition.
Value *CondWB, *WC;
BasicBlock *IfTrueBB, *IfFalseBB;
if (!parseWidenableBranch(PBI, CondWB, WC, IfTrueBB, IfFalseBB) ||
IfTrueBB != BI->getParent() || !BI->getParent()->getSinglePredecessor())
return false;
if (!IfFalseBB->phis().empty())
return false; // TODO
// Use lambda to lazily compute expensive condition after cheap ones.
auto NoSideEffects = [](BasicBlock &BB) {
return !llvm::any_of(BB, [](const Instruction &I) {
return I.mayWriteToMemory() || I.mayHaveSideEffects();
});
};
if (BI->getSuccessor(1) != IfFalseBB && // no inf looping
BI->getSuccessor(1)->getTerminatingDeoptimizeCall() && // profitability
NoSideEffects(*BI->getParent())) {
BI->getSuccessor(1)->removePredecessor(BI->getParent());
BI->setSuccessor(1, IfFalseBB);
return true;
}
if (BI->getSuccessor(0) != IfFalseBB && // no inf looping
BI->getSuccessor(0)->getTerminatingDeoptimizeCall() && // profitability
NoSideEffects(*BI->getParent())) {
BI->getSuccessor(0)->removePredecessor(BI->getParent());
BI->setSuccessor(0, IfFalseBB);
return true;
apilipenkoUnsubmitted
Not Done
ReplyInline Actions

This can be structured better. First, you need NoSideEffects(*BI->getParent()) for both of the cases, so it can be turned into an early return check. And second, these cases seem to differ only by successor index. Factor out a lambda and call it for 0 and 1?

apilipenko: This can be structured better. First, you need `NoSideEffects(*BI->getParent())` for both of…
reamesAuthorUnsubmitted
Done
ReplyInline Actions

The use of the lambda here is important. I only want to evaluate the expensive predicate if both of the cheap ones have passed.

As for the second point, possible. I played with a couple and nothing really seemed cleaner, but I can give it another attempt.

reames: The use of the lambda here is important. I only want to evaluate the expensive predicate if…
apilipenkoUnsubmitted
Not Done
ReplyInline Actions

Ah, makes sense. May be a comment explaining the use of the lambda then?

apilipenko: Ah, makes sense. May be a comment explaining the use of the lambda then?
}
return false;
}
/// If we have a conditional branch as a predecessor of another block, /// If we have a conditional branch as a predecessor of another block,
/// this function tries to simplify it. We know /// this function tries to simplify it. We know
/// that PBI and BI are both conditional branches, and BI is in one of the /// that PBI and BI are both conditional branches, and BI is in one of the
/// successor blocks of PBI - PBI branches to BI. /// successor blocks of PBI - PBI branches to BI.
static bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI, static bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI,
const DataLayout &DL, const DataLayout &DL,
const TargetTransformInfo &TTI) { const TargetTransformInfo &TTI) {
assert(PBI->isConditional() && BI->isConditional()); assert(PBI->isConditional() && BI->isConditional());
Show All 39 Lines if (BlockIsSimpleEnoughToThreadThrough(BB)) {
} }
} }
BI->setCondition(NewPN); BI->setCondition(NewPN);
return true; return true;
} }
} }
// If the previous block ended with a widenable branch, determine if reusing
// the target block is profitable and legal. This will have the effect of
// "widening" PBI, but doesn't require us to reason about hosting safety.
if (tryWidenCondBranchToCondBranch(PBI, BI))
return true;
if (auto *CE = dyn_cast<ConstantExpr>(BI->getCondition())) if (auto *CE = dyn_cast<ConstantExpr>(BI->getCondition()))
if (CE->canTrap()) if (CE->canTrap())
return false; return false;
// If both branches are conditional and both contain stores to the same // If both branches are conditional and both contain stores to the same
// address, remove the stores from the conditionals and create a conditional // address, remove the stores from the conditionals and create a conditional
// merged store at the end. // merged store at the end.
if (MergeCondStores && mergeConditionalStores(PBI, BI, DL, TTI)) if (MergeCondStores && mergeConditionalStores(PBI, BI, DL, TTI))
▲ Show 20 Lines • Show All 2,859 Lines • Show Last 20 Lines

llvm/test/Transforms/SimplifyCFG/wc-widen-block.ll

  • This file was added.
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -passes=simplify-cfg -S < %s | FileCheck %s
define i32 @basic(i1 %cond_0, i32* %p) {
; CHECK-LABEL: @basic(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
; CHECK-NEXT: [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_0:%.*]], [[WIDENABLE_COND]]
; CHECK-NEXT: br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
; CHECK: deopt:
; CHECK-NEXT: [[DEOPTRET:%.*]] = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
; CHECK-NEXT: ret i32 [[DEOPTRET]]
; CHECK: guarded:
; CHECK-NEXT: [[V:%.*]] = load i32, i32* [[P:%.*]]
; CHECK-NEXT: [[COND_1:%.*]] = icmp eq i32 [[V]], 0
; CHECK-NEXT: br i1 [[COND_1]], label [[RETURN:%.*]], label [[DEOPT]], !prof !0
; CHECK: return:
; CHECK-NEXT: ret i32 0
;
entry:
%widenable_cond = call i1 @llvm.experimental.widenable.condition()
%exiplicit_guard_cond = and i1 %cond_0, %widenable_cond
br i1 %exiplicit_guard_cond, label %guarded, label %deopt, !prof !0
deopt:
%deoptret = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
ret i32 %deoptret
guarded:
%v = load i32, i32* %p
%cond_1 = icmp eq i32 %v, 0
br i1 %cond_1, label %return, label %deopt2, !prof !0
deopt2:
%deoptret2 = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
ret i32 %deoptret2
return:
ret i32 0
}
define i32 @mergeable(i1 %cond_0, i1 %cond_1) {
; CHECK-LABEL: @mergeable(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
; CHECK-NEXT: [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_0:%.*]], [[WIDENABLE_COND]]
; CHECK-NEXT: [[EXIPLICIT_GUARD_COND_NOT:%.*]] = xor i1 [[EXIPLICIT_GUARD_COND]], true
; CHECK-NEXT: [[COND_1_NOT:%.*]] = xor i1 [[COND_1:%.*]], true
; CHECK-NEXT: [[BRMERGE:%.*]] = or i1 [[EXIPLICIT_GUARD_COND_NOT]], [[COND_1_NOT]]
; CHECK-NEXT: br i1 [[BRMERGE]], label [[DEOPT:%.*]], label [[RETURN:%.*]], !prof !1
; CHECK: deopt:
; CHECK-NEXT: [[DEOPTRET:%.*]] = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
; CHECK-NEXT: ret i32 [[DEOPTRET]]
; CHECK: return:
; CHECK-NEXT: ret i32 0
;
entry:
%widenable_cond = call i1 @llvm.experimental.widenable.condition()
%exiplicit_guard_cond = and i1 %cond_0, %widenable_cond
br i1 %exiplicit_guard_cond, label %guarded, label %deopt, !prof !0
deopt:
%deoptret = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
ret i32 %deoptret
guarded:
br i1 %cond_1, label %return, label %deopt2, !prof !0
deopt2:
%deoptret2 = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
ret i32 %deoptret2
return:
ret i32 0
}
define i32 @basic_swapped_branch(i1 %cond_0, i32* %p) {
; CHECK-LABEL: @basic_swapped_branch(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
; CHECK-NEXT: [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_0:%.*]], [[WIDENABLE_COND]]
; CHECK-NEXT: br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
; CHECK: deopt:
; CHECK-NEXT: [[DEOPTRET:%.*]] = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
; CHECK-NEXT: ret i32 [[DEOPTRET]]
; CHECK: guarded:
; CHECK-NEXT: [[V:%.*]] = load i32, i32* [[P:%.*]]
; CHECK-NEXT: [[COND_1:%.*]] = icmp eq i32 [[V]], 0
; CHECK-NEXT: br i1 [[COND_1]], label [[DEOPT]], label [[RETURN:%.*]], !prof !0
; CHECK: return:
; CHECK-NEXT: ret i32 0
;
entry:
%widenable_cond = call i1 @llvm.experimental.widenable.condition()
%exiplicit_guard_cond = and i1 %cond_0, %widenable_cond
br i1 %exiplicit_guard_cond, label %guarded, label %deopt, !prof !0
deopt:
%deoptret = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
ret i32 %deoptret
guarded:
%v = load i32, i32* %p
%cond_1 = icmp eq i32 %v, 0
br i1 %cond_1, label %deopt2, label %return, !prof !0
deopt2:
%deoptret2 = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
ret i32 %deoptret2
return:
ret i32 0
}
define i32 @todo_sink_side_effect(i1 %cond_0, i1 %cond_1) {
; CHECK-LABEL: @todo_sink_side_effect(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
; CHECK-NEXT: [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_0:%.*]], [[WIDENABLE_COND]]
; CHECK-NEXT: br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
; CHECK: deopt:
; CHECK-NEXT: [[DEOPTRET:%.*]] = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
; CHECK-NEXT: ret i32 [[DEOPTRET]]
; CHECK: guarded:
; CHECK-NEXT: call void @unknown()
; CHECK-NEXT: br i1 [[COND_1:%.*]], label [[RETURN:%.*]], label [[DEOPT2:%.*]], !prof !0
; CHECK: deopt2:
; CHECK-NEXT: [[DEOPTRET2:%.*]] = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
; CHECK-NEXT: ret i32 [[DEOPTRET2]]
; CHECK: return:
; CHECK-NEXT: ret i32 0
;
entry:
%widenable_cond = call i1 @llvm.experimental.widenable.condition()
%exiplicit_guard_cond = and i1 %cond_0, %widenable_cond
br i1 %exiplicit_guard_cond, label %guarded, label %deopt, !prof !0
deopt:
%deoptret = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
ret i32 %deoptret
guarded:
call void @unknown()
br i1 %cond_1, label %return, label %deopt2, !prof !0
deopt2:
%deoptret2 = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
ret i32 %deoptret2
return:
ret i32 0
}
define i32 @neg_unsinkable_side_effect(i1 %cond_0) {
; CHECK-LABEL: @neg_unsinkable_side_effect(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
; CHECK-NEXT: [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_0:%.*]], [[WIDENABLE_COND]]
; CHECK-NEXT: br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
; CHECK: deopt:
; CHECK-NEXT: [[DEOPTRET:%.*]] = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
; CHECK-NEXT: ret i32 [[DEOPTRET]]
; CHECK: guarded:
; CHECK-NEXT: [[V:%.*]] = call i32 @unknown_i32()
; CHECK-NEXT: [[COND_1:%.*]] = icmp eq i32 [[V]], 0
; CHECK-NEXT: br i1 [[COND_1]], label [[RETURN:%.*]], label [[DEOPT2:%.*]], !prof !0
; CHECK: deopt2:
; CHECK-NEXT: [[DEOPTRET2:%.*]] = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
; CHECK-NEXT: ret i32 [[DEOPTRET2]]
; CHECK: return:
; CHECK-NEXT: ret i32 0
;
entry:
%widenable_cond = call i1 @llvm.experimental.widenable.condition()
%exiplicit_guard_cond = and i1 %cond_0, %widenable_cond
br i1 %exiplicit_guard_cond, label %guarded, label %deopt, !prof !0
deopt:
%deoptret = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
ret i32 %deoptret
guarded:
%v = call i32 @unknown_i32()
%cond_1 = icmp eq i32 %v, 0
br i1 %cond_1, label %return, label %deopt2, !prof !0
deopt2:
%deoptret2 = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
ret i32 %deoptret2
return:
ret i32 0
}
define i32 @neg_inf_loop(i1 %cond_0, i1 %cond_1) {
; CHECK-LABEL: @neg_inf_loop(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
; CHECK-NEXT: [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_0:%.*]], [[WIDENABLE_COND]]
; CHECK-NEXT: br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
; CHECK: deopt:
; CHECK-NEXT: [[DEOPTRET:%.*]] = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
; CHECK-NEXT: ret i32 [[DEOPTRET]]
; CHECK: guarded:
; CHECK-NEXT: call void @unknown()
; CHECK-NEXT: br i1 [[COND_1:%.*]], label [[RETURN:%.*]], label [[DEOPT]], !prof !0
; CHECK: return:
; CHECK-NEXT: ret i32 0
;
entry:
%widenable_cond = call i1 @llvm.experimental.widenable.condition()
%exiplicit_guard_cond = and i1 %cond_0, %widenable_cond
br i1 %exiplicit_guard_cond, label %guarded, label %deopt, !prof !0
deopt:
%deoptret = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
ret i32 %deoptret
guarded:
call void @unknown()
br i1 %cond_1, label %return, label %deopt, !prof !0
return:
ret i32 0
}
define i32 @todo_phi(i1 %cond_0, i1 %cond_1) {
; CHECK-LABEL: @todo_phi(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
; CHECK-NEXT: [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_0:%.*]], [[WIDENABLE_COND]]
; CHECK-NEXT: br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
; CHECK: deopt:
; CHECK-NEXT: [[PHI:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ]
; CHECK-NEXT: [[DEOPTRET:%.*]] = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"(i32 [[PHI]]) ]
; CHECK-NEXT: ret i32 [[DEOPTRET]]
; CHECK: guarded:
; CHECK-NEXT: br i1 [[COND_1:%.*]], label [[RETURN:%.*]], label [[DEOPT2:%.*]], !prof !0
; CHECK: deopt2:
; CHECK-NEXT: [[DEOPTRET2:%.*]] = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
; CHECK-NEXT: ret i32 [[DEOPTRET2]]
; CHECK: return:
; CHECK-NEXT: ret i32 0
;
entry:
%widenable_cond = call i1 @llvm.experimental.widenable.condition()
%exiplicit_guard_cond = and i1 %cond_0, %widenable_cond
br i1 %exiplicit_guard_cond, label %guarded, label %deopt, !prof !0
deopt:
%phi = phi i32 [0, %entry]
%deoptret = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"(i32 %phi) ]
ret i32 %deoptret
guarded:
br i1 %cond_1, label %return, label %deopt2, !prof !0
deopt2:
%deoptret2 = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
ret i32 %deoptret2
return:
ret i32 0
}
define i32 @neg_loop(i1 %cond_0, i1 %cond_1) {
; CHECK-LABEL: @neg_loop(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[GUARDED:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
; CHECK-NEXT: [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_0:%.*]], [[WIDENABLE_COND]]
; CHECK-NEXT: br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED]], label [[DEOPT:%.*]], !prof !0
; CHECK: deopt:
; CHECK-NEXT: [[DEOPTRET:%.*]] = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
; CHECK-NEXT: ret i32 [[DEOPTRET]]
; CHECK: guarded:
; CHECK-NEXT: call void @unknown()
; CHECK-NEXT: br i1 [[COND_1:%.*]], label [[LOOP:%.*]], label [[DEOPT2:%.*]], !prof !0
; CHECK: deopt2:
; CHECK-NEXT: [[DEOPTRET2:%.*]] = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
; CHECK-NEXT: ret i32 [[DEOPTRET2]]
;
entry:
br label %guarded
loop:
%widenable_cond = call i1 @llvm.experimental.widenable.condition()
%exiplicit_guard_cond = and i1 %cond_0, %widenable_cond
br i1 %exiplicit_guard_cond, label %guarded, label %deopt, !prof !0
deopt:
%deoptret = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
ret i32 %deoptret
guarded:
call void @unknown()
br i1 %cond_1, label %loop, label %deopt2, !prof !0
deopt2:
%deoptret2 = call i32 (...) @llvm.experimental.deoptimize.i32() [ "deopt"() ]
ret i32 %deoptret2
}
declare void @unknown()
declare i32 @unknown_i32()
declare i1 @llvm.experimental.widenable.condition()
declare i32 @llvm.experimental.deoptimize.i32(...)
!0 = !{!"branch_weights", i32 1048576, i32 1}
!1 = !{i32 1, i32 -2147483648}