|
0
|
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>
|
|
|
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 /* This file is compiled twice: once for the generator programs
|
|
|
22 once for the compiler. */
|
|
|
23 #ifdef GENERATOR_FILE
|
|
|
24 #include "bconfig.h"
|
|
|
25 #else
|
|
|
26 #include "config.h"
|
|
|
27 #endif
|
|
|
28
|
|
|
29 #include "system.h"
|
|
|
30 #include "ggc.h"
|
|
|
31 #include "vec.h"
|
|
|
32 #include "coretypes.h"
|
|
|
33 #include "toplev.h"
|
|
|
34 #include "hashtab.h"
|
|
|
35
|
|
|
36 struct vec_prefix
|
|
|
37 {
|
|
|
38 unsigned num;
|
|
|
39 unsigned alloc;
|
|
|
40 void *vec[1];
|
|
|
41 };
|
|
|
42
|
|
|
43
|
|
|
44 #ifdef GATHER_STATISTICS
|
|
|
45
|
|
|
46 /* Store information about each particular vector. */
|
|
|
47 struct vec_descriptor
|
|
|
48 {
|
|
|
49 const char *function;
|
|
|
50 const char *file;
|
|
|
51 int line;
|
|
|
52 size_t allocated;
|
|
|
53 size_t times;
|
|
|
54 size_t peak;
|
|
|
55 };
|
|
|
56
|
|
|
57
|
|
|
58 /* Hashtable mapping vec addresses to descriptors. */
|
|
|
59 static htab_t vec_desc_hash;
|
|
|
60
|
|
|
61 /* Hashtable helpers. */
|
|
|
62 static hashval_t
|
|
|
63 hash_descriptor (const void *p)
|
|
|
64 {
|
|
|
65 const struct vec_descriptor *const d =
|
|
|
66 (const struct vec_descriptor *) p;
|
|
|
67 return htab_hash_pointer (d->file) + d->line;
|
|
|
68 }
|
|
|
69 static int
|
|
|
70 eq_descriptor (const void *p1, const void *p2)
|
|
|
71 {
|
|
|
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;
|
|
|
75 }
|
|
|
76
|
|
|
77 /* Hashtable converting address of allocated field to loc descriptor. */
|
|
|
78 static htab_t ptr_hash;
|
|
|
79 struct ptr_hash_entry
|
|
|
80 {
|
|
|
81 void *ptr;
|
|
|
82 struct vec_descriptor *loc;
|
|
|
83 size_t allocated;
|
|
|
84 };
|
|
|
85
|
|
|
86 /* Hash table helpers functions. */
|
|
|
87 static hashval_t
|
|
|
88 hash_ptr (const void *p)
|
|
|
89 {
|
|
|
90 const struct ptr_hash_entry *const d = (const struct ptr_hash_entry *) p;
|
|
|
91
|
|
|
92 return htab_hash_pointer (d->ptr);
|
|
|
93 }
|
|
|
94
|
|
|
95 static int
|
|
|
96 eq_ptr (const void *p1, const void *p2)
|
|
|
97 {
|
|
|
98 const struct ptr_hash_entry *const p = (const struct ptr_hash_entry *) p1;
|
|
|
99
|
|
|
100 return (p->ptr == p2);
|
|
|
101 }
|
|
|
102
|
|
|
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)
|
|
|
106 {
|
|
|
107 struct vec_descriptor loc;
|
|
|
108 struct vec_descriptor **slot;
|
|
|
109
|
|
|
110 loc.file = name;
|
|
|
111 loc.line = line;
|
|
|
112 loc.function = function;
|
|
|
113 if (!vec_desc_hash)
|
|
|
114 vec_desc_hash = htab_create (10, hash_descriptor, eq_descriptor, NULL);
|
|
|
115
|
|
|
116 slot = (struct vec_descriptor **) htab_find_slot (vec_desc_hash, &loc, 1);
|
|
|
117 if (*slot)
|
|
|
118 return *slot;
|
|
|
119 *slot = XCNEW (struct vec_descriptor);
|
|
|
120 (*slot)->file = name;
|
|
|
121 (*slot)->line = line;
|
|
|
122 (*slot)->function = function;
|
|
|
123 (*slot)->allocated = 0;
|
|
|
124 (*slot)->peak = 0;
|
|
|
125 return *slot;
|
|
|
126 }
|
|
|
127
|
|
|
128 /* Account the overhead. */
|
|
|
129 static void
|
|
|
130 register_overhead (struct vec_prefix *ptr, size_t size,
|
|
|
131 const char *name, int line, const char *function)
|
|
|
132 {
|
|
|
133 struct vec_descriptor *loc = vec_descriptor (name, line, function);
|
|
|
134 struct ptr_hash_entry *p = XNEW (struct ptr_hash_entry);
|
|
|
135 PTR *slot;
|
|
|
136
|
|
|
137 p->ptr = ptr;
|
|
|
138 p->loc = loc;
|
|
|
139 p->allocated = size;
|
|
|
140 if (!ptr_hash)
|
|
|
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);
|
|
|
143 gcc_assert (!*slot);
|
|
|
144 *slot = p;
|
|
|
145
|
|
|
146 loc->allocated += size;
|
|
|
147 if (loc->peak < loc->allocated)
|
|
|
148 loc->peak += loc->allocated;
|
|
|
149 loc->times++;
|
|
|
150 }
|
|
|
151
|
|
|
152 /* Notice that the pointer has been freed. */
|
|
|
153 static void
|
|
|
154 free_overhead (struct vec_prefix *ptr)
|
|
|
155 {
|
|
|
156 PTR *slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr),
|
|
|
157 NO_INSERT);
|
|
|
158 struct ptr_hash_entry *p = (struct ptr_hash_entry *) *slot;
|
|
|
159 p->loc->allocated -= p->allocated;
|
|
|
160 htab_clear_slot (ptr_hash, slot);
|
|
|
161 free (p);
|
|
|
162 }
|
|
|
163
|
|
|
164 void
|
|
|
165 vec_heap_free (void *ptr)
|
|
|
166 {
|
|
|
167 free_overhead ((struct vec_prefix *)ptr);
|
|
|
168 free (ptr);
|
|
|
169 }
|
|
|
170 #endif
|
|
|
171
|
|
|
172 /* Calculate the new ALLOC value, making sure that RESERVE slots are
|
|
|
173 free. If EXACT grow exactly, otherwise grow exponentially. */
|
|
|
174
|
|
|
175 static inline unsigned
|
|
|
176 calculate_allocation (const struct vec_prefix *pfx, int reserve, bool exact)
|
|
|
177 {
|
|
|
178 unsigned alloc = 0;
|
|
|
179 unsigned num = 0;
|
|
|
180
|
|
|
181 gcc_assert (reserve >= 0);
|
|
|
182
|
|
|
183 if (pfx)
|
|
|
184 {
|
|
|
185 alloc = pfx->alloc;
|
|
|
186 num = pfx->num;
|
|
|
187 }
|
|
|
188 else if (!reserve)
|
|
|
189 /* If there's no prefix, and we've not requested anything, then we
|
|
|
190 will create a NULL vector. */
|
|
|
191 return 0;
|
|
|
192
|
|
|
193 /* We must have run out of room. */
|
|
|
194 gcc_assert (alloc - num < (unsigned) reserve);
|
|
|
195
|
|
|
196 if (exact)
|
|
|
197 /* Exact size. */
|
|
|
198 alloc = num + reserve;
|
|
|
199 else
|
|
|
200 {
|
|
|
201 /* Exponential growth. */
|
|
|
202 if (!alloc)
|
|
|
203 alloc = 4;
|
|
|
204 else if (alloc < 16)
|
|
|
205 /* Double when small. */
|
|
|
206 alloc = alloc * 2;
|
|
|
207 else
|
|
|
208 /* Grow slower when large. */
|
|
|
209 alloc = (alloc * 3 / 2);
|
|
|
210
|
|
|
211 /* If this is still too small, set it to the right size. */
|
|
|
212 if (alloc < num + reserve)
|
|
|
213 alloc = num + reserve;
|
|
|
214 }
|
|
|
215 return alloc;
|
|
|
216 }
|
|
|
217
|
|
|
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
|
|
|
222 sized elements. */
|
|
|
223
|
|
|
224 static void *
|
|
|
225 vec_gc_o_reserve_1 (void *vec, int reserve, size_t vec_offset, size_t elt_size,
|
|
|
226 bool exact MEM_STAT_DECL)
|
|
|
227 {
|
|
|
228 struct vec_prefix *pfx = (struct vec_prefix *) vec;
|
|
|
229 unsigned alloc = alloc = calculate_allocation (pfx, reserve, exact);
|
|
|
230
|
|
|
231 if (!alloc)
|
|
|
232 {
|
|
|
233 if (pfx)
|
|
|
234 ggc_free (pfx);
|
|
|
235 return NULL;
|
|
|
236 }
|
|
|
237
|
|
|
238 vec = ggc_realloc_stat (vec, vec_offset + alloc * elt_size PASS_MEM_STAT);
|
|
|
239 ((struct vec_prefix *)vec)->alloc = alloc;
|
|
|
240 if (!pfx)
|
|
|
241 ((struct vec_prefix *)vec)->num = 0;
|
|
|
242
|
|
|
243 return vec;
|
|
|
244 }
|
|
|
245
|
|
|
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. */
|
|
|
250
|
|
|
251 void *
|
|
|
252 vec_gc_p_reserve (void *vec, int reserve MEM_STAT_DECL)
|
|
|
253 {
|
|
|
254 return vec_gc_o_reserve_1 (vec, reserve,
|
|
|
255 offsetof (struct vec_prefix, vec),
|
|
|
256 sizeof (void *), false
|
|
|
257 PASS_MEM_STAT);
|
|
|
258 }
|
|
|
259
|
|
|
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
|
|
|
263 created. */
|
|
|
264
|
|
|
265 void *
|
|
|
266 vec_gc_p_reserve_exact (void *vec, int reserve MEM_STAT_DECL)
|
|
|
267 {
|
|
|
268 return vec_gc_o_reserve_1 (vec, reserve,
|
|
|
269 offsetof (struct vec_prefix, vec),
|
|
|
270 sizeof (void *), true
|
|
|
271 PASS_MEM_STAT);
|
|
|
272 }
|
|
|
273
|
|
|
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
|
|
|
276 sized elements. */
|
|
|
277
|
|
|
278 void *
|
|
|
279 vec_gc_o_reserve (void *vec, int reserve, size_t vec_offset, size_t elt_size
|
|
|
280 MEM_STAT_DECL)
|
|
|
281 {
|
|
|
282 return vec_gc_o_reserve_1 (vec, reserve, vec_offset, elt_size, false
|
|
|
283 PASS_MEM_STAT);
|
|
|
284 }
|
|
|
285
|
|
|
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. */
|
|
|
289
|
|
|
290 void *
|
|
|
291 vec_gc_o_reserve_exact (void *vec, int reserve, size_t vec_offset,
|
|
|
292 size_t elt_size MEM_STAT_DECL)
|
|
|
293 {
|
|
|
294 return vec_gc_o_reserve_1 (vec, reserve, vec_offset, elt_size, true
|
|
|
295 PASS_MEM_STAT);
|
|
|
296 }
|
|
|
297
|
|
|
298 /* As for vec_gc_o_reserve_1, but for heap allocated vectors. */
|
|
|
299
|
|
|
300 static void *
|
|
|
301 vec_heap_o_reserve_1 (void *vec, int reserve, size_t vec_offset,
|
|
|
302 size_t elt_size, bool exact MEM_STAT_DECL)
|
|
|
303 {
|
|
|
304 struct vec_prefix *pfx = (struct vec_prefix *) vec;
|
|
|
305 unsigned alloc = calculate_allocation (pfx, reserve, exact);
|
|
|
306
|
|
|
307 if (!alloc)
|
|
|
308 {
|
|
|
309 if (pfx)
|
|
|
310 vec_heap_free (pfx);
|
|
|
311 return NULL;
|
|
|
312 }
|
|
|
313
|
|
|
314 #ifdef GATHER_STATISTICS
|
|
|
315 if (vec)
|
|
|
316 free_overhead (pfx);
|
|
|
317 #endif
|
|
|
318
|
|
|
319 vec = xrealloc (vec, vec_offset + alloc * elt_size);
|
|
|
320 ((struct vec_prefix *)vec)->alloc = alloc;
|
|
|
321 if (!pfx)
|
|
|
322 ((struct vec_prefix *)vec)->num = 0;
|
|
|
323 #ifdef GATHER_STATISTICS
|
|
|
324 if (vec)
|
|
|
325 register_overhead ((struct vec_prefix *)vec,
|
|
|
326 vec_offset + alloc * elt_size PASS_MEM_STAT);
|
|
|
327 #endif
|
|
|
328
|
|
|
329 return vec;
|
|
|
330 }
|
|
|
331
|
|
|
332 /* As for vec_gc_p_reserve, but for heap allocated vectors. */
|
|
|
333
|
|
|
334 void *
|
|
|
335 vec_heap_p_reserve (void *vec, int reserve MEM_STAT_DECL)
|
|
|
336 {
|
|
|
337 return vec_heap_o_reserve_1 (vec, reserve,
|
|
|
338 offsetof (struct vec_prefix, vec),
|
|
|
339 sizeof (void *), false
|
|
|
340 PASS_MEM_STAT);
|
|
|
341 }
|
|
|
342
|
|
|
343 /* As for vec_gc_p_reserve_exact, but for heap allocated vectors. */
|
|
|
344
|
|
|
345 void *
|
|
|
346 vec_heap_p_reserve_exact (void *vec, int reserve MEM_STAT_DECL)
|
|
|
347 {
|
|
|
348 return vec_heap_o_reserve_1 (vec, reserve,
|
|
|
349 offsetof (struct vec_prefix, vec),
|
|
|
350 sizeof (void *), true
|
|
|
351 PASS_MEM_STAT);
|
|
|
352 }
|
|
|
353
|
|
|
354 /* As for vec_gc_o_reserve, but for heap allocated vectors. */
|
|
|
355
|
|
|
356 void *
|
|
|
357 vec_heap_o_reserve (void *vec, int reserve, size_t vec_offset, size_t elt_size
|
|
|
358 MEM_STAT_DECL)
|
|
|
359 {
|
|
|
360 return vec_heap_o_reserve_1 (vec, reserve, vec_offset, elt_size, false
|
|
|
361 PASS_MEM_STAT);
|
|
|
362 }
|
|
|
363
|
|
|
364 /* As for vec_gc_o_reserve_exact, but for heap allocated vectors. */
|
|
|
365
|
|
|
366 void *
|
|
|
367 vec_heap_o_reserve_exact (void *vec, int reserve, size_t vec_offset,
|
|
|
368 size_t elt_size MEM_STAT_DECL)
|
|
|
369 {
|
|
|
370 return vec_heap_o_reserve_1 (vec, reserve, vec_offset, elt_size, true
|
|
|
371 PASS_MEM_STAT);
|
|
|
372 }
|
|
|
373
|
|
|
374 #if ENABLE_CHECKING
|
|
|
375 /* Issue a vector domain error, and then fall over. */
|
|
|
376
|
|
|
377 void
|
|
|
378 vec_assert_fail (const char *op, const char *struct_name,
|
|
|
379 const char *file, unsigned int line, const char *function)
|
|
|
380 {
|
|
|
381 internal_error ("vector %s %s domain error, in %s at %s:%u",
|
|
|
382 struct_name, op, function, trim_filename (file), line);
|
|
|
383 }
|
|
|
384 #endif
|
|
|
385
|
|
|
386 #ifdef GATHER_STATISTICS
|
|
|
387 /* Helper for qsort; sort descriptors by amount of memory consumed. */
|
|
|
388 static int
|
|
|
389 cmp_statistic (const void *loc1, const void *loc2)
|
|
|
390 {
|
|
|
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;
|
|
|
395 long diff;
|
|
|
396 diff = l1->allocated - l2->allocated;
|
|
|
397 if (!diff)
|
|
|
398 diff = l1->peak - l2->peak;
|
|
|
399 if (!diff)
|
|
|
400 diff = l1->times - l2->times;
|
|
|
401 return diff > 0 ? 1 : diff < 0 ? -1 : 0;
|
|
|
402 }
|
|
|
403 /* Collect array of the descriptors from hashtable. */
|
|
|
404 static struct vec_descriptor **loc_array;
|
|
|
405 static int
|
|
|
406 add_statistics (void **slot, void *b)
|
|
|
407 {
|
|
|
408 int *n = (int *)b;
|
|
|
409 loc_array[*n] = (struct vec_descriptor *) *slot;
|
|
|
410 (*n)++;
|
|
|
411 return 1;
|
|
|
412 }
|
|
|
413
|
|
|
414 /* Dump per-site memory statistics. */
|
|
|
415 #endif
|
|
|
416 void
|
|
|
417 dump_vec_loc_statistics (void)
|
|
|
418 {
|
|
|
419 #ifdef GATHER_STATISTICS
|
|
|
420 int nentries = 0;
|
|
|
421 char s[4096];
|
|
|
422 size_t allocated = 0;
|
|
|
423 size_t times = 0;
|
|
|
424 int i;
|
|
|
425
|
|
|
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++)
|
|
|
434 {
|
|
|
435 struct vec_descriptor *d = loc_array[i];
|
|
|
436 allocated += d->allocated;
|
|
|
437 times += d->times;
|
|
|
438 }
|
|
|
439 for (i = 0; i < nentries; i++)
|
|
|
440 {
|
|
|
441 struct vec_descriptor *d = loc_array[i];
|
|
|
442 const char *s1 = d->file;
|
|
|
443 const char *s2;
|
|
|
444 while ((s2 = strstr (s1, "gcc/")))
|
|
|
445 s1 = s2 + 4;
|
|
|
446 sprintf (s, "%s:%i (%s)", s1, d->line, d->function);
|
|
|
447 s[48] = 0;
|
|
|
448 fprintf (stderr, "%-48s %10li:%4.1f%% %10li %10li:%4.1f%% \n", s,
|
|
|
449 (long)d->allocated,
|
|
|
450 (d->allocated) * 100.0 / allocated,
|
|
|
451 (long)d->peak,
|
|
|
452 (long)d->times,
|
|
|
453 (d->times) * 100.0 / times);
|
|
|
454 }
|
|
|
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");
|
|
|
460 #endif
|
|
|
461 }
|
