cp-tree.h (scratchalloc, [...]): Define as macros for now.

	* cp-tree.h (scratchalloc, build_scratch_list, make_scratch_vec,
	scratch_tree_cons): Define as macros for now.
	* call.c, class.c, cvt.c, decl.c, decl2.c, except.c, expr.c, init.c,
	lex.c, method.c, parse.y, pt.c, rtti.c, search.c, tree.c, typeck.c,
	typeck2.c: Use them and the expression_obstack variants.

From-SVN: r15900

19 files changed, 246 insertions, 230 deletions

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 2f87e33..eb91717 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,8 +1,15 @@
-Mon Oct 13 17:41:26 1997  Benjamin Kosnik  <bkoz@rhino.cygnus.com>
+Tue Oct 14 11:46:14 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* cp-tree.h (scratchalloc, build_scratch_list, make_scratch_vec,
+	scratch_tree_cons): Define as macros for now.
+	* call.c, class.c, cvt.c, decl.c, decl2.c, except.c, expr.c, init.c, 
+	lex.c, method.c, parse.y, pt.c, rtti.c, search.c, tree.c, typeck.c,
+	typeck2.c: Use them and the expression_obstack variants.
 
- 	* decl.c (store_return_init): Allow classes with explicit ctors to
-	be used with the named return values extension.
+Mon Oct 13 17:41:26 1997  Benjamin Kosnik  <bkoz@rhino.cygnus.com>
 
+	* decl.c (store_return_init): Allow classes with explicit ctors to
+ 	be used with the named return values extension.
 
 Fri Oct 10 12:21:11 1997  Jason Merrill  <jason@yorick.cygnus.com>
 
diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 8d1bd04..eaa39c6 100644
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -1267,7 +1267,7 @@ build_field_call (basetype_path, instance_ptr, name, parms)
 	      if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance))) == FUNCTION_TYPE)
 		return build_function_call (instance, parms);
 	      else if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance))) == METHOD_TYPE)
-		return build_function_call (instance, tree_cons (NULL_TREE, current_class_ptr, parms));
+		return build_function_call (instance, expr_tree_cons (NULL_TREE, current_class_ptr, parms));
 	    }
 	}
       return NULL_TREE;
@@ -2110,14 +2110,14 @@ build_method_call (instance, name, parms, basetype_path, flags)
 	 of the signature pointer?  */
       constp = TYPE_READONLY (basetype);
       volatilep = TYPE_VOLATILE (basetype);
-      parms = tree_cons (NULL_TREE, instance_ptr, parms);
+      parms = expr_tree_cons (NULL_TREE, instance_ptr, parms);
     }
   else if (instance)
     {
       /* TREE_READONLY (instance) fails for references.  */
       constp = TYPE_READONLY (TREE_TYPE (TREE_TYPE (instance_ptr)));
       volatilep = TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (instance_ptr)));
-      parms = tree_cons (NULL_TREE, instance_ptr, parms);
+      parms = expr_tree_cons (NULL_TREE, instance_ptr, parms);
     }
   else
     {
@@ -2126,18 +2126,18 @@ build_method_call (instance, name, parms, basetype_path, flags)
 	  && ! (flags & LOOKUP_HAS_IN_CHARGE))
 	{
 	  flags |= LOOKUP_HAS_IN_CHARGE;
-	  parms = tree_cons (NULL_TREE, integer_one_node, parms);
-	  parmtypes = tree_cons (NULL_TREE, integer_type_node, parmtypes);
+	  parms = expr_tree_cons (NULL_TREE, integer_one_node, parms);
+	  parmtypes = scratch_tree_cons (NULL_TREE, integer_type_node, parmtypes);
 	}
 
       constp = 0;
       volatilep = 0;
       instance_ptr = build_int_2 (0, 0);
       TREE_TYPE (instance_ptr) = build_pointer_type (basetype);
-      parms = tree_cons (NULL_TREE, instance_ptr, parms);
+      parms = expr_tree_cons (NULL_TREE, instance_ptr, parms);
     }
 
-  parmtypes = tree_cons (NULL_TREE, TREE_TYPE (instance_ptr), parmtypes);
+  parmtypes = scratch_tree_cons (NULL_TREE, TREE_TYPE (instance_ptr), parmtypes);
 
   if (last == NULL_TREE)
     last = parmtypes;
@@ -2171,10 +2171,10 @@ build_method_call (instance, name, parms, basetype_path, flags)
 	      tree tmplist;
 	      
 	      flags |= LOOKUP_HAS_IN_CHARGE;
-	      tmplist = tree_cons (NULL_TREE, integer_zero_node,
+	      tmplist = expr_tree_cons (NULL_TREE, integer_zero_node,
 				   TREE_CHAIN (parms));
 	      TREE_CHAIN (parms) = tmplist;
-	      tmplist = tree_cons (NULL_TREE, integer_type_node, TREE_CHAIN (parmtypes));
+	      tmplist = scratch_tree_cons (NULL_TREE, integer_type_node, TREE_CHAIN (parmtypes));
 	      TREE_CHAIN (parmtypes) = tmplist;
 	    }
 	  basetype = BINFO_TYPE (tmp);
@@ -2225,7 +2225,7 @@ build_method_call (instance, name, parms, basetype_path, flags)
 	      else
 		my_friendly_abort (167);
 
-	      friend_parms = tree_cons (NULL_TREE, parm, TREE_CHAIN (parms));
+	      friend_parms = expr_tree_cons (NULL_TREE, parm, TREE_CHAIN (parms));
 
 	      cp->h_len = len;
 	      cp->harshness = (struct harshness_code *)
@@ -2275,7 +2275,7 @@ build_method_call (instance, name, parms, basetype_path, flags)
 #endif
 	      ever_seen++;
 	      if (pass > 0)
-		found_fns = tree_cons (NULL_TREE, function, found_fns);
+		found_fns = scratch_tree_cons (NULL_TREE, function, found_fns);
 
 	      /* Not looking for friends here.  */
 	      if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE
@@ -2606,7 +2606,7 @@ build_method_call (instance, name, parms, basetype_path, flags)
 	  instance_ptr = convert_pointer_to (basetype, instance_ptr);
 	  instance = build_indirect_ref (instance_ptr, NULL_PTR);
 	}
-      parms = tree_cons (NULL_TREE, instance_ptr,
+      parms = expr_tree_cons (NULL_TREE, instance_ptr,
 			 convert_arguments (NULL_TREE, TREE_CHAIN (TYPE_ARG_TYPES (fntype)), TREE_CHAIN (parms), function, sub_flags));
     }
   else
@@ -2654,7 +2654,7 @@ build_method_call (instance, name, parms, basetype_path, flags)
 		   || TREE_OPERAND (instance, 0) != instance_ptr)
 	    instance = build_indirect_ref (instance_ptr, NULL_PTR);
 	}
-      parms = tree_cons (NULL_TREE, instance_ptr,
+      parms = expr_tree_cons (NULL_TREE, instance_ptr,
 			 convert_arguments (NULL_TREE, TREE_CHAIN (TYPE_ARG_TYPES (fntype)), TREE_CHAIN (parms), function, LOOKUP_NORMAL));
     }
 
@@ -2842,7 +2842,7 @@ build_overload_call_real (fnname, parms, flags, final_cp, require_complete)
       if (TREE_CODE (function) == TEMPLATE_DECL)
 	{
 	  int ntparms = DECL_NTPARMS (function);
-	  tree targs = make_tree_vec (ntparms);
+	  tree targs = make_scratch_vec (ntparms);
 	  int i;
 
 	  i = type_unification (DECL_INNERMOST_TEMPLATE_PARMS (function),
@@ -2885,7 +2885,7 @@ build_overload_call_real (fnname, parms, flags, final_cp, require_complete)
 	     passed to calling function.  */
 	  cp->h_len = parmlength;
 	  cp->harshness = (struct harshness_code *)
-	    oballoc ((parmlength + 1) * sizeof (struct harshness_code));
+	    scratchalloc ((parmlength + 1) * sizeof (struct harshness_code));
 
 	  compute_conversion_costs (function, parms, cp, parmlength);
 
@@ -3379,7 +3379,7 @@ add_function_candidate (candidates, fn, arglist, flags)
     }
 
   len = list_length (argnode);
-  convs = make_tree_vec (len);
+  convs = make_scratch_vec (len);
 
   for (i = 0; i < len; ++i)
     {
@@ -3428,7 +3428,7 @@ add_function_candidate (candidates, fn, arglist, flags)
 	break;
       }
 
-  cand = (struct z_candidate *) oballoc (sizeof (struct z_candidate));
+  cand = (struct z_candidate *) scratchalloc (sizeof (struct z_candidate));
 
   cand->fn = fn;
   cand->convs = convs;
@@ -3454,7 +3454,7 @@ add_conv_candidate (candidates, fn, obj, arglist)
   tree totype = TREE_TYPE (TREE_TYPE (fn));
   tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (totype));
   int i, len = list_length (arglist) + 1;
-  tree convs = make_tree_vec (len);
+  tree convs = make_scratch_vec (len);
   tree parmnode = parmlist;
   tree argnode = arglist;
   int viable = 1;
@@ -3505,7 +3505,7 @@ add_conv_candidate (candidates, fn, obj, arglist)
 	break;
       }
 
-  cand = (struct z_candidate *) oballoc (sizeof (struct z_candidate));
+  cand = (struct z_candidate *) scratchalloc (sizeof (struct z_candidate));
 
   cand->fn = fn;
   cand->convs = convs;
