//===----------------------------------------------------------------------===//
#include "llvm/CodeGen/Passes.h"
+#include "llvm/CodeGen/MachineDebugInfo.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/MachineJumpTableInfo.h"
#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/Target/TargetMachine.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/STLExtras.h"
using namespace llvm;
+static Statistic<> NumDeadBlocks("branchfold", "Number of dead blocks removed");
+static Statistic<> NumBranchOpts("branchfold", "Number of branches optimized");
+static Statistic<> NumTailMerge ("branchfold", "Number of block tails merged");
+static cl::opt<bool> EnableTailMerge("enable-tail-merge", cl::Hidden);
+
namespace {
struct BranchFolder : public MachineFunctionPass {
virtual bool runOnMachineFunction(MachineFunction &MF);
- virtual const char *getPassName() const { return "Branch Folder"; }
+ virtual const char *getPassName() const { return "Control Flow Optimizer"; }
+ const TargetInstrInfo *TII;
+ MachineDebugInfo *MDI;
+ bool MadeChange;
private:
- bool OptimizeBlock(MachineFunction::iterator MBB,
- const TargetInstrInfo &TII);
-
- bool isUncondBranch(const MachineInstr *MI, const TargetInstrInfo &TII) {
- return TII.isBarrier(MI->getOpcode()) && TII.isBranch(MI->getOpcode());
- }
- bool isCondBranch(const MachineInstr *MI, const TargetInstrInfo &TII) {
- return TII.isBranch(MI->getOpcode()) && !TII.isBarrier(MI->getOpcode());
- }
+ // Tail Merging.
+ bool TailMergeBlocks(MachineFunction &MF);
+ void ReplaceTailWithBranchTo(MachineBasicBlock::iterator OldInst,
+ MachineBasicBlock *NewDest);
+ MachineBasicBlock *SplitMBBAt(MachineBasicBlock &CurMBB,
+ MachineBasicBlock::iterator BBI1);
+
+ // Branch optzn.
+ bool OptimizeBranches(MachineFunction &MF);
+ void OptimizeBlock(MachineBasicBlock *MBB);
+ void RemoveDeadBlock(MachineBasicBlock *MBB);
+
+ bool CanFallThrough(MachineBasicBlock *CurBB);
+ bool CanFallThrough(MachineBasicBlock *CurBB, bool BranchUnAnalyzable,
+ MachineBasicBlock *TBB, MachineBasicBlock *FBB,
+ const std::vector<MachineOperand> &Cond);
};
}
FunctionPass *llvm::createBranchFoldingPass() { return new BranchFolder(); }
+/// 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!");
+
+ MachineFunction *MF = MBB->getParent();
+ // drop all successors.
+ while (!MBB->succ_empty())
+ MBB->removeSuccessor(MBB->succ_end()-1);
+
+ // If there is DWARF info to active, check to see if there are any DWARF_LABEL
+ // records in the basic block. If so, unregister them from MachineDebugInfo.
+ if (MDI && !MBB->empty()) {
+ unsigned DWARF_LABELOpc = TII->getDWARF_LABELOpcode();
+ assert(DWARF_LABELOpc &&
+ "Target supports dwarf but didn't implement getDWARF_LABELOpcode!");
+
+ for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end();
+ I != E; ++I) {
+ if ((unsigned)I->getOpcode() == DWARF_LABELOpc) {
+ // The label ID # is always operand #0, an immediate.
+ MDI->InvalidateLabel(I->getOperand(0).getImm());
+ }
+ }
+ }
+
+ // Remove the block.
+ MF->getBasicBlockList().erase(MBB);
+}
+
bool BranchFolder::runOnMachineFunction(MachineFunction &MF) {
+ TII = MF.getTarget().getInstrInfo();
+ if (!TII) return false;
+
+ MDI = getAnalysisToUpdate<MachineDebugInfo>();
+
bool EverMadeChange = false;
- bool MadeChange = true;
- const TargetInstrInfo &TII = *MF.getTarget().getInstrInfo();
- while (MadeChange) {
- MadeChange = false;
- for (MachineFunction::iterator MBB = ++MF.begin(), E = MF.end(); MBB != E;
- ++MBB)
- MadeChange |= OptimizeBlock(MBB, TII);
-
- // If branches were folded away somehow, do a quick scan and delete any dead
- // blocks.
- if (MadeChange) {
- for (MachineFunction::iterator I = ++MF.begin(), E = MF.end(); I != E; ) {
- MachineBasicBlock *MBB = I++;
- // Is it dead?
- if (MBB->pred_empty()) {
- // drop all successors.
- while (!MBB->succ_empty())
- MBB->removeSuccessor(MBB->succ_end()-1);
- MF.getBasicBlockList().erase(MBB);
+ bool MadeChangeThisIteration = true;
+ while (MadeChangeThisIteration) {
+ MadeChangeThisIteration = false;
+ MadeChangeThisIteration |= TailMergeBlocks(MF);
+ MadeChangeThisIteration |= OptimizeBranches(MF);
+ EverMadeChange |= MadeChangeThisIteration;
+ }
+
+ // See if any jump tables have become mergable or dead as the code generator
+ // did its thing.
+ MachineJumpTableInfo *JTI = MF.getJumpTableInfo();
+ const std::vector<MachineJumpTableEntry> &JTs = JTI->getJumpTables();
+ if (!JTs.empty()) {
+ // Figure out how these jump tables should be merged.
+ std::vector<unsigned> JTMapping;
+ JTMapping.reserve(JTs.size());
+
+ // We always keep the 0th jump table.
+ JTMapping.push_back(0);
+
+ // 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));
+
+ // 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
+ // whether we see a jump table idx, if not, we can delete the JT.
+ std::vector<bool> JTIsLive;
+ JTIsLive.resize(JTs.size());
+ for (MachineFunction::iterator BB = MF.begin(), E = MF.end();
+ BB != E; ++BB) {
+ for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end();
+ I != E; ++I)
+ for (unsigned op = 0, e = I->getNumOperands(); op != e; ++op) {
+ MachineOperand &Op = I->getOperand(op);
+ if (!Op.isJumpTableIndex()) continue;
+ unsigned NewIdx = JTMapping[Op.getJumpTableIndex()];
+ Op.setJumpTableIndex(NewIdx);
+
+ // Remember that this JT is live.
+ JTIsLive[NewIdx] = true;
}
+ }
+
+ // Finally, remove dead jump tables. This happens either because the
+ // indirect jump was unreachable (and thus deleted) or because the jump
+ // table was merged with some other one.
+ for (unsigned i = 0, e = JTIsLive.size(); i != e; ++i)
+ if (!JTIsLive[i]) {
+ JTI->RemoveJumpTable(i);
+ EverMadeChange = true;
}
+ }
+
+ return EverMadeChange;
+}
+
+//===----------------------------------------------------------------------===//
+// Tail Merging of Blocks
+//===----------------------------------------------------------------------===//
+
+/// HashMachineInstr - Compute a hash value for MI and its operands.
+static unsigned HashMachineInstr(const MachineInstr *MI) {
+ unsigned Hash = MI->getOpcode();
+ for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
+ const MachineOperand &Op = MI->getOperand(i);
+
+ // Merge in bits from the operand if easy.
+ unsigned OperandHash = 0;
+ switch (Op.getType()) {
+ case MachineOperand::MO_Register: OperandHash = Op.getReg(); break;
+ case MachineOperand::MO_Immediate: OperandHash = Op.getImm(); break;
+ case MachineOperand::MO_MachineBasicBlock:
+ OperandHash = Op.getMachineBasicBlock()->getNumber();
+ break;
+ case MachineOperand::MO_FrameIndex: OperandHash = Op.getFrameIndex(); break;
+ case MachineOperand::MO_ConstantPoolIndex:
+ OperandHash = Op.getConstantPoolIndex();
+ break;
+ case MachineOperand::MO_JumpTableIndex:
+ OperandHash = Op.getJumpTableIndex();
+ break;
+ case MachineOperand::MO_GlobalAddress:
+ case MachineOperand::MO_ExternalSymbol:
+ // Global address / external symbol are too hard, don't bother, but do
+ // pull in the offset.
+ OperandHash = Op.getOffset();
+ break;
+ default: break;
+ }
+
+ Hash += ((OperandHash << 3) | Op.getType()) << (i&31);
+ }
+ return Hash;
+}
+
+/// HashEndOfMBB - Hash the last two instructions in the MBB. We hash two
+/// instructions, because cross-jumping only saves code when at least two
+/// instructions are removed (since a branch must be inserted).
+static unsigned HashEndOfMBB(const MachineBasicBlock *MBB) {
+ MachineBasicBlock::const_iterator I = MBB->end();
+ if (I == MBB->begin())
+ return 0; // Empty MBB.
+
+ --I;
+ unsigned Hash = HashMachineInstr(I);
+
+ if (I == MBB->begin())
+ return Hash; // Single instr MBB.
+
+ --I;
+ // Hash in the second-to-last instruction.
+ Hash ^= HashMachineInstr(I) << 2;
+ return Hash;
+}
+
+/// ComputeCommonTailLength - Given two machine basic blocks, compute the number
+/// of instructions they actually have in common together at their end. Return
+/// iterators for the first shared instruction in each block.
+static unsigned ComputeCommonTailLength(MachineBasicBlock *MBB1,
+ MachineBasicBlock *MBB2,
+ MachineBasicBlock::iterator &I1,
+ MachineBasicBlock::iterator &I2) {
+ I1 = MBB1->end();
+ I2 = MBB2->end();
+
+ unsigned TailLen = 0;
+ while (I1 != MBB1->begin() && I2 != MBB2->begin()) {
+ --I1; --I2;
+ if (!I1->isIdenticalTo(I2)) {
+ ++I1; ++I2;
+ break;
}
+ ++TailLen;
+ }
+ return TailLen;
+}
- EverMadeChange |= MadeChange;
+/// ReplaceTailWithBranchTo - Delete the instruction OldInst and everything
+/// after it, replacing it with an unconditional branch to NewDest. This
+/// returns true if OldInst's block is modified, false if NewDest is modified.
+void BranchFolder::ReplaceTailWithBranchTo(MachineBasicBlock::iterator OldInst,
+ MachineBasicBlock *NewDest) {
+ MachineBasicBlock *OldBB = OldInst->getParent();
+
+ // Remove all the old successors of OldBB from the CFG.
+ while (!OldBB->succ_empty())
+ OldBB->removeSuccessor(OldBB->succ_begin());
+
+ // Remove all the dead instructions from the end of OldBB.
+ OldBB->erase(OldInst, OldBB->end());
+
+ // If OldBB isn't immediately before OldBB, insert a branch to it.
+ if (++MachineFunction::iterator(OldBB) != MachineFunction::iterator(NewDest))
+ TII->InsertBranch(*OldBB, NewDest, 0, std::vector<MachineOperand>());
+ OldBB->addSuccessor(NewDest);
+ ++NumTailMerge;
+}
+
+/// SplitMBBAt - Given a machine basic block and an iterator into it, split the
+/// MBB so that the part before the iterator falls into the part starting at the
+/// iterator. This returns the new MBB.
+MachineBasicBlock *BranchFolder::SplitMBBAt(MachineBasicBlock &CurMBB,
+ MachineBasicBlock::iterator BBI1) {
+ // Create the fall-through block.
+ MachineFunction::iterator MBBI = &CurMBB;
+ MachineBasicBlock *NewMBB = new MachineBasicBlock(CurMBB.getBasicBlock());
+ CurMBB.getParent()->getBasicBlockList().insert(++MBBI, NewMBB);
+
+ // Move all the successors of this block to the specified block.
+ while (!CurMBB.succ_empty()) {
+ MachineBasicBlock *S = *(CurMBB.succ_end()-1);
+ NewMBB->addSuccessor(S);
+ CurMBB.removeSuccessor(S);
+ }
+
+ // Add an edge from CurMBB to NewMBB for the fall-through.
+ CurMBB.addSuccessor(NewMBB);
+
+ // Splice the code over.
+ NewMBB->splice(NewMBB->end(), &CurMBB, BBI1, CurMBB.end());
+ return NewMBB;
+}
+
+/// EstimateRuntime - Make a rough estimate for how long it will take to run
+/// the specified code.
+static unsigned EstimateRuntime(MachineBasicBlock::iterator I,
+ MachineBasicBlock::iterator E,
+ const TargetInstrInfo *TII) {
+ unsigned Time = 0;
+ for (; I != E; ++I) {
+ const TargetInstrDescriptor &TID = TII->get(I->getOpcode());
+ if (TID.Flags & M_CALL_FLAG)
+ Time += 10;
+ else if (TID.Flags & (M_LOAD_FLAG|M_STORE_FLAG))
+ Time += 2;
+ else
+ ++Time;
}
+ return Time;
+}
- return EverMadeChange;
+/// ShouldSplitFirstBlock - We need to either split MBB1 at MBB1I or MBB2 at
+/// MBB2I and then insert an unconditional branch in the other block. Determine
+/// which is the best to split
+static bool ShouldSplitFirstBlock(MachineBasicBlock *MBB1,
+ MachineBasicBlock::iterator MBB1I,
+ MachineBasicBlock *MBB2,
+ MachineBasicBlock::iterator MBB2I,
+ const TargetInstrInfo *TII) {
+ // 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.
+ unsigned MBB1Time = EstimateRuntime(MBB1->begin(), MBB1I, TII);
+ unsigned MBB2Time = EstimateRuntime(MBB2->begin(), MBB2I, TII);
+
+ // If the MBB1 prefix takes "less time" to run than the MBB2 prefix, split the
+ // MBB1 block so it falls through. This will penalize the MBB2 path, but will
+ // have a lower overall impact on the program execution.
+ 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));
+ }
+
+ // Sort by hash value so that blocks with identical end sequences sort
+ // together.
+ std::stable_sort(MergePotentials.begin(), MergePotentials.end());
+
+ // Walk through equivalence sets looking for actual exact matches.
+ while (MergePotentials.size() > 1) {
+ unsigned CurHash = (MergePotentials.end()-1)->first;
+ unsigned PrevHash = (MergePotentials.end()-2)->first;
+ MachineBasicBlock *CurMBB = (MergePotentials.end()-1)->second;
+
+ // If there is nothing that matches the hash of the current basic block,
+ // give up.
+ if (CurHash != PrevHash) {
+ MergePotentials.pop_back();
+ continue;
+ }
+
+ // Determine the actual length of the shared tail between these two basic
+ // blocks. Because the hash can have collisions, it's possible that this is
+ // less than 2.
+ MachineBasicBlock::iterator BBI1, BBI2;
+ unsigned CommonTailLen =
+ ComputeCommonTailLength(CurMBB, (MergePotentials.end()-2)->second,
+ BBI1, BBI2);
+
+ // 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.
+ if (CommonTailLen < 2) {
+ unsigned FoundMatch = ~0U;
+ for (int i = MergePotentials.size()-2;
+ i != -1 && MergePotentials[i].first == CurHash; --i) {
+ CommonTailLen = ComputeCommonTailLength(CurMBB,
+ MergePotentials[i].second,
+ BBI1, BBI2);
+ if (CommonTailLen >= 2) {
+ FoundMatch = i;
+ break;
+ }
+ }
+
+ // If we didn't find anything that has at least two instructions matching
+ // this one, bail out.
+ if (FoundMatch == ~0U) {
+ MergePotentials.pop_back();
+ continue;
+ }
+
+ // Otherwise, move the matching block to the right position.
+ std::swap(MergePotentials[FoundMatch], *(MergePotentials.end()-2));
+ }
+
+ 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) {
+ 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)) {
+ CurMBB = SplitMBBAt(*CurMBB, BBI1);
+ BBI1 = CurMBB->begin();
+ MergePotentials.back().second = CurMBB;
+ } else {
+ MBB2 = SplitMBBAt(*MBB2, BBI2);
+ BBI2 = MBB2->begin();
+ (MergePotentials.end()-2)->second = MBB2;
+ }
+ }
+
+ if (MBB2->begin() == BBI2) {
+ // 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?");
+ // Hack the end off MBB2, making it jump to CurMBB instead.
+ ReplaceTailWithBranchTo(BBI2, CurMBB);
+ // This modifies MBB2, so remove it from the worklist.
+ MergePotentials.erase(MergePotentials.end()-2);
+ }
+ MadeChange = true;
+ }
+
+ return MadeChange;
+}
+
+
+//===----------------------------------------------------------------------===//
+// Branch Optimization
+//===----------------------------------------------------------------------===//
+
+bool BranchFolder::OptimizeBranches(MachineFunction &MF) {
+ MadeChange = false;
+
+ for (MachineFunction::iterator I = ++MF.begin(), E = MF.end(); I != E; ) {
+ MachineBasicBlock *MBB = I++;
+ OptimizeBlock(MBB);
+
+ // If it is dead, remove it.
+ if (MBB->pred_empty()) {
+ RemoveDeadBlock(MBB);
+ MadeChange = true;
+ ++NumDeadBlocks;
+ }
+ }
+ return MadeChange;
}
+
+/// CorrectExtraCFGEdges - Various pieces of code can cause excess edges in the
+/// CFG to be inserted. If we have proven that MBB can only branch to DestA and
+/// DestB, remove any other MBB successors from the CFG. DestA and DestB can
+/// be null.
+static bool CorrectExtraCFGEdges(MachineBasicBlock &MBB,
+ MachineBasicBlock *DestA,
+ MachineBasicBlock *DestB,
+ bool isCond,
+ MachineFunction::iterator FallThru) {
+ bool MadeChange = false;
+ bool AddedFallThrough = false;
+
+ // If this block ends with a conditional branch that falls through to its
+ // successor, set DestB as the successor.
+ if (isCond) {
+ if (DestB == 0 && FallThru != MBB.getParent()->end()) {
+ DestB = FallThru;
+ AddedFallThrough = true;
+ }
+ } else {
+ // If this is an unconditional branch with no explicit dest, it must just be
+ // a fallthrough into DestB.
+ if (DestA == 0 && FallThru != MBB.getParent()->end()) {
+ DestA = FallThru;
+ AddedFallThrough = true;
+ }
+ }
+
+ MachineBasicBlock::pred_iterator SI = MBB.succ_begin();
+ while (SI != MBB.succ_end()) {
+ if (*SI == DestA) {
+ DestA = 0;
+ ++SI;
+ } else if (*SI == DestB) {
+ DestB = 0;
+ ++SI;
+ } else {
+ // Otherwise, this is a superfluous edge, remove it.
+ MBB.removeSuccessor(SI);
+ MadeChange = true;
+ }
+ }
+ if (!AddedFallThrough) {
+ assert(DestA == 0 && DestB == 0 &&
+ "MachineCFG is missing edges!");
+ } else if (isCond) {
+ assert(DestA == 0 && "MachineCFG is missing edges!");
+ }
+ return MadeChange;
+}
+
+
/// ReplaceUsesOfBlockWith - Given a machine basic block 'BB' that branched to
/// 'Old', change the code and CFG so that it branches to 'New' instead.
static void ReplaceUsesOfBlockWith(MachineBasicBlock *BB,
MachineBasicBlock *Old,
MachineBasicBlock *New,
- const TargetInstrInfo &TII) {
+ const TargetInstrInfo *TII) {
assert(Old != New && "Cannot replace self with self!");
MachineBasicBlock::iterator I = BB->end();
while (I != BB->begin()) {
--I;
- if (!TII.isTerminatorInstr(I->getOpcode())) break;
+ if (!TII->isTerminatorInstr(I->getOpcode())) break;
// Scan the operands of this machine instruction, replacing any uses of Old
// with New.
}
}
+/// CanFallThrough - Return true if the specified block (with the specified
+/// branch condition) can implicitly transfer control to the block after it by
+/// falling off the end of it. This should return false if it can reach the
+/// block after it, but it uses an explicit branch to do so (e.g. a table jump).
+///
+/// True is a conservative answer.
+///
+bool BranchFolder::CanFallThrough(MachineBasicBlock *CurBB,
+ bool BranchUnAnalyzable,
+ MachineBasicBlock *TBB, MachineBasicBlock *FBB,
+ const std::vector<MachineOperand> &Cond) {
+ MachineFunction::iterator Fallthrough = CurBB;
+ ++Fallthrough;
+ // If FallthroughBlock is off the end of the function, it can't fall through.
+ if (Fallthrough == CurBB->getParent()->end())
+ return false;
+
+ // If FallthroughBlock isn't a successor of CurBB, no fallthrough is possible.
+ if (!CurBB->isSuccessor(Fallthrough))
+ return false;
+
+ // If we couldn't analyze the branch, assume it could fall through.
+ if (BranchUnAnalyzable) return true;
+
+ // If there is no branch, control always falls through.
+ if (TBB == 0) return true;
+
+ // If there is some explicit branch to the fallthrough block, it can obviously
+ // reach, even though the branch should get folded to fall through implicitly.
+ if (MachineFunction::iterator(TBB) == Fallthrough ||
+ MachineFunction::iterator(FBB) == Fallthrough)
+ return true;
+
+ // If it's an unconditional branch to some block not the fall through, it
+ // doesn't fall through.
+ if (Cond.empty()) return false;
+
+ // Otherwise, if it is conditional and has no explicit false block, it falls
+ // through.
+ return FBB == 0;
+}
+
+/// CanFallThrough - Return true if the specified can implicitly transfer
+/// control to the block after it by falling off the end of it. This should
+/// return false if it can reach the block after it, but it uses an explicit
+/// branch to do so (e.g. a table jump).
+///
+/// True is a conservative answer.
+///
+bool BranchFolder::CanFallThrough(MachineBasicBlock *CurBB) {
+ MachineBasicBlock *TBB = 0, *FBB = 0;
+ std::vector<MachineOperand> Cond;
+ bool CurUnAnalyzable = TII->AnalyzeBranch(*CurBB, TBB, FBB, Cond);
+ return CanFallThrough(CurBB, CurUnAnalyzable, TBB, FBB, Cond);
+}
-bool BranchFolder::OptimizeBlock(MachineFunction::iterator MBB,
- const TargetInstrInfo &TII) {
+/// OptimizeBlock - Analyze and optimize control flow related to the specified
+/// block. This is never called on the entry block.
+void BranchFolder::OptimizeBlock(MachineBasicBlock *MBB) {
+ MachineFunction::iterator FallThrough = MBB;
+ ++FallThrough;
+
// If this block is empty, make everyone use its fall-through, not the block
// explicitly.
if (MBB->empty()) {
- if (MBB->pred_empty()) return false;
- MachineFunction::iterator FallThrough =next(MBB);
- assert(FallThrough != MBB->getParent()->end() &&
- "Fell off the end of the function!");
- while (!MBB->pred_empty()) {
- MachineBasicBlock *Pred = *(MBB->pred_end()-1);
- ReplaceUsesOfBlockWith(Pred, MBB, FallThrough, TII);
+ // Dead block? Leave for cleanup later.
+ if (MBB->pred_empty()) return;
+
+ if (FallThrough == MBB->getParent()->end()) {
+ // TODO: Simplify preds to not branch here if possible!
+ } else {
+ // Rewrite all predecessors of the old block to go to the fallthrough
+ // instead.
+ while (!MBB->pred_empty()) {
+ MachineBasicBlock *Pred = *(MBB->pred_end()-1);
+ ReplaceUsesOfBlockWith(Pred, MBB, FallThrough, TII);
+ }
+
+ // If MBB was the target of a jump table, update jump tables to go to the
+ // fallthrough instead.
+ MBB->getParent()->getJumpTableInfo()->
+ ReplaceMBBInJumpTables(MBB, FallThrough);
+ MadeChange = true;
}
- return true;
+ return;
}
-#if 0
+ // Check to see if we can simplify the terminator of the block before this
+ // one.
+ MachineBasicBlock &PrevBB = *prior(MachineFunction::iterator(MBB));
- if (MBB->pred_size() == 1) {
- // If this block has a single predecessor, and if that block has a single
- // successor, merge this block into that block.
- MachineBasicBlock *Pred = *MBB->pred_begin();
- if (Pred->succ_size() == 1) {
- // Delete all of the terminators from end of the pred block. NOTE, this
- // assumes that terminators do not have side effects!
- // FIXME: This doesn't work for FP_REG_KILL.
-
- while (!Pred->empty() && TII.isTerminatorInstr(Pred->back().getOpcode()))
- Pred->pop_back();
-
- // Splice the instructions over.
- Pred->splice(Pred->end(), MBB, MBB->begin(), MBB->end());
-
- // If MBB does not end with a barrier, add a goto instruction to the end.
- if (Pred->empty() || !TII.isBarrier(Pred->back().getOpcode()))
- TII.insertGoto(*Pred, *next(MBB));
-
- // Update the CFG now.
- Pred->removeSuccessor(Pred->succ_begin());
- while (!MBB->succ_empty()) {
- Pred->addSuccessor(*(MBB->succ_end()-1));
- MBB->removeSuccessor(MBB->succ_end()-1);
+ MachineBasicBlock *PriorTBB = 0, *PriorFBB = 0;
+ std::vector<MachineOperand> PriorCond;
+ bool PriorUnAnalyzable =
+ TII->AnalyzeBranch(PrevBB, PriorTBB, PriorFBB, PriorCond);
+ if (!PriorUnAnalyzable) {
+ // If the CFG for the prior block has extra edges, remove them.
+ MadeChange |= CorrectExtraCFGEdges(PrevBB, PriorTBB, PriorFBB,
+ !PriorCond.empty(), MBB);
+
+ // If the previous branch is conditional and both conditions go to the same
+ // destination, remove the branch, replacing it with an unconditional one or
+ // a fall-through.
+ if (PriorTBB && PriorTBB == PriorFBB) {
+ TII->RemoveBranch(PrevBB);
+ PriorCond.clear();
+ if (PriorTBB != MBB)
+ TII->InsertBranch(PrevBB, PriorTBB, 0, PriorCond);
+ MadeChange = true;
+ ++NumBranchOpts;
+ return OptimizeBlock(MBB);
+ }
+
+ // If the previous branch *only* branches to *this* block (conditional or
+ // not) remove the branch.
+ if (PriorTBB == MBB && PriorFBB == 0) {
+ TII->RemoveBranch(PrevBB);
+ MadeChange = true;
+ ++NumBranchOpts;
+ return OptimizeBlock(MBB);
+ }
+
+ // If the prior block branches somewhere else on the condition and here if
+ // the condition is false, remove the uncond second branch.
+ if (PriorFBB == MBB) {
+ TII->RemoveBranch(PrevBB);
+ TII->InsertBranch(PrevBB, PriorTBB, 0, PriorCond);
+ MadeChange = true;
+ ++NumBranchOpts;
+ return OptimizeBlock(MBB);
+ }
+
+ // If the prior block branches here on true and somewhere else on false, and
+ // if the branch condition is reversible, reverse the branch to create a
+ // fall-through.
+ if (PriorTBB == MBB) {
+ std::vector<MachineOperand> NewPriorCond(PriorCond);
+ if (!TII->ReverseBranchCondition(NewPriorCond)) {
+ TII->RemoveBranch(PrevBB);
+ TII->InsertBranch(PrevBB, PriorFBB, 0, NewPriorCond);
+ MadeChange = true;
+ ++NumBranchOpts;
+ return OptimizeBlock(MBB);
}
- return true;
}
}
- // If BB falls through into Old, insert an unconditional branch to New.
- MachineFunction::iterator BBSucc = BB; ++BBSucc;
- if (BBSucc != BB->getParent()->end() && &*BBSucc == Old)
- TII.insertGoto(*BB, *New);
-
-
- if (MBB->pred_size() == 1) {
- // If this block has a single predecessor, and if that block has a single
- // successor, merge this block into that block.
- MachineBasicBlock *Pred = *MBB->pred_begin();
- if (Pred->succ_size() == 1) {
- // Delete all of the terminators from end of the pred block. NOTE, this
- // assumes that terminators do not have side effects!
- // FIXME: This doesn't work for FP_REG_KILL.
-
- while (!Pred->empty() && TII.isTerminatorInstr(Pred->back().getOpcode()))
- Pred->pop_back();
-
- // Splice the instructions over.
- Pred->splice(Pred->end(), MBB, MBB->begin(), MBB->end());
+ // Analyze the branch in the current block.
+ MachineBasicBlock *CurTBB = 0, *CurFBB = 0;
+ std::vector<MachineOperand> CurCond;
+ bool CurUnAnalyzable = TII->AnalyzeBranch(*MBB, CurTBB, CurFBB, CurCond);
+ if (!CurUnAnalyzable) {
+ // If the CFG for the prior block has extra edges, remove them.
+ MadeChange |= CorrectExtraCFGEdges(*MBB, CurTBB, CurFBB,
+ !CurCond.empty(),
+ ++MachineFunction::iterator(MBB));
- // If MBB does not end with a barrier, add a goto instruction to the end.
- if (Pred->empty() || !TII.isBarrier(Pred->back().getOpcode()))
- TII.insertGoto(*Pred, *next(MBB));
+ // If this branch is the only thing in its block, see if we can forward
+ // other blocks across it.
+ if (CurTBB && CurCond.empty() && CurFBB == 0 &&
+ TII->isBranch(MBB->begin()->getOpcode()) && CurTBB != MBB) {
+ // This block may contain just an unconditional branch. Because there can
+ // be 'non-branch terminators' in the block, try removing the branch and
+ // then seeing if the block is empty.
+ TII->RemoveBranch(*MBB);
- // Update the CFG now.
- Pred->removeSuccessor(Pred->succ_begin());
- while (!MBB->succ_empty()) {
- Pred->addSuccessor(*(MBB->succ_end()-1));
- MBB->removeSuccessor(MBB->succ_end()-1);
- }
- return true;
- }
- }
+ // If this block is just an unconditional branch to CurTBB, we can
+ // usually completely eliminate the block. The only case we cannot
+ // completely eliminate the block is when the block before this one
+ // falls through into MBB and we can't understand the prior block's branch
+ // condition.
+ if (MBB->empty()) {
+ bool PredHasNoFallThrough = TII->BlockHasNoFallThrough(PrevBB);
+ if (PredHasNoFallThrough || !PriorUnAnalyzable ||
+ !PrevBB.isSuccessor(MBB)) {
+ // If the prior block falls through into us, turn it into an
+ // explicit branch to us to make updates simpler.
+ if (!PredHasNoFallThrough && PrevBB.isSuccessor(MBB) &&
+ PriorTBB != MBB && PriorFBB != MBB) {
+ if (PriorTBB == 0) {
+ assert(PriorCond.empty() && PriorFBB == 0 &&
+ "Bad branch analysis");
+ PriorTBB = MBB;
+ } else {
+ assert(PriorFBB == 0 && "Machine CFG out of date!");
+ PriorFBB = MBB;
+ }
+ TII->RemoveBranch(PrevBB);
+ TII->InsertBranch(PrevBB, PriorTBB, PriorFBB, PriorCond);
+ }
- // If the first instruction in this block is an unconditional branch, and if
- // there are predecessors, fold the branch into the predecessors.
- if (!MBB->pred_empty() && isUncondBranch(MBB->begin(), TII)) {
- MachineInstr *Br = MBB->begin();
- assert(Br->getNumOperands() == 1 && Br->getOperand(0).isMachineBasicBlock()
- && "Uncond branch should take one MBB argument!");
- MachineBasicBlock *Dest = Br->getOperand(0).getMachineBasicBlock();
+ // Iterate through all the predecessors, revectoring each in-turn.
+ MachineBasicBlock::pred_iterator PI = MBB->pred_begin();
+ bool DidChange = false;
+ bool HasBranchToSelf = false;
+ while (PI != MBB->pred_end()) {
+ if (*PI == MBB) {
+ // If this block has an uncond branch to itself, leave it.
+ ++PI;
+ HasBranchToSelf = true;
+ } else {
+ DidChange = true;
+ ReplaceUsesOfBlockWith(*PI, MBB, CurTBB, TII);
+ }
+ }
- while (!MBB->pred_empty()) {
- MachineBasicBlock *Pred = *(MBB->pred_end()-1);
- ReplaceUsesOfBlockWith(Pred, MBB, Dest, TII);
+ // Change any jumptables to go to the new MBB.
+ MBB->getParent()->getJumpTableInfo()->
+ ReplaceMBBInJumpTables(MBB, CurTBB);
+ if (DidChange) {
+ ++NumBranchOpts;
+ MadeChange = true;
+ if (!HasBranchToSelf) return;
+ }
+ }
+ }
+
+ // Add the branch back if the block is more than just an uncond branch.
+ TII->InsertBranch(*MBB, CurTBB, 0, CurCond);
}
- return true;
}
- // If the last instruction is an unconditional branch and the fall through
- // block is the destination, just delete the branch.
- if (isUncondBranch(--MBB->end(), TII)) {
- MachineBasicBlock::iterator MI = --MBB->end();
- MachineInstr *UncondBr = MI;
- MachineFunction::iterator FallThrough = next(MBB);
-
- MachineFunction::iterator UncondDest =
- MI->getOperand(0).getMachineBasicBlock();
- if (UncondDest == FallThrough) {
- // Just delete the branch. This does not effect the CFG.
- MBB->erase(UncondBr);
- return true;
- }
-
- // Okay, so we don't have a fall-through. Check to see if we have an
- // conditional branch that would be a fall through if we reversed it. If
- // so, invert the condition and delete the uncond branch.
- if (MI != MBB->begin() && isCondBranch(--MI, TII)) {
- // We assume that conditional branches always have the branch dest as the
- // last operand. This could be generalized in the future if needed.
- unsigned LastOpnd = MI->getNumOperands()-1;
- if (MachineFunction::iterator(
- MI->getOperand(LastOpnd).getMachineBasicBlock()) == FallThrough) {
- // Change the cond branch to go to the uncond dest, nuke the uncond,
- // then reverse the condition.
- MI->getOperand(LastOpnd).setMachineBasicBlock(UncondDest);
- MBB->erase(UncondBr);
- TII.reverseBranchCondition(MI);
- return true;
+ // If the prior block doesn't fall through into this block, and if this
+ // block doesn't fall through into some other block, see if we can find a
+ // place to move this block where a fall-through will happen.
+ if (!CanFallThrough(&PrevBB, PriorUnAnalyzable,
+ PriorTBB, PriorFBB, PriorCond)) {
+ // Now we know that there was no fall-through into this block, check to
+ // see if it has a fall-through into its successor.
+ if (!CanFallThrough(MBB, CurUnAnalyzable, CurTBB, CurFBB, CurCond)) {
+ // Check all the predecessors of this block. If one of them has no fall
+ // throughs, move this block right after it.
+ for (MachineBasicBlock::pred_iterator PI = MBB->pred_begin(),
+ E = MBB->pred_end(); PI != E; ++PI) {
+ // Analyze the branch at the end of the pred.
+ MachineBasicBlock *PredBB = *PI;
+ MachineFunction::iterator PredFallthrough = PredBB; ++PredFallthrough;
+ std::vector<MachineOperand> PredCond;
+ if (PredBB != MBB && !CanFallThrough(PredBB)) {
+ MBB->moveAfter(PredBB);
+ MadeChange = true;
+ return OptimizeBlock(MBB);
+ }
+ }
+
+ // Check all successors to see if we can move this block before it.
+ for (MachineBasicBlock::succ_iterator SI = MBB->succ_begin(),
+ E = MBB->succ_end(); SI != E; ++SI) {
+ // Analyze the branch at the end of the block before the succ.
+ MachineBasicBlock *SuccBB = *SI;
+ MachineFunction::iterator SuccPrev = SuccBB; --SuccPrev;
+ std::vector<MachineOperand> SuccPrevCond;
+ if (SuccBB != MBB && !CanFallThrough(SuccPrev)) {
+ MBB->moveBefore(SuccBB);
+ MadeChange = true;
+ return OptimizeBlock(MBB);
+ }
+ }
+
+ // Okay, there is no really great place to put this block. If, however,
+ // the block before this one would be a fall-through if this block were
+ // removed, move this block to the end of the function.
+ if (FallThrough != MBB->getParent()->end() &&
+ PrevBB.isSuccessor(FallThrough)) {
+ MBB->moveAfter(--MBB->getParent()->end());
+ MadeChange = true;
+ return;
}
}
}
-#endif
- return false;
}
projects / oota-llvm.git / blobdiff