Index: lib/CodeGen/BranchFolding.cpp |
=================================================================== |
--- lib/CodeGen/BranchFolding.cpp (revision 78188) |
+++ lib/CodeGen/BranchFolding.cpp (working copy) |
@@ -18,6 +18,7 @@ |
#define DEBUG_TYPE "branchfolding" |
#include "llvm/CodeGen/Passes.h" |
+#include "llvm/CodeGen/MachineConstantPool.h" |
#include "llvm/CodeGen/MachineModuleInfo.h" |
#include "llvm/CodeGen/MachineFunctionPass.h" |
#include "llvm/CodeGen/MachineJumpTableInfo.h" |
@@ -37,18 +38,18 @@ |
STATISTIC(NumDeadBlocks, "Number of dead blocks removed"); |
STATISTIC(NumBranchOpts, "Number of branches optimized"); |
STATISTIC(NumTailMerge , "Number of block tails merged"); |
-static cl::opt<cl::boolOrDefault> FlagEnableTailMerge("enable-tail-merge", |
+static cl::opt<cl::boolOrDefault> FlagEnableTailMerge("enable-tail-merge", |
cl::init(cl::BOU_UNSET), cl::Hidden); |
// Throttle for huge numbers of predecessors (compile speed problems) |
static cl::opt<unsigned> |
-TailMergeThreshold("tail-merge-threshold", |
+TailMergeThreshold("tail-merge-threshold", |
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) : |
+ explicit BranchFolder(bool defaultEnableTailMerge) : |
MachineFunctionPass(&ID) { |
switch (FlagEnableTailMerge) { |
case cl::BOU_UNSET: EnableTailMerge = defaultEnableTailMerge; break; |
@@ -92,7 +93,7 @@ |
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, |
@@ -101,7 +102,7 @@ |
char BranchFolder::ID = 0; |
} |
-FunctionPass *llvm::createBranchFoldingPass(bool DefaultEnableTailMerge) { |
+FunctionPass *llvm::createBranchFoldingPass(bool DefaultEnableTailMerge) { |
return new BranchFolder(DefaultEnableTailMerge); } |
/// RemoveDeadBlock - Remove the specified dead machine basic block from the |
@@ -109,12 +110,12 @@ |
void BranchFolder::RemoveDeadBlock(MachineBasicBlock *MBB) { |
assert(MBB->pred_empty() && "MBB must be dead!"); |
DOUT << "\nRemoving MBB: " << *MBB; |
- |
+ |
MachineFunction *MF = MBB->getParent(); |
// drop all successors. |
while (!MBB->succ_empty()) |
MBB->removeSuccessor(MBB->succ_end()-1); |
- |
+ |
// If there are any labels in the basic block, unregister them from |
// MachineModuleInfo. |
if (MMI && !MBB->empty()) { |
@@ -125,7 +126,7 @@ |
MMI->InvalidateLabel(I->getOperand(0).getImm()); |
} |
} |
- |
+ |
// Remove the block. |
MF->erase(MBB); |
} |
@@ -217,7 +218,7 @@ |
// 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); |
@@ -225,7 +226,7 @@ |
// 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. |
@@ -237,14 +238,29 @@ |
for (unsigned op = 0, e = I->getNumOperands(); op != e; ++op) { |
MachineOperand &Op = I->getOperand(op); |
if (!Op.isJTI()) continue; |
- unsigned NewIdx = JTMapping[Op.getIndex()]; |
+ // Remap index. |
+ const unsigned NewIdx = JTMapping[Op.getIndex()]; |
Op.setIndex(NewIdx); |
- |
// Remember that this JT is live. |
JTIsLive.set(NewIdx); |
} |
} |
- |
+ |
+ // This currently only used on ARM targets where the ConstantPool |
+ // subclass is overloading getJumpTableIndex() |
+ const std::vector<MachineConstantPoolEntry>& CPs = |
+ MF.getConstantPool()->getConstants(); |
+ for (unsigned i = 0, e = CPs.size(); i != e; ++i) { |
+ if (!CPs[i].isMachineConstantPoolEntry()) continue; |
+ unsigned *JTIndex = CPs[i].Val.MachineCPVal->getJumpTableIndex(); |
+ if (!JTIndex) continue; |
+ // Remap index. |
+ const unsigned NewIdx = JTMapping[*JTIndex]; |
+ *JTIndex = NewIdx; |
+ // Remember that this JT is live. |
+ JTIsLive.set(NewIdx); |
+ } |
+ |
// 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. |
@@ -254,7 +270,7 @@ |
EverMadeChange = true; |
} |
} |
- |
+ |
delete RS; |
return EverMadeChange; |
} |
@@ -268,7 +284,7 @@ |
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()) { |
@@ -290,15 +306,15 @@ |
break; |
default: break; |
} |
- |
+ |
Hash += ((OperandHash << 3) | Op.getType()) << (i&31); |
} |
return Hash; |
} |
/// HashEndOfMBB - Hash the last few instructions in the MBB. For blocks |
-/// with no successors, we hash two instructions, because cross-jumping |
-/// only saves code when at least two instructions are removed (since a |
+/// with no successors, we hash two instructions, because cross-jumping |
+/// only saves code when at least two instructions are removed (since a |
/// branch must be inserted). For blocks with a successor, one of the |
/// two blocks to be tail-merged will end with a branch already, so |
/// it gains to cross-jump even for one instruction. |
@@ -308,13 +324,13 @@ |
MachineBasicBlock::const_iterator I = MBB->end(); |
if (I == MBB->begin()) |
return 0; // Empty MBB. |
- |
+ |
--I; |
unsigned Hash = HashMachineInstr(I); |
- |
+ |
if (I == MBB->begin() || minCommonTailLength == 1) |
return Hash; // Single instr MBB. |
- |
+ |
--I; |
// Hash in the second-to-last instruction. |
Hash ^= HashMachineInstr(I) << 2; |
@@ -330,11 +346,11 @@ |
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) || |
+ if (!I1->isIdenticalTo(I2) || |
// FIXME: This check is dubious. It's used to get around a problem where |
// people incorrectly expect inline asm directives to remain in the same |
// relative order. This is untenable because normal compiler |
@@ -355,11 +371,11 @@ |
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()); |
@@ -384,10 +400,10 @@ |
// Move all the successors of this block to the specified block. |
NewMBB->transferSuccessors(&CurMBB); |
- |
+ |
// 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()); |
@@ -469,23 +485,23 @@ |
} |
/// ComputeSameTails - Look through all the blocks in MergePotentials that have |
-/// hash CurHash (guaranteed to match the last element). Build the vector |
+/// hash CurHash (guaranteed to match the last element). Build the vector |
/// SameTails of all those that have the (same) largest number of instructions |
/// in common of any pair of these blocks. SameTails entries contain an |
-/// iterator into MergePotentials (from which the MachineBasicBlock can be |
-/// found) and a MachineBasicBlock::iterator into that MBB indicating the |
+/// iterator into MergePotentials (from which the MachineBasicBlock can be |
+/// found) and a MachineBasicBlock::iterator into that MBB indicating the |
/// instruction where the matching code sequence begins. |
/// Order of elements in SameTails is the reverse of the order in which |
/// those blocks appear in MergePotentials (where they are not necessarily |
/// consecutive). |
-unsigned BranchFolder::ComputeSameTails(unsigned CurHash, |
+unsigned BranchFolder::ComputeSameTails(unsigned CurHash, |
unsigned minCommonTailLength) { |
unsigned maxCommonTailLength = 0U; |
SameTails.clear(); |
MachineBasicBlock::iterator TrialBBI1, TrialBBI2; |
MPIterator HighestMPIter = prior(MergePotentials.end()); |
for (MPIterator CurMPIter = prior(MergePotentials.end()), |
- B = MergePotentials.begin(); |
+ B = MergePotentials.begin(); |
CurMPIter!=B && CurMPIter->first==CurHash; |
--CurMPIter) { |
for (MPIterator I = prior(CurMPIter); I->first==CurHash ; --I) { |
@@ -524,11 +540,11 @@ |
/// RemoveBlocksWithHash - Remove all blocks with hash CurHash from |
/// MergePotentials, restoring branches at ends of blocks as appropriate. |
-void BranchFolder::RemoveBlocksWithHash(unsigned CurHash, |
+void BranchFolder::RemoveBlocksWithHash(unsigned CurHash, |
MachineBasicBlock* SuccBB, |
MachineBasicBlock* PredBB) { |
MPIterator CurMPIter, B; |
- for (CurMPIter = prior(MergePotentials.end()), B = MergePotentials.begin(); |
+ for (CurMPIter = prior(MergePotentials.end()), B = MergePotentials.begin(); |
CurMPIter->first==CurHash; |
--CurMPIter) { |
// Put the unconditional branch back, if we need one. |
@@ -557,7 +573,7 @@ |
} |
// Otherwise, make a (fairly bogus) choice based on estimate of |
// how long it will take the various blocks to execute. |
- unsigned t = EstimateRuntime(SameTails[i].first->second->begin(), |
+ unsigned t = EstimateRuntime(SameTails[i].first->second->begin(), |
SameTails[i].second); |
if (t<=TimeEstimate) { |
TimeEstimate = t; |
@@ -568,7 +584,7 @@ |
MachineBasicBlock::iterator BBI = SameTails[commonTailIndex].second; |
MachineBasicBlock *MBB = SameTails[commonTailIndex].first->second; |
- DOUT << "\nSplitting " << MBB->getNumber() << ", size " << |
+ DOUT << "\nSplitting " << MBB->getNumber() << ", size " << |
maxCommonTailLength; |
MachineBasicBlock *newMBB = SplitMBBAt(*MBB, BBI); |
@@ -585,7 +601,7 @@ |
// 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). |
+// 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. |
@@ -596,7 +612,7 @@ |
// FIXME: Ask the target to provide the threshold? |
unsigned minCommonTailLength = (SuccBB ? 1 : 2) + 1; |
MadeChange = false; |
- |
+ |
DOUT << "\nTryMergeBlocks " << MergePotentials.size() << '\n'; |
// Sort by hash value so that blocks with identical end sequences sort |
@@ -606,13 +622,13 @@ |
// Walk through equivalence sets looking for actual exact matches. |
while (MergePotentials.size() > 1) { |
unsigned CurHash = prior(MergePotentials.end())->first; |
- |
+ |
// Build SameTails, identifying the set of blocks with this hash code |
// and with the maximum number of instructions in common. |
- unsigned maxCommonTailLength = ComputeSameTails(CurHash, |
+ unsigned maxCommonTailLength = ComputeSameTails(CurHash, |
minCommonTailLength); |
- // If we didn't find any pair that has at least minCommonTailLength |
+ // If we didn't find any pair that has at least minCommonTailLength |
// instructions in common, remove all blocks with this hash code and retry. |
if (SameTails.empty()) { |
RemoveBlocksWithHash(CurHash, SuccBB, PredBB); |
@@ -665,7 +681,7 @@ |
bool BranchFolder::TailMergeBlocks(MachineFunction &MF) { |
if (!EnableTailMerge) return false; |
- |
+ |
MadeChange = false; |
// First find blocks with no successors. |
@@ -684,7 +700,7 @@ |
// (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 |
+ // 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 |
@@ -703,7 +719,7 @@ |
MachineBasicBlock *IBB = I; |
MachineBasicBlock *PredBB = prior(I); |
MergePotentials.clear(); |
- for (MachineBasicBlock::pred_iterator P = I->pred_begin(), |
+ for (MachineBasicBlock::pred_iterator P = I->pred_begin(), |
E2 = I->pred_end(); |
P != E2; ++P) { |
MachineBasicBlock* PBB = *P; |
@@ -760,7 +776,7 @@ |
// Reinsert an unconditional branch if needed. |
// The 1 below can occur as a result of removing blocks in TryMergeBlocks. |
PredBB = prior(I); // this may have been changed in TryMergeBlocks |
- if (MergePotentials.size()==1 && |
+ if (MergePotentials.size()==1 && |
MergePotentials.begin()->second != PredBB) |
FixTail(MergePotentials.begin()->second, I, TII); |
} |
@@ -774,14 +790,14 @@ |
bool BranchFolder::OptimizeBranches(MachineFunction &MF) { |
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); |
- |
+ |
// If it is dead, remove it. |
if (MBB->pred_empty()) { |
RemoveDeadBlock(MBB); |
@@ -802,7 +818,7 @@ |
/// |
bool BranchFolder::CanFallThrough(MachineBasicBlock *CurBB, |
bool BranchUnAnalyzable, |
- MachineBasicBlock *TBB, |
+ MachineBasicBlock *TBB, |
MachineBasicBlock *FBB, |
const SmallVectorImpl<MachineOperand> &Cond) { |
MachineFunction::iterator Fallthrough = CurBB; |
@@ -810,14 +826,14 @@ |
// 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; |
@@ -826,11 +842,11 @@ |
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 |
+ |
+ // 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; |
@@ -854,14 +870,14 @@ |
/// 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 |
/// result in infinite loops. |
-static bool IsBetterFallthrough(MachineBasicBlock *MBB1, |
+static bool IsBetterFallthrough(MachineBasicBlock *MBB1, |
MachineBasicBlock *MBB2) { |
// Right now, we use a simple heuristic. If MBB2 ends with a call, and |
// MBB1 doesn't, we prefer to fall through into MBB1. This allows us to |
// optimize branches that branch to either a return block or an assert block |
// into a fallthrough to the return. |
if (MBB1->empty() || MBB2->empty()) return false; |
- |
+ |
// If there is a clear successor ordering we make sure that one block |
// will fall through to the next |
if (MBB1->isSuccessor(MBB2)) return true; |
@@ -877,14 +893,14 @@ |
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. Landing pads should not do this since the landing-pad table |
// points to this block. |
if (MBB->empty() && !MBB->isLandingPad()) { |
// 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 { |
@@ -894,7 +910,7 @@ |
MachineBasicBlock *Pred = *(MBB->pred_end()-1); |
Pred->ReplaceUsesOfBlockWith(MBB, FallThrough); |
} |
- |
+ |
// If MBB was the target of a jump table, update jump tables to go to the |
// fallthrough instead. |
MBB->getParent()->getJumpTableInfo()-> |
@@ -916,20 +932,20 @@ |
// If the CFG for the prior block has extra edges, remove them. |
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 |
// a fall-through. |
if (PriorTBB && PriorTBB == PriorFBB) { |
TII->RemoveBranch(PrevBB); |
- PriorCond.clear(); |
+ 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) { |
@@ -938,7 +954,7 @@ |
++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) { |
@@ -948,7 +964,7 @@ |
++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. |
@@ -962,7 +978,7 @@ |
return OptimizeBlock(MBB); |
} |
} |
- |
+ |
// 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 |
@@ -975,7 +991,7 @@ |
MachineFunction::iterator(PriorTBB) == FallThrough && |
!CanFallThrough(MBB)) { |
bool DoTransform = true; |
- |
+ |
// We have to be careful that the succs of PredBB aren't both no-successor |
// blocks. If neither have successors and if PredBB is the second from |
// last block in the function, we'd just keep swapping the two blocks for |
@@ -999,15 +1015,15 @@ |
if (DoTransform && !MBB->succ_empty() && |
(!CanFallThrough(PriorTBB) || PriorTBB->empty())) |
DoTransform = false; |
- |
- |
+ |
+ |
if (DoTransform) { |
// 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"; |
- |
+ |
TII->RemoveBranch(PrevBB); |
TII->InsertBranch(PrevBB, MBB, 0, NewPriorCond); |
@@ -1020,7 +1036,7 @@ |
} |
} |
} |
- |
+ |
// Analyze the branch in the current block. |
MachineBasicBlock *CurTBB = 0, *CurFBB = 0; |
SmallVector<MachineOperand, 4> CurCond; |
@@ -1029,7 +1045,7 @@ |
// If the CFG for the prior block has extra edges, remove them. |
MadeChange |= MBB->CorrectExtraCFGEdges(CurTBB, CurFBB, !CurCond.empty()); |
- // If this is a two-way branch, and the FBB branches to this block, reverse |
+ // 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: |
// Loop: xxx; jcc Out; jmp Loop |
// we want: |
@@ -1044,11 +1060,11 @@ |
return OptimizeBlock(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 && |
+ if (CurTBB && CurCond.empty() && CurFBB == 0 && |
MBB->begin()->getDesc().isBranch() && 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 |
@@ -1066,7 +1082,7 @@ |
!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) && |
+ if (!PredHasNoFallThrough && PrevBB.isSuccessor(MBB) && |
PriorTBB != MBB && PriorFBB != MBB) { |
if (PriorTBB == 0) { |
assert(PriorCond.empty() && PriorFBB == 0 && |
@@ -1102,7 +1118,7 @@ |
NewCurFBB, NewCurCond, true); |
if (!NewCurUnAnalyzable && NewCurTBB && NewCurTBB == NewCurFBB) { |
TII->RemoveBranch(*PMBB); |
- NewCurCond.clear(); |
+ NewCurCond.clear(); |
TII->InsertBranch(*PMBB, NewCurTBB, 0, NewCurCond); |
MadeChange = true; |
++NumBranchOpts; |
@@ -1121,7 +1137,7 @@ |
} |
} |
} |
- |
+ |
// Add the branch back if the block is more than just an uncond branch. |
TII->InsertBranch(*MBB, CurTBB, 0, CurCond); |
} |
@@ -1134,7 +1150,7 @@ |
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. |
- bool CurFallsThru = CanFallThrough(MBB, CurUnAnalyzable, CurTBB, CurFBB, |
+ bool CurFallsThru = CanFallThrough(MBB, CurUnAnalyzable, CurTBB, CurFBB, |
CurCond); |
if (!MBB->isLandingPad()) { |
@@ -1150,7 +1166,7 @@ |
&& (!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 |
+ // 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; |
@@ -1169,7 +1185,7 @@ |
} |
} |
} |
- |
+ |
if (!CurFallsThru) { |
// Check all successors to see if we can move this block before it. |
for (MachineBasicBlock::succ_iterator SI = MBB->succ_begin(), |
@@ -1178,7 +1194,7 @@ |
MachineBasicBlock *SuccBB = *SI; |
MachineFunction::iterator SuccPrev = SuccBB; --SuccPrev; |
std::vector<MachineOperand> SuccPrevCond; |
- |
+ |
// If this block doesn't already fall-through to that successor, and if |
// the succ doesn't already have a block that can fall through into it, |
// and if the successor isn't an EH destination, we can arrange for the |
@@ -1190,7 +1206,7 @@ |
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. |