1 //===- SimplifyCFG.cpp - Code to perform CFG simplification ---------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // Peephole optimize the CFG. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #define DEBUG_TYPE "simplifycfg" 15 #include "llvm/Transforms/Utils/Local.h" 16 #include "llvm/Constants.h" 17 #include "llvm/DerivedTypes.h" 18 #include "llvm/GlobalVariable.h" 19 #include "llvm/IRBuilder.h" 20 #include "llvm/Instructions.h" 21 #include "llvm/IntrinsicInst.h" 22 #include "llvm/LLVMContext.h" 23 #include "llvm/MDBuilder.h" 24 #include "llvm/Metadata.h" 25 #include "llvm/Module.h" 26 #include "llvm/Operator.h" 27 #include "llvm/Type.h" 28 #include "llvm/ADT/DenseMap.h" 29 #include "llvm/ADT/STLExtras.h" 30 #include "llvm/ADT/SetVector.h" 31 #include "llvm/ADT/SmallPtrSet.h" 32 #include "llvm/ADT/SmallVector.h" 33 #include "llvm/ADT/Statistic.h" 34 #include "llvm/Analysis/InstructionSimplify.h" 35 #include "llvm/Analysis/ValueTracking.h" 36 #include "llvm/Support/CFG.h" 37 #include "llvm/Support/CommandLine.h" 38 #include "llvm/Support/ConstantRange.h" 39 #include "llvm/Support/Debug.h" 40 #include "llvm/Support/NoFolder.h" 41 #include "llvm/Support/raw_ostream.h" 42 #include "llvm/Target/TargetData.h" 43 #include "llvm/Transforms/Utils/BasicBlockUtils.h" 44 #include <algorithm> 45 #include <set> 46 #include <map> 47 using namespace llvm; 48 49 static cl::opt<unsigned> 50 PHINodeFoldingThreshold("phi-node-folding-threshold", cl::Hidden, cl::init(1), 51 cl::desc("Control the amount of phi node folding to perform (default = 1)")); 52 53 static cl::opt<bool> 54 DupRet("simplifycfg-dup-ret", cl::Hidden, cl::init(false), 55 cl::desc("Duplicate return instructions into unconditional branches")); 56 57 STATISTIC(NumSpeculations, "Number of speculative executed instructions"); 58 STATISTIC(NumLookupTables, "Number of switch instructions turned into lookup tables"); 59 60 namespace { 61 /// ValueEqualityComparisonCase - Represents a case of a switch. 62 struct ValueEqualityComparisonCase { 63 ConstantInt *Value; 64 BasicBlock *Dest; 65 66 ValueEqualityComparisonCase(ConstantInt *Value, BasicBlock *Dest) 67 : Value(Value), Dest(Dest) {} 68 69 bool operator<(ValueEqualityComparisonCase RHS) const { 70 // Comparing pointers is ok as we only rely on the order for uniquing. 71 return Value < RHS.Value; 72 } 73 }; 74 75 class SimplifyCFGOpt { 76 const TargetData *const TD; 77 78 Value *isValueEqualityComparison(TerminatorInst *TI); 79 BasicBlock *GetValueEqualityComparisonCases(TerminatorInst *TI, 80 std::vector<ValueEqualityComparisonCase> &Cases); 81 bool SimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI, 82 BasicBlock *Pred, 83 IRBuilder<> &Builder); 84 bool FoldValueComparisonIntoPredecessors(TerminatorInst *TI, 85 IRBuilder<> &Builder); 86 87 bool SimplifyReturn(ReturnInst *RI, IRBuilder<> &Builder); 88 bool SimplifyResume(ResumeInst *RI, IRBuilder<> &Builder); 89 bool SimplifyUnreachable(UnreachableInst *UI); 90 bool SimplifySwitch(SwitchInst *SI, IRBuilder<> &Builder); 91 bool SimplifyIndirectBr(IndirectBrInst *IBI); 92 bool SimplifyUncondBranch(BranchInst *BI, IRBuilder <> &Builder); 93 bool SimplifyCondBranch(BranchInst *BI, IRBuilder <>&Builder); 94 95 public: 96 explicit SimplifyCFGOpt(const TargetData *td) : TD(td) {} 97 bool run(BasicBlock *BB); 98 }; 99 } 100 101 /// SafeToMergeTerminators - Return true if it is safe to merge these two 102 /// terminator instructions together. 103 /// 104 static bool SafeToMergeTerminators(TerminatorInst *SI1, TerminatorInst *SI2) { 105 if (SI1 == SI2) return false; // Can't merge with self! 106 107 // It is not safe to merge these two switch instructions if they have a common 108 // successor, and if that successor has a PHI node, and if *that* PHI node has 109 // conflicting incoming values from the two switch blocks. 110 BasicBlock *SI1BB = SI1->getParent(); 111 BasicBlock *SI2BB = SI2->getParent(); 112 SmallPtrSet<BasicBlock*, 16> SI1Succs(succ_begin(SI1BB), succ_end(SI1BB)); 113 114 for (succ_iterator I = succ_begin(SI2BB), E = succ_end(SI2BB); I != E; ++I) 115 if (SI1Succs.count(*I)) 116 for (BasicBlock::iterator BBI = (*I)->begin(); 117 isa<PHINode>(BBI); ++BBI) { 118 PHINode *PN = cast<PHINode>(BBI); 119 if (PN->getIncomingValueForBlock(SI1BB) != 120 PN->getIncomingValueForBlock(SI2BB)) 121 return false; 122 } 123 124 return true; 125 } 126 127 /// isProfitableToFoldUnconditional - Return true if it is safe and profitable 128 /// to merge these two terminator instructions together, where SI1 is an 129 /// unconditional branch. PhiNodes will store all PHI nodes in common 130 /// successors. 131 /// 132 static bool isProfitableToFoldUnconditional(BranchInst *SI1, 133 BranchInst *SI2, 134 Instruction *Cond, 135 SmallVectorImpl<PHINode*> &PhiNodes) { 136 if (SI1 == SI2) return false; // Can't merge with self! 137 assert(SI1->isUnconditional() && SI2->isConditional()); 138 139 // We fold the unconditional branch if we can easily update all PHI nodes in 140 // common successors: 141 // 1> We have a constant incoming value for the conditional branch; 142 // 2> We have "Cond" as the incoming value for the unconditional branch; 143 // 3> SI2->getCondition() and Cond have same operands. 144 CmpInst *Ci2 = dyn_cast<CmpInst>(SI2->getCondition()); 145 if (!Ci2) return false; 146 if (!(Cond->getOperand(0) == Ci2->getOperand(0) && 147 Cond->getOperand(1) == Ci2->getOperand(1)) && 148 !(Cond->getOperand(0) == Ci2->getOperand(1) && 149 Cond->getOperand(1) == Ci2->getOperand(0))) 150 return false; 151 152 BasicBlock *SI1BB = SI1->getParent(); 153 BasicBlock *SI2BB = SI2->getParent(); 154 SmallPtrSet<BasicBlock*, 16> SI1Succs(succ_begin(SI1BB), succ_end(SI1BB)); 155 for (succ_iterator I = succ_begin(SI2BB), E = succ_end(SI2BB); I != E; ++I) 156 if (SI1Succs.count(*I)) 157 for (BasicBlock::iterator BBI = (*I)->begin(); 158 isa<PHINode>(BBI); ++BBI) { 159 PHINode *PN = cast<PHINode>(BBI); 160 if (PN->getIncomingValueForBlock(SI1BB) != Cond || 161 !isa<ConstantInt>(PN->getIncomingValueForBlock(SI2BB))) 162 return false; 163 PhiNodes.push_back(PN); 164 } 165 return true; 166 } 167 168 /// AddPredecessorToBlock - Update PHI nodes in Succ to indicate that there will 169 /// now be entries in it from the 'NewPred' block. The values that will be 170 /// flowing into the PHI nodes will be the same as those coming in from 171 /// ExistPred, an existing predecessor of Succ. 172 static void AddPredecessorToBlock(BasicBlock *Succ, BasicBlock *NewPred, 173 BasicBlock *ExistPred) { 174 if (!isa<PHINode>(Succ->begin())) return; // Quick exit if nothing to do 175 176 PHINode *PN; 177 for (BasicBlock::iterator I = Succ->begin(); 178 (PN = dyn_cast<PHINode>(I)); ++I) 179 PN->addIncoming(PN->getIncomingValueForBlock(ExistPred), NewPred); 180 } 181 182 183 /// GetIfCondition - Given a basic block (BB) with two predecessors (and at 184 /// least one PHI node in it), check to see if the merge at this block is due 185 /// to an "if condition". If so, return the boolean condition that determines 186 /// which entry into BB will be taken. Also, return by references the block 187 /// that will be entered from if the condition is true, and the block that will 188 /// be entered if the condition is false. 189 /// 190 /// This does no checking to see if the true/false blocks have large or unsavory 191 /// instructions in them. 192 static Value *GetIfCondition(BasicBlock *BB, BasicBlock *&IfTrue, 193 BasicBlock *&IfFalse) { 194 PHINode *SomePHI = cast<PHINode>(BB->begin()); 195 assert(SomePHI->getNumIncomingValues() == 2 && 196 "Function can only handle blocks with 2 predecessors!"); 197 BasicBlock *Pred1 = SomePHI->getIncomingBlock(0); 198 BasicBlock *Pred2 = SomePHI->getIncomingBlock(1); 199 200 // We can only handle branches. Other control flow will be lowered to 201 // branches if possible anyway. 202 BranchInst *Pred1Br = dyn_cast<BranchInst>(Pred1->getTerminator()); 203 BranchInst *Pred2Br = dyn_cast<BranchInst>(Pred2->getTerminator()); 204 if (Pred1Br == 0 || Pred2Br == 0) 205 return 0; 206 207 // Eliminate code duplication by ensuring that Pred1Br is conditional if 208 // either are. 209 if (Pred2Br->isConditional()) { 210 // If both branches are conditional, we don't have an "if statement". In 211 // reality, we could transform this case, but since the condition will be 212 // required anyway, we stand no chance of eliminating it, so the xform is 213 // probably not profitable. 214 if (Pred1Br->isConditional()) 215 return 0; 216 217 std::swap(Pred1, Pred2); 218 std::swap(Pred1Br, Pred2Br); 219 } 220 221 if (Pred1Br->isConditional()) { 222 // The only thing we have to watch out for here is to make sure that Pred2 223 // doesn't have incoming edges from other blocks. If it does, the condition 224 // doesn't dominate BB. 225 if (Pred2->getSinglePredecessor() == 0) 226 return 0; 227 228 // If we found a conditional branch predecessor, make sure that it branches 229 // to BB and Pred2Br. If it doesn't, this isn't an "if statement". 230 if (Pred1Br->getSuccessor(0) == BB && 231 Pred1Br->getSuccessor(1) == Pred2) { 232 IfTrue = Pred1; 233 IfFalse = Pred2; 234 } else if (Pred1Br->getSuccessor(0) == Pred2 && 235 Pred1Br->getSuccessor(1) == BB) { 236 IfTrue = Pred2; 237 IfFalse = Pred1; 238 } else { 239 // We know that one arm of the conditional goes to BB, so the other must 240 // go somewhere unrelated, and this must not be an "if statement". 241 return 0; 242 } 243 244 return Pred1Br->getCondition(); 245 } 246 247 // Ok, if we got here, both predecessors end with an unconditional branch to 248 // BB. Don't panic! If both blocks only have a single (identical) 249 // predecessor, and THAT is a conditional branch, then we're all ok! 250 BasicBlock *CommonPred = Pred1->getSinglePredecessor(); 251 if (CommonPred == 0 || CommonPred != Pred2->getSinglePredecessor()) 252 return 0; 253 254 // Otherwise, if this is a conditional branch, then we can use it! 255 BranchInst *BI = dyn_cast<BranchInst>(CommonPred->getTerminator()); 256 if (BI == 0) return 0; 257 258 assert(BI->isConditional() && "Two successors but not conditional?"); 259 if (BI->getSuccessor(0) == Pred1) { 260 IfTrue = Pred1; 261 IfFalse = Pred2; 262 } else { 263 IfTrue = Pred2; 264 IfFalse = Pred1; 265 } 266 return BI->getCondition(); 267 } 268 269 /// ComputeSpeculuationCost - Compute an abstract "cost" of speculating the 270 /// given instruction, which is assumed to be safe to speculate. 1 means 271 /// cheap, 2 means less cheap, and UINT_MAX means prohibitively expensive. 272 static unsigned ComputeSpeculationCost(const User *I) { 273 assert(isSafeToSpeculativelyExecute(I) && 274 "Instruction is not safe to speculatively execute!"); 275 switch (Operator::getOpcode(I)) { 276 default: 277 // In doubt, be conservative. 278 return UINT_MAX; 279 case Instruction::GetElementPtr: 280 // GEPs are cheap if all indices are constant. 281 if (!cast<GEPOperator>(I)->hasAllConstantIndices()) 282 return UINT_MAX; 283 return 1; 284 case Instruction::Load: 285 case Instruction::Add: 286 case Instruction::Sub: 287 case Instruction::And: 288 case Instruction::Or: 289 case Instruction::Xor: 290 case Instruction::Shl: 291 case Instruction::LShr: 292 case Instruction::AShr: 293 case Instruction::ICmp: 294 case Instruction::Trunc: 295 case Instruction::ZExt: 296 case Instruction::SExt: 297 return 1; // These are all cheap. 298 299 case Instruction::Call: 300 case Instruction::Select: 301 return 2; 302 } 303 } 304 305 /// DominatesMergePoint - If we have a merge point of an "if condition" as 306 /// accepted above, return true if the specified value dominates the block. We 307 /// don't handle the true generality of domination here, just a special case 308 /// which works well enough for us. 309 /// 310 /// If AggressiveInsts is non-null, and if V does not dominate BB, we check to 311 /// see if V (which must be an instruction) and its recursive operands 312 /// that do not dominate BB have a combined cost lower than CostRemaining and 313 /// are non-trapping. If both are true, the instruction is inserted into the 314 /// set and true is returned. 315 /// 316 /// The cost for most non-trapping instructions is defined as 1 except for 317 /// Select whose cost is 2. 318 /// 319 /// After this function returns, CostRemaining is decreased by the cost of 320 /// V plus its non-dominating operands. If that cost is greater than 321 /// CostRemaining, false is returned and CostRemaining is undefined. 322 static bool DominatesMergePoint(Value *V, BasicBlock *BB, 323 SmallPtrSet<Instruction*, 4> *AggressiveInsts, 324 unsigned &CostRemaining) { 325 Instruction *I = dyn_cast<Instruction>(V); 326 if (!I) { 327 // Non-instructions all dominate instructions, but not all constantexprs 328 // can be executed unconditionally. 329 if (ConstantExpr *C = dyn_cast<ConstantExpr>(V)) 330 if (C->canTrap()) 331 return false; 332 return true; 333 } 334 BasicBlock *PBB = I->getParent(); 335 336 // We don't want to allow weird loops that might have the "if condition" in 337 // the bottom of this block. 338 if (PBB == BB) return false; 339 340 // If this instruction is defined in a block that contains an unconditional 341 // branch to BB, then it must be in the 'conditional' part of the "if 342 // statement". If not, it definitely dominates the region. 343 BranchInst *BI = dyn_cast<BranchInst>(PBB->getTerminator()); 344 if (BI == 0 || BI->isConditional() || BI->getSuccessor(0) != BB) 345 return true; 346 347 // If we aren't allowing aggressive promotion anymore, then don't consider 348 // instructions in the 'if region'. 349 if (AggressiveInsts == 0) return false; 350 351 // If we have seen this instruction before, don't count it again. 352 if (AggressiveInsts->count(I)) return true; 353 354 // Okay, it looks like the instruction IS in the "condition". Check to 355 // see if it's a cheap instruction to unconditionally compute, and if it 356 // only uses stuff defined outside of the condition. If so, hoist it out. 357 if (!isSafeToSpeculativelyExecute(I)) 358 return false; 359 360 unsigned Cost = ComputeSpeculationCost(I); 361 362 if (Cost > CostRemaining) 363 return false; 364 365 CostRemaining -= Cost; 366 367 // Okay, we can only really hoist these out if their operands do 368 // not take us over the cost threshold. 369 for (User::op_iterator i = I->op_begin(), e = I->op_end(); i != e; ++i) 370 if (!DominatesMergePoint(*i, BB, AggressiveInsts, CostRemaining)) 371 return false; 372 // Okay, it's safe to do this! Remember this instruction. 373 AggressiveInsts->insert(I); 374 return true; 375 } 376 377 /// GetConstantInt - Extract ConstantInt from value, looking through IntToPtr 378 /// and PointerNullValue. Return NULL if value is not a constant int. 379 static ConstantInt *GetConstantInt(Value *V, const TargetData *TD) { 380 // Normal constant int. 381 ConstantInt *CI = dyn_cast<ConstantInt>(V); 382 if (CI || !TD || !isa<Constant>(V) || !V->getType()->isPointerTy()) 383 return CI; 384 385 // This is some kind of pointer constant. Turn it into a pointer-sized 386 // ConstantInt if possible. 387 IntegerType *PtrTy = TD->getIntPtrType(V->getContext()); 388 389 // Null pointer means 0, see SelectionDAGBuilder::getValue(const Value*). 390 if (isa<ConstantPointerNull>(V)) 391 return ConstantInt::get(PtrTy, 0); 392 393 // IntToPtr const int. 394 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) 395 if (CE->getOpcode() == Instruction::IntToPtr) 396 if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(0))) { 397 // The constant is very likely to have the right type already. 398 if (CI->getType() == PtrTy) 399 return CI; 400 else 401 return cast<ConstantInt> 402 (ConstantExpr::getIntegerCast(CI, PtrTy, /*isSigned=*/false)); 403 } 404 return 0; 405 } 406 407 /// GatherConstantCompares - Given a potentially 'or'd or 'and'd together 408 /// collection of icmp eq/ne instructions that compare a value against a 409 /// constant, return the value being compared, and stick the constant into the 410 /// Values vector. 411 static Value * 412 GatherConstantCompares(Value *V, std::vector<ConstantInt*> &Vals, Value *&Extra, 413 const TargetData *TD, bool isEQ, unsigned &UsedICmps) { 414 Instruction *I = dyn_cast<Instruction>(V); 415 if (I == 0) return 0; 416 417 // If this is an icmp against a constant, handle this as one of the cases. 418 if (ICmpInst *ICI = dyn_cast<ICmpInst>(I)) { 419 if (ConstantInt *C = GetConstantInt(I->getOperand(1), TD)) { 420 if (ICI->getPredicate() == (isEQ ? ICmpInst::ICMP_EQ:ICmpInst::ICMP_NE)) { 421 UsedICmps++; 422 Vals.push_back(C); 423 return I->getOperand(0); 424 } 425 426 // If we have "x ult 3" comparison, for example, then we can add 0,1,2 to 427 // the set. 428 ConstantRange Span = 429 ConstantRange::makeICmpRegion(ICI->getPredicate(), C->getValue()); 430 431 // If this is an and/!= check then we want to optimize "x ugt 2" into 432 // x != 0 && x != 1. 433 if (!isEQ) 434 Span = Span.inverse(); 435 436 // If there are a ton of values, we don't want to make a ginormous switch. 437 if (Span.getSetSize().ugt(8) || Span.isEmptySet()) 438 return 0; 439 440 for (APInt Tmp = Span.getLower(); Tmp != Span.getUpper(); ++Tmp) 441 Vals.push_back(ConstantInt::get(V->getContext(), Tmp)); 442 UsedICmps++; 443 return I->getOperand(0); 444 } 445 return 0; 446 } 447 448 // Otherwise, we can only handle an | or &, depending on isEQ. 449 if (I->getOpcode() != (isEQ ? Instruction::Or : Instruction::And)) 450 return 0; 451 452 unsigned NumValsBeforeLHS = Vals.size(); 453 unsigned UsedICmpsBeforeLHS = UsedICmps; 454 if (Value *LHS = GatherConstantCompares(I->getOperand(0), Vals, Extra, TD, 455 isEQ, UsedICmps)) { 456 unsigned NumVals = Vals.size(); 457 unsigned UsedICmpsBeforeRHS = UsedICmps; 458 if (Value *RHS = GatherConstantCompares(I->getOperand(1), Vals, Extra, TD, 459 isEQ, UsedICmps)) { 460 if (LHS == RHS) 461 return LHS; 462 Vals.resize(NumVals); 463 UsedICmps = UsedICmpsBeforeRHS; 464 } 465 466 // The RHS of the or/and can't be folded in and we haven't used "Extra" yet, 467 // set it and return success. 468 if (Extra == 0 || Extra == I->getOperand(1)) { 469 Extra = I->getOperand(1); 470 return LHS; 471 } 472 473 Vals.resize(NumValsBeforeLHS); 474 UsedICmps = UsedICmpsBeforeLHS; 475 return 0; 476 } 477 478 // If the LHS can't be folded in, but Extra is available and RHS can, try to 479 // use LHS as Extra. 480 if (Extra == 0 || Extra == I->getOperand(0)) { 481 Value *OldExtra = Extra; 482 Extra = I->getOperand(0); 483 if (Value *RHS = GatherConstantCompares(I->getOperand(1), Vals, Extra, TD, 484 isEQ, UsedICmps)) 485 return RHS; 486 assert(Vals.size() == NumValsBeforeLHS); 487 Extra = OldExtra; 488 } 489 490 return 0; 491 } 492 493 static void EraseTerminatorInstAndDCECond(TerminatorInst *TI) { 494 Instruction *Cond = 0; 495 if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { 496 Cond = dyn_cast<Instruction>(SI->getCondition()); 497 } else if (BranchInst *BI = dyn_cast<BranchInst>(TI)) { 498 if (BI->isConditional()) 499 Cond = dyn_cast<Instruction>(BI->getCondition()); 500 } else if (IndirectBrInst *IBI = dyn_cast<IndirectBrInst>(TI)) { 501 Cond = dyn_cast<Instruction>(IBI->getAddress()); 502 } 503 504 TI->eraseFromParent(); 505 if (Cond) RecursivelyDeleteTriviallyDeadInstructions(Cond); 506 } 507 508 /// isValueEqualityComparison - Return true if the specified terminator checks 509 /// to see if a value is equal to constant integer value. 510 Value *SimplifyCFGOpt::isValueEqualityComparison(TerminatorInst *TI) { 511 Value *CV = 0; 512 if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { 513 // Do not permit merging of large switch instructions into their 514 // predecessors unless there is only one predecessor. 515 if (SI->getNumSuccessors()*std::distance(pred_begin(SI->getParent()), 516 pred_end(SI->getParent())) <= 128) 517 CV = SI->getCondition(); 518 } else if (BranchInst *BI = dyn_cast<BranchInst>(TI)) 519 if (BI->isConditional() && BI->getCondition()->hasOneUse()) 520 if (ICmpInst *ICI = dyn_cast<ICmpInst>(BI->getCondition())) 521 if ((ICI->getPredicate() == ICmpInst::ICMP_EQ || 522 ICI->getPredicate() == ICmpInst::ICMP_NE) && 523 GetConstantInt(ICI->getOperand(1), TD)) 524 CV = ICI->getOperand(0); 525 526 // Unwrap any lossless ptrtoint cast. 527 if (TD && CV && CV->getType() == TD->getIntPtrType(CV->getContext())) 528 if (PtrToIntInst *PTII = dyn_cast<PtrToIntInst>(CV)) 529 CV = PTII->getOperand(0); 530 return CV; 531 } 532 533 /// GetValueEqualityComparisonCases - Given a value comparison instruction, 534 /// decode all of the 'cases' that it represents and return the 'default' block. 535 BasicBlock *SimplifyCFGOpt:: 536 GetValueEqualityComparisonCases(TerminatorInst *TI, 537 std::vector<ValueEqualityComparisonCase> 538 &Cases) { 539 if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { 540 Cases.reserve(SI->getNumCases()); 541 for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end(); i != e; ++i) 542 Cases.push_back(ValueEqualityComparisonCase(i.getCaseValue(), 543 i.getCaseSuccessor())); 544 return SI->getDefaultDest(); 545 } 546 547 BranchInst *BI = cast<BranchInst>(TI); 548 ICmpInst *ICI = cast<ICmpInst>(BI->getCondition()); 549 BasicBlock *Succ = BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_NE); 550 Cases.push_back(ValueEqualityComparisonCase(GetConstantInt(ICI->getOperand(1), 551 TD), 552 Succ)); 553 return BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_EQ); 554 } 555 556 557 /// EliminateBlockCases - Given a vector of bb/value pairs, remove any entries 558 /// in the list that match the specified block. 559 static void EliminateBlockCases(BasicBlock *BB, 560 std::vector<ValueEqualityComparisonCase> &Cases) { 561 for (unsigned i = 0, e = Cases.size(); i != e; ++i) 562 if (Cases[i].Dest == BB) { 563 Cases.erase(Cases.begin()+i); 564 --i; --e; 565 } 566 } 567 568 /// ValuesOverlap - Return true if there are any keys in C1 that exist in C2 as 569 /// well. 570 static bool 571 ValuesOverlap(std::vector<ValueEqualityComparisonCase> &C1, 572 std::vector<ValueEqualityComparisonCase > &C2) { 573 std::vector<ValueEqualityComparisonCase> *V1 = &C1, *V2 = &C2; 574 575 // Make V1 be smaller than V2. 576 if (V1->size() > V2->size()) 577 std::swap(V1, V2); 578 579 if (V1->size() == 0) return false; 580 if (V1->size() == 1) { 581 // Just scan V2. 582 ConstantInt *TheVal = (*V1)[0].Value; 583 for (unsigned i = 0, e = V2->size(); i != e; ++i) 584 if (TheVal == (*V2)[i].Value) 585 return true; 586 } 587 588 // Otherwise, just sort both lists and compare element by element. 589 array_pod_sort(V1->begin(), V1->end()); 590 array_pod_sort(V2->begin(), V2->end()); 591 unsigned i1 = 0, i2 = 0, e1 = V1->size(), e2 = V2->size(); 592 while (i1 != e1 && i2 != e2) { 593 if ((*V1)[i1].Value == (*V2)[i2].Value) 594 return true; 595 if ((*V1)[i1].Value < (*V2)[i2].Value) 596 ++i1; 597 else 598 ++i2; 599 } 600 return false; 601 } 602 603 /// SimplifyEqualityComparisonWithOnlyPredecessor - If TI is known to be a 604 /// terminator instruction and its block is known to only have a single 605 /// predecessor block, check to see if that predecessor is also a value 606 /// comparison with the same value, and if that comparison determines the 607 /// outcome of this comparison. If so, simplify TI. This does a very limited 608 /// form of jump threading. 609 bool SimplifyCFGOpt:: 610 SimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI, 611 BasicBlock *Pred, 612 IRBuilder<> &Builder) { 613 Value *PredVal = isValueEqualityComparison(Pred->getTerminator()); 614 if (!PredVal) return false; // Not a value comparison in predecessor. 615 616 Value *ThisVal = isValueEqualityComparison(TI); 617 assert(ThisVal && "This isn't a value comparison!!"); 618 if (ThisVal != PredVal) return false; // Different predicates. 619 620 // TODO: Preserve branch weight metadata, similarly to how 621 // FoldValueComparisonIntoPredecessors preserves it. 622 623 // Find out information about when control will move from Pred to TI's block. 624 std::vector<ValueEqualityComparisonCase> PredCases; 625 BasicBlock *PredDef = GetValueEqualityComparisonCases(Pred->getTerminator(), 626 PredCases); 627 EliminateBlockCases(PredDef, PredCases); // Remove default from cases. 628 629 // Find information about how control leaves this block. 630 std::vector<ValueEqualityComparisonCase> ThisCases; 631 BasicBlock *ThisDef = GetValueEqualityComparisonCases(TI, ThisCases); 632 EliminateBlockCases(ThisDef, ThisCases); // Remove default from cases. 633 634 // If TI's block is the default block from Pred's comparison, potentially 635 // simplify TI based on this knowledge. 636 if (PredDef == TI->getParent()) { 637 // If we are here, we know that the value is none of those cases listed in 638 // PredCases. If there are any cases in ThisCases that are in PredCases, we 639 // can simplify TI. 640 if (!ValuesOverlap(PredCases, ThisCases)) 641 return false; 642 643 if (isa<BranchInst>(TI)) { 644 // Okay, one of the successors of this condbr is dead. Convert it to a 645 // uncond br. 646 assert(ThisCases.size() == 1 && "Branch can only have one case!"); 647 // Insert the new branch. 648 Instruction *NI = Builder.CreateBr(ThisDef); 649 (void) NI; 650 651 // Remove PHI node entries for the dead edge. 652 ThisCases[0].Dest->removePredecessor(TI->getParent()); 653 654 DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator() 655 << "Through successor TI: " << *TI << "Leaving: " << *NI << "\n"); 656 657 EraseTerminatorInstAndDCECond(TI); 658 return true; 659 } 660 661 SwitchInst *SI = cast<SwitchInst>(TI); 662 // Okay, TI has cases that are statically dead, prune them away. 663 SmallPtrSet<Constant*, 16> DeadCases; 664 for (unsigned i = 0, e = PredCases.size(); i != e; ++i) 665 DeadCases.insert(PredCases[i].Value); 666 667 DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator() 668 << "Through successor TI: " << *TI); 669 670 for (SwitchInst::CaseIt i = SI->case_end(), e = SI->case_begin(); i != e;) { 671 --i; 672 if (DeadCases.count(i.getCaseValue())) { 673 i.getCaseSuccessor()->removePredecessor(TI->getParent()); 674 SI->removeCase(i); 675 } 676 } 677 678 DEBUG(dbgs() << "Leaving: " << *TI << "\n"); 679 return true; 680 } 681 682 // Otherwise, TI's block must correspond to some matched value. Find out 683 // which value (or set of values) this is. 684 ConstantInt *TIV = 0; 685 BasicBlock *TIBB = TI->getParent(); 686 for (unsigned i = 0, e = PredCases.size(); i != e; ++i) 687 if (PredCases[i].Dest == TIBB) { 688 if (TIV != 0) 689 return false; // Cannot handle multiple values coming to this block. 690 TIV = PredCases[i].Value; 691 } 692 assert(TIV && "No edge from pred to succ?"); 693 694 // Okay, we found the one constant that our value can be if we get into TI's 695 // BB. Find out which successor will unconditionally be branched to. 696 BasicBlock *TheRealDest = 0; 697 for (unsigned i = 0, e = ThisCases.size(); i != e; ++i) 698 if (ThisCases[i].Value == TIV) { 699 TheRealDest = ThisCases[i].Dest; 700 break; 701 } 702 703 // If not handled by any explicit cases, it is handled by the default case. 704 if (TheRealDest == 0) TheRealDest = ThisDef; 705 706 // Remove PHI node entries for dead edges. 707 BasicBlock *CheckEdge = TheRealDest; 708 for (succ_iterator SI = succ_begin(TIBB), e = succ_end(TIBB); SI != e; ++SI) 709 if (*SI != CheckEdge) 710 (*SI)->removePredecessor(TIBB); 711 else 712 CheckEdge = 0; 713 714 // Insert the new branch. 715 Instruction *NI = Builder.CreateBr(TheRealDest); 716 (void) NI; 717 718 DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator() 719 << "Through successor TI: " << *TI << "Leaving: " << *NI << "\n"); 720 721 EraseTerminatorInstAndDCECond(TI); 722 return true; 723 } 724 725 namespace { 726 /// ConstantIntOrdering - This class implements a stable ordering of constant 727 /// integers that does not depend on their address. This is important for 728 /// applications that sort ConstantInt's to ensure uniqueness. 729 struct ConstantIntOrdering { 730 bool operator()(const ConstantInt *LHS, const ConstantInt *RHS) const { 731 return LHS->getValue().ult(RHS->getValue()); 732 } 733 }; 734 } 735 736 static int ConstantIntSortPredicate(const void *P1, const void *P2) { 737 const ConstantInt *LHS = *(const ConstantInt*const*)P1; 738 const ConstantInt *RHS = *(const ConstantInt*const*)P2; 739 if (LHS->getValue().ult(RHS->getValue())) 740 return 1; 741 if (LHS->getValue() == RHS->getValue()) 742 return 0; 743 return -1; 744 } 745 746 static inline bool HasBranchWeights(const Instruction* I) { 747 MDNode* ProfMD = I->getMetadata(LLVMContext::MD_prof); 748 if (ProfMD && ProfMD->getOperand(0)) 749 if (MDString* MDS = dyn_cast<MDString>(ProfMD->getOperand(0))) 750 return MDS->getString().equals("branch_weights"); 751 752 return false; 753 } 754 755 /// Tries to get a branch weight for the given instruction, returns NULL if it 756 /// can't. Pos starts at 0. 757 static ConstantInt* GetWeight(Instruction* I, int Pos) { 758 MDNode* ProfMD = I->getMetadata(LLVMContext::MD_prof); 759 if (ProfMD && ProfMD->getOperand(0)) { 760 if (MDString* MDS = dyn_cast<MDString>(ProfMD->getOperand(0))) { 761 if (MDS->getString().equals("branch_weights")) { 762 assert(ProfMD->getNumOperands() >= 3); 763 return dyn_cast<ConstantInt>(ProfMD->getOperand(1 + Pos)); 764 } 765 } 766 } 767 768 return 0; 769 } 770 771 /// Scale the given weights based on the successor TI's metadata. Scaling is 772 /// done by multiplying every weight by the sum of the successor's weights. 773 static void ScaleWeights(Instruction* STI, MutableArrayRef<uint64_t> Weights) { 774 // Sum the successor's weights 775 assert(HasBranchWeights(STI)); 776 unsigned Scale = 0; 777 MDNode* ProfMD = STI->getMetadata(LLVMContext::MD_prof); 778 for (unsigned i = 1; i < ProfMD->getNumOperands(); ++i) { 779 ConstantInt* CI = dyn_cast<ConstantInt>(ProfMD->getOperand(i)); 780 assert(CI); 781 Scale += CI->getValue().getZExtValue(); 782 } 783 784 // Skip default, as it's replaced during the folding 785 for (unsigned i = 1; i < Weights.size(); ++i) { 786 Weights[i] *= Scale; 787 } 788 } 789 790 /// Sees if any of the weights are too big for a uint32_t, and halves all the 791 /// weights if any are. 792 static void FitWeights(MutableArrayRef<uint64_t> Weights) { 793 bool Halve = false; 794 for (unsigned i = 0; i < Weights.size(); ++i) 795 if (Weights[i] > UINT_MAX) { 796 Halve = true; 797 break; 798 } 799 800 if (! Halve) 801 return; 802 803 for (unsigned i = 0; i < Weights.size(); ++i) 804 Weights[i] /= 2; 805 } 806 807 /// FoldValueComparisonIntoPredecessors - The specified terminator is a value 808 /// equality comparison instruction (either a switch or a branch on "X == c"). 809 /// See if any of the predecessors of the terminator block are value comparisons 810 /// on the same value. If so, and if safe to do so, fold them together. 811 bool SimplifyCFGOpt::FoldValueComparisonIntoPredecessors(TerminatorInst *TI, 812 IRBuilder<> &Builder) { 813 BasicBlock *BB = TI->getParent(); 814 Value *CV = isValueEqualityComparison(TI); // CondVal 815 assert(CV && "Not a comparison?"); 816 bool Changed = false; 817 818 SmallVector<BasicBlock*, 16> Preds(pred_begin(BB), pred_end(BB)); 819 while (!Preds.empty()) { 820 BasicBlock *Pred = Preds.pop_back_val(); 821 822 // See if the predecessor is a comparison with the same value. 823 TerminatorInst *PTI = Pred->getTerminator(); 824 Value *PCV = isValueEqualityComparison(PTI); // PredCondVal 825 826 if (PCV == CV && SafeToMergeTerminators(TI, PTI)) { 827 // Figure out which 'cases' to copy from SI to PSI. 828 std::vector<ValueEqualityComparisonCase> BBCases; 829 BasicBlock *BBDefault = GetValueEqualityComparisonCases(TI, BBCases); 830 831 std::vector<ValueEqualityComparisonCase> PredCases; 832 BasicBlock *PredDefault = GetValueEqualityComparisonCases(PTI, PredCases); 833 834 // Based on whether the default edge from PTI goes to BB or not, fill in 835 // PredCases and PredDefault with the new switch cases we would like to 836 // build. 837 SmallVector<BasicBlock*, 8> NewSuccessors; 838 839 // Update the branch weight metadata along the way 840 SmallVector<uint64_t, 8> Weights; 841 uint64_t PredDefaultWeight = 0; 842 bool PredHasWeights = HasBranchWeights(PTI); 843 bool SuccHasWeights = HasBranchWeights(TI); 844 845 if (PredHasWeights) { 846 MDNode* MD = PTI->getMetadata(LLVMContext::MD_prof); 847 assert(MD); 848 for (unsigned i = 1, e = MD->getNumOperands(); i < e; ++i) { 849 ConstantInt* CI = dyn_cast<ConstantInt>(MD->getOperand(i)); 850 assert(CI); 851 Weights.push_back(CI->getValue().getZExtValue()); 852 } 853 854 // If the predecessor is a conditional eq, then swap the default weight 855 // to be the first entry. 856 if (BranchInst* BI = dyn_cast<BranchInst>(PTI)) { 857 assert(Weights.size() == 2); 858 ICmpInst *ICI = cast<ICmpInst>(BI->getCondition()); 859 860 if (ICI->getPredicate() == ICmpInst::ICMP_EQ) { 861 std::swap(Weights.front(), Weights.back()); 862 } 863 } 864 865 PredDefaultWeight = Weights.front(); 866 } else if (SuccHasWeights) { 867 // If there are no predecessor weights but there are successor weights, 868 // populate Weights with 1, which will later be scaled to the sum of 869 // successor's weights 870 Weights.assign(1 + PredCases.size(), 1); 871 PredDefaultWeight = 1; 872 } 873 874 uint64_t SuccDefaultWeight = 0; 875 if (SuccHasWeights) { 876 int Index = 0; 877 if (BranchInst* BI = dyn_cast<BranchInst>(TI)) { 878 ICmpInst* ICI = dyn_cast<ICmpInst>(BI->getCondition()); 879 assert(ICI); 880 881 if (ICI->getPredicate() == ICmpInst::ICMP_EQ) 882 Index = 1; 883 } 884 885 SuccDefaultWeight = GetWeight(TI, Index)->getValue().getZExtValue(); 886 } 887 888 if (PredDefault == BB) { 889 // If this is the default destination from PTI, only the edges in TI 890 // that don't occur in PTI, or that branch to BB will be activated. 891 std::set<ConstantInt*, ConstantIntOrdering> PTIHandled; 892 for (unsigned i = 0, e = PredCases.size(); i != e; ++i) 893 if (PredCases[i].Dest != BB) 894 PTIHandled.insert(PredCases[i].Value); 895 else { 896 // The default destination is BB, we don't need explicit targets. 897 std::swap(PredCases[i], PredCases.back()); 898 899 if (PredHasWeights) { 900 std::swap(Weights[i+1], Weights.back()); 901 Weights.pop_back(); 902 } 903 904 PredCases.pop_back(); 905 --i; --e; 906 } 907 908 // Reconstruct the new switch statement we will be building. 909 if (PredDefault != BBDefault) { 910 PredDefault->removePredecessor(Pred); 911 PredDefault = BBDefault; 912 NewSuccessors.push_back(BBDefault); 913 } 914 915 if (SuccHasWeights) { 916 ScaleWeights(TI, Weights); 917 Weights.front() *= SuccDefaultWeight; 918 } else if (PredHasWeights) { 919 Weights.front() /= (1 + BBCases.size()); 920 } 921 922 for (unsigned i = 0, e = BBCases.size(); i != e; ++i) 923 if (!PTIHandled.count(BBCases[i].Value) && 924 BBCases[i].Dest != BBDefault) { 925 PredCases.push_back(BBCases[i]); 926 NewSuccessors.push_back(BBCases[i].Dest); 927 if (SuccHasWeights) { 928 Weights.push_back(PredDefaultWeight * 929 GetWeight(TI, i)->getValue().getZExtValue()); 930 } else if (PredHasWeights) { 931 // Split the old default's weight amongst the children 932 Weights.push_back(PredDefaultWeight / (1 + BBCases.size())); 933 } 934 } 935 936 } else { 937 // FIXME: preserve branch weight metadata, similarly to the 'then' 938 // above. For now, drop it. 939 PredHasWeights = false; 940 SuccHasWeights = false; 941 942 // If this is not the default destination from PSI, only the edges 943 // in SI that occur in PSI with a destination of BB will be 944 // activated. 945 std::set<ConstantInt*, ConstantIntOrdering> PTIHandled; 946 for (unsigned i = 0, e = PredCases.size(); i != e; ++i) 947 if (PredCases[i].Dest == BB) { 948 PTIHandled.insert(PredCases[i].Value); 949 std::swap(PredCases[i], PredCases.back()); 950 PredCases.pop_back(); 951 --i; --e; 952 } 953 954 // Okay, now we know which constants were sent to BB from the 955 // predecessor. Figure out where they will all go now. 956 for (unsigned i = 0, e = BBCases.size(); i != e; ++i) 957 if (PTIHandled.count(BBCases[i].Value)) { 958 // If this is one we are capable of getting... 959 PredCases.push_back(BBCases[i]); 960 NewSuccessors.push_back(BBCases[i].Dest); 961 PTIHandled.erase(BBCases[i].Value);// This constant is taken care of 962 } 963 964 // If there are any constants vectored to BB that TI doesn't handle, 965 // they must go to the default destination of TI. 966 for (std::set<ConstantInt*, ConstantIntOrdering>::iterator I = 967 PTIHandled.begin(), 968 E = PTIHandled.end(); I != E; ++I) { 969 PredCases.push_back(ValueEqualityComparisonCase(*I, BBDefault)); 970 NewSuccessors.push_back(BBDefault); 971 } 972 } 973 974 // Okay, at this point, we know which new successor Pred will get. Make 975 // sure we update the number of entries in the PHI nodes for these 976 // successors. 977 for (unsigned i = 0, e = NewSuccessors.size(); i != e; ++i) 978 AddPredecessorToBlock(NewSuccessors[i], Pred, BB); 979 980 Builder.SetInsertPoint(PTI); 981 // Convert pointer to int before we switch. 982 if (CV->getType()->isPointerTy()) { 983 assert(TD && "Cannot switch on pointer without TargetData"); 984 CV = Builder.CreatePtrToInt(CV, TD->getIntPtrType(CV->getContext()), 985 "magicptr"); 986 } 987 988 // Now that the successors are updated, create the new Switch instruction. 989 SwitchInst *NewSI = Builder.CreateSwitch(CV, PredDefault, 990 PredCases.size()); 991 NewSI->setDebugLoc(PTI->getDebugLoc()); 992 for (unsigned i = 0, e = PredCases.size(); i != e; ++i) 993 NewSI->addCase(PredCases[i].Value, PredCases[i].Dest); 994 995 if (PredHasWeights || SuccHasWeights) { 996 // Halve the weights if any of them cannot fit in an uint32_t 997 FitWeights(Weights); 998 999 SmallVector<uint32_t, 8> MDWeights(Weights.begin(), Weights.end()); 1000 1001 NewSI->setMetadata(LLVMContext::MD_prof, 1002 MDBuilder(BB->getContext()). 1003 createBranchWeights(MDWeights)); 1004 } 1005 1006 EraseTerminatorInstAndDCECond(PTI); 1007 1008 // Okay, last check. If BB is still a successor of PSI, then we must 1009 // have an infinite loop case. If so, add an infinitely looping block 1010 // to handle the case to preserve the behavior of the code. 1011 BasicBlock *InfLoopBlock = 0; 1012 for (unsigned i = 0, e = NewSI->getNumSuccessors(); i != e; ++i) 1013 if (NewSI->getSuccessor(i) == BB) { 1014 if (InfLoopBlock == 0) { 1015 // Insert it at the end of the function, because it's either code, 1016 // or it won't matter if it's hot. :) 1017 InfLoopBlock = BasicBlock::Create(BB->getContext(), 1018 "infloop", BB->getParent()); 1019 BranchInst::Create(InfLoopBlock, InfLoopBlock); 1020 } 1021 NewSI->setSuccessor(i, InfLoopBlock); 1022 } 1023 1024 Changed = true; 1025 } 1026 } 1027 return Changed; 1028 } 1029 1030 // isSafeToHoistInvoke - If we would need to insert a select that uses the 1031 // value of this invoke (comments in HoistThenElseCodeToIf explain why we 1032 // would need to do this), we can't hoist the invoke, as there is nowhere 1033 // to put the select in this case. 1034 static bool isSafeToHoistInvoke(BasicBlock *BB1, BasicBlock *BB2, 1035 Instruction *I1, Instruction *I2) { 1036 for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) { 1037 PHINode *PN; 1038 for (BasicBlock::iterator BBI = SI->begin(); 1039 (PN = dyn_cast<PHINode>(BBI)); ++BBI) { 1040 Value *BB1V = PN->getIncomingValueForBlock(BB1); 1041 Value *BB2V = PN->getIncomingValueForBlock(BB2); 1042 if (BB1V != BB2V && (BB1V==I1 || BB2V==I2)) { 1043 return false; 1044 } 1045 } 1046 } 1047 return true; 1048 } 1049 1050 /// HoistThenElseCodeToIf - Given a conditional branch that goes to BB1 and 1051 /// BB2, hoist any common code in the two blocks up into the branch block. The 1052 /// caller of this function guarantees that BI's block dominates BB1 and BB2. 1053 static bool HoistThenElseCodeToIf(BranchInst *BI) { 1054 // This does very trivial matching, with limited scanning, to find identical 1055 // instructions in the two blocks. In particular, we don't want to get into 1056 // O(M*N) situations here where M and N are the sizes of BB1 and BB2. As 1057 // such, we currently just scan for obviously identical instructions in an 1058 // identical order. 1059 BasicBlock *BB1 = BI->getSuccessor(0); // The true destination. 1060 BasicBlock *BB2 = BI->getSuccessor(1); // The false destination 1061 1062 BasicBlock::iterator BB1_Itr = BB1->begin(); 1063 BasicBlock::iterator BB2_Itr = BB2->begin(); 1064 1065 Instruction *I1 = BB1_Itr++, *I2 = BB2_Itr++; 1066 // Skip debug info if it is not identical. 1067 DbgInfoIntrinsic *DBI1 = dyn_cast<DbgInfoIntrinsic>(I1); 1068 DbgInfoIntrinsic *DBI2 = dyn_cast<DbgInfoIntrinsic>(I2); 1069 if (!DBI1 || !DBI2 || !DBI1->isIdenticalToWhenDefined(DBI2)) { 1070 while (isa<DbgInfoIntrinsic>(I1)) 1071 I1 = BB1_Itr++; 1072 while (isa<DbgInfoIntrinsic>(I2)) 1073 I2 = BB2_Itr++; 1074 } 1075 if (isa<PHINode>(I1) || !I1->isIdenticalToWhenDefined(I2) || 1076 (isa<InvokeInst>(I1) && !isSafeToHoistInvoke(BB1, BB2, I1, I2))) 1077 return false; 1078 1079 // If we get here, we can hoist at least one instruction. 1080 BasicBlock *BIParent = BI->getParent(); 1081 1082 do { 1083 // If we are hoisting the terminator instruction, don't move one (making a 1084 // broken BB), instead clone it, and remove BI. 1085 if (isa<TerminatorInst>(I1)) 1086 goto HoistTerminator; 1087 1088 // For a normal instruction, we just move one to right before the branch, 1089 // then replace all uses of the other with the first. Finally, we remove 1090 // the now redundant second instruction. 1091 BIParent->getInstList().splice(BI, BB1->getInstList(), I1); 1092 if (!I2->use_empty()) 1093 I2->replaceAllUsesWith(I1); 1094 I1->intersectOptionalDataWith(I2); 1095 I2->eraseFromParent(); 1096 1097 I1 = BB1_Itr++; 1098 I2 = BB2_Itr++; 1099 // Skip debug info if it is not identical. 1100 DbgInfoIntrinsic *DBI1 = dyn_cast<DbgInfoIntrinsic>(I1); 1101 DbgInfoIntrinsic *DBI2 = dyn_cast<DbgInfoIntrinsic>(I2); 1102 if (!DBI1 || !DBI2 || !DBI1->isIdenticalToWhenDefined(DBI2)) { 1103 while (isa<DbgInfoIntrinsic>(I1)) 1104 I1 = BB1_Itr++; 1105 while (isa<DbgInfoIntrinsic>(I2)) 1106 I2 = BB2_Itr++; 1107 } 1108 } while (I1->isIdenticalToWhenDefined(I2)); 1109 1110 return true; 1111 1112 HoistTerminator: 1113 // It may not be possible to hoist an invoke. 1114 if (isa<InvokeInst>(I1) && !isSafeToHoistInvoke(BB1, BB2, I1, I2)) 1115 return true; 1116 1117 // Okay, it is safe to hoist the terminator. 1118 Instruction *NT = I1->clone(); 1119 BIParent->getInstList().insert(BI, NT); 1120 if (!NT->getType()->isVoidTy()) { 1121 I1->replaceAllUsesWith(NT); 1122 I2->replaceAllUsesWith(NT); 1123 NT->takeName(I1); 1124 } 1125 1126 IRBuilder<true, NoFolder> Builder(NT); 1127 // Hoisting one of the terminators from our successor is a great thing. 1128 // Unfortunately, the successors of the if/else blocks may have PHI nodes in 1129 // them. If they do, all PHI entries for BB1/BB2 must agree for all PHI 1130 // nodes, so we insert select instruction to compute the final result. 1131 std::map<std::pair<Value*,Value*>, SelectInst*> InsertedSelects; 1132 for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) { 1133 PHINode *PN; 1134 for (BasicBlock::iterator BBI = SI->begin(); 1135 (PN = dyn_cast<PHINode>(BBI)); ++BBI) { 1136 Value *BB1V = PN->getIncomingValueForBlock(BB1); 1137 Value *BB2V = PN->getIncomingValueForBlock(BB2); 1138 if (BB1V == BB2V) continue; 1139 1140 // These values do not agree. Insert a select instruction before NT 1141 // that determines the right value. 1142 SelectInst *&SI = InsertedSelects[std::make_pair(BB1V, BB2V)]; 1143 if (SI == 0) 1144 SI = cast<SelectInst> 1145 (Builder.CreateSelect(BI->getCondition(), BB1V, BB2V, 1146 BB1V->getName()+"."+BB2V->getName())); 1147 1148 // Make the PHI node use the select for all incoming values for BB1/BB2 1149 for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 1150 if (PN->getIncomingBlock(i) == BB1 || PN->getIncomingBlock(i) == BB2) 1151 PN->setIncomingValue(i, SI); 1152 } 1153 } 1154 1155 // Update any PHI nodes in our new successors. 1156 for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) 1157 AddPredecessorToBlock(*SI, BIParent, BB1); 1158 1159 EraseTerminatorInstAndDCECond(BI); 1160 return true; 1161 } 1162 1163 /// SpeculativelyExecuteBB - Given a conditional branch that goes to BB1 1164 /// and an BB2 and the only successor of BB1 is BB2, hoist simple code 1165 /// (for now, restricted to a single instruction that's side effect free) from 1166 /// the BB1 into the branch block to speculatively execute it. 1167 /// 1168 /// Turn 1169 /// BB: 1170 /// %t1 = icmp 1171 /// br i1 %t1, label %BB1, label %BB2 1172 /// BB1: 1173 /// %t3 = add %t2, c 1174 /// br label BB2 1175 /// BB2: 1176 /// => 1177 /// BB: 1178 /// %t1 = icmp 1179 /// %t4 = add %t2, c 1180 /// %t3 = select i1 %t1, %t2, %t3 1181 static bool SpeculativelyExecuteBB(BranchInst *BI, BasicBlock *BB1) { 1182 // Only speculatively execution a single instruction (not counting the 1183 // terminator) for now. 1184 Instruction *HInst = NULL; 1185 Instruction *Term = BB1->getTerminator(); 1186 for (BasicBlock::iterator BBI = BB1->begin(), BBE = BB1->end(); 1187 BBI != BBE; ++BBI) { 1188 Instruction *I = BBI; 1189 // Skip debug info. 1190 if (isa<DbgInfoIntrinsic>(I)) continue; 1191 if (I == Term) break; 1192 1193 if (HInst) 1194 return false; 1195 HInst = I; 1196 } 1197 1198 BasicBlock *BIParent = BI->getParent(); 1199 1200 // Check the instruction to be hoisted, if there is one. 1201 if (HInst) { 1202 // Don't hoist the instruction if it's unsafe or expensive. 1203 if (!isSafeToSpeculativelyExecute(HInst)) 1204 return false; 1205 if (ComputeSpeculationCost(HInst) > PHINodeFoldingThreshold) 1206 return false; 1207 1208 // Do not hoist the instruction if any of its operands are defined but not 1209 // used in this BB. The transformation will prevent the operand from 1210 // being sunk into the use block. 1211 for (User::op_iterator i = HInst->op_begin(), e = HInst->op_end(); 1212 i != e; ++i) { 1213 Instruction *OpI = dyn_cast<Instruction>(*i); 1214 if (OpI && OpI->getParent() == BIParent && 1215 !OpI->mayHaveSideEffects() && 1216 !OpI->isUsedInBasicBlock(BIParent)) 1217 return false; 1218 } 1219 } 1220 1221 // Be conservative for now. FP select instruction can often be expensive. 1222 Value *BrCond = BI->getCondition(); 1223 if (isa<FCmpInst>(BrCond)) 1224 return false; 1225 1226 // If BB1 is actually on the false edge of the conditional branch, remember 1227 // to swap the select operands later. 1228 bool Invert = false; 1229 if (BB1 != BI->getSuccessor(0)) { 1230 assert(BB1 == BI->getSuccessor(1) && "No edge from 'if' block?"); 1231 Invert = true; 1232 } 1233 1234 // Collect interesting PHIs, and scan for hazards. 1235 SmallSetVector<std::pair<Value *, Value *>, 4> PHIs; 1236 BasicBlock *BB2 = BB1->getTerminator()->getSuccessor(0); 1237 for (BasicBlock::iterator I = BB2->begin(); 1238 PHINode *PN = dyn_cast<PHINode>(I); ++I) { 1239 Value *BB1V = PN->getIncomingValueForBlock(BB1); 1240 Value *BIParentV = PN->getIncomingValueForBlock(BIParent); 1241 1242 // Skip PHIs which are trivial. 1243 if (BB1V == BIParentV) 1244 continue; 1245 1246 // Check for saftey. 1247 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(BB1V)) { 1248 // An unfolded ConstantExpr could end up getting expanded into 1249 // Instructions. Don't speculate this and another instruction at 1250 // the same time. 1251 if (HInst) 1252 return false; 1253 if (!isSafeToSpeculativelyExecute(CE)) 1254 return false; 1255 if (ComputeSpeculationCost(CE) > PHINodeFoldingThreshold) 1256 return false; 1257 } 1258 1259 // Ok, we may insert a select for this PHI. 1260 PHIs.insert(std::make_pair(BB1V, BIParentV)); 1261 } 1262 1263 // If there are no PHIs to process, bail early. This helps ensure idempotence 1264 // as well. 1265 if (PHIs.empty()) 1266 return false; 1267 1268 // If we get here, we can hoist the instruction and if-convert. 1269 DEBUG(dbgs() << "SPECULATIVELY EXECUTING BB" << *BB1 << "\n";); 1270 1271 // Hoist the instruction. 1272 if (HInst) 1273 BIParent->getInstList().splice(BI, BB1->getInstList(), HInst); 1274 1275 // Insert selects and rewrite the PHI operands. 1276 IRBuilder<true, NoFolder> Builder(BI); 1277 for (unsigned i = 0, e = PHIs.size(); i != e; ++i) { 1278 Value *TrueV = PHIs[i].first; 1279 Value *FalseV = PHIs[i].second; 1280 1281 // Create a select whose true value is the speculatively executed value and 1282 // false value is the previously determined FalseV. 1283 SelectInst *SI; 1284 if (Invert) 1285 SI = cast<SelectInst> 1286 (Builder.CreateSelect(BrCond, FalseV, TrueV, 1287 FalseV->getName() + "." + TrueV->getName())); 1288 else 1289 SI = cast<SelectInst> 1290 (Builder.CreateSelect(BrCond, TrueV, FalseV, 1291 TrueV->getName() + "." + FalseV->getName())); 1292 1293 // Make the PHI node use the select for all incoming values for "then" and 1294 // "if" blocks. 1295 for (BasicBlock::iterator I = BB2->begin(); 1296 PHINode *PN = dyn_cast<PHINode>(I); ++I) { 1297 unsigned BB1I = PN->getBasicBlockIndex(BB1); 1298 unsigned BIParentI = PN->getBasicBlockIndex(BIParent); 1299 Value *BB1V = PN->getIncomingValue(BB1I); 1300 Value *BIParentV = PN->getIncomingValue(BIParentI); 1301 if (TrueV == BB1V && FalseV == BIParentV) { 1302 PN->setIncomingValue(BB1I, SI); 1303 PN->setIncomingValue(BIParentI, SI); 1304 } 1305 } 1306 } 1307 1308 ++NumSpeculations; 1309 return true; 1310 } 1311 1312 /// BlockIsSimpleEnoughToThreadThrough - Return true if we can thread a branch 1313 /// across this block. 1314 static bool BlockIsSimpleEnoughToThreadThrough(BasicBlock *BB) { 1315 BranchInst *BI = cast<BranchInst>(BB->getTerminator()); 1316 unsigned Size = 0; 1317 1318 for (BasicBlock::iterator BBI = BB->begin(); &*BBI != BI; ++BBI) { 1319 if (isa<DbgInfoIntrinsic>(BBI)) 1320 continue; 1321 if (Size > 10) return false; // Don't clone large BB's. 1322 ++Size; 1323 1324 // We can only support instructions that do not define values that are 1325 // live outside of the current basic block. 1326 for (Value::use_iterator UI = BBI->use_begin(), E = BBI->use_end(); 1327 UI != E; ++UI) { 1328 Instruction *U = cast<Instruction>(*UI); 1329 if (U->getParent() != BB || isa<PHINode>(U)) return false; 1330 } 1331 1332 // Looks ok, continue checking. 1333 } 1334 1335 return true; 1336 } 1337 1338 /// FoldCondBranchOnPHI - If we have a conditional branch on a PHI node value 1339 /// that is defined in the same block as the branch and if any PHI entries are 1340 /// constants, thread edges corresponding to that entry to be branches to their 1341 /// ultimate destination. 1342 static bool FoldCondBranchOnPHI(BranchInst *BI, const TargetData *TD) { 1343 BasicBlock *BB = BI->getParent(); 1344 PHINode *PN = dyn_cast<PHINode>(BI->getCondition()); 1345 // NOTE: we currently cannot transform this case if the PHI node is used 1346 // outside of the block. 1347 if (!PN || PN->getParent() != BB || !PN->hasOneUse()) 1348 return false; 1349 1350 // Degenerate case of a single entry PHI. 1351 if (PN->getNumIncomingValues() == 1) { 1352 FoldSingleEntryPHINodes(PN->getParent()); 1353 return true; 1354 } 1355 1356 // Now we know that this block has multiple preds and two succs. 1357 if (!BlockIsSimpleEnoughToThreadThrough(BB)) return false; 1358 1359 // Okay, this is a simple enough basic block. See if any phi values are 1360 // constants. 1361 for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { 1362 ConstantInt *CB = dyn_cast<ConstantInt>(PN->getIncomingValue(i)); 1363 if (CB == 0 || !CB->getType()->isIntegerTy(1)) continue; 1364 1365 // Okay, we now know that all edges from PredBB should be revectored to 1366 // branch to RealDest. 1367 BasicBlock *PredBB = PN->getIncomingBlock(i); 1368 BasicBlock *RealDest = BI->getSuccessor(!CB->getZExtValue()); 1369 1370 if (RealDest == BB) continue; // Skip self loops. 1371 // Skip if the predecessor's terminator is an indirect branch. 1372 if (isa<IndirectBrInst>(PredBB->getTerminator())) continue; 1373 1374 // The dest block might have PHI nodes, other predecessors and other 1375 // difficult cases. Instead of being smart about this, just insert a new 1376 // block that jumps to the destination block, effectively splitting 1377 // the edge we are about to create. 1378 BasicBlock *EdgeBB = BasicBlock::Create(BB->getContext(), 1379 RealDest->getName()+".critedge", 1380 RealDest->getParent(), RealDest); 1381 BranchInst::Create(RealDest, EdgeBB); 1382 1383 // Update PHI nodes. 1384 AddPredecessorToBlock(RealDest, EdgeBB, BB); 1385 1386 // BB may have instructions that are being threaded over. Clone these 1387 // instructions into EdgeBB. We know that there will be no uses of the 1388 // cloned instructions outside of EdgeBB. 1389 BasicBlock::iterator InsertPt = EdgeBB->begin(); 1390 DenseMap<Value*, Value*> TranslateMap; // Track translated values. 1391 for (BasicBlock::iterator BBI = BB->begin(); &*BBI != BI; ++BBI) { 1392 if (PHINode *PN = dyn_cast<PHINode>(BBI)) { 1393 TranslateMap[PN] = PN->getIncomingValueForBlock(PredBB); 1394 continue; 1395 } 1396 // Clone the instruction. 1397 Instruction *N = BBI->clone(); 1398 if (BBI->hasName()) N->setName(BBI->getName()+".c"); 1399 1400 // Update operands due to translation. 1401 for (User::op_iterator i = N->op_begin(), e = N->op_end(); 1402 i != e; ++i) { 1403 DenseMap<Value*, Value*>::iterator PI = TranslateMap.find(*i); 1404 if (PI != TranslateMap.end()) 1405 *i = PI->second; 1406 } 1407 1408 // Check for trivial simplification. 1409 if (Value *V = SimplifyInstruction(N, TD)) { 1410 TranslateMap[BBI] = V; 1411 delete N; // Instruction folded away, don't need actual inst 1412 } else { 1413 // Insert the new instruction into its new home. 1414 EdgeBB->getInstList().insert(InsertPt, N); 1415 if (!BBI->use_empty()) 1416 TranslateMap[BBI] = N; 1417 } 1418 } 1419 1420 // Loop over all of the edges from PredBB to BB, changing them to branch 1421 // to EdgeBB instead. 1422 TerminatorInst *PredBBTI = PredBB->getTerminator(); 1423 for (unsigned i = 0, e = PredBBTI->getNumSuccessors(); i != e; ++i) 1424 if (PredBBTI->getSuccessor(i) == BB) { 1425 BB->removePredecessor(PredBB); 1426 PredBBTI->setSuccessor(i, EdgeBB); 1427 } 1428 1429 // Recurse, simplifying any other constants. 1430 return FoldCondBranchOnPHI(BI, TD) | true; 1431 } 1432 1433 return false; 1434 } 1435 1436 /// FoldTwoEntryPHINode - Given a BB that starts with the specified two-entry 1437 /// PHI node, see if we can eliminate it. 1438 static bool FoldTwoEntryPHINode(PHINode *PN, const TargetData *TD) { 1439 // Ok, this is a two entry PHI node. Check to see if this is a simple "if 1440 // statement", which has a very simple dominance structure. Basically, we 1441 // are trying to find the condition that is being branched on, which 1442 // subsequently causes this merge to happen. We really want control 1443 // dependence information for this check, but simplifycfg can't keep it up 1444 // to date, and this catches most of the cases we care about anyway. 1445 BasicBlock *BB = PN->getParent(); 1446 BasicBlock *IfTrue, *IfFalse; 1447 Value *IfCond = GetIfCondition(BB, IfTrue, IfFalse); 1448 if (!IfCond || 1449 // Don't bother if the branch will be constant folded trivially. 1450 isa<ConstantInt>(IfCond)) 1451 return false; 1452 1453 // Okay, we found that we can merge this two-entry phi node into a select. 1454 // Doing so would require us to fold *all* two entry phi nodes in this block. 1455 // At some point this becomes non-profitable (particularly if the target 1456 // doesn't support cmov's). Only do this transformation if there are two or 1457 // fewer PHI nodes in this block. 1458 unsigned NumPhis = 0; 1459 for (BasicBlock::iterator I = BB->begin(); isa<PHINode>(I); ++NumPhis, ++I) 1460 if (NumPhis > 2) 1461 return false; 1462 1463 // Loop over the PHI's seeing if we can promote them all to select 1464 // instructions. While we are at it, keep track of the instructions 1465 // that need to be moved to the dominating block. 1466 SmallPtrSet<Instruction*, 4> AggressiveInsts; 1467 unsigned MaxCostVal0 = PHINodeFoldingThreshold, 1468 MaxCostVal1 = PHINodeFoldingThreshold; 1469 1470 for (BasicBlock::iterator II = BB->begin(); isa<PHINode>(II);) { 1471 PHINode *PN = cast<PHINode>(II++); 1472 if (Value *V = SimplifyInstruction(PN, TD)) { 1473 PN->replaceAllUsesWith(V); 1474 PN->eraseFromParent(); 1475 continue; 1476 } 1477 1478 if (!DominatesMergePoint(PN->getIncomingValue(0), BB, &AggressiveInsts, 1479 MaxCostVal0) || 1480 !DominatesMergePoint(PN->getIncomingValue(1), BB, &AggressiveInsts, 1481 MaxCostVal1)) 1482 return false; 1483 } 1484 1485 // If we folded the first phi, PN dangles at this point. Refresh it. If 1486 // we ran out of PHIs then we simplified them all. 1487 PN = dyn_cast<PHINode>(BB->begin()); 1488 if (PN == 0) return true; 1489 1490 // Don't fold i1 branches on PHIs which contain binary operators. These can 1491 // often be turned into switches and other things. 1492 if (PN->getType()->isIntegerTy(1) && 1493 (isa<BinaryOperator>(PN->getIncomingValue(0)) || 1494 isa<BinaryOperator>(PN->getIncomingValue(1)) || 1495 isa<BinaryOperator>(IfCond))) 1496 return false; 1497 1498 // If we all PHI nodes are promotable, check to make sure that all 1499 // instructions in the predecessor blocks can be promoted as well. If 1500 // not, we won't be able to get rid of the control flow, so it's not 1501 // worth promoting to select instructions. 1502 BasicBlock *DomBlock = 0; 1503 BasicBlock *IfBlock1 = PN->getIncomingBlock(0); 1504 BasicBlock *IfBlock2 = PN->getIncomingBlock(1); 1505 if (cast<BranchInst>(IfBlock1->getTerminator())->isConditional()) { 1506 IfBlock1 = 0; 1507 } else { 1508 DomBlock = *pred_begin(IfBlock1); 1509 for (BasicBlock::iterator I = IfBlock1->begin();!isa<TerminatorInst>(I);++I) 1510 if (!AggressiveInsts.count(I) && !isa<DbgInfoIntrinsic>(I)) { 1511 // This is not an aggressive instruction that we can promote. 1512 // Because of this, we won't be able to get rid of the control 1513 // flow, so the xform is not worth it. 1514 return false; 1515 } 1516 } 1517 1518 if (cast<BranchInst>(IfBlock2->getTerminator())->isConditional()) { 1519 IfBlock2 = 0; 1520 } else { 1521 DomBlock = *pred_begin(IfBlock2); 1522 for (BasicBlock::iterator I = IfBlock2->begin();!isa<TerminatorInst>(I);++I) 1523 if (!AggressiveInsts.count(I) && !isa<DbgInfoIntrinsic>(I)) { 1524 // This is not an aggressive instruction that we can promote. 1525 // Because of this, we won't be able to get rid of the control 1526 // flow, so the xform is not worth it. 1527 return false; 1528 } 1529 } 1530 1531 DEBUG(dbgs() << "FOUND IF CONDITION! " << *IfCond << " T: " 1532 << IfTrue->getName() << " F: " << IfFalse->getName() << "\n"); 1533 1534 // If we can still promote the PHI nodes after this gauntlet of tests, 1535 // do all of the PHI's now. 1536 Instruction *InsertPt = DomBlock->getTerminator(); 1537 IRBuilder<true, NoFolder> Builder(InsertPt); 1538 1539 // Move all 'aggressive' instructions, which are defined in the 1540 // conditional parts of the if's up to the dominating block. 1541 if (IfBlock1) 1542 DomBlock->getInstList().splice(InsertPt, 1543 IfBlock1->getInstList(), IfBlock1->begin(), 1544 IfBlock1->getTerminator()); 1545 if (IfBlock2) 1546 DomBlock->getInstList().splice(InsertPt, 1547 IfBlock2->getInstList(), IfBlock2->begin(), 1548 IfBlock2->getTerminator()); 1549 1550 while (PHINode *PN = dyn_cast<PHINode>(BB->begin())) { 1551 // Change the PHI node into a select instruction. 1552 Value *TrueVal = PN->getIncomingValue(PN->getIncomingBlock(0) == IfFalse); 1553 Value *FalseVal = PN->getIncomingValue(PN->getIncomingBlock(0) == IfTrue); 1554 1555 SelectInst *NV = 1556 cast<SelectInst>(Builder.CreateSelect(IfCond, TrueVal, FalseVal, "")); 1557 PN->replaceAllUsesWith(NV); 1558 NV->takeName(PN); 1559 PN->eraseFromParent(); 1560 } 1561 1562 // At this point, IfBlock1 and IfBlock2 are both empty, so our if statement 1563 // has been flattened. Change DomBlock to jump directly to our new block to 1564 // avoid other simplifycfg's kicking in on the diamond. 1565 TerminatorInst *OldTI = DomBlock->getTerminator(); 1566 Builder.SetInsertPoint(OldTI); 1567 Builder.CreateBr(BB); 1568 OldTI->eraseFromParent(); 1569 return true; 1570 } 1571 1572 /// SimplifyCondBranchToTwoReturns - If we found a conditional branch that goes 1573 /// to two returning blocks, try to merge them together into one return, 1574 /// introducing a select if the return values disagree. 1575 static bool SimplifyCondBranchToTwoReturns(BranchInst *BI, 1576 IRBuilder<> &Builder) { 1577 assert(BI->isConditional() && "Must be a conditional branch"); 1578 BasicBlock *TrueSucc = BI->getSuccessor(0); 1579 BasicBlock *FalseSucc = BI->getSuccessor(1); 1580 ReturnInst *TrueRet = cast<ReturnInst>(TrueSucc->getTerminator()); 1581 ReturnInst *FalseRet = cast<ReturnInst>(FalseSucc->getTerminator()); 1582 1583 // Check to ensure both blocks are empty (just a return) or optionally empty 1584 // with PHI nodes. If there are other instructions, merging would cause extra 1585 // computation on one path or the other. 1586 if (!TrueSucc->getFirstNonPHIOrDbg()->isTerminator()) 1587 return false; 1588 if (!FalseSucc->getFirstNonPHIOrDbg()->isTerminator()) 1589 return false; 1590 1591 Builder.SetInsertPoint(BI); 1592 // Okay, we found a branch that is going to two return nodes. If 1593 // there is no return value for this function, just change the 1594 // branch into a return. 1595 if (FalseRet->getNumOperands() == 0) { 1596 TrueSucc->removePredecessor(BI->getParent()); 1597 FalseSucc->removePredecessor(BI->getParent()); 1598 Builder.CreateRetVoid(); 1599 EraseTerminatorInstAndDCECond(BI); 1600 return true; 1601 } 1602 1603 // Otherwise, figure out what the true and false return values are 1604 // so we can insert a new select instruction. 1605 Value *TrueValue = TrueRet->getReturnValue(); 1606 Value *FalseValue = FalseRet->getReturnValue(); 1607 1608 // Unwrap any PHI nodes in the return blocks. 1609 if (PHINode *TVPN = dyn_cast_or_null<PHINode>(TrueValue)) 1610 if (TVPN->getParent() == TrueSucc) 1611 TrueValue = TVPN->getIncomingValueForBlock(BI->getParent()); 1612 if (PHINode *FVPN = dyn_cast_or_null<PHINode>(FalseValue)) 1613 if (FVPN->getParent() == FalseSucc) 1614 FalseValue = FVPN->getIncomingValueForBlock(BI->getParent()); 1615 1616 // In order for this transformation to be safe, we must be able to 1617 // unconditionally execute both operands to the return. This is 1618 // normally the case, but we could have a potentially-trapping 1619 // constant expression that prevents this transformation from being 1620 // safe. 1621 if (ConstantExpr *TCV = dyn_cast_or_null<ConstantExpr>(TrueValue)) 1622 if (TCV->canTrap()) 1623 return false; 1624 if (ConstantExpr *FCV = dyn_cast_or_null<ConstantExpr>(FalseValue)) 1625 if (FCV->canTrap()) 1626 return false; 1627 1628 // Okay, we collected all the mapped values and checked them for sanity, and 1629 // defined to really do this transformation. First, update the CFG. 1630 TrueSucc->removePredecessor(BI->getParent()); 1631 FalseSucc->removePredecessor(BI->getParent()); 1632 1633 // Insert select instructions where needed. 1634 Value *BrCond = BI->getCondition(); 1635 if (TrueValue) { 1636 // Insert a select if the results differ. 1637 if (TrueValue == FalseValue || isa<UndefValue>(FalseValue)) { 1638 } else if (isa<UndefValue>(TrueValue)) { 1639 TrueValue = FalseValue; 1640 } else { 1641 TrueValue = Builder.CreateSelect(BrCond, TrueValue, 1642 FalseValue, "retval"); 1643 } 1644 } 1645 1646 Value *RI = !TrueValue ? 1647 Builder.CreateRetVoid() : Builder.CreateRet(TrueValue); 1648 1649 (void) RI; 1650 1651 DEBUG(dbgs() << "\nCHANGING BRANCH TO TWO RETURNS INTO SELECT:" 1652 << "\n " << *BI << "NewRet = " << *RI 1653 << "TRUEBLOCK: " << *TrueSucc << "FALSEBLOCK: "<< *FalseSucc); 1654 1655 EraseTerminatorInstAndDCECond(BI); 1656 1657 return true; 1658 } 1659 1660 /// ExtractBranchMetadata - Given a conditional BranchInstruction, retrieve the 1661 /// probabilities of the branch taking each edge. Fills in the two APInt 1662 /// parameters and return true, or returns false if no or invalid metadata was 1663 /// found. 1664 static bool ExtractBranchMetadata(BranchInst *BI, 1665 APInt &ProbTrue, APInt &ProbFalse) { 1666 assert(BI->isConditional() && 1667 "Looking for probabilities on unconditional branch?"); 1668 MDNode *ProfileData = BI->getMetadata(LLVMContext::MD_prof); 1669 if (!ProfileData || ProfileData->getNumOperands() != 3) return false; 1670 ConstantInt *CITrue = dyn_cast<ConstantInt>(ProfileData->getOperand(1)); 1671 ConstantInt *CIFalse = dyn_cast<ConstantInt>(ProfileData->getOperand(2)); 1672 if (!CITrue || !CIFalse) return false; 1673 ProbTrue = CITrue->getValue(); 1674 ProbFalse = CIFalse->getValue(); 1675 assert(ProbTrue.getBitWidth() == 32 && ProbFalse.getBitWidth() == 32 && 1676 "Branch probability metadata must be 32-bit integers"); 1677 return true; 1678 } 1679 1680 /// MultiplyAndLosePrecision - Multiplies A and B, then returns the result. In 1681 /// the event of overflow, logically-shifts all four inputs right until the 1682 /// multiply fits. 1683 static APInt MultiplyAndLosePrecision(APInt &A, APInt &B, APInt &C, APInt &D, 1684 unsigned &BitsLost) { 1685 BitsLost = 0; 1686 bool Overflow = false; 1687 APInt Result = A.umul_ov(B, Overflow); 1688 if (Overflow) { 1689 APInt MaxB = APInt::getMaxValue(A.getBitWidth()).udiv(A); 1690 do { 1691 B = B.lshr(1); 1692 ++BitsLost; 1693 } while (B.ugt(MaxB)); 1694 A = A.lshr(BitsLost); 1695 C = C.lshr(BitsLost); 1696 D = D.lshr(BitsLost); 1697 Result = A * B; 1698 } 1699 return Result; 1700 } 1701 1702 /// checkCSEInPredecessor - Return true if the given instruction is available 1703 /// in its predecessor block. If yes, the instruction will be removed. 1704 /// 1705 static bool checkCSEInPredecessor(Instruction *Inst, BasicBlock *PB) { 1706 if (!isa<BinaryOperator>(Inst) && !isa<CmpInst>(Inst)) 1707 return false; 1708 for (BasicBlock::iterator I = PB->begin(), E = PB->end(); I != E; I++) { 1709 Instruction *PBI = &*I; 1710 // Check whether Inst and PBI generate the same value. 1711 if (Inst->isIdenticalTo(PBI)) { 1712 Inst->replaceAllUsesWith(PBI); 1713 Inst->eraseFromParent(); 1714 return true; 1715 } 1716 } 1717 return false; 1718 } 1719 1720 /// FoldBranchToCommonDest - If this basic block is simple enough, and if a 1721 /// predecessor branches to us and one of our successors, fold the block into 1722 /// the predecessor and use logical operations to pick the right destination. 1723 bool llvm::FoldBranchToCommonDest(BranchInst *BI) { 1724 BasicBlock *BB = BI->getParent(); 1725 1726 Instruction *Cond = 0; 1727 if (BI->isConditional()) 1728 Cond = dyn_cast<Instruction>(BI->getCondition()); 1729 else { 1730 // For unconditional branch, check for a simple CFG pattern, where 1731 // BB has a single predecessor and BB's successor is also its predecessor's 1732 // successor. If such pattern exisits, check for CSE between BB and its 1733 // predecessor. 1734 if (BasicBlock *PB = BB->getSinglePredecessor()) 1735 if (BranchInst *PBI = dyn_cast<BranchInst>(PB->getTerminator())) 1736 if (PBI->isConditional() && 1737 (BI->getSuccessor(0) == PBI->getSuccessor(0) || 1738 BI->getSuccessor(0) == PBI->getSuccessor(1))) { 1739 for (BasicBlock::iterator I = BB->begin(), E = BB->end(); 1740 I != E; ) { 1741 Instruction *Curr = I++; 1742 if (isa<CmpInst>(Curr)) { 1743 Cond = Curr; 1744 break; 1745 } 1746 // Quit if we can't remove this instruction. 1747 if (!checkCSEInPredecessor(Curr, PB)) 1748 return false; 1749 } 1750 } 1751 1752 if (Cond == 0) 1753 return false; 1754 } 1755 1756 if (Cond == 0 || (!isa<CmpInst>(Cond) && !isa<BinaryOperator>(Cond)) || 1757 Cond->getParent() != BB || !Cond->hasOneUse()) 1758 return false; 1759 1760 // Only allow this if the condition is a simple instruction that can be 1761 // executed unconditionally. It must be in the same block as the branch, and 1762 // must be at the front of the block. 1763 BasicBlock::iterator FrontIt = BB->front(); 1764 1765 // Ignore dbg intrinsics. 1766 while (isa<DbgInfoIntrinsic>(FrontIt)) ++FrontIt; 1767 1768 // Allow a single instruction to be hoisted in addition to the compare 1769 // that feeds the branch. We later ensure that any values that _it_ uses 1770 // were also live in the predecessor, so that we don't unnecessarily create 1771 // register pressure or inhibit out-of-order execution. 1772 Instruction *BonusInst = 0; 1773 if (&*FrontIt != Cond && 1774 FrontIt->hasOneUse() && *FrontIt->use_begin() == Cond && 1775 isSafeToSpeculativelyExecute(FrontIt)) { 1776 BonusInst = &*FrontIt; 1777 ++FrontIt; 1778 1779 // Ignore dbg intrinsics. 1780 while (isa<DbgInfoIntrinsic>(FrontIt)) ++FrontIt; 1781 } 1782 1783 // Only a single bonus inst is allowed. 1784 if (&*FrontIt != Cond) 1785 return false; 1786 1787 // Make sure the instruction after the condition is the cond branch. 1788 BasicBlock::iterator CondIt = Cond; ++CondIt; 1789 1790 // Ingore dbg intrinsics. 1791 while (isa<DbgInfoIntrinsic>(CondIt)) ++CondIt; 1792 1793 if (&*CondIt != BI) 1794 return false; 1795 1796 // Cond is known to be a compare or binary operator. Check to make sure that 1797 // neither operand is a potentially-trapping constant expression. 1798 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Cond->getOperand(0))) 1799 if (CE->canTrap()) 1800 return false; 1801 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Cond->getOperand(1))) 1802 if (CE->canTrap()) 1803 return false; 1804 1805 // Finally, don't infinitely unroll conditional loops. 1806 BasicBlock *TrueDest = BI->getSuccessor(0); 1807 BasicBlock *FalseDest = (BI->isConditional()) ? BI->getSuccessor(1) : 0; 1808 if (TrueDest == BB || FalseDest == BB) 1809 return false; 1810 1811 for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) { 1812 BasicBlock *PredBlock = *PI; 1813 BranchInst *PBI = dyn_cast<BranchInst>(PredBlock->getTerminator()); 1814 1815 // Check that we have two conditional branches. If there is a PHI node in 1816 // the common successor, verify that the same value flows in from both 1817 // blocks. 1818 SmallVector<PHINode*, 4> PHIs; 1819 if (PBI == 0 || PBI->isUnconditional() || 1820 (BI->isConditional() && 1821 !SafeToMergeTerminators(BI, PBI)) || 1822 (!BI->isConditional() && 1823 !isProfitableToFoldUnconditional(BI, PBI, Cond, PHIs))) 1824 continue; 1825 1826 // Determine if the two branches share a common destination. 1827 Instruction::BinaryOps Opc; 1828 bool InvertPredCond = false; 1829 1830 if (BI->isConditional()) { 1831 if (PBI->getSuccessor(0) == TrueDest) 1832 Opc = Instruction::Or; 1833 else if (PBI->getSuccessor(1) == FalseDest) 1834 Opc = Instruction::And; 1835 else if (PBI->getSuccessor(0) == FalseDest) 1836 Opc = Instruction::And, InvertPredCond = true; 1837 else if (PBI->getSuccessor(1) == TrueDest) 1838 Opc = Instruction::Or, InvertPredCond = true; 1839 else 1840 continue; 1841 } else { 1842 if (PBI->getSuccessor(0) != TrueDest && PBI->getSuccessor(1) != TrueDest) 1843 continue; 1844 } 1845 1846 // Ensure that any values used in the bonus instruction are also used 1847 // by the terminator of the predecessor. This means that those values 1848 // must already have been resolved, so we won't be inhibiting the 1849 // out-of-order core by speculating them earlier. 1850 if (BonusInst) { 1851 // Collect the values used by the bonus inst 1852 SmallPtrSet<Value*, 4> UsedValues; 1853 for (Instruction::op_iterator OI = BonusInst->op_begin(), 1854 OE = BonusInst->op_end(); OI != OE; ++OI) { 1855 Value *V = *OI; 1856 if (!isa<Constant>(V)) 1857 UsedValues.insert(V); 1858 } 1859 1860 SmallVector<std::pair<Value*, unsigned>, 4> Worklist; 1861 Worklist.push_back(std::make_pair(PBI->getOperand(0), 0)); 1862 1863 // Walk up to four levels back up the use-def chain of the predecessor's 1864 // terminator to see if all those values were used. The choice of four 1865 // levels is arbitrary, to provide a compile-time-cost bound. 1866 while (!Worklist.empty()) { 1867 std::pair<Value*, unsigned> Pair = Worklist.back(); 1868 Worklist.pop_back(); 1869 1870 if (Pair.second >= 4) continue; 1871 UsedValues.erase(Pair.first); 1872 if (UsedValues.empty()) break; 1873 1874 if (Instruction *I = dyn_cast<Instruction>(Pair.first)) { 1875 for (Instruction::op_iterator OI = I->op_begin(), OE = I->op_end(); 1876 OI != OE; ++OI) 1877 Worklist.push_back(std::make_pair(OI->get(), Pair.second+1)); 1878 } 1879 } 1880 1881 if (!UsedValues.empty()) return false; 1882 } 1883 1884 DEBUG(dbgs() << "FOLDING BRANCH TO COMMON DEST:\n" << *PBI << *BB); 1885 IRBuilder<> Builder(PBI); 1886 1887 // If we need to invert the condition in the pred block to match, do so now. 1888 if (InvertPredCond) { 1889 Value *NewCond = PBI->getCondition(); 1890 1891 if (NewCond->hasOneUse() && isa<CmpInst>(NewCond)) { 1892 CmpInst *CI = cast<CmpInst>(NewCond); 1893 CI->setPredicate(CI->getInversePredicate()); 1894 } else { 1895 NewCond = Builder.CreateNot(NewCond, 1896 PBI->getCondition()->getName()+".not"); 1897 } 1898 1899 PBI->setCondition(NewCond); 1900 PBI->swapSuccessors(); 1901 } 1902 1903 // If we have a bonus inst, clone it into the predecessor block. 1904 Instruction *NewBonus = 0; 1905 if (BonusInst) { 1906 NewBonus = BonusInst->clone(); 1907 PredBlock->getInstList().insert(PBI, NewBonus); 1908 NewBonus->takeName(BonusInst); 1909 BonusInst->setName(BonusInst->getName()+".old"); 1910 } 1911 1912 // Clone Cond into the predecessor basic block, and or/and the 1913 // two conditions together. 1914 Instruction *New = Cond->clone(); 1915 if (BonusInst) New->replaceUsesOfWith(BonusInst, NewBonus); 1916 PredBlock->getInstList().insert(PBI, New); 1917 New->takeName(Cond); 1918 Cond->setName(New->getName()+".old"); 1919 1920 if (BI->isConditional()) { 1921 Instruction *NewCond = 1922 cast<Instruction>(Builder.CreateBinOp(Opc, PBI->getCondition(), 1923 New, "or.cond")); 1924 PBI->setCondition(NewCond); 1925 1926 if (PBI->getSuccessor(0) == BB) { 1927 AddPredecessorToBlock(TrueDest, PredBlock, BB); 1928 PBI->setSuccessor(0, TrueDest); 1929 } 1930 if (PBI->getSuccessor(1) == BB) { 1931 AddPredecessorToBlock(FalseDest, PredBlock, BB); 1932 PBI->setSuccessor(1, FalseDest); 1933 } 1934 } else { 1935 // Update PHI nodes in the common successors. 1936 for (unsigned i = 0, e = PHIs.size(); i != e; ++i) { 1937 ConstantInt *PBI_C = cast<ConstantInt>( 1938 PHIs[i]->getIncomingValueForBlock(PBI->getParent())); 1939 assert(PBI_C->getType()->isIntegerTy(1)); 1940 Instruction *MergedCond = 0; 1941 if (PBI->getSuccessor(0) == TrueDest) { 1942 // Create (PBI_Cond and PBI_C) or (!PBI_Cond and BI_Value) 1943 // PBI_C is true: PBI_Cond or (!PBI_Cond and BI_Value) 1944 // is false: !PBI_Cond and BI_Value 1945 Instruction *NotCond = 1946 cast<Instruction>(Builder.CreateNot(PBI->getCondition(), 1947 "not.cond")); 1948 MergedCond = 1949 cast<Instruction>(Builder.CreateBinOp(Instruction::And, 1950 NotCond, New, 1951 "and.cond")); 1952 if (PBI_C->isOne()) 1953 MergedCond = 1954 cast<Instruction>(Builder.CreateBinOp(Instruction::Or, 1955 PBI->getCondition(), MergedCond, 1956 "or.cond")); 1957 } else { 1958 // Create (PBI_Cond and BI_Value) or (!PBI_Cond and PBI_C) 1959 // PBI_C is true: (PBI_Cond and BI_Value) or (!PBI_Cond) 1960 // is false: PBI_Cond and BI_Value 1961 MergedCond = 1962 cast<Instruction>(Builder.CreateBinOp(Instruction::And, 1963 PBI->getCondition(), New, 1964 "and.cond")); 1965 if (PBI_C->isOne()) { 1966 Instruction *NotCond = 1967 cast<Instruction>(Builder.CreateNot(PBI->getCondition(), 1968 "not.cond")); 1969 MergedCond = 1970 cast<Instruction>(Builder.CreateBinOp(Instruction::Or, 1971 NotCond, MergedCond, 1972 "or.cond")); 1973 } 1974 } 1975 // Update PHI Node. 1976 PHIs[i]->setIncomingValue(PHIs[i]->getBasicBlockIndex(PBI->getParent()), 1977 MergedCond); 1978 } 1979 // Change PBI from Conditional to Unconditional. 1980 BranchInst *New_PBI = BranchInst::Create(TrueDest, PBI); 1981 EraseTerminatorInstAndDCECond(PBI); 1982 PBI = New_PBI; 1983 } 1984 1985 // TODO: If BB is reachable from all paths through PredBlock, then we 1986 // could replace PBI's branch probabilities with BI's. 1987 1988 // Merge probability data into PredBlock's branch. 1989 APInt A, B, C, D; 1990 if (PBI->isConditional() && BI->isConditional() && 1991 ExtractBranchMetadata(PBI, C, D) && ExtractBranchMetadata(BI, A, B)) { 1992 // Given IR which does: 1993 // bbA: 1994 // br i1 %x, label %bbB, label %bbC 1995 // bbB: 1996 // br i1 %y, label %bbD, label %bbC 1997 // Let's call the probability that we take the edge from %bbA to %bbB 1998 // 'a', from %bbA to %bbC, 'b', from %bbB to %bbD 'c' and from %bbB to 1999 // %bbC probability 'd'. 2000 // 2001 // We transform the IR into: 2002 // bbA: 2003 // br i1 %z, label %bbD, label %bbC 2004 // where the probability of going to %bbD is (a*c) and going to bbC is 2005 // (b+a*d). 2006 // 2007 // Probabilities aren't stored as ratios directly. Using branch weights, 2008 // we get: 2009 // (a*c)% = A*C, (b+(a*d))% = A*D+B*C+B*D. 2010 2011 // In the event of overflow, we want to drop the LSB of the input 2012 // probabilities. 2013 unsigned BitsLost; 2014 2015 // Ignore overflow result on ProbTrue. 2016 APInt ProbTrue = MultiplyAndLosePrecision(A, C, B, D, BitsLost); 2017 2018 APInt Tmp1 = MultiplyAndLosePrecision(B, D, A, C, BitsLost); 2019 if (BitsLost) { 2020 ProbTrue = ProbTrue.lshr(BitsLost*2); 2021 } 2022 2023 APInt Tmp2 = MultiplyAndLosePrecision(A, D, C, B, BitsLost); 2024 if (BitsLost) { 2025 ProbTrue = ProbTrue.lshr(BitsLost*2); 2026 Tmp1 = Tmp1.lshr(BitsLost*2); 2027 } 2028 2029 APInt Tmp3 = MultiplyAndLosePrecision(B, C, A, D, BitsLost); 2030 if (BitsLost) { 2031 ProbTrue = ProbTrue.lshr(BitsLost*2); 2032 Tmp1 = Tmp1.lshr(BitsLost*2); 2033 Tmp2 = Tmp2.lshr(BitsLost*2); 2034 } 2035 2036 bool Overflow1 = false, Overflow2 = false; 2037 APInt Tmp4 = Tmp2.uadd_ov(Tmp3, Overflow1); 2038 APInt ProbFalse = Tmp4.uadd_ov(Tmp1, Overflow2); 2039 2040 if (Overflow1 || Overflow2) { 2041 ProbTrue = ProbTrue.lshr(1); 2042 Tmp1 = Tmp1.lshr(1); 2043 Tmp2 = Tmp2.lshr(1); 2044 Tmp3 = Tmp3.lshr(1); 2045 Tmp4 = Tmp2 + Tmp3; 2046 ProbFalse = Tmp4 + Tmp1; 2047 } 2048 2049 // The sum of branch weights must fit in 32-bits. 2050 if (ProbTrue.isNegative() && ProbFalse.isNegative()) { 2051 ProbTrue = ProbTrue.lshr(1); 2052 ProbFalse = ProbFalse.lshr(1); 2053 } 2054 2055 if (ProbTrue != ProbFalse) { 2056 // Normalize the result. 2057 APInt GCD = APIntOps::GreatestCommonDivisor(ProbTrue, ProbFalse); 2058 ProbTrue = ProbTrue.udiv(GCD); 2059 ProbFalse = ProbFalse.udiv(GCD); 2060 2061 MDBuilder MDB(BI->getContext()); 2062 MDNode *N = MDB.createBranchWeights(ProbTrue.getZExtValue(), 2063 ProbFalse.getZExtValue()); 2064 PBI->setMetadata(LLVMContext::MD_prof, N); 2065 } else { 2066 PBI->setMetadata(LLVMContext::MD_prof, NULL); 2067 } 2068 } else { 2069 PBI->setMetadata(LLVMContext::MD_prof, NULL); 2070 } 2071 2072 // Copy any debug value intrinsics into the end of PredBlock. 2073 for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 2074 if (isa<DbgInfoIntrinsic>(*I)) 2075 I->clone()->insertBefore(PBI); 2076 2077 return true; 2078 } 2079 return false; 2080 } 2081 2082 /// SimplifyCondBranchToCondBranch - If we have a conditional branch as a 2083 /// predecessor of another block, this function tries to simplify it. We know 2084 /// that PBI and BI are both conditional branches, and BI is in one of the 2085 /// successor blocks of PBI - PBI branches to BI. 2086 static bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI) { 2087 assert(PBI->isConditional() && BI->isConditional()); 2088 BasicBlock *BB = BI->getParent(); 2089 2090 // If this block ends with a branch instruction, and if there is a 2091 // predecessor that ends on a branch of the same condition, make 2092 // this conditional branch redundant. 2093 if (PBI->getCondition() == BI->getCondition() && 2094 PBI->getSuccessor(0) != PBI->getSuccessor(1)) { 2095 // Okay, the outcome of this conditional branch is statically 2096 // knowable. If this block had a single pred, handle specially. 2097 if (BB->getSinglePredecessor()) { 2098 // Turn this into a branch on constant. 2099 bool CondIsTrue = PBI->getSuccessor(0) == BB; 2100 BI->setCondition(ConstantInt::get(Type::getInt1Ty(BB->getContext()), 2101 CondIsTrue)); 2102 return true; // Nuke the branch on constant. 2103 } 2104 2105 // Otherwise, if there are multiple predecessors, insert a PHI that merges 2106 // in the constant and simplify the block result. Subsequent passes of 2107 // simplifycfg will thread the block. 2108 if (BlockIsSimpleEnoughToThreadThrough(BB)) { 2109 pred_iterator PB = pred_begin(BB), PE = pred_end(BB); 2110 PHINode *NewPN = PHINode::Create(Type::getInt1Ty(BB->getContext()), 2111 std::distance(PB, PE), 2112 BI->getCondition()->getName() + ".pr", 2113 BB->begin()); 2114 // Okay, we're going to insert the PHI node. Since PBI is not the only 2115 // predecessor, compute the PHI'd conditional value for all of the preds. 2116 // Any predecessor where the condition is not computable we keep symbolic. 2117 for (pred_iterator PI = PB; PI != PE; ++PI) { 2118 BasicBlock *P = *PI; 2119 if ((PBI = dyn_cast<BranchInst>(P->getTerminator())) && 2120 PBI != BI && PBI->isConditional() && 2121 PBI->getCondition() == BI->getCondition() && 2122 PBI->getSuccessor(0) != PBI->getSuccessor(1)) { 2123 bool CondIsTrue = PBI->getSuccessor(0) == BB; 2124 NewPN->addIncoming(ConstantInt::get(Type::getInt1Ty(BB->getContext()), 2125 CondIsTrue), P); 2126 } else { 2127 NewPN->addIncoming(BI->getCondition(), P); 2128 } 2129 } 2130 2131 BI->setCondition(NewPN); 2132 return true; 2133 } 2134 } 2135 2136 // If this is a conditional branch in an empty block, and if any 2137 // predecessors is a conditional branch to one of our destinations, 2138 // fold the conditions into logical ops and one cond br. 2139 BasicBlock::iterator BBI = BB->begin(); 2140 // Ignore dbg intrinsics. 2141 while (isa<DbgInfoIntrinsic>(BBI)) 2142 ++BBI; 2143 if (&*BBI != BI) 2144 return false; 2145 2146 2147 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(BI->getCondition())) 2148 if (CE->canTrap()) 2149 return false; 2150 2151 int PBIOp, BIOp; 2152 if (PBI->getSuccessor(0) == BI->getSuccessor(0)) 2153 PBIOp = BIOp = 0; 2154 else if (PBI->getSuccessor(0) == BI->getSuccessor(1)) 2155 PBIOp = 0, BIOp = 1; 2156 else if (PBI->getSuccessor(1) == BI->getSuccessor(0)) 2157 PBIOp = 1, BIOp = 0; 2158 else if (PBI->getSuccessor(1) == BI->getSuccessor(1)) 2159 PBIOp = BIOp = 1; 2160 else 2161 return false; 2162 2163 // Check to make sure that the other destination of this branch 2164 // isn't BB itself. If so, this is an infinite loop that will 2165 // keep getting unwound. 2166 if (PBI->getSuccessor(PBIOp) == BB) 2167 return false; 2168 2169 // Do not perform this transformation if it would require 2170 // insertion of a large number of select instructions. For targets 2171 // without predication/cmovs, this is a big pessimization. 2172 BasicBlock *CommonDest = PBI->getSuccessor(PBIOp); 2173 2174 unsigned NumPhis = 0; 2175 for (BasicBlock::iterator II = CommonDest->begin(); 2176 isa<PHINode>(II); ++II, ++NumPhis) 2177 if (NumPhis > 2) // Disable this xform. 2178 return false; 2179 2180 // Finally, if everything is ok, fold the branches to logical ops. 2181 BasicBlock *OtherDest = BI->getSuccessor(BIOp ^ 1); 2182 2183 DEBUG(dbgs() << "FOLDING BRs:" << *PBI->getParent() 2184 << "AND: " << *BI->getParent()); 2185 2186 2187 // If OtherDest *is* BB, then BB is a basic block with a single conditional 2188 // branch in it, where one edge (OtherDest) goes back to itself but the other 2189 // exits. We don't *know* that the program avoids the infinite loop 2190 // (even though that seems likely). If we do this xform naively, we'll end up 2191 // recursively unpeeling the loop. Since we know that (after the xform is 2192 // done) that the block *is* infinite if reached, we just make it an obviously 2193 // infinite loop with no cond branch. 2194 if (OtherDest == BB) { 2195 // Insert it at the end of the function, because it's either code, 2196 // or it won't matter if it's hot. :) 2197 BasicBlock *InfLoopBlock = BasicBlock::Create(BB->getContext(), 2198 "infloop", BB->getParent()); 2199 BranchInst::Create(InfLoopBlock, InfLoopBlock); 2200 OtherDest = InfLoopBlock; 2201 } 2202 2203 DEBUG(dbgs() << *PBI->getParent()->getParent()); 2204 2205 // BI may have other predecessors. Because of this, we leave 2206 // it alone, but modify PBI. 2207 2208 // Make sure we get to CommonDest on True&True directions. 2209 Value *PBICond = PBI->getCondition(); 2210 IRBuilder<true, NoFolder> Builder(PBI); 2211 if (PBIOp) 2212 PBICond = Builder.CreateNot(PBICond, PBICond->getName()+".not"); 2213 2214 Value *BICond = BI->getCondition(); 2215 if (BIOp) 2216 BICond = Builder.CreateNot(BICond, BICond->getName()+".not"); 2217 2218 // Merge the conditions. 2219 Value *Cond = Builder.CreateOr(PBICond, BICond, "brmerge"); 2220 2221 // Modify PBI to branch on the new condition to the new dests. 2222 PBI->setCondition(Cond); 2223 PBI->setSuccessor(0, CommonDest); 2224 PBI->setSuccessor(1, OtherDest); 2225 2226 // OtherDest may have phi nodes. If so, add an entry from PBI's 2227 // block that are identical to the entries for BI's block. 2228 AddPredecessorToBlock(OtherDest, PBI->getParent(), BB); 2229 2230 // We know that the CommonDest already had an edge from PBI to 2231 // it. If it has PHIs though, the PHIs may have different 2232 // entries for BB and PBI's BB. If so, insert a select to make 2233 // them agree. 2234 PHINode *PN; 2235 for (BasicBlock::iterator II = CommonDest->begin(); 2236 (PN = dyn_cast<PHINode>(II)); ++II) { 2237 Value *BIV = PN->getIncomingValueForBlock(BB); 2238 unsigned PBBIdx = PN->getBasicBlockIndex(PBI->getParent()); 2239 Value *PBIV = PN->getIncomingValue(PBBIdx); 2240 if (BIV != PBIV) { 2241 // Insert a select in PBI to pick the right value. 2242 Value *NV = cast<SelectInst> 2243 (Builder.CreateSelect(PBICond, PBIV, BIV, PBIV->getName()+".mux")); 2244 PN->setIncomingValue(PBBIdx, NV); 2245 } 2246 } 2247 2248 DEBUG(dbgs() << "INTO: " << *PBI->getParent()); 2249 DEBUG(dbgs() << *PBI->getParent()->getParent()); 2250 2251 // This basic block is probably dead. We know it has at least 2252 // one fewer predecessor. 2253 return true; 2254 } 2255 2256 // SimplifyTerminatorOnSelect - Simplifies a terminator by replacing it with a 2257 // branch to TrueBB if Cond is true or to FalseBB if Cond is false. 2258 // Takes care of updating the successors and removing the old terminator. 2259 // Also makes sure not to introduce new successors by assuming that edges to 2260 // non-successor TrueBBs and FalseBBs aren't reachable. 2261 static bool SimplifyTerminatorOnSelect(TerminatorInst *OldTerm, Value *Cond, 2262 BasicBlock *TrueBB, BasicBlock *FalseBB){ 2263 // Remove any superfluous successor edges from the CFG. 2264 // First, figure out which successors to preserve. 2265 // If TrueBB and FalseBB are equal, only try to preserve one copy of that 2266 // successor. 2267 BasicBlock *KeepEdge1 = TrueBB; 2268 BasicBlock *KeepEdge2 = TrueBB != FalseBB ? FalseBB : 0; 2269 2270 // Then remove the rest. 2271 for (unsigned I = 0, E = OldTerm->getNumSuccessors(); I != E; ++I) { 2272 BasicBlock *Succ = OldTerm->getSuccessor(I); 2273 // Make sure only to keep exactly one copy of each edge. 2274 if (Succ == KeepEdge1) 2275 KeepEdge1 = 0; 2276 else if (Succ == KeepEdge2) 2277 KeepEdge2 = 0; 2278 else 2279 Succ->removePredecessor(OldTerm->getParent()); 2280 } 2281 2282 IRBuilder<> Builder(OldTerm); 2283 Builder.SetCurrentDebugLocation(OldTerm->getDebugLoc()); 2284 2285 // Insert an appropriate new terminator. 2286 if ((KeepEdge1 == 0) && (KeepEdge2 == 0)) { 2287 if (TrueBB == FalseBB) 2288 // We were only looking for one successor, and it was present. 2289 // Create an unconditional branch to it. 2290 Builder.CreateBr(TrueBB); 2291 else 2292 // We found both of the successors we were looking for. 2293 // Create a conditional branch sharing the condition of the select. 2294 Builder.CreateCondBr(Cond, TrueBB, FalseBB); 2295 } else if (KeepEdge1 && (KeepEdge2 || TrueBB == FalseBB)) { 2296 // Neither of the selected blocks were successors, so this 2297 // terminator must be unreachable. 2298 new UnreachableInst(OldTerm->getContext(), OldTerm); 2299 } else { 2300 // One of the selected values was a successor, but the other wasn't. 2301 // Insert an unconditional branch to the one that was found; 2302 // the edge to the one that wasn't must be unreachable. 2303 if (KeepEdge1 == 0) 2304 // Only TrueBB was found. 2305 Builder.CreateBr(TrueBB); 2306 else 2307 // Only FalseBB was found. 2308 Builder.CreateBr(FalseBB); 2309 } 2310 2311 EraseTerminatorInstAndDCECond(OldTerm); 2312 return true; 2313 } 2314 2315 // SimplifySwitchOnSelect - Replaces 2316 // (switch (select cond, X, Y)) on constant X, Y 2317 // with a branch - conditional if X and Y lead to distinct BBs, 2318 // unconditional otherwise. 2319 static bool SimplifySwitchOnSelect(SwitchInst *SI, SelectInst *Select) { 2320 // Check for constant integer values in the select. 2321 ConstantInt *TrueVal = dyn_cast<ConstantInt>(Select->getTrueValue()); 2322 ConstantInt *FalseVal = dyn_cast<ConstantInt>(Select->getFalseValue()); 2323 if (!TrueVal || !FalseVal) 2324 return false; 2325 2326 // Find the relevant condition and destinations. 2327 Value *Condition = Select->getCondition(); 2328 BasicBlock *TrueBB = SI->findCaseValue(TrueVal).getCaseSuccessor(); 2329 BasicBlock *FalseBB = SI->findCaseValue(FalseVal).getCaseSuccessor(); 2330 2331 // Perform the actual simplification. 2332 return SimplifyTerminatorOnSelect(SI, Condition, TrueBB, FalseBB); 2333 } 2334 2335 // SimplifyIndirectBrOnSelect - Replaces 2336 // (indirectbr (select cond, blockaddress(@fn, BlockA), 2337 // blockaddress(@fn, BlockB))) 2338 // with 2339 // (br cond, BlockA, BlockB). 2340 static bool SimplifyIndirectBrOnSelect(IndirectBrInst *IBI, SelectInst *SI) { 2341 // Check that both operands of the select are block addresses. 2342 BlockAddress *TBA = dyn_cast<BlockAddress>(SI->getTrueValue()); 2343 BlockAddress *FBA = dyn_cast<BlockAddress>(SI->getFalseValue()); 2344 if (!TBA || !FBA) 2345 return false; 2346 2347 // Extract the actual blocks. 2348 BasicBlock *TrueBB = TBA->getBasicBlock(); 2349 BasicBlock *FalseBB = FBA->getBasicBlock(); 2350 2351 // Perform the actual simplification. 2352 return SimplifyTerminatorOnSelect(IBI, SI->getCondition(), TrueBB, FalseBB); 2353 } 2354 2355 /// TryToSimplifyUncondBranchWithICmpInIt - This is called when we find an icmp 2356 /// instruction (a seteq/setne with a constant) as the only instruction in a 2357 /// block that ends with an uncond branch. We are looking for a very specific 2358 /// pattern that occurs when "A == 1 || A == 2 || A == 3" gets simplified. In 2359 /// this case, we merge the first two "or's of icmp" into a switch, but then the 2360 /// default value goes to an uncond block with a seteq in it, we get something 2361 /// like: 2362 /// 2363 /// switch i8 %A, label %DEFAULT [ i8 1, label %end i8 2, label %end ] 2364 /// DEFAULT: 2365 /// %tmp = icmp eq i8 %A, 92 2366 /// br label %end 2367 /// end: 2368 /// ... = phi i1 [ true, %entry ], [ %tmp, %DEFAULT ], [ true, %entry ] 2369 /// 2370 /// We prefer to split the edge to 'end' so that there is a true/false entry to 2371 /// the PHI, merging the third icmp into the switch. 2372 static bool TryToSimplifyUncondBranchWithICmpInIt(ICmpInst *ICI, 2373 const TargetData *TD, 2374 IRBuilder<> &Builder) { 2375 BasicBlock *BB = ICI->getParent(); 2376 2377 // If the block has any PHIs in it or the icmp has multiple uses, it is too 2378 // complex. 2379 if (isa<PHINode>(BB->begin()) || !ICI->hasOneUse()) return false; 2380 2381 Value *V = ICI->getOperand(0); 2382 ConstantInt *Cst = cast<ConstantInt>(ICI->getOperand(1)); 2383 2384 // The pattern we're looking for is where our only predecessor is a switch on 2385 // 'V' and this block is the default case for the switch. In this case we can 2386 // fold the compared value into the switch to simplify things. 2387 BasicBlock *Pred = BB->getSinglePredecessor(); 2388 if (Pred == 0 || !isa<SwitchInst>(Pred->getTerminator())) return false; 2389 2390 SwitchInst *SI = cast<SwitchInst>(Pred->getTerminator()); 2391 if (SI->getCondition() != V) 2392 return false; 2393 2394 // If BB is reachable on a non-default case, then we simply know the value of 2395 // V in this block. Substitute it and constant fold the icmp instruction 2396 // away. 2397 if (SI->getDefaultDest() != BB) { 2398 ConstantInt *VVal = SI->findCaseDest(BB); 2399 assert(VVal && "Should have a unique destination value"); 2400 ICI->setOperand(0, VVal); 2401 2402 if (Value *V = SimplifyInstruction(ICI, TD)) { 2403 ICI->replaceAllUsesWith(V); 2404 ICI->eraseFromParent(); 2405 } 2406 // BB is now empty, so it is likely to simplify away. 2407 return SimplifyCFG(BB) | true; 2408 } 2409 2410 // Ok, the block is reachable from the default dest. If the constant we're 2411 // comparing exists in one of the other edges, then we can constant fold ICI 2412 // and zap it. 2413 if (SI->findCaseValue(Cst) != SI->case_default()) { 2414 Value *V; 2415 if (ICI->getPredicate() == ICmpInst::ICMP_EQ) 2416 V = ConstantInt::getFalse(BB->getContext()); 2417 else 2418 V = ConstantInt::getTrue(BB->getContext()); 2419 2420 ICI->replaceAllUsesWith(V); 2421 ICI->eraseFromParent(); 2422 // BB is now empty, so it is likely to simplify away. 2423 return SimplifyCFG(BB) | true; 2424 } 2425 2426 // The use of the icmp has to be in the 'end' block, by the only PHI node in 2427 // the block. 2428 BasicBlock *SuccBlock = BB->getTerminator()->getSuccessor(0); 2429 PHINode *PHIUse = dyn_cast<PHINode>(ICI->use_back()); 2430 if (PHIUse == 0 || PHIUse != &SuccBlock->front() || 2431 isa<PHINode>(++BasicBlock::iterator(PHIUse))) 2432 return false; 2433 2434 // If the icmp is a SETEQ, then the default dest gets false, the new edge gets 2435 // true in the PHI. 2436 Constant *DefaultCst = ConstantInt::getTrue(BB->getContext()); 2437 Constant *NewCst = ConstantInt::getFalse(BB->getContext()); 2438 2439 if (ICI->getPredicate() == ICmpInst::ICMP_EQ) 2440 std::swap(DefaultCst, NewCst); 2441 2442 // Replace ICI (which is used by the PHI for the default value) with true or 2443 // false depending on if it is EQ or NE. 2444 ICI->replaceAllUsesWith(DefaultCst); 2445 ICI->eraseFromParent(); 2446 2447 // Okay, the switch goes to this block on a default value. Add an edge from 2448 // the switch to the merge point on the compared value. 2449 BasicBlock *NewBB = BasicBlock::Create(BB->getContext(), "switch.edge", 2450 BB->getParent(), BB); 2451 SI->addCase(Cst, NewBB); 2452 2453 // NewBB branches to the phi block, add the uncond branch and the phi entry. 2454 Builder.SetInsertPoint(NewBB); 2455 Builder.SetCurrentDebugLocation(SI->getDebugLoc()); 2456 Builder.CreateBr(SuccBlock); 2457 PHIUse->addIncoming(NewCst, NewBB); 2458 return true; 2459 } 2460 2461 /// SimplifyBranchOnICmpChain - The specified branch is a conditional branch. 2462 /// Check to see if it is branching on an or/and chain of icmp instructions, and 2463 /// fold it into a switch instruction if so. 2464 static bool SimplifyBranchOnICmpChain(BranchInst *BI, const TargetData *TD, 2465 IRBuilder<> &Builder) { 2466 Instruction *Cond = dyn_cast<Instruction>(BI->getCondition()); 2467 if (Cond == 0) return false; 2468 2469 2470 // Change br (X == 0 | X == 1), T, F into a switch instruction. 2471 // If this is a bunch of seteq's or'd together, or if it's a bunch of 2472 // 'setne's and'ed together, collect them. 2473 Value *CompVal = 0; 2474 std::vector<ConstantInt*> Values; 2475 bool TrueWhenEqual = true; 2476 Value *ExtraCase = 0; 2477 unsigned UsedICmps = 0; 2478 2479 if (Cond->getOpcode() == Instruction::Or) { 2480 CompVal = GatherConstantCompares(Cond, Values, ExtraCase, TD, true, 2481 UsedICmps); 2482 } else if (Cond->getOpcode() == Instruction::And) { 2483 CompVal = GatherConstantCompares(Cond, Values, ExtraCase, TD, false, 2484 UsedICmps); 2485 TrueWhenEqual = false; 2486 } 2487 2488 // If we didn't have a multiply compared value, fail. 2489 if (CompVal == 0) return false; 2490 2491 // Avoid turning single icmps into a switch. 2492 if (UsedICmps <= 1) 2493 return false; 2494 2495 // There might be duplicate constants in the list, which the switch 2496 // instruction can't handle, remove them now. 2497 array_pod_sort(Values.begin(), Values.end(), ConstantIntSortPredicate); 2498 Values.erase(std::unique(Values.begin(), Values.end()), Values.end()); 2499 2500 // If Extra was used, we require at least two switch values to do the 2501 // transformation. A switch with one value is just an cond branch. 2502 if (ExtraCase && Values.size() < 2) return false; 2503 2504 // TODO: Preserve branch weight metadata, similarly to how 2505 // FoldValueComparisonIntoPredecessors preserves it. 2506 2507 // Figure out which block is which destination. 2508 BasicBlock *DefaultBB = BI->getSuccessor(1); 2509 BasicBlock *EdgeBB = BI->getSuccessor(0); 2510 if (!TrueWhenEqual) std::swap(DefaultBB, EdgeBB); 2511 2512 BasicBlock *BB = BI->getParent(); 2513 2514 DEBUG(dbgs() << "Converting 'icmp' chain with " << Values.size() 2515 << " cases into SWITCH. BB is:\n" << *BB); 2516 2517 // If there are any extra values that couldn't be folded into the switch 2518 // then we evaluate them with an explicit branch first. Split the block 2519 // right before the condbr to handle it. 2520 if (ExtraCase) { 2521 BasicBlock *NewBB = BB->splitBasicBlock(BI, "switch.early.test"); 2522 // Remove the uncond branch added to the old block. 2523 TerminatorInst *OldTI = BB->getTerminator(); 2524 Builder.SetInsertPoint(OldTI); 2525 2526 if (TrueWhenEqual) 2527 Builder.CreateCondBr(ExtraCase, EdgeBB, NewBB); 2528 else 2529 Builder.CreateCondBr(ExtraCase, NewBB, EdgeBB); 2530 2531 OldTI->eraseFromParent(); 2532 2533 // If there are PHI nodes in EdgeBB, then we need to add a new entry to them 2534 // for the edge we just added. 2535 AddPredecessorToBlock(EdgeBB, BB, NewBB); 2536 2537 DEBUG(dbgs() << " ** 'icmp' chain unhandled condition: " << *ExtraCase 2538 << "\nEXTRABB = " << *BB); 2539 BB = NewBB; 2540 } 2541 2542 Builder.SetInsertPoint(BI); 2543 // Convert pointer to int before we switch. 2544 if (CompVal->getType()->isPointerTy()) { 2545 assert(TD && "Cannot switch on pointer without TargetData"); 2546 CompVal = Builder.CreatePtrToInt(CompVal, 2547 TD->getIntPtrType(CompVal->getContext()), 2548 "magicptr"); 2549 } 2550 2551 // Create the new switch instruction now. 2552 SwitchInst *New = Builder.CreateSwitch(CompVal, DefaultBB, Values.size()); 2553 2554 // Add all of the 'cases' to the switch instruction. 2555 for (unsigned i = 0, e = Values.size(); i != e; ++i) 2556 New->addCase(Values[i], EdgeBB); 2557 2558 // We added edges from PI to the EdgeBB. As such, if there were any 2559 // PHI nodes in EdgeBB, they need entries to be added corresponding to 2560 // the number of edges added. 2561 for (BasicBlock::iterator BBI = EdgeBB->begin(); 2562 isa<PHINode>(BBI); ++BBI) { 2563 PHINode *PN = cast<PHINode>(BBI); 2564 Value *InVal = PN->getIncomingValueForBlock(BB); 2565 for (unsigned i = 0, e = Values.size()-1; i != e; ++i) 2566 PN->addIncoming(InVal, BB); 2567 } 2568 2569 // Erase the old branch instruction. 2570 EraseTerminatorInstAndDCECond(BI); 2571 2572 DEBUG(dbgs() << " ** 'icmp' chain result is:\n" << *BB << '\n'); 2573 return true; 2574 } 2575 2576 bool SimplifyCFGOpt::SimplifyResume(ResumeInst *RI, IRBuilder<> &Builder) { 2577 // If this is a trivial landing pad that just continues unwinding the caught 2578 // exception then zap the landing pad, turning its invokes into calls. 2579 BasicBlock *BB = RI->getParent(); 2580 LandingPadInst *LPInst = dyn_cast<LandingPadInst>(BB->getFirstNonPHI()); 2581 if (RI->getValue() != LPInst) 2582 // Not a landing pad, or the resume is not unwinding the exception that 2583 // caused control to branch here. 2584 return false; 2585 2586 // Check that there are no other instructions except for debug intrinsics. 2587 BasicBlock::iterator I = LPInst, E = RI; 2588 while (++I != E) 2589 if (!isa<DbgInfoIntrinsic>(I)) 2590 return false; 2591 2592 // Turn all invokes that unwind here into calls and delete the basic block. 2593 for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB); PI != PE;) { 2594 InvokeInst *II = cast<InvokeInst>((*PI++)->getTerminator()); 2595 SmallVector<Value*, 8> Args(II->op_begin(), II->op_end() - 3); 2596 // Insert a call instruction before the invoke. 2597 CallInst *Call = CallInst::Create(II->getCalledValue(), Args, "", II); 2598 Call->takeName(II); 2599 Call->setCallingConv(II->getCallingConv()); 2600 Call->setAttributes(II->getAttributes()); 2601 Call->setDebugLoc(II->getDebugLoc()); 2602 2603 // Anything that used the value produced by the invoke instruction now uses 2604 // the value produced by the call instruction. Note that we do this even 2605 // for void functions and calls with no uses so that the callgraph edge is 2606 // updated. 2607 II->replaceAllUsesWith(Call); 2608 BB->removePredecessor(II->getParent()); 2609 2610 // Insert a branch to the normal destination right before the invoke. 2611 BranchInst::Create(II->getNormalDest(), II); 2612 2613 // Finally, delete the invoke instruction! 2614 II->eraseFromParent(); 2615 } 2616 2617 // The landingpad is now unreachable. Zap it. 2618 BB->eraseFromParent(); 2619 return true; 2620 } 2621 2622 bool SimplifyCFGOpt::SimplifyReturn(ReturnInst *RI, IRBuilder<> &Builder) { 2623 BasicBlock *BB = RI->getParent(); 2624 if (!BB->getFirstNonPHIOrDbg()->isTerminator()) return false; 2625 2626 // Find predecessors that end with branches. 2627 SmallVector<BasicBlock*, 8> UncondBranchPreds; 2628 SmallVector<BranchInst*, 8> CondBranchPreds; 2629 for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) { 2630 BasicBlock *P = *PI; 2631 TerminatorInst *PTI = P->getTerminator(); 2632 if (BranchInst *BI = dyn_cast<BranchInst>(PTI)) { 2633 if (BI->isUnconditional()) 2634 UncondBranchPreds.push_back(P); 2635 else 2636 CondBranchPreds.push_back(BI); 2637 } 2638 } 2639 2640 // If we found some, do the transformation! 2641 if (!UncondBranchPreds.empty() && DupRet) { 2642 while (!UncondBranchPreds.empty()) { 2643 BasicBlock *Pred = UncondBranchPreds.pop_back_val(); 2644 DEBUG(dbgs() << "FOLDING: " << *BB 2645 << "INTO UNCOND BRANCH PRED: " << *Pred); 2646 (void)FoldReturnIntoUncondBranch(RI, BB, Pred); 2647 } 2648 2649 // If we eliminated all predecessors of the block, delete the block now. 2650 if (pred_begin(BB) == pred_end(BB)) 2651 // We know there are no successors, so just nuke the block. 2652 BB->eraseFromParent(); 2653 2654 return true; 2655 } 2656 2657 // Check out all of the conditional branches going to this return 2658 // instruction. If any of them just select between returns, change the 2659 // branch itself into a select/return pair. 2660 while (!CondBranchPreds.empty()) { 2661 BranchInst *BI = CondBranchPreds.pop_back_val(); 2662 2663 // Check to see if the non-BB successor is also a return block. 2664 if (isa<ReturnInst>(BI->getSuccessor(0)->getTerminator()) && 2665 isa<ReturnInst>(BI->getSuccessor(1)->getTerminator()) && 2666 SimplifyCondBranchToTwoReturns(BI, Builder)) 2667 return true; 2668 } 2669 return false; 2670 } 2671 2672 bool SimplifyCFGOpt::SimplifyUnreachable(UnreachableInst *UI) { 2673 BasicBlock *BB = UI->getParent(); 2674 2675 bool Changed = false; 2676 2677 // If there are any instructions immediately before the unreachable that can 2678 // be removed, do so. 2679 while (UI != BB->begin()) { 2680 BasicBlock::iterator BBI = UI; 2681 --BBI; 2682 // Do not delete instructions that can have side effects which might cause 2683 // the unreachable to not be reachable; specifically, calls and volatile 2684 // operations may have this effect. 2685 if (isa<CallInst>(BBI) && !isa<DbgInfoIntrinsic>(BBI)) break; 2686 2687 if (BBI->mayHaveSideEffects()) { 2688 if (StoreInst *SI = dyn_cast<StoreInst>(BBI)) { 2689 if (SI->isVolatile()) 2690 break; 2691 } else if (LoadInst *LI = dyn_cast<LoadInst>(BBI)) { 2692 if (LI->isVolatile()) 2693 break; 2694 } else if (AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(BBI)) { 2695 if (RMWI->isVolatile()) 2696 break; 2697 } else if (AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(BBI)) { 2698 if (CXI->isVolatile()) 2699 break; 2700 } else if (!isa<FenceInst>(BBI) && !isa<VAArgInst>(BBI) && 2701 !isa<LandingPadInst>(BBI)) { 2702 break; 2703 } 2704 // Note that deleting LandingPad's here is in fact okay, although it 2705 // involves a bit of subtle reasoning. If this inst is a LandingPad, 2706 // all the predecessors of this block will be the unwind edges of Invokes, 2707 // and we can therefore guarantee this block will be erased. 2708 } 2709 2710 // Delete this instruction (any uses are guaranteed to be dead) 2711 if (!BBI->use_empty()) 2712 BBI->replaceAllUsesWith(UndefValue::get(BBI->getType())); 2713 BBI->eraseFromParent(); 2714 Changed = true; 2715 } 2716 2717 // If the unreachable instruction is the first in the block, take a gander 2718 // at all of the predecessors of this instruction, and simplify them. 2719 if (&BB->front() != UI) return Changed; 2720 2721 SmallVector<BasicBlock*, 8> Preds(pred_begin(BB), pred_end(BB)); 2722 for (unsigned i = 0, e = Preds.size(); i != e; ++i) { 2723 TerminatorInst *TI = Preds[i]->getTerminator(); 2724 IRBuilder<> Builder(TI); 2725 if (BranchInst *BI = dyn_cast<BranchInst>(TI)) { 2726 if (BI->isUnconditional()) { 2727 if (BI->getSuccessor(0) == BB) { 2728 new UnreachableInst(TI->getContext(), TI); 2729 TI->eraseFromParent(); 2730 Changed = true; 2731 } 2732 } else { 2733 if (BI->getSuccessor(0) == BB) { 2734 Builder.CreateBr(BI->getSuccessor(1)); 2735 EraseTerminatorInstAndDCECond(BI); 2736 } else if (BI->getSuccessor(1) == BB) { 2737 Builder.CreateBr(BI->getSuccessor(0)); 2738 EraseTerminatorInstAndDCECond(BI); 2739 Changed = true; 2740 } 2741 } 2742 } else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { 2743 for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end(); 2744 i != e; ++i) 2745 if (i.getCaseSuccessor() == BB) { 2746 BB->removePredecessor(SI->getParent()); 2747 SI->removeCase(i); 2748 --i; --e; 2749 Changed = true; 2750 } 2751 // If the default value is unreachable, figure out the most popular 2752 // destination and make it the default. 2753 if (SI->getDefaultDest() == BB) { 2754 std::map<BasicBlock*, std::pair<unsigned, unsigned> > Popularity; 2755 for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end(); 2756 i != e; ++i) { 2757 std::pair<unsigned, unsigned> &entry = 2758 Popularity[i.getCaseSuccessor()]; 2759 if (entry.first == 0) { 2760 entry.first = 1; 2761 entry.second = i.getCaseIndex(); 2762 } else { 2763 entry.first++; 2764 } 2765 } 2766 2767 // Find the most popular block. 2768 unsigned MaxPop = 0; 2769 unsigned MaxIndex = 0; 2770 BasicBlock *MaxBlock = 0; 2771 for (std::map<BasicBlock*, std::pair<unsigned, unsigned> >::iterator 2772 I = Popularity.begin(), E = Popularity.end(); I != E; ++I) { 2773 if (I->second.first > MaxPop || 2774 (I->second.first == MaxPop && MaxIndex > I->second.second)) { 2775 MaxPop = I->second.first; 2776 MaxIndex = I->second.second; 2777 MaxBlock = I->first; 2778 } 2779 } 2780 if (MaxBlock) { 2781 // Make this the new default, allowing us to delete any explicit 2782 // edges to it. 2783 SI->setDefaultDest(MaxBlock); 2784 Changed = true; 2785 2786 // If MaxBlock has phinodes in it, remove MaxPop-1 entries from 2787 // it. 2788 if (isa<PHINode>(MaxBlock->begin())) 2789 for (unsigned i = 0; i != MaxPop-1; ++i) 2790 MaxBlock->removePredecessor(SI->getParent()); 2791 2792 for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end(); 2793 i != e; ++i) 2794 if (i.getCaseSuccessor() == MaxBlock) { 2795 SI->removeCase(i); 2796 --i; --e; 2797 } 2798 } 2799 } 2800 } else if (InvokeInst *II = dyn_cast<InvokeInst>(TI)) { 2801 if (II->getUnwindDest() == BB) { 2802 // Convert the invoke to a call instruction. This would be a good 2803 // place to note that the call does not throw though. 2804 BranchInst *BI = Builder.CreateBr(II->getNormalDest()); 2805 II->removeFromParent(); // Take out of symbol table 2806 2807 // Insert the call now... 2808 SmallVector<Value*, 8> Args(II->op_begin(), II->op_end()-3); 2809 Builder.SetInsertPoint(BI); 2810 CallInst *CI = Builder.CreateCall(II->getCalledValue(), 2811 Args, II->getName()); 2812 CI->setCallingConv(II->getCallingConv()); 2813 CI->setAttributes(II->getAttributes()); 2814 // If the invoke produced a value, the call does now instead. 2815 II->replaceAllUsesWith(CI); 2816 delete II; 2817 Changed = true; 2818 } 2819 } 2820 } 2821 2822 // If this block is now dead, remove it. 2823 if (pred_begin(BB) == pred_end(BB) && 2824 BB != &BB->getParent()->getEntryBlock()) { 2825 // We know there are no successors, so just nuke the block. 2826 BB->eraseFromParent(); 2827 return true; 2828 } 2829 2830 return Changed; 2831 } 2832 2833 /// TurnSwitchRangeIntoICmp - Turns a switch with that contains only a 2834 /// integer range comparison into a sub, an icmp and a branch. 2835 static bool TurnSwitchRangeIntoICmp(SwitchInst *SI, IRBuilder<> &Builder) { 2836 assert(SI->getNumCases() > 1 && "Degenerate switch?"); 2837 2838 // Make sure all cases point to the same destination and gather the values. 2839 SmallVector<ConstantInt *, 16> Cases; 2840 SwitchInst::CaseIt I = SI->case_begin(); 2841 Cases.push_back(I.getCaseValue()); 2842 SwitchInst::CaseIt PrevI = I++; 2843 for (SwitchInst::CaseIt E = SI->case_end(); I != E; PrevI = I++) { 2844 if (PrevI.getCaseSuccessor() != I.getCaseSuccessor()) 2845 return false; 2846 Cases.push_back(I.getCaseValue()); 2847 } 2848 assert(Cases.size() == SI->getNumCases() && "Not all cases gathered"); 2849 2850 // Sort the case values, then check if they form a range we can transform. 2851 array_pod_sort(Cases.begin(), Cases.end(), ConstantIntSortPredicate); 2852 for (unsigned I = 1, E = Cases.size(); I != E; ++I) { 2853 if (Cases[I-1]->getValue() != Cases[I]->getValue()+1) 2854 return false; 2855 } 2856 2857 Constant *Offset = ConstantExpr::getNeg(Cases.back()); 2858 Constant *NumCases = ConstantInt::get(Offset->getType(), SI->getNumCases()); 2859 2860 Value *Sub = SI->getCondition(); 2861 if (!Offset->isNullValue()) 2862 Sub = Builder.CreateAdd(Sub, Offset, Sub->getName()+".off"); 2863 Value *Cmp = Builder.CreateICmpULT(Sub, NumCases, "switch"); 2864 Builder.CreateCondBr( 2865 Cmp, SI->case_begin().getCaseSuccessor(), SI->getDefaultDest()); 2866 2867 // Prune obsolete incoming values off the successor's PHI nodes. 2868 for (BasicBlock::iterator BBI = SI->case_begin().getCaseSuccessor()->begin(); 2869 isa<PHINode>(BBI); ++BBI) { 2870 for (unsigned I = 0, E = SI->getNumCases()-1; I != E; ++I) 2871 cast<PHINode>(BBI)->removeIncomingValue(SI->getParent()); 2872 } 2873 SI->eraseFromParent(); 2874 2875 return true; 2876 } 2877 2878 /// EliminateDeadSwitchCases - Compute masked bits for the condition of a switch 2879 /// and use it to remove dead cases. 2880 static bool EliminateDeadSwitchCases(SwitchInst *SI) { 2881 Value *Cond = SI->getCondition(); 2882 unsigned Bits = cast<IntegerType>(Cond->getType())->getBitWidth(); 2883 APInt KnownZero(Bits, 0), KnownOne(Bits, 0); 2884 ComputeMaskedBits(Cond, KnownZero, KnownOne); 2885 2886 // Gather dead cases. 2887 SmallVector<ConstantInt*, 8> DeadCases; 2888 for (SwitchInst::CaseIt I = SI->case_begin(), E = SI->case_end(); I != E; ++I) { 2889 if ((I.getCaseValue()->getValue() & KnownZero) != 0 || 2890 (I.getCaseValue()->getValue() & KnownOne) != KnownOne) { 2891 DeadCases.push_back(I.getCaseValue()); 2892 DEBUG(dbgs() << "SimplifyCFG: switch case '" 2893 << I.getCaseValue() << "' is dead.\n"); 2894 } 2895 } 2896 2897 // Remove dead cases from the switch. 2898 for (unsigned I = 0, E = DeadCases.size(); I != E; ++I) { 2899 SwitchInst::CaseIt Case = SI->findCaseValue(DeadCases[I]); 2900 assert(Case != SI->case_default() && 2901 "Case was not found. Probably mistake in DeadCases forming."); 2902 // Prune unused values from PHI nodes. 2903 Case.getCaseSuccessor()->removePredecessor(SI->getParent()); 2904 SI->removeCase(Case); 2905 } 2906 2907 return !DeadCases.empty(); 2908 } 2909 2910 /// FindPHIForConditionForwarding - If BB would be eligible for simplification 2911 /// by TryToSimplifyUncondBranchFromEmptyBlock (i.e. it is empty and terminated 2912 /// by an unconditional branch), look at the phi node for BB in the successor 2913 /// block and see if the incoming value is equal to CaseValue. If so, return 2914 /// the phi node, and set PhiIndex to BB's index in the phi node. 2915 static PHINode *FindPHIForConditionForwarding(ConstantInt *CaseValue, 2916 BasicBlock *BB, 2917 int *PhiIndex) { 2918 if (BB->getFirstNonPHIOrDbg() != BB->getTerminator()) 2919 return NULL; // BB must be empty to be a candidate for simplification. 2920 if (!BB->getSinglePredecessor()) 2921 return NULL; // BB must be dominated by the switch. 2922 2923 BranchInst *Branch = dyn_cast<BranchInst>(BB->getTerminator()); 2924 if (!Branch || !Branch->isUnconditional()) 2925 return NULL; // Terminator must be unconditional branch. 2926 2927 BasicBlock *Succ = Branch->getSuccessor(0); 2928 2929 BasicBlock::iterator I = Succ->begin(); 2930 while (PHINode *PHI = dyn_cast<PHINode>(I++)) { 2931 int Idx = PHI->getBasicBlockIndex(BB); 2932 assert(Idx >= 0 && "PHI has no entry for predecessor?"); 2933 2934 Value *InValue = PHI->getIncomingValue(Idx); 2935 if (InValue != CaseValue) continue; 2936 2937 *PhiIndex = Idx; 2938 return PHI; 2939 } 2940 2941 return NULL; 2942 } 2943 2944 /// ForwardSwitchConditionToPHI - Try to forward the condition of a switch 2945 /// instruction to a phi node dominated by the switch, if that would mean that 2946 /// some of the destination blocks of the switch can be folded away. 2947 /// Returns true if a change is made. 2948 static bool ForwardSwitchConditionToPHI(SwitchInst *SI) { 2949 typedef DenseMap<PHINode*, SmallVector<int,4> > ForwardingNodesMap; 2950 ForwardingNodesMap ForwardingNodes; 2951 2952 for (SwitchInst::CaseIt I = SI->case_begin(), E = SI->case_end(); I != E; ++I) { 2953 ConstantInt *CaseValue = I.getCaseValue(); 2954 BasicBlock *CaseDest = I.getCaseSuccessor(); 2955 2956 int PhiIndex; 2957 PHINode *PHI = FindPHIForConditionForwarding(CaseValue, CaseDest, 2958 &PhiIndex); 2959 if (!PHI) continue; 2960 2961 ForwardingNodes[PHI].push_back(PhiIndex); 2962 } 2963 2964 bool Changed = false; 2965 2966 for (ForwardingNodesMap::iterator I = ForwardingNodes.begin(), 2967 E = ForwardingNodes.end(); I != E; ++I) { 2968 PHINode *Phi = I->first; 2969 SmallVector<int,4> &Indexes = I->second; 2970 2971 if (Indexes.size() < 2) continue; 2972 2973 for (size_t I = 0, E = Indexes.size(); I != E; ++I) 2974 Phi->setIncomingValue(Indexes[I], SI->getCondition()); 2975 Changed = true; 2976 } 2977 2978 return Changed; 2979 } 2980 2981 /// ValidLookupTableConstant - Return true if the backend will be able to handle 2982 /// initializing an array of constants like C. 2983 static bool ValidLookupTableConstant(Constant *C) { 2984 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) 2985 return CE->isGEPWithNoNotionalOverIndexing(); 2986 2987 return isa<ConstantFP>(C) || 2988 isa<ConstantInt>(C) || 2989 isa<ConstantPointerNull>(C) || 2990 isa<GlobalValue>(C) || 2991 isa<UndefValue>(C); 2992 } 2993 2994 /// GetCaseResulsts - Try to determine the resulting constant values in phi 2995 /// nodes at the common destination basic block for one of the case 2996 /// destinations of a switch instruction. 2997 static bool GetCaseResults(SwitchInst *SI, 2998 BasicBlock *CaseDest, 2999 BasicBlock **CommonDest, 3000 SmallVector<std::pair<PHINode*,Constant*>, 4> &Res) { 3001 // The block from which we enter the common destination. 3002 BasicBlock *Pred = SI->getParent(); 3003 3004 // If CaseDest is empty, continue to its successor. 3005 if (CaseDest->getFirstNonPHIOrDbg() == CaseDest->getTerminator() && 3006 !isa<PHINode>(CaseDest->begin())) { 3007 3008 TerminatorInst *Terminator = CaseDest->getTerminator(); 3009 if (Terminator->getNumSuccessors() != 1) 3010 return false; 3011 3012 Pred = CaseDest; 3013 CaseDest = Terminator->getSuccessor(0); 3014 } 3015 3016 // If we did not have a CommonDest before, use the current one. 3017 if (!*CommonDest) 3018 *CommonDest = CaseDest; 3019 // If the destination isn't the common one, abort. 3020 if (CaseDest != *CommonDest) 3021 return false; 3022 3023 // Get the values for this case from phi nodes in the destination block. 3024 BasicBlock::iterator I = (*CommonDest)->begin(); 3025 while (PHINode *PHI = dyn_cast<PHINode>(I++)) { 3026 int Idx = PHI->getBasicBlockIndex(Pred); 3027 if (Idx == -1) 3028 continue; 3029 3030 Constant *ConstVal = dyn_cast<Constant>(PHI->getIncomingValue(Idx)); 3031 if (!ConstVal) 3032 return false; 3033 3034 // Be conservative about which kinds of constants we support. 3035 if (!ValidLookupTableConstant(ConstVal)) 3036 return false; 3037 3038 Res.push_back(std::make_pair(PHI, ConstVal)); 3039 } 3040 3041 return true; 3042 } 3043 3044 /// BuildLookupTable - Build a lookup table with the contents of Results, using 3045 /// DefaultResult to fill the holes in the table. If the table ends up 3046 /// containing the same result in each element, set *SingleResult to that value 3047 /// and return NULL. 3048 static GlobalVariable *BuildLookupTable(Module &M, 3049 uint64_t TableSize, 3050 ConstantInt *Offset, 3051 const SmallVector<std::pair<ConstantInt*, Constant*>, 4>& Results, 3052 Constant *DefaultResult, 3053 Constant **SingleResult) { 3054 assert(Results.size() && "Need values to build lookup table"); 3055 assert(TableSize >= Results.size() && "Table needs to hold all values"); 3056 3057 // If all values in the table are equal, this is that value. 3058 Constant *SameResult = Results.begin()->second; 3059 3060 // Build up the table contents. 3061 std::vector<Constant*> TableContents(TableSize); 3062 for (size_t I = 0, E = Results.size(); I != E; ++I) { 3063 ConstantInt *CaseVal = Results[I].first; 3064 Constant *CaseRes = Results[I].second; 3065 3066 uint64_t Idx = (CaseVal->getValue() - Offset->getValue()).getLimitedValue(); 3067 TableContents[Idx] = CaseRes; 3068 3069 if (CaseRes != SameResult) 3070 SameResult = NULL; 3071 } 3072 3073 // Fill in any holes in the table with the default result. 3074 if (Results.size() < TableSize) { 3075 for (unsigned i = 0; i < TableSize; ++i) { 3076 if (!TableContents[i]) 3077 TableContents[i] = DefaultResult; 3078 } 3079 3080 if (DefaultResult != SameResult) 3081 SameResult = NULL; 3082 } 3083 3084 // Same result was used in the entire table; just return that. 3085 if (SameResult) { 3086 *SingleResult = SameResult; 3087 return NULL; 3088 } 3089 3090 ArrayType *ArrayTy = ArrayType::get(DefaultResult->getType(), TableSize); 3091 Constant *Initializer = ConstantArray::get(ArrayTy, TableContents); 3092 3093 GlobalVariable *GV = new GlobalVariable(M, ArrayTy, /*constant=*/ true, 3094 GlobalVariable::PrivateLinkage, 3095 Initializer, 3096 "switch.table"); 3097 GV->setUnnamedAddr(true); 3098 return GV; 3099 } 3100 3101 /// SwitchToLookupTable - If the switch is only used to initialize one or more 3102 /// phi nodes in a common successor block with different constant values, 3103 /// replace the switch with lookup tables. 3104 static bool SwitchToLookupTable(SwitchInst *SI, 3105 IRBuilder<> &Builder) { 3106 assert(SI->getNumCases() > 1 && "Degenerate switch?"); 3107 // FIXME: Handle unreachable cases. 3108 3109 // FIXME: If the switch is too sparse for a lookup table, perhaps we could 3110 // split off a dense part and build a lookup table for that. 3111 3112 // FIXME: If the results are all integers and the lookup table would fit in a 3113 // target-legal register, we should store them as a bitmap and use shift/mask 3114 // to look up the result. 3115 3116 // FIXME: This creates arrays of GEPs to constant strings, which means each 3117 // GEP needs a runtime relocation in PIC code. We should just build one big 3118 // string and lookup indices into that. 3119 3120 // Ignore the switch if the number of cases are too small. 3121 // This is similar to the check when building jump tables in 3122 // SelectionDAGBuilder::handleJTSwitchCase. 3123 // FIXME: Determine the best cut-off. 3124 if (SI->getNumCases() < 4) 3125 return false; 3126 3127 // Figure out the corresponding result for each case value and phi node in the 3128 // common destination, as well as the the min and max case values. 3129 assert(SI->case_begin() != SI->case_end()); 3130 SwitchInst::CaseIt CI = SI->case_begin(); 3131 ConstantInt *MinCaseVal = CI.getCaseValue(); 3132 ConstantInt *MaxCaseVal = CI.getCaseValue(); 3133 3134 BasicBlock *CommonDest = NULL; 3135 typedef SmallVector<std::pair<ConstantInt*, Constant*>, 4> ResultListTy; 3136 SmallDenseMap<PHINode*, ResultListTy> ResultLists; 3137 SmallDenseMap<PHINode*, Constant*> DefaultResults; 3138 SmallDenseMap<PHINode*, Type*> ResultTypes; 3139 SmallVector<PHINode*, 4> PHIs; 3140 3141 for (SwitchInst::CaseIt E = SI->case_end(); CI != E; ++CI) { 3142 ConstantInt *CaseVal = CI.getCaseValue(); 3143 if (CaseVal->getValue().slt(MinCaseVal->getValue())) 3144 MinCaseVal = CaseVal; 3145 if (CaseVal->getValue().sgt(MaxCaseVal->getValue())) 3146 MaxCaseVal = CaseVal; 3147 3148 // Resulting value at phi nodes for this case value. 3149 typedef SmallVector<std::pair<PHINode*, Constant*>, 4> ResultsTy; 3150 ResultsTy Results; 3151 if (!GetCaseResults(SI, CI.getCaseSuccessor(), &CommonDest, Results)) 3152 return false; 3153 3154 // Append the result from this case to the list for each phi. 3155 for (ResultsTy::iterator I = Results.begin(), E = Results.end(); I!=E; ++I) { 3156 if (!ResultLists.count(I->first)) 3157 PHIs.push_back(I->first); 3158 ResultLists[I->first].push_back(std::make_pair(CaseVal, I->second)); 3159 } 3160 } 3161 3162 // Get the resulting values for the default case. 3163 SmallVector<std::pair<PHINode*, Constant*>, 4> DefaultResultsList; 3164 if (!GetCaseResults(SI, SI->getDefaultDest(), &CommonDest, DefaultResultsList)) 3165 return false; 3166 for (size_t I = 0, E = DefaultResultsList.size(); I != E; ++I) { 3167 PHINode *PHI = DefaultResultsList[I].first; 3168 Constant *Result = DefaultResultsList[I].second; 3169 DefaultResults[PHI] = Result; 3170 ResultTypes[PHI] = Result->getType(); 3171 } 3172 3173 APInt RangeSpread = MaxCaseVal->getValue() - MinCaseVal->getValue(); 3174 // The table density should be at lest 40%. This is the same criterion as for 3175 // jump tables, see SelectionDAGBuilder::handleJTSwitchCase. 3176 // FIXME: Find the best cut-off. 3177 // Be careful to avoid overlow in the density computation. 3178 if (RangeSpread.zextOrSelf(64).ugt(UINT64_MAX / 4 - 1)) 3179 return false; 3180 uint64_t TableSize = RangeSpread.getLimitedValue() + 1; 3181 if (SI->getNumCases() * 10 < TableSize * 4) 3182 return false; 3183 3184 // Build the lookup tables. 3185 SmallDenseMap<PHINode*, GlobalVariable*> LookupTables; 3186 SmallDenseMap<PHINode*, Constant*> SingleResults; 3187 3188 Module &Mod = *CommonDest->getParent()->getParent(); 3189 for (SmallVector<PHINode*, 4>::iterator I = PHIs.begin(), E = PHIs.end(); 3190 I != E; ++I) { 3191 PHINode *PHI = *I; 3192 3193 Constant *SingleResult = NULL; 3194 LookupTables[PHI] = BuildLookupTable(Mod, TableSize, MinCaseVal, 3195 ResultLists[PHI], DefaultResults[PHI], 3196 &SingleResult); 3197 SingleResults[PHI] = SingleResult; 3198 } 3199 3200 // Create the BB that does the lookups. 3201 BasicBlock *LookupBB = BasicBlock::Create(Mod.getContext(), 3202 "switch.lookup", 3203 CommonDest->getParent(), 3204 CommonDest); 3205 3206 // Check whether the condition value is within the case range, and branch to 3207 // the new BB. 3208 Builder.SetInsertPoint(SI); 3209 Value *TableIndex = Builder.CreateSub(SI->getCondition(), MinCaseVal, 3210 "switch.tableidx"); 3211 Value *Cmp = Builder.CreateICmpULT(TableIndex, ConstantInt::get( 3212 MinCaseVal->getType(), TableSize)); 3213 Builder.CreateCondBr(Cmp, LookupBB, SI->getDefaultDest()); 3214 3215 // Populate the BB that does the lookups. 3216 Builder.SetInsertPoint(LookupBB); 3217 bool ReturnedEarly = false; 3218 for (SmallVector<PHINode*, 4>::iterator I = PHIs.begin(), E = PHIs.end(); 3219 I != E; ++I) { 3220 PHINode *PHI = *I; 3221 // There was a single result for this phi; just use that. 3222 if (Constant *SingleResult = SingleResults[PHI]) { 3223 PHI->addIncoming(SingleResult, LookupBB); 3224 continue; 3225 } 3226 3227 Value *GEPIndices[] = { Builder.getInt32(0), TableIndex }; 3228 Value *GEP = Builder.CreateInBoundsGEP(LookupTables[PHI], GEPIndices, 3229 "switch.gep"); 3230 Value *Result = Builder.CreateLoad(GEP, "switch.load"); 3231 3232 // If the result is only going to be used to return from the function, 3233 // we want to do that right here. 3234 if (PHI->hasOneUse() && isa<ReturnInst>(*PHI->use_begin())) { 3235 if (CommonDest->getFirstNonPHIOrDbg() == CommonDest->getTerminator()) { 3236 Builder.CreateRet(Result); 3237 ReturnedEarly = true; 3238 } 3239 } 3240 3241 if (!ReturnedEarly) 3242 PHI->addIncoming(Result, LookupBB); 3243 } 3244 3245 if (!ReturnedEarly) 3246 Builder.CreateBr(CommonDest); 3247 3248 // Remove the switch. 3249 for (unsigned i = 0; i < SI->getNumSuccessors(); ++i) { 3250 BasicBlock *Succ = SI->getSuccessor(i); 3251 if (Succ == SI->getDefaultDest()) continue; 3252 Succ->removePredecessor(SI->getParent()); 3253 } 3254 SI->eraseFromParent(); 3255 3256 ++NumLookupTables; 3257 return true; 3258 } 3259 3260 bool SimplifyCFGOpt::SimplifySwitch(SwitchInst *SI, IRBuilder<> &Builder) { 3261 // If this switch is too complex to want to look at, ignore it. 3262 if (!isValueEqualityComparison(SI)) 3263 return false; 3264 3265 BasicBlock *BB = SI->getParent(); 3266 3267 // If we only have one predecessor, and if it is a branch on this value, 3268 // see if that predecessor totally determines the outcome of this switch. 3269 if (BasicBlock *OnlyPred = BB->getSinglePredecessor()) 3270 if (SimplifyEqualityComparisonWithOnlyPredecessor(SI, OnlyPred, Builder)) 3271 return SimplifyCFG(BB) | true; 3272 3273 Value *Cond = SI->getCondition(); 3274 if (SelectInst *Select = dyn_cast<SelectInst>(Cond)) 3275 if (SimplifySwitchOnSelect(SI, Select)) 3276 return SimplifyCFG(BB) | true; 3277 3278 // If the block only contains the switch, see if we can fold the block 3279 // away into any preds. 3280 BasicBlock::iterator BBI = BB->begin(); 3281 // Ignore dbg intrinsics. 3282 while (isa<DbgInfoIntrinsic>(BBI)) 3283 ++BBI; 3284 if (SI == &*BBI) 3285 if (FoldValueComparisonIntoPredecessors(SI, Builder)) 3286 return SimplifyCFG(BB) | true; 3287 3288 // Try to transform the switch into an icmp and a branch. 3289 if (TurnSwitchRangeIntoICmp(SI, Builder)) 3290 return SimplifyCFG(BB) | true; 3291 3292 // Remove unreachable cases. 3293 if (EliminateDeadSwitchCases(SI)) 3294 return SimplifyCFG(BB) | true; 3295 3296 if (ForwardSwitchConditionToPHI(SI)) 3297 return SimplifyCFG(BB) | true; 3298 3299 if (SwitchToLookupTable(SI, Builder)) 3300 return SimplifyCFG(BB) | true; 3301 3302 return false; 3303 } 3304 3305 bool SimplifyCFGOpt::SimplifyIndirectBr(IndirectBrInst *IBI) { 3306 BasicBlock *BB = IBI->getParent(); 3307 bool Changed = false; 3308 3309 // Eliminate redundant destinations. 3310 SmallPtrSet<Value *, 8> Succs; 3311 for (unsigned i = 0, e = IBI->getNumDestinations(); i != e; ++i) { 3312 BasicBlock *Dest = IBI->getDestination(i); 3313 if (!Dest->hasAddressTaken() || !Succs.insert(Dest)) { 3314 Dest->removePredecessor(BB); 3315 IBI->removeDestination(i); 3316 --i; --e; 3317 Changed = true; 3318 } 3319 } 3320 3321 if (IBI->getNumDestinations() == 0) { 3322 // If the indirectbr has no successors, change it to unreachable. 3323 new UnreachableInst(IBI->getContext(), IBI); 3324 EraseTerminatorInstAndDCECond(IBI); 3325 return true; 3326 } 3327 3328 if (IBI->getNumDestinations() == 1) { 3329 // If the indirectbr has one successor, change it to a direct branch. 3330 BranchInst::Create(IBI->getDestination(0), IBI); 3331 EraseTerminatorInstAndDCECond(IBI); 3332 return true; 3333 } 3334 3335 if (SelectInst *SI = dyn_cast<SelectInst>(IBI->getAddress())) { 3336 if (SimplifyIndirectBrOnSelect(IBI, SI)) 3337 return SimplifyCFG(BB) | true; 3338 } 3339 return Changed; 3340 } 3341 3342 bool SimplifyCFGOpt::SimplifyUncondBranch(BranchInst *BI, IRBuilder<> &Builder){ 3343 BasicBlock *BB = BI->getParent(); 3344 3345 // If the Terminator is the only non-phi instruction, simplify the block. 3346 BasicBlock::iterator I = BB->getFirstNonPHIOrDbgOrLifetime(); 3347 if (I->isTerminator() && BB != &BB->getParent()->getEntryBlock() && 3348 TryToSimplifyUncondBranchFromEmptyBlock(BB)) 3349 return true; 3350 3351 // If the only instruction in the block is a seteq/setne comparison 3352 // against a constant, try to simplify the block. 3353 if (ICmpInst *ICI = dyn_cast<ICmpInst>(I)) 3354 if (ICI->isEquality() && isa<ConstantInt>(ICI->getOperand(1))) { 3355 for (++I; isa<DbgInfoIntrinsic>(I); ++I) 3356 ; 3357 if (I->isTerminator() && 3358 TryToSimplifyUncondBranchWithICmpInIt(ICI, TD, Builder)) 3359 return true; 3360 } 3361 3362 // If this basic block is ONLY a compare and a branch, and if a predecessor 3363 // branches to us and our successor, fold the comparison into the 3364 // predecessor and use logical operations to update the incoming value 3365 // for PHI nodes in common successor. 3366 if (FoldBranchToCommonDest(BI)) 3367 return SimplifyCFG(BB) | true; 3368 return false; 3369 } 3370 3371 3372 bool SimplifyCFGOpt::SimplifyCondBranch(BranchInst *BI, IRBuilder<> &Builder) { 3373 BasicBlock *BB = BI->getParent(); 3374 3375 // Conditional branch 3376 if (isValueEqualityComparison(BI)) { 3377 // If we only have one predecessor, and if it is a branch on this value, 3378 // see if that predecessor totally determines the outcome of this 3379 // switch. 3380 if (BasicBlock *OnlyPred = BB->getSinglePredecessor()) 3381 if (SimplifyEqualityComparisonWithOnlyPredecessor(BI, OnlyPred, Builder)) 3382 return SimplifyCFG(BB) | true; 3383 3384 // This block must be empty, except for the setcond inst, if it exists. 3385 // Ignore dbg intrinsics. 3386 BasicBlock::iterator I = BB->begin(); 3387 // Ignore dbg intrinsics. 3388 while (isa<DbgInfoIntrinsic>(I)) 3389 ++I; 3390 if (&*I == BI) { 3391 if (FoldValueComparisonIntoPredecessors(BI, Builder)) 3392 return SimplifyCFG(BB) | true; 3393 } else if (&*I == cast<Instruction>(BI->getCondition())){ 3394 ++I; 3395 // Ignore dbg intrinsics. 3396 while (isa<DbgInfoIntrinsic>(I)) 3397 ++I; 3398 if (&*I == BI && FoldValueComparisonIntoPredecessors(BI, Builder)) 3399 return SimplifyCFG(BB) | true; 3400 } 3401 } 3402 3403 // Try to turn "br (X == 0 | X == 1), T, F" into a switch instruction. 3404 if (SimplifyBranchOnICmpChain(BI, TD, Builder)) 3405 return true; 3406 3407 // If this basic block is ONLY a compare and a branch, and if a predecessor 3408 // branches to us and one of our successors, fold the comparison into the 3409 // predecessor and use logical operations to pick the right destination. 3410 if (FoldBranchToCommonDest(BI)) 3411 return SimplifyCFG(BB) | true; 3412 3413 // We have a conditional branch to two blocks that are only reachable 3414 // from BI. We know that the condbr dominates the two blocks, so see if 3415 // there is any identical code in the "then" and "else" blocks. If so, we 3416 // can hoist it up to the branching block. 3417 if (BI->getSuccessor(0)->getSinglePredecessor() != 0) { 3418 if (BI->getSuccessor(1)->getSinglePredecessor() != 0) { 3419 if (HoistThenElseCodeToIf(BI)) 3420 return SimplifyCFG(BB) | true; 3421 } else { 3422 // If Successor #1 has multiple preds, we may be able to conditionally 3423 // execute Successor #0 if it branches to successor #1. 3424 TerminatorInst *Succ0TI = BI->getSuccessor(0)->getTerminator(); 3425 if (Succ0TI->getNumSuccessors() == 1 && 3426 Succ0TI->getSuccessor(0) == BI->getSuccessor(1)) 3427 if (SpeculativelyExecuteBB(BI, BI->getSuccessor(0))) 3428 return SimplifyCFG(BB) | true; 3429 } 3430 } else if (BI->getSuccessor(1)->getSinglePredecessor() != 0) { 3431 // If Successor #0 has multiple preds, we may be able to conditionally 3432 // execute Successor #1 if it branches to successor #0. 3433 TerminatorInst *Succ1TI = BI->getSuccessor(1)->getTerminator(); 3434 if (Succ1TI->getNumSuccessors() == 1 && 3435 Succ1TI->getSuccessor(0) == BI->getSuccessor(0)) 3436 if (SpeculativelyExecuteBB(BI, BI->getSuccessor(1))) 3437 return SimplifyCFG(BB) | true; 3438 } 3439 3440 // If this is a branch on a phi node in the current block, thread control 3441 // through this block if any PHI node entries are constants. 3442 if (PHINode *PN = dyn_cast<PHINode>(BI->getCondition())) 3443 if (PN->getParent() == BI->getParent()) 3444 if (FoldCondBranchOnPHI(BI, TD)) 3445 return SimplifyCFG(BB) | true; 3446 3447 // Scan predecessor blocks for conditional branches. 3448 for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) 3449 if (BranchInst *PBI = dyn_cast<BranchInst>((*PI)->getTerminator())) 3450 if (PBI != BI && PBI->isConditional()) 3451 if (SimplifyCondBranchToCondBranch(PBI, BI)) 3452 return SimplifyCFG(BB) | true; 3453 3454 return false; 3455 } 3456 3457 /// Check if passing a value to an instruction will cause undefined behavior. 3458 static bool passingValueIsAlwaysUndefined(Value *V, Instruction *I) { 3459 Constant *C = dyn_cast<Constant>(V); 3460 if (!C) 3461 return false; 3462 3463 if (!I->hasOneUse()) // Only look at single-use instructions, for compile time 3464 return false; 3465 3466 if (C->isNullValue()) { 3467 Instruction *Use = I->use_back(); 3468 3469 // Now make sure that there are no instructions in between that can alter 3470 // control flow (eg. calls) 3471 for (BasicBlock::iterator i = ++BasicBlock::iterator(I); &*i != Use; ++i) 3472 if (i == I->getParent()->end() || i->mayHaveSideEffects()) 3473 return false; 3474 3475 // Look through GEPs. A load from a GEP derived from NULL is still undefined 3476 if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Use)) 3477 if (GEP->getPointerOperand() == I) 3478 return passingValueIsAlwaysUndefined(V, GEP); 3479 3480 // Look through bitcasts. 3481 if (BitCastInst *BC = dyn_cast<BitCastInst>(Use)) 3482 return passingValueIsAlwaysUndefined(V, BC); 3483 3484 // Load from null is undefined. 3485 if (LoadInst *LI = dyn_cast<LoadInst>(Use)) 3486 return LI->getPointerAddressSpace() == 0; 3487 3488 // Store to null is undefined. 3489 if (StoreInst *SI = dyn_cast<StoreInst>(Use)) 3490 return SI->getPointerAddressSpace() == 0 && SI->getPointerOperand() == I; 3491 } 3492 return false; 3493 } 3494 3495 /// If BB has an incoming value that will always trigger undefined behavior 3496 /// (eg. null pointer dereference), remove the branch leading here. 3497 static bool removeUndefIntroducingPredecessor(BasicBlock *BB) { 3498 for (BasicBlock::iterator i = BB->begin(); 3499 PHINode *PHI = dyn_cast<PHINode>(i); ++i) 3500 for (unsigned i = 0, e = PHI->getNumIncomingValues(); i != e; ++i) 3501 if (passingValueIsAlwaysUndefined(PHI->getIncomingValue(i), PHI)) { 3502 TerminatorInst *T = PHI->getIncomingBlock(i)->getTerminator(); 3503 IRBuilder<> Builder(T); 3504 if (BranchInst *BI = dyn_cast<BranchInst>(T)) { 3505 BB->removePredecessor(PHI->getIncomingBlock(i)); 3506 // Turn uncoditional branches into unreachables and remove the dead 3507 // destination from conditional branches. 3508 if (BI->isUnconditional()) 3509 Builder.CreateUnreachable(); 3510 else 3511 Builder.CreateBr(BI->getSuccessor(0) == BB ? BI->getSuccessor(1) : 3512 BI->getSuccessor(0)); 3513 BI->eraseFromParent(); 3514 return true; 3515 } 3516 // TODO: SwitchInst. 3517 } 3518 3519 return false; 3520 } 3521 3522 bool SimplifyCFGOpt::run(BasicBlock *BB) { 3523 bool Changed = false; 3524 3525 assert(BB && BB->getParent() && "Block not embedded in function!"); 3526 assert(BB->getTerminator() && "Degenerate basic block encountered!"); 3527 3528 // Remove basic blocks that have no predecessors (except the entry block)... 3529 // or that just have themself as a predecessor. These are unreachable. 3530 if ((pred_begin(BB) == pred_end(BB) && 3531 BB != &BB->getParent()->getEntryBlock()) || 3532 BB->getSinglePredecessor() == BB) { 3533 DEBUG(dbgs() << "Removing BB: \n" << *BB); 3534 DeleteDeadBlock(BB); 3535 return true; 3536 } 3537 3538 // Check to see if we can constant propagate this terminator instruction 3539 // away... 3540 Changed |= ConstantFoldTerminator(BB, true); 3541 3542 // Check for and eliminate duplicate PHI nodes in this block. 3543 Changed |= EliminateDuplicatePHINodes(BB); 3544 3545 // Check for and remove branches that will always cause undefined behavior. 3546 Changed |= removeUndefIntroducingPredecessor(BB); 3547 3548 // Merge basic blocks into their predecessor if there is only one distinct 3549 // pred, and if there is only one distinct successor of the predecessor, and 3550 // if there are no PHI nodes. 3551 // 3552 if (MergeBlockIntoPredecessor(BB)) 3553 return true; 3554 3555 IRBuilder<> Builder(BB); 3556 3557 // If there is a trivial two-entry PHI node in this basic block, and we can 3558 // eliminate it, do so now. 3559 if (PHINode *PN = dyn_cast<PHINode>(BB->begin())) 3560 if (PN->getNumIncomingValues() == 2) 3561 Changed |= FoldTwoEntryPHINode(PN, TD); 3562 3563 Builder.SetInsertPoint(BB->getTerminator()); 3564 if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator())) { 3565 if (BI->isUnconditional()) { 3566 if (SimplifyUncondBranch(BI, Builder)) return true; 3567 } else { 3568 if (SimplifyCondBranch(BI, Builder)) return true; 3569 } 3570 } else if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator())) { 3571 if (SimplifyReturn(RI, Builder)) return true; 3572 } else if (ResumeInst *RI = dyn_cast<ResumeInst>(BB->getTerminator())) { 3573 if (SimplifyResume(RI, Builder)) return true; 3574 } else if (SwitchInst *SI = dyn_cast<SwitchInst>(BB->getTerminator())) { 3575 if (SimplifySwitch(SI, Builder)) return true; 3576 } else if (UnreachableInst *UI = 3577 dyn_cast<UnreachableInst>(BB->getTerminator())) { 3578 if (SimplifyUnreachable(UI)) return true; 3579 } else if (IndirectBrInst *IBI = 3580 dyn_cast<IndirectBrInst>(BB->getTerminator())) { 3581 if (SimplifyIndirectBr(IBI)) return true; 3582 } 3583 3584 return Changed; 3585 } 3586 3587 /// SimplifyCFG - This function is used to do simplification of a CFG. For 3588 /// example, it adjusts branches to branches to eliminate the extra hop, it 3589 /// eliminates unreachable basic blocks, and does other "peephole" optimization 3590 /// of the CFG. It returns true if a modification was made. 3591 /// 3592 bool llvm::SimplifyCFG(BasicBlock *BB, const TargetData *TD) { 3593 return SimplifyCFGOpt(TD).run(BB); 3594 } 3595