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 (decl, 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 NULL or the size of cookie
2879 in bytes. FULL_SIZE is NULL if it is unknown how big the heap allocation
2880 will be, otherwise size of the heap object. If COOKIE_SIZE is NULL,
2881 return array type ELT_TYPE[FULL_SIZE / sizeof(ELT_TYPE)], otherwise return
2882 struct { size_t[COOKIE_SIZE/sizeof(size_t)]; ELT_TYPE[N]; }
2883 where N is nothing (flexible array member) if FULL_SIZE is NULL, otherwise
2884 it is computed such that the size of the struct fits into FULL_SIZE. */
2885
2886 tree
build_new_constexpr_heap_type(tree elt_type,tree cookie_size,tree full_size)2887 build_new_constexpr_heap_type (tree elt_type, tree cookie_size, tree full_size)
2888 {
2889 gcc_assert (cookie_size == NULL_TREE || tree_fits_uhwi_p (cookie_size));
2890 gcc_assert (full_size == NULL_TREE || tree_fits_uhwi_p (full_size));
2891 unsigned HOST_WIDE_INT csz = cookie_size ? tree_to_uhwi (cookie_size) : 0;
2892 tree itype2 = NULL_TREE;
2893 if (full_size)
2894 {
2895 unsigned HOST_WIDE_INT fsz = tree_to_uhwi (full_size);
2896 gcc_assert (fsz >= csz);
2897 fsz -= csz;
2898 fsz /= int_size_in_bytes (elt_type);
2899 itype2 = build_index_type (size_int (fsz - 1));
2900 if (!cookie_size)
2901 return build_cplus_array_type (elt_type, itype2);
2902 }
2903 else
2904 gcc_assert (cookie_size);
2905 csz /= int_size_in_bytes (sizetype);
2906 tree itype1 = build_index_type (size_int (csz - 1));
2907 tree atype1 = build_cplus_array_type (sizetype, itype1);
2908 tree atype2 = build_cplus_array_type (elt_type, itype2);
2909 tree rtype = cxx_make_type (RECORD_TYPE);
2910 TYPE_NAME (rtype) = heap_identifier;
2911 tree fld1 = build_decl (UNKNOWN_LOCATION, FIELD_DECL, NULL_TREE, atype1);
2912 tree fld2 = build_decl (UNKNOWN_LOCATION, FIELD_DECL, NULL_TREE, atype2);
2913 DECL_FIELD_CONTEXT (fld1) = rtype;
2914 DECL_FIELD_CONTEXT (fld2) = rtype;
2915 DECL_ARTIFICIAL (fld1) = true;
2916 DECL_ARTIFICIAL (fld2) = true;
2917 TYPE_FIELDS (rtype) = fld1;
2918 DECL_CHAIN (fld1) = fld2;
2919 layout_type (rtype);
2920 return rtype;
2921 }
2922
2923 /* Help the constexpr code to find the right type for the heap variable
2924 by adding a NOP_EXPR around ALLOC_CALL if needed for cookie_size.
2925 Return ALLOC_CALL or ALLOC_CALL cast to a pointer to
2926 struct { size_t[cookie_size/sizeof(size_t)]; elt_type[]; }. */
2927
2928 static tree
maybe_wrap_new_for_constexpr(tree alloc_call,tree elt_type,tree cookie_size)2929 maybe_wrap_new_for_constexpr (tree alloc_call, tree elt_type, tree cookie_size)
2930 {
2931 if (cxx_dialect < cxx2a)
2932 return alloc_call;
2933
2934 if (current_function_decl != NULL_TREE
2935 && !DECL_DECLARED_CONSTEXPR_P (current_function_decl))
2936 return alloc_call;
2937
2938 tree call_expr = extract_call_expr (alloc_call);
2939 if (call_expr == error_mark_node)
2940 return alloc_call;
2941
2942 tree alloc_call_fndecl = cp_get_callee_fndecl_nofold (call_expr);
2943 if (alloc_call_fndecl == NULL_TREE
2944 || !IDENTIFIER_NEW_OP_P (DECL_NAME (alloc_call_fndecl))
2945 || CP_DECL_CONTEXT (alloc_call_fndecl) != global_namespace)
2946 return alloc_call;
2947
2948 tree rtype = build_new_constexpr_heap_type (elt_type, cookie_size,
2949 NULL_TREE);
2950 return build_nop (build_pointer_type (rtype), alloc_call);
2951 }
2952
2953 /* Generate code for a new-expression, including calling the "operator
2954 new" function, initializing the object, and, if an exception occurs
2955 during construction, cleaning up. The arguments are as for
2956 build_raw_new_expr. This may change PLACEMENT and INIT.
2957 TYPE is the type of the object being constructed, possibly an array
2958 of NELTS elements when NELTS is non-null (in "new T[NELTS]", T may
2959 be an array of the form U[inner], with the whole expression being
2960 "new U[NELTS][inner]"). */
2961
2962 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)2963 build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts,
2964 vec<tree, va_gc> **init, bool globally_qualified_p,
2965 tsubst_flags_t complain)
2966 {
2967 tree size, rval;
2968 /* True iff this is a call to "operator new[]" instead of just
2969 "operator new". */
2970 bool array_p = false;
2971 /* If ARRAY_P is true, the element type of the array. This is never
2972 an ARRAY_TYPE; for something like "new int[3][4]", the
2973 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
2974 TYPE. */
2975 tree elt_type;
2976 /* The type of the new-expression. (This type is always a pointer
2977 type.) */
2978 tree pointer_type;
2979 tree non_const_pointer_type;
2980 /* The most significant array bound in int[OUTER_NELTS][inner]. */
2981 tree outer_nelts = NULL_TREE;
2982 /* For arrays with a non-constant number of elements, a bounds checks
2983 on the NELTS parameter to avoid integer overflow at runtime. */
2984 tree outer_nelts_check = NULL_TREE;
2985 bool outer_nelts_from_type = false;
2986 /* Number of the "inner" elements in "new T[OUTER_NELTS][inner]". */
2987 offset_int inner_nelts_count = 1;
2988 tree alloc_call, alloc_expr;
2989 /* Size of the inner array elements (those with constant dimensions). */
2990 offset_int inner_size;
2991 /* The address returned by the call to "operator new". This node is
2992 a VAR_DECL and is therefore reusable. */
2993 tree alloc_node;
2994 tree alloc_fn;
2995 tree cookie_expr, init_expr;
2996 int nothrow, check_new;
2997 /* If non-NULL, the number of extra bytes to allocate at the
2998 beginning of the storage allocated for an array-new expression in
2999 order to store the number of elements. */
3000 tree cookie_size = NULL_TREE;
3001 tree placement_first;
3002 tree placement_expr = NULL_TREE;
3003 /* True if the function we are calling is a placement allocation
3004 function. */
3005 bool placement_allocation_fn_p;
3006 /* True if the storage must be initialized, either by a constructor
3007 or due to an explicit new-initializer. */
3008 bool is_initialized;
3009 /* The address of the thing allocated, not including any cookie. In
3010 particular, if an array cookie is in use, DATA_ADDR is the
3011 address of the first array element. This node is a VAR_DECL, and
3012 is therefore reusable. */
3013 tree data_addr;
3014 tree init_preeval_expr = NULL_TREE;
3015 tree orig_type = type;
3016
3017 if (nelts)
3018 {
3019 outer_nelts = nelts;
3020 array_p = true;
3021 }
3022 else if (TREE_CODE (type) == ARRAY_TYPE)
3023 {
3024 /* Transforms new (T[N]) to new T[N]. The former is a GNU
3025 extension for variable N. (This also covers new T where T is
3026 a VLA typedef.) */
3027 array_p = true;
3028 nelts = array_type_nelts_top (type);
3029 outer_nelts = nelts;
3030 type = TREE_TYPE (type);
3031 outer_nelts_from_type = true;
3032 }
3033
3034 /* Lots of logic below depends on whether we have a constant number of
3035 elements, so go ahead and fold it now. */
3036 const_tree cst_outer_nelts = fold_non_dependent_expr (outer_nelts, complain);
3037
3038 /* If our base type is an array, then make sure we know how many elements
3039 it has. */
3040 for (elt_type = type;
3041 TREE_CODE (elt_type) == ARRAY_TYPE;
3042 elt_type = TREE_TYPE (elt_type))
3043 {
3044 tree inner_nelts = array_type_nelts_top (elt_type);
3045 tree inner_nelts_cst = maybe_constant_value (inner_nelts);
3046 if (TREE_CODE (inner_nelts_cst) == INTEGER_CST)
3047 {
3048 wi::overflow_type overflow;
3049 offset_int result = wi::mul (wi::to_offset (inner_nelts_cst),
3050 inner_nelts_count, SIGNED, &overflow);
3051 if (overflow)
3052 {
3053 if (complain & tf_error)
3054 error ("integer overflow in array size");
3055 nelts = error_mark_node;
3056 }
3057 inner_nelts_count = result;
3058 }
3059 else
3060 {
3061 if (complain & tf_error)
3062 {
3063 error_at (cp_expr_loc_or_input_loc (inner_nelts),
3064 "array size in new-expression must be constant");
3065 cxx_constant_value(inner_nelts);
3066 }
3067 nelts = error_mark_node;
3068 }
3069 if (nelts != error_mark_node)
3070 nelts = cp_build_binary_op (input_location,
3071 MULT_EXPR, nelts,
3072 inner_nelts_cst,
3073 complain);
3074 }
3075
3076 if (!verify_type_context (input_location, TCTX_ALLOCATION, elt_type,
3077 !(complain & tf_error)))
3078 return error_mark_node;
3079
3080 if (variably_modified_type_p (elt_type, NULL_TREE) && (complain & tf_error))
3081 {
3082 error ("variably modified type not allowed in new-expression");
3083 return error_mark_node;
3084 }
3085
3086 if (nelts == error_mark_node)
3087 return error_mark_node;
3088
3089 /* Warn if we performed the (T[N]) to T[N] transformation and N is
3090 variable. */
3091 if (outer_nelts_from_type
3092 && !TREE_CONSTANT (cst_outer_nelts))
3093 {
3094 if (complain & tf_warning_or_error)
3095 {
3096 pedwarn (cp_expr_loc_or_input_loc (outer_nelts), OPT_Wvla,
3097 typedef_variant_p (orig_type)
3098 ? G_("non-constant array new length must be specified "
3099 "directly, not by %<typedef%>")
3100 : G_("non-constant array new length must be specified "
3101 "without parentheses around the type-id"));
3102 }
3103 else
3104 return error_mark_node;
3105 }
3106
3107 if (VOID_TYPE_P (elt_type))
3108 {
3109 if (complain & tf_error)
3110 error ("invalid type %<void%> for %<new%>");
3111 return error_mark_node;
3112 }
3113
3114 if (is_std_init_list (elt_type))
3115 warning (OPT_Winit_list_lifetime,
3116 "%<new%> of %<initializer_list%> does not "
3117 "extend the lifetime of the underlying array");
3118
3119 if (abstract_virtuals_error_sfinae (ACU_NEW, elt_type, complain))
3120 return error_mark_node;
3121
3122 is_initialized = (type_build_ctor_call (elt_type) || *init != NULL);
3123
3124 if (*init == NULL && cxx_dialect < cxx11)
3125 {
3126 bool maybe_uninitialized_error = false;
3127 /* A program that calls for default-initialization [...] of an
3128 entity of reference type is ill-formed. */
3129 if (CLASSTYPE_REF_FIELDS_NEED_INIT (elt_type))
3130 maybe_uninitialized_error = true;
3131
3132 /* A new-expression that creates an object of type T initializes
3133 that object as follows:
3134 - If the new-initializer is omitted:
3135 -- If T is a (possibly cv-qualified) non-POD class type
3136 (or array thereof), the object is default-initialized (8.5).
3137 [...]
3138 -- Otherwise, the object created has indeterminate
3139 value. If T is a const-qualified type, or a (possibly
3140 cv-qualified) POD class type (or array thereof)
3141 containing (directly or indirectly) a member of
3142 const-qualified type, the program is ill-formed; */
3143
3144 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (elt_type))
3145 maybe_uninitialized_error = true;
3146
3147 if (maybe_uninitialized_error
3148 && diagnose_uninitialized_cst_or_ref_member (elt_type,
3149 /*using_new=*/true,
3150 complain & tf_error))
3151 return error_mark_node;
3152 }
3153
3154 if (CP_TYPE_CONST_P (elt_type) && *init == NULL
3155 && default_init_uninitialized_part (elt_type))
3156 {
3157 if (complain & tf_error)
3158 error ("uninitialized const in %<new%> of %q#T", elt_type);
3159 return error_mark_node;
3160 }
3161
3162 size = size_in_bytes (elt_type);
3163 if (array_p)
3164 {
3165 /* Maximum available size in bytes. Half of the address space
3166 minus the cookie size. */
3167 offset_int max_size
3168 = wi::set_bit_in_zero <offset_int> (TYPE_PRECISION (sizetype) - 1);
3169 /* Maximum number of outer elements which can be allocated. */
3170 offset_int max_outer_nelts;
3171 tree max_outer_nelts_tree;
3172
3173 gcc_assert (TREE_CODE (size) == INTEGER_CST);
3174 cookie_size = targetm.cxx.get_cookie_size (elt_type);
3175 gcc_assert (TREE_CODE (cookie_size) == INTEGER_CST);
3176 gcc_checking_assert (wi::ltu_p (wi::to_offset (cookie_size), max_size));
3177 /* Unconditionally subtract the cookie size. This decreases the
3178 maximum object size and is safe even if we choose not to use
3179 a cookie after all. */
3180 max_size -= wi::to_offset (cookie_size);
3181 wi::overflow_type overflow;
3182 inner_size = wi::mul (wi::to_offset (size), inner_nelts_count, SIGNED,
3183 &overflow);
3184 if (overflow || wi::gtu_p (inner_size, max_size))
3185 {
3186 if (complain & tf_error)
3187 {
3188 cst_size_error error;
3189 if (overflow)
3190 error = cst_size_overflow;
3191 else
3192 {
3193 error = cst_size_too_big;
3194 size = size_binop (MULT_EXPR, size,
3195 wide_int_to_tree (sizetype,
3196 inner_nelts_count));
3197 size = cp_fully_fold (size);
3198 }
3199 invalid_array_size_error (input_location, error, size,
3200 /*name=*/NULL_TREE);
3201 }
3202 return error_mark_node;
3203 }
3204
3205 max_outer_nelts = wi::udiv_trunc (max_size, inner_size);
3206 max_outer_nelts_tree = wide_int_to_tree (sizetype, max_outer_nelts);
3207
3208 size = size_binop (MULT_EXPR, size, fold_convert (sizetype, nelts));
3209
3210 if (TREE_CODE (cst_outer_nelts) == INTEGER_CST)
3211 {
3212 if (tree_int_cst_lt (max_outer_nelts_tree, cst_outer_nelts))
3213 {
3214 /* When the array size is constant, check it at compile time
3215 to make sure it doesn't exceed the implementation-defined
3216 maximum, as required by C++ 14 (in C++ 11 this requirement
3217 isn't explicitly stated but it's enforced anyway -- see
3218 grokdeclarator in cp/decl.c). */
3219 if (complain & tf_error)
3220 {
3221 size = cp_fully_fold (size);
3222 invalid_array_size_error (input_location, cst_size_too_big,
3223 size, NULL_TREE);
3224 }
3225 return error_mark_node;
3226 }
3227 }
3228 else
3229 {
3230 /* When a runtime check is necessary because the array size
3231 isn't constant, keep only the top-most seven bits (starting
3232 with the most significant non-zero bit) of the maximum size
3233 to compare the array size against, to simplify encoding the
3234 constant maximum size in the instruction stream. */
3235
3236 unsigned shift = (max_outer_nelts.get_precision ()) - 7
3237 - wi::clz (max_outer_nelts);
3238 max_outer_nelts = (max_outer_nelts >> shift) << shift;
3239
3240 outer_nelts_check = fold_build2 (LE_EXPR, boolean_type_node,
3241 outer_nelts,
3242 max_outer_nelts_tree);
3243 }
3244 }
3245
3246 tree align_arg = NULL_TREE;
3247 if (type_has_new_extended_alignment (elt_type))
3248 align_arg = build_int_cst (align_type_node, TYPE_ALIGN_UNIT (elt_type));
3249
3250 alloc_fn = NULL_TREE;
3251
3252 /* If PLACEMENT is a single simple pointer type not passed by
3253 reference, prepare to capture it in a temporary variable. Do
3254 this now, since PLACEMENT will change in the calls below. */
3255 placement_first = NULL_TREE;
3256 if (vec_safe_length (*placement) == 1
3257 && (TYPE_PTR_P (TREE_TYPE ((**placement)[0]))))
3258 placement_first = (**placement)[0];
3259
3260 bool member_new_p = false;
3261
3262 /* Allocate the object. */
3263 tree fnname;
3264 tree fns;
3265
3266 fnname = ovl_op_identifier (false, array_p ? VEC_NEW_EXPR : NEW_EXPR);
3267
3268 member_new_p = !globally_qualified_p
3269 && CLASS_TYPE_P (elt_type)
3270 && (array_p
3271 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
3272 : TYPE_HAS_NEW_OPERATOR (elt_type));
3273
3274 if (member_new_p)
3275 {
3276 /* Use a class-specific operator new. */
3277 /* If a cookie is required, add some extra space. */
3278 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
3279 size = size_binop (PLUS_EXPR, size, cookie_size);
3280 else
3281 {
3282 cookie_size = NULL_TREE;
3283 /* No size arithmetic necessary, so the size check is
3284 not needed. */
3285 if (outer_nelts_check != NULL && inner_size == 1)
3286 outer_nelts_check = NULL_TREE;
3287 }
3288 /* Perform the overflow check. */
3289 tree errval = TYPE_MAX_VALUE (sizetype);
3290 if (cxx_dialect >= cxx11 && flag_exceptions)
3291 errval = throw_bad_array_new_length ();
3292 if (outer_nelts_check != NULL_TREE)
3293 size = fold_build3 (COND_EXPR, sizetype, outer_nelts_check,
3294 size, errval);
3295 /* Create the argument list. */
3296 vec_safe_insert (*placement, 0, size);
3297 /* Do name-lookup to find the appropriate operator. */
3298 fns = lookup_fnfields (elt_type, fnname, /*protect=*/2);
3299 if (fns == NULL_TREE)
3300 {
3301 if (complain & tf_error)
3302 error ("no suitable %qD found in class %qT", fnname, elt_type);
3303 return error_mark_node;
3304 }
3305 if (TREE_CODE (fns) == TREE_LIST)
3306 {
3307 if (complain & tf_error)
3308 {
3309 error ("request for member %qD is ambiguous", fnname);
3310 print_candidates (fns);
3311 }
3312 return error_mark_node;
3313 }
3314 tree dummy = build_dummy_object (elt_type);
3315 alloc_call = NULL_TREE;
3316 if (align_arg)
3317 {
3318 vec<tree, va_gc> *align_args
3319 = vec_copy_and_insert (*placement, align_arg, 1);
3320 alloc_call
3321 = build_new_method_call (dummy, fns, &align_args,
3322 /*conversion_path=*/NULL_TREE,
3323 LOOKUP_NORMAL, &alloc_fn, tf_none);
3324 /* If no matching function is found and the allocated object type
3325 has new-extended alignment, the alignment argument is removed
3326 from the argument list, and overload resolution is performed
3327 again. */
3328 if (alloc_call == error_mark_node)
3329 alloc_call = NULL_TREE;
3330 }
3331 if (!alloc_call)
3332 alloc_call = build_new_method_call (dummy, fns, placement,
3333 /*conversion_path=*/NULL_TREE,
3334 LOOKUP_NORMAL,
3335 &alloc_fn, complain);
3336 }
3337 else
3338 {
3339 /* Use a global operator new. */
3340 /* See if a cookie might be required. */
3341 if (!(array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type)))
3342 {
3343 cookie_size = NULL_TREE;
3344 /* No size arithmetic necessary, so the size check is
3345 not needed. */
3346 if (outer_nelts_check != NULL && inner_size == 1)
3347 outer_nelts_check = NULL_TREE;
3348 }
3349
3350 alloc_call = build_operator_new_call (fnname, placement,
3351 &size, &cookie_size,
3352 align_arg, outer_nelts_check,
3353 &alloc_fn, complain);
3354 }
3355
3356 if (alloc_call == error_mark_node)
3357 return error_mark_node;
3358
3359 gcc_assert (alloc_fn != NULL_TREE);
3360
3361 /* Now, check to see if this function is actually a placement
3362 allocation function. This can happen even when PLACEMENT is NULL
3363 because we might have something like:
3364
3365 struct S { void* operator new (size_t, int i = 0); };
3366
3367 A call to `new S' will get this allocation function, even though
3368 there is no explicit placement argument. If there is more than
3369 one argument, or there are variable arguments, then this is a
3370 placement allocation function. */
3371 placement_allocation_fn_p
3372 = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
3373 || varargs_function_p (alloc_fn));
3374
3375 if (warn_aligned_new
3376 && !placement_allocation_fn_p
3377 && TYPE_ALIGN (elt_type) > malloc_alignment ()
3378 && (warn_aligned_new > 1
3379 || CP_DECL_CONTEXT (alloc_fn) == global_namespace)
3380 && !aligned_allocation_fn_p (alloc_fn))
3381 {
3382 auto_diagnostic_group d;
3383 if (warning (OPT_Waligned_new_, "%<new%> of type %qT with extended "
3384 "alignment %d", elt_type, TYPE_ALIGN_UNIT (elt_type)))
3385 {
3386 inform (input_location, "uses %qD, which does not have an alignment "
3387 "parameter", alloc_fn);
3388 if (!aligned_new_threshold)
3389 inform (input_location, "use %<-faligned-new%> to enable C++17 "
3390 "over-aligned new support");
3391 }
3392 }
3393
3394 /* If we found a simple case of PLACEMENT_EXPR above, then copy it
3395 into a temporary variable. */
3396 if (!processing_template_decl
3397 && TREE_CODE (alloc_call) == CALL_EXPR
3398 && call_expr_nargs (alloc_call) == 2
3399 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 0))) == INTEGER_TYPE
3400 && TYPE_PTR_P (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 1))))
3401 {
3402 tree placement = CALL_EXPR_ARG (alloc_call, 1);
3403
3404 if (placement_first != NULL_TREE
3405 && (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement)))
3406 || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement)))))
3407 {
3408 placement_expr = get_target_expr (placement_first);
3409 CALL_EXPR_ARG (alloc_call, 1)
3410 = fold_convert (TREE_TYPE (placement), placement_expr);
3411 }
3412
3413 if (!member_new_p
3414 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 1)))))
3415 {
3416 /* Attempt to make the warning point at the operator new argument. */
3417 if (placement_first)
3418 placement = placement_first;
3419
3420 warn_placement_new_too_small (orig_type, nelts, size, placement);
3421 }
3422 }
3423
3424 tree alloc_call_expr = extract_call_expr (alloc_call);
3425 if (TREE_CODE (alloc_call_expr) == CALL_EXPR)
3426 CALL_FROM_NEW_OR_DELETE_P (alloc_call_expr) = 1;
3427
3428 if (cookie_size)
3429 alloc_call = maybe_wrap_new_for_constexpr (alloc_call, elt_type,
3430 cookie_size);
3431
3432 /* In the simple case, we can stop now. */
3433 pointer_type = build_pointer_type (type);
3434 if (!cookie_size && !is_initialized)
3435 return build_nop (pointer_type, alloc_call);
3436
3437 /* Store the result of the allocation call in a variable so that we can
3438 use it more than once. */
3439 alloc_expr = get_target_expr (alloc_call);
3440 alloc_node = TARGET_EXPR_SLOT (alloc_expr);
3441
3442 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
3443 while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
3444 alloc_call = TREE_OPERAND (alloc_call, 1);
3445
3446 /* Preevaluate the placement args so that we don't reevaluate them for a
3447 placement delete. */
3448 if (placement_allocation_fn_p)
3449 {
3450 tree inits;
3451 stabilize_call (alloc_call, &inits);
3452 if (inits)
3453 alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
3454 alloc_expr);
3455 }
3456
3457 /* unless an allocation function is declared with an empty excep-
3458 tion-specification (_except.spec_), throw(), it indicates failure to
3459 allocate storage by throwing a bad_alloc exception (clause _except_,
3460 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
3461 cation function is declared with an empty exception-specification,
3462 throw(), it returns null to indicate failure to allocate storage and a
3463 non-null pointer otherwise.
3464
3465 So check for a null exception spec on the op new we just called. */
3466
3467 nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
3468 check_new
3469 = flag_check_new || (nothrow && !std_placement_new_fn_p (alloc_fn));
3470
3471 if (cookie_size)
3472 {
3473 tree cookie;
3474 tree cookie_ptr;
3475 tree size_ptr_type;
3476
3477 /* Adjust so we're pointing to the start of the object. */
3478 data_addr = fold_build_pointer_plus (alloc_node, cookie_size);
3479
3480 /* Store the number of bytes allocated so that we can know how
3481 many elements to destroy later. We use the last sizeof
3482 (size_t) bytes to store the number of elements. */
3483 cookie_ptr = size_binop (MINUS_EXPR, cookie_size, size_in_bytes (sizetype));
3484 cookie_ptr = fold_build_pointer_plus_loc (input_location,
3485 alloc_node, cookie_ptr);
3486 size_ptr_type = build_pointer_type (sizetype);
3487 cookie_ptr = fold_convert (size_ptr_type, cookie_ptr);
3488 cookie = cp_build_fold_indirect_ref (cookie_ptr);
3489
3490 cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
3491
3492 if (targetm.cxx.cookie_has_size ())
3493 {
3494 /* Also store the element size. */
3495 cookie_ptr = fold_build_pointer_plus (cookie_ptr,
3496 fold_build1_loc (input_location,
3497 NEGATE_EXPR, sizetype,
3498 size_in_bytes (sizetype)));
3499
3500 cookie = cp_build_fold_indirect_ref (cookie_ptr);
3501 cookie = build2 (MODIFY_EXPR, sizetype, cookie,
3502 size_in_bytes (elt_type));
3503 cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
3504 cookie, cookie_expr);
3505 }
3506 }
3507 else
3508 {
3509 cookie_expr = NULL_TREE;
3510 data_addr = alloc_node;
3511 }
3512
3513 /* Now use a pointer to the type we've actually allocated. */
3514
3515 /* But we want to operate on a non-const version to start with,
3516 since we'll be modifying the elements. */
3517 non_const_pointer_type = build_pointer_type
3518 (cp_build_qualified_type (type, cp_type_quals (type) & ~TYPE_QUAL_CONST));
3519
3520 data_addr = fold_convert (non_const_pointer_type, data_addr);
3521 /* Any further uses of alloc_node will want this type, too. */
3522 alloc_node = fold_convert (non_const_pointer_type, alloc_node);
3523
3524 /* Now initialize the allocated object. Note that we preevaluate the
3525 initialization expression, apart from the actual constructor call or
3526 assignment--we do this because we want to delay the allocation as long
3527 as possible in order to minimize the size of the exception region for
3528 placement delete. */
3529 if (is_initialized)
3530 {
3531 bool stable;
3532 bool explicit_value_init_p = false;
3533
3534 if (*init != NULL && (*init)->is_empty ())
3535 {
3536 *init = NULL;
3537 explicit_value_init_p = true;
3538 }
3539
3540 if (processing_template_decl)
3541 {
3542 /* Avoid an ICE when converting to a base in build_simple_base_path.
3543 We'll throw this all away anyway, and build_new will create
3544 a NEW_EXPR. */
3545 tree t = fold_convert (build_pointer_type (elt_type), data_addr);
3546 /* build_value_init doesn't work in templates, and we don't need
3547 the initializer anyway since we're going to throw it away and
3548 rebuild it at instantiation time, so just build up a single
3549 constructor call to get any appropriate diagnostics. */
3550 init_expr = cp_build_fold_indirect_ref (t);
3551 if (type_build_ctor_call (elt_type))
3552 init_expr = build_special_member_call (init_expr,
3553 complete_ctor_identifier,
3554 init, elt_type,
3555 LOOKUP_NORMAL,
3556 complain);
3557 stable = stabilize_init (init_expr, &init_preeval_expr);
3558 }
3559 else if (array_p)
3560 {
3561 tree vecinit = NULL_TREE;
3562 if (vec_safe_length (*init) == 1
3563 && DIRECT_LIST_INIT_P ((**init)[0]))
3564 {
3565 vecinit = (**init)[0];
3566 if (CONSTRUCTOR_NELTS (vecinit) == 0)
3567 /* List-value-initialization, leave it alone. */;
3568 else
3569 {
3570 tree arraytype, domain;
3571 if (TREE_CONSTANT (nelts))
3572 domain = compute_array_index_type (NULL_TREE, nelts,
3573 complain);
3574 else
3575 /* We'll check the length at runtime. */
3576 domain = NULL_TREE;
3577 arraytype = build_cplus_array_type (type, domain);
3578 vecinit = digest_init (arraytype, vecinit, complain);
3579 }
3580 }
3581 else if (*init)
3582 {
3583 if (complain & tf_error)
3584 error ("parenthesized initializer in array new");
3585 return error_mark_node;
3586 }
3587 init_expr
3588 = build_vec_init (data_addr,
3589 cp_build_binary_op (input_location,
3590 MINUS_EXPR, outer_nelts,
3591 integer_one_node,
3592 complain),
3593 vecinit,
3594 explicit_value_init_p,
3595 /*from_array=*/0,
3596 complain);
3597
3598 /* An array initialization is stable because the initialization
3599 of each element is a full-expression, so the temporaries don't
3600 leak out. */
3601 stable = true;
3602 }
3603 else
3604 {
3605 init_expr = cp_build_fold_indirect_ref (data_addr);
3606
3607 if (type_build_ctor_call (type) && !explicit_value_init_p)
3608 {
3609 init_expr = build_special_member_call (init_expr,
3610 complete_ctor_identifier,
3611 init, elt_type,
3612 LOOKUP_NORMAL,
3613 complain|tf_no_cleanup);
3614 }
3615 else if (explicit_value_init_p)
3616 {
3617 /* Something like `new int()'. NO_CLEANUP is needed so
3618 we don't try and build a (possibly ill-formed)
3619 destructor. */
3620 tree val = build_value_init (type, complain | tf_no_cleanup);
3621 if (val == error_mark_node)
3622 return error_mark_node;
3623 init_expr = build2 (INIT_EXPR, type, init_expr, val);
3624 }
3625 else
3626 {
3627 tree ie;
3628
3629 /* We are processing something like `new int (10)', which
3630 means allocate an int, and initialize it with 10.
3631
3632 In C++20, also handle `new A(1, 2)'. */
3633 if (cxx_dialect >= cxx2a
3634 && AGGREGATE_TYPE_P (type)
3635 && (*init)->length () > 1)
3636 {
3637 ie = build_tree_list_vec (*init);
3638 ie = build_constructor_from_list (init_list_type_node, ie);
3639 CONSTRUCTOR_IS_DIRECT_INIT (ie) = true;
3640 CONSTRUCTOR_IS_PAREN_INIT (ie) = true;
3641 ie = digest_init (type, ie, complain);
3642 }
3643 else
3644 ie = build_x_compound_expr_from_vec (*init, "new initializer",
3645 complain);
3646 init_expr = cp_build_modify_expr (input_location, init_expr,
3647 INIT_EXPR, ie, complain);
3648 }
3649 /* If the initializer uses C++14 aggregate NSDMI that refer to the
3650 object being initialized, replace them now and don't try to
3651 preevaluate. */
3652 bool had_placeholder = false;
3653 if (!processing_template_decl
3654 && TREE_CODE (init_expr) == INIT_EXPR)
3655 TREE_OPERAND (init_expr, 1)
3656 = replace_placeholders (TREE_OPERAND (init_expr, 1),
3657 TREE_OPERAND (init_expr, 0),
3658 &had_placeholder);
3659 stable = (!had_placeholder
3660 && stabilize_init (init_expr, &init_preeval_expr));
3661 }
3662
3663 if (init_expr == error_mark_node)
3664 return error_mark_node;
3665
3666 /* If any part of the object initialization terminates by throwing an
3667 exception and a suitable deallocation function can be found, the
3668 deallocation function is called to free the memory in which the
3669 object was being constructed, after which the exception continues
3670 to propagate in the context of the new-expression. If no
3671 unambiguous matching deallocation function can be found,
3672 propagating the exception does not cause the object's memory to be
3673 freed. */
3674 if (flag_exceptions)
3675 {
3676 enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
3677 tree cleanup;
3678
3679 /* The Standard is unclear here, but the right thing to do
3680 is to use the same method for finding deallocation
3681 functions that we use for finding allocation functions. */
3682 cleanup = (build_op_delete_call
3683 (dcode,
3684 alloc_node,
3685 size,
3686 globally_qualified_p,
3687 placement_allocation_fn_p ? alloc_call : NULL_TREE,
3688 alloc_fn,
3689 complain));
3690
3691 if (!cleanup)
3692 /* We're done. */;
3693 else if (stable)
3694 /* This is much simpler if we were able to preevaluate all of
3695 the arguments to the constructor call. */
3696 {
3697 /* CLEANUP is compiler-generated, so no diagnostics. */
3698 TREE_NO_WARNING (cleanup) = true;
3699 init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
3700 init_expr, cleanup);
3701 /* Likewise, this try-catch is compiler-generated. */
3702 TREE_NO_WARNING (init_expr) = true;
3703 }
3704 else
3705 /* Ack! First we allocate the memory. Then we set our sentry
3706 variable to true, and expand a cleanup that deletes the
3707 memory if sentry is true. Then we run the constructor, and
3708 finally clear the sentry.
3709
3710 We need to do this because we allocate the space first, so
3711 if there are any temporaries with cleanups in the
3712 constructor args and we weren't able to preevaluate them, we
3713 need this EH region to extend until end of full-expression
3714 to preserve nesting. */
3715 {
3716 tree end, sentry, begin;
3717
3718 begin = get_target_expr (boolean_true_node);
3719 CLEANUP_EH_ONLY (begin) = 1;
3720
3721 sentry = TARGET_EXPR_SLOT (begin);
3722
3723 /* CLEANUP is compiler-generated, so no diagnostics. */
3724 TREE_NO_WARNING (cleanup) = true;
3725
3726 TARGET_EXPR_CLEANUP (begin)
3727 = build3 (COND_EXPR, void_type_node, sentry,
3728 cleanup, void_node);
3729
3730 end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
3731 sentry, boolean_false_node);
3732
3733 init_expr
3734 = build2 (COMPOUND_EXPR, void_type_node, begin,
3735 build2 (COMPOUND_EXPR, void_type_node, init_expr,
3736 end));
3737 /* Likewise, this is compiler-generated. */
3738 TREE_NO_WARNING (init_expr) = true;
3739 }
3740 }
3741 }
3742 else
3743 init_expr = NULL_TREE;
3744
3745 /* Now build up the return value in reverse order. */
3746
3747 rval = data_addr;
3748
3749 if (init_expr)
3750 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
3751 if (cookie_expr)
3752 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
3753
3754 if (rval == data_addr)
3755 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
3756 and return the call (which doesn't need to be adjusted). */
3757 rval = TARGET_EXPR_INITIAL (alloc_expr);
3758 else
3759 {
3760 if (check_new)
3761 {
3762 tree ifexp = cp_build_binary_op (input_location,
3763 NE_EXPR, alloc_node,
3764 nullptr_node,
3765 complain);
3766 rval = build_conditional_expr (input_location, ifexp, rval,
3767 alloc_node, complain);
3768 }
3769
3770 /* Perform the allocation before anything else, so that ALLOC_NODE
3771 has been initialized before we start using it. */
3772 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
3773 }
3774
3775 if (init_preeval_expr)
3776 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
3777
3778 /* A new-expression is never an lvalue. */
3779 gcc_assert (!obvalue_p (rval));
3780
3781 return convert (pointer_type, rval);
3782 }
3783
3784 /* Generate a representation for a C++ "new" expression. *PLACEMENT
3785 is a vector of placement-new arguments (or NULL if none). If NELTS
3786 is NULL, TYPE is the type of the storage to be allocated. If NELTS
3787 is not NULL, then this is an array-new allocation; TYPE is the type
3788 of the elements in the array and NELTS is the number of elements in
3789 the array. *INIT, if non-NULL, is the initializer for the new
3790 object, or an empty vector to indicate an initializer of "()". If
3791 USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
3792 rather than just "new". This may change PLACEMENT and INIT. */
3793
3794 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)3795 build_new (location_t loc, vec<tree, va_gc> **placement, tree type,
3796 tree nelts, vec<tree, va_gc> **init, int use_global_new,
3797 tsubst_flags_t complain)
3798 {
3799 tree rval;
3800 vec<tree, va_gc> *orig_placement = NULL;
3801 tree orig_nelts = NULL_TREE;
3802 vec<tree, va_gc> *orig_init = NULL;
3803
3804 if (type == error_mark_node)
3805 return error_mark_node;
3806
3807 if (nelts == NULL_TREE
3808 /* Don't do auto deduction where it might affect mangling. */
3809 && (!processing_template_decl || at_function_scope_p ()))
3810 {
3811 tree auto_node = type_uses_auto (type);
3812 if (auto_node)
3813 {
3814 tree d_init = NULL_TREE;
3815 const size_t len = vec_safe_length (*init);
3816 /* E.g. new auto(x) must have exactly one element, or
3817 a {} initializer will have one element. */
3818 if (len == 1)
3819 {
3820 d_init = (**init)[0];
3821 d_init = resolve_nondeduced_context (d_init, complain);
3822 }
3823 /* For the rest, e.g. new A(1, 2, 3), create a list. */
3824 else if (len > 1)
3825 {
3826 unsigned int n;
3827 tree t;
3828 tree *pp = &d_init;
3829 FOR_EACH_VEC_ELT (**init, n, t)
3830 {
3831 t = resolve_nondeduced_context (t, complain);
3832 *pp = build_tree_list (NULL_TREE, t);
3833 pp = &TREE_CHAIN (*pp);
3834 }
3835 }
3836 type = do_auto_deduction (type, d_init, auto_node, complain);
3837 }
3838 }
3839
3840 if (processing_template_decl)
3841 {
3842 if (dependent_type_p (type)
3843 || any_type_dependent_arguments_p (*placement)
3844 || (nelts && type_dependent_expression_p (nelts))
3845 || (nelts && *init)
3846 || any_type_dependent_arguments_p (*init))
3847 return build_raw_new_expr (loc, *placement, type, nelts, *init,
3848 use_global_new);
3849
3850 orig_placement = make_tree_vector_copy (*placement);
3851 orig_nelts = nelts;
3852 if (*init)
3853 {
3854 orig_init = make_tree_vector_copy (*init);
3855 /* Also copy any CONSTRUCTORs in *init, since reshape_init and
3856 digest_init clobber them in place. */
3857 for (unsigned i = 0; i < orig_init->length(); ++i)
3858 {
3859 tree e = (**init)[i];
3860 if (TREE_CODE (e) == CONSTRUCTOR)
3861 (**init)[i] = copy_node (e);
3862 }
3863 }
3864
3865 make_args_non_dependent (*placement);
3866 if (nelts)
3867 nelts = build_non_dependent_expr (nelts);
3868 make_args_non_dependent (*init);
3869 }
3870
3871 if (nelts)
3872 {
3873 location_t nelts_loc = cp_expr_loc_or_loc (nelts, loc);
3874 if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
3875 {
3876 if (complain & tf_error)
3877 permerror (nelts_loc,
3878 "size in array new must have integral type");
3879 else
3880 return error_mark_node;
3881 }
3882
3883 /* Try to determine the constant value only for the purposes
3884 of the diagnostic below but continue to use the original
3885 value and handle const folding later. */
3886 const_tree cst_nelts = fold_non_dependent_expr (nelts, complain);
3887
3888 /* The expression in a noptr-new-declarator is erroneous if it's of
3889 non-class type and its value before converting to std::size_t is
3890 less than zero. ... If the expression is a constant expression,
3891 the program is ill-fomed. */
3892 if (TREE_CODE (cst_nelts) == INTEGER_CST
3893 && !valid_array_size_p (nelts_loc, cst_nelts, NULL_TREE,
3894 complain & tf_error))
3895 return error_mark_node;
3896
3897 nelts = mark_rvalue_use (nelts);
3898 nelts = cp_save_expr (cp_convert (sizetype, nelts, complain));
3899 }
3900
3901 /* ``A reference cannot be created by the new operator. A reference
3902 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
3903 returned by new.'' ARM 5.3.3 */
3904 if (TYPE_REF_P (type))
3905 {
3906 if (complain & tf_error)
3907 error_at (loc, "new cannot be applied to a reference type");
3908 else
3909 return error_mark_node;
3910 type = TREE_TYPE (type);
3911 }
3912
3913 if (TREE_CODE (type) == FUNCTION_TYPE)
3914 {
3915 if (complain & tf_error)
3916 error_at (loc, "new cannot be applied to a function type");
3917 return error_mark_node;
3918 }
3919
3920 /* The type allocated must be complete. If the new-type-id was
3921 "T[N]" then we are just checking that "T" is complete here, but
3922 that is equivalent, since the value of "N" doesn't matter. */
3923 if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
3924 return error_mark_node;
3925
3926 rval = build_new_1 (placement, type, nelts, init, use_global_new, complain);
3927 if (rval == error_mark_node)
3928 return error_mark_node;
3929
3930 if (processing_template_decl)
3931 {
3932 tree ret = build_raw_new_expr (loc, orig_placement, type, orig_nelts,
3933 orig_init, use_global_new);
3934 release_tree_vector (orig_placement);
3935 release_tree_vector (orig_init);
3936 return ret;
3937 }
3938
3939 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
3940 rval = build1_loc (loc, NOP_EXPR, TREE_TYPE (rval), rval);
3941 TREE_NO_WARNING (rval) = 1;
3942
3943 return rval;
3944 }
3945
3946 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)3947 build_vec_delete_1 (location_t loc, tree base, tree maxindex, tree type,
3948 special_function_kind auto_delete_vec,
3949 int use_global_delete, tsubst_flags_t complain)
3950 {
3951 tree virtual_size;
3952 tree ptype = build_pointer_type (type = complete_type (type));
3953 tree size_exp;
3954
3955 /* Temporary variables used by the loop. */
3956 tree tbase, tbase_init;
3957
3958 /* This is the body of the loop that implements the deletion of a
3959 single element, and moves temp variables to next elements. */
3960 tree body;
3961
3962 /* This is the LOOP_EXPR that governs the deletion of the elements. */
3963 tree loop = 0;
3964
3965 /* This is the thing that governs what to do after the loop has run. */
3966 tree deallocate_expr = 0;
3967
3968 /* This is the BIND_EXPR which holds the outermost iterator of the
3969 loop. It is convenient to set this variable up and test it before
3970 executing any other code in the loop.
3971 This is also the containing expression returned by this function. */
3972 tree controller = NULL_TREE;
3973 tree tmp;
3974
3975 /* We should only have 1-D arrays here. */
3976 gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
3977
3978 if (base == error_mark_node || maxindex == error_mark_node)
3979 return error_mark_node;
3980
3981 if (!verify_type_context (loc, TCTX_DEALLOCATION, type,
3982 !(complain & tf_error)))
3983 return error_mark_node;
3984
3985 if (!COMPLETE_TYPE_P (type))
3986 {
3987 if (complain & tf_warning)
3988 {
3989 auto_diagnostic_group d;
3990 if (warning_at (loc, OPT_Wdelete_incomplete,
3991 "possible problem detected in invocation of "
3992 "operator %<delete []%>"))
3993 {
3994 cxx_incomplete_type_diagnostic (base, type, DK_WARNING);
3995 inform (loc, "neither the destructor nor the "
3996 "class-specific operator %<delete []%> will be called, "
3997 "even if they are declared when the class is defined");
3998 }
3999 }
4000 /* This size won't actually be used. */
4001 size_exp = size_one_node;
4002 goto no_destructor;
4003 }
4004
4005 size_exp = size_in_bytes (type);
4006
4007 if (! MAYBE_CLASS_TYPE_P (type))
4008 goto no_destructor;
4009 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
4010 {
4011 /* Make sure the destructor is callable. */
4012 if (type_build_dtor_call (type))
4013 {
4014 tmp = build_delete (loc, ptype, base, sfk_complete_destructor,
4015 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1,
4016 complain);
4017 if (tmp == error_mark_node)
4018 return error_mark_node;
4019 }
4020 goto no_destructor;
4021 }
4022
4023 /* The below is short by the cookie size. */
4024 virtual_size = size_binop (MULT_EXPR, size_exp,
4025 fold_convert (sizetype, maxindex));
4026
4027 tbase = create_temporary_var (ptype);
4028 DECL_INITIAL (tbase)
4029 = fold_build_pointer_plus_loc (loc, fold_convert (ptype, base),
4030 virtual_size);
4031 tbase_init = build_stmt (loc, DECL_EXPR, tbase);
4032 controller = build3 (BIND_EXPR, void_type_node, tbase, NULL_TREE, NULL_TREE);
4033 TREE_SIDE_EFFECTS (controller) = 1;
4034
4035 body = build1 (EXIT_EXPR, void_type_node,
4036 build2 (EQ_EXPR, boolean_type_node, tbase,
4037 fold_convert (ptype, base)));
4038 tmp = fold_build1_loc (loc, NEGATE_EXPR, sizetype, size_exp);
4039 tmp = fold_build_pointer_plus (tbase, tmp);
4040 tmp = cp_build_modify_expr (loc, tbase, NOP_EXPR, tmp, complain);
4041 if (tmp == error_mark_node)
4042 return error_mark_node;
4043 body = build_compound_expr (loc, body, tmp);
4044 tmp = build_delete (loc, ptype, tbase, sfk_complete_destructor,
4045 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1,
4046 complain);
4047 if (tmp == error_mark_node)
4048 return error_mark_node;
4049 body = build_compound_expr (loc, body, tmp);
4050
4051 loop = build1 (LOOP_EXPR, void_type_node, body);
4052 loop = build_compound_expr (loc, tbase_init, loop);
4053
4054 no_destructor:
4055 /* Delete the storage if appropriate. */
4056 if (auto_delete_vec == sfk_deleting_destructor)
4057 {
4058 tree base_tbd;
4059
4060 /* The below is short by the cookie size. */
4061 virtual_size = size_binop (MULT_EXPR, size_exp,
4062 fold_convert (sizetype, maxindex));
4063
4064 if (! TYPE_VEC_NEW_USES_COOKIE (type))
4065 /* no header */
4066 base_tbd = base;
4067 else
4068 {
4069 tree cookie_size;
4070
4071 cookie_size = targetm.cxx.get_cookie_size (type);
4072 base_tbd = cp_build_binary_op (loc,
4073 MINUS_EXPR,
4074 cp_convert (string_type_node,
4075 base, complain),
4076 cookie_size,
4077 complain);
4078 if (base_tbd == error_mark_node)
4079 return error_mark_node;
4080 base_tbd = cp_convert (ptype, base_tbd, complain);
4081 /* True size with header. */
4082 virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
4083 }
4084
4085 deallocate_expr = build_op_delete_call (VEC_DELETE_EXPR,
4086 base_tbd, virtual_size,
4087 use_global_delete & 1,
4088 /*placement=*/NULL_TREE,
4089 /*alloc_fn=*/NULL_TREE,
4090 complain);
4091
4092 tree deallocate_call_expr = extract_call_expr (deallocate_expr);
4093 if (TREE_CODE (deallocate_call_expr) == CALL_EXPR)
4094 CALL_FROM_NEW_OR_DELETE_P (deallocate_call_expr) = 1;
4095 }
4096
4097 body = loop;
4098 if (!deallocate_expr)
4099 ;
4100 else if (!body)
4101 body = deallocate_expr;
4102 else
4103 /* The delete operator must be called, even if a destructor
4104 throws. */
4105 body = build2 (TRY_FINALLY_EXPR, void_type_node, body, deallocate_expr);
4106
4107 if (!body)
4108 body = integer_zero_node;
4109
4110 /* Outermost wrapper: If pointer is null, punt. */
4111 tree cond = build2_loc (loc, NE_EXPR, boolean_type_node, base,
4112 fold_convert (TREE_TYPE (base), nullptr_node));
4113 /* This is a compiler generated comparison, don't emit
4114 e.g. -Wnonnull-compare warning for it. */
4115 TREE_NO_WARNING (cond) = 1;
4116 body = build3_loc (loc, COND_EXPR, void_type_node,
4117 cond, body, integer_zero_node);
4118 COND_EXPR_IS_VEC_DELETE (body) = true;
4119 body = build1 (NOP_EXPR, void_type_node, body);
4120
4121 if (controller)
4122 {
4123 TREE_OPERAND (controller, 1) = body;
4124 body = controller;
4125 }
4126
4127 if (TREE_CODE (base) == SAVE_EXPR)
4128 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
4129 body = build2 (COMPOUND_EXPR, void_type_node, base, body);
4130
4131 return convert_to_void (body, ICV_CAST, complain);
4132 }
4133
4134 /* Create an unnamed variable of the indicated TYPE. */
4135
4136 tree
create_temporary_var(tree type)4137 create_temporary_var (tree type)
4138 {
4139 tree decl;
4140
4141 decl = build_decl (input_location,
4142 VAR_DECL, NULL_TREE, type);
4143 TREE_USED (decl) = 1;
4144 DECL_ARTIFICIAL (decl) = 1;
4145 DECL_IGNORED_P (decl) = 1;
4146 DECL_CONTEXT (decl) = current_function_decl;
4147
4148 return decl;
4149 }
4150
4151 /* Create a new temporary variable of the indicated TYPE, initialized
4152 to INIT.
4153
4154 It is not entered into current_binding_level, because that breaks
4155 things when it comes time to do final cleanups (which take place
4156 "outside" the binding contour of the function). */
4157
4158 tree
get_temp_regvar(tree type,tree init)4159 get_temp_regvar (tree type, tree init)
4160 {
4161 tree decl;
4162
4163 decl = create_temporary_var (type);
4164 add_decl_expr (decl);
4165
4166 finish_expr_stmt (cp_build_modify_expr (input_location, decl, INIT_EXPR,
4167 init, tf_warning_or_error));
4168
4169 return decl;
4170 }
4171
4172 /* Subroutine of build_vec_init. Returns true if assigning to an array of
4173 INNER_ELT_TYPE from INIT is trivial. */
4174
4175 static bool
vec_copy_assign_is_trivial(tree inner_elt_type,tree init)4176 vec_copy_assign_is_trivial (tree inner_elt_type, tree init)
4177 {
4178 tree fromtype = inner_elt_type;
4179 if (lvalue_p (init))
4180 fromtype = cp_build_reference_type (fromtype, /*rval*/false);
4181 return is_trivially_xible (MODIFY_EXPR, inner_elt_type, fromtype);
4182 }
4183
4184 /* Subroutine of build_vec_init: Check that the array has at least N
4185 elements. Other parameters are local variables in build_vec_init. */
4186
4187 void
finish_length_check(tree atype,tree iterator,tree obase,unsigned n)4188 finish_length_check (tree atype, tree iterator, tree obase, unsigned n)
4189 {
4190 tree nelts = build_int_cst (ptrdiff_type_node, n - 1);
4191 if (TREE_CODE (atype) != ARRAY_TYPE)
4192 {
4193 if (flag_exceptions)
4194 {
4195 tree c = fold_build2 (LT_EXPR, boolean_type_node, iterator,
4196 nelts);
4197 c = build3 (COND_EXPR, void_type_node, c,
4198 throw_bad_array_new_length (), void_node);
4199 finish_expr_stmt (c);
4200 }
4201 /* Don't check an array new when -fno-exceptions. */
4202 }
4203 else if (sanitize_flags_p (SANITIZE_BOUNDS)
4204 && current_function_decl != NULL_TREE)
4205 {
4206 /* Make sure the last element of the initializer is in bounds. */
4207 finish_expr_stmt
4208 (ubsan_instrument_bounds
4209 (input_location, obase, &nelts, /*ignore_off_by_one*/false));
4210 }
4211 }
4212
4213 /* `build_vec_init' returns tree structure that performs
4214 initialization of a vector of aggregate types.
4215
4216 BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
4217 to the first element, of POINTER_TYPE.
4218 MAXINDEX is the maximum index of the array (one less than the
4219 number of elements). It is only used if BASE is a pointer or
4220 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
4221
4222 INIT is the (possibly NULL) initializer.
4223
4224 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All
4225 elements in the array are value-initialized.
4226
4227 FROM_ARRAY is 0 if we should init everything with INIT
4228 (i.e., every element initialized from INIT).
4229 FROM_ARRAY is 1 if we should index into INIT in parallel
4230 with initialization of DECL.
4231 FROM_ARRAY is 2 if we should index into INIT in parallel,
4232 but use assignment instead of initialization. */
4233
4234 tree
build_vec_init(tree base,tree maxindex,tree init,bool explicit_value_init_p,int from_array,tsubst_flags_t complain)4235 build_vec_init (tree base, tree maxindex, tree init,
4236 bool explicit_value_init_p,
4237 int from_array, tsubst_flags_t complain)
4238 {
4239 tree rval;
4240 tree base2 = NULL_TREE;
4241 tree itype = NULL_TREE;
4242 tree iterator;
4243 /* The type of BASE. */
4244 tree atype = TREE_TYPE (base);
4245 /* The type of an element in the array. */
4246 tree type = TREE_TYPE (atype);
4247 /* The element type reached after removing all outer array
4248 types. */
4249 tree inner_elt_type;
4250 /* The type of a pointer to an element in the array. */
4251 tree ptype;
4252 tree stmt_expr;
4253 tree compound_stmt;
4254 int destroy_temps;
4255 tree try_block = NULL_TREE;
4256 HOST_WIDE_INT num_initialized_elts = 0;
4257 bool is_global;
4258 tree obase = base;
4259 bool xvalue = false;
4260 bool errors = false;
4261 location_t loc = (init ? cp_expr_loc_or_input_loc (init)
4262 : location_of (base));
4263
4264 if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype))
4265 maxindex = array_type_nelts (atype);
4266
4267 if (maxindex == NULL_TREE || maxindex == error_mark_node)
4268 return error_mark_node;
4269
4270 maxindex = maybe_constant_value (maxindex);
4271 if (explicit_value_init_p)
4272 gcc_assert (!init);
4273
4274 inner_elt_type = strip_array_types (type);
4275
4276 /* Look through the TARGET_EXPR around a compound literal. */
4277 if (init && TREE_CODE (init) == TARGET_EXPR
4278 && TREE_CODE (TARGET_EXPR_INITIAL (init)) == CONSTRUCTOR
4279 && from_array != 2)
4280 init = TARGET_EXPR_INITIAL (init);
4281
4282 bool direct_init = false;
4283 if (from_array && init && BRACE_ENCLOSED_INITIALIZER_P (init)
4284 && CONSTRUCTOR_NELTS (init) == 1)
4285 {
4286 tree elt = CONSTRUCTOR_ELT (init, 0)->value;
4287 if (TREE_CODE (TREE_TYPE (elt)) == ARRAY_TYPE)
4288 {
4289 direct_init = DIRECT_LIST_INIT_P (init);
4290 init = elt;
4291 }
4292 }
4293
4294 /* If we have a braced-init-list or string constant, make sure that the array
4295 is big enough for all the initializers. */
4296 bool length_check = (init
4297 && (TREE_CODE (init) == STRING_CST
4298 || (TREE_CODE (init) == CONSTRUCTOR
4299 && CONSTRUCTOR_NELTS (init) > 0))
4300 && !TREE_CONSTANT (maxindex));
4301
4302 if (init
4303 && TREE_CODE (atype) == ARRAY_TYPE
4304 && TREE_CONSTANT (maxindex)
4305 && (from_array == 2
4306 ? vec_copy_assign_is_trivial (inner_elt_type, init)
4307 : !TYPE_NEEDS_CONSTRUCTING (type))
4308 && ((TREE_CODE (init) == CONSTRUCTOR
4309 && (BRACE_ENCLOSED_INITIALIZER_P (init)
4310 || (same_type_ignoring_top_level_qualifiers_p
4311 (atype, TREE_TYPE (init))))
4312 /* Don't do this if the CONSTRUCTOR might contain something
4313 that might throw and require us to clean up. */
4314 && (vec_safe_is_empty (CONSTRUCTOR_ELTS (init))
4315 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
4316 || from_array))
4317 {
4318 /* Do non-default initialization of trivial arrays resulting from
4319 brace-enclosed initializers. In this case, digest_init and
4320 store_constructor will handle the semantics for us. */
4321
4322 if (BRACE_ENCLOSED_INITIALIZER_P (init))
4323 init = digest_init (atype, init, complain);
4324 stmt_expr = build2 (INIT_EXPR, atype, base, init);
4325 return stmt_expr;
4326 }
4327
4328 maxindex = cp_convert (ptrdiff_type_node, maxindex, complain);
4329 maxindex = fold_simple (maxindex);
4330
4331 if (TREE_CODE (atype) == ARRAY_TYPE)
4332 {
4333 ptype = build_pointer_type (type);
4334 base = decay_conversion (base, complain);
4335 if (base == error_mark_node)
4336 return error_mark_node;
4337 base = cp_convert (ptype, base, complain);
4338 }
4339 else
4340 ptype = atype;
4341
4342 if (integer_all_onesp (maxindex))
4343 {
4344 /* Shortcut zero element case to avoid unneeded constructor synthesis. */
4345 if (init && TREE_SIDE_EFFECTS (init))
4346 base = build2 (COMPOUND_EXPR, ptype, init, base);
4347 return base;
4348 }
4349
4350 /* The code we are generating looks like:
4351 ({
4352 T* t1 = (T*) base;
4353 T* rval = t1;
4354 ptrdiff_t iterator = maxindex;
4355 try {
4356 for (; iterator != -1; --iterator) {
4357 ... initialize *t1 ...
4358 ++t1;
4359 }
4360 } catch (...) {
4361 ... destroy elements that were constructed ...
4362 }
4363 rval;
4364 })
4365
4366 We can omit the try and catch blocks if we know that the
4367 initialization will never throw an exception, or if the array
4368 elements do not have destructors. We can omit the loop completely if
4369 the elements of the array do not have constructors.
4370
4371 We actually wrap the entire body of the above in a STMT_EXPR, for
4372 tidiness.
4373
4374 When copying from array to another, when the array elements have
4375 only trivial copy constructors, we should use __builtin_memcpy
4376 rather than generating a loop. That way, we could take advantage
4377 of whatever cleverness the back end has for dealing with copies
4378 of blocks of memory. */
4379
4380 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
4381 destroy_temps = stmts_are_full_exprs_p ();
4382 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
4383 rval = get_temp_regvar (ptype, base);
4384 base = get_temp_regvar (ptype, rval);
4385 iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
4386
4387 /* If initializing one array from another, initialize element by
4388 element. We rely upon the below calls to do the argument
4389 checking. Evaluate the initializer before entering the try block. */
4390 if (from_array && init && TREE_CODE (init) != CONSTRUCTOR)
4391 {
4392 if (lvalue_kind (init) & clk_rvalueref)
4393 xvalue = true;
4394 base2 = decay_conversion (init, complain);
4395 if (base2 == error_mark_node)
4396 return error_mark_node;
4397 itype = TREE_TYPE (base2);
4398 base2 = get_temp_regvar (itype, base2);
4399 itype = TREE_TYPE (itype);
4400 }
4401
4402 /* Protect the entire array initialization so that we can destroy
4403 the partially constructed array if an exception is thrown.
4404 But don't do this if we're assigning. */
4405 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
4406 && from_array != 2)
4407 {
4408 try_block = begin_try_block ();
4409 }
4410
4411 /* Should we try to create a constant initializer? */
4412 bool try_const = (TREE_CODE (atype) == ARRAY_TYPE
4413 && TREE_CONSTANT (maxindex)
4414 && (init ? TREE_CODE (init) == CONSTRUCTOR
4415 : (type_has_constexpr_default_constructor
4416 (inner_elt_type)))
4417 && (literal_type_p (inner_elt_type)
4418 || TYPE_HAS_CONSTEXPR_CTOR (inner_elt_type)));
4419 vec<constructor_elt, va_gc> *const_vec = NULL;
4420 bool saw_non_const = false;
4421 /* If we're initializing a static array, we want to do static
4422 initialization of any elements with constant initializers even if
4423 some are non-constant. */
4424 bool do_static_init = (DECL_P (obase) && TREE_STATIC (obase));
4425
4426 bool empty_list = false;
4427 if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
4428 && CONSTRUCTOR_NELTS (init) == 0)
4429 /* Skip over the handling of non-empty init lists. */
4430 empty_list = true;
4431
4432 /* Maybe pull out constant value when from_array? */
4433
4434 else if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
4435 {
4436 /* Do non-default initialization of non-trivial arrays resulting from
4437 brace-enclosed initializers. */
4438 unsigned HOST_WIDE_INT idx;
4439 tree field, elt;
4440 /* If the constructor already has the array type, it's been through
4441 digest_init, so we shouldn't try to do anything more. */
4442 bool digested = same_type_p (atype, TREE_TYPE (init));
4443 from_array = 0;
4444
4445 if (length_check)
4446 finish_length_check (atype, iterator, obase, CONSTRUCTOR_NELTS (init));
4447
4448 if (try_const)
4449 vec_alloc (const_vec, CONSTRUCTOR_NELTS (init));
4450
4451 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx, field, elt)
4452 {
4453 tree baseref = build1 (INDIRECT_REF, type, base);
4454 tree one_init;
4455
4456 num_initialized_elts++;
4457
4458 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4459 if (digested)
4460 one_init = build2 (INIT_EXPR, type, baseref, elt);
4461 else if (MAYBE_CLASS_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
4462 one_init = build_aggr_init (baseref, elt, 0, complain);
4463 else
4464 one_init = cp_build_modify_expr (input_location, baseref,
4465 NOP_EXPR, elt, complain);
4466 if (one_init == error_mark_node)
4467 errors = true;
4468 if (try_const)
4469 {
4470 if (!field)
4471 field = size_int (idx);
4472 tree e = maybe_constant_init (one_init);
4473 if (reduced_constant_expression_p (e))
4474 {
4475 CONSTRUCTOR_APPEND_ELT (const_vec, field, e);
4476 if (do_static_init)
4477 one_init = NULL_TREE;
4478 else
4479 one_init = build2 (INIT_EXPR, type, baseref, e);
4480 }
4481 else
4482 {
4483 if (do_static_init)
4484 {
4485 tree value = build_zero_init (TREE_TYPE (e), NULL_TREE,
4486 true);
4487 if (value)
4488 CONSTRUCTOR_APPEND_ELT (const_vec, field, value);
4489 }
4490 saw_non_const = true;
4491 }
4492 }
4493
4494 if (one_init)
4495 finish_expr_stmt (one_init);
4496 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
4497
4498 one_init = cp_build_unary_op (PREINCREMENT_EXPR, base, false,
4499 complain);
4500 if (one_init == error_mark_node)
4501 errors = true;
4502 else
4503 finish_expr_stmt (one_init);
4504
4505 one_init = cp_build_unary_op (PREDECREMENT_EXPR, iterator, false,
4506 complain);
4507 if (one_init == error_mark_node)
4508 errors = true;
4509 else
4510 finish_expr_stmt (one_init);
4511 }
4512
4513 /* Any elements without explicit initializers get T{}. */
4514 empty_list = true;
4515 }
4516 else if (init && TREE_CODE (init) == STRING_CST)
4517 {
4518 /* Check that the array is at least as long as the string. */
4519 if (length_check)
4520 finish_length_check (atype, iterator, obase,
4521 TREE_STRING_LENGTH (init));
4522 tree length = build_int_cst (ptrdiff_type_node,
4523 TREE_STRING_LENGTH (init));
4524
4525 /* Copy the string to the first part of the array. */
4526 tree alias_set = build_int_cst (build_pointer_type (type), 0);
4527 tree lhs = build2 (MEM_REF, TREE_TYPE (init), base, alias_set);
4528 tree stmt = build2 (MODIFY_EXPR, void_type_node, lhs, init);
4529 finish_expr_stmt (stmt);
4530
4531 /* Adjust the counter and pointer. */
4532 stmt = cp_build_binary_op (loc, MINUS_EXPR, iterator, length, complain);
4533 stmt = build2 (MODIFY_EXPR, void_type_node, iterator, stmt);
4534 finish_expr_stmt (stmt);
4535
4536 stmt = cp_build_binary_op (loc, PLUS_EXPR, base, length, complain);
4537 stmt = build2 (MODIFY_EXPR, void_type_node, base, stmt);
4538 finish_expr_stmt (stmt);
4539
4540 /* And set the rest of the array to NUL. */
4541 from_array = 0;
4542 explicit_value_init_p = true;
4543 }
4544 else if (from_array)
4545 {
4546 if (init)
4547 /* OK, we set base2 above. */;
4548 else if (CLASS_TYPE_P (type)
4549 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
4550 {
4551 if (complain & tf_error)
4552 error ("initializer ends prematurely");
4553 errors = true;
4554 }
4555 }
4556
4557 /* Now, default-initialize any remaining elements. We don't need to
4558 do that if a) the type does not need constructing, or b) we've
4559 already initialized all the elements.
4560
4561 We do need to keep going if we're copying an array. */
4562
4563 if (try_const && !init)
4564 /* With a constexpr default constructor, which we checked for when
4565 setting try_const above, default-initialization is equivalent to
4566 value-initialization, and build_value_init gives us something more
4567 friendly to maybe_constant_init. */
4568 explicit_value_init_p = true;
4569 if (from_array
4570 || ((type_build_ctor_call (type) || init || explicit_value_init_p)
4571 && ! (tree_fits_shwi_p (maxindex)
4572 && (num_initialized_elts
4573 == tree_to_shwi (maxindex) + 1))))
4574 {
4575 /* If the ITERATOR is lesser or equal to -1, then we don't have to loop;
4576 we've already initialized all the elements. */
4577 tree for_stmt;
4578 tree elt_init;
4579 tree to;
4580
4581 for_stmt = begin_for_stmt (NULL_TREE, NULL_TREE);
4582 finish_init_stmt (for_stmt);
4583 finish_for_cond (build2 (GT_EXPR, boolean_type_node, iterator,
4584 build_int_cst (TREE_TYPE (iterator), -1)),
4585 for_stmt, false, 0);
4586 elt_init = cp_build_unary_op (PREDECREMENT_EXPR, iterator, false,
4587 complain);
4588 if (elt_init == error_mark_node)
4589 errors = true;
4590 finish_for_expr (elt_init, for_stmt);
4591
4592 to = build1 (INDIRECT_REF, type, base);
4593
4594 /* If the initializer is {}, then all elements are initialized from T{}.
4595 But for non-classes, that's the same as value-initialization. */
4596 if (empty_list)
4597 {
4598 if (cxx_dialect >= cxx11 && AGGREGATE_TYPE_P (type))
4599 {
4600 init = build_constructor (init_list_type_node, NULL);
4601 }
4602 else
4603 {
4604 init = NULL_TREE;
4605 explicit_value_init_p = true;
4606 }
4607 }
4608
4609 if (from_array)
4610 {
4611 tree from;
4612
4613 if (base2)
4614 {
4615 from = build1 (INDIRECT_REF, itype, base2);
4616 if (xvalue)
4617 from = move (from);
4618 if (direct_init)
4619 from = build_tree_list (NULL_TREE, from);
4620 }
4621 else
4622 from = NULL_TREE;
4623
4624 if (TREE_CODE (type) == ARRAY_TYPE)
4625 elt_init = build_vec_init (to, NULL_TREE, from, /*val_init*/false,
4626 from_array, complain);
4627 else if (from_array == 2)
4628 elt_init = cp_build_modify_expr (input_location, to, NOP_EXPR,
4629 from, complain);
4630 else if (type_build_ctor_call (type))
4631 elt_init = build_aggr_init (to, from, 0, complain);
4632 else if (from)
4633 elt_init = cp_build_modify_expr (input_location, to, NOP_EXPR, from,
4634 complain);
4635 else
4636 gcc_unreachable ();
4637 }
4638 else if (TREE_CODE (type) == ARRAY_TYPE)
4639 {
4640 if (init && !BRACE_ENCLOSED_INITIALIZER_P (init))
4641 {
4642 if ((complain & tf_error))
4643 error_at (loc, "array must be initialized "
4644 "with a brace-enclosed initializer");
4645 elt_init = error_mark_node;
4646 }
4647 else
4648 elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
4649 0, init,
4650 explicit_value_init_p,
4651 0, complain);
4652 }
4653 else if (explicit_value_init_p)
4654 {
4655 elt_init = build_value_init (type, complain);
4656 if (elt_init != error_mark_node)
4657 elt_init = build2 (INIT_EXPR, type, to, elt_init);
4658 }
4659 else
4660 {
4661 gcc_assert (type_build_ctor_call (type) || init);
4662 if (CLASS_TYPE_P (type))
4663 elt_init = build_aggr_init (to, init, 0, complain);
4664 else
4665 {
4666 if (TREE_CODE (init) == TREE_LIST)
4667 init = build_x_compound_expr_from_list (init, ELK_INIT,
4668 complain);
4669 elt_init = (init == error_mark_node
4670 ? error_mark_node
4671 : build2 (INIT_EXPR, type, to, init));
4672 }
4673 }
4674
4675 if (elt_init == error_mark_node)
4676 errors = true;
4677
4678 if (try_const)
4679 {
4680 /* FIXME refs to earlier elts */
4681 tree e = maybe_constant_init (elt_init);
4682 if (reduced_constant_expression_p (e))
4683 {
4684 if (initializer_zerop (e))
4685 /* Don't fill the CONSTRUCTOR with zeros. */
4686 e = NULL_TREE;
4687 if (do_static_init)
4688 elt_init = NULL_TREE;
4689 }
4690 else
4691 {
4692 saw_non_const = true;
4693 if (do_static_init)
4694 e = build_zero_init (TREE_TYPE (e), NULL_TREE, true);
4695 else
4696 e = NULL_TREE;
4697 }
4698
4699 if (e)
4700 {
4701 HOST_WIDE_INT last = tree_to_shwi (maxindex);
4702 if (num_initialized_elts <= last)
4703 {
4704 tree field = size_int (num_initialized_elts);
4705 if (num_initialized_elts != last)
4706 field = build2 (RANGE_EXPR, sizetype, field,
4707 size_int (last));
4708 CONSTRUCTOR_APPEND_ELT (const_vec, field, e);
4709 }
4710 }
4711 }
4712
4713 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4714 if (elt_init && !errors)
4715 finish_expr_stmt (elt_init);
4716 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
4717
4718 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, false,
4719 complain));
4720 if (base2)
4721 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base2, false,
4722 complain));
4723
4724 finish_for_stmt (for_stmt);
4725 }
4726
4727 /* Make sure to cleanup any partially constructed elements. */
4728 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
4729 && from_array != 2)
4730 {
4731 tree e;
4732 tree m = cp_build_binary_op (input_location,
4733 MINUS_EXPR, maxindex, iterator,
4734 complain);
4735
4736 /* Flatten multi-dimensional array since build_vec_delete only
4737 expects one-dimensional array. */
4738 if (TREE_CODE (type) == ARRAY_TYPE)
4739 m = cp_build_binary_op (input_location,
4740 MULT_EXPR, m,
4741 /* Avoid mixing signed and unsigned. */
4742 convert (TREE_TYPE (m),
4743 array_type_nelts_total (type)),
4744 complain);
4745
4746 finish_cleanup_try_block (try_block);
4747 e = build_vec_delete_1 (input_location, rval, m,
4748 inner_elt_type, sfk_complete_destructor,
4749 /*use_global_delete=*/0, complain);
4750 if (e == error_mark_node)
4751 errors = true;
4752 finish_cleanup (e, try_block);
4753 }
4754
4755 /* The value of the array initialization is the array itself, RVAL
4756 is a pointer to the first element. */
4757 finish_stmt_expr_expr (rval, stmt_expr);
4758
4759 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
4760
4761 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
4762
4763 if (errors)
4764 return error_mark_node;
4765
4766 if (try_const)
4767 {
4768 if (!saw_non_const)
4769 {
4770 tree const_init = build_constructor (atype, const_vec);
4771 return build2 (INIT_EXPR, atype, obase, const_init);
4772 }
4773 else if (do_static_init && !vec_safe_is_empty (const_vec))
4774 DECL_INITIAL (obase) = build_constructor (atype, const_vec);
4775 else
4776 vec_free (const_vec);
4777 }
4778
4779 /* Now make the result have the correct type. */
4780 if (TREE_CODE (atype) == ARRAY_TYPE)
4781 {
4782 atype = build_pointer_type (atype);
4783 stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
4784 stmt_expr = cp_build_fold_indirect_ref (stmt_expr);
4785 TREE_NO_WARNING (stmt_expr) = 1;
4786 }
4787
4788 return stmt_expr;
4789 }
4790
4791 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
4792 build_delete. */
4793
4794 static tree
build_dtor_call(tree exp,special_function_kind dtor_kind,int flags,tsubst_flags_t complain)4795 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags,
4796 tsubst_flags_t complain)
4797 {
4798 tree name;
4799 switch (dtor_kind)
4800 {
4801 case sfk_complete_destructor:
4802 name = complete_dtor_identifier;
4803 break;
4804
4805 case sfk_base_destructor:
4806 name = base_dtor_identifier;
4807 break;
4808
4809 case sfk_deleting_destructor:
4810 name = deleting_dtor_identifier;
4811 break;
4812
4813 default:
4814 gcc_unreachable ();
4815 }
4816
4817 return build_special_member_call (exp, name,
4818 /*args=*/NULL,
4819 /*binfo=*/TREE_TYPE (exp),
4820 flags,
4821 complain);
4822 }
4823
4824 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
4825 ADDR is an expression which yields the store to be destroyed.
4826 AUTO_DELETE is the name of the destructor to call, i.e., either
4827 sfk_complete_destructor, sfk_base_destructor, or
4828 sfk_deleting_destructor.
4829
4830 FLAGS is the logical disjunction of zero or more LOOKUP_
4831 flags. See cp-tree.h for more info. */
4832
4833 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)4834 build_delete (location_t loc, tree otype, tree addr,
4835 special_function_kind auto_delete,
4836 int flags, int use_global_delete, tsubst_flags_t complain)
4837 {
4838 tree expr;
4839
4840 if (addr == error_mark_node)
4841 return error_mark_node;
4842
4843 tree type = TYPE_MAIN_VARIANT (otype);
4844
4845 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
4846 set to `error_mark_node' before it gets properly cleaned up. */
4847 if (type == error_mark_node)
4848 return error_mark_node;
4849
4850 if (TYPE_PTR_P (type))
4851 type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4852
4853 if (TREE_CODE (type) == ARRAY_TYPE)
4854 {
4855 if (TYPE_DOMAIN (type) == NULL_TREE)
4856 {
4857 if (complain & tf_error)
4858 error_at (loc, "unknown array size in delete");
4859 return error_mark_node;
4860 }
4861 return build_vec_delete (loc, addr, array_type_nelts (type),
4862 auto_delete, use_global_delete, complain);
4863 }
4864
4865 bool deleting = (auto_delete == sfk_deleting_destructor);
4866 gcc_assert (deleting == !(flags & LOOKUP_DESTRUCTOR));
4867
4868 if (TYPE_PTR_P (otype))
4869 {
4870 addr = mark_rvalue_use (addr);
4871
4872 /* We don't want to warn about delete of void*, only other
4873 incomplete types. Deleting other incomplete types
4874 invokes undefined behavior, but it is not ill-formed, so
4875 compile to something that would even do The Right Thing
4876 (TM) should the type have a trivial dtor and no delete
4877 operator. */
4878 if (!VOID_TYPE_P (type))
4879 {
4880 complete_type (type);
4881 if (deleting
4882 && !verify_type_context (loc, TCTX_DEALLOCATION, type,
4883 !(complain & tf_error)))
4884 return error_mark_node;
4885
4886 if (!COMPLETE_TYPE_P (type))
4887 {
4888 if (complain & tf_warning)
4889 {
4890 auto_diagnostic_group d;
4891 if (warning_at (loc, OPT_Wdelete_incomplete,
4892 "possible problem detected in invocation of "
4893 "%<operator delete%>"))
4894 {
4895 cxx_incomplete_type_diagnostic (addr, type, DK_WARNING);
4896 inform (loc,
4897 "neither the destructor nor the class-specific "
4898 "%<operator delete%> will be called, even if "
4899 "they are declared when the class is defined");
4900 }
4901 }
4902 }
4903 else if (deleting && warn_delnonvdtor
4904 && MAYBE_CLASS_TYPE_P (type) && !CLASSTYPE_FINAL (type)
4905 && TYPE_POLYMORPHIC_P (type))
4906 {
4907 tree dtor = CLASSTYPE_DESTRUCTOR (type);
4908 if (!dtor || !DECL_VINDEX (dtor))
4909 {
4910 if (CLASSTYPE_PURE_VIRTUALS (type))
4911 warning_at (loc, OPT_Wdelete_non_virtual_dtor,
4912 "deleting object of abstract class type %qT"
4913 " which has non-virtual destructor"
4914 " will cause undefined behavior", type);
4915 else
4916 warning_at (loc, OPT_Wdelete_non_virtual_dtor,
4917 "deleting object of polymorphic class type %qT"
4918 " which has non-virtual destructor"
4919 " might cause undefined behavior", type);
4920 }
4921 }
4922 }
4923
4924 /* Throw away const and volatile on target type of addr. */
4925 addr = convert_force (build_pointer_type (type), addr, 0, complain);
4926 }
4927 else
4928 {
4929 /* Don't check PROTECT here; leave that decision to the
4930 destructor. If the destructor is accessible, call it,
4931 else report error. */
4932 addr = cp_build_addr_expr (addr, complain);
4933 if (addr == error_mark_node)
4934 return error_mark_node;
4935
4936 addr = convert_force (build_pointer_type (type), addr, 0, complain);
4937 }
4938
4939 if (deleting)
4940 /* We will use ADDR multiple times so we must save it. */
4941 addr = save_expr (addr);
4942
4943 bool virtual_p = false;
4944 if (type_build_dtor_call (type))
4945 {
4946 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
4947 lazily_declare_fn (sfk_destructor, type);
4948 virtual_p = DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTOR (type));
4949 }
4950
4951 tree head = NULL_TREE;
4952 tree do_delete = NULL_TREE;
4953 bool destroying_delete = false;
4954
4955 if (!deleting)
4956 {
4957 /* Leave do_delete null. */
4958 }
4959 /* For `::delete x', we must not use the deleting destructor
4960 since then we would not be sure to get the global `operator
4961 delete'. */
4962 else if (use_global_delete)
4963 {
4964 head = get_target_expr (build_headof (addr));
4965 /* Delete the object. */
4966 do_delete = build_op_delete_call (DELETE_EXPR,
4967 head,
4968 cxx_sizeof_nowarn (type),
4969 /*global_p=*/true,
4970 /*placement=*/NULL_TREE,
4971 /*alloc_fn=*/NULL_TREE,
4972 complain);
4973 /* Otherwise, treat this like a complete object destructor
4974 call. */
4975 auto_delete = sfk_complete_destructor;
4976 }
4977 /* If the destructor is non-virtual, there is no deleting
4978 variant. Instead, we must explicitly call the appropriate
4979 `operator delete' here. */
4980 else if (!virtual_p)
4981 {
4982 /* Build the call. */
4983 do_delete = build_op_delete_call (DELETE_EXPR,
4984 addr,
4985 cxx_sizeof_nowarn (type),
4986 /*global_p=*/false,
4987 /*placement=*/NULL_TREE,
4988 /*alloc_fn=*/NULL_TREE,
4989 complain);
4990 /* Call the complete object destructor. */
4991 auto_delete = sfk_complete_destructor;
4992 if (do_delete != error_mark_node)
4993 {
4994 tree fn = get_callee_fndecl (do_delete);
4995 destroying_delete = destroying_delete_p (fn);
4996 }
4997 }
4998 else if (TYPE_GETS_REG_DELETE (type))
4999 {
5000 /* Make sure we have access to the member op delete, even though
5001 we'll actually be calling it from the destructor. */
5002 build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
5003 /*global_p=*/false,
5004 /*placement=*/NULL_TREE,
5005 /*alloc_fn=*/NULL_TREE,
5006 complain);
5007 }
5008
5009 if (!destroying_delete && type_build_dtor_call (type))
5010 expr = build_dtor_call (cp_build_fold_indirect_ref (addr),
5011 auto_delete, flags, complain);
5012 else
5013 expr = build_trivial_dtor_call (addr);
5014 if (expr == error_mark_node)
5015 return error_mark_node;
5016
5017 if (!deleting)
5018 {
5019 protected_set_expr_location (expr, loc);
5020 return expr;
5021 }
5022
5023 if (do_delete)
5024 {
5025 tree do_delete_call_expr = extract_call_expr (do_delete);
5026 if (TREE_CODE (do_delete_call_expr) == CALL_EXPR)
5027 CALL_FROM_NEW_OR_DELETE_P (do_delete_call_expr) = 1;
5028 }
5029
5030 if (do_delete && !TREE_SIDE_EFFECTS (expr))
5031 expr = do_delete;
5032 else if (do_delete)
5033 /* The delete operator must be called, regardless of whether
5034 the destructor throws.
5035
5036 [expr.delete]/7 The deallocation function is called
5037 regardless of whether the destructor for the object or some
5038 element of the array throws an exception. */
5039 expr = build2 (TRY_FINALLY_EXPR, void_type_node, expr, do_delete);
5040
5041 /* We need to calculate this before the dtor changes the vptr. */
5042 if (head)
5043 expr = build2 (COMPOUND_EXPR, void_type_node, head, expr);
5044
5045 /* Handle deleting a null pointer. */
5046 warning_sentinel s (warn_address);
5047 tree ifexp = cp_build_binary_op (loc, NE_EXPR, addr,
5048 nullptr_node, complain);
5049 ifexp = cp_fully_fold (ifexp);
5050
5051 if (ifexp == error_mark_node)
5052 return error_mark_node;
5053 /* This is a compiler generated comparison, don't emit
5054 e.g. -Wnonnull-compare warning for it. */
5055 else if (TREE_CODE (ifexp) == NE_EXPR)
5056 TREE_NO_WARNING (ifexp) = 1;
5057
5058 if (!integer_nonzerop (ifexp))
5059 expr = build3 (COND_EXPR, void_type_node, ifexp, expr, void_node);
5060
5061 protected_set_expr_location (expr, loc);
5062 return expr;
5063 }
5064
5065 /* At the beginning of a destructor, push cleanups that will call the
5066 destructors for our base classes and members.
5067
5068 Called from begin_destructor_body. */
5069
5070 void
push_base_cleanups(void)5071 push_base_cleanups (void)
5072 {
5073 tree binfo, base_binfo;
5074 int i;
5075 tree member;
5076 tree expr;
5077 vec<tree, va_gc> *vbases;
5078
5079 /* Run destructors for all virtual baseclasses. */
5080 if (!ABSTRACT_CLASS_TYPE_P (current_class_type)
5081 && CLASSTYPE_VBASECLASSES (current_class_type))
5082 {
5083 tree cond = (condition_conversion
5084 (build2 (BIT_AND_EXPR, integer_type_node,
5085 current_in_charge_parm,
5086 integer_two_node)));
5087
5088 /* The CLASSTYPE_VBASECLASSES vector is in initialization
5089 order, which is also the right order for pushing cleanups. */
5090 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
5091 vec_safe_iterate (vbases, i, &base_binfo); i++)
5092 {
5093 if (type_build_dtor_call (BINFO_TYPE (base_binfo)))
5094 {
5095 expr = build_special_member_call (current_class_ref,
5096 base_dtor_identifier,
5097 NULL,
5098 base_binfo,
5099 (LOOKUP_NORMAL
5100 | LOOKUP_NONVIRTUAL),
5101 tf_warning_or_error);
5102 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
5103 {
5104 expr = build3 (COND_EXPR, void_type_node, cond,
5105 expr, void_node);
5106 finish_decl_cleanup (NULL_TREE, expr);
5107 }
5108 }
5109 }
5110 }
5111
5112 /* Take care of the remaining baseclasses. */
5113 for (binfo = TYPE_BINFO (current_class_type), i = 0;
5114 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
5115 {
5116 if (BINFO_VIRTUAL_P (base_binfo)
5117 || !type_build_dtor_call (BINFO_TYPE (base_binfo)))
5118 continue;
5119
5120 expr = build_special_member_call (current_class_ref,
5121 base_dtor_identifier,
5122 NULL, base_binfo,
5123 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
5124 tf_warning_or_error);
5125 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
5126 finish_decl_cleanup (NULL_TREE, expr);
5127 }
5128
5129 /* Don't automatically destroy union members. */
5130 if (TREE_CODE (current_class_type) == UNION_TYPE)
5131 return;
5132
5133 for (member = TYPE_FIELDS (current_class_type); member;
5134 member = DECL_CHAIN (member))
5135 {
5136 tree this_type = TREE_TYPE (member);
5137 if (this_type == error_mark_node
5138 || TREE_CODE (member) != FIELD_DECL
5139 || DECL_ARTIFICIAL (member))
5140 continue;
5141 if (ANON_AGGR_TYPE_P (this_type))
5142 continue;
5143 if (type_build_dtor_call (this_type))
5144 {
5145 tree this_member = (build_class_member_access_expr
5146 (current_class_ref, member,
5147 /*access_path=*/NULL_TREE,
5148 /*preserve_reference=*/false,
5149 tf_warning_or_error));
5150 expr = build_delete (input_location, this_type, this_member,
5151 sfk_complete_destructor,
5152 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
5153 0, tf_warning_or_error);
5154 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (this_type))
5155 finish_decl_cleanup (NULL_TREE, expr);
5156 }
5157 }
5158 }
5159
5160 /* Build a C++ vector delete expression.
5161 MAXINDEX is the number of elements to be deleted.
5162 ELT_SIZE is the nominal size of each element in the vector.
5163 BASE is the expression that should yield the store to be deleted.
5164 This function expands (or synthesizes) these calls itself.
5165 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
5166
5167 This also calls delete for virtual baseclasses of elements of the vector.
5168
5169 Update: MAXINDEX is no longer needed. The size can be extracted from the
5170 start of the vector for pointers, and from the type for arrays. We still
5171 use MAXINDEX for arrays because it happens to already have one of the
5172 values we'd have to extract. (We could use MAXINDEX with pointers to
5173 confirm the size, and trap if the numbers differ; not clear that it'd
5174 be worth bothering.) */
5175
5176 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)5177 build_vec_delete (location_t loc, tree base, tree maxindex,
5178 special_function_kind auto_delete_vec,
5179 int use_global_delete, tsubst_flags_t complain)
5180 {
5181 tree type;
5182 tree rval;
5183 tree base_init = NULL_TREE;
5184
5185 type = TREE_TYPE (base);
5186
5187 if (TYPE_PTR_P (type))
5188 {
5189 /* Step back one from start of vector, and read dimension. */
5190 tree cookie_addr;
5191 tree size_ptr_type = build_pointer_type (sizetype);
5192
5193 base = mark_rvalue_use (base);
5194 if (TREE_SIDE_EFFECTS (base))
5195 {
5196 base_init = get_target_expr (base);
5197 base = TARGET_EXPR_SLOT (base_init);
5198 }
5199 type = strip_array_types (TREE_TYPE (type));
5200 cookie_addr = fold_build1_loc (loc, NEGATE_EXPR,
5201 sizetype, TYPE_SIZE_UNIT (sizetype));
5202 cookie_addr = fold_build_pointer_plus (fold_convert (size_ptr_type, base),
5203 cookie_addr);
5204 maxindex = cp_build_fold_indirect_ref (cookie_addr);
5205 }
5206 else if (TREE_CODE (type) == ARRAY_TYPE)
5207 {
5208 /* Get the total number of things in the array, maxindex is a
5209 bad name. */
5210 maxindex = array_type_nelts_total (type);
5211 type = strip_array_types (type);
5212 base = decay_conversion (base, complain);
5213 if (base == error_mark_node)
5214 return error_mark_node;
5215 if (TREE_SIDE_EFFECTS (base))
5216 {
5217 base_init = get_target_expr (base);
5218 base = TARGET_EXPR_SLOT (base_init);
5219 }
5220 }
5221 else
5222 {
5223 if (base != error_mark_node && !(complain & tf_error))
5224 error_at (loc,
5225 "type to vector delete is neither pointer or array type");
5226 return error_mark_node;
5227 }
5228
5229 rval = build_vec_delete_1 (loc, base, maxindex, type, auto_delete_vec,
5230 use_global_delete, complain);
5231 if (base_init && rval != error_mark_node)
5232 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);
5233
5234 protected_set_expr_location (rval, loc);
5235 return rval;
5236 }
5237
5238 #include "gt-cp-init.h"
5239