1 /* Handle initialization things in C++.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* High-level class interface. */
27 #include "coretypes.h"
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);
57 static void diagnose_uninitialized_cst_or_ref_member_1 (tree, tree, bool);
59 /* We are about to generate some complex initialization code.
60 Conceptually, it is all a single expression. However, we may want
61 to include conditionals, loops, and other such statement-level
62 constructs. Therefore, we build the initialization code inside a
63 statement-expression. This function starts such an expression.
64 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
65 pass them back to finish_init_stmts when the expression is
69 begin_init_stmts (tree *stmt_expr_p, tree *compound_stmt_p)
71 bool is_global = !building_stmt_tree ();
73 *stmt_expr_p = begin_stmt_expr ();
74 *compound_stmt_p = begin_compound_stmt (BCS_NO_SCOPE);
79 /* Finish out the statement-expression begun by the previous call to
80 begin_init_stmts. Returns the statement-expression itself. */
83 finish_init_stmts (bool is_global, tree stmt_expr, tree compound_stmt)
85 finish_compound_stmt (compound_stmt);
87 stmt_expr = finish_stmt_expr (stmt_expr, true);
89 gcc_assert (!building_stmt_tree () == is_global);
96 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
97 which we want to initialize the vtable pointer for, DATA is
98 TREE_LIST whose TREE_VALUE is the this ptr expression. */
101 dfs_initialize_vtbl_ptrs (tree binfo, void *data)
103 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
104 return dfs_skip_bases;
106 if (!BINFO_PRIMARY_P (binfo) || BINFO_VIRTUAL_P (binfo))
108 tree base_ptr = TREE_VALUE ((tree) data);
110 base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /*nonnull=*/1);
112 expand_virtual_init (binfo, base_ptr);
118 /* Initialize all the vtable pointers in the object pointed to by
122 initialize_vtbl_ptrs (tree addr)
127 type = TREE_TYPE (TREE_TYPE (addr));
128 list = build_tree_list (type, addr);
130 /* Walk through the hierarchy, initializing the vptr in each base
131 class. We do these in pre-order because we can't find the virtual
132 bases for a class until we've initialized the vtbl for that
134 dfs_walk_once (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs, NULL, list);
137 /* Return an expression for the zero-initialization of an object with
138 type T. This expression will either be a constant (in the case
139 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
140 aggregate), or NULL (in the case that T does not require
141 initialization). In either case, the value can be used as
142 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
143 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
144 is the number of elements in the array. If STATIC_STORAGE_P is
145 TRUE, initializers are only generated for entities for which
146 zero-initialization does not simply mean filling the storage with
150 build_zero_init (tree type, tree nelts, bool static_storage_p)
152 tree init = NULL_TREE;
156 To zero-initialize an object of type T means:
158 -- if T is a scalar type, the storage is set to the value of zero
161 -- if T is a non-union class type, the storage for each nonstatic
162 data member and each base-class subobject is zero-initialized.
164 -- if T is a union type, the storage for its first data member is
167 -- if T is an array type, the storage for each element is
170 -- if T is a reference type, no initialization is performed. */
172 gcc_assert (nelts == NULL_TREE || TREE_CODE (nelts) == INTEGER_CST);
174 if (type == error_mark_node)
176 else if (static_storage_p && zero_init_p (type))
177 /* In order to save space, we do not explicitly build initializers
178 for items that do not need them. GCC's semantics are that
179 items with static storage duration that are not otherwise
180 initialized are initialized to zero. */
182 else if (SCALAR_TYPE_P (type))
183 init = convert (type, integer_zero_node);
184 else if (CLASS_TYPE_P (type))
187 VEC(constructor_elt,gc) *v = NULL;
189 /* Iterate over the fields, building initializations. */
190 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
192 if (TREE_CODE (field) != FIELD_DECL)
195 /* Note that for class types there will be FIELD_DECLs
196 corresponding to base classes as well. Thus, iterating
197 over TYPE_FIELDs will result in correct initialization of
198 all of the subobjects. */
199 if (!static_storage_p || !zero_init_p (TREE_TYPE (field)))
201 tree value = build_zero_init (TREE_TYPE (field),
205 CONSTRUCTOR_APPEND_ELT(v, field, value);
208 /* For unions, only the first field is initialized. */
209 if (TREE_CODE (type) == UNION_TYPE)
213 /* Build a constructor to contain the initializations. */
214 init = build_constructor (type, v);
216 else if (TREE_CODE (type) == ARRAY_TYPE)
219 VEC(constructor_elt,gc) *v = NULL;
221 /* Iterate over the array elements, building initializations. */
223 max_index = fold_build2_loc (input_location,
224 MINUS_EXPR, TREE_TYPE (nelts),
225 nelts, integer_one_node);
227 max_index = array_type_nelts (type);
229 /* If we have an error_mark here, we should just return error mark
230 as we don't know the size of the array yet. */
231 if (max_index == error_mark_node)
232 return error_mark_node;
233 gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
235 /* A zero-sized array, which is accepted as an extension, will
236 have an upper bound of -1. */
237 if (!tree_int_cst_equal (max_index, integer_minus_one_node))
241 v = VEC_alloc (constructor_elt, gc, 1);
242 ce = VEC_quick_push (constructor_elt, v, NULL);
244 /* If this is a one element array, we just use a regular init. */
245 if (tree_int_cst_equal (size_zero_node, max_index))
246 ce->index = size_zero_node;
248 ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
251 ce->value = build_zero_init (TREE_TYPE (type),
256 /* Build a constructor to contain the initializations. */
257 init = build_constructor (type, v);
259 else if (TREE_CODE (type) == VECTOR_TYPE)
260 init = fold_convert (type, integer_zero_node);
262 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
264 /* In all cases, the initializer is a constant. */
266 TREE_CONSTANT (init) = 1;
271 /* Return a suitable initializer for value-initializing an object of type
272 TYPE, as described in [dcl.init]. */
275 build_value_init (tree type)
279 To value-initialize an object of type T means:
281 - if T is a class type (clause 9) with a user-provided constructor
282 (12.1), then the default constructor for T is called (and the
283 initialization is ill-formed if T has no accessible default
286 - if T is a non-union class type without a user-provided constructor,
287 then every non-static data member and base-class component of T is
288 value-initialized;92)
290 - if T is an array type, then each element is value-initialized;
292 - otherwise, the object is zero-initialized.
294 A program that calls for default-initialization or
295 value-initialization of an entity of reference type is ill-formed.
297 92) Value-initialization for such a class object may be implemented by
298 zero-initializing the object and then calling the default
301 if (CLASS_TYPE_P (type))
303 if (type_has_user_provided_constructor (type))
304 return build_aggr_init_expr
306 build_special_member_call (NULL_TREE, complete_ctor_identifier,
307 NULL, type, LOOKUP_NORMAL,
308 tf_warning_or_error));
309 else if (TREE_CODE (type) != UNION_TYPE && TYPE_NEEDS_CONSTRUCTING (type))
311 /* This is a class that needs constructing, but doesn't have
312 a user-provided constructor. So we need to zero-initialize
313 the object and then call the implicitly defined ctor.
314 This will be handled in simplify_aggr_init_expr. */
315 tree ctor = build_special_member_call
316 (NULL_TREE, complete_ctor_identifier,
317 NULL, type, LOOKUP_NORMAL, tf_warning_or_error);
319 ctor = build_aggr_init_expr (type, ctor);
320 AGGR_INIT_ZERO_FIRST (ctor) = 1;
324 return build_value_init_noctor (type);
327 /* Like build_value_init, but don't call the constructor for TYPE. Used
328 for base initializers. */
331 build_value_init_noctor (tree type)
333 if (CLASS_TYPE_P (type))
335 gcc_assert (!TYPE_NEEDS_CONSTRUCTING (type));
337 if (TREE_CODE (type) != UNION_TYPE)
340 VEC(constructor_elt,gc) *v = NULL;
342 /* Iterate over the fields, building initializations. */
343 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
347 if (TREE_CODE (field) != FIELD_DECL)
350 ftype = TREE_TYPE (field);
352 if (TREE_CODE (ftype) == REFERENCE_TYPE)
353 error ("value-initialization of reference");
355 /* We could skip vfields and fields of types with
356 user-defined constructors, but I think that won't improve
357 performance at all; it should be simpler in general just
358 to zero out the entire object than try to only zero the
359 bits that actually need it. */
361 /* Note that for class types there will be FIELD_DECLs
362 corresponding to base classes as well. Thus, iterating
363 over TYPE_FIELDs will result in correct initialization of
364 all of the subobjects. */
365 value = build_value_init (ftype);
368 CONSTRUCTOR_APPEND_ELT(v, field, value);
371 /* Build a constructor to contain the zero- initializations. */
372 return build_constructor (type, v);
375 else if (TREE_CODE (type) == ARRAY_TYPE)
377 VEC(constructor_elt,gc) *v = NULL;
379 /* Iterate over the array elements, building initializations. */
380 tree max_index = array_type_nelts (type);
382 /* If we have an error_mark here, we should just return error mark
383 as we don't know the size of the array yet. */
384 if (max_index == error_mark_node)
385 return error_mark_node;
386 gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
388 /* A zero-sized array, which is accepted as an extension, will
389 have an upper bound of -1. */
390 if (!tree_int_cst_equal (max_index, integer_minus_one_node))
394 v = VEC_alloc (constructor_elt, gc, 1);
395 ce = VEC_quick_push (constructor_elt, v, NULL);
397 /* If this is a one element array, we just use a regular init. */
398 if (tree_int_cst_equal (size_zero_node, max_index))
399 ce->index = size_zero_node;
401 ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
404 ce->value = build_value_init (TREE_TYPE (type));
406 /* The gimplifier can't deal with a RANGE_EXPR of TARGET_EXPRs. */
407 gcc_assert (TREE_CODE (ce->value) != TARGET_EXPR
408 && TREE_CODE (ce->value) != AGGR_INIT_EXPR);
411 /* Build a constructor to contain the initializations. */
412 return build_constructor (type, v);
415 return build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
418 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
419 arguments. If TREE_LIST is void_type_node, an empty initializer
420 list was given; if NULL_TREE no initializer was given. */
423 perform_member_init (tree member, tree init)
426 tree type = TREE_TYPE (member);
428 /* Effective C++ rule 12 requires that all data members be
430 if (warn_ecpp && init == NULL_TREE && TREE_CODE (type) != ARRAY_TYPE)
431 warning_at (DECL_SOURCE_LOCATION (current_function_decl), OPT_Weffc__,
432 "%qD should be initialized in the member initialization list",
435 /* Get an lvalue for the data member. */
436 decl = build_class_member_access_expr (current_class_ref, member,
437 /*access_path=*/NULL_TREE,
438 /*preserve_reference=*/true,
439 tf_warning_or_error);
440 if (decl == error_mark_node)
443 if (init == void_type_node)
445 /* mem() means value-initialization. */
446 if (TREE_CODE (type) == ARRAY_TYPE)
448 init = build_vec_init (decl, NULL_TREE, NULL_TREE,
449 /*explicit_value_init_p=*/true,
451 tf_warning_or_error);
452 finish_expr_stmt (init);
456 if (TREE_CODE (type) == REFERENCE_TYPE)
457 permerror (DECL_SOURCE_LOCATION (current_function_decl),
458 "value-initialization of %q#D, which has reference type",
462 init = build2 (INIT_EXPR, type, decl, build_value_init (type));
463 finish_expr_stmt (init);
467 /* Deal with this here, as we will get confused if we try to call the
468 assignment op for an anonymous union. This can happen in a
469 synthesized copy constructor. */
470 else if (ANON_AGGR_TYPE_P (type))
474 init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init));
475 finish_expr_stmt (init);
478 else if (TYPE_NEEDS_CONSTRUCTING (type))
480 if (init != NULL_TREE
481 && TREE_CODE (type) == ARRAY_TYPE
482 && TREE_CHAIN (init) == NULL_TREE
483 && TREE_CODE (TREE_TYPE (TREE_VALUE (init))) == ARRAY_TYPE)
485 /* Initialization of one array from another. */
486 finish_expr_stmt (build_vec_init (decl, NULL_TREE, TREE_VALUE (init),
487 /*explicit_value_init_p=*/false,
489 tf_warning_or_error));
493 if (CP_TYPE_CONST_P (type)
495 && !type_has_user_provided_default_constructor (type))
496 /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
497 vtable; still give this diagnostic. */
498 permerror (DECL_SOURCE_LOCATION (current_function_decl),
499 "uninitialized member %qD with %<const%> type %qT",
501 finish_expr_stmt (build_aggr_init (decl, init, 0,
502 tf_warning_or_error));
507 if (init == NULL_TREE)
510 /* member traversal: note it leaves init NULL */
511 if (TREE_CODE (type) == REFERENCE_TYPE)
512 permerror (DECL_SOURCE_LOCATION (current_function_decl),
513 "uninitialized reference member %qD",
515 else if (CP_TYPE_CONST_P (type))
516 permerror (DECL_SOURCE_LOCATION (current_function_decl),
517 "uninitialized member %qD with %<const%> type %qT",
520 core_type = strip_array_types (type);
521 if (CLASS_TYPE_P (core_type)
522 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)
523 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)))
524 diagnose_uninitialized_cst_or_ref_member (core_type,
528 else if (TREE_CODE (init) == TREE_LIST)
529 /* There was an explicit member initialization. Do some work
531 init = build_x_compound_expr_from_list (init, "member initializer");
534 finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,
535 tf_warning_or_error));
538 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
542 expr = build_class_member_access_expr (current_class_ref, member,
543 /*access_path=*/NULL_TREE,
544 /*preserve_reference=*/false,
545 tf_warning_or_error);
546 expr = build_delete (type, expr, sfk_complete_destructor,
547 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
549 if (expr != error_mark_node)
550 finish_eh_cleanup (expr);
554 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
555 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
558 build_field_list (tree t, tree list, int *uses_unions_p)
564 /* Note whether or not T is a union. */
565 if (TREE_CODE (t) == UNION_TYPE)
568 for (fields = TYPE_FIELDS (t); fields; fields = TREE_CHAIN (fields))
570 /* Skip CONST_DECLs for enumeration constants and so forth. */
571 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
574 /* Keep track of whether or not any fields are unions. */
575 if (TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
578 /* For an anonymous struct or union, we must recursively
579 consider the fields of the anonymous type. They can be
580 directly initialized from the constructor. */
581 if (ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
583 /* Add this field itself. Synthesized copy constructors
584 initialize the entire aggregate. */
585 list = tree_cons (fields, NULL_TREE, list);
586 /* And now add the fields in the anonymous aggregate. */
587 list = build_field_list (TREE_TYPE (fields), list,
590 /* Add this field. */
591 else if (DECL_NAME (fields))
592 list = tree_cons (fields, NULL_TREE, list);
598 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
599 a FIELD_DECL or BINFO in T that needs initialization. The
600 TREE_VALUE gives the initializer, or list of initializer arguments.
602 Return a TREE_LIST containing all of the initializations required
603 for T, in the order in which they should be performed. The output
604 list has the same format as the input. */
607 sort_mem_initializers (tree t, tree mem_inits)
610 tree base, binfo, base_binfo;
613 VEC(tree,gc) *vbases;
617 /* Build up a list of initializations. The TREE_PURPOSE of entry
618 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
619 TREE_VALUE will be the constructor arguments, or NULL if no
620 explicit initialization was provided. */
621 sorted_inits = NULL_TREE;
623 /* Process the virtual bases. */
624 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
625 VEC_iterate (tree, vbases, i, base); i++)
626 sorted_inits = tree_cons (base, NULL_TREE, sorted_inits);
628 /* Process the direct bases. */
629 for (binfo = TYPE_BINFO (t), i = 0;
630 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
631 if (!BINFO_VIRTUAL_P (base_binfo))
632 sorted_inits = tree_cons (base_binfo, NULL_TREE, sorted_inits);
634 /* Process the non-static data members. */
635 sorted_inits = build_field_list (t, sorted_inits, &uses_unions_p);
636 /* Reverse the entire list of initializations, so that they are in
637 the order that they will actually be performed. */
638 sorted_inits = nreverse (sorted_inits);
640 /* If the user presented the initializers in an order different from
641 that in which they will actually occur, we issue a warning. Keep
642 track of the next subobject which can be explicitly initialized
643 without issuing a warning. */
644 next_subobject = sorted_inits;
646 /* Go through the explicit initializers, filling in TREE_PURPOSE in
648 for (init = mem_inits; init; init = TREE_CHAIN (init))
653 subobject = TREE_PURPOSE (init);
655 /* If the explicit initializers are in sorted order, then
656 SUBOBJECT will be NEXT_SUBOBJECT, or something following
658 for (subobject_init = next_subobject;
660 subobject_init = TREE_CHAIN (subobject_init))
661 if (TREE_PURPOSE (subobject_init) == subobject)
664 /* Issue a warning if the explicit initializer order does not
665 match that which will actually occur.
666 ??? Are all these on the correct lines? */
667 if (warn_reorder && !subobject_init)
669 if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)
670 warning (OPT_Wreorder, "%q+D will be initialized after",
671 TREE_PURPOSE (next_subobject));
673 warning (OPT_Wreorder, "base %qT will be initialized after",
674 TREE_PURPOSE (next_subobject));
675 if (TREE_CODE (subobject) == FIELD_DECL)
676 warning (OPT_Wreorder, " %q+#D", subobject);
678 warning (OPT_Wreorder, " base %qT", subobject);
679 warning_at (DECL_SOURCE_LOCATION (current_function_decl),
680 OPT_Wreorder, " when initialized here");
683 /* Look again, from the beginning of the list. */
686 subobject_init = sorted_inits;
687 while (TREE_PURPOSE (subobject_init) != subobject)
688 subobject_init = TREE_CHAIN (subobject_init);
691 /* It is invalid to initialize the same subobject more than
693 if (TREE_VALUE (subobject_init))
695 if (TREE_CODE (subobject) == FIELD_DECL)
696 error_at (DECL_SOURCE_LOCATION (current_function_decl),
697 "multiple initializations given for %qD",
700 error_at (DECL_SOURCE_LOCATION (current_function_decl),
701 "multiple initializations given for base %qT",
705 /* Record the initialization. */
706 TREE_VALUE (subobject_init) = TREE_VALUE (init);
707 next_subobject = subobject_init;
712 If a ctor-initializer specifies more than one mem-initializer for
713 multiple members of the same union (including members of
714 anonymous unions), the ctor-initializer is ill-formed. */
717 tree last_field = NULL_TREE;
718 for (init = sorted_inits; init; init = TREE_CHAIN (init))
724 /* Skip uninitialized members and base classes. */
725 if (!TREE_VALUE (init)
726 || TREE_CODE (TREE_PURPOSE (init)) != FIELD_DECL)
728 /* See if this field is a member of a union, or a member of a
729 structure contained in a union, etc. */
730 field = TREE_PURPOSE (init);
731 for (field_type = DECL_CONTEXT (field);
732 !same_type_p (field_type, t);
733 field_type = TYPE_CONTEXT (field_type))
734 if (TREE_CODE (field_type) == UNION_TYPE)
736 /* If this field is not a member of a union, skip it. */
737 if (TREE_CODE (field_type) != UNION_TYPE)
740 /* It's only an error if we have two initializers for the same
748 /* See if LAST_FIELD and the field initialized by INIT are
749 members of the same union. If so, there's a problem,
750 unless they're actually members of the same structure
751 which is itself a member of a union. For example, given:
753 union { struct { int i; int j; }; };
755 initializing both `i' and `j' makes sense. */
756 field_type = DECL_CONTEXT (field);
760 tree last_field_type;
762 last_field_type = DECL_CONTEXT (last_field);
765 if (same_type_p (last_field_type, field_type))
767 if (TREE_CODE (field_type) == UNION_TYPE)
768 error_at (DECL_SOURCE_LOCATION (current_function_decl),
769 "initializations for multiple members of %qT",
775 if (same_type_p (last_field_type, t))
778 last_field_type = TYPE_CONTEXT (last_field_type);
781 /* If we've reached the outermost class, then we're
783 if (same_type_p (field_type, t))
786 field_type = TYPE_CONTEXT (field_type);
797 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
798 is a TREE_LIST giving the explicit mem-initializer-list for the
799 constructor. The TREE_PURPOSE of each entry is a subobject (a
800 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
801 is a TREE_LIST giving the arguments to the constructor or
802 void_type_node for an empty list of arguments. */
805 emit_mem_initializers (tree mem_inits)
807 /* We will already have issued an error message about the fact that
808 the type is incomplete. */
809 if (!COMPLETE_TYPE_P (current_class_type))
812 /* Sort the mem-initializers into the order in which the
813 initializations should be performed. */
814 mem_inits = sort_mem_initializers (current_class_type, mem_inits);
816 in_base_initializer = 1;
818 /* Initialize base classes. */
820 && TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)
822 tree subobject = TREE_PURPOSE (mem_inits);
823 tree arguments = TREE_VALUE (mem_inits);
825 /* If these initializations are taking place in a copy constructor,
826 the base class should probably be explicitly initialized if there
827 is a user-defined constructor in the base class (other than the
828 default constructor, which will be called anyway). */
829 if (extra_warnings && !arguments
830 && DECL_COPY_CONSTRUCTOR_P (current_function_decl)
831 && type_has_user_nondefault_constructor (BINFO_TYPE (subobject)))
832 warning_at (DECL_SOURCE_LOCATION (current_function_decl), OPT_Wextra,
833 "base class %q#T should be explicitly initialized in the "
835 BINFO_TYPE (subobject));
837 /* Initialize the base. */
838 if (BINFO_VIRTUAL_P (subobject))
839 construct_virtual_base (subobject, arguments);
844 base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
846 expand_aggr_init_1 (subobject, NULL_TREE,
847 cp_build_indirect_ref (base_addr, RO_NULL,
848 tf_warning_or_error),
851 tf_warning_or_error);
852 expand_cleanup_for_base (subobject, NULL_TREE);
855 mem_inits = TREE_CHAIN (mem_inits);
857 in_base_initializer = 0;
859 /* Initialize the vptrs. */
860 initialize_vtbl_ptrs (current_class_ptr);
862 /* Initialize the data members. */
865 perform_member_init (TREE_PURPOSE (mem_inits),
866 TREE_VALUE (mem_inits));
867 mem_inits = TREE_CHAIN (mem_inits);
871 /* Returns the address of the vtable (i.e., the value that should be
872 assigned to the vptr) for BINFO. */
875 build_vtbl_address (tree binfo)
877 tree binfo_for = binfo;
880 if (BINFO_VPTR_INDEX (binfo) && BINFO_VIRTUAL_P (binfo))
881 /* If this is a virtual primary base, then the vtable we want to store
882 is that for the base this is being used as the primary base of. We
883 can't simply skip the initialization, because we may be expanding the
884 inits of a subobject constructor where the virtual base layout
886 while (BINFO_PRIMARY_P (binfo_for))
887 binfo_for = BINFO_INHERITANCE_CHAIN (binfo_for);
889 /* Figure out what vtable BINFO's vtable is based on, and mark it as
891 vtbl = get_vtbl_decl_for_binfo (binfo_for);
892 TREE_USED (vtbl) = 1;
894 /* Now compute the address to use when initializing the vptr. */
895 vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
896 if (TREE_CODE (vtbl) == VAR_DECL)
897 vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
902 /* This code sets up the virtual function tables appropriate for
903 the pointer DECL. It is a one-ply initialization.
905 BINFO is the exact type that DECL is supposed to be. In
906 multiple inheritance, this might mean "C's A" if C : A, B. */
909 expand_virtual_init (tree binfo, tree decl)
914 /* Compute the initializer for vptr. */
915 vtbl = build_vtbl_address (binfo);
917 /* We may get this vptr from a VTT, if this is a subobject
918 constructor or subobject destructor. */
919 vtt_index = BINFO_VPTR_INDEX (binfo);
925 /* Compute the value to use, when there's a VTT. */
926 vtt_parm = current_vtt_parm;
927 vtbl2 = build2 (POINTER_PLUS_EXPR,
928 TREE_TYPE (vtt_parm),
931 vtbl2 = cp_build_indirect_ref (vtbl2, RO_NULL, tf_warning_or_error);
932 vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
934 /* The actual initializer is the VTT value only in the subobject
935 constructor. In maybe_clone_body we'll substitute NULL for
936 the vtt_parm in the case of the non-subobject constructor. */
937 vtbl = build3 (COND_EXPR,
939 build2 (EQ_EXPR, boolean_type_node,
940 current_in_charge_parm, integer_zero_node),
945 /* Compute the location of the vtpr. */
946 vtbl_ptr = build_vfield_ref (cp_build_indirect_ref (decl, RO_NULL,
947 tf_warning_or_error),
949 gcc_assert (vtbl_ptr != error_mark_node);
951 /* Assign the vtable to the vptr. */
952 vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
953 finish_expr_stmt (cp_build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl,
954 tf_warning_or_error));
957 /* If an exception is thrown in a constructor, those base classes already
958 constructed must be destroyed. This function creates the cleanup
959 for BINFO, which has just been constructed. If FLAG is non-NULL,
960 it is a DECL which is nonzero when this base needs to be
964 expand_cleanup_for_base (tree binfo, tree flag)
968 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
971 /* Call the destructor. */
972 expr = build_special_member_call (current_class_ref,
973 base_dtor_identifier,
976 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
977 tf_warning_or_error);
979 expr = fold_build3_loc (input_location,
980 COND_EXPR, void_type_node,
981 c_common_truthvalue_conversion (input_location, flag),
982 expr, integer_zero_node);
984 finish_eh_cleanup (expr);
987 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
991 construct_virtual_base (tree vbase, tree arguments)
997 /* If there are virtual base classes with destructors, we need to
998 emit cleanups to destroy them if an exception is thrown during
999 the construction process. These exception regions (i.e., the
1000 period during which the cleanups must occur) begin from the time
1001 the construction is complete to the end of the function. If we
1002 create a conditional block in which to initialize the
1003 base-classes, then the cleanup region for the virtual base begins
1004 inside a block, and ends outside of that block. This situation
1005 confuses the sjlj exception-handling code. Therefore, we do not
1006 create a single conditional block, but one for each
1007 initialization. (That way the cleanup regions always begin
1008 in the outer block.) We trust the back end to figure out
1009 that the FLAG will not change across initializations, and
1010 avoid doing multiple tests. */
1011 flag = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
1012 inner_if_stmt = begin_if_stmt ();
1013 finish_if_stmt_cond (flag, inner_if_stmt);
1015 /* Compute the location of the virtual base. If we're
1016 constructing virtual bases, then we must be the most derived
1017 class. Therefore, we don't have to look up the virtual base;
1018 we already know where it is. */
1019 exp = convert_to_base_statically (current_class_ref, vbase);
1021 expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
1022 LOOKUP_COMPLAIN, tf_warning_or_error);
1023 finish_then_clause (inner_if_stmt);
1024 finish_if_stmt (inner_if_stmt);
1026 expand_cleanup_for_base (vbase, flag);
1029 /* Find the context in which this FIELD can be initialized. */
1032 initializing_context (tree field)
1034 tree t = DECL_CONTEXT (field);
1036 /* Anonymous union members can be initialized in the first enclosing
1037 non-anonymous union context. */
1038 while (t && ANON_AGGR_TYPE_P (t))
1039 t = TYPE_CONTEXT (t);
1043 /* Function to give error message if member initialization specification
1044 is erroneous. FIELD is the member we decided to initialize.
1045 TYPE is the type for which the initialization is being performed.
1046 FIELD must be a member of TYPE.
1048 MEMBER_NAME is the name of the member. */
1051 member_init_ok_or_else (tree field, tree type, tree member_name)
1053 if (field == error_mark_node)
1057 error ("class %qT does not have any field named %qD", type,
1061 if (TREE_CODE (field) == VAR_DECL)
1063 error ("%q#D is a static data member; it can only be "
1064 "initialized at its definition",
1068 if (TREE_CODE (field) != FIELD_DECL)
1070 error ("%q#D is not a non-static data member of %qT",
1074 if (initializing_context (field) != type)
1076 error ("class %qT does not have any field named %qD", type,
1084 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1085 is a _TYPE node or TYPE_DECL which names a base for that type.
1086 Check the validity of NAME, and return either the base _TYPE, base
1087 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
1088 NULL_TREE and issue a diagnostic.
1090 An old style unnamed direct single base construction is permitted,
1091 where NAME is NULL. */
1094 expand_member_init (tree name)
1099 if (!current_class_ref)
1104 /* This is an obsolete unnamed base class initializer. The
1105 parser will already have warned about its use. */
1106 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type)))
1109 error ("unnamed initializer for %qT, which has no base classes",
1110 current_class_type);
1113 basetype = BINFO_TYPE
1114 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0));
1117 error ("unnamed initializer for %qT, which uses multiple inheritance",
1118 current_class_type);
1122 else if (TYPE_P (name))
1124 basetype = TYPE_MAIN_VARIANT (name);
1125 name = TYPE_NAME (name);
1127 else if (TREE_CODE (name) == TYPE_DECL)
1128 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
1130 basetype = NULL_TREE;
1139 if (current_template_parms)
1142 class_binfo = TYPE_BINFO (current_class_type);
1143 direct_binfo = NULL_TREE;
1144 virtual_binfo = NULL_TREE;
1146 /* Look for a direct base. */
1147 for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i)
1148 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo), basetype))
1151 /* Look for a virtual base -- unless the direct base is itself
1153 if (!direct_binfo || !BINFO_VIRTUAL_P (direct_binfo))
1154 virtual_binfo = binfo_for_vbase (basetype, current_class_type);
1156 /* [class.base.init]
1158 If a mem-initializer-id is ambiguous because it designates
1159 both a direct non-virtual base class and an inherited virtual
1160 base class, the mem-initializer is ill-formed. */
1161 if (direct_binfo && virtual_binfo)
1163 error ("%qD is both a direct base and an indirect virtual base",
1168 if (!direct_binfo && !virtual_binfo)
1170 if (CLASSTYPE_VBASECLASSES (current_class_type))
1171 error ("type %qT is not a direct or virtual base of %qT",
1172 basetype, current_class_type);
1174 error ("type %qT is not a direct base of %qT",
1175 basetype, current_class_type);
1179 return direct_binfo ? direct_binfo : virtual_binfo;
1183 if (TREE_CODE (name) == IDENTIFIER_NODE)
1184 field = lookup_field (current_class_type, name, 1, false);
1188 if (member_init_ok_or_else (field, current_class_type, name))
1195 /* This is like `expand_member_init', only it stores one aggregate
1198 INIT comes in two flavors: it is either a value which
1199 is to be stored in EXP, or it is a parameter list
1200 to go to a constructor, which will operate on EXP.
1201 If INIT is not a parameter list for a constructor, then set
1202 LOOKUP_ONLYCONVERTING.
1203 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1204 the initializer, if FLAGS is 0, then it is the (init) form.
1205 If `init' is a CONSTRUCTOR, then we emit a warning message,
1206 explaining that such initializations are invalid.
1208 If INIT resolves to a CALL_EXPR which happens to return
1209 something of the type we are looking for, then we know
1210 that we can safely use that call to perform the
1213 The virtual function table pointer cannot be set up here, because
1214 we do not really know its type.
1216 This never calls operator=().
1218 When initializing, nothing is CONST.
1220 A default copy constructor may have to be used to perform the
1223 A constructor or a conversion operator may have to be used to
1224 perform the initialization, but not both, as it would be ambiguous. */
1227 build_aggr_init (tree exp, tree init, int flags, tsubst_flags_t complain)
1232 tree type = TREE_TYPE (exp);
1233 int was_const = TREE_READONLY (exp);
1234 int was_volatile = TREE_THIS_VOLATILE (exp);
1237 if (init == error_mark_node)
1238 return error_mark_node;
1240 TREE_READONLY (exp) = 0;
1241 TREE_THIS_VOLATILE (exp) = 0;
1243 if (init && TREE_CODE (init) != TREE_LIST)
1244 flags |= LOOKUP_ONLYCONVERTING;
1246 if (TREE_CODE (type) == ARRAY_TYPE)
1250 /* An array may not be initialized use the parenthesized
1251 initialization form -- unless the initializer is "()". */
1252 if (init && TREE_CODE (init) == TREE_LIST)
1254 if (complain & tf_error)
1255 error ("bad array initializer");
1256 return error_mark_node;
1258 /* Must arrange to initialize each element of EXP
1259 from elements of INIT. */
1260 itype = init ? TREE_TYPE (init) : NULL_TREE;
1261 if (cv_qualified_p (type))
1262 TREE_TYPE (exp) = cv_unqualified (type);
1263 if (itype && cv_qualified_p (itype))
1264 TREE_TYPE (init) = cv_unqualified (itype);
1265 stmt_expr = build_vec_init (exp, NULL_TREE, init,
1266 /*explicit_value_init_p=*/false,
1267 itype && same_type_p (TREE_TYPE (init),
1270 TREE_READONLY (exp) = was_const;
1271 TREE_THIS_VOLATILE (exp) = was_volatile;
1272 TREE_TYPE (exp) = type;
1274 TREE_TYPE (init) = itype;
1278 if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1279 /* Just know that we've seen something for this node. */
1280 TREE_USED (exp) = 1;
1282 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
1283 destroy_temps = stmts_are_full_exprs_p ();
1284 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
1285 expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1286 init, LOOKUP_NORMAL|flags, complain);
1287 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
1288 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
1289 TREE_READONLY (exp) = was_const;
1290 TREE_THIS_VOLATILE (exp) = was_volatile;
1296 expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags,
1297 tsubst_flags_t complain)
1299 tree type = TREE_TYPE (exp);
1302 /* It fails because there may not be a constructor which takes
1303 its own type as the first (or only parameter), but which does
1304 take other types via a conversion. So, if the thing initializing
1305 the expression is a unit element of type X, first try X(X&),
1306 followed by initialization by X. If neither of these work
1307 out, then look hard. */
1309 VEC(tree,gc) *parms;
1311 if (init && TREE_CODE (init) != TREE_LIST
1312 && (flags & LOOKUP_ONLYCONVERTING))
1314 /* Base subobjects should only get direct-initialization. */
1315 gcc_assert (true_exp == exp);
1317 if (flags & DIRECT_BIND)
1318 /* Do nothing. We hit this in two cases: Reference initialization,
1319 where we aren't initializing a real variable, so we don't want
1320 to run a new constructor; and catching an exception, where we
1321 have already built up the constructor call so we could wrap it
1322 in an exception region. */;
1323 else if (BRACE_ENCLOSED_INITIALIZER_P (init)
1324 && CP_AGGREGATE_TYPE_P (type))
1326 /* A brace-enclosed initializer for an aggregate. */
1327 init = digest_init (type, init);
1330 init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1332 if (TREE_CODE (init) == MUST_NOT_THROW_EXPR)
1333 /* We need to protect the initialization of a catch parm with a
1334 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1335 around the TARGET_EXPR for the copy constructor. See
1336 initialize_handler_parm. */
1338 TREE_OPERAND (init, 0) = build2 (INIT_EXPR, TREE_TYPE (exp), exp,
1339 TREE_OPERAND (init, 0));
1340 TREE_TYPE (init) = void_type_node;
1343 init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1344 TREE_SIDE_EFFECTS (init) = 1;
1345 finish_expr_stmt (init);
1349 if (init == NULL_TREE)
1351 else if (TREE_CODE (init) == TREE_LIST && !TREE_TYPE (init))
1353 parms = make_tree_vector ();
1354 for (; init != NULL_TREE; init = TREE_CHAIN (init))
1355 VEC_safe_push (tree, gc, parms, TREE_VALUE (init));
1358 parms = make_tree_vector_single (init);
1360 if (true_exp == exp)
1361 ctor_name = complete_ctor_identifier;
1363 ctor_name = base_ctor_identifier;
1365 rval = build_special_member_call (exp, ctor_name, &parms, binfo, flags,
1369 release_tree_vector (parms);
1371 if (TREE_SIDE_EFFECTS (rval))
1372 finish_expr_stmt (convert_to_void (rval, NULL, complain));
1375 /* This function is responsible for initializing EXP with INIT
1378 BINFO is the binfo of the type for who we are performing the
1379 initialization. For example, if W is a virtual base class of A and B,
1381 If we are initializing B, then W must contain B's W vtable, whereas
1382 were we initializing C, W must contain C's W vtable.
1384 TRUE_EXP is nonzero if it is the true expression being initialized.
1385 In this case, it may be EXP, or may just contain EXP. The reason we
1386 need this is because if EXP is a base element of TRUE_EXP, we
1387 don't necessarily know by looking at EXP where its virtual
1388 baseclass fields should really be pointing. But we do know
1389 from TRUE_EXP. In constructors, we don't know anything about
1390 the value being initialized.
1392 FLAGS is just passed to `build_new_method_call'. See that function
1393 for its description. */
1396 expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags,
1397 tsubst_flags_t complain)
1399 tree type = TREE_TYPE (exp);
1401 gcc_assert (init != error_mark_node && type != error_mark_node);
1402 gcc_assert (building_stmt_tree ());
1404 /* Use a function returning the desired type to initialize EXP for us.
1405 If the function is a constructor, and its first argument is
1406 NULL_TREE, know that it was meant for us--just slide exp on
1407 in and expand the constructor. Constructors now come
1410 if (init && TREE_CODE (exp) == VAR_DECL
1411 && COMPOUND_LITERAL_P (init))
1413 /* If store_init_value returns NULL_TREE, the INIT has been
1414 recorded as the DECL_INITIAL for EXP. That means there's
1415 nothing more we have to do. */
1416 init = store_init_value (exp, init, flags);
1418 finish_expr_stmt (init);
1422 /* If an explicit -- but empty -- initializer list was present,
1423 that's value-initialization. */
1424 if (init == void_type_node)
1426 /* If there's a user-provided constructor, we just call that. */
1427 if (type_has_user_provided_constructor (type))
1428 /* Fall through. */;
1429 /* If there isn't, but we still need to call the constructor,
1430 zero out the object first. */
1431 else if (TYPE_NEEDS_CONSTRUCTING (type))
1433 init = build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
1434 init = build2 (INIT_EXPR, type, exp, init);
1435 finish_expr_stmt (init);
1436 /* And then call the constructor. */
1438 /* If we don't need to mess with the constructor at all,
1439 then just zero out the object and we're done. */
1442 init = build2 (INIT_EXPR, type, exp, build_value_init_noctor (type));
1443 finish_expr_stmt (init);
1449 /* We know that expand_default_init can handle everything we want
1451 expand_default_init (binfo, true_exp, exp, init, flags, complain);
1454 /* Report an error if TYPE is not a user-defined, class type. If
1455 OR_ELSE is nonzero, give an error message. */
1458 is_class_type (tree type, int or_else)
1460 if (type == error_mark_node)
1463 if (! CLASS_TYPE_P (type))
1466 error ("%qT is not a class type", type);
1473 get_type_value (tree name)
1475 if (name == error_mark_node)
1478 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1479 return IDENTIFIER_TYPE_VALUE (name);
1484 /* Build a reference to a member of an aggregate. This is not a C++
1485 `&', but really something which can have its address taken, and
1486 then act as a pointer to member, for example TYPE :: FIELD can have
1487 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
1488 this expression is the operand of "&".
1490 @@ Prints out lousy diagnostics for operator <typename>
1493 @@ This function should be rewritten and placed in search.c. */
1496 build_offset_ref (tree type, tree member, bool address_p)
1499 tree basebinfo = NULL_TREE;
1501 /* class templates can come in as TEMPLATE_DECLs here. */
1502 if (TREE_CODE (member) == TEMPLATE_DECL)
1505 if (dependent_type_p (type) || type_dependent_expression_p (member))
1506 return build_qualified_name (NULL_TREE, type, member,
1507 /*template_p=*/false);
1509 gcc_assert (TYPE_P (type));
1510 if (! is_class_type (type, 1))
1511 return error_mark_node;
1513 gcc_assert (DECL_P (member) || BASELINK_P (member));
1514 /* Callers should call mark_used before this point. */
1515 gcc_assert (!DECL_P (member) || TREE_USED (member));
1517 if (!COMPLETE_TYPE_P (complete_type (type))
1518 && !TYPE_BEING_DEFINED (type))
1520 error ("incomplete type %qT does not have member %qD", type, member);
1521 return error_mark_node;
1524 /* Entities other than non-static members need no further
1526 if (TREE_CODE (member) == TYPE_DECL)
1528 if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1529 return convert_from_reference (member);
1531 if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1533 error ("invalid pointer to bit-field %qD", member);
1534 return error_mark_node;
1537 /* Set up BASEBINFO for member lookup. */
1538 decl = maybe_dummy_object (type, &basebinfo);
1540 /* A lot of this logic is now handled in lookup_member. */
1541 if (BASELINK_P (member))
1543 /* Go from the TREE_BASELINK to the member function info. */
1544 tree t = BASELINK_FUNCTIONS (member);
1546 if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1548 /* Get rid of a potential OVERLOAD around it. */
1549 t = OVL_CURRENT (t);
1551 /* Unique functions are handled easily. */
1553 /* For non-static member of base class, we need a special rule
1554 for access checking [class.protected]:
1556 If the access is to form a pointer to member, the
1557 nested-name-specifier shall name the derived class
1558 (or any class derived from that class). */
1559 if (address_p && DECL_P (t)
1560 && DECL_NONSTATIC_MEMBER_P (t))
1561 perform_or_defer_access_check (TYPE_BINFO (type), t, t);
1563 perform_or_defer_access_check (basebinfo, t, t);
1565 if (DECL_STATIC_FUNCTION_P (t))
1570 TREE_TYPE (member) = unknown_type_node;
1572 else if (address_p && TREE_CODE (member) == FIELD_DECL)
1573 /* We need additional test besides the one in
1574 check_accessibility_of_qualified_id in case it is
1575 a pointer to non-static member. */
1576 perform_or_defer_access_check (TYPE_BINFO (type), member, member);
1580 /* If MEMBER is non-static, then the program has fallen afoul of
1583 An id-expression that denotes a nonstatic data member or
1584 nonstatic member function of a class can only be used:
1586 -- as part of a class member access (_expr.ref_) in which the
1587 object-expression refers to the member's class or a class
1588 derived from that class, or
1590 -- to form a pointer to member (_expr.unary.op_), or
1592 -- in the body of a nonstatic member function of that class or
1593 of a class derived from that class (_class.mfct.nonstatic_), or
1595 -- in a mem-initializer for a constructor for that class or for
1596 a class derived from that class (_class.base.init_). */
1597 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1599 /* Build a representation of the qualified name suitable
1600 for use as the operand to "&" -- even though the "&" is
1601 not actually present. */
1602 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1603 /* In Microsoft mode, treat a non-static member function as if
1604 it were a pointer-to-member. */
1605 if (flag_ms_extensions)
1607 PTRMEM_OK_P (member) = 1;
1608 return cp_build_unary_op (ADDR_EXPR, member, 0,
1609 tf_warning_or_error);
1611 error ("invalid use of non-static member function %qD",
1612 TREE_OPERAND (member, 1));
1613 return error_mark_node;
1615 else if (TREE_CODE (member) == FIELD_DECL)
1617 error ("invalid use of non-static data member %qD", member);
1618 return error_mark_node;
1623 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1624 PTRMEM_OK_P (member) = 1;
1628 /* If DECL is a scalar enumeration constant or variable with a
1629 constant initializer, return the initializer (or, its initializers,
1630 recursively); otherwise, return DECL. If INTEGRAL_P, the
1631 initializer is only returned if DECL is an integral
1632 constant-expression. */
1635 constant_value_1 (tree decl, bool integral_p)
1637 while (TREE_CODE (decl) == CONST_DECL
1639 ? DECL_INTEGRAL_CONSTANT_VAR_P (decl)
1640 : (TREE_CODE (decl) == VAR_DECL
1641 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))))
1644 /* Static data members in template classes may have
1645 non-dependent initializers. References to such non-static
1646 data members are not value-dependent, so we must retrieve the
1647 initializer here. The DECL_INITIAL will have the right type,
1648 but will not have been folded because that would prevent us
1649 from performing all appropriate semantic checks at
1650 instantiation time. */
1651 if (DECL_CLASS_SCOPE_P (decl)
1652 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
1653 && uses_template_parms (CLASSTYPE_TI_ARGS
1654 (DECL_CONTEXT (decl))))
1656 ++processing_template_decl;
1657 init = fold_non_dependent_expr (DECL_INITIAL (decl));
1658 --processing_template_decl;
1662 /* If DECL is a static data member in a template
1663 specialization, we must instantiate it here. The
1664 initializer for the static data member is not processed
1665 until needed; we need it now. */
1667 init = DECL_INITIAL (decl);
1669 if (init == error_mark_node)
1671 if (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
1672 /* Treat the error as a constant to avoid cascading errors on
1673 excessively recursive template instantiation (c++/9335). */
1678 /* Initializers in templates are generally expanded during
1679 instantiation, so before that for const int i(2)
1680 INIT is a TREE_LIST with the actual initializer as
1682 if (processing_template_decl
1684 && TREE_CODE (init) == TREE_LIST
1685 && TREE_CHAIN (init) == NULL_TREE)
1686 init = TREE_VALUE (init);
1688 || !TREE_TYPE (init)
1690 ? !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (init))
1691 : (!TREE_CONSTANT (init)
1692 /* Do not return an aggregate constant (of which
1693 string literals are a special case), as we do not
1694 want to make inadvertent copies of such entities,
1695 and we must be sure that their addresses are the
1697 || TREE_CODE (init) == CONSTRUCTOR
1698 || TREE_CODE (init) == STRING_CST)))
1700 decl = unshare_expr (init);
1705 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1706 constant of integral or enumeration type, then return that value.
1707 These are those variables permitted in constant expressions by
1711 integral_constant_value (tree decl)
1713 return constant_value_1 (decl, /*integral_p=*/true);
1716 /* A more relaxed version of integral_constant_value, used by the
1717 common C/C++ code and by the C++ front end for optimization
1721 decl_constant_value (tree decl)
1723 return constant_value_1 (decl,
1724 /*integral_p=*/processing_template_decl);
1727 /* Common subroutines of build_new and build_vec_delete. */
1729 /* Call the global __builtin_delete to delete ADDR. */
1732 build_builtin_delete_call (tree addr)
1734 mark_used (global_delete_fndecl);
1735 return build_call_n (global_delete_fndecl, 1, addr);
1738 /* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
1739 the type of the object being allocated; otherwise, it's just TYPE.
1740 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
1741 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
1742 a vector of arguments to be provided as arguments to a placement
1743 new operator. This routine performs no semantic checks; it just
1744 creates and returns a NEW_EXPR. */
1747 build_raw_new_expr (VEC(tree,gc) *placement, tree type, tree nelts,
1748 VEC(tree,gc) *init, int use_global_new)
1753 /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR.
1754 If INIT is not NULL, then we want to store VOID_ZERO_NODE. This
1755 permits us to distinguish the case of a missing initializer "new
1756 int" from an empty initializer "new int()". */
1758 init_list = NULL_TREE;
1759 else if (VEC_empty (tree, init))
1760 init_list = void_zero_node;
1762 init_list = build_tree_list_vec (init);
1764 new_expr = build4 (NEW_EXPR, build_pointer_type (type),
1765 build_tree_list_vec (placement), type, nelts,
1767 NEW_EXPR_USE_GLOBAL (new_expr) = use_global_new;
1768 TREE_SIDE_EFFECTS (new_expr) = 1;
1773 /* Diagnose uninitialized const members or reference members of type
1774 TYPE. USING_NEW is used to disambiguate the diagnostic between a
1775 new expression without a new-initializer and a declaration */
1778 diagnose_uninitialized_cst_or_ref_member_1 (tree type, tree origin,
1783 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1787 if (TREE_CODE (field) != FIELD_DECL)
1790 field_type = strip_array_types (TREE_TYPE (field));
1792 if (TREE_CODE (field_type) == REFERENCE_TYPE)
1795 error ("uninitialized reference member in %q#T using %<new%>",
1798 error ("uninitialized reference member in %q#T", origin);
1799 inform (DECL_SOURCE_LOCATION (field),
1800 "%qD should be initialized", field);
1803 if (CP_TYPE_CONST_P (field_type))
1806 error ("uninitialized const member in %q#T using %<new%>",
1809 error ("uninitialized const member in %q#T", origin);
1810 inform (DECL_SOURCE_LOCATION (field),
1811 "%qD should be initialized", field);
1814 if (CLASS_TYPE_P (field_type))
1815 diagnose_uninitialized_cst_or_ref_member_1 (field_type,
1821 diagnose_uninitialized_cst_or_ref_member (tree type, bool using_new)
1823 diagnose_uninitialized_cst_or_ref_member_1 (type, type, using_new);
1826 /* Generate code for a new-expression, including calling the "operator
1827 new" function, initializing the object, and, if an exception occurs
1828 during construction, cleaning up. The arguments are as for
1829 build_raw_new_expr. This may change PLACEMENT and INIT. */
1832 build_new_1 (VEC(tree,gc) **placement, tree type, tree nelts,
1833 VEC(tree,gc) **init, bool globally_qualified_p,
1834 tsubst_flags_t complain)
1837 /* True iff this is a call to "operator new[]" instead of just
1839 bool array_p = false;
1840 /* If ARRAY_P is true, the element type of the array. This is never
1841 an ARRAY_TYPE; for something like "new int[3][4]", the
1842 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
1845 /* The type of the new-expression. (This type is always a pointer
1848 tree non_const_pointer_type;
1849 tree outer_nelts = NULL_TREE;
1850 tree alloc_call, alloc_expr;
1851 /* The address returned by the call to "operator new". This node is
1852 a VAR_DECL and is therefore reusable. */
1855 tree cookie_expr, init_expr;
1856 int nothrow, check_new;
1857 int use_java_new = 0;
1858 /* If non-NULL, the number of extra bytes to allocate at the
1859 beginning of the storage allocated for an array-new expression in
1860 order to store the number of elements. */
1861 tree cookie_size = NULL_TREE;
1862 tree placement_first;
1863 tree placement_expr = NULL_TREE;
1864 /* True if the function we are calling is a placement allocation
1866 bool placement_allocation_fn_p;
1867 /* True if the storage must be initialized, either by a constructor
1868 or due to an explicit new-initializer. */
1869 bool is_initialized;
1870 /* The address of the thing allocated, not including any cookie. In
1871 particular, if an array cookie is in use, DATA_ADDR is the
1872 address of the first array element. This node is a VAR_DECL, and
1873 is therefore reusable. */
1875 tree init_preeval_expr = NULL_TREE;
1879 outer_nelts = nelts;
1882 else if (TREE_CODE (type) == ARRAY_TYPE)
1885 nelts = array_type_nelts_top (type);
1886 outer_nelts = nelts;
1887 type = TREE_TYPE (type);
1890 /* If our base type is an array, then make sure we know how many elements
1892 for (elt_type = type;
1893 TREE_CODE (elt_type) == ARRAY_TYPE;
1894 elt_type = TREE_TYPE (elt_type))
1895 nelts = cp_build_binary_op (input_location,
1897 array_type_nelts_top (elt_type),
1900 if (TREE_CODE (elt_type) == VOID_TYPE)
1902 if (complain & tf_error)
1903 error ("invalid type %<void%> for new");
1904 return error_mark_node;
1907 if (abstract_virtuals_error (NULL_TREE, elt_type))
1908 return error_mark_node;
1910 is_initialized = (TYPE_NEEDS_CONSTRUCTING (elt_type) || *init != NULL);
1912 if (*init == NULL && !type_has_user_provided_constructor (elt_type))
1914 bool uninitialized_error = false;
1915 /* A program that calls for default-initialization [...] of an
1916 entity of reference type is ill-formed. */
1917 if (CLASSTYPE_REF_FIELDS_NEED_INIT (elt_type))
1918 uninitialized_error = true;
1920 /* A new-expression that creates an object of type T initializes
1921 that object as follows:
1922 - If the new-initializer is omitted:
1923 -- If T is a (possibly cv-qualified) non-POD class type
1924 (or array thereof), the object is default-initialized (8.5).
1926 -- Otherwise, the object created has indeterminate
1927 value. If T is a const-qualified type, or a (possibly
1928 cv-qualified) POD class type (or array thereof)
1929 containing (directly or indirectly) a member of
1930 const-qualified type, the program is ill-formed; */
1932 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (elt_type))
1933 uninitialized_error = true;
1935 if (uninitialized_error)
1937 if (complain & tf_error)
1938 diagnose_uninitialized_cst_or_ref_member (elt_type,
1940 return error_mark_node;
1944 if (CP_TYPE_CONST_P (elt_type) && *init == NULL
1945 && !type_has_user_provided_default_constructor (elt_type))
1947 if (complain & tf_error)
1948 error ("uninitialized const in %<new%> of %q#T", elt_type);
1949 return error_mark_node;
1952 size = size_in_bytes (elt_type);
1954 size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
1956 alloc_fn = NULL_TREE;
1958 /* If PLACEMENT is a single simple pointer type not passed by
1959 reference, prepare to capture it in a temporary variable. Do
1960 this now, since PLACEMENT will change in the calls below. */
1961 placement_first = NULL_TREE;
1962 if (VEC_length (tree, *placement) == 1
1963 && (TREE_CODE (TREE_TYPE (VEC_index (tree, *placement, 0)))
1965 placement_first = VEC_index (tree, *placement, 0);
1967 /* Allocate the object. */
1968 if (VEC_empty (tree, *placement) && TYPE_FOR_JAVA (elt_type))
1971 tree class_decl = build_java_class_ref (elt_type);
1972 static const char alloc_name[] = "_Jv_AllocObject";
1974 if (class_decl == error_mark_node)
1975 return error_mark_node;
1978 if (!get_global_value_if_present (get_identifier (alloc_name),
1981 if (complain & tf_error)
1982 error ("call to Java constructor with %qs undefined", alloc_name);
1983 return error_mark_node;
1985 else if (really_overloaded_fn (alloc_fn))
1987 if (complain & tf_error)
1988 error ("%qD should never be overloaded", alloc_fn);
1989 return error_mark_node;
1991 alloc_fn = OVL_CURRENT (alloc_fn);
1992 class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
1993 alloc_call = (cp_build_function_call
1995 build_tree_list (NULL_TREE, class_addr),
1998 else if (TYPE_FOR_JAVA (elt_type) && MAYBE_CLASS_TYPE_P (elt_type))
2000 error ("Java class %q#T object allocated using placement new", elt_type);
2001 return error_mark_node;
2008 fnname = ansi_opname (array_p ? VEC_NEW_EXPR : NEW_EXPR);
2010 if (!globally_qualified_p
2011 && CLASS_TYPE_P (elt_type)
2013 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
2014 : TYPE_HAS_NEW_OPERATOR (elt_type)))
2016 /* Use a class-specific operator new. */
2017 /* If a cookie is required, add some extra space. */
2018 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
2020 cookie_size = targetm.cxx.get_cookie_size (elt_type);
2021 size = size_binop (PLUS_EXPR, size, cookie_size);
2023 /* Create the argument list. */
2024 VEC_safe_insert (tree, gc, *placement, 0, size);
2025 /* Do name-lookup to find the appropriate operator. */
2026 fns = lookup_fnfields (elt_type, fnname, /*protect=*/2);
2027 if (fns == NULL_TREE)
2029 if (complain & tf_error)
2030 error ("no suitable %qD found in class %qT", fnname, elt_type);
2031 return error_mark_node;
2033 if (TREE_CODE (fns) == TREE_LIST)
2035 if (complain & tf_error)
2037 error ("request for member %qD is ambiguous", fnname);
2038 print_candidates (fns);
2040 return error_mark_node;
2042 alloc_call = build_new_method_call (build_dummy_object (elt_type),
2044 /*conversion_path=*/NULL_TREE,
2051 /* Use a global operator new. */
2052 /* See if a cookie might be required. */
2053 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
2054 cookie_size = targetm.cxx.get_cookie_size (elt_type);
2056 cookie_size = NULL_TREE;
2058 alloc_call = build_operator_new_call (fnname, placement,
2059 &size, &cookie_size,
2064 if (alloc_call == error_mark_node)
2065 return error_mark_node;
2067 gcc_assert (alloc_fn != NULL_TREE);
2069 /* If we found a simple case of PLACEMENT_EXPR above, then copy it
2070 into a temporary variable. */
2071 if (!processing_template_decl
2072 && placement_first != NULL_TREE
2073 && TREE_CODE (alloc_call) == CALL_EXPR
2074 && call_expr_nargs (alloc_call) == 2
2075 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 0))) == INTEGER_TYPE
2076 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 1))) == POINTER_TYPE)
2078 tree placement_arg = CALL_EXPR_ARG (alloc_call, 1);
2080 if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg)))
2081 || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg))))
2083 placement_expr = get_target_expr (placement_first);
2084 CALL_EXPR_ARG (alloc_call, 1)
2085 = convert (TREE_TYPE (placement_arg), placement_expr);
2089 /* In the simple case, we can stop now. */
2090 pointer_type = build_pointer_type (type);
2091 if (!cookie_size && !is_initialized)
2092 return build_nop (pointer_type, alloc_call);
2094 /* Store the result of the allocation call in a variable so that we can
2095 use it more than once. */
2096 alloc_expr = get_target_expr (alloc_call);
2097 alloc_node = TARGET_EXPR_SLOT (alloc_expr);
2099 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
2100 while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
2101 alloc_call = TREE_OPERAND (alloc_call, 1);
2103 /* Now, check to see if this function is actually a placement
2104 allocation function. This can happen even when PLACEMENT is NULL
2105 because we might have something like:
2107 struct S { void* operator new (size_t, int i = 0); };
2109 A call to `new S' will get this allocation function, even though
2110 there is no explicit placement argument. If there is more than
2111 one argument, or there are variable arguments, then this is a
2112 placement allocation function. */
2113 placement_allocation_fn_p
2114 = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
2115 || varargs_function_p (alloc_fn));
2117 /* Preevaluate the placement args so that we don't reevaluate them for a
2118 placement delete. */
2119 if (placement_allocation_fn_p)
2122 stabilize_call (alloc_call, &inits);
2124 alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
2128 /* unless an allocation function is declared with an empty excep-
2129 tion-specification (_except.spec_), throw(), it indicates failure to
2130 allocate storage by throwing a bad_alloc exception (clause _except_,
2131 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2132 cation function is declared with an empty exception-specification,
2133 throw(), it returns null to indicate failure to allocate storage and a
2134 non-null pointer otherwise.
2136 So check for a null exception spec on the op new we just called. */
2138 nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
2139 check_new = (flag_check_new || nothrow) && ! use_java_new;
2147 /* Adjust so we're pointing to the start of the object. */
2148 data_addr = build2 (POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
2149 alloc_node, cookie_size);
2151 /* Store the number of bytes allocated so that we can know how
2152 many elements to destroy later. We use the last sizeof
2153 (size_t) bytes to store the number of elements. */
2154 cookie_ptr = size_binop (MINUS_EXPR, cookie_size, size_in_bytes (sizetype));
2155 cookie_ptr = fold_build2_loc (input_location,
2156 POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
2157 alloc_node, cookie_ptr);
2158 size_ptr_type = build_pointer_type (sizetype);
2159 cookie_ptr = fold_convert (size_ptr_type, cookie_ptr);
2160 cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
2162 cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
2164 if (targetm.cxx.cookie_has_size ())
2166 /* Also store the element size. */
2167 cookie_ptr = build2 (POINTER_PLUS_EXPR, size_ptr_type, cookie_ptr,
2168 fold_build1_loc (input_location,
2169 NEGATE_EXPR, sizetype,
2170 size_in_bytes (sizetype)));
2172 cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
2173 cookie = build2 (MODIFY_EXPR, sizetype, cookie,
2174 size_in_bytes (elt_type));
2175 cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
2176 cookie, cookie_expr);
2181 cookie_expr = NULL_TREE;
2182 data_addr = alloc_node;
2185 /* Now use a pointer to the type we've actually allocated. */
2187 /* But we want to operate on a non-const version to start with,
2188 since we'll be modifying the elements. */
2189 non_const_pointer_type = build_pointer_type
2190 (cp_build_qualified_type (type, TYPE_QUALS (type) & ~TYPE_QUAL_CONST));
2192 data_addr = fold_convert (non_const_pointer_type, data_addr);
2193 /* Any further uses of alloc_node will want this type, too. */
2194 alloc_node = fold_convert (non_const_pointer_type, alloc_node);
2196 /* Now initialize the allocated object. Note that we preevaluate the
2197 initialization expression, apart from the actual constructor call or
2198 assignment--we do this because we want to delay the allocation as long
2199 as possible in order to minimize the size of the exception region for
2200 placement delete. */
2204 bool explicit_value_init_p = false;
2206 if (*init != NULL && VEC_empty (tree, *init))
2209 explicit_value_init_p = true;
2214 tree vecinit = NULL_TREE;
2215 if (*init && VEC_length (tree, *init) == 1
2216 && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *init, 0))
2217 && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *init, 0)))
2219 tree arraytype, domain;
2220 vecinit = VEC_index (tree, *init, 0);
2221 if (TREE_CONSTANT (nelts))
2222 domain = compute_array_index_type (NULL_TREE, nelts);
2226 if (CONSTRUCTOR_NELTS (vecinit) > 0)
2227 warning (0, "non-constant array size in new, unable to "
2228 "verify length of initializer-list");
2230 arraytype = build_cplus_array_type (type, domain);
2231 vecinit = digest_init (arraytype, vecinit);
2235 if (complain & tf_error)
2236 permerror (input_location, "ISO C++ forbids initialization in array new");
2238 return error_mark_node;
2239 vecinit = build_tree_list_vec (*init);
2242 = build_vec_init (data_addr,
2243 cp_build_binary_op (input_location,
2244 MINUS_EXPR, outer_nelts,
2248 explicit_value_init_p,
2252 /* An array initialization is stable because the initialization
2253 of each element is a full-expression, so the temporaries don't
2259 init_expr = cp_build_indirect_ref (data_addr, RO_NULL, complain);
2261 if (TYPE_NEEDS_CONSTRUCTING (type) && !explicit_value_init_p)
2263 init_expr = build_special_member_call (init_expr,
2264 complete_ctor_identifier,
2269 else if (explicit_value_init_p)
2271 /* Something like `new int()'. */
2272 init_expr = build2 (INIT_EXPR, type,
2273 init_expr, build_value_init (type));
2279 /* We are processing something like `new int (10)', which
2280 means allocate an int, and initialize it with 10. */
2282 ie = build_x_compound_expr_from_vec (*init, "new initializer");
2283 init_expr = cp_build_modify_expr (init_expr, INIT_EXPR, ie,
2286 stable = stabilize_init (init_expr, &init_preeval_expr);
2289 if (init_expr == error_mark_node)
2290 return error_mark_node;
2292 /* If any part of the object initialization terminates by throwing an
2293 exception and a suitable deallocation function can be found, the
2294 deallocation function is called to free the memory in which the
2295 object was being constructed, after which the exception continues
2296 to propagate in the context of the new-expression. If no
2297 unambiguous matching deallocation function can be found,
2298 propagating the exception does not cause the object's memory to be
2300 if (flag_exceptions && ! use_java_new)
2302 enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
2305 /* The Standard is unclear here, but the right thing to do
2306 is to use the same method for finding deallocation
2307 functions that we use for finding allocation functions. */
2308 cleanup = (build_op_delete_call
2312 globally_qualified_p,
2313 placement_allocation_fn_p ? alloc_call : NULL_TREE,
2319 /* This is much simpler if we were able to preevaluate all of
2320 the arguments to the constructor call. */
2322 /* CLEANUP is compiler-generated, so no diagnostics. */
2323 TREE_NO_WARNING (cleanup) = true;
2324 init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2325 init_expr, cleanup);
2326 /* Likewise, this try-catch is compiler-generated. */
2327 TREE_NO_WARNING (init_expr) = true;
2330 /* Ack! First we allocate the memory. Then we set our sentry
2331 variable to true, and expand a cleanup that deletes the
2332 memory if sentry is true. Then we run the constructor, and
2333 finally clear the sentry.
2335 We need to do this because we allocate the space first, so
2336 if there are any temporaries with cleanups in the
2337 constructor args and we weren't able to preevaluate them, we
2338 need this EH region to extend until end of full-expression
2339 to preserve nesting. */
2341 tree end, sentry, begin;
2343 begin = get_target_expr (boolean_true_node);
2344 CLEANUP_EH_ONLY (begin) = 1;
2346 sentry = TARGET_EXPR_SLOT (begin);
2348 /* CLEANUP is compiler-generated, so no diagnostics. */
2349 TREE_NO_WARNING (cleanup) = true;
2351 TARGET_EXPR_CLEANUP (begin)
2352 = build3 (COND_EXPR, void_type_node, sentry,
2353 cleanup, void_zero_node);
2355 end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2356 sentry, boolean_false_node);
2359 = build2 (COMPOUND_EXPR, void_type_node, begin,
2360 build2 (COMPOUND_EXPR, void_type_node, init_expr,
2362 /* Likewise, this is compiler-generated. */
2363 TREE_NO_WARNING (init_expr) = true;
2368 init_expr = NULL_TREE;
2370 /* Now build up the return value in reverse order. */
2375 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2377 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2379 if (rval == data_addr)
2380 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2381 and return the call (which doesn't need to be adjusted). */
2382 rval = TARGET_EXPR_INITIAL (alloc_expr);
2387 tree ifexp = cp_build_binary_op (input_location,
2388 NE_EXPR, alloc_node,
2391 rval = build_conditional_expr (ifexp, rval, alloc_node,
2395 /* Perform the allocation before anything else, so that ALLOC_NODE
2396 has been initialized before we start using it. */
2397 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2400 if (init_preeval_expr)
2401 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2403 /* A new-expression is never an lvalue. */
2404 gcc_assert (!lvalue_p (rval));
2406 return convert (pointer_type, rval);
2409 /* Generate a representation for a C++ "new" expression. *PLACEMENT
2410 is a vector of placement-new arguments (or NULL if none). If NELTS
2411 is NULL, TYPE is the type of the storage to be allocated. If NELTS
2412 is not NULL, then this is an array-new allocation; TYPE is the type
2413 of the elements in the array and NELTS is the number of elements in
2414 the array. *INIT, if non-NULL, is the initializer for the new
2415 object, or an empty vector to indicate an initializer of "()". If
2416 USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
2417 rather than just "new". This may change PLACEMENT and INIT. */
2420 build_new (VEC(tree,gc) **placement, tree type, tree nelts,
2421 VEC(tree,gc) **init, int use_global_new, tsubst_flags_t complain)
2424 VEC(tree,gc) *orig_placement = NULL;
2425 tree orig_nelts = NULL_TREE;
2426 VEC(tree,gc) *orig_init = NULL;
2428 if (type == error_mark_node)
2429 return error_mark_node;
2431 if (nelts == NULL_TREE && VEC_length (tree, *init) == 1)
2433 tree auto_node = type_uses_auto (type);
2434 if (auto_node && describable_type (VEC_index (tree, *init, 0)))
2435 type = do_auto_deduction (type, VEC_index (tree, *init, 0), auto_node);
2438 if (processing_template_decl)
2440 if (dependent_type_p (type)
2441 || any_type_dependent_arguments_p (*placement)
2442 || (nelts && type_dependent_expression_p (nelts))
2443 || any_type_dependent_arguments_p (*init))
2444 return build_raw_new_expr (*placement, type, nelts, *init,
2447 orig_placement = make_tree_vector_copy (*placement);
2449 orig_init = make_tree_vector_copy (*init);
2451 make_args_non_dependent (*placement);
2453 nelts = build_non_dependent_expr (nelts);
2454 make_args_non_dependent (*init);
2459 if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
2461 if (complain & tf_error)
2462 permerror (input_location, "size in array new must have integral type");
2464 return error_mark_node;
2466 nelts = mark_rvalue_use (nelts);
2467 nelts = cp_save_expr (cp_convert (sizetype, nelts));
2470 /* ``A reference cannot be created by the new operator. A reference
2471 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2472 returned by new.'' ARM 5.3.3 */
2473 if (TREE_CODE (type) == REFERENCE_TYPE)
2475 if (complain & tf_error)
2476 error ("new cannot be applied to a reference type");
2478 return error_mark_node;
2479 type = TREE_TYPE (type);
2482 if (TREE_CODE (type) == FUNCTION_TYPE)
2484 if (complain & tf_error)
2485 error ("new cannot be applied to a function type");
2486 return error_mark_node;
2489 /* The type allocated must be complete. If the new-type-id was
2490 "T[N]" then we are just checking that "T" is complete here, but
2491 that is equivalent, since the value of "N" doesn't matter. */
2492 if (!complete_type_or_else (type, NULL_TREE))
2493 return error_mark_node;
2495 rval = build_new_1 (placement, type, nelts, init, use_global_new, complain);
2496 if (rval == error_mark_node)
2497 return error_mark_node;
2499 if (processing_template_decl)
2501 tree ret = build_raw_new_expr (orig_placement, type, orig_nelts,
2502 orig_init, use_global_new);
2503 release_tree_vector (orig_placement);
2504 release_tree_vector (orig_init);
2508 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2509 rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
2510 TREE_NO_WARNING (rval) = 1;
2515 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2518 build_java_class_ref (tree type)
2520 tree name = NULL_TREE, class_decl;
2521 static tree CL_suffix = NULL_TREE;
2522 if (CL_suffix == NULL_TREE)
2523 CL_suffix = get_identifier("class$");
2524 if (jclass_node == NULL_TREE)
2526 jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2527 if (jclass_node == NULL_TREE)
2529 error ("call to Java constructor, while %<jclass%> undefined");
2530 return error_mark_node;
2532 jclass_node = TREE_TYPE (jclass_node);
2535 /* Mangle the class$ field. */
2538 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2539 if (DECL_NAME (field) == CL_suffix)
2541 mangle_decl (field);
2542 name = DECL_ASSEMBLER_NAME (field);
2547 error ("can't find %<class$%> in %qT", type);
2548 return error_mark_node;
2552 class_decl = IDENTIFIER_GLOBAL_VALUE (name);
2553 if (class_decl == NULL_TREE)
2555 class_decl = build_decl (input_location,
2556 VAR_DECL, name, TREE_TYPE (jclass_node));
2557 TREE_STATIC (class_decl) = 1;
2558 DECL_EXTERNAL (class_decl) = 1;
2559 TREE_PUBLIC (class_decl) = 1;
2560 DECL_ARTIFICIAL (class_decl) = 1;
2561 DECL_IGNORED_P (class_decl) = 1;
2562 pushdecl_top_level (class_decl);
2563 make_decl_rtl (class_decl);
2569 build_vec_delete_1 (tree base, tree maxindex, tree type,
2570 special_function_kind auto_delete_vec, int use_global_delete)
2573 tree ptype = build_pointer_type (type = complete_type (type));
2574 tree size_exp = size_in_bytes (type);
2576 /* Temporary variables used by the loop. */
2577 tree tbase, tbase_init;
2579 /* This is the body of the loop that implements the deletion of a
2580 single element, and moves temp variables to next elements. */
2583 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2586 /* This is the thing that governs what to do after the loop has run. */
2587 tree deallocate_expr = 0;
2589 /* This is the BIND_EXPR which holds the outermost iterator of the
2590 loop. It is convenient to set this variable up and test it before
2591 executing any other code in the loop.
2592 This is also the containing expression returned by this function. */
2593 tree controller = NULL_TREE;
2596 /* We should only have 1-D arrays here. */
2597 gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2599 if (! MAYBE_CLASS_TYPE_P (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2602 /* The below is short by the cookie size. */
2603 virtual_size = size_binop (MULT_EXPR, size_exp,
2604 convert (sizetype, maxindex));
2606 tbase = create_temporary_var (ptype);
2607 tbase_init = cp_build_modify_expr (tbase, NOP_EXPR,
2608 fold_build2_loc (input_location,
2609 POINTER_PLUS_EXPR, ptype,
2610 fold_convert (ptype, base),
2612 tf_warning_or_error);
2613 controller = build3 (BIND_EXPR, void_type_node, tbase,
2614 NULL_TREE, NULL_TREE);
2615 TREE_SIDE_EFFECTS (controller) = 1;
2617 body = build1 (EXIT_EXPR, void_type_node,
2618 build2 (EQ_EXPR, boolean_type_node, tbase,
2619 fold_convert (ptype, base)));
2620 tmp = fold_build1_loc (input_location, NEGATE_EXPR, sizetype, size_exp);
2621 body = build_compound_expr
2623 body, cp_build_modify_expr (tbase, NOP_EXPR,
2624 build2 (POINTER_PLUS_EXPR, ptype, tbase, tmp),
2625 tf_warning_or_error));
2626 body = build_compound_expr
2628 body, build_delete (ptype, tbase, sfk_complete_destructor,
2629 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1));
2631 loop = build1 (LOOP_EXPR, void_type_node, body);
2632 loop = build_compound_expr (input_location, tbase_init, loop);
2635 /* If the delete flag is one, or anything else with the low bit set,
2636 delete the storage. */
2637 if (auto_delete_vec != sfk_base_destructor)
2641 /* The below is short by the cookie size. */
2642 virtual_size = size_binop (MULT_EXPR, size_exp,
2643 convert (sizetype, maxindex));
2645 if (! TYPE_VEC_NEW_USES_COOKIE (type))
2652 cookie_size = targetm.cxx.get_cookie_size (type);
2654 = cp_convert (ptype,
2655 cp_build_binary_op (input_location,
2657 cp_convert (string_type_node,
2660 tf_warning_or_error));
2661 /* True size with header. */
2662 virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2665 if (auto_delete_vec == sfk_deleting_destructor)
2666 deallocate_expr = build_op_delete_call (VEC_DELETE_EXPR,
2667 base_tbd, virtual_size,
2668 use_global_delete & 1,
2669 /*placement=*/NULL_TREE,
2670 /*alloc_fn=*/NULL_TREE);
2674 if (!deallocate_expr)
2677 body = deallocate_expr;
2679 body = build_compound_expr (input_location, body, deallocate_expr);
2682 body = integer_zero_node;
2684 /* Outermost wrapper: If pointer is null, punt. */
2685 body = fold_build3_loc (input_location, COND_EXPR, void_type_node,
2686 fold_build2_loc (input_location,
2687 NE_EXPR, boolean_type_node, base,
2688 convert (TREE_TYPE (base),
2689 integer_zero_node)),
2690 body, integer_zero_node);
2691 body = build1 (NOP_EXPR, void_type_node, body);
2695 TREE_OPERAND (controller, 1) = body;
2699 if (TREE_CODE (base) == SAVE_EXPR)
2700 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
2701 body = build2 (COMPOUND_EXPR, void_type_node, base, body);
2703 return convert_to_void (body, /*implicit=*/NULL, tf_warning_or_error);
2706 /* Create an unnamed variable of the indicated TYPE. */
2709 create_temporary_var (tree type)
2713 decl = build_decl (input_location,
2714 VAR_DECL, NULL_TREE, type);
2715 TREE_USED (decl) = 1;
2716 DECL_ARTIFICIAL (decl) = 1;
2717 DECL_IGNORED_P (decl) = 1;
2718 DECL_CONTEXT (decl) = current_function_decl;
2723 /* Create a new temporary variable of the indicated TYPE, initialized
2726 It is not entered into current_binding_level, because that breaks
2727 things when it comes time to do final cleanups (which take place
2728 "outside" the binding contour of the function). */
2731 get_temp_regvar (tree type, tree init)
2735 decl = create_temporary_var (type);
2736 add_decl_expr (decl);
2738 finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,
2739 tf_warning_or_error));
2744 /* `build_vec_init' returns tree structure that performs
2745 initialization of a vector of aggregate types.
2747 BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
2748 to the first element, of POINTER_TYPE.
2749 MAXINDEX is the maximum index of the array (one less than the
2750 number of elements). It is only used if BASE is a pointer or
2751 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2753 INIT is the (possibly NULL) initializer.
2755 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All
2756 elements in the array are value-initialized.
2758 FROM_ARRAY is 0 if we should init everything with INIT
2759 (i.e., every element initialized from INIT).
2760 FROM_ARRAY is 1 if we should index into INIT in parallel
2761 with initialization of DECL.
2762 FROM_ARRAY is 2 if we should index into INIT in parallel,
2763 but use assignment instead of initialization. */
2766 build_vec_init (tree base, tree maxindex, tree init,
2767 bool explicit_value_init_p,
2768 int from_array, tsubst_flags_t complain)
2771 tree base2 = NULL_TREE;
2772 tree itype = NULL_TREE;
2774 /* The type of BASE. */
2775 tree atype = TREE_TYPE (base);
2776 /* The type of an element in the array. */
2777 tree type = TREE_TYPE (atype);
2778 /* The element type reached after removing all outer array
2780 tree inner_elt_type;
2781 /* The type of a pointer to an element in the array. */
2786 tree try_block = NULL_TREE;
2787 int num_initialized_elts = 0;
2790 if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype))
2791 maxindex = array_type_nelts (atype);
2793 if (maxindex == NULL_TREE || maxindex == error_mark_node)
2794 return error_mark_node;
2796 if (explicit_value_init_p)
2799 inner_elt_type = strip_array_types (type);
2801 /* Look through the TARGET_EXPR around a compound literal. */
2802 if (init && TREE_CODE (init) == TARGET_EXPR
2803 && TREE_CODE (TARGET_EXPR_INITIAL (init)) == CONSTRUCTOR
2805 init = TARGET_EXPR_INITIAL (init);
2808 && TREE_CODE (atype) == ARRAY_TYPE
2810 ? (!CLASS_TYPE_P (inner_elt_type)
2811 || !TYPE_HAS_COMPLEX_ASSIGN_REF (inner_elt_type))
2812 : !TYPE_NEEDS_CONSTRUCTING (type))
2813 && ((TREE_CODE (init) == CONSTRUCTOR
2814 /* Don't do this if the CONSTRUCTOR might contain something
2815 that might throw and require us to clean up. */
2816 && (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))
2817 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
2820 /* Do non-default initialization of trivial arrays resulting from
2821 brace-enclosed initializers. In this case, digest_init and
2822 store_constructor will handle the semantics for us. */
2824 stmt_expr = build2 (INIT_EXPR, atype, base, init);
2828 maxindex = cp_convert (ptrdiff_type_node, maxindex);
2829 if (TREE_CODE (atype) == ARRAY_TYPE)
2831 ptype = build_pointer_type (type);
2832 base = cp_convert (ptype, decay_conversion (base));
2837 /* The code we are generating looks like:
2841 ptrdiff_t iterator = maxindex;
2843 for (; iterator != -1; --iterator) {
2844 ... initialize *t1 ...
2848 ... destroy elements that were constructed ...
2853 We can omit the try and catch blocks if we know that the
2854 initialization will never throw an exception, or if the array
2855 elements do not have destructors. We can omit the loop completely if
2856 the elements of the array do not have constructors.
2858 We actually wrap the entire body of the above in a STMT_EXPR, for
2861 When copying from array to another, when the array elements have
2862 only trivial copy constructors, we should use __builtin_memcpy
2863 rather than generating a loop. That way, we could take advantage
2864 of whatever cleverness the back end has for dealing with copies
2865 of blocks of memory. */
2867 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
2868 destroy_temps = stmts_are_full_exprs_p ();
2869 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2870 rval = get_temp_regvar (ptype, base);
2871 base = get_temp_regvar (ptype, rval);
2872 iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2874 /* If initializing one array from another, initialize element by
2875 element. We rely upon the below calls to do the argument
2876 checking. Evaluate the initializer before entering the try block. */
2877 if (from_array && init && TREE_CODE (init) != CONSTRUCTOR)
2879 base2 = decay_conversion (init);
2880 itype = TREE_TYPE (base2);
2881 base2 = get_temp_regvar (itype, base2);
2882 itype = TREE_TYPE (itype);
2885 /* Protect the entire array initialization so that we can destroy
2886 the partially constructed array if an exception is thrown.
2887 But don't do this if we're assigning. */
2888 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2891 try_block = begin_try_block ();
2894 if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
2896 /* Do non-default initialization of non-trivial arrays resulting from
2897 brace-enclosed initializers. */
2898 unsigned HOST_WIDE_INT idx;
2902 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
2904 tree baseref = build1 (INDIRECT_REF, type, base);
2906 num_initialized_elts++;
2908 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2909 if (MAYBE_CLASS_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
2910 finish_expr_stmt (build_aggr_init (baseref, elt, 0, complain));
2912 finish_expr_stmt (cp_build_modify_expr (baseref, NOP_EXPR,
2914 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2916 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
2918 finish_expr_stmt (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
2922 /* Clear out INIT so that we don't get confused below. */
2925 else if (from_array)
2928 /* OK, we set base2 above. */;
2929 else if (TYPE_LANG_SPECIFIC (type)
2930 && TYPE_NEEDS_CONSTRUCTING (type)
2931 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2933 if (complain & tf_error)
2934 error ("initializer ends prematurely");
2935 return error_mark_node;
2939 /* Now, default-initialize any remaining elements. We don't need to
2940 do that if a) the type does not need constructing, or b) we've
2941 already initialized all the elements.
2943 We do need to keep going if we're copying an array. */
2946 || ((TYPE_NEEDS_CONSTRUCTING (type) || explicit_value_init_p)
2947 && ! (host_integerp (maxindex, 0)
2948 && (num_initialized_elts
2949 == tree_low_cst (maxindex, 0) + 1))))
2951 /* If the ITERATOR is equal to -1, then we don't have to loop;
2952 we've already initialized all the elements. */
2957 for_stmt = begin_for_stmt ();
2958 finish_for_init_stmt (for_stmt);
2959 finish_for_cond (build2 (NE_EXPR, boolean_type_node, iterator,
2960 build_int_cst (TREE_TYPE (iterator), -1)),
2962 finish_for_expr (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
2966 to = build1 (INDIRECT_REF, type, base);
2973 from = build1 (INDIRECT_REF, itype, base2);
2977 if (from_array == 2)
2978 elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
2980 else if (TYPE_NEEDS_CONSTRUCTING (type))
2981 elt_init = build_aggr_init (to, from, 0, complain);
2983 elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
2988 else if (TREE_CODE (type) == ARRAY_TYPE)
2992 ("cannot initialize multi-dimensional array with initializer");
2993 elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
2995 explicit_value_init_p,
2998 else if (explicit_value_init_p)
2999 elt_init = build2 (INIT_EXPR, type, to,
3000 build_value_init (type));
3003 gcc_assert (TYPE_NEEDS_CONSTRUCTING (type));
3004 elt_init = build_aggr_init (to, init, 0, complain);
3007 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
3008 finish_expr_stmt (elt_init);
3009 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
3011 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
3014 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base2, 0,
3017 finish_for_stmt (for_stmt);
3020 /* Make sure to cleanup any partially constructed elements. */
3021 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
3025 tree m = cp_build_binary_op (input_location,
3026 MINUS_EXPR, maxindex, iterator,
3029 /* Flatten multi-dimensional array since build_vec_delete only
3030 expects one-dimensional array. */
3031 if (TREE_CODE (type) == ARRAY_TYPE)
3032 m = cp_build_binary_op (input_location,
3034 array_type_nelts_total (type),
3037 finish_cleanup_try_block (try_block);
3038 e = build_vec_delete_1 (rval, m,
3039 inner_elt_type, sfk_base_destructor,
3040 /*use_global_delete=*/0);
3041 finish_cleanup (e, try_block);
3044 /* The value of the array initialization is the array itself, RVAL
3045 is a pointer to the first element. */
3046 finish_stmt_expr_expr (rval, stmt_expr);
3048 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
3050 /* Now make the result have the correct type. */
3051 if (TREE_CODE (atype) == ARRAY_TYPE)
3053 atype = build_pointer_type (atype);
3054 stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
3055 stmt_expr = cp_build_indirect_ref (stmt_expr, RO_NULL, complain);
3056 TREE_NO_WARNING (stmt_expr) = 1;
3059 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
3063 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
3067 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags)
3073 case sfk_complete_destructor:
3074 name = complete_dtor_identifier;
3077 case sfk_base_destructor:
3078 name = base_dtor_identifier;
3081 case sfk_deleting_destructor:
3082 name = deleting_dtor_identifier;
3088 fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
3089 return build_new_method_call (exp, fn,
3091 /*conversion_path=*/NULL_TREE,
3094 tf_warning_or_error);
3097 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3098 ADDR is an expression which yields the store to be destroyed.
3099 AUTO_DELETE is the name of the destructor to call, i.e., either
3100 sfk_complete_destructor, sfk_base_destructor, or
3101 sfk_deleting_destructor.
3103 FLAGS is the logical disjunction of zero or more LOOKUP_
3104 flags. See cp-tree.h for more info. */
3107 build_delete (tree type, tree addr, special_function_kind auto_delete,
3108 int flags, int use_global_delete)
3112 if (addr == error_mark_node)
3113 return error_mark_node;
3115 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3116 set to `error_mark_node' before it gets properly cleaned up. */
3117 if (type == error_mark_node)
3118 return error_mark_node;
3120 type = TYPE_MAIN_VARIANT (type);
3122 addr = mark_rvalue_use (addr);
3124 if (TREE_CODE (type) == POINTER_TYPE)
3126 bool complete_p = true;
3128 type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
3129 if (TREE_CODE (type) == ARRAY_TYPE)
3132 /* We don't want to warn about delete of void*, only other
3133 incomplete types. Deleting other incomplete types
3134 invokes undefined behavior, but it is not ill-formed, so
3135 compile to something that would even do The Right Thing
3136 (TM) should the type have a trivial dtor and no delete
3138 if (!VOID_TYPE_P (type))
3140 complete_type (type);
3141 if (!COMPLETE_TYPE_P (type))
3143 if (warning (0, "possible problem detected in invocation of "
3144 "delete operator:"))
3146 cxx_incomplete_type_diagnostic (addr, type, DK_WARNING);
3147 inform (input_location, "neither the destructor nor the class-specific "
3148 "operator delete will be called, even if they are "
3149 "declared when the class is defined.");
3154 if (VOID_TYPE_P (type) || !complete_p || !MAYBE_CLASS_TYPE_P (type))
3155 /* Call the builtin operator delete. */
3156 return build_builtin_delete_call (addr);
3157 if (TREE_SIDE_EFFECTS (addr))
3158 addr = save_expr (addr);
3160 /* Throw away const and volatile on target type of addr. */
3161 addr = convert_force (build_pointer_type (type), addr, 0);
3163 else if (TREE_CODE (type) == ARRAY_TYPE)
3167 if (TYPE_DOMAIN (type) == NULL_TREE)
3169 error ("unknown array size in delete");
3170 return error_mark_node;
3172 return build_vec_delete (addr, array_type_nelts (type),
3173 auto_delete, use_global_delete);
3177 /* Don't check PROTECT here; leave that decision to the
3178 destructor. If the destructor is accessible, call it,
3179 else report error. */
3180 addr = cp_build_unary_op (ADDR_EXPR, addr, 0, tf_warning_or_error);
3181 if (TREE_SIDE_EFFECTS (addr))
3182 addr = save_expr (addr);
3184 addr = convert_force (build_pointer_type (type), addr, 0);
3187 gcc_assert (MAYBE_CLASS_TYPE_P (type));
3189 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
3191 if (auto_delete != sfk_deleting_destructor)
3192 return void_zero_node;
3194 return build_op_delete_call (DELETE_EXPR, addr,
3195 cxx_sizeof_nowarn (type),
3197 /*placement=*/NULL_TREE,
3198 /*alloc_fn=*/NULL_TREE);
3202 tree head = NULL_TREE;
3203 tree do_delete = NULL_TREE;
3206 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
3207 lazily_declare_fn (sfk_destructor, type);
3209 /* For `::delete x', we must not use the deleting destructor
3210 since then we would not be sure to get the global `operator
3212 if (use_global_delete && auto_delete == sfk_deleting_destructor)
3214 /* We will use ADDR multiple times so we must save it. */
3215 addr = save_expr (addr);
3216 head = get_target_expr (build_headof (addr));
3217 /* Delete the object. */
3218 do_delete = build_builtin_delete_call (head);
3219 /* Otherwise, treat this like a complete object destructor
3221 auto_delete = sfk_complete_destructor;
3223 /* If the destructor is non-virtual, there is no deleting
3224 variant. Instead, we must explicitly call the appropriate
3225 `operator delete' here. */
3226 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
3227 && auto_delete == sfk_deleting_destructor)
3229 /* We will use ADDR multiple times so we must save it. */
3230 addr = save_expr (addr);
3231 /* Build the call. */
3232 do_delete = build_op_delete_call (DELETE_EXPR,
3234 cxx_sizeof_nowarn (type),
3236 /*placement=*/NULL_TREE,
3237 /*alloc_fn=*/NULL_TREE);
3238 /* Call the complete object destructor. */
3239 auto_delete = sfk_complete_destructor;
3241 else if (auto_delete == sfk_deleting_destructor
3242 && TYPE_GETS_REG_DELETE (type))
3244 /* Make sure we have access to the member op delete, even though
3245 we'll actually be calling it from the destructor. */
3246 build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
3248 /*placement=*/NULL_TREE,
3249 /*alloc_fn=*/NULL_TREE);
3252 expr = build_dtor_call (cp_build_indirect_ref (addr, RO_NULL,
3253 tf_warning_or_error),
3254 auto_delete, flags);
3256 expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
3258 /* We need to calculate this before the dtor changes the vptr. */
3260 expr = build2 (COMPOUND_EXPR, void_type_node, head, expr);
3262 if (flags & LOOKUP_DESTRUCTOR)
3263 /* Explicit destructor call; don't check for null pointer. */
3264 ifexp = integer_one_node;
3266 /* Handle deleting a null pointer. */
3267 ifexp = fold (cp_build_binary_op (input_location,
3268 NE_EXPR, addr, integer_zero_node,
3269 tf_warning_or_error));
3271 if (ifexp != integer_one_node)
3272 expr = build3 (COND_EXPR, void_type_node,
3273 ifexp, expr, void_zero_node);
3279 /* At the beginning of a destructor, push cleanups that will call the
3280 destructors for our base classes and members.
3282 Called from begin_destructor_body. */
3285 push_base_cleanups (void)
3287 tree binfo, base_binfo;
3291 VEC(tree,gc) *vbases;
3293 /* Run destructors for all virtual baseclasses. */
3294 if (CLASSTYPE_VBASECLASSES (current_class_type))
3296 tree cond = (condition_conversion
3297 (build2 (BIT_AND_EXPR, integer_type_node,
3298 current_in_charge_parm,
3299 integer_two_node)));
3301 /* The CLASSTYPE_VBASECLASSES vector is in initialization
3302 order, which is also the right order for pushing cleanups. */
3303 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
3304 VEC_iterate (tree, vbases, i, base_binfo); i++)
3306 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
3308 expr = build_special_member_call (current_class_ref,
3309 base_dtor_identifier,
3313 | LOOKUP_NONVIRTUAL),
3314 tf_warning_or_error);
3315 expr = build3 (COND_EXPR, void_type_node, cond,
3316 expr, void_zero_node);
3317 finish_decl_cleanup (NULL_TREE, expr);
3322 /* Take care of the remaining baseclasses. */
3323 for (binfo = TYPE_BINFO (current_class_type), i = 0;
3324 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
3326 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
3327 || BINFO_VIRTUAL_P (base_binfo))
3330 expr = build_special_member_call (current_class_ref,
3331 base_dtor_identifier,
3333 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
3334 tf_warning_or_error);
3335 finish_decl_cleanup (NULL_TREE, expr);
3338 for (member = TYPE_FIELDS (current_class_type); member;
3339 member = TREE_CHAIN (member))
3341 if (TREE_TYPE (member) == error_mark_node
3342 || TREE_CODE (member) != FIELD_DECL
3343 || DECL_ARTIFICIAL (member))
3345 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
3347 tree this_member = (build_class_member_access_expr
3348 (current_class_ref, member,
3349 /*access_path=*/NULL_TREE,
3350 /*preserve_reference=*/false,
3351 tf_warning_or_error));
3352 tree this_type = TREE_TYPE (member);
3353 expr = build_delete (this_type, this_member,
3354 sfk_complete_destructor,
3355 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
3357 finish_decl_cleanup (NULL_TREE, expr);
3362 /* Build a C++ vector delete expression.
3363 MAXINDEX is the number of elements to be deleted.
3364 ELT_SIZE is the nominal size of each element in the vector.
3365 BASE is the expression that should yield the store to be deleted.
3366 This function expands (or synthesizes) these calls itself.
3367 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3369 This also calls delete for virtual baseclasses of elements of the vector.
3371 Update: MAXINDEX is no longer needed. The size can be extracted from the
3372 start of the vector for pointers, and from the type for arrays. We still
3373 use MAXINDEX for arrays because it happens to already have one of the
3374 values we'd have to extract. (We could use MAXINDEX with pointers to
3375 confirm the size, and trap if the numbers differ; not clear that it'd
3376 be worth bothering.) */
3379 build_vec_delete (tree base, tree maxindex,
3380 special_function_kind auto_delete_vec, int use_global_delete)
3384 tree base_init = NULL_TREE;
3386 type = TREE_TYPE (base);
3388 if (TREE_CODE (type) == POINTER_TYPE)
3390 /* Step back one from start of vector, and read dimension. */
3392 tree size_ptr_type = build_pointer_type (sizetype);
3394 if (TREE_SIDE_EFFECTS (base))
3396 base_init = get_target_expr (base);
3397 base = TARGET_EXPR_SLOT (base_init);
3399 type = strip_array_types (TREE_TYPE (type));
3400 cookie_addr = fold_build1_loc (input_location, NEGATE_EXPR,
3401 sizetype, TYPE_SIZE_UNIT (sizetype));
3402 cookie_addr = build2 (POINTER_PLUS_EXPR,
3404 fold_convert (size_ptr_type, base),
3406 maxindex = cp_build_indirect_ref (cookie_addr, RO_NULL, tf_warning_or_error);
3408 else if (TREE_CODE (type) == ARRAY_TYPE)
3410 /* Get the total number of things in the array, maxindex is a
3412 maxindex = array_type_nelts_total (type);
3413 type = strip_array_types (type);
3414 base = cp_build_unary_op (ADDR_EXPR, base, 1, tf_warning_or_error);
3415 if (TREE_SIDE_EFFECTS (base))
3417 base_init = get_target_expr (base);
3418 base = TARGET_EXPR_SLOT (base_init);
3423 if (base != error_mark_node)
3424 error ("type to vector delete is neither pointer or array type");
3425 return error_mark_node;
3428 rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3431 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);