[BOLT][NFC] Minor cleanup in ICP getCallTargets and canPromoteCallsite

[Amir]

Summary

Minor refactoring. NFC.

[rafauler]

Thanks!

bolt/lib/Passes/IndirectCallPromotion.cpp

 }
 
 // Get list of targets for a given call sorted by most frequently
 // called first.
 std::vector<IndirectCallPromotion::Callsite>
 IndirectCallPromotion::getCallTargets(BinaryBasicBlock &BB,
                                       const MCInst &Inst) const {
   BinaryFunction &BF = *BB.getFunction();
-  BinaryContext &BC = BF.getBinaryContext();
+  const BinaryContext &BC = BF.getBinaryContext();
   std::vector<Callsite> Targets;
 
   if (const JumpTable *JT = BF.getJumpTable(Inst)) {
     // Don't support PIC jump tables for now
     if (!opts::ICPJumpTablesByTarget && JT->Type == JumpTable::JTT_PIC)
       return Targets;
     const Location From(BF.getSymbol());
     const std::pair<size_t, size_t> Range =
for (size_t I = 0; I < N; ++I) {
       assert(Targets[I].To.Sym && "All ICP targets must be to known symbols");
       assert(Targets[I].JTIndices.empty() &&
              "Can't have jump table indices for non-jump tables");
       SymTargets.emplace_back(Targets[I].To.Sym, 0);
     }
     return SymTargets;
   }
 
+  // Use memory profile to select hot targets.
   JumpTableInfoType HotTargets =
       maybeGetHotJumpTableTargets(BB, CallInst, TargetFetchInst, JT);
 
   auto findTargetsIndex = [&](uint64_t JTIndex) {
     for (size_t I = 0; I < Targets.size(); ++I)
       if (llvm::is_contained(Targets[I].JTIndices, JTIndex))
         return I;
     LLVM_DEBUG(dbgs() << "BOLT-ERROR: Unable to find target index for hot jump "
IndirectCallPromotion::fixCFG(BinaryBasicBlock &IndCallBlock,
   assert(Function.validateCFG());
 
   return MergeBlock;
 }
 
 size_t IndirectCallPromotion::canPromoteCallsite(
     const BinaryBasicBlock &BB, const MCInst &Inst,
     const std::vector<Callsite> &Targets, uint64_t NumCalls) {
+  BinaryFunction *BF = BB.getFunction();
+  const BinaryContext &BC = BF->getBinaryContext();
+
   if (BB.getKnownExecutionCount() < opts::ExecutionCountThreshold)
     return 0;
 
-  const bool IsJumpTable = BB.getFunction()->getJumpTable(Inst);
+  const bool IsJumpTable = BF->getJumpTable(Inst);
 
   auto computeStats = [&](size_t N) {
     for (size_t I = 0; I < N; ++I)
-      if (!IsJumpTable)
-        TotalNumFrequentCalls += Targets[I].Branches;
-      else
+      if (IsJumpTable)
         TotalNumFrequentJmps += Targets[I].Branches;
+      else
+        TotalNumFrequentCalls += Targets[I].Branches;
   };
 
   // If we have no targets (or no calls), skip this callsite.
   if (Targets.empty() || !NumCalls) {
     if (opts::Verbosity >= 1) {
       const ptrdiff_t InstIdx = &Inst - &(*BB.begin());
-      outs() << "BOLT-INFO: ICP failed in " << *BB.getFunction() << " @ "
-             << InstIdx << " in " << BB.getName() << ", calls = " << NumCalls
+      outs() << "BOLT-INFO: ICP failed in " << *BF << " @ " << InstIdx << " in "
+             << BB.getName() << ", calls = " << NumCalls
              << ", targets empty or NumCalls == 0.\n";
     }
     return 0;
   }
 
   size_t TopN = opts::ICPTopN;
   if (IsJumpTable)
     TopN = opts::ICPJumpTablesTopN ? opts::ICPJumpTablesTopN : TopN;
   else
     TopN = opts::ICPCallsTopN ? opts::ICPCallsTopN : TopN;
 
   const size_t TrialN = TopN ? std::min(TopN, Targets.size()) : Targets.size();
 
   if (opts::ICPTopCallsites > 0) {
-    BinaryContext &BC = BB.getFunction()->getBinaryContext();
     if (!BC.MIB->hasAnnotation(Inst, "DoICP"))
       return 0;
   }
 
   // Pick the top N targets.
   uint64_t TotalMispredictsTopN = 0;
   size_t N = 0;
 
if (opts::ICPUseMispredicts &&
 
     // Compute the misprediction frequency of the top N call targets.  If this
     // frequency is greater than the threshold, we should try ICP on this
     // callsite.
     const double TopNFrequency = (100.0 * TotalMispredictsTopN) / NumCalls;
     if (TopNFrequency == 0 || TopNFrequency < opts::ICPMispredictThreshold) {
       if (opts::Verbosity >= 1) {
         const ptrdiff_t InstIdx = &Inst - &(*BB.begin());
-        outs() << "BOLT-INFO: ICP failed in " << *BB.getFunction() << " @ "
-               << InstIdx << " in " << BB.getName() << ", calls = " << NumCalls
+        outs() << "BOLT-INFO: ICP failed in " << *BF << " @ " << InstIdx
+               << " in " << BB.getName() << ", calls = " << NumCalls
                << ", top N mis. frequency " << format("%.1f", TopNFrequency)
                << "% < " << opts::ICPMispredictThreshold << "%\n";
       }
       return 0;
     }
   } else {
     size_t MaxTargets = 0;
 
if (!IsJumpTable || opts::ICPJumpTablesByTarget) {
       // this frequency is less than the threshold, we should skip ICP at
       // this callsite.
       const double TopNMispredictFrequency =
           (100.0 * TotalMispredictsTopN) / NumCalls;
 
       if (TopNMispredictFrequency < opts::ICPMispredictThreshold) {
         if (opts::Verbosity >= 1) {
           const ptrdiff_t InstIdx = &Inst - &(*BB.begin());
-          outs() << "BOLT-INFO: ICP failed in " << *BB.getFunction() << " @ "
-                 << InstIdx << " in " << BB.getName()
-                 << ", calls = " << NumCalls << ", top N mispredict frequency "
+          outs() << "BOLT-INFO: ICP failed in " << *BF << " @ " << InstIdx
+                 << " in " << BB.getName() << ", calls = " << NumCalls
+                 << ", top N mispredict frequency "
                  << format("%.1f", TopNMispredictFrequency) << "% < "
                  << opts::ICPMispredictThreshold << "%\n";
         }
         return 0;
       }
     }
   }
 
   // Filter functions that can have ICP applied (for debugging)
   if (!opts::ICPFuncsList.empty()) {
     for (std::string &Name : opts::ICPFuncsList)
-      if (BB.getFunction()->hasName(Name))
+      if (BF->hasName(Name))
         return N;
     return 0;
   }
 
   return N;
 }
 
 void IndirectCallPromotion::printCallsiteInfo(