@@ -3534,7 +3534,7 @@ build_builtin_candidate (candidates, fnname, type1, type2,
   types[0] = type1;
   types[1] = type2;
 
-  convs = make_tree_vec (args[2] ? 3 : (args[1] ? 2 : 1));
+  convs = make_scratch_vec (args[2] ? 3 : (args[1] ? 2 : 1));
 
   for (i = 0; i < 2; ++i)
     {
@@ -3565,7 +3565,7 @@ build_builtin_candidate (candidates, fnname, type1, type2,
 	viable = 0;
     }      
 
-  cand = (struct z_candidate *) oballoc (sizeof (struct z_candidate));
+  cand = (struct z_candidate *) scratchalloc (sizeof (struct z_candidate));
 
   cand->fn = fnname;
   cand->convs = convs;
@@ -4074,10 +4074,10 @@ add_builtin_candidates (candidates, code, code2, fnname, args, flags)
 	  if (code == COND_EXPR)
 	    {
 	      if (real_lvalue_p (args[i]))
-		types[i] = tree_cons
+		types[i] = scratch_tree_cons
 		  (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
 
-	      types[i] = tree_cons
+	      types[i] = scratch_tree_cons
 		(NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
 	    }
 		
@@ -4095,37 +4095,37 @@ add_builtin_candidates (candidates, code, code2, fnname, args, flags)
 		continue;
 
 	      if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
-		types[i] = tree_cons (NULL_TREE, type, types[i]);
+		types[i] = scratch_tree_cons (NULL_TREE, type, types[i]);
 
 	      type = non_reference (type);
 	      if (i != 0 || ! ref1)
 		{
 		  type = TYPE_MAIN_VARIANT (type_decays_to (type));
 		  if (code == COND_EXPR && TREE_CODE (type) == ENUMERAL_TYPE)
-		    types[i] = tree_cons (NULL_TREE, type, types[i]);
+		    types[i] = scratch_tree_cons (NULL_TREE, type, types[i]);
 		  if (INTEGRAL_TYPE_P (type))
 		    type = type_promotes_to (type);
 		}
 
 	      if (! value_member (type, types[i]))
-		types[i] = tree_cons (NULL_TREE, type, types[i]);
+		types[i] = scratch_tree_cons (NULL_TREE, type, types[i]);
 	    }
 	}
       else
 	{
 	  if (code == COND_EXPR && real_lvalue_p (args[i]))
-	    types[i] = tree_cons
+	    types[i] = scratch_tree_cons
 	      (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
 	  type = non_reference (argtypes[i]);
 	  if (i != 0 || ! ref1)
 	    {
 	      type = TYPE_MAIN_VARIANT (type_decays_to (type));
 	      if (code == COND_EXPR && TREE_CODE (type) == ENUMERAL_TYPE)
-		types[i] = tree_cons (NULL_TREE, type, types[i]);
+		types[i] = scratch_tree_cons (NULL_TREE, type, types[i]);
 	      if (INTEGRAL_TYPE_P (type))
 		type = type_promotes_to (type);
 	    }
-	  types[i] = tree_cons (NULL_TREE, type, types[i]);
+	  types[i] = scratch_tree_cons (NULL_TREE, type, types[i]);
 	}
     }
 
@@ -4161,7 +4161,7 @@ add_template_candidate (candidates, tmpl, explicit_targs,
      int flags;
 {
   int ntparms = DECL_NTPARMS (tmpl);
-  tree targs = make_tree_vec (ntparms);
+  tree targs = make_scratch_vec (ntparms);
   struct z_candidate *cand;
   int i;
   tree fn;
@@ -4188,7 +4188,7 @@ add_template_conv_candidate (candidates, tmpl, obj, arglist, return_type)
      tree tmpl, obj, arglist, return_type;
 {
   int ntparms = DECL_NTPARMS (tmpl);
-  tree targs = make_tree_vec (ntparms);
+  tree targs = make_scratch_vec (ntparms);
   struct z_candidate *cand;
   int i;
   tree fn;
@@ -4306,10 +4306,10 @@ build_user_type_conversion_1 (totype, expr, flags)
     {
       tree t = build_int_2 (0, 0);
       TREE_TYPE (t) = build_pointer_type (totype);
-      args = build_tree_list (NULL_TREE, expr);
+      args = build_scratch_list (NULL_TREE, expr);
       if (TYPE_USES_VIRTUAL_BASECLASSES (totype))
-	args = tree_cons (NULL_TREE, integer_one_node, args);
-      args = tree_cons (NULL_TREE, t, args);
+	args = scratch_tree_cons (NULL_TREE, integer_one_node, args);
+      args = scratch_tree_cons (NULL_TREE, t, args);
 
       ctors = TREE_VALUE (ctors);
     }
@@ -4320,7 +4320,7 @@ build_user_type_conversion_1 (totype, expr, flags)
 
       if (TREE_CODE (ctors) == TEMPLATE_DECL) 
 	{
-	  templates = decl_tree_cons (NULL_TREE, ctors, templates);
+	  templates = scratch_tree_cons (NULL_TREE, ctors, templates);
 	  candidates = 
 	    add_template_candidate (candidates, ctors,
 				    NULL_TREE, args, NULL_TREE, flags);
@@ -4337,7 +4337,7 @@ build_user_type_conversion_1 (totype, expr, flags)
     }
 
   if (convs)
-    args = build_tree_list (NULL_TREE, build_this (expr));
+    args = build_scratch_list (NULL_TREE, build_this (expr));
 
   for (; convs; convs = TREE_CHAIN (convs))
     {
@@ -4362,7 +4362,7 @@ build_user_type_conversion_1 (totype, expr, flags)
 	  {
 	    if (TREE_CODE (fn) == TEMPLATE_DECL)
 	      {
-		templates = decl_tree_cons (NULL_TREE, fn, templates);
+		templates = scratch_tree_cons (NULL_TREE, fn, templates);
 		candidates = 
 		  add_template_candidate (candidates, fn, NULL_TREE,
 					  args, totype, flags);
@@ -4507,7 +4507,7 @@ build_new_function_call (fn, args, obj)
 	{
 	  if (TREE_CODE (t) == TEMPLATE_DECL)
 	    {
-	      templates = decl_tree_cons (NULL_TREE, t, templates);
+	      templates = scratch_tree_cons (NULL_TREE, t, templates);
 	      candidates = add_template_candidate
 		(candidates, t, explicit_targs, args, NULL_TREE,
 		 LOOKUP_NORMAL);  
@@ -4570,13 +4570,13 @@ build_object_call (obj, args)
   if (fns)
     {
       tree fn = TREE_VALUE (fns);
-      mem_args = tree_cons (NULL_TREE, build_this (obj), args);
+      mem_args = scratch_tree_cons (NULL_TREE, build_this (obj), args);
 
       for (; fn; fn = DECL_CHAIN (fn))
 	{
 	  if (TREE_CODE (fn) == TEMPLATE_DECL)
 	    {
-	      templates = decl_tree_cons (NULL_TREE, fn, templates);
+	      templates = scratch_tree_cons (NULL_TREE, fn, templates);
 	      candidates 
 		= add_template_candidate (candidates, fn, NULL_TREE,
 					  mem_args, NULL_TREE, 
@@ -4604,7 +4604,7 @@ build_object_call (obj, args)
 	  {
 	    if (TREE_CODE (fn) == TEMPLATE_DECL) 
 	      {
-		templates = decl_tree_cons (NULL_TREE, fn, templates);
+		templates = scratch_tree_cons (NULL_TREE, fn, templates);
 		candidates = add_template_conv_candidate (candidates,
 							  fn,
 							  obj,
@@ -4718,7 +4718,7 @@ build_new_op (code, flags, arg1, arg2, arg3)
       {
 	tree rval;
 
-	arglist = tree_cons (NULL_TREE, arg2, arg3);
+	arglist = scratch_tree_cons (NULL_TREE, arg2, arg3);
 	if (flags & LOOKUP_GLOBAL)
 	  return build_new_function_call
 	    (lookup_name_nonclass (fnname), arglist, NULL_TREE);
@@ -4746,9 +4746,9 @@ build_new_op (code, flags, arg1, arg2, arg3)
 	if (flags & LOOKUP_GLOBAL)
 	  return build_new_function_call
 	    (lookup_name_nonclass (fnname),
-	     build_tree_list (NULL_TREE, arg1), NULL_TREE);
+	     build_scratch_list (NULL_TREE, arg1), NULL_TREE);
 
-	arglist = tree_cons (NULL_TREE, arg1, build_tree_list (NULL_TREE, arg2));
+	arglist = scratch_tree_cons (NULL_TREE, arg1, build_scratch_list (NULL_TREE, arg2));
 
 	arg1 = TREE_TYPE (arg1);
 
@@ -4814,12 +4814,12 @@ build_new_op (code, flags, arg1, arg2, arg3)
   /* + Koenig lookup */
 
   if (arg2 && arg3)
-    arglist = tree_cons (NULL_TREE, arg1, tree_cons
-		      (NULL_TREE, arg2, build_tree_list (NULL_TREE, arg3)));
+    arglist = scratch_tree_cons (NULL_TREE, arg1, scratch_tree_cons
+		      (NULL_TREE, arg2, build_scratch_list (NULL_TREE, arg3)));
   else if (arg2)
-    arglist = tree_cons (NULL_TREE, arg1, build_tree_list (NULL_TREE, arg2));
+    arglist = scratch_tree_cons (NULL_TREE, arg1, build_scratch_list (NULL_TREE, arg2));
   else
-    arglist = build_tree_list (NULL_TREE, arg1);
+    arglist = build_scratch_list (NULL_TREE, arg1);
 
   if (fns && TREE_CODE (fns) == TREE_LIST)
     fns = TREE_VALUE (fns);
@@ -4827,7 +4827,7 @@ build_new_op (code, flags, arg1, arg2, arg3)
     {
       if (TREE_CODE (fns) == TEMPLATE_DECL)
 	{
-	  templates = decl_tree_cons (NULL_TREE, fns, templates);
+	  templates = scratch_tree_cons (NULL_TREE, fns, templates);
 	  candidates 
 	    = add_template_candidate (candidates, fns, NULL_TREE,
 				      arglist, TREE_TYPE (fnname),
@@ -4845,7 +4845,7 @@ build_new_op (code, flags, arg1, arg2, arg3)
   if (fns)
     {
       tree fn = TREE_VALUE (fns);
-      mem_arglist = tree_cons (NULL_TREE, build_this (arg1), TREE_CHAIN (arglist));
+      mem_arglist = scratch_tree_cons (NULL_TREE, build_this (arg1), TREE_CHAIN (arglist));
       for (; fn; fn = DECL_CHAIN (fn))
 	{
 	  tree this_arglist;
@@ -4858,7 +4858,7 @@ build_new_op (code, flags, arg1, arg2, arg3)
 	  if (TREE_CODE (fn) == TEMPLATE_DECL)
 	    {
 	      /* A member template. */
-	      templates = decl_tree_cons (NULL_TREE, fn, templates);
+	      templates = scratch_tree_cons (NULL_TREE, fn, templates);
 	      candidates 
 		= add_template_candidate (candidates, fn, NULL_TREE,
 					  this_arglist,  TREE_TYPE
@@ -5134,10 +5134,10 @@ convert_like (convs, expr)
 	    tree t = build_int_2 (0, 0);
 	    TREE_TYPE (t) = build_pointer_type (DECL_CONTEXT (fn));
 
-	    args = build_tree_list (NULL_TREE, expr);
+	    args = build_scratch_list (NULL_TREE, expr);
 	    if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
-	      args = tree_cons (NULL_TREE, integer_one_node, args);
-	    args = tree_cons (NULL_TREE, t, args);
+	      args = scratch_tree_cons (NULL_TREE, integer_one_node, args);
+	    args = scratch_tree_cons (NULL_TREE, t, args);
 	  }
 	else
 	  args = build_this (expr);
@@ -5232,19 +5232,19 @@ build_over_call (fn, convs, args, flags)
   int is_method = 0;
 
   if (args && TREE_CODE (args) != TREE_LIST)
-    args = build_tree_list (NULL_TREE, args);
+    args = build_scratch_list (NULL_TREE, args);
   arg = args;
 
   /* The implicit parameters to a constructor are not considered by overload
      resolution, and must be of the proper type.  */
   if (DECL_CONSTRUCTOR_P (fn))
     {
-      converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
+      converted_args = expr_tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
       arg = TREE_CHAIN (arg);
       parm = TREE_CHAIN (parm);
       if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
 	{
-	  converted_args = tree_cons
+	  converted_args = expr_tree_cons
 	    (NULL_TREE, TREE_VALUE (arg), converted_args);
 	  arg = TREE_CHAIN (arg);
 	  parm = TREE_CHAIN (parm);
@@ -5267,7 +5267,7 @@ build_over_call (fn, convs, args, flags)
 	  cp_pedwarn ("passing `%T' as `this' argument of `%#D' discards %s",
 		      TREE_TYPE (argtype), fn, p);
 	}
-      converted_args = tree_cons
+      converted_args = expr_tree_cons
 	(NULL_TREE, convert_force (TREE_VALUE (parm), TREE_VALUE (arg), CONV_C_CAST),
 	 converted_args);
       parm = TREE_CHAIN (parm);
@@ -5311,7 +5311,7 @@ build_over_call (fn, convs, args, flags)
 	  && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
 	val = default_conversion (val);
 #endif
-      converted_args = tree_cons (NULL_TREE, val, converted_args);
+      converted_args = expr_tree_cons (NULL_TREE, val, converted_args);
     }
 
   /* Default arguments */
@@ -5324,7 +5324,7 @@ build_over_call (fn, convs, args, flags)
 	   not in tsubst.  */
 	arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
 			   TREE_VEC_LENGTH (DECL_TI_ARGS (fn)), NULL_TREE);
-      converted_args = tree_cons
+      converted_args = expr_tree_cons
 	(NULL_TREE, convert_default_arg (TREE_VALUE (parm), arg),
 	 converted_args);
     }
@@ -5347,7 +5347,7 @@ build_over_call (fn, convs, args, flags)
 	/* Convert `short' and `char' to full-size `int'.  */
 	val = default_conversion (val);
 
-      converted_args = tree_cons (NULL_TREE, val, converted_args);
+      converted_args = expr_tree_cons (NULL_TREE, val, converted_args);
     }
 
   converted_args = nreverse (converted_args);
@@ -5551,9 +5551,9 @@ build_new_method_call (instance, name, args, basetype_path, flags)
 	  && ! (flags & LOOKUP_HAS_IN_CHARGE))
 	{
 	  flags |= LOOKUP_HAS_IN_CHARGE;
-	  args = tree_cons (NULL_TREE, integer_one_node, args);
+	  args = scratch_tree_cons (NULL_TREE, integer_one_node, args);
 	}
-      mem_args = tree_cons (NULL_TREE, instance_ptr, args);
+      mem_args = scratch_tree_cons (NULL_TREE, instance_ptr, args);
       for (; t; t = DECL_CHAIN (t))
 	{
 	  tree this_arglist;
@@ -5571,7 +5571,7 @@ build_new_method_call (instance, name, args, basetype_path, flags)
 	  if (TREE_CODE (t) == TEMPLATE_DECL)
 	    {
 	      /* A member template. */
-	      templates = decl_tree_cons (NULL_TREE, t, templates);
+	      templates = scratch_tree_cons (NULL_TREE, t, templates);
 	      candidates = 
 		add_template_candidate (candidates, t, explicit_targs,
 					this_arglist,
diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index 9f1aeb0..da5fcd3 100644
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -270,6 +270,7 @@ build_vbase_path (code, type, expr, path, alias_this)
     {
       tree reverse_path = NULL_TREE;
 
+      push_expression_obstack ();
       while (path)
 	{
 	  tree r = copy_node (path);
@@ -278,6 +279,7 @@ build_vbase_path (code, type, expr, path, alias_this)
 	  path = BINFO_INHERITANCE_CHAIN (path);
 	}
       path = reverse_path;
+      pop_obstacks ();
     }
 
   basetype = BINFO_TYPE (path);
@@ -447,9 +449,9 @@ build_vtable_entry (delta, pfn)
   else
     {
       extern int flag_huge_objects;
-      tree elems = tree_cons (NULL_TREE, delta,
-			      tree_cons (NULL_TREE, integer_zero_node,
-					 build_tree_list (NULL_TREE, pfn)));
+      tree elems = expr_tree_cons (NULL_TREE, delta,
+			      expr_tree_cons (NULL_TREE, integer_zero_node,
+					 build_expr_list (NULL_TREE, pfn)));
       tree entry = build (CONSTRUCTOR, vtable_entry_type, NULL_TREE, elems);
 
       /* DELTA is constructed by `size_int', which means it may be an
@@ -3324,7 +3326,7 @@ finish_struct_1 (t, warn_anon)
 	    fdecl = lookup_fnfields (binfo, sname, 0);
 
 	  if (fdecl)
-	    access_decls = tree_cons (access, fdecl, access_decls);
+	    access_decls = scratch_tree_cons (access, fdecl, access_decls);
 	  else
 	    cp_error_at ("no members matching `%D' in `%#T'", x, ctype);
 	  continue;
@@ -5100,7 +5102,7 @@ instantiate_type (lhstype, rhs, complain)
 		if (TREE_CODE (elem) == TEMPLATE_DECL)
 		  {
 		    int n = DECL_NTPARMS (elem);
-		    tree t = make_tree_vec (n);
+		    tree t = make_scratch_vec (n);
 		    int i, d = 0;
 		    i = type_unification
 		      (DECL_INNERMOST_TEMPLATE_PARMS (elem), 
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index f91e680..3cb83df 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -2471,6 +2471,10 @@ extern int cp_tree_equal			PROTO((tree, tree));
 extern int can_free				PROTO((struct obstack *, tree));
 extern tree mapcar				PROTO((tree, tree (*) (tree)));
 extern void debug_binfo				PROTO((tree));
+#define scratchalloc expralloc
+#define scratch_tree_cons expr_tree_cons
+#define build_scratch_list build_expr_list
+#define make_scratch_vec make_temp_vec
 
 /* in typeck.c */
 extern tree condition_conversion		PROTO((tree));
diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c
index b488c0d..2996492 100644
--- a/gcc/cp/cvt.c
+++ b/gcc/cp/cvt.c
@@ -579,7 +579,7 @@ convert_to_reference (reftype, expr, convtype, flags, decl)
 	  && ! CLASSTYPE_ABSTRACT_VIRTUALS (type)
 	  && (rval = build_method_call
 	      (NULL_TREE, ctor_identifier,
-	       build_tree_list (NULL_TREE, expr), TYPE_BINFO (type),
+	       build_expr_list (NULL_TREE, expr), TYPE_BINFO (type),
 	       LOOKUP_NO_CONVERSION|LOOKUP_SPECULATIVELY
 	       | LOOKUP_ONLYCONVERTING)))
 	{
@@ -589,7 +589,7 @@ convert_to_reference (reftype, expr, convtype, flags, decl)
 	    {
 	      tree t = get_temp_name (type, toplevel_bindings_p ());
 	      init = build_method_call (t, ctor_identifier,
-					build_tree_list (NULL_TREE, expr),
+					build_expr_list (NULL_TREE, expr),
 					TYPE_BINFO (type),
 					LOOKUP_NORMAL|LOOKUP_NO_CONVERSION
 					| LOOKUP_ONLYCONVERTING);
@@ -604,7 +604,7 @@ convert_to_reference (reftype, expr, convtype, flags, decl)
 	  else
 	    {
 	      init = build_method_call (NULL_TREE, ctor_identifier,
-					build_tree_list (NULL_TREE, expr),
+					build_expr_list (NULL_TREE, expr),
 					TYPE_BINFO (type),
 					LOOKUP_NORMAL|LOOKUP_NO_CONVERSION
 					|LOOKUP_ONLYCONVERTING);
@@ -711,18 +711,18 @@ convert_to_aggr (type, expr, msgp, protect)
   can_be_private = 0;
   can_be_protected = IDENTIFIER_CLASS_VALUE (name) || name == current_class_name;
 
-  parmlist = build_tree_list (NULL_TREE, expr);
-  parmtypes = tree_cons (NULL_TREE, TREE_TYPE (expr), void_list_node);
+  parmlist = build_expr_list (NULL_TREE, expr);
+  parmtypes = scratch_tree_cons (NULL_TREE, TREE_TYPE (expr), void_list_node);
 
   if (TYPE_USES_VIRTUAL_BASECLASSES (basetype))
     {
-      parmtypes = tree_cons (NULL_TREE, integer_type_node, parmtypes);
-      parmlist = tree_cons (NULL_TREE, integer_one_node, parmlist);
+      parmtypes = expr_tree_cons (NULL_TREE, integer_type_node, parmtypes);
+      parmlist = scratch_tree_cons (NULL_TREE, integer_one_node, parmlist);
     }
 
   /* The type of the first argument will be filled in inside the loop.  */
-  parmlist = tree_cons (NULL_TREE, integer_zero_node, parmlist);
-  parmtypes = tree_cons (NULL_TREE, build_pointer_type (basetype), parmtypes);
+  parmlist = expr_tree_cons (NULL_TREE, integer_zero_node, parmlist);
+  parmtypes = scratch_tree_cons (NULL_TREE, build_pointer_type (basetype), parmtypes);
 
   /* No exact conversion was found.  See if an approximate
      one will do.  */
@@ -1119,7 +1119,7 @@ ocp_convert (type, expr, convtype, flags)
 	    }
 	  if (ctor)
 	    ctor = build_method_call (NULL_TREE, ctor_identifier,
-				      build_tree_list (NULL_TREE, ctor),
+				      build_expr_list (NULL_TREE, ctor),
 				      TYPE_BINFO (type), flags);
 	  if (ctor)
 	    return build_cplus_new (type, ctor);
@@ -1139,7 +1139,7 @@ ocp_convert (type, expr, convtype, flags)
 
 	  if (TYPE_HAS_CONSTRUCTOR (complete_type (type)))
 	    ctor = build_method_call (NULL_TREE, ctor_identifier,
-				      build_tree_list (NULL_TREE, e),
+				      build_expr_list (NULL_TREE, e),
 				      TYPE_BINFO (type),
 				      (flags & LOOKUP_NORMAL)
 				      | LOOKUP_SPECULATIVELY
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 1046209..ad80b45 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -7045,7 +7045,7 @@ expand_static_init (decl, init)
 	  end_anon_func ();
 	  mark_addressable (cleanup);
 	  cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
-	  fcall = build_function_call (Atexit, tree_cons (NULL_TREE, cleanup, NULL_TREE));
+	  fcall = build_function_call (Atexit, expr_tree_cons (NULL_TREE, cleanup, NULL_TREE));
 	  expand_expr_stmt (fcall);
 	}
 
@@ -11318,7 +11318,7 @@ start_function (declspecs, declarator, attrs, pre_parsed_p)
 	  && ! CLASSTYPE_GOT_SEMICOLON (restype))
 	{
 	  cp_error ("semicolon missing after declaration of `%#T'", restype);
-	  shadow_tag (build_tree_list (NULL_TREE, restype));
+	  shadow_tag (build_expr_list (NULL_TREE, restype));
 	  CLASSTYPE_GOT_SEMICOLON (restype) = 1;
 	  if (TREE_CODE (fntype) == FUNCTION_TYPE)
 	    fntype = build_function_type (integer_type_node,
@@ -12013,7 +12013,7 @@ finish_function (lineno, call_poplevel, nested)
 			  expand_expr_stmt
 			    (build_scoped_method_call
 			     (current_class_ref, vb, dtor_identifier,
-			      build_tree_list (NULL_TREE, integer_zero_node)));
+			      build_expr_list (NULL_TREE, integer_zero_node)));
 			}
 		      vbases = TREE_CHAIN (vbases);
 		    }
@@ -12038,8 +12038,8 @@ finish_function (lineno, call_poplevel, nested)
 							       error_mark_node),
 						       NULL_PTR),
 				   ansi_opname[(int) DELETE_EXPR],
-				   tree_cons (NULL_TREE, current_class_ptr,
-					      build_tree_list (NULL_TREE, virtual_size)),
+				   expr_tree_cons (NULL_TREE, current_class_ptr,
+					      build_expr_list (NULL_TREE, virtual_size)),
 				   NULL_TREE, LOOKUP_NORMAL);
 	  else if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
 	    exprstmt = build_x_delete (ptr_type_node, current_class_ptr, 0,
@@ -12675,8 +12675,8 @@ maybe_build_cleanup_1 (decl, auto_delete)
 
       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
 	  && ! TYPE_HAS_DESTRUCTOR (type))
-	rval = build_compound_expr (tree_cons (NULL_TREE, rval,
-					       build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
+	rval = build_compound_expr (expr_tree_cons (NULL_TREE, rval,
+					       build_expr_list (NULL_TREE, build_vbase_delete (type, decl))));
 
       if (TREE_CODE (decl) != PARM_DECL)
 	resume_momentary (temp);
diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index 325090a..c9c7f7c 100644
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -1446,7 +1446,7 @@ check_classfn (ctype, function)
 			/* This function might be an instantiation
 			   or specialization of fndecl.  */
 			templates = 
-			  tree_cons (NULL_TREE, fndecl, templates);
+			  scratch_tree_cons (NULL_TREE, fndecl, templates);
 		    }
 #endif
 		  fndecl = DECL_CHAIN (fndecl);
@@ -1462,7 +1462,7 @@ check_classfn (ctype, function)
 	       the names don't match, there is some specialization
 	       occurring.  */
 	    templates = 
-	      tree_cons (NULL_TREE, fndecl, templates);
+	      scratch_tree_cons (NULL_TREE, fndecl, templates);
 	}
     }
 
@@ -2217,7 +2217,7 @@ finish_anon_union (anon_union_decl)
       DECL_INITIAL (decl) = NULL_TREE;
       /* If there's a cleanup to do, it belongs in the
 	 TREE_PURPOSE of the following TREE_LIST.  */
-      elems = tree_cons (NULL_TREE, decl, elems);
+      elems = scratch_tree_cons (NULL_TREE, decl, elems);
       TREE_TYPE (elems) = type;
     }
   if (static_p)
@@ -3598,7 +3598,7 @@ build_expr_from_tree (t)
 	chain = TREE_CHAIN (t);
 	if (chain && chain != void_type_node)
 	  chain = build_expr_from_tree (chain);
-	return tree_cons (purpose, value, chain);
+	return expr_tree_cons (purpose, value, chain);
       }
 
     case COMPONENT_REF:
@@ -3645,7 +3645,7 @@ reparse_decl_as_expr (type, decl)
 {
   decl = build_expr_from_tree (decl);
   if (type)
-    return build_functional_cast (type, build_tree_list (NULL_TREE, decl));
+    return build_functional_cast (type, build_expr_list (NULL_TREE, decl));
   else
     return decl;
 }
diff --git a/gcc/cp/except.c b/gcc/cp/except.c
index 355485a..ef4b6e0 100644
--- a/gcc/cp/except.c
+++ b/gcc/cp/except.c
@@ -487,11 +487,11 @@ expand_start_catch_block (declspecs, declarator)
 	init_type = build_reference_type (init_type);
 
       exp = saved_throw_value;
-      exp = tree_cons (NULL_TREE,
+      exp = expr_tree_cons (NULL_TREE,
 		       build_eh_type_type (TREE_TYPE (decl)),
-		       tree_cons (NULL_TREE,
+		       expr_tree_cons (NULL_TREE,
 				  saved_throw_type,
-				  tree_cons (NULL_TREE, exp, NULL_TREE)));
+				  expr_tree_cons (NULL_TREE, exp, NULL_TREE)));
       exp = build_function_call (CatchMatch, exp);
       call_rtx = expand_call (exp, NULL_RTX, 0);
       assemble_external (TREE_OPERAND (CatchMatch, 0));
@@ -618,7 +618,7 @@ do_unwind (inner_throw_label)
   rtx temp;
 
   /* Call to  __builtin_return_address. */
-  params = tree_cons (NULL_TREE, integer_zero_node, NULL_TREE);
+  params = expr_tree_cons (NULL_TREE, integer_zero_node, NULL_TREE);
   fcall = build_function_call (BuiltinReturnAddress, params);
   next_pc = expand_expr (fcall, NULL_RTX, Pmode, 0);
   /* In the return, the new pc is pc+8, as the value coming in is
@@ -671,14 +671,14 @@ do_unwind (inner_throw_label)
 #if 0
   /* I would like to do this here, but the move below doesn't seem to work.  */
   /* Call to  __builtin_return_address.  */
-  params = tree_cons (NULL_TREE, integer_zero_node, NULL_TREE);
+  params = expr_tree_cons (NULL_TREE, integer_zero_node, NULL_TREE);
   fcall = build_function_call (BuiltinReturnAddress, params);
   next_pc = expand_expr (fcall, NULL_RTX, Pmode, 0);
 
   emit_move_insn (next_pc, inner_throw_label);
   /* So, for now, just pass throw label to stack unwinder.  */
 #endif
-  params = tree_cons (NULL_TREE, make_tree (ptr_type_node,
+  params = expr_tree_cons (NULL_TREE, make_tree (ptr_type_node,
 					    inner_throw_label), NULL_TREE);
   
   do_function_call (Unwind, params, NULL_TREE);
@@ -752,7 +752,7 @@ expand_builtin_throw ()
 
   /* search for an exception handler for the saved_pc */
   handler = do_function_call (FirstExceptionMatch,
-			      tree_cons (NULL_TREE, saved_pc,
+			      expr_tree_cons (NULL_TREE, saved_pc,
 					 NULL_TREE),
 			      ptr_type_node);
   assemble_external (TREE_OPERAND (FirstExceptionMatch, 0));
@@ -800,7 +800,7 @@ expand_builtin_throw ()
   emit_move_insn (next_pc,
 		  gen_rtx (MEM, Pmode, plus_constant (hard_frame_pointer_rtx, -4)));
 #else
-  params = tree_cons (NULL_TREE, integer_zero_node, NULL_TREE);
+  params = expr_tree_cons (NULL_TREE, integer_zero_node, NULL_TREE);
   fcall = build_function_call (BuiltinReturnAddress, params);
   next_pc = expand_expr (fcall, NULL_RTX, Pmode, 0);
 #endif
@@ -969,11 +969,11 @@ expand_end_eh_spec (raises)
 	{
 	  /* check TREE_VALUE (raises) here */
 	  exp = saved_throw_value;
-	  exp = tree_cons (NULL_TREE,
+	  exp = expr_tree_cons (NULL_TREE,
 			   build_eh_type_type (match_type),
-			   tree_cons (NULL_TREE,
+			   expr_tree_cons (NULL_TREE,
 				      saved_throw_type,
-				      tree_cons (NULL_TREE, exp, NULL_TREE)));
+				      expr_tree_cons (NULL_TREE, exp, NULL_TREE)));
 	  exp = build_function_call (CatchMatch, exp);
 	  assemble_external (TREE_OPERAND (CatchMatch, 0));
 
@@ -1137,7 +1137,7 @@ expand_throw (exp)
 
 	  /* Make a copy of the thrown object.  WP 15.1.5  */
 	  exp = build_new (NULL_TREE, TREE_TYPE (exp),
-			   build_tree_list (NULL_TREE, exp),
+			   build_expr_list (NULL_TREE, exp),
 			   0);
 
 	  if (exp == error_mark_node)
diff --git a/gcc/cp/expr.c b/gcc/cp/expr.c
index a14695d..2162b0d 100644
--- a/gcc/cp/expr.c
+++ b/gcc/cp/expr.c
@@ -112,7 +112,7 @@ cplus_expand_expr (exp, target, tmode, modifier)
 	       parameter value.  */
 	    mark_addressable (slot);
 	    if (TREE_PERMANENT (args))
-	      args = tree_cons (0, build1 (ADDR_EXPR, type, slot),
+	      args = expr_tree_cons (0, build1 (ADDR_EXPR, type, slot),
 				TREE_CHAIN (args));
 	    else
 	      TREE_VALUE (args) = build1 (ADDR_EXPR, type, slot);
diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index 826c520..985fae8 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -173,7 +173,7 @@ perform_member_init (member, name, init, explicit)
       /* Since `init' is already a TREE_LIST on the current_member_init_list,
 	 only build it into one if we aren't already a list.  */
       if (init != NULL_TREE && TREE_CODE (init) != TREE_LIST)
-	init = build_tree_list (NULL_TREE, init);
+	init = build_expr_list (NULL_TREE, init);
 
       decl = build_component_ref (current_class_ref, name, NULL_TREE, explicit);
 
@@ -489,7 +489,7 @@ build_partial_cleanup_for (binfo)
 {
   return build_scoped_method_call
     (current_class_ref, binfo, dtor_identifier,
-     build_tree_list (NULL_TREE, integer_zero_node));
+     build_expr_list (NULL_TREE, integer_zero_node));
 }
 
 /* Perform whatever initializations have yet to be done on the base
@@ -1287,14 +1287,14 @@ expand_default_init (binfo, true_exp, exp, init, alias_this, flags)
       return;
     }
   else
-    parms = build_tree_list (NULL_TREE, init);
+    parms = build_expr_list (NULL_TREE, init);
 
   if (TYPE_USES_VIRTUAL_BASECLASSES (type))
     {
       if (true_exp == exp)
-	parms = tree_cons (NULL_TREE, integer_one_node, parms);
+	parms = expr_tree_cons (NULL_TREE, integer_one_node, parms);
       else
-	parms = tree_cons (NULL_TREE, integer_zero_node, parms);
+	parms = expr_tree_cons (NULL_TREE, integer_zero_node, parms);
       flags |= LOOKUP_HAS_IN_CHARGE;
     }
 
@@ -1549,7 +1549,7 @@ expand_aggr_init_1 (binfo, true_exp, exp, init, alias_this, flags)
 		{
 		  /* See if there is a constructor for``type'' that takes a
 		     ``ttype''-typed object.  */
-		  tree parms = build_tree_list (NULL_TREE, init);
+		  tree parms = build_expr_list (NULL_TREE, init);
 		  tree as_cons = NULL_TREE;
 		  if (TYPE_HAS_CONSTRUCTOR (type))
 		    as_cons = build_method_call (exp, ctor_identifier,
@@ -2508,7 +2508,7 @@ build_new (placement, decl, init, use_global_new)
     {
       rval = build_builtin_call (build_pointer_type (true_type),
 				 has_array ? BIVN : BIN,
-				 build_tree_list (NULL_TREE, size));
+				 build_expr_list (NULL_TREE, size));
       TREE_CALLS_NEW (rval) = 1;
     }
 
@@ -2538,8 +2538,8 @@ build_new (placement, decl, init, use_global_new)
       rval = cp_convert (build_pointer_type (true_type), rval);
       TREE_CALLS_NEW (rval) = 1;
       TREE_SIDE_EFFECTS (rval) = 1;
-      rval = build_compound_expr (tree_cons (NULL_TREE, exp1,
-					     build_tree_list (NULL_TREE, rval)));
+      rval = build_compound_expr (expr_tree_cons (NULL_TREE, exp1,
+					     build_expr_list (NULL_TREE, rval)));
     }
 
   if (rval == error_mark_node)
@@ -2590,7 +2590,7 @@ build_new (placement, decl, init, use_global_new)
 
 	  if (rval && TYPE_USES_VIRTUAL_BASECLASSES (true_type))
 	    {
-	      init = tree_cons (NULL_TREE, integer_one_node, init);
+	      init = expr_tree_cons (NULL_TREE, integer_one_node, init);
 	      flags |= LOOKUP_HAS_IN_CHARGE;
 	    }
 
@@ -2717,7 +2717,7 @@ build_new (placement, decl, init, use_global_new)
 
   if (pending_sizes)
     rval = build_compound_expr (chainon (pending_sizes,
-					 build_tree_list (NULL_TREE, rval)));
+					 build_expr_list (NULL_TREE, rval)));
 
   return rval;
 }
@@ -2785,7 +2785,7 @@ build_vec_delete_1 (base, maxindex, type, auto_delete_vec, auto_delete,
 						   1));
       /* This is the real size */
       virtual_size = size_binop (PLUS_EXPR, virtual_size, BI_header_size);
-      body = build_tree_list (NULL_TREE,
+      body = build_expr_list (NULL_TREE,
 			      build_x_delete (ptype, base_tbd,
 					      2 | use_global_delete,
 					      virtual_size));
@@ -2797,24 +2797,24 @@ build_vec_delete_1 (base, maxindex, type, auto_delete_vec, auto_delete,
   else
     body = NULL_TREE;
 
-  body = tree_cons (NULL_TREE,
+  body = expr_tree_cons (NULL_TREE,
 		    build_delete (ptype, tbase, auto_delete,
 				  LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1),
 		    body);
 
-  body = tree_cons (NULL_TREE,
+  body = expr_tree_cons (NULL_TREE,
 		    build_modify_expr (tbase, NOP_EXPR, build (MINUS_EXPR, ptype, tbase, size_exp)),
 		    body);
 
-  body = tree_cons (NULL_TREE,
+  body = expr_tree_cons (NULL_TREE,
 		    build (EXIT_EXPR, void_type_node,
 			   build (EQ_EXPR, boolean_type_node, base, tbase)),
 		    body);
 
   loop = build (LOOP_EXPR, void_type_node, build_compound_expr (body));
 
-  loop = tree_cons (NULL_TREE, tbase_init,
-		    tree_cons (NULL_TREE, loop, NULL_TREE));
+  loop = expr_tree_cons (NULL_TREE, tbase_init,
+		    expr_tree_cons (NULL_TREE, loop, NULL_TREE));
   loop = build_compound_expr (loop);
 
  no_destructor:
@@ -2855,8 +2855,8 @@ build_vec_delete_1 (base, maxindex, type, auto_delete_vec, auto_delete,
 
   if (loop && deallocate_expr != integer_zero_node)
     {
-      body = tree_cons (NULL_TREE, loop,
-			tree_cons (NULL_TREE, deallocate_expr, NULL_TREE));
+      body = expr_tree_cons (NULL_TREE, loop,
+			expr_tree_cons (NULL_TREE, deallocate_expr, NULL_TREE));
       body = build_compound_expr (body);
     }
   else
@@ -3158,7 +3158,7 @@ build_x_delete (type, addr, which_delete, virtual_size)
     rval = build_opfncall (code, LOOKUP_NORMAL, addr, virtual_size, NULL_TREE);
   else
     rval = build_builtin_call (void_type_node, use_vec_delete ? BIVD : BID,
-			       build_tree_list (NULL_TREE, addr));
+			       build_expr_list (NULL_TREE, addr));
   return rval;
 }
 
@@ -3209,7 +3209,7 @@ build_delete (type, addr, auto_delete, flags, use_global_delete)
 	{
 	  /* Call the builtin operator delete.  */
 	  return build_builtin_call (void_type_node, BID,
-				     build_tree_list (NULL_TREE, addr));
+				     build_expr_list (NULL_TREE, addr));
 	}
       if (TREE_SIDE_EFFECTS (addr))
 	addr = save_expr (addr);
@@ -3267,7 +3267,7 @@ build_delete (type, addr, auto_delete, flags, use_global_delete)
 
       /* Call the builtin operator delete.  */
       return build_builtin_call (void_type_node, BID,
-				 build_tree_list (NULL_TREE, addr));
+				 build_expr_list (NULL_TREE, addr));
     }
 
   /* Below, we will reverse the order in which these calls are made.
@@ -3284,7 +3284,7 @@ build_delete (type, addr, auto_delete, flags, use_global_delete)
 	  tree cond = fold (build (BIT_AND_EXPR, integer_type_node,
 				   auto_delete, integer_one_node));
 	  tree call = build_builtin_call
-	    (void_type_node, BID, build_tree_list (NULL_TREE, addr));
+	    (void_type_node, BID, build_expr_list (NULL_TREE, addr));
 
 	  cond = fold (build (COND_EXPR, void_type_node, cond,
 			      call, void_zero_node));
@@ -3298,7 +3298,7 @@ build_delete (type, addr, auto_delete, flags, use_global_delete)
 	passed_auto_delete = auto_delete;
 
       expr = build_method_call
-	(ref, dtor_identifier, build_tree_list (NULL_TREE, passed_auto_delete),
+	(ref, dtor_identifier, build_expr_list (NULL_TREE, passed_auto_delete),
 	 NULL_TREE, flags);
 
       if (do_delete)
@@ -3337,14 +3337,14 @@ build_delete (type, addr, auto_delete, flags, use_global_delete)
 	  cond = build (COND_EXPR, void_type_node,
 			build (BIT_AND_EXPR, integer_type_node, auto_delete, integer_one_node),
 			build_builtin_call (void_type_node, BID,
-					    build_tree_list (NULL_TREE, addr)),
+					    build_expr_list (NULL_TREE, addr)),
 			void_zero_node);
 	}
       else
 	cond = NULL_TREE;
 
       if (cond)
-	exprstmt = build_tree_list (NULL_TREE, cond);
+	exprstmt = build_expr_list (NULL_TREE, cond);
 
       if (base_binfo
 	  && ! TREE_VIA_VIRTUAL (base_binfo)
@@ -3359,8 +3359,8 @@ build_delete (type, addr, auto_delete, flags, use_global_delete)
 
 	  expr = build_scoped_method_call
 	    (ref, base_binfo, dtor_identifier,
-	     build_tree_list (NULL_TREE, this_auto_delete));
-	  exprstmt = tree_cons (NULL_TREE, expr, exprstmt);
+	     build_expr_list (NULL_TREE, this_auto_delete));
+	  exprstmt = expr_tree_cons (NULL_TREE, expr, exprstmt);
 	}
 
       /* Take care of the remaining baseclasses.  */
@@ -3373,9 +3373,9 @@ build_delete (type, addr, auto_delete, flags, use_global_delete)
 
 	  expr = build_scoped_method_call
 	    (ref, base_binfo, dtor_identifier,
-	     build_tree_list (NULL_TREE, integer_zero_node));
+	     build_expr_list (NULL_TREE, integer_zero_node));
 
-	  exprstmt = tree_cons (NULL_TREE, expr, exprstmt);
+	  exprstmt = expr_tree_cons (NULL_TREE, expr, exprstmt);
 	}
 
       for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
@@ -3387,7 +3387,7 @@ build_delete (type, addr, auto_delete, flags, use_global_delete)
 	      tree this_member = build_component_ref (ref, DECL_NAME (member), NULL_TREE, 0);
 	      tree this_type = TREE_TYPE (member);
 	      expr = build_delete (this_type, this_member, integer_two_node, flags, 0);
-	      exprstmt = tree_cons (NULL_TREE, expr, exprstmt);
+	      exprstmt = expr_tree_cons (NULL_TREE, expr, exprstmt);
 	    }
 	}
 
@@ -3414,7 +3414,7 @@ build_vbase_delete (type, decl)
     {
       tree this_addr = convert_force (build_pointer_type (BINFO_TYPE (vbases)),
 				      addr, 0);
-      result = tree_cons (NULL_TREE,
+      result = expr_tree_cons (NULL_TREE,
 			  build_delete (TREE_TYPE (this_addr), this_addr,
 					integer_zero_node,
 					LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0),
diff --git a/gcc/cp/lex.c b/gcc/cp/lex.c
index d1b7d69..9a79535 100644
--- a/gcc/cp/lex.c
+++ b/gcc/cp/lex.c
@@ -4461,7 +4461,7 @@ make_lang_type (code)
     pi[--i] = 0;
 
   TYPE_LANG_SPECIFIC (t) = (struct lang_type *) pi;
-  CLASSTYPE_AS_LIST (t) = build_tree_list (NULL_TREE, t);
+  CLASSTYPE_AS_LIST (t) = build_expr_list (NULL_TREE, t);
   SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
   CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
   CLASSTYPE_VBASE_SIZE (t) = integer_zero_node;
diff --git a/gcc/cp/method.c b/gcc/cp/method.c
index 6b77e78..3dc46d0 100644
--- a/gcc/cp/method.c
+++ b/gcc/cp/method.c
@@ -1375,7 +1375,7 @@ build_opfncall (code, flags, xarg1, xarg2, arg3)
     case VEC_NEW_EXPR:
     case NEW_EXPR:
       {
-	tree args = tree_cons (NULL_TREE, xarg2, arg3);
+	tree args = expr_tree_cons (NULL_TREE, xarg2, arg3);
 	fnname = ansi_opname[(int) code];
 	if (flags & LOOKUP_GLOBAL)
 	  return build_overload_call (fnname, args, flags & LOOKUP_COMPLAIN);
@@ -1401,7 +1401,7 @@ build_opfncall (code, flags, xarg1, xarg2, arg3)
 	fnname = ansi_opname[(int) code];
 	if (flags & LOOKUP_GLOBAL)
 	  return build_overload_call (fnname,
-				      build_tree_list (NULL_TREE, xarg1),
+				      build_expr_list (NULL_TREE, xarg1),
 				      flags & LOOKUP_COMPLAIN);
 	arg1 = TREE_TYPE (xarg1);
 
@@ -1425,8 +1425,8 @@ build_opfncall (code, flags, xarg1, xarg2, arg3)
 	  (build_indirect_ref (build1 (NOP_EXPR, arg1,
 				       error_mark_node),
 			       NULL_PTR),
-	   fnname, tree_cons (NULL_TREE, xarg1,
-			       build_tree_list (NULL_TREE, xarg2)),
+	   fnname, expr_tree_cons (NULL_TREE, xarg1,
+			       build_expr_list (NULL_TREE, xarg2)),
 	   NULL_TREE, flags);
 #if 0
 	/* This can happen when operator delete is protected.  */
@@ -1604,25 +1604,25 @@ build_opfncall (code, flags, xarg1, xarg2, arg3)
     }
   else if (code == COND_EXPR)
     {
-      parms = tree_cons (NULL_TREE, xarg2, build_tree_list (NULL_TREE, arg3));
+      parms = expr_tree_cons (NULL_TREE, xarg2, build_expr_list (NULL_TREE, arg3));
       rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
     }
   else if (code == METHOD_CALL_EXPR)
     {
       /* must be a member function.  */
-      parms = tree_cons (NULL_TREE, xarg2, arg3);
+      parms = expr_tree_cons (NULL_TREE, xarg2, arg3);
       return build_method_call (xarg1, fnname, parms, NULL_TREE,
 				LOOKUP_NORMAL);
     }
   else if (fields1)
     {
-      parms = build_tree_list (NULL_TREE, xarg2);
+      parms = build_expr_list (NULL_TREE, xarg2);
       rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
     }
   else
     {
-      parms = tree_cons (NULL_TREE, xarg1,
-			 build_tree_list (NULL_TREE, xarg2));
+      parms = expr_tree_cons (NULL_TREE, xarg1,
+			 build_expr_list (NULL_TREE, xarg2));
       rval = build_overload_call (fnname, parms, flags);
     }
 
@@ -1919,9 +1919,9 @@ emit_thunk (thunk_fndecl)
     t = build_int_2 (delta, -1 * (delta < 0));
     TREE_TYPE (t) = signed_type (sizetype);
     t = fold (build (PLUS_EXPR, TREE_TYPE (a), a, t));
-    t = tree_cons (NULL_TREE, t, NULL_TREE);
+    t = expr_tree_cons (NULL_TREE, t, NULL_TREE);
     for (a = TREE_CHAIN (a); a; a = TREE_CHAIN (a))
-      t = tree_cons (NULL_TREE, a, t);
+      t = expr_tree_cons (NULL_TREE, a, t);
     t = nreverse (t);
     t = build_call (function, TREE_TYPE (TREE_TYPE (function)), t);
     c_expand_return (t);
@@ -2102,7 +2102,7 @@ do_build_assign_ref (fndecl)
 	     CONV_IMPLICIT|CONV_CONST, LOOKUP_COMPLAIN, NULL_TREE);
 	  p = convert_from_reference (p);
 	  p = build_member_call (basetype, ansi_opname [MODIFY_EXPR],
-				 build_tree_list (NULL_TREE, p));
+				 build_expr_list (NULL_TREE, p));
 	  expand_expr_stmt (p);
 	}
       for (; fields; fields = TREE_CHAIN (fields))
diff --git a/gcc/cp/parse.y b/gcc/cp/parse.y
index 4449d92..dfc59ae 100644
--- a/gcc/cp/parse.y
+++ b/gcc/cp/parse.y
@@ -1049,20 +1049,20 @@ already_scoped_stmt:
 
 nontrivial_exprlist:
 	  expr_no_commas ',' expr_no_commas
-		{ $$ = tree_cons (NULL_TREE, $$, 
-		                  build_tree_list (NULL_TREE, $3)); }
+		{ $$ = expr_tree_cons (NULL_TREE, $$, 
+		                  build_expr_list (NULL_TREE, $3)); }
 	| expr_no_commas ',' error
-		{ $$ = tree_cons (NULL_TREE, $$, 
-		                  build_tree_list (NULL_TREE, error_mark_node)); }
+		{ $$ = expr_tree_cons (NULL_TREE, $$, 
+		                  build_expr_list (NULL_TREE, error_mark_node)); }
 	| nontrivial_exprlist ',' expr_no_commas
-		{ chainon ($$, build_tree_list (NULL_TREE, $3)); }
+		{ chainon ($$, build_expr_list (NULL_TREE, $3)); }
 	| nontrivial_exprlist ',' error
-		{ chainon ($$, build_tree_list (NULL_TREE, error_mark_node)); }
+		{ chainon ($$, build_expr_list (NULL_TREE, error_mark_node)); }
 	;
 
 nonnull_exprlist:
 	  expr_no_commas
-		{ $$ = build_tree_list (NULL_TREE, $$); }
+		{ $$ = build_expr_list (NULL_TREE, $$); }
 	| nontrivial_exprlist
 	;
 
@@ -2169,16 +2169,16 @@ initlist:
 	  init
 		{ $$ = build_tree_list (NULL_TREE, $$); }
 	| initlist ',' init
-		{ $$ = tree_cons (NULL_TREE, $3, $$); }
+		{ $$ = expr_tree_cons (NULL_TREE, $3, $$); }
 	/* These are for labeled elements.  */
 	| '[' expr_no_commas ']' init
-		{ $$ = build_tree_list ($2, $4); }
+		{ $$ = build_expr_list ($2, $4); }
 	| initlist ',' CASE expr_no_commas ':' init
-		{ $$ = tree_cons ($4, $6, $$); }
+		{ $$ = expr_tree_cons ($4, $6, $$); }
 	| identifier ':' init
-		{ $$ = build_tree_list ($$, $3); }
+		{ $$ = build_expr_list ($$, $3); }
 	| initlist ',' identifier ':' init
-		{ $$ = tree_cons ($3, $5, $$); }
+		{ $$ = expr_tree_cons ($3, $5, $$); }
 	;
 
 fn.defpen:
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 8e1e42c..1e342e8 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -380,7 +380,7 @@ determine_explicit_specialization (template_id, type, targs_out,
       if (list_length (TREE_OPERAND (template_id, 1)) > DECL_NTPARMS (fn))
 	continue;
 
-      targs = make_tree_vec (DECL_NTPARMS (fn));
+      targs = make_scratch_vec (DECL_NTPARMS (fn));
 
       /* We allow incomplete unification here, because we are going to
 	 check all the functions. */
@@ -417,7 +417,7 @@ determine_explicit_specialization (template_id, type, targs_out,
 		}
 	    }
 
-	  matching_fns = tree_cons (fn, targs, matching_fns);
+	  matching_fns = scratch_tree_cons (fn, targs, matching_fns);
 	}
     }
 
@@ -3438,6 +3438,7 @@ instantiate_template (tmpl, targ_ptr)
 	}
       TREE_VEC_ELT (targ_ptr, i) = copy_to_permanent (t);
     }
+  targ_ptr = copy_to_permanent (targ_ptr);
 
   if (DECL_TEMPLATE_INFO (tmpl) && DECL_TI_ARGS (tmpl))
     targ_ptr = add_to_template_args (DECL_TI_ARGS (tmpl), targ_ptr);
@@ -3491,10 +3492,10 @@ fn_type_unification (fn, explicit_targs, targs, args, return_type, strict)
     {
       /* This is a template conversion operator.  Use the return types
          as well as the argument types.  */
-      fn_arg_types = tree_cons (NULL_TREE, 
+      fn_arg_types = scratch_tree_cons (NULL_TREE, 
 				TREE_TYPE (TREE_TYPE (fn)),
 				fn_arg_types);
-      decl_arg_types = tree_cons (NULL_TREE,
+      decl_arg_types = scratch_tree_cons (NULL_TREE,
 				  return_type,
 				  decl_arg_types);
     }
@@ -3653,7 +3654,7 @@ type_unification_real (tparms, targs, parms, args, nsubsts, subr,
 	      nsubsts = 0;
 	      ntparms = DECL_NTPARMS (arg);
 	      targs = (tree *) alloca (sizeof (tree) * ntparms);
-	      parm = tree_cons (NULL_TREE, parm, NULL_TREE);
+	      parm = expr_tree_cons (NULL_TREE, parm, NULL_TREE);
 	      return 
 		type_unification (DECL_INNERMOST_TEMPLATE_PARMS (arg), 
 				  targs,
@@ -4029,7 +4030,7 @@ get_bindings (fn, decl)
      tree fn, decl;
 {
   int ntparms = DECL_NTPARMS (fn);
-  tree targs = make_tree_vec (ntparms);
+  tree targs = make_scratch_vec (ntparms);
   int i;
 
   i = fn_type_unification (fn, NULL_TREE, targs, 
diff --git a/gcc/cp/rtti.c b/gcc/cp/rtti.c
index dd82e34..e7b83d3 100644
--- a/gcc/cp/rtti.c
+++ b/gcc/cp/rtti.c
@@ -269,7 +269,7 @@ build_x_typeid (exp)
       tree bad = throw_bad_typeid ();
 
       bad = build_compound_expr
-	(tree_cons (NULL_TREE, bad, build_tree_list
+	(expr_tree_cons (NULL_TREE, bad, build_expr_list
 		    (NULL_TREE, cp_convert (type, integer_zero_node))));
       exp = build (COND_EXPR, type, cond, exp, bad);
     }
@@ -624,8 +624,8 @@ build_dynamic_cast_1 (type, expr)
 	    {
 	      expr1 = throw_bad_cast ();
 	      expr1 = build_compound_expr
-		(tree_cons (NULL_TREE, expr1,
-			    build_tree_list (NULL_TREE, cp_convert (type, integer_zero_node))));
+		(expr_tree_cons (NULL_TREE, expr1,
+			    build_expr_list (NULL_TREE, cp_convert (type, integer_zero_node))));
 	      TREE_TYPE (expr1) = type;
 	      result = save_expr (result);
 	      return build (COND_EXPR, type, result, result, expr1);
@@ -810,7 +810,7 @@ expand_class_desc (tdecl, type)
 	   (NULL_TREE, isvir, tree_cons
 	    (NULL_TREE, access, NULL_TREE)))));
       TREE_HAS_CONSTRUCTOR (elt) = TREE_CONSTANT (elt) = TREE_STATIC (elt) = 1;
-      elts = tree_cons (NULL_TREE, elt, elts);
+      elts = expr_tree_cons (NULL_TREE, elt, elts);
       base_cnt++;
     }
 #if 0
@@ -837,10 +837,10 @@ expand_class_desc (tdecl, type)
       offset = BINFO_OFFSET (vb);
       isvir = build_int_2 (1, 0);
 
-      base_list = tree_cons (NULL_TREE, base, base_list);
-      isvir_list = tree_cons (NULL_TREE, isvir, isvir_list);
-      acc_list = tree_cons (NULL_TREE, access, acc_list);
-      off_list = tree_cons (NULL_TREE, offset, off_list);
+      base_list = expr_tree_cons (NULL_TREE, base, base_list);
+      isvir_list = expr_tree_cons (NULL_TREE, isvir, isvir_list);
+      acc_list = expr_tree_cons (NULL_TREE, access, acc_list);
+      off_list = expr_tree_cons (NULL_TREE, offset, off_list);
 
       base_cnt++;
       vb = TREE_CHAIN (vb);
@@ -957,7 +957,7 @@ expand_attr_desc (tdecl, type)
   elems = tree_cons
     (NULL_TREE, decay_conversion (tdecl), tree_cons
      (NULL_TREE, decay_conversion (name_string), tree_cons
-      (NULL_TREE, attrval, tree_cons (NULL_TREE, t, NULL_TREE))));
+      (NULL_TREE, attrval, expr_tree_cons (NULL_TREE, t, NULL_TREE))));
 
   fn = get_identifier ("__rtti_attr");
   if (IDENTIFIER_GLOBAL_VALUE (fn))
@@ -1199,9 +1199,9 @@ build_t_desc (type, definition)
   /* Show that we are defining the t_desc for this type.  */
   DECL_INITIAL (tdecl) = error_mark_node;
 
-  parents = build_tree_list (NULL_TREE, integer_zero_node);
-  vbases = build_tree_list (NULL_TREE, integer_zero_node);
-  offsets = build_tree_list (NULL_TREE, integer_zero_node);
+  parents = build_expr_list (NULL_TREE, integer_zero_node);
+  vbases = build_expr_list (NULL_TREE, integer_zero_node);
+  offsets = build_expr_list (NULL_TREE, integer_zero_node);
   methods = NULL_TREE;
   ivars = NULL_TREE;
 
diff --git a/gcc/cp/search.c b/gcc/cp/search.c
index 6da3f81..d75fe62 100644
--- a/gcc/cp/search.c
+++ b/gcc/cp/search.c
@@ -1317,7 +1317,7 @@ lookup_field (xbasetype, name, protect, want_type)
       return rval;
     }
 
-  basetype_chain = build_tree_list (NULL_TREE, basetype_path);
+  basetype_chain = build_expr_list (NULL_TREE, basetype_path);
   TREE_VIA_PUBLIC (basetype_chain) = TREE_VIA_PUBLIC (basetype_path);
   TREE_VIA_PROTECTED (basetype_chain) = TREE_VIA_PROTECTED (basetype_path);
   TREE_VIA_VIRTUAL (basetype_chain) = TREE_VIA_VIRTUAL (basetype_path);
@@ -1348,11 +1348,11 @@ lookup_field (xbasetype, name, protect, want_type)
 	      TREE_VIA_PROTECTED (btypes) = TREE_VIA_PROTECTED (base_binfo);
 	      TREE_VIA_VIRTUAL (btypes) = TREE_VIA_VIRTUAL (base_binfo);
 	      if (TREE_VIA_VIRTUAL (base_binfo))
-		btypes = tree_cons (NULL_TREE,
+		btypes = my_tree_cons (NULL_TREE,
 				    TYPE_BINFO (BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i))),
 				    btypes);
 	      else
-		btypes = tree_cons (NULL_TREE,
+		btypes = my_tree_cons (NULL_TREE,
 				    TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i),
 				    btypes);
 	      obstack_ptr_grow (&search_obstack, btypes);
@@ -1838,7 +1838,7 @@ lookup_fnfields (basetype_path, name, complain)
     }
   else
     {
-      basetype_chain = build_tree_list (NULL_TREE, basetype_path);
+      basetype_chain = build_expr_list (NULL_TREE, basetype_path);
       TREE_VIA_PUBLIC (basetype_chain) = TREE_VIA_PUBLIC (basetype_path);
       TREE_VIA_PROTECTED (basetype_chain) = TREE_VIA_PROTECTED (basetype_path);
       TREE_VIA_VIRTUAL (basetype_chain) = TREE_VIA_VIRTUAL (basetype_path);
@@ -1870,11 +1870,11 @@ lookup_fnfields (basetype_path, name, complain)
 	      TREE_VIA_PROTECTED (btypes) = TREE_VIA_PROTECTED (base_binfo);
 	      TREE_VIA_VIRTUAL (btypes) = TREE_VIA_VIRTUAL (base_binfo);
 	      if (TREE_VIA_VIRTUAL (base_binfo))
-		btypes = tree_cons (NULL_TREE,
+		btypes = my_tree_cons (NULL_TREE,
 				    TYPE_BINFO (BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i))),
 				    btypes);
 	      else
-		btypes = tree_cons (NULL_TREE,
+		btypes = my_tree_cons (NULL_TREE,
 				    TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i),
 				    btypes);
 	      obstack_ptr_grow (&search_obstack, btypes);
@@ -3672,6 +3672,8 @@ reinit_search_statistics ()
 #endif /* GATHER_STATISTICS */
 }
 
+#define scratch_tree_cons expr_tree_cons
+
 static tree conversions;
 static void
 add_conversions (binfo)
@@ -3685,7 +3687,7 @@ add_conversions (binfo)
       tree tmp = TREE_VEC_ELT (method_vec, i);
       if (! IDENTIFIER_TYPENAME_P (DECL_NAME (tmp)))
 	break;
-      conversions = tree_cons (binfo, tmp, conversions);
+      conversions = scratch_tree_cons (binfo, tmp, conversions);
     }
   SET_BINFO_MARKED (binfo);
 }
diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index 63e2cdb..c681651 100644
--- a/gcc/cp/tree.c
+++ b/gcc/cp/tree.c
@@ -1655,14 +1655,9 @@ extern int depth_reached;
 void
 print_lang_statistics ()
 {
-  extern struct obstack maybepermanent_obstack, decl_obstack;
+  extern struct obstack decl_obstack;
   print_obstack_statistics ("class_obstack", &class_obstack);
   print_obstack_statistics ("decl_obstack", &decl_obstack);
-  print_obstack_statistics ("permanent_obstack", &permanent_obstack);
-  print_obstack_statistics ("maybepermanent_obstack", &maybepermanent_obstack);
-#if 0
-  print_inline_obstack_statistics ();
-#endif
   print_search_statistics ();
   print_class_statistics ();
 #ifdef GATHER_STATISTICS
@@ -1765,8 +1760,6 @@ break_out_target_exprs (t)
 /* Obstack used for allocating nodes in template function and variable
    definitions.  */
 
-extern struct obstack *expression_obstack;
-
 /* Similar to `build_nt', except we build
    on the permanent_obstack, regardless.  */
 
@@ -2063,13 +2056,20 @@ make_temp_vec (len)
      int len;
 {
   register tree node;
-  push_obstacks_nochange ();
-  resume_temporary_allocation ();
+  register struct obstack *ambient_obstack = current_obstack;
+  current_obstack = expression_obstack;
   node = make_tree_vec (len);
-  pop_obstacks ();
+  current_obstack = ambient_obstack;
   return node;
 }
 
+void
+push_expression_obstack ()
+{
+  push_obstacks_nochange ();
+  current_obstack = expression_obstack;
+}
+
 /* The type of ARG when used as an lvalue.  */
 
 tree
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 96d1c26..a97dbbb 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -2417,7 +2417,7 @@ build_x_function_call (function, params, decl)
       decl_addr = build_unary_op (ADDR_EXPR, decl, 0);
       function = get_member_function_from_ptrfunc (&decl_addr,
 						   TREE_OPERAND (function, 1));
-      params = tree_cons (NULL_TREE, decl_addr, params);
+      params = expr_tree_cons (NULL_TREE, decl_addr, params);
       return build_function_call (function, params);
     }
 
@@ -2467,7 +2467,7 @@ build_x_function_call (function, params, decl)
 	}
       else
 	decl = build_c_cast (ctypeptr, decl);
-      params = tree_cons (NULL_TREE, decl, params);
+      params = expr_tree_cons (NULL_TREE, decl, params);
     }
 
   return build_function_call (function, params);
@@ -2870,7 +2870,7 @@ convert_arguments (return_loc, typelist, values, fndecl, flags)
 	  if (parmval == error_mark_node)
 	    return error_mark_node;
 
-	  result = tree_cons (NULL_TREE, parmval, result);
+	  result = expr_tree_cons (NULL_TREE, parmval, result);
 	}
       else
 	{
@@ -2881,17 +2881,17 @@ convert_arguments (return_loc, typelist, values, fndecl, flags)
 	      && (TYPE_PRECISION (TREE_TYPE (val))
 		  < TYPE_PRECISION (double_type_node)))
 	    /* Convert `float' to `double'.  */
