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