OSDN Git Service

(root) / pf3gnuchains / gcc-fork.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Replace type != type comparisons with types_compatible_p.
[pf3gnuchains/gcc-fork.git] / gcc / ggc-common.c
diff --git a/gcc/ggc-common.c b/gcc/ggc-common.c
index 53057c8..28c2b79 100644 (file)
--- a/gcc/ggc-common.c
+++ b/gcc/ggc-common.c
@@ -1,11 +1,12 @@
 /* Simple garbage collection for the GNU compiler.
 /* Simple garbage collection for the GNU compiler.
-   Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+   Free Software Foundation, Inc.
 
 This file is part of GCC.
 
 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
 
 This file is part of GCC.
 
 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
-Software Foundation; either version 2, or (at your option) any later
+Software Foundation; either version 3, or (at your option) any later
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
@@ -14,692 +15,1083 @@ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 for more details.
 
 You should have received a copy of the GNU General Public License
 for more details.
 
 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.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
 
 /* Generic garbage collection (GC) functions and data, not specific to
    any particular GC implementation.  */
 
 #include "config.h"
 #include "system.h"
 
 /* Generic garbage collection (GC) functions and data, not specific to
    any particular GC implementation.  */
 
 #include "config.h"
 #include "system.h"
-#include "rtl.h"
-#include "tree.h"
-#include "tm_p.h"
-#include "hash.h"
+#include "coretypes.h"
 #include "hashtab.h"
 #include "hashtab.h"
-#include "varray.h"
 #include "ggc.h"
 #include "ggc.h"
+#include "toplev.h"
+#include "params.h"
+#include "hosthooks.h"
+#include "hosthooks-def.h"
+#include "plugin.h"
+#include "vec.h"
+#include "timevar.h"
+
+#ifdef HAVE_SYS_RESOURCE_H
+# include <sys/resource.h>
+#endif
+
+#ifdef HAVE_MMAP_FILE
+# include <sys/mman.h>
+# ifdef HAVE_MINCORE
+/* This is on Solaris.  */
+#  include <sys/types.h>
+# endif
+#endif
+
+#ifndef MAP_FAILED
+# define MAP_FAILED ((void *)-1)
+#endif
+
+/* When set, ggc_collect will do collection.  */
+bool ggc_force_collect;
+
+/* When true, protect the contents of the identifier hash table.  */
+bool ggc_protect_identifiers = true;
 
 /* Statistics about the allocation.  */
 static ggc_statistics *ggc_stats;
 
 
 /* Statistics about the allocation.  */
 static ggc_statistics *ggc_stats;
 
-/* The FALSE_LABEL_STACK, declared in except.h, has language-dependent
-   semantics.  If a front-end needs to mark the false label stack, it
-   should set this pointer to a non-NULL value.  Otherwise, no marking
-   will be done.  */
-void (*lang_mark_false_label_stack) PARAMS ((struct label_node *));
-
-/* Trees that have been marked, but whose children still need marking.  */
-varray_type ggc_pending_trees;
-
-static void ggc_mark_rtx_ptr PARAMS ((void *));
-static void ggc_mark_tree_ptr PARAMS ((void *));
-static void ggc_mark_rtx_varray_ptr PARAMS ((void *));
-static void ggc_mark_tree_varray_ptr PARAMS ((void *));
-static void ggc_mark_tree_hash_table_ptr PARAMS ((void *));
-static int ggc_htab_delete PARAMS ((void **, void *));
-static void ggc_mark_trees PARAMS ((void));
-static bool ggc_mark_tree_hash_table_entry PARAMS ((struct hash_entry *,
-                                                   hash_table_key));
+struct traversal_state;
+
+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.  */
 
 
 /* Maintain global roots that are preserved during GC.  */
 
-/* Global roots that are preserved during calls to gc.  */
+/* Process a slot of an htab by deleting it if it has not been marked.  */
 
 
-struct ggc_root
+static int
+ggc_htab_delete (void **slot, void *info)
 {
 {
-  struct ggc_root *next;
-  void *base;
-  int nelt;
-  int size;
-  void (*cb) PARAMS ((void *));
-};
+  const struct ggc_cache_tab *r = (const struct ggc_cache_tab *) info;
 
 
-static struct ggc_root *roots;
+  if (! (*r->marked_p) (*slot))
+    htab_clear_slot (*r->base, slot);
+  else
+    (*r->cb) (*slot);
 
 
-/* Add BASE as a new garbage collection root.  It is an array of
-   length NELT with each element SIZE bytes long.  CB is a 
-   function that will be called with a pointer to each element
-   of the array; it is the intention that CB call the appropriate
-   routine to mark gc-able memory for that element.  */
+  return 1;
+}
 
 
-void
-ggc_add_root (base, nelt, size, cb)
-     void *base;
-     int nelt, size;
-     void (*cb) PARAMS ((void *));
-{
-  struct ggc_root *x = (struct ggc_root *) xmalloc (sizeof (*x));
 
 
-  x->next = roots;
-  x->base = base;
-  x->nelt = nelt;
-  x->size = size;
-  x->cb = cb;
+/* This extra vector of dynamically registered root_tab-s is used by
+   ggc_mark_roots and gives the ability to dynamically add new GGC root
+   tables, for instance from some plugins; this vector is on the heap
+   since it is used by GGC internally.  */
+typedef const struct ggc_root_tab *const_ggc_root_tab_t;
+DEF_VEC_P(const_ggc_root_tab_t);
+DEF_VEC_ALLOC_P(const_ggc_root_tab_t, heap);
+static VEC(const_ggc_root_tab_t, heap) *extra_root_vec;
+
+/* Dynamically register a new GGC root table RT. This is useful for
+   plugins. */
 
 
-  roots = x;
+void
+ggc_register_root_tab (const struct ggc_root_tab* rt)
+{
+  if (rt)
+    VEC_safe_push (const_ggc_root_tab_t, heap, extra_root_vec, rt);
 }
 
 }
 
-/* Register an array of rtx as a GC root.  */
+/* This extra vector of dynamically registered cache_tab-s is used by
+   ggc_mark_roots and gives the ability to dynamically add new GGC cache
+   tables, for instance from some plugins; this vector is on the heap
+   since it is used by GGC internally.  */
+typedef const struct ggc_cache_tab *const_ggc_cache_tab_t;
+DEF_VEC_P(const_ggc_cache_tab_t);
+DEF_VEC_ALLOC_P(const_ggc_cache_tab_t, heap);
+static VEC(const_ggc_cache_tab_t, heap) *extra_cache_vec;
+
+/* Dynamically register a new GGC cache table CT. This is useful for
+   plugins. */
 
 void
 
 void
