1/* Vector API for GNU compiler.
2   Copyright (C) 2004-2015 Free Software Foundation, Inc.
3   Contributed by Nathan Sidwell <nathan@codesourcery.com>
4   Re-implemented in C++ by Diego Novillo <dnovillo@google.com>
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3.  If not see
20<http://www.gnu.org/licenses/>.  */
21
22/* This file is compiled twice: once for the generator programs
23   once for the compiler.  */
24#ifdef GENERATOR_FILE
25#include "bconfig.h"
26#else
27#include "config.h"
28#endif
29
30#include "system.h"
31#include "coretypes.h"
32#include "ggc.h"
33#include "vec.h"
34#include "diagnostic-core.h"
35#include "hashtab.h"
36
37/* vNULL is an empty type with a template cast operation that returns
38   a zero-initialized vec<T, A, L> instance.  Use this when you want
39   to assign nil values to new vec instances or pass a nil vector as
40   a function call argument.
41
42   We use this technique because vec<T, A, L> must be PODs (they are
43   stored in unions and passed in vararg functions), this means that
44   they cannot have ctors/dtors.  */
45vnull vNULL;
46
47
48/* Store information about each particular vector.  */
49struct vec_descriptor
50{
51  const char *function;
52  const char *file;
53  int line;
54  size_t allocated;
55  size_t times;
56  size_t peak;
57};
58
59
60/* Hashtable mapping vec addresses to descriptors.  */
61static htab_t vec_desc_hash;
62
63/* Hashtable helpers.  */
64static hashval_t
65hash_descriptor (const void *p)
66{
67  const struct vec_descriptor *const d =
68    (const struct vec_descriptor *) p;
69  return htab_hash_pointer (d->file) + d->line;
70}
71static int
72eq_descriptor (const void *p1, const void *p2)
73{
74  const struct vec_descriptor *const d = (const struct vec_descriptor *) p1;
75  const struct vec_descriptor *const l = (const struct vec_descriptor *) p2;
76  return d->file == l->file && d->function == l->function && d->line == l->line;
77}
78
79/* Hashtable converting address of allocated field to loc descriptor.  */
80static htab_t ptr_hash;
81struct ptr_hash_entry
82{
83  void *ptr;
84  struct vec_descriptor *loc;
85  size_t allocated;
86};
87
88/* Hash table helpers functions.  */
89static hashval_t
90hash_ptr (const void *p)
91{
92  const struct ptr_hash_entry *const d = (const struct ptr_hash_entry *) p;
93
94  return htab_hash_pointer (d->ptr);
95}
96
97static int
98eq_ptr (const void *p1, const void *p2)
99{
100  const struct ptr_hash_entry *const p = (const struct ptr_hash_entry *) p1;
101
102  return (p->ptr == p2);
103}
104
105/* Return descriptor for given call site, create new one if needed.  */
106static struct vec_descriptor *
107vec_descriptor (const char *name, int line, const char *function)
108{
109  struct vec_descriptor loc;
110  struct vec_descriptor **slot;
111
112  loc.file = name;
113  loc.line = line;
114  loc.function = function;
115  if (!vec_desc_hash)
116    vec_desc_hash = htab_create (10, hash_descriptor, eq_descriptor, NULL);
117
118  slot = (struct vec_descriptor **) htab_find_slot (vec_desc_hash, &loc,
119						    INSERT);
120  if (*slot)
121    return *slot;
122  *slot = XCNEW (struct vec_descriptor);
123  (*slot)->file = name;
124  (*slot)->line = line;
125  (*slot)->function = function;
126  (*slot)->allocated = 0;
127  (*slot)->peak = 0;
128  return *slot;
129}
130
131/* Account the overhead.  */
132
133void
134vec_prefix::register_overhead (size_t size, const char *name, int line,
135			       const char *function)
136{
137  struct vec_descriptor *loc = vec_descriptor (name, line, function);
138  struct ptr_hash_entry *p = XNEW (struct ptr_hash_entry);
139  PTR *slot;
140
141  p->ptr = this;
142  p->loc = loc;
143  p->allocated = size;
144  if (!ptr_hash)
145    ptr_hash = htab_create (10, hash_ptr, eq_ptr, NULL);
146  slot = htab_find_slot_with_hash (ptr_hash, this, htab_hash_pointer (this),
147				   INSERT);
148  gcc_assert (!*slot);
149  *slot = p;
150
151  loc->allocated += size;
152  if (loc->peak < loc->allocated)
153    loc->peak += loc->allocated;
154  loc->times++;
155}
156
157
158/* Notice that the memory allocated for the vector has been freed.  */
159
160void
161vec_prefix::release_overhead (void)
162{
163  PTR *slot = htab_find_slot_with_hash (ptr_hash, this,
164					htab_hash_pointer (this),
165					NO_INSERT);
166  struct ptr_hash_entry *p = (struct ptr_hash_entry *) *slot;
167  p->loc->allocated -= p->allocated;
168  htab_clear_slot (ptr_hash, slot);
169  ::free (p);
170}
171
172
173/* Calculate the number of slots to reserve a vector, making sure that
174   it is of at least DESIRED size by growing ALLOC exponentially.  */
175
176unsigned
177vec_prefix::calculate_allocation_1 (unsigned alloc, unsigned desired)
178{
179  /* We must have run out of room.  */
180  gcc_assert (alloc < desired);
181
182  /* Exponential growth. */
183  if (!alloc)
184    alloc = 4;
185  else if (alloc < 16)
186    /* Double when small.  */
187    alloc = alloc * 2;
188  else
189    /* Grow slower when large.  */
190    alloc = (alloc * 3 / 2);
191
192  /* If this is still too small, set it to the right size. */
193  if (alloc < desired)
194    alloc = desired;
195  return alloc;
196}
197
198
199/* Helper for qsort; sort descriptors by amount of memory consumed.  */
200
201static int
202cmp_statistic (const void *loc1, const void *loc2)
203{
204  const struct vec_descriptor *const l1 =
205    *(const struct vec_descriptor *const *) loc1;
206  const struct vec_descriptor *const l2 =
207    *(const struct vec_descriptor *const *) loc2;
208  long diff;
209  diff = l1->allocated - l2->allocated;
210  if (!diff)
211    diff = l1->peak - l2->peak;
212  if (!diff)
213    diff = l1->times - l2->times;
214  return diff > 0 ? 1 : diff < 0 ? -1 : 0;
215}
216
217
218/* Collect array of the descriptors from hashtable.  */
219
220static struct vec_descriptor **loc_array;
221static int
222add_statistics (void **slot, void *b)
223{
224  int *n = (int *)b;
225  loc_array[*n] = (struct vec_descriptor *) *slot;
226  (*n)++;
227  return 1;
228}
229
230/* Dump per-site memory statistics.  */
231
232void
233dump_vec_loc_statistics (void)
234{
235  int nentries = 0;
236  char s[4096];
237  size_t allocated = 0;
238  size_t times = 0;
239  int i;
240
241  if (! GATHER_STATISTICS)
242    return;
243
244  loc_array = XCNEWVEC (struct vec_descriptor *, vec_desc_hash->n_elements);
245  fprintf (stderr, "Heap vectors:\n");
246  fprintf (stderr, "\n%-48s %10s       %10s       %10s\n",
247	   "source location", "Leak", "Peak", "Times");
248  fprintf (stderr, "-------------------------------------------------------\n");
249  htab_traverse (vec_desc_hash, add_statistics, &nentries);
250  qsort (loc_array, nentries, sizeof (*loc_array), cmp_statistic);
251  for (i = 0; i < nentries; i++)
252    {
253      struct vec_descriptor *d = loc_array[i];
254      allocated += d->allocated;
255      times += d->times;
256    }
257  for (i = 0; i < nentries; i++)
258    {
259      struct vec_descriptor *d = loc_array[i];
260      const char *s1 = d->file;
261      const char *s2;
262      while ((s2 = strstr (s1, "gcc/")))
263	s1 = s2 + 4;
264      sprintf (s, "%s:%i (%s)", s1, d->line, d->function);
265      s[48] = 0;
266      fprintf (stderr, "%-48s %10li:%4.1f%% %10li      %10li:%4.1f%% \n", s,
267	       (long)d->allocated,
268	       (d->allocated) * 100.0 / allocated,
269	       (long)d->peak,
270	       (long)d->times,
271	       (d->times) * 100.0 / times);
272    }
273  fprintf (stderr, "%-48s %10ld                        %10ld\n",
274	   "Total", (long)allocated, (long)times);
275  fprintf (stderr, "\n%-48s %10s       %10s       %10s\n",
276	   "source location", "Leak", "Peak", "Times");
277  fprintf (stderr, "-------------------------------------------------------\n");
278}
279