This is an archive of the discontinued LLVM Phabricator instance.

Differential D120095

Simplify/cleanup BasicBlockUtilsTest
ClosedPublic

Authored by MatzeB on Feb 17 2022, 3:46 PM.

Details

Reviewers
arsenm
yrouban
kobeliu85
sidbav
modimo
wenlei
Summary

Cleanup BasicBolckUtilsTest using C++ raw string literals, remove duplicated block functions and smaller style changes.

Diff Detail

Event Timeline

MatzeB created this revision.Feb 17 2022, 3:46 PM
Herald added a subscriber: mcrosier. · View Herald TranscriptFeb 17 2022, 3:46 PM
MatzeB requested review of this revision.Feb 17 2022, 3:46 PM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 17 2022, 3:46 PM
Herald added subscribers: llvm-commits, wdng. · View Herald Transcript
MatzeB added a child revision: D120096: PGOInstrumentation, GCOVProfiling: Split indirectbr critical edges regardless of PHIs.Feb 17 2022, 3:51 PM
Harbormaster completed remote builds in B150346: Diff 409808.Feb 17 2022, 4:19 PM
modimo added a comment.Feb 17 2022, 5:20 PM

The Windows build testing is failing. Took a look and pretty sure you just need to rebase past 19bdf44d850884a13a8708ccf1260fb7f4ef4eb3 which reverted the patch with the failing tests.

MatzeB updated this revision to Diff 410878.Feb 23 2022, 11:21 AM
Harbormaster completed remote builds in B151100: Diff 410878.Feb 23 2022, 12:12 PM
modimo accepted this revision.Feb 23 2022, 1:12 PM

LGTM

This revision is now accepted and ready to land.Feb 23 2022, 1:12 PM
wenlei accepted this revision.Feb 23 2022, 5:53 PM
MatzeB closed this revision.Feb 23 2022, 5:57 PM

landed as d7a307320e50a0c83d052b04c766e9cf4d618b37

Revision Contents

PathSize
llvm/
unittests/
Transforms/
Utils/
544 lines

Diff 410878

llvm/unittests/Transforms/Utils/BasicBlockUtilsTest.cpp

