1 /* Vector API for GNU compiler.
2 Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
3 Contributed by Nathan Sidwell <nathan@codesourcery.com>
5 This file is part of GCC.
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
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
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/>. */
21 /* This file is compiled twice: once for the generator programs
22 once for the compiler. */
32 #include "coretypes.h"
44 #ifdef GATHER_STATISTICS
46 /* Store information about each particular vector. */
58 /* Hashtable mapping vec addresses to descriptors. */
59 static htab_t vec_desc_hash;
61 /* Hashtable helpers. */
63 hash_descriptor (const void *p)
65 const struct vec_descriptor *const d =
66 (const struct vec_descriptor *) p;
67 return htab_hash_pointer (d->file) + d->line;
70 eq_descriptor (const void *p1, const void *p2)
72 const struct vec_descriptor *const d = (const struct vec_descriptor *) p1;
73 const struct vec_descriptor *const l = (const struct vec_descriptor *) p2;
74 return d->file == l->file && d->function == l->function && d->line == l->line;
77 /* Hashtable converting address of allocated field to loc descriptor. */
78 static htab_t ptr_hash;
82 struct vec_descriptor *loc;
86 /* Hash table helpers functions. */
88 hash_ptr (const void *p)
90 const struct ptr_hash_entry *const d = (const struct ptr_hash_entry *) p;
92 return htab_hash_pointer (d->ptr);
96 eq_ptr (const void *p1, const void *p2)
98 const struct ptr_hash_entry *const p = (const struct ptr_hash_entry *) p1;
100 return (p->ptr == p2);
103 /* Return descriptor for given call site, create new one if needed. */
104 static struct vec_descriptor *
105 vec_descriptor (const char *name, int line, const char *function)
107 struct vec_descriptor loc;
108 struct vec_descriptor **slot;
112 loc.function = function;
114 vec_desc_hash = htab_create (10, hash_descriptor, eq_descriptor, NULL);
116 slot = (struct vec_descriptor **) htab_find_slot (vec_desc_hash, &loc, 1);
119 *slot = XCNEW (struct vec_descriptor);
120 (*slot)->file = name;
121 (*slot)->line = line;
122 (*slot)->function = function;
123 (*slot)->allocated = 0;
128 /* Account the overhead. */
130 register_overhead (struct vec_prefix *ptr, size_t size,
131 const char *name, int line, const char *function)
133 struct vec_descriptor *loc = vec_descriptor (name, line, function);
134 struct ptr_hash_entry *p = XNEW (struct ptr_hash_entry);
141 ptr_hash = htab_create (10, hash_ptr, eq_ptr, NULL);
142 slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr), INSERT);
146 loc->allocated += size;
147 if (loc->peak < loc->allocated)
148 loc->peak += loc->allocated;
152 /* Notice that the pointer has been freed. */
154 free_overhead (struct vec_prefix *ptr)
156 PTR *slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr),
158 struct ptr_hash_entry *p = (struct ptr_hash_entry *) *slot;
159 p->loc->allocated -= p->allocated;
160 htab_clear_slot (ptr_hash, slot);
165 vec_heap_free (void *ptr)
167 free_overhead ((struct vec_prefix *)ptr);
172 /* Calculate the new ALLOC value, making sure that RESERVE slots are
173 free. If EXACT grow exactly, otherwise grow exponentially. */
175 static inline unsigned
176 calculate_allocation (const struct vec_prefix *pfx, int reserve, bool exact)
181 gcc_assert (reserve >= 0);
189 /* If there's no prefix, and we've not requested anything, then we
190 will create a NULL vector. */
193 /* We must have run out of room. */
194 gcc_assert (alloc - num < (unsigned) reserve);
198 alloc = num + reserve;
201 /* Exponential growth. */
205 /* Double when small. */
208 /* Grow slower when large. */
209 alloc = (alloc * 3 / 2);
211 /* If this is still too small, set it to the right size. */
212 if (alloc < num + reserve)
213 alloc = num + reserve;
218 /* Ensure there are at least RESERVE free slots in VEC. If EXACT grow
219 exactly, else grow exponentially. As a special case, if VEC is
220 NULL and RESERVE is 0, no vector will be created. The vector's
221 trailing array is at VEC_OFFSET offset and consists of ELT_SIZE
225 vec_gc_o_reserve_1 (void *vec, int reserve, size_t vec_offset, size_t elt_size,
226 bool exact MEM_STAT_DECL)
228 struct vec_prefix *pfx = (struct vec_prefix *) vec;
229 unsigned alloc = alloc = calculate_allocation (pfx, reserve, exact);
238 vec = ggc_realloc_stat (vec, vec_offset + alloc * elt_size PASS_MEM_STAT);
239 ((struct vec_prefix *)vec)->alloc = alloc;
241 ((struct vec_prefix *)vec)->num = 0;
246 /* Ensure there are at least RESERVE free slots in VEC, growing
247 exponentially. If RESERVE < 0 grow exactly, else grow
248 exponentially. As a special case, if VEC is NULL, and RESERVE is
249 0, no vector will be created. */
252 vec_gc_p_reserve (void *vec, int reserve MEM_STAT_DECL)
254 return vec_gc_o_reserve_1 (vec, reserve,
255 offsetof (struct vec_prefix, vec),
256 sizeof (void *), false
260 /* Ensure there are at least RESERVE free slots in VEC, growing
261 exactly. If RESERVE < 0 grow exactly, else grow exponentially. As
262 a special case, if VEC is NULL, and RESERVE is 0, no vector will be
266 vec_gc_p_reserve_exact (void *vec, int reserve MEM_STAT_DECL)
268 return vec_gc_o_reserve_1 (vec, reserve,
269 offsetof (struct vec_prefix, vec),
270 sizeof (void *), true
274 /* As for vec_gc_p_reserve, but for object vectors. The vector's
275 trailing array is at VEC_OFFSET offset and consists of ELT_SIZE
279 vec_gc_o_reserve (void *vec, int reserve, size_t vec_offset, size_t elt_size
282 return vec_gc_o_reserve_1 (vec, reserve, vec_offset, elt_size, false
286 /* As for vec_gc_p_reserve_exact, but for object vectors. The
287 vector's trailing array is at VEC_OFFSET offset and consists of
288 ELT_SIZE sized elements. */
291 vec_gc_o_reserve_exact (void *vec, int reserve, size_t vec_offset,
292 size_t elt_size MEM_STAT_DECL)
294 return vec_gc_o_reserve_1 (vec, reserve, vec_offset, elt_size, true
298 /* As for vec_gc_o_reserve_1, but for heap allocated vectors. */
301 vec_heap_o_reserve_1 (void *vec, int reserve, size_t vec_offset,
302 size_t elt_size, bool exact MEM_STAT_DECL)
304 struct vec_prefix *pfx = (struct vec_prefix *) vec;
305 unsigned alloc = calculate_allocation (pfx, reserve, exact);
314 #ifdef GATHER_STATISTICS
319 vec = xrealloc (vec, vec_offset + alloc * elt_size);
320 ((struct vec_prefix *)vec)->alloc = alloc;
322 ((struct vec_prefix *)vec)->num = 0;
323 #ifdef GATHER_STATISTICS
325 register_overhead ((struct vec_prefix *)vec,
326 vec_offset + alloc * elt_size PASS_MEM_STAT);
332 /* As for vec_gc_p_reserve, but for heap allocated vectors. */
335 vec_heap_p_reserve (void *vec, int reserve MEM_STAT_DECL)
337 return vec_heap_o_reserve_1 (vec, reserve,
338 offsetof (struct vec_prefix, vec),
339 sizeof (void *), false
343 /* As for vec_gc_p_reserve_exact, but for heap allocated vectors. */
346 vec_heap_p_reserve_exact (void *vec, int reserve MEM_STAT_DECL)
348 return vec_heap_o_reserve_1 (vec, reserve,
349 offsetof (struct vec_prefix, vec),
350 sizeof (void *), true
354 /* As for vec_gc_o_reserve, but for heap allocated vectors. */
357 vec_heap_o_reserve (void *vec, int reserve, size_t vec_offset, size_t elt_size
360 return vec_heap_o_reserve_1 (vec, reserve, vec_offset, elt_size, false
364 /* As for vec_gc_o_reserve_exact, but for heap allocated vectors. */
367 vec_heap_o_reserve_exact (void *vec, int reserve, size_t vec_offset,
368 size_t elt_size MEM_STAT_DECL)
370 return vec_heap_o_reserve_1 (vec, reserve, vec_offset, elt_size, true
375 /* Issue a vector domain error, and then fall over. */
378 vec_assert_fail (const char *op, const char *struct_name,
379 const char *file, unsigned int line, const char *function)
381 internal_error ("vector %s %s domain error, in %s at %s:%u",
382 struct_name, op, function, trim_filename (file), line);
386 #ifdef GATHER_STATISTICS
387 /* Helper for qsort; sort descriptors by amount of memory consumed. */
389 cmp_statistic (const void *loc1, const void *loc2)
391 const struct vec_descriptor *const l1 =
392 *(const struct vec_descriptor *const *) loc1;
393 const struct vec_descriptor *const l2 =
394 *(const struct vec_descriptor *const *) loc2;
396 diff = l1->allocated - l2->allocated;
398 diff = l1->peak - l2->peak;
400 diff = l1->times - l2->times;
401 return diff > 0 ? 1 : diff < 0 ? -1 : 0;
403 /* Collect array of the descriptors from hashtable. */
404 static struct vec_descriptor **loc_array;
406 add_statistics (void **slot, void *b)
409 loc_array[*n] = (struct vec_descriptor *) *slot;
414 /* Dump per-site memory statistics. */
417 dump_vec_loc_statistics (void)
419 #ifdef GATHER_STATISTICS
422 size_t allocated = 0;
426 loc_array = XCNEWVEC (struct vec_descriptor *, vec_desc_hash->n_elements);
427 fprintf (stderr, "Heap vectors:\n");
428 fprintf (stderr, "\n%-48s %10s %10s %10s\n",
429 "source location", "Leak", "Peak", "Times");
430 fprintf (stderr, "-------------------------------------------------------\n");
431 htab_traverse (vec_desc_hash, add_statistics, &nentries);
432 qsort (loc_array, nentries, sizeof (*loc_array), cmp_statistic);
433 for (i = 0; i < nentries; i++)
435 struct vec_descriptor *d = loc_array[i];
436 allocated += d->allocated;
439 for (i = 0; i < nentries; i++)
441 struct vec_descriptor *d = loc_array[i];
442 const char *s1 = d->file;
444 while ((s2 = strstr (s1, "gcc/")))
446 sprintf (s, "%s:%i (%s)", s1, d->line, d->function);
448 fprintf (stderr, "%-48s %10li:%4.1f%% %10li %10li:%4.1f%% \n", s,
450 (d->allocated) * 100.0 / allocated,
453 (d->times) * 100.0 / times);
455 fprintf (stderr, "%-48s %10ld %10ld\n",
456 "Total", (long)allocated, (long)times);
457 fprintf (stderr, "\n%-48s %10s %10s %10s\n",
458 "source location", "Leak", "Peak", "Times");
459 fprintf (stderr, "-------------------------------------------------------\n");