1 /* Handle initialization things in C++.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* High-level class interface. */
27 #include "coretypes.h"
35 static bool begin_init_stmts (tree
*, tree
*);
36 static tree
finish_init_stmts (bool, tree
, tree
);
37 static void construct_virtual_base (tree
, tree
);
38 static void expand_aggr_init_1 (tree
, tree
, tree
, tree
, int, tsubst_flags_t
);
39 static void expand_default_init (tree
, tree
, tree
, tree
, int, tsubst_flags_t
);
40 static tree
build_vec_delete_1 (tree
, tree
, tree
, special_function_kind
, int);
41 static void perform_member_init (tree
, tree
);
42 static tree
build_builtin_delete_call (tree
);
43 static int member_init_ok_or_else (tree
, tree
, tree
);
44 static void expand_virtual_init (tree
, tree
);
45 static tree
sort_mem_initializers (tree
, tree
);
46 static tree
initializing_context (tree
);
47 static void expand_cleanup_for_base (tree
, tree
);
48 static tree
get_temp_regvar (tree
, tree
);
49 static tree
dfs_initialize_vtbl_ptrs (tree
, void *);
50 static tree
build_dtor_call (tree
, special_function_kind
, int);
51 static tree
build_field_list (tree
, tree
, int *);
52 static tree
build_vtbl_address (tree
);
53 static int diagnose_uninitialized_cst_or_ref_member_1 (tree
, tree
, bool, bool);
55 /* We are about to generate some complex initialization code.
56 Conceptually, it is all a single expression. However, we may want
57 to include conditionals, loops, and other such statement-level
58 constructs. Therefore, we build the initialization code inside a
59 statement-expression. This function starts such an expression.
60 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
61 pass them back to finish_init_stmts when the expression is
65 begin_init_stmts (tree
*stmt_expr_p
, tree
*compound_stmt_p
)
67 bool is_global
= !building_stmt_tree ();
69 *stmt_expr_p
= begin_stmt_expr ();
70 *compound_stmt_p
= begin_compound_stmt (BCS_NO_SCOPE
);
75 /* Finish out the statement-expression begun by the previous call to
76 begin_init_stmts. Returns the statement-expression itself. */
79 finish_init_stmts (bool is_global
, tree stmt_expr
, tree compound_stmt
)
81 finish_compound_stmt (compound_stmt
);
83 stmt_expr
= finish_stmt_expr (stmt_expr
, true);
85 gcc_assert (!building_stmt_tree () == is_global
);
92 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
93 which we want to initialize the vtable pointer for, DATA is
94 TREE_LIST whose TREE_VALUE is the this ptr expression. */
97 dfs_initialize_vtbl_ptrs (tree binfo
, void *data
)
99 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
100 return dfs_skip_bases
;
102 if (!BINFO_PRIMARY_P (binfo
) || BINFO_VIRTUAL_P (binfo
))
104 tree base_ptr
= TREE_VALUE ((tree
) data
);
106 base_ptr
= build_base_path (PLUS_EXPR
, base_ptr
, binfo
, /*nonnull=*/1);
108 expand_virtual_init (binfo
, base_ptr
);
114 /* Initialize all the vtable pointers in the object pointed to by
118 initialize_vtbl_ptrs (tree addr
)
123 type
= TREE_TYPE (TREE_TYPE (addr
));
124 list
= build_tree_list (type
, addr
);
126 /* Walk through the hierarchy, initializing the vptr in each base
127 class. We do these in pre-order because we can't find the virtual
128 bases for a class until we've initialized the vtbl for that
130 dfs_walk_once (TYPE_BINFO (type
), dfs_initialize_vtbl_ptrs
, NULL
, list
);
133 /* Return an expression for the zero-initialization of an object with
134 type T. This expression will either be a constant (in the case
135 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
136 aggregate), or NULL (in the case that T does not require
137 initialization). In either case, the value can be used as
138 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
139 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
140 is the number of elements in the array. If STATIC_STORAGE_P is
141 TRUE, initializers are only generated for entities for which
142 zero-initialization does not simply mean filling the storage with
143 zero bytes. FIELD_SIZE, if non-NULL, is the bit size of the field,
144 subfields with bit positions at or above that bit size shouldn't
148 build_zero_init_1 (tree type
, tree nelts
, bool static_storage_p
,
151 tree init
= NULL_TREE
;
155 To zero-initialize an object of type T means:
157 -- if T is a scalar type, the storage is set to the value of zero
160 -- if T is a non-union class type, the storage for each nonstatic
161 data member and each base-class subobject is zero-initialized.
163 -- if T is a union type, the storage for its first data member is
166 -- if T is an array type, the storage for each element is
169 -- if T is a reference type, no initialization is performed. */
171 gcc_assert (nelts
== NULL_TREE
|| TREE_CODE (nelts
) == INTEGER_CST
);
173 if (type
== error_mark_node
)
175 else if (static_storage_p
&& zero_init_p (type
))
176 /* In order to save space, we do not explicitly build initializers
177 for items that do not need them. GCC's semantics are that
178 items with static storage duration that are not otherwise
179 initialized are initialized to zero. */
181 else if (SCALAR_TYPE_P (type
))
182 init
= convert (type
, integer_zero_node
);
183 else if (CLASS_TYPE_P (type
))
186 VEC(constructor_elt
,gc
) *v
= NULL
;
188 /* Iterate over the fields, building initializations. */
189 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
191 if (TREE_CODE (field
) != FIELD_DECL
)
194 /* Don't add virtual bases for base classes if they are beyond
195 the size of the current field, that means it is present
196 somewhere else in the object. */
199 tree bitpos
= bit_position (field
);
200 if (TREE_CODE (bitpos
) == INTEGER_CST
201 && !tree_int_cst_lt (bitpos
, field_size
))
205 /* Note that for class types there will be FIELD_DECLs
206 corresponding to base classes as well. Thus, iterating
207 over TYPE_FIELDs will result in correct initialization of
208 all of the subobjects. */
209 if (!static_storage_p
|| !zero_init_p (TREE_TYPE (field
)))
212 = (DECL_FIELD_IS_BASE (field
)
214 && TREE_CODE (DECL_SIZE (field
)) == INTEGER_CST
)
215 ? DECL_SIZE (field
) : NULL_TREE
;
216 tree value
= build_zero_init_1 (TREE_TYPE (field
),
221 CONSTRUCTOR_APPEND_ELT(v
, field
, value
);
224 /* For unions, only the first field is initialized. */
225 if (TREE_CODE (type
) == UNION_TYPE
)
229 /* Build a constructor to contain the initializations. */
230 init
= build_constructor (type
, v
);
232 else if (TREE_CODE (type
) == ARRAY_TYPE
)
235 VEC(constructor_elt
,gc
) *v
= NULL
;
237 /* Iterate over the array elements, building initializations. */
239 max_index
= fold_build2_loc (input_location
,
240 MINUS_EXPR
, TREE_TYPE (nelts
),
241 nelts
, integer_one_node
);
243 max_index
= array_type_nelts (type
);
245 /* If we have an error_mark here, we should just return error mark
246 as we don't know the size of the array yet. */
247 if (max_index
== error_mark_node
)
248 return error_mark_node
;
249 gcc_assert (TREE_CODE (max_index
) == INTEGER_CST
);
251 /* A zero-sized array, which is accepted as an extension, will
252 have an upper bound of -1. */
253 if (!tree_int_cst_equal (max_index
, integer_minus_one_node
))
257 v
= VEC_alloc (constructor_elt
, gc
, 1);
258 ce
= VEC_quick_push (constructor_elt
, v
, NULL
);
260 /* If this is a one element array, we just use a regular init. */
261 if (tree_int_cst_equal (size_zero_node
, max_index
))
262 ce
->index
= size_zero_node
;
264 ce
->index
= build2 (RANGE_EXPR
, sizetype
, size_zero_node
,
267 ce
->value
= build_zero_init_1 (TREE_TYPE (type
),
269 static_storage_p
, NULL_TREE
);
272 /* Build a constructor to contain the initializations. */
273 init
= build_constructor (type
, v
);
275 else if (TREE_CODE (type
) == VECTOR_TYPE
)
276 init
= build_zero_cst (type
);
278 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
280 /* In all cases, the initializer is a constant. */
282 TREE_CONSTANT (init
) = 1;
287 /* Return an expression for the zero-initialization of an object with
288 type T. This expression will either be a constant (in the case
289 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
290 aggregate), or NULL (in the case that T does not require
291 initialization). In either case, the value can be used as
292 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
293 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
294 is the number of elements in the array. If STATIC_STORAGE_P is
295 TRUE, initializers are only generated for entities for which
296 zero-initialization does not simply mean filling the storage with
300 build_zero_init (tree type
, tree nelts
, bool static_storage_p
)
302 return build_zero_init_1 (type
, nelts
, static_storage_p
, NULL_TREE
);
305 /* Return a suitable initializer for value-initializing an object of type
306 TYPE, as described in [dcl.init]. */
309 build_value_init (tree type
, tsubst_flags_t complain
)
313 To value-initialize an object of type T means:
315 - if T is a class type (clause 9) with a user-provided constructor
316 (12.1), then the default constructor for T is called (and the
317 initialization is ill-formed if T has no accessible default
320 - if T is a non-union class type without a user-provided constructor,
321 then every non-static data member and base-class component of T is
322 value-initialized;92)
324 - if T is an array type, then each element is value-initialized;
326 - otherwise, the object is zero-initialized.
328 A program that calls for default-initialization or
329 value-initialization of an entity of reference type is ill-formed.
331 92) Value-initialization for such a class object may be implemented by
332 zero-initializing the object and then calling the default
335 /* The AGGR_INIT_EXPR tweaking below breaks in templates. */
336 gcc_assert (!processing_template_decl
);
338 if (CLASS_TYPE_P (type
))
340 if (type_has_user_provided_constructor (type
))
341 return build_aggr_init_expr
343 build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
344 NULL
, type
, LOOKUP_NORMAL
,
346 else if (TREE_CODE (type
) != UNION_TYPE
&& TYPE_NEEDS_CONSTRUCTING (type
))
348 /* This is a class that needs constructing, but doesn't have
349 a user-provided constructor. So we need to zero-initialize
350 the object and then call the implicitly defined ctor.
351 This will be handled in simplify_aggr_init_expr. */
352 tree ctor
= build_special_member_call
353 (NULL_TREE
, complete_ctor_identifier
,
354 NULL
, type
, LOOKUP_NORMAL
, complain
);
355 if (ctor
!= error_mark_node
)
357 ctor
= build_aggr_init_expr (type
, ctor
);
358 AGGR_INIT_ZERO_FIRST (ctor
) = 1;
363 return build_value_init_noctor (type
, complain
);
366 /* Like build_value_init, but don't call the constructor for TYPE. Used
367 for base initializers. */
370 build_value_init_noctor (tree type
, tsubst_flags_t complain
)
372 if (CLASS_TYPE_P (type
))
374 gcc_assert (!TYPE_NEEDS_CONSTRUCTING (type
));
376 if (TREE_CODE (type
) != UNION_TYPE
)
379 VEC(constructor_elt
,gc
) *v
= NULL
;
381 /* Iterate over the fields, building initializations. */
382 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
386 if (TREE_CODE (field
) != FIELD_DECL
)
389 ftype
= TREE_TYPE (field
);
391 if (TREE_CODE (ftype
) == REFERENCE_TYPE
)
393 if (complain
& tf_error
)
394 error ("value-initialization of reference");
396 return error_mark_node
;
399 /* We could skip vfields and fields of types with
400 user-defined constructors, but I think that won't improve
401 performance at all; it should be simpler in general just
402 to zero out the entire object than try to only zero the
403 bits that actually need it. */
405 /* Note that for class types there will be FIELD_DECLs
406 corresponding to base classes as well. Thus, iterating
407 over TYPE_FIELDs will result in correct initialization of
408 all of the subobjects. */
409 value
= build_value_init (ftype
, complain
);
412 CONSTRUCTOR_APPEND_ELT(v
, field
, value
);
415 /* Build a constructor to contain the zero- initializations. */
416 return build_constructor (type
, v
);
419 else if (TREE_CODE (type
) == ARRAY_TYPE
)
421 VEC(constructor_elt
,gc
) *v
= NULL
;
423 /* Iterate over the array elements, building initializations. */
424 tree max_index
= array_type_nelts (type
);
426 /* If we have an error_mark here, we should just return error mark
427 as we don't know the size of the array yet. */
428 if (max_index
== error_mark_node
)
430 error ("cannot value-initialize array of unknown bound %qT", type
);
431 return error_mark_node
;
433 gcc_assert (TREE_CODE (max_index
) == INTEGER_CST
);
435 /* A zero-sized array, which is accepted as an extension, will
436 have an upper bound of -1. */
437 if (!tree_int_cst_equal (max_index
, integer_minus_one_node
))
441 v
= VEC_alloc (constructor_elt
, gc
, 1);
442 ce
= VEC_quick_push (constructor_elt
, v
, NULL
);
444 /* If this is a one element array, we just use a regular init. */
445 if (tree_int_cst_equal (size_zero_node
, max_index
))
446 ce
->index
= size_zero_node
;
448 ce
->index
= build2 (RANGE_EXPR
, sizetype
, size_zero_node
,
451 ce
->value
= build_value_init (TREE_TYPE (type
), complain
);
453 /* The gimplifier can't deal with a RANGE_EXPR of TARGET_EXPRs. */
454 gcc_assert (TREE_CODE (ce
->value
) != TARGET_EXPR
455 && TREE_CODE (ce
->value
) != AGGR_INIT_EXPR
);
458 /* Build a constructor to contain the initializations. */
459 return build_constructor (type
, v
);
462 return build_zero_init (type
, NULL_TREE
, /*static_storage_p=*/false);
465 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
466 arguments. If TREE_LIST is void_type_node, an empty initializer
467 list was given; if NULL_TREE no initializer was given. */
470 perform_member_init (tree member
, tree init
)
473 tree type
= TREE_TYPE (member
);
475 /* Effective C++ rule 12 requires that all data members be
477 if (warn_ecpp
&& init
== NULL_TREE
&& TREE_CODE (type
) != ARRAY_TYPE
)
478 warning_at (DECL_SOURCE_LOCATION (current_function_decl
), OPT_Weffc__
,
479 "%qD should be initialized in the member initialization list",
482 /* Get an lvalue for the data member. */
483 decl
= build_class_member_access_expr (current_class_ref
, member
,
484 /*access_path=*/NULL_TREE
,
485 /*preserve_reference=*/true,
486 tf_warning_or_error
);
487 if (decl
== error_mark_node
)
490 if (init
== void_type_node
)
492 /* mem() means value-initialization. */
493 if (TREE_CODE (type
) == ARRAY_TYPE
)
495 init
= build_vec_init_expr (type
, init
);
496 init
= build2 (INIT_EXPR
, type
, decl
, init
);
497 finish_expr_stmt (init
);
501 if (TREE_CODE (type
) == REFERENCE_TYPE
)
502 permerror (DECL_SOURCE_LOCATION (current_function_decl
),
503 "value-initialization of %q#D, which has reference type",
507 init
= build2 (INIT_EXPR
, type
, decl
,
508 build_value_init (type
, tf_warning_or_error
));
509 finish_expr_stmt (init
);
513 /* Deal with this here, as we will get confused if we try to call the
514 assignment op for an anonymous union. This can happen in a
515 synthesized copy constructor. */
516 else if (ANON_AGGR_TYPE_P (type
))
520 init
= build2 (INIT_EXPR
, type
, decl
, TREE_VALUE (init
));
521 finish_expr_stmt (init
);
524 else if (TYPE_NEEDS_CONSTRUCTING (type
))
526 if (TREE_CODE (type
) == ARRAY_TYPE
)
530 gcc_assert (TREE_CHAIN (init
) == NULL_TREE
);
531 init
= TREE_VALUE (init
);
533 if (init
== NULL_TREE
534 || same_type_ignoring_top_level_qualifiers_p (type
,
537 init
= build_vec_init_expr (type
, init
);
538 init
= build2 (INIT_EXPR
, type
, decl
, init
);
539 finish_expr_stmt (init
);
542 error ("invalid initializer for array member %q#D", member
);
546 int flags
= LOOKUP_NORMAL
;
547 if (DECL_DEFAULTED_FN (current_function_decl
))
548 flags
|= LOOKUP_DEFAULTED
;
549 if (CP_TYPE_CONST_P (type
)
551 && !type_has_user_provided_default_constructor (type
))
552 /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
553 vtable; still give this diagnostic. */
554 permerror (DECL_SOURCE_LOCATION (current_function_decl
),
555 "uninitialized member %qD with %<const%> type %qT",
557 finish_expr_stmt (build_aggr_init (decl
, init
, flags
,
558 tf_warning_or_error
));
563 if (init
== NULL_TREE
)
566 /* member traversal: note it leaves init NULL */
567 if (TREE_CODE (type
) == REFERENCE_TYPE
)
568 permerror (DECL_SOURCE_LOCATION (current_function_decl
),
569 "uninitialized reference member %qD",
571 else if (CP_TYPE_CONST_P (type
))
572 permerror (DECL_SOURCE_LOCATION (current_function_decl
),
573 "uninitialized member %qD with %<const%> type %qT",
576 core_type
= strip_array_types (type
);
578 if (DECL_DECLARED_CONSTEXPR_P (current_function_decl
)
579 && !type_has_constexpr_default_constructor (core_type
))
581 if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
582 error ("uninitialized member %qD in %<constexpr%> constructor",
584 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
587 if (CLASS_TYPE_P (core_type
)
588 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
589 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
590 diagnose_uninitialized_cst_or_ref_member (core_type
,
594 else if (TREE_CODE (init
) == TREE_LIST
)
595 /* There was an explicit member initialization. Do some work
597 init
= build_x_compound_expr_from_list (init
, ELK_MEM_INIT
,
598 tf_warning_or_error
);
601 finish_expr_stmt (cp_build_modify_expr (decl
, INIT_EXPR
, init
,
602 tf_warning_or_error
));
605 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
609 expr
= build_class_member_access_expr (current_class_ref
, member
,
610 /*access_path=*/NULL_TREE
,
611 /*preserve_reference=*/false,
612 tf_warning_or_error
);
613 expr
= build_delete (type
, expr
, sfk_complete_destructor
,
614 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0);
616 if (expr
!= error_mark_node
)
617 finish_eh_cleanup (expr
);
621 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
622 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
625 build_field_list (tree t
, tree list
, int *uses_unions_p
)
631 /* Note whether or not T is a union. */
632 if (TREE_CODE (t
) == UNION_TYPE
)
635 for (fields
= TYPE_FIELDS (t
); fields
; fields
= DECL_CHAIN (fields
))
639 /* Skip CONST_DECLs for enumeration constants and so forth. */
640 if (TREE_CODE (fields
) != FIELD_DECL
|| DECL_ARTIFICIAL (fields
))
643 fieldtype
= TREE_TYPE (fields
);
644 /* Keep track of whether or not any fields are unions. */
645 if (TREE_CODE (fieldtype
) == UNION_TYPE
)
648 /* For an anonymous struct or union, we must recursively
649 consider the fields of the anonymous type. They can be
650 directly initialized from the constructor. */
651 if (ANON_AGGR_TYPE_P (fieldtype
))
653 /* Add this field itself. Synthesized copy constructors
654 initialize the entire aggregate. */
655 list
= tree_cons (fields
, NULL_TREE
, list
);
656 /* And now add the fields in the anonymous aggregate. */
657 list
= build_field_list (fieldtype
, list
, uses_unions_p
);
659 /* Add this field. */
660 else if (DECL_NAME (fields
))
661 list
= tree_cons (fields
, NULL_TREE
, list
);
667 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
668 a FIELD_DECL or BINFO in T that needs initialization. The
669 TREE_VALUE gives the initializer, or list of initializer arguments.
671 Return a TREE_LIST containing all of the initializations required
672 for T, in the order in which they should be performed. The output
673 list has the same format as the input. */
676 sort_mem_initializers (tree t
, tree mem_inits
)
679 tree base
, binfo
, base_binfo
;
682 VEC(tree
,gc
) *vbases
;
686 /* Build up a list of initializations. The TREE_PURPOSE of entry
687 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
688 TREE_VALUE will be the constructor arguments, or NULL if no
689 explicit initialization was provided. */
690 sorted_inits
= NULL_TREE
;
692 /* Process the virtual bases. */
693 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
694 VEC_iterate (tree
, vbases
, i
, base
); i
++)
695 sorted_inits
= tree_cons (base
, NULL_TREE
, sorted_inits
);
697 /* Process the direct bases. */
698 for (binfo
= TYPE_BINFO (t
), i
= 0;
699 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
700 if (!BINFO_VIRTUAL_P (base_binfo
))
701 sorted_inits
= tree_cons (base_binfo
, NULL_TREE
, sorted_inits
);
703 /* Process the non-static data members. */
704 sorted_inits
= build_field_list (t
, sorted_inits
, &uses_unions_p
);
705 /* Reverse the entire list of initializations, so that they are in
706 the order that they will actually be performed. */
707 sorted_inits
= nreverse (sorted_inits
);
709 /* If the user presented the initializers in an order different from
710 that in which they will actually occur, we issue a warning. Keep
711 track of the next subobject which can be explicitly initialized
712 without issuing a warning. */
713 next_subobject
= sorted_inits
;
715 /* Go through the explicit initializers, filling in TREE_PURPOSE in
717 for (init
= mem_inits
; init
; init
= TREE_CHAIN (init
))
722 subobject
= TREE_PURPOSE (init
);
724 /* If the explicit initializers are in sorted order, then
725 SUBOBJECT will be NEXT_SUBOBJECT, or something following
727 for (subobject_init
= next_subobject
;
729 subobject_init
= TREE_CHAIN (subobject_init
))
730 if (TREE_PURPOSE (subobject_init
) == subobject
)
733 /* Issue a warning if the explicit initializer order does not
734 match that which will actually occur.
735 ??? Are all these on the correct lines? */
736 if (warn_reorder
&& !subobject_init
)
738 if (TREE_CODE (TREE_PURPOSE (next_subobject
)) == FIELD_DECL
)
739 warning (OPT_Wreorder
, "%q+D will be initialized after",
740 TREE_PURPOSE (next_subobject
));
742 warning (OPT_Wreorder
, "base %qT will be initialized after",
743 TREE_PURPOSE (next_subobject
));
744 if (TREE_CODE (subobject
) == FIELD_DECL
)
745 warning (OPT_Wreorder
, " %q+#D", subobject
);
747 warning (OPT_Wreorder
, " base %qT", subobject
);
748 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
749 OPT_Wreorder
, " when initialized here");
752 /* Look again, from the beginning of the list. */
755 subobject_init
= sorted_inits
;
756 while (TREE_PURPOSE (subobject_init
) != subobject
)
757 subobject_init
= TREE_CHAIN (subobject_init
);
760 /* It is invalid to initialize the same subobject more than
762 if (TREE_VALUE (subobject_init
))
764 if (TREE_CODE (subobject
) == FIELD_DECL
)
765 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
766 "multiple initializations given for %qD",
769 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
770 "multiple initializations given for base %qT",
774 /* Record the initialization. */
775 TREE_VALUE (subobject_init
) = TREE_VALUE (init
);
776 next_subobject
= subobject_init
;
781 If a ctor-initializer specifies more than one mem-initializer for
782 multiple members of the same union (including members of
783 anonymous unions), the ctor-initializer is ill-formed.
785 Here we also splice out uninitialized union members. */
788 tree last_field
= NULL_TREE
;
790 for (p
= &sorted_inits
; *p
; )
798 field
= TREE_PURPOSE (init
);
800 /* Skip base classes. */
801 if (TREE_CODE (field
) != FIELD_DECL
)
804 /* If this is an anonymous union with no explicit initializer,
806 if (!TREE_VALUE (init
) && ANON_UNION_TYPE_P (TREE_TYPE (field
)))
809 /* See if this field is a member of a union, or a member of a
810 structure contained in a union, etc. */
811 for (ctx
= DECL_CONTEXT (field
);
812 !same_type_p (ctx
, t
);
813 ctx
= TYPE_CONTEXT (ctx
))
814 if (TREE_CODE (ctx
) == UNION_TYPE
)
816 /* If this field is not a member of a union, skip it. */
817 if (TREE_CODE (ctx
) != UNION_TYPE
)
820 /* If this union member has no explicit initializer, splice
822 if (!TREE_VALUE (init
))
825 /* It's only an error if we have two initializers for the same
833 /* See if LAST_FIELD and the field initialized by INIT are
834 members of the same union. If so, there's a problem,
835 unless they're actually members of the same structure
836 which is itself a member of a union. For example, given:
838 union { struct { int i; int j; }; };
840 initializing both `i' and `j' makes sense. */
841 ctx
= DECL_CONTEXT (field
);
847 last_ctx
= DECL_CONTEXT (last_field
);
850 if (same_type_p (last_ctx
, ctx
))
852 if (TREE_CODE (ctx
) == UNION_TYPE
)
853 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
854 "initializations for multiple members of %qT",
860 if (same_type_p (last_ctx
, t
))
863 last_ctx
= TYPE_CONTEXT (last_ctx
);
866 /* If we've reached the outermost class, then we're
868 if (same_type_p (ctx
, t
))
871 ctx
= TYPE_CONTEXT (ctx
);
878 p
= &TREE_CHAIN (*p
);
881 *p
= TREE_CHAIN (*p
);
889 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
890 is a TREE_LIST giving the explicit mem-initializer-list for the
891 constructor. The TREE_PURPOSE of each entry is a subobject (a
892 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
893 is a TREE_LIST giving the arguments to the constructor or
894 void_type_node for an empty list of arguments. */
897 emit_mem_initializers (tree mem_inits
)
899 int flags
= LOOKUP_NORMAL
;
901 /* We will already have issued an error message about the fact that
902 the type is incomplete. */
903 if (!COMPLETE_TYPE_P (current_class_type
))
906 if (DECL_DEFAULTED_FN (current_function_decl
))
907 flags
|= LOOKUP_DEFAULTED
;
909 /* Sort the mem-initializers into the order in which the
910 initializations should be performed. */
911 mem_inits
= sort_mem_initializers (current_class_type
, mem_inits
);
913 in_base_initializer
= 1;
915 /* Initialize base classes. */
917 && TREE_CODE (TREE_PURPOSE (mem_inits
)) != FIELD_DECL
)
919 tree subobject
= TREE_PURPOSE (mem_inits
);
920 tree arguments
= TREE_VALUE (mem_inits
);
922 if (arguments
== NULL_TREE
)
924 /* If these initializations are taking place in a copy constructor,
925 the base class should probably be explicitly initialized if there
926 is a user-defined constructor in the base class (other than the
927 default constructor, which will be called anyway). */
929 && DECL_COPY_CONSTRUCTOR_P (current_function_decl
)
930 && type_has_user_nondefault_constructor (BINFO_TYPE (subobject
)))
931 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
932 OPT_Wextra
, "base class %q#T should be explicitly "
933 "initialized in the copy constructor",
934 BINFO_TYPE (subobject
));
936 if (DECL_DECLARED_CONSTEXPR_P (current_function_decl
)
937 && !(type_has_constexpr_default_constructor
938 (BINFO_TYPE (subobject
))))
940 if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
941 error ("uninitialized base %qT in %<constexpr%> constructor",
942 BINFO_TYPE (subobject
));
943 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
947 /* Initialize the base. */
948 if (BINFO_VIRTUAL_P (subobject
))
949 construct_virtual_base (subobject
, arguments
);
954 base_addr
= build_base_path (PLUS_EXPR
, current_class_ptr
,
956 expand_aggr_init_1 (subobject
, NULL_TREE
,
957 cp_build_indirect_ref (base_addr
, RO_NULL
,
958 tf_warning_or_error
),
961 tf_warning_or_error
);
962 expand_cleanup_for_base (subobject
, NULL_TREE
);
965 mem_inits
= TREE_CHAIN (mem_inits
);
967 in_base_initializer
= 0;
969 /* Initialize the vptrs. */
970 initialize_vtbl_ptrs (current_class_ptr
);
972 /* Initialize the data members. */
975 perform_member_init (TREE_PURPOSE (mem_inits
),
976 TREE_VALUE (mem_inits
));
977 mem_inits
= TREE_CHAIN (mem_inits
);
981 /* Returns the address of the vtable (i.e., the value that should be
982 assigned to the vptr) for BINFO. */
985 build_vtbl_address (tree binfo
)
987 tree binfo_for
= binfo
;
990 if (BINFO_VPTR_INDEX (binfo
) && BINFO_VIRTUAL_P (binfo
))
991 /* If this is a virtual primary base, then the vtable we want to store
992 is that for the base this is being used as the primary base of. We
993 can't simply skip the initialization, because we may be expanding the
994 inits of a subobject constructor where the virtual base layout
996 while (BINFO_PRIMARY_P (binfo_for
))
997 binfo_for
= BINFO_INHERITANCE_CHAIN (binfo_for
);
999 /* Figure out what vtable BINFO's vtable is based on, and mark it as
1001 vtbl
= get_vtbl_decl_for_binfo (binfo_for
);
1002 TREE_USED (vtbl
) = 1;
1004 /* Now compute the address to use when initializing the vptr. */
1005 vtbl
= unshare_expr (BINFO_VTABLE (binfo_for
));
1006 if (TREE_CODE (vtbl
) == VAR_DECL
)
1007 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
1012 /* This code sets up the virtual function tables appropriate for
1013 the pointer DECL. It is a one-ply initialization.
1015 BINFO is the exact type that DECL is supposed to be. In
1016 multiple inheritance, this might mean "C's A" if C : A, B. */
1019 expand_virtual_init (tree binfo
, tree decl
)
1021 tree vtbl
, vtbl_ptr
;
1024 /* Compute the initializer for vptr. */
1025 vtbl
= build_vtbl_address (binfo
);
1027 /* We may get this vptr from a VTT, if this is a subobject
1028 constructor or subobject destructor. */
1029 vtt_index
= BINFO_VPTR_INDEX (binfo
);
1035 /* Compute the value to use, when there's a VTT. */
1036 vtt_parm
= current_vtt_parm
;
1037 vtbl2
= build2 (POINTER_PLUS_EXPR
,
1038 TREE_TYPE (vtt_parm
),
1041 vtbl2
= cp_build_indirect_ref (vtbl2
, RO_NULL
, tf_warning_or_error
);
1042 vtbl2
= convert (TREE_TYPE (vtbl
), vtbl2
);
1044 /* The actual initializer is the VTT value only in the subobject
1045 constructor. In maybe_clone_body we'll substitute NULL for
1046 the vtt_parm in the case of the non-subobject constructor. */
1047 vtbl
= build3 (COND_EXPR
,
1049 build2 (EQ_EXPR
, boolean_type_node
,
1050 current_in_charge_parm
, integer_zero_node
),
1055 /* Compute the location of the vtpr. */
1056 vtbl_ptr
= build_vfield_ref (cp_build_indirect_ref (decl
, RO_NULL
,
1057 tf_warning_or_error
),
1059 gcc_assert (vtbl_ptr
!= error_mark_node
);
1061 /* Assign the vtable to the vptr. */
1062 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0);
1063 finish_expr_stmt (cp_build_modify_expr (vtbl_ptr
, NOP_EXPR
, vtbl
,
1064 tf_warning_or_error
));
1067 /* If an exception is thrown in a constructor, those base classes already
1068 constructed must be destroyed. This function creates the cleanup
1069 for BINFO, which has just been constructed. If FLAG is non-NULL,
1070 it is a DECL which is nonzero when this base needs to be
1074 expand_cleanup_for_base (tree binfo
, tree flag
)
1078 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo
)))
1081 /* Call the destructor. */
1082 expr
= build_special_member_call (current_class_ref
,
1083 base_dtor_identifier
,
1086 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
1087 tf_warning_or_error
);
1089 expr
= fold_build3_loc (input_location
,
1090 COND_EXPR
, void_type_node
,
1091 c_common_truthvalue_conversion (input_location
, flag
),
1092 expr
, integer_zero_node
);
1094 finish_eh_cleanup (expr
);
1097 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
1101 construct_virtual_base (tree vbase
, tree arguments
)
1107 /* If there are virtual base classes with destructors, we need to
1108 emit cleanups to destroy them if an exception is thrown during
1109 the construction process. These exception regions (i.e., the
1110 period during which the cleanups must occur) begin from the time
1111 the construction is complete to the end of the function. If we
1112 create a conditional block in which to initialize the
1113 base-classes, then the cleanup region for the virtual base begins
1114 inside a block, and ends outside of that block. This situation
1115 confuses the sjlj exception-handling code. Therefore, we do not
1116 create a single conditional block, but one for each
1117 initialization. (That way the cleanup regions always begin
1118 in the outer block.) We trust the back end to figure out
1119 that the FLAG will not change across initializations, and
1120 avoid doing multiple tests. */
1121 flag
= DECL_CHAIN (DECL_ARGUMENTS (current_function_decl
));
1122 inner_if_stmt
= begin_if_stmt ();
1123 finish_if_stmt_cond (flag
, inner_if_stmt
);
1125 /* Compute the location of the virtual base. If we're
1126 constructing virtual bases, then we must be the most derived
1127 class. Therefore, we don't have to look up the virtual base;
1128 we already know where it is. */
1129 exp
= convert_to_base_statically (current_class_ref
, vbase
);
1131 expand_aggr_init_1 (vbase
, current_class_ref
, exp
, arguments
,
1132 LOOKUP_COMPLAIN
, tf_warning_or_error
);
1133 finish_then_clause (inner_if_stmt
);
1134 finish_if_stmt (inner_if_stmt
);
1136 expand_cleanup_for_base (vbase
, flag
);
1139 /* Find the context in which this FIELD can be initialized. */
1142 initializing_context (tree field
)
1144 tree t
= DECL_CONTEXT (field
);
1146 /* Anonymous union members can be initialized in the first enclosing
1147 non-anonymous union context. */
1148 while (t
&& ANON_AGGR_TYPE_P (t
))
1149 t
= TYPE_CONTEXT (t
);
1153 /* Function to give error message if member initialization specification
1154 is erroneous. FIELD is the member we decided to initialize.
1155 TYPE is the type for which the initialization is being performed.
1156 FIELD must be a member of TYPE.
1158 MEMBER_NAME is the name of the member. */
1161 member_init_ok_or_else (tree field
, tree type
, tree member_name
)
1163 if (field
== error_mark_node
)
1167 error ("class %qT does not have any field named %qD", type
,
1171 if (TREE_CODE (field
) == VAR_DECL
)
1173 error ("%q#D is a static data member; it can only be "
1174 "initialized at its definition",
1178 if (TREE_CODE (field
) != FIELD_DECL
)
1180 error ("%q#D is not a non-static data member of %qT",
1184 if (initializing_context (field
) != type
)
1186 error ("class %qT does not have any field named %qD", type
,
1194 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1195 is a _TYPE node or TYPE_DECL which names a base for that type.
1196 Check the validity of NAME, and return either the base _TYPE, base
1197 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
1198 NULL_TREE and issue a diagnostic.
1200 An old style unnamed direct single base construction is permitted,
1201 where NAME is NULL. */
1204 expand_member_init (tree name
)
1209 if (!current_class_ref
)
1214 /* This is an obsolete unnamed base class initializer. The
1215 parser will already have warned about its use. */
1216 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type
)))
1219 error ("unnamed initializer for %qT, which has no base classes",
1220 current_class_type
);
1223 basetype
= BINFO_TYPE
1224 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type
), 0));
1227 error ("unnamed initializer for %qT, which uses multiple inheritance",
1228 current_class_type
);
1232 else if (TYPE_P (name
))
1234 basetype
= TYPE_MAIN_VARIANT (name
);
1235 name
= TYPE_NAME (name
);
1237 else if (TREE_CODE (name
) == TYPE_DECL
)
1238 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (name
));
1240 basetype
= NULL_TREE
;
1249 if (current_template_parms
)
1252 class_binfo
= TYPE_BINFO (current_class_type
);
1253 direct_binfo
= NULL_TREE
;
1254 virtual_binfo
= NULL_TREE
;
1256 /* Look for a direct base. */
1257 for (i
= 0; BINFO_BASE_ITERATE (class_binfo
, i
, direct_binfo
); ++i
)
1258 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo
), basetype
))
1261 /* Look for a virtual base -- unless the direct base is itself
1263 if (!direct_binfo
|| !BINFO_VIRTUAL_P (direct_binfo
))
1264 virtual_binfo
= binfo_for_vbase (basetype
, current_class_type
);
1266 /* [class.base.init]
1268 If a mem-initializer-id is ambiguous because it designates
1269 both a direct non-virtual base class and an inherited virtual
1270 base class, the mem-initializer is ill-formed. */
1271 if (direct_binfo
&& virtual_binfo
)
1273 error ("%qD is both a direct base and an indirect virtual base",
1278 if (!direct_binfo
&& !virtual_binfo
)
1280 if (CLASSTYPE_VBASECLASSES (current_class_type
))
1281 error ("type %qT is not a direct or virtual base of %qT",
1282 basetype
, current_class_type
);
1284 error ("type %qT is not a direct base of %qT",
1285 basetype
, current_class_type
);
1289 return direct_binfo
? direct_binfo
: virtual_binfo
;
1293 if (TREE_CODE (name
) == IDENTIFIER_NODE
)
1294 field
= lookup_field (current_class_type
, name
, 1, false);
1298 if (member_init_ok_or_else (field
, current_class_type
, name
))
1305 /* This is like `expand_member_init', only it stores one aggregate
1308 INIT comes in two flavors: it is either a value which
1309 is to be stored in EXP, or it is a parameter list
1310 to go to a constructor, which will operate on EXP.
1311 If INIT is not a parameter list for a constructor, then set
1312 LOOKUP_ONLYCONVERTING.
1313 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1314 the initializer, if FLAGS is 0, then it is the (init) form.
1315 If `init' is a CONSTRUCTOR, then we emit a warning message,
1316 explaining that such initializations are invalid.
1318 If INIT resolves to a CALL_EXPR which happens to return
1319 something of the type we are looking for, then we know
1320 that we can safely use that call to perform the
1323 The virtual function table pointer cannot be set up here, because
1324 we do not really know its type.
1326 This never calls operator=().
1328 When initializing, nothing is CONST.
1330 A default copy constructor may have to be used to perform the
1333 A constructor or a conversion operator may have to be used to
1334 perform the initialization, but not both, as it would be ambiguous. */
1337 build_aggr_init (tree exp
, tree init
, int flags
, tsubst_flags_t complain
)
1342 tree type
= TREE_TYPE (exp
);
1343 int was_const
= TREE_READONLY (exp
);
1344 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1347 if (init
== error_mark_node
)
1348 return error_mark_node
;
1350 TREE_READONLY (exp
) = 0;
1351 TREE_THIS_VOLATILE (exp
) = 0;
1353 if (init
&& TREE_CODE (init
) != TREE_LIST
1354 && !(BRACE_ENCLOSED_INITIALIZER_P (init
)
1355 && CONSTRUCTOR_IS_DIRECT_INIT (init
)))
1356 flags
|= LOOKUP_ONLYCONVERTING
;
1358 if (TREE_CODE (type
) == ARRAY_TYPE
)
1362 /* An array may not be initialized use the parenthesized
1363 initialization form -- unless the initializer is "()". */
1364 if (init
&& TREE_CODE (init
) == TREE_LIST
)
1366 if (complain
& tf_error
)
1367 error ("bad array initializer");
1368 return error_mark_node
;
1370 /* Must arrange to initialize each element of EXP
1371 from elements of INIT. */
1372 itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1373 if (cv_qualified_p (type
))
1374 TREE_TYPE (exp
) = cv_unqualified (type
);
1375 if (itype
&& cv_qualified_p (itype
))
1376 TREE_TYPE (init
) = cv_unqualified (itype
);
1377 stmt_expr
= build_vec_init (exp
, NULL_TREE
, init
,
1378 /*explicit_value_init_p=*/false,
1379 itype
&& same_type_p (TREE_TYPE (init
),
1382 TREE_READONLY (exp
) = was_const
;
1383 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1384 TREE_TYPE (exp
) = type
;
1386 TREE_TYPE (init
) = itype
;
1390 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1391 /* Just know that we've seen something for this node. */
1392 TREE_USED (exp
) = 1;
1394 is_global
= begin_init_stmts (&stmt_expr
, &compound_stmt
);
1395 destroy_temps
= stmts_are_full_exprs_p ();
1396 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
1397 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1398 init
, LOOKUP_NORMAL
|flags
, complain
);
1399 stmt_expr
= finish_init_stmts (is_global
, stmt_expr
, compound_stmt
);
1400 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
1401 TREE_READONLY (exp
) = was_const
;
1402 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1408 expand_default_init (tree binfo
, tree true_exp
, tree exp
, tree init
, int flags
,
1409 tsubst_flags_t complain
)
1411 tree type
= TREE_TYPE (exp
);
1414 /* It fails because there may not be a constructor which takes
1415 its own type as the first (or only parameter), but which does
1416 take other types via a conversion. So, if the thing initializing
1417 the expression is a unit element of type X, first try X(X&),
1418 followed by initialization by X. If neither of these work
1419 out, then look hard. */
1421 VEC(tree
,gc
) *parms
;
1423 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
1424 && CP_AGGREGATE_TYPE_P (type
))
1426 /* A brace-enclosed initializer for an aggregate. In C++0x this can
1427 happen for direct-initialization, too. */
1428 init
= digest_init (type
, init
);
1429 init
= build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1430 TREE_SIDE_EFFECTS (init
) = 1;
1431 finish_expr_stmt (init
);
1435 if (init
&& TREE_CODE (init
) != TREE_LIST
1436 && (flags
& LOOKUP_ONLYCONVERTING
))
1438 /* Base subobjects should only get direct-initialization. */
1439 gcc_assert (true_exp
== exp
);
1441 if (flags
& DIRECT_BIND
)
1442 /* Do nothing. We hit this in two cases: Reference initialization,
1443 where we aren't initializing a real variable, so we don't want
1444 to run a new constructor; and catching an exception, where we
1445 have already built up the constructor call so we could wrap it
1446 in an exception region. */;
1448 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
1450 if (TREE_CODE (init
) == MUST_NOT_THROW_EXPR
)
1451 /* We need to protect the initialization of a catch parm with a
1452 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1453 around the TARGET_EXPR for the copy constructor. See
1454 initialize_handler_parm. */
1456 TREE_OPERAND (init
, 0) = build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
,
1457 TREE_OPERAND (init
, 0));
1458 TREE_TYPE (init
) = void_type_node
;
1461 init
= build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1462 TREE_SIDE_EFFECTS (init
) = 1;
1463 finish_expr_stmt (init
);
1467 if (init
== NULL_TREE
)
1469 else if (TREE_CODE (init
) == TREE_LIST
&& !TREE_TYPE (init
))
1471 parms
= make_tree_vector ();
1472 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
1473 VEC_safe_push (tree
, gc
, parms
, TREE_VALUE (init
));
1476 parms
= make_tree_vector_single (init
);
1478 if (true_exp
== exp
)
1479 ctor_name
= complete_ctor_identifier
;
1481 ctor_name
= base_ctor_identifier
;
1483 rval
= build_special_member_call (exp
, ctor_name
, &parms
, binfo
, flags
,
1487 release_tree_vector (parms
);
1489 if (exp
== true_exp
&& TREE_CODE (rval
) == CALL_EXPR
)
1491 tree fn
= get_callee_fndecl (rval
);
1492 if (fn
&& DECL_DECLARED_CONSTEXPR_P (fn
))
1494 tree e
= maybe_constant_value (rval
);
1495 if (TREE_CONSTANT (e
))
1496 rval
= build2 (INIT_EXPR
, type
, exp
, e
);
1500 /* FIXME put back convert_to_void? */
1501 if (TREE_SIDE_EFFECTS (rval
))
1502 finish_expr_stmt (rval
);
1505 /* This function is responsible for initializing EXP with INIT
1508 BINFO is the binfo of the type for who we are performing the
1509 initialization. For example, if W is a virtual base class of A and B,
1511 If we are initializing B, then W must contain B's W vtable, whereas
1512 were we initializing C, W must contain C's W vtable.
1514 TRUE_EXP is nonzero if it is the true expression being initialized.
1515 In this case, it may be EXP, or may just contain EXP. The reason we
1516 need this is because if EXP is a base element of TRUE_EXP, we
1517 don't necessarily know by looking at EXP where its virtual
1518 baseclass fields should really be pointing. But we do know
1519 from TRUE_EXP. In constructors, we don't know anything about
1520 the value being initialized.
1522 FLAGS is just passed to `build_new_method_call'. See that function
1523 for its description. */
1526 expand_aggr_init_1 (tree binfo
, tree true_exp
, tree exp
, tree init
, int flags
,
1527 tsubst_flags_t complain
)
1529 tree type
= TREE_TYPE (exp
);
1531 gcc_assert (init
!= error_mark_node
&& type
!= error_mark_node
);
1532 gcc_assert (building_stmt_tree ());
1534 /* Use a function returning the desired type to initialize EXP for us.
1535 If the function is a constructor, and its first argument is
1536 NULL_TREE, know that it was meant for us--just slide exp on
1537 in and expand the constructor. Constructors now come
1540 if (init
&& TREE_CODE (exp
) == VAR_DECL
1541 && COMPOUND_LITERAL_P (init
))
1543 /* If store_init_value returns NULL_TREE, the INIT has been
1544 recorded as the DECL_INITIAL for EXP. That means there's
1545 nothing more we have to do. */
1546 init
= store_init_value (exp
, init
, flags
);
1548 finish_expr_stmt (init
);
1552 /* If an explicit -- but empty -- initializer list was present,
1553 that's value-initialization. */
1554 if (init
== void_type_node
)
1556 /* If there's a user-provided constructor, we just call that. */
1557 if (type_has_user_provided_constructor (type
))
1558 /* Fall through. */;
1559 /* If there isn't, but we still need to call the constructor,
1560 zero out the object first. */
1561 else if (TYPE_NEEDS_CONSTRUCTING (type
))
1563 init
= build_zero_init (type
, NULL_TREE
, /*static_storage_p=*/false);
1564 init
= build2 (INIT_EXPR
, type
, exp
, init
);
1565 finish_expr_stmt (init
);
1566 /* And then call the constructor. */
1568 /* If we don't need to mess with the constructor at all,
1569 then just zero out the object and we're done. */
1572 init
= build2 (INIT_EXPR
, type
, exp
,
1573 build_value_init_noctor (type
, complain
));
1574 finish_expr_stmt (init
);
1580 /* We know that expand_default_init can handle everything we want
1582 expand_default_init (binfo
, true_exp
, exp
, init
, flags
, complain
);
1585 /* Report an error if TYPE is not a user-defined, class type. If
1586 OR_ELSE is nonzero, give an error message. */
1589 is_class_type (tree type
, int or_else
)
1591 if (type
== error_mark_node
)
1594 if (! CLASS_TYPE_P (type
))
1597 error ("%qT is not a class type", type
);
1604 get_type_value (tree name
)
1606 if (name
== error_mark_node
)
1609 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1610 return IDENTIFIER_TYPE_VALUE (name
);
1615 /* Build a reference to a member of an aggregate. This is not a C++
1616 `&', but really something which can have its address taken, and
1617 then act as a pointer to member, for example TYPE :: FIELD can have
1618 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
1619 this expression is the operand of "&".
1621 @@ Prints out lousy diagnostics for operator <typename>
1624 @@ This function should be rewritten and placed in search.c. */
1627 build_offset_ref (tree type
, tree member
, bool address_p
)
1630 tree basebinfo
= NULL_TREE
;
1632 /* class templates can come in as TEMPLATE_DECLs here. */
1633 if (TREE_CODE (member
) == TEMPLATE_DECL
)
1636 if (dependent_scope_p (type
) || type_dependent_expression_p (member
))
1637 return build_qualified_name (NULL_TREE
, type
, member
,
1638 /*template_p=*/false);
1640 gcc_assert (TYPE_P (type
));
1641 if (! is_class_type (type
, 1))
1642 return error_mark_node
;
1644 gcc_assert (DECL_P (member
) || BASELINK_P (member
));
1645 /* Callers should call mark_used before this point. */
1646 gcc_assert (!DECL_P (member
) || TREE_USED (member
));
1648 type
= TYPE_MAIN_VARIANT (type
);
1649 if (!COMPLETE_OR_OPEN_TYPE_P (complete_type (type
)))
1651 error ("incomplete type %qT does not have member %qD", type
, member
);
1652 return error_mark_node
;
1655 /* Entities other than non-static members need no further
1657 if (TREE_CODE (member
) == TYPE_DECL
)
1659 if (TREE_CODE (member
) == VAR_DECL
|| TREE_CODE (member
) == CONST_DECL
)
1660 return convert_from_reference (member
);
1662 if (TREE_CODE (member
) == FIELD_DECL
&& DECL_C_BIT_FIELD (member
))
1664 error ("invalid pointer to bit-field %qD", member
);
1665 return error_mark_node
;
1668 /* Set up BASEBINFO for member lookup. */
1669 decl
= maybe_dummy_object (type
, &basebinfo
);
1671 /* A lot of this logic is now handled in lookup_member. */
1672 if (BASELINK_P (member
))
1674 /* Go from the TREE_BASELINK to the member function info. */
1675 tree t
= BASELINK_FUNCTIONS (member
);
1677 if (TREE_CODE (t
) != TEMPLATE_ID_EXPR
&& !really_overloaded_fn (t
))
1679 /* Get rid of a potential OVERLOAD around it. */
1680 t
= OVL_CURRENT (t
);
1682 /* Unique functions are handled easily. */
1684 /* For non-static member of base class, we need a special rule
1685 for access checking [class.protected]:
1687 If the access is to form a pointer to member, the
1688 nested-name-specifier shall name the derived class
1689 (or any class derived from that class). */
1690 if (address_p
&& DECL_P (t
)
1691 && DECL_NONSTATIC_MEMBER_P (t
))
1692 perform_or_defer_access_check (TYPE_BINFO (type
), t
, t
);
1694 perform_or_defer_access_check (basebinfo
, t
, t
);
1696 if (DECL_STATIC_FUNCTION_P (t
))
1701 TREE_TYPE (member
) = unknown_type_node
;
1703 else if (address_p
&& TREE_CODE (member
) == FIELD_DECL
)
1704 /* We need additional test besides the one in
1705 check_accessibility_of_qualified_id in case it is
1706 a pointer to non-static member. */
1707 perform_or_defer_access_check (TYPE_BINFO (type
), member
, member
);
1711 /* If MEMBER is non-static, then the program has fallen afoul of
1714 An id-expression that denotes a nonstatic data member or
1715 nonstatic member function of a class can only be used:
1717 -- as part of a class member access (_expr.ref_) in which the
1718 object-expression refers to the member's class or a class
1719 derived from that class, or
1721 -- to form a pointer to member (_expr.unary.op_), or
1723 -- in the body of a nonstatic member function of that class or
1724 of a class derived from that class (_class.mfct.nonstatic_), or
1726 -- in a mem-initializer for a constructor for that class or for
1727 a class derived from that class (_class.base.init_). */
1728 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member
))
1730 /* Build a representation of the qualified name suitable
1731 for use as the operand to "&" -- even though the "&" is
1732 not actually present. */
1733 member
= build2 (OFFSET_REF
, TREE_TYPE (member
), decl
, member
);
1734 /* In Microsoft mode, treat a non-static member function as if
1735 it were a pointer-to-member. */
1736 if (flag_ms_extensions
)
1738 PTRMEM_OK_P (member
) = 1;
1739 return cp_build_addr_expr (member
, tf_warning_or_error
);
1741 error ("invalid use of non-static member function %qD",
1742 TREE_OPERAND (member
, 1));
1743 return error_mark_node
;
1745 else if (TREE_CODE (member
) == FIELD_DECL
)
1747 error ("invalid use of non-static data member %qD", member
);
1748 return error_mark_node
;
1753 member
= build2 (OFFSET_REF
, TREE_TYPE (member
), decl
, member
);
1754 PTRMEM_OK_P (member
) = 1;
1758 /* If DECL is a scalar enumeration constant or variable with a
1759 constant initializer, return the initializer (or, its initializers,
1760 recursively); otherwise, return DECL. If INTEGRAL_P, the
1761 initializer is only returned if DECL is an integral
1762 constant-expression. */
1765 constant_value_1 (tree decl
, bool integral_p
)
1767 while (TREE_CODE (decl
) == CONST_DECL
1769 ? decl_constant_var_p (decl
)
1770 : (TREE_CODE (decl
) == VAR_DECL
1771 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl
)))))
1774 /* If DECL is a static data member in a template
1775 specialization, we must instantiate it here. The
1776 initializer for the static data member is not processed
1777 until needed; we need it now. */
1779 mark_rvalue_use (decl
);
1780 init
= DECL_INITIAL (decl
);
1781 if (init
== error_mark_node
)
1783 if (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
))
1784 /* Treat the error as a constant to avoid cascading errors on
1785 excessively recursive template instantiation (c++/9335). */
1790 /* Initializers in templates are generally expanded during
1791 instantiation, so before that for const int i(2)
1792 INIT is a TREE_LIST with the actual initializer as
1794 if (processing_template_decl
1796 && TREE_CODE (init
) == TREE_LIST
1797 && TREE_CHAIN (init
) == NULL_TREE
)
1798 init
= TREE_VALUE (init
);
1800 || !TREE_TYPE (init
)
1801 || !TREE_CONSTANT (init
)
1803 /* Do not return an aggregate constant (of which
1804 string literals are a special case), as we do not
1805 want to make inadvertent copies of such entities,
1806 and we must be sure that their addresses are the
1808 && (TREE_CODE (init
) == CONSTRUCTOR
1809 || TREE_CODE (init
) == STRING_CST
)))
1811 decl
= unshare_expr (init
);
1816 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1817 constant of integral or enumeration type, then return that value.
1818 These are those variables permitted in constant expressions by
1822 integral_constant_value (tree decl
)
1824 return constant_value_1 (decl
, /*integral_p=*/true);
1827 /* A more relaxed version of integral_constant_value, used by the
1828 common C/C++ code and by the C++ front end for optimization
1832 decl_constant_value (tree decl
)
1834 return constant_value_1 (decl
,
1835 /*integral_p=*/processing_template_decl
);
1838 /* Common subroutines of build_new and build_vec_delete. */
1840 /* Call the global __builtin_delete to delete ADDR. */
1843 build_builtin_delete_call (tree addr
)
1845 mark_used (global_delete_fndecl
);
1846 return build_call_n (global_delete_fndecl
, 1, addr
);
1849 /* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
1850 the type of the object being allocated; otherwise, it's just TYPE.
1851 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
1852 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
1853 a vector of arguments to be provided as arguments to a placement
1854 new operator. This routine performs no semantic checks; it just
1855 creates and returns a NEW_EXPR. */
1858 build_raw_new_expr (VEC(tree
,gc
) *placement
, tree type
, tree nelts
,
1859 VEC(tree
,gc
) *init
, int use_global_new
)
1864 /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR.
1865 If INIT is not NULL, then we want to store VOID_ZERO_NODE. This
1866 permits us to distinguish the case of a missing initializer "new
1867 int" from an empty initializer "new int()". */
1869 init_list
= NULL_TREE
;
1870 else if (VEC_empty (tree
, init
))
1871 init_list
= void_zero_node
;
1873 init_list
= build_tree_list_vec (init
);
1875 new_expr
= build4 (NEW_EXPR
, build_pointer_type (type
),
1876 build_tree_list_vec (placement
), type
, nelts
,
1878 NEW_EXPR_USE_GLOBAL (new_expr
) = use_global_new
;
1879 TREE_SIDE_EFFECTS (new_expr
) = 1;
1884 /* Diagnose uninitialized const members or reference members of type
1885 TYPE. USING_NEW is used to disambiguate the diagnostic between a
1886 new expression without a new-initializer and a declaration. Returns
1890 diagnose_uninitialized_cst_or_ref_member_1 (tree type
, tree origin
,
1891 bool using_new
, bool complain
)
1894 int error_count
= 0;
1896 if (type_has_user_provided_constructor (type
))
1899 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1903 if (TREE_CODE (field
) != FIELD_DECL
)
1906 field_type
= strip_array_types (TREE_TYPE (field
));
1908 if (TREE_CODE (field_type
) == REFERENCE_TYPE
)
1914 error ("uninitialized reference member in %q#T "
1915 "using %<new%> without new-initializer", origin
);
1917 error ("uninitialized reference member in %q#T", origin
);
1918 inform (DECL_SOURCE_LOCATION (field
),
1919 "%qD should be initialized", field
);
1923 if (CP_TYPE_CONST_P (field_type
))
1929 error ("uninitialized const member in %q#T "
1930 "using %<new%> without new-initializer", origin
);
1932 error ("uninitialized const member in %q#T", origin
);
1933 inform (DECL_SOURCE_LOCATION (field
),
1934 "%qD should be initialized", field
);
1938 if (CLASS_TYPE_P (field_type
))
1940 += diagnose_uninitialized_cst_or_ref_member_1 (field_type
, origin
,
1941 using_new
, complain
);
1947 diagnose_uninitialized_cst_or_ref_member (tree type
, bool using_new
, bool complain
)
1949 return diagnose_uninitialized_cst_or_ref_member_1 (type
, type
, using_new
, complain
);
1952 /* Generate code for a new-expression, including calling the "operator
1953 new" function, initializing the object, and, if an exception occurs
1954 during construction, cleaning up. The arguments are as for
1955 build_raw_new_expr. This may change PLACEMENT and INIT. */
1958 build_new_1 (VEC(tree
,gc
) **placement
, tree type
, tree nelts
,
1959 VEC(tree
,gc
) **init
, bool globally_qualified_p
,
1960 tsubst_flags_t complain
)
1963 /* True iff this is a call to "operator new[]" instead of just
1965 bool array_p
= false;
1966 /* If ARRAY_P is true, the element type of the array. This is never
1967 an ARRAY_TYPE; for something like "new int[3][4]", the
1968 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
1971 /* The type of the new-expression. (This type is always a pointer
1974 tree non_const_pointer_type
;
1975 tree outer_nelts
= NULL_TREE
;
1976 tree alloc_call
, alloc_expr
;
1977 /* The address returned by the call to "operator new". This node is
1978 a VAR_DECL and is therefore reusable. */
1981 tree cookie_expr
, init_expr
;
1982 int nothrow
, check_new
;
1983 int use_java_new
= 0;
1984 /* If non-NULL, the number of extra bytes to allocate at the
1985 beginning of the storage allocated for an array-new expression in
1986 order to store the number of elements. */
1987 tree cookie_size
= NULL_TREE
;
1988 tree placement_first
;
1989 tree placement_expr
= NULL_TREE
;
1990 /* True if the function we are calling is a placement allocation
1992 bool placement_allocation_fn_p
;
1993 /* True if the storage must be initialized, either by a constructor
1994 or due to an explicit new-initializer. */
1995 bool is_initialized
;
1996 /* The address of the thing allocated, not including any cookie. In
1997 particular, if an array cookie is in use, DATA_ADDR is the
1998 address of the first array element. This node is a VAR_DECL, and
1999 is therefore reusable. */
2001 tree init_preeval_expr
= NULL_TREE
;
2005 outer_nelts
= nelts
;
2008 else if (TREE_CODE (type
) == ARRAY_TYPE
)
2011 nelts
= array_type_nelts_top (type
);
2012 outer_nelts
= nelts
;
2013 type
= TREE_TYPE (type
);
2016 /* If our base type is an array, then make sure we know how many elements
2018 for (elt_type
= type
;
2019 TREE_CODE (elt_type
) == ARRAY_TYPE
;
2020 elt_type
= TREE_TYPE (elt_type
))
2021 nelts
= cp_build_binary_op (input_location
,
2023 array_type_nelts_top (elt_type
),
2026 if (TREE_CODE (elt_type
) == VOID_TYPE
)
2028 if (complain
& tf_error
)
2029 error ("invalid type %<void%> for new");
2030 return error_mark_node
;
2033 if (abstract_virtuals_error (NULL_TREE
, elt_type
))
2034 return error_mark_node
;
2036 is_initialized
= (TYPE_NEEDS_CONSTRUCTING (elt_type
) || *init
!= NULL
);
2040 bool maybe_uninitialized_error
= false;
2041 /* A program that calls for default-initialization [...] of an
2042 entity of reference type is ill-formed. */
2043 if (CLASSTYPE_REF_FIELDS_NEED_INIT (elt_type
))
2044 maybe_uninitialized_error
= true;
2046 /* A new-expression that creates an object of type T initializes
2047 that object as follows:
2048 - If the new-initializer is omitted:
2049 -- If T is a (possibly cv-qualified) non-POD class type
2050 (or array thereof), the object is default-initialized (8.5).
2052 -- Otherwise, the object created has indeterminate
2053 value. If T is a const-qualified type, or a (possibly
2054 cv-qualified) POD class type (or array thereof)
2055 containing (directly or indirectly) a member of
2056 const-qualified type, the program is ill-formed; */
2058 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (elt_type
))
2059 maybe_uninitialized_error
= true;
2061 if (maybe_uninitialized_error
2062 && diagnose_uninitialized_cst_or_ref_member (elt_type
,
2064 complain
& tf_error
))
2065 return error_mark_node
;
2068 if (CP_TYPE_CONST_P (elt_type
) && *init
== NULL
2069 && !type_has_user_provided_default_constructor (elt_type
))
2071 if (complain
& tf_error
)
2072 error ("uninitialized const in %<new%> of %q#T", elt_type
);
2073 return error_mark_node
;
2076 size
= size_in_bytes (elt_type
);
2078 size
= size_binop (MULT_EXPR
, size
, convert (sizetype
, nelts
));
2080 alloc_fn
= NULL_TREE
;
2082 /* If PLACEMENT is a single simple pointer type not passed by
2083 reference, prepare to capture it in a temporary variable. Do
2084 this now, since PLACEMENT will change in the calls below. */
2085 placement_first
= NULL_TREE
;
2086 if (VEC_length (tree
, *placement
) == 1
2087 && (TREE_CODE (TREE_TYPE (VEC_index (tree
, *placement
, 0)))
2089 placement_first
= VEC_index (tree
, *placement
, 0);
2091 /* Allocate the object. */
2092 if (VEC_empty (tree
, *placement
) && TYPE_FOR_JAVA (elt_type
))
2095 tree class_decl
= build_java_class_ref (elt_type
);
2096 static const char alloc_name
[] = "_Jv_AllocObject";
2098 if (class_decl
== error_mark_node
)
2099 return error_mark_node
;
2102 if (!get_global_value_if_present (get_identifier (alloc_name
),
2105 if (complain
& tf_error
)
2106 error ("call to Java constructor with %qs undefined", alloc_name
);
2107 return error_mark_node
;
2109 else if (really_overloaded_fn (alloc_fn
))
2111 if (complain
& tf_error
)
2112 error ("%qD should never be overloaded", alloc_fn
);
2113 return error_mark_node
;
2115 alloc_fn
= OVL_CURRENT (alloc_fn
);
2116 class_addr
= build1 (ADDR_EXPR
, jclass_node
, class_decl
);
2117 alloc_call
= cp_build_function_call_nary (alloc_fn
, complain
,
2118 class_addr
, NULL_TREE
);
2120 else if (TYPE_FOR_JAVA (elt_type
) && MAYBE_CLASS_TYPE_P (elt_type
))
2122 error ("Java class %q#T object allocated using placement new", elt_type
);
2123 return error_mark_node
;
2130 fnname
= ansi_opname (array_p
? VEC_NEW_EXPR
: NEW_EXPR
);
2132 if (!globally_qualified_p
2133 && CLASS_TYPE_P (elt_type
)
2135 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type
)
2136 : TYPE_HAS_NEW_OPERATOR (elt_type
)))
2138 /* Use a class-specific operator new. */
2139 /* If a cookie is required, add some extra space. */
2140 if (array_p
&& TYPE_VEC_NEW_USES_COOKIE (elt_type
))
2142 cookie_size
= targetm
.cxx
.get_cookie_size (elt_type
);
2143 size
= size_binop (PLUS_EXPR
, size
, cookie_size
);
2145 /* Create the argument list. */
2146 VEC_safe_insert (tree
, gc
, *placement
, 0, size
);
2147 /* Do name-lookup to find the appropriate operator. */
2148 fns
= lookup_fnfields (elt_type
, fnname
, /*protect=*/2);
2149 if (fns
== NULL_TREE
)
2151 if (complain
& tf_error
)
2152 error ("no suitable %qD found in class %qT", fnname
, elt_type
);
2153 return error_mark_node
;
2155 if (TREE_CODE (fns
) == TREE_LIST
)
2157 if (complain
& tf_error
)
2159 error ("request for member %qD is ambiguous", fnname
);
2160 print_candidates (fns
);
2162 return error_mark_node
;
2164 alloc_call
= build_new_method_call (build_dummy_object (elt_type
),
2166 /*conversion_path=*/NULL_TREE
,
2173 /* Use a global operator new. */
2174 /* See if a cookie might be required. */
2175 if (array_p
&& TYPE_VEC_NEW_USES_COOKIE (elt_type
))
2176 cookie_size
= targetm
.cxx
.get_cookie_size (elt_type
);
2178 cookie_size
= NULL_TREE
;
2180 alloc_call
= build_operator_new_call (fnname
, placement
,
2181 &size
, &cookie_size
,
2186 if (alloc_call
== error_mark_node
)
2187 return error_mark_node
;
2189 gcc_assert (alloc_fn
!= NULL_TREE
);
2191 /* If we found a simple case of PLACEMENT_EXPR above, then copy it
2192 into a temporary variable. */
2193 if (!processing_template_decl
2194 && placement_first
!= NULL_TREE
2195 && TREE_CODE (alloc_call
) == CALL_EXPR
2196 && call_expr_nargs (alloc_call
) == 2
2197 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 0))) == INTEGER_TYPE
2198 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 1))) == POINTER_TYPE
)
2200 tree placement_arg
= CALL_EXPR_ARG (alloc_call
, 1);
2202 if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg
)))
2203 || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg
))))
2205 placement_expr
= get_target_expr (placement_first
);
2206 CALL_EXPR_ARG (alloc_call
, 1)
2207 = convert (TREE_TYPE (placement_arg
), placement_expr
);
2211 /* In the simple case, we can stop now. */
2212 pointer_type
= build_pointer_type (type
);
2213 if (!cookie_size
&& !is_initialized
)
2214 return build_nop (pointer_type
, alloc_call
);
2216 /* Store the result of the allocation call in a variable so that we can
2217 use it more than once. */
2218 alloc_expr
= get_target_expr (alloc_call
);
2219 alloc_node
= TARGET_EXPR_SLOT (alloc_expr
);
2221 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
2222 while (TREE_CODE (alloc_call
) == COMPOUND_EXPR
)
2223 alloc_call
= TREE_OPERAND (alloc_call
, 1);
2225 /* Now, check to see if this function is actually a placement
2226 allocation function. This can happen even when PLACEMENT is NULL
2227 because we might have something like:
2229 struct S { void* operator new (size_t, int i = 0); };
2231 A call to `new S' will get this allocation function, even though
2232 there is no explicit placement argument. If there is more than
2233 one argument, or there are variable arguments, then this is a
2234 placement allocation function. */
2235 placement_allocation_fn_p
2236 = (type_num_arguments (TREE_TYPE (alloc_fn
)) > 1
2237 || varargs_function_p (alloc_fn
));
2239 /* Preevaluate the placement args so that we don't reevaluate them for a
2240 placement delete. */
2241 if (placement_allocation_fn_p
)
2244 stabilize_call (alloc_call
, &inits
);
2246 alloc_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (alloc_expr
), inits
,
2250 /* unless an allocation function is declared with an empty excep-
2251 tion-specification (_except.spec_), throw(), it indicates failure to
2252 allocate storage by throwing a bad_alloc exception (clause _except_,
2253 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2254 cation function is declared with an empty exception-specification,
2255 throw(), it returns null to indicate failure to allocate storage and a
2256 non-null pointer otherwise.
2258 So check for a null exception spec on the op new we just called. */
2260 nothrow
= TYPE_NOTHROW_P (TREE_TYPE (alloc_fn
));
2261 check_new
= (flag_check_new
|| nothrow
) && ! use_java_new
;
2269 /* Adjust so we're pointing to the start of the object. */
2270 data_addr
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (alloc_node
),
2271 alloc_node
, cookie_size
);
2273 /* Store the number of bytes allocated so that we can know how
2274 many elements to destroy later. We use the last sizeof
2275 (size_t) bytes to store the number of elements. */
2276 cookie_ptr
= size_binop (MINUS_EXPR
, cookie_size
, size_in_bytes (sizetype
));
2277 cookie_ptr
= fold_build2_loc (input_location
,
2278 POINTER_PLUS_EXPR
, TREE_TYPE (alloc_node
),
2279 alloc_node
, cookie_ptr
);
2280 size_ptr_type
= build_pointer_type (sizetype
);
2281 cookie_ptr
= fold_convert (size_ptr_type
, cookie_ptr
);
2282 cookie
= cp_build_indirect_ref (cookie_ptr
, RO_NULL
, complain
);
2284 cookie_expr
= build2 (MODIFY_EXPR
, sizetype
, cookie
, nelts
);
2286 if (targetm
.cxx
.cookie_has_size ())
2288 /* Also store the element size. */
2289 cookie_ptr
= build2 (POINTER_PLUS_EXPR
, size_ptr_type
, cookie_ptr
,
2290 fold_build1_loc (input_location
,
2291 NEGATE_EXPR
, sizetype
,
2292 size_in_bytes (sizetype
)));
2294 cookie
= cp_build_indirect_ref (cookie_ptr
, RO_NULL
, complain
);
2295 cookie
= build2 (MODIFY_EXPR
, sizetype
, cookie
,
2296 size_in_bytes (elt_type
));
2297 cookie_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (cookie_expr
),
2298 cookie
, cookie_expr
);
2303 cookie_expr
= NULL_TREE
;
2304 data_addr
= alloc_node
;
2307 /* Now use a pointer to the type we've actually allocated. */
2309 /* But we want to operate on a non-const version to start with,
2310 since we'll be modifying the elements. */
2311 non_const_pointer_type
= build_pointer_type
2312 (cp_build_qualified_type (type
, cp_type_quals (type
) & ~TYPE_QUAL_CONST
));
2314 data_addr
= fold_convert (non_const_pointer_type
, data_addr
);
2315 /* Any further uses of alloc_node will want this type, too. */
2316 alloc_node
= fold_convert (non_const_pointer_type
, alloc_node
);
2318 /* Now initialize the allocated object. Note that we preevaluate the
2319 initialization expression, apart from the actual constructor call or
2320 assignment--we do this because we want to delay the allocation as long
2321 as possible in order to minimize the size of the exception region for
2322 placement delete. */
2326 bool explicit_value_init_p
= false;
2328 if (*init
!= NULL
&& VEC_empty (tree
, *init
))
2331 explicit_value_init_p
= true;
2334 if (processing_template_decl
&& explicit_value_init_p
)
2336 /* build_value_init doesn't work in templates, and we don't need
2337 the initializer anyway since we're going to throw it away and
2338 rebuild it at instantiation time, so just build up a single
2339 constructor call to get any appropriate diagnostics. */
2340 init_expr
= cp_build_indirect_ref (data_addr
, RO_NULL
, complain
);
2341 if (TYPE_NEEDS_CONSTRUCTING (elt_type
))
2342 init_expr
= build_special_member_call (init_expr
,
2343 complete_ctor_identifier
,
2347 stable
= stabilize_init (init_expr
, &init_preeval_expr
);
2351 tree vecinit
= NULL_TREE
;
2352 if (*init
&& VEC_length (tree
, *init
) == 1
2353 && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree
, *init
, 0))
2354 && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree
, *init
, 0)))
2356 tree arraytype
, domain
;
2357 vecinit
= VEC_index (tree
, *init
, 0);
2358 if (TREE_CONSTANT (nelts
))
2359 domain
= compute_array_index_type (NULL_TREE
, nelts
, complain
);
2363 if (CONSTRUCTOR_NELTS (vecinit
) > 0)
2364 warning (0, "non-constant array size in new, unable to "
2365 "verify length of initializer-list");
2367 arraytype
= build_cplus_array_type (type
, domain
);
2368 vecinit
= digest_init (arraytype
, vecinit
);
2372 if (complain
& tf_error
)
2373 permerror (input_location
, "ISO C++ forbids initialization in array new");
2375 return error_mark_node
;
2376 vecinit
= build_tree_list_vec (*init
);
2379 = build_vec_init (data_addr
,
2380 cp_build_binary_op (input_location
,
2381 MINUS_EXPR
, outer_nelts
,
2385 explicit_value_init_p
,
2389 /* An array initialization is stable because the initialization
2390 of each element is a full-expression, so the temporaries don't
2396 init_expr
= cp_build_indirect_ref (data_addr
, RO_NULL
, complain
);
2398 if (TYPE_NEEDS_CONSTRUCTING (type
) && !explicit_value_init_p
)
2400 init_expr
= build_special_member_call (init_expr
,
2401 complete_ctor_identifier
,
2406 else if (explicit_value_init_p
)
2408 /* Something like `new int()'. */
2409 tree val
= build_value_init (type
, complain
);
2410 if (val
== error_mark_node
)
2411 return error_mark_node
;
2412 init_expr
= build2 (INIT_EXPR
, type
, init_expr
, val
);
2418 /* We are processing something like `new int (10)', which
2419 means allocate an int, and initialize it with 10. */
2421 ie
= build_x_compound_expr_from_vec (*init
, "new initializer");
2422 init_expr
= cp_build_modify_expr (init_expr
, INIT_EXPR
, ie
,
2425 stable
= stabilize_init (init_expr
, &init_preeval_expr
);
2428 if (init_expr
== error_mark_node
)
2429 return error_mark_node
;
2431 /* If any part of the object initialization terminates by throwing an
2432 exception and a suitable deallocation function can be found, the
2433 deallocation function is called to free the memory in which the
2434 object was being constructed, after which the exception continues
2435 to propagate in the context of the new-expression. If no
2436 unambiguous matching deallocation function can be found,
2437 propagating the exception does not cause the object's memory to be
2439 if (flag_exceptions
&& ! use_java_new
)
2441 enum tree_code dcode
= array_p
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2444 /* The Standard is unclear here, but the right thing to do
2445 is to use the same method for finding deallocation
2446 functions that we use for finding allocation functions. */
2447 cleanup
= (build_op_delete_call
2451 globally_qualified_p
,
2452 placement_allocation_fn_p
? alloc_call
: NULL_TREE
,
2458 /* This is much simpler if we were able to preevaluate all of
2459 the arguments to the constructor call. */
2461 /* CLEANUP is compiler-generated, so no diagnostics. */
2462 TREE_NO_WARNING (cleanup
) = true;
2463 init_expr
= build2 (TRY_CATCH_EXPR
, void_type_node
,
2464 init_expr
, cleanup
);
2465 /* Likewise, this try-catch is compiler-generated. */
2466 TREE_NO_WARNING (init_expr
) = true;
2469 /* Ack! First we allocate the memory. Then we set our sentry
2470 variable to true, and expand a cleanup that deletes the
2471 memory if sentry is true. Then we run the constructor, and
2472 finally clear the sentry.
2474 We need to do this because we allocate the space first, so
2475 if there are any temporaries with cleanups in the
2476 constructor args and we weren't able to preevaluate them, we
2477 need this EH region to extend until end of full-expression
2478 to preserve nesting. */
2480 tree end
, sentry
, begin
;
2482 begin
= get_target_expr (boolean_true_node
);
2483 CLEANUP_EH_ONLY (begin
) = 1;
2485 sentry
= TARGET_EXPR_SLOT (begin
);
2487 /* CLEANUP is compiler-generated, so no diagnostics. */
2488 TREE_NO_WARNING (cleanup
) = true;
2490 TARGET_EXPR_CLEANUP (begin
)
2491 = build3 (COND_EXPR
, void_type_node
, sentry
,
2492 cleanup
, void_zero_node
);
2494 end
= build2 (MODIFY_EXPR
, TREE_TYPE (sentry
),
2495 sentry
, boolean_false_node
);
2498 = build2 (COMPOUND_EXPR
, void_type_node
, begin
,
2499 build2 (COMPOUND_EXPR
, void_type_node
, init_expr
,
2501 /* Likewise, this is compiler-generated. */
2502 TREE_NO_WARNING (init_expr
) = true;
2507 init_expr
= NULL_TREE
;
2509 /* Now build up the return value in reverse order. */
2514 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), init_expr
, rval
);
2516 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), cookie_expr
, rval
);
2518 if (rval
== data_addr
)
2519 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2520 and return the call (which doesn't need to be adjusted). */
2521 rval
= TARGET_EXPR_INITIAL (alloc_expr
);
2526 tree ifexp
= cp_build_binary_op (input_location
,
2527 NE_EXPR
, alloc_node
,
2530 rval
= build_conditional_expr (ifexp
, rval
, alloc_node
,
2534 /* Perform the allocation before anything else, so that ALLOC_NODE
2535 has been initialized before we start using it. */
2536 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
2539 if (init_preeval_expr
)
2540 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), init_preeval_expr
, rval
);
2542 /* A new-expression is never an lvalue. */
2543 gcc_assert (!lvalue_p (rval
));
2545 return convert (pointer_type
, rval
);
2548 /* Generate a representation for a C++ "new" expression. *PLACEMENT
2549 is a vector of placement-new arguments (or NULL if none). If NELTS
2550 is NULL, TYPE is the type of the storage to be allocated. If NELTS
2551 is not NULL, then this is an array-new allocation; TYPE is the type
2552 of the elements in the array and NELTS is the number of elements in
2553 the array. *INIT, if non-NULL, is the initializer for the new
2554 object, or an empty vector to indicate an initializer of "()". If
2555 USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
2556 rather than just "new". This may change PLACEMENT and INIT. */
2559 build_new (VEC(tree
,gc
) **placement
, tree type
, tree nelts
,
2560 VEC(tree
,gc
) **init
, int use_global_new
, tsubst_flags_t complain
)
2563 VEC(tree
,gc
) *orig_placement
= NULL
;
2564 tree orig_nelts
= NULL_TREE
;
2565 VEC(tree
,gc
) *orig_init
= NULL
;
2567 if (type
== error_mark_node
)
2568 return error_mark_node
;
2570 if (nelts
== NULL_TREE
&& VEC_length (tree
, *init
) == 1)
2572 tree auto_node
= type_uses_auto (type
);
2575 tree d_init
= VEC_index (tree
, *init
, 0);
2576 d_init
= resolve_nondeduced_context (d_init
);
2577 if (describable_type (d_init
))
2578 type
= do_auto_deduction (type
, d_init
, auto_node
);
2582 if (processing_template_decl
)
2584 if (dependent_type_p (type
)
2585 || any_type_dependent_arguments_p (*placement
)
2586 || (nelts
&& type_dependent_expression_p (nelts
))
2587 || any_type_dependent_arguments_p (*init
))
2588 return build_raw_new_expr (*placement
, type
, nelts
, *init
,
2591 orig_placement
= make_tree_vector_copy (*placement
);
2593 orig_init
= make_tree_vector_copy (*init
);
2595 make_args_non_dependent (*placement
);
2597 nelts
= build_non_dependent_expr (nelts
);
2598 make_args_non_dependent (*init
);
2603 if (!build_expr_type_conversion (WANT_INT
| WANT_ENUM
, nelts
, false))
2605 if (complain
& tf_error
)
2606 permerror (input_location
, "size in array new must have integral type");
2608 return error_mark_node
;
2610 nelts
= mark_rvalue_use (nelts
);
2611 nelts
= cp_save_expr (cp_convert (sizetype
, nelts
));
2614 /* ``A reference cannot be created by the new operator. A reference
2615 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2616 returned by new.'' ARM 5.3.3 */
2617 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2619 if (complain
& tf_error
)
2620 error ("new cannot be applied to a reference type");
2622 return error_mark_node
;
2623 type
= TREE_TYPE (type
);
2626 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2628 if (complain
& tf_error
)
2629 error ("new cannot be applied to a function type");
2630 return error_mark_node
;
2633 /* The type allocated must be complete. If the new-type-id was
2634 "T[N]" then we are just checking that "T" is complete here, but
2635 that is equivalent, since the value of "N" doesn't matter. */
2636 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
2637 return error_mark_node
;
2639 rval
= build_new_1 (placement
, type
, nelts
, init
, use_global_new
, complain
);
2640 if (rval
== error_mark_node
)
2641 return error_mark_node
;
2643 if (processing_template_decl
)
2645 tree ret
= build_raw_new_expr (orig_placement
, type
, orig_nelts
,
2646 orig_init
, use_global_new
);
2647 release_tree_vector (orig_placement
);
2648 release_tree_vector (orig_init
);
2652 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2653 rval
= build1 (NOP_EXPR
, TREE_TYPE (rval
), rval
);
2654 TREE_NO_WARNING (rval
) = 1;
2659 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2662 build_java_class_ref (tree type
)
2664 tree name
= NULL_TREE
, class_decl
;
2665 static tree CL_suffix
= NULL_TREE
;
2666 if (CL_suffix
== NULL_TREE
)
2667 CL_suffix
= get_identifier("class$");
2668 if (jclass_node
== NULL_TREE
)
2670 jclass_node
= IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2671 if (jclass_node
== NULL_TREE
)
2673 error ("call to Java constructor, while %<jclass%> undefined");
2674 return error_mark_node
;
2676 jclass_node
= TREE_TYPE (jclass_node
);
2679 /* Mangle the class$ field. */
2682 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2683 if (DECL_NAME (field
) == CL_suffix
)
2685 mangle_decl (field
);
2686 name
= DECL_ASSEMBLER_NAME (field
);
2691 error ("can%'t find %<class$%> in %qT", type
);
2692 return error_mark_node
;
2696 class_decl
= IDENTIFIER_GLOBAL_VALUE (name
);
2697 if (class_decl
== NULL_TREE
)
2699 class_decl
= build_decl (input_location
,
2700 VAR_DECL
, name
, TREE_TYPE (jclass_node
));
2701 TREE_STATIC (class_decl
) = 1;
2702 DECL_EXTERNAL (class_decl
) = 1;
2703 TREE_PUBLIC (class_decl
) = 1;
2704 DECL_ARTIFICIAL (class_decl
) = 1;
2705 DECL_IGNORED_P (class_decl
) = 1;
2706 pushdecl_top_level (class_decl
);
2707 make_decl_rtl (class_decl
);
2713 build_vec_delete_1 (tree base
, tree maxindex
, tree type
,
2714 special_function_kind auto_delete_vec
, int use_global_delete
)
2717 tree ptype
= build_pointer_type (type
= complete_type (type
));
2718 tree size_exp
= size_in_bytes (type
);
2720 /* Temporary variables used by the loop. */
2721 tree tbase
, tbase_init
;
2723 /* This is the body of the loop that implements the deletion of a
2724 single element, and moves temp variables to next elements. */
2727 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2730 /* This is the thing that governs what to do after the loop has run. */
2731 tree deallocate_expr
= 0;
2733 /* This is the BIND_EXPR which holds the outermost iterator of the
2734 loop. It is convenient to set this variable up and test it before
2735 executing any other code in the loop.
2736 This is also the containing expression returned by this function. */
2737 tree controller
= NULL_TREE
;
2740 /* We should only have 1-D arrays here. */
2741 gcc_assert (TREE_CODE (type
) != ARRAY_TYPE
);
2743 if (! MAYBE_CLASS_TYPE_P (type
) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
2746 /* The below is short by the cookie size. */
2747 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2748 convert (sizetype
, maxindex
));
2750 tbase
= create_temporary_var (ptype
);
2751 tbase_init
= cp_build_modify_expr (tbase
, NOP_EXPR
,
2752 fold_build2_loc (input_location
,
2753 POINTER_PLUS_EXPR
, ptype
,
2754 fold_convert (ptype
, base
),
2756 tf_warning_or_error
);
2757 controller
= build3 (BIND_EXPR
, void_type_node
, tbase
,
2758 NULL_TREE
, NULL_TREE
);
2759 TREE_SIDE_EFFECTS (controller
) = 1;
2761 body
= build1 (EXIT_EXPR
, void_type_node
,
2762 build2 (EQ_EXPR
, boolean_type_node
, tbase
,
2763 fold_convert (ptype
, base
)));
2764 tmp
= fold_build1_loc (input_location
, NEGATE_EXPR
, sizetype
, size_exp
);
2765 body
= build_compound_expr
2767 body
, cp_build_modify_expr (tbase
, NOP_EXPR
,
2768 build2 (POINTER_PLUS_EXPR
, ptype
, tbase
, tmp
),
2769 tf_warning_or_error
));
2770 body
= build_compound_expr
2772 body
, build_delete (ptype
, tbase
, sfk_complete_destructor
,
2773 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1));
2775 loop
= build1 (LOOP_EXPR
, void_type_node
, body
);
2776 loop
= build_compound_expr (input_location
, tbase_init
, loop
);
2779 /* If the delete flag is one, or anything else with the low bit set,
2780 delete the storage. */
2781 if (auto_delete_vec
!= sfk_base_destructor
)
2785 /* The below is short by the cookie size. */
2786 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2787 convert (sizetype
, maxindex
));
2789 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
2796 cookie_size
= targetm
.cxx
.get_cookie_size (type
);
2798 = cp_convert (ptype
,
2799 cp_build_binary_op (input_location
,
2801 cp_convert (string_type_node
,
2804 tf_warning_or_error
));
2805 /* True size with header. */
2806 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, cookie_size
);
2809 if (auto_delete_vec
== sfk_deleting_destructor
)
2810 deallocate_expr
= build_op_delete_call (VEC_DELETE_EXPR
,
2811 base_tbd
, virtual_size
,
2812 use_global_delete
& 1,
2813 /*placement=*/NULL_TREE
,
2814 /*alloc_fn=*/NULL_TREE
);
2818 if (!deallocate_expr
)
2821 body
= deallocate_expr
;
2823 body
= build_compound_expr (input_location
, body
, deallocate_expr
);
2826 body
= integer_zero_node
;
2828 /* Outermost wrapper: If pointer is null, punt. */
2829 body
= fold_build3_loc (input_location
, COND_EXPR
, void_type_node
,
2830 fold_build2_loc (input_location
,
2831 NE_EXPR
, boolean_type_node
, base
,
2832 convert (TREE_TYPE (base
),
2833 integer_zero_node
)),
2834 body
, integer_zero_node
);
2835 body
= build1 (NOP_EXPR
, void_type_node
, body
);
2839 TREE_OPERAND (controller
, 1) = body
;
2843 if (TREE_CODE (base
) == SAVE_EXPR
)
2844 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
2845 body
= build2 (COMPOUND_EXPR
, void_type_node
, base
, body
);
2847 return convert_to_void (body
, ICV_CAST
, tf_warning_or_error
);
2850 /* Create an unnamed variable of the indicated TYPE. */
2853 create_temporary_var (tree type
)
2857 decl
= build_decl (input_location
,
2858 VAR_DECL
, NULL_TREE
, type
);
2859 TREE_USED (decl
) = 1;
2860 DECL_ARTIFICIAL (decl
) = 1;
2861 DECL_IGNORED_P (decl
) = 1;
2862 DECL_CONTEXT (decl
) = current_function_decl
;
2867 /* Create a new temporary variable of the indicated TYPE, initialized
2870 It is not entered into current_binding_level, because that breaks
2871 things when it comes time to do final cleanups (which take place
2872 "outside" the binding contour of the function). */
2875 get_temp_regvar (tree type
, tree init
)
2879 decl
= create_temporary_var (type
);
2880 add_decl_expr (decl
);
2882 finish_expr_stmt (cp_build_modify_expr (decl
, INIT_EXPR
, init
,
2883 tf_warning_or_error
));
2888 /* `build_vec_init' returns tree structure that performs
2889 initialization of a vector of aggregate types.
2891 BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
2892 to the first element, of POINTER_TYPE.
2893 MAXINDEX is the maximum index of the array (one less than the
2894 number of elements). It is only used if BASE is a pointer or
2895 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2897 INIT is the (possibly NULL) initializer.
2899 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All
2900 elements in the array are value-initialized.
2902 FROM_ARRAY is 0 if we should init everything with INIT
2903 (i.e., every element initialized from INIT).
2904 FROM_ARRAY is 1 if we should index into INIT in parallel
2905 with initialization of DECL.
2906 FROM_ARRAY is 2 if we should index into INIT in parallel,
2907 but use assignment instead of initialization. */
2910 build_vec_init (tree base
, tree maxindex
, tree init
,
2911 bool explicit_value_init_p
,
2912 int from_array
, tsubst_flags_t complain
)
2915 tree base2
= NULL_TREE
;
2916 tree itype
= NULL_TREE
;
2918 /* The type of BASE. */
2919 tree atype
= TREE_TYPE (base
);
2920 /* The type of an element in the array. */
2921 tree type
= TREE_TYPE (atype
);
2922 /* The element type reached after removing all outer array
2924 tree inner_elt_type
;
2925 /* The type of a pointer to an element in the array. */
2930 tree try_block
= NULL_TREE
;
2931 int num_initialized_elts
= 0;
2933 tree const_init
= NULL_TREE
;
2935 bool xvalue
= false;
2937 if (TREE_CODE (atype
) == ARRAY_TYPE
&& TYPE_DOMAIN (atype
))
2938 maxindex
= array_type_nelts (atype
);
2940 if (maxindex
== NULL_TREE
|| maxindex
== error_mark_node
)
2941 return error_mark_node
;
2943 if (explicit_value_init_p
)
2946 inner_elt_type
= strip_array_types (type
);
2948 /* Look through the TARGET_EXPR around a compound literal. */
2949 if (init
&& TREE_CODE (init
) == TARGET_EXPR
2950 && TREE_CODE (TARGET_EXPR_INITIAL (init
)) == CONSTRUCTOR
2952 init
= TARGET_EXPR_INITIAL (init
);
2955 && TREE_CODE (atype
) == ARRAY_TYPE
2957 ? (!CLASS_TYPE_P (inner_elt_type
)
2958 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (inner_elt_type
))
2959 : !TYPE_NEEDS_CONSTRUCTING (type
))
2960 && ((TREE_CODE (init
) == CONSTRUCTOR
2961 /* Don't do this if the CONSTRUCTOR might contain something
2962 that might throw and require us to clean up. */
2963 && (VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (init
))
2964 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type
)))
2967 /* Do non-default initialization of trivial arrays resulting from
2968 brace-enclosed initializers. In this case, digest_init and
2969 store_constructor will handle the semantics for us. */
2971 stmt_expr
= build2 (INIT_EXPR
, atype
, base
, init
);
2975 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
);
2976 if (TREE_CODE (atype
) == ARRAY_TYPE
)
2978 ptype
= build_pointer_type (type
);
2979 base
= cp_convert (ptype
, decay_conversion (base
));
2984 /* The code we are generating looks like:
2988 ptrdiff_t iterator = maxindex;
2990 for (; iterator != -1; --iterator) {
2991 ... initialize *t1 ...
2995 ... destroy elements that were constructed ...
3000 We can omit the try and catch blocks if we know that the
3001 initialization will never throw an exception, or if the array
3002 elements do not have destructors. We can omit the loop completely if
3003 the elements of the array do not have constructors.
3005 We actually wrap the entire body of the above in a STMT_EXPR, for
3008 When copying from array to another, when the array elements have
3009 only trivial copy constructors, we should use __builtin_memcpy
3010 rather than generating a loop. That way, we could take advantage
3011 of whatever cleverness the back end has for dealing with copies
3012 of blocks of memory. */
3014 is_global
= begin_init_stmts (&stmt_expr
, &compound_stmt
);
3015 destroy_temps
= stmts_are_full_exprs_p ();
3016 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
3017 rval
= get_temp_regvar (ptype
, base
);
3018 base
= get_temp_regvar (ptype
, rval
);
3019 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
3021 /* If initializing one array from another, initialize element by
3022 element. We rely upon the below calls to do the argument
3023 checking. Evaluate the initializer before entering the try block. */
3024 if (from_array
&& init
&& TREE_CODE (init
) != CONSTRUCTOR
)
3026 if (lvalue_kind (init
) & clk_rvalueref
)
3028 base2
= decay_conversion (init
);
3029 itype
= TREE_TYPE (base2
);
3030 base2
= get_temp_regvar (itype
, base2
);
3031 itype
= TREE_TYPE (itype
);
3034 /* Protect the entire array initialization so that we can destroy
3035 the partially constructed array if an exception is thrown.
3036 But don't do this if we're assigning. */
3037 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
3040 try_block
= begin_try_block ();
3043 /* Maybe pull out constant value when from_array? */
3045 if (init
!= NULL_TREE
&& TREE_CODE (init
) == CONSTRUCTOR
)
3047 /* Do non-default initialization of non-trivial arrays resulting from
3048 brace-enclosed initializers. */
3049 unsigned HOST_WIDE_INT idx
;
3051 /* Should we try to create a constant initializer? */
3052 bool try_const
= (literal_type_p (inner_elt_type
)
3053 || TYPE_HAS_CONSTEXPR_CTOR (inner_elt_type
));
3054 bool saw_non_const
= false;
3055 bool saw_const
= false;
3056 /* If we're initializing a static array, we want to do static
3057 initialization of any elements with constant initializers even if
3058 some are non-constant. */
3059 bool do_static_init
= (DECL_P (obase
) && TREE_STATIC (obase
));
3060 VEC(constructor_elt
,gc
) *new_vec
;
3064 new_vec
= VEC_alloc (constructor_elt
, gc
, CONSTRUCTOR_NELTS (init
));
3068 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
, field
, elt
)
3070 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
3073 num_initialized_elts
++;
3075 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
3076 if (MAYBE_CLASS_TYPE_P (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
3077 one_init
= build_aggr_init (baseref
, elt
, 0, complain
);
3079 one_init
= cp_build_modify_expr (baseref
, NOP_EXPR
,
3085 if (TREE_CODE (e
) == EXPR_STMT
)
3086 e
= TREE_OPERAND (e
, 0);
3087 if (TREE_CODE (e
) == CONVERT_EXPR
3088 && VOID_TYPE_P (TREE_TYPE (e
)))
3089 e
= TREE_OPERAND (e
, 0);
3090 e
= maybe_constant_init (e
);
3091 if (reduced_constant_expression_p (e
))
3093 CONSTRUCTOR_APPEND_ELT (new_vec
, field
, e
);
3095 one_init
= NULL_TREE
;
3097 one_init
= build2 (INIT_EXPR
, type
, baseref
, e
);
3103 CONSTRUCTOR_APPEND_ELT (new_vec
, field
,
3104 build_zero_init (TREE_TYPE (e
),
3106 saw_non_const
= true;
3111 finish_expr_stmt (one_init
);
3112 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
3114 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR
, base
, 0,
3116 finish_expr_stmt (cp_build_unary_op (PREDECREMENT_EXPR
, iterator
, 0,
3123 const_init
= build_constructor (atype
, new_vec
);
3124 else if (do_static_init
&& saw_const
)
3125 DECL_INITIAL (obase
) = build_constructor (atype
, new_vec
);
3127 VEC_free (constructor_elt
, gc
, new_vec
);
3130 /* Clear out INIT so that we don't get confused below. */
3133 else if (from_array
)
3136 /* OK, we set base2 above. */;
3137 else if (TYPE_LANG_SPECIFIC (type
)
3138 && TYPE_NEEDS_CONSTRUCTING (type
)
3139 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
3141 if (complain
& tf_error
)
3142 error ("initializer ends prematurely");
3143 return error_mark_node
;
3147 /* Now, default-initialize any remaining elements. We don't need to
3148 do that if a) the type does not need constructing, or b) we've
3149 already initialized all the elements.
3151 We do need to keep going if we're copying an array. */
3154 || ((TYPE_NEEDS_CONSTRUCTING (type
) || explicit_value_init_p
)
3155 && ! (host_integerp (maxindex
, 0)
3156 && (num_initialized_elts
3157 == tree_low_cst (maxindex
, 0) + 1))))
3159 /* If the ITERATOR is equal to -1, then we don't have to loop;
3160 we've already initialized all the elements. */
3165 for_stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
3166 finish_for_init_stmt (for_stmt
);
3167 finish_for_cond (build2 (NE_EXPR
, boolean_type_node
, iterator
,
3168 build_int_cst (TREE_TYPE (iterator
), -1)),
3170 finish_for_expr (cp_build_unary_op (PREDECREMENT_EXPR
, iterator
, 0,
3174 to
= build1 (INDIRECT_REF
, type
, base
);
3182 from
= build1 (INDIRECT_REF
, itype
, base2
);
3189 if (from_array
== 2)
3190 elt_init
= cp_build_modify_expr (to
, NOP_EXPR
, from
,
3192 else if (TYPE_NEEDS_CONSTRUCTING (type
))
3193 elt_init
= build_aggr_init (to
, from
, 0, complain
);
3195 elt_init
= cp_build_modify_expr (to
, NOP_EXPR
, from
,
3200 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3204 ("cannot initialize multi-dimensional array with initializer");
3205 elt_init
= build_vec_init (build1 (INDIRECT_REF
, type
, base
),
3207 explicit_value_init_p
,
3210 else if (explicit_value_init_p
)
3212 elt_init
= build_value_init (type
, complain
);
3213 if (elt_init
== error_mark_node
)
3214 return error_mark_node
;
3216 elt_init
= build2 (INIT_EXPR
, type
, to
, elt_init
);
3220 gcc_assert (TYPE_NEEDS_CONSTRUCTING (type
));
3221 elt_init
= build_aggr_init (to
, init
, 0, complain
);
3224 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
3225 finish_expr_stmt (elt_init
);
3226 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
3228 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR
, base
, 0,
3231 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR
, base2
, 0,
3234 finish_for_stmt (for_stmt
);
3237 /* Make sure to cleanup any partially constructed elements. */
3238 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
3242 tree m
= cp_build_binary_op (input_location
,
3243 MINUS_EXPR
, maxindex
, iterator
,
3246 /* Flatten multi-dimensional array since build_vec_delete only
3247 expects one-dimensional array. */
3248 if (TREE_CODE (type
) == ARRAY_TYPE
)
3249 m
= cp_build_binary_op (input_location
,
3251 array_type_nelts_total (type
),
3254 finish_cleanup_try_block (try_block
);
3255 e
= build_vec_delete_1 (rval
, m
,
3256 inner_elt_type
, sfk_base_destructor
,
3257 /*use_global_delete=*/0);
3258 finish_cleanup (e
, try_block
);
3261 /* The value of the array initialization is the array itself, RVAL
3262 is a pointer to the first element. */
3263 finish_stmt_expr_expr (rval
, stmt_expr
);
3265 stmt_expr
= finish_init_stmts (is_global
, stmt_expr
, compound_stmt
);
3267 /* Now make the result have the correct type. */
3268 if (TREE_CODE (atype
) == ARRAY_TYPE
)
3270 atype
= build_pointer_type (atype
);
3271 stmt_expr
= build1 (NOP_EXPR
, atype
, stmt_expr
);
3272 stmt_expr
= cp_build_indirect_ref (stmt_expr
, RO_NULL
, complain
);
3273 TREE_NO_WARNING (stmt_expr
) = 1;
3276 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
3279 return build2 (INIT_EXPR
, atype
, obase
, const_init
);
3283 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
3287 build_dtor_call (tree exp
, special_function_kind dtor_kind
, int flags
)
3293 case sfk_complete_destructor
:
3294 name
= complete_dtor_identifier
;
3297 case sfk_base_destructor
:
3298 name
= base_dtor_identifier
;
3301 case sfk_deleting_destructor
:
3302 name
= deleting_dtor_identifier
;
3308 fn
= lookup_fnfields (TREE_TYPE (exp
), name
, /*protect=*/2);
3309 return build_new_method_call (exp
, fn
,
3311 /*conversion_path=*/NULL_TREE
,
3314 tf_warning_or_error
);
3317 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3318 ADDR is an expression which yields the store to be destroyed.
3319 AUTO_DELETE is the name of the destructor to call, i.e., either
3320 sfk_complete_destructor, sfk_base_destructor, or
3321 sfk_deleting_destructor.
3323 FLAGS is the logical disjunction of zero or more LOOKUP_
3324 flags. See cp-tree.h for more info. */
3327 build_delete (tree type
, tree addr
, special_function_kind auto_delete
,
3328 int flags
, int use_global_delete
)
3332 if (addr
== error_mark_node
)
3333 return error_mark_node
;
3335 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3336 set to `error_mark_node' before it gets properly cleaned up. */
3337 if (type
== error_mark_node
)
3338 return error_mark_node
;
3340 type
= TYPE_MAIN_VARIANT (type
);
3342 addr
= mark_rvalue_use (addr
);
3344 if (TREE_CODE (type
) == POINTER_TYPE
)
3346 bool complete_p
= true;
3348 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
3349 if (TREE_CODE (type
) == ARRAY_TYPE
)
3352 /* We don't want to warn about delete of void*, only other
3353 incomplete types. Deleting other incomplete types
3354 invokes undefined behavior, but it is not ill-formed, so
3355 compile to something that would even do The Right Thing
3356 (TM) should the type have a trivial dtor and no delete
3358 if (!VOID_TYPE_P (type
))
3360 complete_type (type
);
3361 if (!COMPLETE_TYPE_P (type
))
3363 if (warning (0, "possible problem detected in invocation of "
3364 "delete operator:"))
3366 cxx_incomplete_type_diagnostic (addr
, type
, DK_WARNING
);
3367 inform (input_location
, "neither the destructor nor the class-specific "
3368 "operator delete will be called, even if they are "
3369 "declared when the class is defined");
3374 if (VOID_TYPE_P (type
) || !complete_p
|| !MAYBE_CLASS_TYPE_P (type
))
3375 /* Call the builtin operator delete. */
3376 return build_builtin_delete_call (addr
);
3377 if (TREE_SIDE_EFFECTS (addr
))
3378 addr
= save_expr (addr
);
3380 /* Throw away const and volatile on target type of addr. */
3381 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3383 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3387 if (TYPE_DOMAIN (type
) == NULL_TREE
)
3389 error ("unknown array size in delete");
3390 return error_mark_node
;
3392 return build_vec_delete (addr
, array_type_nelts (type
),
3393 auto_delete
, use_global_delete
);
3397 /* Don't check PROTECT here; leave that decision to the
3398 destructor. If the destructor is accessible, call it,
3399 else report error. */
3400 addr
= cp_build_addr_expr (addr
, tf_warning_or_error
);
3401 if (TREE_SIDE_EFFECTS (addr
))
3402 addr
= save_expr (addr
);
3404 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3407 gcc_assert (MAYBE_CLASS_TYPE_P (type
));
3409 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
3411 if (auto_delete
!= sfk_deleting_destructor
)
3412 return void_zero_node
;
3414 return build_op_delete_call (DELETE_EXPR
, addr
,
3415 cxx_sizeof_nowarn (type
),
3417 /*placement=*/NULL_TREE
,
3418 /*alloc_fn=*/NULL_TREE
);
3422 tree head
= NULL_TREE
;
3423 tree do_delete
= NULL_TREE
;
3426 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
3427 lazily_declare_fn (sfk_destructor
, type
);
3429 /* For `::delete x', we must not use the deleting destructor
3430 since then we would not be sure to get the global `operator
3432 if (use_global_delete
&& auto_delete
== sfk_deleting_destructor
)
3434 /* We will use ADDR multiple times so we must save it. */
3435 addr
= save_expr (addr
);
3436 head
= get_target_expr (build_headof (addr
));
3437 /* Delete the object. */
3438 do_delete
= build_builtin_delete_call (head
);
3439 /* Otherwise, treat this like a complete object destructor
3441 auto_delete
= sfk_complete_destructor
;
3443 /* If the destructor is non-virtual, there is no deleting
3444 variant. Instead, we must explicitly call the appropriate
3445 `operator delete' here. */
3446 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type
))
3447 && auto_delete
== sfk_deleting_destructor
)
3449 /* We will use ADDR multiple times so we must save it. */
3450 addr
= save_expr (addr
);
3451 /* Build the call. */
3452 do_delete
= build_op_delete_call (DELETE_EXPR
,
3454 cxx_sizeof_nowarn (type
),
3456 /*placement=*/NULL_TREE
,
3457 /*alloc_fn=*/NULL_TREE
);
3458 /* Call the complete object destructor. */
3459 auto_delete
= sfk_complete_destructor
;
3461 else if (auto_delete
== sfk_deleting_destructor
3462 && TYPE_GETS_REG_DELETE (type
))
3464 /* Make sure we have access to the member op delete, even though
3465 we'll actually be calling it from the destructor. */
3466 build_op_delete_call (DELETE_EXPR
, addr
, cxx_sizeof_nowarn (type
),
3468 /*placement=*/NULL_TREE
,
3469 /*alloc_fn=*/NULL_TREE
);
3472 expr
= build_dtor_call (cp_build_indirect_ref (addr
, RO_NULL
,
3473 tf_warning_or_error
),
3474 auto_delete
, flags
);
3476 expr
= build2 (COMPOUND_EXPR
, void_type_node
, expr
, do_delete
);
3478 /* We need to calculate this before the dtor changes the vptr. */
3480 expr
= build2 (COMPOUND_EXPR
, void_type_node
, head
, expr
);
3482 if (flags
& LOOKUP_DESTRUCTOR
)
3483 /* Explicit destructor call; don't check for null pointer. */
3484 ifexp
= integer_one_node
;
3486 /* Handle deleting a null pointer. */
3487 ifexp
= fold (cp_build_binary_op (input_location
,
3488 NE_EXPR
, addr
, integer_zero_node
,
3489 tf_warning_or_error
));
3491 if (ifexp
!= integer_one_node
)
3492 expr
= build3 (COND_EXPR
, void_type_node
,
3493 ifexp
, expr
, void_zero_node
);
3499 /* At the beginning of a destructor, push cleanups that will call the
3500 destructors for our base classes and members.
3502 Called from begin_destructor_body. */
3505 push_base_cleanups (void)
3507 tree binfo
, base_binfo
;
3511 VEC(tree
,gc
) *vbases
;
3513 /* Run destructors for all virtual baseclasses. */
3514 if (CLASSTYPE_VBASECLASSES (current_class_type
))
3516 tree cond
= (condition_conversion
3517 (build2 (BIT_AND_EXPR
, integer_type_node
,
3518 current_in_charge_parm
,
3519 integer_two_node
)));
3521 /* The CLASSTYPE_VBASECLASSES vector is in initialization
3522 order, which is also the right order for pushing cleanups. */
3523 for (vbases
= CLASSTYPE_VBASECLASSES (current_class_type
), i
= 0;
3524 VEC_iterate (tree
, vbases
, i
, base_binfo
); i
++)
3526 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
3528 expr
= build_special_member_call (current_class_ref
,
3529 base_dtor_identifier
,
3533 | LOOKUP_NONVIRTUAL
),
3534 tf_warning_or_error
);
3535 expr
= build3 (COND_EXPR
, void_type_node
, cond
,
3536 expr
, void_zero_node
);
3537 finish_decl_cleanup (NULL_TREE
, expr
);
3542 /* Take care of the remaining baseclasses. */
3543 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
3544 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
3546 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
))
3547 || BINFO_VIRTUAL_P (base_binfo
))
3550 expr
= build_special_member_call (current_class_ref
,
3551 base_dtor_identifier
,
3553 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
3554 tf_warning_or_error
);
3555 finish_decl_cleanup (NULL_TREE
, expr
);
3558 /* Don't automatically destroy union members. */
3559 if (TREE_CODE (current_class_type
) == UNION_TYPE
)
3562 for (member
= TYPE_FIELDS (current_class_type
); member
;
3563 member
= DECL_CHAIN (member
))
3565 tree this_type
= TREE_TYPE (member
);
3566 if (this_type
== error_mark_node
3567 || TREE_CODE (member
) != FIELD_DECL
3568 || DECL_ARTIFICIAL (member
))
3570 if (ANON_UNION_TYPE_P (this_type
))
3572 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (this_type
))
3574 tree this_member
= (build_class_member_access_expr
3575 (current_class_ref
, member
,
3576 /*access_path=*/NULL_TREE
,
3577 /*preserve_reference=*/false,
3578 tf_warning_or_error
));
3579 expr
= build_delete (this_type
, this_member
,
3580 sfk_complete_destructor
,
3581 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
,
3583 finish_decl_cleanup (NULL_TREE
, expr
);
3588 /* Build a C++ vector delete expression.
3589 MAXINDEX is the number of elements to be deleted.
3590 ELT_SIZE is the nominal size of each element in the vector.
3591 BASE is the expression that should yield the store to be deleted.
3592 This function expands (or synthesizes) these calls itself.
3593 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3595 This also calls delete for virtual baseclasses of elements of the vector.
3597 Update: MAXINDEX is no longer needed. The size can be extracted from the
3598 start of the vector for pointers, and from the type for arrays. We still
3599 use MAXINDEX for arrays because it happens to already have one of the
3600 values we'd have to extract. (We could use MAXINDEX with pointers to
3601 confirm the size, and trap if the numbers differ; not clear that it'd
3602 be worth bothering.) */
3605 build_vec_delete (tree base
, tree maxindex
,
3606 special_function_kind auto_delete_vec
, int use_global_delete
)
3610 tree base_init
= NULL_TREE
;
3612 type
= TREE_TYPE (base
);
3614 if (TREE_CODE (type
) == POINTER_TYPE
)
3616 /* Step back one from start of vector, and read dimension. */
3618 tree size_ptr_type
= build_pointer_type (sizetype
);
3620 if (TREE_SIDE_EFFECTS (base
))
3622 base_init
= get_target_expr (base
);
3623 base
= TARGET_EXPR_SLOT (base_init
);
3625 type
= strip_array_types (TREE_TYPE (type
));
3626 cookie_addr
= fold_build1_loc (input_location
, NEGATE_EXPR
,
3627 sizetype
, TYPE_SIZE_UNIT (sizetype
));
3628 cookie_addr
= build2 (POINTER_PLUS_EXPR
,
3630 fold_convert (size_ptr_type
, base
),
3632 maxindex
= cp_build_indirect_ref (cookie_addr
, RO_NULL
, tf_warning_or_error
);
3634 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3636 /* Get the total number of things in the array, maxindex is a
3638 maxindex
= array_type_nelts_total (type
);
3639 type
= strip_array_types (type
);
3640 base
= cp_build_addr_expr (base
, tf_warning_or_error
);
3641 if (TREE_SIDE_EFFECTS (base
))
3643 base_init
= get_target_expr (base
);
3644 base
= TARGET_EXPR_SLOT (base_init
);
3649 if (base
!= error_mark_node
)
3650 error ("type to vector delete is neither pointer or array type");
3651 return error_mark_node
;
3654 rval
= build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
,
3657 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), base_init
, rval
);