OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [statistics.c] - Blame information for rev 283

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.