1 /* Handle initialization things in C++.
2 Copyright (C) 1987-2017 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
);
287 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
289 /* In all cases, the initializer is a constant. */
291 TREE_CONSTANT (init
) = 1;
296 /* Return an expression for the zero-initialization of an object with
297 type T. This expression will either be a constant (in the case
298 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
299 aggregate), or NULL (in the case that T does not require
300 initialization). In either case, the value can be used as
301 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
302 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
303 is the number of elements in the array. If STATIC_STORAGE_P is
304 TRUE, initializers are only generated for entities for which
305 zero-initialization does not simply mean filling the storage with
309 build_zero_init (tree type
, tree nelts
, bool static_storage_p
)
311 return build_zero_init_1 (type
, nelts
, static_storage_p
, NULL_TREE
);
314 /* Return a suitable initializer for value-initializing an object of type
315 TYPE, as described in [dcl.init]. */
318 build_value_init (tree type
, tsubst_flags_t complain
)
322 To value-initialize an object of type T means:
324 - if T is a class type (clause 9) with either no default constructor
325 (12.1) or a default constructor that is user-provided or deleted,
326 then the object is default-initialized;
328 - if T is a (possibly cv-qualified) class type without a user-provided
329 or deleted default constructor, then the object is zero-initialized
330 and the semantic constraints for default-initialization are checked,
331 and if T has a non-trivial default constructor, the object is
334 - if T is an array type, then each element is value-initialized;
336 - otherwise, the object is zero-initialized.
338 A program that calls for default-initialization or
339 value-initialization of an entity of reference type is ill-formed. */
341 /* The AGGR_INIT_EXPR tweaking below breaks in templates. */
342 gcc_assert (!processing_template_decl
343 || (SCALAR_TYPE_P (type
) || TREE_CODE (type
) == ARRAY_TYPE
));
345 if (CLASS_TYPE_P (type
)
346 && type_build_ctor_call (type
))
349 build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
350 NULL
, type
, LOOKUP_NORMAL
,
352 if (ctor
== error_mark_node
)
355 if (TREE_CODE (ctor
) == CALL_EXPR
)
356 fn
= get_callee_fndecl (ctor
);
357 ctor
= build_aggr_init_expr (type
, ctor
);
358 if (fn
&& user_provided_p (fn
))
360 else if (TYPE_HAS_COMPLEX_DFLT (type
))
362 /* This is a class that needs constructing, but doesn't have
363 a user-provided constructor. So we need to zero-initialize
364 the object and then call the implicitly defined ctor.
365 This will be handled in simplify_aggr_init_expr. */
366 AGGR_INIT_ZERO_FIRST (ctor
) = 1;
371 /* Discard any access checking during subobject initialization;
372 the checks are implied by the call to the ctor which we have
373 verified is OK (cpp0x/defaulted46.C). */
374 push_deferring_access_checks (dk_deferred
);
375 tree r
= build_value_init_noctor (type
, complain
);
376 pop_deferring_access_checks ();
380 /* Like build_value_init, but don't call the constructor for TYPE. Used
381 for base initializers. */
384 build_value_init_noctor (tree type
, tsubst_flags_t complain
)
386 if (!COMPLETE_TYPE_P (type
))
388 if (complain
& tf_error
)
389 error ("value-initialization of incomplete type %qT", type
);
390 return error_mark_node
;
392 /* FIXME the class and array cases should just use digest_init once it is
394 if (CLASS_TYPE_P (type
))
396 gcc_assert (!TYPE_HAS_COMPLEX_DFLT (type
)
399 if (TREE_CODE (type
) != UNION_TYPE
)
402 vec
<constructor_elt
, va_gc
> *v
= NULL
;
404 /* Iterate over the fields, building initializations. */
405 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
409 if (TREE_CODE (field
) != FIELD_DECL
)
412 ftype
= TREE_TYPE (field
);
414 if (ftype
== error_mark_node
)
417 /* We could skip vfields and fields of types with
418 user-defined constructors, but I think that won't improve
419 performance at all; it should be simpler in general just
420 to zero out the entire object than try to only zero the
421 bits that actually need it. */
423 /* Note that for class types there will be FIELD_DECLs
424 corresponding to base classes as well. Thus, iterating
425 over TYPE_FIELDs will result in correct initialization of
426 all of the subobjects. */
427 value
= build_value_init (ftype
, complain
);
428 value
= maybe_constant_init (value
);
430 if (value
== error_mark_node
)
431 return error_mark_node
;
433 CONSTRUCTOR_APPEND_ELT(v
, field
, value
);
435 /* We shouldn't have gotten here for anything that would need
436 non-trivial initialization, and gimplify_init_ctor_preeval
437 would need to be fixed to allow it. */
438 gcc_assert (TREE_CODE (value
) != TARGET_EXPR
439 && TREE_CODE (value
) != AGGR_INIT_EXPR
);
442 /* Build a constructor to contain the zero- initializations. */
443 return build_constructor (type
, v
);
446 else if (TREE_CODE (type
) == ARRAY_TYPE
)
448 vec
<constructor_elt
, va_gc
> *v
= NULL
;
450 /* Iterate over the array elements, building initializations. */
451 tree max_index
= array_type_nelts (type
);
453 /* If we have an error_mark here, we should just return error mark
454 as we don't know the size of the array yet. */
455 if (max_index
== error_mark_node
)
457 if (complain
& tf_error
)
458 error ("cannot value-initialize array of unknown bound %qT",
460 return error_mark_node
;
462 gcc_assert (TREE_CODE (max_index
) == INTEGER_CST
);
464 /* A zero-sized array, which is accepted as an extension, will
465 have an upper bound of -1. */
466 if (!tree_int_cst_equal (max_index
, integer_minus_one_node
))
470 /* If this is a one element array, we just use a regular init. */
471 if (tree_int_cst_equal (size_zero_node
, max_index
))
472 ce
.index
= size_zero_node
;
474 ce
.index
= build2 (RANGE_EXPR
, sizetype
, size_zero_node
, max_index
);
476 ce
.value
= build_value_init (TREE_TYPE (type
), complain
);
477 ce
.value
= maybe_constant_init (ce
.value
);
478 if (ce
.value
== error_mark_node
)
479 return error_mark_node
;
484 /* We shouldn't have gotten here for anything that would need
485 non-trivial initialization, and gimplify_init_ctor_preeval
486 would need to be fixed to allow it. */
487 gcc_assert (TREE_CODE (ce
.value
) != TARGET_EXPR
488 && TREE_CODE (ce
.value
) != AGGR_INIT_EXPR
);
491 /* Build a constructor to contain the initializations. */
492 return build_constructor (type
, v
);
494 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
496 if (complain
& tf_error
)
497 error ("value-initialization of function type %qT", type
);
498 return error_mark_node
;
500 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
502 if (complain
& tf_error
)
503 error ("value-initialization of reference type %qT", type
);
504 return error_mark_node
;
507 return build_zero_init (type
, NULL_TREE
, /*static_storage_p=*/false);
510 /* Initialize current class with INIT, a TREE_LIST of
511 arguments for a target constructor. If TREE_LIST is void_type_node,
512 an empty initializer list was given. */
515 perform_target_ctor (tree init
)
517 tree decl
= current_class_ref
;
518 tree type
= current_class_type
;
520 finish_expr_stmt (build_aggr_init (decl
, init
,
521 LOOKUP_NORMAL
|LOOKUP_DELEGATING_CONS
,
522 tf_warning_or_error
));
523 if (type_build_dtor_call (type
))
525 tree expr
= build_delete (type
, decl
, sfk_complete_destructor
,
529 0, tf_warning_or_error
);
530 if (expr
!= error_mark_node
531 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
532 finish_eh_cleanup (expr
);
536 /* Return the non-static data initializer for FIELD_DECL MEMBER. */
538 static GTY((cache
)) tree_cache_map
*nsdmi_inst
;
541 get_nsdmi (tree member
, bool in_ctor
, tsubst_flags_t complain
)
544 tree save_ccp
= current_class_ptr
;
545 tree save_ccr
= current_class_ref
;
547 if (DECL_LANG_SPECIFIC (member
) && DECL_TEMPLATE_INFO (member
))
549 init
= DECL_INITIAL (DECL_TI_TEMPLATE (member
));
551 = EXPR_LOC_OR_LOC (init
, DECL_SOURCE_LOCATION (member
));
553 if (TREE_CODE (init
) == DEFAULT_ARG
)
555 else if (nsdmi_inst
&& (slot
= nsdmi_inst
->get (member
)))
557 /* Check recursive instantiation. */
558 else if (DECL_INSTANTIATING_NSDMI_P (member
))
560 if (complain
& tf_error
)
561 error_at (expr_loc
, "recursive instantiation of default member "
562 "initializer for %qD", member
);
563 init
= error_mark_node
;
567 int un
= cp_unevaluated_operand
;
568 cp_unevaluated_operand
= 0;
570 location_t sloc
= input_location
;
571 input_location
= expr_loc
;
573 DECL_INSTANTIATING_NSDMI_P (member
) = 1;
575 inject_this_parameter (DECL_CONTEXT (member
), TYPE_UNQUALIFIED
);
577 start_lambda_scope (member
);
579 /* Do deferred instantiation of the NSDMI. */
580 init
= (tsubst_copy_and_build
581 (init
, DECL_TI_ARGS (member
),
582 complain
, member
, /*function_p=*/false,
583 /*integral_constant_expression_p=*/false));
584 init
= digest_nsdmi_init (member
, init
, complain
);
586 finish_lambda_scope ();
588 DECL_INSTANTIATING_NSDMI_P (member
) = 0;
590 if (init
!= error_mark_node
)
593 nsdmi_inst
= tree_cache_map::create_ggc (37);
594 nsdmi_inst
->put (member
, init
);
597 input_location
= sloc
;
598 cp_unevaluated_operand
= un
;
602 init
= DECL_INITIAL (member
);
604 if (init
&& TREE_CODE (init
) == DEFAULT_ARG
)
606 if (complain
& tf_error
)
608 error ("default member initializer for %qD required before the end "
609 "of its enclosing class", member
);
610 inform (location_of (init
), "defined here");
611 DECL_INITIAL (member
) = error_mark_node
;
613 init
= error_mark_node
;
618 current_class_ptr
= save_ccp
;
619 current_class_ref
= save_ccr
;
623 /* Use a PLACEHOLDER_EXPR when we don't have a 'this' parameter to
624 refer to; constexpr evaluation knows what to do with it. */
625 current_class_ref
= build0 (PLACEHOLDER_EXPR
, DECL_CONTEXT (member
));
626 current_class_ptr
= build_address (current_class_ref
);
629 /* Strip redundant TARGET_EXPR so we don't need to remap it, and
630 so the aggregate init code below will see a CONSTRUCTOR. */
631 bool simple_target
= (init
&& SIMPLE_TARGET_EXPR_P (init
));
633 init
= TARGET_EXPR_INITIAL (init
);
634 init
= break_out_target_exprs (init
);
635 if (simple_target
&& TREE_CODE (init
) != CONSTRUCTOR
)
636 /* Now put it back so C++17 copy elision works. */
637 init
= get_target_expr (init
);
639 current_class_ptr
= save_ccp
;
640 current_class_ref
= save_ccr
;
644 /* Diagnose the flexible array MEMBER if its INITializer is non-null
645 and return true if so. Otherwise return false. */
648 maybe_reject_flexarray_init (tree member
, tree init
)
650 tree type
= TREE_TYPE (member
);
653 || TREE_CODE (type
) != ARRAY_TYPE
654 || TYPE_DOMAIN (type
))
657 /* Point at the flexible array member declaration if it's initialized
658 in-class, and at the ctor if it's initialized in a ctor member
661 if (DECL_INITIAL (member
) == init
662 || !current_function_decl
663 || DECL_DEFAULTED_FN (current_function_decl
))
664 loc
= DECL_SOURCE_LOCATION (member
);
666 loc
= DECL_SOURCE_LOCATION (current_function_decl
);
668 error_at (loc
, "initializer for flexible array member %q#D", member
);
672 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
673 arguments. If TREE_LIST is void_type_node, an empty initializer
674 list was given; if NULL_TREE no initializer was given. */
677 perform_member_init (tree member
, tree init
)
680 tree type
= TREE_TYPE (member
);
682 /* Use the non-static data member initializer if there was no
683 mem-initializer for this field. */
684 if (init
== NULL_TREE
)
685 init
= get_nsdmi (member
, /*ctor*/true, tf_warning_or_error
);
687 if (init
== error_mark_node
)
690 /* Effective C++ rule 12 requires that all data members be
692 if (warn_ecpp
&& init
== NULL_TREE
&& TREE_CODE (type
) != ARRAY_TYPE
)
693 warning_at (DECL_SOURCE_LOCATION (current_function_decl
), OPT_Weffc__
,
694 "%qD should be initialized in the member initialization list",
697 /* Get an lvalue for the data member. */
698 decl
= build_class_member_access_expr (current_class_ref
, member
,
699 /*access_path=*/NULL_TREE
,
700 /*preserve_reference=*/true,
701 tf_warning_or_error
);
702 if (decl
== error_mark_node
)
705 if (warn_init_self
&& init
&& TREE_CODE (init
) == TREE_LIST
706 && TREE_CHAIN (init
) == NULL_TREE
)
708 tree val
= TREE_VALUE (init
);
709 /* Handle references. */
710 if (REFERENCE_REF_P (val
))
711 val
= TREE_OPERAND (val
, 0);
712 if (TREE_CODE (val
) == COMPONENT_REF
&& TREE_OPERAND (val
, 1) == member
713 && TREE_OPERAND (val
, 0) == current_class_ref
)
714 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
715 OPT_Winit_self
, "%qD is initialized with itself",
719 if (init
== void_type_node
)
721 /* mem() means value-initialization. */
722 if (TREE_CODE (type
) == ARRAY_TYPE
)
724 init
= build_vec_init_expr (type
, init
, tf_warning_or_error
);
725 init
= build2 (INIT_EXPR
, type
, decl
, init
);
726 finish_expr_stmt (init
);
730 tree value
= build_value_init (type
, tf_warning_or_error
);
731 if (value
== error_mark_node
)
733 init
= build2 (INIT_EXPR
, type
, decl
, value
);
734 finish_expr_stmt (init
);
737 /* Deal with this here, as we will get confused if we try to call the
738 assignment op for an anonymous union. This can happen in a
739 synthesized copy constructor. */
740 else if (ANON_AGGR_TYPE_P (type
))
744 init
= build2 (INIT_EXPR
, type
, decl
, TREE_VALUE (init
));
745 finish_expr_stmt (init
);
749 && (TREE_CODE (type
) == REFERENCE_TYPE
750 /* Pre-digested NSDMI. */
751 || (((TREE_CODE (init
) == CONSTRUCTOR
752 && TREE_TYPE (init
) == type
)
753 /* { } mem-initializer. */
754 || (TREE_CODE (init
) == TREE_LIST
755 && DIRECT_LIST_INIT_P (TREE_VALUE (init
))))
756 && (CP_AGGREGATE_TYPE_P (type
)
757 || is_std_init_list (type
)))))
759 /* With references and list-initialization, we need to deal with
760 extending temporary lifetimes. 12.2p5: "A temporary bound to a
761 reference member in a constructor’s ctor-initializer (12.6.2)
762 persists until the constructor exits." */
764 vec
<tree
, va_gc
> *cleanups
= make_tree_vector ();
765 if (TREE_CODE (init
) == TREE_LIST
)
766 init
= build_x_compound_expr_from_list (init
, ELK_MEM_INIT
,
767 tf_warning_or_error
);
768 if (TREE_TYPE (init
) != type
)
770 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
771 && CP_AGGREGATE_TYPE_P (type
))
772 init
= reshape_init (type
, init
, tf_warning_or_error
);
773 init
= digest_init (type
, init
, tf_warning_or_error
);
775 if (init
== error_mark_node
)
777 /* A FIELD_DECL doesn't really have a suitable lifetime, but
778 make_temporary_var_for_ref_to_temp will treat it as automatic and
779 set_up_extended_ref_temp wants to use the decl in a warning. */
780 init
= extend_ref_init_temps (member
, init
, &cleanups
);
781 if (TREE_CODE (type
) == ARRAY_TYPE
782 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (type
)))
783 init
= build_vec_init_expr (type
, init
, tf_warning_or_error
);
784 init
= build2 (INIT_EXPR
, type
, decl
, init
);
785 finish_expr_stmt (init
);
786 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
787 push_cleanup (decl
, t
, false);
788 release_tree_vector (cleanups
);
790 else if (type_build_ctor_call (type
)
791 || (init
&& CLASS_TYPE_P (strip_array_types (type
))))
793 if (TREE_CODE (type
) == ARRAY_TYPE
)
797 /* Check to make sure the member initializer is valid and
798 something like a CONSTRUCTOR in: T a[] = { 1, 2 } and
799 if it isn't, return early to avoid triggering another
801 if (maybe_reject_flexarray_init (member
, init
))
804 if (TREE_CODE (init
) != TREE_LIST
|| TREE_CHAIN (init
))
805 init
= error_mark_node
;
807 init
= TREE_VALUE (init
);
809 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
810 init
= digest_init (type
, init
, tf_warning_or_error
);
812 if (init
== NULL_TREE
813 || same_type_ignoring_top_level_qualifiers_p (type
,
816 if (TYPE_DOMAIN (type
) && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
818 /* Initialize the array only if it's not a flexible
819 array member (i.e., if it has an upper bound). */
820 init
= build_vec_init_expr (type
, init
, tf_warning_or_error
);
821 init
= build2 (INIT_EXPR
, type
, decl
, init
);
822 finish_expr_stmt (init
);
826 error ("invalid initializer for array member %q#D", member
);
830 int flags
= LOOKUP_NORMAL
;
831 if (DECL_DEFAULTED_FN (current_function_decl
))
832 flags
|= LOOKUP_DEFAULTED
;
833 if (CP_TYPE_CONST_P (type
)
835 && default_init_uninitialized_part (type
))
837 /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
838 vtable; still give this diagnostic. */
839 if (permerror (DECL_SOURCE_LOCATION (current_function_decl
),
840 "uninitialized const member in %q#T", type
))
841 inform (DECL_SOURCE_LOCATION (member
),
842 "%q#D should be initialized", member
);
844 finish_expr_stmt (build_aggr_init (decl
, init
, flags
,
845 tf_warning_or_error
));
850 if (init
== NULL_TREE
)
853 /* member traversal: note it leaves init NULL */
854 if (TREE_CODE (type
) == REFERENCE_TYPE
)
856 if (permerror (DECL_SOURCE_LOCATION (current_function_decl
),
857 "uninitialized reference member in %q#T", type
))
858 inform (DECL_SOURCE_LOCATION (member
),
859 "%q#D should be initialized", member
);
861 else if (CP_TYPE_CONST_P (type
))
863 if (permerror (DECL_SOURCE_LOCATION (current_function_decl
),
864 "uninitialized const member in %q#T", type
))
865 inform (DECL_SOURCE_LOCATION (member
),
866 "%q#D should be initialized", member
);
869 core_type
= strip_array_types (type
);
871 if (CLASS_TYPE_P (core_type
)
872 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
873 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
874 diagnose_uninitialized_cst_or_ref_member (core_type
,
878 else if (TREE_CODE (init
) == TREE_LIST
)
879 /* There was an explicit member initialization. Do some work
881 init
= build_x_compound_expr_from_list (init
, ELK_MEM_INIT
,
882 tf_warning_or_error
);
884 /* Reject a member initializer for a flexible array member. */
885 if (init
&& !maybe_reject_flexarray_init (member
, init
))
886 finish_expr_stmt (cp_build_modify_expr (input_location
, decl
,
888 tf_warning_or_error
));
891 if (type_build_dtor_call (type
))
895 expr
= build_class_member_access_expr (current_class_ref
, member
,
896 /*access_path=*/NULL_TREE
,
897 /*preserve_reference=*/false,
898 tf_warning_or_error
);
899 expr
= build_delete (type
, expr
, sfk_complete_destructor
,
900 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0,
901 tf_warning_or_error
);
903 if (expr
!= error_mark_node
904 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
905 finish_eh_cleanup (expr
);
909 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
910 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
913 build_field_list (tree t
, tree list
, int *uses_unions_or_anon_p
)
917 /* Note whether or not T is a union. */
918 if (TREE_CODE (t
) == UNION_TYPE
)
919 *uses_unions_or_anon_p
= 1;
921 for (fields
= TYPE_FIELDS (t
); fields
; fields
= DECL_CHAIN (fields
))
925 /* Skip CONST_DECLs for enumeration constants and so forth. */
926 if (TREE_CODE (fields
) != FIELD_DECL
|| DECL_ARTIFICIAL (fields
))
929 fieldtype
= TREE_TYPE (fields
);
931 /* For an anonymous struct or union, we must recursively
932 consider the fields of the anonymous type. They can be
933 directly initialized from the constructor. */
934 if (ANON_AGGR_TYPE_P (fieldtype
))
936 /* Add this field itself. Synthesized copy constructors
937 initialize the entire aggregate. */
938 list
= tree_cons (fields
, NULL_TREE
, list
);
939 /* And now add the fields in the anonymous aggregate. */
940 list
= build_field_list (fieldtype
, list
, uses_unions_or_anon_p
);
941 *uses_unions_or_anon_p
= 1;
943 /* Add this field. */
944 else if (DECL_NAME (fields
))
945 list
= tree_cons (fields
, NULL_TREE
, list
);
951 /* Return the innermost aggregate scope for FIELD, whether that is
952 the enclosing class or an anonymous aggregate within it. */
955 innermost_aggr_scope (tree field
)
957 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
958 return TREE_TYPE (field
);
960 return DECL_CONTEXT (field
);
963 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
964 a FIELD_DECL or BINFO in T that needs initialization. The
965 TREE_VALUE gives the initializer, or list of initializer arguments.
967 Return a TREE_LIST containing all of the initializations required
968 for T, in the order in which they should be performed. The output
969 list has the same format as the input. */
972 sort_mem_initializers (tree t
, tree mem_inits
)
975 tree base
, binfo
, base_binfo
;
978 vec
<tree
, va_gc
> *vbases
;
980 int uses_unions_or_anon_p
= 0;
982 /* Build up a list of initializations. The TREE_PURPOSE of entry
983 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
984 TREE_VALUE will be the constructor arguments, or NULL if no
985 explicit initialization was provided. */
986 sorted_inits
= NULL_TREE
;
988 /* Process the virtual bases. */
989 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
990 vec_safe_iterate (vbases
, i
, &base
); i
++)
991 sorted_inits
= tree_cons (base
, NULL_TREE
, sorted_inits
);
993 /* Process the direct bases. */
994 for (binfo
= TYPE_BINFO (t
), i
= 0;
995 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
996 if (!BINFO_VIRTUAL_P (base_binfo
))
997 sorted_inits
= tree_cons (base_binfo
, NULL_TREE
, sorted_inits
);
999 /* Process the non-static data members. */
1000 sorted_inits
= build_field_list (t
, sorted_inits
, &uses_unions_or_anon_p
);
1001 /* Reverse the entire list of initializations, so that they are in
1002 the order that they will actually be performed. */
1003 sorted_inits
= nreverse (sorted_inits
);
1005 /* If the user presented the initializers in an order different from
1006 that in which they will actually occur, we issue a warning. Keep
1007 track of the next subobject which can be explicitly initialized
1008 without issuing a warning. */
1009 next_subobject
= sorted_inits
;
1011 /* Go through the explicit initializers, filling in TREE_PURPOSE in
1012 the SORTED_INITS. */
1013 for (init
= mem_inits
; init
; init
= TREE_CHAIN (init
))
1016 tree subobject_init
;
1018 subobject
= TREE_PURPOSE (init
);
1020 /* If the explicit initializers are in sorted order, then
1021 SUBOBJECT will be NEXT_SUBOBJECT, or something following
1023 for (subobject_init
= next_subobject
;
1025 subobject_init
= TREE_CHAIN (subobject_init
))
1026 if (TREE_PURPOSE (subobject_init
) == subobject
)
1029 /* Issue a warning if the explicit initializer order does not
1030 match that which will actually occur.
1031 ??? Are all these on the correct lines? */
1032 if (warn_reorder
&& !subobject_init
)
1034 if (TREE_CODE (TREE_PURPOSE (next_subobject
)) == FIELD_DECL
)
1035 warning_at (DECL_SOURCE_LOCATION (TREE_PURPOSE (next_subobject
)),
1036 OPT_Wreorder
, "%qD will be initialized after",
1037 TREE_PURPOSE (next_subobject
));
1039 warning (OPT_Wreorder
, "base %qT will be initialized after",
1040 TREE_PURPOSE (next_subobject
));
1041 if (TREE_CODE (subobject
) == FIELD_DECL
)
1042 warning_at (DECL_SOURCE_LOCATION (subobject
),
1043 OPT_Wreorder
, " %q#D", subobject
);
1045 warning (OPT_Wreorder
, " base %qT", subobject
);
1046 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
1047 OPT_Wreorder
, " when initialized here");
1050 /* Look again, from the beginning of the list. */
1051 if (!subobject_init
)
1053 subobject_init
= sorted_inits
;
1054 while (TREE_PURPOSE (subobject_init
) != subobject
)
1055 subobject_init
= TREE_CHAIN (subobject_init
);
1058 /* It is invalid to initialize the same subobject more than
1060 if (TREE_VALUE (subobject_init
))
1062 if (TREE_CODE (subobject
) == FIELD_DECL
)
1063 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1064 "multiple initializations given for %qD",
1067 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1068 "multiple initializations given for base %qT",
1072 /* Record the initialization. */
1073 TREE_VALUE (subobject_init
) = TREE_VALUE (init
);
1074 next_subobject
= subobject_init
;
1077 /* [class.base.init]
1079 If a ctor-initializer specifies more than one mem-initializer for
1080 multiple members of the same union (including members of
1081 anonymous unions), the ctor-initializer is ill-formed.
1083 Here we also splice out uninitialized union members. */
1084 if (uses_unions_or_anon_p
)
1086 tree
*last_p
= NULL
;
1088 for (p
= &sorted_inits
; *p
; )
1095 field
= TREE_PURPOSE (init
);
1097 /* Skip base classes. */
1098 if (TREE_CODE (field
) != FIELD_DECL
)
1101 /* If this is an anonymous aggregate with no explicit initializer,
1103 if (!TREE_VALUE (init
) && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
1106 /* See if this field is a member of a union, or a member of a
1107 structure contained in a union, etc. */
1108 ctx
= innermost_aggr_scope (field
);
1110 /* If this field is not a member of a union, skip it. */
1111 if (TREE_CODE (ctx
) != UNION_TYPE
1112 && !ANON_AGGR_TYPE_P (ctx
))
1115 /* If this union member has no explicit initializer and no NSDMI,
1117 if (TREE_VALUE (init
) || DECL_INITIAL (field
))
1122 /* It's only an error if we have two initializers for the same
1130 /* See if LAST_FIELD and the field initialized by INIT are
1131 members of the same union (or the union itself). If so, there's
1132 a problem, unless they're actually members of the same structure
1133 which is itself a member of a union. For example, given:
1135 union { struct { int i; int j; }; };
1137 initializing both `i' and `j' makes sense. */
1138 ctx
= common_enclosing_class
1139 (innermost_aggr_scope (field
),
1140 innermost_aggr_scope (TREE_PURPOSE (*last_p
)));
1142 if (ctx
&& (TREE_CODE (ctx
) == UNION_TYPE
1143 || ctx
== TREE_TYPE (TREE_PURPOSE (*last_p
))))
1145 /* A mem-initializer hides an NSDMI. */
1146 if (TREE_VALUE (init
) && !TREE_VALUE (*last_p
))
1147 *last_p
= TREE_CHAIN (*last_p
);
1148 else if (TREE_VALUE (*last_p
) && !TREE_VALUE (init
))
1152 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1153 "initializations for multiple members of %qT",
1162 p
= &TREE_CHAIN (*p
);
1165 *p
= TREE_CHAIN (*p
);
1170 return sorted_inits
;
1173 /* Callback for cp_walk_tree to mark all PARM_DECLs in a tree as read. */
1176 mark_exp_read_r (tree
*tp
, int *, void *)
1179 if (TREE_CODE (t
) == PARM_DECL
)
1184 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
1185 is a TREE_LIST giving the explicit mem-initializer-list for the
1186 constructor. The TREE_PURPOSE of each entry is a subobject (a
1187 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
1188 is a TREE_LIST giving the arguments to the constructor or
1189 void_type_node for an empty list of arguments. */
1192 emit_mem_initializers (tree mem_inits
)
1194 int flags
= LOOKUP_NORMAL
;
1196 /* We will already have issued an error message about the fact that
1197 the type is incomplete. */
1198 if (!COMPLETE_TYPE_P (current_class_type
))
1202 && TYPE_P (TREE_PURPOSE (mem_inits
))
1203 && same_type_p (TREE_PURPOSE (mem_inits
), current_class_type
))
1205 /* Delegating constructor. */
1206 gcc_assert (TREE_CHAIN (mem_inits
) == NULL_TREE
);
1207 perform_target_ctor (TREE_VALUE (mem_inits
));
1211 if (DECL_DEFAULTED_FN (current_function_decl
)
1212 && ! DECL_INHERITED_CTOR (current_function_decl
))
1213 flags
|= LOOKUP_DEFAULTED
;
1215 /* Sort the mem-initializers into the order in which the
1216 initializations should be performed. */
1217 mem_inits
= sort_mem_initializers (current_class_type
, mem_inits
);
1219 in_base_initializer
= 1;
1221 /* Initialize base classes. */
1223 && TREE_CODE (TREE_PURPOSE (mem_inits
)) != FIELD_DECL
);
1224 mem_inits
= TREE_CHAIN (mem_inits
))
1226 tree subobject
= TREE_PURPOSE (mem_inits
);
1227 tree arguments
= TREE_VALUE (mem_inits
);
1229 /* We already have issued an error message. */
1230 if (arguments
== error_mark_node
)
1233 /* Suppress access control when calling the inherited ctor. */
1234 bool inherited_base
= (DECL_INHERITED_CTOR (current_function_decl
)
1235 && flag_new_inheriting_ctors
1238 push_deferring_access_checks (dk_deferred
);
1240 if (arguments
== NULL_TREE
)
1242 /* If these initializations are taking place in a copy constructor,
1243 the base class should probably be explicitly initialized if there
1244 is a user-defined constructor in the base class (other than the
1245 default constructor, which will be called anyway). */
1247 && DECL_COPY_CONSTRUCTOR_P (current_function_decl
)
1248 && type_has_user_nondefault_constructor (BINFO_TYPE (subobject
)))
1249 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
1250 OPT_Wextra
, "base class %q#T should be explicitly "
1251 "initialized in the copy constructor",
1252 BINFO_TYPE (subobject
));
1255 /* Initialize the base. */
1256 if (!BINFO_VIRTUAL_P (subobject
))
1260 base_addr
= build_base_path (PLUS_EXPR
, current_class_ptr
,
1261 subobject
, 1, tf_warning_or_error
);
1262 expand_aggr_init_1 (subobject
, NULL_TREE
,
1263 cp_build_fold_indirect_ref (base_addr
),
1266 tf_warning_or_error
);
1267 expand_cleanup_for_base (subobject
, NULL_TREE
);
1269 else if (!ABSTRACT_CLASS_TYPE_P (current_class_type
))
1270 /* C++14 DR1658 Means we do not have to construct vbases of
1271 abstract classes. */
1272 construct_virtual_base (subobject
, arguments
);
1274 /* When not constructing vbases of abstract classes, at least mark
1275 the arguments expressions as read to avoid
1276 -Wunused-but-set-parameter false positives. */
1277 cp_walk_tree (&arguments
, mark_exp_read_r
, NULL
, NULL
);
1280 pop_deferring_access_checks ();
1282 in_base_initializer
= 0;
1284 /* Initialize the vptrs. */
1285 initialize_vtbl_ptrs (current_class_ptr
);
1287 /* Initialize the data members. */
1290 perform_member_init (TREE_PURPOSE (mem_inits
),
1291 TREE_VALUE (mem_inits
));
1292 mem_inits
= TREE_CHAIN (mem_inits
);
1296 /* Returns the address of the vtable (i.e., the value that should be
1297 assigned to the vptr) for BINFO. */
1300 build_vtbl_address (tree binfo
)
1302 tree binfo_for
= binfo
;
1305 if (BINFO_VPTR_INDEX (binfo
) && BINFO_VIRTUAL_P (binfo
))
1306 /* If this is a virtual primary base, then the vtable we want to store
1307 is that for the base this is being used as the primary base of. We
1308 can't simply skip the initialization, because we may be expanding the
1309 inits of a subobject constructor where the virtual base layout
1310 can be different. */
1311 while (BINFO_PRIMARY_P (binfo_for
))
1312 binfo_for
= BINFO_INHERITANCE_CHAIN (binfo_for
);
1314 /* Figure out what vtable BINFO's vtable is based on, and mark it as
1316 vtbl
= get_vtbl_decl_for_binfo (binfo_for
);
1317 TREE_USED (vtbl
) = true;
1319 /* Now compute the address to use when initializing the vptr. */
1320 vtbl
= unshare_expr (BINFO_VTABLE (binfo_for
));
1322 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
1327 /* This code sets up the virtual function tables appropriate for
1328 the pointer DECL. It is a one-ply initialization.
1330 BINFO is the exact type that DECL is supposed to be. In
1331 multiple inheritance, this might mean "C's A" if C : A, B. */
1334 expand_virtual_init (tree binfo
, tree decl
)
1336 tree vtbl
, vtbl_ptr
;
1339 /* Compute the initializer for vptr. */
1340 vtbl
= build_vtbl_address (binfo
);
1342 /* We may get this vptr from a VTT, if this is a subobject
1343 constructor or subobject destructor. */
1344 vtt_index
= BINFO_VPTR_INDEX (binfo
);
1350 /* Compute the value to use, when there's a VTT. */
1351 vtt_parm
= current_vtt_parm
;
1352 vtbl2
= fold_build_pointer_plus (vtt_parm
, vtt_index
);
1353 vtbl2
= cp_build_fold_indirect_ref (vtbl2
);
1354 vtbl2
= convert (TREE_TYPE (vtbl
), vtbl2
);
1356 /* The actual initializer is the VTT value only in the subobject
1357 constructor. In maybe_clone_body we'll substitute NULL for
1358 the vtt_parm in the case of the non-subobject constructor. */
1359 vtbl
= build_if_in_charge (vtbl
, vtbl2
);
1362 /* Compute the location of the vtpr. */
1363 vtbl_ptr
= build_vfield_ref (cp_build_fold_indirect_ref (decl
),
1365 gcc_assert (vtbl_ptr
!= error_mark_node
);
1367 /* Assign the vtable to the vptr. */
1368 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0, tf_warning_or_error
);
1369 finish_expr_stmt (cp_build_modify_expr (input_location
, vtbl_ptr
, NOP_EXPR
,
1370 vtbl
, tf_warning_or_error
));
1373 /* If an exception is thrown in a constructor, those base classes already
1374 constructed must be destroyed. This function creates the cleanup
1375 for BINFO, which has just been constructed. If FLAG is non-NULL,
1376 it is a DECL which is nonzero when this base needs to be
1380 expand_cleanup_for_base (tree binfo
, tree flag
)
1384 if (!type_build_dtor_call (BINFO_TYPE (binfo
)))
1387 /* Call the destructor. */
1388 expr
= build_special_member_call (current_class_ref
,
1389 base_dtor_identifier
,
1392 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
1393 tf_warning_or_error
);
1395 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo
)))
1399 expr
= fold_build3_loc (input_location
,
1400 COND_EXPR
, void_type_node
,
1401 c_common_truthvalue_conversion (input_location
, flag
),
1402 expr
, integer_zero_node
);
1404 finish_eh_cleanup (expr
);
1407 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
1411 construct_virtual_base (tree vbase
, tree arguments
)
1417 /* If there are virtual base classes with destructors, we need to
1418 emit cleanups to destroy them if an exception is thrown during
1419 the construction process. These exception regions (i.e., the
1420 period during which the cleanups must occur) begin from the time
1421 the construction is complete to the end of the function. If we
1422 create a conditional block in which to initialize the
1423 base-classes, then the cleanup region for the virtual base begins
1424 inside a block, and ends outside of that block. This situation
1425 confuses the sjlj exception-handling code. Therefore, we do not
1426 create a single conditional block, but one for each
1427 initialization. (That way the cleanup regions always begin
1428 in the outer block.) We trust the back end to figure out
1429 that the FLAG will not change across initializations, and
1430 avoid doing multiple tests. */
1431 flag
= DECL_CHAIN (DECL_ARGUMENTS (current_function_decl
));
1432 inner_if_stmt
= begin_if_stmt ();
1433 finish_if_stmt_cond (flag
, inner_if_stmt
);
1435 /* Compute the location of the virtual base. If we're
1436 constructing virtual bases, then we must be the most derived
1437 class. Therefore, we don't have to look up the virtual base;
1438 we already know where it is. */
1439 exp
= convert_to_base_statically (current_class_ref
, vbase
);
1441 expand_aggr_init_1 (vbase
, current_class_ref
, exp
, arguments
,
1442 0, tf_warning_or_error
);
1443 finish_then_clause (inner_if_stmt
);
1444 finish_if_stmt (inner_if_stmt
);
1446 expand_cleanup_for_base (vbase
, flag
);
1449 /* Find the context in which this FIELD can be initialized. */
1452 initializing_context (tree field
)
1454 tree t
= DECL_CONTEXT (field
);
1456 /* Anonymous union members can be initialized in the first enclosing
1457 non-anonymous union context. */
1458 while (t
&& ANON_AGGR_TYPE_P (t
))
1459 t
= TYPE_CONTEXT (t
);
1463 /* Function to give error message if member initialization specification
1464 is erroneous. FIELD is the member we decided to initialize.
1465 TYPE is the type for which the initialization is being performed.
1466 FIELD must be a member of TYPE.
1468 MEMBER_NAME is the name of the member. */
1471 member_init_ok_or_else (tree field
, tree type
, tree member_name
)
1473 if (field
== error_mark_node
)
1477 error ("class %qT does not have any field named %qD", type
,
1483 error ("%q#D is a static data member; it can only be "
1484 "initialized at its definition",
1488 if (TREE_CODE (field
) != FIELD_DECL
)
1490 error ("%q#D is not a non-static data member of %qT",
1494 if (initializing_context (field
) != type
)
1496 error ("class %qT does not have any field named %qD", type
,
1504 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1505 is a _TYPE node or TYPE_DECL which names a base for that type.
1506 Check the validity of NAME, and return either the base _TYPE, base
1507 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
1508 NULL_TREE and issue a diagnostic.
1510 An old style unnamed direct single base construction is permitted,
1511 where NAME is NULL. */
1514 expand_member_init (tree name
)
1519 if (!current_class_ref
)
1524 /* This is an obsolete unnamed base class initializer. The
1525 parser will already have warned about its use. */
1526 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type
)))
1529 error ("unnamed initializer for %qT, which has no base classes",
1530 current_class_type
);
1533 basetype
= BINFO_TYPE
1534 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type
), 0));
1537 error ("unnamed initializer for %qT, which uses multiple inheritance",
1538 current_class_type
);
1542 else if (TYPE_P (name
))
1544 basetype
= TYPE_MAIN_VARIANT (name
);
1545 name
= TYPE_NAME (name
);
1547 else if (TREE_CODE (name
) == TYPE_DECL
)
1548 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (name
));
1550 basetype
= NULL_TREE
;
1559 if (current_template_parms
1560 || same_type_p (basetype
, current_class_type
))
1563 class_binfo
= TYPE_BINFO (current_class_type
);
1564 direct_binfo
= NULL_TREE
;
1565 virtual_binfo
= NULL_TREE
;
1567 /* Look for a direct base. */
1568 for (i
= 0; BINFO_BASE_ITERATE (class_binfo
, i
, direct_binfo
); ++i
)
1569 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo
), basetype
))
1572 /* Look for a virtual base -- unless the direct base is itself
1574 if (!direct_binfo
|| !BINFO_VIRTUAL_P (direct_binfo
))
1575 virtual_binfo
= binfo_for_vbase (basetype
, current_class_type
);
1577 /* [class.base.init]
1579 If a mem-initializer-id is ambiguous because it designates
1580 both a direct non-virtual base class and an inherited virtual
1581 base class, the mem-initializer is ill-formed. */
1582 if (direct_binfo
&& virtual_binfo
)
1584 error ("%qD is both a direct base and an indirect virtual base",
1589 if (!direct_binfo
&& !virtual_binfo
)
1591 if (CLASSTYPE_VBASECLASSES (current_class_type
))
1592 error ("type %qT is not a direct or virtual base of %qT",
1593 basetype
, current_class_type
);
1595 error ("type %qT is not a direct base of %qT",
1596 basetype
, current_class_type
);
1600 return direct_binfo
? direct_binfo
: virtual_binfo
;
1604 if (identifier_p (name
))
1605 field
= lookup_field (current_class_type
, name
, 1, false);
1609 if (member_init_ok_or_else (field
, current_class_type
, name
))
1616 /* This is like `expand_member_init', only it stores one aggregate
1619 INIT comes in two flavors: it is either a value which
1620 is to be stored in EXP, or it is a parameter list
1621 to go to a constructor, which will operate on EXP.
1622 If INIT is not a parameter list for a constructor, then set
1623 LOOKUP_ONLYCONVERTING.
1624 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1625 the initializer, if FLAGS is 0, then it is the (init) form.
1626 If `init' is a CONSTRUCTOR, then we emit a warning message,
1627 explaining that such initializations are invalid.
1629 If INIT resolves to a CALL_EXPR which happens to return
1630 something of the type we are looking for, then we know
1631 that we can safely use that call to perform the
1634 The virtual function table pointer cannot be set up here, because
1635 we do not really know its type.
1637 This never calls operator=().
1639 When initializing, nothing is CONST.
1641 A default copy constructor may have to be used to perform the
1644 A constructor or a conversion operator may have to be used to
1645 perform the initialization, but not both, as it would be ambiguous. */
1648 build_aggr_init (tree exp
, tree init
, int flags
, tsubst_flags_t complain
)
1653 tree type
= TREE_TYPE (exp
);
1654 int was_const
= TREE_READONLY (exp
);
1655 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1658 if (init
== error_mark_node
)
1659 return error_mark_node
;
1661 location_t init_loc
= (init
1662 ? EXPR_LOC_OR_LOC (init
, input_location
)
1663 : location_of (exp
));
1665 TREE_READONLY (exp
) = 0;
1666 TREE_THIS_VOLATILE (exp
) = 0;
1668 if (TREE_CODE (type
) == ARRAY_TYPE
)
1670 tree itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1673 if (VAR_P (exp
) && DECL_DECOMPOSITION_P (exp
))
1676 if (init
&& DECL_P (init
)
1677 && !(flags
& LOOKUP_ONLYCONVERTING
))
1679 /* Wrap the initializer in a CONSTRUCTOR so that build_vec_init
1680 recognizes it as direct-initialization. */
1681 init
= build_constructor_single (init_list_type_node
,
1683 CONSTRUCTOR_IS_DIRECT_INIT (init
) = true;
1688 /* An array may not be initialized use the parenthesized
1689 initialization form -- unless the initializer is "()". */
1690 if (init
&& TREE_CODE (init
) == TREE_LIST
)
1692 if (complain
& tf_error
)
1693 error ("bad array initializer");
1694 return error_mark_node
;
1696 /* Must arrange to initialize each element of EXP
1697 from elements of INIT. */
1698 if (cv_qualified_p (type
))
1699 TREE_TYPE (exp
) = cv_unqualified (type
);
1700 if (itype
&& cv_qualified_p (itype
))
1701 TREE_TYPE (init
) = cv_unqualified (itype
);
1702 from_array
= (itype
&& same_type_p (TREE_TYPE (init
),
1705 if (init
&& !from_array
1706 && !BRACE_ENCLOSED_INITIALIZER_P (init
))
1708 if (complain
& tf_error
)
1709 permerror (init_loc
, "array must be initialized "
1710 "with a brace-enclosed initializer");
1712 return error_mark_node
;
1716 stmt_expr
= build_vec_init (exp
, NULL_TREE
, init
,
1717 /*explicit_value_init_p=*/false,
1720 TREE_READONLY (exp
) = was_const
;
1721 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1722 TREE_TYPE (exp
) = type
;
1723 /* Restore the type of init unless it was used directly. */
1724 if (init
&& TREE_CODE (stmt_expr
) != INIT_EXPR
)
1725 TREE_TYPE (init
) = itype
;
1729 if (init
&& init
!= void_type_node
1730 && TREE_CODE (init
) != TREE_LIST
1731 && !(TREE_CODE (init
) == TARGET_EXPR
1732 && TARGET_EXPR_DIRECT_INIT_P (init
))
1733 && !DIRECT_LIST_INIT_P (init
))
1734 flags
|= LOOKUP_ONLYCONVERTING
;
1736 if ((VAR_P (exp
) || TREE_CODE (exp
) == PARM_DECL
)
1737 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (type
)))
1738 /* Just know that we've seen something for this node. */
1739 TREE_USED (exp
) = 1;
1741 is_global
= begin_init_stmts (&stmt_expr
, &compound_stmt
);
1742 destroy_temps
= stmts_are_full_exprs_p ();
1743 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
1744 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1745 init
, LOOKUP_NORMAL
|flags
, complain
);
1746 stmt_expr
= finish_init_stmts (is_global
, stmt_expr
, compound_stmt
);
1747 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
1748 TREE_READONLY (exp
) = was_const
;
1749 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1755 expand_default_init (tree binfo
, tree true_exp
, tree exp
, tree init
, int flags
,
1756 tsubst_flags_t complain
)
1758 tree type
= TREE_TYPE (exp
);
1760 /* It fails because there may not be a constructor which takes
1761 its own type as the first (or only parameter), but which does
1762 take other types via a conversion. So, if the thing initializing
1763 the expression is a unit element of type X, first try X(X&),
1764 followed by initialization by X. If neither of these work
1765 out, then look hard. */
1767 vec
<tree
, va_gc
> *parms
;
1769 /* If we have direct-initialization from an initializer list, pull
1770 it out of the TREE_LIST so the code below can see it. */
1771 if (init
&& TREE_CODE (init
) == TREE_LIST
1772 && DIRECT_LIST_INIT_P (TREE_VALUE (init
)))
1774 gcc_checking_assert ((flags
& LOOKUP_ONLYCONVERTING
) == 0
1775 && TREE_CHAIN (init
) == NULL_TREE
);
1776 init
= TREE_VALUE (init
);
1777 /* Only call reshape_init if it has not been called earlier
1779 if (BRACE_ENCLOSED_INITIALIZER_P (init
) && CP_AGGREGATE_TYPE_P (type
))
1780 init
= reshape_init (type
, init
, complain
);
1783 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
1784 && CP_AGGREGATE_TYPE_P (type
))
1785 /* A brace-enclosed initializer for an aggregate. In C++0x this can
1786 happen for direct-initialization, too. */
1787 init
= digest_init (type
, init
, complain
);
1789 /* A CONSTRUCTOR of the target's type is a previously digested
1790 initializer, whether that happened just above or in
1791 cp_parser_late_parsing_nsdmi.
1793 A TARGET_EXPR with TARGET_EXPR_DIRECT_INIT_P or TARGET_EXPR_LIST_INIT_P
1794 set represents the whole initialization, so we shouldn't build up
1795 another ctor call. */
1797 && (TREE_CODE (init
) == CONSTRUCTOR
1798 || (TREE_CODE (init
) == TARGET_EXPR
1799 && (TARGET_EXPR_DIRECT_INIT_P (init
)
1800 || TARGET_EXPR_LIST_INIT_P (init
))))
1801 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (init
), type
))
1803 /* Early initialization via a TARGET_EXPR only works for
1804 complete objects. */
1805 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
|| true_exp
== exp
);
1807 init
= build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1808 TREE_SIDE_EFFECTS (init
) = 1;
1809 finish_expr_stmt (init
);
1813 if (init
&& TREE_CODE (init
) != TREE_LIST
1814 && (flags
& LOOKUP_ONLYCONVERTING
))
1816 /* Base subobjects should only get direct-initialization. */
1817 gcc_assert (true_exp
== exp
);
1819 if (flags
& DIRECT_BIND
)
1820 /* Do nothing. We hit this in two cases: Reference initialization,
1821 where we aren't initializing a real variable, so we don't want
1822 to run a new constructor; and catching an exception, where we
1823 have already built up the constructor call so we could wrap it
1824 in an exception region. */;
1826 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
,
1829 if (TREE_CODE (init
) == MUST_NOT_THROW_EXPR
)
1830 /* We need to protect the initialization of a catch parm with a
1831 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1832 around the TARGET_EXPR for the copy constructor. See
1833 initialize_handler_parm. */
1835 TREE_OPERAND (init
, 0) = build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
,
1836 TREE_OPERAND (init
, 0));
1837 TREE_TYPE (init
) = void_type_node
;
1840 init
= build2 (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1841 TREE_SIDE_EFFECTS (init
) = 1;
1842 finish_expr_stmt (init
);
1846 if (init
== NULL_TREE
)
1848 else if (TREE_CODE (init
) == TREE_LIST
&& !TREE_TYPE (init
))
1850 parms
= make_tree_vector ();
1851 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
1852 vec_safe_push (parms
, TREE_VALUE (init
));
1855 parms
= make_tree_vector_single (init
);
1857 if (exp
== current_class_ref
&& current_function_decl
1858 && DECL_HAS_IN_CHARGE_PARM_P (current_function_decl
))
1860 /* Delegating constructor. */
1863 tree elt
; unsigned i
;
1865 /* Unshare the arguments for the second call. */
1866 vec
<tree
, va_gc
> *parms2
= make_tree_vector ();
1867 FOR_EACH_VEC_SAFE_ELT (parms
, i
, elt
)
1869 elt
= break_out_target_exprs (elt
);
1870 vec_safe_push (parms2
, elt
);
1872 complete
= build_special_member_call (exp
, complete_ctor_identifier
,
1873 &parms2
, binfo
, flags
,
1875 complete
= fold_build_cleanup_point_expr (void_type_node
, complete
);
1876 release_tree_vector (parms2
);
1878 base
= build_special_member_call (exp
, base_ctor_identifier
,
1879 &parms
, binfo
, flags
,
1881 base
= fold_build_cleanup_point_expr (void_type_node
, base
);
1882 rval
= build_if_in_charge (complete
, base
);
1886 tree ctor_name
= (true_exp
== exp
1887 ? complete_ctor_identifier
: base_ctor_identifier
);
1889 rval
= build_special_member_call (exp
, ctor_name
, &parms
, binfo
, flags
,
1894 release_tree_vector (parms
);
1896 if (exp
== true_exp
&& TREE_CODE (rval
) == CALL_EXPR
)
1898 tree fn
= get_callee_fndecl (rval
);
1899 if (fn
&& DECL_DECLARED_CONSTEXPR_P (fn
))
1901 tree e
= maybe_constant_init (rval
, exp
);
1902 if (TREE_CONSTANT (e
))
1903 rval
= build2 (INIT_EXPR
, type
, exp
, e
);
1907 /* FIXME put back convert_to_void? */
1908 if (TREE_SIDE_EFFECTS (rval
))
1909 finish_expr_stmt (rval
);
1912 /* This function is responsible for initializing EXP with INIT
1915 BINFO is the binfo of the type for who we are performing the
1916 initialization. For example, if W is a virtual base class of A and B,
1918 If we are initializing B, then W must contain B's W vtable, whereas
1919 were we initializing C, W must contain C's W vtable.
1921 TRUE_EXP is nonzero if it is the true expression being initialized.
1922 In this case, it may be EXP, or may just contain EXP. The reason we
1923 need this is because if EXP is a base element of TRUE_EXP, we
1924 don't necessarily know by looking at EXP where its virtual
1925 baseclass fields should really be pointing. But we do know
1926 from TRUE_EXP. In constructors, we don't know anything about
1927 the value being initialized.
1929 FLAGS is just passed to `build_new_method_call'. See that function
1930 for its description. */
1933 expand_aggr_init_1 (tree binfo
, tree true_exp
, tree exp
, tree init
, int flags
,
1934 tsubst_flags_t complain
)
1936 tree type
= TREE_TYPE (exp
);
1938 gcc_assert (init
!= error_mark_node
&& type
!= error_mark_node
);
1939 gcc_assert (building_stmt_list_p ());
1941 /* Use a function returning the desired type to initialize EXP for us.
1942 If the function is a constructor, and its first argument is
1943 NULL_TREE, know that it was meant for us--just slide exp on
1944 in and expand the constructor. Constructors now come
1947 if (init
&& VAR_P (exp
)
1948 && COMPOUND_LITERAL_P (init
))
1950 vec
<tree
, va_gc
> *cleanups
= NULL
;
1951 /* If store_init_value returns NULL_TREE, the INIT has been
1952 recorded as the DECL_INITIAL for EXP. That means there's
1953 nothing more we have to do. */
1954 init
= store_init_value (exp
, init
, &cleanups
, flags
);
1956 finish_expr_stmt (init
);
1957 gcc_assert (!cleanups
);
1961 /* List-initialization from {} becomes value-initialization for non-aggregate
1962 classes with default constructors. Handle this here when we're
1963 initializing a base, so protected access works. */
1964 if (exp
!= true_exp
&& init
&& TREE_CODE (init
) == TREE_LIST
)
1966 tree elt
= TREE_VALUE (init
);
1967 if (DIRECT_LIST_INIT_P (elt
)
1968 && CONSTRUCTOR_ELTS (elt
) == 0
1969 && CLASSTYPE_NON_AGGREGATE (type
)
1970 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1971 init
= void_type_node
;
1974 /* If an explicit -- but empty -- initializer list was present,
1975 that's value-initialization. */
1976 if (init
== void_type_node
)
1978 /* If the type has data but no user-provided ctor, we need to zero
1980 if (!type_has_user_provided_constructor (type
)
1981 && !is_really_empty_class (type
))
1983 tree field_size
= NULL_TREE
;
1984 if (exp
!= true_exp
&& CLASSTYPE_AS_BASE (type
) != type
)
1985 /* Don't clobber already initialized virtual bases. */
1986 field_size
= TYPE_SIZE (CLASSTYPE_AS_BASE (type
));
1987 init
= build_zero_init_1 (type
, NULL_TREE
, /*static_storage_p=*/false,
1989 init
= build2 (INIT_EXPR
, type
, exp
, init
);
1990 finish_expr_stmt (init
);
1993 /* If we don't need to mess with the constructor at all,
1995 if (! type_build_ctor_call (type
))
1998 /* Otherwise fall through and call the constructor. */
2002 /* We know that expand_default_init can handle everything we want
2004 expand_default_init (binfo
, true_exp
, exp
, init
, flags
, complain
);
2007 /* Report an error if TYPE is not a user-defined, class type. If
2008 OR_ELSE is nonzero, give an error message. */
2011 is_class_type (tree type
, int or_else
)
2013 if (type
== error_mark_node
)
2016 if (! CLASS_TYPE_P (type
))
2019 error ("%qT is not a class type", type
);
2026 get_type_value (tree name
)
2028 if (name
== error_mark_node
)
2031 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
2032 return IDENTIFIER_TYPE_VALUE (name
);
2037 /* Build a reference to a member of an aggregate. This is not a C++
2038 `&', but really something which can have its address taken, and
2039 then act as a pointer to member, for example TYPE :: FIELD can have
2040 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
2041 this expression is the operand of "&".
2043 @@ Prints out lousy diagnostics for operator <typename>
2046 @@ This function should be rewritten and placed in search.c. */
2049 build_offset_ref (tree type
, tree member
, bool address_p
,
2050 tsubst_flags_t complain
)
2053 tree basebinfo
= NULL_TREE
;
2055 /* class templates can come in as TEMPLATE_DECLs here. */
2056 if (TREE_CODE (member
) == TEMPLATE_DECL
)
2059 if (dependent_scope_p (type
) || type_dependent_expression_p (member
))
2060 return build_qualified_name (NULL_TREE
, type
, member
,
2061 /*template_p=*/false);
2063 gcc_assert (TYPE_P (type
));
2064 if (! is_class_type (type
, 1))
2065 return error_mark_node
;
2067 gcc_assert (DECL_P (member
) || BASELINK_P (member
));
2068 /* Callers should call mark_used before this point. */
2069 gcc_assert (!DECL_P (member
) || TREE_USED (member
));
2071 type
= TYPE_MAIN_VARIANT (type
);
2072 if (!COMPLETE_OR_OPEN_TYPE_P (complete_type (type
)))
2074 if (complain
& tf_error
)
2075 error ("incomplete type %qT does not have member %qD", type
, member
);
2076 return error_mark_node
;
2079 /* Entities other than non-static members need no further
2081 if (TREE_CODE (member
) == TYPE_DECL
)
2083 if (VAR_P (member
) || TREE_CODE (member
) == CONST_DECL
)
2084 return convert_from_reference (member
);
2086 if (TREE_CODE (member
) == FIELD_DECL
&& DECL_C_BIT_FIELD (member
))
2088 if (complain
& tf_error
)
2089 error ("invalid pointer to bit-field %qD", member
);
2090 return error_mark_node
;
2093 /* Set up BASEBINFO for member lookup. */
2094 decl
= maybe_dummy_object (type
, &basebinfo
);
2096 /* A lot of this logic is now handled in lookup_member. */
2097 if (BASELINK_P (member
))
2099 /* Go from the TREE_BASELINK to the member function info. */
2100 tree t
= BASELINK_FUNCTIONS (member
);
2102 if (TREE_CODE (t
) != TEMPLATE_ID_EXPR
&& !really_overloaded_fn (t
))
2104 /* Get rid of a potential OVERLOAD around it. */
2107 /* Unique functions are handled easily. */
2109 /* For non-static member of base class, we need a special rule
2110 for access checking [class.protected]:
2112 If the access is to form a pointer to member, the
2113 nested-name-specifier shall name the derived class
2114 (or any class derived from that class). */
2116 if (address_p
&& DECL_P (t
)
2117 && DECL_NONSTATIC_MEMBER_P (t
))
2118 ok
= perform_or_defer_access_check (TYPE_BINFO (type
), t
, t
,
2121 ok
= perform_or_defer_access_check (basebinfo
, t
, t
,
2124 return error_mark_node
;
2125 if (DECL_STATIC_FUNCTION_P (t
))
2130 TREE_TYPE (member
) = unknown_type_node
;
2132 else if (address_p
&& TREE_CODE (member
) == FIELD_DECL
)
2134 /* We need additional test besides the one in
2135 check_accessibility_of_qualified_id in case it is
2136 a pointer to non-static member. */
2137 if (!perform_or_defer_access_check (TYPE_BINFO (type
), member
, member
,
2139 return error_mark_node
;
2144 /* If MEMBER is non-static, then the program has fallen afoul of
2147 An id-expression that denotes a nonstatic data member or
2148 nonstatic member function of a class can only be used:
2150 -- as part of a class member access (_expr.ref_) in which the
2151 object-expression refers to the member's class or a class
2152 derived from that class, or
2154 -- to form a pointer to member (_expr.unary.op_), or
2156 -- in the body of a nonstatic member function of that class or
2157 of a class derived from that class (_class.mfct.nonstatic_), or
2159 -- in a mem-initializer for a constructor for that class or for
2160 a class derived from that class (_class.base.init_). */
2161 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member
))
2163 /* Build a representation of the qualified name suitable
2164 for use as the operand to "&" -- even though the "&" is
2165 not actually present. */
2166 member
= build2 (OFFSET_REF
, TREE_TYPE (member
), decl
, member
);
2167 /* In Microsoft mode, treat a non-static member function as if
2168 it were a pointer-to-member. */
2169 if (flag_ms_extensions
)
2171 PTRMEM_OK_P (member
) = 1;
2172 return cp_build_addr_expr (member
, complain
);
2174 if (complain
& tf_error
)
2175 error ("invalid use of non-static member function %qD",
2176 TREE_OPERAND (member
, 1));
2177 return error_mark_node
;
2179 else if (TREE_CODE (member
) == FIELD_DECL
)
2181 if (complain
& tf_error
)
2182 error ("invalid use of non-static data member %qD", member
);
2183 return error_mark_node
;
2188 member
= build2 (OFFSET_REF
, TREE_TYPE (member
), decl
, member
);
2189 PTRMEM_OK_P (member
) = 1;
2193 /* If DECL is a scalar enumeration constant or variable with a
2194 constant initializer, return the initializer (or, its initializers,
2195 recursively); otherwise, return DECL. If STRICT_P, the
2196 initializer is only returned if DECL is a
2197 constant-expression. If RETURN_AGGREGATE_CST_OK_P, it is ok to
2198 return an aggregate constant. */
2201 constant_value_1 (tree decl
, bool strict_p
, bool return_aggregate_cst_ok_p
)
2203 while (TREE_CODE (decl
) == CONST_DECL
2204 || decl_constant_var_p (decl
)
2205 || (!strict_p
&& VAR_P (decl
)
2206 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl
))))
2209 /* If DECL is a static data member in a template
2210 specialization, we must instantiate it here. The
2211 initializer for the static data member is not processed
2212 until needed; we need it now. */
2213 mark_used (decl
, tf_none
);
2214 init
= DECL_INITIAL (decl
);
2215 if (init
== error_mark_node
)
2217 if (TREE_CODE (decl
) == CONST_DECL
2218 || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
))
2219 /* Treat the error as a constant to avoid cascading errors on
2220 excessively recursive template instantiation (c++/9335). */
2225 /* Initializers in templates are generally expanded during
2226 instantiation, so before that for const int i(2)
2227 INIT is a TREE_LIST with the actual initializer as
2229 if (processing_template_decl
2231 && TREE_CODE (init
) == TREE_LIST
2232 && TREE_CHAIN (init
) == NULL_TREE
)
2233 init
= TREE_VALUE (init
);
2234 /* Instantiate a non-dependent initializer for user variables. We
2235 mustn't do this for the temporary for an array compound literal;
2236 trying to instatiate the initializer will keep creating new
2237 temporaries until we crash. Probably it's not useful to do it for
2238 other artificial variables, either. */
2239 if (!DECL_ARTIFICIAL (decl
))
2240 init
= instantiate_non_dependent_or_null (init
);
2242 || !TREE_TYPE (init
)
2243 || !TREE_CONSTANT (init
)
2244 || (!return_aggregate_cst_ok_p
2245 /* Unless RETURN_AGGREGATE_CST_OK_P is true, do not
2246 return an aggregate constant (of which string
2247 literals are a special case), as we do not want
2248 to make inadvertent copies of such entities, and
2249 we must be sure that their addresses are the
2251 && (TREE_CODE (init
) == CONSTRUCTOR
2252 || TREE_CODE (init
) == STRING_CST
)))
2254 /* Don't return a CONSTRUCTOR for a variable with partial run-time
2255 initialization, since it doesn't represent the entire value. */
2256 if (TREE_CODE (init
) == CONSTRUCTOR
2257 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
))
2259 /* If the variable has a dynamic initializer, don't use its
2260 DECL_INITIAL which doesn't reflect the real value. */
2262 && TREE_STATIC (decl
)
2263 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
)
2264 && DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
2266 decl
= unshare_expr (init
);
2271 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by constant
2272 of integral or enumeration type, or a constexpr variable of scalar type,
2273 then return that value. These are those variables permitted in constant
2274 expressions by [5.19/1]. */
2277 scalar_constant_value (tree decl
)
2279 return constant_value_1 (decl
, /*strict_p=*/true,
2280 /*return_aggregate_cst_ok_p=*/false);
2283 /* Like scalar_constant_value, but can also return aggregate initializers. */
2286 decl_really_constant_value (tree decl
)
2288 return constant_value_1 (decl
, /*strict_p=*/true,
2289 /*return_aggregate_cst_ok_p=*/true);
2292 /* A more relaxed version of scalar_constant_value, used by the
2293 common C/C++ code. */
2296 decl_constant_value (tree decl
)
2298 return constant_value_1 (decl
, /*strict_p=*/processing_template_decl
,
2299 /*return_aggregate_cst_ok_p=*/true);
2302 /* Common subroutines of build_new and build_vec_delete. */
2304 /* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
2305 the type of the object being allocated; otherwise, it's just TYPE.
2306 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
2307 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
2308 a vector of arguments to be provided as arguments to a placement
2309 new operator. This routine performs no semantic checks; it just
2310 creates and returns a NEW_EXPR. */
2313 build_raw_new_expr (vec
<tree
, va_gc
> *placement
, tree type
, tree nelts
,
2314 vec
<tree
, va_gc
> *init
, int use_global_new
)
2319 /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR.
2320 If INIT is not NULL, then we want to store VOID_ZERO_NODE. This
2321 permits us to distinguish the case of a missing initializer "new
2322 int" from an empty initializer "new int()". */
2324 init_list
= NULL_TREE
;
2325 else if (init
->is_empty ())
2326 init_list
= void_node
;
2328 init_list
= build_tree_list_vec (init
);
2330 new_expr
= build4 (NEW_EXPR
, build_pointer_type (type
),
2331 build_tree_list_vec (placement
), type
, nelts
,
2333 NEW_EXPR_USE_GLOBAL (new_expr
) = use_global_new
;
2334 TREE_SIDE_EFFECTS (new_expr
) = 1;
2339 /* Diagnose uninitialized const members or reference members of type
2340 TYPE. USING_NEW is used to disambiguate the diagnostic between a
2341 new expression without a new-initializer and a declaration. Returns
2345 diagnose_uninitialized_cst_or_ref_member_1 (tree type
, tree origin
,
2346 bool using_new
, bool complain
)
2349 int error_count
= 0;
2351 if (type_has_user_provided_constructor (type
))
2354 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2358 if (TREE_CODE (field
) != FIELD_DECL
)
2361 field_type
= strip_array_types (TREE_TYPE (field
));
2363 if (type_has_user_provided_constructor (field_type
))
2366 if (TREE_CODE (field_type
) == REFERENCE_TYPE
)
2371 if (DECL_CONTEXT (field
) == origin
)
2374 error ("uninitialized reference member in %q#T "
2375 "using %<new%> without new-initializer", origin
);
2377 error ("uninitialized reference member in %q#T", origin
);
2382 error ("uninitialized reference member in base %q#T "
2383 "of %q#T using %<new%> without new-initializer",
2384 DECL_CONTEXT (field
), origin
);
2386 error ("uninitialized reference member in base %q#T "
2387 "of %q#T", DECL_CONTEXT (field
), origin
);
2389 inform (DECL_SOURCE_LOCATION (field
),
2390 "%q#D should be initialized", field
);
2394 if (CP_TYPE_CONST_P (field_type
))
2399 if (DECL_CONTEXT (field
) == origin
)
2402 error ("uninitialized const member in %q#T "
2403 "using %<new%> without new-initializer", origin
);
2405 error ("uninitialized const member in %q#T", origin
);
2410 error ("uninitialized const member in base %q#T "
2411 "of %q#T using %<new%> without new-initializer",
2412 DECL_CONTEXT (field
), origin
);
2414 error ("uninitialized const member in base %q#T "
2415 "of %q#T", DECL_CONTEXT (field
), origin
);
2417 inform (DECL_SOURCE_LOCATION (field
),
2418 "%q#D should be initialized", field
);
2422 if (CLASS_TYPE_P (field_type
))
2424 += diagnose_uninitialized_cst_or_ref_member_1 (field_type
, origin
,
2425 using_new
, complain
);
2431 diagnose_uninitialized_cst_or_ref_member (tree type
, bool using_new
, bool complain
)
2433 return diagnose_uninitialized_cst_or_ref_member_1 (type
, type
, using_new
, complain
);
2436 /* Call __cxa_bad_array_new_length to indicate that the size calculation
2437 overflowed. Pretend it returns sizetype so that it plays nicely in the
2441 throw_bad_array_new_length (void)
2445 tree name
= get_identifier ("__cxa_throw_bad_array_new_length");
2447 fn
= get_global_binding (name
);
2449 fn
= push_throw_library_fn
2450 (name
, build_function_type_list (sizetype
, NULL_TREE
));
2453 return build_cxx_call (fn
, 0, NULL
, tf_warning_or_error
);
2456 /* Attempt to find the initializer for field T in the initializer INIT,
2457 when non-null. Returns the initializer when successful and NULL
2460 find_field_init (tree t
, tree init
)
2465 unsigned HOST_WIDE_INT idx
;
2468 /* Iterate over all top-level initializer elements. */
2469 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
, field
, elt
)
2471 /* If the member T is found, return it. */
2475 /* Otherwise continue and/or recurse into nested initializers. */
2476 if (TREE_CODE (elt
) == CONSTRUCTOR
2477 && (init
= find_field_init (t
, elt
)))
2483 /* Attempt to verify that the argument, OPER, of a placement new expression
2484 refers to an object sufficiently large for an object of TYPE or an array
2485 of NELTS of such objects when NELTS is non-null, and issue a warning when
2486 it does not. SIZE specifies the size needed to construct the object or
2487 array and captures the result of NELTS * sizeof (TYPE). (SIZE could be
2488 greater when the array under construction requires a cookie to store
2489 NELTS. GCC's placement new expression stores the cookie when invoking
2490 a user-defined placement new operator function but not the default one.
2491 Placement new expressions with user-defined placement new operator are
2492 not diagnosed since we don't know how they use the buffer (this could
2493 be a future extension). */
2495 warn_placement_new_too_small (tree type
, tree nelts
, tree size
, tree oper
)
2497 location_t loc
= EXPR_LOC_OR_LOC (oper
, input_location
);
2499 /* The number of bytes to add to or subtract from the size of the provided
2500 buffer based on an offset into an array or an array element reference.
2501 Although intermediate results may be negative (as in a[3] - 2) a valid
2502 final result cannot be. */
2503 offset_int adjust
= 0;
2504 /* True when the size of the entire destination object should be used
2505 to compute the possibly optimistic estimate of the available space. */
2506 bool use_obj_size
= false;
2507 /* True when the reference to the destination buffer is an ADDR_EXPR. */
2508 bool addr_expr
= false;
2512 /* Using a function argument or a (non-array) variable as an argument
2513 to placement new is not checked since it's unknown what it might
2515 if (TREE_CODE (oper
) == PARM_DECL
2517 || TREE_CODE (oper
) == COMPONENT_REF
)
2520 /* Evaluate any constant expressions. */
2521 size
= fold_non_dependent_expr (size
);
2523 /* Handle the common case of array + offset expression when the offset
2525 if (TREE_CODE (oper
) == POINTER_PLUS_EXPR
)
2527 /* If the offset is compile-time constant, use it to compute a more
2528 accurate estimate of the size of the buffer. Since the operand
2529 of POINTER_PLUS_EXPR is represented as an unsigned type, convert
2531 Otherwise, use the size of the entire array as an optimistic
2532 estimate (this may lead to false negatives). */
2533 tree adj
= TREE_OPERAND (oper
, 1);
2534 if (CONSTANT_CLASS_P (adj
))
2535 adjust
+= wi::to_offset (convert (ssizetype
, adj
));
2537 use_obj_size
= true;
2539 oper
= TREE_OPERAND (oper
, 0);
2544 if (TREE_CODE (oper
) == TARGET_EXPR
)
2545 oper
= TREE_OPERAND (oper
, 1);
2546 else if (TREE_CODE (oper
) == ADDR_EXPR
)
2549 oper
= TREE_OPERAND (oper
, 0);
2554 if (TREE_CODE (oper
) == ARRAY_REF
2555 && (addr_expr
|| TREE_CODE (TREE_TYPE (oper
)) == ARRAY_TYPE
))
2557 /* Similar to the offset computed above, see if the array index
2558 is a compile-time constant. If so, and unless the offset was
2559 not a compile-time constant, use the index to determine the
2560 size of the buffer. Otherwise, use the entire array as
2561 an optimistic estimate of the size. */
2562 const_tree adj
= fold_non_dependent_expr (TREE_OPERAND (oper
, 1));
2563 if (!use_obj_size
&& CONSTANT_CLASS_P (adj
))
2564 adjust
+= wi::to_offset (adj
);
2567 use_obj_size
= true;
2571 oper
= TREE_OPERAND (oper
, 0);
2574 /* Refers to the declared object that constains the subobject referenced
2575 by OPER. When the object is initialized, makes it possible to determine
2576 the actual size of a flexible array member used as the buffer passed
2577 as OPER to placement new. */
2578 tree var_decl
= NULL_TREE
;
2579 /* True when operand is a COMPONENT_REF, to distinguish flexible array
2580 members from arrays of unspecified size. */
2581 bool compref
= TREE_CODE (oper
) == COMPONENT_REF
;
2583 /* For COMPONENT_REF (i.e., a struct member) the size of the entire
2584 enclosing struct. Used to validate the adjustment (offset) into
2585 an array at the end of a struct. */
2586 offset_int compsize
= 0;
2588 /* Descend into a struct or union to find the member whose address
2589 is being used as the argument. */
2590 if (TREE_CODE (oper
) == COMPONENT_REF
)
2592 tree comptype
= TREE_TYPE (TREE_OPERAND (oper
, 0));
2593 compsize
= wi::to_offset (TYPE_SIZE_UNIT (comptype
));
2596 while (TREE_CODE (op0
= TREE_OPERAND (op0
, 0)) == COMPONENT_REF
);
2599 oper
= TREE_OPERAND (oper
, 1);
2602 tree opertype
= TREE_TYPE (oper
);
2603 if ((addr_expr
|| !POINTER_TYPE_P (opertype
))
2605 || TREE_CODE (oper
) == FIELD_DECL
2606 || TREE_CODE (oper
) == PARM_DECL
))
2608 /* A possibly optimistic estimate of the number of bytes available
2609 in the destination buffer. */
2610 offset_int bytes_avail
= 0;
2611 /* True when the estimate above is in fact the exact size
2612 of the destination buffer rather than an estimate. */
2613 bool exact_size
= true;
2615 /* Treat members of unions and members of structs uniformly, even
2616 though the size of a member of a union may be viewed as extending
2617 to the end of the union itself (it is by __builtin_object_size). */
2618 if ((VAR_P (oper
) || use_obj_size
)
2619 && DECL_SIZE_UNIT (oper
)
2620 && tree_fits_uhwi_p (DECL_SIZE_UNIT (oper
)))
2622 /* Use the size of the entire array object when the expression
2623 refers to a variable or its size depends on an expression
2624 that's not a compile-time constant. */
2625 bytes_avail
= wi::to_offset (DECL_SIZE_UNIT (oper
));
2626 exact_size
= !use_obj_size
;
2628 else if (tree opersize
= TYPE_SIZE_UNIT (opertype
))
2630 /* Use the size of the type of the destination buffer object
2631 as the optimistic estimate of the available space in it.
2632 Use the maximum possible size for zero-size arrays and
2633 flexible array members (except of initialized objects
2635 if (TREE_CODE (opersize
) == INTEGER_CST
)
2636 bytes_avail
= wi::to_offset (opersize
);
2639 if (bytes_avail
== 0)
2643 /* Constructing into a buffer provided by the flexible array
2644 member of a declared object (which is permitted as a G++
2645 extension). If the array member has been initialized,
2646 determine its size from the initializer. Otherwise,
2647 the array size is zero. */
2648 if (tree init
= find_field_init (oper
, DECL_INITIAL (var_decl
)))
2649 bytes_avail
= wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (init
)));
2652 bytes_avail
= (wi::to_offset (TYPE_MAX_VALUE (ptrdiff_type_node
))
2656 tree_code oper_code
= TREE_CODE (opertype
);
2658 if (compref
&& oper_code
== ARRAY_TYPE
)
2660 tree nelts
= array_type_nelts_top (opertype
);
2661 tree nelts_cst
= maybe_constant_value (nelts
);
2662 if (TREE_CODE (nelts_cst
) == INTEGER_CST
2663 && integer_onep (nelts_cst
)
2665 && warn_placement_new
< 2)
2669 /* Reduce the size of the buffer by the adjustment computed above
2670 from the offset and/or the index into the array. */
2671 if (bytes_avail
< adjust
|| adjust
< 0)
2675 tree elttype
= (TREE_CODE (opertype
) == ARRAY_TYPE
2676 ? TREE_TYPE (opertype
) : opertype
);
2677 if (tree eltsize
= TYPE_SIZE_UNIT (elttype
))
2679 bytes_avail
-= adjust
* wi::to_offset (eltsize
);
2680 if (bytes_avail
< 0)
2685 /* The minimum amount of space needed for the allocation. This
2686 is an optimistic estimate that makes it possible to detect
2687 placement new invocation for some undersize buffers but not
2689 offset_int bytes_need
;
2691 if (CONSTANT_CLASS_P (size
))
2692 bytes_need
= wi::to_offset (size
);
2693 else if (nelts
&& CONSTANT_CLASS_P (nelts
))
2694 bytes_need
= (wi::to_offset (nelts
)
2695 * wi::to_offset (TYPE_SIZE_UNIT (type
)));
2696 else if (tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
2697 bytes_need
= wi::to_offset (TYPE_SIZE_UNIT (type
));
2700 /* The type is a VLA. */
2704 if (bytes_avail
< bytes_need
)
2707 if (CONSTANT_CLASS_P (nelts
))
2708 warning_at (loc
, OPT_Wplacement_new_
,
2710 "placement new constructing an object of type "
2711 "%<%T [%wu]%> and size %qwu in a region of type %qT "
2713 : "placement new constructing an object of type "
2714 "%<%T [%wu]%> and size %qwu in a region of type %qT "
2715 "and size at most %qwu",
2716 type
, tree_to_uhwi (nelts
), bytes_need
.to_uhwi (),
2717 opertype
, bytes_avail
.to_uhwi ());
2719 warning_at (loc
, OPT_Wplacement_new_
,
2721 "placement new constructing an array of objects "
2722 "of type %qT and size %qwu in a region of type %qT "
2724 : "placement new constructing an array of objects "
2725 "of type %qT and size %qwu in a region of type %qT "
2726 "and size at most %qwu",
2727 type
, bytes_need
.to_uhwi (), opertype
,
2728 bytes_avail
.to_uhwi ());
2730 warning_at (loc
, OPT_Wplacement_new_
,
2732 "placement new constructing an object of type %qT "
2733 "and size %qwu in a region of type %qT and size %qwi"
2734 : "placement new constructing an object of type %qT "
2735 "and size %qwu in a region of type %qT and size "
2737 type
, bytes_need
.to_uhwi (), opertype
,
2738 bytes_avail
.to_uhwi ());
2743 /* True if alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__. */
2746 type_has_new_extended_alignment (tree t
)
2748 return (aligned_new_threshold
2749 && TYPE_ALIGN_UNIT (t
) > (unsigned)aligned_new_threshold
);
2752 /* Return the alignment we expect malloc to guarantee. This should just be
2753 MALLOC_ABI_ALIGNMENT, but that macro defaults to only BITS_PER_WORD for some
2754 reason, so don't let the threshold be smaller than max_align_t_align. */
2759 return MAX (max_align_t_align(), MALLOC_ABI_ALIGNMENT
);
2762 /* Determine whether an allocation function is a namespace-scope
2763 non-replaceable placement new function. See DR 1748.
2764 TODO: Enable in all standard modes. */
2766 std_placement_new_fn_p (tree alloc_fn
)
2768 if (DECL_NAMESPACE_SCOPE_P (alloc_fn
))
2770 tree first_arg
= TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn
)));
2771 if ((TREE_VALUE (first_arg
) == ptr_type_node
)
2772 && TREE_CHAIN (first_arg
) == void_list_node
)
2778 /* Generate code for a new-expression, including calling the "operator
2779 new" function, initializing the object, and, if an exception occurs
2780 during construction, cleaning up. The arguments are as for
2781 build_raw_new_expr. This may change PLACEMENT and INIT.
2782 TYPE is the type of the object being constructed, possibly an array
2783 of NELTS elements when NELTS is non-null (in "new T[NELTS]", T may
2784 be an array of the form U[inner], with the whole expression being
2785 "new U[NELTS][inner]"). */
2788 build_new_1 (vec
<tree
, va_gc
> **placement
, tree type
, tree nelts
,
2789 vec
<tree
, va_gc
> **init
, bool globally_qualified_p
,
2790 tsubst_flags_t complain
)
2793 /* True iff this is a call to "operator new[]" instead of just
2795 bool array_p
= false;
2796 /* If ARRAY_P is true, the element type of the array. This is never
2797 an ARRAY_TYPE; for something like "new int[3][4]", the
2798 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
2801 /* The type of the new-expression. (This type is always a pointer
2804 tree non_const_pointer_type
;
2805 /* The most significant array bound in int[OUTER_NELTS][inner]. */
2806 tree outer_nelts
= NULL_TREE
;
2807 /* For arrays with a non-constant number of elements, a bounds checks
2808 on the NELTS parameter to avoid integer overflow at runtime. */
2809 tree outer_nelts_check
= NULL_TREE
;
2810 bool outer_nelts_from_type
= false;
2811 /* Number of the "inner" elements in "new T[OUTER_NELTS][inner]". */
2812 offset_int inner_nelts_count
= 1;
2813 tree alloc_call
, alloc_expr
;
2814 /* Size of the inner array elements (those with constant dimensions). */
2815 offset_int inner_size
;
2816 /* The address returned by the call to "operator new". This node is
2817 a VAR_DECL and is therefore reusable. */
2820 tree cookie_expr
, init_expr
;
2821 int nothrow
, check_new
;
2822 /* If non-NULL, the number of extra bytes to allocate at the
2823 beginning of the storage allocated for an array-new expression in
2824 order to store the number of elements. */
2825 tree cookie_size
= NULL_TREE
;
2826 tree placement_first
;
2827 tree placement_expr
= NULL_TREE
;
2828 /* True if the function we are calling is a placement allocation
2830 bool placement_allocation_fn_p
;
2831 /* True if the storage must be initialized, either by a constructor
2832 or due to an explicit new-initializer. */
2833 bool is_initialized
;
2834 /* The address of the thing allocated, not including any cookie. In
2835 particular, if an array cookie is in use, DATA_ADDR is the
2836 address of the first array element. This node is a VAR_DECL, and
2837 is therefore reusable. */
2839 tree init_preeval_expr
= NULL_TREE
;
2840 tree orig_type
= type
;
2844 outer_nelts
= nelts
;
2847 else if (TREE_CODE (type
) == ARRAY_TYPE
)
2849 /* Transforms new (T[N]) to new T[N]. The former is a GNU
2850 extension for variable N. (This also covers new T where T is
2853 nelts
= array_type_nelts_top (type
);
2854 outer_nelts
= nelts
;
2855 type
= TREE_TYPE (type
);
2856 outer_nelts_from_type
= true;
2859 /* Lots of logic below. depends on whether we have a constant number of
2860 elements, so go ahead and fold it now. */
2862 outer_nelts
= maybe_constant_value (outer_nelts
);
2864 /* If our base type is an array, then make sure we know how many elements
2866 for (elt_type
= type
;
2867 TREE_CODE (elt_type
) == ARRAY_TYPE
;
2868 elt_type
= TREE_TYPE (elt_type
))
2870 tree inner_nelts
= array_type_nelts_top (elt_type
);
2871 tree inner_nelts_cst
= maybe_constant_value (inner_nelts
);
2872 if (TREE_CODE (inner_nelts_cst
) == INTEGER_CST
)
2875 offset_int result
= wi::mul (wi::to_offset (inner_nelts_cst
),
2876 inner_nelts_count
, SIGNED
, &overflow
);
2879 if (complain
& tf_error
)
2880 error ("integer overflow in array size");
2881 nelts
= error_mark_node
;
2883 inner_nelts_count
= result
;
2887 if (complain
& tf_error
)
2889 error_at (EXPR_LOC_OR_LOC (inner_nelts
, input_location
),
2890 "array size in new-expression must be constant");
2891 cxx_constant_value(inner_nelts
);
2893 nelts
= error_mark_node
;
2895 if (nelts
!= error_mark_node
)
2896 nelts
= cp_build_binary_op (input_location
,
2902 if (variably_modified_type_p (elt_type
, NULL_TREE
) && (complain
& tf_error
))
2904 error ("variably modified type not allowed in new-expression");
2905 return error_mark_node
;
2908 if (nelts
== error_mark_node
)
2909 return error_mark_node
;
2911 /* Warn if we performed the (T[N]) to T[N] transformation and N is
2913 if (outer_nelts_from_type
2914 && !TREE_CONSTANT (outer_nelts
))
2916 if (complain
& tf_warning_or_error
)
2918 pedwarn (EXPR_LOC_OR_LOC (outer_nelts
, input_location
), OPT_Wvla
,
2919 typedef_variant_p (orig_type
)
2920 ? G_("non-constant array new length must be specified "
2921 "directly, not by typedef")
2922 : G_("non-constant array new length must be specified "
2923 "without parentheses around the type-id"));
2926 return error_mark_node
;
2929 if (VOID_TYPE_P (elt_type
))
2931 if (complain
& tf_error
)
2932 error ("invalid type %<void%> for new");
2933 return error_mark_node
;
2936 if (abstract_virtuals_error_sfinae (ACU_NEW
, elt_type
, complain
))
2937 return error_mark_node
;
2939 is_initialized
= (type_build_ctor_call (elt_type
) || *init
!= NULL
);
2941 if (*init
== NULL
&& cxx_dialect
< cxx11
)
2943 bool maybe_uninitialized_error
= false;
2944 /* A program that calls for default-initialization [...] of an
2945 entity of reference type is ill-formed. */
2946 if (CLASSTYPE_REF_FIELDS_NEED_INIT (elt_type
))
2947 maybe_uninitialized_error
= true;
2949 /* A new-expression that creates an object of type T initializes
2950 that object as follows:
2951 - If the new-initializer is omitted:
2952 -- If T is a (possibly cv-qualified) non-POD class type
2953 (or array thereof), the object is default-initialized (8.5).
2955 -- Otherwise, the object created has indeterminate
2956 value. If T is a const-qualified type, or a (possibly
2957 cv-qualified) POD class type (or array thereof)
2958 containing (directly or indirectly) a member of
2959 const-qualified type, the program is ill-formed; */
2961 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (elt_type
))
2962 maybe_uninitialized_error
= true;
2964 if (maybe_uninitialized_error
2965 && diagnose_uninitialized_cst_or_ref_member (elt_type
,
2967 complain
& tf_error
))
2968 return error_mark_node
;
2971 if (CP_TYPE_CONST_P (elt_type
) && *init
== NULL
2972 && default_init_uninitialized_part (elt_type
))
2974 if (complain
& tf_error
)
2975 error ("uninitialized const in %<new%> of %q#T", elt_type
);
2976 return error_mark_node
;
2979 size
= size_in_bytes (elt_type
);
2982 /* Maximum available size in bytes. Half of the address space
2983 minus the cookie size. */
2985 = wi::set_bit_in_zero
<offset_int
> (TYPE_PRECISION (sizetype
) - 1);
2986 /* Maximum number of outer elements which can be allocated. */
2987 offset_int max_outer_nelts
;
2988 tree max_outer_nelts_tree
;
2990 gcc_assert (TREE_CODE (size
) == INTEGER_CST
);
2991 cookie_size
= targetm
.cxx
.get_cookie_size (elt_type
);
2992 gcc_assert (TREE_CODE (cookie_size
) == INTEGER_CST
);
2993 gcc_checking_assert (wi::ltu_p (wi::to_offset (cookie_size
), max_size
));
2994 /* Unconditionally subtract the cookie size. This decreases the
2995 maximum object size and is safe even if we choose not to use
2996 a cookie after all. */
2997 max_size
-= wi::to_offset (cookie_size
);
2999 inner_size
= wi::mul (wi::to_offset (size
), inner_nelts_count
, SIGNED
,
3001 if (overflow
|| wi::gtu_p (inner_size
, max_size
))
3003 if (complain
& tf_error
)
3004 error ("size of array is too large");
3005 return error_mark_node
;
3008 max_outer_nelts
= wi::udiv_trunc (max_size
, inner_size
);
3009 max_outer_nelts_tree
= wide_int_to_tree (sizetype
, max_outer_nelts
);
3011 size
= size_binop (MULT_EXPR
, size
, fold_convert (sizetype
, nelts
));
3013 if (INTEGER_CST
== TREE_CODE (outer_nelts
))
3015 if (tree_int_cst_lt (max_outer_nelts_tree
, outer_nelts
))
3017 /* When the array size is constant, check it at compile time
3018 to make sure it doesn't exceed the implementation-defined
3019 maximum, as required by C++ 14 (in C++ 11 this requirement
3020 isn't explicitly stated but it's enforced anyway -- see
3021 grokdeclarator in cp/decl.c). */
3022 if (complain
& tf_error
)
3023 error ("size of array is too large");
3024 return error_mark_node
;
3029 /* When a runtime check is necessary because the array size
3030 isn't constant, keep only the top-most seven bits (starting
3031 with the most significant non-zero bit) of the maximum size
3032 to compare the array size against, to simplify encoding the
3033 constant maximum size in the instruction stream. */
3035 unsigned shift
= (max_outer_nelts
.get_precision ()) - 7
3036 - wi::clz (max_outer_nelts
);
3037 max_outer_nelts
= (max_outer_nelts
>> shift
) << shift
;
3039 outer_nelts_check
= fold_build2 (LE_EXPR
, boolean_type_node
,
3041 max_outer_nelts_tree
);
3045 tree align_arg
= NULL_TREE
;
3046 if (type_has_new_extended_alignment (elt_type
))
3047 align_arg
= build_int_cst (align_type_node
, TYPE_ALIGN_UNIT (elt_type
));
3049 alloc_fn
= NULL_TREE
;
3051 /* If PLACEMENT is a single simple pointer type not passed by
3052 reference, prepare to capture it in a temporary variable. Do
3053 this now, since PLACEMENT will change in the calls below. */
3054 placement_first
= NULL_TREE
;
3055 if (vec_safe_length (*placement
) == 1
3056 && (TYPE_PTR_P (TREE_TYPE ((**placement
)[0]))))
3057 placement_first
= (**placement
)[0];
3059 bool member_new_p
= false;
3061 /* Allocate the object. */
3065 fnname
= ovl_op_identifier (false, array_p
? VEC_NEW_EXPR
: NEW_EXPR
);
3067 member_new_p
= !globally_qualified_p
3068 && CLASS_TYPE_P (elt_type
)
3070 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type
)
3071 : TYPE_HAS_NEW_OPERATOR (elt_type
));
3075 /* Use a class-specific operator new. */
3076 /* If a cookie is required, add some extra space. */
3077 if (array_p
&& TYPE_VEC_NEW_USES_COOKIE (elt_type
))
3078 size
= size_binop (PLUS_EXPR
, size
, cookie_size
);
3081 cookie_size
= NULL_TREE
;
3082 /* No size arithmetic necessary, so the size check is
3084 if (outer_nelts_check
!= NULL
&& inner_size
== 1)
3085 outer_nelts_check
= NULL_TREE
;
3087 /* Perform the overflow check. */
3088 tree errval
= TYPE_MAX_VALUE (sizetype
);
3089 if (cxx_dialect
>= cxx11
&& flag_exceptions
)
3090 errval
= throw_bad_array_new_length ();
3091 if (outer_nelts_check
!= NULL_TREE
)
3092 size
= fold_build3 (COND_EXPR
, sizetype
, outer_nelts_check
,
3094 /* Create the argument list. */
3095 vec_safe_insert (*placement
, 0, size
);
3096 /* Do name-lookup to find the appropriate operator. */
3097 fns
= lookup_fnfields (elt_type
, fnname
, /*protect=*/2);
3098 if (fns
== NULL_TREE
)
3100 if (complain
& tf_error
)
3101 error ("no suitable %qD found in class %qT", fnname
, elt_type
);
3102 return error_mark_node
;
3104 if (TREE_CODE (fns
) == TREE_LIST
)
3106 if (complain
& tf_error
)
3108 error ("request for member %qD is ambiguous", fnname
);
3109 print_candidates (fns
);
3111 return error_mark_node
;
3113 tree dummy
= build_dummy_object (elt_type
);
3114 alloc_call
= NULL_TREE
;
3117 vec
<tree
, va_gc
> *align_args
3118 = vec_copy_and_insert (*placement
, align_arg
, 1);
3120 = build_new_method_call (dummy
, fns
, &align_args
,
3121 /*conversion_path=*/NULL_TREE
,
3122 LOOKUP_NORMAL
, &alloc_fn
, tf_none
);
3123 /* If no matching function is found and the allocated object type
3124 has new-extended alignment, the alignment argument is removed
3125 from the argument list, and overload resolution is performed
3127 if (alloc_call
== error_mark_node
)
3128 alloc_call
= NULL_TREE
;
3131 alloc_call
= build_new_method_call (dummy
, fns
, placement
,
3132 /*conversion_path=*/NULL_TREE
,
3134 &alloc_fn
, complain
);
3138 /* Use a global operator new. */
3139 /* See if a cookie might be required. */
3140 if (!(array_p
&& TYPE_VEC_NEW_USES_COOKIE (elt_type
)))
3142 cookie_size
= NULL_TREE
;
3143 /* No size arithmetic necessary, so the size check is
3145 if (outer_nelts_check
!= NULL
&& inner_size
== 1)
3146 outer_nelts_check
= NULL_TREE
;
3149 alloc_call
= build_operator_new_call (fnname
, placement
,
3150 &size
, &cookie_size
,
3151 align_arg
, outer_nelts_check
,
3152 &alloc_fn
, complain
);
3155 if (alloc_call
== error_mark_node
)
3156 return error_mark_node
;
3158 gcc_assert (alloc_fn
!= NULL_TREE
);
3160 /* Now, check to see if this function is actually a placement
3161 allocation function. This can happen even when PLACEMENT is NULL
3162 because we might have something like:
3164 struct S { void* operator new (size_t, int i = 0); };
3166 A call to `new S' will get this allocation function, even though
3167 there is no explicit placement argument. If there is more than
3168 one argument, or there are variable arguments, then this is a
3169 placement allocation function. */
3170 placement_allocation_fn_p
3171 = (type_num_arguments (TREE_TYPE (alloc_fn
)) > 1
3172 || varargs_function_p (alloc_fn
));
3174 if (warn_aligned_new
3175 && !placement_allocation_fn_p
3176 && TYPE_ALIGN (elt_type
) > malloc_alignment ()
3177 && (warn_aligned_new
> 1
3178 || CP_DECL_CONTEXT (alloc_fn
) == global_namespace
)
3179 && !aligned_allocation_fn_p (alloc_fn
))
3181 if (warning (OPT_Waligned_new_
, "%<new%> of type %qT with extended "
3182 "alignment %d", elt_type
, TYPE_ALIGN_UNIT (elt_type
)))
3184 inform (input_location
, "uses %qD, which does not have an alignment "
3185 "parameter", alloc_fn
);
3186 if (!aligned_new_threshold
)
3187 inform (input_location
, "use %<-faligned-new%> to enable C++17 "
3188 "over-aligned new support");
3192 /* If we found a simple case of PLACEMENT_EXPR above, then copy it
3193 into a temporary variable. */
3194 if (!processing_template_decl
3195 && TREE_CODE (alloc_call
) == CALL_EXPR
3196 && call_expr_nargs (alloc_call
) == 2
3197 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 0))) == INTEGER_TYPE
3198 && TYPE_PTR_P (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 1))))
3200 tree placement
= CALL_EXPR_ARG (alloc_call
, 1);
3202 if (placement_first
!= NULL_TREE
3203 && (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement
)))
3204 || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement
)))))
3206 placement_expr
= get_target_expr (placement_first
);
3207 CALL_EXPR_ARG (alloc_call
, 1)
3208 = fold_convert (TREE_TYPE (placement
), placement_expr
);
3212 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (CALL_EXPR_ARG (alloc_call
, 1)))))
3214 /* Attempt to make the warning point at the operator new argument. */
3215 if (placement_first
)
3216 placement
= placement_first
;
3218 warn_placement_new_too_small (orig_type
, nelts
, size
, placement
);
3222 /* In the simple case, we can stop now. */
3223 pointer_type
= build_pointer_type (type
);
3224 if (!cookie_size
&& !is_initialized
)
3225 return build_nop (pointer_type
, alloc_call
);
3227 /* Store the result of the allocation call in a variable so that we can
3228 use it more than once. */
3229 alloc_expr
= get_target_expr (alloc_call
);
3230 alloc_node
= TARGET_EXPR_SLOT (alloc_expr
);
3232 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
3233 while (TREE_CODE (alloc_call
) == COMPOUND_EXPR
)
3234 alloc_call
= TREE_OPERAND (alloc_call
, 1);
3236 /* Preevaluate the placement args so that we don't reevaluate them for a
3237 placement delete. */
3238 if (placement_allocation_fn_p
)
3241 stabilize_call (alloc_call
, &inits
);
3243 alloc_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (alloc_expr
), inits
,
3247 /* unless an allocation function is declared with an empty excep-
3248 tion-specification (_except.spec_), throw(), it indicates failure to
3249 allocate storage by throwing a bad_alloc exception (clause _except_,
3250 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
3251 cation function is declared with an empty exception-specification,
3252 throw(), it returns null to indicate failure to allocate storage and a
3253 non-null pointer otherwise.
3255 So check for a null exception spec on the op new we just called. */
3257 nothrow
= TYPE_NOTHROW_P (TREE_TYPE (alloc_fn
));
3259 = flag_check_new
|| (nothrow
&& !std_placement_new_fn_p (alloc_fn
));
3267 /* Adjust so we're pointing to the start of the object. */
3268 data_addr
= fold_build_pointer_plus (alloc_node
, cookie_size
);
3270 /* Store the number of bytes allocated so that we can know how
3271 many elements to destroy later. We use the last sizeof
3272 (size_t) bytes to store the number of elements. */
3273 cookie_ptr
= size_binop (MINUS_EXPR
, cookie_size
, size_in_bytes (sizetype
));
3274 cookie_ptr
= fold_build_pointer_plus_loc (input_location
,
3275 alloc_node
, cookie_ptr
);
3276 size_ptr_type
= build_pointer_type (sizetype
);
3277 cookie_ptr
= fold_convert (size_ptr_type
, cookie_ptr
);
3278 cookie
= cp_build_fold_indirect_ref (cookie_ptr
);
3280 cookie_expr
= build2 (MODIFY_EXPR
, sizetype
, cookie
, nelts
);
3282 if (targetm
.cxx
.cookie_has_size ())
3284 /* Also store the element size. */
3285 cookie_ptr
= fold_build_pointer_plus (cookie_ptr
,
3286 fold_build1_loc (input_location
,
3287 NEGATE_EXPR
, sizetype
,
3288 size_in_bytes (sizetype
)));
3290 cookie
= cp_build_fold_indirect_ref (cookie_ptr
);
3291 cookie
= build2 (MODIFY_EXPR
, sizetype
, cookie
,
3292 size_in_bytes (elt_type
));
3293 cookie_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (cookie_expr
),
3294 cookie
, cookie_expr
);
3299 cookie_expr
= NULL_TREE
;
3300 data_addr
= alloc_node
;
3303 /* Now use a pointer to the type we've actually allocated. */
3305 /* But we want to operate on a non-const version to start with,
3306 since we'll be modifying the elements. */
3307 non_const_pointer_type
= build_pointer_type
3308 (cp_build_qualified_type (type
, cp_type_quals (type
) & ~TYPE_QUAL_CONST
));
3310 data_addr
= fold_convert (non_const_pointer_type
, data_addr
);
3311 /* Any further uses of alloc_node will want this type, too. */
3312 alloc_node
= fold_convert (non_const_pointer_type
, alloc_node
);
3314 /* Now initialize the allocated object. Note that we preevaluate the
3315 initialization expression, apart from the actual constructor call or
3316 assignment--we do this because we want to delay the allocation as long
3317 as possible in order to minimize the size of the exception region for
3318 placement delete. */
3322 bool explicit_value_init_p
= false;
3324 if (*init
!= NULL
&& (*init
)->is_empty ())
3327 explicit_value_init_p
= true;
3330 if (processing_template_decl
&& explicit_value_init_p
)
3332 /* build_value_init doesn't work in templates, and we don't need
3333 the initializer anyway since we're going to throw it away and
3334 rebuild it at instantiation time, so just build up a single
3335 constructor call to get any appropriate diagnostics. */
3336 init_expr
= cp_build_fold_indirect_ref (data_addr
);
3337 if (type_build_ctor_call (elt_type
))
3338 init_expr
= build_special_member_call (init_expr
,
3339 complete_ctor_identifier
,
3343 stable
= stabilize_init (init_expr
, &init_preeval_expr
);
3347 tree vecinit
= NULL_TREE
;
3348 if (vec_safe_length (*init
) == 1
3349 && DIRECT_LIST_INIT_P ((**init
)[0]))
3351 vecinit
= (**init
)[0];
3352 if (CONSTRUCTOR_NELTS (vecinit
) == 0)
3353 /* List-value-initialization, leave it alone. */;
3356 tree arraytype
, domain
;
3357 if (TREE_CONSTANT (nelts
))
3358 domain
= compute_array_index_type (NULL_TREE
, nelts
,
3361 /* We'll check the length at runtime. */
3363 arraytype
= build_cplus_array_type (type
, domain
);
3364 vecinit
= digest_init (arraytype
, vecinit
, complain
);
3369 if (complain
& tf_error
)
3370 permerror (input_location
,
3371 "parenthesized initializer in array new");
3373 return error_mark_node
;
3374 vecinit
= build_tree_list_vec (*init
);
3377 = build_vec_init (data_addr
,
3378 cp_build_binary_op (input_location
,
3379 MINUS_EXPR
, outer_nelts
,
3383 explicit_value_init_p
,
3387 /* An array initialization is stable because the initialization
3388 of each element is a full-expression, so the temporaries don't
3394 init_expr
= cp_build_fold_indirect_ref (data_addr
);
3396 if (type_build_ctor_call (type
) && !explicit_value_init_p
)
3398 init_expr
= build_special_member_call (init_expr
,
3399 complete_ctor_identifier
,
3404 else if (explicit_value_init_p
)
3406 /* Something like `new int()'. NO_CLEANUP is needed so
3407 we don't try and build a (possibly ill-formed)
3409 tree val
= build_value_init (type
, complain
| tf_no_cleanup
);
3410 if (val
== error_mark_node
)
3411 return error_mark_node
;
3412 init_expr
= build2 (INIT_EXPR
, type
, init_expr
, val
);
3418 /* We are processing something like `new int (10)', which
3419 means allocate an int, and initialize it with 10. */
3421 ie
= build_x_compound_expr_from_vec (*init
, "new initializer",
3423 init_expr
= cp_build_modify_expr (input_location
, init_expr
,
3424 INIT_EXPR
, ie
, complain
);
3426 /* If the initializer uses C++14 aggregate NSDMI that refer to the
3427 object being initialized, replace them now and don't try to
3429 bool had_placeholder
= false;
3430 if (!processing_template_decl
3431 && TREE_CODE (init_expr
) == INIT_EXPR
)
3432 TREE_OPERAND (init_expr
, 1)
3433 = replace_placeholders (TREE_OPERAND (init_expr
, 1),
3434 TREE_OPERAND (init_expr
, 0),
3436 stable
= (!had_placeholder
3437 && stabilize_init (init_expr
, &init_preeval_expr
));
3440 if (init_expr
== error_mark_node
)
3441 return error_mark_node
;
3443 /* If any part of the object initialization terminates by throwing an
3444 exception and a suitable deallocation function can be found, the
3445 deallocation function is called to free the memory in which the
3446 object was being constructed, after which the exception continues
3447 to propagate in the context of the new-expression. If no
3448 unambiguous matching deallocation function can be found,
3449 propagating the exception does not cause the object's memory to be
3451 if (flag_exceptions
)
3453 enum tree_code dcode
= array_p
? VEC_DELETE_EXPR
: DELETE_EXPR
;
3456 /* The Standard is unclear here, but the right thing to do
3457 is to use the same method for finding deallocation
3458 functions that we use for finding allocation functions. */
3459 cleanup
= (build_op_delete_call
3463 globally_qualified_p
,
3464 placement_allocation_fn_p
? alloc_call
: NULL_TREE
,
3471 /* This is much simpler if we were able to preevaluate all of
3472 the arguments to the constructor call. */
3474 /* CLEANUP is compiler-generated, so no diagnostics. */
3475 TREE_NO_WARNING (cleanup
) = true;
3476 init_expr
= build2 (TRY_CATCH_EXPR
, void_type_node
,
3477 init_expr
, cleanup
);
3478 /* Likewise, this try-catch is compiler-generated. */
3479 TREE_NO_WARNING (init_expr
) = true;
3482 /* Ack! First we allocate the memory. Then we set our sentry
3483 variable to true, and expand a cleanup that deletes the
3484 memory if sentry is true. Then we run the constructor, and
3485 finally clear the sentry.
3487 We need to do this because we allocate the space first, so
3488 if there are any temporaries with cleanups in the
3489 constructor args and we weren't able to preevaluate them, we
3490 need this EH region to extend until end of full-expression
3491 to preserve nesting. */
3493 tree end
, sentry
, begin
;
3495 begin
= get_target_expr (boolean_true_node
);
3496 CLEANUP_EH_ONLY (begin
) = 1;
3498 sentry
= TARGET_EXPR_SLOT (begin
);
3500 /* CLEANUP is compiler-generated, so no diagnostics. */
3501 TREE_NO_WARNING (cleanup
) = true;
3503 TARGET_EXPR_CLEANUP (begin
)
3504 = build3 (COND_EXPR
, void_type_node
, sentry
,
3505 cleanup
, void_node
);
3507 end
= build2 (MODIFY_EXPR
, TREE_TYPE (sentry
),
3508 sentry
, boolean_false_node
);
3511 = build2 (COMPOUND_EXPR
, void_type_node
, begin
,
3512 build2 (COMPOUND_EXPR
, void_type_node
, init_expr
,
3514 /* Likewise, this is compiler-generated. */
3515 TREE_NO_WARNING (init_expr
) = true;
3520 init_expr
= NULL_TREE
;
3522 /* Now build up the return value in reverse order. */
3527 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), init_expr
, rval
);
3529 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), cookie_expr
, rval
);
3531 if (rval
== data_addr
)
3532 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
3533 and return the call (which doesn't need to be adjusted). */
3534 rval
= TARGET_EXPR_INITIAL (alloc_expr
);
3539 tree ifexp
= cp_build_binary_op (input_location
,
3540 NE_EXPR
, alloc_node
,
3543 rval
= build_conditional_expr (input_location
, ifexp
, rval
,
3544 alloc_node
, complain
);
3547 /* Perform the allocation before anything else, so that ALLOC_NODE
3548 has been initialized before we start using it. */
3549 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
3552 if (init_preeval_expr
)
3553 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), init_preeval_expr
, rval
);
3555 /* A new-expression is never an lvalue. */
3556 gcc_assert (!obvalue_p (rval
));
3558 return convert (pointer_type
, rval
);
3561 /* Generate a representation for a C++ "new" expression. *PLACEMENT
3562 is a vector of placement-new arguments (or NULL if none). If NELTS
3563 is NULL, TYPE is the type of the storage to be allocated. If NELTS
3564 is not NULL, then this is an array-new allocation; TYPE is the type
3565 of the elements in the array and NELTS is the number of elements in
3566 the array. *INIT, if non-NULL, is the initializer for the new
3567 object, or an empty vector to indicate an initializer of "()". If
3568 USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
3569 rather than just "new". This may change PLACEMENT and INIT. */
3572 build_new (vec
<tree
, va_gc
> **placement
, tree type
, tree nelts
,
3573 vec
<tree
, va_gc
> **init
, int use_global_new
, tsubst_flags_t complain
)
3576 vec
<tree
, va_gc
> *orig_placement
= NULL
;
3577 tree orig_nelts
= NULL_TREE
;
3578 vec
<tree
, va_gc
> *orig_init
= NULL
;
3580 if (type
== error_mark_node
)
3581 return error_mark_node
;
3583 if (nelts
== NULL_TREE
3584 /* Don't do auto deduction where it might affect mangling. */
3585 && (!processing_template_decl
|| at_function_scope_p ()))
3587 tree auto_node
= type_uses_auto (type
);
3590 tree d_init
= NULL_TREE
;
3591 if (vec_safe_length (*init
) == 1)
3593 d_init
= (**init
)[0];
3594 d_init
= resolve_nondeduced_context (d_init
, complain
);
3596 type
= do_auto_deduction (type
, d_init
, auto_node
);
3600 if (processing_template_decl
)
3602 if (dependent_type_p (type
)
3603 || any_type_dependent_arguments_p (*placement
)
3604 || (nelts
&& type_dependent_expression_p (nelts
))
3606 || any_type_dependent_arguments_p (*init
))
3607 return build_raw_new_expr (*placement
, type
, nelts
, *init
,
3610 orig_placement
= make_tree_vector_copy (*placement
);
3614 orig_init
= make_tree_vector_copy (*init
);
3615 /* Also copy any CONSTRUCTORs in *init, since reshape_init and
3616 digest_init clobber them in place. */
3617 for (unsigned i
= 0; i
< orig_init
->length(); ++i
)
3619 tree e
= (**init
)[i
];
3620 if (TREE_CODE (e
) == CONSTRUCTOR
)
3621 (**init
)[i
] = copy_node (e
);
3625 make_args_non_dependent (*placement
);
3627 nelts
= build_non_dependent_expr (nelts
);
3628 make_args_non_dependent (*init
);
3633 if (!build_expr_type_conversion (WANT_INT
| WANT_ENUM
, nelts
, false))
3635 if (complain
& tf_error
)
3636 permerror (input_location
, "size in array new must have integral type");
3638 return error_mark_node
;
3641 /* Try to determine the constant value only for the purposes
3642 of the diagnostic below but continue to use the original
3643 value and handle const folding later. */
3644 const_tree cst_nelts
= maybe_constant_value (nelts
);
3646 /* The expression in a noptr-new-declarator is erroneous if it's of
3647 non-class type and its value before converting to std::size_t is
3648 less than zero. ... If the expression is a constant expression,
3649 the program is ill-fomed. */
3650 if (INTEGER_CST
== TREE_CODE (cst_nelts
)
3651 && tree_int_cst_sgn (cst_nelts
) == -1)
3653 if (complain
& tf_error
)
3654 error ("size of array is negative");
3655 return error_mark_node
;
3658 nelts
= mark_rvalue_use (nelts
);
3659 nelts
= cp_save_expr (cp_convert (sizetype
, nelts
, complain
));
3662 /* ``A reference cannot be created by the new operator. A reference
3663 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
3664 returned by new.'' ARM 5.3.3 */
3665 if (TREE_CODE (type
) == REFERENCE_TYPE
)
3667 if (complain
& tf_error
)
3668 error ("new cannot be applied to a reference type");
3670 return error_mark_node
;
3671 type
= TREE_TYPE (type
);
3674 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3676 if (complain
& tf_error
)
3677 error ("new cannot be applied to a function type");
3678 return error_mark_node
;
3681 /* The type allocated must be complete. If the new-type-id was
3682 "T[N]" then we are just checking that "T" is complete here, but
3683 that is equivalent, since the value of "N" doesn't matter. */
3684 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
3685 return error_mark_node
;
3687 rval
= build_new_1 (placement
, type
, nelts
, init
, use_global_new
, complain
);
3688 if (rval
== error_mark_node
)
3689 return error_mark_node
;
3691 if (processing_template_decl
)
3693 tree ret
= build_raw_new_expr (orig_placement
, type
, orig_nelts
,
3694 orig_init
, use_global_new
);
3695 release_tree_vector (orig_placement
);
3696 release_tree_vector (orig_init
);
3700 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
3701 rval
= build1 (NOP_EXPR
, TREE_TYPE (rval
), rval
);
3702 TREE_NO_WARNING (rval
) = 1;
3708 build_vec_delete_1 (tree base
, tree maxindex
, tree type
,
3709 special_function_kind auto_delete_vec
,
3710 int use_global_delete
, tsubst_flags_t complain
)
3713 tree ptype
= build_pointer_type (type
= complete_type (type
));
3716 /* Temporary variables used by the loop. */
3717 tree tbase
, tbase_init
;
3719 /* This is the body of the loop that implements the deletion of a
3720 single element, and moves temp variables to next elements. */
3723 /* This is the LOOP_EXPR that governs the deletion of the elements. */
3726 /* This is the thing that governs what to do after the loop has run. */
3727 tree deallocate_expr
= 0;
3729 /* This is the BIND_EXPR which holds the outermost iterator of the
3730 loop. It is convenient to set this variable up and test it before
3731 executing any other code in the loop.
3732 This is also the containing expression returned by this function. */
3733 tree controller
= NULL_TREE
;
3736 /* We should only have 1-D arrays here. */
3737 gcc_assert (TREE_CODE (type
) != ARRAY_TYPE
);
3739 if (base
== error_mark_node
|| maxindex
== error_mark_node
)
3740 return error_mark_node
;
3742 if (!COMPLETE_TYPE_P (type
))
3744 if ((complain
& tf_warning
)
3745 && warning (OPT_Wdelete_incomplete
,
3746 "possible problem detected in invocation of "
3747 "delete [] operator:"))
3749 cxx_incomplete_type_diagnostic (base
, type
, DK_WARNING
);
3750 inform (input_location
, "neither the destructor nor the "
3751 "class-specific operator delete [] will be called, "
3752 "even if they are declared when the class is defined");
3754 /* This size won't actually be used. */
3755 size_exp
= size_one_node
;
3759 size_exp
= size_in_bytes (type
);
3761 if (! MAYBE_CLASS_TYPE_P (type
))
3763 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
3765 /* Make sure the destructor is callable. */
3766 if (type_build_dtor_call (type
))
3768 tmp
= build_delete (ptype
, base
, sfk_complete_destructor
,
3769 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1,
3771 if (tmp
== error_mark_node
)
3772 return error_mark_node
;
3777 /* The below is short by the cookie size. */
3778 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
3779 fold_convert (sizetype
, maxindex
));
3781 tbase
= create_temporary_var (ptype
);
3783 = cp_build_modify_expr (input_location
, tbase
, NOP_EXPR
,
3784 fold_build_pointer_plus_loc (input_location
,
3785 fold_convert (ptype
,
3789 if (tbase_init
== error_mark_node
)
3790 return error_mark_node
;
3791 controller
= build3 (BIND_EXPR
, void_type_node
, tbase
,
3792 NULL_TREE
, NULL_TREE
);
3793 TREE_SIDE_EFFECTS (controller
) = 1;
3795 body
= build1 (EXIT_EXPR
, void_type_node
,
3796 build2 (EQ_EXPR
, boolean_type_node
, tbase
,
3797 fold_convert (ptype
, base
)));
3798 tmp
= fold_build1_loc (input_location
, NEGATE_EXPR
, sizetype
, size_exp
);
3799 tmp
= fold_build_pointer_plus (tbase
, tmp
);
3800 tmp
= cp_build_modify_expr (input_location
, tbase
, NOP_EXPR
, tmp
, complain
);
3801 if (tmp
== error_mark_node
)
3802 return error_mark_node
;
3803 body
= build_compound_expr (input_location
, body
, tmp
);
3804 tmp
= build_delete (ptype
, tbase
, sfk_complete_destructor
,
3805 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1,
3807 if (tmp
== error_mark_node
)
3808 return error_mark_node
;
3809 body
= build_compound_expr (input_location
, body
, tmp
);
3811 loop
= build1 (LOOP_EXPR
, void_type_node
, body
);
3812 loop
= build_compound_expr (input_location
, tbase_init
, loop
);
3815 /* Delete the storage if appropriate. */
3816 if (auto_delete_vec
== sfk_deleting_destructor
)
3820 /* The below is short by the cookie size. */
3821 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
3822 fold_convert (sizetype
, maxindex
));
3824 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
3831 cookie_size
= targetm
.cxx
.get_cookie_size (type
);
3832 base_tbd
= cp_build_binary_op (input_location
,
3834 cp_convert (string_type_node
,
3838 if (base_tbd
== error_mark_node
)
3839 return error_mark_node
;
3840 base_tbd
= cp_convert (ptype
, base_tbd
, complain
);
3841 /* True size with header. */
3842 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, cookie_size
);
3845 deallocate_expr
= build_op_delete_call (VEC_DELETE_EXPR
,
3846 base_tbd
, virtual_size
,
3847 use_global_delete
& 1,
3848 /*placement=*/NULL_TREE
,
3849 /*alloc_fn=*/NULL_TREE
,
3854 if (!deallocate_expr
)
3857 body
= deallocate_expr
;
3859 /* The delete operator mist be called, even if a destructor
3861 body
= build2 (TRY_FINALLY_EXPR
, void_type_node
, body
, deallocate_expr
);
3864 body
= integer_zero_node
;
3866 /* Outermost wrapper: If pointer is null, punt. */
3867 tree cond
= build2_loc (input_location
, NE_EXPR
, boolean_type_node
, base
,
3868 fold_convert (TREE_TYPE (base
), nullptr_node
));
3869 /* This is a compiler generated comparison, don't emit
3870 e.g. -Wnonnull-compare warning for it. */
3871 TREE_NO_WARNING (cond
) = 1;
3872 body
= build3_loc (input_location
, COND_EXPR
, void_type_node
,
3873 cond
, body
, integer_zero_node
);
3874 COND_EXPR_IS_VEC_DELETE (body
) = true;
3875 body
= build1 (NOP_EXPR
, void_type_node
, body
);
3879 TREE_OPERAND (controller
, 1) = body
;
3883 if (TREE_CODE (base
) == SAVE_EXPR
)
3884 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
3885 body
= build2 (COMPOUND_EXPR
, void_type_node
, base
, body
);
3887 return convert_to_void (body
, ICV_CAST
, complain
);
3890 /* Create an unnamed variable of the indicated TYPE. */
3893 create_temporary_var (tree type
)
3897 decl
= build_decl (input_location
,
3898 VAR_DECL
, NULL_TREE
, type
);
3899 TREE_USED (decl
) = 1;
3900 DECL_ARTIFICIAL (decl
) = 1;
3901 DECL_IGNORED_P (decl
) = 1;
3902 DECL_CONTEXT (decl
) = current_function_decl
;
3907 /* Create a new temporary variable of the indicated TYPE, initialized
3910 It is not entered into current_binding_level, because that breaks
3911 things when it comes time to do final cleanups (which take place
3912 "outside" the binding contour of the function). */
3915 get_temp_regvar (tree type
, tree init
)
3919 decl
= create_temporary_var (type
);
3920 add_decl_expr (decl
);
3922 finish_expr_stmt (cp_build_modify_expr (input_location
, decl
, INIT_EXPR
,
3923 init
, tf_warning_or_error
));
3928 /* Subroutine of build_vec_init. Returns true if assigning to an array of
3929 INNER_ELT_TYPE from INIT is trivial. */
3932 vec_copy_assign_is_trivial (tree inner_elt_type
, tree init
)
3934 tree fromtype
= inner_elt_type
;
3935 if (lvalue_p (init
))
3936 fromtype
= cp_build_reference_type (fromtype
, /*rval*/false);
3937 return is_trivially_xible (MODIFY_EXPR
, inner_elt_type
, fromtype
);
3940 /* Subroutine of build_vec_init: Check that the array has at least N
3941 elements. Other parameters are local variables in build_vec_init. */
3944 finish_length_check (tree atype
, tree iterator
, tree obase
, unsigned n
)
3946 tree nelts
= build_int_cst (ptrdiff_type_node
, n
- 1);
3947 if (TREE_CODE (atype
) != ARRAY_TYPE
)
3949 if (flag_exceptions
)
3951 tree c
= fold_build2 (LT_EXPR
, boolean_type_node
, iterator
,
3953 c
= build3 (COND_EXPR
, void_type_node
, c
,
3954 throw_bad_array_new_length (), void_node
);
3955 finish_expr_stmt (c
);
3957 /* Don't check an array new when -fno-exceptions. */
3959 else if (sanitize_flags_p (SANITIZE_BOUNDS
)
3960 && current_function_decl
!= NULL_TREE
)
3962 /* Make sure the last element of the initializer is in bounds. */
3964 (ubsan_instrument_bounds
3965 (input_location
, obase
, &nelts
, /*ignore_off_by_one*/false));
3969 /* `build_vec_init' returns tree structure that performs
3970 initialization of a vector of aggregate types.
3972 BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
3973 to the first element, of POINTER_TYPE.
3974 MAXINDEX is the maximum index of the array (one less than the
3975 number of elements). It is only used if BASE is a pointer or
3976 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
3978 INIT is the (possibly NULL) initializer.
3980 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All
3981 elements in the array are value-initialized.
3983 FROM_ARRAY is 0 if we should init everything with INIT
3984 (i.e., every element initialized from INIT).
3985 FROM_ARRAY is 1 if we should index into INIT in parallel
3986 with initialization of DECL.
3987 FROM_ARRAY is 2 if we should index into INIT in parallel,
3988 but use assignment instead of initialization. */
3991 build_vec_init (tree base
, tree maxindex
, tree init
,
3992 bool explicit_value_init_p
,
3993 int from_array
, tsubst_flags_t complain
)
3996 tree base2
= NULL_TREE
;
3997 tree itype
= NULL_TREE
;
3999 /* The type of BASE. */
4000 tree atype
= TREE_TYPE (base
);
4001 /* The type of an element in the array. */
4002 tree type
= TREE_TYPE (atype
);
4003 /* The element type reached after removing all outer array
4005 tree inner_elt_type
;
4006 /* The type of a pointer to an element in the array. */
4011 tree try_block
= NULL_TREE
;
4012 int num_initialized_elts
= 0;
4015 bool xvalue
= false;
4016 bool errors
= false;
4017 location_t loc
= (init
? EXPR_LOC_OR_LOC (init
, input_location
)
4018 : location_of (base
));
4020 if (TREE_CODE (atype
) == ARRAY_TYPE
&& TYPE_DOMAIN (atype
))
4021 maxindex
= array_type_nelts (atype
);
4023 if (maxindex
== NULL_TREE
|| maxindex
== error_mark_node
)
4024 return error_mark_node
;
4026 maxindex
= maybe_constant_value (maxindex
);
4027 if (explicit_value_init_p
)
4030 inner_elt_type
= strip_array_types (type
);
4032 /* Look through the TARGET_EXPR around a compound literal. */
4033 if (init
&& TREE_CODE (init
) == TARGET_EXPR
4034 && TREE_CODE (TARGET_EXPR_INITIAL (init
)) == CONSTRUCTOR
4036 init
= TARGET_EXPR_INITIAL (init
);
4038 bool direct_init
= false;
4039 if (from_array
&& init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
4040 && CONSTRUCTOR_NELTS (init
) == 1)
4042 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
4043 if (TREE_CODE (TREE_TYPE (elt
)) == ARRAY_TYPE
)
4045 direct_init
= DIRECT_LIST_INIT_P (init
);
4050 /* If we have a braced-init-list or string constant, make sure that the array
4051 is big enough for all the initializers. */
4052 bool length_check
= (init
4053 && (TREE_CODE (init
) == STRING_CST
4054 || (TREE_CODE (init
) == CONSTRUCTOR
4055 && CONSTRUCTOR_NELTS (init
) > 0))
4056 && !TREE_CONSTANT (maxindex
));
4059 && TREE_CODE (atype
) == ARRAY_TYPE
4060 && TREE_CONSTANT (maxindex
)
4062 ? vec_copy_assign_is_trivial (inner_elt_type
, init
)
4063 : !TYPE_NEEDS_CONSTRUCTING (type
))
4064 && ((TREE_CODE (init
) == CONSTRUCTOR
4065 && (BRACE_ENCLOSED_INITIALIZER_P (init
)
4066 || (same_type_ignoring_top_level_qualifiers_p
4067 (atype
, TREE_TYPE (init
))))
4068 /* Don't do this if the CONSTRUCTOR might contain something
4069 that might throw and require us to clean up. */
4070 && (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
))
4071 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type
)))
4074 /* Do non-default initialization of trivial arrays resulting from
4075 brace-enclosed initializers. In this case, digest_init and
4076 store_constructor will handle the semantics for us. */
4078 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
4079 init
= digest_init (atype
, init
, complain
);
4080 stmt_expr
= build2 (INIT_EXPR
, atype
, base
, init
);
4084 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
, complain
);
4085 maxindex
= fold_simple (maxindex
);
4087 if (TREE_CODE (atype
) == ARRAY_TYPE
)
4089 ptype
= build_pointer_type (type
);
4090 base
= decay_conversion (base
, complain
);
4091 if (base
== error_mark_node
)
4092 return error_mark_node
;
4093 base
= cp_convert (ptype
, base
, complain
);
4098 /* The code we are generating looks like:
4102 ptrdiff_t iterator = maxindex;
4104 for (; iterator != -1; --iterator) {
4105 ... initialize *t1 ...
4109 ... destroy elements that were constructed ...
4114 We can omit the try and catch blocks if we know that the
4115 initialization will never throw an exception, or if the array
4116 elements do not have destructors. We can omit the loop completely if
4117 the elements of the array do not have constructors.
4119 We actually wrap the entire body of the above in a STMT_EXPR, for
4122 When copying from array to another, when the array elements have
4123 only trivial copy constructors, we should use __builtin_memcpy
4124 rather than generating a loop. That way, we could take advantage
4125 of whatever cleverness the back end has for dealing with copies
4126 of blocks of memory. */
4128 is_global
= begin_init_stmts (&stmt_expr
, &compound_stmt
);
4129 destroy_temps
= stmts_are_full_exprs_p ();
4130 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
4131 rval
= get_temp_regvar (ptype
, base
);
4132 base
= get_temp_regvar (ptype
, rval
);
4133 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
4135 /* If initializing one array from another, initialize element by
4136 element. We rely upon the below calls to do the argument
4137 checking. Evaluate the initializer before entering the try block. */
4138 if (from_array
&& init
&& TREE_CODE (init
) != CONSTRUCTOR
)
4140 if (lvalue_kind (init
) & clk_rvalueref
)
4142 base2
= decay_conversion (init
, complain
);
4143 if (base2
== error_mark_node
)
4144 return error_mark_node
;
4145 itype
= TREE_TYPE (base2
);
4146 base2
= get_temp_regvar (itype
, base2
);
4147 itype
= TREE_TYPE (itype
);
4150 /* Protect the entire array initialization so that we can destroy
4151 the partially constructed array if an exception is thrown.
4152 But don't do this if we're assigning. */
4153 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
4156 try_block
= begin_try_block ();
4159 /* Should we try to create a constant initializer? */
4160 bool try_const
= (TREE_CODE (atype
) == ARRAY_TYPE
4161 && TREE_CONSTANT (maxindex
)
4162 && (init
? TREE_CODE (init
) == CONSTRUCTOR
4163 : (type_has_constexpr_default_constructor
4165 && (literal_type_p (inner_elt_type
)
4166 || TYPE_HAS_CONSTEXPR_CTOR (inner_elt_type
)));
4167 vec
<constructor_elt
, va_gc
> *const_vec
= NULL
;
4168 bool saw_non_const
= false;
4169 /* If we're initializing a static array, we want to do static
4170 initialization of any elements with constant initializers even if
4171 some are non-constant. */
4172 bool do_static_init
= (DECL_P (obase
) && TREE_STATIC (obase
));
4174 bool empty_list
= false;
4175 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
4176 && CONSTRUCTOR_NELTS (init
) == 0)
4177 /* Skip over the handling of non-empty init lists. */
4180 /* Maybe pull out constant value when from_array? */
4182 else if (init
!= NULL_TREE
&& TREE_CODE (init
) == CONSTRUCTOR
)
4184 /* Do non-default initialization of non-trivial arrays resulting from
4185 brace-enclosed initializers. */
4186 unsigned HOST_WIDE_INT idx
;
4188 /* If the constructor already has the array type, it's been through
4189 digest_init, so we shouldn't try to do anything more. */
4190 bool digested
= same_type_p (atype
, TREE_TYPE (init
));
4194 finish_length_check (atype
, iterator
, obase
, CONSTRUCTOR_NELTS (init
));
4197 vec_alloc (const_vec
, CONSTRUCTOR_NELTS (init
));
4199 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
, field
, elt
)
4201 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
4204 num_initialized_elts
++;
4206 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
4208 one_init
= build2 (INIT_EXPR
, type
, baseref
, elt
);
4209 else if (MAYBE_CLASS_TYPE_P (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
4210 one_init
= build_aggr_init (baseref
, elt
, 0, complain
);
4212 one_init
= cp_build_modify_expr (input_location
, baseref
,
4213 NOP_EXPR
, elt
, complain
);
4214 if (one_init
== error_mark_node
)
4218 tree e
= maybe_constant_init (one_init
);
4219 if (reduced_constant_expression_p (e
))
4221 CONSTRUCTOR_APPEND_ELT (const_vec
, field
, e
);
4223 one_init
= NULL_TREE
;
4225 one_init
= build2 (INIT_EXPR
, type
, baseref
, e
);
4231 tree value
= build_zero_init (TREE_TYPE (e
), NULL_TREE
,
4234 CONSTRUCTOR_APPEND_ELT (const_vec
, field
, value
);
4236 saw_non_const
= true;
4241 finish_expr_stmt (one_init
);
4242 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
4244 one_init
= cp_build_unary_op (PREINCREMENT_EXPR
, base
, false,
4246 if (one_init
== error_mark_node
)
4249 finish_expr_stmt (one_init
);
4251 one_init
= cp_build_unary_op (PREDECREMENT_EXPR
, iterator
, false,
4253 if (one_init
== error_mark_node
)
4256 finish_expr_stmt (one_init
);
4259 /* Any elements without explicit initializers get T{}. */
4262 else if (init
&& TREE_CODE (init
) == STRING_CST
)
4264 /* Check that the array is at least as long as the string. */
4266 finish_length_check (atype
, iterator
, obase
,
4267 TREE_STRING_LENGTH (init
));
4268 tree length
= build_int_cst (ptrdiff_type_node
,
4269 TREE_STRING_LENGTH (init
));
4271 /* Copy the string to the first part of the array. */
4272 tree alias_set
= build_int_cst (build_pointer_type (type
), 0);
4273 tree lhs
= build2 (MEM_REF
, TREE_TYPE (init
), base
, alias_set
);
4274 tree stmt
= build2 (MODIFY_EXPR
, void_type_node
, lhs
, init
);
4275 finish_expr_stmt (stmt
);
4277 /* Adjust the counter and pointer. */
4278 stmt
= cp_build_binary_op (loc
, MINUS_EXPR
, iterator
, length
, complain
);
4279 stmt
= build2 (MODIFY_EXPR
, void_type_node
, iterator
, stmt
);
4280 finish_expr_stmt (stmt
);
4282 stmt
= cp_build_binary_op (loc
, PLUS_EXPR
, base
, length
, complain
);
4283 stmt
= build2 (MODIFY_EXPR
, void_type_node
, base
, stmt
);
4284 finish_expr_stmt (stmt
);
4286 /* And set the rest of the array to NUL. */
4288 explicit_value_init_p
= true;
4290 else if (from_array
)
4293 /* OK, we set base2 above. */;
4294 else if (CLASS_TYPE_P (type
)
4295 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
4297 if (complain
& tf_error
)
4298 error ("initializer ends prematurely");
4303 /* Now, default-initialize any remaining elements. We don't need to
4304 do that if a) the type does not need constructing, or b) we've
4305 already initialized all the elements.
4307 We do need to keep going if we're copying an array. */
4309 if (try_const
&& !init
)
4310 /* With a constexpr default constructor, which we checked for when
4311 setting try_const above, default-initialization is equivalent to
4312 value-initialization, and build_value_init gives us something more
4313 friendly to maybe_constant_init. */
4314 explicit_value_init_p
= true;
4316 || ((type_build_ctor_call (type
) || init
|| explicit_value_init_p
)
4317 && ! (tree_fits_shwi_p (maxindex
)
4318 && (num_initialized_elts
4319 == tree_to_shwi (maxindex
) + 1))))
4321 /* If the ITERATOR is lesser or equal to -1, then we don't have to loop;
4322 we've already initialized all the elements. */
4327 for_stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
4328 finish_init_stmt (for_stmt
);
4329 finish_for_cond (build2 (GT_EXPR
, boolean_type_node
, iterator
,
4330 build_int_cst (TREE_TYPE (iterator
), -1)),
4332 elt_init
= cp_build_unary_op (PREDECREMENT_EXPR
, iterator
, false,
4334 if (elt_init
== error_mark_node
)
4336 finish_for_expr (elt_init
, for_stmt
);
4338 to
= build1 (INDIRECT_REF
, type
, base
);
4340 /* If the initializer is {}, then all elements are initialized from T{}.
4341 But for non-classes, that's the same as value-initialization. */
4344 if (cxx_dialect
>= cxx11
&& AGGREGATE_TYPE_P (type
))
4346 init
= build_constructor (init_list_type_node
, NULL
);
4351 explicit_value_init_p
= true;
4361 from
= build1 (INDIRECT_REF
, itype
, base2
);
4365 from
= build_tree_list (NULL_TREE
, from
);
4370 if (from_array
== 2)
4371 elt_init
= cp_build_modify_expr (input_location
, to
, NOP_EXPR
,
4373 else if (type_build_ctor_call (type
))
4374 elt_init
= build_aggr_init (to
, from
, 0, complain
);
4376 elt_init
= cp_build_modify_expr (input_location
, to
, NOP_EXPR
, from
,
4381 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4383 if (init
&& !BRACE_ENCLOSED_INITIALIZER_P (init
))
4385 ("cannot initialize multi-dimensional array with initializer");
4386 elt_init
= build_vec_init (build1 (INDIRECT_REF
, type
, base
),
4388 explicit_value_init_p
,
4391 else if (explicit_value_init_p
)
4393 elt_init
= build_value_init (type
, complain
);
4394 if (elt_init
!= error_mark_node
)
4395 elt_init
= build2 (INIT_EXPR
, type
, to
, elt_init
);
4399 gcc_assert (type_build_ctor_call (type
) || init
);
4400 if (CLASS_TYPE_P (type
))
4401 elt_init
= build_aggr_init (to
, init
, 0, complain
);
4404 if (TREE_CODE (init
) == TREE_LIST
)
4405 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
4407 elt_init
= build2 (INIT_EXPR
, type
, to
, init
);
4411 if (elt_init
== error_mark_node
)
4416 /* FIXME refs to earlier elts */
4417 tree e
= maybe_constant_init (elt_init
);
4418 if (reduced_constant_expression_p (e
))
4420 if (initializer_zerop (e
))
4421 /* Don't fill the CONSTRUCTOR with zeros. */
4424 elt_init
= NULL_TREE
;
4428 saw_non_const
= true;
4430 e
= build_zero_init (TREE_TYPE (e
), NULL_TREE
, true);
4437 int max
= tree_to_shwi (maxindex
)+1;
4438 for (; num_initialized_elts
< max
; ++num_initialized_elts
)
4440 tree field
= size_int (num_initialized_elts
);
4441 CONSTRUCTOR_APPEND_ELT (const_vec
, field
, e
);
4446 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
4448 finish_expr_stmt (elt_init
);
4449 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
4451 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR
, base
, false,
4454 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR
, base2
, false,
4457 finish_for_stmt (for_stmt
);
4460 /* Make sure to cleanup any partially constructed elements. */
4461 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
4465 tree m
= cp_build_binary_op (input_location
,
4466 MINUS_EXPR
, maxindex
, iterator
,
4469 /* Flatten multi-dimensional array since build_vec_delete only
4470 expects one-dimensional array. */
4471 if (TREE_CODE (type
) == ARRAY_TYPE
)
4472 m
= cp_build_binary_op (input_location
,
4474 /* Avoid mixing signed and unsigned. */
4475 convert (TREE_TYPE (m
),
4476 array_type_nelts_total (type
)),
4479 finish_cleanup_try_block (try_block
);
4480 e
= build_vec_delete_1 (rval
, m
,
4481 inner_elt_type
, sfk_complete_destructor
,
4482 /*use_global_delete=*/0, complain
);
4483 if (e
== error_mark_node
)
4485 finish_cleanup (e
, try_block
);
4488 /* The value of the array initialization is the array itself, RVAL
4489 is a pointer to the first element. */
4490 finish_stmt_expr_expr (rval
, stmt_expr
);
4492 stmt_expr
= finish_init_stmts (is_global
, stmt_expr
, compound_stmt
);
4494 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
4497 return error_mark_node
;
4503 tree const_init
= build_constructor (atype
, const_vec
);
4504 return build2 (INIT_EXPR
, atype
, obase
, const_init
);
4506 else if (do_static_init
&& !vec_safe_is_empty (const_vec
))
4507 DECL_INITIAL (obase
) = build_constructor (atype
, const_vec
);
4509 vec_free (const_vec
);
4512 /* Now make the result have the correct type. */
4513 if (TREE_CODE (atype
) == ARRAY_TYPE
)
4515 atype
= build_pointer_type (atype
);
4516 stmt_expr
= build1 (NOP_EXPR
, atype
, stmt_expr
);
4517 stmt_expr
= cp_build_fold_indirect_ref (stmt_expr
);
4518 TREE_NO_WARNING (stmt_expr
) = 1;
4524 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
4528 build_dtor_call (tree exp
, special_function_kind dtor_kind
, int flags
,
4529 tsubst_flags_t complain
)
4535 case sfk_complete_destructor
:
4536 name
= complete_dtor_identifier
;
4539 case sfk_base_destructor
:
4540 name
= base_dtor_identifier
;
4543 case sfk_deleting_destructor
:
4544 name
= deleting_dtor_identifier
;
4550 fn
= lookup_fnfields (TREE_TYPE (exp
), name
, /*protect=*/2);
4551 return build_new_method_call (exp
, fn
,
4553 /*conversion_path=*/NULL_TREE
,
4559 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
4560 ADDR is an expression which yields the store to be destroyed.
4561 AUTO_DELETE is the name of the destructor to call, i.e., either
4562 sfk_complete_destructor, sfk_base_destructor, or
4563 sfk_deleting_destructor.
4565 FLAGS is the logical disjunction of zero or more LOOKUP_
4566 flags. See cp-tree.h for more info. */
4569 build_delete (tree otype
, tree addr
, special_function_kind auto_delete
,
4570 int flags
, int use_global_delete
, tsubst_flags_t complain
)
4574 if (addr
== error_mark_node
)
4575 return error_mark_node
;
4577 tree type
= TYPE_MAIN_VARIANT (otype
);
4579 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
4580 set to `error_mark_node' before it gets properly cleaned up. */
4581 if (type
== error_mark_node
)
4582 return error_mark_node
;
4584 if (TREE_CODE (type
) == POINTER_TYPE
)
4585 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
4587 if (TREE_CODE (type
) == ARRAY_TYPE
)
4589 if (TYPE_DOMAIN (type
) == NULL_TREE
)
4591 if (complain
& tf_error
)
4592 error ("unknown array size in delete");
4593 return error_mark_node
;
4595 return build_vec_delete (addr
, array_type_nelts (type
),
4596 auto_delete
, use_global_delete
, complain
);
4599 if (TYPE_PTR_P (otype
))
4601 addr
= mark_rvalue_use (addr
);
4603 /* We don't want to warn about delete of void*, only other
4604 incomplete types. Deleting other incomplete types
4605 invokes undefined behavior, but it is not ill-formed, so
4606 compile to something that would even do The Right Thing
4607 (TM) should the type have a trivial dtor and no delete
4609 if (!VOID_TYPE_P (type
))
4611 complete_type (type
);
4612 if (!COMPLETE_TYPE_P (type
))
4614 if ((complain
& tf_warning
)
4615 && warning (OPT_Wdelete_incomplete
,
4616 "possible problem detected in invocation of "
4617 "delete operator:"))
4619 cxx_incomplete_type_diagnostic (addr
, type
, DK_WARNING
);
4620 inform (input_location
,
4621 "neither the destructor nor the class-specific "
4622 "operator delete will be called, even if they are "
4623 "declared when the class is defined");
4626 else if (auto_delete
== sfk_deleting_destructor
&& warn_delnonvdtor
4627 && MAYBE_CLASS_TYPE_P (type
) && !CLASSTYPE_FINAL (type
)
4628 && TYPE_POLYMORPHIC_P (type
))
4630 tree dtor
= CLASSTYPE_DESTRUCTOR (type
);
4631 if (!dtor
|| !DECL_VINDEX (dtor
))
4633 if (CLASSTYPE_PURE_VIRTUALS (type
))
4634 warning (OPT_Wdelete_non_virtual_dtor
,
4635 "deleting object of abstract class type %qT"
4636 " which has non-virtual destructor"
4637 " will cause undefined behavior", type
);
4639 warning (OPT_Wdelete_non_virtual_dtor
,
4640 "deleting object of polymorphic class type %qT"
4641 " which has non-virtual destructor"
4642 " might cause undefined behavior", type
);
4646 if (TREE_SIDE_EFFECTS (addr
))
4647 addr
= save_expr (addr
);
4649 /* Throw away const and volatile on target type of addr. */
4650 addr
= convert_force (build_pointer_type (type
), addr
, 0, complain
);
4654 /* Don't check PROTECT here; leave that decision to the
4655 destructor. If the destructor is accessible, call it,
4656 else report error. */
4657 addr
= cp_build_addr_expr (addr
, complain
);
4658 if (addr
== error_mark_node
)
4659 return error_mark_node
;
4660 if (TREE_SIDE_EFFECTS (addr
))
4661 addr
= save_expr (addr
);
4663 addr
= convert_force (build_pointer_type (type
), addr
, 0, complain
);
4666 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
4668 /* Make sure the destructor is callable. */
4669 if (type_build_dtor_call (type
))
4671 expr
= build_dtor_call (cp_build_fold_indirect_ref (addr
),
4672 sfk_complete_destructor
, flags
, complain
);
4673 if (expr
== error_mark_node
)
4674 return error_mark_node
;
4677 if (auto_delete
!= sfk_deleting_destructor
)
4680 return build_op_delete_call (DELETE_EXPR
, addr
,
4681 cxx_sizeof_nowarn (type
),
4683 /*placement=*/NULL_TREE
,
4684 /*alloc_fn=*/NULL_TREE
,
4689 tree head
= NULL_TREE
;
4690 tree do_delete
= NULL_TREE
;
4693 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
4694 lazily_declare_fn (sfk_destructor
, type
);
4696 /* For `::delete x', we must not use the deleting destructor
4697 since then we would not be sure to get the global `operator
4699 if (use_global_delete
&& auto_delete
== sfk_deleting_destructor
)
4701 /* We will use ADDR multiple times so we must save it. */
4702 addr
= save_expr (addr
);
4703 head
= get_target_expr (build_headof (addr
));
4704 /* Delete the object. */
4705 do_delete
= build_op_delete_call (DELETE_EXPR
,
4707 cxx_sizeof_nowarn (type
),
4709 /*placement=*/NULL_TREE
,
4710 /*alloc_fn=*/NULL_TREE
,
4712 /* Otherwise, treat this like a complete object destructor
4714 auto_delete
= sfk_complete_destructor
;
4716 /* If the destructor is non-virtual, there is no deleting
4717 variant. Instead, we must explicitly call the appropriate
4718 `operator delete' here. */
4719 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTOR (type
))
4720 && auto_delete
== sfk_deleting_destructor
)
4722 /* We will use ADDR multiple times so we must save it. */
4723 addr
= save_expr (addr
);
4724 /* Build the call. */
4725 do_delete
= build_op_delete_call (DELETE_EXPR
,
4727 cxx_sizeof_nowarn (type
),
4729 /*placement=*/NULL_TREE
,
4730 /*alloc_fn=*/NULL_TREE
,
4732 /* Call the complete object destructor. */
4733 auto_delete
= sfk_complete_destructor
;
4735 else if (auto_delete
== sfk_deleting_destructor
4736 && TYPE_GETS_REG_DELETE (type
))
4738 /* Make sure we have access to the member op delete, even though
4739 we'll actually be calling it from the destructor. */
4740 build_op_delete_call (DELETE_EXPR
, addr
, cxx_sizeof_nowarn (type
),
4742 /*placement=*/NULL_TREE
,
4743 /*alloc_fn=*/NULL_TREE
,
4747 expr
= build_dtor_call (cp_build_fold_indirect_ref (addr
),
4748 auto_delete
, flags
, complain
);
4749 if (expr
== error_mark_node
)
4750 return error_mark_node
;
4752 /* The delete operator must be called, regardless of whether
4753 the destructor throws.
4755 [expr.delete]/7 The deallocation function is called
4756 regardless of whether the destructor for the object or some
4757 element of the array throws an exception. */
4758 expr
= build2 (TRY_FINALLY_EXPR
, void_type_node
, expr
, do_delete
);
4760 /* We need to calculate this before the dtor changes the vptr. */
4762 expr
= build2 (COMPOUND_EXPR
, void_type_node
, head
, expr
);
4764 if (flags
& LOOKUP_DESTRUCTOR
)
4765 /* Explicit destructor call; don't check for null pointer. */
4766 ifexp
= integer_one_node
;
4769 /* Handle deleting a null pointer. */
4770 warning_sentinel
s (warn_address
);
4771 ifexp
= cp_build_binary_op (input_location
, NE_EXPR
, addr
,
4772 nullptr_node
, complain
);
4773 if (ifexp
== error_mark_node
)
4774 return error_mark_node
;
4775 /* This is a compiler generated comparison, don't emit
4776 e.g. -Wnonnull-compare warning for it. */
4777 else if (TREE_CODE (ifexp
) == NE_EXPR
)
4778 TREE_NO_WARNING (ifexp
) = 1;
4781 if (ifexp
!= integer_one_node
)
4782 expr
= build3 (COND_EXPR
, void_type_node
, ifexp
, expr
, void_node
);
4788 /* At the beginning of a destructor, push cleanups that will call the
4789 destructors for our base classes and members.
4791 Called from begin_destructor_body. */
4794 push_base_cleanups (void)
4796 tree binfo
, base_binfo
;
4800 vec
<tree
, va_gc
> *vbases
;
4802 /* Run destructors for all virtual baseclasses. */
4803 if (!ABSTRACT_CLASS_TYPE_P (current_class_type
)
4804 && CLASSTYPE_VBASECLASSES (current_class_type
))
4806 tree cond
= (condition_conversion
4807 (build2 (BIT_AND_EXPR
, integer_type_node
,
4808 current_in_charge_parm
,
4809 integer_two_node
)));
4811 /* The CLASSTYPE_VBASECLASSES vector is in initialization
4812 order, which is also the right order for pushing cleanups. */
4813 for (vbases
= CLASSTYPE_VBASECLASSES (current_class_type
), i
= 0;
4814 vec_safe_iterate (vbases
, i
, &base_binfo
); i
++)
4816 if (type_build_dtor_call (BINFO_TYPE (base_binfo
)))
4818 expr
= build_special_member_call (current_class_ref
,
4819 base_dtor_identifier
,
4823 | LOOKUP_NONVIRTUAL
),
4824 tf_warning_or_error
);
4825 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
4827 expr
= build3 (COND_EXPR
, void_type_node
, cond
,
4829 finish_decl_cleanup (NULL_TREE
, expr
);
4835 /* Take care of the remaining baseclasses. */
4836 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
4837 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
4839 if (BINFO_VIRTUAL_P (base_binfo
)
4840 || !type_build_dtor_call (BINFO_TYPE (base_binfo
)))
4843 expr
= build_special_member_call (current_class_ref
,
4844 base_dtor_identifier
,
4846 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
4847 tf_warning_or_error
);
4848 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
4849 finish_decl_cleanup (NULL_TREE
, expr
);
4852 /* Don't automatically destroy union members. */
4853 if (TREE_CODE (current_class_type
) == UNION_TYPE
)
4856 for (member
= TYPE_FIELDS (current_class_type
); member
;
4857 member
= DECL_CHAIN (member
))
4859 tree this_type
= TREE_TYPE (member
);
4860 if (this_type
== error_mark_node
4861 || TREE_CODE (member
) != FIELD_DECL
4862 || DECL_ARTIFICIAL (member
))
4864 if (ANON_AGGR_TYPE_P (this_type
))
4866 if (type_build_dtor_call (this_type
))
4868 tree this_member
= (build_class_member_access_expr
4869 (current_class_ref
, member
,
4870 /*access_path=*/NULL_TREE
,
4871 /*preserve_reference=*/false,
4872 tf_warning_or_error
));
4873 expr
= build_delete (this_type
, this_member
,
4874 sfk_complete_destructor
,
4875 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
,
4876 0, tf_warning_or_error
);
4877 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (this_type
))
4878 finish_decl_cleanup (NULL_TREE
, expr
);
4883 /* Build a C++ vector delete expression.
4884 MAXINDEX is the number of elements to be deleted.
4885 ELT_SIZE is the nominal size of each element in the vector.
4886 BASE is the expression that should yield the store to be deleted.
4887 This function expands (or synthesizes) these calls itself.
4888 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
4890 This also calls delete for virtual baseclasses of elements of the vector.
4892 Update: MAXINDEX is no longer needed. The size can be extracted from the
4893 start of the vector for pointers, and from the type for arrays. We still
4894 use MAXINDEX for arrays because it happens to already have one of the
4895 values we'd have to extract. (We could use MAXINDEX with pointers to
4896 confirm the size, and trap if the numbers differ; not clear that it'd
4897 be worth bothering.) */
4900 build_vec_delete (tree base
, tree maxindex
,
4901 special_function_kind auto_delete_vec
,
4902 int use_global_delete
, tsubst_flags_t complain
)
4906 tree base_init
= NULL_TREE
;
4908 type
= TREE_TYPE (base
);
4910 if (TYPE_PTR_P (type
))
4912 /* Step back one from start of vector, and read dimension. */
4914 tree size_ptr_type
= build_pointer_type (sizetype
);
4916 base
= mark_rvalue_use (base
);
4917 if (TREE_SIDE_EFFECTS (base
))
4919 base_init
= get_target_expr (base
);
4920 base
= TARGET_EXPR_SLOT (base_init
);
4922 type
= strip_array_types (TREE_TYPE (type
));
4923 cookie_addr
= fold_build1_loc (input_location
, NEGATE_EXPR
,
4924 sizetype
, TYPE_SIZE_UNIT (sizetype
));
4925 cookie_addr
= fold_build_pointer_plus (fold_convert (size_ptr_type
, base
),
4927 maxindex
= cp_build_fold_indirect_ref (cookie_addr
);
4929 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4931 /* Get the total number of things in the array, maxindex is a
4933 maxindex
= array_type_nelts_total (type
);
4934 type
= strip_array_types (type
);
4935 base
= decay_conversion (base
, complain
);
4936 if (base
== error_mark_node
)
4937 return error_mark_node
;
4938 if (TREE_SIDE_EFFECTS (base
))
4940 base_init
= get_target_expr (base
);
4941 base
= TARGET_EXPR_SLOT (base_init
);
4946 if (base
!= error_mark_node
&& !(complain
& tf_error
))
4947 error ("type to vector delete is neither pointer or array type");
4948 return error_mark_node
;
4951 rval
= build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
,
4952 use_global_delete
, complain
);
4953 if (base_init
&& rval
!= error_mark_node
)
4954 rval
= build2 (COMPOUND_EXPR
, TREE_TYPE (rval
), base_init
, rval
);
4959 #include "gt-cp-init.h"