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 } 151