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 not the entry
 967     // block, which we can't jump to), we can treat all blocks with this same
 968     // tail at once.  Use PredBB if that is one of the possibilities, as that
 969     // 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())
 978       commonTailIndex = 1;
 979     else if (SameTails.size() == 2 &&
 980              SameTails[1].getBlock()->isLayoutSuccessor(
 981                                                      SameTails[0].getBlock()) &&
 982              SameTails[0].tailIsWholeBlock())
 983       commonTailIndex = 0;
 984     else {
 985       // Otherwise just pick one, favoring the fall-through predecessor if
 986       // there is one.
 987       for (unsigned i = 0, e = SameTails.size(); i != e; ++i) {
 988         MachineBasicBlock *MBB = SameTails[i].getBlock();
 989         if (MBB == EntryBB && SameTails[i].tailIsWholeBlock())
 990           continue;
 991         if (MBB == PredBB) {
 992           commonTailIndex = i;
 993           break;
 994         }
 995         if (SameTails[i].tailIsWholeBlock())
 996           commonTailIndex = i;
 997       }
 998     }
 999
1000     if (commonTailIndex == SameTails.size() ||
1001         (SameTails[commonTailIndex].getBlock() == PredBB &&
1002          !SameTails[commonTailIndex].tailIsWholeBlock())) {
1003       // None of the blocks consist entirely of the common tail.
1004       // Split a block so that one does.
1005       if (!CreateCommonTailOnlyBlock(PredBB, SuccBB,
1006                                      maxCommonTailLength, commonTailIndex)) {
1007         RemoveBlocksWithHash(CurHash, SuccBB, PredBB);
1008         continue;
1009       }
1010     }
1011
1012     MachineBasicBlock *MBB = SameTails[commonTailIndex].getBlock();
1013
1014     // Recompute common tail MBB's edge weights and block frequency.
1015     setCommonTailEdgeWeights(*MBB);
1016
1017     // Merge debug locations, MMOs and undef flags across identical instructions
1018     // for common tail.
1019     mergeCommonTails(commonTailIndex);
1020
1021     // MBB is common tail.  Adjust all other BB's to jump to this one.
1022     // Traversal must be forwards so erases work.
1023     LLVM_DEBUG(dbgs() << "\nUsing common tail in " << printMBBReference(*MBB)
1024                       << " for ");
1025     for (unsigned int i=0, e = SameTails.size(); i != e; ++i) {
1026       if (commonTailIndex == i)
1027         continue;
1028       LLVM_DEBUG(dbgs() << printMBBReference(*SameTails[i].getBlock())
1029                         << (i == e - 1 ? "" : ", "));
1030       // Hack the end off BB i, making it jump to BB commonTailIndex instead.
1031       replaceTailWithBranchTo(SameTails[i].getTailStartPos(), *MBB);
1032       // BB i is no longer a predecessor of SuccBB; remove it from the worklist.
1033       MergePotentials.erase(SameTails[i].getMPIter());
1034     }
1035     LLVM_DEBUG(dbgs() << "\n");
1036     // We leave commonTailIndex in the worklist in case there are other blocks
1037     // that match it with a smaller number of instructions.
1038     MadeChange = true;
1039   }
1040   return MadeChange;
1041 }
1042
1043 bool BranchFolder::TailMergeBlocks(MachineFunction &MF) {
1044   bool MadeChange = false;
1045   if (!EnableTailMerge)
1046     return MadeChange;
1047
1048   // First find blocks with no successors.
1049   // Block placement may create new tail merging opportunities for these blocks.
1050   MergePotentials.clear();
1051   for (MachineBasicBlock &MBB : MF) {
1052     if (MergePotentials.size() == TailMergeThreshold)
1053       break;
1054     if (!TriedMerging.count(&MBB) && MBB.succ_empty())
1055       MergePotentials.push_back(MergePotentialsElt(HashEndOfMBB(MBB), &MBB));
1056   }
1057
1058   // If this is a large problem, avoid visiting the same basic blocks
1059   // multiple times.
1060   if (MergePotentials.size() == TailMergeThreshold)
1061     for (unsigned i = 0, e = MergePotentials.size(); i != e; ++i)
1062       TriedMerging.insert(MergePotentials[i].getBlock());
1063
1064   // See if we can do any tail merging on those.
1065   if (MergePotentials.size() >= 2)
1066     MadeChange |= TryTailMergeBlocks(nullptr, nullptr, MinCommonTailLength);
1067
1068   // Look at blocks (IBB) with multiple predecessors (PBB).
1069   // We change each predecessor to a canonical form, by
1070   // (1) temporarily removing any unconditional branch from the predecessor
1071   // to IBB, and
1072   // (2) alter conditional branches so they branch to the other block
1073   // not IBB; this may require adding back an unconditional branch to IBB
1074   // later, where there wasn't one coming in.  E.g.
1075   //   Bcc IBB
1076   //   fallthrough to QBB
1077   // here becomes
1078   //   Bncc QBB
1079   // with a conceptual B to IBB after that, which never actually exists.
1080   // With those changes, we see whether the predecessors' tails match,
1081   // and merge them if so.  We change things out of canonical form and
1082   // back to the way they were later in the process.  (OptimizeBranches
1083   // would undo some of this, but we can't use it, because we'd get into
1084   // a compile-time infinite loop repeatedly doing and undoing the same
1085   // transformations.)
1086
1087   for (MachineFunction::iterator I = std::next(MF.begin()), E = MF.end();
1088        I != E; ++I) {
1089     if (I->pred_size() < 2) continue;
1090     SmallPtrSet<MachineBasicBlock *, 8> UniquePreds;
1091     MachineBasicBlock *IBB = &*I;
1092     MachineBasicBlock *PredBB = &*std::prev(I);
1093     MergePotentials.clear();
1094     MachineLoop *ML;
1095
1096     // Bail if merging after placement and IBB is the loop header because
1097     // -- If merging predecessors that belong to the same loop as IBB, the
1098     // common tail of merged predecessors may become the loop top if block
1099     // placement is called again and the predecessors may branch to this common
1100     // tail and require more branches. This can be relaxed if
1101     // MachineBlockPlacement::findBestLoopTop is more flexible.
1102     // --If merging predecessors that do not belong to the same loop as IBB, the
1103     // loop info of IBB's loop and the other loops may be affected. Calling the
1104     // block placement again may make big change to the layout and eliminate the
1105     // reason to do tail merging here.
1106     if (AfterBlockPlacement && MLI) {
1107       ML = MLI->getLoopFor(IBB);
1108       if (ML && IBB == ML->getHeader())
1109         continue;
1110     }
1111
1112     for (MachineBasicBlock *PBB : I->predecessors()) {
1113       if (MergePotentials.size() == TailMergeThreshold)
1114         break;
1115
1116       if (TriedMerging.count(PBB))
1117         continue;
1118
1119       // Skip blocks that loop to themselves, can't tail merge these.
1120       if (PBB == IBB)
1121         continue;
1122
1123       // Visit each predecessor only once.
1124       if (!UniquePreds.insert(PBB).second)
1125         continue;
1126
1127       // Skip blocks which may jump to a landing pad. Can't tail merge these.
1128       if (PBB->hasEHPadSuccessor())
1129         continue;
1130
1131       // After block placement, only consider predecessors that belong to the
1132       // same loop as IBB.  The reason is the same as above when skipping loop
1133       // header.
1134       if (AfterBlockPlacement && MLI)
1135         if (ML != MLI->getLoopFor(PBB))
1136           continue;
1137
1138       MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
1139       SmallVector<MachineOperand, 4> Cond;
1140       if (!TII->analyzeBranch(*PBB, TBB, FBB, Cond, true)) {
1141         // Failing case: IBB is the target of a cbr, and we cannot reverse the
1142         // branch.
1143         SmallVector<MachineOperand, 4> NewCond(Cond);
1144         if (!Cond.empty() && TBB == IBB) {
1145           if (TII->reverseBranchCondition(NewCond))
1146             continue;
1147           // This is the QBB case described above
1148           if (!FBB) {
1149             auto Next = ++PBB->getIterator();
1150             if (Next != MF.end())
1151               FBB = &*Next;
1152           }
1153         }
1154
1155         // Remove the unconditional branch at the end, if any.
1156         if (TBB && (Cond.empty() || FBB)) {
1157           DebugLoc dl = PBB->findBranchDebugLoc();
1158           TII->removeBranch(*PBB);
1159           if (!Cond.empty())
1160             // reinsert conditional branch only, for now
1161             TII->insertBranch(*PBB, (TBB == IBB) ? FBB : TBB, nullptr,
1162                               NewCond, dl);
1163         }
1164
1165         MergePotentials.push_back(MergePotentialsElt(HashEndOfMBB(*PBB), PBB));
1166       }
1167     }
1168
1169     // If this is a large problem, avoid visiting the same basic blocks multiple
1170     // times.
1171     if (MergePotentials.size() == TailMergeThreshold)
1172       for (unsigned i = 0, e = MergePotentials.size(); i != e; ++i)
1173         TriedMerging.insert(MergePotentials[i].getBlock());
1174
1175     if (MergePotentials.size() >= 2)
1176       MadeChange |= TryTailMergeBlocks(IBB, PredBB, MinCommonTailLength);
1177
1178     // Reinsert an unconditional branch if needed. The 1 below can occur as a
1179     // result of removing blocks in TryTailMergeBlocks.
1180     PredBB = &*std::prev(I); // this may have been changed in TryTailMergeBlocks
1181     if (MergePotentials.size() == 1 &&
1182         MergePotentials.begin()->getBlock() != PredBB)
1183       FixTail(MergePotentials.begin()->getBlock(), IBB, TII);
1184   }
1185
1186   return MadeChange;
1187 }
1188
1189 void BranchFolder::setCommonTailEdgeWeights(MachineBasicBlock &TailMBB) {
1190   SmallVector<BlockFrequency, 2> EdgeFreqLs(TailMBB.succ_size());
1191   BlockFrequency AccumulatedMBBFreq;
1192
1193   // Aggregate edge frequency of successor edge j:
1194   //  edgeFreq(j) = sum (freq(bb) * edgeProb(bb, j)),
1195   //  where bb is a basic block that is in SameTails.
1196   for (const auto &Src : SameTails) {
1197     const MachineBasicBlock *SrcMBB = Src.getBlock();
1198     BlockFrequency BlockFreq = MBBFreqInfo.getBlockFreq(SrcMBB);
1199     AccumulatedMBBFreq += BlockFreq;
1200
1201     // It is not necessary to recompute edge weights if TailBB has less than two
1202     // successors.
1203     if (TailMBB.succ_size() <= 1)
1204       continue;
1205
1206     auto EdgeFreq = EdgeFreqLs.begin();
1207
1208     for (auto SuccI = TailMBB.succ_begin(), SuccE = TailMBB.succ_end();
1209          SuccI != SuccE; ++SuccI, ++EdgeFreq)
1210       *EdgeFreq += BlockFreq * MBPI.getEdgeProbability(SrcMBB, *SuccI);
1211   }
1212
1213   MBBFreqInfo.setBlockFreq(&TailMBB, AccumulatedMBBFreq);
1214
1215   if (TailMBB.succ_size() <= 1)
1216     return;
1217
1218   auto SumEdgeFreq =
1219       std::accumulate(EdgeFreqLs.begin(), EdgeFreqLs.end(), BlockFrequency(0))
1220           .getFrequency();
1221   auto EdgeFreq = EdgeFreqLs.begin();
1222
1223   if (SumEdgeFreq > 0) {
1224     for (auto SuccI = TailMBB.succ_begin(), SuccE = TailMBB.succ_end();
1225          SuccI != SuccE; ++SuccI, ++EdgeFreq) {
1226       auto Prob = BranchProbability::getBranchProbability(
1227           EdgeFreq->getFrequency(), SumEdgeFreq);
1228       TailMBB.setSuccProbability(SuccI, Prob);
1229     }
1230   }
1231 }
1232
1233 //===----------------------------------------------------------------------===//
1234 //  Branch Optimization
1235 //===----------------------------------------------------------------------===//
1236
1237 bool BranchFolder::OptimizeBranches(MachineFunction &MF) {
1238   bool MadeChange = false;
1239
1240   // Make sure blocks are numbered in order
1241   MF.RenumberBlocks();
1242   // Renumbering blocks alters EH scope membership, recalculate it.
1243   EHScopeMembership = getEHScopeMembership(MF);
1244
1245   for (MachineFunction::iterator I = std::next(MF.begin()), E = MF.end();
1246        I != E; ) {
1247     MachineBasicBlock *MBB = &*I++;
1248     MadeChange |= OptimizeBlock(MBB);
1249
1250     // If it is dead, remove it.
1251     if (MBB->pred_empty()) {
1252       RemoveDeadBlock(MBB);
1253       MadeChange = true;
1254       ++NumDeadBlocks;
1255     }
1256   }
1257
1258   return MadeChange;
1259 }
1260
1261 // Blocks should be considered empty if they contain only debug info;
1262 // else the debug info would affect codegen.
1263 static bool IsEmptyBlock(MachineBasicBlock *MBB) {
1264   return MBB->getFirstNonDebugInstr() == MBB->end();
1265 }
1266
1267 // Blocks with only debug info and branches should be considered the same
1268 // as blocks with only branches.
1269 static bool IsBranchOnlyBlock(MachineBasicBlock *MBB) {
1270   MachineBasicBlock::iterator I = MBB->getFirstNonDebugInstr();
1271   assert(I != MBB->end() && "empty block!");
1272   return I->isBranch();
1273 }
1274
1275 /// IsBetterFallthrough - Return true if it would be clearly better to
1276 /// fall-through to MBB1 than to fall through into MBB2.  This has to return
1277 /// a strict ordering, returning true for both (MBB1,MBB2) and (MBB2,MBB1) will
1278 /// result in infinite loops.
1279 static bool IsBetterFallthrough(MachineBasicBlock *MBB1,
1280                                 MachineBasicBlock *MBB2) {
1281   assert(MBB1 && MBB2 && "Unknown MachineBasicBlock");
1282
1283   // Right now, we use a simple heuristic.  If MBB2 ends with a call, and
1284   // MBB1 doesn't, we prefer to fall through into MBB1.  This allows us to
1285   // optimize branches that branch to either a return block or an assert block
1286   // into a fallthrough to the return.
1287   MachineBasicBlock::iterator MBB1I = MBB1->getLastNonDebugInstr();
1288   MachineBasicBlock::iterator MBB2I = MBB2->getLastNonDebugInstr();
1289   if (MBB1I == MBB1->end() || MBB2I == MBB2->end())
1290     return false;
1291
1292   // If there is a clear successor ordering we make sure that one block
1293   // will fall through to the next
1294   if (MBB1->isSuccessor(MBB2)) return true;
1295   if (MBB2->isSuccessor(MBB1)) return false;
1296
1297   return MBB2I->isCall() && !MBB1I->isCall();
1298 }
1299
1300 /// getBranchDebugLoc - Find and return, if any, the DebugLoc of the branch
1301 /// instructions on the block.
1302 static DebugLoc getBranchDebugLoc(MachineBasicBlock &MBB) {
1303   MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
1304   if (I != MBB.end() && I->isBranch())
1305     return I->getDebugLoc();
1306   return DebugLoc();
1307 }
1308
1309 static void copyDebugInfoToPredecessor(const TargetInstrInfo *TII,
1310                                        MachineBasicBlock &MBB,
1311                                        MachineBasicBlock &PredMBB) {
1312   auto InsertBefore = PredMBB.getFirstTerminator();
1313   for (MachineInstr &MI : MBB.instrs())
1314     if (MI.isDebugInstr()) {
1315       TII->duplicate(PredMBB, InsertBefore, MI);
1316       LLVM_DEBUG(dbgs() << "Copied debug entity from empty block to pred: "
1317                         << MI);
1318     }
1319 }
1320
1321 static void copyDebugInfoToSuccessor(const TargetInstrInfo *TII,
1322                                      MachineBasicBlock &MBB,
1323                                      MachineBasicBlock &SuccMBB) {
1324   auto InsertBefore = SuccMBB.SkipPHIsAndLabels(SuccMBB.begin());
1325   for (MachineInstr &MI : MBB.instrs())
1326     if (MI.isDebugInstr()) {
1327       TII->duplicate(SuccMBB, InsertBefore, MI);
1328       LLVM_DEBUG(dbgs() << "Copied debug entity from empty block to succ: "
1329                         << MI);
1330     }
1331 }
1332
1333 // Try to salvage DBG_VALUE instructions from an otherwise empty block. If such
1334 // a basic block is removed we would lose the debug information unless we have
1335 // copied the information to a predecessor/successor.
1336 //
1337 // TODO: This function only handles some simple cases. An alternative would be
1338 // to run a heavier analysis, such as the LiveDebugValues pass, before we do
1339 // branch folding.
1340 static void salvageDebugInfoFromEmptyBlock(const TargetInstrInfo *TII,
1341                                            MachineBasicBlock &MBB) {
1342   assert(IsEmptyBlock(&MBB) && "Expected an empty block (except debug info).");
1343   // If this MBB is the only predecessor of a successor it is legal to copy
1344   // DBG_VALUE instructions to the beginning of the successor.
1345   for (MachineBasicBlock *SuccBB : MBB.successors())
1346     if (SuccBB->pred_size() == 1)
1347       copyDebugInfoToSuccessor(TII, MBB, *SuccBB);
1348   // If this MBB is the only successor of a predecessor it is legal to copy the
1349   // DBG_VALUE instructions to the end of the predecessor (just before the
1350   // terminators, assuming that the terminator isn't affecting the DBG_VALUE).
1351   for (MachineBasicBlock *PredBB : MBB.predecessors())
1352     if (PredBB->succ_size() == 1)
1353       copyDebugInfoToPredecessor(TII, MBB, *PredBB);
1354 }
1355
1356 bool BranchFolder::OptimizeBlock(MachineBasicBlock *MBB) {
1357   bool MadeChange = false;
1358   MachineFunction &MF = *MBB->getParent();
1359 ReoptimizeBlock:
1360
1361   MachineFunction::iterator FallThrough = MBB->getIterator();
1362   ++FallThrough;
1363
1364   // Make sure MBB and FallThrough belong to the same EH scope.
1365   bool SameEHScope = true;
1366   if (!EHScopeMembership.empty() && FallThrough != MF.end()) {
1367     auto MBBEHScope = EHScopeMembership.find(MBB);
1368     assert(MBBEHScope != EHScopeMembership.end());
1369     auto FallThroughEHScope = EHScopeMembership.find(&*FallThrough);
1370     assert(FallThroughEHScope != EHScopeMembership.end());
1371     SameEHScope = MBBEHScope->second == FallThroughEHScope->second;
1372   }
1373
1374   // If this block is empty, make everyone use its fall-through, not the block
1375   // explicitly.  Landing pads should not do this since the landing-pad table
1376   // points to this block.  Blocks with their addresses taken shouldn't be
1377   // optimized away.
1378   if (IsEmptyBlock(MBB) && !MBB->isEHPad() && !MBB->hasAddressTaken() &&
1379       SameEHScope) {
1380     salvageDebugInfoFromEmptyBlock(TII, *MBB);
1381     // Dead block?  Leave for cleanup later.
1382     if (MBB->pred_empty()) return MadeChange;
1383
1384     if (FallThrough == MF.end()) {
1385       // TODO: Simplify preds to not branch here if possible!
1386     } else if (FallThrough->isEHPad()) {
1387       // Don't rewrite to a landing pad fallthough.  That could lead to the case
1388       // where a BB jumps to more than one landing pad.
1389       // TODO: Is it ever worth rewriting predecessors which don't already
1390       // jump to a landing pad, and so can safely jump to the fallthrough?
1391     } else if (MBB->isSuccessor(&*FallThrough)) {
1392       // Rewrite all predecessors of the old block to go to the fallthrough
1393       // instead.
1394       while (!MBB->pred_empty()) {
1395         MachineBasicBlock *Pred = *(MBB->pred_end()-1);
1396         Pred->ReplaceUsesOfBlockWith(MBB, &*FallThrough);
1397       }
1398       // If MBB was the target of a jump table, update jump tables to go to the
1399       // fallthrough instead.
1400       if (MachineJumpTableInfo *MJTI = MF.getJumpTableInfo())
1401         MJTI->ReplaceMBBInJumpTables(MBB, &*FallThrough);
1402       MadeChange = true;
1403     }
1404     return MadeChange;
1405   }
1406
1407   // Check to see if we can simplify the terminator of the block before this
1408   // one.
1409   MachineBasicBlock &PrevBB = *std::prev(MachineFunction::iterator(MBB));
1410
1411   MachineBasicBlock *PriorTBB = nullptr, *PriorFBB = nullptr;
1412   SmallVector<MachineOperand, 4> PriorCond;
1413   bool PriorUnAnalyzable =
1414       TII->analyzeBranch(PrevBB, PriorTBB, PriorFBB, PriorCond, true);
1415   if (!PriorUnAnalyzable) {
1416     // If the CFG for the prior block has extra edges, remove them.
1417     MadeChange |= PrevBB.CorrectExtraCFGEdges(PriorTBB, PriorFBB,
1418                                               !PriorCond.empty());
1419
1420     // If the previous branch is conditional and both conditions go to the same
1421     // destination, remove the branch, replacing it with an unconditional one or
1422     // a fall-through.
1423     if (PriorTBB && PriorTBB == PriorFBB) {
1424       DebugLoc dl = getBranchDebugLoc(PrevBB);
1425       TII->removeBranch(PrevBB);
1426       PriorCond.clear();
1427       if (PriorTBB != MBB)
1428         TII->insertBranch(PrevBB, PriorTBB, nullptr, PriorCond, dl);
1429       MadeChange = true;
1430       ++NumBranchOpts;
1431       goto ReoptimizeBlock;
1432     }
1433
1434     // If the previous block unconditionally falls through to this block and
1435     // this block has no other predecessors, move the contents of this block
1436     // into the prior block. This doesn't usually happen when SimplifyCFG
1437     // has been used, but it can happen if tail merging splits a fall-through
1438     // predecessor of a block.
1439     // This has to check PrevBB->succ_size() because EH edges are ignored by
1440     // AnalyzeBranch.
1441     if (PriorCond.empty() && !PriorTBB && MBB->pred_size() == 1 &&
1442         PrevBB.succ_size() == 1 &&
1443         !MBB->hasAddressTaken() && !MBB->isEHPad()) {
1444       LLVM_DEBUG(dbgs() << "\nMerging into block: " << PrevBB
1445                         << "From MBB: " << *MBB);
1446       // Remove redundant DBG_VALUEs first.
1447       if (PrevBB.begin() != PrevBB.end()) {
1448         MachineBasicBlock::iterator PrevBBIter = PrevBB.end();
1449         --PrevBBIter;
1450         MachineBasicBlock::iterator MBBIter = MBB->begin();
1451         // Check if DBG_VALUE at the end of PrevBB is identical to the
1452         // DBG_VALUE at the beginning of MBB.
1453         while (PrevBBIter != PrevBB.begin() && MBBIter != MBB->end()
1454                && PrevBBIter->isDebugInstr() && MBBIter->isDebugInstr()) {
1455           if (!MBBIter->isIdenticalTo(*PrevBBIter))
1456             break;
1457           MachineInstr &DuplicateDbg = *MBBIter;
1458           ++MBBIter; -- PrevBBIter;
1459           DuplicateDbg.eraseFromParent();
1460         }
1461       }
1462       PrevBB.splice(PrevBB.end(), MBB, MBB->begin(), MBB->end());
1463       PrevBB.removeSuccessor(PrevBB.succ_begin());
1464       assert(PrevBB.succ_empty());
1465       PrevBB.transferSuccessors(MBB);
1466       MadeChange = true;
1467       return MadeChange;
1468     }
1469
1470     // If the previous branch *only* branches to *this* block (conditional or
1471     // not) remove the branch.
1472     if (PriorTBB == MBB && !PriorFBB) {
1473       TII->removeBranch(PrevBB);
1474       MadeChange = true;
1475       ++NumBranchOpts;
1476       goto ReoptimizeBlock;
1477     }
1478
1479     // If the prior block branches somewhere else on the condition and here if
1480     // the condition is false, remove the uncond second branch.
1481     if (PriorFBB == MBB) {
1482       DebugLoc dl = getBranchDebugLoc(PrevBB);
1483       TII->removeBranch(PrevBB);
1484       TII->insertBranch(PrevBB, PriorTBB, nullptr, PriorCond, dl);
1485       MadeChange = true;
1486       ++NumBranchOpts;
1487       goto ReoptimizeBlock;
1488     }
1489
1490     // If the prior block branches here on true and somewhere else on false, and
1491     // if the branch condition is reversible, reverse the branch to create a
1492     // fall-through.
1493     if (PriorTBB == MBB) {
1494       SmallVector<MachineOperand, 4> NewPriorCond(PriorCond);
1495       if (!TII->reverseBranchCondition(NewPriorCond)) {
1496         DebugLoc dl = getBranchDebugLoc(PrevBB);
1497         TII->removeBranch(PrevBB);
1498         TII->insertBranch(PrevBB, PriorFBB, nullptr, NewPriorCond, dl);
1499         MadeChange = true;
1500         ++NumBranchOpts;
1501         goto ReoptimizeBlock;
1502       }
1503     }
1504
1505     // If this block has no successors (e.g. it is a return block or ends with
1506     // a call to a no-return function like abort or __cxa_throw) and if the pred
1507     // falls through into this block, and if it would otherwise fall through
1508     // into the block after this, move this block to the end of the function.
1509     //
1510     // We consider it more likely that execution will stay in the function (e.g.
1511     // due to loops) than it is to exit it.  This asserts in loops etc, moving
1512     // the assert condition out of the loop body.
1513     if (MBB->succ_empty() && !PriorCond.empty() && !PriorFBB &&
1514         MachineFunction::iterator(PriorTBB) == FallThrough &&
1515         !MBB->canFallThrough()) {
1516       bool DoTransform = true;
1517
1518       // We have to be careful that the succs of PredBB aren't both no-successor
1519       // blocks.  If neither have successors and if PredBB is the second from
1520       // last block in the function, we'd just keep swapping the two blocks for
1521       // last.  Only do the swap if one is clearly better to fall through than
1522       // the other.
1523       if (FallThrough == --MF.end() &&
1524           !IsBetterFallthrough(PriorTBB, MBB))
1525         DoTransform = false;
1526
1527       if (DoTransform) {
1528         // Reverse the branch so we will fall through on the previous true cond.
1529         SmallVector<MachineOperand, 4> NewPriorCond(PriorCond);
1530         if (!TII->reverseBranchCondition(NewPriorCond)) {
1531           LLVM_DEBUG(dbgs() << "\nMoving MBB: " << *MBB
1532                             << "To make fallthrough to: " << *PriorTBB << "\n");
1533
1534           DebugLoc dl = getBranchDebugLoc(PrevBB);
1535           TII->removeBranch(PrevBB);
1536           TII->insertBranch(PrevBB, MBB, nullptr, NewPriorCond, dl);
1537
1538           // Move this block to the end of the function.
1539           MBB->moveAfter(&MF.back());
1540           MadeChange = true;
1541           ++NumBranchOpts;
1542           return MadeChange;
1543         }
1544       }
1545     }
1546   }
1547
1548   bool OptForSize =
1549       MF.getFunction().hasOptSize() ||
1550       llvm::shouldOptimizeForSize(MBB, PSI, &MBBFreqInfo.getMBFI());
1551   if (!IsEmptyBlock(MBB) && MBB->pred_size() == 1 && OptForSize) {
1552     // Changing "Jcc foo; foo: jmp bar;" into "Jcc bar;" might change the branch
1553     // direction, thereby defeating careful block placement and regressing
1554     // performance. Therefore, only consider this for optsize functions.
1555     MachineInstr &TailCall = *MBB->getFirstNonDebugInstr();
1556     if (TII->isUnconditionalTailCall(TailCall)) {
1557       MachineBasicBlock *Pred = *MBB->pred_begin();
1558       MachineBasicBlock *PredTBB = nullptr, *PredFBB = nullptr;
1559       SmallVector<MachineOperand, 4> PredCond;
1560       bool PredAnalyzable =
1561           !TII->analyzeBranch(*Pred, PredTBB, PredFBB, PredCond, true);
1562
1563       if (PredAnalyzable && !PredCond.empty() && PredTBB == MBB &&
1564           PredTBB != PredFBB) {
1565         // The predecessor has a conditional branch to this block which consists
1566         // of only a tail call. Try to fold the tail call into the conditional
1567         // branch.
1568         if (TII->canMakeTailCallConditional(PredCond, TailCall)) {
1569           // TODO: It would be nice if analyzeBranch() could provide a pointer
1570           // to the branch instruction so replaceBranchWithTailCall() doesn't
1571           // have to search for it.
1572           TII->replaceBranchWithTailCall(*Pred, PredCond, TailCall);
1573           ++NumTailCalls;
1574           Pred->removeSuccessor(MBB);
1575           MadeChange = true;
1576           return MadeChange;
1577         }
1578       }
1579       // If the predecessor is falling through to this block, we could reverse
1580       // the branch condition and fold the tail call into that. However, after
1581       // that we might have to re-arrange the CFG to fall through to the other
1582       // block and there is a high risk of regressing code size rather than
1583       // improving it.
1584     }
1585   }
1586
1587   // Analyze the branch in the current block.
1588   MachineBasicBlock *CurTBB = nullptr, *CurFBB = nullptr;
1589   SmallVector<MachineOperand, 4> CurCond;
1590   bool CurUnAnalyzable =
1591       TII->analyzeBranch(*MBB, CurTBB, CurFBB, CurCond, true);
1592   if (!CurUnAnalyzable) {
1593     // If the CFG for the prior block has extra edges, remove them.
1594     MadeChange |= MBB->CorrectExtraCFGEdges(CurTBB, CurFBB, !CurCond.empty());
1595
1596     // If this is a two-way branch, and the FBB branches to this block, reverse
1597     // the condition so the single-basic-block loop is faster.  Instead of:
1598     //    Loop: xxx; jcc Out; jmp Loop
1599     // we want:
1600     //    Loop: xxx; jncc Loop; jmp Out
1601     if (CurTBB && CurFBB && CurFBB == MBB && CurTBB != MBB) {
1602       SmallVector<MachineOperand, 4> NewCond(CurCond);
1603       if (!TII->reverseBranchCondition(NewCond)) {
1604         DebugLoc dl = getBranchDebugLoc(*MBB);
1605         TII->removeBranch(*MBB);
1606         TII->insertBranch(*MBB, CurFBB, CurTBB, NewCond, dl);
1607         MadeChange = true;
1608         ++NumBranchOpts;
1609         goto ReoptimizeBlock;
1610       }
1611     }
1612
1613     // If this branch is the only thing in its block, see if we can forward
1614     // other blocks across it.
1615     if (CurTBB && CurCond.empty() && !CurFBB &&
1616         IsBranchOnlyBlock(MBB) && CurTBB != MBB &&
1617         !MBB->hasAddressTaken() && !MBB->isEHPad()) {
1618       DebugLoc dl = getBranchDebugLoc(*MBB);
1619       // This block may contain just an unconditional branch.  Because there can
1620       // be 'non-branch terminators' in the block, try removing the branch and
1621       // then seeing if the block is empty.
1622       TII->removeBranch(*MBB);
1623       // If the only things remaining in the block are debug info, remove these
1624       // as well, so this will behave the same as an empty block in non-debug
1625       // mode.
1626       if (IsEmptyBlock(MBB)) {
1627         // Make the block empty, losing the debug info (we could probably
1628         // improve this in some cases.)
1629         MBB->erase(MBB->begin(), MBB->end());
1630       }
1631       // If this block is just an unconditional branch to CurTBB, we can
1632       // usually completely eliminate the block.  The only case we cannot
1633       // completely eliminate the block is when the block before this one
1634       // falls through into MBB and we can't understand the prior block's branch
1635       // condition.
1636       if (MBB->empty()) {
1637         bool PredHasNoFallThrough = !PrevBB.canFallThrough();
1638         if (PredHasNoFallThrough || !PriorUnAnalyzable ||
1639             !PrevBB.isSuccessor(MBB)) {
1640           // If the prior block falls through into us, turn it into an
1641           // explicit branch to us to make updates simpler.
1642           if (!PredHasNoFallThrough && PrevBB.isSuccessor(MBB) &&
1643               PriorTBB != MBB && PriorFBB != MBB) {
1644             if (!PriorTBB) {
1645               assert(PriorCond.empty() && !PriorFBB &&
1646                      "Bad branch analysis");
1647               PriorTBB = MBB;
1648             } else {
1649               assert(!PriorFBB && "Machine CFG out of date!");
1650               PriorFBB = MBB;
1651             }
1652             DebugLoc pdl = getBranchDebugLoc(PrevBB);
1653             TII->removeBranch(PrevBB);
1654             TII->insertBranch(PrevBB, PriorTBB, PriorFBB, PriorCond, pdl);
1655           }
1656
1657           // Iterate through all the predecessors, revectoring each in-turn.
1658           size_t PI = 0;
1659           bool DidChange = false;
1660           bool HasBranchToSelf = false;
1661           while(PI != MBB->pred_size()) {
1662             MachineBasicBlock *PMBB = *(MBB->pred_begin() + PI);
1663             if (PMBB == MBB) {
1664               // If this block has an uncond branch to itself, leave it.
1665               ++PI;
1666               HasBranchToSelf = true;
1667             } else {
1668               DidChange = true;
1669               PMBB->ReplaceUsesOfBlockWith(MBB, CurTBB);
1670               // If this change resulted in PMBB ending in a conditional
1671               // branch where both conditions go to the same destination,
1672               // change this to an unconditional branch (and fix the CFG).
1673               MachineBasicBlock *NewCurTBB = nullptr, *NewCurFBB = nullptr;
1674               SmallVector<MachineOperand, 4> NewCurCond;
1675               bool NewCurUnAnalyzable = TII->analyzeBranch(
1676                   *PMBB, NewCurTBB, NewCurFBB, NewCurCond, true);
1677               if (!NewCurUnAnalyzable && NewCurTBB && NewCurTBB == NewCurFBB) {
1678                 DebugLoc pdl = getBranchDebugLoc(*PMBB);
1679                 TII->removeBranch(*PMBB);
1680                 NewCurCond.clear();
1681                 TII->insertBranch(*PMBB, NewCurTBB, nullptr, NewCurCond, pdl);
1682                 MadeChange = true;
1683                 ++NumBranchOpts;
1684                 PMBB->CorrectExtraCFGEdges(NewCurTBB, nullptr, false);
1685               }
1686             }
1687           }
1688
1689           // Change any jumptables to go to the new MBB.
1690           if (MachineJumpTableInfo *MJTI = MF.getJumpTableInfo())
1691             MJTI->ReplaceMBBInJumpTables(MBB, CurTBB);
1692           if (DidChange) {
1693             ++NumBranchOpts;
1694             MadeChange = true;
1695             if (!HasBranchToSelf) return MadeChange;
1696           }
1697         }
1698       }
1699
1700       // Add the branch back if the block is more than just an uncond branch.
1701       TII->insertBranch(*MBB, CurTBB, nullptr, CurCond, dl);
1702     }
1703   }
1704
1705   // If the prior block doesn't fall through into this block, and if this
1706   // block doesn't fall through into some other block, see if we can find a
1707   // place to move this block where a fall-through will happen.
1708   if (!PrevBB.canFallThrough()) {
1709     // Now we know that there was no fall-through into this block, check to
1710     // see if it has a fall-through into its successor.
1711     bool CurFallsThru = MBB->canFallThrough();
1712
1713     if (!MBB->isEHPad()) {
1714       // Check all the predecessors of this block.  If one of them has no fall
1715       // throughs, move this block right after it.
1716       for (MachineBasicBlock *PredBB : MBB->predecessors()) {
1717         // Analyze the branch at the end of the pred.
1718         MachineBasicBlock *PredTBB = nullptr, *PredFBB = nullptr;
1719         SmallVector<MachineOperand, 4> PredCond;
1720         if (PredBB != MBB && !PredBB->canFallThrough() &&
1721             !TII->analyzeBranch(*PredBB, PredTBB, PredFBB, PredCond, true) &&
1722             (!CurFallsThru || !CurTBB || !CurFBB) &&
1723             (!CurFallsThru || MBB->getNumber() >= PredBB->getNumber())) {
1724           // If the current block doesn't fall through, just move it.
1725           // If the current block can fall through and does not end with a
1726           // conditional branch, we need to append an unconditional jump to
1727           // the (current) next block.  To avoid a possible compile-time
1728           // infinite loop, move blocks only backward in this case.
1729           // Also, if there are already 2 branches here, we cannot add a third;
1730           // this means we have the case
1731           // Bcc next
1732           // B elsewhere
1733           // next:
1734           if (CurFallsThru) {
1735             MachineBasicBlock *NextBB = &*std::next(MBB->getIterator());
1736             CurCond.clear();
1737             TII->insertBranch(*MBB, NextBB, nullptr, CurCond, DebugLoc());
1738           }
1739           MBB->moveAfter(PredBB);
1740           MadeChange = true;
1741           goto ReoptimizeBlock;
1742         }
1743       }
1744     }
1745
1746     if (!CurFallsThru) {
1747       // Check all successors to see if we can move this block before it.
1748       for (MachineBasicBlock *SuccBB : MBB->successors()) {
1749         // Analyze the branch at the end of the block before the succ.
1750         MachineFunction::iterator SuccPrev = --SuccBB->getIterator();
1751
1752         // If this block doesn't already fall-through to that successor, and if
1753         // the succ doesn't already have a block that can fall through into it,
1754         // and if the successor isn't an EH destination, we can arrange for the
1755         // fallthrough to happen.
1756         if (SuccBB != MBB && &*SuccPrev != MBB &&
1757             !SuccPrev->canFallThrough() && !CurUnAnalyzable &&
1758             !SuccBB->isEHPad()) {
1759           MBB->moveBefore(SuccBB);
1760           MadeChange = true;
1761           goto ReoptimizeBlock;
1762         }
1763       }
1764
1765       // Okay, there is no really great place to put this block.  If, however,
1766       // the block before this one would be a fall-through if this block were
1767       // removed, move this block to the end of the function. There is no real
1768       // advantage in "falling through" to an EH block, so we don't want to
1769       // perform this transformation for that case.
1770       //
1771       // Also, Windows EH introduced the possibility of an arbitrary number of
1772       // successors to a given block.  The analyzeBranch call does not consider
1773       // exception handling and so we can get in a state where a block
1774       // containing a call is followed by multiple EH blocks that would be
1775       // rotated infinitely at the end of the function if the transformation
1776       // below were performed for EH "FallThrough" blocks.  Therefore, even if
1777       // that appears not to be happening anymore, we should assume that it is
1778       // possible and not remove the "!FallThrough()->isEHPad" condition below.
1779       MachineBasicBlock *PrevTBB = nullptr, *PrevFBB = nullptr;
1780       SmallVector<MachineOperand, 4> PrevCond;
1781       if (FallThrough != MF.end() &&
1782           !FallThrough->isEHPad() &&
1783           !TII->analyzeBranch(PrevBB, PrevTBB, PrevFBB, PrevCond, true) &&
1784           PrevBB.isSuccessor(&*FallThrough)) {
1785         MBB->moveAfter(&MF.back());
1786         MadeChange = true;
1787         return MadeChange;
1788       }
1789     }
1790   }
1791
1792   return MadeChange;
1793 }
1794
1795 //===----------------------------------------------------------------------===//
1796 //  Hoist Common Code
1797 //===----------------------------------------------------------------------===//
1798
1799 bool BranchFolder::HoistCommonCode(MachineFunction &MF) {
1800   bool MadeChange = false;
1801   for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ) {
1802     MachineBasicBlock *MBB = &*I++;
1803     MadeChange |= HoistCommonCodeInSuccs(MBB);
1804   }
1805
1806   return MadeChange;
1807 }
1808
1809 /// findFalseBlock - BB has a fallthrough. Find its 'false' successor given
1810 /// its 'true' successor.
1811 static MachineBasicBlock *findFalseBlock(MachineBasicBlock *BB,
1812                                          MachineBasicBlock *TrueBB) {
1813   for (MachineBasicBlock *SuccBB : BB->successors())
1814     if (SuccBB != TrueBB)
1815       return SuccBB;
1816   return nullptr;
1817 }
1818
1819 template <class Container>
1820 static void addRegAndItsAliases(unsigned Reg, const TargetRegisterInfo *TRI,
1821                                 Container &Set) {
1822   if (Register::isPhysicalRegister(Reg)) {
1823     for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI)
1824       Set.insert(*AI);
1825   } else {
1826     Set.insert(Reg);
1827   }
1828 }
1829
1830 /// findHoistingInsertPosAndDeps - Find the location to move common instructions
1831 /// in successors to. The location is usually just before the terminator,
1832 /// however if the terminator is a conditional branch and its previous
1833 /// instruction is the flag setting instruction, the previous instruction is
1834 /// the preferred location. This function also gathers uses and defs of the
1835 /// instructions from the insertion point to the end of the block. The data is
1836 /// used by HoistCommonCodeInSuccs to ensure safety.
1837 static
1838 MachineBasicBlock::iterator findHoistingInsertPosAndDeps(MachineBasicBlock *MBB,
1839                                                   const TargetInstrInfo *TII,
1840                                                   const TargetRegisterInfo *TRI,
1841                                                   SmallSet<unsigned,4> &Uses,
1842                                                   SmallSet<unsigned,4> &Defs) {
1843   MachineBasicBlock::iterator Loc = MBB->getFirstTerminator();
1844   if (!TII->isUnpredicatedTerminator(*Loc))
1845     return MBB->end();
1846
1847   for (const MachineOperand &MO : Loc->operands()) {
1848     if (!MO.isReg())
1849       continue;
1850     Register Reg = MO.getReg();
1851     if (!Reg)
1852       continue;
1853     if (MO.isUse()) {
1854       addRegAndItsAliases(Reg, TRI, Uses);
1855     } else {
1856       if (!MO.isDead())
1857         // Don't try to hoist code in the rare case the terminator defines a
1858         // register that is later used.
1859         return MBB->end();
1860
1861       // If the terminator defines a register, make sure we don't hoist
1862       // the instruction whose def might be clobbered by the terminator.
1863       addRegAndItsAliases(Reg, TRI, Defs);
1864     }
1865   }
1866
1867   if (Uses.empty())
1868     return Loc;
1869   // If the terminator is the only instruction in the block and Uses is not
1870   // empty (or we would have returned above), we can still safely hoist
1871   // instructions just before the terminator as long as the Defs/Uses are not
1872   // violated (which is checked in HoistCommonCodeInSuccs).
1873   if (Loc == MBB->begin())
1874     return Loc;
1875
1876   // The terminator is probably a conditional branch, try not to separate the
1877   // branch from condition setting instruction.
1878   MachineBasicBlock::iterator PI =
1879     skipDebugInstructionsBackward(std::prev(Loc), MBB->begin());
1880
1881   bool IsDef = false;
1882   for (const MachineOperand &MO : PI->operands()) {
1883     // If PI has a regmask operand, it is probably a call. Separate away.
1884     if (MO.isRegMask())
1885       return Loc;
1886     if (!MO.isReg() || MO.isUse())
1887       continue;
1888     Register Reg = MO.getReg();
1889     if (!Reg)
1890       continue;
1891     if (Uses.count(Reg)) {
1892       IsDef = true;
1893       break;
1894     }
1895   }
1896   if (!IsDef)
1897     // The condition setting instruction is not just before the conditional
1898     // branch.
1899     return Loc;
1900
1901   // Be conservative, don't insert instruction above something that may have
1902   // side-effects. And since it's potentially bad to separate flag setting
1903   // instruction from the conditional branch, just abort the optimization
1904   // completely.
1905   // Also avoid moving code above predicated instruction since it's hard to
1906   // reason about register liveness with predicated instruction.
1907   bool DontMoveAcrossStore = true;
1908   if (!PI->isSafeToMove(nullptr, DontMoveAcrossStore) || TII->isPredicated(*PI))
1909     return MBB->end();
1910
1911   // Find out what registers are live. Note this routine is ignoring other live
1912   // registers which are only used by instructions in successor blocks.
1913   for (const MachineOperand &MO : PI->operands()) {
1914     if (!MO.isReg())
1915       continue;
1916     Register Reg = MO.getReg();
1917     if (!Reg)
1918       continue;
1919     if (MO.isUse()) {
1920       addRegAndItsAliases(Reg, TRI, Uses);
1921     } else {
1922       if (Uses.erase(Reg)) {
1923         if (Register::isPhysicalRegister(Reg)) {
1924           for (MCSubRegIterator SubRegs(Reg, TRI); SubRegs.isValid(); ++SubRegs)
1925             Uses.erase(*SubRegs); // Use sub-registers to be conservative
1926         }
1927       }
1928       addRegAndItsAliases(Reg, TRI, Defs);
1929     }
1930   }
1931
1932   return PI;
1933 }
1934
1935 bool BranchFolder::HoistCommonCodeInSuccs(MachineBasicBlock *MBB) {
1936   MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
1937   SmallVector<MachineOperand, 4> Cond;
1938   if (TII->analyzeBranch(*MBB, TBB, FBB, Cond, true) || !TBB || Cond.empty())
1939     return false;
1940
1941   if (!FBB) FBB = findFalseBlock(MBB, TBB);
1942   if (!FBB)
1943     // Malformed bcc? True and false blocks are the same?
1944     return false;
1945
1946   // Restrict the optimization to cases where MBB is the only predecessor,
1947   // it is an obvious win.
1948   if (TBB->pred_size() > 1 || FBB->pred_size() > 1)
1949     return false;
1950
1951   // Find a suitable position to hoist the common instructions to. Also figure
1952   // out which registers are used or defined by instructions from the insertion
1953   // point to the end of the block.
1954   SmallSet<unsigned, 4> Uses, Defs;
1955   MachineBasicBlock::iterator Loc =
1956     findHoistingInsertPosAndDeps(MBB, TII, TRI, Uses, Defs);
1957   if (Loc == MBB->end())
1958     return false;
1959
1960   bool HasDups = false;
1961   SmallSet<unsigned, 4> ActiveDefsSet, AllDefsSet;
1962   MachineBasicBlock::iterator TIB = TBB->begin();
1963   MachineBasicBlock::iterator FIB = FBB->begin();
1964   MachineBasicBlock::iterator TIE = TBB->end();
1965   MachineBasicBlock::iterator FIE = FBB->end();
1966   while (TIB != TIE && FIB != FIE) {
1967     // Skip dbg_value instructions. These do not count.
1968     TIB = skipDebugInstructionsForward(TIB, TIE);
1969     FIB = skipDebugInstructionsForward(FIB, FIE);
1970     if (TIB == TIE || FIB == FIE)
1971       break;
1972
1973     if (!TIB->isIdenticalTo(*FIB, MachineInstr::CheckKillDead))
1974       break;
1975
1976     if (TII->isPredicated(*TIB))
1977       // Hard to reason about register liveness with predicated instruction.
1978       break;
1979
1980     bool IsSafe = true;
1981     for (MachineOperand &MO : TIB->operands()) {
1982       // Don't attempt to hoist instructions with register masks.
1983       if (MO.isRegMask()) {
1984         IsSafe = false;
1985         break;
1986       }
1987       if (!MO.isReg())
1988         continue;
1989       Register Reg = MO.getReg();
1990       if (!Reg)
1991         continue;
1992       if (MO.isDef()) {
1993         if (Uses.count(Reg)) {
1994           // Avoid clobbering a register that's used by the instruction at
1995           // the point of insertion.
1996           IsSafe = false;
1997           break;
1998         }
1999
2000         if (Defs.count(Reg) && !MO.isDead()) {
2001           // Don't hoist the instruction if the def would be clobber by the
2002           // instruction at the point insertion. FIXME: This is overly
2003           // conservative. It should be possible to hoist the instructions
2004           // in BB2 in the following example:
2005           // BB1:
2006           // r1, eflag = op1 r2, r3
2007           // brcc eflag
2008           //
2009           // BB2:
2010           // r1 = op2, ...
2011           //    = op3, killed r1
2012           IsSafe = false;
2013           break;
2014         }
2015       } else if (!ActiveDefsSet.count(Reg)) {
2016         if (Defs.count(Reg)) {
2017           // Use is defined by the instruction at the point of insertion.
2018           IsSafe = false;
2019           break;
2020         }
2021
2022         if (MO.isKill() && Uses.count(Reg))
2023           // Kills a register that's read by the instruction at the point of
2024           // insertion. Remove the kill marker.
2025           MO.setIsKill(false);
2026       }
2027     }
2028     if (!IsSafe)
2029       break;
2030
2031     bool DontMoveAcrossStore = true;
2032     if (!TIB->isSafeToMove(nullptr, DontMoveAcrossStore))
2033       break;
2034
2035     // Remove kills from ActiveDefsSet, these registers had short live ranges.
2036     for (const MachineOperand &MO : TIB->operands()) {
2037       if (!MO.isReg() || !MO.isUse() || !MO.isKill())
2038         continue;
2039       Register Reg = MO.getReg();
2040       if (!Reg)
2041         continue;
2042       if (!AllDefsSet.count(Reg)) {
2043         continue;
2044       }
2045       if (Register::isPhysicalRegister(Reg)) {
2046         for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI)
2047           ActiveDefsSet.erase(*AI);
2048       } else {
2049         ActiveDefsSet.erase(Reg);
2050       }
2051     }
2052
2053     // Track local defs so we can update liveins.
2054     for (const MachineOperand &MO : TIB->operands()) {
2055       if (!MO.isReg() || !MO.isDef() || MO.isDead())
2056         continue;
2057       Register Reg = MO.getReg();
2058       if (!Reg || Register::isVirtualRegister(Reg))
2059         continue;
2060       addRegAndItsAliases(Reg, TRI, ActiveDefsSet);
2061       addRegAndItsAliases(Reg, TRI, AllDefsSet);
2062     }
2063
2064     HasDups = true;
2065     ++TIB;
2066     ++FIB;
2067   }
2068
2069   if (!HasDups)
2070     return false;
2071
2072   MBB->splice(Loc, TBB, TBB->begin(), TIB);
2073   FBB->erase(FBB->begin(), FIB);
2074
2075   if (UpdateLiveIns) {
2076     recomputeLiveIns(*TBB);
2077     recomputeLiveIns(*FBB);
2078   }
2079
2080   ++NumHoist;
2081   return true;
2082 }