Alex Samuel <samuel@codesourcery.com>

        * ggc.h (rtvec_def): Forward declare.
        (tree_node): Likewise.
        (ggc_root): Define.
        (roots): Declare.
        (ggc_set_mark_rtx): Add prototype.
        (ggc_set_mark_rtvec): Likewise.
        (ggc_set_mark_tree): Likewise.
        * ggc-simple.c (ggc_root): Don't define.
        (roots): Don't declare.
        (ggc_mark_rtx): Remove.
        (ggc_mark_rtvec): Likewise.
        (ggc_mark_tree): Likewise.
        (ggc_mark_varray): Likewise.
        (ggc_mark_tree_hash_table_entry): Likewise.
        (ggc_mark_tree_hash_table): Likewise.
        (ggc_set_mart_rtx): New function.
        (ggc_set_mark_rtvec): Likewise.
        (ggc_set_mark_tree): Likewise.
        (ggc_add_root): Remove.
        (ggc_add_rtx_root): Likewise.
        (ggc_remove_tree_root): Likewise.
        (ggc_add_string_root): Likewise.
        (ggc_add_tree_varray_root): Likewise.
        (ggc_add_tree_hash_table_root): Likewise.
        (ggc_del_root): Likewise.
        (ggc_mark_rtx_ptr): Likewise.
        (ggc_mark_tree_ptr): Likewise.
        (ggc_mark_string_ptr): Likewise.
        (ggc_mark_tree_varray_ptr): Likewise.
        (ggc_mark_tree_hash_table_ptr): Likewise.
        * ggc-common.c: New file.
        * Makefile.in (OBJS): Add ggc-common.o.
        (ggc-common.o): List dependencies.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@29281 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 19 insertions, 389 deletions

diff --git a/gcc/ggc-simple.c b/gcc/ggc-simple.c
index d6e13cbf6f4..12120be3fd1 100644
--- a/gcc/ggc-simple.c
+++ b/gcc/ggc-simple.c
@@ -50,17 +50,6 @@
 
 /* Global lists of roots, rtxs, and trees.  */
 
-struct ggc_root
-{
-  struct ggc_root *next;
-  void *base;
-  int nelt;
-  int size;
-  void (*cb) PROTO ((void *));
-};
-
-static struct ggc_root *roots;
-
 struct ggc_rtx
 {
   struct ggc_rtx *chain;
@@ -137,14 +126,6 @@ static void ggc_free_tree PROTO ((struct ggc_tree *t));
 static void ggc_free_string PROTO ((struct ggc_string *s));
 static void ggc_free_any PROTO ((struct ggc_any *a));
 
-static void ggc_mark_rtx_ptr PROTO ((void *elt));
-static void ggc_mark_tree_ptr PROTO ((void *elt));
-static void ggc_mark_string_ptr PROTO ((void *elt));
-static void ggc_mark_tree_varray_ptr PROTO ((void *elt));
-static void ggc_mark_tree_hash_table_ptr PROTO ((void *elt));
-static boolean ggc_mark_tree_hash_table_entry PROTO ((struct hash_entry *,
-						      hash_table_key));
-
 /* Called once to initialize the garbage collector.  */
 
 void 
@@ -346,7 +327,7 @@ ggc_alloc (bytes)
 
 /* Freeing a bit of rtl is as simple as calling free.  */
 
-static inline void 
+static inline void
 ggc_free_rtx (r)
      struct ggc_rtx *r;
 {
@@ -430,252 +411,34 @@ ggc_free_any (a)
 
 /* Mark a node.  */
 
-void
-ggc_mark_rtx (r)
+int
+ggc_set_mark_rtx (r)
      rtx r;
 {
-  const char *fmt;
-  int i;
-
-  if (r == NULL_RTX || r->gc_mark)
-    return;
-  r->gc_mark = 1;
-
-  /* ??? If (some of) these are really pass-dependant info, do we have
-     any right poking our noses in?  */
-  switch (GET_CODE (r))
-    {
-    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))
-	{
-	case NOTE_INSN_RANGE_START:
-	case NOTE_INSN_RANGE_END:
-	case NOTE_INSN_LIVE:
-	  ggc_mark_rtx (NOTE_RANGE_INFO (r));
-	  break;
-
-	default:
-	  if (NOTE_LINE_NUMBER (r) >= 0)
-	    ggc_mark_string (NOTE_SOURCE_FILE (r));
-	  break;
-	}
-      break;
-
-    default:
-      break;
-    }
-
-  for (fmt = GET_RTX_FORMAT (GET_CODE (r)), i = 0; *fmt ; ++fmt, ++i)
-    {
-      switch (*fmt)
-	{
-	case 'e': case 'u':
-	  ggc_mark_rtx (XEXP (r, i));
-	  break;
-	case 'V': case 'E':
-	  ggc_mark_rtvec (XVEC (r, i));
-	  break;
-	case 'S': case 's':
-	  ggc_mark_string (XSTR (r, i));
-	  break;
-	}
-    }
+  int marked = r->gc_mark;
+  if (! marked)
+    r->gc_mark = 1;
+  return marked;
 }
 
