cp-tree.h (scratch_tree_cons): Remove.

	* cp-tree.h (scratch_tree_cons): Remove.
	* call.c: Replace all uses of expr_tree_cons, saveable_tree_cons,
	and perm_tree_cons with plain tree_cons.
	* class.c: Likewise.
	* decl.c: Likewise.
	* decl2.c: Likewise.
	* except.c: Likewise.
	* expr.c: Likewise.
	* init.c: Likewise.
	* lex.c: Likewise.
	* method.c: Likewise.
	* parse.y: Likewise.
	* pt.c: Likewise.
	* repo.c: Likewise.
	* rtti.c: Likewise.
	* search.c: Likewise.
	* typeck.c: Likewise.
	* parse.c: Regenerated.
	* tree.c (build_srcloc): Simplify.

From-SVN: r29225

diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index dced83b335427ee51b608c0dfac862239447208c..ac0ad6bf40dbd91bec6aac3d4a62c0d91f9cb46d 100644 (file)
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -162,7 +162,7 @@ build_field_call (basetype_path, instance_ptr, name, parms)
          else if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance)))
                   == METHOD_TYPE)
            return build_function_call
-             (instance, expr_tree_cons (NULL_TREE, instance_ptr, parms));
+             (instance, tree_cons (NULL_TREE, instance_ptr, parms));
        }
     }
 
@@ -1992,10 +1992,10 @@ add_builtin_candidates (candidates, code, code2, fnname, args, flags)
          if (code == COND_EXPR)
            {
              if (real_lvalue_p (args[i]))
-               types[i] = scratch_tree_cons
+               types[i] = tree_cons
                  (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
 
-             types[i] = scratch_tree_cons
+             types[i] = tree_cons
                (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
            }
 
@@ -2012,37 +2012,37 @@ add_builtin_candidates (candidates, code, code2, fnname, args, flags)
                continue;
 
              if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
-               types[i] = scratch_tree_cons (NULL_TREE, type, types[i]);
+               types[i] = 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] = scratch_tree_cons (NULL_TREE, type, types[i]);
+                   types[i] = 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] = scratch_tree_cons (NULL_TREE, type, types[i]);
+               types[i] = tree_cons (NULL_TREE, type, types[i]);
            }
        }
       else
        {
          if (code == COND_EXPR && real_lvalue_p (args[i]))
-           types[i] = scratch_tree_cons
+           types[i] = 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] = scratch_tree_cons (NULL_TREE, type, types[i]);
+               types[i] = tree_cons (NULL_TREE, type, types[i]);
              if (INTEGRAL_TYPE_P (type))
                type = type_promotes_to (type);
            }
-         types[i] = scratch_tree_cons (NULL_TREE, type, types[i]);
+         types[i] = tree_cons (NULL_TREE, type, types[i]);
        }
     }
 
@@ -2256,8 +2256,8 @@ build_user_type_conversion_1 (totype, expr, flags)
       TREE_TYPE (t) = build_pointer_type (totype);
       args = build_scratch_list (NULL_TREE, expr);
       if (TYPE_USES_VIRTUAL_BASECLASSES (totype))
-       args = scratch_tree_cons (NULL_TREE, integer_one_node, args);
-      args = scratch_tree_cons (NULL_TREE, t, args);
+       args = tree_cons (NULL_TREE, integer_one_node, args);
+      args = tree_cons (NULL_TREE, t, args);
 
       ctors = TREE_VALUE (ctors);
     }
