1/* Handle initialization things in -*- C++ -*-
2 Copyright (C) 1987-2025 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 3, or (at your option)
10any later version.
11
12GCC is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21/* High-level class interface. */
22
23#include "config.h"
24#include "system.h"
25#include "coretypes.h"
26#include "target.h"
27#include "cp-tree.h"
28#include "stringpool.h"
29#include "varasm.h"
30#include "gimplify.h"
31#include "c-family/c-ubsan.h"
32#include "intl.h"
33#include "stringpool.h"
34#include "attribs.h"
35#include "asan.h"
36#include "stor-layout.h"
37#include "pointer-query.h"
38
39static bool begin_init_stmts (tree *, tree *);
40static tree finish_init_stmts (bool, tree, tree);
41static void construct_virtual_base (tree, tree);
42static bool expand_aggr_init_1 (tree, tree, tree, tree, int, tsubst_flags_t);
43static bool expand_default_init (tree, tree, tree, tree, int, tsubst_flags_t);
44static int member_init_ok_or_else (tree, tree, tree);
45static void expand_virtual_init (tree, tree);
46static tree sort_mem_initializers (tree, tree);
47static tree initializing_context (tree);
48static void expand_cleanup_for_base (tree, tree);
49static tree dfs_initialize_vtbl_ptrs (tree, void *);
50static tree build_field_list (tree, tree, int *);
51static int diagnose_uninitialized_cst_or_ref_member_1 (tree, tree, bool, bool);
52
53static GTY(()) tree fn;
54
55/* We are about to generate some complex initialization code.
56 Conceptually, it is all a single expression. However, we may want
57 to include conditionals, loops, and other such statement-level
58 constructs. Therefore, we build the initialization code inside a
59 statement-expression. This function starts such an expression.
60 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
61 pass them back to finish_init_stmts when the expression is
62 complete. */
63
64static bool
65begin_init_stmts (tree *stmt_expr_p, tree *compound_stmt_p)
66{
67 bool is_global = !building_stmt_list_p ();
68
69 *stmt_expr_p = begin_stmt_expr ();
70 *compound_stmt_p = begin_compound_stmt (BCS_NO_SCOPE);
71
72 return is_global;
73}
74
75/* Finish out the statement-expression begun by the previous call to
76 begin_init_stmts. Returns the statement-expression itself. */
77
78static tree
79finish_init_stmts (bool is_global, tree stmt_expr, tree compound_stmt)
80{
81 finish_compound_stmt (compound_stmt);
82
83 stmt_expr = finish_stmt_expr (stmt_expr, true);
84
85 gcc_assert (!building_stmt_list_p () == is_global);
86
87 return stmt_expr;
88}
89
90/* Constructors */
91
92/* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
93 which we want to initialize the vtable pointer for, DATA is
94 TREE_LIST whose TREE_VALUE is the this ptr expression. */
95
96static tree
97dfs_initialize_vtbl_ptrs (tree binfo, void *data)
98{
99 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
100 return dfs_skip_bases;
101
102 if (!BINFO_PRIMARY_P (binfo) || BINFO_VIRTUAL_P (binfo))
103 {
104 tree base_ptr = TREE_VALUE ((tree) data);
105
106 base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /*nonnull=*/1,
107 tf_warning_or_error);
108
109 expand_virtual_init (binfo, base_ptr);
110 }
111
112 return NULL_TREE;
113}
114
115/* Initialize all the vtable pointers in the object pointed to by
116 ADDR. */
117
118void
119initialize_vtbl_ptrs (tree addr)
120{
121 tree list;
122 tree type;
123
124 type = TREE_TYPE (TREE_TYPE (addr));
125 list = build_tree_list (type, addr);
126
127 /* Walk through the hierarchy, initializing the vptr in each base
128 class. We do these in pre-order because we can't find the virtual
129 bases for a class until we've initialized the vtbl for that
130 class. */
131 dfs_walk_once (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs, NULL, list);
132}
133
134/* Return an expression for the zero-initialization of an object with
135 type T. This expression will either be a constant (in the case
136 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
137 aggregate), or NULL (in the case that T does not require
138 initialization). In either case, the value can be used as
139 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
140 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
141 is the number of elements in the array. If STATIC_STORAGE_P is
142 TRUE, initializers are only generated for entities for which
143 zero-initialization does not simply mean filling the storage with
144 zero bytes. FIELD_SIZE, if non-NULL, is the bit size of the field,
145 subfields with bit positions at or above that bit size shouldn't
146 be added. Note that this only works when the result is assigned
147 to a base COMPONENT_REF; if we only have a pointer to the base subobject,
148 expand_assignment will end up clearing the full size of TYPE. */
149
150static tree
151build_zero_init_1 (tree type, tree nelts, bool static_storage_p,
152 tree field_size)
153{
154 tree init = NULL_TREE;
155
156 /* [dcl.init]
157
158 To zero-initialize an object of type T means:
159
160 -- if T is a scalar type, the storage is set to the value of zero
161 converted to T.
162
163 -- if T is a non-union class type, the storage for each non-static
164 data member and each base-class subobject is zero-initialized.
165
166 -- if T is a union type, the storage for its first data member is
167 zero-initialized.
168
169 -- if T is an array type, the storage for each element is
170 zero-initialized.
171
172 -- if T is a reference type, no initialization is performed. */
173
174 gcc_assert (nelts == NULL_TREE || TREE_CODE (nelts) == INTEGER_CST);
175
176 /* An initializer is unqualified. */
177 type = cv_unqualified (type);
178
179 if (type == error_mark_node)
180 ;
181 else if (static_storage_p && zero_init_p (type))
182 /* In order to save space, we do not explicitly build initializers
183 for items that do not need them. GCC's semantics are that
184 items with static storage duration that are not otherwise
185 initialized are initialized to zero. */
186 ;
187 else if (TYPE_PTR_OR_PTRMEM_P (type))
188 init = fold (convert (type, nullptr_node));
189 else if (NULLPTR_TYPE_P (type))
190 init = build_int_cst (type, 0);
191 else if (SCALAR_TYPE_P (type))
192 init = build_zero_cst (type);
193 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (type)))
194 {
195 tree field, next;
196 vec<constructor_elt, va_gc> *v = NULL;
197
198 /* Iterate over the fields, building initializations. */
199 for (field = TYPE_FIELDS (type); field; field = next)
200 {
201 next = DECL_CHAIN (field);
202
203 if (TREE_CODE (field) != FIELD_DECL)
204 continue;
205
206 /* For unions, only the first field is initialized. */
207 if (TREE_CODE (type) == UNION_TYPE)
208 next = NULL_TREE;
209
210 if (TREE_TYPE (field) == error_mark_node)
211 continue;
212
213 /* Don't add virtual bases for base classes if they are beyond
214 the size of the current field, that means it is present
215 somewhere else in the object. */
216 if (field_size)
217 {
218 tree bitpos = bit_position (field);
219 if (TREE_CODE (bitpos) == INTEGER_CST
220 && !tree_int_cst_lt (t1: bitpos, t2: field_size))
221 continue;
222 }
223
224 /* Don't add zero width bitfields. */
225 if (DECL_C_BIT_FIELD (field)
226 && integer_zerop (DECL_SIZE (field)))
227 continue;
228
229 /* Note that for class types there will be FIELD_DECLs
230 corresponding to base classes as well. Thus, iterating
231 over TYPE_FIELDs will result in correct initialization of
232 all of the subobjects. */
233 if (!static_storage_p || !zero_init_p (TREE_TYPE (field)))
234 {
235 tree new_field_size
236 = (DECL_FIELD_IS_BASE (field)
237 && DECL_SIZE (field)
238 && TREE_CODE (DECL_SIZE (field)) == INTEGER_CST)
239 ? DECL_SIZE (field) : NULL_TREE;
240 tree value = build_zero_init_1 (TREE_TYPE (field),
241 /*nelts=*/NULL_TREE,
242 static_storage_p,
243 field_size: new_field_size);
244 if (value)
245 CONSTRUCTOR_APPEND_ELT(v, field, value);
246 }
247 }
248
249 /* Build a constructor to contain the initializations. */
250 init = build_constructor (type, v);
251 CONSTRUCTOR_ZERO_PADDING_BITS (init) = 1;
252 }
253 else if (TREE_CODE (type) == ARRAY_TYPE)
254 {
255 tree max_index;
256 vec<constructor_elt, va_gc> *v = NULL;
257
258 /* Iterate over the array elements, building initializations. */
259 if (nelts)
260 max_index = fold_build2_loc (input_location, MINUS_EXPR,
261 TREE_TYPE (nelts), nelts,
262 build_one_cst (TREE_TYPE (nelts)));
263 /* Treat flexible array members like [0] arrays. */
264 else if (TYPE_DOMAIN (type) == NULL_TREE)
265 return NULL_TREE;
266 else
267 max_index = array_type_nelts_minus_one (type);
268
269 /* If we have an error_mark here, we should just return error mark
270 as we don't know the size of the array yet. */
271 if (max_index == error_mark_node)
272 return error_mark_node;
273 gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
274
275 /* A zero-sized array, which is accepted as an extension, will
276 have an upper bound of -1. */
277 if (!integer_minus_onep (max_index))
278 {
279 constructor_elt ce;
280
281 /* If this is a one element array, we just use a regular init. */
282 if (integer_zerop (max_index))
283 ce.index = size_zero_node;
284 else
285 ce.index = build2 (RANGE_EXPR, sizetype, size_zero_node,
286 max_index);
287
288 ce.value = build_zero_init_1 (TREE_TYPE (type), /*nelts=*/NULL_TREE,
289 static_storage_p, NULL_TREE);
290 if (ce.value)
291 {
292 vec_alloc (v, nelems: 1);
293 v->quick_push (obj: ce);
294 }
295 }
296
297 /* Build a constructor to contain the initializations. */
298 init = build_constructor (type, v);
299 }
300 else if (VECTOR_TYPE_P (type))
301 init = build_zero_cst (type);
302 else
303 gcc_assert (TYPE_REF_P (type));
304
305 /* In all cases, the initializer is a constant. */
306 if (init)
307 TREE_CONSTANT (init) = 1;
308
309 return init;
310}
311
312/* Return an expression for the zero-initialization of an object with
313 type T. This expression will either be a constant (in the case
314 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
315 aggregate), or NULL (in the case that T does not require
316 initialization). In either case, the value can be used as
317 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
318 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
319 is the number of elements in the array. If STATIC_STORAGE_P is
320 TRUE, initializers are only generated for entities for which
321 zero-initialization does not simply mean filling the storage with
322 zero bytes. */
323
324tree
325build_zero_init (tree type, tree nelts, bool static_storage_p)
326{
327 return build_zero_init_1 (type, nelts, static_storage_p, NULL_TREE);
328}
329
330/* Return a suitable initializer for value-initializing an object of type
331 TYPE, as described in [dcl.init]. */
332
333tree
334build_value_init (tree type, tsubst_flags_t complain)
335{
336 /* [dcl.init]
337
338 To value-initialize an object of type T means:
339
340 - if T is a class type (clause 9) with either no default constructor
341 (12.1) or a default constructor that is user-provided or deleted,
342 then the object is default-initialized;
343
344 - if T is a (possibly cv-qualified) class type without a user-provided
345 or deleted default constructor, then the object is zero-initialized
346 and the semantic constraints for default-initialization are checked,
347 and if T has a non-trivial default constructor, the object is
348 default-initialized;
349
350 - if T is an array type, then each element is value-initialized;
351
352 - otherwise, the object is zero-initialized.
353
354 A program that calls for default-initialization or
355 value-initialization of an entity of reference type is ill-formed. */
356
357 if (CLASS_TYPE_P (type) && type_build_ctor_call (type))
358 {
359 tree ctor
360 = build_special_member_call (NULL_TREE, complete_ctor_identifier,
361 NULL, type, LOOKUP_NORMAL, complain);
362 if (ctor == error_mark_node || TREE_CONSTANT (ctor))
363 return ctor;
364 if (processing_template_decl)
365 /* The AGGR_INIT_EXPR tweaking below breaks in templates. */
366 return build_min (CAST_EXPR, type, NULL_TREE);
367 tree fn = NULL_TREE;
368 if (TREE_CODE (ctor) == CALL_EXPR)
369 fn = get_callee_fndecl (ctor);
370 ctor = build_aggr_init_expr (type, ctor);
371 if (fn && user_provided_p (fn))
372 return ctor;
373 else if (TYPE_HAS_COMPLEX_DFLT (type))
374 {
375 /* This is a class that needs constructing, but doesn't have
376 a user-provided constructor. So we need to zero-initialize
377 the object and then call the implicitly defined ctor.
378 This will be handled in simplify_aggr_init_expr. */
379 AGGR_INIT_ZERO_FIRST (ctor) = 1;
380 return ctor;
381 }
382 }
383
384 /* Discard any access checking during subobject initialization;
385 the checks are implied by the call to the ctor which we have
386 verified is OK (cpp0x/defaulted46.C). */
387 push_deferring_access_checks (dk_deferred);
388 tree r = build_value_init_noctor (type, complain);
389 pop_deferring_access_checks ();
390 return r;
391}
392
393/* Like build_value_init, but don't call the constructor for TYPE. Used
394 for base initializers. */
395
396tree
397build_value_init_noctor (tree type, tsubst_flags_t complain)
398{
399 if (!COMPLETE_TYPE_P (type))
400 {
401 if (complain & tf_error)
402 error ("value-initialization of incomplete type %qT", type);
403 return error_mark_node;
404 }
405 /* FIXME the class and array cases should just use digest_init once it is
406 SFINAE-enabled. */
407 if (CLASS_TYPE_P (type))
408 {
409 gcc_assert (!TYPE_HAS_COMPLEX_DFLT (type)
410 || errorcount != 0);
411
412 if (TREE_CODE (type) != UNION_TYPE)
413 {
414 tree field;
415 vec<constructor_elt, va_gc> *v = NULL;
416
417 /* Iterate over the fields, building initializations. */
418 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
419 {
420 tree ftype, value;
421
422 if (TREE_CODE (field) != FIELD_DECL)
423 continue;
424
425 ftype = TREE_TYPE (field);
426
427 if (ftype == error_mark_node)
428 continue;
429
430 /* Ignore flexible array members for value initialization. */
431 if (TREE_CODE (ftype) == ARRAY_TYPE
432 && !COMPLETE_TYPE_P (ftype)
433 && !TYPE_DOMAIN (ftype)
434 && COMPLETE_TYPE_P (TREE_TYPE (ftype))
435 && (next_aggregate_field (DECL_CHAIN (field))
436 == NULL_TREE))
437 continue;
438
439 /* Ignore unnamed zero-width bitfields. */
440 if (DECL_UNNAMED_BIT_FIELD (field)
441 && integer_zerop (DECL_SIZE (field)))
442 continue;
443
444 /* We could skip vfields and fields of types with
445 user-defined constructors, but I think that won't improve
446 performance at all; it should be simpler in general just
447 to zero out the entire object than try to only zero the
448 bits that actually need it. */
449
450 /* Note that for class types there will be FIELD_DECLs
451 corresponding to base classes as well. Thus, iterating
452 over TYPE_FIELDs will result in correct initialization of
453 all of the subobjects. */
454 value = build_value_init (type: ftype, complain);
455 value = maybe_constant_init (value);
456
457 if (value == error_mark_node)
458 return error_mark_node;
459
460 CONSTRUCTOR_APPEND_ELT(v, field, value);
461
462 /* We shouldn't have gotten here for anything that would need
463 non-trivial initialization, and gimplify_init_ctor_preeval
464 would need to be fixed to allow it. */
465 gcc_assert (TREE_CODE (value) != TARGET_EXPR
466 && TREE_CODE (value) != AGGR_INIT_EXPR);
467 }
468
469 /* Build a constructor to contain the zero- initializations. */
470 tree ret = build_constructor (type, v);
471 CONSTRUCTOR_ZERO_PADDING_BITS (ret) = 1;
472 return ret;
473 }
474 }
475 else if (TREE_CODE (type) == ARRAY_TYPE)
476 {
477 vec<constructor_elt, va_gc> *v = NULL;
478
479 /* Iterate over the array elements, building initializations. */
480 tree max_index = array_type_nelts_minus_one (type);
481
482 /* If we have an error_mark here, we should just return error mark
483 as we don't know the size of the array yet. */
484 if (max_index == error_mark_node)
485 {
486 if (complain & tf_error)
487 error ("cannot value-initialize array of unknown bound %qT",
488 type);
489 return error_mark_node;
490 }
491 gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
492
493 /* A zero-sized array, which is accepted as an extension, will
494 have an upper bound of -1. */
495 if (!tree_int_cst_equal (max_index, integer_minus_one_node))
496 {
497 constructor_elt ce;
498
499 /* If this is a one element array, we just use a regular init. */
500 if (tree_int_cst_equal (size_zero_node, max_index))
501 ce.index = size_zero_node;
502 else
503 ce.index = build2 (RANGE_EXPR, sizetype, size_zero_node, max_index);
504
505 ce.value = build_value_init (TREE_TYPE (type), complain);
506 ce.value = maybe_constant_init (ce.value);
507 if (ce.value == error_mark_node)
508 return error_mark_node;
509
510 vec_alloc (v, nelems: 1);
511 v->quick_push (obj: ce);
512
513 /* We shouldn't have gotten here for anything that would need
514 non-trivial initialization, and gimplify_init_ctor_preeval
515 would need to be fixed to allow it. */
516 gcc_assert (TREE_CODE (ce.value) != TARGET_EXPR
517 && TREE_CODE (ce.value) != AGGR_INIT_EXPR);
518 }
519
520 /* Build a constructor to contain the initializations. */
521 return build_constructor (type, v);
522 }
523 else if (TREE_CODE (type) == FUNCTION_TYPE)
524 {
525 if (complain & tf_error)
526 error ("value-initialization of function type %qT", type);
527 return error_mark_node;
528 }
529 else if (TYPE_REF_P (type))
530 {
531 if (complain & tf_error)
532 error ("value-initialization of reference type %qT", type);
533 return error_mark_node;
534 }
535
536 return build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
537}
538
539/* Initialize current class with INIT, a TREE_LIST of arguments for
540 a target constructor. If TREE_LIST is void_type_node, an empty
541 initializer list was given. Return the target constructor. */
542
543static tree
544perform_target_ctor (tree init)
545{
546 tree decl = current_class_ref;
547 tree type = current_class_type;
548
549 init = build_aggr_init (decl, init, LOOKUP_NORMAL|LOOKUP_DELEGATING_CONS,
550 tf_warning_or_error);
551 finish_expr_stmt (init);
552 if (type_build_dtor_call (type))
553 {
554 tree expr = build_delete (input_location,
555 type, decl, sfk_complete_destructor,
556 LOOKUP_NORMAL
557 |LOOKUP_NONVIRTUAL
558 |LOOKUP_DESTRUCTOR,
559 0, tf_warning_or_error);
560 if (DECL_HAS_IN_CHARGE_PARM_P (current_function_decl))
561 {
562 tree base = build_delete (input_location,
563 type, decl, sfk_base_destructor,
564 LOOKUP_NORMAL
565 |LOOKUP_NONVIRTUAL
566 |LOOKUP_DESTRUCTOR,
567 0, tf_warning_or_error);
568 expr = build_if_in_charge (true_stmt: expr, false_stmt: base);
569 }
570 if (expr != error_mark_node
571 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
572 finish_eh_cleanup (expr);
573 }
574 return init;
575}
576
577/* Instantiate the default member initializer of MEMBER, if needed.
578 Only get_nsdmi should use the return value of this function. */
579
580tree
581maybe_instantiate_nsdmi_init (tree member, tsubst_flags_t complain)
582{
583 tree init = DECL_INITIAL (member);
584
585 /* tsubst_decl uses void_node to indicate an uninstantiated DMI. */
586 if (init == void_node)
587 {
588 /* Clear any special tsubst flags; the result of NSDMI instantiation
589 should be independent of the substitution context. */
590 complain &= tf_warning_or_error;
591
592 init = DECL_INITIAL (DECL_TI_TEMPLATE (member));
593 location_t expr_loc
594 = cp_expr_loc_or_loc (t: init, DECL_SOURCE_LOCATION (member));
595 if (TREE_CODE (init) == DEFERRED_PARSE)
596 /* Unparsed. */;
597 /* Check recursive instantiation. */
598 else if (DECL_INSTANTIATING_NSDMI_P (member))
599 {
600 if (complain & tf_error)
601 error_at (expr_loc, "recursive instantiation of default member "
602 "initializer for %qD", member);
603 init = error_mark_node;
604 }
605 else
606 {
607 cp_evaluated ev;
608
609 location_t sloc = input_location;
610 input_location = expr_loc;
611
612 DECL_INSTANTIATING_NSDMI_P (member) = 1;
613
614 bool pushed = false;
615 tree ctx = type_context_for_name_lookup (member);
616
617 bool push_to_top = maybe_push_to_top_level (member);
618 if (!currently_open_class (ctx))
619 {
620 push_nested_class (ctx);
621 push_deferring_access_checks (dk_no_deferred);
622 pushed = true;
623 }
624
625 inject_this_parameter (ctx, TYPE_UNQUALIFIED);
626
627 start_lambda_scope (decl: member);
628
629 /* Do deferred instantiation of the NSDMI. */
630 init = tsubst_expr (init, DECL_TI_ARGS (member), complain, member);
631 init = digest_nsdmi_init (member, init, complain);
632
633 finish_lambda_scope ();
634
635 DECL_INSTANTIATING_NSDMI_P (member) = 0;
636
637 if (init != error_mark_node)
638 DECL_INITIAL (member) = init;
639
640 if (pushed)
641 {
642 pop_deferring_access_checks ();
643 pop_nested_class ();
644 }
645 maybe_pop_from_top_level (push_to_top);
646
647 input_location = sloc;
648 }
649 }
650
651 return init;
652}
653
654/* Return the non-static data initializer for FIELD_DECL MEMBER. */
655
656tree
657get_nsdmi (tree member, bool in_ctor, tsubst_flags_t complain)
658{
659 tree save_ccp = current_class_ptr;
660 tree save_ccr = current_class_ref;
661
662 tree init = maybe_instantiate_nsdmi_init (member, complain);
663
664 if (init && TREE_CODE (init) == DEFERRED_PARSE)
665 {
666 if (complain & tf_error)
667 {
668 auto_diagnostic_group d;
669 error ("default member initializer for %qD required before the end "
670 "of its enclosing class", member);
671 inform (location_of (init), "defined here");
672 DECL_INITIAL (member) = error_mark_node;
673 }
674 init = error_mark_node;
675 }
676
677 if (in_ctor)
678 {
679 current_class_ptr = save_ccp;
680 current_class_ref = save_ccr;
681 }
682 else
683 {
684 /* Use a PLACEHOLDER_EXPR when we don't have a 'this' parameter to
685 refer to; constexpr evaluation knows what to do with it. */
686 current_class_ref = build0 (PLACEHOLDER_EXPR, DECL_CONTEXT (member));
687 current_class_ptr = build_address (current_class_ref);
688 }
689
690 /* Clear processing_template_decl for sake of break_out_target_exprs;
691 INIT is always non-templated. */
692 processing_template_decl_sentinel ptds;
693
694 /* Strip redundant TARGET_EXPR so we don't need to remap it, and
695 so the aggregate init code below will see a CONSTRUCTOR. */
696 bool simple_target = (init && SIMPLE_TARGET_EXPR_P (init));
697 if (simple_target)
698 init = TARGET_EXPR_INITIAL (init);
699 init = break_out_target_exprs (init, /*loc*/true);
700 if (init && TREE_CODE (init) == TARGET_EXPR)
701 /* In a constructor, this expresses the full initialization, prevent
702 perform_member_init from calling another constructor (58162). */
703 TARGET_EXPR_DIRECT_INIT_P (init) = in_ctor;
704 if (simple_target && TREE_CODE (init) != CONSTRUCTOR)
705 /* Now put it back so C++17 copy elision works. */
706 init = get_target_expr (init);
707
708 set_target_expr_eliding (init);
709
710 current_class_ptr = save_ccp;
711 current_class_ref = save_ccr;
712 return init;
713}
714
715/* Diagnose the flexible array MEMBER if its INITializer is non-null
716 and return true if so. Otherwise return false. */
717
718bool
719maybe_reject_flexarray_init (tree member, tree init)
720{
721 tree type = TREE_TYPE (member);
722
723 if (!init
724 || TREE_CODE (type) != ARRAY_TYPE
725 || TYPE_DOMAIN (type))
726 return false;
727
728 /* Point at the flexible array member declaration if it's initialized
729 in-class, and at the ctor if it's initialized in a ctor member
730 initializer list. */
731 location_t loc;
732 if (DECL_INITIAL (member) == init
733 || !current_function_decl
734 || DECL_DEFAULTED_FN (current_function_decl))
735 loc = DECL_SOURCE_LOCATION (member);
736 else
737 loc = DECL_SOURCE_LOCATION (current_function_decl);
738
739 error_at (loc, "initializer for flexible array member %q#D", member);
740 return true;
741}
742
743/* If INIT's value can come from a call to std::initializer_list<T>::begin,
744 return that function. Otherwise, NULL_TREE. */
745
746static tree
747find_list_begin (tree init)
748{
749 STRIP_NOPS (init);
750 while (TREE_CODE (init) == COMPOUND_EXPR)
751 init = TREE_OPERAND (init, 1);
752 STRIP_NOPS (init);
753 if (TREE_CODE (init) == COND_EXPR)
754 {
755 tree left = TREE_OPERAND (init, 1);
756 if (!left)
757 left = TREE_OPERAND (init, 0);
758 left = find_list_begin (init: left);
759 if (left)
760 return left;
761 return find_list_begin (TREE_OPERAND (init, 2));
762 }
763 if (TREE_CODE (init) == CALL_EXPR)
764 if (tree fn = get_callee_fndecl (init))
765 if (id_equal (DECL_NAME (fn), str: "begin")
766 && is_std_init_list (DECL_CONTEXT (fn)))
767 return fn;
768 return NULL_TREE;
769}
770
771/* If INIT initializing MEMBER is copying the address of the underlying array
772 of an initializer_list, warn. */
773
774static void
775maybe_warn_list_ctor (tree member, tree init)
776{
777 tree memtype = TREE_TYPE (member);
778 if (!init || !TYPE_PTR_P (memtype)
779 || !is_list_ctor (current_function_decl))
780 return;
781
782 tree parm = FUNCTION_FIRST_USER_PARMTYPE (current_function_decl);
783 parm = TREE_VALUE (parm);
784 tree initlist = non_reference (parm);
785
786 /* Do not warn if the parameter is an lvalue reference to non-const. */
787 if (TYPE_REF_P (parm) && !TYPE_REF_IS_RVALUE (parm)
788 && !CP_TYPE_CONST_P (initlist))
789 return;
790
791 tree targs = CLASSTYPE_TI_ARGS (initlist);
792 tree elttype = TREE_VEC_ELT (targs, 0);
793
794 if (!same_type_ignoring_top_level_qualifiers_p
795 (TREE_TYPE (memtype), elttype))
796 return;
797
798 tree begin = find_list_begin (init);
799 if (!begin)
800 return;
801
802 location_t loc = cp_expr_loc_or_input_loc (t: init);
803 warning_at (loc, OPT_Winit_list_lifetime,
804 "initializing %qD from %qE does not extend the lifetime "
805 "of the underlying array", member, begin);
806}
807
808/* Data structure for find_uninit_fields_r, below. */
809
810struct find_uninit_data {
811 /* The set tracking the yet-uninitialized members. */
812 hash_set<tree> *uninitialized;
813 /* The data member we are currently initializing. It can be either
814 a type (initializing a base class/delegating constructors), or
815 a COMPONENT_REF. */
816 tree member;
817};
818
819/* walk_tree callback that warns about using uninitialized data in
820 a member-initializer-list. */
821
822static tree
823find_uninit_fields_r (tree *tp, int *walk_subtrees, void *data)
824{
825 find_uninit_data *d = static_cast<find_uninit_data *>(data);
826 hash_set<tree> *uninitialized = d->uninitialized;
827 tree init = *tp;
828 const tree_code code = TREE_CODE (init);
829
830 /* No need to look into types or unevaluated operands. */
831 if (TYPE_P (init) || unevaluated_p (code))
832 {
833 *walk_subtrees = false;
834 return NULL_TREE;
835 }
836
837 switch (code)
838 {
839 /* We'd need data flow info to avoid false positives. */
840 case COND_EXPR:
841 case VEC_COND_EXPR:
842 case BIND_EXPR:
843 /* We might see a MODIFY_EXPR in cases like S() : a((b = 42)), c(b) { }
844 where the initializer for 'a' surreptitiously initializes 'b'. Let's
845 not bother with these complicated scenarios in the front end. */
846 case MODIFY_EXPR:
847 /* Don't attempt to handle statement-expressions, either. */
848 case STATEMENT_LIST:
849 uninitialized->empty ();
850 gcc_fallthrough ();
851 /* If we're just taking the address of an object, it doesn't matter
852 whether it's been initialized. */
853 case ADDR_EXPR:
854 *walk_subtrees = false;
855 return NULL_TREE;
856 default:
857 break;
858 }
859
860 /* We'd need data flow info to avoid false positives. */
861 if (truth_value_p (code))
862 goto give_up;
863 /* Attempt to handle a simple a{b}, but no more. */
864 else if (BRACE_ENCLOSED_INITIALIZER_P (init))
865 {
866 if (CONSTRUCTOR_NELTS (init) == 1
867 && !BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (init, 0)->value))
868 init = CONSTRUCTOR_ELT (init, 0)->value;
869 else
870 goto give_up;
871 }
872 /* Warn about uninitialized 'this'. */
873 else if (code == CALL_EXPR)
874 {
875 tree fn = get_callee_fndecl (init);
876 if (fn && DECL_IOBJ_MEMBER_FUNCTION_P (fn))
877 {
878 tree op = CALL_EXPR_ARG (init, 0);
879 if (TREE_CODE (op) == ADDR_EXPR)
880 op = TREE_OPERAND (op, 0);
881 temp_override<tree> ovr (d->member, DECL_ARGUMENTS (fn));
882 cp_walk_tree_without_duplicates (&op, find_uninit_fields_r, data);
883 }
884 /* Functions (whether static or nonstatic member) may have side effects
885 and initialize other members; it's not the front end's job to try to
886 figure it out. But don't give up for constructors: we still want to
887 warn when initializing base classes:
888
889 struct D : public B {
890 int x;
891 D() : B(x) {}
892 };
893
894 so carry on to detect that 'x' is used uninitialized. */
895 if (!fn || !DECL_CONSTRUCTOR_P (fn))
896 goto give_up;
897 }
898
899 /* If we find FIELD in the uninitialized set, we warn. */
900 if (code == COMPONENT_REF)
901 {
902 tree field = TREE_OPERAND (init, 1);
903 tree type = TYPE_P (d->member) ? d->member : TREE_TYPE (d->member);
904
905 /* We're initializing a reference member with itself. */
906 if (TYPE_REF_P (type) && cp_tree_equal (d->member, init))
907 warning_at (EXPR_LOCATION (init), OPT_Winit_self,
908 "%qD is initialized with itself", field);
909 else if (cp_tree_equal (TREE_OPERAND (init, 0), current_class_ref)
910 && uninitialized->contains (k: field))
911 {
912 if (TYPE_REF_P (TREE_TYPE (field)))
913 warning_at (EXPR_LOCATION (init), OPT_Wuninitialized,
914 "reference %qD is not yet bound to a value when used "
915 "here", field);
916 else if ((!INDIRECT_TYPE_P (type) || is_this_parameter (d->member))
917 && !conv_binds_to_reference_parm_p (type, init))
918 warning_at (EXPR_LOCATION (init), OPT_Wuninitialized,
919 "member %qD is used uninitialized", field);
920 *walk_subtrees = false;
921 }
922 }
923
924 return NULL_TREE;
925
926give_up:
927 *walk_subtrees = false;
928 uninitialized->empty ();
929 return integer_zero_node;
930}
931
932/* Wrapper around find_uninit_fields_r above. */
933
934static void
935find_uninit_fields (tree *t, hash_set<tree> *uninitialized, tree member)
936{
937 if (!uninitialized->is_empty ())
938 {
939 find_uninit_data data = { .uninitialized: uninitialized, .member: member };
940 cp_walk_tree_without_duplicates (t, find_uninit_fields_r, &data);
941 }
942}
943
944/* Return true if it's OK to initialize an array TYPE from INIT. Mere mortals
945 can't copy arrays, but the compiler can do so with a VEC_INIT_EXPR in
946 certain cases. */
947
948static bool
949can_init_array_with_p (tree type, tree init)
950{
951 if (!init)
952 /* Value-init, OK. */
953 return true;
954 if (!same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (init)))
955 return false;
956 /* We're called from synthesize_method, and we're processing the
957 mem-initializers of a constructor. */
958 if (DECL_DEFAULTED_FN (current_function_decl))
959 return true;
960 if (TREE_CODE (init) == TARGET_EXPR)
961 {
962 init = TARGET_EXPR_INITIAL (init);
963 /* As an extension, we allow copying from a compound literal. */
964 if (TREE_CODE (init) == CONSTRUCTOR)
965 return CONSTRUCTOR_C99_COMPOUND_LITERAL (init);
966 /* VEC_INIT_EXPR is used for non-constant initialization of trailing
967 elements with no explicit initializers. */
968 else if (TREE_CODE (init) == VEC_INIT_EXPR)
969 return true;
970 }
971
972 permerror (input_location, "array must be initialized "
973 "with a brace-enclosed initializer");
974 return true;
975}
976
977/* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
978 arguments. If TREE_LIST is void_type_node, an empty initializer
979 list was given; if NULL_TREE no initializer was given. UNINITIALIZED
980 is the hash set that tracks uninitialized fields. */
981
982static void
983perform_member_init (tree member, tree init, hash_set<tree> &uninitialized)
984{
985 tree decl;
986 tree type = TREE_TYPE (member);
987
988 /* Use the non-static data member initializer if there was no
989 mem-initializer for this field. */
990 if (init == NULL_TREE)
991 init = get_nsdmi (member, /*ctor*/in_ctor: true, complain: tf_warning_or_error);
992
993 if (init == error_mark_node)
994 return;
995
996 /* Effective C++ rule 12 requires that all data members be
997 initialized. */
998 if (warn_ecpp && init == NULL_TREE && TREE_CODE (type) != ARRAY_TYPE)
999 warning_at (DECL_SOURCE_LOCATION (current_function_decl), OPT_Weffc__,
1000 "%qD should be initialized in the member initialization list",
1001 member);
1002
1003 /* Get an lvalue for the data member. */
1004 decl = build_class_member_access_expr (current_class_ref, member,
1005 /*access_path=*/NULL_TREE,
1006 /*preserve_reference=*/true,
1007 tf_warning_or_error);
1008 if (decl == error_mark_node)
1009 return;
1010
1011 if ((warn_init_self || warn_uninitialized || warn_self_move)
1012 && init
1013 && TREE_CODE (init) == TREE_LIST
1014 && TREE_CHAIN (init) == NULL_TREE)
1015 {
1016 tree val = TREE_VALUE (init);
1017 /* Handle references. */
1018 if (REFERENCE_REF_P (val))
1019 val = TREE_OPERAND (val, 0);
1020 if (TREE_CODE (val) == COMPONENT_REF && TREE_OPERAND (val, 1) == member
1021 && TREE_OPERAND (val, 0) == current_class_ref)
1022 warning_at (DECL_SOURCE_LOCATION (current_function_decl),
1023 OPT_Winit_self, "%qD is initialized with itself",
1024 member);
1025 else if (!maybe_warn_self_move (input_location, member,
1026 TREE_VALUE (init)))
1027 find_uninit_fields (t: &val, uninitialized: &uninitialized, member: decl);
1028 }
1029
1030 if (array_of_unknown_bound_p (type))
1031 {
1032 maybe_reject_flexarray_init (member, init);
1033 return;
1034 }
1035
1036 if (init && TREE_CODE (init) == TREE_LIST)
1037 {
1038 /* A(): a{e} */
1039 if (DIRECT_LIST_INIT_P (TREE_VALUE (init)))
1040 init = build_x_compound_expr_from_list (init, ELK_MEM_INIT,
1041 tf_warning_or_error);
1042 /* We are trying to initialize an array from a ()-list. If we
1043 should attempt to do so, conjure up a CONSTRUCTOR. */
1044 else if (TREE_CODE (type) == ARRAY_TYPE
1045 /* P0960 is a C++20 feature. */
1046 && cxx_dialect >= cxx20)
1047 init = do_aggregate_paren_init (init, type);
1048 else if (!CLASS_TYPE_P (type))
1049 init = build_x_compound_expr_from_list (init, ELK_MEM_INIT,
1050 tf_warning_or_error);
1051 /* If we're initializing a class from a ()-list, leave the TREE_LIST
1052 alone: we might call an appropriate constructor, or (in C++20)
1053 do aggregate-initialization. */
1054 }
1055
1056 /* Assume we are initializing the member. */
1057 bool member_initialized_p = true;
1058
1059 if (init == void_type_node)
1060 {
1061 /* mem() means value-initialization. */
1062 if (TREE_CODE (type) == ARRAY_TYPE)
1063 {
1064 init = build_vec_init_expr (type, init, tf_warning_or_error);
1065 init = cp_build_init_expr (t: decl, i: init);
1066 finish_expr_stmt (init);
1067 }
1068 else
1069 {
1070 tree value = build_value_init (type, complain: tf_warning_or_error);
1071 if (value == error_mark_node)
1072 return;
1073 init = cp_build_init_expr (t: decl, i: value);
1074 finish_expr_stmt (init);
1075 }
1076 }
1077 /* Deal with this here, as we will get confused if we try to call the
1078 assignment op for an anonymous union. This can happen in a
1079 synthesized copy constructor. */
1080 else if (ANON_AGGR_TYPE_P (type))
1081 {
1082 if (init)
1083 {
1084 init = cp_build_init_expr (t: decl, TREE_VALUE (init));
1085 finish_expr_stmt (init);
1086 }
1087 }
1088 else if (init
1089 && (TYPE_REF_P (type)
1090 || (TREE_CODE (init) == CONSTRUCTOR
1091 && (CP_AGGREGATE_TYPE_P (type)
1092 || is_std_init_list (type)))))
1093 {
1094 /* With references and list-initialization, we need to deal with
1095 extending temporary lifetimes. 12.2p5: "A temporary bound to a
1096 reference member in a constructor's ctor-initializer (12.6.2)
1097 persists until the constructor exits." */
1098 unsigned i; tree t;
1099 releasing_vec cleanups;
1100 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (init), type))
1101 {
1102 if (BRACE_ENCLOSED_INITIALIZER_P (init)
1103 && CP_AGGREGATE_TYPE_P (type))
1104 init = reshape_init (type, init, tf_warning_or_error);
1105 init = digest_init (type, init, tf_warning_or_error);
1106 }
1107 if (init == error_mark_node)
1108 return;
1109 if (is_empty_field (member)
1110 && !TREE_SIDE_EFFECTS (init))
1111 /* Don't add trivial initialization of an empty base/field, as they
1112 might not be ordered the way the back-end expects. */
1113 return;
1114 /* A FIELD_DECL doesn't really have a suitable lifetime, but
1115 make_temporary_var_for_ref_to_temp will treat it as automatic and
1116 set_up_extended_ref_temp wants to use the decl in a warning. */
1117 init = extend_ref_init_temps (member, init, &cleanups);
1118 if (TREE_CODE (type) == ARRAY_TYPE
1119 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (type)))
1120 init = build_vec_init_expr (type, init, tf_warning_or_error);
1121 init = cp_build_init_expr (t: decl, i: init);
1122 finish_expr_stmt (init);
1123 FOR_EACH_VEC_ELT (*cleanups, i, t)
1124 push_cleanup (NULL_TREE, t, false);
1125 }
1126 else if (type_build_ctor_call (type)
1127 || (init && CLASS_TYPE_P (strip_array_types (type))))
1128 {
1129 if (TREE_CODE (type) == ARRAY_TYPE)
1130 {
1131 if (can_init_array_with_p (type, init))
1132 {
1133 if (TYPE_DOMAIN (type) && TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
1134 {
1135 /* Initialize the array only if it's not a flexible
1136 array member (i.e., if it has an upper bound). */
1137 init = build_vec_init_expr (type, init, tf_warning_or_error);
1138 init = cp_build_init_expr (t: decl, i: init);
1139 finish_expr_stmt (init);
1140 }
1141 }
1142 else
1143 error ("invalid initializer for array member %q#D", member);
1144 }
1145 else
1146 {
1147 int flags = LOOKUP_NORMAL;
1148 if (DECL_DEFAULTED_FN (current_function_decl))
1149 flags |= LOOKUP_DEFAULTED;
1150 if (CP_TYPE_CONST_P (type)
1151 && init == NULL_TREE
1152 && default_init_uninitialized_part (type))
1153 {
1154 /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
1155 vtable; still give this diagnostic. */
1156 auto_diagnostic_group d;
1157 if (permerror (DECL_SOURCE_LOCATION (current_function_decl),
1158 "uninitialized const member in %q#T", type))
1159 inform (DECL_SOURCE_LOCATION (member),
1160 "%q#D should be initialized", member );
1161 }
1162 finish_expr_stmt (build_aggr_init (decl, init, flags,
1163 tf_warning_or_error));
1164 }
1165 }
1166 else
1167 {
1168 if (init == NULL_TREE)
1169 {
1170 tree core_type;
1171 /* member traversal: note it leaves init NULL */
1172 if (TYPE_REF_P (type))
1173 {
1174 auto_diagnostic_group d;
1175 if (permerror (DECL_SOURCE_LOCATION (current_function_decl),
1176 "uninitialized reference member in %q#T", type))
1177 inform (DECL_SOURCE_LOCATION (member),
1178 "%q#D should be initialized", member);
1179 }
1180 else if (CP_TYPE_CONST_P (type))
1181 {
1182 auto_diagnostic_group d;
1183 if (permerror (DECL_SOURCE_LOCATION (current_function_decl),
1184 "uninitialized const member in %q#T", type))
1185 inform (DECL_SOURCE_LOCATION (member),
1186 "%q#D should be initialized", member );
1187 }
1188
1189 core_type = strip_array_types (type);
1190
1191 if (CLASS_TYPE_P (core_type)
1192 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)
1193 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)))
1194 diagnose_uninitialized_cst_or_ref_member (core_type,
1195 /*using_new=*/false,
1196 /*complain=*/true);
1197
1198 /* We left the member uninitialized. */
1199 member_initialized_p = false;
1200 }
1201
1202 maybe_warn_list_ctor (member, init);
1203
1204 if (init)
1205 finish_expr_stmt (cp_build_modify_expr (input_location, decl,
1206 INIT_EXPR, init,
1207 tf_warning_or_error));
1208 }
1209
1210 if (member_initialized_p && warn_uninitialized)
1211 /* This member is now initialized, remove it from the uninitialized
1212 set. */
1213 uninitialized.remove (k: member);
1214
1215 if (type_build_dtor_call (type))
1216 {
1217 tree expr;
1218
1219 expr = build_class_member_access_expr (current_class_ref, member,
1220 /*access_path=*/NULL_TREE,
1221 /*preserve_reference=*/false,
1222 tf_warning_or_error);
1223 expr = build_delete (input_location,
1224 type, expr, sfk_complete_destructor,
1225 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0,
1226 tf_warning_or_error);
1227
1228 if (expr != error_mark_node
1229 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
1230 finish_eh_cleanup (expr);
1231 }
1232}
1233
1234/* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
1235 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
1236
1237static tree
1238build_field_list (tree t, tree list, int *uses_unions_or_anon_p)
1239{
1240 tree fields;
1241
1242 /* Note whether or not T is a union. */
1243 if (TREE_CODE (t) == UNION_TYPE)
1244 *uses_unions_or_anon_p = 1;
1245
1246 for (fields = TYPE_FIELDS (t); fields; fields = DECL_CHAIN (fields))
1247 {
1248 tree fieldtype;
1249
1250 /* Skip CONST_DECLs for enumeration constants and so forth. */
1251 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
1252 continue;
1253
1254 fieldtype = TREE_TYPE (fields);
1255
1256 /* For an anonymous struct or union, we must recursively
1257 consider the fields of the anonymous type. They can be
1258 directly initialized from the constructor. */
1259 if (ANON_AGGR_TYPE_P (fieldtype))
1260 {
1261 /* Add this field itself. Synthesized copy constructors
1262 initialize the entire aggregate. */
1263 list = tree_cons (fields, NULL_TREE, list);
1264 /* And now add the fields in the anonymous aggregate. */
1265 list = build_field_list (t: fieldtype, list, uses_unions_or_anon_p);
1266 *uses_unions_or_anon_p = 1;
1267 }
1268 /* Add this field. */
1269 else if (DECL_NAME (fields))
1270 list = tree_cons (fields, NULL_TREE, list);
1271 }
1272
1273 return list;
1274}
1275
1276/* Return the innermost aggregate scope for FIELD, whether that is
1277 the enclosing class or an anonymous aggregate within it. */
1278
1279static tree
1280innermost_aggr_scope (tree field)
1281{
1282 if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1283 return TREE_TYPE (field);
1284 else
1285 return DECL_CONTEXT (field);
1286}
1287
1288/* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
1289 a FIELD_DECL or BINFO in T that needs initialization. The
1290 TREE_VALUE gives the initializer, or list of initializer arguments.
1291
1292 Return a TREE_LIST containing all of the initializations required
1293 for T, in the order in which they should be performed. The output
1294 list has the same format as the input. */
1295
1296static tree
1297sort_mem_initializers (tree t, tree mem_inits)
1298{
1299 tree init;
1300 tree base, binfo, base_binfo;
1301 tree sorted_inits;
1302 tree next_subobject;
1303 vec<tree, va_gc> *vbases;
1304 int i;
1305 int uses_unions_or_anon_p = 0;
1306
1307 /* Build up a list of initializations. The TREE_PURPOSE of entry
1308 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
1309 TREE_VALUE will be the constructor arguments, or NULL if no
1310 explicit initialization was provided. */
1311 sorted_inits = NULL_TREE;
1312
1313 /* Process the virtual bases. */
1314 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
1315 vec_safe_iterate (v: vbases, ix: i, ptr: &base); i++)
1316 sorted_inits = tree_cons (base, NULL_TREE, sorted_inits);
1317
1318 /* Process the direct bases. */
1319 for (binfo = TYPE_BINFO (t), i = 0;
1320 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
1321 if (!BINFO_VIRTUAL_P (base_binfo))
1322 sorted_inits = tree_cons (base_binfo, NULL_TREE, sorted_inits);
1323
1324 /* Process the non-static data members. */
1325 sorted_inits = build_field_list (t, list: sorted_inits, uses_unions_or_anon_p: &uses_unions_or_anon_p);
1326 /* Reverse the entire list of initializations, so that they are in
1327 the order that they will actually be performed. */
1328 sorted_inits = nreverse (sorted_inits);
1329
1330 /* If the user presented the initializers in an order different from
1331 that in which they will actually occur, we issue a warning. Keep
1332 track of the next subobject which can be explicitly initialized
1333 without issuing a warning. */
1334 next_subobject = sorted_inits;
1335
1336 /* Go through the explicit initializers, filling in TREE_PURPOSE in
1337 the SORTED_INITS. */
1338 for (init = mem_inits; init; init = TREE_CHAIN (init))
1339 {
1340 tree subobject;
1341 tree subobject_init;
1342
1343 subobject = TREE_PURPOSE (init);
1344
1345 /* If the explicit initializers are in sorted order, then
1346 SUBOBJECT will be NEXT_SUBOBJECT, or something following
1347 it. */
1348 for (subobject_init = next_subobject;
1349 subobject_init;
1350 subobject_init = TREE_CHAIN (subobject_init))
1351 if (TREE_PURPOSE (subobject_init) == subobject)
1352 break;
1353
1354 /* Issue a warning if the explicit initializer order does not
1355 match that which will actually occur.
1356 ??? Are all these on the correct lines? */
1357 if (warn_reorder && !subobject_init)
1358 {
1359 if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)
1360 warning_at (DECL_SOURCE_LOCATION (TREE_PURPOSE (next_subobject)),
1361 OPT_Wreorder, "%qD will be initialized after",
1362 TREE_PURPOSE (next_subobject));
1363 else
1364 warning (OPT_Wreorder, "base %qT will be initialized after",
1365 TREE_PURPOSE (next_subobject));
1366 if (TREE_CODE (subobject) == FIELD_DECL)
1367 warning_at (DECL_SOURCE_LOCATION (subobject),
1368 OPT_Wreorder, " %q#D", subobject);
1369 else
1370 warning (OPT_Wreorder, " base %qT", subobject);
1371 warning_at (DECL_SOURCE_LOCATION (current_function_decl),
1372 OPT_Wreorder, " when initialized here");
1373 }
1374
1375 /* Look again, from the beginning of the list. */
1376 if (!subobject_init)
1377 {
1378 subobject_init = sorted_inits;
1379 while (TREE_PURPOSE (subobject_init) != subobject)
1380 subobject_init = TREE_CHAIN (subobject_init);
1381 }
1382
1383 /* It is invalid to initialize the same subobject more than
1384 once. */
1385 if (TREE_VALUE (subobject_init))
1386 {
1387 if (TREE_CODE (subobject) == FIELD_DECL)
1388 error_at (DECL_SOURCE_LOCATION (current_function_decl),
1389 "multiple initializations given for %qD",
1390 subobject);
1391 else
1392 error_at (DECL_SOURCE_LOCATION (current_function_decl),
1393 "multiple initializations given for base %qT",
1394 subobject);
1395 }
1396
1397 /* Record the initialization. */
1398 TREE_VALUE (subobject_init) = TREE_VALUE (init);
1399 /* Carry over the dummy TREE_TYPE node containing the source location. */
1400 TREE_TYPE (subobject_init) = TREE_TYPE (init);
1401 next_subobject = subobject_init;
1402 }
1403
1404 /* [class.base.init]
1405
1406 If a ctor-initializer specifies more than one mem-initializer for
1407 multiple members of the same union (including members of
1408 anonymous unions), the ctor-initializer is ill-formed.
1409
1410 Here we also splice out uninitialized union members. */
1411 if (uses_unions_or_anon_p)
1412 {
1413 tree *last_p = NULL;
1414 tree *p;
1415 for (p = &sorted_inits; *p; )
1416 {
1417 tree field;
1418 tree ctx;
1419
1420 init = *p;
1421
1422 field = TREE_PURPOSE (init);
1423
1424 /* Skip base classes. */
1425 if (TREE_CODE (field) != FIELD_DECL)
1426 goto next;
1427
1428 /* If this is an anonymous aggregate with no explicit initializer,
1429 splice it out. */
1430 if (!TREE_VALUE (init) && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1431 goto splice;
1432
1433 /* See if this field is a member of a union, or a member of a
1434 structure contained in a union, etc. */
1435 ctx = innermost_aggr_scope (field);
1436
1437 /* If this field is not a member of a union, skip it. */
1438 if (TREE_CODE (ctx) != UNION_TYPE
1439 && !ANON_AGGR_TYPE_P (ctx))
1440 goto next;
1441
1442 /* If this union member has no explicit initializer and no NSDMI,
1443 splice it out. */
1444 if (TREE_VALUE (init) || DECL_INITIAL (field))
1445 /* OK. */;
1446 else
1447 goto splice;
1448
1449 /* It's only an error if we have two initializers for the same
1450 union type. */
1451 if (!last_p)
1452 {
1453 last_p = p;
1454 goto next;
1455 }
1456
1457 /* See if LAST_FIELD and the field initialized by INIT are
1458 members of the same union (or the union itself). If so, there's
1459 a problem, unless they're actually members of the same structure
1460 which is itself a member of a union. For example, given:
1461
1462 union { struct { int i; int j; }; };
1463
1464 initializing both `i' and `j' makes sense. */
1465 ctx = common_enclosing_class
1466 (innermost_aggr_scope (field),
1467 innermost_aggr_scope (TREE_PURPOSE (*last_p)));
1468
1469 if (ctx && (TREE_CODE (ctx) == UNION_TYPE
1470 || ctx == TREE_TYPE (TREE_PURPOSE (*last_p))))
1471 {
1472 /* A mem-initializer hides an NSDMI. */
1473 if (TREE_VALUE (init) && !TREE_VALUE (*last_p))
1474 *last_p = TREE_CHAIN (*last_p);
1475 else if (TREE_VALUE (*last_p) && !TREE_VALUE (init))
1476 goto splice;
1477 else
1478 {
1479 error_at (DECL_SOURCE_LOCATION (current_function_decl),
1480 "initializations for multiple members of %qT",
1481 ctx);
1482 goto splice;
1483 }
1484 }
1485
1486 last_p = p;
1487
1488 next:
1489 p = &TREE_CHAIN (*p);
1490 continue;
1491 splice:
1492 *p = TREE_CHAIN (*p);
1493 }
1494 }
1495
1496 return sorted_inits;
1497}
1498
1499/* Callback for cp_walk_tree to mark all PARM_DECLs in a tree as read. */
1500
1501static tree
1502mark_exp_read_r (tree *tp, int *, void *)
1503{
1504 tree t = *tp;
1505 if (TREE_CODE (t) == PARM_DECL)
1506 mark_exp_read (t);
1507 return NULL_TREE;
1508}
1509
1510/* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
1511 is a TREE_LIST giving the explicit mem-initializer-list for the
1512 constructor. The TREE_PURPOSE of each entry is a subobject (a
1513 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
1514 is a TREE_LIST giving the arguments to the constructor or
1515 void_type_node for an empty list of arguments. */
1516
1517void
1518emit_mem_initializers (tree mem_inits)
1519{
1520 int flags = LOOKUP_NORMAL;
1521
1522 /* We will already have issued an error message about the fact that
1523 the type is incomplete. */
1524 if (!COMPLETE_TYPE_P (current_class_type))
1525 return;
1526
1527 /* Keep a set holding fields that are not initialized. */
1528 hash_set<tree> uninitialized;
1529
1530 /* Initially that is all of them. */
1531 if (warn_uninitialized)
1532 for (tree f = next_aggregate_field (TYPE_FIELDS (current_class_type));
1533 f != NULL_TREE;
1534 f = next_aggregate_field (DECL_CHAIN (f)))
1535 if (!DECL_ARTIFICIAL (f)
1536 && !is_really_empty_class (TREE_TYPE (f), /*ignore_vptr*/false))
1537 uninitialized.add (k: f);
1538
1539 if (mem_inits
1540 && TYPE_P (TREE_PURPOSE (mem_inits))
1541 && same_type_p (TREE_PURPOSE (mem_inits), current_class_type))
1542 {
1543 /* Delegating constructor. */
1544 gcc_assert (TREE_CHAIN (mem_inits) == NULL_TREE);
1545 tree ctor = perform_target_ctor (TREE_VALUE (mem_inits));
1546 find_uninit_fields (t: &ctor, uninitialized: &uninitialized, current_class_type);
1547 return;
1548 }
1549
1550 if (DECL_DEFAULTED_FN (current_function_decl)
1551 && ! DECL_INHERITED_CTOR (current_function_decl))
1552 flags |= LOOKUP_DEFAULTED;
1553
1554 /* Sort the mem-initializers into the order in which the
1555 initializations should be performed. */
1556 mem_inits = sort_mem_initializers (current_class_type, mem_inits);
1557
1558 in_base_initializer = 1;
1559
1560 /* Initialize base classes. */
1561 for (; (mem_inits
1562 && TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL);
1563 mem_inits = TREE_CHAIN (mem_inits))
1564 {
1565 tree subobject = TREE_PURPOSE (mem_inits);
1566 tree arguments = TREE_VALUE (mem_inits);
1567
1568 /* We already have issued an error message. */
1569 if (arguments == error_mark_node)
1570 continue;
1571
1572 /* Suppress access control when calling the inherited ctor. */
1573 bool inherited_base = (DECL_INHERITED_CTOR (current_function_decl)
1574 && flag_new_inheriting_ctors
1575 && arguments);
1576 if (inherited_base)
1577 push_deferring_access_checks (dk_deferred);
1578
1579 if (arguments == NULL_TREE)
1580 {
1581 /* If these initializations are taking place in a copy constructor,
1582 the base class should probably be explicitly initialized if there
1583 is a user-defined constructor in the base class (other than the
1584 default constructor, which will be called anyway). */
1585 if (extra_warnings
1586 && DECL_COPY_CONSTRUCTOR_P (current_function_decl)
1587 && type_has_user_nondefault_constructor (BINFO_TYPE (subobject)))
1588 warning_at (DECL_SOURCE_LOCATION (current_function_decl),
1589 OPT_Wextra, "base class %q#T should be explicitly "
1590 "initialized in the copy constructor",
1591 BINFO_TYPE (subobject));
1592 }
1593
1594 /* Initialize the base. */
1595 if (!BINFO_VIRTUAL_P (subobject))
1596 {
1597 tree base_addr;
1598
1599 base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
1600 subobject, 1, tf_warning_or_error);
1601 expand_aggr_init_1 (subobject, NULL_TREE,
1602 cp_build_fold_indirect_ref (base_addr),
1603 arguments,
1604 flags,
1605 tf_warning_or_error);
1606 expand_cleanup_for_base (subobject, NULL_TREE);
1607 if (STATEMENT_LIST_TAIL (cur_stmt_list))
1608 find_uninit_fields (t: &STATEMENT_LIST_TAIL (cur_stmt_list)->stmt,
1609 uninitialized: &uninitialized, BINFO_TYPE (subobject));
1610 }
1611 else if (!ABSTRACT_CLASS_TYPE_P (current_class_type))
1612 /* C++14 DR1658 Means we do not have to construct vbases of
1613 abstract classes. */
1614 construct_virtual_base (subobject, arguments);
1615 else
1616 /* When not constructing vbases of abstract classes, at least mark
1617 the arguments expressions as read to avoid
1618 -Wunused-but-set-parameter false positives. */
1619 cp_walk_tree (&arguments, mark_exp_read_r, NULL, NULL);
1620
1621 if (inherited_base)
1622 pop_deferring_access_checks ();
1623 }
1624 in_base_initializer = 0;
1625
1626 /* Initialize the vptrs. */
1627 initialize_vtbl_ptrs (current_class_ptr);
1628
1629 /* Initialize the data members. */
1630 while (mem_inits)
1631 {
1632 /* If this initializer was explicitly provided, then the dummy TREE_TYPE
1633 node contains the source location. */
1634 iloc_sentinel ils (EXPR_LOCATION (TREE_TYPE (mem_inits)));
1635
1636 perform_member_init (TREE_PURPOSE (mem_inits),
1637 TREE_VALUE (mem_inits),
1638 uninitialized);
1639
1640 mem_inits = TREE_CHAIN (mem_inits);
1641 }
1642}
1643
1644/* Returns the address of the vtable (i.e., the value that should be
1645 assigned to the vptr) for BINFO. */
1646
1647tree
1648build_vtbl_address (tree binfo)
1649{
1650 tree binfo_for = binfo;
1651 tree vtbl;
1652
1653 if (BINFO_VPTR_INDEX (binfo) && BINFO_VIRTUAL_P (binfo))
1654 /* If this is a virtual primary base, then the vtable we want to store
1655 is that for the base this is being used as the primary base of. We
1656 can't simply skip the initialization, because we may be expanding the
1657 inits of a subobject constructor where the virtual base layout
1658 can be different. */
1659 while (BINFO_PRIMARY_P (binfo_for))
1660 binfo_for = BINFO_INHERITANCE_CHAIN (binfo_for);
1661
1662 /* Figure out what vtable BINFO's vtable is based on, and mark it as
1663 used. */
1664 vtbl = get_vtbl_decl_for_binfo (binfo_for);
1665 TREE_USED (vtbl) = true;
1666
1667 /* Now compute the address to use when initializing the vptr. */
1668 vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
1669 if (VAR_P (vtbl))
1670 vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
1671
1672 return vtbl;
1673}
1674
1675/* This code sets up the virtual function tables appropriate for
1676 the pointer DECL. It is a one-ply initialization.
1677
1678 BINFO is the exact type that DECL is supposed to be. In
1679 multiple inheritance, this might mean "C's A" if C : A, B. */
1680
1681static void
1682expand_virtual_init (tree binfo, tree decl)
1683{
1684 tree vtbl, vtbl_ptr;
1685 tree vtt_index;
1686
1687 /* Compute the initializer for vptr. */
1688 vtbl = build_vtbl_address (binfo);
1689
1690 /* We may get this vptr from a VTT, if this is a subobject
1691 constructor or subobject destructor. */
1692 vtt_index = BINFO_VPTR_INDEX (binfo);
1693 if (vtt_index)
1694 {
1695 tree vtbl2;
1696 tree vtt_parm;
1697
1698 /* Compute the value to use, when there's a VTT. */
1699 vtt_parm = current_vtt_parm;
1700 vtbl2 = fold_build_pointer_plus (vtt_parm, vtt_index);
1701 vtbl2 = cp_build_fold_indirect_ref (vtbl2);
1702 vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
1703
1704 /* The actual initializer is the VTT value only in the subobject
1705 constructor. In maybe_clone_body we'll substitute NULL for
1706 the vtt_parm in the case of the non-subobject constructor. */
1707 vtbl = build_if_in_charge (true_stmt: vtbl, false_stmt: vtbl2);
1708 }
1709
1710 /* Compute the location of the vtpr. */
1711 vtbl_ptr = build_vfield_ref (cp_build_fold_indirect_ref (decl),
1712 TREE_TYPE (binfo));
1713 gcc_assert (vtbl_ptr != error_mark_node);
1714
1715 /* Assign the vtable to the vptr. */
1716 vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0, tf_warning_or_error);
1717 finish_expr_stmt (cp_build_modify_expr (input_location, vtbl_ptr, NOP_EXPR,
1718 vtbl, tf_warning_or_error));
1719}
1720
1721/* If an exception is thrown in a constructor, those base classes already
1722 constructed must be destroyed. This function creates the cleanup
1723 for BINFO, which has just been constructed. If FLAG is non-NULL,
1724 it is a DECL which is nonzero when this base needs to be
1725 destroyed. */
1726
1727static void
1728expand_cleanup_for_base (tree binfo, tree flag)
1729{
1730 tree expr;
1731
1732 if (!type_build_dtor_call (BINFO_TYPE (binfo)))
1733 return;
1734
1735 /* Call the destructor. */
1736 expr = build_special_member_call (current_class_ref,
1737 base_dtor_identifier,
1738 NULL,
1739 binfo,
1740 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
1741 tf_warning_or_error);
1742
1743 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
1744 return;
1745
1746 if (flag)
1747 expr = fold_build3_loc (input_location,
1748 COND_EXPR, void_type_node,
1749 c_common_truthvalue_conversion (input_location, flag),
1750 expr, integer_zero_node);
1751
1752 finish_eh_cleanup (expr);
1753}
1754
1755/* Construct the virtual base-class VBASE passing the ARGUMENTS to its
1756 constructor. */
1757
1758static void
1759construct_virtual_base (tree vbase, tree arguments)
1760{
1761 tree inner_if_stmt;
1762 tree exp;
1763 tree flag;
1764
1765 /* If there are virtual base classes with destructors, we need to
1766 emit cleanups to destroy them if an exception is thrown during
1767 the construction process. These exception regions (i.e., the
1768 period during which the cleanups must occur) begin from the time
1769 the construction is complete to the end of the function. If we
1770 create a conditional block in which to initialize the
1771 base-classes, then the cleanup region for the virtual base begins
1772 inside a block, and ends outside of that block. This situation
1773 confuses the sjlj exception-handling code. Therefore, we do not
1774 create a single conditional block, but one for each
1775 initialization. (That way the cleanup regions always begin
1776 in the outer block.) We trust the back end to figure out
1777 that the FLAG will not change across initializations, and
1778 avoid doing multiple tests. */
1779 flag = DECL_CHAIN (DECL_ARGUMENTS (current_function_decl));
1780 inner_if_stmt = begin_if_stmt ();
1781 finish_if_stmt_cond (flag, inner_if_stmt);
1782
1783 /* Compute the location of the virtual base. If we're
1784 constructing virtual bases, then we must be the most derived
1785 class. Therefore, we don't have to look up the virtual base;
1786 we already know where it is. */
1787 exp = convert_to_base_statically (current_class_ref, vbase);
1788
1789 expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
1790 0, tf_warning_or_error);
1791 finish_then_clause (inner_if_stmt);
1792 finish_if_stmt (inner_if_stmt);
1793
1794 expand_cleanup_for_base (binfo: vbase, flag);
1795}
1796
1797/* Find the context in which this FIELD can be initialized. */
1798
1799static tree
1800initializing_context (tree field)
1801{
1802 tree t = DECL_CONTEXT (field);
1803
1804 /* Anonymous union members can be initialized in the first enclosing
1805 non-anonymous union context. */
1806 while (t && ANON_AGGR_TYPE_P (t))
1807 t = TYPE_CONTEXT (t);
1808 return t;
1809}
1810
1811/* Function to give error message if member initialization specification
1812 is erroneous. FIELD is the member we decided to initialize.
1813 TYPE is the type for which the initialization is being performed.
1814 FIELD must be a member of TYPE.
1815
1816 MEMBER_NAME is the name of the member. */
1817
1818static int
1819member_init_ok_or_else (tree field, tree type, tree member_name)
1820{
1821 if (field == error_mark_node)
1822 return 0;
1823 if (!field)
1824 {
1825 error ("class %qT does not have any field named %qD", type,
1826 member_name);
1827 return 0;
1828 }
1829 if (VAR_P (field))
1830 {
1831 error ("%q#D is a static data member; it can only be "
1832 "initialized at its definition",
1833 field);
1834 return 0;
1835 }
1836 if (TREE_CODE (field) != FIELD_DECL)
1837 {
1838 error ("%q#D is not a non-static data member of %qT",
1839 field, type);
1840 return 0;
1841 }
1842 if (initializing_context (field) != type)
1843 {
1844 error ("class %qT does not have any field named %qD", type,
1845 member_name);
1846 return 0;
1847 }
1848
1849 return 1;
1850}
1851
1852/* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1853 is a _TYPE node or TYPE_DECL which names a base for that type.
1854 Check the validity of NAME, and return either the base _TYPE, base
1855 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
1856 NULL_TREE and issue a diagnostic.
1857
1858 An old style unnamed direct single base construction is permitted,
1859 where NAME is NULL. */
1860
1861tree
1862expand_member_init (tree name)
1863{
1864 tree basetype;
1865 tree field;
1866
1867 if (!current_class_ref)
1868 return NULL_TREE;
1869
1870 if (!name)
1871 {
1872 /* This is an obsolete unnamed base class initializer. The
1873 parser will already have warned about its use. */
1874 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type)))
1875 {
1876 case 0:
1877 error ("unnamed initializer for %qT, which has no base classes",
1878 current_class_type);
1879 return NULL_TREE;
1880 case 1:
1881 basetype = BINFO_TYPE
1882 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0));
1883 break;
1884 default:
1885 error ("unnamed initializer for %qT, which uses multiple inheritance",
1886 current_class_type);
1887 return NULL_TREE;
1888 }
1889 }
1890 else if (TYPE_P (name))
1891 {
1892 basetype = TYPE_MAIN_VARIANT (name);
1893 name = TYPE_NAME (name);
1894 }
1895 else if (TREE_CODE (name) == TYPE_DECL)
1896 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
1897 else
1898 basetype = NULL_TREE;
1899
1900 if (basetype)
1901 {
1902 tree class_binfo;
1903 tree direct_binfo;
1904 tree virtual_binfo;
1905 int i;
1906
1907 if (current_template_parms
1908 || same_type_p (basetype, current_class_type))
1909 return basetype;
1910
1911 class_binfo = TYPE_BINFO (current_class_type);
1912 direct_binfo = NULL_TREE;
1913 virtual_binfo = NULL_TREE;
1914
1915 /* Look for a direct base. */
1916 for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i)
1917 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo), basetype))
1918 break;
1919
1920 /* Look for a virtual base -- unless the direct base is itself
1921 virtual. */
1922 if (!direct_binfo || !BINFO_VIRTUAL_P (direct_binfo))
1923 virtual_binfo = binfo_for_vbase (basetype, current_class_type);
1924
1925 /* [class.base.init]
1926
1927 If a mem-initializer-id is ambiguous because it designates
1928 both a direct non-virtual base class and an inherited virtual
1929 base class, the mem-initializer is ill-formed. */
1930 if (direct_binfo && virtual_binfo)
1931 {
1932 error ("%qD is both a direct base and an indirect virtual base",
1933 basetype);
1934 return NULL_TREE;
1935 }
1936
1937 if (!direct_binfo && !virtual_binfo)
1938 {
1939 if (CLASSTYPE_VBASECLASSES (current_class_type))
1940 error ("type %qT is not a direct or virtual base of %qT",
1941 basetype, current_class_type);
1942 else
1943 error ("type %qT is not a direct base of %qT",
1944 basetype, current_class_type);
1945 return NULL_TREE;
1946 }
1947
1948 return direct_binfo ? direct_binfo : virtual_binfo;
1949 }
1950 else
1951 {
1952 if (identifier_p (t: name))
1953 field = lookup_field (current_class_type, name, 1, false);
1954 else
1955 field = name;
1956
1957 if (member_init_ok_or_else (field, current_class_type, member_name: name))
1958 return field;
1959 }
1960
1961 return NULL_TREE;
1962}
1963
1964/* This is like `expand_member_init', only it stores one aggregate
1965 value into another.
1966
1967 INIT comes in two flavors: it is either a value which
1968 is to be stored in EXP, or it is a parameter list
1969 to go to a constructor, which will operate on EXP.
1970 If INIT is not a parameter list for a constructor, then set
1971 LOOKUP_ONLYCONVERTING.
1972 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1973 the initializer, if FLAGS is 0, then it is the (init) form.
1974 If `init' is a CONSTRUCTOR, then we emit a warning message,
1975 explaining that such initializations are invalid.
1976
1977 If INIT resolves to a CALL_EXPR which happens to return
1978 something of the type we are looking for, then we know
1979 that we can safely use that call to perform the
1980 initialization.
1981
1982 The virtual function table pointer cannot be set up here, because
1983 we do not really know its type.
1984
1985 This never calls operator=().
1986
1987 When initializing, nothing is CONST.
1988
1989 A default copy constructor may have to be used to perform the
1990 initialization.
1991
1992 A constructor or a conversion operator may have to be used to
1993 perform the initialization, but not both, as it would be ambiguous. */
1994
1995tree
1996build_aggr_init (tree exp, tree init, int flags, tsubst_flags_t complain)
1997{
1998 tree stmt_expr;
1999 tree compound_stmt;
2000 int destroy_temps;
2001 tree type = TREE_TYPE (exp);
2002 int was_const = TREE_READONLY (exp);
2003 int was_volatile = TREE_THIS_VOLATILE (exp);
2004 int is_global;
2005
2006 if (init == error_mark_node)
2007 return error_mark_node;
2008
2009 location_t init_loc = (init
2010 ? cp_expr_loc_or_input_loc (t: init)
2011 : location_of (exp));
2012
2013 TREE_READONLY (exp) = 0;
2014 TREE_THIS_VOLATILE (exp) = 0;
2015
2016 if (TREE_CODE (type) == ARRAY_TYPE)
2017 {
2018 tree itype = init ? TREE_TYPE (init) : NULL_TREE;
2019 int from_array = 0;
2020
2021 if (DECL_DECOMPOSITION_P (exp))
2022 {
2023 from_array = 1;
2024 init = mark_rvalue_use (init);
2025 if (init
2026 && DECL_P (tree_strip_any_location_wrapper (init))
2027 && !(flags & LOOKUP_ONLYCONVERTING))
2028 {
2029 /* Wrap the initializer in a CONSTRUCTOR so that build_vec_init
2030 recognizes it as direct-initialization. */
2031 init = build_constructor_single (init_list_type_node,
2032 NULL_TREE, init);
2033 CONSTRUCTOR_IS_DIRECT_INIT (init) = true;
2034 }
2035 }
2036 else
2037 {
2038 /* Must arrange to initialize each element of EXP
2039 from elements of INIT. */
2040 if (cv_qualified_p (type))
2041 TREE_TYPE (exp) = cv_unqualified (type);
2042 if (itype && cv_qualified_p (itype))
2043 TREE_TYPE (init) = cv_unqualified (itype);
2044 from_array = (itype && same_type_p (TREE_TYPE (init),
2045 TREE_TYPE (exp)));
2046
2047 if (init && !BRACE_ENCLOSED_INITIALIZER_P (init)
2048 && (!from_array
2049 || (TREE_CODE (init) != CONSTRUCTOR
2050 /* Can happen, eg, handling the compound-literals
2051 extension (ext/complit12.C). */
2052 && TREE_CODE (init) != TARGET_EXPR)))
2053 {
2054 if (complain & tf_error)
2055 error_at (init_loc, "array must be initialized "
2056 "with a brace-enclosed initializer");
2057 return error_mark_node;
2058 }
2059 }
2060
2061 stmt_expr = build_vec_init (exp, NULL_TREE, init,
2062 /*explicit_value_init_p=*/false,
2063 from_array,
2064 complain);
2065 TREE_READONLY (exp) = was_const;
2066 TREE_THIS_VOLATILE (exp) = was_volatile;
2067 TREE_TYPE (exp) = type;
2068 /* Restore the type of init unless it was used directly. */
2069 if (init && TREE_CODE (stmt_expr) != INIT_EXPR)
2070 TREE_TYPE (init) = itype;
2071 return stmt_expr;
2072 }
2073
2074 if (is_copy_initialization (init))
2075 flags |= LOOKUP_ONLYCONVERTING;
2076
2077 is_global = begin_init_stmts (stmt_expr_p: &stmt_expr, compound_stmt_p: &compound_stmt);
2078 destroy_temps = stmts_are_full_exprs_p ();
2079 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2080 bool ok = expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
2081 init, LOOKUP_NORMAL|flags, complain);
2082 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
2083 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
2084 TREE_READONLY (exp) = was_const;
2085 TREE_THIS_VOLATILE (exp) = was_volatile;
2086 if (!ok)
2087 return error_mark_node;
2088
2089 if ((VAR_P (exp) || TREE_CODE (exp) == PARM_DECL)
2090 && TREE_SIDE_EFFECTS (stmt_expr)
2091 && !lookup_attribute (attr_name: "warn_unused", TYPE_ATTRIBUTES (type)))
2092 /* Just know that we've seen something for this node. */
2093 TREE_USED (exp) = 1;
2094
2095 return stmt_expr;
2096}
2097
2098static bool
2099expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags,
2100 tsubst_flags_t complain)
2101{
2102 tree type = TREE_TYPE (exp);
2103
2104 /* It fails because there may not be a constructor which takes
2105 its own type as the first (or only parameter), but which does
2106 take other types via a conversion. So, if the thing initializing
2107 the expression is a unit element of type X, first try X(X&),
2108 followed by initialization by X. If neither of these work
2109 out, then look hard. */
2110 tree rval;
2111 vec<tree, va_gc> *parms;
2112
2113 /* If we have direct-initialization from an initializer list, pull
2114 it out of the TREE_LIST so the code below can see it. */
2115 if (init && TREE_CODE (init) == TREE_LIST
2116 && DIRECT_LIST_INIT_P (TREE_VALUE (init)))
2117 {
2118 gcc_checking_assert ((flags & LOOKUP_ONLYCONVERTING) == 0
2119 && TREE_CHAIN (init) == NULL_TREE);
2120 init = TREE_VALUE (init);
2121 /* Only call reshape_init if it has not been called earlier
2122 by the callers. */
2123 if (BRACE_ENCLOSED_INITIALIZER_P (init) && CP_AGGREGATE_TYPE_P (type))
2124 init = reshape_init (type, init, complain);
2125 }
2126
2127 if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
2128 && CP_AGGREGATE_TYPE_P (type))
2129 /* A brace-enclosed initializer for an aggregate. In C++0x this can
2130 happen for direct-initialization, too. */
2131 init = digest_init (type, init, complain);
2132
2133 if (init == error_mark_node)
2134 return false;
2135
2136 /* A CONSTRUCTOR of the target's type is a previously digested
2137 initializer, whether that happened just above or in
2138 cp_parser_late_parsing_nsdmi.
2139
2140 A TARGET_EXPR with TARGET_EXPR_DIRECT_INIT_P or TARGET_EXPR_LIST_INIT_P
2141 set represents the whole initialization, so we shouldn't build up
2142 another ctor call. */
2143 if (init
2144 && (TREE_CODE (init) == CONSTRUCTOR
2145 || (TREE_CODE (init) == TARGET_EXPR
2146 && (TARGET_EXPR_DIRECT_INIT_P (init)
2147 || TARGET_EXPR_LIST_INIT_P (init))))
2148 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (init), type))
2149 {
2150 /* Early initialization via a TARGET_EXPR only works for
2151 complete objects. */
2152 gcc_assert (TREE_CODE (init) == CONSTRUCTOR || true_exp == exp);
2153
2154 init = cp_build_init_expr (t: exp, i: init);
2155 TREE_SIDE_EFFECTS (init) = 1;
2156 finish_expr_stmt (init);
2157 return true;
2158 }
2159
2160 if (init && TREE_CODE (init) != TREE_LIST
2161 && (flags & LOOKUP_ONLYCONVERTING)
2162 && !unsafe_return_slot_p (exp))
2163 {
2164 /* Base subobjects should only get direct-initialization. */
2165 gcc_assert (true_exp == exp);
2166
2167 if (flags & DIRECT_BIND)
2168 /* Do nothing. We hit this in two cases: Reference initialization,
2169 where we aren't initializing a real variable, so we don't want
2170 to run a new constructor; and catching an exception, where we
2171 have already built up the constructor call so we could wrap it
2172 in an exception region. */;
2173 else
2174 {
2175 init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP,
2176 flags, complain | tf_no_cleanup);
2177 if (init == error_mark_node)
2178 return false;
2179 }
2180
2181 /* We need to protect the initialization of a catch parm with a
2182 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
2183 around the TARGET_EXPR for the copy constructor. See
2184 initialize_handler_parm. */
2185 tree *p = &init;
2186 while (TREE_CODE (*p) == MUST_NOT_THROW_EXPR
2187 || TREE_CODE (*p) == CLEANUP_POINT_EXPR)
2188 {
2189 /* Avoid voidify_wrapper_expr making a temporary. */
2190 TREE_TYPE (*p) = void_type_node;
2191 p = &TREE_OPERAND (*p, 0);
2192 }
2193 *p = cp_build_init_expr (t: exp, i: *p);
2194 finish_expr_stmt (init);
2195 return true;
2196 }
2197
2198 if (init == NULL_TREE)
2199 parms = NULL;
2200 else if (TREE_CODE (init) == TREE_LIST && !TREE_TYPE (init))
2201 {
2202 parms = make_tree_vector ();
2203 for (; init != NULL_TREE; init = TREE_CHAIN (init))
2204 vec_safe_push (v&: parms, TREE_VALUE (init));
2205 }
2206 else
2207 parms = make_tree_vector_single (init);
2208
2209 if (exp == current_class_ref && current_function_decl
2210 && DECL_HAS_IN_CHARGE_PARM_P (current_function_decl))
2211 {
2212 /* Delegating constructor. */
2213 tree complete;
2214 tree base;
2215 tree elt; unsigned i;
2216
2217 /* Unshare the arguments for the second call. */
2218 releasing_vec parms2;
2219 FOR_EACH_VEC_SAFE_ELT (parms, i, elt)
2220 {
2221 elt = break_out_target_exprs (elt);
2222 vec_safe_push (r&: parms2, t: elt);
2223 }
2224 complete = build_special_member_call (exp, complete_ctor_identifier,
2225 &parms2, binfo, flags,
2226 complain);
2227 complete = fold_build_cleanup_point_expr (void_type_node, expr: complete);
2228
2229 base = build_special_member_call (exp, base_ctor_identifier,
2230 &parms, binfo, flags,
2231 complain);
2232 base = fold_build_cleanup_point_expr (void_type_node, expr: base);
2233 if (complete == error_mark_node || base == error_mark_node)
2234 return false;
2235 rval = build_if_in_charge (true_stmt: complete, false_stmt: base);
2236 }
2237 else
2238 {
2239 tree ctor_name = (true_exp == exp
2240 ? complete_ctor_identifier : base_ctor_identifier);
2241
2242 rval = build_special_member_call (exp, ctor_name, &parms, binfo, flags,
2243 complain);
2244 if (rval == error_mark_node)
2245 return false;
2246 }
2247
2248 if (parms != NULL)
2249 release_tree_vector (parms);
2250
2251 if (exp == true_exp && TREE_CODE (rval) == CALL_EXPR)
2252 {
2253 tree fn = get_callee_fndecl (rval);
2254 if (fn && DECL_DECLARED_CONSTEXPR_P (fn))
2255 {
2256 tree e = maybe_constant_init (rval, exp);
2257 if (TREE_CONSTANT (e))
2258 rval = cp_build_init_expr (t: exp, i: e);
2259 }
2260 }
2261
2262 /* FIXME put back convert_to_void? */
2263 if (TREE_SIDE_EFFECTS (rval))
2264 finish_expr_stmt (rval);
2265
2266 return true;
2267}
2268
2269/* This function is responsible for initializing EXP with INIT
2270 (if any). Returns true on success, false on failure.
2271
2272 BINFO is the binfo of the type for who we are performing the
2273 initialization. For example, if W is a virtual base class of A and B,
2274 and C : A, B.
2275 If we are initializing B, then W must contain B's W vtable, whereas
2276 were we initializing C, W must contain C's W vtable.
2277
2278 TRUE_EXP is nonzero if it is the true expression being initialized.
2279 In this case, it may be EXP, or may just contain EXP. The reason we
2280 need this is because if EXP is a base element of TRUE_EXP, we
2281 don't necessarily know by looking at EXP where its virtual
2282 baseclass fields should really be pointing. But we do know
2283 from TRUE_EXP. In constructors, we don't know anything about
2284 the value being initialized.
2285
2286 FLAGS is just passed to `build_new_method_call'. See that function
2287 for its description. */
2288
2289static bool
2290expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags,
2291 tsubst_flags_t complain)
2292{
2293 tree type = TREE_TYPE (exp);
2294
2295 gcc_assert (init != error_mark_node && type != error_mark_node);
2296 gcc_assert (building_stmt_list_p ());
2297
2298 /* Use a function returning the desired type to initialize EXP for us.
2299 If the function is a constructor, and its first argument is
2300 NULL_TREE, know that it was meant for us--just slide exp on
2301 in and expand the constructor. Constructors now come
2302 as TARGET_EXPRs. */
2303
2304 if (init && VAR_P (exp)
2305 && COMPOUND_LITERAL_P (init))
2306 {
2307 vec<tree, va_gc> *cleanups = NULL;
2308 /* If store_init_value returns NULL_TREE, the INIT has been
2309 recorded as the DECL_INITIAL for EXP. That means there's
2310 nothing more we have to do. */
2311 init = store_init_value (exp, init, &cleanups, flags);
2312 if (init)
2313 finish_expr_stmt (init);
2314 gcc_assert (!cleanups);
2315 return true;
2316 }
2317
2318 /* List-initialization from {} becomes value-initialization for non-aggregate
2319 classes with default constructors. Handle this here when we're
2320 initializing a base, so protected access works. */
2321 if (exp != true_exp && init && TREE_CODE (init) == TREE_LIST)
2322 {
2323 tree elt = TREE_VALUE (init);
2324 if (DIRECT_LIST_INIT_P (elt)
2325 && CONSTRUCTOR_ELTS (elt) == 0
2326 && CLASSTYPE_NON_AGGREGATE (type)
2327 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2328 init = void_type_node;
2329 }
2330
2331 /* If an explicit -- but empty -- initializer list was present,
2332 that's value-initialization. */
2333 if (init == void_type_node)
2334 {
2335 /* If the type has data but no user-provided default ctor, we need to zero
2336 out the object. */
2337 if (type_has_non_user_provided_default_constructor (type)
2338 && !is_really_empty_class (type, /*ignore_vptr*/true))
2339 {
2340 tree field_size = NULL_TREE;
2341 if (exp != true_exp && CLASSTYPE_AS_BASE (type) != type)
2342 /* Don't clobber already initialized virtual bases. */
2343 field_size = TYPE_SIZE (CLASSTYPE_AS_BASE (type));
2344 init = build_zero_init_1 (type, NULL_TREE, /*static_storage_p=*/false,
2345 field_size);
2346 init = cp_build_init_expr (t: exp, i: init);
2347 finish_expr_stmt (init);
2348 }
2349
2350 /* If we don't need to mess with the constructor at all,
2351 then we're done. */
2352 if (! type_build_ctor_call (type))
2353 return true;
2354
2355 /* Otherwise fall through and call the constructor. */
2356 init = NULL_TREE;
2357 }
2358
2359 /* We know that expand_default_init can handle everything we want
2360 at this point. */
2361 return expand_default_init (binfo, true_exp, exp, init, flags, complain);
2362}
2363
2364/* Report an error if TYPE is not a user-defined, class type. If
2365 OR_ELSE is nonzero, give an error message. */
2366
2367int
2368is_class_type (tree type, int or_else)
2369{
2370 if (type == error_mark_node)
2371 return 0;
2372
2373 if (! CLASS_TYPE_P (type))
2374 {
2375 if (or_else)
2376 error ("%qT is not a class type", type);
2377 return 0;
2378 }
2379 return 1;
2380}
2381
2382/* Returns true iff the initializer INIT represents copy-initialization
2383 (and therefore we must set LOOKUP_ONLYCONVERTING when processing it). */
2384
2385bool
2386is_copy_initialization (tree init)
2387{
2388 return (init && init != void_type_node
2389 && TREE_CODE (init) != TREE_LIST
2390 && !(TREE_CODE (init) == TARGET_EXPR
2391 && TARGET_EXPR_DIRECT_INIT_P (init))
2392 && !DIRECT_LIST_INIT_P (init));
2393}
2394
2395/* Build a reference to a member of an aggregate. This is not a C++
2396 `&', but really something which can have its address taken, and
2397 then act as a pointer to member, for example TYPE :: FIELD can have
2398 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
2399 this expression is the operand of "&".
2400
2401 @@ Prints out lousy diagnostics for operator <typename>
2402 @@ fields.
2403
2404 @@ This function should be rewritten and placed in search.cc. */
2405
2406tree
2407build_offset_ref (tree type, tree member, bool address_p,
2408 tsubst_flags_t complain)
2409{
2410 tree decl;
2411 tree basebinfo = NULL_TREE;
2412
2413 /* class templates can come in as TEMPLATE_DECLs here. */
2414 if (TREE_CODE (member) == TEMPLATE_DECL)
2415 return member;
2416
2417 if (dependent_scope_p (type) || type_dependent_expression_p (member))
2418 return build_qualified_name (NULL_TREE, type, member,
2419 /*template_p=*/false);
2420
2421 gcc_assert (TYPE_P (type));
2422 if (! is_class_type (type, or_else: 1))
2423 return error_mark_node;
2424
2425 gcc_assert (DECL_P (member) || BASELINK_P (member));
2426 /* Callers should call mark_used before this point, except for functions. */
2427 gcc_assert (!DECL_P (member) || TREE_USED (member)
2428 || TREE_CODE (member) == FUNCTION_DECL);
2429
2430 type = TYPE_MAIN_VARIANT (type);
2431 if (!COMPLETE_OR_OPEN_TYPE_P (complete_type (type)))
2432 {
2433 if (complain & tf_error)
2434 error ("incomplete type %qT does not have member %qD", type, member);
2435 return error_mark_node;
2436 }
2437
2438 /* Entities other than non-static members need no further
2439 processing. */
2440 if (TREE_CODE (member) == TYPE_DECL)
2441 return member;
2442 if (VAR_P (member) || TREE_CODE (member) == CONST_DECL)
2443 return convert_from_reference (member);
2444
2445 if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
2446 {
2447 if (complain & tf_error)
2448 error ("invalid pointer to bit-field %qD", member);
2449 return error_mark_node;
2450 }
2451
2452 /* Set up BASEBINFO for member lookup. */
2453 decl = maybe_dummy_object (type, &basebinfo);
2454
2455 /* A lot of this logic is now handled in lookup_member. */
2456 if (BASELINK_P (member))
2457 {
2458 /* Go from the TREE_BASELINK to the member function info. */
2459 tree t = BASELINK_FUNCTIONS (member);
2460
2461 if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
2462 {
2463 /* Get rid of a potential OVERLOAD around it. */
2464 t = OVL_FIRST (t);
2465
2466 /* Unique functions are handled easily. */
2467
2468 /* For non-static member of base class, we need a special rule
2469 for access checking [class.protected]:
2470
2471 If the access is to form a pointer to member, the
2472 nested-name-specifier shall name the derived class
2473 (or any class derived from that class). */
2474 bool ok;
2475 if (address_p && DECL_P (t)
2476 && DECL_NONSTATIC_MEMBER_P (t))
2477 ok = perform_or_defer_access_check (TYPE_BINFO (type), t, t,
2478 complain);
2479 else
2480 ok = perform_or_defer_access_check (basebinfo, t, t,
2481 complain);
2482 if (!ok)
2483 return error_mark_node;
2484 if (DECL_STATIC_FUNCTION_P (t))
2485 return member;
2486 member = t;
2487 }
2488 else
2489 TREE_TYPE (member) = unknown_type_node;
2490 }
2491 else if (address_p && TREE_CODE (member) == FIELD_DECL)
2492 {
2493 /* We need additional test besides the one in
2494 check_accessibility_of_qualified_id in case it is
2495 a pointer to non-static member. */
2496 if (!perform_or_defer_access_check (TYPE_BINFO (type), member, member,
2497 complain))
2498 return error_mark_node;
2499 }
2500
2501 if (!address_p)
2502 {
2503 /* If MEMBER is non-static, then the program has fallen afoul of
2504 [expr.prim]:
2505
2506 An id-expression that denotes a non-static data member or
2507 non-static member function of a class can only be used:
2508
2509 -- as part of a class member access (_expr.ref_) in which the
2510 object-expression refers to the member's class or a class
2511 derived from that class, or
2512
2513 -- to form a pointer to member (_expr.unary.op_), or
2514
2515 -- in the body of a non-static member function of that class or
2516 of a class derived from that class (_class.mfct.non-static_), or
2517
2518 -- in a mem-initializer for a constructor for that class or for
2519 a class derived from that class (_class.base.init_). */
2520 if (DECL_OBJECT_MEMBER_FUNCTION_P (member))
2521 {
2522 /* Build a representation of the qualified name suitable
2523 for use as the operand to "&" -- even though the "&" is
2524 not actually present. */
2525 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
2526 /* In Microsoft mode, treat a non-static member function as if
2527 it were a pointer-to-member. */
2528 if (flag_ms_extensions)
2529 {
2530 PTRMEM_OK_P (member) = 1;
2531 return cp_build_addr_expr (member, complain);
2532 }
2533 if (complain & tf_error)
2534 error ("invalid use of non-static member function %qD",
2535 TREE_OPERAND (member, 1));
2536 return error_mark_node;
2537 }
2538 else if (TREE_CODE (member) == FIELD_DECL)
2539 {
2540 if (complain & tf_error)
2541 error ("invalid use of non-static data member %qD", member);
2542 return error_mark_node;
2543 }
2544 return member;
2545 }
2546
2547 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
2548 PTRMEM_OK_P (member) = 1;
2549 return member;
2550}
2551
2552/* If DECL is a scalar enumeration constant or variable with a
2553 constant initializer, return the initializer (or, its initializers,
2554 recursively); otherwise, return DECL. If STRICT_P, the
2555 initializer is only returned if DECL is a
2556 constant-expression. If RETURN_AGGREGATE_CST_OK_P, it is ok to
2557 return an aggregate constant. If UNSHARE_P, return an unshared
2558 copy of the initializer. */
2559
2560static tree
2561constant_value_1 (tree decl, bool strict_p, bool return_aggregate_cst_ok_p,
2562 bool unshare_p)
2563{
2564 while (TREE_CODE (decl) == CONST_DECL
2565 || decl_constant_var_p (decl)
2566 || (!strict_p && VAR_P (decl)
2567 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl))))
2568 {
2569 tree init;
2570 /* If DECL is a static data member in a template
2571 specialization, we must instantiate it here. The
2572 initializer for the static data member is not processed
2573 until needed; we need it now. */
2574 mark_used (decl, tf_none);
2575 init = DECL_INITIAL (decl);
2576 if (init == error_mark_node)
2577 {
2578 if (TREE_CODE (decl) == CONST_DECL
2579 || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
2580 /* Treat the error as a constant to avoid cascading errors on
2581 excessively recursive template instantiation (c++/9335). */
2582 return init;
2583 else
2584 return decl;
2585 }
2586 /* Initializers in templates are generally expanded during
2587 instantiation, so before that for const int i(2)
2588 INIT is a TREE_LIST with the actual initializer as
2589 TREE_VALUE. */
2590 if (processing_template_decl
2591 && init
2592 && TREE_CODE (init) == TREE_LIST
2593 && TREE_CHAIN (init) == NULL_TREE)
2594 init = TREE_VALUE (init);
2595 /* Instantiate a non-dependent initializer for user variables. We
2596 mustn't do this for the temporary for an array compound literal;
2597 trying to instatiate the initializer will keep creating new
2598 temporaries until we crash. Probably it's not useful to do it for
2599 other artificial variables, either. */
2600 if (!DECL_ARTIFICIAL (decl))
2601 init = instantiate_non_dependent_or_null (init);
2602 if (!init
2603 || !TREE_TYPE (init)
2604 || !TREE_CONSTANT (init)
2605 || (!return_aggregate_cst_ok_p
2606 /* Unless RETURN_AGGREGATE_CST_OK_P is true, do not
2607 return an aggregate constant (of which string
2608 literals are a special case), as we do not want
2609 to make inadvertent copies of such entities, and
2610 we must be sure that their addresses are the
2611 same everywhere. */
2612 && (TREE_CODE (init) == CONSTRUCTOR
2613 || TREE_CODE (init) == STRING_CST)))
2614 break;
2615 /* Don't return a CONSTRUCTOR for a variable with partial run-time
2616 initialization, since it doesn't represent the entire value.
2617 Similarly for VECTOR_CSTs created by cp_folding those
2618 CONSTRUCTORs. */
2619 if ((TREE_CODE (init) == CONSTRUCTOR
2620 || TREE_CODE (init) == VECTOR_CST)
2621 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
2622 break;
2623 /* If the variable has a dynamic initializer, don't use its
2624 DECL_INITIAL which doesn't reflect the real value. */
2625 if (VAR_P (decl)
2626 && TREE_STATIC (decl)
2627 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)
2628 && DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2629 break;
2630 decl = init;
2631 }
2632 return unshare_p ? unshare_expr (decl) : decl;
2633}
2634
2635/* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by constant
2636 of integral or enumeration type, or a constexpr variable of scalar type,
2637 then return that value. These are those variables permitted in constant
2638 expressions by [5.19/1]. */
2639
2640tree
2641scalar_constant_value (tree decl)
2642{
2643 return constant_value_1 (decl, /*strict_p=*/true,
2644 /*return_aggregate_cst_ok_p=*/false,
2645 /*unshare_p=*/true);
2646}
2647
2648/* Like scalar_constant_value, but can also return aggregate initializers.
2649 If UNSHARE_P, return an unshared copy of the initializer. */
2650
2651tree
2652decl_really_constant_value (tree decl, bool unshare_p /*= true*/)
2653{
2654 return constant_value_1 (decl, /*strict_p=*/true,
2655 /*return_aggregate_cst_ok_p=*/true,
2656 /*unshare_p=*/unshare_p);
2657}
2658
2659/* A more relaxed version of decl_really_constant_value, used by the
2660 common C/C++ code. */
2661
2662tree
2663decl_constant_value (tree decl, bool unshare_p)
2664{
2665 return constant_value_1 (decl, /*strict_p=*/processing_template_decl,
2666 /*return_aggregate_cst_ok_p=*/true,
2667 /*unshare_p=*/unshare_p);
2668}
2669
2670tree
2671decl_constant_value (tree decl)
2672{
2673 return decl_constant_value (decl, /*unshare_p=*/true);
2674}
2675
2676/* Common subroutines of build_new and build_vec_delete. */
2677
2678/* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
2679 the type of the object being allocated; otherwise, it's just TYPE.
2680 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
2681 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
2682 a vector of arguments to be provided as arguments to a placement
2683 new operator. This routine performs no semantic checks; it just
2684 creates and returns a NEW_EXPR. */
2685
2686static tree
2687build_raw_new_expr (location_t loc, vec<tree, va_gc> *placement, tree type,
2688 tree nelts, vec<tree, va_gc> *init, int use_global_new)
2689{
2690 tree init_list;
2691 tree new_expr;
2692
2693 /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR.
2694 If INIT is not NULL, then we want to store VOID_ZERO_NODE. This
2695 permits us to distinguish the case of a missing initializer "new
2696 int" from an empty initializer "new int()". */
2697 if (init == NULL)
2698 init_list = NULL_TREE;
2699 else if (init->is_empty ())
2700 init_list = void_node;
2701 else
2702 init_list = build_tree_list_vec (init);
2703
2704 new_expr = build4_loc (loc, code: NEW_EXPR, type: build_pointer_type (type),
2705 arg0: build_tree_list_vec (placement), arg1: type, arg2: nelts,
2706 arg3: init_list);
2707 NEW_EXPR_USE_GLOBAL (new_expr) = use_global_new;
2708 TREE_SIDE_EFFECTS (new_expr) = 1;
2709
2710 return new_expr;
2711}
2712
2713/* Diagnose uninitialized const members or reference members of type
2714 TYPE. USING_NEW is used to disambiguate the diagnostic between a
2715 new expression without a new-initializer and a declaration. Returns
2716 the error count. */
2717
2718static int
2719diagnose_uninitialized_cst_or_ref_member_1 (tree type, tree origin,
2720 bool using_new, bool complain)
2721{
2722 tree field;
2723 int error_count = 0;
2724
2725 if (type_has_user_provided_constructor (type))
2726 return 0;
2727
2728 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
2729 {
2730 tree field_type;
2731
2732 if (TREE_CODE (field) != FIELD_DECL)
2733 continue;
2734
2735 field_type = strip_array_types (TREE_TYPE (field));
2736
2737 if (type_has_user_provided_constructor (field_type))
2738 continue;
2739
2740 if (TYPE_REF_P (field_type))
2741 {
2742 ++ error_count;
2743 if (complain)
2744 {
2745 auto_diagnostic_group d;
2746 if (DECL_CONTEXT (field) == origin)
2747 {
2748 if (using_new)
2749 error ("uninitialized reference member in %q#T "
2750 "using %<new%> without new-initializer", origin);
2751 else
2752 error ("uninitialized reference member in %q#T", origin);
2753 }
2754 else
2755 {
2756 if (using_new)
2757 error ("uninitialized reference member in base %q#T "
2758 "of %q#T using %<new%> without new-initializer",
2759 DECL_CONTEXT (field), origin);
2760 else
2761 error ("uninitialized reference member in base %q#T "
2762 "of %q#T", DECL_CONTEXT (field), origin);
2763 }
2764 inform (DECL_SOURCE_LOCATION (field),
2765 "%q#D should be initialized", field);
2766 }
2767 }
2768
2769 if (CP_TYPE_CONST_P (field_type))
2770 {
2771 ++ error_count;
2772 if (complain)
2773 {
2774 auto_diagnostic_group d;
2775 if (DECL_CONTEXT (field) == origin)
2776 {
2777 if (using_new)
2778 error ("uninitialized const member in %q#T "
2779 "using %<new%> without new-initializer", origin);
2780 else
2781 error ("uninitialized const member in %q#T", origin);
2782 }
2783 else
2784 {
2785 if (using_new)
2786 error ("uninitialized const member in base %q#T "
2787 "of %q#T using %<new%> without new-initializer",
2788 DECL_CONTEXT (field), origin);
2789 else
2790 error ("uninitialized const member in base %q#T "
2791 "of %q#T", DECL_CONTEXT (field), origin);
2792 }
2793 inform (DECL_SOURCE_LOCATION (field),
2794 "%q#D should be initialized", field);
2795 }
2796 }
2797
2798 if (CLASS_TYPE_P (field_type))
2799 error_count
2800 += diagnose_uninitialized_cst_or_ref_member_1 (type: field_type, origin,
2801 using_new, complain);
2802 }
2803 return error_count;
2804}
2805
2806int
2807diagnose_uninitialized_cst_or_ref_member (tree type, bool using_new, bool complain)
2808{
2809 return diagnose_uninitialized_cst_or_ref_member_1 (type, origin: type, using_new, complain);
2810}
2811
2812/* Call __cxa_bad_array_new_length to indicate that the size calculation
2813 overflowed. */
2814
2815tree
2816throw_bad_array_new_length (void)
2817{
2818 if (!fn)
2819 {
2820 tree name = get_identifier ("__cxa_throw_bad_array_new_length");
2821
2822 fn = get_global_binding (id: name);
2823 if (!fn)
2824 fn = push_throw_library_fn
2825 (name, build_function_type_list (void_type_node, NULL_TREE));
2826 }
2827
2828 return build_cxx_call (fn, 0, NULL, tf_warning_or_error);
2829}
2830
2831/* Attempt to verify that the argument, OPER, of a placement new expression
2832 refers to an object sufficiently large for an object of TYPE or an array
2833 of NELTS of such objects when NELTS is non-null, and issue a warning when
2834 it does not. SIZE specifies the size needed to construct the object or
2835 array and captures the result of NELTS * sizeof (TYPE). (SIZE could be
2836 greater when the array under construction requires a cookie to store
2837 NELTS. GCC's placement new expression stores the cookie when invoking
2838 a user-defined placement new operator function but not the default one.
2839 Placement new expressions with user-defined placement new operator are
2840 not diagnosed since we don't know how they use the buffer (this could
2841 be a future extension). */
2842static void
2843warn_placement_new_too_small (tree type, tree nelts, tree size, tree oper)
2844{
2845 location_t loc = cp_expr_loc_or_input_loc (t: oper);
2846
2847 STRIP_NOPS (oper);
2848
2849 /* Using a function argument or a (non-array) variable as an argument
2850 to placement new is not checked since it's unknown what it might
2851 point to. */
2852 if (TREE_CODE (oper) == PARM_DECL
2853 || VAR_P (oper)
2854 || TREE_CODE (oper) == COMPONENT_REF)
2855 return;
2856
2857 /* Evaluate any constant expressions. */
2858 size = fold_non_dependent_expr (size);
2859
2860 access_ref ref;
2861 ref.eval = [](tree x){ return fold_non_dependent_expr (x); };
2862 ref.trail1special = warn_placement_new < 2;
2863 tree objsize = compute_objsize (ptr: oper, ostype: 1, pref: &ref);
2864 if (!objsize)
2865 return;
2866
2867 /* We can only draw conclusions if ref.deref == -1,
2868 i.e. oper is the address of the object. */
2869 if (ref.deref != -1)
2870 return;
2871
2872 offset_int bytes_avail = wi::to_offset (t: objsize);
2873 offset_int bytes_need;
2874
2875 if (CONSTANT_CLASS_P (size))
2876 bytes_need = wi::to_offset (t: size);
2877 else if (nelts && CONSTANT_CLASS_P (nelts))
2878 bytes_need = (wi::to_offset (t: nelts)
2879 * wi::to_offset (TYPE_SIZE_UNIT (type)));
2880 else if (tree_fits_uhwi_p (TYPE_SIZE_UNIT (type)))
2881 bytes_need = wi::to_offset (TYPE_SIZE_UNIT (type));
2882 else
2883 {
2884 /* The type is a VLA. */
2885 return;
2886 }
2887
2888 if (bytes_avail >= bytes_need)
2889 return;
2890
2891 /* True when the size to mention in the warning is exact as opposed
2892 to "at least N". */
2893 const bool exact_size = (ref.offrng[0] == ref.offrng[1]
2894 || ref.sizrng[1] - ref.offrng[0] == 0);
2895
2896 tree opertype = ref.ref ? TREE_TYPE (ref.ref) : TREE_TYPE (oper);
2897 bool warned = false;
2898 if (nelts)
2899 nelts = fold_for_warn (nelts);
2900
2901 auto_diagnostic_group d;
2902 if (nelts)
2903 if (CONSTANT_CLASS_P (nelts))
2904 warned = warning_at (loc, OPT_Wplacement_new_,
2905 (exact_size
2906 ? G_("placement new constructing an object "
2907 "of type %<%T [%wu]%> and size %qwu "
2908 "in a region of type %qT and size %qwi")
2909 : G_("placement new constructing an object "
2910 "of type %<%T [%wu]%> and size %qwu "
2911 "in a region of type %qT and size "
2912 "at most %qwu")),
2913 type, tree_to_uhwi (nelts),
2914 bytes_need.to_uhwi (),
2915 opertype, bytes_avail.to_uhwi ());
2916 else
2917 warned = warning_at (loc, OPT_Wplacement_new_,
2918 (exact_size
2919 ? G_("placement new constructing an array "
2920 "of objects of type %qT and size %qwu "
2921 "in a region of type %qT and size %qwi")
2922 : G_("placement new constructing an array "
2923 "of objects of type %qT and size %qwu "
2924 "in a region of type %qT and size "
2925 "at most %qwu")),
2926 type, bytes_need.to_uhwi (), opertype,
2927 bytes_avail.to_uhwi ());
2928 else
2929 warned = warning_at (loc, OPT_Wplacement_new_,
2930 (exact_size
2931 ? G_("placement new constructing an object "
2932 "of type %qT and size %qwu in a region "
2933 "of type %qT and size %qwi")
2934 : G_("placement new constructing an object "
2935 "of type %qT "
2936 "and size %qwu in a region of type %qT "
2937 "and size at most %qwu")),
2938 type, bytes_need.to_uhwi (), opertype,
2939 bytes_avail.to_uhwi ());
2940
2941 if (!warned || !ref.ref)
2942 return;
2943
2944 if (ref.offrng[0] == 0 || !ref.offset_bounded ())
2945 /* Avoid mentioning the offset when its lower bound is zero
2946 or when it's impossibly large. */
2947 inform (DECL_SOURCE_LOCATION (ref.ref),
2948 "%qD declared here", ref.ref);
2949 else if (ref.offrng[0] == ref.offrng[1])
2950 inform (DECL_SOURCE_LOCATION (ref.ref),
2951 "at offset %wi from %qD declared here",
2952 ref.offrng[0].to_shwi (), ref.ref);
2953 else
2954 inform (DECL_SOURCE_LOCATION (ref.ref),
2955 "at offset [%wi, %wi] from %qD declared here",
2956 ref.offrng[0].to_shwi (), ref.offrng[1].to_shwi (), ref.ref);
2957}
2958
2959/* True if alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__. */
2960
2961bool
2962type_has_new_extended_alignment (tree t)
2963{
2964 return (aligned_new_threshold
2965 && TYPE_ALIGN_UNIT (t) > (unsigned)aligned_new_threshold);
2966}
2967
2968/* Return the alignment we expect malloc to guarantee. This should just be
2969 MALLOC_ABI_ALIGNMENT, but that macro defaults to only BITS_PER_WORD for some
2970 reason, so don't let the threshold be smaller than max_align_t_align. */
2971
2972unsigned
2973malloc_alignment ()
2974{
2975 return MAX (max_align_t_align(), MALLOC_ABI_ALIGNMENT);
2976}
2977
2978/* Determine whether an allocation function is a namespace-scope
2979 non-replaceable placement new function. See DR 1748. */
2980bool
2981std_placement_new_fn_p (tree alloc_fn)
2982{
2983 if (DECL_NAMESPACE_SCOPE_P (alloc_fn)
2984 && IDENTIFIER_NEW_OP_P (DECL_NAME (alloc_fn))
2985 && !DECL_IS_REPLACEABLE_OPERATOR_NEW_P (alloc_fn))
2986 {
2987 tree first_arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
2988 if (first_arg
2989 && (TREE_VALUE (first_arg) == ptr_type_node)
2990 && (TREE_CHAIN (first_arg) == void_list_node))
2991 return true;
2992 }
2993 return false;
2994}
2995
2996/* For element type ELT_TYPE, return the appropriate type of the heap object
2997 containing such element(s). COOKIE_SIZE is the size of cookie in bytes.
2998 Return
2999 struct { size_t[COOKIE_SIZE/sizeof(size_t)]; ELT_TYPE[N]; }
3000 where N is nothing (flexible array member) if ITYPE2 is NULL, otherwise
3001 the array has ITYPE2 as its TYPE_DOMAIN. */
3002
3003tree
3004build_new_constexpr_heap_type (tree elt_type, tree cookie_size, tree itype2)
3005{
3006 gcc_assert (tree_fits_uhwi_p (cookie_size));
3007 unsigned HOST_WIDE_INT csz = tree_to_uhwi (cookie_size);
3008 csz /= int_size_in_bytes (sizetype);
3009 tree itype1 = build_index_type (size_int (csz - 1));
3010 tree atype1 = build_cplus_array_type (sizetype, itype1);
3011 tree atype2 = build_cplus_array_type (elt_type, itype2);
3012 tree rtype = cxx_make_type (RECORD_TYPE);
3013 TYPE_NAME (rtype) = heap_identifier;
3014 tree fld1 = build_decl (UNKNOWN_LOCATION, FIELD_DECL, NULL_TREE, atype1);
3015 tree fld2 = build_decl (UNKNOWN_LOCATION, FIELD_DECL, NULL_TREE, atype2);
3016 DECL_FIELD_CONTEXT (fld1) = rtype;
3017 DECL_FIELD_CONTEXT (fld2) = rtype;
3018 DECL_ARTIFICIAL (fld1) = true;
3019 DECL_ARTIFICIAL (fld2) = true;
3020 TYPE_FIELDS (rtype) = fld1;
3021 DECL_CHAIN (fld1) = fld2;
3022 layout_type (rtype);
3023 return rtype;
3024}
3025
3026/* Help the constexpr code to find the right type for the heap variable
3027 by adding a NOP_EXPR around ALLOC_CALL if needed for cookie_size.
3028 Return ALLOC_CALL or ALLOC_CALL cast to a pointer to
3029 struct { size_t[cookie_size/sizeof(size_t)]; elt_type[]; }. */
3030
3031static tree
3032maybe_wrap_new_for_constexpr (tree alloc_call, tree elt_type, tree cookie_size)
3033{
3034 if (cxx_dialect < cxx20)
3035 return alloc_call;
3036
3037 if (current_function_decl != NULL_TREE
3038 && !DECL_DECLARED_CONSTEXPR_P (current_function_decl))
3039 return alloc_call;
3040
3041 tree call_expr = extract_call_expr (alloc_call);
3042 if (call_expr == error_mark_node)
3043 return alloc_call;
3044
3045 tree alloc_call_fndecl = cp_get_callee_fndecl_nofold (call_expr);
3046 if (alloc_call_fndecl == NULL_TREE
3047 || !IDENTIFIER_NEW_OP_P (DECL_NAME (alloc_call_fndecl))
3048 || CP_DECL_CONTEXT (alloc_call_fndecl) != global_namespace)
3049 return alloc_call;
3050
3051 tree rtype = build_new_constexpr_heap_type (elt_type, cookie_size,
3052 NULL_TREE);
3053 return build_nop (build_pointer_type (rtype), alloc_call);
3054}
3055
3056/* Generate code for a new-expression, including calling the "operator
3057 new" function, initializing the object, and, if an exception occurs
3058 during construction, cleaning up. The arguments are as for
3059 build_raw_new_expr. This may change PLACEMENT and INIT.
3060 TYPE is the type of the object being constructed, possibly an array
3061 of NELTS elements when NELTS is non-null (in "new T[NELTS]", T may
3062 be an array of the form U[inner], with the whole expression being
3063 "new U[NELTS][inner]"). */
3064
3065static tree
3066build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts,
3067 vec<tree, va_gc> **init, bool globally_qualified_p,
3068 tsubst_flags_t complain)
3069{
3070 tree size, rval;
3071 /* True iff this is a call to "operator new[]" instead of just
3072 "operator new". */
3073 bool array_p = false;
3074 /* If ARRAY_P is true, the element type of the array. This is never
3075 an ARRAY_TYPE; for something like "new int[3][4]", the
3076 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
3077 TYPE. */
3078 tree elt_type;
3079 /* The type of the new-expression. (This type is always a pointer
3080 type.) */
3081 tree pointer_type;
3082 tree non_const_pointer_type;
3083 /* The most significant array bound in int[OUTER_NELTS][inner]. */
3084 tree outer_nelts = NULL_TREE;
3085 /* For arrays with a non-constant number of elements, a bounds checks
3086 on the NELTS parameter to avoid integer overflow at runtime. */
3087 tree outer_nelts_check = NULL_TREE;
3088 bool outer_nelts_from_type = false;
3089 /* Number of the "inner" elements in "new T[OUTER_NELTS][inner]". */
3090 offset_int inner_nelts_count = 1;
3091 tree alloc_call, alloc_expr;
3092 /* Size of the inner array elements (those with constant dimensions). */
3093 offset_int inner_size;
3094 /* The address returned by the call to "operator new". This node is
3095 a VAR_DECL and is therefore reusable. */
3096 tree alloc_node;
3097 tree alloc_fn;
3098 tree cookie_expr, init_expr;
3099 int nothrow, check_new;
3100 /* If non-NULL, the number of extra bytes to allocate at the
3101 beginning of the storage allocated for an array-new expression in
3102 order to store the number of elements. */
3103 tree cookie_size = NULL_TREE;
3104 tree placement_first;
3105 tree placement_expr = NULL_TREE;
3106 /* True if the function we are calling is a placement allocation
3107 function. */
3108 bool placement_allocation_fn_p;
3109 /* True if the storage must be initialized, either by a constructor
3110 or due to an explicit new-initializer. */
3111 bool is_initialized;
3112 /* The address of the thing allocated, not including any cookie. In
3113 particular, if an array cookie is in use, DATA_ADDR is the
3114 address of the first array element. This node is a VAR_DECL, and
3115 is therefore reusable. */
3116 tree data_addr;
3117 tree orig_type = type;
3118
3119 if (nelts)
3120 {
3121 outer_nelts = nelts;
3122 array_p = true;
3123 }
3124 else if (TREE_CODE (type) == ARRAY_TYPE)
3125 {
3126 /* Transforms new (T[N]) to new T[N]. The former is a GNU
3127 extension for variable N. (This also covers new T where T is
3128 a VLA typedef.) */
3129 array_p = true;
3130 nelts = array_type_nelts_top (type);
3131 outer_nelts = nelts;
3132 type = TREE_TYPE (type);
3133 outer_nelts_from_type = true;
3134 }
3135
3136 /* Lots of logic below depends on whether we have a constant number of
3137 elements, so go ahead and fold it now. */
3138 const_tree cst_outer_nelts = fold_non_dependent_expr (outer_nelts, complain);
3139
3140 /* If our base type is an array, then make sure we know how many elements
3141 it has. */
3142 for (elt_type = type;
3143 TREE_CODE (elt_type) == ARRAY_TYPE;
3144 elt_type = TREE_TYPE (elt_type))
3145 {
3146 tree inner_nelts = array_type_nelts_top (elt_type);
3147 tree inner_nelts_cst = maybe_constant_value (inner_nelts);
3148 if (TREE_CODE (inner_nelts_cst) == INTEGER_CST)
3149 {
3150 wi::overflow_type overflow;
3151 offset_int result = wi::mul (x: wi::to_offset (t: inner_nelts_cst),
3152 y: inner_nelts_count, sgn: SIGNED, overflow: &overflow);
3153 if (overflow)
3154 {
3155 if (complain & tf_error)
3156 error ("integer overflow in array size");
3157 nelts = error_mark_node;
3158 }
3159 inner_nelts_count = result;
3160 }
3161 else
3162 {
3163 if (complain & tf_error)
3164 {
3165 error_at (cp_expr_loc_or_input_loc (t: inner_nelts),
3166 "array size in new-expression must be constant");
3167 cxx_constant_value(inner_nelts);
3168 }
3169 nelts = error_mark_node;
3170 }
3171 if (nelts != error_mark_node)
3172 nelts = cp_build_binary_op (input_location,
3173 MULT_EXPR, nelts,
3174 inner_nelts_cst,
3175 complain);
3176 }
3177
3178 if (!verify_type_context (input_location, TCTX_ALLOCATION, elt_type,
3179 !(complain & tf_error)))
3180 return error_mark_node;
3181
3182 if (variably_modified_type_p (elt_type, NULL_TREE) && (complain & tf_error))
3183 {
3184 error ("variably modified type not allowed in new-expression");
3185 return error_mark_node;
3186 }
3187
3188 if (nelts == error_mark_node)
3189 return error_mark_node;
3190
3191 /* Warn if we performed the (T[N]) to T[N] transformation and N is
3192 variable. */
3193 if (outer_nelts_from_type
3194 && !TREE_CONSTANT (cst_outer_nelts))
3195 {
3196 if (complain & tf_warning_or_error)
3197 {
3198 pedwarn (cp_expr_loc_or_input_loc (t: outer_nelts), OPT_Wvla,
3199 typedef_variant_p (type: orig_type)
3200 ? G_("non-constant array new length must be specified "
3201 "directly, not by %<typedef%>")
3202 : G_("non-constant array new length must be specified "
3203 "without parentheses around the type-id"));
3204 }
3205 else
3206 return error_mark_node;
3207 }
3208
3209 if (VOID_TYPE_P (elt_type))
3210 {
3211 if (complain & tf_error)
3212 error ("invalid type %<void%> for %<new%>");
3213 return error_mark_node;
3214 }
3215
3216 if (is_std_init_list (elt_type) && !cp_unevaluated_operand)
3217 warning (OPT_Winit_list_lifetime,
3218 "%<new%> of %<initializer_list%> does not "
3219 "extend the lifetime of the underlying array");
3220
3221 if (abstract_virtuals_error (ACU_NEW, elt_type, complain))
3222 return error_mark_node;
3223
3224 is_initialized = (type_build_ctor_call (elt_type) || *init != NULL);
3225
3226 if (*init == NULL && cxx_dialect < cxx11)
3227 {
3228 bool maybe_uninitialized_error = false;
3229 /* A program that calls for default-initialization [...] of an
3230 entity of reference type is ill-formed. */
3231 if (CLASSTYPE_REF_FIELDS_NEED_INIT (elt_type))
3232 maybe_uninitialized_error = true;
3233
3234 /* A new-expression that creates an object of type T initializes
3235 that object as follows:
3236 - If the new-initializer is omitted:
3237 -- If T is a (possibly cv-qualified) non-POD class type
3238 (or array thereof), the object is default-initialized (8.5).
3239 [...]
3240 -- Otherwise, the object created has indeterminate
3241 value. If T is a const-qualified type, or a (possibly
3242 cv-qualified) POD class type (or array thereof)
3243 containing (directly or indirectly) a member of
3244 const-qualified type, the program is ill-formed; */
3245
3246 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (elt_type))
3247 maybe_uninitialized_error = true;
3248
3249 if (maybe_uninitialized_error
3250 && diagnose_uninitialized_cst_or_ref_member (type: elt_type,
3251 /*using_new=*/true,
3252 complain: complain & tf_error))
3253 return error_mark_node;
3254 }
3255
3256 if (CP_TYPE_CONST_P (elt_type) && *init == NULL
3257 && default_init_uninitialized_part (elt_type))
3258 {
3259 if (complain & tf_error)
3260 error ("uninitialized const in %<new%> of %q#T", elt_type);
3261 return error_mark_node;
3262 }
3263
3264 size = size_in_bytes (t: elt_type);
3265 if (array_p)
3266 {
3267 /* Maximum available size in bytes. Half of the address space
3268 minus the cookie size. */
3269 offset_int max_size
3270 = wi::set_bit_in_zero <offset_int> (TYPE_PRECISION (sizetype) - 1);
3271 /* Maximum number of outer elements which can be allocated. */
3272 offset_int max_outer_nelts;
3273 tree max_outer_nelts_tree;
3274
3275 gcc_assert (TREE_CODE (size) == INTEGER_CST);
3276 cookie_size = targetm.cxx.get_cookie_size (elt_type);
3277 gcc_assert (TREE_CODE (cookie_size) == INTEGER_CST);
3278 gcc_checking_assert (wi::ltu_p (wi::to_offset (cookie_size), max_size));
3279 /* Unconditionally subtract the cookie size. This decreases the
3280 maximum object size and is safe even if we choose not to use
3281 a cookie after all. */
3282 max_size -= wi::to_offset (t: cookie_size);
3283 wi::overflow_type overflow;
3284 inner_size = wi::mul (x: wi::to_offset (t: size), y: inner_nelts_count, sgn: SIGNED,
3285 overflow: &overflow);
3286 if (overflow || wi::gtu_p (x: inner_size, y: max_size))
3287 {
3288 if (complain & tf_error)
3289 {
3290 cst_size_error error;
3291 if (overflow)
3292 error = cst_size_overflow;
3293 else
3294 {
3295 error = cst_size_too_big;
3296 size = size_binop (MULT_EXPR, size,
3297 wide_int_to_tree (sizetype,
3298 inner_nelts_count));
3299 size = cp_fully_fold (size);
3300 }
3301 invalid_array_size_error (input_location, error, size,
3302 /*name=*/NULL_TREE);
3303 }
3304 return error_mark_node;
3305 }
3306
3307 max_outer_nelts = wi::udiv_trunc (x: max_size, y: inner_size);
3308 max_outer_nelts_tree = wide_int_to_tree (sizetype, cst: max_outer_nelts);
3309
3310 size = build2 (MULT_EXPR, sizetype, size, nelts);
3311
3312 if (TREE_CODE (cst_outer_nelts) == INTEGER_CST)
3313 {
3314 if (tree_int_cst_lt (t1: max_outer_nelts_tree, t2: cst_outer_nelts))
3315 {
3316 /* When the array size is constant, check it at compile time
3317 to make sure it doesn't exceed the implementation-defined
3318 maximum, as required by C++ 14 (in C++ 11 this requirement
3319 isn't explicitly stated but it's enforced anyway -- see
3320 grokdeclarator in cp/decl.cc). */
3321 if (complain & tf_error)
3322 {
3323 size = cp_fully_fold (size);
3324 invalid_array_size_error (input_location, cst_size_too_big,
3325 size, NULL_TREE);
3326 }
3327 return error_mark_node;
3328 }
3329 }
3330 else
3331 {
3332 /* When a runtime check is necessary because the array size
3333 isn't constant, keep only the top-most seven bits (starting
3334 with the most significant non-zero bit) of the maximum size
3335 to compare the array size against, to simplify encoding the
3336 constant maximum size in the instruction stream. */
3337
3338 unsigned shift = (max_outer_nelts.get_precision ()) - 7
3339 - wi::clz (max_outer_nelts);
3340 max_outer_nelts = (max_outer_nelts >> shift) << shift;
3341
3342 outer_nelts_check = build2 (LE_EXPR, boolean_type_node,
3343 outer_nelts,
3344 max_outer_nelts_tree);
3345 }
3346 }
3347
3348 tree align_arg = NULL_TREE;
3349 if (type_has_new_extended_alignment (t: elt_type))
3350 {
3351 unsigned align = TYPE_ALIGN_UNIT (elt_type);
3352 /* Also consider the alignment of the cookie, if any. */
3353 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
3354 align = MAX (align, TYPE_ALIGN_UNIT (size_type_node));
3355 align_arg = build_int_cst (align_type_node, align);
3356 }
3357
3358 alloc_fn = NULL_TREE;
3359
3360 /* If PLACEMENT is a single simple pointer type not passed by
3361 reference, prepare to capture it in a temporary variable. Do
3362 this now, since PLACEMENT will change in the calls below. */
3363 placement_first = NULL_TREE;
3364 if (vec_safe_length (v: *placement) == 1
3365 && (TYPE_PTR_P (TREE_TYPE ((**placement)[0]))))
3366 placement_first = (**placement)[0];
3367
3368 bool member_new_p = false;
3369
3370 /* Allocate the object. */
3371 tree fnname;
3372 tree fns;
3373
3374 fnname = ovl_op_identifier (isass: false, code: array_p ? VEC_NEW_EXPR : NEW_EXPR);
3375
3376 member_new_p = !globally_qualified_p
3377 && CLASS_TYPE_P (elt_type)
3378 && (array_p
3379 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
3380 : TYPE_HAS_NEW_OPERATOR (elt_type));
3381
3382 bool member_delete_p = (!globally_qualified_p
3383 && CLASS_TYPE_P (elt_type)
3384 && (array_p
3385 ? TYPE_GETS_VEC_DELETE (elt_type)
3386 : TYPE_GETS_REG_DELETE (elt_type)));
3387
3388 if (member_new_p)
3389 {
3390 /* Use a class-specific operator new. */
3391 /* If a cookie is required, add some extra space. */
3392 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
3393 size = build2 (PLUS_EXPR, sizetype, size, cookie_size);
3394 else
3395 {
3396 cookie_size = NULL_TREE;
3397 /* No size arithmetic necessary, so the size check is
3398 not needed. */
3399 if (outer_nelts_check != NULL && inner_size == 1)
3400 outer_nelts_check = NULL_TREE;
3401 }
3402 /* Perform the overflow check. */
3403 tree errval = TYPE_MAX_VALUE (sizetype);
3404 if (cxx_dialect >= cxx11 && flag_exceptions)
3405 errval = throw_bad_array_new_length ();
3406 if (outer_nelts_check != NULL_TREE)
3407 size = build3 (COND_EXPR, sizetype, outer_nelts_check, size, errval);
3408 size = fold_to_constant (size);
3409 /* Create the argument list. */
3410 vec_safe_insert (v&: *placement, ix: 0, obj: size);
3411 /* Do name-lookup to find the appropriate operator. */
3412 fns = lookup_fnfields (elt_type, fnname, /*protect=*/2, complain);
3413 if (fns == NULL_TREE)
3414 {
3415 if (complain & tf_error)
3416 error ("no suitable %qD found in class %qT", fnname, elt_type);
3417 return error_mark_node;
3418 }
3419 if (TREE_CODE (fns) == TREE_LIST)
3420 {
3421 if (complain & tf_error)
3422 {
3423 auto_diagnostic_group d;
3424 error ("request for member %qD is ambiguous", fnname);
3425 print_candidates (fns);
3426 }
3427 return error_mark_node;
3428 }
3429 tree dummy = build_dummy_object (elt_type);
3430 alloc_call = NULL_TREE;
3431 if (align_arg)
3432 {
3433 vec<tree, va_gc> *align_args
3434 = vec_copy_and_insert (*placement, align_arg, 1);
3435 alloc_call
3436 = build_new_method_call (dummy, fns, &align_args,
3437 /*conversion_path=*/NULL_TREE,
3438 LOOKUP_NORMAL, &alloc_fn, tf_none);
3439 /* If no matching function is found and the allocated object type
3440 has new-extended alignment, the alignment argument is removed
3441 from the argument list, and overload resolution is performed
3442 again. */
3443 if (alloc_call == error_mark_node)
3444 alloc_call = NULL_TREE;
3445 }
3446 if (!alloc_call)
3447 alloc_call = build_new_method_call (dummy, fns, placement,
3448 /*conversion_path=*/NULL_TREE,
3449 LOOKUP_NORMAL,
3450 &alloc_fn, complain);
3451 }
3452 else
3453 {
3454 /* Use a global operator new. */
3455 /* See if a cookie might be required. */
3456 if (!(array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type)))
3457 {
3458 cookie_size = NULL_TREE;
3459 /* No size arithmetic necessary, so the size check is
3460 not needed. */
3461 if (outer_nelts_check != NULL && inner_size == 1)
3462 outer_nelts_check = NULL_TREE;
3463 }
3464
3465 size = fold_to_constant (size);
3466 /* If size is zero e.g. due to type having zero size, try to
3467 preserve outer_nelts for constant expression evaluation
3468 purposes. */
3469 if (integer_zerop (size) && outer_nelts)
3470 size = build2 (MULT_EXPR, TREE_TYPE (size), size, outer_nelts);
3471
3472 alloc_call = build_operator_new_call (fnname, placement,
3473 &size, &cookie_size,
3474 align_arg, outer_nelts_check,
3475 &alloc_fn, complain);
3476 }
3477
3478 if (alloc_call == error_mark_node)
3479 return error_mark_node;
3480
3481 gcc_assert (alloc_fn != NULL_TREE);
3482
3483 /* Now, check to see if this function is actually a placement
3484 allocation function. This can happen even when PLACEMENT is NULL
3485 because we might have something like:
3486
3487 struct S { void* operator new (size_t, int i = 0); };
3488
3489 A call to `new S' will get this allocation function, even though
3490 there is no explicit placement argument. If there is more than
3491 one argument, or there are variable arguments, then this is a
3492 placement allocation function. */
3493 placement_allocation_fn_p
3494 = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
3495 || varargs_function_p (alloc_fn));
3496
3497 if (complain & tf_warning_or_error
3498 && warn_aligned_new
3499 && !placement_allocation_fn_p
3500 && TYPE_ALIGN (elt_type) > malloc_alignment ()
3501 && (warn_aligned_new > 1
3502 || CP_DECL_CONTEXT (alloc_fn) == global_namespace)
3503 && !aligned_allocation_fn_p (alloc_fn))
3504 {
3505 auto_diagnostic_group d;
3506 if (warning (OPT_Waligned_new_, "%<new%> of type %qT with extended "
3507 "alignment %d", elt_type, TYPE_ALIGN_UNIT (elt_type)))
3508 {
3509 inform (input_location, "uses %qD, which does not have an alignment "
3510 "parameter", alloc_fn);
3511 if (!aligned_new_threshold)
3512 inform (input_location, "use %<-faligned-new%> to enable C++17 "
3513 "over-aligned new support");
3514 }
3515 }
3516
3517 /* If we found a simple case of PLACEMENT_EXPR above, then copy it
3518 into a temporary variable. */
3519 if (!processing_template_decl
3520 && TREE_CODE (alloc_call) == CALL_EXPR
3521 && call_expr_nargs (alloc_call) == 2
3522 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 0))) == INTEGER_TYPE
3523 && TYPE_PTR_P (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 1))))
3524 {
3525 tree placement = CALL_EXPR_ARG (alloc_call, 1);
3526
3527 if (placement_first != NULL_TREE
3528 && (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement)))
3529 || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement)))))
3530 {
3531 placement_expr = get_internal_target_expr (placement_first);
3532 CALL_EXPR_ARG (alloc_call, 1)
3533 = fold_convert (TREE_TYPE (placement), placement_expr);
3534 }
3535
3536 if (!member_new_p
3537 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 1)))))
3538 {
3539 /* Attempt to make the warning point at the operator new argument. */
3540 if (placement_first)
3541 placement = placement_first;
3542
3543 warn_placement_new_too_small (type: orig_type, nelts, size, oper: placement);
3544 }
3545 }
3546
3547 alloc_expr = alloc_call;
3548 if (cookie_size)
3549 alloc_expr = maybe_wrap_new_for_constexpr (alloc_call: alloc_expr, elt_type: type,
3550 cookie_size);
3551
3552 /* In the simple case, we can stop now. */
3553 pointer_type = build_pointer_type (type);
3554 if (!cookie_size && !is_initialized && !member_delete_p)
3555 return build_nop (pointer_type, alloc_expr);
3556
3557 /* Store the result of the allocation call in a variable so that we can
3558 use it more than once. */
3559 alloc_expr = get_internal_target_expr (alloc_expr);
3560 alloc_node = TARGET_EXPR_SLOT (alloc_expr);
3561
3562 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
3563 while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
3564 alloc_call = TREE_OPERAND (alloc_call, 1);
3565
3566 /* Preevaluate the placement args so that we don't reevaluate them for a
3567 placement delete. */
3568 if (placement_allocation_fn_p)
3569 {
3570 tree inits;
3571 stabilize_call (alloc_call, &inits);
3572 if (inits)
3573 alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
3574 alloc_expr);
3575 }
3576
3577 /* unless an allocation function is declared with an empty excep-
3578 tion-specification (_except.spec_), throw(), it indicates failure to
3579 allocate storage by throwing a bad_alloc exception (clause _except_,
3580 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
3581 cation function is declared with an empty exception-specification,
3582 throw(), it returns null to indicate failure to allocate storage and a
3583 non-null pointer otherwise.
3584
3585 So check for a null exception spec on the op new we just called. */
3586
3587 nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
3588 check_new
3589 = flag_check_new || (nothrow && !std_placement_new_fn_p (alloc_fn));
3590
3591 if (cookie_size)
3592 {
3593 tree cookie;
3594 tree cookie_ptr;
3595 tree size_ptr_type;
3596
3597 /* Adjust so we're pointing to the start of the object. */
3598 data_addr = fold_build_pointer_plus (alloc_node, cookie_size);
3599
3600 /* Store the number of bytes allocated so that we can know how
3601 many elements to destroy later. We use the last sizeof
3602 (size_t) bytes to store the number of elements. */
3603 cookie_ptr = size_binop (MINUS_EXPR, cookie_size, size_in_bytes (sizetype));
3604 cookie_ptr = fold_build_pointer_plus_loc (loc: input_location,
3605 ptr: alloc_node, off: cookie_ptr);
3606 size_ptr_type = build_pointer_type (sizetype);
3607 cookie_ptr = fold_convert (size_ptr_type, cookie_ptr);
3608 cookie = cp_build_fold_indirect_ref (cookie_ptr);
3609
3610 cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
3611
3612 if (targetm.cxx.cookie_has_size ())
3613 {
3614 /* Also store the element size. */
3615 cookie_ptr = fold_build_pointer_plus (cookie_ptr,
3616 fold_build1_loc (input_location,
3617 NEGATE_EXPR, sizetype,
3618 size_in_bytes (sizetype)));
3619
3620 cookie = cp_build_fold_indirect_ref (cookie_ptr);
3621 cookie = build2 (MODIFY_EXPR, sizetype, cookie,
3622 size_in_bytes (t: elt_type));
3623 cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
3624 cookie, cookie_expr);
3625 }
3626 }
3627 else
3628 {
3629 cookie_expr = NULL_TREE;
3630 data_addr = alloc_node;
3631 }
3632
3633 /* Now use a pointer to the type we've actually allocated. */
3634
3635 /* But we want to operate on a non-const version to start with,
3636 since we'll be modifying the elements. */
3637 non_const_pointer_type = build_pointer_type
3638 (cp_build_qualified_type (type, cp_type_quals (type) & ~TYPE_QUAL_CONST));
3639
3640 data_addr = fold_convert (non_const_pointer_type, data_addr);
3641 /* Any further uses of alloc_node will want this type, too. */
3642 alloc_node = fold_convert (non_const_pointer_type, alloc_node);
3643
3644 /* Now initialize the allocated object. Note that we preevaluate the
3645 initialization expression, apart from the actual constructor call or
3646 assignment--we do this because we want to delay the allocation as long
3647 as possible in order to minimize the size of the exception region for
3648 placement delete. */
3649 if (is_initialized)
3650 {
3651 bool explicit_value_init_p = false;
3652
3653 if (*init != NULL && (*init)->is_empty ())
3654 {
3655 *init = NULL;
3656 explicit_value_init_p = true;
3657 }
3658
3659 if (processing_template_decl)
3660 {
3661 /* Avoid an ICE when converting to a base in build_simple_base_path.
3662 We'll throw this all away anyway, and build_new will create
3663 a NEW_EXPR. */
3664 tree t = fold_convert (build_pointer_type (elt_type), data_addr);
3665 /* build_value_init doesn't work in templates, and we don't need
3666 the initializer anyway since we're going to throw it away and
3667 rebuild it at instantiation time, so just build up a single
3668 constructor call to get any appropriate diagnostics. */
3669 init_expr = cp_build_fold_indirect_ref (t);
3670 if (type_build_ctor_call (elt_type))
3671 init_expr = build_special_member_call (init_expr,
3672 complete_ctor_identifier,
3673 init, elt_type,
3674 LOOKUP_NORMAL,
3675 complain);
3676 }
3677 else if (array_p)
3678 {
3679 tree vecinit = NULL_TREE;
3680 const size_t len = vec_safe_length (v: *init);
3681 if (len == 1 && DIRECT_LIST_INIT_P ((**init)[0]))
3682 {
3683 vecinit = (**init)[0];
3684 if (CONSTRUCTOR_NELTS (vecinit) == 0)
3685 /* List-value-initialization, leave it alone. */;
3686 else
3687 {
3688 tree arraytype, domain;
3689 if (TREE_CONSTANT (nelts))
3690 domain = compute_array_index_type (NULL_TREE, nelts,
3691 complain);
3692 else
3693 /* We'll check the length at runtime. */
3694 domain = NULL_TREE;
3695 arraytype = build_cplus_array_type (type, domain);
3696 /* If we have new char[4]{"foo"}, we have to reshape
3697 so that the STRING_CST isn't wrapped in { }. */
3698 vecinit = reshape_init (arraytype, vecinit, complain);
3699 /* The middle end doesn't cope with the location wrapper
3700 around a STRING_CST. */
3701 STRIP_ANY_LOCATION_WRAPPER (vecinit);
3702 vecinit = digest_init (arraytype, vecinit, complain);
3703 }
3704 }
3705 else if (*init)
3706 {
3707 if (complain & tf_error)
3708 error ("parenthesized initializer in array new");
3709 return error_mark_node;
3710 }
3711
3712 /* Collect flags for disabling subobject cleanups once the complete
3713 object is fully constructed. */
3714 vec<tree, va_gc> *flags = make_tree_vector ();
3715
3716 init_expr
3717 = build_vec_init (data_addr,
3718 cp_build_binary_op (input_location,
3719 MINUS_EXPR, outer_nelts,
3720 integer_one_node,
3721 complain),
3722 vecinit,
3723 explicit_value_init_p,
3724 /*from_array=*/0,
3725 complain,
3726 &flags);
3727
3728 for (tree f : flags)
3729 {
3730 tree cl = build_disable_temp_cleanup (f);
3731 cl = convert_to_void (cl, ICV_STATEMENT, complain);
3732 init_expr = build2 (COMPOUND_EXPR, void_type_node,
3733 init_expr, cl);
3734 }
3735 release_tree_vector (flags);
3736 }
3737 else
3738 {
3739 init_expr = cp_build_fold_indirect_ref (data_addr);
3740
3741 if (type_build_ctor_call (type) && !explicit_value_init_p)
3742 {
3743 init_expr = build_special_member_call (init_expr,
3744 complete_ctor_identifier,
3745 init, elt_type,
3746 LOOKUP_NORMAL,
3747 complain|tf_no_cleanup);
3748 }
3749 else if (explicit_value_init_p)
3750 {
3751 /* Something like `new int()'. NO_CLEANUP is needed so
3752 we don't try and build a (possibly ill-formed)
3753 destructor. */
3754 tree val = build_value_init (type, complain: complain | tf_no_cleanup);
3755 if (val == error_mark_node)
3756 return error_mark_node;
3757 init_expr = cp_build_init_expr (t: init_expr, i: val);
3758 }
3759 else
3760 {
3761 tree ie;
3762
3763 /* We are processing something like `new int (10)', which
3764 means allocate an int, and initialize it with 10.
3765
3766 In C++20, also handle `new A(1, 2)'. */
3767 if (cxx_dialect >= cxx20
3768 && AGGREGATE_TYPE_P (type)
3769 && (*init)->length () > 1)
3770 {
3771 ie = build_constructor_from_vec (init_list_type_node, *init);
3772 CONSTRUCTOR_IS_DIRECT_INIT (ie) = true;
3773 CONSTRUCTOR_IS_PAREN_INIT (ie) = true;
3774 ie = digest_init (type, ie, complain);
3775 }
3776 else
3777 ie = build_x_compound_expr_from_vec (*init, "new initializer",
3778 complain);
3779 init_expr = cp_build_modify_expr (input_location, init_expr,
3780 INIT_EXPR, ie, complain);
3781 }
3782 /* If the initializer uses C++14 aggregate NSDMI that refer to the
3783 object being initialized, replace them now and don't try to
3784 preevaluate. */
3785 bool had_placeholder = false;
3786 if (!processing_template_decl
3787 && TREE_CODE (init_expr) == INIT_EXPR)
3788 TREE_OPERAND (init_expr, 1)
3789 = replace_placeholders (TREE_OPERAND (init_expr, 1),
3790 TREE_OPERAND (init_expr, 0),
3791 &had_placeholder);
3792 }
3793
3794 if (init_expr == error_mark_node)
3795 return error_mark_node;
3796 }
3797 else
3798 init_expr = NULL_TREE;
3799
3800 /* If any part of the object initialization terminates by throwing an
3801 exception and a suitable deallocation function can be found, the
3802 deallocation function is called to free the memory in which the
3803 object was being constructed, after which the exception continues
3804 to propagate in the context of the new-expression. If no
3805 unambiguous matching deallocation function can be found,
3806 propagating the exception does not cause the object's memory to be
3807 freed. */
3808 if (flag_exceptions && (init_expr || member_delete_p))
3809 {
3810 enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
3811 tree cleanup;
3812
3813 /* The Standard is unclear here, but the right thing to do
3814 is to use the same method for finding deallocation
3815 functions that we use for finding allocation functions. */
3816 cleanup = (build_op_delete_call
3817 (dcode,
3818 alloc_node,
3819 size,
3820 globally_qualified_p,
3821 placement_allocation_fn_p ? alloc_call : NULL_TREE,
3822 alloc_fn,
3823 complain));
3824
3825 if (cleanup && init_expr && !processing_template_decl)
3826 /* Ack! First we allocate the memory. Then we set our sentry
3827 variable to true, and expand a cleanup that deletes the
3828 memory if sentry is true. Then we run the constructor, and
3829 finally clear the sentry.
3830
3831 We need to do this because we allocate the space first, so
3832 if there are any temporaries with cleanups in the
3833 constructor args, we need this EH region to extend until
3834 end of full-expression to preserve nesting.
3835
3836 We used to try to evaluate the args first to avoid this, but
3837 since C++17 [expr.new] says that "The invocation of the
3838 allocation function is sequenced before the evaluations of
3839 expressions in the new-initializer." */
3840 {
3841 tree end, sentry, begin;
3842
3843 begin = get_internal_target_expr (boolean_true_node);
3844
3845 sentry = TARGET_EXPR_SLOT (begin);
3846
3847 /* CLEANUP is compiler-generated, so no diagnostics. */
3848 suppress_warning (cleanup);
3849
3850 TARGET_EXPR_CLEANUP (begin)
3851 = build3 (COND_EXPR, void_type_node, sentry,
3852 cleanup, void_node);
3853
3854 end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
3855 sentry, boolean_false_node);
3856
3857 init_expr
3858 = build2 (COMPOUND_EXPR, void_type_node, begin,
3859 build2 (COMPOUND_EXPR, void_type_node, init_expr,
3860 end));
3861 /* Likewise, this is compiler-generated. */
3862 suppress_warning (init_expr);
3863 }
3864 }
3865
3866 /* Now build up the return value in reverse order. */
3867
3868 rval = data_addr;
3869
3870 if (init_expr)
3871 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
3872 if (cookie_expr)
3873 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
3874
3875 suppress_warning (rval, OPT_Wunused_value);
3876
3877 if (rval == data_addr && TREE_CODE (alloc_expr) == TARGET_EXPR)
3878 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
3879 and return the call (which doesn't need to be adjusted). */
3880 rval = TARGET_EXPR_INITIAL (alloc_expr);
3881 else
3882 {
3883 if (check_new)
3884 {
3885 tree ifexp = cp_build_binary_op (input_location,
3886 NE_EXPR, alloc_node,
3887 nullptr_node,
3888 complain);
3889 rval = build_conditional_expr (input_location, ifexp, rval,
3890 alloc_node, complain);
3891 }
3892
3893 /* Perform the allocation before anything else, so that ALLOC_NODE
3894 has been initialized before we start using it. */
3895 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
3896 }
3897
3898 /* A new-expression is never an lvalue. */
3899 gcc_assert (!obvalue_p (rval));
3900
3901 return convert (pointer_type, rval);
3902}
3903
3904/* Generate a representation for a C++ "new" expression. *PLACEMENT
3905 is a vector of placement-new arguments (or NULL if none). If NELTS
3906 is NULL, TYPE is the type of the storage to be allocated. If NELTS
3907 is not NULL, then this is an array-new allocation; TYPE is the type
3908 of the elements in the array and NELTS is the number of elements in
3909 the array. *INIT, if non-NULL, is the initializer for the new
3910 object, or an empty vector to indicate an initializer of "()". If
3911 USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
3912 rather than just "new". This may change PLACEMENT and INIT. */
3913
3914tree
3915build_new (location_t loc, vec<tree, va_gc> **placement, tree type,
3916 tree nelts, vec<tree, va_gc> **init, int use_global_new,
3917 tsubst_flags_t complain)
3918{
3919 tree rval;
3920 vec<tree, va_gc> *orig_placement = NULL;
3921 tree orig_nelts = NULL_TREE;
3922 vec<tree, va_gc> *orig_init = NULL;
3923
3924 if (type == error_mark_node)
3925 return error_mark_node;
3926
3927 if (nelts == NULL_TREE
3928 /* Don't do auto deduction where it might affect mangling. */
3929 && (!processing_template_decl || at_function_scope_p ()))
3930 {
3931 tree auto_node = type_uses_auto (type);
3932 if (auto_node)
3933 {
3934 tree d_init = NULL_TREE;
3935 const size_t len = vec_safe_length (v: *init);
3936 /* E.g. new auto(x) must have exactly one element, or
3937 a {} initializer will have one element. */
3938 if (len == 1)
3939 {
3940 d_init = (**init)[0];
3941 d_init = resolve_nondeduced_context (d_init, complain);
3942 }
3943 /* For the rest, e.g. new A(1, 2, 3), create a list. */
3944 else if (len > 1)
3945 {
3946 unsigned int n;
3947 tree t;
3948 tree *pp = &d_init;
3949 FOR_EACH_VEC_ELT (**init, n, t)
3950 {
3951 t = resolve_nondeduced_context (t, complain);
3952 *pp = build_tree_list (NULL_TREE, t);
3953 pp = &TREE_CHAIN (*pp);
3954 }
3955 }
3956 type = do_auto_deduction (type, d_init, auto_node, complain);
3957 }
3958 }
3959
3960 if (processing_template_decl)
3961 {
3962 if (dependent_type_p (type)
3963 || any_type_dependent_arguments_p (*placement)
3964 || (nelts && type_dependent_expression_p (nelts))
3965 || (nelts && *init)
3966 || any_type_dependent_arguments_p (*init))
3967 return build_raw_new_expr (loc, placement: *placement, type, nelts, init: *init,
3968 use_global_new);
3969
3970 orig_placement = make_tree_vector_copy (*placement);
3971 orig_nelts = nelts;
3972 if (*init)
3973 {
3974 orig_init = make_tree_vector_copy (*init);
3975 /* Also copy any CONSTRUCTORs in *init, since reshape_init and
3976 digest_init clobber them in place. */
3977 for (unsigned i = 0; i < orig_init->length(); ++i)
3978 {
3979 tree e = (**init)[i];
3980 if (TREE_CODE (e) == CONSTRUCTOR)
3981 (**init)[i] = copy_node (e);
3982 }
3983 }
3984 }
3985
3986 if (nelts)
3987 {
3988 location_t nelts_loc = cp_expr_loc_or_loc (t: nelts, or_loc: loc);
3989 if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
3990 {
3991 if (complain & tf_error)
3992 permerror (nelts_loc,
3993 "size in array new must have integral type");
3994 else
3995 return error_mark_node;
3996 }
3997
3998 /* Try to determine the constant value only for the purposes
3999 of the diagnostic below but continue to use the original
4000 value and handle const folding later. */
4001 const_tree cst_nelts = fold_non_dependent_expr (nelts, complain);
4002
4003 /* The expression in a noptr-new-declarator is erroneous if it's of
4004 non-class type and its value before converting to std::size_t is
4005 less than zero. ... If the expression is a constant expression,
4006 the program is ill-fomed. */
4007 if (TREE_CODE (cst_nelts) == INTEGER_CST
4008 && !valid_array_size_p (nelts_loc, cst_nelts, NULL_TREE,
4009 complain & tf_error))
4010 return error_mark_node;
4011
4012 nelts = mark_rvalue_use (nelts);
4013 nelts = cp_save_expr (cp_convert (sizetype, nelts, complain));
4014 }
4015
4016 /* ``A reference cannot be created by the new operator. A reference
4017 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
4018 returned by new.'' ARM 5.3.3 */
4019 if (TYPE_REF_P (type))
4020 {
4021 if (complain & tf_error)
4022 error_at (loc, "new cannot be applied to a reference type");
4023 else
4024 return error_mark_node;
4025 type = TREE_TYPE (type);
4026 }
4027
4028 if (TREE_CODE (type) == FUNCTION_TYPE)
4029 {
4030 if (complain & tf_error)
4031 error_at (loc, "new cannot be applied to a function type");
4032 return error_mark_node;
4033 }
4034
4035 /* P1009: Array size deduction in new-expressions. */
4036 const bool array_p = TREE_CODE (type) == ARRAY_TYPE;
4037 if (*init
4038 /* If the array didn't specify its bound, we have to deduce it. */
4039 && ((array_p && !TYPE_DOMAIN (type))
4040 /* For C++20 array with parenthesized-init, we have to process
4041 the parenthesized-list. But don't do it for (), which is
4042 value-initialization, and INIT should stay empty. */
4043 || (cxx_dialect >= cxx20
4044 && (array_p || nelts)
4045 && !(*init)->is_empty ())))
4046 {
4047 /* This means we have 'new T[]()'. */
4048 if ((*init)->is_empty ())
4049 {
4050 tree ctor = build_constructor (init_list_type_node, NULL);
4051 CONSTRUCTOR_IS_DIRECT_INIT (ctor) = true;
4052 vec_safe_push (v&: *init, obj: ctor);
4053 }
4054 tree &elt = (**init)[0];
4055 /* The C++20 'new T[](e_0, ..., e_k)' case allowed by P0960. */
4056 if (!DIRECT_LIST_INIT_P (elt) && cxx_dialect >= cxx20)
4057 {
4058 tree ctor = build_constructor_from_vec (init_list_type_node, *init);
4059 CONSTRUCTOR_IS_DIRECT_INIT (ctor) = true;
4060 CONSTRUCTOR_IS_PAREN_INIT (ctor) = true;
4061 elt = ctor;
4062 /* We've squashed all the vector elements into the first one;
4063 truncate the rest. */
4064 (*init)->truncate (size: 1);
4065 }
4066 /* Otherwise we should have 'new T[]{e_0, ..., e_k}'. */
4067 if (array_p && !TYPE_DOMAIN (type))
4068 {
4069 /* We need to reshape before deducing the bounds to handle code like
4070
4071 struct S { int x, y; };
4072 new S[]{1, 2, 3, 4};
4073
4074 which should deduce S[2]. But don't change ELT itself: we want to
4075 pass a list-initializer to build_new_1, even for STRING_CSTs. */
4076 tree e = elt;
4077 if (BRACE_ENCLOSED_INITIALIZER_P (e))
4078 e = reshape_init (type, e, complain);
4079 cp_complete_array_type (&type, e, /*do_default*/false);
4080 }
4081 }
4082
4083 /* The type allocated must be complete. If the new-type-id was
4084 "T[N]" then we are just checking that "T" is complete here, but
4085 that is equivalent, since the value of "N" doesn't matter. */
4086 if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
4087 return error_mark_node;
4088
4089 rval = build_new_1 (placement, type, nelts, init, globally_qualified_p: use_global_new, complain);
4090 if (rval == error_mark_node)
4091 return error_mark_node;
4092
4093 if (processing_template_decl)
4094 {
4095 tree ret = build_raw_new_expr (loc, placement: orig_placement, type, nelts: orig_nelts,
4096 init: orig_init, use_global_new);
4097 release_tree_vector (orig_placement);
4098 release_tree_vector (orig_init);
4099 return ret;
4100 }
4101
4102 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
4103 rval = build1_loc (loc, code: NOP_EXPR, TREE_TYPE (rval), arg1: rval);
4104 suppress_warning (rval, OPT_Wunused_value);
4105
4106 return rval;
4107}
4108
4109static tree
4110build_vec_delete_1 (location_t loc, tree base, tree maxindex, tree type,
4111 special_function_kind auto_delete_vec,
4112 int use_global_delete, tsubst_flags_t complain,
4113 bool in_cleanup = false)
4114{
4115 tree virtual_size;
4116 tree ptype = build_pointer_type (type = complete_type (type));
4117 tree size_exp;
4118
4119 /* Temporary variables used by the loop. */
4120 tree tbase, tbase_init;
4121
4122 /* This is the body of the loop that implements the deletion of a
4123 single element, and moves temp variables to next elements. */
4124 tree body;
4125
4126 /* This is the LOOP_EXPR that governs the deletion of the elements. */
4127 tree loop = 0;
4128
4129 /* This is the thing that governs what to do after the loop has run. */
4130 tree deallocate_expr = 0;
4131
4132 /* This is the BIND_EXPR which holds the outermost iterator of the
4133 loop. It is convenient to set this variable up and test it before
4134 executing any other code in the loop.
4135 This is also the containing expression returned by this function. */
4136 tree controller = NULL_TREE;
4137 tree tmp;
4138
4139 /* We should only have 1-D arrays here. */
4140 gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
4141
4142 if (base == error_mark_node || maxindex == error_mark_node)
4143 return error_mark_node;
4144
4145 if (!verify_type_context (loc, TCTX_DEALLOCATION, type,
4146 !(complain & tf_error)))
4147 return error_mark_node;
4148
4149 if (!COMPLETE_TYPE_P (type))
4150 {
4151 if (cxx_dialect > cxx23)
4152 {
4153 if (complain & tf_error)
4154 {
4155 auto_diagnostic_group d;
4156 int saved_errorcount = errorcount;
4157 if (permerror_opt (loc, OPT_Wdelete_incomplete,
4158 "operator %<delete []%> used on "
4159 "incomplete type"))
4160 {
4161 cxx_incomplete_type_inform (type);
4162 if (errorcount != saved_errorcount)
4163 return error_mark_node;
4164 }
4165 }
4166 else
4167 return error_mark_node;
4168 }
4169 else if (complain & tf_warning)
4170 {
4171 auto_diagnostic_group d;
4172 if (warning_at (loc, OPT_Wdelete_incomplete,
4173 "possible problem detected in invocation of "
4174 "operator %<delete []%>"))
4175 {
4176 cxx_incomplete_type_diagnostic (value: base, type, diag_kind: DK_WARNING);
4177 inform (loc, "neither the destructor nor the "
4178 "class-specific operator %<delete []%> will be called, "
4179 "even if they are declared when the class is defined");
4180 }
4181 }
4182 /* This size won't actually be used. */
4183 size_exp = size_one_node;
4184 goto no_destructor;
4185 }
4186
4187 size_exp = size_in_bytes (t: type);
4188
4189 if (! MAYBE_CLASS_TYPE_P (type))
4190 goto no_destructor;
4191 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
4192 {
4193 /* Make sure the destructor is callable. */
4194 if (type_build_dtor_call (type))
4195 {
4196 tmp = build_delete (loc, ptype, base, sfk_complete_destructor,
4197 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR|LOOKUP_NONVIRTUAL,
4198 1, complain);
4199 if (tmp == error_mark_node)
4200 return error_mark_node;
4201 }
4202 goto no_destructor;
4203 }
4204
4205 /* The below is short by the cookie size. */
4206 virtual_size = size_binop (MULT_EXPR, size_exp,
4207 fold_convert (sizetype, maxindex));
4208
4209 tbase = create_temporary_var (ptype);
4210 DECL_INITIAL (tbase)
4211 = fold_build_pointer_plus_loc (loc, fold_convert (ptype, base),
4212 off: virtual_size);
4213 tbase_init = build_stmt (loc, DECL_EXPR, tbase);
4214 controller = build3 (BIND_EXPR, void_type_node, tbase, NULL_TREE, NULL_TREE);
4215 TREE_SIDE_EFFECTS (controller) = 1;
4216 BIND_EXPR_VEC_DTOR (controller) = true;
4217
4218 body = build1 (EXIT_EXPR, void_type_node,
4219 build2 (EQ_EXPR, boolean_type_node, tbase,
4220 fold_convert (ptype, base)));
4221 tmp = fold_build1_loc (loc, NEGATE_EXPR, sizetype, size_exp);
4222 tmp = fold_build_pointer_plus (tbase, tmp);
4223 tmp = cp_build_modify_expr (loc, tbase, NOP_EXPR, tmp, complain);
4224 if (tmp == error_mark_node)
4225 return error_mark_node;
4226 body = build_compound_expr (loc, body, tmp);
4227 /* [expr.delete]/3: "In an array delete expression, if the dynamic type of
4228 the object to be deleted is not similar to its static type, the behavior
4229 is undefined." So we can set LOOKUP_NONVIRTUAL. */
4230 tmp = build_delete (loc, ptype, tbase, sfk_complete_destructor,
4231 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR|LOOKUP_NONVIRTUAL,
4232 1, complain);
4233 if (tmp == error_mark_node)
4234 return error_mark_node;
4235 body = build_compound_expr (loc, body, tmp);
4236
4237 loop = build1 (LOOP_EXPR, void_type_node, body);
4238
4239 /* If one destructor throws, keep trying to clean up the rest, unless we're
4240 already in a build_vec_init cleanup. */
4241 if (flag_exceptions && !in_cleanup && !processing_template_decl
4242 && !expr_noexcept_p (tmp, tf_none))
4243 {
4244 loop = build2 (TRY_CATCH_EXPR, void_type_node, loop,
4245 unshare_expr (loop));
4246 /* Tell honor_protect_cleanup_actions to discard this on the
4247 exceptional path. */
4248 TRY_CATCH_IS_CLEANUP (loop) = true;
4249 }
4250
4251 loop = build_compound_expr (loc, tbase_init, loop);
4252
4253 no_destructor:
4254 /* Delete the storage if appropriate. */
4255 if (auto_delete_vec == sfk_deleting_destructor)
4256 {
4257 tree base_tbd;
4258
4259 /* The below is short by the cookie size. */
4260 virtual_size = size_binop (MULT_EXPR, size_exp,
4261 fold_convert (sizetype, maxindex));
4262
4263 if (! TYPE_VEC_NEW_USES_COOKIE (type))
4264 /* no header */
4265 base_tbd = base;
4266 else
4267 {
4268 tree cookie_size;
4269
4270 cookie_size = targetm.cxx.get_cookie_size (type);
4271 base_tbd = cp_build_binary_op (loc,
4272 MINUS_EXPR,
4273 cp_convert (string_type_node,
4274 base, complain),
4275 cookie_size,
4276 complain);
4277 if (base_tbd == error_mark_node)
4278 return error_mark_node;
4279 base_tbd = cp_convert (ptype, base_tbd, complain);
4280 /* True size with header. */
4281 virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
4282 }
4283
4284 deallocate_expr = build_op_delete_call (VEC_DELETE_EXPR,
4285 base_tbd, virtual_size,
4286 use_global_delete & 1,
4287 /*placement=*/NULL_TREE,
4288 /*alloc_fn=*/NULL_TREE,
4289 complain);
4290 }
4291
4292 body = loop;
4293 if (deallocate_expr == error_mark_node)
4294 return error_mark_node;
4295 else if (!deallocate_expr)
4296 ;
4297 else if (!body)
4298 body = deallocate_expr;
4299 else
4300 /* The delete operator must be called, even if a destructor
4301 throws. */
4302 body = build2 (TRY_FINALLY_EXPR, void_type_node, body, deallocate_expr);
4303
4304 if (!body)
4305 body = integer_zero_node;
4306
4307 /* Outermost wrapper: If pointer is null, punt. */
4308 tree cond = build2_loc (loc, code: NE_EXPR, boolean_type_node, arg0: base,
4309 fold_convert (TREE_TYPE (base), nullptr_node));
4310 /* This is a compiler generated comparison, don't emit
4311 e.g. -Wnonnull-compare warning for it. */
4312 suppress_warning (cond, OPT_Wnonnull_compare);
4313 body = build3_loc (loc, code: COND_EXPR, void_type_node,
4314 arg0: cond, arg1: body, integer_zero_node);
4315 COND_EXPR_IS_VEC_DELETE (body) = true;
4316 body = build1 (NOP_EXPR, void_type_node, body);
4317
4318 if (controller)
4319 {
4320 TREE_OPERAND (controller, 1) = body;
4321 body = controller;
4322 }
4323
4324 if (TREE_CODE (base) == SAVE_EXPR)
4325 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
4326 body = build2 (COMPOUND_EXPR, void_type_node, base, body);
4327
4328 return convert_to_void (body, ICV_CAST, complain);
4329}
4330
4331/* Create an unnamed variable of the indicated TYPE. */
4332
4333tree
4334create_temporary_var (tree type)
4335{
4336 tree decl;
4337
4338 decl = build_decl (input_location,
4339 VAR_DECL, NULL_TREE, type);
4340 TREE_USED (decl) = 1;
4341 DECL_ARTIFICIAL (decl) = 1;
4342 DECL_IGNORED_P (decl) = 1;
4343 DECL_CONTEXT (decl) = current_function_decl;
4344
4345 return decl;
4346}
4347
4348/* Create a new temporary variable of the indicated TYPE, initialized
4349 to INIT.
4350
4351 It is not entered into current_binding_level, because that breaks
4352 things when it comes time to do final cleanups (which take place
4353 "outside" the binding contour of the function). */
4354
4355tree
4356get_temp_regvar (tree type, tree init)
4357{
4358 tree decl;
4359
4360 decl = create_temporary_var (type);
4361 add_decl_expr (decl);
4362
4363 finish_expr_stmt (cp_build_modify_expr (input_location, decl, INIT_EXPR,
4364 init, tf_warning_or_error));
4365
4366 return decl;
4367}
4368
4369/* Subroutine of build_vec_init. Returns true if assigning to an array of
4370 INNER_ELT_TYPE from INIT is trivial. */
4371
4372static bool
4373vec_copy_assign_is_trivial (tree inner_elt_type, tree init)
4374{
4375 tree fromtype = inner_elt_type;
4376 if (lvalue_p (init))
4377 fromtype = cp_build_reference_type (fromtype, /*rval*/false);
4378 return is_trivially_xible (MODIFY_EXPR, inner_elt_type, fromtype);
4379}
4380
4381/* Subroutine of build_vec_init: Check that the array has at least N
4382 elements. Other parameters are local variables in build_vec_init. */
4383
4384void
4385finish_length_check (tree atype, tree iterator, tree obase, unsigned n)
4386{
4387 tree nelts = build_int_cst (ptrdiff_type_node, n - 1);
4388 if (TREE_CODE (atype) != ARRAY_TYPE)
4389 {
4390 if (flag_exceptions)
4391 {
4392 tree c = fold_build2 (LT_EXPR, boolean_type_node, iterator,
4393 nelts);
4394 c = build3 (COND_EXPR, void_type_node, c,
4395 throw_bad_array_new_length (), void_node);
4396 finish_expr_stmt (c);
4397 }
4398 /* Don't check an array new when -fno-exceptions. */
4399 }
4400 else if (sanitize_flags_p (flag: SANITIZE_BOUNDS)
4401 && current_function_decl != NULL_TREE)
4402 {
4403 /* Make sure the last element of the initializer is in bounds. */
4404 finish_expr_stmt
4405 (ubsan_instrument_bounds
4406 (input_location, obase, &nelts, /*ignore_off_by_one*/false));
4407 }
4408}
4409
4410/* walk_tree callback to collect temporaries in an expression. */
4411
4412tree
4413find_temps_r (tree *tp, int *walk_subtrees, void *data)
4414{
4415 vec<tree*> &temps = *static_cast<auto_vec<tree*> *>(data);
4416 tree t = *tp;
4417 if (TREE_CODE (t) == TARGET_EXPR
4418 && !TARGET_EXPR_ELIDING_P (t))
4419 temps.safe_push (obj: tp);
4420 else if (TYPE_P (t))
4421 *walk_subtrees = 0;
4422
4423 return NULL_TREE;
4424}
4425
4426/* walk_tree callback to collect temporaries in an expression that
4427 are allocator arguments to standard library classes. */
4428
4429static tree
4430find_allocator_temps_r (tree *tp, int *walk_subtrees, void *data)
4431{
4432 vec<tree*> &temps = *static_cast<auto_vec<tree*> *>(data);
4433 tree t = *tp;
4434 if (TYPE_P (t))
4435 {
4436 *walk_subtrees = 0;
4437 return NULL_TREE;
4438 }
4439
4440 /* If this is a call to a constructor for a std:: class, look for
4441 a reference-to-allocator argument. */
4442 tree fn = cp_get_callee_fndecl_nofold (t);
4443 if (fn && DECL_CONSTRUCTOR_P (fn)
4444 && decl_in_std_namespace_p (TYPE_NAME (DECL_CONTEXT (fn))))
4445 {
4446 int nargs = call_expr_nargs (t);
4447 for (int i = 1; i < nargs; ++i)
4448 {
4449 tree arg = get_nth_callarg (t, n: i);
4450 tree atype = TREE_TYPE (arg);
4451 if (TREE_CODE (atype) == REFERENCE_TYPE
4452 && is_std_allocator (TREE_TYPE (atype)))
4453 {
4454 STRIP_NOPS (arg);
4455 if (TREE_CODE (arg) == ADDR_EXPR)
4456 {
4457 tree *ap = &TREE_OPERAND (arg, 0);
4458 if (TREE_CODE (*ap) == TARGET_EXPR)
4459 temps.safe_push (obj: ap);
4460 }
4461 }
4462 }
4463 }
4464
4465 return NULL_TREE;
4466}
4467
4468/* If INIT initializes a standard library class, and involves a temporary
4469 std::allocator<T>, use ALLOC_OBJ for all such temporaries.
4470
4471 Note that this can clobber the input to build_vec_init; no unsharing is
4472 done. To make this safe we use the TARGET_EXPR in all places rather than
4473 pulling out the TARGET_EXPR_SLOT.
4474
4475 Used by build_vec_init when initializing an array of e.g. strings to reuse
4476 the same temporary allocator for all of the strings. We can do this because
4477 std::allocator has no data and the standard library doesn't care about the
4478 address of allocator objects.
4479
4480 ??? Add an attribute to allow users to assert the same property for other
4481 classes, i.e. one object of the type is interchangeable with any other? */
4482
4483static void
4484combine_allocator_temps (tree &init, tree &alloc_obj)
4485{
4486 auto_vec<tree*> temps;
4487 cp_walk_tree_without_duplicates (&init, find_allocator_temps_r, &temps);
4488 for (tree *p : temps)
4489 {
4490 if (!alloc_obj)
4491 alloc_obj = *p;
4492 else
4493 *p = alloc_obj;
4494 }
4495}
4496
4497/* `build_vec_init' returns tree structure that performs
4498 initialization of a vector of aggregate types.
4499
4500 BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
4501 to the first element, of POINTER_TYPE.
4502 MAXINDEX is the maximum index of the array (one less than the
4503 number of elements). It is only used if BASE is a pointer or
4504 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
4505
4506 INIT is the (possibly NULL) initializer.
4507
4508 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All
4509 elements in the array are value-initialized.
4510
4511 FROM_ARRAY is 0 if we should init everything with INIT
4512 (i.e., every element initialized from INIT).
4513 FROM_ARRAY is 1 if we should index into INIT in parallel
4514 with initialization of DECL.
4515 FROM_ARRAY is 2 if we should index into INIT in parallel,
4516 but use assignment instead of initialization. */
4517
4518tree
4519build_vec_init (tree base, tree maxindex, tree init,
4520 bool explicit_value_init_p,
4521 int from_array,
4522 tsubst_flags_t complain,
4523 vec<tree, va_gc>** cleanup_flags /* = nullptr */)
4524{
4525 tree rval;
4526 tree base2 = NULL_TREE;
4527 tree itype = NULL_TREE;
4528 tree iterator;
4529 /* The type of BASE. */
4530 tree atype = TREE_TYPE (base);
4531 /* The type of an element in the array. */
4532 tree type = TREE_TYPE (atype);
4533 /* The element type reached after removing all outer array
4534 types. */
4535 tree inner_elt_type;
4536 /* The type of a pointer to an element in the array. */
4537 tree ptype;
4538 tree stmt_expr;
4539 tree compound_stmt;
4540 int destroy_temps;
4541 HOST_WIDE_INT num_initialized_elts = 0;
4542 bool is_global;
4543 tree obase = base;
4544 bool xvalue = false;
4545 bool errors = false;
4546 location_t loc = (init ? cp_expr_loc_or_input_loc (t: init)
4547 : location_of (base));
4548
4549 if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype))
4550 maxindex = array_type_nelts_minus_one (atype);
4551
4552 if (maxindex == NULL_TREE || maxindex == error_mark_node)
4553 return error_mark_node;
4554
4555 maxindex = maybe_constant_value (maxindex);
4556 if (explicit_value_init_p)
4557 gcc_assert (!init);
4558
4559 inner_elt_type = strip_array_types (type);
4560
4561 /* Look through the TARGET_EXPR around a compound literal. */
4562 if (init && TREE_CODE (init) == TARGET_EXPR
4563 && TREE_CODE (TARGET_EXPR_INITIAL (init)) == CONSTRUCTOR
4564 && from_array != 2
4565 && (same_type_ignoring_top_level_qualifiers_p
4566 (TREE_TYPE (init), atype)))
4567 init = TARGET_EXPR_INITIAL (init);
4568
4569 if (tree vi = get_vec_init_expr (t: init))
4570 init = VEC_INIT_EXPR_INIT (vi);
4571
4572 bool direct_init = false;
4573 if (from_array && init && BRACE_ENCLOSED_INITIALIZER_P (init)
4574 && CONSTRUCTOR_NELTS (init) == 1)
4575 {
4576 tree elt = CONSTRUCTOR_ELT (init, 0)->value;
4577 if (TREE_CODE (TREE_TYPE (elt)) == ARRAY_TYPE
4578 && TREE_CODE (elt) != VEC_INIT_EXPR)
4579 {
4580 direct_init = DIRECT_LIST_INIT_P (init);
4581 init = elt;
4582 }
4583 }
4584
4585 /* from_array doesn't apply to initialization from CONSTRUCTOR. */
4586 if (init && TREE_CODE (init) == CONSTRUCTOR)
4587 from_array = 0;
4588
4589 /* If we have a braced-init-list or string constant, make sure that the array
4590 is big enough for all the initializers. */
4591 bool length_check = (init
4592 && (TREE_CODE (init) == STRING_CST
4593 || (TREE_CODE (init) == CONSTRUCTOR
4594 && CONSTRUCTOR_NELTS (init) > 0))
4595 && !TREE_CONSTANT (maxindex));
4596
4597 if (init
4598 && TREE_CODE (atype) == ARRAY_TYPE
4599 && TREE_CONSTANT (maxindex)
4600 && !vla_type_p (type)
4601 && (from_array == 2
4602 ? vec_copy_assign_is_trivial (inner_elt_type, init)
4603 : !TYPE_NEEDS_CONSTRUCTING (type))
4604 && ((TREE_CODE (init) == CONSTRUCTOR
4605 && (BRACE_ENCLOSED_INITIALIZER_P (init)
4606 || (same_type_ignoring_top_level_qualifiers_p
4607 (atype, TREE_TYPE (init))))
4608 /* Don't do this if the CONSTRUCTOR might contain something
4609 that might throw and require us to clean up. */
4610 && (vec_safe_is_empty (CONSTRUCTOR_ELTS (init))
4611 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
4612 || from_array))
4613 {
4614 /* Do non-default initialization of trivial arrays resulting from
4615 brace-enclosed initializers. In this case, digest_init and
4616 store_constructor will handle the semantics for us. */
4617
4618 if (BRACE_ENCLOSED_INITIALIZER_P (init))
4619 init = digest_init (atype, init, complain);
4620 stmt_expr = cp_build_init_expr (t: base, i: init);
4621 return stmt_expr;
4622 }
4623
4624 maxindex = cp_convert (ptrdiff_type_node, maxindex, complain);
4625 maxindex = fold_simple (maxindex);
4626
4627 if (TREE_CODE (atype) == ARRAY_TYPE)
4628 {
4629 ptype = build_pointer_type (type);
4630 base = decay_conversion (base, complain);
4631 if (base == error_mark_node)
4632 return error_mark_node;
4633 base = cp_convert (ptype, base, complain);
4634 }
4635 else
4636 ptype = atype;
4637
4638 if (integer_all_onesp (maxindex))
4639 {
4640 /* Shortcut zero element case to avoid unneeded constructor synthesis. */
4641 if (init && TREE_SIDE_EFFECTS (init))
4642 base = build2 (COMPOUND_EXPR, ptype, init, base);
4643 return base;
4644 }
4645
4646 /* The code we are generating looks like:
4647 ({
4648 T* t1 = (T*) base;
4649 T* rval = t1;
4650 ptrdiff_t iterator = maxindex;
4651 try {
4652 for (; iterator != -1; --iterator) {
4653 ... initialize *t1 ...
4654 ++t1;
4655 }
4656 } catch (...) {
4657 ... destroy elements that were constructed ...
4658 }
4659 rval;
4660 })
4661
4662 We can omit the try and catch blocks if we know that the
4663 initialization will never throw an exception, or if the array
4664 elements do not have destructors. We can omit the loop completely if
4665 the elements of the array do not have constructors.
4666
4667 We actually wrap the entire body of the above in a STMT_EXPR, for
4668 tidiness.
4669
4670 When copying from array to another, when the array elements have
4671 only trivial copy constructors, we should use __builtin_memcpy
4672 rather than generating a loop. That way, we could take advantage
4673 of whatever cleverness the back end has for dealing with copies
4674 of blocks of memory. */
4675
4676 is_global = begin_init_stmts (stmt_expr_p: &stmt_expr, compound_stmt_p: &compound_stmt);
4677 destroy_temps = stmts_are_full_exprs_p ();
4678 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
4679 rval = get_temp_regvar (type: ptype, init: base);
4680 base = get_temp_regvar (type: ptype, init: rval);
4681 tree iterator_targ = get_internal_target_expr (maxindex);
4682 add_stmt (iterator_targ);
4683 iterator = TARGET_EXPR_SLOT (iterator_targ);
4684
4685 /* If initializing one array from another, initialize element by
4686 element. We rely upon the below calls to do the argument
4687 checking. Evaluate the initializer before entering the try block. */
4688 if (from_array)
4689 {
4690 if (lvalue_kind (init) & clk_rvalueref)
4691 xvalue = true;
4692 if (TREE_CODE (init) == TARGET_EXPR)
4693 {
4694 /* Avoid error in decay_conversion. */
4695 base2 = decay_conversion (TARGET_EXPR_SLOT (init), complain);
4696 base2 = cp_build_compound_expr (init, base2, tf_none);
4697 }
4698 else
4699 base2 = decay_conversion (init, complain);
4700 if (base2 == error_mark_node)
4701 return error_mark_node;
4702 itype = TREE_TYPE (base2);
4703 base2 = get_temp_regvar (type: itype, init: base2);
4704 itype = TREE_TYPE (itype);
4705 }
4706
4707 /* Protect the entire array initialization so that we can destroy
4708 the partially constructed array if an exception is thrown.
4709 But don't do this if we're assigning. */
4710 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
4711 && from_array != 2)
4712 {
4713 tree e;
4714 tree m = cp_build_binary_op (input_location,
4715 MINUS_EXPR, maxindex, iterator,
4716 complain);
4717
4718 /* Flatten multi-dimensional array since build_vec_delete only
4719 expects one-dimensional array. */
4720 if (TREE_CODE (type) == ARRAY_TYPE)
4721 m = cp_build_binary_op (input_location,
4722 MULT_EXPR, m,
4723 /* Avoid mixing signed and unsigned. */
4724 convert (TREE_TYPE (m),
4725 array_type_nelts_total (type)),
4726 complain);
4727
4728 e = build_vec_delete_1 (loc: input_location, base: rval, maxindex: m,
4729 type: inner_elt_type, auto_delete_vec: sfk_complete_destructor,
4730 /*use_global_delete=*/0, complain,
4731 /*in_cleanup*/true);
4732 if (e == error_mark_node)
4733 errors = true;
4734 TARGET_EXPR_CLEANUP (iterator_targ) = e;
4735 CLEANUP_EH_ONLY (iterator_targ) = true;
4736
4737 /* Since we push this cleanup before doing any initialization, cleanups
4738 for any temporaries in the initialization are naturally within our
4739 cleanup region, so we don't want wrap_temporary_cleanups to do
4740 anything for arrays. But if the array is a subobject, we need to
4741 tell split_nonconstant_init or cp_genericize_target_expr how to turn
4742 off this cleanup in favor of the cleanup for the complete object.
4743
4744 ??? For an array temporary such as an initializer_list backing array,
4745 it would avoid redundancy to leave this cleanup active, clear
4746 CLEANUP_EH_ONLY, and not build another cleanup for the temporary
4747 itself. But that breaks when gimplify_target_expr adds a clobber
4748 cleanup that runs before the build_vec_init cleanup. */
4749 if (cleanup_flags)
4750 vec_safe_push (v&: *cleanup_flags,
4751 obj: build_tree_list (rval, build_zero_cst (ptype)));
4752 }
4753
4754 /* Should we try to create a constant initializer? */
4755 bool try_const = (TREE_CODE (atype) == ARRAY_TYPE
4756 && TREE_CONSTANT (maxindex)
4757 && (init ? TREE_CODE (init) == CONSTRUCTOR
4758 : (type_has_constexpr_default_constructor
4759 (inner_elt_type)
4760 /* Value-initialization of scalars is constexpr. */
4761 || (explicit_value_init_p
4762 && SCALAR_TYPE_P (inner_elt_type))))
4763 && (literal_type_p (inner_elt_type)
4764 || TYPE_HAS_CONSTEXPR_CTOR (inner_elt_type)));
4765 vec<constructor_elt, va_gc> *const_vec = NULL;
4766 bool saw_non_const = false;
4767 /* If we're initializing a static array, we want to do static
4768 initialization of any elements with constant initializers even if
4769 some are non-constant. */
4770 bool do_static_init = (DECL_P (obase) && TREE_STATIC (obase));
4771
4772 bool empty_list = false;
4773 if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
4774 && CONSTRUCTOR_NELTS (init) == 0)
4775 /* Skip over the handling of non-empty init lists. */
4776 empty_list = true;
4777
4778 /* Maybe pull out constant value when from_array? */
4779
4780 else if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
4781 {
4782 /* Do non-default initialization of non-trivial arrays resulting from
4783 brace-enclosed initializers. */
4784 unsigned HOST_WIDE_INT idx;
4785 tree field, elt;
4786 /* If the constructor already has the array type, it's been through
4787 digest_init, so we shouldn't try to do anything more. */
4788 bool digested = (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE
4789 && same_type_p (type, TREE_TYPE (TREE_TYPE (init))));
4790 from_array = 0;
4791
4792 if (length_check)
4793 finish_length_check (atype, iterator, obase, CONSTRUCTOR_NELTS (init));
4794
4795 if (try_const)
4796 vec_alloc (v&: const_vec, CONSTRUCTOR_NELTS (init));
4797
4798 tree alloc_obj = NULL_TREE;
4799
4800 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx, field, elt)
4801 {
4802 tree baseref = build1 (INDIRECT_REF, type, base);
4803 tree one_init;
4804
4805 if (field && TREE_CODE (field) == RANGE_EXPR)
4806 num_initialized_elts += range_expr_nelts (field);
4807 else
4808 num_initialized_elts++;
4809
4810 /* We need to see sub-array TARGET_EXPR before cp_fold_r so we can
4811 handle cleanup flags properly. */
4812 gcc_checking_assert (!target_expr_needs_replace (elt));
4813
4814 if (digested)
4815 one_init = cp_build_init_expr (t: baseref, i: elt);
4816 else if (tree vi = get_vec_init_expr (t: elt))
4817 one_init = expand_vec_init_expr (baseref, vi, complain,
4818 cleanup_flags);
4819 else if (MAYBE_CLASS_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
4820 one_init = build_aggr_init (exp: baseref, init: elt, flags: 0, complain);
4821 else
4822 one_init = cp_build_modify_expr (input_location, baseref,
4823 NOP_EXPR, elt, complain);
4824 if (one_init == error_mark_node)
4825 errors = true;
4826 if (try_const)
4827 {
4828 if (!field)
4829 field = size_int (idx);
4830 tree e = maybe_constant_init (one_init);
4831 if (reduced_constant_expression_p (e))
4832 {
4833 CONSTRUCTOR_APPEND_ELT (const_vec, field, e);
4834 if (do_static_init)
4835 one_init = NULL_TREE;
4836 else
4837 one_init = cp_build_init_expr (t: baseref, i: e);
4838 }
4839 else
4840 {
4841 if (do_static_init)
4842 {
4843 tree value = build_zero_init (TREE_TYPE (e), NULL_TREE,
4844 static_storage_p: true);
4845 if (value)
4846 CONSTRUCTOR_APPEND_ELT (const_vec, field, value);
4847 }
4848 saw_non_const = true;
4849 }
4850 }
4851
4852 if (one_init)
4853 {
4854 /* Only create one std::allocator temporary. */
4855 combine_allocator_temps (init&: one_init, alloc_obj);
4856 finish_expr_stmt (one_init);
4857 }
4858
4859 one_init = cp_build_unary_op (PREINCREMENT_EXPR, base, false,
4860 complain);
4861 if (one_init == error_mark_node)
4862 errors = true;
4863 else
4864 finish_expr_stmt (one_init);
4865
4866 one_init = cp_build_unary_op (PREDECREMENT_EXPR, iterator, false,
4867 complain);
4868 if (one_init == error_mark_node)
4869 errors = true;
4870 else
4871 finish_expr_stmt (one_init);
4872 }
4873
4874 /* Any elements without explicit initializers get T{}. */
4875 empty_list = true;
4876 }
4877 else if (init && TREE_CODE (init) == STRING_CST)
4878 {
4879 /* Check that the array is at least as long as the string. */
4880 if (length_check)
4881 finish_length_check (atype, iterator, obase,
4882 TREE_STRING_LENGTH (init));
4883 tree length = build_int_cst (ptrdiff_type_node,
4884 TREE_STRING_LENGTH (init));
4885
4886 /* Copy the string to the first part of the array. */
4887 tree alias_set = build_int_cst (build_pointer_type (type), 0);
4888 tree lhs = build2 (MEM_REF, TREE_TYPE (init), base, alias_set);
4889 tree stmt = build2 (MODIFY_EXPR, void_type_node, lhs, init);
4890 finish_expr_stmt (stmt);
4891
4892 /* Adjust the counter and pointer. */
4893 stmt = cp_build_binary_op (loc, MINUS_EXPR, iterator, length, complain);
4894 stmt = build2 (MODIFY_EXPR, void_type_node, iterator, stmt);
4895 finish_expr_stmt (stmt);
4896
4897 stmt = cp_build_binary_op (loc, PLUS_EXPR, base, length, complain);
4898 stmt = build2 (MODIFY_EXPR, void_type_node, base, stmt);
4899 finish_expr_stmt (stmt);
4900
4901 /* And set the rest of the array to NUL. */
4902 from_array = 0;
4903 explicit_value_init_p = true;
4904 }
4905 else if (from_array)
4906 {
4907 if (init)
4908 /* OK, we set base2 above. */;
4909 else if (CLASS_TYPE_P (type)
4910 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
4911 {
4912 if (complain & tf_error)
4913 error ("initializer ends prematurely");
4914 errors = true;
4915 }
4916 }
4917
4918 /* Now, default-initialize any remaining elements. We don't need to
4919 do that if a) the type does not need constructing, or b) we've
4920 already initialized all the elements.
4921
4922 We do need to keep going if we're copying an array. */
4923
4924 if (try_const && !init
4925 && (cxx_dialect < cxx20
4926 || !default_init_uninitialized_part (inner_elt_type)))
4927 /* With a constexpr default constructor, which we checked for when
4928 setting try_const above, default-initialization is equivalent to
4929 value-initialization, and build_value_init gives us something more
4930 friendly to maybe_constant_init. Except in C++20 and up a constexpr
4931 constructor need not initialize all the members. */
4932 explicit_value_init_p = true;
4933 if (from_array
4934 || ((type_build_ctor_call (type) || init || explicit_value_init_p)
4935 && ! (tree_fits_shwi_p (maxindex)
4936 && (num_initialized_elts
4937 == tree_to_shwi (maxindex) + 1))))
4938 {
4939 /* If the ITERATOR is lesser or equal to -1, then we don't have to loop;
4940 we've already initialized all the elements. */
4941 tree for_stmt;
4942 tree elt_init;
4943 tree to;
4944
4945 for_stmt = begin_for_stmt (NULL_TREE, NULL_TREE);
4946 finish_init_stmt (for_stmt);
4947 finish_for_cond (build2 (GT_EXPR, boolean_type_node, iterator,
4948 build_int_cst (TREE_TYPE (iterator), -1)),
4949 for_stmt, false, 0, false);
4950 /* We used to pass this decrement to finish_for_expr; now we add it to
4951 elt_init below so it's part of the same full-expression as the
4952 initialization, and thus happens before any potentially throwing
4953 temporary cleanups. */
4954 tree decr = cp_build_unary_op (PREDECREMENT_EXPR, iterator, false,
4955 complain);
4956
4957
4958 to = build1 (INDIRECT_REF, type, base);
4959
4960 /* If the initializer is {}, then all elements are initialized from T{}.
4961 But for non-classes, that's the same as value-initialization. */
4962 if (empty_list)
4963 {
4964 if (cxx_dialect >= cxx11
4965 && (CLASS_TYPE_P (type)
4966 || TREE_CODE (type) == ARRAY_TYPE))
4967 {
4968 init = build_constructor (init_list_type_node, NULL);
4969 }
4970 else
4971 {
4972 init = NULL_TREE;
4973 explicit_value_init_p = true;
4974 }
4975 }
4976
4977 if (from_array)
4978 {
4979 tree from;
4980
4981 if (base2)
4982 {
4983 from = build1 (INDIRECT_REF, itype, base2);
4984 if (xvalue)
4985 from = move (from);
4986 if (direct_init)
4987 {
4988 /* Wrap the initializer in a CONSTRUCTOR so that
4989 build_vec_init recognizes it as direct-initialization. */
4990 from = build_constructor_single (init_list_type_node,
4991 NULL_TREE, from);
4992 CONSTRUCTOR_IS_DIRECT_INIT (from) = true;
4993 }
4994 }
4995 else
4996 from = NULL_TREE;
4997
4998 if (TREE_CODE (type) == ARRAY_TYPE)
4999 elt_init = build_vec_init (base: to, NULL_TREE, init: from, /*val_init*/explicit_value_init_p: false,
5000 from_array, complain);
5001 else if (from_array == 2)
5002 elt_init = cp_build_modify_expr (input_location, to, NOP_EXPR,
5003 from, complain);
5004 else if (type_build_ctor_call (type))
5005 elt_init = build_aggr_init (exp: to, init: from, flags: 0, complain);
5006 else if (from)
5007 elt_init = cp_build_modify_expr (input_location, to, NOP_EXPR, from,
5008 complain);
5009 else
5010 gcc_unreachable ();
5011 }
5012 else if (TREE_CODE (type) == ARRAY_TYPE)
5013 {
5014 if (init && !BRACE_ENCLOSED_INITIALIZER_P (init))
5015 {
5016 if ((complain & tf_error))
5017 error_at (loc, "array must be initialized "
5018 "with a brace-enclosed initializer");
5019 elt_init = error_mark_node;
5020 }
5021 else
5022 elt_init = build_vec_init (base: build1 (INDIRECT_REF, type, base),
5023 maxindex: 0, init,
5024 explicit_value_init_p,
5025 from_array: 0, complain);
5026 }
5027 else if (explicit_value_init_p)
5028 {
5029 elt_init = build_value_init (type, complain);
5030 if (elt_init != error_mark_node)
5031 elt_init = cp_build_init_expr (t: to, i: elt_init);
5032 }
5033 else
5034 {
5035 gcc_assert (type_build_ctor_call (type) || init);
5036 if (CLASS_TYPE_P (type))
5037 elt_init = build_aggr_init (exp: to, init, flags: 0, complain);
5038 else
5039 {
5040 if (TREE_CODE (init) == TREE_LIST)
5041 init = build_x_compound_expr_from_list (init, ELK_INIT,
5042 complain);
5043 elt_init = (init == error_mark_node
5044 ? error_mark_node
5045 : build2 (INIT_EXPR, type, to, init));
5046 }
5047 }
5048
5049 if (elt_init == error_mark_node)
5050 errors = true;
5051
5052 if (try_const)
5053 {
5054 /* FIXME refs to earlier elts */
5055 tree e = maybe_constant_init (elt_init);
5056 if (reduced_constant_expression_p (e))
5057 {
5058 if (initializer_zerop (e))
5059 /* Don't fill the CONSTRUCTOR with zeros. */
5060 e = NULL_TREE;
5061 if (do_static_init)
5062 elt_init = NULL_TREE;
5063 }
5064 else
5065 {
5066 saw_non_const = true;
5067 if (do_static_init)
5068 e = build_zero_init (TREE_TYPE (e), NULL_TREE, static_storage_p: true);
5069 else
5070 e = NULL_TREE;
5071 }
5072
5073 if (e)
5074 {
5075 HOST_WIDE_INT last = tree_to_shwi (maxindex);
5076 if (num_initialized_elts <= last)
5077 {
5078 tree field = size_int (num_initialized_elts);
5079 if (num_initialized_elts != last)
5080 field = build2 (RANGE_EXPR, sizetype, field,
5081 size_int (last));
5082 CONSTRUCTOR_APPEND_ELT (const_vec, field, e);
5083 }
5084 }
5085 }
5086
5087 /* [class.temporary]: "There are three contexts in which temporaries are
5088 destroyed at a different point than the end of the full-
5089 expression. The first context is when a default constructor is called
5090 to initialize an element of an array with no corresponding
5091 initializer. The second context is when a copy constructor is called
5092 to copy an element of an array while the entire array is copied. In
5093 either case, if the constructor has one or more default arguments, the
5094 destruction of every temporary created in a default argument is
5095 sequenced before the construction of the next array element, if any."
5096
5097 So, for this loop, statements are full-expressions. */
5098 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5099 if (elt_init && !errors)
5100 elt_init = build2 (COMPOUND_EXPR, void_type_node, elt_init, decr);
5101 else
5102 elt_init = decr;
5103 finish_expr_stmt (elt_init);
5104 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
5105
5106 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, false,
5107 complain));
5108 if (base2)
5109 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base2, false,
5110 complain));
5111
5112 finish_for_stmt (for_stmt);
5113 }
5114
5115 /* The value of the array initialization is the array itself, RVAL
5116 is a pointer to the first element. */
5117 finish_stmt_expr_expr (rval, stmt_expr);
5118
5119 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
5120
5121 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
5122
5123 if (errors)
5124 return error_mark_node;
5125
5126 if (try_const)
5127 {
5128 if (!saw_non_const)
5129 {
5130 /* If we're not generating the loop, we don't need to reset the
5131 iterator. */
5132 if (cleanup_flags
5133 && !vec_safe_is_empty (v: *cleanup_flags))
5134 {
5135 auto l = (*cleanup_flags)->last ();
5136 gcc_assert (TREE_PURPOSE (l) == iterator);
5137 (*cleanup_flags)->pop ();
5138 }
5139 tree const_init = build_constructor (atype, const_vec);
5140 return build2 (INIT_EXPR, atype, obase, const_init);
5141 }
5142 else if (do_static_init && !vec_safe_is_empty (v: const_vec))
5143 DECL_INITIAL (obase) = build_constructor (atype, const_vec);
5144 else
5145 vec_free (v&: const_vec);
5146 }
5147
5148 /* Now make the result have the correct type. */
5149 if (TREE_CODE (atype) == ARRAY_TYPE)
5150 {
5151 atype = build_reference_type (atype);
5152 stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
5153 stmt_expr = convert_from_reference (stmt_expr);
5154 }
5155
5156 return stmt_expr;
5157}
5158
5159/* Call the DTOR_KIND destructor for EXP. FLAGS are as for
5160 build_delete. */
5161
5162static tree
5163build_dtor_call (tree exp, special_function_kind dtor_kind, int flags,
5164 tsubst_flags_t complain)
5165{
5166 tree name;
5167 switch (dtor_kind)
5168 {
5169 case sfk_complete_destructor:
5170 name = complete_dtor_identifier;
5171 break;
5172
5173 case sfk_base_destructor:
5174 name = base_dtor_identifier;
5175 break;
5176
5177 case sfk_deleting_destructor:
5178 name = deleting_dtor_identifier;
5179 break;
5180
5181 default:
5182 gcc_unreachable ();
5183 }
5184
5185 return build_special_member_call (exp, name,
5186 /*args=*/NULL,
5187 /*binfo=*/TREE_TYPE (exp),
5188 flags,
5189 complain);
5190}
5191
5192/* Generate a call to a destructor. TYPE is the type to cast ADDR to.
5193 ADDR is an expression which yields the store to be destroyed.
5194 AUTO_DELETE is the name of the destructor to call, i.e., either
5195 sfk_complete_destructor, sfk_base_destructor, or
5196 sfk_deleting_destructor.
5197
5198 FLAGS is the logical disjunction of zero or more LOOKUP_
5199 flags. See cp-tree.h for more info. */
5200
5201tree
5202build_delete (location_t loc, tree otype, tree addr,
5203 special_function_kind auto_delete,
5204 int flags, int use_global_delete, tsubst_flags_t complain)
5205{
5206 tree expr;
5207
5208 if (addr == error_mark_node)
5209 return error_mark_node;
5210
5211 tree type = TYPE_MAIN_VARIANT (otype);
5212
5213 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
5214 set to `error_mark_node' before it gets properly cleaned up. */
5215 if (type == error_mark_node)
5216 return error_mark_node;
5217
5218 if (TYPE_PTR_P (type))
5219 type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
5220
5221 if (TREE_CODE (type) == ARRAY_TYPE)
5222 {
5223 if (TYPE_DOMAIN (type) == NULL_TREE)
5224 {
5225 if (complain & tf_error)
5226 error_at (loc, "unknown array size in delete");
5227 return error_mark_node;
5228 }
5229 return build_vec_delete (loc, addr, array_type_nelts_minus_one (type),
5230 auto_delete, use_global_delete, complain);
5231 }
5232
5233 bool deleting = (auto_delete == sfk_deleting_destructor);
5234 gcc_assert (deleting == !(flags & LOOKUP_DESTRUCTOR));
5235
5236 if (TYPE_PTR_P (otype))
5237 {
5238 addr = mark_rvalue_use (addr);
5239
5240 /* We don't want to warn about delete of void*, only other
5241 incomplete types. Deleting other incomplete types
5242 invokes undefined behavior, but it is not ill-formed, so
5243 compile to something that would even do The Right Thing
5244 (TM) should the type have a trivial dtor and no delete
5245 operator. */
5246 if (!VOID_TYPE_P (type))
5247 {
5248 complete_type (type);
5249 if (deleting
5250 && !verify_type_context (loc, TCTX_DEALLOCATION, type,
5251 !(complain & tf_error)))
5252 return error_mark_node;
5253
5254 if (!COMPLETE_TYPE_P (type))
5255 {
5256 if (cxx_dialect > cxx23)
5257 {
5258 if (complain & tf_error)
5259 {
5260 auto_diagnostic_group d;
5261 int saved_errorcount = errorcount;
5262 if (permerror_opt (loc, OPT_Wdelete_incomplete,
5263 "operator %<delete%> used on "
5264 "incomplete type"))
5265 {
5266 cxx_incomplete_type_inform (type);
5267 if (errorcount != saved_errorcount)
5268 return error_mark_node;
5269 }
5270 }
5271 else
5272 return error_mark_node;
5273 }
5274 else if (complain & tf_warning)
5275 {
5276 auto_diagnostic_group d;
5277 if (warning_at (loc, OPT_Wdelete_incomplete,
5278 "possible problem detected in invocation of "
5279 "%<operator delete%>"))
5280 {
5281 cxx_incomplete_type_diagnostic (value: addr, type, diag_kind: DK_WARNING);
5282 inform (loc,
5283 "neither the destructor nor the class-specific "
5284 "%<operator delete%> will be called, even if "
5285 "they are declared when the class is defined");
5286 }
5287 }
5288 }
5289 else if (deleting && warn_delnonvdtor
5290 && MAYBE_CLASS_TYPE_P (type) && !CLASSTYPE_FINAL (type)
5291 && TYPE_POLYMORPHIC_P (type))
5292 {
5293 tree dtor = CLASSTYPE_DESTRUCTOR (type);
5294 if (!dtor || !DECL_VINDEX (dtor))
5295 {
5296 if (CLASSTYPE_PURE_VIRTUALS (type))
5297 warning_at (loc, OPT_Wdelete_non_virtual_dtor,
5298 "deleting object of abstract class type %qT"
5299 " which has non-virtual destructor"
5300 " will cause undefined behavior", type);
5301 else
5302 warning_at (loc, OPT_Wdelete_non_virtual_dtor,
5303 "deleting object of polymorphic class type %qT"
5304 " which has non-virtual destructor"
5305 " might cause undefined behavior", type);
5306 }
5307 }
5308 }
5309
5310 /* Throw away const and volatile on target type of addr. */
5311 addr = convert_force (build_pointer_type (type), addr, 0, complain);
5312 }
5313 else
5314 {
5315 /* Don't check PROTECT here; leave that decision to the
5316 destructor. If the destructor is accessible, call it,
5317 else report error. */
5318 addr = cp_build_addr_expr (addr, complain);
5319 if (addr == error_mark_node)
5320 return error_mark_node;
5321
5322 addr = convert_force (build_pointer_type (type), addr, 0, complain);
5323 }
5324
5325 tree addr_expr = NULL_TREE;
5326 if (deleting)
5327 /* We will use ADDR multiple times so we must save it. */
5328 {
5329 addr_expr = get_internal_target_expr (addr);
5330 addr = TARGET_EXPR_SLOT (addr_expr);
5331 }
5332
5333 bool virtual_p = false;
5334 if (type_build_dtor_call (type))
5335 {
5336 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
5337 lazily_declare_fn (sfk_destructor, type);
5338 virtual_p = DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTOR (type));
5339 }
5340
5341 tree head = NULL_TREE;
5342 tree do_delete = NULL_TREE;
5343 bool destroying_delete = false;
5344
5345 if (!deleting)
5346 {
5347 /* Leave do_delete null. */
5348 }
5349 /* For `::delete x', we must not use the deleting destructor
5350 since then we would not be sure to get the global `operator
5351 delete'. */
5352 else if (use_global_delete)
5353 {
5354 head = get_internal_target_expr (build_headof (addr));
5355 /* Delete the object. */
5356 do_delete = build_op_delete_call (DELETE_EXPR,
5357 head,
5358 cxx_sizeof_nowarn (type),
5359 /*global_p=*/true,
5360 /*placement=*/NULL_TREE,
5361 /*alloc_fn=*/NULL_TREE,
5362 complain);
5363 /* Otherwise, treat this like a complete object destructor
5364 call. */
5365 auto_delete = sfk_complete_destructor;
5366 }
5367 /* If the destructor is non-virtual, there is no deleting
5368 variant. Instead, we must explicitly call the appropriate
5369 `operator delete' here. */
5370 else if (!virtual_p)
5371 {
5372 /* Build the call. */
5373 do_delete = build_op_delete_call (DELETE_EXPR,
5374 addr,
5375 cxx_sizeof_nowarn (type),
5376 /*global_p=*/false,
5377 /*placement=*/NULL_TREE,
5378 /*alloc_fn=*/NULL_TREE,
5379 complain);
5380 /* Call the complete object destructor. */
5381 auto_delete = sfk_complete_destructor;
5382 if (do_delete != error_mark_node)
5383 {
5384 tree fn = get_callee_fndecl (do_delete);
5385 destroying_delete = destroying_delete_p (fn);
5386 }
5387 }
5388 else if (TYPE_GETS_REG_DELETE (type))
5389 {
5390 /* Make sure we have access to the member op delete, even though
5391 we'll actually be calling it from the destructor. */
5392 build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
5393 /*global_p=*/false,
5394 /*placement=*/NULL_TREE,
5395 /*alloc_fn=*/NULL_TREE,
5396 complain);
5397 }
5398
5399 if (destroying_delete)
5400 /* The operator delete will call the destructor. */
5401 expr = addr;
5402 else if (type_build_dtor_call (type))
5403 expr = build_dtor_call (exp: cp_build_fold_indirect_ref (addr),
5404 dtor_kind: auto_delete, flags, complain);
5405 else
5406 expr = build_trivial_dtor_call (addr);
5407 if (expr == error_mark_node)
5408 return error_mark_node;
5409
5410 if (!deleting)
5411 {
5412 protected_set_expr_location (expr, loc);
5413 return expr;
5414 }
5415
5416 if (do_delete == error_mark_node)
5417 return error_mark_node;
5418
5419 if (do_delete && !TREE_SIDE_EFFECTS (expr))
5420 expr = do_delete;
5421 else if (do_delete)
5422 /* The delete operator must be called, regardless of whether
5423 the destructor throws.
5424
5425 [expr.delete]/7 The deallocation function is called
5426 regardless of whether the destructor for the object or some
5427 element of the array throws an exception. */
5428 expr = build2 (TRY_FINALLY_EXPR, void_type_node, expr, do_delete);
5429
5430 /* We need to calculate this before the dtor changes the vptr. */
5431 if (head)
5432 expr = build2 (COMPOUND_EXPR, void_type_node, head, expr);
5433
5434 /* Handle deleting a null pointer. */
5435 warning_sentinel s (warn_address);
5436 tree ifexp = cp_build_binary_op (loc, NE_EXPR, addr,
5437 nullptr_node, complain);
5438 ifexp = cp_fully_fold (ifexp);
5439
5440 if (ifexp == error_mark_node)
5441 return error_mark_node;
5442 /* This is a compiler generated comparison, don't emit
5443 e.g. -Wnonnull-compare warning for it. */
5444 else if (TREE_CODE (ifexp) == NE_EXPR)
5445 suppress_warning (ifexp, OPT_Wnonnull_compare);
5446
5447 if (!integer_nonzerop (ifexp))
5448 expr = build3 (COND_EXPR, void_type_node, ifexp, expr, void_node);
5449
5450 if (addr_expr)
5451 expr = cp_build_compound_expr (addr_expr, expr, tf_none);
5452
5453 protected_set_expr_location (expr, loc);
5454 return expr;
5455}
5456
5457/* At the beginning of a destructor, push cleanups that will call the
5458 destructors for our base classes and members.
5459
5460 Called from begin_destructor_body. */
5461
5462void
5463push_base_cleanups (void)
5464{
5465 tree binfo, base_binfo;
5466 int i;
5467 tree member;
5468 tree expr;
5469 vec<tree, va_gc> *vbases;
5470
5471 /* Run destructors for all virtual baseclasses. */
5472 if (!ABSTRACT_CLASS_TYPE_P (current_class_type)
5473 && CLASSTYPE_VBASECLASSES (current_class_type))
5474 {
5475 tree cond = (condition_conversion
5476 (build2 (BIT_AND_EXPR, integer_type_node,
5477 current_in_charge_parm,
5478 integer_two_node)));
5479
5480 /* The CLASSTYPE_VBASECLASSES vector is in initialization
5481 order, which is also the right order for pushing cleanups. */
5482 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
5483 vec_safe_iterate (v: vbases, ix: i, ptr: &base_binfo); i++)
5484 {
5485 if (type_build_dtor_call (BINFO_TYPE (base_binfo)))
5486 {
5487 expr = build_special_member_call (current_class_ref,
5488 base_dtor_identifier,
5489 NULL,
5490 base_binfo,
5491 (LOOKUP_NORMAL
5492 | LOOKUP_NONVIRTUAL),
5493 tf_warning_or_error);
5494 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
5495 {
5496 expr = build3 (COND_EXPR, void_type_node, cond,
5497 expr, void_node);
5498 finish_decl_cleanup (NULL_TREE, expr);
5499 }
5500 }
5501 }
5502 }
5503
5504 /* Take care of the remaining baseclasses. */
5505 for (binfo = TYPE_BINFO (current_class_type), i = 0;
5506 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
5507 {
5508 if (BINFO_VIRTUAL_P (base_binfo)
5509 || !type_build_dtor_call (BINFO_TYPE (base_binfo)))
5510 continue;
5511
5512 expr = build_special_member_call (current_class_ref,
5513 base_dtor_identifier,
5514 NULL, base_binfo,
5515 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
5516 tf_warning_or_error);
5517 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
5518 finish_decl_cleanup (NULL_TREE, expr);
5519 }
5520
5521 /* Don't automatically destroy union members. */
5522 if (TREE_CODE (current_class_type) == UNION_TYPE)
5523 return;
5524
5525 for (member = TYPE_FIELDS (current_class_type); member;
5526 member = DECL_CHAIN (member))
5527 {
5528 tree this_type = TREE_TYPE (member);
5529 if (this_type == error_mark_node
5530 || TREE_CODE (member) != FIELD_DECL
5531 || DECL_ARTIFICIAL (member))
5532 continue;
5533 if (ANON_AGGR_TYPE_P (this_type))
5534 continue;
5535 if (type_build_dtor_call (this_type))
5536 {
5537 tree this_member = (build_class_member_access_expr
5538 (current_class_ref, member,
5539 /*access_path=*/NULL_TREE,
5540 /*preserve_reference=*/false,
5541 tf_warning_or_error));
5542 expr = build_delete (loc: input_location, otype: this_type, addr: this_member,
5543 auto_delete: sfk_complete_destructor,
5544 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
5545 use_global_delete: 0, complain: tf_warning_or_error);
5546 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (this_type))
5547 finish_decl_cleanup (NULL_TREE, expr);
5548 }
5549 }
5550}
5551
5552/* Build a C++ vector delete expression.
5553 MAXINDEX is the number of elements to be deleted.
5554 ELT_SIZE is the nominal size of each element in the vector.
5555 BASE is the expression that should yield the store to be deleted.
5556 This function expands (or synthesizes) these calls itself.
5557 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
5558
5559 This also calls delete for virtual baseclasses of elements of the vector.
5560
5561 Update: MAXINDEX is no longer needed. The size can be extracted from the
5562 start of the vector for pointers, and from the type for arrays. We still
5563 use MAXINDEX for arrays because it happens to already have one of the
5564 values we'd have to extract. (We could use MAXINDEX with pointers to
5565 confirm the size, and trap if the numbers differ; not clear that it'd
5566 be worth bothering.) */
5567
5568tree
5569build_vec_delete (location_t loc, tree base, tree maxindex,
5570 special_function_kind auto_delete_vec,
5571 int use_global_delete, tsubst_flags_t complain)
5572{
5573 tree type;
5574 tree rval;
5575 tree base_init = NULL_TREE;
5576
5577 type = TREE_TYPE (base);
5578
5579 if (TYPE_PTR_P (type))
5580 {
5581 /* Step back one from start of vector, and read dimension. */
5582 tree cookie_addr;
5583 tree size_ptr_type = build_pointer_type (sizetype);
5584
5585 base = mark_rvalue_use (base);
5586 if (TREE_SIDE_EFFECTS (base))
5587 {
5588 base_init = get_internal_target_expr (base);
5589 base = TARGET_EXPR_SLOT (base_init);
5590 }
5591 type = strip_array_types (TREE_TYPE (type));
5592 cookie_addr = fold_build1_loc (loc, NEGATE_EXPR,
5593 sizetype, TYPE_SIZE_UNIT (sizetype));
5594 cookie_addr = fold_build_pointer_plus (fold_convert (size_ptr_type, base),
5595 cookie_addr);
5596 maxindex = cp_build_fold_indirect_ref (cookie_addr);
5597 }
5598 else if (TREE_CODE (type) == ARRAY_TYPE)
5599 {
5600 /* Get the total number of things in the array, maxindex is a
5601 bad name. */
5602 maxindex = array_type_nelts_total (type);
5603 type = strip_array_types (type);
5604 base = decay_conversion (base, complain);
5605 if (base == error_mark_node)
5606 return error_mark_node;
5607 if (TREE_SIDE_EFFECTS (base))
5608 {
5609 base_init = get_internal_target_expr (base);
5610 base = TARGET_EXPR_SLOT (base_init);
5611 }
5612 }
5613 else
5614 {
5615 if (base != error_mark_node && !(complain & tf_error))
5616 error_at (loc,
5617 "type to vector delete is neither pointer or array type");
5618 return error_mark_node;
5619 }
5620
5621 rval = build_vec_delete_1 (loc, base, maxindex, type, auto_delete_vec,
5622 use_global_delete, complain);
5623 if (base_init && rval != error_mark_node)
5624 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);
5625
5626 protected_set_expr_location (rval, loc);
5627 return rval;
5628}
5629
5630#include "gt-cp-init.h"
5631

Provided by KDAB

Privacy Policy
Update your C++ knowledge – Modern C++11/14/17 Training
Find out more

source code of gcc/cp/init.cc