From 2bdb7d0cc88881857073b36f4a09ebe2f2008c24 Mon Sep 17 00:00:00 2001 From: Evan Cheng Date: Mon, 18 Jun 2007 22:43:58 +0000 Subject: [PATCH] Move CorrectExtraCFGEdges() from BranchFolding.cpp to a MachineBasicBlock method. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@37633 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/CodeGen/MachineBasicBlock.h | 10 +++ lib/CodeGen/BranchFolding.cpp | 79 ++---------------------- lib/CodeGen/MachineBasicBlock.cpp | 60 ++++++++++++++++++ 3 files changed, 74 insertions(+), 75 deletions(-) diff --git a/include/llvm/CodeGen/MachineBasicBlock.h b/include/llvm/CodeGen/MachineBasicBlock.h index 790be6cb644..fe8a0ab3005 100644 --- a/include/llvm/CodeGen/MachineBasicBlock.h +++ b/include/llvm/CodeGen/MachineBasicBlock.h @@ -250,6 +250,16 @@ public: /// 'Old', change the code and CFG so that it branches to 'New' instead. void ReplaceUsesOfBlockWith(MachineBasicBlock *Old, MachineBasicBlock *New); + /// 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. Besides DestA and DestB, retain other edges leading + /// to LandingPads (currently there can be only one; we don't check or require + /// that here). Note it is possible that DestA and/or DestB are LandingPads. + bool CorrectExtraCFGEdges(MachineBasicBlock *DestA, + MachineBasicBlock *DestB, + bool isCond); + // Debugging methods. void dump() const; void print(std::ostream &OS) const; diff --git a/lib/CodeGen/BranchFolding.cpp b/lib/CodeGen/BranchFolding.cpp index 71fac0b8eb7..ad7d5fcc332 100644 --- a/lib/CodeGen/BranchFolding.cpp +++ b/lib/CodeGen/BranchFolding.cpp @@ -87,12 +87,6 @@ namespace { char BranchFolder::ID = 0; } -static bool CorrectExtraCFGEdges(MachineBasicBlock &MBB, - MachineBasicBlock *DestA, - MachineBasicBlock *DestB, - bool isCond, - MachineFunction::iterator FallThru); - FunctionPass *llvm::createBranchFoldingPass(bool DefaultEnableTailMerge) { return new BranchFolder(DefaultEnableTailMerge); } @@ -133,8 +127,7 @@ bool BranchFolder::runOnMachineFunction(MachineFunction &MF) { MachineBasicBlock *MBB = I, *TBB = 0, *FBB = 0; std::vector Cond; if (!TII->AnalyzeBranch(*MBB, TBB, FBB, Cond)) - EverMadeChange |= CorrectExtraCFGEdges(*MBB, TBB, FBB, - !Cond.empty(), next(I)); + EverMadeChange |= MBB->CorrectExtraCFGEdges(TBB, FBB, !Cond.empty()); } RegInfo = MF.getTarget().getRegisterInfo(); @@ -702,68 +695,6 @@ bool BranchFolder::OptimizeBranches(MachineFunction &MF) { } -/// 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. -/// Besides DestA and DestB, retain other edges leading to LandingPads (currently -/// there can be only one; we don't check or require that here). -/// Note it is possible that DestA and/or DestB are LandingPads. -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::succ_iterator SI = MBB.succ_begin(); - MachineBasicBlock *OrigDestA = DestA, *OrigDestB = DestB; - while (SI != MBB.succ_end()) { - if (*SI == DestA && DestA == DestB) { - DestA = DestB = 0; - ++SI; - } else if (*SI == DestA) { - DestA = 0; - ++SI; - } else if (*SI == DestB) { - DestB = 0; - ++SI; - } else if ((*SI)->isLandingPad() && - *SI!=OrigDestA && *SI!=OrigDestB) { - ++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; -} - - /// 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 @@ -880,8 +811,8 @@ void BranchFolder::OptimizeBlock(MachineBasicBlock *MBB) { 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); + MadeChange |= PrevBB.CorrectExtraCFGEdges(PriorTBB, PriorFBB, + !PriorCond.empty()); // If the previous branch is conditional and both conditions go to the same // destination, remove the branch, replacing it with an unconditional one or @@ -993,9 +924,7 @@ void BranchFolder::OptimizeBlock(MachineBasicBlock *MBB) { 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)); + MadeChange |= MBB->CorrectExtraCFGEdges(CurTBB, CurFBB, !CurCond.empty()); // If this is a two-way branch, and the FBB branches to this block, reverse // the condition so the single-basic-block loop is faster. Instead of: diff --git a/lib/CodeGen/MachineBasicBlock.cpp b/lib/CodeGen/MachineBasicBlock.cpp index af3676431f6..da062b1559e 100644 --- a/lib/CodeGen/MachineBasicBlock.cpp +++ b/lib/CodeGen/MachineBasicBlock.cpp @@ -225,3 +225,63 @@ void MachineBasicBlock::ReplaceUsesOfBlockWith(MachineBasicBlock *Old, addSuccessor(New); } +/// 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. +/// Besides DestA and DestB, retain other edges leading to LandingPads (currently +/// there can be only one; we don't check or require that here). +/// Note it is possible that DestA and/or DestB are LandingPads. +bool MachineBasicBlock::CorrectExtraCFGEdges(MachineBasicBlock *DestA, + MachineBasicBlock *DestB, + bool isCond) { + bool MadeChange = false; + bool AddedFallThrough = false; + + MachineBasicBlock *FallThru = getNext(); + + // 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 != 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 != getParent()->end()) { + DestA = FallThru; + AddedFallThrough = true; + } + } + + MachineBasicBlock::succ_iterator SI = succ_begin(); + MachineBasicBlock *OrigDestA = DestA, *OrigDestB = DestB; + while (SI != succ_end()) { + if (*SI == DestA && DestA == DestB) { + DestA = DestB = 0; + ++SI; + } else if (*SI == DestA) { + DestA = 0; + ++SI; + } else if (*SI == DestB) { + DestB = 0; + ++SI; + } else if ((*SI)->isLandingPad() && + *SI!=OrigDestA && *SI!=OrigDestB) { + ++SI; + } else { + // Otherwise, this is a superfluous edge, remove it. + 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; +} -- 2.34.1