@@ -2269,7 +2269,7 @@ build_user_type_conversion_1 (totype, expr, flags)
 
       if (TREE_CODE (ctor) == TEMPLATE_DECL) 
        {
-         templates = scratch_tree_cons (NULL_TREE, ctor, templates);
+         templates = tree_cons (NULL_TREE, ctor, templates);
          candidates = 
            add_template_candidate (candidates, ctor,
                                    NULL_TREE, args, NULL_TREE, flags,
@@ -2319,7 +2319,7 @@ build_user_type_conversion_1 (totype, expr, flags)
 
            if (TREE_CODE (fn) == TEMPLATE_DECL)
              {
-               templates = scratch_tree_cons (NULL_TREE, fn, templates);
+               templates = tree_cons (NULL_TREE, fn, templates);
                candidates = 
                  add_template_candidate (candidates, fn, NULL_TREE,
                                          args, totype, flags,
@@ -2476,7 +2476,7 @@ build_new_function_call (fn, args)
 
          if (TREE_CODE (t) == TEMPLATE_DECL)
            {
-             templates = scratch_tree_cons (NULL_TREE, t, templates);
+             templates = tree_cons (NULL_TREE, t, templates);
              candidates = add_template_candidate
                (candidates, t, explicit_targs, args, NULL_TREE,
                 LOOKUP_NORMAL, DEDUCE_CALL);  
@@ -2555,7 +2555,7 @@ build_object_call (obj, args)
   if (fns)
     {
       tree base = TREE_PURPOSE (fns);
-      mem_args = scratch_tree_cons (NULL_TREE, build_this (obj), args);
+      mem_args = tree_cons (NULL_TREE, build_this (obj), args);
 
       for (fns = TREE_VALUE (fns); fns; fns = OVL_NEXT (fns))
        {
@@ -3139,10 +3139,10 @@ build_new_op (code, flags, arg1, arg2, arg3)
     arg2 = integer_zero_node;
 
   if (arg2 && arg3)
-    arglist = scratch_tree_cons (NULL_TREE, arg1, scratch_tree_cons
+    arglist = tree_cons (NULL_TREE, arg1, tree_cons
                      (NULL_TREE, arg2, build_scratch_list (NULL_TREE, arg3)));
   else if (arg2)
-    arglist = scratch_tree_cons (NULL_TREE, arg1, build_scratch_list (NULL_TREE, arg2));
+    arglist = tree_cons (NULL_TREE, arg1, build_scratch_list (NULL_TREE, arg2));
   else
     arglist = build_scratch_list (NULL_TREE, arg1);
 
@@ -3155,7 +3155,7 @@ build_new_op (code, flags, arg1, arg2, arg3)
       tree fn = OVL_CURRENT (fns);
       if (TREE_CODE (fn) == TEMPLATE_DECL)
        {
-         templates = scratch_tree_cons (NULL_TREE, fn, templates);
+         templates = tree_cons (NULL_TREE, fn, templates);
          candidates 
            = add_template_candidate (candidates, fn, NULL_TREE,
                                      arglist, TREE_TYPE (fnname),
@@ -3177,7 +3177,7 @@ build_new_op (code, flags, arg1, arg2, arg3)
   if (fns)
     {
       tree basetype = TREE_PURPOSE (fns);
-      mem_arglist = scratch_tree_cons (NULL_TREE, build_this (arg1), TREE_CHAIN (arglist));
+      mem_arglist = tree_cons (NULL_TREE, build_this (arg1), TREE_CHAIN (arglist));
       for (fns = TREE_VALUE (fns); fns; fns = OVL_NEXT (fns))
        {
          tree fn = OVL_CURRENT (fns);
@@ -3191,7 +3191,7 @@ build_new_op (code, flags, arg1, arg2, arg3)
          if (TREE_CODE (fn) == TEMPLATE_DECL)
            {
              /* A member template. */
-             templates = scratch_tree_cons (NULL_TREE, fn, templates);
+             templates = tree_cons (NULL_TREE, fn, templates);
              candidates 
                = add_template_candidate (candidates, fn, NULL_TREE,
                                          this_arglist,  TREE_TYPE (fnname),
@@ -3521,7 +3521,7 @@ build_op_delete_call (code, addr, size, flags, placement)
       if (TREE_CODE (fns) == TREE_LIST)
        /* Member functions.  */
        enforce_access (TREE_PURPOSE (fns), fn);
-      return build_function_call (fn, expr_tree_cons (NULL_TREE, addr, args));
+      return build_function_call (fn, tree_cons (NULL_TREE, addr, args));
     }
 
   /* If we are doing placement delete we do nothing if we don't find a
@@ -3542,8 +3542,8 @@ build_op_delete_call (code, addr, size, flags, placement)
        /* Member functions.  */
        enforce_access (TREE_PURPOSE (fns), fn);
       return build_function_call
-       (fn, expr_tree_cons (NULL_TREE, addr,
-                            build_expr_list (NULL_TREE, size)));
+       (fn, tree_cons (NULL_TREE, addr,
+                       build_expr_list (NULL_TREE, size)));
     }
 
   /* finish_function passes LOOKUP_SPECULATIVELY if we're in a
@@ -3628,8 +3628,8 @@ convert_like (convs, expr)
 
            args = build_scratch_list (NULL_TREE, expr);
            if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
-             args = scratch_tree_cons (NULL_TREE, integer_one_node, args);
-           args = scratch_tree_cons (NULL_TREE, t, args);
+             args = tree_cons (NULL_TREE, integer_one_node, args);
+           args = tree_cons (NULL_TREE, t, args);
          }
        else
          args = build_this (expr);
@@ -3856,12 +3856,12 @@ build_over_call (cand, args, flags)
      resolution, and must be of the proper type.  */
   if (DECL_CONSTRUCTOR_P (fn))
     {
-      converted_args = expr_tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
+      converted_args = 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 = expr_tree_cons
+         converted_args = tree_cons
            (NULL_TREE, TREE_VALUE (arg), converted_args);
          arg = TREE_CHAIN (arg);
          parm = TREE_CHAIN (parm);
@@ -3885,7 +3885,7 @@ build_over_call (cand, args, flags)
         optimize accordingly.  */
       my_friendly_assert (TREE_CODE (parmtype) == POINTER_TYPE, 19990811);
       t = convert_pointer_to_real (TREE_TYPE (parmtype), TREE_VALUE (arg));
-      converted_args = expr_tree_cons (NULL_TREE, t, converted_args);
+      converted_args = tree_cons (NULL_TREE, t, converted_args);
       parm = TREE_CHAIN (parm);
       arg = TREE_CHAIN (arg);
       ++i;
@@ -3933,24 +3933,24 @@ build_over_call (cand, args, flags)
              || TREE_CODE (type) == ENUMERAL_TYPE)
          && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
        val = default_conversion (val);
-      converted_args = expr_tree_cons (NULL_TREE, val, converted_args);
+      converted_args = tree_cons (NULL_TREE, val, converted_args);
     }
 
   /* Default arguments */
   for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm))
     converted_args 
-      = expr_tree_cons (NULL_TREE, 
-                       convert_default_arg (TREE_VALUE (parm), 
-                                            TREE_PURPOSE (parm),
-                                            fn),
-                       converted_args);
+      = tree_cons (NULL_TREE, 
+                  convert_default_arg (TREE_VALUE (parm), 
+                                       TREE_PURPOSE (parm),
+                                       fn),
+                  converted_args);
 
   /* Ellipsis */
   for (; arg; arg = TREE_CHAIN (arg))
     converted_args 
-      = expr_tree_cons (NULL_TREE,
-                       convert_arg_to_ellipsis (TREE_VALUE (arg)),
-                       converted_args);
+      = tree_cons (NULL_TREE,
+                  convert_arg_to_ellipsis (TREE_VALUE (arg)),
+                  converted_args);
 
   converted_args = nreverse (converted_args);
 
@@ -4206,9 +4206,9 @@ build_new_method_call (instance, name, args, basetype_path, flags)
          && ! (flags & LOOKUP_HAS_IN_CHARGE))
        {
          flags |= LOOKUP_HAS_IN_CHARGE;
-         args = scratch_tree_cons (NULL_TREE, integer_one_node, args);
+         args = tree_cons (NULL_TREE, integer_one_node, args);
        }
-      mem_args = scratch_tree_cons (NULL_TREE, instance_ptr, args);
+      mem_args = tree_cons (NULL_TREE, instance_ptr, args);
       for (; fn; fn = OVL_NEXT (fn))
        {
          tree t = OVL_CURRENT (fn);
@@ -4227,7 +4227,7 @@ build_new_method_call (instance, name, args, basetype_path, flags)
          if (TREE_CODE (t) == TEMPLATE_DECL)
            {
              /* A member template. */
-             templates = scratch_tree_cons (NULL_TREE, t, templates);
+             templates = tree_cons (NULL_TREE, t, templates);
              candidates = 
                add_template_candidate (candidates, t, explicit_targs,
                                        this_arglist,
@@ -4774,9 +4774,9 @@ static void
 add_warning (winner, loser)
      struct z_candidate *winner, *loser;
 {
-  winner->warnings = expr_tree_cons (NULL_PTR,
-                                    build_expr_ptr_wrapper (loser),
-                                    winner->warnings);
+  winner->warnings = tree_cons (NULL_PTR,
+                               build_expr_ptr_wrapper (loser),
+                               winner->warnings);
 }
 
 /* Returns true iff functions are equivalent. Equivalent functions are

diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index ab417f505ea0db50113e3b56808a4c130daa74a9..2c6a03f71562085e43f48ed60509e5eb4d3945d9 100644 (file)
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -399,8 +399,8 @@ build_vtable_entry (delta, pfn)
   else
     {
       extern int flag_huge_objects;
-      tree elems = expr_tree_cons (NULL_TREE, delta,
-                             expr_tree_cons (NULL_TREE, integer_zero_node,
+      tree elems = tree_cons (NULL_TREE, delta,
+                             tree_cons (NULL_TREE, integer_zero_node,
                                         build_expr_list (NULL_TREE, pfn)));
       tree entry = build (CONSTRUCTOR, vtable_entry_type, NULL_TREE, elems);
 
@@ -3358,7 +3358,7 @@ finish_struct_1 (t)
          else
            fields = TREE_CHAIN (x);
          
-         access_decls = scratch_tree_cons (NULL_TREE, x, access_decls);
+         access_decls = tree_cons (NULL_TREE, x, access_decls);
          continue;
        }
 
@@ -4820,7 +4820,7 @@ resolve_address_of_overloaded_function (target_type,
            fntype = build_pointer_type (fntype);
 
          if (can_convert_arg (target_type, fntype, fn))
-           matches = scratch_tree_cons (fn, NULL_TREE, matches);
+           matches = tree_cons (fn, NULL_TREE, matches);
        }
     }
 
@@ -4879,7 +4879,7 @@ resolve_address_of_overloaded_function (target_type,
          else if (!is_reference)
            instantiation_type = build_pointer_type (instantiation_type);
          if (can_convert_arg (target_type, instantiation_type, instantiation))
-           matches = scratch_tree_cons (instantiation, fn, matches);
+           matches = tree_cons (instantiation, fn, matches);
        }
 
       /* Now, remove all but the most specialized of the matches.  */
@@ -4889,7 +4889,7 @@ resolve_address_of_overloaded_function (target_type,
                                                       explicit_targs);
 
          if (match != error_mark_node)
-           matches = scratch_tree_cons (match, NULL_TREE, NULL_TREE);
+           matches = tree_cons (match, NULL_TREE, NULL_TREE);
        }
     }
 
@@ -4907,8 +4907,8 @@ resolve_address_of_overloaded_function (target_type,
              TREE_VALUE slots, so we cons one up here (we're losing anyway,
              so why be clever?).  */
           for (; overload; overload = OVL_NEXT (overload))
-            matches = scratch_tree_cons (NULL_TREE, OVL_CURRENT (overload),
-                                         matches);
+            matches = tree_cons (NULL_TREE, OVL_CURRENT (overload),
+                                matches);
           
          print_candidates (matches);
        }

diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index f5b1a6ebdd88e433b8b2868046f25e8d4afff49f..4a37cdb2a330016ea79e99145bbfca24845826c4 100644 (file)
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -3709,7 +3709,6 @@ extern tree cp_build_qualified_type_real        PROTO((tree, int, int));
   cp_build_qualified_type_real ((TYPE), (QUALS), /*complain=*/1)
 
 #define scratchalloc expralloc
-#define scratch_tree_cons expr_tree_cons
 #define build_scratch_list build_expr_list
 #define make_scratch_vec make_temp_vec
 #define push_scratch_obstack push_expression_obstack

diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 264f7b2a3f2e9ebb6ec556e2e4c39ac98e72afa3..6305a623a936bc5531e803599931a6712b604afb 100644 (file)
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -2687,7 +2687,7 @@ maybe_process_template_type_declaration (type, globalize, b)
                 that won't happen below because B is not the class
                 binding level, but is instead the pseudo-global level.  */
              b->level_chain->tags = 
-               saveable_tree_cons (name, type, b->level_chain->tags);
+               tree_cons (name, type, b->level_chain->tags);
              if (TYPE_SIZE (current_class_type) == NULL_TREE)
                CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
            }
@@ -2737,10 +2737,7 @@ pushtag (name, type, globalize)
         || (globalize && b->parm_flag == 2))
     b = b->level_chain;
 
-  if (toplevel_bindings_p ())
-    b->tags = perm_tree_cons (name, type, b->tags);
-  else
-    b->tags = saveable_tree_cons (name, type, b->tags);
+  b->tags = tree_cons (name, type, b->tags);
 
   if (name)
     {
@@ -4401,7 +4398,7 @@ push_using_directive (used)
 
   ancestor = namespace_ancestor (current_decl_namespace (), used);
   ud = current_binding_level->using_directives;
-  ud = perm_tree_cons (used, ancestor, ud);
+  ud = tree_cons (used, ancestor, ud);
   current_binding_level->using_directives = ud;
   return ud;
 }
@@ -5483,7 +5480,7 @@ unqualified_namespace_lookup (name, flags, spacesp)
   for (; !val; scope = CP_DECL_CONTEXT (scope))
     {
       if (spacesp)
-       *spacesp = scratch_tree_cons (scope, NULL_TREE, *spacesp);
+       *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
       val = binding_for_name (name, scope);
 
       /* Initialize binding for this context. */
@@ -8185,9 +8182,9 @@ expand_static_init (decl, init)
          mark_addressable (cleanup);
          cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
          fcall = build_function_call (Atexit, 
-                                      expr_tree_cons (NULL_TREE, 
-                                                      cleanup, 
-                                                      NULL_TREE));
+                                      tree_cons (NULL_TREE, 
+                                                 cleanup, 
+                                                 NULL_TREE));
          finish_expr_stmt (fcall);
        }
 
@@ -8205,7 +8202,7 @@ expand_static_init (decl, init)
         currently in the temporary obstack.  */
       if (!TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
        preserve_initializer ();
-      static_aggregates = perm_tree_cons (init, decl, static_aggregates);
+      static_aggregates = tree_cons (init, decl, static_aggregates);
     }
 }
 
@@ -8535,9 +8532,9 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
             the information in the TEMPLATE_ID_EXPR.  */
          SET_DECL_IMPLICIT_INSTANTIATION (decl);
          DECL_TEMPLATE_INFO (decl)
-           = perm_tree_cons (TREE_OPERAND (orig_declarator, 0),
-                             TREE_OPERAND (orig_declarator, 1),
-                             NULL_TREE);
+           = tree_cons (TREE_OPERAND (orig_declarator, 0),
+                        TREE_OPERAND (orig_declarator, 1),
+                        NULL_TREE);
 
          if (has_default_arg)
            {
@@ -11614,7 +11611,7 @@ grokparms (first_parm, funcdef_flag)
                  TREE_CHAIN (list_node) = NULL_TREE;
                }
              else
-               list_node = saveable_tree_cons (init, type, NULL_TREE);
+               list_node = tree_cons (init, type, NULL_TREE);
              if (result == NULL_TREE)
                {
                  result = list_node;
@@ -12796,7 +12793,7 @@ build_enumerator (name, value, type)
      enum_overflow = tree_int_cst_lt (enum_next_value, value);
    }
 
-  result = saveable_tree_cons (name, decl, NULL_TREE);
+  result = tree_cons (name, decl, NULL_TREE);
   return result;
 }
 
@@ -14034,9 +14031,9 @@ finish_function (lineno, flags)
     }
 
   if (DECL_STATIC_CONSTRUCTOR (fndecl))
-    static_ctors = perm_tree_cons (NULL_TREE, fndecl, static_ctors);
+    static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
   if (DECL_STATIC_DESTRUCTOR (fndecl))
-    static_dtors = perm_tree_cons (NULL_TREE, fndecl, static_dtors);
+    static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
 
   if (! nested)
     {
@@ -14296,7 +14293,7 @@ maybe_build_cleanup_1 (decl, auto_delete)
 
       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
          && ! TYPE_HAS_DESTRUCTOR (type))
-       rval = build_compound_expr (expr_tree_cons (NULL_TREE, rval,
+       rval = build_compound_expr (tree_cons (NULL_TREE, rval,
                                               build_expr_list (NULL_TREE, build_vbase_delete (type, decl))));
 
       if (TREE_CODE (decl) != PARM_DECL)

diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index 6ca93f9c0248f8bff6c9170679a09ce3a1329e44..332fca525748d168769c4b32fbb6e412dddcd085 100644 (file)
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -2151,7 +2151,7 @@ build_anon_union_vars (anon_decl, elems, static_p, external_p)
 
       /* If there's a cleanup to do, it belongs in the
         TREE_PURPOSE of the following TREE_LIST.  */
-      *elems = scratch_tree_cons (NULL_TREE, decl, *elems);
+      *elems = tree_cons (NULL_TREE, decl, *elems);
       TREE_TYPE (*elems) = type;
     }
   
@@ -2952,8 +2952,8 @@ start_static_storage_duration_function ()
 
   /* Create the parameters.  */
   parm_types = void_list_node;
-  parm_types = perm_tree_cons (NULL_TREE, integer_type_node, parm_types);
-  parm_types = perm_tree_cons (NULL_TREE, integer_type_node, parm_types);
+  parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
+  parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
   type = build_function_type (void_type_node, parm_types);
 
   /* Create the FUNCTION_DECL itself.  */
@@ -3986,7 +3986,7 @@ build_expr_from_tree (t)
        chain = TREE_CHAIN (t);
        if (chain && chain != void_type_node)
          chain = build_expr_from_tree (chain);
-       return expr_tree_cons (purpose, value, chain);
+       return tree_cons (purpose, value, chain);
       }
 
     case COMPONENT_REF:
@@ -4185,14 +4185,14 @@ add_using_namespace (user, used, indirect)
 
   /* Add used to the user's using list. */
   DECL_NAMESPACE_USING (user) 
-    = perm_tree_cons (used, namespace_ancestor (user, used), 
-                     DECL_NAMESPACE_USING (user));
+    = tree_cons (used, namespace_ancestor (user, used), 
+                DECL_NAMESPACE_USING (user));
 
   TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
 
   /* Add user to the used's users list. */
   DECL_NAMESPACE_USERS (used)
-    = perm_tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
+    = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
 
   /* Recursively add all namespaces used. */
   for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
@@ -4335,8 +4335,8 @@ lookup_using_namespace (name, val, usings, scope, flags, spacesp)
     if (TREE_VALUE (iter) == scope)
       {
        if (spacesp)
-         *spacesp = scratch_tree_cons (TREE_PURPOSE (iter), NULL_TREE,
-                                       *spacesp);
+         *spacesp = tree_cons (TREE_PURPOSE (iter), NULL_TREE,
+                               *spacesp);
        val1 = binding_for_name (name, TREE_PURPOSE (iter));
        /* Resolve ambiguities. */
        val = ambiguous_decl (name, val, val1, flags);

diff --git a/gcc/cp/except.c b/gcc/cp/except.c
index 87c6e470d0b058fd5e236c04dd63d2ee8dcf54b5..18bd798a25b661080112ac6a9ee49ed8c474ed96 100644 (file)
--- a/gcc/cp/except.c
+++ b/gcc/cp/except.c
@@ -470,7 +470,7 @@ do_pop_exception ()
   mark_used (fn);
   /* Arrange to do a dynamically scoped cleanup upon exit from this region.  */
   cleanup = lookup_name (get_identifier ("__exception_info"), 0);
-  cleanup = build_function_call (fn, expr_tree_cons
+  cleanup = build_function_call (fn, tree_cons
                                 (NULL_TREE, cleanup, NULL_TREE));
   return cleanup;
 }
@@ -691,7 +691,7 @@ expand_end_eh_spec (raises)
   /* Build up an array of type_infos.  */
   for (; raises && TREE_VALUE (raises); raises = TREE_CHAIN (raises))
     {
-      types = expr_tree_cons
+      types = tree_cons
        (NULL_TREE, build_eh_type_type (TREE_VALUE (raises)), types);
       ++count;
     }
@@ -731,8 +731,8 @@ expand_end_eh_spec (raises)
     }
 
   mark_used (fn);
-  tmp = expr_tree_cons (NULL_TREE, build_int_2 (count, 0), expr_tree_cons
-                       (NULL_TREE, decl, NULL_TREE));
+  tmp = tree_cons (NULL_TREE, build_int_2 (count, 0), 
+                  tree_cons (NULL_TREE, decl, NULL_TREE));
   tmp = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), tmp);
   expand_expr (tmp, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
@@ -872,7 +872,7 @@ alloc_eh_object (type)
     }
 
   mark_used (fn);
-  exp = build_function_call (fn, expr_tree_cons
+  exp = build_function_call (fn, tree_cons
                             (NULL_TREE, size_in_bytes (type), NULL_TREE));
   exp = build1 (NOP_EXPR, build_pointer_type (type), exp);
   return exp;
@@ -1025,9 +1025,9 @@ expand_throw (exp)
        }
 
       mark_used (fn);
-      e = expr_tree_cons (NULL_TREE, exp, expr_tree_cons
-                         (NULL_TREE, throw_type, expr_tree_cons
-                          (NULL_TREE, cleanup, NULL_TREE)));
+      e = tree_cons (NULL_TREE, exp, tree_cons
+                    (NULL_TREE, throw_type, tree_cons
+                     (NULL_TREE, cleanup, NULL_TREE)));
       e = build_function_call (fn, e);
       expand_expr (e, const0_rtx, VOIDmode, 0);
     }

