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
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"
39 static bool begin_init_stmts (tree *, tree *);
40 static tree finish_init_stmts (bool, tree, tree);
41 static void construct_virtual_base (tree, tree);
42 static void expand_aggr_init_1 (tree, tree, tree, tree, int, tsubst_flags_t);
43 static void expand_default_init (tree, tree, tree, tree, int, tsubst_flags_t);
44 static tree build_vec_delete_1 (tree, tree, tree, special_function_kind, int);
45 static void perform_member_init (tree, tree);
46 static tree build_builtin_delete_call (tree);
47 static int member_init_ok_or_else (tree, tree, tree);
48 static void expand_virtual_init (tree, tree);
49 static tree sort_mem_initializers (tree, tree);
50 static tree initializing_context (tree);
51 static void expand_cleanup_for_base (tree, tree);
52 static tree get_temp_regvar (tree, tree);
53 static tree dfs_initialize_vtbl_ptrs (tree, void *);
54 static tree build_dtor_call (tree, special_function_kind, int);
55 static tree build_field_list (tree, tree, int *);
56 static tree build_vtbl_address (tree);
58 /* We are about to generate some complex initialization code.
59 Conceptually, it is all a single expression. However, we may want
60 to include conditionals, loops, and other such statement-level
61 constructs. Therefore, we build the initialization code inside a
62 statement-expression. This function starts such an expression.
63 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
64 pass them back to finish_init_stmts when the expression is
68 begin_init_stmts (tree *stmt_expr_p, tree *compound_stmt_p)
70 bool is_global = !building_stmt_tree ();
72 *stmt_expr_p = begin_stmt_expr ();
73 *compound_stmt_p = begin_compound_stmt (BCS_NO_SCOPE);
78 /* Finish out the statement-expression begun by the previous call to
79 begin_init_stmts. Returns the statement-expression itself. */
82 finish_init_stmts (bool is_global, tree stmt_expr, tree compound_stmt)
84 finish_compound_stmt (compound_stmt);
86 stmt_expr = finish_stmt_expr (stmt_expr, true);
88 gcc_assert (!building_stmt_tree () == is_global);
95 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
96 which we want to initialize the vtable pointer for, DATA is
97 TREE_LIST whose TREE_VALUE is the this ptr expression. */
100 dfs_initialize_vtbl_ptrs (tree binfo, void *data)
102 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
103 return dfs_skip_bases;
105 if (!BINFO_PRIMARY_P (binfo) || BINFO_VIRTUAL_P (binfo))
107 tree base_ptr = TREE_VALUE ((tree) data);
109 base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /*nonnull=*/1);
111 expand_virtual_init (binfo, base_ptr);
117 /* Initialize all the vtable pointers in the object pointed to by
121 initialize_vtbl_ptrs (tree addr)
126 type = TREE_TYPE (TREE_TYPE (addr));
127 list = build_tree_list (type, addr);
129 /* Walk through the hierarchy, initializing the vptr in each base
130 class. We do these in pre-order because we can't find the virtual
131 bases for a class until we've initialized the vtbl for that
133 dfs_walk_once (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs, NULL, list);
136 /* Return an expression for the zero-initialization of an object with
137 type T. This expression will either be a constant (in the case
138 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
139 aggregate), or NULL (in the case that T does not require
140 initialization). In either case, the value can be used as
141 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
142 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
143 is the number of elements in the array. If STATIC_STORAGE_P is
144 TRUE, initializers are only generated for entities for which
145 zero-initialization does not simply mean filling the storage with
149 build_zero_init (tree type, tree nelts, bool static_storage_p)
151 tree init = NULL_TREE;
155 To zero-initialize an object of type T means:
157 -- if T is a scalar type, the storage is set to the value of zero
160 -- if T is a non-union class type, the storage for each nonstatic
161 data member and each base-class subobject is zero-initialized.
163 -- if T is a union type, the storage for its first data member is
166 -- if T is an array type, the storage for each element is
169 -- if T is a reference type, no initialization is performed. */
171 gcc_assert (nelts == NULL_TREE || TREE_CODE (nelts) == INTEGER_CST);
173 if (type == error_mark_node)
175 else if (static_storage_p && zero_init_p (type))
176 /* In order to save space, we do not explicitly build initializers
177 for items that do not need them. GCC's semantics are that
178 items with static storage duration that are not otherwise
179 initialized are initialized to zero. */
181 else if (SCALAR_TYPE_P (type))
182 init = convert (type, integer_zero_node);
183 else if (CLASS_TYPE_P (type))
186 VEC(constructor_elt,gc) *v = NULL;
188 /* Iterate over the fields, building initializations. */
189 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
191 if (TREE_CODE (field) != FIELD_DECL)
194 /* Note that for class types there will be FIELD_DECLs
195 corresponding to base classes as well. Thus, iterating
196 over TYPE_FIELDs will result in correct initialization of
197 all of the subobjects. */
198 if (!static_storage_p || !zero_init_p (TREE_TYPE (field)))
200 tree value = build_zero_init (TREE_TYPE (field),
204 CONSTRUCTOR_APPEND_ELT(v, field, value);
207 /* For unions, only the first field is initialized. */
208 if (TREE_CODE (type) == UNION_TYPE)
212 /* Build a constructor to contain the initializations. */
213 init = build_constructor (type, v);
215 else if (TREE_CODE (type) == ARRAY_TYPE)
218 VEC(constructor_elt,gc) *v = NULL;
220 /* Iterate over the array elements, building initializations. */
222 max_index = fold_build2 (MINUS_EXPR, TREE_TYPE (nelts),
223 nelts, integer_one_node);
225 max_index = array_type_nelts (type);
227 /* If we have an error_mark here, we should just return error mark
228 as we don't know the size of the array yet. */
229 if (max_index == error_mark_node)
230 return error_mark_node;
231 gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
233 /* A zero-sized array, which is accepted as an extension, will
234 have an upper bound of -1. */
235 if (!tree_int_cst_equal (max_index, integer_minus_one_node))
239 v = VEC_alloc (constructor_elt, gc, 1);
240 ce = VEC_quick_push (constructor_elt, v, NULL);
242 /* If this is a one element array, we just use a regular init. */
243 if (tree_int_cst_equal (size_zero_node, max_index))
244 ce->index = size_zero_node;
246 ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
249 ce->value = build_zero_init (TREE_TYPE (type),
254 /* Build a constructor to contain the initializations. */
255 init = build_constructor (type, v);
257 else if (TREE_CODE (type) == VECTOR_TYPE)
258 init = fold_convert (type, integer_zero_node);
260 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
262 /* In all cases, the initializer is a constant. */
264 TREE_CONSTANT (init) = 1;
269 /* Return a suitable initializer for value-initializing an object of type
270 TYPE, as described in [dcl.init]. */
273 build_value_init (tree type)
277 To value-initialize an object of type T means:
279 - if T is a class type (clause 9) with a user-provided constructor
280 (12.1), then the default constructor for T is called (and the
281 initialization is ill-formed if T has no accessible default
284 - if T is a non-union class type without a user-provided constructor,
285 then every non-static data member and base-class component of T is
286 value-initialized;92)
288 - if T is an array type, then each element is value-initialized;
290 - otherwise, the object is zero-initialized.
292 A program that calls for default-initialization or
293 value-initialization of an entity of reference type is ill-formed.
295 92) Value-initialization for such a class object may be implemented by
296 zero-initializing the object and then calling the default
299 if (CLASS_TYPE_P (type))
301 if (type_has_user_provided_constructor (type))
302 return build_aggr_init_expr
304 build_special_member_call (NULL_TREE, complete_ctor_identifier,
305 NULL_TREE, type, LOOKUP_NORMAL,
306 tf_warning_or_error));
307 else if (TREE_CODE (type) != UNION_TYPE && TYPE_NEEDS_CONSTRUCTING (type))
309 /* This is a class that needs constructing, but doesn't have
310 a user-provided constructor. So we need to zero-initialize
311 the object and then call the implicitly defined ctor.
312 Implement this by sticking the zero-initialization inside
313 the TARGET_EXPR for the constructor call;
314 cp_gimplify_init_expr will know how to handle it. */
315 tree init = build_zero_init (type, NULL_TREE,
316 /*static_storage_p=*/false);
317 tree ctor = build_special_member_call
318 (NULL_TREE, complete_ctor_identifier,
319 NULL_TREE, type, LOOKUP_NORMAL, tf_warning_or_error);
321 ctor = build_cplus_new (type, ctor);
322 init = build2 (INIT_EXPR, void_type_node,
323 TARGET_EXPR_SLOT (ctor), init);
324 init = build2 (COMPOUND_EXPR, void_type_node, init,
325 TARGET_EXPR_INITIAL (ctor));
326 TARGET_EXPR_INITIAL (ctor) = init;
329 else if (TREE_CODE (type) != UNION_TYPE)
332 VEC(constructor_elt,gc) *v = NULL;
334 /* Iterate over the fields, building initializations. */
335 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
339 if (TREE_CODE (field) != FIELD_DECL)
342 ftype = TREE_TYPE (field);
344 if (TREE_CODE (ftype) == REFERENCE_TYPE)
345 error ("value-initialization of reference");
347 /* We could skip vfields and fields of types with
348 user-defined constructors, but I think that won't improve
349 performance at all; it should be simpler in general just
350 to zero out the entire object than try to only zero the
351 bits that actually need it. */
353 /* Note that for class types there will be FIELD_DECLs
354 corresponding to base classes as well. Thus, iterating
355 over TYPE_FIELDs will result in correct initialization of
356 all of the subobjects. */
357 value = build_value_init (ftype);
360 CONSTRUCTOR_APPEND_ELT(v, field, value);
363 /* Build a constructor to contain the zero- initializations. */
364 return build_constructor (type, v);
367 else if (TREE_CODE (type) == ARRAY_TYPE)
369 VEC(constructor_elt,gc) *v = NULL;
371 /* Iterate over the array elements, building initializations. */
372 tree max_index = array_type_nelts (type);
374 /* If we have an error_mark here, we should just return error mark
375 as we don't know the size of the array yet. */
376 if (max_index == error_mark_node)
377 return error_mark_node;
378 gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
380 /* A zero-sized array, which is accepted as an extension, will
381 have an upper bound of -1. */
382 if (!tree_int_cst_equal (max_index, integer_minus_one_node))
386 v = VEC_alloc (constructor_elt, gc, 1);
387 ce = VEC_quick_push (constructor_elt, v, NULL);
389 /* If this is a one element array, we just use a regular init. */
390 if (tree_int_cst_equal (size_zero_node, max_index))
391 ce->index = size_zero_node;
393 ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
396 ce->value = build_value_init (TREE_TYPE (type));
398 /* The gimplifier can't deal with a RANGE_EXPR of TARGET_EXPRs. */
399 gcc_assert (TREE_CODE (ce->value) != TARGET_EXPR
400 && TREE_CODE (ce->value) != AGGR_INIT_EXPR);
403 /* Build a constructor to contain the initializations. */
404 return build_constructor (type, v);
407 return build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
410 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
411 arguments. If TREE_LIST is void_type_node, an empty initializer
412 list was given; if NULL_TREE no initializer was given. */
415 perform_member_init (tree member, tree init)
418 tree type = TREE_TYPE (member);
420 /* Effective C++ rule 12 requires that all data members be
422 if (warn_ecpp && init == NULL_TREE && TREE_CODE (type) != ARRAY_TYPE)
423 warning (OPT_Weffc__, "%J%qD should be initialized in the member initialization "
424 "list", current_function_decl, member);
426 /* Get an lvalue for the data member. */
427 decl = build_class_member_access_expr (current_class_ref, member,
428 /*access_path=*/NULL_TREE,
429 /*preserve_reference=*/true,
430 tf_warning_or_error);
431 if (decl == error_mark_node)
434 if (init == void_type_node)
436 /* mem() means value-initialization. */
437 if (TREE_CODE (type) == ARRAY_TYPE)
438 init = build_vec_init (decl, NULL_TREE, NULL_TREE,
439 /*explicit_value_init_p=*/true,
441 tf_warning_or_error);
444 if (TREE_CODE (type) == REFERENCE_TYPE)
445 warning (0, "%Jdefault-initialization of %q#D, "
446 "which has reference type",
447 current_function_decl, member);
448 init = build2 (INIT_EXPR, type, decl, build_value_init (type));
450 finish_expr_stmt (init);
452 /* Deal with this here, as we will get confused if we try to call the
453 assignment op for an anonymous union. This can happen in a
454 synthesized copy constructor. */
455 else if (ANON_AGGR_TYPE_P (type))
459 init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init));
460 finish_expr_stmt (init);
463 else if (TYPE_NEEDS_CONSTRUCTING (type))
465 if (init != NULL_TREE
466 && TREE_CODE (type) == ARRAY_TYPE
467 && TREE_CHAIN (init) == NULL_TREE
468 && TREE_CODE (TREE_TYPE (TREE_VALUE (init))) == ARRAY_TYPE)
470 /* Initialization of one array from another. */
471 finish_expr_stmt (build_vec_init (decl, NULL_TREE, TREE_VALUE (init),
472 /*explicit_value_init_p=*/false,
474 tf_warning_or_error));
478 if (CP_TYPE_CONST_P (type)
480 && !type_has_user_provided_default_constructor (type))
481 /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
482 vtable; still give this diagnostic. */
483 permerror (input_location, "%Juninitialized member %qD with %<const%> type %qT",
484 current_function_decl, member, type);
485 finish_expr_stmt (build_aggr_init (decl, init, 0,
486 tf_warning_or_error));
491 if (init == NULL_TREE)
493 /* member traversal: note it leaves init NULL */
494 if (TREE_CODE (type) == REFERENCE_TYPE)
495 permerror (input_location, "%Juninitialized reference member %qD",
496 current_function_decl, member);
497 else if (CP_TYPE_CONST_P (type))
498 permerror (input_location, "%Juninitialized member %qD with %<const%> type %qT",
499 current_function_decl, member, type);
501 else if (TREE_CODE (init) == TREE_LIST)
502 /* There was an explicit member initialization. Do some work
504 init = build_x_compound_expr_from_list (init, "member initializer");
507 finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,
508 tf_warning_or_error));
511 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
515 expr = build_class_member_access_expr (current_class_ref, member,
516 /*access_path=*/NULL_TREE,
517 /*preserve_reference=*/false,
518 tf_warning_or_error);
519 expr = build_delete (type, expr, sfk_complete_destructor,
520 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
522 if (expr != error_mark_node)
523 finish_eh_cleanup (expr);
527 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
528 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
531 build_field_list (tree t, tree list, int *uses_unions_p)
537 /* Note whether or not T is a union. */
538 if (TREE_CODE (t) == UNION_TYPE)
541 for (fields = TYPE_FIELDS (t); fields; fields = TREE_CHAIN (fields))
543 /* Skip CONST_DECLs for enumeration constants and so forth. */
544 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
547 /* Keep track of whether or not any fields are unions. */
548 if (TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
551 /* For an anonymous struct or union, we must recursively
552 consider the fields of the anonymous type. They can be
553 directly initialized from the constructor. */
554 if (ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
556 /* Add this field itself. Synthesized copy constructors
557 initialize the entire aggregate. */
558 list = tree_cons (fields, NULL_TREE, list);
559 /* And now add the fields in the anonymous aggregate. */
560 list = build_field_list (TREE_TYPE (fields), list,
563 /* Add this field. */
564 else if (DECL_NAME (fields))
565 list = tree_cons (fields, NULL_TREE, list);
571 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
572 a FIELD_DECL or BINFO in T that needs initialization. The
573 TREE_VALUE gives the initializer, or list of initializer arguments.
575 Return a TREE_LIST containing all of the initializations required
576 for T, in the order in which they should be performed. The output
577 list has the same format as the input. */
580 sort_mem_initializers (tree t, tree mem_inits)
583 tree base, binfo, base_binfo;
586 VEC(tree,gc) *vbases;
590 /* Build up a list of initializations. The TREE_PURPOSE of entry
591 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
592 TREE_VALUE will be the constructor arguments, or NULL if no
593 explicit initialization was provided. */
594 sorted_inits = NULL_TREE;
596 /* Process the virtual bases. */
597 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
598 VEC_iterate (tree, vbases, i, base); i++)
599 sorted_inits = tree_cons (base, NULL_TREE, sorted_inits);
601 /* Process the direct bases. */
602 for (binfo = TYPE_BINFO (t), i = 0;
603 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
604 if (!BINFO_VIRTUAL_P (base_binfo))
605 sorted_inits = tree_cons (base_binfo, NULL_TREE, sorted_inits);
607 /* Process the non-static data members. */
608 sorted_inits = build_field_list (t, sorted_inits, &uses_unions_p);
609 /* Reverse the entire list of initializations, so that they are in
610 the order that they will actually be performed. */
611 sorted_inits = nreverse (sorted_inits);
613 /* If the user presented the initializers in an order different from
614 that in which they will actually occur, we issue a warning. Keep
615 track of the next subobject which can be explicitly initialized
616 without issuing a warning. */
617 next_subobject = sorted_inits;
619 /* Go through the explicit initializers, filling in TREE_PURPOSE in
621 for (init = mem_inits; init; init = TREE_CHAIN (init))
626 subobject = TREE_PURPOSE (init);
628 /* If the explicit initializers are in sorted order, then
629 SUBOBJECT will be NEXT_SUBOBJECT, or something following
631 for (subobject_init = next_subobject;
633 subobject_init = TREE_CHAIN (subobject_init))
634 if (TREE_PURPOSE (subobject_init) == subobject)
637 /* Issue a warning if the explicit initializer order does not
638 match that which will actually occur.
639 ??? Are all these on the correct lines? */
640 if (warn_reorder && !subobject_init)
642 if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)
643 warning (OPT_Wreorder, "%q+D will be initialized after",
644 TREE_PURPOSE (next_subobject));
646 warning (OPT_Wreorder, "base %qT will be initialized after",
647 TREE_PURPOSE (next_subobject));
648 if (TREE_CODE (subobject) == FIELD_DECL)
649 warning (OPT_Wreorder, " %q+#D", subobject);
651 warning (OPT_Wreorder, " base %qT", subobject);
652 warning (OPT_Wreorder, "%J when initialized here", current_function_decl);
655 /* Look again, from the beginning of the list. */
658 subobject_init = sorted_inits;
659 while (TREE_PURPOSE (subobject_init) != subobject)
660 subobject_init = TREE_CHAIN (subobject_init);
663 /* It is invalid to initialize the same subobject more than
665 if (TREE_VALUE (subobject_init))
667 if (TREE_CODE (subobject) == FIELD_DECL)
668 error ("%Jmultiple initializations given for %qD",
669 current_function_decl, subobject);
671 error ("%Jmultiple initializations given for base %qT",
672 current_function_decl, subobject);
675 /* Record the initialization. */
676 TREE_VALUE (subobject_init) = TREE_VALUE (init);
677 next_subobject = subobject_init;
682 If a ctor-initializer specifies more than one mem-initializer for
683 multiple members of the same union (including members of
684 anonymous unions), the ctor-initializer is ill-formed. */
687 tree last_field = NULL_TREE;
688 for (init = sorted_inits; init; init = TREE_CHAIN (init))
694 /* Skip uninitialized members and base classes. */
695 if (!TREE_VALUE (init)
696 || TREE_CODE (TREE_PURPOSE (init)) != FIELD_DECL)
698 /* See if this field is a member of a union, or a member of a
699 structure contained in a union, etc. */
700 field = TREE_PURPOSE (init);
701 for (field_type = DECL_CONTEXT (field);
702 !same_type_p (field_type, t);
703 field_type = TYPE_CONTEXT (field_type))
704 if (TREE_CODE (field_type) == UNION_TYPE)
706 /* If this field is not a member of a union, skip it. */
707 if (TREE_CODE (field_type) != UNION_TYPE)
710 /* It's only an error if we have two initializers for the same
718 /* See if LAST_FIELD and the field initialized by INIT are
719 members of the same union. If so, there's a problem,
720 unless they're actually members of the same structure
721 which is itself a member of a union. For example, given:
723 union { struct { int i; int j; }; };
725 initializing both `i' and `j' makes sense. */
726 field_type = DECL_CONTEXT (field);
730 tree last_field_type;
732 last_field_type = DECL_CONTEXT (last_field);
735 if (same_type_p (last_field_type, field_type))
737 if (TREE_CODE (field_type) == UNION_TYPE)
738 error ("%Jinitializations for multiple members of %qT",
739 current_function_decl, last_field_type);
744 if (same_type_p (last_field_type, t))
747 last_field_type = TYPE_CONTEXT (last_field_type);
750 /* If we've reached the outermost class, then we're
752 if (same_type_p (field_type, t))
755 field_type = TYPE_CONTEXT (field_type);
766 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
767 is a TREE_LIST giving the explicit mem-initializer-list for the
768 constructor. The TREE_PURPOSE of each entry is a subobject (a
769 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
770 is a TREE_LIST giving the arguments to the constructor or
771 void_type_node for an empty list of arguments. */
774 emit_mem_initializers (tree mem_inits)
776 /* We will already have issued an error message about the fact that
777 the type is incomplete. */
778 if (!COMPLETE_TYPE_P (current_class_type))
781 /* Sort the mem-initializers into the order in which the
782 initializations should be performed. */
783 mem_inits = sort_mem_initializers (current_class_type, mem_inits);
785 in_base_initializer = 1;
787 /* Initialize base classes. */
789 && TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)
791 tree subobject = TREE_PURPOSE (mem_inits);
792 tree arguments = TREE_VALUE (mem_inits);
794 /* If these initializations are taking place in a copy constructor,
795 the base class should probably be explicitly initialized if there
796 is a user-defined constructor in the base class (other than the
797 default constructor, which will be called anyway). */
798 if (extra_warnings && !arguments
799 && DECL_COPY_CONSTRUCTOR_P (current_function_decl)
800 && type_has_user_nondefault_constructor (BINFO_TYPE (subobject)))
801 warning (OPT_Wextra, "%Jbase class %q#T should be explicitly initialized in the "
803 current_function_decl, BINFO_TYPE (subobject));
805 /* If an explicit -- but empty -- initializer list was present,
806 treat it just like default initialization at this point. */
807 if (arguments == void_type_node)
808 arguments = NULL_TREE;
810 /* Initialize the base. */
811 if (BINFO_VIRTUAL_P (subobject))
812 construct_virtual_base (subobject, arguments);
817 base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
819 expand_aggr_init_1 (subobject, NULL_TREE,
820 cp_build_indirect_ref (base_addr, NULL,
821 tf_warning_or_error),
824 tf_warning_or_error);
825 expand_cleanup_for_base (subobject, NULL_TREE);
828 mem_inits = TREE_CHAIN (mem_inits);
830 in_base_initializer = 0;
832 /* Initialize the vptrs. */
833 initialize_vtbl_ptrs (current_class_ptr);
835 /* Initialize the data members. */
838 perform_member_init (TREE_PURPOSE (mem_inits),
839 TREE_VALUE (mem_inits));
840 mem_inits = TREE_CHAIN (mem_inits);
844 /* Returns the address of the vtable (i.e., the value that should be
845 assigned to the vptr) for BINFO. */
848 build_vtbl_address (tree binfo)
850 tree binfo_for = binfo;
853 if (BINFO_VPTR_INDEX (binfo) && BINFO_VIRTUAL_P (binfo))
854 /* If this is a virtual primary base, then the vtable we want to store
855 is that for the base this is being used as the primary base of. We
856 can't simply skip the initialization, because we may be expanding the
857 inits of a subobject constructor where the virtual base layout
859 while (BINFO_PRIMARY_P (binfo_for))
860 binfo_for = BINFO_INHERITANCE_CHAIN (binfo_for);
862 /* Figure out what vtable BINFO's vtable is based on, and mark it as
864 vtbl = get_vtbl_decl_for_binfo (binfo_for);
865 assemble_external (vtbl);
866 TREE_USED (vtbl) = 1;
868 /* Now compute the address to use when initializing the vptr. */
869 vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
870 if (TREE_CODE (vtbl) == VAR_DECL)
871 vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
876 /* This code sets up the virtual function tables appropriate for
877 the pointer DECL. It is a one-ply initialization.
879 BINFO is the exact type that DECL is supposed to be. In
880 multiple inheritance, this might mean "C's A" if C : A, B. */
883 expand_virtual_init (tree binfo, tree decl)
888 /* Compute the initializer for vptr. */
889 vtbl = build_vtbl_address (binfo);
891 /* We may get this vptr from a VTT, if this is a subobject
892 constructor or subobject destructor. */
893 vtt_index = BINFO_VPTR_INDEX (binfo);
899 /* Compute the value to use, when there's a VTT. */
900 vtt_parm = current_vtt_parm;
901 vtbl2 = build2 (POINTER_PLUS_EXPR,
902 TREE_TYPE (vtt_parm),
905 vtbl2 = cp_build_indirect_ref (vtbl2, NULL, tf_warning_or_error);
906 vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
908 /* The actual initializer is the VTT value only in the subobject
909 constructor. In maybe_clone_body we'll substitute NULL for
910 the vtt_parm in the case of the non-subobject constructor. */
911 vtbl = build3 (COND_EXPR,
913 build2 (EQ_EXPR, boolean_type_node,
914 current_in_charge_parm, integer_zero_node),
919 /* Compute the location of the vtpr. */
920 vtbl_ptr = build_vfield_ref (cp_build_indirect_ref (decl, NULL,
921 tf_warning_or_error),
923 gcc_assert (vtbl_ptr != error_mark_node);
925 /* Assign the vtable to the vptr. */
926 vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
927 finish_expr_stmt (cp_build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl,
928 tf_warning_or_error));
931 /* If an exception is thrown in a constructor, those base classes already
932 constructed must be destroyed. This function creates the cleanup
933 for BINFO, which has just been constructed. If FLAG is non-NULL,
934 it is a DECL which is nonzero when this base needs to be
938 expand_cleanup_for_base (tree binfo, tree flag)
942 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
945 /* Call the destructor. */
946 expr = build_special_member_call (current_class_ref,
947 base_dtor_identifier,
950 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
951 tf_warning_or_error);
953 expr = fold_build3 (COND_EXPR, void_type_node,
954 c_common_truthvalue_conversion (input_location, flag),
955 expr, integer_zero_node);
957 finish_eh_cleanup (expr);
960 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
964 construct_virtual_base (tree vbase, tree arguments)
970 /* If there are virtual base classes with destructors, we need to
971 emit cleanups to destroy them if an exception is thrown during
972 the construction process. These exception regions (i.e., the
973 period during which the cleanups must occur) begin from the time
974 the construction is complete to the end of the function. If we
975 create a conditional block in which to initialize the
976 base-classes, then the cleanup region for the virtual base begins
977 inside a block, and ends outside of that block. This situation
978 confuses the sjlj exception-handling code. Therefore, we do not
979 create a single conditional block, but one for each
980 initialization. (That way the cleanup regions always begin
981 in the outer block.) We trust the back end to figure out
982 that the FLAG will not change across initializations, and
983 avoid doing multiple tests. */
984 flag = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
985 inner_if_stmt = begin_if_stmt ();
986 finish_if_stmt_cond (flag, inner_if_stmt);
988 /* Compute the location of the virtual base. If we're
989 constructing virtual bases, then we must be the most derived
990 class. Therefore, we don't have to look up the virtual base;
991 we already know where it is. */
992 exp = convert_to_base_statically (current_class_ref, vbase);
994 expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
995 LOOKUP_COMPLAIN, tf_warning_or_error);
996 finish_then_clause (inner_if_stmt);
997 finish_if_stmt (inner_if_stmt);
999 expand_cleanup_for_base (vbase, flag);
1002 /* Find the context in which this FIELD can be initialized. */
1005 initializing_context (tree field)
1007 tree t = DECL_CONTEXT (field);
1009 /* Anonymous union members can be initialized in the first enclosing
1010 non-anonymous union context. */
1011 while (t && ANON_AGGR_TYPE_P (t))
1012 t = TYPE_CONTEXT (t);
1016 /* Function to give error message if member initialization specification
1017 is erroneous. FIELD is the member we decided to initialize.
1018 TYPE is the type for which the initialization is being performed.
1019 FIELD must be a member of TYPE.
1021 MEMBER_NAME is the name of the member. */
1024 member_init_ok_or_else (tree field, tree type, tree member_name)
1026 if (field == error_mark_node)
1030 error ("class %qT does not have any field named %qD", type,
1034 if (TREE_CODE (field) == VAR_DECL)
1036 error ("%q#D is a static data member; it can only be "
1037 "initialized at its definition",
1041 if (TREE_CODE (field) != FIELD_DECL)
1043 error ("%q#D is not a non-static data member of %qT",
1047 if (initializing_context (field) != type)
1049 error ("class %qT does not have any field named %qD", type,
1057 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1058 is a _TYPE node or TYPE_DECL which names a base for that type.
1059 Check the validity of NAME, and return either the base _TYPE, base
1060 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
1061 NULL_TREE and issue a diagnostic.
1063 An old style unnamed direct single base construction is permitted,
1064 where NAME is NULL. */
1067 expand_member_init (tree name)
1072 if (!current_class_ref)
1077 /* This is an obsolete unnamed base class initializer. The
1078 parser will already have warned about its use. */
1079 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type)))
1082 error ("unnamed initializer for %qT, which has no base classes",
1083 current_class_type);
1086 basetype = BINFO_TYPE
1087 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0));
1090 error ("unnamed initializer for %qT, which uses multiple inheritance",
1091 current_class_type);
1095 else if (TYPE_P (name))
1097 basetype = TYPE_MAIN_VARIANT (name);
1098 name = TYPE_NAME (name);
1100 else if (TREE_CODE (name) == TYPE_DECL)
1101 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
1103 basetype = NULL_TREE;
1112 if (current_template_parms)
1115 class_binfo = TYPE_BINFO (current_class_type);
1116 direct_binfo = NULL_TREE;
1117 virtual_binfo = NULL_TREE;
1119 /* Look for a direct base. */
1120 for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i)
1121 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo), basetype))
1124 /* Look for a virtual base -- unless the direct base is itself
1126 if (!direct_binfo || !BINFO_VIRTUAL_P (direct_binfo))
1127 virtual_binfo = binfo_for_vbase (basetype, current_class_type);
1129 /* [class.base.init]
1131 If a mem-initializer-id is ambiguous because it designates
1132 both a direct non-virtual base class and an inherited virtual
1133 base class, the mem-initializer is ill-formed. */
1134 if (direct_binfo && virtual_binfo)
1136 error ("%qD is both a direct base and an indirect virtual base",
1141 if (!direct_binfo && !virtual_binfo)
1143 if (CLASSTYPE_VBASECLASSES (current_class_type))
1144 error ("type %qT is not a direct or virtual base of %qT",
1145 basetype, current_class_type);
1147 error ("type %qT is not a direct base of %qT",
1148 basetype, current_class_type);
1152 return direct_binfo ? direct_binfo : virtual_binfo;
1156 if (TREE_CODE (name) == IDENTIFIER_NODE)
1157 field = lookup_field (current_class_type, name, 1, false);
1161 if (member_init_ok_or_else (field, current_class_type, name))
1168 /* This is like `expand_member_init', only it stores one aggregate
1171 INIT comes in two flavors: it is either a value which
1172 is to be stored in EXP, or it is a parameter list
1173 to go to a constructor, which will operate on EXP.
1174 If INIT is not a parameter list for a constructor, then set
1175 LOOKUP_ONLYCONVERTING.
1176 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1177 the initializer, if FLAGS is 0, then it is the (init) form.
1178 If `init' is a CONSTRUCTOR, then we emit a warning message,
1179 explaining that such initializations are invalid.
1181 If INIT resolves to a CALL_EXPR which happens to return
1182 something of the type we are looking for, then we know
1183 that we can safely use that call to perform the
1186 The virtual function table pointer cannot be set up here, because
1187 we do not really know its type.
1189 This never calls operator=().
1191 When initializing, nothing is CONST.
1193 A default copy constructor may have to be used to perform the
1196 A constructor or a conversion operator may have to be used to
1197 perform the initialization, but not both, as it would be ambiguous. */
1200 build_aggr_init (tree exp, tree init, int flags, tsubst_flags_t complain)
1205 tree type = TREE_TYPE (exp);
1206 int was_const = TREE_READONLY (exp);
1207 int was_volatile = TREE_THIS_VOLATILE (exp);
1210 if (init == error_mark_node)
1211 return error_mark_node;
1213 TREE_READONLY (exp) = 0;
1214 TREE_THIS_VOLATILE (exp) = 0;
1216 if (init && TREE_CODE (init) != TREE_LIST)
1217 flags |= LOOKUP_ONLYCONVERTING;
1219 if (TREE_CODE (type) == ARRAY_TYPE)
1223 /* An array may not be initialized use the parenthesized
1224 initialization form -- unless the initializer is "()". */
1225 if (init && TREE_CODE (init) == TREE_LIST)
1227 if (complain & tf_error)
1228 error ("bad array initializer");
1229 return error_mark_node;
1231 /* Must arrange to initialize each element of EXP
1232 from elements of INIT. */
1233 itype = init ? TREE_TYPE (init) : NULL_TREE;
1234 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
1235 TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1236 if (itype && cp_type_quals (itype) != TYPE_UNQUALIFIED)
1237 itype = TREE_TYPE (init) = TYPE_MAIN_VARIANT (itype);
1238 stmt_expr = build_vec_init (exp, NULL_TREE, init,
1239 /*explicit_value_init_p=*/false,
1240 itype && same_type_p (itype,
1243 TREE_READONLY (exp) = was_const;
1244 TREE_THIS_VOLATILE (exp) = was_volatile;
1245 TREE_TYPE (exp) = type;
1247 TREE_TYPE (init) = itype;
1251 if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1252 /* Just know that we've seen something for this node. */
1253 TREE_USED (exp) = 1;
1255 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
1256 destroy_temps = stmts_are_full_exprs_p ();
1257 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
1258 expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1259 init, LOOKUP_NORMAL|flags, complain);
1260 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
1261 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
1262 TREE_READONLY (exp) = was_const;
1263 TREE_THIS_VOLATILE (exp) = was_volatile;
1269 expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags,
1270 tsubst_flags_t complain)
1272 tree type = TREE_TYPE (exp);
1275 /* It fails because there may not be a constructor which takes
1276 its own type as the first (or only parameter), but which does
1277 take other types via a conversion. So, if the thing initializing
1278 the expression is a unit element of type X, first try X(X&),
1279 followed by initialization by X. If neither of these work
1280 out, then look hard. */
1284 if (init && TREE_CODE (init) != TREE_LIST
1285 && (flags & LOOKUP_ONLYCONVERTING))
1287 /* Base subobjects should only get direct-initialization. */
1288 gcc_assert (true_exp == exp);
1290 if (flags & DIRECT_BIND)
1291 /* Do nothing. We hit this in two cases: Reference initialization,
1292 where we aren't initializing a real variable, so we don't want
1293 to run a new constructor; and catching an exception, where we
1294 have already built up the constructor call so we could wrap it
1295 in an exception region. */;
1296 else if (BRACE_ENCLOSED_INITIALIZER_P (init)
1297 && CP_AGGREGATE_TYPE_P (type))
1299 /* A brace-enclosed initializer for an aggregate. */
1300 init = digest_init (type, init);
1303 init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1305 if (TREE_CODE (init) == MUST_NOT_THROW_EXPR)
1306 /* We need to protect the initialization of a catch parm with a
1307 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1308 around the TARGET_EXPR for the copy constructor. See
1309 initialize_handler_parm. */
1311 TREE_OPERAND (init, 0) = build2 (INIT_EXPR, TREE_TYPE (exp), exp,
1312 TREE_OPERAND (init, 0));
1313 TREE_TYPE (init) = void_type_node;
1316 init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1317 TREE_SIDE_EFFECTS (init) = 1;
1318 finish_expr_stmt (init);
1322 if (init == NULL_TREE
1323 || (TREE_CODE (init) == TREE_LIST && ! TREE_TYPE (init)))
1327 init = TREE_VALUE (parms);
1330 parms = build_tree_list (NULL_TREE, init);
1332 if (true_exp == exp)
1333 ctor_name = complete_ctor_identifier;
1335 ctor_name = base_ctor_identifier;
1337 rval = build_special_member_call (exp, ctor_name, parms, binfo, flags,
1339 if (TREE_SIDE_EFFECTS (rval))
1340 finish_expr_stmt (convert_to_void (rval, NULL, complain));
1343 /* This function is responsible for initializing EXP with INIT
1346 BINFO is the binfo of the type for who we are performing the
1347 initialization. For example, if W is a virtual base class of A and B,
1349 If we are initializing B, then W must contain B's W vtable, whereas
1350 were we initializing C, W must contain C's W vtable.
1352 TRUE_EXP is nonzero if it is the true expression being initialized.
1353 In this case, it may be EXP, or may just contain EXP. The reason we
1354 need this is because if EXP is a base element of TRUE_EXP, we
1355 don't necessarily know by looking at EXP where its virtual
1356 baseclass fields should really be pointing. But we do know
1357 from TRUE_EXP. In constructors, we don't know anything about
1358 the value being initialized.
1360 FLAGS is just passed to `build_new_method_call'. See that function
1361 for its description. */
1364 expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags,
1365 tsubst_flags_t complain)
1367 tree type = TREE_TYPE (exp);
1369 gcc_assert (init != error_mark_node && type != error_mark_node);
1370 gcc_assert (building_stmt_tree ());
1372 /* Use a function returning the desired type to initialize EXP for us.
1373 If the function is a constructor, and its first argument is
1374 NULL_TREE, know that it was meant for us--just slide exp on
1375 in and expand the constructor. Constructors now come
1378 if (init && TREE_CODE (exp) == VAR_DECL
1379 && COMPOUND_LITERAL_P (init))
1381 /* If store_init_value returns NULL_TREE, the INIT has been
1382 recorded as the DECL_INITIAL for EXP. That means there's
1383 nothing more we have to do. */
1384 init = store_init_value (exp, init);
1386 finish_expr_stmt (init);
1390 /* We know that expand_default_init can handle everything we want
1392 expand_default_init (binfo, true_exp, exp, init, flags, complain);
1395 /* Report an error if TYPE is not a user-defined, class type. If
1396 OR_ELSE is nonzero, give an error message. */
1399 is_class_type (tree type, int or_else)
1401 if (type == error_mark_node)
1404 if (! CLASS_TYPE_P (type))
1407 error ("%qT is not a class type", type);
1414 get_type_value (tree name)
1416 if (name == error_mark_node)
1419 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1420 return IDENTIFIER_TYPE_VALUE (name);
1425 /* Build a reference to a member of an aggregate. This is not a C++
1426 `&', but really something which can have its address taken, and
1427 then act as a pointer to member, for example TYPE :: FIELD can have
1428 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
1429 this expression is the operand of "&".
1431 @@ Prints out lousy diagnostics for operator <typename>
1434 @@ This function should be rewritten and placed in search.c. */
1437 build_offset_ref (tree type, tree member, bool address_p)
1440 tree basebinfo = NULL_TREE;
1442 /* class templates can come in as TEMPLATE_DECLs here. */
1443 if (TREE_CODE (member) == TEMPLATE_DECL)
1446 if (dependent_type_p (type) || type_dependent_expression_p (member))
1447 return build_qualified_name (NULL_TREE, type, member,
1448 /*template_p=*/false);
1450 gcc_assert (TYPE_P (type));
1451 if (! is_class_type (type, 1))
1452 return error_mark_node;
1454 gcc_assert (DECL_P (member) || BASELINK_P (member));
1455 /* Callers should call mark_used before this point. */
1456 gcc_assert (!DECL_P (member) || TREE_USED (member));
1458 if (!COMPLETE_TYPE_P (complete_type (type))
1459 && !TYPE_BEING_DEFINED (type))
1461 error ("incomplete type %qT does not have member %qD", type, member);
1462 return error_mark_node;
1465 /* Entities other than non-static members need no further
1467 if (TREE_CODE (member) == TYPE_DECL)
1469 if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1470 return convert_from_reference (member);
1472 if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1474 error ("invalid pointer to bit-field %qD", member);
1475 return error_mark_node;
1478 /* Set up BASEBINFO for member lookup. */
1479 decl = maybe_dummy_object (type, &basebinfo);
1481 /* A lot of this logic is now handled in lookup_member. */
1482 if (BASELINK_P (member))
1484 /* Go from the TREE_BASELINK to the member function info. */
1485 tree t = BASELINK_FUNCTIONS (member);
1487 if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1489 /* Get rid of a potential OVERLOAD around it. */
1490 t = OVL_CURRENT (t);
1492 /* Unique functions are handled easily. */
1494 /* For non-static member of base class, we need a special rule
1495 for access checking [class.protected]:
1497 If the access is to form a pointer to member, the
1498 nested-name-specifier shall name the derived class
1499 (or any class derived from that class). */
1500 if (address_p && DECL_P (t)
1501 && DECL_NONSTATIC_MEMBER_P (t))
1502 perform_or_defer_access_check (TYPE_BINFO (type), t, t);
1504 perform_or_defer_access_check (basebinfo, t, t);
1506 if (DECL_STATIC_FUNCTION_P (t))
1511 TREE_TYPE (member) = unknown_type_node;
1513 else if (address_p && TREE_CODE (member) == FIELD_DECL)
1514 /* We need additional test besides the one in
1515 check_accessibility_of_qualified_id in case it is
1516 a pointer to non-static member. */
1517 perform_or_defer_access_check (TYPE_BINFO (type), member, member);
1521 /* If MEMBER is non-static, then the program has fallen afoul of
1524 An id-expression that denotes a nonstatic data member or
1525 nonstatic member function of a class can only be used:
1527 -- as part of a class member access (_expr.ref_) in which the
1528 object-expression refers to the member's class or a class
1529 derived from that class, or
1531 -- to form a pointer to member (_expr.unary.op_), or
1533 -- in the body of a nonstatic member function of that class or
1534 of a class derived from that class (_class.mfct.nonstatic_), or
1536 -- in a mem-initializer for a constructor for that class or for
1537 a class derived from that class (_class.base.init_). */
1538 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1540 /* Build a representation of the qualified name suitable
1541 for use as the operand to "&" -- even though the "&" is
1542 not actually present. */
1543 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1544 /* In Microsoft mode, treat a non-static member function as if
1545 it were a pointer-to-member. */
1546 if (flag_ms_extensions)
1548 PTRMEM_OK_P (member) = 1;
1549 return cp_build_unary_op (ADDR_EXPR, member, 0,
1550 tf_warning_or_error);
1552 error ("invalid use of non-static member function %qD",
1553 TREE_OPERAND (member, 1));
1554 return error_mark_node;
1556 else if (TREE_CODE (member) == FIELD_DECL)
1558 error ("invalid use of non-static data member %qD", member);
1559 return error_mark_node;
1564 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1565 PTRMEM_OK_P (member) = 1;
1569 /* If DECL is a scalar enumeration constant or variable with a
1570 constant initializer, return the initializer (or, its initializers,
1571 recursively); otherwise, return DECL. If INTEGRAL_P, the
1572 initializer is only returned if DECL is an integral
1573 constant-expression. */
1576 constant_value_1 (tree decl, bool integral_p)
1578 while (TREE_CODE (decl) == CONST_DECL
1580 ? DECL_INTEGRAL_CONSTANT_VAR_P (decl)
1581 : (TREE_CODE (decl) == VAR_DECL
1582 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))))
1585 /* Static data members in template classes may have
1586 non-dependent initializers. References to such non-static
1587 data members are not value-dependent, so we must retrieve the
1588 initializer here. The DECL_INITIAL will have the right type,
1589 but will not have been folded because that would prevent us
1590 from performing all appropriate semantic checks at
1591 instantiation time. */
1592 if (DECL_CLASS_SCOPE_P (decl)
1593 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
1594 && uses_template_parms (CLASSTYPE_TI_ARGS
1595 (DECL_CONTEXT (decl))))
1597 ++processing_template_decl;
1598 init = fold_non_dependent_expr (DECL_INITIAL (decl));
1599 --processing_template_decl;
1603 /* If DECL is a static data member in a template
1604 specialization, we must instantiate it here. The
1605 initializer for the static data member is not processed
1606 until needed; we need it now. */
1608 init = DECL_INITIAL (decl);
1610 if (init == error_mark_node)
1612 /* Initializers in templates are generally expanded during
1613 instantiation, so before that for const int i(2)
1614 INIT is a TREE_LIST with the actual initializer as
1616 if (processing_template_decl
1618 && TREE_CODE (init) == TREE_LIST
1619 && TREE_CHAIN (init) == NULL_TREE)
1620 init = TREE_VALUE (init);
1622 || !TREE_TYPE (init)
1624 ? !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (init))
1625 : (!TREE_CONSTANT (init)
1626 /* Do not return an aggregate constant (of which
1627 string literals are a special case), as we do not
1628 want to make inadvertent copies of such entities,
1629 and we must be sure that their addresses are the
1631 || TREE_CODE (init) == CONSTRUCTOR
1632 || TREE_CODE (init) == STRING_CST)))
1634 decl = unshare_expr (init);
1639 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1640 constant of integral or enumeration type, then return that value.
1641 These are those variables permitted in constant expressions by
1645 integral_constant_value (tree decl)
1647 return constant_value_1 (decl, /*integral_p=*/true);
1650 /* A more relaxed version of integral_constant_value, used by the
1651 common C/C++ code and by the C++ front end for optimization
1655 decl_constant_value (tree decl)
1657 return constant_value_1 (decl,
1658 /*integral_p=*/processing_template_decl);
1661 /* Common subroutines of build_new and build_vec_delete. */
1663 /* Call the global __builtin_delete to delete ADDR. */
1666 build_builtin_delete_call (tree addr)
1668 mark_used (global_delete_fndecl);
1669 return build_call_n (global_delete_fndecl, 1, addr);
1672 /* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
1673 the type of the object being allocated; otherwise, it's just TYPE.
1674 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
1675 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
1676 the TREE_LIST of arguments to be provided as arguments to a
1677 placement new operator. This routine performs no semantic checks;
1678 it just creates and returns a NEW_EXPR. */
1681 build_raw_new_expr (tree placement, tree type, tree nelts, tree init,
1686 new_expr = build4 (NEW_EXPR, build_pointer_type (type), placement, type,
1688 NEW_EXPR_USE_GLOBAL (new_expr) = use_global_new;
1689 TREE_SIDE_EFFECTS (new_expr) = 1;
1694 /* Make sure that there are no aliasing issues with T, a placement new
1695 expression applied to PLACEMENT, by recording the change in dynamic
1696 type. If placement new is inlined, as it is with libstdc++, and if
1697 the type of the placement new differs from the type of the
1698 placement location itself, then alias analysis may think it is OK
1699 to interchange writes to the location from before the placement new
1700 and from after the placement new. We have to prevent type-based
1701 alias analysis from applying. PLACEMENT may be NULL, which means
1702 that we couldn't capture it in a temporary variable, in which case
1703 we use a memory clobber. */
1706 avoid_placement_new_aliasing (tree t, tree placement)
1710 if (processing_template_decl)
1713 /* If we are not using type based aliasing, we don't have to do
1715 if (!flag_strict_aliasing)
1718 /* If we have a pointer and a location, record the change in dynamic
1719 type. Otherwise we need a general memory clobber. */
1720 if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE
1721 && placement != NULL_TREE
1722 && TREE_CODE (TREE_TYPE (placement)) == POINTER_TYPE)
1723 type_change = build_stmt (CHANGE_DYNAMIC_TYPE_EXPR,
1728 /* Build a memory clobber. */
1729 type_change = build_stmt (ASM_EXPR,
1730 build_string (0, ""),
1733 tree_cons (NULL_TREE,
1734 build_string (6, "memory"),
1737 ASM_VOLATILE_P (type_change) = 1;
1740 return build2 (COMPOUND_EXPR, TREE_TYPE (t), type_change, t);
1743 /* Generate code for a new-expression, including calling the "operator
1744 new" function, initializing the object, and, if an exception occurs
1745 during construction, cleaning up. The arguments are as for
1746 build_raw_new_expr. */
1749 build_new_1 (tree placement, tree type, tree nelts, tree init,
1750 bool globally_qualified_p, tsubst_flags_t complain)
1753 /* True iff this is a call to "operator new[]" instead of just
1755 bool array_p = false;
1756 /* True iff ARRAY_P is true and the bound of the array type is
1757 not necessarily a compile time constant. For example, VLA_P is
1758 true for "new int[f()]". */
1760 /* The type being allocated. If ARRAY_P is true, this will be an
1763 /* If ARRAY_P is true, the element type of the array. This is an
1764 never ARRAY_TYPE; for something like "new int[3][4]", the
1765 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
1768 /* The type of the new-expression. (This type is always a pointer
1771 /* A pointer type pointing to the FULL_TYPE. */
1772 tree full_pointer_type;
1773 tree outer_nelts = NULL_TREE;
1774 tree alloc_call, alloc_expr;
1775 /* The address returned by the call to "operator new". This node is
1776 a VAR_DECL and is therefore reusable. */
1779 tree cookie_expr, init_expr;
1780 int nothrow, check_new;
1781 int use_java_new = 0;
1782 /* If non-NULL, the number of extra bytes to allocate at the
1783 beginning of the storage allocated for an array-new expression in
1784 order to store the number of elements. */
1785 tree cookie_size = NULL_TREE;
1786 tree placement_expr = NULL_TREE;
1787 /* True if the function we are calling is a placement allocation
1789 bool placement_allocation_fn_p;
1790 tree args = NULL_TREE;
1791 /* True if the storage must be initialized, either by a constructor
1792 or due to an explicit new-initializer. */
1793 bool is_initialized;
1794 /* The address of the thing allocated, not including any cookie. In
1795 particular, if an array cookie is in use, DATA_ADDR is the
1796 address of the first array element. This node is a VAR_DECL, and
1797 is therefore reusable. */
1799 tree init_preeval_expr = NULL_TREE;
1805 outer_nelts = nelts;
1808 /* ??? The middle-end will error on us for building a VLA outside a
1809 function context. Methinks that's not it's purvey. So we'll do
1810 our own VLA layout later. */
1812 index = convert (sizetype, nelts);
1813 index = size_binop (MINUS_EXPR, index, size_one_node);
1814 index = build_index_type (index);
1815 full_type = build_cplus_array_type (type, NULL_TREE);
1816 /* We need a copy of the type as build_array_type will return a shared copy
1817 of the incomplete array type. */
1818 full_type = build_distinct_type_copy (full_type);
1819 TYPE_DOMAIN (full_type) = index;
1820 SET_TYPE_STRUCTURAL_EQUALITY (full_type);
1825 if (TREE_CODE (type) == ARRAY_TYPE)
1828 nelts = array_type_nelts_top (type);
1829 outer_nelts = nelts;
1830 type = TREE_TYPE (type);
1834 /* If our base type is an array, then make sure we know how many elements
1836 for (elt_type = type;
1837 TREE_CODE (elt_type) == ARRAY_TYPE;
1838 elt_type = TREE_TYPE (elt_type))
1839 nelts = cp_build_binary_op (input_location,
1841 array_type_nelts_top (elt_type),
1844 if (TREE_CODE (elt_type) == VOID_TYPE)
1846 if (complain & tf_error)
1847 error ("invalid type %<void%> for new");
1848 return error_mark_node;
1851 if (abstract_virtuals_error (NULL_TREE, elt_type))
1852 return error_mark_node;
1854 is_initialized = (TYPE_NEEDS_CONSTRUCTING (elt_type) || init);
1856 if (CP_TYPE_CONST_P (elt_type) && !init
1857 && !type_has_user_provided_default_constructor (elt_type))
1859 if (complain & tf_error)
1860 error ("uninitialized const in %<new%> of %q#T", elt_type);
1861 return error_mark_node;
1864 size = size_in_bytes (elt_type);
1867 size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
1872 /* Do our own VLA layout. Setting TYPE_SIZE/_UNIT is
1873 necessary in order for the <INIT_EXPR <*foo> <CONSTRUCTOR
1874 ...>> to be valid. */
1875 TYPE_SIZE_UNIT (full_type) = size;
1876 n = convert (bitsizetype, nelts);
1877 bitsize = size_binop (MULT_EXPR, TYPE_SIZE (elt_type), n);
1878 TYPE_SIZE (full_type) = bitsize;
1882 alloc_fn = NULL_TREE;
1884 /* Allocate the object. */
1885 if (! placement && TYPE_FOR_JAVA (elt_type))
1888 tree class_decl = build_java_class_ref (elt_type);
1889 static const char alloc_name[] = "_Jv_AllocObject";
1891 if (class_decl == error_mark_node)
1892 return error_mark_node;
1895 if (!get_global_value_if_present (get_identifier (alloc_name),
1898 if (complain & tf_error)
1899 error ("call to Java constructor with %qs undefined", alloc_name);
1900 return error_mark_node;
1902 else if (really_overloaded_fn (alloc_fn))
1904 if (complain & tf_error)
1905 error ("%qD should never be overloaded", alloc_fn);
1906 return error_mark_node;
1908 alloc_fn = OVL_CURRENT (alloc_fn);
1909 class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
1910 alloc_call = (cp_build_function_call
1912 build_tree_list (NULL_TREE, class_addr),
1915 else if (TYPE_FOR_JAVA (elt_type) && MAYBE_CLASS_TYPE_P (elt_type))
1917 error ("Java class %q#T object allocated using placement new", elt_type);
1918 return error_mark_node;
1925 fnname = ansi_opname (array_p ? VEC_NEW_EXPR : NEW_EXPR);
1927 if (!globally_qualified_p
1928 && CLASS_TYPE_P (elt_type)
1930 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
1931 : TYPE_HAS_NEW_OPERATOR (elt_type)))
1933 /* Use a class-specific operator new. */
1934 /* If a cookie is required, add some extra space. */
1935 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
1937 cookie_size = targetm.cxx.get_cookie_size (elt_type);
1938 size = size_binop (PLUS_EXPR, size, cookie_size);
1940 /* Create the argument list. */
1941 args = tree_cons (NULL_TREE, size, placement);
1942 /* Do name-lookup to find the appropriate operator. */
1943 fns = lookup_fnfields (elt_type, fnname, /*protect=*/2);
1944 if (fns == NULL_TREE)
1946 if (complain & tf_error)
1947 error ("no suitable %qD found in class %qT", fnname, elt_type);
1948 return error_mark_node;
1950 if (TREE_CODE (fns) == TREE_LIST)
1952 if (complain & tf_error)
1954 error ("request for member %qD is ambiguous", fnname);
1955 print_candidates (fns);
1957 return error_mark_node;
1959 alloc_call = build_new_method_call (build_dummy_object (elt_type),
1961 /*conversion_path=*/NULL_TREE,
1968 /* Use a global operator new. */
1969 /* See if a cookie might be required. */
1970 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
1971 cookie_size = targetm.cxx.get_cookie_size (elt_type);
1973 cookie_size = NULL_TREE;
1975 alloc_call = build_operator_new_call (fnname, placement,
1976 &size, &cookie_size,
1981 if (alloc_call == error_mark_node)
1982 return error_mark_node;
1984 gcc_assert (alloc_fn != NULL_TREE);
1986 /* If PLACEMENT is a simple pointer type and is not passed by reference,
1987 then copy it into PLACEMENT_EXPR. */
1988 if (!processing_template_decl
1989 && placement != NULL_TREE
1990 && TREE_CHAIN (placement) == NULL_TREE
1991 && TREE_CODE (TREE_TYPE (TREE_VALUE (placement))) == POINTER_TYPE
1992 && TREE_CODE (alloc_call) == CALL_EXPR
1993 && call_expr_nargs (alloc_call) == 2
1994 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 0))) == INTEGER_TYPE
1995 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 1))) == POINTER_TYPE)
1997 tree placement_arg = CALL_EXPR_ARG (alloc_call, 1);
1999 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg)))
2000 || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg))))
2002 placement_expr = get_target_expr (TREE_VALUE (placement));
2003 CALL_EXPR_ARG (alloc_call, 1)
2004 = convert (TREE_TYPE (placement_arg), placement_expr);
2008 /* In the simple case, we can stop now. */
2009 pointer_type = build_pointer_type (type);
2010 if (!cookie_size && !is_initialized)
2012 rval = build_nop (pointer_type, alloc_call);
2013 if (placement != NULL)
2014 rval = avoid_placement_new_aliasing (rval, placement_expr);
2018 /* Store the result of the allocation call in a variable so that we can
2019 use it more than once. */
2020 alloc_expr = get_target_expr (alloc_call);
2021 alloc_node = TARGET_EXPR_SLOT (alloc_expr);
2023 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
2024 while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
2025 alloc_call = TREE_OPERAND (alloc_call, 1);
2027 /* Now, check to see if this function is actually a placement
2028 allocation function. This can happen even when PLACEMENT is NULL
2029 because we might have something like:
2031 struct S { void* operator new (size_t, int i = 0); };
2033 A call to `new S' will get this allocation function, even though
2034 there is no explicit placement argument. If there is more than
2035 one argument, or there are variable arguments, then this is a
2036 placement allocation function. */
2037 placement_allocation_fn_p
2038 = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
2039 || varargs_function_p (alloc_fn));
2041 /* Preevaluate the placement args so that we don't reevaluate them for a
2042 placement delete. */
2043 if (placement_allocation_fn_p)
2046 stabilize_call (alloc_call, &inits);
2048 alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
2052 /* unless an allocation function is declared with an empty excep-
2053 tion-specification (_except.spec_), throw(), it indicates failure to
2054 allocate storage by throwing a bad_alloc exception (clause _except_,
2055 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2056 cation function is declared with an empty exception-specification,
2057 throw(), it returns null to indicate failure to allocate storage and a
2058 non-null pointer otherwise.
2060 So check for a null exception spec on the op new we just called. */
2062 nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
2063 check_new = (flag_check_new || nothrow) && ! use_java_new;
2071 /* Adjust so we're pointing to the start of the object. */
2072 data_addr = build2 (POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
2073 alloc_node, cookie_size);
2075 /* Store the number of bytes allocated so that we can know how
2076 many elements to destroy later. We use the last sizeof
2077 (size_t) bytes to store the number of elements. */
2078 cookie_ptr = size_binop (MINUS_EXPR, cookie_size, size_in_bytes (sizetype));
2079 cookie_ptr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
2080 alloc_node, cookie_ptr);
2081 size_ptr_type = build_pointer_type (sizetype);
2082 cookie_ptr = fold_convert (size_ptr_type, cookie_ptr);
2083 cookie = cp_build_indirect_ref (cookie_ptr, NULL, complain);
2085 cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
2087 if (targetm.cxx.cookie_has_size ())
2089 /* Also store the element size. */
2090 cookie_ptr = build2 (POINTER_PLUS_EXPR, size_ptr_type, cookie_ptr,
2091 fold_build1 (NEGATE_EXPR, sizetype,
2092 size_in_bytes (sizetype)));
2094 cookie = cp_build_indirect_ref (cookie_ptr, NULL, complain);
2095 cookie = build2 (MODIFY_EXPR, sizetype, cookie,
2096 size_in_bytes (elt_type));
2097 cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
2098 cookie, cookie_expr);
2103 cookie_expr = NULL_TREE;
2104 data_addr = alloc_node;
2107 /* Now use a pointer to the type we've actually allocated. */
2108 full_pointer_type = build_pointer_type (full_type);
2109 data_addr = fold_convert (full_pointer_type, data_addr);
2111 /* Now initialize the allocated object. Note that we preevaluate the
2112 initialization expression, apart from the actual constructor call or
2113 assignment--we do this because we want to delay the allocation as long
2114 as possible in order to minimize the size of the exception region for
2115 placement delete. */
2119 bool explicit_value_init_p = false;
2121 init_expr = cp_build_indirect_ref (data_addr, NULL, complain);
2123 if (init == void_zero_node)
2126 explicit_value_init_p = true;
2133 if (complain & tf_error)
2134 permerror (input_location, "ISO C++ forbids initialization in array new");
2136 return error_mark_node;
2139 = build_vec_init (init_expr,
2140 cp_build_binary_op (input_location,
2141 MINUS_EXPR, outer_nelts,
2145 explicit_value_init_p,
2149 /* An array initialization is stable because the initialization
2150 of each element is a full-expression, so the temporaries don't
2156 if (TYPE_NEEDS_CONSTRUCTING (type) && !explicit_value_init_p)
2158 init_expr = build_special_member_call (init_expr,
2159 complete_ctor_identifier,
2164 else if (explicit_value_init_p)
2166 /* Something like `new int()'. */
2167 init_expr = build2 (INIT_EXPR, full_type,
2168 init_expr, build_value_init (full_type));
2172 /* We are processing something like `new int (10)', which
2173 means allocate an int, and initialize it with 10. */
2175 if (TREE_CODE (init) == TREE_LIST)
2176 init = build_x_compound_expr_from_list (init,
2179 gcc_assert (TREE_CODE (init) != CONSTRUCTOR
2180 || TREE_TYPE (init) != NULL_TREE);
2182 init_expr = cp_build_modify_expr (init_expr, INIT_EXPR, init,
2185 stable = stabilize_init (init_expr, &init_preeval_expr);
2188 if (init_expr == error_mark_node)
2189 return error_mark_node;
2191 /* If any part of the object initialization terminates by throwing an
2192 exception and a suitable deallocation function can be found, the
2193 deallocation function is called to free the memory in which the
2194 object was being constructed, after which the exception continues
2195 to propagate in the context of the new-expression. If no
2196 unambiguous matching deallocation function can be found,
2197 propagating the exception does not cause the object's memory to be
2199 if (flag_exceptions && ! use_java_new)
2201 enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
2204 /* The Standard is unclear here, but the right thing to do
2205 is to use the same method for finding deallocation
2206 functions that we use for finding allocation functions. */
2207 cleanup = (build_op_delete_call
2209 fold_convert (full_pointer_type, alloc_node),
2211 globally_qualified_p,
2212 placement_allocation_fn_p ? alloc_call : NULL_TREE,
2218 /* This is much simpler if we were able to preevaluate all of
2219 the arguments to the constructor call. */
2220 init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2221 init_expr, cleanup);
2223 /* Ack! First we allocate the memory. Then we set our sentry
2224 variable to true, and expand a cleanup that deletes the
2225 memory if sentry is true. Then we run the constructor, and
2226 finally clear the sentry.
2228 We need to do this because we allocate the space first, so
2229 if there are any temporaries with cleanups in the
2230 constructor args and we weren't able to preevaluate them, we
2231 need this EH region to extend until end of full-expression
2232 to preserve nesting. */
2234 tree end, sentry, begin;
2236 begin = get_target_expr (boolean_true_node);
2237 CLEANUP_EH_ONLY (begin) = 1;
2239 sentry = TARGET_EXPR_SLOT (begin);
2241 TARGET_EXPR_CLEANUP (begin)
2242 = build3 (COND_EXPR, void_type_node, sentry,
2243 cleanup, void_zero_node);
2245 end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2246 sentry, boolean_false_node);
2249 = build2 (COMPOUND_EXPR, void_type_node, begin,
2250 build2 (COMPOUND_EXPR, void_type_node, init_expr,
2257 init_expr = NULL_TREE;
2259 /* Now build up the return value in reverse order. */
2264 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2266 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2268 if (rval == data_addr)
2269 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2270 and return the call (which doesn't need to be adjusted). */
2271 rval = TARGET_EXPR_INITIAL (alloc_expr);
2276 tree ifexp = cp_build_binary_op (input_location,
2277 NE_EXPR, alloc_node,
2280 rval = build_conditional_expr (ifexp, rval, alloc_node,
2284 /* Perform the allocation before anything else, so that ALLOC_NODE
2285 has been initialized before we start using it. */
2286 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2289 if (init_preeval_expr)
2290 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2292 /* Convert to the final type. */
2293 rval = build_nop (pointer_type, rval);
2295 /* A new-expression is never an lvalue. */
2296 gcc_assert (!lvalue_p (rval));
2298 if (placement != NULL)
2299 rval = avoid_placement_new_aliasing (rval, placement_expr);
2304 /* Generate a representation for a C++ "new" expression. PLACEMENT is
2305 a TREE_LIST of placement-new arguments (or NULL_TREE if none). If
2306 NELTS is NULL, TYPE is the type of the storage to be allocated. If
2307 NELTS is not NULL, then this is an array-new allocation; TYPE is
2308 the type of the elements in the array and NELTS is the number of
2309 elements in the array. INIT, if non-NULL, is the initializer for
2310 the new object, or void_zero_node to indicate an initializer of
2311 "()". If USE_GLOBAL_NEW is true, then the user explicitly wrote
2312 "::new" rather than just "new". */
2315 build_new (tree placement, tree type, tree nelts, tree init,
2316 int use_global_new, tsubst_flags_t complain)
2319 tree orig_placement;
2323 if (placement == error_mark_node || type == error_mark_node
2324 || init == error_mark_node)
2325 return error_mark_node;
2327 orig_placement = placement;
2331 if (nelts == NULL_TREE && init != void_zero_node && list_length (init) == 1
2332 && !any_type_dependent_arguments_p (init))
2334 tree auto_node = type_uses_auto (type);
2336 type = do_auto_deduction (type, TREE_VALUE (init), auto_node);
2339 if (processing_template_decl)
2341 if (dependent_type_p (type)
2342 || any_type_dependent_arguments_p (placement)
2343 || (nelts && type_dependent_expression_p (nelts))
2344 || (init != void_zero_node
2345 && any_type_dependent_arguments_p (init)))
2346 return build_raw_new_expr (placement, type, nelts, init,
2348 placement = build_non_dependent_args (placement);
2350 nelts = build_non_dependent_expr (nelts);
2351 if (init != void_zero_node)
2352 init = build_non_dependent_args (init);
2357 if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
2359 if (complain & tf_error)
2360 permerror (input_location, "size in array new must have integral type");
2362 return error_mark_node;
2364 nelts = cp_save_expr (cp_convert (sizetype, nelts));
2367 /* ``A reference cannot be created by the new operator. A reference
2368 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2369 returned by new.'' ARM 5.3.3 */
2370 if (TREE_CODE (type) == REFERENCE_TYPE)
2372 if (complain & tf_error)
2373 error ("new cannot be applied to a reference type");
2375 return error_mark_node;
2376 type = TREE_TYPE (type);
2379 if (TREE_CODE (type) == FUNCTION_TYPE)
2381 if (complain & tf_error)
2382 error ("new cannot be applied to a function type");
2383 return error_mark_node;
2386 /* The type allocated must be complete. If the new-type-id was
2387 "T[N]" then we are just checking that "T" is complete here, but
2388 that is equivalent, since the value of "N" doesn't matter. */
2389 if (!complete_type_or_else (type, NULL_TREE))
2390 return error_mark_node;
2392 rval = build_new_1 (placement, type, nelts, init, use_global_new, complain);
2393 if (rval == error_mark_node)
2394 return error_mark_node;
2396 if (processing_template_decl)
2397 return build_raw_new_expr (orig_placement, type, orig_nelts, orig_init,
2400 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2401 rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
2402 TREE_NO_WARNING (rval) = 1;
2407 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2410 build_java_class_ref (tree type)
2412 tree name = NULL_TREE, class_decl;
2413 static tree CL_suffix = NULL_TREE;
2414 if (CL_suffix == NULL_TREE)
2415 CL_suffix = get_identifier("class$");
2416 if (jclass_node == NULL_TREE)
2418 jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2419 if (jclass_node == NULL_TREE)
2421 error ("call to Java constructor, while %<jclass%> undefined");
2422 return error_mark_node;
2424 jclass_node = TREE_TYPE (jclass_node);
2427 /* Mangle the class$ field. */
2430 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2431 if (DECL_NAME (field) == CL_suffix)
2433 mangle_decl (field);
2434 name = DECL_ASSEMBLER_NAME (field);
2439 error ("can't find %<class$%> in %qT", type);
2440 return error_mark_node;
2444 class_decl = IDENTIFIER_GLOBAL_VALUE (name);
2445 if (class_decl == NULL_TREE)
2447 class_decl = build_decl (VAR_DECL, name, TREE_TYPE (jclass_node));
2448 TREE_STATIC (class_decl) = 1;
2449 DECL_EXTERNAL (class_decl) = 1;
2450 TREE_PUBLIC (class_decl) = 1;
2451 DECL_ARTIFICIAL (class_decl) = 1;
2452 DECL_IGNORED_P (class_decl) = 1;
2453 pushdecl_top_level (class_decl);
2454 make_decl_rtl (class_decl);
2460 build_vec_delete_1 (tree base, tree maxindex, tree type,
2461 special_function_kind auto_delete_vec, int use_global_delete)
2464 tree ptype = build_pointer_type (type = complete_type (type));
2465 tree size_exp = size_in_bytes (type);
2467 /* Temporary variables used by the loop. */
2468 tree tbase, tbase_init;
2470 /* This is the body of the loop that implements the deletion of a
2471 single element, and moves temp variables to next elements. */
2474 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2477 /* This is the thing that governs what to do after the loop has run. */
2478 tree deallocate_expr = 0;
2480 /* This is the BIND_EXPR which holds the outermost iterator of the
2481 loop. It is convenient to set this variable up and test it before
2482 executing any other code in the loop.
2483 This is also the containing expression returned by this function. */
2484 tree controller = NULL_TREE;
2487 /* We should only have 1-D arrays here. */
2488 gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2490 if (! MAYBE_CLASS_TYPE_P (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2493 /* The below is short by the cookie size. */
2494 virtual_size = size_binop (MULT_EXPR, size_exp,
2495 convert (sizetype, maxindex));
2497 tbase = create_temporary_var (ptype);
2498 tbase_init = cp_build_modify_expr (tbase, NOP_EXPR,
2499 fold_build2 (POINTER_PLUS_EXPR, ptype,
2500 fold_convert (ptype, base),
2502 tf_warning_or_error);
2503 DECL_REGISTER (tbase) = 1;
2504 controller = build3 (BIND_EXPR, void_type_node, tbase,
2505 NULL_TREE, NULL_TREE);
2506 TREE_SIDE_EFFECTS (controller) = 1;
2508 body = build1 (EXIT_EXPR, void_type_node,
2509 build2 (EQ_EXPR, boolean_type_node, tbase,
2510 fold_convert (ptype, base)));
2511 tmp = fold_build1 (NEGATE_EXPR, sizetype, size_exp);
2512 body = build_compound_expr
2513 (body, cp_build_modify_expr (tbase, NOP_EXPR,
2514 build2 (POINTER_PLUS_EXPR, ptype, tbase, tmp),
2515 tf_warning_or_error));
2516 body = build_compound_expr
2517 (body, build_delete (ptype, tbase, sfk_complete_destructor,
2518 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1));
2520 loop = build1 (LOOP_EXPR, void_type_node, body);
2521 loop = build_compound_expr (tbase_init, loop);
2524 /* If the delete flag is one, or anything else with the low bit set,
2525 delete the storage. */
2526 if (auto_delete_vec != sfk_base_destructor)
2530 /* The below is short by the cookie size. */
2531 virtual_size = size_binop (MULT_EXPR, size_exp,
2532 convert (sizetype, maxindex));
2534 if (! TYPE_VEC_NEW_USES_COOKIE (type))
2541 cookie_size = targetm.cxx.get_cookie_size (type);
2543 = cp_convert (ptype,
2544 cp_build_binary_op (input_location,
2546 cp_convert (string_type_node,
2549 tf_warning_or_error));
2550 /* True size with header. */
2551 virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2554 if (auto_delete_vec == sfk_deleting_destructor)
2555 deallocate_expr = build_op_delete_call (VEC_DELETE_EXPR,
2556 base_tbd, virtual_size,
2557 use_global_delete & 1,
2558 /*placement=*/NULL_TREE,
2559 /*alloc_fn=*/NULL_TREE);
2563 if (!deallocate_expr)
2566 body = deallocate_expr;
2568 body = build_compound_expr (body, deallocate_expr);
2571 body = integer_zero_node;
2573 /* Outermost wrapper: If pointer is null, punt. */
2574 body = fold_build3 (COND_EXPR, void_type_node,
2575 fold_build2 (NE_EXPR, boolean_type_node, base,
2576 convert (TREE_TYPE (base),
2577 integer_zero_node)),
2578 body, integer_zero_node);
2579 body = build1 (NOP_EXPR, void_type_node, body);
2583 TREE_OPERAND (controller, 1) = body;
2587 if (TREE_CODE (base) == SAVE_EXPR)
2588 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
2589 body = build2 (COMPOUND_EXPR, void_type_node, base, body);
2591 return convert_to_void (body, /*implicit=*/NULL, tf_warning_or_error);
2594 /* Create an unnamed variable of the indicated TYPE. */
2597 create_temporary_var (tree type)
2601 decl = build_decl (VAR_DECL, NULL_TREE, type);
2602 TREE_USED (decl) = 1;
2603 DECL_ARTIFICIAL (decl) = 1;
2604 DECL_IGNORED_P (decl) = 1;
2605 DECL_SOURCE_LOCATION (decl) = input_location;
2606 DECL_CONTEXT (decl) = current_function_decl;
2611 /* Create a new temporary variable of the indicated TYPE, initialized
2614 It is not entered into current_binding_level, because that breaks
2615 things when it comes time to do final cleanups (which take place
2616 "outside" the binding contour of the function). */
2619 get_temp_regvar (tree type, tree init)
2623 decl = create_temporary_var (type);
2624 add_decl_expr (decl);
2626 finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,
2627 tf_warning_or_error));
2632 /* `build_vec_init' returns tree structure that performs
2633 initialization of a vector of aggregate types.
2635 BASE is a reference to the vector, of ARRAY_TYPE.
2636 MAXINDEX is the maximum index of the array (one less than the
2637 number of elements). It is only used if
2638 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2640 INIT is the (possibly NULL) initializer.
2642 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All
2643 elements in the array are value-initialized.
2645 FROM_ARRAY is 0 if we should init everything with INIT
2646 (i.e., every element initialized from INIT).
2647 FROM_ARRAY is 1 if we should index into INIT in parallel
2648 with initialization of DECL.
2649 FROM_ARRAY is 2 if we should index into INIT in parallel,
2650 but use assignment instead of initialization. */
2653 build_vec_init (tree base, tree maxindex, tree init,
2654 bool explicit_value_init_p,
2655 int from_array, tsubst_flags_t complain)
2658 tree base2 = NULL_TREE;
2660 tree itype = NULL_TREE;
2662 /* The type of the array. */
2663 tree atype = TREE_TYPE (base);
2664 /* The type of an element in the array. */
2665 tree type = TREE_TYPE (atype);
2666 /* The element type reached after removing all outer array
2668 tree inner_elt_type;
2669 /* The type of a pointer to an element in the array. */
2674 tree try_block = NULL_TREE;
2675 int num_initialized_elts = 0;
2678 if (TYPE_DOMAIN (atype))
2679 maxindex = array_type_nelts (atype);
2681 if (maxindex == NULL_TREE || maxindex == error_mark_node)
2682 return error_mark_node;
2684 if (explicit_value_init_p)
2687 inner_elt_type = strip_array_types (atype);
2690 ? (!CLASS_TYPE_P (inner_elt_type)
2691 || !TYPE_HAS_COMPLEX_ASSIGN_REF (inner_elt_type))
2692 : !TYPE_NEEDS_CONSTRUCTING (type))
2693 && ((TREE_CODE (init) == CONSTRUCTOR
2694 /* Don't do this if the CONSTRUCTOR might contain something
2695 that might throw and require us to clean up. */
2696 && (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))
2697 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
2700 /* Do non-default initialization of POD arrays resulting from
2701 brace-enclosed initializers. In this case, digest_init and
2702 store_constructor will handle the semantics for us. */
2704 stmt_expr = build2 (INIT_EXPR, atype, base, init);
2708 maxindex = cp_convert (ptrdiff_type_node, maxindex);
2709 ptype = build_pointer_type (type);
2710 size = size_in_bytes (type);
2711 if (TREE_CODE (TREE_TYPE (base)) == ARRAY_TYPE)
2712 base = cp_convert (ptype, decay_conversion (base));
2714 /* The code we are generating looks like:
2718 ptrdiff_t iterator = maxindex;
2720 for (; iterator != -1; --iterator) {
2721 ... initialize *t1 ...
2725 ... destroy elements that were constructed ...
2730 We can omit the try and catch blocks if we know that the
2731 initialization will never throw an exception, or if the array
2732 elements do not have destructors. We can omit the loop completely if
2733 the elements of the array do not have constructors.
2735 We actually wrap the entire body of the above in a STMT_EXPR, for
2738 When copying from array to another, when the array elements have
2739 only trivial copy constructors, we should use __builtin_memcpy
2740 rather than generating a loop. That way, we could take advantage
2741 of whatever cleverness the back end has for dealing with copies
2742 of blocks of memory. */
2744 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
2745 destroy_temps = stmts_are_full_exprs_p ();
2746 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2747 rval = get_temp_regvar (ptype, base);
2748 base = get_temp_regvar (ptype, rval);
2749 iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2751 /* Protect the entire array initialization so that we can destroy
2752 the partially constructed array if an exception is thrown.
2753 But don't do this if we're assigning. */
2754 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2757 try_block = begin_try_block ();
2760 if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
2762 /* Do non-default initialization of non-POD arrays resulting from
2763 brace-enclosed initializers. */
2764 unsigned HOST_WIDE_INT idx;
2768 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
2770 tree baseref = build1 (INDIRECT_REF, type, base);
2772 num_initialized_elts++;
2774 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2775 if (MAYBE_CLASS_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
2776 finish_expr_stmt (build_aggr_init (baseref, elt, 0, complain));
2778 finish_expr_stmt (cp_build_modify_expr (baseref, NOP_EXPR,
2780 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2782 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
2784 finish_expr_stmt (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
2788 /* Clear out INIT so that we don't get confused below. */
2791 else if (from_array)
2793 /* If initializing one array from another, initialize element by
2794 element. We rely upon the below calls the do argument
2798 base2 = decay_conversion (init);
2799 itype = TREE_TYPE (base2);
2800 base2 = get_temp_regvar (itype, base2);
2801 itype = TREE_TYPE (itype);
2803 else if (TYPE_LANG_SPECIFIC (type)
2804 && TYPE_NEEDS_CONSTRUCTING (type)
2805 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2807 if (complain & tf_error)
2808 error ("initializer ends prematurely");
2809 return error_mark_node;
2813 /* Now, default-initialize any remaining elements. We don't need to
2814 do that if a) the type does not need constructing, or b) we've
2815 already initialized all the elements.
2817 We do need to keep going if we're copying an array. */
2820 || ((TYPE_NEEDS_CONSTRUCTING (type) || explicit_value_init_p)
2821 && ! (host_integerp (maxindex, 0)
2822 && (num_initialized_elts
2823 == tree_low_cst (maxindex, 0) + 1))))
2825 /* If the ITERATOR is equal to -1, then we don't have to loop;
2826 we've already initialized all the elements. */
2831 for_stmt = begin_for_stmt ();
2832 finish_for_init_stmt (for_stmt);
2833 finish_for_cond (build2 (NE_EXPR, boolean_type_node, iterator,
2834 build_int_cst (TREE_TYPE (iterator), -1)),
2836 finish_for_expr (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
2840 to = build1 (INDIRECT_REF, type, base);
2847 from = build1 (INDIRECT_REF, itype, base2);
2851 if (from_array == 2)
2852 elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
2854 else if (TYPE_NEEDS_CONSTRUCTING (type))
2855 elt_init = build_aggr_init (to, from, 0, complain);
2857 elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
2862 else if (TREE_CODE (type) == ARRAY_TYPE)
2866 ("cannot initialize multi-dimensional array with initializer");
2867 elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
2869 explicit_value_init_p,
2872 else if (explicit_value_init_p)
2873 elt_init = build2 (INIT_EXPR, type, to,
2874 build_value_init (type));
2877 gcc_assert (TYPE_NEEDS_CONSTRUCTING (type));
2878 elt_init = build_aggr_init (to, init, 0, complain);
2881 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2882 finish_expr_stmt (elt_init);
2883 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2885 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
2888 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base2, 0,
2891 finish_for_stmt (for_stmt);
2894 /* Make sure to cleanup any partially constructed elements. */
2895 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2899 tree m = cp_build_binary_op (input_location,
2900 MINUS_EXPR, maxindex, iterator,
2903 /* Flatten multi-dimensional array since build_vec_delete only
2904 expects one-dimensional array. */
2905 if (TREE_CODE (type) == ARRAY_TYPE)
2906 m = cp_build_binary_op (input_location,
2908 array_type_nelts_total (type),
2911 finish_cleanup_try_block (try_block);
2912 e = build_vec_delete_1 (rval, m,
2913 inner_elt_type, sfk_base_destructor,
2914 /*use_global_delete=*/0);
2915 finish_cleanup (e, try_block);
2918 /* The value of the array initialization is the array itself, RVAL
2919 is a pointer to the first element. */
2920 finish_stmt_expr_expr (rval, stmt_expr);
2922 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
2924 /* Now convert make the result have the correct type. */
2925 atype = build_pointer_type (atype);
2926 stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
2927 stmt_expr = cp_build_indirect_ref (stmt_expr, NULL, complain);
2929 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
2933 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
2937 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags)
2943 case sfk_complete_destructor:
2944 name = complete_dtor_identifier;
2947 case sfk_base_destructor:
2948 name = base_dtor_identifier;
2951 case sfk_deleting_destructor:
2952 name = deleting_dtor_identifier;
2958 fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
2959 return build_new_method_call (exp, fn,
2961 /*conversion_path=*/NULL_TREE,
2964 tf_warning_or_error);
2967 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2968 ADDR is an expression which yields the store to be destroyed.
2969 AUTO_DELETE is the name of the destructor to call, i.e., either
2970 sfk_complete_destructor, sfk_base_destructor, or
2971 sfk_deleting_destructor.
2973 FLAGS is the logical disjunction of zero or more LOOKUP_
2974 flags. See cp-tree.h for more info. */
2977 build_delete (tree type, tree addr, special_function_kind auto_delete,
2978 int flags, int use_global_delete)
2982 if (addr == error_mark_node)
2983 return error_mark_node;
2985 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
2986 set to `error_mark_node' before it gets properly cleaned up. */
2987 if (type == error_mark_node)
2988 return error_mark_node;
2990 type = TYPE_MAIN_VARIANT (type);
2992 if (TREE_CODE (type) == POINTER_TYPE)
2994 bool complete_p = true;
2996 type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
2997 if (TREE_CODE (type) == ARRAY_TYPE)
3000 /* We don't want to warn about delete of void*, only other
3001 incomplete types. Deleting other incomplete types
3002 invokes undefined behavior, but it is not ill-formed, so
3003 compile to something that would even do The Right Thing
3004 (TM) should the type have a trivial dtor and no delete
3006 if (!VOID_TYPE_P (type))
3008 complete_type (type);
3009 if (!COMPLETE_TYPE_P (type))
3011 if (warning (0, "possible problem detected in invocation of "
3012 "delete operator:"))
3014 cxx_incomplete_type_diagnostic (addr, type, DK_WARNING);
3015 inform (input_location, "neither the destructor nor the class-specific "
3016 "operator delete will be called, even if they are "
3017 "declared when the class is defined.");
3022 if (VOID_TYPE_P (type) || !complete_p || !MAYBE_CLASS_TYPE_P (type))
3023 /* Call the builtin operator delete. */
3024 return build_builtin_delete_call (addr);
3025 if (TREE_SIDE_EFFECTS (addr))
3026 addr = save_expr (addr);
3028 /* Throw away const and volatile on target type of addr. */
3029 addr = convert_force (build_pointer_type (type), addr, 0);
3031 else if (TREE_CODE (type) == ARRAY_TYPE)
3035 if (TYPE_DOMAIN (type) == NULL_TREE)
3037 error ("unknown array size in delete");
3038 return error_mark_node;
3040 return build_vec_delete (addr, array_type_nelts (type),
3041 auto_delete, use_global_delete);
3045 /* Don't check PROTECT here; leave that decision to the
3046 destructor. If the destructor is accessible, call it,
3047 else report error. */
3048 addr = cp_build_unary_op (ADDR_EXPR, addr, 0, tf_warning_or_error);
3049 if (TREE_SIDE_EFFECTS (addr))
3050 addr = save_expr (addr);
3052 addr = convert_force (build_pointer_type (type), addr, 0);
3055 gcc_assert (MAYBE_CLASS_TYPE_P (type));
3057 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
3059 if (auto_delete != sfk_deleting_destructor)
3060 return void_zero_node;
3062 return build_op_delete_call (DELETE_EXPR, addr,
3063 cxx_sizeof_nowarn (type),
3065 /*placement=*/NULL_TREE,
3066 /*alloc_fn=*/NULL_TREE);
3070 tree head = NULL_TREE;
3071 tree do_delete = NULL_TREE;
3074 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
3075 lazily_declare_fn (sfk_destructor, type);
3077 /* For `::delete x', we must not use the deleting destructor
3078 since then we would not be sure to get the global `operator
3080 if (use_global_delete && auto_delete == sfk_deleting_destructor)
3082 /* We will use ADDR multiple times so we must save it. */
3083 addr = save_expr (addr);
3084 head = get_target_expr (build_headof (addr));
3085 /* Delete the object. */
3086 do_delete = build_builtin_delete_call (head);
3087 /* Otherwise, treat this like a complete object destructor
3089 auto_delete = sfk_complete_destructor;
3091 /* If the destructor is non-virtual, there is no deleting
3092 variant. Instead, we must explicitly call the appropriate
3093 `operator delete' here. */
3094 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
3095 && auto_delete == sfk_deleting_destructor)
3097 /* We will use ADDR multiple times so we must save it. */
3098 addr = save_expr (addr);
3099 /* Build the call. */
3100 do_delete = build_op_delete_call (DELETE_EXPR,
3102 cxx_sizeof_nowarn (type),
3104 /*placement=*/NULL_TREE,
3105 /*alloc_fn=*/NULL_TREE);
3106 /* Call the complete object destructor. */
3107 auto_delete = sfk_complete_destructor;
3109 else if (auto_delete == sfk_deleting_destructor
3110 && TYPE_GETS_REG_DELETE (type))
3112 /* Make sure we have access to the member op delete, even though
3113 we'll actually be calling it from the destructor. */
3114 build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
3116 /*placement=*/NULL_TREE,
3117 /*alloc_fn=*/NULL_TREE);
3120 expr = build_dtor_call (cp_build_indirect_ref (addr, NULL,
3121 tf_warning_or_error),
3122 auto_delete, flags);
3124 expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
3126 /* We need to calculate this before the dtor changes the vptr. */
3128 expr = build2 (COMPOUND_EXPR, void_type_node, head, expr);
3130 if (flags & LOOKUP_DESTRUCTOR)
3131 /* Explicit destructor call; don't check for null pointer. */
3132 ifexp = integer_one_node;
3134 /* Handle deleting a null pointer. */
3135 ifexp = fold (cp_build_binary_op (input_location,
3136 NE_EXPR, addr, integer_zero_node,
3137 tf_warning_or_error));
3139 if (ifexp != integer_one_node)
3140 expr = build3 (COND_EXPR, void_type_node,
3141 ifexp, expr, void_zero_node);
3147 /* At the beginning of a destructor, push cleanups that will call the
3148 destructors for our base classes and members.
3150 Called from begin_destructor_body. */
3153 push_base_cleanups (void)
3155 tree binfo, base_binfo;
3159 VEC(tree,gc) *vbases;
3161 /* Run destructors for all virtual baseclasses. */
3162 if (CLASSTYPE_VBASECLASSES (current_class_type))
3164 tree cond = (condition_conversion
3165 (build2 (BIT_AND_EXPR, integer_type_node,
3166 current_in_charge_parm,
3167 integer_two_node)));
3169 /* The CLASSTYPE_VBASECLASSES vector is in initialization
3170 order, which is also the right order for pushing cleanups. */
3171 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
3172 VEC_iterate (tree, vbases, i, base_binfo); i++)
3174 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
3176 expr = build_special_member_call (current_class_ref,
3177 base_dtor_identifier,
3181 | LOOKUP_NONVIRTUAL),
3182 tf_warning_or_error);
3183 expr = build3 (COND_EXPR, void_type_node, cond,
3184 expr, void_zero_node);
3185 finish_decl_cleanup (NULL_TREE, expr);
3190 /* Take care of the remaining baseclasses. */
3191 for (binfo = TYPE_BINFO (current_class_type), i = 0;
3192 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
3194 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
3195 || BINFO_VIRTUAL_P (base_binfo))
3198 expr = build_special_member_call (current_class_ref,
3199 base_dtor_identifier,
3200 NULL_TREE, base_binfo,
3201 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
3202 tf_warning_or_error);
3203 finish_decl_cleanup (NULL_TREE, expr);
3206 for (member = TYPE_FIELDS (current_class_type); member;
3207 member = TREE_CHAIN (member))
3209 if (TREE_TYPE (member) == error_mark_node
3210 || TREE_CODE (member) != FIELD_DECL
3211 || DECL_ARTIFICIAL (member))
3213 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
3215 tree this_member = (build_class_member_access_expr
3216 (current_class_ref, member,
3217 /*access_path=*/NULL_TREE,
3218 /*preserve_reference=*/false,
3219 tf_warning_or_error));
3220 tree this_type = TREE_TYPE (member);
3221 expr = build_delete (this_type, this_member,
3222 sfk_complete_destructor,
3223 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
3225 finish_decl_cleanup (NULL_TREE, expr);
3230 /* Build a C++ vector delete expression.
3231 MAXINDEX is the number of elements to be deleted.
3232 ELT_SIZE is the nominal size of each element in the vector.
3233 BASE is the expression that should yield the store to be deleted.
3234 This function expands (or synthesizes) these calls itself.
3235 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3237 This also calls delete for virtual baseclasses of elements of the vector.
3239 Update: MAXINDEX is no longer needed. The size can be extracted from the
3240 start of the vector for pointers, and from the type for arrays. We still
3241 use MAXINDEX for arrays because it happens to already have one of the
3242 values we'd have to extract. (We could use MAXINDEX with pointers to
3243 confirm the size, and trap if the numbers differ; not clear that it'd
3244 be worth bothering.) */
3247 build_vec_delete (tree base, tree maxindex,
3248 special_function_kind auto_delete_vec, int use_global_delete)
3252 tree base_init = NULL_TREE;
3254 type = TREE_TYPE (base);
3256 if (TREE_CODE (type) == POINTER_TYPE)
3258 /* Step back one from start of vector, and read dimension. */
3260 tree size_ptr_type = build_pointer_type (sizetype);
3262 if (TREE_SIDE_EFFECTS (base))
3264 base_init = get_target_expr (base);
3265 base = TARGET_EXPR_SLOT (base_init);
3267 type = strip_array_types (TREE_TYPE (type));
3268 cookie_addr = fold_build1 (NEGATE_EXPR, sizetype, TYPE_SIZE_UNIT (sizetype));
3269 cookie_addr = build2 (POINTER_PLUS_EXPR,
3271 fold_convert (size_ptr_type, base),
3273 maxindex = cp_build_indirect_ref (cookie_addr, NULL, tf_warning_or_error);
3275 else if (TREE_CODE (type) == ARRAY_TYPE)
3277 /* Get the total number of things in the array, maxindex is a
3279 maxindex = array_type_nelts_total (type);
3280 type = strip_array_types (type);
3281 base = cp_build_unary_op (ADDR_EXPR, base, 1, tf_warning_or_error);
3282 if (TREE_SIDE_EFFECTS (base))
3284 base_init = get_target_expr (base);
3285 base = TARGET_EXPR_SLOT (base_init);
3290 if (base != error_mark_node)
3291 error ("type to vector delete is neither pointer or array type");
3292 return error_mark_node;
3295 rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3298 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);