OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [ggc-common.c] - Diff between revs 154 and 816

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 154 Rev 816
/* Simple garbage collection for the GNU compiler.
/* Simple garbage collection for the GNU compiler.
   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
   Free Software Foundation, Inc.
   Free Software Foundation, Inc.
 
 
This file is part of GCC.
This file is part of GCC.
 
 
GCC is free software; you can redistribute it and/or modify it under
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
Software Foundation; either version 3, or (at your option) any later
version.
version.
 
 
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.
for more details.
 
 
You should have received a copy of the GNU General Public License
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */
<http://www.gnu.org/licenses/>.  */
 
 
/* Generic garbage collection (GC) functions and data, not specific to
/* Generic garbage collection (GC) functions and data, not specific to
   any particular GC implementation.  */
   any particular GC implementation.  */
 
 
#include "config.h"
#include "config.h"
#include "system.h"
#include "system.h"
#include "coretypes.h"
#include "coretypes.h"
#include "hashtab.h"
#include "hashtab.h"
#include "ggc.h"
#include "ggc.h"
#include "toplev.h"
#include "toplev.h"
#include "params.h"
#include "params.h"
#include "hosthooks.h"
#include "hosthooks.h"
#include "hosthooks-def.h"
#include "hosthooks-def.h"
 
 
#ifdef HAVE_SYS_RESOURCE_H
#ifdef HAVE_SYS_RESOURCE_H
# include <sys/resource.h>
# include <sys/resource.h>
#endif
#endif
 
 
#ifdef HAVE_MMAP_FILE
#ifdef HAVE_MMAP_FILE
# include <sys/mman.h>
# include <sys/mman.h>
# ifdef HAVE_MINCORE
# ifdef HAVE_MINCORE
/* This is on Solaris.  */
/* This is on Solaris.  */
#  include <sys/types.h> 
#  include <sys/types.h> 
# endif
# endif
#endif
#endif
 
 
#ifndef MAP_FAILED
#ifndef MAP_FAILED
# define MAP_FAILED ((void *)-1)
# define MAP_FAILED ((void *)-1)
#endif
#endif
 
 
#ifdef ENABLE_VALGRIND_CHECKING
#ifdef ENABLE_VALGRIND_CHECKING
# ifdef HAVE_VALGRIND_MEMCHECK_H
# ifdef HAVE_VALGRIND_MEMCHECK_H
#  include <valgrind/memcheck.h>
#  include <valgrind/memcheck.h>
# elif defined HAVE_MEMCHECK_H
# elif defined HAVE_MEMCHECK_H
#  include <memcheck.h>
#  include <memcheck.h>
# else
# else
#  include <valgrind.h>
#  include <valgrind.h>
# endif
# endif
#else
#else
/* Avoid #ifdef:s when we can help it.  */
/* Avoid #ifdef:s when we can help it.  */
#define VALGRIND_DISCARD(x)
#define VALGRIND_DISCARD(x)
#endif
#endif
 
 
/* When set, ggc_collect will do collection.  */
/* When set, ggc_collect will do collection.  */
bool ggc_force_collect;
bool ggc_force_collect;
 
 
/* Statistics about the allocation.  */
/* Statistics about the allocation.  */
static ggc_statistics *ggc_stats;
static ggc_statistics *ggc_stats;
 
 
struct traversal_state;
struct traversal_state;
 
 
static int ggc_htab_delete (void **, void *);
static int ggc_htab_delete (void **, void *);
static hashval_t saving_htab_hash (const void *);
static hashval_t saving_htab_hash (const void *);
static int saving_htab_eq (const void *, const void *);
static int saving_htab_eq (const void *, const void *);
static int call_count (void **, void *);
static int call_count (void **, void *);
static int call_alloc (void **, void *);
static int call_alloc (void **, void *);
static int compare_ptr_data (const void *, const void *);
static int compare_ptr_data (const void *, const void *);
static void relocate_ptrs (void *, void *);
static void relocate_ptrs (void *, void *);
static void write_pch_globals (const struct ggc_root_tab * const *tab,
static void write_pch_globals (const struct ggc_root_tab * const *tab,
                               struct traversal_state *state);
                               struct traversal_state *state);