-	    result = tree_cons (NULL_TREE, cp_convert (double_type_node, val), result);
+	    result = expr_tree_cons (NULL_TREE, cp_convert (double_type_node, val), result);
 	  else if (TYPE_LANG_SPECIFIC (TREE_TYPE (val))
 		   && ! TYPE_HAS_TRIVIAL_INIT_REF (TREE_TYPE (val)))
 	    {
 	      cp_warning ("cannot pass objects of type `%T' through `...'",
 			  TREE_TYPE (val));
-	      result = tree_cons (NULL_TREE, val, result);
+	      result = expr_tree_cons (NULL_TREE, val, result);
 	    }
 	  else
 	    /* Convert `short' and `char' to full-size `int'.  */
-	    result = tree_cons (NULL_TREE, default_conversion (val), result);
+	    result = expr_tree_cons (NULL_TREE, default_conversion (val), result);
 	}
 
       if (typetail)
@@ -2936,7 +2936,7 @@ convert_arguments (return_loc, typelist, values, fndecl, flags)
 	      if (parmval == error_mark_node)
 		return error_mark_node;
 
-	      result = tree_cons (0, parmval, result);
+	      result = expr_tree_cons (0, parmval, result);
 	      typetail = TREE_CHAIN (typetail);
 	      /* ends with `...'.  */
 	      if (typetail == NULL_TREE)