-ggc_add_rtx_root (base, nelt)
-     rtx *base;
-     int nelt;
+ggc_register_cache_tab (const struct ggc_cache_tab* ct)
 {
 {
-  ggc_add_root (base, nelt, sizeof (rtx), ggc_mark_rtx_ptr);
+  if (ct)
+    VEC_safe_push (const_ggc_cache_tab_t, heap, extra_cache_vec, ct);
 }
 
 }
 
-/* Register an array of trees as a GC root.  */
+/* Scan a hash table that has objects which are to be deleted if they are not
+   already marked.  */
 
 
-void
-ggc_add_tree_root (base, nelt)
-     tree *base;
-     int nelt;
+static void
+ggc_scan_cache_tab (const_ggc_cache_tab_t ctp)
 {
 {
-  ggc_add_root (base, nelt, sizeof (tree), ggc_mark_tree_ptr);
+  const struct ggc_cache_tab *cti;
+
+  for (cti = ctp; cti->base != NULL; cti++)
+    if (*cti->base)
+      {
+        ggc_set_mark (*cti->base);
+        htab_traverse_noresize (*cti->base, ggc_htab_delete,
+                                CONST_CAST (void *, (const void *)cti));
+        ggc_set_mark ((*cti->base)->entries);
+      }
 }
 
 }
 
-/* Register a varray of rtxs as a GC root.  */
+/* Iterate through all registered roots and mark each element.  */
 
 void
 
 void
-ggc_add_rtx_varray_root (base, nelt)
-     varray_type *base;
-     int nelt;
+ggc_mark_roots (void)
 {
 {
-  ggc_add_root (base, nelt, sizeof (varray_type), 
-               ggc_mark_rtx_varray_ptr);
+  const struct ggc_root_tab *const *rt;
+  const struct ggc_root_tab *rti;
+  const_ggc_root_tab_t rtp;
+  const struct ggc_cache_tab *const *ct;
+  const_ggc_cache_tab_t ctp;
+  size_t i;
+
+  for (rt = gt_ggc_deletable_rtab; *rt; rt++)
+    for (rti = *rt; rti->base != NULL; rti++)
+      memset (rti->base, 0, rti->stride);
+
+  for (rt = gt_ggc_rtab; *rt; rt++)
+    for (rti = *rt; rti->base != NULL; rti++)
+      for (i = 0; i < rti->nelt; i++)
+       (*rti->cb) (*(void **)((char *)rti->base + rti->stride * i));
+
+  for (i = 0; VEC_iterate (const_ggc_root_tab_t, extra_root_vec, i, rtp); i++)
+    {
+      for (rti = rtp; rti->base != NULL; rti++)
+        for (i = 0; i < rti->nelt; i++)
+          (*rti->cb) (*(void **) ((char *)rti->base + rti->stride * i));
+    }
+
+  if (ggc_protect_identifiers)
+    ggc_mark_stringpool ();
+
+  /* Now scan all hash tables that have objects which are to be deleted if
+     they are not already marked.  */
+  for (ct = gt_ggc_cache_rtab; *ct; ct++)
+    ggc_scan_cache_tab (*ct);
+
+  for (i = 0; VEC_iterate (const_ggc_cache_tab_t, extra_cache_vec, i, ctp); i++)
+    ggc_scan_cache_tab (ctp);
+
+  if (! ggc_protect_identifiers)
+    ggc_purge_stringpool ();
+
+  /* Some plugins may call ggc_set_mark from here.  */
+  invoke_plugin_callbacks (PLUGIN_GGC_MARKING, NULL);
 }
 
 }
 
-/* Register a varray of trees as a GC root.  */
+/* Allocate a block of memory, then clear it.  */
+void *
+ggc_alloc_cleared_stat (size_t size MEM_STAT_DECL)
+{
+  void *buf = ggc_alloc_stat (size PASS_MEM_STAT);
+  memset (buf, 0, size);
+  return buf;
+}
 
 
-void
-ggc_add_tree_varray_root (base, nelt)
-     varray_type *base;
-     int nelt;
+/* Resize a block of memory, possibly re-allocating it.  */
+void *
+ggc_realloc_stat (void *x, size_t size MEM_STAT_DECL)
 {
 {
-  ggc_add_root (base, nelt, sizeof (varray_type), 
-               ggc_mark_tree_varray_ptr);
+  void *r;
+  size_t old_size;
+
+  if (x == NULL)
+    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
+        the "new" size accessible, since ggc_get_size returns the size of
+        the pool, not the size of the individually allocated object, the
+        size which was previously made accessible.  Unfortunately, we
+        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
+        after the end of the object (by small offsets).  Discard the
+        handle to avoid handle leak.  */
+      VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS ((char *) x + size,
+                                                   old_size - size));
+      VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (x, size));
+      return x;
+    }
+
+  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
+     that were marked invalid with the memcpy below.  We lose a bit of the
+     initialization-tracking since some of it may be uninitialized.  */
+  VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (x, old_size));
+
+  memcpy (r, x, old_size);
+
+  /* The old object is not supposed to be used anymore.  */
+  ggc_free (x);
+
+  return r;
 }
 
 }
 
-/* Register a hash table of trees as a GC root.  */
+/* Like ggc_alloc_cleared, but performs a multiplication.  */
+void *
+ggc_calloc (size_t s1, size_t s2)
+{
+  return ggc_alloc_cleared (s1 * s2);
+}
+
+/* These are for splay_tree_new_ggc.  */
+void *
+ggc_splay_alloc (int sz, void *nl)
+{
+  gcc_assert (!nl);
+  return ggc_alloc (sz);
+}
 
 void
 
 void
-ggc_add_tree_hash_table_root (base, nelt)
-     struct hash_table **base;
-     int nelt;
+ggc_splay_dont_free (void * x ATTRIBUTE_UNUSED, void *nl)
 {
 {
-  ggc_add_root (base, nelt, sizeof (struct hash_table *), 
-               ggc_mark_tree_hash_table_ptr);
+  gcc_assert (!nl);
 }
 
 }
 
-/* Remove the previously registered GC root at BASE.  */
+/* Print statistics that are independent of the collector in use.  */
+#define SCALE(x) ((unsigned long) ((x) < 1024*10 \
+                 ? (x) \
+                 : ((x) < 1024*1024*10 \
+                    ? (x) / 1024 \
+                    : (x) / (1024*1024))))
+#define LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M'))
 
 void
 
 void
-ggc_del_root (base)
-     void *base;
+ggc_print_common_statistics (FILE *stream ATTRIBUTE_UNUSED,
+                            ggc_statistics *stats)
 {
 {
-  struct ggc_root *x, **p;
+  /* Set the pointer so that during collection we will actually gather
+     the statistics.  */
+  ggc_stats = stats;
 
 
-  p = &roots, x = roots;
-  while (x)
-    {
-      if (x->base == base)
-       {
-         *p = x->next;
-         free (x);
-         return;
-       }
-      p = &x->next;
-      x = x->next;
-    }
+  /* Then do one collection to fill in the statistics.  */
+  ggc_collect ();
+
+  /* At present, we don't really gather any interesting statistics.  */
 
 
-  abort();
+  /* Don't gather statistics any more.  */
+  ggc_stats = NULL;
 }
 }