static double ggc_rlimit_bound (double);
static double ggc_rlimit_bound (double);
 
 
/* Maintain global roots that are preserved during GC.  */
/* Maintain global roots that are preserved during GC.  */
 
 
/* Process a slot of an htab by deleting it if it has not been marked.  */
/* Process a slot of an htab by deleting it if it has not been marked.  */
 
 
static int
static int
ggc_htab_delete (void **slot, void *info)
ggc_htab_delete (void **slot, void *info)
{
{
  const struct ggc_cache_tab *r = (const struct ggc_cache_tab *) info;
  const struct ggc_cache_tab *r = (const struct ggc_cache_tab *) info;
 
 
  if (! (*r->marked_p) (*slot))
  if (! (*r->marked_p) (*slot))
    htab_clear_slot (*r->base, slot);
    htab_clear_slot (*r->base, slot);
  else
  else
    (*r->cb) (*slot);
    (*r->cb) (*slot);
 
 
  return 1;
  return 1;
}
}
 
 
/* Iterate through all registered roots and mark each element.  */
/* Iterate through all registered roots and mark each element.  */
 
 
void
void
ggc_mark_roots (void)
ggc_mark_roots (void)
{
{
  const struct ggc_root_tab *const *rt;
  const struct ggc_root_tab *const *rt;
  const struct ggc_root_tab *rti;
  const struct ggc_root_tab *rti;
  const struct ggc_cache_tab *const *ct;
  const struct ggc_cache_tab *const *ct;
  const struct ggc_cache_tab *cti;
  const struct ggc_cache_tab *cti;
  size_t i;
  size_t i;
 
 
  for (rt = gt_ggc_deletable_rtab; *rt; rt++)
  for (rt = gt_ggc_deletable_rtab; *rt; rt++)
    for (rti = *rt; rti->base != NULL; rti++)
    for (rti = *rt; rti->base != NULL; rti++)
      memset (rti->base, 0, rti->stride);
      memset (rti->base, 0, rti->stride);
 
 
  for (rt = gt_ggc_rtab; *rt; rt++)
  for (rt = gt_ggc_rtab; *rt; rt++)
    for (rti = *rt; rti->base != NULL; rti++)
    for (rti = *rt; rti->base != NULL; rti++)
      for (i = 0; i < rti->nelt; i++)
      for (i = 0; i < rti->nelt; i++)
        (*rti->cb)(*(void **)((char *)rti->base + rti->stride * i));
        (*rti->cb)(*(void **)((char *)rti->base + rti->stride * i));
 
 
  ggc_mark_stringpool ();
  ggc_mark_stringpool ();
 
 
  /* Now scan all hash tables that have objects which are to be deleted if
  /* Now scan all hash tables that have objects which are to be deleted if
     they are not already marked.  */
     they are not already marked.  */
  for (ct = gt_ggc_cache_rtab; *ct; ct++)
  for (ct = gt_ggc_cache_rtab; *ct; ct++)
    for (cti = *ct; cti->base != NULL; cti++)
    for (cti = *ct; cti->base != NULL; cti++)
      if (*cti->base)
      if (*cti->base)
        {
        {
          ggc_set_mark (*cti->base);
          ggc_set_mark (*cti->base);
          htab_traverse_noresize (*cti->base, ggc_htab_delete, (void *) cti);
          htab_traverse_noresize (*cti->base, ggc_htab_delete, (void *) cti);
          ggc_set_mark ((*cti->base)->entries);
          ggc_set_mark ((*cti->base)->entries);
        }
        }
}
}
 
 
/* Allocate a block of memory, then clear it.  */
/* Allocate a block of memory, then clear it.  */
void *
void *
ggc_alloc_cleared_stat (size_t size MEM_STAT_DECL)
ggc_alloc_cleared_stat (size_t size MEM_STAT_DECL)
{
{
  void *buf = ggc_alloc_stat (size PASS_MEM_STAT);
  void *buf = ggc_alloc_stat (size PASS_MEM_STAT);
  memset (buf, 0, size);
  memset (buf, 0, size);
  return buf;
  return buf;
}
}
 
 
/* Resize a block of memory, possibly re-allocating it.  */
/* Resize a block of memory, possibly re-allocating it.  */
void *
void *
ggc_realloc_stat (void *x, size_t size MEM_STAT_DECL)
ggc_realloc_stat (void *x, size_t size MEM_STAT_DECL)
{
{
  void *r;
  void *r;
  size_t old_size;
  size_t old_size;
 
 
  if (x == NULL)
  if (x == NULL)
    return ggc_alloc_stat (size PASS_MEM_STAT);
    return ggc_alloc_stat (size PASS_MEM_STAT);
 
 
  old_size = ggc_get_size (x);
  old_size = ggc_get_size (x);
 
 
  if (size <= old_size)
  if (size <= old_size)
    {
    {
      /* Mark the unwanted memory as unaccessible.  We also need to make
      /* Mark the unwanted memory as unaccessible.  We also need to make
         the "new" size accessible, since ggc_get_size returns the size of
         the "new" size accessible, since ggc_get_size returns the size of
         the pool, not the size of the individually allocated object, the
         the pool, not the size of the individually allocated object, the
         size which was previously made accessible.  Unfortunately, we
         size which was previously made accessible.  Unfortunately, we
         don't know that previously allocated size.  Without that
         don't know that previously allocated size.  Without that
         knowledge we have to lose some initialization-tracking for the
         knowledge we have to lose some initialization-tracking for the
         old parts of the object.  An alternative is to mark the whole
         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
         after the end of the object (by small offsets).  Discard the
         handle to avoid handle leak.  */
         handle to avoid handle leak.  */
      VALGRIND_DISCARD (VALGRIND_MAKE_NOACCESS ((char *) x + size,
      VALGRIND_DISCARD (VALGRIND_MAKE_NOACCESS ((char *) x + size,
                                                old_size - size));
                                                old_size - size));
      VALGRIND_DISCARD (VALGRIND_MAKE_READABLE (x, size));
      VALGRIND_DISCARD (VALGRIND_MAKE_READABLE (x, size));
      return x;
      return x;
    }
    }
 
 
  r = ggc_alloc_stat (size PASS_MEM_STAT);
  r = ggc_alloc_stat (size PASS_MEM_STAT);
 
 
  /* Since ggc_get_size returns the size of the pool, not the size of the
  /* 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
     individually allocated object, we'd access parts of the old object
     that were marked invalid with the memcpy below.  We lose a bit of the
     that were marked invalid with the memcpy below.  We lose a bit of the
     initialization-tracking since some of it may be uninitialized.  */
     initialization-tracking since some of it may be uninitialized.  */
  VALGRIND_DISCARD (VALGRIND_MAKE_READABLE (x, old_size));
  VALGRIND_DISCARD (VALGRIND_MAKE_READABLE (x, old_size));
 
 
  memcpy (r, x, old_size);
  memcpy (r, x, old_size);
 
 
  /* The old object is not supposed to be used anymore.  */
  /* The old object is not supposed to be used anymore.  */
  ggc_free (x);
  ggc_free (x);
 
 
  return r;
  return r;
}
}
 
 
/* Like ggc_alloc_cleared, but performs a multiplication.  */
/* Like ggc_alloc_cleared, but performs a multiplication.  */
void *
void *
ggc_calloc (size_t s1, size_t s2)
ggc_calloc (size_t s1, size_t s2)
{
{
  return ggc_alloc_cleared (s1 * s2);
  return ggc_alloc_cleared (s1 * s2);
}
}
 
 
/* These are for splay_tree_new_ggc.  */
/* These are for splay_tree_new_ggc.  */
void *
void *
ggc_splay_alloc (int sz, void *nl)
ggc_splay_alloc (int sz, void *nl)
{
{
  gcc_assert (!nl);
  gcc_assert (!nl);
  return ggc_alloc (sz);
  return ggc_alloc (sz);
}
}
 
 
void
void
ggc_splay_dont_free (void * x ATTRIBUTE_UNUSED, void *nl)
ggc_splay_dont_free (void * x ATTRIBUTE_UNUSED, void *nl)
{
{
  gcc_assert (!nl);
  gcc_assert (!nl);
}
}
 
 
/* Print statistics that are independent of the collector in use.  */
/* Print statistics that are independent of the collector in use.  */
#define SCALE(x) ((unsigned long) ((x) < 1024*10 \
#define SCALE(x) ((unsigned long) ((x) < 1024*10 \
                  ? (x) \
                  ? (x) \
                  : ((x) < 1024*1024*10 \
                  : ((x) < 1024*1024*10 \
                     ? (x) / 1024 \
                     ? (x) / 1024 \
                     : (x) / (1024*1024))))
                     : (x) / (1024*1024))))
#define LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M'))
#define LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M'))
 
 
void
void
ggc_print_common_statistics (FILE *stream ATTRIBUTE_UNUSED,
ggc_print_common_statistics (FILE *stream ATTRIBUTE_UNUSED,
                             ggc_statistics *stats)
                             ggc_statistics *stats)
{
{
  /* Set the pointer so that during collection we will actually gather
  /* Set the pointer so that during collection we will actually gather
     the statistics.  */
     the statistics.  */
  ggc_stats = stats;
  ggc_stats = stats;
 
 
  /* Then do one collection to fill in the statistics.  */
  /* Then do one collection to fill in the statistics.  */
  ggc_collect ();
  ggc_collect ();
 
 
  /* At present, we don't really gather any interesting statistics.  */
  /* At present, we don't really gather any interesting statistics.  */
 
 
  /* Don't gather statistics any more.  */
  /* Don't gather statistics any more.  */
  ggc_stats = NULL;
  ggc_stats = NULL;
}
}


