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