1 /* Handle initialization things in C++.
2 Copyright (C) 1987-2020 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* High-level class interface. */
25 #include "coretypes.h"
28 #include "stringpool.h"
31 #include "c-family/c-ubsan.h"
33 #include "stringpool.h"
36 #include "stor-layout.h"
38 static bool begin_init_stmts (tree
*, tree
*);
39 static tree
finish_init_stmts (bool, tree
, tree
);
40 static void construct_virtual_base (tree
, tree
);
41 static void expand_aggr_init_1 (tree
, tree
, tree
, tree
, int, tsubst_flags_t
);
42 static void expand_default_init (tree
, tree
, tree
, tree
, int, tsubst_flags_t
);
43 static void perform_member_init (tree
, tree
);
44 static int member_init_ok_or_else (tree
, tree
, tree
);
45 static void expand_virtual_init (tree
, tree
);
46 static tree
sort_mem_initializers (tree
, tree
);
47 static tree
initializing_context (tree
);
48 static void expand_cleanup_for_base (tree
, tree
);
49 static tree
dfs_initialize_vtbl_ptrs (tree
, void *);
50 static tree
build_field_list (tree
, tree
, int *);
51 static int diagnose_uninitialized_cst_or_ref_member_1 (tree
, tree
, bool, bool);
53 static GTY(()) tree fn
;
55 /* We are about to generate some complex initialization code.
56 Conceptually, it is all a single expression. However, we may want
57 to include conditionals, loops, and other such statement-level
58 constructs. Therefore, we build the initialization code inside a
59 statement-expression. This function starts such an expression.
60 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
61 pass them back to finish_init_stmts when the expression is
65 begin_init_stmts (tree
*stmt_expr_p
, tree
*compound_stmt_p
)
67 bool is_global
= !building_stmt_list_p ();
69 *stmt_expr_p
= begin_stmt_expr ();
70 *compound_stmt_p
= begin_compound_stmt (BCS_NO_SCOPE
);
75 /* Finish out the statement-expression begun by the previous call to
76 begin_init_stmts. Returns the statement-expression itself. */
79 finish_init_stmts (bool is_global
, tree stmt_expr
, tree compound_stmt
)
81 finish_compound_stmt (compound_stmt
);
83 stmt_expr
= finish_stmt_expr (stmt_expr
, true);
85 gcc_assert (!building_stmt_list_p () == is_global
);
92 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
93 which we want to initialize the vtable pointer for, DATA is
94 TREE_LIST whose TREE_VALUE is the this ptr expression. */
97 dfs_initialize_vtbl_ptrs (tree binfo
, void *data
)
99 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
100 return dfs_skip_bases
;
102 if (!BINFO_PRIMARY_P (binfo
) || BINFO_VIRTUAL_P (binfo
))
104 tree base_ptr
= TREE_VALUE ((tree
) data
);
106 base_ptr
= build_base_path (PLUS_EXPR
, base_ptr
, binfo
, /*nonnull=*/1,
107 tf_warning_or_error
);
109 expand_virtual_init (binfo
, base_ptr
);
115 /* Initialize all the vtable pointers in the object pointed to by
119 initialize_vtbl_ptrs (tree addr
)
124 type
= TREE_TYPE (TREE_TYPE (addr
));
125 list
= build_tree_list (type
, addr
);
127 /* Walk through the hierarchy, initializing the vptr in each base
128 class. We do these in pre-order because we can't find the virtual
129 bases for a class until we've initialized the vtbl for that
131 dfs_walk_once (TYPE_BINFO (type
), dfs_initialize_vtbl_ptrs
, NULL
, list
);
134 /* Return an expression for the zero-initialization of an object with
135 type T. This expression will either be a constant (in the case
136 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
137 aggregate), or NULL (in the case that T does not require
138 initialization). In either case, the value can be used as
139 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
140 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
141 is the number of elements in the array. If STATIC_STORAGE_P is
142 TRUE, initializers are only generated for entities for which
143 zero-initialization does not simply mean filling the storage with
144 zero bytes. FIELD_SIZE, if non-NULL, is the bit size of the field,
145 subfields with bit positions at or above that bit size shouldn't
146 be added. Note that this only works when the result is assigned
147 to a base COMPONENT_REF; if we only have a pointer to the base subobject,
148 expand_assignment will end up clearing the full size of TYPE. */
151 build_zero_init_1 (tree type
, tree nelts
, bool static_storage_p
,
154 tree init
= NULL_TREE
;
158 To zero-initialize an object of type T means:
160 -- if T is a scalar type, the storage is set to the value of zero
163 -- if T is a non-union class type, the storage for each non-static
164 data member and each base-class subobject is zero-initialized.
166 -- if T is a union type, the storage for its first data member is
169 -- if T is an array type, the storage for each element is
172 -- if T is a reference type, no initialization is performed. */
174 gcc_assert (nelts
== NULL_TREE
|| TREE_CODE (nelts
) == INTEGER_CST
);
176 if (type
== error_mark_node
)
178 else if (static_storage_p
&& zero_init_p (type
))
179 /* In order to save space, we do not explicitly build initializers
180 for items that do not need them. GCC's semantics are that
181 items with static storage duration that are not otherwise
182 initialized are initialized to zero. */
184 else if (TYPE_PTR_OR_PTRMEM_P (type
))
185 init
= fold (convert (type
, nullptr_node
));
186 else if (NULLPTR_TYPE_P (type
))
187 init
= build_int_cst (type
, 0);
188 else if (SCALAR_TYPE_P (type
))
189 init
= fold (convert (type
, integer_zero_node
));
190 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (type
)))
193 vec
<constructor_elt
, va_gc
> *v
= NULL
;
195 /* Iterate over the fields, building initializations. */
196 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
198 if (TREE_CODE (field
) != FIELD_DECL
)
201 if (TREE_TYPE (field
) == error_mark_node
)
204 /* Don't add virtual bases for base classes if they are beyond
205 the size of the current field, that means it is present
206 somewhere else in the object. */
209 tree bitpos
= bit_position (field
);
210 if (TREE_CODE (bitpos
) == INTEGER_CST
211 && !tree_int_cst_lt (bitpos
, field_size
))
215 /* Note that for class types there will be FIELD_DECLs
216 corresponding to base classes as well. Thus, iterating
217 over TYPE_FIELDs will result in correct initialization of
218 all of the subobjects. */
219 if (!static_storage_p
|| !zero_init_p (TREE_TYPE (field
)))
222 = (DECL_FIELD_IS_BASE (field
)
224 && TREE_CODE (DECL_SIZE (field
)) == INTEGER_CST
)
225 ? DECL_SIZE (field
) : NULL_TREE
;
226 tree value
= build_zero_init_1 (TREE_TYPE (field
),
231 CONSTRUCTOR_APPEND_ELT(v
, field
, value
);
234 /* For unions, only the first field is initialized. */
235 if (TREE_CODE (type
) == UNION_TYPE
)
239 /* Build a constructor to contain the initializations. */
240 init
= build_constructor (type
, v
);
242 else if (TREE_CODE (type
) == ARRAY_TYPE
)
245 vec
<constructor_elt
, va_gc
> *v
= NULL
;
247 /* Iterate over the array elements, building initializations. */
249 max_index
= fold_build2_loc (input_location
,
250 MINUS_EXPR
, TREE_TYPE (nelts
),
251 nelts
, integer_one_node
);
253 max_index
= array_type_nelts (type
);
255 /* If we have an error_mark here, we should just return error mark
256 as we don't know the size of the array yet. */
257 if (max_index
== error_mark_node
)
258 return error_mark_node
;
259 gcc_assert (TREE_CODE (max_index
) == INTEGER_CST
);
261 /* A zero-sized array, which is accepted as an extension, will
262 have an upper bound of -1. */
263 if (!tree_int_cst_equal (max_index
, integer_minus_one_node
))
267 /* If this is a one element array, we just use a regular init. */
268 if (tree_int_cst_equal (size_zero_node
, max_index
))
269 ce
.index
= size_zero_node
;
271 ce
.index
= build2 (RANGE_EXPR
, sizetype
, size_zero_node
,
274 ce
.value
= build_zero_init_1 (TREE_TYPE (type
),
276 static_storage_p
, NULL_TREE
);
284 /* Build a constructor to contain the initializations. */
285 init
= build_constructor (type
, v
);
287 else if (VECTOR_TYPE_P (type
))
288 init
= build_zero_cst (type
);
291 gcc_assert (TYPE_REF_P (type
));
292 init
= build_zero_cst (type
);
295 /* In all cases, the initializer is a constant. */
297 TREE_CONSTANT (init
) = 1;
302 /* Return an expression for the zero-initialization of an object with
303 type T. This expression will either be a constant (in the case
304 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
305 aggregate), or NULL (in the case that T does not require
306 initialization). In either case, the value can be used as
307 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
308 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
309 is the number of elements in the array. If STATIC_STORAGE_P is
310 TRUE, initializers are only generated for entities for which
311 zero-initialization does not simply mean filling the storage with
315 build_zero_init (tree type
, tree nelts
, bool static_storage_p
)
317 return build_zero_init_1 (type
, nelts
, static_storage_p
, NULL_TREE
);
320 /* Return a suitable initializer for value-initializing an object of type
321 TYPE, as described in [dcl.init]. */
324 build_value_init (tree type
, tsubst_flags_t complain
)
328 To value-initialize an object of type T means:
330 - if T is a class type (clause 9) with either no default constructor
331 (12.1) or a default constructor that is user-provided or deleted,
332 then the object is default-initialized;
334 - if T is a (possibly cv-qualified) class type without a user-provided
335 or deleted default constructor, then the object is zero-initialized
336 and the semantic constraints for default-initialization are checked,
337 and if T has a non-trivial default constructor, the object is
340 - if T is an array type, then each element is value-initialized;
342 - otherwise, the object is zero-initialized.
344 A program that calls for default-initialization or
345 value-initialization of an entity of reference type is ill-formed. */
347 /* The AGGR_INIT_EXPR tweaking below breaks in templates. */
348 gcc_assert (!processing_template_decl
349 || (SCALAR_TYPE_P (type
) || TREE_CODE (type
) == ARRAY_TYPE
));
351 if (CLASS_TYPE_P (type
) && type_build_ctor_call (type
))
354 = build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
355 NULL
, type
, LOOKUP_NORMAL
, complain
);
356 if (ctor
== error_mark_node
|| TREE_CONSTANT (ctor
))
359 if (TREE_CODE (ctor
) == CALL_EXPR
)
360 fn
= get_callee_fndecl (ctor
);
361 ctor
= build_aggr_init_expr (type
, ctor
);
362 if (fn
&& user_provided_p (fn
))
364 else if (TYPE_HAS_COMPLEX_DFLT (type
))
366 /* This is a class that needs constructing, but doesn't have
367 a user-provided constructor. So we need to zero-initialize
368 the object and then call the implicitly defined ctor.
369 This will be handled in simplify_aggr_init_expr. */
370 AGGR_INIT_ZERO_FIRST (ctor
) = 1;
375 /* Discard any access checking during subobject initialization;
376 the checks are implied by the call to the ctor which we have
377 verified is OK (cpp0x/defaulted46.C). */
378 push_deferring_access_checks (dk_deferred
);
379 tree r
= build_value_init_noctor (type
, complain
);
380 pop_deferring_access_checks ();
384 /* Like build_value_init, but don't call the constructor for TYPE. Used
385 for base initializers. */
388 build_value_init_noctor (tree type
, tsubst_flags_t complain
)
390 if (!COMPLETE_TYPE_P (type
))
392 if (complain
& tf_error
)
393 error ("value-initialization of incomplete type %qT", type
);
394 return error_mark_node
;
396 /* FIXME the class and array cases should just use digest_init once it is
398 if (CLASS_TYPE_P (type
))
400 gcc_assert (!TYPE_HAS_COMPLEX_DFLT (type
)
403 if (TREE_CODE (type
) != UNION_TYPE
)
406 vec
<constructor_elt
, va_gc
> *v
= NULL
;
408 /* Iterate over the fields, building initializations. */
409 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
413 if (TREE_CODE (field
) != FIELD_DECL
)
416 ftype
= TREE_TYPE (field
);
418 if (ftype
== error_mark_node
)
421 /* Ignore flexible array members for value initialization. */
422 if (TREE_CODE (ftype
) == ARRAY_TYPE
423 && !COMPLETE_TYPE_P (ftype
)
424 && !TYPE_DOMAIN (ftype
)
425 && COMPLETE_TYPE_P (TREE_TYPE (ftype
))
426 && (next_initializable_field (DECL_CHAIN (field
))
430 /* We could skip vfields and fields of types with
431 user-defined constructors, but I think that won't improve
432 performance at all; it should be simpler in general just
433 to zero out the entire object than try to only zero the
434 bits that actually need it. */
436 /* Note that for class types there will be FIELD_DECLs
437 corresponding to base classes as well. Thus, iterating
438 over TYPE_FIELDs will result in correct initialization of
439 all of the subobjects. */
440 value
= build_value_init (ftype
, complain
);
441 value
= maybe_constant_init (value
);
443 if (value
== error_mark_node
)
444 return error_mark_node
;
446 CONSTRUCTOR_APPEND_ELT(v
, field
, value
);
448 /* We shouldn't have gotten here for anything that would need
449 non-trivial initialization, and gimplify_init_ctor_preeval
450 would need to be fixed to allow it. */
451 gcc_assert (TREE_CODE (value
) != TARGET_EXPR
452 && TREE_CODE (value
) != AGGR_INIT_EXPR
);
455 /* Build a constructor to contain the zero- initializations. */
456 return build_constructor (type
, v
);
459 else if (TREE_CODE (type
) == ARRAY_TYPE
)
461 vec
<constructor_elt
, va_gc
> *v
= NULL
;
463 /* Iterate over the array elements, building initializations. */
464 tree max_index
= array_type_nelts (type
);
466 /* If we have an error_mark here, we should just return error mark
467 as we don't know the size of the array yet. */
468 if (max_index
== error_mark_node
)
470 if (complain
& tf_error
)
471 error ("cannot value-initialize array of unknown bound %qT",
473 return error_mark_node
;
475 gcc_assert (TREE_CODE (max_index
) == INTEGER_CST
);
477 /* A zero-sized array, which is accepted as an extension, will
478 have an upper bound of -1. */
479 if (!tree_int_cst_equal (max_index
, integer_minus_one_node
))
483 /* If this is a one element array, we just use a regular init. */
484 if (tree_int_cst_equal (size_zero_node
, max_index
))
485 ce
.index
= size_zero_node
;
487 ce
.index
= build2 (RANGE_EXPR
, sizetype
, size_zero_node
, max_index
);
489 ce
.value
= build_value_init (TREE_TYPE (type
), complain
);
490 ce
.value
= maybe_constant_init (ce
.value
);
491 if (ce
.value
== error_mark_node
)
492 return error_mark_node
;
497 /* We shouldn't have gotten here for anything that would need
498 non-trivial initialization, and gimplify_init_ctor_preeval
499 would need to be fixed to allow it. */
500 gcc_assert (TREE_CODE (ce
.value
) != TARGET_EXPR
501 && TREE_CODE (ce
.value
) != AGGR_INIT_EXPR
);
504 /* Build a constructor to contain the initializations. */
505 return build_constructor (type
, v
);
507 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
509 if (complain
& tf_error
)
510 error ("value-initialization of function type %qT", type
);
511 return error_mark_node
;
513 else if (TYPE_REF_P (type
))
515 if (complain
& tf_error
)
516 error ("value-initialization of reference type %qT", type
);
517 return error_mark_node
;
520 return build_zero_init (type
, NULL_TREE
, /*static_storage_p=*/false);
523 /* Initialize current class with INIT, a TREE_LIST of
524 arguments for a target constructor. If TREE_LIST is void_type_node,
525 an empty initializer list was given. */
528 perform_target_ctor (tree init
)
530 tree decl
= current_class_ref
;
531 tree type
= current_class_type
;
533 finish_expr_stmt (build_aggr_init (decl
, init
,
534 LOOKUP_NORMAL
|LOOKUP_DELEGATING_CONS
,
535 tf_warning_or_error
));
536 if (type_build_dtor_call (type
))
538 tree expr
= build_delete (input_location
,
539 type
, decl
, sfk_complete_destructor
,
543 0, tf_warning_or_error
);
544 if (expr
!= error_mark_node
545 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
546 finish_eh_cleanup (expr
);
550 /* Return the non-static data initializer for FIELD_DECL MEMBER. */
552 static GTY((cache
)) decl_tree_cache_map
*nsdmi_inst
;
555 get_nsdmi (tree member
, bool in_ctor
, tsubst_flags_t complain
)
558 tree save_ccp
= current_class_ptr
;
559 tree save_ccr
= current_class_ref
;
561 if (DECL_LANG_SPECIFIC (member
) && DECL_TEMPLATE_INFO (member
))
563 init
= DECL_INITIAL (DECL_TI_TEMPLATE (member
));
565 = cp_expr_loc_or_loc (init
, DECL_SOURCE_LOCATION (member
));
566 if (TREE_CODE (init
) == DEFERRED_PARSE
)
568 else if (tree
*slot
= hash_map_safe_get (nsdmi_inst
, member
))
570 /* Check recursive instantiation. */
571 else if (DECL_INSTANTIATING_NSDMI_P (member
))
573 if (complain
& tf_error
)
574 error_at (expr_loc
, "recursive instantiation of default member "
575 "initializer for %qD", member
);
576 init
= error_mark_node
;
582 location_t sloc
= input_location
;
583 input_location
= expr_loc
;
585 DECL_INSTANTIATING_NSDMI_P (member
) = 1;
588 tree ctx
= DECL_CONTEXT (member
);
589 if (!currently_open_class (ctx
)
590 && !LOCAL_CLASS_P (ctx
))
592 push_to_top_level ();
593 push_nested_class (ctx
);
597 gcc_checking_assert (!processing_template_decl
);
599 inject_this_parameter (ctx
, TYPE_UNQUALIFIED
);
601 start_lambda_scope (member
);
603 /* Do deferred instantiation of the NSDMI. */
604 init
= (tsubst_copy_and_build
605 (init
, DECL_TI_ARGS (member
),
606 complain
, member
, /*function_p=*/false,
607 /*integral_constant_expression_p=*/false));
608 init
= digest_nsdmi_init (member
, init
, complain
);
610 finish_lambda_scope ();
612 DECL_INSTANTIATING_NSDMI_P (member
) = 0;
614 if (init
!= error_mark_node
)
615 hash_map_safe_put
<hm_ggc
> (nsdmi_inst
, member
, init
);
620 pop_from_top_level ();
623 input_location
= sloc
;
627 init
= DECL_INITIAL (member
);
629 if (init
&& TREE_CODE (init
) == DEFERRED_PARSE
)
631 if (complain
& tf_error
)
633 error ("default member initializer for %qD required before the end "
634 "of its enclosing class", member
);
635 inform (location_of (init
), "defined here");
636 DECL_INITIAL (member
) = error_mark_node
;
638 init
= error_mark_node
;
643 current_class_ptr
= save_ccp
;
644 current_class_ref
= save_ccr
;
648 /* Use a PLACEHOLDER_EXPR when we don't have a 'this' parameter to
649 refer to; constexpr evaluation knows what to do with it. */
650 current_class_ref
= build0 (PLACEHOLDER_EXPR
, DECL_CONTEXT (member
));
651 current_class_ptr
= build_address (current_class_ref
);
654 /* Strip redundant TARGET_EXPR so we don't need to remap it, and
655 so the aggregate init code below will see a CONSTRUCTOR. */
656 bool simple_target
= (init
&& SIMPLE_TARGET_EXPR_P (init
));
658 init
= TARGET_EXPR_INITIAL (init
);
659 init
= break_out_target_exprs (init
, /*loc*/true);
660 if (in_ctor
&& init
&& TREE_CODE (init
) == TARGET_EXPR
)
661 /* This expresses the full initialization, prevent perform_member_init from
662 calling another constructor (58162). */
663 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
664 if (simple_target
&& TREE_CODE (init
) != CONSTRUCTOR
)
665 /* Now put it back so C++17 copy elision works. */
666 init
= get_target_expr (init
);
668 current_class_ptr
= save_ccp
;
669 current_class_ref
= save_ccr
;
673 /* Diagnose the flexible array MEMBER if its INITializer is non-null
674 and return true if so. Otherwise return false. */
677 maybe_reject_flexarray_init (tree member
, tree init
)
679 tree type
= TREE_TYPE (member
);
682 || TREE_CODE (type
) != ARRAY_TYPE
683 || TYPE_DOMAIN (type
))
686 /* Point at the flexible array member declaration if it's initialized
687 in-class, and at the ctor if it's initialized in a ctor member
690 if (DECL_INITIAL (member
) == init
691 || !current_function_decl
692 || DECL_DEFAULTED_FN (current_function_decl
))
693 loc
= DECL_SOURCE_LOCATION (member
);
695 loc
= DECL_SOURCE_LOCATION (current_function_decl
);
697 error_at (loc
, "initializer for flexible array member %q#D", member
);
701 /* If INIT's value can come from a call to std::initializer_list<T>::begin,
702 return that function. Otherwise, NULL_TREE. */
705 find_list_begin (tree init
)
708 while (TREE_CODE (init
) == COMPOUND_EXPR
)
709 init
= TREE_OPERAND (init
, 1);
711 if (TREE_CODE (init
) == COND_EXPR
)
713 tree left
= TREE_OPERAND (init
, 1);
715 left
= TREE_OPERAND (init
, 0);
716 left
= find_list_begin (left
);
719 return find_list_begin (TREE_OPERAND (init
, 2));
721 if (TREE_CODE (init
) == CALL_EXPR
)
722 if (tree fn
= get_callee_fndecl (init
))
723 if (id_equal (DECL_NAME (fn
), "begin")
724 && is_std_init_list (DECL_CONTEXT (fn
)))
729 /* If INIT initializing MEMBER is copying the address of the underlying array
730 of an initializer_list, warn. */
733 maybe_warn_list_ctor (tree member
, tree init
)
735 tree memtype
= TREE_TYPE (member
);
736 if (!init
|| !TYPE_PTR_P (memtype
)
737 || !is_list_ctor (current_function_decl
))
740 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (current_function_decl
);
741 tree initlist
= non_reference (TREE_VALUE (parms
));
742 tree targs
= CLASSTYPE_TI_ARGS (initlist
);
743 tree elttype
= TREE_VEC_ELT (targs
, 0);
745 if (!same_type_ignoring_top_level_qualifiers_p
746 (TREE_TYPE (memtype
), elttype
))
749 tree begin
= find_list_begin (init
);
753 location_t loc
= cp_expr_loc_or_input_loc (init
);
754 warning_at (loc
, OPT_Winit_list_lifetime
,
755 "initializing %qD from %qE does not extend the lifetime "
756 "of the underlying array", member
, begin
);
759 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
760 arguments. If TREE_LIST is void_type_node, an empty initializer
761 list was given; if NULL_TREE no initializer was given. */
764 perform_member_init (tree member
, tree init
)
767 tree type
= TREE_TYPE (member
);
769 /* Use the non-static data member initializer if there was no
770 mem-initializer for this field. */
771 if (init
== NULL_TREE
)
772 init
= get_nsdmi (member
, /*ctor*/true, tf_warning_or_error
);
774 if (init
== error_mark_node
)
777 /* Effective C++ rule 12 requires that all data members be
779 if (warn_ecpp
&& init
== NULL_TREE
&& TREE_CODE (type
) != ARRAY_TYPE
)
780 warning_at (DECL_SOURCE_LOCATION (current_function_decl
), OPT_Weffc__
,
781 "%qD should be initialized in the member initialization list",
784 /* Get an lvalue for the data member. */
785 decl
= build_class_member_access_expr (current_class_ref
, member
,
786 /*access_path=*/NULL_TREE
,
787 /*preserve_reference=*/true,
788 tf_warning_or_error
);
789 if (decl
== error_mark_node
)
792 if (warn_init_self
&& init
&& TREE_CODE (init
) == TREE_LIST
793 && TREE_CHAIN (init
) == NULL_TREE
)
795 tree val
= TREE_VALUE (init
);
796 /* Handle references. */
797 if (REFERENCE_REF_P (val
))
798 val
= TREE_OPERAND (val
, 0);
799 if (TREE_CODE (val
) == COMPONENT_REF
&& TREE_OPERAND (val
, 1) == member
800 && TREE_OPERAND (val
, 0) == current_class_ref
)
801 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
802 OPT_Winit_self
, "%qD is initialized with itself",
806 if (array_of_unknown_bound_p (type
))
808 maybe_reject_flexarray_init (member
, init
);
812 if (init
&& TREE_CODE (init
) == TREE_LIST
)
815 if (DIRECT_LIST_INIT_P (TREE_VALUE (init
)))
816 init
= build_x_compound_expr_from_list (init
, ELK_MEM_INIT
,
817 tf_warning_or_error
);
818 /* We are trying to initialize an array from a ()-list. If we
819 should attempt to do so, conjure up a CONSTRUCTOR. */
820 else if (TREE_CODE (type
) == ARRAY_TYPE
821 /* P0960 is a C++20 feature. */
822 && cxx_dialect
>= cxx20
)
823 init
= do_aggregate_paren_init (init
, type
);
824 else if (!CLASS_TYPE_P (type
))
825 init
= build_x_compound_expr_from_list (init
, ELK_MEM_INIT
,
826 tf_warning_or_error
);
827 /* If we're initializing a class from a ()-list, leave the TREE_LIST
828 alone: we might call an appropriate constructor, or (in C++20)
829 do aggregate-initialization. */
832 if (init
== void_type_node
)
834 /* mem() means value-initialization. */
835 if (TREE_CODE (type
) == ARRAY_TYPE
)
837 init
= build_vec_init_expr (type
, init
, tf_warning_or_error
);
838 init
= build2 (INIT_EXPR
, type
, decl
, init
);
839 finish_expr_stmt (init
);
843 tree value
= build_value_init (type
, tf_warning_or_error
);
844 if (value
== error_mark_node
)
846 init
= build2 (INIT_EXPR
, type
, decl
, value
);
847 finish_expr_stmt (init
);
850 /* Deal with this here, as we will get confused if we try to call the
851 assignment op for an anonymous union. This can happen in a
852 synthesized copy constructor. */
853 else if (ANON_AGGR_TYPE_P (type
))
857 init
= build2 (INIT_EXPR
, type
, decl
, TREE_VALUE (init
));
858 finish_expr_stmt (init
);
862 && (TYPE_REF_P (type
)
863 || (TREE_CODE (init
) == CONSTRUCTOR
864 && (CP_AGGREGATE_TYPE_P (type
)
865 || is_std_init_list (type
)))))
867 /* With references and list-initialization, we need to deal with
868 extending temporary lifetimes. 12.2p5: "A temporary bound to a
869 reference member in a constructor’s ctor-initializer (12.6.2)
870 persists until the constructor exits." */
872 releasing_vec cleanups
;
873 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (init
), type
))
875 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
876 && CP_AGGREGATE_TYPE_P (type
))
877 init
= reshape_init (type
, init
, tf_warning_or_error
);
878 init
= digest_init (type
, init
, tf_warning_or_error
);
880 if (init
== error_mark_node
)
882 if (DECL_SIZE (member
) && integer_zerop (DECL_SIZE (member
))
883 && !TREE_SIDE_EFFECTS (init
))
884 /* Don't add trivial initialization of an empty base/field, as they
885 might not be ordered the way the back-end expects. */
887 /* A FIELD_DECL doesn't really have a suitable lifetime, but
888 make_temporary_var_for_ref_to_temp will treat it as automatic and
889 set_up_extended_ref_temp wants to use the decl in a warning. */
890 init
= extend_ref_init_temps (member
, init
, &cleanups
);
891 if (TREE_CODE (type
) == ARRAY_TYPE
892 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (type
)))
893 init
= build_vec_init_expr (type
, init
, tf_warning_or_error
);
894 init
= build2 (INIT_EXPR
, type
, decl
, init
);
895 finish_expr_stmt (init
);
896 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
897 push_cleanup (decl
, t
, false);
899 else if (type_build_ctor_call (type
)
900 || (init
&& CLASS_TYPE_P (strip_array_types (type
))))
902 if (TREE_CODE (type
) == ARRAY_TYPE
)
904 if (init
== NULL_TREE
905 || same_type_ignoring_top_level_qualifiers_p (type
,
908 if (TYPE_DOMAIN (type
) && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
910 /* Initialize the array only if it's not a flexible
911 array member (i.e., if it has an upper bound). */
912 init
= build_vec_init_expr (type
, init
, tf_warning_or_error
);
913 init
= build2 (INIT_EXPR
, type
, decl
, init
);
914 finish_expr_stmt (init
);
918 error ("invalid initializer for array member %q#D", member
);
922 int flags
= LOOKUP_NORMAL
;
923 if (DECL_DEFAULTED_FN (current_function_decl
))
924 flags
|= LOOKUP_DEFAULTED
;
925 if (CP_TYPE_CONST_P (type
)
927 && default_init_uninitialized_part (type
))
929 /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
930 vtable; still give this diagnostic. */
931 auto_diagnostic_group d
;
932 if (permerror (DECL_SOURCE_LOCATION (current_function_decl
),
933 "uninitialized const member in %q#T", type
))
934 inform (DECL_SOURCE_LOCATION (member
),
935 "%q#D should be initialized", member
);
937 finish_expr_stmt (build_aggr_init (decl
, init
, flags
,
938 tf_warning_or_error
));
943 if (init
== NULL_TREE
)
946 /* member traversal: note it leaves init NULL */
947 if (TYPE_REF_P (type
))
949 auto_diagnostic_group d
;
950 if (permerror (DECL_SOURCE_LOCATION (current_function_decl
),
951 "uninitialized reference member in %q#T", type
))
952 inform (DECL_SOURCE_LOCATION (member
),
953 "%q#D should be initialized", member
);
955 else if (CP_TYPE_CONST_P (type
))
957 auto_diagnostic_group d
;
958 if (permerror (DECL_SOURCE_LOCATION (current_function_decl
),
959 "uninitialized const member in %q#T", type
))
960 inform (DECL_SOURCE_LOCATION (member
),
961 "%q#D should be initialized", member
);
964 core_type
= strip_array_types (type
);
966 if (CLASS_TYPE_P (core_type
)
967 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
968 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
969 diagnose_uninitialized_cst_or_ref_member (core_type
,
974 maybe_warn_list_ctor (member
, init
);
977 finish_expr_stmt (cp_build_modify_expr (input_location
, decl
,
979 tf_warning_or_error
));
982 if (type_build_dtor_call (type
))
986 expr
= build_class_member_access_expr (current_class_ref
, member
,
987 /*access_path=*/NULL_TREE
,
988 /*preserve_reference=*/false,
989 tf_warning_or_error
);
990 expr
= build_delete (input_location
,
991 type
, expr
, sfk_complete_destructor
,
992 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0,
993 tf_warning_or_error
);
995 if (expr
!= error_mark_node
996 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
997 finish_eh_cleanup (expr
);
1001 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
1002 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
1005 build_field_list (tree t
, tree list
, int *uses_unions_or_anon_p
)
1009 /* Note whether or not T is a union. */
1010 if (TREE_CODE (t
) == UNION_TYPE
)
1011 *uses_unions_or_anon_p
= 1;
1013 for (fields
= TYPE_FIELDS (t
); fields
; fields
= DECL_CHAIN (fields
))
1017 /* Skip CONST_DECLs for enumeration constants and so forth. */
1018 if (TREE_CODE (fields
) != FIELD_DECL
|| DECL_ARTIFICIAL (fields
))
1021 fieldtype
= TREE_TYPE (fields
);
1023 /* For an anonymous struct or union, we must recursively
1024 consider the fields of the anonymous type. They can be
1025 directly initialized from the constructor. */
1026 if (ANON_AGGR_TYPE_P (fieldtype
))
1028 /* Add this field itself. Synthesized copy constructors
1029 initialize the entire aggregate. */
1030 list
= tree_cons (fields
, NULL_TREE
, list
);
1031 /* And now add the fields in the anonymous aggregate. */
1032 list
= build_field_list (fieldtype
, list
, uses_unions_or_anon_p
);
1033 *uses_unions_or_anon_p
= 1;
1035 /* Add this field. */
1036 else if (DECL_NAME (fields
))
1037 list
= tree_cons (fields
, NULL_TREE
, list
);
1043 /* Return the innermost aggregate scope for FIELD, whether that is
1044 the enclosing class or an anonymous aggregate within it. */
1047 innermost_aggr_scope (tree field
)
1049 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
1050 return TREE_TYPE (field
);
1052 return DECL_CONTEXT (field
);
1055 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
1056 a FIELD_DECL or BINFO in T that needs initialization. The
1057 TREE_VALUE gives the initializer, or list of initializer arguments.
1059 Return a TREE_LIST containing all of the initializations required
1060 for T, in the order in which they should be performed. The output
1061 list has the same format as the input. */
1064 sort_mem_initializers (tree t
, tree mem_inits
)
1067 tree base
, binfo
, base_binfo
;
1069 tree next_subobject
;
1070 vec
<tree
, va_gc
> *vbases
;
1072 int uses_unions_or_anon_p
= 0;
1074 /* Build up a list of initializations. The TREE_PURPOSE of entry
1075 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
1076 TREE_VALUE will be the constructor arguments, or NULL if no
1077 explicit initialization was provided. */
1078 sorted_inits
= NULL_TREE
;
1080 /* Process the virtual bases. */
1081 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
1082 vec_safe_iterate (vbases
, i
, &base
); i
++)
1083 sorted_inits
= tree_cons (base
, NULL_TREE
, sorted_inits
);
1085 /* Process the direct bases. */
1086 for (binfo
= TYPE_BINFO (t
), i
= 0;
1087 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
1088 if (!BINFO_VIRTUAL_P (base_binfo
))
1089 sorted_inits
= tree_cons (base_binfo
, NULL_TREE
, sorted_inits
);
1091 /* Process the non-static data members. */
1092 sorted_inits
= build_field_list (t
, sorted_inits
, &uses_unions_or_anon_p
);
1093 /* Reverse the entire list of initializations, so that they are in
1094 the order that they will actually be performed. */
1095 sorted_inits
= nreverse (sorted_inits
);
1097 /* If the user presented the initializers in an order different from
1098 that in which they will actually occur, we issue a warning. Keep
1099 track of the next subobject which can be explicitly initialized
1100 without issuing a warning. */
1101 next_subobject
= sorted_inits
;
1103 /* Go through the explicit initializers, filling in TREE_PURPOSE in
1104 the SORTED_INITS. */
1105 for (init
= mem_inits
; init
; init
= TREE_CHAIN (init
))
1108 tree subobject_init
;
1110 subobject
= TREE_PURPOSE (init
);
1112 /* If the explicit initializers are in sorted order, then
1113 SUBOBJECT will be NEXT_SUBOBJECT, or something following
1115 for (subobject_init
= next_subobject
;
1117 subobject_init
= TREE_CHAIN (subobject_init
))
1118 if (TREE_PURPOSE (subobject_init
) == subobject
)
1121 /* Issue a warning if the explicit initializer order does not
1122 match that which will actually occur.
1123 ??? Are all these on the correct lines? */
1124 if (warn_reorder
&& !subobject_init
)
1126 if (TREE_CODE (TREE_PURPOSE (next_subobject
)) == FIELD_DECL
)
1127 warning_at (DECL_SOURCE_LOCATION (TREE_PURPOSE (next_subobject
)),
1128 OPT_Wreorder
, "%qD will be initialized after",
1129 TREE_PURPOSE (next_subobject
));
1131 warning (OPT_Wreorder
, "base %qT will be initialized after",
1132 TREE_PURPOSE (next_subobject
));
1133 if (TREE_CODE (subobject
) == FIELD_DECL
)
1134 warning_at (DECL_SOURCE_LOCATION (subobject
),
1135 OPT_Wreorder
, " %q#D", subobject
);
1137 warning (OPT_Wreorder
, " base %qT", subobject
);
1138 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
1139 OPT_Wreorder
, " when initialized here");
1142 /* Look again, from the beginning of the list. */
1143 if (!subobject_init
)
1145 subobject_init
= sorted_inits
;
1146 while (TREE_PURPOSE (subobject_init
) != subobject
)
1147 subobject_init
= TREE_CHAIN (subobject_init
);
1150 /* It is invalid to initialize the same subobject more than
1152 if (TREE_VALUE (subobject_init
))
1154 if (TREE_CODE (subobject
) == FIELD_DECL
)
1155 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1156 "multiple initializations given for %qD",
1159 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1160 "multiple initializations given for base %qT",
1164 /* Record the initialization. */
1165 TREE_VALUE (subobject_init
) = TREE_VALUE (init
);
1166 /* Carry over the dummy TREE_TYPE node containing the source location. */
1167 TREE_TYPE (subobject_init
) = TREE_TYPE (init
);
1168 next_subobject
= subobject_init
;
1171 /* [class.base.init]
1173 If a ctor-initializer specifies more than one mem-initializer for
1174 multiple members of the same union (including members of
1175 anonymous unions), the ctor-initializer is ill-formed.
1177 Here we also splice out uninitialized union members. */
1178 if (uses_unions_or_anon_p
)
1180 tree
*last_p
= NULL
;
1182 for (p
= &sorted_inits
; *p
; )
1189 field
= TREE_PURPOSE (init
);
1191 /* Skip base classes. */
1192 if (TREE_CODE (field
) != FIELD_DECL
)
1195 /* If this is an anonymous aggregate with no explicit initializer,
1197 if (!TREE_VALUE (init
) && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
1200 /* See if this field is a member of a union, or a member of a
1201 structure contained in a union, etc. */
1202 ctx
= innermost_aggr_scope (field
);
1204 /* If this field is not a member of a union, skip it. */
1205 if (TREE_CODE (ctx
) != UNION_TYPE
1206 && !ANON_AGGR_TYPE_P (ctx
))
1209 /* If this union member has no explicit initializer and no NSDMI,
1211 if (TREE_VALUE (init
) || DECL_INITIAL (field
))
1216 /* It's only an error if we have two initializers for the same
1224 /* See if LAST_FIELD and the field initialized by INIT are
1225 members of the same union (or the union itself). If so, there's
1226 a problem, unless they're actually members of the same structure
1227 which is itself a member of a union. For example, given:
1229 union { struct { int i; int j; }; };
1231 initializing both `i' and `j' makes sense. */
1232 ctx
= common_enclosing_class
1233 (innermost_aggr_scope (field
),
1234 innermost_aggr_scope (TREE_PURPOSE (*last_p
)));
1236 if (ctx
&& (TREE_CODE (ctx
) == UNION_TYPE
1237 || ctx
== TREE_TYPE (TREE_PURPOSE (*last_p
))))
1239 /* A mem-initializer hides an NSDMI. */
1240 if (TREE_VALUE (init
) && !TREE_VALUE (*last_p
))
1241 *last_p
= TREE_CHAIN (*last_p
);
1242 else if (TREE_VALUE (*last_p
) && !TREE_VALUE (init
))
1246 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1247 "initializations for multiple members of %qT",
1256 p
= &TREE_CHAIN (*p
);
1259 *p
= TREE_CHAIN (*p
);
1264 return sorted_inits
;
1267 /* Callback for cp_walk_tree to mark all PARM_DECLs in a tree as read. */
1270 mark_exp_read_r (tree
*tp
, int *, void *)
1273 if (TREE_CODE (t
) == PARM_DECL
)
1278 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
1279 is a TREE_LIST giving the explicit mem-initializer-list for the
1280 constructor. The TREE_PURPOSE of each entry is a subobject (a
1281 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
1282 is a TREE_LIST giving the arguments to the constructor or
1283 void_type_node for an empty list of arguments. */
1286 emit_mem_initializers (tree mem_inits
)
1288 int flags
= LOOKUP_NORMAL
;
1290 /* We will already have issued an error message about the fact that
1291 the type is incomplete. */
1292 if (!COMPLETE_TYPE_P (current_class_type
))
1296 && TYPE_P (TREE_PURPOSE (mem_inits
))
1297 && same_type_p (TREE_PURPOSE (mem_inits
), current_class_type
))
1299 /* Delegating constructor. */
1300 gcc_assert (TREE_CHAIN (mem_inits
) == NULL_TREE
);
1301 perform_target_ctor (TREE_VALUE (mem_inits
));
1305 if (DECL_DEFAULTED_FN (current_function_decl
)
1306 && ! DECL_INHERITED_CTOR (current_function_decl
))
1307 flags
|= LOOKUP_DEFAULTED
;
1309 /* Sort the mem-initializers into the order in which the
1310 initializations should be performed. */
1311 mem_inits
= sort_mem_initializers (current_class_type
, mem_inits
);
1313 in_base_initializer
= 1;
1315 /* Initialize base classes. */
1317 && TREE_CODE (TREE_PURPOSE (mem_inits
)) != FIELD_DECL
);
1318 mem_inits
= TREE_CHAIN (mem_inits
))
1320 tree subobject
= TREE_PURPOSE (mem_inits
);
1321 tree arguments
= TREE_VALUE (mem_inits
);
1323 /* We already have issued an error message. */
1324 if (arguments
== error_mark_node
)
1327 /* Suppress access control when calling the inherited ctor. */
1328 bool inherited_base
= (DECL_INHERITED_CTOR (current_function_decl
)
1329 && flag_new_inheriting_ctors
1332 push_deferring_access_checks (dk_deferred
);
1334 if (arguments
== NULL_TREE
)
1336 /* If these initializations are taking place in a copy constructor,
1337 the base class should probably be explicitly initialized if there
1338 is a user-defined constructor in the base class (other than the
1339 default constructor, which will be called anyway). */
1341 && DECL_COPY_CONSTRUCTOR_P (current_function_decl
)
1342 && type_has_user_nondefault_constructor (BINFO_TYPE (subobject
)))
1343 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
1344 OPT_Wextra
, "base class %q#T should be explicitly "
1345 "initialized in the copy constructor",
1346 BINFO_TYPE (subobject
));
1349 /* Initialize the base. */
1350 if (!BINFO_VIRTUAL_P (subobject
))
1354 base_addr
= build_base_path (PLUS_EXPR
, current_class_ptr
,
1355 subobject
, 1, tf_warning_or_error
);
1356 expand_aggr_init_1 (subobject
, NULL_TREE
,
1357 cp_build_fold_indirect_ref (base_addr
),
1360 tf_warning_or_error
);
1361 expand_cleanup_for_base (subobject
, NULL_TREE
);
1363 else if (!ABSTRACT_CLASS_TYPE_P (current_class_type
))
1364 /* C++14 DR1658 Means we do not have to construct vbases of
1365 abstract classes. */
1366 construct_virtual_base (subobject
, arguments
);
1368 /* When not constructing vbases of abstract classes, at least mark
1369 the arguments expressions as read to avoid
1370 -Wunused-but-set-parameter false positives. */
1371 cp_walk_tree (&arguments
, mark_exp_read_r
, NULL
, NULL
);
1374 pop_deferring_access_checks ();
1376 in_base_initializer
= 0;
1378 /* Initialize the vptrs. */
1379 initialize_vtbl_ptrs (current_class_ptr
);
1381 /* Initialize the data members. */
1384 /* If this initializer was explicitly provided, then the dummy TREE_TYPE
1385 node contains the source location. */
1386 iloc_sentinel
ils (EXPR_LOCATION (TREE_TYPE (mem_inits
)));
1388 perform_member_init (TREE_PURPOSE (mem_inits
),
1389 TREE_VALUE (mem_inits
));
1390 mem_inits
= TREE_CHAIN (mem_inits
);
1394 /* Returns the address of the vtable (i.e., the value that should be
1395 assigned to the vptr) for BINFO. */
1398 build_vtbl_address (tree binfo
)
1400 tree binfo_for
= binfo
;
1403 if (BINFO_VPTR_INDEX (binfo
) && BINFO_VIRTUAL_P (binfo
))
1404 /* If this is a virtual primary base, then the vtable we want to store
1405 is that for the base this is being used as the primary base of. We
1406 can't simply skip the initialization, because we may be expanding the
1407 inits of a subobject constructor where the virtual base layout
1408 can be different. */
1409 while (BINFO_PRIMARY_P (binfo_for
))
1410 binfo_for
= BINFO_INHERITANCE_CHAIN (binfo_for
);
1412 /* Figure out what vtable BINFO's vtable is based on, and mark it as
1414 vtbl
= get_vtbl_decl_for_binfo (binfo_for
);
1415 TREE_USED (vtbl
) = true;
1417 /* Now compute the address to use when initializing the vptr. */
1418 vtbl
= unshare_expr (BINFO_VTABLE (binfo_for
));
1420 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
1425 /* This code sets up the virtual function tables appropriate for
1426 the pointer DECL. It is a one-ply initialization.
1428 BINFO is the exact type that DECL is supposed to be. In
1429 multiple inheritance, this might mean "C's A" if C : A, B. */
1432 expand_virtual_init (tree binfo
, tree decl
)
1434 tree vtbl
, vtbl_ptr
;
1437 /* Compute the initializer for vptr. */
1438 vtbl
= build_vtbl_address (binfo
);
1440 /* We may get this vptr from a VTT, if this is a subobject
1441 constructor or subobject destructor. */
1442 vtt_index
= BINFO_VPTR_INDEX (binfo
);
1448 /* Compute the value to use, when there's a VTT. */
1449 vtt_parm
= current_vtt_parm
;
1450 vtbl2
= fold_build_pointer_plus (vtt_parm
, vtt_index
);
1451 vtbl2
= cp_build_fold_indirect_ref (vtbl2
);
1452 vtbl2
= convert (TREE_TYPE (vtbl
), vtbl2
);
1454 /* The actual initializer is the VTT value only in the subobject
1455 constructor. In maybe_clone_body we'll substitute NULL for
1456 the vtt_parm in the case of the non-subobject constructor. */
1457 vtbl
= build_if_in_charge (vtbl
, vtbl2
);
1460 /* Compute the location of the vtpr. */
1461 vtbl_ptr
= build_vfield_ref (cp_build_fold_indirect_ref (decl
),
1463 gcc_assert (vtbl_ptr
!= error_mark_node
);
1465 /* Assign the vtable to the vptr. */
1466 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0, tf_warning_or_error
);
1467 finish_expr_stmt (cp_build_modify_expr (input_location
, vtbl_ptr
, NOP_EXPR
,
1468 vtbl
, tf_warning_or_error
));
1471 /* If an exception is thrown in a constructor, those base classes already
1472 constructed must be destroyed. This function creates the cleanup
1473 for BINFO, which has just been constructed. If FLAG is non-NULL,
1474 it is a DECL which is nonzero when this base needs to be
1478 expand_cleanup_for_base (tree binfo
, tree flag
)
1482 if (!type_build_dtor_call (BINFO_TYPE (binfo
)))
1485 /* Call the destructor. */
1486 expr
= build_special_member_call (current_class_ref
,
1487 base_dtor_identifier
,
1490 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
1491 tf_warning_or_error
);
1493 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo
)))
1497 expr
= fold_build3_loc (input_location
,
1498 COND_EXPR
, void_type_node
,
1499 c_common_truthvalue_conversion (input_location
, flag
),
1500 expr
, integer_zero_node
);
1502 finish_eh_cleanup (expr
);
1505 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
1509 construct_virtual_base (tree vbase
, tree arguments
)
1515 /* If there are virtual base classes with destructors, we need to
1516 emit cleanups to destroy them if an exception is thrown during
1517 the construction process. These exception regions (i.e., the
1518 period during which the cleanups must occur) begin from the time
1519 the construction is complete to the end of the function. If we
1520 create a conditional block in which to initialize the
1521 base-classes, then the cleanup region for the virtual base begins
1522 inside a block, and ends outside of that block. This situation
1523 confuses the sjlj exception-handling code. Therefore, we do not
1524 create a single conditional block, but one for each
1525 initialization. (That way the cleanup regions always begin
1526 in the outer block.) We trust the back end to figure out
1527 that the FLAG will not change across initializations, and
1528 avoid doing multiple tests. */
1529 flag
= DECL_CHAIN (DECL_ARGUMENTS (current_function_decl
));
1530 inner_if_stmt
= begin_if_stmt ();
1531 finish_if_stmt_cond (flag
, inner_if_stmt
);
1533 /* Compute the location of the virtual base. If we're
1534 constructing virtual bases, then we must be the most derived
1535 class. Therefore, we don't have to look up the virtual base;
1536 we already know where it is. */
1537 exp
= convert_to_base_statically (current_class_ref
, vbase
);
1539 expand_aggr_init_1 (vbase
, current_class_ref
, exp
, arguments
,
1540 0, tf_warning_or_error
);
1541 finish_then_clause (inner_if_stmt
);
1542 finish_if_stmt (inner_if_stmt
);
1544 expand_cleanup_for_base (vbase
, flag
);
1547 /* Find the context in which this FIELD can be initialized. */
1550 initializing_context (tree field
)
1552 tree t
= DECL_CONTEXT (field
);
1554 /* Anonymous union members can be initialized in the first enclosing
1555 non-anonymous union context. */
1556 while (t
&& ANON_AGGR_TYPE_P (t
))
1557 t
= TYPE_CONTEXT (t
);
1561 /* Function to give error message if member initialization specification
1562 is erroneous. FIELD is the member we decided to initialize.
1563 TYPE is the type for which the initialization is being performed.
1564 FIELD must be a member of TYPE.
1566 MEMBER_NAME is the name of the member. */
1569 member_init_ok_or_else (tree field
, tree type
, tree member_name
)
1571 if (field
== error_mark_node
)
1575 error ("class %qT does not have any field named %qD", type
,
1581 error ("%q#D is a static data member; it can only be "
1582 "initialized at its definition",
1586 if (TREE_CODE (field
) != FIELD_DECL
)
1588 error ("%q#D is not a non-static data member of %qT",
1592 if (initializing_context (field
) != type
)
1594 error ("class %qT does not have any field named %qD", type
,
1602 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1603 is a _TYPE node or TYPE_DECL which names a base for that type.
1604 Check the validity of NAME, and return either the base _TYPE, base
1605 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
1606 NULL_TREE and issue a diagnostic.
1608 An old style unnamed direct single base construction is permitted,
1609 where NAME is NULL. */
1612 expand_member_init (tree name
)
1617 if (!current_class_ref
)
1622 /* This is an obsolete unnamed base class initializer. The
1623 parser will already have warned about its use. */
1624 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type
)))
1627 error ("unnamed initializer for %qT, which has no base classes",
1628 current_class_type
);
1631 basetype
= BINFO_TYPE
1632 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type
), 0));
1635 error ("unnamed initializer for %qT, which uses multiple inheritance",
1636 current_class_type
);
1640 else if (TYPE_P (name
))
1642 basetype
= TYPE_MAIN_VARIANT (name
);
1643 name
= TYPE_NAME (name
);
1645 else if (TREE_CODE (name
) == TYPE_DECL
)
1646 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (name
));
1648 basetype
= NULL_TREE
;
1657 if (current_template_parms
1658 || same_type_p (basetype
, current_class_type
))
1661 class_binfo
= TYPE_BINFO (current_class_type
);
1662 direct_binfo
= NULL_TREE
;
1663 virtual_binfo
= NULL_TREE
;
1665 /* Look for a direct base. */
1666 for (i
= 0; BINFO_BASE_ITERATE (class_binfo
, i
, direct_binfo
); ++i
)
1667 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo
), basetype
))
1670 /* Look for a virtual base -- unless the direct base is itself
1672 if (!direct_binfo
|| !BINFO_VIRTUAL_P (direct_binfo
))
1673 virtual_binfo
= binfo_for_vbase (basetype
, current_class_type
);
1675 /* [class.base.init]
1677 If a mem-initializer-id is ambiguous because it designates
1678 both a direct non-virtual base class and an inherited virtual
1679 base class, the mem-initializer is ill-formed. */
1680 if (direct_binfo
&& virtual_binfo
)
1682 error ("%qD is both a direct base and an indirect virtual base",
1687 if (!direct_binfo
&& !virtual_binfo
)
1689 if (CLASSTYPE_VBASECLASSES (current_class_type
))
1690 error ("type %qT is not a direct or virtual base of %qT",
1691 basetype
, current_class_type
);
1693 error ("type %qT is not a direct base of %qT",
1694 basetype
, current_class_type
);
1698 return direct_binfo
? direct_binfo
: virtual_binfo
;
1702 if (identifier_p (name
))
1703 field
= lookup_field (current_class_type
, name
, 1, false);
1707 if (member_init_ok_or_else (field
, current_class_type
, name
))
1714 /* This is like `expand_member_init', only it stores one aggregate
1717 INIT comes in two flavors: it is either a value which
1718 is to be stored in EXP, or it is a parameter list
1719 to go to a constructor, which will operate on EXP.
1720 If INIT is not a parameter list for a constructor, then set
1721 LOOKUP_ONLYCONVERTING.
1722 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1723 the initializer, if FLAGS is 0, then it is the (init) form.
1724 If `init' is a CONSTRUCTOR, then we emit a warning message,
1725 explaining that such initializations are invalid.
1727 If INIT resolves to a CALL_EXPR which happens to return
1728 something of the type we are looking for, then we know
1729 that we can safely use that call to perform the
1732 The virtual function table pointer cannot be set up here, because
1733 we do not really know its type.
1735 This never calls operator=().
1737 When initializing, nothing is CONST.
1739 A default copy constructor may have to be used to perform the
1742 A constructor or a conversion operator may have to be used to
1743 perform the initialization, but not both, as it would be ambiguous. */
1746 build_aggr_init (tree exp
, tree init
, int flags
, tsubst_flags_t complain
)
1751 tree type
= TREE_TYPE (exp
);
1752 int was_const
= TREE_READONLY (exp
);
1753 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1756 if (init
== error_mark_node
)
1757 return error_mark_node
;
1759 location_t init_loc
= (init
1760 ? cp_expr_loc_or_input_loc (init
)
1761 : location_of (exp
));
1763 TREE_READONLY (exp
) = 0;
1764 TREE_THIS_VOLATILE (exp
) = 0;
1766 if (TREE_CODE (type
) == ARRAY_TYPE
)
1768 tree itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1771 if (VAR_P (exp
) && DECL_DECOMPOSITION_P (exp
))
1774 init
= mark_rvalue_use (init
);
1776 && DECL_P (tree_strip_any_location_wrapper (init
))
1777 && !(flags
& LOOKUP_ONLYCONVERTING
))
1779 /* Wrap the initializer in a CONSTRUCTOR so that build_vec_init
1780 recognizes it as direct-initialization. */
1781 init
= build_constructor_single (init_list_type_node
,
1783 CONSTRUCTOR_IS_DIRECT_INIT (init
) = true;
1788 /* Must arrange to initialize each element of EXP
1789 from elements of INIT. */
1790 if (cv_qualified_p (type
))
1791 TREE_TYPE (exp
) = cv_unqualified (type
);
1792 if (itype
&& cv_qualified_p (itype
))
1793 TREE_TYPE (init
) = cv_unqualified (itype
);
1794 from_array
= (itype
&& same_type_p (TREE_TYPE (init
),
1797 if (init
&& !BRACE_ENCLOSED_INITIALIZER_P (init
)
1799 || (TREE_CODE (init
) != CONSTRUCTOR
1800 /* Can happen, eg, handling the compound-literals
1801 extension (ext/complit12.C). */
1802 && TREE_CODE (init
) != TARGET_EXPR
)))
1804 if (complain
& tf_error
)
1805 error_at (init_loc
, "array must be initialized "
1806 "with a brace-enclosed initializer");
1807 return error_mark_node
;
1811 stmt_expr
= build_vec_init (exp
, NULL_TREE
, init
,
1812 /*explicit_value_init_p=*/false,
1815 TREE_READONLY (exp
) = was_const
;
1816 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1817 TREE_TYPE (exp
) = type
;
1818 /* Restore the type of init unless it was used directly. */
1819 if (init
&& TREE_CODE (stmt_expr
) != INIT_EXPR
)
1820 TREE_TYPE (init
) = itype
;
1824 if (init
&& init
!= void_type_node
1825 && TREE_CODE (init
) != TREE_LIST
1826 && !(TREE_CODE (init
) == TARGET_EXPR
1827 && TARGET_EXPR_DIRECT_INIT_P (init
))
1828 && !DIRECT_LIST_INIT_P (init
))
1829 flags
|= LOOKUP_ONLYCONVERTING
;
1831 is_global
= begin_init_stmts (&stmt_expr
, &compound_stmt
);
1832 destroy_temps
= stmts_are_full_exprs_p ();
1833 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
1834 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1835 init
, LOOKUP_NORMAL
|flags
, complain
);
1836 stmt_expr
= finish_init_stmts (is_global
, stmt_expr
, compound_stmt
);
1837 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
1838 TREE_READONLY (exp
) = was_const
;
1839 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1841 if ((VAR_P (exp
) || TREE_CODE (exp
) == PARM_DECL
)
1842 && TREE_SIDE_EFFECTS (stmt_expr
)
1843 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (type
)))
1844 /* Just know that we've seen something for this node. */
1845 TREE_USED (exp
) = 1;
1851 expand_default_init (tree binfo
, tree true_exp
, tree exp
, tree init
, int flags
,
1852 tsubst_flags_t complain
)
1854 tree type
= TREE_TYPE (exp
);
1856 /* It fails because there may not be a constructor which takes
1857 its own type as the first (or only parameter), but which does
1858 take other types via a conversion. So, if the thing initializing
1859 the expression is a unit element of type X, first try X(X&),
1860 followed by initialization by X. If neither of these work
1861 out, then look hard. */
1863 vec
<tree
, va_gc
> *parms
;
1865 /* If we have direct-initialization from an initializer list, pull
1866 it out of the TREE_LIST so the code below can see it. */
1867 if (init
&& TREE_CODE (init
) == TREE_LIST
1868 && DIRECT_LIST_INIT_P (TREE_VALUE (init
)))
1870 gcc_checking_assert ((flags
& LOOKUP_ONLYCONVERTING
) == 0
1871 && TREE_CHAIN (init
) == NULL_TREE
);
1872 init
= TREE_VALUE (init
);
1873 /* Only call reshape_init if it has not been called earlier
1875 if (BRACE_ENCLOSED_INITIALIZER_P (init
) && CP_AGGREGATE_TYPE_P (type
))
1876 init
= reshape_init (type
, init
, complain
);
1879 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
1880 && CP_AGGREGATE_TYPE_P (type
))
1881 /* A brace-enclosed initializer for an aggregate. In C++0x this can
1882 happen for direct-initialization, too. */
1883 init
= digest_init (type
, init
, complain
);
1885 /* A CONSTRUCTOR of the target's type is a previously digested
1886 initializer, whether that happened just above or in
1887 cp_parser_late_parsing_nsdmi.
1889 A TARGET_EXPR with TARGET_EXPR_DIRECT_INIT_P or TARGET_EXPR_LIST_INIT_P
1890 set represents the whole initialization, so we shouldn't build up
1891 another ctor call. */
1893 && (TREE_CODE (init
) == CONSTRUCTOR
1894 || (TREE_CODE (init
) == TARGET_EXPR
1895 && (TARGET_EXPR_DIRECT_INIT_P (init
)
1896 || TARGET_EXPR_LIST_INIT_P (init
))))
1897 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (init
), type
))
1899 /* Early initialization via a TARGET_EXPR only works for
1900 complete objects. */
1901 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
|| true_exp
== exp
);
1903 init
= build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1904 TREE_SIDE_EFFECTS (init
) = 1;
1905 finish_expr_stmt (init
);
1909 if (init
&& TREE_CODE (init
) != TREE_LIST
1910 && (flags
& LOOKUP_ONLYCONVERTING
)
1911 && !unsafe_return_slot_p (exp
))
1913 /* Base subobjects should only get direct-initialization. */
1914 gcc_assert (true_exp
== exp
);
1916 if (flags
& DIRECT_BIND
)
1917 /* Do nothing. We hit this in two cases: Reference initialization,
1918 where we aren't initializing a real variable, so we don't want
1919 to run a new constructor; and catching an exception, where we
1920 have already built up the constructor call so we could wrap it
1921 in an exception region. */;
1923 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
,
1926 if (TREE_CODE (init
) == MUST_NOT_THROW_EXPR
)
1927 /* We need to protect the initialization of a catch parm with a
1928 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1929 around the TARGET_EXPR for the copy constructor. See
1930 initialize_handler_parm. */
1932 TREE_OPERAND (init
, 0) = build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
,
1933 TREE_OPERAND (init
, 0));
1934 TREE_TYPE (init
) = void_type_node
;
1937 init
= build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1938 TREE_SIDE_EFFECTS (init
) = 1;
1939 finish_expr_stmt (init
);
1943 if (init
== NULL_TREE
)
1945 else if (TREE_CODE (init
) == TREE_LIST
&& !TREE_TYPE (init
))
1947 parms
= make_tree_vector ();
1948 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
1949 vec_safe_push (parms
, TREE_VALUE (init
));
1952 parms
= make_tree_vector_single (init
);
1954 if (exp
== current_class_ref
&& current_function_decl
1955 && DECL_HAS_IN_CHARGE_PARM_P (current_function_decl
))
1957 /* Delegating constructor. */
1960 tree elt
; unsigned i
;
1962 /* Unshare the arguments for the second call. */
1963 releasing_vec parms2
;
1964 FOR_EACH_VEC_SAFE_ELT (parms
, i
, elt
)
1966 elt
= break_out_target_exprs (elt
);
1967 vec_safe_push (parms2
, elt
);
1969 complete
= build_special_member_call (exp
, complete_ctor_identifier
,
1970 &parms2
, binfo
, flags
,
1972 complete
= fold_build_cleanup_point_expr (void_type_node
, complete
);
1974 base
= build_special_member_call (exp
, base_ctor_identifier
,
1975 &parms
, binfo
, flags
,
1977 base
= fold_build_cleanup_point_expr (void_type_node
, base
);
1978 rval
= build_if_in_charge (complete
, base
);
1982 tree ctor_name
= (true_exp
== exp
1983 ? complete_ctor_identifier
: base_ctor_identifier
);
1985 rval
= build_special_member_call (exp
, ctor_name
, &parms
, binfo
, flags
,
1990 release_tree_vector (parms
);
1992 if (exp
== true_exp
&& TREE_CODE (rval
) == CALL_EXPR
)
1994 tree fn
= get_callee_fndecl (rval
);
1995 if (fn
&& DECL_DECLARED_CONSTEXPR_P (fn
))
1997 tree e
= maybe_constant_init (rval
, exp
);
1998 if (TREE_CONSTANT (e
))
1999 rval
= build2 (INIT_EXPR
, type
, exp
, e
);
2003 /* FIXME put back convert_to_void? */
2004 if (TREE_SIDE_EFFECTS (rval
))
2005 finish_expr_stmt (rval
);
2008 /* This function is responsible for initializing EXP with INIT
2011 BINFO is the binfo of the type for who we are performing the
2012 initialization. For example, if W is a virtual base class of A and B,
2014 If we are initializing B, then W must contain B's W vtable, whereas
2015 were we initializing C, W must contain C's W vtable.
2017 TRUE_EXP is nonzero if it is the true expression being initialized.
2018 In this case, it may be EXP, or may just contain EXP. The reason we
2019 need this is because if EXP is a base element of TRUE_EXP, we
2020 don't necessarily know by looking at EXP where its virtual
2021 baseclass fields should really be pointing. But we do know
2022 from TRUE_EXP. In constructors, we don't know anything about
2023 the value being initialized.
2025 FLAGS is just passed to `build_new_method_call'. See that function
2026 for its description. */
2029 expand_aggr_init_1 (tree binfo
, tree true_exp
, tree exp
, tree init
, int flags
,
2030 tsubst_flags_t complain
)
2032 tree type
= TREE_TYPE (exp
);
2034 gcc_assert (init
!= error_mark_node
&& type
!= error_mark_node
);
2035 gcc_assert (building_stmt_list_p ());
2037 /* Use a function returning the desired type to initialize EXP for us.
2038 If the function is a constructor, and its first argument is
2039 NULL_TREE, know that it was meant for us--just slide exp on
2040 in and expand the constructor. Constructors now come
2043 if (init
&& VAR_P (exp
)
2044 && COMPOUND_LITERAL_P (init
))
2046 vec
<tree
, va_gc
> *cleanups
= NULL
;
2047 /* If store_init_value returns NULL_TREE, the INIT has been
2048 recorded as the DECL_INITIAL for EXP. That means there's
2049 nothing more we have to do. */
2050 init
= store_init_value (exp
, init
, &cleanups
, flags
);
2052 finish_expr_stmt (init
);
2053 gcc_assert (!cleanups
);
2057 /* List-initialization from {} becomes value-initialization for non-aggregate
2058 classes with default constructors. Handle this here when we're
2059 initializing a base, so protected access works. */
2060 if (exp
!= true_exp
&& init
&& TREE_CODE (init
) == TREE_LIST
)
2062 tree elt
= TREE_VALUE (init
);
2063 if (DIRECT_LIST_INIT_P (elt
)
2064 && CONSTRUCTOR_ELTS (elt
) == 0
2065 && CLASSTYPE_NON_AGGREGATE (type
)
2066 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2067 init
= void_type_node
;
2070 /* If an explicit -- but empty -- initializer list was present,
2071 that's value-initialization. */
2072 if (init
== void_type_node
)
2074 /* If the type has data but no user-provided ctor, we need to zero
2076 if (!type_has_user_provided_constructor (type
)
2077 && !is_really_empty_class (type
, /*ignore_vptr*/true))
2079 tree field_size
= NULL_TREE
;
2080 if (exp
!= true_exp
&& CLASSTYPE_AS_BASE (type
) != type
)
2081 /* Don't clobber already initialized virtual bases. */
2082 field_size
= TYPE_SIZE (CLASSTYPE_AS_BASE (type
));
2083 init
= build_zero_init_1 (type
, NULL_TREE
, /*static_storage_p=*/false,
2085 init
= build2 (INIT_EXPR
, type
, exp
, init
);
2086 finish_expr_stmt (init
);
2089 /* If we don't need to mess with the constructor at all,
2091 if (! type_build_ctor_call (type
))
2094 /* Otherwise fall through and call the constructor. */
2098 /* We know that expand_default_init can handle everything we want
2100 expand_default_init (binfo
, true_exp
, exp
, init
, flags
, complain
);
2103 /* Report an error if TYPE is not a user-defined, class type. If
2104 OR_ELSE is nonzero, give an error message. */
2107 is_class_type (tree type
, int or_else
)
2109 if (type
== error_mark_node
)
2112 if (! CLASS_TYPE_P (type
))
2115 error ("%qT is not a class type", type
);
2122 get_type_value (tree name
)
2124 if (name
== error_mark_node
)
2127 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
2128 return IDENTIFIER_TYPE_VALUE (name
);
2133 /* Build a reference to a member of an aggregate. This is not a C++
2134 `&', but really something which can have its address taken, and
2135 then act as a pointer to member, for example TYPE :: FIELD can have
2136 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
2137 this expression is the operand of "&".
2139 @@ Prints out lousy diagnostics for operator <typename>
2142 @@ This function should be rewritten and placed in search.c. */
2145 build_offset_ref (tree type
, tree member
, bool address_p
,
2146 tsubst_flags_t complain
)
2149 tree basebinfo
= NULL_TREE
;
2151 /* class templates can come in as TEMPLATE_DECLs here. */
2152 if (TREE_CODE (member
) == TEMPLATE_DECL
)
2155 if (dependent_scope_p (type
) || type_dependent_expression_p (member
))
2156 return build_qualified_name (NULL_TREE
, type
, member
,
2157 /*template_p=*/false);
2159 gcc_assert (TYPE_P (type
));
2160 if (! is_class_type (type
, 1))
2161 return error_mark_node
;
2163 gcc_assert (DECL_P (member
) || BASELINK_P (member
));
2164 /* Callers should call mark_used before this point. */
2165 gcc_assert (!DECL_P (member
) || TREE_USED (member
));
2167 type
= TYPE_MAIN_VARIANT (type
);
2168 if (!COMPLETE_OR_OPEN_TYPE_P (complete_type (type
)))
2170 if (complain
& tf_error
)
2171 error ("incomplete type %qT does not have member %qD", type
, member
);
2172 return error_mark_node
;
2175 /* Entities other than non-static members need no further
2177 if (TREE_CODE (member
) == TYPE_DECL
)
2179 if (VAR_P (member
) || TREE_CODE (member
) == CONST_DECL
)
2180 return convert_from_reference (member
);
2182 if (TREE_CODE (member
) == FIELD_DECL
&& DECL_C_BIT_FIELD (member
))
2184 if (complain
& tf_error
)
2185 error ("invalid pointer to bit-field %qD", member
);
2186 return error_mark_node
;
2189 /* Set up BASEBINFO for member lookup. */
2190 decl
= maybe_dummy_object (type
, &basebinfo
);
2192 /* A lot of this logic is now handled in lookup_member. */
2193 if (BASELINK_P (member
))
2195 /* Go from the TREE_BASELINK to the member function info. */
2196 tree t
= BASELINK_FUNCTIONS (member
);
2198 if (TREE_CODE (t
) != TEMPLATE_ID_EXPR
&& !really_overloaded_fn (t
))
2200 /* Get rid of a potential OVERLOAD around it. */
2203 /* Unique functions are handled easily. */
2205 /* For non-static member of base class, we need a special rule
2206 for access checking [class.protected]:
2208 If the access is to form a pointer to member, the
2209 nested-name-specifier shall name the derived class
2210 (or any class derived from that class). */
2212 if (address_p
&& DECL_P (t
)
2213 && DECL_NONSTATIC_MEMBER_P (t
))
2214 ok
= perform_or_defer_access_check (TYPE_BINFO (type
), t
, t
,
2217 ok
= perform_or_defer_access_check (basebinfo
, t
, t
,
2220 return error_mark_node
;
2221 if (DECL_STATIC_FUNCTION_P (t
))
2226 TREE_TYPE (member
) = unknown_type_node
;
2228 else if (address_p
&& TREE_CODE (member
) == FIELD_DECL
)
2230 /* We need additional test besides the one in
2231 check_accessibility_of_qualified_id in case it is
2232 a pointer to non-static member. */
2233 if (!perform_or_defer_access_check (TYPE_BINFO (type
), member
, member
,
2235 return error_mark_node
;
2240 /* If MEMBER is non-static, then the program has fallen afoul of
2243 An id-expression that denotes a non-static data member or
2244 non-static member function of a class can only be used:
2246 -- as part of a class member access (_expr.ref_) in which the
2247 object-expression refers to the member's class or a class
2248 derived from that class, or
2250 -- to form a pointer to member (_expr.unary.op_), or
2252 -- in the body of a non-static member function of that class or
2253 of a class derived from that class (_class.mfct.non-static_), or
2255 -- in a mem-initializer for a constructor for that class or for
2256 a class derived from that class (_class.base.init_). */
2257 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member
))
2259 /* Build a representation of the qualified name suitable
2260 for use as the operand to "&" -- even though the "&" is
2261 not actually present. */
2262 member
= build2 (OFFSET_REF
, TREE_TYPE (member
), decl
, member
);
2263 /* In Microsoft mode, treat a non-static member function as if
2264 it were a pointer-to-member. */
2265 if (flag_ms_extensions
)
2267 PTRMEM_OK_P (member
) = 1;
2268 return cp_build_addr_expr (member
, complain
);
2270 if (complain
& tf_error
)
2271 error ("invalid use of non-static member function %qD",
2272 TREE_OPERAND (member
, 1));
2273 return error_mark_node
;
2275 else if (TREE_CODE (member
) == FIELD_DECL
)
2277 if (complain
& tf_error
)
2278 error ("invalid use of non-static data member %qD", member
);
2279 return error_mark_node
;
2284 member
= build2 (OFFSET_REF
, TREE_TYPE (member
), decl
, member
);
2285 PTRMEM_OK_P (member
) = 1;
2289 /* If DECL is a scalar enumeration constant or variable with a
2290 constant initializer, return the initializer (or, its initializers,
2291 recursively); otherwise, return DECL. If STRICT_P, the
2292 initializer is only returned if DECL is a
2293 constant-expression. If RETURN_AGGREGATE_CST_OK_P, it is ok to
2294 return an aggregate constant. If UNSHARE_P, return an unshared
2295 copy of the initializer. */
2298 constant_value_1 (tree decl
, bool strict_p
, bool return_aggregate_cst_ok_p
,
2301 while (TREE_CODE (decl
) == CONST_DECL
2302 || decl_constant_var_p (decl
)
2303 || (!strict_p
&& VAR_P (decl
)
2304 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl
))))
2307 /* If DECL is a static data member in a template
2308 specialization, we must instantiate it here. The
2309 initializer for the static data member is not processed
2310 until needed; we need it now. */
2311 mark_used (decl
, tf_none
);
2312 init
= DECL_INITIAL (decl
);
2313 if (init
== error_mark_node
)
2315 if (TREE_CODE (decl
) == CONST_DECL
2316 || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
))
2317 /* Treat the error as a constant to avoid cascading errors on
2318 excessively recursive template instantiation (c++/9335). */
2323 /* Initializers in templates are generally expanded during
2324 instantiation, so before that for const int i(2)
2325 INIT is a TREE_LIST with the actual initializer as
2327 if (processing_template_decl
2329 && TREE_CODE (init
) == TREE_LIST
2330 && TREE_CHAIN (init
) == NULL_TREE
)
2331 init
= TREE_VALUE (init
);
2332 /* Instantiate a non-dependent initializer for user variables. We
2333 mustn't do this for the temporary for an array compound literal;
2334 trying to instatiate the initializer will keep creating new
2335 temporaries until we crash. Probably it's not useful to do it for
2336 other artificial variables, either. */
2337 if (!DECL_ARTIFICIAL (decl
))
2338 init
= instantiate_non_dependent_or_null (init
);
2340 || !TREE_TYPE (init
)
2341 || !TREE_CONSTANT (init
)
2342 || (!return_aggregate_cst_ok_p
2343 /* Unless RETURN_AGGREGATE_CST_OK_P is true, do not
2344 return an aggregate constant (of which string
2345 literals are a special case), as we do not want
2346 to make inadvertent copies of such entities, and
2347 we must be sure that their addresses are the
2349 && (TREE_CODE (init
) == CONSTRUCTOR
2350 || TREE_CODE (init
) == STRING_CST
)))
2352 /* Don't return a CONSTRUCTOR for a variable with partial run-time
2353 initialization, since it doesn't represent the entire value.
2354 Similarly for VECTOR_CSTs created by cp_folding those
2356 if ((TREE_CODE (init
) == CONSTRUCTOR
2357 || TREE_CODE (init
) == VECTOR_CST
)
2358 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
))
2360 /* If the variable has a dynamic initializer, don't use its
2361 DECL_INITIAL which doesn't reflect the real value. */
2363 && TREE_STATIC (decl
)
2364 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
)
2365 && DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
2369 return unshare_p
? unshare_expr (decl
) : decl
;
2372 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by constant
2373 of integral or enumeration type, or a constexpr variable of scalar type,
2374 then return that value. These are those variables permitted in constant
2375 expressions by [5.19/1]. */
2378 scalar_constant_value (tree decl
)
2380 return constant_value_1 (decl
, /*strict_p=*/true,
2381 /*return_aggregate_cst_ok_p=*/false,
2382 /*unshare_p=*/true);
2385 /* Like scalar_constant_value, but can also return aggregate initializers.
2386 If UNSHARE_P, return an unshared copy of the initializer. */
2389 decl_really_constant_value (tree decl
, bool unshare_p
/*= true*/)
2391 return constant_value_1 (decl
, /*strict_p=*/true,
2392 /*return_aggregate_cst_ok_p=*/true,
2393 /*unshare_p=*/unshare_p
);
2396 /* A more relaxed version of decl_really_constant_value, used by the
2397 common C/C++ code. */
2400 decl_constant_value (tree decl
, bool unshare_p
)
2402 return constant_value_1 (decl
, /*strict_p=*/processing_template_decl
,
2403 /*return_aggregate_cst_ok_p=*/true,
2404 /*unshare_p=*/unshare_p
);
2408 decl_constant_value (tree decl
)
2410 return decl_constant_value (decl
, /*unshare_p=*/true);
2413 /* Common subroutines of build_new and build_vec_delete. */
2415 /* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
2416 the type of the object being allocated; otherwise, it's just TYPE.
2417 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
2418 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
2419 a vector of arguments to be provided as arguments to a placement
2420 new operator. This routine performs no semantic checks; it just
2421 creates and returns a NEW_EXPR. */
2424 build_raw_new_expr (location_t loc
, vec
<tree
, va_gc
> *placement
, tree type
,
2425 tree nelts
, vec
<tree
, va_gc
> *init
, int use_global_new
)
2430 /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR.
2431 If INIT is not NULL, then we want to store VOID_ZERO_NODE. This
2432 permits us to distinguish the case of a missing initializer "new
2433 int" from an empty initializer "new int()". */
2435 init_list
= NULL_TREE
;
2436 else if (init
->is_empty ())
2437 init_list
= void_node
;
2439 init_list
= build_tree_list_vec (init
);
2441 new_expr
= build4_loc (loc
, NEW_EXPR
, build_pointer_type (type
),
2442 build_tree_list_vec (placement
), type
, nelts
,
2444 NEW_EXPR_USE_GLOBAL (new_expr
) = use_global_new
;
2445 TREE_SIDE_EFFECTS (new_expr
) = 1;
2450 /* Diagnose uninitialized const members or reference members of type
2451 TYPE. USING_NEW is used to disambiguate the diagnostic between a
2452 new expression without a new-initializer and a declaration. Returns
2456 diagnose_uninitialized_cst_or_ref_member_1 (tree type
, tree origin
,
2457 bool using_new
, bool complain
)
2460 int error_count
= 0;
2462 if (type_has_user_provided_constructor (type
))
2465 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2469 if (TREE_CODE (field
) != FIELD_DECL
)
2472 field_type
= strip_array_types (TREE_TYPE (field
));
2474 if (type_has_user_provided_constructor (field_type
))
2477 if (TYPE_REF_P (field_type
))
2482 if (DECL_CONTEXT (field
) == origin
)
2485 error ("uninitialized reference member in %q#T "
2486 "using %<new%> without new-initializer", origin
);
2488 error ("uninitialized reference member in %q#T", origin
);
2493 error ("uninitialized reference member in base %q#T "
2494 "of %q#T using %<new%> without new-initializer",
2495 DECL_CONTEXT (field
), origin
);
2497 error ("uninitialized reference member in base %q#T "
2498 "of %q#T", DECL_CONTEXT (field
), origin
);
2500 inform (DECL_SOURCE_LOCATION (field
),
2501 "%q#D should be initialized", field
);
2505 if (CP_TYPE_CONST_P (field_type
))
2510 if (DECL_CONTEXT (field
) == origin
)
2513 error ("uninitialized const member in %q#T "
2514 "using %<new%> without new-initializer", origin
);
2516 error ("uninitialized const member in %q#T", origin
);
2521 error ("uninitialized const member in base %q#T "
2522 "of %q#T using %<new%> without new-initializer",
2523 DECL_CONTEXT (field
), origin
);
2525 error ("uninitialized const member in base %q#T "
2526 "of %q#T", DECL_CONTEXT (field
), origin
);
2528 inform (DECL_SOURCE_LOCATION (field
),
2529 "%q#D should be initialized", field
);
2533 if (CLASS_TYPE_P (field_type
))
2535 += diagnose_uninitialized_cst_or_ref_member_1 (field_type
, origin
,
2536 using_new
, complain
);
2542 diagnose_uninitialized_cst_or_ref_member (tree type
, bool using_new
, bool complain
)
2544 return diagnose_uninitialized_cst_or_ref_member_1 (type
, type
, using_new
, complain
);
2547 /* Call __cxa_bad_array_new_length to indicate that the size calculation
2548 overflowed. Pretend it returns sizetype so that it plays nicely in the
2552 throw_bad_array_new_length (void)
2556 tree name
= get_identifier ("__cxa_throw_bad_array_new_length");
2558 fn
= get_global_binding (name
);
2560 fn
= push_throw_library_fn
2561 (name
, build_function_type_list (sizetype
, NULL_TREE
));
2564 return build_cxx_call (fn
, 0, NULL
, tf_warning_or_error
);
2567 /* Attempt to find the initializer for flexible array field T in the
2568 initializer INIT, when non-null. Returns the initializer when
2569 successful and NULL otherwise. */
2571 find_flexarray_init (tree t
, tree init
)
2573 if (!init
|| init
== error_mark_node
)
2576 unsigned HOST_WIDE_INT idx
;
2579 /* Iterate over all top-level initializer elements. */
2580 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
, field
, elt
)
2581 /* If the member T is found, return it. */
2588 /* Attempt to verify that the argument, OPER, of a placement new expression
2589 refers to an object sufficiently large for an object of TYPE or an array
2590 of NELTS of such objects when NELTS is non-null, and issue a warning when
2591 it does not. SIZE specifies the size needed to construct the object or
2592 array and captures the result of NELTS * sizeof (TYPE). (SIZE could be
2593 greater when the array under construction requires a cookie to store
2594 NELTS. GCC's placement new expression stores the cookie when invoking
2595 a user-defined placement new operator function but not the default one.
2596 Placement new expressions with user-defined placement new operator are
2597 not diagnosed since we don't know how they use the buffer (this could
2598 be a future extension). */
2600 warn_placement_new_too_small (tree type
, tree nelts
, tree size
, tree oper
)
2602 location_t loc
= cp_expr_loc_or_input_loc (oper
);
2604 /* The number of bytes to add to or subtract from the size of the provided
2605 buffer based on an offset into an array or an array element reference.
2606 Although intermediate results may be negative (as in a[3] - 2) a valid
2607 final result cannot be. */
2608 offset_int adjust
= 0;
2609 /* True when the size of the entire destination object should be used
2610 to compute the possibly optimistic estimate of the available space. */
2611 bool use_obj_size
= false;
2612 /* True when the reference to the destination buffer is an ADDR_EXPR. */
2613 bool addr_expr
= false;
2617 /* Using a function argument or a (non-array) variable as an argument
2618 to placement new is not checked since it's unknown what it might
2620 if (TREE_CODE (oper
) == PARM_DECL
2622 || TREE_CODE (oper
) == COMPONENT_REF
)
2625 /* Evaluate any constant expressions. */
2626 size
= fold_non_dependent_expr (size
);
2628 /* Handle the common case of array + offset expression when the offset
2630 if (TREE_CODE (oper
) == POINTER_PLUS_EXPR
)
2632 /* If the offset is compile-time constant, use it to compute a more
2633 accurate estimate of the size of the buffer. Since the operand
2634 of POINTER_PLUS_EXPR is represented as an unsigned type, convert
2636 Otherwise, use the size of the entire array as an optimistic
2637 estimate (this may lead to false negatives). */
2638 tree adj
= TREE_OPERAND (oper
, 1);
2639 adj
= fold_for_warn (adj
);
2640 if (CONSTANT_CLASS_P (adj
))
2641 adjust
+= wi::to_offset (convert (ssizetype
, adj
));
2643 use_obj_size
= true;
2645 oper
= TREE_OPERAND (oper
, 0);
2650 if (TREE_CODE (oper
) == TARGET_EXPR
)
2651 oper
= TREE_OPERAND (oper
, 1);
2652 else if (TREE_CODE (oper
) == ADDR_EXPR
)
2655 oper
= TREE_OPERAND (oper
, 0);
2660 if (TREE_CODE (oper
) == ARRAY_REF
2661 && (addr_expr
|| TREE_CODE (TREE_TYPE (oper
)) == ARRAY_TYPE
))
2663 /* Similar to the offset computed above, see if the array index
2664 is a compile-time constant. If so, and unless the offset was
2665 not a compile-time constant, use the index to determine the
2666 size of the buffer. Otherwise, use the entire array as
2667 an optimistic estimate of the size. */
2668 const_tree adj
= fold_non_dependent_expr (TREE_OPERAND (oper
, 1));
2669 if (!use_obj_size
&& CONSTANT_CLASS_P (adj
))
2670 adjust
+= wi::to_offset (adj
);
2673 use_obj_size
= true;
2677 oper
= TREE_OPERAND (oper
, 0);
2680 /* Refers to the declared object that constains the subobject referenced
2681 by OPER. When the object is initialized, makes it possible to determine
2682 the actual size of a flexible array member used as the buffer passed
2683 as OPER to placement new. */
2684 tree var_decl
= NULL_TREE
;
2685 /* True when operand is a COMPONENT_REF, to distinguish flexible array
2686 members from arrays of unspecified size. */
2687 bool compref
= TREE_CODE (oper
) == COMPONENT_REF
;
2689 /* For COMPONENT_REF (i.e., a struct member) the size of the entire
2690 enclosing struct. Used to validate the adjustment (offset) into
2691 an array at the end of a struct. */
2692 offset_int compsize
= 0;
2694 /* Descend into a struct or union to find the member whose address
2695 is being used as the argument. */
2696 if (TREE_CODE (oper
) == COMPONENT_REF
)
2698 tree comptype
= TREE_TYPE (TREE_OPERAND (oper
, 0));
2699 compsize
= wi::to_offset (TYPE_SIZE_UNIT (comptype
));
2702 while (TREE_CODE (op0
= TREE_OPERAND (op0
, 0)) == COMPONENT_REF
);
2703 STRIP_ANY_LOCATION_WRAPPER (op0
);
2706 oper
= TREE_OPERAND (oper
, 1);
2709 STRIP_ANY_LOCATION_WRAPPER (oper
);
2710 tree opertype
= TREE_TYPE (oper
);
2711 if ((addr_expr
|| !INDIRECT_TYPE_P (opertype
))
2713 || TREE_CODE (oper
) == FIELD_DECL
2714 || TREE_CODE (oper
) == PARM_DECL
))
2716 /* A possibly optimistic estimate of the number of bytes available
2717 in the destination buffer. */
2718 offset_int bytes_avail
= 0;
2719 /* True when the estimate above is in fact the exact size
2720 of the destination buffer rather than an estimate. */
2721 bool exact_size
= true;
2723 /* Treat members of unions and members of structs uniformly, even
2724 though the size of a member of a union may be viewed as extending
2725 to the end of the union itself (it is by __builtin_object_size). */
2726 if ((VAR_P (oper
) || use_obj_size
)
2727 && DECL_SIZE_UNIT (oper
)
2728 && tree_fits_uhwi_p (DECL_SIZE_UNIT (oper
)))
2730 /* Use the size of the entire array object when the expression
2731 refers to a variable or its size depends on an expression
2732 that's not a compile-time constant. */
2733 bytes_avail
= wi::to_offset (DECL_SIZE_UNIT (oper
));
2734 exact_size
= !use_obj_size
;
2736 else if (tree opersize
= TYPE_SIZE_UNIT (opertype
))
2738 /* Use the size of the type of the destination buffer object
2739 as the optimistic estimate of the available space in it.
2740 Use the maximum possible size for zero-size arrays and
2741 flexible array members (except of initialized objects
2743 if (TREE_CODE (opersize
) == INTEGER_CST
)
2744 bytes_avail
= wi::to_offset (opersize
);
2747 if (bytes_avail
== 0)
2751 /* Constructing into a buffer provided by the flexible array
2752 member of a declared object (which is permitted as a G++
2753 extension). If the array member has been initialized,
2754 determine its size from the initializer. Otherwise,
2755 the array size is zero. */
2756 if (tree init
= find_flexarray_init (oper
,
2757 DECL_INITIAL (var_decl
)))
2758 bytes_avail
= wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (init
)));
2761 bytes_avail
= (wi::to_offset (TYPE_MAX_VALUE (ptrdiff_type_node
))
2765 tree_code oper_code
= TREE_CODE (opertype
);
2767 if (compref
&& oper_code
== ARRAY_TYPE
)
2769 tree nelts
= array_type_nelts_top (opertype
);
2770 tree nelts_cst
= maybe_constant_value (nelts
);
2771 if (TREE_CODE (nelts_cst
) == INTEGER_CST
2772 && integer_onep (nelts_cst
)
2774 && warn_placement_new
< 2)
2778 /* Reduce the size of the buffer by the adjustment computed above
2779 from the offset and/or the index into the array. */
2780 if (bytes_avail
< adjust
|| adjust
< 0)
2784 tree elttype
= (TREE_CODE (opertype
) == ARRAY_TYPE
2785 ? TREE_TYPE (opertype
) : opertype
);
2786 if (tree eltsize
= TYPE_SIZE_UNIT (elttype
))
2788 bytes_avail
-= adjust
* wi::to_offset (eltsize
);
2789 if (bytes_avail
< 0)
2794 /* The minimum amount of space needed for the allocation. This
2795 is an optimistic estimate that makes it possible to detect
2796 placement new invocation for some undersize buffers but not
2798 offset_int bytes_need
;
2801 nelts
= fold_for_warn (nelts
);
2803 if (CONSTANT_CLASS_P (size
))
2804 bytes_need
= wi::to_offset (size
);
2805 else if (nelts
&& CONSTANT_CLASS_P (nelts
))
2806 bytes_need
= (wi::to_offset (nelts
)
2807 * wi::to_offset (TYPE_SIZE_UNIT (type
)));
2808 else if (tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
2809 bytes_need
= wi::to_offset (TYPE_SIZE_UNIT (type
));
2812 /* The type is a VLA. */
2816 if (bytes_avail
< bytes_need
)
2819 if (CONSTANT_CLASS_P (nelts
))
2820 warning_at (loc
, OPT_Wplacement_new_
,
2822 "placement new constructing an object of type "
2823 "%<%T [%wu]%> and size %qwu in a region of type %qT "
2825 : "placement new constructing an object of type "
2826 "%<%T [%wu]%> and size %qwu in a region of type %qT "
2827 "and size at most %qwu",
2828 type
, tree_to_uhwi (nelts
), bytes_need
.to_uhwi (),
2829 opertype
, bytes_avail
.to_uhwi ());
2831 warning_at (loc
, OPT_Wplacement_new_
,
2833 "placement new constructing an array of objects "
2834 "of type %qT and size %qwu in a region of type %qT "
2836 : "placement new constructing an array of objects "
2837 "of type %qT and size %qwu in a region of type %qT "
2838 "and size at most %qwu",
2839 type
, bytes_need
.to_uhwi (), opertype
,
2840 bytes_avail
.to_uhwi ());
2842 warning_at (loc
, OPT_Wplacement_new_
,
2844 "placement new constructing an object of type %qT "
2845 "and size %qwu in a region of type %qT and size %qwi"
2846 : "placement new constructing an object of type %qT "
2847 "and size %qwu in a region of type %qT and size "
2849 type
, bytes_need
.to_uhwi (), opertype
,
2850 bytes_avail
.to_uhwi ());
2855 /* True if alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__. */
2858 type_has_new_extended_alignment (tree t
)
2860 return (aligned_new_threshold
2861 && TYPE_ALIGN_UNIT (t
) > (unsigned)aligned_new_threshold
);
2864 /* Return the alignment we expect malloc to guarantee. This should just be
2865 MALLOC_ABI_ALIGNMENT, but that macro defaults to only BITS_PER_WORD for some
2866 reason, so don't let the threshold be smaller than max_align_t_align. */
2871 return MAX (max_align_t_align(), MALLOC_ABI_ALIGNMENT
);
2874 /* Determine whether an allocation function is a namespace-scope
2875 non-replaceable placement new function. See DR 1748. */
2877 std_placement_new_fn_p (tree alloc_fn
)
2879 if (DECL_NAMESPACE_SCOPE_P (alloc_fn
))
2881 tree first_arg
= TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn
)));
2882 if ((TREE_VALUE (first_arg
) == ptr_type_node
)
2883 && TREE_CHAIN (first_arg
) == void_list_node
)
2889 /* For element type ELT_TYPE, return the appropriate type of the heap object
2890 containing such element(s). COOKIE_SIZE is NULL or the size of cookie
2891 in bytes. FULL_SIZE is NULL if it is unknown how big the heap allocation
2892 will be, otherwise size of the heap object. If COOKIE_SIZE is NULL,
2893 return array type ELT_TYPE[FULL_SIZE / sizeof(ELT_TYPE)], otherwise return
2894 struct { size_t[COOKIE_SIZE/sizeof(size_t)]; ELT_TYPE[N]; }
2895 where N is nothing (flexible array member) if FULL_SIZE is NULL, otherwise
2896 it is computed such that the size of the struct fits into FULL_SIZE. */
2899 build_new_constexpr_heap_type (tree elt_type
, tree cookie_size
, tree full_size
)
2901 gcc_assert (cookie_size
== NULL_TREE
|| tree_fits_uhwi_p (cookie_size
));
2902 gcc_assert (full_size
== NULL_TREE
|| tree_fits_uhwi_p (full_size
));
2903 unsigned HOST_WIDE_INT csz
= cookie_size
? tree_to_uhwi (cookie_size
) : 0;
2904 tree itype2
= NULL_TREE
;
2907 unsigned HOST_WIDE_INT fsz
= tree_to_uhwi (full_size
);
2908 gcc_assert (fsz
>= csz
);
2910 fsz
/= int_size_in_bytes (elt_type
);
2911 itype2
= build_index_type (size_int (fsz
- 1));
2913 return build_cplus_array_type (elt_type
, itype2
);
2916 gcc_assert (cookie_size
);
2917 csz
/= int_size_in_bytes (sizetype
);
2918 tree itype1
= build_index_type (size_int (csz
- 1));
2919 tree atype1
= build_cplus_array_type (sizetype
, itype1
);
2920 tree atype2
= build_cplus_array_type (elt_type
, itype2
);
2921 tree rtype
= cxx_make_type (RECORD_TYPE
);
2922 TYPE_NAME (rtype
) = heap_identifier
;
2923 tree fld1
= build_decl (UNKNOWN_LOCATION
, FIELD_DECL
, NULL_TREE
, atype1
);
2924 tree fld2
= build_decl (UNKNOWN_LOCATION
, FIELD_DECL
, NULL_TREE
, atype2
);
2925 DECL_FIELD_CONTEXT (fld1
) = rtype
;
2926 DECL_FIELD_CONTEXT (fld2
) = rtype
;
2927 DECL_ARTIFICIAL (fld1
) = true;
2928 DECL_ARTIFICIAL (fld2
) = true;
2929 TYPE_FIELDS (rtype
) = fld1
;
2930 DECL_CHAIN (fld1
) = fld2
;
2931 layout_type (rtype
);
2935 /* Help the constexpr code to find the right type for the heap variable
2936 by adding a NOP_EXPR around ALLOC_CALL if needed for cookie_size.
2937 Return ALLOC_CALL or ALLOC_CALL cast to a pointer to
2938 struct { size_t[cookie_size/sizeof(size_t)]; elt_type[]; }. */
2941 maybe_wrap_new_for_constexpr (tree alloc_call
, tree elt_type
, tree cookie_size
)
2943 if (cxx_dialect
< cxx20
)
2946 if (current_function_decl
!= NULL_TREE
2947 && !DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
2950 tree call_expr
= extract_call_expr (alloc_call
);
2951 if (call_expr
== error_mark_node
)
2954 tree alloc_call_fndecl
= cp_get_callee_fndecl_nofold (call_expr
);
2955 if (alloc_call_fndecl
== NULL_TREE
2956 || !IDENTIFIER_NEW_OP_P (DECL_NAME (alloc_call_fndecl
))
2957 || CP_DECL_CONTEXT (alloc_call_fndecl
) != global_namespace
)
2960 tree rtype
= build_new_constexpr_heap_type (elt_type
, cookie_size
,
2962 return build_nop (build_pointer_type (rtype
), alloc_call
);
2965 /* Generate code for a new-expression, including calling the "operator
2966 new" function, initializing the object, and, if an exception occurs
2967 during construction, cleaning up. The arguments are as for
2968 build_raw_new_expr. This may change PLACEMENT and INIT.
2969 TYPE is the type of the object being constructed, possibly an array
2970 of NELTS elements when NELTS is non-null (in "new T[NELTS]", T may
2971 be an array of the form U[inner], with the whole expression being
2972 "new U[NELTS][inner]"). */
2975 build_new_1 (vec
<tree
, va_gc
> **placement
, tree type
, tree nelts
,
2976 vec
<tree
, va_gc
> **init
, bool globally_qualified_p
,
2977 tsubst_flags_t complain
)
2980 /* True iff this is a call to "operator new[]" instead of just
2982 bool array_p
= false;
2983 /* If ARRAY_P is true, the element type of the array. This is never
2984 an ARRAY_TYPE; for something like "new int[3][4]", the
2985 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
2988 /* The type of the new-expression. (This type is always a pointer
2991 tree non_const_pointer_type
;
2992 /* The most significant array bound in int[OUTER_NELTS][inner]. */
2993 tree outer_nelts
= NULL_TREE
;
2994 /* For arrays with a non-constant number of elements, a bounds checks
2995 on the NELTS parameter to avoid integer overflow at runtime. */
2996 tree outer_nelts_check
= NULL_TREE
;
2997 bool outer_nelts_from_type
= false;
2998 /* Number of the "inner" elements in "new T[OUTER_NELTS][inner]". */
2999 offset_int inner_nelts_count
= 1;
3000 tree alloc_call
, alloc_expr
;
3001 /* Size of the inner array elements (those with constant dimensions). */
3002 offset_int inner_size
;
3003 /* The address returned by the call to "operator new". This node is
3004 a VAR_DECL and is therefore reusable. */
3007 tree cookie_expr
, init_expr
;
3008 int nothrow
, check_new
;
3009 /* If non-NULL, the number of extra bytes to allocate at the
3010 beginning of the storage allocated for an array-new expression in
3011 order to store the number of elements. */
3012 tree cookie_size
= NULL_TREE
;
3013 tree placement_first
;
3014 tree placement_expr
= NULL_TREE
;
3015 /* True if the function we are calling is a placement allocation
3017 bool placement_allocation_fn_p
;
3018 /* True if the storage must be initialized, either by a constructor
3019 or due to an explicit new-initializer. */
3020 bool is_initialized
;
3021 /* The address of the thing allocated, not including any cookie. In
3022 particular, if an array cookie is in use, DATA_ADDR is the
3023 address of the first array element. This node is a VAR_DECL, and
3024 is therefore reusable. */
3026 tree init_preeval_expr
= NULL_TREE
;
3027 tree orig_type
= type
;
3031 outer_nelts
= nelts
;
3034 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3036 /* Transforms new (T[N]) to new T[N]. The former is a GNU
3037 extension for variable N. (This also covers new T where T is
3040 nelts
= array_type_nelts_top (type
);
3041 outer_nelts
= nelts
;
3042 type
= TREE_TYPE (type
);
3043 outer_nelts_from_type
= true;
3046 /* Lots of logic below depends on whether we have a constant number of
3047 elements, so go ahead and fold it now. */
3048 const_tree cst_outer_nelts
= fold_non_dependent_expr (outer_nelts
, complain
);
3050 /* If our base type is an array, then make sure we know how many elements
3052 for (elt_type
= type
;
3053 TREE_CODE (elt_type
) == ARRAY_TYPE
;
3054 elt_type
= TREE_TYPE (elt_type
))
3056 tree inner_nelts
= array_type_nelts_top (elt_type
);
3057 tree inner_nelts_cst
= maybe_constant_value (inner_nelts
);
3058 if (TREE_CODE (inner_nelts_cst
) == INTEGER_CST
)
3060 wi::overflow_type overflow
;
3061 offset_int result
= wi::mul (wi::to_offset (inner_nelts_cst
),
3062 inner_nelts_count
, SIGNED
, &overflow
);
3065 if (complain
& tf_error
)
3066 error ("integer overflow in array size");
3067 nelts
= error_mark_node
;
3069 inner_nelts_count
= result
;
3073 if (complain
& tf_error
)
3075 error_at (cp_expr_loc_or_input_loc (inner_nelts
),
3076 "array size in new-expression must be constant");
3077 cxx_constant_value(inner_nelts
);
3079 nelts
= error_mark_node
;
3081 if (nelts
!= error_mark_node
)
3082 nelts
= cp_build_binary_op (input_location
,
3088 if (!verify_type_context (input_location
, TCTX_ALLOCATION
, elt_type
,
3089 !(complain
& tf_error
)))
3090 return error_mark_node
;
3092 if (variably_modified_type_p (elt_type
, NULL_TREE
) && (complain
& tf_error
))
3094 error ("variably modified type not allowed in new-expression");
3095 return error_mark_node
;
3098 if (nelts
== error_mark_node
)
3099 return error_mark_node
;
3101 /* Warn if we performed the (T[N]) to T[N] transformation and N is
3103 if (outer_nelts_from_type
3104 && !TREE_CONSTANT (cst_outer_nelts
))
3106 if (complain
& tf_warning_or_error
)
3108 pedwarn (cp_expr_loc_or_input_loc (outer_nelts
), OPT_Wvla
,
3109 typedef_variant_p (orig_type
)
3110 ? G_("non-constant array new length must be specified "
3111 "directly, not by %<typedef%>")
3112 : G_("non-constant array new length must be specified "
3113 "without parentheses around the type-id"));
3116 return error_mark_node
;
3119 if (VOID_TYPE_P (elt_type
))
3121 if (complain
& tf_error
)
3122 error ("invalid type %<void%> for %<new%>");
3123 return error_mark_node
;
3126 if (is_std_init_list (elt_type
))
3127 warning (OPT_Winit_list_lifetime
,
3128 "%<new%> of %<initializer_list%> does not "
3129 "extend the lifetime of the underlying array");
3131 if (abstract_virtuals_error_sfinae (ACU_NEW
, elt_type
, complain
))
3132 return error_mark_node
;
3134 is_initialized
= (type_build_ctor_call (elt_type
) || *init
!= NULL
);
3136 if (*init
== NULL
&& cxx_dialect
< cxx11
)
3138 bool maybe_uninitialized_error
= false;
3139 /* A program that calls for default-initialization [...] of an
3140 entity of reference type is ill-formed. */
3141 if (CLASSTYPE_REF_FIELDS_NEED_INIT (elt_type
))
3142 maybe_uninitialized_error
= true;
3144 /* A new-expression that creates an object of type T initializes
3145 that object as follows:
3146 - If the new-initializer is omitted:
3147 -- If T is a (possibly cv-qualified) non-POD class type
3148 (or array thereof), the object is default-initialized (8.5).
3150 -- Otherwise, the object created has indeterminate
3151 value. If T is a const-qualified type, or a (possibly
3152 cv-qualified) POD class type (or array thereof)
3153 containing (directly or indirectly) a member of
3154 const-qualified type, the program is ill-formed; */
3156 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (elt_type
))
3157 maybe_uninitialized_error
= true;
3159 if (maybe_uninitialized_error
3160 && diagnose_uninitialized_cst_or_ref_member (elt_type
,
3162 complain
& tf_error
))
3163 return error_mark_node
;
3166 if (CP_TYPE_CONST_P (elt_type
) && *init
== NULL
3167 && default_init_uninitialized_part (elt_type
))
3169 if (complain
& tf_error
)
3170 error ("uninitialized const in %<new%> of %q#T", elt_type
);
3171 return error_mark_node
;
3174 size
= size_in_bytes (elt_type
);
3177 /* Maximum available size in bytes. Half of the address space
3178 minus the cookie size. */
3180 = wi::set_bit_in_zero
<offset_int
> (TYPE_PRECISION (sizetype
) - 1);
3181 /* Maximum number of outer elements which can be allocated. */
3182 offset_int max_outer_nelts
;
3183 tree max_outer_nelts_tree
;
3185 gcc_assert (TREE_CODE (size
) == INTEGER_CST
);
3186 cookie_size
= targetm
.cxx
.get_cookie_size (elt_type
);
3187 gcc_assert (TREE_CODE (cookie_size
) == INTEGER_CST
);
3188 gcc_checking_assert (wi::ltu_p (wi::to_offset (cookie_size
), max_size
));
3189 /* Unconditionally subtract the cookie size. This decreases the
3190 maximum object size and is safe even if we choose not to use
3191 a cookie after all. */
3192 max_size
-= wi::to_offset (cookie_size
);
3193 wi::overflow_type overflow
;
3194 inner_size
= wi::mul (wi::to_offset (size
), inner_nelts_count
, SIGNED
,
3196 if (overflow
|| wi::gtu_p (inner_size
, max_size
))
3198 if (complain
& tf_error
)
3200 cst_size_error error
;
3202 error
= cst_size_overflow
;
3205 error
= cst_size_too_big
;
3206 size
= size_binop (MULT_EXPR
, size
,
3207 wide_int_to_tree (sizetype
,
3208 inner_nelts_count
));
3209 size
= cp_fully_fold (size
);
3211 invalid_array_size_error (input_location
, error
, size
,
3212 /*name=*/NULL_TREE
);
3214 return error_mark_node
;
3217 max_outer_nelts
= wi::udiv_trunc (max_size
, inner_size
);
3218 max_outer_nelts_tree
= wide_int_to_tree (sizetype
, max_outer_nelts
);
3220 size
= size_binop (MULT_EXPR
, size
, fold_convert (sizetype
, nelts
));
3222 if (TREE_CODE (cst_outer_nelts
) == INTEGER_CST
)
3224 if (tree_int_cst_lt (max_outer_nelts_tree
, cst_outer_nelts
))
3226 /* When the array size is constant, check it at compile time
3227 to make sure it doesn't exceed the implementation-defined
3228 maximum, as required by C++ 14 (in C++ 11 this requirement
3229 isn't explicitly stated but it's enforced anyway -- see
3230 grokdeclarator in cp/decl.c). */
3231 if (complain
& tf_error
)
3233 size
= cp_fully_fold (size
);
3234 invalid_array_size_error (input_location
, cst_size_too_big
,
3237 return error_mark_node
;
3242 /* When a runtime check is necessary because the array size
3243 isn't constant, keep only the top-most seven bits (starting
3244 with the most significant non-zero bit) of the maximum size
3245 to compare the array size against, to simplify encoding the
3246 constant maximum size in the instruction stream. */
3248 unsigned shift
= (max_outer_nelts
.get_precision ()) - 7
3249 - wi::clz (max_outer_nelts
);
3250 max_outer_nelts
= (max_outer_nelts
>> shift
) << shift
;
3252 outer_nelts_check
= fold_build2 (LE_EXPR
, boolean_type_node
,
3254 max_outer_nelts_tree
);
3258 tree align_arg
= NULL_TREE
;
3259 if (type_has_new_extended_alignment (elt_type
))
3260 align_arg
= build_int_cst (align_type_node
, TYPE_ALIGN_UNIT (elt_type
));
3262 alloc_fn
= NULL_TREE
;
3264 /* If PLACEMENT is a single simple pointer type not passed by
3265 reference, prepare to capture it in a temporary variable. Do
3266 this now, since PLACEMENT will change in the calls below. */
3267 placement_first
= NULL_TREE
;
3268 if (vec_safe_length (*placement
) == 1
3269 && (TYPE_PTR_P (TREE_TYPE ((**placement
)[0]))))
3270 placement_first
= (**placement
)[0];
3272 bool member_new_p
= false;
3274 /* Allocate the object. */
3278 fnname
= ovl_op_identifier (false, array_p
? VEC_NEW_EXPR
: NEW_EXPR
);
3280 member_new_p
= !globally_qualified_p
3281 && CLASS_TYPE_P (elt_type
)
3283 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type
)
3284 : TYPE_HAS_NEW_OPERATOR (elt_type
));
3288 /* Use a class-specific operator new. */
3289 /* If a cookie is required, add some extra space. */
3290 if (array_p
&& TYPE_VEC_NEW_USES_COOKIE (elt_type
))
3291 size
= size_binop (PLUS_EXPR
, size
, cookie_size
);
3294 cookie_size
= NULL_TREE
;
3295 /* No size arithmetic necessary, so the size check is
3297 if (outer_nelts_check
!= NULL
&& inner_size
== 1)
3298 outer_nelts_check
= NULL_TREE
;
3300 /* Perform the overflow check. */
3301 tree errval
= TYPE_MAX_VALUE (sizetype
);
3302 if (cxx_dialect
>= cxx11
&& flag_exceptions
)
3303 errval
= throw_bad_array_new_length ();
3304 if (outer_nelts_check
!= NULL_TREE
)
3305 size
= fold_build3 (COND_EXPR
, sizetype
, outer_nelts_check
,
3307 /* Create the argument list. */
3308 vec_safe_insert (*placement
, 0, size
);
3309 /* Do name-lookup to find the appropriate operator. */
3310 fns
= lookup_fnfields (elt_type
, fnname
, /*protect=*/2, complain
);
3311 if (fns
== NULL_TREE
)
3313 if (complain
& tf_error
)
3314 error ("no suitable %qD found in class %qT", fnname
, elt_type
);
3315 return error_mark_node
;
3317 if (TREE_CODE (fns
) == TREE_LIST
)
3319 if (complain
& tf_error
)
3321 error ("request for member %qD is ambiguous", fnname
);
3322 print_candidates (fns
);
3324 return error_mark_node
;
3326 tree dummy
= build_dummy_object (elt_type
);
3327 alloc_call
= NULL_TREE
;
3330 vec
<tree
, va_gc
> *align_args
3331 = vec_copy_and_insert (*placement
, align_arg
, 1);
3333 = build_new_method_call (dummy
, fns
, &align_args
,
3334 /*conversion_path=*/NULL_TREE
,
3335 LOOKUP_NORMAL
, &alloc_fn
, tf_none
);
3336 /* If no matching function is found and the allocated object type
3337 has new-extended alignment, the alignment argument is removed
3338 from the argument list, and overload resolution is performed
3340 if (alloc_call
== error_mark_node
)
3341 alloc_call
= NULL_TREE
;
3344 alloc_call
= build_new_method_call (dummy
, fns
, placement
,
3345 /*conversion_path=*/NULL_TREE
,
3347 &alloc_fn
, complain
);
3351 /* Use a global operator new. */
3352 /* See if a cookie might be required. */
3353 if (!(array_p
&& TYPE_VEC_NEW_USES_COOKIE (elt_type
)))
3355 cookie_size
= NULL_TREE
;
3356 /* No size arithmetic necessary, so the size check is
3358 if (outer_nelts_check
!= NULL
&& inner_size
== 1)
3359 outer_nelts_check
= NULL_TREE
;
3362 alloc_call
= build_operator_new_call (fnname
, placement
,
3363 &size
, &cookie_size
,
3364 align_arg
, outer_nelts_check
,
3365 &alloc_fn
, complain
);
3368 if (alloc_call
== error_mark_node
)
3369 return error_mark_node
;
3371 gcc_assert (alloc_fn
!= NULL_TREE
);
3373 /* Now, check to see if this function is actually a placement
3374 allocation function. This can happen even when PLACEMENT is NULL
3375 because we might have something like:
3377 struct S { void* operator new (size_t, int i = 0); };
3379 A call to `new S' will get this allocation function, even though
3380 there is no explicit placement argument. If there is more than
3381 one argument, or there are variable arguments, then this is a
3382 placement allocation function. */
3383 placement_allocation_fn_p
3384 = (type_num_arguments (TREE_TYPE (alloc_fn
)) > 1
3385 || varargs_function_p (alloc_fn
));
3387 if (warn_aligned_new
3388 && !placement_allocation_fn_p
3389 && TYPE_ALIGN (elt_type
) > malloc_alignment ()
3390 && (warn_aligned_new
> 1
3391 || CP_DECL_CONTEXT (alloc_fn
) == global_namespace
)
3392 && !aligned_allocation_fn_p (alloc_fn
))
3394 auto_diagnostic_group d
;
3395 if (warning (OPT_Waligned_new_
, "%<new%> of type %qT with extended "
3396 "alignment %d", elt_type
, TYPE_ALIGN_UNIT (elt_type
)))
3398 inform (input_location
, "uses %qD, which does not have an alignment "
3399 "parameter", alloc_fn
);
3400 if (!aligned_new_threshold
)
3401 inform (input_location
, "use %<-faligned-new%> to enable C++17 "
3402 "over-aligned new support");
3406 /* If we found a simple case of PLACEMENT_EXPR above, then copy it
3407 into a temporary variable. */
3408 if (!processing_template_decl
3409 && TREE_CODE (alloc_call
) == CALL_EXPR
3410 && call_expr_nargs (alloc_call
) == 2
3411 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 0))) == INTEGER_TYPE
3412 && TYPE_PTR_P (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 1))))
3414 tree placement
= CALL_EXPR_ARG (alloc_call
, 1);
3416 if (placement_first
!= NULL_TREE
3417 && (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement
)))
3418 || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement
)))))
3420 placement_expr
= get_target_expr (placement_first
);
3421 CALL_EXPR_ARG (alloc_call
, 1)
3422 = fold_convert (TREE_TYPE (placement
), placement_expr
);
3426 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 1)))))
3428 /* Attempt to make the warning point at the operator new argument. */
3429 if (placement_first
)
3430 placement
= placement_first
;
3432 warn_placement_new_too_small (orig_type
, nelts
, size
, placement
);
3437 alloc_call
= maybe_wrap_new_for_constexpr (alloc_call
, elt_type
,
3440 /* In the simple case, we can stop now. */
3441 pointer_type
= build_pointer_type (type
);
3442 if (!cookie_size
&& !is_initialized
)
3443 return build_nop (pointer_type
, alloc_call
);
3445 /* Store the result of the allocation call in a variable so that we can
3446 use it more than once. */
3447 alloc_expr
= get_target_expr (alloc_call
);
3448 alloc_node
= TARGET_EXPR_SLOT (alloc_expr
);
3450 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
3451 while (TREE_CODE (alloc_call
) == COMPOUND_EXPR
)
3452 alloc_call
= TREE_OPERAND (alloc_call
, 1);
3454 /* Preevaluate the placement args so that we don't reevaluate them for a
3455 placement delete. */
3456 if (placement_allocation_fn_p
)
3459 stabilize_call (alloc_call
, &inits
);
3461 alloc_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (alloc_expr
), inits
,
3465 /* unless an allocation function is declared with an empty excep-
3466 tion-specification (_except.spec_), throw(), it indicates failure to
3467 allocate storage by throwing a bad_alloc exception (clause _except_,
3468 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
3469 cation function is declared with an empty exception-specification,
3470 throw(), it returns null to indicate failure to allocate storage and a
3471 non-null pointer otherwise.
3473 So check for a null exception spec on the op new we just called. */
3475 nothrow
= TYPE_NOTHROW_P (TREE_TYPE (alloc_fn
));
3477 = flag_check_new
|| (nothrow
&& !std_placement_new_fn_p (alloc_fn
));
3485 /* Adjust so we're pointing to the start of the object. */
3486 data_addr
= fold_build_pointer_plus (alloc_node
, cookie_size
);
3488 /* Store the number of bytes allocated so that we can know how
3489 many elements to destroy later. We use the last sizeof
3490 (size_t) bytes to store the number of elements. */
3491 cookie_ptr
= size_binop (MINUS_EXPR
, cookie_size
, size_in_bytes (sizetype
));
3492 cookie_ptr
= fold_build_pointer_plus_loc (input_location
,
3493 alloc_node
, cookie_ptr
);
3494 size_ptr_type
= build_pointer_type (sizetype
);
3495 cookie_ptr
= fold_convert (size_ptr_type
, cookie_ptr
);
3496 cookie
= cp_build_fold_indirect_ref (cookie_ptr
);
3498 cookie_expr
= build2 (MODIFY_EXPR
, sizetype
, cookie
, nelts
);
3500 if (targetm
.cxx
.cookie_has_size ())
3502 /* Also store the element size. */
3503 cookie_ptr
= fold_build_pointer_plus (cookie_ptr
,
3504 fold_build1_loc (input_location
,
3505 NEGATE_EXPR
, sizetype
,
3506 size_in_bytes (sizetype
)));
3508 cookie
= cp_build_fold_indirect_ref (cookie_ptr
);
3509 cookie
= build2 (MODIFY_EXPR
, sizetype
, cookie
,
3510 size_in_bytes (elt_type
));
3511 cookie_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (cookie_expr
),
3512 cookie
, cookie_expr
);
3517 cookie_expr
= NULL_TREE
;
3518 data_addr
= alloc_node
;
3521 /* Now use a pointer to the type we've actually allocated. */
3523 /* But we want to operate on a non-const version to start with,
3524 since we'll be modifying the elements. */
3525 non_const_pointer_type
= build_pointer_type
3526 (cp_build_qualified_type (type
, cp_type_quals (type
) & ~TYPE_QUAL_CONST
));
3528 data_addr
= fold_convert (non_const_pointer_type
, data_addr
);
3529 /* Any further uses of alloc_node will want this type, too. */
3530 alloc_node
= fold_convert (non_const_pointer_type
, alloc_node
);
3532 /* Now initialize the allocated object. Note that we preevaluate the
3533 initialization expression, apart from the actual constructor call or
3534 assignment--we do this because we want to delay the allocation as long
3535 as possible in order to minimize the size of the exception region for
3536 placement delete. */
3540 bool explicit_value_init_p
= false;
3542 if (*init
!= NULL
&& (*init
)->is_empty ())
3545 explicit_value_init_p
= true;
3548 if (processing_template_decl
)
3550 /* Avoid an ICE when converting to a base in build_simple_base_path.
3551 We'll throw this all away anyway, and build_new will create
3553 tree t
= fold_convert (build_pointer_type (elt_type
), data_addr
);
3554 /* build_value_init doesn't work in templates, and we don't need
3555 the initializer anyway since we're going to throw it away and
3556 rebuild it at instantiation time, so just build up a single
3557 constructor call to get any appropriate diagnostics. */
3558 init_expr
= cp_build_fold_indirect_ref (t
);
3559 if (type_build_ctor_call (elt_type
))
3560 init_expr
= build_special_member_call (init_expr
,
3561 complete_ctor_identifier
,
3565 stable
= stabilize_init (init_expr
, &init_preeval_expr
);
3569 tree vecinit
= NULL_TREE
;
3570 const size_t len
= vec_safe_length (*init
);
3571 if (len
== 1 && DIRECT_LIST_INIT_P ((**init
)[0]))
3573 vecinit
= (**init
)[0];
3574 if (CONSTRUCTOR_NELTS (vecinit
) == 0)
3575 /* List-value-initialization, leave it alone. */;
3578 tree arraytype
, domain
;
3579 if (TREE_CONSTANT (nelts
))
3580 domain
= compute_array_index_type (NULL_TREE
, nelts
,
3583 /* We'll check the length at runtime. */
3585 arraytype
= build_cplus_array_type (type
, domain
);
3586 /* If we have new char[4]{"foo"}, we have to reshape
3587 so that the STRING_CST isn't wrapped in { }. */
3588 vecinit
= reshape_init (arraytype
, vecinit
, complain
);
3589 /* The middle end doesn't cope with the location wrapper
3590 around a STRING_CST. */
3591 STRIP_ANY_LOCATION_WRAPPER (vecinit
);
3592 vecinit
= digest_init (arraytype
, vecinit
, complain
);
3597 if (complain
& tf_error
)
3598 error ("parenthesized initializer in array new");
3599 return error_mark_node
;
3602 = build_vec_init (data_addr
,
3603 cp_build_binary_op (input_location
,
3604 MINUS_EXPR
, outer_nelts
,
3608 explicit_value_init_p
,
3612 /* An array initialization is stable because the initialization
3613 of each element is a full-expression, so the temporaries don't
3619 init_expr
= cp_build_fold_indirect_ref (data_addr
);
3621 if (type_build_ctor_call (type
) && !explicit_value_init_p
)
3623 init_expr
= build_special_member_call (init_expr
,
3624 complete_ctor_identifier
,
3627 complain
|tf_no_cleanup
);
3629 else if (explicit_value_init_p
)
3631 /* Something like `new int()'. NO_CLEANUP is needed so
3632 we don't try and build a (possibly ill-formed)
3634 tree val
= build_value_init (type
, complain
| tf_no_cleanup
);
3635 if (val
== error_mark_node
)
3636 return error_mark_node
;
3637 init_expr
= build2 (INIT_EXPR
, type
, init_expr
, val
);
3643 /* We are processing something like `new int (10)', which
3644 means allocate an int, and initialize it with 10.
3646 In C++20, also handle `new A(1, 2)'. */
3647 if (cxx_dialect
>= cxx20
3648 && AGGREGATE_TYPE_P (type
)
3649 && (*init
)->length () > 1)
3651 ie
= build_constructor_from_vec (init_list_type_node
, *init
);
3652 CONSTRUCTOR_IS_DIRECT_INIT (ie
) = true;
3653 CONSTRUCTOR_IS_PAREN_INIT (ie
) = true;
3654 ie
= digest_init (type
, ie
, complain
);
3657 ie
= build_x_compound_expr_from_vec (*init
, "new initializer",
3659 init_expr
= cp_build_modify_expr (input_location
, init_expr
,
3660 INIT_EXPR
, ie
, complain
);
3662 /* If the initializer uses C++14 aggregate NSDMI that refer to the
3663 object being initialized, replace them now and don't try to
3665 bool had_placeholder
= false;
3666 if (!processing_template_decl
3667 && TREE_CODE (init_expr
) == INIT_EXPR
)
3668 TREE_OPERAND (init_expr
, 1)
3669 = replace_placeholders (TREE_OPERAND (init_expr
, 1),
3670 TREE_OPERAND (init_expr
, 0),
3672 stable
= (!had_placeholder
3673 && stabilize_init (init_expr
, &init_preeval_expr
));
3676 if (init_expr
== error_mark_node
)
3677 return error_mark_node
;
3679 /* If any part of the object initialization terminates by throwing an
3680 exception and a suitable deallocation function can be found, the
3681 deallocation function is called to free the memory in which the
3682 object was being constructed, after which the exception continues
3683 to propagate in the context of the new-expression. If no
3684 unambiguous matching deallocation function can be found,
3685 propagating the exception does not cause the object's memory to be
3687 if (flag_exceptions
)
3689 enum tree_code dcode
= array_p
? VEC_DELETE_EXPR
: DELETE_EXPR
;
3692 /* The Standard is unclear here, but the right thing to do
3693 is to use the same method for finding deallocation
3694 functions that we use for finding allocation functions. */
3695 cleanup
= (build_op_delete_call
3699 globally_qualified_p
,
3700 placement_allocation_fn_p
? alloc_call
: NULL_TREE
,
3707 /* This is much simpler if we were able to preevaluate all of
3708 the arguments to the constructor call. */
3710 /* CLEANUP is compiler-generated, so no diagnostics. */
3711 TREE_NO_WARNING (cleanup
) = true;
3712 init_expr
= build2 (TRY_CATCH_EXPR
, void_type_node
,
3713 init_expr
, cleanup
);
3714 /* Likewise, this try-catch is compiler-generated. */
3715 TREE_NO_WARNING (init_expr
) = true;
3718 /* Ack! First we allocate the memory. Then we set our sentry
3719 variable to true, and expand a cleanup that deletes the
3720 memory if sentry is true. Then we run the constructor, and
3721 finally clear the sentry.
3723 We need to do this because we allocate the space first, so
3724 if there are any temporaries with cleanups in the
3725 constructor args and we weren't able to preevaluate them, we
3726 need this EH region to extend until end of full-expression
3727 to preserve nesting. */
3729 tree end
, sentry
, begin
;
3731 begin
= get_target_expr (boolean_true_node
);
3732 CLEANUP_EH_ONLY (begin
) = 1;
3734 sentry
= TARGET_EXPR_SLOT (begin
);
3736 /* CLEANUP is compiler-generated, so no diagnostics. */
3737 TREE_NO_WARNING (cleanup
) = true;
3739 TARGET_EXPR_CLEANUP (begin
)
3740 = build3 (COND_EXPR
, void_type_node
, sentry
,
3741 cleanup
, void_node
);
3743 end
= build2 (MODIFY_EXPR
, TREE_TYPE (sentry
),
3744 sentry
, boolean_false_node
);
3747 = build2 (COMPOUND_EXPR
, void_type_node
, begin
,
3748 build2 (COMPOUND_EXPR
, void_type_node
, init_expr
,
3750 /* Likewise, this is compiler-generated. */
3751 TREE_NO_WARNING (init_expr
) = true;
3756 init_expr
= NULL_TREE
;
3758 /* Now build up the return value in reverse order. */
3763 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), init_expr
, rval
);
3765 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), cookie_expr
, rval
);
3767 if (rval
== data_addr
)
3768 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
3769 and return the call (which doesn't need to be adjusted). */
3770 rval
= TARGET_EXPR_INITIAL (alloc_expr
);
3775 tree ifexp
= cp_build_binary_op (input_location
,
3776 NE_EXPR
, alloc_node
,
3779 rval
= build_conditional_expr (input_location
, ifexp
, rval
,
3780 alloc_node
, complain
);
3783 /* Perform the allocation before anything else, so that ALLOC_NODE
3784 has been initialized before we start using it. */
3785 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
3788 if (init_preeval_expr
)
3789 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), init_preeval_expr
, rval
);
3791 /* A new-expression is never an lvalue. */
3792 gcc_assert (!obvalue_p (rval
));
3794 return convert (pointer_type
, rval
);
3797 /* Generate a representation for a C++ "new" expression. *PLACEMENT
3798 is a vector of placement-new arguments (or NULL if none). If NELTS
3799 is NULL, TYPE is the type of the storage to be allocated. If NELTS
3800 is not NULL, then this is an array-new allocation; TYPE is the type
3801 of the elements in the array and NELTS is the number of elements in
3802 the array. *INIT, if non-NULL, is the initializer for the new
3803 object, or an empty vector to indicate an initializer of "()". If
3804 USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
3805 rather than just "new". This may change PLACEMENT and INIT. */
3808 build_new (location_t loc
, vec
<tree
, va_gc
> **placement
, tree type
,
3809 tree nelts
, vec
<tree
, va_gc
> **init
, int use_global_new
,
3810 tsubst_flags_t complain
)
3813 vec
<tree
, va_gc
> *orig_placement
= NULL
;
3814 tree orig_nelts
= NULL_TREE
;
3815 vec
<tree
, va_gc
> *orig_init
= NULL
;
3817 if (type
== error_mark_node
)
3818 return error_mark_node
;
3820 if (nelts
== NULL_TREE
3821 /* Don't do auto deduction where it might affect mangling. */
3822 && (!processing_template_decl
|| at_function_scope_p ()))
3824 tree auto_node
= type_uses_auto (type
);
3827 tree d_init
= NULL_TREE
;
3828 const size_t len
= vec_safe_length (*init
);
3829 /* E.g. new auto(x) must have exactly one element, or
3830 a {} initializer will have one element. */
3833 d_init
= (**init
)[0];
3834 d_init
= resolve_nondeduced_context (d_init
, complain
);
3836 /* For the rest, e.g. new A(1, 2, 3), create a list. */
3842 FOR_EACH_VEC_ELT (**init
, n
, t
)
3844 t
= resolve_nondeduced_context (t
, complain
);
3845 *pp
= build_tree_list (NULL_TREE
, t
);
3846 pp
= &TREE_CHAIN (*pp
);
3849 type
= do_auto_deduction (type
, d_init
, auto_node
, complain
);
3853 if (processing_template_decl
)
3855 if (dependent_type_p (type
)
3856 || any_type_dependent_arguments_p (*placement
)
3857 || (nelts
&& type_dependent_expression_p (nelts
))
3859 || any_type_dependent_arguments_p (*init
))
3860 return build_raw_new_expr (loc
, *placement
, type
, nelts
, *init
,
3863 orig_placement
= make_tree_vector_copy (*placement
);
3867 orig_init
= make_tree_vector_copy (*init
);
3868 /* Also copy any CONSTRUCTORs in *init, since reshape_init and
3869 digest_init clobber them in place. */
3870 for (unsigned i
= 0; i
< orig_init
->length(); ++i
)
3872 tree e
= (**init
)[i
];
3873 if (TREE_CODE (e
) == CONSTRUCTOR
)
3874 (**init
)[i
] = copy_node (e
);
3878 make_args_non_dependent (*placement
);
3880 nelts
= build_non_dependent_expr (nelts
);
3881 make_args_non_dependent (*init
);
3886 location_t nelts_loc
= cp_expr_loc_or_loc (nelts
, loc
);
3887 if (!build_expr_type_conversion (WANT_INT
| WANT_ENUM
, nelts
, false))
3889 if (complain
& tf_error
)
3890 permerror (nelts_loc
,
3891 "size in array new must have integral type");
3893 return error_mark_node
;
3896 /* Try to determine the constant value only for the purposes
3897 of the diagnostic below but continue to use the original
3898 value and handle const folding later. */
3899 const_tree cst_nelts
= fold_non_dependent_expr (nelts
, complain
);
3901 /* The expression in a noptr-new-declarator is erroneous if it's of
3902 non-class type and its value before converting to std::size_t is
3903 less than zero. ... If the expression is a constant expression,
3904 the program is ill-fomed. */
3905 if (TREE_CODE (cst_nelts
) == INTEGER_CST
3906 && !valid_array_size_p (nelts_loc
, cst_nelts
, NULL_TREE
,
3907 complain
& tf_error
))
3908 return error_mark_node
;
3910 nelts
= mark_rvalue_use (nelts
);
3911 nelts
= cp_save_expr (cp_convert (sizetype
, nelts
, complain
));
3914 /* ``A reference cannot be created by the new operator. A reference
3915 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
3916 returned by new.'' ARM 5.3.3 */
3917 if (TYPE_REF_P (type
))
3919 if (complain
& tf_error
)
3920 error_at (loc
, "new cannot be applied to a reference type");
3922 return error_mark_node
;
3923 type
= TREE_TYPE (type
);
3926 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3928 if (complain
& tf_error
)
3929 error_at (loc
, "new cannot be applied to a function type");
3930 return error_mark_node
;
3933 /* P1009: Array size deduction in new-expressions. */
3934 const bool array_p
= TREE_CODE (type
) == ARRAY_TYPE
;
3935 if (*init
&& (array_p
|| (nelts
&& cxx_dialect
>= cxx20
)))
3937 /* This means we have 'new T[]()'. */
3938 if ((*init
)->is_empty ())
3940 tree ctor
= build_constructor (init_list_type_node
, NULL
);
3941 CONSTRUCTOR_IS_DIRECT_INIT (ctor
) = true;
3942 vec_safe_push (*init
, ctor
);
3944 tree
&elt
= (**init
)[0];
3945 /* The C++20 'new T[](e_0, ..., e_k)' case allowed by P0960. */
3946 if (!DIRECT_LIST_INIT_P (elt
) && cxx_dialect
>= cxx20
)
3948 tree ctor
= build_constructor_from_vec (init_list_type_node
, *init
);
3949 CONSTRUCTOR_IS_DIRECT_INIT (ctor
) = true;
3950 CONSTRUCTOR_IS_PAREN_INIT (ctor
) = true;
3952 /* We've squashed all the vector elements into the first one;
3953 truncate the rest. */
3954 (*init
)->truncate (1);
3956 /* Otherwise we should have 'new T[]{e_0, ..., e_k}'. */
3957 if (array_p
&& !TYPE_DOMAIN (type
))
3959 /* We need to reshape before deducing the bounds to handle code like
3961 struct S { int x, y; };
3962 new S[]{1, 2, 3, 4};
3964 which should deduce S[2]. But don't change ELT itself: we want to
3965 pass a list-initializer to build_new_1, even for STRING_CSTs. */
3967 if (BRACE_ENCLOSED_INITIALIZER_P (e
))
3968 e
= reshape_init (type
, e
, complain
);
3969 cp_complete_array_type (&type
, e
, /*do_default*/false);
3973 /* The type allocated must be complete. If the new-type-id was
3974 "T[N]" then we are just checking that "T" is complete here, but
3975 that is equivalent, since the value of "N" doesn't matter. */
3976 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
3977 return error_mark_node
;
3979 rval
= build_new_1 (placement
, type
, nelts
, init
, use_global_new
, complain
);
3980 if (rval
== error_mark_node
)
3981 return error_mark_node
;
3983 if (processing_template_decl
)
3985 tree ret
= build_raw_new_expr (loc
, orig_placement
, type
, orig_nelts
,
3986 orig_init
, use_global_new
);
3987 release_tree_vector (orig_placement
);
3988 release_tree_vector (orig_init
);
3992 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
3993 rval
= build1_loc (loc
, NOP_EXPR
, TREE_TYPE (rval
), rval
);
3994 TREE_NO_WARNING (rval
) = 1;
4000 build_vec_delete_1 (location_t loc
, tree base
, tree maxindex
, tree type
,
4001 special_function_kind auto_delete_vec
,
4002 int use_global_delete
, tsubst_flags_t complain
)
4005 tree ptype
= build_pointer_type (type
= complete_type (type
));
4008 /* Temporary variables used by the loop. */
4009 tree tbase
, tbase_init
;
4011 /* This is the body of the loop that implements the deletion of a
4012 single element, and moves temp variables to next elements. */
4015 /* This is the LOOP_EXPR that governs the deletion of the elements. */
4018 /* This is the thing that governs what to do after the loop has run. */
4019 tree deallocate_expr
= 0;
4021 /* This is the BIND_EXPR which holds the outermost iterator of the
4022 loop. It is convenient to set this variable up and test it before
4023 executing any other code in the loop.
4024 This is also the containing expression returned by this function. */
4025 tree controller
= NULL_TREE
;
4028 /* We should only have 1-D arrays here. */
4029 gcc_assert (TREE_CODE (type
) != ARRAY_TYPE
);
4031 if (base
== error_mark_node
|| maxindex
== error_mark_node
)
4032 return error_mark_node
;
4034 if (!verify_type_context (loc
, TCTX_DEALLOCATION
, type
,
4035 !(complain
& tf_error
)))
4036 return error_mark_node
;
4038 if (!COMPLETE_TYPE_P (type
))
4040 if (complain
& tf_warning
)
4042 auto_diagnostic_group d
;
4043 if (warning_at (loc
, OPT_Wdelete_incomplete
,
4044 "possible problem detected in invocation of "
4045 "operator %<delete []%>"))
4047 cxx_incomplete_type_diagnostic (base
, type
, DK_WARNING
);
4048 inform (loc
, "neither the destructor nor the "
4049 "class-specific operator %<delete []%> will be called, "
4050 "even if they are declared when the class is defined");
4053 /* This size won't actually be used. */
4054 size_exp
= size_one_node
;
4058 size_exp
= size_in_bytes (type
);
4060 if (! MAYBE_CLASS_TYPE_P (type
))
4062 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
4064 /* Make sure the destructor is callable. */
4065 if (type_build_dtor_call (type
))
4067 tmp
= build_delete (loc
, ptype
, base
, sfk_complete_destructor
,
4068 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1,
4070 if (tmp
== error_mark_node
)
4071 return error_mark_node
;
4076 /* The below is short by the cookie size. */
4077 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
4078 fold_convert (sizetype
, maxindex
));
4080 tbase
= create_temporary_var (ptype
);
4081 DECL_INITIAL (tbase
)
4082 = fold_build_pointer_plus_loc (loc
, fold_convert (ptype
, base
),
4084 tbase_init
= build_stmt (loc
, DECL_EXPR
, tbase
);
4085 controller
= build3 (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
4086 TREE_SIDE_EFFECTS (controller
) = 1;
4088 body
= build1 (EXIT_EXPR
, void_type_node
,
4089 build2 (EQ_EXPR
, boolean_type_node
, tbase
,
4090 fold_convert (ptype
, base
)));
4091 tmp
= fold_build1_loc (loc
, NEGATE_EXPR
, sizetype
, size_exp
);
4092 tmp
= fold_build_pointer_plus (tbase
, tmp
);
4093 tmp
= cp_build_modify_expr (loc
, tbase
, NOP_EXPR
, tmp
, complain
);
4094 if (tmp
== error_mark_node
)
4095 return error_mark_node
;
4096 body
= build_compound_expr (loc
, body
, tmp
);
4097 tmp
= build_delete (loc
, ptype
, tbase
, sfk_complete_destructor
,
4098 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1,
4100 if (tmp
== error_mark_node
)
4101 return error_mark_node
;
4102 body
= build_compound_expr (loc
, body
, tmp
);
4104 loop
= build1 (LOOP_EXPR
, void_type_node
, body
);
4105 loop
= build_compound_expr (loc
, tbase_init
, loop
);
4108 /* Delete the storage if appropriate. */
4109 if (auto_delete_vec
== sfk_deleting_destructor
)
4113 /* The below is short by the cookie size. */
4114 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
4115 fold_convert (sizetype
, maxindex
));
4117 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
4124 cookie_size
= targetm
.cxx
.get_cookie_size (type
);
4125 base_tbd
= cp_build_binary_op (loc
,
4127 cp_convert (string_type_node
,
4131 if (base_tbd
== error_mark_node
)
4132 return error_mark_node
;
4133 base_tbd
= cp_convert (ptype
, base_tbd
, complain
);
4134 /* True size with header. */
4135 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, cookie_size
);
4138 deallocate_expr
= build_op_delete_call (VEC_DELETE_EXPR
,
4139 base_tbd
, virtual_size
,
4140 use_global_delete
& 1,
4141 /*placement=*/NULL_TREE
,
4142 /*alloc_fn=*/NULL_TREE
,
4147 if (deallocate_expr
== error_mark_node
)
4148 return error_mark_node
;
4149 else if (!deallocate_expr
)
4152 body
= deallocate_expr
;
4154 /* The delete operator must be called, even if a destructor
4156 body
= build2 (TRY_FINALLY_EXPR
, void_type_node
, body
, deallocate_expr
);
4159 body
= integer_zero_node
;
4161 /* Outermost wrapper: If pointer is null, punt. */
4162 tree cond
= build2_loc (loc
, NE_EXPR
, boolean_type_node
, base
,
4163 fold_convert (TREE_TYPE (base
), nullptr_node
));
4164 /* This is a compiler generated comparison, don't emit
4165 e.g. -Wnonnull-compare warning for it. */
4166 TREE_NO_WARNING (cond
) = 1;
4167 body
= build3_loc (loc
, COND_EXPR
, void_type_node
,
4168 cond
, body
, integer_zero_node
);
4169 COND_EXPR_IS_VEC_DELETE (body
) = true;
4170 body
= build1 (NOP_EXPR
, void_type_node
, body
);
4174 TREE_OPERAND (controller
, 1) = body
;
4178 if (TREE_CODE (base
) == SAVE_EXPR
)
4179 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
4180 body
= build2 (COMPOUND_EXPR
, void_type_node
, base
, body
);
4182 return convert_to_void (body
, ICV_CAST
, complain
);
4185 /* Create an unnamed variable of the indicated TYPE. */
4188 create_temporary_var (tree type
)
4192 decl
= build_decl (input_location
,
4193 VAR_DECL
, NULL_TREE
, type
);
4194 TREE_USED (decl
) = 1;
4195 DECL_ARTIFICIAL (decl
) = 1;
4196 DECL_IGNORED_P (decl
) = 1;
4197 DECL_CONTEXT (decl
) = current_function_decl
;
4202 /* Create a new temporary variable of the indicated TYPE, initialized
4205 It is not entered into current_binding_level, because that breaks
4206 things when it comes time to do final cleanups (which take place
4207 "outside" the binding contour of the function). */
4210 get_temp_regvar (tree type
, tree init
)
4214 decl
= create_temporary_var (type
);
4215 add_decl_expr (decl
);
4217 finish_expr_stmt (cp_build_modify_expr (input_location
, decl
, INIT_EXPR
,
4218 init
, tf_warning_or_error
));
4223 /* Subroutine of build_vec_init. Returns true if assigning to an array of
4224 INNER_ELT_TYPE from INIT is trivial. */
4227 vec_copy_assign_is_trivial (tree inner_elt_type
, tree init
)
4229 tree fromtype
= inner_elt_type
;
4230 if (lvalue_p (init
))
4231 fromtype
= cp_build_reference_type (fromtype
, /*rval*/false);
4232 return is_trivially_xible (MODIFY_EXPR
, inner_elt_type
, fromtype
);
4235 /* Subroutine of build_vec_init: Check that the array has at least N
4236 elements. Other parameters are local variables in build_vec_init. */
4239 finish_length_check (tree atype
, tree iterator
, tree obase
, unsigned n
)
4241 tree nelts
= build_int_cst (ptrdiff_type_node
, n
- 1);
4242 if (TREE_CODE (atype
) != ARRAY_TYPE
)
4244 if (flag_exceptions
)
4246 tree c
= fold_build2 (LT_EXPR
, boolean_type_node
, iterator
,
4248 c
= build3 (COND_EXPR
, void_type_node
, c
,
4249 throw_bad_array_new_length (), void_node
);
4250 finish_expr_stmt (c
);
4252 /* Don't check an array new when -fno-exceptions. */
4254 else if (sanitize_flags_p (SANITIZE_BOUNDS
)
4255 && current_function_decl
!= NULL_TREE
)
4257 /* Make sure the last element of the initializer is in bounds. */
4259 (ubsan_instrument_bounds
4260 (input_location
, obase
, &nelts
, /*ignore_off_by_one*/false));
4264 /* `build_vec_init' returns tree structure that performs
4265 initialization of a vector of aggregate types.
4267 BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
4268 to the first element, of POINTER_TYPE.
4269 MAXINDEX is the maximum index of the array (one less than the
4270 number of elements). It is only used if BASE is a pointer or
4271 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
4273 INIT is the (possibly NULL) initializer.
4275 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All
4276 elements in the array are value-initialized.
4278 FROM_ARRAY is 0 if we should init everything with INIT
4279 (i.e., every element initialized from INIT).
4280 FROM_ARRAY is 1 if we should index into INIT in parallel
4281 with initialization of DECL.
4282 FROM_ARRAY is 2 if we should index into INIT in parallel,
4283 but use assignment instead of initialization. */
4286 build_vec_init (tree base
, tree maxindex
, tree init
,
4287 bool explicit_value_init_p
,
4288 int from_array
, tsubst_flags_t complain
)
4291 tree base2
= NULL_TREE
;
4292 tree itype
= NULL_TREE
;
4294 /* The type of BASE. */
4295 tree atype
= TREE_TYPE (base
);
4296 /* The type of an element in the array. */
4297 tree type
= TREE_TYPE (atype
);
4298 /* The element type reached after removing all outer array
4300 tree inner_elt_type
;
4301 /* The type of a pointer to an element in the array. */
4306 tree try_block
= NULL_TREE
;
4307 HOST_WIDE_INT num_initialized_elts
= 0;
4310 bool xvalue
= false;
4311 bool errors
= false;
4312 location_t loc
= (init
? cp_expr_loc_or_input_loc (init
)
4313 : location_of (base
));
4315 if (TREE_CODE (atype
) == ARRAY_TYPE
&& TYPE_DOMAIN (atype
))
4316 maxindex
= array_type_nelts (atype
);
4318 if (maxindex
== NULL_TREE
|| maxindex
== error_mark_node
)
4319 return error_mark_node
;
4321 maxindex
= maybe_constant_value (maxindex
);
4322 if (explicit_value_init_p
)
4325 inner_elt_type
= strip_array_types (type
);
4327 /* Look through the TARGET_EXPR around a compound literal. */
4328 if (init
&& TREE_CODE (init
) == TARGET_EXPR
4329 && TREE_CODE (TARGET_EXPR_INITIAL (init
)) == CONSTRUCTOR
4331 init
= TARGET_EXPR_INITIAL (init
);
4333 bool direct_init
= false;
4334 if (from_array
&& init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
4335 && CONSTRUCTOR_NELTS (init
) == 1)
4337 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
4338 if (TREE_CODE (TREE_TYPE (elt
)) == ARRAY_TYPE
)
4340 direct_init
= DIRECT_LIST_INIT_P (init
);
4345 /* If we have a braced-init-list or string constant, make sure that the array
4346 is big enough for all the initializers. */
4347 bool length_check
= (init
4348 && (TREE_CODE (init
) == STRING_CST
4349 || (TREE_CODE (init
) == CONSTRUCTOR
4350 && CONSTRUCTOR_NELTS (init
) > 0))
4351 && !TREE_CONSTANT (maxindex
));
4354 && TREE_CODE (atype
) == ARRAY_TYPE
4355 && TREE_CONSTANT (maxindex
)
4357 ? vec_copy_assign_is_trivial (inner_elt_type
, init
)
4358 : !TYPE_NEEDS_CONSTRUCTING (type
))
4359 && ((TREE_CODE (init
) == CONSTRUCTOR
4360 && (BRACE_ENCLOSED_INITIALIZER_P (init
)
4361 || (same_type_ignoring_top_level_qualifiers_p
4362 (atype
, TREE_TYPE (init
))))
4363 /* Don't do this if the CONSTRUCTOR might contain something
4364 that might throw and require us to clean up. */
4365 && (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
))
4366 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type
)))
4369 /* Do non-default initialization of trivial arrays resulting from
4370 brace-enclosed initializers. In this case, digest_init and
4371 store_constructor will handle the semantics for us. */
4373 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
4374 init
= digest_init (atype
, init
, complain
);
4375 stmt_expr
= build2 (INIT_EXPR
, atype
, base
, init
);
4379 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
, complain
);
4380 maxindex
= fold_simple (maxindex
);
4382 if (TREE_CODE (atype
) == ARRAY_TYPE
)
4384 ptype
= build_pointer_type (type
);
4385 base
= decay_conversion (base
, complain
);
4386 if (base
== error_mark_node
)
4387 return error_mark_node
;
4388 base
= cp_convert (ptype
, base
, complain
);
4393 /* The code we are generating looks like:
4397 ptrdiff_t iterator = maxindex;
4399 for (; iterator != -1; --iterator) {
4400 ... initialize *t1 ...
4404 ... destroy elements that were constructed ...
4409 We can omit the try and catch blocks if we know that the
4410 initialization will never throw an exception, or if the array
4411 elements do not have destructors. We can omit the loop completely if
4412 the elements of the array do not have constructors.
4414 We actually wrap the entire body of the above in a STMT_EXPR, for
4417 When copying from array to another, when the array elements have
4418 only trivial copy constructors, we should use __builtin_memcpy
4419 rather than generating a loop. That way, we could take advantage
4420 of whatever cleverness the back end has for dealing with copies
4421 of blocks of memory. */
4423 is_global
= begin_init_stmts (&stmt_expr
, &compound_stmt
);
4424 destroy_temps
= stmts_are_full_exprs_p ();
4425 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
4426 rval
= get_temp_regvar (ptype
, base
);
4427 base
= get_temp_regvar (ptype
, rval
);
4428 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
4430 /* If initializing one array from another, initialize element by
4431 element. We rely upon the below calls to do the argument
4432 checking. Evaluate the initializer before entering the try block. */
4433 if (from_array
&& init
&& TREE_CODE (init
) != CONSTRUCTOR
)
4435 if (lvalue_kind (init
) & clk_rvalueref
)
4437 base2
= decay_conversion (init
, complain
);
4438 if (base2
== error_mark_node
)
4439 return error_mark_node
;
4440 itype
= TREE_TYPE (base2
);
4441 base2
= get_temp_regvar (itype
, base2
);
4442 itype
= TREE_TYPE (itype
);
4445 /* Protect the entire array initialization so that we can destroy
4446 the partially constructed array if an exception is thrown.
4447 But don't do this if we're assigning. */
4448 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
4451 try_block
= begin_try_block ();
4454 /* Should we try to create a constant initializer? */
4455 bool try_const
= (TREE_CODE (atype
) == ARRAY_TYPE
4456 && TREE_CONSTANT (maxindex
)
4457 && (init
? TREE_CODE (init
) == CONSTRUCTOR
4458 : (type_has_constexpr_default_constructor
4460 && (literal_type_p (inner_elt_type
)
4461 || TYPE_HAS_CONSTEXPR_CTOR (inner_elt_type
)));
4462 vec
<constructor_elt
, va_gc
> *const_vec
= NULL
;
4463 bool saw_non_const
= false;
4464 /* If we're initializing a static array, we want to do static
4465 initialization of any elements with constant initializers even if
4466 some are non-constant. */
4467 bool do_static_init
= (DECL_P (obase
) && TREE_STATIC (obase
));
4469 bool empty_list
= false;
4470 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
4471 && CONSTRUCTOR_NELTS (init
) == 0)
4472 /* Skip over the handling of non-empty init lists. */
4475 /* Maybe pull out constant value when from_array? */
4477 else if (init
!= NULL_TREE
&& TREE_CODE (init
) == CONSTRUCTOR
)
4479 /* Do non-default initialization of non-trivial arrays resulting from
4480 brace-enclosed initializers. */
4481 unsigned HOST_WIDE_INT idx
;
4483 /* If the constructor already has the array type, it's been through
4484 digest_init, so we shouldn't try to do anything more. */
4485 bool digested
= same_type_p (atype
, TREE_TYPE (init
));
4489 finish_length_check (atype
, iterator
, obase
, CONSTRUCTOR_NELTS (init
));
4492 vec_alloc (const_vec
, CONSTRUCTOR_NELTS (init
));
4494 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
, field
, elt
)
4496 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
4499 num_initialized_elts
++;
4501 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
4503 one_init
= build2 (INIT_EXPR
, type
, baseref
, elt
);
4504 else if (MAYBE_CLASS_TYPE_P (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
4505 one_init
= build_aggr_init (baseref
, elt
, 0, complain
);
4507 one_init
= cp_build_modify_expr (input_location
, baseref
,
4508 NOP_EXPR
, elt
, complain
);
4509 if (one_init
== error_mark_node
)
4514 field
= size_int (idx
);
4515 tree e
= maybe_constant_init (one_init
);
4516 if (reduced_constant_expression_p (e
))
4518 CONSTRUCTOR_APPEND_ELT (const_vec
, field
, e
);
4520 one_init
= NULL_TREE
;
4522 one_init
= build2 (INIT_EXPR
, type
, baseref
, e
);
4528 tree value
= build_zero_init (TREE_TYPE (e
), NULL_TREE
,
4531 CONSTRUCTOR_APPEND_ELT (const_vec
, field
, value
);
4533 saw_non_const
= true;
4538 finish_expr_stmt (one_init
);
4539 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
4541 one_init
= cp_build_unary_op (PREINCREMENT_EXPR
, base
, false,
4543 if (one_init
== error_mark_node
)
4546 finish_expr_stmt (one_init
);
4548 one_init
= cp_build_unary_op (PREDECREMENT_EXPR
, iterator
, false,
4550 if (one_init
== error_mark_node
)
4553 finish_expr_stmt (one_init
);
4556 /* Any elements without explicit initializers get T{}. */
4559 else if (init
&& TREE_CODE (init
) == STRING_CST
)
4561 /* Check that the array is at least as long as the string. */
4563 finish_length_check (atype
, iterator
, obase
,
4564 TREE_STRING_LENGTH (init
));
4565 tree length
= build_int_cst (ptrdiff_type_node
,
4566 TREE_STRING_LENGTH (init
));
4568 /* Copy the string to the first part of the array. */
4569 tree alias_set
= build_int_cst (build_pointer_type (type
), 0);
4570 tree lhs
= build2 (MEM_REF
, TREE_TYPE (init
), base
, alias_set
);
4571 tree stmt
= build2 (MODIFY_EXPR
, void_type_node
, lhs
, init
);
4572 finish_expr_stmt (stmt
);
4574 /* Adjust the counter and pointer. */
4575 stmt
= cp_build_binary_op (loc
, MINUS_EXPR
, iterator
, length
, complain
);
4576 stmt
= build2 (MODIFY_EXPR
, void_type_node
, iterator
, stmt
);
4577 finish_expr_stmt (stmt
);
4579 stmt
= cp_build_binary_op (loc
, PLUS_EXPR
, base
, length
, complain
);
4580 stmt
= build2 (MODIFY_EXPR
, void_type_node
, base
, stmt
);
4581 finish_expr_stmt (stmt
);
4583 /* And set the rest of the array to NUL. */
4585 explicit_value_init_p
= true;
4587 else if (from_array
)
4590 /* OK, we set base2 above. */;
4591 else if (CLASS_TYPE_P (type
)
4592 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
4594 if (complain
& tf_error
)
4595 error ("initializer ends prematurely");
4600 /* Now, default-initialize any remaining elements. We don't need to
4601 do that if a) the type does not need constructing, or b) we've
4602 already initialized all the elements.
4604 We do need to keep going if we're copying an array. */
4606 if (try_const
&& !init
)
4607 /* With a constexpr default constructor, which we checked for when
4608 setting try_const above, default-initialization is equivalent to
4609 value-initialization, and build_value_init gives us something more
4610 friendly to maybe_constant_init. */
4611 explicit_value_init_p
= true;
4613 || ((type_build_ctor_call (type
) || init
|| explicit_value_init_p
)
4614 && ! (tree_fits_shwi_p (maxindex
)
4615 && (num_initialized_elts
4616 == tree_to_shwi (maxindex
) + 1))))
4618 /* If the ITERATOR is lesser or equal to -1, then we don't have to loop;
4619 we've already initialized all the elements. */
4624 for_stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
4625 finish_init_stmt (for_stmt
);
4626 finish_for_cond (build2 (GT_EXPR
, boolean_type_node
, iterator
,
4627 build_int_cst (TREE_TYPE (iterator
), -1)),
4628 for_stmt
, false, 0);
4629 elt_init
= cp_build_unary_op (PREDECREMENT_EXPR
, iterator
, false,
4631 if (elt_init
== error_mark_node
)
4633 finish_for_expr (elt_init
, for_stmt
);
4635 to
= build1 (INDIRECT_REF
, type
, base
);
4637 /* If the initializer is {}, then all elements are initialized from T{}.
4638 But for non-classes, that's the same as value-initialization. */
4641 if (cxx_dialect
>= cxx11
&& AGGREGATE_TYPE_P (type
))
4643 init
= build_constructor (init_list_type_node
, NULL
);
4648 explicit_value_init_p
= true;
4658 from
= build1 (INDIRECT_REF
, itype
, base2
);
4662 from
= build_tree_list (NULL_TREE
, from
);
4667 if (TREE_CODE (type
) == ARRAY_TYPE
)
4668 elt_init
= build_vec_init (to
, NULL_TREE
, from
, /*val_init*/false,
4669 from_array
, complain
);
4670 else if (from_array
== 2)
4671 elt_init
= cp_build_modify_expr (input_location
, to
, NOP_EXPR
,
4673 else if (type_build_ctor_call (type
))
4674 elt_init
= build_aggr_init (to
, from
, 0, complain
);
4676 elt_init
= cp_build_modify_expr (input_location
, to
, NOP_EXPR
, from
,
4681 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4683 if (init
&& !BRACE_ENCLOSED_INITIALIZER_P (init
))
4685 if ((complain
& tf_error
))
4686 error_at (loc
, "array must be initialized "
4687 "with a brace-enclosed initializer");
4688 elt_init
= error_mark_node
;
4691 elt_init
= build_vec_init (build1 (INDIRECT_REF
, type
, base
),
4693 explicit_value_init_p
,
4696 else if (explicit_value_init_p
)
4698 elt_init
= build_value_init (type
, complain
);
4699 if (elt_init
!= error_mark_node
)
4700 elt_init
= build2 (INIT_EXPR
, type
, to
, elt_init
);
4704 gcc_assert (type_build_ctor_call (type
) || init
);
4705 if (CLASS_TYPE_P (type
))
4706 elt_init
= build_aggr_init (to
, init
, 0, complain
);
4709 if (TREE_CODE (init
) == TREE_LIST
)
4710 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
4712 elt_init
= (init
== error_mark_node
4714 : build2 (INIT_EXPR
, type
, to
, init
));
4718 if (elt_init
== error_mark_node
)
4723 /* FIXME refs to earlier elts */
4724 tree e
= maybe_constant_init (elt_init
);
4725 if (reduced_constant_expression_p (e
))
4727 if (initializer_zerop (e
))
4728 /* Don't fill the CONSTRUCTOR with zeros. */
4731 elt_init
= NULL_TREE
;
4735 saw_non_const
= true;
4737 e
= build_zero_init (TREE_TYPE (e
), NULL_TREE
, true);
4744 HOST_WIDE_INT last
= tree_to_shwi (maxindex
);
4745 if (num_initialized_elts
<= last
)
4747 tree field
= size_int (num_initialized_elts
);
4748 if (num_initialized_elts
!= last
)
4749 field
= build2 (RANGE_EXPR
, sizetype
, field
,
4751 CONSTRUCTOR_APPEND_ELT (const_vec
, field
, e
);
4756 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
4757 if (elt_init
&& !errors
)
4758 finish_expr_stmt (elt_init
);
4759 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
4761 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR
, base
, false,
4764 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR
, base2
, false,
4767 finish_for_stmt (for_stmt
);
4770 /* Make sure to cleanup any partially constructed elements. */
4771 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
4775 tree m
= cp_build_binary_op (input_location
,
4776 MINUS_EXPR
, maxindex
, iterator
,
4779 /* Flatten multi-dimensional array since build_vec_delete only
4780 expects one-dimensional array. */
4781 if (TREE_CODE (type
) == ARRAY_TYPE
)
4782 m
= cp_build_binary_op (input_location
,
4784 /* Avoid mixing signed and unsigned. */
4785 convert (TREE_TYPE (m
),
4786 array_type_nelts_total (type
)),
4789 finish_cleanup_try_block (try_block
);
4790 e
= build_vec_delete_1 (input_location
, rval
, m
,
4791 inner_elt_type
, sfk_complete_destructor
,
4792 /*use_global_delete=*/0, complain
);
4793 if (e
== error_mark_node
)
4795 finish_cleanup (e
, try_block
);
4798 /* The value of the array initialization is the array itself, RVAL
4799 is a pointer to the first element. */
4800 finish_stmt_expr_expr (rval
, stmt_expr
);
4802 stmt_expr
= finish_init_stmts (is_global
, stmt_expr
, compound_stmt
);
4804 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
4807 return error_mark_node
;
4813 tree const_init
= build_constructor (atype
, const_vec
);
4814 return build2 (INIT_EXPR
, atype
, obase
, const_init
);
4816 else if (do_static_init
&& !vec_safe_is_empty (const_vec
))
4817 DECL_INITIAL (obase
) = build_constructor (atype
, const_vec
);
4819 vec_free (const_vec
);
4822 /* Now make the result have the correct type. */
4823 if (TREE_CODE (atype
) == ARRAY_TYPE
)
4825 atype
= build_pointer_type (atype
);
4826 stmt_expr
= build1 (NOP_EXPR
, atype
, stmt_expr
);
4827 stmt_expr
= cp_build_fold_indirect_ref (stmt_expr
);
4828 TREE_NO_WARNING (stmt_expr
) = 1;
4834 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
4838 build_dtor_call (tree exp
, special_function_kind dtor_kind
, int flags
,
4839 tsubst_flags_t complain
)
4844 case sfk_complete_destructor
:
4845 name
= complete_dtor_identifier
;
4848 case sfk_base_destructor
:
4849 name
= base_dtor_identifier
;
4852 case sfk_deleting_destructor
:
4853 name
= deleting_dtor_identifier
;
4860 return build_special_member_call (exp
, name
,
4862 /*binfo=*/TREE_TYPE (exp
),
4867 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
4868 ADDR is an expression which yields the store to be destroyed.
4869 AUTO_DELETE is the name of the destructor to call, i.e., either
4870 sfk_complete_destructor, sfk_base_destructor, or
4871 sfk_deleting_destructor.
4873 FLAGS is the logical disjunction of zero or more LOOKUP_
4874 flags. See cp-tree.h for more info. */
4877 build_delete (location_t loc
, tree otype
, tree addr
,
4878 special_function_kind auto_delete
,
4879 int flags
, int use_global_delete
, tsubst_flags_t complain
)
4883 if (addr
== error_mark_node
)
4884 return error_mark_node
;
4886 tree type
= TYPE_MAIN_VARIANT (otype
);
4888 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
4889 set to `error_mark_node' before it gets properly cleaned up. */
4890 if (type
== error_mark_node
)
4891 return error_mark_node
;
4893 if (TYPE_PTR_P (type
))
4894 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
4896 if (TREE_CODE (type
) == ARRAY_TYPE
)
4898 if (TYPE_DOMAIN (type
) == NULL_TREE
)
4900 if (complain
& tf_error
)
4901 error_at (loc
, "unknown array size in delete");
4902 return error_mark_node
;
4904 return build_vec_delete (loc
, addr
, array_type_nelts (type
),
4905 auto_delete
, use_global_delete
, complain
);
4908 bool deleting
= (auto_delete
== sfk_deleting_destructor
);
4909 gcc_assert (deleting
== !(flags
& LOOKUP_DESTRUCTOR
));
4911 if (TYPE_PTR_P (otype
))
4913 addr
= mark_rvalue_use (addr
);
4915 /* We don't want to warn about delete of void*, only other
4916 incomplete types. Deleting other incomplete types
4917 invokes undefined behavior, but it is not ill-formed, so
4918 compile to something that would even do The Right Thing
4919 (TM) should the type have a trivial dtor and no delete
4921 if (!VOID_TYPE_P (type
))
4923 complete_type (type
);
4925 && !verify_type_context (loc
, TCTX_DEALLOCATION
, type
,
4926 !(complain
& tf_error
)))
4927 return error_mark_node
;
4929 if (!COMPLETE_TYPE_P (type
))
4931 if (complain
& tf_warning
)
4933 auto_diagnostic_group d
;
4934 if (warning_at (loc
, OPT_Wdelete_incomplete
,
4935 "possible problem detected in invocation of "
4936 "%<operator delete%>"))
4938 cxx_incomplete_type_diagnostic (addr
, type
, DK_WARNING
);
4940 "neither the destructor nor the class-specific "
4941 "%<operator delete%> will be called, even if "
4942 "they are declared when the class is defined");
4946 else if (deleting
&& warn_delnonvdtor
4947 && MAYBE_CLASS_TYPE_P (type
) && !CLASSTYPE_FINAL (type
)
4948 && TYPE_POLYMORPHIC_P (type
))
4950 tree dtor
= CLASSTYPE_DESTRUCTOR (type
);
4951 if (!dtor
|| !DECL_VINDEX (dtor
))
4953 if (CLASSTYPE_PURE_VIRTUALS (type
))
4954 warning_at (loc
, OPT_Wdelete_non_virtual_dtor
,
4955 "deleting object of abstract class type %qT"
4956 " which has non-virtual destructor"
4957 " will cause undefined behavior", type
);
4959 warning_at (loc
, OPT_Wdelete_non_virtual_dtor
,
4960 "deleting object of polymorphic class type %qT"
4961 " which has non-virtual destructor"
4962 " might cause undefined behavior", type
);
4967 /* Throw away const and volatile on target type of addr. */
4968 addr
= convert_force (build_pointer_type (type
), addr
, 0, complain
);
4972 /* Don't check PROTECT here; leave that decision to the
4973 destructor. If the destructor is accessible, call it,
4974 else report error. */
4975 addr
= cp_build_addr_expr (addr
, complain
);
4976 if (addr
== error_mark_node
)
4977 return error_mark_node
;
4979 addr
= convert_force (build_pointer_type (type
), addr
, 0, complain
);
4983 /* We will use ADDR multiple times so we must save it. */
4984 addr
= save_expr (addr
);
4986 bool virtual_p
= false;
4987 if (type_build_dtor_call (type
))
4989 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
4990 lazily_declare_fn (sfk_destructor
, type
);
4991 virtual_p
= DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTOR (type
));
4994 tree head
= NULL_TREE
;
4995 tree do_delete
= NULL_TREE
;
4996 bool destroying_delete
= false;
5000 /* Leave do_delete null. */
5002 /* For `::delete x', we must not use the deleting destructor
5003 since then we would not be sure to get the global `operator
5005 else if (use_global_delete
)
5007 head
= get_target_expr (build_headof (addr
));
5008 /* Delete the object. */
5009 do_delete
= build_op_delete_call (DELETE_EXPR
,
5011 cxx_sizeof_nowarn (type
),
5013 /*placement=*/NULL_TREE
,
5014 /*alloc_fn=*/NULL_TREE
,
5016 /* Otherwise, treat this like a complete object destructor
5018 auto_delete
= sfk_complete_destructor
;
5020 /* If the destructor is non-virtual, there is no deleting
5021 variant. Instead, we must explicitly call the appropriate
5022 `operator delete' here. */
5023 else if (!virtual_p
)
5025 /* Build the call. */
5026 do_delete
= build_op_delete_call (DELETE_EXPR
,
5028 cxx_sizeof_nowarn (type
),
5030 /*placement=*/NULL_TREE
,
5031 /*alloc_fn=*/NULL_TREE
,
5033 /* Call the complete object destructor. */
5034 auto_delete
= sfk_complete_destructor
;
5035 if (do_delete
!= error_mark_node
)
5037 tree fn
= get_callee_fndecl (do_delete
);
5038 destroying_delete
= destroying_delete_p (fn
);
5041 else if (TYPE_GETS_REG_DELETE (type
))
5043 /* Make sure we have access to the member op delete, even though
5044 we'll actually be calling it from the destructor. */
5045 build_op_delete_call (DELETE_EXPR
, addr
, cxx_sizeof_nowarn (type
),
5047 /*placement=*/NULL_TREE
,
5048 /*alloc_fn=*/NULL_TREE
,
5052 if (!destroying_delete
&& type_build_dtor_call (type
))
5053 expr
= build_dtor_call (cp_build_fold_indirect_ref (addr
),
5054 auto_delete
, flags
, complain
);
5056 expr
= build_trivial_dtor_call (addr
);
5057 if (expr
== error_mark_node
)
5058 return error_mark_node
;
5062 protected_set_expr_location (expr
, loc
);
5066 if (do_delete
== error_mark_node
)
5067 return error_mark_node
;
5069 if (do_delete
&& !TREE_SIDE_EFFECTS (expr
))
5072 /* The delete operator must be called, regardless of whether
5073 the destructor throws.
5075 [expr.delete]/7 The deallocation function is called
5076 regardless of whether the destructor for the object or some
5077 element of the array throws an exception. */
5078 expr
= build2 (TRY_FINALLY_EXPR
, void_type_node
, expr
, do_delete
);
5080 /* We need to calculate this before the dtor changes the vptr. */
5082 expr
= build2 (COMPOUND_EXPR
, void_type_node
, head
, expr
);
5084 /* Handle deleting a null pointer. */
5085 warning_sentinel
s (warn_address
);
5086 tree ifexp
= cp_build_binary_op (loc
, NE_EXPR
, addr
,
5087 nullptr_node
, complain
);
5088 ifexp
= cp_fully_fold (ifexp
);
5090 if (ifexp
== error_mark_node
)
5091 return error_mark_node
;
5092 /* This is a compiler generated comparison, don't emit
5093 e.g. -Wnonnull-compare warning for it. */
5094 else if (TREE_CODE (ifexp
) == NE_EXPR
)
5095 TREE_NO_WARNING (ifexp
) = 1;
5097 if (!integer_nonzerop (ifexp
))
5098 expr
= build3 (COND_EXPR
, void_type_node
, ifexp
, expr
, void_node
);
5100 protected_set_expr_location (expr
, loc
);
5104 /* At the beginning of a destructor, push cleanups that will call the
5105 destructors for our base classes and members.
5107 Called from begin_destructor_body. */
5110 push_base_cleanups (void)
5112 tree binfo
, base_binfo
;
5116 vec
<tree
, va_gc
> *vbases
;
5118 /* Run destructors for all virtual baseclasses. */
5119 if (!ABSTRACT_CLASS_TYPE_P (current_class_type
)
5120 && CLASSTYPE_VBASECLASSES (current_class_type
))
5122 tree cond
= (condition_conversion
5123 (build2 (BIT_AND_EXPR
, integer_type_node
,
5124 current_in_charge_parm
,
5125 integer_two_node
)));
5127 /* The CLASSTYPE_VBASECLASSES vector is in initialization
5128 order, which is also the right order for pushing cleanups. */
5129 for (vbases
= CLASSTYPE_VBASECLASSES (current_class_type
), i
= 0;
5130 vec_safe_iterate (vbases
, i
, &base_binfo
); i
++)
5132 if (type_build_dtor_call (BINFO_TYPE (base_binfo
)))
5134 expr
= build_special_member_call (current_class_ref
,
5135 base_dtor_identifier
,
5139 | LOOKUP_NONVIRTUAL
),
5140 tf_warning_or_error
);
5141 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
5143 expr
= build3 (COND_EXPR
, void_type_node
, cond
,
5145 finish_decl_cleanup (NULL_TREE
, expr
);
5151 /* Take care of the remaining baseclasses. */
5152 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
5153 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5155 if (BINFO_VIRTUAL_P (base_binfo
)
5156 || !type_build_dtor_call (BINFO_TYPE (base_binfo
)))
5159 expr
= build_special_member_call (current_class_ref
,
5160 base_dtor_identifier
,
5162 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
5163 tf_warning_or_error
);
5164 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
5165 finish_decl_cleanup (NULL_TREE
, expr
);
5168 /* Don't automatically destroy union members. */
5169 if (TREE_CODE (current_class_type
) == UNION_TYPE
)
5172 for (member
= TYPE_FIELDS (current_class_type
); member
;
5173 member
= DECL_CHAIN (member
))
5175 tree this_type
= TREE_TYPE (member
);
5176 if (this_type
== error_mark_node
5177 || TREE_CODE (member
) != FIELD_DECL
5178 || DECL_ARTIFICIAL (member
))
5180 if (ANON_AGGR_TYPE_P (this_type
))
5182 if (type_build_dtor_call (this_type
))
5184 tree this_member
= (build_class_member_access_expr
5185 (current_class_ref
, member
,
5186 /*access_path=*/NULL_TREE
,
5187 /*preserve_reference=*/false,
5188 tf_warning_or_error
));
5189 expr
= build_delete (input_location
, this_type
, this_member
,
5190 sfk_complete_destructor
,
5191 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
,
5192 0, tf_warning_or_error
);
5193 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (this_type
))
5194 finish_decl_cleanup (NULL_TREE
, expr
);
5199 /* Build a C++ vector delete expression.
5200 MAXINDEX is the number of elements to be deleted.
5201 ELT_SIZE is the nominal size of each element in the vector.
5202 BASE is the expression that should yield the store to be deleted.
5203 This function expands (or synthesizes) these calls itself.
5204 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
5206 This also calls delete for virtual baseclasses of elements of the vector.
5208 Update: MAXINDEX is no longer needed. The size can be extracted from the
5209 start of the vector for pointers, and from the type for arrays. We still
5210 use MAXINDEX for arrays because it happens to already have one of the
5211 values we'd have to extract. (We could use MAXINDEX with pointers to
5212 confirm the size, and trap if the numbers differ; not clear that it'd
5213 be worth bothering.) */
5216 build_vec_delete (location_t loc
, tree base
, tree maxindex
,
5217 special_function_kind auto_delete_vec
,
5218 int use_global_delete
, tsubst_flags_t complain
)
5222 tree base_init
= NULL_TREE
;
5224 type
= TREE_TYPE (base
);
5226 if (TYPE_PTR_P (type
))
5228 /* Step back one from start of vector, and read dimension. */
5230 tree size_ptr_type
= build_pointer_type (sizetype
);
5232 base
= mark_rvalue_use (base
);
5233 if (TREE_SIDE_EFFECTS (base
))
5235 base_init
= get_target_expr (base
);
5236 base
= TARGET_EXPR_SLOT (base_init
);
5238 type
= strip_array_types (TREE_TYPE (type
));
5239 cookie_addr
= fold_build1_loc (loc
, NEGATE_EXPR
,
5240 sizetype
, TYPE_SIZE_UNIT (sizetype
));
5241 cookie_addr
= fold_build_pointer_plus (fold_convert (size_ptr_type
, base
),
5243 maxindex
= cp_build_fold_indirect_ref (cookie_addr
);
5245 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5247 /* Get the total number of things in the array, maxindex is a
5249 maxindex
= array_type_nelts_total (type
);
5250 type
= strip_array_types (type
);
5251 base
= decay_conversion (base
, complain
);
5252 if (base
== error_mark_node
)
5253 return error_mark_node
;
5254 if (TREE_SIDE_EFFECTS (base
))
5256 base_init
= get_target_expr (base
);
5257 base
= TARGET_EXPR_SLOT (base_init
);
5262 if (base
!= error_mark_node
&& !(complain
& tf_error
))
5264 "type to vector delete is neither pointer or array type");
5265 return error_mark_node
;
5268 rval
= build_vec_delete_1 (loc
, base
, maxindex
, type
, auto_delete_vec
,
5269 use_global_delete
, complain
);
5270 if (base_init
&& rval
!= error_mark_node
)
5271 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), base_init
, rval
);
5273 protected_set_expr_location (rval
, loc
);
5277 #include "gt-cp-init.h"