/* Functions for saving and restoring GCable memory to disk.  */
/* Functions for saving and restoring GCable memory to disk.  */
 
 
static htab_t saving_htab;
static htab_t saving_htab;
 
 
struct ptr_data
struct ptr_data
{
{
  void *obj;
  void *obj;
  void *note_ptr_cookie;
  void *note_ptr_cookie;
  gt_note_pointers note_ptr_fn;
  gt_note_pointers note_ptr_fn;
  gt_handle_reorder reorder_fn;
  gt_handle_reorder reorder_fn;
  size_t size;
  size_t size;
  void *new_addr;
  void *new_addr;
  enum gt_types_enum type;
  enum gt_types_enum type;
};
};
 
 
#define POINTER_HASH(x) (hashval_t)((long)x >> 3)
#define POINTER_HASH(x) (hashval_t)((long)x >> 3)
 
 
/* Register an object in the hash table.  */
/* Register an object in the hash table.  */
 
 
int
int
gt_pch_note_object (void *obj, void *note_ptr_cookie,
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)
                    enum gt_types_enum type)
{
{
  struct ptr_data **slot;
  struct ptr_data **slot;
 
 
  if (obj == NULL || obj == (void *) 1)
  if (obj == NULL || obj == (void *) 1)
    return 0;
    return 0;
 
 
  slot = (struct ptr_data **)
  slot = (struct ptr_data **)
    htab_find_slot_with_hash (saving_htab, obj, POINTER_HASH (obj),
    htab_find_slot_with_hash (saving_htab, obj, POINTER_HASH (obj),
                              INSERT);
                              INSERT);
  if (*slot != NULL)
  if (*slot != NULL)
    {
    {
      gcc_assert ((*slot)->note_ptr_fn == note_ptr_fn
      gcc_assert ((*slot)->note_ptr_fn == note_ptr_fn
                  && (*slot)->note_ptr_cookie == note_ptr_cookie);
                  && (*slot)->note_ptr_cookie == note_ptr_cookie);
      return 0;
      return 0;
    }
    }
 
 
  *slot = xcalloc (sizeof (struct ptr_data), 1);
  *slot = xcalloc (sizeof (struct ptr_data), 1);
  (*slot)->obj = obj;
  (*slot)->obj = obj;
  (*slot)->note_ptr_fn = note_ptr_fn;
  (*slot)->note_ptr_fn = note_ptr_fn;
  (*slot)->note_ptr_cookie = note_ptr_cookie;
  (*slot)->note_ptr_cookie = note_ptr_cookie;
  if (note_ptr_fn == gt_pch_p_S)
  if (note_ptr_fn == gt_pch_p_S)
    (*slot)->size = strlen (obj) + 1;
    (*slot)->size = strlen (obj) + 1;
  else
  else
    (*slot)->size = ggc_get_size (obj);
    (*slot)->size = ggc_get_size (obj);
  (*slot)->type = type;
  (*slot)->type = type;
  return 1;
  return 1;
}
}
 
 
/* Register an object in the hash table.  */
/* Register an object in the hash table.  */
 
 
void
void
gt_pch_note_reorder (void *obj, void *note_ptr_cookie,
gt_pch_note_reorder (void *obj, void *note_ptr_cookie,
                     gt_handle_reorder reorder_fn)
                     gt_handle_reorder reorder_fn)
{
{
  struct ptr_data *data;
  struct ptr_data *data;
 
 
  if (obj == NULL || obj == (void *) 1)
  if (obj == NULL || obj == (void *) 1)
    return;
    return;
 
 
  data = htab_find_with_hash (saving_htab, obj, POINTER_HASH (obj));
  data = htab_find_with_hash (saving_htab, obj, POINTER_HASH (obj));
  gcc_assert (data && data->note_ptr_cookie == note_ptr_cookie);
  gcc_assert (data && data->note_ptr_cookie == note_ptr_cookie);
 
 
  data->reorder_fn = reorder_fn;
  data->reorder_fn = reorder_fn;
}
}
 
 
/* Hash and equality functions for saving_htab, callbacks for htab_create.  */
/* Hash and equality functions for saving_htab, callbacks for htab_create.  */
 
 
static hashval_t
static hashval_t
saving_htab_hash (const void *p)
saving_htab_hash (const void *p)
{
{
  return POINTER_HASH (((struct ptr_data *)p)->obj);
  return POINTER_HASH (((struct ptr_data *)p)->obj);
}
}
 
 
static int
static int
saving_htab_eq (const void *p1, const void *p2)
saving_htab_eq (const void *p1, const void *p2)
{
{
  return ((struct ptr_data *)p1)->obj == p2;
  return ((struct ptr_data *)p1)->obj == p2;
}
}
 
 
/* Handy state for the traversal functions.  */
/* Handy state for the traversal functions.  */
 
 
struct traversal_state
struct traversal_state
{
{
  FILE *f;
  FILE *f;
  struct ggc_pch_data *d;
  struct ggc_pch_data *d;
  size_t count;
  size_t count;
  struct ptr_data **ptrs;
  struct ptr_data **ptrs;
  size_t ptrs_i;
  size_t ptrs_i;
};
};
 
 
/* Callbacks for htab_traverse.  */
/* Callbacks for htab_traverse.  */
 
 
static int
static int
call_count (void **slot, void *state_p)
call_count (void **slot, void *state_p)
{
{
  struct ptr_data *d = (struct ptr_data *)*slot;
  struct ptr_data *d = (struct ptr_data *)*slot;
  struct traversal_state *state = (struct traversal_state *)state_p;
  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,
                        d->note_ptr_fn == gt_pch_p_S,
                        d->type);
                        d->type);
  state->count++;
  state->count++;
  return 1;
  return 1;
}
}
 
 
static int
static int
call_alloc (void **slot, void *state_p)
call_alloc (void **slot, void *state_p)
{
{
  struct ptr_data *d = (struct ptr_data *)*slot;
  struct ptr_data *d = (struct ptr_data *)*slot;
  struct traversal_state *state = (struct traversal_state *)state_p;
  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,
                                      d->note_ptr_fn == gt_pch_p_S,
                                      d->type);
                                      d->type);
  state->ptrs[state->ptrs_i++] = d;
  state->ptrs[state->ptrs_i++] = d;
  return 1;
  return 1;
}
}
 
 
/* Callback for qsort.  */
/* Callback for qsort.  */
 
 
static int
static int
compare_ptr_data (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 *p1 = *(struct ptr_data *const *)p1_p;
  struct ptr_data *p2 = *(struct ptr_data *const *)p2_p;
  struct ptr_data *p2 = *(struct ptr_data *const *)p2_p;
  return (((size_t)p1->new_addr > (size_t)p2->new_addr)
  return (((size_t)p1->new_addr > (size_t)p2->new_addr)
          - ((size_t)p1->new_addr < (size_t)p2->new_addr));
          - ((size_t)p1->new_addr < (size_t)p2->new_addr));
}
}
 
 
/* Callbacks for note_ptr_fn.  */
/* Callbacks for note_ptr_fn.  */
 
 
static void
static void
relocate_ptrs (void *ptr_p, void *state_p)
relocate_ptrs (void *ptr_p, void *state_p)
{
{
  void **ptr = (void **)ptr_p;
  void **ptr = (void **)ptr_p;
  struct traversal_state *state ATTRIBUTE_UNUSED
  struct traversal_state *state ATTRIBUTE_UNUSED
    = (struct traversal_state *)state_p;
    = (struct traversal_state *)state_p;
  struct ptr_data *result;
  struct ptr_data *result;
 
 
  if (*ptr == NULL || *ptr == (void *)1)
  if (*ptr == NULL || *ptr == (void *)1)
    return;
    return;
 
 
  result = htab_find_with_hash (saving_htab, *ptr, POINTER_HASH (*ptr));
  result = htab_find_with_hash (saving_htab, *ptr, POINTER_HASH (*ptr));
  gcc_assert (result);
  gcc_assert (result);
  *ptr = result->new_addr;
  *ptr = result->new_addr;
}
}
 
 
/* Write out, after relocation, the pointers in TAB.  */
/* Write out, after relocation, the pointers in TAB.  */
static void
static void
write_pch_globals (const struct ggc_root_tab * const *tab,
write_pch_globals (const struct ggc_root_tab * const *tab,
                   struct traversal_state *state)
                   struct traversal_state *state)
{
{
  const struct ggc_root_tab *const *rt;
  const struct ggc_root_tab *const *rt;
  const struct ggc_root_tab *rti;
  const struct ggc_root_tab *rti;
  size_t i;
  size_t i;
 
 
  for (rt = tab; *rt; rt++)
  for (rt = tab; *rt; rt++)
    for (rti = *rt; rti->base != NULL; rti++)
    for (rti = *rt; rti->base != NULL; rti++)
      for (i = 0; i < rti->nelt; i++)
      for (i = 0; i < rti->nelt; i++)
        {
        {
          void *ptr = *(void **)((char *)rti->base + rti->stride * i);
          void *ptr = *(void **)((char *)rti->base + rti->stride * i);
          struct ptr_data *new_ptr;
          struct ptr_data *new_ptr;
          if (ptr == NULL || ptr == (void *)1)
          if (ptr == NULL || ptr == (void *)1)
            {
            {
              if (fwrite (&ptr, sizeof (void *), 1, state->f)
              if (fwrite (&ptr, sizeof (void *), 1, state->f)
                  != 1)
                  != 1)
                fatal_error ("can't write PCH file: %m");
                fatal_error ("can't write PCH file: %m");
            }
            }
          else
          else
            {
            {
              new_ptr = htab_find_with_hash (saving_htab, ptr,
              new_ptr = htab_find_with_hash (saving_htab, ptr,
                                             POINTER_HASH (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)
                  != 1)
                fatal_error ("can't write PCH file: %m");
                fatal_error ("can't write PCH file: %m");
            }
            }
        }
        }
}
}
 
 
/* Hold the information we need to mmap the file back in.  */
/* Hold the information we need to mmap the file back in.  */
 
 
struct mmap_info
struct mmap_info
{
{
  size_t offset;
  size_t offset;
  size_t size;
  size_t size;
  void *preferred_base;
  void *preferred_base;
};
};
 
 
/* Write out the state of the compiler to F.  */
/* Write out the state of the compiler to F.  */
 
 
void
void
gt_pch_save (FILE *f)
gt_pch_save (FILE *f)
{
{
  const struct ggc_root_tab *const *rt;
  const struct ggc_root_tab *const *rt;
  const struct ggc_root_tab *rti;
  const struct ggc_root_tab *rti;
  size_t i;
  size_t i;
  struct traversal_state state;
  struct traversal_state state;
  char *this_object = NULL;
  char *this_object = NULL;
  size_t this_object_size = 0;
  size_t this_object_size = 0;
  struct mmap_info mmi;
  struct mmap_info mmi;
  const size_t mmap_offset_alignment = host_hooks.gt_pch_alloc_granularity();
  const size_t mmap_offset_alignment = host_hooks.gt_pch_alloc_granularity();
 
 
  gt_pch_save_stringpool ();
  gt_pch_save_stringpool ();
 
 
  saving_htab = htab_create (50000, saving_htab_hash, saving_htab_eq, free);
  saving_htab = htab_create (50000, saving_htab_hash, saving_htab_eq, free);
 
 
  for (rt = gt_ggc_rtab; *rt; rt++)
  for (rt = gt_ggc_rtab; *rt; rt++)
    for (rti = *rt; rti->base != NULL; rti++)
    for (rti = *rt; rti->base != NULL; rti++)
      for (i = 0; i < rti->nelt; i++)
      for (i = 0; i < rti->nelt; i++)
        (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
        (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
 
 
  for (rt = gt_pch_cache_rtab; *rt; rt++)
  for (rt = gt_pch_cache_rtab; *rt; rt++)
    for (rti = *rt; rti->base != NULL; rti++)
    for (rti = *rt; rti->base != NULL; rti++)
      for (i = 0; i < rti->nelt; i++)
      for (i = 0; i < rti->nelt; i++)
        (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
        (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
 
 
  /* Prepare the objects for writing, determine addresses and such.  */
  /* Prepare the objects for writing, determine addresses and such.  */
  state.f = f;
  state.f = f;
  state.d = init_ggc_pch();
  state.d = init_ggc_pch();
  state.count = 0;
  state.count = 0;
  htab_traverse (saving_htab, call_count, &state);
  htab_traverse (saving_htab, call_count, &state);
 
 
  mmi.size = ggc_pch_total_size (state.d);
  mmi.size = ggc_pch_total_size (state.d);
 
 
  /* Try to arrange things so that no relocation is necessary, but
  /* Try to arrange things so that no relocation is necessary, but
     don't try very hard.  On most platforms, this will always work,
     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.
     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
     (The extra work goes in HOST_HOOKS_GT_PCH_GET_ADDRESS and
     HOST_HOOKS_GT_PCH_USE_ADDRESS.)  */
     HOST_HOOKS_GT_PCH_USE_ADDRESS.)  */
  mmi.preferred_base = host_hooks.gt_pch_get_address (mmi.size, fileno (f));
  mmi.preferred_base = host_hooks.gt_pch_get_address (mmi.size, fileno (f));
 
 
  ggc_pch_this_base (state.d, mmi.preferred_base);
  ggc_pch_this_base (state.d, mmi.preferred_base);
 
 
  state.ptrs = XNEWVEC (struct ptr_data *, state.count);
  state.ptrs = XNEWVEC (struct ptr_data *, state.count);
  state.ptrs_i = 0;
  state.ptrs_i = 0;
  htab_traverse (saving_htab, call_alloc, &state);
  htab_traverse (saving_htab, call_alloc, &state);
  qsort (state.ptrs, state.count, sizeof (*state.ptrs), compare_ptr_data);
  qsort (state.ptrs, state.count, sizeof (*state.ptrs), compare_ptr_data);
 
 
  /* Write out all the scalar variables.  */
  /* Write out all the scalar variables.  */
  for (rt = gt_pch_scalar_rtab; *rt; rt++)
  for (rt = gt_pch_scalar_rtab; *rt; rt++)
    for (rti = *rt; rti->base != NULL; rti++)
    for (rti = *rt; rti->base != NULL; rti++)
      if (fwrite (rti->base, rti->stride, 1, f) != 1)
      if (fwrite (rti->base, rti->stride, 1, f) != 1)
        fatal_error ("can't write PCH file: %m");
        fatal_error ("can't write PCH file: %m");
 
 
  /* Write out all the global pointers, after translation.  */
  /* Write out all the global pointers, after translation.  */
  write_pch_globals (gt_ggc_rtab, &state);
  write_pch_globals (gt_ggc_rtab, &state);
  write_pch_globals (gt_pch_cache_rtab, &state);
  write_pch_globals (gt_pch_cache_rtab, &state);
 
 
  /* Pad the PCH file so that the mmapped area starts on an allocation
  /* Pad the PCH file so that the mmapped area starts on an allocation
     granularity (usually page) boundary.  */
     granularity (usually page) boundary.  */
  {
  {
    long o;
    long o;
    o = ftell (state.f) + sizeof (mmi);
    o = ftell (state.f) + sizeof (mmi);
    if (o == -1)
    if (o == -1)
      fatal_error ("can't get position in PCH file: %m");
      fatal_error ("can't get position in PCH file: %m");
    mmi.offset = mmap_offset_alignment - o % mmap_offset_alignment;
    mmi.offset = mmap_offset_alignment - o % mmap_offset_alignment;
    if (mmi.offset == mmap_offset_alignment)
    if (mmi.offset == mmap_offset_alignment)
      mmi.offset = 0;
      mmi.offset = 0;
    mmi.offset += o;
    mmi.offset += o;
  }
  }
  if (fwrite (&mmi, sizeof (mmi), 1, state.f) != 1)
  if (fwrite (&mmi, sizeof (mmi), 1, state.f) != 1)
    fatal_error ("can't write PCH file: %m");
    fatal_error ("can't write PCH file: %m");
  if (mmi.offset != 0
  if (mmi.offset != 0
      && fseek (state.f, mmi.offset, SEEK_SET) != 0)
      && fseek (state.f, mmi.offset, SEEK_SET) != 0)
    fatal_error ("can't write padding to PCH file: %m");
    fatal_error ("can't write padding to PCH file: %m");
 
 
  ggc_pch_prepare_write (state.d, state.f);
  ggc_pch_prepare_write (state.d, state.f);
 
 
  /* Actually write out the objects.  */
  /* Actually write out the objects.  */
  for (i = 0; i < state.count; i++)
  for (i = 0; i < state.count; i++)
    {
    {
      if (this_object_size < state.ptrs[i]->size)
      if (this_object_size < state.ptrs[i]->size)
        {
        {
          this_object_size = state.ptrs[i]->size;
          this_object_size = state.ptrs[i]->size;
          this_object = xrealloc (this_object, this_object_size);
          this_object = xrealloc (this_object, this_object_size);
        }
        }
      memcpy (this_object, state.ptrs[i]->obj, state.ptrs[i]->size);
      memcpy (this_object, state.ptrs[i]->obj, state.ptrs[i]->size);
      if (state.ptrs[i]->reorder_fn != NULL)
      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,
                                   state.ptrs[i]->note_ptr_cookie,
                                   relocate_ptrs, &state);
                                   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,
                                  state.ptrs[i]->note_ptr_cookie,
                                  relocate_ptrs, &state);
                                  relocate_ptrs, &state);
      ggc_pch_write_object (state.d, state.f, state.ptrs[i]->obj,
      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);
                            state.ptrs[i]->note_ptr_fn == gt_pch_p_S);
      if (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);
        memcpy (state.ptrs[i]->obj, this_object, state.ptrs[i]->size);
    }
    }
  ggc_pch_finish (state.d, state.f);
  ggc_pch_finish (state.d, state.f);
  gt_pch_fixup_stringpool ();
  gt_pch_fixup_stringpool ();
 
 
  free (state.ptrs);
  free (state.ptrs);
  htab_delete (saving_htab);
  htab_delete (saving_htab);
}
}
 
 
/* Read the state of the compiler back in from F.  */
/* Read the state of the compiler back in from F.  */
 
 
void
void
gt_pch_restore (FILE *f)
gt_pch_restore (FILE *f)
{
{
  const struct ggc_root_tab *const *rt;
  const struct ggc_root_tab *const *rt;
  const struct ggc_root_tab *rti;
  const struct ggc_root_tab *rti;
  size_t i;
  size_t i;
  struct mmap_info mmi;
  struct mmap_info mmi;
  int result;
  int result;
 
 
  /* Delete any deletable objects.  This makes ggc_pch_read much
  /* Delete any deletable objects.  This makes ggc_pch_read much
     faster, as it can be sure that no GCable objects remain other
     faster, as it can be sure that no GCable objects remain other
     than the ones just read in.  */
     than the ones just read in.  */
  for (rt = gt_ggc_deletable_rtab; *rt; rt++)
  for (rt = gt_ggc_deletable_rtab; *rt; rt++)
    for (rti = *rt; rti->base != NULL; rti++)
    for (rti = *rt; rti->base != NULL; rti++)
      memset (rti->base, 0, rti->stride);
      memset (rti->base, 0, rti->stride);
 
 
  /* Read in all the scalar variables.  */
  /* Read in all the scalar variables.  */
  for (rt = gt_pch_scalar_rtab; *rt; rt++)
  for (rt = gt_pch_scalar_rtab; *rt; rt++)
    for (rti = *rt; rti->base != NULL; rti++)
    for (rti = *rt; rti->base != NULL; rti++)
      if (fread (rti->base, rti->stride, 1, f) != 1)
      if (fread (rti->base, rti->stride, 1, f) != 1)
        fatal_error ("can't read PCH file: %m");
        fatal_error ("can't read PCH file: %m");
 
 
  /* Read in all the global pointers, in 6 easy loops.  */
  /* Read in all the global pointers, in 6 easy loops.  */
  for (rt = gt_ggc_rtab; *rt; rt++)
  for (rt = gt_ggc_rtab; *rt; rt++)
    for (rti = *rt; rti->base != NULL; rti++)
    for (rti = *rt; rti->base != NULL; rti++)
      for (i = 0; i < rti->nelt; i++)
      for (i = 0; i < rti->nelt; i++)
        if (fread ((char *)rti->base + rti->stride * i,
        if (fread ((char *)rti->base + rti->stride * i,
                   sizeof (void *), 1, f) != 1)
                   sizeof (void *), 1, f) != 1)
          fatal_error ("can't read PCH file: %m");
          fatal_error ("can't read PCH file: %m");
 
 
  for (rt = gt_pch_cache_rtab; *rt; rt++)
  for (rt = gt_pch_cache_rtab; *rt; rt++)
    for (rti = *rt; rti->base != NULL; rti++)
    for (rti = *rt; rti->base != NULL; rti++)
      for (i = 0; i < rti->nelt; i++)
      for (i = 0; i < rti->nelt; i++)
        if (fread ((char *)rti->base + rti->stride * i,
        if (fread ((char *)rti->base + rti->stride * i,
                   sizeof (void *), 1, f) != 1)
                   sizeof (void *), 1, f) != 1)
          fatal_error ("can't read PCH file: %m");
          fatal_error ("can't read PCH file: %m");
 
 
  if (fread (&mmi, sizeof (mmi), 1, f) != 1)
  if (fread (&mmi, sizeof (mmi), 1, f) != 1)
    fatal_error ("can't read PCH file: %m");
    fatal_error ("can't read PCH file: %m");
 
 
  result = host_hooks.gt_pch_use_address (mmi.preferred_base, mmi.size,
  result = host_hooks.gt_pch_use_address (mmi.preferred_base, mmi.size,
                                          fileno (f), mmi.offset);
                                          fileno (f), mmi.offset);
  if (result < 0)
  if (result < 0)
    fatal_error ("had to relocate PCH");
    fatal_error ("had to relocate PCH");
  if (result == 0)
  if (result == 0)
    {
    {
      if (fseek (f, mmi.offset, SEEK_SET) != 0
      if (fseek (f, mmi.offset, SEEK_SET) != 0
          || fread (mmi.preferred_base, mmi.size, 1, f) != 1)
          || fread (mmi.preferred_base, mmi.size, 1, f) != 1)
        fatal_error ("can't read PCH file: %m");
        fatal_error ("can't read PCH file: %m");
    }
    }
  else if (fseek (f, mmi.offset + mmi.size, SEEK_SET) != 0)
  else if (fseek (f, mmi.offset + mmi.size, SEEK_SET) != 0)
    fatal_error ("can't read PCH file: %m");
    fatal_error ("can't read PCH file: %m");
 
 
  ggc_pch_read (f, mmi.preferred_base);
  ggc_pch_read (f, mmi.preferred_base);
 
 
  gt_pch_restore_stringpool ();
  gt_pch_restore_stringpool ();
}
}
 
 
/* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is not present.
/* 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
   Select no address whatsoever, and let gt_pch_save choose what it will with
   malloc, presumably.  */
   malloc, presumably.  */
 
 
