2013-11-21 Edward Smith-Rowland <3dw4rd@verizon.net>
[official-gcc.git] / gcc / statistics.c
blob51d3f3af088c7959a2d41c1a54f368c8d66579b3
1 /* Optimization statistics functions.
2 Copyright (C) 2008-2013 Free Software Foundation, Inc.
3 Contributed by Richard Guenther <rguenther@suse.de>
5 This file is part of GCC.
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.
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.
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/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tree-pass.h"
25 #include "tree-dump.h"
26 #include "statistics.h"
27 #include "hash-table.h"
28 #include "function.h"
29 #include "context.h"
30 #include "pass_manager.h"
32 static int statistics_dump_nr;
33 static int statistics_dump_flags;
34 static FILE *statistics_dump_file;
36 /* Statistics entry. A integer counter associated to a string ID
37 and value. */
39 typedef struct statistics_counter_s {
40 const char *id;
41 int val;
42 bool histogram_p;
43 unsigned HOST_WIDE_INT count;
44 unsigned HOST_WIDE_INT prev_dumped_count;
45 } statistics_counter_t;
47 /* Hashtable helpers. */
49 struct stats_counter_hasher
51 typedef statistics_counter_t value_type;
52 typedef statistics_counter_t compare_type;
53 static inline hashval_t hash (const value_type *);
54 static inline bool equal (const value_type *, const compare_type *);
55 static inline void remove (value_type *);
58 /* Hash a statistic counter by its string ID. */
60 inline hashval_t
61 stats_counter_hasher::hash (const value_type *c)
63 return htab_hash_string (c->id) + c->val;
66 /* Compare two statistic counters by their string IDs. */
68 inline bool
69 stats_counter_hasher::equal (const value_type *c1, const compare_type *c2)
71 return c1->val == c2->val && strcmp (c1->id, c2->id) == 0;
74 /* Free a statistics entry. */
76 inline void
77 stats_counter_hasher::remove (value_type *v)
79 free (CONST_CAST (char *, v->id));
80 free (v);
83 typedef hash_table <stats_counter_hasher> stats_counter_table_type;
85 /* Array of statistic hashes, indexed by pass id. */
86 static stats_counter_table_type *statistics_hashes;
87 static unsigned nr_statistics_hashes;
89 /* Return the current hashtable to be used for recording or printing
90 statistics. */
92 static stats_counter_table_type
93 curr_statistics_hash (void)
95 unsigned idx;
97 gcc_assert (current_pass->static_pass_number >= 0);
98 idx = current_pass->static_pass_number;
100 if (idx < nr_statistics_hashes
101 && statistics_hashes[idx].is_created ())
102 return statistics_hashes[idx];
104 if (idx >= nr_statistics_hashes)
106 statistics_hashes = XRESIZEVEC (stats_counter_table_type,
107 statistics_hashes, idx+1);
108 memset (statistics_hashes + nr_statistics_hashes, 0,
109 (idx + 1 - nr_statistics_hashes)
110 * sizeof (stats_counter_table_type));
111 nr_statistics_hashes = idx + 1;
114 statistics_hashes[idx].create (15);
116 return statistics_hashes[idx];
119 /* Helper for statistics_fini_pass. Print the counter difference
120 since the last dump for the pass dump files. */
123 statistics_fini_pass_1 (statistics_counter_t **slot,
124 void *data ATTRIBUTE_UNUSED)
126 statistics_counter_t *counter = *slot;
127 unsigned HOST_WIDE_INT count = counter->count - counter->prev_dumped_count;
128 if (count == 0)
129 return 1;
130 if (counter->histogram_p)
131 fprintf (dump_file, "%s == %d: " HOST_WIDE_INT_PRINT_DEC "\n",
132 counter->id, counter->val, count);
133 else
134 fprintf (dump_file, "%s: " HOST_WIDE_INT_PRINT_DEC "\n",
135 counter->id, count);
136 counter->prev_dumped_count = counter->count;
137 return 1;
140 /* Helper for statistics_fini_pass. Print the counter difference
141 since the last dump for the statistics dump. */
144 statistics_fini_pass_2 (statistics_counter_t **slot,
145 void *data ATTRIBUTE_UNUSED)
147 statistics_counter_t *counter = *slot;
148 unsigned HOST_WIDE_INT count = counter->count - counter->prev_dumped_count;
149 if (count == 0)
150 return 1;
151 counter->prev_dumped_count = counter->count;
152 if (counter->histogram_p)
153 fprintf (statistics_dump_file,
154 "%d %s \"%s == %d\" \"%s\" " HOST_WIDE_INT_PRINT_DEC "\n",
155 current_pass->static_pass_number,
156 current_pass->name,
157 counter->id, counter->val,
158 current_function_name (),
159 count);
160 else
161 fprintf (statistics_dump_file,
162 "%d %s \"%s\" \"%s\" " HOST_WIDE_INT_PRINT_DEC "\n",
163 current_pass->static_pass_number,
164 current_pass->name,
165 counter->id,
166 current_function_name (),
167 count);
168 counter->prev_dumped_count = counter->count;
169 return 1;
172 /* Helper for statistics_fini_pass, reset the counters. */
175 statistics_fini_pass_3 (statistics_counter_t **slot,
176 void *data ATTRIBUTE_UNUSED)
178 statistics_counter_t *counter = *slot;
179 counter->prev_dumped_count = counter->count;
180 return 1;
183 /* Dump the current statistics incrementally. */
185 void
186 statistics_fini_pass (void)
188 if (current_pass->static_pass_number == -1)
189 return;
191 if (dump_file
192 && dump_flags & TDF_STATS)
194 fprintf (dump_file, "\n");
195 fprintf (dump_file, "Pass statistics:\n");
196 fprintf (dump_file, "----------------\n");
197 curr_statistics_hash ()
198 .traverse_noresize <void *, statistics_fini_pass_1> (NULL);
199 fprintf (dump_file, "\n");
201 if (statistics_dump_file
202 && !(statistics_dump_flags & TDF_STATS
203 || statistics_dump_flags & TDF_DETAILS))
204 curr_statistics_hash ()
205 .traverse_noresize <void *, statistics_fini_pass_2> (NULL);
206 curr_statistics_hash ()
207 .traverse_noresize <void *, statistics_fini_pass_3> (NULL);
210 /* Helper for printing summary information. */
213 statistics_fini_1 (statistics_counter_t **slot, opt_pass *pass)
215 statistics_counter_t *counter = *slot;
216 if (counter->count == 0)
217 return 1;
218 if (counter->histogram_p)
219 fprintf (statistics_dump_file,
220 "%d %s \"%s == %d\" " HOST_WIDE_INT_PRINT_DEC "\n",
221 pass->static_pass_number,
222 pass->name,
223 counter->id, counter->val,
224 counter->count);
225 else
226 fprintf (statistics_dump_file,
227 "%d %s \"%s\" " HOST_WIDE_INT_PRINT_DEC "\n",
228 pass->static_pass_number,
229 pass->name,
230 counter->id,
231 counter->count);
232 return 1;
235 /* Finish the statistics and dump summary information. */
237 void
238 statistics_fini (void)
240 gcc::pass_manager *passes = g->get_passes ();
241 if (!statistics_dump_file)
242 return;
244 if (statistics_dump_flags & TDF_STATS)
246 unsigned i;
247 for (i = 0; i < nr_statistics_hashes; ++i)
248 if (statistics_hashes[i].is_created ()
249 && passes->get_pass_for_id (i) != NULL)
250 statistics_hashes[i]
251 .traverse_noresize <opt_pass *, statistics_fini_1>
252 (passes->get_pass_for_id (i));
255 dump_end (statistics_dump_nr, statistics_dump_file);
258 /* Register the statistics dump file. */
260 void
261 statistics_early_init (void)
263 gcc::dump_manager *dumps = g->get_dumps ();
264 statistics_dump_nr = dumps->dump_register (".statistics", "statistics",
265 "statistics", TDF_TREE,
266 OPTGROUP_NONE);
269 /* Init the statistics. */
271 void
272 statistics_init (void)
274 gcc::dump_manager *dumps = g->get_dumps ();
275 statistics_dump_file = dump_begin (statistics_dump_nr, NULL);
276 statistics_dump_flags = dumps->get_dump_file_info (statistics_dump_nr)->pflags;
279 /* Lookup or add a statistics counter in the hashtable HASH with ID, VAL
280 and HISTOGRAM_P. */
282 static statistics_counter_t *
283 lookup_or_add_counter (stats_counter_table_type hash, const char *id, int val,
284 bool histogram_p)
286 statistics_counter_t **counter;
287 statistics_counter_t c;
288 c.id = id;
289 c.val = val;
290 counter = hash.find_slot (&c, INSERT);
291 if (!*counter)
293 *counter = XNEW (struct statistics_counter_s);
294 (*counter)->id = xstrdup (id);
295 (*counter)->val = val;
296 (*counter)->histogram_p = histogram_p;
297 (*counter)->prev_dumped_count = 0;
298 (*counter)->count = 0;
300 return *counter;
303 /* Add statistics information about event ID in function FN.
304 This will increment the counter associated with ID by INCR.
305 It will also dump the event to the global statistics file if requested. */
307 void
308 statistics_counter_event (struct function *fn, const char *id, int incr)
310 statistics_counter_t *counter;
312 if ((!(dump_flags & TDF_STATS)
313 && !statistics_dump_file)
314 || incr == 0)
315 return;
317 if (current_pass->static_pass_number != -1)
319 counter = lookup_or_add_counter (curr_statistics_hash (), id, 0, false);
320 gcc_assert (!counter->histogram_p);
321 counter->count += incr;
324 if (!statistics_dump_file
325 || !(statistics_dump_flags & TDF_DETAILS))
326 return;
328 fprintf (statistics_dump_file,
329 "%d %s \"%s\" \"%s\" %d\n",
330 current_pass->static_pass_number,
331 current_pass->name,
333 function_name (fn),
334 incr);
337 /* Add statistics information about event ID in function FN with the
338 histogram value VAL.
339 It will dump the event to the global statistics file if requested. */
341 void
342 statistics_histogram_event (struct function *fn, const char *id, int val)
344 statistics_counter_t *counter;
346 if (!(dump_flags & TDF_STATS)
347 && !statistics_dump_file)
348 return;
350 counter = lookup_or_add_counter (curr_statistics_hash (), id, val, true);
351 gcc_assert (counter->histogram_p);
352 counter->count += 1;
354 if (!statistics_dump_file
355 || !(statistics_dump_flags & TDF_DETAILS))
356 return;
358 fprintf (statistics_dump_file,
359 "%d %s \"%s == %d\" \"%s\" 1\n",
360 current_pass->static_pass_number,
361 current_pass->name,
362 id, val,
363 function_name (fn));