1 //===- IfConversion.cpp - Machine code if conversion pass -----------------===// 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 // This file implements the machine instruction level if-conversion pass, which 11 // tries to convert conditional branches into predicated instructions. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "BranchFolding.h" 16 #include "llvm/ADT/STLExtras.h" 17 #include "llvm/ADT/ScopeExit.h" 18 #include "llvm/ADT/SmallSet.h" 19 #include "llvm/ADT/SmallVector.h" 20 #include "llvm/ADT/SparseSet.h" 21 #include "llvm/ADT/Statistic.h" 22 #include "llvm/ADT/iterator_range.h" 23 #include "llvm/CodeGen/LivePhysRegs.h" 24 #include "llvm/CodeGen/MachineBasicBlock.h" 25 #include "llvm/CodeGen/MachineBlockFrequencyInfo.h" 26 #include "llvm/CodeGen/MachineBranchProbabilityInfo.h" 27 #include "llvm/CodeGen/MachineFunction.h" 28 #include "llvm/CodeGen/MachineFunctionPass.h" 29 #include "llvm/CodeGen/MachineInstr.h" 30 #include "llvm/CodeGen/MachineInstrBuilder.h" 31 #include "llvm/CodeGen/MachineModuleInfo.h" 32 #include "llvm/CodeGen/MachineOperand.h" 33 #include "llvm/CodeGen/MachineRegisterInfo.h" 34 #include "llvm/CodeGen/TargetInstrInfo.h" 35 #include "llvm/CodeGen/TargetLowering.h" 36 #include "llvm/CodeGen/TargetRegisterInfo.h" 37 #include "llvm/CodeGen/TargetSchedule.h" 38 #include "llvm/CodeGen/TargetSubtargetInfo.h" 39 #include "llvm/IR/DebugLoc.h" 40 #include "llvm/MC/MCRegisterInfo.h" 41 #include "llvm/Pass.h" 42 #include "llvm/Support/BranchProbability.h" 43 #include "llvm/Support/CommandLine.h" 44 #include "llvm/Support/Debug.h" 45 #include "llvm/Support/ErrorHandling.h" 46 #include "llvm/Support/raw_ostream.h" 47 #include <algorithm> 48 #include <cassert> 49 #include <functional> 50 #include <iterator> 51 #include <memory> 52 #include <utility> 53 #include <vector> 54 55 using namespace llvm; 56 57 #define DEBUG_TYPE "if-converter" 58 59 // Hidden options for help debugging. 60 static cl::opt<int> IfCvtFnStart("ifcvt-fn-start", cl::init(-1), cl::Hidden); 61 static cl::opt<int> IfCvtFnStop("ifcvt-fn-stop", cl::init(-1), cl::Hidden); 62 static cl::opt<int> IfCvtLimit("ifcvt-limit", cl::init(-1), cl::Hidden); 63 static cl::opt<bool> DisableSimple("disable-ifcvt-simple", 64 cl::init(false), cl::Hidden); 65 static cl::opt<bool> DisableSimpleF("disable-ifcvt-simple-false", 66 cl::init(false), cl::Hidden); 67 static cl::opt<bool> DisableTriangle("disable-ifcvt-triangle", 68 cl::init(false), cl::Hidden); 69 static cl::opt<bool> DisableTriangleR("disable-ifcvt-triangle-rev", 70 cl::init(false), cl::Hidden); 71 static cl::opt<bool> DisableTriangleF("disable-ifcvt-triangle-false", 72 cl::init(false), cl::Hidden); 73 static cl::opt<bool> DisableTriangleFR("disable-ifcvt-triangle-false-rev", 74 cl::init(false), cl::Hidden); 75 static cl::opt<bool> DisableDiamond("disable-ifcvt-diamond", 76 cl::init(false), cl::Hidden); 77 static cl::opt<bool> DisableForkedDiamond("disable-ifcvt-forked-diamond", 78 cl::init(false), cl::Hidden); 79 static cl::opt<bool> IfCvtBranchFold("ifcvt-branch-fold", 80 cl::init(true), cl::Hidden); 81 82 STATISTIC(NumSimple, "Number of simple if-conversions performed"); 83 STATISTIC(NumSimpleFalse, "Number of simple (F) if-conversions performed"); 84 STATISTIC(NumTriangle, "Number of triangle if-conversions performed"); 85 STATISTIC(NumTriangleRev, "Number of triangle (R) if-conversions performed"); 86 STATISTIC(NumTriangleFalse,"Number of triangle (F) if-conversions performed"); 87 STATISTIC(NumTriangleFRev, "Number of triangle (F/R) if-conversions performed"); 88 STATISTIC(NumDiamonds, "Number of diamond if-conversions performed"); 89 STATISTIC(NumForkedDiamonds, "Number of forked-diamond if-conversions performed"); 90 STATISTIC(NumIfConvBBs, "Number of if-converted blocks"); 91 STATISTIC(NumDupBBs, "Number of duplicated blocks"); 92 STATISTIC(NumUnpred, "Number of true blocks of diamonds unpredicated"); 93 94 namespace { 95 96 class IfConverter : public MachineFunctionPass { 97 enum IfcvtKind { 98 ICNotClassfied, // BB data valid, but not classified. 99 ICSimpleFalse, // Same as ICSimple, but on the false path. 100 ICSimple, // BB is entry of an one split, no rejoin sub-CFG. 101 ICTriangleFRev, // Same as ICTriangleFalse, but false path rev condition. 102 ICTriangleRev, // Same as ICTriangle, but true path rev condition. 103 ICTriangleFalse, // Same as ICTriangle, but on the false path. 104 ICTriangle, // BB is entry of a triangle sub-CFG. 105 ICDiamond, // BB is entry of a diamond sub-CFG. 106 ICForkedDiamond // BB is entry of an almost diamond sub-CFG, with a 107 // common tail that can be shared. 108 }; 109 110 /// One per MachineBasicBlock, this is used to cache the result 111 /// if-conversion feasibility analysis. This includes results from 112 /// TargetInstrInfo::analyzeBranch() (i.e. TBB, FBB, and Cond), and its 113 /// classification, and common tail block of its successors (if it's a 114 /// diamond shape), its size, whether it's predicable, and whether any 115 /// instruction can clobber the 'would-be' predicate. 116 /// 117 /// IsDone - True if BB is not to be considered for ifcvt. 118 /// IsBeingAnalyzed - True if BB is currently being analyzed. 119 /// IsAnalyzed - True if BB has been analyzed (info is still valid). 120 /// IsEnqueued - True if BB has been enqueued to be ifcvt'ed. 121 /// IsBrAnalyzable - True if analyzeBranch() returns false. 122 /// HasFallThrough - True if BB may fallthrough to the following BB. 123 /// IsUnpredicable - True if BB is known to be unpredicable. 124 /// ClobbersPred - True if BB could modify predicates (e.g. has 125 /// cmp, call, etc.) 126 /// NonPredSize - Number of non-predicated instructions. 127 /// ExtraCost - Extra cost for multi-cycle instructions. 128 /// ExtraCost2 - Some instructions are slower when predicated 129 /// BB - Corresponding MachineBasicBlock. 130 /// TrueBB / FalseBB- See analyzeBranch(). 131 /// BrCond - Conditions for end of block conditional branches. 132 /// Predicate - Predicate used in the BB. 133 struct BBInfo { 134 bool IsDone : 1; 135 bool IsBeingAnalyzed : 1; 136 bool IsAnalyzed : 1; 137 bool IsEnqueued : 1; 138 bool IsBrAnalyzable : 1; 139 bool IsBrReversible : 1; 140 bool HasFallThrough : 1; 141 bool IsUnpredicable : 1; 142 bool CannotBeCopied : 1; 143 bool ClobbersPred : 1; 144 unsigned NonPredSize = 0; 145 unsigned ExtraCost = 0; 146 unsigned ExtraCost2 = 0; 147 MachineBasicBlock *BB = nullptr; 148 MachineBasicBlock *TrueBB = nullptr; 149 MachineBasicBlock *FalseBB = nullptr; 150 SmallVector<MachineOperand, 4> BrCond; 151 SmallVector<MachineOperand, 4> Predicate; 152 153 BBInfo() : IsDone(false), IsBeingAnalyzed(false), 154 IsAnalyzed(false), IsEnqueued(false), IsBrAnalyzable(false), 155 IsBrReversible(false), HasFallThrough(false), 156 IsUnpredicable(false), CannotBeCopied(false), 157 ClobbersPred(false) {} 158 }; 159 160 /// Record information about pending if-conversions to attempt: 161 /// BBI - Corresponding BBInfo. 162 /// Kind - Type of block. See IfcvtKind. 163 /// NeedSubsumption - True if the to-be-predicated BB has already been 164 /// predicated. 165 /// NumDups - Number of instructions that would be duplicated due 166 /// to this if-conversion. (For diamonds, the number of 167 /// identical instructions at the beginnings of both 168 /// paths). 169 /// NumDups2 - For diamonds, the number of identical instructions 170 /// at the ends of both paths. 171 struct IfcvtToken { 172 BBInfo &BBI; 173 IfcvtKind Kind; 174 unsigned NumDups; 175 unsigned NumDups2; 176 bool NeedSubsumption : 1; 177 bool TClobbersPred : 1; 178 bool FClobbersPred : 1; 179 180 IfcvtToken(BBInfo &b, IfcvtKind k, bool s, unsigned d, unsigned d2 = 0, 181 bool tc = false, bool fc = false) 182 : BBI(b), Kind(k), NumDups(d), NumDups2(d2), NeedSubsumption(s), 183 TClobbersPred(tc), FClobbersPred(fc) {} 184 }; 185 186 /// Results of if-conversion feasibility analysis indexed by basic block 187 /// number. 188 std::vector<BBInfo> BBAnalysis; 189 TargetSchedModel SchedModel; 190 191 const TargetLoweringBase *TLI; 192 const TargetInstrInfo *TII; 193 const TargetRegisterInfo *TRI; 194 const MachineBranchProbabilityInfo *MBPI; 195 MachineRegisterInfo *MRI; 196 197 LivePhysRegs Redefs; 198 199 bool PreRegAlloc; 200 bool MadeChange; 201 int FnNum = -1; 202 std::function<bool(const MachineFunction &)> PredicateFtor; 203 204 public: 205 static char ID; 206 207 IfConverter(std::function<bool(const MachineFunction &)> Ftor = nullptr) 208 : MachineFunctionPass(ID), PredicateFtor(std::move(Ftor)) { 209 initializeIfConverterPass(*PassRegistry::getPassRegistry()); 210 } 211 212 void getAnalysisUsage(AnalysisUsage &AU) const override { 213 AU.addRequired<MachineBlockFrequencyInfo>(); 214 AU.addRequired<MachineBranchProbabilityInfo>(); 215 MachineFunctionPass::getAnalysisUsage(AU); 216 } 217 218 bool runOnMachineFunction(MachineFunction &MF) override; 219 220 MachineFunctionProperties getRequiredProperties() const override { 221 return MachineFunctionProperties().set( 222 MachineFunctionProperties::Property::NoVRegs); 223 } 224 225 private: 226 bool reverseBranchCondition(BBInfo &BBI) const; 227 bool ValidSimple(BBInfo &TrueBBI, unsigned &Dups, 228 BranchProbability Prediction) const; 229 bool ValidTriangle(BBInfo &TrueBBI, BBInfo &FalseBBI, 230 bool FalseBranch, unsigned &Dups, 231 BranchProbability Prediction) const; 232 bool CountDuplicatedInstructions( 233 MachineBasicBlock::iterator &TIB, MachineBasicBlock::iterator &FIB, 234 MachineBasicBlock::iterator &TIE, MachineBasicBlock::iterator &FIE, 235 unsigned &Dups1, unsigned &Dups2, 236 MachineBasicBlock &TBB, MachineBasicBlock &FBB, 237 bool SkipUnconditionalBranches) const; 238 bool ValidDiamond(BBInfo &TrueBBI, BBInfo &FalseBBI, 239 unsigned &Dups1, unsigned &Dups2, 240 BBInfo &TrueBBICalc, BBInfo &FalseBBICalc) const; 241 bool ValidForkedDiamond(BBInfo &TrueBBI, BBInfo &FalseBBI, 242 unsigned &Dups1, unsigned &Dups2, 243 BBInfo &TrueBBICalc, BBInfo &FalseBBICalc) const; 244 void AnalyzeBranches(BBInfo &BBI); 245 void ScanInstructions(BBInfo &BBI, 246 MachineBasicBlock::iterator &Begin, 247 MachineBasicBlock::iterator &End, 248 bool BranchUnpredicable = false) const; 249 bool RescanInstructions( 250 MachineBasicBlock::iterator &TIB, MachineBasicBlock::iterator &FIB, 251 MachineBasicBlock::iterator &TIE, MachineBasicBlock::iterator &FIE, 252 BBInfo &TrueBBI, BBInfo &FalseBBI) const; 253 void AnalyzeBlock(MachineBasicBlock &MBB, 254 std::vector<std::unique_ptr<IfcvtToken>> &Tokens); 255 bool FeasibilityAnalysis(BBInfo &BBI, SmallVectorImpl<MachineOperand> &Pred, 256 bool isTriangle = false, bool RevBranch = false, 257 bool hasCommonTail = false); 258 void AnalyzeBlocks(MachineFunction &MF, 259 std::vector<std::unique_ptr<IfcvtToken>> &Tokens); 260 void InvalidatePreds(MachineBasicBlock &MBB); 261 bool IfConvertSimple(BBInfo &BBI, IfcvtKind Kind); 262 bool IfConvertTriangle(BBInfo &BBI, IfcvtKind Kind); 263 bool IfConvertDiamondCommon(BBInfo &BBI, BBInfo &TrueBBI, BBInfo &FalseBBI, 264 unsigned NumDups1, unsigned NumDups2, 265 bool TClobbersPred, bool FClobbersPred, 266 bool RemoveBranch, bool MergeAddEdges); 267 bool IfConvertDiamond(BBInfo &BBI, IfcvtKind Kind, 268 unsigned NumDups1, unsigned NumDups2, 269 bool TClobbers, bool FClobbers); 270 bool IfConvertForkedDiamond(BBInfo &BBI, IfcvtKind Kind, 271 unsigned NumDups1, unsigned NumDups2, 272 bool TClobbers, bool FClobbers); 273 void PredicateBlock(BBInfo &BBI, 274 MachineBasicBlock::iterator E, 275 SmallVectorImpl<MachineOperand> &Cond, 276 SmallSet<unsigned, 4> *LaterRedefs = nullptr); 277 void CopyAndPredicateBlock(BBInfo &ToBBI, BBInfo &FromBBI, 278 SmallVectorImpl<MachineOperand> &Cond, 279 bool IgnoreBr = false); 280 void MergeBlocks(BBInfo &ToBBI, BBInfo &FromBBI, bool AddEdges = true); 281 282 bool MeetIfcvtSizeLimit(MachineBasicBlock &BB, 283 unsigned Cycle, unsigned Extra, 284 BranchProbability Prediction) const { 285 return Cycle > 0 && TII->isProfitableToIfCvt(BB, Cycle, Extra, 286 Prediction); 287 } 288 289 bool MeetIfcvtSizeLimit(MachineBasicBlock &TBB, 290 unsigned TCycle, unsigned TExtra, 291 MachineBasicBlock &FBB, 292 unsigned FCycle, unsigned FExtra, 293 BranchProbability Prediction) const { 294 return TCycle > 0 && FCycle > 0 && 295 TII->isProfitableToIfCvt(TBB, TCycle, TExtra, FBB, FCycle, FExtra, 296 Prediction); 297 } 298 299 /// Returns true if Block ends without a terminator. 300 bool blockAlwaysFallThrough(BBInfo &BBI) const { 301 return BBI.IsBrAnalyzable && BBI.TrueBB == nullptr; 302 } 303 304 /// Used to sort if-conversion candidates. 305 static bool IfcvtTokenCmp(const std::unique_ptr<IfcvtToken> &C1, 306 const std::unique_ptr<IfcvtToken> &C2) { 307 int Incr1 = (C1->Kind == ICDiamond) 308 ? -(int)(C1->NumDups + C1->NumDups2) : (int)C1->NumDups; 309 int Incr2 = (C2->Kind == ICDiamond) 310 ? -(int)(C2->NumDups + C2->NumDups2) : (int)C2->NumDups; 311 if (Incr1 > Incr2) 312 return true; 313 else if (Incr1 == Incr2) { 314 // Favors subsumption. 315 if (!C1->NeedSubsumption && C2->NeedSubsumption) 316 return true; 317 else if (C1->NeedSubsumption == C2->NeedSubsumption) { 318 // Favors diamond over triangle, etc. 319 if ((unsigned)C1->Kind < (unsigned)C2->Kind) 320 return true; 321 else if (C1->Kind == C2->Kind) 322 return C1->BBI.BB->getNumber() < C2->BBI.BB->getNumber(); 323 } 324 } 325 return false; 326 } 327 }; 328 329 } // end anonymous namespace 330 331 char IfConverter::ID = 0; 332 333 char &llvm::IfConverterID = IfConverter::ID; 334 335 INITIALIZE_PASS_BEGIN(IfConverter, DEBUG_TYPE, "If Converter", false, false) 336 INITIALIZE_PASS_DEPENDENCY(MachineBranchProbabilityInfo) 337 INITIALIZE_PASS_END(IfConverter, DEBUG_TYPE, "If Converter", false, false) 338 339 bool IfConverter::runOnMachineFunction(MachineFunction &MF) { 340 if (skipFunction(MF.getFunction()) || (PredicateFtor && !PredicateFtor(MF))) 341 return false; 342 343 const TargetSubtargetInfo &ST = MF.getSubtarget(); 344 TLI = ST.getTargetLowering(); 345 TII = ST.getInstrInfo(); 346 TRI = ST.getRegisterInfo(); 347 BranchFolder::MBFIWrapper MBFI(getAnalysis<MachineBlockFrequencyInfo>()); 348 MBPI = &getAnalysis<MachineBranchProbabilityInfo>(); 349 MRI = &MF.getRegInfo(); 350 SchedModel.init(&ST); 351 352 if (!TII) return false; 353 354 PreRegAlloc = MRI->isSSA(); 355 356 bool BFChange = false; 357 if (!PreRegAlloc) { 358 // Tail merge tend to expose more if-conversion opportunities. 359 BranchFolder BF(true, false, MBFI, *MBPI); 360 BFChange = BF.OptimizeFunction(MF, TII, ST.getRegisterInfo(), 361 getAnalysisIfAvailable<MachineModuleInfo>()); 362 } 363 364 LLVM_DEBUG(dbgs() << "\nIfcvt: function (" << ++FnNum << ") \'" 365 << MF.getName() << "\'"); 366 367 if (FnNum < IfCvtFnStart || (IfCvtFnStop != -1 && FnNum > IfCvtFnStop)) { 368 LLVM_DEBUG(dbgs() << " skipped\n"); 369 return false; 370 } 371 LLVM_DEBUG(dbgs() << "\n"); 372 373 MF.RenumberBlocks(); 374 BBAnalysis.resize(MF.getNumBlockIDs()); 375 376 std::vector<std::unique_ptr<IfcvtToken>> Tokens; 377 MadeChange = false; 378 unsigned NumIfCvts = NumSimple + NumSimpleFalse + NumTriangle + 379 NumTriangleRev + NumTriangleFalse + NumTriangleFRev + NumDiamonds; 380 while (IfCvtLimit == -1 || (int)NumIfCvts < IfCvtLimit) { 381 // Do an initial analysis for each basic block and find all the potential 382 // candidates to perform if-conversion. 383 bool Change = false; 384 AnalyzeBlocks(MF, Tokens); 385 while (!Tokens.empty()) { 386 std::unique_ptr<IfcvtToken> Token = std::move(Tokens.back()); 387 Tokens.pop_back(); 388 BBInfo &BBI = Token->BBI; 389 IfcvtKind Kind = Token->Kind; 390 unsigned NumDups = Token->NumDups; 391 unsigned NumDups2 = Token->NumDups2; 392 393 // If the block has been evicted out of the queue or it has already been 394 // marked dead (due to it being predicated), then skip it. 395 if (BBI.IsDone) 396 BBI.IsEnqueued = false; 397 if (!BBI.IsEnqueued) 398 continue; 399 400 BBI.IsEnqueued = false; 401 402 bool RetVal = false; 403 switch (Kind) { 404 default: llvm_unreachable("Unexpected!"); 405 case ICSimple: 406 case ICSimpleFalse: { 407 bool isFalse = Kind == ICSimpleFalse; 408 if ((isFalse && DisableSimpleF) || (!isFalse && DisableSimple)) break; 409 LLVM_DEBUG(dbgs() << "Ifcvt (Simple" 410 << (Kind == ICSimpleFalse ? " false" : "") 411 << "): " << printMBBReference(*BBI.BB) << " (" 412 << ((Kind == ICSimpleFalse) ? BBI.FalseBB->getNumber() 413 : BBI.TrueBB->getNumber()) 414 << ") "); 415 RetVal = IfConvertSimple(BBI, Kind); 416 LLVM_DEBUG(dbgs() << (RetVal ? "succeeded!" : "failed!") << "\n"); 417 if (RetVal) { 418 if (isFalse) ++NumSimpleFalse; 419 else ++NumSimple; 420 } 421 break; 422 } 423 case ICTriangle: 424 case ICTriangleRev: 425 case ICTriangleFalse: 426 case ICTriangleFRev: { 427 bool isFalse = Kind == ICTriangleFalse; 428 bool isRev = (Kind == ICTriangleRev || Kind == ICTriangleFRev); 429 if (DisableTriangle && !isFalse && !isRev) break; 430 if (DisableTriangleR && !isFalse && isRev) break; 431 if (DisableTriangleF && isFalse && !isRev) break; 432 if (DisableTriangleFR && isFalse && isRev) break; 433 LLVM_DEBUG(dbgs() << "Ifcvt (Triangle"); 434 if (isFalse) 435 LLVM_DEBUG(dbgs() << " false"); 436 if (isRev) 437 LLVM_DEBUG(dbgs() << " rev"); 438 LLVM_DEBUG(dbgs() << "): " << printMBBReference(*BBI.BB) 439 << " (T:" << BBI.TrueBB->getNumber() 440 << ",F:" << BBI.FalseBB->getNumber() << ") "); 441 RetVal = IfConvertTriangle(BBI, Kind); 442 LLVM_DEBUG(dbgs() << (RetVal ? "succeeded!" : "failed!") << "\n"); 443 if (RetVal) { 444 if (isFalse) { 445 if (isRev) ++NumTriangleFRev; 446 else ++NumTriangleFalse; 447 } else { 448 if (isRev) ++NumTriangleRev; 449 else ++NumTriangle; 450 } 451 } 452 break; 453 } 454 case ICDiamond: 455 if (DisableDiamond) break; 456 LLVM_DEBUG(dbgs() << "Ifcvt (Diamond): " << printMBBReference(*BBI.BB) 457 << " (T:" << BBI.TrueBB->getNumber() 458 << ",F:" << BBI.FalseBB->getNumber() << ") "); 459 RetVal = IfConvertDiamond(BBI, Kind, NumDups, NumDups2, 460 Token->TClobbersPred, 461 Token->FClobbersPred); 462 LLVM_DEBUG(dbgs() << (RetVal ? "succeeded!" : "failed!") << "\n"); 463 if (RetVal) ++NumDiamonds; 464 break; 465 case ICForkedDiamond: 466 if (DisableForkedDiamond) break; 467 LLVM_DEBUG(dbgs() << "Ifcvt (Forked Diamond): " 468 << printMBBReference(*BBI.BB) 469 << " (T:" << BBI.TrueBB->getNumber() 470 << ",F:" << BBI.FalseBB->getNumber() << ") "); 471 RetVal = IfConvertForkedDiamond(BBI, Kind, NumDups, NumDups2, 472 Token->TClobbersPred, 473 Token->FClobbersPred); 474 LLVM_DEBUG(dbgs() << (RetVal ? "succeeded!" : "failed!") << "\n"); 475 if (RetVal) ++NumForkedDiamonds; 476 break; 477 } 478 479 if (RetVal && MRI->tracksLiveness()) 480 recomputeLivenessFlags(*BBI.BB); 481 482 Change |= RetVal; 483 484 NumIfCvts = NumSimple + NumSimpleFalse + NumTriangle + NumTriangleRev + 485 NumTriangleFalse + NumTriangleFRev + NumDiamonds; 486 if (IfCvtLimit != -1 && (int)NumIfCvts >= IfCvtLimit) 487 break; 488 } 489 490 if (!Change) 491 break; 492 MadeChange |= Change; 493 } 494 495 Tokens.clear(); 496 BBAnalysis.clear(); 497 498 if (MadeChange && IfCvtBranchFold) { 499 BranchFolder BF(false, false, MBFI, *MBPI); 500 BF.OptimizeFunction(MF, TII, MF.getSubtarget().getRegisterInfo(), 501 getAnalysisIfAvailable<MachineModuleInfo>()); 502 } 503 504 MadeChange |= BFChange; 505 return MadeChange; 506 } 507 508 /// BB has a fallthrough. Find its 'false' successor given its 'true' successor. 509 static MachineBasicBlock *findFalseBlock(MachineBasicBlock *BB, 510 MachineBasicBlock *TrueBB) { 511 for (MachineBasicBlock *SuccBB : BB->successors()) { 512 if (SuccBB != TrueBB) 513 return SuccBB; 514 } 515 return nullptr; 516 } 517 518 /// Reverse the condition of the end of the block branch. Swap block's 'true' 519 /// and 'false' successors. 520 bool IfConverter::reverseBranchCondition(BBInfo &BBI) const { 521 DebugLoc dl; // FIXME: this is nowhere 522 if (!TII->reverseBranchCondition(BBI.BrCond)) { 523 TII->removeBranch(*BBI.BB); 524 TII->insertBranch(*BBI.BB, BBI.FalseBB, BBI.TrueBB, BBI.BrCond, dl); 525 std::swap(BBI.TrueBB, BBI.FalseBB); 526 return true; 527 } 528 return false; 529 } 530 531 /// Returns the next block in the function blocks ordering. If it is the end, 532 /// returns NULL. 533 static inline MachineBasicBlock *getNextBlock(MachineBasicBlock &MBB) { 534 MachineFunction::iterator I = MBB.getIterator(); 535 MachineFunction::iterator E = MBB.getParent()->end(); 536 if (++I == E) 537 return nullptr; 538 return &*I; 539 } 540 541 /// Returns true if the 'true' block (along with its predecessor) forms a valid 542 /// simple shape for ifcvt. It also returns the number of instructions that the 543 /// ifcvt would need to duplicate if performed in Dups. 544 bool IfConverter::ValidSimple(BBInfo &TrueBBI, unsigned &Dups, 545 BranchProbability Prediction) const { 546 Dups = 0; 547 if (TrueBBI.IsBeingAnalyzed || TrueBBI.IsDone) 548 return false; 549 550 if (TrueBBI.IsBrAnalyzable) 551 return false; 552 553 if (TrueBBI.BB->pred_size() > 1) { 554 if (TrueBBI.CannotBeCopied || 555 !TII->isProfitableToDupForIfCvt(*TrueBBI.BB, TrueBBI.NonPredSize, 556 Prediction)) 557 return false; 558 Dups = TrueBBI.NonPredSize; 559 } 560 561 return true; 562 } 563 564 /// Returns true if the 'true' and 'false' blocks (along with their common 565 /// predecessor) forms a valid triangle shape for ifcvt. If 'FalseBranch' is 566 /// true, it checks if 'true' block's false branch branches to the 'false' block 567 /// rather than the other way around. It also returns the number of instructions 568 /// that the ifcvt would need to duplicate if performed in 'Dups'. 569 bool IfConverter::ValidTriangle(BBInfo &TrueBBI, BBInfo &FalseBBI, 570 bool FalseBranch, unsigned &Dups, 571 BranchProbability Prediction) const { 572 Dups = 0; 573 if (TrueBBI.IsBeingAnalyzed || TrueBBI.IsDone) 574 return false; 575 576 if (TrueBBI.BB->pred_size() > 1) { 577 if (TrueBBI.CannotBeCopied) 578 return false; 579 580 unsigned Size = TrueBBI.NonPredSize; 581 if (TrueBBI.IsBrAnalyzable) { 582 if (TrueBBI.TrueBB && TrueBBI.BrCond.empty()) 583 // Ends with an unconditional branch. It will be removed. 584 --Size; 585 else { 586 MachineBasicBlock *FExit = FalseBranch 587 ? TrueBBI.TrueBB : TrueBBI.FalseBB; 588 if (FExit) 589 // Require a conditional branch 590 ++Size; 591 } 592 } 593 if (!TII->isProfitableToDupForIfCvt(*TrueBBI.BB, Size, Prediction)) 594 return false; 595 Dups = Size; 596 } 597 598 MachineBasicBlock *TExit = FalseBranch ? TrueBBI.FalseBB : TrueBBI.TrueBB; 599 if (!TExit && blockAlwaysFallThrough(TrueBBI)) { 600 MachineFunction::iterator I = TrueBBI.BB->getIterator(); 601 if (++I == TrueBBI.BB->getParent()->end()) 602 return false; 603 TExit = &*I; 604 } 605 return TExit && TExit == FalseBBI.BB; 606 } 607 608 /// Count duplicated instructions and move the iterators to show where they 609 /// are. 610 /// @param TIB True Iterator Begin 611 /// @param FIB False Iterator Begin 612 /// These two iterators initially point to the first instruction of the two 613 /// blocks, and finally point to the first non-shared instruction. 614 /// @param TIE True Iterator End 615 /// @param FIE False Iterator End 616 /// These two iterators initially point to End() for the two blocks() and 617 /// finally point to the first shared instruction in the tail. 618 /// Upon return [TIB, TIE), and [FIB, FIE) mark the un-duplicated portions of 619 /// two blocks. 620 /// @param Dups1 count of duplicated instructions at the beginning of the 2 621 /// blocks. 622 /// @param Dups2 count of duplicated instructions at the end of the 2 blocks. 623 /// @param SkipUnconditionalBranches if true, Don't make sure that 624 /// unconditional branches at the end of the blocks are the same. True is 625 /// passed when the blocks are analyzable to allow for fallthrough to be 626 /// handled. 627 /// @return false if the shared portion prevents if conversion. 628 bool IfConverter::CountDuplicatedInstructions( 629 MachineBasicBlock::iterator &TIB, 630 MachineBasicBlock::iterator &FIB, 631 MachineBasicBlock::iterator &TIE, 632 MachineBasicBlock::iterator &FIE, 633 unsigned &Dups1, unsigned &Dups2, 634 MachineBasicBlock &TBB, MachineBasicBlock &FBB, 635 bool SkipUnconditionalBranches) const { 636 while (TIB != TIE && FIB != FIE) { 637 // Skip dbg_value instructions. These do not count. 638 TIB = skipDebugInstructionsForward(TIB, TIE); 639 FIB = skipDebugInstructionsForward(FIB, FIE); 640 if (TIB == TIE || FIB == FIE) 641 break; 642 if (!TIB->isIdenticalTo(*FIB)) 643 break; 644 // A pred-clobbering instruction in the shared portion prevents 645 // if-conversion. 646 std::vector<MachineOperand> PredDefs; 647 if (TII->DefinesPredicate(*TIB, PredDefs)) 648 return false; 649 // If we get all the way to the branch instructions, don't count them. 650 if (!TIB->isBranch()) 651 ++Dups1; 652 ++TIB; 653 ++FIB; 654 } 655 656 // Check for already containing all of the block. 657 if (TIB == TIE || FIB == FIE) 658 return true; 659 // Now, in preparation for counting duplicate instructions at the ends of the 660 // blocks, switch to reverse_iterators. Note that getReverse() returns an 661 // iterator that points to the same instruction, unlike std::reverse_iterator. 662 // We have to do our own shifting so that we get the same range. 663 MachineBasicBlock::reverse_iterator RTIE = std::next(TIE.getReverse()); 664 MachineBasicBlock::reverse_iterator RFIE = std::next(FIE.getReverse()); 665 const MachineBasicBlock::reverse_iterator RTIB = std::next(TIB.getReverse()); 666 const MachineBasicBlock::reverse_iterator RFIB = std::next(FIB.getReverse()); 667 668 if (!TBB.succ_empty() || !FBB.succ_empty()) { 669 if (SkipUnconditionalBranches) { 670 while (RTIE != RTIB && RTIE->isUnconditionalBranch()) 671 ++RTIE; 672 while (RFIE != RFIB && RFIE->isUnconditionalBranch()) 673 ++RFIE; 674 } 675 } 676 677 // Count duplicate instructions at the ends of the blocks. 678 while (RTIE != RTIB && RFIE != RFIB) { 679 // Skip dbg_value instructions. These do not count. 680 // Note that these are reverse iterators going forward. 681 RTIE = skipDebugInstructionsForward(RTIE, RTIB); 682 RFIE = skipDebugInstructionsForward(RFIE, RFIB); 683 if (RTIE == RTIB || RFIE == RFIB) 684 break; 685 if (!RTIE->isIdenticalTo(*RFIE)) 686 break; 687 // We have to verify that any branch instructions are the same, and then we 688 // don't count them toward the # of duplicate instructions. 689 if (!RTIE->isBranch()) 690 ++Dups2; 691 ++RTIE; 692 ++RFIE; 693 } 694 TIE = std::next(RTIE.getReverse()); 695 FIE = std::next(RFIE.getReverse()); 696 return true; 697 } 698 699 /// RescanInstructions - Run ScanInstructions on a pair of blocks. 700 /// @param TIB - True Iterator Begin, points to first non-shared instruction 701 /// @param FIB - False Iterator Begin, points to first non-shared instruction 702 /// @param TIE - True Iterator End, points past last non-shared instruction 703 /// @param FIE - False Iterator End, points past last non-shared instruction 704 /// @param TrueBBI - BBInfo to update for the true block. 705 /// @param FalseBBI - BBInfo to update for the false block. 706 /// @returns - false if either block cannot be predicated or if both blocks end 707 /// with a predicate-clobbering instruction. 708 bool IfConverter::RescanInstructions( 709 MachineBasicBlock::iterator &TIB, MachineBasicBlock::iterator &FIB, 710 MachineBasicBlock::iterator &TIE, MachineBasicBlock::iterator &FIE, 711 BBInfo &TrueBBI, BBInfo &FalseBBI) const { 712 bool BranchUnpredicable = true; 713 TrueBBI.IsUnpredicable = FalseBBI.IsUnpredicable = false; 714 ScanInstructions(TrueBBI, TIB, TIE, BranchUnpredicable); 715 if (TrueBBI.IsUnpredicable) 716 return false; 717 ScanInstructions(FalseBBI, FIB, FIE, BranchUnpredicable); 718 if (FalseBBI.IsUnpredicable) 719 return false; 720 if (TrueBBI.ClobbersPred && FalseBBI.ClobbersPred) 721 return false; 722 return true; 723 } 724 725 #ifndef NDEBUG 726 static void verifySameBranchInstructions( 727 MachineBasicBlock *MBB1, 728 MachineBasicBlock *MBB2) { 729 const MachineBasicBlock::reverse_iterator B1 = MBB1->rend(); 730 const MachineBasicBlock::reverse_iterator B2 = MBB2->rend(); 731 MachineBasicBlock::reverse_iterator E1 = MBB1->rbegin(); 732 MachineBasicBlock::reverse_iterator E2 = MBB2->rbegin(); 733 while (E1 != B1 && E2 != B2) { 734 skipDebugInstructionsForward(E1, B1); 735 skipDebugInstructionsForward(E2, B2); 736 if (E1 == B1 && E2 == B2) 737 break; 738 739 if (E1 == B1) { 740 assert(!E2->isBranch() && "Branch mis-match, one block is empty."); 741 break; 742 } 743 if (E2 == B2) { 744 assert(!E1->isBranch() && "Branch mis-match, one block is empty."); 745 break; 746 } 747 748 if (E1->isBranch() || E2->isBranch()) 749 assert(E1->isIdenticalTo(*E2) && 750 "Branch mis-match, branch instructions don't match."); 751 else 752 break; 753 ++E1; 754 ++E2; 755 } 756 } 757 #endif 758 759 /// ValidForkedDiamond - Returns true if the 'true' and 'false' blocks (along 760 /// with their common predecessor) form a diamond if a common tail block is 761 /// extracted. 762 /// While not strictly a diamond, this pattern would form a diamond if 763 /// tail-merging had merged the shared tails. 764 /// EBB 765 /// _/ \_ 766 /// | | 767 /// TBB FBB 768 /// / \ / \ 769 /// FalseBB TrueBB FalseBB 770 /// Currently only handles analyzable branches. 771 /// Specifically excludes actual diamonds to avoid overlap. 772 bool IfConverter::ValidForkedDiamond( 773 BBInfo &TrueBBI, BBInfo &FalseBBI, 774 unsigned &Dups1, unsigned &Dups2, 775 BBInfo &TrueBBICalc, BBInfo &FalseBBICalc) const { 776 Dups1 = Dups2 = 0; 777 if (TrueBBI.IsBeingAnalyzed || TrueBBI.IsDone || 778 FalseBBI.IsBeingAnalyzed || FalseBBI.IsDone) 779 return false; 780 781 if (!TrueBBI.IsBrAnalyzable || !FalseBBI.IsBrAnalyzable) 782 return false; 783 // Don't IfConvert blocks that can't be folded into their predecessor. 784 if (TrueBBI.BB->pred_size() > 1 || FalseBBI.BB->pred_size() > 1) 785 return false; 786 787 // This function is specifically looking for conditional tails, as 788 // unconditional tails are already handled by the standard diamond case. 789 if (TrueBBI.BrCond.size() == 0 || 790 FalseBBI.BrCond.size() == 0) 791 return false; 792 793 MachineBasicBlock *TT = TrueBBI.TrueBB; 794 MachineBasicBlock *TF = TrueBBI.FalseBB; 795 MachineBasicBlock *FT = FalseBBI.TrueBB; 796 MachineBasicBlock *FF = FalseBBI.FalseBB; 797 798 if (!TT) 799 TT = getNextBlock(*TrueBBI.BB); 800 if (!TF) 801 TF = getNextBlock(*TrueBBI.BB); 802 if (!FT) 803 FT = getNextBlock(*FalseBBI.BB); 804 if (!FF) 805 FF = getNextBlock(*FalseBBI.BB); 806 807 if (!TT || !TF) 808 return false; 809 810 // Check successors. If they don't match, bail. 811 if (!((TT == FT && TF == FF) || (TF == FT && TT == FF))) 812 return false; 813 814 bool FalseReversed = false; 815 if (TF == FT && TT == FF) { 816 // If the branches are opposing, but we can't reverse, don't do it. 817 if (!FalseBBI.IsBrReversible) 818 return false; 819 FalseReversed = true; 820 reverseBranchCondition(FalseBBI); 821 } 822 auto UnReverseOnExit = make_scope_exit([&]() { 823 if (FalseReversed) 824 reverseBranchCondition(FalseBBI); 825 }); 826 827 // Count duplicate instructions at the beginning of the true and false blocks. 828 MachineBasicBlock::iterator TIB = TrueBBI.BB->begin(); 829 MachineBasicBlock::iterator FIB = FalseBBI.BB->begin(); 830 MachineBasicBlock::iterator TIE = TrueBBI.BB->end(); 831 MachineBasicBlock::iterator FIE = FalseBBI.BB->end(); 832 if(!CountDuplicatedInstructions(TIB, FIB, TIE, FIE, Dups1, Dups2, 833 *TrueBBI.BB, *FalseBBI.BB, 834 /* SkipUnconditionalBranches */ true)) 835 return false; 836 837 TrueBBICalc.BB = TrueBBI.BB; 838 FalseBBICalc.BB = FalseBBI.BB; 839 if (!RescanInstructions(TIB, FIB, TIE, FIE, TrueBBICalc, FalseBBICalc)) 840 return false; 841 842 // The size is used to decide whether to if-convert, and the shared portions 843 // are subtracted off. Because of the subtraction, we just use the size that 844 // was calculated by the original ScanInstructions, as it is correct. 845 TrueBBICalc.NonPredSize = TrueBBI.NonPredSize; 846 FalseBBICalc.NonPredSize = FalseBBI.NonPredSize; 847 return true; 848 } 849 850 /// ValidDiamond - Returns true if the 'true' and 'false' blocks (along 851 /// with their common predecessor) forms a valid diamond shape for ifcvt. 852 bool IfConverter::ValidDiamond( 853 BBInfo &TrueBBI, BBInfo &FalseBBI, 854 unsigned &Dups1, unsigned &Dups2, 855 BBInfo &TrueBBICalc, BBInfo &FalseBBICalc) const { 856 Dups1 = Dups2 = 0; 857 if (TrueBBI.IsBeingAnalyzed || TrueBBI.IsDone || 858 FalseBBI.IsBeingAnalyzed || FalseBBI.IsDone) 859 return false; 860 861 MachineBasicBlock *TT = TrueBBI.TrueBB; 862 MachineBasicBlock *FT = FalseBBI.TrueBB; 863 864 if (!TT && blockAlwaysFallThrough(TrueBBI)) 865 TT = getNextBlock(*TrueBBI.BB); 866 if (!FT && blockAlwaysFallThrough(FalseBBI)) 867 FT = getNextBlock(*FalseBBI.BB); 868 if (TT != FT) 869 return false; 870 if (!TT && (TrueBBI.IsBrAnalyzable || FalseBBI.IsBrAnalyzable)) 871 return false; 872 if (TrueBBI.BB->pred_size() > 1 || FalseBBI.BB->pred_size() > 1) 873 return false; 874 875 // FIXME: Allow true block to have an early exit? 876 if (TrueBBI.FalseBB || FalseBBI.FalseBB) 877 return false; 878 879 // Count duplicate instructions at the beginning and end of the true and 880 // false blocks. 881 // Skip unconditional branches only if we are considering an analyzable 882 // diamond. Otherwise the branches must be the same. 883 bool SkipUnconditionalBranches = 884 TrueBBI.IsBrAnalyzable && FalseBBI.IsBrAnalyzable; 885 MachineBasicBlock::iterator TIB = TrueBBI.BB->begin(); 886 MachineBasicBlock::iterator FIB = FalseBBI.BB->begin(); 887 MachineBasicBlock::iterator TIE = TrueBBI.BB->end(); 888 MachineBasicBlock::iterator FIE = FalseBBI.BB->end(); 889 if(!CountDuplicatedInstructions(TIB, FIB, TIE, FIE, Dups1, Dups2, 890 *TrueBBI.BB, *FalseBBI.BB, 891 SkipUnconditionalBranches)) 892 return false; 893 894 TrueBBICalc.BB = TrueBBI.BB; 895 FalseBBICalc.BB = FalseBBI.BB; 896 if (!RescanInstructions(TIB, FIB, TIE, FIE, TrueBBICalc, FalseBBICalc)) 897 return false; 898 // The size is used to decide whether to if-convert, and the shared portions 899 // are subtracted off. Because of the subtraction, we just use the size that 900 // was calculated by the original ScanInstructions, as it is correct. 901 TrueBBICalc.NonPredSize = TrueBBI.NonPredSize; 902 FalseBBICalc.NonPredSize = FalseBBI.NonPredSize; 903 return true; 904 } 905 906 /// AnalyzeBranches - Look at the branches at the end of a block to determine if 907 /// the block is predicable. 908 void IfConverter::AnalyzeBranches(BBInfo &BBI) { 909 if (BBI.IsDone) 910 return; 911 912 BBI.TrueBB = BBI.FalseBB = nullptr; 913 BBI.BrCond.clear(); 914 BBI.IsBrAnalyzable = 915 !TII->analyzeBranch(*BBI.BB, BBI.TrueBB, BBI.FalseBB, BBI.BrCond); 916 SmallVector<MachineOperand, 4> RevCond(BBI.BrCond.begin(), BBI.BrCond.end()); 917 BBI.IsBrReversible = (RevCond.size() == 0) || 918 !TII->reverseBranchCondition(RevCond); 919 BBI.HasFallThrough = BBI.IsBrAnalyzable && BBI.FalseBB == nullptr; 920 921 if (BBI.BrCond.size()) { 922 // No false branch. This BB must end with a conditional branch and a 923 // fallthrough. 924 if (!BBI.FalseBB) 925 BBI.FalseBB = findFalseBlock(BBI.BB, BBI.TrueBB); 926 if (!BBI.FalseBB) { 927 // Malformed bcc? True and false blocks are the same? 928 BBI.IsUnpredicable = true; 929 } 930 } 931 } 932 933 /// ScanInstructions - Scan all the instructions in the block to determine if 934 /// the block is predicable. In most cases, that means all the instructions 935 /// in the block are isPredicable(). Also checks if the block contains any 936 /// instruction which can clobber a predicate (e.g. condition code register). 937 /// If so, the block is not predicable unless it's the last instruction. 938 void IfConverter::ScanInstructions(BBInfo &BBI, 939 MachineBasicBlock::iterator &Begin, 940 MachineBasicBlock::iterator &End, 941 bool BranchUnpredicable) const { 942 if (BBI.IsDone || BBI.IsUnpredicable) 943 return; 944 945 bool AlreadyPredicated = !BBI.Predicate.empty(); 946 947 BBI.NonPredSize = 0; 948 BBI.ExtraCost = 0; 949 BBI.ExtraCost2 = 0; 950 BBI.ClobbersPred = false; 951 for (MachineInstr &MI : make_range(Begin, End)) { 952 if (MI.isDebugInstr()) 953 continue; 954 955 // It's unsafe to duplicate convergent instructions in this context, so set 956 // BBI.CannotBeCopied to true if MI is convergent. To see why, consider the 957 // following CFG, which is subject to our "simple" transformation. 958 // 959 // BB0 // if (c1) goto BB1; else goto BB2; 960 // / \ 961 // BB1 | 962 // | BB2 // if (c2) goto TBB; else goto FBB; 963 // | / | 964 // | / | 965 // TBB | 966 // | | 967 // | FBB 968 // | 969 // exit 970 // 971 // Suppose we want to move TBB's contents up into BB1 and BB2 (in BB1 they'd 972 // be unconditional, and in BB2, they'd be predicated upon c2), and suppose 973 // TBB contains a convergent instruction. This is safe iff doing so does 974 // not add a control-flow dependency to the convergent instruction -- i.e., 975 // it's safe iff the set of control flows that leads us to the convergent 976 // instruction does not get smaller after the transformation. 977 // 978 // Originally we executed TBB if c1 || c2. After the transformation, there 979 // are two copies of TBB's instructions. We get to the first if c1, and we 980 // get to the second if !c1 && c2. 981 // 982 // There are clearly fewer ways to satisfy the condition "c1" than 983 // "c1 || c2". Since we've shrunk the set of control flows which lead to 984 // our convergent instruction, the transformation is unsafe. 985 if (MI.isNotDuplicable() || MI.isConvergent()) 986 BBI.CannotBeCopied = true; 987 988 bool isPredicated = TII->isPredicated(MI); 989 bool isCondBr = BBI.IsBrAnalyzable && MI.isConditionalBranch(); 990 991 if (BranchUnpredicable && MI.isBranch()) { 992 BBI.IsUnpredicable = true; 993 return; 994 } 995 996 // A conditional branch is not predicable, but it may be eliminated. 997 if (isCondBr) 998 continue; 999 1000 if (!isPredicated) { 1001 BBI.NonPredSize++; 1002 unsigned ExtraPredCost = TII->getPredicationCost(MI); 1003 unsigned NumCycles = SchedModel.computeInstrLatency(&MI, false); 1004 if (NumCycles > 1) 1005 BBI.ExtraCost += NumCycles-1; 1006 BBI.ExtraCost2 += ExtraPredCost; 1007 } else if (!AlreadyPredicated) { 1008 // FIXME: This instruction is already predicated before the 1009 // if-conversion pass. It's probably something like a conditional move. 1010 // Mark this block unpredicable for now. 1011 BBI.IsUnpredicable = true; 1012 return; 1013 } 1014 1015 if (BBI.ClobbersPred && !isPredicated) { 1016 // Predicate modification instruction should end the block (except for 1017 // already predicated instructions and end of block branches). 1018 // Predicate may have been modified, the subsequent (currently) 1019 // unpredicated instructions cannot be correctly predicated. 1020 BBI.IsUnpredicable = true; 1021 return; 1022 } 1023 1024 // FIXME: Make use of PredDefs? e.g. ADDC, SUBC sets predicates but are 1025 // still potentially predicable. 1026 std::vector<MachineOperand> PredDefs; 1027 if (TII->DefinesPredicate(MI, PredDefs)) 1028 BBI.ClobbersPred = true; 1029 1030 if (!TII->isPredicable(MI)) { 1031 BBI.IsUnpredicable = true; 1032 return; 1033 } 1034 } 1035 } 1036 1037 /// Determine if the block is a suitable candidate to be predicated by the 1038 /// specified predicate. 1039 /// @param BBI BBInfo for the block to check 1040 /// @param Pred Predicate array for the branch that leads to BBI 1041 /// @param isTriangle true if the Analysis is for a triangle 1042 /// @param RevBranch true if Reverse(Pred) leads to BBI (e.g. BBI is the false 1043 /// case 1044 /// @param hasCommonTail true if BBI shares a tail with a sibling block that 1045 /// contains any instruction that would make the block unpredicable. 1046 bool IfConverter::FeasibilityAnalysis(BBInfo &BBI, 1047 SmallVectorImpl<MachineOperand> &Pred, 1048 bool isTriangle, bool RevBranch, 1049 bool hasCommonTail) { 1050 // If the block is dead or unpredicable, then it cannot be predicated. 1051 // Two blocks may share a common unpredicable tail, but this doesn't prevent 1052 // them from being if-converted. The non-shared portion is assumed to have 1053 // been checked 1054 if (BBI.IsDone || (BBI.IsUnpredicable && !hasCommonTail)) 1055 return false; 1056 1057 // If it is already predicated but we couldn't analyze its terminator, the 1058 // latter might fallthrough, but we can't determine where to. 1059 // Conservatively avoid if-converting again. 1060 if (BBI.Predicate.size() && !BBI.IsBrAnalyzable) 1061 return false; 1062 1063 // If it is already predicated, check if the new predicate subsumes 1064 // its predicate. 1065 if (BBI.Predicate.size() && !TII->SubsumesPredicate(Pred, BBI.Predicate)) 1066 return false; 1067 1068 if (!hasCommonTail && BBI.BrCond.size()) { 1069 if (!isTriangle) 1070 return false; 1071 1072 // Test predicate subsumption. 1073 SmallVector<MachineOperand, 4> RevPred(Pred.begin(), Pred.end()); 1074 SmallVector<MachineOperand, 4> Cond(BBI.BrCond.begin(), BBI.BrCond.end()); 1075 if (RevBranch) { 1076 if (TII->reverseBranchCondition(Cond)) 1077 return false; 1078 } 1079 if (TII->reverseBranchCondition(RevPred) || 1080 !TII->SubsumesPredicate(Cond, RevPred)) 1081 return false; 1082 } 1083 1084 return true; 1085 } 1086 1087 /// Analyze the structure of the sub-CFG starting from the specified block. 1088 /// Record its successors and whether it looks like an if-conversion candidate. 1089 void IfConverter::AnalyzeBlock( 1090 MachineBasicBlock &MBB, std::vector<std::unique_ptr<IfcvtToken>> &Tokens) { 1091 struct BBState { 1092 BBState(MachineBasicBlock &MBB) : MBB(&MBB), SuccsAnalyzed(false) {} 1093 MachineBasicBlock *MBB; 1094 1095 /// This flag is true if MBB's successors have been analyzed. 1096 bool SuccsAnalyzed; 1097 }; 1098 1099 // Push MBB to the stack. 1100 SmallVector<BBState, 16> BBStack(1, MBB); 1101 1102 while (!BBStack.empty()) { 1103 BBState &State = BBStack.back(); 1104 MachineBasicBlock *BB = State.MBB; 1105 BBInfo &BBI = BBAnalysis[BB->getNumber()]; 1106 1107 if (!State.SuccsAnalyzed) { 1108 if (BBI.IsAnalyzed || BBI.IsBeingAnalyzed) { 1109 BBStack.pop_back(); 1110 continue; 1111 } 1112 1113 BBI.BB = BB; 1114 BBI.IsBeingAnalyzed = true; 1115 1116 AnalyzeBranches(BBI); 1117 MachineBasicBlock::iterator Begin = BBI.BB->begin(); 1118 MachineBasicBlock::iterator End = BBI.BB->end(); 1119 ScanInstructions(BBI, Begin, End); 1120 1121 // Unanalyzable or ends with fallthrough or unconditional branch, or if is 1122 // not considered for ifcvt anymore. 1123 if (!BBI.IsBrAnalyzable || BBI.BrCond.empty() || BBI.IsDone) { 1124 BBI.IsBeingAnalyzed = false; 1125 BBI.IsAnalyzed = true; 1126 BBStack.pop_back(); 1127 continue; 1128 } 1129 1130 // Do not ifcvt if either path is a back edge to the entry block. 1131 if (BBI.TrueBB == BB || BBI.FalseBB == BB) { 1132 BBI.IsBeingAnalyzed = false; 1133 BBI.IsAnalyzed = true; 1134 BBStack.pop_back(); 1135 continue; 1136 } 1137 1138 // Do not ifcvt if true and false fallthrough blocks are the same. 1139 if (!BBI.FalseBB) { 1140 BBI.IsBeingAnalyzed = false; 1141 BBI.IsAnalyzed = true; 1142 BBStack.pop_back(); 1143 continue; 1144 } 1145 1146 // Push the False and True blocks to the stack. 1147 State.SuccsAnalyzed = true; 1148 BBStack.push_back(*BBI.FalseBB); 1149 BBStack.push_back(*BBI.TrueBB); 1150 continue; 1151 } 1152 1153 BBInfo &TrueBBI = BBAnalysis[BBI.TrueBB->getNumber()]; 1154 BBInfo &FalseBBI = BBAnalysis[BBI.FalseBB->getNumber()]; 1155 1156 if (TrueBBI.IsDone && FalseBBI.IsDone) { 1157 BBI.IsBeingAnalyzed = false; 1158 BBI.IsAnalyzed = true; 1159 BBStack.pop_back(); 1160 continue; 1161 } 1162 1163 SmallVector<MachineOperand, 4> 1164 RevCond(BBI.BrCond.begin(), BBI.BrCond.end()); 1165 bool CanRevCond = !TII->reverseBranchCondition(RevCond); 1166 1167 unsigned Dups = 0; 1168 unsigned Dups2 = 0; 1169 bool TNeedSub = !TrueBBI.Predicate.empty(); 1170 bool FNeedSub = !FalseBBI.Predicate.empty(); 1171 bool Enqueued = false; 1172 1173 BranchProbability Prediction = MBPI->getEdgeProbability(BB, TrueBBI.BB); 1174 1175 if (CanRevCond) { 1176 BBInfo TrueBBICalc, FalseBBICalc; 1177 auto feasibleDiamond = [&]() { 1178 bool MeetsSize = MeetIfcvtSizeLimit( 1179 *TrueBBI.BB, (TrueBBICalc.NonPredSize - (Dups + Dups2) + 1180 TrueBBICalc.ExtraCost), TrueBBICalc.ExtraCost2, 1181 *FalseBBI.BB, (FalseBBICalc.NonPredSize - (Dups + Dups2) + 1182 FalseBBICalc.ExtraCost), FalseBBICalc.ExtraCost2, 1183 Prediction); 1184 bool TrueFeasible = FeasibilityAnalysis(TrueBBI, BBI.BrCond, 1185 /* IsTriangle */ false, /* RevCond */ false, 1186 /* hasCommonTail */ true); 1187 bool FalseFeasible = FeasibilityAnalysis(FalseBBI, RevCond, 1188 /* IsTriangle */ false, /* RevCond */ false, 1189 /* hasCommonTail */ true); 1190 return MeetsSize && TrueFeasible && FalseFeasible; 1191 }; 1192 1193 if (ValidDiamond(TrueBBI, FalseBBI, Dups, Dups2, 1194 TrueBBICalc, FalseBBICalc)) { 1195 if (feasibleDiamond()) { 1196 // Diamond: 1197 // EBB 1198 // / \_ 1199 // | | 1200 // TBB FBB 1201 // \ / 1202 // TailBB 1203 // Note TailBB can be empty. 1204 Tokens.push_back(llvm::make_unique<IfcvtToken>( 1205 BBI, ICDiamond, TNeedSub | FNeedSub, Dups, Dups2, 1206 (bool) TrueBBICalc.ClobbersPred, (bool) FalseBBICalc.ClobbersPred)); 1207 Enqueued = true; 1208 } 1209 } else if (ValidForkedDiamond(TrueBBI, FalseBBI, Dups, Dups2, 1210 TrueBBICalc, FalseBBICalc)) { 1211 if (feasibleDiamond()) { 1212 // ForkedDiamond: 1213 // if TBB and FBB have a common tail that includes their conditional 1214 // branch instructions, then we can If Convert this pattern. 1215 // EBB 1216 // _/ \_ 1217 // | | 1218 // TBB FBB 1219 // / \ / \ 1220 // FalseBB TrueBB FalseBB 1221 // 1222 Tokens.push_back(llvm::make_unique<IfcvtToken>( 1223 BBI, ICForkedDiamond, TNeedSub | FNeedSub, Dups, Dups2, 1224 (bool) TrueBBICalc.ClobbersPred, (bool) FalseBBICalc.ClobbersPred)); 1225 Enqueued = true; 1226 } 1227 } 1228 } 1229 1230 if (ValidTriangle(TrueBBI, FalseBBI, false, Dups, Prediction) && 1231 MeetIfcvtSizeLimit(*TrueBBI.BB, TrueBBI.NonPredSize + TrueBBI.ExtraCost, 1232 TrueBBI.ExtraCost2, Prediction) && 1233 FeasibilityAnalysis(TrueBBI, BBI.BrCond, true)) { 1234 // Triangle: 1235 // EBB 1236 // | \_ 1237 // | | 1238 // | TBB 1239 // | / 1240 // FBB 1241 Tokens.push_back( 1242 llvm::make_unique<IfcvtToken>(BBI, ICTriangle, TNeedSub, Dups)); 1243 Enqueued = true; 1244 } 1245 1246 if (ValidTriangle(TrueBBI, FalseBBI, true, Dups, Prediction) && 1247 MeetIfcvtSizeLimit(*TrueBBI.BB, TrueBBI.NonPredSize + TrueBBI.ExtraCost, 1248 TrueBBI.ExtraCost2, Prediction) && 1249 FeasibilityAnalysis(TrueBBI, BBI.BrCond, true, true)) { 1250 Tokens.push_back( 1251 llvm::make_unique<IfcvtToken>(BBI, ICTriangleRev, TNeedSub, Dups)); 1252 Enqueued = true; 1253 } 1254 1255 if (ValidSimple(TrueBBI, Dups, Prediction) && 1256 MeetIfcvtSizeLimit(*TrueBBI.BB, TrueBBI.NonPredSize + TrueBBI.ExtraCost, 1257 TrueBBI.ExtraCost2, Prediction) && 1258 FeasibilityAnalysis(TrueBBI, BBI.BrCond)) { 1259 // Simple (split, no rejoin): 1260 // EBB 1261 // | \_ 1262 // | | 1263 // | TBB---> exit 1264 // | 1265 // FBB 1266 Tokens.push_back( 1267 llvm::make_unique<IfcvtToken>(BBI, ICSimple, TNeedSub, Dups)); 1268 Enqueued = true; 1269 } 1270 1271 if (CanRevCond) { 1272 // Try the other path... 1273 if (ValidTriangle(FalseBBI, TrueBBI, false, Dups, 1274 Prediction.getCompl()) && 1275 MeetIfcvtSizeLimit(*FalseBBI.BB, 1276 FalseBBI.NonPredSize + FalseBBI.ExtraCost, 1277 FalseBBI.ExtraCost2, Prediction.getCompl()) && 1278 FeasibilityAnalysis(FalseBBI, RevCond, true)) { 1279 Tokens.push_back(llvm::make_unique<IfcvtToken>(BBI, ICTriangleFalse, 1280 FNeedSub, Dups)); 1281 Enqueued = true; 1282 } 1283 1284 if (ValidTriangle(FalseBBI, TrueBBI, true, Dups, 1285 Prediction.getCompl()) && 1286 MeetIfcvtSizeLimit(*FalseBBI.BB, 1287 FalseBBI.NonPredSize + FalseBBI.ExtraCost, 1288 FalseBBI.ExtraCost2, Prediction.getCompl()) && 1289 FeasibilityAnalysis(FalseBBI, RevCond, true, true)) { 1290 Tokens.push_back( 1291 llvm::make_unique<IfcvtToken>(BBI, ICTriangleFRev, FNeedSub, Dups)); 1292 Enqueued = true; 1293 } 1294 1295 if (ValidSimple(FalseBBI, Dups, Prediction.getCompl()) && 1296 MeetIfcvtSizeLimit(*FalseBBI.BB, 1297 FalseBBI.NonPredSize + FalseBBI.ExtraCost, 1298 FalseBBI.ExtraCost2, Prediction.getCompl()) && 1299 FeasibilityAnalysis(FalseBBI, RevCond)) { 1300 Tokens.push_back( 1301 llvm::make_unique<IfcvtToken>(BBI, ICSimpleFalse, FNeedSub, Dups)); 1302 Enqueued = true; 1303 } 1304 } 1305 1306 BBI.IsEnqueued = Enqueued; 1307 BBI.IsBeingAnalyzed = false; 1308 BBI.IsAnalyzed = true; 1309 BBStack.pop_back(); 1310 } 1311 } 1312 1313 /// Analyze all blocks and find entries for all if-conversion candidates. 1314 void IfConverter::AnalyzeBlocks( 1315 MachineFunction &MF, std::vector<std::unique_ptr<IfcvtToken>> &Tokens) { 1316 for (MachineBasicBlock &MBB : MF) 1317 AnalyzeBlock(MBB, Tokens); 1318 1319 // Sort to favor more complex ifcvt scheme. 1320 std::stable_sort(Tokens.begin(), Tokens.end(), IfcvtTokenCmp); 1321 } 1322 1323 /// Returns true either if ToMBB is the next block after MBB or that all the 1324 /// intervening blocks are empty (given MBB can fall through to its next block). 1325 static bool canFallThroughTo(MachineBasicBlock &MBB, MachineBasicBlock &ToMBB) { 1326 MachineFunction::iterator PI = MBB.getIterator(); 1327 MachineFunction::iterator I = std::next(PI); 1328 MachineFunction::iterator TI = ToMBB.getIterator(); 1329 MachineFunction::iterator E = MBB.getParent()->end(); 1330 while (I != TI) { 1331 // Check isSuccessor to avoid case where the next block is empty, but 1332 // it's not a successor. 1333 if (I == E || !I->empty() || !PI->isSuccessor(&*I)) 1334 return false; 1335 PI = I++; 1336 } 1337 // Finally see if the last I is indeed a successor to PI. 1338 return PI->isSuccessor(&*I); 1339 } 1340 1341 /// Invalidate predecessor BB info so it would be re-analyzed to determine if it 1342 /// can be if-converted. If predecessor is already enqueued, dequeue it! 1343 void IfConverter::InvalidatePreds(MachineBasicBlock &MBB) { 1344 for (const MachineBasicBlock *Predecessor : MBB.predecessors()) { 1345 BBInfo &PBBI = BBAnalysis[Predecessor->getNumber()]; 1346 if (PBBI.IsDone || PBBI.BB == &MBB) 1347 continue; 1348 PBBI.IsAnalyzed = false; 1349 PBBI.IsEnqueued = false; 1350 } 1351 } 1352 1353 /// Inserts an unconditional branch from \p MBB to \p ToMBB. 1354 static void InsertUncondBranch(MachineBasicBlock &MBB, MachineBasicBlock &ToMBB, 1355 const TargetInstrInfo *TII) { 1356 DebugLoc dl; // FIXME: this is nowhere 1357 SmallVector<MachineOperand, 0> NoCond; 1358 TII->insertBranch(MBB, &ToMBB, nullptr, NoCond, dl); 1359 } 1360 1361 /// Behaves like LiveRegUnits::StepForward() but also adds implicit uses to all 1362 /// values defined in MI which are also live/used by MI. 1363 static void UpdatePredRedefs(MachineInstr &MI, LivePhysRegs &Redefs) { 1364 const TargetRegisterInfo *TRI = MI.getMF()->getSubtarget().getRegisterInfo(); 1365 1366 // Before stepping forward past MI, remember which regs were live 1367 // before MI. This is needed to set the Undef flag only when reg is 1368 // dead. 1369 SparseSet<unsigned> LiveBeforeMI; 1370 LiveBeforeMI.setUniverse(TRI->getNumRegs()); 1371 for (unsigned Reg : Redefs) 1372 LiveBeforeMI.insert(Reg); 1373 1374 SmallVector<std::pair<unsigned, const MachineOperand*>, 4> Clobbers; 1375 Redefs.stepForward(MI, Clobbers); 1376 1377 // Now add the implicit uses for each of the clobbered values. 1378 for (auto Clobber : Clobbers) { 1379 // FIXME: Const cast here is nasty, but better than making StepForward 1380 // take a mutable instruction instead of const. 1381 unsigned Reg = Clobber.first; 1382 MachineOperand &Op = const_cast<MachineOperand&>(*Clobber.second); 1383 MachineInstr *OpMI = Op.getParent(); 1384 MachineInstrBuilder MIB(*OpMI->getMF(), OpMI); 1385 if (Op.isRegMask()) { 1386 // First handle regmasks. They clobber any entries in the mask which 1387 // means that we need a def for those registers. 1388 if (LiveBeforeMI.count(Reg)) 1389 MIB.addReg(Reg, RegState::Implicit); 1390 1391 // We also need to add an implicit def of this register for the later 1392 // use to read from. 1393 // For the register allocator to have allocated a register clobbered 1394 // by the call which is used later, it must be the case that 1395 // the call doesn't return. 1396 MIB.addReg(Reg, RegState::Implicit | RegState::Define); 1397 continue; 1398 } 1399 if (LiveBeforeMI.count(Reg)) 1400 MIB.addReg(Reg, RegState::Implicit); 1401 else { 1402 bool HasLiveSubReg = false; 1403 for (MCSubRegIterator S(Reg, TRI); S.isValid(); ++S) { 1404 if (!LiveBeforeMI.count(*S)) 1405 continue; 1406 HasLiveSubReg = true; 1407 break; 1408 } 1409 if (HasLiveSubReg) 1410 MIB.addReg(Reg, RegState::Implicit); 1411 } 1412 } 1413 } 1414 1415 /// If convert a simple (split, no rejoin) sub-CFG. 1416 bool IfConverter::IfConvertSimple(BBInfo &BBI, IfcvtKind Kind) { 1417 BBInfo &TrueBBI = BBAnalysis[BBI.TrueBB->getNumber()]; 1418 BBInfo &FalseBBI = BBAnalysis[BBI.FalseBB->getNumber()]; 1419 BBInfo *CvtBBI = &TrueBBI; 1420 BBInfo *NextBBI = &FalseBBI; 1421 1422 SmallVector<MachineOperand, 4> Cond(BBI.BrCond.begin(), BBI.BrCond.end()); 1423 if (Kind == ICSimpleFalse) 1424 std::swap(CvtBBI, NextBBI); 1425 1426 MachineBasicBlock &CvtMBB = *CvtBBI->BB; 1427 MachineBasicBlock &NextMBB = *NextBBI->BB; 1428 if (CvtBBI->IsDone || 1429 (CvtBBI->CannotBeCopied && CvtMBB.pred_size() > 1)) { 1430 // Something has changed. It's no longer safe to predicate this block. 1431 BBI.IsAnalyzed = false; 1432 CvtBBI->IsAnalyzed = false; 1433 return false; 1434 } 1435 1436 if (CvtMBB.hasAddressTaken()) 1437 // Conservatively abort if-conversion if BB's address is taken. 1438 return false; 1439 1440 if (Kind == ICSimpleFalse) 1441 if (TII->reverseBranchCondition(Cond)) 1442 llvm_unreachable("Unable to reverse branch condition!"); 1443 1444 Redefs.init(*TRI); 1445 1446 if (MRI->tracksLiveness()) { 1447 // Initialize liveins to the first BB. These are potentiall redefined by 1448 // predicated instructions. 1449 Redefs.addLiveIns(CvtMBB); 1450 Redefs.addLiveIns(NextMBB); 1451 } 1452 1453 // Remove the branches from the entry so we can add the contents of the true 1454 // block to it. 1455 BBI.NonPredSize -= TII->removeBranch(*BBI.BB); 1456 1457 if (CvtMBB.pred_size() > 1) { 1458 // Copy instructions in the true block, predicate them, and add them to 1459 // the entry block. 1460 CopyAndPredicateBlock(BBI, *CvtBBI, Cond); 1461 1462 // Keep the CFG updated. 1463 BBI.BB->removeSuccessor(&CvtMBB, true); 1464 } else { 1465 // Predicate the instructions in the true block. 1466 PredicateBlock(*CvtBBI, CvtMBB.end(), Cond); 1467 1468 // Merge converted block into entry block. The BB to Cvt edge is removed 1469 // by MergeBlocks. 1470 MergeBlocks(BBI, *CvtBBI); 1471 } 1472 1473 bool IterIfcvt = true; 1474 if (!canFallThroughTo(*BBI.BB, NextMBB)) { 1475 InsertUncondBranch(*BBI.BB, NextMBB, TII); 1476 BBI.HasFallThrough = false; 1477 // Now ifcvt'd block will look like this: 1478 // BB: 1479 // ... 1480 // t, f = cmp 1481 // if t op 1482 // b BBf 1483 // 1484 // We cannot further ifcvt this block because the unconditional branch 1485 // will have to be predicated on the new condition, that will not be 1486 // available if cmp executes. 1487 IterIfcvt = false; 1488 } 1489 1490 // Update block info. BB can be iteratively if-converted. 1491 if (!IterIfcvt) 1492 BBI.IsDone = true; 1493 InvalidatePreds(*BBI.BB); 1494 CvtBBI->IsDone = true; 1495 1496 // FIXME: Must maintain LiveIns. 1497 return true; 1498 } 1499 1500 /// If convert a triangle sub-CFG. 1501 bool IfConverter::IfConvertTriangle(BBInfo &BBI, IfcvtKind Kind) { 1502 BBInfo &TrueBBI = BBAnalysis[BBI.TrueBB->getNumber()]; 1503 BBInfo &FalseBBI = BBAnalysis[BBI.FalseBB->getNumber()]; 1504 BBInfo *CvtBBI = &TrueBBI; 1505 BBInfo *NextBBI = &FalseBBI; 1506 DebugLoc dl; // FIXME: this is nowhere 1507 1508 SmallVector<MachineOperand, 4> Cond(BBI.BrCond.begin(), BBI.BrCond.end()); 1509 if (Kind == ICTriangleFalse || Kind == ICTriangleFRev) 1510 std::swap(CvtBBI, NextBBI); 1511 1512 MachineBasicBlock &CvtMBB = *CvtBBI->BB; 1513 MachineBasicBlock &NextMBB = *NextBBI->BB; 1514 if (CvtBBI->IsDone || 1515 (CvtBBI->CannotBeCopied && CvtMBB.pred_size() > 1)) { 1516 // Something has changed. It's no longer safe to predicate this block. 1517 BBI.IsAnalyzed = false; 1518 CvtBBI->IsAnalyzed = false; 1519 return false; 1520 } 1521 1522 if (CvtMBB.hasAddressTaken()) 1523 // Conservatively abort if-conversion if BB's address is taken. 1524 return false; 1525 1526 if (Kind == ICTriangleFalse || Kind == ICTriangleFRev) 1527 if (TII->reverseBranchCondition(Cond)) 1528 llvm_unreachable("Unable to reverse branch condition!"); 1529 1530 if (Kind == ICTriangleRev || Kind == ICTriangleFRev) { 1531 if (reverseBranchCondition(*CvtBBI)) { 1532 // BB has been changed, modify its predecessors (except for this 1533 // one) so they don't get ifcvt'ed based on bad intel. 1534 for (MachineBasicBlock *PBB : CvtMBB.predecessors()) { 1535 if (PBB == BBI.BB) 1536 continue; 1537 BBInfo &PBBI = BBAnalysis[PBB->getNumber()]; 1538 if (PBBI.IsEnqueued) { 1539 PBBI.IsAnalyzed = false; 1540 PBBI.IsEnqueued = false; 1541 } 1542 } 1543 } 1544 } 1545 1546 // Initialize liveins to the first BB. These are potentially redefined by 1547 // predicated instructions. 1548 Redefs.init(*TRI); 1549 if (MRI->tracksLiveness()) { 1550 Redefs.addLiveIns(CvtMBB); 1551 Redefs.addLiveIns(NextMBB); 1552 } 1553 1554 bool HasEarlyExit = CvtBBI->FalseBB != nullptr; 1555 BranchProbability CvtNext, CvtFalse, BBNext, BBCvt; 1556 1557 if (HasEarlyExit) { 1558 // Get probabilities before modifying CvtMBB and BBI.BB. 1559 CvtNext = MBPI->getEdgeProbability(&CvtMBB, &NextMBB); 1560 CvtFalse = MBPI->getEdgeProbability(&CvtMBB, CvtBBI->FalseBB); 1561 BBNext = MBPI->getEdgeProbability(BBI.BB, &NextMBB); 1562 BBCvt = MBPI->getEdgeProbability(BBI.BB, &CvtMBB); 1563 } 1564 1565 // Remove the branches from the entry so we can add the contents of the true 1566 // block to it. 1567 BBI.NonPredSize -= TII->removeBranch(*BBI.BB); 1568 1569 if (CvtMBB.pred_size() > 1) { 1570 // Copy instructions in the true block, predicate them, and add them to 1571 // the entry block. 1572 CopyAndPredicateBlock(BBI, *CvtBBI, Cond, true); 1573 } else { 1574 // Predicate the 'true' block after removing its branch. 1575 CvtBBI->NonPredSize -= TII->removeBranch(CvtMBB); 1576 PredicateBlock(*CvtBBI, CvtMBB.end(), Cond); 1577 1578 // Now merge the entry of the triangle with the true block. 1579 MergeBlocks(BBI, *CvtBBI, false); 1580 } 1581 1582 // Keep the CFG updated. 1583 BBI.BB->removeSuccessor(&CvtMBB, true); 1584 1585 // If 'true' block has a 'false' successor, add an exit branch to it. 1586 if (HasEarlyExit) { 1587 SmallVector<MachineOperand, 4> RevCond(CvtBBI->BrCond.begin(), 1588 CvtBBI->BrCond.end()); 1589 if (TII->reverseBranchCondition(RevCond)) 1590 llvm_unreachable("Unable to reverse branch condition!"); 1591 1592 // Update the edge probability for both CvtBBI->FalseBB and NextBBI. 1593 // NewNext = New_Prob(BBI.BB, NextMBB) = 1594 // Prob(BBI.BB, NextMBB) + 1595 // Prob(BBI.BB, CvtMBB) * Prob(CvtMBB, NextMBB) 1596 // NewFalse = New_Prob(BBI.BB, CvtBBI->FalseBB) = 1597 // Prob(BBI.BB, CvtMBB) * Prob(CvtMBB, CvtBBI->FalseBB) 1598 auto NewTrueBB = getNextBlock(*BBI.BB); 1599 auto NewNext = BBNext + BBCvt * CvtNext; 1600 auto NewTrueBBIter = find(BBI.BB->successors(), NewTrueBB); 1601 if (NewTrueBBIter != BBI.BB->succ_end()) 1602 BBI.BB->setSuccProbability(NewTrueBBIter, NewNext); 1603 1604 auto NewFalse = BBCvt * CvtFalse; 1605 TII->insertBranch(*BBI.BB, CvtBBI->FalseBB, nullptr, RevCond, dl); 1606 BBI.BB->addSuccessor(CvtBBI->FalseBB, NewFalse); 1607 } 1608 1609 // Merge in the 'false' block if the 'false' block has no other 1610 // predecessors. Otherwise, add an unconditional branch to 'false'. 1611 bool FalseBBDead = false; 1612 bool IterIfcvt = true; 1613 bool isFallThrough = canFallThroughTo(*BBI.BB, NextMBB); 1614 if (!isFallThrough) { 1615 // Only merge them if the true block does not fallthrough to the false 1616 // block. By not merging them, we make it possible to iteratively 1617 // ifcvt the blocks. 1618 if (!HasEarlyExit && 1619 NextMBB.pred_size() == 1 && !NextBBI->HasFallThrough && 1620 !NextMBB.hasAddressTaken()) { 1621 MergeBlocks(BBI, *NextBBI); 1622 FalseBBDead = true; 1623 } else { 1624 InsertUncondBranch(*BBI.BB, NextMBB, TII); 1625 BBI.HasFallThrough = false; 1626 } 1627 // Mixed predicated and unpredicated code. This cannot be iteratively 1628 // predicated. 1629 IterIfcvt = false; 1630 } 1631 1632 // Update block info. BB can be iteratively if-converted. 1633 if (!IterIfcvt) 1634 BBI.IsDone = true; 1635 InvalidatePreds(*BBI.BB); 1636 CvtBBI->IsDone = true; 1637 if (FalseBBDead) 1638 NextBBI->IsDone = true; 1639 1640 // FIXME: Must maintain LiveIns. 1641 return true; 1642 } 1643 1644 /// Common code shared between diamond conversions. 1645 /// \p BBI, \p TrueBBI, and \p FalseBBI form the diamond shape. 1646 /// \p NumDups1 - number of shared instructions at the beginning of \p TrueBBI 1647 /// and FalseBBI 1648 /// \p NumDups2 - number of shared instructions at the end of \p TrueBBI 1649 /// and \p FalseBBI 1650 /// \p RemoveBranch - Remove the common branch of the two blocks before 1651 /// predicating. Only false for unanalyzable fallthrough 1652 /// cases. The caller will replace the branch if necessary. 1653 /// \p MergeAddEdges - Add successor edges when merging blocks. Only false for 1654 /// unanalyzable fallthrough 1655 bool IfConverter::IfConvertDiamondCommon( 1656 BBInfo &BBI, BBInfo &TrueBBI, BBInfo &FalseBBI, 1657 unsigned NumDups1, unsigned NumDups2, 1658 bool TClobbersPred, bool FClobbersPred, 1659 bool RemoveBranch, bool MergeAddEdges) { 1660 1661 if (TrueBBI.IsDone || FalseBBI.IsDone || 1662 TrueBBI.BB->pred_size() > 1 || FalseBBI.BB->pred_size() > 1) { 1663 // Something has changed. It's no longer safe to predicate these blocks. 1664 BBI.IsAnalyzed = false; 1665 TrueBBI.IsAnalyzed = false; 1666 FalseBBI.IsAnalyzed = false; 1667 return false; 1668 } 1669 1670 if (TrueBBI.BB->hasAddressTaken() || FalseBBI.BB->hasAddressTaken()) 1671 // Conservatively abort if-conversion if either BB has its address taken. 1672 return false; 1673 1674 // Put the predicated instructions from the 'true' block before the 1675 // instructions from the 'false' block, unless the true block would clobber 1676 // the predicate, in which case, do the opposite. 1677 BBInfo *BBI1 = &TrueBBI; 1678 BBInfo *BBI2 = &FalseBBI; 1679 SmallVector<MachineOperand, 4> RevCond(BBI.BrCond.begin(), BBI.BrCond.end()); 1680 if (TII->reverseBranchCondition(RevCond)) 1681 llvm_unreachable("Unable to reverse branch condition!"); 1682 SmallVector<MachineOperand, 4> *Cond1 = &BBI.BrCond; 1683 SmallVector<MachineOperand, 4> *Cond2 = &RevCond; 1684 1685 // Figure out the more profitable ordering. 1686 bool DoSwap = false; 1687 if (TClobbersPred && !FClobbersPred) 1688 DoSwap = true; 1689 else if (!TClobbersPred && !FClobbersPred) { 1690 if (TrueBBI.NonPredSize > FalseBBI.NonPredSize) 1691 DoSwap = true; 1692 } else if (TClobbersPred && FClobbersPred) 1693 llvm_unreachable("Predicate info cannot be clobbered by both sides."); 1694 if (DoSwap) { 1695 std::swap(BBI1, BBI2); 1696 std::swap(Cond1, Cond2); 1697 } 1698 1699 // Remove the conditional branch from entry to the blocks. 1700 BBI.NonPredSize -= TII->removeBranch(*BBI.BB); 1701 1702 MachineBasicBlock &MBB1 = *BBI1->BB; 1703 MachineBasicBlock &MBB2 = *BBI2->BB; 1704 1705 // Initialize the Redefs: 1706 // - BB2 live-in regs need implicit uses before being redefined by BB1 1707 // instructions. 1708 // - BB1 live-out regs need implicit uses before being redefined by BB2 1709 // instructions. We start with BB1 live-ins so we have the live-out regs 1710 // after tracking the BB1 instructions. 1711 Redefs.init(*TRI); 1712 if (MRI->tracksLiveness()) { 1713 Redefs.addLiveIns(MBB1); 1714 Redefs.addLiveIns(MBB2); 1715 } 1716 1717 // Remove the duplicated instructions at the beginnings of both paths. 1718 // Skip dbg_value instructions. 1719 MachineBasicBlock::iterator DI1 = MBB1.getFirstNonDebugInstr(); 1720 MachineBasicBlock::iterator DI2 = MBB2.getFirstNonDebugInstr(); 1721 BBI1->NonPredSize -= NumDups1; 1722 BBI2->NonPredSize -= NumDups1; 1723 1724 // Skip past the dups on each side separately since there may be 1725 // differing dbg_value entries. NumDups1 can include a "return" 1726 // instruction, if it's not marked as "branch". 1727 for (unsigned i = 0; i < NumDups1; ++DI1) { 1728 if (DI1 == MBB1.end()) 1729 break; 1730 if (!DI1->isDebugInstr()) 1731 ++i; 1732 } 1733 while (NumDups1 != 0) { 1734 ++DI2; 1735 if (DI2 == MBB2.end()) 1736 break; 1737 if (!DI2->isDebugInstr()) 1738 --NumDups1; 1739 } 1740 1741 if (MRI->tracksLiveness()) { 1742 for (const MachineInstr &MI : make_range(MBB1.begin(), DI1)) { 1743 SmallVector<std::pair<unsigned, const MachineOperand*>, 4> Dummy; 1744 Redefs.stepForward(MI, Dummy); 1745 } 1746 } 1747 1748 BBI.BB->splice(BBI.BB->end(), &MBB1, MBB1.begin(), DI1); 1749 MBB2.erase(MBB2.begin(), DI2); 1750 1751 // The branches have been checked to match, so it is safe to remove the 1752 // branch in BB1 and rely on the copy in BB2. The complication is that 1753 // the blocks may end with a return instruction, which may or may not 1754 // be marked as "branch". If it's not, then it could be included in 1755 // "dups1", leaving the blocks potentially empty after moving the common 1756 // duplicates. 1757 #ifndef NDEBUG 1758 // Unanalyzable branches must match exactly. Check that now. 1759 if (!BBI1->IsBrAnalyzable) 1760 verifySameBranchInstructions(&MBB1, &MBB2); 1761 #endif 1762 BBI1->NonPredSize -= TII->removeBranch(*BBI1->BB); 1763 // Remove duplicated instructions. 1764 DI1 = MBB1.end(); 1765 for (unsigned i = 0; i != NumDups2; ) { 1766 // NumDups2 only counted non-dbg_value instructions, so this won't 1767 // run off the head of the list. 1768 assert(DI1 != MBB1.begin()); 1769 --DI1; 1770 // skip dbg_value instructions 1771 if (!DI1->isDebugInstr()) 1772 ++i; 1773 } 1774 MBB1.erase(DI1, MBB1.end()); 1775 1776 DI2 = BBI2->BB->end(); 1777 // The branches have been checked to match. Skip over the branch in the false 1778 // block so that we don't try to predicate it. 1779 if (RemoveBranch) 1780 BBI2->NonPredSize -= TII->removeBranch(*BBI2->BB); 1781 else { 1782 // Make DI2 point to the end of the range where the common "tail" 1783 // instructions could be found. 1784 while (DI2 != MBB2.begin()) { 1785 MachineBasicBlock::iterator Prev = std::prev(DI2); 1786 if (!Prev->isBranch() && !Prev->isDebugInstr()) 1787 break; 1788 DI2 = Prev; 1789 } 1790 } 1791 while (NumDups2 != 0) { 1792 // NumDups2 only counted non-dbg_value instructions, so this won't 1793 // run off the head of the list. 1794 assert(DI2 != MBB2.begin()); 1795 --DI2; 1796 // skip dbg_value instructions 1797 if (!DI2->isDebugInstr()) 1798 --NumDups2; 1799 } 1800 1801 // Remember which registers would later be defined by the false block. 1802 // This allows us not to predicate instructions in the true block that would 1803 // later be re-defined. That is, rather than 1804 // subeq r0, r1, #1 1805 // addne r0, r1, #1 1806 // generate: 1807 // sub r0, r1, #1 1808 // addne r0, r1, #1 1809 SmallSet<unsigned, 4> RedefsByFalse; 1810 SmallSet<unsigned, 4> ExtUses; 1811 if (TII->isProfitableToUnpredicate(MBB1, MBB2)) { 1812 for (const MachineInstr &FI : make_range(MBB2.begin(), DI2)) { 1813 if (FI.isDebugInstr()) 1814 continue; 1815 SmallVector<unsigned, 4> Defs; 1816 for (const MachineOperand &MO : FI.operands()) { 1817 if (!MO.isReg()) 1818 continue; 1819 unsigned Reg = MO.getReg(); 1820 if (!Reg) 1821 continue; 1822 if (MO.isDef()) { 1823 Defs.push_back(Reg); 1824 } else if (!RedefsByFalse.count(Reg)) { 1825 // These are defined before ctrl flow reach the 'false' instructions. 1826 // They cannot be modified by the 'true' instructions. 1827 for (MCSubRegIterator SubRegs(Reg, TRI, /*IncludeSelf=*/true); 1828 SubRegs.isValid(); ++SubRegs) 1829 ExtUses.insert(*SubRegs); 1830 } 1831 } 1832 1833 for (unsigned Reg : Defs) { 1834 if (!ExtUses.count(Reg)) { 1835 for (MCSubRegIterator SubRegs(Reg, TRI, /*IncludeSelf=*/true); 1836 SubRegs.isValid(); ++SubRegs) 1837 RedefsByFalse.insert(*SubRegs); 1838 } 1839 } 1840 } 1841 } 1842 1843 // Predicate the 'true' block. 1844 PredicateBlock(*BBI1, MBB1.end(), *Cond1, &RedefsByFalse); 1845 1846 // After predicating BBI1, if there is a predicated terminator in BBI1 and 1847 // a non-predicated in BBI2, then we don't want to predicate the one from 1848 // BBI2. The reason is that if we merged these blocks, we would end up with 1849 // two predicated terminators in the same block. 1850 // Also, if the branches in MBB1 and MBB2 were non-analyzable, then don't 1851 // predicate them either. They were checked to be identical, and so the 1852 // same branch would happen regardless of which path was taken. 1853 if (!MBB2.empty() && (DI2 == MBB2.end())) { 1854 MachineBasicBlock::iterator BBI1T = MBB1.getFirstTerminator(); 1855 MachineBasicBlock::iterator BBI2T = MBB2.getFirstTerminator(); 1856 bool BB1Predicated = BBI1T != MBB1.end() && TII->isPredicated(*BBI1T); 1857 bool BB2NonPredicated = BBI2T != MBB2.end() && !TII->isPredicated(*BBI2T); 1858 if (BB2NonPredicated && (BB1Predicated || !BBI2->IsBrAnalyzable)) 1859 --DI2; 1860 } 1861 1862 // Predicate the 'false' block. 1863 PredicateBlock(*BBI2, DI2, *Cond2); 1864 1865 // Merge the true block into the entry of the diamond. 1866 MergeBlocks(BBI, *BBI1, MergeAddEdges); 1867 MergeBlocks(BBI, *BBI2, MergeAddEdges); 1868 return true; 1869 } 1870 1871 /// If convert an almost-diamond sub-CFG where the true 1872 /// and false blocks share a common tail. 1873 bool IfConverter::IfConvertForkedDiamond( 1874 BBInfo &BBI, IfcvtKind Kind, 1875 unsigned NumDups1, unsigned NumDups2, 1876 bool TClobbersPred, bool FClobbersPred) { 1877 BBInfo &TrueBBI = BBAnalysis[BBI.TrueBB->getNumber()]; 1878 BBInfo &FalseBBI = BBAnalysis[BBI.FalseBB->getNumber()]; 1879 1880 // Save the debug location for later. 1881 DebugLoc dl; 1882 MachineBasicBlock::iterator TIE = TrueBBI.BB->getFirstTerminator(); 1883 if (TIE != TrueBBI.BB->end()) 1884 dl = TIE->getDebugLoc(); 1885 // Removing branches from both blocks is safe, because we have already 1886 // determined that both blocks have the same branch instructions. The branch 1887 // will be added back at the end, unpredicated. 1888 if (!IfConvertDiamondCommon( 1889 BBI, TrueBBI, FalseBBI, 1890 NumDups1, NumDups2, 1891 TClobbersPred, FClobbersPred, 1892 /* RemoveBranch */ true, /* MergeAddEdges */ true)) 1893 return false; 1894 1895 // Add back the branch. 1896 // Debug location saved above when removing the branch from BBI2 1897 TII->insertBranch(*BBI.BB, TrueBBI.TrueBB, TrueBBI.FalseBB, 1898 TrueBBI.BrCond, dl); 1899 1900 // Update block info. 1901 BBI.IsDone = TrueBBI.IsDone = FalseBBI.IsDone = true; 1902 InvalidatePreds(*BBI.BB); 1903 1904 // FIXME: Must maintain LiveIns. 1905 return true; 1906 } 1907 1908 /// If convert a diamond sub-CFG. 1909 bool IfConverter::IfConvertDiamond(BBInfo &BBI, IfcvtKind Kind, 1910 unsigned NumDups1, unsigned NumDups2, 1911 bool TClobbersPred, bool FClobbersPred) { 1912 BBInfo &TrueBBI = BBAnalysis[BBI.TrueBB->getNumber()]; 1913 BBInfo &FalseBBI = BBAnalysis[BBI.FalseBB->getNumber()]; 1914 MachineBasicBlock *TailBB = TrueBBI.TrueBB; 1915 1916 // True block must fall through or end with an unanalyzable terminator. 1917 if (!TailBB) { 1918 if (blockAlwaysFallThrough(TrueBBI)) 1919 TailBB = FalseBBI.TrueBB; 1920 assert((TailBB || !TrueBBI.IsBrAnalyzable) && "Unexpected!"); 1921 } 1922 1923 if (!IfConvertDiamondCommon( 1924 BBI, TrueBBI, FalseBBI, 1925 NumDups1, NumDups2, 1926 TClobbersPred, FClobbersPred, 1927 /* RemoveBranch */ TrueBBI.IsBrAnalyzable, 1928 /* MergeAddEdges */ TailBB == nullptr)) 1929 return false; 1930 1931 // If the if-converted block falls through or unconditionally branches into 1932 // the tail block, and the tail block does not have other predecessors, then 1933 // fold the tail block in as well. Otherwise, unless it falls through to the 1934 // tail, add a unconditional branch to it. 1935 if (TailBB) { 1936 // We need to remove the edges to the true and false blocks manually since 1937 // we didn't let IfConvertDiamondCommon update the CFG. 1938 BBI.BB->removeSuccessor(TrueBBI.BB); 1939 BBI.BB->removeSuccessor(FalseBBI.BB, true); 1940 1941 BBInfo &TailBBI = BBAnalysis[TailBB->getNumber()]; 1942 bool CanMergeTail = !TailBBI.HasFallThrough && 1943 !TailBBI.BB->hasAddressTaken(); 1944 // The if-converted block can still have a predicated terminator 1945 // (e.g. a predicated return). If that is the case, we cannot merge 1946 // it with the tail block. 1947 MachineBasicBlock::const_iterator TI = BBI.BB->getFirstTerminator(); 1948 if (TI != BBI.BB->end() && TII->isPredicated(*TI)) 1949 CanMergeTail = false; 1950 // There may still be a fall-through edge from BBI1 or BBI2 to TailBB; 1951 // check if there are any other predecessors besides those. 1952 unsigned NumPreds = TailBB->pred_size(); 1953 if (NumPreds > 1) 1954 CanMergeTail = false; 1955 else if (NumPreds == 1 && CanMergeTail) { 1956 MachineBasicBlock::pred_iterator PI = TailBB->pred_begin(); 1957 if (*PI != TrueBBI.BB && *PI != FalseBBI.BB) 1958 CanMergeTail = false; 1959 } 1960 if (CanMergeTail) { 1961 MergeBlocks(BBI, TailBBI); 1962 TailBBI.IsDone = true; 1963 } else { 1964 BBI.BB->addSuccessor(TailBB, BranchProbability::getOne()); 1965 InsertUncondBranch(*BBI.BB, *TailBB, TII); 1966 BBI.HasFallThrough = false; 1967 } 1968 } 1969 1970 // Update block info. 1971 BBI.IsDone = TrueBBI.IsDone = FalseBBI.IsDone = true; 1972 InvalidatePreds(*BBI.BB); 1973 1974 // FIXME: Must maintain LiveIns. 1975 return true; 1976 } 1977 1978 static bool MaySpeculate(const MachineInstr &MI, 1979 SmallSet<unsigned, 4> &LaterRedefs) { 1980 bool SawStore = true; 1981 if (!MI.isSafeToMove(nullptr, SawStore)) 1982 return false; 1983 1984 for (const MachineOperand &MO : MI.operands()) { 1985 if (!MO.isReg()) 1986 continue; 1987 unsigned Reg = MO.getReg(); 1988 if (!Reg) 1989 continue; 1990 if (MO.isDef() && !LaterRedefs.count(Reg)) 1991 return false; 1992 } 1993 1994 return true; 1995 } 1996 1997 /// Predicate instructions from the start of the block to the specified end with 1998 /// the specified condition. 1999 void IfConverter::PredicateBlock(BBInfo &BBI, 2000 MachineBasicBlock::iterator E, 2001 SmallVectorImpl<MachineOperand> &Cond, 2002 SmallSet<unsigned, 4> *LaterRedefs) { 2003 bool AnyUnpred = false; 2004 bool MaySpec = LaterRedefs != nullptr; 2005 for (MachineInstr &I : make_range(BBI.BB->begin(), E)) { 2006 if (I.isDebugInstr() || TII->isPredicated(I)) 2007 continue; 2008 // It may be possible not to predicate an instruction if it's the 'true' 2009 // side of a diamond and the 'false' side may re-define the instruction's 2010 // defs. 2011 if (MaySpec && MaySpeculate(I, *LaterRedefs)) { 2012 AnyUnpred = true; 2013 continue; 2014 } 2015 // If any instruction is predicated, then every instruction after it must 2016 // be predicated. 2017 MaySpec = false; 2018 if (!TII->PredicateInstruction(I, Cond)) { 2019 #ifndef NDEBUG 2020 dbgs() << "Unable to predicate " << I << "!\n"; 2021 #endif 2022 llvm_unreachable(nullptr); 2023 } 2024 2025 // If the predicated instruction now redefines a register as the result of 2026 // if-conversion, add an implicit kill. 2027 UpdatePredRedefs(I, Redefs); 2028 } 2029 2030 BBI.Predicate.append(Cond.begin(), Cond.end()); 2031 2032 BBI.IsAnalyzed = false; 2033 BBI.NonPredSize = 0; 2034 2035 ++NumIfConvBBs; 2036 if (AnyUnpred) 2037 ++NumUnpred; 2038 } 2039 2040 /// Copy and predicate instructions from source BB to the destination block. 2041 /// Skip end of block branches if IgnoreBr is true. 2042 void IfConverter::CopyAndPredicateBlock(BBInfo &ToBBI, BBInfo &FromBBI, 2043 SmallVectorImpl<MachineOperand> &Cond, 2044 bool IgnoreBr) { 2045 MachineFunction &MF = *ToBBI.BB->getParent(); 2046 2047 MachineBasicBlock &FromMBB = *FromBBI.BB; 2048 for (MachineInstr &I : FromMBB) { 2049 // Do not copy the end of the block branches. 2050 if (IgnoreBr && I.isBranch()) 2051 break; 2052 2053 MachineInstr *MI = MF.CloneMachineInstr(&I); 2054 ToBBI.BB->insert(ToBBI.BB->end(), MI); 2055 ToBBI.NonPredSize++; 2056 unsigned ExtraPredCost = TII->getPredicationCost(I); 2057 unsigned NumCycles = SchedModel.computeInstrLatency(&I, false); 2058 if (NumCycles > 1) 2059 ToBBI.ExtraCost += NumCycles-1; 2060 ToBBI.ExtraCost2 += ExtraPredCost; 2061 2062 if (!TII->isPredicated(I) && !MI->isDebugInstr()) { 2063 if (!TII->PredicateInstruction(*MI, Cond)) { 2064 #ifndef NDEBUG 2065 dbgs() << "Unable to predicate " << I << "!\n"; 2066 #endif 2067 llvm_unreachable(nullptr); 2068 } 2069 } 2070 2071 // If the predicated instruction now redefines a register as the result of 2072 // if-conversion, add an implicit kill. 2073 UpdatePredRedefs(*MI, Redefs); 2074 } 2075 2076 if (!IgnoreBr) { 2077 std::vector<MachineBasicBlock *> Succs(FromMBB.succ_begin(), 2078 FromMBB.succ_end()); 2079 MachineBasicBlock *NBB = getNextBlock(FromMBB); 2080 MachineBasicBlock *FallThrough = FromBBI.HasFallThrough ? NBB : nullptr; 2081 2082 for (MachineBasicBlock *Succ : Succs) { 2083 // Fallthrough edge can't be transferred. 2084 if (Succ == FallThrough) 2085 continue; 2086 ToBBI.BB->addSuccessor(Succ); 2087 } 2088 } 2089 2090 ToBBI.Predicate.append(FromBBI.Predicate.begin(), FromBBI.Predicate.end()); 2091 ToBBI.Predicate.append(Cond.begin(), Cond.end()); 2092 2093 ToBBI.ClobbersPred |= FromBBI.ClobbersPred; 2094 ToBBI.IsAnalyzed = false; 2095 2096 ++NumDupBBs; 2097 } 2098 2099 /// Move all instructions from FromBB to the end of ToBB. This will leave 2100 /// FromBB as an empty block, so remove all of its successor edges except for 2101 /// the fall-through edge. If AddEdges is true, i.e., when FromBBI's branch is 2102 /// being moved, add those successor edges to ToBBI and remove the old edge 2103 /// from ToBBI to FromBBI. 2104 void IfConverter::MergeBlocks(BBInfo &ToBBI, BBInfo &FromBBI, bool AddEdges) { 2105 MachineBasicBlock &FromMBB = *FromBBI.BB; 2106 assert(!FromMBB.hasAddressTaken() && 2107 "Removing a BB whose address is taken!"); 2108 2109 // In case FromMBB contains terminators (e.g. return instruction), 2110 // first move the non-terminator instructions, then the terminators. 2111 MachineBasicBlock::iterator FromTI = FromMBB.getFirstTerminator(); 2112 MachineBasicBlock::iterator ToTI = ToBBI.BB->getFirstTerminator(); 2113 ToBBI.BB->splice(ToTI, &FromMBB, FromMBB.begin(), FromTI); 2114 2115 // If FromBB has non-predicated terminator we should copy it at the end. 2116 if (FromTI != FromMBB.end() && !TII->isPredicated(*FromTI)) 2117 ToTI = ToBBI.BB->end(); 2118 ToBBI.BB->splice(ToTI, &FromMBB, FromTI, FromMBB.end()); 2119 2120 // Force normalizing the successors' probabilities of ToBBI.BB to convert all 2121 // unknown probabilities into known ones. 2122 // FIXME: This usage is too tricky and in the future we would like to 2123 // eliminate all unknown probabilities in MBB. 2124 if (ToBBI.IsBrAnalyzable) 2125 ToBBI.BB->normalizeSuccProbs(); 2126 2127 SmallVector<MachineBasicBlock *, 4> FromSuccs(FromMBB.succ_begin(), 2128 FromMBB.succ_end()); 2129 MachineBasicBlock *NBB = getNextBlock(FromMBB); 2130 MachineBasicBlock *FallThrough = FromBBI.HasFallThrough ? NBB : nullptr; 2131 // The edge probability from ToBBI.BB to FromMBB, which is only needed when 2132 // AddEdges is true and FromMBB is a successor of ToBBI.BB. 2133 auto To2FromProb = BranchProbability::getZero(); 2134 if (AddEdges && ToBBI.BB->isSuccessor(&FromMBB)) { 2135 // Remove the old edge but remember the edge probability so we can calculate 2136 // the correct weights on the new edges being added further down. 2137 To2FromProb = MBPI->getEdgeProbability(ToBBI.BB, &FromMBB); 2138 ToBBI.BB->removeSuccessor(&FromMBB); 2139 } 2140 2141 for (MachineBasicBlock *Succ : FromSuccs) { 2142 // Fallthrough edge can't be transferred. 2143 if (Succ == FallThrough) 2144 continue; 2145 2146 auto NewProb = BranchProbability::getZero(); 2147 if (AddEdges) { 2148 // Calculate the edge probability for the edge from ToBBI.BB to Succ, 2149 // which is a portion of the edge probability from FromMBB to Succ. The 2150 // portion ratio is the edge probability from ToBBI.BB to FromMBB (if 2151 // FromBBI is a successor of ToBBI.BB. See comment below for excepion). 2152 NewProb = MBPI->getEdgeProbability(&FromMBB, Succ); 2153 2154 // To2FromProb is 0 when FromMBB is not a successor of ToBBI.BB. This 2155 // only happens when if-converting a diamond CFG and FromMBB is the 2156 // tail BB. In this case FromMBB post-dominates ToBBI.BB and hence we 2157 // could just use the probabilities on FromMBB's out-edges when adding 2158 // new successors. 2159 if (!To2FromProb.isZero()) 2160 NewProb *= To2FromProb; 2161 } 2162 2163 FromMBB.removeSuccessor(Succ); 2164 2165 if (AddEdges) { 2166 // If the edge from ToBBI.BB to Succ already exists, update the 2167 // probability of this edge by adding NewProb to it. An example is shown 2168 // below, in which A is ToBBI.BB and B is FromMBB. In this case we 2169 // don't have to set C as A's successor as it already is. We only need to 2170 // update the edge probability on A->C. Note that B will not be 2171 // immediately removed from A's successors. It is possible that B->D is 2172 // not removed either if D is a fallthrough of B. Later the edge A->D 2173 // (generated here) and B->D will be combined into one edge. To maintain 2174 // correct edge probability of this combined edge, we need to set the edge 2175 // probability of A->B to zero, which is already done above. The edge 2176 // probability on A->D is calculated by scaling the original probability 2177 // on A->B by the probability of B->D. 2178 // 2179 // Before ifcvt: After ifcvt (assume B->D is kept): 2180 // 2181 // A A 2182 // /| /|\ 2183 // / B / B| 2184 // | /| | || 2185 // |/ | | |/ 2186 // C D C D 2187 // 2188 if (ToBBI.BB->isSuccessor(Succ)) 2189 ToBBI.BB->setSuccProbability( 2190 find(ToBBI.BB->successors(), Succ), 2191 MBPI->getEdgeProbability(ToBBI.BB, Succ) + NewProb); 2192 else 2193 ToBBI.BB->addSuccessor(Succ, NewProb); 2194 } 2195 } 2196 2197 // Move the now empty FromMBB out of the way to the end of the function so 2198 // it doesn't interfere with fallthrough checks done by canFallThroughTo(). 2199 MachineBasicBlock *Last = &*FromMBB.getParent()->rbegin(); 2200 if (Last != &FromMBB) 2201 FromMBB.moveAfter(Last); 2202 2203 // Normalize the probabilities of ToBBI.BB's successors with all adjustment 2204 // we've done above. 2205 if (ToBBI.IsBrAnalyzable && FromBBI.IsBrAnalyzable) 2206 ToBBI.BB->normalizeSuccProbs(); 2207 2208 ToBBI.Predicate.append(FromBBI.Predicate.begin(), FromBBI.Predicate.end()); 2209 FromBBI.Predicate.clear(); 2210 2211 ToBBI.NonPredSize += FromBBI.NonPredSize; 2212 ToBBI.ExtraCost += FromBBI.ExtraCost; 2213 ToBBI.ExtraCost2 += FromBBI.ExtraCost2; 2214 FromBBI.NonPredSize = 0; 2215 FromBBI.ExtraCost = 0; 2216 FromBBI.ExtraCost2 = 0; 2217 2218 ToBBI.ClobbersPred |= FromBBI.ClobbersPred; 2219 ToBBI.HasFallThrough = FromBBI.HasFallThrough; 2220 ToBBI.IsAnalyzed = false; 2221 FromBBI.IsAnalyzed = false; 2222 } 2223 2224 FunctionPass * 2225 llvm::createIfConverter(std::function<bool(const MachineFunction &)> Ftor) { 2226 return new IfConverter(std::move(Ftor)); 2227 } 2228