+\f
+/* Functions for saving and restoring GCable memory to disk.  */
 
 
-/* Add a hash table to be scanned when all roots have been processed.  We
-   delete any entry in the table that has not been marked.  */
+static htab_t saving_htab;
 
 
-struct d_htab_root
+struct ptr_data
 {
 {
-  struct d_htab_root *next;
-  htab_t htab;
-  ggc_htab_marked_p marked_p;
-  ggc_htab_mark mark;
+  void *obj;
+  void *note_ptr_cookie;
+  gt_note_pointers note_ptr_fn;
+  gt_handle_reorder reorder_fn;
+  size_t size;
+  void *new_addr;
+  enum gt_types_enum type;
 };
 
 };
 
-static struct d_htab_root *d_htab_roots;
+#define POINTER_HASH(x) (hashval_t)((long)x >> 3)
 
 
-/* Add X, an htab, to a list of htabs that contain objects which are allocated
-   from GC memory.  Once all other roots are marked, we check each object in
-   the htab to see if it has already been marked.  If not, it is deleted.
+/* Register an object in the hash table.  */
 
 
-   MARKED_P, if specified, is a function that returns 1 if the entry is to
-   be considered as "marked".  If not present, the data structure pointed to
-   by the htab slot is tested.  This function should be supplied if some
-   other object (such as something pointed to by that object) should be tested
-   in which case the function tests whether that object (or objects) are
-   marked (using ggc_marked_p) and returns nonzero if it is.
+int
+gt_pch_note_object (void *obj, void *note_ptr_cookie,
+                   gt_note_pointers note_ptr_fn,
+                   enum gt_types_enum type)
+{
+  struct ptr_data **slot;
 
 
-   MARK, if specified, is a function that is passed the contents of a slot
-   that has been determined to have been "marked" (via the above function)
-   and marks any other objects pointed to by that object.  For example,
-   we might have a hash table of memory attribute blocks, which are pointed
-   to by a MEM RTL but have a pointer to a DECL.  MARKED_P in that case will
-   not be specified because we want to know if the attribute block is pointed
-   to by the MEM, but MARK must be specified because if the block has been
-   marked, we need to mark the DECL.  */
+  if (obj == NULL || obj == (void *) 1)
+    return 0;
+
+  slot = (struct ptr_data **)
+    htab_find_slot_with_hash (saving_htab, obj, POINTER_HASH (obj),
+                             INSERT);
+  if (*slot != NULL)
+    {
+      gcc_assert ((*slot)->note_ptr_fn == note_ptr_fn
+                 && (*slot)->note_ptr_cookie == note_ptr_cookie);
+      return 0;
+    }
+
+  *slot = XCNEW (struct ptr_data);
+  (*slot)->obj = obj;
+  (*slot)->note_ptr_fn = note_ptr_fn;
+  (*slot)->note_ptr_cookie = note_ptr_cookie;
+  if (note_ptr_fn == gt_pch_p_S)
+    (*slot)->size = strlen ((const char *)obj) + 1;
+  else
+    (*slot)->size = ggc_get_size (obj);
+  (*slot)->type = type;
+  return 1;
+}
+
+/* Register an object in the hash table.  */
 
 void
 
 void
-ggc_add_deletable_htab (x, marked_p, mark)
-     PTR x;
-     ggc_htab_marked_p marked_p;
-     ggc_htab_mark mark;
+gt_pch_note_reorder (void *obj, void *note_ptr_cookie,
+                    gt_handle_reorder reorder_fn)
 {
 {
-  struct d_htab_root *r
-    = (struct d_htab_root *) xmalloc (sizeof (struct d_htab_root));
+  struct ptr_data *data;
+
+  if (obj == NULL || obj == (void *) 1)
+    return;
+
+  data = (struct ptr_data *)
+    htab_find_with_hash (saving_htab, obj, POINTER_HASH (obj));
+  gcc_assert (data && data->note_ptr_cookie == note_ptr_cookie);
 
 
-  r->next = d_htab_roots;
-  r->htab = (htab_t) x;
-  r->marked_p = marked_p ? marked_p : ggc_marked_p;
-  r->mark = mark;
-  d_htab_roots = r;
+  data->reorder_fn = reorder_fn;
 }
 
 }
 
-/* Process a slot of an htab by deleting it if it has not been marked.  */
+/* Hash and equality functions for saving_htab, callbacks for htab_create.  */
 
 
-static int
-ggc_htab_delete (slot, info)
-     void **slot;
-     void *info;
+static hashval_t
+saving_htab_hash (const void *p)
 {
 {
-  struct d_htab_root *r = (struct d_htab_root *) info;
-
-  if (! (*r->marked_p) (*slot))
-    htab_clear_slot (r->htab, slot);
-  else if (r->mark)
-    (*r->mark) (*slot);
+  return POINTER_HASH (((const struct ptr_data *)p)->obj);
+}
 
 
-  return 1;
+static int
+saving_htab_eq (const void *p1, const void *p2)
+{
+  return ((const struct ptr_data *)p1)->obj == p2;
 }
 
 }
 
-/* Iterate through all registered roots and mark each element.  */
+/* Handy state for the traversal functions.  */
 
 
-void
-ggc_mark_roots ()
+struct traversal_state
 {
 {
-  struct ggc_root *x;
-  struct d_htab_root *y;
-  
-  VARRAY_TREE_INIT (ggc_pending_trees, 4096, "ggc_pending_trees");
+  FILE *f;
+  struct ggc_pch_data *d;
+  size_t count;
+  struct ptr_data **ptrs;
+  size_t ptrs_i;
+};
 
 
-  for (x = roots; x != NULL; x = x->next)
-    {
-      char *elt = x->base;
-      int s = x->size, n = x->nelt;
-      void (*cb) PARAMS ((void *)) = x->cb;
-      int i;
+/* Callbacks for htab_traverse.  */
 
 
-      for (i = 0; i < n; ++i, elt += s)
-       (*cb)(elt);
-    }
+static int
+call_count (void **slot, void *state_p)
+{
+  struct ptr_data *d = (struct ptr_data *)*slot;
+  struct traversal_state *state = (struct traversal_state *)state_p;
 
 
-  /* Mark all the queued up trees, and their children.  */
-  ggc_mark_trees ();
-  VARRAY_FREE (ggc_pending_trees);
+  ggc_pch_count_object (state->d, d->obj, d->size,
+                       d->note_ptr_fn == gt_pch_p_S,
+                       d->type);
+  state->count++;
+  return 1;
+}
 
 
-  /* Now scan all hash tables that have objects which are to be deleted if
-     they are not already marked.  Since these may mark more trees, we need
-     to reinitialize that varray.  */
-  VARRAY_TREE_INIT (ggc_pending_trees, 1024, "ggc_pending_trees");
+static int
+call_alloc (void **slot, void *state_p)
+{
+  struct ptr_data *d = (struct ptr_data *)*slot;
+  struct traversal_state *state = (struct traversal_state *)state_p;
 
 
-  for (y = d_htab_roots; y != NULL; y = y->next)
-    htab_traverse (y->htab, ggc_htab_delete, (PTR) y);
-  ggc_mark_trees ();
-  VARRAY_FREE (ggc_pending_trees);
+  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;
 }
 
 }
 
