From b49a6a907c1e3e1cd0b80b0d7879b1709bdf81e7 Mon Sep 17 00:00:00 2001 From: Alex Samuel Date: Sat, 11 Sep 1999 19:48:37 +0000 Subject: [PATCH] Alex Samuel * 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. From-SVN: r29281 --- gcc/ChangeLog | 36 +++++ gcc/Makefile.in | 5 +- gcc/ggc-common.c | 417 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ gcc/ggc-simple.c | 408 +++-------------------------------------------------- gcc/ggc.h | 69 ++++++--- 5 files changed, 524 insertions(+), 411 deletions(-) create mode 100644 gcc/ggc-common.c diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 6b96962..16f2ca6 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,39 @@ +Sat Sep 11 12:41:55 1999 Alex Samuel + + * 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. + 1999-09-10 22:37 -0700 Zack Weinberg * cppalloc.c (xstrdup): Use memcpy. diff --git a/gcc/Makefile.in b/gcc/Makefile.in index a5a87ee..8e3623a 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -675,7 +675,7 @@ OBJS = toplev.o version.o tree.o print-tree.o stor-layout.o fold-const.o \ insn-opinit.o insn-recog.o insn-extract.o insn-output.o insn-emit.o lcm.o \ profile.o insn-attrtab.o $(out_object_file) $(EXTRA_OBJS) convert.o \ mbchar.o dyn-string.o splay-tree.o graph.o sbitmap.o resource.o hash.o \ - lists.o $(GGC) + lists.o ggc-common.o $(GGC) # GEN files are listed separately, so they can be built before doing parallel # makes for cc1 or cc1plus. Otherwise sequent parallel make attempts to load @@ -1445,6 +1445,9 @@ dumpvers: dumpvers.c version.o: version.c +ggc-common.o: ggc-common.c $(CONFIG_H) $(RTL_BASE_H) $(TREE_H) \ + flags.h ggc.h varray.h hash.h + ggc-simple.o: ggc-simple.c $(CONFIG_H) $(RTL_BASE_H) $(TREE_H) flags.h \ ggc.h varray.h hash.h diff --git a/gcc/ggc-common.c b/gcc/ggc-common.c new file mode 100644 index 0000000..7fc2068 --- /dev/null +++ b/gcc/ggc-common.c @@ -0,0 +1,417 @@ +/* Simple garbage collection for the GNU compiler. + Copyright (C) 1998 Free Software Foundation, Inc. + + This file is part of GNU CC. + + GNU CC 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 version. + + GNU CC is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or 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 + along with GNU CC; see the file COPYING. If not, write to + the Free Software Foundation, 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* Generic garbage collection (GC) functions and data, not specific to + any particular GC implementation. */ + +#include "config.h" +#include "system.h" +#include "ggc.h" +#include "hash.h" +#include "rtl.h" +#include "tree.h" +#include "varray.h" + + +/* Maintain global roots that are preserved during GC. */ + +struct ggc_root *roots; + +/* Type-correct function to pass to ggc_add_root. It just forwards + *ELT (which is an rtx) to ggc_mark_tree_varray. */ + +static void +ggc_mark_rtx_ptr (elt) + void *elt; +{ + ggc_mark_rtx (*(rtx *)elt); +} + +/* Type-correct function to pass to ggc_add_root. It just forwards + *ELT (which is a tree) to ggc_mark_tree. */ + +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 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); +} + +static void +ggc_mark_string_ptr (elt) + void *elt; +{ + ggc_mark_string (*(char **)elt); +} + +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); +} + +/* 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_add_string_root (base, nelt) + char **base; + int nelt; +{ + ggc_add_root (base, nelt, sizeof (char *), ggc_mark_string_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(); +} + +void +ggc_mark_rtx (r) + rtx r; +{ + const char *fmt; + int i; + + if (r == NULL_RTX || ggc_set_mark_rtx (r)) + return; + + /* ??? 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; + } + } +} + +void +ggc_mark_rtvec (v) + rtvec v; +{ + int i; + + if (v == NULL || ggc_set_mark_rtvec (v)) + return; + + i = GET_NUM_ELEM (v); + while (--i >= 0) + ggc_mark_rtx (RTVEC_ELT (v, i)); +} + +void +ggc_mark_tree (t) + tree t; +{ + /* FIXME what if t == NULL_TREE ? */ + if (t == NULL || ggc_set_mark_tree (t)) + return; + + /* 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); +} + diff --git a/gcc/ggc-simple.c b/gcc/ggc-simple.c index d6e13cb..12120be 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 diff --git a/gcc/ggc.h b/gcc/ggc.h index bd6fe2f..d7111d6 100644 --- a/gcc/ggc.h +++ b/gcc/ggc.h @@ -31,27 +31,63 @@ extern int ggc_p; compiler. However, rather than force everyone who includes this header to include all the headers in which they are declared, we just forward-declare them here. */ -struct label_node; struct eh_status; struct emit_status; +struct hash_table; +struct label_node; +struct rtvec_def; struct stmt_status; +union tree_node; struct varasm_status; struct varray_head_tag; -struct hash_table; -/* Startup */ +/* Global roots that are preserved during calls to gc. */ + +struct ggc_root +{ + struct ggc_root *next; + void *base; + int nelt; + int size; + void (*cb) PROTO ((void *)); +}; + +extern struct ggc_root *roots; + +/* Manipulate global roots that are needed between calls to gc. */ +void ggc_add_root PROTO ((void *base, int nelt, int size, void (*)(void *))); +void ggc_add_rtx_root PROTO ((struct rtx_def **, int nelt)); +void ggc_add_tree_root PROTO ((union tree_node **, int nelt)); +void ggc_add_string_root PROTO ((char **, int nelt)); +void ggc_add_tree_varray_root PROTO ((struct varray_head_tag **, int nelt)); +void ggc_add_tree_hash_table_root PROTO ((struct hash_table **, int nelt)); +void ggc_del_root PROTO ((void *base)); +/* Mark nodes from the gc_add_root callback. These functions follow + pointers to mark other objects too. */ +void ggc_mark_rtx PROTO ((struct rtx_def *)); +void ggc_mark_rtvec PROTO ((struct rtvec_def *)); +void ggc_mark_tree PROTO ((union tree_node *)); +void ggc_mark_tree_varray PROTO ((struct varray_head_tag *)); +void ggc_mark_tree_hash_table PROTO ((struct hash_table *)); +void ggc_mark_string PROTO ((char *)); +void ggc_mark PROTO ((void *)); + + +/* A GC implementation must provide these functions. */ + +/* Initialize the garbage collector. */ extern void init_ggc PROTO ((void)); /* Start a new GGC context. Memory allocated in previous contexts will not be collected while the new context is active. */ extern void ggc_pop_context PROTO ((void)); + /* Finish a GC context. Any uncollected memory in the new context will be merged with the old context. */ extern void ggc_push_context PROTO ((void)); /* Allocation. */ - struct rtx_def *ggc_alloc_rtx PROTO ((int nslots)); struct rtvec_def *ggc_alloc_rtvec PROTO ((int nelt)); union tree_node *ggc_alloc_tree PROTO ((int length)); @@ -60,26 +96,17 @@ void *ggc_alloc PROTO ((size_t)); /* Invoke the collector. This is really just a hint, but in the case of the simple collector, the only time it will happen. */ - void ggc_collect PROTO ((void)); -/* Manipulate global roots that are needed between calls to gc. */ -void ggc_add_root PROTO ((void *base, int nelt, int size, void (*)(void *))); -void ggc_add_rtx_root PROTO ((struct rtx_def **, int nelt)); -void ggc_add_tree_root PROTO ((union tree_node **, int nelt)); -void ggc_add_string_root PROTO ((char **, int nelt)); -void ggc_add_tree_varray_root PROTO ((struct varray_head_tag **, int nelt)); -void ggc_add_tree_hash_table_root PROTO ((struct hash_table **, int nelt)); -void ggc_del_root PROTO ((void *base)); +/* Actually set the mark on a particular region of memory, but don't + follow pointers. These functions are called by ggc_mark_*. They + return zero if the object was not previously marked; they return + non-zero if the object was already marked, or if, for any other + reason, pointers in this data structure should not be traversed. */ +int ggc_set_mark_rtx PROTO ((struct rtx_def *)); +int ggc_set_mark_rtvec PROTO ((struct rtvec_def *)); +int ggc_set_mark_tree PROTO ((union tree_node *)); -/* Mark nodes from the gc_add_root callback. */ -void ggc_mark_rtx PROTO ((struct rtx_def *)); -void ggc_mark_rtvec PROTO ((struct rtvec_def *)); -void ggc_mark_tree PROTO ((union tree_node *)); -void ggc_mark_tree_varray PROTO ((struct varray_head_tag *)); -void ggc_mark_tree_hash_table PROTO ((struct hash_table *)); -void ggc_mark_string PROTO ((char *)); -void ggc_mark PROTO ((void *)); /* Callbacks to the languages. */ -- 2.7.4