X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FCodeGen%2FBranchFolding.cpp;h=d4b1e90fd54c8f530ba483edca7c8265f69a3800;hb=524825b626e8cf9b323a9dd985dcf0f74a99c46e;hp=2f25800cd0b9c04b5cc50cdc16cdb992be878a8c;hpb=0370fad74b48388412c52d1325512f2c218487fa;p=oota-llvm.git diff --git a/lib/CodeGen/BranchFolding.cpp b/lib/CodeGen/BranchFolding.cpp index 2f25800cd0b..d4b1e90fd54 100644 --- a/lib/CodeGen/BranchFolding.cpp +++ b/lib/CodeGen/BranchFolding.cpp @@ -38,9 +38,15 @@ STATISTIC(NumTailMerge , "Number of block tails merged"); static cl::opt FlagEnableTailMerge("enable-tail-merge", cl::init(cl::BOU_UNSET), cl::Hidden); namespace { + // Throttle for huge numbers of predecessors (compile speed problems) + cl::opt + TailMergeThreshold("tail-merge-threshold", + cl::desc("Max number of predecessors to consider tail merging"), + cl::init(100), cl::Hidden); + struct BranchFolder : public MachineFunctionPass { static char ID; - BranchFolder(bool defaultEnableTailMerge) : + explicit BranchFolder(bool defaultEnableTailMerge) : MachineFunctionPass((intptr_t)&ID) { switch (FlagEnableTailMerge) { case cl::BOU_UNSET: EnableTailMerge = defaultEnableTailMerge; break; @@ -81,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); } @@ -127,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(); @@ -272,7 +271,13 @@ static unsigned ComputeCommonTailLength(MachineBasicBlock *MBB1, 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 + // optimizations (like this one) may reorder and/or merge these + // directives. + I1->getOpcode() == TargetInstrInfo::INLINEASM) { ++I1; ++I2; break; } @@ -430,8 +435,14 @@ static bool MergeCompare(const std::pair &p, return true; else if (p.second->getNumber() > q.second->getNumber()) return false; - else + else { + // _GLIBCXX_DEBUG checks strict weak ordering, which involves comparing + // an object with itself. +#ifndef _GLIBCXX_DEBUG assert(0 && "Predecessor appears twice"); +#endif + return(false); + } } // See if any of the blocks in MergePotentials (which all have a common single @@ -577,7 +588,8 @@ bool BranchFolder::TailMergeBlocks(MachineFunction &MF) { MergePotentials.push_back(std::make_pair(HashEndOfMBB(I, 2U), I)); } // See if we can do any tail merging on those. - MadeChange |= TryMergeBlocks(NULL, NULL); + if (MergePotentials.size() < TailMergeThreshold) + MadeChange |= TryMergeBlocks(NULL, NULL); // Look at blocks (IBB) with multiple predecessors (PBB). // We change each predecessor to a canonical form, by @@ -599,11 +611,13 @@ bool BranchFolder::TailMergeBlocks(MachineFunction &MF) { // transformations.) for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) { - if (!I->succ_empty() && I->pred_size() >= 2) { + if (!I->succ_empty() && I->pred_size() >= 2 && + I->pred_size() < TailMergeThreshold) { MachineBasicBlock *IBB = I; MachineBasicBlock *PredBB = prior(I); MergePotentials.clear(); - for (MachineBasicBlock::pred_iterator P = I->pred_begin(), E2 = I->pred_end(); + 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. @@ -622,6 +636,28 @@ bool BranchFolder::TailMergeBlocks(MachineFunction &MF) { if (!FBB) FBB = next(MachineFunction::iterator(PBB)); } + // Failing case: the only way IBB can be reached from PBB is via + // exception handling. Happens for landing pads. Would be nice + // to have a bit in the edge so we didn't have to do all this. + if (IBB->isLandingPad()) { + MachineFunction::iterator IP = PBB; IP++; + MachineBasicBlock* PredNextBB = NULL; + if (IP!=MF.end()) + PredNextBB = IP; + if (TBB==NULL) { + if (IBB!=PredNextBB) // fallthrough + continue; + } else if (FBB) { + if (TBB!=IBB && FBB!=IBB) // cbr then ubr + continue; + } else if (Cond.size() == 0) { + if (TBB!=IBB) // ubr + continue; + } else { + if (TBB!=IBB && IBB!=PredNextBB) // cbr + continue; + } + } // Remove the unconditional branch at the end, if any. if (TBB && (Cond.size()==0 || FBB)) { TII->RemoveBranch(*PBB); @@ -671,68 +707,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 @@ -849,8 +823,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 @@ -962,9 +936,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: @@ -1018,17 +990,18 @@ void BranchFolder::OptimizeBlock(MachineBasicBlock *MBB) { } // Iterate through all the predecessors, revectoring each in-turn. - MachineBasicBlock::pred_iterator PI = MBB->pred_begin(); + size_t PI = 0; bool DidChange = false; bool HasBranchToSelf = false; - while (PI != MBB->pred_end()) { - if (*PI == MBB) { + while(PI != MBB->pred_size()) { + MachineBasicBlock *PMBB = *(MBB->pred_begin() + PI); + if (PMBB == MBB) { // If this block has an uncond branch to itself, leave it. ++PI; HasBranchToSelf = true; } else { DidChange = true; - (*PI)->ReplaceUsesOfBlockWith(MBB, CurTBB); + PMBB->ReplaceUsesOfBlockWith(MBB, CurTBB); } }