-/* R had not been previously marked, but has now been marked via
-   ggc_set_mark.  Now recurse and process the children.  */
+/* Callback for qsort.  */
 
 
-void
-ggc_mark_rtx_children (r)
-     rtx r;
+static int
+compare_ptr_data (const void *p1_p, const void *p2_p)
 {
 {
-  const char *fmt;
-  int i;
-  rtx next_rtx;
+  const struct ptr_data *const p1 = *(const struct ptr_data *const *)p1_p;
+  const struct ptr_data *const p2 = *(const struct ptr_data *const *)p2_p;
+  return (((size_t)p1->new_addr > (size_t)p2->new_addr)
+         - ((size_t)p1->new_addr < (size_t)p2->new_addr));
+}
 
 
-  do 
-    {
-      enum rtx_code code = GET_CODE (r);
-      /* This gets set to a child rtx to eliminate tail recursion.  */
-      next_rtx = NULL;
+/* Callbacks for note_ptr_fn.  */
 
 
-      /* Collect statistics, if appropriate.  */
-      if (ggc_stats)
-       {
-         ++ggc_stats->num_rtxs[(int) code];
-         ggc_stats->size_rtxs[(int) code] += ggc_get_size (r);
-       }
+static void
+relocate_ptrs (void *ptr_p, void *state_p)
+{
+  void **ptr = (void **)ptr_p;
+  struct traversal_state *state ATTRIBUTE_UNUSED
+    = (struct traversal_state *)state_p;
+  struct ptr_data *result;
+
+  if (*ptr == NULL || *ptr == (void *)1)
+    return;
+
+  result = (struct ptr_data *)
+    htab_find_with_hash (saving_htab, *ptr, POINTER_HASH (*ptr));
+  gcc_assert (result);
+  *ptr = result->new_addr;
+}
 
 
-      /* ??? If (some of) these are really pass-dependent info, do we
-        have any right poking our noses in?  */
-      switch (code)
+/* Write out, after relocation, the pointers in TAB.  */
+static void
+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;
+  size_t i;
+
+  for (rt = tab; *rt; rt++)
+    for (rti = *rt; rti->base != NULL; rti++)
+      for (i = 0; i < rti->nelt; i++)
        {
        {
-       case MEM:
-         ggc_mark (MEM_ATTRS (r));
-         break;
-       case JUMP_INSN:
-         ggc_mark_rtx (JUMP_LABEL (r));
-         break;
-       case CODE_LABEL:
-         ggc_mark_rtx (LABEL_REFS (r));
-         break;
-       case LABEL_REF:
-         ggc_mark_rtx (LABEL_NEXTREF (r));
-         ggc_mark_rtx (CONTAINING_INSN (r));
-         break;
-       case ADDRESSOF:
-         ggc_mark_tree (ADDRESSOF_DECL (r));
-         break;
-       case CONST_DOUBLE:
-         ggc_mark_rtx (CONST_DOUBLE_CHAIN (r));
-         break;
-       case NOTE:
-         switch (NOTE_LINE_NUMBER (r))
+         void *ptr = *(void **)((char *)rti->base + rti->stride * i);
+         struct ptr_data *new_ptr;
+         if (ptr == NULL || ptr == (void *)1)
            {
            {
-           case NOTE_INSN_RANGE_BEG:
-           case NOTE_INSN_RANGE_END:
-           case NOTE_INSN_LIVE:
-           case NOTE_INSN_EXPECTED_VALUE:
-             ggc_mark_rtx (NOTE_RANGE_INFO (r));
-             break;
-
-           case NOTE_INSN_BLOCK_BEG:
-           case NOTE_INSN_BLOCK_END:
-             ggc_mark_tree (NOTE_BLOCK (r));
-             break;
-
-           default:
-             break;
+             if (fwrite (&ptr, sizeof (void *), 1, state->f)
+                 != 1)
+               fatal_error ("can't write PCH file: %m");
+           }
+         else
+           {
+             new_ptr = (struct ptr_data *)
+               htab_find_with_hash (saving_htab, ptr, POINTER_HASH (ptr));
+             if (fwrite (&new_ptr->new_addr, sizeof (void *), 1, state->f)
+                 != 1)
+               fatal_error ("can't write PCH file: %m");
            }
            }
-         break;
-
-       default:
-         break;
        }
        }
+}
+
+/* Hold the information we need to mmap the file back in.  */
+
+struct mmap_info
+{
+  size_t offset;
+  size_t size;
+  void *preferred_base;
+};
 
 
-      for (fmt = GET_RTX_FORMAT (GET_CODE (r)), i = 0; *fmt ; ++fmt, ++i)
+/* Write out the state of the compiler to F.  */
+
+void
+gt_pch_save (FILE *f)
+{
+  const struct ggc_root_tab *const *rt;
+  const struct ggc_root_tab *rti;
+  size_t i;
+  struct traversal_state state;
+  char *this_object = NULL;
+  size_t this_object_size = 0;
+  struct mmap_info mmi;
+  const size_t mmap_offset_alignment = host_hooks.gt_pch_alloc_granularity();
+
+  gt_pch_save_stringpool ();
+
+  timevar_push (TV_PCH_PTR_REALLOC);
+  saving_htab = htab_create (50000, saving_htab_hash, saving_htab_eq, free);
+
+  for (rt = gt_ggc_rtab; *rt; rt++)
+    for (rti = *rt; rti->base != NULL; rti++)
+      for (i = 0; i < rti->nelt; i++)
+       (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
+
+  for (rt = gt_pch_cache_rtab; *rt; rt++)
+    for (rti = *rt; rti->base != NULL; rti++)
+      for (i = 0; i < rti->nelt; i++)
+       (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
+
+  /* Prepare the objects for writing, determine addresses and such.  */
+  state.f = f;
+  state.d = init_ggc_pch();
+  state.count = 0;
+  htab_traverse (saving_htab, call_count, &state);
+
+  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.
+     (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 = XNEWVEC (struct ptr_data *, state.count);
+  state.ptrs_i = 0;
+
+  htab_traverse (saving_htab, call_alloc, &state);
+  timevar_pop (TV_PCH_PTR_REALLOC);
+
+  timevar_push (TV_PCH_PTR_SORT);
+  qsort (state.ptrs, state.count, sizeof (*state.ptrs), compare_ptr_data);
+  timevar_pop (TV_PCH_PTR_SORT);
+
+  /* Write out all the scalar variables.  */
+  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_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);
+
+  /* Pad the PCH file so that the mmapped area starts on an allocation
+     granularity (usually page) boundary.  */
+  {
+    long o;
+    o = ftell (state.f) + sizeof (mmi);
+    if (o == -1)
+      fatal_error ("can't get position in PCH file: %m");
+    mmi.offset = mmap_offset_alignment - o % mmap_offset_alignment;
+    if (mmi.offset == mmap_offset_alignment)
+      mmi.offset = 0;
+    mmi.offset += o;
+  }
+  if (fwrite (&mmi, sizeof (mmi), 1, state.f) != 1)
+    fatal_error ("can't write PCH file: %m");
+  if (mmi.offset != 0
+      && 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++)
+    {
+      if (this_object_size < state.ptrs[i]->size)
        {
        {
-         rtx exp;
-         switch (*fmt)
-           {
-           case 'e': case 'u':
-             exp = XEXP (r, i);
-             if (ggc_test_and_set_mark (exp))
-               { 
-                 if (next_rtx == NULL) 
-                   next_rtx = exp; 
-                 else 
-                   ggc_mark_rtx_children (exp);
-               } 
-             break;
-           case 'V': case 'E':
-             ggc_mark_rtvec (XVEC (r, i));
-             break;
-           }
+         this_object_size = state.ptrs[i]->size;
+         this_object = XRESIZEVAR (char, this_object, this_object_size);
        }
        }
+      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]->note_ptr_cookie,
+                                  relocate_ptrs, &state);
+      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]->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);
     }
     }
