1 /* Handle initialization things in -*- C++ -*-
2 Copyright (C) 1987-2022 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"
37 #include "pointer-query.h"
39 static bool begin_init_stmts (tree
*, tree
*);
40 static tree
finish_init_stmts (bool, tree
, tree
);
41 static void construct_virtual_base (tree
, tree
);
42 static bool expand_aggr_init_1 (tree
, tree
, tree
, tree
, int, tsubst_flags_t
);
43 static bool expand_default_init (tree
, tree
, tree
, tree
, int, tsubst_flags_t
);
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
= build_zero_cst (type
);
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
, MINUS_EXPR
,
250 TREE_TYPE (nelts
), nelts
,
251 build_one_cst (TREE_TYPE (nelts
)));
252 /* Treat flexible array members like [0] arrays. */
253 else if (TYPE_DOMAIN (type
) == NULL_TREE
)
256 max_index
= array_type_nelts (type
);
258 /* If we have an error_mark here, we should just return error mark
259 as we don't know the size of the array yet. */
260 if (max_index
== error_mark_node
)
261 return error_mark_node
;
262 gcc_assert (TREE_CODE (max_index
) == INTEGER_CST
);
264 /* A zero-sized array, which is accepted as an extension, will
265 have an upper bound of -1. */
266 if (!integer_minus_onep (max_index
))
270 /* If this is a one element array, we just use a regular init. */
271 if (integer_zerop (max_index
))
272 ce
.index
= size_zero_node
;
274 ce
.index
= build2 (RANGE_EXPR
, sizetype
, size_zero_node
,
277 ce
.value
= build_zero_init_1 (TREE_TYPE (type
), /*nelts=*/NULL_TREE
,
278 static_storage_p
, NULL_TREE
);
286 /* Build a constructor to contain the initializations. */
287 init
= build_constructor (type
, v
);
289 else if (VECTOR_TYPE_P (type
))
290 init
= build_zero_cst (type
);
292 gcc_assert (TYPE_REF_P (type
));
294 /* In all cases, the initializer is a constant. */
296 TREE_CONSTANT (init
) = 1;
301 /* Return an expression for the zero-initialization of an object with
302 type T. This expression will either be a constant (in the case
303 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
304 aggregate), or NULL (in the case that T does not require
305 initialization). In either case, the value can be used as
306 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
307 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
308 is the number of elements in the array. If STATIC_STORAGE_P is
309 TRUE, initializers are only generated for entities for which
310 zero-initialization does not simply mean filling the storage with
314 build_zero_init (tree type
, tree nelts
, bool static_storage_p
)
316 return build_zero_init_1 (type
, nelts
, static_storage_p
, NULL_TREE
);
319 /* Return a suitable initializer for value-initializing an object of type
320 TYPE, as described in [dcl.init]. */
323 build_value_init (tree type
, tsubst_flags_t complain
)
327 To value-initialize an object of type T means:
329 - if T is a class type (clause 9) with either no default constructor
330 (12.1) or a default constructor that is user-provided or deleted,
331 then the object is default-initialized;
333 - if T is a (possibly cv-qualified) class type without a user-provided
334 or deleted default constructor, then the object is zero-initialized
335 and the semantic constraints for default-initialization are checked,
336 and if T has a non-trivial default constructor, the object is
339 - if T is an array type, then each element is value-initialized;
341 - otherwise, the object is zero-initialized.
343 A program that calls for default-initialization or
344 value-initialization of an entity of reference type is ill-formed. */
346 if (CLASS_TYPE_P (type
) && type_build_ctor_call (type
))
349 = build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
350 NULL
, type
, LOOKUP_NORMAL
, complain
);
351 if (ctor
== error_mark_node
|| TREE_CONSTANT (ctor
))
353 if (processing_template_decl
)
354 /* The AGGR_INIT_EXPR tweaking below breaks in templates. */
355 return build_min (CAST_EXPR
, type
, NULL_TREE
);
357 if (TREE_CODE (ctor
) == CALL_EXPR
)
358 fn
= get_callee_fndecl (ctor
);
359 ctor
= build_aggr_init_expr (type
, ctor
);
360 if (fn
&& user_provided_p (fn
))
362 else if (TYPE_HAS_COMPLEX_DFLT (type
))
364 /* This is a class that needs constructing, but doesn't have
365 a user-provided constructor. So we need to zero-initialize
366 the object and then call the implicitly defined ctor.
367 This will be handled in simplify_aggr_init_expr. */
368 AGGR_INIT_ZERO_FIRST (ctor
) = 1;
373 /* Discard any access checking during subobject initialization;
374 the checks are implied by the call to the ctor which we have
375 verified is OK (cpp0x/defaulted46.C). */
376 push_deferring_access_checks (dk_deferred
);
377 tree r
= build_value_init_noctor (type
, complain
);
378 pop_deferring_access_checks ();
382 /* Like build_value_init, but don't call the constructor for TYPE. Used
383 for base initializers. */
386 build_value_init_noctor (tree type
, tsubst_flags_t complain
)
388 if (!COMPLETE_TYPE_P (type
))
390 if (complain
& tf_error
)
391 error ("value-initialization of incomplete type %qT", type
);
392 return error_mark_node
;
394 /* FIXME the class and array cases should just use digest_init once it is
396 if (CLASS_TYPE_P (type
))
398 gcc_assert (!TYPE_HAS_COMPLEX_DFLT (type
)
401 if (TREE_CODE (type
) != UNION_TYPE
)
404 vec
<constructor_elt
, va_gc
> *v
= NULL
;
406 /* Iterate over the fields, building initializations. */
407 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
411 if (TREE_CODE (field
) != FIELD_DECL
)
414 ftype
= TREE_TYPE (field
);
416 if (ftype
== error_mark_node
)
419 /* Ignore flexible array members for value initialization. */
420 if (TREE_CODE (ftype
) == ARRAY_TYPE
421 && !COMPLETE_TYPE_P (ftype
)
422 && !TYPE_DOMAIN (ftype
)
423 && COMPLETE_TYPE_P (TREE_TYPE (ftype
))
424 && (next_aggregate_field (DECL_CHAIN (field
))
428 /* Ignore unnamed zero-width bitfields. */
429 if (DECL_UNNAMED_BIT_FIELD (field
)
430 && integer_zerop (DECL_SIZE (field
)))
433 /* We could skip vfields and fields of types with
434 user-defined constructors, but I think that won't improve
435 performance at all; it should be simpler in general just
436 to zero out the entire object than try to only zero the
437 bits that actually need it. */
439 /* Note that for class types there will be FIELD_DECLs
440 corresponding to base classes as well. Thus, iterating
441 over TYPE_FIELDs will result in correct initialization of
442 all of the subobjects. */
443 value
= build_value_init (ftype
, complain
);
444 value
= maybe_constant_init (value
);
446 if (value
== error_mark_node
)
447 return error_mark_node
;
449 CONSTRUCTOR_APPEND_ELT(v
, field
, value
);
451 /* We shouldn't have gotten here for anything that would need
452 non-trivial initialization, and gimplify_init_ctor_preeval
453 would need to be fixed to allow it. */
454 gcc_assert (TREE_CODE (value
) != TARGET_EXPR
455 && TREE_CODE (value
) != AGGR_INIT_EXPR
);
458 /* Build a constructor to contain the zero- initializations. */
459 return build_constructor (type
, v
);
462 else if (TREE_CODE (type
) == ARRAY_TYPE
)
464 vec
<constructor_elt
, va_gc
> *v
= NULL
;
466 /* Iterate over the array elements, building initializations. */
467 tree max_index
= array_type_nelts (type
);
469 /* If we have an error_mark here, we should just return error mark
470 as we don't know the size of the array yet. */
471 if (max_index
== error_mark_node
)
473 if (complain
& tf_error
)
474 error ("cannot value-initialize array of unknown bound %qT",
476 return error_mark_node
;
478 gcc_assert (TREE_CODE (max_index
) == INTEGER_CST
);
480 /* A zero-sized array, which is accepted as an extension, will
481 have an upper bound of -1. */
482 if (!tree_int_cst_equal (max_index
, integer_minus_one_node
))
486 /* If this is a one element array, we just use a regular init. */
487 if (tree_int_cst_equal (size_zero_node
, max_index
))
488 ce
.index
= size_zero_node
;
490 ce
.index
= build2 (RANGE_EXPR
, sizetype
, size_zero_node
, max_index
);
492 ce
.value
= build_value_init (TREE_TYPE (type
), complain
);
493 ce
.value
= maybe_constant_init (ce
.value
);
494 if (ce
.value
== error_mark_node
)
495 return error_mark_node
;
500 /* We shouldn't have gotten here for anything that would need
501 non-trivial initialization, and gimplify_init_ctor_preeval
502 would need to be fixed to allow it. */
503 gcc_assert (TREE_CODE (ce
.value
) != TARGET_EXPR
504 && TREE_CODE (ce
.value
) != AGGR_INIT_EXPR
);
507 /* Build a constructor to contain the initializations. */
508 return build_constructor (type
, v
);
510 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
512 if (complain
& tf_error
)
513 error ("value-initialization of function type %qT", type
);
514 return error_mark_node
;
516 else if (TYPE_REF_P (type
))
518 if (complain
& tf_error
)
519 error ("value-initialization of reference type %qT", type
);
520 return error_mark_node
;
523 return build_zero_init (type
, NULL_TREE
, /*static_storage_p=*/false);
526 /* Initialize current class with INIT, a TREE_LIST of arguments for
527 a target constructor. If TREE_LIST is void_type_node, an empty
528 initializer list was given. Return the target constructor. */
531 perform_target_ctor (tree init
)
533 tree decl
= current_class_ref
;
534 tree type
= current_class_type
;
536 init
= build_aggr_init (decl
, init
, LOOKUP_NORMAL
|LOOKUP_DELEGATING_CONS
,
537 tf_warning_or_error
);
538 finish_expr_stmt (init
);
539 if (type_build_dtor_call (type
))
541 tree expr
= build_delete (input_location
,
542 type
, decl
, sfk_complete_destructor
,
546 0, tf_warning_or_error
);
547 if (DECL_HAS_IN_CHARGE_PARM_P (current_function_decl
))
549 tree base
= build_delete (input_location
,
550 type
, decl
, sfk_base_destructor
,
554 0, tf_warning_or_error
);
555 expr
= build_if_in_charge (expr
, base
);
557 if (expr
!= error_mark_node
558 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
559 finish_eh_cleanup (expr
);
564 /* Return the non-static data initializer for FIELD_DECL MEMBER. */
566 static GTY((cache
)) decl_tree_cache_map
*nsdmi_inst
;
569 get_nsdmi (tree member
, bool in_ctor
, tsubst_flags_t complain
)
572 tree save_ccp
= current_class_ptr
;
573 tree save_ccr
= current_class_ref
;
575 if (DECL_LANG_SPECIFIC (member
) && DECL_TEMPLATE_INFO (member
))
577 init
= DECL_INITIAL (DECL_TI_TEMPLATE (member
));
579 = cp_expr_loc_or_loc (init
, DECL_SOURCE_LOCATION (member
));
580 if (TREE_CODE (init
) == DEFERRED_PARSE
)
582 else if (tree
*slot
= hash_map_safe_get (nsdmi_inst
, member
))
584 /* Check recursive instantiation. */
585 else if (DECL_INSTANTIATING_NSDMI_P (member
))
587 if (complain
& tf_error
)
588 error_at (expr_loc
, "recursive instantiation of default member "
589 "initializer for %qD", member
);
590 init
= error_mark_node
;
596 location_t sloc
= input_location
;
597 input_location
= expr_loc
;
599 DECL_INSTANTIATING_NSDMI_P (member
) = 1;
602 tree ctx
= DECL_CONTEXT (member
);
604 processing_template_decl_sentinel
ptds (/*reset*/false);
605 if (!currently_open_class (ctx
))
607 if (!LOCAL_CLASS_P (ctx
))
608 push_to_top_level ();
610 /* push_to_top_level would lose the necessary function context,
611 just reset processing_template_decl. */
612 processing_template_decl
= 0;
613 push_nested_class (ctx
);
614 push_deferring_access_checks (dk_no_deferred
);
618 inject_this_parameter (ctx
, TYPE_UNQUALIFIED
);
620 start_lambda_scope (member
);
622 /* Do deferred instantiation of the NSDMI. */
623 init
= tsubst_copy_and_build (init
, DECL_TI_ARGS (member
),
625 init
= digest_nsdmi_init (member
, init
, complain
);
627 finish_lambda_scope ();
629 DECL_INSTANTIATING_NSDMI_P (member
) = 0;
631 if (init
!= error_mark_node
)
632 hash_map_safe_put
<hm_ggc
> (nsdmi_inst
, member
, init
);
636 pop_deferring_access_checks ();
638 if (!LOCAL_CLASS_P (ctx
))
639 pop_from_top_level ();
642 input_location
= sloc
;
646 init
= DECL_INITIAL (member
);
648 if (init
&& TREE_CODE (init
) == DEFERRED_PARSE
)
650 if (complain
& tf_error
)
652 error ("default member initializer for %qD required before the end "
653 "of its enclosing class", member
);
654 inform (location_of (init
), "defined here");
655 DECL_INITIAL (member
) = error_mark_node
;
657 init
= error_mark_node
;
662 current_class_ptr
= save_ccp
;
663 current_class_ref
= save_ccr
;
667 /* Use a PLACEHOLDER_EXPR when we don't have a 'this' parameter to
668 refer to; constexpr evaluation knows what to do with it. */
669 current_class_ref
= build0 (PLACEHOLDER_EXPR
, DECL_CONTEXT (member
));
670 current_class_ptr
= build_address (current_class_ref
);
673 /* Strip redundant TARGET_EXPR so we don't need to remap it, and
674 so the aggregate init code below will see a CONSTRUCTOR. */
675 bool simple_target
= (init
&& SIMPLE_TARGET_EXPR_P (init
));
677 init
= TARGET_EXPR_INITIAL (init
);
678 init
= break_out_target_exprs (init
, /*loc*/true);
679 if (init
&& TREE_CODE (init
) == TARGET_EXPR
)
680 /* In a constructor, this expresses the full initialization, prevent
681 perform_member_init from calling another constructor (58162). */
682 TARGET_EXPR_DIRECT_INIT_P (init
) = in_ctor
;
683 if (simple_target
&& TREE_CODE (init
) != CONSTRUCTOR
)
684 /* Now put it back so C++17 copy elision works. */
685 init
= get_target_expr (init
);
687 set_target_expr_eliding (init
);
689 current_class_ptr
= save_ccp
;
690 current_class_ref
= save_ccr
;
694 /* Diagnose the flexible array MEMBER if its INITializer is non-null
695 and return true if so. Otherwise return false. */
698 maybe_reject_flexarray_init (tree member
, tree init
)
700 tree type
= TREE_TYPE (member
);
703 || TREE_CODE (type
) != ARRAY_TYPE
704 || TYPE_DOMAIN (type
))
707 /* Point at the flexible array member declaration if it's initialized
708 in-class, and at the ctor if it's initialized in a ctor member
711 if (DECL_INITIAL (member
) == init
712 || !current_function_decl
713 || DECL_DEFAULTED_FN (current_function_decl
))
714 loc
= DECL_SOURCE_LOCATION (member
);
716 loc
= DECL_SOURCE_LOCATION (current_function_decl
);
718 error_at (loc
, "initializer for flexible array member %q#D", member
);
722 /* If INIT's value can come from a call to std::initializer_list<T>::begin,
723 return that function. Otherwise, NULL_TREE. */
726 find_list_begin (tree init
)
729 while (TREE_CODE (init
) == COMPOUND_EXPR
)
730 init
= TREE_OPERAND (init
, 1);
732 if (TREE_CODE (init
) == COND_EXPR
)
734 tree left
= TREE_OPERAND (init
, 1);
736 left
= TREE_OPERAND (init
, 0);
737 left
= find_list_begin (left
);
740 return find_list_begin (TREE_OPERAND (init
, 2));
742 if (TREE_CODE (init
) == CALL_EXPR
)
743 if (tree fn
= get_callee_fndecl (init
))
744 if (id_equal (DECL_NAME (fn
), "begin")
745 && is_std_init_list (DECL_CONTEXT (fn
)))
750 /* If INIT initializing MEMBER is copying the address of the underlying array
751 of an initializer_list, warn. */
754 maybe_warn_list_ctor (tree member
, tree init
)
756 tree memtype
= TREE_TYPE (member
);
757 if (!init
|| !TYPE_PTR_P (memtype
)
758 || !is_list_ctor (current_function_decl
))
761 tree parm
= FUNCTION_FIRST_USER_PARMTYPE (current_function_decl
);
762 parm
= TREE_VALUE (parm
);
763 tree initlist
= non_reference (parm
);
765 /* Do not warn if the parameter is an lvalue reference to non-const. */
766 if (TYPE_REF_P (parm
) && !TYPE_REF_IS_RVALUE (parm
)
767 && !CP_TYPE_CONST_P (initlist
))
770 tree targs
= CLASSTYPE_TI_ARGS (initlist
);
771 tree elttype
= TREE_VEC_ELT (targs
, 0);
773 if (!same_type_ignoring_top_level_qualifiers_p
774 (TREE_TYPE (memtype
), elttype
))
777 tree begin
= find_list_begin (init
);
781 location_t loc
= cp_expr_loc_or_input_loc (init
);
782 warning_at (loc
, OPT_Winit_list_lifetime
,
783 "initializing %qD from %qE does not extend the lifetime "
784 "of the underlying array", member
, begin
);
787 /* Data structure for find_uninit_fields_r, below. */
789 struct find_uninit_data
{
790 /* The set tracking the yet-uninitialized members. */
791 hash_set
<tree
> *uninitialized
;
792 /* The data member we are currently initializing. It can be either
793 a type (initializing a base class/delegating constructors), or
798 /* walk_tree callback that warns about using uninitialized data in
799 a member-initializer-list. */
802 find_uninit_fields_r (tree
*tp
, int *walk_subtrees
, void *data
)
804 find_uninit_data
*d
= static_cast<find_uninit_data
*>(data
);
805 hash_set
<tree
> *uninitialized
= d
->uninitialized
;
807 const tree_code code
= TREE_CODE (init
);
809 /* No need to look into types or unevaluated operands. */
810 if (TYPE_P (init
) || unevaluated_p (code
))
812 *walk_subtrees
= false;
818 /* We'd need data flow info to avoid false positives. */
822 /* We might see a MODIFY_EXPR in cases like S() : a((b = 42)), c(b) { }
823 where the initializer for 'a' surreptitiously initializes 'b'. Let's
824 not bother with these complicated scenarios in the front end. */
826 /* Don't attempt to handle statement-expressions, either. */
828 uninitialized
->empty ();
830 /* If we're just taking the address of an object, it doesn't matter
831 whether it's been initialized. */
833 *walk_subtrees
= false;
839 /* We'd need data flow info to avoid false positives. */
840 if (truth_value_p (code
))
842 /* Attempt to handle a simple a{b}, but no more. */
843 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
845 if (CONSTRUCTOR_NELTS (init
) == 1
846 && !BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (init
, 0)->value
))
847 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
851 /* Warn about uninitialized 'this'. */
852 else if (code
== CALL_EXPR
)
854 tree fn
= get_callee_fndecl (init
);
855 if (fn
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
857 tree op
= CALL_EXPR_ARG (init
, 0);
858 if (TREE_CODE (op
) == ADDR_EXPR
)
859 op
= TREE_OPERAND (op
, 0);
860 temp_override
<tree
> ovr (d
->member
, DECL_ARGUMENTS (fn
));
861 cp_walk_tree_without_duplicates (&op
, find_uninit_fields_r
, data
);
863 /* Functions (whether static or nonstatic member) may have side effects
864 and initialize other members; it's not the front end's job to try to
865 figure it out. But don't give up for constructors: we still want to
866 warn when initializing base classes:
868 struct D : public B {
873 so carry on to detect that 'x' is used uninitialized. */
874 if (!fn
|| !DECL_CONSTRUCTOR_P (fn
))
878 /* If we find FIELD in the uninitialized set, we warn. */
879 if (code
== COMPONENT_REF
)
881 tree field
= TREE_OPERAND (init
, 1);
882 tree type
= TYPE_P (d
->member
) ? d
->member
: TREE_TYPE (d
->member
);
884 /* We're initializing a reference member with itself. */
885 if (TYPE_REF_P (type
) && cp_tree_equal (d
->member
, init
))
886 warning_at (EXPR_LOCATION (init
), OPT_Winit_self
,
887 "%qD is initialized with itself", field
);
888 else if (cp_tree_equal (TREE_OPERAND (init
, 0), current_class_ref
)
889 && uninitialized
->contains (field
))
891 if (TYPE_REF_P (TREE_TYPE (field
)))
892 warning_at (EXPR_LOCATION (init
), OPT_Wuninitialized
,
893 "reference %qD is not yet bound to a value when used "
895 else if (!INDIRECT_TYPE_P (type
) || is_this_parameter (d
->member
))
896 warning_at (EXPR_LOCATION (init
), OPT_Wuninitialized
,
897 "member %qD is used uninitialized", field
);
898 *walk_subtrees
= false;
905 *walk_subtrees
= false;
906 uninitialized
->empty ();
907 return integer_zero_node
;
910 /* Wrapper around find_uninit_fields_r above. */
913 find_uninit_fields (tree
*t
, hash_set
<tree
> *uninitialized
, tree member
)
915 if (!uninitialized
->is_empty ())
917 find_uninit_data data
= { uninitialized
, member
};
918 cp_walk_tree_without_duplicates (t
, find_uninit_fields_r
, &data
);
922 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
923 arguments. If TREE_LIST is void_type_node, an empty initializer
924 list was given; if NULL_TREE no initializer was given. UNINITIALIZED
925 is the hash set that tracks uninitialized fields. */
928 perform_member_init (tree member
, tree init
, hash_set
<tree
> &uninitialized
)
931 tree type
= TREE_TYPE (member
);
933 /* Use the non-static data member initializer if there was no
934 mem-initializer for this field. */
935 if (init
== NULL_TREE
)
936 init
= get_nsdmi (member
, /*ctor*/true, tf_warning_or_error
);
938 if (init
== error_mark_node
)
941 /* Effective C++ rule 12 requires that all data members be
943 if (warn_ecpp
&& init
== NULL_TREE
&& TREE_CODE (type
) != ARRAY_TYPE
)
944 warning_at (DECL_SOURCE_LOCATION (current_function_decl
), OPT_Weffc__
,
945 "%qD should be initialized in the member initialization list",
948 /* Get an lvalue for the data member. */
949 decl
= build_class_member_access_expr (current_class_ref
, member
,
950 /*access_path=*/NULL_TREE
,
951 /*preserve_reference=*/true,
952 tf_warning_or_error
);
953 if (decl
== error_mark_node
)
956 if ((warn_init_self
|| warn_uninitialized
)
958 && TREE_CODE (init
) == TREE_LIST
959 && TREE_CHAIN (init
) == NULL_TREE
)
961 tree val
= TREE_VALUE (init
);
962 /* Handle references. */
963 if (REFERENCE_REF_P (val
))
964 val
= TREE_OPERAND (val
, 0);
965 if (TREE_CODE (val
) == COMPONENT_REF
&& TREE_OPERAND (val
, 1) == member
966 && TREE_OPERAND (val
, 0) == current_class_ref
)
967 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
968 OPT_Winit_self
, "%qD is initialized with itself",
971 find_uninit_fields (&val
, &uninitialized
, decl
);
974 if (array_of_unknown_bound_p (type
))
976 maybe_reject_flexarray_init (member
, init
);
980 if (init
&& TREE_CODE (init
) == TREE_LIST
)
983 if (DIRECT_LIST_INIT_P (TREE_VALUE (init
)))
984 init
= build_x_compound_expr_from_list (init
, ELK_MEM_INIT
,
985 tf_warning_or_error
);
986 /* We are trying to initialize an array from a ()-list. If we
987 should attempt to do so, conjure up a CONSTRUCTOR. */
988 else if (TREE_CODE (type
) == ARRAY_TYPE
989 /* P0960 is a C++20 feature. */
990 && cxx_dialect
>= cxx20
)
991 init
= do_aggregate_paren_init (init
, type
);
992 else if (!CLASS_TYPE_P (type
))
993 init
= build_x_compound_expr_from_list (init
, ELK_MEM_INIT
,
994 tf_warning_or_error
);
995 /* If we're initializing a class from a ()-list, leave the TREE_LIST
996 alone: we might call an appropriate constructor, or (in C++20)
997 do aggregate-initialization. */
1000 /* Assume we are initializing the member. */
1001 bool member_initialized_p
= true;
1003 if (init
== void_type_node
)
1005 /* mem() means value-initialization. */
1006 if (TREE_CODE (type
) == ARRAY_TYPE
)
1008 init
= build_vec_init_expr (type
, init
, tf_warning_or_error
);
1009 init
= cp_build_init_expr (decl
, init
);
1010 finish_expr_stmt (init
);
1014 tree value
= build_value_init (type
, tf_warning_or_error
);
1015 if (value
== error_mark_node
)
1017 init
= cp_build_init_expr (decl
, value
);
1018 finish_expr_stmt (init
);
1021 /* Deal with this here, as we will get confused if we try to call the
1022 assignment op for an anonymous union. This can happen in a
1023 synthesized copy constructor. */
1024 else if (ANON_AGGR_TYPE_P (type
))
1028 init
= cp_build_init_expr (decl
, TREE_VALUE (init
));
1029 finish_expr_stmt (init
);
1033 && (TYPE_REF_P (type
)
1034 || (TREE_CODE (init
) == CONSTRUCTOR
1035 && (CP_AGGREGATE_TYPE_P (type
)
1036 || is_std_init_list (type
)))))
1038 /* With references and list-initialization, we need to deal with
1039 extending temporary lifetimes. 12.2p5: "A temporary bound to a
1040 reference member in a constructor’s ctor-initializer (12.6.2)
1041 persists until the constructor exits." */
1043 releasing_vec cleanups
;
1044 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (init
), type
))
1046 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1047 && CP_AGGREGATE_TYPE_P (type
))
1048 init
= reshape_init (type
, init
, tf_warning_or_error
);
1049 init
= digest_init (type
, init
, tf_warning_or_error
);
1051 if (init
== error_mark_node
)
1053 if (is_empty_field (member
)
1054 && !TREE_SIDE_EFFECTS (init
))
1055 /* Don't add trivial initialization of an empty base/field, as they
1056 might not be ordered the way the back-end expects. */
1058 /* A FIELD_DECL doesn't really have a suitable lifetime, but
1059 make_temporary_var_for_ref_to_temp will treat it as automatic and
1060 set_up_extended_ref_temp wants to use the decl in a warning. */
1061 init
= extend_ref_init_temps (member
, init
, &cleanups
);
1062 if (TREE_CODE (type
) == ARRAY_TYPE
1063 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (type
)))
1064 init
= build_vec_init_expr (type
, init
, tf_warning_or_error
);
1065 init
= cp_build_init_expr (decl
, init
);
1066 finish_expr_stmt (init
);
1067 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
1068 push_cleanup (NULL_TREE
, t
, false);
1070 else if (type_build_ctor_call (type
)
1071 || (init
&& CLASS_TYPE_P (strip_array_types (type
))))
1073 if (TREE_CODE (type
) == ARRAY_TYPE
)
1075 if (init
== NULL_TREE
1076 || same_type_ignoring_top_level_qualifiers_p (type
,
1079 if (TYPE_DOMAIN (type
) && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
1081 /* Initialize the array only if it's not a flexible
1082 array member (i.e., if it has an upper bound). */
1083 init
= build_vec_init_expr (type
, init
, tf_warning_or_error
);
1084 init
= cp_build_init_expr (decl
, init
);
1085 finish_expr_stmt (init
);
1089 error ("invalid initializer for array member %q#D", member
);
1093 int flags
= LOOKUP_NORMAL
;
1094 if (DECL_DEFAULTED_FN (current_function_decl
))
1095 flags
|= LOOKUP_DEFAULTED
;
1096 if (CP_TYPE_CONST_P (type
)
1097 && init
== NULL_TREE
1098 && default_init_uninitialized_part (type
))
1100 /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
1101 vtable; still give this diagnostic. */
1102 auto_diagnostic_group d
;
1103 if (permerror (DECL_SOURCE_LOCATION (current_function_decl
),
1104 "uninitialized const member in %q#T", type
))
1105 inform (DECL_SOURCE_LOCATION (member
),
1106 "%q#D should be initialized", member
);
1108 finish_expr_stmt (build_aggr_init (decl
, init
, flags
,
1109 tf_warning_or_error
));
1114 if (init
== NULL_TREE
)
1117 /* member traversal: note it leaves init NULL */
1118 if (TYPE_REF_P (type
))
1120 auto_diagnostic_group d
;
1121 if (permerror (DECL_SOURCE_LOCATION (current_function_decl
),
1122 "uninitialized reference member in %q#T", type
))
1123 inform (DECL_SOURCE_LOCATION (member
),
1124 "%q#D should be initialized", member
);
1126 else if (CP_TYPE_CONST_P (type
))
1128 auto_diagnostic_group d
;
1129 if (permerror (DECL_SOURCE_LOCATION (current_function_decl
),
1130 "uninitialized const member in %q#T", type
))
1131 inform (DECL_SOURCE_LOCATION (member
),
1132 "%q#D should be initialized", member
);
1135 core_type
= strip_array_types (type
);
1137 if (CLASS_TYPE_P (core_type
)
1138 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
1139 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
1140 diagnose_uninitialized_cst_or_ref_member (core_type
,
1141 /*using_new=*/false,
1144 /* We left the member uninitialized. */
1145 member_initialized_p
= false;
1148 maybe_warn_list_ctor (member
, init
);
1151 finish_expr_stmt (cp_build_modify_expr (input_location
, decl
,
1153 tf_warning_or_error
));
1156 if (member_initialized_p
&& warn_uninitialized
)
1157 /* This member is now initialized, remove it from the uninitialized
1159 uninitialized
.remove (member
);
1161 if (type_build_dtor_call (type
))
1165 expr
= build_class_member_access_expr (current_class_ref
, member
,
1166 /*access_path=*/NULL_TREE
,
1167 /*preserve_reference=*/false,
1168 tf_warning_or_error
);
1169 expr
= build_delete (input_location
,
1170 type
, expr
, sfk_complete_destructor
,
1171 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0,
1172 tf_warning_or_error
);
1174 if (expr
!= error_mark_node
1175 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
1176 finish_eh_cleanup (expr
);
1180 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
1181 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
1184 build_field_list (tree t
, tree list
, int *uses_unions_or_anon_p
)
1188 /* Note whether or not T is a union. */
1189 if (TREE_CODE (t
) == UNION_TYPE
)
1190 *uses_unions_or_anon_p
= 1;
1192 for (fields
= TYPE_FIELDS (t
); fields
; fields
= DECL_CHAIN (fields
))
1196 /* Skip CONST_DECLs for enumeration constants and so forth. */
1197 if (TREE_CODE (fields
) != FIELD_DECL
|| DECL_ARTIFICIAL (fields
))
1200 fieldtype
= TREE_TYPE (fields
);
1202 /* For an anonymous struct or union, we must recursively
1203 consider the fields of the anonymous type. They can be
1204 directly initialized from the constructor. */
1205 if (ANON_AGGR_TYPE_P (fieldtype
))
1207 /* Add this field itself. Synthesized copy constructors
1208 initialize the entire aggregate. */
1209 list
= tree_cons (fields
, NULL_TREE
, list
);
1210 /* And now add the fields in the anonymous aggregate. */
1211 list
= build_field_list (fieldtype
, list
, uses_unions_or_anon_p
);
1212 *uses_unions_or_anon_p
= 1;
1214 /* Add this field. */
1215 else if (DECL_NAME (fields
))
1216 list
= tree_cons (fields
, NULL_TREE
, list
);
1222 /* Return the innermost aggregate scope for FIELD, whether that is
1223 the enclosing class or an anonymous aggregate within it. */
1226 innermost_aggr_scope (tree field
)
1228 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
1229 return TREE_TYPE (field
);
1231 return DECL_CONTEXT (field
);
1234 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
1235 a FIELD_DECL or BINFO in T that needs initialization. The
1236 TREE_VALUE gives the initializer, or list of initializer arguments.
1238 Return a TREE_LIST containing all of the initializations required
1239 for T, in the order in which they should be performed. The output
1240 list has the same format as the input. */
1243 sort_mem_initializers (tree t
, tree mem_inits
)
1246 tree base
, binfo
, base_binfo
;
1248 tree next_subobject
;
1249 vec
<tree
, va_gc
> *vbases
;
1251 int uses_unions_or_anon_p
= 0;
1253 /* Build up a list of initializations. The TREE_PURPOSE of entry
1254 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
1255 TREE_VALUE will be the constructor arguments, or NULL if no
1256 explicit initialization was provided. */
1257 sorted_inits
= NULL_TREE
;
1259 /* Process the virtual bases. */
1260 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
1261 vec_safe_iterate (vbases
, i
, &base
); i
++)
1262 sorted_inits
= tree_cons (base
, NULL_TREE
, sorted_inits
);
1264 /* Process the direct bases. */
1265 for (binfo
= TYPE_BINFO (t
), i
= 0;
1266 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
1267 if (!BINFO_VIRTUAL_P (base_binfo
))
1268 sorted_inits
= tree_cons (base_binfo
, NULL_TREE
, sorted_inits
);
1270 /* Process the non-static data members. */
1271 sorted_inits
= build_field_list (t
, sorted_inits
, &uses_unions_or_anon_p
);
1272 /* Reverse the entire list of initializations, so that they are in
1273 the order that they will actually be performed. */
1274 sorted_inits
= nreverse (sorted_inits
);
1276 /* If the user presented the initializers in an order different from
1277 that in which they will actually occur, we issue a warning. Keep
1278 track of the next subobject which can be explicitly initialized
1279 without issuing a warning. */
1280 next_subobject
= sorted_inits
;
1282 /* Go through the explicit initializers, filling in TREE_PURPOSE in
1283 the SORTED_INITS. */
1284 for (init
= mem_inits
; init
; init
= TREE_CHAIN (init
))
1287 tree subobject_init
;
1289 subobject
= TREE_PURPOSE (init
);
1291 /* If the explicit initializers are in sorted order, then
1292 SUBOBJECT will be NEXT_SUBOBJECT, or something following
1294 for (subobject_init
= next_subobject
;
1296 subobject_init
= TREE_CHAIN (subobject_init
))
1297 if (TREE_PURPOSE (subobject_init
) == subobject
)
1300 /* Issue a warning if the explicit initializer order does not
1301 match that which will actually occur.
1302 ??? Are all these on the correct lines? */
1303 if (warn_reorder
&& !subobject_init
)
1305 if (TREE_CODE (TREE_PURPOSE (next_subobject
)) == FIELD_DECL
)
1306 warning_at (DECL_SOURCE_LOCATION (TREE_PURPOSE (next_subobject
)),
1307 OPT_Wreorder
, "%qD will be initialized after",
1308 TREE_PURPOSE (next_subobject
));
1310 warning (OPT_Wreorder
, "base %qT will be initialized after",
1311 TREE_PURPOSE (next_subobject
));
1312 if (TREE_CODE (subobject
) == FIELD_DECL
)
1313 warning_at (DECL_SOURCE_LOCATION (subobject
),
1314 OPT_Wreorder
, " %q#D", subobject
);
1316 warning (OPT_Wreorder
, " base %qT", subobject
);
1317 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
1318 OPT_Wreorder
, " when initialized here");
1321 /* Look again, from the beginning of the list. */
1322 if (!subobject_init
)
1324 subobject_init
= sorted_inits
;
1325 while (TREE_PURPOSE (subobject_init
) != subobject
)
1326 subobject_init
= TREE_CHAIN (subobject_init
);
1329 /* It is invalid to initialize the same subobject more than
1331 if (TREE_VALUE (subobject_init
))
1333 if (TREE_CODE (subobject
) == FIELD_DECL
)
1334 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1335 "multiple initializations given for %qD",
1338 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1339 "multiple initializations given for base %qT",
1343 /* Record the initialization. */
1344 TREE_VALUE (subobject_init
) = TREE_VALUE (init
);
1345 /* Carry over the dummy TREE_TYPE node containing the source location. */
1346 TREE_TYPE (subobject_init
) = TREE_TYPE (init
);
1347 next_subobject
= subobject_init
;
1350 /* [class.base.init]
1352 If a ctor-initializer specifies more than one mem-initializer for
1353 multiple members of the same union (including members of
1354 anonymous unions), the ctor-initializer is ill-formed.
1356 Here we also splice out uninitialized union members. */
1357 if (uses_unions_or_anon_p
)
1359 tree
*last_p
= NULL
;
1361 for (p
= &sorted_inits
; *p
; )
1368 field
= TREE_PURPOSE (init
);
1370 /* Skip base classes. */
1371 if (TREE_CODE (field
) != FIELD_DECL
)
1374 /* If this is an anonymous aggregate with no explicit initializer,
1376 if (!TREE_VALUE (init
) && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
1379 /* See if this field is a member of a union, or a member of a
1380 structure contained in a union, etc. */
1381 ctx
= innermost_aggr_scope (field
);
1383 /* If this field is not a member of a union, skip it. */
1384 if (TREE_CODE (ctx
) != UNION_TYPE
1385 && !ANON_AGGR_TYPE_P (ctx
))
1388 /* If this union member has no explicit initializer and no NSDMI,
1390 if (TREE_VALUE (init
) || DECL_INITIAL (field
))
1395 /* It's only an error if we have two initializers for the same
1403 /* See if LAST_FIELD and the field initialized by INIT are
1404 members of the same union (or the union itself). If so, there's
1405 a problem, unless they're actually members of the same structure
1406 which is itself a member of a union. For example, given:
1408 union { struct { int i; int j; }; };
1410 initializing both `i' and `j' makes sense. */
1411 ctx
= common_enclosing_class
1412 (innermost_aggr_scope (field
),
1413 innermost_aggr_scope (TREE_PURPOSE (*last_p
)));
1415 if (ctx
&& (TREE_CODE (ctx
) == UNION_TYPE
1416 || ctx
== TREE_TYPE (TREE_PURPOSE (*last_p
))))
1418 /* A mem-initializer hides an NSDMI. */
1419 if (TREE_VALUE (init
) && !TREE_VALUE (*last_p
))
1420 *last_p
= TREE_CHAIN (*last_p
);
1421 else if (TREE_VALUE (*last_p
) && !TREE_VALUE (init
))
1425 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1426 "initializations for multiple members of %qT",
1435 p
= &TREE_CHAIN (*p
);
1438 *p
= TREE_CHAIN (*p
);
1442 return sorted_inits
;
1445 /* Callback for cp_walk_tree to mark all PARM_DECLs in a tree as read. */
1448 mark_exp_read_r (tree
*tp
, int *, void *)
1451 if (TREE_CODE (t
) == PARM_DECL
)
1456 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
1457 is a TREE_LIST giving the explicit mem-initializer-list for the
1458 constructor. The TREE_PURPOSE of each entry is a subobject (a
1459 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
1460 is a TREE_LIST giving the arguments to the constructor or
1461 void_type_node for an empty list of arguments. */
1464 emit_mem_initializers (tree mem_inits
)
1466 int flags
= LOOKUP_NORMAL
;
1468 /* We will already have issued an error message about the fact that
1469 the type is incomplete. */
1470 if (!COMPLETE_TYPE_P (current_class_type
))
1473 /* Keep a set holding fields that are not initialized. */
1474 hash_set
<tree
> uninitialized
;
1476 /* Initially that is all of them. */
1477 if (warn_uninitialized
)
1478 for (tree f
= next_aggregate_field (TYPE_FIELDS (current_class_type
));
1480 f
= next_aggregate_field (DECL_CHAIN (f
)))
1481 if (!DECL_ARTIFICIAL (f
)
1482 && !is_really_empty_class (TREE_TYPE (f
), /*ignore_vptr*/false))
1483 uninitialized
.add (f
);
1486 && TYPE_P (TREE_PURPOSE (mem_inits
))
1487 && same_type_p (TREE_PURPOSE (mem_inits
), current_class_type
))
1489 /* Delegating constructor. */
1490 gcc_assert (TREE_CHAIN (mem_inits
) == NULL_TREE
);
1491 tree ctor
= perform_target_ctor (TREE_VALUE (mem_inits
));
1492 find_uninit_fields (&ctor
, &uninitialized
, current_class_type
);
1496 if (DECL_DEFAULTED_FN (current_function_decl
)
1497 && ! DECL_INHERITED_CTOR (current_function_decl
))
1498 flags
|= LOOKUP_DEFAULTED
;
1500 /* Sort the mem-initializers into the order in which the
1501 initializations should be performed. */
1502 mem_inits
= sort_mem_initializers (current_class_type
, mem_inits
);
1504 in_base_initializer
= 1;
1506 /* Initialize base classes. */
1508 && TREE_CODE (TREE_PURPOSE (mem_inits
)) != FIELD_DECL
);
1509 mem_inits
= TREE_CHAIN (mem_inits
))
1511 tree subobject
= TREE_PURPOSE (mem_inits
);
1512 tree arguments
= TREE_VALUE (mem_inits
);
1514 /* We already have issued an error message. */
1515 if (arguments
== error_mark_node
)
1518 /* Suppress access control when calling the inherited ctor. */
1519 bool inherited_base
= (DECL_INHERITED_CTOR (current_function_decl
)
1520 && flag_new_inheriting_ctors
1523 push_deferring_access_checks (dk_deferred
);
1525 if (arguments
== NULL_TREE
)
1527 /* If these initializations are taking place in a copy constructor,
1528 the base class should probably be explicitly initialized if there
1529 is a user-defined constructor in the base class (other than the
1530 default constructor, which will be called anyway). */
1532 && DECL_COPY_CONSTRUCTOR_P (current_function_decl
)
1533 && type_has_user_nondefault_constructor (BINFO_TYPE (subobject
)))
1534 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
1535 OPT_Wextra
, "base class %q#T should be explicitly "
1536 "initialized in the copy constructor",
1537 BINFO_TYPE (subobject
));
1540 /* Initialize the base. */
1541 if (!BINFO_VIRTUAL_P (subobject
))
1545 base_addr
= build_base_path (PLUS_EXPR
, current_class_ptr
,
1546 subobject
, 1, tf_warning_or_error
);
1547 expand_aggr_init_1 (subobject
, NULL_TREE
,
1548 cp_build_fold_indirect_ref (base_addr
),
1551 tf_warning_or_error
);
1552 expand_cleanup_for_base (subobject
, NULL_TREE
);
1553 if (STATEMENT_LIST_TAIL (cur_stmt_list
))
1554 find_uninit_fields (&STATEMENT_LIST_TAIL (cur_stmt_list
)->stmt
,
1555 &uninitialized
, BINFO_TYPE (subobject
));
1557 else if (!ABSTRACT_CLASS_TYPE_P (current_class_type
))
1558 /* C++14 DR1658 Means we do not have to construct vbases of
1559 abstract classes. */
1560 construct_virtual_base (subobject
, arguments
);
1562 /* When not constructing vbases of abstract classes, at least mark
1563 the arguments expressions as read to avoid
1564 -Wunused-but-set-parameter false positives. */
1565 cp_walk_tree (&arguments
, mark_exp_read_r
, NULL
, NULL
);
1568 pop_deferring_access_checks ();
1570 in_base_initializer
= 0;
1572 /* Initialize the vptrs. */
1573 initialize_vtbl_ptrs (current_class_ptr
);
1575 /* Initialize the data members. */
1578 /* If this initializer was explicitly provided, then the dummy TREE_TYPE
1579 node contains the source location. */
1580 iloc_sentinel
ils (EXPR_LOCATION (TREE_TYPE (mem_inits
)));
1582 perform_member_init (TREE_PURPOSE (mem_inits
),
1583 TREE_VALUE (mem_inits
),
1586 mem_inits
= TREE_CHAIN (mem_inits
);
1590 /* Returns the address of the vtable (i.e., the value that should be
1591 assigned to the vptr) for BINFO. */
1594 build_vtbl_address (tree binfo
)
1596 tree binfo_for
= binfo
;
1599 if (BINFO_VPTR_INDEX (binfo
) && BINFO_VIRTUAL_P (binfo
))
1600 /* If this is a virtual primary base, then the vtable we want to store
1601 is that for the base this is being used as the primary base of. We
1602 can't simply skip the initialization, because we may be expanding the
1603 inits of a subobject constructor where the virtual base layout
1604 can be different. */
1605 while (BINFO_PRIMARY_P (binfo_for
))
1606 binfo_for
= BINFO_INHERITANCE_CHAIN (binfo_for
);
1608 /* Figure out what vtable BINFO's vtable is based on, and mark it as
1610 vtbl
= get_vtbl_decl_for_binfo (binfo_for
);
1611 TREE_USED (vtbl
) = true;
1613 /* Now compute the address to use when initializing the vptr. */
1614 vtbl
= unshare_expr (BINFO_VTABLE (binfo_for
));
1616 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
1621 /* This code sets up the virtual function tables appropriate for
1622 the pointer DECL. It is a one-ply initialization.
1624 BINFO is the exact type that DECL is supposed to be. In
1625 multiple inheritance, this might mean "C's A" if C : A, B. */
1628 expand_virtual_init (tree binfo
, tree decl
)
1630 tree vtbl
, vtbl_ptr
;
1633 /* Compute the initializer for vptr. */
1634 vtbl
= build_vtbl_address (binfo
);
1636 /* We may get this vptr from a VTT, if this is a subobject
1637 constructor or subobject destructor. */
1638 vtt_index
= BINFO_VPTR_INDEX (binfo
);
1644 /* Compute the value to use, when there's a VTT. */
1645 vtt_parm
= current_vtt_parm
;
1646 vtbl2
= fold_build_pointer_plus (vtt_parm
, vtt_index
);
1647 vtbl2
= cp_build_fold_indirect_ref (vtbl2
);
1648 vtbl2
= convert (TREE_TYPE (vtbl
), vtbl2
);
1650 /* The actual initializer is the VTT value only in the subobject
1651 constructor. In maybe_clone_body we'll substitute NULL for
1652 the vtt_parm in the case of the non-subobject constructor. */
1653 vtbl
= build_if_in_charge (vtbl
, vtbl2
);
1656 /* Compute the location of the vtpr. */
1657 vtbl_ptr
= build_vfield_ref (cp_build_fold_indirect_ref (decl
),
1659 gcc_assert (vtbl_ptr
!= error_mark_node
);
1661 /* Assign the vtable to the vptr. */
1662 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0, tf_warning_or_error
);
1663 finish_expr_stmt (cp_build_modify_expr (input_location
, vtbl_ptr
, NOP_EXPR
,
1664 vtbl
, tf_warning_or_error
));
1667 /* If an exception is thrown in a constructor, those base classes already
1668 constructed must be destroyed. This function creates the cleanup
1669 for BINFO, which has just been constructed. If FLAG is non-NULL,
1670 it is a DECL which is nonzero when this base needs to be
1674 expand_cleanup_for_base (tree binfo
, tree flag
)
1678 if (!type_build_dtor_call (BINFO_TYPE (binfo
)))
1681 /* Call the destructor. */
1682 expr
= build_special_member_call (current_class_ref
,
1683 base_dtor_identifier
,
1686 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
1687 tf_warning_or_error
);
1689 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo
)))
1693 expr
= fold_build3_loc (input_location
,
1694 COND_EXPR
, void_type_node
,
1695 c_common_truthvalue_conversion (input_location
, flag
),
1696 expr
, integer_zero_node
);
1698 finish_eh_cleanup (expr
);
1701 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
1705 construct_virtual_base (tree vbase
, tree arguments
)
1711 /* If there are virtual base classes with destructors, we need to
1712 emit cleanups to destroy them if an exception is thrown during
1713 the construction process. These exception regions (i.e., the
1714 period during which the cleanups must occur) begin from the time
1715 the construction is complete to the end of the function. If we
1716 create a conditional block in which to initialize the
1717 base-classes, then the cleanup region for the virtual base begins
1718 inside a block, and ends outside of that block. This situation
1719 confuses the sjlj exception-handling code. Therefore, we do not
1720 create a single conditional block, but one for each
1721 initialization. (That way the cleanup regions always begin
1722 in the outer block.) We trust the back end to figure out
1723 that the FLAG will not change across initializations, and
1724 avoid doing multiple tests. */
1725 flag
= DECL_CHAIN (DECL_ARGUMENTS (current_function_decl
));
1726 inner_if_stmt
= begin_if_stmt ();
1727 finish_if_stmt_cond (flag
, inner_if_stmt
);
1729 /* Compute the location of the virtual base. If we're
1730 constructing virtual bases, then we must be the most derived
1731 class. Therefore, we don't have to look up the virtual base;
1732 we already know where it is. */
1733 exp
= convert_to_base_statically (current_class_ref
, vbase
);
1735 expand_aggr_init_1 (vbase
, current_class_ref
, exp
, arguments
,
1736 0, tf_warning_or_error
);
1737 finish_then_clause (inner_if_stmt
);
1738 finish_if_stmt (inner_if_stmt
);
1740 expand_cleanup_for_base (vbase
, flag
);
1743 /* Find the context in which this FIELD can be initialized. */
1746 initializing_context (tree field
)
1748 tree t
= DECL_CONTEXT (field
);
1750 /* Anonymous union members can be initialized in the first enclosing
1751 non-anonymous union context. */
1752 while (t
&& ANON_AGGR_TYPE_P (t
))
1753 t
= TYPE_CONTEXT (t
);
1757 /* Function to give error message if member initialization specification
1758 is erroneous. FIELD is the member we decided to initialize.
1759 TYPE is the type for which the initialization is being performed.
1760 FIELD must be a member of TYPE.
1762 MEMBER_NAME is the name of the member. */
1765 member_init_ok_or_else (tree field
, tree type
, tree member_name
)
1767 if (field
== error_mark_node
)
1771 error ("class %qT does not have any field named %qD", type
,
1777 error ("%q#D is a static data member; it can only be "
1778 "initialized at its definition",
1782 if (TREE_CODE (field
) != FIELD_DECL
)
1784 error ("%q#D is not a non-static data member of %qT",
1788 if (initializing_context (field
) != type
)
1790 error ("class %qT does not have any field named %qD", type
,
1798 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1799 is a _TYPE node or TYPE_DECL which names a base for that type.
1800 Check the validity of NAME, and return either the base _TYPE, base
1801 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
1802 NULL_TREE and issue a diagnostic.
1804 An old style unnamed direct single base construction is permitted,
1805 where NAME is NULL. */
1808 expand_member_init (tree name
)
1813 if (!current_class_ref
)
1818 /* This is an obsolete unnamed base class initializer. The
1819 parser will already have warned about its use. */
1820 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type
)))
1823 error ("unnamed initializer for %qT, which has no base classes",
1824 current_class_type
);
1827 basetype
= BINFO_TYPE
1828 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type
), 0));
1831 error ("unnamed initializer for %qT, which uses multiple inheritance",
1832 current_class_type
);
1836 else if (TYPE_P (name
))
1838 basetype
= TYPE_MAIN_VARIANT (name
);
1839 name
= TYPE_NAME (name
);
1841 else if (TREE_CODE (name
) == TYPE_DECL
)
1842 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (name
));
1844 basetype
= NULL_TREE
;
1853 if (current_template_parms
1854 || same_type_p (basetype
, current_class_type
))
1857 class_binfo
= TYPE_BINFO (current_class_type
);
1858 direct_binfo
= NULL_TREE
;
1859 virtual_binfo
= NULL_TREE
;
1861 /* Look for a direct base. */
1862 for (i
= 0; BINFO_BASE_ITERATE (class_binfo
, i
, direct_binfo
); ++i
)
1863 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo
), basetype
))
1866 /* Look for a virtual base -- unless the direct base is itself
1868 if (!direct_binfo
|| !BINFO_VIRTUAL_P (direct_binfo
))
1869 virtual_binfo
= binfo_for_vbase (basetype
, current_class_type
);
1871 /* [class.base.init]
1873 If a mem-initializer-id is ambiguous because it designates
1874 both a direct non-virtual base class and an inherited virtual
1875 base class, the mem-initializer is ill-formed. */
1876 if (direct_binfo
&& virtual_binfo
)
1878 error ("%qD is both a direct base and an indirect virtual base",
1883 if (!direct_binfo
&& !virtual_binfo
)
1885 if (CLASSTYPE_VBASECLASSES (current_class_type
))
1886 error ("type %qT is not a direct or virtual base of %qT",
1887 basetype
, current_class_type
);
1889 error ("type %qT is not a direct base of %qT",
1890 basetype
, current_class_type
);
1894 return direct_binfo
? direct_binfo
: virtual_binfo
;
1898 if (identifier_p (name
))
1899 field
= lookup_field (current_class_type
, name
, 1, false);
1903 if (member_init_ok_or_else (field
, current_class_type
, name
))
1910 /* This is like `expand_member_init', only it stores one aggregate
1913 INIT comes in two flavors: it is either a value which
1914 is to be stored in EXP, or it is a parameter list
1915 to go to a constructor, which will operate on EXP.
1916 If INIT is not a parameter list for a constructor, then set
1917 LOOKUP_ONLYCONVERTING.
1918 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1919 the initializer, if FLAGS is 0, then it is the (init) form.
1920 If `init' is a CONSTRUCTOR, then we emit a warning message,
1921 explaining that such initializations are invalid.
1923 If INIT resolves to a CALL_EXPR which happens to return
1924 something of the type we are looking for, then we know
1925 that we can safely use that call to perform the
1928 The virtual function table pointer cannot be set up here, because
1929 we do not really know its type.
1931 This never calls operator=().
1933 When initializing, nothing is CONST.
1935 A default copy constructor may have to be used to perform the
1938 A constructor or a conversion operator may have to be used to
1939 perform the initialization, but not both, as it would be ambiguous. */
1942 build_aggr_init (tree exp
, tree init
, int flags
, tsubst_flags_t complain
)
1947 tree type
= TREE_TYPE (exp
);
1948 int was_const
= TREE_READONLY (exp
);
1949 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1952 if (init
== error_mark_node
)
1953 return error_mark_node
;
1955 location_t init_loc
= (init
1956 ? cp_expr_loc_or_input_loc (init
)
1957 : location_of (exp
));
1959 TREE_READONLY (exp
) = 0;
1960 TREE_THIS_VOLATILE (exp
) = 0;
1962 if (TREE_CODE (type
) == ARRAY_TYPE
)
1964 tree itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1967 if (VAR_P (exp
) && DECL_DECOMPOSITION_P (exp
))
1970 init
= mark_rvalue_use (init
);
1972 && DECL_P (tree_strip_any_location_wrapper (init
))
1973 && !(flags
& LOOKUP_ONLYCONVERTING
))
1975 /* Wrap the initializer in a CONSTRUCTOR so that build_vec_init
1976 recognizes it as direct-initialization. */
1977 init
= build_constructor_single (init_list_type_node
,
1979 CONSTRUCTOR_IS_DIRECT_INIT (init
) = true;
1984 /* Must arrange to initialize each element of EXP
1985 from elements of INIT. */
1986 if (cv_qualified_p (type
))
1987 TREE_TYPE (exp
) = cv_unqualified (type
);
1988 if (itype
&& cv_qualified_p (itype
))
1989 TREE_TYPE (init
) = cv_unqualified (itype
);
1990 from_array
= (itype
&& same_type_p (TREE_TYPE (init
),
1993 if (init
&& !BRACE_ENCLOSED_INITIALIZER_P (init
)
1995 || (TREE_CODE (init
) != CONSTRUCTOR
1996 /* Can happen, eg, handling the compound-literals
1997 extension (ext/complit12.C). */
1998 && TREE_CODE (init
) != TARGET_EXPR
)))
2000 if (complain
& tf_error
)
2001 error_at (init_loc
, "array must be initialized "
2002 "with a brace-enclosed initializer");
2003 return error_mark_node
;
2007 stmt_expr
= build_vec_init (exp
, NULL_TREE
, init
,
2008 /*explicit_value_init_p=*/false,
2011 TREE_READONLY (exp
) = was_const
;
2012 TREE_THIS_VOLATILE (exp
) = was_volatile
;
2013 TREE_TYPE (exp
) = type
;
2014 /* Restore the type of init unless it was used directly. */
2015 if (init
&& TREE_CODE (stmt_expr
) != INIT_EXPR
)
2016 TREE_TYPE (init
) = itype
;
2020 if (is_copy_initialization (init
))
2021 flags
|= LOOKUP_ONLYCONVERTING
;
2023 is_global
= begin_init_stmts (&stmt_expr
, &compound_stmt
);
2024 destroy_temps
= stmts_are_full_exprs_p ();
2025 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
2026 bool ok
= expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
2027 init
, LOOKUP_NORMAL
|flags
, complain
);
2028 stmt_expr
= finish_init_stmts (is_global
, stmt_expr
, compound_stmt
);
2029 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
2030 TREE_READONLY (exp
) = was_const
;
2031 TREE_THIS_VOLATILE (exp
) = was_volatile
;
2033 return error_mark_node
;
2035 if ((VAR_P (exp
) || TREE_CODE (exp
) == PARM_DECL
)
2036 && TREE_SIDE_EFFECTS (stmt_expr
)
2037 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (type
)))
2038 /* Just know that we've seen something for this node. */
2039 TREE_USED (exp
) = 1;
2045 expand_default_init (tree binfo
, tree true_exp
, tree exp
, tree init
, int flags
,
2046 tsubst_flags_t complain
)
2048 tree type
= TREE_TYPE (exp
);
2050 /* It fails because there may not be a constructor which takes
2051 its own type as the first (or only parameter), but which does
2052 take other types via a conversion. So, if the thing initializing
2053 the expression is a unit element of type X, first try X(X&),
2054 followed by initialization by X. If neither of these work
2055 out, then look hard. */
2057 vec
<tree
, va_gc
> *parms
;
2059 /* If we have direct-initialization from an initializer list, pull
2060 it out of the TREE_LIST so the code below can see it. */
2061 if (init
&& TREE_CODE (init
) == TREE_LIST
2062 && DIRECT_LIST_INIT_P (TREE_VALUE (init
)))
2064 gcc_checking_assert ((flags
& LOOKUP_ONLYCONVERTING
) == 0
2065 && TREE_CHAIN (init
) == NULL_TREE
);
2066 init
= TREE_VALUE (init
);
2067 /* Only call reshape_init if it has not been called earlier
2069 if (BRACE_ENCLOSED_INITIALIZER_P (init
) && CP_AGGREGATE_TYPE_P (type
))
2070 init
= reshape_init (type
, init
, complain
);
2073 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
2074 && CP_AGGREGATE_TYPE_P (type
))
2075 /* A brace-enclosed initializer for an aggregate. In C++0x this can
2076 happen for direct-initialization, too. */
2077 init
= digest_init (type
, init
, complain
);
2079 if (init
== error_mark_node
)
2082 /* A CONSTRUCTOR of the target's type is a previously digested
2083 initializer, whether that happened just above or in
2084 cp_parser_late_parsing_nsdmi.
2086 A TARGET_EXPR with TARGET_EXPR_DIRECT_INIT_P or TARGET_EXPR_LIST_INIT_P
2087 set represents the whole initialization, so we shouldn't build up
2088 another ctor call. */
2090 && (TREE_CODE (init
) == CONSTRUCTOR
2091 || (TREE_CODE (init
) == TARGET_EXPR
2092 && (TARGET_EXPR_DIRECT_INIT_P (init
)
2093 || TARGET_EXPR_LIST_INIT_P (init
))))
2094 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (init
), type
))
2096 /* Early initialization via a TARGET_EXPR only works for
2097 complete objects. */
2098 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
|| true_exp
== exp
);
2100 init
= cp_build_init_expr (exp
, init
);
2101 TREE_SIDE_EFFECTS (init
) = 1;
2102 finish_expr_stmt (init
);
2106 if (init
&& TREE_CODE (init
) != TREE_LIST
2107 && (flags
& LOOKUP_ONLYCONVERTING
)
2108 && !unsafe_return_slot_p (exp
))
2110 /* Base subobjects should only get direct-initialization. */
2111 gcc_assert (true_exp
== exp
);
2113 if (flags
& DIRECT_BIND
)
2114 /* Do nothing. We hit this in two cases: Reference initialization,
2115 where we aren't initializing a real variable, so we don't want
2116 to run a new constructor; and catching an exception, where we
2117 have already built up the constructor call so we could wrap it
2118 in an exception region. */;
2121 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
,
2122 flags
, complain
| tf_no_cleanup
);
2123 if (init
== error_mark_node
)
2127 /* We need to protect the initialization of a catch parm with a
2128 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
2129 around the TARGET_EXPR for the copy constructor. See
2130 initialize_handler_parm. */
2132 while (TREE_CODE (*p
) == MUST_NOT_THROW_EXPR
2133 || TREE_CODE (*p
) == CLEANUP_POINT_EXPR
)
2135 /* Avoid voidify_wrapper_expr making a temporary. */
2136 TREE_TYPE (*p
) = void_type_node
;
2137 p
= &TREE_OPERAND (*p
, 0);
2139 *p
= cp_build_init_expr (exp
, *p
);
2140 finish_expr_stmt (init
);
2144 if (init
== NULL_TREE
)
2146 else if (TREE_CODE (init
) == TREE_LIST
&& !TREE_TYPE (init
))
2148 parms
= make_tree_vector ();
2149 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
2150 vec_safe_push (parms
, TREE_VALUE (init
));
2153 parms
= make_tree_vector_single (init
);
2155 if (exp
== current_class_ref
&& current_function_decl
2156 && DECL_HAS_IN_CHARGE_PARM_P (current_function_decl
))
2158 /* Delegating constructor. */
2161 tree elt
; unsigned i
;
2163 /* Unshare the arguments for the second call. */
2164 releasing_vec parms2
;
2165 FOR_EACH_VEC_SAFE_ELT (parms
, i
, elt
)
2167 elt
= break_out_target_exprs (elt
);
2168 vec_safe_push (parms2
, elt
);
2170 complete
= build_special_member_call (exp
, complete_ctor_identifier
,
2171 &parms2
, binfo
, flags
,
2173 complete
= fold_build_cleanup_point_expr (void_type_node
, complete
);
2175 base
= build_special_member_call (exp
, base_ctor_identifier
,
2176 &parms
, binfo
, flags
,
2178 base
= fold_build_cleanup_point_expr (void_type_node
, base
);
2179 if (complete
== error_mark_node
|| base
== error_mark_node
)
2181 rval
= build_if_in_charge (complete
, base
);
2185 tree ctor_name
= (true_exp
== exp
2186 ? complete_ctor_identifier
: base_ctor_identifier
);
2188 rval
= build_special_member_call (exp
, ctor_name
, &parms
, binfo
, flags
,
2190 if (rval
== error_mark_node
)
2195 release_tree_vector (parms
);
2197 if (exp
== true_exp
&& TREE_CODE (rval
) == CALL_EXPR
)
2199 tree fn
= get_callee_fndecl (rval
);
2200 if (fn
&& DECL_DECLARED_CONSTEXPR_P (fn
))
2202 tree e
= maybe_constant_init (rval
, exp
);
2203 if (TREE_CONSTANT (e
))
2204 rval
= cp_build_init_expr (exp
, e
);
2208 /* FIXME put back convert_to_void? */
2209 if (TREE_SIDE_EFFECTS (rval
))
2210 finish_expr_stmt (rval
);
2215 /* This function is responsible for initializing EXP with INIT
2216 (if any). Returns true on success, false on failure.
2218 BINFO is the binfo of the type for who we are performing the
2219 initialization. For example, if W is a virtual base class of A and B,
2221 If we are initializing B, then W must contain B's W vtable, whereas
2222 were we initializing C, W must contain C's W vtable.
2224 TRUE_EXP is nonzero if it is the true expression being initialized.
2225 In this case, it may be EXP, or may just contain EXP. The reason we
2226 need this is because if EXP is a base element of TRUE_EXP, we
2227 don't necessarily know by looking at EXP where its virtual
2228 baseclass fields should really be pointing. But we do know
2229 from TRUE_EXP. In constructors, we don't know anything about
2230 the value being initialized.
2232 FLAGS is just passed to `build_new_method_call'. See that function
2233 for its description. */
2236 expand_aggr_init_1 (tree binfo
, tree true_exp
, tree exp
, tree init
, int flags
,
2237 tsubst_flags_t complain
)
2239 tree type
= TREE_TYPE (exp
);
2241 gcc_assert (init
!= error_mark_node
&& type
!= error_mark_node
);
2242 gcc_assert (building_stmt_list_p ());
2244 /* Use a function returning the desired type to initialize EXP for us.
2245 If the function is a constructor, and its first argument is
2246 NULL_TREE, know that it was meant for us--just slide exp on
2247 in and expand the constructor. Constructors now come
2250 if (init
&& VAR_P (exp
)
2251 && COMPOUND_LITERAL_P (init
))
2253 vec
<tree
, va_gc
> *cleanups
= NULL
;
2254 /* If store_init_value returns NULL_TREE, the INIT has been
2255 recorded as the DECL_INITIAL for EXP. That means there's
2256 nothing more we have to do. */
2257 init
= store_init_value (exp
, init
, &cleanups
, flags
);
2259 finish_expr_stmt (init
);
2260 gcc_assert (!cleanups
);
2264 /* List-initialization from {} becomes value-initialization for non-aggregate
2265 classes with default constructors. Handle this here when we're
2266 initializing a base, so protected access works. */
2267 if (exp
!= true_exp
&& init
&& TREE_CODE (init
) == TREE_LIST
)
2269 tree elt
= TREE_VALUE (init
);
2270 if (DIRECT_LIST_INIT_P (elt
)
2271 && CONSTRUCTOR_ELTS (elt
) == 0
2272 && CLASSTYPE_NON_AGGREGATE (type
)
2273 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2274 init
= void_type_node
;
2277 /* If an explicit -- but empty -- initializer list was present,
2278 that's value-initialization. */
2279 if (init
== void_type_node
)
2281 /* If the type has data but no user-provided default ctor, we need to zero
2283 if (type_has_non_user_provided_default_constructor (type
)
2284 && !is_really_empty_class (type
, /*ignore_vptr*/true))
2286 tree field_size
= NULL_TREE
;
2287 if (exp
!= true_exp
&& CLASSTYPE_AS_BASE (type
) != type
)
2288 /* Don't clobber already initialized virtual bases. */
2289 field_size
= TYPE_SIZE (CLASSTYPE_AS_BASE (type
));
2290 init
= build_zero_init_1 (type
, NULL_TREE
, /*static_storage_p=*/false,
2292 init
= cp_build_init_expr (exp
, init
);
2293 finish_expr_stmt (init
);
2296 /* If we don't need to mess with the constructor at all,
2298 if (! type_build_ctor_call (type
))
2301 /* Otherwise fall through and call the constructor. */
2305 /* We know that expand_default_init can handle everything we want
2307 return expand_default_init (binfo
, true_exp
, exp
, init
, flags
, complain
);
2310 /* Report an error if TYPE is not a user-defined, class type. If
2311 OR_ELSE is nonzero, give an error message. */
2314 is_class_type (tree type
, int or_else
)
2316 if (type
== error_mark_node
)
2319 if (! CLASS_TYPE_P (type
))
2322 error ("%qT is not a class type", type
);
2328 /* Returns true iff the initializer INIT represents copy-initialization
2329 (and therefore we must set LOOKUP_ONLYCONVERTING when processing it). */
2332 is_copy_initialization (tree init
)
2334 return (init
&& init
!= void_type_node
2335 && TREE_CODE (init
) != TREE_LIST
2336 && !(TREE_CODE (init
) == TARGET_EXPR
2337 && TARGET_EXPR_DIRECT_INIT_P (init
))
2338 && !DIRECT_LIST_INIT_P (init
));
2341 /* Build a reference to a member of an aggregate. This is not a C++
2342 `&', but really something which can have its address taken, and
2343 then act as a pointer to member, for example TYPE :: FIELD can have
2344 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
2345 this expression is the operand of "&".
2347 @@ Prints out lousy diagnostics for operator <typename>
2350 @@ This function should be rewritten and placed in search.cc. */
2353 build_offset_ref (tree type
, tree member
, bool address_p
,
2354 tsubst_flags_t complain
)
2357 tree basebinfo
= NULL_TREE
;
2359 /* class templates can come in as TEMPLATE_DECLs here. */
2360 if (TREE_CODE (member
) == TEMPLATE_DECL
)
2363 if (dependent_scope_p (type
) || type_dependent_expression_p (member
))
2364 return build_qualified_name (NULL_TREE
, type
, member
,
2365 /*template_p=*/false);
2367 gcc_assert (TYPE_P (type
));
2368 if (! is_class_type (type
, 1))
2369 return error_mark_node
;
2371 gcc_assert (DECL_P (member
) || BASELINK_P (member
));
2372 /* Callers should call mark_used before this point, except for functions. */
2373 gcc_assert (!DECL_P (member
) || TREE_USED (member
)
2374 || TREE_CODE (member
) == FUNCTION_DECL
);
2376 type
= TYPE_MAIN_VARIANT (type
);
2377 if (!COMPLETE_OR_OPEN_TYPE_P (complete_type (type
)))
2379 if (complain
& tf_error
)
2380 error ("incomplete type %qT does not have member %qD", type
, member
);
2381 return error_mark_node
;
2384 /* Entities other than non-static members need no further
2386 if (TREE_CODE (member
) == TYPE_DECL
)
2388 if (VAR_P (member
) || TREE_CODE (member
) == CONST_DECL
)
2389 return convert_from_reference (member
);
2391 if (TREE_CODE (member
) == FIELD_DECL
&& DECL_C_BIT_FIELD (member
))
2393 if (complain
& tf_error
)
2394 error ("invalid pointer to bit-field %qD", member
);
2395 return error_mark_node
;
2398 /* Set up BASEBINFO for member lookup. */
2399 decl
= maybe_dummy_object (type
, &basebinfo
);
2401 /* A lot of this logic is now handled in lookup_member. */
2402 if (BASELINK_P (member
))
2404 /* Go from the TREE_BASELINK to the member function info. */
2405 tree t
= BASELINK_FUNCTIONS (member
);
2407 if (TREE_CODE (t
) != TEMPLATE_ID_EXPR
&& !really_overloaded_fn (t
))
2409 /* Get rid of a potential OVERLOAD around it. */
2412 /* Unique functions are handled easily. */
2414 /* For non-static member of base class, we need a special rule
2415 for access checking [class.protected]:
2417 If the access is to form a pointer to member, the
2418 nested-name-specifier shall name the derived class
2419 (or any class derived from that class). */
2421 if (address_p
&& DECL_P (t
)
2422 && DECL_NONSTATIC_MEMBER_P (t
))
2423 ok
= perform_or_defer_access_check (TYPE_BINFO (type
), t
, t
,
2426 ok
= perform_or_defer_access_check (basebinfo
, t
, t
,
2429 return error_mark_node
;
2430 if (DECL_STATIC_FUNCTION_P (t
))
2435 TREE_TYPE (member
) = unknown_type_node
;
2437 else if (address_p
&& TREE_CODE (member
) == FIELD_DECL
)
2439 /* We need additional test besides the one in
2440 check_accessibility_of_qualified_id in case it is
2441 a pointer to non-static member. */
2442 if (!perform_or_defer_access_check (TYPE_BINFO (type
), member
, member
,
2444 return error_mark_node
;
2449 /* If MEMBER is non-static, then the program has fallen afoul of
2452 An id-expression that denotes a non-static data member or
2453 non-static member function of a class can only be used:
2455 -- as part of a class member access (_expr.ref_) in which the
2456 object-expression refers to the member's class or a class
2457 derived from that class, or
2459 -- to form a pointer to member (_expr.unary.op_), or
2461 -- in the body of a non-static member function of that class or
2462 of a class derived from that class (_class.mfct.non-static_), or
2464 -- in a mem-initializer for a constructor for that class or for
2465 a class derived from that class (_class.base.init_). */
2466 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member
))
2468 /* Build a representation of the qualified name suitable
2469 for use as the operand to "&" -- even though the "&" is
2470 not actually present. */
2471 member
= build2 (OFFSET_REF
, TREE_TYPE (member
), decl
, member
);
2472 /* In Microsoft mode, treat a non-static member function as if
2473 it were a pointer-to-member. */
2474 if (flag_ms_extensions
)
2476 PTRMEM_OK_P (member
) = 1;
2477 return cp_build_addr_expr (member
, complain
);
2479 if (complain
& tf_error
)
2480 error ("invalid use of non-static member function %qD",
2481 TREE_OPERAND (member
, 1));
2482 return error_mark_node
;
2484 else if (TREE_CODE (member
) == FIELD_DECL
)
2486 if (complain
& tf_error
)
2487 error ("invalid use of non-static data member %qD", member
);
2488 return error_mark_node
;
2493 member
= build2 (OFFSET_REF
, TREE_TYPE (member
), decl
, member
);
2494 PTRMEM_OK_P (member
) = 1;
2498 /* If DECL is a scalar enumeration constant or variable with a
2499 constant initializer, return the initializer (or, its initializers,
2500 recursively); otherwise, return DECL. If STRICT_P, the
2501 initializer is only returned if DECL is a
2502 constant-expression. If RETURN_AGGREGATE_CST_OK_P, it is ok to
2503 return an aggregate constant. If UNSHARE_P, return an unshared
2504 copy of the initializer. */
2507 constant_value_1 (tree decl
, bool strict_p
, bool return_aggregate_cst_ok_p
,
2510 while (TREE_CODE (decl
) == CONST_DECL
2511 || decl_constant_var_p (decl
)
2512 || (!strict_p
&& VAR_P (decl
)
2513 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl
))))
2516 /* If DECL is a static data member in a template
2517 specialization, we must instantiate it here. The
2518 initializer for the static data member is not processed
2519 until needed; we need it now. */
2520 mark_used (decl
, tf_none
);
2521 init
= DECL_INITIAL (decl
);
2522 if (init
== error_mark_node
)
2524 if (TREE_CODE (decl
) == CONST_DECL
2525 || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
))
2526 /* Treat the error as a constant to avoid cascading errors on
2527 excessively recursive template instantiation (c++/9335). */
2532 /* Initializers in templates are generally expanded during
2533 instantiation, so before that for const int i(2)
2534 INIT is a TREE_LIST with the actual initializer as
2536 if (processing_template_decl
2538 && TREE_CODE (init
) == TREE_LIST
2539 && TREE_CHAIN (init
) == NULL_TREE
)
2540 init
= TREE_VALUE (init
);
2541 /* Instantiate a non-dependent initializer for user variables. We
2542 mustn't do this for the temporary for an array compound literal;
2543 trying to instatiate the initializer will keep creating new
2544 temporaries until we crash. Probably it's not useful to do it for
2545 other artificial variables, either. */
2546 if (!DECL_ARTIFICIAL (decl
))
2547 init
= instantiate_non_dependent_or_null (init
);
2549 || !TREE_TYPE (init
)
2550 || !TREE_CONSTANT (init
)
2551 || (!return_aggregate_cst_ok_p
2552 /* Unless RETURN_AGGREGATE_CST_OK_P is true, do not
2553 return an aggregate constant (of which string
2554 literals are a special case), as we do not want
2555 to make inadvertent copies of such entities, and
2556 we must be sure that their addresses are the
2558 && (TREE_CODE (init
) == CONSTRUCTOR
2559 || TREE_CODE (init
) == STRING_CST
)))
2561 /* Don't return a CONSTRUCTOR for a variable with partial run-time
2562 initialization, since it doesn't represent the entire value.
2563 Similarly for VECTOR_CSTs created by cp_folding those
2565 if ((TREE_CODE (init
) == CONSTRUCTOR
2566 || TREE_CODE (init
) == VECTOR_CST
)
2567 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
))
2569 /* If the variable has a dynamic initializer, don't use its
2570 DECL_INITIAL which doesn't reflect the real value. */
2572 && TREE_STATIC (decl
)
2573 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
)
2574 && DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
2578 return unshare_p
? unshare_expr (decl
) : decl
;
2581 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by constant
2582 of integral or enumeration type, or a constexpr variable of scalar type,
2583 then return that value. These are those variables permitted in constant
2584 expressions by [5.19/1]. */
2587 scalar_constant_value (tree decl
)
2589 return constant_value_1 (decl
, /*strict_p=*/true,
2590 /*return_aggregate_cst_ok_p=*/false,
2591 /*unshare_p=*/true);
2594 /* Like scalar_constant_value, but can also return aggregate initializers.
2595 If UNSHARE_P, return an unshared copy of the initializer. */
2598 decl_really_constant_value (tree decl
, bool unshare_p
/*= true*/)
2600 return constant_value_1 (decl
, /*strict_p=*/true,
2601 /*return_aggregate_cst_ok_p=*/true,
2602 /*unshare_p=*/unshare_p
);
2605 /* A more relaxed version of decl_really_constant_value, used by the
2606 common C/C++ code. */
2609 decl_constant_value (tree decl
, bool unshare_p
)
2611 return constant_value_1 (decl
, /*strict_p=*/processing_template_decl
,
2612 /*return_aggregate_cst_ok_p=*/true,
2613 /*unshare_p=*/unshare_p
);
2617 decl_constant_value (tree decl
)
2619 return decl_constant_value (decl
, /*unshare_p=*/true);
2622 /* Common subroutines of build_new and build_vec_delete. */
2624 /* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
2625 the type of the object being allocated; otherwise, it's just TYPE.
2626 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
2627 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
2628 a vector of arguments to be provided as arguments to a placement
2629 new operator. This routine performs no semantic checks; it just
2630 creates and returns a NEW_EXPR. */
2633 build_raw_new_expr (location_t loc
, vec
<tree
, va_gc
> *placement
, tree type
,
2634 tree nelts
, vec
<tree
, va_gc
> *init
, int use_global_new
)
2639 /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR.
2640 If INIT is not NULL, then we want to store VOID_ZERO_NODE. This
2641 permits us to distinguish the case of a missing initializer "new
2642 int" from an empty initializer "new int()". */
2644 init_list
= NULL_TREE
;
2645 else if (init
->is_empty ())
2646 init_list
= void_node
;
2648 init_list
= build_tree_list_vec (init
);
2650 new_expr
= build4_loc (loc
, NEW_EXPR
, build_pointer_type (type
),
2651 build_tree_list_vec (placement
), type
, nelts
,
2653 NEW_EXPR_USE_GLOBAL (new_expr
) = use_global_new
;
2654 TREE_SIDE_EFFECTS (new_expr
) = 1;
2659 /* Diagnose uninitialized const members or reference members of type
2660 TYPE. USING_NEW is used to disambiguate the diagnostic between a
2661 new expression without a new-initializer and a declaration. Returns
2665 diagnose_uninitialized_cst_or_ref_member_1 (tree type
, tree origin
,
2666 bool using_new
, bool complain
)
2669 int error_count
= 0;
2671 if (type_has_user_provided_constructor (type
))
2674 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2678 if (TREE_CODE (field
) != FIELD_DECL
)
2681 field_type
= strip_array_types (TREE_TYPE (field
));
2683 if (type_has_user_provided_constructor (field_type
))
2686 if (TYPE_REF_P (field_type
))
2691 if (DECL_CONTEXT (field
) == origin
)
2694 error ("uninitialized reference member in %q#T "
2695 "using %<new%> without new-initializer", origin
);
2697 error ("uninitialized reference member in %q#T", origin
);
2702 error ("uninitialized reference member in base %q#T "
2703 "of %q#T using %<new%> without new-initializer",
2704 DECL_CONTEXT (field
), origin
);
2706 error ("uninitialized reference member in base %q#T "
2707 "of %q#T", DECL_CONTEXT (field
), origin
);
2709 inform (DECL_SOURCE_LOCATION (field
),
2710 "%q#D should be initialized", field
);
2714 if (CP_TYPE_CONST_P (field_type
))
2719 if (DECL_CONTEXT (field
) == origin
)
2722 error ("uninitialized const member in %q#T "
2723 "using %<new%> without new-initializer", origin
);
2725 error ("uninitialized const member in %q#T", origin
);
2730 error ("uninitialized const member in base %q#T "
2731 "of %q#T using %<new%> without new-initializer",
2732 DECL_CONTEXT (field
), origin
);
2734 error ("uninitialized const member in base %q#T "
2735 "of %q#T", DECL_CONTEXT (field
), origin
);
2737 inform (DECL_SOURCE_LOCATION (field
),
2738 "%q#D should be initialized", field
);
2742 if (CLASS_TYPE_P (field_type
))
2744 += diagnose_uninitialized_cst_or_ref_member_1 (field_type
, origin
,
2745 using_new
, complain
);
2751 diagnose_uninitialized_cst_or_ref_member (tree type
, bool using_new
, bool complain
)
2753 return diagnose_uninitialized_cst_or_ref_member_1 (type
, type
, using_new
, complain
);
2756 /* Call __cxa_bad_array_new_length to indicate that the size calculation
2757 overflowed. Pretend it returns sizetype so that it plays nicely in the
2761 throw_bad_array_new_length (void)
2765 tree name
= get_identifier ("__cxa_throw_bad_array_new_length");
2767 fn
= get_global_binding (name
);
2769 fn
= push_throw_library_fn
2770 (name
, build_function_type_list (sizetype
, NULL_TREE
));
2773 return build_cxx_call (fn
, 0, NULL
, tf_warning_or_error
);
2776 /* Attempt to verify that the argument, OPER, of a placement new expression
2777 refers to an object sufficiently large for an object of TYPE or an array
2778 of NELTS of such objects when NELTS is non-null, and issue a warning when
2779 it does not. SIZE specifies the size needed to construct the object or
2780 array and captures the result of NELTS * sizeof (TYPE). (SIZE could be
2781 greater when the array under construction requires a cookie to store
2782 NELTS. GCC's placement new expression stores the cookie when invoking
2783 a user-defined placement new operator function but not the default one.
2784 Placement new expressions with user-defined placement new operator are
2785 not diagnosed since we don't know how they use the buffer (this could
2786 be a future extension). */
2788 warn_placement_new_too_small (tree type
, tree nelts
, tree size
, tree oper
)
2790 location_t loc
= cp_expr_loc_or_input_loc (oper
);
2794 /* Using a function argument or a (non-array) variable as an argument
2795 to placement new is not checked since it's unknown what it might
2797 if (TREE_CODE (oper
) == PARM_DECL
2799 || TREE_CODE (oper
) == COMPONENT_REF
)
2802 /* Evaluate any constant expressions. */
2803 size
= fold_non_dependent_expr (size
);
2806 ref
.eval
= [](tree x
){ return fold_non_dependent_expr (x
); };
2807 ref
.trail1special
= warn_placement_new
< 2;
2808 tree objsize
= compute_objsize (oper
, 1, &ref
);
2812 /* We can only draw conclusions if ref.deref == -1,
2813 i.e. oper is the address of the object. */
2814 if (ref
.deref
!= -1)
2817 offset_int bytes_avail
= wi::to_offset (objsize
);
2818 offset_int bytes_need
;
2820 if (CONSTANT_CLASS_P (size
))
2821 bytes_need
= wi::to_offset (size
);
2822 else if (nelts
&& CONSTANT_CLASS_P (nelts
))
2823 bytes_need
= (wi::to_offset (nelts
)
2824 * wi::to_offset (TYPE_SIZE_UNIT (type
)));
2825 else if (tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
2826 bytes_need
= wi::to_offset (TYPE_SIZE_UNIT (type
));
2829 /* The type is a VLA. */
2833 if (bytes_avail
>= bytes_need
)
2836 /* True when the size to mention in the warning is exact as opposed
2838 const bool exact_size
= (ref
.offrng
[0] == ref
.offrng
[1]
2839 || ref
.sizrng
[1] - ref
.offrng
[0] == 0);
2841 tree opertype
= ref
.ref
? TREE_TYPE (ref
.ref
) : TREE_TYPE (oper
);
2842 bool warned
= false;
2844 nelts
= fold_for_warn (nelts
);
2846 if (CONSTANT_CLASS_P (nelts
))
2847 warned
= warning_at (loc
, OPT_Wplacement_new_
,
2849 ? G_("placement new constructing an object "
2850 "of type %<%T [%wu]%> and size %qwu "
2851 "in a region of type %qT and size %qwi")
2852 : G_("placement new constructing an object "
2853 "of type %<%T [%wu]%> and size %qwu "
2854 "in a region of type %qT and size "
2856 type
, tree_to_uhwi (nelts
),
2857 bytes_need
.to_uhwi (),
2858 opertype
, bytes_avail
.to_uhwi ());
2860 warned
= warning_at (loc
, OPT_Wplacement_new_
,
2862 ? G_("placement new constructing an array "
2863 "of objects of type %qT and size %qwu "
2864 "in a region of type %qT and size %qwi")
2865 : G_("placement new constructing an array "
2866 "of objects of type %qT and size %qwu "
2867 "in a region of type %qT and size "
2869 type
, bytes_need
.to_uhwi (), opertype
,
2870 bytes_avail
.to_uhwi ());
2872 warned
= warning_at (loc
, OPT_Wplacement_new_
,
2874 ? G_("placement new constructing an object "
2875 "of type %qT and size %qwu in a region "
2876 "of type %qT and size %qwi")
2877 : G_("placement new constructing an object "
2879 "and size %qwu in a region of type %qT "
2880 "and size at most %qwu")),
2881 type
, bytes_need
.to_uhwi (), opertype
,
2882 bytes_avail
.to_uhwi ());
2884 if (!warned
|| !ref
.ref
)
2887 if (ref
.offrng
[0] == 0 || !ref
.offset_bounded ())
2888 /* Avoid mentioning the offset when its lower bound is zero
2889 or when it's impossibly large. */
2890 inform (DECL_SOURCE_LOCATION (ref
.ref
),
2891 "%qD declared here", ref
.ref
);
2892 else if (ref
.offrng
[0] == ref
.offrng
[1])
2893 inform (DECL_SOURCE_LOCATION (ref
.ref
),
2894 "at offset %wi from %qD declared here",
2895 ref
.offrng
[0].to_shwi (), ref
.ref
);
2897 inform (DECL_SOURCE_LOCATION (ref
.ref
),
2898 "at offset [%wi, %wi] from %qD declared here",
2899 ref
.offrng
[0].to_shwi (), ref
.offrng
[1].to_shwi (), ref
.ref
);
2902 /* True if alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__. */
2905 type_has_new_extended_alignment (tree t
)
2907 return (aligned_new_threshold
2908 && TYPE_ALIGN_UNIT (t
) > (unsigned)aligned_new_threshold
);
2911 /* Return the alignment we expect malloc to guarantee. This should just be
2912 MALLOC_ABI_ALIGNMENT, but that macro defaults to only BITS_PER_WORD for some
2913 reason, so don't let the threshold be smaller than max_align_t_align. */
2918 return MAX (max_align_t_align(), MALLOC_ABI_ALIGNMENT
);
2921 /* Determine whether an allocation function is a namespace-scope
2922 non-replaceable placement new function. See DR 1748. */
2924 std_placement_new_fn_p (tree alloc_fn
)
2926 if (DECL_NAMESPACE_SCOPE_P (alloc_fn
))
2928 tree first_arg
= TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn
)));
2929 if ((TREE_VALUE (first_arg
) == ptr_type_node
)
2930 && TREE_CHAIN (first_arg
) == void_list_node
)
2936 /* For element type ELT_TYPE, return the appropriate type of the heap object
2937 containing such element(s). COOKIE_SIZE is the size of cookie in bytes.
2939 struct { size_t[COOKIE_SIZE/sizeof(size_t)]; ELT_TYPE[N]; }
2940 where N is nothing (flexible array member) if ITYPE2 is NULL, otherwise
2941 the array has ITYPE2 as its TYPE_DOMAIN. */
2944 build_new_constexpr_heap_type (tree elt_type
, tree cookie_size
, tree itype2
)
2946 gcc_assert (tree_fits_uhwi_p (cookie_size
));
2947 unsigned HOST_WIDE_INT csz
= tree_to_uhwi (cookie_size
);
2948 csz
/= int_size_in_bytes (sizetype
);
2949 tree itype1
= build_index_type (size_int (csz
- 1));
2950 tree atype1
= build_cplus_array_type (sizetype
, itype1
);
2951 tree atype2
= build_cplus_array_type (elt_type
, itype2
);
2952 tree rtype
= cxx_make_type (RECORD_TYPE
);
2953 TYPE_NAME (rtype
) = heap_identifier
;
2954 tree fld1
= build_decl (UNKNOWN_LOCATION
, FIELD_DECL
, NULL_TREE
, atype1
);
2955 tree fld2
= build_decl (UNKNOWN_LOCATION
, FIELD_DECL
, NULL_TREE
, atype2
);
2956 DECL_FIELD_CONTEXT (fld1
) = rtype
;
2957 DECL_FIELD_CONTEXT (fld2
) = rtype
;
2958 DECL_ARTIFICIAL (fld1
) = true;
2959 DECL_ARTIFICIAL (fld2
) = true;
2960 TYPE_FIELDS (rtype
) = fld1
;
2961 DECL_CHAIN (fld1
) = fld2
;
2962 layout_type (rtype
);
2966 /* Help the constexpr code to find the right type for the heap variable
2967 by adding a NOP_EXPR around ALLOC_CALL if needed for cookie_size.
2968 Return ALLOC_CALL or ALLOC_CALL cast to a pointer to
2969 struct { size_t[cookie_size/sizeof(size_t)]; elt_type[]; }. */
2972 maybe_wrap_new_for_constexpr (tree alloc_call
, tree elt_type
, tree cookie_size
)
2974 if (cxx_dialect
< cxx20
)
2977 if (current_function_decl
!= NULL_TREE
2978 && !DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
2981 tree call_expr
= extract_call_expr (alloc_call
);
2982 if (call_expr
== error_mark_node
)
2985 tree alloc_call_fndecl
= cp_get_callee_fndecl_nofold (call_expr
);
2986 if (alloc_call_fndecl
== NULL_TREE
2987 || !IDENTIFIER_NEW_OP_P (DECL_NAME (alloc_call_fndecl
))
2988 || CP_DECL_CONTEXT (alloc_call_fndecl
) != global_namespace
)
2991 tree rtype
= build_new_constexpr_heap_type (elt_type
, cookie_size
,
2993 return build_nop (build_pointer_type (rtype
), alloc_call
);
2996 /* Generate code for a new-expression, including calling the "operator
2997 new" function, initializing the object, and, if an exception occurs
2998 during construction, cleaning up. The arguments are as for
2999 build_raw_new_expr. This may change PLACEMENT and INIT.
3000 TYPE is the type of the object being constructed, possibly an array
3001 of NELTS elements when NELTS is non-null (in "new T[NELTS]", T may
3002 be an array of the form U[inner], with the whole expression being
3003 "new U[NELTS][inner]"). */
3006 build_new_1 (vec
<tree
, va_gc
> **placement
, tree type
, tree nelts
,
3007 vec
<tree
, va_gc
> **init
, bool globally_qualified_p
,
3008 tsubst_flags_t complain
)
3011 /* True iff this is a call to "operator new[]" instead of just
3013 bool array_p
= false;
3014 /* If ARRAY_P is true, the element type of the array. This is never
3015 an ARRAY_TYPE; for something like "new int[3][4]", the
3016 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
3019 /* The type of the new-expression. (This type is always a pointer
3022 tree non_const_pointer_type
;
3023 /* The most significant array bound in int[OUTER_NELTS][inner]. */
3024 tree outer_nelts
= NULL_TREE
;
3025 /* For arrays with a non-constant number of elements, a bounds checks
3026 on the NELTS parameter to avoid integer overflow at runtime. */
3027 tree outer_nelts_check
= NULL_TREE
;
3028 bool outer_nelts_from_type
= false;
3029 /* Number of the "inner" elements in "new T[OUTER_NELTS][inner]". */
3030 offset_int inner_nelts_count
= 1;
3031 tree alloc_call
, alloc_expr
;
3032 /* Size of the inner array elements (those with constant dimensions). */
3033 offset_int inner_size
;
3034 /* The address returned by the call to "operator new". This node is
3035 a VAR_DECL and is therefore reusable. */
3038 tree cookie_expr
, init_expr
;
3039 int nothrow
, check_new
;
3040 /* If non-NULL, the number of extra bytes to allocate at the
3041 beginning of the storage allocated for an array-new expression in
3042 order to store the number of elements. */
3043 tree cookie_size
= NULL_TREE
;
3044 tree placement_first
;
3045 tree placement_expr
= NULL_TREE
;
3046 /* True if the function we are calling is a placement allocation
3048 bool placement_allocation_fn_p
;
3049 /* True if the storage must be initialized, either by a constructor
3050 or due to an explicit new-initializer. */
3051 bool is_initialized
;
3052 /* The address of the thing allocated, not including any cookie. In
3053 particular, if an array cookie is in use, DATA_ADDR is the
3054 address of the first array element. This node is a VAR_DECL, and
3055 is therefore reusable. */
3057 tree orig_type
= type
;
3061 outer_nelts
= nelts
;
3064 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3066 /* Transforms new (T[N]) to new T[N]. The former is a GNU
3067 extension for variable N. (This also covers new T where T is
3070 nelts
= array_type_nelts_top (type
);
3071 outer_nelts
= nelts
;
3072 type
= TREE_TYPE (type
);
3073 outer_nelts_from_type
= true;
3076 /* Lots of logic below depends on whether we have a constant number of
3077 elements, so go ahead and fold it now. */
3078 const_tree cst_outer_nelts
= fold_non_dependent_expr (outer_nelts
, complain
);
3080 /* If our base type is an array, then make sure we know how many elements
3082 for (elt_type
= type
;
3083 TREE_CODE (elt_type
) == ARRAY_TYPE
;
3084 elt_type
= TREE_TYPE (elt_type
))
3086 tree inner_nelts
= array_type_nelts_top (elt_type
);
3087 tree inner_nelts_cst
= maybe_constant_value (inner_nelts
);
3088 if (TREE_CODE (inner_nelts_cst
) == INTEGER_CST
)
3090 wi::overflow_type overflow
;
3091 offset_int result
= wi::mul (wi::to_offset (inner_nelts_cst
),
3092 inner_nelts_count
, SIGNED
, &overflow
);
3095 if (complain
& tf_error
)
3096 error ("integer overflow in array size");
3097 nelts
= error_mark_node
;
3099 inner_nelts_count
= result
;
3103 if (complain
& tf_error
)
3105 error_at (cp_expr_loc_or_input_loc (inner_nelts
),
3106 "array size in new-expression must be constant");
3107 cxx_constant_value(inner_nelts
);
3109 nelts
= error_mark_node
;
3111 if (nelts
!= error_mark_node
)
3112 nelts
= cp_build_binary_op (input_location
,
3118 if (!verify_type_context (input_location
, TCTX_ALLOCATION
, elt_type
,
3119 !(complain
& tf_error
)))
3120 return error_mark_node
;
3122 if (variably_modified_type_p (elt_type
, NULL_TREE
) && (complain
& tf_error
))
3124 error ("variably modified type not allowed in new-expression");
3125 return error_mark_node
;
3128 if (nelts
== error_mark_node
)
3129 return error_mark_node
;
3131 /* Warn if we performed the (T[N]) to T[N] transformation and N is
3133 if (outer_nelts_from_type
3134 && !TREE_CONSTANT (cst_outer_nelts
))
3136 if (complain
& tf_warning_or_error
)
3138 pedwarn (cp_expr_loc_or_input_loc (outer_nelts
), OPT_Wvla
,
3139 typedef_variant_p (orig_type
)
3140 ? G_("non-constant array new length must be specified "
3141 "directly, not by %<typedef%>")
3142 : G_("non-constant array new length must be specified "
3143 "without parentheses around the type-id"));
3146 return error_mark_node
;
3149 if (VOID_TYPE_P (elt_type
))
3151 if (complain
& tf_error
)
3152 error ("invalid type %<void%> for %<new%>");
3153 return error_mark_node
;
3156 if (is_std_init_list (elt_type
) && !cp_unevaluated_operand
)
3157 warning (OPT_Winit_list_lifetime
,
3158 "%<new%> of %<initializer_list%> does not "
3159 "extend the lifetime of the underlying array");
3161 if (abstract_virtuals_error (ACU_NEW
, elt_type
, complain
))
3162 return error_mark_node
;
3164 is_initialized
= (type_build_ctor_call (elt_type
) || *init
!= NULL
);
3166 if (*init
== NULL
&& cxx_dialect
< cxx11
)
3168 bool maybe_uninitialized_error
= false;
3169 /* A program that calls for default-initialization [...] of an
3170 entity of reference type is ill-formed. */
3171 if (CLASSTYPE_REF_FIELDS_NEED_INIT (elt_type
))
3172 maybe_uninitialized_error
= true;
3174 /* A new-expression that creates an object of type T initializes
3175 that object as follows:
3176 - If the new-initializer is omitted:
3177 -- If T is a (possibly cv-qualified) non-POD class type
3178 (or array thereof), the object is default-initialized (8.5).
3180 -- Otherwise, the object created has indeterminate
3181 value. If T is a const-qualified type, or a (possibly
3182 cv-qualified) POD class type (or array thereof)
3183 containing (directly or indirectly) a member of
3184 const-qualified type, the program is ill-formed; */
3186 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (elt_type
))
3187 maybe_uninitialized_error
= true;
3189 if (maybe_uninitialized_error
3190 && diagnose_uninitialized_cst_or_ref_member (elt_type
,
3192 complain
& tf_error
))
3193 return error_mark_node
;
3196 if (CP_TYPE_CONST_P (elt_type
) && *init
== NULL
3197 && default_init_uninitialized_part (elt_type
))
3199 if (complain
& tf_error
)
3200 error ("uninitialized const in %<new%> of %q#T", elt_type
);
3201 return error_mark_node
;
3204 size
= size_in_bytes (elt_type
);
3207 /* Maximum available size in bytes. Half of the address space
3208 minus the cookie size. */
3210 = wi::set_bit_in_zero
<offset_int
> (TYPE_PRECISION (sizetype
) - 1);
3211 /* Maximum number of outer elements which can be allocated. */
3212 offset_int max_outer_nelts
;
3213 tree max_outer_nelts_tree
;
3215 gcc_assert (TREE_CODE (size
) == INTEGER_CST
);
3216 cookie_size
= targetm
.cxx
.get_cookie_size (elt_type
);
3217 gcc_assert (TREE_CODE (cookie_size
) == INTEGER_CST
);
3218 gcc_checking_assert (wi::ltu_p (wi::to_offset (cookie_size
), max_size
));
3219 /* Unconditionally subtract the cookie size. This decreases the
3220 maximum object size and is safe even if we choose not to use
3221 a cookie after all. */
3222 max_size
-= wi::to_offset (cookie_size
);
3223 wi::overflow_type overflow
;
3224 inner_size
= wi::mul (wi::to_offset (size
), inner_nelts_count
, SIGNED
,
3226 if (overflow
|| wi::gtu_p (inner_size
, max_size
))
3228 if (complain
& tf_error
)
3230 cst_size_error error
;
3232 error
= cst_size_overflow
;
3235 error
= cst_size_too_big
;
3236 size
= size_binop (MULT_EXPR
, size
,
3237 wide_int_to_tree (sizetype
,
3238 inner_nelts_count
));
3239 size
= cp_fully_fold (size
);
3241 invalid_array_size_error (input_location
, error
, size
,
3242 /*name=*/NULL_TREE
);
3244 return error_mark_node
;
3247 max_outer_nelts
= wi::udiv_trunc (max_size
, inner_size
);
3248 max_outer_nelts_tree
= wide_int_to_tree (sizetype
, max_outer_nelts
);
3250 size
= size_binop (MULT_EXPR
, size
, fold_convert (sizetype
, nelts
));
3252 if (TREE_CODE (cst_outer_nelts
) == INTEGER_CST
)
3254 if (tree_int_cst_lt (max_outer_nelts_tree
, cst_outer_nelts
))
3256 /* When the array size is constant, check it at compile time
3257 to make sure it doesn't exceed the implementation-defined
3258 maximum, as required by C++ 14 (in C++ 11 this requirement
3259 isn't explicitly stated but it's enforced anyway -- see
3260 grokdeclarator in cp/decl.cc). */
3261 if (complain
& tf_error
)
3263 size
= cp_fully_fold (size
);
3264 invalid_array_size_error (input_location
, cst_size_too_big
,
3267 return error_mark_node
;
3272 /* When a runtime check is necessary because the array size
3273 isn't constant, keep only the top-most seven bits (starting
3274 with the most significant non-zero bit) of the maximum size
3275 to compare the array size against, to simplify encoding the
3276 constant maximum size in the instruction stream. */
3278 unsigned shift
= (max_outer_nelts
.get_precision ()) - 7
3279 - wi::clz (max_outer_nelts
);
3280 max_outer_nelts
= (max_outer_nelts
>> shift
) << shift
;
3282 outer_nelts_check
= fold_build2 (LE_EXPR
, boolean_type_node
,
3284 max_outer_nelts_tree
);
3288 tree align_arg
= NULL_TREE
;
3289 if (type_has_new_extended_alignment (elt_type
))
3291 unsigned align
= TYPE_ALIGN_UNIT (elt_type
);
3292 /* Also consider the alignment of the cookie, if any. */
3293 if (array_p
&& TYPE_VEC_NEW_USES_COOKIE (elt_type
))
3294 align
= MAX (align
, TYPE_ALIGN_UNIT (size_type_node
));
3295 align_arg
= build_int_cst (align_type_node
, align
);
3298 alloc_fn
= NULL_TREE
;
3300 /* If PLACEMENT is a single simple pointer type not passed by
3301 reference, prepare to capture it in a temporary variable. Do
3302 this now, since PLACEMENT will change in the calls below. */
3303 placement_first
= NULL_TREE
;
3304 if (vec_safe_length (*placement
) == 1
3305 && (TYPE_PTR_P (TREE_TYPE ((**placement
)[0]))))
3306 placement_first
= (**placement
)[0];
3308 bool member_new_p
= false;
3310 /* Allocate the object. */
3314 fnname
= ovl_op_identifier (false, array_p
? VEC_NEW_EXPR
: NEW_EXPR
);
3316 member_new_p
= !globally_qualified_p
3317 && CLASS_TYPE_P (elt_type
)
3319 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type
)
3320 : TYPE_HAS_NEW_OPERATOR (elt_type
));
3322 bool member_delete_p
= (!globally_qualified_p
3323 && CLASS_TYPE_P (elt_type
)
3325 ? TYPE_GETS_VEC_DELETE (elt_type
)
3326 : TYPE_GETS_REG_DELETE (elt_type
)));
3330 /* Use a class-specific operator new. */
3331 /* If a cookie is required, add some extra space. */
3332 if (array_p
&& TYPE_VEC_NEW_USES_COOKIE (elt_type
))
3333 size
= size_binop (PLUS_EXPR
, size
, cookie_size
);
3336 cookie_size
= NULL_TREE
;
3337 /* No size arithmetic necessary, so the size check is
3339 if (outer_nelts_check
!= NULL
&& inner_size
== 1)
3340 outer_nelts_check
= NULL_TREE
;
3342 /* Perform the overflow check. */
3343 tree errval
= TYPE_MAX_VALUE (sizetype
);
3344 if (cxx_dialect
>= cxx11
&& flag_exceptions
)
3345 errval
= throw_bad_array_new_length ();
3346 if (outer_nelts_check
!= NULL_TREE
)
3347 size
= fold_build3 (COND_EXPR
, sizetype
, outer_nelts_check
,
3349 /* Create the argument list. */
3350 vec_safe_insert (*placement
, 0, size
);
3351 /* Do name-lookup to find the appropriate operator. */
3352 fns
= lookup_fnfields (elt_type
, fnname
, /*protect=*/2, complain
);
3353 if (fns
== NULL_TREE
)
3355 if (complain
& tf_error
)
3356 error ("no suitable %qD found in class %qT", fnname
, elt_type
);
3357 return error_mark_node
;
3359 if (TREE_CODE (fns
) == TREE_LIST
)
3361 if (complain
& tf_error
)
3363 error ("request for member %qD is ambiguous", fnname
);
3364 print_candidates (fns
);
3366 return error_mark_node
;
3368 tree dummy
= build_dummy_object (elt_type
);
3369 alloc_call
= NULL_TREE
;
3372 vec
<tree
, va_gc
> *align_args
3373 = vec_copy_and_insert (*placement
, align_arg
, 1);
3375 = build_new_method_call (dummy
, fns
, &align_args
,
3376 /*conversion_path=*/NULL_TREE
,
3377 LOOKUP_NORMAL
, &alloc_fn
, tf_none
);
3378 /* If no matching function is found and the allocated object type
3379 has new-extended alignment, the alignment argument is removed
3380 from the argument list, and overload resolution is performed
3382 if (alloc_call
== error_mark_node
)
3383 alloc_call
= NULL_TREE
;
3386 alloc_call
= build_new_method_call (dummy
, fns
, placement
,
3387 /*conversion_path=*/NULL_TREE
,
3389 &alloc_fn
, complain
);
3393 /* Use a global operator new. */
3394 /* See if a cookie might be required. */
3395 if (!(array_p
&& TYPE_VEC_NEW_USES_COOKIE (elt_type
)))
3397 cookie_size
= NULL_TREE
;
3398 /* No size arithmetic necessary, so the size check is
3400 if (outer_nelts_check
!= NULL
&& inner_size
== 1)
3401 outer_nelts_check
= NULL_TREE
;
3404 /* If size is zero e.g. due to type having zero size, try to
3405 preserve outer_nelts for constant expression evaluation
3407 if (integer_zerop (size
) && outer_nelts
)
3408 size
= build2 (MULT_EXPR
, TREE_TYPE (size
), size
, outer_nelts
);
3410 alloc_call
= build_operator_new_call (fnname
, placement
,
3411 &size
, &cookie_size
,
3412 align_arg
, outer_nelts_check
,
3413 &alloc_fn
, complain
);
3416 if (alloc_call
== error_mark_node
)
3417 return error_mark_node
;
3419 gcc_assert (alloc_fn
!= NULL_TREE
);
3421 /* Now, check to see if this function is actually a placement
3422 allocation function. This can happen even when PLACEMENT is NULL
3423 because we might have something like:
3425 struct S { void* operator new (size_t, int i = 0); };
3427 A call to `new S' will get this allocation function, even though
3428 there is no explicit placement argument. If there is more than
3429 one argument, or there are variable arguments, then this is a
3430 placement allocation function. */
3431 placement_allocation_fn_p
3432 = (type_num_arguments (TREE_TYPE (alloc_fn
)) > 1
3433 || varargs_function_p (alloc_fn
));
3435 if (complain
& tf_warning_or_error
3437 && !placement_allocation_fn_p
3438 && TYPE_ALIGN (elt_type
) > malloc_alignment ()
3439 && (warn_aligned_new
> 1
3440 || CP_DECL_CONTEXT (alloc_fn
) == global_namespace
)
3441 && !aligned_allocation_fn_p (alloc_fn
))
3443 auto_diagnostic_group d
;
3444 if (warning (OPT_Waligned_new_
, "%<new%> of type %qT with extended "
3445 "alignment %d", elt_type
, TYPE_ALIGN_UNIT (elt_type
)))
3447 inform (input_location
, "uses %qD, which does not have an alignment "
3448 "parameter", alloc_fn
);
3449 if (!aligned_new_threshold
)
3450 inform (input_location
, "use %<-faligned-new%> to enable C++17 "
3451 "over-aligned new support");
3455 /* If we found a simple case of PLACEMENT_EXPR above, then copy it
3456 into a temporary variable. */
3457 if (!processing_template_decl
3458 && TREE_CODE (alloc_call
) == CALL_EXPR
3459 && call_expr_nargs (alloc_call
) == 2
3460 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 0))) == INTEGER_TYPE
3461 && TYPE_PTR_P (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 1))))
3463 tree placement
= CALL_EXPR_ARG (alloc_call
, 1);
3465 if (placement_first
!= NULL_TREE
3466 && (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement
)))
3467 || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement
)))))
3469 placement_expr
= get_target_expr (placement_first
);
3470 CALL_EXPR_ARG (alloc_call
, 1)
3471 = fold_convert (TREE_TYPE (placement
), placement_expr
);
3475 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 1)))))
3477 /* Attempt to make the warning point at the operator new argument. */
3478 if (placement_first
)
3479 placement
= placement_first
;
3481 warn_placement_new_too_small (orig_type
, nelts
, size
, placement
);
3485 alloc_expr
= alloc_call
;
3487 alloc_expr
= maybe_wrap_new_for_constexpr (alloc_expr
, type
,
3490 /* In the simple case, we can stop now. */
3491 pointer_type
= build_pointer_type (type
);
3492 if (!cookie_size
&& !is_initialized
&& !member_delete_p
)
3493 return build_nop (pointer_type
, alloc_expr
);
3495 /* Store the result of the allocation call in a variable so that we can
3496 use it more than once. */
3497 alloc_expr
= get_target_expr (alloc_expr
);
3498 alloc_node
= TARGET_EXPR_SLOT (alloc_expr
);
3500 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
3501 while (TREE_CODE (alloc_call
) == COMPOUND_EXPR
)
3502 alloc_call
= TREE_OPERAND (alloc_call
, 1);
3504 /* Preevaluate the placement args so that we don't reevaluate them for a
3505 placement delete. */
3506 if (placement_allocation_fn_p
)
3509 stabilize_call (alloc_call
, &inits
);
3511 alloc_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (alloc_expr
), inits
,
3515 /* unless an allocation function is declared with an empty excep-
3516 tion-specification (_except.spec_), throw(), it indicates failure to
3517 allocate storage by throwing a bad_alloc exception (clause _except_,
3518 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
3519 cation function is declared with an empty exception-specification,
3520 throw(), it returns null to indicate failure to allocate storage and a
3521 non-null pointer otherwise.
3523 So check for a null exception spec on the op new we just called. */
3525 nothrow
= TYPE_NOTHROW_P (TREE_TYPE (alloc_fn
));
3527 = flag_check_new
|| (nothrow
&& !std_placement_new_fn_p (alloc_fn
));
3535 /* Adjust so we're pointing to the start of the object. */
3536 data_addr
= fold_build_pointer_plus (alloc_node
, cookie_size
);
3538 /* Store the number of bytes allocated so that we can know how
3539 many elements to destroy later. We use the last sizeof
3540 (size_t) bytes to store the number of elements. */
3541 cookie_ptr
= size_binop (MINUS_EXPR
, cookie_size
, size_in_bytes (sizetype
));
3542 cookie_ptr
= fold_build_pointer_plus_loc (input_location
,
3543 alloc_node
, cookie_ptr
);
3544 size_ptr_type
= build_pointer_type (sizetype
);
3545 cookie_ptr
= fold_convert (size_ptr_type
, cookie_ptr
);
3546 cookie
= cp_build_fold_indirect_ref (cookie_ptr
);
3548 cookie_expr
= build2 (MODIFY_EXPR
, sizetype
, cookie
, nelts
);
3550 if (targetm
.cxx
.cookie_has_size ())
3552 /* Also store the element size. */
3553 cookie_ptr
= fold_build_pointer_plus (cookie_ptr
,
3554 fold_build1_loc (input_location
,
3555 NEGATE_EXPR
, sizetype
,
3556 size_in_bytes (sizetype
)));
3558 cookie
= cp_build_fold_indirect_ref (cookie_ptr
);
3559 cookie
= build2 (MODIFY_EXPR
, sizetype
, cookie
,
3560 size_in_bytes (elt_type
));
3561 cookie_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (cookie_expr
),
3562 cookie
, cookie_expr
);
3567 cookie_expr
= NULL_TREE
;
3568 data_addr
= alloc_node
;
3571 /* Now use a pointer to the type we've actually allocated. */
3573 /* But we want to operate on a non-const version to start with,
3574 since we'll be modifying the elements. */
3575 non_const_pointer_type
= build_pointer_type
3576 (cp_build_qualified_type (type
, cp_type_quals (type
) & ~TYPE_QUAL_CONST
));
3578 data_addr
= fold_convert (non_const_pointer_type
, data_addr
);
3579 /* Any further uses of alloc_node will want this type, too. */
3580 alloc_node
= fold_convert (non_const_pointer_type
, alloc_node
);
3582 /* Now initialize the allocated object. Note that we preevaluate the
3583 initialization expression, apart from the actual constructor call or
3584 assignment--we do this because we want to delay the allocation as long
3585 as possible in order to minimize the size of the exception region for
3586 placement delete. */
3589 bool explicit_value_init_p
= false;
3591 if (*init
!= NULL
&& (*init
)->is_empty ())
3594 explicit_value_init_p
= true;
3597 if (processing_template_decl
)
3599 /* Avoid an ICE when converting to a base in build_simple_base_path.
3600 We'll throw this all away anyway, and build_new will create
3602 tree t
= fold_convert (build_pointer_type (elt_type
), data_addr
);
3603 /* build_value_init doesn't work in templates, and we don't need
3604 the initializer anyway since we're going to throw it away and
3605 rebuild it at instantiation time, so just build up a single
3606 constructor call to get any appropriate diagnostics. */
3607 init_expr
= cp_build_fold_indirect_ref (t
);
3608 if (type_build_ctor_call (elt_type
))
3609 init_expr
= build_special_member_call (init_expr
,
3610 complete_ctor_identifier
,
3617 tree vecinit
= NULL_TREE
;
3618 const size_t len
= vec_safe_length (*init
);
3619 if (len
== 1 && DIRECT_LIST_INIT_P ((**init
)[0]))
3621 vecinit
= (**init
)[0];
3622 if (CONSTRUCTOR_NELTS (vecinit
) == 0)
3623 /* List-value-initialization, leave it alone. */;
3626 tree arraytype
, domain
;
3627 if (TREE_CONSTANT (nelts
))
3628 domain
= compute_array_index_type (NULL_TREE
, nelts
,
3631 /* We'll check the length at runtime. */
3633 arraytype
= build_cplus_array_type (type
, domain
);
3634 /* If we have new char[4]{"foo"}, we have to reshape
3635 so that the STRING_CST isn't wrapped in { }. */
3636 vecinit
= reshape_init (arraytype
, vecinit
, complain
);
3637 /* The middle end doesn't cope with the location wrapper
3638 around a STRING_CST. */
3639 STRIP_ANY_LOCATION_WRAPPER (vecinit
);
3640 vecinit
= digest_init (arraytype
, vecinit
, complain
);
3645 if (complain
& tf_error
)
3646 error ("parenthesized initializer in array new");
3647 return error_mark_node
;
3650 = build_vec_init (data_addr
,
3651 cp_build_binary_op (input_location
,
3652 MINUS_EXPR
, outer_nelts
,
3656 explicit_value_init_p
,
3662 init_expr
= cp_build_fold_indirect_ref (data_addr
);
3664 if (type_build_ctor_call (type
) && !explicit_value_init_p
)
3666 init_expr
= build_special_member_call (init_expr
,
3667 complete_ctor_identifier
,
3670 complain
|tf_no_cleanup
);
3672 else if (explicit_value_init_p
)
3674 /* Something like `new int()'. NO_CLEANUP is needed so
3675 we don't try and build a (possibly ill-formed)
3677 tree val
= build_value_init (type
, complain
| tf_no_cleanup
);
3678 if (val
== error_mark_node
)
3679 return error_mark_node
;
3680 init_expr
= cp_build_init_expr (init_expr
, val
);
3686 /* We are processing something like `new int (10)', which
3687 means allocate an int, and initialize it with 10.
3689 In C++20, also handle `new A(1, 2)'. */
3690 if (cxx_dialect
>= cxx20
3691 && AGGREGATE_TYPE_P (type
)
3692 && (*init
)->length () > 1)
3694 ie
= build_constructor_from_vec (init_list_type_node
, *init
);
3695 CONSTRUCTOR_IS_DIRECT_INIT (ie
) = true;
3696 CONSTRUCTOR_IS_PAREN_INIT (ie
) = true;
3697 ie
= digest_init (type
, ie
, complain
);
3700 ie
= build_x_compound_expr_from_vec (*init
, "new initializer",
3702 init_expr
= cp_build_modify_expr (input_location
, init_expr
,
3703 INIT_EXPR
, ie
, complain
);
3705 /* If the initializer uses C++14 aggregate NSDMI that refer to the
3706 object being initialized, replace them now and don't try to
3708 bool had_placeholder
= false;
3709 if (!processing_template_decl
3710 && TREE_CODE (init_expr
) == INIT_EXPR
)
3711 TREE_OPERAND (init_expr
, 1)
3712 = replace_placeholders (TREE_OPERAND (init_expr
, 1),
3713 TREE_OPERAND (init_expr
, 0),
3717 if (init_expr
== error_mark_node
)
3718 return error_mark_node
;
3721 init_expr
= NULL_TREE
;
3723 /* If any part of the object initialization terminates by throwing an
3724 exception and a suitable deallocation function can be found, the
3725 deallocation function is called to free the memory in which the
3726 object was being constructed, after which the exception continues
3727 to propagate in the context of the new-expression. If no
3728 unambiguous matching deallocation function can be found,
3729 propagating the exception does not cause the object's memory to be
3731 if (flag_exceptions
&& (init_expr
|| member_delete_p
))
3733 enum tree_code dcode
= array_p
? VEC_DELETE_EXPR
: DELETE_EXPR
;
3736 /* The Standard is unclear here, but the right thing to do
3737 is to use the same method for finding deallocation
3738 functions that we use for finding allocation functions. */
3739 cleanup
= (build_op_delete_call
3743 globally_qualified_p
,
3744 placement_allocation_fn_p
? alloc_call
: NULL_TREE
,
3748 if (cleanup
&& init_expr
&& !processing_template_decl
)
3749 /* Ack! First we allocate the memory. Then we set our sentry
3750 variable to true, and expand a cleanup that deletes the
3751 memory if sentry is true. Then we run the constructor, and
3752 finally clear the sentry.
3754 We need to do this because we allocate the space first, so
3755 if there are any temporaries with cleanups in the
3756 constructor args, we need this EH region to extend until
3757 end of full-expression to preserve nesting.
3759 We used to try to evaluate the args first to avoid this, but
3760 since C++17 [expr.new] says that "The invocation of the
3761 allocation function is sequenced before the evaluations of
3762 expressions in the new-initializer." */
3764 tree end
, sentry
, begin
;
3766 begin
= get_target_expr (boolean_true_node
);
3767 CLEANUP_EH_ONLY (begin
) = 1;
3769 sentry
= TARGET_EXPR_SLOT (begin
);
3771 /* CLEANUP is compiler-generated, so no diagnostics. */
3772 suppress_warning (cleanup
);
3774 TARGET_EXPR_CLEANUP (begin
)
3775 = build3 (COND_EXPR
, void_type_node
, sentry
,
3776 cleanup
, void_node
);
3778 end
= build2 (MODIFY_EXPR
, TREE_TYPE (sentry
),
3779 sentry
, boolean_false_node
);
3782 = build2 (COMPOUND_EXPR
, void_type_node
, begin
,
3783 build2 (COMPOUND_EXPR
, void_type_node
, init_expr
,
3785 /* Likewise, this is compiler-generated. */
3786 suppress_warning (init_expr
);
3790 /* Now build up the return value in reverse order. */
3795 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), init_expr
, rval
);
3797 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), cookie_expr
, rval
);
3799 if (rval
== data_addr
&& TREE_CODE (alloc_expr
) == TARGET_EXPR
)
3800 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
3801 and return the call (which doesn't need to be adjusted). */
3802 rval
= TARGET_EXPR_INITIAL (alloc_expr
);
3807 tree ifexp
= cp_build_binary_op (input_location
,
3808 NE_EXPR
, alloc_node
,
3811 rval
= build_conditional_expr (input_location
, ifexp
, rval
,
3812 alloc_node
, complain
);
3815 /* Perform the allocation before anything else, so that ALLOC_NODE
3816 has been initialized before we start using it. */
3817 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
3820 /* A new-expression is never an lvalue. */
3821 gcc_assert (!obvalue_p (rval
));
3823 return convert (pointer_type
, rval
);
3826 /* Generate a representation for a C++ "new" expression. *PLACEMENT
3827 is a vector of placement-new arguments (or NULL if none). If NELTS
3828 is NULL, TYPE is the type of the storage to be allocated. If NELTS
3829 is not NULL, then this is an array-new allocation; TYPE is the type
3830 of the elements in the array and NELTS is the number of elements in
3831 the array. *INIT, if non-NULL, is the initializer for the new
3832 object, or an empty vector to indicate an initializer of "()". If
3833 USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
3834 rather than just "new". This may change PLACEMENT and INIT. */
3837 build_new (location_t loc
, vec
<tree
, va_gc
> **placement
, tree type
,
3838 tree nelts
, vec
<tree
, va_gc
> **init
, int use_global_new
,
3839 tsubst_flags_t complain
)
3842 vec
<tree
, va_gc
> *orig_placement
= NULL
;
3843 tree orig_nelts
= NULL_TREE
;
3844 vec
<tree
, va_gc
> *orig_init
= NULL
;
3846 if (type
== error_mark_node
)
3847 return error_mark_node
;
3849 if (nelts
== NULL_TREE
3850 /* Don't do auto deduction where it might affect mangling. */
3851 && (!processing_template_decl
|| at_function_scope_p ()))
3853 tree auto_node
= type_uses_auto (type
);
3856 tree d_init
= NULL_TREE
;
3857 const size_t len
= vec_safe_length (*init
);
3858 /* E.g. new auto(x) must have exactly one element, or
3859 a {} initializer will have one element. */
3862 d_init
= (**init
)[0];
3863 d_init
= resolve_nondeduced_context (d_init
, complain
);
3865 /* For the rest, e.g. new A(1, 2, 3), create a list. */
3871 FOR_EACH_VEC_ELT (**init
, n
, t
)
3873 t
= resolve_nondeduced_context (t
, complain
);
3874 *pp
= build_tree_list (NULL_TREE
, t
);
3875 pp
= &TREE_CHAIN (*pp
);
3878 type
= do_auto_deduction (type
, d_init
, auto_node
, complain
);
3882 if (processing_template_decl
)
3884 if (dependent_type_p (type
)
3885 || any_type_dependent_arguments_p (*placement
)
3886 || (nelts
&& type_dependent_expression_p (nelts
))
3888 || any_type_dependent_arguments_p (*init
))
3889 return build_raw_new_expr (loc
, *placement
, type
, nelts
, *init
,
3892 orig_placement
= make_tree_vector_copy (*placement
);
3896 orig_init
= make_tree_vector_copy (*init
);
3897 /* Also copy any CONSTRUCTORs in *init, since reshape_init and
3898 digest_init clobber them in place. */
3899 for (unsigned i
= 0; i
< orig_init
->length(); ++i
)
3901 tree e
= (**init
)[i
];
3902 if (TREE_CODE (e
) == CONSTRUCTOR
)
3903 (**init
)[i
] = copy_node (e
);
3907 make_args_non_dependent (*placement
);
3909 nelts
= build_non_dependent_expr (nelts
);
3910 make_args_non_dependent (*init
);
3915 location_t nelts_loc
= cp_expr_loc_or_loc (nelts
, loc
);
3916 if (!build_expr_type_conversion (WANT_INT
| WANT_ENUM
, nelts
, false))
3918 if (complain
& tf_error
)
3919 permerror (nelts_loc
,
3920 "size in array new must have integral type");
3922 return error_mark_node
;
3925 /* Try to determine the constant value only for the purposes
3926 of the diagnostic below but continue to use the original
3927 value and handle const folding later. */
3928 const_tree cst_nelts
= fold_non_dependent_expr (nelts
, complain
);
3930 /* The expression in a noptr-new-declarator is erroneous if it's of
3931 non-class type and its value before converting to std::size_t is
3932 less than zero. ... If the expression is a constant expression,
3933 the program is ill-fomed. */
3934 if (TREE_CODE (cst_nelts
) == INTEGER_CST
3935 && !valid_array_size_p (nelts_loc
, cst_nelts
, NULL_TREE
,
3936 complain
& tf_error
))
3937 return error_mark_node
;
3939 nelts
= mark_rvalue_use (nelts
);
3940 nelts
= cp_save_expr (cp_convert (sizetype
, nelts
, complain
));
3943 /* ``A reference cannot be created by the new operator. A reference
3944 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
3945 returned by new.'' ARM 5.3.3 */
3946 if (TYPE_REF_P (type
))
3948 if (complain
& tf_error
)
3949 error_at (loc
, "new cannot be applied to a reference type");
3951 return error_mark_node
;
3952 type
= TREE_TYPE (type
);
3955 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3957 if (complain
& tf_error
)
3958 error_at (loc
, "new cannot be applied to a function type");
3959 return error_mark_node
;
3962 /* P1009: Array size deduction in new-expressions. */
3963 const bool array_p
= TREE_CODE (type
) == ARRAY_TYPE
;
3965 /* If ARRAY_P, we have to deduce the array bound. For C++20 paren-init,
3966 we have to process the parenthesized-list. But don't do it for (),
3967 which is value-initialization, and INIT should stay empty. */
3968 && (array_p
|| (cxx_dialect
>= cxx20
&& nelts
&& !(*init
)->is_empty ())))
3970 /* This means we have 'new T[]()'. */
3971 if ((*init
)->is_empty ())
3973 tree ctor
= build_constructor (init_list_type_node
, NULL
);
3974 CONSTRUCTOR_IS_DIRECT_INIT (ctor
) = true;
3975 vec_safe_push (*init
, ctor
);
3977 tree
&elt
= (**init
)[0];
3978 /* The C++20 'new T[](e_0, ..., e_k)' case allowed by P0960. */
3979 if (!DIRECT_LIST_INIT_P (elt
) && cxx_dialect
>= cxx20
)
3981 tree ctor
= build_constructor_from_vec (init_list_type_node
, *init
);
3982 CONSTRUCTOR_IS_DIRECT_INIT (ctor
) = true;
3983 CONSTRUCTOR_IS_PAREN_INIT (ctor
) = true;
3985 /* We've squashed all the vector elements into the first one;
3986 truncate the rest. */
3987 (*init
)->truncate (1);
3989 /* Otherwise we should have 'new T[]{e_0, ..., e_k}'. */
3990 if (array_p
&& !TYPE_DOMAIN (type
))
3992 /* We need to reshape before deducing the bounds to handle code like
3994 struct S { int x, y; };
3995 new S[]{1, 2, 3, 4};
3997 which should deduce S[2]. But don't change ELT itself: we want to
3998 pass a list-initializer to build_new_1, even for STRING_CSTs. */
4000 if (BRACE_ENCLOSED_INITIALIZER_P (e
))
4001 e
= reshape_init (type
, e
, complain
);
4002 cp_complete_array_type (&type
, e
, /*do_default*/false);
4006 /* The type allocated must be complete. If the new-type-id was
4007 "T[N]" then we are just checking that "T" is complete here, but
4008 that is equivalent, since the value of "N" doesn't matter. */
4009 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
4010 return error_mark_node
;
4012 rval
= build_new_1 (placement
, type
, nelts
, init
, use_global_new
, complain
);
4013 if (rval
== error_mark_node
)
4014 return error_mark_node
;
4016 if (processing_template_decl
)
4018 tree ret
= build_raw_new_expr (loc
, orig_placement
, type
, orig_nelts
,
4019 orig_init
, use_global_new
);
4020 release_tree_vector (orig_placement
);
4021 release_tree_vector (orig_init
);
4025 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
4026 rval
= build1_loc (loc
, NOP_EXPR
, TREE_TYPE (rval
), rval
);
4027 suppress_warning (rval
, OPT_Wunused_value
);
4033 build_vec_delete_1 (location_t loc
, tree base
, tree maxindex
, tree type
,
4034 special_function_kind auto_delete_vec
,
4035 int use_global_delete
, tsubst_flags_t complain
,
4036 bool in_cleanup
= false)
4039 tree ptype
= build_pointer_type (type
= complete_type (type
));
4042 /* Temporary variables used by the loop. */
4043 tree tbase
, tbase_init
;
4045 /* This is the body of the loop that implements the deletion of a
4046 single element, and moves temp variables to next elements. */
4049 /* This is the LOOP_EXPR that governs the deletion of the elements. */
4052 /* This is the thing that governs what to do after the loop has run. */
4053 tree deallocate_expr
= 0;
4055 /* This is the BIND_EXPR which holds the outermost iterator of the
4056 loop. It is convenient to set this variable up and test it before
4057 executing any other code in the loop.
4058 This is also the containing expression returned by this function. */
4059 tree controller
= NULL_TREE
;
4062 /* We should only have 1-D arrays here. */
4063 gcc_assert (TREE_CODE (type
) != ARRAY_TYPE
);
4065 if (base
== error_mark_node
|| maxindex
== error_mark_node
)
4066 return error_mark_node
;
4068 if (!verify_type_context (loc
, TCTX_DEALLOCATION
, type
,
4069 !(complain
& tf_error
)))
4070 return error_mark_node
;
4072 if (!COMPLETE_TYPE_P (type
))
4074 if (complain
& tf_warning
)
4076 auto_diagnostic_group d
;
4077 if (warning_at (loc
, OPT_Wdelete_incomplete
,
4078 "possible problem detected in invocation of "
4079 "operator %<delete []%>"))
4081 cxx_incomplete_type_diagnostic (base
, type
, DK_WARNING
);
4082 inform (loc
, "neither the destructor nor the "
4083 "class-specific operator %<delete []%> will be called, "
4084 "even if they are declared when the class is defined");
4087 /* This size won't actually be used. */
4088 size_exp
= size_one_node
;
4092 size_exp
= size_in_bytes (type
);
4094 if (! MAYBE_CLASS_TYPE_P (type
))
4096 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
4098 /* Make sure the destructor is callable. */
4099 if (type_build_dtor_call (type
))
4101 tmp
= build_delete (loc
, ptype
, base
, sfk_complete_destructor
,
4102 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1,
4104 if (tmp
== error_mark_node
)
4105 return error_mark_node
;
4110 /* The below is short by the cookie size. */
4111 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
4112 fold_convert (sizetype
, maxindex
));
4114 tbase
= create_temporary_var (ptype
);
4115 DECL_INITIAL (tbase
)
4116 = fold_build_pointer_plus_loc (loc
, fold_convert (ptype
, base
),
4118 tbase_init
= build_stmt (loc
, DECL_EXPR
, tbase
);
4119 controller
= build3 (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
4120 TREE_SIDE_EFFECTS (controller
) = 1;
4121 BIND_EXPR_VEC_DTOR (controller
) = true;
4123 body
= build1 (EXIT_EXPR
, void_type_node
,
4124 build2 (EQ_EXPR
, boolean_type_node
, tbase
,
4125 fold_convert (ptype
, base
)));
4126 tmp
= fold_build1_loc (loc
, NEGATE_EXPR
, sizetype
, size_exp
);
4127 tmp
= fold_build_pointer_plus (tbase
, tmp
);
4128 tmp
= cp_build_modify_expr (loc
, tbase
, NOP_EXPR
, tmp
, complain
);
4129 if (tmp
== error_mark_node
)
4130 return error_mark_node
;
4131 body
= build_compound_expr (loc
, body
, tmp
);
4132 tmp
= build_delete (loc
, ptype
, tbase
, sfk_complete_destructor
,
4133 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1,
4135 if (tmp
== error_mark_node
)
4136 return error_mark_node
;
4137 body
= build_compound_expr (loc
, body
, tmp
);
4139 loop
= build1 (LOOP_EXPR
, void_type_node
, body
);
4141 /* If one destructor throws, keep trying to clean up the rest, unless we're
4142 already in a build_vec_init cleanup. */
4143 if (flag_exceptions
&& !in_cleanup
&& !expr_noexcept_p (tmp
, tf_none
))
4145 loop
= build2 (TRY_CATCH_EXPR
, void_type_node
, loop
,
4146 unshare_expr (loop
));
4147 /* Tell honor_protect_cleanup_actions to discard this on the
4148 exceptional path. */
4149 TRY_CATCH_IS_CLEANUP (loop
) = true;
4152 loop
= build_compound_expr (loc
, tbase_init
, loop
);
4155 /* Delete the storage if appropriate. */
4156 if (auto_delete_vec
== sfk_deleting_destructor
)
4160 /* The below is short by the cookie size. */
4161 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
4162 fold_convert (sizetype
, maxindex
));
4164 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
4171 cookie_size
= targetm
.cxx
.get_cookie_size (type
);
4172 base_tbd
= cp_build_binary_op (loc
,
4174 cp_convert (string_type_node
,
4178 if (base_tbd
== error_mark_node
)
4179 return error_mark_node
;
4180 base_tbd
= cp_convert (ptype
, base_tbd
, complain
);
4181 /* True size with header. */
4182 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, cookie_size
);
4185 deallocate_expr
= build_op_delete_call (VEC_DELETE_EXPR
,
4186 base_tbd
, virtual_size
,
4187 use_global_delete
& 1,
4188 /*placement=*/NULL_TREE
,
4189 /*alloc_fn=*/NULL_TREE
,
4194 if (deallocate_expr
== error_mark_node
)
4195 return error_mark_node
;
4196 else if (!deallocate_expr
)
4199 body
= deallocate_expr
;
4201 /* The delete operator must be called, even if a destructor
4203 body
= build2 (TRY_FINALLY_EXPR
, void_type_node
, body
, deallocate_expr
);
4206 body
= integer_zero_node
;
4208 /* Outermost wrapper: If pointer is null, punt. */
4209 tree cond
= build2_loc (loc
, NE_EXPR
, boolean_type_node
, base
,
4210 fold_convert (TREE_TYPE (base
), nullptr_node
));
4211 /* This is a compiler generated comparison, don't emit
4212 e.g. -Wnonnull-compare warning for it. */
4213 suppress_warning (cond
, OPT_Wnonnull_compare
);
4214 body
= build3_loc (loc
, COND_EXPR
, void_type_node
,
4215 cond
, body
, integer_zero_node
);
4216 COND_EXPR_IS_VEC_DELETE (body
) = true;
4217 body
= build1 (NOP_EXPR
, void_type_node
, body
);
4221 TREE_OPERAND (controller
, 1) = body
;
4225 if (TREE_CODE (base
) == SAVE_EXPR
)
4226 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
4227 body
= build2 (COMPOUND_EXPR
, void_type_node
, base
, body
);
4229 return convert_to_void (body
, ICV_CAST
, complain
);
4232 /* Create an unnamed variable of the indicated TYPE. */
4235 create_temporary_var (tree type
)
4239 decl
= build_decl (input_location
,
4240 VAR_DECL
, NULL_TREE
, type
);
4241 TREE_USED (decl
) = 1;
4242 DECL_ARTIFICIAL (decl
) = 1;
4243 DECL_IGNORED_P (decl
) = 1;
4244 DECL_CONTEXT (decl
) = current_function_decl
;
4249 /* Create a new temporary variable of the indicated TYPE, initialized
4252 It is not entered into current_binding_level, because that breaks
4253 things when it comes time to do final cleanups (which take place
4254 "outside" the binding contour of the function). */
4257 get_temp_regvar (tree type
, tree init
)
4261 decl
= create_temporary_var (type
);
4262 add_decl_expr (decl
);
4264 finish_expr_stmt (cp_build_modify_expr (input_location
, decl
, INIT_EXPR
,
4265 init
, tf_warning_or_error
));
4270 /* Subroutine of build_vec_init. Returns true if assigning to an array of
4271 INNER_ELT_TYPE from INIT is trivial. */
4274 vec_copy_assign_is_trivial (tree inner_elt_type
, tree init
)
4276 tree fromtype
= inner_elt_type
;
4277 if (lvalue_p (init
))
4278 fromtype
= cp_build_reference_type (fromtype
, /*rval*/false);
4279 return is_trivially_xible (MODIFY_EXPR
, inner_elt_type
, fromtype
);
4282 /* Subroutine of build_vec_init: Check that the array has at least N
4283 elements. Other parameters are local variables in build_vec_init. */
4286 finish_length_check (tree atype
, tree iterator
, tree obase
, unsigned n
)
4288 tree nelts
= build_int_cst (ptrdiff_type_node
, n
- 1);
4289 if (TREE_CODE (atype
) != ARRAY_TYPE
)
4291 if (flag_exceptions
)
4293 tree c
= fold_build2 (LT_EXPR
, boolean_type_node
, iterator
,
4295 c
= build3 (COND_EXPR
, void_type_node
, c
,
4296 throw_bad_array_new_length (), void_node
);
4297 finish_expr_stmt (c
);
4299 /* Don't check an array new when -fno-exceptions. */
4301 else if (sanitize_flags_p (SANITIZE_BOUNDS
)
4302 && current_function_decl
!= NULL_TREE
)
4304 /* Make sure the last element of the initializer is in bounds. */
4306 (ubsan_instrument_bounds
4307 (input_location
, obase
, &nelts
, /*ignore_off_by_one*/false));
4311 /* walk_tree callback to collect temporaries in an expression. */
4314 find_temps_r (tree
*tp
, int *walk_subtrees
, void *data
)
4316 vec
<tree
*> &temps
= *static_cast<auto_vec
<tree
*> *>(data
);
4318 if (TREE_CODE (t
) == TARGET_EXPR
4319 && !TARGET_EXPR_ELIDING_P (t
))
4320 temps
.safe_push (tp
);
4321 else if (TYPE_P (t
))
4327 /* If INIT initializes a standard library class, and involves a temporary
4328 std::allocator<T>, return a pointer to the temp.
4330 Used by build_vec_init when initializing an array of e.g. strings to reuse
4331 the same temporary allocator for all of the strings. We can do this because
4332 std::allocator has no data and the standard library doesn't care about the
4333 address of allocator objects.
4335 ??? Add an attribute to allow users to assert the same property for other
4336 classes, i.e. one object of the type is interchangeable with any other? */
4339 find_allocator_temp (tree init
)
4341 if (TREE_CODE (init
) == EXPR_STMT
)
4342 init
= EXPR_STMT_EXPR (init
);
4343 if (TREE_CODE (init
) == CONVERT_EXPR
)
4344 init
= TREE_OPERAND (init
, 0);
4345 tree type
= TREE_TYPE (init
);
4346 if (!CLASS_TYPE_P (type
) || !decl_in_std_namespace_p (TYPE_NAME (type
)))
4348 auto_vec
<tree
*> temps
;
4349 cp_walk_tree_without_duplicates (&init
, find_temps_r
, &temps
);
4350 for (tree
*p
: temps
)
4351 if (is_std_allocator (TREE_TYPE (*p
)))
4356 /* `build_vec_init' returns tree structure that performs
4357 initialization of a vector of aggregate types.
4359 BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
4360 to the first element, of POINTER_TYPE.
4361 MAXINDEX is the maximum index of the array (one less than the
4362 number of elements). It is only used if BASE is a pointer or
4363 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
4365 INIT is the (possibly NULL) initializer.
4367 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All
4368 elements in the array are value-initialized.
4370 FROM_ARRAY is 0 if we should init everything with INIT
4371 (i.e., every element initialized from INIT).
4372 FROM_ARRAY is 1 if we should index into INIT in parallel
4373 with initialization of DECL.
4374 FROM_ARRAY is 2 if we should index into INIT in parallel,
4375 but use assignment instead of initialization. */
4378 build_vec_init (tree base
, tree maxindex
, tree init
,
4379 bool explicit_value_init_p
,
4381 tsubst_flags_t complain
,
4382 vec
<tree
, va_gc
>** flags
/* = nullptr */)
4385 tree base2
= NULL_TREE
;
4386 tree itype
= NULL_TREE
;
4388 /* The type of BASE. */
4389 tree atype
= TREE_TYPE (base
);
4390 /* The type of an element in the array. */
4391 tree type
= TREE_TYPE (atype
);
4392 /* The element type reached after removing all outer array
4394 tree inner_elt_type
;
4395 /* The type of a pointer to an element in the array. */
4400 HOST_WIDE_INT num_initialized_elts
= 0;
4403 bool xvalue
= false;
4404 bool errors
= false;
4405 location_t loc
= (init
? cp_expr_loc_or_input_loc (init
)
4406 : location_of (base
));
4408 if (TREE_CODE (atype
) == ARRAY_TYPE
&& TYPE_DOMAIN (atype
))
4409 maxindex
= array_type_nelts (atype
);
4411 if (maxindex
== NULL_TREE
|| maxindex
== error_mark_node
)
4412 return error_mark_node
;
4414 maxindex
= maybe_constant_value (maxindex
);
4415 if (explicit_value_init_p
)
4418 inner_elt_type
= strip_array_types (type
);
4420 /* Look through the TARGET_EXPR around a compound literal. */
4421 if (init
&& TREE_CODE (init
) == TARGET_EXPR
4422 && TREE_CODE (TARGET_EXPR_INITIAL (init
)) == CONSTRUCTOR
4424 && (same_type_ignoring_top_level_qualifiers_p
4425 (TREE_TYPE (init
), atype
)))
4426 init
= TARGET_EXPR_INITIAL (init
);
4428 if (tree vi
= get_vec_init_expr (init
))
4429 init
= VEC_INIT_EXPR_INIT (vi
);
4431 bool direct_init
= false;
4432 if (from_array
&& init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
4433 && CONSTRUCTOR_NELTS (init
) == 1)
4435 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
4436 if (TREE_CODE (TREE_TYPE (elt
)) == ARRAY_TYPE
4437 && TREE_CODE (elt
) != VEC_INIT_EXPR
)
4439 direct_init
= DIRECT_LIST_INIT_P (init
);
4444 /* from_array doesn't apply to initialization from CONSTRUCTOR. */
4445 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
)
4448 /* If we have a braced-init-list or string constant, make sure that the array
4449 is big enough for all the initializers. */
4450 bool length_check
= (init
4451 && (TREE_CODE (init
) == STRING_CST
4452 || (TREE_CODE (init
) == CONSTRUCTOR
4453 && CONSTRUCTOR_NELTS (init
) > 0))
4454 && !TREE_CONSTANT (maxindex
));
4457 && TREE_CODE (atype
) == ARRAY_TYPE
4458 && TREE_CONSTANT (maxindex
)
4459 && !vla_type_p (type
)
4461 ? vec_copy_assign_is_trivial (inner_elt_type
, init
)
4462 : !TYPE_NEEDS_CONSTRUCTING (type
))
4463 && ((TREE_CODE (init
) == CONSTRUCTOR
4464 && (BRACE_ENCLOSED_INITIALIZER_P (init
)
4465 || (same_type_ignoring_top_level_qualifiers_p
4466 (atype
, TREE_TYPE (init
))))
4467 /* Don't do this if the CONSTRUCTOR might contain something
4468 that might throw and require us to clean up. */
4469 && (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
))
4470 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type
)))
4473 /* Do non-default initialization of trivial arrays resulting from
4474 brace-enclosed initializers. In this case, digest_init and
4475 store_constructor will handle the semantics for us. */
4477 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
4478 init
= digest_init (atype
, init
, complain
);
4479 stmt_expr
= cp_build_init_expr (base
, init
);
4483 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
, complain
);
4484 maxindex
= fold_simple (maxindex
);
4486 if (TREE_CODE (atype
) == ARRAY_TYPE
)
4488 ptype
= build_pointer_type (type
);
4489 base
= decay_conversion (base
, complain
);
4490 if (base
== error_mark_node
)
4491 return error_mark_node
;
4492 base
= cp_convert (ptype
, base
, complain
);
4497 if (integer_all_onesp (maxindex
))
4499 /* Shortcut zero element case to avoid unneeded constructor synthesis. */
4500 if (init
&& TREE_SIDE_EFFECTS (init
))
4501 base
= build2 (COMPOUND_EXPR
, ptype
, init
, base
);
4505 /* The code we are generating looks like:
4509 ptrdiff_t iterator = maxindex;
4511 for (; iterator != -1; --iterator) {
4512 ... initialize *t1 ...
4516 ... destroy elements that were constructed ...
4521 We can omit the try and catch blocks if we know that the
4522 initialization will never throw an exception, or if the array
4523 elements do not have destructors. We can omit the loop completely if
4524 the elements of the array do not have constructors.
4526 We actually wrap the entire body of the above in a STMT_EXPR, for
4529 When copying from array to another, when the array elements have
4530 only trivial copy constructors, we should use __builtin_memcpy
4531 rather than generating a loop. That way, we could take advantage
4532 of whatever cleverness the back end has for dealing with copies
4533 of blocks of memory. */
4535 is_global
= begin_init_stmts (&stmt_expr
, &compound_stmt
);
4536 destroy_temps
= stmts_are_full_exprs_p ();
4537 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
4538 rval
= get_temp_regvar (ptype
, base
);
4539 base
= get_temp_regvar (ptype
, rval
);
4540 tree iterator_targ
= get_target_expr (maxindex
);
4541 add_stmt (iterator_targ
);
4542 iterator
= TARGET_EXPR_SLOT (iterator_targ
);
4544 /* If initializing one array from another, initialize element by
4545 element. We rely upon the below calls to do the argument
4546 checking. Evaluate the initializer before entering the try block. */
4549 if (lvalue_kind (init
) & clk_rvalueref
)
4551 if (TREE_CODE (init
) == TARGET_EXPR
)
4553 /* Avoid error in decay_conversion. */
4554 base2
= decay_conversion (TARGET_EXPR_SLOT (init
), complain
);
4555 base2
= cp_build_compound_expr (init
, base2
, tf_none
);
4558 base2
= decay_conversion (init
, complain
);
4559 if (base2
== error_mark_node
)
4560 return error_mark_node
;
4561 itype
= TREE_TYPE (base2
);
4562 base2
= get_temp_regvar (itype
, base2
);
4563 itype
= TREE_TYPE (itype
);
4566 /* Protect the entire array initialization so that we can destroy
4567 the partially constructed array if an exception is thrown.
4568 But don't do this if we're assigning. */
4569 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
4573 tree m
= cp_build_binary_op (input_location
,
4574 MINUS_EXPR
, maxindex
, iterator
,
4577 /* Flatten multi-dimensional array since build_vec_delete only
4578 expects one-dimensional array. */
4579 if (TREE_CODE (type
) == ARRAY_TYPE
)
4580 m
= cp_build_binary_op (input_location
,
4582 /* Avoid mixing signed and unsigned. */
4583 convert (TREE_TYPE (m
),
4584 array_type_nelts_total (type
)),
4587 e
= build_vec_delete_1 (input_location
, rval
, m
,
4588 inner_elt_type
, sfk_complete_destructor
,
4589 /*use_global_delete=*/0, complain
,
4590 /*in_cleanup*/true);
4591 if (e
== error_mark_node
)
4593 TARGET_EXPR_CLEANUP (iterator_targ
) = e
;
4594 CLEANUP_EH_ONLY (iterator_targ
) = true;
4596 /* Since we push this cleanup before doing any initialization, cleanups
4597 for any temporaries in the initialization are naturally within our
4598 cleanup region, so we don't want wrap_temporary_cleanups to do
4599 anything for arrays. But if the array is a subobject, we need to
4600 tell split_nonconstant_init how to turn off this cleanup in favor of
4601 the cleanup for the complete object. */
4603 vec_safe_push (*flags
, build_tree_list (iterator
, maxindex
));
4606 /* Should we try to create a constant initializer? */
4607 bool try_const
= (TREE_CODE (atype
) == ARRAY_TYPE
4608 && TREE_CONSTANT (maxindex
)
4609 && (init
? TREE_CODE (init
) == CONSTRUCTOR
4610 : (type_has_constexpr_default_constructor
4612 && (literal_type_p (inner_elt_type
)
4613 || TYPE_HAS_CONSTEXPR_CTOR (inner_elt_type
)));
4614 vec
<constructor_elt
, va_gc
> *const_vec
= NULL
;
4615 bool saw_non_const
= false;
4616 /* If we're initializing a static array, we want to do static
4617 initialization of any elements with constant initializers even if
4618 some are non-constant. */
4619 bool do_static_init
= (DECL_P (obase
) && TREE_STATIC (obase
));
4621 bool empty_list
= false;
4622 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
4623 && CONSTRUCTOR_NELTS (init
) == 0)
4624 /* Skip over the handling of non-empty init lists. */
4627 /* Maybe pull out constant value when from_array? */
4629 else if (init
!= NULL_TREE
&& TREE_CODE (init
) == CONSTRUCTOR
)
4631 /* Do non-default initialization of non-trivial arrays resulting from
4632 brace-enclosed initializers. */
4633 unsigned HOST_WIDE_INT idx
;
4635 /* If the constructor already has the array type, it's been through
4636 digest_init, so we shouldn't try to do anything more. */
4637 bool digested
= same_type_p (atype
, TREE_TYPE (init
));
4641 finish_length_check (atype
, iterator
, obase
, CONSTRUCTOR_NELTS (init
));
4644 vec_alloc (const_vec
, CONSTRUCTOR_NELTS (init
));
4646 tree alloc_obj
= NULL_TREE
;
4648 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
, field
, elt
)
4650 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
4653 num_initialized_elts
++;
4655 /* We need to see sub-array TARGET_EXPR before cp_fold_r so we can
4656 handle cleanup flags properly. */
4657 gcc_checking_assert (!target_expr_needs_replace (elt
));
4660 one_init
= cp_build_init_expr (baseref
, elt
);
4661 else if (tree vi
= get_vec_init_expr (elt
))
4662 one_init
= expand_vec_init_expr (baseref
, vi
, complain
, flags
);
4663 else if (MAYBE_CLASS_TYPE_P (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
4664 one_init
= build_aggr_init (baseref
, elt
, 0, complain
);
4666 one_init
= cp_build_modify_expr (input_location
, baseref
,
4667 NOP_EXPR
, elt
, complain
);
4668 if (one_init
== error_mark_node
)
4673 field
= size_int (idx
);
4674 tree e
= maybe_constant_init (one_init
);
4675 if (reduced_constant_expression_p (e
))
4677 CONSTRUCTOR_APPEND_ELT (const_vec
, field
, e
);
4679 one_init
= NULL_TREE
;
4681 one_init
= cp_build_init_expr (baseref
, e
);
4687 tree value
= build_zero_init (TREE_TYPE (e
), NULL_TREE
,
4690 CONSTRUCTOR_APPEND_ELT (const_vec
, field
, value
);
4692 saw_non_const
= true;
4698 /* Only create one std::allocator temporary. */
4699 if (tree
*this_alloc
= find_allocator_temp (one_init
))
4702 *this_alloc
= alloc_obj
;
4704 alloc_obj
= TARGET_EXPR_SLOT (*this_alloc
);
4706 finish_expr_stmt (one_init
);
4709 one_init
= cp_build_unary_op (PREINCREMENT_EXPR
, base
, false,
4711 if (one_init
== error_mark_node
)
4714 finish_expr_stmt (one_init
);
4716 one_init
= cp_build_unary_op (PREDECREMENT_EXPR
, iterator
, false,
4718 if (one_init
== error_mark_node
)
4721 finish_expr_stmt (one_init
);
4724 /* Any elements without explicit initializers get T{}. */
4727 else if (init
&& TREE_CODE (init
) == STRING_CST
)
4729 /* Check that the array is at least as long as the string. */
4731 finish_length_check (atype
, iterator
, obase
,
4732 TREE_STRING_LENGTH (init
));
4733 tree length
= build_int_cst (ptrdiff_type_node
,
4734 TREE_STRING_LENGTH (init
));
4736 /* Copy the string to the first part of the array. */
4737 tree alias_set
= build_int_cst (build_pointer_type (type
), 0);
4738 tree lhs
= build2 (MEM_REF
, TREE_TYPE (init
), base
, alias_set
);
4739 tree stmt
= build2 (MODIFY_EXPR
, void_type_node
, lhs
, init
);
4740 finish_expr_stmt (stmt
);
4742 /* Adjust the counter and pointer. */
4743 stmt
= cp_build_binary_op (loc
, MINUS_EXPR
, iterator
, length
, complain
);
4744 stmt
= build2 (MODIFY_EXPR
, void_type_node
, iterator
, stmt
);
4745 finish_expr_stmt (stmt
);
4747 stmt
= cp_build_binary_op (loc
, PLUS_EXPR
, base
, length
, complain
);
4748 stmt
= build2 (MODIFY_EXPR
, void_type_node
, base
, stmt
);
4749 finish_expr_stmt (stmt
);
4751 /* And set the rest of the array to NUL. */
4753 explicit_value_init_p
= true;
4755 else if (from_array
)
4758 /* OK, we set base2 above. */;
4759 else if (CLASS_TYPE_P (type
)
4760 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
4762 if (complain
& tf_error
)
4763 error ("initializer ends prematurely");
4768 /* Now, default-initialize any remaining elements. We don't need to
4769 do that if a) the type does not need constructing, or b) we've
4770 already initialized all the elements.
4772 We do need to keep going if we're copying an array. */
4774 if (try_const
&& !init
4775 && (cxx_dialect
< cxx20
4776 || !default_init_uninitialized_part (inner_elt_type
)))
4777 /* With a constexpr default constructor, which we checked for when
4778 setting try_const above, default-initialization is equivalent to
4779 value-initialization, and build_value_init gives us something more
4780 friendly to maybe_constant_init. Except in C++20 and up a constexpr
4781 constructor need not initialize all the members. */
4782 explicit_value_init_p
= true;
4784 || ((type_build_ctor_call (type
) || init
|| explicit_value_init_p
)
4785 && ! (tree_fits_shwi_p (maxindex
)
4786 && (num_initialized_elts
4787 == tree_to_shwi (maxindex
) + 1))))
4789 /* If the ITERATOR is lesser or equal to -1, then we don't have to loop;
4790 we've already initialized all the elements. */
4795 for_stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
4796 finish_init_stmt (for_stmt
);
4797 finish_for_cond (build2 (GT_EXPR
, boolean_type_node
, iterator
,
4798 build_int_cst (TREE_TYPE (iterator
), -1)),
4799 for_stmt
, false, 0);
4800 /* We used to pass this decrement to finish_for_expr; now we add it to
4801 elt_init below so it's part of the same full-expression as the
4802 initialization, and thus happens before any potentially throwing
4803 temporary cleanups. */
4804 tree decr
= cp_build_unary_op (PREDECREMENT_EXPR
, iterator
, false,
4808 to
= build1 (INDIRECT_REF
, type
, base
);
4810 /* If the initializer is {}, then all elements are initialized from T{}.
4811 But for non-classes, that's the same as value-initialization. */
4814 if (cxx_dialect
>= cxx11
&& AGGREGATE_TYPE_P (type
))
4816 init
= build_constructor (init_list_type_node
, NULL
);
4821 explicit_value_init_p
= true;
4831 from
= build1 (INDIRECT_REF
, itype
, base2
);
4835 from
= build_tree_list (NULL_TREE
, from
);
4840 if (TREE_CODE (type
) == ARRAY_TYPE
)
4841 elt_init
= build_vec_init (to
, NULL_TREE
, from
, /*val_init*/false,
4842 from_array
, complain
);
4843 else if (from_array
== 2)
4844 elt_init
= cp_build_modify_expr (input_location
, to
, NOP_EXPR
,
4846 else if (type_build_ctor_call (type
))
4847 elt_init
= build_aggr_init (to
, from
, 0, complain
);
4849 elt_init
= cp_build_modify_expr (input_location
, to
, NOP_EXPR
, from
,
4854 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4856 if (init
&& !BRACE_ENCLOSED_INITIALIZER_P (init
))
4858 if ((complain
& tf_error
))
4859 error_at (loc
, "array must be initialized "
4860 "with a brace-enclosed initializer");
4861 elt_init
= error_mark_node
;
4864 elt_init
= build_vec_init (build1 (INDIRECT_REF
, type
, base
),
4866 explicit_value_init_p
,
4869 else if (explicit_value_init_p
)
4871 elt_init
= build_value_init (type
, complain
);
4872 if (elt_init
!= error_mark_node
)
4873 elt_init
= cp_build_init_expr (to
, elt_init
);
4877 gcc_assert (type_build_ctor_call (type
) || init
);
4878 if (CLASS_TYPE_P (type
))
4879 elt_init
= build_aggr_init (to
, init
, 0, complain
);
4882 if (TREE_CODE (init
) == TREE_LIST
)
4883 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
4885 elt_init
= (init
== error_mark_node
4887 : build2 (INIT_EXPR
, type
, to
, init
));
4891 if (elt_init
== error_mark_node
)
4896 /* FIXME refs to earlier elts */
4897 tree e
= maybe_constant_init (elt_init
);
4898 if (reduced_constant_expression_p (e
))
4900 if (initializer_zerop (e
))
4901 /* Don't fill the CONSTRUCTOR with zeros. */
4904 elt_init
= NULL_TREE
;
4908 saw_non_const
= true;
4910 e
= build_zero_init (TREE_TYPE (e
), NULL_TREE
, true);
4917 HOST_WIDE_INT last
= tree_to_shwi (maxindex
);
4918 if (num_initialized_elts
<= last
)
4920 tree field
= size_int (num_initialized_elts
);
4921 if (num_initialized_elts
!= last
)
4922 field
= build2 (RANGE_EXPR
, sizetype
, field
,
4924 CONSTRUCTOR_APPEND_ELT (const_vec
, field
, e
);
4929 /* [class.temporary]: "There are three contexts in which temporaries are
4930 destroyed at a different point than the end of the full-
4931 expression. The first context is when a default constructor is called
4932 to initialize an element of an array with no corresponding
4933 initializer. The second context is when a copy constructor is called
4934 to copy an element of an array while the entire array is copied. In
4935 either case, if the constructor has one or more default arguments, the
4936 destruction of every temporary created in a default argument is
4937 sequenced before the construction of the next array element, if any."
4939 So, for this loop, statements are full-expressions. */
4940 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
4941 if (elt_init
&& !errors
)
4942 elt_init
= build2 (COMPOUND_EXPR
, void_type_node
, elt_init
, decr
);
4945 finish_expr_stmt (elt_init
);
4946 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
4948 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR
, base
, false,
4951 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR
, base2
, false,
4954 finish_for_stmt (for_stmt
);
4957 /* The value of the array initialization is the array itself, RVAL
4958 is a pointer to the first element. */
4959 finish_stmt_expr_expr (rval
, stmt_expr
);
4961 stmt_expr
= finish_init_stmts (is_global
, stmt_expr
, compound_stmt
);
4963 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
4966 return error_mark_node
;
4972 tree const_init
= build_constructor (atype
, const_vec
);
4973 return build2 (INIT_EXPR
, atype
, obase
, const_init
);
4975 else if (do_static_init
&& !vec_safe_is_empty (const_vec
))
4976 DECL_INITIAL (obase
) = build_constructor (atype
, const_vec
);
4978 vec_free (const_vec
);
4981 /* Now make the result have the correct type. */
4982 if (TREE_CODE (atype
) == ARRAY_TYPE
)
4984 atype
= build_reference_type (atype
);
4985 stmt_expr
= build1 (NOP_EXPR
, atype
, stmt_expr
);
4986 stmt_expr
= convert_from_reference (stmt_expr
);
4992 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
4996 build_dtor_call (tree exp
, special_function_kind dtor_kind
, int flags
,
4997 tsubst_flags_t complain
)
5002 case sfk_complete_destructor
:
5003 name
= complete_dtor_identifier
;
5006 case sfk_base_destructor
:
5007 name
= base_dtor_identifier
;
5010 case sfk_deleting_destructor
:
5011 name
= deleting_dtor_identifier
;
5018 return build_special_member_call (exp
, name
,
5020 /*binfo=*/TREE_TYPE (exp
),
5025 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
5026 ADDR is an expression which yields the store to be destroyed.
5027 AUTO_DELETE is the name of the destructor to call, i.e., either
5028 sfk_complete_destructor, sfk_base_destructor, or
5029 sfk_deleting_destructor.
5031 FLAGS is the logical disjunction of zero or more LOOKUP_
5032 flags. See cp-tree.h for more info. */
5035 build_delete (location_t loc
, tree otype
, tree addr
,
5036 special_function_kind auto_delete
,
5037 int flags
, int use_global_delete
, tsubst_flags_t complain
)
5041 if (addr
== error_mark_node
)
5042 return error_mark_node
;
5044 tree type
= TYPE_MAIN_VARIANT (otype
);
5046 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
5047 set to `error_mark_node' before it gets properly cleaned up. */
5048 if (type
== error_mark_node
)
5049 return error_mark_node
;
5051 if (TYPE_PTR_P (type
))
5052 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
5054 if (TREE_CODE (type
) == ARRAY_TYPE
)
5056 if (TYPE_DOMAIN (type
) == NULL_TREE
)
5058 if (complain
& tf_error
)
5059 error_at (loc
, "unknown array size in delete");
5060 return error_mark_node
;
5062 return build_vec_delete (loc
, addr
, array_type_nelts (type
),
5063 auto_delete
, use_global_delete
, complain
);
5066 bool deleting
= (auto_delete
== sfk_deleting_destructor
);
5067 gcc_assert (deleting
== !(flags
& LOOKUP_DESTRUCTOR
));
5069 if (TYPE_PTR_P (otype
))
5071 addr
= mark_rvalue_use (addr
);
5073 /* We don't want to warn about delete of void*, only other
5074 incomplete types. Deleting other incomplete types
5075 invokes undefined behavior, but it is not ill-formed, so
5076 compile to something that would even do The Right Thing
5077 (TM) should the type have a trivial dtor and no delete
5079 if (!VOID_TYPE_P (type
))
5081 complete_type (type
);
5083 && !verify_type_context (loc
, TCTX_DEALLOCATION
, type
,
5084 !(complain
& tf_error
)))
5085 return error_mark_node
;
5087 if (!COMPLETE_TYPE_P (type
))
5089 if (complain
& tf_warning
)
5091 auto_diagnostic_group d
;
5092 if (warning_at (loc
, OPT_Wdelete_incomplete
,
5093 "possible problem detected in invocation of "
5094 "%<operator delete%>"))
5096 cxx_incomplete_type_diagnostic (addr
, type
, DK_WARNING
);
5098 "neither the destructor nor the class-specific "
5099 "%<operator delete%> will be called, even if "
5100 "they are declared when the class is defined");
5104 else if (deleting
&& warn_delnonvdtor
5105 && MAYBE_CLASS_TYPE_P (type
) && !CLASSTYPE_FINAL (type
)
5106 && TYPE_POLYMORPHIC_P (type
))
5108 tree dtor
= CLASSTYPE_DESTRUCTOR (type
);
5109 if (!dtor
|| !DECL_VINDEX (dtor
))
5111 if (CLASSTYPE_PURE_VIRTUALS (type
))
5112 warning_at (loc
, OPT_Wdelete_non_virtual_dtor
,
5113 "deleting object of abstract class type %qT"
5114 " which has non-virtual destructor"
5115 " will cause undefined behavior", type
);
5117 warning_at (loc
, OPT_Wdelete_non_virtual_dtor
,
5118 "deleting object of polymorphic class type %qT"
5119 " which has non-virtual destructor"
5120 " might cause undefined behavior", type
);
5125 /* Throw away const and volatile on target type of addr. */
5126 addr
= convert_force (build_pointer_type (type
), addr
, 0, complain
);
5130 /* Don't check PROTECT here; leave that decision to the
5131 destructor. If the destructor is accessible, call it,
5132 else report error. */
5133 addr
= cp_build_addr_expr (addr
, complain
);
5134 if (addr
== error_mark_node
)
5135 return error_mark_node
;
5137 addr
= convert_force (build_pointer_type (type
), addr
, 0, complain
);
5141 /* We will use ADDR multiple times so we must save it. */
5142 addr
= save_expr (addr
);
5144 bool virtual_p
= false;
5145 if (type_build_dtor_call (type
))
5147 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
5148 lazily_declare_fn (sfk_destructor
, type
);
5149 virtual_p
= DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTOR (type
));
5152 tree head
= NULL_TREE
;
5153 tree do_delete
= NULL_TREE
;
5154 bool destroying_delete
= false;
5158 /* Leave do_delete null. */
5160 /* For `::delete x', we must not use the deleting destructor
5161 since then we would not be sure to get the global `operator
5163 else if (use_global_delete
)
5165 head
= get_target_expr (build_headof (addr
));
5166 /* Delete the object. */
5167 do_delete
= build_op_delete_call (DELETE_EXPR
,
5169 cxx_sizeof_nowarn (type
),
5171 /*placement=*/NULL_TREE
,
5172 /*alloc_fn=*/NULL_TREE
,
5174 /* Otherwise, treat this like a complete object destructor
5176 auto_delete
= sfk_complete_destructor
;
5178 /* If the destructor is non-virtual, there is no deleting
5179 variant. Instead, we must explicitly call the appropriate
5180 `operator delete' here. */
5181 else if (!virtual_p
)
5183 /* Build the call. */
5184 do_delete
= build_op_delete_call (DELETE_EXPR
,
5186 cxx_sizeof_nowarn (type
),
5188 /*placement=*/NULL_TREE
,
5189 /*alloc_fn=*/NULL_TREE
,
5191 /* Call the complete object destructor. */
5192 auto_delete
= sfk_complete_destructor
;
5193 if (do_delete
!= error_mark_node
)
5195 tree fn
= get_callee_fndecl (do_delete
);
5196 destroying_delete
= destroying_delete_p (fn
);
5199 else if (TYPE_GETS_REG_DELETE (type
))
5201 /* Make sure we have access to the member op delete, even though
5202 we'll actually be calling it from the destructor. */
5203 build_op_delete_call (DELETE_EXPR
, addr
, cxx_sizeof_nowarn (type
),
5205 /*placement=*/NULL_TREE
,
5206 /*alloc_fn=*/NULL_TREE
,
5210 if (destroying_delete
)
5211 /* The operator delete will call the destructor. */
5213 else if (type_build_dtor_call (type
))
5214 expr
= build_dtor_call (cp_build_fold_indirect_ref (addr
),
5215 auto_delete
, flags
, complain
);
5217 expr
= build_trivial_dtor_call (addr
);
5218 if (expr
== error_mark_node
)
5219 return error_mark_node
;
5223 protected_set_expr_location (expr
, loc
);
5227 if (do_delete
== error_mark_node
)
5228 return error_mark_node
;
5230 if (do_delete
&& !TREE_SIDE_EFFECTS (expr
))
5233 /* The delete operator must be called, regardless of whether
5234 the destructor throws.
5236 [expr.delete]/7 The deallocation function is called
5237 regardless of whether the destructor for the object or some
5238 element of the array throws an exception. */
5239 expr
= build2 (TRY_FINALLY_EXPR
, void_type_node
, expr
, do_delete
);
5241 /* We need to calculate this before the dtor changes the vptr. */
5243 expr
= build2 (COMPOUND_EXPR
, void_type_node
, head
, expr
);
5245 /* Handle deleting a null pointer. */
5246 warning_sentinel
s (warn_address
);
5247 tree ifexp
= cp_build_binary_op (loc
, NE_EXPR
, addr
,
5248 nullptr_node
, complain
);
5249 ifexp
= cp_fully_fold (ifexp
);
5251 if (ifexp
== error_mark_node
)
5252 return error_mark_node
;
5253 /* This is a compiler generated comparison, don't emit
5254 e.g. -Wnonnull-compare warning for it. */
5255 else if (TREE_CODE (ifexp
) == NE_EXPR
)
5256 suppress_warning (ifexp
, OPT_Wnonnull_compare
);
5258 if (!integer_nonzerop (ifexp
))
5259 expr
= build3 (COND_EXPR
, void_type_node
, ifexp
, expr
, void_node
);
5261 protected_set_expr_location (expr
, loc
);
5265 /* At the beginning of a destructor, push cleanups that will call the
5266 destructors for our base classes and members.
5268 Called from begin_destructor_body. */
5271 push_base_cleanups (void)
5273 tree binfo
, base_binfo
;
5277 vec
<tree
, va_gc
> *vbases
;
5279 /* Run destructors for all virtual baseclasses. */
5280 if (!ABSTRACT_CLASS_TYPE_P (current_class_type
)
5281 && CLASSTYPE_VBASECLASSES (current_class_type
))
5283 tree cond
= (condition_conversion
5284 (build2 (BIT_AND_EXPR
, integer_type_node
,
5285 current_in_charge_parm
,
5286 integer_two_node
)));
5288 /* The CLASSTYPE_VBASECLASSES vector is in initialization
5289 order, which is also the right order for pushing cleanups. */
5290 for (vbases
= CLASSTYPE_VBASECLASSES (current_class_type
), i
= 0;
5291 vec_safe_iterate (vbases
, i
, &base_binfo
); i
++)
5293 if (type_build_dtor_call (BINFO_TYPE (base_binfo
)))
5295 expr
= build_special_member_call (current_class_ref
,
5296 base_dtor_identifier
,
5300 | LOOKUP_NONVIRTUAL
),
5301 tf_warning_or_error
);
5302 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
5304 expr
= build3 (COND_EXPR
, void_type_node
, cond
,
5306 finish_decl_cleanup (NULL_TREE
, expr
);
5312 /* Take care of the remaining baseclasses. */
5313 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
5314 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5316 if (BINFO_VIRTUAL_P (base_binfo
)
5317 || !type_build_dtor_call (BINFO_TYPE (base_binfo
)))
5320 expr
= build_special_member_call (current_class_ref
,
5321 base_dtor_identifier
,
5323 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
5324 tf_warning_or_error
);
5325 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
5326 finish_decl_cleanup (NULL_TREE
, expr
);
5329 /* Don't automatically destroy union members. */
5330 if (TREE_CODE (current_class_type
) == UNION_TYPE
)
5333 for (member
= TYPE_FIELDS (current_class_type
); member
;
5334 member
= DECL_CHAIN (member
))
5336 tree this_type
= TREE_TYPE (member
);
5337 if (this_type
== error_mark_node
5338 || TREE_CODE (member
) != FIELD_DECL
5339 || DECL_ARTIFICIAL (member
))
5341 if (ANON_AGGR_TYPE_P (this_type
))
5343 if (type_build_dtor_call (this_type
))
5345 tree this_member
= (build_class_member_access_expr
5346 (current_class_ref
, member
,
5347 /*access_path=*/NULL_TREE
,
5348 /*preserve_reference=*/false,
5349 tf_warning_or_error
));
5350 expr
= build_delete (input_location
, this_type
, this_member
,
5351 sfk_complete_destructor
,
5352 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
,
5353 0, tf_warning_or_error
);
5354 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (this_type
))
5355 finish_decl_cleanup (NULL_TREE
, expr
);
5360 /* Build a C++ vector delete expression.
5361 MAXINDEX is the number of elements to be deleted.
5362 ELT_SIZE is the nominal size of each element in the vector.
5363 BASE is the expression that should yield the store to be deleted.
5364 This function expands (or synthesizes) these calls itself.
5365 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
5367 This also calls delete for virtual baseclasses of elements of the vector.
5369 Update: MAXINDEX is no longer needed. The size can be extracted from the
5370 start of the vector for pointers, and from the type for arrays. We still
5371 use MAXINDEX for arrays because it happens to already have one of the
5372 values we'd have to extract. (We could use MAXINDEX with pointers to
5373 confirm the size, and trap if the numbers differ; not clear that it'd
5374 be worth bothering.) */
5377 build_vec_delete (location_t loc
, tree base
, tree maxindex
,
5378 special_function_kind auto_delete_vec
,
5379 int use_global_delete
, tsubst_flags_t complain
)
5383 tree base_init
= NULL_TREE
;
5385 type
= TREE_TYPE (base
);
5387 if (TYPE_PTR_P (type
))
5389 /* Step back one from start of vector, and read dimension. */
5391 tree size_ptr_type
= build_pointer_type (sizetype
);
5393 base
= mark_rvalue_use (base
);
5394 if (TREE_SIDE_EFFECTS (base
))
5396 base_init
= get_target_expr (base
);
5397 base
= TARGET_EXPR_SLOT (base_init
);
5399 type
= strip_array_types (TREE_TYPE (type
));
5400 cookie_addr
= fold_build1_loc (loc
, NEGATE_EXPR
,
5401 sizetype
, TYPE_SIZE_UNIT (sizetype
));
5402 cookie_addr
= fold_build_pointer_plus (fold_convert (size_ptr_type
, base
),
5404 maxindex
= cp_build_fold_indirect_ref (cookie_addr
);
5406 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5408 /* Get the total number of things in the array, maxindex is a
5410 maxindex
= array_type_nelts_total (type
);
5411 type
= strip_array_types (type
);
5412 base
= decay_conversion (base
, complain
);
5413 if (base
== error_mark_node
)
5414 return error_mark_node
;
5415 if (TREE_SIDE_EFFECTS (base
))
5417 base_init
= get_target_expr (base
);
5418 base
= TARGET_EXPR_SLOT (base_init
);
5423 if (base
!= error_mark_node
&& !(complain
& tf_error
))
5425 "type to vector delete is neither pointer or array type");
5426 return error_mark_node
;
5429 rval
= build_vec_delete_1 (loc
, base
, maxindex
, type
, auto_delete_vec
,
5430 use_global_delete
, complain
);
5431 if (base_init
&& rval
!= error_mark_node
)
5432 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), base_init
, rval
);
5434 protected_set_expr_location (rval
, loc
);
5438 #include "gt-cp-init.h"