[BOLT] Split missed macro-fusion counting around removeConditionalTailCalls

[Amir]

Summary

D156389 fixes conditional tail calls instrumentation by moving Offset annotation
from the conditional jump left in place of CTC to the newly constructed tail
call. However, this breaks missed macro-op fusion opportunities counting which
relies on offset information for conditional jumps.

Work around that by collecting the blocks with missed macro-fusion before
removeConditionalTailCalls but computing the count after it.

Depends On:
D156389

bolt/include/bolt/Core/BinaryFunction.h

public:
   /// Return a list of basic blocks sorted using DFS and update layout indices
   /// using the same order. Does not modify the current layout.
   BasicBlockListType dfs() const;
 
   /// Find the loops in the CFG of the function and store information about
   /// them.
   void calculateLoopInfo();
 
+  /// Find blocks with missed macro-fusion opportunities.
+  using SmallBlocksSet = SmallPtrSet<const BinaryBasicBlock *, 1>;
+  SmallBlocksSet findMissedMacroOpFusionBlocks();
+
   /// Calculate missed macro-fusion opportunities and update BinaryContext
   /// stats.
-  void calculateMacroOpFusionStats();
+  void calculateMacroOpFusionStats(SmallBlocksSet &Blocks);
 
   /// Returns if loop detection has been run for this function.
   bool hasLoopInfo() const { return BLI != nullptr; }
 
   const BinaryLoopInfo &getLoopInfo() { return *BLI.get(); }
 
   bool isLoopFree() {
     if (!hasLoopInfo())

bolt/lib/Core/BinaryFunction.cpp

bool BinaryFunction::buildCFG(MCPlusBuilder::AllocatorIdTy AllocatorId) {
 
   clearList(ExternallyReferencedOffsets);
   clearList(UnknownIndirectBranchOffsets);
 
   return true;
 }
 
 void BinaryFunction::postProcessCFG() {
+  SmallBlocksSet MissedMacroFusionBlocks = findMissedMacroOpFusionBlocks();
+
   if (isSimple() && !BasicBlocks.empty()) {
     // Convert conditional tail call branches to conditional branches that jump
     // to a tail call.
     removeConditionalTailCalls();
 
     postProcessProfile();
 
     // Eliminate inconsistencies between branch instructions and CFG.
     postProcessBranches();
   }
 
-  calculateMacroOpFusionStats();
+  calculateMacroOpFusionStats(MissedMacroFusionBlocks);
 
   // The final cleanup of intermediate structures.
   clearList(IgnoredBranches);
 
   // Remove "Offset" annotations, unless we need an address-translation table
   // later. This has no cost, since annotations are allocated by a bumpptr
   // allocator and won't be released anyway until late in the pipeline.
   if (!requiresAddressTranslation() && !opts::Instrument) {
     for (BinaryBasicBlock &BB : blocks())
       for (MCInst &Inst : BB)
         BC.MIB->clearOffset(Inst);
   }
 
   assert((!isSimple() || validateCFG()) &&
          "invalid CFG detected after post-processing");
 }
 
-void BinaryFunction::calculateMacroOpFusionStats() {
+BinaryFunction::SmallBlocksSet BinaryFunction::findMissedMacroOpFusionBlocks() {
+  SmallBlocksSet Blocks;
   if (!getBinaryContext().isX86())
-    return;
+    return Blocks;
   for (const BinaryBasicBlock &BB : blocks()) {
     auto II = BB.getMacroOpFusionPair();
     if (II == BB.end())
       continue;
 
     // Check offset of the second instruction.
     // FIXME: arch-specific.
     const uint32_t Offset = BC.MIB->getOffsetWithDefault(*std::next(II), 0);
     if (!Offset || (getAddress() + Offset) % 64)
       continue;
 
     LLVM_DEBUG(dbgs() << "\nmissed macro-op fusion at address 0x"
                       << Twine::utohexstr(getAddress() + Offset)
                       << " in function " << *this << "; executed "
                       << BB.getKnownExecutionCount() << " times.\n");
     ++BC.MissedMacroFusionPairs;
-    BC.MissedMacroFusionExecCount += BB.getKnownExecutionCount();
+    Blocks.insert(&BB);
   }
+  return Blocks;
+}
+
+void BinaryFunction::calculateMacroOpFusionStats(SmallBlocksSet &Blocks) {
+  for (const BinaryBasicBlock *BB : Blocks)
+    BC.MissedMacroFusionExecCount += BB->getKnownExecutionCount();
 }
 
 void BinaryFunction::removeTagsFromProfile() {
   for (BinaryBasicBlock *BB : BasicBlocks) {
     if (BB->ExecutionCount == BinaryBasicBlock::COUNT_NO_PROFILE)
       BB->ExecutionCount = 0;
     for (BinaryBasicBlock::BinaryBranchInfo &BI : BB->branch_info()) {
       if (BI.Count != BinaryBasicBlock::COUNT_NO_PROFILE &&