-  while ((r = next_rtx) != NULL);
+  ggc_pch_finish (state.d, state.f);
+  gt_pch_fixup_stringpool ();
+
+  free (state.ptrs);
+  htab_delete (saving_htab);
 }
 
 }
 
-/* V had not been previously marked, but has now been marked via
-   ggc_set_mark.  Now recurse and process the children.  */
+/* Read the state of the compiler back in from F.  */
 
 void
 
 void
-ggc_mark_rtvec_children (v)
-     rtvec v;
+gt_pch_restore (FILE *f)
 {
 {
-  int i;
+  const struct ggc_root_tab *const *rt;
+  const struct ggc_root_tab *rti;
+  size_t i;
+  struct mmap_info mmi;
+  int result;
+
+  /* Delete any deletable objects.  This makes ggc_pch_read much
+     faster, as it can be sure that no GCable objects remain other
+     than the ones just read in.  */
+  for (rt = gt_ggc_deletable_rtab; *rt; rt++)
+    for (rti = *rt; rti->base != NULL; rti++)
+      memset (rti->base, 0, rti->stride);
+
+  /* Read in all the scalar variables.  */
+  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_error ("can't read PCH file: %m");
+
+  /* Read in all the global pointers, in 6 easy loops.  */
+  for (rt = gt_ggc_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_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_error ("can't read PCH file: %m");
+
+  if (fread (&mmi, sizeof (mmi), 1, f) != 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)
+    {
+      if (fseek (f, mmi.offset, SEEK_SET) != 0
+         || 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_error ("can't read PCH file: %m");
+
+  ggc_pch_read (f, mmi.preferred_base);
 
 
-  i = GET_NUM_ELEM (v);
-  while (--i >= 0)
-    ggc_mark_rtx (RTVEC_ELT (v, i));
+  gt_pch_restore_stringpool ();
 }
 
 }
 
-/* Recursively set marks on all of the children of the
-   GCC_PENDING_TREES.  */
+/* 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.  */
 
 
-static void
-ggc_mark_trees ()
+void *
+default_gt_pch_get_address (size_t size ATTRIBUTE_UNUSED,
+                           int fd ATTRIBUTE_UNUSED)
 {
 {
-  while (ggc_pending_trees->elements_used)
-    {
-      tree t;
-      enum tree_code code;
+  return NULL;
+}
 
 
-      t = VARRAY_TOP_TREE (ggc_pending_trees);
-      VARRAY_POP (ggc_pending_trees);
-      code = TREE_CODE (t);
+/* 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.  */
 
 
-      /* Collect statistics, if appropriate.  */
-      if (ggc_stats)
-       {
-         ++ggc_stats->num_trees[(int) code];
-         ggc_stats->size_trees[(int) code] += ggc_get_size (t);
-       }
+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;
+}
 
 
-      /* Bits from common.  */
-      ggc_mark_tree (TREE_TYPE (t));
-      ggc_mark_tree (TREE_CHAIN (t));
+/* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS.   Return the
+   alignment required for allocating virtual memory. Usually this is the
+   same as pagesize.  */
 
 
-      /* Some nodes require special handling.  */
-      switch (code)
-       {
-       case TREE_LIST:
-         ggc_mark_tree (TREE_PURPOSE (t));
-         ggc_mark_tree (TREE_VALUE (t));
-         continue;
-
-       case TREE_VEC:
-         {
-           int i = TREE_VEC_LENGTH (t);
-
-           while (--i >= 0)
-             ggc_mark_tree (TREE_VEC_ELT (t, i));
-           continue;
-         }
-
-       case COMPLEX_CST:
-         ggc_mark_tree (TREE_REALPART (t));
-         ggc_mark_tree (TREE_IMAGPART (t));
-         break;
-
-       case PARM_DECL:
-         ggc_mark_rtx (DECL_INCOMING_RTL (t));
-         break;
-
-       case FIELD_DECL:
-         ggc_mark_tree (DECL_FIELD_BIT_OFFSET (t));
-         break;
-
-       case IDENTIFIER_NODE:
-         lang_mark_tree (t);
-         continue;
-
-       default:
-         break;
-       }
-  
-      /* But in general we can handle them by class.  */
-      switch (TREE_CODE_CLASS (code))
-       {
-       case 'd': /* A decl node.  */
-         ggc_mark_tree (DECL_SIZE (t));
-         ggc_mark_tree (DECL_SIZE_UNIT (t));
-         ggc_mark_tree (DECL_NAME (t));
-         ggc_mark_tree (DECL_CONTEXT (t));
-         ggc_mark_tree (DECL_ARGUMENTS (t));
-         ggc_mark_tree (DECL_RESULT_FLD (t));
-         ggc_mark_tree (DECL_INITIAL (t));
-         ggc_mark_tree (DECL_ABSTRACT_ORIGIN (t));
-         ggc_mark_tree (DECL_SECTION_NAME (t));
-         ggc_mark_tree (DECL_ATTRIBUTES (t));
-         if (DECL_RTL_SET_P (t))
-           ggc_mark_rtx (DECL_RTL (t));
-         ggc_mark_rtx (DECL_LIVE_RANGE_RTL (t));
-         ggc_mark_tree (DECL_VINDEX (t));
-         if (DECL_ASSEMBLER_NAME_SET_P (t))
-           ggc_mark_tree (DECL_ASSEMBLER_NAME (t));
-         if (TREE_CODE (t) == FUNCTION_DECL && DECL_SAVED_INSNS (t))
-           ggc_mark_struct_function (DECL_SAVED_INSNS (t));
-         lang_mark_tree (t);
-         break;
-
-       case 't': /* A type node.  */
-         ggc_mark_tree (TYPE_SIZE (t));
-         ggc_mark_tree (TYPE_SIZE_UNIT (t));
-         ggc_mark_tree (TYPE_ATTRIBUTES (t));
-         ggc_mark_tree (TYPE_VALUES (t));
-         ggc_mark_tree (TYPE_POINTER_TO (t));
-         ggc_mark_tree (TYPE_REFERENCE_TO (t));
-         ggc_mark_tree (TYPE_NAME (t));
-         ggc_mark_tree (TYPE_MIN_VALUE (t));
-         ggc_mark_tree (TYPE_MAX_VALUE (t));
-         ggc_mark_tree (TYPE_NEXT_VARIANT (t));
-         ggc_mark_tree (TYPE_MAIN_VARIANT (t));
-         ggc_mark_tree (TYPE_BINFO (t));
-         ggc_mark_tree (TYPE_CONTEXT (t));
-         lang_mark_tree (t);
-         break;
-
-       case 'b': /* A lexical block.  */
-         ggc_mark_tree (BLOCK_VARS (t));
-         ggc_mark_tree (BLOCK_SUBBLOCKS (t));
-         ggc_mark_tree (BLOCK_SUPERCONTEXT (t));
-         ggc_mark_tree (BLOCK_ABSTRACT_ORIGIN (t));
-         break;
-
-       case 'c': /* A constant.  */
-         ggc_mark_rtx (TREE_CST_RTL (t));
-         break;
-
-       case 'r': case '<': case '1':
-       case '2': case 'e': case 's': /* Expressions.  */
-         {
-           int i = TREE_CODE_LENGTH (TREE_CODE (t));
-           int first_rtl = first_rtl_op (TREE_CODE (t));
-
-           while (--i >= 0)
-             {
-               if (i >= first_rtl)
-                 ggc_mark_rtx ((rtx) TREE_OPERAND (t, i));
-               else
-                 ggc_mark_tree (TREE_OPERAND (t, i));
-             }
-           break;      
-         }
-
-       case 'x':
-         lang_mark_tree (t);
-         break;
-       }
-    }
+size_t
+default_gt_pch_alloc_granularity (void)
+{
+  return getpagesize();
 }
 
 }
 
-/* Mark all the elements of the varray V, which contains rtxs.  */
+#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
-ggc_mark_rtx_varray (v)
-     varray_type v;
+void *
+mmap_gt_pch_get_address (size_t size, int fd)
 {
 {
-  int i;
+  void *ret;
+
+  ret = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
+  if (ret == (void *) MAP_FAILED)
+    ret = NULL;
+  else
+    munmap ((caddr_t) ret, size);
 
 
-  if (v)
-    for (i = v->num_elements - 1; i >= 0; --i) 
-      ggc_mark_rtx (VARRAY_RTX (v, i));
+  return ret;
 }
 
 }
 
-/* Mark all the elements of the varray V, which contains trees.  */
+/* 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.
 
 
-void
-ggc_mark_tree_varray (v)
-     varray_type v;
+   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)
 {
 {
-  int i;
+  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;
 
 
-  if (v)
-    for (i = v->num_elements - 1; i >= 0; --i) 
-      ggc_mark_tree (VARRAY_TREE (v, i));
+  addr = mmap ((caddr_t) base, size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
+              fd, offset);
+
+  return addr == base ? 1 : -1;
 }
 }
+#endif /* HAVE_MMAP_FILE */
 
 
-/* Mark the hash table-entry HE.  Its key field is really a tree.  */
+/* Modify the bound based on rlimits.  */
+static double
+ggc_rlimit_bound (double limit)
+{
+#if defined(HAVE_GETRLIMIT)
+  struct rlimit rlim;
+# if defined (RLIMIT_AS)
+  /* 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.  */
+  if (getrlimit (RLIMIT_AS, &rlim) == 0
+      && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
+      && rlim.rlim_cur < limit)
+    limit = rlim.rlim_cur;
+# elif defined (RLIMIT_DATA)
+  /* ... 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
+     mmap at all, apparently.)  */
+  if (getrlimit (RLIMIT_DATA, &rlim) == 0
+      && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
+      && rlim.rlim_cur < limit
+      /* Darwin has this horribly bogus default setting of
+        RLIMIT_DATA, to 6144Kb.  No-one notices because RLIMIT_DATA
+        appears to be ignored.  Ignore such silliness.  If a limit
+        this small was actually effective for mmap, GCC wouldn't even
+        start up.  */
+      && rlim.rlim_cur >= 8 * 1024 * 1024)
+    limit = rlim.rlim_cur;
+# endif /* RLIMIT_AS or RLIMIT_DATA */
+#endif /* HAVE_GETRLIMIT */
+
+  return limit;
+}
 
 
-static bool
-ggc_mark_tree_hash_table_entry (he, k)
-     struct hash_entry *he;
-     hash_table_key k ATTRIBUTE_UNUSED;
+/* Heuristic to set a default for GGC_MIN_EXPAND.  */
+int
+ggc_min_expand_heuristic (void)
 {
 {
-  ggc_mark_tree ((tree) he->key);
-  return true;
+  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;
+  min_expand *= 70;
+  min_expand = MIN (min_expand, 70);
+  min_expand += 30;
+
+  return min_expand;
 }
 
 }
 
-/* Mark all the elements of the hash-table H, which contains trees.  */
+/* Heuristic to set a default for GGC_MIN_HEAPSIZE.  */
+int
+ggc_min_heapsize_heuristic (void)
+{
+  double phys_kbytes = physmem_total();
+  double limit_kbytes = ggc_rlimit_bound (phys_kbytes * 2);
+
+  phys_kbytes /= 1024; /* Convert to Kbytes.  */
+  limit_kbytes /= 1024;
+
+  /* The heuristic is RAM/8, with a lower bound of 4M and an upper
+     bound of 128M (when RAM >= 1GB).  */
+  phys_kbytes /= 8;
+
+#if defined(HAVE_GETRLIMIT) && defined (RLIMIT_RSS)
+  /* Try not to overrun the RSS limit while doing garbage collection.
+     The RSS limit is only advisory, so no margin is subtracted.  */
+ {
+   struct rlimit rlim;
+   if (getrlimit (RLIMIT_RSS, &rlim) == 0
+       && rlim.rlim_cur != (rlim_t) RLIM_INFINITY)
+     phys_kbytes = MIN (phys_kbytes, rlim.rlim_cur / 1024);
+ }
+# endif
+
+  /* Don't blindly run over our data limit; do GC at least when the
+     *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);
+
+  phys_kbytes = MAX (phys_kbytes, 4 * 1024);
+  phys_kbytes = MIN (phys_kbytes, 128 * 1024);
+
+  return phys_kbytes;
+}
 
 void
 
 void
-ggc_mark_tree_hash_table (ht)
-     struct hash_table *ht;
+init_ggc_heuristics (void)
 {
 {
-  hash_traverse (ht, ggc_mark_tree_hash_table_entry, /*info=*/0);
+#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
 }
 
 }
 
