1 /* Handle initialization things in C++.
2 Copyright (C) 1987-2020 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* High-level class interface. */
25 #include "coretypes.h"
28 #include "stringpool.h"
31 #include "c-family/c-ubsan.h"
33 #include "stringpool.h"
36 #include "stor-layout.h"
38 static bool begin_init_stmts (tree
*, tree
*);
39 static tree
finish_init_stmts (bool, tree
, tree
);
40 static void construct_virtual_base (tree
, tree
);
41 static void expand_aggr_init_1 (tree
, tree
, tree
, tree
, int, tsubst_flags_t
);
42 static void expand_default_init (tree
, tree
, tree
, tree
, int, tsubst_flags_t
);
43 static void perform_member_init (tree
, tree
);
44 static int member_init_ok_or_else (tree
, tree
, tree
);
45 static void expand_virtual_init (tree
, tree
);
46 static tree
sort_mem_initializers (tree
, tree
);
47 static tree
initializing_context (tree
);
48 static void expand_cleanup_for_base (tree
, tree
);
49 static tree
dfs_initialize_vtbl_ptrs (tree
, void *);
50 static tree
build_field_list (tree
, tree
, int *);
51 static int diagnose_uninitialized_cst_or_ref_member_1 (tree
, tree
, bool, bool);
53 static GTY(()) tree fn
;
55 /* We are about to generate some complex initialization code.
56 Conceptually, it is all a single expression. However, we may want
57 to include conditionals, loops, and other such statement-level
58 constructs. Therefore, we build the initialization code inside a
59 statement-expression. This function starts such an expression.
60 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
61 pass them back to finish_init_stmts when the expression is
65 begin_init_stmts (tree
*stmt_expr_p
, tree
*compound_stmt_p
)
67 bool is_global
= !building_stmt_list_p ();
69 *stmt_expr_p
= begin_stmt_expr ();
70 *compound_stmt_p
= begin_compound_stmt (BCS_NO_SCOPE
);
75 /* Finish out the statement-expression begun by the previous call to
76 begin_init_stmts. Returns the statement-expression itself. */
79 finish_init_stmts (bool is_global
, tree stmt_expr
, tree compound_stmt
)
81 finish_compound_stmt (compound_stmt
);
83 stmt_expr
= finish_stmt_expr (stmt_expr
, true);
85 gcc_assert (!building_stmt_list_p () == is_global
);
92 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
93 which we want to initialize the vtable pointer for, DATA is
94 TREE_LIST whose TREE_VALUE is the this ptr expression. */
97 dfs_initialize_vtbl_ptrs (tree binfo
, void *data
)
99 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
100 return dfs_skip_bases
;
102 if (!BINFO_PRIMARY_P (binfo
) || BINFO_VIRTUAL_P (binfo
))
104 tree base_ptr
= TREE_VALUE ((tree
) data
);
106 base_ptr
= build_base_path (PLUS_EXPR
, base_ptr
, binfo
, /*nonnull=*/1,
107 tf_warning_or_error
);
109 expand_virtual_init (binfo
, base_ptr
);
115 /* Initialize all the vtable pointers in the object pointed to by
119 initialize_vtbl_ptrs (tree addr
)
124 type
= TREE_TYPE (TREE_TYPE (addr
));
125 list
= build_tree_list (type
, addr
);
127 /* Walk through the hierarchy, initializing the vptr in each base
128 class. We do these in pre-order because we can't find the virtual
129 bases for a class until we've initialized the vtbl for that
131 dfs_walk_once (TYPE_BINFO (type
), dfs_initialize_vtbl_ptrs
, NULL
, list
);
134 /* Return an expression for the zero-initialization of an object with
135 type T. This expression will either be a constant (in the case
136 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
137 aggregate), or NULL (in the case that T does not require
138 initialization). In either case, the value can be used as
139 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
140 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
141 is the number of elements in the array. If STATIC_STORAGE_P is
142 TRUE, initializers are only generated for entities for which
143 zero-initialization does not simply mean filling the storage with
144 zero bytes. FIELD_SIZE, if non-NULL, is the bit size of the field,
145 subfields with bit positions at or above that bit size shouldn't
146 be added. Note that this only works when the result is assigned
147 to a base COMPONENT_REF; if we only have a pointer to the base subobject,
148 expand_assignment will end up clearing the full size of TYPE. */
151 build_zero_init_1 (tree type
, tree nelts
, bool static_storage_p
,
154 tree init
= NULL_TREE
;
158 To zero-initialize an object of type T means:
160 -- if T is a scalar type, the storage is set to the value of zero
163 -- if T is a non-union class type, the storage for each nonstatic
164 data member and each base-class subobject is zero-initialized.
166 -- if T is a union type, the storage for its first data member is
169 -- if T is an array type, the storage for each element is
172 -- if T is a reference type, no initialization is performed. */
174 gcc_assert (nelts
== NULL_TREE
|| TREE_CODE (nelts
) == INTEGER_CST
);
176 if (type
== error_mark_node
)
178 else if (static_storage_p
&& zero_init_p (type
))
179 /* In order to save space, we do not explicitly build initializers
180 for items that do not need them. GCC's semantics are that
181 items with static storage duration that are not otherwise
182 initialized are initialized to zero. */
184 else if (TYPE_PTR_OR_PTRMEM_P (type
))
185 init
= fold (convert (type
, nullptr_node
));
186 else if (NULLPTR_TYPE_P (type
))
187 init
= build_int_cst (type
, 0);
188 else if (SCALAR_TYPE_P (type
))
189 init
= fold (convert (type
, integer_zero_node
));
190 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (type
)))
193 vec
<constructor_elt
, va_gc
> *v
= NULL
;
195 /* Iterate over the fields, building initializations. */
196 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
198 if (TREE_CODE (field
) != FIELD_DECL
)
201 if (TREE_TYPE (field
) == error_mark_node
)
204 /* Don't add virtual bases for base classes if they are beyond
205 the size of the current field, that means it is present
206 somewhere else in the object. */
209 tree bitpos
= bit_position (field
);
210 if (TREE_CODE (bitpos
) == INTEGER_CST
211 && !tree_int_cst_lt (bitpos
, field_size
))
215 /* Note that for class types there will be FIELD_DECLs
216 corresponding to base classes as well. Thus, iterating
217 over TYPE_FIELDs will result in correct initialization of
218 all of the subobjects. */
219 if (!static_storage_p
|| !zero_init_p (TREE_TYPE (field
)))
222 = (DECL_FIELD_IS_BASE (field
)
224 && TREE_CODE (DECL_SIZE (field
)) == INTEGER_CST
)
225 ? DECL_SIZE (field
) : NULL_TREE
;
226 tree value
= build_zero_init_1 (TREE_TYPE (field
),
231 CONSTRUCTOR_APPEND_ELT(v
, field
, value
);
234 /* For unions, only the first field is initialized. */
235 if (TREE_CODE (type
) == UNION_TYPE
)
239 /* Build a constructor to contain the initializations. */
240 init
= build_constructor (type
, v
);
242 else if (TREE_CODE (type
) == ARRAY_TYPE
)
245 vec
<constructor_elt
, va_gc
> *v
= NULL
;
247 /* Iterate over the array elements, building initializations. */
249 max_index
= fold_build2_loc (input_location
,
250 MINUS_EXPR
, TREE_TYPE (nelts
),
251 nelts
, integer_one_node
);
253 max_index
= array_type_nelts (type
);
255 /* If we have an error_mark here, we should just return error mark
256 as we don't know the size of the array yet. */
257 if (max_index
== error_mark_node
)
258 return error_mark_node
;
259 gcc_assert (TREE_CODE (max_index
) == INTEGER_CST
);
261 /* A zero-sized array, which is accepted as an extension, will
262 have an upper bound of -1. */
263 if (!tree_int_cst_equal (max_index
, integer_minus_one_node
))
267 /* If this is a one element array, we just use a regular init. */
268 if (tree_int_cst_equal (size_zero_node
, max_index
))
269 ce
.index
= size_zero_node
;
271 ce
.index
= build2 (RANGE_EXPR
, sizetype
, size_zero_node
,
274 ce
.value
= build_zero_init_1 (TREE_TYPE (type
),
276 static_storage_p
, NULL_TREE
);
284 /* Build a constructor to contain the initializations. */
285 init
= build_constructor (type
, v
);
287 else if (VECTOR_TYPE_P (type
))
288 init
= build_zero_cst (type
);
291 gcc_assert (TYPE_REF_P (type
));
292 init
= build_zero_cst (type
);
295 /* In all cases, the initializer is a constant. */
297 TREE_CONSTANT (init
) = 1;
302 /* Return an expression for the zero-initialization of an object with
303 type T. This expression will either be a constant (in the case
304 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
305 aggregate), or NULL (in the case that T does not require
306 initialization). In either case, the value can be used as
307 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
308 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
309 is the number of elements in the array. If STATIC_STORAGE_P is
310 TRUE, initializers are only generated for entities for which
311 zero-initialization does not simply mean filling the storage with
315 build_zero_init (tree type
, tree nelts
, bool static_storage_p
)
317 return build_zero_init_1 (type
, nelts
, static_storage_p
, NULL_TREE
);
320 /* Return a suitable initializer for value-initializing an object of type
321 TYPE, as described in [dcl.init]. */
324 build_value_init (tree type
, tsubst_flags_t complain
)
328 To value-initialize an object of type T means:
330 - if T is a class type (clause 9) with either no default constructor
331 (12.1) or a default constructor that is user-provided or deleted,
332 then the object is default-initialized;
334 - if T is a (possibly cv-qualified) class type without a user-provided
335 or deleted default constructor, then the object is zero-initialized
336 and the semantic constraints for default-initialization are checked,
337 and if T has a non-trivial default constructor, the object is
340 - if T is an array type, then each element is value-initialized;
342 - otherwise, the object is zero-initialized.
344 A program that calls for default-initialization or
345 value-initialization of an entity of reference type is ill-formed. */
347 /* The AGGR_INIT_EXPR tweaking below breaks in templates. */
348 gcc_assert (!processing_template_decl
349 || (SCALAR_TYPE_P (type
) || TREE_CODE (type
) == ARRAY_TYPE
));
351 if (CLASS_TYPE_P (type
) && type_build_ctor_call (type
))
354 = build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
355 NULL
, type
, LOOKUP_NORMAL
, complain
);
356 if (ctor
== error_mark_node
|| TREE_CONSTANT (ctor
))
359 if (TREE_CODE (ctor
) == CALL_EXPR
)
360 fn
= get_callee_fndecl (ctor
);
361 ctor
= build_aggr_init_expr (type
, ctor
);
362 if (fn
&& user_provided_p (fn
))
364 else if (TYPE_HAS_COMPLEX_DFLT (type
))
366 /* This is a class that needs constructing, but doesn't have
367 a user-provided constructor. So we need to zero-initialize
368 the object and then call the implicitly defined ctor.
369 This will be handled in simplify_aggr_init_expr. */
370 AGGR_INIT_ZERO_FIRST (ctor
) = 1;
375 /* Discard any access checking during subobject initialization;
376 the checks are implied by the call to the ctor which we have
377 verified is OK (cpp0x/defaulted46.C). */
378 push_deferring_access_checks (dk_deferred
);
379 tree r
= build_value_init_noctor (type
, complain
);
380 pop_deferring_access_checks ();
384 /* Like build_value_init, but don't call the constructor for TYPE. Used
385 for base initializers. */
388 build_value_init_noctor (tree type
, tsubst_flags_t complain
)
390 if (!COMPLETE_TYPE_P (type
))
392 if (complain
& tf_error
)
393 error ("value-initialization of incomplete type %qT", type
);
394 return error_mark_node
;
396 /* FIXME the class and array cases should just use digest_init once it is
398 if (CLASS_TYPE_P (type
))
400 gcc_assert (!TYPE_HAS_COMPLEX_DFLT (type
)
403 if (TREE_CODE (type
) != UNION_TYPE
)
406 vec
<constructor_elt
, va_gc
> *v
= NULL
;
408 /* Iterate over the fields, building initializations. */
409 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
413 if (TREE_CODE (field
) != FIELD_DECL
)
416 ftype
= TREE_TYPE (field
);
418 if (ftype
== error_mark_node
)
421 /* Ignore flexible array members for value initialization. */
422 if (TREE_CODE (ftype
) == ARRAY_TYPE
423 && !COMPLETE_TYPE_P (ftype
)
424 && !TYPE_DOMAIN (ftype
)
425 && COMPLETE_TYPE_P (TREE_TYPE (ftype
))
426 && (next_initializable_field (DECL_CHAIN (field
))
430 /* We could skip vfields and fields of types with
431 user-defined constructors, but I think that won't improve
432 performance at all; it should be simpler in general just
433 to zero out the entire object than try to only zero the
434 bits that actually need it. */
436 /* Note that for class types there will be FIELD_DECLs
437 corresponding to base classes as well. Thus, iterating
438 over TYPE_FIELDs will result in correct initialization of
439 all of the subobjects. */
440 value
= build_value_init (ftype
, complain
);
441 value
= maybe_constant_init (value
);
443 if (value
== error_mark_node
)
444 return error_mark_node
;
446 CONSTRUCTOR_APPEND_ELT(v
, field
, value
);
448 /* We shouldn't have gotten here for anything that would need
449 non-trivial initialization, and gimplify_init_ctor_preeval
450 would need to be fixed to allow it. */
451 gcc_assert (TREE_CODE (value
) != TARGET_EXPR
452 && TREE_CODE (value
) != AGGR_INIT_EXPR
);
455 /* Build a constructor to contain the zero- initializations. */
456 return build_constructor (type
, v
);
459 else if (TREE_CODE (type
) == ARRAY_TYPE
)
461 vec
<constructor_elt
, va_gc
> *v
= NULL
;
463 /* Iterate over the array elements, building initializations. */
464 tree max_index
= array_type_nelts (type
);
466 /* If we have an error_mark here, we should just return error mark
467 as we don't know the size of the array yet. */
468 if (max_index
== error_mark_node
)
470 if (complain
& tf_error
)
471 error ("cannot value-initialize array of unknown bound %qT",
473 return error_mark_node
;
475 gcc_assert (TREE_CODE (max_index
) == INTEGER_CST
);
477 /* A zero-sized array, which is accepted as an extension, will
478 have an upper bound of -1. */
479 if (!tree_int_cst_equal (max_index
, integer_minus_one_node
))
483 /* If this is a one element array, we just use a regular init. */
484 if (tree_int_cst_equal (size_zero_node
, max_index
))
485 ce
.index
= size_zero_node
;
487 ce
.index
= build2 (RANGE_EXPR
, sizetype
, size_zero_node
, max_index
);
489 ce
.value
= build_value_init (TREE_TYPE (type
), complain
);
490 ce
.value
= maybe_constant_init (ce
.value
);
491 if (ce
.value
== error_mark_node
)
492 return error_mark_node
;
497 /* We shouldn't have gotten here for anything that would need
498 non-trivial initialization, and gimplify_init_ctor_preeval
499 would need to be fixed to allow it. */
500 gcc_assert (TREE_CODE (ce
.value
) != TARGET_EXPR
501 && TREE_CODE (ce
.value
) != AGGR_INIT_EXPR
);
504 /* Build a constructor to contain the initializations. */
505 return build_constructor (type
, v
);
507 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
509 if (complain
& tf_error
)
510 error ("value-initialization of function type %qT", type
);
511 return error_mark_node
;
513 else if (TYPE_REF_P (type
))
515 if (complain
& tf_error
)
516 error ("value-initialization of reference type %qT", type
);
517 return error_mark_node
;
520 return build_zero_init (type
, NULL_TREE
, /*static_storage_p=*/false);
523 /* Initialize current class with INIT, a TREE_LIST of
524 arguments for a target constructor. If TREE_LIST is void_type_node,
525 an empty initializer list was given. */
528 perform_target_ctor (tree init
)
530 tree decl
= current_class_ref
;
531 tree type
= current_class_type
;
533 finish_expr_stmt (build_aggr_init (decl
, init
,
534 LOOKUP_NORMAL
|LOOKUP_DELEGATING_CONS
,
535 tf_warning_or_error
));
536 if (type_build_dtor_call (type
))
538 tree expr
= build_delete (input_location
,
539 type
, decl
, sfk_complete_destructor
,
543 0, tf_warning_or_error
);
544 if (expr
!= error_mark_node
545 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
546 finish_eh_cleanup (expr
);
550 /* Return the non-static data initializer for FIELD_DECL MEMBER. */
552 static GTY((cache
)) decl_tree_cache_map
*nsdmi_inst
;
555 get_nsdmi (tree member
, bool in_ctor
, tsubst_flags_t complain
)
558 tree save_ccp
= current_class_ptr
;
559 tree save_ccr
= current_class_ref
;
561 if (DECL_LANG_SPECIFIC (member
) && DECL_TEMPLATE_INFO (member
))
563 init
= DECL_INITIAL (DECL_TI_TEMPLATE (member
));
565 = cp_expr_loc_or_loc (init
, DECL_SOURCE_LOCATION (member
));
566 if (TREE_CODE (init
) == DEFERRED_PARSE
)
568 else if (tree
*slot
= hash_map_safe_get (nsdmi_inst
, member
))
570 /* Check recursive instantiation. */
571 else if (DECL_INSTANTIATING_NSDMI_P (member
))
573 if (complain
& tf_error
)
574 error_at (expr_loc
, "recursive instantiation of default member "
575 "initializer for %qD", member
);
576 init
= error_mark_node
;
582 location_t sloc
= input_location
;
583 input_location
= expr_loc
;
585 DECL_INSTANTIATING_NSDMI_P (member
) = 1;
588 if (!currently_open_class (DECL_CONTEXT (member
)))
590 push_to_top_level ();
591 push_nested_class (DECL_CONTEXT (member
));
595 gcc_checking_assert (!processing_template_decl
);
597 inject_this_parameter (DECL_CONTEXT (member
), TYPE_UNQUALIFIED
);
599 start_lambda_scope (member
);
601 /* Do deferred instantiation of the NSDMI. */
602 init
= (tsubst_copy_and_build
603 (init
, DECL_TI_ARGS (member
),
604 complain
, member
, /*function_p=*/false,
605 /*integral_constant_expression_p=*/false));
606 init
= digest_nsdmi_init (member
, init
, complain
);
608 finish_lambda_scope ();
610 DECL_INSTANTIATING_NSDMI_P (member
) = 0;
612 if (init
!= error_mark_node
)
613 hash_map_safe_put
<hm_ggc
> (nsdmi_inst
, member
, init
);
618 pop_from_top_level ();
621 input_location
= sloc
;
625 init
= DECL_INITIAL (member
);
627 if (init
&& TREE_CODE (init
) == DEFERRED_PARSE
)
629 if (complain
& tf_error
)
631 error ("default member initializer for %qD required before the end "
632 "of its enclosing class", member
);
633 inform (location_of (init
), "defined here");
634 DECL_INITIAL (member
) = error_mark_node
;
636 init
= error_mark_node
;
641 current_class_ptr
= save_ccp
;
642 current_class_ref
= save_ccr
;
646 /* Use a PLACEHOLDER_EXPR when we don't have a 'this' parameter to
647 refer to; constexpr evaluation knows what to do with it. */
648 current_class_ref
= build0 (PLACEHOLDER_EXPR
, DECL_CONTEXT (member
));
649 current_class_ptr
= build_address (current_class_ref
);
652 /* Strip redundant TARGET_EXPR so we don't need to remap it, and
653 so the aggregate init code below will see a CONSTRUCTOR. */
654 bool simple_target
= (init
&& SIMPLE_TARGET_EXPR_P (init
));
656 init
= TARGET_EXPR_INITIAL (init
);
657 init
= break_out_target_exprs (init
, /*loc*/true);
658 if (simple_target
&& TREE_CODE (init
) != CONSTRUCTOR
)
659 /* Now put it back so C++17 copy elision works. */
660 init
= get_target_expr (init
);
662 current_class_ptr
= save_ccp
;
663 current_class_ref
= save_ccr
;
667 /* Diagnose the flexible array MEMBER if its INITializer is non-null
668 and return true if so. Otherwise return false. */
671 maybe_reject_flexarray_init (tree member
, tree init
)
673 tree type
= TREE_TYPE (member
);
676 || TREE_CODE (type
) != ARRAY_TYPE
677 || TYPE_DOMAIN (type
))
680 /* Point at the flexible array member declaration if it's initialized
681 in-class, and at the ctor if it's initialized in a ctor member
684 if (DECL_INITIAL (member
) == init
685 || !current_function_decl
686 || DECL_DEFAULTED_FN (current_function_decl
))
687 loc
= DECL_SOURCE_LOCATION (member
);
689 loc
= DECL_SOURCE_LOCATION (current_function_decl
);
691 error_at (loc
, "initializer for flexible array member %q#D", member
);
695 /* If INIT's value can come from a call to std::initializer_list<T>::begin,
696 return that function. Otherwise, NULL_TREE. */
699 find_list_begin (tree init
)
702 while (TREE_CODE (init
) == COMPOUND_EXPR
)
703 init
= TREE_OPERAND (init
, 1);
705 if (TREE_CODE (init
) == COND_EXPR
)
707 tree left
= TREE_OPERAND (init
, 1);
709 left
= TREE_OPERAND (init
, 0);
710 left
= find_list_begin (left
);
713 return find_list_begin (TREE_OPERAND (init
, 2));
715 if (TREE_CODE (init
) == CALL_EXPR
)
716 if (tree fn
= get_callee_fndecl (init
))
717 if (id_equal (DECL_NAME (fn
), "begin")
718 && is_std_init_list (DECL_CONTEXT (fn
)))
723 /* If INIT initializing MEMBER is copying the address of the underlying array
724 of an initializer_list, warn. */
727 maybe_warn_list_ctor (tree member
, tree init
)
729 tree memtype
= TREE_TYPE (member
);
730 if (!init
|| !TYPE_PTR_P (memtype
)
731 || !is_list_ctor (current_function_decl
))
734 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (current_function_decl
);
735 tree initlist
= non_reference (TREE_VALUE (parms
));
736 tree targs
= CLASSTYPE_TI_ARGS (initlist
);
737 tree elttype
= TREE_VEC_ELT (targs
, 0);
739 if (!same_type_ignoring_top_level_qualifiers_p
740 (TREE_TYPE (memtype
), elttype
))
743 tree begin
= find_list_begin (init
);
747 location_t loc
= cp_expr_loc_or_input_loc (init
);
748 warning_at (loc
, OPT_Winit_list_lifetime
,
749 "initializing %qD from %qE does not extend the lifetime "
750 "of the underlying array", member
, begin
);
753 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
754 arguments. If TREE_LIST is void_type_node, an empty initializer
755 list was given; if NULL_TREE no initializer was given. */
758 perform_member_init (tree member
, tree init
)
761 tree type
= TREE_TYPE (member
);
763 /* Use the non-static data member initializer if there was no
764 mem-initializer for this field. */
765 if (init
== NULL_TREE
)
766 init
= get_nsdmi (member
, /*ctor*/true, tf_warning_or_error
);
768 if (init
== error_mark_node
)
771 /* Effective C++ rule 12 requires that all data members be
773 if (warn_ecpp
&& init
== NULL_TREE
&& TREE_CODE (type
) != ARRAY_TYPE
)
774 warning_at (DECL_SOURCE_LOCATION (current_function_decl
), OPT_Weffc__
,
775 "%qD should be initialized in the member initialization list",
778 /* Get an lvalue for the data member. */
779 decl
= build_class_member_access_expr (current_class_ref
, member
,
780 /*access_path=*/NULL_TREE
,
781 /*preserve_reference=*/true,
782 tf_warning_or_error
);
783 if (decl
== error_mark_node
)
786 if (warn_init_self
&& init
&& TREE_CODE (init
) == TREE_LIST
787 && TREE_CHAIN (init
) == NULL_TREE
)
789 tree val
= TREE_VALUE (init
);
790 /* Handle references. */
791 if (REFERENCE_REF_P (val
))
792 val
= TREE_OPERAND (val
, 0);
793 if (TREE_CODE (val
) == COMPONENT_REF
&& TREE_OPERAND (val
, 1) == member
794 && TREE_OPERAND (val
, 0) == current_class_ref
)
795 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
796 OPT_Winit_self
, "%qD is initialized with itself",
800 if (init
== void_type_node
)
802 /* mem() means value-initialization. */
803 if (TREE_CODE (type
) == ARRAY_TYPE
)
805 init
= build_vec_init_expr (type
, init
, tf_warning_or_error
);
806 init
= build2 (INIT_EXPR
, type
, decl
, init
);
807 finish_expr_stmt (init
);
811 tree value
= build_value_init (type
, tf_warning_or_error
);
812 if (value
== error_mark_node
)
814 init
= build2 (INIT_EXPR
, type
, decl
, value
);
815 finish_expr_stmt (init
);
818 /* Deal with this here, as we will get confused if we try to call the
819 assignment op for an anonymous union. This can happen in a
820 synthesized copy constructor. */
821 else if (ANON_AGGR_TYPE_P (type
))
825 init
= build2 (INIT_EXPR
, type
, decl
, TREE_VALUE (init
));
826 finish_expr_stmt (init
);
830 && (TYPE_REF_P (type
)
831 /* Pre-digested NSDMI. */
832 || (((TREE_CODE (init
) == CONSTRUCTOR
833 && TREE_TYPE (init
) == type
)
834 /* { } mem-initializer. */
835 || (TREE_CODE (init
) == TREE_LIST
836 && DIRECT_LIST_INIT_P (TREE_VALUE (init
))))
837 && (CP_AGGREGATE_TYPE_P (type
)
838 || is_std_init_list (type
)))))
840 /* With references and list-initialization, we need to deal with
841 extending temporary lifetimes. 12.2p5: "A temporary bound to a
842 reference member in a constructor’s ctor-initializer (12.6.2)
843 persists until the constructor exits." */
845 releasing_vec cleanups
;
846 if (TREE_CODE (init
) == TREE_LIST
)
847 init
= build_x_compound_expr_from_list (init
, ELK_MEM_INIT
,
848 tf_warning_or_error
);
849 if (TREE_TYPE (init
) != type
)
851 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
852 && CP_AGGREGATE_TYPE_P (type
))
853 init
= reshape_init (type
, init
, tf_warning_or_error
);
854 init
= digest_init (type
, init
, tf_warning_or_error
);
856 if (init
== error_mark_node
)
858 /* A FIELD_DECL doesn't really have a suitable lifetime, but
859 make_temporary_var_for_ref_to_temp will treat it as automatic and
860 set_up_extended_ref_temp wants to use the decl in a warning. */
861 init
= extend_ref_init_temps (member
, init
, &cleanups
);
862 if (TREE_CODE (type
) == ARRAY_TYPE
863 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (type
)))
864 init
= build_vec_init_expr (type
, init
, tf_warning_or_error
);
865 init
= build2 (INIT_EXPR
, type
, decl
, init
);
866 finish_expr_stmt (init
);
867 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
868 push_cleanup (decl
, t
, false);
870 else if (type_build_ctor_call (type
)
871 || (init
&& CLASS_TYPE_P (strip_array_types (type
))))
873 if (TREE_CODE (type
) == ARRAY_TYPE
)
877 /* Check to make sure the member initializer is valid and
878 something like a CONSTRUCTOR in: T a[] = { 1, 2 } and
879 if it isn't, return early to avoid triggering another
881 if (maybe_reject_flexarray_init (member
, init
))
884 if (TREE_CODE (init
) != TREE_LIST
|| TREE_CHAIN (init
))
885 init
= error_mark_node
;
887 init
= TREE_VALUE (init
);
889 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
890 init
= digest_init (type
, init
, tf_warning_or_error
);
892 if (init
== NULL_TREE
893 || same_type_ignoring_top_level_qualifiers_p (type
,
896 if (TYPE_DOMAIN (type
) && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
898 /* Initialize the array only if it's not a flexible
899 array member (i.e., if it has an upper bound). */
900 init
= build_vec_init_expr (type
, init
, tf_warning_or_error
);
901 init
= build2 (INIT_EXPR
, type
, decl
, init
);
902 finish_expr_stmt (init
);
906 error ("invalid initializer for array member %q#D", member
);
910 int flags
= LOOKUP_NORMAL
;
911 if (DECL_DEFAULTED_FN (current_function_decl
))
912 flags
|= LOOKUP_DEFAULTED
;
913 if (CP_TYPE_CONST_P (type
)
915 && default_init_uninitialized_part (type
))
917 /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
918 vtable; still give this diagnostic. */
919 auto_diagnostic_group d
;
920 if (permerror (DECL_SOURCE_LOCATION (current_function_decl
),
921 "uninitialized const member in %q#T", type
))
922 inform (DECL_SOURCE_LOCATION (member
),
923 "%q#D should be initialized", member
);
925 finish_expr_stmt (build_aggr_init (decl
, init
, flags
,
926 tf_warning_or_error
));
931 if (init
== NULL_TREE
)
934 /* member traversal: note it leaves init NULL */
935 if (TYPE_REF_P (type
))
937 auto_diagnostic_group d
;
938 if (permerror (DECL_SOURCE_LOCATION (current_function_decl
),
939 "uninitialized reference member in %q#T", type
))
940 inform (DECL_SOURCE_LOCATION (member
),
941 "%q#D should be initialized", member
);
943 else if (CP_TYPE_CONST_P (type
))
945 auto_diagnostic_group d
;
946 if (permerror (DECL_SOURCE_LOCATION (current_function_decl
),
947 "uninitialized const member in %q#T", type
))
948 inform (DECL_SOURCE_LOCATION (member
),
949 "%q#D should be initialized", member
);
952 core_type
= strip_array_types (type
);
954 if (CLASS_TYPE_P (core_type
)
955 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
956 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
957 diagnose_uninitialized_cst_or_ref_member (core_type
,
961 else if (TREE_CODE (init
) == TREE_LIST
)
962 /* There was an explicit member initialization. Do some work
964 init
= build_x_compound_expr_from_list (init
, ELK_MEM_INIT
,
965 tf_warning_or_error
);
967 maybe_warn_list_ctor (member
, init
);
969 /* Reject a member initializer for a flexible array member. */
970 if (init
&& !maybe_reject_flexarray_init (member
, init
))
971 finish_expr_stmt (cp_build_modify_expr (input_location
, decl
,
973 tf_warning_or_error
));
976 if (type_build_dtor_call (type
))
980 expr
= build_class_member_access_expr (current_class_ref
, member
,
981 /*access_path=*/NULL_TREE
,
982 /*preserve_reference=*/false,
983 tf_warning_or_error
);
984 expr
= build_delete (input_location
,
985 type
, expr
, sfk_complete_destructor
,
986 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0,
987 tf_warning_or_error
);
989 if (expr
!= error_mark_node
990 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
991 finish_eh_cleanup (expr
);
995 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
996 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
999 build_field_list (tree t
, tree list
, int *uses_unions_or_anon_p
)
1003 /* Note whether or not T is a union. */
1004 if (TREE_CODE (t
) == UNION_TYPE
)
1005 *uses_unions_or_anon_p
= 1;
1007 for (fields
= TYPE_FIELDS (t
); fields
; fields
= DECL_CHAIN (fields
))
1011 /* Skip CONST_DECLs for enumeration constants and so forth. */
1012 if (TREE_CODE (fields
) != FIELD_DECL
|| DECL_ARTIFICIAL (fields
))
1015 fieldtype
= TREE_TYPE (fields
);
1017 /* For an anonymous struct or union, we must recursively
1018 consider the fields of the anonymous type. They can be
1019 directly initialized from the constructor. */
1020 if (ANON_AGGR_TYPE_P (fieldtype
))
1022 /* Add this field itself. Synthesized copy constructors
1023 initialize the entire aggregate. */
1024 list
= tree_cons (fields
, NULL_TREE
, list
);
1025 /* And now add the fields in the anonymous aggregate. */
1026 list
= build_field_list (fieldtype
, list
, uses_unions_or_anon_p
);
1027 *uses_unions_or_anon_p
= 1;
1029 /* Add this field. */
1030 else if (DECL_NAME (fields
))
1031 list
= tree_cons (fields
, NULL_TREE
, list
);
1037 /* Return the innermost aggregate scope for FIELD, whether that is
1038 the enclosing class or an anonymous aggregate within it. */
1041 innermost_aggr_scope (tree field
)
1043 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
1044 return TREE_TYPE (field
);
1046 return DECL_CONTEXT (field
);
1049 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
1050 a FIELD_DECL or BINFO in T that needs initialization. The
1051 TREE_VALUE gives the initializer, or list of initializer arguments.
1053 Return a TREE_LIST containing all of the initializations required
1054 for T, in the order in which they should be performed. The output
1055 list has the same format as the input. */
1058 sort_mem_initializers (tree t
, tree mem_inits
)
1061 tree base
, binfo
, base_binfo
;
1063 tree next_subobject
;
1064 vec
<tree
, va_gc
> *vbases
;
1066 int uses_unions_or_anon_p
= 0;
1068 /* Build up a list of initializations. The TREE_PURPOSE of entry
1069 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
1070 TREE_VALUE will be the constructor arguments, or NULL if no
1071 explicit initialization was provided. */
1072 sorted_inits
= NULL_TREE
;
1074 /* Process the virtual bases. */
1075 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
1076 vec_safe_iterate (vbases
, i
, &base
); i
++)
1077 sorted_inits
= tree_cons (base
, NULL_TREE
, sorted_inits
);
1079 /* Process the direct bases. */
1080 for (binfo
= TYPE_BINFO (t
), i
= 0;
1081 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
1082 if (!BINFO_VIRTUAL_P (base_binfo
))
1083 sorted_inits
= tree_cons (base_binfo
, NULL_TREE
, sorted_inits
);
1085 /* Process the non-static data members. */
1086 sorted_inits
= build_field_list (t
, sorted_inits
, &uses_unions_or_anon_p
);
1087 /* Reverse the entire list of initializations, so that they are in
1088 the order that they will actually be performed. */
1089 sorted_inits
= nreverse (sorted_inits
);
1091 /* If the user presented the initializers in an order different from
1092 that in which they will actually occur, we issue a warning. Keep
1093 track of the next subobject which can be explicitly initialized
1094 without issuing a warning. */
1095 next_subobject
= sorted_inits
;
1097 /* Go through the explicit initializers, filling in TREE_PURPOSE in
1098 the SORTED_INITS. */
1099 for (init
= mem_inits
; init
; init
= TREE_CHAIN (init
))
1102 tree subobject_init
;
1104 subobject
= TREE_PURPOSE (init
);
1106 /* If the explicit initializers are in sorted order, then
1107 SUBOBJECT will be NEXT_SUBOBJECT, or something following
1109 for (subobject_init
= next_subobject
;
1111 subobject_init
= TREE_CHAIN (subobject_init
))
1112 if (TREE_PURPOSE (subobject_init
) == subobject
)
1115 /* Issue a warning if the explicit initializer order does not
1116 match that which will actually occur.
1117 ??? Are all these on the correct lines? */
1118 if (warn_reorder
&& !subobject_init
)
1120 if (TREE_CODE (TREE_PURPOSE (next_subobject
)) == FIELD_DECL
)
1121 warning_at (DECL_SOURCE_LOCATION (TREE_PURPOSE (next_subobject
)),
1122 OPT_Wreorder
, "%qD will be initialized after",
1123 TREE_PURPOSE (next_subobject
));
1125 warning (OPT_Wreorder
, "base %qT will be initialized after",
1126 TREE_PURPOSE (next_subobject
));
1127 if (TREE_CODE (subobject
) == FIELD_DECL
)
1128 warning_at (DECL_SOURCE_LOCATION (subobject
),
1129 OPT_Wreorder
, " %q#D", subobject
);
1131 warning (OPT_Wreorder
, " base %qT", subobject
);
1132 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
1133 OPT_Wreorder
, " when initialized here");
1136 /* Look again, from the beginning of the list. */
1137 if (!subobject_init
)
1139 subobject_init
= sorted_inits
;
1140 while (TREE_PURPOSE (subobject_init
) != subobject
)
1141 subobject_init
= TREE_CHAIN (subobject_init
);
1144 /* It is invalid to initialize the same subobject more than
1146 if (TREE_VALUE (subobject_init
))
1148 if (TREE_CODE (subobject
) == FIELD_DECL
)
1149 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1150 "multiple initializations given for %qD",
1153 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1154 "multiple initializations given for base %qT",
1158 /* Record the initialization. */
1159 TREE_VALUE (subobject_init
) = TREE_VALUE (init
);
1160 next_subobject
= subobject_init
;
1163 /* [class.base.init]
1165 If a ctor-initializer specifies more than one mem-initializer for
1166 multiple members of the same union (including members of
1167 anonymous unions), the ctor-initializer is ill-formed.
1169 Here we also splice out uninitialized union members. */
1170 if (uses_unions_or_anon_p
)
1172 tree
*last_p
= NULL
;
1174 for (p
= &sorted_inits
; *p
; )
1181 field
= TREE_PURPOSE (init
);
1183 /* Skip base classes. */
1184 if (TREE_CODE (field
) != FIELD_DECL
)
1187 /* If this is an anonymous aggregate with no explicit initializer,
1189 if (!TREE_VALUE (init
) && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
1192 /* See if this field is a member of a union, or a member of a
1193 structure contained in a union, etc. */
1194 ctx
= innermost_aggr_scope (field
);
1196 /* If this field is not a member of a union, skip it. */
1197 if (TREE_CODE (ctx
) != UNION_TYPE
1198 && !ANON_AGGR_TYPE_P (ctx
))
1201 /* If this union member has no explicit initializer and no NSDMI,
1203 if (TREE_VALUE (init
) || DECL_INITIAL (field
))
1208 /* It's only an error if we have two initializers for the same
1216 /* See if LAST_FIELD and the field initialized by INIT are
1217 members of the same union (or the union itself). If so, there's
1218 a problem, unless they're actually members of the same structure
1219 which is itself a member of a union. For example, given:
1221 union { struct { int i; int j; }; };
1223 initializing both `i' and `j' makes sense. */
1224 ctx
= common_enclosing_class
1225 (innermost_aggr_scope (field
),
1226 innermost_aggr_scope (TREE_PURPOSE (*last_p
)));
1228 if (ctx
&& (TREE_CODE (ctx
) == UNION_TYPE
1229 || ctx
== TREE_TYPE (TREE_PURPOSE (*last_p
))))
1231 /* A mem-initializer hides an NSDMI. */
1232 if (TREE_VALUE (init
) && !TREE_VALUE (*last_p
))
1233 *last_p
= TREE_CHAIN (*last_p
);
1234 else if (TREE_VALUE (*last_p
) && !TREE_VALUE (init
))
1238 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1239 "initializations for multiple members of %qT",
1248 p
= &TREE_CHAIN (*p
);
1251 *p
= TREE_CHAIN (*p
);
1256 return sorted_inits
;
1259 /* Callback for cp_walk_tree to mark all PARM_DECLs in a tree as read. */
1262 mark_exp_read_r (tree
*tp
, int *, void *)
1265 if (TREE_CODE (t
) == PARM_DECL
)
1270 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
1271 is a TREE_LIST giving the explicit mem-initializer-list for the
1272 constructor. The TREE_PURPOSE of each entry is a subobject (a
1273 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
1274 is a TREE_LIST giving the arguments to the constructor or
1275 void_type_node for an empty list of arguments. */
1278 emit_mem_initializers (tree mem_inits
)
1280 int flags
= LOOKUP_NORMAL
;
1282 /* We will already have issued an error message about the fact that
1283 the type is incomplete. */
1284 if (!COMPLETE_TYPE_P (current_class_type
))
1288 && TYPE_P (TREE_PURPOSE (mem_inits
))
1289 && same_type_p (TREE_PURPOSE (mem_inits
), current_class_type
))
1291 /* Delegating constructor. */
1292 gcc_assert (TREE_CHAIN (mem_inits
) == NULL_TREE
);
1293 perform_target_ctor (TREE_VALUE (mem_inits
));
1297 if (DECL_DEFAULTED_FN (current_function_decl
)
1298 && ! DECL_INHERITED_CTOR (current_function_decl
))
1299 flags
|= LOOKUP_DEFAULTED
;
1301 /* Sort the mem-initializers into the order in which the
1302 initializations should be performed. */
1303 mem_inits
= sort_mem_initializers (current_class_type
, mem_inits
);
1305 in_base_initializer
= 1;
1307 /* Initialize base classes. */
1309 && TREE_CODE (TREE_PURPOSE (mem_inits
)) != FIELD_DECL
);
1310 mem_inits
= TREE_CHAIN (mem_inits
))
1312 tree subobject
= TREE_PURPOSE (mem_inits
);
1313 tree arguments
= TREE_VALUE (mem_inits
);
1315 /* We already have issued an error message. */
1316 if (arguments
== error_mark_node
)
1319 /* Suppress access control when calling the inherited ctor. */
1320 bool inherited_base
= (DECL_INHERITED_CTOR (current_function_decl
)
1321 && flag_new_inheriting_ctors
1324 push_deferring_access_checks (dk_deferred
);
1326 if (arguments
== NULL_TREE
)
1328 /* If these initializations are taking place in a copy constructor,
1329 the base class should probably be explicitly initialized if there
1330 is a user-defined constructor in the base class (other than the
1331 default constructor, which will be called anyway). */
1333 && DECL_COPY_CONSTRUCTOR_P (current_function_decl
)
1334 && type_has_user_nondefault_constructor (BINFO_TYPE (subobject
)))
1335 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
1336 OPT_Wextra
, "base class %q#T should be explicitly "
1337 "initialized in the copy constructor",
1338 BINFO_TYPE (subobject
));
1341 /* Initialize the base. */
1342 if (!BINFO_VIRTUAL_P (subobject
))
1346 base_addr
= build_base_path (PLUS_EXPR
, current_class_ptr
,
1347 subobject
, 1, tf_warning_or_error
);
1348 expand_aggr_init_1 (subobject
, NULL_TREE
,
1349 cp_build_fold_indirect_ref (base_addr
),
1352 tf_warning_or_error
);
1353 expand_cleanup_for_base (subobject
, NULL_TREE
);
1355 else if (!ABSTRACT_CLASS_TYPE_P (current_class_type
))
1356 /* C++14 DR1658 Means we do not have to construct vbases of
1357 abstract classes. */
1358 construct_virtual_base (subobject
, arguments
);
1360 /* When not constructing vbases of abstract classes, at least mark
1361 the arguments expressions as read to avoid
1362 -Wunused-but-set-parameter false positives. */
1363 cp_walk_tree (&arguments
, mark_exp_read_r
, NULL
, NULL
);
1366 pop_deferring_access_checks ();
1368 in_base_initializer
= 0;
1370 /* Initialize the vptrs. */
1371 initialize_vtbl_ptrs (current_class_ptr
);
1373 /* Initialize the data members. */
1376 perform_member_init (TREE_PURPOSE (mem_inits
),
1377 TREE_VALUE (mem_inits
));
1378 mem_inits
= TREE_CHAIN (mem_inits
);
1382 /* Returns the address of the vtable (i.e., the value that should be
1383 assigned to the vptr) for BINFO. */
1386 build_vtbl_address (tree binfo
)
1388 tree binfo_for
= binfo
;
1391 if (BINFO_VPTR_INDEX (binfo
) && BINFO_VIRTUAL_P (binfo
))
1392 /* If this is a virtual primary base, then the vtable we want to store
1393 is that for the base this is being used as the primary base of. We
1394 can't simply skip the initialization, because we may be expanding the
1395 inits of a subobject constructor where the virtual base layout
1396 can be different. */
1397 while (BINFO_PRIMARY_P (binfo_for
))
1398 binfo_for
= BINFO_INHERITANCE_CHAIN (binfo_for
);
1400 /* Figure out what vtable BINFO's vtable is based on, and mark it as
1402 vtbl
= get_vtbl_decl_for_binfo (binfo_for
);
1403 TREE_USED (vtbl
) = true;
1405 /* Now compute the address to use when initializing the vptr. */
1406 vtbl
= unshare_expr (BINFO_VTABLE (binfo_for
));
1408 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
1413 /* This code sets up the virtual function tables appropriate for
1414 the pointer DECL. It is a one-ply initialization.
1416 BINFO is the exact type that DECL is supposed to be. In
1417 multiple inheritance, this might mean "C's A" if C : A, B. */
1420 expand_virtual_init (tree binfo
, tree decl
)
1422 tree vtbl
, vtbl_ptr
;
1425 /* Compute the initializer for vptr. */
1426 vtbl
= build_vtbl_address (binfo
);
1428 /* We may get this vptr from a VTT, if this is a subobject
1429 constructor or subobject destructor. */
1430 vtt_index
= BINFO_VPTR_INDEX (binfo
);
1436 /* Compute the value to use, when there's a VTT. */
1437 vtt_parm
= current_vtt_parm
;
1438 vtbl2
= fold_build_pointer_plus (vtt_parm
, vtt_index
);
1439 vtbl2
= cp_build_fold_indirect_ref (vtbl2
);
1440 vtbl2
= convert (TREE_TYPE (vtbl
), vtbl2
);
1442 /* The actual initializer is the VTT value only in the subobject
1443 constructor. In maybe_clone_body we'll substitute NULL for
1444 the vtt_parm in the case of the non-subobject constructor. */
1445 vtbl
= build_if_in_charge (vtbl
, vtbl2
);
1448 /* Compute the location of the vtpr. */
1449 vtbl_ptr
= build_vfield_ref (cp_build_fold_indirect_ref (decl
),
1451 gcc_assert (vtbl_ptr
!= error_mark_node
);
1453 /* Assign the vtable to the vptr. */
1454 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0, tf_warning_or_error
);
1455 finish_expr_stmt (cp_build_modify_expr (input_location
, vtbl_ptr
, NOP_EXPR
,
1456 vtbl
, tf_warning_or_error
));
1459 /* If an exception is thrown in a constructor, those base classes already
1460 constructed must be destroyed. This function creates the cleanup
1461 for BINFO, which has just been constructed. If FLAG is non-NULL,
1462 it is a DECL which is nonzero when this base needs to be
1466 expand_cleanup_for_base (tree binfo
, tree flag
)
1470 if (!type_build_dtor_call (BINFO_TYPE (binfo
)))
1473 /* Call the destructor. */
1474 expr
= build_special_member_call (current_class_ref
,
1475 base_dtor_identifier
,
1478 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
1479 tf_warning_or_error
);
1481 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo
)))
1485 expr
= fold_build3_loc (input_location
,
1486 COND_EXPR
, void_type_node
,
1487 c_common_truthvalue_conversion (input_location
, flag
),
1488 expr
, integer_zero_node
);
1490 finish_eh_cleanup (expr
);
1493 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
1497 construct_virtual_base (tree vbase
, tree arguments
)
1503 /* If there are virtual base classes with destructors, we need to
1504 emit cleanups to destroy them if an exception is thrown during
1505 the construction process. These exception regions (i.e., the
1506 period during which the cleanups must occur) begin from the time
1507 the construction is complete to the end of the function. If we
1508 create a conditional block in which to initialize the
1509 base-classes, then the cleanup region for the virtual base begins
1510 inside a block, and ends outside of that block. This situation
1511 confuses the sjlj exception-handling code. Therefore, we do not
1512 create a single conditional block, but one for each
1513 initialization. (That way the cleanup regions always begin
1514 in the outer block.) We trust the back end to figure out
1515 that the FLAG will not change across initializations, and
1516 avoid doing multiple tests. */
1517 flag
= DECL_CHAIN (DECL_ARGUMENTS (current_function_decl
));
1518 inner_if_stmt
= begin_if_stmt ();
1519 finish_if_stmt_cond (flag
, inner_if_stmt
);
1521 /* Compute the location of the virtual base. If we're
1522 constructing virtual bases, then we must be the most derived
1523 class. Therefore, we don't have to look up the virtual base;
1524 we already know where it is. */
1525 exp
= convert_to_base_statically (current_class_ref
, vbase
);
1527 expand_aggr_init_1 (vbase
, current_class_ref
, exp
, arguments
,
1528 0, tf_warning_or_error
);
1529 finish_then_clause (inner_if_stmt
);
1530 finish_if_stmt (inner_if_stmt
);
1532 expand_cleanup_for_base (vbase
, flag
);
1535 /* Find the context in which this FIELD can be initialized. */
1538 initializing_context (tree field
)
1540 tree t
= DECL_CONTEXT (field
);
1542 /* Anonymous union members can be initialized in the first enclosing
1543 non-anonymous union context. */
1544 while (t
&& ANON_AGGR_TYPE_P (t
))
1545 t
= TYPE_CONTEXT (t
);
1549 /* Function to give error message if member initialization specification
1550 is erroneous. FIELD is the member we decided to initialize.
1551 TYPE is the type for which the initialization is being performed.
1552 FIELD must be a member of TYPE.
1554 MEMBER_NAME is the name of the member. */
1557 member_init_ok_or_else (tree field
, tree type
, tree member_name
)
1559 if (field
== error_mark_node
)
1563 error ("class %qT does not have any field named %qD", type
,
1569 error ("%q#D is a static data member; it can only be "
1570 "initialized at its definition",
1574 if (TREE_CODE (field
) != FIELD_DECL
)
1576 error ("%q#D is not a non-static data member of %qT",
1580 if (initializing_context (field
) != type
)
1582 error ("class %qT does not have any field named %qD", type
,
1590 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1591 is a _TYPE node or TYPE_DECL which names a base for that type.
1592 Check the validity of NAME, and return either the base _TYPE, base
1593 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
1594 NULL_TREE and issue a diagnostic.
1596 An old style unnamed direct single base construction is permitted,
1597 where NAME is NULL. */
1600 expand_member_init (tree name
)
1605 if (!current_class_ref
)
1610 /* This is an obsolete unnamed base class initializer. The
1611 parser will already have warned about its use. */
1612 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type
)))
1615 error ("unnamed initializer for %qT, which has no base classes",
1616 current_class_type
);
1619 basetype
= BINFO_TYPE
1620 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type
), 0));
1623 error ("unnamed initializer for %qT, which uses multiple inheritance",
1624 current_class_type
);
1628 else if (TYPE_P (name
))
1630 basetype
= TYPE_MAIN_VARIANT (name
);
1631 name
= TYPE_NAME (name
);
1633 else if (TREE_CODE (name
) == TYPE_DECL
)
1634 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (name
));
1636 basetype
= NULL_TREE
;
1645 if (current_template_parms
1646 || same_type_p (basetype
, current_class_type
))
1649 class_binfo
= TYPE_BINFO (current_class_type
);
1650 direct_binfo
= NULL_TREE
;
1651 virtual_binfo
= NULL_TREE
;
1653 /* Look for a direct base. */
1654 for (i
= 0; BINFO_BASE_ITERATE (class_binfo
, i
, direct_binfo
); ++i
)
1655 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo
), basetype
))
1658 /* Look for a virtual base -- unless the direct base is itself
1660 if (!direct_binfo
|| !BINFO_VIRTUAL_P (direct_binfo
))
1661 virtual_binfo
= binfo_for_vbase (basetype
, current_class_type
);
1663 /* [class.base.init]
1665 If a mem-initializer-id is ambiguous because it designates
1666 both a direct non-virtual base class and an inherited virtual
1667 base class, the mem-initializer is ill-formed. */
1668 if (direct_binfo
&& virtual_binfo
)
1670 error ("%qD is both a direct base and an indirect virtual base",
1675 if (!direct_binfo
&& !virtual_binfo
)
1677 if (CLASSTYPE_VBASECLASSES (current_class_type
))
1678 error ("type %qT is not a direct or virtual base of %qT",
1679 basetype
, current_class_type
);
1681 error ("type %qT is not a direct base of %qT",
1682 basetype
, current_class_type
);
1686 return direct_binfo
? direct_binfo
: virtual_binfo
;
1690 if (identifier_p (name
))
1691 field
= lookup_field (current_class_type
, name
, 1, false);
1695 if (member_init_ok_or_else (field
, current_class_type
, name
))
1702 /* This is like `expand_member_init', only it stores one aggregate
1705 INIT comes in two flavors: it is either a value which
1706 is to be stored in EXP, or it is a parameter list
1707 to go to a constructor, which will operate on EXP.
1708 If INIT is not a parameter list for a constructor, then set
1709 LOOKUP_ONLYCONVERTING.
1710 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1711 the initializer, if FLAGS is 0, then it is the (init) form.
1712 If `init' is a CONSTRUCTOR, then we emit a warning message,
1713 explaining that such initializations are invalid.
1715 If INIT resolves to a CALL_EXPR which happens to return
1716 something of the type we are looking for, then we know
1717 that we can safely use that call to perform the
1720 The virtual function table pointer cannot be set up here, because
1721 we do not really know its type.
1723 This never calls operator=().
1725 When initializing, nothing is CONST.
1727 A default copy constructor may have to be used to perform the
1730 A constructor or a conversion operator may have to be used to
1731 perform the initialization, but not both, as it would be ambiguous. */
1734 build_aggr_init (tree exp
, tree init
, int flags
, tsubst_flags_t complain
)
1739 tree type
= TREE_TYPE (exp
);
1740 int was_const
= TREE_READONLY (exp
);
1741 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1744 if (init
== error_mark_node
)
1745 return error_mark_node
;
1747 location_t init_loc
= (init
1748 ? cp_expr_loc_or_input_loc (init
)
1749 : location_of (exp
));
1751 TREE_READONLY (exp
) = 0;
1752 TREE_THIS_VOLATILE (exp
) = 0;
1754 if (TREE_CODE (type
) == ARRAY_TYPE
)
1756 tree itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1759 if (VAR_P (exp
) && DECL_DECOMPOSITION_P (exp
))
1762 init
= mark_rvalue_use (init
);
1764 && DECL_P (tree_strip_any_location_wrapper (init
))
1765 && !(flags
& LOOKUP_ONLYCONVERTING
))
1767 /* Wrap the initializer in a CONSTRUCTOR so that build_vec_init
1768 recognizes it as direct-initialization. */
1769 init
= build_constructor_single (init_list_type_node
,
1771 CONSTRUCTOR_IS_DIRECT_INIT (init
) = true;
1776 /* Must arrange to initialize each element of EXP
1777 from elements of INIT. */
1778 if (cv_qualified_p (type
))
1779 TREE_TYPE (exp
) = cv_unqualified (type
);
1780 if (itype
&& cv_qualified_p (itype
))
1781 TREE_TYPE (init
) = cv_unqualified (itype
);
1782 from_array
= (itype
&& same_type_p (TREE_TYPE (init
),
1785 if (init
&& !BRACE_ENCLOSED_INITIALIZER_P (init
)
1787 || (TREE_CODE (init
) != CONSTRUCTOR
1788 /* Can happen, eg, handling the compound-literals
1789 extension (ext/complit12.C). */
1790 && TREE_CODE (init
) != TARGET_EXPR
)))
1792 if (complain
& tf_error
)
1793 error_at (init_loc
, "array must be initialized "
1794 "with a brace-enclosed initializer");
1795 return error_mark_node
;
1799 stmt_expr
= build_vec_init (exp
, NULL_TREE
, init
,
1800 /*explicit_value_init_p=*/false,
1803 TREE_READONLY (exp
) = was_const
;
1804 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1805 TREE_TYPE (exp
) = type
;
1806 /* Restore the type of init unless it was used directly. */
1807 if (init
&& TREE_CODE (stmt_expr
) != INIT_EXPR
)
1808 TREE_TYPE (init
) = itype
;
1812 if (init
&& init
!= void_type_node
1813 && TREE_CODE (init
) != TREE_LIST
1814 && !(TREE_CODE (init
) == TARGET_EXPR
1815 && TARGET_EXPR_DIRECT_INIT_P (init
))
1816 && !DIRECT_LIST_INIT_P (init
))
1817 flags
|= LOOKUP_ONLYCONVERTING
;
1819 is_global
= begin_init_stmts (&stmt_expr
, &compound_stmt
);
1820 destroy_temps
= stmts_are_full_exprs_p ();
1821 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
1822 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1823 init
, LOOKUP_NORMAL
|flags
, complain
);
1824 stmt_expr
= finish_init_stmts (is_global
, stmt_expr
, compound_stmt
);
1825 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
1826 TREE_READONLY (exp
) = was_const
;
1827 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1829 if ((VAR_P (exp
) || TREE_CODE (exp
) == PARM_DECL
)
1830 && TREE_SIDE_EFFECTS (stmt_expr
)
1831 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (type
)))
1832 /* Just know that we've seen something for this node. */
1833 TREE_USED (exp
) = 1;
1839 expand_default_init (tree binfo
, tree true_exp
, tree exp
, tree init
, int flags
,
1840 tsubst_flags_t complain
)
1842 tree type
= TREE_TYPE (exp
);
1844 /* It fails because there may not be a constructor which takes
1845 its own type as the first (or only parameter), but which does
1846 take other types via a conversion. So, if the thing initializing
1847 the expression is a unit element of type X, first try X(X&),
1848 followed by initialization by X. If neither of these work
1849 out, then look hard. */
1851 vec
<tree
, va_gc
> *parms
;
1853 /* If we have direct-initialization from an initializer list, pull
1854 it out of the TREE_LIST so the code below can see it. */
1855 if (init
&& TREE_CODE (init
) == TREE_LIST
1856 && DIRECT_LIST_INIT_P (TREE_VALUE (init
)))
1858 gcc_checking_assert ((flags
& LOOKUP_ONLYCONVERTING
) == 0
1859 && TREE_CHAIN (init
) == NULL_TREE
);
1860 init
= TREE_VALUE (init
);
1861 /* Only call reshape_init if it has not been called earlier
1863 if (BRACE_ENCLOSED_INITIALIZER_P (init
) && CP_AGGREGATE_TYPE_P (type
))
1864 init
= reshape_init (type
, init
, complain
);
1867 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
1868 && CP_AGGREGATE_TYPE_P (type
))
1869 /* A brace-enclosed initializer for an aggregate. In C++0x this can
1870 happen for direct-initialization, too. */
1871 init
= digest_init (type
, init
, complain
);
1873 /* A CONSTRUCTOR of the target's type is a previously digested
1874 initializer, whether that happened just above or in
1875 cp_parser_late_parsing_nsdmi.
1877 A TARGET_EXPR with TARGET_EXPR_DIRECT_INIT_P or TARGET_EXPR_LIST_INIT_P
1878 set represents the whole initialization, so we shouldn't build up
1879 another ctor call. */
1881 && (TREE_CODE (init
) == CONSTRUCTOR
1882 || (TREE_CODE (init
) == TARGET_EXPR
1883 && (TARGET_EXPR_DIRECT_INIT_P (init
)
1884 || TARGET_EXPR_LIST_INIT_P (init
))))
1885 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (init
), type
))
1887 /* Early initialization via a TARGET_EXPR only works for
1888 complete objects. */
1889 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
|| true_exp
== exp
);
1891 init
= build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1892 TREE_SIDE_EFFECTS (init
) = 1;
1893 finish_expr_stmt (init
);
1897 if (init
&& TREE_CODE (init
) != TREE_LIST
1898 && (flags
& LOOKUP_ONLYCONVERTING
))
1900 /* Base subobjects should only get direct-initialization. */
1901 gcc_assert (true_exp
== exp
);
1903 if (flags
& DIRECT_BIND
)
1904 /* Do nothing. We hit this in two cases: Reference initialization,
1905 where we aren't initializing a real variable, so we don't want
1906 to run a new constructor; and catching an exception, where we
1907 have already built up the constructor call so we could wrap it
1908 in an exception region. */;
1910 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
,
1913 if (TREE_CODE (init
) == MUST_NOT_THROW_EXPR
)
1914 /* We need to protect the initialization of a catch parm with a
1915 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1916 around the TARGET_EXPR for the copy constructor. See
1917 initialize_handler_parm. */
1919 TREE_OPERAND (init
, 0) = build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
,
1920 TREE_OPERAND (init
, 0));
1921 TREE_TYPE (init
) = void_type_node
;
1924 init
= build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1925 TREE_SIDE_EFFECTS (init
) = 1;
1926 finish_expr_stmt (init
);
1930 if (init
== NULL_TREE
)
1932 else if (TREE_CODE (init
) == TREE_LIST
&& !TREE_TYPE (init
))
1934 parms
= make_tree_vector ();
1935 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
1936 vec_safe_push (parms
, TREE_VALUE (init
));
1939 parms
= make_tree_vector_single (init
);
1941 if (exp
== current_class_ref
&& current_function_decl
1942 && DECL_HAS_IN_CHARGE_PARM_P (current_function_decl
))
1944 /* Delegating constructor. */
1947 tree elt
; unsigned i
;
1949 /* Unshare the arguments for the second call. */
1950 releasing_vec parms2
;
1951 FOR_EACH_VEC_SAFE_ELT (parms
, i
, elt
)
1953 elt
= break_out_target_exprs (elt
);
1954 vec_safe_push (parms2
, elt
);
1956 complete
= build_special_member_call (exp
, complete_ctor_identifier
,
1957 &parms2
, binfo
, flags
,
1959 complete
= fold_build_cleanup_point_expr (void_type_node
, complete
);
1961 base
= build_special_member_call (exp
, base_ctor_identifier
,
1962 &parms
, binfo
, flags
,
1964 base
= fold_build_cleanup_point_expr (void_type_node
, base
);
1965 rval
= build_if_in_charge (complete
, base
);
1969 tree ctor_name
= (true_exp
== exp
1970 ? complete_ctor_identifier
: base_ctor_identifier
);
1972 rval
= build_special_member_call (exp
, ctor_name
, &parms
, binfo
, flags
,
1977 release_tree_vector (parms
);
1979 if (exp
== true_exp
&& TREE_CODE (rval
) == CALL_EXPR
)
1981 tree fn
= get_callee_fndecl (rval
);
1982 if (fn
&& DECL_DECLARED_CONSTEXPR_P (fn
))
1984 tree e
= maybe_constant_init (rval
, exp
);
1985 if (TREE_CONSTANT (e
))
1986 rval
= build2 (INIT_EXPR
, type
, exp
, e
);
1990 /* FIXME put back convert_to_void? */
1991 if (TREE_SIDE_EFFECTS (rval
))
1992 finish_expr_stmt (rval
);
1995 /* This function is responsible for initializing EXP with INIT
1998 BINFO is the binfo of the type for who we are performing the
1999 initialization. For example, if W is a virtual base class of A and B,
2001 If we are initializing B, then W must contain B's W vtable, whereas
2002 were we initializing C, W must contain C's W vtable.
2004 TRUE_EXP is nonzero if it is the true expression being initialized.
2005 In this case, it may be EXP, or may just contain EXP. The reason we
2006 need this is because if EXP is a base element of TRUE_EXP, we
2007 don't necessarily know by looking at EXP where its virtual
2008 baseclass fields should really be pointing. But we do know
2009 from TRUE_EXP. In constructors, we don't know anything about
2010 the value being initialized.
2012 FLAGS is just passed to `build_new_method_call'. See that function
2013 for its description. */
2016 expand_aggr_init_1 (tree binfo
, tree true_exp
, tree exp
, tree init
, int flags
,
2017 tsubst_flags_t complain
)
2019 tree type
= TREE_TYPE (exp
);
2021 gcc_assert (init
!= error_mark_node
&& type
!= error_mark_node
);
2022 gcc_assert (building_stmt_list_p ());
2024 /* Use a function returning the desired type to initialize EXP for us.
2025 If the function is a constructor, and its first argument is
2026 NULL_TREE, know that it was meant for us--just slide exp on
2027 in and expand the constructor. Constructors now come
2030 if (init
&& VAR_P (exp
)
2031 && COMPOUND_LITERAL_P (init
))
2033 vec
<tree
, va_gc
> *cleanups
= NULL
;
2034 /* If store_init_value returns NULL_TREE, the INIT has been
2035 recorded as the DECL_INITIAL for EXP. That means there's
2036 nothing more we have to do. */
2037 init
= store_init_value (exp
, init
, &cleanups
, flags
);
2039 finish_expr_stmt (init
);
2040 gcc_assert (!cleanups
);
2044 /* List-initialization from {} becomes value-initialization for non-aggregate
2045 classes with default constructors. Handle this here when we're
2046 initializing a base, so protected access works. */
2047 if (exp
!= true_exp
&& init
&& TREE_CODE (init
) == TREE_LIST
)
2049 tree elt
= TREE_VALUE (init
);
2050 if (DIRECT_LIST_INIT_P (elt
)
2051 && CONSTRUCTOR_ELTS (elt
) == 0
2052 && CLASSTYPE_NON_AGGREGATE (type
)
2053 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2054 init
= void_type_node
;
2057 /* If an explicit -- but empty -- initializer list was present,
2058 that's value-initialization. */
2059 if (init
== void_type_node
)
2061 /* If the type has data but no user-provided ctor, we need to zero
2063 if (!type_has_user_provided_constructor (type
)
2064 && !is_really_empty_class (type
, /*ignore_vptr*/true))
2066 tree field_size
= NULL_TREE
;
2067 if (exp
!= true_exp
&& CLASSTYPE_AS_BASE (type
) != type
)
2068 /* Don't clobber already initialized virtual bases. */
2069 field_size
= TYPE_SIZE (CLASSTYPE_AS_BASE (type
));
2070 init
= build_zero_init_1 (type
, NULL_TREE
, /*static_storage_p=*/false,
2072 init
= build2 (INIT_EXPR
, type
, exp
, init
);
2073 finish_expr_stmt (init
);
2076 /* If we don't need to mess with the constructor at all,
2078 if (! type_build_ctor_call (type
))
2081 /* Otherwise fall through and call the constructor. */
2085 /* We know that expand_default_init can handle everything we want
2087 expand_default_init (binfo
, true_exp
, exp
, init
, flags
, complain
);
2090 /* Report an error if TYPE is not a user-defined, class type. If
2091 OR_ELSE is nonzero, give an error message. */
2094 is_class_type (tree type
, int or_else
)
2096 if (type
== error_mark_node
)
2099 if (! CLASS_TYPE_P (type
))
2102 error ("%qT is not a class type", type
);
2109 get_type_value (tree name
)
2111 if (name
== error_mark_node
)
2114 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
2115 return IDENTIFIER_TYPE_VALUE (name
);
2120 /* Build a reference to a member of an aggregate. This is not a C++
2121 `&', but really something which can have its address taken, and
2122 then act as a pointer to member, for example TYPE :: FIELD can have
2123 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
2124 this expression is the operand of "&".
2126 @@ Prints out lousy diagnostics for operator <typename>
2129 @@ This function should be rewritten and placed in search.c. */
2132 build_offset_ref (tree type
, tree member
, bool address_p
,
2133 tsubst_flags_t complain
)
2136 tree basebinfo
= NULL_TREE
;
2138 /* class templates can come in as TEMPLATE_DECLs here. */
2139 if (TREE_CODE (member
) == TEMPLATE_DECL
)
2142 if (dependent_scope_p (type
) || type_dependent_expression_p (member
))
2143 return build_qualified_name (NULL_TREE
, type
, member
,
2144 /*template_p=*/false);
2146 gcc_assert (TYPE_P (type
));
2147 if (! is_class_type (type
, 1))
2148 return error_mark_node
;
2150 gcc_assert (DECL_P (member
) || BASELINK_P (member
));
2151 /* Callers should call mark_used before this point. */
2152 gcc_assert (!DECL_P (member
) || TREE_USED (member
));
2154 type
= TYPE_MAIN_VARIANT (type
);
2155 if (!COMPLETE_OR_OPEN_TYPE_P (complete_type (type
)))
2157 if (complain
& tf_error
)
2158 error ("incomplete type %qT does not have member %qD", type
, member
);
2159 return error_mark_node
;
2162 /* Entities other than non-static members need no further
2164 if (TREE_CODE (member
) == TYPE_DECL
)
2166 if (VAR_P (member
) || TREE_CODE (member
) == CONST_DECL
)
2167 return convert_from_reference (member
);
2169 if (TREE_CODE (member
) == FIELD_DECL
&& DECL_C_BIT_FIELD (member
))
2171 if (complain
& tf_error
)
2172 error ("invalid pointer to bit-field %qD", member
);
2173 return error_mark_node
;
2176 /* Set up BASEBINFO for member lookup. */
2177 decl
= maybe_dummy_object (type
, &basebinfo
);
2179 /* A lot of this logic is now handled in lookup_member. */
2180 if (BASELINK_P (member
))
2182 /* Go from the TREE_BASELINK to the member function info. */
2183 tree t
= BASELINK_FUNCTIONS (member
);
2185 if (TREE_CODE (t
) != TEMPLATE_ID_EXPR
&& !really_overloaded_fn (t
))
2187 /* Get rid of a potential OVERLOAD around it. */
2190 /* Unique functions are handled easily. */
2192 /* For non-static member of base class, we need a special rule
2193 for access checking [class.protected]:
2195 If the access is to form a pointer to member, the
2196 nested-name-specifier shall name the derived class
2197 (or any class derived from that class). */
2199 if (address_p
&& DECL_P (t
)
2200 && DECL_NONSTATIC_MEMBER_P (t
))
2201 ok
= perform_or_defer_access_check (TYPE_BINFO (type
), t
, t
,
2204 ok
= perform_or_defer_access_check (basebinfo
, t
, t
,
2207 return error_mark_node
;
2208 if (DECL_STATIC_FUNCTION_P (t
))
2213 TREE_TYPE (member
) = unknown_type_node
;
2215 else if (address_p
&& TREE_CODE (member
) == FIELD_DECL
)
2217 /* We need additional test besides the one in
2218 check_accessibility_of_qualified_id in case it is
2219 a pointer to non-static member. */
2220 if (!perform_or_defer_access_check (TYPE_BINFO (type
), member
, member
,
2222 return error_mark_node
;
2227 /* If MEMBER is non-static, then the program has fallen afoul of
2230 An id-expression that denotes a nonstatic data member or
2231 nonstatic member function of a class can only be used:
2233 -- as part of a class member access (_expr.ref_) in which the
2234 object-expression refers to the member's class or a class
2235 derived from that class, or
2237 -- to form a pointer to member (_expr.unary.op_), or
2239 -- in the body of a nonstatic member function of that class or
2240 of a class derived from that class (_class.mfct.nonstatic_), or
2242 -- in a mem-initializer for a constructor for that class or for
2243 a class derived from that class (_class.base.init_). */
2244 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member
))
2246 /* Build a representation of the qualified name suitable
2247 for use as the operand to "&" -- even though the "&" is
2248 not actually present. */
2249 member
= build2 (OFFSET_REF
, TREE_TYPE (member
), decl
, member
);
2250 /* In Microsoft mode, treat a non-static member function as if
2251 it were a pointer-to-member. */
2252 if (flag_ms_extensions
)
2254 PTRMEM_OK_P (member
) = 1;
2255 return cp_build_addr_expr (member
, complain
);
2257 if (complain
& tf_error
)
2258 error ("invalid use of non-static member function %qD",
2259 TREE_OPERAND (member
, 1));
2260 return error_mark_node
;
2262 else if (TREE_CODE (member
) == FIELD_DECL
)
2264 if (complain
& tf_error
)
2265 error ("invalid use of non-static data member %qD", member
);
2266 return error_mark_node
;
2271 member
= build2 (OFFSET_REF
, TREE_TYPE (member
), decl
, member
);
2272 PTRMEM_OK_P (member
) = 1;
2276 /* If DECL is a scalar enumeration constant or variable with a
2277 constant initializer, return the initializer (or, its initializers,
2278 recursively); otherwise, return DECL. If STRICT_P, the
2279 initializer is only returned if DECL is a
2280 constant-expression. If RETURN_AGGREGATE_CST_OK_P, it is ok to
2281 return an aggregate constant. */
2284 constant_value_1 (tree decl
, bool strict_p
, bool return_aggregate_cst_ok_p
)
2286 while (TREE_CODE (decl
) == CONST_DECL
2287 || decl_constant_var_p (decl
)
2288 || (!strict_p
&& VAR_P (decl
)
2289 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl
))))
2292 /* If DECL is a static data member in a template
2293 specialization, we must instantiate it here. The
2294 initializer for the static data member is not processed
2295 until needed; we need it now. */
2296 mark_used (decl
, tf_none
);
2297 init
= DECL_INITIAL (decl
);
2298 if (init
== error_mark_node
)
2300 if (TREE_CODE (decl
) == CONST_DECL
2301 || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
))
2302 /* Treat the error as a constant to avoid cascading errors on
2303 excessively recursive template instantiation (c++/9335). */
2308 /* Initializers in templates are generally expanded during
2309 instantiation, so before that for const int i(2)
2310 INIT is a TREE_LIST with the actual initializer as
2312 if (processing_template_decl
2314 && TREE_CODE (init
) == TREE_LIST
2315 && TREE_CHAIN (init
) == NULL_TREE
)
2316 init
= TREE_VALUE (init
);
2317 /* Instantiate a non-dependent initializer for user variables. We
2318 mustn't do this for the temporary for an array compound literal;
2319 trying to instatiate the initializer will keep creating new
2320 temporaries until we crash. Probably it's not useful to do it for
2321 other artificial variables, either. */
2322 if (!DECL_ARTIFICIAL (decl
))
2323 init
= instantiate_non_dependent_or_null (init
);
2325 || !TREE_TYPE (init
)
2326 || !TREE_CONSTANT (init
)
2327 || (!return_aggregate_cst_ok_p
2328 /* Unless RETURN_AGGREGATE_CST_OK_P is true, do not
2329 return an aggregate constant (of which string
2330 literals are a special case), as we do not want
2331 to make inadvertent copies of such entities, and
2332 we must be sure that their addresses are the
2334 && (TREE_CODE (init
) == CONSTRUCTOR
2335 || TREE_CODE (init
) == STRING_CST
)))
2337 /* Don't return a CONSTRUCTOR for a variable with partial run-time
2338 initialization, since it doesn't represent the entire value.
2339 Similarly for VECTOR_CSTs created by cp_folding those
2341 if ((TREE_CODE (init
) == CONSTRUCTOR
2342 || TREE_CODE (init
) == VECTOR_CST
)
2343 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
))
2345 /* If the variable has a dynamic initializer, don't use its
2346 DECL_INITIAL which doesn't reflect the real value. */
2348 && TREE_STATIC (decl
)
2349 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
)
2350 && DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
2352 decl
= unshare_expr (init
);
2357 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by constant
2358 of integral or enumeration type, or a constexpr variable of scalar type,
2359 then return that value. These are those variables permitted in constant
2360 expressions by [5.19/1]. */
2363 scalar_constant_value (tree decl
)
2365 return constant_value_1 (decl
, /*strict_p=*/true,
2366 /*return_aggregate_cst_ok_p=*/false);
2369 /* Like scalar_constant_value, but can also return aggregate initializers. */
2372 decl_really_constant_value (tree decl
)
2374 return constant_value_1 (decl
, /*strict_p=*/true,
2375 /*return_aggregate_cst_ok_p=*/true);
2378 /* A more relaxed version of scalar_constant_value, used by the
2379 common C/C++ code. */
2382 decl_constant_value (tree decl
)
2384 return constant_value_1 (decl
, /*strict_p=*/processing_template_decl
,
2385 /*return_aggregate_cst_ok_p=*/true);
2388 /* Common subroutines of build_new and build_vec_delete. */
2390 /* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
2391 the type of the object being allocated; otherwise, it's just TYPE.
2392 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
2393 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
2394 a vector of arguments to be provided as arguments to a placement
2395 new operator. This routine performs no semantic checks; it just
2396 creates and returns a NEW_EXPR. */
2399 build_raw_new_expr (vec
<tree
, va_gc
> *placement
, tree type
, tree nelts
,
2400 vec
<tree
, va_gc
> *init
, int use_global_new
)
2405 /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR.
2406 If INIT is not NULL, then we want to store VOID_ZERO_NODE. This
2407 permits us to distinguish the case of a missing initializer "new
2408 int" from an empty initializer "new int()". */
2410 init_list
= NULL_TREE
;
2411 else if (init
->is_empty ())
2412 init_list
= void_node
;
2414 init_list
= build_tree_list_vec (init
);
2416 new_expr
= build4 (NEW_EXPR
, build_pointer_type (type
),
2417 build_tree_list_vec (placement
), type
, nelts
,
2419 NEW_EXPR_USE_GLOBAL (new_expr
) = use_global_new
;
2420 TREE_SIDE_EFFECTS (new_expr
) = 1;
2425 /* Diagnose uninitialized const members or reference members of type
2426 TYPE. USING_NEW is used to disambiguate the diagnostic between a
2427 new expression without a new-initializer and a declaration. Returns
2431 diagnose_uninitialized_cst_or_ref_member_1 (tree type
, tree origin
,
2432 bool using_new
, bool complain
)
2435 int error_count
= 0;
2437 if (type_has_user_provided_constructor (type
))
2440 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2444 if (TREE_CODE (field
) != FIELD_DECL
)
2447 field_type
= strip_array_types (TREE_TYPE (field
));
2449 if (type_has_user_provided_constructor (field_type
))
2452 if (TYPE_REF_P (field_type
))
2457 if (DECL_CONTEXT (field
) == origin
)
2460 error ("uninitialized reference member in %q#T "
2461 "using %<new%> without new-initializer", origin
);
2463 error ("uninitialized reference member in %q#T", origin
);
2468 error ("uninitialized reference member in base %q#T "
2469 "of %q#T using %<new%> without new-initializer",
2470 DECL_CONTEXT (field
), origin
);
2472 error ("uninitialized reference member in base %q#T "
2473 "of %q#T", DECL_CONTEXT (field
), origin
);
2475 inform (DECL_SOURCE_LOCATION (field
),
2476 "%q#D should be initialized", field
);
2480 if (CP_TYPE_CONST_P (field_type
))
2485 if (DECL_CONTEXT (field
) == origin
)
2488 error ("uninitialized const member in %q#T "
2489 "using %<new%> without new-initializer", origin
);
2491 error ("uninitialized const member in %q#T", origin
);
2496 error ("uninitialized const member in base %q#T "
2497 "of %q#T using %<new%> without new-initializer",
2498 DECL_CONTEXT (field
), origin
);
2500 error ("uninitialized const member in base %q#T "
2501 "of %q#T", DECL_CONTEXT (field
), origin
);
2503 inform (DECL_SOURCE_LOCATION (field
),
2504 "%q#D should be initialized", field
);
2508 if (CLASS_TYPE_P (field_type
))
2510 += diagnose_uninitialized_cst_or_ref_member_1 (field_type
, origin
,
2511 using_new
, complain
);
2517 diagnose_uninitialized_cst_or_ref_member (tree type
, bool using_new
, bool complain
)
2519 return diagnose_uninitialized_cst_or_ref_member_1 (type
, type
, using_new
, complain
);
2522 /* Call __cxa_bad_array_new_length to indicate that the size calculation
2523 overflowed. Pretend it returns sizetype so that it plays nicely in the
2527 throw_bad_array_new_length (void)
2531 tree name
= get_identifier ("__cxa_throw_bad_array_new_length");
2533 fn
= get_global_binding (name
);
2535 fn
= push_throw_library_fn
2536 (name
, build_function_type_list (sizetype
, NULL_TREE
));
2539 return build_cxx_call (fn
, 0, NULL
, tf_warning_or_error
);
2542 /* Attempt to find the initializer for flexible array field T in the
2543 initializer INIT, when non-null. Returns the initializer when
2544 successful and NULL otherwise. */
2546 find_flexarray_init (tree t
, tree init
)
2548 if (!init
|| init
== error_mark_node
)
2551 unsigned HOST_WIDE_INT idx
;
2554 /* Iterate over all top-level initializer elements. */
2555 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
, field
, elt
)
2556 /* If the member T is found, return it. */
2563 /* Attempt to verify that the argument, OPER, of a placement new expression
2564 refers to an object sufficiently large for an object of TYPE or an array
2565 of NELTS of such objects when NELTS is non-null, and issue a warning when
2566 it does not. SIZE specifies the size needed to construct the object or
2567 array and captures the result of NELTS * sizeof (TYPE). (SIZE could be
2568 greater when the array under construction requires a cookie to store
2569 NELTS. GCC's placement new expression stores the cookie when invoking
2570 a user-defined placement new operator function but not the default one.
2571 Placement new expressions with user-defined placement new operator are
2572 not diagnosed since we don't know how they use the buffer (this could
2573 be a future extension). */
2575 warn_placement_new_too_small (tree type
, tree nelts
, tree size
, tree oper
)
2577 location_t loc
= cp_expr_loc_or_input_loc (oper
);
2579 /* The number of bytes to add to or subtract from the size of the provided
2580 buffer based on an offset into an array or an array element reference.
2581 Although intermediate results may be negative (as in a[3] - 2) a valid
2582 final result cannot be. */
2583 offset_int adjust
= 0;
2584 /* True when the size of the entire destination object should be used
2585 to compute the possibly optimistic estimate of the available space. */
2586 bool use_obj_size
= false;
2587 /* True when the reference to the destination buffer is an ADDR_EXPR. */
2588 bool addr_expr
= false;
2592 /* Using a function argument or a (non-array) variable as an argument
2593 to placement new is not checked since it's unknown what it might
2595 if (TREE_CODE (oper
) == PARM_DECL
2597 || TREE_CODE (oper
) == COMPONENT_REF
)
2600 /* Evaluate any constant expressions. */
2601 size
= fold_non_dependent_expr (size
);
2603 /* Handle the common case of array + offset expression when the offset
2605 if (TREE_CODE (oper
) == POINTER_PLUS_EXPR
)
2607 /* If the offset is compile-time constant, use it to compute a more
2608 accurate estimate of the size of the buffer. Since the operand
2609 of POINTER_PLUS_EXPR is represented as an unsigned type, convert
2611 Otherwise, use the size of the entire array as an optimistic
2612 estimate (this may lead to false negatives). */
2613 tree adj
= TREE_OPERAND (oper
, 1);
2614 adj
= fold_for_warn (adj
);
2615 if (CONSTANT_CLASS_P (adj
))
2616 adjust
+= wi::to_offset (convert (ssizetype
, adj
));
2618 use_obj_size
= true;
2620 oper
= TREE_OPERAND (oper
, 0);
2625 if (TREE_CODE (oper
) == TARGET_EXPR
)
2626 oper
= TREE_OPERAND (oper
, 1);
2627 else if (TREE_CODE (oper
) == ADDR_EXPR
)
2630 oper
= TREE_OPERAND (oper
, 0);
2635 if (TREE_CODE (oper
) == ARRAY_REF
2636 && (addr_expr
|| TREE_CODE (TREE_TYPE (oper
)) == ARRAY_TYPE
))
2638 /* Similar to the offset computed above, see if the array index
2639 is a compile-time constant. If so, and unless the offset was
2640 not a compile-time constant, use the index to determine the
2641 size of the buffer. Otherwise, use the entire array as
2642 an optimistic estimate of the size. */
2643 const_tree adj
= fold_non_dependent_expr (TREE_OPERAND (oper
, 1));
2644 if (!use_obj_size
&& CONSTANT_CLASS_P (adj
))
2645 adjust
+= wi::to_offset (adj
);
2648 use_obj_size
= true;
2652 oper
= TREE_OPERAND (oper
, 0);
2655 /* Refers to the declared object that constains the subobject referenced
2656 by OPER. When the object is initialized, makes it possible to determine
2657 the actual size of a flexible array member used as the buffer passed
2658 as OPER to placement new. */
2659 tree var_decl
= NULL_TREE
;
2660 /* True when operand is a COMPONENT_REF, to distinguish flexible array
2661 members from arrays of unspecified size. */
2662 bool compref
= TREE_CODE (oper
) == COMPONENT_REF
;
2664 /* For COMPONENT_REF (i.e., a struct member) the size of the entire
2665 enclosing struct. Used to validate the adjustment (offset) into
2666 an array at the end of a struct. */
2667 offset_int compsize
= 0;
2669 /* Descend into a struct or union to find the member whose address
2670 is being used as the argument. */
2671 if (TREE_CODE (oper
) == COMPONENT_REF
)
2673 tree comptype
= TREE_TYPE (TREE_OPERAND (oper
, 0));
2674 compsize
= wi::to_offset (TYPE_SIZE_UNIT (comptype
));
2677 while (TREE_CODE (op0
= TREE_OPERAND (op0
, 0)) == COMPONENT_REF
);
2678 STRIP_ANY_LOCATION_WRAPPER (op0
);
2681 oper
= TREE_OPERAND (oper
, 1);
2684 STRIP_ANY_LOCATION_WRAPPER (oper
);
2685 tree opertype
= TREE_TYPE (oper
);
2686 if ((addr_expr
|| !INDIRECT_TYPE_P (opertype
))
2688 || TREE_CODE (oper
) == FIELD_DECL
2689 || TREE_CODE (oper
) == PARM_DECL
))
2691 /* A possibly optimistic estimate of the number of bytes available
2692 in the destination buffer. */
2693 offset_int bytes_avail
= 0;
2694 /* True when the estimate above is in fact the exact size
2695 of the destination buffer rather than an estimate. */
2696 bool exact_size
= true;
2698 /* Treat members of unions and members of structs uniformly, even
2699 though the size of a member of a union may be viewed as extending
2700 to the end of the union itself (it is by __builtin_object_size). */
2701 if ((VAR_P (oper
) || use_obj_size
)
2702 && DECL_SIZE_UNIT (oper
)
2703 && tree_fits_uhwi_p (DECL_SIZE_UNIT (oper
)))
2705 /* Use the size of the entire array object when the expression
2706 refers to a variable or its size depends on an expression
2707 that's not a compile-time constant. */
2708 bytes_avail
= wi::to_offset (DECL_SIZE_UNIT (oper
));
2709 exact_size
= !use_obj_size
;
2711 else if (tree opersize
= TYPE_SIZE_UNIT (opertype
))
2713 /* Use the size of the type of the destination buffer object
2714 as the optimistic estimate of the available space in it.
2715 Use the maximum possible size for zero-size arrays and
2716 flexible array members (except of initialized objects
2718 if (TREE_CODE (opersize
) == INTEGER_CST
)
2719 bytes_avail
= wi::to_offset (opersize
);
2722 if (bytes_avail
== 0)
2726 /* Constructing into a buffer provided by the flexible array
2727 member of a declared object (which is permitted as a G++
2728 extension). If the array member has been initialized,
2729 determine its size from the initializer. Otherwise,
2730 the array size is zero. */
2731 if (tree init
= find_flexarray_init (oper
,
2732 DECL_INITIAL (var_decl
)))
2733 bytes_avail
= wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (init
)));
2736 bytes_avail
= (wi::to_offset (TYPE_MAX_VALUE (ptrdiff_type_node
))
2740 tree_code oper_code
= TREE_CODE (opertype
);
2742 if (compref
&& oper_code
== ARRAY_TYPE
)
2744 tree nelts
= array_type_nelts_top (opertype
);
2745 tree nelts_cst
= maybe_constant_value (nelts
);
2746 if (TREE_CODE (nelts_cst
) == INTEGER_CST
2747 && integer_onep (nelts_cst
)
2749 && warn_placement_new
< 2)
2753 /* Reduce the size of the buffer by the adjustment computed above
2754 from the offset and/or the index into the array. */
2755 if (bytes_avail
< adjust
|| adjust
< 0)
2759 tree elttype
= (TREE_CODE (opertype
) == ARRAY_TYPE
2760 ? TREE_TYPE (opertype
) : opertype
);
2761 if (tree eltsize
= TYPE_SIZE_UNIT (elttype
))
2763 bytes_avail
-= adjust
* wi::to_offset (eltsize
);
2764 if (bytes_avail
< 0)
2769 /* The minimum amount of space needed for the allocation. This
2770 is an optimistic estimate that makes it possible to detect
2771 placement new invocation for some undersize buffers but not
2773 offset_int bytes_need
;
2776 nelts
= fold_for_warn (nelts
);
2778 if (CONSTANT_CLASS_P (size
))
2779 bytes_need
= wi::to_offset (size
);
2780 else if (nelts
&& CONSTANT_CLASS_P (nelts
))
2781 bytes_need
= (wi::to_offset (nelts
)
2782 * wi::to_offset (TYPE_SIZE_UNIT (type
)));
2783 else if (tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
2784 bytes_need
= wi::to_offset (TYPE_SIZE_UNIT (type
));
2787 /* The type is a VLA. */
2791 if (bytes_avail
< bytes_need
)
2794 if (CONSTANT_CLASS_P (nelts
))
2795 warning_at (loc
, OPT_Wplacement_new_
,
2797 "placement new constructing an object of type "
2798 "%<%T [%wu]%> and size %qwu in a region of type %qT "
2800 : "placement new constructing an object of type "
2801 "%<%T [%wu]%> and size %qwu in a region of type %qT "
2802 "and size at most %qwu",
2803 type
, tree_to_uhwi (nelts
), bytes_need
.to_uhwi (),
2804 opertype
, bytes_avail
.to_uhwi ());
2806 warning_at (loc
, OPT_Wplacement_new_
,
2808 "placement new constructing an array of objects "
2809 "of type %qT and size %qwu in a region of type %qT "
2811 : "placement new constructing an array of objects "
2812 "of type %qT and size %qwu in a region of type %qT "
2813 "and size at most %qwu",
2814 type
, bytes_need
.to_uhwi (), opertype
,
2815 bytes_avail
.to_uhwi ());
2817 warning_at (loc
, OPT_Wplacement_new_
,
2819 "placement new constructing an object of type %qT "
2820 "and size %qwu in a region of type %qT and size %qwi"
2821 : "placement new constructing an object of type %qT "
2822 "and size %qwu in a region of type %qT and size "
2824 type
, bytes_need
.to_uhwi (), opertype
,
2825 bytes_avail
.to_uhwi ());
2830 /* True if alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__. */
2833 type_has_new_extended_alignment (tree t
)
2835 return (aligned_new_threshold
2836 && TYPE_ALIGN_UNIT (t
) > (unsigned)aligned_new_threshold
);
2839 /* Return the alignment we expect malloc to guarantee. This should just be
2840 MALLOC_ABI_ALIGNMENT, but that macro defaults to only BITS_PER_WORD for some
2841 reason, so don't let the threshold be smaller than max_align_t_align. */
2846 return MAX (max_align_t_align(), MALLOC_ABI_ALIGNMENT
);
2849 /* Determine whether an allocation function is a namespace-scope
2850 non-replaceable placement new function. See DR 1748. */
2852 std_placement_new_fn_p (tree alloc_fn
)
2854 if (DECL_NAMESPACE_SCOPE_P (alloc_fn
))
2856 tree first_arg
= TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn
)));
2857 if ((TREE_VALUE (first_arg
) == ptr_type_node
)
2858 && TREE_CHAIN (first_arg
) == void_list_node
)
2864 /* For element type ELT_TYPE, return the appropriate type of the heap object
2865 containing such element(s). COOKIE_SIZE is NULL or the size of cookie
2866 in bytes. FULL_SIZE is NULL if it is unknown how big the heap allocation
2867 will be, otherwise size of the heap object. If COOKIE_SIZE is NULL,
2868 return array type ELT_TYPE[FULL_SIZE / sizeof(ELT_TYPE)], otherwise return
2869 struct { size_t[COOKIE_SIZE/sizeof(size_t)]; ELT_TYPE[N]; }
2870 where N is nothing (flexible array member) if FULL_SIZE is NULL, otherwise
2871 it is computed such that the size of the struct fits into FULL_SIZE. */
2874 build_new_constexpr_heap_type (tree elt_type
, tree cookie_size
, tree full_size
)
2876 gcc_assert (cookie_size
== NULL_TREE
|| tree_fits_uhwi_p (cookie_size
));
2877 gcc_assert (full_size
== NULL_TREE
|| tree_fits_uhwi_p (full_size
));
2878 unsigned HOST_WIDE_INT csz
= cookie_size
? tree_to_uhwi (cookie_size
) : 0;
2879 tree itype2
= NULL_TREE
;
2882 unsigned HOST_WIDE_INT fsz
= tree_to_uhwi (full_size
);
2883 gcc_assert (fsz
>= csz
);
2885 fsz
/= int_size_in_bytes (elt_type
);
2886 itype2
= build_index_type (size_int (fsz
- 1));
2888 return build_cplus_array_type (elt_type
, itype2
);
2891 gcc_assert (cookie_size
);
2892 csz
/= int_size_in_bytes (sizetype
);
2893 tree itype1
= build_index_type (size_int (csz
- 1));
2894 tree atype1
= build_cplus_array_type (sizetype
, itype1
);
2895 tree atype2
= build_cplus_array_type (elt_type
, itype2
);
2896 tree rtype
= cxx_make_type (RECORD_TYPE
);
2897 TYPE_NAME (rtype
) = heap_identifier
;
2898 tree fld1
= build_decl (UNKNOWN_LOCATION
, FIELD_DECL
, NULL_TREE
, atype1
);
2899 tree fld2
= build_decl (UNKNOWN_LOCATION
, FIELD_DECL
, NULL_TREE
, atype2
);
2900 DECL_FIELD_CONTEXT (fld1
) = rtype
;
2901 DECL_FIELD_CONTEXT (fld2
) = rtype
;
2902 DECL_ARTIFICIAL (fld1
) = true;
2903 DECL_ARTIFICIAL (fld2
) = true;
2904 TYPE_FIELDS (rtype
) = fld1
;
2905 DECL_CHAIN (fld1
) = fld2
;
2906 layout_type (rtype
);
2910 /* Help the constexpr code to find the right type for the heap variable
2911 by adding a NOP_EXPR around ALLOC_CALL if needed for cookie_size.
2912 Return ALLOC_CALL or ALLOC_CALL cast to a pointer to
2913 struct { size_t[cookie_size/sizeof(size_t)]; elt_type[]; }. */
2916 maybe_wrap_new_for_constexpr (tree alloc_call
, tree elt_type
, tree cookie_size
)
2918 if (cxx_dialect
< cxx2a
)
2921 if (current_function_decl
!= NULL_TREE
2922 && !DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
2925 tree call_expr
= extract_call_expr (alloc_call
);
2926 if (call_expr
== error_mark_node
)
2929 tree alloc_call_fndecl
= cp_get_callee_fndecl_nofold (call_expr
);
2930 if (alloc_call_fndecl
== NULL_TREE
2931 || !IDENTIFIER_NEW_OP_P (DECL_NAME (alloc_call_fndecl
))
2932 || CP_DECL_CONTEXT (alloc_call_fndecl
) != global_namespace
)
2935 tree rtype
= build_new_constexpr_heap_type (elt_type
, cookie_size
,
2937 return build_nop (build_pointer_type (rtype
), alloc_call
);
2940 /* Generate code for a new-expression, including calling the "operator
2941 new" function, initializing the object, and, if an exception occurs
2942 during construction, cleaning up. The arguments are as for
2943 build_raw_new_expr. This may change PLACEMENT and INIT.
2944 TYPE is the type of the object being constructed, possibly an array
2945 of NELTS elements when NELTS is non-null (in "new T[NELTS]", T may
2946 be an array of the form U[inner], with the whole expression being
2947 "new U[NELTS][inner]"). */
2950 build_new_1 (vec
<tree
, va_gc
> **placement
, tree type
, tree nelts
,
2951 vec
<tree
, va_gc
> **init
, bool globally_qualified_p
,
2952 tsubst_flags_t complain
)
2955 /* True iff this is a call to "operator new[]" instead of just
2957 bool array_p
= false;
2958 /* If ARRAY_P is true, the element type of the array. This is never
2959 an ARRAY_TYPE; for something like "new int[3][4]", the
2960 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
2963 /* The type of the new-expression. (This type is always a pointer
2966 tree non_const_pointer_type
;
2967 /* The most significant array bound in int[OUTER_NELTS][inner]. */
2968 tree outer_nelts
= NULL_TREE
;
2969 /* For arrays with a non-constant number of elements, a bounds checks
2970 on the NELTS parameter to avoid integer overflow at runtime. */
2971 tree outer_nelts_check
= NULL_TREE
;
2972 bool outer_nelts_from_type
= false;
2973 /* Number of the "inner" elements in "new T[OUTER_NELTS][inner]". */
2974 offset_int inner_nelts_count
= 1;
2975 tree alloc_call
, alloc_expr
;
2976 /* Size of the inner array elements (those with constant dimensions). */
2977 offset_int inner_size
;
2978 /* The address returned by the call to "operator new". This node is
2979 a VAR_DECL and is therefore reusable. */
2982 tree cookie_expr
, init_expr
;
2983 int nothrow
, check_new
;
2984 /* If non-NULL, the number of extra bytes to allocate at the
2985 beginning of the storage allocated for an array-new expression in
2986 order to store the number of elements. */
2987 tree cookie_size
= NULL_TREE
;
2988 tree placement_first
;
2989 tree placement_expr
= NULL_TREE
;
2990 /* True if the function we are calling is a placement allocation
2992 bool placement_allocation_fn_p
;
2993 /* True if the storage must be initialized, either by a constructor
2994 or due to an explicit new-initializer. */
2995 bool is_initialized
;
2996 /* The address of the thing allocated, not including any cookie. In
2997 particular, if an array cookie is in use, DATA_ADDR is the
2998 address of the first array element. This node is a VAR_DECL, and
2999 is therefore reusable. */
3001 tree init_preeval_expr
= NULL_TREE
;
3002 tree orig_type
= type
;
3006 outer_nelts
= nelts
;
3009 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3011 /* Transforms new (T[N]) to new T[N]. The former is a GNU
3012 extension for variable N. (This also covers new T where T is
3015 nelts
= array_type_nelts_top (type
);
3016 outer_nelts
= nelts
;
3017 type
= TREE_TYPE (type
);
3018 outer_nelts_from_type
= true;
3021 /* Lots of logic below depends on whether we have a constant number of
3022 elements, so go ahead and fold it now. */
3023 const_tree cst_outer_nelts
= fold_non_dependent_expr (outer_nelts
, complain
);
3025 /* If our base type is an array, then make sure we know how many elements
3027 for (elt_type
= type
;
3028 TREE_CODE (elt_type
) == ARRAY_TYPE
;
3029 elt_type
= TREE_TYPE (elt_type
))
3031 tree inner_nelts
= array_type_nelts_top (elt_type
);
3032 tree inner_nelts_cst
= maybe_constant_value (inner_nelts
);
3033 if (TREE_CODE (inner_nelts_cst
) == INTEGER_CST
)
3035 wi::overflow_type overflow
;
3036 offset_int result
= wi::mul (wi::to_offset (inner_nelts_cst
),
3037 inner_nelts_count
, SIGNED
, &overflow
);
3040 if (complain
& tf_error
)
3041 error ("integer overflow in array size");
3042 nelts
= error_mark_node
;
3044 inner_nelts_count
= result
;
3048 if (complain
& tf_error
)
3050 error_at (cp_expr_loc_or_input_loc (inner_nelts
),
3051 "array size in new-expression must be constant");
3052 cxx_constant_value(inner_nelts
);
3054 nelts
= error_mark_node
;
3056 if (nelts
!= error_mark_node
)
3057 nelts
= cp_build_binary_op (input_location
,
3063 if (!verify_type_context (input_location
, TCTX_ALLOCATION
, elt_type
,
3064 !(complain
& tf_error
)))
3065 return error_mark_node
;
3067 if (variably_modified_type_p (elt_type
, NULL_TREE
) && (complain
& tf_error
))
3069 error ("variably modified type not allowed in new-expression");
3070 return error_mark_node
;
3073 if (nelts
== error_mark_node
)
3074 return error_mark_node
;
3076 /* Warn if we performed the (T[N]) to T[N] transformation and N is
3078 if (outer_nelts_from_type
3079 && !TREE_CONSTANT (cst_outer_nelts
))
3081 if (complain
& tf_warning_or_error
)
3083 pedwarn (cp_expr_loc_or_input_loc (outer_nelts
), OPT_Wvla
,
3084 typedef_variant_p (orig_type
)
3085 ? G_("non-constant array new length must be specified "
3086 "directly, not by %<typedef%>")
3087 : G_("non-constant array new length must be specified "
3088 "without parentheses around the type-id"));
3091 return error_mark_node
;
3094 if (VOID_TYPE_P (elt_type
))
3096 if (complain
& tf_error
)
3097 error ("invalid type %<void%> for %<new%>");
3098 return error_mark_node
;
3101 if (is_std_init_list (elt_type
))
3102 warning (OPT_Winit_list_lifetime
,
3103 "%<new%> of %<initializer_list%> does not "
3104 "extend the lifetime of the underlying array");
3106 if (abstract_virtuals_error_sfinae (ACU_NEW
, elt_type
, complain
))
3107 return error_mark_node
;
3109 is_initialized
= (type_build_ctor_call (elt_type
) || *init
!= NULL
);
3111 if (*init
== NULL
&& cxx_dialect
< cxx11
)
3113 bool maybe_uninitialized_error
= false;
3114 /* A program that calls for default-initialization [...] of an
3115 entity of reference type is ill-formed. */
3116 if (CLASSTYPE_REF_FIELDS_NEED_INIT (elt_type
))
3117 maybe_uninitialized_error
= true;
3119 /* A new-expression that creates an object of type T initializes
3120 that object as follows:
3121 - If the new-initializer is omitted:
3122 -- If T is a (possibly cv-qualified) non-POD class type
3123 (or array thereof), the object is default-initialized (8.5).
3125 -- Otherwise, the object created has indeterminate
3126 value. If T is a const-qualified type, or a (possibly
3127 cv-qualified) POD class type (or array thereof)
3128 containing (directly or indirectly) a member of
3129 const-qualified type, the program is ill-formed; */
3131 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (elt_type
))
3132 maybe_uninitialized_error
= true;
3134 if (maybe_uninitialized_error
3135 && diagnose_uninitialized_cst_or_ref_member (elt_type
,
3137 complain
& tf_error
))
3138 return error_mark_node
;
3141 if (CP_TYPE_CONST_P (elt_type
) && *init
== NULL
3142 && default_init_uninitialized_part (elt_type
))
3144 if (complain
& tf_error
)
3145 error ("uninitialized const in %<new%> of %q#T", elt_type
);
3146 return error_mark_node
;
3149 size
= size_in_bytes (elt_type
);
3152 /* Maximum available size in bytes. Half of the address space
3153 minus the cookie size. */
3155 = wi::set_bit_in_zero
<offset_int
> (TYPE_PRECISION (sizetype
) - 1);
3156 /* Maximum number of outer elements which can be allocated. */
3157 offset_int max_outer_nelts
;
3158 tree max_outer_nelts_tree
;
3160 gcc_assert (TREE_CODE (size
) == INTEGER_CST
);
3161 cookie_size
= targetm
.cxx
.get_cookie_size (elt_type
);
3162 gcc_assert (TREE_CODE (cookie_size
) == INTEGER_CST
);
3163 gcc_checking_assert (wi::ltu_p (wi::to_offset (cookie_size
), max_size
));
3164 /* Unconditionally subtract the cookie size. This decreases the
3165 maximum object size and is safe even if we choose not to use
3166 a cookie after all. */
3167 max_size
-= wi::to_offset (cookie_size
);
3168 wi::overflow_type overflow
;
3169 inner_size
= wi::mul (wi::to_offset (size
), inner_nelts_count
, SIGNED
,
3171 if (overflow
|| wi::gtu_p (inner_size
, max_size
))
3173 if (complain
& tf_error
)
3175 cst_size_error error
;
3177 error
= cst_size_overflow
;
3180 error
= cst_size_too_big
;
3181 size
= size_binop (MULT_EXPR
, size
,
3182 wide_int_to_tree (sizetype
,
3183 inner_nelts_count
));
3184 size
= cp_fully_fold (size
);
3186 invalid_array_size_error (input_location
, error
, size
,
3187 /*name=*/NULL_TREE
);
3189 return error_mark_node
;
3192 max_outer_nelts
= wi::udiv_trunc (max_size
, inner_size
);
3193 max_outer_nelts_tree
= wide_int_to_tree (sizetype
, max_outer_nelts
);
3195 size
= size_binop (MULT_EXPR
, size
, fold_convert (sizetype
, nelts
));
3197 if (TREE_CODE (cst_outer_nelts
) == INTEGER_CST
)
3199 if (tree_int_cst_lt (max_outer_nelts_tree
, cst_outer_nelts
))
3201 /* When the array size is constant, check it at compile time
3202 to make sure it doesn't exceed the implementation-defined
3203 maximum, as required by C++ 14 (in C++ 11 this requirement
3204 isn't explicitly stated but it's enforced anyway -- see
3205 grokdeclarator in cp/decl.c). */
3206 if (complain
& tf_error
)
3208 size
= cp_fully_fold (size
);
3209 invalid_array_size_error (input_location
, cst_size_too_big
,
3212 return error_mark_node
;
3217 /* When a runtime check is necessary because the array size
3218 isn't constant, keep only the top-most seven bits (starting
3219 with the most significant non-zero bit) of the maximum size
3220 to compare the array size against, to simplify encoding the
3221 constant maximum size in the instruction stream. */
3223 unsigned shift
= (max_outer_nelts
.get_precision ()) - 7
3224 - wi::clz (max_outer_nelts
);
3225 max_outer_nelts
= (max_outer_nelts
>> shift
) << shift
;
3227 outer_nelts_check
= fold_build2 (LE_EXPR
, boolean_type_node
,
3229 max_outer_nelts_tree
);
3233 tree align_arg
= NULL_TREE
;
3234 if (type_has_new_extended_alignment (elt_type
))
3235 align_arg
= build_int_cst (align_type_node
, TYPE_ALIGN_UNIT (elt_type
));
3237 alloc_fn
= NULL_TREE
;
3239 /* If PLACEMENT is a single simple pointer type not passed by
3240 reference, prepare to capture it in a temporary variable. Do
3241 this now, since PLACEMENT will change in the calls below. */
3242 placement_first
= NULL_TREE
;
3243 if (vec_safe_length (*placement
) == 1
3244 && (TYPE_PTR_P (TREE_TYPE ((**placement
)[0]))))
3245 placement_first
= (**placement
)[0];
3247 bool member_new_p
= false;
3249 /* Allocate the object. */
3253 fnname
= ovl_op_identifier (false, array_p
? VEC_NEW_EXPR
: NEW_EXPR
);
3255 member_new_p
= !globally_qualified_p
3256 && CLASS_TYPE_P (elt_type
)
3258 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type
)
3259 : TYPE_HAS_NEW_OPERATOR (elt_type
));
3263 /* Use a class-specific operator new. */
3264 /* If a cookie is required, add some extra space. */
3265 if (array_p
&& TYPE_VEC_NEW_USES_COOKIE (elt_type
))
3266 size
= size_binop (PLUS_EXPR
, size
, cookie_size
);
3269 cookie_size
= NULL_TREE
;
3270 /* No size arithmetic necessary, so the size check is
3272 if (outer_nelts_check
!= NULL
&& inner_size
== 1)
3273 outer_nelts_check
= NULL_TREE
;
3275 /* Perform the overflow check. */
3276 tree errval
= TYPE_MAX_VALUE (sizetype
);
3277 if (cxx_dialect
>= cxx11
&& flag_exceptions
)
3278 errval
= throw_bad_array_new_length ();
3279 if (outer_nelts_check
!= NULL_TREE
)
3280 size
= fold_build3 (COND_EXPR
, sizetype
, outer_nelts_check
,
3282 /* Create the argument list. */
3283 vec_safe_insert (*placement
, 0, size
);
3284 /* Do name-lookup to find the appropriate operator. */
3285 fns
= lookup_fnfields (elt_type
, fnname
, /*protect=*/2);
3286 if (fns
== NULL_TREE
)
3288 if (complain
& tf_error
)
3289 error ("no suitable %qD found in class %qT", fnname
, elt_type
);
3290 return error_mark_node
;
3292 if (TREE_CODE (fns
) == TREE_LIST
)
3294 if (complain
& tf_error
)
3296 error ("request for member %qD is ambiguous", fnname
);
3297 print_candidates (fns
);
3299 return error_mark_node
;
3301 tree dummy
= build_dummy_object (elt_type
);
3302 alloc_call
= NULL_TREE
;
3305 vec
<tree
, va_gc
> *align_args
3306 = vec_copy_and_insert (*placement
, align_arg
, 1);
3308 = build_new_method_call (dummy
, fns
, &align_args
,
3309 /*conversion_path=*/NULL_TREE
,
3310 LOOKUP_NORMAL
, &alloc_fn
, tf_none
);
3311 /* If no matching function is found and the allocated object type
3312 has new-extended alignment, the alignment argument is removed
3313 from the argument list, and overload resolution is performed
3315 if (alloc_call
== error_mark_node
)
3316 alloc_call
= NULL_TREE
;
3319 alloc_call
= build_new_method_call (dummy
, fns
, placement
,
3320 /*conversion_path=*/NULL_TREE
,
3322 &alloc_fn
, complain
);
3326 /* Use a global operator new. */
3327 /* See if a cookie might be required. */
3328 if (!(array_p
&& TYPE_VEC_NEW_USES_COOKIE (elt_type
)))
3330 cookie_size
= NULL_TREE
;
3331 /* No size arithmetic necessary, so the size check is
3333 if (outer_nelts_check
!= NULL
&& inner_size
== 1)
3334 outer_nelts_check
= NULL_TREE
;
3337 alloc_call
= build_operator_new_call (fnname
, placement
,
3338 &size
, &cookie_size
,
3339 align_arg
, outer_nelts_check
,
3340 &alloc_fn
, complain
);
3343 if (alloc_call
== error_mark_node
)
3344 return error_mark_node
;
3346 gcc_assert (alloc_fn
!= NULL_TREE
);
3348 /* Now, check to see if this function is actually a placement
3349 allocation function. This can happen even when PLACEMENT is NULL
3350 because we might have something like:
3352 struct S { void* operator new (size_t, int i = 0); };
3354 A call to `new S' will get this allocation function, even though
3355 there is no explicit placement argument. If there is more than
3356 one argument, or there are variable arguments, then this is a
3357 placement allocation function. */
3358 placement_allocation_fn_p
3359 = (type_num_arguments (TREE_TYPE (alloc_fn
)) > 1
3360 || varargs_function_p (alloc_fn
));
3362 if (warn_aligned_new
3363 && !placement_allocation_fn_p
3364 && TYPE_ALIGN (elt_type
) > malloc_alignment ()
3365 && (warn_aligned_new
> 1
3366 || CP_DECL_CONTEXT (alloc_fn
) == global_namespace
)
3367 && !aligned_allocation_fn_p (alloc_fn
))
3369 auto_diagnostic_group d
;
3370 if (warning (OPT_Waligned_new_
, "%<new%> of type %qT with extended "
3371 "alignment %d", elt_type
, TYPE_ALIGN_UNIT (elt_type
)))
3373 inform (input_location
, "uses %qD, which does not have an alignment "
3374 "parameter", alloc_fn
);
3375 if (!aligned_new_threshold
)
3376 inform (input_location
, "use %<-faligned-new%> to enable C++17 "
3377 "over-aligned new support");
3381 /* If we found a simple case of PLACEMENT_EXPR above, then copy it
3382 into a temporary variable. */
3383 if (!processing_template_decl
3384 && TREE_CODE (alloc_call
) == CALL_EXPR
3385 && call_expr_nargs (alloc_call
) == 2
3386 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 0))) == INTEGER_TYPE
3387 && TYPE_PTR_P (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 1))))
3389 tree placement
= CALL_EXPR_ARG (alloc_call
, 1);
3391 if (placement_first
!= NULL_TREE
3392 && (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement
)))
3393 || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement
)))))
3395 placement_expr
= get_target_expr (placement_first
);
3396 CALL_EXPR_ARG (alloc_call
, 1)
3397 = fold_convert (TREE_TYPE (placement
), placement_expr
);
3401 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 1)))))
3403 /* Attempt to make the warning point at the operator new argument. */
3404 if (placement_first
)
3405 placement
= placement_first
;
3407 warn_placement_new_too_small (orig_type
, nelts
, size
, placement
);
3411 tree alloc_call_expr
= extract_call_expr (alloc_call
);
3412 if (TREE_CODE (alloc_call_expr
) == CALL_EXPR
)
3413 CALL_FROM_NEW_OR_DELETE_P (alloc_call_expr
) = 1;
3416 alloc_call
= maybe_wrap_new_for_constexpr (alloc_call
, elt_type
,
3419 /* In the simple case, we can stop now. */
3420 pointer_type
= build_pointer_type (type
);
3421 if (!cookie_size
&& !is_initialized
)
3422 return build_nop (pointer_type
, alloc_call
);
3424 /* Store the result of the allocation call in a variable so that we can
3425 use it more than once. */
3426 alloc_expr
= get_target_expr (alloc_call
);
3427 alloc_node
= TARGET_EXPR_SLOT (alloc_expr
);
3429 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
3430 while (TREE_CODE (alloc_call
) == COMPOUND_EXPR
)
3431 alloc_call
= TREE_OPERAND (alloc_call
, 1);
3433 /* Preevaluate the placement args so that we don't reevaluate them for a
3434 placement delete. */
3435 if (placement_allocation_fn_p
)
3438 stabilize_call (alloc_call
, &inits
);
3440 alloc_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (alloc_expr
), inits
,
3444 /* unless an allocation function is declared with an empty excep-
3445 tion-specification (_except.spec_), throw(), it indicates failure to
3446 allocate storage by throwing a bad_alloc exception (clause _except_,
3447 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
3448 cation function is declared with an empty exception-specification,
3449 throw(), it returns null to indicate failure to allocate storage and a
3450 non-null pointer otherwise.
3452 So check for a null exception spec on the op new we just called. */
3454 nothrow
= TYPE_NOTHROW_P (TREE_TYPE (alloc_fn
));
3456 = flag_check_new
|| (nothrow
&& !std_placement_new_fn_p (alloc_fn
));
3464 /* Adjust so we're pointing to the start of the object. */
3465 data_addr
= fold_build_pointer_plus (alloc_node
, cookie_size
);
3467 /* Store the number of bytes allocated so that we can know how
3468 many elements to destroy later. We use the last sizeof
3469 (size_t) bytes to store the number of elements. */
3470 cookie_ptr
= size_binop (MINUS_EXPR
, cookie_size
, size_in_bytes (sizetype
));
3471 cookie_ptr
= fold_build_pointer_plus_loc (input_location
,
3472 alloc_node
, cookie_ptr
);
3473 size_ptr_type
= build_pointer_type (sizetype
);
3474 cookie_ptr
= fold_convert (size_ptr_type
, cookie_ptr
);
3475 cookie
= cp_build_fold_indirect_ref (cookie_ptr
);
3477 cookie_expr
= build2 (MODIFY_EXPR
, sizetype
, cookie
, nelts
);
3479 if (targetm
.cxx
.cookie_has_size ())
3481 /* Also store the element size. */
3482 cookie_ptr
= fold_build_pointer_plus (cookie_ptr
,
3483 fold_build1_loc (input_location
,
3484 NEGATE_EXPR
, sizetype
,
3485 size_in_bytes (sizetype
)));
3487 cookie
= cp_build_fold_indirect_ref (cookie_ptr
);
3488 cookie
= build2 (MODIFY_EXPR
, sizetype
, cookie
,
3489 size_in_bytes (elt_type
));
3490 cookie_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (cookie_expr
),
3491 cookie
, cookie_expr
);
3496 cookie_expr
= NULL_TREE
;
3497 data_addr
= alloc_node
;
3500 /* Now use a pointer to the type we've actually allocated. */
3502 /* But we want to operate on a non-const version to start with,
3503 since we'll be modifying the elements. */
3504 non_const_pointer_type
= build_pointer_type
3505 (cp_build_qualified_type (type
, cp_type_quals (type
) & ~TYPE_QUAL_CONST
));
3507 data_addr
= fold_convert (non_const_pointer_type
, data_addr
);
3508 /* Any further uses of alloc_node will want this type, too. */
3509 alloc_node
= fold_convert (non_const_pointer_type
, alloc_node
);
3511 /* Now initialize the allocated object. Note that we preevaluate the
3512 initialization expression, apart from the actual constructor call or
3513 assignment--we do this because we want to delay the allocation as long
3514 as possible in order to minimize the size of the exception region for
3515 placement delete. */
3519 bool explicit_value_init_p
= false;
3521 if (*init
!= NULL
&& (*init
)->is_empty ())
3524 explicit_value_init_p
= true;
3527 if (processing_template_decl
&& explicit_value_init_p
)
3529 /* build_value_init doesn't work in templates, and we don't need
3530 the initializer anyway since we're going to throw it away and
3531 rebuild it at instantiation time, so just build up a single
3532 constructor call to get any appropriate diagnostics. */
3533 init_expr
= cp_build_fold_indirect_ref (data_addr
);
3534 if (type_build_ctor_call (elt_type
))
3535 init_expr
= build_special_member_call (init_expr
,
3536 complete_ctor_identifier
,
3540 stable
= stabilize_init (init_expr
, &init_preeval_expr
);
3544 tree vecinit
= NULL_TREE
;
3545 if (vec_safe_length (*init
) == 1
3546 && DIRECT_LIST_INIT_P ((**init
)[0]))
3548 vecinit
= (**init
)[0];
3549 if (CONSTRUCTOR_NELTS (vecinit
) == 0)
3550 /* List-value-initialization, leave it alone. */;
3553 tree arraytype
, domain
;
3554 if (TREE_CONSTANT (nelts
))
3555 domain
= compute_array_index_type (NULL_TREE
, nelts
,
3558 /* We'll check the length at runtime. */
3560 arraytype
= build_cplus_array_type (type
, domain
);
3561 vecinit
= digest_init (arraytype
, vecinit
, complain
);
3566 if (complain
& tf_error
)
3567 error ("parenthesized initializer in array new");
3568 return error_mark_node
;
3571 = build_vec_init (data_addr
,
3572 cp_build_binary_op (input_location
,
3573 MINUS_EXPR
, outer_nelts
,
3577 explicit_value_init_p
,
3581 /* An array initialization is stable because the initialization
3582 of each element is a full-expression, so the temporaries don't
3588 init_expr
= cp_build_fold_indirect_ref (data_addr
);
3590 if (type_build_ctor_call (type
) && !explicit_value_init_p
)
3592 init_expr
= build_special_member_call (init_expr
,
3593 complete_ctor_identifier
,
3596 complain
|tf_no_cleanup
);
3598 else if (explicit_value_init_p
)
3600 /* Something like `new int()'. NO_CLEANUP is needed so
3601 we don't try and build a (possibly ill-formed)
3603 tree val
= build_value_init (type
, complain
| tf_no_cleanup
);
3604 if (val
== error_mark_node
)
3605 return error_mark_node
;
3606 init_expr
= build2 (INIT_EXPR
, type
, init_expr
, val
);
3612 /* We are processing something like `new int (10)', which
3613 means allocate an int, and initialize it with 10.
3615 In C++20, also handle `new A(1, 2)'. */
3616 if (cxx_dialect
>= cxx2a
3617 && AGGREGATE_TYPE_P (type
)
3618 && (*init
)->length () > 1)
3620 ie
= build_tree_list_vec (*init
);
3621 ie
= build_constructor_from_list (init_list_type_node
, ie
);
3622 CONSTRUCTOR_IS_DIRECT_INIT (ie
) = true;
3623 CONSTRUCTOR_IS_PAREN_INIT (ie
) = true;
3624 ie
= digest_init (type
, ie
, complain
);
3627 ie
= build_x_compound_expr_from_vec (*init
, "new initializer",
3629 init_expr
= cp_build_modify_expr (input_location
, init_expr
,
3630 INIT_EXPR
, ie
, complain
);
3632 /* If the initializer uses C++14 aggregate NSDMI that refer to the
3633 object being initialized, replace them now and don't try to
3635 bool had_placeholder
= false;
3636 if (!processing_template_decl
3637 && TREE_CODE (init_expr
) == INIT_EXPR
)
3638 TREE_OPERAND (init_expr
, 1)
3639 = replace_placeholders (TREE_OPERAND (init_expr
, 1),
3640 TREE_OPERAND (init_expr
, 0),
3642 stable
= (!had_placeholder
3643 && stabilize_init (init_expr
, &init_preeval_expr
));
3646 if (init_expr
== error_mark_node
)
3647 return error_mark_node
;
3649 /* If any part of the object initialization terminates by throwing an
3650 exception and a suitable deallocation function can be found, the
3651 deallocation function is called to free the memory in which the
3652 object was being constructed, after which the exception continues
3653 to propagate in the context of the new-expression. If no
3654 unambiguous matching deallocation function can be found,
3655 propagating the exception does not cause the object's memory to be
3657 if (flag_exceptions
)
3659 enum tree_code dcode
= array_p
? VEC_DELETE_EXPR
: DELETE_EXPR
;
3662 /* The Standard is unclear here, but the right thing to do
3663 is to use the same method for finding deallocation
3664 functions that we use for finding allocation functions. */
3665 cleanup
= (build_op_delete_call
3669 globally_qualified_p
,
3670 placement_allocation_fn_p
? alloc_call
: NULL_TREE
,
3677 /* This is much simpler if we were able to preevaluate all of
3678 the arguments to the constructor call. */
3680 /* CLEANUP is compiler-generated, so no diagnostics. */
3681 TREE_NO_WARNING (cleanup
) = true;
3682 init_expr
= build2 (TRY_CATCH_EXPR
, void_type_node
,
3683 init_expr
, cleanup
);
3684 /* Likewise, this try-catch is compiler-generated. */
3685 TREE_NO_WARNING (init_expr
) = true;
3688 /* Ack! First we allocate the memory. Then we set our sentry
3689 variable to true, and expand a cleanup that deletes the
3690 memory if sentry is true. Then we run the constructor, and
3691 finally clear the sentry.
3693 We need to do this because we allocate the space first, so
3694 if there are any temporaries with cleanups in the
3695 constructor args and we weren't able to preevaluate them, we
3696 need this EH region to extend until end of full-expression
3697 to preserve nesting. */
3699 tree end
, sentry
, begin
;
3701 begin
= get_target_expr (boolean_true_node
);
3702 CLEANUP_EH_ONLY (begin
) = 1;
3704 sentry
= TARGET_EXPR_SLOT (begin
);
3706 /* CLEANUP is compiler-generated, so no diagnostics. */
3707 TREE_NO_WARNING (cleanup
) = true;
3709 TARGET_EXPR_CLEANUP (begin
)
3710 = build3 (COND_EXPR
, void_type_node
, sentry
,
3711 cleanup
, void_node
);
3713 end
= build2 (MODIFY_EXPR
, TREE_TYPE (sentry
),
3714 sentry
, boolean_false_node
);
3717 = build2 (COMPOUND_EXPR
, void_type_node
, begin
,
3718 build2 (COMPOUND_EXPR
, void_type_node
, init_expr
,
3720 /* Likewise, this is compiler-generated. */
3721 TREE_NO_WARNING (init_expr
) = true;
3726 init_expr
= NULL_TREE
;
3728 /* Now build up the return value in reverse order. */
3733 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), init_expr
, rval
);
3735 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), cookie_expr
, rval
);
3737 if (rval
== data_addr
)
3738 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
3739 and return the call (which doesn't need to be adjusted). */
3740 rval
= TARGET_EXPR_INITIAL (alloc_expr
);
3745 tree ifexp
= cp_build_binary_op (input_location
,
3746 NE_EXPR
, alloc_node
,
3749 rval
= build_conditional_expr (input_location
, ifexp
, rval
,
3750 alloc_node
, complain
);
3753 /* Perform the allocation before anything else, so that ALLOC_NODE
3754 has been initialized before we start using it. */
3755 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
3758 if (init_preeval_expr
)
3759 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), init_preeval_expr
, rval
);
3761 /* A new-expression is never an lvalue. */
3762 gcc_assert (!obvalue_p (rval
));
3764 return convert (pointer_type
, rval
);
3767 /* Generate a representation for a C++ "new" expression. *PLACEMENT
3768 is a vector of placement-new arguments (or NULL if none). If NELTS
3769 is NULL, TYPE is the type of the storage to be allocated. If NELTS
3770 is not NULL, then this is an array-new allocation; TYPE is the type
3771 of the elements in the array and NELTS is the number of elements in
3772 the array. *INIT, if non-NULL, is the initializer for the new
3773 object, or an empty vector to indicate an initializer of "()". If
3774 USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
3775 rather than just "new". This may change PLACEMENT and INIT. */
3778 build_new (vec
<tree
, va_gc
> **placement
, tree type
, tree nelts
,
3779 vec
<tree
, va_gc
> **init
, int use_global_new
, tsubst_flags_t complain
)
3782 vec
<tree
, va_gc
> *orig_placement
= NULL
;
3783 tree orig_nelts
= NULL_TREE
;
3784 vec
<tree
, va_gc
> *orig_init
= NULL
;
3786 if (type
== error_mark_node
)
3787 return error_mark_node
;
3789 if (nelts
== NULL_TREE
3790 /* Don't do auto deduction where it might affect mangling. */
3791 && (!processing_template_decl
|| at_function_scope_p ()))
3793 tree auto_node
= type_uses_auto (type
);
3796 tree d_init
= NULL_TREE
;
3797 const size_t len
= vec_safe_length (*init
);
3798 /* E.g. new auto(x) must have exactly one element, or
3799 a {} initializer will have one element. */
3802 d_init
= (**init
)[0];
3803 d_init
= resolve_nondeduced_context (d_init
, complain
);
3805 /* For the rest, e.g. new A(1, 2, 3), create a list. */
3811 FOR_EACH_VEC_ELT (**init
, n
, t
)
3813 t
= resolve_nondeduced_context (t
, complain
);
3814 *pp
= build_tree_list (NULL_TREE
, t
);
3815 pp
= &TREE_CHAIN (*pp
);
3818 type
= do_auto_deduction (type
, d_init
, auto_node
, complain
);
3822 if (processing_template_decl
)
3824 if (dependent_type_p (type
)
3825 || any_type_dependent_arguments_p (*placement
)
3826 || (nelts
&& type_dependent_expression_p (nelts
))
3828 || any_type_dependent_arguments_p (*init
))
3829 return build_raw_new_expr (*placement
, type
, nelts
, *init
,
3832 orig_placement
= make_tree_vector_copy (*placement
);
3836 orig_init
= make_tree_vector_copy (*init
);
3837 /* Also copy any CONSTRUCTORs in *init, since reshape_init and
3838 digest_init clobber them in place. */
3839 for (unsigned i
= 0; i
< orig_init
->length(); ++i
)
3841 tree e
= (**init
)[i
];
3842 if (TREE_CODE (e
) == CONSTRUCTOR
)
3843 (**init
)[i
] = copy_node (e
);
3847 make_args_non_dependent (*placement
);
3849 nelts
= build_non_dependent_expr (nelts
);
3850 make_args_non_dependent (*init
);
3855 if (!build_expr_type_conversion (WANT_INT
| WANT_ENUM
, nelts
, false))
3857 if (complain
& tf_error
)
3858 permerror (cp_expr_loc_or_input_loc (nelts
),
3859 "size in array new must have integral type");
3861 return error_mark_node
;
3864 /* Try to determine the constant value only for the purposes
3865 of the diagnostic below but continue to use the original
3866 value and handle const folding later. */
3867 const_tree cst_nelts
= fold_non_dependent_expr (nelts
, complain
);
3869 /* The expression in a noptr-new-declarator is erroneous if it's of
3870 non-class type and its value before converting to std::size_t is
3871 less than zero. ... If the expression is a constant expression,
3872 the program is ill-fomed. */
3873 if (TREE_CODE (cst_nelts
) == INTEGER_CST
3874 && !valid_array_size_p (cp_expr_loc_or_input_loc (nelts
),
3875 cst_nelts
, NULL_TREE
,
3876 complain
& tf_error
))
3877 return error_mark_node
;
3879 nelts
= mark_rvalue_use (nelts
);
3880 nelts
= cp_save_expr (cp_convert (sizetype
, nelts
, complain
));
3883 /* ``A reference cannot be created by the new operator. A reference
3884 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
3885 returned by new.'' ARM 5.3.3 */
3886 if (TYPE_REF_P (type
))
3888 if (complain
& tf_error
)
3889 error ("new cannot be applied to a reference type");
3891 return error_mark_node
;
3892 type
= TREE_TYPE (type
);
3895 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3897 if (complain
& tf_error
)
3898 error ("new cannot be applied to a function type");
3899 return error_mark_node
;
3902 /* The type allocated must be complete. If the new-type-id was
3903 "T[N]" then we are just checking that "T" is complete here, but
3904 that is equivalent, since the value of "N" doesn't matter. */
3905 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
3906 return error_mark_node
;
3908 rval
= build_new_1 (placement
, type
, nelts
, init
, use_global_new
, complain
);
3909 if (rval
== error_mark_node
)
3910 return error_mark_node
;
3912 if (processing_template_decl
)
3914 tree ret
= build_raw_new_expr (orig_placement
, type
, orig_nelts
,
3915 orig_init
, use_global_new
);
3916 release_tree_vector (orig_placement
);
3917 release_tree_vector (orig_init
);
3921 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
3922 rval
= build1 (NOP_EXPR
, TREE_TYPE (rval
), rval
);
3923 TREE_NO_WARNING (rval
) = 1;
3929 build_vec_delete_1 (location_t loc
, tree base
, tree maxindex
, tree type
,
3930 special_function_kind auto_delete_vec
,
3931 int use_global_delete
, tsubst_flags_t complain
)
3934 tree ptype
= build_pointer_type (type
= complete_type (type
));
3937 /* Temporary variables used by the loop. */
3938 tree tbase
, tbase_init
;
3940 /* This is the body of the loop that implements the deletion of a
3941 single element, and moves temp variables to next elements. */
3944 /* This is the LOOP_EXPR that governs the deletion of the elements. */
3947 /* This is the thing that governs what to do after the loop has run. */
3948 tree deallocate_expr
= 0;
3950 /* This is the BIND_EXPR which holds the outermost iterator of the
3951 loop. It is convenient to set this variable up and test it before
3952 executing any other code in the loop.
3953 This is also the containing expression returned by this function. */
3954 tree controller
= NULL_TREE
;
3957 /* We should only have 1-D arrays here. */
3958 gcc_assert (TREE_CODE (type
) != ARRAY_TYPE
);
3960 if (base
== error_mark_node
|| maxindex
== error_mark_node
)
3961 return error_mark_node
;
3963 if (!verify_type_context (loc
, TCTX_DEALLOCATION
, type
,
3964 !(complain
& tf_error
)))
3965 return error_mark_node
;
3967 if (!COMPLETE_TYPE_P (type
))
3969 if (complain
& tf_warning
)
3971 auto_diagnostic_group d
;
3972 if (warning_at (loc
, OPT_Wdelete_incomplete
,
3973 "possible problem detected in invocation of "
3974 "operator %<delete []%>"))
3976 cxx_incomplete_type_diagnostic (base
, type
, DK_WARNING
);
3977 inform (loc
, "neither the destructor nor the "
3978 "class-specific operator %<delete []%> will be called, "
3979 "even if they are declared when the class is defined");
3982 /* This size won't actually be used. */
3983 size_exp
= size_one_node
;
3987 size_exp
= size_in_bytes (type
);
3989 if (! MAYBE_CLASS_TYPE_P (type
))
3991 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
3993 /* Make sure the destructor is callable. */
3994 if (type_build_dtor_call (type
))
3996 tmp
= build_delete (loc
, ptype
, base
, sfk_complete_destructor
,
3997 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1,
3999 if (tmp
== error_mark_node
)
4000 return error_mark_node
;
4005 /* The below is short by the cookie size. */
4006 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
4007 fold_convert (sizetype
, maxindex
));
4009 tbase
= create_temporary_var (ptype
);
4010 DECL_INITIAL (tbase
)
4011 = fold_build_pointer_plus_loc (loc
, fold_convert (ptype
, base
),
4013 tbase_init
= build_stmt (loc
, DECL_EXPR
, tbase
);
4014 controller
= build3 (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
4015 TREE_SIDE_EFFECTS (controller
) = 1;
4017 body
= build1 (EXIT_EXPR
, void_type_node
,
4018 build2 (EQ_EXPR
, boolean_type_node
, tbase
,
4019 fold_convert (ptype
, base
)));
4020 tmp
= fold_build1_loc (loc
, NEGATE_EXPR
, sizetype
, size_exp
);
4021 tmp
= fold_build_pointer_plus (tbase
, tmp
);
4022 tmp
= cp_build_modify_expr (loc
, tbase
, NOP_EXPR
, tmp
, complain
);
4023 if (tmp
== error_mark_node
)
4024 return error_mark_node
;
4025 body
= build_compound_expr (loc
, body
, tmp
);
4026 tmp
= build_delete (loc
, ptype
, tbase
, sfk_complete_destructor
,
4027 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1,
4029 if (tmp
== error_mark_node
)
4030 return error_mark_node
;
4031 body
= build_compound_expr (loc
, body
, tmp
);
4033 loop
= build1 (LOOP_EXPR
, void_type_node
, body
);
4034 loop
= build_compound_expr (loc
, tbase_init
, loop
);
4037 /* Delete the storage if appropriate. */
4038 if (auto_delete_vec
== sfk_deleting_destructor
)
4042 /* The below is short by the cookie size. */
4043 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
4044 fold_convert (sizetype
, maxindex
));
4046 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
4053 cookie_size
= targetm
.cxx
.get_cookie_size (type
);
4054 base_tbd
= cp_build_binary_op (loc
,
4056 cp_convert (string_type_node
,
4060 if (base_tbd
== error_mark_node
)
4061 return error_mark_node
;
4062 base_tbd
= cp_convert (ptype
, base_tbd
, complain
);
4063 /* True size with header. */
4064 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, cookie_size
);
4067 deallocate_expr
= build_op_delete_call (VEC_DELETE_EXPR
,
4068 base_tbd
, virtual_size
,
4069 use_global_delete
& 1,
4070 /*placement=*/NULL_TREE
,
4071 /*alloc_fn=*/NULL_TREE
,
4074 tree deallocate_call_expr
= extract_call_expr (deallocate_expr
);
4075 if (TREE_CODE (deallocate_call_expr
) == CALL_EXPR
)
4076 CALL_FROM_NEW_OR_DELETE_P (deallocate_call_expr
) = 1;
4080 if (!deallocate_expr
)
4083 body
= deallocate_expr
;
4085 /* The delete operator must be called, even if a destructor
4087 body
= build2 (TRY_FINALLY_EXPR
, void_type_node
, body
, deallocate_expr
);
4090 body
= integer_zero_node
;
4092 /* Outermost wrapper: If pointer is null, punt. */
4093 tree cond
= build2_loc (loc
, NE_EXPR
, boolean_type_node
, base
,
4094 fold_convert (TREE_TYPE (base
), nullptr_node
));
4095 /* This is a compiler generated comparison, don't emit
4096 e.g. -Wnonnull-compare warning for it. */
4097 TREE_NO_WARNING (cond
) = 1;
4098 body
= build3_loc (loc
, COND_EXPR
, void_type_node
,
4099 cond
, body
, integer_zero_node
);
4100 COND_EXPR_IS_VEC_DELETE (body
) = true;
4101 body
= build1 (NOP_EXPR
, void_type_node
, body
);
4105 TREE_OPERAND (controller
, 1) = body
;
4109 if (TREE_CODE (base
) == SAVE_EXPR
)
4110 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
4111 body
= build2 (COMPOUND_EXPR
, void_type_node
, base
, body
);
4113 return convert_to_void (body
, ICV_CAST
, complain
);
4116 /* Create an unnamed variable of the indicated TYPE. */
4119 create_temporary_var (tree type
)
4123 decl
= build_decl (input_location
,
4124 VAR_DECL
, NULL_TREE
, type
);
4125 TREE_USED (decl
) = 1;
4126 DECL_ARTIFICIAL (decl
) = 1;
4127 DECL_IGNORED_P (decl
) = 1;
4128 DECL_CONTEXT (decl
) = current_function_decl
;
4133 /* Create a new temporary variable of the indicated TYPE, initialized
4136 It is not entered into current_binding_level, because that breaks
4137 things when it comes time to do final cleanups (which take place
4138 "outside" the binding contour of the function). */
4141 get_temp_regvar (tree type
, tree init
)
4145 decl
= create_temporary_var (type
);
4146 add_decl_expr (decl
);
4148 finish_expr_stmt (cp_build_modify_expr (input_location
, decl
, INIT_EXPR
,
4149 init
, tf_warning_or_error
));
4154 /* Subroutine of build_vec_init. Returns true if assigning to an array of
4155 INNER_ELT_TYPE from INIT is trivial. */
4158 vec_copy_assign_is_trivial (tree inner_elt_type
, tree init
)
4160 tree fromtype
= inner_elt_type
;
4161 if (lvalue_p (init
))
4162 fromtype
= cp_build_reference_type (fromtype
, /*rval*/false);
4163 return is_trivially_xible (MODIFY_EXPR
, inner_elt_type
, fromtype
);
4166 /* Subroutine of build_vec_init: Check that the array has at least N
4167 elements. Other parameters are local variables in build_vec_init. */
4170 finish_length_check (tree atype
, tree iterator
, tree obase
, unsigned n
)
4172 tree nelts
= build_int_cst (ptrdiff_type_node
, n
- 1);
4173 if (TREE_CODE (atype
) != ARRAY_TYPE
)
4175 if (flag_exceptions
)
4177 tree c
= fold_build2 (LT_EXPR
, boolean_type_node
, iterator
,
4179 c
= build3 (COND_EXPR
, void_type_node
, c
,
4180 throw_bad_array_new_length (), void_node
);
4181 finish_expr_stmt (c
);
4183 /* Don't check an array new when -fno-exceptions. */
4185 else if (sanitize_flags_p (SANITIZE_BOUNDS
)
4186 && current_function_decl
!= NULL_TREE
)
4188 /* Make sure the last element of the initializer is in bounds. */
4190 (ubsan_instrument_bounds
4191 (input_location
, obase
, &nelts
, /*ignore_off_by_one*/false));
4195 /* `build_vec_init' returns tree structure that performs
4196 initialization of a vector of aggregate types.
4198 BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
4199 to the first element, of POINTER_TYPE.
4200 MAXINDEX is the maximum index of the array (one less than the
4201 number of elements). It is only used if BASE is a pointer or
4202 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
4204 INIT is the (possibly NULL) initializer.
4206 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All
4207 elements in the array are value-initialized.
4209 FROM_ARRAY is 0 if we should init everything with INIT
4210 (i.e., every element initialized from INIT).
4211 FROM_ARRAY is 1 if we should index into INIT in parallel
4212 with initialization of DECL.
4213 FROM_ARRAY is 2 if we should index into INIT in parallel,
4214 but use assignment instead of initialization. */
4217 build_vec_init (tree base
, tree maxindex
, tree init
,
4218 bool explicit_value_init_p
,
4219 int from_array
, tsubst_flags_t complain
)
4222 tree base2
= NULL_TREE
;
4223 tree itype
= NULL_TREE
;
4225 /* The type of BASE. */
4226 tree atype
= TREE_TYPE (base
);
4227 /* The type of an element in the array. */
4228 tree type
= TREE_TYPE (atype
);
4229 /* The element type reached after removing all outer array
4231 tree inner_elt_type
;
4232 /* The type of a pointer to an element in the array. */
4237 tree try_block
= NULL_TREE
;
4238 HOST_WIDE_INT num_initialized_elts
= 0;
4241 bool xvalue
= false;
4242 bool errors
= false;
4243 location_t loc
= (init
? cp_expr_loc_or_input_loc (init
)
4244 : location_of (base
));
4246 if (TREE_CODE (atype
) == ARRAY_TYPE
&& TYPE_DOMAIN (atype
))
4247 maxindex
= array_type_nelts (atype
);
4249 if (maxindex
== NULL_TREE
|| maxindex
== error_mark_node
)
4250 return error_mark_node
;
4252 maxindex
= maybe_constant_value (maxindex
);
4253 if (explicit_value_init_p
)
4256 inner_elt_type
= strip_array_types (type
);
4258 /* Look through the TARGET_EXPR around a compound literal. */
4259 if (init
&& TREE_CODE (init
) == TARGET_EXPR
4260 && TREE_CODE (TARGET_EXPR_INITIAL (init
)) == CONSTRUCTOR
4262 init
= TARGET_EXPR_INITIAL (init
);
4264 bool direct_init
= false;
4265 if (from_array
&& init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
4266 && CONSTRUCTOR_NELTS (init
) == 1)
4268 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
4269 if (TREE_CODE (TREE_TYPE (elt
)) == ARRAY_TYPE
)
4271 direct_init
= DIRECT_LIST_INIT_P (init
);
4276 /* If we have a braced-init-list or string constant, make sure that the array
4277 is big enough for all the initializers. */
4278 bool length_check
= (init
4279 && (TREE_CODE (init
) == STRING_CST
4280 || (TREE_CODE (init
) == CONSTRUCTOR
4281 && CONSTRUCTOR_NELTS (init
) > 0))
4282 && !TREE_CONSTANT (maxindex
));
4285 && TREE_CODE (atype
) == ARRAY_TYPE
4286 && TREE_CONSTANT (maxindex
)
4288 ? vec_copy_assign_is_trivial (inner_elt_type
, init
)
4289 : !TYPE_NEEDS_CONSTRUCTING (type
))
4290 && ((TREE_CODE (init
) == CONSTRUCTOR
4291 && (BRACE_ENCLOSED_INITIALIZER_P (init
)
4292 || (same_type_ignoring_top_level_qualifiers_p
4293 (atype
, TREE_TYPE (init
))))
4294 /* Don't do this if the CONSTRUCTOR might contain something
4295 that might throw and require us to clean up. */
4296 && (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
))
4297 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type
)))
4300 /* Do non-default initialization of trivial arrays resulting from
4301 brace-enclosed initializers. In this case, digest_init and
4302 store_constructor will handle the semantics for us. */
4304 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
4305 init
= digest_init (atype
, init
, complain
);
4306 stmt_expr
= build2 (INIT_EXPR
, atype
, base
, init
);
4310 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
, complain
);
4311 maxindex
= fold_simple (maxindex
);
4313 if (TREE_CODE (atype
) == ARRAY_TYPE
)
4315 ptype
= build_pointer_type (type
);
4316 base
= decay_conversion (base
, complain
);
4317 if (base
== error_mark_node
)
4318 return error_mark_node
;
4319 base
= cp_convert (ptype
, base
, complain
);
4324 /* The code we are generating looks like:
4328 ptrdiff_t iterator = maxindex;
4330 for (; iterator != -1; --iterator) {
4331 ... initialize *t1 ...
4335 ... destroy elements that were constructed ...
4340 We can omit the try and catch blocks if we know that the
4341 initialization will never throw an exception, or if the array
4342 elements do not have destructors. We can omit the loop completely if
4343 the elements of the array do not have constructors.
4345 We actually wrap the entire body of the above in a STMT_EXPR, for
4348 When copying from array to another, when the array elements have
4349 only trivial copy constructors, we should use __builtin_memcpy
4350 rather than generating a loop. That way, we could take advantage
4351 of whatever cleverness the back end has for dealing with copies
4352 of blocks of memory. */
4354 is_global
= begin_init_stmts (&stmt_expr
, &compound_stmt
);
4355 destroy_temps
= stmts_are_full_exprs_p ();
4356 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
4357 rval
= get_temp_regvar (ptype
, base
);
4358 base
= get_temp_regvar (ptype
, rval
);
4359 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
4361 /* If initializing one array from another, initialize element by
4362 element. We rely upon the below calls to do the argument
4363 checking. Evaluate the initializer before entering the try block. */
4364 if (from_array
&& init
&& TREE_CODE (init
) != CONSTRUCTOR
)
4366 if (lvalue_kind (init
) & clk_rvalueref
)
4368 base2
= decay_conversion (init
, complain
);
4369 if (base2
== error_mark_node
)
4370 return error_mark_node
;
4371 itype
= TREE_TYPE (base2
);
4372 base2
= get_temp_regvar (itype
, base2
);
4373 itype
= TREE_TYPE (itype
);
4376 /* Protect the entire array initialization so that we can destroy
4377 the partially constructed array if an exception is thrown.
4378 But don't do this if we're assigning. */
4379 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
4382 try_block
= begin_try_block ();
4385 /* Should we try to create a constant initializer? */
4386 bool try_const
= (TREE_CODE (atype
) == ARRAY_TYPE
4387 && TREE_CONSTANT (maxindex
)
4388 && (init
? TREE_CODE (init
) == CONSTRUCTOR
4389 : (type_has_constexpr_default_constructor
4391 && (literal_type_p (inner_elt_type
)
4392 || TYPE_HAS_CONSTEXPR_CTOR (inner_elt_type
)));
4393 vec
<constructor_elt
, va_gc
> *const_vec
= NULL
;
4394 bool saw_non_const
= false;
4395 /* If we're initializing a static array, we want to do static
4396 initialization of any elements with constant initializers even if
4397 some are non-constant. */
4398 bool do_static_init
= (DECL_P (obase
) && TREE_STATIC (obase
));
4400 bool empty_list
= false;
4401 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
4402 && CONSTRUCTOR_NELTS (init
) == 0)
4403 /* Skip over the handling of non-empty init lists. */
4406 /* Maybe pull out constant value when from_array? */
4408 else if (init
!= NULL_TREE
&& TREE_CODE (init
) == CONSTRUCTOR
)
4410 /* Do non-default initialization of non-trivial arrays resulting from
4411 brace-enclosed initializers. */
4412 unsigned HOST_WIDE_INT idx
;
4414 /* If the constructor already has the array type, it's been through
4415 digest_init, so we shouldn't try to do anything more. */
4416 bool digested
= same_type_p (atype
, TREE_TYPE (init
));
4420 finish_length_check (atype
, iterator
, obase
, CONSTRUCTOR_NELTS (init
));
4423 vec_alloc (const_vec
, CONSTRUCTOR_NELTS (init
));
4425 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
, field
, elt
)
4427 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
4430 num_initialized_elts
++;
4432 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
4434 one_init
= build2 (INIT_EXPR
, type
, baseref
, elt
);
4435 else if (MAYBE_CLASS_TYPE_P (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
4436 one_init
= build_aggr_init (baseref
, elt
, 0, complain
);
4438 one_init
= cp_build_modify_expr (input_location
, baseref
,
4439 NOP_EXPR
, elt
, complain
);
4440 if (one_init
== error_mark_node
)
4444 tree e
= maybe_constant_init (one_init
);
4445 if (reduced_constant_expression_p (e
))
4447 CONSTRUCTOR_APPEND_ELT (const_vec
, field
, e
);
4449 one_init
= NULL_TREE
;
4451 one_init
= build2 (INIT_EXPR
, type
, baseref
, e
);
4457 tree value
= build_zero_init (TREE_TYPE (e
), NULL_TREE
,
4460 CONSTRUCTOR_APPEND_ELT (const_vec
, field
, value
);
4462 saw_non_const
= true;
4467 finish_expr_stmt (one_init
);
4468 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
4470 one_init
= cp_build_unary_op (PREINCREMENT_EXPR
, base
, false,
4472 if (one_init
== error_mark_node
)
4475 finish_expr_stmt (one_init
);
4477 one_init
= cp_build_unary_op (PREDECREMENT_EXPR
, iterator
, false,
4479 if (one_init
== error_mark_node
)
4482 finish_expr_stmt (one_init
);
4485 /* Any elements without explicit initializers get T{}. */
4488 else if (init
&& TREE_CODE (init
) == STRING_CST
)
4490 /* Check that the array is at least as long as the string. */
4492 finish_length_check (atype
, iterator
, obase
,
4493 TREE_STRING_LENGTH (init
));
4494 tree length
= build_int_cst (ptrdiff_type_node
,
4495 TREE_STRING_LENGTH (init
));
4497 /* Copy the string to the first part of the array. */
4498 tree alias_set
= build_int_cst (build_pointer_type (type
), 0);
4499 tree lhs
= build2 (MEM_REF
, TREE_TYPE (init
), base
, alias_set
);
4500 tree stmt
= build2 (MODIFY_EXPR
, void_type_node
, lhs
, init
);
4501 finish_expr_stmt (stmt
);
4503 /* Adjust the counter and pointer. */
4504 stmt
= cp_build_binary_op (loc
, MINUS_EXPR
, iterator
, length
, complain
);
4505 stmt
= build2 (MODIFY_EXPR
, void_type_node
, iterator
, stmt
);
4506 finish_expr_stmt (stmt
);
4508 stmt
= cp_build_binary_op (loc
, PLUS_EXPR
, base
, length
, complain
);
4509 stmt
= build2 (MODIFY_EXPR
, void_type_node
, base
, stmt
);
4510 finish_expr_stmt (stmt
);
4512 /* And set the rest of the array to NUL. */
4514 explicit_value_init_p
= true;
4516 else if (from_array
)
4519 /* OK, we set base2 above. */;
4520 else if (CLASS_TYPE_P (type
)
4521 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
4523 if (complain
& tf_error
)
4524 error ("initializer ends prematurely");
4529 /* Now, default-initialize any remaining elements. We don't need to
4530 do that if a) the type does not need constructing, or b) we've
4531 already initialized all the elements.
4533 We do need to keep going if we're copying an array. */
4535 if (try_const
&& !init
)
4536 /* With a constexpr default constructor, which we checked for when
4537 setting try_const above, default-initialization is equivalent to
4538 value-initialization, and build_value_init gives us something more
4539 friendly to maybe_constant_init. */
4540 explicit_value_init_p
= true;
4542 || ((type_build_ctor_call (type
) || init
|| explicit_value_init_p
)
4543 && ! (tree_fits_shwi_p (maxindex
)
4544 && (num_initialized_elts
4545 == tree_to_shwi (maxindex
) + 1))))
4547 /* If the ITERATOR is lesser or equal to -1, then we don't have to loop;
4548 we've already initialized all the elements. */
4553 for_stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
4554 finish_init_stmt (for_stmt
);
4555 finish_for_cond (build2 (GT_EXPR
, boolean_type_node
, iterator
,
4556 build_int_cst (TREE_TYPE (iterator
), -1)),
4557 for_stmt
, false, 0);
4558 elt_init
= cp_build_unary_op (PREDECREMENT_EXPR
, iterator
, false,
4560 if (elt_init
== error_mark_node
)
4562 finish_for_expr (elt_init
, for_stmt
);
4564 to
= build1 (INDIRECT_REF
, type
, base
);
4566 /* If the initializer is {}, then all elements are initialized from T{}.
4567 But for non-classes, that's the same as value-initialization. */
4570 if (cxx_dialect
>= cxx11
&& AGGREGATE_TYPE_P (type
))
4572 init
= build_constructor (init_list_type_node
, NULL
);
4577 explicit_value_init_p
= true;
4587 from
= build1 (INDIRECT_REF
, itype
, base2
);
4591 from
= build_tree_list (NULL_TREE
, from
);
4596 if (TREE_CODE (type
) == ARRAY_TYPE
)
4597 elt_init
= build_vec_init (to
, NULL_TREE
, from
, /*val_init*/false,
4598 from_array
, complain
);
4599 else if (from_array
== 2)
4600 elt_init
= cp_build_modify_expr (input_location
, to
, NOP_EXPR
,
4602 else if (type_build_ctor_call (type
))
4603 elt_init
= build_aggr_init (to
, from
, 0, complain
);
4605 elt_init
= cp_build_modify_expr (input_location
, to
, NOP_EXPR
, from
,
4610 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4612 if (init
&& !BRACE_ENCLOSED_INITIALIZER_P (init
))
4614 if ((complain
& tf_error
))
4615 error_at (loc
, "array must be initialized "
4616 "with a brace-enclosed initializer");
4617 elt_init
= error_mark_node
;
4620 elt_init
= build_vec_init (build1 (INDIRECT_REF
, type
, base
),
4622 explicit_value_init_p
,
4625 else if (explicit_value_init_p
)
4627 elt_init
= build_value_init (type
, complain
);
4628 if (elt_init
!= error_mark_node
)
4629 elt_init
= build2 (INIT_EXPR
, type
, to
, elt_init
);
4633 gcc_assert (type_build_ctor_call (type
) || init
);
4634 if (CLASS_TYPE_P (type
))
4635 elt_init
= build_aggr_init (to
, init
, 0, complain
);
4638 if (TREE_CODE (init
) == TREE_LIST
)
4639 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
4641 elt_init
= (init
== error_mark_node
4643 : build2 (INIT_EXPR
, type
, to
, init
));
4647 if (elt_init
== error_mark_node
)
4652 /* FIXME refs to earlier elts */
4653 tree e
= maybe_constant_init (elt_init
);
4654 if (reduced_constant_expression_p (e
))
4656 if (initializer_zerop (e
))
4657 /* Don't fill the CONSTRUCTOR with zeros. */
4660 elt_init
= NULL_TREE
;
4664 saw_non_const
= true;
4666 e
= build_zero_init (TREE_TYPE (e
), NULL_TREE
, true);
4673 HOST_WIDE_INT last
= tree_to_shwi (maxindex
);
4674 if (num_initialized_elts
<= last
)
4676 tree field
= size_int (num_initialized_elts
);
4677 if (num_initialized_elts
!= last
)
4678 field
= build2 (RANGE_EXPR
, sizetype
, field
,
4680 CONSTRUCTOR_APPEND_ELT (const_vec
, field
, e
);
4685 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
4686 if (elt_init
&& !errors
)
4687 finish_expr_stmt (elt_init
);
4688 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
4690 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR
, base
, false,
4693 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR
, base2
, false,
4696 finish_for_stmt (for_stmt
);
4699 /* Make sure to cleanup any partially constructed elements. */
4700 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
4704 tree m
= cp_build_binary_op (input_location
,
4705 MINUS_EXPR
, maxindex
, iterator
,
4708 /* Flatten multi-dimensional array since build_vec_delete only
4709 expects one-dimensional array. */
4710 if (TREE_CODE (type
) == ARRAY_TYPE
)
4711 m
= cp_build_binary_op (input_location
,
4713 /* Avoid mixing signed and unsigned. */
4714 convert (TREE_TYPE (m
),
4715 array_type_nelts_total (type
)),
4718 finish_cleanup_try_block (try_block
);
4719 e
= build_vec_delete_1 (input_location
, rval
, m
,
4720 inner_elt_type
, sfk_complete_destructor
,
4721 /*use_global_delete=*/0, complain
);
4722 if (e
== error_mark_node
)
4724 finish_cleanup (e
, try_block
);
4727 /* The value of the array initialization is the array itself, RVAL
4728 is a pointer to the first element. */
4729 finish_stmt_expr_expr (rval
, stmt_expr
);
4731 stmt_expr
= finish_init_stmts (is_global
, stmt_expr
, compound_stmt
);
4733 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
4736 return error_mark_node
;
4742 tree const_init
= build_constructor (atype
, const_vec
);
4743 return build2 (INIT_EXPR
, atype
, obase
, const_init
);
4745 else if (do_static_init
&& !vec_safe_is_empty (const_vec
))
4746 DECL_INITIAL (obase
) = build_constructor (atype
, const_vec
);
4748 vec_free (const_vec
);
4751 /* Now make the result have the correct type. */
4752 if (TREE_CODE (atype
) == ARRAY_TYPE
)
4754 atype
= build_pointer_type (atype
);
4755 stmt_expr
= build1 (NOP_EXPR
, atype
, stmt_expr
);
4756 stmt_expr
= cp_build_fold_indirect_ref (stmt_expr
);
4757 TREE_NO_WARNING (stmt_expr
) = 1;
4763 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
4767 build_dtor_call (tree exp
, special_function_kind dtor_kind
, int flags
,
4768 tsubst_flags_t complain
)
4773 case sfk_complete_destructor
:
4774 name
= complete_dtor_identifier
;
4777 case sfk_base_destructor
:
4778 name
= base_dtor_identifier
;
4781 case sfk_deleting_destructor
:
4782 name
= deleting_dtor_identifier
;
4789 return build_special_member_call (exp
, name
,
4791 /*binfo=*/TREE_TYPE (exp
),
4796 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
4797 ADDR is an expression which yields the store to be destroyed.
4798 AUTO_DELETE is the name of the destructor to call, i.e., either
4799 sfk_complete_destructor, sfk_base_destructor, or
4800 sfk_deleting_destructor.
4802 FLAGS is the logical disjunction of zero or more LOOKUP_
4803 flags. See cp-tree.h for more info. */
4806 build_delete (location_t loc
, tree otype
, tree addr
,
4807 special_function_kind auto_delete
,
4808 int flags
, int use_global_delete
, tsubst_flags_t complain
)
4812 if (addr
== error_mark_node
)
4813 return error_mark_node
;
4815 tree type
= TYPE_MAIN_VARIANT (otype
);
4817 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
4818 set to `error_mark_node' before it gets properly cleaned up. */
4819 if (type
== error_mark_node
)
4820 return error_mark_node
;
4822 if (TYPE_PTR_P (type
))
4823 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
4825 if (TREE_CODE (type
) == ARRAY_TYPE
)
4827 if (TYPE_DOMAIN (type
) == NULL_TREE
)
4829 if (complain
& tf_error
)
4830 error_at (loc
, "unknown array size in delete");
4831 return error_mark_node
;
4833 return build_vec_delete (loc
, addr
, array_type_nelts (type
),
4834 auto_delete
, use_global_delete
, complain
);
4837 bool deleting
= (auto_delete
== sfk_deleting_destructor
);
4838 gcc_assert (deleting
== !(flags
& LOOKUP_DESTRUCTOR
));
4840 if (TYPE_PTR_P (otype
))
4842 addr
= mark_rvalue_use (addr
);
4844 /* We don't want to warn about delete of void*, only other
4845 incomplete types. Deleting other incomplete types
4846 invokes undefined behavior, but it is not ill-formed, so
4847 compile to something that would even do The Right Thing
4848 (TM) should the type have a trivial dtor and no delete
4850 if (!VOID_TYPE_P (type
))
4852 complete_type (type
);
4854 && !verify_type_context (loc
, TCTX_DEALLOCATION
, type
,
4855 !(complain
& tf_error
)))
4856 return error_mark_node
;
4858 if (!COMPLETE_TYPE_P (type
))
4860 if (complain
& tf_warning
)
4862 auto_diagnostic_group d
;
4863 if (warning_at (loc
, OPT_Wdelete_incomplete
,
4864 "possible problem detected in invocation of "
4865 "%<operator delete%>"))
4867 cxx_incomplete_type_diagnostic (addr
, type
, DK_WARNING
);
4869 "neither the destructor nor the class-specific "
4870 "%<operator delete%> will be called, even if "
4871 "they are declared when the class is defined");
4875 else if (deleting
&& warn_delnonvdtor
4876 && MAYBE_CLASS_TYPE_P (type
) && !CLASSTYPE_FINAL (type
)
4877 && TYPE_POLYMORPHIC_P (type
))
4879 tree dtor
= CLASSTYPE_DESTRUCTOR (type
);
4880 if (!dtor
|| !DECL_VINDEX (dtor
))
4882 if (CLASSTYPE_PURE_VIRTUALS (type
))
4883 warning_at (loc
, OPT_Wdelete_non_virtual_dtor
,
4884 "deleting object of abstract class type %qT"
4885 " which has non-virtual destructor"
4886 " will cause undefined behavior", type
);
4888 warning_at (loc
, OPT_Wdelete_non_virtual_dtor
,
4889 "deleting object of polymorphic class type %qT"
4890 " which has non-virtual destructor"
4891 " might cause undefined behavior", type
);
4896 /* Throw away const and volatile on target type of addr. */
4897 addr
= convert_force (build_pointer_type (type
), addr
, 0, complain
);
4901 /* Don't check PROTECT here; leave that decision to the
4902 destructor. If the destructor is accessible, call it,
4903 else report error. */
4904 addr
= cp_build_addr_expr (addr
, complain
);
4905 if (addr
== error_mark_node
)
4906 return error_mark_node
;
4908 addr
= convert_force (build_pointer_type (type
), addr
, 0, complain
);
4912 /* We will use ADDR multiple times so we must save it. */
4913 addr
= save_expr (addr
);
4915 bool virtual_p
= false;
4916 if (type_build_dtor_call (type
))
4918 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
4919 lazily_declare_fn (sfk_destructor
, type
);
4920 virtual_p
= DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTOR (type
));
4923 tree head
= NULL_TREE
;
4924 tree do_delete
= NULL_TREE
;
4925 bool destroying_delete
= false;
4929 /* Leave do_delete null. */
4931 /* For `::delete x', we must not use the deleting destructor
4932 since then we would not be sure to get the global `operator
4934 else if (use_global_delete
)
4936 head
= get_target_expr (build_headof (addr
));
4937 /* Delete the object. */
4938 do_delete
= build_op_delete_call (DELETE_EXPR
,
4940 cxx_sizeof_nowarn (type
),
4942 /*placement=*/NULL_TREE
,
4943 /*alloc_fn=*/NULL_TREE
,
4945 /* Otherwise, treat this like a complete object destructor
4947 auto_delete
= sfk_complete_destructor
;
4949 /* If the destructor is non-virtual, there is no deleting
4950 variant. Instead, we must explicitly call the appropriate
4951 `operator delete' here. */
4952 else if (!virtual_p
)
4954 /* Build the call. */
4955 do_delete
= build_op_delete_call (DELETE_EXPR
,
4957 cxx_sizeof_nowarn (type
),
4959 /*placement=*/NULL_TREE
,
4960 /*alloc_fn=*/NULL_TREE
,
4962 /* Call the complete object destructor. */
4963 auto_delete
= sfk_complete_destructor
;
4964 if (do_delete
!= error_mark_node
)
4966 tree fn
= get_callee_fndecl (do_delete
);
4967 destroying_delete
= destroying_delete_p (fn
);
4970 else if (TYPE_GETS_REG_DELETE (type
))
4972 /* Make sure we have access to the member op delete, even though
4973 we'll actually be calling it from the destructor. */
4974 build_op_delete_call (DELETE_EXPR
, addr
, cxx_sizeof_nowarn (type
),
4976 /*placement=*/NULL_TREE
,
4977 /*alloc_fn=*/NULL_TREE
,
4981 if (!destroying_delete
&& type_build_dtor_call (type
))
4982 expr
= build_dtor_call (cp_build_fold_indirect_ref (addr
),
4983 auto_delete
, flags
, complain
);
4985 expr
= build_trivial_dtor_call (addr
);
4986 if (expr
== error_mark_node
)
4987 return error_mark_node
;
4991 protected_set_expr_location (expr
, loc
);
4997 tree do_delete_call_expr
= extract_call_expr (do_delete
);
4998 if (TREE_CODE (do_delete_call_expr
) == CALL_EXPR
)
4999 CALL_FROM_NEW_OR_DELETE_P (do_delete_call_expr
) = 1;
5002 if (do_delete
&& !TREE_SIDE_EFFECTS (expr
))
5005 /* The delete operator must be called, regardless of whether
5006 the destructor throws.
5008 [expr.delete]/7 The deallocation function is called
5009 regardless of whether the destructor for the object or some
5010 element of the array throws an exception. */
5011 expr
= build2 (TRY_FINALLY_EXPR
, void_type_node
, expr
, do_delete
);
5013 /* We need to calculate this before the dtor changes the vptr. */
5015 expr
= build2 (COMPOUND_EXPR
, void_type_node
, head
, expr
);
5017 /* Handle deleting a null pointer. */
5018 warning_sentinel
s (warn_address
);
5019 tree ifexp
= cp_build_binary_op (loc
, NE_EXPR
, addr
,
5020 nullptr_node
, complain
);
5021 ifexp
= cp_fully_fold (ifexp
);
5023 if (ifexp
== error_mark_node
)
5024 return error_mark_node
;
5025 /* This is a compiler generated comparison, don't emit
5026 e.g. -Wnonnull-compare warning for it. */
5027 else if (TREE_CODE (ifexp
) == NE_EXPR
)
5028 TREE_NO_WARNING (ifexp
) = 1;
5030 if (!integer_nonzerop (ifexp
))
5031 expr
= build3 (COND_EXPR
, void_type_node
, ifexp
, expr
, void_node
);
5033 protected_set_expr_location (expr
, loc
);
5037 /* At the beginning of a destructor, push cleanups that will call the
5038 destructors for our base classes and members.
5040 Called from begin_destructor_body. */
5043 push_base_cleanups (void)
5045 tree binfo
, base_binfo
;
5049 vec
<tree
, va_gc
> *vbases
;
5051 /* Run destructors for all virtual baseclasses. */
5052 if (!ABSTRACT_CLASS_TYPE_P (current_class_type
)
5053 && CLASSTYPE_VBASECLASSES (current_class_type
))
5055 tree cond
= (condition_conversion
5056 (build2 (BIT_AND_EXPR
, integer_type_node
,
5057 current_in_charge_parm
,
5058 integer_two_node
)));
5060 /* The CLASSTYPE_VBASECLASSES vector is in initialization
5061 order, which is also the right order for pushing cleanups. */
5062 for (vbases
= CLASSTYPE_VBASECLASSES (current_class_type
), i
= 0;
5063 vec_safe_iterate (vbases
, i
, &base_binfo
); i
++)
5065 if (type_build_dtor_call (BINFO_TYPE (base_binfo
)))
5067 expr
= build_special_member_call (current_class_ref
,
5068 base_dtor_identifier
,
5072 | LOOKUP_NONVIRTUAL
),
5073 tf_warning_or_error
);
5074 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
5076 expr
= build3 (COND_EXPR
, void_type_node
, cond
,
5078 finish_decl_cleanup (NULL_TREE
, expr
);
5084 /* Take care of the remaining baseclasses. */
5085 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
5086 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5088 if (BINFO_VIRTUAL_P (base_binfo
)
5089 || !type_build_dtor_call (BINFO_TYPE (base_binfo
)))
5092 expr
= build_special_member_call (current_class_ref
,
5093 base_dtor_identifier
,
5095 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
5096 tf_warning_or_error
);
5097 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
5098 finish_decl_cleanup (NULL_TREE
, expr
);
5101 /* Don't automatically destroy union members. */
5102 if (TREE_CODE (current_class_type
) == UNION_TYPE
)
5105 for (member
= TYPE_FIELDS (current_class_type
); member
;
5106 member
= DECL_CHAIN (member
))
5108 tree this_type
= TREE_TYPE (member
);
5109 if (this_type
== error_mark_node
5110 || TREE_CODE (member
) != FIELD_DECL
5111 || DECL_ARTIFICIAL (member
))
5113 if (ANON_AGGR_TYPE_P (this_type
))
5115 if (type_build_dtor_call (this_type
))
5117 tree this_member
= (build_class_member_access_expr
5118 (current_class_ref
, member
,
5119 /*access_path=*/NULL_TREE
,
5120 /*preserve_reference=*/false,
5121 tf_warning_or_error
));
5122 expr
= build_delete (input_location
, this_type
, this_member
,
5123 sfk_complete_destructor
,
5124 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
,
5125 0, tf_warning_or_error
);
5126 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (this_type
))
5127 finish_decl_cleanup (NULL_TREE
, expr
);
5132 /* Build a C++ vector delete expression.
5133 MAXINDEX is the number of elements to be deleted.
5134 ELT_SIZE is the nominal size of each element in the vector.
5135 BASE is the expression that should yield the store to be deleted.
5136 This function expands (or synthesizes) these calls itself.
5137 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
5139 This also calls delete for virtual baseclasses of elements of the vector.
5141 Update: MAXINDEX is no longer needed. The size can be extracted from the
5142 start of the vector for pointers, and from the type for arrays. We still
5143 use MAXINDEX for arrays because it happens to already have one of the
5144 values we'd have to extract. (We could use MAXINDEX with pointers to
5145 confirm the size, and trap if the numbers differ; not clear that it'd
5146 be worth bothering.) */
5149 build_vec_delete (location_t loc
, tree base
, tree maxindex
,
5150 special_function_kind auto_delete_vec
,
5151 int use_global_delete
, tsubst_flags_t complain
)
5155 tree base_init
= NULL_TREE
;
5157 type
= TREE_TYPE (base
);
5159 if (TYPE_PTR_P (type
))
5161 /* Step back one from start of vector, and read dimension. */
5163 tree size_ptr_type
= build_pointer_type (sizetype
);
5165 base
= mark_rvalue_use (base
);
5166 if (TREE_SIDE_EFFECTS (base
))
5168 base_init
= get_target_expr (base
);
5169 base
= TARGET_EXPR_SLOT (base_init
);
5171 type
= strip_array_types (TREE_TYPE (type
));
5172 cookie_addr
= fold_build1_loc (loc
, NEGATE_EXPR
,
5173 sizetype
, TYPE_SIZE_UNIT (sizetype
));
5174 cookie_addr
= fold_build_pointer_plus (fold_convert (size_ptr_type
, base
),
5176 maxindex
= cp_build_fold_indirect_ref (cookie_addr
);
5178 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5180 /* Get the total number of things in the array, maxindex is a
5182 maxindex
= array_type_nelts_total (type
);
5183 type
= strip_array_types (type
);
5184 base
= decay_conversion (base
, complain
);
5185 if (base
== error_mark_node
)
5186 return error_mark_node
;
5187 if (TREE_SIDE_EFFECTS (base
))
5189 base_init
= get_target_expr (base
);
5190 base
= TARGET_EXPR_SLOT (base_init
);
5195 if (base
!= error_mark_node
&& !(complain
& tf_error
))
5197 "type to vector delete is neither pointer or array type");
5198 return error_mark_node
;
5201 rval
= build_vec_delete_1 (loc
, base
, maxindex
, type
, auto_delete_vec
,
5202 use_global_delete
, complain
);
5203 if (base_init
&& rval
!= error_mark_node
)
5204 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), base_init
, rval
);
5206 protected_set_expr_location (rval
, loc
);
5210 #include "gt-cp-init.h"