1 /* Optimization statistics functions. 2 Copyright (C) 2008-2015 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 "tree-pass.h" 25 #include "tree-dump.h" 26 #include "statistics.h" 27 #include "hash-table.h" 28 #include "hashtab.h" 29 #include "hash-set.h" 30 #include "vec.h" 31 #include "machmode.h" 32 #include "tm.h" 33 #include "hard-reg-set.h" 34 #include "input.h" 35 #include "function.h" 36 #include "context.h" 37 #include "pass_manager.h" 38 39 static int statistics_dump_nr; 40 static int statistics_dump_flags; 41 static FILE *statistics_dump_file; 42 43 /* Statistics entry. A integer counter associated to a string ID 44 and value. */ 45 46 typedef struct statistics_counter_s { 47 const char *id; 48 int val; 49 bool histogram_p; 50 unsigned HOST_WIDE_INT count; 51 unsigned HOST_WIDE_INT prev_dumped_count; 52 } statistics_counter_t; 53 54 /* Hashtable helpers. */ 55 56 struct stats_counter_hasher 57 { 58 typedef statistics_counter_t value_type; 59 typedef statistics_counter_t compare_type; 60 static inline hashval_t hash (const value_type *); 61 static inline bool equal (const value_type *, const compare_type *); 62 static inline void remove (value_type *); 63 }; 64 65 /* Hash a statistic counter by its string ID. */ 66 67 inline hashval_t 68 stats_counter_hasher::hash (const value_type *c) 69 { 70 return htab_hash_string (c->id) + c->val; 71 } 72 73 /* Compare two statistic counters by their string IDs. */ 74 75 inline bool 76 stats_counter_hasher::equal (const value_type *c1, const compare_type *c2) 77 { 78 return c1->val == c2->val && strcmp (c1->id, c2->id) == 0; 79 } 80 81 /* Free a statistics entry. */ 82 83 inline void 84 stats_counter_hasher::remove (value_type *v) 85 { 86 free (CONST_CAST (char *, v->id)); 87 free (v); 88 } 89 90 typedef hash_table<stats_counter_hasher> stats_counter_table_type; 91 92 /* Array of statistic hashes, indexed by pass id. */ 93 static stats_counter_table_type **statistics_hashes; 94 static unsigned nr_statistics_hashes; 95 96 /* Return the current hashtable to be used for recording or printing 97 statistics. */ 98 99 static stats_counter_table_type * 100 curr_statistics_hash (void) 101 { 102 unsigned idx; 103 104 gcc_assert (current_pass->static_pass_number >= 0); 105 idx = current_pass->static_pass_number; 106 107 if (idx < nr_statistics_hashes 108 && statistics_hashes[idx]) 109 return statistics_hashes[idx]; 110 111 if (idx >= nr_statistics_hashes) 112 { 113 statistics_hashes = XRESIZEVEC (stats_counter_table_type *, 114 statistics_hashes, idx+1); 115 memset (statistics_hashes + nr_statistics_hashes, 0, 116 (idx + 1 - nr_statistics_hashes) 117 * sizeof (stats_counter_table_type *)); 118 nr_statistics_hashes = idx + 1; 119 } 120 121 statistics_hashes[idx] = new stats_counter_table_type (15); 122 123 return statistics_hashes[idx]; 124 } 125 126 /* Helper for statistics_fini_pass. Print the counter difference 127 since the last dump for the pass dump files. */ 128 129 int 130 statistics_fini_pass_1 (statistics_counter_t **slot, 131 void *data ATTRIBUTE_UNUSED) 132 { 133 statistics_counter_t *counter = *slot; 134 unsigned HOST_WIDE_INT count = counter->count - counter->prev_dumped_count; 135 if (count == 0) 136 return 1; 137 if (counter->histogram_p) 138 fprintf (dump_file, "%s == %d: " HOST_WIDE_INT_PRINT_DEC "\n", 139 counter->id, counter->val, count); 140 else 141 fprintf (dump_file, "%s: " HOST_WIDE_INT_PRINT_DEC "\n", 142 counter->id, count); 143 counter->prev_dumped_count = counter->count; 144 return 1; 145 } 146 147 /* Helper for statistics_fini_pass. Print the counter difference 148 since the last dump for the statistics dump. */ 149 150 int 151 statistics_fini_pass_2 (statistics_counter_t **slot, 152 void *data ATTRIBUTE_UNUSED) 153 { 154 statistics_counter_t *counter = *slot; 155 unsigned HOST_WIDE_INT count = counter->count - counter->prev_dumped_count; 156 if (count == 0) 157 return 1; 158 counter->prev_dumped_count = counter->count; 159 if (counter->histogram_p) 160 fprintf (statistics_dump_file, 161 "%d %s \"%s == %d\" \"%s\" " HOST_WIDE_INT_PRINT_DEC "\n", 162 current_pass->static_pass_number, 163 current_pass->name, 164 counter->id, counter->val, 165 current_function_name (), 166 count); 167 else 168 fprintf (statistics_dump_file, 169 "%d %s \"%s\" \"%s\" " HOST_WIDE_INT_PRINT_DEC "\n", 170 current_pass->static_pass_number, 171 current_pass->name, 172 counter->id, 173 current_function_name (), 174 count); 175 counter->prev_dumped_count = counter->count; 176 return 1; 177 } 178 179 /* Helper for statistics_fini_pass, reset the counters. */ 180 181 int 182 statistics_fini_pass_3 (statistics_counter_t **slot, 183 void *data ATTRIBUTE_UNUSED) 184 { 185 statistics_counter_t *counter = *slot; 186 counter->prev_dumped_count = counter->count; 187 return 1; 188 } 189 190 /* Dump the current statistics incrementally. */ 191 192 void 193 statistics_fini_pass (void) 194 { 195 if (current_pass->static_pass_number == -1) 196 return; 197 198 if (dump_file 199 && dump_flags & TDF_STATS) 200 { 201 fprintf (dump_file, "\n"); 202 fprintf (dump_file, "Pass statistics:\n"); 203 fprintf (dump_file, "----------------\n"); 204 curr_statistics_hash () 205 ->traverse_noresize <void *, statistics_fini_pass_1> (NULL); 206 fprintf (dump_file, "\n"); 207 } 208 if (statistics_dump_file 209 && !(statistics_dump_flags & TDF_STATS 210 || statistics_dump_flags & TDF_DETAILS)) 211 curr_statistics_hash () 212 ->traverse_noresize <void *, statistics_fini_pass_2> (NULL); 213 curr_statistics_hash () 214 ->traverse_noresize <void *, statistics_fini_pass_3> (NULL); 215 } 216 217 /* Helper for printing summary information. */ 218 219 int 220 statistics_fini_1 (statistics_counter_t **slot, opt_pass *pass) 221 { 222 statistics_counter_t *counter = *slot; 223 if (counter->count == 0) 224 return 1; 225 if (counter->histogram_p) 226 fprintf (statistics_dump_file, 227 "%d %s \"%s == %d\" " HOST_WIDE_INT_PRINT_DEC "\n", 228 pass->static_pass_number, 229 pass->name, 230 counter->id, counter->val, 231 counter->count); 232 else 233 fprintf (statistics_dump_file, 234 "%d %s \"%s\" " HOST_WIDE_INT_PRINT_DEC "\n", 235 pass->static_pass_number, 236 pass->name, 237 counter->id, 238 counter->count); 239 return 1; 240 } 241 242 /* Finish the statistics and dump summary information. */ 243 244 void 245 statistics_fini (void) 246 { 247 gcc::pass_manager *passes = g->get_passes (); 248 if (!statistics_dump_file) 249 return; 250 251 if (statistics_dump_flags & TDF_STATS) 252 { 253 unsigned i; 254 for (i = 0; i < nr_statistics_hashes; ++i) 255 if (statistics_hashes[i] 256 && passes->get_pass_for_id (i) != NULL) 257 statistics_hashes[i] 258 ->traverse_noresize <opt_pass *, statistics_fini_1> 259 (passes->get_pass_for_id (i)); 260 } 261 262 dump_end (statistics_dump_nr, statistics_dump_file); 263 } 264 265 /* Register the statistics dump file. */ 266 267 void 268 statistics_early_init (void) 269 { 270 gcc::dump_manager *dumps = g->get_dumps (); 271 statistics_dump_nr = dumps->dump_register (".statistics", "statistics", 272 "statistics", TDF_TREE, 273 OPTGROUP_NONE, 274 false); 275 } 276 277 /* Init the statistics. */ 278 279 void 280 statistics_init (void) 281 { 282 gcc::dump_manager *dumps = g->get_dumps (); 283 statistics_dump_file = dump_begin (statistics_dump_nr, NULL); 284 statistics_dump_flags = dumps->get_dump_file_info (statistics_dump_nr)->pflags; 285 } 286 287 /* Lookup or add a statistics counter in the hashtable HASH with ID, VAL 288 and HISTOGRAM_P. */ 289 290 static statistics_counter_t * 291 lookup_or_add_counter (stats_counter_table_type *hash, const char *id, int val, 292 bool histogram_p) 293 { 294 statistics_counter_t **counter; 295 statistics_counter_t c; 296 c.id = id; 297 c.val = val; 298 counter = hash->find_slot (&c, INSERT); 299 if (!*counter) 300 { 301 *counter = XNEW (struct statistics_counter_s); 302 (*counter)->id = xstrdup (id); 303 (*counter)->val = val; 304 (*counter)->histogram_p = histogram_p; 305 (*counter)->prev_dumped_count = 0; 306 (*counter)->count = 0; 307 } 308 return *counter; 309 } 310 311 /* Add statistics information about event ID in function FN. 312 This will increment the counter associated with ID by INCR. 313 It will also dump the event to the global statistics file if requested. */ 314 315 void 316 statistics_counter_event (struct function *fn, const char *id, int incr) 317 { 318 statistics_counter_t *counter; 319 320 if ((!(dump_flags & TDF_STATS) 321 && !statistics_dump_file) 322 || incr == 0) 323 return; 324 325 if (current_pass->static_pass_number != -1) 326 { 327 counter = lookup_or_add_counter (curr_statistics_hash (), id, 0, false); 328 gcc_assert (!counter->histogram_p); 329 counter->count += incr; 330 } 331 332 if (!statistics_dump_file 333 || !(statistics_dump_flags & TDF_DETAILS)) 334 return; 335 336 fprintf (statistics_dump_file, 337 "%d %s \"%s\" \"%s\" %d\n", 338 current_pass->static_pass_number, 339 current_pass->name, 340 id, 341 function_name (fn), 342 incr); 343 } 344 345 /* Add statistics information about event ID in function FN with the 346 histogram value VAL. 347 It will dump the event to the global statistics file if requested. */ 348 349 void 350 statistics_histogram_event (struct function *fn, const char *id, int val) 351 { 352 statistics_counter_t *counter; 353 354 if (!(dump_flags & TDF_STATS) 355 && !statistics_dump_file) 356 return; 357 358 counter = lookup_or_add_counter (curr_statistics_hash (), id, val, true); 359 gcc_assert (counter->histogram_p); 360 counter->count += 1; 361 362 if (!statistics_dump_file 363 || !(statistics_dump_flags & TDF_DETAILS)) 364 return; 365 366 fprintf (statistics_dump_file, 367 "%d %s \"%s == %d\" \"%s\" 1\n", 368 current_pass->static_pass_number, 369 current_pass->name, 370 id, val, 371 function_name (fn)); 372 } 373