1/* Optimization statistics functions.
2 Copyright (C) 2008-2025 Free Software Foundation, Inc.
3 Contributed by Richard Guenther <rguenther@suse.de>
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along 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
30static int statistics_dump_nr;
31static dump_flags_t statistics_dump_flags;
32static FILE *statistics_dump_file;
33
34/* Statistics entry. A integer counter associated to a string ID
35 and value. */
36
37struct 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
47struct 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
57inline hashval_t
58stats_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
65inline bool
66stats_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
74inline void
75stats_counter_hasher::remove (statistics_counter *v)
76{
77 free (CONST_CAST (char *, v->id));
78 free (ptr: v);
79}
80
81typedef hash_table<stats_counter_hasher> stats_counter_table_type;
82
83/* Array of statistic hashes, indexed by pass id. */
84static stats_counter_table_type **statistics_hashes;
85static unsigned nr_statistics_hashes;
86
87/* Return the current hashtable to be used for recording or printing
88 statistics. */
89
90static stats_counter_table_type *
91curr_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
123static const char *
124get_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
139int
140statistics_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
160int
161statistics_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
191int
192statistics_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
202void
203statistics_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
233int
234statistics_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
258void
259statistics_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
281void
282statistics_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
293void
294statistics_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
304static statistics_counter *
305lookup_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
329void
330statistics_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
364void
365statistics_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

source code of gcc/statistics.cc