1/* Debug counter for debugging support
2 Copyright (C) 2006-2024 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>.
19
20See dbgcnt.def for usage information. */
21
22#include "config.h"
23#include "system.h"
24#include "coretypes.h"
25#include "diagnostic-core.h"
26#include "dumpfile.h"
27#include "selftest.h"
28#include "intl.h"
29
30#include "dbgcnt.h"
31
32struct string2counter_map {
33 const char *name;
34 enum debug_counter counter;
35};
36
37#define DEBUG_COUNTER(a) { #a , a },
38
39static struct string2counter_map map[debug_counter_number_of_counters] =
40{
41#include "dbgcnt.def"
42};
43#undef DEBUG_COUNTER
44
45typedef std::pair<unsigned int, unsigned int> limit_tuple;
46
47static vec<limit_tuple> limits[debug_counter_number_of_counters];
48static vec<limit_tuple> original_limits[debug_counter_number_of_counters];
49
50static unsigned int count[debug_counter_number_of_counters];
51
52static void
53print_limit_reach (const char *counter, int limit, bool upper_p)
54{
55 char buffer[128];
56 sprintf (s: buffer, format: "***dbgcnt: %s limit %d reached for %s.***\n",
57 upper_p ? "upper" : "lower", limit, counter);
58 fputs (s: buffer, stderr);
59 if (dump_file)
60 fputs (s: buffer, stream: dump_file);
61}
62
63bool
64dbg_cnt (enum debug_counter index)
65{
66 unsigned v = ++count[index];
67
68 if (!limits[index].exists ())
69 return true;
70 else if (limits[index].is_empty ())
71 return false;
72
73 unsigned last = limits[index].length () - 1;
74 unsigned int min = limits[index][last].first;
75 unsigned int max = limits[index][last].second;
76
77 if (v < min)
78 return false;
79 else if (v == min)
80 {
81 print_limit_reach (counter: map[index].name, limit: v, upper_p: false);
82 if (min == max)
83 {
84 print_limit_reach (counter: map[index].name, limit: v, upper_p: true);
85 limits[index].pop ();
86 }
87 return true;
88 }
89 else if (v < max)
90 return true;
91 else if (v == max)
92 {
93 print_limit_reach (counter: map[index].name, limit: v, upper_p: true);
94 limits[index].pop ();
95 return true;
96 }
97 else
98 return false;
99}
100
101/* Return the counter for INDEX. */
102
103unsigned
104dbg_cnt_counter (enum debug_counter index)
105{
106 return count[index];
107}
108
109/* Compare limit_tuple intervals by first item in descending order. */
110
111static int
112cmp_tuples (const void *ptr1, const void *ptr2)
113{
114 const limit_tuple *p1 = (const limit_tuple *)ptr1;
115 const limit_tuple *p2 = (const limit_tuple *)ptr2;
116
117 if (p1->first < p2->first)
118 return 1;
119 else if (p1->first > p2->first)
120 return -1;
121 return 0;
122}
123
124static bool
125dbg_cnt_set_limit_by_index (enum debug_counter index, const char *name,
126 unsigned int low, unsigned int high)
127{
128 if (!limits[index].exists ())
129 limits[index].create (nelems: 1);
130
131 limits[index].safe_push (obj: limit_tuple (low, high));
132 limits[index].qsort (cmp_tuples);
133
134 for (unsigned i = 0; i < limits[index].length () - 1; i++)
135 {
136 limit_tuple t1 = limits[index][i];
137 limit_tuple t2 = limits[index][i + 1];
138 if (t1.first <= t2.second)
139 {
140 error ("Interval overlap of %<-fdbg-cnt=%s%>: [%u, %u] and "
141 "[%u, %u]", name, t2.first, t2.second, t1.first, t1.second);
142 return false;
143 }
144 }
145
146 original_limits[index] = limits[index].copy ();
147
148 return true;
149}
150
151static bool
152dbg_cnt_set_limit_by_name (const char *name, unsigned int low,
153 unsigned int high)
154{
155 if (high < low)
156 {
157 error ("%<-fdbg-cnt=%s:%d-%d%> has smaller upper limit than the lower",
158 name, low, high);
159 return false;
160 }
161
162 int i;
163 for (i = debug_counter_number_of_counters - 1; i >= 0; i--)
164 if (strcmp (s1: map[i].name, s2: name) == 0)
165 break;
166
167 if (i < 0)
168 {
169 error ("cannot find a valid counter name %qs of %<-fdbg-cnt=%> option",
170 name);
171 return false;
172 }
173
174 return dbg_cnt_set_limit_by_index (index: (enum debug_counter) i, name, low, high);
175}
176
177/* Process a single "low:high" pair.
178 Returns NULL if there's no valid pair is found.
179 Otherwise returns a pointer to the end of the pair. */
180
181static bool
182dbg_cnt_process_single_pair (char *name, char *str)
183{
184 char *value1 = strtok (s: str, delim: "-");
185 char *value2 = strtok (NULL, delim: "-");
186
187 unsigned int high, low;
188
189 if (value1 == NULL)
190 return false;
191
192 if (value2 == NULL)
193 {
194 high = strtol (nptr: value1, NULL, base: 10);
195 /* Let's allow 0:0. */
196 low = high == 0 ? 0 : 1;
197 }
198 else
199 {
200 low = strtol (nptr: value1, NULL, base: 10);
201 high = strtol (nptr: value2, NULL, base: 10);
202 }
203
204 return dbg_cnt_set_limit_by_name (name, low, high);
205}
206
207void
208dbg_cnt_process_opt (const char *arg)
209{
210 char *str = xstrdup (arg);
211
212 auto_vec<char *> tokens;
213 for (char *next = strtok (s: str, delim: ","); next != NULL; next = strtok (NULL, delim: ","))
214 tokens.safe_push (obj: next);
215
216 unsigned i;
217 for (i = 0; i < tokens.length (); i++)
218 {
219 auto_vec<char *> ranges;
220 char *name = strtok (s: tokens[i], delim: ":");
221 for (char *part = strtok (NULL, delim: ":"); part; part = strtok (NULL, delim: ":"))
222 ranges.safe_push (obj: part);
223
224 for (unsigned j = 0; j < ranges.length (); j++)
225 {
226 if (!dbg_cnt_process_single_pair (name, str: ranges[j]))
227 break;
228 }
229 }
230}
231
232/* Print name, limit and count of all counters. */
233
234void
235dbg_cnt_list_all_counters (void)
236{
237 int i;
238 fprintf (stderr, format: " %-30s%-15s %s\n", G_("counter name"),
239 G_("counter value"), G_("closed intervals"));
240 fprintf (stderr, format: "-----------------------------------------------------------------\n");
241 for (i = 0; i < debug_counter_number_of_counters; i++)
242 {
243 fprintf (stderr, format: " %-30s%-15d ", map[i].name, count[i]);
244 if (original_limits[i].exists ())
245 {
246 for (int j = original_limits[i].length () - 1; j >= 0; j--)
247 {
248 fprintf (stderr, format: "[%u, %u]", original_limits[i][j].first,
249 original_limits[i][j].second);
250 if (j > 0)
251 fprintf (stderr, format: ", ");
252 }
253 fprintf (stderr, format: "\n");
254 }
255 else
256 fprintf (stderr, format: "unset\n");
257 }
258 fprintf (stderr, format: "\n");
259}
260
261#if CHECKING_P
262
263namespace selftest {
264
265/* Selftests. */
266
267static void
268test_sorted_dbg_counters ()
269{
270 for (unsigned i = 0; i < debug_counter_number_of_counters - 1; i++)
271 ASSERT_LT (strcmp (map[i].name, map[i + 1].name), 0);
272}
273
274void
275dbgcnt_cc_tests ()
276{
277 test_sorted_dbg_counters ();
278}
279
280} // namespace selftest
281
282#endif /* #if CHECKING_P */
283

source code of gcc/dbgcnt.cc