[BOLT][NFC] Make ICP options naming uniform

[Amir]

Summary

Rename opts::IndirectCallPromotion* to opts::ICP*, making option naming
uniform and easier to follow.

[rafauler]

LGTM

bolt/lib/Core/BinaryFunctionProfile.cpp

 
 using namespace llvm;
 using namespace bolt;
 
 namespace opts {
 
 extern cl::OptionCategory BoltOptCategory;
 
-cl::opt<IndirectCallPromotionType>
-IndirectCallPromotion("indirect-call-promotion",
-  cl::init(ICP_NONE),
+cl::opt<IndirectCallPromotionType> ICP(
+    "indirect-call-promotion", cl::init(ICP_NONE),
     cl::desc("indirect call promotion"),
     cl::values(
         clEnumValN(ICP_NONE, "none", "do not perform indirect call promotion"),
         clEnumValN(ICP_CALLS, "calls", "perform ICP on indirect calls"),
-    clEnumValN(ICP_JUMP_TABLES, "jump-tables", "perform ICP on jump tables"),
+        clEnumValN(ICP_JUMP_TABLES, "jump-tables",
+                   "perform ICP on jump tables"),
         clEnumValN(ICP_ALL, "all", "perform ICP on calls and jump tables")),
-  cl::ZeroOrMore,
-  cl::cat(BoltOptCategory));
+    cl::ZeroOrMore, cl::cat(BoltOptCategory));
 
 extern cl::opt<JumpTableSupportLevel> JumpTables;
 
 static cl::opt<bool>
 FixFuncCounts("fix-func-counts",
   cl::desc("adjust function counts based on basic blocks execution count"),
   cl::init(false),
   cl::ZeroOrMore,
for (BinaryBasicBlock *BB : BasicBlocks) {
 
     uint64_t TotalBranchCount = 0;
     for (const BinaryBasicBlock::BinaryBranchInfo &BranchInfo :
          BB->branch_info()) {
       TotalBranchCount += BranchInfo.Count;
     }
     JT->Count += TotalBranchCount;
 
-    if (opts::IndirectCallPromotion < ICP_JUMP_TABLES &&
-        opts::JumpTables < JTS_AGGRESSIVE)
+    if (opts::ICP < ICP_JUMP_TABLES && opts::JumpTables < JTS_AGGRESSIVE)
       continue;
 
     if (JT->Counts.empty())
       JT->Counts.resize(JT->Entries.size());
     auto EI = JT->Entries.begin();
     uint64_t Delta = (JTAddress - JT->getAddress()) / JT->EntrySize;
     EI += Delta;
     while (EI != JT->Entries.end()) {

bolt/lib/Passes/IndirectCallPromotion.cpp

 
 using namespace llvm;
 using namespace bolt;
 
 namespace opts {
 
 extern cl::OptionCategory BoltOptCategory;
 
-extern cl::opt<IndirectCallPromotionType> IndirectCallPromotion;
+extern cl::opt<IndirectCallPromotionType> ICP;
 extern cl::opt<unsigned> Verbosity;
 extern cl::opt<unsigned> ExecutionCountThreshold;
 
 static cl::opt<unsigned> ICPJTRemainingPercentThreshold(
     "icp-jt-remaining-percent-threshold",
     cl::desc("The percentage threshold against remaining unpromoted indirect "
              "call count for the promotion for jump tables"),
     cl::init(30), cl::ZeroOrMore, cl::Hidden, cl::cat(BoltOptCategory));

 
 static cl::opt<unsigned> ICPCallsTotalPercentThreshold(
     "icp-calls-total-percent-threshold",
     cl::desc(
         "The percentage threshold against total count for the promotion for "
         "calls"),
     cl::init(30), cl::ZeroOrMore, cl::Hidden, cl::cat(BoltOptCategory));
 
-static cl::opt<unsigned> IndirectCallPromotionMispredictThreshold(
+static cl::opt<unsigned> ICPMispredictThreshold(
     "indirect-call-promotion-mispredict-threshold",
     cl::desc("misprediction threshold for skipping ICP on an "
              "indirect call"),
     cl::init(0), cl::ZeroOrMore, cl::cat(BoltOptCategory));
 
-static cl::opt<bool> IndirectCallPromotionUseMispredicts(
+static cl::opt<bool> ICPUseMispredicts(
     "indirect-call-promotion-use-mispredicts",
     cl::desc("use misprediction frequency for determining whether or not ICP "
              "should be applied at a callsite.  The "
              "-indirect-call-promotion-mispredict-threshold value will be used "
              "by this heuristic"),
     cl::ZeroOrMore, cl::cat(BoltOptCategory));
 
-static cl::opt<unsigned> IndirectCallPromotionTopN(
-    "indirect-call-promotion-topn",
+static cl::opt<unsigned>
+    ICPTopN("indirect-call-promotion-topn",
             cl::desc("limit number of targets to consider when doing indirect "
                      "call promotion. 0 = no limit"),
             cl::init(3), cl::ZeroOrMore, cl::cat(BoltOptCategory));
 
-static cl::opt<unsigned> IndirectCallPromotionCallsTopN(
+static cl::opt<unsigned> ICPCallsTopN(
     "indirect-call-promotion-calls-topn",
     cl::desc("limit number of targets to consider when doing indirect "
              "call promotion on calls. 0 = no limit"),
     cl::init(0), cl::ZeroOrMore, cl::cat(BoltOptCategory));
 
-static cl::opt<unsigned> IndirectCallPromotionJumpTablesTopN(
+static cl::opt<unsigned> ICPJumpTablesTopN(
     "indirect-call-promotion-jump-tables-topn",
     cl::desc("limit number of targets to consider when doing indirect "
              "call promotion on jump tables. 0 = no limit"),
     cl::init(0), cl::ZeroOrMore, cl::cat(BoltOptCategory));
 
 static cl::opt<bool> EliminateLoads(
     "icp-eliminate-loads",
     cl::desc("enable load elimination using memory profiling data when "
if (!HotTargets.empty()) {
     std::map<const MCSymbol *, uint32_t> IndicesPerTarget;
     uint64_t TotalMemAccesses = 0;
     for (size_t I = 0; I < HotTargets.size(); ++I) {
       const uint64_t TargetIndex = findTargetsIndex(HotTargets[I].second);
       ++IndicesPerTarget[Targets[TargetIndex].To.Sym];
       TotalMemAccesses += HotTargets[I].first;
     }
     uint64_t RemainingMemAccesses = TotalMemAccesses;
-    const size_t TopN = opts::IndirectCallPromotionJumpTablesTopN != 0
-                            ? opts::IndirectCallPromotionTopN
-                            : opts::IndirectCallPromotionTopN;
+    const size_t TopN =
+        opts::ICPJumpTablesTopN != 0 ? opts::ICPTopN : opts::ICPTopN;
     size_t I = 0;
     for (; I < HotTargets.size(); ++I) {
       const uint64_t MemAccesses = HotTargets[I].first;
       if (100 * MemAccesses <
           TotalMemAccesses * opts::ICPJTTotalPercentThreshold)
         break;
       if (100 * MemAccesses <
           RemainingMemAccesses * opts::ICPJTRemainingPercentThreshold)
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
              << ", targets empty or NumCalls == 0.\n";
     }
     return 0;
   }
 
-  size_t TopN = opts::IndirectCallPromotionTopN;
+  size_t TopN = opts::ICPTopN;
   if (IsJumpTable) {
-    if (opts::IndirectCallPromotionJumpTablesTopN != 0)
-      TopN = opts::IndirectCallPromotionJumpTablesTopN;
-  } else if (opts::IndirectCallPromotionCallsTopN != 0) {
-    TopN = opts::IndirectCallPromotionCallsTopN;
+    if (opts::ICPJumpTablesTopN != 0)
+      TopN = opts::ICPJumpTablesTopN;
+  } else if (opts::ICPCallsTopN != 0) {
+    TopN = opts::ICPCallsTopN;
   }
   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::IndirectCallPromotionUseMispredicts &&
+  if (opts::ICPUseMispredicts &&
       (!IsJumpTable || opts::ICPJumpTablesByTarget)) {
     // Count total number of mispredictions for (at most) the top N targets.
     // We may choose a smaller N (TrialN vs. N) if the frequency threshold
     // is exceeded by fewer targets.
-    double Threshold = double(opts::IndirectCallPromotionMispredictThreshold);
+    double Threshold = double(opts::ICPMispredictThreshold);
     for (size_t I = 0; I < TrialN && Threshold > 0; ++I, ++N) {
       Threshold -= (100.0 * Targets[I].Mispreds) / NumCalls;
       TotalMispredictsTopN += Targets[I].Mispreds;
     }
     computeStats(N);
 
     // 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::IndirectCallPromotionMispredictThreshold) {
+    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
                << ", top N mis. frequency " << format("%.1f", TopNFrequency)
-               << "% < " << opts::IndirectCallPromotionMispredictThreshold
-               << "%\n";
+               << "% < " << opts::ICPMispredictThreshold << "%\n";
       }
       return 0;
     }
   } else {
     size_t MaxTargets = 0;
 
     // Count total number of calls for (at most) the top N targets.
     // We may choose a smaller N (TrialN vs. N) if the frequency threshold
if (opts::ICPUseMispredicts &&
     // care as long as we are saving loads from the jump table.
     if (!IsJumpTable || opts::ICPJumpTablesByTarget) {
       // Compute the misprediction frequency of the top N call targets.  If
       // this frequency is less than the threshold, we should skip ICP at
       // this callsite.
       const double TopNMispredictFrequency =
           (100.0 * TotalMispredictsTopN) / NumCalls;
 
-      if (TopNMispredictFrequency <
-          opts::IndirectCallPromotionMispredictThreshold) {
+      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 "
                  << format("%.1f", TopNMispredictFrequency) << "% < "
-                 << opts::IndirectCallPromotionMispredictThreshold << "%\n";
+                 << opts::ICPMispredictThreshold << "%\n";
         }
         return 0;
       }
     }
   }
 
   // Filter functions that can have ICP applied (for debugging)
   if (!opts::ICPFuncsList.empty()) {
void IndirectCallPromotion::printCallsiteInfo(
 
   LLVM_DEBUG({
     dbgs() << "BOLT-INFO: ICP original call instruction:";
     BC.printInstruction(dbgs(), Inst, Targets[0].From.Addr, nullptr, true);
   });
 }
 
 void IndirectCallPromotion::runOnFunctions(BinaryContext &BC) {
-  if (opts::IndirectCallPromotion == ICP_NONE)
+  if (opts::ICP == ICP_NONE)
     return;
 
   auto &BFs = BC.getBinaryFunctions();
 
-  const bool OptimizeCalls = (opts::IndirectCallPromotion == ICP_CALLS ||
-                              opts::IndirectCallPromotion == ICP_ALL);
+  const bool OptimizeCalls = (opts::ICP == ICP_CALLS || opts::ICP == ICP_ALL);
   const bool OptimizeJumpTables =
-      (opts::IndirectCallPromotion == ICP_JUMP_TABLES ||
-       opts::IndirectCallPromotion == ICP_ALL);
+      (opts::ICP == ICP_JUMP_TABLES || opts::ICP == ICP_ALL);
 
   std::unique_ptr<RegAnalysis> RA;
   std::unique_ptr<BinaryFunctionCallGraph> CG;
   if (OptimizeJumpTables) {
     CG.reset(new BinaryFunctionCallGraph(buildCallGraph(BC)));
     RA.reset(new RegAnalysis(BC, &BFs, &*CG));
   }