48#include "llvm/Config/llvm-config.h"
69#define DEBUG_TYPE "branch-folder"
71STATISTIC(NumDeadBlocks,
"Number of dead blocks removed");
72STATISTIC(NumBranchOpts,
"Number of branches optimized");
73STATISTIC(NumTailMerge ,
"Number of block tails merged");
74STATISTIC(NumHoist ,
"Number of times common instructions are hoisted");
75STATISTIC(NumTailCalls,
"Number of tail calls optimized");
81 bool EnableCommonHoist;
82 bool EnableBasicBlockReordering;
87 explicit BranchFolderLegacy(
bool EnableCommonHoist =
true,
88 bool EnableBasicBlockReordering =
true)
90 EnableBasicBlockReordering(EnableBasicBlockReordering) {}
94 void getAnalysisUsage(AnalysisUsage &AU)
const override {
95 AU.
addRequired<MachineBlockFrequencyInfoWrapperPass>();
96 AU.
addRequired<MachineBranchProbabilityInfoWrapperPass>();
103 MachineFunctionProperties getRequiredProperties()
const override {
104 return MachineFunctionProperties().setNoPHIs();
110char BranchFolderLegacy::ID = 0;
120 bool EnableTailMerge =
121 !MF.getTarget().requiresStructuredCFG() && this->EnableTailMerge;
125 .getCachedResult<ProfileSummaryAnalysis>(
126 *MF.getFunction().getParent());
129 "ProfileSummaryAnalysis is required for BranchFoldingPass",
false);
133 BranchFolder Folder(EnableTailMerge,
true, MBBFreqInfo, MBPI,
135 Folder.setBasicBlockReordering(
true);
136 if (Folder.OptimizeFunction(MF, MF.getSubtarget().getInstrInfo(),
137 MF.getSubtarget().getRegisterInfo()))
147 TargetPassConfig *PassConfig = &getAnalysis<TargetPassConfig>();
152 MBFIWrapper MBBFreqInfo(
153 getAnalysis<MachineBlockFrequencyInfoWrapperPass>().getMBFI());
155 EnableTailMerge, EnableCommonHoist, MBBFreqInfo,
156 getAnalysis<MachineBranchProbabilityInfoWrapperPass>().getMBPI(),
157 &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI());
158 Folder.setBasicBlockReordering(EnableBasicBlockReordering);
167 : EnableTailMerge(DefaultEnableTailMerge),
168 EnableHoistCommonCode(CommonHoist), EnableBasicBlockReordering(
true),
169 MinCommonTailLength(MinTailLength), MBBFreqInfo(FreqInfo), MBPI(ProbInfo),
173 assert(
MBB->pred_empty() &&
"MBB must be dead!");
178 while (!
MBB->succ_empty())
179 MBB->removeSuccessor(
MBB->succ_end()-1);
182 TriedMerging.erase(
MBB);
186 if (
MI.shouldUpdateAdditionalCallInfo())
193 EHScopeMembership.erase(
MBB);
200 if (!tii)
return false;
202 TriedMerging.clear();
205 AfterBlockPlacement = AfterPlacement;
212 if (MinCommonTailLength == 0) {
213 MinCommonTailLength =
214 Opts->tail_merge_size.value_or(TII->getTailMergeSize(MF));
217 UpdateLiveIns = MRI.tracksLiveness() && TRI->trackLivenessAfterRegAlloc(MF);
219 MRI.invalidateLiveness();
224 EnableTailMerge =
valueOr(Opts->tail_merge, EnableTailMerge);
225 EnableHoistCommonCode =
226 valueOr(Opts->branch_folder_hoist_common_code, EnableHoistCommonCode);
227 EnableBasicBlockReordering =
228 valueOr(Opts->branch_folder_reorder_blocks, EnableBasicBlockReordering);
230 bool MadeChange =
false;
235 bool MadeChangeThisIteration =
true;
236 while (MadeChangeThisIteration) {
237 MadeChangeThisIteration = TailMergeBlocks(MF);
240 if (!AfterBlockPlacement || MadeChangeThisIteration)
241 MadeChangeThisIteration |= OptimizeBranches(MF);
242 if (EnableHoistCommonCode)
243 MadeChangeThisIteration |= HoistCommonCode(MF);
244 MadeChange |= MadeChangeThisIteration;
258 if (!
Op.isJTI())
continue;
261 JTIsLive.
set(
Op.getIndex());
267 for (
unsigned i = 0, e = JTIsLive.
size(); i != e; ++i)
268 if (!JTIsLive.
test(i)) {
282 unsigned Hash =
MI.getOpcode();
283 for (
unsigned i = 0, e =
MI.getNumOperands(); i != e; ++i) {
289 unsigned OperandHash = 0;
290 switch (
Op.getType()) {
292 OperandHash =
Op.getReg().id();
295 OperandHash =
Op.getImm();
298 OperandHash =
Op.getMBB()->getNumber();
303 OperandHash =
Op.getIndex();
309 OperandHash =
Op.getOffset();
315 Hash += ((OperandHash << 3) |
Op.getType()) << (i & 31);
331 return !(
MI.isDebugInstr() ||
MI.isCFIInstruction());
335 if (
MI.isPseudoProbe())
347 if (!IsSensitive1 && !IsSensitive2)
349 if (IsSensitive1 != IsSensitive2)
361 while (
I !=
MBB->begin()) {
382 unsigned TailLen = 0;
386 if (MBBI1 == MBB1->
end() || MBBI2 == MBB2->
end())
388 if (!MBBI1->isIdenticalTo(*MBBI2) ||
395 MBBI1->isInlineAsm()) {
413 MachineBasicBlock &OldMBB = *OldInst->getParent();
415 LiveRegs.addLiveOuts(OldMBB);
420 LiveRegs.stepBackward(*
I);
421 }
while (
I != OldInst);
426 for (MachineBasicBlock::RegisterMaskPair
P : NewDest.
liveins()) {
430 "Can only handle full register.");
431 MCRegister
Reg =
P.PhysReg;
432 if (!LiveRegs.available(*MRI,
Reg))
435 BuildMI(OldMBB, OldInst,
DL, TII->get(TargetOpcode::IMPLICIT_DEF),
Reg);
439 TII->ReplaceTailWithBranchTo(OldInst, &NewDest);
446 if (!TII->isLegalToSplitMBBAt(CurMBB, BBI1))
463 NewMBB->
splice(NewMBB->
end(), &CurMBB, BBI1, CurMBB.
end());
467 if (MachineLoop *
ML = MLI->getLoopFor(&CurMBB))
468 ML->addBasicBlockToLoop(NewMBB, *MLI);
471 MBBFreqInfo.setBlockFreq(NewMBB, MBBFreqInfo.getBlockFreq(&CurMBB));
477 const auto &EHScopeI = EHScopeMembership.find(&CurMBB);
478 if (EHScopeI != EHScopeMembership.end()) {
479 auto n = EHScopeI->second;
480 EHScopeMembership[NewMBB] = n;
491 for (;
I !=
E; ++
I) {
496 else if (
I->mayLoadOrStore())
517 if (
I != MF->
end() && !
TII->analyzeBranch(*CurMBB,
TBB, FBB,
Cond,
true)) {
519 if (
TBB == NextBB && !
Cond.empty() && !FBB) {
520 if (!
TII->reverseBranchCondition(
Cond)) {
521 TII->removeBranch(*CurMBB);
522 TII->insertBranch(*CurMBB, SuccBB,
nullptr,
Cond, dl);
527 TII->insertBranch(*CurMBB, SuccBB,
nullptr,
532BranchFolder::MergePotentialsElt::operator<(
const MergePotentialsElt &o)
const {
533 if (getHash() <
o.getHash())
535 if (getHash() >
o.getHash())
537 if (getBlock()->getNumber() <
o.getBlock()->getNumber())
539 if (getBlock()->getNumber() >
o.getBlock()->getNumber())
550 unsigned NumTerms = 0;
552 if (
I ==
MBB->begin()) {
557 if (!
I->isTerminator())
break;
567 if (!
MBB->succ_empty())
571 return !(
MBB->back().isReturn() ||
MBB->back().isIndirectBranch());
592 unsigned MinCommonTailLength,
unsigned &CommonTailLen,
601 if (!EHScopeMembership.
empty()) {
602 auto EHScope1 = EHScopeMembership.
find(MBB1);
603 assert(EHScope1 != EHScopeMembership.
end());
604 auto EHScope2 = EHScopeMembership.
find(MBB2);
605 assert(EHScope2 != EHScopeMembership.
end());
606 if (EHScope1->second != EHScope2->second)
611 if (CommonTailLen == 0)
615 << CommonTailLen <<
'\n');
625 bool FullBlockTail1 = I1 == MBB1->
begin();
626 bool FullBlockTail2 = I2 == MBB2->
begin();
633 if ((MBB1 == PredBB || MBB2 == PredBB) &&
634 (!AfterPlacement || MBB1->
succ_size() == 1)) {
637 if (CommonTailLen > NumTerms)
646 if (FullBlockTail1 && FullBlockTail2 &&
663 if (AfterPlacement && FullBlockTail1 && FullBlockTail2) {
665 if (!
MBB->succ_empty() && !
MBB->canFallThrough())
669 return (
MBB != &*MF->
begin()) && std::prev(
I)->canFallThrough();
671 if (!BothFallThrough(MBB1) || !BothFallThrough(MBB2))
680 unsigned EffectiveTailLen = CommonTailLen;
681 if (SuccBB && MBB1 != PredBB && MBB2 != PredBB &&
682 (MBB1->
succ_size() == 1 || !AfterPlacement) &&
688 if (EffectiveTailLen >= MinCommonTailLength)
697 return EffectiveTailLen >= 2 && OptForSize &&
698 (FullBlockTail1 || FullBlockTail2);
701unsigned BranchFolder::ComputeSameTails(
unsigned CurHash,
702 unsigned MinCommonTailLength,
703 MachineBasicBlock *SuccBB,
704 MachineBasicBlock *PredBB) {
705 unsigned maxCommonTailLength = 0
U;
708 MPIterator HighestMPIter = std::prev(MergePotentials.end());
709 for (MPIterator CurMPIter = std::prev(MergePotentials.end()),
710 B = MergePotentials.begin();
711 CurMPIter !=
B && CurMPIter->getHash() == CurHash; --CurMPIter) {
712 for (MPIterator
I = std::prev(CurMPIter);
I->getHash() == CurHash; --
I) {
713 unsigned CommonTailLen;
716 CommonTailLen, TrialBBI1, TrialBBI2,
719 AfterBlockPlacement, MBBFreqInfo, PSI)) {
720 if (CommonTailLen > maxCommonTailLength) {
722 maxCommonTailLength = CommonTailLen;
723 HighestMPIter = CurMPIter;
724 SameTails.push_back(SameTailElt(CurMPIter, TrialBBI1));
726 if (HighestMPIter == CurMPIter &&
727 CommonTailLen == maxCommonTailLength)
728 SameTails.push_back(SameTailElt(
I, TrialBBI2));
734 return maxCommonTailLength;
737void BranchFolder::RemoveBlocksWithHash(
unsigned CurHash,
738 MachineBasicBlock *SuccBB,
739 MachineBasicBlock *PredBB,
741 MPIterator CurMPIter,
B;
742 for (CurMPIter = std::prev(MergePotentials.end()),
743 B = MergePotentials.begin();
744 CurMPIter->getHash() == CurHash; --CurMPIter) {
746 MachineBasicBlock *CurMBB = CurMPIter->getBlock();
747 if (SuccBB && CurMBB != PredBB)
748 FixTail(CurMBB, SuccBB, TII, BranchDL);
752 if (CurMPIter->getHash() != CurHash)
754 MergePotentials.erase(CurMPIter, MergePotentials.end());
757bool BranchFolder::CreateCommonTailOnlyBlock(MachineBasicBlock *&PredBB,
758 MachineBasicBlock *SuccBB,
759 unsigned maxCommonTailLength,
760 unsigned &commonTailIndex) {
762 unsigned TimeEstimate = ~0
U;
763 for (
unsigned i = 0, e = SameTails.size(); i != e; ++i) {
765 if (SameTails[i].getBlock() == PredBB) {
772 SameTails[i].getTailStartPos());
773 if (t <= TimeEstimate) {
780 SameTails[commonTailIndex].getTailStartPos();
781 MachineBasicBlock *
MBB = SameTails[commonTailIndex].getBlock();
784 << maxCommonTailLength);
791 MachineBasicBlock *newMBB = SplitMBBAt(*
MBB, BBI, BB);
797 SameTails[commonTailIndex].setBlock(newMBB);
798 SameTails[commonTailIndex].setTailStartPos(newMBB->
begin());
823 unsigned CommonTailLen = 0;
824 for (
auto E =
MBB->end(); MBBIStartPos !=
E; ++MBBIStartPos)
832 while (CommonTailLen--) {
833 assert(
MBBI != MBBIE &&
"Reached BB end within common tail length!");
844 assert(MBBICommon != MBBIECommon &&
845 "Reached BB end within common tail length!");
846 assert(MBBICommon->isIdenticalTo(*
MBBI) &&
"Expected matching MIIs!");
849 if (MBBICommon->mayLoadOrStore())
850 MBBICommon->cloneMergedMemRefs(*
MBB->getParent(), {&*MBBICommon, &*MBBI});
860void BranchFolder::mergeCommonTails(
unsigned commonTailIndex) {
861 MachineBasicBlock *
MBB = SameTails[commonTailIndex].getBlock();
863 std::vector<MachineBasicBlock::iterator> NextCommonInsts(SameTails.size());
864 for (
unsigned int i = 0 ; i != SameTails.size() ; ++i) {
865 if (i != commonTailIndex) {
866 NextCommonInsts[i] = SameTails[i].getTailStartPos();
870 "MBB is not a common tail only block");
874 for (
auto &
MI : *
MBB) {
878 for (
unsigned int i = 0 ; i < NextCommonInsts.size() ; i++) {
879 if (i == commonTailIndex)
882 auto &Pos = NextCommonInsts[i];
883 assert(Pos != SameTails[i].getBlock()->
end() &&
884 "Reached BB end within common tail");
887 assert(Pos != SameTails[i].getBlock()->
end() &&
888 "Reached BB end within common tail");
890 assert(
MI.isIdenticalTo(*Pos) &&
"Expected matching MIIs!");
892 NextCommonInsts[i] = ++Pos;
898 LivePhysRegs NewLiveIns(*TRI);
906 LiveRegs.addLiveOuts(*
Pred);
909 if (!LiveRegs.available(*MRI,
Reg))
915 return NewLiveIns.contains(SReg) && !MRI->isReserved(SReg);
920 BuildMI(*
Pred, InsertBefore,
DL, TII->get(TargetOpcode::IMPLICIT_DEF),
939bool BranchFolder::TryTailMergeBlocks(MachineBasicBlock *SuccBB,
940 MachineBasicBlock *PredBB,
941 unsigned MinCommonTailLength) {
942 bool MadeChange =
false;
945 dbgs() <<
"\nTryTailMergeBlocks: ";
946 for (
unsigned i = 0, e = MergePotentials.size(); i != e; ++i)
948 << (i ==
e - 1 ?
"" :
", ");
956 dbgs() <<
"Looking for common tails of at least " << MinCommonTailLength
957 <<
" instruction" << (MinCommonTailLength == 1 ?
"" :
"s") <<
'\n';
965 while (MergePotentials.size() > 1) {
966 unsigned CurHash = MergePotentials.back().getHash();
967 const DebugLoc &BranchDL = MergePotentials.back().getBranchDebugLoc();
971 unsigned maxCommonTailLength = ComputeSameTails(CurHash,
977 if (SameTails.empty()) {
978 RemoveBlocksWithHash(CurHash, SuccBB, PredBB, BranchDL);
986 MachineBasicBlock *EntryBB =
987 &MergePotentials.front().getBlock()->getParent()->front();
988 unsigned commonTailIndex = SameTails.size();
991 if (SameTails.size() == 2 &&
992 SameTails[0].getBlock()->isLayoutSuccessor(SameTails[1].getBlock()) &&
993 SameTails[1].tailIsWholeBlock() && !SameTails[1].getBlock()->isEHPad())
995 else if (SameTails.size() == 2 &&
996 SameTails[1].getBlock()->isLayoutSuccessor(
997 SameTails[0].getBlock()) &&
998 SameTails[0].tailIsWholeBlock() &&
999 !SameTails[0].getBlock()->isEHPad())
1000 commonTailIndex = 0;
1004 for (
unsigned i = 0, e = SameTails.size(); i != e; ++i) {
1005 MachineBasicBlock *
MBB = SameTails[i].getBlock();
1007 SameTails[i].tailIsWholeBlock())
1009 if (
MBB == PredBB) {
1010 commonTailIndex = i;
1013 if (SameTails[i].tailIsWholeBlock())
1014 commonTailIndex = i;
1018 if (commonTailIndex == SameTails.size() ||
1019 (SameTails[commonTailIndex].getBlock() == PredBB &&
1020 !SameTails[commonTailIndex].tailIsWholeBlock())) {
1023 if (!CreateCommonTailOnlyBlock(PredBB, SuccBB,
1024 maxCommonTailLength, commonTailIndex)) {
1025 RemoveBlocksWithHash(CurHash, SuccBB, PredBB, BranchDL);
1030 MachineBasicBlock *
MBB = SameTails[commonTailIndex].getBlock();
1033 setCommonTailEdgeWeights(*
MBB);
1037 mergeCommonTails(commonTailIndex);
1043 for (
unsigned int i=0, e = SameTails.size(); i != e; ++i) {
1044 if (commonTailIndex == i)
1047 << (i == e - 1 ?
"" :
", "));
1049 replaceTailWithBranchTo(SameTails[i].getTailStartPos(), *
MBB);
1051 MergePotentials.erase(SameTails[i].getMPIter());
1062 bool MadeChange =
false;
1063 if (!EnableTailMerge)
1068 MergePotentials.clear();
1069 for (MachineBasicBlock &
MBB : MF) {
1070 if (MergePotentials.size() == Opts->tail_merge_threshold)
1079 if (MergePotentials.size() == Opts->tail_merge_threshold)
1080 for (
const MergePotentialsElt &Elt : MergePotentials)
1081 TriedMerging.insert(Elt.getBlock());
1084 if (MergePotentials.size() >= 2)
1085 MadeChange |= TryTailMergeBlocks(
nullptr,
nullptr, MinCommonTailLength);
1108 if (
I->pred_size() < 2)
continue;
1109 SmallPtrSet<MachineBasicBlock *, 8> UniquePreds;
1110 MachineBasicBlock *IBB = &*
I;
1111 MachineBasicBlock *PredBB = &*std::prev(
I);
1112 MergePotentials.clear();
1125 if (AfterBlockPlacement && MLI) {
1126 ML = MLI->getLoopFor(IBB);
1127 if (
ML && IBB ==
ML->getHeader())
1131 for (MachineBasicBlock *PBB :
I->predecessors()) {
1132 if (MergePotentials.size() == Opts->tail_merge_threshold)
1135 if (TriedMerging.count(PBB))
1143 if (!UniquePreds.
insert(PBB).second)
1148 if (PBB->hasEHPadSuccessor() || PBB->mayHaveInlineAsmBr())
1154 if (AfterBlockPlacement && MLI)
1155 if (
ML != MLI->getLoopFor(PBB))
1158 MachineBasicBlock *
TBB =
nullptr, *FBB =
nullptr;
1159 SmallVector<MachineOperand, 4>
Cond;
1160 if (!TII->analyzeBranch(*PBB,
TBB, FBB,
Cond,
true)) {
1163 SmallVector<MachineOperand, 4> NewCond(
Cond);
1165 if (TII->reverseBranchCondition(NewCond))
1169 auto Next = ++PBB->getIterator();
1170 if (
Next != MF.end())
1176 DebugLoc dl = PBB->findBranchDebugLoc();
1178 TII->removeBranch(*PBB);
1181 TII->insertBranch(*PBB, (
TBB == IBB) ? FBB :
TBB,
nullptr,
1185 MergePotentials.push_back(
1192 if (MergePotentials.size() == Opts->tail_merge_threshold)
1193 for (MergePotentialsElt &Elt : MergePotentials)
1194 TriedMerging.insert(Elt.getBlock());
1196 if (MergePotentials.size() >= 2)
1197 MadeChange |= TryTailMergeBlocks(IBB, PredBB, MinCommonTailLength);
1201 PredBB = &*std::prev(
I);
1202 if (MergePotentials.size() == 1 &&
1203 MergePotentials.begin()->getBlock() != PredBB)
1204 FixTail(MergePotentials.begin()->getBlock(), IBB, TII,
1205 MergePotentials.begin()->getBranchDebugLoc());
1211void BranchFolder::setCommonTailEdgeWeights(MachineBasicBlock &TailMBB) {
1213 BlockFrequency AccumulatedMBBFreq;
1218 for (
const auto &Src : SameTails) {
1219 const MachineBasicBlock *SrcMBB = Src.getBlock();
1220 BlockFrequency BlockFreq = MBBFreqInfo.getBlockFreq(SrcMBB);
1221 AccumulatedMBBFreq += BlockFreq;
1228 auto EdgeFreq = EdgeFreqLs.begin();
1231 SuccI != SuccE; ++SuccI, ++EdgeFreq)
1232 *EdgeFreq += BlockFreq * MBPI.getEdgeProbability(SrcMBB, *SuccI);
1235 MBBFreqInfo.setBlockFreq(&TailMBB, AccumulatedMBBFreq);
1241 std::accumulate(EdgeFreqLs.begin(), EdgeFreqLs.end(), BlockFrequency(0))
1243 auto EdgeFreq = EdgeFreqLs.begin();
1245 if (SumEdgeFreq > 0) {
1247 SuccI != SuccE; ++SuccI, ++EdgeFreq) {
1249 EdgeFreq->getFrequency(), SumEdgeFreq);
1260 bool MadeChange =
false;
1267 for (MachineBasicBlock &
MBB :
1269 MadeChange |= OptimizeBlock(&
MBB);
1274 RemoveDeadBlock(&
MBB);
1286 return MBB->getFirstNonDebugInstr(
true) ==
MBB->end();
1294 return I->isBranch();
1303 assert(MBB1 && MBB2 &&
"Unknown MachineBasicBlock");
1311 if (MBB1I == MBB1->
end() || MBB2I == MBB2->
end())
1319 return MBB2I->isCall() && !MBB1I->isCall();
1327 if (
MI.isDebugInstr()) {
1328 TII->duplicate(PredMBB, InsertBefore,
MI);
1329 LLVM_DEBUG(
dbgs() <<
"Copied debug entity from empty block to pred: "
1339 if (
MI.isDebugInstr()) {
1340 TII->duplicate(SuccMBB, InsertBefore,
MI);
1341 LLVM_DEBUG(
dbgs() <<
"Copied debug entity from empty block to succ: "
1371 return !CurCond.
empty() &&
1374 return LHS.isIdenticalTo(
RHS);
1378bool BranchFolder::OptimizeBlock(MachineBasicBlock *
MBB) {
1379 bool MadeChange =
false;
1387 bool SameEHScope =
true;
1388 if (!EHScopeMembership.empty() && FallThrough != MF.
end()) {
1389 auto MBBEHScope = EHScopeMembership.find(
MBB);
1390 assert(MBBEHScope != EHScopeMembership.end());
1391 auto FallThroughEHScope = EHScopeMembership.find(&*FallThrough);
1392 assert(FallThroughEHScope != EHScopeMembership.end());
1393 SameEHScope = MBBEHScope->second == FallThroughEHScope->second;
1398 MachineBasicBlock *CurTBB =
nullptr, *CurFBB =
nullptr;
1399 SmallVector<MachineOperand, 4> CurCond;
1400 bool CurUnAnalyzable =
1401 TII->analyzeBranch(*
MBB, CurTBB, CurFBB, CurCond,
true);
1413 if (FallThrough == MF.
end()) {
1415 }
else if (FallThrough->isEHPad()) {
1425 Pred->ReplaceUsesOfBlockWith(
MBB, &*FallThrough);
1431 if (*SI != &*FallThrough && !FallThrough->isSuccessor(*SI)) {
1432 assert((*SI)->isEHPad() &&
"Bad CFG");
1433 FallThrough->copySuccessor(
MBB, SI);
1438 MJTI->ReplaceMBBInJumpTables(
MBB, &*FallThrough);
1448 MachineBasicBlock *PriorTBB =
nullptr, *PriorFBB =
nullptr;
1449 SmallVector<MachineOperand, 4> PriorCond;
1450 bool PriorUnAnalyzable =
1451 TII->analyzeBranch(PrevBB, PriorTBB, PriorFBB, PriorCond,
true);
1452 if (!PriorUnAnalyzable) {
1456 if (PriorTBB && PriorTBB == PriorFBB) {
1458 TII->removeBranch(PrevBB);
1460 if (PriorTBB !=
MBB)
1461 TII->insertBranch(PrevBB, PriorTBB,
nullptr, PriorCond, Dl);
1464 goto ReoptimizeBlock;
1478 <<
"From MBB: " << *
MBB);
1480 if (!PrevBB.
empty()) {
1486 while (PrevBBIter != PrevBB.
begin() && MBBIter !=
MBB->
end()
1487 && PrevBBIter->isDebugInstr() && MBBIter->isDebugInstr()) {
1488 if (!MBBIter->isIdenticalTo(*PrevBBIter))
1490 MachineInstr &DuplicateDbg = *MBBIter;
1491 ++MBBIter; -- PrevBBIter;
1505 if (PriorTBB ==
MBB && !PriorFBB) {
1506 TII->removeBranch(PrevBB);
1509 goto ReoptimizeBlock;
1514 if (PriorFBB ==
MBB) {
1516 TII->removeBranch(PrevBB);
1517 TII->insertBranch(PrevBB, PriorTBB,
nullptr, PriorCond, Dl);
1520 goto ReoptimizeBlock;
1526 if (PriorTBB ==
MBB) {
1527 SmallVector<MachineOperand, 4> NewPriorCond(PriorCond);
1528 if (!TII->reverseBranchCondition(NewPriorCond)) {
1530 TII->removeBranch(PrevBB);
1531 TII->insertBranch(PrevBB, PriorFBB,
nullptr, NewPriorCond, Dl);
1534 goto ReoptimizeBlock;
1547 TII->removeBranch(PrevBB);
1551 goto ReoptimizeBlock;
1565 bool DoTransform =
true;
1572 if (FallThrough == --MF.
end() &&
1574 DoTransform =
false;
1578 SmallVector<MachineOperand, 4> NewPriorCond(PriorCond);
1579 if (!TII->reverseBranchCondition(NewPriorCond)) {
1581 <<
"To make fallthrough to: " << *PriorTBB <<
"\n");
1584 TII->removeBranch(PrevBB);
1585 TII->insertBranch(PrevBB,
MBB,
nullptr, NewPriorCond, Dl);
1599 if (TII->isUnconditionalTailCall(TailCall)) {
1602 MachineBasicBlock *PredTBB =
nullptr, *PredFBB =
nullptr;
1603 SmallVector<MachineOperand, 4> PredCond;
1604 bool PredAnalyzable =
1605 !TII->analyzeBranch(*
Pred, PredTBB, PredFBB, PredCond,
true);
1608 if (PredAnalyzable && !PredCond.
empty() && PredTBB ==
MBB &&
1609 PredTBB != PredFBB) {
1613 if (TII->canMakeTailCallConditional(PredCond, TailCall)) {
1617 TII->replaceBranchWithTailCall(*
Pred, PredCond, TailCall);
1627 if (!PredsChanged.
empty()) {
1628 NumTailCalls += PredsChanged.
size();
1629 for (
auto &
Pred : PredsChanged)
1637 if (!CurUnAnalyzable) {
1643 if (CurTBB && CurFBB && CurFBB ==
MBB && CurTBB !=
MBB) {
1644 SmallVector<MachineOperand, 4> NewCond(CurCond);
1645 if (!TII->reverseBranchCondition(NewCond)) {
1647 TII->removeBranch(*
MBB);
1648 TII->insertBranch(*
MBB, CurFBB, CurTBB, NewCond, Dl);
1651 goto ReoptimizeBlock;
1657 if (CurTBB && CurCond.
empty() && !CurFBB &&
1664 TII->removeBranch(*
MBB);
1680 if (PredHasNoFallThrough || !PriorUnAnalyzable ||
1685 PriorTBB !=
MBB && PriorFBB !=
MBB) {
1688 "Bad branch analysis");
1691 assert(!PriorFBB &&
"Machine CFG out of date!");
1695 TII->removeBranch(PrevBB);
1696 TII->insertBranch(PrevBB, PriorTBB, PriorFBB, PriorCond, PrevDl);
1701 bool DidChange =
false;
1702 bool HasBranchToSelf =
false;
1708 HasBranchToSelf =
true;
1718 assert((*SI)->isEHPad() &&
"Bad CFG");
1724 MachineBasicBlock *NewCurTBB =
nullptr, *NewCurFBB =
nullptr;
1725 SmallVector<MachineOperand, 4> NewCurCond;
1726 bool NewCurUnAnalyzable = TII->analyzeBranch(
1727 *PMBB, NewCurTBB, NewCurFBB, NewCurCond,
true);
1728 if (!NewCurUnAnalyzable && NewCurTBB && NewCurTBB == NewCurFBB) {
1730 TII->removeBranch(*PMBB);
1732 TII->insertBranch(*PMBB, NewCurTBB,
nullptr, NewCurCond,
1742 MJTI->ReplaceMBBInJumpTables(
MBB, CurTBB);
1746 if (!HasBranchToSelf)
return MadeChange;
1752 TII->insertBranch(*
MBB, CurTBB,
nullptr, CurCond, Dl);
1770 MachineBasicBlock *PredTBB =
nullptr, *PredFBB =
nullptr;
1771 SmallVector<MachineOperand, 4> PredCond;
1773 !TII->analyzeBranch(*PredBB, PredTBB, PredFBB, PredCond,
true) &&
1774 (PredTBB ==
MBB || PredFBB ==
MBB) &&
1775 (!CurFallsThru || !CurTBB || !CurFBB) &&
1790 TII->insertBranch(*
MBB, NextBB,
nullptr, CurCond,
DebugLoc());
1794 goto ReoptimizeBlock;
1799 if (!CurFallsThru) {
1802 if (!CurUnAnalyzable) {
1803 for (MachineBasicBlock *SuccBB : {CurFBB, CurTBB}) {
1812 if (SuccBB !=
MBB && &*SuccPrev !=
MBB &&
1813 !SuccPrev->canFallThrough()) {
1816 goto ReoptimizeBlock;
1842 MachineBasicBlock *PrevTBB =
nullptr, *PrevFBB =
nullptr;
1843 SmallVector<MachineOperand, 4> PrevCond;
1845 if (FallThrough != MF.
end() && !FallThrough->isEHPad() &&
1846 !FallThrough->isInlineAsmBrIndirectTarget() &&
1847 !TII->analyzeBranch(PrevBB, PrevTBB, PrevFBB, PrevCond,
true) &&
1864 bool MadeChange =
false;
1866 MadeChange |= HoistCommonCodeInSuccs(&
MBB);
1876 if (SuccBB != TrueBB)
1881template <
class Container>
1884 if (
Reg.isPhysical()) {
1906 if (!
TII->isUnpredicatedTerminator(*
Loc))
1947 if (!MO.isReg() || MO.isUse())
1968 bool DontMoveAcrossStore =
true;
1969 if (!PI->isSafeToMove(DontMoveAcrossStore) ||
TII->isPredicated(*PI))
1984 if (
Reg.isPhysical()) {
1996bool BranchFolder::HoistCommonCodeInSuccs(MachineBasicBlock *
MBB) {
1997 MachineBasicBlock *
TBB =
nullptr, *FBB =
nullptr;
1998 SmallVector<MachineOperand, 4>
Cond;
2009 if (
TBB->pred_size() > 1 || FBB->pred_size() > 1)
2015 SmallSet<Register, 4>
Uses, Defs;
2021 bool HasDups =
false;
2022 SmallSet<Register, 4> ActiveDefsSet, AllDefsSet;
2028 while (TIB != TIE && FIB != FIE) {
2032 if (TIB == TIE || FIB == FIE)
2038 if (TII->isPredicated(*TIB))
2042 if (!TII->isSafeToMove(*TIB,
TBB, MF))
2047 for (MachineOperand &MO : TIB->operands()) {
2049 if (MO.isRegMask()) {
2066 if (Defs.
count(
Reg) && !MO.isDead()) {
2081 }
else if (!ActiveDefsSet.
count(
Reg)) {
2088 if (MO.isKill() &&
Uses.count(
Reg))
2091 MO.setIsKill(
false);
2097 bool DontMoveAcrossStore =
true;
2098 if (!TIB->isSafeToMove(DontMoveAcrossStore))
2102 for (
const MachineOperand &MO : TIB->all_uses()) {
2112 for (MCRegAliasIterator AI(
Reg, TRI,
true); AI.isValid(); ++AI)
2113 ActiveDefsSet.
erase(*AI);
2120 for (
const MachineOperand &MO : TIB->all_defs()) {
2147 MachineInstrBuilder MIRBuilder(*
MBB->
getParent(), Loc);
2149 assert(DI->isDebugInstr() &&
"Expected a debug instruction");
2150 if (DI->isDebugRef()) {
2151 const TargetInstrInfo *TII =
2153 const MCInstrDesc &DBGV = TII->
get(TargetOpcode::DBG_VALUE);
2155 DI->getDebugVariable(), DI->getDebugExpression());
2160 if (DI->isDebugPHI()) {
2161 DI->eraseFromParent();
2165 if (!DI->isDebugLabel())
2166 DI->setDebugValueUndef();
2167 DI->moveBefore(&*Loc);
2179 while (FI != FE && FI->isDebugInstr())
2180 HoistAndKillDbgInstr(FI++);
2183 if (TI->isDebugInstr()) {
2184 HoistAndKillDbgInstr(TI);
2189 assert(FI != FE &&
"Unexpected end of FBB range");
2192 assert(!TI->isPseudoProbe() &&
"Unexpected pseudo probe in range");
2196 "Expected non-debug lockstep");
2205 TI->moveBefore(&*Loc);
2210 FBB->
erase(FBB->begin(), FIB);
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
MachineBasicBlock MachineBasicBlock::iterator MBBI
This file implements the BitVector class.
static unsigned EstimateRuntime(MachineBasicBlock::iterator I, MachineBasicBlock::iterator E)
EstimateRuntime - Make a rough estimate for how long it will take to run the specified code.
static unsigned ComputeCommonTailLength(MachineBasicBlock *MBB1, MachineBasicBlock *MBB2, MachineBasicBlock::iterator &I1, MachineBasicBlock::iterator &I2)
Given two machine basic blocks, return the number of instructions they actually have in common togeth...
static void mergeUndefFlag(MachineInstr &Merged, const MachineInstr &Other)
Ensure undef flag is preserved only when it is present in both instructions.
static MachineBasicBlock * findFalseBlock(MachineBasicBlock *BB, MachineBasicBlock *TrueBB)
findFalseBlock - BB has a fallthrough.
static void copyDebugInfoToPredecessor(const TargetInstrInfo *TII, MachineBasicBlock &MBB, MachineBasicBlock &PredMBB)
static unsigned HashMachineInstr(const MachineInstr &MI)
HashMachineInstr - Compute a hash value for MI and its operands.
static bool countsAsInstruction(const MachineInstr &MI)
Whether MI should be counted as an instruction when calculating common tail.
static unsigned CountTerminators(MachineBasicBlock *MBB, MachineBasicBlock::iterator &I)
CountTerminators - Count the number of terminators in the given block and set I to the position of th...
static bool blockEndsInUnreachable(const MachineBasicBlock *MBB)
A no successor, non-return block probably ends in unreachable and is cold.
static void salvageDebugInfoFromEmptyBlock(const TargetInstrInfo *TII, MachineBasicBlock &MBB)
static MachineBasicBlock::iterator skipBackwardPastNonInstructions(MachineBasicBlock::iterator I, MachineBasicBlock *MBB)
Iterate backwards from the given iterator I, towards the beginning of the block.
static bool haveSamePseudoProbeContext(const MachineInstr &MI1, const MachineInstr &MI2)
static void addRegAndItsAliases(Register Reg, const TargetRegisterInfo *TRI, Container &Set)
static bool areConditionalsEqual(ArrayRef< MachineOperand > CurCond, ArrayRef< MachineOperand > PriorCond)
static bool isPseudoProbeSensitiveInstruction(const MachineInstr &MI)
static bool IsEmptyBlock(MachineBasicBlock *MBB)
static bool ProfitableToMerge(MachineBasicBlock *MBB1, MachineBasicBlock *MBB2, unsigned MinCommonTailLength, unsigned &CommonTailLen, MachineBasicBlock::iterator &I1, MachineBasicBlock::iterator &I2, MachineBasicBlock *SuccBB, MachineBasicBlock *PredBB, DenseMap< const MachineBasicBlock *, int > &EHScopeMembership, bool AfterPlacement, MBFIWrapper &MBBFreqInfo, ProfileSummaryInfo *PSI)
ProfitableToMerge - Check if two machine basic blocks have a common tail and decide if it would be pr...
static void copyDebugInfoToSuccessor(const TargetInstrInfo *TII, MachineBasicBlock &MBB, MachineBasicBlock &SuccMBB)
static bool IsBranchOnlyBlock(MachineBasicBlock *MBB)
static void FixTail(MachineBasicBlock *CurMBB, MachineBasicBlock *SuccBB, const TargetInstrInfo *TII, const DebugLoc &BranchDL)
static bool IsBetterFallthrough(MachineBasicBlock *MBB1, MachineBasicBlock *MBB2)
IsBetterFallthrough - Return true if it would be clearly better to fall-through to MBB1 than to fall ...
static unsigned HashEndOfMBB(const MachineBasicBlock &MBB)
HashEndOfMBB - Hash the last instruction in the MBB.
static void mergeOperations(MachineBasicBlock::iterator MBBIStartPos, MachineBasicBlock &MBBCommon)
static MachineBasicBlock::iterator findHoistingInsertPosAndDeps(MachineBasicBlock *MBB, const TargetInstrInfo *TII, const TargetRegisterInfo *TRI, SmallSet< Register, 4 > &Uses, SmallSet< Register, 4 > &Defs)
findHoistingInsertPosAndDeps - Find the location to move common instructions in successors to.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
const HexagonInstrInfo * TII
A common definition of LaneBitmask for use in TableGen and CodeGen.
Register const TargetRegisterInfo * TRI
Promote Memory to Register
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
SmallVector< MachineOperand, 4 > Cond
const SmallVectorImpl< MachineOperand > MachineBasicBlock * TBB
Remove Loads Into Fake Uses
This file defines the SmallSet class.
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
Target-Independent Code Generator Pass Configuration Options pass.
AnalysisUsage & addRequired()
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
Represent a constant reference to an array (0 or more elements consecutively in memory),...
bool empty() const
Check if the array is empty.
LLVM Basic Block Representation.
bool test(unsigned Idx) const
Returns true if bit Idx is set.
BitVector & set()
Set all bits in the bitvector.
size_type size() const
Returns the number of bits in this bitvector.
bool OptimizeFunction(MachineFunction &MF, const TargetInstrInfo *tii, const TargetRegisterInfo *tri, MachineLoopInfo *mli=nullptr, bool AfterPlacement=false)
Perhaps branch folding, tail merging and other CFG optimizations on the given function.
BranchFolder(bool DefaultEnableTailMerge, bool CommonHoist, MBFIWrapper &FreqInfo, const MachineBranchProbabilityInfo &ProbInfo, ProfileSummaryInfo *PSI, unsigned MinTailLength=0)
static LLVM_ABI BranchProbability getBranchProbability(uint64_t Numerator, uint64_t Denominator)
static bool isPseudoProbeDiscriminator(unsigned Discriminator)
static LLVM_ABI DILocation * getMergedLocation(DILocation *LocA, DILocation *LocB)
Attempts to merge LocA and LocB into a single location; see DebugLoc::getMergedLocation for more deta...
bool isSameSourceLocation(const DebugLoc &Other) const
Return true if the source locations match, ignoring isImplicitCode and source atom info.
static LLVM_ABI DebugLoc getMergedLocation(DebugLoc LocA, DebugLoc LocB)
When two instructions are combined into a single instruction we also need to combine the original loc...
iterator find(const_arg_type_t< KeyT > Val)
void removeBlock(BlockT *BB)
This method completely removes BB from all data structures, including all of the Loop objects it is n...
const MCInstrDesc & get(unsigned Opcode) const
Return the machine instruction descriptor that corresponds to the specified instruction opcode.
MCRegAliasIterator enumerates all registers aliasing Reg.
An RAII based helper class to modify MachineFunctionProperties when running pass.
unsigned pred_size() const
bool isEHPad() const
Returns true if the block is a landing pad.
MachineInstrBundleIterator< const MachineInstr > const_iterator
LLVM_ABI void moveBefore(MachineBasicBlock *NewAfter)
Move 'this' block before or after the specified block.
LLVM_ABI void transferSuccessors(MachineBasicBlock *FromMBB)
Transfers all the successors from MBB to this machine basic block (i.e., copies all the successors Fr...
LLVM_ABI instr_iterator insert(instr_iterator I, MachineInstr *M)
Insert MI into the instruction list before I, possibly inside a bundle.
iterator_range< livein_iterator > liveins() const
int getNumber() const
MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a MachineFuncti...
LLVM_ABI iterator SkipPHIsAndLabels(iterator I)
Return the first instruction in MBB after I that is not a PHI or a label.
const BasicBlock * getBasicBlock() const
Return the LLVM basic block that this instance corresponded to originally.
LLVM_ABI bool canFallThrough()
Return true if the block can implicitly transfer control to the block after it by falling off the end...
LLVM_ABI void setSuccProbability(succ_iterator I, BranchProbability Prob)
Set successor probability of a given iterator.
LLVM_ABI iterator getFirstNonDebugInstr(bool SkipPseudoOp=true)
Returns an iterator to the first non-debug instruction in the basic block, or end().
succ_iterator succ_begin()
LLVM_ABI void clearLiveIns()
Clear live in list.
LLVM_ABI iterator getFirstTerminator()
Returns an iterator to the first terminator instruction of this basic block.
unsigned succ_size() const
bool hasAddressTaken() const
Test whether this block is used as something other than the target of a terminator,...
LLVM_ABI void addSuccessor(MachineBasicBlock *Succ, BranchProbability Prob=BranchProbability::getUnknown())
Add Succ as a successor of this MachineBasicBlock.
LLVM_ABI void copySuccessor(const MachineBasicBlock *Orig, succ_iterator I)
Copy a successor (and any probability info) from original block to this block's.
LLVM_ABI void removeSuccessor(MachineBasicBlock *Succ, bool NormalizeSuccProbs=false)
Remove successor from the successors list of this MachineBasicBlock.
pred_iterator pred_begin()
LLVM_ABI iterator getLastNonDebugInstr(bool SkipPseudoOp=true)
Returns an iterator to the last non-debug instruction in the basic block, or end().
LLVM_ABI void ReplaceUsesOfBlockWith(MachineBasicBlock *Old, MachineBasicBlock *New)
Given a machine basic block that branched to 'Old', change the code and CFG so that it branches to 'N...
MachineInstrBundleIterator< MachineInstr, true > reverse_iterator
LLVM_ABI bool isLayoutSuccessor(const MachineBasicBlock *MBB) const
Return true if the specified MBB will be emitted immediately after this block, such that if this bloc...
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
LLVM_ABI instr_iterator erase(instr_iterator I)
Remove an instruction from the instruction list and delete it.
LLVM_ABI DebugLoc findBranchDebugLoc()
Find and return the merged DebugLoc of the branch instructions of the block.
iterator_range< succ_iterator > successors()
reverse_iterator rbegin()
bool isMachineBlockAddressTaken() const
Test whether this block is used as something other than the target of a terminator,...
LLVM_ABI bool isSuccessor(const MachineBasicBlock *MBB) const
Return true if the specified MBB is a successor of this block.
iterator_range< pred_iterator > predecessors()
void splice(iterator Where, MachineBasicBlock *Other, iterator From)
Take an instruction from MBB 'Other' at the position From, and insert it into this MBB right before '...
MachineInstrBundleIterator< MachineInstr > iterator
LLVM_ABI void moveAfter(MachineBasicBlock *NewBefore)
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Function & getFunction()
Return the LLVM function that this machine code represents.
const MachineBasicBlock & back() const
BasicBlockListType::iterator iterator
void eraseAdditionalCallInfo(const MachineInstr *MI)
Following functions update call site info.
void RenumberBlocks(MachineBasicBlock *MBBFrom=nullptr)
RenumberBlocks - This discards all of the MachineBasicBlock numbers and recomputes them.
const MachineJumpTableInfo * getJumpTableInfo() const
getJumpTableInfo - Return the jump table info object for the current function.
MachineBasicBlock * CreateMachineBasicBlock(const BasicBlock *BB=nullptr, std::optional< UniqueBBID > BBID=std::nullopt)
CreateMachineInstr - Allocate a new MachineInstr.
void erase(iterator MBBI)
void insert(iterator MBBI, MachineBasicBlock *MBB)
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
Representation of each machine instruction.
bool isBarrier(QueryType Type=AnyInBundle) const
Returns true if the specified instruction stops control flow from executing the instruction immediate...
unsigned getNumOperands() const
Retuns the total number of operands.
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
const MachineOperand & getOperand(unsigned i) const
LLVM_ABI MachineInstrBundleIterator< MachineInstr > eraseFromParent()
Unlink 'this' from the containing basic block and delete it.
void RemoveJumpTable(unsigned Idx)
RemoveJumpTable - Mark the specific index as being dead.
const std::vector< MachineJumpTableEntry > & getJumpTables() const
MachineOperand class - Representation of each machine instruction operand.
bool isReg() const
isReg - Tests if this is a MO_Register operand.
void setIsUndef(bool Val=true)
@ MO_Immediate
Immediate operand.
@ MO_ConstantPoolIndex
Address of indexed Constant in Constant Pool.
@ MO_GlobalAddress
Address of a global value.
@ MO_MachineBasicBlock
MachineBasicBlock reference.
@ MO_FrameIndex
Abstract Stack Frame Index.
@ MO_Register
Register operand.
@ MO_ExternalSymbol
Name of external global symbol.
@ MO_JumpTableIndex
Address of indexed Jump Table for switch.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Analysis providing profile information.
Wrapper class representing virtual and physical registers.
constexpr bool isVirtual() const
Return true if the specified register number is in the virtual register namespace.
constexpr bool isPhysical() const
Return true if the specified register number is in the physical register namespace.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
size_type count(const T &V) const
count - Return 1 if the element is in the set, 0 otherwise.
iterator erase(const_iterator CI)
void push_back(const T &Elt)
LLVM_NO_SANITIZE_CFI_UNRELATED_CAST iterator begin()
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
TargetInstrInfo - Interface to description of machine instruction set.
bool requiresStructuredCFG() const
bool getEnableTailMerge() const
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
virtual const TargetInstrInfo * getInstrInfo() const
virtual const TargetRegisterInfo * getRegisterInfo() const =0
Return the target's register information.
self_iterator getIterator()
@ BasicBlock
Various leaf nodes.
LLVM_ABI iterator begin() const
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
OuterAnalysisManagerProxy< ModuleAnalysisManager, MachineFunction > ModuleAnalysisManagerMachineFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
LLVM_ABI bool shouldOptimizeForSize(const MachineFunction *MF, ProfileSummaryInfo *PSI, const MachineBlockFrequencyInfo *BFI, PGSOQueryType QueryType=PGSOQueryType::Other)
Returns true if machine function MF is suggested to be size-optimized based on the profile.
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
AnalysisManager< MachineFunction > MachineFunctionAnalysisManager
LLVM_ABI PreservedAnalyses getMachineFunctionPassPreservedAnalyses()
Returns the minimum set of Analyses that all machine function passes must preserve.
IterT skipDebugInstructionsForward(IterT It, IterT End, bool SkipPseudoOp=true)
Increment It until it points to a non-debug instruction or to End and return the resulting iterator.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
void sort(IteratorTy Start, IteratorTy End)
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
DWARFExpression::Operation Op
LLVM_ABI void computeAndAddLiveIns(LivePhysRegs &LiveRegs, MachineBasicBlock &MBB)
Convenience function combining computeLiveIns() and addLiveIns().
constexpr bool valueOr(BoolOrDefault X, bool Default)
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Next
LLVM_ABI void computeLiveIns(LivePhysRegs &LiveRegs, const MachineBasicBlock &MBB)
Computes registers live-in to MBB assuming all of its successors live-in lists are up-to-date.
bool equal(L &&LRange, R &&RRange)
Wrapper function around std::equal to detect if pair-wise elements between two ranges are the same.
LLVM_ABI char & BranchFolderPassID
BranchFolding - This pass performs machine code CFG based optimizations to delete branches to branche...
IterT prev_nodbg(IterT It, IterT Begin, bool SkipPseudoOp=true)
Decrement It, then continue decrementing it while it points to a debug instruction.
void fullyRecomputeLiveIns(ArrayRef< MachineBasicBlock * > MBBs)
Convenience function for recomputing live-in's for a set of MBBs until the computation converges.
LLVM_ABI Printable printMBBReference(const MachineBasicBlock &MBB)
Prints a machine basic block reference.
LLVM_ABI void addLiveIns(MachineBasicBlock &MBB, const LivePhysRegs &LiveRegs)
Adds registers contained in LiveRegs to the block live-in list of MBB.
LLVM_ABI DenseMap< const MachineBasicBlock *, int > getEHScopeMembership(const MachineFunction &MF)
const CodeGenOptions & getCodeGenOptions(const LLVMContext &C)
static constexpr LaneBitmask getAll()