diff --git a/gcc/cp/expr.c b/gcc/cp/expr.c
index 373afe62dbc25d16e97a11df8432652af55a3c0e..c1f72636c980f9722384d8d38ba80ca5a5bf2d8e 100644 (file)
--- a/gcc/cp/expr.c
+++ b/gcc/cp/expr.c
@@ -161,7 +161,7 @@ cplus_expand_expr (exp, target, tmode, modifier)
               parameter value.  */
            mark_addressable (slot);
            if (TREE_PERMANENT (args))
-             args = expr_tree_cons (0, build1 (ADDR_EXPR, type, slot),
+             args = 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 a550a72a3f086a6b2ef4848a12b7ce93db59bcb7..fd48f198cab385aa6ad451d1644529527c028d0e 100644 (file)
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -1196,9 +1196,9 @@ expand_default_init (binfo, true_exp, exp, init, flags)
   if (TYPE_USES_VIRTUAL_BASECLASSES (type))
     {
       if (true_exp == exp)
-       parms = expr_tree_cons (NULL_TREE, integer_one_node, parms);
+       parms = tree_cons (NULL_TREE, integer_one_node, parms);
       else
-       parms = expr_tree_cons (NULL_TREE, integer_zero_node, parms);
+       parms = tree_cons (NULL_TREE, integer_zero_node, parms);
       flags |= LOOKUP_HAS_IN_CHARGE;
     }
 
@@ -2266,7 +2266,7 @@ build_new_1 (exp)
        susp = suspend_momentary ();
 
       rval = build_op_new_call
-       (code, true_type, expr_tree_cons (NULL_TREE, size, placement),
+       (code, true_type, tree_cons (NULL_TREE, size, placement),
         LOOKUP_NORMAL | (use_global_new * LOOKUP_GLOBAL));
       rval = cp_convert (build_pointer_type (true_type), rval);
 
@@ -2324,7 +2324,7 @@ build_new_1 (exp)
       TREE_SIDE_EFFECTS (exp1) = 1;
       rval = cp_convert (build_pointer_type (true_type), rval);
       rval = build_compound_expr
-       (expr_tree_cons (NULL_TREE, exp1,
+       (tree_cons (NULL_TREE, exp1,
                         build_expr_list (NULL_TREE, rval)));
     }
 
@@ -2389,7 +2389,7 @@ build_new_1 (exp)
 
          if (rval && TYPE_USES_VIRTUAL_BASECLASSES (true_type))
            {
-             init = expr_tree_cons (NULL_TREE, integer_one_node, init);
+             init = tree_cons (NULL_TREE, integer_one_node, init);
              flags |= LOOKUP_HAS_IN_CHARGE;
            }
 
@@ -2580,24 +2580,24 @@ build_vec_delete_1 (base, maxindex, type, auto_delete_vec, auto_delete,
   else
     body = NULL_TREE;
 
-  body = expr_tree_cons (NULL_TREE,
+  body = tree_cons (NULL_TREE,
                    build_delete (ptype, tbase, auto_delete,
                                  LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1),
                    body);
 
-  body = expr_tree_cons (NULL_TREE,
+  body = tree_cons (NULL_TREE,
                    build_modify_expr (tbase, NOP_EXPR, build (MINUS_EXPR, ptype, tbase, size_exp)),
                    body);
 
-  body = expr_tree_cons (NULL_TREE,
+  body = 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 = expr_tree_cons (NULL_TREE, tbase_init,
-                   expr_tree_cons (NULL_TREE, loop, NULL_TREE));
+  loop = tree_cons (NULL_TREE, tbase_init,
+                   tree_cons (NULL_TREE, loop, NULL_TREE));
   loop = build_compound_expr (loop);
 
  no_destructor:
@@ -2636,8 +2636,8 @@ build_vec_delete_1 (base, maxindex, type, auto_delete_vec, auto_delete,
 
   if (loop && deallocate_expr != integer_zero_node)
     {
-      body = expr_tree_cons (NULL_TREE, loop,
-                       expr_tree_cons (NULL_TREE, deallocate_expr, NULL_TREE));
+      body = tree_cons (NULL_TREE, loop,
+                       tree_cons (NULL_TREE, deallocate_expr, NULL_TREE));
       body = build_compound_expr (body);
     }
   else
@@ -3240,7 +3240,7 @@ build_delete (type, addr, auto_delete, flags, use_global_delete)
          expr = build_scoped_method_call
            (ref, base_binfo, dtor_identifier,
             build_expr_list (NULL_TREE, this_auto_delete));
-         exprstmt = expr_tree_cons (NULL_TREE, expr, exprstmt);
+         exprstmt = tree_cons (NULL_TREE, expr, exprstmt);
        }
 
       /* Take care of the remaining baseclasses.  */
@@ -3255,7 +3255,7 @@ build_delete (type, addr, auto_delete, flags, use_global_delete)
            (ref, base_binfo, dtor_identifier,
             build_expr_list (NULL_TREE, integer_zero_node));
 
-         exprstmt = expr_tree_cons (NULL_TREE, expr, exprstmt);
+         exprstmt = tree_cons (NULL_TREE, expr, exprstmt);
        }
 
       for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
@@ -3267,7 +3267,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 = expr_tree_cons (NULL_TREE, expr, exprstmt);
+             exprstmt = tree_cons (NULL_TREE, expr, exprstmt);
            }
        }
 
@@ -3294,7 +3294,7 @@ build_vbase_delete (type, decl)
     {
       tree this_addr = convert_force (build_pointer_type (BINFO_TYPE (vbases)),
                                      addr, 0);
-      result = expr_tree_cons (NULL_TREE,
+      result = 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 1ab7f0dfb39088aa75957fb48eb78e6457fc959c..21b09d47eb807237e2eb31406b6f5a71aef1aa71 100644 (file)
--- a/gcc/cp/lex.c
+++ b/gcc/cp/lex.c
@@ -2751,9 +2751,9 @@ handle_cp_pragma (pname)
        }
 
       pending_vtables
-       = perm_tree_cons (NULL_TREE,
-                         get_identifier (TREE_STRING_POINTER (yylval.ttype)),
-                         pending_vtables);
+       = tree_cons (NULL_TREE,
+                    get_identifier (TREE_STRING_POINTER (yylval.ttype)),
+                    pending_vtables);
       token = real_yylex ();
       if (token != END_OF_LINE)
        warning ("trailing characters ignored");

diff --git a/gcc/cp/method.c b/gcc/cp/method.c
index 7b74443b05b32af4f512d97e89e94ab464d74a1f..f71b03e507e4788637b67c4b3f19580ae9394392 100644 (file)
--- a/gcc/cp/method.c
+++ b/gcc/cp/method.c
@@ -2140,9 +2140,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 = expr_tree_cons (NULL_TREE, t, NULL_TREE);
+    t = tree_cons (NULL_TREE, t, NULL_TREE);
     for (a = TREE_CHAIN (a); a; a = TREE_CHAIN (a))
-      t = expr_tree_cons (NULL_TREE, a, t);
+      t = tree_cons (NULL_TREE, a, t);
     t = nreverse (t);
     t = build_call (function, TREE_TYPE (TREE_TYPE (function)), t);
     c_expand_return (t);

diff --git a/gcc/cp/parse.c b/gcc/cp/parse.c
index 9ec49033522cac20b9f5619b739ad858578650f7..beca740de3068491761c8cd44bcbacceec3b8fda 100644 (file)
--- a/gcc/cp/parse.c
+++ b/gcc/cp/parse.c
@@ -5246,12 +5246,12 @@ case 207:
     break;}
 case 209:
 #line 1075 "parse.y"
-{ yyval.ttype = expr_tree_cons (NULL_TREE, yyval.ttype, 
+{ yyval.ttype = tree_cons (NULL_TREE, yyval.ttype, 
                                  build_expr_list (NULL_TREE, yyvsp[0].ttype)); ;
     break;}
 case 210:
 #line 1078 "parse.y"
-{ yyval.ttype = expr_tree_cons (NULL_TREE, yyval.ttype, 
+{ yyval.ttype = tree_cons (NULL_TREE, yyval.ttype, 
                                  build_expr_list (NULL_TREE, error_mark_node)); ;
     break;}
 case 211:
@@ -6310,7 +6310,7 @@ case 454:
     break;}
 case 455:
 #line 2055 "parse.y"
-{ yyval.ttype = expr_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ;
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ;
     break;}
 case 456:
 #line 2058 "parse.y"
@@ -6322,7 +6322,7 @@ case 457:
     break;}
 case 458:
 #line 2062 "parse.y"
-{ yyval.ttype = expr_tree_cons (yyvsp[-2].ttype, yyvsp[0].ttype, yyval.ttype); ;
+{ yyval.ttype = tree_cons (yyvsp[-2].ttype, yyvsp[0].ttype, yyval.ttype); ;
     break;}
 case 459:
 #line 2067 "parse.y"

diff --git a/gcc/cp/parse.y b/gcc/cp/parse.y
index e12d1b245910fcba7f1f58611bf33c7899606120..dcee4ecf8aad4a95fda7b2abd2cfa675f4649653 100644 (file)
--- a/gcc/cp/parse.y
+++ b/gcc/cp/parse.y
@@ -1072,10 +1072,10 @@ already_scoped_stmt:
 
 nontrivial_exprlist:
          expr_no_commas ',' expr_no_commas
-               { $$ = expr_tree_cons (NULL_TREE, $$, 
+               { $$ = tree_cons (NULL_TREE, $$, 
                                  build_expr_list (NULL_TREE, $3)); }
        | expr_no_commas ',' error
-               { $$ = expr_tree_cons (NULL_TREE, $$, 
+               { $$ = tree_cons (NULL_TREE, $$, 
                                  build_expr_list (NULL_TREE, error_mark_node)); }
        | nontrivial_exprlist ',' expr_no_commas
                { chainon ($$, build_expr_list (NULL_TREE, $3)); }
@@ -2052,14 +2052,14 @@ initlist:
          init
                { $$ = build_tree_list (NULL_TREE, $$); }
        | initlist ',' init
-               { $$ = expr_tree_cons (NULL_TREE, $3, $$); }
+               { $$ = tree_cons (NULL_TREE, $3, $$); }
        /* These are for labeled elements.  */
        | '[' expr_no_commas ']' init
                { $$ = build_expr_list ($2, $4); }
        | identifier ':' init
                { $$ = build_expr_list ($$, $3); }
        | initlist ',' identifier ':' init
-               { $$ = expr_tree_cons ($3, $5, $$); }
+               { $$ = tree_cons ($3, $5, $$); }
        ;
 
 fn.defpen:

diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index a02e17a06b9210f50e19b52941edaeac79655c8c..a452241bdf894171a866a6adb589dcbb24609beb 100644 (file)
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -912,7 +912,7 @@ register_specialization (spec, tmpl, args)
       }
 
   DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
-     = perm_tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
+     = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
 
   return spec;
 }
@@ -951,7 +951,7 @@ register_local_specialization (spec, tmpl, fn)
      tree fn;
 {
   DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
-     = perm_tree_cons (fn, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
+     = tree_cons (fn, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
 
   return spec;
 }
@@ -1090,7 +1090,7 @@ determine_specialization (template_id, decl, targs_out,
        continue;
 
       /* Save this template, and the arguments deduced.  */
-      templates = scratch_tree_cons (targs, tmpl, templates);
+      templates = tree_cons (targs, tmpl, templates);
     }
 
   if (templates && TREE_CHAIN (templates))
@@ -1130,7 +1130,7 @@ determine_specialization (template_id, decl, targs_out,
      if (tmpl && tmpl != error_mark_node)
        {
         targs = get_bindings (tmpl, decl, explicit_targs);
-        templates = scratch_tree_cons (targs, tmpl, NULL_TREE);
+        templates = tree_cons (targs, tmpl, NULL_TREE);
        }
     }
 
@@ -1546,8 +1546,7 @@ check_explicit_specialization (declarator, decl, template_count, flags)
            }
 
          /* Set up the DECL_TEMPLATE_INFO for DECL.  */
-         DECL_TEMPLATE_INFO (decl) 
-           = perm_tree_cons (tmpl, targs, NULL_TREE);
+         DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
 
          /* Mangle the function name appropriately.  Note that we do
             not mangle specializations of non-template member
@@ -2232,8 +2231,8 @@ process_partial_specialization (decl)
     return decl;
 
   DECL_TEMPLATE_SPECIALIZATIONS (maintmpl) = CLASSTYPE_TI_SPEC_INFO (type)
-    = perm_tree_cons (inner_args, inner_parms,
-                     DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
+    = tree_cons (inner_args, inner_parms,
+                DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
   TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
   return decl;
 }
@@ -2547,8 +2546,8 @@ push_template_decl_real (decl, is_friend)
          TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
          DECL_TI_TEMPLATE (decl) = new_tmpl;
          SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
-         DECL_TEMPLATE_INFO (new_tmpl) = 
-           perm_tree_cons (tmpl, args, NULL_TREE);
+         DECL_TEMPLATE_INFO (new_tmpl) 
+           = tree_cons (tmpl, args, NULL_TREE);
 
          register_specialization (new_tmpl, tmpl, args);
          return decl;
@@ -2604,7 +2603,7 @@ push_template_decl_real (decl, is_friend)
   if (primary)
     DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
 
-  info = perm_tree_cons (tmpl, args, NULL_TREE);
+  info = tree_cons (tmpl, args, NULL_TREE);
 
   if (DECL_IMPLICIT_TYPEDEF_P (decl))
     {
@@ -3633,8 +3632,7 @@ add_pending_template (d)
   if (TI_PENDING_TEMPLATE_FLAG (ti))
     return;
 
-  *template_tail = perm_tree_cons
-    (build_srcloc_here (), d, NULL_TREE);
+  *template_tail = tree_cons (build_srcloc_here (), d, NULL_TREE);
   template_tail = &TREE_CHAIN (*template_tail);
   TI_PENDING_TEMPLATE_FLAG (ti) = 1;
 }
@@ -3802,7 +3800,7 @@ lookup_template_class (d1, arglist, in_decl, context, entering_scope)
        return error_mark_node;
 
       TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm)
-       = perm_tree_cons (template2, arglist2, NULL_TREE);
+       = tree_cons (template2, arglist2, NULL_TREE);
       TYPE_SIZE (parm) = 0;
       return parm;
     }
@@ -5889,7 +5887,7 @@ tsubst_decl (t, args, type, in_decl)
        if (gen_tmpl)
          {
            DECL_TEMPLATE_INFO (r) 
-             = perm_tree_cons (gen_tmpl, argvec, NULL_TREE);
+             = tree_cons (gen_tmpl, argvec, NULL_TREE);
            SET_DECL_IMPLICIT_INSTANTIATION (r);
            register_specialization (r, gen_tmpl, argvec);
 
@@ -6100,7 +6098,7 @@ tsubst_decl (t, args, type, in_decl)
        if (ctx)
          DECL_EXTERNAL (r) = 1;
 
-       DECL_TEMPLATE_INFO (r) = perm_tree_cons (tmpl, argvec, NULL_TREE);
+       DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
        SET_DECL_IMPLICIT_INSTANTIATION (r);
        if (ctx)
          register_specialization (r, gen_tmpl, argvec);
@@ -6511,7 +6509,7 @@ tsubst (t, args, complain, in_decl)
                  return error_mark_node;
 
                TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
-                 = perm_tree_cons (TYPE_NAME (t), argvec, NULL_TREE);
+                 = tree_cons (TYPE_NAME (t), argvec, NULL_TREE);
              }
            break;
 
@@ -7674,9 +7672,9 @@ fn_type_unification (fn, explicit_targs, targs, args, return_type,
       /* This is a template conversion operator.  Use the return types
          as well as the argument types.  We use it instead of 'this', since
          we could be comparing conversions from different classes.  */
-      parms = scratch_tree_cons (NULL_TREE, TREE_TYPE (fntype),
-                                TREE_CHAIN (parms));
-      args = scratch_tree_cons (NULL_TREE, return_type, TREE_CHAIN (args));
+      parms = tree_cons (NULL_TREE, TREE_TYPE (fntype),
+                        TREE_CHAIN (parms));
+      args = tree_cons (NULL_TREE, return_type, TREE_CHAIN (args));
     }
 
   /* We allow incomplete unification without an error message here
@@ -9044,8 +9042,7 @@ most_specialized (fns, decl, explicit_args)
 
       args = get_bindings (candidate, decl, explicit_args);
       if (args)
-       candidates = scratch_tree_cons (NULL_TREE, candidate, 
-                                       candidates);
+       candidates = tree_cons (NULL_TREE, candidate, candidates);
     }
 
   return most_specialized_instantiation (candidates, explicit_args);
@@ -9909,7 +9906,7 @@ add_maybe_template (d, fns)
       return;
     }
 
-  *maybe_template_tail = perm_tree_cons (t, d, NULL_TREE);
+  *maybe_template_tail = tree_cons (t, d, NULL_TREE);
   maybe_template_tail = &TREE_CHAIN (*maybe_template_tail);
   DECL_MAYBE_TEMPLATE (d) = 1;
 }

diff --git a/gcc/cp/repo.c b/gcc/cp/repo.c
index 4adcc35eaab3fc2332ee9f28a57f6b55e9055a69..fdeefb18f4decdb27c8b514ed514d2c07d5c24d1 100644 (file)
--- a/gcc/cp/repo.c
+++ b/gcc/cp/repo.c
@@ -142,7 +142,7 @@ repo_template_used (t)
   if (! IDENTIFIER_REPO_USED (id))
     {
       IDENTIFIER_REPO_USED (id) = 1;
-      pending_repo = perm_tree_cons (NULL_TREE, id, pending_repo);
+      pending_repo = tree_cons (NULL_TREE, id, pending_repo);
     }
 }
 
@@ -156,7 +156,7 @@ repo_vtable_used (t)
   if (! flag_use_repository)
     return;
 
-  pending_repo = perm_tree_cons (NULL_TREE, t, pending_repo);
+  pending_repo = tree_cons (NULL_TREE, t, pending_repo);
 }
 
 /* Note that an inline with external linkage has been used, and offer to
@@ -176,7 +176,7 @@ repo_inline_used (fn)
       return;
     }
 
-  pending_repo = perm_tree_cons (NULL_TREE, fn, pending_repo);
+  pending_repo = tree_cons (NULL_TREE, fn, pending_repo);
 }
 
 /* Note that a particular typeinfo node has been used, and offer to
@@ -347,7 +347,7 @@ init_repo (filename)
            else
              orig = NULL_TREE;
 
-           original_repo = perm_tree_cons (orig, id, original_repo);
+           original_repo = tree_cons (orig, id, original_repo);
          }
          break;
        default:

diff --git a/gcc/cp/rtti.c b/gcc/cp/rtti.c
index d5d3377ba1fcdc21553e2d28c1ca212136445181..2b4eeaf7af2296804953118359e569d4602d0898 100644 (file)
--- a/gcc/cp/rtti.c
+++ b/gcc/cp/rtti.c
@@ -298,7 +298,7 @@ build_x_typeid (exp)
       tree bad = throw_bad_typeid ();
 
       bad = build_compound_expr
-       (expr_tree_cons (NULL_TREE, bad, build_expr_list
+       (tree_cons (NULL_TREE, bad, build_expr_list
                    (NULL_TREE, cp_convert (type, integer_zero_node))));
       exp = build (COND_EXPR, type, cond, exp, bad);
     }
@@ -676,7 +676,7 @@ build_dynamic_cast_1 (type, expr)
            {
              expr1 = throw_bad_cast ();
              expr1 = build_compound_expr
-               (expr_tree_cons (NULL_TREE, expr1,
+               (tree_cons (NULL_TREE, expr1,
                            build_expr_list (NULL_TREE, cp_convert (type, integer_zero_node))));
              TREE_TYPE (expr1) = type;
              result = save_expr (result);
@@ -868,7 +868,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 = expr_tree_cons (NULL_TREE, elt, elts);
+      elts = tree_cons (NULL_TREE, elt, elts);
       base_cnt++;
     }
 #if 0
@@ -895,10 +895,10 @@ expand_class_desc (tdecl, type)
       offset = BINFO_OFFSET (vb);
       isvir = build_int_2 (1, 0);
 
-      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_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_cnt++;
       vb = TREE_CHAIN (vb);
@@ -1014,7 +1014,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, expr_tree_cons (NULL_TREE, t, NULL_TREE))));
+      (NULL_TREE, attrval, tree_cons (NULL_TREE, t, NULL_TREE))));
 
   fn = get_identifier ("__rtti_attr");
   if (IDENTIFIER_GLOBAL_VALUE (fn))

diff --git a/gcc/cp/search.c b/gcc/cp/search.c
index 6ce849447a8029121cf8d0d58eebdeef7c777f5c..818ab144f45fd20ae67b3bb9afc354c931a4a252 100644 (file)
--- a/gcc/cp/search.c
+++ b/gcc/cp/search.c
@@ -1333,14 +1333,12 @@ lookup_field_r (binfo, data)
              /* This is the first time we noticed an ambiguity.  Add
                 what we previously thought was a reasonable candidate
                 to the list.  */
-             lfi->ambiguous = scratch_tree_cons (NULL_TREE, lfi->rval,
-                                                 NULL_TREE);
+             lfi->ambiguous = tree_cons (NULL_TREE, lfi->rval, NULL_TREE);
              TREE_TYPE (lfi->ambiguous) = error_mark_node;
            }
 
          /* Add the new value.  */
-         lfi->ambiguous = scratch_tree_cons (NULL_TREE, nval, 
-                                             lfi->ambiguous);
+         lfi->ambiguous = tree_cons (NULL_TREE, nval, lfi->ambiguous);
          TREE_TYPE (lfi->ambiguous) = error_mark_node;
          lfi->errstr = "request for member `%D' is ambiguous";
        }
@@ -1484,7 +1482,7 @@ lookup_member (xbasetype, name, protect, want_type)
 
   if (rval && is_overloaded_fn (rval)) 
     {
-      rval = scratch_tree_cons (basetype_path, rval, NULL_TREE);
+      rval = tree_cons (basetype_path, rval, NULL_TREE);
       SET_BASELINK_P (rval);
     }
 
@@ -1774,10 +1772,9 @@ get_virtuals_named_this_r (binfo, data)
   idx = lookup_fnfields_here (BINFO_TYPE (binfo), gvnti->name);
   if (idx >= 0)
     gvnti->fields
-      = scratch_tree_cons (binfo, 
-                          TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
-                                        idx),
-                          gvnti->fields);
+      = tree_cons (binfo, 
+                  TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), idx),
+                  gvnti->fields);
 
   return NULL_TREE;
 }
@@ -3150,8 +3147,6 @@ reinit_search_statistics ()
 #endif /* GATHER_STATISTICS */
 }
 
-#define scratch_tree_cons expr_tree_cons
-
 static tree
 add_conversions (binfo, data)
      tree binfo;
@@ -3178,7 +3173,7 @@ add_conversions (binfo, data)
       /* Make sure we don't already have this conversion.  */
       if (! IDENTIFIER_MARKED (name))
        {
-         *conversions = scratch_tree_cons (binfo, tmp, *conversions);
+         *conversions = tree_cons (binfo, tmp, *conversions);
          IDENTIFIER_MARKED (name) = 1;
        }
     }

diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index e71cf1279254091d17afb4415ba94650870551f9..2cb6721bb76c18504fb441c945714ab0cb3c91f4 100644 (file)
--- a/gcc/cp/tree.c
+++ b/gcc/cp/tree.c
@@ -2522,19 +2522,10 @@ build_srcloc (file, line)
 {
   tree t;
 
-  /* Make sure that we put these on the permanent obstack; up in
-     add_pending_template, we pass this return value into perm_tree_cons,
-     which also puts it on the permanent_obstack.  However, this wasn't
-     explicitly doing the same.  */
-  register struct obstack *ambient_obstack = current_obstack;
-  current_obstack = &permanent_obstack;
-
   t = make_node (SRCLOC);
   SRCLOC_FILE (t) = file;
   SRCLOC_LINE (t) = line;
 
-  current_obstack = ambient_obstack;
-
   return t;
 }
 

diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 68563f801ac8b6026ff53b60f14de467fd0c7dd4..b035fbe93b2fb31b355d2bbb69e062d26f32b163 100644 (file)
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -2833,7 +2833,7 @@ build_x_function_call (function, params, decl)
        function = TREE_OPERAND (function, 1);
 
       function = get_member_function_from_ptrfunc (&decl_addr, function);
-      params = expr_tree_cons (NULL_TREE, decl_addr, params);
+      params = tree_cons (NULL_TREE, decl_addr, params);
       return build_function_call (function, params);
     }
 
