[BOLT] Minor refactoring for -print-sorted-by option

[maksfb]

Summary

Only display used values for -print-sorted-by option when printing help.

[maksfb]

Rebase+Lint

[maksfb]

Add Summary.

[hzq]

Looks good to me, looks more concise and intuitive.

bolt/include/bolt/Core/DynoStats.h

 namespace llvm {
 
 namespace bolt {
 class BinaryFunction;
 
 /// Class encapsulating runtime statistics about an execution unit.
 class DynoStats {
 
-#define DYNO_STATS\
-  D(FIRST_DYNO_STAT,              "<reserved>", Fn)\
-  D(FORWARD_COND_BRANCHES,        "executed forward branches", Fn)\
-  D(FORWARD_COND_BRANCHES_TAKEN,  "taken forward branches", Fn)\
-  D(BACKWARD_COND_BRANCHES,       "executed backward branches", Fn)\
-  D(BACKWARD_COND_BRANCHES_TAKEN, "taken backward branches", Fn)\
-  D(UNCOND_BRANCHES,              "executed unconditional branches", Fn)\
-  D(FUNCTION_CALLS,               "all function calls", Fn)\
-  D(INDIRECT_CALLS,               "indirect calls", Fn)\
-  D(PLT_CALLS,                    "PLT calls", Fn)\
-  D(INSTRUCTIONS,                 "executed instructions", Fn)\
-  D(LOADS,                        "executed load instructions", Fn)\
-  D(STORES,                       "executed store instructions", Fn)\
-  D(JUMP_TABLE_BRANCHES,          "taken jump table branches", Fn)\
-  D(UNKNOWN_INDIRECT_BRANCHES,    "taken unknown indirect branches", Fn)\
-  D(ALL_BRANCHES,                 "total branches",\
-      Fadd(ALL_CONDITIONAL, UNCOND_BRANCHES))\
-  D(ALL_TAKEN,                    "taken branches",\
-      Fadd(TAKEN_CONDITIONAL, UNCOND_BRANCHES))\
-  D(NONTAKEN_CONDITIONAL,         "non-taken conditional branches",\
-      Fsub(ALL_CONDITIONAL, TAKEN_CONDITIONAL))\
-  D(TAKEN_CONDITIONAL,            "taken conditional branches",\
-      Fadd(FORWARD_COND_BRANCHES_TAKEN, BACKWARD_COND_BRANCHES_TAKEN))\
-  D(ALL_CONDITIONAL,              "all conditional branches",\
-      Fadd(FORWARD_COND_BRANCHES, BACKWARD_COND_BRANCHES))\
-  D(VENEER_CALLS_AARCH64,         "linker-inserted veneer calls", Fn)\
-  D(LAST_DYNO_STAT,               "<reserved>", 0)
+#define REAL_DYNO_STATS                                                        \
+  D(FORWARD_COND_BRANCHES, "executed forward branches", Fn)                    \
+  D(FORWARD_COND_BRANCHES_TAKEN, "taken forward branches", Fn)                 \
+  D(BACKWARD_COND_BRANCHES, "executed backward branches", Fn)                  \
+  D(BACKWARD_COND_BRANCHES_TAKEN, "taken backward branches", Fn)               \
+  D(UNCOND_BRANCHES, "executed unconditional branches", Fn)                    \
+  D(FUNCTION_CALLS, "all function calls", Fn)                                  \
+  D(INDIRECT_CALLS, "indirect calls", Fn)                                      \
+  D(PLT_CALLS, "PLT calls", Fn)                                                \
+  D(INSTRUCTIONS, "executed instructions", Fn)                                 \
+  D(LOADS, "executed load instructions", Fn)                                   \
+  D(STORES, "executed store instructions", Fn)                                 \
+  D(JUMP_TABLE_BRANCHES, "taken jump table branches", Fn)                      \
+  D(UNKNOWN_INDIRECT_BRANCHES, "taken unknown indirect branches", Fn)          \
+  D(ALL_BRANCHES, "total branches", Fadd(ALL_CONDITIONAL, UNCOND_BRANCHES))    \
+  D(ALL_TAKEN, "taken branches", Fadd(TAKEN_CONDITIONAL, UNCOND_BRANCHES))     \
+  D(NONTAKEN_CONDITIONAL, "non-taken conditional branches",                    \
+    Fsub(ALL_CONDITIONAL, TAKEN_CONDITIONAL))                                  \
+  D(TAKEN_CONDITIONAL, "taken conditional branches",                           \
+    Fadd(FORWARD_COND_BRANCHES_TAKEN, BACKWARD_COND_BRANCHES_TAKEN))           \
+  D(ALL_CONDITIONAL, "all conditional branches",                               \
+    Fadd(FORWARD_COND_BRANCHES, BACKWARD_COND_BRANCHES))                       \
+  D(VENEER_CALLS_AARCH64, "linker-inserted veneer calls", Fn)
+
+#define DYNO_STATS                                                             \
+  D(FIRST_DYNO_STAT, "<reserved>", 0)                                          \
+  REAL_DYNO_STATS                                                              \
+  D(LAST_DYNO_STAT, "<reserved>", 0)
 
 public:
 #define D(name, ...) name,
   enum Category : uint8_t { DYNO_STATS };
 #undef D
 
 private:
   uint64_t Stats[LAST_DYNO_STAT + 1];

bolt/lib/Passes/BinaryPasses.cpp

 #define DEBUG_TYPE "bolt-opts"
 
 using namespace llvm;
 using namespace bolt;
 
 namespace {
 
 const char *dynoStatsOptName(const bolt::DynoStats::Category C) {
-  if (C == bolt::DynoStats::FIRST_DYNO_STAT)
-    return "none";
-  else if (C == bolt::DynoStats::LAST_DYNO_STAT)
-    return "all";
+  assert(C > bolt::DynoStats::FIRST_DYNO_STAT &&
+         C < DynoStats::LAST_DYNO_STAT && "Unexpected dyno stat category.");
 
   static std::string OptNames[bolt::DynoStats::LAST_DYNO_STAT + 1];
 
   OptNames[C] = bolt::DynoStats::Description(C);
 
   std::replace(OptNames[C].begin(), OptNames[C].end(), ' ', '-');
 
   return OptNames[C].c_str();
 }
-
-const char *dynoStatsOptDesc(const bolt::DynoStats::Category C) {
-  if (C == bolt::DynoStats::FIRST_DYNO_STAT)
-    return "unsorted";
-  else if (C == bolt::DynoStats::LAST_DYNO_STAT)
-    return "sorted by all stats";
-
-  return bolt::DynoStats::Description(C);
-}
-
 }
 
 namespace opts {
 
 extern cl::OptionCategory BoltCategory;
 extern cl::OptionCategory BoltOptCategory;
 
 extern cl::opt<bolt::MacroFusionType> AlignMacroOpFusion;
cl::values(clEnumValN(Peepholes::PEEP_NONE, "none", "disable peepholes"),
                           "enable all peephole optimizations")),
     cl::ZeroOrMore, cl::cat(BoltOptCategory));
 
 static cl::opt<unsigned>
     PrintFuncStat("print-function-statistics",
                   cl::desc("print statistics about basic block ordering"),
                   cl::init(0), cl::cat(BoltOptCategory));
 
-static cl::list<bolt::DynoStats::Category> PrintSortedBy(
-    "print-sorted-by", cl::CommaSeparated,
+static cl::list<bolt::DynoStats::Category>
+    PrintSortedBy("print-sorted-by", cl::CommaSeparated,
                   cl::desc("print functions sorted by order of dyno stats"),
                   cl::value_desc("key1,key2,key3,..."),
                   cl::values(
-#define D(name, ...)                                        \
-    clEnumValN(bolt::DynoStats::name,                     \
-               dynoStatsOptName(bolt::DynoStats::name),   \
-               dynoStatsOptDesc(bolt::DynoStats::name)),
-        DYNO_STATS
+#define D(name, description, ...)                                              \
+  clEnumValN(bolt::DynoStats::name, dynoStatsOptName(bolt::DynoStats::name),   \
+             description),
+                      REAL_DYNO_STATS
 #undef D
-            clEnumValN(bolt::DynoStats::LAST_DYNO_STAT, ".", ".")),
+                          clEnumValN(bolt::DynoStats::LAST_DYNO_STAT, "all",
+                                     "sorted by all names")),
                   cl::ZeroOrMore, cl::cat(BoltOptCategory));
 
 static cl::opt<bool>
     PrintUnknown("print-unknown",
                  cl::desc("print names of functions with unknown control flow"),
                  cl::cat(BoltCategory), cl::Hidden);
 
 static cl::opt<bool>
     PrintUnknownCFG("print-unknown-cfg",
if (opts::Verbosity >= 1) {
       auto SFI = ProfiledFunctions.begin();
       auto SFIend = ProfiledFunctions.end();
       for (unsigned I = 0u; I < opts::TopCalledLimit && SFI != SFIend;
            ++SFI, ++I)
         outs() << "  " << **SFI << " : " << (*SFI)->getExecutionCount() << '\n';
     }
   }
 
-  if (!opts::PrintSortedBy.empty() &&
-      !llvm::is_contained(opts::PrintSortedBy, DynoStats::FIRST_DYNO_STAT)) {
-
+  if (!opts::PrintSortedBy.empty()) {
     std::vector<BinaryFunction *> Functions;
     std::map<const BinaryFunction *, DynoStats> Stats;
 
     for (auto &BFI : BC.getBinaryFunctions()) {
       BinaryFunction &BF = BFI.second;
       if (shouldOptimize(BF) && BF.hasValidProfile()) {
         Functions.push_back(&BF);
         Stats.emplace(&BF, getDynoStats(BF));