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