1 /* Handle initialization things in C++.
2 Copyright (C) 1987-2018 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"
37 static bool begin_init_stmts (tree
*, tree
*);
38 static tree
finish_init_stmts (bool, tree
, tree
);
39 static void construct_virtual_base (tree
, tree
);
40 static void expand_aggr_init_1 (tree
, tree
, tree
, tree
, int, tsubst_flags_t
);
41 static void expand_default_init (tree
, tree
, tree
, tree
, int, tsubst_flags_t
);
42 static void perform_member_init (tree
, tree
);
43 static int member_init_ok_or_else (tree
, tree
, tree
);
44 static void expand_virtual_init (tree
, tree
);
45 static tree
sort_mem_initializers (tree
, tree
);
46 static tree
initializing_context (tree
);
47 static void expand_cleanup_for_base (tree
, tree
);
48 static tree
dfs_initialize_vtbl_ptrs (tree
, void *);
49 static tree
build_field_list (tree
, tree
, int *);
50 static int diagnose_uninitialized_cst_or_ref_member_1 (tree
, tree
, bool, bool);
52 static GTY(()) tree fn
;
54 /* We are about to generate some complex initialization code.
55 Conceptually, it is all a single expression. However, we may want
56 to include conditionals, loops, and other such statement-level
57 constructs. Therefore, we build the initialization code inside a
58 statement-expression. This function starts such an expression.
59 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
60 pass them back to finish_init_stmts when the expression is
64 begin_init_stmts (tree
*stmt_expr_p
, tree
*compound_stmt_p
)
66 bool is_global
= !building_stmt_list_p ();
68 *stmt_expr_p
= begin_stmt_expr ();
69 *compound_stmt_p
= begin_compound_stmt (BCS_NO_SCOPE
);
74 /* Finish out the statement-expression begun by the previous call to
75 begin_init_stmts. Returns the statement-expression itself. */
78 finish_init_stmts (bool is_global
, tree stmt_expr
, tree compound_stmt
)
80 finish_compound_stmt (compound_stmt
);
82 stmt_expr
= finish_stmt_expr (stmt_expr
, true);
84 gcc_assert (!building_stmt_list_p () == is_global
);
91 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
92 which we want to initialize the vtable pointer for, DATA is
93 TREE_LIST whose TREE_VALUE is the this ptr expression. */
96 dfs_initialize_vtbl_ptrs (tree binfo
, void *data
)
98 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
99 return dfs_skip_bases
;
101 if (!BINFO_PRIMARY_P (binfo
) || BINFO_VIRTUAL_P (binfo
))
103 tree base_ptr
= TREE_VALUE ((tree
) data
);
105 base_ptr
= build_base_path (PLUS_EXPR
, base_ptr
, binfo
, /*nonnull=*/1,
106 tf_warning_or_error
);
108 expand_virtual_init (binfo
, base_ptr
);
114 /* Initialize all the vtable pointers in the object pointed to by
118 initialize_vtbl_ptrs (tree addr
)
123 type
= TREE_TYPE (TREE_TYPE (addr
));
124 list
= build_tree_list (type
, addr
);
126 /* Walk through the hierarchy, initializing the vptr in each base
127 class. We do these in pre-order because we can't find the virtual
128 bases for a class until we've initialized the vtbl for that
130 dfs_walk_once (TYPE_BINFO (type
), dfs_initialize_vtbl_ptrs
, NULL
, list
);
133 /* Return an expression for the zero-initialization of an object with
134 type T. This expression will either be a constant (in the case
135 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
136 aggregate), or NULL (in the case that T does not require
137 initialization). In either case, the value can be used as
138 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
139 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
140 is the number of elements in the array. If STATIC_STORAGE_P is
141 TRUE, initializers are only generated for entities for which
142 zero-initialization does not simply mean filling the storage with
143 zero bytes. FIELD_SIZE, if non-NULL, is the bit size of the field,
144 subfields with bit positions at or above that bit size shouldn't
145 be added. Note that this only works when the result is assigned
146 to a base COMPONENT_REF; if we only have a pointer to the base subobject,
147 expand_assignment will end up clearing the full size of TYPE. */
150 build_zero_init_1 (tree type
, tree nelts
, bool static_storage_p
,
153 tree init
= NULL_TREE
;
157 To zero-initialize an object of type T means:
159 -- if T is a scalar type, the storage is set to the value of zero
162 -- if T is a non-union class type, the storage for each nonstatic
163 data member and each base-class subobject is zero-initialized.
165 -- if T is a union type, the storage for its first data member is
168 -- if T is an array type, the storage for each element is
171 -- if T is a reference type, no initialization is performed. */
173 gcc_assert (nelts
== NULL_TREE
|| TREE_CODE (nelts
) == INTEGER_CST
);
175 if (type
== error_mark_node
)
177 else if (static_storage_p
&& zero_init_p (type
))
178 /* In order to save space, we do not explicitly build initializers
179 for items that do not need them. GCC's semantics are that
180 items with static storage duration that are not otherwise
181 initialized are initialized to zero. */
183 else if (TYPE_PTR_OR_PTRMEM_P (type
))
184 init
= fold (convert (type
, nullptr_node
));
185 else if (SCALAR_TYPE_P (type
))
186 init
= fold (convert (type
, integer_zero_node
));
187 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (type
)))
190 vec
<constructor_elt
, va_gc
> *v
= NULL
;
192 /* Iterate over the fields, building initializations. */
193 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
195 if (TREE_CODE (field
) != FIELD_DECL
)
198 if (TREE_TYPE (field
) == error_mark_node
)
201 /* Don't add virtual bases for base classes if they are beyond
202 the size of the current field, that means it is present
203 somewhere else in the object. */
206 tree bitpos
= bit_position (field
);
207 if (TREE_CODE (bitpos
) == INTEGER_CST
208 && !tree_int_cst_lt (bitpos
, field_size
))
212 /* Note that for class types there will be FIELD_DECLs
213 corresponding to base classes as well. Thus, iterating
214 over TYPE_FIELDs will result in correct initialization of
215 all of the subobjects. */
216 if (!static_storage_p
|| !zero_init_p (TREE_TYPE (field
)))
219 = (DECL_FIELD_IS_BASE (field
)
221 && TREE_CODE (DECL_SIZE (field
)) == INTEGER_CST
)
222 ? DECL_SIZE (field
) : NULL_TREE
;
223 tree value
= build_zero_init_1 (TREE_TYPE (field
),
228 CONSTRUCTOR_APPEND_ELT(v
, field
, value
);
231 /* For unions, only the first field is initialized. */
232 if (TREE_CODE (type
) == UNION_TYPE
)
236 /* Build a constructor to contain the initializations. */
237 init
= build_constructor (type
, v
);
239 else if (TREE_CODE (type
) == ARRAY_TYPE
)
242 vec
<constructor_elt
, va_gc
> *v
= NULL
;
244 /* Iterate over the array elements, building initializations. */
246 max_index
= fold_build2_loc (input_location
,
247 MINUS_EXPR
, TREE_TYPE (nelts
),
248 nelts
, integer_one_node
);
250 max_index
= array_type_nelts (type
);
252 /* If we have an error_mark here, we should just return error mark
253 as we don't know the size of the array yet. */
254 if (max_index
== error_mark_node
)
255 return error_mark_node
;
256 gcc_assert (TREE_CODE (max_index
) == INTEGER_CST
);
258 /* A zero-sized array, which is accepted as an extension, will
259 have an upper bound of -1. */
260 if (!tree_int_cst_equal (max_index
, integer_minus_one_node
))
264 /* If this is a one element array, we just use a regular init. */
265 if (tree_int_cst_equal (size_zero_node
, max_index
))
266 ce
.index
= size_zero_node
;
268 ce
.index
= build2 (RANGE_EXPR
, sizetype
, size_zero_node
,
271 ce
.value
= build_zero_init_1 (TREE_TYPE (type
),
273 static_storage_p
, NULL_TREE
);
281 /* Build a constructor to contain the initializations. */
282 init
= build_constructor (type
, v
);
284 else if (VECTOR_TYPE_P (type
))
285 init
= build_zero_cst (type
);
288 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
289 init
= build_zero_cst (type
);
292 /* In all cases, the initializer is a constant. */
294 TREE_CONSTANT (init
) = 1;
299 /* Return an expression for the zero-initialization of an object with
300 type T. This expression will either be a constant (in the case
301 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
302 aggregate), or NULL (in the case that T does not require
303 initialization). In either case, the value can be used as
304 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
305 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
306 is the number of elements in the array. If STATIC_STORAGE_P is
307 TRUE, initializers are only generated for entities for which
308 zero-initialization does not simply mean filling the storage with
312 build_zero_init (tree type
, tree nelts
, bool static_storage_p
)
314 return build_zero_init_1 (type
, nelts
, static_storage_p
, NULL_TREE
);
317 /* Return a suitable initializer for value-initializing an object of type
318 TYPE, as described in [dcl.init]. */
321 build_value_init (tree type
, tsubst_flags_t complain
)
325 To value-initialize an object of type T means:
327 - if T is a class type (clause 9) with either no default constructor
328 (12.1) or a default constructor that is user-provided or deleted,
329 then the object is default-initialized;
331 - if T is a (possibly cv-qualified) class type without a user-provided
332 or deleted default constructor, then the object is zero-initialized
333 and the semantic constraints for default-initialization are checked,
334 and if T has a non-trivial default constructor, the object is
337 - if T is an array type, then each element is value-initialized;
339 - otherwise, the object is zero-initialized.
341 A program that calls for default-initialization or
342 value-initialization of an entity of reference type is ill-formed. */
344 /* The AGGR_INIT_EXPR tweaking below breaks in templates. */
345 gcc_assert (!processing_template_decl
346 || (SCALAR_TYPE_P (type
) || TREE_CODE (type
) == ARRAY_TYPE
));
348 if (CLASS_TYPE_P (type
)
349 && type_build_ctor_call (type
))
352 build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
353 NULL
, type
, LOOKUP_NORMAL
,
355 if (ctor
== error_mark_node
)
358 if (TREE_CODE (ctor
) == CALL_EXPR
)
359 fn
= get_callee_fndecl (ctor
);
360 ctor
= build_aggr_init_expr (type
, ctor
);
361 if (fn
&& user_provided_p (fn
))
363 else if (TYPE_HAS_COMPLEX_DFLT (type
))
365 /* This is a class that needs constructing, but doesn't have
366 a user-provided constructor. So we need to zero-initialize
367 the object and then call the implicitly defined ctor.
368 This will be handled in simplify_aggr_init_expr. */
369 AGGR_INIT_ZERO_FIRST (ctor
) = 1;
374 /* Discard any access checking during subobject initialization;
375 the checks are implied by the call to the ctor which we have
376 verified is OK (cpp0x/defaulted46.C). */
377 push_deferring_access_checks (dk_deferred
);
378 tree r
= build_value_init_noctor (type
, complain
);
379 pop_deferring_access_checks ();
383 /* Like build_value_init, but don't call the constructor for TYPE. Used
384 for base initializers. */
387 build_value_init_noctor (tree type
, tsubst_flags_t complain
)
389 if (!COMPLETE_TYPE_P (type
))
391 if (complain
& tf_error
)
392 error ("value-initialization of incomplete type %qT", type
);
393 return error_mark_node
;
395 /* FIXME the class and array cases should just use digest_init once it is
397 if (CLASS_TYPE_P (type
))
399 gcc_assert (!TYPE_HAS_COMPLEX_DFLT (type
)
402 if (TREE_CODE (type
) != UNION_TYPE
)
405 vec
<constructor_elt
, va_gc
> *v
= NULL
;
407 /* Iterate over the fields, building initializations. */
408 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
412 if (TREE_CODE (field
) != FIELD_DECL
)
415 ftype
= TREE_TYPE (field
);
417 if (ftype
== error_mark_node
)
420 /* We could skip vfields and fields of types with
421 user-defined constructors, but I think that won't improve
422 performance at all; it should be simpler in general just
423 to zero out the entire object than try to only zero the
424 bits that actually need it. */
426 /* Note that for class types there will be FIELD_DECLs
427 corresponding to base classes as well. Thus, iterating
428 over TYPE_FIELDs will result in correct initialization of
429 all of the subobjects. */
430 value
= build_value_init (ftype
, complain
);
431 value
= maybe_constant_init (value
);
433 if (value
== error_mark_node
)
434 return error_mark_node
;
436 CONSTRUCTOR_APPEND_ELT(v
, field
, value
);
438 /* We shouldn't have gotten here for anything that would need
439 non-trivial initialization, and gimplify_init_ctor_preeval
440 would need to be fixed to allow it. */
441 gcc_assert (TREE_CODE (value
) != TARGET_EXPR
442 && TREE_CODE (value
) != AGGR_INIT_EXPR
);
445 /* Build a constructor to contain the zero- initializations. */
446 return build_constructor (type
, v
);
449 else if (TREE_CODE (type
) == ARRAY_TYPE
)
451 vec
<constructor_elt
, va_gc
> *v
= NULL
;
453 /* Iterate over the array elements, building initializations. */
454 tree max_index
= array_type_nelts (type
);
456 /* If we have an error_mark here, we should just return error mark
457 as we don't know the size of the array yet. */
458 if (max_index
== error_mark_node
)
460 if (complain
& tf_error
)
461 error ("cannot value-initialize array of unknown bound %qT",
463 return error_mark_node
;
465 gcc_assert (TREE_CODE (max_index
) == INTEGER_CST
);
467 /* A zero-sized array, which is accepted as an extension, will
468 have an upper bound of -1. */
469 if (!tree_int_cst_equal (max_index
, integer_minus_one_node
))
473 /* If this is a one element array, we just use a regular init. */
474 if (tree_int_cst_equal (size_zero_node
, max_index
))
475 ce
.index
= size_zero_node
;
477 ce
.index
= build2 (RANGE_EXPR
, sizetype
, size_zero_node
, max_index
);
479 ce
.value
= build_value_init (TREE_TYPE (type
), complain
);
480 ce
.value
= maybe_constant_init (ce
.value
);
481 if (ce
.value
== error_mark_node
)
482 return error_mark_node
;
487 /* We shouldn't have gotten here for anything that would need
488 non-trivial initialization, and gimplify_init_ctor_preeval
489 would need to be fixed to allow it. */
490 gcc_assert (TREE_CODE (ce
.value
) != TARGET_EXPR
491 && TREE_CODE (ce
.value
) != AGGR_INIT_EXPR
);
494 /* Build a constructor to contain the initializations. */
495 return build_constructor (type
, v
);
497 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
499 if (complain
& tf_error
)
500 error ("value-initialization of function type %qT", type
);
501 return error_mark_node
;
503 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
505 if (complain
& tf_error
)
506 error ("value-initialization of reference type %qT", type
);
507 return error_mark_node
;
510 return build_zero_init (type
, NULL_TREE
, /*static_storage_p=*/false);
513 /* Initialize current class with INIT, a TREE_LIST of
514 arguments for a target constructor. If TREE_LIST is void_type_node,
515 an empty initializer list was given. */
518 perform_target_ctor (tree init
)
520 tree decl
= current_class_ref
;
521 tree type
= current_class_type
;
523 finish_expr_stmt (build_aggr_init (decl
, init
,
524 LOOKUP_NORMAL
|LOOKUP_DELEGATING_CONS
,
525 tf_warning_or_error
));
526 if (type_build_dtor_call (type
))
528 tree expr
= build_delete (type
, decl
, sfk_complete_destructor
,
532 0, tf_warning_or_error
);
533 if (expr
!= error_mark_node
534 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
535 finish_eh_cleanup (expr
);
539 /* Return the non-static data initializer for FIELD_DECL MEMBER. */
541 static GTY((cache
)) tree_cache_map
*nsdmi_inst
;
544 get_nsdmi (tree member
, bool in_ctor
, tsubst_flags_t complain
)
547 tree save_ccp
= current_class_ptr
;
548 tree save_ccr
= current_class_ref
;
550 if (DECL_LANG_SPECIFIC (member
) && DECL_TEMPLATE_INFO (member
))
552 init
= DECL_INITIAL (DECL_TI_TEMPLATE (member
));
554 = EXPR_LOC_OR_LOC (init
, DECL_SOURCE_LOCATION (member
));
556 if (TREE_CODE (init
) == DEFAULT_ARG
)
558 else if (nsdmi_inst
&& (slot
= nsdmi_inst
->get (member
)))
560 /* Check recursive instantiation. */
561 else if (DECL_INSTANTIATING_NSDMI_P (member
))
563 if (complain
& tf_error
)
564 error_at (expr_loc
, "recursive instantiation of default member "
565 "initializer for %qD", member
);
566 init
= error_mark_node
;
570 int un
= cp_unevaluated_operand
;
571 cp_unevaluated_operand
= 0;
573 location_t sloc
= input_location
;
574 input_location
= expr_loc
;
576 DECL_INSTANTIATING_NSDMI_P (member
) = 1;
578 inject_this_parameter (DECL_CONTEXT (member
), TYPE_UNQUALIFIED
);
580 start_lambda_scope (member
);
582 /* Do deferred instantiation of the NSDMI. */
583 init
= (tsubst_copy_and_build
584 (init
, DECL_TI_ARGS (member
),
585 complain
, member
, /*function_p=*/false,
586 /*integral_constant_expression_p=*/false));
587 init
= digest_nsdmi_init (member
, init
, complain
);
589 finish_lambda_scope ();
591 DECL_INSTANTIATING_NSDMI_P (member
) = 0;
593 if (init
!= error_mark_node
)
596 nsdmi_inst
= tree_cache_map::create_ggc (37);
597 nsdmi_inst
->put (member
, init
);
600 input_location
= sloc
;
601 cp_unevaluated_operand
= un
;
605 init
= DECL_INITIAL (member
);
607 if (init
&& TREE_CODE (init
) == DEFAULT_ARG
)
609 if (complain
& tf_error
)
611 error ("default member initializer for %qD required before the end "
612 "of its enclosing class", member
);
613 inform (location_of (init
), "defined here");
614 DECL_INITIAL (member
) = error_mark_node
;
616 init
= error_mark_node
;
621 current_class_ptr
= save_ccp
;
622 current_class_ref
= save_ccr
;
626 /* Use a PLACEHOLDER_EXPR when we don't have a 'this' parameter to
627 refer to; constexpr evaluation knows what to do with it. */
628 current_class_ref
= build0 (PLACEHOLDER_EXPR
, DECL_CONTEXT (member
));
629 current_class_ptr
= build_address (current_class_ref
);
632 /* Strip redundant TARGET_EXPR so we don't need to remap it, and
633 so the aggregate init code below will see a CONSTRUCTOR. */
634 bool simple_target
= (init
&& SIMPLE_TARGET_EXPR_P (init
));
636 init
= TARGET_EXPR_INITIAL (init
);
637 init
= break_out_target_exprs (init
);
638 if (simple_target
&& TREE_CODE (init
) != CONSTRUCTOR
)
639 /* Now put it back so C++17 copy elision works. */
640 init
= get_target_expr (init
);
642 current_class_ptr
= save_ccp
;
643 current_class_ref
= save_ccr
;
647 /* Diagnose the flexible array MEMBER if its INITializer is non-null
648 and return true if so. Otherwise return false. */
651 maybe_reject_flexarray_init (tree member
, tree init
)
653 tree type
= TREE_TYPE (member
);
656 || TREE_CODE (type
) != ARRAY_TYPE
657 || TYPE_DOMAIN (type
))
660 /* Point at the flexible array member declaration if it's initialized
661 in-class, and at the ctor if it's initialized in a ctor member
664 if (DECL_INITIAL (member
) == init
665 || !current_function_decl
666 || DECL_DEFAULTED_FN (current_function_decl
))
667 loc
= DECL_SOURCE_LOCATION (member
);
669 loc
= DECL_SOURCE_LOCATION (current_function_decl
);
671 error_at (loc
, "initializer for flexible array member %q#D", member
);
675 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
676 arguments. If TREE_LIST is void_type_node, an empty initializer
677 list was given; if NULL_TREE no initializer was given. */
680 perform_member_init (tree member
, tree init
)
683 tree type
= TREE_TYPE (member
);
685 /* Use the non-static data member initializer if there was no
686 mem-initializer for this field. */
687 if (init
== NULL_TREE
)
688 init
= get_nsdmi (member
, /*ctor*/true, tf_warning_or_error
);
690 if (init
== error_mark_node
)
693 /* Effective C++ rule 12 requires that all data members be
695 if (warn_ecpp
&& init
== NULL_TREE
&& TREE_CODE (type
) != ARRAY_TYPE
)
696 warning_at (DECL_SOURCE_LOCATION (current_function_decl
), OPT_Weffc__
,
697 "%qD should be initialized in the member initialization list",
700 /* Get an lvalue for the data member. */
701 decl
= build_class_member_access_expr (current_class_ref
, member
,
702 /*access_path=*/NULL_TREE
,
703 /*preserve_reference=*/true,
704 tf_warning_or_error
);
705 if (decl
== error_mark_node
)
708 if (warn_init_self
&& init
&& TREE_CODE (init
) == TREE_LIST
709 && TREE_CHAIN (init
) == NULL_TREE
)
711 tree val
= TREE_VALUE (init
);
712 /* Handle references. */
713 if (REFERENCE_REF_P (val
))
714 val
= TREE_OPERAND (val
, 0);
715 if (TREE_CODE (val
) == COMPONENT_REF
&& TREE_OPERAND (val
, 1) == member
716 && TREE_OPERAND (val
, 0) == current_class_ref
)
717 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
718 OPT_Winit_self
, "%qD is initialized with itself",
722 if (init
== void_type_node
)
724 /* mem() means value-initialization. */
725 if (TREE_CODE (type
) == ARRAY_TYPE
)
727 init
= build_vec_init_expr (type
, init
, tf_warning_or_error
);
728 init
= build2 (INIT_EXPR
, type
, decl
, init
);
729 finish_expr_stmt (init
);
733 tree value
= build_value_init (type
, tf_warning_or_error
);
734 if (value
== error_mark_node
)
736 init
= build2 (INIT_EXPR
, type
, decl
, value
);
737 finish_expr_stmt (init
);
740 /* Deal with this here, as we will get confused if we try to call the
741 assignment op for an anonymous union. This can happen in a
742 synthesized copy constructor. */
743 else if (ANON_AGGR_TYPE_P (type
))
747 init
= build2 (INIT_EXPR
, type
, decl
, TREE_VALUE (init
));
748 finish_expr_stmt (init
);
752 && (TREE_CODE (type
) == REFERENCE_TYPE
753 /* Pre-digested NSDMI. */
754 || (((TREE_CODE (init
) == CONSTRUCTOR
755 && TREE_TYPE (init
) == type
)
756 /* { } mem-initializer. */
757 || (TREE_CODE (init
) == TREE_LIST
758 && DIRECT_LIST_INIT_P (TREE_VALUE (init
))))
759 && (CP_AGGREGATE_TYPE_P (type
)
760 || is_std_init_list (type
)))))
762 /* With references and list-initialization, we need to deal with
763 extending temporary lifetimes. 12.2p5: "A temporary bound to a
764 reference member in a constructor’s ctor-initializer (12.6.2)
765 persists until the constructor exits." */
767 vec
<tree
, va_gc
> *cleanups
= make_tree_vector ();
768 if (TREE_CODE (init
) == TREE_LIST
)
769 init
= build_x_compound_expr_from_list (init
, ELK_MEM_INIT
,
770 tf_warning_or_error
);
771 if (TREE_TYPE (init
) != type
)
773 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
774 && CP_AGGREGATE_TYPE_P (type
))
775 init
= reshape_init (type
, init
, tf_warning_or_error
);
776 init
= digest_init (type
, init
, tf_warning_or_error
);
778 if (init
== error_mark_node
)
780 /* A FIELD_DECL doesn't really have a suitable lifetime, but
781 make_temporary_var_for_ref_to_temp will treat it as automatic and
782 set_up_extended_ref_temp wants to use the decl in a warning. */
783 init
= extend_ref_init_temps (member
, init
, &cleanups
);
784 if (TREE_CODE (type
) == ARRAY_TYPE
785 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (type
)))
786 init
= build_vec_init_expr (type
, init
, tf_warning_or_error
);
787 init
= build2 (INIT_EXPR
, type
, decl
, init
);
788 finish_expr_stmt (init
);
789 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
790 push_cleanup (decl
, t
, false);
791 release_tree_vector (cleanups
);
793 else if (type_build_ctor_call (type
)
794 || (init
&& CLASS_TYPE_P (strip_array_types (type
))))
796 if (TREE_CODE (type
) == ARRAY_TYPE
)
800 /* Check to make sure the member initializer is valid and
801 something like a CONSTRUCTOR in: T a[] = { 1, 2 } and
802 if it isn't, return early to avoid triggering another
804 if (maybe_reject_flexarray_init (member
, init
))
807 if (TREE_CODE (init
) != TREE_LIST
|| TREE_CHAIN (init
))
808 init
= error_mark_node
;
810 init
= TREE_VALUE (init
);
812 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
813 init
= digest_init (type
, init
, tf_warning_or_error
);
815 if (init
== NULL_TREE
816 || same_type_ignoring_top_level_qualifiers_p (type
,
819 if (TYPE_DOMAIN (type
) && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
821 /* Initialize the array only if it's not a flexible
822 array member (i.e., if it has an upper bound). */
823 init
= build_vec_init_expr (type
, init
, tf_warning_or_error
);
824 init
= build2 (INIT_EXPR
, type
, decl
, init
);
825 finish_expr_stmt (init
);
829 error ("invalid initializer for array member %q#D", member
);
833 int flags
= LOOKUP_NORMAL
;
834 if (DECL_DEFAULTED_FN (current_function_decl
))
835 flags
|= LOOKUP_DEFAULTED
;
836 if (CP_TYPE_CONST_P (type
)
838 && default_init_uninitialized_part (type
))
840 /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
841 vtable; still give this diagnostic. */
842 if (permerror (DECL_SOURCE_LOCATION (current_function_decl
),
843 "uninitialized const member in %q#T", type
))
844 inform (DECL_SOURCE_LOCATION (member
),
845 "%q#D should be initialized", member
);
847 finish_expr_stmt (build_aggr_init (decl
, init
, flags
,
848 tf_warning_or_error
));
853 if (init
== NULL_TREE
)
856 /* member traversal: note it leaves init NULL */
857 if (TREE_CODE (type
) == REFERENCE_TYPE
)
859 if (permerror (DECL_SOURCE_LOCATION (current_function_decl
),
860 "uninitialized reference member in %q#T", type
))
861 inform (DECL_SOURCE_LOCATION (member
),
862 "%q#D should be initialized", member
);
864 else if (CP_TYPE_CONST_P (type
))
866 if (permerror (DECL_SOURCE_LOCATION (current_function_decl
),
867 "uninitialized const member in %q#T", type
))
868 inform (DECL_SOURCE_LOCATION (member
),
869 "%q#D should be initialized", member
);
872 core_type
= strip_array_types (type
);
874 if (CLASS_TYPE_P (core_type
)
875 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
876 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
877 diagnose_uninitialized_cst_or_ref_member (core_type
,
881 else if (TREE_CODE (init
) == TREE_LIST
)
882 /* There was an explicit member initialization. Do some work
884 init
= build_x_compound_expr_from_list (init
, ELK_MEM_INIT
,
885 tf_warning_or_error
);
887 /* Reject a member initializer for a flexible array member. */
888 if (init
&& !maybe_reject_flexarray_init (member
, init
))
889 finish_expr_stmt (cp_build_modify_expr (input_location
, decl
,
891 tf_warning_or_error
));
894 if (type_build_dtor_call (type
))
898 expr
= build_class_member_access_expr (current_class_ref
, member
,
899 /*access_path=*/NULL_TREE
,
900 /*preserve_reference=*/false,
901 tf_warning_or_error
);
902 expr
= build_delete (type
, expr
, sfk_complete_destructor
,
903 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0,
904 tf_warning_or_error
);
906 if (expr
!= error_mark_node
907 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
908 finish_eh_cleanup (expr
);
912 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
913 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
916 build_field_list (tree t
, tree list
, int *uses_unions_or_anon_p
)
920 /* Note whether or not T is a union. */
921 if (TREE_CODE (t
) == UNION_TYPE
)
922 *uses_unions_or_anon_p
= 1;
924 for (fields
= TYPE_FIELDS (t
); fields
; fields
= DECL_CHAIN (fields
))
928 /* Skip CONST_DECLs for enumeration constants and so forth. */
929 if (TREE_CODE (fields
) != FIELD_DECL
|| DECL_ARTIFICIAL (fields
))
932 fieldtype
= TREE_TYPE (fields
);
934 /* For an anonymous struct or union, we must recursively
935 consider the fields of the anonymous type. They can be
936 directly initialized from the constructor. */
937 if (ANON_AGGR_TYPE_P (fieldtype
))
939 /* Add this field itself. Synthesized copy constructors
940 initialize the entire aggregate. */
941 list
= tree_cons (fields
, NULL_TREE
, list
);
942 /* And now add the fields in the anonymous aggregate. */
943 list
= build_field_list (fieldtype
, list
, uses_unions_or_anon_p
);
944 *uses_unions_or_anon_p
= 1;
946 /* Add this field. */
947 else if (DECL_NAME (fields
))
948 list
= tree_cons (fields
, NULL_TREE
, list
);
954 /* Return the innermost aggregate scope for FIELD, whether that is
955 the enclosing class or an anonymous aggregate within it. */
958 innermost_aggr_scope (tree field
)
960 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
961 return TREE_TYPE (field
);
963 return DECL_CONTEXT (field
);
966 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
967 a FIELD_DECL or BINFO in T that needs initialization. The
968 TREE_VALUE gives the initializer, or list of initializer arguments.
970 Return a TREE_LIST containing all of the initializations required
971 for T, in the order in which they should be performed. The output
972 list has the same format as the input. */
975 sort_mem_initializers (tree t
, tree mem_inits
)
978 tree base
, binfo
, base_binfo
;
981 vec
<tree
, va_gc
> *vbases
;
983 int uses_unions_or_anon_p
= 0;
985 /* Build up a list of initializations. The TREE_PURPOSE of entry
986 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
987 TREE_VALUE will be the constructor arguments, or NULL if no
988 explicit initialization was provided. */
989 sorted_inits
= NULL_TREE
;
991 /* Process the virtual bases. */
992 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
993 vec_safe_iterate (vbases
, i
, &base
); i
++)
994 sorted_inits
= tree_cons (base
, NULL_TREE
, sorted_inits
);
996 /* Process the direct bases. */
997 for (binfo
= TYPE_BINFO (t
), i
= 0;
998 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
999 if (!BINFO_VIRTUAL_P (base_binfo
))
1000 sorted_inits
= tree_cons (base_binfo
, NULL_TREE
, sorted_inits
);
1002 /* Process the non-static data members. */
1003 sorted_inits
= build_field_list (t
, sorted_inits
, &uses_unions_or_anon_p
);
1004 /* Reverse the entire list of initializations, so that they are in
1005 the order that they will actually be performed. */
1006 sorted_inits
= nreverse (sorted_inits
);
1008 /* If the user presented the initializers in an order different from
1009 that in which they will actually occur, we issue a warning. Keep
1010 track of the next subobject which can be explicitly initialized
1011 without issuing a warning. */
1012 next_subobject
= sorted_inits
;
1014 /* Go through the explicit initializers, filling in TREE_PURPOSE in
1015 the SORTED_INITS. */
1016 for (init
= mem_inits
; init
; init
= TREE_CHAIN (init
))
1019 tree subobject_init
;
1021 subobject
= TREE_PURPOSE (init
);
1023 /* If the explicit initializers are in sorted order, then
1024 SUBOBJECT will be NEXT_SUBOBJECT, or something following
1026 for (subobject_init
= next_subobject
;
1028 subobject_init
= TREE_CHAIN (subobject_init
))
1029 if (TREE_PURPOSE (subobject_init
) == subobject
)
1032 /* Issue a warning if the explicit initializer order does not
1033 match that which will actually occur.
1034 ??? Are all these on the correct lines? */
1035 if (warn_reorder
&& !subobject_init
)
1037 if (TREE_CODE (TREE_PURPOSE (next_subobject
)) == FIELD_DECL
)
1038 warning_at (DECL_SOURCE_LOCATION (TREE_PURPOSE (next_subobject
)),
1039 OPT_Wreorder
, "%qD will be initialized after",
1040 TREE_PURPOSE (next_subobject
));
1042 warning (OPT_Wreorder
, "base %qT will be initialized after",
1043 TREE_PURPOSE (next_subobject
));
1044 if (TREE_CODE (subobject
) == FIELD_DECL
)
1045 warning_at (DECL_SOURCE_LOCATION (subobject
),
1046 OPT_Wreorder
, " %q#D", subobject
);
1048 warning (OPT_Wreorder
, " base %qT", subobject
);
1049 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
1050 OPT_Wreorder
, " when initialized here");
1053 /* Look again, from the beginning of the list. */
1054 if (!subobject_init
)
1056 subobject_init
= sorted_inits
;
1057 while (TREE_PURPOSE (subobject_init
) != subobject
)
1058 subobject_init
= TREE_CHAIN (subobject_init
);
1061 /* It is invalid to initialize the same subobject more than
1063 if (TREE_VALUE (subobject_init
))
1065 if (TREE_CODE (subobject
) == FIELD_DECL
)
1066 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1067 "multiple initializations given for %qD",
1070 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1071 "multiple initializations given for base %qT",
1075 /* Record the initialization. */
1076 TREE_VALUE (subobject_init
) = TREE_VALUE (init
);
1077 next_subobject
= subobject_init
;
1080 /* [class.base.init]
1082 If a ctor-initializer specifies more than one mem-initializer for
1083 multiple members of the same union (including members of
1084 anonymous unions), the ctor-initializer is ill-formed.
1086 Here we also splice out uninitialized union members. */
1087 if (uses_unions_or_anon_p
)
1089 tree
*last_p
= NULL
;
1091 for (p
= &sorted_inits
; *p
; )
1098 field
= TREE_PURPOSE (init
);
1100 /* Skip base classes. */
1101 if (TREE_CODE (field
) != FIELD_DECL
)
1104 /* If this is an anonymous aggregate with no explicit initializer,
1106 if (!TREE_VALUE (init
) && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
1109 /* See if this field is a member of a union, or a member of a
1110 structure contained in a union, etc. */
1111 ctx
= innermost_aggr_scope (field
);
1113 /* If this field is not a member of a union, skip it. */
1114 if (TREE_CODE (ctx
) != UNION_TYPE
1115 && !ANON_AGGR_TYPE_P (ctx
))
1118 /* If this union member has no explicit initializer and no NSDMI,
1120 if (TREE_VALUE (init
) || DECL_INITIAL (field
))
1125 /* It's only an error if we have two initializers for the same
1133 /* See if LAST_FIELD and the field initialized by INIT are
1134 members of the same union (or the union itself). If so, there's
1135 a problem, unless they're actually members of the same structure
1136 which is itself a member of a union. For example, given:
1138 union { struct { int i; int j; }; };
1140 initializing both `i' and `j' makes sense. */
1141 ctx
= common_enclosing_class
1142 (innermost_aggr_scope (field
),
1143 innermost_aggr_scope (TREE_PURPOSE (*last_p
)));
1145 if (ctx
&& (TREE_CODE (ctx
) == UNION_TYPE
1146 || ctx
== TREE_TYPE (TREE_PURPOSE (*last_p
))))
1148 /* A mem-initializer hides an NSDMI. */
1149 if (TREE_VALUE (init
) && !TREE_VALUE (*last_p
))
1150 *last_p
= TREE_CHAIN (*last_p
);
1151 else if (TREE_VALUE (*last_p
) && !TREE_VALUE (init
))
1155 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1156 "initializations for multiple members of %qT",
1165 p
= &TREE_CHAIN (*p
);
1168 *p
= TREE_CHAIN (*p
);
1173 return sorted_inits
;
1176 /* Callback for cp_walk_tree to mark all PARM_DECLs in a tree as read. */
1179 mark_exp_read_r (tree
*tp
, int *, void *)
1182 if (TREE_CODE (t
) == PARM_DECL
)
1187 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
1188 is a TREE_LIST giving the explicit mem-initializer-list for the
1189 constructor. The TREE_PURPOSE of each entry is a subobject (a
1190 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
1191 is a TREE_LIST giving the arguments to the constructor or
1192 void_type_node for an empty list of arguments. */
1195 emit_mem_initializers (tree mem_inits
)
1197 int flags
= LOOKUP_NORMAL
;
1199 /* We will already have issued an error message about the fact that
1200 the type is incomplete. */
1201 if (!COMPLETE_TYPE_P (current_class_type
))
1205 && TYPE_P (TREE_PURPOSE (mem_inits
))
1206 && same_type_p (TREE_PURPOSE (mem_inits
), current_class_type
))
1208 /* Delegating constructor. */
1209 gcc_assert (TREE_CHAIN (mem_inits
) == NULL_TREE
);
1210 perform_target_ctor (TREE_VALUE (mem_inits
));
1214 if (DECL_DEFAULTED_FN (current_function_decl
)
1215 && ! DECL_INHERITED_CTOR (current_function_decl
))
1216 flags
|= LOOKUP_DEFAULTED
;
1218 /* Sort the mem-initializers into the order in which the
1219 initializations should be performed. */
1220 mem_inits
= sort_mem_initializers (current_class_type
, mem_inits
);
1222 in_base_initializer
= 1;
1224 /* Initialize base classes. */
1226 && TREE_CODE (TREE_PURPOSE (mem_inits
)) != FIELD_DECL
);
1227 mem_inits
= TREE_CHAIN (mem_inits
))
1229 tree subobject
= TREE_PURPOSE (mem_inits
);
1230 tree arguments
= TREE_VALUE (mem_inits
);
1232 /* We already have issued an error message. */
1233 if (arguments
== error_mark_node
)
1236 /* Suppress access control when calling the inherited ctor. */
1237 bool inherited_base
= (DECL_INHERITED_CTOR (current_function_decl
)
1238 && flag_new_inheriting_ctors
1241 push_deferring_access_checks (dk_deferred
);
1243 if (arguments
== NULL_TREE
)
1245 /* If these initializations are taking place in a copy constructor,
1246 the base class should probably be explicitly initialized if there
1247 is a user-defined constructor in the base class (other than the
1248 default constructor, which will be called anyway). */
1250 && DECL_COPY_CONSTRUCTOR_P (current_function_decl
)
1251 && type_has_user_nondefault_constructor (BINFO_TYPE (subobject
)))
1252 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
1253 OPT_Wextra
, "base class %q#T should be explicitly "
1254 "initialized in the copy constructor",
1255 BINFO_TYPE (subobject
));
1258 /* Initialize the base. */
1259 if (!BINFO_VIRTUAL_P (subobject
))
1263 base_addr
= build_base_path (PLUS_EXPR
, current_class_ptr
,
1264 subobject
, 1, tf_warning_or_error
);
1265 expand_aggr_init_1 (subobject
, NULL_TREE
,
1266 cp_build_fold_indirect_ref (base_addr
),
1269 tf_warning_or_error
);
1270 expand_cleanup_for_base (subobject
, NULL_TREE
);
1272 else if (!ABSTRACT_CLASS_TYPE_P (current_class_type
))
1273 /* C++14 DR1658 Means we do not have to construct vbases of
1274 abstract classes. */
1275 construct_virtual_base (subobject
, arguments
);
1277 /* When not constructing vbases of abstract classes, at least mark
1278 the arguments expressions as read to avoid
1279 -Wunused-but-set-parameter false positives. */
1280 cp_walk_tree (&arguments
, mark_exp_read_r
, NULL
, NULL
);
1283 pop_deferring_access_checks ();
1285 in_base_initializer
= 0;
1287 /* Initialize the vptrs. */
1288 initialize_vtbl_ptrs (current_class_ptr
);
1290 /* Initialize the data members. */
1293 perform_member_init (TREE_PURPOSE (mem_inits
),
1294 TREE_VALUE (mem_inits
));
1295 mem_inits
= TREE_CHAIN (mem_inits
);
1299 /* Returns the address of the vtable (i.e., the value that should be
1300 assigned to the vptr) for BINFO. */
1303 build_vtbl_address (tree binfo
)
1305 tree binfo_for
= binfo
;
1308 if (BINFO_VPTR_INDEX (binfo
) && BINFO_VIRTUAL_P (binfo
))
1309 /* If this is a virtual primary base, then the vtable we want to store
1310 is that for the base this is being used as the primary base of. We
1311 can't simply skip the initialization, because we may be expanding the
1312 inits of a subobject constructor where the virtual base layout
1313 can be different. */
1314 while (BINFO_PRIMARY_P (binfo_for
))
1315 binfo_for
= BINFO_INHERITANCE_CHAIN (binfo_for
);
1317 /* Figure out what vtable BINFO's vtable is based on, and mark it as
1319 vtbl
= get_vtbl_decl_for_binfo (binfo_for
);
1320 TREE_USED (vtbl
) = true;
1322 /* Now compute the address to use when initializing the vptr. */
1323 vtbl
= unshare_expr (BINFO_VTABLE (binfo_for
));
1325 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
1330 /* This code sets up the virtual function tables appropriate for
1331 the pointer DECL. It is a one-ply initialization.
1333 BINFO is the exact type that DECL is supposed to be. In
1334 multiple inheritance, this might mean "C's A" if C : A, B. */
1337 expand_virtual_init (tree binfo
, tree decl
)
1339 tree vtbl
, vtbl_ptr
;
1342 /* Compute the initializer for vptr. */
1343 vtbl
= build_vtbl_address (binfo
);
1345 /* We may get this vptr from a VTT, if this is a subobject
1346 constructor or subobject destructor. */
1347 vtt_index
= BINFO_VPTR_INDEX (binfo
);
1353 /* Compute the value to use, when there's a VTT. */
1354 vtt_parm
= current_vtt_parm
;
1355 vtbl2
= fold_build_pointer_plus (vtt_parm
, vtt_index
);
1356 vtbl2
= cp_build_fold_indirect_ref (vtbl2
);
1357 vtbl2
= convert (TREE_TYPE (vtbl
), vtbl2
);
1359 /* The actual initializer is the VTT value only in the subobject
1360 constructor. In maybe_clone_body we'll substitute NULL for
1361 the vtt_parm in the case of the non-subobject constructor. */
1362 vtbl
= build_if_in_charge (vtbl
, vtbl2
);
1365 /* Compute the location of the vtpr. */
1366 vtbl_ptr
= build_vfield_ref (cp_build_fold_indirect_ref (decl
),
1368 gcc_assert (vtbl_ptr
!= error_mark_node
);
1370 /* Assign the vtable to the vptr. */
1371 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0, tf_warning_or_error
);
1372 finish_expr_stmt (cp_build_modify_expr (input_location
, vtbl_ptr
, NOP_EXPR
,
1373 vtbl
, tf_warning_or_error
));
1376 /* If an exception is thrown in a constructor, those base classes already
1377 constructed must be destroyed. This function creates the cleanup
1378 for BINFO, which has just been constructed. If FLAG is non-NULL,
1379 it is a DECL which is nonzero when this base needs to be
1383 expand_cleanup_for_base (tree binfo
, tree flag
)
1387 if (!type_build_dtor_call (BINFO_TYPE (binfo
)))
1390 /* Call the destructor. */
1391 expr
= build_special_member_call (current_class_ref
,
1392 base_dtor_identifier
,
1395 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
1396 tf_warning_or_error
);
1398 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo
)))
1402 expr
= fold_build3_loc (input_location
,
1403 COND_EXPR
, void_type_node
,
1404 c_common_truthvalue_conversion (input_location
, flag
),
1405 expr
, integer_zero_node
);
1407 finish_eh_cleanup (expr
);
1410 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
1414 construct_virtual_base (tree vbase
, tree arguments
)
1420 /* If there are virtual base classes with destructors, we need to
1421 emit cleanups to destroy them if an exception is thrown during
1422 the construction process. These exception regions (i.e., the
1423 period during which the cleanups must occur) begin from the time
1424 the construction is complete to the end of the function. If we
1425 create a conditional block in which to initialize the
1426 base-classes, then the cleanup region for the virtual base begins
1427 inside a block, and ends outside of that block. This situation
1428 confuses the sjlj exception-handling code. Therefore, we do not
1429 create a single conditional block, but one for each
1430 initialization. (That way the cleanup regions always begin
1431 in the outer block.) We trust the back end to figure out
1432 that the FLAG will not change across initializations, and
1433 avoid doing multiple tests. */
1434 flag
= DECL_CHAIN (DECL_ARGUMENTS (current_function_decl
));
1435 inner_if_stmt
= begin_if_stmt ();
1436 finish_if_stmt_cond (flag
, inner_if_stmt
);
1438 /* Compute the location of the virtual base. If we're
1439 constructing virtual bases, then we must be the most derived
1440 class. Therefore, we don't have to look up the virtual base;
1441 we already know where it is. */
1442 exp
= convert_to_base_statically (current_class_ref
, vbase
);
1444 expand_aggr_init_1 (vbase
, current_class_ref
, exp
, arguments
,
1445 0, tf_warning_or_error
);
1446 finish_then_clause (inner_if_stmt
);
1447 finish_if_stmt (inner_if_stmt
);
1449 expand_cleanup_for_base (vbase
, flag
);
1452 /* Find the context in which this FIELD can be initialized. */
1455 initializing_context (tree field
)
1457 tree t
= DECL_CONTEXT (field
);
1459 /* Anonymous union members can be initialized in the first enclosing
1460 non-anonymous union context. */
1461 while (t
&& ANON_AGGR_TYPE_P (t
))
1462 t
= TYPE_CONTEXT (t
);
1466 /* Function to give error message if member initialization specification
1467 is erroneous. FIELD is the member we decided to initialize.
1468 TYPE is the type for which the initialization is being performed.
1469 FIELD must be a member of TYPE.
1471 MEMBER_NAME is the name of the member. */
1474 member_init_ok_or_else (tree field
, tree type
, tree member_name
)
1476 if (field
== error_mark_node
)
1480 error ("class %qT does not have any field named %qD", type
,
1486 error ("%q#D is a static data member; it can only be "
1487 "initialized at its definition",
1491 if (TREE_CODE (field
) != FIELD_DECL
)
1493 error ("%q#D is not a non-static data member of %qT",
1497 if (initializing_context (field
) != type
)
1499 error ("class %qT does not have any field named %qD", type
,
1507 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1508 is a _TYPE node or TYPE_DECL which names a base for that type.
1509 Check the validity of NAME, and return either the base _TYPE, base
1510 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
1511 NULL_TREE and issue a diagnostic.
1513 An old style unnamed direct single base construction is permitted,
1514 where NAME is NULL. */
1517 expand_member_init (tree name
)
1522 if (!current_class_ref
)
1527 /* This is an obsolete unnamed base class initializer. The
1528 parser will already have warned about its use. */
1529 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type
)))
1532 error ("unnamed initializer for %qT, which has no base classes",
1533 current_class_type
);
1536 basetype
= BINFO_TYPE
1537 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type
), 0));
1540 error ("unnamed initializer for %qT, which uses multiple inheritance",
1541 current_class_type
);
1545 else if (TYPE_P (name
))
1547 basetype
= TYPE_MAIN_VARIANT (name
);
1548 name
= TYPE_NAME (name
);
1550 else if (TREE_CODE (name
) == TYPE_DECL
)
1551 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (name
));
1553 basetype
= NULL_TREE
;
1562 if (current_template_parms
1563 || same_type_p (basetype
, current_class_type
))
1566 class_binfo
= TYPE_BINFO (current_class_type
);
1567 direct_binfo
= NULL_TREE
;
1568 virtual_binfo
= NULL_TREE
;
1570 /* Look for a direct base. */
1571 for (i
= 0; BINFO_BASE_ITERATE (class_binfo
, i
, direct_binfo
); ++i
)
1572 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo
), basetype
))
1575 /* Look for a virtual base -- unless the direct base is itself
1577 if (!direct_binfo
|| !BINFO_VIRTUAL_P (direct_binfo
))
1578 virtual_binfo
= binfo_for_vbase (basetype
, current_class_type
);
1580 /* [class.base.init]
1582 If a mem-initializer-id is ambiguous because it designates
1583 both a direct non-virtual base class and an inherited virtual
1584 base class, the mem-initializer is ill-formed. */
1585 if (direct_binfo
&& virtual_binfo
)
1587 error ("%qD is both a direct base and an indirect virtual base",
1592 if (!direct_binfo
&& !virtual_binfo
)
1594 if (CLASSTYPE_VBASECLASSES (current_class_type
))
1595 error ("type %qT is not a direct or virtual base of %qT",
1596 basetype
, current_class_type
);
1598 error ("type %qT is not a direct base of %qT",
1599 basetype
, current_class_type
);
1603 return direct_binfo
? direct_binfo
: virtual_binfo
;
1607 if (identifier_p (name
))
1608 field
= lookup_field (current_class_type
, name
, 1, false);
1612 if (member_init_ok_or_else (field
, current_class_type
, name
))
1619 /* This is like `expand_member_init', only it stores one aggregate
1622 INIT comes in two flavors: it is either a value which
1623 is to be stored in EXP, or it is a parameter list
1624 to go to a constructor, which will operate on EXP.
1625 If INIT is not a parameter list for a constructor, then set
1626 LOOKUP_ONLYCONVERTING.
1627 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1628 the initializer, if FLAGS is 0, then it is the (init) form.
1629 If `init' is a CONSTRUCTOR, then we emit a warning message,
1630 explaining that such initializations are invalid.
1632 If INIT resolves to a CALL_EXPR which happens to return
1633 something of the type we are looking for, then we know
1634 that we can safely use that call to perform the
1637 The virtual function table pointer cannot be set up here, because
1638 we do not really know its type.
1640 This never calls operator=().
1642 When initializing, nothing is CONST.
1644 A default copy constructor may have to be used to perform the
1647 A constructor or a conversion operator may have to be used to
1648 perform the initialization, but not both, as it would be ambiguous. */
1651 build_aggr_init (tree exp
, tree init
, int flags
, tsubst_flags_t complain
)
1656 tree type
= TREE_TYPE (exp
);
1657 int was_const
= TREE_READONLY (exp
);
1658 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1661 if (init
== error_mark_node
)
1662 return error_mark_node
;
1664 location_t init_loc
= (init
1665 ? EXPR_LOC_OR_LOC (init
, input_location
)
1666 : location_of (exp
));
1668 TREE_READONLY (exp
) = 0;
1669 TREE_THIS_VOLATILE (exp
) = 0;
1671 if (TREE_CODE (type
) == ARRAY_TYPE
)
1673 tree itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1676 if (VAR_P (exp
) && DECL_DECOMPOSITION_P (exp
))
1679 if (init
&& DECL_P (init
)
1680 && !(flags
& LOOKUP_ONLYCONVERTING
))
1682 /* Wrap the initializer in a CONSTRUCTOR so that build_vec_init
1683 recognizes it as direct-initialization. */
1684 init
= build_constructor_single (init_list_type_node
,
1686 CONSTRUCTOR_IS_DIRECT_INIT (init
) = true;
1691 /* An array may not be initialized use the parenthesized
1692 initialization form -- unless the initializer is "()". */
1693 if (init
&& TREE_CODE (init
) == TREE_LIST
)
1695 if (complain
& tf_error
)
1696 error ("bad array initializer");
1697 return error_mark_node
;
1699 /* Must arrange to initialize each element of EXP
1700 from elements of INIT. */
1701 if (cv_qualified_p (type
))
1702 TREE_TYPE (exp
) = cv_unqualified (type
);
1703 if (itype
&& cv_qualified_p (itype
))
1704 TREE_TYPE (init
) = cv_unqualified (itype
);
1705 from_array
= (itype
&& same_type_p (TREE_TYPE (init
),
1708 if (init
&& !from_array
1709 && !BRACE_ENCLOSED_INITIALIZER_P (init
))
1711 if (complain
& tf_error
)
1712 permerror (init_loc
, "array must be initialized "
1713 "with a brace-enclosed initializer");
1715 return error_mark_node
;
1719 stmt_expr
= build_vec_init (exp
, NULL_TREE
, init
,
1720 /*explicit_value_init_p=*/false,
1723 TREE_READONLY (exp
) = was_const
;
1724 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1725 TREE_TYPE (exp
) = type
;
1726 /* Restore the type of init unless it was used directly. */
1727 if (init
&& TREE_CODE (stmt_expr
) != INIT_EXPR
)
1728 TREE_TYPE (init
) = itype
;
1732 if (init
&& init
!= void_type_node
1733 && TREE_CODE (init
) != TREE_LIST
1734 && !(TREE_CODE (init
) == TARGET_EXPR
1735 && TARGET_EXPR_DIRECT_INIT_P (init
))
1736 && !DIRECT_LIST_INIT_P (init
))
1737 flags
|= LOOKUP_ONLYCONVERTING
;
1739 if ((VAR_P (exp
) || TREE_CODE (exp
) == PARM_DECL
)
1740 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (type
)))
1741 /* Just know that we've seen something for this node. */
1742 TREE_USED (exp
) = 1;
1744 is_global
= begin_init_stmts (&stmt_expr
, &compound_stmt
);
1745 destroy_temps
= stmts_are_full_exprs_p ();
1746 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
1747 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1748 init
, LOOKUP_NORMAL
|flags
, complain
);
1749 stmt_expr
= finish_init_stmts (is_global
, stmt_expr
, compound_stmt
);
1750 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
1751 TREE_READONLY (exp
) = was_const
;
1752 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1758 expand_default_init (tree binfo
, tree true_exp
, tree exp
, tree init
, int flags
,
1759 tsubst_flags_t complain
)
1761 tree type
= TREE_TYPE (exp
);
1763 /* It fails because there may not be a constructor which takes
1764 its own type as the first (or only parameter), but which does
1765 take other types via a conversion. So, if the thing initializing
1766 the expression is a unit element of type X, first try X(X&),
1767 followed by initialization by X. If neither of these work
1768 out, then look hard. */
1770 vec
<tree
, va_gc
> *parms
;
1772 /* If we have direct-initialization from an initializer list, pull
1773 it out of the TREE_LIST so the code below can see it. */
1774 if (init
&& TREE_CODE (init
) == TREE_LIST
1775 && DIRECT_LIST_INIT_P (TREE_VALUE (init
)))
1777 gcc_checking_assert ((flags
& LOOKUP_ONLYCONVERTING
) == 0
1778 && TREE_CHAIN (init
) == NULL_TREE
);
1779 init
= TREE_VALUE (init
);
1780 /* Only call reshape_init if it has not been called earlier
1782 if (BRACE_ENCLOSED_INITIALIZER_P (init
) && CP_AGGREGATE_TYPE_P (type
))
1783 init
= reshape_init (type
, init
, complain
);
1786 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
1787 && CP_AGGREGATE_TYPE_P (type
))
1788 /* A brace-enclosed initializer for an aggregate. In C++0x this can
1789 happen for direct-initialization, too. */
1790 init
= digest_init (type
, init
, complain
);
1792 /* A CONSTRUCTOR of the target's type is a previously digested
1793 initializer, whether that happened just above or in
1794 cp_parser_late_parsing_nsdmi.
1796 A TARGET_EXPR with TARGET_EXPR_DIRECT_INIT_P or TARGET_EXPR_LIST_INIT_P
1797 set represents the whole initialization, so we shouldn't build up
1798 another ctor call. */
1800 && (TREE_CODE (init
) == CONSTRUCTOR
1801 || (TREE_CODE (init
) == TARGET_EXPR
1802 && (TARGET_EXPR_DIRECT_INIT_P (init
)
1803 || TARGET_EXPR_LIST_INIT_P (init
))))
1804 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (init
), type
))
1806 /* Early initialization via a TARGET_EXPR only works for
1807 complete objects. */
1808 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
|| true_exp
== exp
);
1810 init
= build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1811 TREE_SIDE_EFFECTS (init
) = 1;
1812 finish_expr_stmt (init
);
1816 if (init
&& TREE_CODE (init
) != TREE_LIST
1817 && (flags
& LOOKUP_ONLYCONVERTING
))
1819 /* Base subobjects should only get direct-initialization. */
1820 gcc_assert (true_exp
== exp
);
1822 if (flags
& DIRECT_BIND
)
1823 /* Do nothing. We hit this in two cases: Reference initialization,
1824 where we aren't initializing a real variable, so we don't want
1825 to run a new constructor; and catching an exception, where we
1826 have already built up the constructor call so we could wrap it
1827 in an exception region. */;
1829 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
,
1832 if (TREE_CODE (init
) == MUST_NOT_THROW_EXPR
)
1833 /* We need to protect the initialization of a catch parm with a
1834 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1835 around the TARGET_EXPR for the copy constructor. See
1836 initialize_handler_parm. */
1838 TREE_OPERAND (init
, 0) = build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
,
1839 TREE_OPERAND (init
, 0));
1840 TREE_TYPE (init
) = void_type_node
;
1843 init
= build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1844 TREE_SIDE_EFFECTS (init
) = 1;
1845 finish_expr_stmt (init
);
1849 if (init
== NULL_TREE
)
1851 else if (TREE_CODE (init
) == TREE_LIST
&& !TREE_TYPE (init
))
1853 parms
= make_tree_vector ();
1854 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
1855 vec_safe_push (parms
, TREE_VALUE (init
));
1858 parms
= make_tree_vector_single (init
);
1860 if (exp
== current_class_ref
&& current_function_decl
1861 && DECL_HAS_IN_CHARGE_PARM_P (current_function_decl
))
1863 /* Delegating constructor. */
1866 tree elt
; unsigned i
;
1868 /* Unshare the arguments for the second call. */
1869 vec
<tree
, va_gc
> *parms2
= make_tree_vector ();
1870 FOR_EACH_VEC_SAFE_ELT (parms
, i
, elt
)
1872 elt
= break_out_target_exprs (elt
);
1873 vec_safe_push (parms2
, elt
);
1875 complete
= build_special_member_call (exp
, complete_ctor_identifier
,
1876 &parms2
, binfo
, flags
,
1878 complete
= fold_build_cleanup_point_expr (void_type_node
, complete
);
1879 release_tree_vector (parms2
);
1881 base
= build_special_member_call (exp
, base_ctor_identifier
,
1882 &parms
, binfo
, flags
,
1884 base
= fold_build_cleanup_point_expr (void_type_node
, base
);
1885 rval
= build_if_in_charge (complete
, base
);
1889 tree ctor_name
= (true_exp
== exp
1890 ? complete_ctor_identifier
: base_ctor_identifier
);
1892 rval
= build_special_member_call (exp
, ctor_name
, &parms
, binfo
, flags
,
1897 release_tree_vector (parms
);
1899 if (exp
== true_exp
&& TREE_CODE (rval
) == CALL_EXPR
)
1901 tree fn
= get_callee_fndecl (rval
);
1902 if (fn
&& DECL_DECLARED_CONSTEXPR_P (fn
))
1904 tree e
= maybe_constant_init (rval
, exp
);
1905 if (TREE_CONSTANT (e
))
1906 rval
= build2 (INIT_EXPR
, type
, exp
, e
);
1910 /* FIXME put back convert_to_void? */
1911 if (TREE_SIDE_EFFECTS (rval
))
1912 finish_expr_stmt (rval
);
1915 /* This function is responsible for initializing EXP with INIT
1918 BINFO is the binfo of the type for who we are performing the
1919 initialization. For example, if W is a virtual base class of A and B,
1921 If we are initializing B, then W must contain B's W vtable, whereas
1922 were we initializing C, W must contain C's W vtable.
1924 TRUE_EXP is nonzero if it is the true expression being initialized.
1925 In this case, it may be EXP, or may just contain EXP. The reason we
1926 need this is because if EXP is a base element of TRUE_EXP, we
1927 don't necessarily know by looking at EXP where its virtual
1928 baseclass fields should really be pointing. But we do know
1929 from TRUE_EXP. In constructors, we don't know anything about
1930 the value being initialized.
1932 FLAGS is just passed to `build_new_method_call'. See that function
1933 for its description. */
1936 expand_aggr_init_1 (tree binfo
, tree true_exp
, tree exp
, tree init
, int flags
,
1937 tsubst_flags_t complain
)
1939 tree type
= TREE_TYPE (exp
);
1941 gcc_assert (init
!= error_mark_node
&& type
!= error_mark_node
);
1942 gcc_assert (building_stmt_list_p ());
1944 /* Use a function returning the desired type to initialize EXP for us.
1945 If the function is a constructor, and its first argument is
1946 NULL_TREE, know that it was meant for us--just slide exp on
1947 in and expand the constructor. Constructors now come
1950 if (init
&& VAR_P (exp
)
1951 && COMPOUND_LITERAL_P (init
))
1953 vec
<tree
, va_gc
> *cleanups
= NULL
;
1954 /* If store_init_value returns NULL_TREE, the INIT has been
1955 recorded as the DECL_INITIAL for EXP. That means there's
1956 nothing more we have to do. */
1957 init
= store_init_value (exp
, init
, &cleanups
, flags
);
1959 finish_expr_stmt (init
);
1960 gcc_assert (!cleanups
);
1964 /* List-initialization from {} becomes value-initialization for non-aggregate
1965 classes with default constructors. Handle this here when we're
1966 initializing a base, so protected access works. */
1967 if (exp
!= true_exp
&& init
&& TREE_CODE (init
) == TREE_LIST
)
1969 tree elt
= TREE_VALUE (init
);
1970 if (DIRECT_LIST_INIT_P (elt
)
1971 && CONSTRUCTOR_ELTS (elt
) == 0
1972 && CLASSTYPE_NON_AGGREGATE (type
)
1973 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1974 init
= void_type_node
;
1977 /* If an explicit -- but empty -- initializer list was present,
1978 that's value-initialization. */
1979 if (init
== void_type_node
)
1981 /* If the type has data but no user-provided ctor, we need to zero
1983 if (!type_has_user_provided_constructor (type
)
1984 && !is_really_empty_class (type
))
1986 tree field_size
= NULL_TREE
;
1987 if (exp
!= true_exp
&& CLASSTYPE_AS_BASE (type
) != type
)
1988 /* Don't clobber already initialized virtual bases. */
1989 field_size
= TYPE_SIZE (CLASSTYPE_AS_BASE (type
));
1990 init
= build_zero_init_1 (type
, NULL_TREE
, /*static_storage_p=*/false,
1992 init
= build2 (INIT_EXPR
, type
, exp
, init
);
1993 finish_expr_stmt (init
);
1996 /* If we don't need to mess with the constructor at all,
1998 if (! type_build_ctor_call (type
))
2001 /* Otherwise fall through and call the constructor. */
2005 /* We know that expand_default_init can handle everything we want
2007 expand_default_init (binfo
, true_exp
, exp
, init
, flags
, complain
);
2010 /* Report an error if TYPE is not a user-defined, class type. If
2011 OR_ELSE is nonzero, give an error message. */
2014 is_class_type (tree type
, int or_else
)
2016 if (type
== error_mark_node
)
2019 if (! CLASS_TYPE_P (type
))
2022 error ("%qT is not a class type", type
);
2029 get_type_value (tree name
)
2031 if (name
== error_mark_node
)
2034 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
2035 return IDENTIFIER_TYPE_VALUE (name
);
2040 /* Build a reference to a member of an aggregate. This is not a C++
2041 `&', but really something which can have its address taken, and
2042 then act as a pointer to member, for example TYPE :: FIELD can have
2043 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
2044 this expression is the operand of "&".
2046 @@ Prints out lousy diagnostics for operator <typename>
2049 @@ This function should be rewritten and placed in search.c. */
2052 build_offset_ref (tree type
, tree member
, bool address_p
,
2053 tsubst_flags_t complain
)
2056 tree basebinfo
= NULL_TREE
;
2058 /* class templates can come in as TEMPLATE_DECLs here. */
2059 if (TREE_CODE (member
) == TEMPLATE_DECL
)
2062 if (dependent_scope_p (type
) || type_dependent_expression_p (member
))
2063 return build_qualified_name (NULL_TREE
, type
, member
,
2064 /*template_p=*/false);
2066 gcc_assert (TYPE_P (type
));
2067 if (! is_class_type (type
, 1))
2068 return error_mark_node
;
2070 gcc_assert (DECL_P (member
) || BASELINK_P (member
));
2071 /* Callers should call mark_used before this point. */
2072 gcc_assert (!DECL_P (member
) || TREE_USED (member
));
2074 type
= TYPE_MAIN_VARIANT (type
);
2075 if (!COMPLETE_OR_OPEN_TYPE_P (complete_type (type
)))
2077 if (complain
& tf_error
)
2078 error ("incomplete type %qT does not have member %qD", type
, member
);
2079 return error_mark_node
;
2082 /* Entities other than non-static members need no further
2084 if (TREE_CODE (member
) == TYPE_DECL
)
2086 if (VAR_P (member
) || TREE_CODE (member
) == CONST_DECL
)
2087 return convert_from_reference (member
);
2089 if (TREE_CODE (member
) == FIELD_DECL
&& DECL_C_BIT_FIELD (member
))
2091 if (complain
& tf_error
)
2092 error ("invalid pointer to bit-field %qD", member
);
2093 return error_mark_node
;
2096 /* Set up BASEBINFO for member lookup. */
2097 decl
= maybe_dummy_object (type
, &basebinfo
);
2099 /* A lot of this logic is now handled in lookup_member. */
2100 if (BASELINK_P (member
))
2102 /* Go from the TREE_BASELINK to the member function info. */
2103 tree t
= BASELINK_FUNCTIONS (member
);
2105 if (TREE_CODE (t
) != TEMPLATE_ID_EXPR
&& !really_overloaded_fn (t
))
2107 /* Get rid of a potential OVERLOAD around it. */
2110 /* Unique functions are handled easily. */
2112 /* For non-static member of base class, we need a special rule
2113 for access checking [class.protected]:
2115 If the access is to form a pointer to member, the
2116 nested-name-specifier shall name the derived class
2117 (or any class derived from that class). */
2119 if (address_p
&& DECL_P (t
)
2120 && DECL_NONSTATIC_MEMBER_P (t
))
2121 ok
= perform_or_defer_access_check (TYPE_BINFO (type
), t
, t
,
2124 ok
= perform_or_defer_access_check (basebinfo
, t
, t
,
2127 return error_mark_node
;
2128 if (DECL_STATIC_FUNCTION_P (t
))
2133 TREE_TYPE (member
) = unknown_type_node
;
2135 else if (address_p
&& TREE_CODE (member
) == FIELD_DECL
)
2137 /* We need additional test besides the one in
2138 check_accessibility_of_qualified_id in case it is
2139 a pointer to non-static member. */
2140 if (!perform_or_defer_access_check (TYPE_BINFO (type
), member
, member
,
2142 return error_mark_node
;
2147 /* If MEMBER is non-static, then the program has fallen afoul of
2150 An id-expression that denotes a nonstatic data member or
2151 nonstatic member function of a class can only be used:
2153 -- as part of a class member access (_expr.ref_) in which the
2154 object-expression refers to the member's class or a class
2155 derived from that class, or
2157 -- to form a pointer to member (_expr.unary.op_), or
2159 -- in the body of a nonstatic member function of that class or
2160 of a class derived from that class (_class.mfct.nonstatic_), or
2162 -- in a mem-initializer for a constructor for that class or for
2163 a class derived from that class (_class.base.init_). */
2164 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member
))
2166 /* Build a representation of the qualified name suitable
2167 for use as the operand to "&" -- even though the "&" is
2168 not actually present. */
2169 member
= build2 (OFFSET_REF
, TREE_TYPE (member
), decl
, member
);
2170 /* In Microsoft mode, treat a non-static member function as if
2171 it were a pointer-to-member. */
2172 if (flag_ms_extensions
)
2174 PTRMEM_OK_P (member
) = 1;
2175 return cp_build_addr_expr (member
, complain
);
2177 if (complain
& tf_error
)
2178 error ("invalid use of non-static member function %qD",
2179 TREE_OPERAND (member
, 1));
2180 return error_mark_node
;
2182 else if (TREE_CODE (member
) == FIELD_DECL
)
2184 if (complain
& tf_error
)
2185 error ("invalid use of non-static data member %qD", member
);
2186 return error_mark_node
;
2191 member
= build2 (OFFSET_REF
, TREE_TYPE (member
), decl
, member
);
2192 PTRMEM_OK_P (member
) = 1;
2196 /* If DECL is a scalar enumeration constant or variable with a
2197 constant initializer, return the initializer (or, its initializers,
2198 recursively); otherwise, return DECL. If STRICT_P, the
2199 initializer is only returned if DECL is a
2200 constant-expression. If RETURN_AGGREGATE_CST_OK_P, it is ok to
2201 return an aggregate constant. */
2204 constant_value_1 (tree decl
, bool strict_p
, bool return_aggregate_cst_ok_p
)
2206 while (TREE_CODE (decl
) == CONST_DECL
2207 || decl_constant_var_p (decl
)
2208 || (!strict_p
&& VAR_P (decl
)
2209 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl
))))
2212 /* If DECL is a static data member in a template
2213 specialization, we must instantiate it here. The
2214 initializer for the static data member is not processed
2215 until needed; we need it now. */
2216 mark_used (decl
, tf_none
);
2217 init
= DECL_INITIAL (decl
);
2218 if (init
== error_mark_node
)
2220 if (TREE_CODE (decl
) == CONST_DECL
2221 || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
))
2222 /* Treat the error as a constant to avoid cascading errors on
2223 excessively recursive template instantiation (c++/9335). */
2228 /* Initializers in templates are generally expanded during
2229 instantiation, so before that for const int i(2)
2230 INIT is a TREE_LIST with the actual initializer as
2232 if (processing_template_decl
2234 && TREE_CODE (init
) == TREE_LIST
2235 && TREE_CHAIN (init
) == NULL_TREE
)
2236 init
= TREE_VALUE (init
);
2237 /* Instantiate a non-dependent initializer for user variables. We
2238 mustn't do this for the temporary for an array compound literal;
2239 trying to instatiate the initializer will keep creating new
2240 temporaries until we crash. Probably it's not useful to do it for
2241 other artificial variables, either. */
2242 if (!DECL_ARTIFICIAL (decl
))
2243 init
= instantiate_non_dependent_or_null (init
);
2245 || !TREE_TYPE (init
)
2246 || !TREE_CONSTANT (init
)
2247 || (!return_aggregate_cst_ok_p
2248 /* Unless RETURN_AGGREGATE_CST_OK_P is true, do not
2249 return an aggregate constant (of which string
2250 literals are a special case), as we do not want
2251 to make inadvertent copies of such entities, and
2252 we must be sure that their addresses are the
2254 && (TREE_CODE (init
) == CONSTRUCTOR
2255 || TREE_CODE (init
) == STRING_CST
)))
2257 /* Don't return a CONSTRUCTOR for a variable with partial run-time
2258 initialization, since it doesn't represent the entire value. */
2259 if (TREE_CODE (init
) == CONSTRUCTOR
2260 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
))
2262 /* If the variable has a dynamic initializer, don't use its
2263 DECL_INITIAL which doesn't reflect the real value. */
2265 && TREE_STATIC (decl
)
2266 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
)
2267 && DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
2269 decl
= unshare_expr (init
);
2274 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by constant
2275 of integral or enumeration type, or a constexpr variable of scalar type,
2276 then return that value. These are those variables permitted in constant
2277 expressions by [5.19/1]. */
2280 scalar_constant_value (tree decl
)
2282 return constant_value_1 (decl
, /*strict_p=*/true,
2283 /*return_aggregate_cst_ok_p=*/false);
2286 /* Like scalar_constant_value, but can also return aggregate initializers. */
2289 decl_really_constant_value (tree decl
)
2291 return constant_value_1 (decl
, /*strict_p=*/true,
2292 /*return_aggregate_cst_ok_p=*/true);
2295 /* A more relaxed version of scalar_constant_value, used by the
2296 common C/C++ code. */
2299 decl_constant_value (tree decl
)
2301 return constant_value_1 (decl
, /*strict_p=*/processing_template_decl
,
2302 /*return_aggregate_cst_ok_p=*/true);
2305 /* Common subroutines of build_new and build_vec_delete. */
2307 /* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
2308 the type of the object being allocated; otherwise, it's just TYPE.
2309 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
2310 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
2311 a vector of arguments to be provided as arguments to a placement
2312 new operator. This routine performs no semantic checks; it just
2313 creates and returns a NEW_EXPR. */
2316 build_raw_new_expr (vec
<tree
, va_gc
> *placement
, tree type
, tree nelts
,
2317 vec
<tree
, va_gc
> *init
, int use_global_new
)
2322 /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR.
2323 If INIT is not NULL, then we want to store VOID_ZERO_NODE. This
2324 permits us to distinguish the case of a missing initializer "new
2325 int" from an empty initializer "new int()". */
2327 init_list
= NULL_TREE
;
2328 else if (init
->is_empty ())
2329 init_list
= void_node
;
2332 init_list
= build_tree_list_vec (init
);
2333 for (tree v
= init_list
; v
; v
= TREE_CHAIN (v
))
2334 if (TREE_CODE (TREE_VALUE (v
)) == OVERLOAD
)
2335 lookup_keep (TREE_VALUE (v
), true);
2338 new_expr
= build4 (NEW_EXPR
, build_pointer_type (type
),
2339 build_tree_list_vec (placement
), type
, nelts
,
2341 NEW_EXPR_USE_GLOBAL (new_expr
) = use_global_new
;
2342 TREE_SIDE_EFFECTS (new_expr
) = 1;
2347 /* Diagnose uninitialized const members or reference members of type
2348 TYPE. USING_NEW is used to disambiguate the diagnostic between a
2349 new expression without a new-initializer and a declaration. Returns
2353 diagnose_uninitialized_cst_or_ref_member_1 (tree type
, tree origin
,
2354 bool using_new
, bool complain
)
2357 int error_count
= 0;
2359 if (type_has_user_provided_constructor (type
))
2362 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2366 if (TREE_CODE (field
) != FIELD_DECL
)
2369 field_type
= strip_array_types (TREE_TYPE (field
));
2371 if (type_has_user_provided_constructor (field_type
))
2374 if (TREE_CODE (field_type
) == REFERENCE_TYPE
)
2379 if (DECL_CONTEXT (field
) == origin
)
2382 error ("uninitialized reference member in %q#T "
2383 "using %<new%> without new-initializer", origin
);
2385 error ("uninitialized reference member in %q#T", origin
);
2390 error ("uninitialized reference member in base %q#T "
2391 "of %q#T using %<new%> without new-initializer",
2392 DECL_CONTEXT (field
), origin
);
2394 error ("uninitialized reference member in base %q#T "
2395 "of %q#T", DECL_CONTEXT (field
), origin
);
2397 inform (DECL_SOURCE_LOCATION (field
),
2398 "%q#D should be initialized", field
);
2402 if (CP_TYPE_CONST_P (field_type
))
2407 if (DECL_CONTEXT (field
) == origin
)
2410 error ("uninitialized const member in %q#T "
2411 "using %<new%> without new-initializer", origin
);
2413 error ("uninitialized const member in %q#T", origin
);
2418 error ("uninitialized const member in base %q#T "
2419 "of %q#T using %<new%> without new-initializer",
2420 DECL_CONTEXT (field
), origin
);
2422 error ("uninitialized const member in base %q#T "
2423 "of %q#T", DECL_CONTEXT (field
), origin
);
2425 inform (DECL_SOURCE_LOCATION (field
),
2426 "%q#D should be initialized", field
);
2430 if (CLASS_TYPE_P (field_type
))
2432 += diagnose_uninitialized_cst_or_ref_member_1 (field_type
, origin
,
2433 using_new
, complain
);
2439 diagnose_uninitialized_cst_or_ref_member (tree type
, bool using_new
, bool complain
)
2441 return diagnose_uninitialized_cst_or_ref_member_1 (type
, type
, using_new
, complain
);
2444 /* Call __cxa_bad_array_new_length to indicate that the size calculation
2445 overflowed. Pretend it returns sizetype so that it plays nicely in the
2449 throw_bad_array_new_length (void)
2453 tree name
= get_identifier ("__cxa_throw_bad_array_new_length");
2455 fn
= get_global_binding (name
);
2457 fn
= push_throw_library_fn
2458 (name
, build_function_type_list (sizetype
, NULL_TREE
));
2461 return build_cxx_call (fn
, 0, NULL
, tf_warning_or_error
);
2464 /* Attempt to find the initializer for flexible array field T in the
2465 initializer INIT, when non-null. Returns the initializer when
2466 successful and NULL otherwise. */
2468 find_flexarray_init (tree t
, tree init
)
2470 if (!init
|| init
== error_mark_node
)
2473 unsigned HOST_WIDE_INT idx
;
2476 /* Iterate over all top-level initializer elements. */
2477 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
, field
, elt
)
2478 /* If the member T is found, return it. */
2485 /* Attempt to verify that the argument, OPER, of a placement new expression
2486 refers to an object sufficiently large for an object of TYPE or an array
2487 of NELTS of such objects when NELTS is non-null, and issue a warning when
2488 it does not. SIZE specifies the size needed to construct the object or
2489 array and captures the result of NELTS * sizeof (TYPE). (SIZE could be
2490 greater when the array under construction requires a cookie to store
2491 NELTS. GCC's placement new expression stores the cookie when invoking
2492 a user-defined placement new operator function but not the default one.
2493 Placement new expressions with user-defined placement new operator are
2494 not diagnosed since we don't know how they use the buffer (this could
2495 be a future extension). */
2497 warn_placement_new_too_small (tree type
, tree nelts
, tree size
, tree oper
)
2499 location_t loc
= EXPR_LOC_OR_LOC (oper
, input_location
);
2501 /* The number of bytes to add to or subtract from the size of the provided
2502 buffer based on an offset into an array or an array element reference.
2503 Although intermediate results may be negative (as in a[3] - 2) a valid
2504 final result cannot be. */
2505 offset_int adjust
= 0;
2506 /* True when the size of the entire destination object should be used
2507 to compute the possibly optimistic estimate of the available space. */
2508 bool use_obj_size
= false;
2509 /* True when the reference to the destination buffer is an ADDR_EXPR. */
2510 bool addr_expr
= false;
2514 /* Using a function argument or a (non-array) variable as an argument
2515 to placement new is not checked since it's unknown what it might
2517 if (TREE_CODE (oper
) == PARM_DECL
2519 || TREE_CODE (oper
) == COMPONENT_REF
)
2522 /* Evaluate any constant expressions. */
2523 size
= fold_non_dependent_expr (size
);
2525 /* Handle the common case of array + offset expression when the offset
2527 if (TREE_CODE (oper
) == POINTER_PLUS_EXPR
)
2529 /* If the offset is compile-time constant, use it to compute a more
2530 accurate estimate of the size of the buffer. Since the operand
2531 of POINTER_PLUS_EXPR is represented as an unsigned type, convert
2533 Otherwise, use the size of the entire array as an optimistic
2534 estimate (this may lead to false negatives). */
2535 tree adj
= TREE_OPERAND (oper
, 1);
2536 if (CONSTANT_CLASS_P (adj
))
2537 adjust
+= wi::to_offset (convert (ssizetype
, adj
));
2539 use_obj_size
= true;
2541 oper
= TREE_OPERAND (oper
, 0);
2546 if (TREE_CODE (oper
) == TARGET_EXPR
)
2547 oper
= TREE_OPERAND (oper
, 1);
2548 else if (TREE_CODE (oper
) == ADDR_EXPR
)
2551 oper
= TREE_OPERAND (oper
, 0);
2556 if (TREE_CODE (oper
) == ARRAY_REF
2557 && (addr_expr
|| TREE_CODE (TREE_TYPE (oper
)) == ARRAY_TYPE
))
2559 /* Similar to the offset computed above, see if the array index
2560 is a compile-time constant. If so, and unless the offset was
2561 not a compile-time constant, use the index to determine the
2562 size of the buffer. Otherwise, use the entire array as
2563 an optimistic estimate of the size. */
2564 const_tree adj
= fold_non_dependent_expr (TREE_OPERAND (oper
, 1));
2565 if (!use_obj_size
&& CONSTANT_CLASS_P (adj
))
2566 adjust
+= wi::to_offset (adj
);
2569 use_obj_size
= true;
2573 oper
= TREE_OPERAND (oper
, 0);
2576 /* Refers to the declared object that constains the subobject referenced
2577 by OPER. When the object is initialized, makes it possible to determine
2578 the actual size of a flexible array member used as the buffer passed
2579 as OPER to placement new. */
2580 tree var_decl
= NULL_TREE
;
2581 /* True when operand is a COMPONENT_REF, to distinguish flexible array
2582 members from arrays of unspecified size. */
2583 bool compref
= TREE_CODE (oper
) == COMPONENT_REF
;
2585 /* For COMPONENT_REF (i.e., a struct member) the size of the entire
2586 enclosing struct. Used to validate the adjustment (offset) into
2587 an array at the end of a struct. */
2588 offset_int compsize
= 0;
2590 /* Descend into a struct or union to find the member whose address
2591 is being used as the argument. */
2592 if (TREE_CODE (oper
) == COMPONENT_REF
)
2594 tree comptype
= TREE_TYPE (TREE_OPERAND (oper
, 0));
2595 compsize
= wi::to_offset (TYPE_SIZE_UNIT (comptype
));
2598 while (TREE_CODE (op0
= TREE_OPERAND (op0
, 0)) == COMPONENT_REF
);
2601 oper
= TREE_OPERAND (oper
, 1);
2604 tree opertype
= TREE_TYPE (oper
);
2605 if ((addr_expr
|| !POINTER_TYPE_P (opertype
))
2607 || TREE_CODE (oper
) == FIELD_DECL
2608 || TREE_CODE (oper
) == PARM_DECL
))
2610 /* A possibly optimistic estimate of the number of bytes available
2611 in the destination buffer. */
2612 offset_int bytes_avail
= 0;
2613 /* True when the estimate above is in fact the exact size
2614 of the destination buffer rather than an estimate. */
2615 bool exact_size
= true;
2617 /* Treat members of unions and members of structs uniformly, even
2618 though the size of a member of a union may be viewed as extending
2619 to the end of the union itself (it is by __builtin_object_size). */
2620 if ((VAR_P (oper
) || use_obj_size
)
2621 && DECL_SIZE_UNIT (oper
)
2622 && tree_fits_uhwi_p (DECL_SIZE_UNIT (oper
)))
2624 /* Use the size of the entire array object when the expression
2625 refers to a variable or its size depends on an expression
2626 that's not a compile-time constant. */
2627 bytes_avail
= wi::to_offset (DECL_SIZE_UNIT (oper
));
2628 exact_size
= !use_obj_size
;
2630 else if (tree opersize
= TYPE_SIZE_UNIT (opertype
))
2632 /* Use the size of the type of the destination buffer object
2633 as the optimistic estimate of the available space in it.
2634 Use the maximum possible size for zero-size arrays and
2635 flexible array members (except of initialized objects
2637 if (TREE_CODE (opersize
) == INTEGER_CST
)
2638 bytes_avail
= wi::to_offset (opersize
);
2641 if (bytes_avail
== 0)
2645 /* Constructing into a buffer provided by the flexible array
2646 member of a declared object (which is permitted as a G++
2647 extension). If the array member has been initialized,
2648 determine its size from the initializer. Otherwise,
2649 the array size is zero. */
2650 if (tree init
= find_flexarray_init (oper
,
2651 DECL_INITIAL (var_decl
)))
2652 bytes_avail
= wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (init
)));
2655 bytes_avail
= (wi::to_offset (TYPE_MAX_VALUE (ptrdiff_type_node
))
2659 tree_code oper_code
= TREE_CODE (opertype
);
2661 if (compref
&& oper_code
== ARRAY_TYPE
)
2663 tree nelts
= array_type_nelts_top (opertype
);
2664 tree nelts_cst
= maybe_constant_value (nelts
);
2665 if (TREE_CODE (nelts_cst
) == INTEGER_CST
2666 && integer_onep (nelts_cst
)
2668 && warn_placement_new
< 2)
2672 /* Reduce the size of the buffer by the adjustment computed above
2673 from the offset and/or the index into the array. */
2674 if (bytes_avail
< adjust
|| adjust
< 0)
2678 tree elttype
= (TREE_CODE (opertype
) == ARRAY_TYPE
2679 ? TREE_TYPE (opertype
) : opertype
);
2680 if (tree eltsize
= TYPE_SIZE_UNIT (elttype
))
2682 bytes_avail
-= adjust
* wi::to_offset (eltsize
);
2683 if (bytes_avail
< 0)
2688 /* The minimum amount of space needed for the allocation. This
2689 is an optimistic estimate that makes it possible to detect
2690 placement new invocation for some undersize buffers but not
2692 offset_int bytes_need
;
2694 if (CONSTANT_CLASS_P (size
))
2695 bytes_need
= wi::to_offset (size
);
2696 else if (nelts
&& CONSTANT_CLASS_P (nelts
))
2697 bytes_need
= (wi::to_offset (nelts
)
2698 * wi::to_offset (TYPE_SIZE_UNIT (type
)));
2699 else if (tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
2700 bytes_need
= wi::to_offset (TYPE_SIZE_UNIT (type
));
2703 /* The type is a VLA. */
2707 if (bytes_avail
< bytes_need
)
2710 if (CONSTANT_CLASS_P (nelts
))
2711 warning_at (loc
, OPT_Wplacement_new_
,
2713 "placement new constructing an object of type "
2714 "%<%T [%wu]%> and size %qwu in a region of type %qT "
2716 : "placement new constructing an object of type "
2717 "%<%T [%wu]%> and size %qwu in a region of type %qT "
2718 "and size at most %qwu",
2719 type
, tree_to_uhwi (nelts
), bytes_need
.to_uhwi (),
2720 opertype
, bytes_avail
.to_uhwi ());
2722 warning_at (loc
, OPT_Wplacement_new_
,
2724 "placement new constructing an array of objects "
2725 "of type %qT and size %qwu in a region of type %qT "
2727 : "placement new constructing an array of objects "
2728 "of type %qT and size %qwu in a region of type %qT "
2729 "and size at most %qwu",
2730 type
, bytes_need
.to_uhwi (), opertype
,
2731 bytes_avail
.to_uhwi ());
2733 warning_at (loc
, OPT_Wplacement_new_
,
2735 "placement new constructing an object of type %qT "
2736 "and size %qwu in a region of type %qT and size %qwi"
2737 : "placement new constructing an object of type %qT "
2738 "and size %qwu in a region of type %qT and size "
2740 type
, bytes_need
.to_uhwi (), opertype
,
2741 bytes_avail
.to_uhwi ());
2746 /* True if alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__. */
2749 type_has_new_extended_alignment (tree t
)
2751 return (aligned_new_threshold
2752 && TYPE_ALIGN_UNIT (t
) > (unsigned)aligned_new_threshold
);
2755 /* Return the alignment we expect malloc to guarantee. This should just be
2756 MALLOC_ABI_ALIGNMENT, but that macro defaults to only BITS_PER_WORD for some
2757 reason, so don't let the threshold be smaller than max_align_t_align. */
2762 return MAX (max_align_t_align(), MALLOC_ABI_ALIGNMENT
);
2765 /* Determine whether an allocation function is a namespace-scope
2766 non-replaceable placement new function. See DR 1748.
2767 TODO: Enable in all standard modes. */
2769 std_placement_new_fn_p (tree alloc_fn
)
2771 if (DECL_NAMESPACE_SCOPE_P (alloc_fn
))
2773 tree first_arg
= TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn
)));
2774 if ((TREE_VALUE (first_arg
) == ptr_type_node
)
2775 && TREE_CHAIN (first_arg
) == void_list_node
)
2781 /* Generate code for a new-expression, including calling the "operator
2782 new" function, initializing the object, and, if an exception occurs
2783 during construction, cleaning up. The arguments are as for
2784 build_raw_new_expr. This may change PLACEMENT and INIT.
2785 TYPE is the type of the object being constructed, possibly an array
2786 of NELTS elements when NELTS is non-null (in "new T[NELTS]", T may
2787 be an array of the form U[inner], with the whole expression being
2788 "new U[NELTS][inner]"). */
2791 build_new_1 (vec
<tree
, va_gc
> **placement
, tree type
, tree nelts
,
2792 vec
<tree
, va_gc
> **init
, bool globally_qualified_p
,
2793 tsubst_flags_t complain
)
2796 /* True iff this is a call to "operator new[]" instead of just
2798 bool array_p
= false;
2799 /* If ARRAY_P is true, the element type of the array. This is never
2800 an ARRAY_TYPE; for something like "new int[3][4]", the
2801 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
2804 /* The type of the new-expression. (This type is always a pointer
2807 tree non_const_pointer_type
;
2808 /* The most significant array bound in int[OUTER_NELTS][inner]. */
2809 tree outer_nelts
= NULL_TREE
;
2810 /* For arrays with a non-constant number of elements, a bounds checks
2811 on the NELTS parameter to avoid integer overflow at runtime. */
2812 tree outer_nelts_check
= NULL_TREE
;
2813 bool outer_nelts_from_type
= false;
2814 /* Number of the "inner" elements in "new T[OUTER_NELTS][inner]". */
2815 offset_int inner_nelts_count
= 1;
2816 tree alloc_call
, alloc_expr
;
2817 /* Size of the inner array elements (those with constant dimensions). */
2818 offset_int inner_size
;
2819 /* The address returned by the call to "operator new". This node is
2820 a VAR_DECL and is therefore reusable. */
2823 tree cookie_expr
, init_expr
;
2824 int nothrow
, check_new
;
2825 /* If non-NULL, the number of extra bytes to allocate at the
2826 beginning of the storage allocated for an array-new expression in
2827 order to store the number of elements. */
2828 tree cookie_size
= NULL_TREE
;
2829 tree placement_first
;
2830 tree placement_expr
= NULL_TREE
;
2831 /* True if the function we are calling is a placement allocation
2833 bool placement_allocation_fn_p
;
2834 /* True if the storage must be initialized, either by a constructor
2835 or due to an explicit new-initializer. */
2836 bool is_initialized
;
2837 /* The address of the thing allocated, not including any cookie. In
2838 particular, if an array cookie is in use, DATA_ADDR is the
2839 address of the first array element. This node is a VAR_DECL, and
2840 is therefore reusable. */
2842 tree init_preeval_expr
= NULL_TREE
;
2843 tree orig_type
= type
;
2847 outer_nelts
= nelts
;
2850 else if (TREE_CODE (type
) == ARRAY_TYPE
)
2852 /* Transforms new (T[N]) to new T[N]. The former is a GNU
2853 extension for variable N. (This also covers new T where T is
2856 nelts
= array_type_nelts_top (type
);
2857 outer_nelts
= nelts
;
2858 type
= TREE_TYPE (type
);
2859 outer_nelts_from_type
= true;
2862 /* Lots of logic below. depends on whether we have a constant number of
2863 elements, so go ahead and fold it now. */
2865 outer_nelts
= maybe_constant_value (outer_nelts
);
2867 /* If our base type is an array, then make sure we know how many elements
2869 for (elt_type
= type
;
2870 TREE_CODE (elt_type
) == ARRAY_TYPE
;
2871 elt_type
= TREE_TYPE (elt_type
))
2873 tree inner_nelts
= array_type_nelts_top (elt_type
);
2874 tree inner_nelts_cst
= maybe_constant_value (inner_nelts
);
2875 if (TREE_CODE (inner_nelts_cst
) == INTEGER_CST
)
2878 offset_int result
= wi::mul (wi::to_offset (inner_nelts_cst
),
2879 inner_nelts_count
, SIGNED
, &overflow
);
2882 if (complain
& tf_error
)
2883 error ("integer overflow in array size");
2884 nelts
= error_mark_node
;
2886 inner_nelts_count
= result
;
2890 if (complain
& tf_error
)
2892 error_at (EXPR_LOC_OR_LOC (inner_nelts
, input_location
),
2893 "array size in new-expression must be constant");
2894 cxx_constant_value(inner_nelts
);
2896 nelts
= error_mark_node
;
2898 if (nelts
!= error_mark_node
)
2899 nelts
= cp_build_binary_op (input_location
,
2905 if (variably_modified_type_p (elt_type
, NULL_TREE
) && (complain
& tf_error
))
2907 error ("variably modified type not allowed in new-expression");
2908 return error_mark_node
;
2911 if (nelts
== error_mark_node
)
2912 return error_mark_node
;
2914 /* Warn if we performed the (T[N]) to T[N] transformation and N is
2916 if (outer_nelts_from_type
2917 && !TREE_CONSTANT (outer_nelts
))
2919 if (complain
& tf_warning_or_error
)
2921 pedwarn (EXPR_LOC_OR_LOC (outer_nelts
, input_location
), OPT_Wvla
,
2922 typedef_variant_p (orig_type
)
2923 ? G_("non-constant array new length must be specified "
2924 "directly, not by typedef")
2925 : G_("non-constant array new length must be specified "
2926 "without parentheses around the type-id"));
2929 return error_mark_node
;
2932 if (VOID_TYPE_P (elt_type
))
2934 if (complain
& tf_error
)
2935 error ("invalid type %<void%> for new");
2936 return error_mark_node
;
2939 if (abstract_virtuals_error_sfinae (ACU_NEW
, elt_type
, complain
))
2940 return error_mark_node
;
2942 is_initialized
= (type_build_ctor_call (elt_type
) || *init
!= NULL
);
2944 if (*init
== NULL
&& cxx_dialect
< cxx11
)
2946 bool maybe_uninitialized_error
= false;
2947 /* A program that calls for default-initialization [...] of an
2948 entity of reference type is ill-formed. */
2949 if (CLASSTYPE_REF_FIELDS_NEED_INIT (elt_type
))
2950 maybe_uninitialized_error
= true;
2952 /* A new-expression that creates an object of type T initializes
2953 that object as follows:
2954 - If the new-initializer is omitted:
2955 -- If T is a (possibly cv-qualified) non-POD class type
2956 (or array thereof), the object is default-initialized (8.5).
2958 -- Otherwise, the object created has indeterminate
2959 value. If T is a const-qualified type, or a (possibly
2960 cv-qualified) POD class type (or array thereof)
2961 containing (directly or indirectly) a member of
2962 const-qualified type, the program is ill-formed; */
2964 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (elt_type
))
2965 maybe_uninitialized_error
= true;
2967 if (maybe_uninitialized_error
2968 && diagnose_uninitialized_cst_or_ref_member (elt_type
,
2970 complain
& tf_error
))
2971 return error_mark_node
;
2974 if (CP_TYPE_CONST_P (elt_type
) && *init
== NULL
2975 && default_init_uninitialized_part (elt_type
))
2977 if (complain
& tf_error
)
2978 error ("uninitialized const in %<new%> of %q#T", elt_type
);
2979 return error_mark_node
;
2982 size
= size_in_bytes (elt_type
);
2985 /* Maximum available size in bytes. Half of the address space
2986 minus the cookie size. */
2988 = wi::set_bit_in_zero
<offset_int
> (TYPE_PRECISION (sizetype
) - 1);
2989 /* Maximum number of outer elements which can be allocated. */
2990 offset_int max_outer_nelts
;
2991 tree max_outer_nelts_tree
;
2993 gcc_assert (TREE_CODE (size
) == INTEGER_CST
);
2994 cookie_size
= targetm
.cxx
.get_cookie_size (elt_type
);
2995 gcc_assert (TREE_CODE (cookie_size
) == INTEGER_CST
);
2996 gcc_checking_assert (wi::ltu_p (wi::to_offset (cookie_size
), max_size
));
2997 /* Unconditionally subtract the cookie size. This decreases the
2998 maximum object size and is safe even if we choose not to use
2999 a cookie after all. */
3000 max_size
-= wi::to_offset (cookie_size
);
3002 inner_size
= wi::mul (wi::to_offset (size
), inner_nelts_count
, SIGNED
,
3004 if (overflow
|| wi::gtu_p (inner_size
, max_size
))
3006 if (complain
& tf_error
)
3007 error ("size of array is too large");
3008 return error_mark_node
;
3011 max_outer_nelts
= wi::udiv_trunc (max_size
, inner_size
);
3012 max_outer_nelts_tree
= wide_int_to_tree (sizetype
, max_outer_nelts
);
3014 size
= size_binop (MULT_EXPR
, size
, fold_convert (sizetype
, nelts
));
3016 if (INTEGER_CST
== TREE_CODE (outer_nelts
))
3018 if (tree_int_cst_lt (max_outer_nelts_tree
, outer_nelts
))
3020 /* When the array size is constant, check it at compile time
3021 to make sure it doesn't exceed the implementation-defined
3022 maximum, as required by C++ 14 (in C++ 11 this requirement
3023 isn't explicitly stated but it's enforced anyway -- see
3024 grokdeclarator in cp/decl.c). */
3025 if (complain
& tf_error
)
3026 error ("size of array is too large");
3027 return error_mark_node
;
3032 /* When a runtime check is necessary because the array size
3033 isn't constant, keep only the top-most seven bits (starting
3034 with the most significant non-zero bit) of the maximum size
3035 to compare the array size against, to simplify encoding the
3036 constant maximum size in the instruction stream. */
3038 unsigned shift
= (max_outer_nelts
.get_precision ()) - 7
3039 - wi::clz (max_outer_nelts
);
3040 max_outer_nelts
= (max_outer_nelts
>> shift
) << shift
;
3042 outer_nelts_check
= fold_build2 (LE_EXPR
, boolean_type_node
,
3044 max_outer_nelts_tree
);
3048 tree align_arg
= NULL_TREE
;
3049 if (type_has_new_extended_alignment (elt_type
))
3050 align_arg
= build_int_cst (align_type_node
, TYPE_ALIGN_UNIT (elt_type
));
3052 alloc_fn
= NULL_TREE
;
3054 /* If PLACEMENT is a single simple pointer type not passed by
3055 reference, prepare to capture it in a temporary variable. Do
3056 this now, since PLACEMENT will change in the calls below. */
3057 placement_first
= NULL_TREE
;
3058 if (vec_safe_length (*placement
) == 1
3059 && (TYPE_PTR_P (TREE_TYPE ((**placement
)[0]))))
3060 placement_first
= (**placement
)[0];
3062 bool member_new_p
= false;
3064 /* Allocate the object. */
3068 fnname
= ovl_op_identifier (false, array_p
? VEC_NEW_EXPR
: NEW_EXPR
);
3070 member_new_p
= !globally_qualified_p
3071 && CLASS_TYPE_P (elt_type
)
3073 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type
)
3074 : TYPE_HAS_NEW_OPERATOR (elt_type
));
3078 /* Use a class-specific operator new. */
3079 /* If a cookie is required, add some extra space. */
3080 if (array_p
&& TYPE_VEC_NEW_USES_COOKIE (elt_type
))
3081 size
= size_binop (PLUS_EXPR
, size
, cookie_size
);
3084 cookie_size
= NULL_TREE
;
3085 /* No size arithmetic necessary, so the size check is
3087 if (outer_nelts_check
!= NULL
&& inner_size
== 1)
3088 outer_nelts_check
= NULL_TREE
;
3090 /* Perform the overflow check. */
3091 tree errval
= TYPE_MAX_VALUE (sizetype
);
3092 if (cxx_dialect
>= cxx11
&& flag_exceptions
)
3093 errval
= throw_bad_array_new_length ();
3094 if (outer_nelts_check
!= NULL_TREE
)
3095 size
= fold_build3 (COND_EXPR
, sizetype
, outer_nelts_check
,
3097 /* Create the argument list. */
3098 vec_safe_insert (*placement
, 0, size
);
3099 /* Do name-lookup to find the appropriate operator. */
3100 fns
= lookup_fnfields (elt_type
, fnname
, /*protect=*/2);
3101 if (fns
== NULL_TREE
)
3103 if (complain
& tf_error
)
3104 error ("no suitable %qD found in class %qT", fnname
, elt_type
);
3105 return error_mark_node
;
3107 if (TREE_CODE (fns
) == TREE_LIST
)
3109 if (complain
& tf_error
)
3111 error ("request for member %qD is ambiguous", fnname
);
3112 print_candidates (fns
);
3114 return error_mark_node
;
3116 tree dummy
= build_dummy_object (elt_type
);
3117 alloc_call
= NULL_TREE
;
3120 vec
<tree
, va_gc
> *align_args
3121 = vec_copy_and_insert (*placement
, align_arg
, 1);
3123 = build_new_method_call (dummy
, fns
, &align_args
,
3124 /*conversion_path=*/NULL_TREE
,
3125 LOOKUP_NORMAL
, &alloc_fn
, tf_none
);
3126 /* If no matching function is found and the allocated object type
3127 has new-extended alignment, the alignment argument is removed
3128 from the argument list, and overload resolution is performed
3130 if (alloc_call
== error_mark_node
)
3131 alloc_call
= NULL_TREE
;
3134 alloc_call
= build_new_method_call (dummy
, fns
, placement
,
3135 /*conversion_path=*/NULL_TREE
,
3137 &alloc_fn
, complain
);
3141 /* Use a global operator new. */
3142 /* See if a cookie might be required. */
3143 if (!(array_p
&& TYPE_VEC_NEW_USES_COOKIE (elt_type
)))
3145 cookie_size
= NULL_TREE
;
3146 /* No size arithmetic necessary, so the size check is
3148 if (outer_nelts_check
!= NULL
&& inner_size
== 1)
3149 outer_nelts_check
= NULL_TREE
;
3152 alloc_call
= build_operator_new_call (fnname
, placement
,
3153 &size
, &cookie_size
,
3154 align_arg
, outer_nelts_check
,
3155 &alloc_fn
, complain
);
3158 if (alloc_call
== error_mark_node
)
3159 return error_mark_node
;
3161 gcc_assert (alloc_fn
!= NULL_TREE
);
3163 /* Now, check to see if this function is actually a placement
3164 allocation function. This can happen even when PLACEMENT is NULL
3165 because we might have something like:
3167 struct S { void* operator new (size_t, int i = 0); };
3169 A call to `new S' will get this allocation function, even though
3170 there is no explicit placement argument. If there is more than
3171 one argument, or there are variable arguments, then this is a
3172 placement allocation function. */
3173 placement_allocation_fn_p
3174 = (type_num_arguments (TREE_TYPE (alloc_fn
)) > 1
3175 || varargs_function_p (alloc_fn
));
3177 if (warn_aligned_new
3178 && !placement_allocation_fn_p
3179 && TYPE_ALIGN (elt_type
) > malloc_alignment ()
3180 && (warn_aligned_new
> 1
3181 || CP_DECL_CONTEXT (alloc_fn
) == global_namespace
)
3182 && !aligned_allocation_fn_p (alloc_fn
))
3184 if (warning (OPT_Waligned_new_
, "%<new%> of type %qT with extended "
3185 "alignment %d", elt_type
, TYPE_ALIGN_UNIT (elt_type
)))
3187 inform (input_location
, "uses %qD, which does not have an alignment "
3188 "parameter", alloc_fn
);
3189 if (!aligned_new_threshold
)
3190 inform (input_location
, "use %<-faligned-new%> to enable C++17 "
3191 "over-aligned new support");
3195 /* If we found a simple case of PLACEMENT_EXPR above, then copy it
3196 into a temporary variable. */
3197 if (!processing_template_decl
3198 && TREE_CODE (alloc_call
) == CALL_EXPR
3199 && call_expr_nargs (alloc_call
) == 2
3200 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 0))) == INTEGER_TYPE
3201 && TYPE_PTR_P (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 1))))
3203 tree placement
= CALL_EXPR_ARG (alloc_call
, 1);
3205 if (placement_first
!= NULL_TREE
3206 && (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement
)))
3207 || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement
)))))
3209 placement_expr
= get_target_expr (placement_first
);
3210 CALL_EXPR_ARG (alloc_call
, 1)
3211 = fold_convert (TREE_TYPE (placement
), placement_expr
);
3215 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 1)))))
3217 /* Attempt to make the warning point at the operator new argument. */
3218 if (placement_first
)
3219 placement
= placement_first
;
3221 warn_placement_new_too_small (orig_type
, nelts
, size
, placement
);
3225 /* In the simple case, we can stop now. */
3226 pointer_type
= build_pointer_type (type
);
3227 if (!cookie_size
&& !is_initialized
)
3228 return build_nop (pointer_type
, alloc_call
);
3230 /* Store the result of the allocation call in a variable so that we can
3231 use it more than once. */
3232 alloc_expr
= get_target_expr (alloc_call
);
3233 alloc_node
= TARGET_EXPR_SLOT (alloc_expr
);
3235 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
3236 while (TREE_CODE (alloc_call
) == COMPOUND_EXPR
)
3237 alloc_call
= TREE_OPERAND (alloc_call
, 1);
3239 /* Preevaluate the placement args so that we don't reevaluate them for a
3240 placement delete. */
3241 if (placement_allocation_fn_p
)
3244 stabilize_call (alloc_call
, &inits
);
3246 alloc_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (alloc_expr
), inits
,
3250 /* unless an allocation function is declared with an empty excep-
3251 tion-specification (_except.spec_), throw(), it indicates failure to
3252 allocate storage by throwing a bad_alloc exception (clause _except_,
3253 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
3254 cation function is declared with an empty exception-specification,
3255 throw(), it returns null to indicate failure to allocate storage and a
3256 non-null pointer otherwise.
3258 So check for a null exception spec on the op new we just called. */
3260 nothrow
= TYPE_NOTHROW_P (TREE_TYPE (alloc_fn
));
3262 = flag_check_new
|| (nothrow
&& !std_placement_new_fn_p (alloc_fn
));
3270 /* Adjust so we're pointing to the start of the object. */
3271 data_addr
= fold_build_pointer_plus (alloc_node
, cookie_size
);
3273 /* Store the number of bytes allocated so that we can know how
3274 many elements to destroy later. We use the last sizeof
3275 (size_t) bytes to store the number of elements. */
3276 cookie_ptr
= size_binop (MINUS_EXPR
, cookie_size
, size_in_bytes (sizetype
));
3277 cookie_ptr
= fold_build_pointer_plus_loc (input_location
,
3278 alloc_node
, cookie_ptr
);
3279 size_ptr_type
= build_pointer_type (sizetype
);
3280 cookie_ptr
= fold_convert (size_ptr_type
, cookie_ptr
);
3281 cookie
= cp_build_fold_indirect_ref (cookie_ptr
);
3283 cookie_expr
= build2 (MODIFY_EXPR
, sizetype
, cookie
, nelts
);
3285 if (targetm
.cxx
.cookie_has_size ())
3287 /* Also store the element size. */
3288 cookie_ptr
= fold_build_pointer_plus (cookie_ptr
,
3289 fold_build1_loc (input_location
,
3290 NEGATE_EXPR
, sizetype
,
3291 size_in_bytes (sizetype
)));
3293 cookie
= cp_build_fold_indirect_ref (cookie_ptr
);
3294 cookie
= build2 (MODIFY_EXPR
, sizetype
, cookie
,
3295 size_in_bytes (elt_type
));
3296 cookie_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (cookie_expr
),
3297 cookie
, cookie_expr
);
3302 cookie_expr
= NULL_TREE
;
3303 data_addr
= alloc_node
;
3306 /* Now use a pointer to the type we've actually allocated. */
3308 /* But we want to operate on a non-const version to start with,
3309 since we'll be modifying the elements. */
3310 non_const_pointer_type
= build_pointer_type
3311 (cp_build_qualified_type (type
, cp_type_quals (type
) & ~TYPE_QUAL_CONST
));
3313 data_addr
= fold_convert (non_const_pointer_type
, data_addr
);
3314 /* Any further uses of alloc_node will want this type, too. */
3315 alloc_node
= fold_convert (non_const_pointer_type
, alloc_node
);
3317 /* Now initialize the allocated object. Note that we preevaluate the
3318 initialization expression, apart from the actual constructor call or
3319 assignment--we do this because we want to delay the allocation as long
3320 as possible in order to minimize the size of the exception region for
3321 placement delete. */
3325 bool explicit_value_init_p
= false;
3327 if (*init
!= NULL
&& (*init
)->is_empty ())
3330 explicit_value_init_p
= true;
3333 if (processing_template_decl
&& explicit_value_init_p
)
3335 /* build_value_init doesn't work in templates, and we don't need
3336 the initializer anyway since we're going to throw it away and
3337 rebuild it at instantiation time, so just build up a single
3338 constructor call to get any appropriate diagnostics. */
3339 init_expr
= cp_build_fold_indirect_ref (data_addr
);
3340 if (type_build_ctor_call (elt_type
))
3341 init_expr
= build_special_member_call (init_expr
,
3342 complete_ctor_identifier
,
3346 stable
= stabilize_init (init_expr
, &init_preeval_expr
);
3350 tree vecinit
= NULL_TREE
;
3351 if (vec_safe_length (*init
) == 1
3352 && DIRECT_LIST_INIT_P ((**init
)[0]))
3354 vecinit
= (**init
)[0];
3355 if (CONSTRUCTOR_NELTS (vecinit
) == 0)
3356 /* List-value-initialization, leave it alone. */;
3359 tree arraytype
, domain
;
3360 if (TREE_CONSTANT (nelts
))
3361 domain
= compute_array_index_type (NULL_TREE
, nelts
,
3364 /* We'll check the length at runtime. */
3366 arraytype
= build_cplus_array_type (type
, domain
);
3367 vecinit
= digest_init (arraytype
, vecinit
, complain
);
3372 if (complain
& tf_error
)
3373 permerror (input_location
,
3374 "parenthesized initializer in array new");
3376 return error_mark_node
;
3377 vecinit
= build_tree_list_vec (*init
);
3380 = build_vec_init (data_addr
,
3381 cp_build_binary_op (input_location
,
3382 MINUS_EXPR
, outer_nelts
,
3386 explicit_value_init_p
,
3390 /* An array initialization is stable because the initialization
3391 of each element is a full-expression, so the temporaries don't
3397 init_expr
= cp_build_fold_indirect_ref (data_addr
);
3399 if (type_build_ctor_call (type
) && !explicit_value_init_p
)
3401 init_expr
= build_special_member_call (init_expr
,
3402 complete_ctor_identifier
,
3407 else if (explicit_value_init_p
)
3409 /* Something like `new int()'. NO_CLEANUP is needed so
3410 we don't try and build a (possibly ill-formed)
3412 tree val
= build_value_init (type
, complain
| tf_no_cleanup
);
3413 if (val
== error_mark_node
)
3414 return error_mark_node
;
3415 init_expr
= build2 (INIT_EXPR
, type
, init_expr
, val
);
3421 /* We are processing something like `new int (10)', which
3422 means allocate an int, and initialize it with 10. */
3424 ie
= build_x_compound_expr_from_vec (*init
, "new initializer",
3426 init_expr
= cp_build_modify_expr (input_location
, init_expr
,
3427 INIT_EXPR
, ie
, complain
);
3429 /* If the initializer uses C++14 aggregate NSDMI that refer to the
3430 object being initialized, replace them now and don't try to
3432 bool had_placeholder
= false;
3433 if (!processing_template_decl
3434 && TREE_CODE (init_expr
) == INIT_EXPR
)
3435 TREE_OPERAND (init_expr
, 1)
3436 = replace_placeholders (TREE_OPERAND (init_expr
, 1),
3437 TREE_OPERAND (init_expr
, 0),
3439 stable
= (!had_placeholder
3440 && stabilize_init (init_expr
, &init_preeval_expr
));
3443 if (init_expr
== error_mark_node
)
3444 return error_mark_node
;
3446 /* If any part of the object initialization terminates by throwing an
3447 exception and a suitable deallocation function can be found, the
3448 deallocation function is called to free the memory in which the
3449 object was being constructed, after which the exception continues
3450 to propagate in the context of the new-expression. If no
3451 unambiguous matching deallocation function can be found,
3452 propagating the exception does not cause the object's memory to be
3454 if (flag_exceptions
)
3456 enum tree_code dcode
= array_p
? VEC_DELETE_EXPR
: DELETE_EXPR
;
3459 /* The Standard is unclear here, but the right thing to do
3460 is to use the same method for finding deallocation
3461 functions that we use for finding allocation functions. */
3462 cleanup
= (build_op_delete_call
3466 globally_qualified_p
,
3467 placement_allocation_fn_p
? alloc_call
: NULL_TREE
,
3474 /* This is much simpler if we were able to preevaluate all of
3475 the arguments to the constructor call. */
3477 /* CLEANUP is compiler-generated, so no diagnostics. */
3478 TREE_NO_WARNING (cleanup
) = true;
3479 init_expr
= build2 (TRY_CATCH_EXPR
, void_type_node
,
3480 init_expr
, cleanup
);
3481 /* Likewise, this try-catch is compiler-generated. */
3482 TREE_NO_WARNING (init_expr
) = true;
3485 /* Ack! First we allocate the memory. Then we set our sentry
3486 variable to true, and expand a cleanup that deletes the
3487 memory if sentry is true. Then we run the constructor, and
3488 finally clear the sentry.
3490 We need to do this because we allocate the space first, so
3491 if there are any temporaries with cleanups in the
3492 constructor args and we weren't able to preevaluate them, we
3493 need this EH region to extend until end of full-expression
3494 to preserve nesting. */
3496 tree end
, sentry
, begin
;
3498 begin
= get_target_expr (boolean_true_node
);
3499 CLEANUP_EH_ONLY (begin
) = 1;
3501 sentry
= TARGET_EXPR_SLOT (begin
);
3503 /* CLEANUP is compiler-generated, so no diagnostics. */
3504 TREE_NO_WARNING (cleanup
) = true;
3506 TARGET_EXPR_CLEANUP (begin
)
3507 = build3 (COND_EXPR
, void_type_node
, sentry
,
3508 cleanup
, void_node
);
3510 end
= build2 (MODIFY_EXPR
, TREE_TYPE (sentry
),
3511 sentry
, boolean_false_node
);
3514 = build2 (COMPOUND_EXPR
, void_type_node
, begin
,
3515 build2 (COMPOUND_EXPR
, void_type_node
, init_expr
,
3517 /* Likewise, this is compiler-generated. */
3518 TREE_NO_WARNING (init_expr
) = true;
3523 init_expr
= NULL_TREE
;
3525 /* Now build up the return value in reverse order. */
3530 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), init_expr
, rval
);
3532 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), cookie_expr
, rval
);
3534 if (rval
== data_addr
)
3535 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
3536 and return the call (which doesn't need to be adjusted). */
3537 rval
= TARGET_EXPR_INITIAL (alloc_expr
);
3542 tree ifexp
= cp_build_binary_op (input_location
,
3543 NE_EXPR
, alloc_node
,
3546 rval
= build_conditional_expr (input_location
, ifexp
, rval
,
3547 alloc_node
, complain
);
3550 /* Perform the allocation before anything else, so that ALLOC_NODE
3551 has been initialized before we start using it. */
3552 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
3555 if (init_preeval_expr
)
3556 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), init_preeval_expr
, rval
);
3558 /* A new-expression is never an lvalue. */
3559 gcc_assert (!obvalue_p (rval
));
3561 return convert (pointer_type
, rval
);
3564 /* Generate a representation for a C++ "new" expression. *PLACEMENT
3565 is a vector of placement-new arguments (or NULL if none). If NELTS
3566 is NULL, TYPE is the type of the storage to be allocated. If NELTS
3567 is not NULL, then this is an array-new allocation; TYPE is the type
3568 of the elements in the array and NELTS is the number of elements in
3569 the array. *INIT, if non-NULL, is the initializer for the new
3570 object, or an empty vector to indicate an initializer of "()". If
3571 USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
3572 rather than just "new". This may change PLACEMENT and INIT. */
3575 build_new (vec
<tree
, va_gc
> **placement
, tree type
, tree nelts
,
3576 vec
<tree
, va_gc
> **init
, int use_global_new
, tsubst_flags_t complain
)
3579 vec
<tree
, va_gc
> *orig_placement
= NULL
;
3580 tree orig_nelts
= NULL_TREE
;
3581 vec
<tree
, va_gc
> *orig_init
= NULL
;
3583 if (type
== error_mark_node
)
3584 return error_mark_node
;
3586 if (nelts
== NULL_TREE
3587 /* Don't do auto deduction where it might affect mangling. */
3588 && (!processing_template_decl
|| at_function_scope_p ()))
3590 tree auto_node
= type_uses_auto (type
);
3593 tree d_init
= NULL_TREE
;
3594 if (vec_safe_length (*init
) == 1)
3596 d_init
= (**init
)[0];
3597 d_init
= resolve_nondeduced_context (d_init
, complain
);
3599 type
= do_auto_deduction (type
, d_init
, auto_node
, complain
);
3603 if (processing_template_decl
)
3605 if (dependent_type_p (type
)
3606 || any_type_dependent_arguments_p (*placement
)
3607 || (nelts
&& type_dependent_expression_p (nelts
))
3609 || any_type_dependent_arguments_p (*init
))
3610 return build_raw_new_expr (*placement
, type
, nelts
, *init
,
3613 orig_placement
= make_tree_vector_copy (*placement
);
3617 orig_init
= make_tree_vector_copy (*init
);
3618 /* Also copy any CONSTRUCTORs in *init, since reshape_init and
3619 digest_init clobber them in place. */
3620 for (unsigned i
= 0; i
< orig_init
->length(); ++i
)
3622 tree e
= (**init
)[i
];
3623 if (TREE_CODE (e
) == CONSTRUCTOR
)
3624 (**init
)[i
] = copy_node (e
);
3628 make_args_non_dependent (*placement
);
3630 nelts
= build_non_dependent_expr (nelts
);
3631 make_args_non_dependent (*init
);
3636 if (!build_expr_type_conversion (WANT_INT
| WANT_ENUM
, nelts
, false))
3638 if (complain
& tf_error
)
3639 permerror (input_location
, "size in array new must have integral type");
3641 return error_mark_node
;
3644 /* Try to determine the constant value only for the purposes
3645 of the diagnostic below but continue to use the original
3646 value and handle const folding later. */
3647 const_tree cst_nelts
= maybe_constant_value (nelts
);
3649 /* The expression in a noptr-new-declarator is erroneous if it's of
3650 non-class type and its value before converting to std::size_t is
3651 less than zero. ... If the expression is a constant expression,
3652 the program is ill-fomed. */
3653 if (INTEGER_CST
== TREE_CODE (cst_nelts
)
3654 && tree_int_cst_sgn (cst_nelts
) == -1)
3656 if (complain
& tf_error
)
3657 error ("size of array is negative");
3658 return error_mark_node
;
3661 nelts
= mark_rvalue_use (nelts
);
3662 nelts
= cp_save_expr (cp_convert (sizetype
, nelts
, complain
));
3665 /* ``A reference cannot be created by the new operator. A reference
3666 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
3667 returned by new.'' ARM 5.3.3 */
3668 if (TREE_CODE (type
) == REFERENCE_TYPE
)
3670 if (complain
& tf_error
)
3671 error ("new cannot be applied to a reference type");
3673 return error_mark_node
;
3674 type
= TREE_TYPE (type
);
3677 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3679 if (complain
& tf_error
)
3680 error ("new cannot be applied to a function type");
3681 return error_mark_node
;
3684 /* The type allocated must be complete. If the new-type-id was
3685 "T[N]" then we are just checking that "T" is complete here, but
3686 that is equivalent, since the value of "N" doesn't matter. */
3687 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
3688 return error_mark_node
;
3690 rval
= build_new_1 (placement
, type
, nelts
, init
, use_global_new
, complain
);
3691 if (rval
== error_mark_node
)
3692 return error_mark_node
;
3694 if (processing_template_decl
)
3696 tree ret
= build_raw_new_expr (orig_placement
, type
, orig_nelts
,
3697 orig_init
, use_global_new
);
3698 release_tree_vector (orig_placement
);
3699 release_tree_vector (orig_init
);
3703 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
3704 rval
= build1 (NOP_EXPR
, TREE_TYPE (rval
), rval
);
3705 TREE_NO_WARNING (rval
) = 1;
3711 build_vec_delete_1 (tree base
, tree maxindex
, tree type
,
3712 special_function_kind auto_delete_vec
,
3713 int use_global_delete
, tsubst_flags_t complain
)
3716 tree ptype
= build_pointer_type (type
= complete_type (type
));
3719 /* Temporary variables used by the loop. */
3720 tree tbase
, tbase_init
;
3722 /* This is the body of the loop that implements the deletion of a
3723 single element, and moves temp variables to next elements. */
3726 /* This is the LOOP_EXPR that governs the deletion of the elements. */
3729 /* This is the thing that governs what to do after the loop has run. */
3730 tree deallocate_expr
= 0;
3732 /* This is the BIND_EXPR which holds the outermost iterator of the
3733 loop. It is convenient to set this variable up and test it before
3734 executing any other code in the loop.
3735 This is also the containing expression returned by this function. */
3736 tree controller
= NULL_TREE
;
3739 /* We should only have 1-D arrays here. */
3740 gcc_assert (TREE_CODE (type
) != ARRAY_TYPE
);
3742 if (base
== error_mark_node
|| maxindex
== error_mark_node
)
3743 return error_mark_node
;
3745 if (!COMPLETE_TYPE_P (type
))
3747 if ((complain
& tf_warning
)
3748 && warning (OPT_Wdelete_incomplete
,
3749 "possible problem detected in invocation of "
3750 "delete [] operator:"))
3752 cxx_incomplete_type_diagnostic (base
, type
, DK_WARNING
);
3753 inform (input_location
, "neither the destructor nor the "
3754 "class-specific operator delete [] will be called, "
3755 "even if they are declared when the class is defined");
3757 /* This size won't actually be used. */
3758 size_exp
= size_one_node
;
3762 size_exp
= size_in_bytes (type
);
3764 if (! MAYBE_CLASS_TYPE_P (type
))
3766 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
3768 /* Make sure the destructor is callable. */
3769 if (type_build_dtor_call (type
))
3771 tmp
= build_delete (ptype
, base
, sfk_complete_destructor
,
3772 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1,
3774 if (tmp
== error_mark_node
)
3775 return error_mark_node
;
3780 /* The below is short by the cookie size. */
3781 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
3782 fold_convert (sizetype
, maxindex
));
3784 tbase
= create_temporary_var (ptype
);
3786 = cp_build_modify_expr (input_location
, tbase
, NOP_EXPR
,
3787 fold_build_pointer_plus_loc (input_location
,
3788 fold_convert (ptype
,
3792 if (tbase_init
== error_mark_node
)
3793 return error_mark_node
;
3794 controller
= build3 (BIND_EXPR
, void_type_node
, tbase
,
3795 NULL_TREE
, NULL_TREE
);
3796 TREE_SIDE_EFFECTS (controller
) = 1;
3798 body
= build1 (EXIT_EXPR
, void_type_node
,
3799 build2 (EQ_EXPR
, boolean_type_node
, tbase
,
3800 fold_convert (ptype
, base
)));
3801 tmp
= fold_build1_loc (input_location
, NEGATE_EXPR
, sizetype
, size_exp
);
3802 tmp
= fold_build_pointer_plus (tbase
, tmp
);
3803 tmp
= cp_build_modify_expr (input_location
, tbase
, NOP_EXPR
, tmp
, complain
);
3804 if (tmp
== error_mark_node
)
3805 return error_mark_node
;
3806 body
= build_compound_expr (input_location
, body
, tmp
);
3807 tmp
= build_delete (ptype
, tbase
, sfk_complete_destructor
,
3808 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1,
3810 if (tmp
== error_mark_node
)
3811 return error_mark_node
;
3812 body
= build_compound_expr (input_location
, body
, tmp
);
3814 loop
= build1 (LOOP_EXPR
, void_type_node
, body
);
3815 loop
= build_compound_expr (input_location
, tbase_init
, loop
);
3818 /* Delete the storage if appropriate. */
3819 if (auto_delete_vec
== sfk_deleting_destructor
)
3823 /* The below is short by the cookie size. */
3824 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
3825 fold_convert (sizetype
, maxindex
));
3827 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
3834 cookie_size
= targetm
.cxx
.get_cookie_size (type
);
3835 base_tbd
= cp_build_binary_op (input_location
,
3837 cp_convert (string_type_node
,
3841 if (base_tbd
== error_mark_node
)
3842 return error_mark_node
;
3843 base_tbd
= cp_convert (ptype
, base_tbd
, complain
);
3844 /* True size with header. */
3845 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, cookie_size
);
3848 deallocate_expr
= build_op_delete_call (VEC_DELETE_EXPR
,
3849 base_tbd
, virtual_size
,
3850 use_global_delete
& 1,
3851 /*placement=*/NULL_TREE
,
3852 /*alloc_fn=*/NULL_TREE
,
3857 if (!deallocate_expr
)
3860 body
= deallocate_expr
;
3862 /* The delete operator mist be called, even if a destructor
3864 body
= build2 (TRY_FINALLY_EXPR
, void_type_node
, body
, deallocate_expr
);
3867 body
= integer_zero_node
;
3869 /* Outermost wrapper: If pointer is null, punt. */
3870 tree cond
= build2_loc (input_location
, NE_EXPR
, boolean_type_node
, base
,
3871 fold_convert (TREE_TYPE (base
), nullptr_node
));
3872 /* This is a compiler generated comparison, don't emit
3873 e.g. -Wnonnull-compare warning for it. */
3874 TREE_NO_WARNING (cond
) = 1;
3875 body
= build3_loc (input_location
, COND_EXPR
, void_type_node
,
3876 cond
, body
, integer_zero_node
);
3877 COND_EXPR_IS_VEC_DELETE (body
) = true;
3878 body
= build1 (NOP_EXPR
, void_type_node
, body
);
3882 TREE_OPERAND (controller
, 1) = body
;
3886 if (TREE_CODE (base
) == SAVE_EXPR
)
3887 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
3888 body
= build2 (COMPOUND_EXPR
, void_type_node
, base
, body
);
3890 return convert_to_void (body
, ICV_CAST
, complain
);
3893 /* Create an unnamed variable of the indicated TYPE. */
3896 create_temporary_var (tree type
)
3900 decl
= build_decl (input_location
,
3901 VAR_DECL
, NULL_TREE
, type
);
3902 TREE_USED (decl
) = 1;
3903 DECL_ARTIFICIAL (decl
) = 1;
3904 DECL_IGNORED_P (decl
) = 1;
3905 DECL_CONTEXT (decl
) = current_function_decl
;
3910 /* Create a new temporary variable of the indicated TYPE, initialized
3913 It is not entered into current_binding_level, because that breaks
3914 things when it comes time to do final cleanups (which take place
3915 "outside" the binding contour of the function). */
3918 get_temp_regvar (tree type
, tree init
)
3922 decl
= create_temporary_var (type
);
3923 add_decl_expr (decl
);
3925 finish_expr_stmt (cp_build_modify_expr (input_location
, decl
, INIT_EXPR
,
3926 init
, tf_warning_or_error
));
3931 /* Subroutine of build_vec_init. Returns true if assigning to an array of
3932 INNER_ELT_TYPE from INIT is trivial. */
3935 vec_copy_assign_is_trivial (tree inner_elt_type
, tree init
)
3937 tree fromtype
= inner_elt_type
;
3938 if (lvalue_p (init
))
3939 fromtype
= cp_build_reference_type (fromtype
, /*rval*/false);
3940 return is_trivially_xible (MODIFY_EXPR
, inner_elt_type
, fromtype
);
3943 /* Subroutine of build_vec_init: Check that the array has at least N
3944 elements. Other parameters are local variables in build_vec_init. */
3947 finish_length_check (tree atype
, tree iterator
, tree obase
, unsigned n
)
3949 tree nelts
= build_int_cst (ptrdiff_type_node
, n
- 1);
3950 if (TREE_CODE (atype
) != ARRAY_TYPE
)
3952 if (flag_exceptions
)
3954 tree c
= fold_build2 (LT_EXPR
, boolean_type_node
, iterator
,
3956 c
= build3 (COND_EXPR
, void_type_node
, c
,
3957 throw_bad_array_new_length (), void_node
);
3958 finish_expr_stmt (c
);
3960 /* Don't check an array new when -fno-exceptions. */
3962 else if (sanitize_flags_p (SANITIZE_BOUNDS
)
3963 && current_function_decl
!= NULL_TREE
)
3965 /* Make sure the last element of the initializer is in bounds. */
3967 (ubsan_instrument_bounds
3968 (input_location
, obase
, &nelts
, /*ignore_off_by_one*/false));
3972 /* `build_vec_init' returns tree structure that performs
3973 initialization of a vector of aggregate types.
3975 BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
3976 to the first element, of POINTER_TYPE.
3977 MAXINDEX is the maximum index of the array (one less than the
3978 number of elements). It is only used if BASE is a pointer or
3979 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
3981 INIT is the (possibly NULL) initializer.
3983 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All
3984 elements in the array are value-initialized.
3986 FROM_ARRAY is 0 if we should init everything with INIT
3987 (i.e., every element initialized from INIT).
3988 FROM_ARRAY is 1 if we should index into INIT in parallel
3989 with initialization of DECL.
3990 FROM_ARRAY is 2 if we should index into INIT in parallel,
3991 but use assignment instead of initialization. */
3994 build_vec_init (tree base
, tree maxindex
, tree init
,
3995 bool explicit_value_init_p
,
3996 int from_array
, tsubst_flags_t complain
)
3999 tree base2
= NULL_TREE
;
4000 tree itype
= NULL_TREE
;
4002 /* The type of BASE. */
4003 tree atype
= TREE_TYPE (base
);
4004 /* The type of an element in the array. */
4005 tree type
= TREE_TYPE (atype
);
4006 /* The element type reached after removing all outer array
4008 tree inner_elt_type
;
4009 /* The type of a pointer to an element in the array. */
4014 tree try_block
= NULL_TREE
;
4015 int num_initialized_elts
= 0;
4018 bool xvalue
= false;
4019 bool errors
= false;
4020 location_t loc
= (init
? EXPR_LOC_OR_LOC (init
, input_location
)
4021 : location_of (base
));
4023 if (TREE_CODE (atype
) == ARRAY_TYPE
&& TYPE_DOMAIN (atype
))
4024 maxindex
= array_type_nelts (atype
);
4026 if (maxindex
== NULL_TREE
|| maxindex
== error_mark_node
)
4027 return error_mark_node
;
4029 maxindex
= maybe_constant_value (maxindex
);
4030 if (explicit_value_init_p
)
4033 inner_elt_type
= strip_array_types (type
);
4035 /* Look through the TARGET_EXPR around a compound literal. */
4036 if (init
&& TREE_CODE (init
) == TARGET_EXPR
4037 && TREE_CODE (TARGET_EXPR_INITIAL (init
)) == CONSTRUCTOR
4039 init
= TARGET_EXPR_INITIAL (init
);
4041 bool direct_init
= false;
4042 if (from_array
&& init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
4043 && CONSTRUCTOR_NELTS (init
) == 1)
4045 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
4046 if (TREE_CODE (TREE_TYPE (elt
)) == ARRAY_TYPE
)
4048 direct_init
= DIRECT_LIST_INIT_P (init
);
4053 /* If we have a braced-init-list or string constant, make sure that the array
4054 is big enough for all the initializers. */
4055 bool length_check
= (init
4056 && (TREE_CODE (init
) == STRING_CST
4057 || (TREE_CODE (init
) == CONSTRUCTOR
4058 && CONSTRUCTOR_NELTS (init
) > 0))
4059 && !TREE_CONSTANT (maxindex
));
4062 && TREE_CODE (atype
) == ARRAY_TYPE
4063 && TREE_CONSTANT (maxindex
)
4065 ? vec_copy_assign_is_trivial (inner_elt_type
, init
)
4066 : !TYPE_NEEDS_CONSTRUCTING (type
))
4067 && ((TREE_CODE (init
) == CONSTRUCTOR
4068 && (BRACE_ENCLOSED_INITIALIZER_P (init
)
4069 || (same_type_ignoring_top_level_qualifiers_p
4070 (atype
, TREE_TYPE (init
))))
4071 /* Don't do this if the CONSTRUCTOR might contain something
4072 that might throw and require us to clean up. */
4073 && (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
))
4074 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type
)))
4077 /* Do non-default initialization of trivial arrays resulting from
4078 brace-enclosed initializers. In this case, digest_init and
4079 store_constructor will handle the semantics for us. */
4081 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
4082 init
= digest_init (atype
, init
, complain
);
4083 stmt_expr
= build2 (INIT_EXPR
, atype
, base
, init
);
4087 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
, complain
);
4088 maxindex
= fold_simple (maxindex
);
4090 if (TREE_CODE (atype
) == ARRAY_TYPE
)
4092 ptype
= build_pointer_type (type
);
4093 base
= decay_conversion (base
, complain
);
4094 if (base
== error_mark_node
)
4095 return error_mark_node
;
4096 base
= cp_convert (ptype
, base
, complain
);
4101 /* The code we are generating looks like:
4105 ptrdiff_t iterator = maxindex;
4107 for (; iterator != -1; --iterator) {
4108 ... initialize *t1 ...
4112 ... destroy elements that were constructed ...
4117 We can omit the try and catch blocks if we know that the
4118 initialization will never throw an exception, or if the array
4119 elements do not have destructors. We can omit the loop completely if
4120 the elements of the array do not have constructors.
4122 We actually wrap the entire body of the above in a STMT_EXPR, for
4125 When copying from array to another, when the array elements have
4126 only trivial copy constructors, we should use __builtin_memcpy
4127 rather than generating a loop. That way, we could take advantage
4128 of whatever cleverness the back end has for dealing with copies
4129 of blocks of memory. */
4131 is_global
= begin_init_stmts (&stmt_expr
, &compound_stmt
);
4132 destroy_temps
= stmts_are_full_exprs_p ();
4133 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
4134 rval
= get_temp_regvar (ptype
, base
);
4135 base
= get_temp_regvar (ptype
, rval
);
4136 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
4138 /* If initializing one array from another, initialize element by
4139 element. We rely upon the below calls to do the argument
4140 checking. Evaluate the initializer before entering the try block. */
4141 if (from_array
&& init
&& TREE_CODE (init
) != CONSTRUCTOR
)
4143 if (lvalue_kind (init
) & clk_rvalueref
)
4145 base2
= decay_conversion (init
, complain
);
4146 if (base2
== error_mark_node
)
4147 return error_mark_node
;
4148 itype
= TREE_TYPE (base2
);
4149 base2
= get_temp_regvar (itype
, base2
);
4150 itype
= TREE_TYPE (itype
);
4153 /* Protect the entire array initialization so that we can destroy
4154 the partially constructed array if an exception is thrown.
4155 But don't do this if we're assigning. */
4156 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
4159 try_block
= begin_try_block ();
4162 /* Should we try to create a constant initializer? */
4163 bool try_const
= (TREE_CODE (atype
) == ARRAY_TYPE
4164 && TREE_CONSTANT (maxindex
)
4165 && (init
? TREE_CODE (init
) == CONSTRUCTOR
4166 : (type_has_constexpr_default_constructor
4168 && (literal_type_p (inner_elt_type
)
4169 || TYPE_HAS_CONSTEXPR_CTOR (inner_elt_type
)));
4170 vec
<constructor_elt
, va_gc
> *const_vec
= NULL
;
4171 bool saw_non_const
= false;
4172 /* If we're initializing a static array, we want to do static
4173 initialization of any elements with constant initializers even if
4174 some are non-constant. */
4175 bool do_static_init
= (DECL_P (obase
) && TREE_STATIC (obase
));
4177 bool empty_list
= false;
4178 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
4179 && CONSTRUCTOR_NELTS (init
) == 0)
4180 /* Skip over the handling of non-empty init lists. */
4183 /* Maybe pull out constant value when from_array? */
4185 else if (init
!= NULL_TREE
&& TREE_CODE (init
) == CONSTRUCTOR
)
4187 /* Do non-default initialization of non-trivial arrays resulting from
4188 brace-enclosed initializers. */
4189 unsigned HOST_WIDE_INT idx
;
4191 /* If the constructor already has the array type, it's been through
4192 digest_init, so we shouldn't try to do anything more. */
4193 bool digested
= same_type_p (atype
, TREE_TYPE (init
));
4197 finish_length_check (atype
, iterator
, obase
, CONSTRUCTOR_NELTS (init
));
4200 vec_alloc (const_vec
, CONSTRUCTOR_NELTS (init
));
4202 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
, field
, elt
)
4204 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
4207 num_initialized_elts
++;
4209 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
4211 one_init
= build2 (INIT_EXPR
, type
, baseref
, elt
);
4212 else if (MAYBE_CLASS_TYPE_P (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
4213 one_init
= build_aggr_init (baseref
, elt
, 0, complain
);
4215 one_init
= cp_build_modify_expr (input_location
, baseref
,
4216 NOP_EXPR
, elt
, complain
);
4217 if (one_init
== error_mark_node
)
4221 tree e
= maybe_constant_init (one_init
);
4222 if (reduced_constant_expression_p (e
))
4224 CONSTRUCTOR_APPEND_ELT (const_vec
, field
, e
);
4226 one_init
= NULL_TREE
;
4228 one_init
= build2 (INIT_EXPR
, type
, baseref
, e
);
4234 tree value
= build_zero_init (TREE_TYPE (e
), NULL_TREE
,
4237 CONSTRUCTOR_APPEND_ELT (const_vec
, field
, value
);
4239 saw_non_const
= true;
4244 finish_expr_stmt (one_init
);
4245 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
4247 one_init
= cp_build_unary_op (PREINCREMENT_EXPR
, base
, false,
4249 if (one_init
== error_mark_node
)
4252 finish_expr_stmt (one_init
);
4254 one_init
= cp_build_unary_op (PREDECREMENT_EXPR
, iterator
, false,
4256 if (one_init
== error_mark_node
)
4259 finish_expr_stmt (one_init
);
4262 /* Any elements without explicit initializers get T{}. */
4265 else if (init
&& TREE_CODE (init
) == STRING_CST
)
4267 /* Check that the array is at least as long as the string. */
4269 finish_length_check (atype
, iterator
, obase
,
4270 TREE_STRING_LENGTH (init
));
4271 tree length
= build_int_cst (ptrdiff_type_node
,
4272 TREE_STRING_LENGTH (init
));
4274 /* Copy the string to the first part of the array. */
4275 tree alias_set
= build_int_cst (build_pointer_type (type
), 0);
4276 tree lhs
= build2 (MEM_REF
, TREE_TYPE (init
), base
, alias_set
);
4277 tree stmt
= build2 (MODIFY_EXPR
, void_type_node
, lhs
, init
);
4278 finish_expr_stmt (stmt
);
4280 /* Adjust the counter and pointer. */
4281 stmt
= cp_build_binary_op (loc
, MINUS_EXPR
, iterator
, length
, complain
);
4282 stmt
= build2 (MODIFY_EXPR
, void_type_node
, iterator
, stmt
);
4283 finish_expr_stmt (stmt
);
4285 stmt
= cp_build_binary_op (loc
, PLUS_EXPR
, base
, length
, complain
);
4286 stmt
= build2 (MODIFY_EXPR
, void_type_node
, base
, stmt
);
4287 finish_expr_stmt (stmt
);
4289 /* And set the rest of the array to NUL. */
4291 explicit_value_init_p
= true;
4293 else if (from_array
)
4296 /* OK, we set base2 above. */;
4297 else if (CLASS_TYPE_P (type
)
4298 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
4300 if (complain
& tf_error
)
4301 error ("initializer ends prematurely");
4306 /* Now, default-initialize any remaining elements. We don't need to
4307 do that if a) the type does not need constructing, or b) we've
4308 already initialized all the elements.
4310 We do need to keep going if we're copying an array. */
4312 if (try_const
&& !init
)
4313 /* With a constexpr default constructor, which we checked for when
4314 setting try_const above, default-initialization is equivalent to
4315 value-initialization, and build_value_init gives us something more
4316 friendly to maybe_constant_init. */
4317 explicit_value_init_p
= true;
4319 || ((type_build_ctor_call (type
) || init
|| explicit_value_init_p
)
4320 && ! (tree_fits_shwi_p (maxindex
)
4321 && (num_initialized_elts
4322 == tree_to_shwi (maxindex
) + 1))))
4324 /* If the ITERATOR is lesser or equal to -1, then we don't have to loop;
4325 we've already initialized all the elements. */
4330 for_stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
4331 finish_init_stmt (for_stmt
);
4332 finish_for_cond (build2 (GT_EXPR
, boolean_type_node
, iterator
,
4333 build_int_cst (TREE_TYPE (iterator
), -1)),
4334 for_stmt
, false, 0);
4335 elt_init
= cp_build_unary_op (PREDECREMENT_EXPR
, iterator
, false,
4337 if (elt_init
== error_mark_node
)
4339 finish_for_expr (elt_init
, for_stmt
);
4341 to
= build1 (INDIRECT_REF
, type
, base
);
4343 /* If the initializer is {}, then all elements are initialized from T{}.
4344 But for non-classes, that's the same as value-initialization. */
4347 if (cxx_dialect
>= cxx11
&& AGGREGATE_TYPE_P (type
))
4349 init
= build_constructor (init_list_type_node
, NULL
);
4354 explicit_value_init_p
= true;
4364 from
= build1 (INDIRECT_REF
, itype
, base2
);
4368 from
= build_tree_list (NULL_TREE
, from
);
4373 if (from_array
== 2)
4374 elt_init
= cp_build_modify_expr (input_location
, to
, NOP_EXPR
,
4376 else if (type_build_ctor_call (type
))
4377 elt_init
= build_aggr_init (to
, from
, 0, complain
);
4379 elt_init
= cp_build_modify_expr (input_location
, to
, NOP_EXPR
, from
,
4384 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4386 if (init
&& !BRACE_ENCLOSED_INITIALIZER_P (init
))
4388 if ((complain
& tf_error
))
4389 error_at (loc
, "array must be initialized "
4390 "with a brace-enclosed initializer");
4391 elt_init
= error_mark_node
;
4394 elt_init
= build_vec_init (build1 (INDIRECT_REF
, type
, base
),
4396 explicit_value_init_p
,
4399 else if (explicit_value_init_p
)
4401 elt_init
= build_value_init (type
, complain
);
4402 if (elt_init
!= error_mark_node
)
4403 elt_init
= build2 (INIT_EXPR
, type
, to
, elt_init
);
4407 gcc_assert (type_build_ctor_call (type
) || init
);
4408 if (CLASS_TYPE_P (type
))
4409 elt_init
= build_aggr_init (to
, init
, 0, complain
);
4412 if (TREE_CODE (init
) == TREE_LIST
)
4413 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
4415 elt_init
= (init
== error_mark_node
4417 : build2 (INIT_EXPR
, type
, to
, init
));
4421 if (elt_init
== error_mark_node
)
4426 /* FIXME refs to earlier elts */
4427 tree e
= maybe_constant_init (elt_init
);
4428 if (reduced_constant_expression_p (e
))
4430 if (initializer_zerop (e
))
4431 /* Don't fill the CONSTRUCTOR with zeros. */
4434 elt_init
= NULL_TREE
;
4438 saw_non_const
= true;
4440 e
= build_zero_init (TREE_TYPE (e
), NULL_TREE
, true);
4447 int max
= tree_to_shwi (maxindex
)+1;
4448 for (; num_initialized_elts
< max
; ++num_initialized_elts
)
4450 tree field
= size_int (num_initialized_elts
);
4451 CONSTRUCTOR_APPEND_ELT (const_vec
, field
, e
);
4456 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
4457 if (elt_init
&& !errors
)
4458 finish_expr_stmt (elt_init
);
4459 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
4461 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR
, base
, false,
4464 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR
, base2
, false,
4467 finish_for_stmt (for_stmt
);
4470 /* Make sure to cleanup any partially constructed elements. */
4471 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
4475 tree m
= cp_build_binary_op (input_location
,
4476 MINUS_EXPR
, maxindex
, iterator
,
4479 /* Flatten multi-dimensional array since build_vec_delete only
4480 expects one-dimensional array. */
4481 if (TREE_CODE (type
) == ARRAY_TYPE
)
4482 m
= cp_build_binary_op (input_location
,
4484 /* Avoid mixing signed and unsigned. */
4485 convert (TREE_TYPE (m
),
4486 array_type_nelts_total (type
)),
4489 finish_cleanup_try_block (try_block
);
4490 e
= build_vec_delete_1 (rval
, m
,
4491 inner_elt_type
, sfk_complete_destructor
,
4492 /*use_global_delete=*/0, complain
);
4493 if (e
== error_mark_node
)
4495 finish_cleanup (e
, try_block
);
4498 /* The value of the array initialization is the array itself, RVAL
4499 is a pointer to the first element. */
4500 finish_stmt_expr_expr (rval
, stmt_expr
);
4502 stmt_expr
= finish_init_stmts (is_global
, stmt_expr
, compound_stmt
);
4504 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
4507 return error_mark_node
;
4513 tree const_init
= build_constructor (atype
, const_vec
);
4514 return build2 (INIT_EXPR
, atype
, obase
, const_init
);
4516 else if (do_static_init
&& !vec_safe_is_empty (const_vec
))
4517 DECL_INITIAL (obase
) = build_constructor (atype
, const_vec
);
4519 vec_free (const_vec
);
4522 /* Now make the result have the correct type. */
4523 if (TREE_CODE (atype
) == ARRAY_TYPE
)
4525 atype
= build_pointer_type (atype
);
4526 stmt_expr
= build1 (NOP_EXPR
, atype
, stmt_expr
);
4527 stmt_expr
= cp_build_fold_indirect_ref (stmt_expr
);
4528 TREE_NO_WARNING (stmt_expr
) = 1;
4534 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
4538 build_dtor_call (tree exp
, special_function_kind dtor_kind
, int flags
,
4539 tsubst_flags_t complain
)
4545 case sfk_complete_destructor
:
4546 name
= complete_dtor_identifier
;
4549 case sfk_base_destructor
:
4550 name
= base_dtor_identifier
;
4553 case sfk_deleting_destructor
:
4554 name
= deleting_dtor_identifier
;
4560 fn
= lookup_fnfields (TREE_TYPE (exp
), name
, /*protect=*/2);
4561 return build_new_method_call (exp
, fn
,
4563 /*conversion_path=*/NULL_TREE
,
4569 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
4570 ADDR is an expression which yields the store to be destroyed.
4571 AUTO_DELETE is the name of the destructor to call, i.e., either
4572 sfk_complete_destructor, sfk_base_destructor, or
4573 sfk_deleting_destructor.
4575 FLAGS is the logical disjunction of zero or more LOOKUP_
4576 flags. See cp-tree.h for more info. */
4579 build_delete (tree otype
, tree addr
, special_function_kind auto_delete
,
4580 int flags
, int use_global_delete
, tsubst_flags_t complain
)
4584 if (addr
== error_mark_node
)
4585 return error_mark_node
;
4587 tree type
= TYPE_MAIN_VARIANT (otype
);
4589 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
4590 set to `error_mark_node' before it gets properly cleaned up. */
4591 if (type
== error_mark_node
)
4592 return error_mark_node
;
4594 if (TREE_CODE (type
) == POINTER_TYPE
)
4595 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
4597 if (TREE_CODE (type
) == ARRAY_TYPE
)
4599 if (TYPE_DOMAIN (type
) == NULL_TREE
)
4601 if (complain
& tf_error
)
4602 error ("unknown array size in delete");
4603 return error_mark_node
;
4605 return build_vec_delete (addr
, array_type_nelts (type
),
4606 auto_delete
, use_global_delete
, complain
);
4609 if (TYPE_PTR_P (otype
))
4611 addr
= mark_rvalue_use (addr
);
4613 /* We don't want to warn about delete of void*, only other
4614 incomplete types. Deleting other incomplete types
4615 invokes undefined behavior, but it is not ill-formed, so
4616 compile to something that would even do The Right Thing
4617 (TM) should the type have a trivial dtor and no delete
4619 if (!VOID_TYPE_P (type
))
4621 complete_type (type
);
4622 if (!COMPLETE_TYPE_P (type
))
4624 if ((complain
& tf_warning
)
4625 && warning (OPT_Wdelete_incomplete
,
4626 "possible problem detected in invocation of "
4627 "delete operator:"))
4629 cxx_incomplete_type_diagnostic (addr
, type
, DK_WARNING
);
4630 inform (input_location
,
4631 "neither the destructor nor the class-specific "
4632 "operator delete will be called, even if they are "
4633 "declared when the class is defined");
4636 else if (auto_delete
== sfk_deleting_destructor
&& warn_delnonvdtor
4637 && MAYBE_CLASS_TYPE_P (type
) && !CLASSTYPE_FINAL (type
)
4638 && TYPE_POLYMORPHIC_P (type
))
4640 tree dtor
= CLASSTYPE_DESTRUCTOR (type
);
4641 if (!dtor
|| !DECL_VINDEX (dtor
))
4643 if (CLASSTYPE_PURE_VIRTUALS (type
))
4644 warning (OPT_Wdelete_non_virtual_dtor
,
4645 "deleting object of abstract class type %qT"
4646 " which has non-virtual destructor"
4647 " will cause undefined behavior", type
);
4649 warning (OPT_Wdelete_non_virtual_dtor
,
4650 "deleting object of polymorphic class type %qT"
4651 " which has non-virtual destructor"
4652 " might cause undefined behavior", type
);
4656 if (TREE_SIDE_EFFECTS (addr
))
4657 addr
= save_expr (addr
);
4659 /* Throw away const and volatile on target type of addr. */
4660 addr
= convert_force (build_pointer_type (type
), addr
, 0, complain
);
4664 /* Don't check PROTECT here; leave that decision to the
4665 destructor. If the destructor is accessible, call it,
4666 else report error. */
4667 addr
= cp_build_addr_expr (addr
, complain
);
4668 if (addr
== error_mark_node
)
4669 return error_mark_node
;
4670 if (TREE_SIDE_EFFECTS (addr
))
4671 addr
= save_expr (addr
);
4673 addr
= convert_force (build_pointer_type (type
), addr
, 0, complain
);
4676 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
4678 /* Make sure the destructor is callable. */
4679 if (type_build_dtor_call (type
))
4681 expr
= build_dtor_call (cp_build_fold_indirect_ref (addr
),
4682 sfk_complete_destructor
, flags
, complain
);
4683 if (expr
== error_mark_node
)
4684 return error_mark_node
;
4687 if (auto_delete
!= sfk_deleting_destructor
)
4690 return build_op_delete_call (DELETE_EXPR
, addr
,
4691 cxx_sizeof_nowarn (type
),
4693 /*placement=*/NULL_TREE
,
4694 /*alloc_fn=*/NULL_TREE
,
4699 tree head
= NULL_TREE
;
4700 tree do_delete
= NULL_TREE
;
4703 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
4704 lazily_declare_fn (sfk_destructor
, type
);
4706 /* For `::delete x', we must not use the deleting destructor
4707 since then we would not be sure to get the global `operator
4709 if (use_global_delete
&& auto_delete
== sfk_deleting_destructor
)
4711 /* We will use ADDR multiple times so we must save it. */
4712 addr
= save_expr (addr
);
4713 head
= get_target_expr (build_headof (addr
));
4714 /* Delete the object. */
4715 do_delete
= build_op_delete_call (DELETE_EXPR
,
4717 cxx_sizeof_nowarn (type
),
4719 /*placement=*/NULL_TREE
,
4720 /*alloc_fn=*/NULL_TREE
,
4722 /* Otherwise, treat this like a complete object destructor
4724 auto_delete
= sfk_complete_destructor
;
4726 /* If the destructor is non-virtual, there is no deleting
4727 variant. Instead, we must explicitly call the appropriate
4728 `operator delete' here. */
4729 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTOR (type
))
4730 && auto_delete
== sfk_deleting_destructor
)
4732 /* We will use ADDR multiple times so we must save it. */
4733 addr
= save_expr (addr
);
4734 /* Build the call. */
4735 do_delete
= build_op_delete_call (DELETE_EXPR
,
4737 cxx_sizeof_nowarn (type
),
4739 /*placement=*/NULL_TREE
,
4740 /*alloc_fn=*/NULL_TREE
,
4742 /* Call the complete object destructor. */
4743 auto_delete
= sfk_complete_destructor
;
4745 else if (auto_delete
== sfk_deleting_destructor
4746 && TYPE_GETS_REG_DELETE (type
))
4748 /* Make sure we have access to the member op delete, even though
4749 we'll actually be calling it from the destructor. */
4750 build_op_delete_call (DELETE_EXPR
, addr
, cxx_sizeof_nowarn (type
),
4752 /*placement=*/NULL_TREE
,
4753 /*alloc_fn=*/NULL_TREE
,
4757 expr
= build_dtor_call (cp_build_fold_indirect_ref (addr
),
4758 auto_delete
, flags
, complain
);
4759 if (expr
== error_mark_node
)
4760 return error_mark_node
;
4762 /* The delete operator must be called, regardless of whether
4763 the destructor throws.
4765 [expr.delete]/7 The deallocation function is called
4766 regardless of whether the destructor for the object or some
4767 element of the array throws an exception. */
4768 expr
= build2 (TRY_FINALLY_EXPR
, void_type_node
, expr
, do_delete
);
4770 /* We need to calculate this before the dtor changes the vptr. */
4772 expr
= build2 (COMPOUND_EXPR
, void_type_node
, head
, expr
);
4774 if (flags
& LOOKUP_DESTRUCTOR
)
4775 /* Explicit destructor call; don't check for null pointer. */
4776 ifexp
= integer_one_node
;
4779 /* Handle deleting a null pointer. */
4780 warning_sentinel
s (warn_address
);
4781 ifexp
= cp_build_binary_op (input_location
, NE_EXPR
, addr
,
4782 nullptr_node
, complain
);
4783 if (ifexp
== error_mark_node
)
4784 return error_mark_node
;
4785 /* This is a compiler generated comparison, don't emit
4786 e.g. -Wnonnull-compare warning for it. */
4787 else if (TREE_CODE (ifexp
) == NE_EXPR
)
4788 TREE_NO_WARNING (ifexp
) = 1;
4791 if (ifexp
!= integer_one_node
)
4792 expr
= build3 (COND_EXPR
, void_type_node
, ifexp
, expr
, void_node
);
4798 /* At the beginning of a destructor, push cleanups that will call the
4799 destructors for our base classes and members.
4801 Called from begin_destructor_body. */
4804 push_base_cleanups (void)
4806 tree binfo
, base_binfo
;
4810 vec
<tree
, va_gc
> *vbases
;
4812 /* Run destructors for all virtual baseclasses. */
4813 if (!ABSTRACT_CLASS_TYPE_P (current_class_type
)
4814 && CLASSTYPE_VBASECLASSES (current_class_type
))
4816 tree cond
= (condition_conversion
4817 (build2 (BIT_AND_EXPR
, integer_type_node
,
4818 current_in_charge_parm
,
4819 integer_two_node
)));
4821 /* The CLASSTYPE_VBASECLASSES vector is in initialization
4822 order, which is also the right order for pushing cleanups. */
4823 for (vbases
= CLASSTYPE_VBASECLASSES (current_class_type
), i
= 0;
4824 vec_safe_iterate (vbases
, i
, &base_binfo
); i
++)
4826 if (type_build_dtor_call (BINFO_TYPE (base_binfo
)))
4828 expr
= build_special_member_call (current_class_ref
,
4829 base_dtor_identifier
,
4833 | LOOKUP_NONVIRTUAL
),
4834 tf_warning_or_error
);
4835 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
4837 expr
= build3 (COND_EXPR
, void_type_node
, cond
,
4839 finish_decl_cleanup (NULL_TREE
, expr
);
4845 /* Take care of the remaining baseclasses. */
4846 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
4847 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
4849 if (BINFO_VIRTUAL_P (base_binfo
)
4850 || !type_build_dtor_call (BINFO_TYPE (base_binfo
)))
4853 expr
= build_special_member_call (current_class_ref
,
4854 base_dtor_identifier
,
4856 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
4857 tf_warning_or_error
);
4858 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
4859 finish_decl_cleanup (NULL_TREE
, expr
);
4862 /* Don't automatically destroy union members. */
4863 if (TREE_CODE (current_class_type
) == UNION_TYPE
)
4866 for (member
= TYPE_FIELDS (current_class_type
); member
;
4867 member
= DECL_CHAIN (member
))
4869 tree this_type
= TREE_TYPE (member
);
4870 if (this_type
== error_mark_node
4871 || TREE_CODE (member
) != FIELD_DECL
4872 || DECL_ARTIFICIAL (member
))
4874 if (ANON_AGGR_TYPE_P (this_type
))
4876 if (type_build_dtor_call (this_type
))
4878 tree this_member
= (build_class_member_access_expr
4879 (current_class_ref
, member
,
4880 /*access_path=*/NULL_TREE
,
4881 /*preserve_reference=*/false,
4882 tf_warning_or_error
));
4883 expr
= build_delete (this_type
, this_member
,
4884 sfk_complete_destructor
,
4885 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
,
4886 0, tf_warning_or_error
);
4887 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (this_type
))
4888 finish_decl_cleanup (NULL_TREE
, expr
);
4893 /* Build a C++ vector delete expression.
4894 MAXINDEX is the number of elements to be deleted.
4895 ELT_SIZE is the nominal size of each element in the vector.
4896 BASE is the expression that should yield the store to be deleted.
4897 This function expands (or synthesizes) these calls itself.
4898 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
4900 This also calls delete for virtual baseclasses of elements of the vector.
4902 Update: MAXINDEX is no longer needed. The size can be extracted from the
4903 start of the vector for pointers, and from the type for arrays. We still
4904 use MAXINDEX for arrays because it happens to already have one of the
4905 values we'd have to extract. (We could use MAXINDEX with pointers to
4906 confirm the size, and trap if the numbers differ; not clear that it'd
4907 be worth bothering.) */
4910 build_vec_delete (tree base
, tree maxindex
,
4911 special_function_kind auto_delete_vec
,
4912 int use_global_delete
, tsubst_flags_t complain
)
4916 tree base_init
= NULL_TREE
;
4918 type
= TREE_TYPE (base
);
4920 if (TYPE_PTR_P (type
))
4922 /* Step back one from start of vector, and read dimension. */
4924 tree size_ptr_type
= build_pointer_type (sizetype
);
4926 base
= mark_rvalue_use (base
);
4927 if (TREE_SIDE_EFFECTS (base
))
4929 base_init
= get_target_expr (base
);
4930 base
= TARGET_EXPR_SLOT (base_init
);
4932 type
= strip_array_types (TREE_TYPE (type
));
4933 cookie_addr
= fold_build1_loc (input_location
, NEGATE_EXPR
,
4934 sizetype
, TYPE_SIZE_UNIT (sizetype
));
4935 cookie_addr
= fold_build_pointer_plus (fold_convert (size_ptr_type
, base
),
4937 maxindex
= cp_build_fold_indirect_ref (cookie_addr
);
4939 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4941 /* Get the total number of things in the array, maxindex is a
4943 maxindex
= array_type_nelts_total (type
);
4944 type
= strip_array_types (type
);
4945 base
= decay_conversion (base
, complain
);
4946 if (base
== error_mark_node
)
4947 return error_mark_node
;
4948 if (TREE_SIDE_EFFECTS (base
))
4950 base_init
= get_target_expr (base
);
4951 base
= TARGET_EXPR_SLOT (base_init
);
4956 if (base
!= error_mark_node
&& !(complain
& tf_error
))
4957 error ("type to vector delete is neither pointer or array type");
4958 return error_mark_node
;
4961 rval
= build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
,
4962 use_global_delete
, complain
);
4963 if (base_init
&& rval
!= error_mark_node
)
4964 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), base_init
, rval
);
4969 #include "gt-cp-init.h"