Show All 38 Linesstatic BasicBlock *getBasicBlockByName(Function &F, StringRef Name) {
for (BasicBlock &BB : F) for (BasicBlock &BB : F)
if (BB.getName() == Name) if (BB.getName() == Name)
return &BB; return &BB;
llvm_unreachable("Expected to find basic block!"); llvm_unreachable("Expected to find basic block!");
} }
TEST(BasicBlockUtils, EliminateUnreachableBlocks) { TEST(BasicBlockUtils, EliminateUnreachableBlocks) {
LLVMContext C; LLVMContext C;
std::unique_ptr<Module> M = parseIR(C, R"IR(
std::unique_ptr<Module> M = parseIR( define i32 @has_unreachable(i1 %cond) {
C, entry:
"define i32 @has_unreachable(i1 %cond) {\n" br i1 %cond, label %bb0, label %bb1
"entry:\n" bb0:
" br i1 %cond, label %bb0, label %bb1\n" br label %bb1
"bb0:\n" bb1:
" br label %bb1\n" %phi = phi i32 [ 0, %entry ], [ 1, %bb0 ]
"bb1:\n" ret i32 %phi
" %phi = phi i32 [ 0, %entry ], [ 1, %bb0 ]" bb2:
" ret i32 %phi\n" ret i32 42
"bb2:\n" }
" ret i32 42\n" )IR");
"}\n" Function *F = M->getFunction("has_unreachable");
"\n"
);
auto *F = M->getFunction("has_unreachable");
DominatorTree DT(*F); DominatorTree DT(*F);
DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager); DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager);
EXPECT_EQ(F->size(), (size_t)4); EXPECT_EQ(F->size(), (size_t)4);
bool Result = EliminateUnreachableBlocks(*F, &DTU); bool Result = EliminateUnreachableBlocks(*F, &DTU);
EXPECT_TRUE(Result); EXPECT_TRUE(Result);
EXPECT_EQ(F->size(), (size_t)3); EXPECT_EQ(F->size(), (size_t)3);
EXPECT_TRUE(DT.verify()); EXPECT_TRUE(DT.verify());
} }
TEST(BasicBlockUtils, SplitEdge_ex1) { TEST(BasicBlockUtils, SplitEdge_ex1) {
LLVMContext C; LLVMContext C;
std::unique_ptr<Module> M = std::unique_ptr<Module> M = parseIR(C, R"IR(
parseIR(C, "define void @foo(i1 %cond0) {\n" define void @foo(i1 %cond0) {
"entry:\n" entry:
" br i1 %cond0, label %bb0, label %bb1\n" br i1 %cond0, label %bb0, label %bb1
"bb0:\n" bb0:
" %0 = mul i32 1, 2\n" %0 = mul i32 1, 2
" br label %bb1\n" br label %bb1
"bb1:\n" bb1:
" br label %bb2\n" br label %bb2
"bb2:\n" bb2:
" ret void\n" ret void
"}\n" }
"\n"); )IR");
Function *F = M->getFunction("foo"); Function *F = M->getFunction("foo");
DominatorTree DT(*F); DominatorTree DT(*F);
BasicBlock *SrcBlock; BasicBlock *SrcBlock;
BasicBlock *DestBlock; BasicBlock *DestBlock;
BasicBlock *NewBB; BasicBlock *NewBB;
SrcBlock = getBasicBlockByName(*F, "entry"); SrcBlock = getBasicBlockByName(*F, "entry");
DestBlock = getBasicBlockByName(*F, "bb0"); DestBlock = getBasicBlockByName(*F, "bb0");
Show All 10 Lines if (BB.getName() == NewBB->getName()) {
BBFlag = true; BBFlag = true;
} }
} }
EXPECT_TRUE(BBFlag); EXPECT_TRUE(BBFlag);
} }
TEST(BasicBlockUtils, SplitEdge_ex2) { TEST(BasicBlockUtils, SplitEdge_ex2) {
LLVMContext C; LLVMContext C;
std::unique_ptr<Module> M = parseIR(C, "define void @foo() {\n" std::unique_ptr<Module> M = parseIR(C, R"IR(
"bb0:\n" define void @foo() {
" br label %bb2\n" bb0:
"bb1:\n" br label %bb2
" br label %bb2\n" bb1:
"bb2:\n" br label %bb2
" ret void\n" bb2:
"}\n" ret void
"\n"); }
)IR");
Function *F = M->getFunction("foo"); Function *F = M->getFunction("foo");
DominatorTree DT(*F); DominatorTree DT(*F);
BasicBlock *SrcBlock; BasicBlock *SrcBlock;
BasicBlock *DestBlock; BasicBlock *DestBlock;
BasicBlock *NewBB; BasicBlock *NewBB;
SrcBlock = getBasicBlockByName(*F, "bb0"); SrcBlock = getBasicBlockByName(*F, "bb0");
Show All 11 Lines if (BB.getName() == NewBB->getName()) {
BBFlag = true; BBFlag = true;
} }
} }
EXPECT_TRUE(BBFlag); EXPECT_TRUE(BBFlag);
} }
TEST(BasicBlockUtils, SplitEdge_ex3) { TEST(BasicBlockUtils, SplitEdge_ex3) {
LLVMContext C; LLVMContext C;
std::unique_ptr<Module> M = std::unique_ptr<Module> M = parseIR(C, R"IR(
parseIR(C, "define i32 @foo(i32 %n) {\n" define i32 @foo(i32 %n) {
"entry:\n" entry:
" br label %header\n" br label %header
"header:\n" header:
" %sum.02 = phi i32 [ 0, %entry ], [ %sum.1, %bb3 ]\n" %sum.02 = phi i32 [ 0, %entry ], [ %sum.1, %bb3 ]
" %0 = phi i32 [ 0, %entry ], [ %4, %bb3 ] \n" %0 = phi i32 [ 0, %entry ], [ %4, %bb3 ]
" %1 = icmp slt i32 %0, %n \n" %1 = icmp slt i32 %0, %n
" br i1 %1, label %bb0, label %bb1\n" br i1 %1, label %bb0, label %bb1
"bb0:\n" bb0:
" %2 = add nsw i32 %sum.02, 2\n" %2 = add nsw i32 %sum.02, 2
" br label %bb2\n" br label %bb2
"bb1:\n" bb1:
" %3 = add nsw i32 %sum.02, 1\n" %3 = add nsw i32 %sum.02, 1
" br label %bb2\n" br label %bb2
"bb2:\n" bb2:
" %sum.1 = phi i32 [ %2, %bb0 ], [ %3, %bb1 ]\n" %sum.1 = phi i32 [ %2, %bb0 ], [ %3, %bb1 ]
" br label %bb3\n" br label %bb3
"bb3:\n" bb3:
" %4 = add nsw i32 %0, 1 \n" %4 = add nsw i32 %0, 1
" %5 = icmp slt i32 %4, 100\n" %5 = icmp slt i32 %4, 100
" br i1 %5, label %header, label %bb4\n" br i1 %5, label %header, label %bb4
"bb4:\n" bb4:
" %sum.0.lcssa = phi i32 [ %sum.1, %bb3 ]\n" %sum.0.lcssa = phi i32 [ %sum.1, %bb3 ]
" ret i32 %sum.0.lcssa\n" ret i32 %sum.0.lcssa
"}\n" }
"\n"); )IR");
Function *F = M->getFunction("foo"); Function *F = M->getFunction("foo");
DominatorTree DT(*F); DominatorTree DT(*F);
LoopInfo LI(DT); LoopInfo LI(DT);
DataLayout DL("e-i64:64-f80:128-n8:16:32:64-S128"); DataLayout DL("e-i64:64-f80:128-n8:16:32:64-S128");
TargetLibraryInfoImpl TLII; TargetLibraryInfoImpl TLII;
TargetLibraryInfo TLI(TLII); TargetLibraryInfo TLI(TLII);
Show All 29 Lines if (BB.getName() == NewBB->getName()) {
BBFlag = true; BBFlag = true;
} }
} }
EXPECT_TRUE(BBFlag); EXPECT_TRUE(BBFlag);
} }
TEST(BasicBlockUtils, SplitEdge_ex4) { TEST(BasicBlockUtils, SplitEdge_ex4) {
LLVMContext C; LLVMContext C;
std::unique_ptr<Module> M = parseIR( std::unique_ptr<Module> M = parseIR(C, R"IR(
C, "define void @bar(i32 %cond) personality i8 0 {\n" define void @bar(i32 %cond) personality i8 0 {
"entry:\n" entry:
" switch i32 %cond, label %exit [\n" switch i32 %cond, label %exit [
" i32 -1, label %continue\n" i32 -1, label %continue
" i32 0, label %continue\n" i32 0, label %continue
" i32 1, label %continue_alt\n" i32 1, label %continue_alt
" i32 2, label %continue_alt\n" i32 2, label %continue_alt
" ]\n" ]
"exit:\n" exit:
" ret void\n" ret void
"continue:\n" continue:
" invoke void @sink() to label %normal unwind label %exception\n" invoke void @sink() to label %normal unwind label %exception
"continue_alt:\n" continue_alt:
" invoke void @sink_alt() to label %normal unwind label %exception\n" invoke void @sink_alt() to label %normal unwind label %exception
"exception:\n" exception:
" %cleanup = landingpad i8 cleanup\n" %cleanup = landingpad i8 cleanup
" br label %trivial-eh-handler\n" br label %trivial-eh-handler
"trivial-eh-handler:\n" trivial-eh-handler:
" call void @sideeffect(i32 1)\n" call void @sideeffect(i32 1)
" br label %normal\n" br label %normal
"normal:\n" normal:
" call void @sideeffect(i32 0)\n" call void @sideeffect(i32 0)
" ret void\n" ret void
"}\n" }
"\n"
"declare void @sideeffect(i32)\n" declare void @sideeffect(i32)
"declare void @sink() cold\n" declare void @sink() cold
"declare void @sink_alt() cold\n"); declare void @sink_alt() cold
)IR");
Function *F = M->getFunction("bar"); Function *F = M->getFunction("bar");
DominatorTree DT(*F); DominatorTree DT(*F);
LoopInfo LI(DT); LoopInfo LI(DT);
TargetLibraryInfoImpl TLII; TargetLibraryInfoImpl TLII;
TargetLibraryInfo TLI(TLII); TargetLibraryInfo TLI(TLII);
Show All 40 Lines if (BB.getName() == NewBB->getName()) {
break; break;
} }
} }
EXPECT_TRUE(BBFlag); EXPECT_TRUE(BBFlag);
} }
TEST(BasicBlockUtils, splitBasicBlockBefore_ex1) { TEST(BasicBlockUtils, splitBasicBlockBefore_ex1) {
LLVMContext C; LLVMContext C;
std::unique_ptr<Module> M = parseIR(C, "define void @foo() {\n" std::unique_ptr<Module> M = parseIR(C, R"IR(
"bb0:\n" define void @foo() {
" %0 = mul i32 1, 2\n" bb0:
" br label %bb2\n" %0 = mul i32 1, 2
"bb1:\n" br label %bb2
" br label %bb3\n" bb1:
"bb2:\n" br label %bb3
" %1 = phi i32 [ %0, %bb0 ]\n" bb2:
" br label %bb3\n" %1 = phi i32 [ %0, %bb0 ]
"bb3:\n" br label %bb3
" ret void\n" bb3:
"}\n" ret void
"\n"); }
)IR");
Function *F = M->getFunction("foo"); Function *F = M->getFunction("foo");
DominatorTree DT(*F); DominatorTree DT(*F);
BasicBlock *DestBlock; BasicBlock *DestBlock;
BasicBlock *NewBB; BasicBlock *NewBB;
DestBlock = getBasicBlockByName(*F, "bb2"); DestBlock = getBasicBlockByName(*F, "bb2");
NewBB = DestBlock->splitBasicBlockBefore(DestBlock->front().getIterator(), NewBB = DestBlock->splitBasicBlockBefore(DestBlock->front().getIterator(),
"test"); "test");
PHINode *PN = dyn_cast<PHINode>(&(DestBlock->front())); PHINode *PN = dyn_cast<PHINode>(&(DestBlock->front()));
EXPECT_EQ(PN->getIncomingBlock(0), NewBB); EXPECT_EQ(PN->getIncomingBlock(0), NewBB);
EXPECT_EQ(NewBB->getName(), "test"); EXPECT_EQ(NewBB->getName(), "test");
EXPECT_EQ(NewBB->getSingleSuccessor(), DestBlock); EXPECT_EQ(NewBB->getSingleSuccessor(), DestBlock);
EXPECT_EQ(DestBlock->getSinglePredecessor(), NewBB); EXPECT_EQ(DestBlock->getSinglePredecessor(), NewBB);
} }
#ifndef NDEBUG #ifndef NDEBUG
TEST(BasicBlockUtils, splitBasicBlockBefore_ex2) { TEST(BasicBlockUtils, splitBasicBlockBefore_ex2) {
LLVMContext C; LLVMContext C;
std::unique_ptr<Module> M = std::unique_ptr<Module> M = parseIR(C, R"IR(
parseIR(C, "define void @foo() {\n" define void @foo() {
"bb0:\n" bb0:
" %0 = mul i32 1, 2\n" %0 = mul i32 1, 2
" br label %bb2\n" br label %bb2
"bb1:\n" bb1:
" br label %bb2\n" br label %bb2
"bb2:\n" bb2:
" %1 = phi i32 [ %0, %bb0 ], [ 1, %bb1 ]\n" %1 = phi i32 [ %0, %bb0 ], [ 1, %bb1 ]
" br label %bb3\n" br label %bb3
"bb3:\n" bb3:
" ret void\n" ret void
"}\n" }
"\n"); )IR");
Function *F = M->getFunction("foo"); Function *F = M->getFunction("foo");
DominatorTree DT(*F); DominatorTree DT(*F);
BasicBlock *DestBlock; BasicBlock *DestBlock = getBasicBlockByName(*F, "bb2");
DestBlock = getBasicBlockByName(*F, "bb2");
ASSERT_DEATH( ASSERT_DEATH(
{ {
DestBlock->splitBasicBlockBefore(DestBlock->front().getIterator(), DestBlock->splitBasicBlockBefore(DestBlock->front().getIterator(),
"test"); "test");
}, },
"cannot split on multi incoming phis"); "cannot split on multi incoming phis");
} }
#endif #endif
TEST(BasicBlockUtils, NoUnreachableBlocksToEliminate) { TEST(BasicBlockUtils, NoUnreachableBlocksToEliminate) {
LLVMContext C; LLVMContext C;
std::unique_ptr<Module> M = parseIR(C, R"IR(
std::unique_ptr<Module> M = parseIR( define i32 @no_unreachable(i1 %cond) {
C, entry:
"define i32 @no_unreachable(i1 %cond) {\n" br i1 %cond, label %bb0, label %bb1
"entry:\n" bb0:
" br i1 %cond, label %bb0, label %bb1\n" br label %bb1
"bb0:\n" bb1:
" br label %bb1\n" %phi = phi i32 [ 0, %entry ], [ 1, %bb0 ]
"bb1:\n" ret i32 %phi
" %phi = phi i32 [ 0, %entry ], [ 1, %bb0 ]" }
" ret i32 %phi\n" )IR");
"}\n" Function *F = M->getFunction("no_unreachable");
"\n"
);
auto *F = M->getFunction("no_unreachable");
DominatorTree DT(*F); DominatorTree DT(*F);
DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager); DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager);
EXPECT_EQ(F->size(), (size_t)3); EXPECT_EQ(F->size(), (size_t)3);
bool Result = EliminateUnreachableBlocks(*F, &DTU); bool Result = EliminateUnreachableBlocks(*F, &DTU);
EXPECT_FALSE(Result); EXPECT_FALSE(Result);
EXPECT_EQ(F->size(), (size_t)3); EXPECT_EQ(F->size(), (size_t)3);
EXPECT_TRUE(DT.verify()); EXPECT_TRUE(DT.verify());
} }
TEST(BasicBlockUtils, SplitBlockPredecessors) { TEST(BasicBlockUtils, SplitBlockPredecessors) {
LLVMContext C; LLVMContext C;
std::unique_ptr<Module> M = parseIR(C, R"IR(
std::unique_ptr<Module> M = parseIR( define i32 @basic_func(i1 %cond) {
C, entry:
"define i32 @basic_func(i1 %cond) {\n" br i1 %cond, label %bb0, label %bb1
"entry:\n" bb0:
" br i1 %cond, label %bb0, label %bb1\n" br label %bb1
"bb0:\n" bb1:
" br label %bb1\n" %phi = phi i32 [ 0, %entry ], [ 1, %bb0 ]
"bb1:\n" ret i32 %phi
" %phi = phi i32 [ 0, %entry ], [ 1, %bb0 ]" }
" ret i32 %phi\n" )IR");
"}\n" Function *F = M->getFunction("basic_func");
"\n"
);
auto *F = M->getFunction("basic_func");
DominatorTree DT(*F); DominatorTree DT(*F);
// Make sure the dominator tree is properly updated if calling this on the // Make sure the dominator tree is properly updated if calling this on the
// entry block. // entry block.
SplitBlockPredecessors(&F->getEntryBlock(), {}, "split.entry", &DT); SplitBlockPredecessors(&F->getEntryBlock(), {}, "split.entry", &DT);
EXPECT_TRUE(DT.verify()); EXPECT_TRUE(DT.verify());
} }
TEST(BasicBlockUtils, SplitCriticalEdge) { TEST(BasicBlockUtils, SplitCriticalEdge) {
LLVMContext C; LLVMContext C;
std::unique_ptr<Module> M = parseIR(C, R"IR(
std::unique_ptr<Module> M = parseIR( define void @crit_edge(i1 %cond0, i1 %cond1) {
C, entry:
"define void @crit_edge(i1 %cond0, i1 %cond1) {\n" br i1 %cond0, label %bb0, label %bb1
"entry:\n" bb0:
" br i1 %cond0, label %bb0, label %bb1\n" br label %bb1
"bb0:\n" bb1:
" br label %bb1\n" br label %bb2
"bb1:\n" bb2:
" br label %bb2\n" ret void
"bb2:\n" }
" ret void\n" )IR");
"}\n" Function *F = M->getFunction("crit_edge");
"\n"
);
auto *F = M->getFunction("crit_edge");
DominatorTree DT(*F); DominatorTree DT(*F);
PostDominatorTree PDT(*F); PostDominatorTree PDT(*F);
CriticalEdgeSplittingOptions CESO(&DT, nullptr, nullptr, &PDT); CriticalEdgeSplittingOptions CESO(&DT, nullptr, nullptr, &PDT);
EXPECT_EQ(1u, SplitAllCriticalEdges(*F, CESO)); EXPECT_EQ(1u, SplitAllCriticalEdges(*F, CESO));
EXPECT_TRUE(DT.verify()); EXPECT_TRUE(DT.verify());
EXPECT_TRUE(PDT.verify()); EXPECT_TRUE(PDT.verify());
} }
TEST(BasicBlockUtils, SplitIndirectBrCriticalEdge) { TEST(BasicBlockUtils, SplitIndirectBrCriticalEdge) {
LLVMContext C; LLVMContext C;
std::unique_ptr<Module> M = parseIR(C, R"IR(
std::unique_ptr<Module> M = define void @crit_edge(i8* %cond0, i1 %cond1) {
parseIR(C, "define void @crit_edge(i8* %cond0, i1 %cond1) {\n" entry:
"entry:\n" indirectbr i8* %cond0, [label %bb0, label %bb1]
" indirectbr i8* %cond0, [label %bb0, label %bb1]\n" bb0:
"bb0:\n" br label %bb1
" br label %bb1\n" bb1:
"bb1:\n" %p = phi i32 [0, %bb0], [0, %entry]
" %p = phi i32 [0, %bb0], [0, %entry]\n" br i1 %cond1, label %bb2, label %bb3
" br i1 %cond1, label %bb2, label %bb3\n" bb2:
"bb2:\n" ret void
" ret void\n" bb3:
"bb3:\n" ret void
" ret void\n" }
"}\n"); )IR");
Function *F = M->getFunction("crit_edge");
auto *F = M->getFunction("crit_edge");
DominatorTree DT(*F); DominatorTree DT(*F);
LoopInfo LI(DT); LoopInfo LI(DT);
BranchProbabilityInfo BPI(*F, LI); BranchProbabilityInfo BPI(*F, LI);
BlockFrequencyInfo BFI(*F, BPI, LI); BlockFrequencyInfo BFI(*F, BPI, LI);
auto Block = [&F](StringRef BBName) -> const BasicBlock & { ASSERT_TRUE(SplitIndirectBrCriticalEdges(*F, &BPI, &BFI));
for (auto &BB : *F)
if (BB.getName() == BBName)
return BB;
llvm_unreachable("Block not found");
};
bool Split = SplitIndirectBrCriticalEdges(*F, &BPI, &BFI);
EXPECT_TRUE(Split);
// Check that successors of the split block get their probability correct. // Check that successors of the split block get their probability correct.
BasicBlock *SplitBB = Block("bb1").getTerminator()->getSuccessor(0); BasicBlock *BB1 = getBasicBlockByName(*F, "bb1");
BasicBlock *SplitBB = BB1->getTerminator()->getSuccessor(0);
EXPECT_EQ(2u, SplitBB->getTerminator()->getNumSuccessors()); EXPECT_EQ(2u, SplitBB->getTerminator()->getNumSuccessors());
EXPECT_EQ(BranchProbability(1, 2), BPI.getEdgeProbability(SplitBB, 0u)); EXPECT_EQ(BranchProbability(1, 2), BPI.getEdgeProbability(SplitBB, 0u));
EXPECT_EQ(BranchProbability(1, 2), BPI.getEdgeProbability(SplitBB, 1u)); EXPECT_EQ(BranchProbability(1, 2), BPI.getEdgeProbability(SplitBB, 1u));
} }
TEST(BasicBlockUtils, SetEdgeProbability) { TEST(BasicBlockUtils, SetEdgeProbability) {
LLVMContext C; LLVMContext C;
std::unique_ptr<Module> M = parseIR(C, R"IR(
std::unique_ptr<Module> M = parseIR( define void @edge_probability(i32 %0) {
C, "define void @edge_probability(i32 %0) {\n" entry:
"entry:\n" switch i32 %0, label %LD [
"switch i32 %0, label %LD [\n" i32 700, label %L0
" i32 700, label %L0\n" i32 701, label %L1
" i32 701, label %L1\n" i32 702, label %L2
" i32 702, label %L2\n" i32 703, label %L3
" i32 703, label %L3\n" i32 704, label %L4
" i32 704, label %L4\n" i32 705, label %L5
" i32 705, label %L5\n" i32 706, label %L6
" i32 706, label %L6\n" i32 707, label %L7
" i32 707, label %L7\n" i32 708, label %L8
" i32 708, label %L8\n" i32 709, label %L9
" i32 709, label %L9\n" i32 710, label %L10
" i32 710, label %L10\n" i32 711, label %L11
" i32 711, label %L11\n" i32 712, label %L12
" i32 712, label %L12\n" i32 713, label %L13
" i32 713, label %L13\n" i32 714, label %L14
" i32 714, label %L14\n" i32 715, label %L15
" i32 715, label %L15\n" i32 716, label %L16
" i32 716, label %L16\n" i32 717, label %L17
" i32 717, label %L17\n" i32 718, label %L18
" i32 718, label %L18\n" i32 719, label %L19
" i32 719, label %L19\n" ], !prof !{!"branch_weights", i32 1, i32 1, i32 1, i32 1, i32 1, i32 451, i32 1,
"], !prof !{!\"branch_weights\", i32 1, i32 1, i32 1, i32 1, i32 1, " i32 12, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1,
"i32 451, i32 1, i32 12, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, " i32 1, i32 1, i32 1, i32 1, i32 1}
"i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1}\n" LD:
"LD:\n" unreachable
" unreachable\n" L0:
"L0:\n" ret void
" ret void\n" L1:
"L1:\n" ret void
" ret void\n" L2:
"L2:\n" ret void
" ret void\n" L3:
"L3:\n" ret void
" ret void\n" L4:
"L4:\n" ret void
" ret void\n" L5:
"L5:\n" ret void
" ret void\n" L6:
"L6:\n" ret void
" ret void\n" L7:
"L7:\n" ret void
" ret void\n" L8:
"L8:\n" ret void
" ret void\n" L9:
"L9:\n" ret void
" ret void\n" L10:
"L10:\n" ret void
" ret void\n" L11:
"L11:\n" ret void
" ret void\n" L12:
"L12:\n" ret void
" ret void\n" L13:
"L13:\n" ret void
" ret void\n" L14:
"L14:\n" ret void
" ret void\n" L15:
"L15:\n" ret void
" ret void\n" L16:
"L16:\n" ret void
" ret void\n" L17:
"L17:\n" ret void
" ret void\n" L18:
"L18:\n" ret void
" ret void\n" L19:
"L19:\n" ret void
" ret void\n" }
"}\n"); )IR");
Function *F = M->getFunction("edge_probability");
auto *F = M->getFunction("edge_probability");
DominatorTree DT(*F); DominatorTree DT(*F);
LoopInfo LI(DT); LoopInfo LI(DT);
BranchProbabilityInfo BPI(*F, LI); BranchProbabilityInfo BPI(*F, LI);
auto Block = [&F](StringRef BBName) -> const BasicBlock & {
for (auto &BB : *F)
if (BB.getName() == BBName)
return BB;
llvm_unreachable("Block not found");
};
// Check that the unreachable block has the minimal probability. // Check that the unreachable block has the minimal probability.
const BasicBlock &EntryBB = Block("entry"); const BasicBlock *EntryBB = getBasicBlockByName(*F, "entry");
const BasicBlock &UnreachableBB = Block("LD"); const BasicBlock *UnreachableBB = getBasicBlockByName(*F, "LD");
EXPECT_EQ(BranchProbability::getRaw(1), EXPECT_EQ(BranchProbability::getRaw(1),
BPI.getEdgeProbability(&EntryBB, &UnreachableBB)); BPI.getEdgeProbability(EntryBB, UnreachableBB));
} }