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