From 4519c0a872bb216f274a27151b56566f3e53a948 Mon Sep 17 00:00:00 2001 From: Mark Mitchell Date: Sat, 4 Sep 1999 19:03:28 +0000 Subject: [PATCH] Make-lang.in (cc1plus): Depend on $(GGC). * Make-lang.in (cc1plus): Depend on $(GGC). * Makefile.in (OBJS): Add ggc-simple.o. (OBJDEPS): Likewise. * cp-tree.h (language_function): Rename members to `x_' versions; we now have x_named_labels, x_ctor_label, x_dtor_label, x_base_init_list, x_member_init_list, x_base_init_expr, x_current_class_ptr, x_current_class_ref, x_last_tree, x_last_expr_type, x_last_dtor_insn, x_last_parm_cleanup_insn, and x_result_rtx. (dtor_label, ctor_label, current_base_init_list, current_member_init_list, base_init_expr, current_class_ptr, current_class_ref, last_tree, last_expr_type): Adjust accordingly. * decl.c: Include ggc.h. (last_dtor_insn): Adjust to use x_ names. (last_parm_cleanup_insn): Likewise. (original_result_rtx): Likewise. (named_labels): Likewise. (mark_binding_level): New function. (mark_cp_function_context): Likewise. (mark_false_label_stack): Likewise. (lang_mark_tree): Likewise. (lang_cleanup_tree): Likewise. From-SVN: r29107 --- gcc/cp/Make-lang.in | 5 +- gcc/cp/Makefile.in | 4 +- gcc/cp/cp-tree.h | 46 +++++++------- gcc/cp/decl.c | 144 ++++++++++++++++++++++++++++++++++++++++++-- 4 files changed, 168 insertions(+), 31 deletions(-) diff --git a/gcc/cp/Make-lang.in b/gcc/cp/Make-lang.in index 032285519a6..67c1219b421 100644 --- a/gcc/cp/Make-lang.in +++ b/gcc/cp/Make-lang.in @@ -120,8 +120,9 @@ CXX_SRCS = $(srcdir)/cp/call.c $(srcdir)/cp/decl2.c \ $(srcdir)/cp/repo.c $(srcdir)/cp/semantics.c \ $(srcdir)/cp/dump.c -cc1plus$(exeext): $(P) $(CXX_SRCS) $(LIBDEPS) stamp-objlist c-common.o c-pragma.o \ - $(srcdir)/cp/cp-tree.h $(srcdir)/cp/cp-tree.def $(srcdir)/cp/gxx.gperf hash.o +cc1plus$(exeext): $(P) $(CXX_SRCS) $(LIBDEPS) stamp-objlist c-common.o \ + c-pragma.o $(srcdir)/cp/cp-tree.h $(srcdir)/cp/cp-tree.def \ + $(srcdir)/cp/gxx.gperf hash.o $(GGC) cd cp; $(MAKE) $(FLAGS_TO_PASS) $(CXX_FLAGS_TO_PASS) ../cc1plus$(exeext) # # Build hooks: diff --git a/gcc/cp/Makefile.in b/gcc/cp/Makefile.in index d71938f293e..4cc047f1d61 100644 --- a/gcc/cp/Makefile.in +++ b/gcc/cp/Makefile.in @@ -178,8 +178,8 @@ CXX_OBJS = call.o decl.o errfn.o expr.o pt.o typeck2.o \ repo.o dump.o @extra_cxx_objs@ # Language-independent object files. -OBJS = `cat ../stamp-objlist` ../c-common.o ../c-pragma.o -OBJDEPS = ../stamp-objlist ../c-common.o ../c-pragma.o +OBJS = `cat ../stamp-objlist` ../c-common.o ../c-pragma.o ../ggc-simple.o +OBJDEPS = ../stamp-objlist ../c-common.o ../c-pragma.o ../ggc-simple.o compiler: ../cc1plus$(exeext) ../cc1plus$(exeext): $(P) $(OBJDEPS) $(CXX_OBJS) $(LIBDEPS) diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 52e1717134d..6d4cd851ddc 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -437,20 +437,20 @@ extern tree cp_global_trees[CPTI_MAX]; struct language_function { - tree named_labels; - tree ctor_label; - tree dtor_label; - tree base_init_list; - tree member_init_list; - tree base_init_expr; - tree current_class_ptr; - tree current_class_ref; - tree last_tree; - tree last_expr_type; - - struct rtx_def *last_dtor_insn; - struct rtx_def *last_parm_cleanup_insn; - struct rtx_def *result_rtx; + tree x_named_labels; + tree x_ctor_label; + tree x_dtor_label; + tree x_base_init_list; + tree x_member_init_list; + tree x_base_init_expr; + tree x_current_class_ptr; + tree x_current_class_ref; + tree x_last_tree; + tree x_last_expr_type; + + struct rtx_def *x_last_dtor_insn; + struct rtx_def *x_last_parm_cleanup_insn; + struct rtx_def *x_result_rtx; int returns_value; int returns_null; @@ -474,12 +474,12 @@ struct language_function /* In a destructor, the point at which all derived class destroying has been done, just before any base class destroying will be done. */ -#define dtor_label cp_function_chain->dtor_label +#define dtor_label cp_function_chain->x_dtor_label /* In a constructor, the point at which we are ready to return the pointer to the initialized object. */ -#define ctor_label cp_function_chain->ctor_label +#define ctor_label cp_function_chain->x_ctor_label /* In C++, structures with well-defined constructors are initialized by those constructors, unasked. CURRENT_BASE_INIT_LIST @@ -491,30 +491,30 @@ struct language_function where each successive term can be handed down the constructor line. Perhaps this was not intended. */ -#define current_base_init_list cp_function_chain->base_init_list -#define current_member_init_list cp_function_chain->member_init_list +#define current_base_init_list cp_function_chain->x_base_init_list +#define current_member_init_list cp_function_chain->x_member_init_list /* Sequence of insns which represents base initialization. */ -#define base_init_expr cp_function_chain->base_init_expr +#define base_init_expr cp_function_chain->x_base_init_expr /* When we're processing a member function, current_class_ptr is the PARM_DECL for the `this' pointer. The current_class_ref is an expression for `*this'. */ -#define current_class_ptr cp_function_chain->current_class_ptr -#define current_class_ref cp_function_chain->current_class_ref +#define current_class_ptr cp_function_chain->x_current_class_ptr +#define current_class_ref cp_function_chain->x_current_class_ref /* When building a statement-tree, this is the last node added to the tree. */ -#define last_tree cp_function_chain->last_tree +#define last_tree cp_function_chain->x_last_tree /* The type of the last expression-statement we have seen. This is required because the type of a statement-expression is the type of the last expression statement. */ -#define last_expr_type cp_function_chain->last_expr_type +#define last_expr_type cp_function_chain->x_last_expr_type /* Set to 0 at beginning of a function definition, set to 1 if a return statement that specifies a return value is seen. */ diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index 0c7a88e1ba1..bb1b8b9b66b 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -43,6 +43,7 @@ Boston, MA 02111-1307, USA. */ #include "toplev.h" #include "../hash.h" #include "defaults.h" +#include "ggc.h" #define obstack_chunk_alloc xmalloc #define obstack_chunk_free free @@ -198,6 +199,8 @@ static void check_initializer PROTO((tree, tree *)); static void make_rtl_for_nonlocal_decl PROTO((tree, tree, const char *)); static void push_cp_function_context PROTO((struct function *)); static void pop_cp_function_context PROTO((struct function *)); +static void mark_binding_level PROTO((void *)); +static void mark_cp_function_context PROTO((struct function *)); #if defined (DEBUG_CP_BINDING_LEVELS) static void indent PROTO((void)); @@ -302,21 +305,21 @@ static int only_namespace_names; /* In a destructor, the last insn emitted after the start of the function and the parms. */ -#define last_dtor_insn cp_function_chain->last_dtor_insn +#define last_dtor_insn cp_function_chain->x_last_dtor_insn /* In a constructor, the last insn emitted after the start of the function and the parms, the exception specification and any function-try-block. The constructor initializers are emitted after this insn. */ -#define last_parm_cleanup_insn cp_function_chain->last_parm_cleanup_insn +#define last_parm_cleanup_insn cp_function_chain->x_last_parm_cleanup_insn /* If original DECL_RESULT of current function was a register, but due to being an addressable named return value, would up on the stack, this variable holds the named return value's original location. */ -#define original_result_rtx cp_function_chain->result_rtx +#define original_result_rtx cp_function_chain->x_result_rtx /* C++: Keep these around to reduce calls to `get_identifier'. Identifiers for `this' in member functions and the auto-delete @@ -415,7 +418,7 @@ static tree current_function_parm_tags; at the end of the function. The TREE_VALUE is a LABEL_DECL; the TREE_PURPOSE is the previous binding of the label. */ -#define named_labels cp_function_chain->named_labels +#define named_labels cp_function_chain->x_named_labels /* The FUNCTION_DECL for the function currently being compiled, or 0 if between functions. */ @@ -1998,6 +2001,30 @@ wrapup_globals_for_namespace (namespace, data) return result; } + +static void +mark_binding_level (arg) + void *arg; +{ + struct binding_level *lvl = *(struct binding_level **)arg; + + while (lvl) + { + ggc_mark_tree (lvl->names); + ggc_mark_tree (lvl->tags); + ggc_mark_tree (lvl->usings); + ggc_mark_tree (lvl->using_directives); + ggc_mark_tree (lvl->class_shadowed); + ggc_mark_tree (lvl->type_shadowed); + ggc_mark_tree (lvl->shadowed_labels); + ggc_mark_tree (lvl->blocks); + ggc_mark_tree (lvl->this_block); + ggc_mark_tree (lvl->incomplete); + ggc_mark_tree (lvl->dead_vars_from_for); + + lvl = lvl->level_chain; + } +} /* For debugging. */ static int no_print_functions = 0; @@ -14537,8 +14564,117 @@ pop_cp_function_context (f) f->language = 0; } +void +mark_cp_function_context (f) + struct function *f; +{ + struct language_function *p = f->language; + + ggc_mark_tree (p->x_named_labels); + ggc_mark_tree (p->x_ctor_label); + ggc_mark_tree (p->x_dtor_label); + ggc_mark_tree (p->x_base_init_list); + ggc_mark_tree (p->x_member_init_list); + ggc_mark_tree (p->x_base_init_expr); + ggc_mark_tree (p->x_current_class_ptr); + ggc_mark_tree (p->x_current_class_ref); + ggc_mark_tree (p->x_last_tree); + ggc_mark_tree (p->x_last_expr_type); + + ggc_mark_rtx (p->x_last_dtor_insn); + ggc_mark_rtx (p->x_last_parm_cleanup_insn); + ggc_mark_rtx (p->x_result_rtx); + + mark_binding_level (&p->binding_level); +} + + int in_function_p () { return function_depth != 0; } + + +void +lang_mark_false_label_stack (arg) + void *arg; +{ + /* C++ doesn't use false_label_stack. It better be NULL. */ + if (*(void **)arg != NULL) + abort(); +} + +void +lang_mark_tree (t) + tree t; +{ + enum tree_code code = TREE_CODE (t); + if (code == IDENTIFIER_NODE) + { + struct lang_identifier *li = (struct lang_identifier *) t; + struct lang_id2 *li2 = li->x; + ggc_mark_tree (li->namespace_bindings); + ggc_mark_tree (li->class_value); + ggc_mark_tree (li->class_template_info); + + if (li2) + { + ggc_mark_tree (li2->label_value); + ggc_mark_tree (li2->implicit_decl); + ggc_mark_tree (li2->error_locus); + } + } + else if (TREE_CODE_CLASS (code) == 'd') + { + struct lang_decl *ld = DECL_LANG_SPECIFIC (t); + + if (ld) + { + ggc_mark_tree (ld->decl_flags.access); + ggc_mark_tree (ld->decl_flags.context); + if (TREE_CODE (t) != NAMESPACE_DECL) + ggc_mark_tree (ld->decl_flags.u.template_info); + if (CAN_HAVE_FULL_LANG_DECL_P (t)) + { + ggc_mark_tree (ld->main_decl_variant); + ggc_mark_tree (ld->befriending_classes); + ggc_mark_tree (ld->saved_tree); + if (TREE_CODE (t) == TYPE_DECL) + ggc_mark_tree (ld->u.sorted_fields); + } + } + } + else if (TREE_CODE_CLASS (code) == 't') + { + struct lang_type *lt = TYPE_LANG_SPECIFIC (t); + + if (lt) + { + ggc_mark_tree (lt->vfields); + ggc_mark_tree (lt->vbases); + ggc_mark_tree (lt->tags); + ggc_mark_tree (lt->search_slot); + ggc_mark_tree (lt->size); + ggc_mark_tree (lt->abstract_virtuals); + ggc_mark_tree (lt->friend_classes); + ggc_mark_tree (lt->rtti); + ggc_mark_tree (lt->methods); + ggc_mark_tree (lt->template_info); + } + } +} + +void +lang_cleanup_tree (t) + tree t; +{ + if (TREE_CODE_CLASS (TREE_CODE (t)) == 't' + && TYPE_LANG_SPECIFIC (t) != NULL) + { +#if 0 + /* This is currently allocated with an obstack. This will change. */ + free (TYPE_LANG_SPECIFIC (t)); +#endif + } +} -- 2.30.2