1 | /* Debug counter for debugging support |
2 | Copyright (C) 2006-2024 Free Software Foundation, Inc. |
3 | |
4 | This file is part of GCC. |
5 | |
6 | GCC is free software; you can redistribute it and/or modify it under |
7 | the terms of the GNU General Public License as published by the Free |
8 | Software Foundation; either version 3, or (at your option) any later |
9 | version. |
10 | |
11 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
12 | WARRANTY; without even the implied warranty of MERCHANTABILITY or |
13 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
14 | for more details. |
15 | |
16 | You should have received a copy of the GNU General Public License |
17 | along with GCC; see the file COPYING3. If not see |
18 | <http://www.gnu.org/licenses/>. |
19 | |
20 | See 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 | |
32 | struct string2counter_map { |
33 | const char *name; |
34 | enum debug_counter counter; |
35 | }; |
36 | |
37 | #define DEBUG_COUNTER(a) { #a , a }, |
38 | |
39 | static struct string2counter_map map[debug_counter_number_of_counters] = |
40 | { |
41 | #include "dbgcnt.def" |
42 | }; |
43 | #undef DEBUG_COUNTER |
44 | |
45 | typedef std::pair<unsigned int, unsigned int> limit_tuple; |
46 | |
47 | static vec<limit_tuple> limits[debug_counter_number_of_counters]; |
48 | static vec<limit_tuple> original_limits[debug_counter_number_of_counters]; |
49 | |
50 | static unsigned int count[debug_counter_number_of_counters]; |
51 | |
52 | static void |
53 | print_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 | |
63 | bool |
64 | dbg_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 | |
103 | unsigned |
104 | dbg_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 | |
111 | static int |
112 | cmp_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 | |
124 | static bool |
125 | dbg_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 | |
151 | static bool |
152 | dbg_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 | |
181 | static bool |
182 | dbg_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 | |
207 | void |
208 | dbg_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 | |
234 | void |
235 | dbg_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 | |
263 | namespace selftest { |
264 | |
265 | /* Selftests. */ |
266 | |
267 | static void |
268 | test_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 | |
274 | void |
275 | dbgcnt_cc_tests () |
276 | { |
277 | test_sorted_dbg_counters (); |
278 | } |
279 | |
280 | } // namespace selftest |
281 | |
282 | #endif /* #if CHECKING_P */ |
283 | |