-void
-ggc_mark_rtvec (v)
+int
+ggc_set_mark_rtvec (v)
      rtvec v;
 {
-  int i;
-
-  if (v == NULL || v->gc_mark)
-    return;
-  v->gc_mark = 1;
-
-  i = GET_NUM_ELEM (v);
-  while (--i >= 0)
-    ggc_mark_rtx (RTVEC_ELT (v, i));
+  int marked = v->gc_mark;
+  if (! marked)
+    v->gc_mark = 1;
+  return marked;
 }
 
-void
-ggc_mark_tree (t)
+int
+ggc_set_mark_tree (t)
      tree t;
 {
-  if (t == NULL_TREE || t->common.gc_mark)
-    return;
-  t->common.gc_mark = 1;
-
-  /* Bits from common.  */
-  ggc_mark_tree (TREE_TYPE (t));
-  ggc_mark_tree (TREE_CHAIN (t));
-
-  /* Some nodes require special handling.  */
-  switch (TREE_CODE (t))
-    {
-    case TREE_LIST:
-      ggc_mark_tree (TREE_PURPOSE (t));
-      ggc_mark_tree (TREE_VALUE (t));
-      return;
-
-    case TREE_VEC:
-      {
-	int i = TREE_VEC_LENGTH (t);
-	while (--i >= 0)
-	  ggc_mark_tree (TREE_VEC_ELT (t, i));
-	return;
-      }
-
-    case SAVE_EXPR:
-      ggc_mark_tree (TREE_OPERAND (t, 0));
-      ggc_mark_tree (SAVE_EXPR_CONTEXT (t));
-      ggc_mark_rtx (SAVE_EXPR_RTL (t));
-      return;
-
-    case RTL_EXPR:
-      ggc_mark_rtx (RTL_EXPR_SEQUENCE (t));
-      ggc_mark_rtx (RTL_EXPR_RTL (t));
-      return;
-
-    case CALL_EXPR:
-      ggc_mark_tree (TREE_OPERAND (t, 0));
-      ggc_mark_tree (TREE_OPERAND (t, 1));
-      ggc_mark_rtx (CALL_EXPR_RTL (t));
-      return;
-
-    case COMPLEX_CST:
-      ggc_mark_tree (TREE_REALPART (t));
-      ggc_mark_tree (TREE_IMAGPART (t));
-      break;
-
-    case STRING_CST:
-      ggc_mark_string (TREE_STRING_POINTER (t));
-      break;
-
-    case PARM_DECL:
-      ggc_mark_rtx (DECL_INCOMING_RTL (t));
-      break;
-
-    case IDENTIFIER_NODE:
-      ggc_mark_string (IDENTIFIER_POINTER (t));
-      lang_mark_tree (t);
-      return;
-
-    default:
-      break;
-    }
-  
-  /* But in general we can handle them by class.  */
-  switch (TREE_CODE_CLASS (TREE_CODE (t)))
-    {
-    case 'd': /* A decl node.  */
-      ggc_mark_tree (DECL_SIZE (t));
-      ggc_mark_tree (DECL_NAME (t));
-      ggc_mark_tree (DECL_CONTEXT (t));
-      ggc_mark_tree (DECL_ARGUMENTS (t));
-      ggc_mark_tree (DECL_RESULT (t));
-      ggc_mark_tree (DECL_INITIAL (t));
-      ggc_mark_tree (DECL_ABSTRACT_ORIGIN (t));
-      ggc_mark_tree (DECL_ASSEMBLER_NAME (t));
-      ggc_mark_tree (DECL_SECTION_NAME (t));
-      ggc_mark_tree (DECL_MACHINE_ATTRIBUTES (t));
-      ggc_mark_rtx (DECL_RTL (t));
-      ggc_mark_tree (DECL_VINDEX (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_NONCOPIED_PARTS (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_TYPE_TAGS (t));
-      ggc_mark_tree (BLOCK_SUBBLOCKS (t));
-      ggc_mark_tree (BLOCK_SUPERCONTEXT (t));
-      ggc_mark_tree (BLOCK_ABSTRACT_ORIGIN (t));
-      ggc_mark_rtx (BLOCK_END_NOTE (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)];
-	while (--i >= 0)
-	  ggc_mark_tree (TREE_OPERAND (t, i));
-	break;
-      }
-
-    case 'x':
-      lang_mark_tree (t);
-      break;
-    }
-}
-
-/* Mark all the elements of the varray V, which contains trees.  */
-
-void
-ggc_mark_tree_varray (v)
-     varray_type v;
-{
-  int i;
-
-  if (v)
-    for (i = v->num_elements - 1; i >= 0; --i) 
-      ggc_mark_tree (VARRAY_TREE (v, i));
-}
-
-/* Mark the hash table-entry HE.  It's key field is really a tree.  */
-
-static boolean
-ggc_mark_tree_hash_table_entry (he, k)
-     struct hash_entry *he;
-     hash_table_key k ATTRIBUTE_UNUSED;
-{
-  ggc_mark_tree ((tree) he->key);
-  return true;
-}
-
-/* Mark all the elements of the hash-table H, which contains trees.  */
-
-void
-ggc_mark_tree_hash_table (ht)
-     struct hash_table *ht;
-{
-  hash_traverse (ht, ggc_mark_tree_hash_table_entry, /*info=*/0);
+  int marked = t->common.gc_mark;
+  if (! marked)
+    t->common.gc_mark = 1;
+  return marked;
 }
 
 void
@@ -883,139 +646,6 @@ ggc_collect ()
     }
 }
 
