X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fggc-common.c;h=4939cb6988886ed9ef870ada95a1305caad68e07;hb=4aaa352fdbf8d0672c30ddf3e6ea61a84f1ae95f;hp=b1c3c61bb2cc1f687570c92c618094638ba14522;hpb=6d05ae3500d879cf95a2de67483a1370f6f0789f;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/ggc-common.c b/gcc/ggc-common.c index b1c3c61bb2c..4939cb69888 100644 --- a/gcc/ggc-common.c +++ b/gcc/ggc-common.c @@ -1,5 +1,5 @@ /* Simple garbage collection for the GNU compiler. - Copyright (C) 1999, 2000, 2001, 2002, 2003 + Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. This file is part of GCC. @@ -29,6 +29,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "ggc.h" #include "toplev.h" #include "params.h" +#include "hosthooks.h" +#include "hosthooks-def.h" #ifdef HAVE_SYS_RESOURCE_H # include @@ -36,13 +38,23 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #ifdef HAVE_MMAP_FILE # include +# ifdef HAVE_MINCORE +/* This is on Solaris. */ +# include +# endif +#endif + +#ifndef MAP_FAILED +# define MAP_FAILED ((void *)-1) #endif #ifdef ENABLE_VALGRIND_CHECKING -# ifdef HAVE_MEMCHECK_H -# include +# ifdef HAVE_VALGRIND_MEMCHECK_H +# include +# elif defined HAVE_MEMCHECK_H +# include # else -# include +# include # endif #else /* Avoid #ifdef:s when we can help it. */ @@ -54,25 +66,23 @@ static ggc_statistics *ggc_stats; struct traversal_state; -static int ggc_htab_delete PARAMS ((void **, void *)); -static hashval_t saving_htab_hash PARAMS ((const PTR)); -static int saving_htab_eq PARAMS ((const PTR, const PTR)); -static int call_count PARAMS ((void **, void *)); -static int call_alloc PARAMS ((void **, void *)); -static int compare_ptr_data PARAMS ((const void *, const void *)); -static void relocate_ptrs PARAMS ((void *, void *)); -static void write_pch_globals PARAMS ((const struct ggc_root_tab * const *tab, - struct traversal_state *state)); -static double ggc_rlimit_bound PARAMS ((double)); +static int ggc_htab_delete (void **, void *); +static hashval_t saving_htab_hash (const void *); +static int saving_htab_eq (const void *, const void *); +static int call_count (void **, void *); +static int call_alloc (void **, void *); +static int compare_ptr_data (const void *, const void *); +static void relocate_ptrs (void *, void *); +static void write_pch_globals (const struct ggc_root_tab * const *tab, + struct traversal_state *state); +static double ggc_rlimit_bound (double); /* Maintain global roots that are preserved during GC. */ /* Process a slot of an htab by deleting it if it has not been marked. */ static int -ggc_htab_delete (slot, info) - void **slot; - void *info; +ggc_htab_delete (void **slot, void *info) { const struct ggc_cache_tab *r = (const struct ggc_cache_tab *) info; @@ -87,7 +97,7 @@ ggc_htab_delete (slot, info) /* Iterate through all registered roots and mark each element. */ void -ggc_mark_roots () +ggc_mark_roots (void) { const struct ggc_root_tab *const *rt; const struct ggc_root_tab *rti; @@ -113,34 +123,32 @@ ggc_mark_roots () if (*cti->base) { ggc_set_mark (*cti->base); - htab_traverse_noresize (*cti->base, ggc_htab_delete, (PTR) cti); + htab_traverse_noresize (*cti->base, ggc_htab_delete, (void *) cti); ggc_set_mark ((*cti->base)->entries); } } /* Allocate a block of memory, then clear it. */ void * -ggc_alloc_cleared (size) - size_t size; +ggc_alloc_cleared_stat (size_t size MEM_STAT_DECL) { - void *buf = ggc_alloc (size); + void *buf = ggc_alloc_stat (size PASS_MEM_STAT); memset (buf, 0, size); return buf; } /* Resize a block of memory, possibly re-allocating it. */ void * -ggc_realloc (x, size) - void *x; - size_t size; +ggc_realloc_stat (void *x, size_t size MEM_STAT_DECL) { void *r; size_t old_size; if (x == NULL) - return ggc_alloc (size); + return ggc_alloc_stat (size PASS_MEM_STAT); old_size = ggc_get_size (x); + if (size <= old_size) { /* Mark the unwanted memory as unaccessible. We also need to make @@ -150,7 +158,7 @@ ggc_realloc (x, size) don't know that previously allocated size. Without that knowledge we have to lose some initialization-tracking for the old parts of the object. An alternative is to mark the whole - old_size as reachable, but that would lose tracking of writes + old_size as reachable, but that would lose tracking of writes after the end of the object (by small offsets). Discard the handle to avoid handle leak. */ VALGRIND_DISCARD (VALGRIND_MAKE_NOACCESS ((char *) x + size, @@ -159,7 +167,7 @@ ggc_realloc (x, size) return x; } - r = ggc_alloc (size); + r = ggc_alloc_stat (size PASS_MEM_STAT); /* Since ggc_get_size returns the size of the pool, not the size of the individually allocated object, we'd access parts of the old object @@ -170,24 +178,21 @@ ggc_realloc (x, size) memcpy (r, x, old_size); /* The old object is not supposed to be used anymore. */ - VALGRIND_DISCARD (VALGRIND_MAKE_NOACCESS (x, old_size)); + ggc_free (x); return r; } /* Like ggc_alloc_cleared, but performs a multiplication. */ void * -ggc_calloc (s1, s2) - size_t s1, s2; +ggc_calloc (size_t s1, size_t s2) { return ggc_alloc_cleared (s1 * s2); } /* These are for splay_tree_new_ggc. */ -PTR -ggc_splay_alloc (sz, nl) - int sz; - PTR nl; +void * +ggc_splay_alloc (int sz, void *nl) { if (nl != NULL) abort (); @@ -195,9 +200,7 @@ ggc_splay_alloc (sz, nl) } void -ggc_splay_dont_free (x, nl) - PTR x ATTRIBUTE_UNUSED; - PTR nl; +ggc_splay_dont_free (void * x ATTRIBUTE_UNUSED, void *nl) { if (nl != NULL) abort (); @@ -212,9 +215,8 @@ ggc_splay_dont_free (x, nl) #define LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M')) void -ggc_print_common_statistics (stream, stats) - FILE *stream ATTRIBUTE_UNUSED; - ggc_statistics *stats; +ggc_print_common_statistics (FILE *stream ATTRIBUTE_UNUSED, + ggc_statistics *stats) { /* Set the pointer so that during collection we will actually gather the statistics. */ @@ -233,7 +235,7 @@ ggc_print_common_statistics (stream, stats) static htab_t saving_htab; -struct ptr_data +struct ptr_data { void *obj; void *note_ptr_cookie; @@ -248,13 +250,11 @@ struct ptr_data /* Register an object in the hash table. */ int -gt_pch_note_object (obj, note_ptr_cookie, note_ptr_fn) - void *obj; - void *note_ptr_cookie; - gt_note_pointers note_ptr_fn; +gt_pch_note_object (void *obj, void *note_ptr_cookie, + gt_note_pointers note_ptr_fn) { struct ptr_data **slot; - + if (obj == NULL || obj == (void *) 1) return 0; @@ -268,7 +268,7 @@ gt_pch_note_object (obj, note_ptr_cookie, note_ptr_fn) abort (); return 0; } - + *slot = xcalloc (sizeof (struct ptr_data), 1); (*slot)->obj = obj; (*slot)->note_ptr_fn = note_ptr_fn; @@ -283,13 +283,11 @@ gt_pch_note_object (obj, note_ptr_cookie, note_ptr_fn) /* Register an object in the hash table. */ void -gt_pch_note_reorder (obj, note_ptr_cookie, reorder_fn) - void *obj; - void *note_ptr_cookie; - gt_handle_reorder reorder_fn; +gt_pch_note_reorder (void *obj, void *note_ptr_cookie, + gt_handle_reorder reorder_fn) { struct ptr_data *data; - + if (obj == NULL || obj == (void *) 1) return; @@ -297,30 +295,27 @@ gt_pch_note_reorder (obj, note_ptr_cookie, reorder_fn) if (data == NULL || data->note_ptr_cookie != note_ptr_cookie) abort (); - + data->reorder_fn = reorder_fn; } /* Hash and equality functions for saving_htab, callbacks for htab_create. */ static hashval_t -saving_htab_hash (p) - const PTR p; +saving_htab_hash (const void *p) { return POINTER_HASH (((struct ptr_data *)p)->obj); } static int -saving_htab_eq (p1, p2) - const PTR p1; - const PTR p2; +saving_htab_eq (const void *p1, const void *p2) { return ((struct ptr_data *)p1)->obj == p2; } /* Handy state for the traversal functions. */ -struct traversal_state +struct traversal_state { FILE *f; struct ggc_pch_data *d; @@ -332,27 +327,23 @@ struct traversal_state /* Callbacks for htab_traverse. */ static int -call_count (slot, state_p) - void **slot; - void *state_p; +call_count (void **slot, void *state_p) { struct ptr_data *d = (struct ptr_data *)*slot; struct traversal_state *state = (struct traversal_state *)state_p; - - ggc_pch_count_object (state->d, d->obj, d->size); + + ggc_pch_count_object (state->d, d->obj, d->size, d->note_ptr_fn == gt_pch_p_S); state->count++; return 1; } static int -call_alloc (slot, state_p) - void **slot; - void *state_p; +call_alloc (void **slot, void *state_p) { struct ptr_data *d = (struct ptr_data *)*slot; struct traversal_state *state = (struct traversal_state *)state_p; - - d->new_addr = ggc_pch_alloc_object (state->d, d->obj, d->size); + + d->new_addr = ggc_pch_alloc_object (state->d, d->obj, d->size, d->note_ptr_fn == gt_pch_p_S); state->ptrs[state->ptrs_i++] = d; return 1; } @@ -360,9 +351,7 @@ call_alloc (slot, state_p) /* Callback for qsort. */ static int -compare_ptr_data (p1_p, p2_p) - const void *p1_p; - const void *p2_p; +compare_ptr_data (const void *p1_p, const void *p2_p) { struct ptr_data *p1 = *(struct ptr_data *const *)p1_p; struct ptr_data *p2 = *(struct ptr_data *const *)p2_p; @@ -373,18 +362,16 @@ compare_ptr_data (p1_p, p2_p) /* Callbacks for note_ptr_fn. */ static void -relocate_ptrs (ptr_p, state_p) - void *ptr_p; - void *state_p; +relocate_ptrs (void *ptr_p, void *state_p) { void **ptr = (void **)ptr_p; - struct traversal_state *state ATTRIBUTE_UNUSED + struct traversal_state *state ATTRIBUTE_UNUSED = (struct traversal_state *)state_p; struct ptr_data *result; if (*ptr == NULL || *ptr == (void *)1) return; - + result = htab_find_with_hash (saving_htab, *ptr, POINTER_HASH (*ptr)); if (result == NULL) abort (); @@ -393,9 +380,8 @@ relocate_ptrs (ptr_p, state_p) /* Write out, after relocation, the pointers in TAB. */ static void -write_pch_globals (tab, state) - const struct ggc_root_tab * const *tab; - struct traversal_state *state; +write_pch_globals (const struct ggc_root_tab * const *tab, + struct traversal_state *state) { const struct ggc_root_tab *const *rt; const struct ggc_root_tab *rti; @@ -409,24 +395,24 @@ write_pch_globals (tab, state) struct ptr_data *new_ptr; if (ptr == NULL || ptr == (void *)1) { - if (fwrite (&ptr, sizeof (void *), 1, state->f) + if (fwrite (&ptr, sizeof (void *), 1, state->f) != 1) - fatal_io_error ("can't write PCH file"); + fatal_error ("can't write PCH file: %m"); } else { - new_ptr = htab_find_with_hash (saving_htab, ptr, + new_ptr = htab_find_with_hash (saving_htab, ptr, POINTER_HASH (ptr)); - if (fwrite (&new_ptr->new_addr, sizeof (void *), 1, state->f) + if (fwrite (&new_ptr->new_addr, sizeof (void *), 1, state->f) != 1) - fatal_io_error ("can't write PCH file"); + fatal_error ("can't write PCH file: %m"); } } } /* Hold the information we need to mmap the file back in. */ -struct mmap_info +struct mmap_info { size_t offset; size_t size; @@ -436,8 +422,7 @@ struct mmap_info /* Write out the state of the compiler to F. */ void -gt_pch_save (f) - FILE *f; +gt_pch_save (FILE *f) { const struct ggc_root_tab *const *rt; const struct ggc_root_tab *rti; @@ -470,21 +455,13 @@ gt_pch_save (f) mmi.size = ggc_pch_total_size (state.d); - /* Try to arrange things so that no relocation is necessary, - but don't try very hard. On most platforms, this will always work, - and on the rest it's a lot of work to do better. */ -#if HAVE_MMAP_FILE - mmi.preferred_base = mmap (NULL, mmi.size, - PROT_READ | PROT_WRITE, MAP_PRIVATE, - fileno (state.f), 0); - if (mmi.preferred_base == (void *)-1) - mmi.preferred_base = NULL; - else - munmap (mmi.preferred_base, mmi.size); -#else /* HAVE_MMAP_FILE */ - mmi.preferred_base = NULL; -#endif /* HAVE_MMAP_FILE */ - + /* Try to arrange things so that no relocation is necessary, but + don't try very hard. On most platforms, this will always work, + and on the rest it's a lot of work to do better. + (The extra work goes in HOST_HOOKS_GT_PCH_GET_ADDRESS and + HOST_HOOKS_GT_PCH_USE_ADDRESS.) */ + mmi.preferred_base = host_hooks.gt_pch_get_address (mmi.size, fileno (f)); + ggc_pch_this_base (state.d, mmi.preferred_base); state.ptrs = xmalloc (state.count * sizeof (*state.ptrs)); @@ -496,30 +473,30 @@ gt_pch_save (f) for (rt = gt_pch_scalar_rtab; *rt; rt++) for (rti = *rt; rti->base != NULL; rti++) if (fwrite (rti->base, rti->stride, 1, f) != 1) - fatal_io_error ("can't write PCH file"); + fatal_error ("can't write PCH file: %m"); /* Write out all the global pointers, after translation. */ write_pch_globals (gt_ggc_rtab, &state); write_pch_globals (gt_pch_cache_rtab, &state); ggc_pch_prepare_write (state.d, state.f); - - /* Pad the PCH file so that the mmaped area starts on a page boundary. */ + + /* Pad the PCH file so that the mmapped area starts on a page boundary. */ { long o; o = ftell (state.f) + sizeof (mmi); if (o == -1) - fatal_io_error ("can't get position in PCH file"); + fatal_error ("can't get position in PCH file: %m"); mmi.offset = page_size - o % page_size; if (mmi.offset == page_size) mmi.offset = 0; mmi.offset += o; } if (fwrite (&mmi, sizeof (mmi), 1, state.f) != 1) - fatal_io_error ("can't write PCH file"); + fatal_error ("can't write PCH file: %m"); if (mmi.offset != 0 && fseek (state.f, mmi.offset, SEEK_SET) != 0) - fatal_io_error ("can't write padding to PCH file"); + fatal_error ("can't write padding to PCH file: %m"); /* Actually write out the objects. */ for (i = 0; i < state.count; i++) @@ -531,18 +508,20 @@ gt_pch_save (f) } memcpy (this_object, state.ptrs[i]->obj, state.ptrs[i]->size); if (state.ptrs[i]->reorder_fn != NULL) - state.ptrs[i]->reorder_fn (state.ptrs[i]->obj, + state.ptrs[i]->reorder_fn (state.ptrs[i]->obj, state.ptrs[i]->note_ptr_cookie, relocate_ptrs, &state); - state.ptrs[i]->note_ptr_fn (state.ptrs[i]->obj, + state.ptrs[i]->note_ptr_fn (state.ptrs[i]->obj, state.ptrs[i]->note_ptr_cookie, relocate_ptrs, &state); ggc_pch_write_object (state.d, state.f, state.ptrs[i]->obj, - state.ptrs[i]->new_addr, state.ptrs[i]->size); + state.ptrs[i]->new_addr, state.ptrs[i]->size, + state.ptrs[i]->note_ptr_fn == gt_pch_p_S); if (state.ptrs[i]->note_ptr_fn != gt_pch_p_S) memcpy (state.ptrs[i]->obj, this_object, state.ptrs[i]->size); } ggc_pch_finish (state.d, state.f); + gt_pch_fixup_stringpool (); free (state.ptrs); htab_delete (saving_htab); @@ -551,14 +530,13 @@ gt_pch_save (f) /* Read the state of the compiler back in from F. */ void -gt_pch_restore (f) - FILE *f; +gt_pch_restore (FILE *f) { const struct ggc_root_tab *const *rt; const struct ggc_root_tab *rti; size_t i; struct mmap_info mmi; - void *addr; + int result; /* Delete any deletable objects. This makes ggc_pch_read much faster, as it can be sure that no GCable objects remain other @@ -571,7 +549,7 @@ gt_pch_restore (f) for (rt = gt_pch_scalar_rtab; *rt; rt++) for (rti = *rt; rti->base != NULL; rti++) if (fread (rti->base, rti->stride, 1, f) != 1) - fatal_io_error ("can't read PCH file"); + fatal_error ("can't read PCH file: %m"); /* Read in all the global pointers, in 6 easy loops. */ for (rt = gt_ggc_rtab; *rt; rt++) @@ -579,67 +557,110 @@ gt_pch_restore (f) for (i = 0; i < rti->nelt; i++) if (fread ((char *)rti->base + rti->stride * i, sizeof (void *), 1, f) != 1) - fatal_io_error ("can't read PCH file"); + fatal_error ("can't read PCH file: %m"); for (rt = gt_pch_cache_rtab; *rt; rt++) for (rti = *rt; rti->base != NULL; rti++) for (i = 0; i < rti->nelt; i++) if (fread ((char *)rti->base + rti->stride * i, sizeof (void *), 1, f) != 1) - fatal_io_error ("can't read PCH file"); + fatal_error ("can't read PCH file: %m"); if (fread (&mmi, sizeof (mmi), 1, f) != 1) - fatal_io_error ("can't read PCH file"); - -#if HAVE_MMAP_FILE - addr = mmap (mmi.preferred_base, mmi.size, - PROT_READ | PROT_WRITE, MAP_PRIVATE, - fileno (f), mmi.offset); -#else - addr = (void *)-1; -#endif - if (addr == (void *)-1) + fatal_error ("can't read PCH file: %m"); + + result = host_hooks.gt_pch_use_address (mmi.preferred_base, mmi.size, + fileno (f), mmi.offset); + if (result < 0) + fatal_error ("had to relocate PCH"); + if (result == 0) { - addr = xmalloc (mmi.size); if (fseek (f, mmi.offset, SEEK_SET) != 0 - || fread (&mmi, mmi.size, 1, f) != 1) - fatal_io_error ("can't read PCH file"); + || fread (mmi.preferred_base, mmi.size, 1, f) != 1) + fatal_error ("can't read PCH file: %m"); } else if (fseek (f, mmi.offset + mmi.size, SEEK_SET) != 0) - fatal_io_error ("can't read PCH file"); + fatal_error ("can't read PCH file: %m"); - ggc_pch_read (f, addr); + ggc_pch_read (f, mmi.preferred_base); - if (addr != mmi.preferred_base) - { - for (rt = gt_ggc_rtab; *rt; rt++) - for (rti = *rt; rti->base != NULL; rti++) - for (i = 0; i < rti->nelt; i++) - { - char **ptr = (char **)((char *)rti->base + rti->stride * i); - if (*ptr != NULL) - *ptr += (size_t)addr - (size_t)mmi.preferred_base; - } - - for (rt = gt_pch_cache_rtab; *rt; rt++) - for (rti = *rt; rti->base != NULL; rti++) - for (i = 0; i < rti->nelt; i++) - { - char **ptr = (char **)((char *)rti->base + rti->stride * i); - if (*ptr != NULL) - *ptr += (size_t)addr - (size_t)mmi.preferred_base; - } + gt_pch_restore_stringpool (); +} - sorry ("had to relocate PCH"); - } +/* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is not present. + Select no address whatsoever, and let gt_pch_save choose what it will with + malloc, presumably. */ - gt_pch_restore_stringpool (); +void * +default_gt_pch_get_address (size_t size ATTRIBUTE_UNUSED, + int fd ATTRIBUTE_UNUSED) +{ + return NULL; +} + +/* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is not present. + Allocate SIZE bytes with malloc. Return 0 if the address we got is the + same as base, indicating that the memory has been allocated but needs to + be read in from the file. Return -1 if the address differs, to relocation + of the PCH file would be required. */ + +int +default_gt_pch_use_address (void *base, size_t size, int fd ATTRIBUTE_UNUSED, + size_t offset ATTRIBUTE_UNUSED) +{ + void *addr = xmalloc (size); + return (addr == base) - 1; } +#if HAVE_MMAP_FILE +/* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is present. + We temporarily allocate SIZE bytes, and let the kernel place the data + wherever it will. If it worked, that's our spot, if not we're likely + to be in trouble. */ + +void * +mmap_gt_pch_get_address (size_t size, int fd) +{ + void *ret; + + ret = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0); + if (ret == (void *) MAP_FAILED) + ret = NULL; + else + munmap (ret, size); + + return ret; +} + +/* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is present. + Map SIZE bytes of FD+OFFSET at BASE. Return 1 if we succeeded at + mapping the data at BASE, -1 if we couldn't. + + This version assumes that the kernel honors the START operand of mmap + even without MAP_FIXED if START through START+SIZE are not currently + mapped with something. */ + +int +mmap_gt_pch_use_address (void *base, size_t size, int fd, size_t offset) +{ + void *addr; + + /* We're called with size == 0 if we're not planning to load a PCH + file at all. This allows the hook to free any static space that + we might have allocated at link time. */ + if (size == 0) + return -1; + + addr = mmap (base, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, + fd, offset); + + return addr == base ? 1 : -1; +} +#endif /* HAVE_MMAP_FILE */ + /* Modify the bound based on rlimits. Keep the smallest number found. */ static double -ggc_rlimit_bound (limit) - double limit; +ggc_rlimit_bound (double limit) { #if defined(HAVE_GETRLIMIT) struct rlimit rlim; @@ -668,13 +689,13 @@ ggc_rlimit_bound (limit) /* Heuristic to set a default for GGC_MIN_EXPAND. */ int -ggc_min_expand_heuristic() +ggc_min_expand_heuristic (void) { double min_expand = physmem_total(); /* Adjust for rlimits. */ min_expand = ggc_rlimit_bound (min_expand); - + /* The heuristic is a percentage equal to 30% + 70%*(RAM/1GB), yielding a lower bound of 30% and an upper bound of 100% (when RAM >= 1GB). */ min_expand /= 1024*1024*1024; @@ -687,15 +708,15 @@ ggc_min_expand_heuristic() /* Heuristic to set a default for GGC_MIN_HEAPSIZE. */ int -ggc_min_heapsize_heuristic() +ggc_min_heapsize_heuristic (void) { double min_heap_kbytes = physmem_total(); /* Adjust for rlimits. */ min_heap_kbytes = ggc_rlimit_bound (min_heap_kbytes); - min_heap_kbytes /= 1024; /* convert to Kbytes. */ - + min_heap_kbytes /= 1024; /* Convert to Kbytes. */ + /* The heuristic is RAM/8, with a lower bound of 4M and an upper bound of 128M (when RAM >= 1GB). */ min_heap_kbytes /= 8; @@ -706,10 +727,148 @@ ggc_min_heapsize_heuristic() } void -init_ggc_heuristics () +init_ggc_heuristics (void) { -#ifndef ENABLE_GC_ALWAYS_COLLECT +#if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT set_param_value ("ggc-min-expand", ggc_min_expand_heuristic()); set_param_value ("ggc-min-heapsize", ggc_min_heapsize_heuristic()); #endif } + +#ifdef GATHER_STATISTICS + +/* Datastructure used to store per-call-site statistics. */ +struct loc_descriptor +{ + const char *file; + int line; + const char *function; + int times; + size_t allocated; + size_t overhead; +}; + +/* Hashtable used for statistics. */ +static htab_t loc_hash; + +/* Hash table helpers functions. */ +static hashval_t +hash_descriptor (const void *p) +{ + const struct loc_descriptor *d = p; + + return htab_hash_pointer (d->function) | d->line; +} + +static int +eq_descriptor (const void *p1, const void *p2) +{ + const struct loc_descriptor *d = p1; + const struct loc_descriptor *d2 = p2; + + return (d->file == d2->file && d->line == d2->line + && d->function == d2->function); +} + +/* Return descriptor for given call site, create new one if needed. */ +static struct loc_descriptor * +loc_descriptor (const char *name, int line, const char *function) +{ + struct loc_descriptor loc; + struct loc_descriptor **slot; + + loc.file = name; + loc.line = line; + loc.function = function; + if (!loc_hash) + loc_hash = htab_create (10, hash_descriptor, eq_descriptor, NULL); + + slot = (struct loc_descriptor **) htab_find_slot (loc_hash, &loc, 1); + if (*slot) + return *slot; + *slot = xcalloc (sizeof (**slot), 1); + (*slot)->file = name; + (*slot)->line = line; + (*slot)->function = function; + return *slot; +} + +/* Record ALLOCATED and OVERHEAD bytes to descriptor NAME:LINE (FUNCTION). */ +void +ggc_record_overhead (size_t allocated, size_t overhead, + const char *name, int line, const char *function) +{ + struct loc_descriptor *loc = loc_descriptor (name, line, function); + + loc->times++; + loc->allocated+=allocated; + loc->overhead+=overhead; +} + +/* Helper for qsort; sort descriptors by amount of memory consumed. */ +static int +cmp_statistic (const void *loc1, const void *loc2) +{ + struct loc_descriptor *l1 = *(struct loc_descriptor **) loc1; + struct loc_descriptor *l2 = *(struct loc_descriptor **) loc2; + return (l1->allocated + l1->overhead) - (l2->allocated + l2->overhead); +} + +/* Collect array of the descriptors from hashtable. */ +struct loc_descriptor **loc_array; +static int +add_statistics (void **slot, void *b) +{ + int *n = (int *)b; + loc_array[*n] = (struct loc_descriptor *) *slot; + (*n)++; + return 1; +} + +/* Dump per-site memory statistics. */ +#endif +void dump_ggc_loc_statistics (void) +{ +#ifdef GATHER_STATISTICS + int nentries = 0; + char s[4096]; + size_t count, size, overhead; + int i; + + loc_array = xcalloc (sizeof (*loc_array), loc_hash->n_elements); + fprintf (stderr, "-------------------------------------------------------\n"); + fprintf (stderr, "\n%-60s %10s %10s %10s\n", + "source location", "Times", "Allocated", "Overhead"); + fprintf (stderr, "-------------------------------------------------------\n"); + count = 0; + size = 0; + overhead = 0; + htab_traverse (loc_hash, add_statistics, &nentries); + qsort (loc_array, nentries, sizeof (*loc_array), cmp_statistic); + for (i = 0; i < nentries; i++) + { + struct loc_descriptor *d = loc_array[i]; + size += d->allocated; + count += d->times; + overhead += d->overhead; + } + for (i = 0; i < nentries; i++) + { + struct loc_descriptor *d = loc_array[i]; + if (d->allocated) + { + const char *s1 = d->file; + const char *s2; + while ((s2 = strstr (s1, "gcc/"))) + s1 = s2 + 4; + sprintf (s, "%s:%i (%s)", s1, d->line, d->function); + fprintf (stderr, "%-60s %10i %10li %10li:%.3f%%\n", s, + d->times, (long)d->allocated, (long)d->overhead, + (d->allocated + d->overhead) *100.0 / (size + overhead)); + } + } + fprintf (stderr, "%-60s %10ld %10ld %10ld\n", + "Total", (long)count, (long)size, (long)overhead); + fprintf (stderr, "-------------------------------------------------------\n"); +#endif +}