/* Simple garbage collection for the GNU compiler.
- Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004
+ Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
Free Software Foundation, Inc.
This file is part of GCC.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA. */
/* Generic garbage collection (GC) functions and data, not specific to
any particular GC implementation. */
void *
ggc_splay_alloc (int sz, void *nl)
{
- if (nl != NULL)
- abort ();
+ gcc_assert (!nl);
return ggc_alloc (sz);
}
void
ggc_splay_dont_free (void * x ATTRIBUTE_UNUSED, void *nl)
{
- if (nl != NULL)
- abort ();
+ gcc_assert (!nl);
}
/* Print statistics that are independent of the collector in use. */
gt_handle_reorder reorder_fn;
size_t size;
void *new_addr;
+ enum gt_types_enum type;
};
#define POINTER_HASH(x) (hashval_t)((long)x >> 3)
int
gt_pch_note_object (void *obj, void *note_ptr_cookie,
- gt_note_pointers note_ptr_fn)
+ gt_note_pointers note_ptr_fn,
+ enum gt_types_enum type)
{
struct ptr_data **slot;
INSERT);
if (*slot != NULL)
{
- if ((*slot)->note_ptr_fn != note_ptr_fn
- || (*slot)->note_ptr_cookie != note_ptr_cookie)
- abort ();
+ gcc_assert ((*slot)->note_ptr_fn == note_ptr_fn
+ && (*slot)->note_ptr_cookie == note_ptr_cookie);
return 0;
}
(*slot)->size = strlen (obj) + 1;
else
(*slot)->size = ggc_get_size (obj);
+ (*slot)->type = type;
return 1;
}
return;
data = htab_find_with_hash (saving_htab, obj, POINTER_HASH (obj));
- if (data == NULL
- || data->note_ptr_cookie != note_ptr_cookie)
- abort ();
+ gcc_assert (data && data->note_ptr_cookie == note_ptr_cookie);
data->reorder_fn = reorder_fn;
}
static hashval_t
saving_htab_hash (const void *p)
{
- return POINTER_HASH (((struct ptr_data *)p)->obj);
+ return POINTER_HASH (((const struct ptr_data *)p)->obj);
}
static int
saving_htab_eq (const void *p1, const void *p2)
{
- return ((struct ptr_data *)p1)->obj == p2;
+ return ((const struct ptr_data *)p1)->obj == p2;
}
/* Handy state for the traversal functions. */
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, d->note_ptr_fn == gt_pch_p_S);
+ ggc_pch_count_object (state->d, d->obj, d->size,
+ d->note_ptr_fn == gt_pch_p_S,
+ d->type);
state->count++;
return 1;
}
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->note_ptr_fn == gt_pch_p_S);
+ d->new_addr = ggc_pch_alloc_object (state->d, d->obj, d->size,
+ d->note_ptr_fn == gt_pch_p_S,
+ d->type);
state->ptrs[state->ptrs_i++] = d;
return 1;
}
return;
result = htab_find_with_hash (saving_htab, *ptr, POINTER_HASH (*ptr));
- if (result == NULL)
- abort ();
+ gcc_assert (result);
*ptr = result->new_addr;
}
ggc_pch_this_base (state.d, mmi.preferred_base);
- state.ptrs = xmalloc (state.count * sizeof (*state.ptrs));
+ state.ptrs = XNEWVEC (struct ptr_data *, state.count);
state.ptrs_i = 0;
htab_traverse (saving_htab, call_alloc, &state);
qsort (state.ptrs, state.count, sizeof (*state.ptrs), compare_ptr_data);
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 mmapped area starts on an allocation
granularity (usually page) boundary. */
{
&& fseek (state.f, mmi.offset, SEEK_SET) != 0)
fatal_error ("can't write padding to PCH file: %m");
+ ggc_pch_prepare_write (state.d, state.f);
+
/* Actually write out the objects. */
for (i = 0; i < state.count; i++)
{
# endif
/* Don't blindly run over our data limit; do GC at least when the
- *next* GC would be within 16Mb of the limit. If GCC does hit the
- data limit, compilation will fail, so this tries to be
- conservative. */
- limit_kbytes = MAX (0, limit_kbytes - 16 * 1024);
+ *next* GC would be within 20Mb of the limit or within a quarter of
+ the limit, whichever is larger. If GCC does hit the data limit,
+ compilation will fail, so this tries to be conservative. */
+ limit_kbytes = MAX (0, limit_kbytes - MAX (limit_kbytes / 4, 20 * 1024));
limit_kbytes = (limit_kbytes * 100) / (110 + ggc_min_expand_heuristic());
phys_kbytes = MIN (phys_kbytes, limit_kbytes);
const char *name, int line, const char *function)
{
struct loc_descriptor *loc = loc_descriptor (name, line, function);
- struct ptr_hash_entry *p = xmalloc (sizeof (struct ptr_hash_entry));
+ struct ptr_hash_entry *p = XNEW (struct ptr_hash_entry);
PTR *slot;
p->ptr = ptr;
if (!ptr_hash)
ptr_hash = htab_create (10, hash_ptr, eq_ptr, NULL);
slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr), INSERT);
- if (*slot)
- abort ();
+ gcc_assert (!*slot);
*slot = p;
loc->times++;
}
/* Notice that the pointer has been freed. */
-void ggc_free_overhead (void *ptr)
+void
+ggc_free_overhead (void *ptr)
{
PTR *slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr),
NO_INSERT);
/* Helper for qsort; sort descriptors by amount of memory consumed. */
static int
+final_cmp_statistic (const void *loc1, const void *loc2)
+{
+ struct loc_descriptor *l1 = *(struct loc_descriptor **) loc1;
+ struct loc_descriptor *l2 = *(struct loc_descriptor **) loc2;
+ long diff;
+ diff = ((long)(l1->allocated + l1->overhead - l1->freed) -
+ (l2->allocated + l2->overhead - l2->freed));
+ return diff > 0 ? 1 : diff < 0 ? -1 : 0;
+}
+
+/* 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 - l1->freed) -
- (l2->allocated + l2->overhead - l1->freed));
+ long diff;
+
+ diff = ((long)(l1->allocated + l1->overhead - l1->freed - l1->collected) -
+ (l2->allocated + l2->overhead - l2->freed - l2->collected));
+ if (diff)
+ return diff > 0 ? 1 : diff < 0 ? -1 : 0;
+ diff = ((long)(l1->allocated + l1->overhead - l1->freed) -
+ (l2->allocated + l2->overhead - l2->freed));
+ return diff > 0 ? 1 : diff < 0 ? -1 : 0;
}
/* Collect array of the descriptors from hashtable. */
/* Dump per-site memory statistics. */
#endif
-void dump_ggc_loc_statistics (void)
+void
+dump_ggc_loc_statistics (bool final ATTRIBUTE_UNUSED)
{
#ifdef GATHER_STATISTICS
int nentries = 0;
"source location", "Garbage", "Freed", "Leak", "Overhead", "Times");
fprintf (stderr, "-------------------------------------------------------\n");
htab_traverse (loc_hash, add_statistics, &nentries);
- qsort (loc_array, nentries, sizeof (*loc_array), cmp_statistic);
+ qsort (loc_array, nentries, sizeof (*loc_array),
+ final ? final_cmp_statistic : cmp_statistic);
for (i = 0; i < nentries; i++)
{
struct loc_descriptor *d = loc_array[i];
OSDN Git Service
