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 void perform_member_init (tree, tree);
41 static tree build_builtin_delete_call (tree);
42 static int member_init_ok_or_else (tree, tree, tree);
43 static void expand_virtual_init (tree, tree);
44 static tree sort_mem_initializers (tree, tree);
45 static tree initializing_context (tree);
46 static void expand_cleanup_for_base (tree, tree);
47 static tree dfs_initialize_vtbl_ptrs (tree, void *);
48 static tree build_field_list (tree, tree, int *);
49 static tree build_vtbl_address (tree);
50 static int diagnose_uninitialized_cst_or_ref_member_1 (tree, tree, bool, bool);
52 /* We are about to generate some complex initialization code.
53 Conceptually, it is all a single expression. However, we may want
54 to include conditionals, loops, and other such statement-level
55 constructs. Therefore, we build the initialization code inside a
56 statement-expression. This function starts such an expression.
57 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
58 pass them back to finish_init_stmts when the expression is
62 begin_init_stmts (tree *stmt_expr_p, tree *compound_stmt_p)
64 bool is_global = !building_stmt_list_p ();
66 *stmt_expr_p = begin_stmt_expr ();
67 *compound_stmt_p = begin_compound_stmt (BCS_NO_SCOPE);
72 /* Finish out the statement-expression begun by the previous call to
73 begin_init_stmts. Returns the statement-expression itself. */
76 finish_init_stmts (bool is_global, tree stmt_expr, tree compound_stmt)
78 finish_compound_stmt (compound_stmt);
80 stmt_expr = finish_stmt_expr (stmt_expr, true);
82 gcc_assert (!building_stmt_list_p () == is_global);
89 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
90 which we want to initialize the vtable pointer for, DATA is
91 TREE_LIST whose TREE_VALUE is the this ptr expression. */
94 dfs_initialize_vtbl_ptrs (tree binfo, void *data)
96 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
97 return dfs_skip_bases;
99 if (!BINFO_PRIMARY_P (binfo) || BINFO_VIRTUAL_P (binfo))
101 tree base_ptr = TREE_VALUE ((tree) data);
103 base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /*nonnull=*/1,
104 tf_warning_or_error);
106 expand_virtual_init (binfo, base_ptr);
112 /* Initialize all the vtable pointers in the object pointed to by
116 initialize_vtbl_ptrs (tree addr)
121 type = TREE_TYPE (TREE_TYPE (addr));
122 list = build_tree_list (type, addr);
124 /* Walk through the hierarchy, initializing the vptr in each base
125 class. We do these in pre-order because we can't find the virtual
126 bases for a class until we've initialized the vtbl for that
128 dfs_walk_once (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs, NULL, list);
131 /* Return an expression for the zero-initialization of an object with
132 type T. This expression will either be a constant (in the case
133 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
134 aggregate), or NULL (in the case that T does not require
135 initialization). In either case, the value can be used as
136 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
137 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
138 is the number of elements in the array. If STATIC_STORAGE_P is
139 TRUE, initializers are only generated for entities for which
140 zero-initialization does not simply mean filling the storage with
141 zero bytes. FIELD_SIZE, if non-NULL, is the bit size of the field,
142 subfields with bit positions at or above that bit size shouldn't
146 build_zero_init_1 (tree type, tree nelts, bool static_storage_p,
149 tree init = NULL_TREE;
153 To zero-initialize an object of type T means:
155 -- if T is a scalar type, the storage is set to the value of zero
158 -- if T is a non-union class type, the storage for each nonstatic
159 data member and each base-class subobject is zero-initialized.
161 -- if T is a union type, the storage for its first data member is
164 -- if T is an array type, the storage for each element is
167 -- if T is a reference type, no initialization is performed. */
169 gcc_assert (nelts == NULL_TREE || TREE_CODE (nelts) == INTEGER_CST);
171 if (type == error_mark_node)
173 else if (static_storage_p && zero_init_p (type))
174 /* In order to save space, we do not explicitly build initializers
175 for items that do not need them. GCC's semantics are that
176 items with static storage duration that are not otherwise
177 initialized are initialized to zero. */
179 else if (SCALAR_TYPE_P (type))
180 init = convert (type, integer_zero_node);
181 else if (CLASS_TYPE_P (type))
184 VEC(constructor_elt,gc) *v = NULL;
186 /* Iterate over the fields, building initializations. */
187 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
189 if (TREE_CODE (field) != FIELD_DECL)
192 /* Don't add virtual bases for base classes if they are beyond
193 the size of the current field, that means it is present
194 somewhere else in the object. */
197 tree bitpos = bit_position (field);
198 if (TREE_CODE (bitpos) == INTEGER_CST
199 && !tree_int_cst_lt (bitpos, field_size))
203 /* Note that for class types there will be FIELD_DECLs
204 corresponding to base classes as well. Thus, iterating
205 over TYPE_FIELDs will result in correct initialization of
206 all of the subobjects. */
207 if (!static_storage_p || !zero_init_p (TREE_TYPE (field)))
210 = (DECL_FIELD_IS_BASE (field)
212 && TREE_CODE (DECL_SIZE (field)) == INTEGER_CST)
213 ? DECL_SIZE (field) : NULL_TREE;
214 tree value = build_zero_init_1 (TREE_TYPE (field),
219 CONSTRUCTOR_APPEND_ELT(v, field, value);
222 /* For unions, only the first field is initialized. */
223 if (TREE_CODE (type) == UNION_TYPE)
227 /* Build a constructor to contain the initializations. */
228 init = build_constructor (type, v);
230 else if (TREE_CODE (type) == ARRAY_TYPE)
233 VEC(constructor_elt,gc) *v = NULL;
235 /* Iterate over the array elements, building initializations. */
237 max_index = fold_build2_loc (input_location,
238 MINUS_EXPR, TREE_TYPE (nelts),
239 nelts, integer_one_node);
241 max_index = array_type_nelts (type);
243 /* If we have an error_mark here, we should just return error mark
244 as we don't know the size of the array yet. */
245 if (max_index == error_mark_node)
246 return error_mark_node;
247 gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
249 /* A zero-sized array, which is accepted as an extension, will
250 have an upper bound of -1. */
251 if (!tree_int_cst_equal (max_index, integer_minus_one_node))
255 v = VEC_alloc (constructor_elt, gc, 1);
256 ce = VEC_quick_push (constructor_elt, v, NULL);
258 /* If this is a one element array, we just use a regular init. */
259 if (tree_int_cst_equal (size_zero_node, max_index))
260 ce->index = size_zero_node;
262 ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
265 ce->value = build_zero_init_1 (TREE_TYPE (type),
267 static_storage_p, NULL_TREE);
270 /* Build a constructor to contain the initializations. */
271 init = build_constructor (type, v);
273 else if (TREE_CODE (type) == VECTOR_TYPE)
274 init = build_zero_cst (type);
276 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
278 /* In all cases, the initializer is a constant. */
280 TREE_CONSTANT (init) = 1;
285 /* Return an expression for the zero-initialization of an object with
286 type T. This expression will either be a constant (in the case
287 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
288 aggregate), or NULL (in the case that T does not require
289 initialization). In either case, the value can be used as
290 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
291 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
292 is the number of elements in the array. If STATIC_STORAGE_P is
293 TRUE, initializers are only generated for entities for which
294 zero-initialization does not simply mean filling the storage with
298 build_zero_init (tree type, tree nelts, bool static_storage_p)
300 return build_zero_init_1 (type, nelts, static_storage_p, NULL_TREE);
303 /* Return a suitable initializer for value-initializing an object of type
304 TYPE, as described in [dcl.init]. */
307 build_value_init (tree type, tsubst_flags_t complain)
311 To value-initialize an object of type T means:
313 - if T is a class type (clause 9) with a user-provided constructor
314 (12.1), then the default constructor for T is called (and the
315 initialization is ill-formed if T has no accessible default
318 - if T is a non-union class type without a user-provided constructor,
319 then every non-static data member and base-class component of T is
320 value-initialized;92)
322 - if T is an array type, then each element is value-initialized;
324 - otherwise, the object is zero-initialized.
326 A program that calls for default-initialization or
327 value-initialization of an entity of reference type is ill-formed.
329 92) Value-initialization for such a class object may be implemented by
330 zero-initializing the object and then calling the default
333 /* The AGGR_INIT_EXPR tweaking below breaks in templates. */
334 gcc_assert (!processing_template_decl || SCALAR_TYPE_P (type));
336 if (CLASS_TYPE_P (type))
338 /* Instead of the above, only consider the user-providedness of the
339 default constructor itself so value-initializing a class with an
340 explicitly defaulted default constructor and another user-provided
341 constructor works properly (c++std-core-19883). */
342 if (type_has_user_provided_default_constructor (type)
343 || (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type)
344 && type_has_user_provided_constructor (type)))
345 return build_aggr_init_expr
347 build_special_member_call (NULL_TREE, complete_ctor_identifier,
348 NULL, type, LOOKUP_NORMAL,
351 else if (TYPE_HAS_COMPLEX_DFLT (type))
353 /* This is a class that needs constructing, but doesn't have
354 a user-provided constructor. So we need to zero-initialize
355 the object and then call the implicitly defined ctor.
356 This will be handled in simplify_aggr_init_expr. */
357 tree ctor = build_special_member_call
358 (NULL_TREE, complete_ctor_identifier,
359 NULL, type, LOOKUP_NORMAL, complain);
360 if (ctor != error_mark_node)
362 ctor = build_aggr_init_expr (type, ctor, complain);
363 AGGR_INIT_ZERO_FIRST (ctor) = 1;
368 return build_value_init_noctor (type, complain);
371 /* Like build_value_init, but don't call the constructor for TYPE. Used
372 for base initializers. */
375 build_value_init_noctor (tree type, tsubst_flags_t complain)
377 /* FIXME the class and array cases should just use digest_init once it is
379 if (CLASS_TYPE_P (type))
381 gcc_assert (!TYPE_HAS_COMPLEX_DFLT (type));
383 if (TREE_CODE (type) != UNION_TYPE)
386 VEC(constructor_elt,gc) *v = NULL;
388 /* Iterate over the fields, building initializations. */
389 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
393 if (TREE_CODE (field) != FIELD_DECL)
396 ftype = TREE_TYPE (field);
398 /* We could skip vfields and fields of types with
399 user-defined constructors, but I think that won't improve
400 performance at all; it should be simpler in general just
401 to zero out the entire object than try to only zero the
402 bits that actually need it. */
404 /* Note that for class types there will be FIELD_DECLs
405 corresponding to base classes as well. Thus, iterating
406 over TYPE_FIELDs will result in correct initialization of
407 all of the subobjects. */
408 value = build_value_init (ftype, complain);
410 if (value == error_mark_node)
411 return error_mark_node;
414 CONSTRUCTOR_APPEND_ELT(v, field, value);
417 /* Build a constructor to contain the zero- initializations. */
418 return build_constructor (type, v);
421 else if (TREE_CODE (type) == ARRAY_TYPE)
423 VEC(constructor_elt,gc) *v = NULL;
425 /* Iterate over the array elements, building initializations. */
426 tree max_index = array_type_nelts (type);
428 /* If we have an error_mark here, we should just return error mark
429 as we don't know the size of the array yet. */
430 if (max_index == error_mark_node)
432 if (complain & tf_error)
433 error ("cannot value-initialize array of unknown bound %qT",
435 return error_mark_node;
437 gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
439 /* A zero-sized array, which is accepted as an extension, will
440 have an upper bound of -1. */
441 if (!tree_int_cst_equal (max_index, integer_minus_one_node))
445 v = VEC_alloc (constructor_elt, gc, 1);
446 ce = VEC_quick_push (constructor_elt, v, NULL);
448 /* If this is a one element array, we just use a regular init. */
449 if (tree_int_cst_equal (size_zero_node, max_index))
450 ce->index = size_zero_node;
452 ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
455 ce->value = build_value_init (TREE_TYPE (type), complain);
457 if (ce->value == error_mark_node)
458 return error_mark_node;
460 /* We shouldn't have gotten here for anything that would need
461 non-trivial initialization, and gimplify_init_ctor_preeval
462 would need to be fixed to allow it. */
463 gcc_assert (TREE_CODE (ce->value) != TARGET_EXPR
464 && TREE_CODE (ce->value) != AGGR_INIT_EXPR);
467 /* Build a constructor to contain the initializations. */
468 return build_constructor (type, v);
470 else if (TREE_CODE (type) == FUNCTION_TYPE)
472 if (complain & tf_error)
473 error ("value-initialization of function type %qT", type);
474 return error_mark_node;
476 else if (TREE_CODE (type) == REFERENCE_TYPE)
478 if (complain & tf_error)
479 error ("value-initialization of reference type %qT", type);
480 return error_mark_node;
483 return build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
486 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
487 arguments. If TREE_LIST is void_type_node, an empty initializer
488 list was given; if NULL_TREE no initializer was given. */
491 perform_member_init (tree member, tree init)
494 tree type = TREE_TYPE (member);
496 /* Use the non-static data member initializer if there was no
497 mem-initializer for this field. */
498 if (init == NULL_TREE)
500 if (CLASSTYPE_TEMPLATE_INSTANTIATION (DECL_CONTEXT (member)))
501 /* Do deferred instantiation of the NSDMI. */
502 init = (tsubst_copy_and_build
503 (DECL_INITIAL (member),
504 CLASSTYPE_TI_ARGS (DECL_CONTEXT (member)),
505 tf_warning_or_error, member, /*function_p=*/false,
506 /*integral_constant_expression_p=*/false));
508 init = break_out_target_exprs (DECL_INITIAL (member));
511 /* Effective C++ rule 12 requires that all data members be
513 if (warn_ecpp && init == NULL_TREE && TREE_CODE (type) != ARRAY_TYPE)
514 warning_at (DECL_SOURCE_LOCATION (current_function_decl), OPT_Weffc__,
515 "%qD should be initialized in the member initialization list",
518 /* Get an lvalue for the data member. */
519 decl = build_class_member_access_expr (current_class_ref, member,
520 /*access_path=*/NULL_TREE,
521 /*preserve_reference=*/true,
522 tf_warning_or_error);
523 if (decl == error_mark_node)
526 if (warn_init_self && init && TREE_CODE (init) == TREE_LIST
527 && TREE_CHAIN (init) == NULL_TREE)
529 tree val = TREE_VALUE (init);
530 if (TREE_CODE (val) == COMPONENT_REF && TREE_OPERAND (val, 1) == member
531 && TREE_OPERAND (val, 0) == current_class_ref)
532 warning_at (DECL_SOURCE_LOCATION (current_function_decl),
533 OPT_Wuninitialized, "%qD is initialized with itself",
537 if (init == void_type_node)
539 /* mem() means value-initialization. */
540 if (TREE_CODE (type) == ARRAY_TYPE)
542 init = build_vec_init_expr (type, init, tf_warning_or_error);
543 init = build2 (INIT_EXPR, type, decl, init);
544 finish_expr_stmt (init);
548 tree value = build_value_init (type, tf_warning_or_error);
549 if (value == error_mark_node)
551 init = build2 (INIT_EXPR, type, decl, value);
552 finish_expr_stmt (init);
555 /* Deal with this here, as we will get confused if we try to call the
556 assignment op for an anonymous union. This can happen in a
557 synthesized copy constructor. */
558 else if (ANON_AGGR_TYPE_P (type))
562 init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init));
563 finish_expr_stmt (init);
566 else if (type_build_ctor_call (type)
567 || (init && CLASS_TYPE_P (strip_array_types (type))))
569 if (TREE_CODE (type) == ARRAY_TYPE)
573 if (TREE_CHAIN (init))
574 init = error_mark_node;
576 init = TREE_VALUE (init);
577 if (BRACE_ENCLOSED_INITIALIZER_P (init))
578 init = digest_init (type, init, tf_warning_or_error);
580 if (init == NULL_TREE
581 || same_type_ignoring_top_level_qualifiers_p (type,
584 init = build_vec_init_expr (type, init, tf_warning_or_error);
585 init = build2 (INIT_EXPR, type, decl, init);
586 finish_expr_stmt (init);
589 error ("invalid initializer for array member %q#D", member);
593 int flags = LOOKUP_NORMAL;
594 if (DECL_DEFAULTED_FN (current_function_decl))
595 flags |= LOOKUP_DEFAULTED;
596 if (CP_TYPE_CONST_P (type)
598 && default_init_uninitialized_part (type))
599 /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
600 vtable; still give this diagnostic. */
601 permerror (DECL_SOURCE_LOCATION (current_function_decl),
602 "uninitialized member %qD with %<const%> type %qT",
604 finish_expr_stmt (build_aggr_init (decl, init, flags,
605 tf_warning_or_error));
610 if (init == NULL_TREE)
613 /* member traversal: note it leaves init NULL */
614 if (TREE_CODE (type) == REFERENCE_TYPE)
615 permerror (DECL_SOURCE_LOCATION (current_function_decl),
616 "uninitialized reference member %qD",
618 else if (CP_TYPE_CONST_P (type))
619 permerror (DECL_SOURCE_LOCATION (current_function_decl),
620 "uninitialized member %qD with %<const%> type %qT",
623 core_type = strip_array_types (type);
625 if (CLASS_TYPE_P (core_type)
626 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)
627 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)))
628 diagnose_uninitialized_cst_or_ref_member (core_type,
632 else if (TREE_CODE (init) == TREE_LIST)
633 /* There was an explicit member initialization. Do some work
635 init = build_x_compound_expr_from_list (init, ELK_MEM_INIT,
636 tf_warning_or_error);
639 finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,
640 tf_warning_or_error));
643 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
647 expr = build_class_member_access_expr (current_class_ref, member,
648 /*access_path=*/NULL_TREE,
649 /*preserve_reference=*/false,
650 tf_warning_or_error);
651 expr = build_delete (type, expr, sfk_complete_destructor,
652 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0,
653 tf_warning_or_error);
655 if (expr != error_mark_node)
656 finish_eh_cleanup (expr);
660 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
661 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
664 build_field_list (tree t, tree list, int *uses_unions_p)
668 /* Note whether or not T is a union. */
669 if (TREE_CODE (t) == UNION_TYPE)
672 for (fields = TYPE_FIELDS (t); fields; fields = DECL_CHAIN (fields))
676 /* Skip CONST_DECLs for enumeration constants and so forth. */
677 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
680 fieldtype = TREE_TYPE (fields);
681 /* Keep track of whether or not any fields are unions. */
682 if (TREE_CODE (fieldtype) == UNION_TYPE)
685 /* For an anonymous struct or union, we must recursively
686 consider the fields of the anonymous type. They can be
687 directly initialized from the constructor. */
688 if (ANON_AGGR_TYPE_P (fieldtype))
690 /* Add this field itself. Synthesized copy constructors
691 initialize the entire aggregate. */
692 list = tree_cons (fields, NULL_TREE, list);
693 /* And now add the fields in the anonymous aggregate. */
694 list = build_field_list (fieldtype, list, uses_unions_p);
696 /* Add this field. */
697 else if (DECL_NAME (fields))
698 list = tree_cons (fields, NULL_TREE, list);
704 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
705 a FIELD_DECL or BINFO in T that needs initialization. The
706 TREE_VALUE gives the initializer, or list of initializer arguments.
708 Return a TREE_LIST containing all of the initializations required
709 for T, in the order in which they should be performed. The output
710 list has the same format as the input. */
713 sort_mem_initializers (tree t, tree mem_inits)
716 tree base, binfo, base_binfo;
719 VEC(tree,gc) *vbases;
721 int uses_unions_p = 0;
723 /* Build up a list of initializations. The TREE_PURPOSE of entry
724 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
725 TREE_VALUE will be the constructor arguments, or NULL if no
726 explicit initialization was provided. */
727 sorted_inits = NULL_TREE;
729 /* Process the virtual bases. */
730 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
731 VEC_iterate (tree, vbases, i, base); i++)
732 sorted_inits = tree_cons (base, NULL_TREE, sorted_inits);
734 /* Process the direct bases. */
735 for (binfo = TYPE_BINFO (t), i = 0;
736 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
737 if (!BINFO_VIRTUAL_P (base_binfo))
738 sorted_inits = tree_cons (base_binfo, NULL_TREE, sorted_inits);
740 /* Process the non-static data members. */
741 sorted_inits = build_field_list (t, sorted_inits, &uses_unions_p);
742 /* Reverse the entire list of initializations, so that they are in
743 the order that they will actually be performed. */
744 sorted_inits = nreverse (sorted_inits);
746 /* If the user presented the initializers in an order different from
747 that in which they will actually occur, we issue a warning. Keep
748 track of the next subobject which can be explicitly initialized
749 without issuing a warning. */
750 next_subobject = sorted_inits;
752 /* Go through the explicit initializers, filling in TREE_PURPOSE in
754 for (init = mem_inits; init; init = TREE_CHAIN (init))
759 subobject = TREE_PURPOSE (init);
761 /* If the explicit initializers are in sorted order, then
762 SUBOBJECT will be NEXT_SUBOBJECT, or something following
764 for (subobject_init = next_subobject;
766 subobject_init = TREE_CHAIN (subobject_init))
767 if (TREE_PURPOSE (subobject_init) == subobject)
770 /* Issue a warning if the explicit initializer order does not
771 match that which will actually occur.
772 ??? Are all these on the correct lines? */
773 if (warn_reorder && !subobject_init)
775 if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)
776 warning (OPT_Wreorder, "%q+D will be initialized after",
777 TREE_PURPOSE (next_subobject));
779 warning (OPT_Wreorder, "base %qT will be initialized after",
780 TREE_PURPOSE (next_subobject));
781 if (TREE_CODE (subobject) == FIELD_DECL)
782 warning (OPT_Wreorder, " %q+#D", subobject);
784 warning (OPT_Wreorder, " base %qT", subobject);
785 warning_at (DECL_SOURCE_LOCATION (current_function_decl),
786 OPT_Wreorder, " when initialized here");
789 /* Look again, from the beginning of the list. */
792 subobject_init = sorted_inits;
793 while (TREE_PURPOSE (subobject_init) != subobject)
794 subobject_init = TREE_CHAIN (subobject_init);
797 /* It is invalid to initialize the same subobject more than
799 if (TREE_VALUE (subobject_init))
801 if (TREE_CODE (subobject) == FIELD_DECL)
802 error_at (DECL_SOURCE_LOCATION (current_function_decl),
803 "multiple initializations given for %qD",
806 error_at (DECL_SOURCE_LOCATION (current_function_decl),
807 "multiple initializations given for base %qT",
811 /* Record the initialization. */
812 TREE_VALUE (subobject_init) = TREE_VALUE (init);
813 next_subobject = subobject_init;
818 If a ctor-initializer specifies more than one mem-initializer for
819 multiple members of the same union (including members of
820 anonymous unions), the ctor-initializer is ill-formed.
822 Here we also splice out uninitialized union members. */
825 tree last_field = NULL_TREE;
827 for (p = &sorted_inits; *p; )
835 field = TREE_PURPOSE (init);
837 /* Skip base classes. */
838 if (TREE_CODE (field) != FIELD_DECL)
841 /* If this is an anonymous union with no explicit initializer,
843 if (!TREE_VALUE (init) && ANON_UNION_TYPE_P (TREE_TYPE (field)))
846 /* See if this field is a member of a union, or a member of a
847 structure contained in a union, etc. */
848 for (ctx = DECL_CONTEXT (field);
849 !same_type_p (ctx, t);
850 ctx = TYPE_CONTEXT (ctx))
851 if (TREE_CODE (ctx) == UNION_TYPE)
853 /* If this field is not a member of a union, skip it. */
854 if (TREE_CODE (ctx) != UNION_TYPE)
857 /* If this union member has no explicit initializer, splice
859 if (!TREE_VALUE (init))
862 /* It's only an error if we have two initializers for the same
870 /* See if LAST_FIELD and the field initialized by INIT are
871 members of the same union. If so, there's a problem,
872 unless they're actually members of the same structure
873 which is itself a member of a union. For example, given:
875 union { struct { int i; int j; }; };
877 initializing both `i' and `j' makes sense. */
878 ctx = DECL_CONTEXT (field);
884 last_ctx = DECL_CONTEXT (last_field);
887 if (same_type_p (last_ctx, ctx))
889 if (TREE_CODE (ctx) == UNION_TYPE)
890 error_at (DECL_SOURCE_LOCATION (current_function_decl),
891 "initializations for multiple members of %qT",
897 if (same_type_p (last_ctx, t))
900 last_ctx = TYPE_CONTEXT (last_ctx);
903 /* If we've reached the outermost class, then we're
905 if (same_type_p (ctx, t))
908 ctx = TYPE_CONTEXT (ctx);
915 p = &TREE_CHAIN (*p);
918 *p = TREE_CHAIN (*p);
926 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
927 is a TREE_LIST giving the explicit mem-initializer-list for the
928 constructor. The TREE_PURPOSE of each entry is a subobject (a
929 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
930 is a TREE_LIST giving the arguments to the constructor or
931 void_type_node for an empty list of arguments. */
934 emit_mem_initializers (tree mem_inits)
936 int flags = LOOKUP_NORMAL;
938 /* We will already have issued an error message about the fact that
939 the type is incomplete. */
940 if (!COMPLETE_TYPE_P (current_class_type))
943 if (DECL_DEFAULTED_FN (current_function_decl))
944 flags |= LOOKUP_DEFAULTED;
946 /* Sort the mem-initializers into the order in which the
947 initializations should be performed. */
948 mem_inits = sort_mem_initializers (current_class_type, mem_inits);
950 in_base_initializer = 1;
952 /* Initialize base classes. */
954 && TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)
956 tree subobject = TREE_PURPOSE (mem_inits);
957 tree arguments = TREE_VALUE (mem_inits);
959 if (arguments == NULL_TREE)
961 /* If these initializations are taking place in a copy constructor,
962 the base class should probably be explicitly initialized if there
963 is a user-defined constructor in the base class (other than the
964 default constructor, which will be called anyway). */
966 && DECL_COPY_CONSTRUCTOR_P (current_function_decl)
967 && type_has_user_nondefault_constructor (BINFO_TYPE (subobject)))
968 warning_at (DECL_SOURCE_LOCATION (current_function_decl),
969 OPT_Wextra, "base class %q#T should be explicitly "
970 "initialized in the copy constructor",
971 BINFO_TYPE (subobject));
974 /* Initialize the base. */
975 if (BINFO_VIRTUAL_P (subobject))
976 construct_virtual_base (subobject, arguments);
981 base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
982 subobject, 1, tf_warning_or_error);
983 expand_aggr_init_1 (subobject, NULL_TREE,
984 cp_build_indirect_ref (base_addr, RO_NULL,
985 tf_warning_or_error),
988 tf_warning_or_error);
989 expand_cleanup_for_base (subobject, NULL_TREE);
992 mem_inits = TREE_CHAIN (mem_inits);
994 in_base_initializer = 0;
996 /* Initialize the vptrs. */
997 initialize_vtbl_ptrs (current_class_ptr);
999 /* Initialize the data members. */
1002 perform_member_init (TREE_PURPOSE (mem_inits),
1003 TREE_VALUE (mem_inits));
1004 mem_inits = TREE_CHAIN (mem_inits);
1008 /* Returns the address of the vtable (i.e., the value that should be
1009 assigned to the vptr) for BINFO. */
1012 build_vtbl_address (tree binfo)
1014 tree binfo_for = binfo;
1017 if (BINFO_VPTR_INDEX (binfo) && BINFO_VIRTUAL_P (binfo))
1018 /* If this is a virtual primary base, then the vtable we want to store
1019 is that for the base this is being used as the primary base of. We
1020 can't simply skip the initialization, because we may be expanding the
1021 inits of a subobject constructor where the virtual base layout
1022 can be different. */
1023 while (BINFO_PRIMARY_P (binfo_for))
1024 binfo_for = BINFO_INHERITANCE_CHAIN (binfo_for);
1026 /* Figure out what vtable BINFO's vtable is based on, and mark it as
1028 vtbl = get_vtbl_decl_for_binfo (binfo_for);
1029 TREE_USED (vtbl) = 1;
1031 /* Now compute the address to use when initializing the vptr. */
1032 vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
1033 if (TREE_CODE (vtbl) == VAR_DECL)
1034 vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
1039 /* This code sets up the virtual function tables appropriate for
1040 the pointer DECL. It is a one-ply initialization.
1042 BINFO is the exact type that DECL is supposed to be. In
1043 multiple inheritance, this might mean "C's A" if C : A, B. */
1046 expand_virtual_init (tree binfo, tree decl)
1048 tree vtbl, vtbl_ptr;
1051 /* Compute the initializer for vptr. */
1052 vtbl = build_vtbl_address (binfo);
1054 /* We may get this vptr from a VTT, if this is a subobject
1055 constructor or subobject destructor. */
1056 vtt_index = BINFO_VPTR_INDEX (binfo);
1062 /* Compute the value to use, when there's a VTT. */
1063 vtt_parm = current_vtt_parm;
1064 vtbl2 = fold_build_pointer_plus (vtt_parm, vtt_index);
1065 vtbl2 = cp_build_indirect_ref (vtbl2, RO_NULL, tf_warning_or_error);
1066 vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
1068 /* The actual initializer is the VTT value only in the subobject
1069 constructor. In maybe_clone_body we'll substitute NULL for
1070 the vtt_parm in the case of the non-subobject constructor. */
1071 vtbl = build3 (COND_EXPR,
1073 build2 (EQ_EXPR, boolean_type_node,
1074 current_in_charge_parm, integer_zero_node),
1079 /* Compute the location of the vtpr. */
1080 vtbl_ptr = build_vfield_ref (cp_build_indirect_ref (decl, RO_NULL,
1081 tf_warning_or_error),
1083 gcc_assert (vtbl_ptr != error_mark_node);
1085 /* Assign the vtable to the vptr. */
1086 vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
1087 finish_expr_stmt (cp_build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl,
1088 tf_warning_or_error));
1091 /* If an exception is thrown in a constructor, those base classes already
1092 constructed must be destroyed. This function creates the cleanup
1093 for BINFO, which has just been constructed. If FLAG is non-NULL,
1094 it is a DECL which is nonzero when this base needs to be
1098 expand_cleanup_for_base (tree binfo, tree flag)
1102 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
1105 /* Call the destructor. */
1106 expr = build_special_member_call (current_class_ref,
1107 base_dtor_identifier,
1110 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
1111 tf_warning_or_error);
1113 expr = fold_build3_loc (input_location,
1114 COND_EXPR, void_type_node,
1115 c_common_truthvalue_conversion (input_location, flag),
1116 expr, integer_zero_node);
1118 finish_eh_cleanup (expr);
1121 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
1125 construct_virtual_base (tree vbase, tree arguments)
1131 /* If there are virtual base classes with destructors, we need to
1132 emit cleanups to destroy them if an exception is thrown during
1133 the construction process. These exception regions (i.e., the
1134 period during which the cleanups must occur) begin from the time
1135 the construction is complete to the end of the function. If we
1136 create a conditional block in which to initialize the
1137 base-classes, then the cleanup region for the virtual base begins
1138 inside a block, and ends outside of that block. This situation
1139 confuses the sjlj exception-handling code. Therefore, we do not
1140 create a single conditional block, but one for each
1141 initialization. (That way the cleanup regions always begin
1142 in the outer block.) We trust the back end to figure out
1143 that the FLAG will not change across initializations, and
1144 avoid doing multiple tests. */
1145 flag = DECL_CHAIN (DECL_ARGUMENTS (current_function_decl));
1146 inner_if_stmt = begin_if_stmt ();
1147 finish_if_stmt_cond (flag, inner_if_stmt);
1149 /* Compute the location of the virtual base. If we're
1150 constructing virtual bases, then we must be the most derived
1151 class. Therefore, we don't have to look up the virtual base;
1152 we already know where it is. */
1153 exp = convert_to_base_statically (current_class_ref, vbase);
1155 expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
1156 LOOKUP_COMPLAIN, tf_warning_or_error);
1157 finish_then_clause (inner_if_stmt);
1158 finish_if_stmt (inner_if_stmt);
1160 expand_cleanup_for_base (vbase, flag);
1163 /* Find the context in which this FIELD can be initialized. */
1166 initializing_context (tree field)
1168 tree t = DECL_CONTEXT (field);
1170 /* Anonymous union members can be initialized in the first enclosing
1171 non-anonymous union context. */
1172 while (t && ANON_AGGR_TYPE_P (t))
1173 t = TYPE_CONTEXT (t);
1177 /* Function to give error message if member initialization specification
1178 is erroneous. FIELD is the member we decided to initialize.
1179 TYPE is the type for which the initialization is being performed.
1180 FIELD must be a member of TYPE.
1182 MEMBER_NAME is the name of the member. */
1185 member_init_ok_or_else (tree field, tree type, tree member_name)
1187 if (field == error_mark_node)
1191 error ("class %qT does not have any field named %qD", type,
1195 if (TREE_CODE (field) == VAR_DECL)
1197 error ("%q#D is a static data member; it can only be "
1198 "initialized at its definition",
1202 if (TREE_CODE (field) != FIELD_DECL)
1204 error ("%q#D is not a non-static data member of %qT",
1208 if (initializing_context (field) != type)
1210 error ("class %qT does not have any field named %qD", type,
1218 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1219 is a _TYPE node or TYPE_DECL which names a base for that type.
1220 Check the validity of NAME, and return either the base _TYPE, base
1221 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
1222 NULL_TREE and issue a diagnostic.
1224 An old style unnamed direct single base construction is permitted,
1225 where NAME is NULL. */
1228 expand_member_init (tree name)
1233 if (!current_class_ref)
1238 /* This is an obsolete unnamed base class initializer. The
1239 parser will already have warned about its use. */
1240 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type)))
1243 error ("unnamed initializer for %qT, which has no base classes",
1244 current_class_type);
1247 basetype = BINFO_TYPE
1248 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0));
1251 error ("unnamed initializer for %qT, which uses multiple inheritance",
1252 current_class_type);
1256 else if (TYPE_P (name))
1258 basetype = TYPE_MAIN_VARIANT (name);
1259 name = TYPE_NAME (name);
1261 else if (TREE_CODE (name) == TYPE_DECL)
1262 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
1264 basetype = NULL_TREE;
1273 if (current_template_parms)
1276 class_binfo = TYPE_BINFO (current_class_type);
1277 direct_binfo = NULL_TREE;
1278 virtual_binfo = NULL_TREE;
1280 /* Look for a direct base. */
1281 for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i)
1282 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo), basetype))
1285 /* Look for a virtual base -- unless the direct base is itself
1287 if (!direct_binfo || !BINFO_VIRTUAL_P (direct_binfo))
1288 virtual_binfo = binfo_for_vbase (basetype, current_class_type);
1290 /* [class.base.init]
1292 If a mem-initializer-id is ambiguous because it designates
1293 both a direct non-virtual base class and an inherited virtual
1294 base class, the mem-initializer is ill-formed. */
1295 if (direct_binfo && virtual_binfo)
1297 error ("%qD is both a direct base and an indirect virtual base",
1302 if (!direct_binfo && !virtual_binfo)
1304 if (CLASSTYPE_VBASECLASSES (current_class_type))
1305 error ("type %qT is not a direct or virtual base of %qT",
1306 basetype, current_class_type);
1308 error ("type %qT is not a direct base of %qT",
1309 basetype, current_class_type);
1313 return direct_binfo ? direct_binfo : virtual_binfo;
1317 if (TREE_CODE (name) == IDENTIFIER_NODE)
1318 field = lookup_field (current_class_type, name, 1, false);
1322 if (member_init_ok_or_else (field, current_class_type, name))
1329 /* This is like `expand_member_init', only it stores one aggregate
1332 INIT comes in two flavors: it is either a value which
1333 is to be stored in EXP, or it is a parameter list
1334 to go to a constructor, which will operate on EXP.
1335 If INIT is not a parameter list for a constructor, then set
1336 LOOKUP_ONLYCONVERTING.
1337 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1338 the initializer, if FLAGS is 0, then it is the (init) form.
1339 If `init' is a CONSTRUCTOR, then we emit a warning message,
1340 explaining that such initializations are invalid.
1342 If INIT resolves to a CALL_EXPR which happens to return
1343 something of the type we are looking for, then we know
1344 that we can safely use that call to perform the
1347 The virtual function table pointer cannot be set up here, because
1348 we do not really know its type.
1350 This never calls operator=().
1352 When initializing, nothing is CONST.
1354 A default copy constructor may have to be used to perform the
1357 A constructor or a conversion operator may have to be used to
1358 perform the initialization, but not both, as it would be ambiguous. */
1361 build_aggr_init (tree exp, tree init, int flags, tsubst_flags_t complain)
1366 tree type = TREE_TYPE (exp);
1367 int was_const = TREE_READONLY (exp);
1368 int was_volatile = TREE_THIS_VOLATILE (exp);
1371 if (init == error_mark_node)
1372 return error_mark_node;
1374 TREE_READONLY (exp) = 0;
1375 TREE_THIS_VOLATILE (exp) = 0;
1377 if (init && TREE_CODE (init) != TREE_LIST
1378 && !(BRACE_ENCLOSED_INITIALIZER_P (init)
1379 && CONSTRUCTOR_IS_DIRECT_INIT (init)))
1380 flags |= LOOKUP_ONLYCONVERTING;
1382 if (TREE_CODE (type) == ARRAY_TYPE)
1386 /* An array may not be initialized use the parenthesized
1387 initialization form -- unless the initializer is "()". */
1388 if (init && TREE_CODE (init) == TREE_LIST)
1390 if (complain & tf_error)
1391 error ("bad array initializer");
1392 return error_mark_node;
1394 /* Must arrange to initialize each element of EXP
1395 from elements of INIT. */
1396 itype = init ? TREE_TYPE (init) : NULL_TREE;
1397 if (cv_qualified_p (type))
1398 TREE_TYPE (exp) = cv_unqualified (type);
1399 if (itype && cv_qualified_p (itype))
1400 TREE_TYPE (init) = cv_unqualified (itype);
1401 stmt_expr = build_vec_init (exp, NULL_TREE, init,
1402 /*explicit_value_init_p=*/false,
1403 itype && same_type_p (TREE_TYPE (init),
1406 TREE_READONLY (exp) = was_const;
1407 TREE_THIS_VOLATILE (exp) = was_volatile;
1408 TREE_TYPE (exp) = type;
1410 TREE_TYPE (init) = itype;
1414 if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1415 /* Just know that we've seen something for this node. */
1416 TREE_USED (exp) = 1;
1418 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
1419 destroy_temps = stmts_are_full_exprs_p ();
1420 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
1421 expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1422 init, LOOKUP_NORMAL|flags, complain);
1423 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
1424 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
1425 TREE_READONLY (exp) = was_const;
1426 TREE_THIS_VOLATILE (exp) = was_volatile;
1432 expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags,
1433 tsubst_flags_t complain)
1435 tree type = TREE_TYPE (exp);
1438 /* It fails because there may not be a constructor which takes
1439 its own type as the first (or only parameter), but which does
1440 take other types via a conversion. So, if the thing initializing
1441 the expression is a unit element of type X, first try X(X&),
1442 followed by initialization by X. If neither of these work
1443 out, then look hard. */
1445 VEC(tree,gc) *parms;
1447 /* If we have direct-initialization from an initializer list, pull
1448 it out of the TREE_LIST so the code below can see it. */
1449 if (init && TREE_CODE (init) == TREE_LIST
1450 && BRACE_ENCLOSED_INITIALIZER_P (TREE_VALUE (init))
1451 && CONSTRUCTOR_IS_DIRECT_INIT (TREE_VALUE (init)))
1453 gcc_checking_assert ((flags & LOOKUP_ONLYCONVERTING) == 0
1454 && TREE_CHAIN (init) == NULL_TREE);
1455 init = TREE_VALUE (init);
1458 if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
1459 && CP_AGGREGATE_TYPE_P (type))
1461 /* A brace-enclosed initializer for an aggregate. In C++0x this can
1462 happen for direct-initialization, too. */
1463 init = digest_init (type, init, complain);
1464 init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1465 TREE_SIDE_EFFECTS (init) = 1;
1466 finish_expr_stmt (init);
1470 if (init && TREE_CODE (init) != TREE_LIST
1471 && (flags & LOOKUP_ONLYCONVERTING))
1473 /* Base subobjects should only get direct-initialization. */
1474 gcc_assert (true_exp == exp);
1476 if (flags & DIRECT_BIND)
1477 /* Do nothing. We hit this in two cases: Reference initialization,
1478 where we aren't initializing a real variable, so we don't want
1479 to run a new constructor; and catching an exception, where we
1480 have already built up the constructor call so we could wrap it
1481 in an exception region. */;
1483 init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1485 if (TREE_CODE (init) == MUST_NOT_THROW_EXPR)
1486 /* We need to protect the initialization of a catch parm with a
1487 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1488 around the TARGET_EXPR for the copy constructor. See
1489 initialize_handler_parm. */
1491 TREE_OPERAND (init, 0) = build2 (INIT_EXPR, TREE_TYPE (exp), exp,
1492 TREE_OPERAND (init, 0));
1493 TREE_TYPE (init) = void_type_node;
1496 init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1497 TREE_SIDE_EFFECTS (init) = 1;
1498 finish_expr_stmt (init);
1502 if (init == NULL_TREE)
1504 else if (TREE_CODE (init) == TREE_LIST && !TREE_TYPE (init))
1506 parms = make_tree_vector ();
1507 for (; init != NULL_TREE; init = TREE_CHAIN (init))
1508 VEC_safe_push (tree, gc, parms, TREE_VALUE (init));
1511 parms = make_tree_vector_single (init);
1513 if (true_exp == exp)
1514 ctor_name = complete_ctor_identifier;
1516 ctor_name = base_ctor_identifier;
1518 rval = build_special_member_call (exp, ctor_name, &parms, binfo, flags,
1522 release_tree_vector (parms);
1524 if (exp == true_exp && TREE_CODE (rval) == CALL_EXPR)
1526 tree fn = get_callee_fndecl (rval);
1527 if (fn && DECL_DECLARED_CONSTEXPR_P (fn))
1529 tree e = maybe_constant_init (rval);
1530 if (TREE_CONSTANT (e))
1531 rval = build2 (INIT_EXPR, type, exp, e);
1535 /* FIXME put back convert_to_void? */
1536 if (TREE_SIDE_EFFECTS (rval))
1537 finish_expr_stmt (rval);
1540 /* This function is responsible for initializing EXP with INIT
1543 BINFO is the binfo of the type for who we are performing the
1544 initialization. For example, if W is a virtual base class of A and B,
1546 If we are initializing B, then W must contain B's W vtable, whereas
1547 were we initializing C, W must contain C's W vtable.
1549 TRUE_EXP is nonzero if it is the true expression being initialized.
1550 In this case, it may be EXP, or may just contain EXP. The reason we
1551 need this is because if EXP is a base element of TRUE_EXP, we
1552 don't necessarily know by looking at EXP where its virtual
1553 baseclass fields should really be pointing. But we do know
1554 from TRUE_EXP. In constructors, we don't know anything about
1555 the value being initialized.
1557 FLAGS is just passed to `build_new_method_call'. See that function
1558 for its description. */
1561 expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags,
1562 tsubst_flags_t complain)
1564 tree type = TREE_TYPE (exp);
1566 gcc_assert (init != error_mark_node && type != error_mark_node);
1567 gcc_assert (building_stmt_list_p ());
1569 /* Use a function returning the desired type to initialize EXP for us.
1570 If the function is a constructor, and its first argument is
1571 NULL_TREE, know that it was meant for us--just slide exp on
1572 in and expand the constructor. Constructors now come
1575 if (init && TREE_CODE (exp) == VAR_DECL
1576 && COMPOUND_LITERAL_P (init))
1578 /* If store_init_value returns NULL_TREE, the INIT has been
1579 recorded as the DECL_INITIAL for EXP. That means there's
1580 nothing more we have to do. */
1581 init = store_init_value (exp, init, flags);
1583 finish_expr_stmt (init);
1587 /* If an explicit -- but empty -- initializer list was present,
1588 that's value-initialization. */
1589 if (init == void_type_node)
1591 /* If there's a user-provided constructor, we just call that. */
1592 if (type_has_user_provided_constructor (type))
1593 /* Fall through. */;
1594 /* If there isn't, but we still need to call the constructor,
1595 zero out the object first. */
1596 else if (type_build_ctor_call (type))
1598 init = build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
1599 init = build2 (INIT_EXPR, type, exp, init);
1600 finish_expr_stmt (init);
1601 /* And then call the constructor. */
1603 /* If we don't need to mess with the constructor at all,
1604 then just zero out the object and we're done. */
1607 init = build2 (INIT_EXPR, type, exp,
1608 build_value_init_noctor (type, complain));
1609 finish_expr_stmt (init);
1615 /* We know that expand_default_init can handle everything we want
1617 expand_default_init (binfo, true_exp, exp, init, flags, complain);
1620 /* Report an error if TYPE is not a user-defined, class type. If
1621 OR_ELSE is nonzero, give an error message. */
1624 is_class_type (tree type, int or_else)
1626 if (type == error_mark_node)
1629 if (! CLASS_TYPE_P (type))
1632 error ("%qT is not a class type", type);
1639 get_type_value (tree name)
1641 if (name == error_mark_node)
1644 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1645 return IDENTIFIER_TYPE_VALUE (name);
1650 /* Build a reference to a member of an aggregate. This is not a C++
1651 `&', but really something which can have its address taken, and
1652 then act as a pointer to member, for example TYPE :: FIELD can have
1653 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
1654 this expression is the operand of "&".
1656 @@ Prints out lousy diagnostics for operator <typename>
1659 @@ This function should be rewritten and placed in search.c. */
1662 build_offset_ref (tree type, tree member, bool address_p)
1665 tree basebinfo = NULL_TREE;
1667 /* class templates can come in as TEMPLATE_DECLs here. */
1668 if (TREE_CODE (member) == TEMPLATE_DECL)
1671 if (dependent_scope_p (type) || type_dependent_expression_p (member))
1672 return build_qualified_name (NULL_TREE, type, member,
1673 /*template_p=*/false);
1675 gcc_assert (TYPE_P (type));
1676 if (! is_class_type (type, 1))
1677 return error_mark_node;
1679 gcc_assert (DECL_P (member) || BASELINK_P (member));
1680 /* Callers should call mark_used before this point. */
1681 gcc_assert (!DECL_P (member) || TREE_USED (member));
1683 type = TYPE_MAIN_VARIANT (type);
1684 if (!COMPLETE_OR_OPEN_TYPE_P (complete_type (type)))
1686 error ("incomplete type %qT does not have member %qD", type, member);
1687 return error_mark_node;
1690 /* Entities other than non-static members need no further
1692 if (TREE_CODE (member) == TYPE_DECL)
1694 if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1695 return convert_from_reference (member);
1697 if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1699 error ("invalid pointer to bit-field %qD", member);
1700 return error_mark_node;
1703 /* Set up BASEBINFO for member lookup. */
1704 decl = maybe_dummy_object (type, &basebinfo);
1706 /* A lot of this logic is now handled in lookup_member. */
1707 if (BASELINK_P (member))
1709 /* Go from the TREE_BASELINK to the member function info. */
1710 tree t = BASELINK_FUNCTIONS (member);
1712 if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1714 /* Get rid of a potential OVERLOAD around it. */
1715 t = OVL_CURRENT (t);
1717 /* Unique functions are handled easily. */
1719 /* For non-static member of base class, we need a special rule
1720 for access checking [class.protected]:
1722 If the access is to form a pointer to member, the
1723 nested-name-specifier shall name the derived class
1724 (or any class derived from that class). */
1725 if (address_p && DECL_P (t)
1726 && DECL_NONSTATIC_MEMBER_P (t))
1727 perform_or_defer_access_check (TYPE_BINFO (type), t, t);
1729 perform_or_defer_access_check (basebinfo, t, t);
1731 if (DECL_STATIC_FUNCTION_P (t))
1736 TREE_TYPE (member) = unknown_type_node;
1738 else if (address_p && TREE_CODE (member) == FIELD_DECL)
1739 /* We need additional test besides the one in
1740 check_accessibility_of_qualified_id in case it is
1741 a pointer to non-static member. */
1742 perform_or_defer_access_check (TYPE_BINFO (type), member, member);
1746 /* If MEMBER is non-static, then the program has fallen afoul of
1749 An id-expression that denotes a nonstatic data member or
1750 nonstatic member function of a class can only be used:
1752 -- as part of a class member access (_expr.ref_) in which the
1753 object-expression refers to the member's class or a class
1754 derived from that class, or
1756 -- to form a pointer to member (_expr.unary.op_), or
1758 -- in the body of a nonstatic member function of that class or
1759 of a class derived from that class (_class.mfct.nonstatic_), or
1761 -- in a mem-initializer for a constructor for that class or for
1762 a class derived from that class (_class.base.init_). */
1763 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1765 /* Build a representation of the qualified name suitable
1766 for use as the operand to "&" -- even though the "&" is
1767 not actually present. */
1768 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1769 /* In Microsoft mode, treat a non-static member function as if
1770 it were a pointer-to-member. */
1771 if (flag_ms_extensions)
1773 PTRMEM_OK_P (member) = 1;
1774 return cp_build_addr_expr (member, tf_warning_or_error);
1776 error ("invalid use of non-static member function %qD",
1777 TREE_OPERAND (member, 1));
1778 return error_mark_node;
1780 else if (TREE_CODE (member) == FIELD_DECL)
1782 error ("invalid use of non-static data member %qD", member);
1783 return error_mark_node;
1788 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1789 PTRMEM_OK_P (member) = 1;
1793 /* If DECL is a scalar enumeration constant or variable with a
1794 constant initializer, return the initializer (or, its initializers,
1795 recursively); otherwise, return DECL. If INTEGRAL_P, the
1796 initializer is only returned if DECL is an integral
1797 constant-expression. */
1800 constant_value_1 (tree decl, bool integral_p)
1802 while (TREE_CODE (decl) == CONST_DECL
1804 ? decl_constant_var_p (decl)
1805 : (TREE_CODE (decl) == VAR_DECL
1806 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))))
1809 /* If DECL is a static data member in a template
1810 specialization, we must instantiate it here. The
1811 initializer for the static data member is not processed
1812 until needed; we need it now. */
1814 mark_rvalue_use (decl);
1815 init = DECL_INITIAL (decl);
1816 if (init == error_mark_node)
1818 if (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
1819 /* Treat the error as a constant to avoid cascading errors on
1820 excessively recursive template instantiation (c++/9335). */
1825 /* Initializers in templates are generally expanded during
1826 instantiation, so before that for const int i(2)
1827 INIT is a TREE_LIST with the actual initializer as
1829 if (processing_template_decl
1831 && TREE_CODE (init) == TREE_LIST
1832 && TREE_CHAIN (init) == NULL_TREE)
1833 init = TREE_VALUE (init);
1835 || !TREE_TYPE (init)
1836 || !TREE_CONSTANT (init)
1838 /* Do not return an aggregate constant (of which
1839 string literals are a special case), as we do not
1840 want to make inadvertent copies of such entities,
1841 and we must be sure that their addresses are the
1843 && (TREE_CODE (init) == CONSTRUCTOR
1844 || TREE_CODE (init) == STRING_CST)))
1846 decl = unshare_expr (init);
1851 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1852 constant of integral or enumeration type, then return that value.
1853 These are those variables permitted in constant expressions by
1857 integral_constant_value (tree decl)
1859 return constant_value_1 (decl, /*integral_p=*/true);
1862 /* A more relaxed version of integral_constant_value, used by the
1863 common C/C++ code and by the C++ front end for optimization
1867 decl_constant_value (tree decl)
1869 return constant_value_1 (decl,
1870 /*integral_p=*/processing_template_decl);
1873 /* Common subroutines of build_new and build_vec_delete. */
1875 /* Call the global __builtin_delete to delete ADDR. */
1878 build_builtin_delete_call (tree addr)
1880 mark_used (global_delete_fndecl);
1881 return build_call_n (global_delete_fndecl, 1, addr);
1884 /* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
1885 the type of the object being allocated; otherwise, it's just TYPE.
1886 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
1887 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
1888 a vector of arguments to be provided as arguments to a placement
1889 new operator. This routine performs no semantic checks; it just
1890 creates and returns a NEW_EXPR. */
1893 build_raw_new_expr (VEC(tree,gc) *placement, tree type, tree nelts,
1894 VEC(tree,gc) *init, int use_global_new)
1899 /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR.
1900 If INIT is not NULL, then we want to store VOID_ZERO_NODE. This
1901 permits us to distinguish the case of a missing initializer "new
1902 int" from an empty initializer "new int()". */
1904 init_list = NULL_TREE;
1905 else if (VEC_empty (tree, init))
1906 init_list = void_zero_node;
1908 init_list = build_tree_list_vec (init);
1910 new_expr = build4 (NEW_EXPR, build_pointer_type (type),
1911 build_tree_list_vec (placement), type, nelts,
1913 NEW_EXPR_USE_GLOBAL (new_expr) = use_global_new;
1914 TREE_SIDE_EFFECTS (new_expr) = 1;
1919 /* Diagnose uninitialized const members or reference members of type
1920 TYPE. USING_NEW is used to disambiguate the diagnostic between a
1921 new expression without a new-initializer and a declaration. Returns
1925 diagnose_uninitialized_cst_or_ref_member_1 (tree type, tree origin,
1926 bool using_new, bool complain)
1929 int error_count = 0;
1931 if (type_has_user_provided_constructor (type))
1934 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
1938 if (TREE_CODE (field) != FIELD_DECL)
1941 field_type = strip_array_types (TREE_TYPE (field));
1943 if (type_has_user_provided_constructor (field_type))
1946 if (TREE_CODE (field_type) == REFERENCE_TYPE)
1952 error ("uninitialized reference member in %q#T "
1953 "using %<new%> without new-initializer", origin);
1955 error ("uninitialized reference member in %q#T", origin);
1956 inform (DECL_SOURCE_LOCATION (field),
1957 "%qD should be initialized", field);
1961 if (CP_TYPE_CONST_P (field_type))
1967 error ("uninitialized const member in %q#T "
1968 "using %<new%> without new-initializer", origin);
1970 error ("uninitialized const member in %q#T", origin);
1971 inform (DECL_SOURCE_LOCATION (field),
1972 "%qD should be initialized", field);
1976 if (CLASS_TYPE_P (field_type))
1978 += diagnose_uninitialized_cst_or_ref_member_1 (field_type, origin,
1979 using_new, complain);
1985 diagnose_uninitialized_cst_or_ref_member (tree type, bool using_new, bool complain)
1987 return diagnose_uninitialized_cst_or_ref_member_1 (type, type, using_new, complain);
1990 /* Generate code for a new-expression, including calling the "operator
1991 new" function, initializing the object, and, if an exception occurs
1992 during construction, cleaning up. The arguments are as for
1993 build_raw_new_expr. This may change PLACEMENT and INIT. */
1996 build_new_1 (VEC(tree,gc) **placement, tree type, tree nelts,
1997 VEC(tree,gc) **init, bool globally_qualified_p,
1998 tsubst_flags_t complain)
2001 /* True iff this is a call to "operator new[]" instead of just
2003 bool array_p = false;
2004 /* If ARRAY_P is true, the element type of the array. This is never
2005 an ARRAY_TYPE; for something like "new int[3][4]", the
2006 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
2009 /* The type of the new-expression. (This type is always a pointer
2012 tree non_const_pointer_type;
2013 tree outer_nelts = NULL_TREE;
2014 tree alloc_call, alloc_expr;
2015 /* The address returned by the call to "operator new". This node is
2016 a VAR_DECL and is therefore reusable. */
2019 tree cookie_expr, init_expr;
2020 int nothrow, check_new;
2021 int use_java_new = 0;
2022 /* If non-NULL, the number of extra bytes to allocate at the
2023 beginning of the storage allocated for an array-new expression in
2024 order to store the number of elements. */
2025 tree cookie_size = NULL_TREE;
2026 tree placement_first;
2027 tree placement_expr = NULL_TREE;
2028 /* True if the function we are calling is a placement allocation
2030 bool placement_allocation_fn_p;
2031 /* True if the storage must be initialized, either by a constructor
2032 or due to an explicit new-initializer. */
2033 bool is_initialized;
2034 /* The address of the thing allocated, not including any cookie. In
2035 particular, if an array cookie is in use, DATA_ADDR is the
2036 address of the first array element. This node is a VAR_DECL, and
2037 is therefore reusable. */
2039 tree init_preeval_expr = NULL_TREE;
2043 outer_nelts = nelts;
2046 else if (TREE_CODE (type) == ARRAY_TYPE)
2049 nelts = array_type_nelts_top (type);
2050 outer_nelts = nelts;
2051 type = TREE_TYPE (type);
2054 /* If our base type is an array, then make sure we know how many elements
2056 for (elt_type = type;
2057 TREE_CODE (elt_type) == ARRAY_TYPE;
2058 elt_type = TREE_TYPE (elt_type))
2059 nelts = cp_build_binary_op (input_location,
2061 array_type_nelts_top (elt_type),
2064 if (TREE_CODE (elt_type) == VOID_TYPE)
2066 if (complain & tf_error)
2067 error ("invalid type %<void%> for new");
2068 return error_mark_node;
2071 if (abstract_virtuals_error_sfinae (NULL_TREE, elt_type, complain))
2072 return error_mark_node;
2074 is_initialized = (type_build_ctor_call (elt_type) || *init != NULL);
2078 bool maybe_uninitialized_error = false;
2079 /* A program that calls for default-initialization [...] of an
2080 entity of reference type is ill-formed. */
2081 if (CLASSTYPE_REF_FIELDS_NEED_INIT (elt_type))
2082 maybe_uninitialized_error = true;
2084 /* A new-expression that creates an object of type T initializes
2085 that object as follows:
2086 - If the new-initializer is omitted:
2087 -- If T is a (possibly cv-qualified) non-POD class type
2088 (or array thereof), the object is default-initialized (8.5).
2090 -- Otherwise, the object created has indeterminate
2091 value. If T is a const-qualified type, or a (possibly
2092 cv-qualified) POD class type (or array thereof)
2093 containing (directly or indirectly) a member of
2094 const-qualified type, the program is ill-formed; */
2096 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (elt_type))
2097 maybe_uninitialized_error = true;
2099 if (maybe_uninitialized_error
2100 && diagnose_uninitialized_cst_or_ref_member (elt_type,
2102 complain & tf_error))
2103 return error_mark_node;
2106 if (CP_TYPE_CONST_P (elt_type) && *init == NULL
2107 && default_init_uninitialized_part (elt_type))
2109 if (complain & tf_error)
2110 error ("uninitialized const in %<new%> of %q#T", elt_type);
2111 return error_mark_node;
2114 size = size_in_bytes (elt_type);
2116 size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
2118 alloc_fn = NULL_TREE;
2120 /* If PLACEMENT is a single simple pointer type not passed by
2121 reference, prepare to capture it in a temporary variable. Do
2122 this now, since PLACEMENT will change in the calls below. */
2123 placement_first = NULL_TREE;
2124 if (VEC_length (tree, *placement) == 1
2125 && (TREE_CODE (TREE_TYPE (VEC_index (tree, *placement, 0)))
2127 placement_first = VEC_index (tree, *placement, 0);
2129 /* Allocate the object. */
2130 if (VEC_empty (tree, *placement) && TYPE_FOR_JAVA (elt_type))
2133 tree class_decl = build_java_class_ref (elt_type);
2134 static const char alloc_name[] = "_Jv_AllocObject";
2136 if (class_decl == error_mark_node)
2137 return error_mark_node;
2140 if (!get_global_value_if_present (get_identifier (alloc_name),
2143 if (complain & tf_error)
2144 error ("call to Java constructor with %qs undefined", alloc_name);
2145 return error_mark_node;
2147 else if (really_overloaded_fn (alloc_fn))
2149 if (complain & tf_error)
2150 error ("%qD should never be overloaded", alloc_fn);
2151 return error_mark_node;
2153 alloc_fn = OVL_CURRENT (alloc_fn);
2154 class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
2155 alloc_call = cp_build_function_call_nary (alloc_fn, complain,
2156 class_addr, NULL_TREE);
2158 else if (TYPE_FOR_JAVA (elt_type) && MAYBE_CLASS_TYPE_P (elt_type))
2160 error ("Java class %q#T object allocated using placement new", elt_type);
2161 return error_mark_node;
2168 fnname = ansi_opname (array_p ? VEC_NEW_EXPR : NEW_EXPR);
2170 if (!globally_qualified_p
2171 && CLASS_TYPE_P (elt_type)
2173 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
2174 : TYPE_HAS_NEW_OPERATOR (elt_type)))
2176 /* Use a class-specific operator new. */
2177 /* If a cookie is required, add some extra space. */
2178 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
2180 cookie_size = targetm.cxx.get_cookie_size (elt_type);
2181 size = size_binop (PLUS_EXPR, size, cookie_size);
2183 /* Create the argument list. */
2184 VEC_safe_insert (tree, gc, *placement, 0, size);
2185 /* Do name-lookup to find the appropriate operator. */
2186 fns = lookup_fnfields (elt_type, fnname, /*protect=*/2);
2187 if (fns == NULL_TREE)
2189 if (complain & tf_error)
2190 error ("no suitable %qD found in class %qT", fnname, elt_type);
2191 return error_mark_node;
2193 if (TREE_CODE (fns) == TREE_LIST)
2195 if (complain & tf_error)
2197 error ("request for member %qD is ambiguous", fnname);
2198 print_candidates (fns);
2200 return error_mark_node;
2202 alloc_call = build_new_method_call (build_dummy_object (elt_type),
2204 /*conversion_path=*/NULL_TREE,
2211 /* Use a global operator new. */
2212 /* See if a cookie might be required. */
2213 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
2214 cookie_size = targetm.cxx.get_cookie_size (elt_type);
2216 cookie_size = NULL_TREE;
2218 alloc_call = build_operator_new_call (fnname, placement,
2219 &size, &cookie_size,
2224 if (alloc_call == error_mark_node)
2225 return error_mark_node;
2227 gcc_assert (alloc_fn != NULL_TREE);
2229 /* If we found a simple case of PLACEMENT_EXPR above, then copy it
2230 into a temporary variable. */
2231 if (!processing_template_decl
2232 && placement_first != NULL_TREE
2233 && TREE_CODE (alloc_call) == CALL_EXPR
2234 && call_expr_nargs (alloc_call) == 2
2235 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 0))) == INTEGER_TYPE
2236 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 1))) == POINTER_TYPE)
2238 tree placement_arg = CALL_EXPR_ARG (alloc_call, 1);
2240 if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg)))
2241 || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg))))
2243 placement_expr = get_target_expr (placement_first);
2244 CALL_EXPR_ARG (alloc_call, 1)
2245 = convert (TREE_TYPE (placement_arg), placement_expr);
2249 /* In the simple case, we can stop now. */
2250 pointer_type = build_pointer_type (type);
2251 if (!cookie_size && !is_initialized)
2252 return build_nop (pointer_type, alloc_call);
2254 /* Store the result of the allocation call in a variable so that we can
2255 use it more than once. */
2256 alloc_expr = get_target_expr (alloc_call);
2257 alloc_node = TARGET_EXPR_SLOT (alloc_expr);
2259 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
2260 while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
2261 alloc_call = TREE_OPERAND (alloc_call, 1);
2263 /* Now, check to see if this function is actually a placement
2264 allocation function. This can happen even when PLACEMENT is NULL
2265 because we might have something like:
2267 struct S { void* operator new (size_t, int i = 0); };
2269 A call to `new S' will get this allocation function, even though
2270 there is no explicit placement argument. If there is more than
2271 one argument, or there are variable arguments, then this is a
2272 placement allocation function. */
2273 placement_allocation_fn_p
2274 = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
2275 || varargs_function_p (alloc_fn));
2277 /* Preevaluate the placement args so that we don't reevaluate them for a
2278 placement delete. */
2279 if (placement_allocation_fn_p)
2282 stabilize_call (alloc_call, &inits);
2284 alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
2288 /* unless an allocation function is declared with an empty excep-
2289 tion-specification (_except.spec_), throw(), it indicates failure to
2290 allocate storage by throwing a bad_alloc exception (clause _except_,
2291 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2292 cation function is declared with an empty exception-specification,
2293 throw(), it returns null to indicate failure to allocate storage and a
2294 non-null pointer otherwise.
2296 So check for a null exception spec on the op new we just called. */
2298 nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
2299 check_new = (flag_check_new || nothrow) && ! use_java_new;
2307 /* Adjust so we're pointing to the start of the object. */
2308 data_addr = fold_build_pointer_plus (alloc_node, cookie_size);
2310 /* Store the number of bytes allocated so that we can know how
2311 many elements to destroy later. We use the last sizeof
2312 (size_t) bytes to store the number of elements. */
2313 cookie_ptr = size_binop (MINUS_EXPR, cookie_size, size_in_bytes (sizetype));
2314 cookie_ptr = fold_build_pointer_plus_loc (input_location,
2315 alloc_node, cookie_ptr);
2316 size_ptr_type = build_pointer_type (sizetype);
2317 cookie_ptr = fold_convert (size_ptr_type, cookie_ptr);
2318 cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
2320 cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
2322 if (targetm.cxx.cookie_has_size ())
2324 /* Also store the element size. */
2325 cookie_ptr = fold_build_pointer_plus (cookie_ptr,
2326 fold_build1_loc (input_location,
2327 NEGATE_EXPR, sizetype,
2328 size_in_bytes (sizetype)));
2330 cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
2331 cookie = build2 (MODIFY_EXPR, sizetype, cookie,
2332 size_in_bytes (elt_type));
2333 cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
2334 cookie, cookie_expr);
2339 cookie_expr = NULL_TREE;
2340 data_addr = alloc_node;
2343 /* Now use a pointer to the type we've actually allocated. */
2345 /* But we want to operate on a non-const version to start with,
2346 since we'll be modifying the elements. */
2347 non_const_pointer_type = build_pointer_type
2348 (cp_build_qualified_type (type, cp_type_quals (type) & ~TYPE_QUAL_CONST));
2350 data_addr = fold_convert (non_const_pointer_type, data_addr);
2351 /* Any further uses of alloc_node will want this type, too. */
2352 alloc_node = fold_convert (non_const_pointer_type, alloc_node);
2354 /* Now initialize the allocated object. Note that we preevaluate the
2355 initialization expression, apart from the actual constructor call or
2356 assignment--we do this because we want to delay the allocation as long
2357 as possible in order to minimize the size of the exception region for
2358 placement delete. */
2362 bool explicit_value_init_p = false;
2364 if (*init != NULL && VEC_empty (tree, *init))
2367 explicit_value_init_p = true;
2370 if (processing_template_decl && explicit_value_init_p)
2372 /* build_value_init doesn't work in templates, and we don't need
2373 the initializer anyway since we're going to throw it away and
2374 rebuild it at instantiation time, so just build up a single
2375 constructor call to get any appropriate diagnostics. */
2376 init_expr = cp_build_indirect_ref (data_addr, RO_NULL, complain);
2377 if (type_build_ctor_call (elt_type))
2378 init_expr = build_special_member_call (init_expr,
2379 complete_ctor_identifier,
2383 stable = stabilize_init (init_expr, &init_preeval_expr);
2387 tree vecinit = NULL_TREE;
2388 if (*init && VEC_length (tree, *init) == 1
2389 && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *init, 0))
2390 && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *init, 0)))
2392 vecinit = VEC_index (tree, *init, 0);
2393 if (CONSTRUCTOR_NELTS (vecinit) == 0)
2394 /* List-value-initialization, leave it alone. */;
2397 tree arraytype, domain;
2398 if (TREE_CONSTANT (nelts))
2399 domain = compute_array_index_type (NULL_TREE, nelts,
2404 if (CONSTRUCTOR_NELTS (vecinit) > 0)
2405 warning (0, "non-constant array size in new, unable "
2406 "to verify length of initializer-list");
2408 arraytype = build_cplus_array_type (type, domain);
2409 vecinit = digest_init (arraytype, vecinit, complain);
2414 if (complain & tf_error)
2415 permerror (input_location,
2416 "parenthesized initializer in array new");
2418 return error_mark_node;
2419 vecinit = build_tree_list_vec (*init);
2422 = build_vec_init (data_addr,
2423 cp_build_binary_op (input_location,
2424 MINUS_EXPR, outer_nelts,
2428 explicit_value_init_p,
2432 /* An array initialization is stable because the initialization
2433 of each element is a full-expression, so the temporaries don't
2439 init_expr = cp_build_indirect_ref (data_addr, RO_NULL, complain);
2441 if (type_build_ctor_call (type) && !explicit_value_init_p)
2443 init_expr = build_special_member_call (init_expr,
2444 complete_ctor_identifier,
2449 else if (explicit_value_init_p)
2451 /* Something like `new int()'. */
2452 tree val = build_value_init (type, complain);
2453 if (val == error_mark_node)
2454 return error_mark_node;
2455 init_expr = build2 (INIT_EXPR, type, init_expr, val);
2461 /* We are processing something like `new int (10)', which
2462 means allocate an int, and initialize it with 10. */
2464 ie = build_x_compound_expr_from_vec (*init, "new initializer");
2465 init_expr = cp_build_modify_expr (init_expr, INIT_EXPR, ie,
2468 stable = stabilize_init (init_expr, &init_preeval_expr);
2471 if (init_expr == error_mark_node)
2472 return error_mark_node;
2474 /* If any part of the object initialization terminates by throwing an
2475 exception and a suitable deallocation function can be found, the
2476 deallocation function is called to free the memory in which the
2477 object was being constructed, after which the exception continues
2478 to propagate in the context of the new-expression. If no
2479 unambiguous matching deallocation function can be found,
2480 propagating the exception does not cause the object's memory to be
2482 if (flag_exceptions && ! use_java_new)
2484 enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
2487 /* The Standard is unclear here, but the right thing to do
2488 is to use the same method for finding deallocation
2489 functions that we use for finding allocation functions. */
2490 cleanup = (build_op_delete_call
2494 globally_qualified_p,
2495 placement_allocation_fn_p ? alloc_call : NULL_TREE,
2501 /* This is much simpler if we were able to preevaluate all of
2502 the arguments to the constructor call. */
2504 /* CLEANUP is compiler-generated, so no diagnostics. */
2505 TREE_NO_WARNING (cleanup) = true;
2506 init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2507 init_expr, cleanup);
2508 /* Likewise, this try-catch is compiler-generated. */
2509 TREE_NO_WARNING (init_expr) = true;
2512 /* Ack! First we allocate the memory. Then we set our sentry
2513 variable to true, and expand a cleanup that deletes the
2514 memory if sentry is true. Then we run the constructor, and
2515 finally clear the sentry.
2517 We need to do this because we allocate the space first, so
2518 if there are any temporaries with cleanups in the
2519 constructor args and we weren't able to preevaluate them, we
2520 need this EH region to extend until end of full-expression
2521 to preserve nesting. */
2523 tree end, sentry, begin;
2525 begin = get_target_expr (boolean_true_node);
2526 CLEANUP_EH_ONLY (begin) = 1;
2528 sentry = TARGET_EXPR_SLOT (begin);
2530 /* CLEANUP is compiler-generated, so no diagnostics. */
2531 TREE_NO_WARNING (cleanup) = true;
2533 TARGET_EXPR_CLEANUP (begin)
2534 = build3 (COND_EXPR, void_type_node, sentry,
2535 cleanup, void_zero_node);
2537 end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2538 sentry, boolean_false_node);
2541 = build2 (COMPOUND_EXPR, void_type_node, begin,
2542 build2 (COMPOUND_EXPR, void_type_node, init_expr,
2544 /* Likewise, this is compiler-generated. */
2545 TREE_NO_WARNING (init_expr) = true;
2550 init_expr = NULL_TREE;
2552 /* Now build up the return value in reverse order. */
2557 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2559 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2561 if (rval == data_addr)
2562 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2563 and return the call (which doesn't need to be adjusted). */
2564 rval = TARGET_EXPR_INITIAL (alloc_expr);
2569 tree ifexp = cp_build_binary_op (input_location,
2570 NE_EXPR, alloc_node,
2573 rval = build_conditional_expr (ifexp, rval, alloc_node,
2577 /* Perform the allocation before anything else, so that ALLOC_NODE
2578 has been initialized before we start using it. */
2579 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2582 if (init_preeval_expr)
2583 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2585 /* A new-expression is never an lvalue. */
2586 gcc_assert (!lvalue_p (rval));
2588 return convert (pointer_type, rval);
2591 /* Generate a representation for a C++ "new" expression. *PLACEMENT
2592 is a vector of placement-new arguments (or NULL if none). If NELTS
2593 is NULL, TYPE is the type of the storage to be allocated. If NELTS
2594 is not NULL, then this is an array-new allocation; TYPE is the type
2595 of the elements in the array and NELTS is the number of elements in
2596 the array. *INIT, if non-NULL, is the initializer for the new
2597 object, or an empty vector to indicate an initializer of "()". If
2598 USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
2599 rather than just "new". This may change PLACEMENT and INIT. */
2602 build_new (VEC(tree,gc) **placement, tree type, tree nelts,
2603 VEC(tree,gc) **init, int use_global_new, tsubst_flags_t complain)
2606 VEC(tree,gc) *orig_placement = NULL;
2607 tree orig_nelts = NULL_TREE;
2608 VEC(tree,gc) *orig_init = NULL;
2610 if (type == error_mark_node)
2611 return error_mark_node;
2613 if (nelts == NULL_TREE && VEC_length (tree, *init) == 1)
2615 tree auto_node = type_uses_auto (type);
2618 tree d_init = VEC_index (tree, *init, 0);
2619 d_init = resolve_nondeduced_context (d_init);
2620 type = do_auto_deduction (type, d_init, auto_node);
2624 if (processing_template_decl)
2626 if (dependent_type_p (type)
2627 || any_type_dependent_arguments_p (*placement)
2628 || (nelts && type_dependent_expression_p (nelts))
2629 || any_type_dependent_arguments_p (*init))
2630 return build_raw_new_expr (*placement, type, nelts, *init,
2633 orig_placement = make_tree_vector_copy (*placement);
2635 orig_init = make_tree_vector_copy (*init);
2637 make_args_non_dependent (*placement);
2639 nelts = build_non_dependent_expr (nelts);
2640 make_args_non_dependent (*init);
2645 if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
2647 if (complain & tf_error)
2648 permerror (input_location, "size in array new must have integral type");
2650 return error_mark_node;
2652 nelts = mark_rvalue_use (nelts);
2653 nelts = cp_save_expr (cp_convert (sizetype, nelts));
2656 /* ``A reference cannot be created by the new operator. A reference
2657 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2658 returned by new.'' ARM 5.3.3 */
2659 if (TREE_CODE (type) == REFERENCE_TYPE)
2661 if (complain & tf_error)
2662 error ("new cannot be applied to a reference type");
2664 return error_mark_node;
2665 type = TREE_TYPE (type);
2668 if (TREE_CODE (type) == FUNCTION_TYPE)
2670 if (complain & tf_error)
2671 error ("new cannot be applied to a function type");
2672 return error_mark_node;
2675 /* The type allocated must be complete. If the new-type-id was
2676 "T[N]" then we are just checking that "T" is complete here, but
2677 that is equivalent, since the value of "N" doesn't matter. */
2678 if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
2679 return error_mark_node;
2681 rval = build_new_1 (placement, type, nelts, init, use_global_new, complain);
2682 if (rval == error_mark_node)
2683 return error_mark_node;
2685 if (processing_template_decl)
2687 tree ret = build_raw_new_expr (orig_placement, type, orig_nelts,
2688 orig_init, use_global_new);
2689 release_tree_vector (orig_placement);
2690 release_tree_vector (orig_init);
2694 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2695 rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
2696 TREE_NO_WARNING (rval) = 1;
2701 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2704 build_java_class_ref (tree type)
2706 tree name = NULL_TREE, class_decl;
2707 static tree CL_suffix = NULL_TREE;
2708 if (CL_suffix == NULL_TREE)
2709 CL_suffix = get_identifier("class$");
2710 if (jclass_node == NULL_TREE)
2712 jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2713 if (jclass_node == NULL_TREE)
2715 error ("call to Java constructor, while %<jclass%> undefined");
2716 return error_mark_node;
2718 jclass_node = TREE_TYPE (jclass_node);
2721 /* Mangle the class$ field. */
2724 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
2725 if (DECL_NAME (field) == CL_suffix)
2727 mangle_decl (field);
2728 name = DECL_ASSEMBLER_NAME (field);
2733 error ("can%'t find %<class$%> in %qT", type);
2734 return error_mark_node;
2738 class_decl = IDENTIFIER_GLOBAL_VALUE (name);
2739 if (class_decl == NULL_TREE)
2741 class_decl = build_decl (input_location,
2742 VAR_DECL, name, TREE_TYPE (jclass_node));
2743 TREE_STATIC (class_decl) = 1;
2744 DECL_EXTERNAL (class_decl) = 1;
2745 TREE_PUBLIC (class_decl) = 1;
2746 DECL_ARTIFICIAL (class_decl) = 1;
2747 DECL_IGNORED_P (class_decl) = 1;
2748 pushdecl_top_level (class_decl);
2749 make_decl_rtl (class_decl);
2755 build_vec_delete_1 (tree base, tree maxindex, tree type,
2756 special_function_kind auto_delete_vec,
2757 int use_global_delete, tsubst_flags_t complain)
2760 tree ptype = build_pointer_type (type = complete_type (type));
2761 tree size_exp = size_in_bytes (type);
2763 /* Temporary variables used by the loop. */
2764 tree tbase, tbase_init;
2766 /* This is the body of the loop that implements the deletion of a
2767 single element, and moves temp variables to next elements. */
2770 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2773 /* This is the thing that governs what to do after the loop has run. */
2774 tree deallocate_expr = 0;
2776 /* This is the BIND_EXPR which holds the outermost iterator of the
2777 loop. It is convenient to set this variable up and test it before
2778 executing any other code in the loop.
2779 This is also the containing expression returned by this function. */
2780 tree controller = NULL_TREE;
2783 /* We should only have 1-D arrays here. */
2784 gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2786 if (base == error_mark_node || maxindex == error_mark_node)
2787 return error_mark_node;
2789 if (! MAYBE_CLASS_TYPE_P (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2792 /* The below is short by the cookie size. */
2793 virtual_size = size_binop (MULT_EXPR, size_exp,
2794 convert (sizetype, maxindex));
2796 tbase = create_temporary_var (ptype);
2798 = cp_build_modify_expr (tbase, NOP_EXPR,
2799 fold_build_pointer_plus_loc (input_location,
2800 fold_convert (ptype,
2804 if (tbase_init == error_mark_node)
2805 return error_mark_node;
2806 controller = build3 (BIND_EXPR, void_type_node, tbase,
2807 NULL_TREE, NULL_TREE);
2808 TREE_SIDE_EFFECTS (controller) = 1;
2810 body = build1 (EXIT_EXPR, void_type_node,
2811 build2 (EQ_EXPR, boolean_type_node, tbase,
2812 fold_convert (ptype, base)));
2813 tmp = fold_build1_loc (input_location, NEGATE_EXPR, sizetype, size_exp);
2814 tmp = fold_build_pointer_plus (tbase, tmp);
2815 tmp = cp_build_modify_expr (tbase, NOP_EXPR, tmp, complain);
2816 if (tmp == error_mark_node)
2817 return error_mark_node;
2818 body = build_compound_expr (input_location, body, tmp);
2819 tmp = build_delete (ptype, tbase, sfk_complete_destructor,
2820 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1,
2822 if (tmp == error_mark_node)
2823 return error_mark_node;
2824 body = build_compound_expr (input_location, body, tmp);
2826 loop = build1 (LOOP_EXPR, void_type_node, body);
2827 loop = build_compound_expr (input_location, tbase_init, loop);
2830 /* Delete the storage if appropriate. */
2831 if (auto_delete_vec == sfk_deleting_destructor)
2835 /* The below is short by the cookie size. */
2836 virtual_size = size_binop (MULT_EXPR, size_exp,
2837 convert (sizetype, maxindex));
2839 if (! TYPE_VEC_NEW_USES_COOKIE (type))
2846 cookie_size = targetm.cxx.get_cookie_size (type);
2847 base_tbd = cp_build_binary_op (input_location,
2849 cp_convert (string_type_node,
2853 if (base_tbd == error_mark_node)
2854 return error_mark_node;
2855 base_tbd = cp_convert (ptype, base_tbd);
2856 /* True size with header. */
2857 virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2860 deallocate_expr = build_op_delete_call (VEC_DELETE_EXPR,
2861 base_tbd, virtual_size,
2862 use_global_delete & 1,
2863 /*placement=*/NULL_TREE,
2864 /*alloc_fn=*/NULL_TREE);
2868 if (!deallocate_expr)
2871 body = deallocate_expr;
2873 body = build_compound_expr (input_location, body, deallocate_expr);
2876 body = integer_zero_node;
2878 /* Outermost wrapper: If pointer is null, punt. */
2879 body = fold_build3_loc (input_location, COND_EXPR, void_type_node,
2880 fold_build2_loc (input_location,
2881 NE_EXPR, boolean_type_node, base,
2882 convert (TREE_TYPE (base),
2883 integer_zero_node)),
2884 body, integer_zero_node);
2885 body = build1 (NOP_EXPR, void_type_node, body);
2889 TREE_OPERAND (controller, 1) = body;
2893 if (TREE_CODE (base) == SAVE_EXPR)
2894 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
2895 body = build2 (COMPOUND_EXPR, void_type_node, base, body);
2897 return convert_to_void (body, ICV_CAST, complain);
2900 /* Create an unnamed variable of the indicated TYPE. */
2903 create_temporary_var (tree type)
2907 decl = build_decl (input_location,
2908 VAR_DECL, NULL_TREE, type);
2909 TREE_USED (decl) = 1;
2910 DECL_ARTIFICIAL (decl) = 1;
2911 DECL_IGNORED_P (decl) = 1;
2912 DECL_CONTEXT (decl) = current_function_decl;
2917 /* Create a new temporary variable of the indicated TYPE, initialized
2920 It is not entered into current_binding_level, because that breaks
2921 things when it comes time to do final cleanups (which take place
2922 "outside" the binding contour of the function). */
2925 get_temp_regvar (tree type, tree init)
2929 decl = create_temporary_var (type);
2930 add_decl_expr (decl);
2932 finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,
2933 tf_warning_or_error));
2938 /* `build_vec_init' returns tree structure that performs
2939 initialization of a vector of aggregate types.
2941 BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
2942 to the first element, of POINTER_TYPE.
2943 MAXINDEX is the maximum index of the array (one less than the
2944 number of elements). It is only used if BASE is a pointer or
2945 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2947 INIT is the (possibly NULL) initializer.
2949 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All
2950 elements in the array are value-initialized.
2952 FROM_ARRAY is 0 if we should init everything with INIT
2953 (i.e., every element initialized from INIT).
2954 FROM_ARRAY is 1 if we should index into INIT in parallel
2955 with initialization of DECL.
2956 FROM_ARRAY is 2 if we should index into INIT in parallel,
2957 but use assignment instead of initialization. */
2960 build_vec_init (tree base, tree maxindex, tree init,
2961 bool explicit_value_init_p,
2962 int from_array, tsubst_flags_t complain)
2965 tree base2 = NULL_TREE;
2966 tree itype = NULL_TREE;
2968 /* The type of BASE. */
2969 tree atype = TREE_TYPE (base);
2970 /* The type of an element in the array. */
2971 tree type = TREE_TYPE (atype);
2972 /* The element type reached after removing all outer array
2974 tree inner_elt_type;
2975 /* The type of a pointer to an element in the array. */
2980 tree try_block = NULL_TREE;
2981 int num_initialized_elts = 0;
2983 tree const_init = NULL_TREE;
2985 bool xvalue = false;
2986 bool errors = false;
2988 if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype))
2989 maxindex = array_type_nelts (atype);
2991 if (maxindex == NULL_TREE || maxindex == error_mark_node)
2992 return error_mark_node;
2994 if (explicit_value_init_p)
2997 inner_elt_type = strip_array_types (type);
2999 /* Look through the TARGET_EXPR around a compound literal. */
3000 if (init && TREE_CODE (init) == TARGET_EXPR
3001 && TREE_CODE (TARGET_EXPR_INITIAL (init)) == CONSTRUCTOR
3003 init = TARGET_EXPR_INITIAL (init);
3006 && TREE_CODE (atype) == ARRAY_TYPE
3008 ? (!CLASS_TYPE_P (inner_elt_type)
3009 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (inner_elt_type))
3010 : !TYPE_NEEDS_CONSTRUCTING (type))
3011 && ((TREE_CODE (init) == CONSTRUCTOR
3012 /* Don't do this if the CONSTRUCTOR might contain something
3013 that might throw and require us to clean up. */
3014 && (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))
3015 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
3018 /* Do non-default initialization of trivial arrays resulting from
3019 brace-enclosed initializers. In this case, digest_init and
3020 store_constructor will handle the semantics for us. */
3022 stmt_expr = build2 (INIT_EXPR, atype, base, init);
3026 maxindex = cp_convert (ptrdiff_type_node, maxindex);
3027 if (TREE_CODE (atype) == ARRAY_TYPE)
3029 ptype = build_pointer_type (type);
3030 base = cp_convert (ptype, decay_conversion (base));
3035 /* The code we are generating looks like:
3039 ptrdiff_t iterator = maxindex;
3041 for (; iterator != -1; --iterator) {
3042 ... initialize *t1 ...
3046 ... destroy elements that were constructed ...
3051 We can omit the try and catch blocks if we know that the
3052 initialization will never throw an exception, or if the array
3053 elements do not have destructors. We can omit the loop completely if
3054 the elements of the array do not have constructors.
3056 We actually wrap the entire body of the above in a STMT_EXPR, for
3059 When copying from array to another, when the array elements have
3060 only trivial copy constructors, we should use __builtin_memcpy
3061 rather than generating a loop. That way, we could take advantage
3062 of whatever cleverness the back end has for dealing with copies
3063 of blocks of memory. */
3065 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
3066 destroy_temps = stmts_are_full_exprs_p ();
3067 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
3068 rval = get_temp_regvar (ptype, base);
3069 base = get_temp_regvar (ptype, rval);
3070 iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
3072 /* If initializing one array from another, initialize element by
3073 element. We rely upon the below calls to do the argument
3074 checking. Evaluate the initializer before entering the try block. */
3075 if (from_array && init && TREE_CODE (init) != CONSTRUCTOR)
3077 if (lvalue_kind (init) & clk_rvalueref)
3079 base2 = decay_conversion (init);
3080 itype = TREE_TYPE (base2);
3081 base2 = get_temp_regvar (itype, base2);
3082 itype = TREE_TYPE (itype);
3085 /* Protect the entire array initialization so that we can destroy
3086 the partially constructed array if an exception is thrown.
3087 But don't do this if we're assigning. */
3088 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
3091 try_block = begin_try_block ();
3094 /* If the initializer is {}, then all elements are initialized from {}.
3095 But for non-classes, that's the same as value-initialization. */
3096 if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
3097 && CONSTRUCTOR_NELTS (init) == 0)
3099 if (CLASS_TYPE_P (type))
3100 /* Leave init alone. */;
3104 explicit_value_init_p = true;
3108 /* Maybe pull out constant value when from_array? */
3110 else if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
3112 /* Do non-default initialization of non-trivial arrays resulting from
3113 brace-enclosed initializers. */
3114 unsigned HOST_WIDE_INT idx;
3116 /* Should we try to create a constant initializer? */
3117 bool try_const = (TREE_CODE (atype) == ARRAY_TYPE
3118 && (literal_type_p (inner_elt_type)
3119 || TYPE_HAS_CONSTEXPR_CTOR (inner_elt_type)));
3120 bool saw_non_const = false;
3121 bool saw_const = false;
3122 /* If we're initializing a static array, we want to do static
3123 initialization of any elements with constant initializers even if
3124 some are non-constant. */
3125 bool do_static_init = (DECL_P (obase) && TREE_STATIC (obase));
3126 VEC(constructor_elt,gc) *new_vec;
3130 new_vec = VEC_alloc (constructor_elt, gc, CONSTRUCTOR_NELTS (init));
3134 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx, field, elt)
3136 tree baseref = build1 (INDIRECT_REF, type, base);
3139 num_initialized_elts++;
3141 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
3142 if (MAYBE_CLASS_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
3143 one_init = build_aggr_init (baseref, elt, 0, complain);
3145 one_init = cp_build_modify_expr (baseref, NOP_EXPR,
3147 if (one_init == error_mark_node)
3152 if (TREE_CODE (e) == EXPR_STMT)
3153 e = TREE_OPERAND (e, 0);
3154 if (TREE_CODE (e) == CONVERT_EXPR
3155 && VOID_TYPE_P (TREE_TYPE (e)))
3156 e = TREE_OPERAND (e, 0);
3157 e = maybe_constant_init (e);
3158 if (reduced_constant_expression_p (e))
3160 CONSTRUCTOR_APPEND_ELT (new_vec, field, e);
3162 one_init = NULL_TREE;
3164 one_init = build2 (INIT_EXPR, type, baseref, e);
3170 CONSTRUCTOR_APPEND_ELT (new_vec, field,
3171 build_zero_init (TREE_TYPE (e),
3173 saw_non_const = true;
3178 finish_expr_stmt (one_init);
3179 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
3181 one_init = cp_build_unary_op (PREINCREMENT_EXPR, base, 0, complain);
3182 if (one_init == error_mark_node)
3185 finish_expr_stmt (one_init);
3187 one_init = cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
3189 if (one_init == error_mark_node)
3192 finish_expr_stmt (one_init);
3198 const_init = build_constructor (atype, new_vec);
3199 else if (do_static_init && saw_const)
3200 DECL_INITIAL (obase) = build_constructor (atype, new_vec);
3202 VEC_free (constructor_elt, gc, new_vec);
3205 /* Clear out INIT so that we don't get confused below. */
3208 else if (from_array)
3211 /* OK, we set base2 above. */;
3212 else if (CLASS_TYPE_P (type)
3213 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
3215 if (complain & tf_error)
3216 error ("initializer ends prematurely");
3221 /* Now, default-initialize any remaining elements. We don't need to
3222 do that if a) the type does not need constructing, or b) we've
3223 already initialized all the elements.
3225 We do need to keep going if we're copying an array. */
3228 || ((type_build_ctor_call (type) || init || explicit_value_init_p)
3229 && ! (host_integerp (maxindex, 0)
3230 && (num_initialized_elts
3231 == tree_low_cst (maxindex, 0) + 1))))
3233 /* If the ITERATOR is equal to -1, then we don't have to loop;
3234 we've already initialized all the elements. */
3239 for_stmt = begin_for_stmt (NULL_TREE, NULL_TREE);
3240 finish_for_init_stmt (for_stmt);
3241 finish_for_cond (build2 (NE_EXPR, boolean_type_node, iterator,
3242 build_int_cst (TREE_TYPE (iterator), -1)),
3244 elt_init = cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
3246 if (elt_init == error_mark_node)
3248 finish_for_expr (elt_init, for_stmt);
3250 to = build1 (INDIRECT_REF, type, base);
3258 from = build1 (INDIRECT_REF, itype, base2);
3265 if (from_array == 2)
3266 elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
3268 else if (type_build_ctor_call (type))
3269 elt_init = build_aggr_init (to, from, 0, complain);
3271 elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
3276 else if (TREE_CODE (type) == ARRAY_TYPE)
3280 ("cannot initialize multi-dimensional array with initializer");
3281 elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
3283 explicit_value_init_p,
3286 else if (explicit_value_init_p)
3288 elt_init = build_value_init (type, complain);
3289 if (elt_init != error_mark_node)
3290 elt_init = build2 (INIT_EXPR, type, to, elt_init);
3294 gcc_assert (type_build_ctor_call (type) || init);
3295 if (CLASS_TYPE_P (type))
3296 elt_init = build_aggr_init (to, init, 0, complain);
3299 if (TREE_CODE (init) == TREE_LIST)
3300 init = build_x_compound_expr_from_list (init, ELK_INIT,
3302 elt_init = build2 (INIT_EXPR, type, to, init);
3306 if (elt_init == error_mark_node)
3309 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
3310 finish_expr_stmt (elt_init);
3311 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
3313 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
3316 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base2, 0,
3319 finish_for_stmt (for_stmt);
3322 /* Make sure to cleanup any partially constructed elements. */
3323 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
3327 tree m = cp_build_binary_op (input_location,
3328 MINUS_EXPR, maxindex, iterator,
3331 /* Flatten multi-dimensional array since build_vec_delete only
3332 expects one-dimensional array. */
3333 if (TREE_CODE (type) == ARRAY_TYPE)
3334 m = cp_build_binary_op (input_location,
3336 array_type_nelts_total (type),
3339 finish_cleanup_try_block (try_block);
3340 e = build_vec_delete_1 (rval, m,
3341 inner_elt_type, sfk_complete_destructor,
3342 /*use_global_delete=*/0, complain);
3343 if (e == error_mark_node)
3345 finish_cleanup (e, try_block);
3348 /* The value of the array initialization is the array itself, RVAL
3349 is a pointer to the first element. */
3350 finish_stmt_expr_expr (rval, stmt_expr);
3352 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
3354 /* Now make the result have the correct type. */
3355 if (TREE_CODE (atype) == ARRAY_TYPE)
3357 atype = build_pointer_type (atype);
3358 stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
3359 stmt_expr = cp_build_indirect_ref (stmt_expr, RO_NULL, complain);
3360 TREE_NO_WARNING (stmt_expr) = 1;
3363 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
3366 return build2 (INIT_EXPR, atype, obase, const_init);
3368 return error_mark_node;
3372 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
3376 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags,
3377 tsubst_flags_t complain)
3383 case sfk_complete_destructor:
3384 name = complete_dtor_identifier;
3387 case sfk_base_destructor:
3388 name = base_dtor_identifier;
3391 case sfk_deleting_destructor:
3392 name = deleting_dtor_identifier;
3398 fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
3399 return build_new_method_call (exp, fn,
3401 /*conversion_path=*/NULL_TREE,
3407 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3408 ADDR is an expression which yields the store to be destroyed.
3409 AUTO_DELETE is the name of the destructor to call, i.e., either
3410 sfk_complete_destructor, sfk_base_destructor, or
3411 sfk_deleting_destructor.
3413 FLAGS is the logical disjunction of zero or more LOOKUP_
3414 flags. See cp-tree.h for more info. */
3417 build_delete (tree type, tree addr, special_function_kind auto_delete,
3418 int flags, int use_global_delete, tsubst_flags_t complain)
3422 if (addr == error_mark_node)
3423 return error_mark_node;
3425 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3426 set to `error_mark_node' before it gets properly cleaned up. */
3427 if (type == error_mark_node)
3428 return error_mark_node;
3430 type = TYPE_MAIN_VARIANT (type);
3432 addr = mark_rvalue_use (addr);
3434 if (TREE_CODE (type) == POINTER_TYPE)
3436 bool complete_p = true;
3438 type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
3439 if (TREE_CODE (type) == ARRAY_TYPE)
3442 /* We don't want to warn about delete of void*, only other
3443 incomplete types. Deleting other incomplete types
3444 invokes undefined behavior, but it is not ill-formed, so
3445 compile to something that would even do The Right Thing
3446 (TM) should the type have a trivial dtor and no delete
3448 if (!VOID_TYPE_P (type))
3450 complete_type (type);
3451 if (!COMPLETE_TYPE_P (type))
3453 if ((complain & tf_warning)
3454 && warning (0, "possible problem detected in invocation of "
3455 "delete operator:"))
3457 cxx_incomplete_type_diagnostic (addr, type, DK_WARNING);
3458 inform (input_location, "neither the destructor nor the class-specific "
3459 "operator delete will be called, even if they are "
3460 "declared when the class is defined");
3464 else if (auto_delete == sfk_deleting_destructor && warn_delnonvdtor
3465 && MAYBE_CLASS_TYPE_P (type) && !CLASSTYPE_FINAL (type)
3466 && TYPE_POLYMORPHIC_P (type))
3469 dtor = CLASSTYPE_DESTRUCTORS (type);
3470 if (!dtor || !DECL_VINDEX (dtor))
3472 if (CLASSTYPE_PURE_VIRTUALS (type))
3473 warning (OPT_Wdelete_non_virtual_dtor,
3474 "deleting object of abstract class type %qT"
3475 " which has non-virtual destructor"
3476 " will cause undefined behaviour", type);
3478 warning (OPT_Wdelete_non_virtual_dtor,
3479 "deleting object of polymorphic class type %qT"
3480 " which has non-virtual destructor"
3481 " might cause undefined behaviour", type);
3485 if (VOID_TYPE_P (type) || !complete_p || !MAYBE_CLASS_TYPE_P (type))
3486 /* Call the builtin operator delete. */
3487 return build_builtin_delete_call (addr);
3488 if (TREE_SIDE_EFFECTS (addr))
3489 addr = save_expr (addr);
3491 /* Throw away const and volatile on target type of addr. */
3492 addr = convert_force (build_pointer_type (type), addr, 0);
3494 else if (TREE_CODE (type) == ARRAY_TYPE)
3498 if (TYPE_DOMAIN (type) == NULL_TREE)
3500 if (complain & tf_error)
3501 error ("unknown array size in delete");
3502 return error_mark_node;
3504 return build_vec_delete (addr, array_type_nelts (type),
3505 auto_delete, use_global_delete, complain);
3509 /* Don't check PROTECT here; leave that decision to the
3510 destructor. If the destructor is accessible, call it,
3511 else report error. */
3512 addr = cp_build_addr_expr (addr, complain);
3513 if (addr == error_mark_node)
3514 return error_mark_node;
3515 if (TREE_SIDE_EFFECTS (addr))
3516 addr = save_expr (addr);
3518 addr = convert_force (build_pointer_type (type), addr, 0);
3521 gcc_assert (MAYBE_CLASS_TYPE_P (type));
3523 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
3525 if (auto_delete != sfk_deleting_destructor)
3526 return void_zero_node;
3528 return build_op_delete_call (DELETE_EXPR, addr,
3529 cxx_sizeof_nowarn (type),
3531 /*placement=*/NULL_TREE,
3532 /*alloc_fn=*/NULL_TREE);
3536 tree head = NULL_TREE;
3537 tree do_delete = NULL_TREE;
3540 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
3541 lazily_declare_fn (sfk_destructor, type);
3543 /* For `::delete x', we must not use the deleting destructor
3544 since then we would not be sure to get the global `operator
3546 if (use_global_delete && auto_delete == sfk_deleting_destructor)
3548 /* We will use ADDR multiple times so we must save it. */
3549 addr = save_expr (addr);
3550 head = get_target_expr (build_headof (addr));
3551 /* Delete the object. */
3552 do_delete = build_builtin_delete_call (head);
3553 /* Otherwise, treat this like a complete object destructor
3555 auto_delete = sfk_complete_destructor;
3557 /* If the destructor is non-virtual, there is no deleting
3558 variant. Instead, we must explicitly call the appropriate
3559 `operator delete' here. */
3560 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
3561 && auto_delete == sfk_deleting_destructor)
3563 /* We will use ADDR multiple times so we must save it. */
3564 addr = save_expr (addr);
3565 /* Build the call. */
3566 do_delete = build_op_delete_call (DELETE_EXPR,
3568 cxx_sizeof_nowarn (type),
3570 /*placement=*/NULL_TREE,
3571 /*alloc_fn=*/NULL_TREE);
3572 /* Call the complete object destructor. */
3573 auto_delete = sfk_complete_destructor;
3575 else if (auto_delete == sfk_deleting_destructor
3576 && TYPE_GETS_REG_DELETE (type))
3578 /* Make sure we have access to the member op delete, even though
3579 we'll actually be calling it from the destructor. */
3580 build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
3582 /*placement=*/NULL_TREE,
3583 /*alloc_fn=*/NULL_TREE);
3586 expr = build_dtor_call (cp_build_indirect_ref (addr, RO_NULL, complain),
3587 auto_delete, flags, complain);
3588 if (expr == error_mark_node)
3589 return error_mark_node;
3591 expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
3593 /* We need to calculate this before the dtor changes the vptr. */
3595 expr = build2 (COMPOUND_EXPR, void_type_node, head, expr);
3597 if (flags & LOOKUP_DESTRUCTOR)
3598 /* Explicit destructor call; don't check for null pointer. */
3599 ifexp = integer_one_node;
3602 /* Handle deleting a null pointer. */
3603 ifexp = fold (cp_build_binary_op (input_location,
3604 NE_EXPR, addr, integer_zero_node,
3606 if (ifexp == error_mark_node)
3607 return error_mark_node;
3610 if (ifexp != integer_one_node)
3611 expr = build3 (COND_EXPR, void_type_node,
3612 ifexp, expr, void_zero_node);
3618 /* At the beginning of a destructor, push cleanups that will call the
3619 destructors for our base classes and members.
3621 Called from begin_destructor_body. */
3624 push_base_cleanups (void)
3626 tree binfo, base_binfo;
3630 VEC(tree,gc) *vbases;
3632 /* Run destructors for all virtual baseclasses. */
3633 if (CLASSTYPE_VBASECLASSES (current_class_type))
3635 tree cond = (condition_conversion
3636 (build2 (BIT_AND_EXPR, integer_type_node,
3637 current_in_charge_parm,
3638 integer_two_node)));
3640 /* The CLASSTYPE_VBASECLASSES vector is in initialization
3641 order, which is also the right order for pushing cleanups. */
3642 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
3643 VEC_iterate (tree, vbases, i, base_binfo); i++)
3645 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
3647 expr = build_special_member_call (current_class_ref,
3648 base_dtor_identifier,
3652 | LOOKUP_NONVIRTUAL),
3653 tf_warning_or_error);
3654 expr = build3 (COND_EXPR, void_type_node, cond,
3655 expr, void_zero_node);
3656 finish_decl_cleanup (NULL_TREE, expr);
3661 /* Take care of the remaining baseclasses. */
3662 for (binfo = TYPE_BINFO (current_class_type), i = 0;
3663 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
3665 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
3666 || BINFO_VIRTUAL_P (base_binfo))
3669 expr = build_special_member_call (current_class_ref,
3670 base_dtor_identifier,
3672 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
3673 tf_warning_or_error);
3674 finish_decl_cleanup (NULL_TREE, expr);
3677 /* Don't automatically destroy union members. */
3678 if (TREE_CODE (current_class_type) == UNION_TYPE)
3681 for (member = TYPE_FIELDS (current_class_type); member;
3682 member = DECL_CHAIN (member))
3684 tree this_type = TREE_TYPE (member);
3685 if (this_type == error_mark_node
3686 || TREE_CODE (member) != FIELD_DECL
3687 || DECL_ARTIFICIAL (member))
3689 if (ANON_UNION_TYPE_P (this_type))
3691 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (this_type))
3693 tree this_member = (build_class_member_access_expr
3694 (current_class_ref, member,
3695 /*access_path=*/NULL_TREE,
3696 /*preserve_reference=*/false,
3697 tf_warning_or_error));
3698 expr = build_delete (this_type, this_member,
3699 sfk_complete_destructor,
3700 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
3701 0, tf_warning_or_error);
3702 finish_decl_cleanup (NULL_TREE, expr);
3707 /* Build a C++ vector delete expression.
3708 MAXINDEX is the number of elements to be deleted.
3709 ELT_SIZE is the nominal size of each element in the vector.
3710 BASE is the expression that should yield the store to be deleted.
3711 This function expands (or synthesizes) these calls itself.
3712 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3714 This also calls delete for virtual baseclasses of elements of the vector.
3716 Update: MAXINDEX is no longer needed. The size can be extracted from the
3717 start of the vector for pointers, and from the type for arrays. We still
3718 use MAXINDEX for arrays because it happens to already have one of the
3719 values we'd have to extract. (We could use MAXINDEX with pointers to
3720 confirm the size, and trap if the numbers differ; not clear that it'd
3721 be worth bothering.) */
3724 build_vec_delete (tree base, tree maxindex,
3725 special_function_kind auto_delete_vec,
3726 int use_global_delete, tsubst_flags_t complain)
3730 tree base_init = NULL_TREE;
3732 type = TREE_TYPE (base);
3734 if (TREE_CODE (type) == POINTER_TYPE)
3736 /* Step back one from start of vector, and read dimension. */
3738 tree size_ptr_type = build_pointer_type (sizetype);
3740 if (TREE_SIDE_EFFECTS (base))
3742 base_init = get_target_expr (base);
3743 base = TARGET_EXPR_SLOT (base_init);
3745 type = strip_array_types (TREE_TYPE (type));
3746 cookie_addr = fold_build1_loc (input_location, NEGATE_EXPR,
3747 sizetype, TYPE_SIZE_UNIT (sizetype));
3748 cookie_addr = fold_build_pointer_plus (fold_convert (size_ptr_type, base),
3750 maxindex = cp_build_indirect_ref (cookie_addr, RO_NULL, complain);
3752 else if (TREE_CODE (type) == ARRAY_TYPE)
3754 /* Get the total number of things in the array, maxindex is a
3756 maxindex = array_type_nelts_total (type);
3757 type = strip_array_types (type);
3758 base = cp_build_addr_expr (base, complain);
3759 if (base == error_mark_node)
3760 return error_mark_node;
3761 if (TREE_SIDE_EFFECTS (base))
3763 base_init = get_target_expr (base);
3764 base = TARGET_EXPR_SLOT (base_init);
3769 if (base != error_mark_node && !(complain & tf_error))
3770 error ("type to vector delete is neither pointer or array type");
3771 return error_mark_node;
3774 rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3775 use_global_delete, complain);
3776 if (base_init && rval != error_mark_node)
3777 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);