llvm/lib/Support/DebugCounter.cpp

   1 #include "llvm/Support/DebugCounter.h"
   2
   3 #include "DebugOptions.h"
   4
   5 #include "llvm/Support/CommandLine.h"
   6 #include "llvm/Support/Format.h"
   7 #include "llvm/Support/ManagedStatic.h"
   8
   9 using namespace llvm;
  10
  11 namespace {
  12 // This class overrides the default list implementation of printing so we
  13 // can pretty print the list of debug counter options.  This type of
  14 // dynamic option is pretty rare (basically this and pass lists).
  15 class DebugCounterList : public cl::list<std::string, DebugCounter> {
  16 private:
  17   using Base = cl::list<std::string, DebugCounter>;
  18
  19 public:
  20   template <class... Mods>
  21   explicit DebugCounterList(Mods &&... Ms) : Base(std::forward<Mods>(Ms)...) {}
  22
  23 private:
  24   void printOptionInfo(size_t GlobalWidth) const override {
  25     // This is a variant of from generic_parser_base::printOptionInfo.  Sadly,
  26     // it's not easy to make it more usable.  We could get it to print these as
  27     // options if we were a cl::opt and registered them, but lists don't have
  28     // options, nor does the parser for std::string.  The other mechanisms for
  29     // options are global and would pollute the global namespace with our
  30     // counters.  Rather than go that route, we have just overridden the
  31     // printing, which only a few things call anyway.
  32     outs() << "  -" << ArgStr;
  33     // All of the other options in CommandLine.cpp use ArgStr.size() + 6 for
  34     // width, so we do the same.
  35     Option::printHelpStr(HelpStr, GlobalWidth, ArgStr.size() + 6);
  36     const auto &CounterInstance = DebugCounter::instance();
  37     for (const auto &Name : CounterInstance) {
  38       const auto Info =
  39           CounterInstance.getCounterInfo(CounterInstance.getCounterId(Name));
  40       size_t NumSpaces = GlobalWidth - Info.first.size() - 8;
  41       outs() << "    =" << Info.first;
  42       outs().indent(NumSpaces) << " -   " << Info.second << '\n';
  43     }
  44   }
  45 };
  46
  47 struct CreateDebugCounterOption {
  48   static void *call() {
  49     return new DebugCounterList(
  50         "debug-counter", cl::Hidden,
  51         cl::desc("Comma separated list of debug counter skip and count"),
  52         cl::CommaSeparated, cl::ZeroOrMore,
  53         cl::location(DebugCounter::instance()));
  54   }
  55 };
  56 } // namespace
  57
  58 static ManagedStatic<DebugCounterList, CreateDebugCounterOption>
  59     DebugCounterOption;
  60 static bool PrintDebugCounter;
  61
  62 void llvm::initDebugCounterOptions() {
  63   *DebugCounterOption;
  64   static cl::opt<bool, true> RegisterPrintDebugCounter(
  65       "print-debug-counter", cl::Hidden, cl::location(PrintDebugCounter),
  66       cl::init(false), cl::Optional,
  67       cl::desc("Print out debug counter info after all counters accumulated"));
  68 }
  69
  70 static ManagedStatic<DebugCounter> DC;
  71
  72 // Print information when destroyed, iff command line option is specified.
  73 DebugCounter::~DebugCounter() {
  74   if (isCountingEnabled() && PrintDebugCounter)
  75     print(dbgs());
  76 }
  77
  78 DebugCounter &DebugCounter::instance() { return *DC; }
  79
  80 // This is called by the command line parser when it sees a value for the
  81 // debug-counter option defined above.
  82 void DebugCounter::push_back(const std::string &Val) {
  83   if (Val.empty())
  84     return;
  85   // The strings should come in as counter=value
  86   auto CounterPair = StringRef(Val).split('=');
  87   if (CounterPair.second.empty()) {
  88     errs() << "DebugCounter Error: " << Val << " does not have an = in it\n";
  89     return;
  90   }
  91   // Now we have counter=value.
  92   // First, process value.
  93   int64_t CounterVal;
  94   if (CounterPair.second.getAsInteger(0, CounterVal)) {
  95     errs() << "DebugCounter Error: " << CounterPair.second
  96            << " is not a number\n";
  97     return;
  98   }
  99   // Now we need to see if this is the skip or the count, remove the suffix, and
 100   // add it to the counter values.
 101   if (CounterPair.first.endswith("-skip")) {
 102     auto CounterName = CounterPair.first.drop_back(5);
 103     unsigned CounterID = getCounterId(std::string(CounterName));
 104     if (!CounterID) {
 105       errs() << "DebugCounter Error: " << CounterName
 106              << " is not a registered counter\n";
 107       return;
 108     }
 109     enableAllCounters();
 110
 111     CounterInfo &Counter = Counters[CounterID];
 112     Counter.Skip = CounterVal;
 113     Counter.IsSet = true;
 114   } else if (CounterPair.first.endswith("-count")) {
 115     auto CounterName = CounterPair.first.drop_back(6);
 116     unsigned CounterID = getCounterId(std::string(CounterName));
 117     if (!CounterID) {
 118       errs() << "DebugCounter Error: " << CounterName
 119              << " is not a registered counter\n";
 120       return;
 121     }
 122     enableAllCounters();
 123
 124     CounterInfo &Counter = Counters[CounterID];
 125     Counter.StopAfter = CounterVal;
 126     Counter.IsSet = true;
 127   } else {
 128     errs() << "DebugCounter Error: " << CounterPair.first
 129            << " does not end with -skip or -count\n";
 130   }
 131 }
 132
 133 void DebugCounter::print(raw_ostream &OS) const {
 134   SmallVector<StringRef, 16> CounterNames(RegisteredCounters.begin(),
 135                                           RegisteredCounters.end());
 136   sort(CounterNames);
 137
 138   auto &Us = instance();
 139   OS << "Counters and values:\n";
 140   for (auto &CounterName : CounterNames) {
 141     unsigned CounterID = getCounterId(std::string(CounterName));
 142     OS << left_justify(RegisteredCounters[CounterID], 32) << ": {"
 143        << Us.Counters[CounterID].Count << "," << Us.Counters[CounterID].Skip
 144        << "," << Us.Counters[CounterID].StopAfter << "}\n";
 145   }
 146 }
 147
 148 LLVM_DUMP_METHOD void DebugCounter::dump() const {
 149   print(dbgs());
 150 }