-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>
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;
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
{
&& ! (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;
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);
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 *)
#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
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
|| 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));
}
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),
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);
}
len = list_length (argnode);
- convs = make_tree_vec (len);
+ convs = make_scratch_vec (len);
for (i = 0; i < len; ++i)
{
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;
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;
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;
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)
{
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;
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]);
}
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]);
}
}
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;
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;
{
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);
}
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);
}
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))
{
{
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);
{
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);
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,
{
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,
{
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);
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);
/* + 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);
{
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),
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;
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
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);
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);
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);
&& (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 */
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);
}
/* 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);
&& ! (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;
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,
{
tree reverse_path = NULL_TREE;
+ push_expression_obstack ();
while (path)
{
tree r = copy_node (path);
path = BINFO_INHERITANCE_CHAIN (path);
}
path = reverse_path;
+ pop_obstacks ();
}
basetype = BINFO_TYPE (path);
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
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;
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),
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));
&& ! 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)))
{
{
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);
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);
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. */
}
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);
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
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);
}
&& ! 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,
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);
}
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,
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);
/* 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);
the names don't match, there is some specialization
occurring. */
templates =
- tree_cons (NULL_TREE, fndecl, templates);
+ scratch_tree_cons (NULL_TREE, fndecl, templates);
}
}
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)
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:
{
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;
}
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));
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
#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);
/* 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));
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
{
/* 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));
/* 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)
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);
/* 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);
{
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
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;
}
{
/* 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,
{
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;
}
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)
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;
}
if (pending_sizes)
rval = build_compound_expr (chainon (pending_sizes,
- build_tree_list (NULL_TREE, rval)));
+ build_expr_list (NULL_TREE, rval)));
return rval;
}
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));
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:
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
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;
}
{
/* 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);
/* 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.
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));
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)
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)
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. */
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))
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);
}
}
{
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),
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;
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);
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);
(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. */
}
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);
}
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);
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))
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
;
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:
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. */
}
}
- matching_fns = tree_cons (fn, targs, matching_fns);
+ matching_fns = scratch_tree_cons (fn, targs, matching_fns);
}
}
}
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);
{
/* 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);
}
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,
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,
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);
}
{
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);
(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
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);
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))
/* 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;
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);
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);
}
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);
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);
#endif /* GATHER_STATISTICS */
}
+#define scratch_tree_cons expr_tree_cons
+
static tree conversions;
static void
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);
}
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
/* 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. */
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
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);
}
}
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);
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
{
&& (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)
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)
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)))
{
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
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);
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;
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
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
{
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);
&& 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;
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)
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)
if (! DECL_NAME (field))
{
- members = tree_cons (field, integer_zero_node, members);
+ members = expr_tree_cons (field, integer_zero_node, members);
continue;
}
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))
{
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'",
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. */
projects / thirdparty / gcc.git / commitdiff