void *
void *
default_gt_pch_get_address (size_t size ATTRIBUTE_UNUSED,
default_gt_pch_get_address (size_t size ATTRIBUTE_UNUSED,
                            int fd ATTRIBUTE_UNUSED)
                            int fd ATTRIBUTE_UNUSED)
{
{
  return NULL;
  return NULL;
}
}
 
 
/* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is not present.
/* 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
   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
   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
   be read in from the file.  Return -1 if the address differs, to relocation
   of the PCH file would be required.  */
   of the PCH file would be required.  */
 
 
int
int
default_gt_pch_use_address (void *base, size_t size, int fd ATTRIBUTE_UNUSED,
default_gt_pch_use_address (void *base, size_t size, int fd ATTRIBUTE_UNUSED,
                            size_t offset ATTRIBUTE_UNUSED)
                            size_t offset ATTRIBUTE_UNUSED)
{
{
  void *addr = xmalloc (size);
  void *addr = xmalloc (size);
  return (addr == base) - 1;
  return (addr == base) - 1;
}
}
 
 
/* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS.   Return the
/* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS.   Return the
   alignment required for allocating virtual memory. Usually this is the
   alignment required for allocating virtual memory. Usually this is the
   same as pagesize.  */
   same as pagesize.  */
 
 
size_t
size_t
default_gt_pch_alloc_granularity (void)
default_gt_pch_alloc_granularity (void)
{
{
  return getpagesize();
  return getpagesize();
}
}
 
 
#if HAVE_MMAP_FILE
#if HAVE_MMAP_FILE
/* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is present.
/* 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
   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
   wherever it will.  If it worked, that's our spot, if not we're likely
   to be in trouble.  */
   to be in trouble.  */
 
 
