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