#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"
static void construct_virtual_base (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 (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_mem_initializers (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, 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));
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);
}
tree
build_zero_init (tree type, tree nelts, bool static_storage_p)
{
tree init = NULL_TREE;
my_friendly_assert (nelts == NULL_TREE || TREE_CODE (nelts) == INTEGER_CST,
20030618);
if (type == error_mark_node)
;
else if (static_storage_p && zero_init_p (type))
;
else if (SCALAR_TYPE_P (type))
init = convert (type, integer_zero_node);
else if (CLASS_TYPE_P (type))
{
tree field;
tree inits;
init = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
inits = NULL_TREE;
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
{
if (TREE_CODE (field) != FIELD_DECL)
continue;
if (static_storage_p && !zero_init_p (TREE_TYPE (field)))
inits = tree_cons (field,
build_zero_init (TREE_TYPE (field),
NULL_TREE,
static_storage_p),
inits);
if (TREE_CODE (type) == UNION_TYPE)
break;
}
CONSTRUCTOR_ELTS (init) = nreverse (inits);
}
else if (TREE_CODE (type) == ARRAY_TYPE)
{
tree index;
tree max_index;
tree inits;
init = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
inits = NULL_TREE;
max_index = nelts ? nelts : array_type_nelts (type);
my_friendly_assert (TREE_CODE (max_index) == INTEGER_CST, 20030618);
for (index = size_zero_node;
!tree_int_cst_lt (max_index, index);
index = size_binop (PLUS_EXPR, index, size_one_node))
inits = tree_cons (index,
build_zero_init (TREE_TYPE (type),
NULL_TREE,
static_storage_p),
inits);
CONSTRUCTOR_ELTS (init) = nreverse (inits);
}
else if (TREE_CODE (type) == REFERENCE_TYPE)
;
else
abort ();
if (init)
TREE_CONSTANT (init) = 1;
return init;
}
static tree
build_default_init (type, nelts)
tree type;
tree nelts;
{
if (TYPE_NEEDS_CONSTRUCTING (type)
|| (nelts && TREE_CODE (nelts) != INTEGER_CST))
return NULL_TREE;
return build_zero_init (type, nelts, false);
}
static void
perform_member_init (tree member, tree init)
{
tree decl;
tree type = TREE_TYPE (member);
bool explicit;
explicit = (init != NULL_TREE);
if (warn_ecpp && !explicit && TREE_CODE (type) != ARRAY_TYPE)
warning ("`%D' should be initialized in the member initialization "
"list",
member);
if (init == void_type_node)
init = NULL_TREE;
decl = build_class_member_access_expr (current_class_ref, member,
NULL_TREE,
true);
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 (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, NULL_TREE, 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, NULL_TREE);
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_class_member_access_expr (current_class_ref, member,
NULL_TREE,
false);
expr = build_delete (type, expr, sfk_complete_destructor,
LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
if (expr != error_mark_node)
finish_eh_cleanup (expr);
}
}
static tree
build_field_list (t, list, uses_unions_p)
tree t;
tree list;
int *uses_unions_p;
{
tree fields;
*uses_unions_p = 0;
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 || DECL_ARTIFICIAL (fields))
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_mem_initializers (tree t, tree mem_inits)
{
tree init;
tree base;
tree sorted_inits;
tree next_subobject;
int i;
int uses_unions_p;
sorted_inits = NULL_TREE;
for (base = CLASSTYPE_VBASECLASSES (t); base; base = TREE_CHAIN (base))
sorted_inits = tree_cons (TREE_VALUE (base), NULL_TREE, sorted_inits);
for (i = 0; i < CLASSTYPE_N_BASECLASSES (t); ++i)
{
base = BINFO_BASETYPE (TYPE_BINFO (t), i);
if (!TREE_VIA_VIRTUAL (base))
sorted_inits = tree_cons (base, NULL_TREE, sorted_inits);
}
sorted_inits = build_field_list (t, sorted_inits, &uses_unions_p);
sorted_inits = nreverse (sorted_inits);
next_subobject = sorted_inits;
for (init = mem_inits; init; init = TREE_CHAIN (init))
{
tree subobject;
tree subobject_init;
subobject = TREE_PURPOSE (init);
for (subobject_init = next_subobject;
subobject_init;
subobject_init = TREE_CHAIN (subobject_init))
if (TREE_PURPOSE (subobject_init) == subobject)
break;
if (warn_reorder && !subobject_init)
{
if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)
cp_warning_at ("`%D' will be initialized after",
TREE_PURPOSE (next_subobject));
else
warning ("base `%T' will be initialized after",
TREE_PURPOSE (next_subobject));
if (TREE_CODE (subobject) == FIELD_DECL)
cp_warning_at (" `%#D'", subobject);
else
warning (" base `%T'", subobject);
}
if (!subobject_init)
{
subobject_init = sorted_inits;
while (TREE_PURPOSE (subobject_init) != subobject)
subobject_init = TREE_CHAIN (subobject_init);
}
if (TREE_VALUE (subobject_init))
{
if (TREE_CODE (subobject) == FIELD_DECL)
error ("multiple initializations given for `%D'", subobject);
else
error ("multiple initializations given for base `%T'",
subobject);
}
TREE_VALUE (subobject_init) = TREE_VALUE (init);
next_subobject = subobject_init;
}
if (uses_unions_p)
{
tree last_field = NULL_TREE;
for (init = sorted_inits; init; init = TREE_CHAIN (init))
{
tree field;
tree field_type;
int done;
if (!TREE_VALUE (init)
|| TREE_CODE (TREE_PURPOSE (init)) != FIELD_DECL)
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 sorted_inits;
}
void
emit_mem_initializers (tree mem_inits)
{
mem_inits = sort_mem_initializers (current_class_type, mem_inits);
while (mem_inits
&& TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)
{
tree subobject = TREE_PURPOSE (mem_inits);
tree arguments = TREE_VALUE (mem_inits);
if (extra_warnings && !arguments
&& DECL_COPY_CONSTRUCTOR_P (current_function_decl)
&& TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (subobject)))
warning ("base class `%#T' should be explicitly initialized in the "
"copy constructor",
BINFO_TYPE (subobject));
if (arguments == void_type_node)
arguments = NULL_TREE;
if (TREE_VIA_VIRTUAL (subobject))
construct_virtual_base (subobject, arguments);
else
{
tree base_addr;
base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
subobject, 1);
expand_aggr_init_1 (subobject, NULL_TREE,
build_indirect_ref (base_addr, NULL),
arguments,
LOOKUP_NORMAL);
expand_cleanup_for_base (subobject, NULL_TREE);
}
mem_inits = TREE_CHAIN (mem_inits);
}
initialize_vtbl_ptrs (current_class_ptr);
while (mem_inits)
{
perform_member_init (TREE_PURPOSE (mem_inits),
TREE_VALUE (mem_inits));
mem_inits = TREE_CHAIN (mem_inits);
}
}
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_special_member_call (current_class_ref,
base_dtor_identifier,
NULL_TREE,
binfo,
LOOKUP_NORMAL | LOOKUP_NONVIRTUAL);
if (flag)
expr = fold (build (COND_EXPR, void_type_node,
c_common_truthvalue_conversion (flag),
expr, integer_zero_node));
finish_eh_cleanup (expr);
}
static void
construct_virtual_base (tree vbase, tree arguments)
{
tree inner_if_stmt;
tree compound_stmt;
tree exp;
tree flag;
flag = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
inner_if_stmt = begin_if_stmt ();
finish_if_stmt_cond (flag, inner_if_stmt);
compound_stmt = begin_compound_stmt (1);
exp = build (PLUS_EXPR,
TREE_TYPE (current_class_ptr),
current_class_ptr,
fold (build1 (NOP_EXPR, TREE_TYPE (current_class_ptr),
BINFO_OFFSET (vbase))));
exp = build1 (NOP_EXPR,
build_pointer_type (BINFO_TYPE (vbase)),
exp);
exp = build1 (INDIRECT_REF, BINFO_TYPE (vbase), exp);
expand_aggr_init_1 (vbase, current_class_ref, exp,
arguments, LOOKUP_COMPLAIN);
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 (tree name, tree init)
{
tree basetype;
tree field;
if (!current_class_ref)
return NULL_TREE;
if (!name)
{
switch (CLASSTYPE_N_BASECLASSES (current_class_type))
{
case 0:
error ("unnamed initializer for `%T', which has no base classes",
current_class_type);
return NULL_TREE;
case 1:
basetype = TYPE_BINFO_BASETYPE (current_class_type, 0);
break;
default:
error ("unnamed initializer for `%T', which uses multiple inheritance",
current_class_type);
return NULL_TREE;
}
}
else if (TYPE_P (name))
{
basetype = TYPE_MAIN_VARIANT (name);
name = TYPE_NAME (name);
}
else if (TREE_CODE (name) == TYPE_DECL)
basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
else
basetype = NULL_TREE;
my_friendly_assert (init != NULL_TREE, 0);
if (basetype)
{
tree binfo;
if (current_template_parms)
return build_tree_list (basetype, init);
binfo = lookup_base (current_class_type, basetype,
ba_ignore, NULL);
if (binfo)
{
if (TREE_VIA_VIRTUAL (binfo))
binfo = binfo_for_vbase (basetype, current_class_type);
else if (BINFO_INHERITANCE_CHAIN (binfo)
!= TYPE_BINFO (current_class_type))
binfo = NULL_TREE;
}
if (!binfo)
{
if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
error ("type `%D' is not a direct or virtual base of `%T'",
name, current_class_type);
else
error ("type `%D' is not a direct base of `%T'",
name, current_class_type);
return NULL_TREE;
}
if (binfo)
return build_tree_list (binfo, init);
}
else
{
if (TREE_CODE (name) == IDENTIFIER_NODE)
field = lookup_field (current_class_type, name, 1, 0);
else
field = name;
if (member_init_ok_or_else (field, current_class_type, name))
return build_tree_list (field, init);
}
return NULL_TREE;
}
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 (itype && cp_type_quals (itype) != TYPE_UNQUALIFIED)
TREE_TYPE (init) = TYPE_MAIN_VARIANT (itype);
stmt_expr = build_vec_init (exp, NULL_TREE, 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;
}
tree
build_init (decl, init, flags)
tree decl, init;
int flags;
{
tree expr;
if (IS_AGGR_TYPE (TREE_TYPE (decl))
|| TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
expr = build_aggr_init (decl, init, flags);
else
expr = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
return 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
&& TREE_HAS_CONSTRUCTOR (init))
{
my_friendly_assert (CP_AGGREGATE_TYPE_P (type), 20021016);
init = digest_init (type, init, (tree *)NULL);
}
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_special_member_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);
my_friendly_assert (building_stmt_tree (), 20021010);
if (init && TREE_CODE (exp) == VAR_DECL
&& TREE_CODE (init) == CONSTRUCTOR
&& TREE_HAS_CONSTRUCTOR (init))
{
if (store_init_value (exp, init))
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;
tree fns;
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 finish_call_expr (name, parmlist, true);
}
if (DECL_P (name))
name = DECL_NAME (name);
if (TREE_CODE (type) == NAMESPACE_DECL)
return finish_call_expr (lookup_namespace_name (type, name),
parmlist,
true);
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 finish_call_expr (lookup_namespace_name (ns, name),
parmlist,
true);
}
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);
fns = lookup_fnfields (basetype_path, method_name, 0);
if (fns)
{
if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
BASELINK_FUNCTIONS (fns) = build_nt (TEMPLATE_ID_EXPR,
BASELINK_FUNCTIONS (fns),
TREE_OPERAND (name, 1));
return build_new_method_call (decl, fns, parmlist,
NULL_TREE,
LOOKUP_NORMAL|LOOKUP_NONVIRTUAL);
}
if (decl == current_class_ref
&& ACCESSIBLY_UNIQUELY_DERIVED_P (type, current_class_type))
{
basetype_path = NULL_TREE;
decl = build_scoped_ref (decl, type, &basetype_path);
if (decl == error_mark_node)
return error_mark_node;
}
if (constructor_name_p (method_name, type))
return build_functional_cast (type, parmlist);
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);
if (BASELINK_P (name) || DECL_P (name))
member = name;
else
{
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 = BASELINK_FUNCTIONS (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 (TREE_CODE (t) != TEMPLATE_ID_EXPR && !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 ("invalid 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 (!cxx_mark_addressable (member))
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 = NULL_TREE;
base = current_class_ref;
if (TREE_CODE (exp) == OFFSET_REF && TREE_CODE (type) == OFFSET_TYPE)
base = build_scoped_ref (base, TYPE_OFFSET_BASETYPE (type), &binfo);
return build_class_member_access_expr (base, member,
NULL_TREE,
false);
}
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 outer_nelts = NULL_TREE;
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 = outer_nelts = TREE_OPERAND (type, 1);
type = TREE_OPERAND (type, 0);
full_type = build_cplus_array_type (type, NULL_TREE);
}
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,
TYPE_BINFO (true_type),
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, nelts);
else if (init && pedantic && has_array)
pedwarn ("ISO C++ forbids initialization in array new");
if (has_array)
init_expr
= build_vec_init (init_expr,
cp_build_binary_op (MINUS_EXPR, outer_nelts,
integer_one_node),
init, 0);
else if (TYPE_NEEDS_CONSTRUCTING (type))
init_expr = build_special_member_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);
CLEANUP_EH_ONLY (begin) = 1;
sentry = TARGET_EXPR_SLOT (begin);
TARGET_EXPR_CLEANUP (begin)
= 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 (TREE_CODE (type) == ARRAY_TYPE)
abort ();
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, maxindex, init, from_array)
tree base, init, maxindex;
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;
if (TYPE_DOMAIN (atype))
maxindex = array_type_nelts (atype);
if (maxindex == NULL_TREE || maxindex == error_mark_node)
return error_mark_node;
if (init
&& (from_array == 2
? (!CLASS_TYPE_P (type) || !TYPE_HAS_COMPLEX_ASSIGN_REF (type))
: !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);
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, 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;
tree m = cp_build_binary_op (MINUS_EXPR, maxindex, iterator);
if (TREE_CODE (type) == ARRAY_TYPE)
{
m = cp_build_binary_op (MULT_EXPR, m,
array_type_nelts_total (type));
type = strip_array_types (type);
}
finish_compound_stmt (1, try_body);
finish_cleanup_try_block (try_block);
e = build_vec_delete_1 (rval, m,
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,
TYPE_BINFO (TREE_TYPE (exp)), 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 (TREE_CODE (type) == ARRAY_TYPE)
goto handle_array;
if (VOID_TYPE_P (type)
|| !complete_type_or_diagnostic (type, addr, 1)
|| !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 (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, cxx_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,
cxx_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, cxx_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))
{
expr = build_special_member_call (current_class_ref,
base_dtor_identifier,
NULL_TREE,
vbase,
(LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL));
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_special_member_call (current_class_ref,
base_dtor_identifier,
NULL_TREE, base_binfo,
LOOKUP_NORMAL | LOOKUP_NONVIRTUAL);
finish_decl_cleanup (NULL_TREE, expr);
}
for (member = TYPE_FIELDS (current_class_type); member;
member = TREE_CHAIN (member))
{
if (TREE_CODE (member) != FIELD_DECL || DECL_ARTIFICIAL (member))
continue;
if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
{
tree this_member = (build_class_member_access_expr
(current_class_ref, member,
NULL_TREE,
false));
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_CODE (type) == POINTER_TYPE)
{
tree cookie_addr;
if (TREE_SIDE_EFFECTS (base))
base = save_expr (base);
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);
if (TREE_SIDE_EFFECTS (base))
base = save_expr (base);
}
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);
}