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

1 files changed, 10 insertions, 796 deletions

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 ();
 }