gcc/statistics.c

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