diff --git a/bolt/include/bolt/Core/BinaryContext.h b/bolt/include/bolt/Core/BinaryContext.h
--- a/bolt/include/bolt/Core/BinaryContext.h
+++ b/bolt/include/bolt/Core/BinaryContext.h
@@ -642,6 +642,16 @@
   uint64_t MissedMacroFusionPairs{0};
   uint64_t MissedMacroFusionExecCount{0};
 
+  /// Binary-wide stats for stale profile matching:
+  ///   the total number of basic blocks in the profile
+  uint32_t NumStaleBlocks{0};
+  ///   the number matched basic blocks
+  uint32_t NumMatchedBlocks{0};
+  ///   the total count of samples in the profile
+  uint64_t StaleSampleCount{0};
+  ///   the count matched samples
+  uint64_t MatchedSampleCount{0};
+
   // Address of the first allocated segment.
   uint64_t FirstAllocAddress{std::numeric_limits<uint64_t>::max()};
 
diff --git a/bolt/include/bolt/Core/BinaryFunction.h b/bolt/include/bolt/Core/BinaryFunction.h
--- a/bolt/include/bolt/Core/BinaryFunction.h
+++ b/bolt/include/bolt/Core/BinaryFunction.h
@@ -381,7 +381,7 @@
   /// Profile match ratio.
   float ProfileMatchRatio{0.0f};
 
-  /// Raw branch count for this function in the profile
+  /// Raw branch count for this function in the profile.
   uint64_t RawBranchCount{0};
 
   /// Indicates the type of profile the function is using.
diff --git a/bolt/lib/Passes/BinaryPasses.cpp b/bolt/lib/Passes/BinaryPasses.cpp
--- a/bolt/lib/Passes/BinaryPasses.cpp
+++ b/bolt/lib/Passes/BinaryPasses.cpp
@@ -1454,6 +1454,13 @@
                      100.0 * NumInferredFunctions / NumAllStaleFunctions,
                      100.0 * InferredSampleCount / TotalSampleCount,
                      InferredSampleCount, TotalSampleCount);
+    outs() << format("BOLT-INFO: stale inference matched %.2f%% of basic blocks"
+                     " (%zu out of %zu stale) responsible for %.2f%% samples"
+                     " (%zu out of %zu stale)\n",
+                     100.0 * BC.NumMatchedBlocks / BC.NumStaleBlocks,
+                     BC.NumMatchedBlocks, BC.NumStaleBlocks,
+                     100.0 * BC.MatchedSampleCount / BC.StaleSampleCount,
+                     BC.MatchedSampleCount, BC.StaleSampleCount);
   }
 
   if (const uint64_t NumUnusedObjects = BC.getNumUnusedProfiledObjects()) {
diff --git a/bolt/lib/Profile/StaleProfileMatching.cpp b/bolt/lib/Profile/StaleProfileMatching.cpp
--- a/bolt/lib/Profile/StaleProfileMatching.cpp
+++ b/bolt/lib/Profile/StaleProfileMatching.cpp
@@ -236,9 +236,8 @@
   /// Find the most similar block for a given hash.
   const FlowBlock *matchBlock(BlendedBlockHash BlendedHash) const {
     auto BlockIt = OpHashToBlocks.find(BlendedHash.OpcodeHash);
-    if (BlockIt == OpHashToBlocks.end()) {
+    if (BlockIt == OpHashToBlocks.end())
       return nullptr;
-    }
     FlowBlock *BestBlock = nullptr;
     uint64_t BestDist = std::numeric_limits<uint64_t>::max();
     for (auto It : BlockIt->second) {
@@ -393,7 +392,8 @@
 /// of the basic blocks in the binary, the count is "matched" to the block.
 /// Similarly, if both the source and the target of a count in the profile are
 /// matched to a jump in the binary, the count is recorded in CFG.
-void matchWeightsByHashes(const BinaryFunction::BasicBlockOrderType &BlockOrder,
+void matchWeightsByHashes(BinaryFunction &BF,
+                          const BinaryFunction::BasicBlockOrderType &BlockOrder,
                           const yaml::bolt::BinaryFunctionProfile &YamlBF,
                           FlowFunction &Func) {
   assert(Func.Blocks.size() == BlockOrder.size() + 1);
@@ -475,12 +475,23 @@
   // Assign block counts based on in-/out- jumps
   for (FlowBlock &Block : Func.Blocks) {
     if (OutWeight[Block.Index] == 0 && InWeight[Block.Index] == 0) {
-      assert(Block.HasUnknownWeight && "unmatched block with positive count");
+      assert(Block.HasUnknownWeight && "unmatched block with a positive count");
       continue;
     }
     Block.HasUnknownWeight = false;
     Block.Weight = std::max(OutWeight[Block.Index], InWeight[Block.Index]);
   }
+
+  // Compute and assign matching stats.
+  BinaryContext &BC = BF.getBinaryContext();
+  for (const yaml::bolt::BinaryBasicBlockProfile &YamlBB : YamlBF.Blocks) {
+    BC.NumStaleBlocks += 1;
+    BC.StaleSampleCount += YamlBB.ExecCount;
+    if (MatchedBlocks.find(YamlBB.Index) != MatchedBlocks.end()) {
+      BC.NumMatchedBlocks += 1;
+      BC.MatchedSampleCount += YamlBB.ExecCount;
+    }
+  }
 }
 
 /// The function finds all blocks that are (i) reachable from the Entry block
@@ -702,7 +713,7 @@
   FlowFunction Func = createFlowFunction(BlockOrder);
 
   // Match as many block/jump counts from the stale profile as possible
-  matchWeightsByHashes(BlockOrder, YamlBF, Func);
+  matchWeightsByHashes(BF, BlockOrder, YamlBF, Func);
 
   // Adjust the flow function by marking unreachable blocks Unlikely so that
   // they don't get any counts assigned