#include "config.h"
#include "system.h"
#include "tree.h"
#include "rtl.h"
#include "expr.h"
#include "cp-tree.h"
#include "flags.h"
#include "output.h"
#include "except.h"
#include "toplev.h"
#include "ggc.h"
static void expand_aggr_vbase_init_1 PARAMS ((tree, tree, tree, tree));
static void construct_virtual_bases PARAMS ((tree, tree, tree, tree, tree));
static void expand_aggr_init_1 PARAMS ((tree, tree, tree, tree, int));
static void expand_default_init PARAMS ((tree, tree, tree, tree, int));
static tree build_vec_delete_1 PARAMS ((tree, tree, tree, special_function_kind, int));
static void perform_member_init PARAMS ((tree, tree, int));
static void sort_base_init PARAMS ((tree, tree, tree *, tree *));
static tree build_builtin_delete_call PARAMS ((tree));
static int member_init_ok_or_else PARAMS ((tree, tree, tree));
static void expand_virtual_init PARAMS ((tree, tree));
static tree sort_member_init PARAMS ((tree, tree));
static tree initializing_context PARAMS ((tree));
static void expand_cleanup_for_base PARAMS ((tree, tree));
static tree get_temp_regvar PARAMS ((tree, tree));
static tree dfs_initialize_vtbl_ptrs PARAMS ((tree, void *));
static tree build_default_init PARAMS ((tree));
static tree build_new_1 PARAMS ((tree));
static tree get_cookie_size PARAMS ((tree));
static tree build_dtor_call PARAMS ((tree, special_function_kind, int));
static tree build_field_list PARAMS ((tree, tree, int *));
static tree build_vtbl_address PARAMS ((tree));
static tree BI_header_type;
void
init_init_processing ()
{
tree fields[1];
BI_header_type = make_aggr_type (RECORD_TYPE);
fields[0] = build_decl (FIELD_DECL, nelts_identifier, sizetype);
finish_builtin_type (BI_header_type, "__new_cookie", fields,
0, double_type_node);
ggc_add_tree_root (&BI_header_type, 1);
}
void
begin_init_stmts (stmt_expr_p, compound_stmt_p)
tree *stmt_expr_p;
tree *compound_stmt_p;
{
if (building_stmt_tree ())
*stmt_expr_p = begin_stmt_expr ();
else
*stmt_expr_p = begin_global_stmt_expr ();
if (building_stmt_tree ())
*compound_stmt_p = begin_compound_stmt (1);
}
tree
finish_init_stmts (stmt_expr, compound_stmt)
tree stmt_expr;
tree compound_stmt;
{
if (building_stmt_tree ())
finish_compound_stmt (1, compound_stmt);
if (building_stmt_tree ())
{
stmt_expr = finish_stmt_expr (stmt_expr);
STMT_EXPR_NO_SCOPE (stmt_expr) = true;
}
else
stmt_expr = finish_global_stmt_expr (stmt_expr);
if (stmt_expr)
TREE_USED (stmt_expr) = 1;
return stmt_expr;
}
static tree
dfs_initialize_vtbl_ptrs (binfo, data)
tree binfo;
void *data;
{
if ((!BINFO_PRIMARY_P (binfo) || TREE_VIA_VIRTUAL (binfo))
&& CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
{
tree base_ptr = TREE_VALUE ((tree) data);
base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, 1);
expand_virtual_init (binfo, base_ptr);
}
SET_BINFO_MARKED (binfo);
return NULL_TREE;
}
void
initialize_vtbl_ptrs (addr)
tree addr;
{
tree list;
tree type;
type = TREE_TYPE (TREE_TYPE (addr));
list = build_tree_list (type, addr);
dfs_walk_real (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs,
NULL, dfs_unmarked_real_bases_queue_p, list);
dfs_walk (TYPE_BINFO (type), dfs_unmark,
dfs_marked_real_bases_queue_p, type);
}
static tree
build_default_init (type)
tree type;
{
tree init = NULL_TREE;
if (TYPE_NEEDS_CONSTRUCTING (type))
return NULL_TREE;
else if (AGGREGATE_TYPE_P (type) && !TYPE_PTRMEMFUNC_P (type))
{
init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, NULL_TREE);
}
else if (TREE_CODE (type) == REFERENCE_TYPE)
return NULL_TREE;
else
{
init = integer_zero_node;
if (TREE_CODE (type) == ENUMERAL_TYPE)
init = fold (build1 (NOP_EXPR, type, init));
}
init = digest_init (type, init, 0);
return init;
}
static void
perform_member_init (member, init, explicit)
tree member, init;
int explicit;
{
tree decl;
tree type = TREE_TYPE (member);
decl = build_component_ref (current_class_ref, member, NULL_TREE, explicit);
if (decl == error_mark_node)
return;
if (ANON_AGGR_TYPE_P (type))
{
if (init)
{
init = build (INIT_EXPR, type, decl, TREE_VALUE (init));
finish_expr_stmt (init);
}
}
else if (TYPE_NEEDS_CONSTRUCTING (type)
|| (init && TYPE_HAS_CONSTRUCTOR (type)))
{
if (init != NULL_TREE && TREE_CODE (init) != TREE_LIST)
init = build_tree_list (NULL_TREE, init);
if (explicit
&& TREE_CODE (type) == ARRAY_TYPE
&& init != NULL_TREE
&& TREE_CHAIN (init) == NULL_TREE
&& TREE_CODE (TREE_TYPE (TREE_VALUE (init))) == ARRAY_TYPE)
{
finish_expr_stmt (build_vec_init (decl, TREE_VALUE (init), 1));
}
else
finish_expr_stmt (build_aggr_init (decl, init, 0));
}
else
{
if (init == NULL_TREE)
{
if (explicit)
{
init = build_default_init (type);
if (TREE_CODE (type) == REFERENCE_TYPE)
warning
("default-initialization of `%#D', which has reference type",
member);
}
else if (TREE_CODE (type) == REFERENCE_TYPE)
pedwarn ("uninitialized reference member `%D'", member);
}
else if (TREE_CODE (init) == TREE_LIST)
{
if (TREE_CHAIN (init))
{
warning ("initializer list treated as compound expression");
init = build_compound_expr (init);
}
else
init = TREE_VALUE (init);
}
if (init)
finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
}
if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
{
tree expr;
expr = build_component_ref (current_class_ref, member, NULL_TREE,
explicit);
expr = build_delete (type, expr, sfk_complete_destructor,
LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
if (expr != error_mark_node)
finish_subobject (expr);
}
}
static tree
build_field_list (t, list, uses_unions_p)
tree t;
tree list;
int *uses_unions_p;
{
tree fields;
if (TREE_CODE (t) == UNION_TYPE)
*uses_unions_p = 1;
for (fields = TYPE_FIELDS (t); fields; fields = TREE_CHAIN (fields))
{
if (TREE_CODE (fields) != FIELD_DECL)
continue;
if (TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
*uses_unions_p = 1;
if (ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
{
list = tree_cons (fields, NULL_TREE, list);
list = build_field_list (TREE_TYPE (fields), list,
uses_unions_p);
}
else if (DECL_NAME (fields))
list = tree_cons (fields, NULL_TREE, list);
}
return list;
}
static tree
sort_member_init (t, member_init_list)
tree t;
tree member_init_list;
{
tree init_list;
tree last_field;
tree init;
int uses_unions_p;
init_list = nreverse (build_field_list (t, NULL_TREE, &uses_unions_p));
last_field = init_list;
for (init = member_init_list; init; init = TREE_CHAIN (init))
{
tree f;
tree initialized_field;
initialized_field = TREE_PURPOSE (init);
my_friendly_assert (TREE_CODE (initialized_field) == FIELD_DECL,
20000516);
for (f = last_field; f; f = TREE_CHAIN (f))
if (TREE_PURPOSE (f) == initialized_field)
break;
if (warn_reorder && !f)
{
cp_warning_at ("member initializers for `%#D'",
TREE_PURPOSE (last_field));
cp_warning_at (" and `%#D'", initialized_field);
warning (" will be re-ordered to match declaration order");
}
if (!f)
{
f = init_list;
while (TREE_PURPOSE (f) != initialized_field)
f = TREE_CHAIN (f);
}
if (TREE_TYPE (f))
error ("multiple initializations given for member `%D'",
initialized_field);
else
{
TREE_TYPE (f) = error_mark_node;
TREE_VALUE (f) = TREE_VALUE (init);
}
last_field = f;
}
if (uses_unions_p)
{
last_field = NULL_TREE;
for (init = init_list; init; init = TREE_CHAIN (init))
{
tree field;
tree field_type;
int done;
if (!TREE_TYPE (init))
continue;
field = TREE_PURPOSE (init);
for (field_type = DECL_CONTEXT (field);
!same_type_p (field_type, t);
field_type = TYPE_CONTEXT (field_type))
if (TREE_CODE (field_type) == UNION_TYPE)
break;
if (TREE_CODE (field_type) != UNION_TYPE)
continue;
if (!last_field)
{
last_field = field;
continue;
}
field_type = DECL_CONTEXT (field);
done = 0;
do
{
tree last_field_type;
last_field_type = DECL_CONTEXT (last_field);
while (1)
{
if (same_type_p (last_field_type, field_type))
{
if (TREE_CODE (field_type) == UNION_TYPE)
error ("initializations for multiple members of `%T'",
last_field_type);
done = 1;
break;
}
if (same_type_p (last_field_type, t))
break;
last_field_type = TYPE_CONTEXT (last_field_type);
}
if (same_type_p (field_type, t))
break;
field_type = TYPE_CONTEXT (field_type);
}
while (!done);
last_field = field;
}
}
return init_list;
}
static void
sort_base_init (t, base_init_list, rbase_ptr, vbase_ptr)
tree t;
tree base_init_list;
tree *rbase_ptr, *vbase_ptr;
{
tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
int i;
tree x;
tree last;
int last_pos = 0;
tree last_base = NULL_TREE;
tree rbases = NULL_TREE;
tree vbases = NULL_TREE;
last = tree_cons (NULL_TREE, NULL_TREE, base_init_list);
for (x = TREE_CHAIN (last); x; x = TREE_CHAIN (x))
{
tree basetype = TREE_PURPOSE (x);
tree binfo = (TREE_CODE (basetype) == TREE_VEC
? basetype : binfo_or_else (basetype, t));
if (binfo == NULL_TREE)
continue;
if (TREE_VIA_VIRTUAL (binfo))
{
tree v = binfo_for_vbase (BINFO_TYPE (binfo), t);
vbases = tree_cons (v, TREE_VALUE (x), vbases);
}
else
{
my_friendly_assert
(same_type_p (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)),
t), 20011113);
TREE_PURPOSE (x) = binfo;
TREE_CHAIN (last) = x;
last = x;
}
}
TREE_CHAIN (last) = NULL_TREE;
for (i = 0; i < n_baseclasses; ++i)
{
tree base_binfo = TREE_VEC_ELT (binfos, i);
tree init;
int pos;
if (TREE_VIA_VIRTUAL (base_binfo))
continue;
init = NULL_TREE;
for (x = base_init_list, pos = 0; x; x = TREE_CHAIN (x), ++pos)
{
tree binfo = TREE_PURPOSE (x);
if (binfo == base_binfo && !init)
{
if (warn_reorder)
{
if (pos < last_pos)
{
cp_warning_at ("base initializers for `%#T'", last_base);
cp_warning_at (" and `%#T'", BINFO_TYPE (binfo));
warning (" will be re-ordered to match inheritance order");
}
last_pos = pos;
last_base = BINFO_TYPE (binfo);
}
TREE_PURPOSE (x) = NULL_TREE;
init = build_tree_list (binfo, TREE_VALUE (x));
}
else if (binfo == base_binfo)
{
error ("base class `%T' already initialized",
BINFO_TYPE (binfo));
break;
}
}
if (!init)
init = build_tree_list (NULL_TREE, NULL_TREE);
rbases = chainon (rbases, init);
}
*rbase_ptr = rbases;
*vbase_ptr = vbases;
}
void
emit_base_init (mem_init_list, base_init_list)
tree mem_init_list;
tree base_init_list;
{
tree member;
tree rbase_init_list, vbase_init_list;
tree t = current_class_type;
tree t_binfo = TYPE_BINFO (t);
tree binfos = BINFO_BASETYPES (t_binfo);
int i;
int n_baseclasses = BINFO_N_BASETYPES (t_binfo);
mem_init_list = sort_member_init (t, mem_init_list);
sort_base_init (t, base_init_list, &rbase_init_list, &vbase_init_list);
if (TYPE_USES_VIRTUAL_BASECLASSES (t))
{
tree first_arg = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
construct_virtual_bases (t, current_class_ref, current_class_ptr,
vbase_init_list, first_arg);
}
for (i = 0; i < n_baseclasses; i++)
{
tree base_binfo = TREE_VEC_ELT (binfos, i);
tree init = void_list_node;
if (TREE_VIA_VIRTUAL (base_binfo))
continue;
my_friendly_assert (BINFO_INHERITANCE_CHAIN (base_binfo) == t_binfo,
999);
if (TREE_PURPOSE (rbase_init_list))
init = TREE_VALUE (rbase_init_list);
else if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo)))
{
init = NULL_TREE;
if (extra_warnings
&& DECL_COPY_CONSTRUCTOR_P (current_function_decl))
warning ("base class `%#T' should be explicitly initialized in the copy constructor",
BINFO_TYPE (base_binfo));
}
if (init != void_list_node)
{
member = build_base_path (PLUS_EXPR, current_class_ptr,
base_binfo, 1);
expand_aggr_init_1 (base_binfo, NULL_TREE,
build_indirect_ref (member, NULL), init,
LOOKUP_NORMAL);
}
expand_cleanup_for_base (base_binfo, NULL_TREE);
rbase_init_list = TREE_CHAIN (rbase_init_list);
}
initialize_vtbl_ptrs (current_class_ptr);
while (mem_init_list)
{
tree init;
tree member;
int from_init_list;
member = TREE_PURPOSE (mem_init_list);
if (TREE_TYPE (mem_init_list))
{
init = TREE_VALUE (mem_init_list);
from_init_list = 1;
}
else
{
init = DECL_INITIAL (member);
from_init_list = 0;
if (warn_ecpp && init == NULL_TREE
&& !DECL_ARTIFICIAL (member)
&& TREE_CODE (TREE_TYPE (member)) != ARRAY_TYPE)
warning ("`%D' should be initialized in the member initialization list", member);
}
perform_member_init (member, init, from_init_list);
mem_init_list = TREE_CHAIN (mem_init_list);
}
}
static tree
build_vtbl_address (binfo)
tree binfo;
{
tree binfo_for = binfo;
tree vtbl;
if (BINFO_VPTR_INDEX (binfo) && TREE_VIA_VIRTUAL (binfo)
&& BINFO_PRIMARY_P (binfo))
while (BINFO_PRIMARY_BASE_OF (binfo_for))
binfo_for = BINFO_PRIMARY_BASE_OF (binfo_for);
vtbl = get_vtbl_decl_for_binfo (binfo_for);
assemble_external (vtbl);
TREE_USED (vtbl) = 1;
vtbl = BINFO_VTABLE (binfo_for);
if (TREE_CODE (vtbl) == VAR_DECL)
{
vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
TREE_CONSTANT (vtbl) = 1;
}
return vtbl;
}
static void
expand_virtual_init (binfo, decl)
tree binfo, decl;
{
tree vtbl, vtbl_ptr;
tree vtt_index;
vtbl = build_vtbl_address (binfo);
vtt_index = BINFO_VPTR_INDEX (binfo);
if (vtt_index)
{
tree vtbl2;
tree vtt_parm;
vtt_parm = current_vtt_parm;
vtbl2 = build (PLUS_EXPR,
TREE_TYPE (vtt_parm),
vtt_parm,
vtt_index);
vtbl2 = build1 (INDIRECT_REF, TREE_TYPE (vtbl), vtbl2);
vtbl = build (COND_EXPR,
TREE_TYPE (vtbl),
build (EQ_EXPR, boolean_type_node,
current_in_charge_parm, integer_zero_node),
vtbl2,
vtbl);
}
vtbl_ptr = build_vfield_ref (build_indirect_ref (decl, NULL),
TREE_TYPE (binfo));
my_friendly_assert (vtbl_ptr != error_mark_node, 20010730);
vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
finish_expr_stmt (build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl));
}
static void
expand_cleanup_for_base (binfo, flag)
tree binfo;
tree flag;
{
tree expr;
if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
return;
expr = (build_scoped_method_call
(current_class_ref, binfo, base_dtor_identifier, NULL_TREE));
if (flag)
expr = fold (build (COND_EXPR, void_type_node,
truthvalue_conversion (flag),
expr, integer_zero_node));
finish_subobject (expr);
}
static void
expand_aggr_vbase_init_1 (binfo, exp, addr, init_list)
tree binfo, exp, addr, init_list;
{
tree init = purpose_member (binfo, init_list);
tree ref = build_indirect_ref (addr, NULL);
if (init)
init = TREE_VALUE (init);
expand_aggr_init_1 (binfo, exp, ref, init, LOOKUP_COMPLAIN);
}
static void
construct_virtual_bases (type, this_ref, this_ptr, init_list, flag)
tree type;
tree this_ref;
tree this_ptr;
tree init_list;
tree flag;
{
tree vbases;
my_friendly_assert (TYPE_USES_VIRTUAL_BASECLASSES (type), 19990621);
for (vbases = CLASSTYPE_VBASECLASSES (type); vbases;
vbases = TREE_CHAIN (vbases))
{
tree inner_if_stmt;
tree compound_stmt;
tree exp;
tree vbase;
inner_if_stmt = begin_if_stmt ();
finish_if_stmt_cond (flag, inner_if_stmt);
compound_stmt = begin_compound_stmt (1);
vbase = TREE_VALUE (vbases);
exp = build (PLUS_EXPR,
TREE_TYPE (this_ptr),
this_ptr,
fold (build1 (NOP_EXPR, TREE_TYPE (this_ptr),
BINFO_OFFSET (vbase))));
exp = build1 (NOP_EXPR,
build_pointer_type (BINFO_TYPE (vbase)),
exp);
expand_aggr_vbase_init_1 (vbase, this_ref, exp, init_list);
finish_compound_stmt (1, compound_stmt);
finish_then_clause (inner_if_stmt);
finish_if_stmt ();
expand_cleanup_for_base (vbase, flag);
}
}
static tree
initializing_context (field)
tree field;
{
tree t = DECL_CONTEXT (field);
while (t && ANON_AGGR_TYPE_P (t))
t = TYPE_CONTEXT (t);
return t;
}
static int
member_init_ok_or_else (field, type, member_name)
tree field;
tree type;
tree member_name;
{
if (field == error_mark_node)
return 0;
if (field == NULL_TREE || initializing_context (field) != type)
{
error ("class `%T' does not have any field named `%D'", type,
member_name);
return 0;
}
if (TREE_STATIC (field))
{
error ("field `%#D' is static; the only point of initialization is its definition",
field);
return 0;
}
return 1;
}
tree
expand_member_init (exp, name, init)
tree exp, name, init;
{
tree basetype = NULL_TREE, field;
tree type;
if (exp == NULL_TREE)
return NULL_TREE;
type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
my_friendly_assert (IS_AGGR_TYPE (type), 20011113);
if (!name)
{
switch (CLASSTYPE_N_BASECLASSES (type))
{
case 0:
error ("unnamed initializer for `%T', which has no base classes",
type);
return NULL_TREE;
case 1:
basetype = TYPE_BINFO_BASETYPE (type, 0);
break;
default:
error ("unnamed initializer for `%T', which uses multiple inheritance",
type);
return NULL_TREE;
}
}
else if (TYPE_P (name))
{
basetype = name;
name = TYPE_NAME (name);
}
else if (TREE_CODE (name) == TYPE_DECL)
basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
my_friendly_assert (init != NULL_TREE, 0);
if (init == void_type_node)
init = NULL_TREE;
if (basetype)
{
if (current_template_parms)
;
else if (vec_binfo_member (basetype, TYPE_BINFO_BASETYPES (type)))
;
else if (binfo_for_vbase (basetype, type))
;
else
{
if (TYPE_USES_VIRTUAL_BASECLASSES (type))
error ("type `%D' is not a direct or virtual base of `%T'",
name, type);
else
error ("type `%D' is not a direct base of `%T'",
name, type);
return NULL_TREE;
}
init = build_tree_list (basetype, init);
}
else
{
field = lookup_field (type, name, 1, 0);
if (! member_init_ok_or_else (field, type, name))
return NULL_TREE;
init = build_tree_list (field, init);
}
return init;
}
tree
build_aggr_init (exp, init, flags)
tree exp, init;
int flags;
{
tree stmt_expr;
tree compound_stmt;
int destroy_temps;
tree type = TREE_TYPE (exp);
int was_const = TREE_READONLY (exp);
int was_volatile = TREE_THIS_VOLATILE (exp);
if (init == error_mark_node)
return error_mark_node;
TREE_READONLY (exp) = 0;
TREE_THIS_VOLATILE (exp) = 0;
if (init && TREE_CODE (init) != TREE_LIST)
flags |= LOOKUP_ONLYCONVERTING;
if (TREE_CODE (type) == ARRAY_TYPE)
{
tree itype = init ? TREE_TYPE (init) : NULL_TREE;
if (init && !itype)
{
error ("bad array initializer");
return error_mark_node;
}
if (cp_type_quals (type) != TYPE_UNQUALIFIED)
{
TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
if (init)
TREE_TYPE (init) = TYPE_MAIN_VARIANT (itype);
}
stmt_expr = build_vec_init (exp, init,
init && same_type_p (TREE_TYPE (init),
TREE_TYPE (exp)));
TREE_READONLY (exp) = was_const;
TREE_THIS_VOLATILE (exp) = was_volatile;
TREE_TYPE (exp) = type;
if (init)
TREE_TYPE (init) = itype;
return stmt_expr;
}
if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
TREE_USED (exp) = 1;
TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
begin_init_stmts (&stmt_expr, &compound_stmt);
destroy_temps = stmts_are_full_exprs_p ();
current_stmt_tree ()->stmts_are_full_exprs_p = 0;
expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
init, LOOKUP_NORMAL|flags);
stmt_expr = finish_init_stmts (stmt_expr, compound_stmt);
current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
TREE_TYPE (exp) = type;
TREE_READONLY (exp) = was_const;
TREE_THIS_VOLATILE (exp) = was_volatile;
return stmt_expr;
}
static void
expand_default_init (binfo, true_exp, exp, init, flags)
tree binfo;
tree true_exp, exp;
tree init;
int flags;
{
tree type = TREE_TYPE (exp);
tree ctor_name;
tree rval;
tree parms;
if (init && TREE_CODE (init) != TREE_LIST
&& (flags & LOOKUP_ONLYCONVERTING))
{
if (true_exp != exp)
abort ();
if (flags & DIRECT_BIND)
;
else if (TREE_CODE (init) == CONSTRUCTOR)
;
else
init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
if (TREE_CODE (init) == TRY_CATCH_EXPR)
TREE_OPERAND (init, 0) = build (INIT_EXPR, TREE_TYPE (exp), exp,
TREE_OPERAND (init, 0));
else
init = build (INIT_EXPR, TREE_TYPE (exp), exp, init);
TREE_SIDE_EFFECTS (init) = 1;
finish_expr_stmt (init);
return;
}
if (init == NULL_TREE
|| (TREE_CODE (init) == TREE_LIST && ! TREE_TYPE (init)))
{
parms = init;
if (parms)
init = TREE_VALUE (parms);
}
else
parms = build_tree_list (NULL_TREE, init);
if (true_exp == exp)
ctor_name = complete_ctor_identifier;
else
ctor_name = base_ctor_identifier;
rval = build_method_call (exp, ctor_name, parms, binfo, flags);
if (TREE_SIDE_EFFECTS (rval))
{
if (building_stmt_tree ())
finish_expr_stmt (rval);
else
genrtl_expr_stmt (rval);
}
}
static void
expand_aggr_init_1 (binfo, true_exp, exp, init, flags)
tree binfo;
tree true_exp, exp;
tree init;
int flags;
{
tree type = TREE_TYPE (exp);
my_friendly_assert (init != error_mark_node && type != error_mark_node, 211);
if (init && TREE_CODE (exp) == VAR_DECL
&& TREE_CODE (init) == CONSTRUCTOR
&& TREE_HAS_CONSTRUCTOR (init))
{
if (!store_init_value (exp, init))
{
if (!building_stmt_tree ())
expand_decl_init (exp);
}
else
finish_expr_stmt (build (INIT_EXPR, type, exp, init));
return;
}
expand_default_init (binfo, true_exp, exp, init, flags);
}
int
is_aggr_type (type, or_else)
tree type;
int or_else;
{
if (type == error_mark_node)
return 0;
if (! IS_AGGR_TYPE (type)
&& TREE_CODE (type) != TEMPLATE_TYPE_PARM
&& TREE_CODE (type) != BOUND_TEMPLATE_TEMPLATE_PARM)
{
if (or_else)
error ("`%T' is not an aggregate type", type);
return 0;
}
return 1;
}
tree
get_aggr_from_typedef (name, or_else)
tree name;
int or_else;
{
tree type;
if (name == error_mark_node)
return NULL_TREE;
if (IDENTIFIER_HAS_TYPE_VALUE (name))
type = IDENTIFIER_TYPE_VALUE (name);
else
{
if (or_else)
error ("`%T' fails to be an aggregate typedef", name);
return NULL_TREE;
}
if (! IS_AGGR_TYPE (type)
&& TREE_CODE (type) != TEMPLATE_TYPE_PARM
&& TREE_CODE (type) != BOUND_TEMPLATE_TEMPLATE_PARM)
{
if (or_else)
error ("type `%T' is of non-aggregate type", type);
return NULL_TREE;
}
return type;
}
tree
get_type_value (name)
tree name;
{
if (name == error_mark_node)
return NULL_TREE;
if (IDENTIFIER_HAS_TYPE_VALUE (name))
return IDENTIFIER_TYPE_VALUE (name);
else
return NULL_TREE;
}
tree
build_member_call (type, name, parmlist)
tree type, name, parmlist;
{
tree t;
tree method_name;
int dtor = 0;
tree basetype_path, decl;
if (TREE_CODE (name) == TEMPLATE_ID_EXPR
&& TREE_CODE (type) == NAMESPACE_DECL)
{
method_name = TREE_OPERAND (name, 0);
if (TREE_CODE (method_name) == LOOKUP_EXPR)
{
method_name = lookup_namespace_name
(type, TREE_OPERAND (method_name, 0));
TREE_OPERAND (name, 0) = method_name;
}
my_friendly_assert (is_overloaded_fn (method_name), 980519);
return build_x_function_call (name, parmlist, current_class_ref);
}
if (DECL_P (name))
name = DECL_NAME (name);
if (TREE_CODE (type) == NAMESPACE_DECL)
return build_x_function_call (lookup_namespace_name (type, name),
parmlist, current_class_ref);
if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
{
method_name = TREE_OPERAND (name, 0);
if (TREE_CODE (method_name) == COMPONENT_REF)
method_name = TREE_OPERAND (method_name, 1);
if (is_overloaded_fn (method_name))
method_name = DECL_NAME (OVL_CURRENT (method_name));
TREE_OPERAND (name, 0) = method_name;
}
else
method_name = name;
if (TREE_CODE (method_name) == BIT_NOT_EXPR)
{
method_name = TREE_OPERAND (method_name, 0);
dtor = 1;
}
if (type && TREE_CODE (type) == IDENTIFIER_NODE
&& get_aggr_from_typedef (type, 0) == 0)
{
tree ns = lookup_name (type, 0);
if (ns && TREE_CODE (ns) == NAMESPACE_DECL)
{
return build_x_function_call (build_offset_ref (type, name),
parmlist, current_class_ref);
}
}
if (type == NULL_TREE || ! is_aggr_type (type, 1))
return error_mark_node;
if (name == NULL_TREE)
return error_mark_node;
if (dtor)
{
error ("cannot call destructor `%T::~%T' without object", type,
method_name);
return error_mark_node;
}
decl = maybe_dummy_object (type, &basetype_path);
if (decl == current_class_ref
&& ACCESSIBLY_UNIQUELY_DERIVED_P (type, current_class_type))
{
tree olddecl = current_class_ptr;
tree oldtype = TREE_TYPE (TREE_TYPE (olddecl));
if (oldtype != type)
{
tree newtype = build_qualified_type (type, TYPE_QUALS (oldtype));
decl = convert_force (build_pointer_type (newtype), olddecl, 0);
decl = build_indirect_ref (decl, NULL);
}
}
if (method_name == constructor_name (type)
|| method_name == constructor_name_full (type))
return build_functional_cast (type, parmlist);
if (lookup_fnfields (basetype_path, method_name, 0))
return build_method_call (decl,
TREE_CODE (name) == TEMPLATE_ID_EXPR
? name : method_name,
parmlist, basetype_path,
LOOKUP_NORMAL|LOOKUP_NONVIRTUAL);
if (TREE_CODE (name) == IDENTIFIER_NODE
&& ((t = lookup_field (TYPE_BINFO (type), name, 1, 0))))
{
if (t == error_mark_node)
return error_mark_node;
if (TREE_CODE (t) == FIELD_DECL)
{
if (is_dummy_object (decl))
{
error ("invalid use of non-static field `%D'", t);
return error_mark_node;
}
decl = build (COMPONENT_REF, TREE_TYPE (t), decl, t);
}
else if (TREE_CODE (t) == VAR_DECL)
decl = t;
else
{
error ("invalid use of member `%D'", t);
return error_mark_node;
}
if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl)))
return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, decl,
parmlist, NULL_TREE);
return build_function_call (decl, parmlist);
}
else
{
error ("no method `%T::%D'", type, name);
return error_mark_node;
}
}
tree
build_offset_ref (type, name)
tree type, name;
{
tree decl, t = error_mark_node;
tree member;
tree basebinfo = NULL_TREE;
tree orig_name = name;
if (TREE_CODE (name) == TEMPLATE_DECL)
return name;
if (processing_template_decl || uses_template_parms (type))
return build_min_nt (SCOPE_REF, type, name);
if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
{
name = TREE_OPERAND (orig_name, 0);
if (DECL_P (name))
name = DECL_NAME (name);
else
{
if (TREE_CODE (name) == LOOKUP_EXPR)
name = TREE_OPERAND (name, 0);
else
{
if (TREE_CODE (name) == COMPONENT_REF)
name = TREE_OPERAND (name, 1);
if (TREE_CODE (name) == OVERLOAD)
name = DECL_NAME (OVL_CURRENT (name));
}
}
my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 0);
}
if (type == NULL_TREE)
return error_mark_node;
if (TREE_CODE (type) == NAMESPACE_DECL)
{
t = lookup_namespace_name (type, name);
if (t == error_mark_node)
return t;
if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
t = build (TEMPLATE_ID_EXPR, TREE_TYPE (t),
t, TREE_OPERAND (orig_name, 1));
if (! type_unknown_p (t))
{
mark_used (t);
t = convert_from_reference (t);
}
return t;
}
if (! is_aggr_type (type, 1))
return error_mark_node;
if (TREE_CODE (name) == BIT_NOT_EXPR)
{
if (! check_dtor_name (type, name))
error ("qualified type `%T' does not match destructor name `~%T'",
type, TREE_OPERAND (name, 0));
name = dtor_identifier;
}
if (!COMPLETE_TYPE_P (complete_type (type))
&& !TYPE_BEING_DEFINED (type))
{
error ("incomplete type `%T' does not have member `%D'", type,
name);
return error_mark_node;
}
decl = maybe_dummy_object (type, &basebinfo);
member = lookup_member (basebinfo, name, 1, 0);
if (member == error_mark_node)
return error_mark_node;
if (member && BASELINK_P (member))
{
tree fnfields = member;
t = TREE_VALUE (fnfields);
if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
{
if (TREE_CODE (t) != OVERLOAD)
t = ovl_cons (t, NULL_TREE);
t = build (TEMPLATE_ID_EXPR, TREE_TYPE (t), t,
TREE_OPERAND (orig_name, 1));
t = build (OFFSET_REF, unknown_type_node, decl, t);
PTRMEM_OK_P (t) = 1;
return t;
}
if (!really_overloaded_fn (t))
{
t = OVL_CURRENT (t);
if (!enforce_access (basebinfo, t))
return error_mark_node;
mark_used (t);
if (DECL_STATIC_FUNCTION_P (t))
return t;
t = build (OFFSET_REF, TREE_TYPE (t), decl, t);
PTRMEM_OK_P (t) = 1;
return t;
}
TREE_TYPE (fnfields) = unknown_type_node;
t = build (OFFSET_REF, unknown_type_node, decl, fnfields);
PTRMEM_OK_P (t) = 1;
return t;
}
t = member;
if (t == NULL_TREE)
{
error ("`%D' is not a member of type `%T'", name, type);
return error_mark_node;
}
if (TREE_CODE (t) == TYPE_DECL)
{
TREE_USED (t) = 1;
return t;
}
if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == CONST_DECL)
{
mark_used (t);
return convert_from_reference (t);
}
if (TREE_CODE (t) == FIELD_DECL && DECL_C_BIT_FIELD (t))
{
error ("illegal pointer to bit-field `%D'", t);
return error_mark_node;
}
if (TREE_CODE (t) == FUNCTION_DECL
&& TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
abort ();
t = build (OFFSET_REF, build_offset_type (type, TREE_TYPE (t)), decl, t);
PTRMEM_OK_P (t) = 1;
return t;
}
tree
resolve_offset_ref (exp)
tree exp;
{
tree type = TREE_TYPE (exp);
tree base = NULL_TREE;
tree member;
tree basetype, addr;
if (TREE_CODE (exp) == OFFSET_REF)
{
member = TREE_OPERAND (exp, 1);
base = TREE_OPERAND (exp, 0);
}
else
{
my_friendly_assert (TREE_CODE (type) == OFFSET_TYPE, 214);
if (TYPE_OFFSET_BASETYPE (type) != current_class_type)
{
error ("object missing in use of pointer-to-member construct");
return error_mark_node;
}
member = exp;
type = TREE_TYPE (type);
base = current_class_ref;
}
if (BASELINK_P (member) || TREE_CODE (member) == TEMPLATE_ID_EXPR)
return build_unary_op (ADDR_EXPR, exp, 0);
if (TREE_CODE (TREE_TYPE (member)) == METHOD_TYPE)
{
if (!flag_ms_extensions)
exp = ovl_cons (member, NULL_TREE);
return build_unary_op (ADDR_EXPR, exp, 0);
}
if ((TREE_CODE (member) == VAR_DECL
&& ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member))
&& ! TYPE_PTRMEM_P (TREE_TYPE (member)))
|| TREE_CODE (TREE_TYPE (member)) == FUNCTION_TYPE)
{
if (mark_addressable (member) == 0)
return error_mark_node;
return member;
}
if (TREE_CODE (TREE_TYPE (member)) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (TREE_TYPE (member))) == METHOD_TYPE)
return member;
if (TREE_CODE (member) == FIELD_DECL && current_class_ref == NULL_TREE)
{
cp_error_at ("member `%D' is non-static but referenced as a static member",
member);
error ("at this point in file");
return error_mark_node;
}
if (TREE_CODE (member) == FIELD_DECL
&& (base == current_class_ref || is_dummy_object (base)))
{
tree binfo = TYPE_BINFO (current_class_type);
base = current_class_ref;
if (TREE_CODE (exp) == OFFSET_REF && TREE_CODE (type) == OFFSET_TYPE)
{
binfo = binfo_or_else (TYPE_OFFSET_BASETYPE (type),
current_class_type);
if (!binfo)
return error_mark_node;
base = build_base_path (PLUS_EXPR, base, binfo, 1);
}
return build_component_ref (base, member, binfo, 1);
}
if (is_dummy_object (base))
addr = error_mark_node;
else
addr = build_unary_op (ADDR_EXPR, base, 0);
if (TYPE_PTRMEM_P (TREE_TYPE (member)))
{
if (addr == error_mark_node)
{
error ("object missing in `%E'", exp);
return error_mark_node;
}
basetype = TYPE_OFFSET_BASETYPE (TREE_TYPE (TREE_TYPE (member)));
basetype = lookup_base (TREE_TYPE (TREE_TYPE (addr)),
basetype, ba_check, NULL);
addr = build_base_path (PLUS_EXPR, addr, basetype, 1);
member = cp_convert (ptrdiff_type_node, member);
addr = build (PLUS_EXPR, build_pointer_type (type), addr, member);
return build_indirect_ref (addr, 0);
}
else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member)))
{
return get_member_function_from_ptrfunc (&addr, member);
}
abort ();
return NULL_TREE;
}
tree
decl_constant_value (decl)
tree decl;
{
if (TREE_READONLY_DECL_P (decl)
&& ! TREE_THIS_VOLATILE (decl)
&& DECL_INITIAL (decl)
&& DECL_INITIAL (decl) != error_mark_node
&& TREE_CONSTANT (DECL_INITIAL (decl))
&& TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
return DECL_INITIAL (decl);
return decl;
}
static tree
build_builtin_delete_call (addr)
tree addr;
{
mark_used (global_delete_fndecl);
return build_call (global_delete_fndecl, build_tree_list (NULL_TREE, addr));
}
tree
build_new (placement, decl, init, use_global_new)
tree placement;
tree decl, init;
int use_global_new;
{
tree type, rval;
tree nelts = NULL_TREE, t;
int has_array = 0;
if (decl == error_mark_node)
return error_mark_node;
if (TREE_CODE (decl) == TREE_LIST)
{
tree absdcl = TREE_VALUE (decl);
tree last_absdcl = NULL_TREE;
if (current_function_decl
&& DECL_CONSTRUCTOR_P (current_function_decl))
my_friendly_assert (immediate_size_expand == 0, 19990926);
nelts = integer_one_node;
if (absdcl && TREE_CODE (absdcl) == CALL_EXPR)
abort ();
while (absdcl && TREE_CODE (absdcl) == INDIRECT_REF)
{
last_absdcl = absdcl;
absdcl = TREE_OPERAND (absdcl, 0);
}
if (absdcl && TREE_CODE (absdcl) == ARRAY_REF)
{
tree this_nelts;
while (TREE_OPERAND (absdcl, 0)
&& TREE_CODE (TREE_OPERAND (absdcl, 0)) == ARRAY_REF)
{
last_absdcl = absdcl;
absdcl = TREE_OPERAND (absdcl, 0);
}
has_array = 1;
this_nelts = TREE_OPERAND (absdcl, 1);
if (this_nelts != error_mark_node)
{
if (this_nelts == NULL_TREE)
error ("new of array type fails to specify size");
else if (processing_template_decl)
{
nelts = this_nelts;
absdcl = TREE_OPERAND (absdcl, 0);
}
else
{
if (build_expr_type_conversion (WANT_INT | WANT_ENUM,
this_nelts, 0)
== NULL_TREE)
pedwarn ("size in array new must have integral type");
this_nelts = save_expr (cp_convert (sizetype, this_nelts));
absdcl = TREE_OPERAND (absdcl, 0);
if (this_nelts == integer_zero_node)
{
warning ("zero size array reserves no space");
nelts = integer_zero_node;
}
else
nelts = cp_build_binary_op (MULT_EXPR, nelts, this_nelts);
}
}
else
nelts = integer_zero_node;
}
if (last_absdcl)
TREE_OPERAND (last_absdcl, 0) = absdcl;
else
TREE_VALUE (decl) = absdcl;
type = groktypename (decl);
if (! type || type == error_mark_node)
return error_mark_node;
}
else if (TREE_CODE (decl) == IDENTIFIER_NODE)
{
if (IDENTIFIER_HAS_TYPE_VALUE (decl))
{
type = IDENTIFIER_TYPE_VALUE (decl);
decl = TYPE_MAIN_DECL (type);
}
else
{
decl = lookup_name (decl, 1);
my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 215);
type = TREE_TYPE (decl);
}
}
else if (TREE_CODE (decl) == TYPE_DECL)
{
type = TREE_TYPE (decl);
}
else
{
type = decl;
decl = TYPE_MAIN_DECL (type);
}
if (processing_template_decl)
{
if (has_array)
t = tree_cons (tree_cons (NULL_TREE, type, NULL_TREE),
build_min_nt (ARRAY_REF, NULL_TREE, nelts),
NULL_TREE);
else
t = type;
rval = build_min_nt (NEW_EXPR, placement, t, init);
NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
return rval;
}
if (TREE_CODE (type) == REFERENCE_TYPE)
{
error ("new cannot be applied to a reference type");
type = TREE_TYPE (type);
}
if (TREE_CODE (type) == FUNCTION_TYPE)
{
error ("new cannot be applied to a function type");
return error_mark_node;
}
if (TREE_CODE (type) == ARRAY_TYPE && has_array == 0)
{
nelts = array_type_nelts_top (type);
has_array = 1;
type = TREE_TYPE (type);
}
if (has_array)
t = build_nt (ARRAY_REF, type, nelts);
else
t = type;
rval = build (NEW_EXPR, build_pointer_type (type), placement, t, init);
NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
TREE_SIDE_EFFECTS (rval) = 1;
rval = build_new_1 (rval);
if (rval == error_mark_node)
return error_mark_node;
rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
TREE_NO_UNUSED_WARNING (rval) = 1;
return rval;
}
tree
build_java_class_ref (type)
tree type;
{
tree name = NULL_TREE, class_decl;
static tree CL_suffix = NULL_TREE;
if (CL_suffix == NULL_TREE)
CL_suffix = get_identifier("class$");
if (jclass_node == NULL_TREE)
{
jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
if (jclass_node == NULL_TREE)
fatal_error ("call to Java constructor, while `jclass' undefined");
jclass_node = TREE_TYPE (jclass_node);
}
{
tree field;
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
if (DECL_NAME (field) == CL_suffix)
{
mangle_decl (field);
name = DECL_ASSEMBLER_NAME (field);
break;
}
if (!field)
internal_error ("can't find class$");
}
class_decl = IDENTIFIER_GLOBAL_VALUE (name);
if (class_decl == NULL_TREE)
{
class_decl = build_decl (VAR_DECL, name, TREE_TYPE (jclass_node));
TREE_STATIC (class_decl) = 1;
DECL_EXTERNAL (class_decl) = 1;
TREE_PUBLIC (class_decl) = 1;
DECL_ARTIFICIAL (class_decl) = 1;
DECL_IGNORED_P (class_decl) = 1;
pushdecl_top_level (class_decl);
make_decl_rtl (class_decl, NULL);
}
return class_decl;
}
static tree
get_cookie_size (type)
tree type;
{
tree cookie_size;
tree sizetype_size;
tree type_align;
sizetype_size = size_in_bytes (sizetype);
type_align = size_int (TYPE_ALIGN_UNIT (type));
if (INT_CST_LT_UNSIGNED (type_align, sizetype_size))
cookie_size = sizetype_size;
else
cookie_size = type_align;
return cookie_size;
}
static tree
build_new_1 (exp)
tree exp;
{
tree placement, init;
tree type, true_type, size, rval, t;
tree full_type;
tree nelts = NULL_TREE;
tree alloc_call, alloc_expr, alloc_node;
tree alloc_fn;
tree cookie_expr, init_expr;
int has_array = 0;
enum tree_code code;
int use_cookie, nothrow, check_new;
int globally_qualified_p;
int use_global_new;
int use_java_new = 0;
tree cookie_size = NULL_TREE;
bool placement_allocation_fn_p;
placement = TREE_OPERAND (exp, 0);
type = TREE_OPERAND (exp, 1);
init = TREE_OPERAND (exp, 2);
globally_qualified_p = NEW_EXPR_USE_GLOBAL (exp);
if (TREE_CODE (type) == ARRAY_REF)
{
has_array = 1;
nelts = TREE_OPERAND (type, 1);
type = TREE_OPERAND (type, 0);
full_type = cp_build_binary_op (MINUS_EXPR, nelts, integer_one_node);
full_type = build_index_type (full_type);
full_type = build_cplus_array_type (type, full_type);
}
else
full_type = type;
true_type = type;
code = has_array ? VEC_NEW_EXPR : NEW_EXPR;
while (TREE_CODE (true_type) == ARRAY_TYPE)
{
tree this_nelts = array_type_nelts_top (true_type);
nelts = cp_build_binary_op (MULT_EXPR, nelts, this_nelts);
true_type = TREE_TYPE (true_type);
}
if (!complete_type_or_else (true_type, exp))
return error_mark_node;
size = size_in_bytes (true_type);
if (has_array)
size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
if (TREE_CODE (true_type) == VOID_TYPE)
{
error ("invalid type `void' for new");
return error_mark_node;
}
if (abstract_virtuals_error (NULL_TREE, true_type))
return error_mark_node;
if (!globally_qualified_p
&& IS_AGGR_TYPE (true_type)
&& (has_array
? TYPE_HAS_ARRAY_NEW_OPERATOR (true_type)
: TYPE_HAS_NEW_OPERATOR (true_type)))
use_global_new = 0;
else
use_global_new = 1;
if (!has_array || !TYPE_VEC_NEW_USES_COOKIE (true_type))
use_cookie = 0;
else if (placement && !TREE_CHAIN (placement)
&& same_type_p (TREE_TYPE (TREE_VALUE (placement)),
ptr_type_node))
use_cookie = !use_global_new;
else
use_cookie = 1;
if (use_cookie)
{
cookie_size = get_cookie_size (true_type);
size = size_binop (PLUS_EXPR, size, cookie_size);
}
if (! placement && TYPE_FOR_JAVA (true_type))
{
tree class_addr, alloc_decl;
tree class_decl = build_java_class_ref (true_type);
tree class_size = size_in_bytes (true_type);
static const char alloc_name[] = "_Jv_AllocObject";
use_java_new = 1;
alloc_decl = IDENTIFIER_GLOBAL_VALUE (get_identifier (alloc_name));
if (alloc_decl == NULL_TREE)
fatal_error ("call to Java constructor with `%s' undefined",
alloc_name);
class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
alloc_call = (build_function_call
(alloc_decl,
tree_cons (NULL_TREE, class_addr,
build_tree_list (NULL_TREE, class_size))));
}
else
{
tree fnname;
tree args;
args = tree_cons (NULL_TREE, size, placement);
fnname = ansi_opname (code);
if (use_global_new)
alloc_call = (build_new_function_call
(lookup_function_nonclass (fnname, args),
args));
else
alloc_call = build_method_call (build_dummy_object (true_type),
fnname, args, NULL_TREE,
LOOKUP_NORMAL);
}
if (alloc_call == error_mark_node)
return error_mark_node;
t = alloc_call;
while (TREE_CODE (t) == COMPOUND_EXPR)
t = TREE_OPERAND (t, 1);
alloc_fn = get_callee_fndecl (t);
my_friendly_assert (alloc_fn != NULL_TREE, 20020325);
placement_allocation_fn_p
= (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
|| varargs_function_p (alloc_fn));
nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
check_new = (flag_check_new || nothrow) && ! use_java_new;
alloc_expr = alloc_call;
if (use_cookie)
alloc_expr = build (PLUS_EXPR, TREE_TYPE (alloc_expr),
alloc_expr, cookie_size);
alloc_expr = convert (build_pointer_type (full_type), alloc_expr);
alloc_expr = get_target_expr (alloc_expr);
alloc_node = TREE_OPERAND (alloc_expr, 0);
if (use_cookie)
{
tree cookie;
cookie = build (MINUS_EXPR, build_pointer_type (sizetype),
alloc_node, size_in_bytes (sizetype));
cookie = build_indirect_ref (cookie, NULL);
cookie_expr = build (MODIFY_EXPR, void_type_node, cookie, nelts);
TREE_SIDE_EFFECTS (cookie_expr) = 1;
}
else
cookie_expr = NULL_TREE;
init_expr = NULL_TREE;
if (TYPE_NEEDS_CONSTRUCTING (type) || init)
{
init_expr = build_indirect_ref (alloc_node, NULL);
if (init == void_zero_node)
init = build_default_init (full_type);
else if (init && pedantic && has_array)
pedwarn ("ISO C++ forbids initialization in array new");
if (has_array)
init_expr = build_vec_init (init_expr, init, 0);
else if (TYPE_NEEDS_CONSTRUCTING (type))
init_expr = build_method_call (init_expr,
complete_ctor_identifier,
init, TYPE_BINFO (true_type),
LOOKUP_NORMAL);
else
{
if (TREE_CODE (init) == TREE_LIST)
{
if (TREE_CHAIN (init) != NULL_TREE)
pedwarn
("initializer list being treated as compound expression");
init = build_compound_expr (init);
}
else if (TREE_CODE (init) == CONSTRUCTOR
&& TREE_TYPE (init) == NULL_TREE)
{
pedwarn ("ISO C++ forbids aggregate initializer to new");
init = digest_init (type, init, 0);
}
init_expr = build_modify_expr (init_expr, INIT_EXPR, init);
}
if (init_expr == error_mark_node)
return error_mark_node;
if (flag_exceptions && ! use_java_new)
{
enum tree_code dcode = has_array ? VEC_DELETE_EXPR : DELETE_EXPR;
tree cleanup;
int flags = (LOOKUP_NORMAL
| (globally_qualified_p * LOOKUP_GLOBAL));
tree delete_node;
if (use_cookie)
delete_node = fold (build (MINUS_EXPR, TREE_TYPE (alloc_node),
alloc_node, cookie_size));
else
delete_node = alloc_node;
flags |= LOOKUP_SPECULATIVELY;
cleanup = build_op_delete_call (dcode, delete_node, size, flags,
(placement_allocation_fn_p
? alloc_call : NULL_TREE));
if (cleanup)
{
tree end, sentry, begin;
begin = get_target_expr (boolean_true_node);
sentry = TREE_OPERAND (begin, 0);
TREE_OPERAND (begin, 2)
= build (COND_EXPR, void_type_node, sentry,
cleanup, void_zero_node);
end = build (MODIFY_EXPR, TREE_TYPE (sentry),
sentry, boolean_false_node);
init_expr
= build (COMPOUND_EXPR, void_type_node, begin,
build (COMPOUND_EXPR, void_type_node, init_expr,
end));
}
}
}
else if (CP_TYPE_CONST_P (true_type))
error ("uninitialized const in `new' of `%#T'", true_type);
rval = alloc_node;
if (init_expr)
rval = build (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
if (cookie_expr)
rval = build (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
if (rval == alloc_node)
rval = TREE_OPERAND (alloc_expr, 1);
else
{
if (check_new)
{
tree ifexp = cp_build_binary_op (NE_EXPR, alloc_node,
integer_zero_node);
rval = build_conditional_expr (ifexp, rval, alloc_node);
}
rval = build (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
}
rval = convert (build_pointer_type (type), rval);
return rval;
}
static tree
build_vec_delete_1 (base, maxindex, type, auto_delete_vec, use_global_delete)
tree base, maxindex, type;
special_function_kind auto_delete_vec;
int use_global_delete;
{
tree virtual_size;
tree ptype = build_pointer_type (type = complete_type (type));
tree size_exp = size_in_bytes (type);
tree tbase, tbase_init;
tree body;
tree loop;
tree deallocate_expr = 0;
tree controller = NULL_TREE;
if (! IS_AGGR_TYPE (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
{
loop = integer_zero_node;
goto no_destructor;
}
virtual_size = size_binop (MULT_EXPR, size_exp,
convert (sizetype, maxindex));
tbase = create_temporary_var (ptype);
tbase_init = build_modify_expr (tbase, NOP_EXPR,
fold (build (PLUS_EXPR, ptype,
base,
virtual_size)));
DECL_REGISTER (tbase) = 1;
controller = build (BIND_EXPR, void_type_node, tbase, NULL_TREE, NULL_TREE);
TREE_SIDE_EFFECTS (controller) = 1;
body = NULL_TREE;
body = tree_cons (NULL_TREE,
build_delete (ptype, tbase, sfk_complete_destructor,
LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1),
body);
body = tree_cons (NULL_TREE,
build_modify_expr (tbase, NOP_EXPR, build (MINUS_EXPR, ptype, tbase, size_exp)),
body);
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 = tree_cons (NULL_TREE, tbase_init,
tree_cons (NULL_TREE, loop, NULL_TREE));
loop = build_compound_expr (loop);
no_destructor:
deallocate_expr = integer_zero_node;
if (auto_delete_vec != sfk_base_destructor)
{
tree base_tbd;
virtual_size = size_binop (MULT_EXPR, size_exp,
convert (sizetype, maxindex));
if (! TYPE_VEC_NEW_USES_COOKIE (type))
base_tbd = base;
else
{
tree cookie_size;
cookie_size = get_cookie_size (type);
base_tbd
= cp_convert (ptype,
cp_build_binary_op (MINUS_EXPR,
cp_convert (string_type_node,
base),
cookie_size));
virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
}
if (auto_delete_vec == sfk_deleting_destructor)
deallocate_expr = build_x_delete (base_tbd,
2 | use_global_delete,
virtual_size);
}
if (loop && deallocate_expr != integer_zero_node)
{
body = tree_cons (NULL_TREE, loop,
tree_cons (NULL_TREE, deallocate_expr, NULL_TREE));
body = build_compound_expr (body);
}
else
body = loop;
body = fold (build (COND_EXPR, void_type_node,
fold (build (NE_EXPR, boolean_type_node, base,
integer_zero_node)),
body, integer_zero_node));
body = build1 (NOP_EXPR, void_type_node, body);
if (controller)
{
TREE_OPERAND (controller, 1) = body;
return controller;
}
else
return cp_convert (void_type_node, body);
}
tree
create_temporary_var (type)
tree type;
{
tree decl;
decl = build_decl (VAR_DECL, NULL_TREE, type);
TREE_USED (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
DECL_SOURCE_FILE (decl) = input_filename;
DECL_SOURCE_LINE (decl) = lineno;
DECL_IGNORED_P (decl) = 1;
DECL_CONTEXT (decl) = current_function_decl;
return decl;
}
static tree
get_temp_regvar (type, init)
tree type, init;
{
tree decl;
decl = create_temporary_var (type);
if (building_stmt_tree ())
add_decl_stmt (decl);
if (!building_stmt_tree ())
SET_DECL_RTL (decl, assign_temp (type, 2, 0, 1));
finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
return decl;
}
tree
build_vec_init (base, init, from_array)
tree base, init;
int from_array;
{
tree rval;
tree base2 = NULL_TREE;
tree size;
tree itype = NULL_TREE;
tree iterator;
tree atype = TREE_TYPE (base);
tree type = TREE_TYPE (atype);
tree ptype;
tree stmt_expr;
tree compound_stmt;
int destroy_temps;
tree try_block = NULL_TREE;
tree try_body = NULL_TREE;
int num_initialized_elts = 0;
tree maxindex = array_type_nelts (TREE_TYPE (base));
if (maxindex == error_mark_node)
return error_mark_node;
if (init && TREE_CODE (init) == CONSTRUCTOR && TREE_TYPE (init) == NULL_TREE)
init = digest_init (atype, init, 0);
if (init && !TYPE_NEEDS_CONSTRUCTING (type)
&& ((TREE_CODE (init) == CONSTRUCTOR
&& (CONSTRUCTOR_ELTS (init) == NULL_TREE
|| ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (target_type (type))))
|| from_array))
{
stmt_expr = build (INIT_EXPR, atype, base, init);
TREE_SIDE_EFFECTS (stmt_expr) = 1;
return stmt_expr;
}
maxindex = cp_convert (ptrdiff_type_node, maxindex);
ptype = build_pointer_type (type);
size = size_in_bytes (type);
if (TREE_CODE (TREE_TYPE (base)) == ARRAY_TYPE)
base = cp_convert (ptype, default_conversion (base));
begin_init_stmts (&stmt_expr, &compound_stmt);
destroy_temps = stmts_are_full_exprs_p ();
current_stmt_tree ()->stmts_are_full_exprs_p = 0;
rval = get_temp_regvar (ptype, base);
base = get_temp_regvar (ptype, rval);
iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
&& from_array != 2)
{
try_block = begin_try_block ();
try_body = begin_compound_stmt (1);
}
if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
{
tree elts;
from_array = 0;
for (elts = CONSTRUCTOR_ELTS (init); elts; elts = TREE_CHAIN (elts))
{
tree elt = TREE_VALUE (elts);
tree baseref = build1 (INDIRECT_REF, type, base);
num_initialized_elts++;
if (IS_AGGR_TYPE (type) || TREE_CODE (type) == ARRAY_TYPE)
finish_expr_stmt (build_aggr_init (baseref, elt, 0));
else
finish_expr_stmt (build_modify_expr (baseref, NOP_EXPR,
elt));
finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
finish_expr_stmt (build_unary_op (PREDECREMENT_EXPR, iterator, 0));
}
init = NULL_TREE;
}
else if (from_array)
{
if (init)
{
base2 = default_conversion (init);
itype = TREE_TYPE (base2);
base2 = get_temp_regvar (itype, base2);
itype = TREE_TYPE (itype);
}
else if (TYPE_LANG_SPECIFIC (type)
&& TYPE_NEEDS_CONSTRUCTING (type)
&& ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
{
error ("initializer ends prematurely");
return error_mark_node;
}
}
if (from_array
|| (TYPE_NEEDS_CONSTRUCTING (type)
&& ! (host_integerp (maxindex, 0)
&& (num_initialized_elts
== tree_low_cst (maxindex, 0) + 1))))
{
tree if_stmt;
tree do_stmt;
tree do_body;
tree elt_init;
if_stmt = begin_if_stmt ();
finish_if_stmt_cond (build (NE_EXPR, boolean_type_node,
iterator, integer_minus_one_node),
if_stmt);
do_stmt = begin_do_stmt ();
do_body = begin_compound_stmt (1);
if (!building_stmt_tree ())
expand_start_target_temps ();
if (from_array)
{
tree to = build1 (INDIRECT_REF, type, base);
tree from;
if (base2)
from = build1 (INDIRECT_REF, itype, base2);
else
from = NULL_TREE;
if (from_array == 2)
elt_init = build_modify_expr (to, NOP_EXPR, from);
else if (TYPE_NEEDS_CONSTRUCTING (type))
elt_init = build_aggr_init (to, from, 0);
else if (from)
elt_init = build_modify_expr (to, NOP_EXPR, from);
else
abort ();
}
else if (TREE_CODE (type) == ARRAY_TYPE)
{
if (init != 0)
sorry
("cannot initialize multi-dimensional array with initializer");
elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
0, 0);
}
else
elt_init = build_aggr_init (build1 (INDIRECT_REF, type, base),
init, 0);
if (!building_stmt_tree ())
{
genrtl_expr_stmt (elt_init);
expand_end_target_temps ();
}
else
{
current_stmt_tree ()->stmts_are_full_exprs_p = 1;
finish_expr_stmt (elt_init);
current_stmt_tree ()->stmts_are_full_exprs_p = 0;
}
finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
if (base2)
finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base2, 0));
finish_compound_stmt (1, do_body);
finish_do_body (do_stmt);
finish_do_stmt (build (NE_EXPR, boolean_type_node,
build_unary_op (PREDECREMENT_EXPR, iterator, 0),
integer_minus_one_node),
do_stmt);
finish_then_clause (if_stmt);
finish_if_stmt ();
}
if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
&& from_array != 2)
{
tree e;
finish_compound_stmt (1, try_body);
finish_cleanup_try_block (try_block);
e = build_vec_delete_1 (rval,
cp_build_binary_op (MINUS_EXPR, maxindex,
iterator),
type,
sfk_base_destructor,
0);
finish_cleanup (e, try_block);
}
finish_expr_stmt (rval);
stmt_expr = finish_init_stmts (stmt_expr, compound_stmt);
current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
return stmt_expr;
}
tree
build_x_delete (addr, which_delete, virtual_size)
tree addr;
int which_delete;
tree virtual_size;
{
int use_global_delete = which_delete & 1;
int use_vec_delete = !!(which_delete & 2);
enum tree_code code = use_vec_delete ? VEC_DELETE_EXPR : DELETE_EXPR;
int flags = LOOKUP_NORMAL | (use_global_delete * LOOKUP_GLOBAL);
return build_op_delete_call (code, addr, virtual_size, flags, NULL_TREE);
}
static tree
build_dtor_call (exp, dtor_kind, flags)
tree exp;
special_function_kind dtor_kind;
int flags;
{
tree name;
switch (dtor_kind)
{
case sfk_complete_destructor:
name = complete_dtor_identifier;
break;
case sfk_base_destructor:
name = base_dtor_identifier;
break;
case sfk_deleting_destructor:
name = deleting_dtor_identifier;
break;
default:
abort ();
}
return build_method_call (exp, name, NULL_TREE, NULL_TREE, flags);
}
tree
build_delete (type, addr, auto_delete, flags, use_global_delete)
tree type, addr;
special_function_kind auto_delete;
int flags;
int use_global_delete;
{
tree expr;
if (addr == error_mark_node)
return error_mark_node;
if (type == error_mark_node)
return error_mark_node;
type = TYPE_MAIN_VARIANT (type);
if (TREE_CODE (type) == POINTER_TYPE)
{
type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
if (!VOID_TYPE_P (type) && !complete_type_or_else (type, addr))
return error_mark_node;
if (TREE_CODE (type) == ARRAY_TYPE)
goto handle_array;
if (! IS_AGGR_TYPE (type))
{
return build_builtin_delete_call (addr);
}
if (TREE_SIDE_EFFECTS (addr))
addr = save_expr (addr);
addr = convert_force (build_pointer_type (type), addr, 0);
}
else if (TREE_CODE (type) == ARRAY_TYPE)
{
handle_array:
if (TREE_SIDE_EFFECTS (addr))
addr = save_expr (addr);
if (TYPE_DOMAIN (type) == NULL_TREE)
{
error ("unknown array size in delete");
return error_mark_node;
}
return build_vec_delete (addr, array_type_nelts (type),
auto_delete, use_global_delete);
}
else
{
addr = build_unary_op (ADDR_EXPR, addr, 0);
if (TREE_SIDE_EFFECTS (addr))
addr = save_expr (addr);
addr = convert_force (build_pointer_type (type), addr, 0);
}
my_friendly_assert (IS_AGGR_TYPE (type), 220);
if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
{
if (auto_delete != sfk_deleting_destructor)
return void_zero_node;
return build_op_delete_call
(DELETE_EXPR, addr, c_sizeof_nowarn (type),
LOOKUP_NORMAL | (use_global_delete * LOOKUP_GLOBAL),
NULL_TREE);
}
else
{
tree do_delete = NULL_TREE;
tree ifexp;
my_friendly_assert (TYPE_HAS_DESTRUCTOR (type), 20011213);
if (use_global_delete && auto_delete == sfk_deleting_destructor)
{
addr = save_expr (addr);
do_delete = build_builtin_delete_call (addr);
auto_delete = sfk_complete_destructor;
}
else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
&& auto_delete == sfk_deleting_destructor)
{
addr = save_expr (addr);
do_delete = build_op_delete_call (DELETE_EXPR,
addr,
c_sizeof_nowarn (type),
LOOKUP_NORMAL,
NULL_TREE);
auto_delete = sfk_complete_destructor;
}
else if (auto_delete == sfk_deleting_destructor
&& TYPE_GETS_REG_DELETE (type))
{
build_op_delete_call (DELETE_EXPR, addr, c_sizeof_nowarn (type),
LOOKUP_NORMAL, NULL_TREE);
}
if (flag_apple_kext && has_apple_kext_compatibility_attr_p (type))
{
my_friendly_assert (auto_delete != sfk_base_destructor, 20020501);
auto_delete = sfk_deleting_destructor;
}
expr = build_dtor_call (build_indirect_ref (addr, NULL),
auto_delete, flags);
if (do_delete)
expr = build (COMPOUND_EXPR, void_type_node, expr, do_delete);
if (flags & LOOKUP_DESTRUCTOR)
ifexp = integer_one_node;
else
ifexp = fold (cp_build_binary_op (NE_EXPR, addr, integer_zero_node));
if (ifexp != integer_one_node)
expr = build (COND_EXPR, void_type_node,
ifexp, expr, void_zero_node);
return expr;
}
}
void
push_base_cleanups ()
{
tree binfos;
int i, n_baseclasses;
tree member;
tree expr;
if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
{
tree vbases;
tree cond = (condition_conversion
(build (BIT_AND_EXPR, integer_type_node,
current_in_charge_parm,
integer_two_node)));
vbases = CLASSTYPE_VBASECLASSES (current_class_type);
for (; vbases;
vbases = TREE_CHAIN (vbases))
{
tree vbase = TREE_VALUE (vbases);
tree base_type = BINFO_TYPE (vbase);
if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (base_type))
{
tree base_ptr_type = build_pointer_type (base_type);
expr = current_class_ptr;
expr = build1 (NOP_EXPR, base_ptr_type, expr);
expr = build (PLUS_EXPR, base_ptr_type, expr,
BINFO_OFFSET (vbase));
expr = build_indirect_ref (expr, NULL);
expr = build_method_call (expr, base_dtor_identifier,
NULL_TREE, vbase,
LOOKUP_NORMAL);
expr = build (COND_EXPR, void_type_node, cond,
expr, void_zero_node);
finish_decl_cleanup (NULL_TREE, expr);
}
}
}
binfos = BINFO_BASETYPES (TYPE_BINFO (current_class_type));
n_baseclasses = CLASSTYPE_N_BASECLASSES (current_class_type);
for (i = 0; i < n_baseclasses; i++)
{
tree base_binfo = TREE_VEC_ELT (binfos, i);
if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
|| TREE_VIA_VIRTUAL (base_binfo))
continue;
expr = build_scoped_method_call (current_class_ref, base_binfo,
base_dtor_identifier,
NULL_TREE);
finish_decl_cleanup (NULL_TREE, expr);
}
for (member = TYPE_FIELDS (current_class_type); member;
member = TREE_CHAIN (member))
{
if (TREE_CODE (member) != FIELD_DECL)
continue;
if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
{
tree this_member = (build_component_ref
(current_class_ref, DECL_NAME (member),
NULL_TREE, 0));
tree this_type = TREE_TYPE (member);
expr = build_delete (this_type, this_member,
sfk_complete_destructor,
LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
0);
finish_decl_cleanup (NULL_TREE, expr);
}
}
}
tree
build_vbase_delete (type, decl)
tree type, decl;
{
tree vbases = CLASSTYPE_VBASECLASSES (type);
tree result = NULL_TREE;
tree addr = build_unary_op (ADDR_EXPR, decl, 0);
my_friendly_assert (addr != error_mark_node, 222);
while (vbases)
{
tree this_addr
= convert_force (build_pointer_type (BINFO_TYPE (TREE_VALUE (vbases))),
addr, 0);
result = tree_cons (NULL_TREE,
build_delete (TREE_TYPE (this_addr), this_addr,
sfk_base_destructor,
LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0),
result);
vbases = TREE_CHAIN (vbases);
}
return build_compound_expr (nreverse (result));
}
tree
build_vec_delete (base, maxindex, auto_delete_vec, use_global_delete)
tree base, maxindex;
special_function_kind auto_delete_vec;
int use_global_delete;
{
tree type;
if (TREE_CODE (base) == OFFSET_REF)
base = resolve_offset_ref (base);
type = TREE_TYPE (base);
base = stabilize_reference (base);
if (TREE_SIDE_EFFECTS (base))
base = save_expr (base);
if (TREE_CODE (type) == POINTER_TYPE)
{
tree cookie_addr;
type = strip_array_types (TREE_TYPE (type));
cookie_addr = build (MINUS_EXPR,
build_pointer_type (sizetype),
base,
TYPE_SIZE_UNIT (sizetype));
maxindex = build_indirect_ref (cookie_addr, NULL);
}
else if (TREE_CODE (type) == ARRAY_TYPE)
{
maxindex = array_type_nelts_total (type);
type = strip_array_types (type);
base = build_unary_op (ADDR_EXPR, base, 1);
}
else
{
if (base != error_mark_node)
error ("type to vector delete is neither pointer or array type");
return error_mark_node;
}
return build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
use_global_delete);
}