@@ -2884,7 +2884,7 @@ build_x_function_call (function, params, decl)
        }
       else
        decl = build_c_cast (ctypeptr, decl);
-      params = expr_tree_cons (NULL_TREE, decl, params);
+      params = tree_cons (NULL_TREE, decl, params);
     }
 
   return build_function_call (function, params);
@@ -3260,14 +3260,14 @@ convert_arguments (typelist, values, fndecl, flags)
          if (parmval == error_mark_node)
            return error_mark_node;
 
-         result = expr_tree_cons (NULL_TREE, parmval, result);
+         result = tree_cons (NULL_TREE, parmval, result);
        }
       else
        {
          if (TREE_CODE (TREE_TYPE (val)) == REFERENCE_TYPE)
            val = convert_from_reference (val);
 
-         result = expr_tree_cons (NULL_TREE,
+         result = tree_cons (NULL_TREE,
                                   convert_arg_to_ellipsis (val),
                                   result);
        }
@@ -3291,7 +3291,7 @@ convert_arguments (typelist, values, fndecl, flags)
              if (parmval == error_mark_node)
                return error_mark_node;
 
-             result = expr_tree_cons (0, parmval, result);
+             result = tree_cons (0, parmval, result);
              typetail = TREE_CHAIN (typetail);
              /* ends with `...'.  */
              if (typetail == NULL_TREE)
@@ -5155,7 +5155,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 (expr_tree_cons (NULL_TREE, result,
+    return build_x_compound_expr (tree_cons (NULL_TREE, result,
                                                  TREE_CHAIN (rest)));
 
   if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
@@ -5174,7 +5174,7 @@ build_x_compound_expr (list)
 #endif
 
   return build_compound_expr
-    (expr_tree_cons (NULL_TREE, TREE_VALUE (list),
+    (tree_cons (NULL_TREE, TREE_VALUE (list),
                     build_expr_list (NULL_TREE,
                                      build_x_compound_expr (rest))));
 }
@@ -6182,18 +6182,18 @@ build_ptrmemfunc1 (type, delta, idx, pfn, delta2)
   if (pfn)
     {
       u = build_nt (CONSTRUCTOR, NULL_TREE,
-                   expr_tree_cons (pfn_identifier, pfn, NULL_TREE));
+                   tree_cons (pfn_identifier, pfn, NULL_TREE));
     }
   else
     {
       u = build_nt (CONSTRUCTOR, NULL_TREE,
-                   expr_tree_cons (delta2_identifier, delta2, NULL_TREE));
+                   tree_cons (delta2_identifier, delta2, NULL_TREE));
     }
 
   u = build_nt (CONSTRUCTOR, NULL_TREE,
-               expr_tree_cons (NULL_TREE, delta,
-                          expr_tree_cons (NULL_TREE, idx,
-                                     expr_tree_cons (NULL_TREE, u, NULL_TREE))));
+               tree_cons (NULL_TREE, delta,
+                          tree_cons (NULL_TREE, idx,
+                                     tree_cons (NULL_TREE, u, NULL_TREE))));
 
   return digest_init (type, u, (tree*)0);
 #else
@@ -6212,14 +6212,14 @@ build_ptrmemfunc1 (type, delta, idx, pfn, delta2)
     {
       allconstant = TREE_CONSTANT (pfn);
       allsimple = !! initializer_constant_valid_p (pfn, TREE_TYPE (pfn));
-      u = expr_tree_cons (pfn_field, pfn, NULL_TREE);
+      u = 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 = expr_tree_cons (delta2_field, delta2, NULL_TREE);
+      u = tree_cons (delta2_field, delta2, NULL_TREE);
     }
 
   delta = convert_and_check (delta_type_node, delta);
@@ -6231,9 +6231,9 @@ build_ptrmemfunc1 (type, delta, idx, pfn, delta2)
       && initializer_constant_valid_p (idx, TREE_TYPE (idx));
 
   u = build (CONSTRUCTOR, subtype, NULL_TREE, u);
-  u = expr_tree_cons (delta_field, delta,
-                expr_tree_cons (idx_field, idx,
-                           expr_tree_cons (pfn_or_delta2_field, u, NULL_TREE)));
+  u = tree_cons (delta_field, delta,
+                tree_cons (idx_field, idx,
+                           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;