1 /* Handle initialization things in C++.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* High-level class interface. */
27 #include "coretypes.h"
39 static bool begin_init_stmts (tree
*, tree
*);
40 static tree
finish_init_stmts (bool, tree
, tree
);
41 static void construct_virtual_base (tree
, tree
);
42 static void expand_aggr_init_1 (tree
, tree
, tree
, tree
, int, tsubst_flags_t
);
43 static void expand_default_init (tree
, tree
, tree
, tree
, int, tsubst_flags_t
);
44 static tree
build_vec_delete_1 (tree
, tree
, tree
, special_function_kind
, int);
45 static void perform_member_init (tree
, tree
);
46 static tree
build_builtin_delete_call (tree
);
47 static int member_init_ok_or_else (tree
, tree
, tree
);
48 static void expand_virtual_init (tree
, tree
);
49 static tree
sort_mem_initializers (tree
, tree
);
50 static tree
initializing_context (tree
);
51 static void expand_cleanup_for_base (tree
, tree
);
52 static tree
get_temp_regvar (tree
, tree
);
53 static tree
dfs_initialize_vtbl_ptrs (tree
, void *);
54 static tree
build_dtor_call (tree
, special_function_kind
, int);
55 static tree
build_field_list (tree
, tree
, int *);
56 static tree
build_vtbl_address (tree
);
58 /* We are about to generate some complex initialization code.
59 Conceptually, it is all a single expression. However, we may want
60 to include conditionals, loops, and other such statement-level
61 constructs. Therefore, we build the initialization code inside a
62 statement-expression. This function starts such an expression.
63 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
64 pass them back to finish_init_stmts when the expression is
68 begin_init_stmts (tree
*stmt_expr_p
, tree
*compound_stmt_p
)
70 bool is_global
= !building_stmt_tree ();
72 *stmt_expr_p
= begin_stmt_expr ();
73 *compound_stmt_p
= begin_compound_stmt (BCS_NO_SCOPE
);
78 /* Finish out the statement-expression begun by the previous call to
79 begin_init_stmts. Returns the statement-expression itself. */
82 finish_init_stmts (bool is_global
, tree stmt_expr
, tree compound_stmt
)
84 finish_compound_stmt (compound_stmt
);
86 stmt_expr
= finish_stmt_expr (stmt_expr
, true);
88 gcc_assert (!building_stmt_tree () == is_global
);
95 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
96 which we want to initialize the vtable pointer for, DATA is
97 TREE_LIST whose TREE_VALUE is the this ptr expression. */
100 dfs_initialize_vtbl_ptrs (tree binfo
, void *data
)
102 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
103 return dfs_skip_bases
;
105 if (!BINFO_PRIMARY_P (binfo
) || BINFO_VIRTUAL_P (binfo
))
107 tree base_ptr
= TREE_VALUE ((tree
) data
);
109 base_ptr
= build_base_path (PLUS_EXPR
, base_ptr
, binfo
, /*nonnull=*/1);
111 expand_virtual_init (binfo
, base_ptr
);
117 /* Initialize all the vtable pointers in the object pointed to by
121 initialize_vtbl_ptrs (tree addr
)
126 type
= TREE_TYPE (TREE_TYPE (addr
));
127 list
= build_tree_list (type
, addr
);
129 /* Walk through the hierarchy, initializing the vptr in each base
130 class. We do these in pre-order because we can't find the virtual
131 bases for a class until we've initialized the vtbl for that
133 dfs_walk_once (TYPE_BINFO (type
), dfs_initialize_vtbl_ptrs
, NULL
, list
);
136 /* Return an expression for the zero-initialization of an object with
137 type T. This expression will either be a constant (in the case
138 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
139 aggregate), or NULL (in the case that T does not require
140 initialization). In either case, the value can be used as
141 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
142 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
143 is the number of elements in the array. If STATIC_STORAGE_P is
144 TRUE, initializers are only generated for entities for which
145 zero-initialization does not simply mean filling the storage with
149 build_zero_init (tree type
, tree nelts
, bool static_storage_p
)
151 tree init
= NULL_TREE
;
155 To zero-initialize an object of type T means:
157 -- if T is a scalar type, the storage is set to the value of zero
160 -- if T is a non-union class type, the storage for each nonstatic
161 data member and each base-class subobject is zero-initialized.
163 -- if T is a union type, the storage for its first data member is
166 -- if T is an array type, the storage for each element is
169 -- if T is a reference type, no initialization is performed. */
171 gcc_assert (nelts
== NULL_TREE
|| TREE_CODE (nelts
) == INTEGER_CST
);
173 if (type
== error_mark_node
)
175 else if (static_storage_p
&& zero_init_p (type
))
176 /* In order to save space, we do not explicitly build initializers
177 for items that do not need them. GCC's semantics are that
178 items with static storage duration that are not otherwise
179 initialized are initialized to zero. */
181 else if (SCALAR_TYPE_P (type
))
182 init
= convert (type
, integer_zero_node
);
183 else if (CLASS_TYPE_P (type
))
186 VEC(constructor_elt
,gc
) *v
= NULL
;
188 /* Iterate over the fields, building initializations. */
189 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
191 if (TREE_CODE (field
) != FIELD_DECL
)
194 /* Note that for class types there will be FIELD_DECLs
195 corresponding to base classes as well. Thus, iterating
196 over TYPE_FIELDs will result in correct initialization of
197 all of the subobjects. */
198 if (!static_storage_p
|| !zero_init_p (TREE_TYPE (field
)))
200 tree value
= build_zero_init (TREE_TYPE (field
),
204 CONSTRUCTOR_APPEND_ELT(v
, field
, value
);
207 /* For unions, only the first field is initialized. */
208 if (TREE_CODE (type
) == UNION_TYPE
)
212 /* Build a constructor to contain the initializations. */
213 init
= build_constructor (type
, v
);
215 else if (TREE_CODE (type
) == ARRAY_TYPE
)
218 VEC(constructor_elt
,gc
) *v
= NULL
;
220 /* Iterate over the array elements, building initializations. */
222 max_index
= fold_build2 (MINUS_EXPR
, TREE_TYPE (nelts
),
223 nelts
, integer_one_node
);
225 max_index
= array_type_nelts (type
);
227 /* If we have an error_mark here, we should just return error mark
228 as we don't know the size of the array yet. */
229 if (max_index
== error_mark_node
)
230 return error_mark_node
;
231 gcc_assert (TREE_CODE (max_index
) == INTEGER_CST
);
233 /* A zero-sized array, which is accepted as an extension, will
234 have an upper bound of -1. */
235 if (!tree_int_cst_equal (max_index
, integer_minus_one_node
))
239 v
= VEC_alloc (constructor_elt
, gc
, 1);
240 ce
= VEC_quick_push (constructor_elt
, v
, NULL
);
242 /* If this is a one element array, we just use a regular init. */
243 if (tree_int_cst_equal (size_zero_node
, max_index
))
244 ce
->index
= size_zero_node
;
246 ce
->index
= build2 (RANGE_EXPR
, sizetype
, size_zero_node
,
249 ce
->value
= build_zero_init (TREE_TYPE (type
),
254 /* Build a constructor to contain the initializations. */
255 init
= build_constructor (type
, v
);
257 else if (TREE_CODE (type
) == VECTOR_TYPE
)
258 init
= fold_convert (type
, integer_zero_node
);
260 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
262 /* In all cases, the initializer is a constant. */
264 TREE_CONSTANT (init
) = 1;
269 /* Return a suitable initializer for value-initializing an object of type
270 TYPE, as described in [dcl.init]. */
273 build_value_init (tree type
)
277 To value-initialize an object of type T means:
279 - if T is a class type (clause 9) with a user-provided constructor
280 (12.1), then the default constructor for T is called (and the
281 initialization is ill-formed if T has no accessible default
284 - if T is a non-union class type without a user-provided constructor,
285 then every non-static data member and base-class component of T is
286 value-initialized;92)
288 - if T is an array type, then each element is value-initialized;
290 - otherwise, the object is zero-initialized.
292 A program that calls for default-initialization or
293 value-initialization of an entity of reference type is ill-formed.
295 92) Value-initialization for such a class object may be implemented by
296 zero-initializing the object and then calling the default
299 if (CLASS_TYPE_P (type
))
301 if (type_has_user_provided_constructor (type
))
302 return build_aggr_init_expr
304 build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
305 NULL_TREE
, type
, LOOKUP_NORMAL
,
306 tf_warning_or_error
));
307 else if (TREE_CODE (type
) != UNION_TYPE
&& TYPE_NEEDS_CONSTRUCTING (type
))
309 /* This is a class that needs constructing, but doesn't have
310 a user-provided constructor. So we need to zero-initialize
311 the object and then call the implicitly defined ctor.
312 This will be handled in simplify_aggr_init_expr. */
313 tree ctor
= build_special_member_call
314 (NULL_TREE
, complete_ctor_identifier
,
315 NULL_TREE
, type
, LOOKUP_NORMAL
, tf_warning_or_error
);
317 ctor
= build_aggr_init_expr (type
, ctor
);
318 AGGR_INIT_ZERO_FIRST (ctor
) = 1;
321 else if (TREE_CODE (type
) != UNION_TYPE
)
324 VEC(constructor_elt
,gc
) *v
= NULL
;
326 /* Iterate over the fields, building initializations. */
327 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
331 if (TREE_CODE (field
) != FIELD_DECL
)
334 ftype
= TREE_TYPE (field
);
336 if (TREE_CODE (ftype
) == REFERENCE_TYPE
)
337 error ("value-initialization of reference");
339 /* We could skip vfields and fields of types with
340 user-defined constructors, but I think that won't improve
341 performance at all; it should be simpler in general just
342 to zero out the entire object than try to only zero the
343 bits that actually need it. */
345 /* Note that for class types there will be FIELD_DECLs
346 corresponding to base classes as well. Thus, iterating
347 over TYPE_FIELDs will result in correct initialization of
348 all of the subobjects. */
349 value
= build_value_init (ftype
);
352 CONSTRUCTOR_APPEND_ELT(v
, field
, value
);
355 /* Build a constructor to contain the zero- initializations. */
356 return build_constructor (type
, v
);
359 else if (TREE_CODE (type
) == ARRAY_TYPE
)
361 VEC(constructor_elt
,gc
) *v
= NULL
;
363 /* Iterate over the array elements, building initializations. */
364 tree max_index
= array_type_nelts (type
);
366 /* If we have an error_mark here, we should just return error mark
367 as we don't know the size of the array yet. */
368 if (max_index
== error_mark_node
)
369 return error_mark_node
;
370 gcc_assert (TREE_CODE (max_index
) == INTEGER_CST
);
372 /* A zero-sized array, which is accepted as an extension, will
373 have an upper bound of -1. */
374 if (!tree_int_cst_equal (max_index
, integer_minus_one_node
))
378 v
= VEC_alloc (constructor_elt
, gc
, 1);
379 ce
= VEC_quick_push (constructor_elt
, v
, NULL
);
381 /* If this is a one element array, we just use a regular init. */
382 if (tree_int_cst_equal (size_zero_node
, max_index
))
383 ce
->index
= size_zero_node
;
385 ce
->index
= build2 (RANGE_EXPR
, sizetype
, size_zero_node
,
388 ce
->value
= build_value_init (TREE_TYPE (type
));
390 /* The gimplifier can't deal with a RANGE_EXPR of TARGET_EXPRs. */
391 gcc_assert (TREE_CODE (ce
->value
) != TARGET_EXPR
392 && TREE_CODE (ce
->value
) != AGGR_INIT_EXPR
);
395 /* Build a constructor to contain the initializations. */
396 return build_constructor (type
, v
);
399 return build_zero_init (type
, NULL_TREE
, /*static_storage_p=*/false);
402 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
403 arguments. If TREE_LIST is void_type_node, an empty initializer
404 list was given; if NULL_TREE no initializer was given. */
407 perform_member_init (tree member
, tree init
)
410 tree type
= TREE_TYPE (member
);
412 /* Effective C++ rule 12 requires that all data members be
414 if (warn_ecpp
&& init
== NULL_TREE
&& TREE_CODE (type
) != ARRAY_TYPE
)
415 warning (OPT_Weffc__
, "%J%qD should be initialized in the member initialization "
416 "list", current_function_decl
, member
);
418 /* Get an lvalue for the data member. */
419 decl
= build_class_member_access_expr (current_class_ref
, member
,
420 /*access_path=*/NULL_TREE
,
421 /*preserve_reference=*/true,
422 tf_warning_or_error
);
423 if (decl
== error_mark_node
)
426 if (init
== void_type_node
)
428 /* mem() means value-initialization. */
429 if (TREE_CODE (type
) == ARRAY_TYPE
)
431 init
= build_vec_init (decl
, NULL_TREE
, NULL_TREE
,
432 /*explicit_value_init_p=*/true,
434 tf_warning_or_error
);
435 finish_expr_stmt (init
);
439 if (TREE_CODE (type
) == REFERENCE_TYPE
)
440 permerror (input_location
, "%Jvalue-initialization of %q#D, "
441 "which has reference type",
442 current_function_decl
, member
);
445 init
= build2 (INIT_EXPR
, type
, decl
, build_value_init (type
));
446 finish_expr_stmt (init
);
450 /* Deal with this here, as we will get confused if we try to call the
451 assignment op for an anonymous union. This can happen in a
452 synthesized copy constructor. */
453 else if (ANON_AGGR_TYPE_P (type
))
457 init
= build2 (INIT_EXPR
, type
, decl
, TREE_VALUE (init
));
458 finish_expr_stmt (init
);
461 else if (TYPE_NEEDS_CONSTRUCTING (type
))
463 if (init
!= NULL_TREE
464 && TREE_CODE (type
) == ARRAY_TYPE
465 && TREE_CHAIN (init
) == NULL_TREE
466 && TREE_CODE (TREE_TYPE (TREE_VALUE (init
))) == ARRAY_TYPE
)
468 /* Initialization of one array from another. */
469 finish_expr_stmt (build_vec_init (decl
, NULL_TREE
, TREE_VALUE (init
),
470 /*explicit_value_init_p=*/false,
472 tf_warning_or_error
));
476 if (CP_TYPE_CONST_P (type
)
478 && !type_has_user_provided_default_constructor (type
))
479 /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
480 vtable; still give this diagnostic. */
481 permerror (input_location
, "%Juninitialized member %qD with %<const%> type %qT",
482 current_function_decl
, member
, type
);
483 finish_expr_stmt (build_aggr_init (decl
, init
, 0,
484 tf_warning_or_error
));
489 if (init
== NULL_TREE
)
491 /* member traversal: note it leaves init NULL */
492 if (TREE_CODE (type
) == REFERENCE_TYPE
)
493 permerror (input_location
, "%Juninitialized reference member %qD",
494 current_function_decl
, member
);
495 else if (CP_TYPE_CONST_P (type
))
496 permerror (input_location
, "%Juninitialized member %qD with %<const%> type %qT",
497 current_function_decl
, member
, type
);
499 else if (TREE_CODE (init
) == TREE_LIST
)
500 /* There was an explicit member initialization. Do some work
502 init
= build_x_compound_expr_from_list (init
, "member initializer");
505 finish_expr_stmt (cp_build_modify_expr (decl
, INIT_EXPR
, init
,
506 tf_warning_or_error
));
509 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
513 expr
= build_class_member_access_expr (current_class_ref
, member
,
514 /*access_path=*/NULL_TREE
,
515 /*preserve_reference=*/false,
516 tf_warning_or_error
);
517 expr
= build_delete (type
, expr
, sfk_complete_destructor
,
518 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0);
520 if (expr
!= error_mark_node
)
521 finish_eh_cleanup (expr
);
525 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
526 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
529 build_field_list (tree t
, tree list
, int *uses_unions_p
)
535 /* Note whether or not T is a union. */
536 if (TREE_CODE (t
) == UNION_TYPE
)
539 for (fields
= TYPE_FIELDS (t
); fields
; fields
= TREE_CHAIN (fields
))
541 /* Skip CONST_DECLs for enumeration constants and so forth. */
542 if (TREE_CODE (fields
) != FIELD_DECL
|| DECL_ARTIFICIAL (fields
))
545 /* Keep track of whether or not any fields are unions. */
546 if (TREE_CODE (TREE_TYPE (fields
)) == UNION_TYPE
)
549 /* For an anonymous struct or union, we must recursively
550 consider the fields of the anonymous type. They can be
551 directly initialized from the constructor. */
552 if (ANON_AGGR_TYPE_P (TREE_TYPE (fields
)))
554 /* Add this field itself. Synthesized copy constructors
555 initialize the entire aggregate. */
556 list
= tree_cons (fields
, NULL_TREE
, list
);
557 /* And now add the fields in the anonymous aggregate. */
558 list
= build_field_list (TREE_TYPE (fields
), list
,
561 /* Add this field. */
562 else if (DECL_NAME (fields
))
563 list
= tree_cons (fields
, NULL_TREE
, list
);
569 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
570 a FIELD_DECL or BINFO in T that needs initialization. The
571 TREE_VALUE gives the initializer, or list of initializer arguments.
573 Return a TREE_LIST containing all of the initializations required
574 for T, in the order in which they should be performed. The output
575 list has the same format as the input. */
578 sort_mem_initializers (tree t
, tree mem_inits
)
581 tree base
, binfo
, base_binfo
;
584 VEC(tree
,gc
) *vbases
;
588 /* Build up a list of initializations. The TREE_PURPOSE of entry
589 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
590 TREE_VALUE will be the constructor arguments, or NULL if no
591 explicit initialization was provided. */
592 sorted_inits
= NULL_TREE
;
594 /* Process the virtual bases. */
595 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
596 VEC_iterate (tree
, vbases
, i
, base
); i
++)
597 sorted_inits
= tree_cons (base
, NULL_TREE
, sorted_inits
);
599 /* Process the direct bases. */
600 for (binfo
= TYPE_BINFO (t
), i
= 0;
601 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
602 if (!BINFO_VIRTUAL_P (base_binfo
))
603 sorted_inits
= tree_cons (base_binfo
, NULL_TREE
, sorted_inits
);
605 /* Process the non-static data members. */
606 sorted_inits
= build_field_list (t
, sorted_inits
, &uses_unions_p
);
607 /* Reverse the entire list of initializations, so that they are in
608 the order that they will actually be performed. */
609 sorted_inits
= nreverse (sorted_inits
);
611 /* If the user presented the initializers in an order different from
612 that in which they will actually occur, we issue a warning. Keep
613 track of the next subobject which can be explicitly initialized
614 without issuing a warning. */
615 next_subobject
= sorted_inits
;
617 /* Go through the explicit initializers, filling in TREE_PURPOSE in
619 for (init
= mem_inits
; init
; init
= TREE_CHAIN (init
))
624 subobject
= TREE_PURPOSE (init
);
626 /* If the explicit initializers are in sorted order, then
627 SUBOBJECT will be NEXT_SUBOBJECT, or something following
629 for (subobject_init
= next_subobject
;
631 subobject_init
= TREE_CHAIN (subobject_init
))
632 if (TREE_PURPOSE (subobject_init
) == subobject
)
635 /* Issue a warning if the explicit initializer order does not
636 match that which will actually occur.
637 ??? Are all these on the correct lines? */
638 if (warn_reorder
&& !subobject_init
)
640 if (TREE_CODE (TREE_PURPOSE (next_subobject
)) == FIELD_DECL
)
641 warning (OPT_Wreorder
, "%q+D will be initialized after",
642 TREE_PURPOSE (next_subobject
));
644 warning (OPT_Wreorder
, "base %qT will be initialized after",
645 TREE_PURPOSE (next_subobject
));
646 if (TREE_CODE (subobject
) == FIELD_DECL
)
647 warning (OPT_Wreorder
, " %q+#D", subobject
);
649 warning (OPT_Wreorder
, " base %qT", subobject
);
650 warning (OPT_Wreorder
, "%J when initialized here", current_function_decl
);
653 /* Look again, from the beginning of the list. */
656 subobject_init
= sorted_inits
;
657 while (TREE_PURPOSE (subobject_init
) != subobject
)
658 subobject_init
= TREE_CHAIN (subobject_init
);
661 /* It is invalid to initialize the same subobject more than
663 if (TREE_VALUE (subobject_init
))
665 if (TREE_CODE (subobject
) == FIELD_DECL
)
666 error ("%Jmultiple initializations given for %qD",
667 current_function_decl
, subobject
);
669 error ("%Jmultiple initializations given for base %qT",
670 current_function_decl
, subobject
);
673 /* Record the initialization. */
674 TREE_VALUE (subobject_init
) = TREE_VALUE (init
);
675 next_subobject
= subobject_init
;
680 If a ctor-initializer specifies more than one mem-initializer for
681 multiple members of the same union (including members of
682 anonymous unions), the ctor-initializer is ill-formed. */
685 tree last_field
= NULL_TREE
;
686 for (init
= sorted_inits
; init
; init
= TREE_CHAIN (init
))
692 /* Skip uninitialized members and base classes. */
693 if (!TREE_VALUE (init
)
694 || TREE_CODE (TREE_PURPOSE (init
)) != FIELD_DECL
)
696 /* See if this field is a member of a union, or a member of a
697 structure contained in a union, etc. */
698 field
= TREE_PURPOSE (init
);
699 for (field_type
= DECL_CONTEXT (field
);
700 !same_type_p (field_type
, t
);
701 field_type
= TYPE_CONTEXT (field_type
))
702 if (TREE_CODE (field_type
) == UNION_TYPE
)
704 /* If this field is not a member of a union, skip it. */
705 if (TREE_CODE (field_type
) != UNION_TYPE
)
708 /* It's only an error if we have two initializers for the same
716 /* See if LAST_FIELD and the field initialized by INIT are
717 members of the same union. If so, there's a problem,
718 unless they're actually members of the same structure
719 which is itself a member of a union. For example, given:
721 union { struct { int i; int j; }; };
723 initializing both `i' and `j' makes sense. */
724 field_type
= DECL_CONTEXT (field
);
728 tree last_field_type
;
730 last_field_type
= DECL_CONTEXT (last_field
);
733 if (same_type_p (last_field_type
, field_type
))
735 if (TREE_CODE (field_type
) == UNION_TYPE
)
736 error ("%Jinitializations for multiple members of %qT",
737 current_function_decl
, last_field_type
);
742 if (same_type_p (last_field_type
, t
))
745 last_field_type
= TYPE_CONTEXT (last_field_type
);
748 /* If we've reached the outermost class, then we're
750 if (same_type_p (field_type
, t
))
753 field_type
= TYPE_CONTEXT (field_type
);
764 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
765 is a TREE_LIST giving the explicit mem-initializer-list for the
766 constructor. The TREE_PURPOSE of each entry is a subobject (a
767 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
768 is a TREE_LIST giving the arguments to the constructor or
769 void_type_node for an empty list of arguments. */
772 emit_mem_initializers (tree mem_inits
)
774 /* We will already have issued an error message about the fact that
775 the type is incomplete. */
776 if (!COMPLETE_TYPE_P (current_class_type
))
779 /* Sort the mem-initializers into the order in which the
780 initializations should be performed. */
781 mem_inits
= sort_mem_initializers (current_class_type
, mem_inits
);
783 in_base_initializer
= 1;
785 /* Initialize base classes. */
787 && TREE_CODE (TREE_PURPOSE (mem_inits
)) != FIELD_DECL
)
789 tree subobject
= TREE_PURPOSE (mem_inits
);
790 tree arguments
= TREE_VALUE (mem_inits
);
792 /* If these initializations are taking place in a copy constructor,
793 the base class should probably be explicitly initialized if there
794 is a user-defined constructor in the base class (other than the
795 default constructor, which will be called anyway). */
796 if (extra_warnings
&& !arguments
797 && DECL_COPY_CONSTRUCTOR_P (current_function_decl
)
798 && type_has_user_nondefault_constructor (BINFO_TYPE (subobject
)))
799 warning (OPT_Wextra
, "%Jbase class %q#T should be explicitly initialized in the "
801 current_function_decl
, BINFO_TYPE (subobject
));
803 /* If an explicit -- but empty -- initializer list was present,
804 treat it just like default initialization at this point. */
805 if (arguments
== void_type_node
)
806 arguments
= NULL_TREE
;
808 /* Initialize the base. */
809 if (BINFO_VIRTUAL_P (subobject
))
810 construct_virtual_base (subobject
, arguments
);
815 base_addr
= build_base_path (PLUS_EXPR
, current_class_ptr
,
817 expand_aggr_init_1 (subobject
, NULL_TREE
,
818 cp_build_indirect_ref (base_addr
, NULL
,
819 tf_warning_or_error
),
822 tf_warning_or_error
);
823 expand_cleanup_for_base (subobject
, NULL_TREE
);
826 mem_inits
= TREE_CHAIN (mem_inits
);
828 in_base_initializer
= 0;
830 /* Initialize the vptrs. */
831 initialize_vtbl_ptrs (current_class_ptr
);
833 /* Initialize the data members. */
836 perform_member_init (TREE_PURPOSE (mem_inits
),
837 TREE_VALUE (mem_inits
));
838 mem_inits
= TREE_CHAIN (mem_inits
);
842 /* Returns the address of the vtable (i.e., the value that should be
843 assigned to the vptr) for BINFO. */
846 build_vtbl_address (tree binfo
)
848 tree binfo_for
= binfo
;
851 if (BINFO_VPTR_INDEX (binfo
) && BINFO_VIRTUAL_P (binfo
))
852 /* If this is a virtual primary base, then the vtable we want to store
853 is that for the base this is being used as the primary base of. We
854 can't simply skip the initialization, because we may be expanding the
855 inits of a subobject constructor where the virtual base layout
857 while (BINFO_PRIMARY_P (binfo_for
))
858 binfo_for
= BINFO_INHERITANCE_CHAIN (binfo_for
);
860 /* Figure out what vtable BINFO's vtable is based on, and mark it as
862 vtbl
= get_vtbl_decl_for_binfo (binfo_for
);
863 assemble_external (vtbl
);
864 TREE_USED (vtbl
) = 1;
866 /* Now compute the address to use when initializing the vptr. */
867 vtbl
= unshare_expr (BINFO_VTABLE (binfo_for
));
868 if (TREE_CODE (vtbl
) == VAR_DECL
)
869 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
874 /* This code sets up the virtual function tables appropriate for
875 the pointer DECL. It is a one-ply initialization.
877 BINFO is the exact type that DECL is supposed to be. In
878 multiple inheritance, this might mean "C's A" if C : A, B. */
881 expand_virtual_init (tree binfo
, tree decl
)
886 /* Compute the initializer for vptr. */
887 vtbl
= build_vtbl_address (binfo
);
889 /* We may get this vptr from a VTT, if this is a subobject
890 constructor or subobject destructor. */
891 vtt_index
= BINFO_VPTR_INDEX (binfo
);
897 /* Compute the value to use, when there's a VTT. */
898 vtt_parm
= current_vtt_parm
;
899 vtbl2
= build2 (POINTER_PLUS_EXPR
,
900 TREE_TYPE (vtt_parm
),
903 vtbl2
= cp_build_indirect_ref (vtbl2
, NULL
, tf_warning_or_error
);
904 vtbl2
= convert (TREE_TYPE (vtbl
), vtbl2
);
906 /* The actual initializer is the VTT value only in the subobject
907 constructor. In maybe_clone_body we'll substitute NULL for
908 the vtt_parm in the case of the non-subobject constructor. */
909 vtbl
= build3 (COND_EXPR
,
911 build2 (EQ_EXPR
, boolean_type_node
,
912 current_in_charge_parm
, integer_zero_node
),
917 /* Compute the location of the vtpr. */
918 vtbl_ptr
= build_vfield_ref (cp_build_indirect_ref (decl
, NULL
,
919 tf_warning_or_error
),
921 gcc_assert (vtbl_ptr
!= error_mark_node
);
923 /* Assign the vtable to the vptr. */
924 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0);
925 finish_expr_stmt (cp_build_modify_expr (vtbl_ptr
, NOP_EXPR
, vtbl
,
926 tf_warning_or_error
));
929 /* If an exception is thrown in a constructor, those base classes already
930 constructed must be destroyed. This function creates the cleanup
931 for BINFO, which has just been constructed. If FLAG is non-NULL,
932 it is a DECL which is nonzero when this base needs to be
936 expand_cleanup_for_base (tree binfo
, tree flag
)
940 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo
)))
943 /* Call the destructor. */
944 expr
= build_special_member_call (current_class_ref
,
945 base_dtor_identifier
,
948 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
949 tf_warning_or_error
);
951 expr
= fold_build3 (COND_EXPR
, void_type_node
,
952 c_common_truthvalue_conversion (input_location
, flag
),
953 expr
, integer_zero_node
);
955 finish_eh_cleanup (expr
);
958 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
962 construct_virtual_base (tree vbase
, tree arguments
)
968 /* If there are virtual base classes with destructors, we need to
969 emit cleanups to destroy them if an exception is thrown during
970 the construction process. These exception regions (i.e., the
971 period during which the cleanups must occur) begin from the time
972 the construction is complete to the end of the function. If we
973 create a conditional block in which to initialize the
974 base-classes, then the cleanup region for the virtual base begins
975 inside a block, and ends outside of that block. This situation
976 confuses the sjlj exception-handling code. Therefore, we do not
977 create a single conditional block, but one for each
978 initialization. (That way the cleanup regions always begin
979 in the outer block.) We trust the back end to figure out
980 that the FLAG will not change across initializations, and
981 avoid doing multiple tests. */
982 flag
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
983 inner_if_stmt
= begin_if_stmt ();
984 finish_if_stmt_cond (flag
, inner_if_stmt
);
986 /* Compute the location of the virtual base. If we're
987 constructing virtual bases, then we must be the most derived
988 class. Therefore, we don't have to look up the virtual base;
989 we already know where it is. */
990 exp
= convert_to_base_statically (current_class_ref
, vbase
);
992 expand_aggr_init_1 (vbase
, current_class_ref
, exp
, arguments
,
993 LOOKUP_COMPLAIN
, tf_warning_or_error
);
994 finish_then_clause (inner_if_stmt
);
995 finish_if_stmt (inner_if_stmt
);
997 expand_cleanup_for_base (vbase
, flag
);
1000 /* Find the context in which this FIELD can be initialized. */
1003 initializing_context (tree field
)
1005 tree t
= DECL_CONTEXT (field
);
1007 /* Anonymous union members can be initialized in the first enclosing
1008 non-anonymous union context. */
1009 while (t
&& ANON_AGGR_TYPE_P (t
))
1010 t
= TYPE_CONTEXT (t
);
1014 /* Function to give error message if member initialization specification
1015 is erroneous. FIELD is the member we decided to initialize.
1016 TYPE is the type for which the initialization is being performed.
1017 FIELD must be a member of TYPE.
1019 MEMBER_NAME is the name of the member. */
1022 member_init_ok_or_else (tree field
, tree type
, tree member_name
)
1024 if (field
== error_mark_node
)
1028 error ("class %qT does not have any field named %qD", type
,
1032 if (TREE_CODE (field
) == VAR_DECL
)
1034 error ("%q#D is a static data member; it can only be "
1035 "initialized at its definition",
1039 if (TREE_CODE (field
) != FIELD_DECL
)
1041 error ("%q#D is not a non-static data member of %qT",
1045 if (initializing_context (field
) != type
)
1047 error ("class %qT does not have any field named %qD", type
,
1055 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1056 is a _TYPE node or TYPE_DECL which names a base for that type.
1057 Check the validity of NAME, and return either the base _TYPE, base
1058 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
1059 NULL_TREE and issue a diagnostic.
1061 An old style unnamed direct single base construction is permitted,
1062 where NAME is NULL. */
1065 expand_member_init (tree name
)
1070 if (!current_class_ref
)
1075 /* This is an obsolete unnamed base class initializer. The
1076 parser will already have warned about its use. */
1077 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type
)))
1080 error ("unnamed initializer for %qT, which has no base classes",
1081 current_class_type
);
1084 basetype
= BINFO_TYPE
1085 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type
), 0));
1088 error ("unnamed initializer for %qT, which uses multiple inheritance",
1089 current_class_type
);
1093 else if (TYPE_P (name
))
1095 basetype
= TYPE_MAIN_VARIANT (name
);
1096 name
= TYPE_NAME (name
);
1098 else if (TREE_CODE (name
) == TYPE_DECL
)
1099 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (name
));
1101 basetype
= NULL_TREE
;
1110 if (current_template_parms
)
1113 class_binfo
= TYPE_BINFO (current_class_type
);
1114 direct_binfo
= NULL_TREE
;
1115 virtual_binfo
= NULL_TREE
;
1117 /* Look for a direct base. */
1118 for (i
= 0; BINFO_BASE_ITERATE (class_binfo
, i
, direct_binfo
); ++i
)
1119 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo
), basetype
))
1122 /* Look for a virtual base -- unless the direct base is itself
1124 if (!direct_binfo
|| !BINFO_VIRTUAL_P (direct_binfo
))
1125 virtual_binfo
= binfo_for_vbase (basetype
, current_class_type
);
1127 /* [class.base.init]
1129 If a mem-initializer-id is ambiguous because it designates
1130 both a direct non-virtual base class and an inherited virtual
1131 base class, the mem-initializer is ill-formed. */
1132 if (direct_binfo
&& virtual_binfo
)
1134 error ("%qD is both a direct base and an indirect virtual base",
1139 if (!direct_binfo
&& !virtual_binfo
)
1141 if (CLASSTYPE_VBASECLASSES (current_class_type
))
1142 error ("type %qT is not a direct or virtual base of %qT",
1143 basetype
, current_class_type
);
1145 error ("type %qT is not a direct base of %qT",
1146 basetype
, current_class_type
);
1150 return direct_binfo
? direct_binfo
: virtual_binfo
;
1154 if (TREE_CODE (name
) == IDENTIFIER_NODE
)
1155 field
= lookup_field (current_class_type
, name
, 1, false);
1159 if (member_init_ok_or_else (field
, current_class_type
, name
))
1166 /* This is like `expand_member_init', only it stores one aggregate
1169 INIT comes in two flavors: it is either a value which
1170 is to be stored in EXP, or it is a parameter list
1171 to go to a constructor, which will operate on EXP.
1172 If INIT is not a parameter list for a constructor, then set
1173 LOOKUP_ONLYCONVERTING.
1174 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1175 the initializer, if FLAGS is 0, then it is the (init) form.
1176 If `init' is a CONSTRUCTOR, then we emit a warning message,
1177 explaining that such initializations are invalid.
1179 If INIT resolves to a CALL_EXPR which happens to return
1180 something of the type we are looking for, then we know
1181 that we can safely use that call to perform the
1184 The virtual function table pointer cannot be set up here, because
1185 we do not really know its type.
1187 This never calls operator=().
1189 When initializing, nothing is CONST.
1191 A default copy constructor may have to be used to perform the
1194 A constructor or a conversion operator may have to be used to
1195 perform the initialization, but not both, as it would be ambiguous. */
1198 build_aggr_init (tree exp
, tree init
, int flags
, tsubst_flags_t complain
)
1203 tree type
= TREE_TYPE (exp
);
1204 int was_const
= TREE_READONLY (exp
);
1205 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1208 if (init
== error_mark_node
)
1209 return error_mark_node
;
1211 TREE_READONLY (exp
) = 0;
1212 TREE_THIS_VOLATILE (exp
) = 0;
1214 if (init
&& TREE_CODE (init
) != TREE_LIST
)
1215 flags
|= LOOKUP_ONLYCONVERTING
;
1217 if (TREE_CODE (type
) == ARRAY_TYPE
)
1221 /* An array may not be initialized use the parenthesized
1222 initialization form -- unless the initializer is "()". */
1223 if (init
&& TREE_CODE (init
) == TREE_LIST
)
1225 if (complain
& tf_error
)
1226 error ("bad array initializer");
1227 return error_mark_node
;
1229 /* Must arrange to initialize each element of EXP
1230 from elements of INIT. */
1231 itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1232 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
1233 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1234 if (itype
&& cp_type_quals (itype
) != TYPE_UNQUALIFIED
)
1235 itype
= TREE_TYPE (init
) = TYPE_MAIN_VARIANT (itype
);
1236 stmt_expr
= build_vec_init (exp
, NULL_TREE
, init
,
1237 /*explicit_value_init_p=*/false,
1238 itype
&& same_type_p (itype
,
1241 TREE_READONLY (exp
) = was_const
;
1242 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1243 TREE_TYPE (exp
) = type
;
1245 TREE_TYPE (init
) = itype
;
1249 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1250 /* Just know that we've seen something for this node. */
1251 TREE_USED (exp
) = 1;
1253 is_global
= begin_init_stmts (&stmt_expr
, &compound_stmt
);
1254 destroy_temps
= stmts_are_full_exprs_p ();
1255 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
1256 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1257 init
, LOOKUP_NORMAL
|flags
, complain
);
1258 stmt_expr
= finish_init_stmts (is_global
, stmt_expr
, compound_stmt
);
1259 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
1260 TREE_READONLY (exp
) = was_const
;
1261 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1267 expand_default_init (tree binfo
, tree true_exp
, tree exp
, tree init
, int flags
,
1268 tsubst_flags_t complain
)
1270 tree type
= TREE_TYPE (exp
);
1273 /* It fails because there may not be a constructor which takes
1274 its own type as the first (or only parameter), but which does
1275 take other types via a conversion. So, if the thing initializing
1276 the expression is a unit element of type X, first try X(X&),
1277 followed by initialization by X. If neither of these work
1278 out, then look hard. */
1282 if (init
&& TREE_CODE (init
) != TREE_LIST
1283 && (flags
& LOOKUP_ONLYCONVERTING
))
1285 /* Base subobjects should only get direct-initialization. */
1286 gcc_assert (true_exp
== exp
);
1288 if (flags
& DIRECT_BIND
)
1289 /* Do nothing. We hit this in two cases: Reference initialization,
1290 where we aren't initializing a real variable, so we don't want
1291 to run a new constructor; and catching an exception, where we
1292 have already built up the constructor call so we could wrap it
1293 in an exception region. */;
1294 else if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1295 && CP_AGGREGATE_TYPE_P (type
))
1297 /* A brace-enclosed initializer for an aggregate. */
1298 init
= digest_init (type
, init
);
1301 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
1303 if (TREE_CODE (init
) == MUST_NOT_THROW_EXPR
)
1304 /* We need to protect the initialization of a catch parm with a
1305 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1306 around the TARGET_EXPR for the copy constructor. See
1307 initialize_handler_parm. */
1309 TREE_OPERAND (init
, 0) = build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
,
1310 TREE_OPERAND (init
, 0));
1311 TREE_TYPE (init
) = void_type_node
;
1314 init
= build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1315 TREE_SIDE_EFFECTS (init
) = 1;
1316 finish_expr_stmt (init
);
1320 if (init
== NULL_TREE
1321 || (TREE_CODE (init
) == TREE_LIST
&& ! TREE_TYPE (init
)))
1325 init
= TREE_VALUE (parms
);
1328 parms
= build_tree_list (NULL_TREE
, init
);
1330 if (true_exp
== exp
)
1331 ctor_name
= complete_ctor_identifier
;
1333 ctor_name
= base_ctor_identifier
;
1335 rval
= build_special_member_call (exp
, ctor_name
, parms
, binfo
, flags
,
1337 if (TREE_SIDE_EFFECTS (rval
))
1338 finish_expr_stmt (convert_to_void (rval
, NULL
, complain
));
1341 /* This function is responsible for initializing EXP with INIT
1344 BINFO is the binfo of the type for who we are performing the
1345 initialization. For example, if W is a virtual base class of A and B,
1347 If we are initializing B, then W must contain B's W vtable, whereas
1348 were we initializing C, W must contain C's W vtable.
1350 TRUE_EXP is nonzero if it is the true expression being initialized.
1351 In this case, it may be EXP, or may just contain EXP. The reason we
1352 need this is because if EXP is a base element of TRUE_EXP, we
1353 don't necessarily know by looking at EXP where its virtual
1354 baseclass fields should really be pointing. But we do know
1355 from TRUE_EXP. In constructors, we don't know anything about
1356 the value being initialized.
1358 FLAGS is just passed to `build_new_method_call'. See that function
1359 for its description. */
1362 expand_aggr_init_1 (tree binfo
, tree true_exp
, tree exp
, tree init
, int flags
,
1363 tsubst_flags_t complain
)
1365 tree type
= TREE_TYPE (exp
);
1367 gcc_assert (init
!= error_mark_node
&& type
!= error_mark_node
);
1368 gcc_assert (building_stmt_tree ());
1370 /* Use a function returning the desired type to initialize EXP for us.
1371 If the function is a constructor, and its first argument is
1372 NULL_TREE, know that it was meant for us--just slide exp on
1373 in and expand the constructor. Constructors now come
1376 if (init
&& TREE_CODE (exp
) == VAR_DECL
1377 && COMPOUND_LITERAL_P (init
))
1379 /* If store_init_value returns NULL_TREE, the INIT has been
1380 recorded as the DECL_INITIAL for EXP. That means there's
1381 nothing more we have to do. */
1382 init
= store_init_value (exp
, init
);
1384 finish_expr_stmt (init
);
1388 /* We know that expand_default_init can handle everything we want
1390 expand_default_init (binfo
, true_exp
, exp
, init
, flags
, complain
);
1393 /* Report an error if TYPE is not a user-defined, class type. If
1394 OR_ELSE is nonzero, give an error message. */
1397 is_class_type (tree type
, int or_else
)
1399 if (type
== error_mark_node
)
1402 if (! CLASS_TYPE_P (type
))
1405 error ("%qT is not a class type", type
);
1412 get_type_value (tree name
)
1414 if (name
== error_mark_node
)
1417 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1418 return IDENTIFIER_TYPE_VALUE (name
);
1423 /* Build a reference to a member of an aggregate. This is not a C++
1424 `&', but really something which can have its address taken, and
1425 then act as a pointer to member, for example TYPE :: FIELD can have
1426 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
1427 this expression is the operand of "&".
1429 @@ Prints out lousy diagnostics for operator <typename>
1432 @@ This function should be rewritten and placed in search.c. */
1435 build_offset_ref (tree type
, tree member
, bool address_p
)
1438 tree basebinfo
= NULL_TREE
;
1440 /* class templates can come in as TEMPLATE_DECLs here. */
1441 if (TREE_CODE (member
) == TEMPLATE_DECL
)
1444 if (dependent_type_p (type
) || type_dependent_expression_p (member
))
1445 return build_qualified_name (NULL_TREE
, type
, member
,
1446 /*template_p=*/false);
1448 gcc_assert (TYPE_P (type
));
1449 if (! is_class_type (type
, 1))
1450 return error_mark_node
;
1452 gcc_assert (DECL_P (member
) || BASELINK_P (member
));
1453 /* Callers should call mark_used before this point. */
1454 gcc_assert (!DECL_P (member
) || TREE_USED (member
));
1456 if (!COMPLETE_TYPE_P (complete_type (type
))
1457 && !TYPE_BEING_DEFINED (type
))
1459 error ("incomplete type %qT does not have member %qD", type
, member
);
1460 return error_mark_node
;
1463 /* Entities other than non-static members need no further
1465 if (TREE_CODE (member
) == TYPE_DECL
)
1467 if (TREE_CODE (member
) == VAR_DECL
|| TREE_CODE (member
) == CONST_DECL
)
1468 return convert_from_reference (member
);
1470 if (TREE_CODE (member
) == FIELD_DECL
&& DECL_C_BIT_FIELD (member
))
1472 error ("invalid pointer to bit-field %qD", member
);
1473 return error_mark_node
;
1476 /* Set up BASEBINFO for member lookup. */
1477 decl
= maybe_dummy_object (type
, &basebinfo
);
1479 /* A lot of this logic is now handled in lookup_member. */
1480 if (BASELINK_P (member
))
1482 /* Go from the TREE_BASELINK to the member function info. */
1483 tree t
= BASELINK_FUNCTIONS (member
);
1485 if (TREE_CODE (t
) != TEMPLATE_ID_EXPR
&& !really_overloaded_fn (t
))
1487 /* Get rid of a potential OVERLOAD around it. */
1488 t
= OVL_CURRENT (t
);
1490 /* Unique functions are handled easily. */
1492 /* For non-static member of base class, we need a special rule
1493 for access checking [class.protected]:
1495 If the access is to form a pointer to member, the
1496 nested-name-specifier shall name the derived class
1497 (or any class derived from that class). */
1498 if (address_p
&& DECL_P (t
)
1499 && DECL_NONSTATIC_MEMBER_P (t
))
1500 perform_or_defer_access_check (TYPE_BINFO (type
), t
, t
);
1502 perform_or_defer_access_check (basebinfo
, t
, t
);
1504 if (DECL_STATIC_FUNCTION_P (t
))
1509 TREE_TYPE (member
) = unknown_type_node
;
1511 else if (address_p
&& TREE_CODE (member
) == FIELD_DECL
)
1512 /* We need additional test besides the one in
1513 check_accessibility_of_qualified_id in case it is
1514 a pointer to non-static member. */
1515 perform_or_defer_access_check (TYPE_BINFO (type
), member
, member
);
1519 /* If MEMBER is non-static, then the program has fallen afoul of
1522 An id-expression that denotes a nonstatic data member or
1523 nonstatic member function of a class can only be used:
1525 -- as part of a class member access (_expr.ref_) in which the
1526 object-expression refers to the member's class or a class
1527 derived from that class, or
1529 -- to form a pointer to member (_expr.unary.op_), or
1531 -- in the body of a nonstatic member function of that class or
1532 of a class derived from that class (_class.mfct.nonstatic_), or
1534 -- in a mem-initializer for a constructor for that class or for
1535 a class derived from that class (_class.base.init_). */
1536 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member
))
1538 /* Build a representation of the qualified name suitable
1539 for use as the operand to "&" -- even though the "&" is
1540 not actually present. */
1541 member
= build2 (OFFSET_REF
, TREE_TYPE (member
), decl
, member
);
1542 /* In Microsoft mode, treat a non-static member function as if
1543 it were a pointer-to-member. */
1544 if (flag_ms_extensions
)
1546 PTRMEM_OK_P (member
) = 1;
1547 return cp_build_unary_op (ADDR_EXPR
, member
, 0,
1548 tf_warning_or_error
);
1550 error ("invalid use of non-static member function %qD",
1551 TREE_OPERAND (member
, 1));
1552 return error_mark_node
;
1554 else if (TREE_CODE (member
) == FIELD_DECL
)
1556 error ("invalid use of non-static data member %qD", member
);
1557 return error_mark_node
;
1562 member
= build2 (OFFSET_REF
, TREE_TYPE (member
), decl
, member
);
1563 PTRMEM_OK_P (member
) = 1;
1567 /* If DECL is a scalar enumeration constant or variable with a
1568 constant initializer, return the initializer (or, its initializers,
1569 recursively); otherwise, return DECL. If INTEGRAL_P, the
1570 initializer is only returned if DECL is an integral
1571 constant-expression. */
1574 constant_value_1 (tree decl
, bool integral_p
)
1576 while (TREE_CODE (decl
) == CONST_DECL
1578 ? DECL_INTEGRAL_CONSTANT_VAR_P (decl
)
1579 : (TREE_CODE (decl
) == VAR_DECL
1580 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl
)))))
1583 /* Static data members in template classes may have
1584 non-dependent initializers. References to such non-static
1585 data members are not value-dependent, so we must retrieve the
1586 initializer here. The DECL_INITIAL will have the right type,
1587 but will not have been folded because that would prevent us
1588 from performing all appropriate semantic checks at
1589 instantiation time. */
1590 if (DECL_CLASS_SCOPE_P (decl
)
1591 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
1592 && uses_template_parms (CLASSTYPE_TI_ARGS
1593 (DECL_CONTEXT (decl
))))
1595 ++processing_template_decl
;
1596 init
= fold_non_dependent_expr (DECL_INITIAL (decl
));
1597 --processing_template_decl
;
1601 /* If DECL is a static data member in a template
1602 specialization, we must instantiate it here. The
1603 initializer for the static data member is not processed
1604 until needed; we need it now. */
1606 init
= DECL_INITIAL (decl
);
1608 if (init
== error_mark_node
)
1610 /* Initializers in templates are generally expanded during
1611 instantiation, so before that for const int i(2)
1612 INIT is a TREE_LIST with the actual initializer as
1614 if (processing_template_decl
1616 && TREE_CODE (init
) == TREE_LIST
1617 && TREE_CHAIN (init
) == NULL_TREE
)
1618 init
= TREE_VALUE (init
);
1620 || !TREE_TYPE (init
)
1622 ? !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (init
))
1623 : (!TREE_CONSTANT (init
)
1624 /* Do not return an aggregate constant (of which
1625 string literals are a special case), as we do not
1626 want to make inadvertent copies of such entities,
1627 and we must be sure that their addresses are the
1629 || TREE_CODE (init
) == CONSTRUCTOR
1630 || TREE_CODE (init
) == STRING_CST
)))
1632 decl
= unshare_expr (init
);
1637 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1638 constant of integral or enumeration type, then return that value.
1639 These are those variables permitted in constant expressions by
1643 integral_constant_value (tree decl
)
1645 return constant_value_1 (decl
, /*integral_p=*/true);
1648 /* A more relaxed version of integral_constant_value, used by the
1649 common C/C++ code and by the C++ front end for optimization
1653 decl_constant_value (tree decl
)
1655 return constant_value_1 (decl
,
1656 /*integral_p=*/processing_template_decl
);
1659 /* Common subroutines of build_new and build_vec_delete. */
1661 /* Call the global __builtin_delete to delete ADDR. */
1664 build_builtin_delete_call (tree addr
)
1666 mark_used (global_delete_fndecl
);
1667 return build_call_n (global_delete_fndecl
, 1, addr
);
1670 /* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
1671 the type of the object being allocated; otherwise, it's just TYPE.
1672 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
1673 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
1674 the TREE_LIST of arguments to be provided as arguments to a
1675 placement new operator. This routine performs no semantic checks;
1676 it just creates and returns a NEW_EXPR. */
1679 build_raw_new_expr (tree placement
, tree type
, tree nelts
, tree init
,
1684 new_expr
= build4 (NEW_EXPR
, build_pointer_type (type
), placement
, type
,
1686 NEW_EXPR_USE_GLOBAL (new_expr
) = use_global_new
;
1687 TREE_SIDE_EFFECTS (new_expr
) = 1;
1692 /* Make sure that there are no aliasing issues with T, a placement new
1693 expression applied to PLACEMENT, by recording the change in dynamic
1694 type. If placement new is inlined, as it is with libstdc++, and if
1695 the type of the placement new differs from the type of the
1696 placement location itself, then alias analysis may think it is OK
1697 to interchange writes to the location from before the placement new
1698 and from after the placement new. We have to prevent type-based
1699 alias analysis from applying. PLACEMENT may be NULL, which means
1700 that we couldn't capture it in a temporary variable, in which case
1701 we use a memory clobber. */
1704 avoid_placement_new_aliasing (tree t
, tree placement
)
1708 if (processing_template_decl
)
1711 /* If we are not using type based aliasing, we don't have to do
1713 if (!flag_strict_aliasing
)
1716 /* If we have a pointer and a location, record the change in dynamic
1717 type. Otherwise we need a general memory clobber. */
1718 if (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
1719 && placement
!= NULL_TREE
1720 && TREE_CODE (TREE_TYPE (placement
)) == POINTER_TYPE
)
1721 type_change
= build_stmt (CHANGE_DYNAMIC_TYPE_EXPR
,
1726 /* Build a memory clobber. */
1727 type_change
= build_stmt (ASM_EXPR
,
1728 build_string (0, ""),
1731 tree_cons (NULL_TREE
,
1732 build_string (6, "memory"),
1735 ASM_VOLATILE_P (type_change
) = 1;
1738 return build2 (COMPOUND_EXPR
, TREE_TYPE (t
), type_change
, t
);
1741 /* Generate code for a new-expression, including calling the "operator
1742 new" function, initializing the object, and, if an exception occurs
1743 during construction, cleaning up. The arguments are as for
1744 build_raw_new_expr. */
1747 build_new_1 (tree placement
, tree type
, tree nelts
, tree init
,
1748 bool globally_qualified_p
, tsubst_flags_t complain
)
1751 /* True iff this is a call to "operator new[]" instead of just
1753 bool array_p
= false;
1754 /* True iff ARRAY_P is true and the bound of the array type is
1755 not necessarily a compile time constant. For example, VLA_P is
1756 true for "new int[f()]". */
1758 /* The type being allocated. If ARRAY_P is true, this will be an
1761 /* If ARRAY_P is true, the element type of the array. This is an
1762 never ARRAY_TYPE; for something like "new int[3][4]", the
1763 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
1766 /* The type of the new-expression. (This type is always a pointer
1769 /* A pointer type pointing to the FULL_TYPE. */
1770 tree full_pointer_type
;
1771 tree outer_nelts
= NULL_TREE
;
1772 tree alloc_call
, alloc_expr
;
1773 /* The address returned by the call to "operator new". This node is
1774 a VAR_DECL and is therefore reusable. */
1777 tree cookie_expr
, init_expr
;
1778 int nothrow
, check_new
;
1779 int use_java_new
= 0;
1780 /* If non-NULL, the number of extra bytes to allocate at the
1781 beginning of the storage allocated for an array-new expression in
1782 order to store the number of elements. */
1783 tree cookie_size
= NULL_TREE
;
1784 tree placement_expr
= NULL_TREE
;
1785 /* True if the function we are calling is a placement allocation
1787 bool placement_allocation_fn_p
;
1788 tree args
= NULL_TREE
;
1789 /* True if the storage must be initialized, either by a constructor
1790 or due to an explicit new-initializer. */
1791 bool is_initialized
;
1792 /* The address of the thing allocated, not including any cookie. In
1793 particular, if an array cookie is in use, DATA_ADDR is the
1794 address of the first array element. This node is a VAR_DECL, and
1795 is therefore reusable. */
1797 tree init_preeval_expr
= NULL_TREE
;
1803 outer_nelts
= nelts
;
1806 /* ??? The middle-end will error on us for building a VLA outside a
1807 function context. Methinks that's not it's purvey. So we'll do
1808 our own VLA layout later. */
1810 index
= convert (sizetype
, nelts
);
1811 index
= size_binop (MINUS_EXPR
, index
, size_one_node
);
1812 index
= build_index_type (index
);
1813 full_type
= build_cplus_array_type (type
, NULL_TREE
);
1814 /* We need a copy of the type as build_array_type will return a shared copy
1815 of the incomplete array type. */
1816 full_type
= build_distinct_type_copy (full_type
);
1817 TYPE_DOMAIN (full_type
) = index
;
1818 SET_TYPE_STRUCTURAL_EQUALITY (full_type
);
1823 if (TREE_CODE (type
) == ARRAY_TYPE
)
1826 nelts
= array_type_nelts_top (type
);
1827 outer_nelts
= nelts
;
1828 type
= TREE_TYPE (type
);
1832 /* If our base type is an array, then make sure we know how many elements
1834 for (elt_type
= type
;
1835 TREE_CODE (elt_type
) == ARRAY_TYPE
;
1836 elt_type
= TREE_TYPE (elt_type
))
1837 nelts
= cp_build_binary_op (input_location
,
1839 array_type_nelts_top (elt_type
),
1842 if (TREE_CODE (elt_type
) == VOID_TYPE
)
1844 if (complain
& tf_error
)
1845 error ("invalid type %<void%> for new");
1846 return error_mark_node
;
1849 if (abstract_virtuals_error (NULL_TREE
, elt_type
))
1850 return error_mark_node
;
1852 is_initialized
= (TYPE_NEEDS_CONSTRUCTING (elt_type
) || init
);
1854 if (CP_TYPE_CONST_P (elt_type
) && !init
1855 && !type_has_user_provided_default_constructor (elt_type
))
1857 if (complain
& tf_error
)
1858 error ("uninitialized const in %<new%> of %q#T", elt_type
);
1859 return error_mark_node
;
1862 size
= size_in_bytes (elt_type
);
1865 size
= size_binop (MULT_EXPR
, size
, convert (sizetype
, nelts
));
1870 /* Do our own VLA layout. Setting TYPE_SIZE/_UNIT is
1871 necessary in order for the <INIT_EXPR <*foo> <CONSTRUCTOR
1872 ...>> to be valid. */
1873 TYPE_SIZE_UNIT (full_type
) = size
;
1874 n
= convert (bitsizetype
, nelts
);
1875 bitsize
= size_binop (MULT_EXPR
, TYPE_SIZE (elt_type
), n
);
1876 TYPE_SIZE (full_type
) = bitsize
;
1880 alloc_fn
= NULL_TREE
;
1882 /* Allocate the object. */
1883 if (! placement
&& TYPE_FOR_JAVA (elt_type
))
1886 tree class_decl
= build_java_class_ref (elt_type
);
1887 static const char alloc_name
[] = "_Jv_AllocObject";
1889 if (class_decl
== error_mark_node
)
1890 return error_mark_node
;
1893 if (!get_global_value_if_present (get_identifier (alloc_name
),
1896 if (complain
& tf_error
)
1897 error ("call to Java constructor with %qs undefined", alloc_name
);
1898 return error_mark_node
;
1900 else if (really_overloaded_fn (alloc_fn
))
1902 if (complain
& tf_error
)
1903 error ("%qD should never be overloaded", alloc_fn
);
1904 return error_mark_node
;
1906 alloc_fn
= OVL_CURRENT (alloc_fn
);
1907 class_addr
= build1 (ADDR_EXPR
, jclass_node
, class_decl
);
1908 alloc_call
= (cp_build_function_call
1910 build_tree_list (NULL_TREE
, class_addr
),
1913 else if (TYPE_FOR_JAVA (elt_type
) && MAYBE_CLASS_TYPE_P (elt_type
))
1915 error ("Java class %q#T object allocated using placement new", elt_type
);
1916 return error_mark_node
;
1923 fnname
= ansi_opname (array_p
? VEC_NEW_EXPR
: NEW_EXPR
);
1925 if (!globally_qualified_p
1926 && CLASS_TYPE_P (elt_type
)
1928 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type
)
1929 : TYPE_HAS_NEW_OPERATOR (elt_type
)))
1931 /* Use a class-specific operator new. */
1932 /* If a cookie is required, add some extra space. */
1933 if (array_p
&& TYPE_VEC_NEW_USES_COOKIE (elt_type
))
1935 cookie_size
= targetm
.cxx
.get_cookie_size (elt_type
);
1936 size
= size_binop (PLUS_EXPR
, size
, cookie_size
);
1938 /* Create the argument list. */
1939 args
= tree_cons (NULL_TREE
, size
, placement
);
1940 /* Do name-lookup to find the appropriate operator. */
1941 fns
= lookup_fnfields (elt_type
, fnname
, /*protect=*/2);
1942 if (fns
== NULL_TREE
)
1944 if (complain
& tf_error
)
1945 error ("no suitable %qD found in class %qT", fnname
, elt_type
);
1946 return error_mark_node
;
1948 if (TREE_CODE (fns
) == TREE_LIST
)
1950 if (complain
& tf_error
)
1952 error ("request for member %qD is ambiguous", fnname
);
1953 print_candidates (fns
);
1955 return error_mark_node
;
1957 alloc_call
= build_new_method_call (build_dummy_object (elt_type
),
1959 /*conversion_path=*/NULL_TREE
,
1966 /* Use a global operator new. */
1967 /* See if a cookie might be required. */
1968 if (array_p
&& TYPE_VEC_NEW_USES_COOKIE (elt_type
))
1969 cookie_size
= targetm
.cxx
.get_cookie_size (elt_type
);
1971 cookie_size
= NULL_TREE
;
1973 alloc_call
= build_operator_new_call (fnname
, placement
,
1974 &size
, &cookie_size
,
1979 if (alloc_call
== error_mark_node
)
1980 return error_mark_node
;
1982 gcc_assert (alloc_fn
!= NULL_TREE
);
1984 /* If PLACEMENT is a simple pointer type and is not passed by reference,
1985 then copy it into PLACEMENT_EXPR. */
1986 if (!processing_template_decl
1987 && placement
!= NULL_TREE
1988 && TREE_CHAIN (placement
) == NULL_TREE
1989 && TREE_CODE (TREE_TYPE (TREE_VALUE (placement
))) == POINTER_TYPE
1990 && TREE_CODE (alloc_call
) == CALL_EXPR
1991 && call_expr_nargs (alloc_call
) == 2
1992 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 0))) == INTEGER_TYPE
1993 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 1))) == POINTER_TYPE
)
1995 tree placement_arg
= CALL_EXPR_ARG (alloc_call
, 1);
1997 if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg
)))
1998 || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg
))))
2000 placement_expr
= get_target_expr (TREE_VALUE (placement
));
2001 CALL_EXPR_ARG (alloc_call
, 1)
2002 = convert (TREE_TYPE (placement_arg
), placement_expr
);
2006 /* In the simple case, we can stop now. */
2007 pointer_type
= build_pointer_type (type
);
2008 if (!cookie_size
&& !is_initialized
)
2010 rval
= build_nop (pointer_type
, alloc_call
);
2011 if (placement
!= NULL
)
2012 rval
= avoid_placement_new_aliasing (rval
, placement_expr
);
2016 /* Store the result of the allocation call in a variable so that we can
2017 use it more than once. */
2018 alloc_expr
= get_target_expr (alloc_call
);
2019 alloc_node
= TARGET_EXPR_SLOT (alloc_expr
);
2021 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
2022 while (TREE_CODE (alloc_call
) == COMPOUND_EXPR
)
2023 alloc_call
= TREE_OPERAND (alloc_call
, 1);
2025 /* Now, check to see if this function is actually a placement
2026 allocation function. This can happen even when PLACEMENT is NULL
2027 because we might have something like:
2029 struct S { void* operator new (size_t, int i = 0); };
2031 A call to `new S' will get this allocation function, even though
2032 there is no explicit placement argument. If there is more than
2033 one argument, or there are variable arguments, then this is a
2034 placement allocation function. */
2035 placement_allocation_fn_p
2036 = (type_num_arguments (TREE_TYPE (alloc_fn
)) > 1
2037 || varargs_function_p (alloc_fn
));
2039 /* Preevaluate the placement args so that we don't reevaluate them for a
2040 placement delete. */
2041 if (placement_allocation_fn_p
)
2044 stabilize_call (alloc_call
, &inits
);
2046 alloc_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (alloc_expr
), inits
,
2050 /* unless an allocation function is declared with an empty excep-
2051 tion-specification (_except.spec_), throw(), it indicates failure to
2052 allocate storage by throwing a bad_alloc exception (clause _except_,
2053 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2054 cation function is declared with an empty exception-specification,
2055 throw(), it returns null to indicate failure to allocate storage and a
2056 non-null pointer otherwise.
2058 So check for a null exception spec on the op new we just called. */
2060 nothrow
= TYPE_NOTHROW_P (TREE_TYPE (alloc_fn
));
2061 check_new
= (flag_check_new
|| nothrow
) && ! use_java_new
;
2069 /* Adjust so we're pointing to the start of the object. */
2070 data_addr
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (alloc_node
),
2071 alloc_node
, cookie_size
);
2073 /* Store the number of bytes allocated so that we can know how
2074 many elements to destroy later. We use the last sizeof
2075 (size_t) bytes to store the number of elements. */
2076 cookie_ptr
= size_binop (MINUS_EXPR
, cookie_size
, size_in_bytes (sizetype
));
2077 cookie_ptr
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (alloc_node
),
2078 alloc_node
, cookie_ptr
);
2079 size_ptr_type
= build_pointer_type (sizetype
);
2080 cookie_ptr
= fold_convert (size_ptr_type
, cookie_ptr
);
2081 cookie
= cp_build_indirect_ref (cookie_ptr
, NULL
, complain
);
2083 cookie_expr
= build2 (MODIFY_EXPR
, sizetype
, cookie
, nelts
);
2085 if (targetm
.cxx
.cookie_has_size ())
2087 /* Also store the element size. */
2088 cookie_ptr
= build2 (POINTER_PLUS_EXPR
, size_ptr_type
, cookie_ptr
,
2089 fold_build1 (NEGATE_EXPR
, sizetype
,
2090 size_in_bytes (sizetype
)));
2092 cookie
= cp_build_indirect_ref (cookie_ptr
, NULL
, complain
);
2093 cookie
= build2 (MODIFY_EXPR
, sizetype
, cookie
,
2094 size_in_bytes (elt_type
));
2095 cookie_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (cookie_expr
),
2096 cookie
, cookie_expr
);
2101 cookie_expr
= NULL_TREE
;
2102 data_addr
= alloc_node
;
2105 /* Now use a pointer to the type we've actually allocated. */
2106 full_pointer_type
= build_pointer_type (full_type
);
2107 data_addr
= fold_convert (full_pointer_type
, data_addr
);
2109 /* Now initialize the allocated object. Note that we preevaluate the
2110 initialization expression, apart from the actual constructor call or
2111 assignment--we do this because we want to delay the allocation as long
2112 as possible in order to minimize the size of the exception region for
2113 placement delete. */
2117 bool explicit_value_init_p
= false;
2119 init_expr
= cp_build_indirect_ref (data_addr
, NULL
, complain
);
2121 if (init
== void_zero_node
)
2124 explicit_value_init_p
= true;
2131 if (complain
& tf_error
)
2132 permerror (input_location
, "ISO C++ forbids initialization in array new");
2134 return error_mark_node
;
2137 = build_vec_init (init_expr
,
2138 cp_build_binary_op (input_location
,
2139 MINUS_EXPR
, outer_nelts
,
2143 explicit_value_init_p
,
2147 /* An array initialization is stable because the initialization
2148 of each element is a full-expression, so the temporaries don't
2154 if (TYPE_NEEDS_CONSTRUCTING (type
) && !explicit_value_init_p
)
2156 init_expr
= build_special_member_call (init_expr
,
2157 complete_ctor_identifier
,
2162 else if (explicit_value_init_p
)
2164 /* Something like `new int()'. */
2165 init_expr
= build2 (INIT_EXPR
, full_type
,
2166 init_expr
, build_value_init (full_type
));
2170 /* We are processing something like `new int (10)', which
2171 means allocate an int, and initialize it with 10. */
2173 if (TREE_CODE (init
) == TREE_LIST
)
2174 init
= build_x_compound_expr_from_list (init
,
2177 gcc_assert (TREE_CODE (init
) != CONSTRUCTOR
2178 || TREE_TYPE (init
) != NULL_TREE
);
2180 init_expr
= cp_build_modify_expr (init_expr
, INIT_EXPR
, init
,
2183 stable
= stabilize_init (init_expr
, &init_preeval_expr
);
2186 if (init_expr
== error_mark_node
)
2187 return error_mark_node
;
2189 /* If any part of the object initialization terminates by throwing an
2190 exception and a suitable deallocation function can be found, the
2191 deallocation function is called to free the memory in which the
2192 object was being constructed, after which the exception continues
2193 to propagate in the context of the new-expression. If no
2194 unambiguous matching deallocation function can be found,
2195 propagating the exception does not cause the object's memory to be
2197 if (flag_exceptions
&& ! use_java_new
)
2199 enum tree_code dcode
= array_p
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2202 /* The Standard is unclear here, but the right thing to do
2203 is to use the same method for finding deallocation
2204 functions that we use for finding allocation functions. */
2205 cleanup
= (build_op_delete_call
2207 fold_convert (full_pointer_type
, alloc_node
),
2209 globally_qualified_p
,
2210 placement_allocation_fn_p
? alloc_call
: NULL_TREE
,
2216 /* This is much simpler if we were able to preevaluate all of
2217 the arguments to the constructor call. */
2218 init_expr
= build2 (TRY_CATCH_EXPR
, void_type_node
,
2219 init_expr
, cleanup
);
2221 /* Ack! First we allocate the memory. Then we set our sentry
2222 variable to true, and expand a cleanup that deletes the
2223 memory if sentry is true. Then we run the constructor, and
2224 finally clear the sentry.
2226 We need to do this because we allocate the space first, so
2227 if there are any temporaries with cleanups in the
2228 constructor args and we weren't able to preevaluate them, we
2229 need this EH region to extend until end of full-expression
2230 to preserve nesting. */
2232 tree end
, sentry
, begin
;
2234 begin
= get_target_expr (boolean_true_node
);
2235 CLEANUP_EH_ONLY (begin
) = 1;
2237 sentry
= TARGET_EXPR_SLOT (begin
);
2239 TARGET_EXPR_CLEANUP (begin
)
2240 = build3 (COND_EXPR
, void_type_node
, sentry
,
2241 cleanup
, void_zero_node
);
2243 end
= build2 (MODIFY_EXPR
, TREE_TYPE (sentry
),
2244 sentry
, boolean_false_node
);
2247 = build2 (COMPOUND_EXPR
, void_type_node
, begin
,
2248 build2 (COMPOUND_EXPR
, void_type_node
, init_expr
,
2255 init_expr
= NULL_TREE
;
2257 /* Now build up the return value in reverse order. */
2262 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), init_expr
, rval
);
2264 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), cookie_expr
, rval
);
2266 if (rval
== data_addr
)
2267 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2268 and return the call (which doesn't need to be adjusted). */
2269 rval
= TARGET_EXPR_INITIAL (alloc_expr
);
2274 tree ifexp
= cp_build_binary_op (input_location
,
2275 NE_EXPR
, alloc_node
,
2278 rval
= build_conditional_expr (ifexp
, rval
, alloc_node
,
2282 /* Perform the allocation before anything else, so that ALLOC_NODE
2283 has been initialized before we start using it. */
2284 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
2287 if (init_preeval_expr
)
2288 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), init_preeval_expr
, rval
);
2290 /* Convert to the final type. */
2291 rval
= build_nop (pointer_type
, rval
);
2293 /* A new-expression is never an lvalue. */
2294 gcc_assert (!lvalue_p (rval
));
2296 if (placement
!= NULL
)
2297 rval
= avoid_placement_new_aliasing (rval
, placement_expr
);
2302 /* Generate a representation for a C++ "new" expression. PLACEMENT is
2303 a TREE_LIST of placement-new arguments (or NULL_TREE if none). If
2304 NELTS is NULL, TYPE is the type of the storage to be allocated. If
2305 NELTS is not NULL, then this is an array-new allocation; TYPE is
2306 the type of the elements in the array and NELTS is the number of
2307 elements in the array. INIT, if non-NULL, is the initializer for
2308 the new object, or void_zero_node to indicate an initializer of
2309 "()". If USE_GLOBAL_NEW is true, then the user explicitly wrote
2310 "::new" rather than just "new". */
2313 build_new (tree placement
, tree type
, tree nelts
, tree init
,
2314 int use_global_new
, tsubst_flags_t complain
)
2317 tree orig_placement
;
2321 if (placement
== error_mark_node
|| type
== error_mark_node
2322 || init
== error_mark_node
)
2323 return error_mark_node
;
2325 orig_placement
= placement
;
2329 if (nelts
== NULL_TREE
&& init
!= void_zero_node
&& list_length (init
) == 1)
2331 tree auto_node
= type_uses_auto (type
);
2332 if (auto_node
&& describable_type (TREE_VALUE (init
)))
2333 type
= do_auto_deduction (type
, TREE_VALUE (init
), auto_node
);
2336 if (processing_template_decl
)
2338 if (dependent_type_p (type
)
2339 || any_type_dependent_arguments_p (placement
)
2340 || (nelts
&& type_dependent_expression_p (nelts
))
2341 || (init
!= void_zero_node
2342 && any_type_dependent_arguments_p (init
)))
2343 return build_raw_new_expr (placement
, type
, nelts
, init
,
2345 placement
= build_non_dependent_args (placement
);
2347 nelts
= build_non_dependent_expr (nelts
);
2348 if (init
!= void_zero_node
)
2349 init
= build_non_dependent_args (init
);
2354 if (!build_expr_type_conversion (WANT_INT
| WANT_ENUM
, nelts
, false))
2356 if (complain
& tf_error
)
2357 permerror (input_location
, "size in array new must have integral type");
2359 return error_mark_node
;
2361 nelts
= cp_save_expr (cp_convert (sizetype
, nelts
));
2364 /* ``A reference cannot be created by the new operator. A reference
2365 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2366 returned by new.'' ARM 5.3.3 */
2367 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2369 if (complain
& tf_error
)
2370 error ("new cannot be applied to a reference type");
2372 return error_mark_node
;
2373 type
= TREE_TYPE (type
);
2376 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2378 if (complain
& tf_error
)
2379 error ("new cannot be applied to a function type");
2380 return error_mark_node
;
2383 /* The type allocated must be complete. If the new-type-id was
2384 "T[N]" then we are just checking that "T" is complete here, but
2385 that is equivalent, since the value of "N" doesn't matter. */
2386 if (!complete_type_or_else (type
, NULL_TREE
))
2387 return error_mark_node
;
2389 rval
= build_new_1 (placement
, type
, nelts
, init
, use_global_new
, complain
);
2390 if (rval
== error_mark_node
)
2391 return error_mark_node
;
2393 if (processing_template_decl
)
2394 return build_raw_new_expr (orig_placement
, type
, orig_nelts
, orig_init
,
2397 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2398 rval
= build1 (NOP_EXPR
, TREE_TYPE (rval
), rval
);
2399 TREE_NO_WARNING (rval
) = 1;
2404 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2407 build_java_class_ref (tree type
)
2409 tree name
= NULL_TREE
, class_decl
;
2410 static tree CL_suffix
= NULL_TREE
;
2411 if (CL_suffix
== NULL_TREE
)
2412 CL_suffix
= get_identifier("class$");
2413 if (jclass_node
== NULL_TREE
)
2415 jclass_node
= IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2416 if (jclass_node
== NULL_TREE
)
2418 error ("call to Java constructor, while %<jclass%> undefined");
2419 return error_mark_node
;
2421 jclass_node
= TREE_TYPE (jclass_node
);
2424 /* Mangle the class$ field. */
2427 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
2428 if (DECL_NAME (field
) == CL_suffix
)
2430 mangle_decl (field
);
2431 name
= DECL_ASSEMBLER_NAME (field
);
2436 error ("can't find %<class$%> in %qT", type
);
2437 return error_mark_node
;
2441 class_decl
= IDENTIFIER_GLOBAL_VALUE (name
);
2442 if (class_decl
== NULL_TREE
)
2444 class_decl
= build_decl (VAR_DECL
, name
, TREE_TYPE (jclass_node
));
2445 TREE_STATIC (class_decl
) = 1;
2446 DECL_EXTERNAL (class_decl
) = 1;
2447 TREE_PUBLIC (class_decl
) = 1;
2448 DECL_ARTIFICIAL (class_decl
) = 1;
2449 DECL_IGNORED_P (class_decl
) = 1;
2450 pushdecl_top_level (class_decl
);
2451 make_decl_rtl (class_decl
);
2457 build_vec_delete_1 (tree base
, tree maxindex
, tree type
,
2458 special_function_kind auto_delete_vec
, int use_global_delete
)
2461 tree ptype
= build_pointer_type (type
= complete_type (type
));
2462 tree size_exp
= size_in_bytes (type
);
2464 /* Temporary variables used by the loop. */
2465 tree tbase
, tbase_init
;
2467 /* This is the body of the loop that implements the deletion of a
2468 single element, and moves temp variables to next elements. */
2471 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2474 /* This is the thing that governs what to do after the loop has run. */
2475 tree deallocate_expr
= 0;
2477 /* This is the BIND_EXPR which holds the outermost iterator of the
2478 loop. It is convenient to set this variable up and test it before
2479 executing any other code in the loop.
2480 This is also the containing expression returned by this function. */
2481 tree controller
= NULL_TREE
;
2484 /* We should only have 1-D arrays here. */
2485 gcc_assert (TREE_CODE (type
) != ARRAY_TYPE
);
2487 if (! MAYBE_CLASS_TYPE_P (type
) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
2490 /* The below is short by the cookie size. */
2491 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2492 convert (sizetype
, maxindex
));
2494 tbase
= create_temporary_var (ptype
);
2495 tbase_init
= cp_build_modify_expr (tbase
, NOP_EXPR
,
2496 fold_build2 (POINTER_PLUS_EXPR
, ptype
,
2497 fold_convert (ptype
, base
),
2499 tf_warning_or_error
);
2500 DECL_REGISTER (tbase
) = 1;
2501 controller
= build3 (BIND_EXPR
, void_type_node
, tbase
,
2502 NULL_TREE
, NULL_TREE
);
2503 TREE_SIDE_EFFECTS (controller
) = 1;
2505 body
= build1 (EXIT_EXPR
, void_type_node
,
2506 build2 (EQ_EXPR
, boolean_type_node
, tbase
,
2507 fold_convert (ptype
, base
)));
2508 tmp
= fold_build1 (NEGATE_EXPR
, sizetype
, size_exp
);
2509 body
= build_compound_expr
2510 (body
, cp_build_modify_expr (tbase
, NOP_EXPR
,
2511 build2 (POINTER_PLUS_EXPR
, ptype
, tbase
, tmp
),
2512 tf_warning_or_error
));
2513 body
= build_compound_expr
2514 (body
, build_delete (ptype
, tbase
, sfk_complete_destructor
,
2515 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1));
2517 loop
= build1 (LOOP_EXPR
, void_type_node
, body
);
2518 loop
= build_compound_expr (tbase_init
, loop
);
2521 /* If the delete flag is one, or anything else with the low bit set,
2522 delete the storage. */
2523 if (auto_delete_vec
!= sfk_base_destructor
)
2527 /* The below is short by the cookie size. */
2528 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2529 convert (sizetype
, maxindex
));
2531 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
2538 cookie_size
= targetm
.cxx
.get_cookie_size (type
);
2540 = cp_convert (ptype
,
2541 cp_build_binary_op (input_location
,
2543 cp_convert (string_type_node
,
2546 tf_warning_or_error
));
2547 /* True size with header. */
2548 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, cookie_size
);
2551 if (auto_delete_vec
== sfk_deleting_destructor
)
2552 deallocate_expr
= build_op_delete_call (VEC_DELETE_EXPR
,
2553 base_tbd
, virtual_size
,
2554 use_global_delete
& 1,
2555 /*placement=*/NULL_TREE
,
2556 /*alloc_fn=*/NULL_TREE
);
2560 if (!deallocate_expr
)
2563 body
= deallocate_expr
;
2565 body
= build_compound_expr (body
, deallocate_expr
);
2568 body
= integer_zero_node
;
2570 /* Outermost wrapper: If pointer is null, punt. */
2571 body
= fold_build3 (COND_EXPR
, void_type_node
,
2572 fold_build2 (NE_EXPR
, boolean_type_node
, base
,
2573 convert (TREE_TYPE (base
),
2574 integer_zero_node
)),
2575 body
, integer_zero_node
);
2576 body
= build1 (NOP_EXPR
, void_type_node
, body
);
2580 TREE_OPERAND (controller
, 1) = body
;
2584 if (TREE_CODE (base
) == SAVE_EXPR
)
2585 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
2586 body
= build2 (COMPOUND_EXPR
, void_type_node
, base
, body
);
2588 return convert_to_void (body
, /*implicit=*/NULL
, tf_warning_or_error
);
2591 /* Create an unnamed variable of the indicated TYPE. */
2594 create_temporary_var (tree type
)
2598 decl
= build_decl (VAR_DECL
, NULL_TREE
, type
);
2599 TREE_USED (decl
) = 1;
2600 DECL_ARTIFICIAL (decl
) = 1;
2601 DECL_IGNORED_P (decl
) = 1;
2602 DECL_SOURCE_LOCATION (decl
) = input_location
;
2603 DECL_CONTEXT (decl
) = current_function_decl
;
2608 /* Create a new temporary variable of the indicated TYPE, initialized
2611 It is not entered into current_binding_level, because that breaks
2612 things when it comes time to do final cleanups (which take place
2613 "outside" the binding contour of the function). */
2616 get_temp_regvar (tree type
, tree init
)
2620 decl
= create_temporary_var (type
);
2621 add_decl_expr (decl
);
2623 finish_expr_stmt (cp_build_modify_expr (decl
, INIT_EXPR
, init
,
2624 tf_warning_or_error
));
2629 /* `build_vec_init' returns tree structure that performs
2630 initialization of a vector of aggregate types.
2632 BASE is a reference to the vector, of ARRAY_TYPE.
2633 MAXINDEX is the maximum index of the array (one less than the
2634 number of elements). It is only used if
2635 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2637 INIT is the (possibly NULL) initializer.
2639 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All
2640 elements in the array are value-initialized.
2642 FROM_ARRAY is 0 if we should init everything with INIT
2643 (i.e., every element initialized from INIT).
2644 FROM_ARRAY is 1 if we should index into INIT in parallel
2645 with initialization of DECL.
2646 FROM_ARRAY is 2 if we should index into INIT in parallel,
2647 but use assignment instead of initialization. */
2650 build_vec_init (tree base
, tree maxindex
, tree init
,
2651 bool explicit_value_init_p
,
2652 int from_array
, tsubst_flags_t complain
)
2655 tree base2
= NULL_TREE
;
2657 tree itype
= NULL_TREE
;
2659 /* The type of the array. */
2660 tree atype
= TREE_TYPE (base
);
2661 /* The type of an element in the array. */
2662 tree type
= TREE_TYPE (atype
);
2663 /* The element type reached after removing all outer array
2665 tree inner_elt_type
;
2666 /* The type of a pointer to an element in the array. */
2671 tree try_block
= NULL_TREE
;
2672 int num_initialized_elts
= 0;
2675 if (TYPE_DOMAIN (atype
))
2676 maxindex
= array_type_nelts (atype
);
2678 if (maxindex
== NULL_TREE
|| maxindex
== error_mark_node
)
2679 return error_mark_node
;
2681 if (explicit_value_init_p
)
2684 inner_elt_type
= strip_array_types (atype
);
2687 ? (!CLASS_TYPE_P (inner_elt_type
)
2688 || !TYPE_HAS_COMPLEX_ASSIGN_REF (inner_elt_type
))
2689 : !TYPE_NEEDS_CONSTRUCTING (type
))
2690 && ((TREE_CODE (init
) == CONSTRUCTOR
2691 /* Don't do this if the CONSTRUCTOR might contain something
2692 that might throw and require us to clean up. */
2693 && (VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (init
))
2694 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type
)))
2697 /* Do non-default initialization of POD arrays resulting from
2698 brace-enclosed initializers. In this case, digest_init and
2699 store_constructor will handle the semantics for us. */
2701 stmt_expr
= build2 (INIT_EXPR
, atype
, base
, init
);
2705 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
);
2706 ptype
= build_pointer_type (type
);
2707 size
= size_in_bytes (type
);
2708 if (TREE_CODE (TREE_TYPE (base
)) == ARRAY_TYPE
)
2709 base
= cp_convert (ptype
, decay_conversion (base
));
2711 /* The code we are generating looks like:
2715 ptrdiff_t iterator = maxindex;
2717 for (; iterator != -1; --iterator) {
2718 ... initialize *t1 ...
2722 ... destroy elements that were constructed ...
2727 We can omit the try and catch blocks if we know that the
2728 initialization will never throw an exception, or if the array
2729 elements do not have destructors. We can omit the loop completely if
2730 the elements of the array do not have constructors.
2732 We actually wrap the entire body of the above in a STMT_EXPR, for
2735 When copying from array to another, when the array elements have
2736 only trivial copy constructors, we should use __builtin_memcpy
2737 rather than generating a loop. That way, we could take advantage
2738 of whatever cleverness the back end has for dealing with copies
2739 of blocks of memory. */
2741 is_global
= begin_init_stmts (&stmt_expr
, &compound_stmt
);
2742 destroy_temps
= stmts_are_full_exprs_p ();
2743 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
2744 rval
= get_temp_regvar (ptype
, base
);
2745 base
= get_temp_regvar (ptype
, rval
);
2746 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
2748 /* Protect the entire array initialization so that we can destroy
2749 the partially constructed array if an exception is thrown.
2750 But don't do this if we're assigning. */
2751 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
2754 try_block
= begin_try_block ();
2757 if (init
!= NULL_TREE
&& TREE_CODE (init
) == CONSTRUCTOR
)
2759 /* Do non-default initialization of non-POD arrays resulting from
2760 brace-enclosed initializers. */
2761 unsigned HOST_WIDE_INT idx
;
2765 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), idx
, elt
)
2767 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
2769 num_initialized_elts
++;
2771 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
2772 if (MAYBE_CLASS_TYPE_P (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
2773 finish_expr_stmt (build_aggr_init (baseref
, elt
, 0, complain
));
2775 finish_expr_stmt (cp_build_modify_expr (baseref
, NOP_EXPR
,
2777 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
2779 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR
, base
, 0,
2781 finish_expr_stmt (cp_build_unary_op (PREDECREMENT_EXPR
, iterator
, 0,
2785 /* Clear out INIT so that we don't get confused below. */
2788 else if (from_array
)
2790 /* If initializing one array from another, initialize element by
2791 element. We rely upon the below calls the do argument
2795 base2
= decay_conversion (init
);
2796 itype
= TREE_TYPE (base2
);
2797 base2
= get_temp_regvar (itype
, base2
);
2798 itype
= TREE_TYPE (itype
);
2800 else if (TYPE_LANG_SPECIFIC (type
)
2801 && TYPE_NEEDS_CONSTRUCTING (type
)
2802 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2804 if (complain
& tf_error
)
2805 error ("initializer ends prematurely");
2806 return error_mark_node
;
2810 /* Now, default-initialize any remaining elements. We don't need to
2811 do that if a) the type does not need constructing, or b) we've
2812 already initialized all the elements.
2814 We do need to keep going if we're copying an array. */
2817 || ((TYPE_NEEDS_CONSTRUCTING (type
) || explicit_value_init_p
)
2818 && ! (host_integerp (maxindex
, 0)
2819 && (num_initialized_elts
2820 == tree_low_cst (maxindex
, 0) + 1))))
2822 /* If the ITERATOR is equal to -1, then we don't have to loop;
2823 we've already initialized all the elements. */
2828 for_stmt
= begin_for_stmt ();
2829 finish_for_init_stmt (for_stmt
);
2830 finish_for_cond (build2 (NE_EXPR
, boolean_type_node
, iterator
,
2831 build_int_cst (TREE_TYPE (iterator
), -1)),
2833 finish_for_expr (cp_build_unary_op (PREDECREMENT_EXPR
, iterator
, 0,
2837 to
= build1 (INDIRECT_REF
, type
, base
);
2844 from
= build1 (INDIRECT_REF
, itype
, base2
);
2848 if (from_array
== 2)
2849 elt_init
= cp_build_modify_expr (to
, NOP_EXPR
, from
,
2851 else if (TYPE_NEEDS_CONSTRUCTING (type
))
2852 elt_init
= build_aggr_init (to
, from
, 0, complain
);
2854 elt_init
= cp_build_modify_expr (to
, NOP_EXPR
, from
,
2859 else if (TREE_CODE (type
) == ARRAY_TYPE
)
2863 ("cannot initialize multi-dimensional array with initializer");
2864 elt_init
= build_vec_init (build1 (INDIRECT_REF
, type
, base
),
2866 explicit_value_init_p
,
2869 else if (explicit_value_init_p
)
2870 elt_init
= build2 (INIT_EXPR
, type
, to
,
2871 build_value_init (type
));
2874 gcc_assert (TYPE_NEEDS_CONSTRUCTING (type
));
2875 elt_init
= build_aggr_init (to
, init
, 0, complain
);
2878 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
2879 finish_expr_stmt (elt_init
);
2880 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
2882 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR
, base
, 0,
2885 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR
, base2
, 0,
2888 finish_for_stmt (for_stmt
);
2891 /* Make sure to cleanup any partially constructed elements. */
2892 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
2896 tree m
= cp_build_binary_op (input_location
,
2897 MINUS_EXPR
, maxindex
, iterator
,
2900 /* Flatten multi-dimensional array since build_vec_delete only
2901 expects one-dimensional array. */
2902 if (TREE_CODE (type
) == ARRAY_TYPE
)
2903 m
= cp_build_binary_op (input_location
,
2905 array_type_nelts_total (type
),
2908 finish_cleanup_try_block (try_block
);
2909 e
= build_vec_delete_1 (rval
, m
,
2910 inner_elt_type
, sfk_base_destructor
,
2911 /*use_global_delete=*/0);
2912 finish_cleanup (e
, try_block
);
2915 /* The value of the array initialization is the array itself, RVAL
2916 is a pointer to the first element. */
2917 finish_stmt_expr_expr (rval
, stmt_expr
);
2919 stmt_expr
= finish_init_stmts (is_global
, stmt_expr
, compound_stmt
);
2921 /* Now convert make the result have the correct type. */
2922 atype
= build_pointer_type (atype
);
2923 stmt_expr
= build1 (NOP_EXPR
, atype
, stmt_expr
);
2924 stmt_expr
= cp_build_indirect_ref (stmt_expr
, NULL
, complain
);
2926 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
2930 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
2934 build_dtor_call (tree exp
, special_function_kind dtor_kind
, int flags
)
2940 case sfk_complete_destructor
:
2941 name
= complete_dtor_identifier
;
2944 case sfk_base_destructor
:
2945 name
= base_dtor_identifier
;
2948 case sfk_deleting_destructor
:
2949 name
= deleting_dtor_identifier
;
2955 fn
= lookup_fnfields (TREE_TYPE (exp
), name
, /*protect=*/2);
2956 return build_new_method_call (exp
, fn
,
2958 /*conversion_path=*/NULL_TREE
,
2961 tf_warning_or_error
);
2964 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2965 ADDR is an expression which yields the store to be destroyed.
2966 AUTO_DELETE is the name of the destructor to call, i.e., either
2967 sfk_complete_destructor, sfk_base_destructor, or
2968 sfk_deleting_destructor.
2970 FLAGS is the logical disjunction of zero or more LOOKUP_
2971 flags. See cp-tree.h for more info. */
2974 build_delete (tree type
, tree addr
, special_function_kind auto_delete
,
2975 int flags
, int use_global_delete
)
2979 if (addr
== error_mark_node
)
2980 return error_mark_node
;
2982 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
2983 set to `error_mark_node' before it gets properly cleaned up. */
2984 if (type
== error_mark_node
)
2985 return error_mark_node
;
2987 type
= TYPE_MAIN_VARIANT (type
);
2989 if (TREE_CODE (type
) == POINTER_TYPE
)
2991 bool complete_p
= true;
2993 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
2994 if (TREE_CODE (type
) == ARRAY_TYPE
)
2997 /* We don't want to warn about delete of void*, only other
2998 incomplete types. Deleting other incomplete types
2999 invokes undefined behavior, but it is not ill-formed, so
3000 compile to something that would even do The Right Thing
3001 (TM) should the type have a trivial dtor and no delete
3003 if (!VOID_TYPE_P (type
))
3005 complete_type (type
);
3006 if (!COMPLETE_TYPE_P (type
))
3008 if (warning (0, "possible problem detected in invocation of "
3009 "delete operator:"))
3011 cxx_incomplete_type_diagnostic (addr
, type
, DK_WARNING
);
3012 inform (input_location
, "neither the destructor nor the class-specific "
3013 "operator delete will be called, even if they are "
3014 "declared when the class is defined.");
3019 if (VOID_TYPE_P (type
) || !complete_p
|| !MAYBE_CLASS_TYPE_P (type
))
3020 /* Call the builtin operator delete. */
3021 return build_builtin_delete_call (addr
);
3022 if (TREE_SIDE_EFFECTS (addr
))
3023 addr
= save_expr (addr
);
3025 /* Throw away const and volatile on target type of addr. */
3026 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3028 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3032 if (TYPE_DOMAIN (type
) == NULL_TREE
)
3034 error ("unknown array size in delete");
3035 return error_mark_node
;
3037 return build_vec_delete (addr
, array_type_nelts (type
),
3038 auto_delete
, use_global_delete
);
3042 /* Don't check PROTECT here; leave that decision to the
3043 destructor. If the destructor is accessible, call it,
3044 else report error. */
3045 addr
= cp_build_unary_op (ADDR_EXPR
, addr
, 0, tf_warning_or_error
);
3046 if (TREE_SIDE_EFFECTS (addr
))
3047 addr
= save_expr (addr
);
3049 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3052 gcc_assert (MAYBE_CLASS_TYPE_P (type
));
3054 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
3056 if (auto_delete
!= sfk_deleting_destructor
)
3057 return void_zero_node
;
3059 return build_op_delete_call (DELETE_EXPR
, addr
,
3060 cxx_sizeof_nowarn (type
),
3062 /*placement=*/NULL_TREE
,
3063 /*alloc_fn=*/NULL_TREE
);
3067 tree head
= NULL_TREE
;
3068 tree do_delete
= NULL_TREE
;
3071 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
3072 lazily_declare_fn (sfk_destructor
, type
);
3074 /* For `::delete x', we must not use the deleting destructor
3075 since then we would not be sure to get the global `operator
3077 if (use_global_delete
&& auto_delete
== sfk_deleting_destructor
)
3079 /* We will use ADDR multiple times so we must save it. */
3080 addr
= save_expr (addr
);
3081 head
= get_target_expr (build_headof (addr
));
3082 /* Delete the object. */
3083 do_delete
= build_builtin_delete_call (head
);
3084 /* Otherwise, treat this like a complete object destructor
3086 auto_delete
= sfk_complete_destructor
;
3088 /* If the destructor is non-virtual, there is no deleting
3089 variant. Instead, we must explicitly call the appropriate
3090 `operator delete' here. */
3091 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type
))
3092 && auto_delete
== sfk_deleting_destructor
)
3094 /* We will use ADDR multiple times so we must save it. */
3095 addr
= save_expr (addr
);
3096 /* Build the call. */
3097 do_delete
= build_op_delete_call (DELETE_EXPR
,
3099 cxx_sizeof_nowarn (type
),
3101 /*placement=*/NULL_TREE
,
3102 /*alloc_fn=*/NULL_TREE
);
3103 /* Call the complete object destructor. */
3104 auto_delete
= sfk_complete_destructor
;
3106 else if (auto_delete
== sfk_deleting_destructor
3107 && TYPE_GETS_REG_DELETE (type
))
3109 /* Make sure we have access to the member op delete, even though
3110 we'll actually be calling it from the destructor. */
3111 build_op_delete_call (DELETE_EXPR
, addr
, cxx_sizeof_nowarn (type
),
3113 /*placement=*/NULL_TREE
,
3114 /*alloc_fn=*/NULL_TREE
);
3117 expr
= build_dtor_call (cp_build_indirect_ref (addr
, NULL
,
3118 tf_warning_or_error
),
3119 auto_delete
, flags
);
3121 expr
= build2 (COMPOUND_EXPR
, void_type_node
, expr
, do_delete
);
3123 /* We need to calculate this before the dtor changes the vptr. */
3125 expr
= build2 (COMPOUND_EXPR
, void_type_node
, head
, expr
);
3127 if (flags
& LOOKUP_DESTRUCTOR
)
3128 /* Explicit destructor call; don't check for null pointer. */
3129 ifexp
= integer_one_node
;
3131 /* Handle deleting a null pointer. */
3132 ifexp
= fold (cp_build_binary_op (input_location
,
3133 NE_EXPR
, addr
, integer_zero_node
,
3134 tf_warning_or_error
));
3136 if (ifexp
!= integer_one_node
)
3137 expr
= build3 (COND_EXPR
, void_type_node
,
3138 ifexp
, expr
, void_zero_node
);
3144 /* At the beginning of a destructor, push cleanups that will call the
3145 destructors for our base classes and members.
3147 Called from begin_destructor_body. */
3150 push_base_cleanups (void)
3152 tree binfo
, base_binfo
;
3156 VEC(tree
,gc
) *vbases
;
3158 /* Run destructors for all virtual baseclasses. */
3159 if (CLASSTYPE_VBASECLASSES (current_class_type
))
3161 tree cond
= (condition_conversion
3162 (build2 (BIT_AND_EXPR
, integer_type_node
,
3163 current_in_charge_parm
,
3164 integer_two_node
)));
3166 /* The CLASSTYPE_VBASECLASSES vector is in initialization
3167 order, which is also the right order for pushing cleanups. */
3168 for (vbases
= CLASSTYPE_VBASECLASSES (current_class_type
), i
= 0;
3169 VEC_iterate (tree
, vbases
, i
, base_binfo
); i
++)
3171 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
3173 expr
= build_special_member_call (current_class_ref
,
3174 base_dtor_identifier
,
3178 | LOOKUP_NONVIRTUAL
),
3179 tf_warning_or_error
);
3180 expr
= build3 (COND_EXPR
, void_type_node
, cond
,
3181 expr
, void_zero_node
);
3182 finish_decl_cleanup (NULL_TREE
, expr
);
3187 /* Take care of the remaining baseclasses. */
3188 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
3189 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
3191 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
))
3192 || BINFO_VIRTUAL_P (base_binfo
))
3195 expr
= build_special_member_call (current_class_ref
,
3196 base_dtor_identifier
,
3197 NULL_TREE
, base_binfo
,
3198 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
3199 tf_warning_or_error
);
3200 finish_decl_cleanup (NULL_TREE
, expr
);
3203 for (member
= TYPE_FIELDS (current_class_type
); member
;
3204 member
= TREE_CHAIN (member
))
3206 if (TREE_TYPE (member
) == error_mark_node
3207 || TREE_CODE (member
) != FIELD_DECL
3208 || DECL_ARTIFICIAL (member
))
3210 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member
)))
3212 tree this_member
= (build_class_member_access_expr
3213 (current_class_ref
, member
,
3214 /*access_path=*/NULL_TREE
,
3215 /*preserve_reference=*/false,
3216 tf_warning_or_error
));
3217 tree this_type
= TREE_TYPE (member
);
3218 expr
= build_delete (this_type
, this_member
,
3219 sfk_complete_destructor
,
3220 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
,
3222 finish_decl_cleanup (NULL_TREE
, expr
);
3227 /* Build a C++ vector delete expression.
3228 MAXINDEX is the number of elements to be deleted.
3229 ELT_SIZE is the nominal size of each element in the vector.
3230 BASE is the expression that should yield the store to be deleted.
3231 This function expands (or synthesizes) these calls itself.
3232 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3234 This also calls delete for virtual baseclasses of elements of the vector.
3236 Update: MAXINDEX is no longer needed. The size can be extracted from the
3237 start of the vector for pointers, and from the type for arrays. We still
3238 use MAXINDEX for arrays because it happens to already have one of the
3239 values we'd have to extract. (We could use MAXINDEX with pointers to
3240 confirm the size, and trap if the numbers differ; not clear that it'd
3241 be worth bothering.) */
3244 build_vec_delete (tree base
, tree maxindex
,
3245 special_function_kind auto_delete_vec
, int use_global_delete
)
3249 tree base_init
= NULL_TREE
;
3251 type
= TREE_TYPE (base
);
3253 if (TREE_CODE (type
) == POINTER_TYPE
)
3255 /* Step back one from start of vector, and read dimension. */
3257 tree size_ptr_type
= build_pointer_type (sizetype
);
3259 if (TREE_SIDE_EFFECTS (base
))
3261 base_init
= get_target_expr (base
);
3262 base
= TARGET_EXPR_SLOT (base_init
);
3264 type
= strip_array_types (TREE_TYPE (type
));
3265 cookie_addr
= fold_build1 (NEGATE_EXPR
, sizetype
, TYPE_SIZE_UNIT (sizetype
));
3266 cookie_addr
= build2 (POINTER_PLUS_EXPR
,
3268 fold_convert (size_ptr_type
, base
),
3270 maxindex
= cp_build_indirect_ref (cookie_addr
, NULL
, tf_warning_or_error
);
3272 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3274 /* Get the total number of things in the array, maxindex is a
3276 maxindex
= array_type_nelts_total (type
);
3277 type
= strip_array_types (type
);
3278 base
= cp_build_unary_op (ADDR_EXPR
, base
, 1, tf_warning_or_error
);
3279 if (TREE_SIDE_EFFECTS (base
))
3281 base_init
= get_target_expr (base
);
3282 base
= TARGET_EXPR_SLOT (base_init
);
3287 if (base
!= error_mark_node
)
3288 error ("type to vector delete is neither pointer or array type");
3289 return error_mark_node
;
3292 rval
= build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
,
3295 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), base_init
, rval
);