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