init.c source code [gcc/cp/init.c]

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

Browse the source code of gcc/cp/init.c