namespace {
struct BranchFolder : public MachineFunctionPass {
- static const int ID;
+ static char ID;
BranchFolder() : MachineFunctionPass((intptr_t)&ID) {}
virtual bool runOnMachineFunction(MachineFunction &MF);
private:
// Tail Merging.
bool TailMergeBlocks(MachineFunction &MF);
+ bool TryMergeBlocks(MachineBasicBlock* SuccBB,
+ MachineBasicBlock* PredBB);
void ReplaceTailWithBranchTo(MachineBasicBlock::iterator OldInst,
MachineBasicBlock *NewDest);
MachineBasicBlock *SplitMBBAt(MachineBasicBlock &CurMBB,
MachineBasicBlock::iterator BBI1);
+ std::vector<std::pair<unsigned,MachineBasicBlock*> > MergePotentials;
const MRegisterInfo *RegInfo;
RegScavenger *RS;
// Branch optzn.
MachineBasicBlock *TBB, MachineBasicBlock *FBB,
const std::vector<MachineOperand> &Cond);
};
- const int BranchFolder::ID = 0;
+ char BranchFolder::ID = 0;
}
+static bool CorrectExtraCFGEdges(MachineBasicBlock &MBB,
+ MachineBasicBlock *DestA,
+ MachineBasicBlock *DestB,
+ bool isCond,
+ MachineFunction::iterator FallThru);
+
FunctionPass *llvm::createBranchFoldingPass() { return new BranchFolder(); }
/// RemoveDeadBlock - Remove the specified dead machine basic block from the
TII = MF.getTarget().getInstrInfo();
if (!TII) return false;
+ // Fix CFG. The later algorithms expect it to be right.
+ bool EverMadeChange = false;
+ for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; I++) {
+ MachineBasicBlock *MBB = I, *TBB = 0, *FBB = 0;
+ std::vector<MachineOperand> Cond;
+ if (!TII->AnalyzeBranch(*MBB, TBB, FBB, Cond))
+ EverMadeChange |= CorrectExtraCFGEdges(*MBB, TBB, FBB,
+ !Cond.empty(), next(I));
+ }
+
RegInfo = MF.getTarget().getRegisterInfo();
RS = RegInfo->requiresRegisterScavenging(MF) ? new RegScavenger() : NULL;
MMI = getAnalysisToUpdate<MachineModuleInfo>();
-
- bool EverMadeChange = false;
+
bool MadeChangeThisIteration = true;
while (MadeChangeThisIteration) {
MadeChangeThisIteration = false;
MachineBasicBlock::iterator MBB1I,
MachineBasicBlock *MBB2,
MachineBasicBlock::iterator MBB2I,
- const TargetInstrInfo *TII) {
+ const TargetInstrInfo *TII,
+ MachineBasicBlock *PredBB) {
+ // If one block is the entry block, split the other one; we can't generate
+ // a branch to the entry block, as its label is not emitted.
+ MachineBasicBlock *Entry = MBB1->getParent()->begin();
+ if (MBB1 == Entry)
+ return false;
+ if (MBB2 == Entry)
+ return true;
+
+ // If one block falls through into the common successor, choose that
+ // one to split; it is one instruction less to do that.
+ if (PredBB) {
+ if (MBB1 == PredBB)
+ return true;
+ else if (MBB2 == PredBB)
+ return false;
+ }
// TODO: if we had some notion of which block was hotter, we could split
// the hot block, so it is the fall-through. Since we don't have profile info
// make a decision based on which will hurt most to split.
return MBB1Time < MBB2Time;
}
-bool BranchFolder::TailMergeBlocks(MachineFunction &MF) {
- MadeChange = false;
-
- if (!EnableTailMerge) return false;
-
- // Find blocks with no successors.
- std::vector<std::pair<unsigned,MachineBasicBlock*> > MergePotentials;
- for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {
- if (I->succ_empty())
- MergePotentials.push_back(std::make_pair(HashEndOfMBB(I), I));
+// CurMBB needs to add an unconditional branch to SuccMBB (we removed these
+// branches temporarily for tail merging). In the case where CurMBB ends
+// with a conditional branch to the next block, optimize by reversing the
+// test and conditionally branching to SuccMBB instead.
+
+static void FixTail(MachineBasicBlock* CurMBB, MachineBasicBlock *SuccBB,
+ const TargetInstrInfo *TII) {
+ MachineFunction *MF = CurMBB->getParent();
+ MachineFunction::iterator I = next(MachineFunction::iterator(CurMBB));
+ MachineBasicBlock *TBB = 0, *FBB = 0;
+ std::vector<MachineOperand> Cond;
+ if (I != MF->end() &&
+ !TII->AnalyzeBranch(*CurMBB, TBB, FBB, Cond)) {
+ MachineBasicBlock *NextBB = I;
+ if (TBB == NextBB && Cond.size() && !FBB) {
+ if (!TII->ReverseBranchCondition(Cond)) {
+ TII->RemoveBranch(*CurMBB);
+ TII->InsertBranch(*CurMBB, SuccBB, NULL, Cond);
+ return;
+ }
+ }
}
+ TII->InsertBranch(*CurMBB, SuccBB, NULL, std::vector<MachineOperand>());
+}
+
+// See if any of the blocks in MergePotentials (which all have a common single
+// successor, or all have no successor) can be tail-merged. If there is a
+// successor, any blocks in MergePotentials that are not tail-merged and
+// are not immediately before Succ must have an unconditional branch to
+// Succ added (but the predecessor/successor lists need no adjustment).
+// The lone predecessor of Succ that falls through into Succ,
+// if any, is given in PredBB.
+
+bool BranchFolder::TryMergeBlocks(MachineBasicBlock *SuccBB,
+ MachineBasicBlock* PredBB) {
+ MadeChange = false;
// Sort by hash value so that blocks with identical end sequences sort
// together.
// If there is nothing that matches the hash of the current basic block,
// give up.
if (CurHash != PrevHash) {
+ if (SuccBB && CurMBB != PredBB)
+ FixTail(CurMBB, SuccBB, TII);
MergePotentials.pop_back();
continue;
}
// If the tails don't have at least two instructions in common, see if there
// is anything else in the equivalence class that does match.
+ // Since instructions may get combined later (e.g. single stores into
+ // store multiple) this measure is not particularly accurate.
if (CommonTailLen < 2) {
unsigned FoundMatch = ~0U;
for (int i = MergePotentials.size()-2;
// If we didn't find anything that has at least two instructions matching
// this one, bail out.
if (FoundMatch == ~0U) {
+ // Put the unconditional branch back, if we need one.
+ if (SuccBB && CurMBB != PredBB)
+ FixTail(CurMBB, SuccBB, TII);
MergePotentials.pop_back();
continue;
}
MachineBasicBlock *MBB2 = (MergePotentials.end()-2)->second;
// If neither block is the entire common tail, split the tail of one block
- // to make it redundant with the other tail.
- if (CurMBB->begin() != BBI1 && MBB2->begin() != BBI2) {
+ // to make it redundant with the other tail. Also, we cannot jump to the
+ // entry block, so if one block is the entry block, split the other one.
+ MachineBasicBlock *Entry = CurMBB->getParent()->begin();
+ if (CurMBB->begin() == BBI1 && CurMBB != Entry)
+ ; // CurMBB is common tail
+ else if (MBB2->begin() == BBI2 && MBB2 != Entry)
+ ; // MBB2 is common tail
+ else {
if (0) { // Enable this to disable partial tail merges.
MergePotentials.pop_back();
continue;
}
// Decide whether we want to split CurMBB or MBB2.
- if (ShouldSplitFirstBlock(CurMBB, BBI1, MBB2, BBI2, TII)) {
+ if (ShouldSplitFirstBlock(CurMBB, BBI1, MBB2, BBI2, TII, PredBB)) {
CurMBB = SplitMBBAt(*CurMBB, BBI1);
BBI1 = CurMBB->begin();
MergePotentials.back().second = CurMBB;
}
}
- if (MBB2->begin() == BBI2) {
+ if (MBB2->begin() == BBI2 && MBB2 != Entry) {
// Hack the end off CurMBB, making it jump to MBBI@ instead.
ReplaceTailWithBranchTo(BBI1, MBB2);
// This modifies CurMBB, so remove it from the worklist.
MergePotentials.pop_back();
} else {
- assert(CurMBB->begin() == BBI1 && "Didn't split block correctly?");
+ assert(CurMBB->begin() == BBI1 && CurMBB != Entry &&
+ "Didn't split block correctly?");
// Hack the end off MBB2, making it jump to CurMBB instead.
ReplaceTailWithBranchTo(BBI2, CurMBB);
// This modifies MBB2, so remove it from the worklist.
}
MadeChange = true;
}
-
return MadeChange;
}
+bool BranchFolder::TailMergeBlocks(MachineFunction &MF) {
+
+ if (!EnableTailMerge) return false;
+
+ MadeChange = false;
+
+ // First find blocks with no successors.
+ MergePotentials.clear();
+ for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {
+ if (I->succ_empty())
+ MergePotentials.push_back(std::make_pair(HashEndOfMBB(I), I));
+ }
+ // See if we can do any tail merging on those.
+ MadeChange |= TryMergeBlocks(NULL, NULL);
+
+ // Look at blocks (IBB) with multiple predecessors (PBB).
+ // We change each predecessor to a canonical form, by
+ // (1) temporarily removing any unconditional branch from the predecessor
+ // to IBB, and
+ // (2) alter conditional branches so they branch to the other block
+ // not IBB; this may require adding back an unconditional branch to IBB
+ // later, where there wasn't one coming in. E.g.
+ // Bcc IBB
+ // fallthrough to QBB
+ // here becomes
+ // Bncc QBB
+ // with a conceptual B to IBB after that, which never actually exists.
+ // With those changes, we see whether the predecessors' tails match,
+ // and merge them if so. We change things out of canonical form and
+ // back to the way they were later in the process. (OptimizeBranches
+ // would undo some of this, but we can't use it, because we'd get into
+ // a compile-time infinite loop repeatedly doing and undoing the same
+ // transformations.)
+
+ for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {
+ if (!I->succ_empty() && I->pred_size() >= 2) {
+ MachineBasicBlock *IBB = I;
+ MachineBasicBlock *PredBB = prior(I);
+ MergePotentials.clear();
+ for (MachineBasicBlock::pred_iterator P = I->pred_begin(), E2 = I->pred_end();
+ P != E2; ++P) {
+ MachineBasicBlock* PBB = *P;
+ // Skip blocks that loop to themselves, can't tail merge these.
+ if (PBB==IBB)
+ continue;
+ MachineBasicBlock *TBB = 0, *FBB = 0;
+ std::vector<MachineOperand> Cond;
+ if (!TII->AnalyzeBranch(*PBB, TBB, FBB, Cond)) {
+ // Failing case: IBB is the target of a cbr, and
+ // we cannot reverse the branch.
+ std::vector<MachineOperand> NewCond(Cond);
+ if (Cond.size() && TBB==IBB) {
+ if (TII->ReverseBranchCondition(NewCond))
+ continue;
+ // This is the QBB case described above
+ if (!FBB)
+ FBB = next(MachineFunction::iterator(PBB));
+ }
+ // Remove the unconditional branch at the end, if any.
+ if (TBB && (Cond.size()==0 || FBB)) {
+ TII->RemoveBranch(*PBB);
+ if (Cond.size())
+ // reinsert conditional branch only, for now
+ TII->InsertBranch(*PBB, (TBB==IBB) ? FBB : TBB, 0, NewCond);
+ }
+ MergePotentials.push_back(std::make_pair(HashEndOfMBB(PBB), *P));
+ }
+ }
+ if (MergePotentials.size() >= 2)
+ MadeChange |= TryMergeBlocks(I, PredBB);
+ // Reinsert an unconditional branch if needed.
+ // The 1 below can be either an original single predecessor, or a result
+ // of removing blocks in TryMergeBlocks.
+ if (MergePotentials.size()==1 &&
+ (MergePotentials.begin())->second != PredBB)
+ FixTail((MergePotentials.begin())->second, I, TII);
+ }
+ }
+ return MadeChange;
+}
//===----------------------------------------------------------------------===//
// Branch Optimization
MachineBasicBlock *PredBB = *PI;
MachineFunction::iterator PredFallthrough = PredBB; ++PredFallthrough;
if (PredBB != MBB && !CanFallThrough(PredBB)
+ && (!CurFallsThru || !CurTBB || !CurFBB)
&& (!CurFallsThru || MBB->getNumber() >= PredBB->getNumber())) {
// If the current block doesn't fall through, just move it.
// If the current block can fall through and does not end with a
// conditional branch, we need to append an unconditional jump to
// the (current) next block. To avoid a possible compile-time
// infinite loop, move blocks only backward in this case.
+ // Also, if there are already 2 branches here, we cannot add a third;
+ // this means we have the case
+ // Bcc next
+ // B elsewhere
+ // next:
if (CurFallsThru) {
MachineBasicBlock *NextBB = next(MachineFunction::iterator(MBB));
CurCond.clear();