#include "config.h"
#include "system.h"
#include "tree.h"
#include "rtl.h"
#include "cp-tree.h"
#include "flags.h"
#include "output.h"
#include "except.h"
#include "expr.h"
#include "toplev.h"
tree current_base_init_list, current_member_init_list;
static void expand_aggr_vbase_init_1 PROTO((tree, tree, tree, tree));
static void construct_virtual_bases PROTO((tree, tree, tree, tree, tree));
static void expand_aggr_init_1 PROTO((tree, tree, tree, tree, int));
static void expand_default_init PROTO((tree, tree, tree, tree, int));
static tree build_vec_delete_1 PROTO((tree, tree, tree, tree, tree,
int));
static void perform_member_init PROTO((tree, tree, tree, int));
static void sort_base_init PROTO((tree, tree *, tree *));
static tree build_builtin_delete_call PROTO((tree));
static int member_init_ok_or_else PROTO((tree, tree, const char *));
static void expand_virtual_init PROTO((tree, tree));
static tree sort_member_init PROTO((tree));
static tree initializing_context PROTO((tree));
static void expand_vec_init_try_block PROTO((tree));
static void expand_vec_init_catch_clause PROTO((tree, tree, tree, tree));
static tree build_java_class_ref PROTO((tree));
static void expand_cleanup_for_base PROTO((tree, tree));
static tree nc_nelts_field_id;
static tree minus_one;
static tree BI_header_type, BI_header_size;
void init_init_processing ()
{
tree fields[1];
minus_one = build_int_2 (-1, -1);
BI_header_type = make_lang_type (RECORD_TYPE);
nc_nelts_field_id = get_identifier ("nelts");
fields[0] = build_lang_field_decl (FIELD_DECL, nc_nelts_field_id, sizetype);
finish_builtin_type (BI_header_type, "__new_cookie", fields,
0, double_type_node);
BI_header_size = size_in_bytes (BI_header_type);
}
void
expand_direct_vtbls_init (real_binfo, binfo, init_self, can_elide, addr)
tree real_binfo, binfo, addr;
int init_self, can_elide;
{
tree real_binfos = BINFO_BASETYPES (real_binfo);
tree binfos = BINFO_BASETYPES (binfo);
int i, n_baselinks = real_binfos ? TREE_VEC_LENGTH (real_binfos) : 0;
for (i = 0; i < n_baselinks; i++)
{
tree real_base_binfo = TREE_VEC_ELT (real_binfos, i);
tree base_binfo = TREE_VEC_ELT (binfos, i);
int is_not_base_vtable
= i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (real_binfo));
if (! TREE_VIA_VIRTUAL (real_base_binfo))
expand_direct_vtbls_init (real_base_binfo, base_binfo,
is_not_base_vtable, can_elide, addr);
}
#if 0
if (can_elide && ! BINFO_MODIFIED (binfo))
return;
#endif
if (init_self && CLASSTYPE_VFIELDS (BINFO_TYPE (real_binfo)))
{
tree base_ptr = convert_pointer_to_real (binfo, addr);
expand_virtual_init (real_binfo, base_ptr);
}
}
static void
perform_member_init (member, name, init, explicit)
tree member, name, init;
int explicit;
{
tree decl;
tree type = TREE_TYPE (member);
expand_start_target_temps ();
if (TYPE_NEEDS_CONSTRUCTING (type)
|| (init && TYPE_HAS_CONSTRUCTOR (type)))
{
if (init != NULL_TREE && TREE_CODE (init) != TREE_LIST)
init = build_expr_list (NULL_TREE, init);
decl = build_component_ref (current_class_ref, name, NULL_TREE, explicit);
if (explicit
&& TREE_CODE (type) == ARRAY_TYPE
&& init != NULL_TREE
&& TREE_CHAIN (init) == NULL_TREE
&& TREE_CODE (TREE_TYPE (TREE_VALUE (init))) == ARRAY_TYPE)
{
expand_vec_init (TREE_OPERAND (decl, 1), decl,
array_type_nelts (type), TREE_VALUE (init), 1);
}
else
expand_aggr_init (decl, init, 0);
}
else
{
if (init == NULL_TREE)
{
if (explicit)
{
if (AGGREGATE_TYPE_P (type))
init = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
else if (TREE_CODE (type) == REFERENCE_TYPE)
{
cp_error ("default-initialization of `%#D', which has reference type",
member);
init = error_mark_node;
}
else
init = integer_zero_node;
}
else if (TREE_CODE (TREE_TYPE (member)) == REFERENCE_TYPE)
cp_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 || explicit)
{
decl = build_component_ref (current_class_ref, name, NULL_TREE,
explicit);
expand_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
}
}
expand_end_target_temps ();
free_temp_slots ();
if (TYPE_NEEDS_DESTRUCTOR (type))
{
tree expr;
push_obstacks_nochange ();
resume_temporary_allocation ();
expr = build_component_ref (current_class_ref, name, NULL_TREE,
explicit);
expr = build_delete (type, expr, integer_zero_node,
LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
if (expr != error_mark_node)
add_partial_entry (expr);
pop_obstacks ();
}
}
extern int warn_reorder;
static tree
sort_member_init (t)
tree t;
{
tree x, member, name, field;
tree init_list = NULL_TREE;
int last_pos = 0;
tree last_field = NULL_TREE;
for (member = TYPE_FIELDS (t); member ; member = TREE_CHAIN (member))
{
int pos;
if (TREE_CODE (member) != FIELD_DECL || !DECL_NAME (member))
continue;
for (x = current_member_init_list, pos = 0; x; x = TREE_CHAIN (x), ++pos)
{
if (TREE_PURPOSE (x) == NULL_TREE)
continue;
name = TREE_PURPOSE (x);
#if 0
field = (TREE_CODE (name) == COMPONENT_REF
? TREE_OPERAND (name, 1) : IDENTIFIER_CLASS_VALUE (name));
#else
my_friendly_assert (TREE_CODE (name) != COMPONENT_REF, 348);
field = IDENTIFIER_CLASS_VALUE (name);
#endif
if (TREE_CODE (field) == TREE_LIST)
field = TREE_VALUE (field);
if (field == member)
{
if (warn_reorder)
{
if (pos < last_pos)
{
cp_warning_at ("member initializers for `%#D'", last_field);
cp_warning_at (" and `%#D'", field);
warning (" will be re-ordered to match declaration order");
}
last_pos = pos;
last_field = field;
}
TREE_PURPOSE (x) = NULL_TREE;
x = build_tree_list (name, TREE_VALUE (x));
goto got_it;
}
}
x = build_tree_list (NULL_TREE, NULL_TREE);
got_it:
init_list = chainon (init_list, x);
}
for (x = current_member_init_list ; x ; x = TREE_CHAIN (x))
{
name = TREE_PURPOSE (x);
if (name)
{
if (purpose_member (name, init_list))
{
cp_error ("multiple initializations given for member `%D'",
IDENTIFIER_CLASS_VALUE (name));
continue;
}
init_list = chainon (init_list,
build_tree_list (name, TREE_VALUE (x)));
TREE_PURPOSE (x) = NULL_TREE;
}
}
return init_list;
}
static void
sort_base_init (t, rbase_ptr, vbase_ptr)
tree t, *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, current_base_init_list);
for (x = TREE_CHAIN (last); x; x = TREE_CHAIN (x))
{
tree basetype = TREE_PURPOSE (x);
tree binfo = NULL_TREE;
if (basetype == NULL_TREE)
{
switch (n_baseclasses)
{
case 0:
cp_error ("`%T' does not have a base class to initialize",
current_class_type);
return;
case 1:
break;
default:
cp_error ("unnamed initializer ambiguous for `%T' which uses multiple inheritance",
current_class_type);
return;
}
binfo = TREE_VEC_ELT (binfos, 0);
}
else if (is_aggr_type (basetype, 1))
{
binfo = binfo_or_else (basetype, t);
if (binfo == NULL_TREE)
continue;
if (TREE_VIA_VIRTUAL (binfo))
{
tree v = CLASSTYPE_VBASECLASSES (t);
while (BINFO_TYPE (v) != BINFO_TYPE (binfo))
v = TREE_CHAIN (v);
vbases = tree_cons (v, TREE_VALUE (x), vbases);
continue;
}
else
{
for (i = n_baseclasses-1; i >= 0; i--)
if (BINFO_TYPE (binfo) == BINFO_TYPE (TREE_VEC_ELT (binfos, i)))
break;
if (i < 0)
{
cp_error ("`%T' is not an immediate base class of `%T'",
basetype, current_class_type);
continue;
}
}
}
else
my_friendly_abort (365);
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);
int pos;
if (TREE_VIA_VIRTUAL (base_binfo))
continue;
for (x = current_base_init_list, pos = 0; x; x = TREE_CHAIN (x), ++pos)
{
tree binfo = TREE_PURPOSE (x);
if (binfo == NULL_TREE)
continue;
if (binfo == base_binfo)
{
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;
x = build_tree_list (binfo, TREE_VALUE (x));
goto got_it;
}
}
x = build_tree_list (NULL_TREE, NULL_TREE);
got_it:
rbases = chainon (rbases, x);
}
*rbase_ptr = rbases;
*vbase_ptr = vbases;
}
extern tree base_init_expr, rtl_expr_chain;
void
emit_base_init (t, immediately)
tree t;
int immediately;
{
tree member;
tree mem_init_list;
tree rbase_init_list, vbase_init_list;
tree t_binfo = TYPE_BINFO (t);
tree binfos = BINFO_BASETYPES (t_binfo);
int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
tree expr = NULL_TREE;
if (! immediately)
{
int momentary;
do_pending_stack_adjust ();
momentary = suspend_momentary ();
expr = make_node (RTL_EXPR);
resume_momentary (momentary);
start_sequence_for_rtl_expr (expr);
}
if (write_symbols == NO_DEBUG)
emit_note (0, -1);
else
emit_line_note_force (DECL_SOURCE_FILE (current_function_decl),
DECL_SOURCE_LINE (current_function_decl));
mem_init_list = sort_member_init (t);
current_member_init_list = NULL_TREE;
sort_base_init (t, &rbase_init_list, &vbase_init_list);
current_base_init_list = NULL_TREE;
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 && copy_args_p (current_function_decl))
cp_warning ("base class `%#T' should be explicitly initialized in the copy constructor",
BINFO_TYPE (base_binfo));
}
if (init != void_list_node)
{
expand_start_target_temps ();
member = convert_pointer_to_real (base_binfo, current_class_ptr);
expand_aggr_init_1 (base_binfo, NULL_TREE,
build_indirect_ref (member, NULL_PTR), init,
LOOKUP_NORMAL);
expand_end_target_temps ();
free_temp_slots ();
}
expand_cleanup_for_base (base_binfo, NULL_TREE);
rbase_init_list = TREE_CHAIN (rbase_init_list);
}
if (TYPE_USES_VIRTUAL_BASECLASSES (t))
expand_indirect_vtbls_init (t_binfo, current_class_ref, current_class_ptr);
expand_direct_vtbls_init (t_binfo, t_binfo, 1, 1, current_class_ptr);
for (member = TYPE_FIELDS (t); member; member = TREE_CHAIN (member))
{
tree init, name;
int from_init_list;
if (TREE_CODE (member) != FIELD_DECL || !DECL_NAME (member))
continue;
if (TREE_PURPOSE (mem_init_list))
{
name = TREE_PURPOSE (mem_init_list);
init = TREE_VALUE (mem_init_list);
from_init_list = 1;
#if 0
if (TREE_CODE (name) == COMPONENT_REF)
name = DECL_NAME (TREE_OPERAND (name, 1));
#else
my_friendly_assert (TREE_CODE (name) != COMPONENT_REF, 349);
#endif
}
else
{
name = DECL_NAME (member);
init = DECL_INITIAL (member);
from_init_list = 0;
if (warn_ecpp && init == NULL_TREE
&& !DECL_ARTIFICIAL (member)
&& TREE_CODE (TREE_TYPE (member)) != ARRAY_TYPE)
cp_warning ("`%D' should be initialized in the member initialization list", member);
}
perform_member_init (member, name, init, from_init_list);
mem_init_list = TREE_CHAIN (mem_init_list);
}
while (mem_init_list)
{
tree name, init, field;
if (TREE_PURPOSE (mem_init_list))
{
name = TREE_PURPOSE (mem_init_list);
init = TREE_VALUE (mem_init_list);
field = IDENTIFIER_CLASS_VALUE (name);
if (TREE_CODE (field) == TREE_LIST)
{
field = TREE_VALUE (field);
if (decl_type_context (field) != current_class_type)
cp_error ("field `%D' not in immediate context", field);
}
#if 0
my_friendly_assert (DECL_FIELD_CONTEXT (field) != t, 351);
#endif
perform_member_init (field, name, init, 1);
}
mem_init_list = TREE_CHAIN (mem_init_list);
}
if (! immediately)
{
do_pending_stack_adjust ();
my_friendly_assert (base_init_expr == 0, 207);
base_init_expr = expr;
TREE_TYPE (expr) = void_type_node;
RTL_EXPR_RTL (expr) = const0_rtx;
RTL_EXPR_SEQUENCE (expr) = get_insns ();
rtl_expr_chain = tree_cons (NULL_TREE, expr, rtl_expr_chain);
end_sequence ();
TREE_SIDE_EFFECTS (expr) = 1;
}
}
void
check_base_init (t)
tree t;
{
tree member;
for (member = TYPE_FIELDS (t); member; member = TREE_CHAIN (member))
if (DECL_NAME (member) && TREE_USED (member))
cp_error ("field `%D' used before initialized (after assignment to `this')",
member);
}
static void
expand_virtual_init (binfo, decl)
tree binfo, decl;
{
tree type = BINFO_TYPE (binfo);
tree vtbl, vtbl_ptr;
tree vtype, vtype_binfo;
vtype = DECL_CONTEXT (CLASSTYPE_VFIELD (type));
vtype_binfo = get_binfo (vtype, TREE_TYPE (TREE_TYPE (decl)), 0);
vtbl = BINFO_VTABLE (binfo_value (DECL_FIELD_CONTEXT (CLASSTYPE_VFIELD (type)), binfo));
assemble_external (vtbl);
TREE_USED (vtbl) = 1;
vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
decl = convert_pointer_to_real (vtype_binfo, decl);
vtbl_ptr = build_vfield_ref (build_indirect_ref (decl, NULL_PTR), vtype);
if (vtbl_ptr == error_mark_node)
return;
vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
expand_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_NEEDS_DESTRUCTOR (BINFO_TYPE (binfo)))
return;
push_obstacks_nochange ();
resume_temporary_allocation ();
expr = (build_scoped_method_call
(current_class_ref, binfo, dtor_identifier,
build_expr_list (NULL_TREE, integer_zero_node)));
if (flag)
expr = fold (build (COND_EXPR, void_type_node,
truthvalue_conversion (flag),
expr, integer_zero_node));
pop_obstacks ();
add_partial_entry (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_PTR);
expand_start_target_temps ();
if (init)
init = TREE_VALUE (init);
expand_aggr_init_1 (binfo, exp, ref, init, LOOKUP_COMPLAIN);
expand_end_target_temps ();
free_temp_slots ();
}
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;
tree result;
my_friendly_assert (TYPE_USES_VIRTUAL_BASECLASSES (type), 19990621);
expand_start_cond (flag, 0);
result = init_vbase_pointers (type, this_ptr);
if (result)
expand_expr_stmt (build_compound_expr (result));
expand_end_cond ();
for (vbases = CLASSTYPE_VBASECLASSES (type); vbases;
vbases = TREE_CHAIN (vbases))
{
tree tmp = purpose_member (vbases, result);
expand_start_cond (flag, 0);
expand_aggr_vbase_init_1 (vbases, this_ref,
TREE_OPERAND (TREE_VALUE (tmp), 0),
init_list);
expand_end_cond ();
expand_cleanup_for_base (vbases, flag);
}
}
static tree
initializing_context (field)
tree field;
{
tree t = DECL_CONTEXT (field);
while (t && ANON_UNION_TYPE_P (t))
t = TYPE_CONTEXT (t);
return t;
}
static int
member_init_ok_or_else (field, type, member_name)
tree field;
tree type;
const char *member_name;
{
if (field == error_mark_node)
return 0;
if (field == NULL_TREE || initializing_context (field) != type)
{
cp_error ("class `%T' does not have any field named `%s'", type,
member_name);
return 0;
}
if (TREE_STATIC (field))
{
cp_error ("field `%#D' is static; only point of initialization is its declaration",
field);
return 0;
}
return 1;
}
void
expand_member_init (exp, name, init)
tree exp, name, init;
{
tree basetype = NULL_TREE, field;
tree type;
if (exp == NULL_TREE)
return;
type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
if (name && TREE_CODE (name) == TYPE_DECL)
{
basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
name = DECL_NAME (name);
}
if (name == NULL_TREE && IS_AGGR_TYPE (type))
switch (CLASSTYPE_N_BASECLASSES (type))
{
case 0:
error ("base class initializer specified, but no base class to initialize");
return;
case 1:
basetype = TYPE_BINFO_BASETYPE (type, 0);
break;
default:
error ("initializer for unnamed base class ambiguous");
cp_error ("(type `%T' uses multiple inheritance)", type);
return;
}
my_friendly_assert (init != NULL_TREE, 0);
if (init == void_type_node)
init = NULL_TREE;
if (name == NULL_TREE || basetype)
{
tree base_init;
if (name == NULL_TREE)
{
#if 0
if (basetype)
name = TYPE_IDENTIFIER (basetype);
else
{
error ("no base class to initialize");
return;
}
#endif
}
else if (basetype != type
&& ! current_template_parms
&& ! vec_binfo_member (basetype,
TYPE_BINFO_BASETYPES (type))
&& ! binfo_member (basetype, CLASSTYPE_VBASECLASSES (type)))
{
if (IDENTIFIER_CLASS_VALUE (name))
goto try_member;
if (TYPE_USES_VIRTUAL_BASECLASSES (type))
cp_error ("type `%T' is not an immediate or virtual basetype for `%T'",
basetype, type);
else
cp_error ("type `%T' is not an immediate basetype for `%T'",
basetype, type);
return;
}
if (purpose_member (basetype, current_base_init_list))
{
cp_error ("base class `%T' already initialized", basetype);
return;
}
if (warn_reorder && current_member_init_list)
{
cp_warning ("base initializer for `%T'", basetype);
warning (" will be re-ordered to precede member initializations");
}
base_init = build_tree_list (basetype, init);
current_base_init_list = chainon (current_base_init_list, base_init);
}
else
{
tree member_init;
try_member:
field = lookup_field (type, name, 1, 0);
if (! member_init_ok_or_else (field, type, IDENTIFIER_POINTER (name)))
return;
if (purpose_member (name, current_member_init_list))
{
cp_error ("field `%D' already initialized", field);
return;
}
member_init = build_tree_list (name, init);
current_member_init_list = chainon (current_member_init_list, member_init);
}
}
void
expand_aggr_init (exp, init, flags)
tree exp, init;
int flags;
{
tree type = TREE_TYPE (exp);
int was_const = TREE_READONLY (exp);
int was_volatile = TREE_THIS_VOLATILE (exp);
if (init == error_mark_node)
return;
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 (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
{
TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
if (init)
TREE_TYPE (init) = TYPE_MAIN_VARIANT (itype);
}
if (init && TREE_TYPE (init) == NULL_TREE)
{
error ("bad array initializer");
return;
}
expand_vec_init (exp, exp, array_type_nelts (type), 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;
}
if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
TREE_USED (exp) = 1;
#if 0
if (init && TREE_CODE (init) == CONSTRUCTOR
&& TYPE_HAS_CONSTRUCTOR (type)
&& TREE_TYPE (init) == type)
init = CONSTRUCTOR_ELTS (init);
#endif
TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
init, LOOKUP_NORMAL|flags);
TREE_TYPE (exp) = type;
TREE_READONLY (exp) = was_const;
TREE_THIS_VOLATILE (exp) = was_volatile;
}
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 rval;
tree parms;
if (init && TREE_CODE (init) != TREE_LIST
&& (flags & LOOKUP_ONLYCONVERTING))
{
if (true_exp != exp)
abort ();
if (flags & DIRECT_BIND)
;
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;
expand_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_expr_list (NULL_TREE, init);
if (TYPE_USES_VIRTUAL_BASECLASSES (type))
{
if (true_exp == exp)
parms = expr_tree_cons (NULL_TREE, integer_one_node, parms);
else
parms = expr_tree_cons (NULL_TREE, integer_zero_node, parms);
flags |= LOOKUP_HAS_IN_CHARGE;
}
rval = build_method_call (exp, ctor_identifier,
parms, binfo, flags);
if (TREE_SIDE_EFFECTS (rval))
expand_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))
{
tree t = store_init_value (exp, init);
if (!t)
{
expand_decl_init (exp);
return;
}
t = build (INIT_EXPR, type, exp, init);
TREE_SIDE_EFFECTS (t) = 1;
expand_expr_stmt (t);
return;
}
expand_default_init (binfo, true_exp, exp, init, flags);
}
int
is_aggr_typedef (name, or_else)
tree name;
int or_else;
{
tree type;
if (name == error_mark_node)
return 0;
if (IDENTIFIER_HAS_TYPE_VALUE (name))
type = IDENTIFIER_TYPE_VALUE (name);
else
{
if (or_else)
cp_error ("`%T' is not an aggregate typedef", name);
return 0;
}
if (! IS_AGGR_TYPE (type)
&& TREE_CODE (type) != TEMPLATE_TYPE_PARM
&& TREE_CODE (type) != TEMPLATE_TEMPLATE_PARM)
{
if (or_else)
cp_error ("`%T' is not an aggregate type", type);
return 0;
}
return 1;
}
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) != TEMPLATE_TEMPLATE_PARM)
{
if (or_else)
cp_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)
cp_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) != TEMPLATE_TEMPLATE_PARM)
{
if (or_else)
cp_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 (type == std_node)
return build_x_function_call (do_scoped_id (name, 0), parmlist,
current_class_ref);
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)
{
cp_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
&& ! pedantic
&& 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_PTR);
}
}
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))
{
cp_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
{
cp_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
{
cp_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 (type == std_node)
return do_scoped_id (name, 0);
if (processing_template_decl || uses_template_parms (type))
return build_min_nt (SCOPE_REF, type, name);
if (TREE_CODE (type) == NAMESPACE_DECL)
{
t = lookup_namespace_name (type, name);
if (t != error_mark_node && ! type_unknown_p (t))
{
mark_used (t);
t = convert_from_reference (t);
}
return t;
}
if (type == NULL_TREE || ! is_aggr_type (type, 1))
return error_mark_node;
if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
{
name = TREE_OPERAND (orig_name, 0);
if (TREE_CODE (name) == LOOKUP_EXPR)
name = TREE_OPERAND (name, 0);
my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 0);
}
if (TREE_CODE (name) == BIT_NOT_EXPR)
{
if (! check_dtor_name (type, name))
cp_error ("qualified type `%T' does not match destructor name `~%T'",
type, TREE_OPERAND (name, 0));
name = dtor_identifier;
}
#if 0
else if (name == constructor_name_full (type)
|| name == constructor_name (type))
name = ctor_identifier;
#endif
if (TYPE_SIZE (complete_type (type)) == 0
&& !TYPE_BEING_DEFINED (type))
{
cp_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);
return build (OFFSET_REF,
unknown_type_node,
decl,
build (TEMPLATE_ID_EXPR,
TREE_TYPE (t),
t,
TREE_OPERAND (orig_name, 1)));
}
if (!really_overloaded_fn (t))
{
t = OVL_CURRENT (t);
basebinfo = TREE_PURPOSE (fnfields);
if (!enforce_access (basebinfo, t))
return error_mark_node;
mark_used (t);
if (DECL_STATIC_FUNCTION_P (t))
return t;
return build (OFFSET_REF, TREE_TYPE (t), decl, t);
}
if (!TREE_PERMANENT (fnfields)
&& ! allocation_temporary_p ())
fnfields = copy_list (fnfields);
TREE_TYPE (fnfields) = unknown_type_node;
return build (OFFSET_REF, unknown_type_node, decl, fnfields);
}
t = member;
if (t == NULL_TREE)
{
cp_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))
{
cp_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)
my_friendly_abort (53);
return build (OFFSET_REF, build_offset_type (type, TREE_TYPE (t)), decl, 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))
{
cp_pedwarn ("assuming & on overloaded member function");
return build_unary_op (ADDR_EXPR, exp, 0);
}
if (TREE_CODE (TREE_TYPE (member)) == METHOD_TYPE)
{
cp_pedwarn ("assuming & on `%E'", member);
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)
{
if (TREE_ADDRESSABLE (member) == 0)
{
cp_error_at ("member `%D' is non-static but referenced as a static member",
member);
error ("at this point in file");
TREE_ADDRESSABLE (member) = 1;
}
return error_mark_node;
}
if (TREE_CODE (member) == FIELD_DECL
&& (base == current_class_ref || is_dummy_object (base)))
{
tree basetype_path;
tree expr;
if (TREE_CODE (exp) == OFFSET_REF && TREE_CODE (type) == OFFSET_TYPE)
basetype = TYPE_OFFSET_BASETYPE (type);
else
basetype = DECL_CONTEXT (member);
base = current_class_ptr;
if (get_base_distance (basetype, TREE_TYPE (TREE_TYPE (base)), 0, &basetype_path) < 0)
{
error_not_base_type (basetype, TREE_TYPE (TREE_TYPE (base)));
return error_mark_node;
}
enforce_access (basetype_path, member);
addr = convert_pointer_to (basetype, base);
expr = build (COMPONENT_REF, TREE_TYPE (member),
build_indirect_ref (addr, NULL_PTR), member);
return convert_from_reference (expr);
}
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)
{
cp_error ("object missing in `%E'", exp);
return error_mark_node;
}
basetype = TYPE_OFFSET_BASETYPE (TREE_TYPE (TREE_TYPE (member)));
addr = convert_pointer_to (basetype, addr);
member = cp_convert (ptrdiff_type_node, member);
member = build_binary_op (MINUS_EXPR, member,
cp_convert (ptrdiff_type_node, integer_one_node));
return build1 (INDIRECT_REF, type,
build (PLUS_EXPR, build_pointer_type (type),
addr, member));
}
else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member)))
{
return get_member_function_from_ptrfunc (&addr, member);
}
my_friendly_abort (56);
return NULL_TREE;
}
tree
decl_constant_value (decl)
tree decl;
{
if (! 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,
void_type_node, build_expr_list (NULL_TREE, addr));
}
extern int flag_check_new;
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;
tree pending_sizes = NULL_TREE;
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;
int old_immediate_size_expand = 0;
if (current_function_decl
&& DECL_CONSTRUCTOR_P (current_function_decl))
{
old_immediate_size_expand = immediate_size_expand;
immediate_size_expand = 0;
}
nelts = integer_one_node;
if (absdcl && TREE_CODE (absdcl) == CALL_EXPR)
my_friendly_abort (215);
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
{
int flags = pedantic ? WANT_INT : (WANT_INT | WANT_ENUM);
if (build_expr_type_conversion (flags, 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 = 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)
{
immediate_size_expand = old_immediate_size_expand;
return error_mark_node;
}
if (current_function_decl
&& DECL_CONSTRUCTOR_P (current_function_decl))
{
pending_sizes = get_pending_sizes ();
immediate_size_expand = old_immediate_size_expand;
}
}
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 = min_tree_cons (min_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 = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
TREE_NO_UNUSED_WARNING (rval) = 1;
if (pending_sizes)
rval = build_compound_expr (chainon (pending_sizes,
build_expr_list (NULL_TREE, rval)));
return rval;
}
static tree jclass_node = NULL_TREE;
static tree
build_java_class_ref (type)
tree type;
{
tree name, class_decl;
static tree CL_prefix = NULL_TREE;
if (CL_prefix == NULL_TREE)
CL_prefix = get_identifier("_CL_");
if (jclass_node == NULL_TREE)
{
jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier("jclass"));
if (jclass_node == NULL_TREE)
fatal("call to Java constructor, while `jclass' undefined");
jclass_node = TREE_TYPE (jclass_node);
}
name = build_overload_with_type (CL_prefix, type);
class_decl = IDENTIFIER_GLOBAL_VALUE (name);
if (class_decl == NULL_TREE)
{
push_obstacks_nochange ();
end_temporary_allocation ();
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_PTR, 1);
pop_obstacks ();
}
return class_decl;
}
tree
build_new_1 (exp)
tree exp;
{
tree placement, init;
tree type, true_type, size, rval;
tree nelts = NULL_TREE;
tree alloc_expr, alloc_node = NULL_TREE;
int has_array = 0;
enum tree_code code = NEW_EXPR;
int use_cookie, nothrow, check_new;
int use_global_new;
int use_java_new = 0;
placement = TREE_OPERAND (exp, 0);
type = TREE_OPERAND (exp, 1);
init = TREE_OPERAND (exp, 2);
use_global_new = NEW_EXPR_USE_GLOBAL (exp);
if (TREE_CODE (type) == ARRAY_REF)
{
has_array = 1;
nelts = TREE_OPERAND (type, 1);
type = TREE_OPERAND (type, 0);
}
true_type = type;
if (CP_TYPE_QUALS (type))
type = TYPE_MAIN_VARIANT (type);
while (TREE_CODE (true_type) == ARRAY_TYPE)
{
tree this_nelts = array_type_nelts_top (true_type);
nelts = 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;
if (has_array)
size = fold (build_binary_op (MULT_EXPR, size_in_bytes (true_type),
nelts));
else
size = size_in_bytes (type);
if (TREE_CODE (true_type) == VOID_TYPE)
{
error ("invalid type `void' for new");
return error_mark_node;
}
if (TYPE_LANG_SPECIFIC (true_type)
&& CLASSTYPE_ABSTRACT_VIRTUALS (true_type))
{
abstract_virtuals_error (NULL_TREE, true_type);
return error_mark_node;
}
if (TYPE_LANG_SPECIFIC (true_type) && IS_SIGNATURE (true_type))
{
signature_error (NULL_TREE, true_type);
return error_mark_node;
}
use_cookie = (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type)
&& ! (placement && ! TREE_CHAIN (placement)
&& TREE_TYPE (TREE_VALUE (placement)) == ptr_type_node));
if (use_cookie)
{
tree extra = BI_header_size;
size = size_binop (PLUS_EXPR, size, extra);
}
if (has_array)
{
code = VEC_NEW_EXPR;
if (init && pedantic)
cp_pedwarn ("initialization in array new");
}
if (! has_array && ! placement && flag_this_is_variable > 0
&& TYPE_NEEDS_CONSTRUCTING (true_type) && init != void_type_node)
{
if (init == NULL_TREE || TREE_CODE (init) == TREE_LIST)
rval = NULL_TREE;
else
{
error ("constructors take parameter lists");
return error_mark_node;
}
}
else 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 char alloc_name[] = "_Jv_AllocObject";
use_java_new = 1;
alloc_decl = IDENTIFIER_GLOBAL_VALUE (get_identifier (alloc_name));
if (alloc_decl == NULL_TREE)
fatal("call to Java constructor, while `%s' undefined", alloc_name);
class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
rval = build_function_call (alloc_decl,
tree_cons (NULL_TREE, class_addr,
build_tree_list (NULL_TREE,
class_size)));
rval = cp_convert (build_pointer_type (true_type), rval);
}
else
{
int susp = 0;
if (flag_exceptions)
susp = suspend_momentary ();
rval = build_op_new_call
(code, true_type, expr_tree_cons (NULL_TREE, size, placement),
LOOKUP_NORMAL | (use_global_new * LOOKUP_GLOBAL));
rval = cp_convert (build_pointer_type (true_type), rval);
if (flag_exceptions)
resume_momentary (susp);
}
nothrow = 0;
if (rval)
{
tree t = TREE_OPERAND (rval, 0);
t = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
nothrow = TYPE_NOTHROW_P (TREE_TYPE (t));
}
check_new = (flag_check_new || nothrow) && ! use_java_new;
if ((check_new || flag_exceptions) && rval)
{
alloc_expr = get_target_expr (rval);
alloc_node = rval = TREE_OPERAND (alloc_expr, 0);
}
else
alloc_expr = NULL_TREE;
if (use_cookie && rval != NULL_TREE)
{
tree extra = BI_header_size;
tree cookie, exp1;
rval = convert (string_type_node, rval);
rval = save_expr (build_binary_op (PLUS_EXPR, rval, extra));
cookie = build_indirect_ref (build (MINUS_EXPR,
build_pointer_type (BI_header_type),
rval, extra), NULL_PTR);
exp1 = build (MODIFY_EXPR, void_type_node,
build_component_ref (cookie, nc_nelts_field_id,
NULL_TREE, 0),
nelts);
TREE_SIDE_EFFECTS (exp1) = 1;
rval = cp_convert (build_pointer_type (true_type), rval);
rval = build_compound_expr
(expr_tree_cons (NULL_TREE, exp1,
build_expr_list (NULL_TREE, rval)));
}
if (rval == error_mark_node)
return error_mark_node;
if (init == void_type_node)
goto done;
if (TYPE_NEEDS_CONSTRUCTING (type) || init)
{
if (! TYPE_NEEDS_CONSTRUCTING (type)
&& ! IS_AGGR_TYPE (type) && ! has_array)
{
tree deref;
tree deref_type;
rval = save_expr (rval);
deref = build_indirect_ref (rval, NULL_PTR);
deref_type = TREE_TYPE (deref);
if (CP_TYPE_CONST_P (deref_type))
TREE_TYPE (deref)
= cp_build_qualified_type (deref_type,
CP_TYPE_QUALS (deref_type)
& ~TYPE_QUAL_CONST);
TREE_READONLY (deref) = 0;
if (TREE_CHAIN (init) != NULL_TREE)
pedwarn ("initializer list being treated as compound expression");
else if (TREE_CODE (init) == CONSTRUCTOR)
{
pedwarn ("initializer list appears where operand should be used");
init = TREE_OPERAND (init, 1);
}
init = build_compound_expr (init);
init = convert_for_initialization (deref, type, init, LOOKUP_NORMAL,
"new", NULL_TREE, 0);
rval = build (COMPOUND_EXPR, TREE_TYPE (rval),
build_modify_expr (deref, NOP_EXPR, init),
rval);
TREE_NO_UNUSED_WARNING (rval) = 1;
TREE_SIDE_EFFECTS (rval) = 1;
}
else if (! has_array)
{
tree newrval;
int flags = LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_COMPLAIN;
if (rval && TYPE_USES_VIRTUAL_BASECLASSES (true_type))
{
init = expr_tree_cons (NULL_TREE, integer_one_node, init);
flags |= LOOKUP_HAS_IN_CHARGE;
}
if (use_java_new)
rval = save_expr (rval);
newrval = rval;
if (newrval && TREE_CODE (TREE_TYPE (newrval)) == POINTER_TYPE)
newrval = build_indirect_ref (newrval, NULL_PTR);
newrval = build_method_call (newrval, ctor_identifier,
init, TYPE_BINFO (true_type), flags);
if (newrval == NULL_TREE || newrval == error_mark_node)
return error_mark_node;
if (use_java_new)
newrval = build (COMPOUND_EXPR, TREE_TYPE (newrval),
newrval, rval);
rval = newrval;
TREE_HAS_CONSTRUCTOR (rval) = 1;
}
else
rval = build (VEC_INIT_EXPR, TREE_TYPE (rval),
save_expr (rval), init, nelts);
if (flag_exceptions && alloc_expr && ! use_java_new)
{
enum tree_code dcode = has_array ? VEC_DELETE_EXPR : DELETE_EXPR;
tree cleanup, fn = NULL_TREE;
int flags = LOOKUP_NORMAL | (use_global_new * LOOKUP_GLOBAL);
int yes = suspend_momentary ();
if (placement)
{
flags |= LOOKUP_SPECULATIVELY;
fn = TREE_OPERAND (alloc_expr, 1);
fn = TREE_OPERAND (fn, 0);
}
size = mapcar (size, permanent_p);
cleanup = build_op_delete_call (dcode, alloc_node, size, flags, fn);
resume_momentary (yes);
if (cleanup)
{
tree end, sentry, begin, buf, t = TREE_TYPE (rval);
begin = get_target_expr (boolean_true_node);
sentry = TREE_OPERAND (begin, 0);
yes = suspend_momentary ();
TREE_OPERAND (begin, 2)
= build (COND_EXPR, void_type_node, sentry,
cleanup, void_zero_node);
resume_momentary (yes);
rval = get_target_expr (rval);
end = build (MODIFY_EXPR, TREE_TYPE (sentry),
sentry, boolean_false_node);
TREE_SIDE_EFFECTS (end) = 1;
buf = TREE_OPERAND (rval, 0);
rval = build (COMPOUND_EXPR, t, begin,
build (COMPOUND_EXPR, t, rval,
build (COMPOUND_EXPR, t, end, buf)));
}
}
}
else if (CP_TYPE_CONST_P (true_type))
cp_error ("uninitialized const in `new' of `%#T'", true_type);
done:
if (alloc_expr && rval == alloc_node)
{
rval = TREE_OPERAND (alloc_expr, 1);
alloc_expr = NULL_TREE;
}
if (check_new && alloc_expr)
{
tree ifexp = build_binary_op (NE_EXPR, alloc_node,
integer_zero_node);
rval = build_conditional_expr (ifexp, rval, alloc_node);
}
if (alloc_expr)
rval = build (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
if (rval && TREE_TYPE (rval) != build_pointer_type (type))
{
rval = build_c_cast (build_pointer_type (type), rval);
}
return rval;
}
static tree
build_vec_delete_1 (base, maxindex, type, auto_delete_vec, auto_delete,
use_global_delete)
tree base, maxindex, type;
tree auto_delete_vec, auto_delete;
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_NEEDS_DESTRUCTOR (type))
{
loop = integer_zero_node;
goto no_destructor;
}
virtual_size = fold (size_binop (MULT_EXPR, size_exp, maxindex));
tbase = build_decl (VAR_DECL, NULL_TREE, 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;
if (auto_delete != integer_zero_node
&& auto_delete != integer_two_node)
{
tree base_tbd = cp_convert (ptype,
build_binary_op (MINUS_EXPR,
cp_convert (ptr_type_node, base),
BI_header_size));
virtual_size = size_binop (PLUS_EXPR, virtual_size, BI_header_size);
body = build_expr_list (NULL_TREE,
build_x_delete (base_tbd,
2 | use_global_delete,
virtual_size));
body = build (COND_EXPR, void_type_node,
build (BIT_AND_EXPR, integer_type_node,
auto_delete, integer_one_node),
body, integer_zero_node);
}
else
body = NULL_TREE;
body = expr_tree_cons (NULL_TREE,
build_delete (ptype, tbase, auto_delete,
LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1),
body);
body = expr_tree_cons (NULL_TREE,
build_modify_expr (tbase, NOP_EXPR, build (MINUS_EXPR, ptype, tbase, size_exp)),
body);
body = expr_tree_cons (NULL_TREE,
build (EXIT_EXPR, void_type_node,
build (EQ_EXPR, boolean_type_node, base, tbase)),
body);
loop = build (LOOP_EXPR, void_type_node, build_compound_expr (body));
loop = expr_tree_cons (NULL_TREE, tbase_init,
expr_tree_cons (NULL_TREE, loop, NULL_TREE));
loop = build_compound_expr (loop);
no_destructor:
if (auto_delete_vec == integer_zero_node)
deallocate_expr = integer_zero_node;
else
{
tree base_tbd;
virtual_size = fold (size_binop (MULT_EXPR, size_exp, maxindex));
if (! TYPE_VEC_NEW_USES_COOKIE (type))
base_tbd = base;
else
{
base_tbd = cp_convert (ptype,
build_binary_op (MINUS_EXPR,
cp_convert (string_type_node, base),
BI_header_size));
virtual_size = size_binop (PLUS_EXPR, virtual_size, BI_header_size);
}
deallocate_expr = build_x_delete (base_tbd,
2 | use_global_delete,
virtual_size);
if (auto_delete_vec != integer_one_node)
deallocate_expr = build (COND_EXPR, void_type_node,
build (BIT_AND_EXPR, integer_type_node,
auto_delete_vec, integer_one_node),
deallocate_expr, integer_zero_node);
}
if (loop && deallocate_expr != integer_zero_node)
{
body = expr_tree_cons (NULL_TREE, loop,
expr_tree_cons (NULL_TREE, deallocate_expr, NULL_TREE));
body = build_compound_expr (body);
}
else
body = loop;
body = build (COND_EXPR, void_type_node,
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);
}
static void
expand_vec_init_try_block (type)
tree type;
{
if (!TYPE_NEEDS_DESTRUCTOR (type) || !flag_exceptions)
return;
expand_eh_region_start ();
}
static void
expand_vec_init_catch_clause (rval, type, maxindex, iterator)
tree rval;
tree type;
tree maxindex;
tree iterator;
{
tree e;
tree cleanup;
if (!TYPE_NEEDS_DESTRUCTOR (type) || !flag_exceptions)
return;
push_obstacks_nochange ();
resume_temporary_allocation ();
cleanup = make_node (RTL_EXPR);
TREE_TYPE (cleanup) = void_type_node;
RTL_EXPR_RTL (cleanup) = const0_rtx;
TREE_SIDE_EFFECTS (cleanup) = 1;
do_pending_stack_adjust ();
start_sequence_for_rtl_expr (cleanup);
e = build_vec_delete_1 (rval,
build_binary_op (MINUS_EXPR, maxindex,
iterator),
type,
integer_zero_node,
integer_zero_node,
0);
expand_expr (e, const0_rtx, VOIDmode, EXPAND_NORMAL);
do_pending_stack_adjust ();
RTL_EXPR_SEQUENCE (cleanup) = get_insns ();
end_sequence ();
cleanup = protect_with_terminate (cleanup);
expand_eh_region_end (cleanup);
pop_obstacks ();
}
tree
expand_vec_init (decl, base, maxindex, init, from_array)
tree decl, base, maxindex, init;
int from_array;
{
tree rval;
tree base2 = NULL_TREE;
tree type = TREE_TYPE (TREE_TYPE (base));
tree size;
tree itype = NULL_TREE;
tree iterator;
int num_initialized_elts = 0;
maxindex = cp_convert (ptrdiff_type_node, maxindex);
if (maxindex == error_mark_node)
return error_mark_node;
if (current_function_decl == NULL_TREE)
{
rval = make_tree_vec (3);
TREE_VEC_ELT (rval, 0) = base;
TREE_VEC_ELT (rval, 1) = maxindex;
TREE_VEC_ELT (rval, 2) = init;
return rval;
}
size = size_in_bytes (type);
base = default_conversion (base);
base = cp_convert (build_pointer_type (type), base);
rval = get_temp_regvar (build_pointer_type (type), base);
base = get_temp_regvar (build_pointer_type (type), base);
iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
expand_vec_init_try_block (type);
if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR
&& (!decl || same_type_p (TREE_TYPE (init), TREE_TYPE (decl))))
{
tree elts;
tree baseref = build1 (INDIRECT_REF, type, base);
from_array = 0;
for (elts = CONSTRUCTOR_ELTS (init); elts; elts = TREE_CHAIN (elts))
{
tree elt = TREE_VALUE (elts);
num_initialized_elts++;
if (IS_AGGR_TYPE (type) || TREE_CODE (type) == ARRAY_TYPE)
expand_aggr_init (baseref, elt, 0);
else
expand_assignment (baseref, elt, 0, 0);
expand_assignment (base,
build (PLUS_EXPR, build_pointer_type (type),
base, size),
0, 0);
expand_assignment (iterator,
build (MINUS_EXPR, ptrdiff_type_node,
iterator, integer_one_node),
0, 0);
}
init = NULL_TREE;
if (obey_regdecls)
use_variable (DECL_RTL (base));
}
else if (from_array)
{
if (decl == NULL_TREE)
{
sorry ("initialization of array from dissimilar array type");
return error_mark_node;
}
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)
&& !(TREE_CODE (maxindex) == INTEGER_CST
&& num_initialized_elts == TREE_INT_CST_LOW (maxindex) + 1)))
{
expand_start_cond (build (NE_EXPR, boolean_type_node,
iterator, minus_one),
0);
expand_start_loop_continue_elsewhere (1);
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)
expand_expr_stmt (build_modify_expr (to, NOP_EXPR, from));
else if (TYPE_NEEDS_CONSTRUCTING (type))
expand_aggr_init (to, from, 0);
else if (from)
expand_assignment (to, from, 0, 0);
else
my_friendly_abort (57);
}
else if (TREE_CODE (type) == ARRAY_TYPE)
{
if (init != 0)
sorry ("cannot initialize multi-dimensional array with initializer");
expand_vec_init (decl,
build1 (NOP_EXPR,
build_pointer_type (TREE_TYPE
(type)),
base),
array_type_nelts (type), 0, 0);
}
else
expand_aggr_init (build1 (INDIRECT_REF, type, base), init, 0);
expand_assignment (base,
build (PLUS_EXPR, build_pointer_type (type),
base, size), 0, 0);
if (base2)
expand_assignment (base2,
build (PLUS_EXPR, build_pointer_type (type),
base2, size), 0, 0);
expand_end_target_temps ();
expand_loop_continue_here ();
expand_exit_loop_if_false (0, build (NE_EXPR, boolean_type_node,
build (PREDECREMENT_EXPR,
ptrdiff_type_node,
iterator,
integer_one_node),
minus_one));
if (obey_regdecls)
{
use_variable (DECL_RTL (base));
if (base2)
use_variable (DECL_RTL (base2));
}
expand_end_loop ();
expand_end_cond ();
}
expand_vec_init_catch_clause (rval, type, maxindex, iterator);
if (obey_regdecls)
{
use_variable (DECL_RTL (iterator));
use_variable (DECL_RTL (rval));
}
return rval;
}
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);
}
tree
build_delete (type, addr, auto_delete, flags, use_global_delete)
tree type, addr;
tree auto_delete;
int flags;
int use_global_delete;
{
tree member;
tree expr;
tree ref;
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 (type != void_type_node && !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);
ref = build_indirect_ref (addr, NULL_PTR);
}
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, integer_zero_node,
use_global_delete);
}
else
{
addr = build_unary_op (ADDR_EXPR, addr, 0);
if (TREE_SIDE_EFFECTS (addr))
addr = save_expr (addr);
if (TREE_CONSTANT (addr))
addr = convert_pointer_to (type, addr);
else
addr = convert_force (build_pointer_type (type), addr, 0);
ref = build_indirect_ref (addr, NULL_PTR);
}
my_friendly_assert (IS_AGGR_TYPE (type), 220);
if (! TYPE_NEEDS_DESTRUCTOR (type))
{
if (auto_delete == integer_zero_node)
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);
}
if (TYPE_HAS_DESTRUCTOR (type))
{
tree passed_auto_delete;
tree do_delete = NULL_TREE;
tree ifexp;
if (use_global_delete)
{
tree cond = fold (build (BIT_AND_EXPR, integer_type_node,
auto_delete, integer_one_node));
tree call = build_builtin_delete_call (addr);
cond = fold (build (COND_EXPR, void_type_node, cond,
call, void_zero_node));
if (cond != void_zero_node)
do_delete = cond;
passed_auto_delete = fold (build (BIT_AND_EXPR, integer_type_node,
auto_delete, integer_two_node));
}
else
passed_auto_delete = auto_delete;
expr = build_method_call
(ref, dtor_identifier, build_expr_list (NULL_TREE, passed_auto_delete),
NULL_TREE, 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 (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;
}
else
{
tree binfos = BINFO_BASETYPES (TYPE_BINFO (type));
int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
tree base_binfo = n_baseclasses > 0 ? TREE_VEC_ELT (binfos, 0) : NULL_TREE;
tree exprstmt = NULL_TREE;
tree parent_auto_delete = auto_delete;
tree cond;
TYPE_HAS_DESTRUCTOR (type) = 1;
if (auto_delete == integer_zero_node)
cond = NULL_TREE;
else if (base_binfo == NULL_TREE
|| ! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo)))
{
cond = build (COND_EXPR, void_type_node,
build (BIT_AND_EXPR, integer_type_node, auto_delete, integer_one_node),
build_builtin_delete_call (addr),
void_zero_node);
}
else
cond = NULL_TREE;
if (cond)
exprstmt = build_expr_list (NULL_TREE, cond);
if (base_binfo
&& ! TREE_VIA_VIRTUAL (base_binfo)
&& TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo)))
{
tree this_auto_delete;
if (BINFO_OFFSET_ZEROP (base_binfo))
this_auto_delete = parent_auto_delete;
else
this_auto_delete = integer_zero_node;
expr = build_scoped_method_call
(ref, base_binfo, dtor_identifier,
build_expr_list (NULL_TREE, this_auto_delete));
exprstmt = expr_tree_cons (NULL_TREE, expr, exprstmt);
}
for (i = 1; i < n_baseclasses; i++)
{
base_binfo = TREE_VEC_ELT (binfos, i);
if (! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo))
|| TREE_VIA_VIRTUAL (base_binfo))
continue;
expr = build_scoped_method_call
(ref, base_binfo, dtor_identifier,
build_expr_list (NULL_TREE, integer_zero_node));
exprstmt = expr_tree_cons (NULL_TREE, expr, exprstmt);
}
for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
{
if (TREE_CODE (member) != FIELD_DECL)
continue;
if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (member)))
{
tree this_member = build_component_ref (ref, DECL_NAME (member), NULL_TREE, 0);
tree this_type = TREE_TYPE (member);
expr = build_delete (this_type, this_member, integer_two_node, flags, 0);
exprstmt = expr_tree_cons (NULL_TREE, expr, exprstmt);
}
}
if (exprstmt)
return build_compound_expr (exprstmt);
return void_zero_node;
}
}
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 (vbases)),
addr, 0);
result = expr_tree_cons (NULL_TREE,
build_delete (TREE_TYPE (this_addr), this_addr,
integer_zero_node,
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, auto_delete,
use_global_delete)
tree base, maxindex;
tree auto_delete_vec, auto_delete;
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 = build (MINUS_EXPR, build_pointer_type (BI_header_type),
base, BI_header_size);
tree cookie = build_indirect_ref (cookie_addr, NULL_PTR);
maxindex = build_component_ref (cookie, nc_nelts_field_id, NULL_TREE, 0);
do
type = TREE_TYPE (type);
while (TREE_CODE (type) == ARRAY_TYPE);
}
else if (TREE_CODE (type) == ARRAY_TYPE)
{
maxindex = array_type_nelts_total (type);
while (TREE_CODE (type) == ARRAY_TYPE)
type = TREE_TYPE (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, auto_delete,
use_global_delete);
}