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