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
8using namespace llvm;
9
10namespace llvm {
11
12void DebugCounter::Chunk::print(llvm::raw_ostream &OS) {
13 if (Begin == End)
14 OS << Begin;
15 else
16 OS << Begin << "-" << End;
17}
18
19void DebugCounter::printChunks(raw_ostream &OS, ArrayRef<Chunk> Chunks) {
20 if (Chunks.empty()) {
21 OS << "empty";
22 } else {
23 bool IsFirst = true;
24 for (auto E : Chunks) {
25 if (!IsFirst)
26 OS << ':';
27 else
28 IsFirst = false;
29 E.print(OS);
30 }
31 }
32}
33
34bool DebugCounter::parseChunks(StringRef Str, SmallVector<Chunk> &Chunks) {
35 StringRef Remaining = Str;
36
37 auto ConsumeInt = [&]() -> int64_t {
38 StringRef Number =
39 Remaining.take_until(F: [](char c) { return c < '0' || c > '9'; });
40 int64_t Res;
41 if (Number.getAsInteger(Radix: 10, Result&: Res)) {
42 errs() << "Failed to parse int at : " << Remaining << "\n";
43 return -1;
44 }
45 Remaining = Remaining.drop_front(N: Number.size());
46 return Res;
47 };
48
49 while (1) {
50 int64_t Num = ConsumeInt();
51 if (Num == -1)
52 return true;
53 if (!Chunks.empty() && Num <= Chunks[Chunks.size() - 1].End) {
54 errs() << "Expected Chunks to be in increasing order " << Num
55 << " <= " << Chunks[Chunks.size() - 1].End << "\n";
56 return true;
57 }
58 if (Remaining.starts_with(Prefix: "-")) {
59 Remaining = Remaining.drop_front();
60 int64_t Num2 = ConsumeInt();
61 if (Num2 == -1)
62 return true;
63 if (Num >= Num2) {
64 errs() << "Expected " << Num << " < " << Num2 << " in " << Num << "-"
65 << Num2 << "\n";
66 return true;
67 }
68
69 Chunks.push_back(Elt: {.Begin: Num, .End: Num2});
70 } else {
71 Chunks.push_back(Elt: {.Begin: Num, .End: Num});
72 }
73 if (Remaining.starts_with(Prefix: ":")) {
74 Remaining = Remaining.drop_front();
75 continue;
76 }
77 if (Remaining.empty())
78 break;
79 errs() << "Failed to parse at : " << Remaining;
80 return true;
81 }
82 return false;
83}
84
85} // namespace llvm
86
87namespace {
88// This class overrides the default list implementation of printing so we
89// can pretty print the list of debug counter options. This type of
90// dynamic option is pretty rare (basically this and pass lists).
91class DebugCounterList : public cl::list<std::string, DebugCounter> {
92private:
93 using Base = cl::list<std::string, DebugCounter>;
94
95public:
96 template <class... Mods>
97 explicit DebugCounterList(Mods &&... Ms) : Base(std::forward<Mods>(Ms)...) {}
98
99private:
100 void printOptionInfo(size_t GlobalWidth) const override {
101 // This is a variant of from generic_parser_base::printOptionInfo. Sadly,
102 // it's not easy to make it more usable. We could get it to print these as
103 // options if we were a cl::opt and registered them, but lists don't have
104 // options, nor does the parser for std::string. The other mechanisms for
105 // options are global and would pollute the global namespace with our
106 // counters. Rather than go that route, we have just overridden the
107 // printing, which only a few things call anyway.
108 outs() << " -" << ArgStr;
109 // All of the other options in CommandLine.cpp use ArgStr.size() + 6 for
110 // width, so we do the same.
111 Option::printHelpStr(HelpStr, Indent: GlobalWidth, FirstLineIndentedBy: ArgStr.size() + 6);
112 const auto &CounterInstance = DebugCounter::instance();
113 for (const auto &Name : CounterInstance) {
114 const auto Info =
115 CounterInstance.getCounterInfo(ID: CounterInstance.getCounterId(Name));
116 size_t NumSpaces = GlobalWidth - Info.first.size() - 8;
117 outs() << " =" << Info.first;
118 outs().indent(NumSpaces) << " - " << Info.second << '\n';
119 }
120 }
121};
122
123// All global objects associated to the DebugCounter, including the DebugCounter
124// itself, are owned by a single global instance of the DebugCounterOwner
125// struct. This makes it easier to control the order in which constructors and
126// destructors are run.
127struct DebugCounterOwner : DebugCounter {
128 DebugCounterList DebugCounterOption{
129 "debug-counter", cl::Hidden,
130 cl::desc("Comma separated list of debug counter skip and count"),
131 cl::CommaSeparated, cl::location<DebugCounter>(L&: *this)};
132 cl::opt<bool, true> PrintDebugCounter{
133 "print-debug-counter",
134 cl::Hidden,
135 cl::Optional,
136 cl::location(L&: this->ShouldPrintCounter),
137 cl::init(Val: false),
138 cl::desc("Print out debug counter info after all counters accumulated")};
139 cl::opt<bool, true> BreakOnLastCount{
140 "debug-counter-break-on-last",
141 cl::Hidden,
142 cl::Optional,
143 cl::location(L&: this->BreakOnLast),
144 cl::init(Val: false),
145 cl::desc("Insert a break point on the last enabled count of a "
146 "chunks list")};
147
148 DebugCounterOwner() {
149 // Our destructor uses the debug stream. By referencing it here, we
150 // ensure that its destructor runs after our destructor.
151 (void)dbgs();
152 }
153
154 // Print information when destroyed, iff command line option is specified.
155 ~DebugCounterOwner() {
156 if (ShouldPrintCounter)
157 print(OS&: dbgs());
158 }
159};
160
161} // anonymous namespace
162
163void llvm::initDebugCounterOptions() { (void)DebugCounter::instance(); }
164
165DebugCounter &DebugCounter::instance() {
166 static DebugCounterOwner O;
167 return O;
168}
169
170// This is called by the command line parser when it sees a value for the
171// debug-counter option defined above.
172void DebugCounter::push_back(const std::string &Val) {
173 if (Val.empty())
174 return;
175#ifdef NDEBUG
176 // isCountingEnabled is hardcoded to false in NDEBUG.
177 errs() << "Requested --debug-counter in LLVM build without assertions. This "
178 "is a no-op.\n";
179#endif
180
181 // The strings should come in as counter=chunk_list
182 auto CounterPair = StringRef(Val).split(Separator: '=');
183 if (CounterPair.second.empty()) {
184 errs() << "DebugCounter Error: " << Val << " does not have an = in it\n";
185 return;
186 }
187 StringRef CounterName = CounterPair.first;
188 SmallVector<Chunk> Chunks;
189
190 if (parseChunks(Str: CounterPair.second, Chunks)) {
191 return;
192 }
193
194 unsigned CounterID = getCounterId(Name: std::string(CounterName));
195 if (!CounterID) {
196 errs() << "DebugCounter Error: " << CounterName
197 << " is not a registered counter\n";
198 return;
199 }
200 enableAllCounters();
201
202 CounterInfo &Counter = Counters[CounterID];
203 Counter.IsSet = true;
204 Counter.Chunks = std::move(Chunks);
205}
206
207void DebugCounter::print(raw_ostream &OS) const {
208 SmallVector<StringRef, 16> CounterNames(RegisteredCounters.begin(),
209 RegisteredCounters.end());
210 sort(C&: CounterNames);
211
212 auto &Us = instance();
213 OS << "Counters and values:\n";
214 for (auto &CounterName : CounterNames) {
215 unsigned CounterID = getCounterId(Name: std::string(CounterName));
216 const CounterInfo &C = Us.Counters[CounterID];
217 OS << left_justify(Str: RegisteredCounters[CounterID], Width: 32) << ": {" << C.Count
218 << ",";
219 printChunks(OS, Chunks: C.Chunks);
220 OS << "}\n";
221 }
222}
223
224bool DebugCounter::shouldExecuteImpl(unsigned CounterName) {
225 auto &Us = instance();
226 auto Result = Us.Counters.find(Val: CounterName);
227 if (Result != Us.Counters.end()) {
228 auto &CounterInfo = Result->second;
229 int64_t CurrCount = CounterInfo.Count++;
230 uint64_t CurrIdx = CounterInfo.CurrChunkIdx;
231
232 if (CounterInfo.Chunks.empty())
233 return true;
234 if (CurrIdx >= CounterInfo.Chunks.size())
235 return false;
236
237 bool Res = CounterInfo.Chunks[CurrIdx].contains(Idx: CurrCount);
238 if (Us.BreakOnLast && CurrIdx == (CounterInfo.Chunks.size() - 1) &&
239 CurrCount == CounterInfo.Chunks[CurrIdx].End) {
240 LLVM_BUILTIN_DEBUGTRAP;
241 }
242 if (CurrCount > CounterInfo.Chunks[CurrIdx].End) {
243 CounterInfo.CurrChunkIdx++;
244
245 /// Handle consecutive blocks.
246 if (CounterInfo.CurrChunkIdx < CounterInfo.Chunks.size() &&
247 CurrCount == CounterInfo.Chunks[CounterInfo.CurrChunkIdx].Begin)
248 return true;
249 }
250 return Res;
251 }
252 // Didn't find the counter, should we warn?
253 return true;
254}
255
256#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
257LLVM_DUMP_METHOD void DebugCounter::dump() const {
258 print(dbgs());
259}
260#endif
261