[BOLT] Update buildCallGraph to check for split blocks

[FPar]

Summary

Use isSplit() instead of isCold() when building the call graph and
update parameter names to reflect this.

[rafauler]

lgtm

bolt/include/bolt/Passes/BinaryFunctionCallGraph.h

 
 using CgFilterFunction = std::function<bool(const BinaryFunction &BF)>;
 inline bool NoFilter(const BinaryFunction &) { return false; }
 
 /// Builds a call graph from the map of BinaryFunctions provided in BC.
 /// The arguments control how the graph is constructed.
 /// Filter is called on each function, any function that it returns true for
 /// is omitted from the graph.
-/// If IncludeColdCalls is true, then calls from cold BBs are considered for the
-/// graph, otherwise they are ignored.
-/// UseFunctionHotSize controls whether the hot size of a function is used when
-/// filling in the Size attribute of new Nodes.
-/// UseEdgeCounts is used to control if the Weight attribute on Arcs is computed
-/// using the number of calls.
+/// If IncludeSplitCalls is true, then calls from cold BBs are considered for
+/// the graph, otherwise they are ignored. UseFunctionHotSize controls whether
+/// the hot size of a function is used when filling in the Size attribute of new
+/// Nodes. UseEdgeCounts is used to control if the Weight attribute on Arcs is
+/// computed using the number of calls.
 BinaryFunctionCallGraph
 buildCallGraph(BinaryContext &BC, CgFilterFunction Filter = NoFilter,
-               bool CgFromPerfData = false, bool IncludeColdCalls = true,
+               bool CgFromPerfData = false, bool IncludeSplitCalls = true,
                bool UseFunctionHotSize = false, bool UseSplitHotSize = false,
                bool UseEdgeCounts = false, bool IgnoreRecursiveCalls = false);
 
 } // namespace bolt
 } // namespace llvm
 
 #endif

bolt/lib/Passes/BinaryFunctionCallGraph.cpp

while (!Worklist.empty()) {
     }
   }
 
   return TopologicalOrder;
 }
 
 BinaryFunctionCallGraph
 buildCallGraph(BinaryContext &BC, CgFilterFunction Filter, bool CgFromPerfData,
-               bool IncludeColdCalls, bool UseFunctionHotSize,
+               bool IncludeSplitCalls, bool UseFunctionHotSize,
                bool UseSplitHotSize, bool UseEdgeCounts,
                bool IgnoreRecursiveCalls) {
   NamedRegionTimer T1("buildcg", "Callgraph construction", "CG breakdown",
                       "CG breakdown", opts::TimeOpts);
   BinaryFunctionCallGraph Cg;
   static constexpr uint64_t COUNT_NO_PROFILE =
       BinaryBasicBlock::COUNT_NO_PROFILE;
 
if (!Function->hasValidProfile() && CgFromPerfData &&
         if (Offset > Size)
           Offset = Size;
 
         if (!recordCall(CSI.Symbol, CSI.Count))
           ++NotProcessed;
       }
     } else {
       for (BinaryBasicBlock *BB : Function->getLayout().blocks()) {
-        // Don't count calls from cold blocks unless requested.
-        if (BB->isCold() && !IncludeColdCalls)
+        // Don't count calls from split blocks unless requested.
+        if (BB->isSplit() && !IncludeSplitCalls)
           continue;
 
         // Determine whether the block is included in Function's (hot) size
         // See BinaryFunction::estimateHotSize
         bool BBIncludedInFunctionSize = false;
         if (UseFunctionHotSize && Function->isSplit()) {
           if (UseSplitHotSize)
-            BBIncludedInFunctionSize = !BB->isCold();
+            BBIncludedInFunctionSize = !BB->isSplit();
           else
             BBIncludedInFunctionSize = BB->getKnownExecutionCount() != 0;
         } else {
           BBIncludedInFunctionSize = true;
         }
 
         for (MCInst &Inst : *BB) {
           // Find call instructions and extract target symbols from each one.

bolt/lib/Passes/ReorderFunctions.cpp

 
 }
 
 void ReorderFunctions::runOnFunctions(BinaryContext &BC) {
   auto &BFs = BC.getBinaryFunctions();
   if (opts::ReorderFunctions != RT_NONE &&
       opts::ReorderFunctions != RT_EXEC_COUNT &&
       opts::ReorderFunctions != RT_USER) {
-    Cg = buildCallGraph(BC,
-                        [](const BinaryFunction &BF) {
-                          if (!BF.hasProfile())
-                            return true;
-                          if (BF.getState() != BinaryFunction::State::CFG)
-                            return true;
-                          return false;
-                        },
-                        opts::CgFromPerfData,
-                        false, // IncludeColdCalls
-                        opts::ReorderFunctionsUseHotSize,
-                        opts::CgUseSplitHotSize,
-                        opts::UseEdgeCounts,
-                        opts::CgIgnoreRecursiveCalls);
+    Cg = buildCallGraph(
+        BC,
+        /*IncludeSplitCalls=*/false, opts::ReorderFunctionsUseHotSize,
+        opts::CgUseSplitHotSize, opts::UseEdgeCounts,
     Cg.normalizeArcWeights();
   }
 
   std::vector<Cluster> Clusters;
 
   switch (opts::ReorderFunctions) {
   case RT_NONE:
     break;