From d7c47c0ef0309b9b24b450072b3fbbebf52f7b5a Mon Sep 17 00:00:00 2001 From: mmitchel Date: Fri, 13 Oct 2000 06:26:46 +0000 Subject: Remove obstacks. * Makefile.in (ggc-callbacks.o): Remove target. (flow.o): Depend on GGC_H. * alias.c (init_alias_analysis): Remove ggc_p conditionals. (end_alias_analysis): Likewise. * basic-block.h (init_flow): New function. (allocate_reg_life_data): Declare. * bb-reorder.c (function_obstack): Replace with ... (flow_obstack): ... new variable. (fixup_reorder_chain): Use it. * c-decl.c (ggc_p): Remove. (caller-save.c): Don't call oballoc/obfree. * combine.c (struct undobuf): Remove storage. (try_combine): Don't call oballoc. (undo_all): Don't call obfree. * cse.c (insert): Use xmalloc, not oballoc. (cse_main): Adjust accordingly. * dwarf2out.c (save_rtx): Remove obstack code. (dwarf2out_init): Remove ggc_p conditionals. * emit-rtl.c (rtl_obstack): Remove. (gen_rtx_CONST_INT): Remove ggc_p conditionals. (make_insn_raw): Likewise. (emit_insn_before): Likewise. (emit_insn_after): Likewise. (emit_insn): Likewise. (gen_sequence): Likewise. (copy_insn_1): Remove handling of `b' RTL components. (init_emit_once): Remove ggc_p conditionals. * except.c (create_rethrow_ref): Don't fool with obstacks. (add_partial_entry): Likewise. (call_get_eh_context): Likewise. (begin_protect_partials): Likewise. (protect_with_terminate): Likewise. * explow.c (plus_constant_wide): Likewise. * expr.c (init_expr_once): Likewise. (emit_block_move): Likewise. (clear_storage): Likewise. (expand_expr): Likewise. * flow.c (function_obstack): Remove. (flow_obstack): New variable. (flow_firstobj): Likewise. (create_base_block): Use the flow_obstack. (split_block): Likewise. (split_edge): Likewise. (calculate_global_regs_live): Likewise. (allocate_bb_life_data): Make it static. Likewiwse. (init_flow): New function. (size_int_type_wide): Remove ggc_p conditionals. * function.c (push_function_context_to): Don't call save_tree_status. (pop_function_context_from): Or restore_tree_status. (assign_stack_local_1): Don't call push_obstacks. (find_fixup_replacement): Use xmalloc. (fixup_var_refs_insns): Free the storage. (insns_for_mem_walk): Don't mess with obstacks. (instantiate_decls): Likewise. (trampoline_address): Likewise. (expand_function_end): Likewise. * function.h (sturct function): Remove obstack-related variables. (save_tree_status): Don't declare. (restore_tree_status): Likewise. * gcse.c (compute_can_copy): Don't call oballoc/obfree. * genattrtab.c (operate_exp): Remove ggc_p conditionals. (simplify_cond): Likewise. (simplify_test_exp): Don't mess with obstacks. (optimize_attrs): Likewise. * gengenrtl.c (gendef): Don't include ggc_p conditionals. * ggc-callbacks.c (ggc_p): Remove. * ggc-none.c (ggc_p): Remove. * ggc.h (ggc_p): Don't declare. * integrate.c (save_for_inline): Don't mess with obstacks. (integrate_decl_tree): Likewise. (output_inline_function): Likewise. * lists.c (init_EXPR_INSN_LIST_cache): Likewise. * loop.c (temp_obstack): Remove. (rtl_obstack): Likewise. (init_loop): Don't mess with obstacks. (reg_address_cost): Free BIVs and GIVs. (check_insns_for_bivs): Use xmalloc, not oballoc. (find_mem_givs): Likewise. (record_biv): Likewise. (general_induction_var): Likewise. (product_cheap_p): Likewse. * optabs.c (init_one_libfunc): Remove ggc_p conditional. * print-tree.c (debug_tree): Don't use oballoc/obfree. (print_node): Likewise. * profile.c (output_func_start_profiler): Remove call to temporary_allocation. * reload1.c (eliminate_regs_in_insn): Don't mess with obstacks. * resource.c (mark_target_live_regs): Use xmalloc. (free_resource_info): Free the memory. * rtl.c (rtl_obstack): Remove. (rtvec_alloc): Don't mess with obstacks. (rtx_alloc): Likewise. (rtx_free): Remove. (copy_rtx): Don't handle `b' cases. (read_rtx): Use a local rtl_obstack. * rtl.h (oballoc): Remove. (obfree): Likewise. (pop_obstacks): Likewise. (push_obstacks): Likewise. (allocate_bb_life_data): Likewise. (allocate_reg_life_data): Likewise. (rtx_free): Likewise. * sdbout.c (sdbout_queue_anonymous_type): Use tree_cons, not saveable_tree_cons. * simplify-rtx.c (cselib_init): Don't mess with obstacks. * stmt.c (mark_block_nesting): Mark the label_chain. (epxand_label): Use ggc_alloc, not oballoc. (clear_last_expr): Don't mess with obstacks. (expand_decl_cleanup): Likewise. (expand_dcc_cleanup): Likewise. (expand_dhc_cleanup): Likewise. (expand_anon_union_decl): Likewise. (add_case_node): Use xmalloc, not oballoc. (free_case_nodes): New function. (expand_end_case): Call it. * stor-layout.c (layout_type): Don't mess with obstacks. (layout_type): Likewise. * toplev.c (wrapup_global_declarations): Likewise. (compile_file): Remove ggc_p conditionals. (rest_of_compilation): Call init_flow. Remove ggc_p conditionals. (decode_f_option): Remove ggc_p conditionals. * tree.c (function_maybepermanent_obstack): Remove. (maybepermanent_obstack): Likewise. (function_obstack): Likewise. (tmeporary_obstack): Likewise. (momentary_obstack): Likewise. (temp_decl_obstack): Likewise. (saveable_obstack): Likewise. (rtl_obstack): Likewise. (current_obstack): Likewise. (expression_obstack): Likewise. (struct obstack_stack): Likewise. (obstack_stack): Likewise. (obstack_stack_obstack): Likewise. (maybepermanent_firstobj): Likewise. (temporary_firstobj): Likewise. (momentary_firstobj): Likewise. (temp_decl_firstobj): Likewise. (momentary_function_firstobj): Likewise. (all_types_permanent): Likewise. (struct momentary_level): Likewise. (momentary_stack): Likewise. (init_obstacks): Remove initialization of removed obstacks. (save_tree_status): Remove. (restore_tree_status): Likewise. (temporary_allocation): Liekwise. (end_temporary_allocation): Liekwise. (resume_temporary_allocation): Likewise. (saveable_allocation): Likewise. (push_obstacks): Likewise. (push_obstacks_nochange): Likewise. (pop_obstacks): Likewise. (allocation_temporary_p): Likewise. (permanent_allocation): Likewise. (preserve_data): Likewise. (preserve_initializer): Likewise. (rtl_in_current_obstack): Likewise. (rtl_in_saveable_obstack): Likewise. (oballoc): Likewise. (obfree): Likewise. (savealloc): Likewise. (expralloc): Likewise. (print_obstack_name): Likewise. (debug_obstack): Likewise. (object_permanent_p): Likewise. (push_momentary): Likewise. (perserve_momentary): Likewise. (clear_momentary): Likewise. (pop_momentary): Likewise. (pop_momentary_nofree): Likewise. (suspend_momentary): Likewise. (resume_momentary): Likewise. (make_node): Don't set TREE_PERMANENT. (copy_node): Remove ggc_p conditionals. Don't set TYPE_OBSTACK. Don't set TREE_PERMANENT. (get_identifier): Remove ggc_p conditionals. (build_string): Likewise. (make_tree_vec): Likewise. (build_decl_list): Remove. (build_expr_list): Likewise. (tree_cons): Remove ggc_p conditionals. (decl_tree_cons): Remove. (expr_tree_cons): Likewise. (perm_tree_cons): Likewise. (temp_tree_cons): Likewise. (saveable_tree_cons): Likewise. (build1): Remove ggc_p conditionals. (build_parse_node): Likewise. (build_type_attribute_variant): Don't mess with obstacks. (build_type_copy): Likewise. (type_hash_canon): Likewise. (build_pointer_type): Likewise. (build_reference_type): Likewise. (build_index_type): Likewise. (build_range_type): Likewise. (dump_tree_statistics): Don't print obstack information. * tree.h (struct tree_common): Remove permanent_flag. (TREE_PERMANENT): Remove. (TREE_SET_PERMANENT): Likewise. (TYPE_OBSTACK): Likewise. (struct tree_type): Remove obstack. (oballoc): Remove. (savealloc): Likewise. (build_decl_list): Likewise. (build_expr_list): Likewise. (perm_tree_cons): Likewise. (temp_tree_cons): Likewise. (saveable_tree_cons): Likewise. (decl_tree_cons): Likewise. (expr_tree_cons): Likewise. (suspend_momentary): Likewise. (allocation_temporary_p): Likewise. (resume_momentary): Likewise. (push_obstacks_nochange): Likewise. (permanent_allocation): Likewise. (push_momentary): Likewise. (clear_momentary): Likewise. (pop_momentary): Likewise. (end_temporary_allocation): Likewise. (pop_obstacks): Likewise. (push_obstacks): Likewise. (pop_momentary_nofree): LIkewise. (preserve_momentary): Likewise. (saveable_allocation): Likewise. (temporary_allocation): Likewise. (resume_temporary_allocation): Likewise. (perserve_initializer): Likewise. (debug_obstack): Likewise. (rtl_in_current_obstack): Likewise. (rtl_in_saveable_obstack): Likewise. (obfree): Likewise. * varasm.c (current_obstack): Remove. (saveable_obstack): Remove. (rtl_obstack): Remove. (immed_double_const): Don't mess with obstacks. (immed_real_cons): Likewise. (output_constant_def): Likewise. (init_varasm_status): Use xcalloc. (mark_pool_constant): Mark the pool constant itself. (free_varasm_status): Free memory. (decode_rtx_const): Call bzero directly, rather than expanding it inline. (record_rtx_const): Don't mess with obstacks. (force_const_mem): Likewise. * config/arm/arm.c (arm_encode_call_attribute): Remove ggc_p conditionals. (aof_pic_entry): Likewise. * config/ia64/ia64.c (ia64_encode_section_info): Likewise. * config/m32r/m32r.c (m32r_encode_section_info): Likewise. * config/pa/pa.c (saveable_obstack): Remove. (rtl_obstack): Likewise. (current_obstack): Likewise. (output_call): Don't mess with obstacks. (hppa_encode_label): Remove ggc_p conditionals. * config/romp/romp.c (get_symref): Don't mess with obstacks. * config/rs6000/rs6000.c (output_toc): Remove ggc_p conditional. (rs6000_encode_section_info): Likewise. * config/sh/sh.c (get_fpscr_rtx): Likewise. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@36856 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/tree.c | 806 +------------------------------------------------------------ 1 file changed, 10 insertions(+), 796 deletions(-) (limited to 'gcc/tree.c') diff --git a/gcc/tree.c b/gcc/tree.c index fab3d1de0c9..7bd7a41309f 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -53,112 +53,10 @@ extern int _obstack_allocated_p PARAMS ((struct obstack *h, PTR obj)); static void unsave_expr_now_r PARAMS ((tree)); -/* Tree nodes of permanent duration are allocated in this obstack. - They are the identifier nodes, and everything outside of - the bodies and parameters of function definitions. */ +/* Objects allocated on this obstack last forever. */ struct obstack permanent_obstack; -/* The initial RTL, and all ..._TYPE nodes, in a function - are allocated in this obstack. Usually they are freed at the - end of the function, but if the function is inline they are saved. - For top-level functions, this is maybepermanent_obstack. - Separate obstacks are made for nested functions. */ - -struct obstack *function_maybepermanent_obstack; - -/* This is the function_maybepermanent_obstack for top-level functions. */ - -struct obstack maybepermanent_obstack; - -/* The contents of the current function definition are allocated - in this obstack, and all are freed at the end of the function. - For top-level functions, this is temporary_obstack. - Separate obstacks are made for nested functions. */ - -struct obstack *function_obstack; - -/* This is used for reading initializers of global variables. */ - -struct obstack temporary_obstack; - -/* The tree nodes of an expression are allocated - in this obstack, and all are freed at the end of the expression. */ - -struct obstack momentary_obstack; - -/* The tree nodes of a declarator are allocated - in this obstack, and all are freed when the declarator - has been parsed. */ - -static struct obstack temp_decl_obstack; - -/* This points at either permanent_obstack - or the current function_maybepermanent_obstack. */ - -struct obstack *saveable_obstack; - -/* This is same as saveable_obstack during parse and expansion phase; - it points to the current function's obstack during optimization. - This is the obstack to be used for creating rtl objects. */ - -struct obstack *rtl_obstack; - -/* This points at either permanent_obstack or the current function_obstack. */ - -struct obstack *current_obstack; - -/* This points at either permanent_obstack or the current function_obstack - or momentary_obstack. */ - -struct obstack *expression_obstack; - -/* Stack of obstack selections for push_obstacks and pop_obstacks. */ - -struct obstack_stack -{ - struct obstack_stack *next; - struct obstack *current; - struct obstack *saveable; - struct obstack *expression; - struct obstack *rtl; -}; - -struct obstack_stack *obstack_stack; - -/* Obstack for allocating struct obstack_stack entries. */ - -static struct obstack obstack_stack_obstack; - -/* Addresses of first objects in some obstacks. - This is for freeing their entire contents. */ -char *maybepermanent_firstobj; -char *temporary_firstobj; -char *momentary_firstobj; -char *temp_decl_firstobj; - -/* This is used to preserve objects (mainly array initializers) that need to - live until the end of the current function, but no further. */ -char *momentary_function_firstobj; - -/* Nonzero means all ..._TYPE nodes should be allocated permanently. */ - -int all_types_permanent; - -/* Stack of places to restore the momentary obstack back to. */ - -struct momentary_level -{ - /* Pointer back to previous such level. */ - struct momentary_level *prev; - /* First object allocated within this level. */ - char *base; - /* Value of expression_obstack saved at entry to this level. */ - struct obstack *obstack; -}; - -struct momentary_level *momentary_stack; - /* Table indexed by tree code giving a string containing a character classifying the tree code. Possibilities are t, d, s, c, r, <, 1, 2 and e. See tree.def for details. */ @@ -304,26 +202,8 @@ tree integer_types[itk_none]; void init_obstacks () { - gcc_obstack_init (&obstack_stack_obstack); gcc_obstack_init (&permanent_obstack); - gcc_obstack_init (&temporary_obstack); - temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0); - gcc_obstack_init (&momentary_obstack); - momentary_firstobj = (char *) obstack_alloc (&momentary_obstack, 0); - momentary_function_firstobj = momentary_firstobj; - gcc_obstack_init (&maybepermanent_obstack); - maybepermanent_firstobj - = (char *) obstack_alloc (&maybepermanent_obstack, 0); - gcc_obstack_init (&temp_decl_obstack); - temp_decl_firstobj = (char *) obstack_alloc (&temp_decl_obstack, 0); - - function_obstack = &temporary_obstack; - function_maybepermanent_obstack = &maybepermanent_obstack; - current_obstack = &permanent_obstack; - expression_obstack = &permanent_obstack; - rtl_obstack = saveable_obstack = &permanent_obstack; - /* Init the hash table of identifiers. */ bzero ((char *) hash_table, sizeof hash_table); ggc_add_tree_root (hash_table, sizeof hash_table / sizeof (tree)); @@ -356,309 +236,7 @@ gcc_obstack_init (obstack) (void (*) PARAMS ((void *))) OBSTACK_CHUNK_FREE); } -/* Save all variables describing the current status into the structure - *P. This function is called whenever we start compiling one - function in the midst of compiling another. For example, when - compiling a nested function, or, in C++, a template instantiation - that is required by the function we are currently compiling. - - CONTEXT is the decl_function_context for the function we're about to - compile; if it isn't current_function_decl, we have to play some games. */ - -void -save_tree_status (p) - struct function *p; -{ - p->all_types_permanent = all_types_permanent; - p->momentary_stack = momentary_stack; - p->maybepermanent_firstobj = maybepermanent_firstobj; - p->temporary_firstobj = temporary_firstobj; - p->momentary_firstobj = momentary_firstobj; - p->momentary_function_firstobj = momentary_function_firstobj; - p->function_obstack = function_obstack; - p->function_maybepermanent_obstack = function_maybepermanent_obstack; - p->current_obstack = current_obstack; - p->expression_obstack = expression_obstack; - p->saveable_obstack = saveable_obstack; - p->rtl_obstack = rtl_obstack; - - function_maybepermanent_obstack - = (struct obstack *) xmalloc (sizeof (struct obstack)); - gcc_obstack_init (function_maybepermanent_obstack); - maybepermanent_firstobj - = (char *) obstack_finish (function_maybepermanent_obstack); - - function_obstack = (struct obstack *) xmalloc (sizeof (struct obstack)); - gcc_obstack_init (function_obstack); - - current_obstack = &permanent_obstack; - expression_obstack = &permanent_obstack; - rtl_obstack = saveable_obstack = &permanent_obstack; - - temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0); - momentary_firstobj = (char *) obstack_finish (&momentary_obstack); - momentary_function_firstobj = momentary_firstobj; -} - -/* Restore all variables describing the current status from the structure *P. - This is used after a nested function. */ - -void -restore_tree_status (p) - struct function *p; -{ - all_types_permanent = p->all_types_permanent; - momentary_stack = p->momentary_stack; - - obstack_free (&momentary_obstack, momentary_function_firstobj); - - /* Free saveable storage used by the function just compiled and not - saved. */ - obstack_free (function_maybepermanent_obstack, maybepermanent_firstobj); - if (obstack_empty_p (function_maybepermanent_obstack)) - { - obstack_free (function_maybepermanent_obstack, NULL); - free (function_maybepermanent_obstack); - } - - obstack_free (&temporary_obstack, temporary_firstobj); - obstack_free (&momentary_obstack, momentary_function_firstobj); - - obstack_free (function_obstack, NULL); - free (function_obstack); - - temporary_firstobj = p->temporary_firstobj; - momentary_firstobj = p->momentary_firstobj; - momentary_function_firstobj = p->momentary_function_firstobj; - maybepermanent_firstobj = p->maybepermanent_firstobj; - function_obstack = p->function_obstack; - function_maybepermanent_obstack = p->function_maybepermanent_obstack; - current_obstack = p->current_obstack; - expression_obstack = p->expression_obstack; - saveable_obstack = p->saveable_obstack; - rtl_obstack = p->rtl_obstack; -} -/* Start allocating on the temporary (per function) obstack. - This is done in start_function before parsing the function body, - and before each initialization at top level, and to go back - to temporary allocation after doing permanent_allocation. */ - -void -temporary_allocation () -{ - /* Note that function_obstack at top level points to temporary_obstack. - But within a nested function context, it is a separate obstack. */ - current_obstack = function_obstack; - expression_obstack = function_obstack; - rtl_obstack = saveable_obstack = function_maybepermanent_obstack; - momentary_stack = 0; -} - -/* Start allocating on the permanent obstack but don't - free the temporary data. After calling this, call - `permanent_allocation' to fully resume permanent allocation status. */ - -void -end_temporary_allocation () -{ - current_obstack = &permanent_obstack; - expression_obstack = &permanent_obstack; - rtl_obstack = saveable_obstack = &permanent_obstack; -} - -/* Resume allocating on the temporary obstack, undoing - effects of `end_temporary_allocation'. */ - -void -resume_temporary_allocation () -{ - current_obstack = function_obstack; - expression_obstack = function_obstack; - rtl_obstack = saveable_obstack = function_maybepermanent_obstack; -} - -/* While doing temporary allocation, switch to allocating in such a - way as to save all nodes if the function is inlined. Call - resume_temporary_allocation to go back to ordinary temporary - allocation. */ - -void -saveable_allocation () -{ - /* Note that function_obstack at top level points to temporary_obstack. - But within a nested function context, it is a separate obstack. */ - expression_obstack = current_obstack = saveable_obstack; -} - -/* Switch to current obstack CURRENT and maybepermanent obstack SAVEABLE, - recording the previously current obstacks on a stack. - This does not free any storage in any obstack. */ - -void -push_obstacks (current, saveable) - struct obstack *current, *saveable; -{ - struct obstack_stack *p; - - p = (struct obstack_stack *) obstack_alloc (&obstack_stack_obstack, - (sizeof (struct obstack_stack))); - - p->current = current_obstack; - p->saveable = saveable_obstack; - p->expression = expression_obstack; - p->rtl = rtl_obstack; - p->next = obstack_stack; - obstack_stack = p; - - current_obstack = current; - expression_obstack = current; - rtl_obstack = saveable_obstack = saveable; -} - -/* Save the current set of obstacks, but don't change them. */ - -void -push_obstacks_nochange () -{ - struct obstack_stack *p; - - p = (struct obstack_stack *) obstack_alloc (&obstack_stack_obstack, - (sizeof (struct obstack_stack))); - - p->current = current_obstack; - p->saveable = saveable_obstack; - p->expression = expression_obstack; - p->rtl = rtl_obstack; - p->next = obstack_stack; - obstack_stack = p; -} - -/* Pop the obstack selection stack. */ - -void -pop_obstacks () -{ - struct obstack_stack *p; - - p = obstack_stack; - obstack_stack = p->next; - - current_obstack = p->current; - saveable_obstack = p->saveable; - expression_obstack = p->expression; - rtl_obstack = p->rtl; - - obstack_free (&obstack_stack_obstack, p); -} - -/* Nonzero if temporary allocation is currently in effect. - Zero if currently doing permanent allocation. */ - -int -allocation_temporary_p () -{ - return current_obstack != &permanent_obstack; -} - -/* Go back to allocating on the permanent obstack - and free everything in the temporary obstack. - - FUNCTION_END is true only if we have just finished compiling a function. - In that case, we also free preserved initial values on the momentary - obstack. */ - -void -permanent_allocation (function_end) - int function_end; -{ - /* Free up previous temporary obstack data */ - obstack_free (&temporary_obstack, temporary_firstobj); - if (function_end) - { - obstack_free (&momentary_obstack, momentary_function_firstobj); - momentary_firstobj = momentary_function_firstobj; - } - else - obstack_free (&momentary_obstack, momentary_firstobj); - - obstack_free (function_maybepermanent_obstack, maybepermanent_firstobj); - obstack_free (&temp_decl_obstack, temp_decl_firstobj); - - current_obstack = &permanent_obstack; - expression_obstack = &permanent_obstack; - rtl_obstack = saveable_obstack = &permanent_obstack; -} - -/* Save permanently everything on the maybepermanent_obstack. */ - -void -preserve_data () -{ - maybepermanent_firstobj - = (char *) obstack_alloc (function_maybepermanent_obstack, 0); -} - -void -preserve_initializer () -{ - struct momentary_level *tem; - char *old_momentary; - - temporary_firstobj - = (char *) obstack_alloc (&temporary_obstack, 0); - maybepermanent_firstobj - = (char *) obstack_alloc (function_maybepermanent_obstack, 0); - - old_momentary = momentary_firstobj; - momentary_firstobj - = (char *) obstack_alloc (&momentary_obstack, 0); - if (momentary_firstobj != old_momentary) - for (tem = momentary_stack; tem; tem = tem->prev) - tem->base = momentary_firstobj; -} - -/* Start allocating new rtl in current_obstack. - Use resume_temporary_allocation - to go back to allocating rtl in saveable_obstack. */ - -void -rtl_in_current_obstack () -{ - rtl_obstack = current_obstack; -} - -/* Start allocating rtl from saveable_obstack. Intended to be used after - a call to push_obstacks_nochange. */ - -void -rtl_in_saveable_obstack () -{ - rtl_obstack = saveable_obstack; -} - -/* Allocate SIZE bytes in the current obstack - and return a pointer to them. - In practice the current obstack is always the temporary one. */ - -char * -oballoc (size) - int size; -{ - return (char *) obstack_alloc (current_obstack, size); -} - -/* Free the object PTR in the current obstack - as well as everything allocated since PTR. - In practice the current obstack is always the temporary one. */ - -void -obfree (ptr) - char *ptr; -{ - obstack_free (current_obstack, ptr); -} - /* Allocate SIZE bytes in the permanent obstack and return a pointer to them. */ @@ -683,204 +261,6 @@ perm_calloc (nelem, size) return rval; } -/* Allocate SIZE bytes in the saveable obstack - and return a pointer to them. */ - -char * -savealloc (size) - int size; -{ - return (char *) obstack_alloc (saveable_obstack, size); -} - -/* Allocate SIZE bytes in the expression obstack - and return a pointer to them. */ - -char * -expralloc (size) - int size; -{ - return (char *) obstack_alloc (expression_obstack, size); -} - -/* Print out which obstack an object is in. */ - -void -print_obstack_name (object, file, prefix) - char *object; - FILE *file; - const char *prefix; -{ - struct obstack *obstack = NULL; - const char *obstack_name = NULL; - struct function *p; - - for (p = outer_function_chain; p; p = p->next) - { - if (_obstack_allocated_p (p->function_obstack, object)) - { - obstack = p->function_obstack; - obstack_name = "containing function obstack"; - } - if (_obstack_allocated_p (p->function_maybepermanent_obstack, object)) - { - obstack = p->function_maybepermanent_obstack; - obstack_name = "containing function maybepermanent obstack"; - } - } - - if (_obstack_allocated_p (&obstack_stack_obstack, object)) - { - obstack = &obstack_stack_obstack; - obstack_name = "obstack_stack_obstack"; - } - else if (_obstack_allocated_p (function_obstack, object)) - { - obstack = function_obstack; - obstack_name = "function obstack"; - } - else if (_obstack_allocated_p (&permanent_obstack, object)) - { - obstack = &permanent_obstack; - obstack_name = "permanent_obstack"; - } - else if (_obstack_allocated_p (&momentary_obstack, object)) - { - obstack = &momentary_obstack; - obstack_name = "momentary_obstack"; - } - else if (_obstack_allocated_p (function_maybepermanent_obstack, object)) - { - obstack = function_maybepermanent_obstack; - obstack_name = "function maybepermanent obstack"; - } - else if (_obstack_allocated_p (&temp_decl_obstack, object)) - { - obstack = &temp_decl_obstack; - obstack_name = "temp_decl_obstack"; - } - - /* Check to see if the object is in the free area of the obstack. */ - if (obstack != NULL) - { - if (object >= obstack->next_free - && object < obstack->chunk_limit) - fprintf (file, "%s in free portion of obstack %s", - prefix, obstack_name); - else - fprintf (file, "%s allocated from %s", prefix, obstack_name); - } - else - fprintf (file, "%s not allocated from any obstack", prefix); -} - -void -debug_obstack (object) - char *object; -{ - print_obstack_name (object, stderr, "object"); - fprintf (stderr, ".\n"); -} - -/* Return 1 if OBJ is in the permanent obstack. - This is slow, and should be used only for debugging. - Use TREE_PERMANENT for other purposes. */ - -int -object_permanent_p (obj) - tree obj; -{ - return _obstack_allocated_p (&permanent_obstack, obj); -} - -/* Start a level of momentary allocation. - In C, each compound statement has its own level - and that level is freed at the end of each statement. - All expression nodes are allocated in the momentary allocation level. */ - -void -push_momentary () -{ - struct momentary_level *tem - = (struct momentary_level *) obstack_alloc (&momentary_obstack, - sizeof (struct momentary_level)); - tem->prev = momentary_stack; - tem->base = (char *) obstack_base (&momentary_obstack); - tem->obstack = expression_obstack; - momentary_stack = tem; - expression_obstack = &momentary_obstack; -} - -/* Set things up so the next clear_momentary will only clear memory - past our present position in momentary_obstack. */ - -void -preserve_momentary () -{ - momentary_stack->base = (char *) obstack_base (&momentary_obstack); -} - -/* Free all the storage in the current momentary-allocation level. - In C, this happens at the end of each statement. */ - -void -clear_momentary () -{ - obstack_free (&momentary_obstack, momentary_stack->base); -} - -/* Discard a level of momentary allocation. - In C, this happens at the end of each compound statement. - Restore the status of expression node allocation - that was in effect before this level was created. */ - -void -pop_momentary () -{ - struct momentary_level *tem = momentary_stack; - momentary_stack = tem->prev; - expression_obstack = tem->obstack; - /* We can't free TEM from the momentary_obstack, because there might - be objects above it which have been saved. We can free back to the - stack of the level we are popping off though. */ - obstack_free (&momentary_obstack, tem->base); -} - -/* Pop back to the previous level of momentary allocation, - but don't free any momentary data just yet. */ - -void -pop_momentary_nofree () -{ - struct momentary_level *tem = momentary_stack; - momentary_stack = tem->prev; - expression_obstack = tem->obstack; -} - -/* Call when starting to parse a declaration: - make expressions in the declaration last the length of the function. - Returns an argument that should be passed to resume_momentary later. */ - -int -suspend_momentary () -{ - register int tem = expression_obstack == &momentary_obstack; - expression_obstack = saveable_obstack; - return tem; -} - -/* Call when finished parsing a declaration: - restore the treatment of node-allocation that was - in effect before the suspension. - YES should be the value previously returned by suspend_momentary. */ - -void -resume_momentary (yes) - int yes; -{ - if (yes) - expression_obstack = &momentary_obstack; -} /* Init the tables indexed by tree code. Note that languages can add to these tables to define their own codes. */ @@ -951,9 +331,6 @@ tree_size (node) } /* Return a newly allocated node of code CODE. - Initialize the node's unique id and its TREE_PERMANENT flag. - Note that if garbage collection is in use, TREE_PERMANENT will - always be zero - we want to eliminate use of TREE_PERMANENT. For decl and type nodes, some other fields are initialized. The rest of the node is initialized to zero. @@ -1037,7 +414,6 @@ make_node (code) memset ((PTR) t, 0, length); TREE_SET_CODE (t, code); - TREE_SET_PERMANENT (t); switch (type) { @@ -1133,10 +509,7 @@ copy_node (node) register size_t length; length = tree_size (node); - if (ggc_p) - t = ggc_alloc_tree (length); - else - t = (tree) obstack_alloc (current_obstack, length); + t = ggc_alloc_tree (length); memcpy (t, node, length); TREE_CHAIN (t) = 0; @@ -1147,8 +520,6 @@ copy_node (node) else if (TREE_CODE_CLASS (code) == 't') { TYPE_UID (t) = next_type_uid++; - TYPE_OBSTACK (t) = current_obstack; - /* The following is so that the debug code for the copy is different from the original type. The two statements usually duplicate each other @@ -1158,8 +529,6 @@ copy_node (node) TYPE_SYMTAB_ADDRESS (t) = 0; } - TREE_SET_PERMANENT (t); - return t; } @@ -1246,10 +615,7 @@ get_identifier (text) id_string_size += len; #endif - if (ggc_p) - IDENTIFIER_POINTER (idp) = ggc_alloc_string (text, len); - else - IDENTIFIER_POINTER (idp) = obstack_copy0 (&permanent_obstack, text, len); + IDENTIFIER_POINTER (idp) = ggc_alloc_string (text, len); TREE_CHAIN (idp) = hash_table[hi]; hash_table[hi] = idp; @@ -1492,17 +858,10 @@ build_string (len, str) int len; const char *str; { - /* Put the string in saveable_obstack since it will be placed in the RTL - for an "asm" statement and will also be kept around a while if - deferring constant output in varasm.c. */ - register tree s = make_node (STRING_CST); TREE_STRING_LENGTH (s) = len; - if (ggc_p) - TREE_STRING_POINTER (s) = ggc_alloc_string (str, len); - else - TREE_STRING_POINTER (s) = obstack_copy0 (saveable_obstack, str, len); + TREE_STRING_POINTER (s) = ggc_alloc_string (str, len); return s; } @@ -1536,22 +895,17 @@ make_tree_vec (len) { register tree t; register int length = (len-1) * sizeof (tree) + sizeof (struct tree_vec); - register struct obstack *obstack = current_obstack; #ifdef GATHER_STATISTICS tree_node_counts[(int)vec_kind]++; tree_node_sizes[(int)vec_kind] += length; #endif - if (ggc_p) - t = ggc_alloc_tree (length); - else - t = (tree) obstack_alloc (obstack, length); + t = ggc_alloc_tree (length); memset ((PTR) t, 0, length); TREE_SET_CODE (t, TREE_VEC); TREE_VEC_LENGTH (t) = len; - TREE_SET_PERMANENT (t); return t; } @@ -2062,36 +1416,6 @@ build_tree_list (parm, value) return t; } -/* Similar, but build on the temp_decl_obstack. */ - -tree -build_decl_list (parm, value) - tree parm, value; -{ - register tree node; - register struct obstack *ambient_obstack = current_obstack; - - current_obstack = &temp_decl_obstack; - node = build_tree_list (parm, value); - current_obstack = ambient_obstack; - return node; -} - -/* Similar, but build on the expression_obstack. */ - -tree -build_expr_list (parm, value) - tree parm, value; -{ - register tree node; - register struct obstack *ambient_obstack = current_obstack; - - current_obstack = expression_obstack; - node = build_tree_list (parm, value); - current_obstack = ambient_obstack; - return node; -} - /* Return a newly created TREE_LIST node whose purpose and value fields are PARM and VALUE and whose TREE_CHAIN is CHAIN. */ @@ -2102,10 +1426,7 @@ tree_cons (purpose, value, chain) { register tree node; - if (ggc_p) - node = ggc_alloc_tree (sizeof (struct tree_list)); - else - node = (tree) obstack_alloc (current_obstack, sizeof (struct tree_list)); + node = ggc_alloc_tree (sizeof (struct tree_list)); memset (node, 0, sizeof (struct tree_common)); @@ -2115,88 +1436,12 @@ tree_cons (purpose, value, chain) #endif TREE_SET_CODE (node, TREE_LIST); - TREE_SET_PERMANENT (node); - TREE_CHAIN (node) = chain; TREE_PURPOSE (node) = purpose; TREE_VALUE (node) = value; return node; } -/* Similar, but build on the temp_decl_obstack. */ - -tree -decl_tree_cons (purpose, value, chain) - tree purpose, value, chain; -{ - register tree node; - register struct obstack *ambient_obstack = current_obstack; - - current_obstack = &temp_decl_obstack; - node = tree_cons (purpose, value, chain); - current_obstack = ambient_obstack; - return node; -} - -/* Similar, but build on the expression_obstack. */ - -tree -expr_tree_cons (purpose, value, chain) - tree purpose, value, chain; -{ - register tree node; - register struct obstack *ambient_obstack = current_obstack; - - current_obstack = expression_obstack; - node = tree_cons (purpose, value, chain); - current_obstack = ambient_obstack; - return node; -} - -/* Same as `tree_cons' but make a permanent object. */ - -tree -perm_tree_cons (purpose, value, chain) - tree purpose, value, chain; -{ - register tree node; - register struct obstack *ambient_obstack = current_obstack; - - current_obstack = &permanent_obstack; - node = tree_cons (purpose, value, chain); - current_obstack = ambient_obstack; - return node; -} - -/* Same as `tree_cons', but make this node temporary, regardless. */ - -tree -temp_tree_cons (purpose, value, chain) - tree purpose, value, chain; -{ - register tree node; - register struct obstack *ambient_obstack = current_obstack; - - current_obstack = &temporary_obstack; - node = tree_cons (purpose, value, chain); - current_obstack = ambient_obstack; - return node; -} - -/* Same as `tree_cons', but save this node if the function's RTL is saved. */ - -tree -saveable_tree_cons (purpose, value, chain) - tree purpose, value, chain; -{ - register tree node; - register struct obstack *ambient_obstack = current_obstack; - - current_obstack = saveable_obstack; - node = tree_cons (purpose, value, chain); - current_obstack = ambient_obstack; - return node; -} /* Return the size nominally occupied by an object of type TYPE when it resides in memory. The value is measured in units of bytes, @@ -3308,7 +2553,6 @@ build1 (code, type, node) tree type; tree node; { - register struct obstack *obstack = expression_obstack; register int length; #ifdef GATHER_STATISTICS register tree_node_kind kind; @@ -3324,10 +2568,7 @@ build1 (code, type, node) length = sizeof (struct tree_exp); - if (ggc_p) - t = ggc_alloc_tree (length); - else - t = (tree) obstack_alloc (obstack, length); + t = ggc_alloc_tree (length); memset ((PTR) t, 0, sizeof (struct tree_common)); @@ -3337,8 +2578,6 @@ build1 (code, type, node) #endif TREE_SET_CODE (t, code); - TREE_SET_PERMANENT (t); - TREE_TYPE (t) = type; TREE_COMPLEXITY (t) = 0; TREE_OPERAND (t, 0) = node; @@ -3408,7 +2647,6 @@ build_parse_node VPARAMS ((enum tree_code code, ...)) #ifndef ANSI_PROTOTYPES enum tree_code code; #endif - register struct obstack *ambient_obstack = expression_obstack; va_list p; register tree t; register int length; @@ -3420,8 +2658,6 @@ build_parse_node VPARAMS ((enum tree_code code, ...)) code = va_arg (p, enum tree_code); #endif - expression_obstack = &temp_decl_obstack; - t = make_node (code); length = TREE_CODE_LENGTH (code); @@ -3429,7 +2665,6 @@ build_parse_node VPARAMS ((enum tree_code code, ...)) TREE_OPERAND (t, i) = va_arg (p, tree); va_end (p); - expression_obstack = ambient_obstack; return t; } @@ -3554,7 +2789,6 @@ build_type_attribute_variant (ttype, attribute) unsigned int hashcode; tree ntype; - push_obstacks (TYPE_OBSTACK (ttype), TYPE_OBSTACK (ttype)); ntype = copy_node (ttype); TYPE_POINTER_TO (ntype) = 0; @@ -3590,7 +2824,6 @@ build_type_attribute_variant (ttype, attribute) ntype = type_hash_canon (hashcode, ntype); ttype = build_qualified_type (ntype, TYPE_QUALS (ttype)); - pop_obstacks (); } return ttype; @@ -3906,11 +3139,8 @@ build_type_copy (type) tree type; { register tree t, m = TYPE_MAIN_VARIANT (type); - register struct obstack *ambient_obstack = current_obstack; - current_obstack = TYPE_OBSTACK (type); t = copy_node (type); - current_obstack = ambient_obstack; TYPE_POINTER_TO (t) = 0; TYPE_REFERENCE_TO (t) = 0; @@ -4053,9 +3283,6 @@ type_hash_canon (hashcode, type) t1 = type_hash_lookup (hashcode, type); if (t1 != 0) { - if (!ggc_p) - obstack_free (TYPE_OBSTACK (type), type); - #ifdef GATHER_STATISTICS tree_node_counts[(int) t_kind]--; tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type); @@ -4064,8 +3291,7 @@ type_hash_canon (hashcode, type) } /* If this is a permanent type, record it for later reuse. */ - if (ggc_p || TREE_PERMANENT (type)) - type_hash_add (hashcode, type); + type_hash_add (hashcode, type); return type; } @@ -4520,10 +3746,8 @@ build_pointer_type (to_type) if (t != 0) return t; - /* We need a new one. Put this in the same obstack as TO_TYPE. */ - push_obstacks (TYPE_OBSTACK (to_type), TYPE_OBSTACK (to_type)); + /* We need a new one. */ t = make_node (POINTER_TYPE); - pop_obstacks (); TREE_TYPE (t) = to_type; @@ -4551,10 +3775,8 @@ build_reference_type (to_type) if (t) return t; - /* We need a new one. Put this in the same obstack as TO_TYPE. */ - push_obstacks (TYPE_OBSTACK (to_type), TYPE_OBSTACK (to_type)); + /* We need a new one. */ t = make_node (REFERENCE_TYPE); - pop_obstacks (); TREE_TYPE (t) = to_type; @@ -4585,9 +3807,7 @@ build_index_type (maxval) TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype); TYPE_MIN_VALUE (itype) = size_zero_node; - push_obstacks (TYPE_OBSTACK (itype), TYPE_OBSTACK (itype)); TYPE_MAX_VALUE (itype) = convert (sizetype, maxval); - pop_obstacks (); TYPE_MODE (itype) = TYPE_MODE (sizetype); TYPE_SIZE (itype) = TYPE_SIZE (sizetype); @@ -4616,10 +3836,8 @@ build_range_type (type, lowval, highval) if (type == NULL_TREE) type = sizetype; - push_obstacks (TYPE_OBSTACK (itype), TYPE_OBSTACK (itype)); TYPE_MIN_VALUE (itype) = convert (type, lowval); TYPE_MAX_VALUE (itype) = highval ? convert (type, highval) : NULL; - pop_obstacks (); TYPE_PRECISION (itype) = TYPE_PRECISION (type); TYPE_MODE (itype) = TYPE_MODE (type); @@ -5281,10 +4499,6 @@ dump_tree_statistics () fprintf (stderr, "(No per-node statistics)\n"); #endif print_obstack_statistics ("permanent_obstack", &permanent_obstack); - print_obstack_statistics ("maybepermanent_obstack", &maybepermanent_obstack); - print_obstack_statistics ("temporary_obstack", &temporary_obstack); - print_obstack_statistics ("momentary_obstack", &momentary_obstack); - print_obstack_statistics ("temp_decl_obstack", &temp_decl_obstack); print_type_hash_statistics (); print_lang_statistics (); } -- cgit v1.2.1