-/* Type-correct function to pass to ggc_add_root.  It just forwards
-   *ELT (which is an rtx) to ggc_mark_rtx.  */
+#ifdef GATHER_STATISTICS
 
 
-static void
-ggc_mark_rtx_ptr (elt)
-     void *elt;
+/* 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;
+  size_t freed;
+  size_t collected;
+};
+
+/* Hashtable used for statistics.  */
+static htab_t loc_hash;
+
+/* Hash table helpers functions.  */
+static hashval_t
+hash_descriptor (const void *p)
 {
 {
-  ggc_mark_rtx (*(rtx *) elt);
+  const struct loc_descriptor *const d = (const struct loc_descriptor *) p;
+
+  return htab_hash_pointer (d->function) | d->line;
 }
 
 }
 
-/* Type-correct function to pass to ggc_add_root.  It just forwards
-   *ELT (which is a tree) to ggc_mark_tree.  */
+static int
+eq_descriptor (const void *p1, const void *p2)
+{
+  const struct loc_descriptor *const d = (const struct loc_descriptor *) p1;
+  const struct loc_descriptor *const d2 = (const struct loc_descriptor *) p2;
 
 
-static void
-ggc_mark_tree_ptr (elt)
-     void *elt;
+  return (d->file == d2->file && d->line == d2->line
+         && d->function == d2->function);
+}
+
+/* Hashtable converting address of allocated field to loc descriptor.  */
+static htab_t ptr_hash;
+struct ptr_hash_entry
 {
 {
-  ggc_mark_tree (*(tree *) elt);
+  void *ptr;
+  struct loc_descriptor *loc;
+  size_t size;
+};
+
+/* Hash table helpers functions.  */
+static hashval_t
+hash_ptr (const void *p)
+{
+  const struct ptr_hash_entry *const d = (const struct ptr_hash_entry *) p;
+
+  return htab_hash_pointer (d->ptr);
 }
 
 }
 