@@ -5146,7 +5146,7 @@ build_x_compound_expr (list)
   result = build_opfncall (COMPOUND_EXPR, LOOKUP_NORMAL,
 			   TREE_VALUE (list), TREE_VALUE (rest), NULL_TREE);
   if (result)
-    return build_x_compound_expr (tree_cons (NULL_TREE, result, TREE_CHAIN (rest)));
+    return build_x_compound_expr (expr_tree_cons (NULL_TREE, result, TREE_CHAIN (rest)));
 
   if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
     {
@@ -5163,8 +5163,8 @@ build_x_compound_expr (list)
     warn_if_unused_value (TREE_VALUE(list));
 #endif
 
-  return build_compound_expr (tree_cons (NULL_TREE, TREE_VALUE (list),
-					 build_tree_list (NULL_TREE, build_x_compound_expr (rest))));
+  return build_compound_expr (expr_tree_cons (NULL_TREE, TREE_VALUE (list),
+					 build_expr_list (NULL_TREE, build_x_compound_expr (rest))));
 }
 
 /* Given a list of expressions, return a compound expression
@@ -5248,7 +5248,7 @@ build_static_cast (type, expr)
   if (IS_AGGR_TYPE (type))
     return build_cplus_new
       (type, (build_method_call
-	      (NULL_TREE, ctor_identifier, build_tree_list (NULL_TREE, expr),
+	      (NULL_TREE, ctor_identifier, build_expr_list (NULL_TREE, expr),
 	       TYPE_BINFO (type), LOOKUP_NORMAL)));
 
   expr = decay_conversion (expr);
@@ -5795,7 +5795,7 @@ build_modify_expr (lhs, modifycode, rhs)
       else
 	{
 	  result = build_method_call (lhs, ctor_identifier,
-				      build_tree_list (NULL_TREE, rhs),
+				      build_expr_list (NULL_TREE, rhs),
 				      TYPE_BINFO (lhstype), LOOKUP_NORMAL);
 	  if (result == NULL_TREE)
 	    return error_mark_node;
@@ -6093,7 +6093,7 @@ build_modify_expr (lhs, modifycode, rhs)
       if (TREE_SIDE_EFFECTS (lhs))
 	cond = build_compound_expr (tree_cons
 				    (NULL_TREE, lhs,
-				     build_tree_list (NULL_TREE, cond)));
+				     build_expr_list (NULL_TREE, cond)));
 
       /* Cannot have two identical lhs on this one tree (result) as preexpand
 	 calls will rip them out and fill in RTL for them, but when the
@@ -6257,18 +6257,18 @@ build_ptrmemfunc1 (type, delta, idx, pfn, delta2)
   if (pfn)
     {
       u = build_nt (CONSTRUCTOR, NULL_TREE,
-		    tree_cons (pfn_identifier, pfn, NULL_TREE));
+		    expr_tree_cons (pfn_identifier, pfn, NULL_TREE));
     }
   else
     {
       u = build_nt (CONSTRUCTOR, NULL_TREE,
-		    tree_cons (delta2_identifier, delta2, NULL_TREE));
+		    expr_tree_cons (delta2_identifier, delta2, NULL_TREE));
     }
 
   u = build_nt (CONSTRUCTOR, NULL_TREE,
-		tree_cons (NULL_TREE, delta,
-			   tree_cons (NULL_TREE, idx,
-				      tree_cons (NULL_TREE, u, NULL_TREE))));
+		expr_tree_cons (NULL_TREE, delta,
+			   expr_tree_cons (NULL_TREE, idx,
+				      expr_tree_cons (NULL_TREE, u, NULL_TREE))));
 
   return digest_init (type, u, (tree*)0);
 #else
@@ -6287,14 +6287,14 @@ build_ptrmemfunc1 (type, delta, idx, pfn, delta2)
     {
       allconstant = TREE_CONSTANT (pfn);
       allsimple = !! initializer_constant_valid_p (pfn, TREE_TYPE (pfn));
-      u = tree_cons (pfn_field, pfn, NULL_TREE);
+      u = expr_tree_cons (pfn_field, pfn, NULL_TREE);
     }
   else
     {
       delta2 = convert_and_check (delta_type_node, delta2);
       allconstant = TREE_CONSTANT (delta2);
       allsimple = !! initializer_constant_valid_p (delta2, TREE_TYPE (delta2));
-      u = tree_cons (delta2_field, delta2, NULL_TREE);
+      u = expr_tree_cons (delta2_field, delta2, NULL_TREE);
     }
 
   delta = convert_and_check (delta_type_node, delta);
@@ -6306,9 +6306,9 @@ build_ptrmemfunc1 (type, delta, idx, pfn, delta2)
       && initializer_constant_valid_p (idx, TREE_TYPE (idx));
 
   u = build (CONSTRUCTOR, subtype, NULL_TREE, u);
-  u = tree_cons (delta_field, delta,
-		 tree_cons (idx_field, idx,
-			    tree_cons (pfn_or_delta2_field, u, NULL_TREE)));
+  u = expr_tree_cons (delta_field, delta,
+		 expr_tree_cons (idx_field, idx,
+			    expr_tree_cons (pfn_or_delta2_field, u, NULL_TREE)));
   u = build (CONSTRUCTOR, type, NULL_TREE, u);
   TREE_CONSTANT (u) = allconstant;
   TREE_STATIC (u) = allconstant && allsimple;
@@ -7036,7 +7036,7 @@ convert_for_initialization (exp, type, rhs, flags, errtype, fndecl, parmnum)
 	  if (TYPE_HAS_INIT_REF (type))
 	    {
 	      tree init = build_method_call (exp, ctor_identifier,
-					     build_tree_list (NULL_TREE, rhs),
+					     build_expr_list (NULL_TREE, rhs),
 					     TYPE_BINFO (type), LOOKUP_NORMAL);
 
 	      if (init == error_mark_node)
diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c
index b03cb5d..93c77dd 100644
--- a/gcc/cp/typeck2.c
+++ b/gcc/cp/typeck2.c
@@ -986,7 +986,7 @@ process_init_constructor (type, init, elts)
 	    allconstant = 0;
 	  else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
 	    allsimple = 0;
-	  members = tree_cons (NULL_TREE, next1, members);
+	  members = expr_tree_cons (NULL_TREE, next1, members);
 	}
     }
   if (TREE_CODE (type) == RECORD_TYPE)
@@ -1021,7 +1021,7 @@ process_init_constructor (type, init, elts)
 
 	  if (! DECL_NAME (field))
 	    {
-	      members = tree_cons (field, integer_zero_node, members);
+	      members = expr_tree_cons (field, integer_zero_node, members);
 	      continue;
 	    }
 
@@ -1050,7 +1050,7 @@ process_init_constructor (type, init, elts)
 	    allconstant = 0;
 	  else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
 	    allsimple = 0;
-	  members = tree_cons (field, next1, members);
+	  members = expr_tree_cons (field, next1, members);
 	}
       for (; field; field = TREE_CHAIN (field))
 	{
@@ -1067,7 +1067,7 @@ process_init_constructor (type, init, elts)
 		allconstant = 0;
 	      else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
 		allsimple = 0;
-	      members = tree_cons (field, next1, members);
+	      members = expr_tree_cons (field, next1, members);
 	    }
 	  else if (TREE_READONLY (field))
 	    error ("uninitialized const member `%s'",
@@ -1149,7 +1149,7 @@ process_init_constructor (type, init, elts)
 	allconstant = 0;
       else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
 	allsimple = 0;
-      members = tree_cons (field, next1, members);
+      members = expr_tree_cons (field, next1, members);
     }
 
   /* If arguments were specified as a list, just remove the ones we used.  */