-/* Manipulate global roots that are needed between calls to gc.  */
-
-void
-ggc_add_root (base, nelt, size, cb)
-     void *base;
-     int nelt, size;
-     void (*cb) PROTO ((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;
-
-  roots = x;
-}
-
-void
-ggc_add_rtx_root (base, nelt)
-     rtx *base;
-     int nelt;
-{
-  ggc_add_root (base, nelt, sizeof(rtx), ggc_mark_rtx_ptr);
-}
-
-void
-ggc_add_tree_root (base, nelt)
-     tree *base;
-     int nelt;
-{
-  ggc_add_root (base, nelt, sizeof(tree), ggc_mark_tree_ptr);
-}
-
-void
-ggc_add_string_root (base, nelt)
-     char **base;
-     int nelt;
-{
-  ggc_add_root (base, nelt, sizeof(char *), ggc_mark_string_ptr);
-}
-
-/* Add V (a varray full of trees) to the list of GC roots.  */
-
-void
-ggc_add_tree_varray_root (base, nelt)
-     varray_type *base;
-     int nelt;
-{
-  ggc_add_root (base, nelt, sizeof (varray_type), 
-		ggc_mark_tree_varray_ptr);
-}
-
-/* Add HT (a hash-table where ever key is a tree) to the list of GC
-   roots.  */
-
-void
-ggc_add_tree_hash_table_root (base, nelt)
-     struct hash_table **base;
-     int nelt;
-{
-  ggc_add_root (base, nelt, sizeof (struct hash_table *), 
-		ggc_mark_tree_hash_table_ptr);
-}
-
-void
-ggc_del_root (base)
-     void *base;
-{
-  struct ggc_root *x, **p;
-
-  p = &roots, x = roots;
-  while (x)
-    {
-      if (x->base == base)
-	{
-	  *p = x->next;
-	  free (x);
-	  return;
-	}
-      p = &x->next;
-      x = x->next;
-    }
-
-  abort();
-}
-
-static void
-ggc_mark_rtx_ptr (elt)
-     void *elt;
-{
-  ggc_mark_rtx (*(rtx *)elt);
-}
-
-static void
-ggc_mark_tree_ptr (elt)
-     void *elt;
-{
-  ggc_mark_tree (*(tree *)elt);
-}
-
-/* Type-correct function to pass to ggc_add_root.  It just forwards
-   ELT (which is really a char **) to ggc_mark_string.  */
-
-static void
-ggc_mark_string_ptr (elt)
-     void *elt;
-{
-  ggc_mark_string (*(char **)elt);
-}
-
-/* Type-correct function to pass to ggc_add_root.  It just forwards
-   ELT (which is really a varray_type *) to ggc_mark_tree_varray.  */
-
-static void
-ggc_mark_tree_varray_ptr (elt)
-     void *elt;
-{
-  ggc_mark_tree_varray (*(varray_type *)elt);
-}
-
-/* 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.  */
-
-static void
-ggc_mark_tree_hash_table_ptr (elt)
-     void *elt;
-{
-  ggc_mark_tree_hash_table (*(struct hash_table **) elt);
-}
-
 #if 0
 /* GDB really should have a memory search function.  Since this is just
    for initial debugging, I won't even pretend to get the __data_start