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"
36 static bool begin_init_stmts (tree *, tree *);
37 static tree finish_init_stmts (bool, tree, tree);
38 static void construct_virtual_base (tree, tree);
39 static void expand_aggr_init_1 (tree, tree, tree, tree, int, tsubst_flags_t);
40 static void expand_default_init (tree, tree, tree, tree, int, tsubst_flags_t);
41 static tree build_vec_delete_1 (tree, tree, tree, special_function_kind, int);
42 static void perform_member_init (tree, tree);
43 static tree build_builtin_delete_call (tree);
44 static int member_init_ok_or_else (tree, tree, tree);
45 static void expand_virtual_init (tree, tree);
46 static tree sort_mem_initializers (tree, tree);
47 static tree initializing_context (tree);
48 static void expand_cleanup_for_base (tree, tree);
49 static tree get_temp_regvar (tree, tree);
50 static tree dfs_initialize_vtbl_ptrs (tree, void *);
51 static tree build_dtor_call (tree, special_function_kind, int);
52 static tree build_field_list (tree, tree, int *);
53 static tree build_vtbl_address (tree);
54 static int diagnose_uninitialized_cst_or_ref_member_1 (tree, tree, bool, bool);
56 /* We are about to generate some complex initialization code.
57 Conceptually, it is all a single expression. However, we may want
58 to include conditionals, loops, and other such statement-level
59 constructs. Therefore, we build the initialization code inside a
60 statement-expression. This function starts such an expression.
61 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
62 pass them back to finish_init_stmts when the expression is
66 begin_init_stmts (tree *stmt_expr_p, tree *compound_stmt_p)
68 bool is_global = !building_stmt_tree ();
70 *stmt_expr_p = begin_stmt_expr ();
71 *compound_stmt_p = begin_compound_stmt (BCS_NO_SCOPE);
76 /* Finish out the statement-expression begun by the previous call to
77 begin_init_stmts. Returns the statement-expression itself. */
80 finish_init_stmts (bool is_global, tree stmt_expr, tree compound_stmt)
82 finish_compound_stmt (compound_stmt);
84 stmt_expr = finish_stmt_expr (stmt_expr, true);
86 gcc_assert (!building_stmt_tree () == is_global);
93 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
94 which we want to initialize the vtable pointer for, DATA is
95 TREE_LIST whose TREE_VALUE is the this ptr expression. */
98 dfs_initialize_vtbl_ptrs (tree binfo, void *data)
100 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
101 return dfs_skip_bases;
103 if (!BINFO_PRIMARY_P (binfo) || BINFO_VIRTUAL_P (binfo))
105 tree base_ptr = TREE_VALUE ((tree) data);
107 base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /*nonnull=*/1);
109 expand_virtual_init (binfo, base_ptr);
115 /* Initialize all the vtable pointers in the object pointed to by
119 initialize_vtbl_ptrs (tree addr)
124 type = TREE_TYPE (TREE_TYPE (addr));
125 list = build_tree_list (type, addr);
127 /* Walk through the hierarchy, initializing the vptr in each base
128 class. We do these in pre-order because we can't find the virtual
129 bases for a class until we've initialized the vtbl for that
131 dfs_walk_once (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs, NULL, list);
134 /* Return an expression for the zero-initialization of an object with
135 type T. This expression will either be a constant (in the case
136 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
137 aggregate), or NULL (in the case that T does not require
138 initialization). In either case, the value can be used as
139 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
140 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
141 is the number of elements in the array. If STATIC_STORAGE_P is
142 TRUE, initializers are only generated for entities for which
143 zero-initialization does not simply mean filling the storage with
147 build_zero_init (tree type, tree nelts, bool static_storage_p)
149 tree init = NULL_TREE;
153 To zero-initialize an object of type T means:
155 -- if T is a scalar type, the storage is set to the value of zero
158 -- if T is a non-union class type, the storage for each nonstatic
159 data member and each base-class subobject is zero-initialized.
161 -- if T is a union type, the storage for its first data member is
164 -- if T is an array type, the storage for each element is
167 -- if T is a reference type, no initialization is performed. */
169 gcc_assert (nelts == NULL_TREE || TREE_CODE (nelts) == INTEGER_CST);
171 if (type == error_mark_node)
173 else if (static_storage_p && zero_init_p (type))
174 /* In order to save space, we do not explicitly build initializers
175 for items that do not need them. GCC's semantics are that
176 items with static storage duration that are not otherwise
177 initialized are initialized to zero. */
179 else if (SCALAR_TYPE_P (type))
180 init = convert (type, integer_zero_node);
181 else if (CLASS_TYPE_P (type))
184 VEC(constructor_elt,gc) *v = NULL;
186 /* Iterate over the fields, building initializations. */
187 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
189 if (TREE_CODE (field) != FIELD_DECL)
192 /* Note that for class types there will be FIELD_DECLs
193 corresponding to base classes as well. Thus, iterating
194 over TYPE_FIELDs will result in correct initialization of
195 all of the subobjects. */
196 if (!static_storage_p || !zero_init_p (TREE_TYPE (field)))
198 tree value = build_zero_init (TREE_TYPE (field),
202 CONSTRUCTOR_APPEND_ELT(v, field, value);
205 /* For unions, only the first field is initialized. */
206 if (TREE_CODE (type) == UNION_TYPE)
210 /* Build a constructor to contain the initializations. */
211 init = build_constructor (type, v);
213 else if (TREE_CODE (type) == ARRAY_TYPE)
216 VEC(constructor_elt,gc) *v = NULL;
218 /* Iterate over the array elements, building initializations. */
220 max_index = fold_build2_loc (input_location,
221 MINUS_EXPR, TREE_TYPE (nelts),
222 nelts, integer_one_node);
224 max_index = array_type_nelts (type);
226 /* If we have an error_mark here, we should just return error mark
227 as we don't know the size of the array yet. */
228 if (max_index == error_mark_node)
229 return error_mark_node;
230 gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
232 /* A zero-sized array, which is accepted as an extension, will
233 have an upper bound of -1. */
234 if (!tree_int_cst_equal (max_index, integer_minus_one_node))
238 v = VEC_alloc (constructor_elt, gc, 1);
239 ce = VEC_quick_push (constructor_elt, v, NULL);
241 /* If this is a one element array, we just use a regular init. */
242 if (tree_int_cst_equal (size_zero_node, max_index))
243 ce->index = size_zero_node;
245 ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
248 ce->value = build_zero_init (TREE_TYPE (type),
253 /* Build a constructor to contain the initializations. */
254 init = build_constructor (type, v);
256 else if (TREE_CODE (type) == VECTOR_TYPE)
257 init = fold_convert (type, integer_zero_node);
259 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
261 /* In all cases, the initializer is a constant. */
263 TREE_CONSTANT (init) = 1;
268 /* Return a suitable initializer for value-initializing an object of type
269 TYPE, as described in [dcl.init]. */
272 build_value_init (tree type)
276 To value-initialize an object of type T means:
278 - if T is a class type (clause 9) with a user-provided constructor
279 (12.1), then the default constructor for T is called (and the
280 initialization is ill-formed if T has no accessible default
283 - if T is a non-union class type without a user-provided constructor,
284 then every non-static data member and base-class component of T is
285 value-initialized;92)
287 - if T is an array type, then each element is value-initialized;
289 - otherwise, the object is zero-initialized.
291 A program that calls for default-initialization or
292 value-initialization of an entity of reference type is ill-formed.
294 92) Value-initialization for such a class object may be implemented by
295 zero-initializing the object and then calling the default
298 if (CLASS_TYPE_P (type))
300 if (type_has_user_provided_constructor (type))
301 return build_aggr_init_expr
303 build_special_member_call (NULL_TREE, complete_ctor_identifier,
304 NULL, type, LOOKUP_NORMAL,
305 tf_warning_or_error));
306 else if (TREE_CODE (type) != UNION_TYPE && TYPE_NEEDS_CONSTRUCTING (type))
308 /* This is a class that needs constructing, but doesn't have
309 a user-provided constructor. So we need to zero-initialize
310 the object and then call the implicitly defined ctor.
311 This will be handled in simplify_aggr_init_expr. */
312 tree ctor = build_special_member_call
313 (NULL_TREE, complete_ctor_identifier,
314 NULL, type, LOOKUP_NORMAL, tf_warning_or_error);
316 ctor = build_aggr_init_expr (type, ctor);
317 AGGR_INIT_ZERO_FIRST (ctor) = 1;
321 return build_value_init_noctor (type);
324 /* Like build_value_init, but don't call the constructor for TYPE. Used
325 for base initializers. */
328 build_value_init_noctor (tree type)
330 if (CLASS_TYPE_P (type))
332 gcc_assert (!TYPE_NEEDS_CONSTRUCTING (type));
334 if (TREE_CODE (type) != UNION_TYPE)
337 VEC(constructor_elt,gc) *v = NULL;
339 /* Iterate over the fields, building initializations. */
340 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
344 if (TREE_CODE (field) != FIELD_DECL)
347 ftype = TREE_TYPE (field);
349 if (TREE_CODE (ftype) == REFERENCE_TYPE)
350 error ("value-initialization of reference");
352 /* We could skip vfields and fields of types with
353 user-defined constructors, but I think that won't improve
354 performance at all; it should be simpler in general just
355 to zero out the entire object than try to only zero the
356 bits that actually need it. */
358 /* Note that for class types there will be FIELD_DECLs
359 corresponding to base classes as well. Thus, iterating
360 over TYPE_FIELDs will result in correct initialization of
361 all of the subobjects. */
362 value = build_value_init (ftype);
365 CONSTRUCTOR_APPEND_ELT(v, field, value);
368 /* Build a constructor to contain the zero- initializations. */
369 return build_constructor (type, v);
372 else if (TREE_CODE (type) == ARRAY_TYPE)
374 VEC(constructor_elt,gc) *v = NULL;
376 /* Iterate over the array elements, building initializations. */
377 tree max_index = array_type_nelts (type);
379 /* If we have an error_mark here, we should just return error mark
380 as we don't know the size of the array yet. */
381 if (max_index == error_mark_node)
382 return error_mark_node;
383 gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
385 /* A zero-sized array, which is accepted as an extension, will
386 have an upper bound of -1. */
387 if (!tree_int_cst_equal (max_index, integer_minus_one_node))
391 v = VEC_alloc (constructor_elt, gc, 1);
392 ce = VEC_quick_push (constructor_elt, v, NULL);
394 /* If this is a one element array, we just use a regular init. */
395 if (tree_int_cst_equal (size_zero_node, max_index))
396 ce->index = size_zero_node;
398 ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
401 ce->value = build_value_init (TREE_TYPE (type));
403 /* The gimplifier can't deal with a RANGE_EXPR of TARGET_EXPRs. */
404 gcc_assert (TREE_CODE (ce->value) != TARGET_EXPR
405 && TREE_CODE (ce->value) != AGGR_INIT_EXPR);
408 /* Build a constructor to contain the initializations. */
409 return build_constructor (type, v);
412 return build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
415 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
416 arguments. If TREE_LIST is void_type_node, an empty initializer
417 list was given; if NULL_TREE no initializer was given. */
420 perform_member_init (tree member, tree init)
423 tree type = TREE_TYPE (member);
425 /* Effective C++ rule 12 requires that all data members be
427 if (warn_ecpp && init == NULL_TREE && TREE_CODE (type) != ARRAY_TYPE)
428 warning_at (DECL_SOURCE_LOCATION (current_function_decl), OPT_Weffc__,
429 "%qD should be initialized in the member initialization list",
432 /* Get an lvalue for the data member. */
433 decl = build_class_member_access_expr (current_class_ref, member,
434 /*access_path=*/NULL_TREE,
435 /*preserve_reference=*/true,
436 tf_warning_or_error);
437 if (decl == error_mark_node)
440 if (init == void_type_node)
442 /* mem() means value-initialization. */
443 if (TREE_CODE (type) == ARRAY_TYPE)
445 init = build_vec_init (decl, NULL_TREE, NULL_TREE,
446 /*explicit_value_init_p=*/true,
448 tf_warning_or_error);
449 finish_expr_stmt (init);
453 if (TREE_CODE (type) == REFERENCE_TYPE)
454 permerror (DECL_SOURCE_LOCATION (current_function_decl),
455 "value-initialization of %q#D, which has reference type",
459 init = build2 (INIT_EXPR, type, decl, build_value_init (type));
460 finish_expr_stmt (init);
464 /* Deal with this here, as we will get confused if we try to call the
465 assignment op for an anonymous union. This can happen in a
466 synthesized copy constructor. */
467 else if (ANON_AGGR_TYPE_P (type))
471 init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init));
472 finish_expr_stmt (init);
475 else if (TYPE_NEEDS_CONSTRUCTING (type))
477 if (init != NULL_TREE
478 && TREE_CODE (type) == ARRAY_TYPE
479 && TREE_CHAIN (init) == NULL_TREE
480 && TREE_CODE (TREE_TYPE (TREE_VALUE (init))) == ARRAY_TYPE)
482 /* Initialization of one array from another. */
483 finish_expr_stmt (build_vec_init (decl, NULL_TREE, TREE_VALUE (init),
484 /*explicit_value_init_p=*/false,
486 tf_warning_or_error));
490 if (CP_TYPE_CONST_P (type)
492 && !type_has_user_provided_default_constructor (type))
493 /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
494 vtable; still give this diagnostic. */
495 permerror (DECL_SOURCE_LOCATION (current_function_decl),
496 "uninitialized member %qD with %<const%> type %qT",
498 finish_expr_stmt (build_aggr_init (decl, init, 0,
499 tf_warning_or_error));
504 if (init == NULL_TREE)
507 /* member traversal: note it leaves init NULL */
508 if (TREE_CODE (type) == REFERENCE_TYPE)
509 permerror (DECL_SOURCE_LOCATION (current_function_decl),
510 "uninitialized reference member %qD",
512 else if (CP_TYPE_CONST_P (type))
513 permerror (DECL_SOURCE_LOCATION (current_function_decl),
514 "uninitialized member %qD with %<const%> type %qT",
517 core_type = strip_array_types (type);
518 if (CLASS_TYPE_P (core_type)
519 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)
520 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)))
521 diagnose_uninitialized_cst_or_ref_member (core_type,
525 else if (TREE_CODE (init) == TREE_LIST)
526 /* There was an explicit member initialization. Do some work
528 init = build_x_compound_expr_from_list (init, ELK_MEM_INIT,
529 tf_warning_or_error);
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 = DECL_CHAIN (fields))
570 /* Skip CONST_DECLs for enumeration constants and so forth. */
571 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
574 fieldtype = TREE_TYPE (fields);
575 /* Keep track of whether or not any fields are unions. */
576 if (TREE_CODE (fieldtype) == UNION_TYPE)
579 /* For an anonymous struct or union, we must recursively
580 consider the fields of the anonymous type. They can be
581 directly initialized from the constructor. */
582 if (ANON_AGGR_TYPE_P (fieldtype))
584 /* Add this field itself. Synthesized copy constructors
585 initialize the entire aggregate. */
586 list = tree_cons (fields, NULL_TREE, list);
587 /* And now add the fields in the anonymous aggregate. */
588 list = build_field_list (fieldtype, list, uses_unions_p);
590 /* Add this field. */
591 else if (DECL_NAME (fields))
592 list = tree_cons (fields, NULL_TREE, list);
598 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
599 a FIELD_DECL or BINFO in T that needs initialization. The
600 TREE_VALUE gives the initializer, or list of initializer arguments.
602 Return a TREE_LIST containing all of the initializations required
603 for T, in the order in which they should be performed. The output
604 list has the same format as the input. */
607 sort_mem_initializers (tree t, tree mem_inits)
610 tree base, binfo, base_binfo;
613 VEC(tree,gc) *vbases;
617 /* Build up a list of initializations. The TREE_PURPOSE of entry
618 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
619 TREE_VALUE will be the constructor arguments, or NULL if no
620 explicit initialization was provided. */
621 sorted_inits = NULL_TREE;
623 /* Process the virtual bases. */
624 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
625 VEC_iterate (tree, vbases, i, base); i++)
626 sorted_inits = tree_cons (base, NULL_TREE, sorted_inits);
628 /* Process the direct bases. */
629 for (binfo = TYPE_BINFO (t), i = 0;
630 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
631 if (!BINFO_VIRTUAL_P (base_binfo))
632 sorted_inits = tree_cons (base_binfo, NULL_TREE, sorted_inits);
634 /* Process the non-static data members. */
635 sorted_inits = build_field_list (t, sorted_inits, &uses_unions_p);
636 /* Reverse the entire list of initializations, so that they are in
637 the order that they will actually be performed. */
638 sorted_inits = nreverse (sorted_inits);
640 /* If the user presented the initializers in an order different from
641 that in which they will actually occur, we issue a warning. Keep
642 track of the next subobject which can be explicitly initialized
643 without issuing a warning. */
644 next_subobject = sorted_inits;
646 /* Go through the explicit initializers, filling in TREE_PURPOSE in
648 for (init = mem_inits; init; init = TREE_CHAIN (init))
653 subobject = TREE_PURPOSE (init);
655 /* If the explicit initializers are in sorted order, then
656 SUBOBJECT will be NEXT_SUBOBJECT, or something following
658 for (subobject_init = next_subobject;
660 subobject_init = TREE_CHAIN (subobject_init))
661 if (TREE_PURPOSE (subobject_init) == subobject)
664 /* Issue a warning if the explicit initializer order does not
665 match that which will actually occur.
666 ??? Are all these on the correct lines? */
667 if (warn_reorder && !subobject_init)
669 if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)
670 warning (OPT_Wreorder, "%q+D will be initialized after",
671 TREE_PURPOSE (next_subobject));
673 warning (OPT_Wreorder, "base %qT will be initialized after",
674 TREE_PURPOSE (next_subobject));
675 if (TREE_CODE (subobject) == FIELD_DECL)
676 warning (OPT_Wreorder, " %q+#D", subobject);
678 warning (OPT_Wreorder, " base %qT", subobject);
679 warning_at (DECL_SOURCE_LOCATION (current_function_decl),
680 OPT_Wreorder, " when initialized here");
683 /* Look again, from the beginning of the list. */
686 subobject_init = sorted_inits;
687 while (TREE_PURPOSE (subobject_init) != subobject)
688 subobject_init = TREE_CHAIN (subobject_init);
691 /* It is invalid to initialize the same subobject more than
693 if (TREE_VALUE (subobject_init))
695 if (TREE_CODE (subobject) == FIELD_DECL)
696 error_at (DECL_SOURCE_LOCATION (current_function_decl),
697 "multiple initializations given for %qD",
700 error_at (DECL_SOURCE_LOCATION (current_function_decl),
701 "multiple initializations given for base %qT",
705 /* Record the initialization. */
706 TREE_VALUE (subobject_init) = TREE_VALUE (init);
707 next_subobject = subobject_init;
712 If a ctor-initializer specifies more than one mem-initializer for
713 multiple members of the same union (including members of
714 anonymous unions), the ctor-initializer is ill-formed.
716 Here we also splice out uninitialized union members. */
719 tree last_field = NULL_TREE;
721 for (p = &sorted_inits; *p; )
729 field = TREE_PURPOSE (init);
731 /* Skip base classes. */
732 if (TREE_CODE (field) != FIELD_DECL)
735 /* If this is an anonymous union with no explicit initializer,
737 if (!TREE_VALUE (init) && ANON_UNION_TYPE_P (TREE_TYPE (field)))
740 /* See if this field is a member of a union, or a member of a
741 structure contained in a union, etc. */
742 for (ctx = DECL_CONTEXT (field);
743 !same_type_p (ctx, t);
744 ctx = TYPE_CONTEXT (ctx))
745 if (TREE_CODE (ctx) == UNION_TYPE)
747 /* If this field is not a member of a union, skip it. */
748 if (TREE_CODE (ctx) != UNION_TYPE)
751 /* If this union member has no explicit initializer, splice
753 if (!TREE_VALUE (init))
756 /* It's only an error if we have two initializers for the same
764 /* See if LAST_FIELD and the field initialized by INIT are
765 members of the same union. If so, there's a problem,
766 unless they're actually members of the same structure
767 which is itself a member of a union. For example, given:
769 union { struct { int i; int j; }; };
771 initializing both `i' and `j' makes sense. */
772 ctx = DECL_CONTEXT (field);
778 last_ctx = DECL_CONTEXT (last_field);
781 if (same_type_p (last_ctx, ctx))
783 if (TREE_CODE (ctx) == UNION_TYPE)
784 error_at (DECL_SOURCE_LOCATION (current_function_decl),
785 "initializations for multiple members of %qT",
791 if (same_type_p (last_ctx, t))
794 last_ctx = TYPE_CONTEXT (last_ctx);
797 /* If we've reached the outermost class, then we're
799 if (same_type_p (ctx, t))
802 ctx = TYPE_CONTEXT (ctx);
809 p = &TREE_CHAIN (*p);
812 *p = TREE_CHAIN (*p);
820 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
821 is a TREE_LIST giving the explicit mem-initializer-list for the
822 constructor. The TREE_PURPOSE of each entry is a subobject (a
823 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
824 is a TREE_LIST giving the arguments to the constructor or
825 void_type_node for an empty list of arguments. */
828 emit_mem_initializers (tree mem_inits)
830 /* We will already have issued an error message about the fact that
831 the type is incomplete. */
832 if (!COMPLETE_TYPE_P (current_class_type))
835 /* Sort the mem-initializers into the order in which the
836 initializations should be performed. */
837 mem_inits = sort_mem_initializers (current_class_type, mem_inits);
839 in_base_initializer = 1;
841 /* Initialize base classes. */
843 && TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)
845 tree subobject = TREE_PURPOSE (mem_inits);
846 tree arguments = TREE_VALUE (mem_inits);
848 /* If these initializations are taking place in a copy constructor,
849 the base class should probably be explicitly initialized if there
850 is a user-defined constructor in the base class (other than the
851 default constructor, which will be called anyway). */
852 if (extra_warnings && !arguments
853 && DECL_COPY_CONSTRUCTOR_P (current_function_decl)
854 && type_has_user_nondefault_constructor (BINFO_TYPE (subobject)))
855 warning_at (DECL_SOURCE_LOCATION (current_function_decl), OPT_Wextra,
856 "base class %q#T should be explicitly initialized in the "
858 BINFO_TYPE (subobject));
860 /* Initialize the base. */
861 if (BINFO_VIRTUAL_P (subobject))
862 construct_virtual_base (subobject, arguments);
867 base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
869 expand_aggr_init_1 (subobject, NULL_TREE,
870 cp_build_indirect_ref (base_addr, RO_NULL,
871 tf_warning_or_error),
874 tf_warning_or_error);
875 expand_cleanup_for_base (subobject, NULL_TREE);
878 mem_inits = TREE_CHAIN (mem_inits);
880 in_base_initializer = 0;
882 /* Initialize the vptrs. */
883 initialize_vtbl_ptrs (current_class_ptr);
885 /* Initialize the data members. */
888 perform_member_init (TREE_PURPOSE (mem_inits),
889 TREE_VALUE (mem_inits));
890 mem_inits = TREE_CHAIN (mem_inits);
894 /* Returns the address of the vtable (i.e., the value that should be
895 assigned to the vptr) for BINFO. */
898 build_vtbl_address (tree binfo)
900 tree binfo_for = binfo;
903 if (BINFO_VPTR_INDEX (binfo) && BINFO_VIRTUAL_P (binfo))
904 /* If this is a virtual primary base, then the vtable we want to store
905 is that for the base this is being used as the primary base of. We
906 can't simply skip the initialization, because we may be expanding the
907 inits of a subobject constructor where the virtual base layout
909 while (BINFO_PRIMARY_P (binfo_for))
910 binfo_for = BINFO_INHERITANCE_CHAIN (binfo_for);
912 /* Figure out what vtable BINFO's vtable is based on, and mark it as
914 vtbl = get_vtbl_decl_for_binfo (binfo_for);
915 TREE_USED (vtbl) = 1;
917 /* Now compute the address to use when initializing the vptr. */
918 vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
919 if (TREE_CODE (vtbl) == VAR_DECL)
920 vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
925 /* This code sets up the virtual function tables appropriate for
926 the pointer DECL. It is a one-ply initialization.
928 BINFO is the exact type that DECL is supposed to be. In
929 multiple inheritance, this might mean "C's A" if C : A, B. */
932 expand_virtual_init (tree binfo, tree decl)
937 /* Compute the initializer for vptr. */
938 vtbl = build_vtbl_address (binfo);
940 /* We may get this vptr from a VTT, if this is a subobject
941 constructor or subobject destructor. */
942 vtt_index = BINFO_VPTR_INDEX (binfo);
948 /* Compute the value to use, when there's a VTT. */
949 vtt_parm = current_vtt_parm;
950 vtbl2 = build2 (POINTER_PLUS_EXPR,
951 TREE_TYPE (vtt_parm),
954 vtbl2 = cp_build_indirect_ref (vtbl2, RO_NULL, tf_warning_or_error);
955 vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
957 /* The actual initializer is the VTT value only in the subobject
958 constructor. In maybe_clone_body we'll substitute NULL for
959 the vtt_parm in the case of the non-subobject constructor. */
960 vtbl = build3 (COND_EXPR,
962 build2 (EQ_EXPR, boolean_type_node,
963 current_in_charge_parm, integer_zero_node),
968 /* Compute the location of the vtpr. */
969 vtbl_ptr = build_vfield_ref (cp_build_indirect_ref (decl, RO_NULL,
970 tf_warning_or_error),
972 gcc_assert (vtbl_ptr != error_mark_node);
974 /* Assign the vtable to the vptr. */
975 vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
976 finish_expr_stmt (cp_build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl,
977 tf_warning_or_error));
980 /* If an exception is thrown in a constructor, those base classes already
981 constructed must be destroyed. This function creates the cleanup
982 for BINFO, which has just been constructed. If FLAG is non-NULL,
983 it is a DECL which is nonzero when this base needs to be
987 expand_cleanup_for_base (tree binfo, tree flag)
991 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
994 /* Call the destructor. */
995 expr = build_special_member_call (current_class_ref,
996 base_dtor_identifier,
999 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
1000 tf_warning_or_error);
1002 expr = fold_build3_loc (input_location,
1003 COND_EXPR, void_type_node,
1004 c_common_truthvalue_conversion (input_location, flag),
1005 expr, integer_zero_node);
1007 finish_eh_cleanup (expr);
1010 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
1014 construct_virtual_base (tree vbase, tree arguments)
1020 /* If there are virtual base classes with destructors, we need to
1021 emit cleanups to destroy them if an exception is thrown during
1022 the construction process. These exception regions (i.e., the
1023 period during which the cleanups must occur) begin from the time
1024 the construction is complete to the end of the function. If we
1025 create a conditional block in which to initialize the
1026 base-classes, then the cleanup region for the virtual base begins
1027 inside a block, and ends outside of that block. This situation
1028 confuses the sjlj exception-handling code. Therefore, we do not
1029 create a single conditional block, but one for each
1030 initialization. (That way the cleanup regions always begin
1031 in the outer block.) We trust the back end to figure out
1032 that the FLAG will not change across initializations, and
1033 avoid doing multiple tests. */
1034 flag = DECL_CHAIN (DECL_ARGUMENTS (current_function_decl));
1035 inner_if_stmt = begin_if_stmt ();
1036 finish_if_stmt_cond (flag, inner_if_stmt);
1038 /* Compute the location of the virtual base. If we're
1039 constructing virtual bases, then we must be the most derived
1040 class. Therefore, we don't have to look up the virtual base;
1041 we already know where it is. */
1042 exp = convert_to_base_statically (current_class_ref, vbase);
1044 expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
1045 LOOKUP_COMPLAIN, tf_warning_or_error);
1046 finish_then_clause (inner_if_stmt);
1047 finish_if_stmt (inner_if_stmt);
1049 expand_cleanup_for_base (vbase, flag);
1052 /* Find the context in which this FIELD can be initialized. */
1055 initializing_context (tree field)
1057 tree t = DECL_CONTEXT (field);
1059 /* Anonymous union members can be initialized in the first enclosing
1060 non-anonymous union context. */
1061 while (t && ANON_AGGR_TYPE_P (t))
1062 t = TYPE_CONTEXT (t);
1066 /* Function to give error message if member initialization specification
1067 is erroneous. FIELD is the member we decided to initialize.
1068 TYPE is the type for which the initialization is being performed.
1069 FIELD must be a member of TYPE.
1071 MEMBER_NAME is the name of the member. */
1074 member_init_ok_or_else (tree field, tree type, tree member_name)
1076 if (field == error_mark_node)
1080 error ("class %qT does not have any field named %qD", type,
1084 if (TREE_CODE (field) == VAR_DECL)
1086 error ("%q#D is a static data member; it can only be "
1087 "initialized at its definition",
1091 if (TREE_CODE (field) != FIELD_DECL)
1093 error ("%q#D is not a non-static data member of %qT",
1097 if (initializing_context (field) != type)
1099 error ("class %qT does not have any field named %qD", type,
1107 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1108 is a _TYPE node or TYPE_DECL which names a base for that type.
1109 Check the validity of NAME, and return either the base _TYPE, base
1110 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
1111 NULL_TREE and issue a diagnostic.
1113 An old style unnamed direct single base construction is permitted,
1114 where NAME is NULL. */
1117 expand_member_init (tree name)
1122 if (!current_class_ref)
1127 /* This is an obsolete unnamed base class initializer. The
1128 parser will already have warned about its use. */
1129 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type)))
1132 error ("unnamed initializer for %qT, which has no base classes",
1133 current_class_type);
1136 basetype = BINFO_TYPE
1137 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0));
1140 error ("unnamed initializer for %qT, which uses multiple inheritance",
1141 current_class_type);
1145 else if (TYPE_P (name))
1147 basetype = TYPE_MAIN_VARIANT (name);
1148 name = TYPE_NAME (name);
1150 else if (TREE_CODE (name) == TYPE_DECL)
1151 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
1153 basetype = NULL_TREE;
1162 if (current_template_parms)
1165 class_binfo = TYPE_BINFO (current_class_type);
1166 direct_binfo = NULL_TREE;
1167 virtual_binfo = NULL_TREE;
1169 /* Look for a direct base. */
1170 for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i)
1171 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo), basetype))
1174 /* Look for a virtual base -- unless the direct base is itself
1176 if (!direct_binfo || !BINFO_VIRTUAL_P (direct_binfo))
1177 virtual_binfo = binfo_for_vbase (basetype, current_class_type);
1179 /* [class.base.init]
1181 If a mem-initializer-id is ambiguous because it designates
1182 both a direct non-virtual base class and an inherited virtual
1183 base class, the mem-initializer is ill-formed. */
1184 if (direct_binfo && virtual_binfo)
1186 error ("%qD is both a direct base and an indirect virtual base",
1191 if (!direct_binfo && !virtual_binfo)
1193 if (CLASSTYPE_VBASECLASSES (current_class_type))
1194 error ("type %qT is not a direct or virtual base of %qT",
1195 basetype, current_class_type);
1197 error ("type %qT is not a direct base of %qT",
1198 basetype, current_class_type);
1202 return direct_binfo ? direct_binfo : virtual_binfo;
1206 if (TREE_CODE (name) == IDENTIFIER_NODE)
1207 field = lookup_field (current_class_type, name, 1, false);
1211 if (member_init_ok_or_else (field, current_class_type, name))
1218 /* This is like `expand_member_init', only it stores one aggregate
1221 INIT comes in two flavors: it is either a value which
1222 is to be stored in EXP, or it is a parameter list
1223 to go to a constructor, which will operate on EXP.
1224 If INIT is not a parameter list for a constructor, then set
1225 LOOKUP_ONLYCONVERTING.
1226 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1227 the initializer, if FLAGS is 0, then it is the (init) form.
1228 If `init' is a CONSTRUCTOR, then we emit a warning message,
1229 explaining that such initializations are invalid.
1231 If INIT resolves to a CALL_EXPR which happens to return
1232 something of the type we are looking for, then we know
1233 that we can safely use that call to perform the
1236 The virtual function table pointer cannot be set up here, because
1237 we do not really know its type.
1239 This never calls operator=().
1241 When initializing, nothing is CONST.
1243 A default copy constructor may have to be used to perform the
1246 A constructor or a conversion operator may have to be used to
1247 perform the initialization, but not both, as it would be ambiguous. */
1250 build_aggr_init (tree exp, tree init, int flags, tsubst_flags_t complain)
1255 tree type = TREE_TYPE (exp);
1256 int was_const = TREE_READONLY (exp);
1257 int was_volatile = TREE_THIS_VOLATILE (exp);
1260 if (init == error_mark_node)
1261 return error_mark_node;
1263 TREE_READONLY (exp) = 0;
1264 TREE_THIS_VOLATILE (exp) = 0;
1266 if (init && TREE_CODE (init) != TREE_LIST
1267 && !(BRACE_ENCLOSED_INITIALIZER_P (init)
1268 && CONSTRUCTOR_IS_DIRECT_INIT (init)))
1269 flags |= LOOKUP_ONLYCONVERTING;
1271 if (TREE_CODE (type) == ARRAY_TYPE)
1275 /* An array may not be initialized use the parenthesized
1276 initialization form -- unless the initializer is "()". */
1277 if (init && TREE_CODE (init) == TREE_LIST)
1279 if (complain & tf_error)
1280 error ("bad array initializer");
1281 return error_mark_node;
1283 /* Must arrange to initialize each element of EXP
1284 from elements of INIT. */
1285 itype = init ? TREE_TYPE (init) : NULL_TREE;
1286 if (cv_qualified_p (type))
1287 TREE_TYPE (exp) = cv_unqualified (type);
1288 if (itype && cv_qualified_p (itype))
1289 TREE_TYPE (init) = cv_unqualified (itype);
1290 stmt_expr = build_vec_init (exp, NULL_TREE, init,
1291 /*explicit_value_init_p=*/false,
1292 itype && same_type_p (TREE_TYPE (init),
1295 TREE_READONLY (exp) = was_const;
1296 TREE_THIS_VOLATILE (exp) = was_volatile;
1297 TREE_TYPE (exp) = type;
1299 TREE_TYPE (init) = itype;
1303 if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1304 /* Just know that we've seen something for this node. */
1305 TREE_USED (exp) = 1;
1307 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
1308 destroy_temps = stmts_are_full_exprs_p ();
1309 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
1310 expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1311 init, LOOKUP_NORMAL|flags, complain);
1312 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
1313 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
1314 TREE_READONLY (exp) = was_const;
1315 TREE_THIS_VOLATILE (exp) = was_volatile;
1321 expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags,
1322 tsubst_flags_t complain)
1324 tree type = TREE_TYPE (exp);
1327 /* It fails because there may not be a constructor which takes
1328 its own type as the first (or only parameter), but which does
1329 take other types via a conversion. So, if the thing initializing
1330 the expression is a unit element of type X, first try X(X&),
1331 followed by initialization by X. If neither of these work
1332 out, then look hard. */
1334 VEC(tree,gc) *parms;
1336 if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
1337 && CP_AGGREGATE_TYPE_P (type))
1339 /* A brace-enclosed initializer for an aggregate. In C++0x this can
1340 happen for direct-initialization, too. */
1341 init = digest_init (type, init);
1342 init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1343 TREE_SIDE_EFFECTS (init) = 1;
1344 finish_expr_stmt (init);
1348 if (init && TREE_CODE (init) != TREE_LIST
1349 && (flags & LOOKUP_ONLYCONVERTING))
1351 /* Base subobjects should only get direct-initialization. */
1352 gcc_assert (true_exp == exp);
1354 if (flags & DIRECT_BIND)
1355 /* Do nothing. We hit this in two cases: Reference initialization,
1356 where we aren't initializing a real variable, so we don't want
1357 to run a new constructor; and catching an exception, where we
1358 have already built up the constructor call so we could wrap it
1359 in an exception region. */;
1361 init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1363 if (TREE_CODE (init) == MUST_NOT_THROW_EXPR)
1364 /* We need to protect the initialization of a catch parm with a
1365 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1366 around the TARGET_EXPR for the copy constructor. See
1367 initialize_handler_parm. */
1369 TREE_OPERAND (init, 0) = build2 (INIT_EXPR, TREE_TYPE (exp), exp,
1370 TREE_OPERAND (init, 0));
1371 TREE_TYPE (init) = void_type_node;
1374 init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1375 TREE_SIDE_EFFECTS (init) = 1;
1376 finish_expr_stmt (init);
1380 if (init == NULL_TREE)
1382 else if (TREE_CODE (init) == TREE_LIST && !TREE_TYPE (init))
1384 parms = make_tree_vector ();
1385 for (; init != NULL_TREE; init = TREE_CHAIN (init))
1386 VEC_safe_push (tree, gc, parms, TREE_VALUE (init));
1389 parms = make_tree_vector_single (init);
1391 if (true_exp == exp)
1392 ctor_name = complete_ctor_identifier;
1394 ctor_name = base_ctor_identifier;
1396 rval = build_special_member_call (exp, ctor_name, &parms, binfo, flags,
1400 release_tree_vector (parms);
1402 if (TREE_SIDE_EFFECTS (rval))
1403 finish_expr_stmt (convert_to_void (rval, ICV_CAST, complain));
1406 /* This function is responsible for initializing EXP with INIT
1409 BINFO is the binfo of the type for who we are performing the
1410 initialization. For example, if W is a virtual base class of A and B,
1412 If we are initializing B, then W must contain B's W vtable, whereas
1413 were we initializing C, W must contain C's W vtable.
1415 TRUE_EXP is nonzero if it is the true expression being initialized.
1416 In this case, it may be EXP, or may just contain EXP. The reason we
1417 need this is because if EXP is a base element of TRUE_EXP, we
1418 don't necessarily know by looking at EXP where its virtual
1419 baseclass fields should really be pointing. But we do know
1420 from TRUE_EXP. In constructors, we don't know anything about
1421 the value being initialized.
1423 FLAGS is just passed to `build_new_method_call'. See that function
1424 for its description. */
1427 expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags,
1428 tsubst_flags_t complain)
1430 tree type = TREE_TYPE (exp);
1432 gcc_assert (init != error_mark_node && type != error_mark_node);
1433 gcc_assert (building_stmt_tree ());
1435 /* Use a function returning the desired type to initialize EXP for us.
1436 If the function is a constructor, and its first argument is
1437 NULL_TREE, know that it was meant for us--just slide exp on
1438 in and expand the constructor. Constructors now come
1441 if (init && TREE_CODE (exp) == VAR_DECL
1442 && COMPOUND_LITERAL_P (init))
1444 /* If store_init_value returns NULL_TREE, the INIT has been
1445 recorded as the DECL_INITIAL for EXP. That means there's
1446 nothing more we have to do. */
1447 init = store_init_value (exp, init, flags);
1449 finish_expr_stmt (init);
1453 /* If an explicit -- but empty -- initializer list was present,
1454 that's value-initialization. */
1455 if (init == void_type_node)
1457 /* If there's a user-provided constructor, we just call that. */
1458 if (type_has_user_provided_constructor (type))
1459 /* Fall through. */;
1460 /* If there isn't, but we still need to call the constructor,
1461 zero out the object first. */
1462 else if (TYPE_NEEDS_CONSTRUCTING (type))
1464 init = build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
1465 init = build2 (INIT_EXPR, type, exp, init);
1466 finish_expr_stmt (init);
1467 /* And then call the constructor. */
1469 /* If we don't need to mess with the constructor at all,
1470 then just zero out the object and we're done. */
1473 init = build2 (INIT_EXPR, type, exp, build_value_init_noctor (type));
1474 finish_expr_stmt (init);
1480 /* We know that expand_default_init can handle everything we want
1482 expand_default_init (binfo, true_exp, exp, init, flags, complain);
1485 /* Report an error if TYPE is not a user-defined, class type. If
1486 OR_ELSE is nonzero, give an error message. */
1489 is_class_type (tree type, int or_else)
1491 if (type == error_mark_node)
1494 if (! CLASS_TYPE_P (type))
1497 error ("%qT is not a class type", type);
1504 get_type_value (tree name)
1506 if (name == error_mark_node)
1509 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1510 return IDENTIFIER_TYPE_VALUE (name);
1515 /* Build a reference to a member of an aggregate. This is not a C++
1516 `&', but really something which can have its address taken, and
1517 then act as a pointer to member, for example TYPE :: FIELD can have
1518 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
1519 this expression is the operand of "&".
1521 @@ Prints out lousy diagnostics for operator <typename>
1524 @@ This function should be rewritten and placed in search.c. */
1527 build_offset_ref (tree type, tree member, bool address_p)
1530 tree basebinfo = NULL_TREE;
1532 /* class templates can come in as TEMPLATE_DECLs here. */
1533 if (TREE_CODE (member) == TEMPLATE_DECL)
1536 if (dependent_scope_p (type) || type_dependent_expression_p (member))
1537 return build_qualified_name (NULL_TREE, type, member,
1538 /*template_p=*/false);
1540 gcc_assert (TYPE_P (type));
1541 if (! is_class_type (type, 1))
1542 return error_mark_node;
1544 gcc_assert (DECL_P (member) || BASELINK_P (member));
1545 /* Callers should call mark_used before this point. */
1546 gcc_assert (!DECL_P (member) || TREE_USED (member));
1548 type = TYPE_MAIN_VARIANT (type);
1549 if (!COMPLETE_OR_OPEN_TYPE_P (complete_type (type)))
1551 error ("incomplete type %qT does not have member %qD", type, member);
1552 return error_mark_node;
1555 /* Entities other than non-static members need no further
1557 if (TREE_CODE (member) == TYPE_DECL)
1559 if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1560 return convert_from_reference (member);
1562 if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1564 error ("invalid pointer to bit-field %qD", member);
1565 return error_mark_node;
1568 /* Set up BASEBINFO for member lookup. */
1569 decl = maybe_dummy_object (type, &basebinfo);
1571 /* A lot of this logic is now handled in lookup_member. */
1572 if (BASELINK_P (member))
1574 /* Go from the TREE_BASELINK to the member function info. */
1575 tree t = BASELINK_FUNCTIONS (member);
1577 if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1579 /* Get rid of a potential OVERLOAD around it. */
1580 t = OVL_CURRENT (t);
1582 /* Unique functions are handled easily. */
1584 /* For non-static member of base class, we need a special rule
1585 for access checking [class.protected]:
1587 If the access is to form a pointer to member, the
1588 nested-name-specifier shall name the derived class
1589 (or any class derived from that class). */
1590 if (address_p && DECL_P (t)
1591 && DECL_NONSTATIC_MEMBER_P (t))
1592 perform_or_defer_access_check (TYPE_BINFO (type), t, t);
1594 perform_or_defer_access_check (basebinfo, t, t);
1596 if (DECL_STATIC_FUNCTION_P (t))
1601 TREE_TYPE (member) = unknown_type_node;
1603 else if (address_p && TREE_CODE (member) == FIELD_DECL)
1604 /* We need additional test besides the one in
1605 check_accessibility_of_qualified_id in case it is
1606 a pointer to non-static member. */
1607 perform_or_defer_access_check (TYPE_BINFO (type), member, member);
1611 /* If MEMBER is non-static, then the program has fallen afoul of
1614 An id-expression that denotes a nonstatic data member or
1615 nonstatic member function of a class can only be used:
1617 -- as part of a class member access (_expr.ref_) in which the
1618 object-expression refers to the member's class or a class
1619 derived from that class, or
1621 -- to form a pointer to member (_expr.unary.op_), or
1623 -- in the body of a nonstatic member function of that class or
1624 of a class derived from that class (_class.mfct.nonstatic_), or
1626 -- in a mem-initializer for a constructor for that class or for
1627 a class derived from that class (_class.base.init_). */
1628 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1630 /* Build a representation of the qualified name suitable
1631 for use as the operand to "&" -- even though the "&" is
1632 not actually present. */
1633 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1634 /* In Microsoft mode, treat a non-static member function as if
1635 it were a pointer-to-member. */
1636 if (flag_ms_extensions)
1638 PTRMEM_OK_P (member) = 1;
1639 return cp_build_unary_op (ADDR_EXPR, member, 0,
1640 tf_warning_or_error);
1642 error ("invalid use of non-static member function %qD",
1643 TREE_OPERAND (member, 1));
1644 return error_mark_node;
1646 else if (TREE_CODE (member) == FIELD_DECL)
1648 error ("invalid use of non-static data member %qD", member);
1649 return error_mark_node;
1654 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1655 PTRMEM_OK_P (member) = 1;
1659 /* If DECL is a scalar enumeration constant or variable with a
1660 constant initializer, return the initializer (or, its initializers,
1661 recursively); otherwise, return DECL. If INTEGRAL_P, the
1662 initializer is only returned if DECL is an integral
1663 constant-expression. */
1666 constant_value_1 (tree decl, bool integral_p)
1668 while (TREE_CODE (decl) == CONST_DECL
1670 ? DECL_INTEGRAL_CONSTANT_VAR_P (decl)
1671 : (TREE_CODE (decl) == VAR_DECL
1672 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))))
1675 /* Static data members in template classes may have
1676 non-dependent initializers. References to such non-static
1677 data members are not value-dependent, so we must retrieve the
1678 initializer here. The DECL_INITIAL will have the right type,
1679 but will not have been folded because that would prevent us
1680 from performing all appropriate semantic checks at
1681 instantiation time. */
1682 if (DECL_CLASS_SCOPE_P (decl)
1683 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
1684 && uses_template_parms (CLASSTYPE_TI_ARGS
1685 (DECL_CONTEXT (decl))))
1687 ++processing_template_decl;
1688 init = fold_non_dependent_expr (DECL_INITIAL (decl));
1689 --processing_template_decl;
1693 /* If DECL is a static data member in a template
1694 specialization, we must instantiate it here. The
1695 initializer for the static data member is not processed
1696 until needed; we need it now. */
1698 init = DECL_INITIAL (decl);
1700 if (init == error_mark_node)
1702 if (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
1703 /* Treat the error as a constant to avoid cascading errors on
1704 excessively recursive template instantiation (c++/9335). */
1709 /* Initializers in templates are generally expanded during
1710 instantiation, so before that for const int i(2)
1711 INIT is a TREE_LIST with the actual initializer as
1713 if (processing_template_decl
1715 && TREE_CODE (init) == TREE_LIST
1716 && TREE_CHAIN (init) == NULL_TREE)
1717 init = TREE_VALUE (init);
1719 || !TREE_TYPE (init)
1721 ? !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (init))
1722 : (!TREE_CONSTANT (init)
1723 /* Do not return an aggregate constant (of which
1724 string literals are a special case), as we do not
1725 want to make inadvertent copies of such entities,
1726 and we must be sure that their addresses are the
1728 || TREE_CODE (init) == CONSTRUCTOR
1729 || TREE_CODE (init) == STRING_CST)))
1731 decl = unshare_expr (init);
1736 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1737 constant of integral or enumeration type, then return that value.
1738 These are those variables permitted in constant expressions by
1742 integral_constant_value (tree decl)
1744 return constant_value_1 (decl, /*integral_p=*/true);
1747 /* A more relaxed version of integral_constant_value, used by the
1748 common C/C++ code and by the C++ front end for optimization
1752 decl_constant_value (tree decl)
1754 return constant_value_1 (decl,
1755 /*integral_p=*/processing_template_decl);
1758 /* Common subroutines of build_new and build_vec_delete. */
1760 /* Call the global __builtin_delete to delete ADDR. */
1763 build_builtin_delete_call (tree addr)
1765 mark_used (global_delete_fndecl);
1766 return build_call_n (global_delete_fndecl, 1, addr);
1769 /* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
1770 the type of the object being allocated; otherwise, it's just TYPE.
1771 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
1772 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
1773 a vector of arguments to be provided as arguments to a placement
1774 new operator. This routine performs no semantic checks; it just
1775 creates and returns a NEW_EXPR. */
1778 build_raw_new_expr (VEC(tree,gc) *placement, tree type, tree nelts,
1779 VEC(tree,gc) *init, int use_global_new)
1784 /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR.
1785 If INIT is not NULL, then we want to store VOID_ZERO_NODE. This
1786 permits us to distinguish the case of a missing initializer "new
1787 int" from an empty initializer "new int()". */
1789 init_list = NULL_TREE;
1790 else if (VEC_empty (tree, init))
1791 init_list = void_zero_node;
1793 init_list = build_tree_list_vec (init);
1795 new_expr = build4 (NEW_EXPR, build_pointer_type (type),
1796 build_tree_list_vec (placement), type, nelts,
1798 NEW_EXPR_USE_GLOBAL (new_expr) = use_global_new;
1799 TREE_SIDE_EFFECTS (new_expr) = 1;
1804 /* Diagnose uninitialized const members or reference members of type
1805 TYPE. USING_NEW is used to disambiguate the diagnostic between a
1806 new expression without a new-initializer and a declaration. Returns
1810 diagnose_uninitialized_cst_or_ref_member_1 (tree type, tree origin,
1811 bool using_new, bool complain)
1814 int error_count = 0;
1816 if (type_has_user_provided_constructor (type))
1819 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
1823 if (TREE_CODE (field) != FIELD_DECL)
1826 field_type = strip_array_types (TREE_TYPE (field));
1828 if (TREE_CODE (field_type) == REFERENCE_TYPE)
1834 error ("uninitialized reference member in %q#T "
1835 "using %<new%> without new-initializer", origin);
1837 error ("uninitialized reference member in %q#T", origin);
1838 inform (DECL_SOURCE_LOCATION (field),
1839 "%qD should be initialized", field);
1843 if (CP_TYPE_CONST_P (field_type))
1849 error ("uninitialized const member in %q#T "
1850 "using %<new%> without new-initializer", origin);
1852 error ("uninitialized const member in %q#T", origin);
1853 inform (DECL_SOURCE_LOCATION (field),
1854 "%qD should be initialized", field);
1858 if (CLASS_TYPE_P (field_type))
1860 += diagnose_uninitialized_cst_or_ref_member_1 (field_type, origin,
1861 using_new, complain);
1867 diagnose_uninitialized_cst_or_ref_member (tree type, bool using_new, bool complain)
1869 return diagnose_uninitialized_cst_or_ref_member_1 (type, type, using_new, complain);
1872 /* Generate code for a new-expression, including calling the "operator
1873 new" function, initializing the object, and, if an exception occurs
1874 during construction, cleaning up. The arguments are as for
1875 build_raw_new_expr. This may change PLACEMENT and INIT. */
1878 build_new_1 (VEC(tree,gc) **placement, tree type, tree nelts,
1879 VEC(tree,gc) **init, bool globally_qualified_p,
1880 tsubst_flags_t complain)
1883 /* True iff this is a call to "operator new[]" instead of just
1885 bool array_p = false;
1886 /* If ARRAY_P is true, the element type of the array. This is never
1887 an ARRAY_TYPE; for something like "new int[3][4]", the
1888 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
1891 /* The type of the new-expression. (This type is always a pointer
1894 tree non_const_pointer_type;
1895 tree outer_nelts = NULL_TREE;
1896 tree alloc_call, alloc_expr;
1897 /* The address returned by the call to "operator new". This node is
1898 a VAR_DECL and is therefore reusable. */
1901 tree cookie_expr, init_expr;
1902 int nothrow, check_new;
1903 int use_java_new = 0;
1904 /* If non-NULL, the number of extra bytes to allocate at the
1905 beginning of the storage allocated for an array-new expression in
1906 order to store the number of elements. */
1907 tree cookie_size = NULL_TREE;
1908 tree placement_first;
1909 tree placement_expr = NULL_TREE;
1910 /* True if the function we are calling is a placement allocation
1912 bool placement_allocation_fn_p;
1913 /* True if the storage must be initialized, either by a constructor
1914 or due to an explicit new-initializer. */
1915 bool is_initialized;
1916 /* The address of the thing allocated, not including any cookie. In
1917 particular, if an array cookie is in use, DATA_ADDR is the
1918 address of the first array element. This node is a VAR_DECL, and
1919 is therefore reusable. */
1921 tree init_preeval_expr = NULL_TREE;
1925 outer_nelts = nelts;
1928 else if (TREE_CODE (type) == ARRAY_TYPE)
1931 nelts = array_type_nelts_top (type);
1932 outer_nelts = nelts;
1933 type = TREE_TYPE (type);
1936 /* If our base type is an array, then make sure we know how many elements
1938 for (elt_type = type;
1939 TREE_CODE (elt_type) == ARRAY_TYPE;
1940 elt_type = TREE_TYPE (elt_type))
1941 nelts = cp_build_binary_op (input_location,
1943 array_type_nelts_top (elt_type),
1946 if (TREE_CODE (elt_type) == VOID_TYPE)
1948 if (complain & tf_error)
1949 error ("invalid type %<void%> for new");
1950 return error_mark_node;
1953 if (abstract_virtuals_error (NULL_TREE, elt_type))
1954 return error_mark_node;
1956 is_initialized = (TYPE_NEEDS_CONSTRUCTING (elt_type) || *init != NULL);
1960 bool maybe_uninitialized_error = false;
1961 /* A program that calls for default-initialization [...] of an
1962 entity of reference type is ill-formed. */
1963 if (CLASSTYPE_REF_FIELDS_NEED_INIT (elt_type))
1964 maybe_uninitialized_error = true;
1966 /* A new-expression that creates an object of type T initializes
1967 that object as follows:
1968 - If the new-initializer is omitted:
1969 -- If T is a (possibly cv-qualified) non-POD class type
1970 (or array thereof), the object is default-initialized (8.5).
1972 -- Otherwise, the object created has indeterminate
1973 value. If T is a const-qualified type, or a (possibly
1974 cv-qualified) POD class type (or array thereof)
1975 containing (directly or indirectly) a member of
1976 const-qualified type, the program is ill-formed; */
1978 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (elt_type))
1979 maybe_uninitialized_error = true;
1981 if (maybe_uninitialized_error
1982 && diagnose_uninitialized_cst_or_ref_member (elt_type,
1984 complain & tf_error))
1985 return error_mark_node;
1988 if (CP_TYPE_CONST_P (elt_type) && *init == NULL
1989 && !type_has_user_provided_default_constructor (elt_type))
1991 if (complain & tf_error)
1992 error ("uninitialized const in %<new%> of %q#T", elt_type);
1993 return error_mark_node;
1996 size = size_in_bytes (elt_type);
1998 size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
2000 alloc_fn = NULL_TREE;
2002 /* If PLACEMENT is a single simple pointer type not passed by
2003 reference, prepare to capture it in a temporary variable. Do
2004 this now, since PLACEMENT will change in the calls below. */
2005 placement_first = NULL_TREE;
2006 if (VEC_length (tree, *placement) == 1
2007 && (TREE_CODE (TREE_TYPE (VEC_index (tree, *placement, 0)))
2009 placement_first = VEC_index (tree, *placement, 0);
2011 /* Allocate the object. */
2012 if (VEC_empty (tree, *placement) && TYPE_FOR_JAVA (elt_type))
2015 tree class_decl = build_java_class_ref (elt_type);
2016 static const char alloc_name[] = "_Jv_AllocObject";
2018 if (class_decl == error_mark_node)
2019 return error_mark_node;
2022 if (!get_global_value_if_present (get_identifier (alloc_name),
2025 if (complain & tf_error)
2026 error ("call to Java constructor with %qs undefined", alloc_name);
2027 return error_mark_node;
2029 else if (really_overloaded_fn (alloc_fn))
2031 if (complain & tf_error)
2032 error ("%qD should never be overloaded", alloc_fn);
2033 return error_mark_node;
2035 alloc_fn = OVL_CURRENT (alloc_fn);
2036 class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
2037 alloc_call = cp_build_function_call_nary (alloc_fn, complain,
2038 class_addr, NULL_TREE);
2040 else if (TYPE_FOR_JAVA (elt_type) && MAYBE_CLASS_TYPE_P (elt_type))
2042 error ("Java class %q#T object allocated using placement new", elt_type);
2043 return error_mark_node;
2050 fnname = ansi_opname (array_p ? VEC_NEW_EXPR : NEW_EXPR);
2052 if (!globally_qualified_p
2053 && CLASS_TYPE_P (elt_type)
2055 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
2056 : TYPE_HAS_NEW_OPERATOR (elt_type)))
2058 /* Use a class-specific operator new. */
2059 /* If a cookie is required, add some extra space. */
2060 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
2062 cookie_size = targetm.cxx.get_cookie_size (elt_type);
2063 size = size_binop (PLUS_EXPR, size, cookie_size);
2065 /* Create the argument list. */
2066 VEC_safe_insert (tree, gc, *placement, 0, size);
2067 /* Do name-lookup to find the appropriate operator. */
2068 fns = lookup_fnfields (elt_type, fnname, /*protect=*/2);
2069 if (fns == NULL_TREE)
2071 if (complain & tf_error)
2072 error ("no suitable %qD found in class %qT", fnname, elt_type);
2073 return error_mark_node;
2075 if (TREE_CODE (fns) == TREE_LIST)
2077 if (complain & tf_error)
2079 error ("request for member %qD is ambiguous", fnname);
2080 print_candidates (fns);
2082 return error_mark_node;
2084 alloc_call = build_new_method_call (build_dummy_object (elt_type),
2086 /*conversion_path=*/NULL_TREE,
2093 /* Use a global operator new. */
2094 /* See if a cookie might be required. */
2095 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
2096 cookie_size = targetm.cxx.get_cookie_size (elt_type);
2098 cookie_size = NULL_TREE;
2100 alloc_call = build_operator_new_call (fnname, placement,
2101 &size, &cookie_size,
2106 if (alloc_call == error_mark_node)
2107 return error_mark_node;
2109 gcc_assert (alloc_fn != NULL_TREE);
2111 /* If we found a simple case of PLACEMENT_EXPR above, then copy it
2112 into a temporary variable. */
2113 if (!processing_template_decl
2114 && placement_first != NULL_TREE
2115 && TREE_CODE (alloc_call) == CALL_EXPR
2116 && call_expr_nargs (alloc_call) == 2
2117 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 0))) == INTEGER_TYPE
2118 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 1))) == POINTER_TYPE)
2120 tree placement_arg = CALL_EXPR_ARG (alloc_call, 1);
2122 if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg)))
2123 || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg))))
2125 placement_expr = get_target_expr (placement_first);
2126 CALL_EXPR_ARG (alloc_call, 1)
2127 = convert (TREE_TYPE (placement_arg), placement_expr);
2131 /* In the simple case, we can stop now. */
2132 pointer_type = build_pointer_type (type);
2133 if (!cookie_size && !is_initialized)
2134 return build_nop (pointer_type, alloc_call);
2136 /* Store the result of the allocation call in a variable so that we can
2137 use it more than once. */
2138 alloc_expr = get_target_expr (alloc_call);
2139 alloc_node = TARGET_EXPR_SLOT (alloc_expr);
2141 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
2142 while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
2143 alloc_call = TREE_OPERAND (alloc_call, 1);
2145 /* Now, check to see if this function is actually a placement
2146 allocation function. This can happen even when PLACEMENT is NULL
2147 because we might have something like:
2149 struct S { void* operator new (size_t, int i = 0); };
2151 A call to `new S' will get this allocation function, even though
2152 there is no explicit placement argument. If there is more than
2153 one argument, or there are variable arguments, then this is a
2154 placement allocation function. */
2155 placement_allocation_fn_p
2156 = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
2157 || varargs_function_p (alloc_fn));
2159 /* Preevaluate the placement args so that we don't reevaluate them for a
2160 placement delete. */
2161 if (placement_allocation_fn_p)
2164 stabilize_call (alloc_call, &inits);
2166 alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
2170 /* unless an allocation function is declared with an empty excep-
2171 tion-specification (_except.spec_), throw(), it indicates failure to
2172 allocate storage by throwing a bad_alloc exception (clause _except_,
2173 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2174 cation function is declared with an empty exception-specification,
2175 throw(), it returns null to indicate failure to allocate storage and a
2176 non-null pointer otherwise.
2178 So check for a null exception spec on the op new we just called. */
2180 nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
2181 check_new = (flag_check_new || nothrow) && ! use_java_new;
2189 /* Adjust so we're pointing to the start of the object. */
2190 data_addr = build2 (POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
2191 alloc_node, cookie_size);
2193 /* Store the number of bytes allocated so that we can know how
2194 many elements to destroy later. We use the last sizeof
2195 (size_t) bytes to store the number of elements. */
2196 cookie_ptr = size_binop (MINUS_EXPR, cookie_size, size_in_bytes (sizetype));
2197 cookie_ptr = fold_build2_loc (input_location,
2198 POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
2199 alloc_node, cookie_ptr);
2200 size_ptr_type = build_pointer_type (sizetype);
2201 cookie_ptr = fold_convert (size_ptr_type, cookie_ptr);
2202 cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
2204 cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
2206 if (targetm.cxx.cookie_has_size ())
2208 /* Also store the element size. */
2209 cookie_ptr = build2 (POINTER_PLUS_EXPR, size_ptr_type, cookie_ptr,
2210 fold_build1_loc (input_location,
2211 NEGATE_EXPR, sizetype,
2212 size_in_bytes (sizetype)));
2214 cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
2215 cookie = build2 (MODIFY_EXPR, sizetype, cookie,
2216 size_in_bytes (elt_type));
2217 cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
2218 cookie, cookie_expr);
2223 cookie_expr = NULL_TREE;
2224 data_addr = alloc_node;
2227 /* Now use a pointer to the type we've actually allocated. */
2229 /* But we want to operate on a non-const version to start with,
2230 since we'll be modifying the elements. */
2231 non_const_pointer_type = build_pointer_type
2232 (cp_build_qualified_type (type, cp_type_quals (type) & ~TYPE_QUAL_CONST));
2234 data_addr = fold_convert (non_const_pointer_type, data_addr);
2235 /* Any further uses of alloc_node will want this type, too. */
2236 alloc_node = fold_convert (non_const_pointer_type, alloc_node);
2238 /* Now initialize the allocated object. Note that we preevaluate the
2239 initialization expression, apart from the actual constructor call or
2240 assignment--we do this because we want to delay the allocation as long
2241 as possible in order to minimize the size of the exception region for
2242 placement delete. */
2246 bool explicit_value_init_p = false;
2248 if (*init != NULL && VEC_empty (tree, *init))
2251 explicit_value_init_p = true;
2256 tree vecinit = NULL_TREE;
2257 if (*init && VEC_length (tree, *init) == 1
2258 && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *init, 0))
2259 && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *init, 0)))
2261 tree arraytype, domain;
2262 vecinit = VEC_index (tree, *init, 0);
2263 if (TREE_CONSTANT (nelts))
2264 domain = compute_array_index_type (NULL_TREE, nelts);
2268 if (CONSTRUCTOR_NELTS (vecinit) > 0)
2269 warning (0, "non-constant array size in new, unable to "
2270 "verify length of initializer-list");
2272 arraytype = build_cplus_array_type (type, domain);
2273 vecinit = digest_init (arraytype, vecinit);
2277 if (complain & tf_error)
2278 permerror (input_location, "ISO C++ forbids initialization in array new");
2280 return error_mark_node;
2281 vecinit = build_tree_list_vec (*init);
2284 = build_vec_init (data_addr,
2285 cp_build_binary_op (input_location,
2286 MINUS_EXPR, outer_nelts,
2290 explicit_value_init_p,
2294 /* An array initialization is stable because the initialization
2295 of each element is a full-expression, so the temporaries don't
2301 init_expr = cp_build_indirect_ref (data_addr, RO_NULL, complain);
2303 if (TYPE_NEEDS_CONSTRUCTING (type) && !explicit_value_init_p)
2305 init_expr = build_special_member_call (init_expr,
2306 complete_ctor_identifier,
2311 else if (explicit_value_init_p)
2313 /* Something like `new int()'. */
2314 init_expr = build2 (INIT_EXPR, type,
2315 init_expr, build_value_init (type));
2321 /* We are processing something like `new int (10)', which
2322 means allocate an int, and initialize it with 10. */
2324 ie = build_x_compound_expr_from_vec (*init, "new initializer");
2325 init_expr = cp_build_modify_expr (init_expr, INIT_EXPR, ie,
2328 stable = stabilize_init (init_expr, &init_preeval_expr);
2331 if (init_expr == error_mark_node)
2332 return error_mark_node;
2334 /* If any part of the object initialization terminates by throwing an
2335 exception and a suitable deallocation function can be found, the
2336 deallocation function is called to free the memory in which the
2337 object was being constructed, after which the exception continues
2338 to propagate in the context of the new-expression. If no
2339 unambiguous matching deallocation function can be found,
2340 propagating the exception does not cause the object's memory to be
2342 if (flag_exceptions && ! use_java_new)
2344 enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
2347 /* The Standard is unclear here, but the right thing to do
2348 is to use the same method for finding deallocation
2349 functions that we use for finding allocation functions. */
2350 cleanup = (build_op_delete_call
2354 globally_qualified_p,
2355 placement_allocation_fn_p ? alloc_call : NULL_TREE,
2361 /* This is much simpler if we were able to preevaluate all of
2362 the arguments to the constructor call. */
2364 /* CLEANUP is compiler-generated, so no diagnostics. */
2365 TREE_NO_WARNING (cleanup) = true;
2366 init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2367 init_expr, cleanup);
2368 /* Likewise, this try-catch is compiler-generated. */
2369 TREE_NO_WARNING (init_expr) = true;
2372 /* Ack! First we allocate the memory. Then we set our sentry
2373 variable to true, and expand a cleanup that deletes the
2374 memory if sentry is true. Then we run the constructor, and
2375 finally clear the sentry.
2377 We need to do this because we allocate the space first, so
2378 if there are any temporaries with cleanups in the
2379 constructor args and we weren't able to preevaluate them, we
2380 need this EH region to extend until end of full-expression
2381 to preserve nesting. */
2383 tree end, sentry, begin;
2385 begin = get_target_expr (boolean_true_node);
2386 CLEANUP_EH_ONLY (begin) = 1;
2388 sentry = TARGET_EXPR_SLOT (begin);
2390 /* CLEANUP is compiler-generated, so no diagnostics. */
2391 TREE_NO_WARNING (cleanup) = true;
2393 TARGET_EXPR_CLEANUP (begin)
2394 = build3 (COND_EXPR, void_type_node, sentry,
2395 cleanup, void_zero_node);
2397 end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2398 sentry, boolean_false_node);
2401 = build2 (COMPOUND_EXPR, void_type_node, begin,
2402 build2 (COMPOUND_EXPR, void_type_node, init_expr,
2404 /* Likewise, this is compiler-generated. */
2405 TREE_NO_WARNING (init_expr) = true;
2410 init_expr = NULL_TREE;
2412 /* Now build up the return value in reverse order. */
2417 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2419 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2421 if (rval == data_addr)
2422 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2423 and return the call (which doesn't need to be adjusted). */
2424 rval = TARGET_EXPR_INITIAL (alloc_expr);
2429 tree ifexp = cp_build_binary_op (input_location,
2430 NE_EXPR, alloc_node,
2433 rval = build_conditional_expr (ifexp, rval, alloc_node,
2437 /* Perform the allocation before anything else, so that ALLOC_NODE
2438 has been initialized before we start using it. */
2439 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2442 if (init_preeval_expr)
2443 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2445 /* A new-expression is never an lvalue. */
2446 gcc_assert (!lvalue_p (rval));
2448 return convert (pointer_type, rval);
2451 /* Generate a representation for a C++ "new" expression. *PLACEMENT
2452 is a vector of placement-new arguments (or NULL if none). If NELTS
2453 is NULL, TYPE is the type of the storage to be allocated. If NELTS
2454 is not NULL, then this is an array-new allocation; TYPE is the type
2455 of the elements in the array and NELTS is the number of elements in
2456 the array. *INIT, if non-NULL, is the initializer for the new
2457 object, or an empty vector to indicate an initializer of "()". If
2458 USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
2459 rather than just "new". This may change PLACEMENT and INIT. */
2462 build_new (VEC(tree,gc) **placement, tree type, tree nelts,
2463 VEC(tree,gc) **init, int use_global_new, tsubst_flags_t complain)
2466 VEC(tree,gc) *orig_placement = NULL;
2467 tree orig_nelts = NULL_TREE;
2468 VEC(tree,gc) *orig_init = NULL;
2470 if (type == error_mark_node)
2471 return error_mark_node;
2473 if (nelts == NULL_TREE && VEC_length (tree, *init) == 1)
2475 tree auto_node = type_uses_auto (type);
2476 if (auto_node && describable_type (VEC_index (tree, *init, 0)))
2477 type = do_auto_deduction (type, VEC_index (tree, *init, 0), auto_node);
2480 if (processing_template_decl)
2482 if (dependent_type_p (type)
2483 || any_type_dependent_arguments_p (*placement)
2484 || (nelts && type_dependent_expression_p (nelts))
2485 || any_type_dependent_arguments_p (*init))
2486 return build_raw_new_expr (*placement, type, nelts, *init,
2489 orig_placement = make_tree_vector_copy (*placement);
2491 orig_init = make_tree_vector_copy (*init);
2493 make_args_non_dependent (*placement);
2495 nelts = build_non_dependent_expr (nelts);
2496 make_args_non_dependent (*init);
2501 if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
2503 if (complain & tf_error)
2504 permerror (input_location, "size in array new must have integral type");
2506 return error_mark_node;
2508 nelts = mark_rvalue_use (nelts);
2509 nelts = cp_save_expr (cp_convert (sizetype, nelts));
2512 /* ``A reference cannot be created by the new operator. A reference
2513 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2514 returned by new.'' ARM 5.3.3 */
2515 if (TREE_CODE (type) == REFERENCE_TYPE)
2517 if (complain & tf_error)
2518 error ("new cannot be applied to a reference type");
2520 return error_mark_node;
2521 type = TREE_TYPE (type);
2524 if (TREE_CODE (type) == FUNCTION_TYPE)
2526 if (complain & tf_error)
2527 error ("new cannot be applied to a function type");
2528 return error_mark_node;
2531 /* The type allocated must be complete. If the new-type-id was
2532 "T[N]" then we are just checking that "T" is complete here, but
2533 that is equivalent, since the value of "N" doesn't matter. */
2534 if (!complete_type_or_else (type, NULL_TREE))
2535 return error_mark_node;
2537 rval = build_new_1 (placement, type, nelts, init, use_global_new, complain);
2538 if (rval == error_mark_node)
2539 return error_mark_node;
2541 if (processing_template_decl)
2543 tree ret = build_raw_new_expr (orig_placement, type, orig_nelts,
2544 orig_init, use_global_new);
2545 release_tree_vector (orig_placement);
2546 release_tree_vector (orig_init);
2550 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2551 rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
2552 TREE_NO_WARNING (rval) = 1;
2557 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2560 build_java_class_ref (tree type)
2562 tree name = NULL_TREE, class_decl;
2563 static tree CL_suffix = NULL_TREE;
2564 if (CL_suffix == NULL_TREE)
2565 CL_suffix = get_identifier("class$");
2566 if (jclass_node == NULL_TREE)
2568 jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2569 if (jclass_node == NULL_TREE)
2571 error ("call to Java constructor, while %<jclass%> undefined");
2572 return error_mark_node;
2574 jclass_node = TREE_TYPE (jclass_node);
2577 /* Mangle the class$ field. */
2580 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
2581 if (DECL_NAME (field) == CL_suffix)
2583 mangle_decl (field);
2584 name = DECL_ASSEMBLER_NAME (field);
2589 error ("can't find %<class$%> in %qT", type);
2590 return error_mark_node;
2594 class_decl = IDENTIFIER_GLOBAL_VALUE (name);
2595 if (class_decl == NULL_TREE)
2597 class_decl = build_decl (input_location,
2598 VAR_DECL, name, TREE_TYPE (jclass_node));
2599 TREE_STATIC (class_decl) = 1;
2600 DECL_EXTERNAL (class_decl) = 1;
2601 TREE_PUBLIC (class_decl) = 1;
2602 DECL_ARTIFICIAL (class_decl) = 1;
2603 DECL_IGNORED_P (class_decl) = 1;
2604 pushdecl_top_level (class_decl);
2605 make_decl_rtl (class_decl);
2611 build_vec_delete_1 (tree base, tree maxindex, tree type,
2612 special_function_kind auto_delete_vec, int use_global_delete)
2615 tree ptype = build_pointer_type (type = complete_type (type));
2616 tree size_exp = size_in_bytes (type);
2618 /* Temporary variables used by the loop. */
2619 tree tbase, tbase_init;
2621 /* This is the body of the loop that implements the deletion of a
2622 single element, and moves temp variables to next elements. */
2625 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2628 /* This is the thing that governs what to do after the loop has run. */
2629 tree deallocate_expr = 0;
2631 /* This is the BIND_EXPR which holds the outermost iterator of the
2632 loop. It is convenient to set this variable up and test it before
2633 executing any other code in the loop.
2634 This is also the containing expression returned by this function. */
2635 tree controller = NULL_TREE;
2638 /* We should only have 1-D arrays here. */
2639 gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2641 if (! MAYBE_CLASS_TYPE_P (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2644 /* The below is short by the cookie size. */
2645 virtual_size = size_binop (MULT_EXPR, size_exp,
2646 convert (sizetype, maxindex));
2648 tbase = create_temporary_var (ptype);
2649 tbase_init = cp_build_modify_expr (tbase, NOP_EXPR,
2650 fold_build2_loc (input_location,
2651 POINTER_PLUS_EXPR, ptype,
2652 fold_convert (ptype, base),
2654 tf_warning_or_error);
2655 controller = build3 (BIND_EXPR, void_type_node, tbase,
2656 NULL_TREE, NULL_TREE);
2657 TREE_SIDE_EFFECTS (controller) = 1;
2659 body = build1 (EXIT_EXPR, void_type_node,
2660 build2 (EQ_EXPR, boolean_type_node, tbase,
2661 fold_convert (ptype, base)));
2662 tmp = fold_build1_loc (input_location, NEGATE_EXPR, sizetype, size_exp);
2663 body = build_compound_expr
2665 body, cp_build_modify_expr (tbase, NOP_EXPR,
2666 build2 (POINTER_PLUS_EXPR, ptype, tbase, tmp),
2667 tf_warning_or_error));
2668 body = build_compound_expr
2670 body, build_delete (ptype, tbase, sfk_complete_destructor,
2671 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1));
2673 loop = build1 (LOOP_EXPR, void_type_node, body);
2674 loop = build_compound_expr (input_location, tbase_init, loop);
2677 /* If the delete flag is one, or anything else with the low bit set,
2678 delete the storage. */
2679 if (auto_delete_vec != sfk_base_destructor)
2683 /* The below is short by the cookie size. */
2684 virtual_size = size_binop (MULT_EXPR, size_exp,
2685 convert (sizetype, maxindex));
2687 if (! TYPE_VEC_NEW_USES_COOKIE (type))
2694 cookie_size = targetm.cxx.get_cookie_size (type);
2696 = cp_convert (ptype,
2697 cp_build_binary_op (input_location,
2699 cp_convert (string_type_node,
2702 tf_warning_or_error));
2703 /* True size with header. */
2704 virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2707 if (auto_delete_vec == sfk_deleting_destructor)
2708 deallocate_expr = build_op_delete_call (VEC_DELETE_EXPR,
2709 base_tbd, virtual_size,
2710 use_global_delete & 1,
2711 /*placement=*/NULL_TREE,
2712 /*alloc_fn=*/NULL_TREE);
2716 if (!deallocate_expr)
2719 body = deallocate_expr;
2721 body = build_compound_expr (input_location, body, deallocate_expr);
2724 body = integer_zero_node;
2726 /* Outermost wrapper: If pointer is null, punt. */
2727 body = fold_build3_loc (input_location, COND_EXPR, void_type_node,
2728 fold_build2_loc (input_location,
2729 NE_EXPR, boolean_type_node, base,
2730 convert (TREE_TYPE (base),
2731 integer_zero_node)),
2732 body, integer_zero_node);
2733 body = build1 (NOP_EXPR, void_type_node, body);
2737 TREE_OPERAND (controller, 1) = body;
2741 if (TREE_CODE (base) == SAVE_EXPR)
2742 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
2743 body = build2 (COMPOUND_EXPR, void_type_node, base, body);
2745 return convert_to_void (body, ICV_CAST, tf_warning_or_error);
2748 /* Create an unnamed variable of the indicated TYPE. */
2751 create_temporary_var (tree type)
2755 decl = build_decl (input_location,
2756 VAR_DECL, NULL_TREE, type);
2757 TREE_USED (decl) = 1;
2758 DECL_ARTIFICIAL (decl) = 1;
2759 DECL_IGNORED_P (decl) = 1;
2760 DECL_CONTEXT (decl) = current_function_decl;
2765 /* Create a new temporary variable of the indicated TYPE, initialized
2768 It is not entered into current_binding_level, because that breaks
2769 things when it comes time to do final cleanups (which take place
2770 "outside" the binding contour of the function). */
2773 get_temp_regvar (tree type, tree init)
2777 decl = create_temporary_var (type);
2778 add_decl_expr (decl);
2780 finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,
2781 tf_warning_or_error));
2786 /* `build_vec_init' returns tree structure that performs
2787 initialization of a vector of aggregate types.
2789 BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
2790 to the first element, of POINTER_TYPE.
2791 MAXINDEX is the maximum index of the array (one less than the
2792 number of elements). It is only used if BASE is a pointer or
2793 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2795 INIT is the (possibly NULL) initializer.
2797 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All
2798 elements in the array are value-initialized.
2800 FROM_ARRAY is 0 if we should init everything with INIT
2801 (i.e., every element initialized from INIT).
2802 FROM_ARRAY is 1 if we should index into INIT in parallel
2803 with initialization of DECL.
2804 FROM_ARRAY is 2 if we should index into INIT in parallel,
2805 but use assignment instead of initialization. */
2808 build_vec_init (tree base, tree maxindex, tree init,
2809 bool explicit_value_init_p,
2810 int from_array, tsubst_flags_t complain)
2813 tree base2 = NULL_TREE;
2814 tree itype = NULL_TREE;
2816 /* The type of BASE. */
2817 tree atype = TREE_TYPE (base);
2818 /* The type of an element in the array. */
2819 tree type = TREE_TYPE (atype);
2820 /* The element type reached after removing all outer array
2822 tree inner_elt_type;
2823 /* The type of a pointer to an element in the array. */
2828 tree try_block = NULL_TREE;
2829 int num_initialized_elts = 0;
2832 if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype))
2833 maxindex = array_type_nelts (atype);
2835 if (maxindex == NULL_TREE || maxindex == error_mark_node)
2836 return error_mark_node;
2838 if (explicit_value_init_p)
2841 inner_elt_type = strip_array_types (type);
2843 /* Look through the TARGET_EXPR around a compound literal. */
2844 if (init && TREE_CODE (init) == TARGET_EXPR
2845 && TREE_CODE (TARGET_EXPR_INITIAL (init)) == CONSTRUCTOR
2847 init = TARGET_EXPR_INITIAL (init);
2850 && TREE_CODE (atype) == ARRAY_TYPE
2852 ? (!CLASS_TYPE_P (inner_elt_type)
2853 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (inner_elt_type))
2854 : !TYPE_NEEDS_CONSTRUCTING (type))
2855 && ((TREE_CODE (init) == CONSTRUCTOR
2856 /* Don't do this if the CONSTRUCTOR might contain something
2857 that might throw and require us to clean up. */
2858 && (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))
2859 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
2862 /* Do non-default initialization of trivial arrays resulting from
2863 brace-enclosed initializers. In this case, digest_init and
2864 store_constructor will handle the semantics for us. */
2866 stmt_expr = build2 (INIT_EXPR, atype, base, init);
2870 maxindex = cp_convert (ptrdiff_type_node, maxindex);
2871 if (TREE_CODE (atype) == ARRAY_TYPE)
2873 ptype = build_pointer_type (type);
2874 base = cp_convert (ptype, decay_conversion (base));
2879 /* The code we are generating looks like:
2883 ptrdiff_t iterator = maxindex;
2885 for (; iterator != -1; --iterator) {
2886 ... initialize *t1 ...
2890 ... destroy elements that were constructed ...
2895 We can omit the try and catch blocks if we know that the
2896 initialization will never throw an exception, or if the array
2897 elements do not have destructors. We can omit the loop completely if
2898 the elements of the array do not have constructors.
2900 We actually wrap the entire body of the above in a STMT_EXPR, for
2903 When copying from array to another, when the array elements have
2904 only trivial copy constructors, we should use __builtin_memcpy
2905 rather than generating a loop. That way, we could take advantage
2906 of whatever cleverness the back end has for dealing with copies
2907 of blocks of memory. */
2909 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
2910 destroy_temps = stmts_are_full_exprs_p ();
2911 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2912 rval = get_temp_regvar (ptype, base);
2913 base = get_temp_regvar (ptype, rval);
2914 iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2916 /* If initializing one array from another, initialize element by
2917 element. We rely upon the below calls to do the argument
2918 checking. Evaluate the initializer before entering the try block. */
2919 if (from_array && init && TREE_CODE (init) != CONSTRUCTOR)
2921 base2 = decay_conversion (init);
2922 itype = TREE_TYPE (base2);
2923 base2 = get_temp_regvar (itype, base2);
2924 itype = TREE_TYPE (itype);
2927 /* Protect the entire array initialization so that we can destroy
2928 the partially constructed array if an exception is thrown.
2929 But don't do this if we're assigning. */
2930 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2933 try_block = begin_try_block ();
2936 if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
2938 /* Do non-default initialization of non-trivial arrays resulting from
2939 brace-enclosed initializers. */
2940 unsigned HOST_WIDE_INT idx;
2944 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
2946 tree baseref = build1 (INDIRECT_REF, type, base);
2948 num_initialized_elts++;
2950 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2951 if (MAYBE_CLASS_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
2952 finish_expr_stmt (build_aggr_init (baseref, elt, 0, complain));
2954 finish_expr_stmt (cp_build_modify_expr (baseref, NOP_EXPR,
2956 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2958 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
2960 finish_expr_stmt (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
2964 /* Clear out INIT so that we don't get confused below. */
2967 else if (from_array)
2970 /* OK, we set base2 above. */;
2971 else if (TYPE_LANG_SPECIFIC (type)
2972 && TYPE_NEEDS_CONSTRUCTING (type)
2973 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2975 if (complain & tf_error)
2976 error ("initializer ends prematurely");
2977 return error_mark_node;
2981 /* Now, default-initialize any remaining elements. We don't need to
2982 do that if a) the type does not need constructing, or b) we've
2983 already initialized all the elements.
2985 We do need to keep going if we're copying an array. */
2988 || ((TYPE_NEEDS_CONSTRUCTING (type) || explicit_value_init_p)
2989 && ! (host_integerp (maxindex, 0)
2990 && (num_initialized_elts
2991 == tree_low_cst (maxindex, 0) + 1))))
2993 /* If the ITERATOR is equal to -1, then we don't have to loop;
2994 we've already initialized all the elements. */
2999 for_stmt = begin_for_stmt ();
3000 finish_for_init_stmt (for_stmt);
3001 finish_for_cond (build2 (NE_EXPR, boolean_type_node, iterator,
3002 build_int_cst (TREE_TYPE (iterator), -1)),
3004 finish_for_expr (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
3008 to = build1 (INDIRECT_REF, type, base);
3015 from = build1 (INDIRECT_REF, itype, base2);
3019 if (from_array == 2)
3020 elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
3022 else if (TYPE_NEEDS_CONSTRUCTING (type))
3023 elt_init = build_aggr_init (to, from, 0, complain);
3025 elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
3030 else if (TREE_CODE (type) == ARRAY_TYPE)
3034 ("cannot initialize multi-dimensional array with initializer");
3035 elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
3037 explicit_value_init_p,
3040 else if (explicit_value_init_p)
3041 elt_init = build2 (INIT_EXPR, type, to,
3042 build_value_init (type));
3045 gcc_assert (TYPE_NEEDS_CONSTRUCTING (type));
3046 elt_init = build_aggr_init (to, init, 0, complain);
3049 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
3050 finish_expr_stmt (elt_init);
3051 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
3053 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
3056 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base2, 0,
3059 finish_for_stmt (for_stmt);
3062 /* Make sure to cleanup any partially constructed elements. */
3063 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
3067 tree m = cp_build_binary_op (input_location,
3068 MINUS_EXPR, maxindex, iterator,
3071 /* Flatten multi-dimensional array since build_vec_delete only
3072 expects one-dimensional array. */
3073 if (TREE_CODE (type) == ARRAY_TYPE)
3074 m = cp_build_binary_op (input_location,
3076 array_type_nelts_total (type),
3079 finish_cleanup_try_block (try_block);
3080 e = build_vec_delete_1 (rval, m,
3081 inner_elt_type, sfk_base_destructor,
3082 /*use_global_delete=*/0);
3083 finish_cleanup (e, try_block);
3086 /* The value of the array initialization is the array itself, RVAL
3087 is a pointer to the first element. */
3088 finish_stmt_expr_expr (rval, stmt_expr);
3090 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
3092 /* Now make the result have the correct type. */
3093 if (TREE_CODE (atype) == ARRAY_TYPE)
3095 atype = build_pointer_type (atype);
3096 stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
3097 stmt_expr = cp_build_indirect_ref (stmt_expr, RO_NULL, complain);
3098 TREE_NO_WARNING (stmt_expr) = 1;
3101 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
3105 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
3109 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags)
3115 case sfk_complete_destructor:
3116 name = complete_dtor_identifier;
3119 case sfk_base_destructor:
3120 name = base_dtor_identifier;
3123 case sfk_deleting_destructor:
3124 name = deleting_dtor_identifier;
3130 fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
3131 return build_new_method_call (exp, fn,
3133 /*conversion_path=*/NULL_TREE,
3136 tf_warning_or_error);
3139 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3140 ADDR is an expression which yields the store to be destroyed.
3141 AUTO_DELETE is the name of the destructor to call, i.e., either
3142 sfk_complete_destructor, sfk_base_destructor, or
3143 sfk_deleting_destructor.
3145 FLAGS is the logical disjunction of zero or more LOOKUP_
3146 flags. See cp-tree.h for more info. */
3149 build_delete (tree type, tree addr, special_function_kind auto_delete,
3150 int flags, int use_global_delete)
3154 if (addr == error_mark_node)
3155 return error_mark_node;
3157 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3158 set to `error_mark_node' before it gets properly cleaned up. */
3159 if (type == error_mark_node)
3160 return error_mark_node;
3162 type = TYPE_MAIN_VARIANT (type);
3164 addr = mark_rvalue_use (addr);
3166 if (TREE_CODE (type) == POINTER_TYPE)
3168 bool complete_p = true;
3170 type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
3171 if (TREE_CODE (type) == ARRAY_TYPE)
3174 /* We don't want to warn about delete of void*, only other
3175 incomplete types. Deleting other incomplete types
3176 invokes undefined behavior, but it is not ill-formed, so
3177 compile to something that would even do The Right Thing
3178 (TM) should the type have a trivial dtor and no delete
3180 if (!VOID_TYPE_P (type))
3182 complete_type (type);
3183 if (!COMPLETE_TYPE_P (type))
3185 if (warning (0, "possible problem detected in invocation of "
3186 "delete operator:"))
3188 cxx_incomplete_type_diagnostic (addr, type, DK_WARNING);
3189 inform (input_location, "neither the destructor nor the class-specific "
3190 "operator delete will be called, even if they are "
3191 "declared when the class is defined.");
3196 if (VOID_TYPE_P (type) || !complete_p || !MAYBE_CLASS_TYPE_P (type))
3197 /* Call the builtin operator delete. */
3198 return build_builtin_delete_call (addr);
3199 if (TREE_SIDE_EFFECTS (addr))
3200 addr = save_expr (addr);
3202 /* Throw away const and volatile on target type of addr. */
3203 addr = convert_force (build_pointer_type (type), addr, 0);
3205 else if (TREE_CODE (type) == ARRAY_TYPE)
3209 if (TYPE_DOMAIN (type) == NULL_TREE)
3211 error ("unknown array size in delete");
3212 return error_mark_node;
3214 return build_vec_delete (addr, array_type_nelts (type),
3215 auto_delete, use_global_delete);
3219 /* Don't check PROTECT here; leave that decision to the
3220 destructor. If the destructor is accessible, call it,
3221 else report error. */
3222 addr = cp_build_unary_op (ADDR_EXPR, addr, 0, tf_warning_or_error);
3223 if (TREE_SIDE_EFFECTS (addr))
3224 addr = save_expr (addr);
3226 addr = convert_force (build_pointer_type (type), addr, 0);
3229 gcc_assert (MAYBE_CLASS_TYPE_P (type));
3231 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
3233 if (auto_delete != sfk_deleting_destructor)
3234 return void_zero_node;
3236 return build_op_delete_call (DELETE_EXPR, addr,
3237 cxx_sizeof_nowarn (type),
3239 /*placement=*/NULL_TREE,
3240 /*alloc_fn=*/NULL_TREE);
3244 tree head = NULL_TREE;
3245 tree do_delete = NULL_TREE;
3248 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
3249 lazily_declare_fn (sfk_destructor, type);
3251 /* For `::delete x', we must not use the deleting destructor
3252 since then we would not be sure to get the global `operator
3254 if (use_global_delete && auto_delete == sfk_deleting_destructor)
3256 /* We will use ADDR multiple times so we must save it. */
3257 addr = save_expr (addr);
3258 head = get_target_expr (build_headof (addr));
3259 /* Delete the object. */
3260 do_delete = build_builtin_delete_call (head);
3261 /* Otherwise, treat this like a complete object destructor
3263 auto_delete = sfk_complete_destructor;
3265 /* If the destructor is non-virtual, there is no deleting
3266 variant. Instead, we must explicitly call the appropriate
3267 `operator delete' here. */
3268 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
3269 && auto_delete == sfk_deleting_destructor)
3271 /* We will use ADDR multiple times so we must save it. */
3272 addr = save_expr (addr);
3273 /* Build the call. */
3274 do_delete = build_op_delete_call (DELETE_EXPR,
3276 cxx_sizeof_nowarn (type),
3278 /*placement=*/NULL_TREE,
3279 /*alloc_fn=*/NULL_TREE);
3280 /* Call the complete object destructor. */
3281 auto_delete = sfk_complete_destructor;
3283 else if (auto_delete == sfk_deleting_destructor
3284 && TYPE_GETS_REG_DELETE (type))
3286 /* Make sure we have access to the member op delete, even though
3287 we'll actually be calling it from the destructor. */
3288 build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
3290 /*placement=*/NULL_TREE,
3291 /*alloc_fn=*/NULL_TREE);
3294 expr = build_dtor_call (cp_build_indirect_ref (addr, RO_NULL,
3295 tf_warning_or_error),
3296 auto_delete, flags);
3298 expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
3300 /* We need to calculate this before the dtor changes the vptr. */
3302 expr = build2 (COMPOUND_EXPR, void_type_node, head, expr);
3304 if (flags & LOOKUP_DESTRUCTOR)
3305 /* Explicit destructor call; don't check for null pointer. */
3306 ifexp = integer_one_node;
3308 /* Handle deleting a null pointer. */
3309 ifexp = fold (cp_build_binary_op (input_location,
3310 NE_EXPR, addr, integer_zero_node,
3311 tf_warning_or_error));
3313 if (ifexp != integer_one_node)
3314 expr = build3 (COND_EXPR, void_type_node,
3315 ifexp, expr, void_zero_node);
3321 /* At the beginning of a destructor, push cleanups that will call the
3322 destructors for our base classes and members.
3324 Called from begin_destructor_body. */
3327 push_base_cleanups (void)
3329 tree binfo, base_binfo;
3333 VEC(tree,gc) *vbases;
3335 /* Run destructors for all virtual baseclasses. */
3336 if (CLASSTYPE_VBASECLASSES (current_class_type))
3338 tree cond = (condition_conversion
3339 (build2 (BIT_AND_EXPR, integer_type_node,
3340 current_in_charge_parm,
3341 integer_two_node)));
3343 /* The CLASSTYPE_VBASECLASSES vector is in initialization
3344 order, which is also the right order for pushing cleanups. */
3345 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
3346 VEC_iterate (tree, vbases, i, base_binfo); i++)
3348 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
3350 expr = build_special_member_call (current_class_ref,
3351 base_dtor_identifier,
3355 | LOOKUP_NONVIRTUAL),
3356 tf_warning_or_error);
3357 expr = build3 (COND_EXPR, void_type_node, cond,
3358 expr, void_zero_node);
3359 finish_decl_cleanup (NULL_TREE, expr);
3364 /* Take care of the remaining baseclasses. */
3365 for (binfo = TYPE_BINFO (current_class_type), i = 0;
3366 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
3368 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
3369 || BINFO_VIRTUAL_P (base_binfo))
3372 expr = build_special_member_call (current_class_ref,
3373 base_dtor_identifier,
3375 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
3376 tf_warning_or_error);
3377 finish_decl_cleanup (NULL_TREE, expr);
3380 /* Don't automatically destroy union members. */
3381 if (TREE_CODE (current_class_type) == UNION_TYPE)
3384 for (member = TYPE_FIELDS (current_class_type); member;
3385 member = DECL_CHAIN (member))
3387 tree this_type = TREE_TYPE (member);
3388 if (this_type == error_mark_node
3389 || TREE_CODE (member) != FIELD_DECL
3390 || DECL_ARTIFICIAL (member))
3392 if (ANON_UNION_TYPE_P (this_type))
3394 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (this_type))
3396 tree this_member = (build_class_member_access_expr
3397 (current_class_ref, member,
3398 /*access_path=*/NULL_TREE,
3399 /*preserve_reference=*/false,
3400 tf_warning_or_error));
3401 expr = build_delete (this_type, this_member,
3402 sfk_complete_destructor,
3403 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
3405 finish_decl_cleanup (NULL_TREE, expr);
3410 /* Build a C++ vector delete expression.
3411 MAXINDEX is the number of elements to be deleted.
3412 ELT_SIZE is the nominal size of each element in the vector.
3413 BASE is the expression that should yield the store to be deleted.
3414 This function expands (or synthesizes) these calls itself.
3415 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3417 This also calls delete for virtual baseclasses of elements of the vector.
3419 Update: MAXINDEX is no longer needed. The size can be extracted from the
3420 start of the vector for pointers, and from the type for arrays. We still
3421 use MAXINDEX for arrays because it happens to already have one of the
3422 values we'd have to extract. (We could use MAXINDEX with pointers to
3423 confirm the size, and trap if the numbers differ; not clear that it'd
3424 be worth bothering.) */
3427 build_vec_delete (tree base, tree maxindex,
3428 special_function_kind auto_delete_vec, int use_global_delete)
3432 tree base_init = NULL_TREE;
3434 type = TREE_TYPE (base);
3436 if (TREE_CODE (type) == POINTER_TYPE)
3438 /* Step back one from start of vector, and read dimension. */
3440 tree size_ptr_type = build_pointer_type (sizetype);
3442 if (TREE_SIDE_EFFECTS (base))
3444 base_init = get_target_expr (base);
3445 base = TARGET_EXPR_SLOT (base_init);
3447 type = strip_array_types (TREE_TYPE (type));
3448 cookie_addr = fold_build1_loc (input_location, NEGATE_EXPR,
3449 sizetype, TYPE_SIZE_UNIT (sizetype));
3450 cookie_addr = build2 (POINTER_PLUS_EXPR,
3452 fold_convert (size_ptr_type, base),
3454 maxindex = cp_build_indirect_ref (cookie_addr, RO_NULL, tf_warning_or_error);
3456 else if (TREE_CODE (type) == ARRAY_TYPE)
3458 /* Get the total number of things in the array, maxindex is a
3460 maxindex = array_type_nelts_total (type);
3461 type = strip_array_types (type);
3462 base = cp_build_unary_op (ADDR_EXPR, base, 1, tf_warning_or_error);
3463 if (TREE_SIDE_EFFECTS (base))
3465 base_init = get_target_expr (base);
3466 base = TARGET_EXPR_SLOT (base_init);
3471 if (base != error_mark_node)
3472 error ("type to vector delete is neither pointer or array type");
3473 return error_mark_node;
3476 rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3479 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);