void *
void *
mmap_gt_pch_get_address (size_t size, int fd)
mmap_gt_pch_get_address (size_t size, int fd)
{
{
  void *ret;
  void *ret;
 
 
  ret = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
  ret = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
  if (ret == (void *) MAP_FAILED)
  if (ret == (void *) MAP_FAILED)
    ret = NULL;
    ret = NULL;
  else
  else
    munmap (ret, size);
    munmap (ret, size);
 
 
  return ret;
  return ret;
}
}
 
 
/* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is present.
/* 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
   Map SIZE bytes of FD+OFFSET at BASE.  Return 1 if we succeeded at
   mapping the data at BASE, -1 if we couldn't.
   mapping the data at BASE, -1 if we couldn't.
 
 
   This version assumes that the kernel honors the START operand of mmap
   This version assumes that the kernel honors the START operand of mmap
   even without MAP_FIXED if START through START+SIZE are not currently
   even without MAP_FIXED if START through START+SIZE are not currently
   mapped with something.  */
   mapped with something.  */
 
 
int
int
mmap_gt_pch_use_address (void *base, size_t size, int fd, size_t offset)
mmap_gt_pch_use_address (void *base, size_t size, int fd, size_t offset)
{
{
  void *addr;
  void *addr;
 
 
  /* We're called with size == 0 if we're not planning to load a PCH
  /* 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
     file at all.  This allows the hook to free any static space that
     we might have allocated at link time.  */
     we might have allocated at link time.  */
  if (size == 0)
  if (size == 0)
    return -1;
    return -1;
 
 
  addr = mmap (base, size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
  addr = mmap (base, size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
               fd, offset);
               fd, offset);
 
 
  return addr == base ? 1 : -1;
  return addr == base ? 1 : -1;
}
}
#endif /* HAVE_MMAP_FILE */
#endif /* HAVE_MMAP_FILE */
 
 
/* Modify the bound based on rlimits.  */
/* Modify the bound based on rlimits.  */
static double
static double
ggc_rlimit_bound (double limit)
ggc_rlimit_bound (double limit)
{
{
#if defined(HAVE_GETRLIMIT)
#if defined(HAVE_GETRLIMIT)
  struct rlimit rlim;
  struct rlimit rlim;
# if defined (RLIMIT_AS)
# if defined (RLIMIT_AS)
  /* RLIMIT_AS is what POSIX says is the limit on mmap.  Presumably
  /* RLIMIT_AS is what POSIX says is the limit on mmap.  Presumably
     any OS which has RLIMIT_AS also has a working mmap that GCC will use.  */
     any OS which has RLIMIT_AS also has a working mmap that GCC will use.  */
  if (getrlimit (RLIMIT_AS, &rlim) == 0
  if (getrlimit (RLIMIT_AS, &rlim) == 0
      && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
      && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
      && rlim.rlim_cur < limit)
      && rlim.rlim_cur < limit)
    limit = rlim.rlim_cur;
    limit = rlim.rlim_cur;
# elif defined (RLIMIT_DATA)
# elif defined (RLIMIT_DATA)
  /* ... but some older OSs bound mmap based on RLIMIT_DATA, or we
  /* ... but some older OSs bound mmap based on RLIMIT_DATA, or we
     might be on an OS that has a broken mmap.  (Others don't bound
     might be on an OS that has a broken mmap.  (Others don't bound
     mmap at all, apparently.)  */
     mmap at all, apparently.)  */
  if (getrlimit (RLIMIT_DATA, &rlim) == 0
  if (getrlimit (RLIMIT_DATA, &rlim) == 0
      && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
      && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
      && rlim.rlim_cur < limit
      && rlim.rlim_cur < limit
      /* Darwin has this horribly bogus default setting of
      /* Darwin has this horribly bogus default setting of
         RLIMIT_DATA, to 6144Kb.  No-one notices because RLIMIT_DATA
         RLIMIT_DATA, to 6144Kb.  No-one notices because RLIMIT_DATA
         appears to be ignored.  Ignore such silliness.  If a limit
         appears to be ignored.  Ignore such silliness.  If a limit
         this small was actually effective for mmap, GCC wouldn't even
         this small was actually effective for mmap, GCC wouldn't even
         start up.  */
         start up.  */
      && rlim.rlim_cur >= 8 * 1024 * 1024)
      && rlim.rlim_cur >= 8 * 1024 * 1024)
    limit = rlim.rlim_cur;
    limit = rlim.rlim_cur;
# endif /* RLIMIT_AS or RLIMIT_DATA */
# endif /* RLIMIT_AS or RLIMIT_DATA */
#endif /* HAVE_GETRLIMIT */
#endif /* HAVE_GETRLIMIT */
 
 
  return limit;
  return limit;
}
}
 
 
/* Heuristic to set a default for GGC_MIN_EXPAND.  */
/* Heuristic to set a default for GGC_MIN_EXPAND.  */
int
int
ggc_min_expand_heuristic (void)
ggc_min_expand_heuristic (void)
{
{
  double min_expand = physmem_total();
  double min_expand = physmem_total();
 
 
  /* Adjust for rlimits.  */
  /* Adjust for rlimits.  */
  min_expand = ggc_rlimit_bound (min_expand);
  min_expand = ggc_rlimit_bound (min_expand);
 
 
  /* The heuristic is a percentage equal to 30% + 70%*(RAM/1GB), yielding
  /* 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).  */
     a lower bound of 30% and an upper bound of 100% (when RAM >= 1GB).  */
  min_expand /= 1024*1024*1024;
  min_expand /= 1024*1024*1024;
  min_expand *= 70;
  min_expand *= 70;
  min_expand = MIN (min_expand, 70);
  min_expand = MIN (min_expand, 70);
  min_expand += 30;
  min_expand += 30;
 
 
  return min_expand;
  return min_expand;
}
}
 
 
/* Heuristic to set a default for GGC_MIN_HEAPSIZE.  */
/* Heuristic to set a default for GGC_MIN_HEAPSIZE.  */
int
int
ggc_min_heapsize_heuristic (void)
ggc_min_heapsize_heuristic (void)
{
{
  double phys_kbytes = physmem_total();
  double phys_kbytes = physmem_total();
  double limit_kbytes = ggc_rlimit_bound (phys_kbytes * 2);
  double limit_kbytes = ggc_rlimit_bound (phys_kbytes * 2);
 
 
  phys_kbytes /= 1024; /* Convert to Kbytes.  */
  phys_kbytes /= 1024; /* Convert to Kbytes.  */
  limit_kbytes /= 1024;
  limit_kbytes /= 1024;
 
 
  /* The heuristic is RAM/8, with a lower bound of 4M and an upper
  /* The heuristic is RAM/8, with a lower bound of 4M and an upper
     bound of 128M (when RAM >= 1GB).  */
     bound of 128M (when RAM >= 1GB).  */
  phys_kbytes /= 8;
  phys_kbytes /= 8;
 
 
#if defined(HAVE_GETRLIMIT) && defined (RLIMIT_RSS)
#if defined(HAVE_GETRLIMIT) && defined (RLIMIT_RSS)
  /* Try not to overrun the RSS limit while doing garbage collection.
  /* Try not to overrun the RSS limit while doing garbage collection.
     The RSS limit is only advisory, so no margin is subtracted.  */
     The RSS limit is only advisory, so no margin is subtracted.  */
 {
 {
   struct rlimit rlim;
   struct rlimit rlim;
   if (getrlimit (RLIMIT_RSS, &rlim) == 0
   if (getrlimit (RLIMIT_RSS, &rlim) == 0
       && rlim.rlim_cur != (rlim_t) RLIM_INFINITY)
       && rlim.rlim_cur != (rlim_t) RLIM_INFINITY)
     phys_kbytes = MIN (phys_kbytes, rlim.rlim_cur / 1024);
     phys_kbytes = MIN (phys_kbytes, rlim.rlim_cur / 1024);
 }
 }
# endif
# endif
 
 
  /* Don't blindly run over our data limit; do GC at least when the
  /* 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
     *next* GC would be within 16Mb of the limit.  If GCC does hit the
     data limit, compilation will fail, so this tries to be
     data limit, compilation will fail, so this tries to be
     conservative.  */
     conservative.  */
  limit_kbytes = MAX (0, limit_kbytes - 16 * 1024);
  limit_kbytes = MAX (0, limit_kbytes - 16 * 1024);
  limit_kbytes = (limit_kbytes * 100) / (110 + ggc_min_expand_heuristic());
  limit_kbytes = (limit_kbytes * 100) / (110 + ggc_min_expand_heuristic());
  phys_kbytes = MIN (phys_kbytes, limit_kbytes);
  phys_kbytes = MIN (phys_kbytes, limit_kbytes);
 
 
  phys_kbytes = MAX (phys_kbytes, 4 * 1024);
  phys_kbytes = MAX (phys_kbytes, 4 * 1024);
  phys_kbytes = MIN (phys_kbytes, 128 * 1024);
  phys_kbytes = MIN (phys_kbytes, 128 * 1024);
 
 
  return phys_kbytes;
  return phys_kbytes;
}
}
 
 
void
void
init_ggc_heuristics (void)
init_ggc_heuristics (void)
{
{
#if !defined ENABLE_GC_CHECKING && !defined 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-expand", ggc_min_expand_heuristic());
  set_param_value ("ggc-min-heapsize", ggc_min_heapsize_heuristic());
  set_param_value ("ggc-min-heapsize", ggc_min_heapsize_heuristic());
#endif
#endif
}
}
 
 
#ifdef GATHER_STATISTICS
#ifdef GATHER_STATISTICS
 
 
/* Datastructure used to store per-call-site statistics.  */
/* Datastructure used to store per-call-site statistics.  */
struct loc_descriptor
struct loc_descriptor
{
{
  const char *file;
  const char *file;
  int line;
  int line;
  const char *function;
  const char *function;
  int times;
  int times;
  size_t allocated;
  size_t allocated;
  size_t overhead;
  size_t overhead;
  size_t freed;
  size_t freed;
  size_t collected;
  size_t collected;
};
};
 
 
/* Hashtable used for statistics.  */
/* Hashtable used for statistics.  */
static htab_t loc_hash;
static htab_t loc_hash;
 
 
/* Hash table helpers functions.  */
/* Hash table helpers functions.  */
static hashval_t
static hashval_t
hash_descriptor (const void *p)
hash_descriptor (const void *p)
{
{
  const struct loc_descriptor *d = p;
  const struct loc_descriptor *d = p;
 
 
  return htab_hash_pointer (d->function) | d->line;
  return htab_hash_pointer (d->function) | d->line;
}
}
 
 
static int
static int
eq_descriptor (const void *p1, const void *p2)
eq_descriptor (const void *p1, const void *p2)
{
{
  const struct loc_descriptor *d = p1;
  const struct loc_descriptor *d = p1;
  const struct loc_descriptor *d2 = p2;
  const struct loc_descriptor *d2 = p2;
 
 
  return (d->file == d2->file && d->line == d2->line
  return (d->file == d2->file && d->line == d2->line
          && d->function == d2->function);
          && d->function == d2->function);
}
}
 
 
/* Hashtable converting address of allocated field to loc descriptor.  */
/* Hashtable converting address of allocated field to loc descriptor.  */
static htab_t ptr_hash;
static htab_t ptr_hash;
struct ptr_hash_entry
struct ptr_hash_entry
{
{
  void *ptr;
  void *ptr;
  struct loc_descriptor *loc;
  struct loc_descriptor *loc;
  size_t size;
  size_t size;
};
};
 
 
/* Hash table helpers functions.  */
/* Hash table helpers functions.  */
static hashval_t
static hashval_t
hash_ptr (const void *p)
hash_ptr (const void *p)
{
{
  const struct ptr_hash_entry *d = p;
  const struct ptr_hash_entry *d = p;
 
 
  return htab_hash_pointer (d->ptr);
  return htab_hash_pointer (d->ptr);
}
}
 
 
static int
static int
eq_ptr (const void *p1, const void *p2)
eq_ptr (const void *p1, const void *p2)
{
{
  const struct ptr_hash_entry *p = p1;
  const struct ptr_hash_entry *p = p1;
 
 
  return (p->ptr == p2);
  return (p->ptr == p2);
}
}
 
 
/* Return descriptor for given call site, create new one if needed.  */
/* Return descriptor for given call site, create new one if needed.  */
static struct loc_descriptor *
static struct loc_descriptor *
loc_descriptor (const char *name, int line, const char *function)
loc_descriptor (const char *name, int line, const char *function)
{
{
  struct loc_descriptor loc;
  struct loc_descriptor loc;
  struct loc_descriptor **slot;
  struct loc_descriptor **slot;
 
 
  loc.file = name;
  loc.file = name;
  loc.line = line;
  loc.line = line;
  loc.function = function;
  loc.function = function;
  if (!loc_hash)
  if (!loc_hash)
    loc_hash = htab_create (10, hash_descriptor, eq_descriptor, NULL);
    loc_hash = htab_create (10, hash_descriptor, eq_descriptor, NULL);
 
 
  slot = (struct loc_descriptor **) htab_find_slot (loc_hash, &loc, 1);
  slot = (struct loc_descriptor **) htab_find_slot (loc_hash, &loc, 1);
  if (*slot)
  if (*slot)
    return *slot;
    return *slot;
  *slot = xcalloc (sizeof (**slot), 1);
  *slot = xcalloc (sizeof (**slot), 1);
  (*slot)->file = name;
  (*slot)->file = name;
  (*slot)->line = line;
  (*slot)->line = line;
  (*slot)->function = function;
  (*slot)->function = function;
  return *slot;
  return *slot;
}
}
 
 
/* Record ALLOCATED and OVERHEAD bytes to descriptor NAME:LINE (FUNCTION).  */
/* Record ALLOCATED and OVERHEAD bytes to descriptor NAME:LINE (FUNCTION).  */
void
void
ggc_record_overhead (size_t allocated, size_t overhead, void *ptr,
ggc_record_overhead (size_t allocated, size_t overhead, void *ptr,
                     const char *name, int line, const char *function)
                     const char *name, int line, const char *function)
{
{
  struct loc_descriptor *loc = loc_descriptor (name, line, function);
  struct loc_descriptor *loc = loc_descriptor (name, line, function);
  struct ptr_hash_entry *p = XNEW (struct ptr_hash_entry);
  struct ptr_hash_entry *p = XNEW (struct ptr_hash_entry);
  PTR *slot;
  PTR *slot;
 
 
  p->ptr = ptr;
  p->ptr = ptr;
  p->loc = loc;
  p->loc = loc;
  p->size = allocated + overhead;
  p->size = allocated + overhead;
  if (!ptr_hash)
  if (!ptr_hash)
    ptr_hash = htab_create (10, hash_ptr, eq_ptr, NULL);
    ptr_hash = htab_create (10, hash_ptr, eq_ptr, NULL);
  slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr), INSERT);
  slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr), INSERT);
  gcc_assert (!*slot);
  gcc_assert (!*slot);
  *slot = p;
  *slot = p;
 
 
  loc->times++;
  loc->times++;
  loc->allocated+=allocated;
  loc->allocated+=allocated;
  loc->overhead+=overhead;
  loc->overhead+=overhead;
}
}
 
 
/* Helper function for prune_overhead_list.  See if SLOT is still marked and
/* Helper function for prune_overhead_list.  See if SLOT is still marked and
   remove it from hashtable if it is not.  */
   remove it from hashtable if it is not.  */
