contrib/llvm-project/llvm/lib/CodeGen/BranchFolding.cpp

   1 //===- BranchFolding.cpp - Fold machine code branch instructions ----------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This pass forwards branches to unconditional branches to make them branch
  10 // directly to the target block.  This pass often results in dead MBB's, which
  11 // it then removes.
  12 //
  13 // Note that this pass must be run after register allocation, it cannot handle
  14 // SSA form. It also must handle virtual registers for targets that emit virtual
  15 // ISA (e.g. NVPTX).
  16 //
  17 //===----------------------------------------------------------------------===//
  18
  19 #include "BranchFolding.h"
  20 #include "llvm/ADT/BitVector.h"
  21 #include "llvm/ADT/DenseMap.h"
  22 #include "llvm/ADT/STLExtras.h"
  23 #include "llvm/ADT/SmallPtrSet.h"
  24 #include "llvm/ADT/SmallSet.h"
  25 #include "llvm/ADT/SmallVector.h"
  26 #include "llvm/ADT/Statistic.h"
  27 #include "llvm/Analysis/ProfileSummaryInfo.h"
  28 #include "llvm/CodeGen/Analysis.h"
  29 #include "llvm/CodeGen/LivePhysRegs.h"
  30 #include "llvm/CodeGen/MachineBasicBlock.h"
  31 #include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
  32 #include "llvm/CodeGen/MachineBranchProbabilityInfo.h"
  33 #include "llvm/CodeGen/MachineFunction.h"
  34 #include "llvm/CodeGen/MachineFunctionPass.h"
  35 #include "llvm/CodeGen/MachineInstr.h"
  36 #include "llvm/CodeGen/MachineInstrBuilder.h"
  37 #include "llvm/CodeGen/MachineJumpTableInfo.h"
  38 #include "llvm/CodeGen/MachineLoopInfo.h"
  39 #include "llvm/CodeGen/MachineModuleInfo.h"
  40 #include "llvm/CodeGen/MachineOperand.h"
  41 #include "llvm/CodeGen/MachineRegisterInfo.h"
  42 #include "llvm/CodeGen/MachineSizeOpts.h"
  43 #include "llvm/CodeGen/TargetInstrInfo.h"
  44 #include "llvm/CodeGen/TargetOpcodes.h"
  45 #include "llvm/CodeGen/TargetPassConfig.h"
  46 #include "llvm/CodeGen/TargetRegisterInfo.h"
  47 #include "llvm/CodeGen/TargetSubtargetInfo.h"
  48 #include "llvm/IR/DebugInfoMetadata.h"
  49 #include "llvm/IR/DebugLoc.h"
  50 #include "llvm/IR/Function.h"
  51 #include "llvm/InitializePasses.h"
  52 #include "llvm/MC/LaneBitmask.h"
  53 #include "llvm/MC/MCRegisterInfo.h"
  54 #include "llvm/Pass.h"
  55 #include "llvm/Support/BlockFrequency.h"
  56 #include "llvm/Support/BranchProbability.h"
  57 #include "llvm/Support/CommandLine.h"
  58 #include "llvm/Support/Debug.h"
  59 #include "llvm/Support/ErrorHandling.h"
  60 #include "llvm/Support/raw_ostream.h"
  61 #include "llvm/Target/TargetMachine.h"
  62 #include <cassert>
  63 #include <cstddef>
  64 #include <iterator>
  65 #include <numeric>
  66 #include <vector>
  67
  68 using namespace llvm;
  69
  70 #define DEBUG_TYPE "branch-folder"
  71
  72 STATISTIC(NumDeadBlocks, "Number of dead blocks removed");
  73 STATISTIC(NumBranchOpts, "Number of branches optimized");
  74 STATISTIC(NumTailMerge , "Number of block tails merged");
  75 STATISTIC(NumHoist     , "Number of times common instructions are hoisted");
  76 STATISTIC(NumTailCalls,  "Number of tail calls optimized");
  77
  78 static cl::opt<cl::boolOrDefault> FlagEnableTailMerge("enable-tail-merge",
  79                               cl::init(cl::BOU_UNSET), cl::Hidden);
  80
  81 // Throttle for huge numbers of predecessors (compile speed problems)
  82 static cl::opt<unsigned>
  83 TailMergeThreshold("tail-merge-threshold",
  84           cl::desc("Max number of predecessors to consider tail merging"),
  85           cl::init(150), cl::Hidden);
  86
  87 // Heuristic for tail merging (and, inversely, tail duplication).
  88 // TODO: This should be replaced with a target query.
  89 static cl::opt<unsigned>
  90 TailMergeSize("tail-merge-size",
  91               cl::desc("Min number of instructions to consider tail merging"),
  92               cl::init(3), cl::Hidden);
  93
  94 namespace {
  95
  96   /// BranchFolderPass - Wrap branch folder in a machine function pass.
  97   class BranchFolderPass : public MachineFunctionPass {
  98   public:
  99     static char ID;
 100
 101     explicit BranchFolderPass(): MachineFunctionPass(ID) {}
 102
 103     bool runOnMachineFunction(MachineFunction &MF) override;
 104
 105     void getAnalysisUsage(AnalysisUsage &AU) const override {
 106       AU.addRequired<MachineBlockFrequencyInfo>();
 107       AU.addRequired<MachineBranchProbabilityInfo>();
 108       AU.addRequired<ProfileSummaryInfoWrapperPass>();
 109       AU.addRequired<TargetPassConfig>();
 110       MachineFunctionPass::getAnalysisUsage(AU);
 111     }
 112   };
 113
 114 } // end anonymous namespace
 115
 116 char BranchFolderPass::ID = 0;
 117
 118 char &llvm::BranchFolderPassID = BranchFolderPass::ID;
 119
 120 INITIALIZE_PASS(BranchFolderPass, DEBUG_TYPE,
 121                 "Control Flow Optimizer", false, false)
 122
 123 bool BranchFolderPass::runOnMachineFunction(MachineFunction &MF) {
 124   if (skipFunction(MF.getFunction()))
 125     return false;
 126
 127   TargetPassConfig *PassConfig = &getAnalysis<TargetPassConfig>();
 128   // TailMerge can create jump into if branches that make CFG irreducible for
 129   // HW that requires structurized CFG.
 130   bool EnableTailMerge = !MF.getTarget().requiresStructuredCFG() &&
 131                          PassConfig->getEnableTailMerge();
 132   BranchFolder::MBFIWrapper MBBFreqInfo(
 133       getAnalysis<MachineBlockFrequencyInfo>());
 134   BranchFolder Folder(EnableTailMerge, /*CommonHoist=*/true, MBBFreqInfo,
 135                       getAnalysis<MachineBranchProbabilityInfo>(),
 136                       &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI());
 137   auto *MMIWP = getAnalysisIfAvailable<MachineModuleInfoWrapperPass>();
 138   return Folder.OptimizeFunction(
 139       MF, MF.getSubtarget().getInstrInfo(), MF.getSubtarget().getRegisterInfo(),
 140       MMIWP ? &MMIWP->getMMI() : nullptr);
 141 }
 142
 143 BranchFolder::BranchFolder(bool defaultEnableTailMerge, bool CommonHoist,
 144                            MBFIWrapper &FreqInfo,
 145                            const MachineBranchProbabilityInfo &ProbInfo,
 146                            ProfileSummaryInfo *PSI,
 147                            unsigned MinTailLength)
 148     : EnableHoistCommonCode(CommonHoist), MinCommonTailLength(MinTailLength),
 149       MBBFreqInfo(FreqInfo), MBPI(ProbInfo), PSI(PSI) {
 150   if (MinCommonTailLength == 0)
 151     MinCommonTailLength = TailMergeSize;
 152   switch (FlagEnableTailMerge) {
 153   case cl::BOU_UNSET: EnableTailMerge = defaultEnableTailMerge; break;
 154   case cl::BOU_TRUE: EnableTailMerge = true; break;
 155   case cl::BOU_FALSE: EnableTailMerge = false; break;
 156   }
 157 }
 158
 159 void BranchFolder::RemoveDeadBlock(MachineBasicBlock *MBB) {
 160   assert(MBB->pred_empty() && "MBB must be dead!");
 161   LLVM_DEBUG(dbgs() << "\nRemoving MBB: " << *MBB);
 162
 163   MachineFunction *MF = MBB->getParent();
 164   // drop all successors.
 165   while (!MBB->succ_empty())
 166     MBB->removeSuccessor(MBB->succ_end()-1);
 167
 168   // Avoid matching if this pointer gets reused.
 169   TriedMerging.erase(MBB);
 170
 171   // Update call site info.
 172   std::for_each(MBB->begin(), MBB->end(), [MF](const MachineInstr &MI) {
 173     if (MI.isCall(MachineInstr::IgnoreBundle))
 174       MF->eraseCallSiteInfo(&MI);
 175   });
 176   // Remove the block.
 177   MF->erase(MBB);
 178   EHScopeMembership.erase(MBB);
 179   if (MLI)
 180     MLI->removeBlock(MBB);
 181 }
 182
 183 bool BranchFolder::OptimizeFunction(MachineFunction &MF,
 184                                     const TargetInstrInfo *tii,
 185                                     const TargetRegisterInfo *tri,
 186                                     MachineModuleInfo *mmi,
 187                                     MachineLoopInfo *mli, bool AfterPlacement) {
 188   if (!tii) return false;
 189
 190   TriedMerging.clear();
 191
 192   MachineRegisterInfo &MRI = MF.getRegInfo();
 193   AfterBlockPlacement = AfterPlacement;
 194   TII = tii;
 195   TRI = tri;
 196   MMI = mmi;
 197   MLI = mli;
 198   this->MRI = &MRI;
 199
 200   UpdateLiveIns = MRI.tracksLiveness() && TRI->trackLivenessAfterRegAlloc(MF);
 201   if (!UpdateLiveIns)
 202     MRI.invalidateLiveness();
 203
 204   // Fix CFG.  The later algorithms expect it to be right.
 205   bool MadeChange = false;
 206   for (MachineBasicBlock &MBB : MF) {
 207     MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
 208     SmallVector<MachineOperand, 4> Cond;
 209     if (!TII->analyzeBranch(MBB, TBB, FBB, Cond, true))
 210       MadeChange |= MBB.CorrectExtraCFGEdges(TBB, FBB, !Cond.empty());
 211   }
 212
 213   // Recalculate EH scope membership.
 214   EHScopeMembership = getEHScopeMembership(MF);
 215
 216   bool MadeChangeThisIteration = true;
 217   while (MadeChangeThisIteration) {
 218     MadeChangeThisIteration    = TailMergeBlocks(MF);
 219     // No need to clean up if tail merging does not change anything after the
 220     // block placement.
 221     if (!AfterBlockPlacement || MadeChangeThisIteration)
 222       MadeChangeThisIteration |= OptimizeBranches(MF);
 223     if (EnableHoistCommonCode)
 224       MadeChangeThisIteration |= HoistCommonCode(MF);
 225     MadeChange |= MadeChangeThisIteration;
 226   }
 227
 228   // See if any jump tables have become dead as the code generator
 229   // did its thing.
 230   MachineJumpTableInfo *JTI = MF.getJumpTableInfo();
 231   if (!JTI)
 232     return MadeChange;
 233
 234   // Walk the function to find jump tables that are live.
 235   BitVector JTIsLive(JTI->getJumpTables().size());
 236   for (const MachineBasicBlock &BB : MF) {
 237     for (const MachineInstr &I : BB)
 238       for (const MachineOperand &Op : I.operands()) {
 239         if (!Op.isJTI()) continue;
 240
 241         // Remember that this JT is live.
 242         JTIsLive.set(Op.getIndex());
 243       }
 244   }
 245
 246   // Finally, remove dead jump tables.  This happens when the
 247   // indirect jump was unreachable (and thus deleted).
 248   for (unsigned i = 0, e = JTIsLive.size(); i != e; ++i)
 249     if (!JTIsLive.test(i)) {
 250       JTI->RemoveJumpTable(i);
 251       MadeChange = true;
 252     }
 253
 254   return MadeChange;
 255 }
 256
 257 //===----------------------------------------------------------------------===//
 258 //  Tail Merging of Blocks
 259 //===----------------------------------------------------------------------===//
 260
 261 /// HashMachineInstr - Compute a hash value for MI and its operands.
 262 static unsigned HashMachineInstr(const MachineInstr &MI) {
 263   unsigned Hash = MI.getOpcode();
 264   for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
 265     const MachineOperand &Op = MI.getOperand(i);
 266
 267     // Merge in bits from the operand if easy. We can't use MachineOperand's
 268     // hash_code here because it's not deterministic and we sort by hash value
 269     // later.
 270     unsigned OperandHash = 0;
 271     switch (Op.getType()) {
 272     case MachineOperand::MO_Register:
 273       OperandHash = Op.getReg();
 274       break;
 275     case MachineOperand::MO_Immediate:
 276       OperandHash = Op.getImm();
 277       break;
 278     case MachineOperand::MO_MachineBasicBlock:
 279       OperandHash = Op.getMBB()->getNumber();
 280       break;
 281     case MachineOperand::MO_FrameIndex:
 282     case MachineOperand::MO_ConstantPoolIndex:
 283     case MachineOperand::MO_JumpTableIndex:
 284       OperandHash = Op.getIndex();
 285       break;
 286     case MachineOperand::MO_GlobalAddress:
 287     case MachineOperand::MO_ExternalSymbol:
 288       // Global address / external symbol are too hard, don't bother, but do
 289       // pull in the offset.
 290       OperandHash = Op.getOffset();
 291       break;
 292     default:
 293       break;
 294     }
 295
 296     Hash += ((OperandHash << 3) | Op.getType()) << (i & 31);
 297   }
 298   return Hash;
 299 }
 300
 301 /// HashEndOfMBB - Hash the last instruction in the MBB.
 302 static unsigned HashEndOfMBB(const MachineBasicBlock &MBB) {
 303   MachineBasicBlock::const_iterator I = MBB.getLastNonDebugInstr();
 304   if (I == MBB.end())
 305     return 0;
 306
 307   return HashMachineInstr(*I);
 308 }
 309
 310 /// Whether MI should be counted as an instruction when calculating common tail.
 311 static bool countsAsInstruction(const MachineInstr &MI) {
 312   return !(MI.isDebugInstr() || MI.isCFIInstruction());
 313 }
 314
 315 /// Iterate backwards from the given iterator \p I, towards the beginning of the
 316 /// block. If a MI satisfying 'countsAsInstruction' is found, return an iterator
 317 /// pointing to that MI. If no such MI is found, return the end iterator.
 318 static MachineBasicBlock::iterator
 319 skipBackwardPastNonInstructions(MachineBasicBlock::iterator I,
 320                                 MachineBasicBlock *MBB) {
 321   while (I != MBB->begin()) {
 322     --I;
 323     if (countsAsInstruction(*I))
 324       return I;
 325   }
 326   return MBB->end();
 327 }
 328
 329 /// Given two machine basic blocks, return the number of instructions they
 330 /// actually have in common together at their end. If a common tail is found (at
 331 /// least by one instruction), then iterators for the first shared instruction
 332 /// in each block are returned as well.
 333 ///
 334 /// Non-instructions according to countsAsInstruction are ignored.
 335 static unsigned ComputeCommonTailLength(MachineBasicBlock *MBB1,
 336                                         MachineBasicBlock *MBB2,
 337                                         MachineBasicBlock::iterator &I1,
 338                                         MachineBasicBlock::iterator &I2) {
 339   MachineBasicBlock::iterator MBBI1 = MBB1->end();
 340   MachineBasicBlock::iterator MBBI2 = MBB2->end();
 341
 342   unsigned TailLen = 0;
 343   while (true) {
 344     MBBI1 = skipBackwardPastNonInstructions(MBBI1, MBB1);
 345     MBBI2 = skipBackwardPastNonInstructions(MBBI2, MBB2);
 346     if (MBBI1 == MBB1->end() || MBBI2 == MBB2->end())
 347       break;
 348     if (!MBBI1->isIdenticalTo(*MBBI2) ||
 349         // FIXME: This check is dubious. It's used to get around a problem where
 350         // people incorrectly expect inline asm directives to remain in the same
 351         // relative order. This is untenable because normal compiler
 352         // optimizations (like this one) may reorder and/or merge these
 353         // directives.
 354         MBBI1->isInlineAsm()) {
 355       break;
 356     }
 357     ++TailLen;
 358     I1 = MBBI1;
 359     I2 = MBBI2;
 360   }
 361
 362   return TailLen;
 363 }
 364
 365 void BranchFolder::replaceTailWithBranchTo(MachineBasicBlock::iterator OldInst,
 366                                            MachineBasicBlock &NewDest) {
 367   if (UpdateLiveIns) {
 368     // OldInst should always point to an instruction.
 369     MachineBasicBlock &OldMBB = *OldInst->getParent();
 370     LiveRegs.clear();
 371     LiveRegs.addLiveOuts(OldMBB);
 372     // Move backward to the place where will insert the jump.
 373     MachineBasicBlock::iterator I = OldMBB.end();
 374     do {
 375       --I;
 376       LiveRegs.stepBackward(*I);
 377     } while (I != OldInst);
 378
 379     // Merging the tails may have switched some undef operand to non-undef ones.
 380     // Add IMPLICIT_DEFS into OldMBB as necessary to have a definition of the
 381     // register.
 382     for (MachineBasicBlock::RegisterMaskPair P : NewDest.liveins()) {
 383       // We computed the liveins with computeLiveIn earlier and should only see
 384       // full registers:
 385       assert(P.LaneMask == LaneBitmask::getAll() &&
 386              "Can only handle full register.");
 387       MCPhysReg Reg = P.PhysReg;
 388       if (!LiveRegs.available(*MRI, Reg))
 389         continue;
 390       DebugLoc DL;
 391       BuildMI(OldMBB, OldInst, DL, TII->get(TargetOpcode::IMPLICIT_DEF), Reg);
 392     }
 393   }
 394
 395   TII->ReplaceTailWithBranchTo(OldInst, &NewDest);
 396   ++NumTailMerge;
 397 }
 398
 399 MachineBasicBlock *BranchFolder::SplitMBBAt(MachineBasicBlock &CurMBB,
 400                                             MachineBasicBlock::iterator BBI1,
 401                                             const BasicBlock *BB) {
 402   if (!TII->isLegalToSplitMBBAt(CurMBB, BBI1))
 403     return nullptr;
 404
 405   MachineFunction &MF = *CurMBB.getParent();
 406
 407   // Create the fall-through block.
 408   MachineFunction::iterator MBBI = CurMBB.getIterator();
 409   MachineBasicBlock *NewMBB = MF.CreateMachineBasicBlock(BB);
 410   CurMBB.getParent()->insert(++MBBI, NewMBB);
 411
 412   // Move all the successors of this block to the specified block.
 413   NewMBB->transferSuccessors(&CurMBB);
 414
 415   // Add an edge from CurMBB to NewMBB for the fall-through.
 416   CurMBB.addSuccessor(NewMBB);
 417
 418   // Splice the code over.
 419   NewMBB->splice(NewMBB->end(), &CurMBB, BBI1, CurMBB.end());
 420
 421   // NewMBB belongs to the same loop as CurMBB.
 422   if (MLI)
 423     if (MachineLoop *ML = MLI->getLoopFor(&CurMBB))
 424       ML->addBasicBlockToLoop(NewMBB, MLI->getBase());
 425
 426   // NewMBB inherits CurMBB's block frequency.
 427   MBBFreqInfo.setBlockFreq(NewMBB, MBBFreqInfo.getBlockFreq(&CurMBB));
 428
 429   if (UpdateLiveIns)
 430     computeAndAddLiveIns(LiveRegs, *NewMBB);
 431
 432   // Add the new block to the EH scope.
 433   const auto &EHScopeI = EHScopeMembership.find(&CurMBB);
 434   if (EHScopeI != EHScopeMembership.end()) {
 435     auto n = EHScopeI->second;
 436     EHScopeMembership[NewMBB] = n;
 437   }
 438
 439   return NewMBB;
 440 }
 441
 442 /// EstimateRuntime - Make a rough estimate for how long it will take to run
 443 /// the specified code.
 444 static unsigned EstimateRuntime(MachineBasicBlock::iterator I,
 445                                 MachineBasicBlock::iterator E) {
 446   unsigned Time = 0;
 447   for (; I != E; ++I) {
 448     if (!countsAsInstruction(*I))
 449       continue;
 450     if (I->isCall())
 451       Time += 10;
 452     else if (I->mayLoadOrStore())
 453       Time += 2;
 454     else
 455       ++Time;
 456   }
 457   return Time;
 458 }
 459
 460 // CurMBB needs to add an unconditional branch to SuccMBB (we removed these
 461 // branches temporarily for tail merging).  In the case where CurMBB ends
 462 // with a conditional branch to the next block, optimize by reversing the
 463 // test and conditionally branching to SuccMBB instead.
 464 static void FixTail(MachineBasicBlock *CurMBB, MachineBasicBlock *SuccBB,
 465                     const TargetInstrInfo *TII) {
 466   MachineFunction *MF = CurMBB->getParent();
 467   MachineFunction::iterator I = std::next(MachineFunction::iterator(CurMBB));
 468   MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
 469   SmallVector<MachineOperand, 4> Cond;
 470   DebugLoc dl = CurMBB->findBranchDebugLoc();
 471   if (I != MF->end() && !TII->analyzeBranch(*CurMBB, TBB, FBB, Cond, true)) {
 472     MachineBasicBlock *NextBB = &*I;
 473     if (TBB == NextBB && !Cond.empty() && !FBB) {
 474       if (!TII->reverseBranchCondition(Cond)) {
 475         TII->removeBranch(*CurMBB);
 476         TII->insertBranch(*CurMBB, SuccBB, nullptr, Cond, dl);
 477         return;
 478       }
 479     }
 480   }
 481   TII->insertBranch(*CurMBB, SuccBB, nullptr,
 482                     SmallVector<MachineOperand, 0>(), dl);
 483 }
 484
 485 bool
 486 BranchFolder::MergePotentialsElt::operator<(const MergePotentialsElt &o) const {
 487   if (getHash() < o.getHash())
 488     return true;
 489   if (getHash() > o.getHash())
 490     return false;
 491   if (getBlock()->getNumber() < o.getBlock()->getNumber())
 492     return true;
 493   if (getBlock()->getNumber() > o.getBlock()->getNumber())
 494     return false;
 495   // _GLIBCXX_DEBUG checks strict weak ordering, which involves comparing
 496   // an object with itself.
 497 #ifndef _GLIBCXX_DEBUG
 498   llvm_unreachable("Predecessor appears twice");
 499 #else
 500   return false;
 501 #endif
 502 }
 503
 504 BlockFrequency
 505 BranchFolder::MBFIWrapper::getBlockFreq(const MachineBasicBlock *MBB) const {
 506   auto I = MergedBBFreq.find(MBB);
 507
 508   if (I != MergedBBFreq.end())
 509     return I->second;
 510
 511   return MBFI.getBlockFreq(MBB);
 512 }
 513
 514 void BranchFolder::MBFIWrapper::setBlockFreq(const MachineBasicBlock *MBB,
 515                                              BlockFrequency F) {
 516   MergedBBFreq[MBB] = F;
 517 }
 518
 519 raw_ostream &
 520 BranchFolder::MBFIWrapper::printBlockFreq(raw_ostream &OS,
 521                                           const MachineBasicBlock *MBB) const {
 522   return MBFI.printBlockFreq(OS, getBlockFreq(MBB));
 523 }
 524
 525 raw_ostream &
 526 BranchFolder::MBFIWrapper::printBlockFreq(raw_ostream &OS,
 527                                           const BlockFrequency Freq) const {
 528   return MBFI.printBlockFreq(OS, Freq);
 529 }
 530
 531 void BranchFolder::MBFIWrapper::view(const Twine &Name, bool isSimple) {
 532   MBFI.view(Name, isSimple);
 533 }
 534
 535 uint64_t
 536 BranchFolder::MBFIWrapper::getEntryFreq() const {
 537   return MBFI.getEntryFreq();
 538 }
 539
 540 /// CountTerminators - Count the number of terminators in the given
 541 /// block and set I to the position of the first non-terminator, if there
 542 /// is one, or MBB->end() otherwise.
 543 static unsigned CountTerminators(MachineBasicBlock *MBB,
 544                                  MachineBasicBlock::iterator &I) {
 545   I = MBB->end();
 546   unsigned NumTerms = 0;
 547   while (true) {
 548     if (I == MBB->begin()) {
 549       I = MBB->end();
 550       break;
 551     }
 552     --I;
 553     if (!I->isTerminator()) break;
 554     ++NumTerms;
 555   }
 556   return NumTerms;
 557 }
 558
 559 /// A no successor, non-return block probably ends in unreachable and is cold.
 560 /// Also consider a block that ends in an indirect branch to be a return block,
 561 /// since many targets use plain indirect branches to return.
 562 static bool blockEndsInUnreachable(const MachineBasicBlock *MBB) {
 563   if (!MBB->succ_empty())
 564     return false;
 565   if (MBB->empty())
 566     return true;
 567   return !(MBB->back().isReturn() || MBB->back().isIndirectBranch());
 568 }
 569
 570 /// ProfitableToMerge - Check if two machine basic blocks have a common tail
 571 /// and decide if it would be profitable to merge those tails.  Return the
 572 /// length of the common tail and iterators to the first common instruction
 573 /// in each block.
 574 /// MBB1, MBB2      The blocks to check
 575 /// MinCommonTailLength  Minimum size of tail block to be merged.
 576 /// CommonTailLen   Out parameter to record the size of the shared tail between
 577 ///                 MBB1 and MBB2
 578 /// I1, I2          Iterator references that will be changed to point to the first
 579 ///                 instruction in the common tail shared by MBB1,MBB2
 580 /// SuccBB          A common successor of MBB1, MBB2 which are in a canonical form
 581 ///                 relative to SuccBB
 582 /// PredBB          The layout predecessor of SuccBB, if any.
 583 /// EHScopeMembership  map from block to EH scope #.
 584 /// AfterPlacement  True if we are merging blocks after layout. Stricter
 585 ///                 thresholds apply to prevent undoing tail-duplication.
 586 static bool
 587 ProfitableToMerge(MachineBasicBlock *MBB1, MachineBasicBlock *MBB2,
 588                   unsigned MinCommonTailLength, unsigned &CommonTailLen,
 589                   MachineBasicBlock::iterator &I1,
 590                   MachineBasicBlock::iterator &I2, MachineBasicBlock *SuccBB,
 591                   MachineBasicBlock *PredBB,
 592                   DenseMap<const MachineBasicBlock *, int> &EHScopeMembership,
 593                   bool AfterPlacement,
 594                   BranchFolder::MBFIWrapper &MBBFreqInfo,
 595                   ProfileSummaryInfo *PSI) {
 596   // It is never profitable to tail-merge blocks from two different EH scopes.
 597   if (!EHScopeMembership.empty()) {
 598     auto EHScope1 = EHScopeMembership.find(MBB1);
 599     assert(EHScope1 != EHScopeMembership.end());
 600     auto EHScope2 = EHScopeMembership.find(MBB2);
 601     assert(EHScope2 != EHScopeMembership.end());
 602     if (EHScope1->second != EHScope2->second)
 603       return false;
 604   }
 605
 606   CommonTailLen = ComputeCommonTailLength(MBB1, MBB2, I1, I2);
 607   if (CommonTailLen == 0)
 608     return false;
 609   LLVM_DEBUG(dbgs() << "Common tail length of " << printMBBReference(*MBB1)
 610                     << " and " << printMBBReference(*MBB2) << " is "
 611                     << CommonTailLen << '\n');
 612
 613   // Move the iterators to the beginning of the MBB if we only got debug
 614   // instructions before the tail. This is to avoid splitting a block when we
 615   // only got debug instructions before the tail (to be invariant on -g).
 616   if (skipDebugInstructionsForward(MBB1->begin(), MBB1->end()) == I1)
 617     I1 = MBB1->begin();
 618   if (skipDebugInstructionsForward(MBB2->begin(), MBB2->end()) == I2)
 619     I2 = MBB2->begin();
 620
 621   bool FullBlockTail1 = I1 == MBB1->begin();
 622   bool FullBlockTail2 = I2 == MBB2->begin();
 623
 624   // It's almost always profitable to merge any number of non-terminator
 625   // instructions with the block that falls through into the common successor.
 626   // This is true only for a single successor. For multiple successors, we are
 627   // trading a conditional branch for an unconditional one.
 628   // TODO: Re-visit successor size for non-layout tail merging.
 629   if ((MBB1 == PredBB || MBB2 == PredBB) &&
 630       (!AfterPlacement || MBB1->succ_size() == 1)) {
 631     MachineBasicBlock::iterator I;
 632     unsigned NumTerms = CountTerminators(MBB1 == PredBB ? MBB2 : MBB1, I);
 633     if (CommonTailLen > NumTerms)
 634       return true;
 635   }
 636
 637   // If these are identical non-return blocks with no successors, merge them.
 638   // Such blocks are typically cold calls to noreturn functions like abort, and
 639   // are unlikely to become a fallthrough target after machine block placement.
 640   // Tail merging these blocks is unlikely to create additional unconditional
 641   // branches, and will reduce the size of this cold code.
 642   if (FullBlockTail1 && FullBlockTail2 &&
 643       blockEndsInUnreachable(MBB1) && blockEndsInUnreachable(MBB2))
 644     return true;
 645
 646   // If one of the blocks can be completely merged and happens to be in
 647   // a position where the other could fall through into it, merge any number
 648   // of instructions, because it can be done without a branch.
 649   // TODO: If the blocks are not adjacent, move one of them so that they are?
 650   if (MBB1->isLayoutSuccessor(MBB2) && FullBlockTail2)
 651     return true;
 652   if (MBB2->isLayoutSuccessor(MBB1) && FullBlockTail1)
 653     return true;
 654
 655   // If both blocks are identical and end in a branch, merge them unless they
 656   // both have a fallthrough predecessor and successor.
 657   // We can only do this after block placement because it depends on whether
 658   // there are fallthroughs, and we don't know until after layout.
 659   if (AfterPlacement && FullBlockTail1 && FullBlockTail2) {
 660     auto BothFallThrough = [](MachineBasicBlock *MBB) {
 661       if (MBB->succ_size() != 0 && !MBB->canFallThrough())
 662         return false;
 663       MachineFunction::iterator I(MBB);
 664       MachineFunction *MF = MBB->getParent();
 665       return (MBB != &*MF->begin()) && std::prev(I)->canFallThrough();
 666     };
 667     if (!BothFallThrough(MBB1) || !BothFallThrough(MBB2))
 668       return true;
 669   }
 670
 671   // If both blocks have an unconditional branch temporarily stripped out,
 672   // count that as an additional common instruction for the following
 673   // heuristics. This heuristic is only accurate for single-succ blocks, so to
 674   // make sure that during layout merging and duplicating don't crash, we check
 675   // for that when merging during layout.
 676   unsigned EffectiveTailLen = CommonTailLen;
 677   if (SuccBB && MBB1 != PredBB && MBB2 != PredBB &&
 678       (MBB1->succ_size() == 1 || !AfterPlacement) &&
 679       !MBB1->back().isBarrier() &&
 680       !MBB2->back().isBarrier())
 681     ++EffectiveTailLen;
 682
 683   // Check if the common tail is long enough to be worthwhile.
 684   if (EffectiveTailLen >= MinCommonTailLength)
 685     return true;
 686
 687   // If we are optimizing for code size, 2 instructions in common is enough if
 688   // we don't have to split a block.  At worst we will be introducing 1 new
 689   // branch instruction, which is likely to be smaller than the 2
 690   // instructions that would be deleted in the merge.
 691   MachineFunction *MF = MBB1->getParent();
 692   bool OptForSize =
 693       MF->getFunction().hasOptSize() ||
 694       (llvm::shouldOptimizeForSize(MBB1, PSI, &MBBFreqInfo.getMBFI()) &&
 695        llvm::shouldOptimizeForSize(MBB2, PSI, &MBBFreqInfo.getMBFI()));
 696   return EffectiveTailLen >= 2 && OptForSize &&
 697          (FullBlockTail1 || FullBlockTail2);
 698 }
 699
 700 unsigned BranchFolder::ComputeSameTails(unsigned CurHash,
 701                                         unsigned MinCommonTailLength,
 702                                         MachineBasicBlock *SuccBB,
 703                                         MachineBasicBlock *PredBB) {
 704   unsigned maxCommonTailLength = 0U;
 705   SameTails.clear();
 706   MachineBasicBlock::iterator TrialBBI1, TrialBBI2;
 707   MPIterator HighestMPIter = std::prev(MergePotentials.end());
 708   for (MPIterator CurMPIter = std::prev(MergePotentials.end()),
 709                   B = MergePotentials.begin();
 710        CurMPIter != B && CurMPIter->getHash() == CurHash; --CurMPIter) {
 711     for (MPIterator I = std::prev(CurMPIter); I->getHash() == CurHash; --I) {
 712       unsigned CommonTailLen;
 713       if (ProfitableToMerge(CurMPIter->getBlock(), I->getBlock(),
 714                             MinCommonTailLength,
 715                             CommonTailLen, TrialBBI1, TrialBBI2,
 716                             SuccBB, PredBB,
 717                             EHScopeMembership,
 718                             AfterBlockPlacement, MBBFreqInfo, PSI)) {
 719         if (CommonTailLen > maxCommonTailLength) {
 720           SameTails.clear();
 721           maxCommonTailLength = CommonTailLen;
 722           HighestMPIter = CurMPIter;
 723           SameTails.push_back(SameTailElt(CurMPIter, TrialBBI1));
 724         }
 725         if (HighestMPIter == CurMPIter &&
 726             CommonTailLen == maxCommonTailLength)
 727           SameTails.push_back(SameTailElt(I, TrialBBI2));
 728       }
 729       if (I == B)
 730         break;
 731     }
 732   }
 733   return maxCommonTailLength;
 734 }
 735
 736 void BranchFolder::RemoveBlocksWithHash(unsigned CurHash,
 737                                         MachineBasicBlock *SuccBB,
 738                                         MachineBasicBlock *PredBB) {
 739   MPIterator CurMPIter, B;
 740   for (CurMPIter = std::prev(MergePotentials.end()),
 741       B = MergePotentials.begin();
 742        CurMPIter->getHash() == CurHash; --CurMPIter) {
 743     // Put the unconditional branch back, if we need one.
 744     MachineBasicBlock *CurMBB = CurMPIter->getBlock();
 745     if (SuccBB && CurMBB != PredBB)
 746       FixTail(CurMBB, SuccBB, TII);
 747     if (CurMPIter == B)
 748       break;
 749   }
 750   if (CurMPIter->getHash() != CurHash)
 751     CurMPIter++;
 752   MergePotentials.erase(CurMPIter, MergePotentials.end());
 753 }
 754
 755 bool BranchFolder::CreateCommonTailOnlyBlock(MachineBasicBlock *&PredBB,
 756                                              MachineBasicBlock *SuccBB,
 757                                              unsigned maxCommonTailLength,
 758                                              unsigned &commonTailIndex) {
 759   commonTailIndex = 0;
 760   unsigned TimeEstimate = ~0U;
 761   for (unsigned i = 0, e = SameTails.size(); i != e; ++i) {
 762     // Use PredBB if possible; that doesn't require a new branch.
 763     if (SameTails[i].getBlock() == PredBB) {
 764       commonTailIndex = i;
 765       break;
 766     }
 767     // Otherwise, make a (fairly bogus) choice based on estimate of
 768     // how long it will take the various blocks to execute.
 769     unsigned t = EstimateRuntime(SameTails[i].getBlock()->begin(),
 770                                  SameTails[i].getTailStartPos());
 771     if (t <= TimeEstimate) {
 772       TimeEstimate = t;
 773       commonTailIndex = i;
 774     }
 775   }
 776
 777   MachineBasicBlock::iterator BBI =
 778     SameTails[commonTailIndex].getTailStartPos();
 779   MachineBasicBlock *MBB = SameTails[commonTailIndex].getBlock();
 780
 781   LLVM_DEBUG(dbgs() << "\nSplitting " << printMBBReference(*MBB) << ", size "
 782                     << maxCommonTailLength);
 783
 784   // If the split block unconditionally falls-thru to SuccBB, it will be
 785   // merged. In control flow terms it should then take SuccBB's name. e.g. If
 786   // SuccBB is an inner loop, the common tail is still part of the inner loop.
 787   const BasicBlock *BB = (SuccBB && MBB->succ_size() == 1) ?
 788     SuccBB->getBasicBlock() : MBB->getBasicBlock();
 789   MachineBasicBlock *newMBB = SplitMBBAt(*MBB, BBI, BB);
 790   if (!newMBB) {
 791     LLVM_DEBUG(dbgs() << "... failed!");
 792     return false;
 793   }
 794
 795   SameTails[commonTailIndex].setBlock(newMBB);
 796   SameTails[commonTailIndex].setTailStartPos(newMBB->begin());
 797
 798   // If we split PredBB, newMBB is the new predecessor.
 799   if (PredBB == MBB)
 800     PredBB = newMBB;
 801
 802   return true;
 803 }
 804
 805 static void
 806 mergeOperations(MachineBasicBlock::iterator MBBIStartPos,
 807                 MachineBasicBlock &MBBCommon) {
 808   MachineBasicBlock *MBB = MBBIStartPos->getParent();
 809   // Note CommonTailLen does not necessarily matches the size of
 810   // the common BB nor all its instructions because of debug
 811   // instructions differences.
 812   unsigned CommonTailLen = 0;
 813   for (auto E = MBB->end(); MBBIStartPos != E; ++MBBIStartPos)
 814     ++CommonTailLen;
 815
 816   MachineBasicBlock::reverse_iterator MBBI = MBB->rbegin();
 817   MachineBasicBlock::reverse_iterator MBBIE = MBB->rend();
 818   MachineBasicBlock::reverse_iterator MBBICommon = MBBCommon.rbegin();
 819   MachineBasicBlock::reverse_iterator MBBIECommon = MBBCommon.rend();
 820
 821   while (CommonTailLen--) {
 822     assert(MBBI != MBBIE && "Reached BB end within common tail length!");
 823     (void)MBBIE;
 824
 825     if (!countsAsInstruction(*MBBI)) {
 826       ++MBBI;
 827       continue;
 828     }
 829
 830     while ((MBBICommon != MBBIECommon) && !countsAsInstruction(*MBBICommon))
 831       ++MBBICommon;
 832
 833     assert(MBBICommon != MBBIECommon &&
 834            "Reached BB end within common tail length!");
 835     assert(MBBICommon->isIdenticalTo(*MBBI) && "Expected matching MIIs!");
 836
 837     // Merge MMOs from memory operations in the common block.
 838     if (MBBICommon->mayLoadOrStore())
 839       MBBICommon->cloneMergedMemRefs(*MBB->getParent(), {&*MBBICommon, &*MBBI});
 840     // Drop undef flags if they aren't present in all merged instructions.
 841     for (unsigned I = 0, E = MBBICommon->getNumOperands(); I != E; ++I) {
 842       MachineOperand &MO = MBBICommon->getOperand(I);
 843       if (MO.isReg() && MO.isUndef()) {
 844         const MachineOperand &OtherMO = MBBI->getOperand(I);
 845         if (!OtherMO.isUndef())
 846           MO.setIsUndef(false);
 847       }
 848     }
 849
 850     ++MBBI;
 851     ++MBBICommon;
 852   }
 853 }
 854
 855 void BranchFolder::mergeCommonTails(unsigned commonTailIndex) {
 856   MachineBasicBlock *MBB = SameTails[commonTailIndex].getBlock();
 857
 858   std::vector<MachineBasicBlock::iterator> NextCommonInsts(SameTails.size());
 859   for (unsigned int i = 0 ; i != SameTails.size() ; ++i) {
 860     if (i != commonTailIndex) {
 861       NextCommonInsts[i] = SameTails[i].getTailStartPos();
 862       mergeOperations(SameTails[i].getTailStartPos(), *MBB);
 863     } else {
 864       assert(SameTails[i].getTailStartPos() == MBB->begin() &&
 865           "MBB is not a common tail only block");
 866     }
 867   }
 868
 869   for (auto &MI : *MBB) {
 870     if (!countsAsInstruction(MI))
 871       continue;
 872     DebugLoc DL = MI.getDebugLoc();
 873     for (unsigned int i = 0 ; i < NextCommonInsts.size() ; i++) {
 874       if (i == commonTailIndex)
 875         continue;
 876
 877       auto &Pos = NextCommonInsts[i];
 878       assert(Pos != SameTails[i].getBlock()->end() &&
 879           "Reached BB end within common tail");
 880       while (!countsAsInstruction(*Pos)) {
 881         ++Pos;
 882         assert(Pos != SameTails[i].getBlock()->end() &&
 883             "Reached BB end within common tail");
 884       }
 885       assert(MI.isIdenticalTo(*Pos) && "Expected matching MIIs!");
 886       DL = DILocation::getMergedLocation(DL, Pos->getDebugLoc());
 887       NextCommonInsts[i] = ++Pos;
 888     }
 889     MI.setDebugLoc(DL);
 890   }
 891
 892   if (UpdateLiveIns) {
 893     LivePhysRegs NewLiveIns(*TRI);
 894     computeLiveIns(NewLiveIns, *MBB);
 895     LiveRegs.init(*TRI);
 896
 897     // The flag merging may lead to some register uses no longer using the
 898     // <undef> flag, add IMPLICIT_DEFs in the predecessors as necessary.
 899     for (MachineBasicBlock *Pred : MBB->predecessors()) {
 900       LiveRegs.clear();
 901       LiveRegs.addLiveOuts(*Pred);
 902       MachineBasicBlock::iterator InsertBefore = Pred->getFirstTerminator();
 903       for (unsigned Reg : NewLiveIns) {
 904         if (!LiveRegs.available(*MRI, Reg))
 905           continue;
 906         DebugLoc DL;
 907         BuildMI(*Pred, InsertBefore, DL, TII->get(TargetOpcode::IMPLICIT_DEF),
 908                 Reg);
 909       }
 910     }
 911
 912     MBB->clearLiveIns();
 913     addLiveIns(*MBB, NewLiveIns);
 914   }
 915 }
 916
 917 // See if any of the blocks in MergePotentials (which all have SuccBB as a
 918 // successor, or all have no successor if it is null) can be tail-merged.
 919 // If there is a successor, any blocks in MergePotentials that are not
 920 // tail-merged and are not immediately before Succ must have an unconditional
 921 // branch to Succ added (but the predecessor/successor lists need no
 922 // adjustment). The lone predecessor of Succ that falls through into Succ,
 923 // if any, is given in PredBB.
 924 // MinCommonTailLength - Except for the special cases below, tail-merge if
 925 // there are at least this many instructions in common.
 926 bool BranchFolder::TryTailMergeBlocks(MachineBasicBlock *SuccBB,
 927                                       MachineBasicBlock *PredBB,
 928                                       unsigned MinCommonTailLength) {
 929   bool MadeChange = false;
 930
 931   LLVM_DEBUG(
 932       dbgs() << "\nTryTailMergeBlocks: ";
 933       for (unsigned i = 0, e = MergePotentials.size(); i != e; ++i) dbgs()
 934       << printMBBReference(*MergePotentials[i].getBlock())
 935       << (i == e - 1 ? "" : ", ");
 936       dbgs() << "\n"; if (SuccBB) {
 937         dbgs() << "  with successor " << printMBBReference(*SuccBB) << '\n';
 938         if (PredBB)
 939           dbgs() << "  which has fall-through from "
 940                  << printMBBReference(*PredBB) << "\n";
 941       } dbgs() << "Looking for common tails of at least "
 942                << MinCommonTailLength << " instruction"
 943                << (MinCommonTailLength == 1 ? "" : "s") << '\n';);
 944
 945   // Sort by hash value so that blocks with identical end sequences sort
 946   // together.
 947   array_pod_sort(MergePotentials.begin(), MergePotentials.end());
 948
 949   // Walk through equivalence sets looking for actual exact matches.
 950   while (MergePotentials.size() > 1) {
 951     unsigned CurHash = MergePotentials.back().getHash();
 952
 953     // Build SameTails, identifying the set of blocks with this hash code
 954     // and with the maximum number of instructions in common.
 955     unsigned maxCommonTailLength = ComputeSameTails(CurHash,
 956                                                     MinCommonTailLength,
 957                                                     SuccBB, PredBB);
 958
 959     // If we didn't find any pair that has at least MinCommonTailLength
 960     // instructions in common, remove all blocks with this hash code and retry.
 961     if (SameTails.empty()) {
 962       RemoveBlocksWithHash(CurHash, SuccBB, PredBB);
 963       continue;
 964     }
 965
 966     // If one of the blocks is the entire common tail (and is not the entry
 967     // block/an EH pad, which we can't jump to), we can treat all blocks with
 968     // this same tail at once.  Use PredBB if that is one of the possibilities,
 969     // as that will not introduce any extra branches.
 970     MachineBasicBlock *EntryBB =
 971         &MergePotentials.front().getBlock()->getParent()->front();
 972     unsigned commonTailIndex = SameTails.size();
 973     // If there are two blocks, check to see if one can be made to fall through
 974     // into the other.
 975     if (SameTails.size() == 2 &&
 976         SameTails[0].getBlock()->isLayoutSuccessor(SameTails[1].getBlock()) &&
 977         SameTails[1].tailIsWholeBlock() && !SameTails[1].getBlock()->isEHPad())
 978       commonTailIndex = 1;
 979     else if (SameTails.size() == 2 &&
 980              SameTails[1].getBlock()->isLayoutSuccessor(
 981                  SameTails[0].getBlock()) &&
 982              SameTails[0].tailIsWholeBlock() &&
 983              !SameTails[0].getBlock()->isEHPad())
 984       commonTailIndex = 0;
 985     else {
 986       // Otherwise just pick one, favoring the fall-through predecessor if
 987       // there is one.
 988       for (unsigned i = 0, e = SameTails.size(); i != e; ++i) {
 989         MachineBasicBlock *MBB = SameTails[i].getBlock();
 990         if ((MBB == EntryBB || MBB->isEHPad()) &&
 991             SameTails[i].tailIsWholeBlock())
 992           continue;
 993         if (MBB == PredBB) {
 994           commonTailIndex = i;
 995           break;
 996         }
 997         if (SameTails[i].tailIsWholeBlock())
 998           commonTailIndex = i;
 999       }
1000     }
1001
1002     if (commonTailIndex == SameTails.size() ||
1003         (SameTails[commonTailIndex].getBlock() == PredBB &&
1004          !SameTails[commonTailIndex].tailIsWholeBlock())) {
1005       // None of the blocks consist entirely of the common tail.
1006       // Split a block so that one does.
1007       if (!CreateCommonTailOnlyBlock(PredBB, SuccBB,
1008                                      maxCommonTailLength, commonTailIndex)) {
1009         RemoveBlocksWithHash(CurHash, SuccBB, PredBB);
1010         continue;
1011       }
1012     }
1013
1014     MachineBasicBlock *MBB = SameTails[commonTailIndex].getBlock();
1015
1016     // Recompute common tail MBB's edge weights and block frequency.
1017     setCommonTailEdgeWeights(*MBB);
1018
1019     // Merge debug locations, MMOs and undef flags across identical instructions
1020     // for common tail.
1021     mergeCommonTails(commonTailIndex);
1022
1023     // MBB is common tail.  Adjust all other BB's to jump to this one.
1024     // Traversal must be forwards so erases work.
1025     LLVM_DEBUG(dbgs() << "\nUsing common tail in " << printMBBReference(*MBB)
1026                       << " for ");
1027     for (unsigned int i=0, e = SameTails.size(); i != e; ++i) {
1028       if (commonTailIndex == i)
1029         continue;
1030       LLVM_DEBUG(dbgs() << printMBBReference(*SameTails[i].getBlock())
1031                         << (i == e - 1 ? "" : ", "));
1032       // Hack the end off BB i, making it jump to BB commonTailIndex instead.
1033       replaceTailWithBranchTo(SameTails[i].getTailStartPos(), *MBB);
1034       // BB i is no longer a predecessor of SuccBB; remove it from the worklist.
1035       MergePotentials.erase(SameTails[i].getMPIter());
1036     }
1037     LLVM_DEBUG(dbgs() << "\n");
1038     // We leave commonTailIndex in the worklist in case there are other blocks
1039     // that match it with a smaller number of instructions.
1040     MadeChange = true;
1041   }
1042   return MadeChange;
1043 }
1044
1045 bool BranchFolder::TailMergeBlocks(MachineFunction &MF) {
1046   bool MadeChange = false;
1047   if (!EnableTailMerge)
1048     return MadeChange;
1049
1050   // First find blocks with no successors.
1051   // Block placement may create new tail merging opportunities for these blocks.
1052   MergePotentials.clear();
1053   for (MachineBasicBlock &MBB : MF) {
1054     if (MergePotentials.size() == TailMergeThreshold)
1055       break;
1056     if (!TriedMerging.count(&MBB) && MBB.succ_empty())
1057       MergePotentials.push_back(MergePotentialsElt(HashEndOfMBB(MBB), &MBB));
1058   }
1059
1060   // If this is a large problem, avoid visiting the same basic blocks
1061   // multiple times.
1062   if (MergePotentials.size() == TailMergeThreshold)
1063     for (unsigned i = 0, e = MergePotentials.size(); i != e; ++i)
1064       TriedMerging.insert(MergePotentials[i].getBlock());
1065
1066   // See if we can do any tail merging on those.
1067   if (MergePotentials.size() >= 2)
1068     MadeChange |= TryTailMergeBlocks(nullptr, nullptr, MinCommonTailLength);
1069
1070   // Look at blocks (IBB) with multiple predecessors (PBB).
1071   // We change each predecessor to a canonical form, by
1072   // (1) temporarily removing any unconditional branch from the predecessor
1073   // to IBB, and
1074   // (2) alter conditional branches so they branch to the other block
1075   // not IBB; this may require adding back an unconditional branch to IBB
1076   // later, where there wasn't one coming in.  E.g.
1077   //   Bcc IBB
1078   //   fallthrough to QBB
1079   // here becomes
1080   //   Bncc QBB
1081   // with a conceptual B to IBB after that, which never actually exists.
1082   // With those changes, we see whether the predecessors' tails match,
1083   // and merge them if so.  We change things out of canonical form and
1084   // back to the way they were later in the process.  (OptimizeBranches
1085   // would undo some of this, but we can't use it, because we'd get into
1086   // a compile-time infinite loop repeatedly doing and undoing the same
1087   // transformations.)
1088
1089   for (MachineFunction::iterator I = std::next(MF.begin()), E = MF.end();
1090        I != E; ++I) {
1091     if (I->pred_size() < 2) continue;
1092     SmallPtrSet<MachineBasicBlock *, 8> UniquePreds;
1093     MachineBasicBlock *IBB = &*I;
1094     MachineBasicBlock *PredBB = &*std::prev(I);
1095     MergePotentials.clear();
1096     MachineLoop *ML;
1097
1098     // Bail if merging after placement and IBB is the loop header because
1099     // -- If merging predecessors that belong to the same loop as IBB, the
1100     // common tail of merged predecessors may become the loop top if block
1101     // placement is called again and the predecessors may branch to this common
1102     // tail and require more branches. This can be relaxed if
1103     // MachineBlockPlacement::findBestLoopTop is more flexible.
1104     // --If merging predecessors that do not belong to the same loop as IBB, the
1105     // loop info of IBB's loop and the other loops may be affected. Calling the
1106     // block placement again may make big change to the layout and eliminate the
1107     // reason to do tail merging here.
1108     if (AfterBlockPlacement && MLI) {
1109       ML = MLI->getLoopFor(IBB);
1110       if (ML && IBB == ML->getHeader())
1111         continue;
1112     }
1113
1114     for (MachineBasicBlock *PBB : I->predecessors()) {
1115       if (MergePotentials.size() == TailMergeThreshold)
1116         break;
1117
1118       if (TriedMerging.count(PBB))
1119         continue;
1120
1121       // Skip blocks that loop to themselves, can't tail merge these.
1122       if (PBB == IBB)
1123         continue;
1124
1125       // Visit each predecessor only once.
1126       if (!UniquePreds.insert(PBB).second)
1127         continue;
1128
1129       // Skip blocks which may jump to a landing pad. Can't tail merge these.
1130       if (PBB->hasEHPadSuccessor())
1131         continue;
1132
1133       // After block placement, only consider predecessors that belong to the
1134       // same loop as IBB.  The reason is the same as above when skipping loop
1135       // header.
1136       if (AfterBlockPlacement && MLI)
1137         if (ML != MLI->getLoopFor(PBB))
1138           continue;
1139
1140       MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
1141       SmallVector<MachineOperand, 4> Cond;
1142       if (!TII->analyzeBranch(*PBB, TBB, FBB, Cond, true)) {
1143         // Failing case: IBB is the target of a cbr, and we cannot reverse the
1144         // branch.
1145         SmallVector<MachineOperand, 4> NewCond(Cond);
1146         if (!Cond.empty() && TBB == IBB) {
1147           if (TII->reverseBranchCondition(NewCond))
1148             continue;
1149           // This is the QBB case described above
1150           if (!FBB) {
1151             auto Next = ++PBB->getIterator();
1152             if (Next != MF.end())
1153               FBB = &*Next;
1154           }
1155         }
1156
1157         // Remove the unconditional branch at the end, if any.
1158         if (TBB && (Cond.empty() || FBB)) {
1159           DebugLoc dl = PBB->findBranchDebugLoc();
1160           TII->removeBranch(*PBB);
1161           if (!Cond.empty())
1162             // reinsert conditional branch only, for now
1163             TII->insertBranch(*PBB, (TBB == IBB) ? FBB : TBB, nullptr,
1164                               NewCond, dl);
1165         }
1166
1167         MergePotentials.push_back(MergePotentialsElt(HashEndOfMBB(*PBB), PBB));
1168       }
1169     }
1170
1171     // If this is a large problem, avoid visiting the same basic blocks multiple
1172     // times.
1173     if (MergePotentials.size() == TailMergeThreshold)
1174       for (unsigned i = 0, e = MergePotentials.size(); i != e; ++i)
1175         TriedMerging.insert(MergePotentials[i].getBlock());
1176
1177     if (MergePotentials.size() >= 2)
1178       MadeChange |= TryTailMergeBlocks(IBB, PredBB, MinCommonTailLength);
1179
1180     // Reinsert an unconditional branch if needed. The 1 below can occur as a
1181     // result of removing blocks in TryTailMergeBlocks.
1182     PredBB = &*std::prev(I); // this may have been changed in TryTailMergeBlocks
1183     if (MergePotentials.size() == 1 &&
1184         MergePotentials.begin()->getBlock() != PredBB)
1185       FixTail(MergePotentials.begin()->getBlock(), IBB, TII);
1186   }
1187
1188   return MadeChange;
1189 }
1190
1191 void BranchFolder::setCommonTailEdgeWeights(MachineBasicBlock &TailMBB) {
1192   SmallVector<BlockFrequency, 2> EdgeFreqLs(TailMBB.succ_size());
1193   BlockFrequency AccumulatedMBBFreq;
1194
1195   // Aggregate edge frequency of successor edge j:
1196   //  edgeFreq(j) = sum (freq(bb) * edgeProb(bb, j)),
1197   //  where bb is a basic block that is in SameTails.
1198   for (const auto &Src : SameTails) {
1199     const MachineBasicBlock *SrcMBB = Src.getBlock();
1200     BlockFrequency BlockFreq = MBBFreqInfo.getBlockFreq(SrcMBB);
1201     AccumulatedMBBFreq += BlockFreq;
1202
1203     // It is not necessary to recompute edge weights if TailBB has less than two
1204     // successors.
1205     if (TailMBB.succ_size() <= 1)
1206       continue;
1207
1208     auto EdgeFreq = EdgeFreqLs.begin();
1209
1210     for (auto SuccI = TailMBB.succ_begin(), SuccE = TailMBB.succ_end();
1211          SuccI != SuccE; ++SuccI, ++EdgeFreq)
1212       *EdgeFreq += BlockFreq * MBPI.getEdgeProbability(SrcMBB, *SuccI);
1213   }
1214
1215   MBBFreqInfo.setBlockFreq(&TailMBB, AccumulatedMBBFreq);
1216
1217   if (TailMBB.succ_size() <= 1)
1218     return;
1219
1220   auto SumEdgeFreq =
1221       std::accumulate(EdgeFreqLs.begin(), EdgeFreqLs.end(), BlockFrequency(0))
1222           .getFrequency();
1223   auto EdgeFreq = EdgeFreqLs.begin();
1224
1225   if (SumEdgeFreq > 0) {
1226     for (auto SuccI = TailMBB.succ_begin(), SuccE = TailMBB.succ_end();
1227          SuccI != SuccE; ++SuccI, ++EdgeFreq) {
1228       auto Prob = BranchProbability::getBranchProbability(
1229           EdgeFreq->getFrequency(), SumEdgeFreq);
1230       TailMBB.setSuccProbability(SuccI, Prob);
1231     }
1232   }
1233 }
1234
1235 //===----------------------------------------------------------------------===//
1236 //  Branch Optimization
1237 //===----------------------------------------------------------------------===//
1238
1239 bool BranchFolder::OptimizeBranches(MachineFunction &MF) {
1240   bool MadeChange = false;
1241
1242   // Make sure blocks are numbered in order
1243   MF.RenumberBlocks();
1244   // Renumbering blocks alters EH scope membership, recalculate it.
1245   EHScopeMembership = getEHScopeMembership(MF);
1246
1247   for (MachineFunction::iterator I = std::next(MF.begin()), E = MF.end();
1248        I != E; ) {
1249     MachineBasicBlock *MBB = &*I++;
1250     MadeChange |= OptimizeBlock(MBB);
1251
1252     // If it is dead, remove it.
1253     if (MBB->pred_empty()) {
1254       RemoveDeadBlock(MBB);
1255       MadeChange = true;
1256       ++NumDeadBlocks;
1257     }
1258   }
1259
1260   return MadeChange;
1261 }
1262
1263 // Blocks should be considered empty if they contain only debug info;
1264 // else the debug info would affect codegen.
1265 static bool IsEmptyBlock(MachineBasicBlock *MBB) {
1266   return MBB->getFirstNonDebugInstr() == MBB->end();
1267 }
1268
1269 // Blocks with only debug info and branches should be considered the same
1270 // as blocks with only branches.
1271 static bool IsBranchOnlyBlock(MachineBasicBlock *MBB) {
1272   MachineBasicBlock::iterator I = MBB->getFirstNonDebugInstr();
1273   assert(I != MBB->end() && "empty block!");
1274   return I->isBranch();
1275 }
1276
1277 /// IsBetterFallthrough - Return true if it would be clearly better to
1278 /// fall-through to MBB1 than to fall through into MBB2.  This has to return
1279 /// a strict ordering, returning true for both (MBB1,MBB2) and (MBB2,MBB1) will
1280 /// result in infinite loops.
1281 static bool IsBetterFallthrough(MachineBasicBlock *MBB1,
1282                                 MachineBasicBlock *MBB2) {
1283   assert(MBB1 && MBB2 && "Unknown MachineBasicBlock");
1284
1285   // Right now, we use a simple heuristic.  If MBB2 ends with a call, and
1286   // MBB1 doesn't, we prefer to fall through into MBB1.  This allows us to
1287   // optimize branches that branch to either a return block or an assert block
1288   // into a fallthrough to the return.
1289   MachineBasicBlock::iterator MBB1I = MBB1->getLastNonDebugInstr();
1290   MachineBasicBlock::iterator MBB2I = MBB2->getLastNonDebugInstr();
1291   if (MBB1I == MBB1->end() || MBB2I == MBB2->end())
1292     return false;
1293
1294   // If there is a clear successor ordering we make sure that one block
1295   // will fall through to the next
1296   if (MBB1->isSuccessor(MBB2)) return true;
1297   if (MBB2->isSuccessor(MBB1)) return false;
1298
1299   return MBB2I->isCall() && !MBB1I->isCall();
1300 }
1301
1302 /// getBranchDebugLoc - Find and return, if any, the DebugLoc of the branch
1303 /// instructions on the block.
1304 static DebugLoc getBranchDebugLoc(MachineBasicBlock &MBB) {
1305   MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
1306   if (I != MBB.end() && I->isBranch())
1307     return I->getDebugLoc();
1308   return DebugLoc();
1309 }
1310
1311 static void copyDebugInfoToPredecessor(const TargetInstrInfo *TII,
1312                                        MachineBasicBlock &MBB,
1313                                        MachineBasicBlock &PredMBB) {
1314   auto InsertBefore = PredMBB.getFirstTerminator();
1315   for (MachineInstr &MI : MBB.instrs())
1316     if (MI.isDebugInstr()) {
1317       TII->duplicate(PredMBB, InsertBefore, MI);
1318       LLVM_DEBUG(dbgs() << "Copied debug entity from empty block to pred: "
1319                         << MI);
1320     }
1321 }
1322
1323 static void copyDebugInfoToSuccessor(const TargetInstrInfo *TII,
1324                                      MachineBasicBlock &MBB,
1325                                      MachineBasicBlock &SuccMBB) {
1326   auto InsertBefore = SuccMBB.SkipPHIsAndLabels(SuccMBB.begin());
1327   for (MachineInstr &MI : MBB.instrs())
1328     if (MI.isDebugInstr()) {
1329       TII->duplicate(SuccMBB, InsertBefore, MI);
1330       LLVM_DEBUG(dbgs() << "Copied debug entity from empty block to succ: "
1331                         << MI);
1332     }
1333 }
1334
1335 // Try to salvage DBG_VALUE instructions from an otherwise empty block. If such
1336 // a basic block is removed we would lose the debug information unless we have
1337 // copied the information to a predecessor/successor.
1338 //
1339 // TODO: This function only handles some simple cases. An alternative would be
1340 // to run a heavier analysis, such as the LiveDebugValues pass, before we do
1341 // branch folding.
1342 static void salvageDebugInfoFromEmptyBlock(const TargetInstrInfo *TII,
1343                                            MachineBasicBlock &MBB) {
1344   assert(IsEmptyBlock(&MBB) && "Expected an empty block (except debug info).");
1345   // If this MBB is the only predecessor of a successor it is legal to copy
1346   // DBG_VALUE instructions to the beginning of the successor.
1347   for (MachineBasicBlock *SuccBB : MBB.successors())
1348     if (SuccBB->pred_size() == 1)
1349       copyDebugInfoToSuccessor(TII, MBB, *SuccBB);
1350   // If this MBB is the only successor of a predecessor it is legal to copy the
1351   // DBG_VALUE instructions to the end of the predecessor (just before the
1352   // terminators, assuming that the terminator isn't affecting the DBG_VALUE).
1353   for (MachineBasicBlock *PredBB : MBB.predecessors())
1354     if (PredBB->succ_size() == 1)
1355       copyDebugInfoToPredecessor(TII, MBB, *PredBB);
1356 }
1357
1358 bool BranchFolder::OptimizeBlock(MachineBasicBlock *MBB) {
1359   bool MadeChange = false;
1360   MachineFunction &MF = *MBB->getParent();
1361 ReoptimizeBlock:
1362
1363   MachineFunction::iterator FallThrough = MBB->getIterator();
1364   ++FallThrough;
1365
1366   // Make sure MBB and FallThrough belong to the same EH scope.
1367   bool SameEHScope = true;
1368   if (!EHScopeMembership.empty() && FallThrough != MF.end()) {
1369     auto MBBEHScope = EHScopeMembership.find(MBB);
1370     assert(MBBEHScope != EHScopeMembership.end());
1371     auto FallThroughEHScope = EHScopeMembership.find(&*FallThrough);
1372     assert(FallThroughEHScope != EHScopeMembership.end());
1373     SameEHScope = MBBEHScope->second == FallThroughEHScope->second;
1374   }
1375
1376   // If this block is empty, make everyone use its fall-through, not the block
1377   // explicitly.  Landing pads should not do this since the landing-pad table
1378   // points to this block.  Blocks with their addresses taken shouldn't be
1379   // optimized away.
1380   if (IsEmptyBlock(MBB) && !MBB->isEHPad() && !MBB->hasAddressTaken() &&
1381       SameEHScope) {
1382     salvageDebugInfoFromEmptyBlock(TII, *MBB);
1383     // Dead block?  Leave for cleanup later.
1384     if (MBB->pred_empty()) return MadeChange;
1385
1386     if (FallThrough == MF.end()) {
1387       // TODO: Simplify preds to not branch here if possible!
1388     } else if (FallThrough->isEHPad()) {
1389       // Don't rewrite to a landing pad fallthough.  That could lead to the case
1390       // where a BB jumps to more than one landing pad.
1391       // TODO: Is it ever worth rewriting predecessors which don't already
1392       // jump to a landing pad, and so can safely jump to the fallthrough?
1393     } else if (MBB->isSuccessor(&*FallThrough)) {
1394       // Rewrite all predecessors of the old block to go to the fallthrough
1395       // instead.
1396       while (!MBB->pred_empty()) {
1397         MachineBasicBlock *Pred = *(MBB->pred_end()-1);
1398         Pred->ReplaceUsesOfBlockWith(MBB, &*FallThrough);
1399       }
1400       // If MBB was the target of a jump table, update jump tables to go to the
1401       // fallthrough instead.
1402       if (MachineJumpTableInfo *MJTI = MF.getJumpTableInfo())
1403         MJTI->ReplaceMBBInJumpTables(MBB, &*FallThrough);
1404       MadeChange = true;
1405     }
1406     return MadeChange;
1407   }
1408
1409   // Check to see if we can simplify the terminator of the block before this
1410   // one.
1411   MachineBasicBlock &PrevBB = *std::prev(MachineFunction::iterator(MBB));
1412
1413   MachineBasicBlock *PriorTBB = nullptr, *PriorFBB = nullptr;
1414   SmallVector<MachineOperand, 4> PriorCond;
1415   bool PriorUnAnalyzable =
1416       TII->analyzeBranch(PrevBB, PriorTBB, PriorFBB, PriorCond, true);
1417   if (!PriorUnAnalyzable) {
1418     // If the CFG for the prior block has extra edges, remove them.
1419     MadeChange |= PrevBB.CorrectExtraCFGEdges(PriorTBB, PriorFBB,
1420                                               !PriorCond.empty());
1421
1422     // If the previous branch is conditional and both conditions go to the same
1423     // destination, remove the branch, replacing it with an unconditional one or
1424     // a fall-through.
1425     if (PriorTBB && PriorTBB == PriorFBB) {
1426       DebugLoc dl = getBranchDebugLoc(PrevBB);
1427       TII->removeBranch(PrevBB);
1428       PriorCond.clear();
1429       if (PriorTBB != MBB)
1430         TII->insertBranch(PrevBB, PriorTBB, nullptr, PriorCond, dl);
1431       MadeChange = true;
1432       ++NumBranchOpts;
1433       goto ReoptimizeBlock;
1434     }
1435
1436     // If the previous block unconditionally falls through to this block and
1437     // this block has no other predecessors, move the contents of this block
1438     // into the prior block. This doesn't usually happen when SimplifyCFG
1439     // has been used, but it can happen if tail merging splits a fall-through
1440     // predecessor of a block.
1441     // This has to check PrevBB->succ_size() because EH edges are ignored by
1442     // AnalyzeBranch.
1443     if (PriorCond.empty() && !PriorTBB && MBB->pred_size() == 1 &&
1444         PrevBB.succ_size() == 1 &&
1445         !MBB->hasAddressTaken() && !MBB->isEHPad()) {
1446       LLVM_DEBUG(dbgs() << "\nMerging into block: " << PrevBB
1447                         << "From MBB: " << *MBB);
1448       // Remove redundant DBG_VALUEs first.
1449       if (PrevBB.begin() != PrevBB.end()) {
1450         MachineBasicBlock::iterator PrevBBIter = PrevBB.end();
1451         --PrevBBIter;
1452         MachineBasicBlock::iterator MBBIter = MBB->begin();
1453         // Check if DBG_VALUE at the end of PrevBB is identical to the
1454         // DBG_VALUE at the beginning of MBB.
1455         while (PrevBBIter != PrevBB.begin() && MBBIter != MBB->end()
1456                && PrevBBIter->isDebugInstr() && MBBIter->isDebugInstr()) {
1457           if (!MBBIter->isIdenticalTo(*PrevBBIter))
1458             break;
1459           MachineInstr &DuplicateDbg = *MBBIter;
1460           ++MBBIter; -- PrevBBIter;
1461           DuplicateDbg.eraseFromParent();
1462         }
1463       }
1464       PrevBB.splice(PrevBB.end(), MBB, MBB->begin(), MBB->end());
1465       PrevBB.removeSuccessor(PrevBB.succ_begin());
1466       assert(PrevBB.succ_empty());
1467       PrevBB.transferSuccessors(MBB);
1468       MadeChange = true;
1469       return MadeChange;
1470     }
1471
1472     // If the previous branch *only* branches to *this* block (conditional or
1473     // not) remove the branch.
1474     if (PriorTBB == MBB && !PriorFBB) {
1475       TII->removeBranch(PrevBB);
1476       MadeChange = true;
1477       ++NumBranchOpts;
1478       goto ReoptimizeBlock;
1479     }
1480
1481     // If the prior block branches somewhere else on the condition and here if
1482     // the condition is false, remove the uncond second branch.
1483     if (PriorFBB == MBB) {
1484       DebugLoc dl = getBranchDebugLoc(PrevBB);
1485       TII->removeBranch(PrevBB);
1486       TII->insertBranch(PrevBB, PriorTBB, nullptr, PriorCond, dl);
1487       MadeChange = true;
1488       ++NumBranchOpts;
1489       goto ReoptimizeBlock;
1490     }
1491
1492     // If the prior block branches here on true and somewhere else on false, and
1493     // if the branch condition is reversible, reverse the branch to create a
1494     // fall-through.
1495     if (PriorTBB == MBB) {
1496       SmallVector<MachineOperand, 4> NewPriorCond(PriorCond);
1497       if (!TII->reverseBranchCondition(NewPriorCond)) {
1498         DebugLoc dl = getBranchDebugLoc(PrevBB);
1499         TII->removeBranch(PrevBB);
1500         TII->insertBranch(PrevBB, PriorFBB, nullptr, NewPriorCond, dl);
1501         MadeChange = true;
1502         ++NumBranchOpts;
1503         goto ReoptimizeBlock;
1504       }
1505     }
1506
1507     // If this block has no successors (e.g. it is a return block or ends with
1508     // a call to a no-return function like abort or __cxa_throw) and if the pred
1509     // falls through into this block, and if it would otherwise fall through
1510     // into the block after this, move this block to the end of the function.
1511     //
1512     // We consider it more likely that execution will stay in the function (e.g.
1513     // due to loops) than it is to exit it.  This asserts in loops etc, moving
1514     // the assert condition out of the loop body.
1515     if (MBB->succ_empty() && !PriorCond.empty() && !PriorFBB &&
1516         MachineFunction::iterator(PriorTBB) == FallThrough &&
1517         !MBB->canFallThrough()) {
1518       bool DoTransform = true;
1519
1520       // We have to be careful that the succs of PredBB aren't both no-successor
1521       // blocks.  If neither have successors and if PredBB is the second from
1522       // last block in the function, we'd just keep swapping the two blocks for
1523       // last.  Only do the swap if one is clearly better to fall through than
1524       // the other.
1525       if (FallThrough == --MF.end() &&
1526           !IsBetterFallthrough(PriorTBB, MBB))
1527         DoTransform = false;
1528
1529       if (DoTransform) {
1530         // Reverse the branch so we will fall through on the previous true cond.
1531         SmallVector<MachineOperand, 4> NewPriorCond(PriorCond);
1532         if (!TII->reverseBranchCondition(NewPriorCond)) {
1533           LLVM_DEBUG(dbgs() << "\nMoving MBB: " << *MBB
1534                             << "To make fallthrough to: " << *PriorTBB << "\n");
1535
1536           DebugLoc dl = getBranchDebugLoc(PrevBB);
1537           TII->removeBranch(PrevBB);
1538           TII->insertBranch(PrevBB, MBB, nullptr, NewPriorCond, dl);
1539
1540           // Move this block to the end of the function.
1541           MBB->moveAfter(&MF.back());
1542           MadeChange = true;
1543           ++NumBranchOpts;
1544           return MadeChange;
1545         }
1546       }
1547     }
1548   }
1549
1550   bool OptForSize =
1551       MF.getFunction().hasOptSize() ||
1552       llvm::shouldOptimizeForSize(MBB, PSI, &MBBFreqInfo.getMBFI());
1553   if (!IsEmptyBlock(MBB) && MBB->pred_size() == 1 && OptForSize) {
1554     // Changing "Jcc foo; foo: jmp bar;" into "Jcc bar;" might change the branch
1555     // direction, thereby defeating careful block placement and regressing
1556     // performance. Therefore, only consider this for optsize functions.
1557     MachineInstr &TailCall = *MBB->getFirstNonDebugInstr();
1558     if (TII->isUnconditionalTailCall(TailCall)) {
1559       MachineBasicBlock *Pred = *MBB->pred_begin();
1560       MachineBasicBlock *PredTBB = nullptr, *PredFBB = nullptr;
1561       SmallVector<MachineOperand, 4> PredCond;
1562       bool PredAnalyzable =
1563           !TII->analyzeBranch(*Pred, PredTBB, PredFBB, PredCond, true);
1564
1565       if (PredAnalyzable && !PredCond.empty() && PredTBB == MBB &&
1566           PredTBB != PredFBB) {
1567         // The predecessor has a conditional branch to this block which consists
1568         // of only a tail call. Try to fold the tail call into the conditional
1569         // branch.
1570         if (TII->canMakeTailCallConditional(PredCond, TailCall)) {
1571           // TODO: It would be nice if analyzeBranch() could provide a pointer
1572           // to the branch instruction so replaceBranchWithTailCall() doesn't
1573           // have to search for it.
1574           TII->replaceBranchWithTailCall(*Pred, PredCond, TailCall);
1575           ++NumTailCalls;
1576           Pred->removeSuccessor(MBB);
1577           MadeChange = true;
1578           return MadeChange;
1579         }
1580       }
1581       // If the predecessor is falling through to this block, we could reverse
1582       // the branch condition and fold the tail call into that. However, after
1583       // that we might have to re-arrange the CFG to fall through to the other
1584       // block and there is a high risk of regressing code size rather than
1585       // improving it.
1586     }
1587   }
1588
1589   // Analyze the branch in the current block.
1590   MachineBasicBlock *CurTBB = nullptr, *CurFBB = nullptr;
1591   SmallVector<MachineOperand, 4> CurCond;
1592   bool CurUnAnalyzable =
1593       TII->analyzeBranch(*MBB, CurTBB, CurFBB, CurCond, true);
1594   if (!CurUnAnalyzable) {
1595     // If the CFG for the prior block has extra edges, remove them.
1596     MadeChange |= MBB->CorrectExtraCFGEdges(CurTBB, CurFBB, !CurCond.empty());
1597
1598     // If this is a two-way branch, and the FBB branches to this block, reverse
1599     // the condition so the single-basic-block loop is faster.  Instead of:
1600     //    Loop: xxx; jcc Out; jmp Loop
1601     // we want:
1602     //    Loop: xxx; jncc Loop; jmp Out
1603     if (CurTBB && CurFBB && CurFBB == MBB && CurTBB != MBB) {
1604       SmallVector<MachineOperand, 4> NewCond(CurCond);
1605       if (!TII->reverseBranchCondition(NewCond)) {
1606         DebugLoc dl = getBranchDebugLoc(*MBB);
1607         TII->removeBranch(*MBB);
1608         TII->insertBranch(*MBB, CurFBB, CurTBB, NewCond, dl);
1609         MadeChange = true;
1610         ++NumBranchOpts;
1611         goto ReoptimizeBlock;
1612       }
1613     }
1614
1615     // If this branch is the only thing in its block, see if we can forward
1616     // other blocks across it.
1617     if (CurTBB && CurCond.empty() && !CurFBB &&
1618         IsBranchOnlyBlock(MBB) && CurTBB != MBB &&
1619         !MBB->hasAddressTaken() && !MBB->isEHPad()) {
1620       DebugLoc dl = getBranchDebugLoc(*MBB);
1621       // This block may contain just an unconditional branch.  Because there can
1622       // be 'non-branch terminators' in the block, try removing the branch and
1623       // then seeing if the block is empty.
1624       TII->removeBranch(*MBB);
1625       // If the only things remaining in the block are debug info, remove these
1626       // as well, so this will behave the same as an empty block in non-debug
1627       // mode.
1628       if (IsEmptyBlock(MBB)) {
1629         // Make the block empty, losing the debug info (we could probably
1630         // improve this in some cases.)
1631         MBB->erase(MBB->begin(), MBB->end());
1632       }
1633       // If this block is just an unconditional branch to CurTBB, we can
1634       // usually completely eliminate the block.  The only case we cannot
1635       // completely eliminate the block is when the block before this one
1636       // falls through into MBB and we can't understand the prior block's branch
1637       // condition.
1638       if (MBB->empty()) {
1639         bool PredHasNoFallThrough = !PrevBB.canFallThrough();
1640         if (PredHasNoFallThrough || !PriorUnAnalyzable ||
1641             !PrevBB.isSuccessor(MBB)) {
1642           // If the prior block falls through into us, turn it into an
1643           // explicit branch to us to make updates simpler.
1644           if (!PredHasNoFallThrough && PrevBB.isSuccessor(MBB) &&
1645               PriorTBB != MBB && PriorFBB != MBB) {
1646             if (!PriorTBB) {
1647               assert(PriorCond.empty() && !PriorFBB &&
1648                      "Bad branch analysis");
1649               PriorTBB = MBB;
1650             } else {
1651               assert(!PriorFBB && "Machine CFG out of date!");
1652               PriorFBB = MBB;
1653             }
1654             DebugLoc pdl = getBranchDebugLoc(PrevBB);
1655             TII->removeBranch(PrevBB);
1656             TII->insertBranch(PrevBB, PriorTBB, PriorFBB, PriorCond, pdl);
1657           }
1658
1659           // Iterate through all the predecessors, revectoring each in-turn.
1660           size_t PI = 0;
1661           bool DidChange = false;
1662           bool HasBranchToSelf = false;
1663           while(PI != MBB->pred_size()) {
1664             MachineBasicBlock *PMBB = *(MBB->pred_begin() + PI);
1665             if (PMBB == MBB) {
1666               // If this block has an uncond branch to itself, leave it.
1667               ++PI;
1668               HasBranchToSelf = true;
1669             } else {
1670               DidChange = true;
1671               PMBB->ReplaceUsesOfBlockWith(MBB, CurTBB);
1672               // If this change resulted in PMBB ending in a conditional
1673               // branch where both conditions go to the same destination,
1674               // change this to an unconditional branch (and fix the CFG).
1675               MachineBasicBlock *NewCurTBB = nullptr, *NewCurFBB = nullptr;
1676               SmallVector<MachineOperand, 4> NewCurCond;
1677               bool NewCurUnAnalyzable = TII->analyzeBranch(
1678                   *PMBB, NewCurTBB, NewCurFBB, NewCurCond, true);
1679               if (!NewCurUnAnalyzable && NewCurTBB && NewCurTBB == NewCurFBB) {
1680                 DebugLoc pdl = getBranchDebugLoc(*PMBB);
1681                 TII->removeBranch(*PMBB);
1682                 NewCurCond.clear();
1683                 TII->insertBranch(*PMBB, NewCurTBB, nullptr, NewCurCond, pdl);
1684                 MadeChange = true;
1685                 ++NumBranchOpts;
1686                 PMBB->CorrectExtraCFGEdges(NewCurTBB, nullptr, false);
1687               }
1688             }
1689           }
1690
1691           // Change any jumptables to go to the new MBB.
1692           if (MachineJumpTableInfo *MJTI = MF.getJumpTableInfo())
1693             MJTI->ReplaceMBBInJumpTables(MBB, CurTBB);
1694           if (DidChange) {
1695             ++NumBranchOpts;
1696             MadeChange = true;
1697             if (!HasBranchToSelf) return MadeChange;
1698           }
1699         }
1700       }
1701
1702       // Add the branch back if the block is more than just an uncond branch.
1703       TII->insertBranch(*MBB, CurTBB, nullptr, CurCond, dl);
1704     }
1705   }
1706
1707   // If the prior block doesn't fall through into this block, and if this
1708   // block doesn't fall through into some other block, see if we can find a
1709   // place to move this block where a fall-through will happen.
1710   if (!PrevBB.canFallThrough()) {
1711     // Now we know that there was no fall-through into this block, check to
1712     // see if it has a fall-through into its successor.
1713     bool CurFallsThru = MBB->canFallThrough();
1714
1715     if (!MBB->isEHPad()) {
1716       // Check all the predecessors of this block.  If one of them has no fall
1717       // throughs, move this block right after it.
1718       for (MachineBasicBlock *PredBB : MBB->predecessors()) {
1719         // Analyze the branch at the end of the pred.
1720         MachineBasicBlock *PredTBB = nullptr, *PredFBB = nullptr;
1721         SmallVector<MachineOperand, 4> PredCond;
1722         if (PredBB != MBB && !PredBB->canFallThrough() &&
1723             !TII->analyzeBranch(*PredBB, PredTBB, PredFBB, PredCond, true) &&
1724             (!CurFallsThru || !CurTBB || !CurFBB) &&
1725             (!CurFallsThru || MBB->getNumber() >= PredBB->getNumber())) {
1726           // If the current block doesn't fall through, just move it.
1727           // If the current block can fall through and does not end with a
1728           // conditional branch, we need to append an unconditional jump to
1729           // the (current) next block.  To avoid a possible compile-time
1730           // infinite loop, move blocks only backward in this case.
1731           // Also, if there are already 2 branches here, we cannot add a third;
1732           // this means we have the case
1733           // Bcc next
1734           // B elsewhere
1735           // next:
1736           if (CurFallsThru) {
1737             MachineBasicBlock *NextBB = &*std::next(MBB->getIterator());
1738             CurCond.clear();
1739             TII->insertBranch(*MBB, NextBB, nullptr, CurCond, DebugLoc());
1740           }
1741           MBB->moveAfter(PredBB);
1742           MadeChange = true;
1743           goto ReoptimizeBlock;
1744         }
1745       }
1746     }
1747
1748     if (!CurFallsThru) {
1749       // Check all successors to see if we can move this block before it.
1750       for (MachineBasicBlock *SuccBB : MBB->successors()) {
1751         // Analyze the branch at the end of the block before the succ.
1752         MachineFunction::iterator SuccPrev = --SuccBB->getIterator();
1753
1754         // If this block doesn't already fall-through to that successor, and if
1755         // the succ doesn't already have a block that can fall through into it,
1756         // and if the successor isn't an EH destination, we can arrange for the
1757         // fallthrough to happen.
1758         if (SuccBB != MBB && &*SuccPrev != MBB &&
1759             !SuccPrev->canFallThrough() && !CurUnAnalyzable &&
1760             !SuccBB->isEHPad()) {
1761           MBB->moveBefore(SuccBB);
1762           MadeChange = true;
1763           goto ReoptimizeBlock;
1764         }
1765       }
1766
1767       // Okay, there is no really great place to put this block.  If, however,
1768       // the block before this one would be a fall-through if this block were
1769       // removed, move this block to the end of the function. There is no real
1770       // advantage in "falling through" to an EH block, so we don't want to
1771       // perform this transformation for that case.
1772       //
1773       // Also, Windows EH introduced the possibility of an arbitrary number of
1774       // successors to a given block.  The analyzeBranch call does not consider
1775       // exception handling and so we can get in a state where a block
1776       // containing a call is followed by multiple EH blocks that would be
1777       // rotated infinitely at the end of the function if the transformation
1778       // below were performed for EH "FallThrough" blocks.  Therefore, even if
1779       // that appears not to be happening anymore, we should assume that it is
1780       // possible and not remove the "!FallThrough()->isEHPad" condition below.
1781       MachineBasicBlock *PrevTBB = nullptr, *PrevFBB = nullptr;
1782       SmallVector<MachineOperand, 4> PrevCond;
1783       if (FallThrough != MF.end() &&
1784           !FallThrough->isEHPad() &&
1785           !TII->analyzeBranch(PrevBB, PrevTBB, PrevFBB, PrevCond, true) &&
1786           PrevBB.isSuccessor(&*FallThrough)) {
1787         MBB->moveAfter(&MF.back());
1788         MadeChange = true;
1789         return MadeChange;
1790       }
1791     }
1792   }
1793
1794   return MadeChange;
1795 }
1796
1797 //===----------------------------------------------------------------------===//
1798 //  Hoist Common Code
1799 //===----------------------------------------------------------------------===//
1800
1801 bool BranchFolder::HoistCommonCode(MachineFunction &MF) {
1802   bool MadeChange = false;
1803   for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ) {
1804     MachineBasicBlock *MBB = &*I++;
1805     MadeChange |= HoistCommonCodeInSuccs(MBB);
1806   }
1807
1808   return MadeChange;
1809 }
1810
1811 /// findFalseBlock - BB has a fallthrough. Find its 'false' successor given
1812 /// its 'true' successor.
1813 static MachineBasicBlock *findFalseBlock(MachineBasicBlock *BB,
1814                                          MachineBasicBlock *TrueBB) {
1815   for (MachineBasicBlock *SuccBB : BB->successors())
1816     if (SuccBB != TrueBB)
1817       return SuccBB;
1818   return nullptr;
1819 }
1820
1821 template <class Container>
1822 static void addRegAndItsAliases(unsigned Reg, const TargetRegisterInfo *TRI,
1823                                 Container &Set) {
1824   if (Register::isPhysicalRegister(Reg)) {
1825     for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI)
1826       Set.insert(*AI);
1827   } else {
1828     Set.insert(Reg);
1829   }
1830 }
1831
1832 /// findHoistingInsertPosAndDeps - Find the location to move common instructions
1833 /// in successors to. The location is usually just before the terminator,
1834 /// however if the terminator is a conditional branch and its previous
1835 /// instruction is the flag setting instruction, the previous instruction is
1836 /// the preferred location. This function also gathers uses and defs of the
1837 /// instructions from the insertion point to the end of the block. The data is
1838 /// used by HoistCommonCodeInSuccs to ensure safety.
1839 static
1840 MachineBasicBlock::iterator findHoistingInsertPosAndDeps(MachineBasicBlock *MBB,
1841                                                   const TargetInstrInfo *TII,
1842                                                   const TargetRegisterInfo *TRI,
1843                                                   SmallSet<unsigned,4> &Uses,
1844                                                   SmallSet<unsigned,4> &Defs) {
1845   MachineBasicBlock::iterator Loc = MBB->getFirstTerminator();
1846   if (!TII->isUnpredicatedTerminator(*Loc))
1847     return MBB->end();
1848
1849   for (const MachineOperand &MO : Loc->operands()) {
1850     if (!MO.isReg())
1851       continue;
1852     Register Reg = MO.getReg();
1853     if (!Reg)
1854       continue;
1855     if (MO.isUse()) {
1856       addRegAndItsAliases(Reg, TRI, Uses);
1857     } else {
1858       if (!MO.isDead())
1859         // Don't try to hoist code in the rare case the terminator defines a
1860         // register that is later used.
1861         return MBB->end();
1862
1863       // If the terminator defines a register, make sure we don't hoist
1864       // the instruction whose def might be clobbered by the terminator.
1865       addRegAndItsAliases(Reg, TRI, Defs);
1866     }
1867   }
1868
1869   if (Uses.empty())
1870     return Loc;
1871   // If the terminator is the only instruction in the block and Uses is not
1872   // empty (or we would have returned above), we can still safely hoist
1873   // instructions just before the terminator as long as the Defs/Uses are not
1874   // violated (which is checked in HoistCommonCodeInSuccs).
1875   if (Loc == MBB->begin())
1876     return Loc;
1877
1878   // The terminator is probably a conditional branch, try not to separate the
1879   // branch from condition setting instruction.
1880   MachineBasicBlock::iterator PI =
1881     skipDebugInstructionsBackward(std::prev(Loc), MBB->begin());
1882
1883   bool IsDef = false;
1884   for (const MachineOperand &MO : PI->operands()) {
1885     // If PI has a regmask operand, it is probably a call. Separate away.
1886     if (MO.isRegMask())
1887       return Loc;
1888     if (!MO.isReg() || MO.isUse())
1889       continue;
1890     Register Reg = MO.getReg();
1891     if (!Reg)
1892       continue;
1893     if (Uses.count(Reg)) {
1894       IsDef = true;
1895       break;
1896     }
1897   }
1898   if (!IsDef)
1899     // The condition setting instruction is not just before the conditional
1900     // branch.
1901     return Loc;
1902
1903   // Be conservative, don't insert instruction above something that may have
1904   // side-effects. And since it's potentially bad to separate flag setting
1905   // instruction from the conditional branch, just abort the optimization
1906   // completely.
1907   // Also avoid moving code above predicated instruction since it's hard to
1908   // reason about register liveness with predicated instruction.
1909   bool DontMoveAcrossStore = true;
1910   if (!PI->isSafeToMove(nullptr, DontMoveAcrossStore) || TII->isPredicated(*PI))
1911     return MBB->end();
1912
1913   // Find out what registers are live. Note this routine is ignoring other live
1914   // registers which are only used by instructions in successor blocks.
1915   for (const MachineOperand &MO : PI->operands()) {
1916     if (!MO.isReg())
1917       continue;
1918     Register Reg = MO.getReg();
1919     if (!Reg)
1920       continue;
1921     if (MO.isUse()) {
1922       addRegAndItsAliases(Reg, TRI, Uses);
1923     } else {
1924       if (Uses.erase(Reg)) {
1925         if (Register::isPhysicalRegister(Reg)) {
1926           for (MCSubRegIterator SubRegs(Reg, TRI); SubRegs.isValid(); ++SubRegs)
1927             Uses.erase(*SubRegs); // Use sub-registers to be conservative
1928         }
1929       }
1930       addRegAndItsAliases(Reg, TRI, Defs);
1931     }
1932   }
1933
1934   return PI;
1935 }
1936
1937 bool BranchFolder::HoistCommonCodeInSuccs(MachineBasicBlock *MBB) {
1938   MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
1939   SmallVector<MachineOperand, 4> Cond;
1940   if (TII->analyzeBranch(*MBB, TBB, FBB, Cond, true) || !TBB || Cond.empty())
1941     return false;
1942
1943   if (!FBB) FBB = findFalseBlock(MBB, TBB);
1944   if (!FBB)
1945     // Malformed bcc? True and false blocks are the same?
1946     return false;
1947
1948   // Restrict the optimization to cases where MBB is the only predecessor,
1949   // it is an obvious win.
1950   if (TBB->pred_size() > 1 || FBB->pred_size() > 1)
1951     return false;
1952
1953   // Find a suitable position to hoist the common instructions to. Also figure
1954   // out which registers are used or defined by instructions from the insertion
1955   // point to the end of the block.
1956   SmallSet<unsigned, 4> Uses, Defs;
1957   MachineBasicBlock::iterator Loc =
1958     findHoistingInsertPosAndDeps(MBB, TII, TRI, Uses, Defs);
1959   if (Loc == MBB->end())
1960     return false;
1961
1962   bool HasDups = false;
1963   SmallSet<unsigned, 4> ActiveDefsSet, AllDefsSet;
1964   MachineBasicBlock::iterator TIB = TBB->begin();
1965   MachineBasicBlock::iterator FIB = FBB->begin();
1966   MachineBasicBlock::iterator TIE = TBB->end();
1967   MachineBasicBlock::iterator FIE = FBB->end();
1968   while (TIB != TIE && FIB != FIE) {
1969     // Skip dbg_value instructions. These do not count.
1970     TIB = skipDebugInstructionsForward(TIB, TIE);
1971     FIB = skipDebugInstructionsForward(FIB, FIE);
1972     if (TIB == TIE || FIB == FIE)
1973       break;
1974
1975     if (!TIB->isIdenticalTo(*FIB, MachineInstr::CheckKillDead))
1976       break;
1977
1978     if (TII->isPredicated(*TIB))
1979       // Hard to reason about register liveness with predicated instruction.
1980       break;
1981
1982     bool IsSafe = true;
1983     for (MachineOperand &MO : TIB->operands()) {
1984       // Don't attempt to hoist instructions with register masks.
1985       if (MO.isRegMask()) {
1986         IsSafe = false;
1987         break;
1988       }
1989       if (!MO.isReg())
1990         continue;
1991       Register Reg = MO.getReg();
1992       if (!Reg)
1993         continue;
1994       if (MO.isDef()) {
1995         if (Uses.count(Reg)) {
1996           // Avoid clobbering a register that's used by the instruction at
1997           // the point of insertion.
1998           IsSafe = false;
1999           break;
2000         }
2001
2002         if (Defs.count(Reg) && !MO.isDead()) {
2003           // Don't hoist the instruction if the def would be clobber by the
2004           // instruction at the point insertion. FIXME: This is overly
2005           // conservative. It should be possible to hoist the instructions
2006           // in BB2 in the following example:
2007           // BB1:
2008           // r1, eflag = op1 r2, r3
2009           // brcc eflag
2010           //
2011           // BB2:
2012           // r1 = op2, ...
2013           //    = op3, killed r1
2014           IsSafe = false;
2015           break;
2016         }
2017       } else if (!ActiveDefsSet.count(Reg)) {
2018         if (Defs.count(Reg)) {
2019           // Use is defined by the instruction at the point of insertion.
2020           IsSafe = false;
2021           break;
2022         }
2023
2024         if (MO.isKill() && Uses.count(Reg))
2025           // Kills a register that's read by the instruction at the point of
2026           // insertion. Remove the kill marker.
2027           MO.setIsKill(false);
2028       }
2029     }
2030     if (!IsSafe)
2031       break;
2032
2033     bool DontMoveAcrossStore = true;
2034     if (!TIB->isSafeToMove(nullptr, DontMoveAcrossStore))
2035       break;
2036
2037     // Remove kills from ActiveDefsSet, these registers had short live ranges.
2038     for (const MachineOperand &MO : TIB->operands()) {
2039       if (!MO.isReg() || !MO.isUse() || !MO.isKill())
2040         continue;
2041       Register Reg = MO.getReg();
2042       if (!Reg)
2043         continue;
2044       if (!AllDefsSet.count(Reg)) {
2045         continue;
2046       }
2047       if (Register::isPhysicalRegister(Reg)) {
2048         for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI)
2049           ActiveDefsSet.erase(*AI);
2050       } else {
2051         ActiveDefsSet.erase(Reg);
2052       }
2053     }
2054
2055     // Track local defs so we can update liveins.
2056     for (const MachineOperand &MO : TIB->operands()) {
2057       if (!MO.isReg() || !MO.isDef() || MO.isDead())
2058         continue;
2059       Register Reg = MO.getReg();
2060       if (!Reg || Register::isVirtualRegister(Reg))
2061         continue;
2062       addRegAndItsAliases(Reg, TRI, ActiveDefsSet);
2063       addRegAndItsAliases(Reg, TRI, AllDefsSet);
2064     }
2065
2066     HasDups = true;
2067     ++TIB;
2068     ++FIB;
2069   }
2070
2071   if (!HasDups)
2072     return false;
2073
2074   MBB->splice(Loc, TBB, TBB->begin(), TIB);
2075   FBB->erase(FBB->begin(), FIB);
2076
2077   if (UpdateLiveIns) {
2078     recomputeLiveIns(*TBB);
2079     recomputeLiveIns(*FBB);
2080   }
2081
2082   ++NumHoist;
2083   return true;
2084 }