-/* Type-correct function to pass to ggc_add_root.  It just forwards
-   ELT (which is really a varray_type *) to ggc_mark_rtx_varray.  */
+static int
+eq_ptr (const void *p1, const void *p2)
+{
+  const struct ptr_hash_entry *const p = (const struct ptr_hash_entry *) p1;
 
 
-static void
-ggc_mark_rtx_varray_ptr (elt)
-     void *elt;
+  return (p->ptr == p2);
+}
+
+/* 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)
 {
 {
-  ggc_mark_rtx_varray (*(varray_type *) elt);
+  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, INSERT);
+  if (*slot)
+    return *slot;
+  *slot = XCNEW (struct loc_descriptor);
+  (*slot)->file = name;
+  (*slot)->line = line;
+  (*slot)->function = function;
+  return *slot;
 }
 
 }
 
-/* Type-correct function to pass to ggc_add_root.  It just forwards
-   ELT (which is really a varray_type *) to ggc_mark_tree_varray.  */
+/* Record ALLOCATED and OVERHEAD bytes to descriptor NAME:LINE (FUNCTION).  */
+void
+ggc_record_overhead (size_t allocated, size_t overhead, void *ptr,
+                    const char *name, int line, const char *function)
+{
+  struct loc_descriptor *loc = loc_descriptor (name, line, function);
+  struct ptr_hash_entry *p = XNEW (struct ptr_hash_entry);
+  PTR *slot;
+
+  p->ptr = ptr;
+  p->loc = loc;
+  p->size = allocated + overhead;
+  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);
+  gcc_assert (!*slot);
+  *slot = p;
+
+  loc->times++;
+  loc->allocated+=allocated;
+  loc->overhead+=overhead;
+}
 
 
-static void
-ggc_mark_tree_varray_ptr (elt)
-     void *elt;
+/* Helper function for prune_overhead_list.  See if SLOT is still marked and
+   remove it from hashtable if it is not.  */
+static int
+ggc_prune_ptr (void **slot, void *b ATTRIBUTE_UNUSED)
 {
 {
-  ggc_mark_tree_varray (*(varray_type *) elt);
+  struct ptr_hash_entry *p = (struct ptr_hash_entry *) *slot;
+  if (!ggc_marked_p (p->ptr))
+    {
+      p->loc->collected += p->size;
+      htab_clear_slot (ptr_hash, slot);
+      free (p);
+    }
+  return 1;
 }
 
 }
 
-/* Type-correct function to pass to ggc_add_root.  It just forwards
-   ELT (which is really a struct hash_table **) to
-   ggc_mark_tree_hash_table.  */
+/* After live values has been marked, walk all recorded pointers and see if
+   they are still live.  */
+void
+ggc_prune_overhead_list (void)
+{
+  htab_traverse (ptr_hash, ggc_prune_ptr, NULL);
+}
 
 
-static void
-ggc_mark_tree_hash_table_ptr (elt)
-     void *elt;
+/* Notice that the pointer has been freed.  */
+void
+ggc_free_overhead (void *ptr)
 {
 {
-  ggc_mark_tree_hash_table (*(struct hash_table **) elt);
+  PTR *slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr),
+                                       NO_INSERT);
+  struct ptr_hash_entry *p = (struct ptr_hash_entry *) *slot;
+  p->loc->freed += p->size;
+  htab_clear_slot (ptr_hash, slot);
+  free (p);
 }
 
 }
 
-/* Allocate a block of memory, then clear it.  */
-void *
-ggc_alloc_cleared (size)
-     size_t size;
+/* Helper for qsort; sort descriptors by amount of memory consumed.  */
+static int
+final_cmp_statistic (const void *loc1, const void *loc2)
 {
 {
-  void *buf = ggc_alloc (size);
-  memset (buf, 0, size);
-  return buf;
+  const struct loc_descriptor *const l1 =
+    *(const struct loc_descriptor *const *) loc1;
+  const struct loc_descriptor *const l2 =
+    *(const struct loc_descriptor *const *) 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;
 }
 
 }
 
