SimplifyCFG.cpp revision ba3c8155704e5e2ac24b5069c32bca359b0738ed
101d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner//===- SimplifyCFG.cpp - Code to perform CFG simplification ---------------===// 2fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 901d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner// 10bb190ac8dafdcc5e604da3695987d69ee8632195Chris Lattner// Peephole optimize the CFG. 1101d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner// 1201d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner//===----------------------------------------------------------------------===// 1301d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner 14218a8223e62c41ae6318e28e8f4c672fcfbb5082Chris Lattner#define DEBUG_TYPE "simplifycfg" 1501d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner#include "llvm/Transforms/Utils/Local.h" 16723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner#include "llvm/Constants.h" 17723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner#include "llvm/Instructions.h" 18383d7ed9158576aef5cde872548225a17e3c0155Devang Patel#include "llvm/IntrinsicInst.h" 190d56008f53587531718ec36af82cc24576580b36Chris Lattner#include "llvm/Type.h" 20c10305743c313558405079452138f03124e87581Reid Spencer#include "llvm/DerivedTypes.h" 21f8bc3008214c8327ff987573a111fc0dcefb7d25Dale Johannesen#include "llvm/GlobalVariable.h" 22302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner#include "llvm/Analysis/InstructionSimplify.h" 2358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen#include "llvm/Target/TargetData.h" 24eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner#include "llvm/Transforms/Utils/BasicBlockUtils.h" 252c63566e406974caa70ee27f35af28112e80f951Dan Gohman#include "llvm/ADT/DenseMap.h" 2693e985f1b17aef62d58e3198a4604f9f6cfe8d19Chris Lattner#include "llvm/ADT/SmallVector.h" 27c9951231822215d6aea7a9b50947c18d8d745609Chris Lattner#include "llvm/ADT/SmallPtrSet.h" 28502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng#include "llvm/ADT/Statistic.h" 296d4d21e29d4840236ab6f15c5247379820021d0cChris Lattner#include "llvm/ADT/STLExtras.h" 30302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner#include "llvm/Support/CFG.h" 31302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner#include "llvm/Support/Debug.h" 32302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner#include "llvm/Support/raw_ostream.h" 3301d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner#include <algorithm> 34d52c261cf801331bebda9711acd54c7c5377a6bdChris Lattner#include <set> 35698f96f7c81e45292ae4f5d76b8e06c88a88a71fChris Lattner#include <map> 36f7703df4968084c18c248c1feea9961c19a32e6aChris Lattnerusing namespace llvm; 37d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 38502a4f5162498ec420e3cb22f667808d726dd7daEvan ChengSTATISTIC(NumSpeculations, "Number of speculative executed instructions"); 39502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng 4058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesennamespace { 4158e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesenclass SimplifyCFGOpt { 4258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen const TargetData *const TD; 4358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 4458e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen Value *isValueEqualityComparison(TerminatorInst *TI); 4558e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen BasicBlock *GetValueEqualityComparisonCases(TerminatorInst *TI, 4658e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen std::vector<std::pair<ConstantInt*, BasicBlock*> > &Cases); 4758e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen bool SimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI, 4858e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen BasicBlock *Pred); 4958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen bool FoldValueComparisonIntoPredecessors(TerminatorInst *TI); 5058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 513d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner bool SimplifyReturn(ReturnInst *RI); 523d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner bool SimplifyUnwind(UnwindInst *UI); 533d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner bool SimplifyUnreachable(UnreachableInst *UI); 543d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner bool SimplifySwitch(SwitchInst *SI); 553d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner bool SimplifyIndirectBr(IndirectBrInst *IBI); 563d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner bool SimplifyUncondBranch(BranchInst *BI); 573d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner bool SimplifyCondBranch(BranchInst *BI); 583d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 5958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesenpublic: 6058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen explicit SimplifyCFGOpt(const TargetData *td) : TD(td) {} 6158e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen bool run(BasicBlock *BB); 6258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen}; 6358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen} 6458e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 652bdcb56146279009f233933a101cb3dd54a951cdChris Lattner/// SafeToMergeTerminators - Return true if it is safe to merge these two 662bdcb56146279009f233933a101cb3dd54a951cdChris Lattner/// terminator instructions together. 672bdcb56146279009f233933a101cb3dd54a951cdChris Lattner/// 682bdcb56146279009f233933a101cb3dd54a951cdChris Lattnerstatic bool SafeToMergeTerminators(TerminatorInst *SI1, TerminatorInst *SI2) { 692bdcb56146279009f233933a101cb3dd54a951cdChris Lattner if (SI1 == SI2) return false; // Can't merge with self! 702bdcb56146279009f233933a101cb3dd54a951cdChris Lattner 712bdcb56146279009f233933a101cb3dd54a951cdChris Lattner // It is not safe to merge these two switch instructions if they have a common 722bdcb56146279009f233933a101cb3dd54a951cdChris Lattner // successor, and if that successor has a PHI node, and if *that* PHI node has 732bdcb56146279009f233933a101cb3dd54a951cdChris Lattner // conflicting incoming values from the two switch blocks. 742bdcb56146279009f233933a101cb3dd54a951cdChris Lattner BasicBlock *SI1BB = SI1->getParent(); 752bdcb56146279009f233933a101cb3dd54a951cdChris Lattner BasicBlock *SI2BB = SI2->getParent(); 76c9951231822215d6aea7a9b50947c18d8d745609Chris Lattner SmallPtrSet<BasicBlock*, 16> SI1Succs(succ_begin(SI1BB), succ_end(SI1BB)); 772bdcb56146279009f233933a101cb3dd54a951cdChris Lattner 782bdcb56146279009f233933a101cb3dd54a951cdChris Lattner for (succ_iterator I = succ_begin(SI2BB), E = succ_end(SI2BB); I != E; ++I) 792bdcb56146279009f233933a101cb3dd54a951cdChris Lattner if (SI1Succs.count(*I)) 802bdcb56146279009f233933a101cb3dd54a951cdChris Lattner for (BasicBlock::iterator BBI = (*I)->begin(); 812bdcb56146279009f233933a101cb3dd54a951cdChris Lattner isa<PHINode>(BBI); ++BBI) { 822bdcb56146279009f233933a101cb3dd54a951cdChris Lattner PHINode *PN = cast<PHINode>(BBI); 832bdcb56146279009f233933a101cb3dd54a951cdChris Lattner if (PN->getIncomingValueForBlock(SI1BB) != 842bdcb56146279009f233933a101cb3dd54a951cdChris Lattner PN->getIncomingValueForBlock(SI2BB)) 852bdcb56146279009f233933a101cb3dd54a951cdChris Lattner return false; 862bdcb56146279009f233933a101cb3dd54a951cdChris Lattner } 872bdcb56146279009f233933a101cb3dd54a951cdChris Lattner 882bdcb56146279009f233933a101cb3dd54a951cdChris Lattner return true; 892bdcb56146279009f233933a101cb3dd54a951cdChris Lattner} 902bdcb56146279009f233933a101cb3dd54a951cdChris Lattner 912bdcb56146279009f233933a101cb3dd54a951cdChris Lattner/// AddPredecessorToBlock - Update PHI nodes in Succ to indicate that there will 922bdcb56146279009f233933a101cb3dd54a951cdChris Lattner/// now be entries in it from the 'NewPred' block. The values that will be 932bdcb56146279009f233933a101cb3dd54a951cdChris Lattner/// flowing into the PHI nodes will be the same as those coming in from 942bdcb56146279009f233933a101cb3dd54a951cdChris Lattner/// ExistPred, an existing predecessor of Succ. 952bdcb56146279009f233933a101cb3dd54a951cdChris Lattnerstatic void AddPredecessorToBlock(BasicBlock *Succ, BasicBlock *NewPred, 962bdcb56146279009f233933a101cb3dd54a951cdChris Lattner BasicBlock *ExistPred) { 972bdcb56146279009f233933a101cb3dd54a951cdChris Lattner if (!isa<PHINode>(Succ->begin())) return; // Quick exit if nothing to do 982bdcb56146279009f233933a101cb3dd54a951cdChris Lattner 99093a4385027235459ab6972b2e2fdc79061773cfChris Lattner PHINode *PN; 100093a4385027235459ab6972b2e2fdc79061773cfChris Lattner for (BasicBlock::iterator I = Succ->begin(); 101093a4385027235459ab6972b2e2fdc79061773cfChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 102093a4385027235459ab6972b2e2fdc79061773cfChris Lattner PN->addIncoming(PN->getIncomingValueForBlock(ExistPred), NewPred); 1032bdcb56146279009f233933a101cb3dd54a951cdChris Lattner} 1042bdcb56146279009f233933a101cb3dd54a951cdChris Lattner 1057e66348cba4384d07b37ad1c186e67ba6d26babdChris Lattner 10673c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattner/// GetIfCondition - Given a basic block (BB) with two predecessors (and at 10773c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattner/// least one PHI node in it), check to see if the merge at this block is due 108723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner/// to an "if condition". If so, return the boolean condition that determines 109723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner/// which entry into BB will be taken. Also, return by references the block 110723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner/// that will be entered from if the condition is true, and the block that will 111723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner/// be entered if the condition is false. 112fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman/// 113995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner/// This does no checking to see if the true/false blocks have large or unsavory 114995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner/// instructions in them. 11573c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattnerstatic Value *GetIfCondition(BasicBlock *BB, BasicBlock *&IfTrue, 11673c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattner BasicBlock *&IfFalse) { 11773c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattner PHINode *SomePHI = cast<PHINode>(BB->begin()); 11873c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattner assert(SomePHI->getNumIncomingValues() == 2 && 119723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner "Function can only handle blocks with 2 predecessors!"); 12073c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattner BasicBlock *Pred1 = SomePHI->getIncomingBlock(0); 12173c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattner BasicBlock *Pred2 = SomePHI->getIncomingBlock(1); 122723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 123723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // We can only handle branches. Other control flow will be lowered to 124723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // branches if possible anyway. 125995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner BranchInst *Pred1Br = dyn_cast<BranchInst>(Pred1->getTerminator()); 126995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner BranchInst *Pred2Br = dyn_cast<BranchInst>(Pred2->getTerminator()); 127995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner if (Pred1Br == 0 || Pred2Br == 0) 128723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner return 0; 129723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 130723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // Eliminate code duplication by ensuring that Pred1Br is conditional if 131723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // either are. 132723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner if (Pred2Br->isConditional()) { 133723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // If both branches are conditional, we don't have an "if statement". In 134723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // reality, we could transform this case, but since the condition will be 135723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // required anyway, we stand no chance of eliminating it, so the xform is 136723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // probably not profitable. 137723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner if (Pred1Br->isConditional()) 138723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner return 0; 139723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 140723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner std::swap(Pred1, Pred2); 141723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner std::swap(Pred1Br, Pred2Br); 142723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner } 143723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 144723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner if (Pred1Br->isConditional()) { 145995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner // The only thing we have to watch out for here is to make sure that Pred2 146995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner // doesn't have incoming edges from other blocks. If it does, the condition 147995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner // doesn't dominate BB. 148995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner if (Pred2->getSinglePredecessor() == 0) 149995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner return 0; 150995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner 151723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // If we found a conditional branch predecessor, make sure that it branches 152723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // to BB and Pred2Br. If it doesn't, this isn't an "if statement". 153723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner if (Pred1Br->getSuccessor(0) == BB && 154723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner Pred1Br->getSuccessor(1) == Pred2) { 155723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner IfTrue = Pred1; 156723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner IfFalse = Pred2; 157723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner } else if (Pred1Br->getSuccessor(0) == Pred2 && 158723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner Pred1Br->getSuccessor(1) == BB) { 159723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner IfTrue = Pred2; 160723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner IfFalse = Pred1; 161723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner } else { 162723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // We know that one arm of the conditional goes to BB, so the other must 163723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // go somewhere unrelated, and this must not be an "if statement". 164723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner return 0; 165723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner } 166723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 167723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner return Pred1Br->getCondition(); 168723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner } 169723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 170723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // Ok, if we got here, both predecessors end with an unconditional branch to 171723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // BB. Don't panic! If both blocks only have a single (identical) 172723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // predecessor, and THAT is a conditional branch, then we're all ok! 173995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner BasicBlock *CommonPred = Pred1->getSinglePredecessor(); 174995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner if (CommonPred == 0 || CommonPred != Pred2->getSinglePredecessor()) 175723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner return 0; 176723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 177723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // Otherwise, if this is a conditional branch, then we can use it! 178995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner BranchInst *BI = dyn_cast<BranchInst>(CommonPred->getTerminator()); 179995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner if (BI == 0) return 0; 180995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner 181995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner assert(BI->isConditional() && "Two successors but not conditional?"); 182995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner if (BI->getSuccessor(0) == Pred1) { 183995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner IfTrue = Pred1; 184995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner IfFalse = Pred2; 185995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner } else { 186995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner IfTrue = Pred2; 187995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner IfFalse = Pred1; 188723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner } 189995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner return BI->getCondition(); 190723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner} 191723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 1925049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// DominatesMergePoint - If we have a merge point of an "if condition" as 1935049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// accepted above, return true if the specified value dominates the block. We 1945049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// don't handle the true generality of domination here, just a special case 1955049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// which works well enough for us. 1965049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// 1975049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// If AggressiveInsts is non-null, and if V does not dominate BB, we check to 1985049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// see if V (which must be an instruction) is cheap to compute and is 1995049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// non-trapping. If both are true, the instruction is inserted into the set 2005049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// and true is returned. 2019c07866ef861e072395306e9811c329c7fe5bbe8Chris Lattnerstatic bool DominatesMergePoint(Value *V, BasicBlock *BB, 20244da7ca4213333bcade57a407a890970351db494Chris Lattner SmallPtrSet<Instruction*, 4> *AggressiveInsts) { 203570751c2a7d8851bc61e408746a903b0253d2d21Chris Lattner Instruction *I = dyn_cast<Instruction>(V); 204b74b1816305affe25da32c2f29532df41a23cd55Chris Lattner if (!I) { 205b74b1816305affe25da32c2f29532df41a23cd55Chris Lattner // Non-instructions all dominate instructions, but not all constantexprs 206b74b1816305affe25da32c2f29532df41a23cd55Chris Lattner // can be executed unconditionally. 207b74b1816305affe25da32c2f29532df41a23cd55Chris Lattner if (ConstantExpr *C = dyn_cast<ConstantExpr>(V)) 208b74b1816305affe25da32c2f29532df41a23cd55Chris Lattner if (C->canTrap()) 209b74b1816305affe25da32c2f29532df41a23cd55Chris Lattner return false; 210b74b1816305affe25da32c2f29532df41a23cd55Chris Lattner return true; 211b74b1816305affe25da32c2f29532df41a23cd55Chris Lattner } 212570751c2a7d8851bc61e408746a903b0253d2d21Chris Lattner BasicBlock *PBB = I->getParent(); 213570751c2a7d8851bc61e408746a903b0253d2d21Chris Lattner 214da895d63377b421dc50117befb2bec80d2973526Chris Lattner // We don't want to allow weird loops that might have the "if condition" in 215570751c2a7d8851bc61e408746a903b0253d2d21Chris Lattner // the bottom of this block. 216570751c2a7d8851bc61e408746a903b0253d2d21Chris Lattner if (PBB == BB) return false; 217570751c2a7d8851bc61e408746a903b0253d2d21Chris Lattner 218570751c2a7d8851bc61e408746a903b0253d2d21Chris Lattner // If this instruction is defined in a block that contains an unconditional 219570751c2a7d8851bc61e408746a903b0253d2d21Chris Lattner // branch to BB, then it must be in the 'conditional' part of the "if 22044da7ca4213333bcade57a407a890970351db494Chris Lattner // statement". If not, it definitely dominates the region. 22144da7ca4213333bcade57a407a890970351db494Chris Lattner BranchInst *BI = dyn_cast<BranchInst>(PBB->getTerminator()); 22244da7ca4213333bcade57a407a890970351db494Chris Lattner if (BI == 0 || BI->isConditional() || BI->getSuccessor(0) != BB) 22344da7ca4213333bcade57a407a890970351db494Chris Lattner return true; 2240b79a7727d68a507837e827803859424cf3d997bEli Friedman 22544da7ca4213333bcade57a407a890970351db494Chris Lattner // If we aren't allowing aggressive promotion anymore, then don't consider 22644da7ca4213333bcade57a407a890970351db494Chris Lattner // instructions in the 'if region'. 22744da7ca4213333bcade57a407a890970351db494Chris Lattner if (AggressiveInsts == 0) return false; 22844da7ca4213333bcade57a407a890970351db494Chris Lattner 22944da7ca4213333bcade57a407a890970351db494Chris Lattner // Okay, it looks like the instruction IS in the "condition". Check to 23044da7ca4213333bcade57a407a890970351db494Chris Lattner // see if it's a cheap instruction to unconditionally compute, and if it 23144da7ca4213333bcade57a407a890970351db494Chris Lattner // only uses stuff defined outside of the condition. If so, hoist it out. 23244da7ca4213333bcade57a407a890970351db494Chris Lattner if (!I->isSafeToSpeculativelyExecute()) 23344da7ca4213333bcade57a407a890970351db494Chris Lattner return false; 234fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 23544da7ca4213333bcade57a407a890970351db494Chris Lattner switch (I->getOpcode()) { 23644da7ca4213333bcade57a407a890970351db494Chris Lattner default: return false; // Cannot hoist this out safely. 23744da7ca4213333bcade57a407a890970351db494Chris Lattner case Instruction::Load: 23844da7ca4213333bcade57a407a890970351db494Chris Lattner // We have to check to make sure there are no instructions before the 23944da7ca4213333bcade57a407a890970351db494Chris Lattner // load in its basic block, as we are going to hoist the load out to its 24044da7ca4213333bcade57a407a890970351db494Chris Lattner // predecessor. 24144da7ca4213333bcade57a407a890970351db494Chris Lattner if (PBB->getFirstNonPHIOrDbg() != I) 24244da7ca4213333bcade57a407a890970351db494Chris Lattner return false; 24344da7ca4213333bcade57a407a890970351db494Chris Lattner break; 24444da7ca4213333bcade57a407a890970351db494Chris Lattner case Instruction::Add: 24544da7ca4213333bcade57a407a890970351db494Chris Lattner case Instruction::Sub: 24644da7ca4213333bcade57a407a890970351db494Chris Lattner case Instruction::And: 24744da7ca4213333bcade57a407a890970351db494Chris Lattner case Instruction::Or: 24844da7ca4213333bcade57a407a890970351db494Chris Lattner case Instruction::Xor: 24944da7ca4213333bcade57a407a890970351db494Chris Lattner case Instruction::Shl: 25044da7ca4213333bcade57a407a890970351db494Chris Lattner case Instruction::LShr: 25144da7ca4213333bcade57a407a890970351db494Chris Lattner case Instruction::AShr: 25244da7ca4213333bcade57a407a890970351db494Chris Lattner case Instruction::ICmp: 25344da7ca4213333bcade57a407a890970351db494Chris Lattner break; // These are all cheap and non-trapping instructions. 25444da7ca4213333bcade57a407a890970351db494Chris Lattner } 255723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 25644da7ca4213333bcade57a407a890970351db494Chris Lattner // Okay, we can only really hoist these out if their operands are not 25744da7ca4213333bcade57a407a890970351db494Chris Lattner // defined in the conditional region. 25844da7ca4213333bcade57a407a890970351db494Chris Lattner for (User::op_iterator i = I->op_begin(), e = I->op_end(); i != e; ++i) 25944da7ca4213333bcade57a407a890970351db494Chris Lattner if (!DominatesMergePoint(*i, BB, 0)) 26044da7ca4213333bcade57a407a890970351db494Chris Lattner return false; 26144da7ca4213333bcade57a407a890970351db494Chris Lattner // Okay, it's safe to do this! Remember this instruction. 26244da7ca4213333bcade57a407a890970351db494Chris Lattner AggressiveInsts->insert(I); 263723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner return true; 264723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner} 26501d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner 26658e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen/// GetConstantInt - Extract ConstantInt from value, looking through IntToPtr 26758e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen/// and PointerNullValue. Return NULL if value is not a constant int. 26828acc135481691771205dea7cb4edbd3927aa764Chris Lattnerstatic ConstantInt *GetConstantInt(Value *V, const TargetData *TD) { 26958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen // Normal constant int. 27058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen ConstantInt *CI = dyn_cast<ConstantInt>(V); 2711df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (CI || !TD || !isa<Constant>(V) || !V->getType()->isPointerTy()) 27258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen return CI; 27358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 27458e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen // This is some kind of pointer constant. Turn it into a pointer-sized 27558e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen // ConstantInt if possible. 27658e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen const IntegerType *PtrTy = TD->getIntPtrType(V->getContext()); 27758e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 27858e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen // Null pointer means 0, see SelectionDAGBuilder::getValue(const Value*). 27958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen if (isa<ConstantPointerNull>(V)) 28058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen return ConstantInt::get(PtrTy, 0); 28158e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 28258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen // IntToPtr const int. 28358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) 28458e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen if (CE->getOpcode() == Instruction::IntToPtr) 28558e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(0))) { 28658e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen // The constant is very likely to have the right type already. 28758e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen if (CI->getType() == PtrTy) 28858e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen return CI; 28958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen else 29058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen return cast<ConstantInt> 29158e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen (ConstantExpr::getIntegerCast(CI, PtrTy, /*isSigned=*/false)); 29258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen } 29358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen return 0; 29458e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen} 29558e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 2960aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner/// GatherConstantCompares - Given a potentially 'or'd or 'and'd together 2970aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner/// collection of icmp eq/ne instructions that compare a value against a 2980aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner/// constant, return the value being compared, and stick the constant into the 2990aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner/// Values vector. 30028acc135481691771205dea7cb4edbd3927aa764Chris Lattnerstatic Value * 3010aa749bde7c696e0522df5581ea9cc70f25e62cbChris LattnerGatherConstantCompares(Value *V, std::vector<ConstantInt*> &Vals, Value *&Extra, 3020aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner const TargetData *TD, bool isEQ) { 3030aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner Instruction *I = dyn_cast<Instruction>(V); 3040aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner if (I == 0) return 0; 3059a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 3067312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner // If this is an icmp against a constant, handle this as one of the cases. 3070aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner if (ICmpInst *ICI = dyn_cast<ICmpInst>(I)) { 3080aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner if (ICI->getPredicate() == (isEQ ? ICmpInst::ICMP_EQ : ICmpInst::ICMP_NE)) 3090aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner if (ConstantInt *C = GetConstantInt(I->getOperand(1), TD)) { 3100aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner Vals.push_back(C); 3110aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner return I->getOperand(0); 3120aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner } 313662269d2abb2f220c3a9b727c2a948246128cd05Chris Lattner return 0; 314662269d2abb2f220c3a9b727c2a948246128cd05Chris Lattner } 315662269d2abb2f220c3a9b727c2a948246128cd05Chris Lattner 3167312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner // Otherwise, we can only handle an | or &, depending on isEQ. 3170aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner if (I->getOpcode() != (isEQ ? Instruction::Or : Instruction::And)) 318662269d2abb2f220c3a9b727c2a948246128cd05Chris Lattner return 0; 319662269d2abb2f220c3a9b727c2a948246128cd05Chris Lattner 3207312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner unsigned NumValsBeforeLHS = Vals.size(); 3210aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner if (Value *LHS = GatherConstantCompares(I->getOperand(0), Vals, Extra, TD, 3220aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner isEQ)) { 3237312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner unsigned NumVals = Vals.size(); 3240aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner if (Value *RHS = GatherConstantCompares(I->getOperand(1), Vals, Extra, TD, 3250aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner isEQ)) { 3260aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner if (LHS == RHS) 3270aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner return LHS; 32892407e589524d98080f4db943a0e2a3bf18ec8a2Chris Lattner Vals.resize(NumVals); 3290aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner } 3307312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner 3317312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner // The RHS of the or/and can't be folded in and we haven't used "Extra" yet, 3327312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner // set it and return success. 3337312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner if (Extra == 0 || Extra == I->getOperand(1)) { 3347312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner Extra = I->getOperand(1); 3357312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner return LHS; 3367312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner } 3377312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner 3387312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner Vals.resize(NumValsBeforeLHS); 3397312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner return 0; 3407312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner } 3417312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner 3427312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner // If the LHS can't be folded in, but Extra is available and RHS can, try to 3437312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner // use LHS as Extra. 3447312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner if (Extra == 0 || Extra == I->getOperand(0)) { 34592407e589524d98080f4db943a0e2a3bf18ec8a2Chris Lattner Value *OldExtra = Extra; 3467312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner Extra = I->getOperand(0); 3477312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner if (Value *RHS = GatherConstantCompares(I->getOperand(1), Vals, Extra, TD, 3487312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner isEQ)) 3497312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner return RHS; 35092407e589524d98080f4db943a0e2a3bf18ec8a2Chris Lattner assert(Vals.size() == NumValsBeforeLHS); 35192407e589524d98080f4db943a0e2a3bf18ec8a2Chris Lattner Extra = OldExtra; 35207e6e56f57e8781a8d7bc601cc9034a3741d84c2Anton Korobeynikov } 3537312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner 3540d56008f53587531718ec36af82cc24576580b36Chris Lattner return 0; 3550d56008f53587531718ec36af82cc24576580b36Chris Lattner} 3560aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner 357080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedmanstatic void EraseTerminatorInstAndDCECond(TerminatorInst *TI) { 358080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman Instruction* Cond = 0; 359080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { 360080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman Cond = dyn_cast<Instruction>(SI->getCondition()); 361080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman } else if (BranchInst *BI = dyn_cast<BranchInst>(TI)) { 362080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman if (BI->isConditional()) 363080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman Cond = dyn_cast<Instruction>(BI->getCondition()); 3647ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel } else if (IndirectBrInst *IBI = dyn_cast<IndirectBrInst>(TI)) { 3657ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel Cond = dyn_cast<Instruction>(IBI->getAddress()); 366080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman } 367080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman 368080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman TI->eraseFromParent(); 369080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman if (Cond) RecursivelyDeleteTriviallyDeadInstructions(Cond); 370080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman} 371080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman 3729fd4955c6ab9a191dec2d5afd4b2027d4b906f2eChris Lattner/// isValueEqualityComparison - Return true if the specified terminator checks 3739fd4955c6ab9a191dec2d5afd4b2027d4b906f2eChris Lattner/// to see if a value is equal to constant integer value. 37458e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund OlesenValue *SimplifyCFGOpt::isValueEqualityComparison(TerminatorInst *TI) { 37558e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen Value *CV = 0; 3764bebf08d152d84970d250feec72fb734cb8a5316Chris Lattner if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { 3774bebf08d152d84970d250feec72fb734cb8a5316Chris Lattner // Do not permit merging of large switch instructions into their 3784bebf08d152d84970d250feec72fb734cb8a5316Chris Lattner // predecessors unless there is only one predecessor. 37958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen if (SI->getNumSuccessors()*std::distance(pred_begin(SI->getParent()), 38058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen pred_end(SI->getParent())) <= 128) 38158e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen CV = SI->getCondition(); 38258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen } else if (BranchInst *BI = dyn_cast<BranchInst>(TI)) 383542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (BI->isConditional() && BI->getCondition()->hasOneUse()) 384e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (ICmpInst *ICI = dyn_cast<ICmpInst>(BI->getCondition())) 385e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if ((ICI->getPredicate() == ICmpInst::ICMP_EQ || 386e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ICI->getPredicate() == ICmpInst::ICMP_NE) && 38728acc135481691771205dea7cb4edbd3927aa764Chris Lattner GetConstantInt(ICI->getOperand(1), TD)) 38858e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen CV = ICI->getOperand(0); 38958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 39058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen // Unwrap any lossless ptrtoint cast. 39158e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen if (TD && CV && CV->getType() == TD->getIntPtrType(CV->getContext())) 39258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen if (PtrToIntInst *PTII = dyn_cast<PtrToIntInst>(CV)) 39358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen CV = PTII->getOperand(0); 39458e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen return CV; 395542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner} 396542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 3975049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// GetValueEqualityComparisonCases - Given a value comparison instruction, 3985049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// decode all of the 'cases' that it represents and return the 'default' block. 39958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund OlesenBasicBlock *SimplifyCFGOpt:: 400fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha BrukmanGetValueEqualityComparisonCases(TerminatorInst *TI, 401542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner std::vector<std::pair<ConstantInt*, 402542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner BasicBlock*> > &Cases) { 403542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { 404542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner Cases.reserve(SI->getNumCases()); 405542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner for (unsigned i = 1, e = SI->getNumCases(); i != e; ++i) 406be54dcc8a9d14592e324d6e6ae1322782e17f09fChris Lattner Cases.push_back(std::make_pair(SI->getCaseValue(i), SI->getSuccessor(i))); 407542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner return SI->getDefaultDest(); 408542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 409542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 410542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner BranchInst *BI = cast<BranchInst>(TI); 411e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ICmpInst *ICI = cast<ICmpInst>(BI->getCondition()); 41228acc135481691771205dea7cb4edbd3927aa764Chris Lattner Cases.push_back(std::make_pair(GetConstantInt(ICI->getOperand(1), TD), 413e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer BI->getSuccessor(ICI->getPredicate() == 414e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ICmpInst::ICMP_NE))); 415e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_EQ); 416542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner} 417542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 418542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 4195049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// EliminateBlockCases - Given a vector of bb/value pairs, remove any entries 4205049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// in the list that match the specified block. 421fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanstatic void EliminateBlockCases(BasicBlock *BB, 422623369ac5669a3667a94a3cbba342dea78845615Chris Lattner std::vector<std::pair<ConstantInt*, BasicBlock*> > &Cases) { 423623369ac5669a3667a94a3cbba342dea78845615Chris Lattner for (unsigned i = 0, e = Cases.size(); i != e; ++i) 424623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if (Cases[i].second == BB) { 425623369ac5669a3667a94a3cbba342dea78845615Chris Lattner Cases.erase(Cases.begin()+i); 426623369ac5669a3667a94a3cbba342dea78845615Chris Lattner --i; --e; 427623369ac5669a3667a94a3cbba342dea78845615Chris Lattner } 428623369ac5669a3667a94a3cbba342dea78845615Chris Lattner} 429623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 4305049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// ValuesOverlap - Return true if there are any keys in C1 that exist in C2 as 4315049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// well. 432623369ac5669a3667a94a3cbba342dea78845615Chris Lattnerstatic bool 433623369ac5669a3667a94a3cbba342dea78845615Chris LattnerValuesOverlap(std::vector<std::pair<ConstantInt*, BasicBlock*> > &C1, 434623369ac5669a3667a94a3cbba342dea78845615Chris Lattner std::vector<std::pair<ConstantInt*, BasicBlock*> > &C2) { 435623369ac5669a3667a94a3cbba342dea78845615Chris Lattner std::vector<std::pair<ConstantInt*, BasicBlock*> > *V1 = &C1, *V2 = &C2; 436623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 437623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // Make V1 be smaller than V2. 438623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if (V1->size() > V2->size()) 439623369ac5669a3667a94a3cbba342dea78845615Chris Lattner std::swap(V1, V2); 440623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 441623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if (V1->size() == 0) return false; 442623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if (V1->size() == 1) { 443623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // Just scan V2. 444623369ac5669a3667a94a3cbba342dea78845615Chris Lattner ConstantInt *TheVal = (*V1)[0].first; 445623369ac5669a3667a94a3cbba342dea78845615Chris Lattner for (unsigned i = 0, e = V2->size(); i != e; ++i) 446623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if (TheVal == (*V2)[i].first) 447623369ac5669a3667a94a3cbba342dea78845615Chris Lattner return true; 448623369ac5669a3667a94a3cbba342dea78845615Chris Lattner } 449623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 450623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // Otherwise, just sort both lists and compare element by element. 451fca20f507ccfd3407511cd1ccb94ab4421388107Chris Lattner array_pod_sort(V1->begin(), V1->end()); 452fca20f507ccfd3407511cd1ccb94ab4421388107Chris Lattner array_pod_sort(V2->begin(), V2->end()); 453623369ac5669a3667a94a3cbba342dea78845615Chris Lattner unsigned i1 = 0, i2 = 0, e1 = V1->size(), e2 = V2->size(); 454623369ac5669a3667a94a3cbba342dea78845615Chris Lattner while (i1 != e1 && i2 != e2) { 455623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if ((*V1)[i1].first == (*V2)[i2].first) 456623369ac5669a3667a94a3cbba342dea78845615Chris Lattner return true; 457623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if ((*V1)[i1].first < (*V2)[i2].first) 458623369ac5669a3667a94a3cbba342dea78845615Chris Lattner ++i1; 459623369ac5669a3667a94a3cbba342dea78845615Chris Lattner else 460623369ac5669a3667a94a3cbba342dea78845615Chris Lattner ++i2; 461623369ac5669a3667a94a3cbba342dea78845615Chris Lattner } 462623369ac5669a3667a94a3cbba342dea78845615Chris Lattner return false; 463623369ac5669a3667a94a3cbba342dea78845615Chris Lattner} 464623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 4655049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// SimplifyEqualityComparisonWithOnlyPredecessor - If TI is known to be a 4665049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// terminator instruction and its block is known to only have a single 4675049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// predecessor block, check to see if that predecessor is also a value 4685049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// comparison with the same value, and if that comparison determines the 4695049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// outcome of this comparison. If so, simplify TI. This does a very limited 4705049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// form of jump threading. 47158e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesenbool SimplifyCFGOpt:: 47258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund OlesenSimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI, 47358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen BasicBlock *Pred) { 474623369ac5669a3667a94a3cbba342dea78845615Chris Lattner Value *PredVal = isValueEqualityComparison(Pred->getTerminator()); 475623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if (!PredVal) return false; // Not a value comparison in predecessor. 476623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 477623369ac5669a3667a94a3cbba342dea78845615Chris Lattner Value *ThisVal = isValueEqualityComparison(TI); 478623369ac5669a3667a94a3cbba342dea78845615Chris Lattner assert(ThisVal && "This isn't a value comparison!!"); 479623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if (ThisVal != PredVal) return false; // Different predicates. 480623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 481623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // Find out information about when control will move from Pred to TI's block. 482623369ac5669a3667a94a3cbba342dea78845615Chris Lattner std::vector<std::pair<ConstantInt*, BasicBlock*> > PredCases; 483623369ac5669a3667a94a3cbba342dea78845615Chris Lattner BasicBlock *PredDef = GetValueEqualityComparisonCases(Pred->getTerminator(), 484623369ac5669a3667a94a3cbba342dea78845615Chris Lattner PredCases); 485623369ac5669a3667a94a3cbba342dea78845615Chris Lattner EliminateBlockCases(PredDef, PredCases); // Remove default from cases. 486fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 487623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // Find information about how control leaves this block. 488623369ac5669a3667a94a3cbba342dea78845615Chris Lattner std::vector<std::pair<ConstantInt*, BasicBlock*> > ThisCases; 489623369ac5669a3667a94a3cbba342dea78845615Chris Lattner BasicBlock *ThisDef = GetValueEqualityComparisonCases(TI, ThisCases); 490623369ac5669a3667a94a3cbba342dea78845615Chris Lattner EliminateBlockCases(ThisDef, ThisCases); // Remove default from cases. 491623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 492623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // If TI's block is the default block from Pred's comparison, potentially 493623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // simplify TI based on this knowledge. 494623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if (PredDef == TI->getParent()) { 495623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // If we are here, we know that the value is none of those cases listed in 496623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // PredCases. If there are any cases in ThisCases that are in PredCases, we 497623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // can simplify TI. 4989a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (!ValuesOverlap(PredCases, ThisCases)) 4999a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner return false; 5009a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 5019a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (isa<BranchInst>(TI)) { 5029a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Okay, one of the successors of this condbr is dead. Convert it to a 5039a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // uncond br. 5049a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner assert(ThisCases.size() == 1 && "Branch can only have one case!"); 5059a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Insert the new branch. 5069a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner Instruction *NI = BranchInst::Create(ThisDef, TI); 5079a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner (void) NI; 508623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 5099a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Remove PHI node entries for the dead edge. 5109a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner ThisCases[0].second->removePredecessor(TI->getParent()); 511623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 5129a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator() 5139a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner << "Through successor TI: " << *TI << "Leaving: " << *NI << "\n"); 514623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 5159a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner EraseTerminatorInstAndDCECond(TI); 5169a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner return true; 517623369ac5669a3667a94a3cbba342dea78845615Chris Lattner } 5189a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 5199a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner SwitchInst *SI = cast<SwitchInst>(TI); 5209a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Okay, TI has cases that are statically dead, prune them away. 5219a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner SmallPtrSet<Constant*, 16> DeadCases; 522623369ac5669a3667a94a3cbba342dea78845615Chris Lattner for (unsigned i = 0, e = PredCases.size(); i != e; ++i) 5239a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner DeadCases.insert(PredCases[i].first); 5249a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 5259a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator() 5269a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner << "Through successor TI: " << *TI); 5279a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 5289a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner for (unsigned i = SI->getNumCases()-1; i != 0; --i) 5299a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (DeadCases.count(SI->getCaseValue(i))) { 5309a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner SI->getSuccessor(i)->removePredecessor(TI->getParent()); 5319a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner SI->removeCase(i); 532623369ac5669a3667a94a3cbba342dea78845615Chris Lattner } 533623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 5349a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner DEBUG(dbgs() << "Leaving: " << *TI << "\n"); 5359a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner return true; 5369a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner } 5379a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 5389a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Otherwise, TI's block must correspond to some matched value. Find out 5399a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // which value (or set of values) this is. 5409a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner ConstantInt *TIV = 0; 5419a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BasicBlock *TIBB = TI->getParent(); 5429a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner for (unsigned i = 0, e = PredCases.size(); i != e; ++i) 5439a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (PredCases[i].second == TIBB) { 5449a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (TIV != 0) 5459a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner return false; // Cannot handle multiple values coming to this block. 5469a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner TIV = PredCases[i].first; 5479a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner } 5489a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner assert(TIV && "No edge from pred to succ?"); 5499a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 5509a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Okay, we found the one constant that our value can be if we get into TI's 5519a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // BB. Find out which successor will unconditionally be branched to. 5529a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BasicBlock *TheRealDest = 0; 5539a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner for (unsigned i = 0, e = ThisCases.size(); i != e; ++i) 5549a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (ThisCases[i].first == TIV) { 5559a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner TheRealDest = ThisCases[i].second; 5569a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner break; 5579a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner } 5589a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 5599a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // If not handled by any explicit cases, it is handled by the default case. 5609a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (TheRealDest == 0) TheRealDest = ThisDef; 561623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 5629a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Remove PHI node entries for dead edges. 5639a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BasicBlock *CheckEdge = TheRealDest; 5649a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner for (succ_iterator SI = succ_begin(TIBB), e = succ_end(TIBB); SI != e; ++SI) 5659a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (*SI != CheckEdge) 5669a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner (*SI)->removePredecessor(TIBB); 5679a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner else 5689a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner CheckEdge = 0; 569623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 5709a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Insert the new branch. 5719a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner Instruction *NI = BranchInst::Create(TheRealDest, TI); 5729a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner (void) NI; 573623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 5749a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator() 5759a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner << "Through successor TI: " << *TI << "Leaving: " << *NI << "\n"); 576623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 5779a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner EraseTerminatorInstAndDCECond(TI); 5789a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner return true; 579623369ac5669a3667a94a3cbba342dea78845615Chris Lattner} 580623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 581c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesennamespace { 582c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen /// ConstantIntOrdering - This class implements a stable ordering of constant 583c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen /// integers that does not depend on their address. This is important for 584c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen /// applications that sort ConstantInt's to ensure uniqueness. 585c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen struct ConstantIntOrdering { 586c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen bool operator()(const ConstantInt *LHS, const ConstantInt *RHS) const { 587c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen return LHS->getValue().ult(RHS->getValue()); 588c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen } 589c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen }; 590c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen} 591a9537cf3fcf9fdaac94749db9fbd34912b1f0f08Dale Johannesen 5926d4d21e29d4840236ab6f15c5247379820021d0cChris Lattnerstatic int ConstantIntSortPredicate(const void *P1, const void *P2) { 5936d4d21e29d4840236ab6f15c5247379820021d0cChris Lattner const ConstantInt *LHS = *(const ConstantInt**)P1; 5946d4d21e29d4840236ab6f15c5247379820021d0cChris Lattner const ConstantInt *RHS = *(const ConstantInt**)P2; 595ba3c8155704e5e2ac24b5069c32bca359b0738edChris Lattner if (LHS->getValue().ult(RHS->getValue())) 596ba3c8155704e5e2ac24b5069c32bca359b0738edChris Lattner return 1; 597ba3c8155704e5e2ac24b5069c32bca359b0738edChris Lattner if (LHS->getValue() == RHS->getValue()) 598ba3c8155704e5e2ac24b5069c32bca359b0738edChris Lattner return 0; 599ba3c8155704e5e2ac24b5069c32bca359b0738edChris Lattner return -1; 6006d4d21e29d4840236ab6f15c5247379820021d0cChris Lattner} 6016d4d21e29d4840236ab6f15c5247379820021d0cChris Lattner 6025049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// FoldValueComparisonIntoPredecessors - The specified terminator is a value 6035049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// equality comparison instruction (either a switch or a branch on "X == c"). 6045049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// See if any of the predecessors of the terminator block are value comparisons 6055049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// on the same value. If so, and if safe to do so, fold them together. 60658e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesenbool SimplifyCFGOpt::FoldValueComparisonIntoPredecessors(TerminatorInst *TI) { 607542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner BasicBlock *BB = TI->getParent(); 608542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner Value *CV = isValueEqualityComparison(TI); // CondVal 609542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner assert(CV && "Not a comparison?"); 610542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner bool Changed = false; 611542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 6128244243a31d636ce8838a81d4c402274fd391d2bChris Lattner SmallVector<BasicBlock*, 16> Preds(pred_begin(BB), pred_end(BB)); 613542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner while (!Preds.empty()) { 614e9d87f49063cb1bd213d8e9c339b9b63393cc2d9Dan Gohman BasicBlock *Pred = Preds.pop_back_val(); 615fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 616542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // See if the predecessor is a comparison with the same value. 617542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner TerminatorInst *PTI = Pred->getTerminator(); 618542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner Value *PCV = isValueEqualityComparison(PTI); // PredCondVal 619542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 620542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (PCV == CV && SafeToMergeTerminators(TI, PTI)) { 621542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // Figure out which 'cases' to copy from SI to PSI. 622542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner std::vector<std::pair<ConstantInt*, BasicBlock*> > BBCases; 623542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner BasicBlock *BBDefault = GetValueEqualityComparisonCases(TI, BBCases); 624542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 625542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner std::vector<std::pair<ConstantInt*, BasicBlock*> > PredCases; 626542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner BasicBlock *PredDefault = GetValueEqualityComparisonCases(PTI, PredCases); 627542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 628542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // Based on whether the default edge from PTI goes to BB or not, fill in 629542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // PredCases and PredDefault with the new switch cases we would like to 630542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // build. 6318244243a31d636ce8838a81d4c402274fd391d2bChris Lattner SmallVector<BasicBlock*, 8> NewSuccessors; 632542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 633542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (PredDefault == BB) { 634542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // If this is the default destination from PTI, only the edges in TI 635542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // that don't occur in PTI, or that branch to BB will be activated. 636c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen std::set<ConstantInt*, ConstantIntOrdering> PTIHandled; 637542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner for (unsigned i = 0, e = PredCases.size(); i != e; ++i) 638542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (PredCases[i].second != BB) 639542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PTIHandled.insert(PredCases[i].first); 640542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner else { 641542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // The default destination is BB, we don't need explicit targets. 642542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner std::swap(PredCases[i], PredCases.back()); 643542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PredCases.pop_back(); 644542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner --i; --e; 645542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 646542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 647542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // Reconstruct the new switch statement we will be building. 648542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (PredDefault != BBDefault) { 649542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PredDefault->removePredecessor(Pred); 650542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PredDefault = BBDefault; 651542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner NewSuccessors.push_back(BBDefault); 652542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 653542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner for (unsigned i = 0, e = BBCases.size(); i != e; ++i) 654542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (!PTIHandled.count(BBCases[i].first) && 655542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner BBCases[i].second != BBDefault) { 656542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PredCases.push_back(BBCases[i]); 657542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner NewSuccessors.push_back(BBCases[i].second); 658542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 659542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 660542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } else { 661542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // If this is not the default destination from PSI, only the edges 662542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // in SI that occur in PSI with a destination of BB will be 663542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // activated. 664c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen std::set<ConstantInt*, ConstantIntOrdering> PTIHandled; 665542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner for (unsigned i = 0, e = PredCases.size(); i != e; ++i) 666542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (PredCases[i].second == BB) { 667542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PTIHandled.insert(PredCases[i].first); 668542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner std::swap(PredCases[i], PredCases.back()); 669542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PredCases.pop_back(); 670542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner --i; --e; 671542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 672542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 673542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // Okay, now we know which constants were sent to BB from the 674542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // predecessor. Figure out where they will all go now. 675542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner for (unsigned i = 0, e = BBCases.size(); i != e; ++i) 676542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (PTIHandled.count(BBCases[i].first)) { 677542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // If this is one we are capable of getting... 678542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PredCases.push_back(BBCases[i]); 679542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner NewSuccessors.push_back(BBCases[i].second); 680542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PTIHandled.erase(BBCases[i].first);// This constant is taken care of 681542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 682542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 683542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // If there are any constants vectored to BB that TI doesn't handle, 684542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // they must go to the default destination of TI. 685c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen for (std::set<ConstantInt*, ConstantIntOrdering>::iterator I = 686c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen PTIHandled.begin(), 687542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner E = PTIHandled.end(); I != E; ++I) { 688542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PredCases.push_back(std::make_pair(*I, BBDefault)); 689542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner NewSuccessors.push_back(BBDefault); 690542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 691542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 692542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 693542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // Okay, at this point, we know which new successor Pred will get. Make 694542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // sure we update the number of entries in the PHI nodes for these 695542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // successors. 696542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner for (unsigned i = 0, e = NewSuccessors.size(); i != e; ++i) 697542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner AddPredecessorToBlock(NewSuccessors[i], Pred, BB); 698542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 69958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen // Convert pointer to int before we switch. 7001df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (CV->getType()->isPointerTy()) { 70158e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen assert(TD && "Cannot switch on pointer without TargetData"); 70258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen CV = new PtrToIntInst(CV, TD->getIntPtrType(CV->getContext()), 70358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen "magicptr", PTI); 70458e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen } 70558e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 706542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // Now that the successors are updated, create the new Switch instruction. 707b1dbcd886a4b5597a839f299054b78b33fb2d6dfGabor Greif SwitchInst *NewSI = SwitchInst::Create(CV, PredDefault, 708b1dbcd886a4b5597a839f299054b78b33fb2d6dfGabor Greif PredCases.size(), PTI); 709542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner for (unsigned i = 0, e = PredCases.size(); i != e; ++i) 710542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner NewSI->addCase(PredCases[i].first, PredCases[i].second); 71113b2f764c041e15af3d6033826deb9c7e669ca97Chris Lattner 712080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman EraseTerminatorInstAndDCECond(PTI); 71313b2f764c041e15af3d6033826deb9c7e669ca97Chris Lattner 714542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // Okay, last check. If BB is still a successor of PSI, then we must 715542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // have an infinite loop case. If so, add an infinitely looping block 716542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // to handle the case to preserve the behavior of the code. 717542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner BasicBlock *InfLoopBlock = 0; 718542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner for (unsigned i = 0, e = NewSI->getNumSuccessors(); i != e; ++i) 719542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (NewSI->getSuccessor(i) == BB) { 720542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (InfLoopBlock == 0) { 721093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // Insert it at the end of the function, because it's either code, 722542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // or it won't matter if it's hot. :) 7231d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson InfLoopBlock = BasicBlock::Create(BB->getContext(), 7241d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson "infloop", BB->getParent()); 725051a950000e21935165db56695e35bade668193bGabor Greif BranchInst::Create(InfLoopBlock, InfLoopBlock); 726542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 727542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner NewSI->setSuccessor(i, InfLoopBlock); 728542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 729fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 730542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner Changed = true; 731542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 732542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 733542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner return Changed; 734542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner} 735542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 736c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen// isSafeToHoistInvoke - If we would need to insert a select that uses the 737c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen// value of this invoke (comments in HoistThenElseCodeToIf explain why we 738c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen// would need to do this), we can't hoist the invoke, as there is nowhere 739c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen// to put the select in this case. 740c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesenstatic bool isSafeToHoistInvoke(BasicBlock *BB1, BasicBlock *BB2, 741c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen Instruction *I1, Instruction *I2) { 742c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) { 743c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen PHINode *PN; 744c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen for (BasicBlock::iterator BBI = SI->begin(); 745c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen (PN = dyn_cast<PHINode>(BBI)); ++BBI) { 746c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen Value *BB1V = PN->getIncomingValueForBlock(BB1); 747c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen Value *BB2V = PN->getIncomingValueForBlock(BB2); 748c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen if (BB1V != BB2V && (BB1V==I1 || BB2V==I2)) { 749c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen return false; 750c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen } 751c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen } 752c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen } 753c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen return true; 754c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen} 755c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen 7566306d07aa8cf71e3c7fed7f295665f53595473ebChris Lattner/// HoistThenElseCodeToIf - Given a conditional branch that goes to BB1 and 75737dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner/// BB2, hoist any common code in the two blocks up into the branch block. The 75837dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner/// caller of this function guarantees that BI's block dominates BB1 and BB2. 75937dc938bbe556a9414d063196d367c2f75d07d95Chris Lattnerstatic bool HoistThenElseCodeToIf(BranchInst *BI) { 76037dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // This does very trivial matching, with limited scanning, to find identical 76137dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // instructions in the two blocks. In particular, we don't want to get into 76237dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // O(M*N) situations here where M and N are the sizes of BB1 and BB2. As 76337dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // such, we currently just scan for obviously identical instructions in an 76437dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // identical order. 76537dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner BasicBlock *BB1 = BI->getSuccessor(0); // The true destination. 76637dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner BasicBlock *BB2 = BI->getSuccessor(1); // The false destination 76737dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner 76865085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel BasicBlock::iterator BB1_Itr = BB1->begin(); 76965085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel BasicBlock::iterator BB2_Itr = BB2->begin(); 77065085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel 77165085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel Instruction *I1 = BB1_Itr++, *I2 = BB2_Itr++; 77265085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel while (isa<DbgInfoIntrinsic>(I1)) 77365085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel I1 = BB1_Itr++; 77465085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel while (isa<DbgInfoIntrinsic>(I2)) 77565085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel I2 = BB2_Itr++; 776c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen if (I1->getOpcode() != I2->getOpcode() || isa<PHINode>(I1) || 77758cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohman !I1->isIdenticalToWhenDefined(I2) || 778c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen (isa<InvokeInst>(I1) && !isSafeToHoistInvoke(BB1, BB2, I1, I2))) 77937dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner return false; 78037dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner 78137dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // If we get here, we can hoist at least one instruction. 78237dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner BasicBlock *BIParent = BI->getParent(); 78337dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner 78437dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner do { 78537dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // If we are hoisting the terminator instruction, don't move one (making a 78637dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // broken BB), instead clone it, and remove BI. 78737dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner if (isa<TerminatorInst>(I1)) 78837dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner goto HoistTerminator; 789fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 79037dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // For a normal instruction, we just move one to right before the branch, 79137dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // then replace all uses of the other with the first. Finally, we remove 79237dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // the now redundant second instruction. 79337dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner BIParent->getInstList().splice(BI, BB1->getInstList(), I1); 79437dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner if (!I2->use_empty()) 79537dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner I2->replaceAllUsesWith(I1); 79658cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohman I1->intersectOptionalDataWith(I2); 797302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner I2->eraseFromParent(); 798fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 79965085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel I1 = BB1_Itr++; 80065085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel while (isa<DbgInfoIntrinsic>(I1)) 80165085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel I1 = BB1_Itr++; 80265085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel I2 = BB2_Itr++; 80365085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel while (isa<DbgInfoIntrinsic>(I2)) 80465085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel I2 = BB2_Itr++; 80558cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohman } while (I1->getOpcode() == I2->getOpcode() && 80658cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohman I1->isIdenticalToWhenDefined(I2)); 80737dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner 80837dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner return true; 80937dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner 81037dc938bbe556a9414d063196d367c2f75d07d95Chris LattnerHoistTerminator: 811c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen // It may not be possible to hoist an invoke. 812c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen if (isa<InvokeInst>(I1) && !isSafeToHoistInvoke(BB1, BB2, I1, I2)) 813c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen return true; 814c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen 81537dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // Okay, it is safe to hoist the terminator. 8166776064d190701c5bae4d5403939eed2e480d1cdNick Lewycky Instruction *NT = I1->clone(); 81737dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner BIParent->getInstList().insert(BI, NT); 818f012705c7e4ca8cf90b6b734ce1d5355daca5ba5Benjamin Kramer if (!NT->getType()->isVoidTy()) { 81937dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner I1->replaceAllUsesWith(NT); 82037dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner I2->replaceAllUsesWith(NT); 82186cc42355593dd1689f7d58d56695c451215b02bChris Lattner NT->takeName(I1); 82237dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner } 82337dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner 82437dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // Hoisting one of the terminators from our successor is a great thing. 82537dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // Unfortunately, the successors of the if/else blocks may have PHI nodes in 82637dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // them. If they do, all PHI entries for BB1/BB2 must agree for all PHI 82737dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // nodes, so we insert select instruction to compute the final result. 82837dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner std::map<std::pair<Value*,Value*>, SelectInst*> InsertedSelects; 82937dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) { 83037dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner PHINode *PN; 83137dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner for (BasicBlock::iterator BBI = SI->begin(); 8320f535c6fa8b03491dc110feb65d78922ee29d1fcChris Lattner (PN = dyn_cast<PHINode>(BBI)); ++BBI) { 83337dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner Value *BB1V = PN->getIncomingValueForBlock(BB1); 83437dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner Value *BB2V = PN->getIncomingValueForBlock(BB2); 8359a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (BB1V == BB2V) continue; 8369a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 8379a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // These values do not agree. Insert a select instruction before NT 8389a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // that determines the right value. 8399a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner SelectInst *&SI = InsertedSelects[std::make_pair(BB1V, BB2V)]; 8409a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (SI == 0) 8419a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner SI = SelectInst::Create(BI->getCondition(), BB1V, BB2V, 8429a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BB1V->getName()+"."+BB2V->getName(), NT); 8439a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Make the PHI node use the select for all incoming values for BB1/BB2 8449a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 8459a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (PN->getIncomingBlock(i) == BB1 || PN->getIncomingBlock(i) == BB2) 8469a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner PN->setIncomingValue(i, SI); 84737dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner } 84837dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner } 84937dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner 85037dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // Update any PHI nodes in our new successors. 85137dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) 85237dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner AddPredecessorToBlock(*SI, BIParent, BB1); 853fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 854080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman EraseTerminatorInstAndDCECond(BI); 85537dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner return true; 85637dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner} 85737dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner 8584d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng/// SpeculativelyExecuteBB - Given a conditional branch that goes to BB1 8594d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng/// and an BB2 and the only successor of BB1 is BB2, hoist simple code 8604d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng/// (for now, restricted to a single instruction that's side effect free) from 8614d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng/// the BB1 into the branch block to speculatively execute it. 8624d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Chengstatic bool SpeculativelyExecuteBB(BranchInst *BI, BasicBlock *BB1) { 8634d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // Only speculatively execution a single instruction (not counting the 8644d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // terminator) for now. 86506b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel Instruction *HInst = NULL; 86606b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel Instruction *Term = BB1->getTerminator(); 86706b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel for (BasicBlock::iterator BBI = BB1->begin(), BBE = BB1->end(); 86806b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel BBI != BBE; ++BBI) { 86906b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel Instruction *I = BBI; 87006b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel // Skip debug info. 8719a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (isa<DbgInfoIntrinsic>(I)) continue; 8729a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (I == Term) break; 87306b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel 8749a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (HInst) 87506b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel return false; 8769a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner HInst = I; 87706b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel } 87806b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel if (!HInst) 87906b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel return false; 8804d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng 881797d95188d00963a835db9ad66dd3c4a54aa2fafEvan Cheng // Be conservative for now. FP select instruction can often be expensive. 882797d95188d00963a835db9ad66dd3c4a54aa2fafEvan Cheng Value *BrCond = BI->getCondition(); 8839a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (isa<FCmpInst>(BrCond)) 884797d95188d00963a835db9ad66dd3c4a54aa2fafEvan Cheng return false; 885797d95188d00963a835db9ad66dd3c4a54aa2fafEvan Cheng 8864d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // If BB1 is actually on the false edge of the conditional branch, remember 8874d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // to swap the select operands later. 8884d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng bool Invert = false; 8894d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng if (BB1 != BI->getSuccessor(0)) { 8904d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng assert(BB1 == BI->getSuccessor(1) && "No edge from 'if' block?"); 8914d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng Invert = true; 8924d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng } 8934d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng 8944d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // Turn 8954d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // BB: 8964d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // %t1 = icmp 8974d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // br i1 %t1, label %BB1, label %BB2 8984d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // BB1: 8994d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // %t3 = add %t2, c 9004d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // br label BB2 9014d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // BB2: 9024d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // => 9034d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // BB: 9044d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // %t1 = icmp 9054d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // %t4 = add %t2, c 9064d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // %t3 = select i1 %t1, %t2, %t3 90706b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel switch (HInst->getOpcode()) { 9084d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng default: return false; // Not safe / profitable to hoist. 9094d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng case Instruction::Add: 9104d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng case Instruction::Sub: 911ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman // Not worth doing for vector ops. 9121df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (HInst->getType()->isVectorTy()) 9139dd3b610dcb17f88ed52ae03022179bf21e0e132Chris Lattner return false; 9149dd3b610dcb17f88ed52ae03022179bf21e0e132Chris Lattner break; 9154d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng case Instruction::And: 9164d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng case Instruction::Or: 9174d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng case Instruction::Xor: 9184d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng case Instruction::Shl: 9194d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng case Instruction::LShr: 9204d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng case Instruction::AShr: 9219dd3b610dcb17f88ed52ae03022179bf21e0e132Chris Lattner // Don't mess with vector operations. 9221df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (HInst->getType()->isVectorTy()) 923e5334ea518e3dffec4037ede97433eb700fa1d26Evan Cheng return false; 9244d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng break; // These are all cheap and non-trapping instructions. 9254d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng } 9266fe73bbcf3b6c1ddfd5e70e8b5188f8df439ace6Chris Lattner 9276fe73bbcf3b6c1ddfd5e70e8b5188f8df439ace6Chris Lattner // If the instruction is obviously dead, don't try to predicate it. 92806b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel if (HInst->use_empty()) { 92906b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel HInst->eraseFromParent(); 9306fe73bbcf3b6c1ddfd5e70e8b5188f8df439ace6Chris Lattner return true; 9316fe73bbcf3b6c1ddfd5e70e8b5188f8df439ace6Chris Lattner } 9324d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng 9334d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // Can we speculatively execute the instruction? And what is the value 9344d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // if the condition is false? Consider the phi uses, if the incoming value 9354d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // from the "if" block are all the same V, then V is the value of the 9364d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // select if the condition is false. 9374d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng BasicBlock *BIParent = BI->getParent(); 9384d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng SmallVector<PHINode*, 4> PHIUses; 9394d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng Value *FalseV = NULL; 9406fe73bbcf3b6c1ddfd5e70e8b5188f8df439ace6Chris Lattner 9416fe73bbcf3b6c1ddfd5e70e8b5188f8df439ace6Chris Lattner BasicBlock *BB2 = BB1->getTerminator()->getSuccessor(0); 94206b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel for (Value::use_iterator UI = HInst->use_begin(), E = HInst->use_end(); 9434d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng UI != E; ++UI) { 9446fe73bbcf3b6c1ddfd5e70e8b5188f8df439ace6Chris Lattner // Ignore any user that is not a PHI node in BB2. These can only occur in 9456fe73bbcf3b6c1ddfd5e70e8b5188f8df439ace6Chris Lattner // unreachable blocks, because they would not be dominated by the instr. 94620361b9d4d9988d7bfa2112650971642cf81d13eGabor Greif PHINode *PN = dyn_cast<PHINode>(*UI); 9476fe73bbcf3b6c1ddfd5e70e8b5188f8df439ace6Chris Lattner if (!PN || PN->getParent() != BB2) 9486fe73bbcf3b6c1ddfd5e70e8b5188f8df439ace6Chris Lattner return false; 9494d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng PHIUses.push_back(PN); 9506fe73bbcf3b6c1ddfd5e70e8b5188f8df439ace6Chris Lattner 9514d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng Value *PHIV = PN->getIncomingValueForBlock(BIParent); 9524d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng if (!FalseV) 9534d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng FalseV = PHIV; 9544d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng else if (FalseV != PHIV) 9556fe73bbcf3b6c1ddfd5e70e8b5188f8df439ace6Chris Lattner return false; // Inconsistent value when condition is false. 9564d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng } 9576fe73bbcf3b6c1ddfd5e70e8b5188f8df439ace6Chris Lattner 9586fe73bbcf3b6c1ddfd5e70e8b5188f8df439ace6Chris Lattner assert(FalseV && "Must have at least one user, and it must be a PHI"); 9594d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng 960502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng // Do not hoist the instruction if any of its operands are defined but not 961502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng // used in this BB. The transformation will prevent the operand from 962502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng // being sunk into the use block. 96306b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel for (User::op_iterator i = HInst->op_begin(), e = HInst->op_end(); 96406b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel i != e; ++i) { 965502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng Instruction *OpI = dyn_cast<Instruction>(*i); 966502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng if (OpI && OpI->getParent() == BIParent && 967502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng !OpI->isUsedInBasicBlock(BIParent)) 968502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng return false; 969502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng } 970502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng 9713d0a9a371c0ce3a46e845a7bf1f1acb7a1cf523eDevang Patel // If we get here, we can hoist the instruction. Try to place it 972990afedb3a4b7d32832d74ad5b5863c19f909e1fDale Johannesen // before the icmp instruction preceding the conditional branch. 9733d0a9a371c0ce3a46e845a7bf1f1acb7a1cf523eDevang Patel BasicBlock::iterator InsertPos = BI; 974990afedb3a4b7d32832d74ad5b5863c19f909e1fDale Johannesen if (InsertPos != BIParent->begin()) 975990afedb3a4b7d32832d74ad5b5863c19f909e1fDale Johannesen --InsertPos; 976990afedb3a4b7d32832d74ad5b5863c19f909e1fDale Johannesen // Skip debug info between condition and branch. 977990afedb3a4b7d32832d74ad5b5863c19f909e1fDale Johannesen while (InsertPos != BIParent->begin() && isa<DbgInfoIntrinsic>(InsertPos)) 9783d0a9a371c0ce3a46e845a7bf1f1acb7a1cf523eDevang Patel --InsertPos; 97920da1f07dac4d771e55ee5c7f105ccedfa4caaaaDevang Patel if (InsertPos == BrCond && !isa<PHINode>(BrCond)) { 9803d0a9a371c0ce3a46e845a7bf1f1acb7a1cf523eDevang Patel SmallPtrSet<Instruction *, 4> BB1Insns; 9813d0a9a371c0ce3a46e845a7bf1f1acb7a1cf523eDevang Patel for(BasicBlock::iterator BB1I = BB1->begin(), BB1E = BB1->end(); 9823d0a9a371c0ce3a46e845a7bf1f1acb7a1cf523eDevang Patel BB1I != BB1E; ++BB1I) 9833d0a9a371c0ce3a46e845a7bf1f1acb7a1cf523eDevang Patel BB1Insns.insert(BB1I); 9843d0a9a371c0ce3a46e845a7bf1f1acb7a1cf523eDevang Patel for(Value::use_iterator UI = BrCond->use_begin(), UE = BrCond->use_end(); 9853d0a9a371c0ce3a46e845a7bf1f1acb7a1cf523eDevang Patel UI != UE; ++UI) { 9863d0a9a371c0ce3a46e845a7bf1f1acb7a1cf523eDevang Patel Instruction *Use = cast<Instruction>(*UI); 9879a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (!BB1Insns.count(Use)) continue; 9889a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 9899a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // If BrCond uses the instruction that place it just before 9909a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // branch instruction. 9919a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner InsertPos = BI; 9929a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner break; 9933d0a9a371c0ce3a46e845a7bf1f1acb7a1cf523eDevang Patel } 9943d0a9a371c0ce3a46e845a7bf1f1acb7a1cf523eDevang Patel } else 9953d0a9a371c0ce3a46e845a7bf1f1acb7a1cf523eDevang Patel InsertPos = BI; 99606b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel BIParent->getInstList().splice(InsertPos, BB1->getInstList(), HInst); 9974d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng 9984d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // Create a select whose true value is the speculatively executed value and 9994d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // false value is the previously determined FalseV. 10004d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng SelectInst *SI; 10014d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng if (Invert) 100206b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel SI = SelectInst::Create(BrCond, FalseV, HInst, 100306b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel FalseV->getName() + "." + HInst->getName(), BI); 10044d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng else 100506b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel SI = SelectInst::Create(BrCond, HInst, FalseV, 100606b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel HInst->getName() + "." + FalseV->getName(), BI); 10074d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng 10084d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // Make the PHI node use the select for all incoming values for "then" and 10094d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // "if" blocks. 10104d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng for (unsigned i = 0, e = PHIUses.size(); i != e; ++i) { 10114d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng PHINode *PN = PHIUses[i]; 10124d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng for (unsigned j = 0, ee = PN->getNumIncomingValues(); j != ee; ++j) 10139a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (PN->getIncomingBlock(j) == BB1 || PN->getIncomingBlock(j) == BIParent) 10144d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng PN->setIncomingValue(j, SI); 10154d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng } 10164d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng 1017502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng ++NumSpeculations; 10184d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng return true; 10194d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng} 10204d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng 10212e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner/// BlockIsSimpleEnoughToThreadThrough - Return true if we can thread a branch 10222e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner/// across this block. 10232e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattnerstatic bool BlockIsSimpleEnoughToThreadThrough(BasicBlock *BB) { 10242e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner BranchInst *BI = cast<BranchInst>(BB->getTerminator()); 1025e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner unsigned Size = 0; 1026e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner 10279200c89968e52a590ee0b96092a0a589aa138a6fDevang Patel for (BasicBlock::iterator BBI = BB->begin(); &*BBI != BI; ++BBI) { 10288483e54837ede5dd40c5561f15c6a663e2bee87cDale Johannesen if (isa<DbgInfoIntrinsic>(BBI)) 10298483e54837ede5dd40c5561f15c6a663e2bee87cDale Johannesen continue; 1030e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner if (Size > 10) return false; // Don't clone large BB's. 10318483e54837ede5dd40c5561f15c6a663e2bee87cDale Johannesen ++Size; 10322e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner 10338483e54837ede5dd40c5561f15c6a663e2bee87cDale Johannesen // We can only support instructions that do not define values that are 1034e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner // live outside of the current basic block. 1035e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner for (Value::use_iterator UI = BBI->use_begin(), E = BBI->use_end(); 1036e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner UI != E; ++UI) { 1037e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner Instruction *U = cast<Instruction>(*UI); 1038e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner if (U->getParent() != BB || isa<PHINode>(U)) return false; 1039e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner } 10402e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner 10412e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner // Looks ok, continue checking. 10422e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner } 1043e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner 10442e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner return true; 10452e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner} 10462e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner 1047eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner/// FoldCondBranchOnPHI - If we have a conditional branch on a PHI node value 1048eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner/// that is defined in the same block as the branch and if any PHI entries are 1049eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner/// constants, thread edges corresponding to that entry to be branches to their 1050eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner/// ultimate destination. 1051302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattnerstatic bool FoldCondBranchOnPHI(BranchInst *BI, const TargetData *TD) { 1052eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner BasicBlock *BB = BI->getParent(); 1053eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner PHINode *PN = dyn_cast<PHINode>(BI->getCondition()); 10549c88d9816246d260b37cdc689f313c56aec6941eChris Lattner // NOTE: we currently cannot transform this case if the PHI node is used 10559c88d9816246d260b37cdc689f313c56aec6941eChris Lattner // outside of the block. 10562e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner if (!PN || PN->getParent() != BB || !PN->hasOneUse()) 10572e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner return false; 1058eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner 1059eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner // Degenerate case of a single entry PHI. 1060eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner if (PN->getNumIncomingValues() == 1) { 106129874e0dc6c4e55bc384611273343bb358982cc3Chris Lattner FoldSingleEntryPHINodes(PN->getParent()); 1062eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner return true; 1063eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner } 1064eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner 1065eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner // Now we know that this block has multiple preds and two succs. 10662e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner if (!BlockIsSimpleEnoughToThreadThrough(BB)) return false; 1067eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner 1068eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner // Okay, this is a simple enough basic block. See if any phi values are 1069eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner // constants. 10706b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { 10719a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner ConstantInt *CB = dyn_cast<ConstantInt>(PN->getIncomingValue(i)); 10729a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (CB == 0 || !CB->getType()->isIntegerTy(1)) continue; 10739a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 10749a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Okay, we now know that all edges from PredBB should be revectored to 10759a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // branch to RealDest. 10769a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BasicBlock *PredBB = PN->getIncomingBlock(i); 10779a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BasicBlock *RealDest = BI->getSuccessor(!CB->getZExtValue()); 10789a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 10799a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (RealDest == BB) continue; // Skip self loops. 10809a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 10819a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // The dest block might have PHI nodes, other predecessors and other 10829a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // difficult cases. Instead of being smart about this, just insert a new 10839a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // block that jumps to the destination block, effectively splitting 10849a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // the edge we are about to create. 10859a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BasicBlock *EdgeBB = BasicBlock::Create(BB->getContext(), 10869a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner RealDest->getName()+".critedge", 10879a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner RealDest->getParent(), RealDest); 10889a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BranchInst::Create(RealDest, EdgeBB); 10896de0a28dfb84095ebd7775f371dd4085cf955076Chris Lattner 10906de0a28dfb84095ebd7775f371dd4085cf955076Chris Lattner // Update PHI nodes. 10916de0a28dfb84095ebd7775f371dd4085cf955076Chris Lattner AddPredecessorToBlock(RealDest, EdgeBB, BB); 10929a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 10939a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // BB may have instructions that are being threaded over. Clone these 10949a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // instructions into EdgeBB. We know that there will be no uses of the 10959a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // cloned instructions outside of EdgeBB. 10969a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BasicBlock::iterator InsertPt = EdgeBB->begin(); 10979a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner DenseMap<Value*, Value*> TranslateMap; // Track translated values. 10989a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner for (BasicBlock::iterator BBI = BB->begin(); &*BBI != BI; ++BBI) { 10999a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(BBI)) { 11009a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner TranslateMap[PN] = PN->getIncomingValueForBlock(PredBB); 11019a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner continue; 11029a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner } 11039a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Clone the instruction. 11049a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner Instruction *N = BBI->clone(); 11059a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (BBI->hasName()) N->setName(BBI->getName()+".c"); 1106eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner 11079a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Update operands due to translation. 11089a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner for (User::op_iterator i = N->op_begin(), e = N->op_end(); 11099a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner i != e; ++i) { 11109a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner DenseMap<Value*, Value*>::iterator PI = TranslateMap.find(*i); 11119a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (PI != TranslateMap.end()) 11129a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner *i = PI->second; 11139a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner } 1114eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner 11159a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Check for trivial simplification. 1116302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner if (Value *V = SimplifyInstruction(N, TD)) { 1117302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner TranslateMap[BBI] = V; 1118302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner delete N; // Instruction folded away, don't need actual inst 11199a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner } else { 11209a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Insert the new instruction into its new home. 11219a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner EdgeBB->getInstList().insert(InsertPt, N); 11229a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (!BBI->use_empty()) 11239a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner TranslateMap[BBI] = N; 1124e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner } 11259a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner } 1126e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner 11279a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Loop over all of the edges from PredBB to BB, changing them to branch 11289a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // to EdgeBB instead. 11299a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner TerminatorInst *PredBBTI = PredBB->getTerminator(); 11309a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner for (unsigned i = 0, e = PredBBTI->getNumSuccessors(); i != e; ++i) 11319a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (PredBBTI->getSuccessor(i) == BB) { 11329a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BB->removePredecessor(PredBB); 11339a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner PredBBTI->setSuccessor(i, EdgeBB); 1134e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner } 11359a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 11369a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Recurse, simplifying any other constants. 1137302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner return FoldCondBranchOnPHI(BI, TD) | true; 11386b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng } 1139eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner 1140eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner return false; 1141eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner} 1142eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner 1143f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner/// FoldTwoEntryPHINode - Given a BB that starts with the specified two-entry 1144f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner/// PHI node, see if we can eliminate it. 114573c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattnerstatic bool FoldTwoEntryPHINode(PHINode *PN, const TargetData *TD) { 1146f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // Ok, this is a two entry PHI node. Check to see if this is a simple "if 1147f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // statement", which has a very simple dominance structure. Basically, we 1148f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // are trying to find the condition that is being branched on, which 1149f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // subsequently causes this merge to happen. We really want control 1150f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // dependence information for this check, but simplifycfg can't keep it up 1151f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // to date, and this catches most of the cases we care about anyway. 1152f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner BasicBlock *BB = PN->getParent(); 1153f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner BasicBlock *IfTrue, *IfFalse; 1154f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner Value *IfCond = GetIfCondition(BB, IfTrue, IfFalse); 115560d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner if (!IfCond || 115660d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner // Don't bother if the branch will be constant folded trivially. 115760d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner isa<ConstantInt>(IfCond)) 115860d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner return false; 1159f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner 1160822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner // Okay, we found that we can merge this two-entry phi node into a select. 1161822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner // Doing so would require us to fold *all* two entry phi nodes in this block. 1162822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner // At some point this becomes non-profitable (particularly if the target 1163822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner // doesn't support cmov's). Only do this transformation if there are two or 1164822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner // fewer PHI nodes in this block. 1165822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner unsigned NumPhis = 0; 1166822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner for (BasicBlock::iterator I = BB->begin(); isa<PHINode>(I); ++NumPhis, ++I) 1167822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner if (NumPhis > 2) 1168822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner return false; 1169822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner 1170f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // Loop over the PHI's seeing if we can promote them all to select 1171f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // instructions. While we are at it, keep track of the instructions 1172f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // that need to be moved to the dominating block. 117344da7ca4213333bcade57a407a890970351db494Chris Lattner SmallPtrSet<Instruction*, 4> AggressiveInsts; 1174f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner 11753aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner for (BasicBlock::iterator II = BB->begin(); isa<PHINode>(II);) { 11763aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner PHINode *PN = cast<PHINode>(II++); 117707ff3539f5342bdac019c68bb362cb222b3f71d9Chris Lattner if (Value *V = SimplifyInstruction(PN, TD)) { 117807ff3539f5342bdac019c68bb362cb222b3f71d9Chris Lattner PN->replaceAllUsesWith(V); 11793aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner PN->eraseFromParent(); 118007ff3539f5342bdac019c68bb362cb222b3f71d9Chris Lattner continue; 1181f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner } 118207ff3539f5342bdac019c68bb362cb222b3f71d9Chris Lattner 118307ff3539f5342bdac019c68bb362cb222b3f71d9Chris Lattner if (!DominatesMergePoint(PN->getIncomingValue(0), BB, &AggressiveInsts) || 118407ff3539f5342bdac019c68bb362cb222b3f71d9Chris Lattner !DominatesMergePoint(PN->getIncomingValue(1), BB, &AggressiveInsts)) 118507ff3539f5342bdac019c68bb362cb222b3f71d9Chris Lattner return false; 1186f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner } 1187f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner 118844da7ca4213333bcade57a407a890970351db494Chris Lattner // If we folded the the first phi, PN dangles at this point. Refresh it. If 118944da7ca4213333bcade57a407a890970351db494Chris Lattner // we ran out of PHIs then we simplified them all. 119044da7ca4213333bcade57a407a890970351db494Chris Lattner PN = dyn_cast<PHINode>(BB->begin()); 119144da7ca4213333bcade57a407a890970351db494Chris Lattner if (PN == 0) return true; 119244da7ca4213333bcade57a407a890970351db494Chris Lattner 11933aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner // Don't fold i1 branches on PHIs which contain binary operators. These can 11943aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner // often be turned into switches and other things. 11953aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner if (PN->getType()->isIntegerTy(1) && 11963aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner (isa<BinaryOperator>(PN->getIncomingValue(0)) || 11973aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner isa<BinaryOperator>(PN->getIncomingValue(1)) || 11983aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner isa<BinaryOperator>(IfCond))) 11993aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner return false; 12003aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner 1201f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // If we all PHI nodes are promotable, check to make sure that all 1202f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // instructions in the predecessor blocks can be promoted as well. If 1203f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // not, we won't be able to get rid of the control flow, so it's not 1204f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // worth promoting to select instructions. 120544da7ca4213333bcade57a407a890970351db494Chris Lattner BasicBlock *DomBlock = 0; 120644da7ca4213333bcade57a407a890970351db494Chris Lattner BasicBlock *IfBlock1 = PN->getIncomingBlock(0); 120744da7ca4213333bcade57a407a890970351db494Chris Lattner BasicBlock *IfBlock2 = PN->getIncomingBlock(1); 120844da7ca4213333bcade57a407a890970351db494Chris Lattner if (cast<BranchInst>(IfBlock1->getTerminator())->isConditional()) { 120944da7ca4213333bcade57a407a890970351db494Chris Lattner IfBlock1 = 0; 121044da7ca4213333bcade57a407a890970351db494Chris Lattner } else { 121144da7ca4213333bcade57a407a890970351db494Chris Lattner DomBlock = *pred_begin(IfBlock1); 121244da7ca4213333bcade57a407a890970351db494Chris Lattner for (BasicBlock::iterator I = IfBlock1->begin();!isa<TerminatorInst>(I);++I) 1213383d7ed9158576aef5cde872548225a17e3c0155Devang Patel if (!AggressiveInsts.count(I) && !isa<DbgInfoIntrinsic>(I)) { 1214f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // This is not an aggressive instruction that we can promote. 1215f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // Because of this, we won't be able to get rid of the control 1216f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // flow, so the xform is not worth it. 1217f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner return false; 1218f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner } 1219f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner } 1220f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner 122144da7ca4213333bcade57a407a890970351db494Chris Lattner if (cast<BranchInst>(IfBlock2->getTerminator())->isConditional()) { 122244da7ca4213333bcade57a407a890970351db494Chris Lattner IfBlock2 = 0; 122344da7ca4213333bcade57a407a890970351db494Chris Lattner } else { 122444da7ca4213333bcade57a407a890970351db494Chris Lattner DomBlock = *pred_begin(IfBlock2); 122544da7ca4213333bcade57a407a890970351db494Chris Lattner for (BasicBlock::iterator I = IfBlock2->begin();!isa<TerminatorInst>(I);++I) 1226383d7ed9158576aef5cde872548225a17e3c0155Devang Patel if (!AggressiveInsts.count(I) && !isa<DbgInfoIntrinsic>(I)) { 1227f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // This is not an aggressive instruction that we can promote. 1228f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // Because of this, we won't be able to get rid of the control 1229f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // flow, so the xform is not worth it. 1230f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner return false; 1231f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner } 1232f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner } 1233e0b18e59120abc29bd25d69d20c4b0f310ec3382Chris Lattner 1234e0b18e59120abc29bd25d69d20c4b0f310ec3382Chris Lattner DEBUG(dbgs() << "FOUND IF CONDITION! " << *IfCond << " T: " 123544da7ca4213333bcade57a407a890970351db494Chris Lattner << IfTrue->getName() << " F: " << IfFalse->getName() << "\n"); 1236f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner 1237f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // If we can still promote the PHI nodes after this gauntlet of tests, 1238f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // do all of the PHI's now. 12393aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner Instruction *InsertPt = DomBlock->getTerminator(); 12403aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner 1241f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // Move all 'aggressive' instructions, which are defined in the 1242f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // conditional parts of the if's up to the dominating block. 12439a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (IfBlock1) 12443aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner DomBlock->getInstList().splice(InsertPt, 12459a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner IfBlock1->getInstList(), IfBlock1->begin(), 1246f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner IfBlock1->getTerminator()); 12479a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (IfBlock2) 12483aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner DomBlock->getInstList().splice(InsertPt, 12499a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner IfBlock2->getInstList(), IfBlock2->begin(), 1250f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner IfBlock2->getTerminator()); 1251f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner 1252f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner while (PHINode *PN = dyn_cast<PHINode>(BB->begin())) { 1253f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // Change the PHI node into a select instruction. 12549a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner Value *TrueVal = PN->getIncomingValue(PN->getIncomingBlock(0) == IfFalse); 12559a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner Value *FalseVal = PN->getIncomingValue(PN->getIncomingBlock(0) == IfTrue); 1256f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner 12573aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner Value *NV = SelectInst::Create(IfCond, TrueVal, FalseVal, "", InsertPt); 125886cc42355593dd1689f7d58d56695c451215b02bChris Lattner PN->replaceAllUsesWith(NV); 125986cc42355593dd1689f7d58d56695c451215b02bChris Lattner NV->takeName(PN); 1260302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner PN->eraseFromParent(); 1261f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner } 126260d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner 126360d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner // At this point, IfBlock1 and IfBlock2 are both empty, so our if statement 126460d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner // has been flattened. Change DomBlock to jump directly to our new block to 126560d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner // avoid other simplifycfg's kicking in on the diamond. 126660d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner TerminatorInst *OldTI = DomBlock->getTerminator(); 126760d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner BranchInst::Create(BB, OldTI); 126860d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner OldTI->eraseFromParent(); 1269f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner return true; 1270f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner} 1271eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner 1272c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner/// SimplifyCondBranchToTwoReturns - If we found a conditional branch that goes 1273c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner/// to two returning blocks, try to merge them together into one return, 1274c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner/// introducing a select if the return values disagree. 1275c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattnerstatic bool SimplifyCondBranchToTwoReturns(BranchInst *BI) { 1276c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner assert(BI->isConditional() && "Must be a conditional branch"); 1277c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner BasicBlock *TrueSucc = BI->getSuccessor(0); 1278c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner BasicBlock *FalseSucc = BI->getSuccessor(1); 1279c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner ReturnInst *TrueRet = cast<ReturnInst>(TrueSucc->getTerminator()); 1280c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner ReturnInst *FalseRet = cast<ReturnInst>(FalseSucc->getTerminator()); 1281c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 1282c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // Check to ensure both blocks are empty (just a return) or optionally empty 1283c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // with PHI nodes. If there are other instructions, merging would cause extra 1284c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // computation on one path or the other. 12859a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (!TrueSucc->getFirstNonPHIOrDbg()->isTerminator()) 12862cc86a1de1cf598be384836f19d1ef1892fb50fcDevang Patel return false; 12879a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (!FalseSucc->getFirstNonPHIOrDbg()->isTerminator()) 12882cc86a1de1cf598be384836f19d1ef1892fb50fcDevang Patel return false; 1289c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 1290c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // Okay, we found a branch that is going to two return nodes. If 1291c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // there is no return value for this function, just change the 1292c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // branch into a return. 1293c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner if (FalseRet->getNumOperands() == 0) { 1294c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner TrueSucc->removePredecessor(BI->getParent()); 1295c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner FalseSucc->removePredecessor(BI->getParent()); 12961d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson ReturnInst::Create(BI->getContext(), 0, BI); 1297080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman EraseTerminatorInstAndDCECond(BI); 1298c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner return true; 1299c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner } 1300c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 1301fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman // Otherwise, figure out what the true and false return values are 1302fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman // so we can insert a new select instruction. 1303fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman Value *TrueValue = TrueRet->getReturnValue(); 1304fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman Value *FalseValue = FalseRet->getReturnValue(); 1305fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman 1306fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman // Unwrap any PHI nodes in the return blocks. 1307fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (PHINode *TVPN = dyn_cast_or_null<PHINode>(TrueValue)) 1308fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (TVPN->getParent() == TrueSucc) 1309fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman TrueValue = TVPN->getIncomingValueForBlock(BI->getParent()); 1310fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (PHINode *FVPN = dyn_cast_or_null<PHINode>(FalseValue)) 1311fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (FVPN->getParent() == FalseSucc) 1312fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman FalseValue = FVPN->getIncomingValueForBlock(BI->getParent()); 1313fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman 1314fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman // In order for this transformation to be safe, we must be able to 1315fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman // unconditionally execute both operands to the return. This is 1316fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman // normally the case, but we could have a potentially-trapping 1317fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman // constant expression that prevents this transformation from being 1318fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman // safe. 1319fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (ConstantExpr *TCV = dyn_cast_or_null<ConstantExpr>(TrueValue)) 1320fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (TCV->canTrap()) 1321fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman return false; 1322fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (ConstantExpr *FCV = dyn_cast_or_null<ConstantExpr>(FalseValue)) 1323fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (FCV->canTrap()) 1324fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman return false; 1325c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 1326c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // Okay, we collected all the mapped values and checked them for sanity, and 1327c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // defined to really do this transformation. First, update the CFG. 1328c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner TrueSucc->removePredecessor(BI->getParent()); 1329c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner FalseSucc->removePredecessor(BI->getParent()); 1330c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 1331c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // Insert select instructions where needed. 1332c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner Value *BrCond = BI->getCondition(); 1333fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (TrueValue) { 1334c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // Insert a select if the results differ. 1335fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (TrueValue == FalseValue || isa<UndefValue>(FalseValue)) { 1336fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman } else if (isa<UndefValue>(TrueValue)) { 1337fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman TrueValue = FalseValue; 1338fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman } else { 1339fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman TrueValue = SelectInst::Create(BrCond, TrueValue, 1340fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman FalseValue, "retval", BI); 1341c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner } 1342c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner } 1343c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 1344fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman Value *RI = !TrueValue ? 13451d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson ReturnInst::Create(BI->getContext(), BI) : 13461d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson ReturnInst::Create(BI->getContext(), TrueValue, BI); 1347e317bcc74c1f317f913e9b05db385901cfc54d0bDaniel Dunbar (void) RI; 1348c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 134989d6fd36a26fdf068ceea90422dc2897e89700b5David Greene DEBUG(dbgs() << "\nCHANGING BRANCH TO TWO RETURNS INTO SELECT:" 1350bdff548e4dd577a72094d57b282de4e765643b96Chris Lattner << "\n " << *BI << "NewRet = " << *RI 1351bdff548e4dd577a72094d57b282de4e765643b96Chris Lattner << "TRUEBLOCK: " << *TrueSucc << "FALSEBLOCK: "<< *FalseSucc); 1352c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 1353080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman EraseTerminatorInstAndDCECond(BI); 1354080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman 1355c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner return true; 1356c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner} 1357c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 13581347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner/// FoldBranchToCommonDest - If this basic block is ONLY a setcc and a branch, 13591347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner/// and if a predecessor branches to us and one of our successors, fold the 13601347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner/// setcc into the predecessor and use logical operations to pick the right 13611347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner/// destination. 13624b35f83b91a1a313f0730c600e5178aaf7df98d6Dan Gohmanbool llvm::FoldBranchToCommonDest(BranchInst *BI) { 1363093a4385027235459ab6972b2e2fdc79061773cfChris Lattner BasicBlock *BB = BI->getParent(); 13641347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner Instruction *Cond = dyn_cast<Instruction>(BI->getCondition()); 1365e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (Cond == 0 || (!isa<CmpInst>(Cond) && !isa<BinaryOperator>(Cond)) || 1366e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson Cond->getParent() != BB || !Cond->hasOneUse()) 1367e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson return false; 1368093a4385027235459ab6972b2e2fdc79061773cfChris Lattner 13691347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner // Only allow this if the condition is a simple instruction that can be 13701347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner // executed unconditionally. It must be in the same block as the branch, and 13711347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner // must be at the front of the block. 1372d0a203d76f4ef77ae1c392e8e73e2f05b676a5f2Devang Patel BasicBlock::iterator FrontIt = BB->front(); 1373d0a203d76f4ef77ae1c392e8e73e2f05b676a5f2Devang Patel // Ignore dbg intrinsics. 1374daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner while (isa<DbgInfoIntrinsic>(FrontIt)) 1375d0a203d76f4ef77ae1c392e8e73e2f05b676a5f2Devang Patel ++FrontIt; 1376e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson 1377e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // Allow a single instruction to be hoisted in addition to the compare 1378e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // that feeds the branch. We later ensure that any values that _it_ uses 1379e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // were also live in the predecessor, so that we don't unnecessarily create 1380e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // register pressure or inhibit out-of-order execution. 1381e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson Instruction *BonusInst = 0; 1382e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (&*FrontIt != Cond && 13832722dfa75dbf4436197f6fcf9d8cb2391975f1a1Owen Anderson FrontIt->hasOneUse() && *FrontIt->use_begin() == Cond && 13842722dfa75dbf4436197f6fcf9d8cb2391975f1a1Owen Anderson FrontIt->isSafeToSpeculativelyExecute()) { 1385e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson BonusInst = &*FrontIt; 1386e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson ++FrontIt; 1387d0a203d76f4ef77ae1c392e8e73e2f05b676a5f2Devang Patel } 13886ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner 1389e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // Only a single bonus inst is allowed. 1390e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (&*FrontIt != Cond) 1391e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson return false; 1392e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson 13931347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner // Make sure the instruction after the condition is the cond branch. 13941347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner BasicBlock::iterator CondIt = Cond; ++CondIt; 1395d0a203d76f4ef77ae1c392e8e73e2f05b676a5f2Devang Patel // Ingore dbg intrinsics. 1396d0a203d76f4ef77ae1c392e8e73e2f05b676a5f2Devang Patel while(isa<DbgInfoIntrinsic>(CondIt)) 1397d0a203d76f4ef77ae1c392e8e73e2f05b676a5f2Devang Patel ++CondIt; 1398d0a203d76f4ef77ae1c392e8e73e2f05b676a5f2Devang Patel if (&*CondIt != BI) { 1399d0a203d76f4ef77ae1c392e8e73e2f05b676a5f2Devang Patel assert (!isa<DbgInfoIntrinsic>(CondIt) && "Hey do not forget debug info!"); 14001347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner return false; 1401d0a203d76f4ef77ae1c392e8e73e2f05b676a5f2Devang Patel } 14026ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner 14036ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner // Cond is known to be a compare or binary operator. Check to make sure that 14046ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner // neither operand is a potentially-trapping constant expression. 14056ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Cond->getOperand(0))) 14066ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner if (CE->canTrap()) 14076ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner return false; 14086ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Cond->getOperand(1))) 14096ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner if (CE->canTrap()) 14106ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner return false; 14116ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner 14121347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner 14131347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner // Finally, don't infinitely unroll conditional loops. 14141347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner BasicBlock *TrueDest = BI->getSuccessor(0); 14151347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner BasicBlock *FalseDest = BI->getSuccessor(1); 14161347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner if (TrueDest == BB || FalseDest == BB) 14171347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner return false; 14181347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner 14191347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) { 14201347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner BasicBlock *PredBlock = *PI; 14211347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner BranchInst *PBI = dyn_cast<BranchInst>(PredBlock->getTerminator()); 14226ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner 1423093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // Check that we have two conditional branches. If there is a PHI node in 1424093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // the common successor, verify that the same value flows in from both 1425093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // blocks. 14261347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner if (PBI == 0 || PBI->isUnconditional() || 14271347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner !SafeToMergeTerminators(BI, PBI)) 14281347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner continue; 14291347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner 1430e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // Ensure that any values used in the bonus instruction are also used 1431e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // by the terminator of the predecessor. This means that those values 1432e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // must already have been resolved, so we won't be inhibiting the 1433e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // out-of-order core by speculating them earlier. 1434e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (BonusInst) { 1435e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // Collect the values used by the bonus inst 1436e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson SmallPtrSet<Value*, 4> UsedValues; 1437e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson for (Instruction::op_iterator OI = BonusInst->op_begin(), 1438e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson OE = BonusInst->op_end(); OI != OE; ++OI) { 1439e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson Value* V = *OI; 1440e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (!isa<Constant>(V)) 1441e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson UsedValues.insert(V); 1442e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson } 1443e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson 1444e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson SmallVector<std::pair<Value*, unsigned>, 4> Worklist; 1445e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson Worklist.push_back(std::make_pair(PBI->getOperand(0), 0)); 1446e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson 1447e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // Walk up to four levels back up the use-def chain of the predecessor's 1448e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // terminator to see if all those values were used. The choice of four 1449e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // levels is arbitrary, to provide a compile-time-cost bound. 1450e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson while (!Worklist.empty()) { 1451e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson std::pair<Value*, unsigned> Pair = Worklist.back(); 1452e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson Worklist.pop_back(); 1453e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson 1454e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (Pair.second >= 4) continue; 1455e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson UsedValues.erase(Pair.first); 1456e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (UsedValues.empty()) break; 1457e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson 1458daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner if (Instruction *I = dyn_cast<Instruction>(Pair.first)) { 1459e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson for (Instruction::op_iterator OI = I->op_begin(), OE = I->op_end(); 1460e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson OI != OE; ++OI) 1461e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson Worklist.push_back(std::make_pair(OI->get(), Pair.second+1)); 1462e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson } 1463e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson } 1464e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson 1465e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (!UsedValues.empty()) return false; 1466e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson } 1467e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson 14683698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner Instruction::BinaryOps Opc; 14693698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner bool InvertPredCond = false; 14703698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner 14713698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner if (PBI->getSuccessor(0) == TrueDest) 14723698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner Opc = Instruction::Or; 14733698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner else if (PBI->getSuccessor(1) == FalseDest) 14743698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner Opc = Instruction::And; 14753698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner else if (PBI->getSuccessor(0) == FalseDest) 14763698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner Opc = Instruction::And, InvertPredCond = true; 14773698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner else if (PBI->getSuccessor(1) == TrueDest) 14783698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner Opc = Instruction::Or, InvertPredCond = true; 14793698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner else 14803698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner continue; 14813698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner 148289d6fd36a26fdf068ceea90422dc2897e89700b5David Greene DEBUG(dbgs() << "FOLDING BRANCH TO COMMON DEST:\n" << *PBI << *BB); 14836ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner 14843698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner // If we need to invert the condition in the pred block to match, do so now. 14853698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner if (InvertPredCond) { 1486daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner Value *NewCond = PBI->getCondition(); 1487daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner 1488daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner if (NewCond->hasOneUse() && isa<CmpInst>(NewCond)) { 1489daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner CmpInst *CI = cast<CmpInst>(NewCond); 1490daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner CI->setPredicate(CI->getInversePredicate()); 1491daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner } else { 1492daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner NewCond = BinaryOperator::CreateNot(NewCond, 14933698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner PBI->getCondition()->getName()+".not", PBI); 1494daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner } 1495daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner 14961347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner PBI->setCondition(NewCond); 14971347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner BasicBlock *OldTrue = PBI->getSuccessor(0); 14981347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner BasicBlock *OldFalse = PBI->getSuccessor(1); 14991347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner PBI->setSuccessor(0, OldFalse); 15001347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner PBI->setSuccessor(1, OldTrue); 15011347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner } 150270087f31f154156bcb494dd0cf3b7d74c0c8b528Chris Lattner 1503e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // If we have a bonus inst, clone it into the predecessor block. 1504e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson Instruction *NewBonus = 0; 1505e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (BonusInst) { 1506e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson NewBonus = BonusInst->clone(); 1507e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson PredBlock->getInstList().insert(PBI, NewBonus); 1508e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson NewBonus->takeName(BonusInst); 1509e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson BonusInst->setName(BonusInst->getName()+".old"); 1510e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson } 1511e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson 15123698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner // Clone Cond into the predecessor basic block, and or/and the 15133698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner // two conditions together. 15146776064d190701c5bae4d5403939eed2e480d1cdNick Lewycky Instruction *New = Cond->clone(); 1515e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (BonusInst) New->replaceUsesOfWith(BonusInst, NewBonus); 15163698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner PredBlock->getInstList().insert(PBI, New); 15173698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner New->takeName(Cond); 15183698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner Cond->setName(New->getName()+".old"); 151970087f31f154156bcb494dd0cf3b7d74c0c8b528Chris Lattner 15203698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner Value *NewCond = BinaryOperator::Create(Opc, PBI->getCondition(), 15213698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner New, "or.cond", PBI); 15223698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner PBI->setCondition(NewCond); 15233698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner if (PBI->getSuccessor(0) == BB) { 15243698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner AddPredecessorToBlock(TrueDest, PredBlock, BB); 15253698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner PBI->setSuccessor(0, TrueDest); 15263698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner } 15273698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner if (PBI->getSuccessor(1) == BB) { 15283698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner AddPredecessorToBlock(FalseDest, PredBlock, BB); 15293698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner PBI->setSuccessor(1, FalseDest); 15301347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner } 1531117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner return true; 15321347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner } 15331347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner return false; 15341347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner} 15351347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner 1536867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner/// SimplifyCondBranchToCondBranch - If we have a conditional branch as a 1537867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner/// predecessor of another block, this function tries to simplify it. We know 1538867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner/// that PBI and BI are both conditional branches, and BI is in one of the 1539867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner/// successor blocks of PBI - PBI branches to BI. 1540867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattnerstatic bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI) { 1541867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner assert(PBI->isConditional() && BI->isConditional()); 1542867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner BasicBlock *BB = BI->getParent(); 15434ae5126d041768ab9665cf2f11c024becd76c41fDan Gohman 1544867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // If this block ends with a branch instruction, and if there is a 1545867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // predecessor that ends on a branch of the same condition, make 1546867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // this conditional branch redundant. 1547867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner if (PBI->getCondition() == BI->getCondition() && 1548867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner PBI->getSuccessor(0) != PBI->getSuccessor(1)) { 1549867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // Okay, the outcome of this conditional branch is statically 1550867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // knowable. If this block had a single pred, handle specially. 1551867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner if (BB->getSinglePredecessor()) { 1552867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // Turn this into a branch on constant. 1553867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner bool CondIsTrue = PBI->getSuccessor(0) == BB; 15541d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson BI->setCondition(ConstantInt::get(Type::getInt1Ty(BB->getContext()), 15551d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson CondIsTrue)); 1556867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner return true; // Nuke the branch on constant. 1557867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner } 1558867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner 1559867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // Otherwise, if there are multiple predecessors, insert a PHI that merges 1560867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // in the constant and simplify the block result. Subsequent passes of 1561867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // simplifycfg will thread the block. 1562867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner if (BlockIsSimpleEnoughToThreadThrough(BB)) { 15631d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PHINode *NewPN = PHINode::Create(Type::getInt1Ty(BB->getContext()), 1564867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner BI->getCondition()->getName() + ".pr", 1565867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner BB->begin()); 1566eb388af89f15ee3de6f53359473e1a54418a667fChris Lattner // Okay, we're going to insert the PHI node. Since PBI is not the only 1567eb388af89f15ee3de6f53359473e1a54418a667fChris Lattner // predecessor, compute the PHI'd conditional value for all of the preds. 1568eb388af89f15ee3de6f53359473e1a54418a667fChris Lattner // Any predecessor where the condition is not computable we keep symbolic. 1569625398343e2673a0c4bb5228fc88f71fe4e1c629Gabor Greif for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) { 1570625398343e2673a0c4bb5228fc88f71fe4e1c629Gabor Greif BasicBlock *P = *PI; 1571625398343e2673a0c4bb5228fc88f71fe4e1c629Gabor Greif if ((PBI = dyn_cast<BranchInst>(P->getTerminator())) && 1572867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner PBI != BI && PBI->isConditional() && 1573867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner PBI->getCondition() == BI->getCondition() && 1574867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner PBI->getSuccessor(0) != PBI->getSuccessor(1)) { 1575867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner bool CondIsTrue = PBI->getSuccessor(0) == BB; 15761d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson NewPN->addIncoming(ConstantInt::get(Type::getInt1Ty(BB->getContext()), 1577625398343e2673a0c4bb5228fc88f71fe4e1c629Gabor Greif CondIsTrue), P); 1578867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner } else { 1579625398343e2673a0c4bb5228fc88f71fe4e1c629Gabor Greif NewPN->addIncoming(BI->getCondition(), P); 1580867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner } 1581625398343e2673a0c4bb5228fc88f71fe4e1c629Gabor Greif } 1582867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner 1583867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner BI->setCondition(NewPN); 1584867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner return true; 1585867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner } 1586867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner } 1587867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner 1588867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // If this is a conditional branch in an empty block, and if any 1589867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // predecessors is a conditional branch to one of our destinations, 1590867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // fold the conditions into logical ops and one cond br. 1591a8d57fe96bb870e4f69c6b522a78936d1495d0d2Zhou Sheng BasicBlock::iterator BBI = BB->begin(); 1592a8d57fe96bb870e4f69c6b522a78936d1495d0d2Zhou Sheng // Ignore dbg intrinsics. 1593a8d57fe96bb870e4f69c6b522a78936d1495d0d2Zhou Sheng while (isa<DbgInfoIntrinsic>(BBI)) 1594a8d57fe96bb870e4f69c6b522a78936d1495d0d2Zhou Sheng ++BBI; 1595a8d57fe96bb870e4f69c6b522a78936d1495d0d2Zhou Sheng if (&*BBI != BI) 1596b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner return false; 159763bf29b5b1c741038d6d502d62721cac0d2760b4Chris Lattner 159863bf29b5b1c741038d6d502d62721cac0d2760b4Chris Lattner 159963bf29b5b1c741038d6d502d62721cac0d2760b4Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(BI->getCondition())) 160063bf29b5b1c741038d6d502d62721cac0d2760b4Chris Lattner if (CE->canTrap()) 160163bf29b5b1c741038d6d502d62721cac0d2760b4Chris Lattner return false; 1602b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 1603b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner int PBIOp, BIOp; 1604b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner if (PBI->getSuccessor(0) == BI->getSuccessor(0)) 1605b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBIOp = BIOp = 0; 1606b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner else if (PBI->getSuccessor(0) == BI->getSuccessor(1)) 1607b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBIOp = 0, BIOp = 1; 1608b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner else if (PBI->getSuccessor(1) == BI->getSuccessor(0)) 1609b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBIOp = 1, BIOp = 0; 1610b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner else if (PBI->getSuccessor(1) == BI->getSuccessor(1)) 1611b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBIOp = BIOp = 1; 1612b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner else 1613b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner return false; 1614867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner 1615b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // Check to make sure that the other destination of this branch 1616b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // isn't BB itself. If so, this is an infinite loop that will 1617b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // keep getting unwound. 1618b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner if (PBI->getSuccessor(PBIOp) == BB) 1619b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner return false; 1620867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner 1621b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // Do not perform this transformation if it would require 1622b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // insertion of a large number of select instructions. For targets 1623b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // without predication/cmovs, this is a big pessimization. 1624b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner BasicBlock *CommonDest = PBI->getSuccessor(PBIOp); 1625867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner 1626b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner unsigned NumPhis = 0; 1627b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner for (BasicBlock::iterator II = CommonDest->begin(); 1628b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner isa<PHINode>(II); ++II, ++NumPhis) 1629b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner if (NumPhis > 2) // Disable this xform. 1630b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner return false; 1631867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner 1632b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // Finally, if everything is ok, fold the branches to logical ops. 1633b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner BasicBlock *OtherDest = BI->getSuccessor(BIOp ^ 1); 1634b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 163589d6fd36a26fdf068ceea90422dc2897e89700b5David Greene DEBUG(dbgs() << "FOLDING BRs:" << *PBI->getParent() 1636bdff548e4dd577a72094d57b282de4e765643b96Chris Lattner << "AND: " << *BI->getParent()); 1637b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 1638093a4385027235459ab6972b2e2fdc79061773cfChris Lattner 1639093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // If OtherDest *is* BB, then BB is a basic block with a single conditional 1640093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // branch in it, where one edge (OtherDest) goes back to itself but the other 1641093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // exits. We don't *know* that the program avoids the infinite loop 1642093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // (even though that seems likely). If we do this xform naively, we'll end up 1643093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // recursively unpeeling the loop. Since we know that (after the xform is 1644093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // done) that the block *is* infinite if reached, we just make it an obviously 1645093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // infinite loop with no cond branch. 1646093a4385027235459ab6972b2e2fdc79061773cfChris Lattner if (OtherDest == BB) { 1647093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // Insert it at the end of the function, because it's either code, 1648093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // or it won't matter if it's hot. :) 16491d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson BasicBlock *InfLoopBlock = BasicBlock::Create(BB->getContext(), 16501d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson "infloop", BB->getParent()); 1651093a4385027235459ab6972b2e2fdc79061773cfChris Lattner BranchInst::Create(InfLoopBlock, InfLoopBlock); 1652093a4385027235459ab6972b2e2fdc79061773cfChris Lattner OtherDest = InfLoopBlock; 1653093a4385027235459ab6972b2e2fdc79061773cfChris Lattner } 1654093a4385027235459ab6972b2e2fdc79061773cfChris Lattner 165589d6fd36a26fdf068ceea90422dc2897e89700b5David Greene DEBUG(dbgs() << *PBI->getParent()->getParent()); 1656b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 1657b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // BI may have other predecessors. Because of this, we leave 1658b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // it alone, but modify PBI. 1659b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 1660b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // Make sure we get to CommonDest on True&True directions. 1661b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner Value *PBICond = PBI->getCondition(); 1662b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner if (PBIOp) 16634ae5126d041768ab9665cf2f11c024becd76c41fDan Gohman PBICond = BinaryOperator::CreateNot(PBICond, 1664b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBICond->getName()+".not", 1665b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBI); 1666b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner Value *BICond = BI->getCondition(); 1667b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner if (BIOp) 16684ae5126d041768ab9665cf2f11c024becd76c41fDan Gohman BICond = BinaryOperator::CreateNot(BICond, 1669b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner BICond->getName()+".not", 1670b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBI); 1671b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // Merge the conditions. 1672b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner Value *Cond = BinaryOperator::CreateOr(PBICond, BICond, "brmerge", PBI); 1673b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 1674b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // Modify PBI to branch on the new condition to the new dests. 1675b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBI->setCondition(Cond); 1676b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBI->setSuccessor(0, CommonDest); 1677b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBI->setSuccessor(1, OtherDest); 1678b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 1679b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // OtherDest may have phi nodes. If so, add an entry from PBI's 1680b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // block that are identical to the entries for BI's block. 16816de0a28dfb84095ebd7775f371dd4085cf955076Chris Lattner AddPredecessorToBlock(OtherDest, PBI->getParent(), BB); 1682b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 1683b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // We know that the CommonDest already had an edge from PBI to 1684b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // it. If it has PHIs though, the PHIs may have different 1685b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // entries for BB and PBI's BB. If so, insert a select to make 1686b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // them agree. 16876de0a28dfb84095ebd7775f371dd4085cf955076Chris Lattner PHINode *PN; 1688b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner for (BasicBlock::iterator II = CommonDest->begin(); 1689b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner (PN = dyn_cast<PHINode>(II)); ++II) { 1690b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner Value *BIV = PN->getIncomingValueForBlock(BB); 1691b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner unsigned PBBIdx = PN->getBasicBlockIndex(PBI->getParent()); 1692b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner Value *PBIV = PN->getIncomingValue(PBBIdx); 1693b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner if (BIV != PBIV) { 1694b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // Insert a select in PBI to pick the right value. 1695b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner Value *NV = SelectInst::Create(PBICond, PBIV, BIV, 1696b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBIV->getName()+".mux", PBI); 1697b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PN->setIncomingValue(PBBIdx, NV); 1698867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner } 1699867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner } 1700b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 170189d6fd36a26fdf068ceea90422dc2897e89700b5David Greene DEBUG(dbgs() << "INTO: " << *PBI->getParent()); 170289d6fd36a26fdf068ceea90422dc2897e89700b5David Greene DEBUG(dbgs() << *PBI->getParent()->getParent()); 1703b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 1704b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // This basic block is probably dead. We know it has at least 1705b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // one fewer predecessor. 1706b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner return true; 1707867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner} 1708867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner 17097ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel// SimplifyIndirectBrOnSelect - Replaces 17107ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel// (indirectbr (select cond, blockaddress(@fn, BlockA), 17117ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel// blockaddress(@fn, BlockB))) 17127ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel// with 17137ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel// (br cond, BlockA, BlockB). 17147ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommelstatic bool SimplifyIndirectBrOnSelect(IndirectBrInst *IBI, SelectInst *SI) { 17157ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Check that both operands of the select are block addresses. 17167ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel BlockAddress *TBA = dyn_cast<BlockAddress>(SI->getTrueValue()); 17177ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel BlockAddress *FBA = dyn_cast<BlockAddress>(SI->getFalseValue()); 17187ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel if (!TBA || !FBA) 17197ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel return false; 17207ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel 17217ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Extract the actual blocks. 17227ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel BasicBlock *TrueBB = TBA->getBasicBlock(); 17237ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel BasicBlock *FalseBB = FBA->getBasicBlock(); 17247ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel 17257ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Remove any superfluous successor edges from the CFG. 17267ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // First, figure out which successors to preserve. 17277ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // If TrueBB and FalseBB are equal, only try to preserve one copy of that 17287ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // successor. 17297ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel BasicBlock *KeepEdge1 = TrueBB; 17307ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel BasicBlock *KeepEdge2 = TrueBB != FalseBB ? FalseBB : 0; 17317ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel 17327ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Then remove the rest. 17337ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel for (unsigned I = 0, E = IBI->getNumSuccessors(); I != E; ++I) { 17347ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel BasicBlock *Succ = IBI->getSuccessor(I); 17357ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Make sure only to keep exactly one copy of each edge. 17367ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel if (Succ == KeepEdge1) 17377ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel KeepEdge1 = 0; 17387ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel else if (Succ == KeepEdge2) 17397ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel KeepEdge2 = 0; 17407ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel else 17417ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel Succ->removePredecessor(IBI->getParent()); 17427ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel } 17437ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel 17447ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Insert an appropriate new terminator. 17457ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel if ((KeepEdge1 == 0) && (KeepEdge2 == 0)) { 17467ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel if (TrueBB == FalseBB) 17477ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // We were only looking for one successor, and it was present. 17487ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Create an unconditional branch to it. 17497ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel BranchInst::Create(TrueBB, IBI); 17507ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel else 17517ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // We found both of the successors we were looking for. 17527ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Create a conditional branch sharing the condition of the select. 17537ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel BranchInst::Create(TrueBB, FalseBB, SI->getCondition(), IBI); 17547ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel } else if (KeepEdge1 && (KeepEdge2 || TrueBB == FalseBB)) { 17557ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Neither of the selected blocks were successors, so this 17567ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // indirectbr must be unreachable. 17577ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel new UnreachableInst(IBI->getContext(), IBI); 17587ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel } else { 17597ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // One of the selected values was a successor, but the other wasn't. 17607ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Insert an unconditional branch to the one that was found; 17617ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // the edge to the one that wasn't must be unreachable. 17627ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel if (KeepEdge1 == 0) 17637ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Only TrueBB was found. 17647ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel BranchInst::Create(TrueBB, IBI); 17657ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel else 17667ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Only FalseBB was found. 17677ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel BranchInst::Create(FalseBB, IBI); 17687ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel } 17697ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel 17707ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel EraseTerminatorInstAndDCECond(IBI); 17717ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel return true; 17727ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel} 17737ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel 177461c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// TryToSimplifyUncondBranchWithICmpInIt - This is called when we find an icmp 177561c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// instruction (a seteq/setne with a constant) as the only instruction in a 177661c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// block that ends with an uncond branch. We are looking for a very specific 177761c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// pattern that occurs when "A == 1 || A == 2 || A == 3" gets simplified. In 177861c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// this case, we merge the first two "or's of icmp" into a switch, but then the 177961c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// default value goes to an uncond block with a seteq in it, we get something 178061c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// like: 178161c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// 178261c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// switch i8 %A, label %DEFAULT [ i8 1, label %end i8 2, label %end ] 178361c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// DEFAULT: 178461c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// %tmp = icmp eq i8 %A, 92 178561c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// br label %end 178661c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// end: 178761c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// ... = phi i1 [ true, %entry ], [ %tmp, %DEFAULT ], [ true, %entry ] 178861c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// 178961c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// We prefer to split the edge to 'end' so that there is a true/false entry to 179061c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// the PHI, merging the third icmp into the switch. 1791302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattnerstatic bool TryToSimplifyUncondBranchWithICmpInIt(ICmpInst *ICI, 1792302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner const TargetData *TD) { 179361c77449c772427a0d2559fca500debd93c7f97cChris Lattner BasicBlock *BB = ICI->getParent(); 179461c77449c772427a0d2559fca500debd93c7f97cChris Lattner // If the block has any PHIs in it or the icmp has multiple uses, it is too 179561c77449c772427a0d2559fca500debd93c7f97cChris Lattner // complex. 179661c77449c772427a0d2559fca500debd93c7f97cChris Lattner if (isa<PHINode>(BB->begin()) || !ICI->hasOneUse()) return false; 179761c77449c772427a0d2559fca500debd93c7f97cChris Lattner 179861c77449c772427a0d2559fca500debd93c7f97cChris Lattner Value *V = ICI->getOperand(0); 179961c77449c772427a0d2559fca500debd93c7f97cChris Lattner ConstantInt *Cst = cast<ConstantInt>(ICI->getOperand(1)); 180061c77449c772427a0d2559fca500debd93c7f97cChris Lattner 180161c77449c772427a0d2559fca500debd93c7f97cChris Lattner // The pattern we're looking for is where our only predecessor is a switch on 180261c77449c772427a0d2559fca500debd93c7f97cChris Lattner // 'V' and this block is the default case for the switch. In this case we can 180361c77449c772427a0d2559fca500debd93c7f97cChris Lattner // fold the compared value into the switch to simplify things. 180461c77449c772427a0d2559fca500debd93c7f97cChris Lattner BasicBlock *Pred = BB->getSinglePredecessor(); 180561c77449c772427a0d2559fca500debd93c7f97cChris Lattner if (Pred == 0 || !isa<SwitchInst>(Pred->getTerminator())) return false; 180661c77449c772427a0d2559fca500debd93c7f97cChris Lattner 180761c77449c772427a0d2559fca500debd93c7f97cChris Lattner SwitchInst *SI = cast<SwitchInst>(Pred->getTerminator()); 180861c77449c772427a0d2559fca500debd93c7f97cChris Lattner if (SI->getCondition() != V) 180961c77449c772427a0d2559fca500debd93c7f97cChris Lattner return false; 181061c77449c772427a0d2559fca500debd93c7f97cChris Lattner 181161c77449c772427a0d2559fca500debd93c7f97cChris Lattner // If BB is reachable on a non-default case, then we simply know the value of 181261c77449c772427a0d2559fca500debd93c7f97cChris Lattner // V in this block. Substitute it and constant fold the icmp instruction 181361c77449c772427a0d2559fca500debd93c7f97cChris Lattner // away. 181461c77449c772427a0d2559fca500debd93c7f97cChris Lattner if (SI->getDefaultDest() != BB) { 181561c77449c772427a0d2559fca500debd93c7f97cChris Lattner ConstantInt *VVal = SI->findCaseDest(BB); 181661c77449c772427a0d2559fca500debd93c7f97cChris Lattner assert(VVal && "Should have a unique destination value"); 181761c77449c772427a0d2559fca500debd93c7f97cChris Lattner ICI->setOperand(0, VVal); 181861c77449c772427a0d2559fca500debd93c7f97cChris Lattner 1819302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner if (Value *V = SimplifyInstruction(ICI, TD)) { 1820302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner ICI->replaceAllUsesWith(V); 182161c77449c772427a0d2559fca500debd93c7f97cChris Lattner ICI->eraseFromParent(); 182261c77449c772427a0d2559fca500debd93c7f97cChris Lattner } 182361c77449c772427a0d2559fca500debd93c7f97cChris Lattner // BB is now empty, so it is likely to simplify away. 182461c77449c772427a0d2559fca500debd93c7f97cChris Lattner return SimplifyCFG(BB) | true; 182561c77449c772427a0d2559fca500debd93c7f97cChris Lattner } 182661c77449c772427a0d2559fca500debd93c7f97cChris Lattner 1827abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner // Ok, the block is reachable from the default dest. If the constant we're 1828abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner // comparing exists in one of the other edges, then we can constant fold ICI 1829abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner // and zap it. 1830abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner if (SI->findCaseValue(Cst) != 0) { 1831abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner Value *V; 1832abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner if (ICI->getPredicate() == ICmpInst::ICMP_EQ) 1833abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner V = ConstantInt::getFalse(BB->getContext()); 1834abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner else 1835abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner V = ConstantInt::getTrue(BB->getContext()); 1836abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner 1837abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner ICI->replaceAllUsesWith(V); 1838abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner ICI->eraseFromParent(); 1839abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner // BB is now empty, so it is likely to simplify away. 1840abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner return SimplifyCFG(BB) | true; 1841abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner } 1842abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner 184361c77449c772427a0d2559fca500debd93c7f97cChris Lattner // The use of the icmp has to be in the 'end' block, by the only PHI node in 184461c77449c772427a0d2559fca500debd93c7f97cChris Lattner // the block. 184561c77449c772427a0d2559fca500debd93c7f97cChris Lattner BasicBlock *SuccBlock = BB->getTerminator()->getSuccessor(0); 184661c77449c772427a0d2559fca500debd93c7f97cChris Lattner PHINode *PHIUse = dyn_cast<PHINode>(ICI->use_back()); 184761c77449c772427a0d2559fca500debd93c7f97cChris Lattner if (PHIUse == 0 || PHIUse != &SuccBlock->front() || 184861c77449c772427a0d2559fca500debd93c7f97cChris Lattner isa<PHINode>(++BasicBlock::iterator(PHIUse))) 184961c77449c772427a0d2559fca500debd93c7f97cChris Lattner return false; 185061c77449c772427a0d2559fca500debd93c7f97cChris Lattner 185161c77449c772427a0d2559fca500debd93c7f97cChris Lattner // If the icmp is a SETEQ, then the default dest gets false, the new edge gets 185261c77449c772427a0d2559fca500debd93c7f97cChris Lattner // true in the PHI. 185361c77449c772427a0d2559fca500debd93c7f97cChris Lattner Constant *DefaultCst = ConstantInt::getTrue(BB->getContext()); 185461c77449c772427a0d2559fca500debd93c7f97cChris Lattner Constant *NewCst = ConstantInt::getFalse(BB->getContext()); 185561c77449c772427a0d2559fca500debd93c7f97cChris Lattner 185661c77449c772427a0d2559fca500debd93c7f97cChris Lattner if (ICI->getPredicate() == ICmpInst::ICMP_EQ) 185761c77449c772427a0d2559fca500debd93c7f97cChris Lattner std::swap(DefaultCst, NewCst); 185861c77449c772427a0d2559fca500debd93c7f97cChris Lattner 185961c77449c772427a0d2559fca500debd93c7f97cChris Lattner // Replace ICI (which is used by the PHI for the default value) with true or 186061c77449c772427a0d2559fca500debd93c7f97cChris Lattner // false depending on if it is EQ or NE. 186161c77449c772427a0d2559fca500debd93c7f97cChris Lattner ICI->replaceAllUsesWith(DefaultCst); 186261c77449c772427a0d2559fca500debd93c7f97cChris Lattner ICI->eraseFromParent(); 186361c77449c772427a0d2559fca500debd93c7f97cChris Lattner 186461c77449c772427a0d2559fca500debd93c7f97cChris Lattner // Okay, the switch goes to this block on a default value. Add an edge from 186561c77449c772427a0d2559fca500debd93c7f97cChris Lattner // the switch to the merge point on the compared value. 186661c77449c772427a0d2559fca500debd93c7f97cChris Lattner BasicBlock *NewBB = BasicBlock::Create(BB->getContext(), "switch.edge", 186761c77449c772427a0d2559fca500debd93c7f97cChris Lattner BB->getParent(), BB); 186861c77449c772427a0d2559fca500debd93c7f97cChris Lattner SI->addCase(Cst, NewBB); 186961c77449c772427a0d2559fca500debd93c7f97cChris Lattner 187061c77449c772427a0d2559fca500debd93c7f97cChris Lattner // NewBB branches to the phi block, add the uncond branch and the phi entry. 187161c77449c772427a0d2559fca500debd93c7f97cChris Lattner BranchInst::Create(SuccBlock, NewBB); 187261c77449c772427a0d2559fca500debd93c7f97cChris Lattner PHIUse->addIncoming(NewCst, NewBB); 187361c77449c772427a0d2559fca500debd93c7f97cChris Lattner return true; 187461c77449c772427a0d2559fca500debd93c7f97cChris Lattner} 187561c77449c772427a0d2559fca500debd93c7f97cChris Lattner 187697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner/// SimplifyBranchOnICmpChain - The specified branch is a conditional branch. 187797fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner/// Check to see if it is branching on an or/and chain of icmp instructions, and 187897fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner/// fold it into a switch instruction if so. 187997fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattnerstatic bool SimplifyBranchOnICmpChain(BranchInst *BI, const TargetData *TD) { 188097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner Instruction *Cond = dyn_cast<Instruction>(BI->getCondition()); 188197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner if (Cond == 0) return false; 188297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 188397fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 188497fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // Change br (X == 0 | X == 1), T, F into a switch instruction. 188597fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // If this is a bunch of seteq's or'd together, or if it's a bunch of 188697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // 'setne's and'ed together, collect them. 188797fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner Value *CompVal = 0; 188897fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner std::vector<ConstantInt*> Values; 188997fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner bool TrueWhenEqual = true; 189097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner Value *ExtraCase = 0; 189197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 189297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner if (Cond->getOpcode() == Instruction::Or) { 189397fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner CompVal = GatherConstantCompares(Cond, Values, ExtraCase, TD, true); 189497fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner } else if (Cond->getOpcode() == Instruction::And) { 189597fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner CompVal = GatherConstantCompares(Cond, Values, ExtraCase, TD, false); 189697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner TrueWhenEqual = false; 189797fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner } 189897fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 189997fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // If we didn't have a multiply compared value, fail. 190097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner if (CompVal == 0) return false; 190197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 190297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // There might be duplicate constants in the list, which the switch 190397fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // instruction can't handle, remove them now. 190497fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner array_pod_sort(Values.begin(), Values.end(), ConstantIntSortPredicate); 190597fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner Values.erase(std::unique(Values.begin(), Values.end()), Values.end()); 190697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 190797fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // If Extra was used, we require at least two switch values to do the 190897fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // transformation. A switch with one value is just an cond branch. 190997fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner if (ExtraCase && Values.size() < 2) return false; 191097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 191197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // Figure out which block is which destination. 191297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner BasicBlock *DefaultBB = BI->getSuccessor(1); 191397fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner BasicBlock *EdgeBB = BI->getSuccessor(0); 191497fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner if (!TrueWhenEqual) std::swap(DefaultBB, EdgeBB); 191597fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 191697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner BasicBlock *BB = BI->getParent(); 191797fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 1918302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner DEBUG(dbgs() << "Converting 'icmp' chain with " << Values.size() 1919117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner << " cases into SWITCH. BB is:\n" << *BB); 1920117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner 192197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // If there are any extra values that couldn't be folded into the switch 192297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // then we evaluate them with an explicit branch first. Split the block 192397fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // right before the condbr to handle it. 192497fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner if (ExtraCase) { 192597fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner BasicBlock *NewBB = BB->splitBasicBlock(BI, "switch.early.test"); 192697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // Remove the uncond branch added to the old block. 192797fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner TerminatorInst *OldTI = BB->getTerminator(); 192897fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 1929117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner if (TrueWhenEqual) 1930117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner BranchInst::Create(EdgeBB, NewBB, ExtraCase, OldTI); 1931117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner else 1932117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner BranchInst::Create(NewBB, EdgeBB, ExtraCase, OldTI); 1933117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner 193497fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner OldTI->eraseFromParent(); 193597bd89ece3fff29ab7e0eaa38f85183abd962f42Chris Lattner 193697bd89ece3fff29ab7e0eaa38f85183abd962f42Chris Lattner // If there are PHI nodes in EdgeBB, then we need to add a new entry to them 193797bd89ece3fff29ab7e0eaa38f85183abd962f42Chris Lattner // for the edge we just added. 19386de0a28dfb84095ebd7775f371dd4085cf955076Chris Lattner AddPredecessorToBlock(EdgeBB, BB, NewBB); 1939302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner 1940302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner DEBUG(dbgs() << " ** 'icmp' chain unhandled condition: " << *ExtraCase 1941302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner << "\nEXTRABB = " << *BB); 194297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner BB = NewBB; 194397fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner } 194497fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 194597fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // Convert pointer to int before we switch. 194697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner if (CompVal->getType()->isPointerTy()) { 194797fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner assert(TD && "Cannot switch on pointer without TargetData"); 194897fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner CompVal = new PtrToIntInst(CompVal, 194997fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner TD->getIntPtrType(CompVal->getContext()), 195097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner "magicptr", BI); 195197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner } 195297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 195397fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // Create the new switch instruction now. 19543d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SwitchInst *New = SwitchInst::Create(CompVal, DefaultBB, Values.size(), BI); 195597fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 195697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // Add all of the 'cases' to the switch instruction. 195797fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner for (unsigned i = 0, e = Values.size(); i != e; ++i) 195897fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner New->addCase(Values[i], EdgeBB); 195997fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 196097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // We added edges from PI to the EdgeBB. As such, if there were any 196197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // PHI nodes in EdgeBB, they need entries to be added corresponding to 196297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // the number of edges added. 196397fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner for (BasicBlock::iterator BBI = EdgeBB->begin(); 196497fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner isa<PHINode>(BBI); ++BBI) { 196597fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner PHINode *PN = cast<PHINode>(BBI); 196697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner Value *InVal = PN->getIncomingValueForBlock(BB); 196797fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner for (unsigned i = 0, e = Values.size()-1; i != e; ++i) 196897fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner PN->addIncoming(InVal, BB); 196997fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner } 197097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 197197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // Erase the old branch instruction. 197297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner EraseTerminatorInstAndDCECond(BI); 1973117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner 1974302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner DEBUG(dbgs() << " ** 'icmp' chain result is:\n" << *BB << '\n'); 197597fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner return true; 197697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner} 197797fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 19783d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattnerbool SimplifyCFGOpt::SimplifyReturn(ReturnInst *RI) { 19793d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *BB = RI->getParent(); 19803d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (!BB->getFirstNonPHIOrDbg()->isTerminator()) return false; 19813d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 19823d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Find predecessors that end with branches. 19833d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SmallVector<BasicBlock*, 8> UncondBranchPreds; 19843d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SmallVector<BranchInst*, 8> CondBranchPreds; 19853d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) { 19863d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *P = *PI; 19873d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner TerminatorInst *PTI = P->getTerminator(); 19883d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BranchInst *BI = dyn_cast<BranchInst>(PTI)) { 19893d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BI->isUnconditional()) 19903d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner UncondBranchPreds.push_back(P); 19913d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner else 19923d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner CondBranchPreds.push_back(BI); 19933d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 19943d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 19953d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 19963d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If we found some, do the transformation! 19973d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (!UncondBranchPreds.empty()) { 19983d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner while (!UncondBranchPreds.empty()) { 19993d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *Pred = UncondBranchPreds.pop_back_val(); 20003d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner DEBUG(dbgs() << "FOLDING: " << *BB 20013d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner << "INTO UNCOND BRANCH PRED: " << *Pred); 20023d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Instruction *UncondBranch = Pred->getTerminator(); 20033d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Clone the return and add it to the end of the predecessor. 20043d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Instruction *NewRet = RI->clone(); 20053d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Pred->getInstList().push_back(NewRet); 20063d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 20073d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the return instruction returns a value, and if the value was a 20083d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // PHI node in "BB", propagate the right value into the return. 20093d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (User::op_iterator i = NewRet->op_begin(), e = NewRet->op_end(); 20103d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner i != e; ++i) 20113d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(*i)) 20123d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (PN->getParent() == BB) 20133d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner *i = PN->getIncomingValueForBlock(Pred); 20143d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 20153d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Update any PHI nodes in the returning block to realize that we no 20163d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // longer branch to them. 20173d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BB->removePredecessor(Pred); 2018302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner UncondBranch->eraseFromParent(); 20193d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 20203d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 20213d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If we eliminated all predecessors of the block, delete the block now. 20223d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (pred_begin(BB) == pred_end(BB)) 20233d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // We know there are no successors, so just nuke the block. 20243d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BB->eraseFromParent(); 20253d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 202601d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner return true; 202701d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner } 20283d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 20293d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Check out all of the conditional branches going to this return 20303d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // instruction. If any of them just select between returns, change the 20313d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // branch itself into a select/return pair. 20323d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner while (!CondBranchPreds.empty()) { 20333d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BranchInst *BI = CondBranchPreds.pop_back_val(); 20343d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 20353d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Check to see if the non-BB successor is also a return block. 20363d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (isa<ReturnInst>(BI->getSuccessor(0)->getTerminator()) && 20373d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner isa<ReturnInst>(BI->getSuccessor(1)->getTerminator()) && 20383d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SimplifyCondBranchToTwoReturns(BI)) 20393d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return true; 20403d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 20413d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return false; 20423d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner} 204301d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner 20443d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattnerbool SimplifyCFGOpt::SimplifyUnwind(UnwindInst *UI) { 20453d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Check to see if the first instruction in this block is just an unwind. 20463d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If so, replace any invoke instructions which use this as an exception 20473d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // destination with call instructions. 20483d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *BB = UI->getParent(); 20493d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (!BB->getFirstNonPHIOrDbg()->isTerminator()) return false; 20502c63566e406974caa70ee27f35af28112e80f951Dan Gohman 20513d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner bool Changed = false; 20523d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SmallVector<BasicBlock*, 8> Preds(pred_begin(BB), pred_end(BB)); 20533d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner while (!Preds.empty()) { 20543d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *Pred = Preds.back(); 20553d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner InvokeInst *II = dyn_cast<InvokeInst>(Pred->getTerminator()); 20563d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (II && II->getUnwindDest() == BB) { 20573d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Insert a new branch instruction before the invoke, because this 20583d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // is now a fall through. 20593d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BranchInst *BI = BranchInst::Create(II->getNormalDest(), II); 20603d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Pred->getInstList().remove(II); // Take out of symbol table 20613d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 20623d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Insert the call now. 20633d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SmallVector<Value*,8> Args(II->op_begin(), II->op_end()-3); 20643d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner CallInst *CI = CallInst::Create(II->getCalledValue(), 20653d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Args.begin(), Args.end(), 20663d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner II->getName(), BI); 20673d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner CI->setCallingConv(II->getCallingConv()); 20683d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner CI->setAttributes(II->getAttributes()); 20693d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the invoke produced a value, the Call now does instead. 20703d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner II->replaceAllUsesWith(CI); 20713d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner delete II; 20723d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Changed = true; 20733d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 20743d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 20753d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Preds.pop_back(); 20763d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 20773d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 20783d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If this block is now dead (and isn't the entry block), remove it. 20793d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (pred_begin(BB) == pred_end(BB) && 20803d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BB != &BB->getParent()->getEntryBlock()) { 20813d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // We know there are no successors, so just nuke the block. 20823d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BB->eraseFromParent(); 2083ddb97a2bf1f06d7d1b0a1af8e74c67917b43b606Chris Lattner return true; 20843d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 2085ddb97a2bf1f06d7d1b0a1af8e74c67917b43b606Chris Lattner 20863d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return Changed; 20873d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner} 2088882d87d168374ce790621e9ad4d7304b9dff0d78Dan Gohman 20893d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattnerbool SimplifyCFGOpt::SimplifyUnreachable(UnreachableInst *UI) { 20903d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *BB = UI->getParent(); 20913d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 20923d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner bool Changed = false; 20933d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 20943d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If there are any instructions immediately before the unreachable that can 20953d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // be removed, do so. 20963d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner while (UI != BB->begin()) { 20973d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock::iterator BBI = UI; 20983d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner --BBI; 20993d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Do not delete instructions that can have side effects, like calls 21003d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // (which may never return) and volatile loads and stores. 21013d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (isa<CallInst>(BBI) && !isa<DbgInfoIntrinsic>(BBI)) break; 21023d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 21033d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (StoreInst *SI = dyn_cast<StoreInst>(BBI)) 21043d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SI->isVolatile()) 21053d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner break; 21063d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 21073d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(BBI)) 21083d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (LI->isVolatile()) 21093d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner break; 21103d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 21113d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Delete this instruction 2112302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner BBI->eraseFromParent(); 21133d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Changed = true; 21143d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 21153d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 21163d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the unreachable instruction is the first in the block, take a gander 21173d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // at all of the predecessors of this instruction, and simplify them. 21183d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (&BB->front() != UI) return Changed; 21193d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 21203d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SmallVector<BasicBlock*, 8> Preds(pred_begin(BB), pred_end(BB)); 21213d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (unsigned i = 0, e = Preds.size(); i != e; ++i) { 21223d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner TerminatorInst *TI = Preds[i]->getTerminator(); 21233d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 21243d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BranchInst *BI = dyn_cast<BranchInst>(TI)) { 21253d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BI->isUnconditional()) { 21263d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BI->getSuccessor(0) == BB) { 21273d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner new UnreachableInst(TI->getContext(), TI); 21283d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner TI->eraseFromParent(); 21293d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Changed = true; 21303d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 21313d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } else { 21323d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BI->getSuccessor(0) == BB) { 21333d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BranchInst::Create(BI->getSuccessor(1), BI); 21343d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner EraseTerminatorInstAndDCECond(BI); 21353d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } else if (BI->getSuccessor(1) == BB) { 21363d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BranchInst::Create(BI->getSuccessor(0), BI); 21373d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner EraseTerminatorInstAndDCECond(BI); 21383d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Changed = true; 213907e6e56f57e8781a8d7bc601cc9034a3741d84c2Anton Korobeynikov } 214019831ec8531b0710629c1b0a8c0323e70ae0ef07Chris Lattner } 21413d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { 21423d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (unsigned i = 1, e = SI->getNumCases(); i != e; ++i) 21433d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SI->getSuccessor(i) == BB) { 21443d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BB->removePredecessor(SI->getParent()); 21453d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SI->removeCase(i); 21463d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner --i; --e; 21473d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Changed = true; 21483d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 21493d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the default value is unreachable, figure out the most popular 21503d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // destination and make it the default. 21513d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SI->getSuccessor(0) == BB) { 21523d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner std::map<BasicBlock*, unsigned> Popularity; 21533d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (unsigned i = 1, e = SI->getNumCases(); i != e; ++i) 21543d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Popularity[SI->getSuccessor(i)]++; 21553d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 21563d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Find the most popular block. 21573d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner unsigned MaxPop = 0; 21583d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *MaxBlock = 0; 21593d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (std::map<BasicBlock*, unsigned>::iterator 21603d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner I = Popularity.begin(), E = Popularity.end(); I != E; ++I) { 21613d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (I->second > MaxPop) { 21623d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner MaxPop = I->second; 21633d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner MaxBlock = I->first; 21643d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 21653d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 21663d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (MaxBlock) { 21673d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Make this the new default, allowing us to delete any explicit 21683d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // edges to it. 21693d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SI->setSuccessor(0, MaxBlock); 21703d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Changed = true; 2171ffba5821eee7b7a6139f9dfb06b8d306bf344a9dChris Lattner 21723d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If MaxBlock has phinodes in it, remove MaxPop-1 entries from 21733d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // it. 21743d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (isa<PHINode>(MaxBlock->begin())) 21753d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (unsigned i = 0; i != MaxPop-1; ++i) 21763d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner MaxBlock->removePredecessor(SI->getParent()); 21773d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 21783d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (unsigned i = 1, e = SI->getNumCases(); i != e; ++i) 21793d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SI->getSuccessor(i) == MaxBlock) { 21803d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SI->removeCase(i); 21813d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner --i; --e; 21823d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 218319831ec8531b0710629c1b0a8c0323e70ae0ef07Chris Lattner } 218419831ec8531b0710629c1b0a8c0323e70ae0ef07Chris Lattner } 21853d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } else if (InvokeInst *II = dyn_cast<InvokeInst>(TI)) { 21863d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (II->getUnwindDest() == BB) { 21873d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Convert the invoke to a call instruction. This would be a good 21883d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // place to note that the call does not throw though. 21899a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BranchInst *BI = BranchInst::Create(II->getNormalDest(), II); 21903d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner II->removeFromParent(); // Take out of symbol table 21913d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 21923d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Insert the call now... 21933d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SmallVector<Value*, 8> Args(II->op_begin(), II->op_end()-3); 21949a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner CallInst *CI = CallInst::Create(II->getCalledValue(), 21959a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner Args.begin(), Args.end(), 21969a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner II->getName(), BI); 21979a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner CI->setCallingConv(II->getCallingConv()); 21989a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner CI->setAttributes(II->getAttributes()); 21993d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the invoke produced a value, the call does now instead. 22009a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner II->replaceAllUsesWith(CI); 22019a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner delete II; 22029a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner Changed = true; 22039a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner } 2204e14ea0804afba2ac5824507571a220d05b0aa21dChris Lattner } 22053d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 22063d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 22073d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If this block is now dead, remove it. 22083d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (pred_begin(BB) == pred_end(BB) && 22093d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BB != &BB->getParent()->getEntryBlock()) { 22103d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // We know there are no successors, so just nuke the block. 22113d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BB->eraseFromParent(); 22123d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return true; 22133d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 22148e509dd5e81e92a466580ab4022994079952cca9Chris Lattner 22153d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return Changed; 22163d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner} 22178e509dd5e81e92a466580ab4022994079952cca9Chris Lattner 2218d0a203d76f4ef77ae1c392e8e73e2f05b676a5f2Devang Patel 22193d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattnerbool SimplifyCFGOpt::SimplifySwitch(SwitchInst *SI) { 22203d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If this switch is too complex to want to look at, ignore it. 22213d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (!isValueEqualityComparison(SI)) 22223d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return false; 2223e67fa05036f634a4ec1e0893033c89250eb58954Chris Lattner 22243d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *BB = SI->getParent(); 22253d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 22263d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If we only have one predecessor, and if it is a branch on this value, 22273d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // see if that predecessor totally determines the outcome of this switch. 22283d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BasicBlock *OnlyPred = BB->getSinglePredecessor()) 22293d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SimplifyEqualityComparisonWithOnlyPredecessor(SI, OnlyPred)) 2230021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner return SimplifyCFG(BB) | true; 22313d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 22323d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the block only contains the switch, see if we can fold the block 22333d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // away into any preds. 22343d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock::iterator BBI = BB->begin(); 22353d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Ignore dbg intrinsics. 22363d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner while (isa<DbgInfoIntrinsic>(BBI)) 22373d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner ++BBI; 22383d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SI == &*BBI) 22393d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (FoldValueComparisonIntoPredecessors(SI)) 2240021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner return SimplifyCFG(BB) | true; 22413d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 22423d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return false; 22433d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner} 22443d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 22453d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattnerbool SimplifyCFGOpt::SimplifyIndirectBr(IndirectBrInst *IBI) { 22463d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *BB = IBI->getParent(); 22473d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner bool Changed = false; 22483d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 22493d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Eliminate redundant destinations. 22503d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SmallPtrSet<Value *, 8> Succs; 22513d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (unsigned i = 0, e = IBI->getNumDestinations(); i != e; ++i) { 22523d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *Dest = IBI->getDestination(i); 22533d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (!Dest->hasAddressTaken() || !Succs.insert(Dest)) { 22543d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Dest->removePredecessor(BB); 22553d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner IBI->removeDestination(i); 22563d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner --i; --e; 2257698f96f7c81e45292ae4f5d76b8e06c88a88a71fChris Lattner Changed = true; 2258698f96f7c81e45292ae4f5d76b8e06c88a88a71fChris Lattner } 22593d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 2260698f96f7c81e45292ae4f5d76b8e06c88a88a71fChris Lattner 22613d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (IBI->getNumDestinations() == 0) { 22623d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the indirectbr has no successors, change it to unreachable. 22633d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner new UnreachableInst(IBI->getContext(), IBI); 22643d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner EraseTerminatorInstAndDCECond(IBI); 22653d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return true; 22663d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 22673d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 22683d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (IBI->getNumDestinations() == 1) { 22693d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the indirectbr has one successor, change it to a direct branch. 22703d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BranchInst::Create(IBI->getDestination(0), IBI); 22713d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner EraseTerminatorInstAndDCECond(IBI); 22723d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return true; 22733d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 22743d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 22753d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(IBI->getAddress())) { 22763d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SimplifyIndirectBrOnSelect(IBI, SI)) 22773d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return SimplifyCFG(BB) | true; 22783d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 22793d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return Changed; 22803d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner} 2281698f96f7c81e45292ae4f5d76b8e06c88a88a71fChris Lattner 22823d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattnerbool SimplifyCFGOpt::SimplifyUncondBranch(BranchInst *BI) { 22833d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *BB = BI->getParent(); 22843d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 22853d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the Terminator is the only non-phi instruction, simplify the block. 22863d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock::iterator I = BB->getFirstNonPHIOrDbg(); 22873d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (I->isTerminator() && BB != &BB->getParent()->getEntryBlock() && 22883d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner TryToSimplifyUncondBranchFromEmptyBlock(BB)) 22893d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return true; 22903d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 22913d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the only instruction in the block is a seteq/setne comparison 22923d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // against a constant, try to simplify the block. 22933d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (ICmpInst *ICI = dyn_cast<ICmpInst>(I)) 22943d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (ICI->isEquality() && isa<ConstantInt>(ICI->getOperand(1))) { 22953d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (++I; isa<DbgInfoIntrinsic>(I); ++I) 22963d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner ; 2297302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner if (I->isTerminator() && TryToSimplifyUncondBranchWithICmpInIt(ICI, TD)) 2298698f96f7c81e45292ae4f5d76b8e06c88a88a71fChris Lattner return true; 2299698f96f7c81e45292ae4f5d76b8e06c88a88a71fChris Lattner } 23003d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23013d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return false; 23023d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner} 2303e2c6d131d12c779a410740e0a90545def75e0f48Dan Gohman 23043d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23053d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattnerbool SimplifyCFGOpt::SimplifyCondBranch(BranchInst *BI) { 23063d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *BB = BI->getParent(); 23073d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23083d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Conditional branch 23093d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (isValueEqualityComparison(BI)) { 23103d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If we only have one predecessor, and if it is a branch on this value, 23113d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // see if that predecessor totally determines the outcome of this 23123d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // switch. 23133d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BasicBlock *OnlyPred = BB->getSinglePredecessor()) 23143d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SimplifyEqualityComparisonWithOnlyPredecessor(BI, OnlyPred)) 23153d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return SimplifyCFG(BB) | true; 23163d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23173d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // This block must be empty, except for the setcond inst, if it exists. 23183d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Ignore dbg intrinsics. 23193d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock::iterator I = BB->begin(); 23203d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Ignore dbg intrinsics. 23213d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner while (isa<DbgInfoIntrinsic>(I)) 23223d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner ++I; 23233d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (&*I == BI) { 23243d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (FoldValueComparisonIntoPredecessors(BI)) 23253d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return SimplifyCFG(BB) | true; 23263d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } else if (&*I == cast<Instruction>(BI->getCondition())){ 23273d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner ++I; 23283d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Ignore dbg intrinsics. 23293d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner while (isa<DbgInfoIntrinsic>(I)) 23303d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner ++I; 23313d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (&*I == BI && FoldValueComparisonIntoPredecessors(BI)) 23323d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return SimplifyCFG(BB) | true; 23333d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 23343d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 23353d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23363d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Try to turn "br (X == 0 | X == 1), T, F" into a switch instruction. 23373d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SimplifyBranchOnICmpChain(BI, TD)) 23383d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return true; 23393d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23403d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // We have a conditional branch to two blocks that are only reachable 23413d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // from BI. We know that the condbr dominates the two blocks, so see if 23423d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // there is any identical code in the "then" and "else" blocks. If so, we 23433d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // can hoist it up to the branching block. 23443d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BI->getSuccessor(0)->getSinglePredecessor() != 0) { 23453d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BI->getSuccessor(1)->getSinglePredecessor() != 0) { 23463d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (HoistThenElseCodeToIf(BI)) 23477ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel return SimplifyCFG(BB) | true; 23483d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } else { 23493d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If Successor #1 has multiple preds, we may be able to conditionally 23503d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // execute Successor #0 if it branches to successor #1. 23513d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner TerminatorInst *Succ0TI = BI->getSuccessor(0)->getTerminator(); 23523d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (Succ0TI->getNumSuccessors() == 1 && 23533d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Succ0TI->getSuccessor(0) == BI->getSuccessor(1)) 23543d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SpeculativelyExecuteBB(BI, BI->getSuccessor(0))) 23553d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return SimplifyCFG(BB) | true; 2356e2c6d131d12c779a410740e0a90545def75e0f48Dan Gohman } 23573d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } else if (BI->getSuccessor(1)->getSinglePredecessor() != 0) { 23583d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If Successor #0 has multiple preds, we may be able to conditionally 23593d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // execute Successor #1 if it branches to successor #0. 23603d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner TerminatorInst *Succ1TI = BI->getSuccessor(1)->getTerminator(); 23613d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (Succ1TI->getNumSuccessors() == 1 && 23623d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Succ1TI->getSuccessor(0) == BI->getSuccessor(0)) 23633d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SpeculativelyExecuteBB(BI, BI->getSuccessor(1))) 23643d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return SimplifyCFG(BB) | true; 236519831ec8531b0710629c1b0a8c0323e70ae0ef07Chris Lattner } 23663d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23673d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If this is a branch on a phi node in the current block, thread control 23683d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // through this block if any PHI node entries are constants. 23693d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(BI->getCondition())) 23703d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (PN->getParent() == BI->getParent()) 2371302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner if (FoldCondBranchOnPHI(BI, TD)) 23723d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return SimplifyCFG(BB) | true; 23733d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23743d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If this basic block is ONLY a setcc and a branch, and if a predecessor 23753d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // branches to us and one of our successors, fold the setcc into the 23763d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // predecessor and use logical operations to pick the right destination. 23773d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (FoldBranchToCommonDest(BI)) 23782d9220e8f5b45390d64e943fa4eef1562b87f04bOwen Anderson return SimplifyCFG(BB) | true; 23793d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23803d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Scan predecessor blocks for conditional branches. 23813d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) 23823d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BranchInst *PBI = dyn_cast<BranchInst>((*PI)->getTerminator())) 23833d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (PBI != BI && PBI->isConditional()) 23843d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SimplifyCondBranchToCondBranch(PBI, BI)) 23853d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return SimplifyCFG(BB) | true; 23863d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23873d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return false; 23883d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner} 23893d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23903d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattnerbool SimplifyCFGOpt::run(BasicBlock *BB) { 23913d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner bool Changed = false; 23923d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 2393302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner assert(BB && BB->getParent() && "Block not embedded in function!"); 23943d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner assert(BB->getTerminator() && "Degenerate basic block encountered!"); 23953d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23963d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Remove basic blocks that have no predecessors (except the entry block)... 23973d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // or that just have themself as a predecessor. These are unreachable. 2398302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner if ((pred_begin(BB) == pred_end(BB) && 2399302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner BB != &BB->getParent()->getEntryBlock()) || 24003d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BB->getSinglePredecessor() == BB) { 24013d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner DEBUG(dbgs() << "Removing BB: \n" << *BB); 24023d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner DeleteDeadBlock(BB); 24033d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return true; 24043d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 24053d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 24063d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Check to see if we can constant propagate this terminator instruction 24073d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // away... 24083d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Changed |= ConstantFoldTerminator(BB); 24093d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 24103d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Check for and eliminate duplicate PHI nodes in this block. 24113d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Changed |= EliminateDuplicatePHINodes(BB); 24123d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 24133d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Merge basic blocks into their predecessor if there is only one distinct 24143d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // pred, and if there is only one distinct successor of the predecessor, and 24153d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // if there are no PHI nodes. 24163d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // 24173d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (MergeBlockIntoPredecessor(BB)) 24183d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return true; 24193d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 24203d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If there is a trivial two-entry PHI node in this basic block, and we can 24213d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // eliminate it, do so now. 24223d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(BB->begin())) 24233d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (PN->getNumIncomingValues() == 2) 242473c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattner Changed |= FoldTwoEntryPHINode(PN, TD); 24253d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 24263d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator())) { 2427021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner if (BI->isUnconditional()) { 2428021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner if (SimplifyUncondBranch(BI)) return true; 2429021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner } else { 2430117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner if (SimplifyCondBranch(BI)) return true; 2431021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner } 2432021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner } else if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator())) { 2433021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner if (SimplifyReturn(RI)) return true; 2434021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner } else if (SwitchInst *SI = dyn_cast<SwitchInst>(BB->getTerminator())) { 2435021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner if (SimplifySwitch(SI)) return true; 2436021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner } else if (UnreachableInst *UI = 2437021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner dyn_cast<UnreachableInst>(BB->getTerminator())) { 2438021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner if (SimplifyUnreachable(UI)) return true; 2439021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner } else if (UnwindInst *UI = dyn_cast<UnwindInst>(BB->getTerminator())) { 2440021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner if (SimplifyUnwind(UI)) return true; 2441021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner } else if (IndirectBrInst *IBI = 2442021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner dyn_cast<IndirectBrInst>(BB->getTerminator())) { 2443021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner if (SimplifyIndirectBr(IBI)) return true; 24443d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 24453d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 2446694e37f08a7c09ccc24642532106295cf7b3a1e3Chris Lattner return Changed; 244701d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner} 244858e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 244958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen/// SimplifyCFG - This function is used to do simplification of a CFG. For 245058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen/// example, it adjusts branches to branches to eliminate the extra hop, it 245158e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen/// eliminates unreachable basic blocks, and does other "peephole" optimization 245258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen/// of the CFG. It returns true if a modification was made. 245358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen/// 245458e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesenbool llvm::SimplifyCFG(BasicBlock *BB, const TargetData *TD) { 245558e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen return SimplifyCFGOpt(TD).run(BB); 245658e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen} 2457