//===----------------------------------------------------------------------===//
#define DEBUG_TYPE "branchfolding"
+#include "BranchFolding.h"
#include "llvm/CodeGen/Passes.h"
#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/STLExtras.h"
cl::desc("Max number of predecessors to consider tail merging"),
cl::init(150), cl::Hidden);
-namespace {
- struct VISIBILITY_HIDDEN BranchFolder : public MachineFunctionPass {
- static char ID;
- explicit BranchFolder(bool defaultEnableTailMerge) :
- MachineFunctionPass(&ID) {
- switch (FlagEnableTailMerge) {
- case cl::BOU_UNSET: EnableTailMerge = defaultEnableTailMerge; break;
- case cl::BOU_TRUE: EnableTailMerge = true; break;
- case cl::BOU_FALSE: EnableTailMerge = false; break;
- }
- }
- virtual bool runOnMachineFunction(MachineFunction &MF);
- virtual const char *getPassName() const { return "Control Flow Optimizer"; }
- const TargetInstrInfo *TII;
- MachineModuleInfo *MMI;
- bool MadeChange;
- private:
- // Tail Merging.
- bool EnableTailMerge;
- bool TailMergeBlocks(MachineFunction &MF);
- bool TryMergeBlocks(MachineBasicBlock* SuccBB,
- MachineBasicBlock* PredBB);
- void ReplaceTailWithBranchTo(MachineBasicBlock::iterator OldInst,
- MachineBasicBlock *NewDest);
- MachineBasicBlock *SplitMBBAt(MachineBasicBlock &CurMBB,
- MachineBasicBlock::iterator BBI1);
- unsigned ComputeSameTails(unsigned CurHash, unsigned minCommonTailLength);
- void RemoveBlocksWithHash(unsigned CurHash, MachineBasicBlock* SuccBB,
- MachineBasicBlock* PredBB);
- unsigned CreateCommonTailOnlyBlock(MachineBasicBlock *&PredBB,
- unsigned maxCommonTailLength);
-
- typedef std::pair<unsigned,MachineBasicBlock*> MergePotentialsElt;
- typedef std::vector<MergePotentialsElt>::iterator MPIterator;
- std::vector<MergePotentialsElt> MergePotentials;
-
- typedef std::pair<MPIterator, MachineBasicBlock::iterator> SameTailElt;
- std::vector<SameTailElt> SameTails;
-
- const TargetRegisterInfo *RegInfo;
- RegScavenger *RS;
- // Branch optzn.
- bool OptimizeBranches(MachineFunction &MF);
- void OptimizeBlock(MachineBasicBlock *MBB);
- void RemoveDeadBlock(MachineBasicBlock *MBB);
- bool OptimizeImpDefsBlock(MachineBasicBlock *MBB);
-
- bool CanFallThrough(MachineBasicBlock *CurBB);
- bool CanFallThrough(MachineBasicBlock *CurBB, bool BranchUnAnalyzable,
- MachineBasicBlock *TBB, MachineBasicBlock *FBB,
- const SmallVectorImpl<MachineOperand> &Cond);
- };
- char BranchFolder::ID = 0;
-}
+char BranchFolderPass::ID = 0;
FunctionPass *llvm::createBranchFoldingPass(bool DefaultEnableTailMerge) {
- return new BranchFolder(DefaultEnableTailMerge); }
+ return new BranchFolderPass(DefaultEnableTailMerge);
+}
+
+bool BranchFolderPass::runOnMachineFunction(MachineFunction &MF) {
+ return OptimizeFunction(MF,
+ MF.getTarget().getInstrInfo(),
+ MF.getTarget().getRegisterInfo(),
+ getAnalysisIfAvailable<MachineModuleInfo>());
+}
+
+
+
+BranchFolder::BranchFolder(bool defaultEnableTailMerge) {
+ switch (FlagEnableTailMerge) {
+ case cl::BOU_UNSET: EnableTailMerge = defaultEnableTailMerge; break;
+ case cl::BOU_TRUE: EnableTailMerge = true; break;
+ case cl::BOU_FALSE: EnableTailMerge = false; break;
+ }
+}
/// RemoveDeadBlock - Remove the specified dead machine basic block from the
/// function, updating the CFG.
void BranchFolder::RemoveDeadBlock(MachineBasicBlock *MBB) {
assert(MBB->pred_empty() && "MBB must be dead!");
- DOUT << "\nRemoving MBB: " << *MBB;
+ DEBUG(errs() << "\nRemoving MBB: " << *MBB);
MachineFunction *MF = MBB->getParent();
// drop all successors.
break;
unsigned Reg = I->getOperand(0).getReg();
ImpDefRegs.insert(Reg);
- for (const unsigned *SubRegs = RegInfo->getSubRegisters(Reg);
+ for (const unsigned *SubRegs = TRI->getSubRegisters(Reg);
unsigned SubReg = *SubRegs; ++SubRegs)
ImpDefRegs.insert(SubReg);
++I;
return true;
}
-bool BranchFolder::runOnMachineFunction(MachineFunction &MF) {
- TII = MF.getTarget().getInstrInfo();
- if (!TII) return false;
+/// OptimizeFunction - Perhaps branch folding, tail merging and other
+/// CFG optimizations on the given function.
+bool BranchFolder::OptimizeFunction(MachineFunction &MF,
+ const TargetInstrInfo *tii,
+ const TargetRegisterInfo *tri,
+ MachineModuleInfo *mmi) {
+ if (!tii) return false;
- RegInfo = MF.getTarget().getRegisterInfo();
+ TII = tii;
+ TRI = tri;
+ MMI = mmi;
+
+ RS = TRI->requiresRegisterScavenging(MF) ? new RegScavenger() : NULL;
// Fix CFG. The later algorithms expect it to be right.
- bool EverMadeChange = false;
+ bool MadeChange = false;
for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; I++) {
MachineBasicBlock *MBB = I, *TBB = 0, *FBB = 0;
SmallVector<MachineOperand, 4> Cond;
if (!TII->AnalyzeBranch(*MBB, TBB, FBB, Cond, true))
- EverMadeChange |= MBB->CorrectExtraCFGEdges(TBB, FBB, !Cond.empty());
- EverMadeChange |= OptimizeImpDefsBlock(MBB);
+ MadeChange |= MBB->CorrectExtraCFGEdges(TBB, FBB, !Cond.empty());
+ MadeChange |= OptimizeImpDefsBlock(MBB);
}
- RS = RegInfo->requiresRegisterScavenging(MF) ? new RegScavenger() : NULL;
-
- MMI = getAnalysisIfAvailable<MachineModuleInfo>();
bool MadeChangeThisIteration = true;
while (MadeChangeThisIteration) {
MadeChangeThisIteration = false;
MadeChangeThisIteration |= TailMergeBlocks(MF);
MadeChangeThisIteration |= OptimizeBranches(MF);
- EverMadeChange |= MadeChangeThisIteration;
+ MadeChange |= MadeChangeThisIteration;
}
// See if any jump tables have become mergable or dead as the code generator
// Scan the jump tables, seeing if there are any duplicates. Note that this
// is N^2, which should be fixed someday.
- for (unsigned i = 1, e = JTs.size(); i != e; ++i)
- JTMapping.push_back(JTI->getJumpTableIndex(JTs[i].MBBs));
+ for (unsigned i = 1, e = JTs.size(); i != e; ++i) {
+ if (JTs[i].MBBs.empty())
+ JTMapping.push_back(i);
+ else
+ JTMapping.push_back(JTI->getJumpTableIndex(JTs[i].MBBs));
+ }
// If a jump table was merge with another one, walk the function rewriting
// references to jump tables to reference the new JT ID's. Keep track of
for (unsigned i = 0, e = JTIsLive.size(); i != e; ++i)
if (!JTIsLive.test(i)) {
JTI->RemoveJumpTable(i);
- EverMadeChange = true;
+ MadeChange = true;
}
}
-
+
delete RS;
- return EverMadeChange;
+ return MadeChange;
}
//===----------------------------------------------------------------------===//
RS->enterBasicBlock(&CurMBB);
if (!CurMBB.empty())
RS->forward(prior(CurMBB.end()));
- BitVector RegsLiveAtExit(RegInfo->getNumRegs());
+ BitVector RegsLiveAtExit(TRI->getNumRegs());
RS->getRegsUsed(RegsLiveAtExit, false);
- for (unsigned int i=0, e=RegInfo->getNumRegs(); i!=e; i++)
+ for (unsigned int i=0, e=TRI->getNumRegs(); i!=e; i++)
if (RegsLiveAtExit[i])
NewMBB->addLiveIn(i);
}
MachineBasicBlock::iterator BBI = SameTails[commonTailIndex].second;
MachineBasicBlock *MBB = SameTails[commonTailIndex].first->second;
- DOUT << "\nSplitting " << MBB->getNumber() << ", size " <<
- maxCommonTailLength;
+ DEBUG(errs() << "\nSplitting " << MBB->getNumber() << ", size "
+ << maxCommonTailLength);
MachineBasicBlock *newMBB = SplitMBBAt(*MBB, BBI);
SameTails[commonTailIndex].first->second = newMBB;
bool BranchFolder::TryMergeBlocks(MachineBasicBlock *SuccBB,
MachineBasicBlock* PredBB) {
+ bool MadeChange = false;
+
// It doesn't make sense to save a single instruction since tail merging
// will add a jump.
// FIXME: Ask the target to provide the threshold?
unsigned minCommonTailLength = (SuccBB ? 1 : 2) + 1;
- MadeChange = false;
- DOUT << "\nTryMergeBlocks " << MergePotentials.size() << '\n';
+ DEBUG(errs() << "\nTryMergeBlocks " << MergePotentials.size() << '\n');
// Sort by hash value so that blocks with identical end sequences sort
// together.
MachineBasicBlock *MBB = SameTails[commonTailIndex].first->second;
// MBB is common tail. Adjust all other BB's to jump to this one.
// Traversal must be forwards so erases work.
- DOUT << "\nUsing common tail " << MBB->getNumber() << " for ";
+ DEBUG(errs() << "\nUsing common tail " << MBB->getNumber() << " for ");
for (unsigned int i=0; i<SameTails.size(); ++i) {
if (commonTailIndex==i)
continue;
- DOUT << SameTails[i].first->second->getNumber() << ",";
+ DEBUG(errs() << SameTails[i].first->second->getNumber() << ",");
// Hack the end off BB i, making it jump to BB commonTailIndex instead.
ReplaceTailWithBranchTo(SameTails[i].second, MBB);
// BB i is no longer a predecessor of SuccBB; remove it from the worklist.
MergePotentials.erase(SameTails[i].first);
}
- DOUT << "\n";
+ DEBUG(errs() << "\n");
// We leave commonTailIndex in the worklist in case there are other blocks
// that match it with a smaller number of instructions.
MadeChange = true;
if (!EnableTailMerge) return false;
- MadeChange = false;
+ bool MadeChange = false;
// First find blocks with no successors.
MergePotentials.clear();
for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {
if (I->pred_size() >= 2 && I->pred_size() < TailMergeThreshold) {
+ SmallPtrSet<MachineBasicBlock *, 8> UniquePreds;
MachineBasicBlock *IBB = I;
MachineBasicBlock *PredBB = prior(I);
MergePotentials.clear();
// Skip blocks that loop to themselves, can't tail merge these.
if (PBB==IBB)
continue;
+ // Visit each predecessor only once.
+ if (!UniquePreds.insert(PBB))
+ continue;
MachineBasicBlock *TBB = 0, *FBB = 0;
SmallVector<MachineOperand, 4> Cond;
if (!TII->AnalyzeBranch(*PBB, TBB, FBB, Cond, true)) {
//===----------------------------------------------------------------------===//
bool BranchFolder::OptimizeBranches(MachineFunction &MF) {
- MadeChange = false;
+ bool MadeChange = false;
// Make sure blocks are numbered in order
MF.RenumberBlocks();
for (MachineFunction::iterator I = ++MF.begin(), E = MF.end(); I != E; ) {
MachineBasicBlock *MBB = I++;
- OptimizeBlock(MBB);
+ MadeChange |= OptimizeBlock(MBB);
// If it is dead, remove it.
if (MBB->pred_empty()) {
return CanFallThrough(CurBB, CurUnAnalyzable, TBB, FBB, Cond);
}
-/// RemoveDuplicateSuccessor - make sure block Pred has at most one
-/// successor edge leading to Succ. This is only called in one place,
-/// but Chris prefers that it be a separate function.
-static void RemoveDuplicateSuccessor(MachineBasicBlock *Pred,
- MachineBasicBlock *Succ) {
- MachineBasicBlock::succ_iterator SI = Pred->succ_begin();
- bool found = false;
- while (SI != Pred->succ_end()) {
- if (*SI == Succ) {
- if (!found) {
- found = true;
- ++SI;
- } else {
- SI = Pred->removeSuccessor(SI);
- }
- } else {
- ++SI;
- }
- }
-}
-
/// IsBetterFallthrough - Return true if it would be clearly better to
/// fall-through to MBB1 than to fall through into MBB2. This has to return
/// a strict ordering, returning true for both (MBB1,MBB2) and (MBB2,MBB1) will
/// OptimizeBlock - Analyze and optimize control flow related to the specified
/// block. This is never called on the entry block.
-void BranchFolder::OptimizeBlock(MachineBasicBlock *MBB) {
+bool BranchFolder::OptimizeBlock(MachineBasicBlock *MBB) {
+ bool MadeChange = false;
+
MachineFunction::iterator FallThrough = MBB;
++FallThrough;
// points to this block.
if (MBB->empty() && !MBB->isLandingPad()) {
// Dead block? Leave for cleanup later.
- if (MBB->pred_empty()) return;
+ if (MBB->pred_empty()) return MadeChange;
if (FallThrough == MBB->getParent()->end()) {
// TODO: Simplify preds to not branch here if possible!
while (!MBB->pred_empty()) {
MachineBasicBlock *Pred = *(MBB->pred_end()-1);
Pred->ReplaceUsesOfBlockWith(MBB, FallThrough);
- // If this resulted in a predecessor with true and false edges
- // both going to the fallthrough block, clean up;
- // BranchFolding doesn't like this.
- RemoveDuplicateSuccessor(Pred, FallThrough);
}
// If MBB was the target of a jump table, update jump tables to go to the
// fallthrough instead.
ReplaceMBBInJumpTables(MBB, FallThrough);
MadeChange = true;
}
- return;
+ return MadeChange;
}
// Check to see if we can simplify the terminator of the block before this
}
}
- // If this block doesn't fall through (e.g. it ends with an uncond branch or
- // has no successors) and if the pred falls through into this block, and if
- // it would otherwise fall through into the block after this, move this
- // block to the end of the function.
+ // If this block has no successors (e.g. it is a return block or ends with
+ // a call to a no-return function like abort or __cxa_throw) and if the pred
+ // falls through into this block, and if it would otherwise fall through
+ // into the block after this, move this block to the end of the function.
//
// We consider it more likely that execution will stay in the function (e.g.
// due to loops) than it is to exit it. This asserts in loops etc, moving
// the assert condition out of the loop body.
- if (!PriorCond.empty() && PriorFBB == 0 &&
+ if (MBB->succ_empty() && !PriorCond.empty() && PriorFBB == 0 &&
MachineFunction::iterator(PriorTBB) == FallThrough &&
!CanFallThrough(MBB)) {
bool DoTransform = true;
// Reverse the branch so we will fall through on the previous true cond.
SmallVector<MachineOperand, 4> NewPriorCond(PriorCond);
if (!TII->ReverseBranchCondition(NewPriorCond)) {
- DOUT << "\nMoving MBB: " << *MBB;
- DOUT << "To make fallthrough to: " << *PriorTBB << "\n";
+ DEBUG(errs() << "\nMoving MBB: " << *MBB
+ << "To make fallthrough to: " << *PriorTBB << "\n");
TII->RemoveBranch(PrevBB);
TII->InsertBranch(PrevBB, MBB, 0, NewPriorCond);
MBB->moveAfter(--MBB->getParent()->end());
MadeChange = true;
++NumBranchOpts;
- return;
+ return MadeChange;
}
}
}
if (DidChange) {
++NumBranchOpts;
MadeChange = true;
- if (!HasBranchToSelf) return;
+ if (!HasBranchToSelf) return MadeChange;
}
}
}
PrevBB.isSuccessor(FallThrough)) {
MBB->moveAfter(--MBB->getParent()->end());
MadeChange = true;
- return;
+ return MadeChange;
}
}
}
+
+ return MadeChange;
}
projects / oota-llvm.git / blobdiff