1 | /* Optimization statistics functions. |
2 | Copyright (C) 2008-2023 Free Software Foundation, Inc. |
3 | Contributed by Richard Guenther <rguenther@suse.de> |
4 | |
5 | This file is part of GCC. |
6 | |
7 | GCC is free software; you can redistribute it and/or modify it under |
8 | the terms of the GNU General Public License as published by the Free |
9 | Software Foundation; either version 3, or (at your option) any later |
10 | version. |
11 | |
12 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
13 | WARRANTY; without even the implied warranty of MERCHANTABILITY or |
14 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
15 | for more details. |
16 | |
17 | You should have received a copy of the GNU General Public License |
18 | along with GCC; see the file COPYING3. If not see |
19 | <http://www.gnu.org/licenses/>. */ |
20 | |
21 | #include "config.h" |
22 | #include "system.h" |
23 | #include "coretypes.h" |
24 | #include "function.h" |
25 | #include "tree-pass.h" |
26 | #include "context.h" |
27 | #include "pass_manager.h" |
28 | #include "tree.h" |
29 | |
30 | static int statistics_dump_nr; |
31 | static dump_flags_t statistics_dump_flags; |
32 | static FILE *statistics_dump_file; |
33 | |
34 | /* Statistics entry. A integer counter associated to a string ID |
35 | and value. */ |
36 | |
37 | struct statistics_counter { |
38 | const char *id; |
39 | int val; |
40 | bool histogram_p; |
41 | unsigned HOST_WIDE_INT count; |
42 | unsigned HOST_WIDE_INT prev_dumped_count; |
43 | }; |
44 | |
45 | /* Hashtable helpers. */ |
46 | |
47 | struct stats_counter_hasher : pointer_hash <statistics_counter> |
48 | { |
49 | static inline hashval_t hash (const statistics_counter *); |
50 | static inline bool equal (const statistics_counter *, |
51 | const statistics_counter *); |
52 | static inline void remove (statistics_counter *); |
53 | }; |
54 | |
55 | /* Hash a statistic counter by its string ID. */ |
56 | |
57 | inline hashval_t |
58 | stats_counter_hasher::hash (const statistics_counter *c) |
59 | { |
60 | return htab_hash_string (c->id) + c->val; |
61 | } |
62 | |
63 | /* Compare two statistic counters by their string IDs. */ |
64 | |
65 | inline bool |
66 | stats_counter_hasher::equal (const statistics_counter *c1, |
67 | const statistics_counter *c2) |
68 | { |
69 | return c1->val == c2->val && strcmp (s1: c1->id, s2: c2->id) == 0; |
70 | } |
71 | |
72 | /* Free a statistics entry. */ |
73 | |
74 | inline void |
75 | stats_counter_hasher::remove (statistics_counter *v) |
76 | { |
77 | free (CONST_CAST (char *, v->id)); |
78 | free (ptr: v); |
79 | } |
80 | |
81 | typedef hash_table<stats_counter_hasher> stats_counter_table_type; |
82 | |
83 | /* Array of statistic hashes, indexed by pass id. */ |
84 | static stats_counter_table_type **statistics_hashes; |
85 | static unsigned nr_statistics_hashes; |
86 | |
87 | /* Return the current hashtable to be used for recording or printing |
88 | statistics. */ |
89 | |
90 | static stats_counter_table_type * |
91 | curr_statistics_hash (bool alloc = true) |
92 | { |
93 | unsigned idx; |
94 | |
95 | gcc_assert (current_pass->static_pass_number >= 0); |
96 | idx = current_pass->static_pass_number; |
97 | |
98 | if (idx < nr_statistics_hashes |
99 | && statistics_hashes[idx]) |
100 | return statistics_hashes[idx]; |
101 | |
102 | if (!alloc) |
103 | return nullptr; |
104 | |
105 | if (idx >= nr_statistics_hashes) |
106 | { |
107 | statistics_hashes = XRESIZEVEC (stats_counter_table_type *, |
108 | statistics_hashes, idx+1); |
109 | memset (s: statistics_hashes + nr_statistics_hashes, c: 0, |
110 | n: (idx + 1 - nr_statistics_hashes) |
111 | * sizeof (stats_counter_table_type *)); |
112 | nr_statistics_hashes = idx + 1; |
113 | } |
114 | |
115 | statistics_hashes[idx] = new stats_counter_table_type (15); |
116 | |
117 | return statistics_hashes[idx]; |
118 | } |
119 | |
120 | /* Helper function to return asmname or name of FN |
121 | depending on whether asmname option is set. */ |
122 | |
123 | static const char * |
124 | get_function_name (struct function *fn) |
125 | { |
126 | if ((statistics_dump_flags & TDF_ASMNAME) |
127 | && fn && DECL_ASSEMBLER_NAME_SET_P (fn->decl)) |
128 | { |
129 | tree asmname = decl_assembler_name (fn->decl); |
130 | if (asmname) |
131 | return IDENTIFIER_POINTER (asmname); |
132 | } |
133 | return function_name (fn); |
134 | } |
135 | |
136 | /* Helper for statistics_fini_pass. Print the counter difference |
137 | since the last dump for the pass dump files. */ |
138 | |
139 | int |
140 | statistics_fini_pass_1 (statistics_counter **slot, |
141 | void *data ATTRIBUTE_UNUSED) |
142 | { |
143 | statistics_counter *counter = *slot; |
144 | unsigned HOST_WIDE_INT count = counter->count - counter->prev_dumped_count; |
145 | if (count == 0) |
146 | return 1; |
147 | if (counter->histogram_p) |
148 | fprintf (stream: dump_file, format: "%s == %d: " HOST_WIDE_INT_PRINT_DEC "\n" , |
149 | counter->id, counter->val, count); |
150 | else |
151 | fprintf (stream: dump_file, format: "%s: " HOST_WIDE_INT_PRINT_DEC "\n" , |
152 | counter->id, count); |
153 | counter->prev_dumped_count = counter->count; |
154 | return 1; |
155 | } |
156 | |
157 | /* Helper for statistics_fini_pass. Print the counter difference |
158 | since the last dump for the statistics dump. */ |
159 | |
160 | int |
161 | statistics_fini_pass_2 (statistics_counter **slot, |
162 | void *data ATTRIBUTE_UNUSED) |
163 | { |
164 | statistics_counter *counter = *slot; |
165 | unsigned HOST_WIDE_INT count = counter->count - counter->prev_dumped_count; |
166 | if (count == 0) |
167 | return 1; |
168 | counter->prev_dumped_count = counter->count; |
169 | if (counter->histogram_p) |
170 | fprintf (stream: statistics_dump_file, |
171 | format: "%d %s \"%s == %d\" \"%s\" " HOST_WIDE_INT_PRINT_DEC "\n" , |
172 | current_pass->static_pass_number, |
173 | current_pass->name, |
174 | counter->id, counter->val, |
175 | get_function_name (cfun), |
176 | count); |
177 | else |
178 | fprintf (stream: statistics_dump_file, |
179 | format: "%d %s \"%s\" \"%s\" " HOST_WIDE_INT_PRINT_DEC "\n" , |
180 | current_pass->static_pass_number, |
181 | current_pass->name, |
182 | counter->id, |
183 | get_function_name (cfun), |
184 | count); |
185 | counter->prev_dumped_count = counter->count; |
186 | return 1; |
187 | } |
188 | |
189 | /* Helper for statistics_fini_pass, reset the counters. */ |
190 | |
191 | int |
192 | statistics_fini_pass_3 (statistics_counter **slot, |
193 | void *data ATTRIBUTE_UNUSED) |
194 | { |
195 | statistics_counter *counter = *slot; |
196 | counter->prev_dumped_count = counter->count; |
197 | return 1; |
198 | } |
199 | |
200 | /* Dump the current statistics incrementally. */ |
201 | |
202 | void |
203 | statistics_fini_pass (void) |
204 | { |
205 | if (current_pass->static_pass_number == -1) |
206 | return; |
207 | |
208 | stats_counter_table_type *stat_hash = curr_statistics_hash (alloc: false); |
209 | |
210 | if (dump_file |
211 | && dump_flags & TDF_STATS) |
212 | { |
213 | fprintf (stream: dump_file, format: "\n" ); |
214 | fprintf (stream: dump_file, format: "Pass statistics of \"%s\": " , current_pass->name); |
215 | fprintf (stream: dump_file, format: "----------------\n" ); |
216 | if (stat_hash) |
217 | stat_hash->traverse_noresize <void *, statistics_fini_pass_1> (NULL); |
218 | fprintf (stream: dump_file, format: "\n" ); |
219 | } |
220 | |
221 | if (!stat_hash) |
222 | return; |
223 | |
224 | if (statistics_dump_file |
225 | && !(statistics_dump_flags & TDF_STATS |
226 | || statistics_dump_flags & TDF_DETAILS)) |
227 | stat_hash->traverse_noresize <void *, statistics_fini_pass_2> (NULL); |
228 | stat_hash->traverse_noresize <void *, statistics_fini_pass_3> (NULL); |
229 | } |
230 | |
231 | /* Helper for printing summary information. */ |
232 | |
233 | int |
234 | statistics_fini_1 (statistics_counter **slot, opt_pass *pass) |
235 | { |
236 | statistics_counter *counter = *slot; |
237 | if (counter->count == 0) |
238 | return 1; |
239 | if (counter->histogram_p) |
240 | fprintf (stream: statistics_dump_file, |
241 | format: "%d %s \"%s == %d\" " HOST_WIDE_INT_PRINT_DEC "\n" , |
242 | pass->static_pass_number, |
243 | pass->name, |
244 | counter->id, counter->val, |
245 | counter->count); |
246 | else |
247 | fprintf (stream: statistics_dump_file, |
248 | format: "%d %s \"%s\" " HOST_WIDE_INT_PRINT_DEC "\n" , |
249 | pass->static_pass_number, |
250 | pass->name, |
251 | counter->id, |
252 | counter->count); |
253 | return 1; |
254 | } |
255 | |
256 | /* Finish the statistics and dump summary information. */ |
257 | |
258 | void |
259 | statistics_fini (void) |
260 | { |
261 | gcc::pass_manager *passes = g->get_passes (); |
262 | if (!statistics_dump_file) |
263 | return; |
264 | |
265 | if (statistics_dump_flags & TDF_STATS) |
266 | { |
267 | unsigned i; |
268 | for (i = 0; i < nr_statistics_hashes; ++i) |
269 | if (statistics_hashes[i] |
270 | && passes->get_pass_for_id (id: i) != NULL) |
271 | statistics_hashes[i] |
272 | ->traverse_noresize <opt_pass *, statistics_fini_1> |
273 | (argument: passes->get_pass_for_id (id: i)); |
274 | } |
275 | |
276 | dump_end (statistics_dump_nr, statistics_dump_file); |
277 | } |
278 | |
279 | /* Register the statistics dump file. */ |
280 | |
281 | void |
282 | statistics_early_init (void) |
283 | { |
284 | gcc::dump_manager *dumps = g->get_dumps (); |
285 | statistics_dump_nr = dumps->dump_register (suffix: ".statistics" , swtch: "statistics" , |
286 | glob: "statistics" , dkind: DK_tree, |
287 | optgroup_flags: OPTGROUP_NONE, |
288 | take_ownership: false); |
289 | } |
290 | |
291 | /* Init the statistics. */ |
292 | |
293 | void |
294 | statistics_init (void) |
295 | { |
296 | gcc::dump_manager *dumps = g->get_dumps (); |
297 | statistics_dump_file = dump_begin (statistics_dump_nr, NULL); |
298 | statistics_dump_flags = dumps->get_dump_file_info (phase: statistics_dump_nr)->pflags; |
299 | } |
300 | |
301 | /* Lookup or add a statistics counter in the hashtable HASH with ID, VAL |
302 | and HISTOGRAM_P. */ |
303 | |
304 | static statistics_counter * |
305 | lookup_or_add_counter (stats_counter_table_type *hash, const char *id, int val, |
306 | bool histogram_p) |
307 | { |
308 | statistics_counter **counter; |
309 | statistics_counter c; |
310 | c.id = id; |
311 | c.val = val; |
312 | counter = hash->find_slot (value: &c, insert: INSERT); |
313 | if (!*counter) |
314 | { |
315 | *counter = XNEW (statistics_counter); |
316 | (*counter)->id = xstrdup (id); |
317 | (*counter)->val = val; |
318 | (*counter)->histogram_p = histogram_p; |
319 | (*counter)->prev_dumped_count = 0; |
320 | (*counter)->count = 0; |
321 | } |
322 | return *counter; |
323 | } |
324 | |
325 | /* Add statistics information about event ID in function FN. |
326 | This will increment the counter associated with ID by INCR. |
327 | It will also dump the event to the global statistics file if requested. */ |
328 | |
329 | void |
330 | statistics_counter_event (struct function *fn, const char *id, int incr) |
331 | { |
332 | statistics_counter *counter; |
333 | |
334 | if ((!(dump_flags & TDF_STATS) |
335 | && !statistics_dump_file) |
336 | || incr == 0) |
337 | return; |
338 | |
339 | if (current_pass |
340 | && current_pass->static_pass_number != -1) |
341 | { |
342 | counter = lookup_or_add_counter (hash: curr_statistics_hash (), id, val: 0, histogram_p: false); |
343 | gcc_assert (!counter->histogram_p); |
344 | counter->count += incr; |
345 | } |
346 | |
347 | if (!statistics_dump_file |
348 | || !(statistics_dump_flags & TDF_DETAILS)) |
349 | return; |
350 | |
351 | fprintf (stream: statistics_dump_file, |
352 | format: "%d %s \"%s\" \"%s\" %d\n" , |
353 | current_pass ? current_pass->static_pass_number : -1, |
354 | current_pass ? current_pass->name : "none" , |
355 | id, |
356 | get_function_name (fn), |
357 | incr); |
358 | } |
359 | |
360 | /* Add statistics information about event ID in function FN with the |
361 | histogram value VAL. |
362 | It will dump the event to the global statistics file if requested. */ |
363 | |
364 | void |
365 | statistics_histogram_event (struct function *fn, const char *id, int val) |
366 | { |
367 | statistics_counter *counter; |
368 | |
369 | if (!(dump_flags & TDF_STATS) |
370 | && !statistics_dump_file) |
371 | return; |
372 | |
373 | counter = lookup_or_add_counter (hash: curr_statistics_hash (), id, val, histogram_p: true); |
374 | gcc_assert (counter->histogram_p); |
375 | counter->count += 1; |
376 | |
377 | if (!statistics_dump_file |
378 | || !(statistics_dump_flags & TDF_DETAILS)) |
379 | return; |
380 | |
381 | fprintf (stream: statistics_dump_file, |
382 | format: "%d %s \"%s == %d\" \"%s\" 1\n" , |
383 | current_pass->static_pass_number, |
384 | current_pass->name, |
385 | id, val, |
386 | get_function_name (fn)); |
387 | } |
388 | |