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" 179d5231022283ff20b0291eb5711a449de262d3feNick Lewycky#include "llvm/DerivedTypes.h" 189d5231022283ff20b0291eb5711a449de262d3feNick Lewycky#include "llvm/GlobalVariable.h" 19723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner#include "llvm/Instructions.h" 20383d7ed9158576aef5cde872548225a17e3c0155Devang Patel#include "llvm/IntrinsicInst.h" 2106cc66f65a5012471835068029f3f4943790f584Nick Lewycky#include "llvm/LLVMContext.h" 2206cc66f65a5012471835068029f3f4943790f584Nick Lewycky#include "llvm/Metadata.h" 233b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman#include "llvm/Operator.h" 240d56008f53587531718ec36af82cc24576580b36Chris Lattner#include "llvm/Type.h" 25302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner#include "llvm/Analysis/InstructionSimplify.h" 2610fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer#include "llvm/Analysis/ValueTracking.h" 2758e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen#include "llvm/Target/TargetData.h" 28eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner#include "llvm/Transforms/Utils/BasicBlockUtils.h" 292c63566e406974caa70ee27f35af28112e80f951Dan Gohman#include "llvm/ADT/DenseMap.h" 303b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman#include "llvm/ADT/SetVector.h" 3193e985f1b17aef62d58e3198a4604f9f6cfe8d19Chris Lattner#include "llvm/ADT/SmallVector.h" 32c9951231822215d6aea7a9b50947c18d8d745609Chris Lattner#include "llvm/ADT/SmallPtrSet.h" 33502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng#include "llvm/ADT/Statistic.h" 346d4d21e29d4840236ab6f15c5247379820021d0cChris Lattner#include "llvm/ADT/STLExtras.h" 35302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner#include "llvm/Support/CFG.h" 36c3f507f98a0747bd256e1c13536060b6fc5c4b62Evan Cheng#include "llvm/Support/CommandLine.h" 37e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner#include "llvm/Support/ConstantRange.h" 38302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner#include "llvm/Support/Debug.h" 393e410c6607192bbf28ba3708245cb70a0f983556Devang Patel#include "llvm/Support/IRBuilder.h" 40d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel#include "llvm/Support/NoFolder.h" 41302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner#include "llvm/Support/raw_ostream.h" 4201d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner#include <algorithm> 43d52c261cf801331bebda9711acd54c7c5377a6bdChris Lattner#include <set> 44698f96f7c81e45292ae4f5d76b8e06c88a88a71fChris Lattner#include <map> 45f7703df4968084c18c248c1feea9961c19a32e6aChris Lattnerusing namespace llvm; 46d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 4757808b3da00d7abd01382d3ed5e70bfb0b2beb4bPeter Collingbournestatic cl::opt<unsigned> 4857808b3da00d7abd01382d3ed5e70bfb0b2beb4bPeter CollingbournePHINodeFoldingThreshold("phi-node-folding-threshold", cl::Hidden, cl::init(1), 4957808b3da00d7abd01382d3ed5e70bfb0b2beb4bPeter Collingbourne cl::desc("Control the amount of phi node folding to perform (default = 1)")); 5057808b3da00d7abd01382d3ed5e70bfb0b2beb4bPeter Collingbourne 51c3f507f98a0747bd256e1c13536060b6fc5c4b62Evan Chengstatic cl::opt<bool> 52c3f507f98a0747bd256e1c13536060b6fc5c4b62Evan ChengDupRet("simplifycfg-dup-ret", cl::Hidden, cl::init(false), 53c3f507f98a0747bd256e1c13536060b6fc5c4b62Evan Cheng cl::desc("Duplicate return instructions into unconditional branches")); 54c3f507f98a0747bd256e1c13536060b6fc5c4b62Evan Cheng 55502a4f5162498ec420e3cb22f667808d726dd7daEvan ChengSTATISTIC(NumSpeculations, "Number of speculative executed instructions"); 56502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng 5758e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesennamespace { 5858e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesenclass SimplifyCFGOpt { 5958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen const TargetData *const TD; 6058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 6158e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen Value *isValueEqualityComparison(TerminatorInst *TI); 6258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen BasicBlock *GetValueEqualityComparisonCases(TerminatorInst *TI, 6358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen std::vector<std::pair<ConstantInt*, BasicBlock*> > &Cases); 6458e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen bool SimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI, 65007349dafda47296177fd7481aff9764d4179f42Devang Patel BasicBlock *Pred, 66007349dafda47296177fd7481aff9764d4179f42Devang Patel IRBuilder<> &Builder); 67b55d924b1e33341d08b1bead78e86fce56617784Devang Patel bool FoldValueComparisonIntoPredecessors(TerminatorInst *TI, 68b55d924b1e33341d08b1bead78e86fce56617784Devang Patel IRBuilder<> &Builder); 6958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 70176ec40cb18c51c14fccbb38ee0db5deafb6baa9Devang Patel bool SimplifyReturn(ReturnInst *RI, IRBuilder<> &Builder); 71aa5abe88d6aa445afa593476a665e3ab14b3524cBill Wendling bool SimplifyResume(ResumeInst *RI, IRBuilder<> &Builder); 723d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner bool SimplifyUnreachable(UnreachableInst *UI); 73007349dafda47296177fd7481aff9764d4179f42Devang Patel bool SimplifySwitch(SwitchInst *SI, IRBuilder<> &Builder); 743d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner bool SimplifyIndirectBr(IndirectBrInst *IBI); 75a23812cfbd23604d2fc103cf232cde8fa270a491Devang Patel bool SimplifyUncondBranch(BranchInst *BI, IRBuilder <> &Builder); 76007349dafda47296177fd7481aff9764d4179f42Devang Patel bool SimplifyCondBranch(BranchInst *BI, IRBuilder <>&Builder); 773d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 7858e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesenpublic: 7958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen explicit SimplifyCFGOpt(const TargetData *td) : TD(td) {} 8058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen bool run(BasicBlock *BB); 8158e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen}; 8258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen} 8358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 842bdcb56146279009f233933a101cb3dd54a951cdChris Lattner/// SafeToMergeTerminators - Return true if it is safe to merge these two 852bdcb56146279009f233933a101cb3dd54a951cdChris Lattner/// terminator instructions together. 862bdcb56146279009f233933a101cb3dd54a951cdChris Lattner/// 872bdcb56146279009f233933a101cb3dd54a951cdChris Lattnerstatic bool SafeToMergeTerminators(TerminatorInst *SI1, TerminatorInst *SI2) { 882bdcb56146279009f233933a101cb3dd54a951cdChris Lattner if (SI1 == SI2) return false; // Can't merge with self! 892bdcb56146279009f233933a101cb3dd54a951cdChris Lattner 902bdcb56146279009f233933a101cb3dd54a951cdChris Lattner // It is not safe to merge these two switch instructions if they have a common 912bdcb56146279009f233933a101cb3dd54a951cdChris Lattner // successor, and if that successor has a PHI node, and if *that* PHI node has 922bdcb56146279009f233933a101cb3dd54a951cdChris Lattner // conflicting incoming values from the two switch blocks. 932bdcb56146279009f233933a101cb3dd54a951cdChris Lattner BasicBlock *SI1BB = SI1->getParent(); 942bdcb56146279009f233933a101cb3dd54a951cdChris Lattner BasicBlock *SI2BB = SI2->getParent(); 95c9951231822215d6aea7a9b50947c18d8d745609Chris Lattner SmallPtrSet<BasicBlock*, 16> SI1Succs(succ_begin(SI1BB), succ_end(SI1BB)); 962bdcb56146279009f233933a101cb3dd54a951cdChris Lattner 972bdcb56146279009f233933a101cb3dd54a951cdChris Lattner for (succ_iterator I = succ_begin(SI2BB), E = succ_end(SI2BB); I != E; ++I) 982bdcb56146279009f233933a101cb3dd54a951cdChris Lattner if (SI1Succs.count(*I)) 992bdcb56146279009f233933a101cb3dd54a951cdChris Lattner for (BasicBlock::iterator BBI = (*I)->begin(); 1002bdcb56146279009f233933a101cb3dd54a951cdChris Lattner isa<PHINode>(BBI); ++BBI) { 1012bdcb56146279009f233933a101cb3dd54a951cdChris Lattner PHINode *PN = cast<PHINode>(BBI); 1022bdcb56146279009f233933a101cb3dd54a951cdChris Lattner if (PN->getIncomingValueForBlock(SI1BB) != 1032bdcb56146279009f233933a101cb3dd54a951cdChris Lattner PN->getIncomingValueForBlock(SI2BB)) 1042bdcb56146279009f233933a101cb3dd54a951cdChris Lattner return false; 1052bdcb56146279009f233933a101cb3dd54a951cdChris Lattner } 1062bdcb56146279009f233933a101cb3dd54a951cdChris Lattner 1072bdcb56146279009f233933a101cb3dd54a951cdChris Lattner return true; 1082bdcb56146279009f233933a101cb3dd54a951cdChris Lattner} 1092bdcb56146279009f233933a101cb3dd54a951cdChris Lattner 1102bdcb56146279009f233933a101cb3dd54a951cdChris Lattner/// AddPredecessorToBlock - Update PHI nodes in Succ to indicate that there will 1112bdcb56146279009f233933a101cb3dd54a951cdChris Lattner/// now be entries in it from the 'NewPred' block. The values that will be 1122bdcb56146279009f233933a101cb3dd54a951cdChris Lattner/// flowing into the PHI nodes will be the same as those coming in from 1132bdcb56146279009f233933a101cb3dd54a951cdChris Lattner/// ExistPred, an existing predecessor of Succ. 1142bdcb56146279009f233933a101cb3dd54a951cdChris Lattnerstatic void AddPredecessorToBlock(BasicBlock *Succ, BasicBlock *NewPred, 1152bdcb56146279009f233933a101cb3dd54a951cdChris Lattner BasicBlock *ExistPred) { 1162bdcb56146279009f233933a101cb3dd54a951cdChris Lattner if (!isa<PHINode>(Succ->begin())) return; // Quick exit if nothing to do 1172bdcb56146279009f233933a101cb3dd54a951cdChris Lattner 118093a4385027235459ab6972b2e2fdc79061773cfChris Lattner PHINode *PN; 119093a4385027235459ab6972b2e2fdc79061773cfChris Lattner for (BasicBlock::iterator I = Succ->begin(); 120093a4385027235459ab6972b2e2fdc79061773cfChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 121093a4385027235459ab6972b2e2fdc79061773cfChris Lattner PN->addIncoming(PN->getIncomingValueForBlock(ExistPred), NewPred); 1222bdcb56146279009f233933a101cb3dd54a951cdChris Lattner} 1232bdcb56146279009f233933a101cb3dd54a951cdChris Lattner 1247e66348cba4384d07b37ad1c186e67ba6d26babdChris Lattner 12573c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattner/// GetIfCondition - Given a basic block (BB) with two predecessors (and at 12673c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattner/// least one PHI node in it), check to see if the merge at this block is due 127723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner/// to an "if condition". If so, return the boolean condition that determines 128723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner/// which entry into BB will be taken. Also, return by references the block 129723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner/// that will be entered from if the condition is true, and the block that will 130723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner/// be entered if the condition is false. 131fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman/// 132995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner/// This does no checking to see if the true/false blocks have large or unsavory 133995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner/// instructions in them. 13473c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattnerstatic Value *GetIfCondition(BasicBlock *BB, BasicBlock *&IfTrue, 13573c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattner BasicBlock *&IfFalse) { 13673c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattner PHINode *SomePHI = cast<PHINode>(BB->begin()); 13773c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattner assert(SomePHI->getNumIncomingValues() == 2 && 138723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner "Function can only handle blocks with 2 predecessors!"); 13973c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattner BasicBlock *Pred1 = SomePHI->getIncomingBlock(0); 14073c50a68a7e26b59db54df86e9cc87eed5034bf4Chris Lattner BasicBlock *Pred2 = SomePHI->getIncomingBlock(1); 141723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 142723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // We can only handle branches. Other control flow will be lowered to 143723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // branches if possible anyway. 144995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner BranchInst *Pred1Br = dyn_cast<BranchInst>(Pred1->getTerminator()); 145995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner BranchInst *Pred2Br = dyn_cast<BranchInst>(Pred2->getTerminator()); 146995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner if (Pred1Br == 0 || Pred2Br == 0) 147723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner return 0; 148723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 149723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // Eliminate code duplication by ensuring that Pred1Br is conditional if 150723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // either are. 151723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner if (Pred2Br->isConditional()) { 152723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // If both branches are conditional, we don't have an "if statement". In 153723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // reality, we could transform this case, but since the condition will be 154723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // required anyway, we stand no chance of eliminating it, so the xform is 155723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // probably not profitable. 156723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner if (Pred1Br->isConditional()) 157723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner return 0; 158723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 159723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner std::swap(Pred1, Pred2); 160723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner std::swap(Pred1Br, Pred2Br); 161723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner } 162723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 163723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner if (Pred1Br->isConditional()) { 164995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner // The only thing we have to watch out for here is to make sure that Pred2 165995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner // doesn't have incoming edges from other blocks. If it does, the condition 166995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner // doesn't dominate BB. 167995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner if (Pred2->getSinglePredecessor() == 0) 168995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner return 0; 169995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner 170723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // If we found a conditional branch predecessor, make sure that it branches 171723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // to BB and Pred2Br. If it doesn't, this isn't an "if statement". 172723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner if (Pred1Br->getSuccessor(0) == BB && 173723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner Pred1Br->getSuccessor(1) == Pred2) { 174723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner IfTrue = Pred1; 175723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner IfFalse = Pred2; 176723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner } else if (Pred1Br->getSuccessor(0) == Pred2 && 177723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner Pred1Br->getSuccessor(1) == BB) { 178723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner IfTrue = Pred2; 179723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner IfFalse = Pred1; 180723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner } else { 181723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // We know that one arm of the conditional goes to BB, so the other must 182723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // go somewhere unrelated, and this must not be an "if statement". 183723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner return 0; 184723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner } 185723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 186723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner return Pred1Br->getCondition(); 187723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner } 188723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 189723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // Ok, if we got here, both predecessors end with an unconditional branch to 190723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // BB. Don't panic! If both blocks only have a single (identical) 191723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // predecessor, and THAT is a conditional branch, then we're all ok! 192995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner BasicBlock *CommonPred = Pred1->getSinglePredecessor(); 193995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner if (CommonPred == 0 || CommonPred != Pred2->getSinglePredecessor()) 194723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner return 0; 195723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 196723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner // Otherwise, if this is a conditional branch, then we can use it! 197995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner BranchInst *BI = dyn_cast<BranchInst>(CommonPred->getTerminator()); 198995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner if (BI == 0) return 0; 199995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner 200995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner assert(BI->isConditional() && "Two successors but not conditional?"); 201995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner if (BI->getSuccessor(0) == Pred1) { 202995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner IfTrue = Pred1; 203995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner IfFalse = Pred2; 204995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner } else { 205995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner IfTrue = Pred2; 206995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner IfFalse = Pred1; 207723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner } 208995ba1bd49e57dee8e301d5f33a7c01d73b7385dChris Lattner return BI->getCondition(); 209723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner} 210723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 2113b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// ComputeSpeculuationCost - Compute an abstract "cost" of speculating the 2123b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// given instruction, which is assumed to be safe to speculate. 1 means 2133b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// cheap, 2 means less cheap, and UINT_MAX means prohibitively expensive. 2143b205175ea417349ab96f3525d730e005e12c0f9Dan Gohmanstatic unsigned ComputeSpeculationCost(const User *I) { 2153b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman assert(isSafeToSpeculativelyExecute(I) && 2163b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman "Instruction is not safe to speculatively execute!"); 2173b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman switch (Operator::getOpcode(I)) { 2183b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman default: 2193b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // In doubt, be conservative. 2203b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman return UINT_MAX; 2213b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman case Instruction::GetElementPtr: 2223b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // GEPs are cheap if all indices are constant. 2233b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman if (!cast<GEPOperator>(I)->hasAllConstantIndices()) 2243b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman return UINT_MAX; 2253b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman return 1; 2263b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman case Instruction::Load: 2273b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman case Instruction::Add: 2283b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman case Instruction::Sub: 2293b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman case Instruction::And: 2303b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman case Instruction::Or: 2313b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman case Instruction::Xor: 2323b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman case Instruction::Shl: 2333b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman case Instruction::LShr: 2343b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman case Instruction::AShr: 2353b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman case Instruction::ICmp: 2363b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman case Instruction::Trunc: 2373b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman case Instruction::ZExt: 2383b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman case Instruction::SExt: 2393b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman return 1; // These are all cheap. 2403b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman 2413b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman case Instruction::Call: 2423b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman case Instruction::Select: 2433b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman return 2; 2443b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman } 2453b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman} 2463b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman 2475049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// DominatesMergePoint - If we have a merge point of an "if condition" as 2485049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// accepted above, return true if the specified value dominates the block. We 2495049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// don't handle the true generality of domination here, just a special case 2505049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// which works well enough for us. 2515049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// 2525049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// If AggressiveInsts is non-null, and if V does not dominate BB, we check to 253f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne/// see if V (which must be an instruction) and its recursive operands 254f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne/// that do not dominate BB have a combined cost lower than CostRemaining and 255f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne/// are non-trapping. If both are true, the instruction is inserted into the 256f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne/// set and true is returned. 257f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne/// 258f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne/// The cost for most non-trapping instructions is defined as 1 except for 259f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne/// Select whose cost is 2. 260f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne/// 261f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne/// After this function returns, CostRemaining is decreased by the cost of 262f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne/// V plus its non-dominating operands. If that cost is greater than 263f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne/// CostRemaining, false is returned and CostRemaining is undefined. 2649c07866ef861e072395306e9811c329c7fe5bbe8Chris Lattnerstatic bool DominatesMergePoint(Value *V, BasicBlock *BB, 265f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne SmallPtrSet<Instruction*, 4> *AggressiveInsts, 266f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne unsigned &CostRemaining) { 267570751c2a7d8851bc61e408746a903b0253d2d21Chris Lattner Instruction *I = dyn_cast<Instruction>(V); 268b74b1816305affe25da32c2f29532df41a23cd55Chris Lattner if (!I) { 269b74b1816305affe25da32c2f29532df41a23cd55Chris Lattner // Non-instructions all dominate instructions, but not all constantexprs 270b74b1816305affe25da32c2f29532df41a23cd55Chris Lattner // can be executed unconditionally. 271b74b1816305affe25da32c2f29532df41a23cd55Chris Lattner if (ConstantExpr *C = dyn_cast<ConstantExpr>(V)) 272b74b1816305affe25da32c2f29532df41a23cd55Chris Lattner if (C->canTrap()) 273b74b1816305affe25da32c2f29532df41a23cd55Chris Lattner return false; 274b74b1816305affe25da32c2f29532df41a23cd55Chris Lattner return true; 275b74b1816305affe25da32c2f29532df41a23cd55Chris Lattner } 276570751c2a7d8851bc61e408746a903b0253d2d21Chris Lattner BasicBlock *PBB = I->getParent(); 277570751c2a7d8851bc61e408746a903b0253d2d21Chris Lattner 278da895d63377b421dc50117befb2bec80d2973526Chris Lattner // We don't want to allow weird loops that might have the "if condition" in 279570751c2a7d8851bc61e408746a903b0253d2d21Chris Lattner // the bottom of this block. 280570751c2a7d8851bc61e408746a903b0253d2d21Chris Lattner if (PBB == BB) return false; 281570751c2a7d8851bc61e408746a903b0253d2d21Chris Lattner 282570751c2a7d8851bc61e408746a903b0253d2d21Chris Lattner // If this instruction is defined in a block that contains an unconditional 283570751c2a7d8851bc61e408746a903b0253d2d21Chris Lattner // branch to BB, then it must be in the 'conditional' part of the "if 28444da7ca4213333bcade57a407a890970351db494Chris Lattner // statement". If not, it definitely dominates the region. 28544da7ca4213333bcade57a407a890970351db494Chris Lattner BranchInst *BI = dyn_cast<BranchInst>(PBB->getTerminator()); 28644da7ca4213333bcade57a407a890970351db494Chris Lattner if (BI == 0 || BI->isConditional() || BI->getSuccessor(0) != BB) 28744da7ca4213333bcade57a407a890970351db494Chris Lattner return true; 2880b79a7727d68a507837e827803859424cf3d997bEli Friedman 28944da7ca4213333bcade57a407a890970351db494Chris Lattner // If we aren't allowing aggressive promotion anymore, then don't consider 29044da7ca4213333bcade57a407a890970351db494Chris Lattner // instructions in the 'if region'. 29144da7ca4213333bcade57a407a890970351db494Chris Lattner if (AggressiveInsts == 0) return false; 29244da7ca4213333bcade57a407a890970351db494Chris Lattner 293f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne // If we have seen this instruction before, don't count it again. 294f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne if (AggressiveInsts->count(I)) return true; 295f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne 29644da7ca4213333bcade57a407a890970351db494Chris Lattner // Okay, it looks like the instruction IS in the "condition". Check to 29744da7ca4213333bcade57a407a890970351db494Chris Lattner // see if it's a cheap instruction to unconditionally compute, and if it 29844da7ca4213333bcade57a407a890970351db494Chris Lattner // only uses stuff defined outside of the condition. If so, hoist it out. 299f0426601977c3e386d2d26c72a2cca691dc42072Dan Gohman if (!isSafeToSpeculativelyExecute(I)) 30044da7ca4213333bcade57a407a890970351db494Chris Lattner return false; 301fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 3023b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman unsigned Cost = ComputeSpeculationCost(I); 303723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner 304f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne if (Cost > CostRemaining) 305f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne return false; 306f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne 307f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne CostRemaining -= Cost; 308f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne 309f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne // Okay, we can only really hoist these out if their operands do 310f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne // not take us over the cost threshold. 31144da7ca4213333bcade57a407a890970351db494Chris Lattner for (User::op_iterator i = I->op_begin(), e = I->op_end(); i != e; ++i) 312f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne if (!DominatesMergePoint(*i, BB, AggressiveInsts, CostRemaining)) 31344da7ca4213333bcade57a407a890970351db494Chris Lattner return false; 31444da7ca4213333bcade57a407a890970351db494Chris Lattner // Okay, it's safe to do this! Remember this instruction. 31544da7ca4213333bcade57a407a890970351db494Chris Lattner AggressiveInsts->insert(I); 316723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner return true; 317723c66d4c0aa081ea8fa221617c5097e31333e6cChris Lattner} 31801d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner 31958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen/// GetConstantInt - Extract ConstantInt from value, looking through IntToPtr 32058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen/// and PointerNullValue. Return NULL if value is not a constant int. 32128acc135481691771205dea7cb4edbd3927aa764Chris Lattnerstatic ConstantInt *GetConstantInt(Value *V, const TargetData *TD) { 32258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen // Normal constant int. 32358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen ConstantInt *CI = dyn_cast<ConstantInt>(V); 3241df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (CI || !TD || !isa<Constant>(V) || !V->getType()->isPointerTy()) 32558e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen return CI; 32658e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 32758e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen // This is some kind of pointer constant. Turn it into a pointer-sized 32858e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen // ConstantInt if possible. 329db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *PtrTy = TD->getIntPtrType(V->getContext()); 33058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 33158e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen // Null pointer means 0, see SelectionDAGBuilder::getValue(const Value*). 33258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen if (isa<ConstantPointerNull>(V)) 33358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen return ConstantInt::get(PtrTy, 0); 33458e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 33558e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen // IntToPtr const int. 33658e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) 33758e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen if (CE->getOpcode() == Instruction::IntToPtr) 33858e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(0))) { 33958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen // The constant is very likely to have the right type already. 34058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen if (CI->getType() == PtrTy) 34158e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen return CI; 34258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen else 34358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen return cast<ConstantInt> 34458e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen (ConstantExpr::getIntegerCast(CI, PtrTy, /*isSigned=*/false)); 34558e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen } 34658e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen return 0; 34758e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen} 34858e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 3490aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner/// GatherConstantCompares - Given a potentially 'or'd or 'and'd together 3500aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner/// collection of icmp eq/ne instructions that compare a value against a 3510aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner/// constant, return the value being compared, and stick the constant into the 3520aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner/// Values vector. 35328acc135481691771205dea7cb4edbd3927aa764Chris Lattnerstatic Value * 3540aa749bde7c696e0522df5581ea9cc70f25e62cbChris LattnerGatherConstantCompares(Value *V, std::vector<ConstantInt*> &Vals, Value *&Extra, 35533828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer const TargetData *TD, bool isEQ, unsigned &UsedICmps) { 3560aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner Instruction *I = dyn_cast<Instruction>(V); 3570aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner if (I == 0) return 0; 3589a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 3597312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner // If this is an icmp against a constant, handle this as one of the cases. 3600aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner if (ICmpInst *ICI = dyn_cast<ICmpInst>(I)) { 361e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner if (ConstantInt *C = GetConstantInt(I->getOperand(1), TD)) { 362e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner if (ICI->getPredicate() == (isEQ ? ICmpInst::ICMP_EQ:ICmpInst::ICMP_NE)) { 36333828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer UsedICmps++; 3640aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner Vals.push_back(C); 3650aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner return I->getOperand(0); 3660aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner } 367e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner 368e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner // If we have "x ult 3" comparison, for example, then we can add 0,1,2 to 369e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner // the set. 370e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner ConstantRange Span = 371a37029cd24105f645a694abbafbc9bf1212708b0Chris Lattner ConstantRange::makeICmpRegion(ICI->getPredicate(), C->getValue()); 372e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner 373e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner // If this is an and/!= check then we want to optimize "x ugt 2" into 374e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner // x != 0 && x != 1. 375e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner if (!isEQ) 376e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner Span = Span.inverse(); 377e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner 378e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner // If there are a ton of values, we don't want to make a ginormous switch. 379f460bf8cd8e8a711e9de33085884e31d1c989010Nick Lewycky if (Span.getSetSize().ugt(8) || Span.isEmptySet()) 380e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner return 0; 381e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner 382e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner for (APInt Tmp = Span.getLower(); Tmp != Span.getUpper(); ++Tmp) 383e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner Vals.push_back(ConstantInt::get(V->getContext(), Tmp)); 38433828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer UsedICmps++; 385e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner return I->getOperand(0); 386e27db74a60c44d2b5d2700ecde11b1adce0d0d59Chris Lattner } 387662269d2abb2f220c3a9b727c2a948246128cd05Chris Lattner return 0; 388662269d2abb2f220c3a9b727c2a948246128cd05Chris Lattner } 389662269d2abb2f220c3a9b727c2a948246128cd05Chris Lattner 3907312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner // Otherwise, we can only handle an | or &, depending on isEQ. 3910aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner if (I->getOpcode() != (isEQ ? Instruction::Or : Instruction::And)) 392662269d2abb2f220c3a9b727c2a948246128cd05Chris Lattner return 0; 393662269d2abb2f220c3a9b727c2a948246128cd05Chris Lattner 3947312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner unsigned NumValsBeforeLHS = Vals.size(); 39533828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer unsigned UsedICmpsBeforeLHS = UsedICmps; 3960aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner if (Value *LHS = GatherConstantCompares(I->getOperand(0), Vals, Extra, TD, 39733828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer isEQ, UsedICmps)) { 3987312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner unsigned NumVals = Vals.size(); 39933828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer unsigned UsedICmpsBeforeRHS = UsedICmps; 4000aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner if (Value *RHS = GatherConstantCompares(I->getOperand(1), Vals, Extra, TD, 40133828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer isEQ, UsedICmps)) { 4020aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner if (LHS == RHS) 4030aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner return LHS; 40492407e589524d98080f4db943a0e2a3bf18ec8a2Chris Lattner Vals.resize(NumVals); 40533828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer UsedICmps = UsedICmpsBeforeRHS; 4060aa749bde7c696e0522df5581ea9cc70f25e62cbChris Lattner } 4077312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner 4087312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner // The RHS of the or/and can't be folded in and we haven't used "Extra" yet, 4097312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner // set it and return success. 4107312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner if (Extra == 0 || Extra == I->getOperand(1)) { 4117312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner Extra = I->getOperand(1); 4127312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner return LHS; 4137312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner } 4147312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner 4157312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner Vals.resize(NumValsBeforeLHS); 41633828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer UsedICmps = UsedICmpsBeforeLHS; 4177312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner return 0; 4187312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner } 4197312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner 4207312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner // If the LHS can't be folded in, but Extra is available and RHS can, try to 4217312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner // use LHS as Extra. 4227312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner if (Extra == 0 || Extra == I->getOperand(0)) { 42392407e589524d98080f4db943a0e2a3bf18ec8a2Chris Lattner Value *OldExtra = Extra; 4247312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner Extra = I->getOperand(0); 4257312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner if (Value *RHS = GatherConstantCompares(I->getOperand(1), Vals, Extra, TD, 42633828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer isEQ, UsedICmps)) 4277312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner return RHS; 42892407e589524d98080f4db943a0e2a3bf18ec8a2Chris Lattner assert(Vals.size() == NumValsBeforeLHS); 42992407e589524d98080f4db943a0e2a3bf18ec8a2Chris Lattner Extra = OldExtra; 43007e6e56f57e8781a8d7bc601cc9034a3741d84c2Anton Korobeynikov } 4317312a22ed63607e4ae7b0d9326e42358fd41e245Chris Lattner 4320d56008f53587531718ec36af82cc24576580b36Chris Lattner return 0; 4330d56008f53587531718ec36af82cc24576580b36Chris Lattner} 4349d5231022283ff20b0291eb5711a449de262d3feNick Lewycky 435080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedmanstatic void EraseTerminatorInstAndDCECond(TerminatorInst *TI) { 4369d5231022283ff20b0291eb5711a449de262d3feNick Lewycky Instruction *Cond = 0; 437080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { 438080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman Cond = dyn_cast<Instruction>(SI->getCondition()); 439080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman } else if (BranchInst *BI = dyn_cast<BranchInst>(TI)) { 440080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman if (BI->isConditional()) 441080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman Cond = dyn_cast<Instruction>(BI->getCondition()); 4427ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel } else if (IndirectBrInst *IBI = dyn_cast<IndirectBrInst>(TI)) { 4437ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel Cond = dyn_cast<Instruction>(IBI->getAddress()); 444080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman } 445080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman 446080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman TI->eraseFromParent(); 447080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman if (Cond) RecursivelyDeleteTriviallyDeadInstructions(Cond); 448080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman} 449080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman 4509fd4955c6ab9a191dec2d5afd4b2027d4b906f2eChris Lattner/// isValueEqualityComparison - Return true if the specified terminator checks 4519fd4955c6ab9a191dec2d5afd4b2027d4b906f2eChris Lattner/// to see if a value is equal to constant integer value. 45258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund OlesenValue *SimplifyCFGOpt::isValueEqualityComparison(TerminatorInst *TI) { 45358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen Value *CV = 0; 4544bebf08d152d84970d250feec72fb734cb8a5316Chris Lattner if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { 4554bebf08d152d84970d250feec72fb734cb8a5316Chris Lattner // Do not permit merging of large switch instructions into their 4564bebf08d152d84970d250feec72fb734cb8a5316Chris Lattner // predecessors unless there is only one predecessor. 45758e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen if (SI->getNumSuccessors()*std::distance(pred_begin(SI->getParent()), 45858e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen pred_end(SI->getParent())) <= 128) 45958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen CV = SI->getCondition(); 46058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen } else if (BranchInst *BI = dyn_cast<BranchInst>(TI)) 461542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (BI->isConditional() && BI->getCondition()->hasOneUse()) 462e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (ICmpInst *ICI = dyn_cast<ICmpInst>(BI->getCondition())) 463e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if ((ICI->getPredicate() == ICmpInst::ICMP_EQ || 464e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ICI->getPredicate() == ICmpInst::ICMP_NE) && 46528acc135481691771205dea7cb4edbd3927aa764Chris Lattner GetConstantInt(ICI->getOperand(1), TD)) 46658e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen CV = ICI->getOperand(0); 46758e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 46858e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen // Unwrap any lossless ptrtoint cast. 46958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen if (TD && CV && CV->getType() == TD->getIntPtrType(CV->getContext())) 47058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen if (PtrToIntInst *PTII = dyn_cast<PtrToIntInst>(CV)) 47158e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen CV = PTII->getOperand(0); 47258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen return CV; 473542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner} 474542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 4755049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// GetValueEqualityComparisonCases - Given a value comparison instruction, 4765049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// decode all of the 'cases' that it represents and return the 'default' block. 47758e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund OlesenBasicBlock *SimplifyCFGOpt:: 478fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha BrukmanGetValueEqualityComparisonCases(TerminatorInst *TI, 479542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner std::vector<std::pair<ConstantInt*, 480542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner BasicBlock*> > &Cases) { 481542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { 482542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner Cases.reserve(SI->getNumCases()); 4833d3abe0852d5f499bed7ab014519dd582a0a795dStepan Dyatkovskiy for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end(); i != e; ++i) 484c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy Cases.push_back(std::make_pair(i.getCaseValue(), 485c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy i.getCaseSuccessor())); 486542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner return SI->getDefaultDest(); 487542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 488542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 489542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner BranchInst *BI = cast<BranchInst>(TI); 490e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ICmpInst *ICI = cast<ICmpInst>(BI->getCondition()); 49128acc135481691771205dea7cb4edbd3927aa764Chris Lattner Cases.push_back(std::make_pair(GetConstantInt(ICI->getOperand(1), TD), 492e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer BI->getSuccessor(ICI->getPredicate() == 493e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ICmpInst::ICMP_NE))); 494e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_EQ); 495542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner} 496542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 497542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 4985049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// EliminateBlockCases - Given a vector of bb/value pairs, remove any entries 4995049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// in the list that match the specified block. 500fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanstatic void EliminateBlockCases(BasicBlock *BB, 501623369ac5669a3667a94a3cbba342dea78845615Chris Lattner std::vector<std::pair<ConstantInt*, BasicBlock*> > &Cases) { 502623369ac5669a3667a94a3cbba342dea78845615Chris Lattner for (unsigned i = 0, e = Cases.size(); i != e; ++i) 503623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if (Cases[i].second == BB) { 504623369ac5669a3667a94a3cbba342dea78845615Chris Lattner Cases.erase(Cases.begin()+i); 505623369ac5669a3667a94a3cbba342dea78845615Chris Lattner --i; --e; 506623369ac5669a3667a94a3cbba342dea78845615Chris Lattner } 507623369ac5669a3667a94a3cbba342dea78845615Chris Lattner} 508623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 5095049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// ValuesOverlap - Return true if there are any keys in C1 that exist in C2 as 5105049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// well. 511623369ac5669a3667a94a3cbba342dea78845615Chris Lattnerstatic bool 512623369ac5669a3667a94a3cbba342dea78845615Chris LattnerValuesOverlap(std::vector<std::pair<ConstantInt*, BasicBlock*> > &C1, 513623369ac5669a3667a94a3cbba342dea78845615Chris Lattner std::vector<std::pair<ConstantInt*, BasicBlock*> > &C2) { 514623369ac5669a3667a94a3cbba342dea78845615Chris Lattner std::vector<std::pair<ConstantInt*, BasicBlock*> > *V1 = &C1, *V2 = &C2; 515623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 516623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // Make V1 be smaller than V2. 517623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if (V1->size() > V2->size()) 518623369ac5669a3667a94a3cbba342dea78845615Chris Lattner std::swap(V1, V2); 519623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 520623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if (V1->size() == 0) return false; 521623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if (V1->size() == 1) { 522623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // Just scan V2. 523623369ac5669a3667a94a3cbba342dea78845615Chris Lattner ConstantInt *TheVal = (*V1)[0].first; 524623369ac5669a3667a94a3cbba342dea78845615Chris Lattner for (unsigned i = 0, e = V2->size(); i != e; ++i) 525623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if (TheVal == (*V2)[i].first) 526623369ac5669a3667a94a3cbba342dea78845615Chris Lattner return true; 527623369ac5669a3667a94a3cbba342dea78845615Chris Lattner } 528623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 529623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // Otherwise, just sort both lists and compare element by element. 530fca20f507ccfd3407511cd1ccb94ab4421388107Chris Lattner array_pod_sort(V1->begin(), V1->end()); 531fca20f507ccfd3407511cd1ccb94ab4421388107Chris Lattner array_pod_sort(V2->begin(), V2->end()); 532623369ac5669a3667a94a3cbba342dea78845615Chris Lattner unsigned i1 = 0, i2 = 0, e1 = V1->size(), e2 = V2->size(); 533623369ac5669a3667a94a3cbba342dea78845615Chris Lattner while (i1 != e1 && i2 != e2) { 534623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if ((*V1)[i1].first == (*V2)[i2].first) 535623369ac5669a3667a94a3cbba342dea78845615Chris Lattner return true; 536623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if ((*V1)[i1].first < (*V2)[i2].first) 537623369ac5669a3667a94a3cbba342dea78845615Chris Lattner ++i1; 538623369ac5669a3667a94a3cbba342dea78845615Chris Lattner else 539623369ac5669a3667a94a3cbba342dea78845615Chris Lattner ++i2; 540623369ac5669a3667a94a3cbba342dea78845615Chris Lattner } 541623369ac5669a3667a94a3cbba342dea78845615Chris Lattner return false; 542623369ac5669a3667a94a3cbba342dea78845615Chris Lattner} 543623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 5445049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// SimplifyEqualityComparisonWithOnlyPredecessor - If TI is known to be a 5455049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// terminator instruction and its block is known to only have a single 5465049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// predecessor block, check to see if that predecessor is also a value 5475049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// comparison with the same value, and if that comparison determines the 5485049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// outcome of this comparison. If so, simplify TI. This does a very limited 5495049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// form of jump threading. 55058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesenbool SimplifyCFGOpt:: 55158e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund OlesenSimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI, 552007349dafda47296177fd7481aff9764d4179f42Devang Patel BasicBlock *Pred, 553007349dafda47296177fd7481aff9764d4179f42Devang Patel IRBuilder<> &Builder) { 554623369ac5669a3667a94a3cbba342dea78845615Chris Lattner Value *PredVal = isValueEqualityComparison(Pred->getTerminator()); 555623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if (!PredVal) return false; // Not a value comparison in predecessor. 556623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 557623369ac5669a3667a94a3cbba342dea78845615Chris Lattner Value *ThisVal = isValueEqualityComparison(TI); 558623369ac5669a3667a94a3cbba342dea78845615Chris Lattner assert(ThisVal && "This isn't a value comparison!!"); 559623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if (ThisVal != PredVal) return false; // Different predicates. 560623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 561623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // Find out information about when control will move from Pred to TI's block. 562623369ac5669a3667a94a3cbba342dea78845615Chris Lattner std::vector<std::pair<ConstantInt*, BasicBlock*> > PredCases; 563623369ac5669a3667a94a3cbba342dea78845615Chris Lattner BasicBlock *PredDef = GetValueEqualityComparisonCases(Pred->getTerminator(), 564623369ac5669a3667a94a3cbba342dea78845615Chris Lattner PredCases); 565623369ac5669a3667a94a3cbba342dea78845615Chris Lattner EliminateBlockCases(PredDef, PredCases); // Remove default from cases. 566fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 567623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // Find information about how control leaves this block. 568623369ac5669a3667a94a3cbba342dea78845615Chris Lattner std::vector<std::pair<ConstantInt*, BasicBlock*> > ThisCases; 569623369ac5669a3667a94a3cbba342dea78845615Chris Lattner BasicBlock *ThisDef = GetValueEqualityComparisonCases(TI, ThisCases); 570623369ac5669a3667a94a3cbba342dea78845615Chris Lattner EliminateBlockCases(ThisDef, ThisCases); // Remove default from cases. 571623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 572623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // If TI's block is the default block from Pred's comparison, potentially 573623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // simplify TI based on this knowledge. 574623369ac5669a3667a94a3cbba342dea78845615Chris Lattner if (PredDef == TI->getParent()) { 575623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // If we are here, we know that the value is none of those cases listed in 576623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // PredCases. If there are any cases in ThisCases that are in PredCases, we 577623369ac5669a3667a94a3cbba342dea78845615Chris Lattner // can simplify TI. 5789a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (!ValuesOverlap(PredCases, ThisCases)) 5799a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner return false; 5809a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 5819a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (isa<BranchInst>(TI)) { 5829a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Okay, one of the successors of this condbr is dead. Convert it to a 5839a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // uncond br. 5849a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner assert(ThisCases.size() == 1 && "Branch can only have one case!"); 5859a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Insert the new branch. 586007349dafda47296177fd7481aff9764d4179f42Devang Patel Instruction *NI = Builder.CreateBr(ThisDef); 5879a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner (void) NI; 588623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 5899a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Remove PHI node entries for the dead edge. 5909a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner ThisCases[0].second->removePredecessor(TI->getParent()); 591623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 5929a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator() 5939a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner << "Through successor TI: " << *TI << "Leaving: " << *NI << "\n"); 594623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 5959a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner EraseTerminatorInstAndDCECond(TI); 5969a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner return true; 597623369ac5669a3667a94a3cbba342dea78845615Chris Lattner } 5989a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 5999a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner SwitchInst *SI = cast<SwitchInst>(TI); 6009a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Okay, TI has cases that are statically dead, prune them away. 6019a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner SmallPtrSet<Constant*, 16> DeadCases; 602623369ac5669a3667a94a3cbba342dea78845615Chris Lattner for (unsigned i = 0, e = PredCases.size(); i != e; ++i) 6039a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner DeadCases.insert(PredCases[i].first); 6049a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 6059a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator() 6069a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner << "Through successor TI: " << *TI); 6079a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 6083d3abe0852d5f499bed7ab014519dd582a0a795dStepan Dyatkovskiy for (SwitchInst::CaseIt i = SI->case_end(), e = SI->case_begin(); i != e;) { 60924473120a253a05f3601cd3373403b47e6d03d41Stepan Dyatkovskiy --i; 610c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy if (DeadCases.count(i.getCaseValue())) { 611c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy i.getCaseSuccessor()->removePredecessor(TI->getParent()); 6129a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner SI->removeCase(i); 613623369ac5669a3667a94a3cbba342dea78845615Chris Lattner } 61424473120a253a05f3601cd3373403b47e6d03d41Stepan Dyatkovskiy } 615623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 6169a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner DEBUG(dbgs() << "Leaving: " << *TI << "\n"); 6179a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner return true; 6189a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner } 6199a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 6209a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Otherwise, TI's block must correspond to some matched value. Find out 6219a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // which value (or set of values) this is. 6229a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner ConstantInt *TIV = 0; 6239a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BasicBlock *TIBB = TI->getParent(); 6249a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner for (unsigned i = 0, e = PredCases.size(); i != e; ++i) 6259a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (PredCases[i].second == TIBB) { 6269a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (TIV != 0) 6279a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner return false; // Cannot handle multiple values coming to this block. 6289a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner TIV = PredCases[i].first; 6299a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner } 6309a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner assert(TIV && "No edge from pred to succ?"); 6319a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 6329a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Okay, we found the one constant that our value can be if we get into TI's 6339a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // BB. Find out which successor will unconditionally be branched to. 6349a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BasicBlock *TheRealDest = 0; 6359a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner for (unsigned i = 0, e = ThisCases.size(); i != e; ++i) 6369a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (ThisCases[i].first == TIV) { 6379a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner TheRealDest = ThisCases[i].second; 6389a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner break; 6399a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner } 6409a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 6419a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // If not handled by any explicit cases, it is handled by the default case. 6429a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (TheRealDest == 0) TheRealDest = ThisDef; 643623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 6449a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Remove PHI node entries for dead edges. 6459a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BasicBlock *CheckEdge = TheRealDest; 6469a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner for (succ_iterator SI = succ_begin(TIBB), e = succ_end(TIBB); SI != e; ++SI) 6479a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (*SI != CheckEdge) 6489a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner (*SI)->removePredecessor(TIBB); 6499a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner else 6509a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner CheckEdge = 0; 651623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 6529a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Insert the new branch. 653007349dafda47296177fd7481aff9764d4179f42Devang Patel Instruction *NI = Builder.CreateBr(TheRealDest); 6549a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner (void) NI; 655623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 6569a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator() 6579a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner << "Through successor TI: " << *TI << "Leaving: " << *NI << "\n"); 658623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 6599a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner EraseTerminatorInstAndDCECond(TI); 6609a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner return true; 661623369ac5669a3667a94a3cbba342dea78845615Chris Lattner} 662623369ac5669a3667a94a3cbba342dea78845615Chris Lattner 663c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesennamespace { 664c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen /// ConstantIntOrdering - This class implements a stable ordering of constant 665c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen /// integers that does not depend on their address. This is important for 666c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen /// applications that sort ConstantInt's to ensure uniqueness. 667c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen struct ConstantIntOrdering { 668c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen bool operator()(const ConstantInt *LHS, const ConstantInt *RHS) const { 669c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen return LHS->getValue().ult(RHS->getValue()); 670c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen } 671c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen }; 672c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen} 673a9537cf3fcf9fdaac94749db9fbd34912b1f0f08Dale Johannesen 6746d4d21e29d4840236ab6f15c5247379820021d0cChris Lattnerstatic int ConstantIntSortPredicate(const void *P1, const void *P2) { 6756d4d21e29d4840236ab6f15c5247379820021d0cChris Lattner const ConstantInt *LHS = *(const ConstantInt**)P1; 6766d4d21e29d4840236ab6f15c5247379820021d0cChris Lattner const ConstantInt *RHS = *(const ConstantInt**)P2; 677ba3c8155704e5e2ac24b5069c32bca359b0738edChris Lattner if (LHS->getValue().ult(RHS->getValue())) 678ba3c8155704e5e2ac24b5069c32bca359b0738edChris Lattner return 1; 679ba3c8155704e5e2ac24b5069c32bca359b0738edChris Lattner if (LHS->getValue() == RHS->getValue()) 680ba3c8155704e5e2ac24b5069c32bca359b0738edChris Lattner return 0; 681ba3c8155704e5e2ac24b5069c32bca359b0738edChris Lattner return -1; 6826d4d21e29d4840236ab6f15c5247379820021d0cChris Lattner} 6836d4d21e29d4840236ab6f15c5247379820021d0cChris Lattner 6845049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// FoldValueComparisonIntoPredecessors - The specified terminator is a value 6855049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// equality comparison instruction (either a switch or a branch on "X == c"). 6865049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// See if any of the predecessors of the terminator block are value comparisons 6875049fa6bbc66534fe0cc361808dff80fd2d5cde2Bill Wendling/// on the same value. If so, and if safe to do so, fold them together. 688b55d924b1e33341d08b1bead78e86fce56617784Devang Patelbool SimplifyCFGOpt::FoldValueComparisonIntoPredecessors(TerminatorInst *TI, 689b55d924b1e33341d08b1bead78e86fce56617784Devang Patel IRBuilder<> &Builder) { 690542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner BasicBlock *BB = TI->getParent(); 691542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner Value *CV = isValueEqualityComparison(TI); // CondVal 692542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner assert(CV && "Not a comparison?"); 693542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner bool Changed = false; 694542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 6958244243a31d636ce8838a81d4c402274fd391d2bChris Lattner SmallVector<BasicBlock*, 16> Preds(pred_begin(BB), pred_end(BB)); 696542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner while (!Preds.empty()) { 697e9d87f49063cb1bd213d8e9c339b9b63393cc2d9Dan Gohman BasicBlock *Pred = Preds.pop_back_val(); 698fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 699542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // See if the predecessor is a comparison with the same value. 700542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner TerminatorInst *PTI = Pred->getTerminator(); 701542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner Value *PCV = isValueEqualityComparison(PTI); // PredCondVal 702542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 703542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (PCV == CV && SafeToMergeTerminators(TI, PTI)) { 704542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // Figure out which 'cases' to copy from SI to PSI. 705542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner std::vector<std::pair<ConstantInt*, BasicBlock*> > BBCases; 706542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner BasicBlock *BBDefault = GetValueEqualityComparisonCases(TI, BBCases); 707542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 708542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner std::vector<std::pair<ConstantInt*, BasicBlock*> > PredCases; 709542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner BasicBlock *PredDefault = GetValueEqualityComparisonCases(PTI, PredCases); 710542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 711542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // Based on whether the default edge from PTI goes to BB or not, fill in 712542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // PredCases and PredDefault with the new switch cases we would like to 713542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // build. 7148244243a31d636ce8838a81d4c402274fd391d2bChris Lattner SmallVector<BasicBlock*, 8> NewSuccessors; 715542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 716542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (PredDefault == BB) { 717542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // If this is the default destination from PTI, only the edges in TI 718542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // that don't occur in PTI, or that branch to BB will be activated. 719c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen std::set<ConstantInt*, ConstantIntOrdering> PTIHandled; 720542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner for (unsigned i = 0, e = PredCases.size(); i != e; ++i) 721542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (PredCases[i].second != BB) 722542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PTIHandled.insert(PredCases[i].first); 723542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner else { 724542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // The default destination is BB, we don't need explicit targets. 725542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner std::swap(PredCases[i], PredCases.back()); 726542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PredCases.pop_back(); 727542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner --i; --e; 728542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 729542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 730542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // Reconstruct the new switch statement we will be building. 731542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (PredDefault != BBDefault) { 732542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PredDefault->removePredecessor(Pred); 733542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PredDefault = BBDefault; 734542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner NewSuccessors.push_back(BBDefault); 735542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 736542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner for (unsigned i = 0, e = BBCases.size(); i != e; ++i) 737542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (!PTIHandled.count(BBCases[i].first) && 738542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner BBCases[i].second != BBDefault) { 739542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PredCases.push_back(BBCases[i]); 740542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner NewSuccessors.push_back(BBCases[i].second); 741542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 742542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 743542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } else { 744542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // If this is not the default destination from PSI, only the edges 745542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // in SI that occur in PSI with a destination of BB will be 746542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // activated. 747c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen std::set<ConstantInt*, ConstantIntOrdering> PTIHandled; 748542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner for (unsigned i = 0, e = PredCases.size(); i != e; ++i) 749542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (PredCases[i].second == BB) { 750542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PTIHandled.insert(PredCases[i].first); 751542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner std::swap(PredCases[i], PredCases.back()); 752542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PredCases.pop_back(); 753542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner --i; --e; 754542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 755542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 756542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // Okay, now we know which constants were sent to BB from the 757542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // predecessor. Figure out where they will all go now. 758542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner for (unsigned i = 0, e = BBCases.size(); i != e; ++i) 759542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (PTIHandled.count(BBCases[i].first)) { 760542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // If this is one we are capable of getting... 761542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PredCases.push_back(BBCases[i]); 762542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner NewSuccessors.push_back(BBCases[i].second); 763542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PTIHandled.erase(BBCases[i].first);// This constant is taken care of 764542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 765542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 766542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // If there are any constants vectored to BB that TI doesn't handle, 767542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // they must go to the default destination of TI. 768c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen for (std::set<ConstantInt*, ConstantIntOrdering>::iterator I = 769c81f5445a7cbe3ba0252aec030082a40e5019eceDale Johannesen PTIHandled.begin(), 770542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner E = PTIHandled.end(); I != E; ++I) { 771542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner PredCases.push_back(std::make_pair(*I, BBDefault)); 772542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner NewSuccessors.push_back(BBDefault); 773542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 774542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 775542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 776542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // Okay, at this point, we know which new successor Pred will get. Make 777542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // sure we update the number of entries in the PHI nodes for these 778542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // successors. 779542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner for (unsigned i = 0, e = NewSuccessors.size(); i != e; ++i) 780542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner AddPredecessorToBlock(NewSuccessors[i], Pred, BB); 781542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 782b55d924b1e33341d08b1bead78e86fce56617784Devang Patel Builder.SetInsertPoint(PTI); 78358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen // Convert pointer to int before we switch. 7841df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (CV->getType()->isPointerTy()) { 78558e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen assert(TD && "Cannot switch on pointer without TargetData"); 786b55d924b1e33341d08b1bead78e86fce56617784Devang Patel CV = Builder.CreatePtrToInt(CV, TD->getIntPtrType(CV->getContext()), 787b55d924b1e33341d08b1bead78e86fce56617784Devang Patel "magicptr"); 78858e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen } 78958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 790542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // Now that the successors are updated, create the new Switch instruction. 791b55d924b1e33341d08b1bead78e86fce56617784Devang Patel SwitchInst *NewSI = Builder.CreateSwitch(CV, PredDefault, 792b55d924b1e33341d08b1bead78e86fce56617784Devang Patel PredCases.size()); 793d80e8ed2fa20c7ad51af49c3b2650525edbdcd08Devang Patel NewSI->setDebugLoc(PTI->getDebugLoc()); 794542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner for (unsigned i = 0, e = PredCases.size(); i != e; ++i) 795542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner NewSI->addCase(PredCases[i].first, PredCases[i].second); 79613b2f764c041e15af3d6033826deb9c7e669ca97Chris Lattner 797080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman EraseTerminatorInstAndDCECond(PTI); 79813b2f764c041e15af3d6033826deb9c7e669ca97Chris Lattner 799542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // Okay, last check. If BB is still a successor of PSI, then we must 800542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // have an infinite loop case. If so, add an infinitely looping block 801542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // to handle the case to preserve the behavior of the code. 802542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner BasicBlock *InfLoopBlock = 0; 803542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner for (unsigned i = 0, e = NewSI->getNumSuccessors(); i != e; ++i) 804542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (NewSI->getSuccessor(i) == BB) { 805542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner if (InfLoopBlock == 0) { 806093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // Insert it at the end of the function, because it's either code, 807542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner // or it won't matter if it's hot. :) 8081d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson InfLoopBlock = BasicBlock::Create(BB->getContext(), 8091d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson "infloop", BB->getParent()); 810051a950000e21935165db56695e35bade668193bGabor Greif BranchInst::Create(InfLoopBlock, InfLoopBlock); 811542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 812542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner NewSI->setSuccessor(i, InfLoopBlock); 813542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 814fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 815542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner Changed = true; 816542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 817542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner } 818542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner return Changed; 819542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner} 820542f149f00afaf1125b8f2040cad4fe05ed24c3aChris Lattner 821c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen// isSafeToHoistInvoke - If we would need to insert a select that uses the 822c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen// value of this invoke (comments in HoistThenElseCodeToIf explain why we 823c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen// would need to do this), we can't hoist the invoke, as there is nowhere 824c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen// to put the select in this case. 825c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesenstatic bool isSafeToHoistInvoke(BasicBlock *BB1, BasicBlock *BB2, 826c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen Instruction *I1, Instruction *I2) { 827c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) { 828c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen PHINode *PN; 829c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen for (BasicBlock::iterator BBI = SI->begin(); 830c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen (PN = dyn_cast<PHINode>(BBI)); ++BBI) { 831c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen Value *BB1V = PN->getIncomingValueForBlock(BB1); 832c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen Value *BB2V = PN->getIncomingValueForBlock(BB2); 833c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen if (BB1V != BB2V && (BB1V==I1 || BB2V==I2)) { 834c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen return false; 835c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen } 836c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen } 837c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen } 838c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen return true; 839c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen} 840c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen 8416306d07aa8cf71e3c7fed7f295665f53595473ebChris Lattner/// HoistThenElseCodeToIf - Given a conditional branch that goes to BB1 and 84237dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner/// BB2, hoist any common code in the two blocks up into the branch block. The 84337dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner/// caller of this function guarantees that BI's block dominates BB1 and BB2. 844216dde91d1def3e08002d6251e11f3dfa5cb3656Rafael Espindolastatic bool HoistThenElseCodeToIf(BranchInst *BI) { 84537dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // This does very trivial matching, with limited scanning, to find identical 84637dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // instructions in the two blocks. In particular, we don't want to get into 84737dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // O(M*N) situations here where M and N are the sizes of BB1 and BB2. As 84837dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // such, we currently just scan for obviously identical instructions in an 84937dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // identical order. 85037dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner BasicBlock *BB1 = BI->getSuccessor(0); // The true destination. 85137dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner BasicBlock *BB2 = BI->getSuccessor(1); // The false destination 85237dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner 85365085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel BasicBlock::iterator BB1_Itr = BB1->begin(); 85465085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel BasicBlock::iterator BB2_Itr = BB2->begin(); 85565085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel 85665085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel Instruction *I1 = BB1_Itr++, *I2 = BB2_Itr++; 857949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel // Skip debug info if it is not identical. 858949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel DbgInfoIntrinsic *DBI1 = dyn_cast<DbgInfoIntrinsic>(I1); 859949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel DbgInfoIntrinsic *DBI2 = dyn_cast<DbgInfoIntrinsic>(I2); 860949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel if (!DBI1 || !DBI2 || !DBI1->isIdenticalToWhenDefined(DBI2)) { 861949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel while (isa<DbgInfoIntrinsic>(I1)) 862949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel I1 = BB1_Itr++; 863949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel while (isa<DbgInfoIntrinsic>(I2)) 864949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel I2 = BB2_Itr++; 865949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel } 866ae6c95b58e78403707fb75e78f0959a86d57b0c5Devang Patel if (isa<PHINode>(I1) || !I1->isIdenticalToWhenDefined(I2) || 867c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen (isa<InvokeInst>(I1) && !isSafeToHoistInvoke(BB1, BB2, I1, I2))) 86837dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner return false; 86937dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner 87037dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // If we get here, we can hoist at least one instruction. 87137dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner BasicBlock *BIParent = BI->getParent(); 87237dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner 87337dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner do { 87437dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // If we are hoisting the terminator instruction, don't move one (making a 87537dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // broken BB), instead clone it, and remove BI. 87637dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner if (isa<TerminatorInst>(I1)) 87737dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner goto HoistTerminator; 878fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 87937dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // For a normal instruction, we just move one to right before the branch, 88037dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // then replace all uses of the other with the first. Finally, we remove 88137dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // the now redundant second instruction. 88237dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner BIParent->getInstList().splice(BI, BB1->getInstList(), I1); 88337dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner if (!I2->use_empty()) 88437dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner I2->replaceAllUsesWith(I1); 88558cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohman I1->intersectOptionalDataWith(I2); 886302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner I2->eraseFromParent(); 887fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 88865085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel I1 = BB1_Itr++; 88965085cf7b3470b7b087f5fd7b0497879b90b32baDevang Patel I2 = BB2_Itr++; 890949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel // Skip debug info if it is not identical. 891949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel DbgInfoIntrinsic *DBI1 = dyn_cast<DbgInfoIntrinsic>(I1); 892949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel DbgInfoIntrinsic *DBI2 = dyn_cast<DbgInfoIntrinsic>(I2); 893949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel if (!DBI1 || !DBI2 || !DBI1->isIdenticalToWhenDefined(DBI2)) { 894949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel while (isa<DbgInfoIntrinsic>(I1)) 895949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel I1 = BB1_Itr++; 896949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel while (isa<DbgInfoIntrinsic>(I2)) 897949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel I2 = BB2_Itr++; 898949666ea16214e1b7e79fc8e653b06ad8b93dd5aDevang Patel } 899ae6c95b58e78403707fb75e78f0959a86d57b0c5Devang Patel } while (I1->isIdenticalToWhenDefined(I2)); 90037dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner 90137dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner return true; 90237dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner 90337dc938bbe556a9414d063196d367c2f75d07d95Chris LattnerHoistTerminator: 904c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen // It may not be possible to hoist an invoke. 905c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen if (isa<InvokeInst>(I1) && !isSafeToHoistInvoke(BB1, BB2, I1, I2)) 906c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen return true; 907c1f104054dda0b3946abbe3b6859e960b60168f7Dale Johannesen 90837dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // Okay, it is safe to hoist the terminator. 9096776064d190701c5bae4d5403939eed2e480d1cdNick Lewycky Instruction *NT = I1->clone(); 91037dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner BIParent->getInstList().insert(BI, NT); 911f012705c7e4ca8cf90b6b734ce1d5355daca5ba5Benjamin Kramer if (!NT->getType()->isVoidTy()) { 91237dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner I1->replaceAllUsesWith(NT); 91337dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner I2->replaceAllUsesWith(NT); 91486cc42355593dd1689f7d58d56695c451215b02bChris Lattner NT->takeName(I1); 91537dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner } 91637dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner 917d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel IRBuilder<true, NoFolder> Builder(NT); 91837dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // Hoisting one of the terminators from our successor is a great thing. 91937dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // Unfortunately, the successors of the if/else blocks may have PHI nodes in 92037dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // them. If they do, all PHI entries for BB1/BB2 must agree for all PHI 92137dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // nodes, so we insert select instruction to compute the final result. 92237dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner std::map<std::pair<Value*,Value*>, SelectInst*> InsertedSelects; 92337dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) { 92437dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner PHINode *PN; 92537dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner for (BasicBlock::iterator BBI = SI->begin(); 9260f535c6fa8b03491dc110feb65d78922ee29d1fcChris Lattner (PN = dyn_cast<PHINode>(BBI)); ++BBI) { 92737dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner Value *BB1V = PN->getIncomingValueForBlock(BB1); 92837dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner Value *BB2V = PN->getIncomingValueForBlock(BB2); 9299a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (BB1V == BB2V) continue; 9309a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 9319a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // These values do not agree. Insert a select instruction before NT 9329a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // that determines the right value. 9339a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner SelectInst *&SI = InsertedSelects[std::make_pair(BB1V, BB2V)]; 934d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel if (SI == 0) 935d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel SI = cast<SelectInst> 936d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel (Builder.CreateSelect(BI->getCondition(), BB1V, BB2V, 937d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel BB1V->getName()+"."+BB2V->getName())); 938d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel 9399a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Make the PHI node use the select for all incoming values for BB1/BB2 9409a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 9419a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (PN->getIncomingBlock(i) == BB1 || PN->getIncomingBlock(i) == BB2) 9429a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner PN->setIncomingValue(i, SI); 94337dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner } 94437dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner } 94537dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner 94637dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner // Update any PHI nodes in our new successors. 94737dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) 94837dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner AddPredecessorToBlock(*SI, BIParent, BB1); 949fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 950080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman EraseTerminatorInstAndDCECond(BI); 95137dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner return true; 95237dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner} 95337dc938bbe556a9414d063196d367c2f75d07d95Chris Lattner 9544d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng/// SpeculativelyExecuteBB - Given a conditional branch that goes to BB1 9554d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng/// and an BB2 and the only successor of BB1 is BB2, hoist simple code 9564d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng/// (for now, restricted to a single instruction that's side effect free) from 9574d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng/// the BB1 into the branch block to speculatively execute it. 9583b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// 9593b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// Turn 9603b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// BB: 9613b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// %t1 = icmp 9623b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// br i1 %t1, label %BB1, label %BB2 9633b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// BB1: 9643b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// %t3 = add %t2, c 9653b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// br label BB2 9663b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// BB2: 9673b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// => 9683b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// BB: 9693b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// %t1 = icmp 9703b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// %t4 = add %t2, c 9713b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman/// %t3 = select i1 %t1, %t2, %t3 972216dde91d1def3e08002d6251e11f3dfa5cb3656Rafael Espindolastatic bool SpeculativelyExecuteBB(BranchInst *BI, BasicBlock *BB1) { 9734d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // Only speculatively execution a single instruction (not counting the 9744d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // terminator) for now. 97506b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel Instruction *HInst = NULL; 97606b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel Instruction *Term = BB1->getTerminator(); 97706b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel for (BasicBlock::iterator BBI = BB1->begin(), BBE = BB1->end(); 97806b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel BBI != BBE; ++BBI) { 97906b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel Instruction *I = BBI; 98006b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel // Skip debug info. 9819a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (isa<DbgInfoIntrinsic>(I)) continue; 9829a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (I == Term) break; 98306b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel 9849a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (HInst) 98506b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel return false; 9869a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner HInst = I; 98706b1e67d44a6c13f9e75fbc1ac3c7de2df4776c9Devang Patel } 9883b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman 9893b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman BasicBlock *BIParent = BI->getParent(); 9903b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman 9913b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // Check the instruction to be hoisted, if there is one. 9923b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman if (HInst) { 9933b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // Don't hoist the instruction if it's unsafe or expensive. 9943b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman if (!isSafeToSpeculativelyExecute(HInst)) 9953b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman return false; 9963b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman if (ComputeSpeculationCost(HInst) > PHINodeFoldingThreshold) 9973b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman return false; 9983b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman 9993b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // Do not hoist the instruction if any of its operands are defined but not 10003b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // used in this BB. The transformation will prevent the operand from 10013b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // being sunk into the use block. 10023b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman for (User::op_iterator i = HInst->op_begin(), e = HInst->op_end(); 10033b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman i != e; ++i) { 10043b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman Instruction *OpI = dyn_cast<Instruction>(*i); 10053b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman if (OpI && OpI->getParent() == BIParent && 10063b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman !OpI->mayHaveSideEffects() && 10073b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman !OpI->isUsedInBasicBlock(BIParent)) 10083b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman return false; 10093b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman } 10103b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman } 10114d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng 1012797d95188d00963a835db9ad66dd3c4a54aa2fafEvan Cheng // Be conservative for now. FP select instruction can often be expensive. 1013797d95188d00963a835db9ad66dd3c4a54aa2fafEvan Cheng Value *BrCond = BI->getCondition(); 10149a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (isa<FCmpInst>(BrCond)) 1015797d95188d00963a835db9ad66dd3c4a54aa2fafEvan Cheng return false; 1016797d95188d00963a835db9ad66dd3c4a54aa2fafEvan Cheng 10174d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // If BB1 is actually on the false edge of the conditional branch, remember 10184d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng // to swap the select operands later. 10194d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng bool Invert = false; 10204d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng if (BB1 != BI->getSuccessor(0)) { 10214d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng assert(BB1 == BI->getSuccessor(1) && "No edge from 'if' block?"); 10224d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng Invert = true; 10234d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng } 10244d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng 10253b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // Collect interesting PHIs, and scan for hazards. 10263b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman SmallSetVector<std::pair<Value *, Value *>, 4> PHIs; 10273b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman BasicBlock *BB2 = BB1->getTerminator()->getSuccessor(0); 10283b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman for (BasicBlock::iterator I = BB2->begin(); 10293b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman PHINode *PN = dyn_cast<PHINode>(I); ++I) { 10303b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman Value *BB1V = PN->getIncomingValueForBlock(BB1); 10313b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman Value *BIParentV = PN->getIncomingValueForBlock(BIParent); 10323b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman 10333b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // Skip PHIs which are trivial. 10343b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman if (BB1V == BIParentV) 10353b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman continue; 10363b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman 10373b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // Check for saftey. 10383b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman if (ConstantExpr *CE = dyn_cast<ConstantExpr>(BB1V)) { 10393b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // An unfolded ConstantExpr could end up getting expanded into 10403b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // Instructions. Don't speculate this and another instruction at 10413b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // the same time. 10423b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman if (HInst) 10433b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman return false; 10443b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman if (!isSafeToSpeculativelyExecute(CE)) 10453b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman return false; 10463b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman if (ComputeSpeculationCost(CE) > PHINodeFoldingThreshold) 10473b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman return false; 10483b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman } 10493b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman 10503b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // Ok, we may insert a select for this PHI. 10513b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman PHIs.insert(std::make_pair(BB1V, BIParentV)); 10526fe73bbcf3b6c1ddfd5e70e8b5188f8df439ace6Chris Lattner } 10534d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng 10543b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // If there are no PHIs to process, bail early. This helps ensure idempotence 10553b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // as well. 10563b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman if (PHIs.empty()) 10573b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman return false; 10586fe73bbcf3b6c1ddfd5e70e8b5188f8df439ace6Chris Lattner 10593b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // If we get here, we can hoist the instruction and if-convert. 10603b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman DEBUG(dbgs() << "SPECULATIVELY EXECUTING BB" << *BB1 << "\n";); 1061502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng 10623b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // Hoist the instruction. 10633b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman if (HInst) 10643b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman BIParent->getInstList().splice(BI, BB1->getInstList(), HInst); 10654d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng 10663b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // Insert selects and rewrite the PHI operands. 1067d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel IRBuilder<true, NoFolder> Builder(BI); 10683b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman for (unsigned i = 0, e = PHIs.size(); i != e; ++i) { 10693b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman Value *TrueV = PHIs[i].first; 10703b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman Value *FalseV = PHIs[i].second; 10713b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman 10723b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // Create a select whose true value is the speculatively executed value and 10733b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // false value is the previously determined FalseV. 10743b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman SelectInst *SI; 10753b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman if (Invert) 10763b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman SI = cast<SelectInst> 10773b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman (Builder.CreateSelect(BrCond, FalseV, TrueV, 10783b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman FalseV->getName() + "." + TrueV->getName())); 10793b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman else 10803b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman SI = cast<SelectInst> 10813b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman (Builder.CreateSelect(BrCond, TrueV, FalseV, 10823b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman TrueV->getName() + "." + FalseV->getName())); 10833b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman 10843b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // Make the PHI node use the select for all incoming values for "then" and 10853b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // "if" blocks. 10863b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman for (BasicBlock::iterator I = BB2->begin(); 10873b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman PHINode *PN = dyn_cast<PHINode>(I); ++I) { 10883b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman unsigned BB1I = PN->getBasicBlockIndex(BB1); 10893b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman unsigned BIParentI = PN->getBasicBlockIndex(BIParent); 10903b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman Value *BB1V = PN->getIncomingValue(BB1I); 10913b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman Value *BIParentV = PN->getIncomingValue(BIParentI); 10923b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman if (TrueV == BB1V && FalseV == BIParentV) { 10933b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman PN->setIncomingValue(BB1I, SI); 10943b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman PN->setIncomingValue(BIParentI, SI); 10953b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman } 10963b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman } 10974d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng } 10984d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng 1099502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng ++NumSpeculations; 11004d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng return true; 11014d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng} 11024d09efd7b8fdf9e8a8c89bdb821f4992091a764bEvan Cheng 11032e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner/// BlockIsSimpleEnoughToThreadThrough - Return true if we can thread a branch 11042e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner/// across this block. 11052e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattnerstatic bool BlockIsSimpleEnoughToThreadThrough(BasicBlock *BB) { 11062e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner BranchInst *BI = cast<BranchInst>(BB->getTerminator()); 1107e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner unsigned Size = 0; 1108e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner 11099200c89968e52a590ee0b96092a0a589aa138a6fDevang Patel for (BasicBlock::iterator BBI = BB->begin(); &*BBI != BI; ++BBI) { 11108483e54837ede5dd40c5561f15c6a663e2bee87cDale Johannesen if (isa<DbgInfoIntrinsic>(BBI)) 11118483e54837ede5dd40c5561f15c6a663e2bee87cDale Johannesen continue; 1112e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner if (Size > 10) return false; // Don't clone large BB's. 11138483e54837ede5dd40c5561f15c6a663e2bee87cDale Johannesen ++Size; 11142e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner 11158483e54837ede5dd40c5561f15c6a663e2bee87cDale Johannesen // We can only support instructions that do not define values that are 1116e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner // live outside of the current basic block. 1117e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner for (Value::use_iterator UI = BBI->use_begin(), E = BBI->use_end(); 1118e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner UI != E; ++UI) { 1119e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner Instruction *U = cast<Instruction>(*UI); 1120e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner if (U->getParent() != BB || isa<PHINode>(U)) return false; 1121e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner } 11222e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner 11232e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner // Looks ok, continue checking. 11242e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner } 1125e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner 11262e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner return true; 11272e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner} 11282e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner 1129eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner/// FoldCondBranchOnPHI - If we have a conditional branch on a PHI node value 1130eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner/// that is defined in the same block as the branch and if any PHI entries are 1131eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner/// constants, thread edges corresponding to that entry to be branches to their 1132eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner/// ultimate destination. 1133302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattnerstatic bool FoldCondBranchOnPHI(BranchInst *BI, const TargetData *TD) { 1134eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner BasicBlock *BB = BI->getParent(); 1135eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner PHINode *PN = dyn_cast<PHINode>(BI->getCondition()); 11369c88d9816246d260b37cdc689f313c56aec6941eChris Lattner // NOTE: we currently cannot transform this case if the PHI node is used 11379c88d9816246d260b37cdc689f313c56aec6941eChris Lattner // outside of the block. 11382e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner if (!PN || PN->getParent() != BB || !PN->hasOneUse()) 11392e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner return false; 1140eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner 1141eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner // Degenerate case of a single entry PHI. 1142eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner if (PN->getNumIncomingValues() == 1) { 114329874e0dc6c4e55bc384611273343bb358982cc3Chris Lattner FoldSingleEntryPHINodes(PN->getParent()); 1144eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner return true; 1145eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner } 1146eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner 1147eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner // Now we know that this block has multiple preds and two succs. 11482e42e36698d5a34f1952ca3389f1973a6a1166f2Chris Lattner if (!BlockIsSimpleEnoughToThreadThrough(BB)) return false; 1149eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner 1150eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner // Okay, this is a simple enough basic block. See if any phi values are 1151eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner // constants. 11526b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { 11539a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner ConstantInt *CB = dyn_cast<ConstantInt>(PN->getIncomingValue(i)); 11549a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (CB == 0 || !CB->getType()->isIntegerTy(1)) continue; 11559a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 11569a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Okay, we now know that all edges from PredBB should be revectored to 11579a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // branch to RealDest. 11589a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BasicBlock *PredBB = PN->getIncomingBlock(i); 11599a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BasicBlock *RealDest = BI->getSuccessor(!CB->getZExtValue()); 11609a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 11619a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (RealDest == BB) continue; // Skip self loops. 11626a648b8538bb4d4b3e96669ef8cd3a4ce3aedeb8Bill Wendling // Skip if the predecessor's terminator is an indirect branch. 11636a648b8538bb4d4b3e96669ef8cd3a4ce3aedeb8Bill Wendling if (isa<IndirectBrInst>(PredBB->getTerminator())) continue; 11649a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 11659a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // The dest block might have PHI nodes, other predecessors and other 11669a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // difficult cases. Instead of being smart about this, just insert a new 11679a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // block that jumps to the destination block, effectively splitting 11689a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // the edge we are about to create. 11699a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BasicBlock *EdgeBB = BasicBlock::Create(BB->getContext(), 11709a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner RealDest->getName()+".critedge", 11719a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner RealDest->getParent(), RealDest); 11729a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BranchInst::Create(RealDest, EdgeBB); 11736de0a28dfb84095ebd7775f371dd4085cf955076Chris Lattner 11746de0a28dfb84095ebd7775f371dd4085cf955076Chris Lattner // Update PHI nodes. 11756de0a28dfb84095ebd7775f371dd4085cf955076Chris Lattner AddPredecessorToBlock(RealDest, EdgeBB, BB); 11769a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner 11779a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // BB may have instructions that are being threaded over. Clone these 11789a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // instructions into EdgeBB. We know that there will be no uses of the 11799a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // cloned instructions outside of EdgeBB. 11809a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BasicBlock::iterator InsertPt = EdgeBB->begin(); 11819a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner DenseMap<Value*, Value*> TranslateMap; // Track translated values. 11829a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner for (BasicBlock::iterator BBI = BB->begin(); &*BBI != BI; ++BBI) { 11839a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(BBI)) { 11849a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner TranslateMap[PN] = PN->getIncomingValueForBlock(PredBB); 11859a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner continue; 11869a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner } 11879a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Clone the instruction. 11889a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner Instruction *N = BBI->clone(); 11899a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (BBI->hasName()) N->setName(BBI->getName()+".c"); 1190eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner 11919a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Update operands due to translation. 11929a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner for (User::op_iterator i = N->op_begin(), e = N->op_end(); 11939a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner i != e; ++i) { 11949a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner DenseMap<Value*, Value*>::iterator PI = TranslateMap.find(*i); 11959a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (PI != TranslateMap.end()) 11969a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner *i = PI->second; 11979a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner } 1198eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner 11999a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Check for trivial simplification. 1200302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner if (Value *V = SimplifyInstruction(N, TD)) { 1201302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner TranslateMap[BBI] = V; 1202302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner delete N; // Instruction folded away, don't need actual inst 12039a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner } else { 12049a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Insert the new instruction into its new home. 12059a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner EdgeBB->getInstList().insert(InsertPt, N); 12069a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (!BBI->use_empty()) 12079a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner TranslateMap[BBI] = N; 1208e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner } 12099a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner } 1210e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner 12119a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Loop over all of the edges from PredBB to BB, changing them to branch 12129a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // to EdgeBB instead. 12139a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner TerminatorInst *PredBBTI = PredBB->getTerminator(); 12149a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner for (unsigned i = 0, e = PredBBTI->getNumSuccessors(); i != e; ++i) 12159a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (PredBBTI->getSuccessor(i) == BB) { 12169a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner BB->removePredecessor(PredBB); 12179a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner PredBBTI->setSuccessor(i, EdgeBB); 1218e9487f0dc8c6d15cb257d5b49fa96ed436d32f5fChris Lattner } 12196a648b8538bb4d4b3e96669ef8cd3a4ce3aedeb8Bill Wendling 12209a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner // Recurse, simplifying any other constants. 1221302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner return FoldCondBranchOnPHI(BI, TD) | true; 12226b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng } 1223eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner 1224eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner return false; 1225eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner} 1226eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner 1227f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner/// FoldTwoEntryPHINode - Given a BB that starts with the specified two-entry 1228f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner/// PHI node, see if we can eliminate it. 1229d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patelstatic bool FoldTwoEntryPHINode(PHINode *PN, const TargetData *TD) { 1230f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // Ok, this is a two entry PHI node. Check to see if this is a simple "if 1231f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // statement", which has a very simple dominance structure. Basically, we 1232f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // are trying to find the condition that is being branched on, which 1233f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // subsequently causes this merge to happen. We really want control 1234f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // dependence information for this check, but simplifycfg can't keep it up 1235f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // to date, and this catches most of the cases we care about anyway. 1236f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner BasicBlock *BB = PN->getParent(); 1237f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner BasicBlock *IfTrue, *IfFalse; 1238f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner Value *IfCond = GetIfCondition(BB, IfTrue, IfFalse); 123960d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner if (!IfCond || 124060d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner // Don't bother if the branch will be constant folded trivially. 124160d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner isa<ConstantInt>(IfCond)) 124260d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner return false; 1243f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner 1244822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner // Okay, we found that we can merge this two-entry phi node into a select. 1245822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner // Doing so would require us to fold *all* two entry phi nodes in this block. 1246822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner // At some point this becomes non-profitable (particularly if the target 1247822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner // doesn't support cmov's). Only do this transformation if there are two or 1248822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner // fewer PHI nodes in this block. 1249822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner unsigned NumPhis = 0; 1250822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner for (BasicBlock::iterator I = BB->begin(); isa<PHINode>(I); ++NumPhis, ++I) 1251822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner if (NumPhis > 2) 1252822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner return false; 1253822a87998387a4c52be5162523f09cc8e5e5afb7Chris Lattner 1254f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // Loop over the PHI's seeing if we can promote them all to select 1255f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // instructions. While we are at it, keep track of the instructions 1256f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // that need to be moved to the dominating block. 125744da7ca4213333bcade57a407a890970351db494Chris Lattner SmallPtrSet<Instruction*, 4> AggressiveInsts; 125857808b3da00d7abd01382d3ed5e70bfb0b2beb4bPeter Collingbourne unsigned MaxCostVal0 = PHINodeFoldingThreshold, 125957808b3da00d7abd01382d3ed5e70bfb0b2beb4bPeter Collingbourne MaxCostVal1 = PHINodeFoldingThreshold; 1260f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner 12613aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner for (BasicBlock::iterator II = BB->begin(); isa<PHINode>(II);) { 12623aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner PHINode *PN = cast<PHINode>(II++); 126307ff3539f5342bdac019c68bb362cb222b3f71d9Chris Lattner if (Value *V = SimplifyInstruction(PN, TD)) { 126407ff3539f5342bdac019c68bb362cb222b3f71d9Chris Lattner PN->replaceAllUsesWith(V); 12653aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner PN->eraseFromParent(); 126607ff3539f5342bdac019c68bb362cb222b3f71d9Chris Lattner continue; 1267f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner } 126807ff3539f5342bdac019c68bb362cb222b3f71d9Chris Lattner 1269f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne if (!DominatesMergePoint(PN->getIncomingValue(0), BB, &AggressiveInsts, 1270f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne MaxCostVal0) || 1271f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne !DominatesMergePoint(PN->getIncomingValue(1), BB, &AggressiveInsts, 1272f15907feadb979daf30b2569954852778e501b2ePeter Collingbourne MaxCostVal1)) 127307ff3539f5342bdac019c68bb362cb222b3f71d9Chris Lattner return false; 1274f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner } 1275f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner 127644da7ca4213333bcade57a407a890970351db494Chris Lattner // If we folded the the first phi, PN dangles at this point. Refresh it. If 127744da7ca4213333bcade57a407a890970351db494Chris Lattner // we ran out of PHIs then we simplified them all. 127844da7ca4213333bcade57a407a890970351db494Chris Lattner PN = dyn_cast<PHINode>(BB->begin()); 127944da7ca4213333bcade57a407a890970351db494Chris Lattner if (PN == 0) return true; 128044da7ca4213333bcade57a407a890970351db494Chris Lattner 12813aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner // Don't fold i1 branches on PHIs which contain binary operators. These can 12823aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner // often be turned into switches and other things. 12833aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner if (PN->getType()->isIntegerTy(1) && 12843aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner (isa<BinaryOperator>(PN->getIncomingValue(0)) || 12853aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner isa<BinaryOperator>(PN->getIncomingValue(1)) || 12863aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner isa<BinaryOperator>(IfCond))) 12873aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner return false; 12883aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner 1289f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // If we all PHI nodes are promotable, check to make sure that all 1290f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // instructions in the predecessor blocks can be promoted as well. If 1291f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // not, we won't be able to get rid of the control flow, so it's not 1292f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // worth promoting to select instructions. 129344da7ca4213333bcade57a407a890970351db494Chris Lattner BasicBlock *DomBlock = 0; 129444da7ca4213333bcade57a407a890970351db494Chris Lattner BasicBlock *IfBlock1 = PN->getIncomingBlock(0); 129544da7ca4213333bcade57a407a890970351db494Chris Lattner BasicBlock *IfBlock2 = PN->getIncomingBlock(1); 129644da7ca4213333bcade57a407a890970351db494Chris Lattner if (cast<BranchInst>(IfBlock1->getTerminator())->isConditional()) { 129744da7ca4213333bcade57a407a890970351db494Chris Lattner IfBlock1 = 0; 129844da7ca4213333bcade57a407a890970351db494Chris Lattner } else { 129944da7ca4213333bcade57a407a890970351db494Chris Lattner DomBlock = *pred_begin(IfBlock1); 130044da7ca4213333bcade57a407a890970351db494Chris Lattner for (BasicBlock::iterator I = IfBlock1->begin();!isa<TerminatorInst>(I);++I) 1301383d7ed9158576aef5cde872548225a17e3c0155Devang Patel if (!AggressiveInsts.count(I) && !isa<DbgInfoIntrinsic>(I)) { 1302f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // This is not an aggressive instruction that we can promote. 1303f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // Because of this, we won't be able to get rid of the control 1304f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // flow, so the xform is not worth it. 1305f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner return false; 1306f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner } 1307f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner } 1308f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner 130944da7ca4213333bcade57a407a890970351db494Chris Lattner if (cast<BranchInst>(IfBlock2->getTerminator())->isConditional()) { 131044da7ca4213333bcade57a407a890970351db494Chris Lattner IfBlock2 = 0; 131144da7ca4213333bcade57a407a890970351db494Chris Lattner } else { 131244da7ca4213333bcade57a407a890970351db494Chris Lattner DomBlock = *pred_begin(IfBlock2); 131344da7ca4213333bcade57a407a890970351db494Chris Lattner for (BasicBlock::iterator I = IfBlock2->begin();!isa<TerminatorInst>(I);++I) 1314383d7ed9158576aef5cde872548225a17e3c0155Devang Patel if (!AggressiveInsts.count(I) && !isa<DbgInfoIntrinsic>(I)) { 1315f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // This is not an aggressive instruction that we can promote. 1316f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // Because of this, we won't be able to get rid of the control 1317f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // flow, so the xform is not worth it. 1318f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner return false; 1319f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner } 1320f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner } 1321e0b18e59120abc29bd25d69d20c4b0f310ec3382Chris Lattner 1322e0b18e59120abc29bd25d69d20c4b0f310ec3382Chris Lattner DEBUG(dbgs() << "FOUND IF CONDITION! " << *IfCond << " T: " 132344da7ca4213333bcade57a407a890970351db494Chris Lattner << IfTrue->getName() << " F: " << IfFalse->getName() << "\n"); 1324f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner 1325f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // If we can still promote the PHI nodes after this gauntlet of tests, 1326f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // do all of the PHI's now. 13273aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner Instruction *InsertPt = DomBlock->getTerminator(); 1328d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel IRBuilder<true, NoFolder> Builder(InsertPt); 13293aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner 1330f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // Move all 'aggressive' instructions, which are defined in the 1331f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // conditional parts of the if's up to the dominating block. 13329a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (IfBlock1) 13333aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner DomBlock->getInstList().splice(InsertPt, 13349a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner IfBlock1->getInstList(), IfBlock1->begin(), 1335f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner IfBlock1->getTerminator()); 13369a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (IfBlock2) 13373aff13b82a579e910420b6c040f3e85c99110e15Chris Lattner DomBlock->getInstList().splice(InsertPt, 13389a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner IfBlock2->getInstList(), IfBlock2->begin(), 1339f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner IfBlock2->getTerminator()); 1340f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner 1341f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner while (PHINode *PN = dyn_cast<PHINode>(BB->begin())) { 1342f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner // Change the PHI node into a select instruction. 13439a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner Value *TrueVal = PN->getIncomingValue(PN->getIncomingBlock(0) == IfFalse); 13449a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner Value *FalseVal = PN->getIncomingValue(PN->getIncomingBlock(0) == IfTrue); 1345f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner 1346f60364de44add5c92841425851cda1a6943bfcd7Devang Patel SelectInst *NV = 1347f60364de44add5c92841425851cda1a6943bfcd7Devang Patel cast<SelectInst>(Builder.CreateSelect(IfCond, TrueVal, FalseVal, "")); 134886cc42355593dd1689f7d58d56695c451215b02bChris Lattner PN->replaceAllUsesWith(NV); 134986cc42355593dd1689f7d58d56695c451215b02bChris Lattner NV->takeName(PN); 1350302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner PN->eraseFromParent(); 1351f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner } 135260d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner 135360d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner // At this point, IfBlock1 and IfBlock2 are both empty, so our if statement 135460d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner // has been flattened. Change DomBlock to jump directly to our new block to 135560d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner // avoid other simplifycfg's kicking in on the diamond. 135660d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner TerminatorInst *OldTI = DomBlock->getTerminator(); 1357f60364de44add5c92841425851cda1a6943bfcd7Devang Patel Builder.SetInsertPoint(OldTI); 1358f60364de44add5c92841425851cda1a6943bfcd7Devang Patel Builder.CreateBr(BB); 135960d410d7bb2eb11f36a004237e5948ffc5aff5a6Chris Lattner OldTI->eraseFromParent(); 1360f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner return true; 1361f58c1a578e63265abf46c395953fe8aa3f73e37cChris Lattner} 1362eaba3a194c23ecbfc5f3da439d1ef7a08eedf02cChris Lattner 1363c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner/// SimplifyCondBranchToTwoReturns - If we found a conditional branch that goes 1364c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner/// to two returning blocks, try to merge them together into one return, 1365c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner/// introducing a select if the return values disagree. 1366176ec40cb18c51c14fccbb38ee0db5deafb6baa9Devang Patelstatic bool SimplifyCondBranchToTwoReturns(BranchInst *BI, 1367176ec40cb18c51c14fccbb38ee0db5deafb6baa9Devang Patel IRBuilder<> &Builder) { 1368c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner assert(BI->isConditional() && "Must be a conditional branch"); 1369c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner BasicBlock *TrueSucc = BI->getSuccessor(0); 1370c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner BasicBlock *FalseSucc = BI->getSuccessor(1); 1371c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner ReturnInst *TrueRet = cast<ReturnInst>(TrueSucc->getTerminator()); 1372c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner ReturnInst *FalseRet = cast<ReturnInst>(FalseSucc->getTerminator()); 1373c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 1374c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // Check to ensure both blocks are empty (just a return) or optionally empty 1375c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // with PHI nodes. If there are other instructions, merging would cause extra 1376c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // computation on one path or the other. 13779a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (!TrueSucc->getFirstNonPHIOrDbg()->isTerminator()) 13782cc86a1de1cf598be384836f19d1ef1892fb50fcDevang Patel return false; 13799a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner if (!FalseSucc->getFirstNonPHIOrDbg()->isTerminator()) 13802cc86a1de1cf598be384836f19d1ef1892fb50fcDevang Patel return false; 1381c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 1382176ec40cb18c51c14fccbb38ee0db5deafb6baa9Devang Patel Builder.SetInsertPoint(BI); 1383c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // Okay, we found a branch that is going to two return nodes. If 1384c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // there is no return value for this function, just change the 1385c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // branch into a return. 1386c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner if (FalseRet->getNumOperands() == 0) { 1387c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner TrueSucc->removePredecessor(BI->getParent()); 1388c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner FalseSucc->removePredecessor(BI->getParent()); 1389176ec40cb18c51c14fccbb38ee0db5deafb6baa9Devang Patel Builder.CreateRetVoid(); 1390080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman EraseTerminatorInstAndDCECond(BI); 1391c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner return true; 1392c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner } 1393c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 1394fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman // Otherwise, figure out what the true and false return values are 1395fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman // so we can insert a new select instruction. 1396fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman Value *TrueValue = TrueRet->getReturnValue(); 1397fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman Value *FalseValue = FalseRet->getReturnValue(); 1398fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman 1399fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman // Unwrap any PHI nodes in the return blocks. 1400fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (PHINode *TVPN = dyn_cast_or_null<PHINode>(TrueValue)) 1401fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (TVPN->getParent() == TrueSucc) 1402fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman TrueValue = TVPN->getIncomingValueForBlock(BI->getParent()); 1403fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (PHINode *FVPN = dyn_cast_or_null<PHINode>(FalseValue)) 1404fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (FVPN->getParent() == FalseSucc) 1405fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman FalseValue = FVPN->getIncomingValueForBlock(BI->getParent()); 1406fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman 1407fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman // In order for this transformation to be safe, we must be able to 1408fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman // unconditionally execute both operands to the return. This is 1409fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman // normally the case, but we could have a potentially-trapping 1410fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman // constant expression that prevents this transformation from being 1411fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman // safe. 1412fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (ConstantExpr *TCV = dyn_cast_or_null<ConstantExpr>(TrueValue)) 1413fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (TCV->canTrap()) 1414fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman return false; 1415fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (ConstantExpr *FCV = dyn_cast_or_null<ConstantExpr>(FalseValue)) 1416fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (FCV->canTrap()) 1417fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman return false; 1418c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 1419c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // Okay, we collected all the mapped values and checked them for sanity, and 1420c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // defined to really do this transformation. First, update the CFG. 1421c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner TrueSucc->removePredecessor(BI->getParent()); 1422c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner FalseSucc->removePredecessor(BI->getParent()); 1423c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 1424c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // Insert select instructions where needed. 1425c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner Value *BrCond = BI->getCondition(); 1426fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (TrueValue) { 1427c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner // Insert a select if the results differ. 1428fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman if (TrueValue == FalseValue || isa<UndefValue>(FalseValue)) { 1429fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman } else if (isa<UndefValue>(TrueValue)) { 1430fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman TrueValue = FalseValue; 1431fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman } else { 1432176ec40cb18c51c14fccbb38ee0db5deafb6baa9Devang Patel TrueValue = Builder.CreateSelect(BrCond, TrueValue, 1433176ec40cb18c51c14fccbb38ee0db5deafb6baa9Devang Patel FalseValue, "retval"); 1434c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner } 1435c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner } 1436c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 1437176ec40cb18c51c14fccbb38ee0db5deafb6baa9Devang Patel Value *RI = !TrueValue ? 1438176ec40cb18c51c14fccbb38ee0db5deafb6baa9Devang Patel Builder.CreateRetVoid() : Builder.CreateRet(TrueValue); 1439176ec40cb18c51c14fccbb38ee0db5deafb6baa9Devang Patel 1440e317bcc74c1f317f913e9b05db385901cfc54d0bDaniel Dunbar (void) RI; 1441c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 144289d6fd36a26fdf068ceea90422dc2897e89700b5David Greene DEBUG(dbgs() << "\nCHANGING BRANCH TO TWO RETURNS INTO SELECT:" 1443bdff548e4dd577a72094d57b282de4e765643b96Chris Lattner << "\n " << *BI << "NewRet = " << *RI 1444bdff548e4dd577a72094d57b282de4e765643b96Chris Lattner << "TRUEBLOCK: " << *TrueSucc << "FALSEBLOCK: "<< *FalseSucc); 1445c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 1446080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman EraseTerminatorInstAndDCECond(BI); 1447080efb8cea6255b4f1f373d9cb583d6a6302106bEli Friedman 1448c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner return true; 1449c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner} 1450c9e495c534b95a72502d1840293e66fa2e2d6882Chris Lattner 145106cc66f65a5012471835068029f3f4943790f584Nick Lewycky/// ExtractBranchMetadata - Given a conditional BranchInstruction, retrieve the 145206cc66f65a5012471835068029f3f4943790f584Nick Lewycky/// probabilities of the branch taking each edge. Fills in the two APInt 145306cc66f65a5012471835068029f3f4943790f584Nick Lewycky/// parameters and return true, or returns false if no or invalid metadata was 145406cc66f65a5012471835068029f3f4943790f584Nick Lewycky/// found. 145506cc66f65a5012471835068029f3f4943790f584Nick Lewyckystatic bool ExtractBranchMetadata(BranchInst *BI, 145606cc66f65a5012471835068029f3f4943790f584Nick Lewycky APInt &ProbTrue, APInt &ProbFalse) { 145706cc66f65a5012471835068029f3f4943790f584Nick Lewycky assert(BI->isConditional() && 145806cc66f65a5012471835068029f3f4943790f584Nick Lewycky "Looking for probabilities on unconditional branch?"); 145906cc66f65a5012471835068029f3f4943790f584Nick Lewycky MDNode *ProfileData = BI->getMetadata(LLVMContext::MD_prof); 146091968489d718b313d4c0b912062e75a82db650e7Nick Lewycky if (!ProfileData || ProfileData->getNumOperands() != 3) return false; 146106cc66f65a5012471835068029f3f4943790f584Nick Lewycky ConstantInt *CITrue = dyn_cast<ConstantInt>(ProfileData->getOperand(1)); 146206cc66f65a5012471835068029f3f4943790f584Nick Lewycky ConstantInt *CIFalse = dyn_cast<ConstantInt>(ProfileData->getOperand(2)); 146391968489d718b313d4c0b912062e75a82db650e7Nick Lewycky if (!CITrue || !CIFalse) return false; 146406cc66f65a5012471835068029f3f4943790f584Nick Lewycky ProbTrue = CITrue->getValue(); 146506cc66f65a5012471835068029f3f4943790f584Nick Lewycky ProbFalse = CIFalse->getValue(); 146606cc66f65a5012471835068029f3f4943790f584Nick Lewycky assert(ProbTrue.getBitWidth() == 32 && ProbFalse.getBitWidth() == 32 && 146706cc66f65a5012471835068029f3f4943790f584Nick Lewycky "Branch probability metadata must be 32-bit integers"); 146806cc66f65a5012471835068029f3f4943790f584Nick Lewycky return true; 146906cc66f65a5012471835068029f3f4943790f584Nick Lewycky} 147006cc66f65a5012471835068029f3f4943790f584Nick Lewycky 14716c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky/// MultiplyAndLosePrecision - Multiplies A and B, then returns the result. In 14726c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky/// the event of overflow, logically-shifts all four inputs right until the 14736c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky/// multiply fits. 14746c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewyckystatic APInt MultiplyAndLosePrecision(APInt &A, APInt &B, APInt &C, APInt &D, 14756c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky unsigned &BitsLost) { 14766c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky BitsLost = 0; 14776c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky bool Overflow = false; 14786c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky APInt Result = A.umul_ov(B, Overflow); 14796c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky if (Overflow) { 14806c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky APInt MaxB = APInt::getMaxValue(A.getBitWidth()).udiv(A); 14816c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky do { 14826c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky B = B.lshr(1); 14836c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky ++BitsLost; 14846c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky } while (B.ugt(MaxB)); 14856c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky A = A.lshr(BitsLost); 14866c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky C = C.lshr(BitsLost); 14876c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky D = D.lshr(BitsLost); 14886c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky Result = A * B; 14896c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky } 14906c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky return Result; 14916c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky} 14926c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky 14936c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky 1494c8fbc34869fc1737adea00f775de5b8dd829f7a1Chris Lattner/// FoldBranchToCommonDest - If this basic block is simple enough, and if a 1495c8fbc34869fc1737adea00f775de5b8dd829f7a1Chris Lattner/// predecessor branches to us and one of our successors, fold the block into 1496c8fbc34869fc1737adea00f775de5b8dd829f7a1Chris Lattner/// the predecessor and use logical operations to pick the right destination. 14974b35f83b91a1a313f0730c600e5178aaf7df98d6Dan Gohmanbool llvm::FoldBranchToCommonDest(BranchInst *BI) { 1498093a4385027235459ab6972b2e2fdc79061773cfChris Lattner BasicBlock *BB = BI->getParent(); 1499d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel 15001347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner Instruction *Cond = dyn_cast<Instruction>(BI->getCondition()); 1501e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (Cond == 0 || (!isa<CmpInst>(Cond) && !isa<BinaryOperator>(Cond)) || 1502e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson Cond->getParent() != BB || !Cond->hasOneUse()) 1503e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson return false; 1504d418194036e9e05f47154535ddb9f1f1c8bc592bDevang Patel 15051347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner // Only allow this if the condition is a simple instruction that can be 15061347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner // executed unconditionally. It must be in the same block as the branch, and 15071347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner // must be at the front of the block. 1508d0a203d76f4ef77ae1c392e8e73e2f05b676a5f2Devang Patel BasicBlock::iterator FrontIt = BB->front(); 15093c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner 1510d0a203d76f4ef77ae1c392e8e73e2f05b676a5f2Devang Patel // Ignore dbg intrinsics. 15113c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner while (isa<DbgInfoIntrinsic>(FrontIt)) ++FrontIt; 15129d5231022283ff20b0291eb5711a449de262d3feNick Lewycky 1513e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // Allow a single instruction to be hoisted in addition to the compare 1514e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // that feeds the branch. We later ensure that any values that _it_ uses 1515e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // were also live in the predecessor, so that we don't unnecessarily create 1516e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // register pressure or inhibit out-of-order execution. 1517e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson Instruction *BonusInst = 0; 1518e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (&*FrontIt != Cond && 15192722dfa75dbf4436197f6fcf9d8cb2391975f1a1Owen Anderson FrontIt->hasOneUse() && *FrontIt->use_begin() == Cond && 1520f0426601977c3e386d2d26c72a2cca691dc42072Dan Gohman isSafeToSpeculativelyExecute(FrontIt)) { 1521e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson BonusInst = &*FrontIt; 1522e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson ++FrontIt; 15233c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner 15243c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner // Ignore dbg intrinsics. 15253c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner while (isa<DbgInfoIntrinsic>(FrontIt)) ++FrontIt; 152660d490cdc7b11e678f35f5b7eb2c9ef354462211Devang Patel } 152760d490cdc7b11e678f35f5b7eb2c9ef354462211Devang Patel 1528e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // Only a single bonus inst is allowed. 1529e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (&*FrontIt != Cond) 1530e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson return false; 1531e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson 15321347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner // Make sure the instruction after the condition is the cond branch. 15331347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner BasicBlock::iterator CondIt = Cond; ++CondIt; 15343c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner 1535d0a203d76f4ef77ae1c392e8e73e2f05b676a5f2Devang Patel // Ingore dbg intrinsics. 15363c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner while (isa<DbgInfoIntrinsic>(CondIt)) ++CondIt; 15373c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner 15383c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner if (&*CondIt != BI) 15391347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner return false; 15406ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner 15416ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner // Cond is known to be a compare or binary operator. Check to make sure that 15426ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner // neither operand is a potentially-trapping constant expression. 15436ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Cond->getOperand(0))) 15446ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner if (CE->canTrap()) 15456ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner return false; 15466ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Cond->getOperand(1))) 15476ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner if (CE->canTrap()) 15486ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner return false; 15496ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner 15501347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner // Finally, don't infinitely unroll conditional loops. 15511347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner BasicBlock *TrueDest = BI->getSuccessor(0); 15521347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner BasicBlock *FalseDest = BI->getSuccessor(1); 15531347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner if (TrueDest == BB || FalseDest == BB) 15541347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner return false; 1555d418194036e9e05f47154535ddb9f1f1c8bc592bDevang Patel 15561347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) { 15571347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner BasicBlock *PredBlock = *PI; 15581347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner BranchInst *PBI = dyn_cast<BranchInst>(PredBlock->getTerminator()); 15596ff645bf0fcfc0c62e9d9126e1243ec8bf10abbcChris Lattner 1560093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // Check that we have two conditional branches. If there is a PHI node in 1561093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // the common successor, verify that the same value flows in from both 1562093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // blocks. 15633c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner if (PBI == 0 || PBI->isUnconditional() || !SafeToMergeTerminators(BI, PBI)) 15641347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner continue; 15651347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner 15663c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner // Determine if the two branches share a common destination. 15673c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner Instruction::BinaryOps Opc; 15683c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner bool InvertPredCond = false; 15693c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner 15703c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner if (PBI->getSuccessor(0) == TrueDest) 15713c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner Opc = Instruction::Or; 15723c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner else if (PBI->getSuccessor(1) == FalseDest) 15733c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner Opc = Instruction::And; 15743c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner else if (PBI->getSuccessor(0) == FalseDest) 15753c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner Opc = Instruction::And, InvertPredCond = true; 15763c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner else if (PBI->getSuccessor(1) == TrueDest) 15773c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner Opc = Instruction::Or, InvertPredCond = true; 15783c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner else 15793c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner continue; 15803c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner 1581e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // Ensure that any values used in the bonus instruction are also used 1582e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // by the terminator of the predecessor. This means that those values 1583e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // must already have been resolved, so we won't be inhibiting the 1584e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // out-of-order core by speculating them earlier. 1585e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (BonusInst) { 1586e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // Collect the values used by the bonus inst 1587e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson SmallPtrSet<Value*, 4> UsedValues; 1588e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson for (Instruction::op_iterator OI = BonusInst->op_begin(), 1589e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson OE = BonusInst->op_end(); OI != OE; ++OI) { 15909d5231022283ff20b0291eb5711a449de262d3feNick Lewycky Value *V = *OI; 1591e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (!isa<Constant>(V)) 1592e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson UsedValues.insert(V); 1593e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson } 1594e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson 1595e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson SmallVector<std::pair<Value*, unsigned>, 4> Worklist; 1596e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson Worklist.push_back(std::make_pair(PBI->getOperand(0), 0)); 1597e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson 1598e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // Walk up to four levels back up the use-def chain of the predecessor's 1599e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // terminator to see if all those values were used. The choice of four 1600e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // levels is arbitrary, to provide a compile-time-cost bound. 1601e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson while (!Worklist.empty()) { 1602e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson std::pair<Value*, unsigned> Pair = Worklist.back(); 1603e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson Worklist.pop_back(); 1604e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson 1605e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (Pair.second >= 4) continue; 1606e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson UsedValues.erase(Pair.first); 1607e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (UsedValues.empty()) break; 1608e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson 1609daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner if (Instruction *I = dyn_cast<Instruction>(Pair.first)) { 1610e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson for (Instruction::op_iterator OI = I->op_begin(), OE = I->op_end(); 1611e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson OI != OE; ++OI) 1612e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson Worklist.push_back(std::make_pair(OI->get(), Pair.second+1)); 1613e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson } 1614e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson } 1615e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson 1616e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (!UsedValues.empty()) return false; 1617e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson } 16183698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner 161989d6fd36a26fdf068ceea90422dc2897e89700b5David Greene DEBUG(dbgs() << "FOLDING BRANCH TO COMMON DEST:\n" << *PBI << *BB); 1620d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel IRBuilder<> Builder(PBI); 1621d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel 16223698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner // If we need to invert the condition in the pred block to match, do so now. 16233698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner if (InvertPredCond) { 1624daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner Value *NewCond = PBI->getCondition(); 1625daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner 1626daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner if (NewCond->hasOneUse() && isa<CmpInst>(NewCond)) { 1627daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner CmpInst *CI = cast<CmpInst>(NewCond); 1628daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner CI->setPredicate(CI->getInversePredicate()); 1629daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner } else { 1630d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel NewCond = Builder.CreateNot(NewCond, 1631d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel PBI->getCondition()->getName()+".not"); 1632daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner } 1633daa02ab70c7619cc22131c75c62390cf3f5f8891Chris Lattner 16341347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner PBI->setCondition(NewCond); 1635c9a1aed7fefe627820bb92154361ede0568229fcNick Lewycky PBI->swapSuccessors(); 16361347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner } 163770087f31f154156bcb494dd0cf3b7d74c0c8b528Chris Lattner 1638e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson // If we have a bonus inst, clone it into the predecessor block. 1639e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson Instruction *NewBonus = 0; 1640e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (BonusInst) { 1641e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson NewBonus = BonusInst->clone(); 1642e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson PredBlock->getInstList().insert(PBI, NewBonus); 1643e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson NewBonus->takeName(BonusInst); 1644e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson BonusInst->setName(BonusInst->getName()+".old"); 1645e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson } 1646e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson 16473698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner // Clone Cond into the predecessor basic block, and or/and the 16483698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner // two conditions together. 16496776064d190701c5bae4d5403939eed2e480d1cdNick Lewycky Instruction *New = Cond->clone(); 1650e84178a0bd3a218238b15ef646f2e740f3a48037Owen Anderson if (BonusInst) New->replaceUsesOfWith(BonusInst, NewBonus); 16513698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner PredBlock->getInstList().insert(PBI, New); 16523698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner New->takeName(Cond); 16533698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner Cond->setName(New->getName()+".old"); 165470087f31f154156bcb494dd0cf3b7d74c0c8b528Chris Lattner 1655d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel Instruction *NewCond = 1656d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel cast<Instruction>(Builder.CreateBinOp(Opc, PBI->getCondition(), 1657d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel New, "or.cond")); 16583698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner PBI->setCondition(NewCond); 16593698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner if (PBI->getSuccessor(0) == BB) { 16603698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner AddPredecessorToBlock(TrueDest, PredBlock, BB); 16613698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner PBI->setSuccessor(0, TrueDest); 16623698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner } 16633698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner if (PBI->getSuccessor(1) == BB) { 16643698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner AddPredecessorToBlock(FalseDest, PredBlock, BB); 16653698909623f994826b6a11fc4ea37e4b425a9589Chris Lattner PBI->setSuccessor(1, FalseDest); 16661347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner } 1667d418194036e9e05f47154535ddb9f1f1c8bc592bDevang Patel 166806cc66f65a5012471835068029f3f4943790f584Nick Lewycky // TODO: If BB is reachable from all paths through PredBlock, then we 166906cc66f65a5012471835068029f3f4943790f584Nick Lewycky // could replace PBI's branch probabilities with BI's. 167006cc66f65a5012471835068029f3f4943790f584Nick Lewycky 167106cc66f65a5012471835068029f3f4943790f584Nick Lewycky // Merge probability data into PredBlock's branch. 167206cc66f65a5012471835068029f3f4943790f584Nick Lewycky APInt A, B, C, D; 167306cc66f65a5012471835068029f3f4943790f584Nick Lewycky if (ExtractBranchMetadata(PBI, C, D) && ExtractBranchMetadata(BI, A, B)) { 16748da7ddf2d28d27e8b7fd8b7f159e2d9584bdc819Nick Lewycky // Given IR which does: 16758da7ddf2d28d27e8b7fd8b7f159e2d9584bdc819Nick Lewycky // bbA: 16768da7ddf2d28d27e8b7fd8b7f159e2d9584bdc819Nick Lewycky // br i1 %x, label %bbB, label %bbC 16778da7ddf2d28d27e8b7fd8b7f159e2d9584bdc819Nick Lewycky // bbB: 16788da7ddf2d28d27e8b7fd8b7f159e2d9584bdc819Nick Lewycky // br i1 %y, label %bbD, label %bbC 16798da7ddf2d28d27e8b7fd8b7f159e2d9584bdc819Nick Lewycky // Let's call the probability that we take the edge from %bbA to %bbB 16808da7ddf2d28d27e8b7fd8b7f159e2d9584bdc819Nick Lewycky // 'a', from %bbA to %bbC, 'b', from %bbB to %bbD 'c' and from %bbB to 16818da7ddf2d28d27e8b7fd8b7f159e2d9584bdc819Nick Lewycky // %bbC probability 'd'. 168206cc66f65a5012471835068029f3f4943790f584Nick Lewycky // 16838da7ddf2d28d27e8b7fd8b7f159e2d9584bdc819Nick Lewycky // We transform the IR into: 16848da7ddf2d28d27e8b7fd8b7f159e2d9584bdc819Nick Lewycky // bbA: 16858da7ddf2d28d27e8b7fd8b7f159e2d9584bdc819Nick Lewycky // br i1 %z, label %bbD, label %bbC 16868da7ddf2d28d27e8b7fd8b7f159e2d9584bdc819Nick Lewycky // where the probability of going to %bbD is (a*c) and going to bbC is 16878da7ddf2d28d27e8b7fd8b7f159e2d9584bdc819Nick Lewycky // (b+a*d). 16888da7ddf2d28d27e8b7fd8b7f159e2d9584bdc819Nick Lewycky // 16898da7ddf2d28d27e8b7fd8b7f159e2d9584bdc819Nick Lewycky // Probabilities aren't stored as ratios directly. Using branch weights, 16908da7ddf2d28d27e8b7fd8b7f159e2d9584bdc819Nick Lewycky // we get: 169106cc66f65a5012471835068029f3f4943790f584Nick Lewycky // (a*c)% = A*C, (b+(a*d))% = A*D+B*C+B*D. 169206cc66f65a5012471835068029f3f4943790f584Nick Lewycky 16936c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky // In the event of overflow, we want to drop the LSB of the input 16946c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky // probabilities. 16956c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky unsigned BitsLost; 169606cc66f65a5012471835068029f3f4943790f584Nick Lewycky 16976c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky // Ignore overflow result on ProbTrue. 16986c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky APInt ProbTrue = MultiplyAndLosePrecision(A, C, B, D, BitsLost); 169906cc66f65a5012471835068029f3f4943790f584Nick Lewycky 17006c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky APInt Tmp1 = MultiplyAndLosePrecision(B, D, A, C, BitsLost); 17016c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky if (BitsLost) { 17026c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky ProbTrue = ProbTrue.lshr(BitsLost*2); 17036c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky } 17046c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky 17056c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky APInt Tmp2 = MultiplyAndLosePrecision(A, D, C, B, BitsLost); 17066c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky if (BitsLost) { 17076c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky ProbTrue = ProbTrue.lshr(BitsLost*2); 17086c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky Tmp1 = Tmp1.lshr(BitsLost*2); 17096c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky } 17106c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky 17116c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky APInt Tmp3 = MultiplyAndLosePrecision(B, C, A, D, BitsLost); 17126c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky if (BitsLost) { 17136c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky ProbTrue = ProbTrue.lshr(BitsLost*2); 17146c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky Tmp1 = Tmp1.lshr(BitsLost*2); 17156c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky Tmp2 = Tmp2.lshr(BitsLost*2); 17166c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky } 17176c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky 17186c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky bool Overflow1 = false, Overflow2 = false; 17196c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky APInt Tmp4 = Tmp2.uadd_ov(Tmp3, Overflow1); 17206c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky APInt ProbFalse = Tmp4.uadd_ov(Tmp1, Overflow2); 17216c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky 17226c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky if (Overflow1 || Overflow2) { 17236c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky ProbTrue = ProbTrue.lshr(1); 17246c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky Tmp1 = Tmp1.lshr(1); 17256c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky Tmp2 = Tmp2.lshr(1); 17266c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky Tmp3 = Tmp3.lshr(1); 17276c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky Tmp4 = Tmp2 + Tmp3; 17286c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky ProbFalse = Tmp4 + Tmp1; 17296c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky } 17306c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky 17316c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky // The sum of branch weights must fit in 32-bits. 17326c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky if (ProbTrue.isNegative() && ProbFalse.isNegative()) { 17336c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky ProbTrue = ProbTrue.lshr(1); 17346c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky ProbFalse = ProbFalse.lshr(1); 17356c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky } 17366c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky 17376c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky if (ProbTrue != ProbFalse) { 17386c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky // Normalize the result. 17396c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky APInt GCD = APIntOps::GreatestCommonDivisor(ProbTrue, ProbFalse); 17406c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky ProbTrue = ProbTrue.udiv(GCD); 17416c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky ProbFalse = ProbFalse.udiv(GCD); 174206cc66f65a5012471835068029f3f4943790f584Nick Lewycky 174306cc66f65a5012471835068029f3f4943790f584Nick Lewycky LLVMContext &Context = BI->getContext(); 174406cc66f65a5012471835068029f3f4943790f584Nick Lewycky Value *Ops[3]; 174506cc66f65a5012471835068029f3f4943790f584Nick Lewycky Ops[0] = BI->getMetadata(LLVMContext::MD_prof)->getOperand(0); 174606cc66f65a5012471835068029f3f4943790f584Nick Lewycky Ops[1] = ConstantInt::get(Context, ProbTrue); 174706cc66f65a5012471835068029f3f4943790f584Nick Lewycky Ops[2] = ConstantInt::get(Context, ProbFalse); 174806cc66f65a5012471835068029f3f4943790f584Nick Lewycky PBI->setMetadata(LLVMContext::MD_prof, MDNode::get(Context, Ops)); 17496c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky } else { 17506c00c6a181934afc8bc23db3033e46a3ff93602bNick Lewycky PBI->setMetadata(LLVMContext::MD_prof, NULL); 175106cc66f65a5012471835068029f3f4943790f584Nick Lewycky } 175206cc66f65a5012471835068029f3f4943790f584Nick Lewycky } else { 175306cc66f65a5012471835068029f3f4943790f584Nick Lewycky PBI->setMetadata(LLVMContext::MD_prof, NULL); 175406cc66f65a5012471835068029f3f4943790f584Nick Lewycky } 175506cc66f65a5012471835068029f3f4943790f584Nick Lewycky 17563c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner // Copy any debug value intrinsics into the end of PredBlock. 17573c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 17583c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner if (isa<DbgInfoIntrinsic>(*I)) 17593c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner I->clone()->insertBefore(PBI); 17603c6e746b5f05ffe3870e2aeadd2f9a3c0a96187bChris Lattner 1761117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner return true; 17621347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner } 17631347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner return false; 17641347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner} 17651347e87c7baa78bd442d7017a8d67bd4fe674e01Chris Lattner 1766867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner/// SimplifyCondBranchToCondBranch - If we have a conditional branch as a 1767867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner/// predecessor of another block, this function tries to simplify it. We know 1768867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner/// that PBI and BI are both conditional branches, and BI is in one of the 1769867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner/// successor blocks of PBI - PBI branches to BI. 1770867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattnerstatic bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI) { 1771867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner assert(PBI->isConditional() && BI->isConditional()); 1772867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner BasicBlock *BB = BI->getParent(); 17734ae5126d041768ab9665cf2f11c024becd76c41fDan Gohman 1774867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // If this block ends with a branch instruction, and if there is a 1775867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // predecessor that ends on a branch of the same condition, make 1776867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // this conditional branch redundant. 1777867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner if (PBI->getCondition() == BI->getCondition() && 1778867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner PBI->getSuccessor(0) != PBI->getSuccessor(1)) { 1779867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // Okay, the outcome of this conditional branch is statically 1780867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // knowable. If this block had a single pred, handle specially. 1781867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner if (BB->getSinglePredecessor()) { 1782867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // Turn this into a branch on constant. 1783867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner bool CondIsTrue = PBI->getSuccessor(0) == BB; 17841d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson BI->setCondition(ConstantInt::get(Type::getInt1Ty(BB->getContext()), 17851d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson CondIsTrue)); 1786867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner return true; // Nuke the branch on constant. 1787867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner } 1788867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner 1789867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // Otherwise, if there are multiple predecessors, insert a PHI that merges 1790867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // in the constant and simplify the block result. Subsequent passes of 1791867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // simplifycfg will thread the block. 1792867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner if (BlockIsSimpleEnoughToThreadThrough(BB)) { 1793d8b4fb4aab4d6fedb2b14bed1b846451b17bde7cJay Foad pred_iterator PB = pred_begin(BB), PE = pred_end(BB); 17941d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PHINode *NewPN = PHINode::Create(Type::getInt1Ty(BB->getContext()), 17953ecfc861b4365f341c5c969b40e1afccde676e6fJay Foad std::distance(PB, PE), 1796867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner BI->getCondition()->getName() + ".pr", 1797867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner BB->begin()); 1798eb388af89f15ee3de6f53359473e1a54418a667fChris Lattner // Okay, we're going to insert the PHI node. Since PBI is not the only 1799eb388af89f15ee3de6f53359473e1a54418a667fChris Lattner // predecessor, compute the PHI'd conditional value for all of the preds. 1800eb388af89f15ee3de6f53359473e1a54418a667fChris Lattner // Any predecessor where the condition is not computable we keep symbolic. 1801d8b4fb4aab4d6fedb2b14bed1b846451b17bde7cJay Foad for (pred_iterator PI = PB; PI != PE; ++PI) { 1802625398343e2673a0c4bb5228fc88f71fe4e1c629Gabor Greif BasicBlock *P = *PI; 1803625398343e2673a0c4bb5228fc88f71fe4e1c629Gabor Greif if ((PBI = dyn_cast<BranchInst>(P->getTerminator())) && 1804867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner PBI != BI && PBI->isConditional() && 1805867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner PBI->getCondition() == BI->getCondition() && 1806867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner PBI->getSuccessor(0) != PBI->getSuccessor(1)) { 1807867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner bool CondIsTrue = PBI->getSuccessor(0) == BB; 18081d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson NewPN->addIncoming(ConstantInt::get(Type::getInt1Ty(BB->getContext()), 1809625398343e2673a0c4bb5228fc88f71fe4e1c629Gabor Greif CondIsTrue), P); 1810867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner } else { 1811625398343e2673a0c4bb5228fc88f71fe4e1c629Gabor Greif NewPN->addIncoming(BI->getCondition(), P); 1812867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner } 1813625398343e2673a0c4bb5228fc88f71fe4e1c629Gabor Greif } 1814867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner 1815867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner BI->setCondition(NewPN); 1816867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner return true; 1817867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner } 1818867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner } 1819867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner 1820867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // If this is a conditional branch in an empty block, and if any 1821867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // predecessors is a conditional branch to one of our destinations, 1822867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner // fold the conditions into logical ops and one cond br. 1823a8d57fe96bb870e4f69c6b522a78936d1495d0d2Zhou Sheng BasicBlock::iterator BBI = BB->begin(); 1824a8d57fe96bb870e4f69c6b522a78936d1495d0d2Zhou Sheng // Ignore dbg intrinsics. 1825a8d57fe96bb870e4f69c6b522a78936d1495d0d2Zhou Sheng while (isa<DbgInfoIntrinsic>(BBI)) 1826a8d57fe96bb870e4f69c6b522a78936d1495d0d2Zhou Sheng ++BBI; 1827a8d57fe96bb870e4f69c6b522a78936d1495d0d2Zhou Sheng if (&*BBI != BI) 1828b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner return false; 182963bf29b5b1c741038d6d502d62721cac0d2760b4Chris Lattner 183063bf29b5b1c741038d6d502d62721cac0d2760b4Chris Lattner 183163bf29b5b1c741038d6d502d62721cac0d2760b4Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(BI->getCondition())) 183263bf29b5b1c741038d6d502d62721cac0d2760b4Chris Lattner if (CE->canTrap()) 183363bf29b5b1c741038d6d502d62721cac0d2760b4Chris Lattner return false; 1834b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 1835b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner int PBIOp, BIOp; 1836b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner if (PBI->getSuccessor(0) == BI->getSuccessor(0)) 1837b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBIOp = BIOp = 0; 1838b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner else if (PBI->getSuccessor(0) == BI->getSuccessor(1)) 1839b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBIOp = 0, BIOp = 1; 1840b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner else if (PBI->getSuccessor(1) == BI->getSuccessor(0)) 1841b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBIOp = 1, BIOp = 0; 1842b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner else if (PBI->getSuccessor(1) == BI->getSuccessor(1)) 1843b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBIOp = BIOp = 1; 1844b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner else 1845b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner return false; 1846867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner 1847b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // Check to make sure that the other destination of this branch 1848b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // isn't BB itself. If so, this is an infinite loop that will 1849b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // keep getting unwound. 1850b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner if (PBI->getSuccessor(PBIOp) == BB) 1851b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner return false; 1852867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner 1853b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // Do not perform this transformation if it would require 1854b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // insertion of a large number of select instructions. For targets 1855b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // without predication/cmovs, this is a big pessimization. 1856b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner BasicBlock *CommonDest = PBI->getSuccessor(PBIOp); 1857867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner 1858b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner unsigned NumPhis = 0; 1859b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner for (BasicBlock::iterator II = CommonDest->begin(); 1860b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner isa<PHINode>(II); ++II, ++NumPhis) 1861b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner if (NumPhis > 2) // Disable this xform. 1862b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner return false; 1863867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner 1864b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // Finally, if everything is ok, fold the branches to logical ops. 1865b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner BasicBlock *OtherDest = BI->getSuccessor(BIOp ^ 1); 1866b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 186789d6fd36a26fdf068ceea90422dc2897e89700b5David Greene DEBUG(dbgs() << "FOLDING BRs:" << *PBI->getParent() 1868bdff548e4dd577a72094d57b282de4e765643b96Chris Lattner << "AND: " << *BI->getParent()); 1869b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 1870093a4385027235459ab6972b2e2fdc79061773cfChris Lattner 1871093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // If OtherDest *is* BB, then BB is a basic block with a single conditional 1872093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // branch in it, where one edge (OtherDest) goes back to itself but the other 1873093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // exits. We don't *know* that the program avoids the infinite loop 1874093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // (even though that seems likely). If we do this xform naively, we'll end up 1875093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // recursively unpeeling the loop. Since we know that (after the xform is 1876093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // done) that the block *is* infinite if reached, we just make it an obviously 1877093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // infinite loop with no cond branch. 1878093a4385027235459ab6972b2e2fdc79061773cfChris Lattner if (OtherDest == BB) { 1879093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // Insert it at the end of the function, because it's either code, 1880093a4385027235459ab6972b2e2fdc79061773cfChris Lattner // or it won't matter if it's hot. :) 18811d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson BasicBlock *InfLoopBlock = BasicBlock::Create(BB->getContext(), 18821d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson "infloop", BB->getParent()); 1883093a4385027235459ab6972b2e2fdc79061773cfChris Lattner BranchInst::Create(InfLoopBlock, InfLoopBlock); 1884093a4385027235459ab6972b2e2fdc79061773cfChris Lattner OtherDest = InfLoopBlock; 1885093a4385027235459ab6972b2e2fdc79061773cfChris Lattner } 1886093a4385027235459ab6972b2e2fdc79061773cfChris Lattner 188789d6fd36a26fdf068ceea90422dc2897e89700b5David Greene DEBUG(dbgs() << *PBI->getParent()->getParent()); 1888d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel 1889b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // BI may have other predecessors. Because of this, we leave 1890b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // it alone, but modify PBI. 1891b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 1892b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // Make sure we get to CommonDest on True&True directions. 1893b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner Value *PBICond = PBI->getCondition(); 1894d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel IRBuilder<true, NoFolder> Builder(PBI); 1895b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner if (PBIOp) 1896d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel PBICond = Builder.CreateNot(PBICond, PBICond->getName()+".not"); 1897d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel 1898b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner Value *BICond = BI->getCondition(); 1899b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner if (BIOp) 1900d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel BICond = Builder.CreateNot(BICond, BICond->getName()+".not"); 1901d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel 1902b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // Merge the conditions. 1903d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel Value *Cond = Builder.CreateOr(PBICond, BICond, "brmerge"); 1904b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 1905b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // Modify PBI to branch on the new condition to the new dests. 1906b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBI->setCondition(Cond); 1907b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBI->setSuccessor(0, CommonDest); 1908b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PBI->setSuccessor(1, OtherDest); 1909b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 1910b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // OtherDest may have phi nodes. If so, add an entry from PBI's 1911b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // block that are identical to the entries for BI's block. 19126de0a28dfb84095ebd7775f371dd4085cf955076Chris Lattner AddPredecessorToBlock(OtherDest, PBI->getParent(), BB); 1913b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 1914b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // We know that the CommonDest already had an edge from PBI to 1915b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // it. If it has PHIs though, the PHIs may have different 1916b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // entries for BB and PBI's BB. If so, insert a select to make 1917b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // them agree. 19186de0a28dfb84095ebd7775f371dd4085cf955076Chris Lattner PHINode *PN; 1919b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner for (BasicBlock::iterator II = CommonDest->begin(); 1920b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner (PN = dyn_cast<PHINode>(II)); ++II) { 1921b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner Value *BIV = PN->getIncomingValueForBlock(BB); 1922b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner unsigned PBBIdx = PN->getBasicBlockIndex(PBI->getParent()); 1923b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner Value *PBIV = PN->getIncomingValue(PBBIdx); 1924b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner if (BIV != PBIV) { 1925b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // Insert a select in PBI to pick the right value. 1926d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel Value *NV = cast<SelectInst> 1927d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel (Builder.CreateSelect(PBICond, PBIV, BIV, PBIV->getName()+".mux")); 1928b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner PN->setIncomingValue(PBBIdx, NV); 1929867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner } 1930867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner } 1931b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 193289d6fd36a26fdf068ceea90422dc2897e89700b5David Greene DEBUG(dbgs() << "INTO: " << *PBI->getParent()); 193389d6fd36a26fdf068ceea90422dc2897e89700b5David Greene DEBUG(dbgs() << *PBI->getParent()->getParent()); 1934b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner 1935b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // This basic block is probably dead. We know it has at least 1936b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner // one fewer predecessor. 1937b824512b8d733ccdfb1b1a2e8a6950605acf1c52Chris Lattner return true; 1938867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner} 1939867661ac8bd8e202bd4becf9b8e046bf69e150b1Chris Lattner 194065fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel// SimplifyTerminatorOnSelect - Simplifies a terminator by replacing it with a 194165fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel// branch to TrueBB if Cond is true or to FalseBB if Cond is false. 194265fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel// Takes care of updating the successors and removing the old terminator. 194365fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel// Also makes sure not to introduce new successors by assuming that edges to 194465fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel// non-successor TrueBBs and FalseBBs aren't reachable. 194565fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommelstatic bool SimplifyTerminatorOnSelect(TerminatorInst *OldTerm, Value *Cond, 194665fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel BasicBlock *TrueBB, BasicBlock *FalseBB){ 19477ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Remove any superfluous successor edges from the CFG. 19487ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // First, figure out which successors to preserve. 19497ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // If TrueBB and FalseBB are equal, only try to preserve one copy of that 19507ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // successor. 19517ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel BasicBlock *KeepEdge1 = TrueBB; 19527ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel BasicBlock *KeepEdge2 = TrueBB != FalseBB ? FalseBB : 0; 19537ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel 19547ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Then remove the rest. 195565fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel for (unsigned I = 0, E = OldTerm->getNumSuccessors(); I != E; ++I) { 195665fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel BasicBlock *Succ = OldTerm->getSuccessor(I); 19577ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Make sure only to keep exactly one copy of each edge. 19587ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel if (Succ == KeepEdge1) 19597ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel KeepEdge1 = 0; 19607ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel else if (Succ == KeepEdge2) 19617ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel KeepEdge2 = 0; 19627ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel else 196365fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel Succ->removePredecessor(OldTerm->getParent()); 19647ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel } 19657ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel 1966d3372b85e6008d85e30d13172ef0b1646b482b7eDevang Patel IRBuilder<> Builder(OldTerm); 1967d3372b85e6008d85e30d13172ef0b1646b482b7eDevang Patel Builder.SetCurrentDebugLocation(OldTerm->getDebugLoc()); 1968d3372b85e6008d85e30d13172ef0b1646b482b7eDevang Patel 19697ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Insert an appropriate new terminator. 19707ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel if ((KeepEdge1 == 0) && (KeepEdge2 == 0)) { 19717ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel if (TrueBB == FalseBB) 19727ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // We were only looking for one successor, and it was present. 19737ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Create an unconditional branch to it. 1974d3372b85e6008d85e30d13172ef0b1646b482b7eDevang Patel Builder.CreateBr(TrueBB); 19757ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel else 19767ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // We found both of the successors we were looking for. 19777ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Create a conditional branch sharing the condition of the select. 1978d3372b85e6008d85e30d13172ef0b1646b482b7eDevang Patel Builder.CreateCondBr(Cond, TrueBB, FalseBB); 19797ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel } else if (KeepEdge1 && (KeepEdge2 || TrueBB == FalseBB)) { 19807ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Neither of the selected blocks were successors, so this 198165fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel // terminator must be unreachable. 198265fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel new UnreachableInst(OldTerm->getContext(), OldTerm); 19837ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel } else { 19847ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // One of the selected values was a successor, but the other wasn't. 19857ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Insert an unconditional branch to the one that was found; 19867ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // the edge to the one that wasn't must be unreachable. 19877ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel if (KeepEdge1 == 0) 19887ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Only TrueBB was found. 1989d3372b85e6008d85e30d13172ef0b1646b482b7eDevang Patel Builder.CreateBr(TrueBB); 19907ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel else 19917ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel // Only FalseBB was found. 1992d3372b85e6008d85e30d13172ef0b1646b482b7eDevang Patel Builder.CreateBr(FalseBB); 19937ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel } 19947ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel 199565fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel EraseTerminatorInstAndDCECond(OldTerm); 19967ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel return true; 19977ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel} 19987ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel 1999f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel// SimplifySwitchOnSelect - Replaces 2000f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel// (switch (select cond, X, Y)) on constant X, Y 2001f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel// with a branch - conditional if X and Y lead to distinct BBs, 2002f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel// unconditional otherwise. 2003f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommelstatic bool SimplifySwitchOnSelect(SwitchInst *SI, SelectInst *Select) { 2004f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel // Check for constant integer values in the select. 2005f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel ConstantInt *TrueVal = dyn_cast<ConstantInt>(Select->getTrueValue()); 2006f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel ConstantInt *FalseVal = dyn_cast<ConstantInt>(Select->getFalseValue()); 2007f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel if (!TrueVal || !FalseVal) 2008f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel return false; 2009f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel 2010f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel // Find the relevant condition and destinations. 2011f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel Value *Condition = Select->getCondition(); 2012c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy BasicBlock *TrueBB = SI->findCaseValue(TrueVal).getCaseSuccessor(); 2013c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy BasicBlock *FalseBB = SI->findCaseValue(FalseVal).getCaseSuccessor(); 2014f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel 2015f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel // Perform the actual simplification. 2016f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel return SimplifyTerminatorOnSelect(SI, Condition, TrueBB, FalseBB); 2017f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel} 2018f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel 201965fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel// SimplifyIndirectBrOnSelect - Replaces 202065fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel// (indirectbr (select cond, blockaddress(@fn, BlockA), 202165fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel// blockaddress(@fn, BlockB))) 202265fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel// with 202365fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel// (br cond, BlockA, BlockB). 202465fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommelstatic bool SimplifyIndirectBrOnSelect(IndirectBrInst *IBI, SelectInst *SI) { 202565fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel // Check that both operands of the select are block addresses. 202665fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel BlockAddress *TBA = dyn_cast<BlockAddress>(SI->getTrueValue()); 202765fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel BlockAddress *FBA = dyn_cast<BlockAddress>(SI->getFalseValue()); 202865fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel if (!TBA || !FBA) 202965fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel return false; 203065fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel 203165fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel // Extract the actual blocks. 203265fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel BasicBlock *TrueBB = TBA->getBasicBlock(); 203365fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel BasicBlock *FalseBB = FBA->getBasicBlock(); 203465fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel 203565fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel // Perform the actual simplification. 203665fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel return SimplifyTerminatorOnSelect(IBI, SI->getCondition(), TrueBB, FalseBB); 203765fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel} 203865fdded3197461232d8428af7ddd0107e4a9f946Frits van Bommel 203961c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// TryToSimplifyUncondBranchWithICmpInIt - This is called when we find an icmp 204061c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// instruction (a seteq/setne with a constant) as the only instruction in a 204161c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// block that ends with an uncond branch. We are looking for a very specific 204261c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// pattern that occurs when "A == 1 || A == 2 || A == 3" gets simplified. In 204361c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// this case, we merge the first two "or's of icmp" into a switch, but then the 204461c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// default value goes to an uncond block with a seteq in it, we get something 204561c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// like: 204661c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// 204761c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// switch i8 %A, label %DEFAULT [ i8 1, label %end i8 2, label %end ] 204861c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// DEFAULT: 204961c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// %tmp = icmp eq i8 %A, 92 205061c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// br label %end 205161c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// end: 205261c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// ... = phi i1 [ true, %entry ], [ %tmp, %DEFAULT ], [ true, %entry ] 205361c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// 205461c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// We prefer to split the edge to 'end' so that there is a true/false entry to 205561c77449c772427a0d2559fca500debd93c7f97cChris Lattner/// the PHI, merging the third icmp into the switch. 2056302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattnerstatic bool TryToSimplifyUncondBranchWithICmpInIt(ICmpInst *ICI, 2057a23812cfbd23604d2fc103cf232cde8fa270a491Devang Patel const TargetData *TD, 2058a23812cfbd23604d2fc103cf232cde8fa270a491Devang Patel IRBuilder<> &Builder) { 205961c77449c772427a0d2559fca500debd93c7f97cChris Lattner BasicBlock *BB = ICI->getParent(); 2060a23812cfbd23604d2fc103cf232cde8fa270a491Devang Patel 206161c77449c772427a0d2559fca500debd93c7f97cChris Lattner // If the block has any PHIs in it or the icmp has multiple uses, it is too 206261c77449c772427a0d2559fca500debd93c7f97cChris Lattner // complex. 206361c77449c772427a0d2559fca500debd93c7f97cChris Lattner if (isa<PHINode>(BB->begin()) || !ICI->hasOneUse()) return false; 206461c77449c772427a0d2559fca500debd93c7f97cChris Lattner 206561c77449c772427a0d2559fca500debd93c7f97cChris Lattner Value *V = ICI->getOperand(0); 206661c77449c772427a0d2559fca500debd93c7f97cChris Lattner ConstantInt *Cst = cast<ConstantInt>(ICI->getOperand(1)); 206761c77449c772427a0d2559fca500debd93c7f97cChris Lattner 206861c77449c772427a0d2559fca500debd93c7f97cChris Lattner // The pattern we're looking for is where our only predecessor is a switch on 206961c77449c772427a0d2559fca500debd93c7f97cChris Lattner // 'V' and this block is the default case for the switch. In this case we can 207061c77449c772427a0d2559fca500debd93c7f97cChris Lattner // fold the compared value into the switch to simplify things. 207161c77449c772427a0d2559fca500debd93c7f97cChris Lattner BasicBlock *Pred = BB->getSinglePredecessor(); 207261c77449c772427a0d2559fca500debd93c7f97cChris Lattner if (Pred == 0 || !isa<SwitchInst>(Pred->getTerminator())) return false; 207361c77449c772427a0d2559fca500debd93c7f97cChris Lattner 207461c77449c772427a0d2559fca500debd93c7f97cChris Lattner SwitchInst *SI = cast<SwitchInst>(Pred->getTerminator()); 207561c77449c772427a0d2559fca500debd93c7f97cChris Lattner if (SI->getCondition() != V) 207661c77449c772427a0d2559fca500debd93c7f97cChris Lattner return false; 207761c77449c772427a0d2559fca500debd93c7f97cChris Lattner 207861c77449c772427a0d2559fca500debd93c7f97cChris Lattner // If BB is reachable on a non-default case, then we simply know the value of 207961c77449c772427a0d2559fca500debd93c7f97cChris Lattner // V in this block. Substitute it and constant fold the icmp instruction 208061c77449c772427a0d2559fca500debd93c7f97cChris Lattner // away. 208161c77449c772427a0d2559fca500debd93c7f97cChris Lattner if (SI->getDefaultDest() != BB) { 208261c77449c772427a0d2559fca500debd93c7f97cChris Lattner ConstantInt *VVal = SI->findCaseDest(BB); 208361c77449c772427a0d2559fca500debd93c7f97cChris Lattner assert(VVal && "Should have a unique destination value"); 208461c77449c772427a0d2559fca500debd93c7f97cChris Lattner ICI->setOperand(0, VVal); 208561c77449c772427a0d2559fca500debd93c7f97cChris Lattner 2086302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner if (Value *V = SimplifyInstruction(ICI, TD)) { 2087302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner ICI->replaceAllUsesWith(V); 208861c77449c772427a0d2559fca500debd93c7f97cChris Lattner ICI->eraseFromParent(); 208961c77449c772427a0d2559fca500debd93c7f97cChris Lattner } 209061c77449c772427a0d2559fca500debd93c7f97cChris Lattner // BB is now empty, so it is likely to simplify away. 209161c77449c772427a0d2559fca500debd93c7f97cChris Lattner return SimplifyCFG(BB) | true; 209261c77449c772427a0d2559fca500debd93c7f97cChris Lattner } 209361c77449c772427a0d2559fca500debd93c7f97cChris Lattner 2094abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner // Ok, the block is reachable from the default dest. If the constant we're 2095abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner // comparing exists in one of the other edges, then we can constant fold ICI 2096abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner // and zap it. 20973d3abe0852d5f499bed7ab014519dd582a0a795dStepan Dyatkovskiy if (SI->findCaseValue(Cst) != SI->case_default()) { 2098abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner Value *V; 2099abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner if (ICI->getPredicate() == ICmpInst::ICMP_EQ) 2100abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner V = ConstantInt::getFalse(BB->getContext()); 2101abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner else 2102abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner V = ConstantInt::getTrue(BB->getContext()); 2103abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner 2104abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner ICI->replaceAllUsesWith(V); 2105abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner ICI->eraseFromParent(); 2106abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner // BB is now empty, so it is likely to simplify away. 2107abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner return SimplifyCFG(BB) | true; 2108abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner } 2109abf706703fcbcde8fdc69b1bbdfb34e874813107Chris Lattner 211061c77449c772427a0d2559fca500debd93c7f97cChris Lattner // The use of the icmp has to be in the 'end' block, by the only PHI node in 211161c77449c772427a0d2559fca500debd93c7f97cChris Lattner // the block. 211261c77449c772427a0d2559fca500debd93c7f97cChris Lattner BasicBlock *SuccBlock = BB->getTerminator()->getSuccessor(0); 211361c77449c772427a0d2559fca500debd93c7f97cChris Lattner PHINode *PHIUse = dyn_cast<PHINode>(ICI->use_back()); 211461c77449c772427a0d2559fca500debd93c7f97cChris Lattner if (PHIUse == 0 || PHIUse != &SuccBlock->front() || 211561c77449c772427a0d2559fca500debd93c7f97cChris Lattner isa<PHINode>(++BasicBlock::iterator(PHIUse))) 211661c77449c772427a0d2559fca500debd93c7f97cChris Lattner return false; 211761c77449c772427a0d2559fca500debd93c7f97cChris Lattner 211861c77449c772427a0d2559fca500debd93c7f97cChris Lattner // If the icmp is a SETEQ, then the default dest gets false, the new edge gets 211961c77449c772427a0d2559fca500debd93c7f97cChris Lattner // true in the PHI. 212061c77449c772427a0d2559fca500debd93c7f97cChris Lattner Constant *DefaultCst = ConstantInt::getTrue(BB->getContext()); 212161c77449c772427a0d2559fca500debd93c7f97cChris Lattner Constant *NewCst = ConstantInt::getFalse(BB->getContext()); 212261c77449c772427a0d2559fca500debd93c7f97cChris Lattner 212361c77449c772427a0d2559fca500debd93c7f97cChris Lattner if (ICI->getPredicate() == ICmpInst::ICMP_EQ) 212461c77449c772427a0d2559fca500debd93c7f97cChris Lattner std::swap(DefaultCst, NewCst); 212561c77449c772427a0d2559fca500debd93c7f97cChris Lattner 212661c77449c772427a0d2559fca500debd93c7f97cChris Lattner // Replace ICI (which is used by the PHI for the default value) with true or 212761c77449c772427a0d2559fca500debd93c7f97cChris Lattner // false depending on if it is EQ or NE. 212861c77449c772427a0d2559fca500debd93c7f97cChris Lattner ICI->replaceAllUsesWith(DefaultCst); 212961c77449c772427a0d2559fca500debd93c7f97cChris Lattner ICI->eraseFromParent(); 213061c77449c772427a0d2559fca500debd93c7f97cChris Lattner 213161c77449c772427a0d2559fca500debd93c7f97cChris Lattner // Okay, the switch goes to this block on a default value. Add an edge from 213261c77449c772427a0d2559fca500debd93c7f97cChris Lattner // the switch to the merge point on the compared value. 213361c77449c772427a0d2559fca500debd93c7f97cChris Lattner BasicBlock *NewBB = BasicBlock::Create(BB->getContext(), "switch.edge", 213461c77449c772427a0d2559fca500debd93c7f97cChris Lattner BB->getParent(), BB); 213561c77449c772427a0d2559fca500debd93c7f97cChris Lattner SI->addCase(Cst, NewBB); 213661c77449c772427a0d2559fca500debd93c7f97cChris Lattner 213761c77449c772427a0d2559fca500debd93c7f97cChris Lattner // NewBB branches to the phi block, add the uncond branch and the phi entry. 2138a23812cfbd23604d2fc103cf232cde8fa270a491Devang Patel Builder.SetInsertPoint(NewBB); 2139a23812cfbd23604d2fc103cf232cde8fa270a491Devang Patel Builder.SetCurrentDebugLocation(SI->getDebugLoc()); 2140a23812cfbd23604d2fc103cf232cde8fa270a491Devang Patel Builder.CreateBr(SuccBlock); 214161c77449c772427a0d2559fca500debd93c7f97cChris Lattner PHIUse->addIncoming(NewCst, NewBB); 214261c77449c772427a0d2559fca500debd93c7f97cChris Lattner return true; 214361c77449c772427a0d2559fca500debd93c7f97cChris Lattner} 214461c77449c772427a0d2559fca500debd93c7f97cChris Lattner 214597fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner/// SimplifyBranchOnICmpChain - The specified branch is a conditional branch. 214697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner/// Check to see if it is branching on an or/and chain of icmp instructions, and 214797fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner/// fold it into a switch instruction if so. 214802dd5418d29c2a43f225df887923e144e12e7ec6Devang Patelstatic bool SimplifyBranchOnICmpChain(BranchInst *BI, const TargetData *TD, 214902dd5418d29c2a43f225df887923e144e12e7ec6Devang Patel IRBuilder<> &Builder) { 215097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner Instruction *Cond = dyn_cast<Instruction>(BI->getCondition()); 215197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner if (Cond == 0) return false; 215297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 215397fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 215497fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // Change br (X == 0 | X == 1), T, F into a switch instruction. 215597fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // If this is a bunch of seteq's or'd together, or if it's a bunch of 215697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // 'setne's and'ed together, collect them. 215797fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner Value *CompVal = 0; 215897fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner std::vector<ConstantInt*> Values; 215997fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner bool TrueWhenEqual = true; 216097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner Value *ExtraCase = 0; 216133828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer unsigned UsedICmps = 0; 216297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 216397fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner if (Cond->getOpcode() == Instruction::Or) { 216433828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer CompVal = GatherConstantCompares(Cond, Values, ExtraCase, TD, true, 216533828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer UsedICmps); 216697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner } else if (Cond->getOpcode() == Instruction::And) { 216733828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer CompVal = GatherConstantCompares(Cond, Values, ExtraCase, TD, false, 216833828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer UsedICmps); 216997fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner TrueWhenEqual = false; 217097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner } 217197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 217297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // If we didn't have a multiply compared value, fail. 217397fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner if (CompVal == 0) return false; 217497fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 217533828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer // Avoid turning single icmps into a switch. 217633828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer if (UsedICmps <= 1) 217733828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer return false; 217833828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer 217997fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // There might be duplicate constants in the list, which the switch 218097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // instruction can't handle, remove them now. 218197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner array_pod_sort(Values.begin(), Values.end(), ConstantIntSortPredicate); 218297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner Values.erase(std::unique(Values.begin(), Values.end()), Values.end()); 218397fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 218497fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // If Extra was used, we require at least two switch values to do the 218597fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // transformation. A switch with one value is just an cond branch. 218697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner if (ExtraCase && Values.size() < 2) return false; 218797fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 218897fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // Figure out which block is which destination. 218997fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner BasicBlock *DefaultBB = BI->getSuccessor(1); 219097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner BasicBlock *EdgeBB = BI->getSuccessor(0); 219197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner if (!TrueWhenEqual) std::swap(DefaultBB, EdgeBB); 219297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 219397fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner BasicBlock *BB = BI->getParent(); 219497fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 2195302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner DEBUG(dbgs() << "Converting 'icmp' chain with " << Values.size() 2196117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner << " cases into SWITCH. BB is:\n" << *BB); 2197117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner 219897fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // If there are any extra values that couldn't be folded into the switch 219997fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // then we evaluate them with an explicit branch first. Split the block 220097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // right before the condbr to handle it. 220197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner if (ExtraCase) { 220297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner BasicBlock *NewBB = BB->splitBasicBlock(BI, "switch.early.test"); 220397fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // Remove the uncond branch added to the old block. 220497fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner TerminatorInst *OldTI = BB->getTerminator(); 220502dd5418d29c2a43f225df887923e144e12e7ec6Devang Patel Builder.SetInsertPoint(OldTI); 220602dd5418d29c2a43f225df887923e144e12e7ec6Devang Patel 2207117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner if (TrueWhenEqual) 220802dd5418d29c2a43f225df887923e144e12e7ec6Devang Patel Builder.CreateCondBr(ExtraCase, EdgeBB, NewBB); 2209117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner else 221002dd5418d29c2a43f225df887923e144e12e7ec6Devang Patel Builder.CreateCondBr(ExtraCase, NewBB, EdgeBB); 2211117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner 221297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner OldTI->eraseFromParent(); 221397bd89ece3fff29ab7e0eaa38f85183abd962f42Chris Lattner 221497bd89ece3fff29ab7e0eaa38f85183abd962f42Chris Lattner // If there are PHI nodes in EdgeBB, then we need to add a new entry to them 221597bd89ece3fff29ab7e0eaa38f85183abd962f42Chris Lattner // for the edge we just added. 22166de0a28dfb84095ebd7775f371dd4085cf955076Chris Lattner AddPredecessorToBlock(EdgeBB, BB, NewBB); 2217302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner 2218302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner DEBUG(dbgs() << " ** 'icmp' chain unhandled condition: " << *ExtraCase 2219302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner << "\nEXTRABB = " << *BB); 222097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner BB = NewBB; 222197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner } 222202dd5418d29c2a43f225df887923e144e12e7ec6Devang Patel 222302dd5418d29c2a43f225df887923e144e12e7ec6Devang Patel Builder.SetInsertPoint(BI); 222497fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // Convert pointer to int before we switch. 222597fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner if (CompVal->getType()->isPointerTy()) { 222697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner assert(TD && "Cannot switch on pointer without TargetData"); 222702dd5418d29c2a43f225df887923e144e12e7ec6Devang Patel CompVal = Builder.CreatePtrToInt(CompVal, 222802dd5418d29c2a43f225df887923e144e12e7ec6Devang Patel TD->getIntPtrType(CompVal->getContext()), 222902dd5418d29c2a43f225df887923e144e12e7ec6Devang Patel "magicptr"); 223097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner } 223197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 223297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // Create the new switch instruction now. 223302dd5418d29c2a43f225df887923e144e12e7ec6Devang Patel SwitchInst *New = Builder.CreateSwitch(CompVal, DefaultBB, Values.size()); 2234d80e8ed2fa20c7ad51af49c3b2650525edbdcd08Devang Patel 223597fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // Add all of the 'cases' to the switch instruction. 223697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner for (unsigned i = 0, e = Values.size(); i != e; ++i) 223797fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner New->addCase(Values[i], EdgeBB); 223897fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 223997fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // We added edges from PI to the EdgeBB. As such, if there were any 224097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // PHI nodes in EdgeBB, they need entries to be added corresponding to 224197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // the number of edges added. 224297fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner for (BasicBlock::iterator BBI = EdgeBB->begin(); 224397fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner isa<PHINode>(BBI); ++BBI) { 224497fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner PHINode *PN = cast<PHINode>(BBI); 224597fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner Value *InVal = PN->getIncomingValueForBlock(BB); 224697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner for (unsigned i = 0, e = Values.size()-1; i != e; ++i) 224797fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner PN->addIncoming(InVal, BB); 224897fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner } 224997fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 225097fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner // Erase the old branch instruction. 225197fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner EraseTerminatorInstAndDCECond(BI); 2252117f8cffc5499217ff8824eb0d6a0f6b1b78d96eChris Lattner 2253302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner DEBUG(dbgs() << " ** 'icmp' chain result is:\n" << *BB << '\n'); 225497fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner return true; 225597fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner} 225697fdb898f5350e51bb40afd58e3f4e1d18e348dbChris Lattner 2257ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sandsbool SimplifyCFGOpt::SimplifyResume(ResumeInst *RI, IRBuilder<> &Builder) { 2258ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands // If this is a trivial landing pad that just continues unwinding the caught 2259ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands // exception then zap the landing pad, turning its invokes into calls. 2260ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands BasicBlock *BB = RI->getParent(); 2261ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands LandingPadInst *LPInst = dyn_cast<LandingPadInst>(BB->getFirstNonPHI()); 2262ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands if (RI->getValue() != LPInst) 2263ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands // Not a landing pad, or the resume is not unwinding the exception that 2264ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands // caused control to branch here. 2265ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands return false; 2266ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands 2267ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands // Check that there are no other instructions except for debug intrinsics. 2268ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands BasicBlock::iterator I = LPInst, E = RI; 2269ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands while (++I != E) 2270ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands if (!isa<DbgInfoIntrinsic>(I)) 2271ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands return false; 2272ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands 2273ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands // Turn all invokes that unwind here into calls and delete the basic block. 2274ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB); PI != PE;) { 2275ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands InvokeInst *II = cast<InvokeInst>((*PI++)->getTerminator()); 2276ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands SmallVector<Value*, 8> Args(II->op_begin(), II->op_end() - 3); 2277ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands // Insert a call instruction before the invoke. 2278ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands CallInst *Call = CallInst::Create(II->getCalledValue(), Args, "", II); 2279ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands Call->takeName(II); 2280ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands Call->setCallingConv(II->getCallingConv()); 2281ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands Call->setAttributes(II->getAttributes()); 2282ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands Call->setDebugLoc(II->getDebugLoc()); 2283ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands 2284ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands // Anything that used the value produced by the invoke instruction now uses 2285ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands // the value produced by the call instruction. Note that we do this even 2286ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands // for void functions and calls with no uses so that the callgraph edge is 2287ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands // updated. 2288ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands II->replaceAllUsesWith(Call); 2289ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands BB->removePredecessor(II->getParent()); 2290ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands 2291ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands // Insert a branch to the normal destination right before the invoke. 2292ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands BranchInst::Create(II->getNormalDest(), II); 2293ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands 2294ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands // Finally, delete the invoke instruction! 2295ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands II->eraseFromParent(); 2296ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands } 2297ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands 2298ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands // The landingpad is now unreachable. Zap it. 2299ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands BB->eraseFromParent(); 2300ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands return true; 2301ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands} 2302ad99ef8bf59adf151ac217e3b2ae6abec41f76e6Duncan Sands 2303176ec40cb18c51c14fccbb38ee0db5deafb6baa9Devang Patelbool SimplifyCFGOpt::SimplifyReturn(ReturnInst *RI, IRBuilder<> &Builder) { 23043d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *BB = RI->getParent(); 23053d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (!BB->getFirstNonPHIOrDbg()->isTerminator()) return false; 23063d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23073d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Find predecessors that end with branches. 23083d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SmallVector<BasicBlock*, 8> UncondBranchPreds; 23093d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SmallVector<BranchInst*, 8> CondBranchPreds; 23103d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) { 23113d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *P = *PI; 23123d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner TerminatorInst *PTI = P->getTerminator(); 23133d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BranchInst *BI = dyn_cast<BranchInst>(PTI)) { 23143d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BI->isUnconditional()) 23153d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner UncondBranchPreds.push_back(P); 23163d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner else 23173d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner CondBranchPreds.push_back(BI); 23183d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 23193d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 23203d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23213d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If we found some, do the transformation! 2322c3f507f98a0747bd256e1c13536060b6fc5c4b62Evan Cheng if (!UncondBranchPreds.empty() && DupRet) { 23233d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner while (!UncondBranchPreds.empty()) { 23243d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *Pred = UncondBranchPreds.pop_back_val(); 23253d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner DEBUG(dbgs() << "FOLDING: " << *BB 23263d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner << "INTO UNCOND BRANCH PRED: " << *Pred); 2327c3f507f98a0747bd256e1c13536060b6fc5c4b62Evan Cheng (void)FoldReturnIntoUncondBranch(RI, BB, Pred); 23283d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 23293d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23303d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If we eliminated all predecessors of the block, delete the block now. 23313d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (pred_begin(BB) == pred_end(BB)) 23323d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // We know there are no successors, so just nuke the block. 23333d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BB->eraseFromParent(); 23343d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 233501d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner return true; 233601d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner } 23373d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23383d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Check out all of the conditional branches going to this return 23393d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // instruction. If any of them just select between returns, change the 23403d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // branch itself into a select/return pair. 23413d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner while (!CondBranchPreds.empty()) { 23423d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BranchInst *BI = CondBranchPreds.pop_back_val(); 23433d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23443d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Check to see if the non-BB successor is also a return block. 23453d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (isa<ReturnInst>(BI->getSuccessor(0)->getTerminator()) && 23463d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner isa<ReturnInst>(BI->getSuccessor(1)->getTerminator()) && 2347176ec40cb18c51c14fccbb38ee0db5deafb6baa9Devang Patel SimplifyCondBranchToTwoReturns(BI, Builder)) 23483d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return true; 23493d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 23503d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return false; 23513d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner} 235201d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner 23533d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattnerbool SimplifyCFGOpt::SimplifyUnreachable(UnreachableInst *UI) { 23543d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *BB = UI->getParent(); 23553d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23563d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner bool Changed = false; 23573d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23583d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If there are any instructions immediately before the unreachable that can 23593d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // be removed, do so. 23603d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner while (UI != BB->begin()) { 23613d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock::iterator BBI = UI; 23623d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner --BBI; 23638176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman // Do not delete instructions that can have side effects which might cause 23648176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman // the unreachable to not be reachable; specifically, calls and volatile 23658176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman // operations may have this effect. 23663d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (isa<CallInst>(BBI) && !isa<DbgInfoIntrinsic>(BBI)) break; 23678176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman 23688176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman if (BBI->mayHaveSideEffects()) { 23698176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman if (StoreInst *SI = dyn_cast<StoreInst>(BBI)) { 23708176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman if (SI->isVolatile()) 23718176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman break; 23728176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman } else if (LoadInst *LI = dyn_cast<LoadInst>(BBI)) { 23738176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman if (LI->isVolatile()) 23748176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman break; 23758176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman } else if (AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(BBI)) { 23768176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman if (RMWI->isVolatile()) 23778176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman break; 23788176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman } else if (AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(BBI)) { 23798176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman if (CXI->isVolatile()) 23808176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman break; 23818176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman } else if (!isa<FenceInst>(BBI) && !isa<VAArgInst>(BBI) && 23828176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman !isa<LandingPadInst>(BBI)) { 23833d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner break; 23848176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman } 238523b49ba6d55972fdffdfd4ed37edcf067bb60f3cBill Wendling // Note that deleting LandingPad's here is in fact okay, although it 238623b49ba6d55972fdffdfd4ed37edcf067bb60f3cBill Wendling // involves a bit of subtle reasoning. If this inst is a LandingPad, 238723b49ba6d55972fdffdfd4ed37edcf067bb60f3cBill Wendling // all the predecessors of this block will be the unwind edges of Invokes, 238823b49ba6d55972fdffdfd4ed37edcf067bb60f3cBill Wendling // and we can therefore guarantee this block will be erased. 23898176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman } 23908176388d65083339efdfa5bee63e620c6bd05aa1Eli Friedman 23912adc5b6a17268834b08fda444b1a84550e8c5ae8Eli Friedman // Delete this instruction (any uses are guaranteed to be dead) 23922adc5b6a17268834b08fda444b1a84550e8c5ae8Eli Friedman if (!BBI->use_empty()) 23932adc5b6a17268834b08fda444b1a84550e8c5ae8Eli Friedman BBI->replaceAllUsesWith(UndefValue::get(BBI->getType())); 2394302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner BBI->eraseFromParent(); 23953d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Changed = true; 23963d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 23973d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 23983d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the unreachable instruction is the first in the block, take a gander 23993d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // at all of the predecessors of this instruction, and simplify them. 24003d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (&BB->front() != UI) return Changed; 24013d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 24023d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SmallVector<BasicBlock*, 8> Preds(pred_begin(BB), pred_end(BB)); 24033d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (unsigned i = 0, e = Preds.size(); i != e; ++i) { 24043d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner TerminatorInst *TI = Preds[i]->getTerminator(); 24051aa89a2f91948993a5d535e3d59513af7f3e7dc9Devang Patel IRBuilder<> Builder(TI); 24063d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BranchInst *BI = dyn_cast<BranchInst>(TI)) { 24073d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BI->isUnconditional()) { 24083d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BI->getSuccessor(0) == BB) { 24093d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner new UnreachableInst(TI->getContext(), TI); 24103d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner TI->eraseFromParent(); 24113d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Changed = true; 24123d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 24133d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } else { 24143d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BI->getSuccessor(0) == BB) { 24151aa89a2f91948993a5d535e3d59513af7f3e7dc9Devang Patel Builder.CreateBr(BI->getSuccessor(1)); 24163d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner EraseTerminatorInstAndDCECond(BI); 24173d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } else if (BI->getSuccessor(1) == BB) { 24181aa89a2f91948993a5d535e3d59513af7f3e7dc9Devang Patel Builder.CreateBr(BI->getSuccessor(0)); 24193d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner EraseTerminatorInstAndDCECond(BI); 24203d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Changed = true; 242107e6e56f57e8781a8d7bc601cc9034a3741d84c2Anton Korobeynikov } 242219831ec8531b0710629c1b0a8c0323e70ae0ef07Chris Lattner } 24233d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { 24243d3abe0852d5f499bed7ab014519dd582a0a795dStepan Dyatkovskiy for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end(); 2425c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy i != e; ++i) 2426c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy if (i.getCaseSuccessor() == BB) { 24273d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BB->removePredecessor(SI->getParent()); 24283d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SI->removeCase(i); 24293d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner --i; --e; 24303d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Changed = true; 24313d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 24323d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the default value is unreachable, figure out the most popular 24333d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // destination and make it the default. 243424473120a253a05f3601cd3373403b47e6d03d41Stepan Dyatkovskiy if (SI->getDefaultDest() == BB) { 2435b1a6eab655adce4f84a15afa9092e814b9aaabdaEli Friedman std::map<BasicBlock*, std::pair<unsigned, unsigned> > Popularity; 24363d3abe0852d5f499bed7ab014519dd582a0a795dStepan Dyatkovskiy for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end(); 2437c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy i != e; ++i) { 24389d5231022283ff20b0291eb5711a449de262d3feNick Lewycky std::pair<unsigned, unsigned> &entry = 2439c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy Popularity[i.getCaseSuccessor()]; 2440b1a6eab655adce4f84a15afa9092e814b9aaabdaEli Friedman if (entry.first == 0) { 2441b1a6eab655adce4f84a15afa9092e814b9aaabdaEli Friedman entry.first = 1; 2442c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy entry.second = i.getCaseIndex(); 2443b1a6eab655adce4f84a15afa9092e814b9aaabdaEli Friedman } else { 2444b1a6eab655adce4f84a15afa9092e814b9aaabdaEli Friedman entry.first++; 2445b1a6eab655adce4f84a15afa9092e814b9aaabdaEli Friedman } 2446b1a6eab655adce4f84a15afa9092e814b9aaabdaEli Friedman } 2447b1a6eab655adce4f84a15afa9092e814b9aaabdaEli Friedman 24483d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Find the most popular block. 24493d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner unsigned MaxPop = 0; 2450b1a6eab655adce4f84a15afa9092e814b9aaabdaEli Friedman unsigned MaxIndex = 0; 24513d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *MaxBlock = 0; 2452b1a6eab655adce4f84a15afa9092e814b9aaabdaEli Friedman for (std::map<BasicBlock*, std::pair<unsigned, unsigned> >::iterator 24533d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner I = Popularity.begin(), E = Popularity.end(); I != E; ++I) { 2454b1a6eab655adce4f84a15afa9092e814b9aaabdaEli Friedman if (I->second.first > MaxPop || 2455b1a6eab655adce4f84a15afa9092e814b9aaabdaEli Friedman (I->second.first == MaxPop && MaxIndex > I->second.second)) { 2456b1a6eab655adce4f84a15afa9092e814b9aaabdaEli Friedman MaxPop = I->second.first; 2457b1a6eab655adce4f84a15afa9092e814b9aaabdaEli Friedman MaxIndex = I->second.second; 24583d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner MaxBlock = I->first; 24593d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 24603d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 24613d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (MaxBlock) { 24623d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Make this the new default, allowing us to delete any explicit 24633d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // edges to it. 246424473120a253a05f3601cd3373403b47e6d03d41Stepan Dyatkovskiy SI->setDefaultDest(MaxBlock); 24653d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Changed = true; 2466ffba5821eee7b7a6139f9dfb06b8d306bf344a9dChris Lattner 24673d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If MaxBlock has phinodes in it, remove MaxPop-1 entries from 24683d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // it. 24693d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (isa<PHINode>(MaxBlock->begin())) 24703d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (unsigned i = 0; i != MaxPop-1; ++i) 24713d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner MaxBlock->removePredecessor(SI->getParent()); 24723d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 24733d3abe0852d5f499bed7ab014519dd582a0a795dStepan Dyatkovskiy for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end(); 2474c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy i != e; ++i) 2475c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy if (i.getCaseSuccessor() == MaxBlock) { 24763d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SI->removeCase(i); 24773d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner --i; --e; 24783d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 247919831ec8531b0710629c1b0a8c0323e70ae0ef07Chris Lattner } 248019831ec8531b0710629c1b0a8c0323e70ae0ef07Chris Lattner } 24813d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } else if (InvokeInst *II = dyn_cast<InvokeInst>(TI)) { 24823d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (II->getUnwindDest() == BB) { 24833d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Convert the invoke to a call instruction. This would be a good 24843d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // place to note that the call does not throw though. 24851aa89a2f91948993a5d535e3d59513af7f3e7dc9Devang Patel BranchInst *BI = Builder.CreateBr(II->getNormalDest()); 24863d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner II->removeFromParent(); // Take out of symbol table 24873d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 24883d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Insert the call now... 24893d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SmallVector<Value*, 8> Args(II->op_begin(), II->op_end()-3); 24901aa89a2f91948993a5d535e3d59513af7f3e7dc9Devang Patel Builder.SetInsertPoint(BI); 24911aa89a2f91948993a5d535e3d59513af7f3e7dc9Devang Patel CallInst *CI = Builder.CreateCall(II->getCalledValue(), 2492a3efbb15ddd5aa9006564cd79086723640084878Jay Foad Args, II->getName()); 24939a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner CI->setCallingConv(II->getCallingConv()); 24949a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner CI->setAttributes(II->getAttributes()); 24953d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the invoke produced a value, the call does now instead. 24969a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner II->replaceAllUsesWith(CI); 24979a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner delete II; 24989a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner Changed = true; 24999a2b72acc9651be04c12ba713702ddc5d449ce72Chris Lattner } 2500e14ea0804afba2ac5824507571a220d05b0aa21dChris Lattner } 25013d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 25023d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 25033d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If this block is now dead, remove it. 25043d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (pred_begin(BB) == pred_end(BB) && 25053d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BB != &BB->getParent()->getEntryBlock()) { 25063d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // We know there are no successors, so just nuke the block. 25073d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BB->eraseFromParent(); 25083d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return true; 25093d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 25108e509dd5e81e92a466580ab4022994079952cca9Chris Lattner 25113d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return Changed; 25123d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner} 25138e509dd5e81e92a466580ab4022994079952cca9Chris Lattner 251456442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer/// TurnSwitchRangeIntoICmp - Turns a switch with that contains only a 251556442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer/// integer range comparison into a sub, an icmp and a branch. 2516007349dafda47296177fd7481aff9764d4179f42Devang Patelstatic bool TurnSwitchRangeIntoICmp(SwitchInst *SI, IRBuilder<> &Builder) { 251724473120a253a05f3601cd3373403b47e6d03d41Stepan Dyatkovskiy assert(SI->getNumCases() > 1 && "Degenerate switch?"); 2518042b27f40e4b1dcae70c0e98c3b4f5760dd8fa9bBenjamin Kramer 2519042b27f40e4b1dcae70c0e98c3b4f5760dd8fa9bBenjamin Kramer // Make sure all cases point to the same destination and gather the values. 2520042b27f40e4b1dcae70c0e98c3b4f5760dd8fa9bBenjamin Kramer SmallVector<ConstantInt *, 16> Cases; 25213d3abe0852d5f499bed7ab014519dd582a0a795dStepan Dyatkovskiy SwitchInst::CaseIt I = SI->case_begin(); 2522c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy Cases.push_back(I.getCaseValue()); 2523c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy SwitchInst::CaseIt PrevI = I++; 25243d3abe0852d5f499bed7ab014519dd582a0a795dStepan Dyatkovskiy for (SwitchInst::CaseIt E = SI->case_end(); I != E; PrevI = I++) { 2525c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy if (PrevI.getCaseSuccessor() != I.getCaseSuccessor()) 252656442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer return false; 2527c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy Cases.push_back(I.getCaseValue()); 2528042b27f40e4b1dcae70c0e98c3b4f5760dd8fa9bBenjamin Kramer } 252924473120a253a05f3601cd3373403b47e6d03d41Stepan Dyatkovskiy assert(Cases.size() == SI->getNumCases() && "Not all cases gathered"); 2530042b27f40e4b1dcae70c0e98c3b4f5760dd8fa9bBenjamin Kramer 2531042b27f40e4b1dcae70c0e98c3b4f5760dd8fa9bBenjamin Kramer // Sort the case values, then check if they form a range we can transform. 2532042b27f40e4b1dcae70c0e98c3b4f5760dd8fa9bBenjamin Kramer array_pod_sort(Cases.begin(), Cases.end(), ConstantIntSortPredicate); 2533042b27f40e4b1dcae70c0e98c3b4f5760dd8fa9bBenjamin Kramer for (unsigned I = 1, E = Cases.size(); I != E; ++I) { 2534042b27f40e4b1dcae70c0e98c3b4f5760dd8fa9bBenjamin Kramer if (Cases[I-1]->getValue() != Cases[I]->getValue()+1) 2535042b27f40e4b1dcae70c0e98c3b4f5760dd8fa9bBenjamin Kramer return false; 2536042b27f40e4b1dcae70c0e98c3b4f5760dd8fa9bBenjamin Kramer } 253756442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer 2538042b27f40e4b1dcae70c0e98c3b4f5760dd8fa9bBenjamin Kramer Constant *Offset = ConstantExpr::getNeg(Cases.back()); 253924473120a253a05f3601cd3373403b47e6d03d41Stepan Dyatkovskiy Constant *NumCases = ConstantInt::get(Offset->getType(), SI->getNumCases()); 254056442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer 254133828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer Value *Sub = SI->getCondition(); 254233828bcb24176aae72afac0e4953e4b7f9560ef1Benjamin Kramer if (!Offset->isNullValue()) 25431f5812bd995afc97d32061c532aaa0aedbead9ffDevang Patel Sub = Builder.CreateAdd(Sub, Offset, Sub->getName()+".off"); 25441f5812bd995afc97d32061c532aaa0aedbead9ffDevang Patel Value *Cmp = Builder.CreateICmpULT(Sub, NumCases, "switch"); 2545c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy Builder.CreateCondBr( 25463d3abe0852d5f499bed7ab014519dd582a0a795dStepan Dyatkovskiy Cmp, SI->case_begin().getCaseSuccessor(), SI->getDefaultDest()); 254756442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer 254856442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer // Prune obsolete incoming values off the successor's PHI nodes. 25493d3abe0852d5f499bed7ab014519dd582a0a795dStepan Dyatkovskiy for (BasicBlock::iterator BBI = SI->case_begin().getCaseSuccessor()->begin(); 255056442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer isa<PHINode>(BBI); ++BBI) { 255124473120a253a05f3601cd3373403b47e6d03d41Stepan Dyatkovskiy for (unsigned I = 0, E = SI->getNumCases()-1; I != E; ++I) 255256442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer cast<PHINode>(BBI)->removeIncomingValue(SI->getParent()); 255356442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer } 255456442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer SI->eraseFromParent(); 255556442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer 255656442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer return true; 255756442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer} 2558d0a203d76f4ef77ae1c392e8e73e2f05b676a5f2Devang Patel 255910fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer/// EliminateDeadSwitchCases - Compute masked bits for the condition of a switch 256010fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer/// and use it to remove dead cases. 256110fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramerstatic bool EliminateDeadSwitchCases(SwitchInst *SI) { 256210fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer Value *Cond = SI->getCondition(); 256310fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer unsigned Bits = cast<IntegerType>(Cond->getType())->getBitWidth(); 256410fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer APInt KnownZero(Bits, 0), KnownOne(Bits, 0); 256526c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola ComputeMaskedBits(Cond, KnownZero, KnownOne); 256610fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer 256710fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer // Gather dead cases. 256810fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer SmallVector<ConstantInt*, 8> DeadCases; 25693d3abe0852d5f499bed7ab014519dd582a0a795dStepan Dyatkovskiy for (SwitchInst::CaseIt I = SI->case_begin(), E = SI->case_end(); I != E; ++I) { 2570c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy if ((I.getCaseValue()->getValue() & KnownZero) != 0 || 2571c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy (I.getCaseValue()->getValue() & KnownOne) != KnownOne) { 2572c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy DeadCases.push_back(I.getCaseValue()); 257310fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer DEBUG(dbgs() << "SimplifyCFG: switch case '" 2574c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy << I.getCaseValue() << "' is dead.\n"); 257510fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer } 257610fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer } 257710fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer 257810fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer // Remove dead cases from the switch. 257910fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer for (unsigned I = 0, E = DeadCases.size(); I != E; ++I) { 2580c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy SwitchInst::CaseIt Case = SI->findCaseValue(DeadCases[I]); 25813d3abe0852d5f499bed7ab014519dd582a0a795dStepan Dyatkovskiy assert(Case != SI->case_default() && 258224473120a253a05f3601cd3373403b47e6d03d41Stepan Dyatkovskiy "Case was not found. Probably mistake in DeadCases forming."); 258310fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer // Prune unused values from PHI nodes. 2584c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy Case.getCaseSuccessor()->removePredecessor(SI->getParent()); 258510fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer SI->removeCase(Case); 258610fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer } 258710fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer 258810fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer return !DeadCases.empty(); 258910fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer} 259010fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer 2591448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg/// FindPHIForConditionForwarding - If BB would be eligible for simplification 2592448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg/// by TryToSimplifyUncondBranchFromEmptyBlock (i.e. it is empty and terminated 2593448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg/// by an unconditional branch), look at the phi node for BB in the successor 2594448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg/// block and see if the incoming value is equal to CaseValue. If so, return 2595448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg/// the phi node, and set PhiIndex to BB's index in the phi node. 2596448da519cca87cbcba620188e1e595dc1f120512Hans Wennborgstatic PHINode *FindPHIForConditionForwarding(ConstantInt *CaseValue, 2597448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg BasicBlock *BB, 2598448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg int *PhiIndex) { 2599448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg if (BB->getFirstNonPHIOrDbg() != BB->getTerminator()) 2600448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg return NULL; // BB must be empty to be a candidate for simplification. 2601448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg if (!BB->getSinglePredecessor()) 2602448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg return NULL; // BB must be dominated by the switch. 2603448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 2604448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg BranchInst *Branch = dyn_cast<BranchInst>(BB->getTerminator()); 2605448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg if (!Branch || !Branch->isUnconditional()) 2606448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg return NULL; // Terminator must be unconditional branch. 2607448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 2608448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg BasicBlock *Succ = Branch->getSuccessor(0); 2609448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 2610448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg BasicBlock::iterator I = Succ->begin(); 2611448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg while (PHINode *PHI = dyn_cast<PHINode>(I++)) { 2612448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg int Idx = PHI->getBasicBlockIndex(BB); 2613448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg assert(Idx >= 0 && "PHI has no entry for predecessor?"); 2614448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 2615448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg Value *InValue = PHI->getIncomingValue(Idx); 2616448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg if (InValue != CaseValue) continue; 2617448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 2618448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg *PhiIndex = Idx; 2619448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg return PHI; 2620448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg } 2621448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 2622448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg return NULL; 2623448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg} 2624448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 2625448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg/// ForwardSwitchConditionToPHI - Try to forward the condition of a switch 2626448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg/// instruction to a phi node dominated by the switch, if that would mean that 2627448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg/// some of the destination blocks of the switch can be folded away. 2628448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg/// Returns true if a change is made. 2629448da519cca87cbcba620188e1e595dc1f120512Hans Wennborgstatic bool ForwardSwitchConditionToPHI(SwitchInst *SI) { 2630448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg typedef DenseMap<PHINode*, SmallVector<int,4> > ForwardingNodesMap; 2631448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg ForwardingNodesMap ForwardingNodes; 2632448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 26333d3abe0852d5f499bed7ab014519dd582a0a795dStepan Dyatkovskiy for (SwitchInst::CaseIt I = SI->case_begin(), E = SI->case_end(); I != E; ++I) { 2634c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy ConstantInt *CaseValue = I.getCaseValue(); 2635c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy BasicBlock *CaseDest = I.getCaseSuccessor(); 2636448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 2637448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg int PhiIndex; 2638448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg PHINode *PHI = FindPHIForConditionForwarding(CaseValue, CaseDest, 2639448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg &PhiIndex); 2640448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg if (!PHI) continue; 2641448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 2642448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg ForwardingNodes[PHI].push_back(PhiIndex); 2643448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg } 2644448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 2645448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg bool Changed = false; 2646448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 2647448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg for (ForwardingNodesMap::iterator I = ForwardingNodes.begin(), 2648448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg E = ForwardingNodes.end(); I != E; ++I) { 2649448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg PHINode *Phi = I->first; 2650448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg SmallVector<int,4> &Indexes = I->second; 2651448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 2652448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg if (Indexes.size() < 2) continue; 2653448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 2654448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg for (size_t I = 0, E = Indexes.size(); I != E; ++I) 2655448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg Phi->setIncomingValue(Indexes[I], SI->getCondition()); 2656448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg Changed = true; 2657448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg } 2658448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 2659448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg return Changed; 2660448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg} 2661448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 2662007349dafda47296177fd7481aff9764d4179f42Devang Patelbool SimplifyCFGOpt::SimplifySwitch(SwitchInst *SI, IRBuilder<> &Builder) { 26633d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If this switch is too complex to want to look at, ignore it. 26643d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (!isValueEqualityComparison(SI)) 26653d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return false; 2666e67fa05036f634a4ec1e0893033c89250eb58954Chris Lattner 26673d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *BB = SI->getParent(); 26683d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 26693d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If we only have one predecessor, and if it is a branch on this value, 26703d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // see if that predecessor totally determines the outcome of this switch. 26713d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BasicBlock *OnlyPred = BB->getSinglePredecessor()) 2672007349dafda47296177fd7481aff9764d4179f42Devang Patel if (SimplifyEqualityComparisonWithOnlyPredecessor(SI, OnlyPred, Builder)) 2673021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner return SimplifyCFG(BB) | true; 2674f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel 2675f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel Value *Cond = SI->getCondition(); 2676f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel if (SelectInst *Select = dyn_cast<SelectInst>(Cond)) 2677f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel if (SimplifySwitchOnSelect(SI, Select)) 2678f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel return SimplifyCFG(BB) | true; 2679f7b2a9d7df0020d5120fbeb3232f9dce57dec6e7Frits van Bommel 26803d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the block only contains the switch, see if we can fold the block 26813d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // away into any preds. 26823d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock::iterator BBI = BB->begin(); 26833d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Ignore dbg intrinsics. 26843d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner while (isa<DbgInfoIntrinsic>(BBI)) 26853d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner ++BBI; 26863d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SI == &*BBI) 2687b55d924b1e33341d08b1bead78e86fce56617784Devang Patel if (FoldValueComparisonIntoPredecessors(SI, Builder)) 2688021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner return SimplifyCFG(BB) | true; 268956442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer 269056442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer // Try to transform the switch into an icmp and a branch. 2691007349dafda47296177fd7481aff9764d4179f42Devang Patel if (TurnSwitchRangeIntoICmp(SI, Builder)) 269256442dfdcf7b07c04b585de5205b9427b1739895Benjamin Kramer return SimplifyCFG(BB) | true; 269310fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer 269410fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer // Remove unreachable cases. 269510fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer if (EliminateDeadSwitchCases(SI)) 269610fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer return SimplifyCFG(BB) | true; 269710fcfb53fdc77061841e815e8b4cd62b48d5767dBenjamin Kramer 2698448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg if (ForwardSwitchConditionToPHI(SI)) 2699448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg return SimplifyCFG(BB) | true; 2700448da519cca87cbcba620188e1e595dc1f120512Hans Wennborg 27013d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return false; 27023d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner} 27033d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 27043d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattnerbool SimplifyCFGOpt::SimplifyIndirectBr(IndirectBrInst *IBI) { 27053d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *BB = IBI->getParent(); 27063d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner bool Changed = false; 27073d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 27083d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Eliminate redundant destinations. 27093d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner SmallPtrSet<Value *, 8> Succs; 27103d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (unsigned i = 0, e = IBI->getNumDestinations(); i != e; ++i) { 27113d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *Dest = IBI->getDestination(i); 27123d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (!Dest->hasAddressTaken() || !Succs.insert(Dest)) { 27133d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Dest->removePredecessor(BB); 27143d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner IBI->removeDestination(i); 27153d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner --i; --e; 2716698f96f7c81e45292ae4f5d76b8e06c88a88a71fChris Lattner Changed = true; 2717698f96f7c81e45292ae4f5d76b8e06c88a88a71fChris Lattner } 27183d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 2719698f96f7c81e45292ae4f5d76b8e06c88a88a71fChris Lattner 27203d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (IBI->getNumDestinations() == 0) { 27213d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the indirectbr has no successors, change it to unreachable. 27223d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner new UnreachableInst(IBI->getContext(), IBI); 27233d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner EraseTerminatorInstAndDCECond(IBI); 27243d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return true; 27253d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 27263d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 27273d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (IBI->getNumDestinations() == 1) { 27283d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the indirectbr has one successor, change it to a direct branch. 27293d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BranchInst::Create(IBI->getDestination(0), IBI); 27303d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner EraseTerminatorInstAndDCECond(IBI); 27313d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return true; 27323d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 27333d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 27343d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(IBI->getAddress())) { 27353d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SimplifyIndirectBrOnSelect(IBI, SI)) 27363d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return SimplifyCFG(BB) | true; 27373d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 27383d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return Changed; 27393d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner} 2740698f96f7c81e45292ae4f5d76b8e06c88a88a71fChris Lattner 2741a23812cfbd23604d2fc103cf232cde8fa270a491Devang Patelbool SimplifyCFGOpt::SimplifyUncondBranch(BranchInst *BI, IRBuilder<> &Builder){ 27423d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *BB = BI->getParent(); 27433d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 27443d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the Terminator is the only non-phi instruction, simplify the block. 274577a2c372face15a302f4c9e5cb9acc035b8b3bd3Rafael Espindola BasicBlock::iterator I = BB->getFirstNonPHIOrDbgOrLifetime(); 27463d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (I->isTerminator() && BB != &BB->getParent()->getEntryBlock() && 27473d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner TryToSimplifyUncondBranchFromEmptyBlock(BB)) 27483d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return true; 27493d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 27503d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If the only instruction in the block is a seteq/setne comparison 27513d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // against a constant, try to simplify the block. 27523d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (ICmpInst *ICI = dyn_cast<ICmpInst>(I)) 27533d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (ICI->isEquality() && isa<ConstantInt>(ICI->getOperand(1))) { 27543d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (++I; isa<DbgInfoIntrinsic>(I); ++I) 27553d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner ; 27569d5231022283ff20b0291eb5711a449de262d3feNick Lewycky if (I->isTerminator() && 27579d5231022283ff20b0291eb5711a449de262d3feNick Lewycky TryToSimplifyUncondBranchWithICmpInIt(ICI, TD, Builder)) 2758698f96f7c81e45292ae4f5d76b8e06c88a88a71fChris Lattner return true; 2759698f96f7c81e45292ae4f5d76b8e06c88a88a71fChris Lattner } 27603d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 27613d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return false; 27623d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner} 2763e2c6d131d12c779a410740e0a90545def75e0f48Dan Gohman 27643d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 2765007349dafda47296177fd7481aff9764d4179f42Devang Patelbool SimplifyCFGOpt::SimplifyCondBranch(BranchInst *BI, IRBuilder<> &Builder) { 27663d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock *BB = BI->getParent(); 27673d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 27683d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Conditional branch 27693d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (isValueEqualityComparison(BI)) { 27703d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If we only have one predecessor, and if it is a branch on this value, 27713d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // see if that predecessor totally determines the outcome of this 27723d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // switch. 27733d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BasicBlock *OnlyPred = BB->getSinglePredecessor()) 2774007349dafda47296177fd7481aff9764d4179f42Devang Patel if (SimplifyEqualityComparisonWithOnlyPredecessor(BI, OnlyPred, Builder)) 27753d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return SimplifyCFG(BB) | true; 27763d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 27773d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // This block must be empty, except for the setcond inst, if it exists. 27783d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Ignore dbg intrinsics. 27793d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BasicBlock::iterator I = BB->begin(); 27803d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Ignore dbg intrinsics. 27813d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner while (isa<DbgInfoIntrinsic>(I)) 27823d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner ++I; 27833d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (&*I == BI) { 2784b55d924b1e33341d08b1bead78e86fce56617784Devang Patel if (FoldValueComparisonIntoPredecessors(BI, Builder)) 27853d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return SimplifyCFG(BB) | true; 27863d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } else if (&*I == cast<Instruction>(BI->getCondition())){ 27873d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner ++I; 27883d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Ignore dbg intrinsics. 27893d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner while (isa<DbgInfoIntrinsic>(I)) 27903d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner ++I; 2791b55d924b1e33341d08b1bead78e86fce56617784Devang Patel if (&*I == BI && FoldValueComparisonIntoPredecessors(BI, Builder)) 27923d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return SimplifyCFG(BB) | true; 27933d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 27943d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 27953d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 27963d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Try to turn "br (X == 0 | X == 1), T, F" into a switch instruction. 279702dd5418d29c2a43f225df887923e144e12e7ec6Devang Patel if (SimplifyBranchOnICmpChain(BI, TD, Builder)) 27983d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return true; 27993d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 28003b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // If this basic block is ONLY a compare and a branch, and if a predecessor 28013b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // branches to us and one of our successors, fold the comparison into the 28023b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman // predecessor and use logical operations to pick the right destination. 28033b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman if (FoldBranchToCommonDest(BI)) 28043b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman return SimplifyCFG(BB) | true; 28053b205175ea417349ab96f3525d730e005e12c0f9Dan Gohman 28063d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // We have a conditional branch to two blocks that are only reachable 28073d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // from BI. We know that the condbr dominates the two blocks, so see if 28083d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // there is any identical code in the "then" and "else" blocks. If so, we 28093d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // can hoist it up to the branching block. 28103d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BI->getSuccessor(0)->getSinglePredecessor() != 0) { 28113d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BI->getSuccessor(1)->getSinglePredecessor() != 0) { 2812216dde91d1def3e08002d6251e11f3dfa5cb3656Rafael Espindola if (HoistThenElseCodeToIf(BI)) 28137ac40c3ffabcdac9510e7efc4dc75a8ed2b32edbFrits van Bommel return SimplifyCFG(BB) | true; 28143d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } else { 28153d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If Successor #1 has multiple preds, we may be able to conditionally 28163d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // execute Successor #0 if it branches to successor #1. 28173d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner TerminatorInst *Succ0TI = BI->getSuccessor(0)->getTerminator(); 28183d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (Succ0TI->getNumSuccessors() == 1 && 28193d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Succ0TI->getSuccessor(0) == BI->getSuccessor(1)) 2820216dde91d1def3e08002d6251e11f3dfa5cb3656Rafael Espindola if (SpeculativelyExecuteBB(BI, BI->getSuccessor(0))) 28213d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return SimplifyCFG(BB) | true; 2822e2c6d131d12c779a410740e0a90545def75e0f48Dan Gohman } 28233d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } else if (BI->getSuccessor(1)->getSinglePredecessor() != 0) { 28243d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If Successor #0 has multiple preds, we may be able to conditionally 28253d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // execute Successor #1 if it branches to successor #0. 28263d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner TerminatorInst *Succ1TI = BI->getSuccessor(1)->getTerminator(); 28273d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (Succ1TI->getNumSuccessors() == 1 && 28283d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Succ1TI->getSuccessor(0) == BI->getSuccessor(0)) 2829216dde91d1def3e08002d6251e11f3dfa5cb3656Rafael Espindola if (SpeculativelyExecuteBB(BI, BI->getSuccessor(1))) 28303d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return SimplifyCFG(BB) | true; 283119831ec8531b0710629c1b0a8c0323e70ae0ef07Chris Lattner } 28323d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 28333d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If this is a branch on a phi node in the current block, thread control 28343d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // through this block if any PHI node entries are constants. 28353d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(BI->getCondition())) 28363d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (PN->getParent() == BI->getParent()) 2837302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner if (FoldCondBranchOnPHI(BI, TD)) 28383d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return SimplifyCFG(BB) | true; 28393d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 28403d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Scan predecessor blocks for conditional branches. 28413d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) 28423d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BranchInst *PBI = dyn_cast<BranchInst>((*PI)->getTerminator())) 28433d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (PBI != BI && PBI->isConditional()) 28443d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (SimplifyCondBranchToCondBranch(PBI, BI)) 28453d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return SimplifyCFG(BB) | true; 28463d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 28473d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return false; 28483d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner} 28493d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 285098d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer/// Check if passing a value to an instruction will cause undefined behavior. 285198d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramerstatic bool passingValueIsAlwaysUndefined(Value *V, Instruction *I) { 285298d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer Constant *C = dyn_cast<Constant>(V); 285398d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer if (!C) 285498d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer return false; 285598d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer 28569bb5488dbd152de41ffcaedccf94bfc43b069becBenjamin Kramer if (!I->hasOneUse()) // Only look at single-use instructions, for compile time 285798d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer return false; 285898d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer 285998d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer if (C->isNullValue()) { 286098d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer Instruction *Use = I->use_back(); 286198d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer 286298d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer // Now make sure that there are no instructions in between that can alter 286398d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer // control flow (eg. calls) 286498d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer for (BasicBlock::iterator i = ++BasicBlock::iterator(I); &*i != Use; ++i) 28659bb5488dbd152de41ffcaedccf94bfc43b069becBenjamin Kramer if (i == I->getParent()->end() || i->mayHaveSideEffects()) 286698d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer return false; 286798d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer 286898d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer // Look through GEPs. A load from a GEP derived from NULL is still undefined 286998d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Use)) 287098d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer if (GEP->getPointerOperand() == I) 287198d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer return passingValueIsAlwaysUndefined(V, GEP); 287298d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer 287398d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer // Look through bitcasts. 287498d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer if (BitCastInst *BC = dyn_cast<BitCastInst>(Use)) 287598d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer return passingValueIsAlwaysUndefined(V, BC); 287698d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer 28779bb5488dbd152de41ffcaedccf94bfc43b069becBenjamin Kramer // Load from null is undefined. 28789bb5488dbd152de41ffcaedccf94bfc43b069becBenjamin Kramer if (LoadInst *LI = dyn_cast<LoadInst>(Use)) 28799bb5488dbd152de41ffcaedccf94bfc43b069becBenjamin Kramer return LI->getPointerAddressSpace() == 0; 288098d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer 28819bb5488dbd152de41ffcaedccf94bfc43b069becBenjamin Kramer // Store to null is undefined. 28829bb5488dbd152de41ffcaedccf94bfc43b069becBenjamin Kramer if (StoreInst *SI = dyn_cast<StoreInst>(Use)) 28839bb5488dbd152de41ffcaedccf94bfc43b069becBenjamin Kramer return SI->getPointerAddressSpace() == 0 && SI->getPointerOperand() == I; 288498d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer } 288598d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer return false; 288698d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer} 288798d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer 288898d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer/// If BB has an incoming value that will always trigger undefined behavior 28899d5231022283ff20b0291eb5711a449de262d3feNick Lewycky/// (eg. null pointer dereference), remove the branch leading here. 289098d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramerstatic bool removeUndefIntroducingPredecessor(BasicBlock *BB) { 289198d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer for (BasicBlock::iterator i = BB->begin(); 289298d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer PHINode *PHI = dyn_cast<PHINode>(i); ++i) 289398d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer for (unsigned i = 0, e = PHI->getNumIncomingValues(); i != e; ++i) 289498d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer if (passingValueIsAlwaysUndefined(PHI->getIncomingValue(i), PHI)) { 289598d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer TerminatorInst *T = PHI->getIncomingBlock(i)->getTerminator(); 289698d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer IRBuilder<> Builder(T); 289798d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer if (BranchInst *BI = dyn_cast<BranchInst>(T)) { 289898d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer BB->removePredecessor(PHI->getIncomingBlock(i)); 289998d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer // Turn uncoditional branches into unreachables and remove the dead 290098d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer // destination from conditional branches. 290198d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer if (BI->isUnconditional()) 290298d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer Builder.CreateUnreachable(); 290398d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer else 290498d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer Builder.CreateBr(BI->getSuccessor(0) == BB ? BI->getSuccessor(1) : 290598d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer BI->getSuccessor(0)); 290698d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer BI->eraseFromParent(); 290798d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer return true; 290898d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer } 290998d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer // TODO: SwitchInst. 291098d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer } 291198d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer 291298d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer return false; 291398d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer} 291498d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer 29153d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattnerbool SimplifyCFGOpt::run(BasicBlock *BB) { 29163d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner bool Changed = false; 29173d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 2918302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner assert(BB && BB->getParent() && "Block not embedded in function!"); 29193d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner assert(BB->getTerminator() && "Degenerate basic block encountered!"); 29203d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 29213d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Remove basic blocks that have no predecessors (except the entry block)... 29223d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // or that just have themself as a predecessor. These are unreachable. 2923302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner if ((pred_begin(BB) == pred_end(BB) && 2924302ba6fc1cb26248b0d6524fc42c740370926d6dChris Lattner BB != &BB->getParent()->getEntryBlock()) || 29253d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner BB->getSinglePredecessor() == BB) { 29263d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner DEBUG(dbgs() << "Removing BB: \n" << *BB); 29273d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner DeleteDeadBlock(BB); 29283d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return true; 29293d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 29303d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 29313d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Check to see if we can constant propagate this terminator instruction 29323d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // away... 29335649ba70fb39f2fda4791d255ae8bb373071874fFrits van Bommel Changed |= ConstantFoldTerminator(BB, true); 29343d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 29353d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Check for and eliminate duplicate PHI nodes in this block. 29363d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner Changed |= EliminateDuplicatePHINodes(BB); 29373d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 293898d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer // Check for and remove branches that will always cause undefined behavior. 293998d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer Changed |= removeUndefIntroducingPredecessor(BB); 294098d6d2372feb2f8bb4c3941b278027499cbfc00bBenjamin Kramer 29413d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // Merge basic blocks into their predecessor if there is only one distinct 29423d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // pred, and if there is only one distinct successor of the predecessor, and 29433d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // if there are no PHI nodes. 29443d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // 29453d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (MergeBlockIntoPredecessor(BB)) 29463d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner return true; 29473d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 29483e410c6607192bbf28ba3708245cb70a0f983556Devang Patel IRBuilder<> Builder(BB); 29493e410c6607192bbf28ba3708245cb70a0f983556Devang Patel 29503d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // If there is a trivial two-entry PHI node in this basic block, and we can 29513d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner // eliminate it, do so now. 29523d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(BB->begin())) 29533d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (PN->getNumIncomingValues() == 2) 2954d3a1788da15311781f661c1cbfe48cd5f98ae778Devang Patel Changed |= FoldTwoEntryPHINode(PN, TD); 29553d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 2956007349dafda47296177fd7481aff9764d4179f42Devang Patel Builder.SetInsertPoint(BB->getTerminator()); 29573d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator())) { 2958021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner if (BI->isUnconditional()) { 2959a23812cfbd23604d2fc103cf232cde8fa270a491Devang Patel if (SimplifyUncondBranch(BI, Builder)) return true; 2960021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner } else { 2961007349dafda47296177fd7481aff9764d4179f42Devang Patel if (SimplifyCondBranch(BI, Builder)) return true; 2962021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner } 2963021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner } else if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator())) { 2964176ec40cb18c51c14fccbb38ee0db5deafb6baa9Devang Patel if (SimplifyReturn(RI, Builder)) return true; 2965aa5abe88d6aa445afa593476a665e3ab14b3524cBill Wendling } else if (ResumeInst *RI = dyn_cast<ResumeInst>(BB->getTerminator())) { 2966aa5abe88d6aa445afa593476a665e3ab14b3524cBill Wendling if (SimplifyResume(RI, Builder)) return true; 2967021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner } else if (SwitchInst *SI = dyn_cast<SwitchInst>(BB->getTerminator())) { 2968007349dafda47296177fd7481aff9764d4179f42Devang Patel if (SimplifySwitch(SI, Builder)) return true; 2969021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner } else if (UnreachableInst *UI = 2970021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner dyn_cast<UnreachableInst>(BB->getTerminator())) { 2971021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner if (SimplifyUnreachable(UI)) return true; 2972021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner } else if (IndirectBrInst *IBI = 2973021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner dyn_cast<IndirectBrInst>(BB->getTerminator())) { 2974021c9d3bd41bc446ef0860c05a073e32afa5e20fChris Lattner if (SimplifyIndirectBr(IBI)) return true; 29753d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner } 29763d5121314ab4af435e1abf5bc09b45c305f2f4b0Chris Lattner 2977694e37f08a7c09ccc24642532106295cf7b3a1e3Chris Lattner return Changed; 297801d1ee3a4c4153c80c3c415e4612db6c27e37acbChris Lattner} 297958e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen 298058e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen/// SimplifyCFG - This function is used to do simplification of a CFG. For 298158e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen/// example, it adjusts branches to branches to eliminate the extra hop, it 298258e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen/// eliminates unreachable basic blocks, and does other "peephole" optimization 298358e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen/// of the CFG. It returns true if a modification was made. 298458e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen/// 298558e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesenbool llvm::SimplifyCFG(BasicBlock *BB, const TargetData *TD) { 298658e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen return SimplifyCFGOpt(TD).run(BB); 298758e9ee85fda5083e2eea987917e8eab6ba31fe5eJakob Stoklund Olesen} 2988