static int
static int
ggc_prune_ptr (void **slot, void *b ATTRIBUTE_UNUSED)
ggc_prune_ptr (void **slot, void *b ATTRIBUTE_UNUSED)
{
{
  struct ptr_hash_entry *p = *slot;
  struct ptr_hash_entry *p = *slot;
  if (!ggc_marked_p (p->ptr))
  if (!ggc_marked_p (p->ptr))
    {
    {
      p->loc->collected += p->size;
      p->loc->collected += p->size;
      htab_clear_slot (ptr_hash, slot);
      htab_clear_slot (ptr_hash, slot);
      free (p);
      free (p);
    }
    }
  return 1;
  return 1;
}
}
 
 
/* After live values has been marked, walk all recorded pointers and see if
/* After live values has been marked, walk all recorded pointers and see if
   they are still live.  */
   they are still live.  */
void
void
ggc_prune_overhead_list (void)
ggc_prune_overhead_list (void)
{
{
  htab_traverse (ptr_hash, ggc_prune_ptr, NULL);
  htab_traverse (ptr_hash, ggc_prune_ptr, NULL);
}
}
 
 
/* Notice that the pointer has been freed.  */
/* Notice that the pointer has been freed.  */
void
void
ggc_free_overhead (void *ptr)
ggc_free_overhead (void *ptr)
{
{
  PTR *slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr),
  PTR *slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr),
                                        NO_INSERT);
                                        NO_INSERT);
  struct ptr_hash_entry *p = *slot;
  struct ptr_hash_entry *p = *slot;
  p->loc->freed += p->size;
  p->loc->freed += p->size;
  htab_clear_slot (ptr_hash, slot);
  htab_clear_slot (ptr_hash, slot);
  free (p);
  free (p);
}
}
 
 
/* Helper for qsort; sort descriptors by amount of memory consumed.  */
/* Helper for qsort; sort descriptors by amount of memory consumed.  */
static int
static int
cmp_statistic (const void *loc1, const void *loc2)
cmp_statistic (const void *loc1, const void *loc2)
{
{
  struct loc_descriptor *l1 = *(struct loc_descriptor **) loc1;
  struct loc_descriptor *l1 = *(struct loc_descriptor **) loc1;
  struct loc_descriptor *l2 = *(struct loc_descriptor **) loc2;
  struct loc_descriptor *l2 = *(struct loc_descriptor **) loc2;
  return ((l1->allocated + l1->overhead - l1->freed) -
  return ((l1->allocated + l1->overhead - l1->freed) -
          (l2->allocated + l2->overhead - l2->freed));
          (l2->allocated + l2->overhead - l2->freed));
}
}
 
 
/* Collect array of the descriptors from hashtable.  */
/* Collect array of the descriptors from hashtable.  */
struct loc_descriptor **loc_array;
struct loc_descriptor **loc_array;
static int
static int
add_statistics (void **slot, void *b)
add_statistics (void **slot, void *b)
{
{
  int *n = (int *)b;
  int *n = (int *)b;
  loc_array[*n] = (struct loc_descriptor *) *slot;
  loc_array[*n] = (struct loc_descriptor *) *slot;
  (*n)++;
  (*n)++;
  return 1;
  return 1;
}
}
 
 
/* Dump per-site memory statistics.  */
/* Dump per-site memory statistics.  */
#endif
#endif
void
void
dump_ggc_loc_statistics (void)
dump_ggc_loc_statistics (void)
{
{
#ifdef GATHER_STATISTICS
#ifdef GATHER_STATISTICS
  int nentries = 0;
  int nentries = 0;
  char s[4096];
  char s[4096];
  size_t collected = 0, freed = 0, allocated = 0, overhead = 0, times = 0;
  size_t collected = 0, freed = 0, allocated = 0, overhead = 0, times = 0;
  int i;
  int i;
 
 
  ggc_force_collect = true;
  ggc_force_collect = true;
  ggc_collect ();
  ggc_collect ();
 
 
  loc_array = xcalloc (sizeof (*loc_array), loc_hash->n_elements);
  loc_array = xcalloc (sizeof (*loc_array), loc_hash->n_elements);
  fprintf (stderr, "-------------------------------------------------------\n");
  fprintf (stderr, "-------------------------------------------------------\n");
  fprintf (stderr, "\n%-48s %10s       %10s       %10s       %10s       %10s\n",
  fprintf (stderr, "\n%-48s %10s       %10s       %10s       %10s       %10s\n",
           "source location", "Garbage", "Freed", "Leak", "Overhead", "Times");
           "source location", "Garbage", "Freed", "Leak", "Overhead", "Times");
  fprintf (stderr, "-------------------------------------------------------\n");
  fprintf (stderr, "-------------------------------------------------------\n");
  htab_traverse (loc_hash, add_statistics, &nentries);
  htab_traverse (loc_hash, add_statistics, &nentries);
  qsort (loc_array, nentries, sizeof (*loc_array), cmp_statistic);
  qsort (loc_array, nentries, sizeof (*loc_array), cmp_statistic);
  for (i = 0; i < nentries; i++)
  for (i = 0; i < nentries; i++)
    {
    {
      struct loc_descriptor *d = loc_array[i];
      struct loc_descriptor *d = loc_array[i];
      allocated += d->allocated;
      allocated += d->allocated;
      times += d->times;
      times += d->times;
      freed += d->freed;
      freed += d->freed;
      collected += d->collected;
      collected += d->collected;
      overhead += d->overhead;
      overhead += d->overhead;
    }
    }
  for (i = 0; i < nentries; i++)
  for (i = 0; i < nentries; i++)
    {
    {
      struct loc_descriptor *d = loc_array[i];
      struct loc_descriptor *d = loc_array[i];
      if (d->allocated)
      if (d->allocated)
        {
        {
          const char *s1 = d->file;
          const char *s1 = d->file;
          const char *s2;
          const char *s2;
          while ((s2 = strstr (s1, "gcc/")))
          while ((s2 = strstr (s1, "gcc/")))
            s1 = s2 + 4;
            s1 = s2 + 4;
          sprintf (s, "%s:%i (%s)", s1, d->line, d->function);
          sprintf (s, "%s:%i (%s)", s1, d->line, d->function);
          s[48] = 0;
          s[48] = 0;
          fprintf (stderr, "%-48s %10li:%4.1f%% %10li:%4.1f%% %10li:%4.1f%% %10li:%4.1f%% %10li\n", s,
          fprintf (stderr, "%-48s %10li:%4.1f%% %10li:%4.1f%% %10li:%4.1f%% %10li:%4.1f%% %10li\n", s,
                   (long)d->collected,
                   (long)d->collected,
                   (d->collected) * 100.0 / collected,
                   (d->collected) * 100.0 / collected,
                   (long)d->freed,
                   (long)d->freed,
                   (d->freed) * 100.0 / freed,
                   (d->freed) * 100.0 / freed,
                   (long)(d->allocated + d->overhead - d->freed - d->collected),
                   (long)(d->allocated + d->overhead - d->freed - d->collected),
                   (d->allocated + d->overhead - d->freed - d->collected) * 100.0
                   (d->allocated + d->overhead - d->freed - d->collected) * 100.0
                   / (allocated + overhead - freed - collected),
                   / (allocated + overhead - freed - collected),
                   (long)d->overhead,
                   (long)d->overhead,
                   d->overhead * 100.0 / overhead,
                   d->overhead * 100.0 / overhead,
                   (long)d->times);
                   (long)d->times);
        }
        }
    }
    }
  fprintf (stderr, "%-48s %10ld       %10ld       %10ld       %10ld       %10ld\n",
  fprintf (stderr, "%-48s %10ld       %10ld       %10ld       %10ld       %10ld\n",
           "Total", (long)collected, (long)freed,
           "Total", (long)collected, (long)freed,
           (long)(allocated + overhead - freed - collected), (long)overhead,
           (long)(allocated + overhead - freed - collected), (long)overhead,
           (long)times);
           (long)times);
  fprintf (stderr, "%-48s %10s       %10s       %10s       %10s       %10s\n",
  fprintf (stderr, "%-48s %10s       %10s       %10s       %10s       %10s\n",
           "source location", "Garbage", "Freed", "Leak", "Overhead", "Times");
           "source location", "Garbage", "Freed", "Leak", "Overhead", "Times");
  fprintf (stderr, "-------------------------------------------------------\n");
  fprintf (stderr, "-------------------------------------------------------\n");
#endif
#endif
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.