-/* Print statistics that are independent of the collector in use.  */
-#define SCALE(x) ((unsigned long) ((x) < 1024*10 \
-                 ? (x) \
-                 : ((x) < 1024*1024*10 \
-                    ? (x) / 1024 \
-                    : (x) / (1024*1024))))
-#define LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M'))
+/* Helper for qsort; sort descriptors by amount of memory consumed.  */
+static int
+cmp_statistic (const void *loc1, const void *loc2)
+{
+  const struct loc_descriptor *const l1 =
+    *(const struct loc_descriptor *const *) loc1;
+  const struct loc_descriptor *const l2 =
+    *(const struct loc_descriptor *const *) loc2;
+  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;
+}
 
 
-void
-ggc_print_common_statistics (stream, stats)
-     FILE *stream;
-     ggc_statistics *stats;
+/* Collect array of the descriptors from hashtable.  */
+static struct loc_descriptor **loc_array;
+static int
+add_statistics (void **slot, void *b)
 {
 {
-  int code;
+  int *n = (int *)b;
+  loc_array[*n] = (struct loc_descriptor *) *slot;
+  (*n)++;
+  return 1;
+}
 
 
-  /* Set the pointer so that during collection we will actually gather
-     the statistics.  */
-  ggc_stats = stats;
+/* Dump per-site memory statistics.  */
+#endif
+void
+dump_ggc_loc_statistics (bool final ATTRIBUTE_UNUSED)
+{
+#ifdef GATHER_STATISTICS
+  int nentries = 0;
+  char s[4096];
+  size_t collected = 0, freed = 0, allocated = 0, overhead = 0, times = 0;
+  int i;
 
 
-  /* Then do one collection to fill in the statistics.  */
+  ggc_force_collect = true;
   ggc_collect ();
 
   ggc_collect ();
 
-  /* Total the statistics.  */
-  for (code = 0; code < MAX_TREE_CODES; ++code)
+  loc_array = XCNEWVEC (struct loc_descriptor *, loc_hash->n_elements);
+  fprintf (stderr, "-------------------------------------------------------\n");
+  fprintf (stderr, "\n%-48s %10s       %10s       %10s       %10s       %10s\n",
+          "source location", "Garbage", "Freed", "Leak", "Overhead", "Times");
+  fprintf (stderr, "-------------------------------------------------------\n");
+  htab_traverse (loc_hash, add_statistics, &nentries);
+  qsort (loc_array, nentries, sizeof (*loc_array),
+        final ? final_cmp_statistic : cmp_statistic);
+  for (i = 0; i < nentries; i++)
     {
     {
-      stats->total_num_trees += stats->num_trees[code];
-      stats->total_size_trees += stats->size_trees[code];
+      struct loc_descriptor *d = loc_array[i];
+      allocated += d->allocated;
+      times += d->times;
+      freed += d->freed;
+      collected += d->collected;
+      overhead += d->overhead;
     }
     }
-  for (code = 0; code < NUM_RTX_CODE; ++code)
+  for (i = 0; i < nentries; i++)
     {
     {
-      stats->total_num_rtxs += stats->num_rtxs[code];
-      stats->total_size_rtxs += stats->size_rtxs[code];
+      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);
+         s[48] = 0;
+         fprintf (stderr, "%-48s %10li:%4.1f%% %10li:%4.1f%% %10li:%4.1f%% %10li:%4.1f%% %10li\n", s,
+                  (long)d->collected,
+                  (d->collected) * 100.0 / collected,
+                  (long)d->freed,
+                  (d->freed) * 100.0 / freed,
+                  (long)(d->allocated + d->overhead - d->freed - d->collected),
+                  (d->allocated + d->overhead - d->freed - d->collected) * 100.0
+                  / (allocated + overhead - freed - collected),
+                  (long)d->overhead,
+                  d->overhead * 100.0 / overhead,
+                  (long)d->times);
+       }
     }
     }
-
-  /* Print the statistics for trees.  */
-  fprintf (stream, "\n%-17s%10s %16s %10s\n", "Tree", 
-          "Number", "Bytes", "% Total");
-  for (code = 0; code < MAX_TREE_CODES; ++code)
-    if (ggc_stats->num_trees[code]) 
-      {
-       fprintf (stream, "%-17s%10u%16ld%c %10.3f\n",
-                tree_code_name[code],
-                ggc_stats->num_trees[code],
-                SCALE (ggc_stats->size_trees[code]),
-                LABEL (ggc_stats->size_trees[code]),
-                (100 * ((double) ggc_stats->size_trees[code]) 
-                 / ggc_stats->total_size_trees));
-      }
-  fprintf (stream,
-          "%-17s%10u%16ld%c\n", "Total",
-          ggc_stats->total_num_trees,
-          SCALE (ggc_stats->total_size_trees),
-          LABEL (ggc_stats->total_size_trees));
-
-  /* Print the statistics for RTL.  */
-  fprintf (stream, "\n%-17s%10s %16s %10s\n", "RTX", 
-          "Number", "Bytes", "% Total");
-  for (code = 0; code < NUM_RTX_CODE; ++code)
-    if (ggc_stats->num_rtxs[code]) 
-      {
-       fprintf (stream, "%-17s%10u%16ld%c %10.3f\n",
-                rtx_name[code],
-                ggc_stats->num_rtxs[code],
-                SCALE (ggc_stats->size_rtxs[code]),
-                LABEL (ggc_stats->size_rtxs[code]),
-                (100 * ((double) ggc_stats->size_rtxs[code]) 
-                 / ggc_stats->total_size_rtxs));
-      }
-  fprintf (stream,
-          "%-17s%10u%16ld%c\n", "Total",
-          ggc_stats->total_num_rtxs,
-          SCALE (ggc_stats->total_size_rtxs),
-          LABEL (ggc_stats->total_size_rtxs));
-
-  /* Don't gather statistics any more.  */
-  ggc_stats = NULL;
+  fprintf (stderr, "%-48s %10ld       %10ld       %10ld       %10ld       %10ld\n",
+          "Total", (long)collected, (long)freed,
+          (long)(allocated + overhead - freed - collected), (long)overhead,
+          (long)times);
+  fprintf (stderr, "%-48s %10s       %10s       %10s       %10s       %10s\n",
+          "source location", "Garbage", "Freed", "Leak", "Overhead", "Times");
+  fprintf (stderr, "-------------------------------------------------------\n");
+  ggc_force_collect = false;
+#endif
 }
 }
About OSDN
Find Software
Develop Software
Help