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 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"
37 static bool begin_init_stmts (tree *, tree *);
38 static tree finish_init_stmts (bool, tree, tree);
39 static void construct_virtual_base (tree, tree);
40 static void expand_aggr_init_1 (tree, tree, tree, tree, int, tsubst_flags_t);
41 static void expand_default_init (tree, tree, tree, tree, int, tsubst_flags_t);
42 static tree build_vec_delete_1 (tree, tree, tree, special_function_kind, int);
43 static void perform_member_init (tree, tree);
44 static tree build_builtin_delete_call (tree);
45 static int member_init_ok_or_else (tree, tree, tree);
46 static void expand_virtual_init (tree, tree);
47 static tree sort_mem_initializers (tree, tree);
48 static tree initializing_context (tree);
49 static void expand_cleanup_for_base (tree, tree);
50 static tree get_temp_regvar (tree, tree);
51 static tree dfs_initialize_vtbl_ptrs (tree, void *);
52 static tree build_dtor_call (tree, special_function_kind, int);
53 static tree build_field_list (tree, tree, int *);
54 static tree build_vtbl_address (tree);
55 static int diagnose_uninitialized_cst_or_ref_member_1 (tree, tree, bool, bool);
57 /* We are about to generate some complex initialization code.
58 Conceptually, it is all a single expression. However, we may want
59 to include conditionals, loops, and other such statement-level
60 constructs. Therefore, we build the initialization code inside a
61 statement-expression. This function starts such an expression.
62 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
63 pass them back to finish_init_stmts when the expression is
67 begin_init_stmts (tree *stmt_expr_p, tree *compound_stmt_p)
69 bool is_global = !building_stmt_tree ();
71 *stmt_expr_p = begin_stmt_expr ();
72 *compound_stmt_p = begin_compound_stmt (BCS_NO_SCOPE);
77 /* Finish out the statement-expression begun by the previous call to
78 begin_init_stmts. Returns the statement-expression itself. */
81 finish_init_stmts (bool is_global, tree stmt_expr, tree compound_stmt)
83 finish_compound_stmt (compound_stmt);
85 stmt_expr = finish_stmt_expr (stmt_expr, true);
87 gcc_assert (!building_stmt_tree () == is_global);
94 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
95 which we want to initialize the vtable pointer for, DATA is
96 TREE_LIST whose TREE_VALUE is the this ptr expression. */
99 dfs_initialize_vtbl_ptrs (tree binfo, void *data)
101 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
102 return dfs_skip_bases;
104 if (!BINFO_PRIMARY_P (binfo) || BINFO_VIRTUAL_P (binfo))
106 tree base_ptr = TREE_VALUE ((tree) data);
108 base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /*nonnull=*/1);
110 expand_virtual_init (binfo, base_ptr);
116 /* Initialize all the vtable pointers in the object pointed to by
120 initialize_vtbl_ptrs (tree addr)
125 type = TREE_TYPE (TREE_TYPE (addr));
126 list = build_tree_list (type, addr);
128 /* Walk through the hierarchy, initializing the vptr in each base
129 class. We do these in pre-order because we can't find the virtual
130 bases for a class until we've initialized the vtbl for that
132 dfs_walk_once (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs, NULL, list);
135 /* Return an expression for the zero-initialization of an object with
136 type T. This expression will either be a constant (in the case
137 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
138 aggregate), or NULL (in the case that T does not require
139 initialization). In either case, the value can be used as
140 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
141 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
142 is the number of elements in the array. If STATIC_STORAGE_P is
143 TRUE, initializers are only generated for entities for which
144 zero-initialization does not simply mean filling the storage with
148 build_zero_init (tree type, tree nelts, bool static_storage_p)
150 tree init = NULL_TREE;
154 To zero-initialize an object of type T means:
156 -- if T is a scalar type, the storage is set to the value of zero
159 -- if T is a non-union class type, the storage for each nonstatic
160 data member and each base-class subobject is zero-initialized.
162 -- if T is a union type, the storage for its first data member is
165 -- if T is an array type, the storage for each element is
168 -- if T is a reference type, no initialization is performed. */
170 gcc_assert (nelts == NULL_TREE || TREE_CODE (nelts) == INTEGER_CST);
172 if (type == error_mark_node)
174 else if (static_storage_p && zero_init_p (type))
175 /* In order to save space, we do not explicitly build initializers
176 for items that do not need them. GCC's semantics are that
177 items with static storage duration that are not otherwise
178 initialized are initialized to zero. */
180 else if (SCALAR_TYPE_P (type))
181 init = convert (type, integer_zero_node);
182 else if (CLASS_TYPE_P (type))
185 VEC(constructor_elt,gc) *v = NULL;
187 /* Iterate over the fields, building initializations. */
188 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
190 if (TREE_CODE (field) != FIELD_DECL)
193 /* Note that for class types there will be FIELD_DECLs
194 corresponding to base classes as well. Thus, iterating
195 over TYPE_FIELDs will result in correct initialization of
196 all of the subobjects. */
197 if (!static_storage_p || !zero_init_p (TREE_TYPE (field)))
199 tree value = build_zero_init (TREE_TYPE (field),
203 CONSTRUCTOR_APPEND_ELT(v, field, value);
206 /* For unions, only the first field is initialized. */
207 if (TREE_CODE (type) == UNION_TYPE)
211 /* Build a constructor to contain the initializations. */
212 init = build_constructor (type, v);
214 else if (TREE_CODE (type) == ARRAY_TYPE)
217 VEC(constructor_elt,gc) *v = NULL;
219 /* Iterate over the array elements, building initializations. */
221 max_index = fold_build2_loc (input_location,
222 MINUS_EXPR, TREE_TYPE (nelts),
223 nelts, integer_one_node);
225 max_index = array_type_nelts (type);
227 /* If we have an error_mark here, we should just return error mark
228 as we don't know the size of the array yet. */
229 if (max_index == error_mark_node)
230 return error_mark_node;
231 gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
233 /* A zero-sized array, which is accepted as an extension, will
234 have an upper bound of -1. */
235 if (!tree_int_cst_equal (max_index, integer_minus_one_node))
239 v = VEC_alloc (constructor_elt, gc, 1);
240 ce = VEC_quick_push (constructor_elt, v, NULL);
242 /* If this is a one element array, we just use a regular init. */
243 if (tree_int_cst_equal (size_zero_node, max_index))
244 ce->index = size_zero_node;
246 ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
249 ce->value = build_zero_init (TREE_TYPE (type),
254 /* Build a constructor to contain the initializations. */
255 init = build_constructor (type, v);
257 else if (TREE_CODE (type) == VECTOR_TYPE)
258 init = fold_convert (type, integer_zero_node);
260 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
262 /* In all cases, the initializer is a constant. */
264 TREE_CONSTANT (init) = 1;
269 /* Return a suitable initializer for value-initializing an object of type
270 TYPE, as described in [dcl.init]. */
273 build_value_init (tree type)
277 To value-initialize an object of type T means:
279 - if T is a class type (clause 9) with a user-provided constructor
280 (12.1), then the default constructor for T is called (and the
281 initialization is ill-formed if T has no accessible default
284 - if T is a non-union class type without a user-provided constructor,
285 then every non-static data member and base-class component of T is
286 value-initialized;92)
288 - if T is an array type, then each element is value-initialized;
290 - otherwise, the object is zero-initialized.
292 A program that calls for default-initialization or
293 value-initialization of an entity of reference type is ill-formed.
295 92) Value-initialization for such a class object may be implemented by
296 zero-initializing the object and then calling the default
299 if (CLASS_TYPE_P (type))
301 if (type_has_user_provided_constructor (type))
302 return build_aggr_init_expr
304 build_special_member_call (NULL_TREE, complete_ctor_identifier,
305 NULL, type, LOOKUP_NORMAL,
306 tf_warning_or_error));
307 else if (TREE_CODE (type) != UNION_TYPE && TYPE_NEEDS_CONSTRUCTING (type))
309 /* This is a class that needs constructing, but doesn't have
310 a user-provided constructor. So we need to zero-initialize
311 the object and then call the implicitly defined ctor.
312 This will be handled in simplify_aggr_init_expr. */
313 tree ctor = build_special_member_call
314 (NULL_TREE, complete_ctor_identifier,
315 NULL, type, LOOKUP_NORMAL, tf_warning_or_error);
317 ctor = build_aggr_init_expr (type, ctor);
318 AGGR_INIT_ZERO_FIRST (ctor) = 1;
322 return build_value_init_noctor (type);
325 /* Like build_value_init, but don't call the constructor for TYPE. Used
326 for base initializers. */
329 build_value_init_noctor (tree type)
331 if (CLASS_TYPE_P (type))
333 gcc_assert (!TYPE_NEEDS_CONSTRUCTING (type));
335 if (TREE_CODE (type) != UNION_TYPE)
338 VEC(constructor_elt,gc) *v = NULL;
340 /* Iterate over the fields, building initializations. */
341 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
345 if (TREE_CODE (field) != FIELD_DECL)
348 ftype = TREE_TYPE (field);
350 if (TREE_CODE (ftype) == REFERENCE_TYPE)
351 error ("value-initialization of reference");
353 /* We could skip vfields and fields of types with
354 user-defined constructors, but I think that won't improve
355 performance at all; it should be simpler in general just
356 to zero out the entire object than try to only zero the
357 bits that actually need it. */
359 /* Note that for class types there will be FIELD_DECLs
360 corresponding to base classes as well. Thus, iterating
361 over TYPE_FIELDs will result in correct initialization of
362 all of the subobjects. */
363 value = build_value_init (ftype);
366 CONSTRUCTOR_APPEND_ELT(v, field, value);
369 /* Build a constructor to contain the zero- initializations. */
370 return build_constructor (type, v);
373 else if (TREE_CODE (type) == ARRAY_TYPE)
375 VEC(constructor_elt,gc) *v = NULL;
377 /* Iterate over the array elements, building initializations. */
378 tree max_index = array_type_nelts (type);
380 /* If we have an error_mark here, we should just return error mark
381 as we don't know the size of the array yet. */
382 if (max_index == error_mark_node)
383 return error_mark_node;
384 gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
386 /* A zero-sized array, which is accepted as an extension, will
387 have an upper bound of -1. */
388 if (!tree_int_cst_equal (max_index, integer_minus_one_node))
392 v = VEC_alloc (constructor_elt, gc, 1);
393 ce = VEC_quick_push (constructor_elt, v, NULL);
395 /* If this is a one element array, we just use a regular init. */
396 if (tree_int_cst_equal (size_zero_node, max_index))
397 ce->index = size_zero_node;
399 ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
402 ce->value = build_value_init (TREE_TYPE (type));
404 /* The gimplifier can't deal with a RANGE_EXPR of TARGET_EXPRs. */
405 gcc_assert (TREE_CODE (ce->value) != TARGET_EXPR
406 && TREE_CODE (ce->value) != AGGR_INIT_EXPR);
409 /* Build a constructor to contain the initializations. */
410 return build_constructor (type, v);
413 return build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
416 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
417 arguments. If TREE_LIST is void_type_node, an empty initializer
418 list was given; if NULL_TREE no initializer was given. */
421 perform_member_init (tree member, tree init)
424 tree type = TREE_TYPE (member);
426 /* Effective C++ rule 12 requires that all data members be
428 if (warn_ecpp && init == NULL_TREE && TREE_CODE (type) != ARRAY_TYPE)
429 warning_at (DECL_SOURCE_LOCATION (current_function_decl), OPT_Weffc__,
430 "%qD should be initialized in the member initialization list",
433 /* Get an lvalue for the data member. */
434 decl = build_class_member_access_expr (current_class_ref, member,
435 /*access_path=*/NULL_TREE,
436 /*preserve_reference=*/true,
437 tf_warning_or_error);
438 if (decl == error_mark_node)
441 if (init == void_type_node)
443 /* mem() means value-initialization. */
444 if (TREE_CODE (type) == ARRAY_TYPE)
446 init = build_vec_init (decl, NULL_TREE, NULL_TREE,
447 /*explicit_value_init_p=*/true,
449 tf_warning_or_error);
450 finish_expr_stmt (init);
454 if (TREE_CODE (type) == REFERENCE_TYPE)
455 permerror (DECL_SOURCE_LOCATION (current_function_decl),
456 "value-initialization of %q#D, which has reference type",
460 init = build2 (INIT_EXPR, type, decl, build_value_init (type));
461 finish_expr_stmt (init);
465 /* Deal with this here, as we will get confused if we try to call the
466 assignment op for an anonymous union. This can happen in a
467 synthesized copy constructor. */
468 else if (ANON_AGGR_TYPE_P (type))
472 init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init));
473 finish_expr_stmt (init);
476 else if (TYPE_NEEDS_CONSTRUCTING (type))
478 if (init != NULL_TREE
479 && TREE_CODE (type) == ARRAY_TYPE
480 && TREE_CHAIN (init) == NULL_TREE
481 && TREE_CODE (TREE_TYPE (TREE_VALUE (init))) == ARRAY_TYPE)
483 /* Initialization of one array from another. */
484 finish_expr_stmt (build_vec_init (decl, NULL_TREE, TREE_VALUE (init),
485 /*explicit_value_init_p=*/false,
487 tf_warning_or_error));
491 if (CP_TYPE_CONST_P (type)
493 && !type_has_user_provided_default_constructor (type))
494 /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
495 vtable; still give this diagnostic. */
496 permerror (DECL_SOURCE_LOCATION (current_function_decl),
497 "uninitialized member %qD with %<const%> type %qT",
499 finish_expr_stmt (build_aggr_init (decl, init, 0,
500 tf_warning_or_error));
505 if (init == NULL_TREE)
508 /* member traversal: note it leaves init NULL */
509 if (TREE_CODE (type) == REFERENCE_TYPE)
510 permerror (DECL_SOURCE_LOCATION (current_function_decl),
511 "uninitialized reference member %qD",
513 else if (CP_TYPE_CONST_P (type))
514 permerror (DECL_SOURCE_LOCATION (current_function_decl),
515 "uninitialized member %qD with %<const%> type %qT",
518 core_type = strip_array_types (type);
519 if (CLASS_TYPE_P (core_type)
520 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)
521 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)))
522 diagnose_uninitialized_cst_or_ref_member (core_type,
526 else if (TREE_CODE (init) == TREE_LIST)
527 /* There was an explicit member initialization. Do some work
529 init = build_x_compound_expr_from_list (init, "member initializer");
532 finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,
533 tf_warning_or_error));
536 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
540 expr = build_class_member_access_expr (current_class_ref, member,
541 /*access_path=*/NULL_TREE,
542 /*preserve_reference=*/false,
543 tf_warning_or_error);
544 expr = build_delete (type, expr, sfk_complete_destructor,
545 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
547 if (expr != error_mark_node)
548 finish_eh_cleanup (expr);
552 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
553 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
556 build_field_list (tree t, tree list, int *uses_unions_p)
562 /* Note whether or not T is a union. */
563 if (TREE_CODE (t) == UNION_TYPE)
566 for (fields = TYPE_FIELDS (t); fields; fields = TREE_CHAIN (fields))
568 /* Skip CONST_DECLs for enumeration constants and so forth. */
569 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
572 /* Keep track of whether or not any fields are unions. */
573 if (TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
576 /* For an anonymous struct or union, we must recursively
577 consider the fields of the anonymous type. They can be
578 directly initialized from the constructor. */
579 if (ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
581 /* Add this field itself. Synthesized copy constructors
582 initialize the entire aggregate. */
583 list = tree_cons (fields, NULL_TREE, list);
584 /* And now add the fields in the anonymous aggregate. */
585 list = build_field_list (TREE_TYPE (fields), list,
588 /* Add this field. */
589 else if (DECL_NAME (fields))
590 list = tree_cons (fields, NULL_TREE, list);
596 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
597 a FIELD_DECL or BINFO in T that needs initialization. The
598 TREE_VALUE gives the initializer, or list of initializer arguments.
600 Return a TREE_LIST containing all of the initializations required
601 for T, in the order in which they should be performed. The output
602 list has the same format as the input. */
605 sort_mem_initializers (tree t, tree mem_inits)
608 tree base, binfo, base_binfo;
611 VEC(tree,gc) *vbases;
615 /* Build up a list of initializations. The TREE_PURPOSE of entry
616 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
617 TREE_VALUE will be the constructor arguments, or NULL if no
618 explicit initialization was provided. */
619 sorted_inits = NULL_TREE;
621 /* Process the virtual bases. */
622 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
623 VEC_iterate (tree, vbases, i, base); i++)
624 sorted_inits = tree_cons (base, NULL_TREE, sorted_inits);
626 /* Process the direct bases. */
627 for (binfo = TYPE_BINFO (t), i = 0;
628 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
629 if (!BINFO_VIRTUAL_P (base_binfo))
630 sorted_inits = tree_cons (base_binfo, NULL_TREE, sorted_inits);
632 /* Process the non-static data members. */
633 sorted_inits = build_field_list (t, sorted_inits, &uses_unions_p);
634 /* Reverse the entire list of initializations, so that they are in
635 the order that they will actually be performed. */
636 sorted_inits = nreverse (sorted_inits);
638 /* If the user presented the initializers in an order different from
639 that in which they will actually occur, we issue a warning. Keep
640 track of the next subobject which can be explicitly initialized
641 without issuing a warning. */
642 next_subobject = sorted_inits;
644 /* Go through the explicit initializers, filling in TREE_PURPOSE in
646 for (init = mem_inits; init; init = TREE_CHAIN (init))
651 subobject = TREE_PURPOSE (init);
653 /* If the explicit initializers are in sorted order, then
654 SUBOBJECT will be NEXT_SUBOBJECT, or something following
656 for (subobject_init = next_subobject;
658 subobject_init = TREE_CHAIN (subobject_init))
659 if (TREE_PURPOSE (subobject_init) == subobject)
662 /* Issue a warning if the explicit initializer order does not
663 match that which will actually occur.
664 ??? Are all these on the correct lines? */
665 if (warn_reorder && !subobject_init)
667 if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)
668 warning (OPT_Wreorder, "%q+D will be initialized after",
669 TREE_PURPOSE (next_subobject));
671 warning (OPT_Wreorder, "base %qT will be initialized after",
672 TREE_PURPOSE (next_subobject));
673 if (TREE_CODE (subobject) == FIELD_DECL)
674 warning (OPT_Wreorder, " %q+#D", subobject);
676 warning (OPT_Wreorder, " base %qT", subobject);
677 warning_at (DECL_SOURCE_LOCATION (current_function_decl),
678 OPT_Wreorder, " when initialized here");
681 /* Look again, from the beginning of the list. */
684 subobject_init = sorted_inits;
685 while (TREE_PURPOSE (subobject_init) != subobject)
686 subobject_init = TREE_CHAIN (subobject_init);
689 /* It is invalid to initialize the same subobject more than
691 if (TREE_VALUE (subobject_init))
693 if (TREE_CODE (subobject) == FIELD_DECL)
694 error_at (DECL_SOURCE_LOCATION (current_function_decl),
695 "multiple initializations given for %qD",
698 error_at (DECL_SOURCE_LOCATION (current_function_decl),
699 "multiple initializations given for base %qT",
703 /* Record the initialization. */
704 TREE_VALUE (subobject_init) = TREE_VALUE (init);
705 next_subobject = subobject_init;
710 If a ctor-initializer specifies more than one mem-initializer for
711 multiple members of the same union (including members of
712 anonymous unions), the ctor-initializer is ill-formed. */
715 tree last_field = NULL_TREE;
716 for (init = sorted_inits; init; init = TREE_CHAIN (init))
722 /* Skip uninitialized members and base classes. */
723 if (!TREE_VALUE (init)
724 || TREE_CODE (TREE_PURPOSE (init)) != FIELD_DECL)
726 /* See if this field is a member of a union, or a member of a
727 structure contained in a union, etc. */
728 field = TREE_PURPOSE (init);
729 for (field_type = DECL_CONTEXT (field);
730 !same_type_p (field_type, t);
731 field_type = TYPE_CONTEXT (field_type))
732 if (TREE_CODE (field_type) == UNION_TYPE)
734 /* If this field is not a member of a union, skip it. */
735 if (TREE_CODE (field_type) != UNION_TYPE)
738 /* It's only an error if we have two initializers for the same
746 /* See if LAST_FIELD and the field initialized by INIT are
747 members of the same union. If so, there's a problem,
748 unless they're actually members of the same structure
749 which is itself a member of a union. For example, given:
751 union { struct { int i; int j; }; };
753 initializing both `i' and `j' makes sense. */
754 field_type = DECL_CONTEXT (field);
758 tree last_field_type;
760 last_field_type = DECL_CONTEXT (last_field);
763 if (same_type_p (last_field_type, field_type))
765 if (TREE_CODE (field_type) == UNION_TYPE)
766 error_at (DECL_SOURCE_LOCATION (current_function_decl),
767 "initializations for multiple members of %qT",
773 if (same_type_p (last_field_type, t))
776 last_field_type = TYPE_CONTEXT (last_field_type);
779 /* If we've reached the outermost class, then we're
781 if (same_type_p (field_type, t))
784 field_type = TYPE_CONTEXT (field_type);
795 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
796 is a TREE_LIST giving the explicit mem-initializer-list for the
797 constructor. The TREE_PURPOSE of each entry is a subobject (a
798 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
799 is a TREE_LIST giving the arguments to the constructor or
800 void_type_node for an empty list of arguments. */
803 emit_mem_initializers (tree mem_inits)
805 /* We will already have issued an error message about the fact that
806 the type is incomplete. */
807 if (!COMPLETE_TYPE_P (current_class_type))
810 /* Sort the mem-initializers into the order in which the
811 initializations should be performed. */
812 mem_inits = sort_mem_initializers (current_class_type, mem_inits);
814 in_base_initializer = 1;
816 /* Initialize base classes. */
818 && TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)
820 tree subobject = TREE_PURPOSE (mem_inits);
821 tree arguments = TREE_VALUE (mem_inits);
823 /* If these initializations are taking place in a copy constructor,
824 the base class should probably be explicitly initialized if there
825 is a user-defined constructor in the base class (other than the
826 default constructor, which will be called anyway). */
827 if (extra_warnings && !arguments
828 && DECL_COPY_CONSTRUCTOR_P (current_function_decl)
829 && type_has_user_nondefault_constructor (BINFO_TYPE (subobject)))
830 warning_at (DECL_SOURCE_LOCATION (current_function_decl), OPT_Wextra,
831 "base class %q#T should be explicitly initialized in the "
833 BINFO_TYPE (subobject));
835 /* Initialize the base. */
836 if (BINFO_VIRTUAL_P (subobject))
837 construct_virtual_base (subobject, arguments);
842 base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
844 expand_aggr_init_1 (subobject, NULL_TREE,
845 cp_build_indirect_ref (base_addr, RO_NULL,
846 tf_warning_or_error),
849 tf_warning_or_error);
850 expand_cleanup_for_base (subobject, NULL_TREE);
853 mem_inits = TREE_CHAIN (mem_inits);
855 in_base_initializer = 0;
857 /* Initialize the vptrs. */
858 initialize_vtbl_ptrs (current_class_ptr);
860 /* Initialize the data members. */
863 perform_member_init (TREE_PURPOSE (mem_inits),
864 TREE_VALUE (mem_inits));
865 mem_inits = TREE_CHAIN (mem_inits);
869 /* Returns the address of the vtable (i.e., the value that should be
870 assigned to the vptr) for BINFO. */
873 build_vtbl_address (tree binfo)
875 tree binfo_for = binfo;
878 if (BINFO_VPTR_INDEX (binfo) && BINFO_VIRTUAL_P (binfo))
879 /* If this is a virtual primary base, then the vtable we want to store
880 is that for the base this is being used as the primary base of. We
881 can't simply skip the initialization, because we may be expanding the
882 inits of a subobject constructor where the virtual base layout
884 while (BINFO_PRIMARY_P (binfo_for))
885 binfo_for = BINFO_INHERITANCE_CHAIN (binfo_for);
887 /* Figure out what vtable BINFO's vtable is based on, and mark it as
889 vtbl = get_vtbl_decl_for_binfo (binfo_for);
890 TREE_USED (vtbl) = 1;
892 /* Now compute the address to use when initializing the vptr. */
893 vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
894 if (TREE_CODE (vtbl) == VAR_DECL)
895 vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
900 /* This code sets up the virtual function tables appropriate for
901 the pointer DECL. It is a one-ply initialization.
903 BINFO is the exact type that DECL is supposed to be. In
904 multiple inheritance, this might mean "C's A" if C : A, B. */
907 expand_virtual_init (tree binfo, tree decl)
912 /* Compute the initializer for vptr. */
913 vtbl = build_vtbl_address (binfo);
915 /* We may get this vptr from a VTT, if this is a subobject
916 constructor or subobject destructor. */
917 vtt_index = BINFO_VPTR_INDEX (binfo);
923 /* Compute the value to use, when there's a VTT. */
924 vtt_parm = current_vtt_parm;
925 vtbl2 = build2 (POINTER_PLUS_EXPR,
926 TREE_TYPE (vtt_parm),
929 vtbl2 = cp_build_indirect_ref (vtbl2, RO_NULL, tf_warning_or_error);
930 vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
932 /* The actual initializer is the VTT value only in the subobject
933 constructor. In maybe_clone_body we'll substitute NULL for
934 the vtt_parm in the case of the non-subobject constructor. */
935 vtbl = build3 (COND_EXPR,
937 build2 (EQ_EXPR, boolean_type_node,
938 current_in_charge_parm, integer_zero_node),
943 /* Compute the location of the vtpr. */
944 vtbl_ptr = build_vfield_ref (cp_build_indirect_ref (decl, RO_NULL,
945 tf_warning_or_error),
947 gcc_assert (vtbl_ptr != error_mark_node);
949 /* Assign the vtable to the vptr. */
950 vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
951 finish_expr_stmt (cp_build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl,
952 tf_warning_or_error));
955 /* If an exception is thrown in a constructor, those base classes already
956 constructed must be destroyed. This function creates the cleanup
957 for BINFO, which has just been constructed. If FLAG is non-NULL,
958 it is a DECL which is nonzero when this base needs to be
962 expand_cleanup_for_base (tree binfo, tree flag)
966 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
969 /* Call the destructor. */
970 expr = build_special_member_call (current_class_ref,
971 base_dtor_identifier,
974 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
975 tf_warning_or_error);
977 expr = fold_build3_loc (input_location,
978 COND_EXPR, void_type_node,
979 c_common_truthvalue_conversion (input_location, flag),
980 expr, integer_zero_node);
982 finish_eh_cleanup (expr);
985 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
989 construct_virtual_base (tree vbase, tree arguments)
995 /* If there are virtual base classes with destructors, we need to
996 emit cleanups to destroy them if an exception is thrown during
997 the construction process. These exception regions (i.e., the
998 period during which the cleanups must occur) begin from the time
999 the construction is complete to the end of the function. If we
1000 create a conditional block in which to initialize the
1001 base-classes, then the cleanup region for the virtual base begins
1002 inside a block, and ends outside of that block. This situation
1003 confuses the sjlj exception-handling code. Therefore, we do not
1004 create a single conditional block, but one for each
1005 initialization. (That way the cleanup regions always begin
1006 in the outer block.) We trust the back end to figure out
1007 that the FLAG will not change across initializations, and
1008 avoid doing multiple tests. */
1009 flag = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
1010 inner_if_stmt = begin_if_stmt ();
1011 finish_if_stmt_cond (flag, inner_if_stmt);
1013 /* Compute the location of the virtual base. If we're
1014 constructing virtual bases, then we must be the most derived
1015 class. Therefore, we don't have to look up the virtual base;
1016 we already know where it is. */
1017 exp = convert_to_base_statically (current_class_ref, vbase);
1019 expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
1020 LOOKUP_COMPLAIN, tf_warning_or_error);
1021 finish_then_clause (inner_if_stmt);
1022 finish_if_stmt (inner_if_stmt);
1024 expand_cleanup_for_base (vbase, flag);
1027 /* Find the context in which this FIELD can be initialized. */
1030 initializing_context (tree field)
1032 tree t = DECL_CONTEXT (field);
1034 /* Anonymous union members can be initialized in the first enclosing
1035 non-anonymous union context. */
1036 while (t && ANON_AGGR_TYPE_P (t))
1037 t = TYPE_CONTEXT (t);
1041 /* Function to give error message if member initialization specification
1042 is erroneous. FIELD is the member we decided to initialize.
1043 TYPE is the type for which the initialization is being performed.
1044 FIELD must be a member of TYPE.
1046 MEMBER_NAME is the name of the member. */
1049 member_init_ok_or_else (tree field, tree type, tree member_name)
1051 if (field == error_mark_node)
1055 error ("class %qT does not have any field named %qD", type,
1059 if (TREE_CODE (field) == VAR_DECL)
1061 error ("%q#D is a static data member; it can only be "
1062 "initialized at its definition",
1066 if (TREE_CODE (field) != FIELD_DECL)
1068 error ("%q#D is not a non-static data member of %qT",
1072 if (initializing_context (field) != type)
1074 error ("class %qT does not have any field named %qD", type,
1082 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1083 is a _TYPE node or TYPE_DECL which names a base for that type.
1084 Check the validity of NAME, and return either the base _TYPE, base
1085 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
1086 NULL_TREE and issue a diagnostic.
1088 An old style unnamed direct single base construction is permitted,
1089 where NAME is NULL. */
1092 expand_member_init (tree name)
1097 if (!current_class_ref)
1102 /* This is an obsolete unnamed base class initializer. The
1103 parser will already have warned about its use. */
1104 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type)))
1107 error ("unnamed initializer for %qT, which has no base classes",
1108 current_class_type);
1111 basetype = BINFO_TYPE
1112 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0));
1115 error ("unnamed initializer for %qT, which uses multiple inheritance",
1116 current_class_type);
1120 else if (TYPE_P (name))
1122 basetype = TYPE_MAIN_VARIANT (name);
1123 name = TYPE_NAME (name);
1125 else if (TREE_CODE (name) == TYPE_DECL)
1126 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
1128 basetype = NULL_TREE;
1137 if (current_template_parms)
1140 class_binfo = TYPE_BINFO (current_class_type);
1141 direct_binfo = NULL_TREE;
1142 virtual_binfo = NULL_TREE;
1144 /* Look for a direct base. */
1145 for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i)
1146 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo), basetype))
1149 /* Look for a virtual base -- unless the direct base is itself
1151 if (!direct_binfo || !BINFO_VIRTUAL_P (direct_binfo))
1152 virtual_binfo = binfo_for_vbase (basetype, current_class_type);
1154 /* [class.base.init]
1156 If a mem-initializer-id is ambiguous because it designates
1157 both a direct non-virtual base class and an inherited virtual
1158 base class, the mem-initializer is ill-formed. */
1159 if (direct_binfo && virtual_binfo)
1161 error ("%qD is both a direct base and an indirect virtual base",
1166 if (!direct_binfo && !virtual_binfo)
1168 if (CLASSTYPE_VBASECLASSES (current_class_type))
1169 error ("type %qT is not a direct or virtual base of %qT",
1170 basetype, current_class_type);
1172 error ("type %qT is not a direct base of %qT",
1173 basetype, current_class_type);
1177 return direct_binfo ? direct_binfo : virtual_binfo;
1181 if (TREE_CODE (name) == IDENTIFIER_NODE)
1182 field = lookup_field (current_class_type, name, 1, false);
1186 if (member_init_ok_or_else (field, current_class_type, name))
1193 /* This is like `expand_member_init', only it stores one aggregate
1196 INIT comes in two flavors: it is either a value which
1197 is to be stored in EXP, or it is a parameter list
1198 to go to a constructor, which will operate on EXP.
1199 If INIT is not a parameter list for a constructor, then set
1200 LOOKUP_ONLYCONVERTING.
1201 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1202 the initializer, if FLAGS is 0, then it is the (init) form.
1203 If `init' is a CONSTRUCTOR, then we emit a warning message,
1204 explaining that such initializations are invalid.
1206 If INIT resolves to a CALL_EXPR which happens to return
1207 something of the type we are looking for, then we know
1208 that we can safely use that call to perform the
1211 The virtual function table pointer cannot be set up here, because
1212 we do not really know its type.
1214 This never calls operator=().
1216 When initializing, nothing is CONST.
1218 A default copy constructor may have to be used to perform the
1221 A constructor or a conversion operator may have to be used to
1222 perform the initialization, but not both, as it would be ambiguous. */
1225 build_aggr_init (tree exp, tree init, int flags, tsubst_flags_t complain)
1230 tree type = TREE_TYPE (exp);
1231 int was_const = TREE_READONLY (exp);
1232 int was_volatile = TREE_THIS_VOLATILE (exp);
1235 if (init == error_mark_node)
1236 return error_mark_node;
1238 TREE_READONLY (exp) = 0;
1239 TREE_THIS_VOLATILE (exp) = 0;
1241 if (init && TREE_CODE (init) != TREE_LIST
1242 && !(BRACE_ENCLOSED_INITIALIZER_P (init)
1243 && CONSTRUCTOR_IS_DIRECT_INIT (init)))
1244 flags |= LOOKUP_ONLYCONVERTING;
1246 if (TREE_CODE (type) == ARRAY_TYPE)
1250 /* An array may not be initialized use the parenthesized
1251 initialization form -- unless the initializer is "()". */
1252 if (init && TREE_CODE (init) == TREE_LIST)
1254 if (complain & tf_error)
1255 error ("bad array initializer");
1256 return error_mark_node;
1258 /* Must arrange to initialize each element of EXP
1259 from elements of INIT. */
1260 itype = init ? TREE_TYPE (init) : NULL_TREE;
1261 if (cv_qualified_p (type))
1262 TREE_TYPE (exp) = cv_unqualified (type);
1263 if (itype && cv_qualified_p (itype))
1264 TREE_TYPE (init) = cv_unqualified (itype);
1265 stmt_expr = build_vec_init (exp, NULL_TREE, init,
1266 /*explicit_value_init_p=*/false,
1267 itype && same_type_p (TREE_TYPE (init),
1270 TREE_READONLY (exp) = was_const;
1271 TREE_THIS_VOLATILE (exp) = was_volatile;
1272 TREE_TYPE (exp) = type;
1274 TREE_TYPE (init) = itype;
1278 if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1279 /* Just know that we've seen something for this node. */
1280 TREE_USED (exp) = 1;
1282 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
1283 destroy_temps = stmts_are_full_exprs_p ();
1284 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
1285 expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1286 init, LOOKUP_NORMAL|flags, complain);
1287 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
1288 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
1289 TREE_READONLY (exp) = was_const;
1290 TREE_THIS_VOLATILE (exp) = was_volatile;
1296 expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags,
1297 tsubst_flags_t complain)
1299 tree type = TREE_TYPE (exp);
1302 /* It fails because there may not be a constructor which takes
1303 its own type as the first (or only parameter), but which does
1304 take other types via a conversion. So, if the thing initializing
1305 the expression is a unit element of type X, first try X(X&),
1306 followed by initialization by X. If neither of these work
1307 out, then look hard. */
1309 VEC(tree,gc) *parms;
1311 if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
1312 && CP_AGGREGATE_TYPE_P (type))
1314 /* A brace-enclosed initializer for an aggregate. In C++0x this can
1315 happen for direct-initialization, too. */
1316 init = digest_init (type, init);
1317 init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1318 TREE_SIDE_EFFECTS (init) = 1;
1319 finish_expr_stmt (init);
1323 if (init && TREE_CODE (init) != TREE_LIST
1324 && (flags & LOOKUP_ONLYCONVERTING))
1326 /* Base subobjects should only get direct-initialization. */
1327 gcc_assert (true_exp == exp);
1329 if (flags & DIRECT_BIND)
1330 /* Do nothing. We hit this in two cases: Reference initialization,
1331 where we aren't initializing a real variable, so we don't want
1332 to run a new constructor; and catching an exception, where we
1333 have already built up the constructor call so we could wrap it
1334 in an exception region. */;
1336 init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1338 if (TREE_CODE (init) == MUST_NOT_THROW_EXPR)
1339 /* We need to protect the initialization of a catch parm with a
1340 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1341 around the TARGET_EXPR for the copy constructor. See
1342 initialize_handler_parm. */
1344 TREE_OPERAND (init, 0) = build2 (INIT_EXPR, TREE_TYPE (exp), exp,
1345 TREE_OPERAND (init, 0));
1346 TREE_TYPE (init) = void_type_node;
1349 init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1350 TREE_SIDE_EFFECTS (init) = 1;
1351 finish_expr_stmt (init);
1355 if (init == NULL_TREE)
1357 else if (TREE_CODE (init) == TREE_LIST && !TREE_TYPE (init))
1359 parms = make_tree_vector ();
1360 for (; init != NULL_TREE; init = TREE_CHAIN (init))
1361 VEC_safe_push (tree, gc, parms, TREE_VALUE (init));
1364 parms = make_tree_vector_single (init);
1366 if (true_exp == exp)
1367 ctor_name = complete_ctor_identifier;
1369 ctor_name = base_ctor_identifier;
1371 rval = build_special_member_call (exp, ctor_name, &parms, binfo, flags,
1375 release_tree_vector (parms);
1377 if (TREE_SIDE_EFFECTS (rval))
1378 finish_expr_stmt (convert_to_void (rval, NULL, complain));
1381 /* This function is responsible for initializing EXP with INIT
1384 BINFO is the binfo of the type for who we are performing the
1385 initialization. For example, if W is a virtual base class of A and B,
1387 If we are initializing B, then W must contain B's W vtable, whereas
1388 were we initializing C, W must contain C's W vtable.
1390 TRUE_EXP is nonzero if it is the true expression being initialized.
1391 In this case, it may be EXP, or may just contain EXP. The reason we
1392 need this is because if EXP is a base element of TRUE_EXP, we
1393 don't necessarily know by looking at EXP where its virtual
1394 baseclass fields should really be pointing. But we do know
1395 from TRUE_EXP. In constructors, we don't know anything about
1396 the value being initialized.
1398 FLAGS is just passed to `build_new_method_call'. See that function
1399 for its description. */
1402 expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags,
1403 tsubst_flags_t complain)
1405 tree type = TREE_TYPE (exp);
1407 gcc_assert (init != error_mark_node && type != error_mark_node);
1408 gcc_assert (building_stmt_tree ());
1410 /* Use a function returning the desired type to initialize EXP for us.
1411 If the function is a constructor, and its first argument is
1412 NULL_TREE, know that it was meant for us--just slide exp on
1413 in and expand the constructor. Constructors now come
1416 if (init && TREE_CODE (exp) == VAR_DECL
1417 && COMPOUND_LITERAL_P (init))
1419 /* If store_init_value returns NULL_TREE, the INIT has been
1420 recorded as the DECL_INITIAL for EXP. That means there's
1421 nothing more we have to do. */
1422 init = store_init_value (exp, init, flags);
1424 finish_expr_stmt (init);
1428 /* If an explicit -- but empty -- initializer list was present,
1429 that's value-initialization. */
1430 if (init == void_type_node)
1432 /* If there's a user-provided constructor, we just call that. */
1433 if (type_has_user_provided_constructor (type))
1434 /* Fall through. */;
1435 /* If there isn't, but we still need to call the constructor,
1436 zero out the object first. */
1437 else if (TYPE_NEEDS_CONSTRUCTING (type))
1439 init = build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
1440 init = build2 (INIT_EXPR, type, exp, init);
1441 finish_expr_stmt (init);
1442 /* And then call the constructor. */
1444 /* If we don't need to mess with the constructor at all,
1445 then just zero out the object and we're done. */
1448 init = build2 (INIT_EXPR, type, exp, build_value_init_noctor (type));
1449 finish_expr_stmt (init);
1455 /* We know that expand_default_init can handle everything we want
1457 expand_default_init (binfo, true_exp, exp, init, flags, complain);
1460 /* Report an error if TYPE is not a user-defined, class type. If
1461 OR_ELSE is nonzero, give an error message. */
1464 is_class_type (tree type, int or_else)
1466 if (type == error_mark_node)
1469 if (! CLASS_TYPE_P (type))
1472 error ("%qT is not a class type", type);
1479 get_type_value (tree name)
1481 if (name == error_mark_node)
1484 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1485 return IDENTIFIER_TYPE_VALUE (name);
1490 /* Build a reference to a member of an aggregate. This is not a C++
1491 `&', but really something which can have its address taken, and
1492 then act as a pointer to member, for example TYPE :: FIELD can have
1493 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
1494 this expression is the operand of "&".
1496 @@ Prints out lousy diagnostics for operator <typename>
1499 @@ This function should be rewritten and placed in search.c. */
1502 build_offset_ref (tree type, tree member, bool address_p)
1505 tree basebinfo = NULL_TREE;
1507 /* class templates can come in as TEMPLATE_DECLs here. */
1508 if (TREE_CODE (member) == TEMPLATE_DECL)
1511 if (dependent_type_p (type) || type_dependent_expression_p (member))
1512 return build_qualified_name (NULL_TREE, type, member,
1513 /*template_p=*/false);
1515 gcc_assert (TYPE_P (type));
1516 if (! is_class_type (type, 1))
1517 return error_mark_node;
1519 gcc_assert (DECL_P (member) || BASELINK_P (member));
1520 /* Callers should call mark_used before this point. */
1521 gcc_assert (!DECL_P (member) || TREE_USED (member));
1523 if (!COMPLETE_TYPE_P (complete_type (type))
1524 && !TYPE_BEING_DEFINED (type))
1526 error ("incomplete type %qT does not have member %qD", type, member);
1527 return error_mark_node;
1530 /* Entities other than non-static members need no further
1532 if (TREE_CODE (member) == TYPE_DECL)
1534 if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1535 return convert_from_reference (member);
1537 if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1539 error ("invalid pointer to bit-field %qD", member);
1540 return error_mark_node;
1543 /* Set up BASEBINFO for member lookup. */
1544 decl = maybe_dummy_object (type, &basebinfo);
1546 /* A lot of this logic is now handled in lookup_member. */
1547 if (BASELINK_P (member))
1549 /* Go from the TREE_BASELINK to the member function info. */
1550 tree t = BASELINK_FUNCTIONS (member);
1552 if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1554 /* Get rid of a potential OVERLOAD around it. */
1555 t = OVL_CURRENT (t);
1557 /* Unique functions are handled easily. */
1559 /* For non-static member of base class, we need a special rule
1560 for access checking [class.protected]:
1562 If the access is to form a pointer to member, the
1563 nested-name-specifier shall name the derived class
1564 (or any class derived from that class). */
1565 if (address_p && DECL_P (t)
1566 && DECL_NONSTATIC_MEMBER_P (t))
1567 perform_or_defer_access_check (TYPE_BINFO (type), t, t);
1569 perform_or_defer_access_check (basebinfo, t, t);
1571 if (DECL_STATIC_FUNCTION_P (t))
1576 TREE_TYPE (member) = unknown_type_node;
1578 else if (address_p && TREE_CODE (member) == FIELD_DECL)
1579 /* We need additional test besides the one in
1580 check_accessibility_of_qualified_id in case it is
1581 a pointer to non-static member. */
1582 perform_or_defer_access_check (TYPE_BINFO (type), member, member);
1586 /* If MEMBER is non-static, then the program has fallen afoul of
1589 An id-expression that denotes a nonstatic data member or
1590 nonstatic member function of a class can only be used:
1592 -- as part of a class member access (_expr.ref_) in which the
1593 object-expression refers to the member's class or a class
1594 derived from that class, or
1596 -- to form a pointer to member (_expr.unary.op_), or
1598 -- in the body of a nonstatic member function of that class or
1599 of a class derived from that class (_class.mfct.nonstatic_), or
1601 -- in a mem-initializer for a constructor for that class or for
1602 a class derived from that class (_class.base.init_). */
1603 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1605 /* Build a representation of the qualified name suitable
1606 for use as the operand to "&" -- even though the "&" is
1607 not actually present. */
1608 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1609 /* In Microsoft mode, treat a non-static member function as if
1610 it were a pointer-to-member. */
1611 if (flag_ms_extensions)
1613 PTRMEM_OK_P (member) = 1;
1614 return cp_build_unary_op (ADDR_EXPR, member, 0,
1615 tf_warning_or_error);
1617 error ("invalid use of non-static member function %qD",
1618 TREE_OPERAND (member, 1));
1619 return error_mark_node;
1621 else if (TREE_CODE (member) == FIELD_DECL)
1623 error ("invalid use of non-static data member %qD", member);
1624 return error_mark_node;
1629 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1630 PTRMEM_OK_P (member) = 1;
1634 /* If DECL is a scalar enumeration constant or variable with a
1635 constant initializer, return the initializer (or, its initializers,
1636 recursively); otherwise, return DECL. If INTEGRAL_P, the
1637 initializer is only returned if DECL is an integral
1638 constant-expression. */
1641 constant_value_1 (tree decl, bool integral_p)
1643 while (TREE_CODE (decl) == CONST_DECL
1645 ? DECL_INTEGRAL_CONSTANT_VAR_P (decl)
1646 : (TREE_CODE (decl) == VAR_DECL
1647 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))))
1650 /* Static data members in template classes may have
1651 non-dependent initializers. References to such non-static
1652 data members are not value-dependent, so we must retrieve the
1653 initializer here. The DECL_INITIAL will have the right type,
1654 but will not have been folded because that would prevent us
1655 from performing all appropriate semantic checks at
1656 instantiation time. */
1657 if (DECL_CLASS_SCOPE_P (decl)
1658 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
1659 && uses_template_parms (CLASSTYPE_TI_ARGS
1660 (DECL_CONTEXT (decl))))
1662 ++processing_template_decl;
1663 init = fold_non_dependent_expr (DECL_INITIAL (decl));
1664 --processing_template_decl;
1668 /* If DECL is a static data member in a template
1669 specialization, we must instantiate it here. The
1670 initializer for the static data member is not processed
1671 until needed; we need it now. */
1673 init = DECL_INITIAL (decl);
1675 if (init == error_mark_node)
1677 if (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
1678 /* Treat the error as a constant to avoid cascading errors on
1679 excessively recursive template instantiation (c++/9335). */
1684 /* Initializers in templates are generally expanded during
1685 instantiation, so before that for const int i(2)
1686 INIT is a TREE_LIST with the actual initializer as
1688 if (processing_template_decl
1690 && TREE_CODE (init) == TREE_LIST
1691 && TREE_CHAIN (init) == NULL_TREE)
1692 init = TREE_VALUE (init);
1694 || !TREE_TYPE (init)
1696 ? !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (init))
1697 : (!TREE_CONSTANT (init)
1698 /* Do not return an aggregate constant (of which
1699 string literals are a special case), as we do not
1700 want to make inadvertent copies of such entities,
1701 and we must be sure that their addresses are the
1703 || TREE_CODE (init) == CONSTRUCTOR
1704 || TREE_CODE (init) == STRING_CST)))
1706 decl = unshare_expr (init);
1711 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1712 constant of integral or enumeration type, then return that value.
1713 These are those variables permitted in constant expressions by
1717 integral_constant_value (tree decl)
1719 return constant_value_1 (decl, /*integral_p=*/true);
1722 /* A more relaxed version of integral_constant_value, used by the
1723 common C/C++ code and by the C++ front end for optimization
1727 decl_constant_value (tree decl)
1729 return constant_value_1 (decl,
1730 /*integral_p=*/processing_template_decl);
1733 /* Common subroutines of build_new and build_vec_delete. */
1735 /* Call the global __builtin_delete to delete ADDR. */
1738 build_builtin_delete_call (tree addr)
1740 mark_used (global_delete_fndecl);
1741 return build_call_n (global_delete_fndecl, 1, addr);
1744 /* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
1745 the type of the object being allocated; otherwise, it's just TYPE.
1746 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
1747 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
1748 a vector of arguments to be provided as arguments to a placement
1749 new operator. This routine performs no semantic checks; it just
1750 creates and returns a NEW_EXPR. */
1753 build_raw_new_expr (VEC(tree,gc) *placement, tree type, tree nelts,
1754 VEC(tree,gc) *init, int use_global_new)
1759 /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR.
1760 If INIT is not NULL, then we want to store VOID_ZERO_NODE. This
1761 permits us to distinguish the case of a missing initializer "new
1762 int" from an empty initializer "new int()". */
1764 init_list = NULL_TREE;
1765 else if (VEC_empty (tree, init))
1766 init_list = void_zero_node;
1768 init_list = build_tree_list_vec (init);
1770 new_expr = build4 (NEW_EXPR, build_pointer_type (type),
1771 build_tree_list_vec (placement), type, nelts,
1773 NEW_EXPR_USE_GLOBAL (new_expr) = use_global_new;
1774 TREE_SIDE_EFFECTS (new_expr) = 1;
1779 /* Diagnose uninitialized const members or reference members of type
1780 TYPE. USING_NEW is used to disambiguate the diagnostic between a
1781 new expression without a new-initializer and a declaration. Returns
1785 diagnose_uninitialized_cst_or_ref_member_1 (tree type, tree origin,
1786 bool using_new, bool complain)
1789 int error_count = 0;
1791 if (type_has_user_provided_constructor (type))
1794 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1798 if (TREE_CODE (field) != FIELD_DECL)
1801 field_type = strip_array_types (TREE_TYPE (field));
1803 if (TREE_CODE (field_type) == REFERENCE_TYPE)
1809 error ("uninitialized reference member in %q#T "
1810 "using %<new%> without new-initializer", origin);
1812 error ("uninitialized reference member in %q#T", origin);
1813 inform (DECL_SOURCE_LOCATION (field),
1814 "%qD should be initialized", field);
1818 if (CP_TYPE_CONST_P (field_type))
1824 error ("uninitialized const member in %q#T "
1825 "using %<new%> without new-initializer", origin);
1827 error ("uninitialized const member in %q#T", origin);
1828 inform (DECL_SOURCE_LOCATION (field),
1829 "%qD should be initialized", field);
1833 if (CLASS_TYPE_P (field_type))
1835 += diagnose_uninitialized_cst_or_ref_member_1 (field_type, origin,
1836 using_new, complain);
1842 diagnose_uninitialized_cst_or_ref_member (tree type, bool using_new, bool complain)
1844 return diagnose_uninitialized_cst_or_ref_member_1 (type, type, using_new, complain);
1847 /* Generate code for a new-expression, including calling the "operator
1848 new" function, initializing the object, and, if an exception occurs
1849 during construction, cleaning up. The arguments are as for
1850 build_raw_new_expr. This may change PLACEMENT and INIT. */
1853 build_new_1 (VEC(tree,gc) **placement, tree type, tree nelts,
1854 VEC(tree,gc) **init, bool globally_qualified_p,
1855 tsubst_flags_t complain)
1858 /* True iff this is a call to "operator new[]" instead of just
1860 bool array_p = false;
1861 /* If ARRAY_P is true, the element type of the array. This is never
1862 an ARRAY_TYPE; for something like "new int[3][4]", the
1863 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
1866 /* The type of the new-expression. (This type is always a pointer
1869 tree non_const_pointer_type;
1870 tree outer_nelts = NULL_TREE;
1871 tree alloc_call, alloc_expr;
1872 /* The address returned by the call to "operator new". This node is
1873 a VAR_DECL and is therefore reusable. */
1876 tree cookie_expr, init_expr;
1877 int nothrow, check_new;
1878 int use_java_new = 0;
1879 /* If non-NULL, the number of extra bytes to allocate at the
1880 beginning of the storage allocated for an array-new expression in
1881 order to store the number of elements. */
1882 tree cookie_size = NULL_TREE;
1883 tree placement_first;
1884 tree placement_expr = NULL_TREE;
1885 /* True if the function we are calling is a placement allocation
1887 bool placement_allocation_fn_p;
1888 /* True if the storage must be initialized, either by a constructor
1889 or due to an explicit new-initializer. */
1890 bool is_initialized;
1891 /* The address of the thing allocated, not including any cookie. In
1892 particular, if an array cookie is in use, DATA_ADDR is the
1893 address of the first array element. This node is a VAR_DECL, and
1894 is therefore reusable. */
1896 tree init_preeval_expr = NULL_TREE;
1900 outer_nelts = nelts;
1903 else if (TREE_CODE (type) == ARRAY_TYPE)
1906 nelts = array_type_nelts_top (type);
1907 outer_nelts = nelts;
1908 type = TREE_TYPE (type);
1911 /* If our base type is an array, then make sure we know how many elements
1913 for (elt_type = type;
1914 TREE_CODE (elt_type) == ARRAY_TYPE;
1915 elt_type = TREE_TYPE (elt_type))
1916 nelts = cp_build_binary_op (input_location,
1918 array_type_nelts_top (elt_type),
1921 if (TREE_CODE (elt_type) == VOID_TYPE)
1923 if (complain & tf_error)
1924 error ("invalid type %<void%> for new");
1925 return error_mark_node;
1928 if (abstract_virtuals_error (NULL_TREE, elt_type))
1929 return error_mark_node;
1931 is_initialized = (TYPE_NEEDS_CONSTRUCTING (elt_type) || *init != NULL);
1935 bool maybe_uninitialized_error = false;
1936 /* A program that calls for default-initialization [...] of an
1937 entity of reference type is ill-formed. */
1938 if (CLASSTYPE_REF_FIELDS_NEED_INIT (elt_type))
1939 maybe_uninitialized_error = true;
1941 /* A new-expression that creates an object of type T initializes
1942 that object as follows:
1943 - If the new-initializer is omitted:
1944 -- If T is a (possibly cv-qualified) non-POD class type
1945 (or array thereof), the object is default-initialized (8.5).
1947 -- Otherwise, the object created has indeterminate
1948 value. If T is a const-qualified type, or a (possibly
1949 cv-qualified) POD class type (or array thereof)
1950 containing (directly or indirectly) a member of
1951 const-qualified type, the program is ill-formed; */
1953 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (elt_type))
1954 maybe_uninitialized_error = true;
1956 if (maybe_uninitialized_error
1957 && diagnose_uninitialized_cst_or_ref_member (elt_type,
1959 complain & tf_error))
1960 return error_mark_node;
1963 if (CP_TYPE_CONST_P (elt_type) && *init == NULL
1964 && !type_has_user_provided_default_constructor (elt_type))
1966 if (complain & tf_error)
1967 error ("uninitialized const in %<new%> of %q#T", elt_type);
1968 return error_mark_node;
1971 size = size_in_bytes (elt_type);
1973 size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
1975 alloc_fn = NULL_TREE;
1977 /* If PLACEMENT is a single simple pointer type not passed by
1978 reference, prepare to capture it in a temporary variable. Do
1979 this now, since PLACEMENT will change in the calls below. */
1980 placement_first = NULL_TREE;
1981 if (VEC_length (tree, *placement) == 1
1982 && (TREE_CODE (TREE_TYPE (VEC_index (tree, *placement, 0)))
1984 placement_first = VEC_index (tree, *placement, 0);
1986 /* Allocate the object. */
1987 if (VEC_empty (tree, *placement) && TYPE_FOR_JAVA (elt_type))
1990 tree class_decl = build_java_class_ref (elt_type);
1991 static const char alloc_name[] = "_Jv_AllocObject";
1993 if (class_decl == error_mark_node)
1994 return error_mark_node;
1997 if (!get_global_value_if_present (get_identifier (alloc_name),
2000 if (complain & tf_error)
2001 error ("call to Java constructor with %qs undefined", alloc_name);
2002 return error_mark_node;
2004 else if (really_overloaded_fn (alloc_fn))
2006 if (complain & tf_error)
2007 error ("%qD should never be overloaded", alloc_fn);
2008 return error_mark_node;
2010 alloc_fn = OVL_CURRENT (alloc_fn);
2011 class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
2012 alloc_call = (cp_build_function_call
2014 build_tree_list (NULL_TREE, class_addr),
2017 else if (TYPE_FOR_JAVA (elt_type) && MAYBE_CLASS_TYPE_P (elt_type))
2019 error ("Java class %q#T object allocated using placement new", elt_type);
2020 return error_mark_node;
2027 fnname = ansi_opname (array_p ? VEC_NEW_EXPR : NEW_EXPR);
2029 if (!globally_qualified_p
2030 && CLASS_TYPE_P (elt_type)
2032 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
2033 : TYPE_HAS_NEW_OPERATOR (elt_type)))
2035 /* Use a class-specific operator new. */
2036 /* If a cookie is required, add some extra space. */
2037 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
2039 cookie_size = targetm.cxx.get_cookie_size (elt_type);
2040 size = size_binop (PLUS_EXPR, size, cookie_size);
2042 /* Create the argument list. */
2043 VEC_safe_insert (tree, gc, *placement, 0, size);
2044 /* Do name-lookup to find the appropriate operator. */
2045 fns = lookup_fnfields (elt_type, fnname, /*protect=*/2);
2046 if (fns == NULL_TREE)
2048 if (complain & tf_error)
2049 error ("no suitable %qD found in class %qT", fnname, elt_type);
2050 return error_mark_node;
2052 if (TREE_CODE (fns) == TREE_LIST)
2054 if (complain & tf_error)
2056 error ("request for member %qD is ambiguous", fnname);
2057 print_candidates (fns);
2059 return error_mark_node;
2061 alloc_call = build_new_method_call (build_dummy_object (elt_type),
2063 /*conversion_path=*/NULL_TREE,
2070 /* Use a global operator new. */
2071 /* See if a cookie might be required. */
2072 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
2073 cookie_size = targetm.cxx.get_cookie_size (elt_type);
2075 cookie_size = NULL_TREE;
2077 alloc_call = build_operator_new_call (fnname, placement,
2078 &size, &cookie_size,
2083 if (alloc_call == error_mark_node)
2084 return error_mark_node;
2086 gcc_assert (alloc_fn != NULL_TREE);
2088 /* If we found a simple case of PLACEMENT_EXPR above, then copy it
2089 into a temporary variable. */
2090 if (!processing_template_decl
2091 && placement_first != NULL_TREE
2092 && TREE_CODE (alloc_call) == CALL_EXPR
2093 && call_expr_nargs (alloc_call) == 2
2094 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 0))) == INTEGER_TYPE
2095 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 1))) == POINTER_TYPE)
2097 tree placement_arg = CALL_EXPR_ARG (alloc_call, 1);
2099 if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg)))
2100 || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg))))
2102 placement_expr = get_target_expr (placement_first);
2103 CALL_EXPR_ARG (alloc_call, 1)
2104 = convert (TREE_TYPE (placement_arg), placement_expr);
2108 /* In the simple case, we can stop now. */
2109 pointer_type = build_pointer_type (type);
2110 if (!cookie_size && !is_initialized)
2111 return build_nop (pointer_type, alloc_call);
2113 /* Store the result of the allocation call in a variable so that we can
2114 use it more than once. */
2115 alloc_expr = get_target_expr (alloc_call);
2116 alloc_node = TARGET_EXPR_SLOT (alloc_expr);
2118 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
2119 while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
2120 alloc_call = TREE_OPERAND (alloc_call, 1);
2122 /* Now, check to see if this function is actually a placement
2123 allocation function. This can happen even when PLACEMENT is NULL
2124 because we might have something like:
2126 struct S { void* operator new (size_t, int i = 0); };
2128 A call to `new S' will get this allocation function, even though
2129 there is no explicit placement argument. If there is more than
2130 one argument, or there are variable arguments, then this is a
2131 placement allocation function. */
2132 placement_allocation_fn_p
2133 = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
2134 || varargs_function_p (alloc_fn));
2136 /* Preevaluate the placement args so that we don't reevaluate them for a
2137 placement delete. */
2138 if (placement_allocation_fn_p)
2141 stabilize_call (alloc_call, &inits);
2143 alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
2147 /* unless an allocation function is declared with an empty excep-
2148 tion-specification (_except.spec_), throw(), it indicates failure to
2149 allocate storage by throwing a bad_alloc exception (clause _except_,
2150 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2151 cation function is declared with an empty exception-specification,
2152 throw(), it returns null to indicate failure to allocate storage and a
2153 non-null pointer otherwise.
2155 So check for a null exception spec on the op new we just called. */
2157 nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
2158 check_new = (flag_check_new || nothrow) && ! use_java_new;
2166 /* Adjust so we're pointing to the start of the object. */
2167 data_addr = build2 (POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
2168 alloc_node, cookie_size);
2170 /* Store the number of bytes allocated so that we can know how
2171 many elements to destroy later. We use the last sizeof
2172 (size_t) bytes to store the number of elements. */
2173 cookie_ptr = size_binop (MINUS_EXPR, cookie_size, size_in_bytes (sizetype));
2174 cookie_ptr = fold_build2_loc (input_location,
2175 POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
2176 alloc_node, cookie_ptr);
2177 size_ptr_type = build_pointer_type (sizetype);
2178 cookie_ptr = fold_convert (size_ptr_type, cookie_ptr);
2179 cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
2181 cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
2183 if (targetm.cxx.cookie_has_size ())
2185 /* Also store the element size. */
2186 cookie_ptr = build2 (POINTER_PLUS_EXPR, size_ptr_type, cookie_ptr,
2187 fold_build1_loc (input_location,
2188 NEGATE_EXPR, sizetype,
2189 size_in_bytes (sizetype)));
2191 cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
2192 cookie = build2 (MODIFY_EXPR, sizetype, cookie,
2193 size_in_bytes (elt_type));
2194 cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
2195 cookie, cookie_expr);
2200 cookie_expr = NULL_TREE;
2201 data_addr = alloc_node;
2204 /* Now use a pointer to the type we've actually allocated. */
2206 /* But we want to operate on a non-const version to start with,
2207 since we'll be modifying the elements. */
2208 non_const_pointer_type = build_pointer_type
2209 (cp_build_qualified_type (type, cp_type_quals (type) & ~TYPE_QUAL_CONST));
2211 data_addr = fold_convert (non_const_pointer_type, data_addr);
2212 /* Any further uses of alloc_node will want this type, too. */
2213 alloc_node = fold_convert (non_const_pointer_type, alloc_node);
2215 /* Now initialize the allocated object. Note that we preevaluate the
2216 initialization expression, apart from the actual constructor call or
2217 assignment--we do this because we want to delay the allocation as long
2218 as possible in order to minimize the size of the exception region for
2219 placement delete. */
2223 bool explicit_value_init_p = false;
2225 if (*init != NULL && VEC_empty (tree, *init))
2228 explicit_value_init_p = true;
2233 tree vecinit = NULL_TREE;
2234 if (*init && VEC_length (tree, *init) == 1
2235 && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *init, 0))
2236 && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *init, 0)))
2238 tree arraytype, domain;
2239 vecinit = VEC_index (tree, *init, 0);
2240 if (TREE_CONSTANT (nelts))
2241 domain = compute_array_index_type (NULL_TREE, nelts);
2245 if (CONSTRUCTOR_NELTS (vecinit) > 0)
2246 warning (0, "non-constant array size in new, unable to "
2247 "verify length of initializer-list");
2249 arraytype = build_cplus_array_type (type, domain);
2250 vecinit = digest_init (arraytype, vecinit);
2254 if (complain & tf_error)
2255 permerror (input_location, "ISO C++ forbids initialization in array new");
2257 return error_mark_node;
2258 vecinit = build_tree_list_vec (*init);
2261 = build_vec_init (data_addr,
2262 cp_build_binary_op (input_location,
2263 MINUS_EXPR, outer_nelts,
2267 explicit_value_init_p,
2271 /* An array initialization is stable because the initialization
2272 of each element is a full-expression, so the temporaries don't
2278 init_expr = cp_build_indirect_ref (data_addr, RO_NULL, complain);
2280 if (TYPE_NEEDS_CONSTRUCTING (type) && !explicit_value_init_p)
2282 init_expr = build_special_member_call (init_expr,
2283 complete_ctor_identifier,
2288 else if (explicit_value_init_p)
2290 /* Something like `new int()'. */
2291 init_expr = build2 (INIT_EXPR, type,
2292 init_expr, build_value_init (type));
2298 /* We are processing something like `new int (10)', which
2299 means allocate an int, and initialize it with 10. */
2301 ie = build_x_compound_expr_from_vec (*init, "new initializer");
2302 init_expr = cp_build_modify_expr (init_expr, INIT_EXPR, ie,
2305 stable = stabilize_init (init_expr, &init_preeval_expr);
2308 if (init_expr == error_mark_node)
2309 return error_mark_node;
2311 /* If any part of the object initialization terminates by throwing an
2312 exception and a suitable deallocation function can be found, the
2313 deallocation function is called to free the memory in which the
2314 object was being constructed, after which the exception continues
2315 to propagate in the context of the new-expression. If no
2316 unambiguous matching deallocation function can be found,
2317 propagating the exception does not cause the object's memory to be
2319 if (flag_exceptions && ! use_java_new)
2321 enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
2324 /* The Standard is unclear here, but the right thing to do
2325 is to use the same method for finding deallocation
2326 functions that we use for finding allocation functions. */
2327 cleanup = (build_op_delete_call
2331 globally_qualified_p,
2332 placement_allocation_fn_p ? alloc_call : NULL_TREE,
2338 /* This is much simpler if we were able to preevaluate all of
2339 the arguments to the constructor call. */
2341 /* CLEANUP is compiler-generated, so no diagnostics. */
2342 TREE_NO_WARNING (cleanup) = true;
2343 init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2344 init_expr, cleanup);
2345 /* Likewise, this try-catch is compiler-generated. */
2346 TREE_NO_WARNING (init_expr) = true;
2349 /* Ack! First we allocate the memory. Then we set our sentry
2350 variable to true, and expand a cleanup that deletes the
2351 memory if sentry is true. Then we run the constructor, and
2352 finally clear the sentry.
2354 We need to do this because we allocate the space first, so
2355 if there are any temporaries with cleanups in the
2356 constructor args and we weren't able to preevaluate them, we
2357 need this EH region to extend until end of full-expression
2358 to preserve nesting. */
2360 tree end, sentry, begin;
2362 begin = get_target_expr (boolean_true_node);
2363 CLEANUP_EH_ONLY (begin) = 1;
2365 sentry = TARGET_EXPR_SLOT (begin);
2367 /* CLEANUP is compiler-generated, so no diagnostics. */
2368 TREE_NO_WARNING (cleanup) = true;
2370 TARGET_EXPR_CLEANUP (begin)
2371 = build3 (COND_EXPR, void_type_node, sentry,
2372 cleanup, void_zero_node);
2374 end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2375 sentry, boolean_false_node);
2378 = build2 (COMPOUND_EXPR, void_type_node, begin,
2379 build2 (COMPOUND_EXPR, void_type_node, init_expr,
2381 /* Likewise, this is compiler-generated. */
2382 TREE_NO_WARNING (init_expr) = true;
2387 init_expr = NULL_TREE;
2389 /* Now build up the return value in reverse order. */
2394 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2396 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2398 if (rval == data_addr)
2399 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2400 and return the call (which doesn't need to be adjusted). */
2401 rval = TARGET_EXPR_INITIAL (alloc_expr);
2406 tree ifexp = cp_build_binary_op (input_location,
2407 NE_EXPR, alloc_node,
2410 rval = build_conditional_expr (ifexp, rval, alloc_node,
2414 /* Perform the allocation before anything else, so that ALLOC_NODE
2415 has been initialized before we start using it. */
2416 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2419 if (init_preeval_expr)
2420 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2422 /* A new-expression is never an lvalue. */
2423 gcc_assert (!lvalue_p (rval));
2425 return convert (pointer_type, rval);
2428 /* Generate a representation for a C++ "new" expression. *PLACEMENT
2429 is a vector of placement-new arguments (or NULL if none). If NELTS
2430 is NULL, TYPE is the type of the storage to be allocated. If NELTS
2431 is not NULL, then this is an array-new allocation; TYPE is the type
2432 of the elements in the array and NELTS is the number of elements in
2433 the array. *INIT, if non-NULL, is the initializer for the new
2434 object, or an empty vector to indicate an initializer of "()". If
2435 USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
2436 rather than just "new". This may change PLACEMENT and INIT. */
2439 build_new (VEC(tree,gc) **placement, tree type, tree nelts,
2440 VEC(tree,gc) **init, int use_global_new, tsubst_flags_t complain)
2443 VEC(tree,gc) *orig_placement = NULL;
2444 tree orig_nelts = NULL_TREE;
2445 VEC(tree,gc) *orig_init = NULL;
2447 if (type == error_mark_node)
2448 return error_mark_node;
2450 if (nelts == NULL_TREE && VEC_length (tree, *init) == 1)
2452 tree auto_node = type_uses_auto (type);
2453 if (auto_node && describable_type (VEC_index (tree, *init, 0)))
2454 type = do_auto_deduction (type, VEC_index (tree, *init, 0), auto_node);
2457 if (processing_template_decl)
2459 if (dependent_type_p (type)
2460 || any_type_dependent_arguments_p (*placement)
2461 || (nelts && type_dependent_expression_p (nelts))
2462 || any_type_dependent_arguments_p (*init))
2463 return build_raw_new_expr (*placement, type, nelts, *init,
2466 orig_placement = make_tree_vector_copy (*placement);
2468 orig_init = make_tree_vector_copy (*init);
2470 make_args_non_dependent (*placement);
2472 nelts = build_non_dependent_expr (nelts);
2473 make_args_non_dependent (*init);
2478 if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
2480 if (complain & tf_error)
2481 permerror (input_location, "size in array new must have integral type");
2483 return error_mark_node;
2485 nelts = mark_rvalue_use (nelts);
2486 nelts = cp_save_expr (cp_convert (sizetype, nelts));
2489 /* ``A reference cannot be created by the new operator. A reference
2490 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2491 returned by new.'' ARM 5.3.3 */
2492 if (TREE_CODE (type) == REFERENCE_TYPE)
2494 if (complain & tf_error)
2495 error ("new cannot be applied to a reference type");
2497 return error_mark_node;
2498 type = TREE_TYPE (type);
2501 if (TREE_CODE (type) == FUNCTION_TYPE)
2503 if (complain & tf_error)
2504 error ("new cannot be applied to a function type");
2505 return error_mark_node;
2508 /* The type allocated must be complete. If the new-type-id was
2509 "T[N]" then we are just checking that "T" is complete here, but
2510 that is equivalent, since the value of "N" doesn't matter. */
2511 if (!complete_type_or_else (type, NULL_TREE))
2512 return error_mark_node;
2514 rval = build_new_1 (placement, type, nelts, init, use_global_new, complain);
2515 if (rval == error_mark_node)
2516 return error_mark_node;
2518 if (processing_template_decl)
2520 tree ret = build_raw_new_expr (orig_placement, type, orig_nelts,
2521 orig_init, use_global_new);
2522 release_tree_vector (orig_placement);
2523 release_tree_vector (orig_init);
2527 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2528 rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
2529 TREE_NO_WARNING (rval) = 1;
2534 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2537 build_java_class_ref (tree type)
2539 tree name = NULL_TREE, class_decl;
2540 static tree CL_suffix = NULL_TREE;
2541 if (CL_suffix == NULL_TREE)
2542 CL_suffix = get_identifier("class$");
2543 if (jclass_node == NULL_TREE)
2545 jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2546 if (jclass_node == NULL_TREE)
2548 error ("call to Java constructor, while %<jclass%> undefined");
2549 return error_mark_node;
2551 jclass_node = TREE_TYPE (jclass_node);
2554 /* Mangle the class$ field. */
2557 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2558 if (DECL_NAME (field) == CL_suffix)
2560 mangle_decl (field);
2561 name = DECL_ASSEMBLER_NAME (field);
2566 error ("can't find %<class$%> in %qT", type);
2567 return error_mark_node;
2571 class_decl = IDENTIFIER_GLOBAL_VALUE (name);
2572 if (class_decl == NULL_TREE)
2574 class_decl = build_decl (input_location,
2575 VAR_DECL, name, TREE_TYPE (jclass_node));
2576 TREE_STATIC (class_decl) = 1;
2577 DECL_EXTERNAL (class_decl) = 1;
2578 TREE_PUBLIC (class_decl) = 1;
2579 DECL_ARTIFICIAL (class_decl) = 1;
2580 DECL_IGNORED_P (class_decl) = 1;
2581 pushdecl_top_level (class_decl);
2582 make_decl_rtl (class_decl);
2588 build_vec_delete_1 (tree base, tree maxindex, tree type,
2589 special_function_kind auto_delete_vec, int use_global_delete)
2592 tree ptype = build_pointer_type (type = complete_type (type));
2593 tree size_exp = size_in_bytes (type);
2595 /* Temporary variables used by the loop. */
2596 tree tbase, tbase_init;
2598 /* This is the body of the loop that implements the deletion of a
2599 single element, and moves temp variables to next elements. */
2602 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2605 /* This is the thing that governs what to do after the loop has run. */
2606 tree deallocate_expr = 0;
2608 /* This is the BIND_EXPR which holds the outermost iterator of the
2609 loop. It is convenient to set this variable up and test it before
2610 executing any other code in the loop.
2611 This is also the containing expression returned by this function. */
2612 tree controller = NULL_TREE;
2615 /* We should only have 1-D arrays here. */
2616 gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2618 if (! MAYBE_CLASS_TYPE_P (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2621 /* The below is short by the cookie size. */
2622 virtual_size = size_binop (MULT_EXPR, size_exp,
2623 convert (sizetype, maxindex));
2625 tbase = create_temporary_var (ptype);
2626 tbase_init = cp_build_modify_expr (tbase, NOP_EXPR,
2627 fold_build2_loc (input_location,
2628 POINTER_PLUS_EXPR, ptype,
2629 fold_convert (ptype, base),
2631 tf_warning_or_error);
2632 controller = build3 (BIND_EXPR, void_type_node, tbase,
2633 NULL_TREE, NULL_TREE);
2634 TREE_SIDE_EFFECTS (controller) = 1;
2636 body = build1 (EXIT_EXPR, void_type_node,
2637 build2 (EQ_EXPR, boolean_type_node, tbase,
2638 fold_convert (ptype, base)));
2639 tmp = fold_build1_loc (input_location, NEGATE_EXPR, sizetype, size_exp);
2640 body = build_compound_expr
2642 body, cp_build_modify_expr (tbase, NOP_EXPR,
2643 build2 (POINTER_PLUS_EXPR, ptype, tbase, tmp),
2644 tf_warning_or_error));
2645 body = build_compound_expr
2647 body, build_delete (ptype, tbase, sfk_complete_destructor,
2648 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1));
2650 loop = build1 (LOOP_EXPR, void_type_node, body);
2651 loop = build_compound_expr (input_location, tbase_init, loop);
2654 /* If the delete flag is one, or anything else with the low bit set,
2655 delete the storage. */
2656 if (auto_delete_vec != sfk_base_destructor)
2660 /* The below is short by the cookie size. */
2661 virtual_size = size_binop (MULT_EXPR, size_exp,
2662 convert (sizetype, maxindex));
2664 if (! TYPE_VEC_NEW_USES_COOKIE (type))
2671 cookie_size = targetm.cxx.get_cookie_size (type);
2673 = cp_convert (ptype,
2674 cp_build_binary_op (input_location,
2676 cp_convert (string_type_node,
2679 tf_warning_or_error));
2680 /* True size with header. */
2681 virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2684 if (auto_delete_vec == sfk_deleting_destructor)
2685 deallocate_expr = build_op_delete_call (VEC_DELETE_EXPR,
2686 base_tbd, virtual_size,
2687 use_global_delete & 1,
2688 /*placement=*/NULL_TREE,
2689 /*alloc_fn=*/NULL_TREE);
2693 if (!deallocate_expr)
2696 body = deallocate_expr;
2698 body = build_compound_expr (input_location, body, deallocate_expr);
2701 body = integer_zero_node;
2703 /* Outermost wrapper: If pointer is null, punt. */
2704 body = fold_build3_loc (input_location, COND_EXPR, void_type_node,
2705 fold_build2_loc (input_location,
2706 NE_EXPR, boolean_type_node, base,
2707 convert (TREE_TYPE (base),
2708 integer_zero_node)),
2709 body, integer_zero_node);
2710 body = build1 (NOP_EXPR, void_type_node, body);
2714 TREE_OPERAND (controller, 1) = body;
2718 if (TREE_CODE (base) == SAVE_EXPR)
2719 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
2720 body = build2 (COMPOUND_EXPR, void_type_node, base, body);
2722 return convert_to_void (body, /*implicit=*/NULL, tf_warning_or_error);
2725 /* Create an unnamed variable of the indicated TYPE. */
2728 create_temporary_var (tree type)
2732 decl = build_decl (input_location,
2733 VAR_DECL, NULL_TREE, type);
2734 TREE_USED (decl) = 1;
2735 DECL_ARTIFICIAL (decl) = 1;
2736 DECL_IGNORED_P (decl) = 1;
2737 DECL_CONTEXT (decl) = current_function_decl;
2742 /* Create a new temporary variable of the indicated TYPE, initialized
2745 It is not entered into current_binding_level, because that breaks
2746 things when it comes time to do final cleanups (which take place
2747 "outside" the binding contour of the function). */
2750 get_temp_regvar (tree type, tree init)
2754 decl = create_temporary_var (type);
2755 add_decl_expr (decl);
2757 finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,
2758 tf_warning_or_error));
2763 /* `build_vec_init' returns tree structure that performs
2764 initialization of a vector of aggregate types.
2766 BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
2767 to the first element, of POINTER_TYPE.
2768 MAXINDEX is the maximum index of the array (one less than the
2769 number of elements). It is only used if BASE is a pointer or
2770 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2772 INIT is the (possibly NULL) initializer.
2774 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All
2775 elements in the array are value-initialized.
2777 FROM_ARRAY is 0 if we should init everything with INIT
2778 (i.e., every element initialized from INIT).
2779 FROM_ARRAY is 1 if we should index into INIT in parallel
2780 with initialization of DECL.
2781 FROM_ARRAY is 2 if we should index into INIT in parallel,
2782 but use assignment instead of initialization. */
2785 build_vec_init (tree base, tree maxindex, tree init,
2786 bool explicit_value_init_p,
2787 int from_array, tsubst_flags_t complain)
2790 tree base2 = NULL_TREE;
2791 tree itype = NULL_TREE;
2793 /* The type of BASE. */
2794 tree atype = TREE_TYPE (base);
2795 /* The type of an element in the array. */
2796 tree type = TREE_TYPE (atype);
2797 /* The element type reached after removing all outer array
2799 tree inner_elt_type;
2800 /* The type of a pointer to an element in the array. */
2805 tree try_block = NULL_TREE;
2806 int num_initialized_elts = 0;
2809 if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype))
2810 maxindex = array_type_nelts (atype);
2812 if (maxindex == NULL_TREE || maxindex == error_mark_node)
2813 return error_mark_node;
2815 if (explicit_value_init_p)
2818 inner_elt_type = strip_array_types (type);
2820 /* Look through the TARGET_EXPR around a compound literal. */
2821 if (init && TREE_CODE (init) == TARGET_EXPR
2822 && TREE_CODE (TARGET_EXPR_INITIAL (init)) == CONSTRUCTOR
2824 init = TARGET_EXPR_INITIAL (init);
2827 && TREE_CODE (atype) == ARRAY_TYPE
2829 ? (!CLASS_TYPE_P (inner_elt_type)
2830 || !TYPE_HAS_COMPLEX_ASSIGN_REF (inner_elt_type))
2831 : !TYPE_NEEDS_CONSTRUCTING (type))
2832 && ((TREE_CODE (init) == CONSTRUCTOR
2833 /* Don't do this if the CONSTRUCTOR might contain something
2834 that might throw and require us to clean up. */
2835 && (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))
2836 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
2839 /* Do non-default initialization of trivial arrays resulting from
2840 brace-enclosed initializers. In this case, digest_init and
2841 store_constructor will handle the semantics for us. */
2843 stmt_expr = build2 (INIT_EXPR, atype, base, init);
2847 maxindex = cp_convert (ptrdiff_type_node, maxindex);
2848 if (TREE_CODE (atype) == ARRAY_TYPE)
2850 ptype = build_pointer_type (type);
2851 base = cp_convert (ptype, decay_conversion (base));
2856 /* The code we are generating looks like:
2860 ptrdiff_t iterator = maxindex;
2862 for (; iterator != -1; --iterator) {
2863 ... initialize *t1 ...
2867 ... destroy elements that were constructed ...
2872 We can omit the try and catch blocks if we know that the
2873 initialization will never throw an exception, or if the array
2874 elements do not have destructors. We can omit the loop completely if
2875 the elements of the array do not have constructors.
2877 We actually wrap the entire body of the above in a STMT_EXPR, for
2880 When copying from array to another, when the array elements have
2881 only trivial copy constructors, we should use __builtin_memcpy
2882 rather than generating a loop. That way, we could take advantage
2883 of whatever cleverness the back end has for dealing with copies
2884 of blocks of memory. */
2886 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
2887 destroy_temps = stmts_are_full_exprs_p ();
2888 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2889 rval = get_temp_regvar (ptype, base);
2890 base = get_temp_regvar (ptype, rval);
2891 iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2893 /* If initializing one array from another, initialize element by
2894 element. We rely upon the below calls to do the argument
2895 checking. Evaluate the initializer before entering the try block. */
2896 if (from_array && init && TREE_CODE (init) != CONSTRUCTOR)
2898 base2 = decay_conversion (init);
2899 itype = TREE_TYPE (base2);
2900 base2 = get_temp_regvar (itype, base2);
2901 itype = TREE_TYPE (itype);
2904 /* Protect the entire array initialization so that we can destroy
2905 the partially constructed array if an exception is thrown.
2906 But don't do this if we're assigning. */
2907 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2910 try_block = begin_try_block ();
2913 if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
2915 /* Do non-default initialization of non-trivial arrays resulting from
2916 brace-enclosed initializers. */
2917 unsigned HOST_WIDE_INT idx;
2921 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
2923 tree baseref = build1 (INDIRECT_REF, type, base);
2925 num_initialized_elts++;
2927 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2928 if (MAYBE_CLASS_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
2929 finish_expr_stmt (build_aggr_init (baseref, elt, 0, complain));
2931 finish_expr_stmt (cp_build_modify_expr (baseref, NOP_EXPR,
2933 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2935 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
2937 finish_expr_stmt (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
2941 /* Clear out INIT so that we don't get confused below. */
2944 else if (from_array)
2947 /* OK, we set base2 above. */;
2948 else if (TYPE_LANG_SPECIFIC (type)
2949 && TYPE_NEEDS_CONSTRUCTING (type)
2950 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2952 if (complain & tf_error)
2953 error ("initializer ends prematurely");
2954 return error_mark_node;
2958 /* Now, default-initialize any remaining elements. We don't need to
2959 do that if a) the type does not need constructing, or b) we've
2960 already initialized all the elements.
2962 We do need to keep going if we're copying an array. */
2965 || ((TYPE_NEEDS_CONSTRUCTING (type) || explicit_value_init_p)
2966 && ! (host_integerp (maxindex, 0)
2967 && (num_initialized_elts
2968 == tree_low_cst (maxindex, 0) + 1))))
2970 /* If the ITERATOR is equal to -1, then we don't have to loop;
2971 we've already initialized all the elements. */
2976 for_stmt = begin_for_stmt ();
2977 finish_for_init_stmt (for_stmt);
2978 finish_for_cond (build2 (NE_EXPR, boolean_type_node, iterator,
2979 build_int_cst (TREE_TYPE (iterator), -1)),
2981 finish_for_expr (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
2985 to = build1 (INDIRECT_REF, type, base);
2992 from = build1 (INDIRECT_REF, itype, base2);
2996 if (from_array == 2)
2997 elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
2999 else if (TYPE_NEEDS_CONSTRUCTING (type))
3000 elt_init = build_aggr_init (to, from, 0, complain);
3002 elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
3007 else if (TREE_CODE (type) == ARRAY_TYPE)
3011 ("cannot initialize multi-dimensional array with initializer");
3012 elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
3014 explicit_value_init_p,
3017 else if (explicit_value_init_p)
3018 elt_init = build2 (INIT_EXPR, type, to,
3019 build_value_init (type));
3022 gcc_assert (TYPE_NEEDS_CONSTRUCTING (type));
3023 elt_init = build_aggr_init (to, init, 0, complain);
3026 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
3027 finish_expr_stmt (elt_init);
3028 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
3030 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
3033 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base2, 0,
3036 finish_for_stmt (for_stmt);
3039 /* Make sure to cleanup any partially constructed elements. */
3040 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
3044 tree m = cp_build_binary_op (input_location,
3045 MINUS_EXPR, maxindex, iterator,
3048 /* Flatten multi-dimensional array since build_vec_delete only
3049 expects one-dimensional array. */
3050 if (TREE_CODE (type) == ARRAY_TYPE)
3051 m = cp_build_binary_op (input_location,
3053 array_type_nelts_total (type),
3056 finish_cleanup_try_block (try_block);
3057 e = build_vec_delete_1 (rval, m,
3058 inner_elt_type, sfk_base_destructor,
3059 /*use_global_delete=*/0);
3060 finish_cleanup (e, try_block);
3063 /* The value of the array initialization is the array itself, RVAL
3064 is a pointer to the first element. */
3065 finish_stmt_expr_expr (rval, stmt_expr);
3067 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
3069 /* Now make the result have the correct type. */
3070 if (TREE_CODE (atype) == ARRAY_TYPE)
3072 atype = build_pointer_type (atype);
3073 stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
3074 stmt_expr = cp_build_indirect_ref (stmt_expr, RO_NULL, complain);
3075 TREE_NO_WARNING (stmt_expr) = 1;
3078 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
3082 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
3086 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags)
3092 case sfk_complete_destructor:
3093 name = complete_dtor_identifier;
3096 case sfk_base_destructor:
3097 name = base_dtor_identifier;
3100 case sfk_deleting_destructor:
3101 name = deleting_dtor_identifier;
3107 fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
3108 return build_new_method_call (exp, fn,
3110 /*conversion_path=*/NULL_TREE,
3113 tf_warning_or_error);
3116 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3117 ADDR is an expression which yields the store to be destroyed.
3118 AUTO_DELETE is the name of the destructor to call, i.e., either
3119 sfk_complete_destructor, sfk_base_destructor, or
3120 sfk_deleting_destructor.
3122 FLAGS is the logical disjunction of zero or more LOOKUP_
3123 flags. See cp-tree.h for more info. */
3126 build_delete (tree type, tree addr, special_function_kind auto_delete,
3127 int flags, int use_global_delete)
3131 if (addr == error_mark_node)
3132 return error_mark_node;
3134 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3135 set to `error_mark_node' before it gets properly cleaned up. */
3136 if (type == error_mark_node)
3137 return error_mark_node;
3139 type = TYPE_MAIN_VARIANT (type);
3141 addr = mark_rvalue_use (addr);
3143 if (TREE_CODE (type) == POINTER_TYPE)
3145 bool complete_p = true;
3147 type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
3148 if (TREE_CODE (type) == ARRAY_TYPE)
3151 /* We don't want to warn about delete of void*, only other
3152 incomplete types. Deleting other incomplete types
3153 invokes undefined behavior, but it is not ill-formed, so
3154 compile to something that would even do The Right Thing
3155 (TM) should the type have a trivial dtor and no delete
3157 if (!VOID_TYPE_P (type))
3159 complete_type (type);
3160 if (!COMPLETE_TYPE_P (type))
3162 if (warning (0, "possible problem detected in invocation of "
3163 "delete operator:"))
3165 cxx_incomplete_type_diagnostic (addr, type, DK_WARNING);
3166 inform (input_location, "neither the destructor nor the class-specific "
3167 "operator delete will be called, even if they are "
3168 "declared when the class is defined.");
3173 if (VOID_TYPE_P (type) || !complete_p || !MAYBE_CLASS_TYPE_P (type))
3174 /* Call the builtin operator delete. */
3175 return build_builtin_delete_call (addr);
3176 if (TREE_SIDE_EFFECTS (addr))
3177 addr = save_expr (addr);
3179 /* Throw away const and volatile on target type of addr. */
3180 addr = convert_force (build_pointer_type (type), addr, 0);
3182 else if (TREE_CODE (type) == ARRAY_TYPE)
3186 if (TYPE_DOMAIN (type) == NULL_TREE)
3188 error ("unknown array size in delete");
3189 return error_mark_node;
3191 return build_vec_delete (addr, array_type_nelts (type),
3192 auto_delete, use_global_delete);
3196 /* Don't check PROTECT here; leave that decision to the
3197 destructor. If the destructor is accessible, call it,
3198 else report error. */
3199 addr = cp_build_unary_op (ADDR_EXPR, addr, 0, tf_warning_or_error);
3200 if (TREE_SIDE_EFFECTS (addr))
3201 addr = save_expr (addr);
3203 addr = convert_force (build_pointer_type (type), addr, 0);
3206 gcc_assert (MAYBE_CLASS_TYPE_P (type));
3208 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
3210 if (auto_delete != sfk_deleting_destructor)
3211 return void_zero_node;
3213 return build_op_delete_call (DELETE_EXPR, addr,
3214 cxx_sizeof_nowarn (type),
3216 /*placement=*/NULL_TREE,
3217 /*alloc_fn=*/NULL_TREE);
3221 tree head = NULL_TREE;
3222 tree do_delete = NULL_TREE;
3225 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
3226 lazily_declare_fn (sfk_destructor, type);
3228 /* For `::delete x', we must not use the deleting destructor
3229 since then we would not be sure to get the global `operator
3231 if (use_global_delete && auto_delete == sfk_deleting_destructor)
3233 /* We will use ADDR multiple times so we must save it. */
3234 addr = save_expr (addr);
3235 head = get_target_expr (build_headof (addr));
3236 /* Delete the object. */
3237 do_delete = build_builtin_delete_call (head);
3238 /* Otherwise, treat this like a complete object destructor
3240 auto_delete = sfk_complete_destructor;
3242 /* If the destructor is non-virtual, there is no deleting
3243 variant. Instead, we must explicitly call the appropriate
3244 `operator delete' here. */
3245 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
3246 && auto_delete == sfk_deleting_destructor)
3248 /* We will use ADDR multiple times so we must save it. */
3249 addr = save_expr (addr);
3250 /* Build the call. */
3251 do_delete = build_op_delete_call (DELETE_EXPR,
3253 cxx_sizeof_nowarn (type),
3255 /*placement=*/NULL_TREE,
3256 /*alloc_fn=*/NULL_TREE);
3257 /* Call the complete object destructor. */
3258 auto_delete = sfk_complete_destructor;
3260 else if (auto_delete == sfk_deleting_destructor
3261 && TYPE_GETS_REG_DELETE (type))
3263 /* Make sure we have access to the member op delete, even though
3264 we'll actually be calling it from the destructor. */
3265 build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
3267 /*placement=*/NULL_TREE,
3268 /*alloc_fn=*/NULL_TREE);
3271 expr = build_dtor_call (cp_build_indirect_ref (addr, RO_NULL,
3272 tf_warning_or_error),
3273 auto_delete, flags);
3275 expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
3277 /* We need to calculate this before the dtor changes the vptr. */
3279 expr = build2 (COMPOUND_EXPR, void_type_node, head, expr);
3281 if (flags & LOOKUP_DESTRUCTOR)
3282 /* Explicit destructor call; don't check for null pointer. */
3283 ifexp = integer_one_node;
3285 /* Handle deleting a null pointer. */
3286 ifexp = fold (cp_build_binary_op (input_location,
3287 NE_EXPR, addr, integer_zero_node,
3288 tf_warning_or_error));
3290 if (ifexp != integer_one_node)
3291 expr = build3 (COND_EXPR, void_type_node,
3292 ifexp, expr, void_zero_node);
3298 /* At the beginning of a destructor, push cleanups that will call the
3299 destructors for our base classes and members.
3301 Called from begin_destructor_body. */
3304 push_base_cleanups (void)
3306 tree binfo, base_binfo;
3310 VEC(tree,gc) *vbases;
3312 /* Run destructors for all virtual baseclasses. */
3313 if (CLASSTYPE_VBASECLASSES (current_class_type))
3315 tree cond = (condition_conversion
3316 (build2 (BIT_AND_EXPR, integer_type_node,
3317 current_in_charge_parm,
3318 integer_two_node)));
3320 /* The CLASSTYPE_VBASECLASSES vector is in initialization
3321 order, which is also the right order for pushing cleanups. */
3322 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
3323 VEC_iterate (tree, vbases, i, base_binfo); i++)
3325 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
3327 expr = build_special_member_call (current_class_ref,
3328 base_dtor_identifier,
3332 | LOOKUP_NONVIRTUAL),
3333 tf_warning_or_error);
3334 expr = build3 (COND_EXPR, void_type_node, cond,
3335 expr, void_zero_node);
3336 finish_decl_cleanup (NULL_TREE, expr);
3341 /* Take care of the remaining baseclasses. */
3342 for (binfo = TYPE_BINFO (current_class_type), i = 0;
3343 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
3345 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
3346 || BINFO_VIRTUAL_P (base_binfo))
3349 expr = build_special_member_call (current_class_ref,
3350 base_dtor_identifier,
3352 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
3353 tf_warning_or_error);
3354 finish_decl_cleanup (NULL_TREE, expr);
3357 for (member = TYPE_FIELDS (current_class_type); member;
3358 member = TREE_CHAIN (member))
3360 if (TREE_TYPE (member) == error_mark_node
3361 || TREE_CODE (member) != FIELD_DECL
3362 || DECL_ARTIFICIAL (member))
3364 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
3366 tree this_member = (build_class_member_access_expr
3367 (current_class_ref, member,
3368 /*access_path=*/NULL_TREE,
3369 /*preserve_reference=*/false,
3370 tf_warning_or_error));
3371 tree this_type = TREE_TYPE (member);
3372 expr = build_delete (this_type, this_member,
3373 sfk_complete_destructor,
3374 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
3376 finish_decl_cleanup (NULL_TREE, expr);
3381 /* Build a C++ vector delete expression.
3382 MAXINDEX is the number of elements to be deleted.
3383 ELT_SIZE is the nominal size of each element in the vector.
3384 BASE is the expression that should yield the store to be deleted.
3385 This function expands (or synthesizes) these calls itself.
3386 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3388 This also calls delete for virtual baseclasses of elements of the vector.
3390 Update: MAXINDEX is no longer needed. The size can be extracted from the
3391 start of the vector for pointers, and from the type for arrays. We still
3392 use MAXINDEX for arrays because it happens to already have one of the
3393 values we'd have to extract. (We could use MAXINDEX with pointers to
3394 confirm the size, and trap if the numbers differ; not clear that it'd
3395 be worth bothering.) */
3398 build_vec_delete (tree base, tree maxindex,
3399 special_function_kind auto_delete_vec, int use_global_delete)
3403 tree base_init = NULL_TREE;
3405 type = TREE_TYPE (base);
3407 if (TREE_CODE (type) == POINTER_TYPE)
3409 /* Step back one from start of vector, and read dimension. */
3411 tree size_ptr_type = build_pointer_type (sizetype);
3413 if (TREE_SIDE_EFFECTS (base))
3415 base_init = get_target_expr (base);
3416 base = TARGET_EXPR_SLOT (base_init);
3418 type = strip_array_types (TREE_TYPE (type));
3419 cookie_addr = fold_build1_loc (input_location, NEGATE_EXPR,
3420 sizetype, TYPE_SIZE_UNIT (sizetype));
3421 cookie_addr = build2 (POINTER_PLUS_EXPR,
3423 fold_convert (size_ptr_type, base),
3425 maxindex = cp_build_indirect_ref (cookie_addr, RO_NULL, tf_warning_or_error);
3427 else if (TREE_CODE (type) == ARRAY_TYPE)
3429 /* Get the total number of things in the array, maxindex is a
3431 maxindex = array_type_nelts_total (type);
3432 type = strip_array_types (type);
3433 base = cp_build_unary_op (ADDR_EXPR, base, 1, tf_warning_or_error);
3434 if (TREE_SIDE_EFFECTS (base))
3436 base_init = get_target_expr (base);
3437 base = TARGET_EXPR_SLOT (base_init);
3442 if (base != error_mark_node)
3443 error ("type to vector delete is neither pointer or array type");
3444 return error_mark_node;
3447 rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3450 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);