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

1	/ Perform -- C++ -- constant expression evaluation, including calls to*
2	constexpr functions. These routines are used both during actual parsing
3	and during the instantiation of template functions.
4
5	Copyright (C) 1998-2017 Free Software Foundation, Inc.
6
7	This file is part of GCC.
8
9	GCC is free software; you can redistribute it and/or modify it
10	under the terms of the GNU General Public License as published by
11	the Free Software Foundation; either version 3, or (at your option)
12	any later version.
13
14	GCC is distributed in the hope that it will be useful, but
15	WITHOUT ANY WARRANTY; without even the implied warranty of
16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17	General Public License for more details.
18
19	You should have received a copy of the GNU General Public License
20	along with GCC; see the file COPYING3. If not see
21	<http://www.gnu.org/licenses/>. /*
22
23	#include "config.h"
24	#include "system.h"
25	#include "coretypes.h"
26	#include "cp-tree.h"
27	#include "varasm.h"
28	#include "c-family/c-objc.h"
29	#include "tree-iterator.h"
30	#include "gimplify.h"
31	#include "builtins.h"
32	#include "tree-inline.h"
33	#include "ubsan.h"
34	#include "gimple-fold.h"
35	#include "timevar.h"
36
37	static bool verify_constant (tree, bool, bool , bool* *);
38	#define VERIFY_CONSTANT(X) \
39	do { \
40	if (verify_constant ((X), ctx->quiet, non_constant_p, overflow_p)) \
41	return t; \
42	} while (0)
43
44	/ Returns true iff FUN is an instantiation of a constexpr function*
45	template or a defaulted constexpr function. /*
46
47	bool
48	is_instantiation_of_constexpr (tree fun)
49	{
50	return ((DECL_TEMPLOID_INSTANTIATION (fun)
51	&& DECL_DECLARED_CONSTEXPR_P (DECL_TI_TEMPLATE (fun)))
52	\|\| (DECL_DEFAULTED_FN (fun)
53	&& DECL_DECLARED_CONSTEXPR_P (fun)));
54	}
55
56	/ Return true if T is a literal type. /
57
58	bool
59	literal_type_p (tree t)
60	{
61	if (SCALAR_TYPE_P (t)
62	\|\| VECTOR_TYPE_P (t)
63	\|\| TREE_CODE (t) == REFERENCE_TYPE
64	\|\| (VOID_TYPE_P (t) && cxx_dialect >= cxx14))
65	return true;
66	if (CLASS_TYPE_P (t))
67	{
68	t = complete_type (t);
69	gcc_assert (COMPLETE_TYPE_P (t) \|\| errorcount);
70	return CLASSTYPE_LITERAL_P (t);
71	}
72	if (TREE_CODE (t) == ARRAY_TYPE)
73	return literal_type_p (strip_array_types (t));
74	return false;
75	}
76
77	/ If DECL is a variable declared `constexpr', require its type*
78	be literal. Return the DECL if OK, otherwise NULL. /*
79
80	tree
81	ensure_literal_type_for_constexpr_object (tree decl)
82	{
83	tree type = TREE_TYPE (decl);
84	if (VAR_P (decl)
85	&& (DECL_DECLARED_CONSTEXPR_P (decl)
86	\|\| var_in_constexpr_fn (decl))
87	&& !processing_template_decl)
88	{
89	tree stype = strip_array_types (type);
90	if (CLASS_TYPE_P (stype) && !COMPLETE_TYPE_P (complete_type (stype)))
91	/ Don't complain here, we'll complain about incompleteness*
92	when we try to initialize the variable. /*;
93	else if (!literal_type_p (type))
94	{
95	if (DECL_DECLARED_CONSTEXPR_P (decl))
96	{
97	error ("the type %qT of %<constexpr%> variable %qD "
98	"is not literal", type, decl);
99	explain_non_literal_class (type);
100	}
101	else
102	{
103	if (!is_instantiation_of_constexpr (current_function_decl))
104	{
105	error ("variable %qD of non-literal type %qT in %<constexpr%> "
106	"function", decl, type);
107	explain_non_literal_class (type);
108	}
109	cp_function_chain->invalid_constexpr = true;
110	}
111	return NULL;
112	}
113	}
114	return decl;
115	}
116
117	/ Representation of entries in the constexpr function definition table. /
118
119	struct GTY((for_user)) constexpr_fundef {
120	tree decl;
121	tree body;
122	};
123
124	struct constexpr_fundef_hasher : ggc_ptr_hash<constexpr_fundef>
125	{
126	static hashval_t hash (constexpr_fundef *);
127	static bool equal (constexpr_fundef , constexpr_fundef );
128	};
129
130	/ This table holds all constexpr function definitions seen in*
131	the current translation unit. /*
132
133	static GTY (()) hash_table<constexpr_fundef_hasher> *constexpr_fundef_table;
134
135	/ Utility function used for managing the constexpr function table.*
136	Return true if the entries pointed to by P and Q are for the
137	same constexpr function. /*
138
139	inline bool
140	constexpr_fundef_hasher::equal (constexpr_fundef lhs, constexpr_fundef rhs)
141	{
142	return lhs->decl == rhs->decl;
143	}
144
145	/ Utility function used for managing the constexpr function table.*
146	Return a hash value for the entry pointed to by Q. /*
147
148	inline hashval_t
149	constexpr_fundef_hasher::hash (constexpr_fundef *fundef)
150	{
151	return DECL_UID (fundef->decl);
152	}
153
154	/ Return a previously saved definition of function FUN. /
155
156	static constexpr_fundef *
157	retrieve_constexpr_fundef (tree fun)
158	{
159	constexpr_fundef fundef = { NULL, NULL };
160	if (constexpr_fundef_table == NULL)
161	return NULL;
162
163	fundef.decl = fun;
164	return constexpr_fundef_table->find (&fundef);
165	}
166
167	/ Check whether the parameter and return types of FUN are valid for a*
168	constexpr function, and complain if COMPLAIN. /*
169
170	bool
171	is_valid_constexpr_fn (tree fun, bool complain)
172	{
173	bool ret = true;
174
175	if (DECL_INHERITED_CTOR (fun)
176	&& TREE_CODE (fun) == TEMPLATE_DECL)
177	{
178	ret = false;
179	if (complain)
180	error ("inherited constructor %qD is not %<constexpr%>",
181	DECL_INHERITED_CTOR (fun));
182	}
183	else
184	{
185	for (tree parm = FUNCTION_FIRST_USER_PARM (fun);
186	parm != NULL_TREE; parm = TREE_CHAIN (parm))
187	if (!literal_type_p (TREE_TYPE (parm)))
188	{
189	ret = false;
190	if (complain)
191	{
192	error ("invalid type for parameter %d of %<constexpr%> "
193	"function %q+#D", DECL_PARM_INDEX (parm), fun);
194	explain_non_literal_class (TREE_TYPE (parm));
195	}
196	}
197	}
198
199	if (LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun)) && cxx_dialect < cxx17)
200	{
201	ret = false;
202	if (complain)
203	inform (DECL_SOURCE_LOCATION (fun),
204	"lambdas are implicitly %<constexpr%> only in C++17 and later");
205	}
206	else if (!DECL_CONSTRUCTOR_P (fun))
207	{
208	tree rettype = TREE_TYPE (TREE_TYPE (fun));
209	if (!literal_type_p (rettype))
210	{
211	ret = false;
212	if (complain)
213	{
214	error ("invalid return type %qT of %<constexpr%> function %q+D",
215	rettype, fun);
216	explain_non_literal_class (rettype);
217	}
218	}
219
220	/ C++14 DR 1684 removed this restriction. /
221	if (cxx_dialect < cxx14
222	&& DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)
223	&& !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun)))
224	{
225	ret = false;
226	if (complain
227	&& pedwarn (DECL_SOURCE_LOCATION (fun), OPT_Wpedantic,
228	"enclosing class of %<constexpr%> non-static member "
229	"function %q+#D is not a literal type", fun))
230	explain_non_literal_class (DECL_CONTEXT (fun));
231	}
232	}
233	else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun)))
234	{
235	ret = false;
236	if (complain)
237	error ("%q#T has virtual base classes", DECL_CONTEXT (fun));
238	}
239
240	return ret;
241	}
242
243	/ Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF*
244	for a member of an anonymous aggregate, INIT is the initializer for that
245	member, and VEC_OUTER is the vector of constructor elements for the class
246	whose constructor we are processing. Add the initializer to the vector
247	and return true to indicate success. /*
248
249	static bool
250	build_anon_member_initialization (tree member, tree init,
251	vec<constructor_elt, va_gc> **vec_outer)
252	{
253	/ MEMBER presents the relevant fields from the inside out, but we need*
254	to build up the initializer from the outside in so that we can reuse
255	previously built CONSTRUCTORs if this is, say, the second field in an
256	anonymous struct. So we use a vec as a stack. /*
257	auto_vec<tree, `2`> fields;
258	do
259	{
260	fields.safe_push (TREE_OPERAND (member, `1`));
261	member = TREE_OPERAND (member, `0`);
262	}
263	while (ANON_AGGR_TYPE_P (TREE_TYPE (member))
264	&& TREE_CODE (member) == COMPONENT_REF);
265
266	/ VEC has the constructor elements vector for the context of FIELD.*
267	If FIELD is an anonymous aggregate, we will push inside it. /*
268	vec<constructor_elt, va_gc> **vec = vec_outer;
269	tree field;
270	while (field = fields.pop(),
271	ANON_AGGR_TYPE_P (TREE_TYPE (field)))
272	{
273	tree ctor;
274	/ If there is already an outer constructor entry for the anonymous*
275	aggregate FIELD, use it; otherwise, insert one. /*
276	if (vec_safe_is_empty (*vec)
277	\|\| (*vec)->last().index != field)
278	{
279	ctor = build_constructor (TREE_TYPE (field), NULL);
280	CONSTRUCTOR_APPEND_ELT (*vec, field, ctor);
281	}
282	else
283	ctor = (*vec)->last().value;
284	vec = &CONSTRUCTOR_ELTS (ctor);
285	}
286
287	/ Now we're at the innermost field, the one that isn't an anonymous*
288	aggregate. Add its initializer to the CONSTRUCTOR and we're done. /*
289	gcc_assert (fields.is_empty());
290	CONSTRUCTOR_APPEND_ELT (*vec, field, init);
291
292	return true;
293	}
294
295	/ Subroutine of build_constexpr_constructor_member_initializers.*
296	The expression tree T represents a data member initialization
297	in a (constexpr) constructor definition. Build a pairing of
298	the data member with its initializer, and prepend that pair
299	to the existing initialization pair INITS. /*
300
301	static bool
302	build_data_member_initialization (tree t, vec<constructor_elt, va_gc> **vec)
303	{
304	tree member, init;
305	if (TREE_CODE (t) == CLEANUP_POINT_EXPR)
306	t = TREE_OPERAND (t, `0`);
307	if (TREE_CODE (t) == EXPR_STMT)
308	t = TREE_OPERAND (t, `0`);
309	if (t == error_mark_node)
310	return false;
311	if (TREE_CODE (t) == STATEMENT_LIST)
312	{
313	tree_stmt_iterator i;
314	for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
315	{
316	if (! build_data_member_initialization (tsi_stmt (i), vec))
317	return false;
318	}
319	return true;
320	}
321	if (TREE_CODE (t) == CLEANUP_STMT)
322	{
323	/ We can't see a CLEANUP_STMT in a constructor for a literal class,*
324	but we can in a constexpr constructor for a non-literal class. Just
325	ignore it; either all the initialization will be constant, in which
326	case the cleanup can't run, or it can't be constexpr.
327	Still recurse into CLEANUP_BODY. /*
328	return build_data_member_initialization (CLEANUP_BODY (t), vec);
329	}
330	if (TREE_CODE (t) == CONVERT_EXPR)
331	t = TREE_OPERAND (t, `0`);
332	if (TREE_CODE (t) == INIT_EXPR
333	/ vptr initialization shows up as a MODIFY_EXPR. In C++14 we only*
334	use what this function builds for cx_check_missing_mem_inits, and
335	assignment in the ctor body doesn't count. /*
336	\|\| (cxx_dialect < cxx14 && TREE_CODE (t) == MODIFY_EXPR))
337	{
338	member = TREE_OPERAND (t, `0`);
339	init = break_out_target_exprs (TREE_OPERAND (t, `1`));
340	}
341	else if (TREE_CODE (t) == CALL_EXPR)
342	{
343	tree fn = get_callee_fndecl (t);
344	if (!fn \|\| !DECL_CONSTRUCTOR_P (fn))
345	/ We're only interested in calls to subobject constructors. /
346	return true;
347	member = CALL_EXPR_ARG (t, `0`);
348	/ We don't use build_cplus_new here because it complains about*
349	abstract bases. Leaving the call unwrapped means that it has the
350	wrong type, but cxx_eval_constant_expression doesn't care. /*
351	init = break_out_target_exprs (t);
352	}
353	else if (TREE_CODE (t) == BIND_EXPR)
354	return build_data_member_initialization (BIND_EXPR_BODY (t), vec);
355	else
356	/ Don't add anything else to the CONSTRUCTOR. /
357	return true;
358	if (INDIRECT_REF_P (member))
359	member = TREE_OPERAND (member, `0`);
360	if (TREE_CODE (member) == NOP_EXPR)
361	{
362	tree op = member;
363	STRIP_NOPS (op);
364	if (TREE_CODE (op) == ADDR_EXPR)
365	{
366	gcc_assert (same_type_ignoring_top_level_qualifiers_p
367	(TREE_TYPE (TREE_TYPE (op)),
368	TREE_TYPE (TREE_TYPE (member))));
369	/ Initializing a cv-qualified member; we need to look through*
370	the const_cast. /*
371	member = op;
372	}
373	else if (op == current_class_ptr
374	&& (same_type_ignoring_top_level_qualifiers_p
375	(TREE_TYPE (TREE_TYPE (member)),
376	current_class_type)))
377	/ Delegating constructor. /
378	member = op;
379	else
380	{
381	/ This is an initializer for an empty base; keep it for now so*
382	we can check it in cxx_eval_bare_aggregate. /*
383	gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member))));
384	}
385	}
386	if (TREE_CODE (member) == ADDR_EXPR)
387	member = TREE_OPERAND (member, `0`);
388	if (TREE_CODE (member) == COMPONENT_REF)
389	{
390	tree aggr = TREE_OPERAND (member, `0`);
391	if (TREE_CODE (aggr) == VAR_DECL)
392	/ Initializing a local variable, don't add anything. /
393	return true;
394	if (TREE_CODE (aggr) != COMPONENT_REF)
395	/ Normal member initialization. /
396	member = TREE_OPERAND (member, `1`);
397	else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr)))
398	/ Initializing a member of an anonymous union. /
399	return build_anon_member_initialization (member, init, vec);
400	else
401	/ We're initializing a vtable pointer in a base. Leave it as*
402	COMPONENT_REF so we remember the path to get to the vfield. /*
403	gcc_assert (TREE_TYPE (member) == vtbl_ptr_type_node);
404	}
405
406	/ Value-initialization can produce multiple initializers for the*
407	same field; use the last one. /*
408	if (!vec_safe_is_empty (vec) && (vec)->last().index == member)
409	(*vec)->last().value = init;
410	else
411	CONSTRUCTOR_APPEND_ELT (*vec, member, init);
412	return true;
413	}
414
415	/ Subroutine of check_constexpr_ctor_body_1 and constexpr_fn_retval.*
416	In C++11 mode checks that the TYPE_DECLs in the BIND_EXPR_VARS of a
417	BIND_EXPR conform to 7.1.5/3/4 on typedef and alias declarations. /*
418
419	static bool
420	check_constexpr_bind_expr_vars (tree t)
421	{
422	gcc_assert (TREE_CODE (t) == BIND_EXPR);
423
424	for (tree var = BIND_EXPR_VARS (t); var; var = DECL_CHAIN (var))
425	if (TREE_CODE (var) == TYPE_DECL
426	&& DECL_IMPLICIT_TYPEDEF_P (var)
427	&& !LAMBDA_TYPE_P (TREE_TYPE (var)))
428	return false;
429	return true;
430	}
431
432	/ Subroutine of check_constexpr_ctor_body. /
433
434	static bool
435	check_constexpr_ctor_body_1 (tree last, tree list)
436	{
437	switch (TREE_CODE (list))
438	{
439	case DECL_EXPR:
440	if (TREE_CODE (DECL_EXPR_DECL (list)) == USING_DECL
441	\|\| TREE_CODE (DECL_EXPR_DECL (list)) == TYPE_DECL)
442	return true;
443	return false;
444
445	case CLEANUP_POINT_EXPR:
446	return check_constexpr_ctor_body (last, TREE_OPERAND (list, `0`),
447	/complain=/false);
448
449	case BIND_EXPR:
450	if (!check_constexpr_bind_expr_vars (list)
451	\|\| !check_constexpr_ctor_body (last, BIND_EXPR_BODY (list),
452	/complain=/false))
453	return false;
454	return true;
455
456	case USING_STMT:
457	case STATIC_ASSERT:
458	case DEBUG_BEGIN_STMT:
459	return true;
460
461	default:
462	return false;
463	}
464	}
465
466	/ Make sure that there are no statements after LAST in the constructor*
467	body represented by LIST. /*
468
469	bool
470	check_constexpr_ctor_body (tree last, tree list, bool complain)
471	{
472	/ C++14 doesn't require a constexpr ctor to have an empty body. /
473	if (cxx_dialect >= cxx14)
474	return true;
475
476	bool ok = true;
477	if (TREE_CODE (list) == STATEMENT_LIST)
478	{
479	tree_stmt_iterator i = tsi_last (list);
480	for (; !tsi_end_p (i); tsi_prev (&i))
481	{
482	tree t = tsi_stmt (i);
483	if (t == last)
484	break;
485	if (!check_constexpr_ctor_body_1 (last, t))
486	{
487	ok = false;
488	break;
489	}
490	}
491	}
492	else if (list != last
493	&& !check_constexpr_ctor_body_1 (last, list))
494	ok = false;
495	if (!ok)
496	{
497	if (complain)
498	error ("%<constexpr%> constructor does not have empty body");
499	DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false;
500	}
501	return ok;
502	}
503
504	/ V is a vector of constructor elements built up for the base and member*
505	initializers of a constructor for TYPE. They need to be in increasing
506	offset order, which they might not be yet if TYPE has a primary base
507	which is not first in the base-clause or a vptr and at least one base
508	all of which are non-primary. /*
509
510	static vec<constructor_elt, va_gc> *
511	sort_constexpr_mem_initializers (tree type, vec<constructor_elt, va_gc> *v)
512	{
513	tree pri = CLASSTYPE_PRIMARY_BINFO (type);
514	tree field_type;
515	unsigned i;
516	constructor_elt *ce;
517
518	if (pri)
519	field_type = BINFO_TYPE (pri);
520	else if (TYPE_CONTAINS_VPTR_P (type))
521	field_type = vtbl_ptr_type_node;
522	else
523	return v;
524
525	/ Find the element for the primary base or vptr and move it to the*
526	beginning of the vec. /*
527	for (i = `0`; vec_safe_iterate (v, i, &ce); ++i)
528	if (TREE_TYPE (ce->index) == field_type)
529	break;
530
531	if (i > `0` && i < vec_safe_length (v))
532	{
533	vec<constructor_elt, va_gc> &vref = *v;
534	constructor_elt elt = vref [i];
535	for (; i > `0`; --i)
536	vref [i] = vref [i-`1`];
537	vref [`0`] = elt;
538	}
539
540	return v;
541	}
542
543	/ Build compile-time evalable representations of member-initializer list*
544	for a constexpr constructor. /*
545
546	static tree
547	build_constexpr_constructor_member_initializers (tree type, tree body)
548	{
549	vec<constructor_elt, va_gc> *vec = NULL;
550	bool ok = true;
551	while (true)
552	switch (TREE_CODE (body))
553	{
554	case MUST_NOT_THROW_EXPR:
555	case EH_SPEC_BLOCK:
556	body = TREE_OPERAND (body, `0`);
557	break;
558
559	case STATEMENT_LIST:
560	for (tree_stmt_iterator i = tsi_start (body);
561	!tsi_end_p (i); tsi_next (&i))
562	{
563	body = tsi_stmt (i);
564	if (TREE_CODE (body) == BIND_EXPR)
565	break;
566	}
567	break;
568
569	case BIND_EXPR:
570	body = BIND_EXPR_BODY (body);
571	goto found;
572
573	default:
574	gcc_unreachable ();
575	}
576	found:
577	if (TREE_CODE (body) == CLEANUP_POINT_EXPR)
578	{
579	body = TREE_OPERAND (body, `0`);
580	if (TREE_CODE (body) == EXPR_STMT)
581	body = TREE_OPERAND (body, `0`);
582	if (TREE_CODE (body) == INIT_EXPR
583	&& (same_type_ignoring_top_level_qualifiers_p
584	(TREE_TYPE (TREE_OPERAND (body, `0`)),
585	current_class_type)))
586	{
587	/ Trivial copy. /
588	return TREE_OPERAND (body, `1`);
589	}
590	ok = build_data_member_initialization (body, &vec);
591	}
592	else if (TREE_CODE (body) == STATEMENT_LIST)
593	{
594	tree_stmt_iterator i;
595	for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
596	{
597	ok = build_data_member_initialization (tsi_stmt (i), &vec);
598	if (!ok)
599	break;
600	}
601	}
602	else if (TREE_CODE (body) == TRY_BLOCK)
603	{
604	error ("body of %<constexpr%> constructor cannot be "
605	"a function-try-block");
606	return error_mark_node;
607	}
608	else if (EXPR_P (body))
609	ok = build_data_member_initialization (body, &vec);
610	else
611	gcc_assert (errorcount > `0`);
612	if (ok)
613	{
614	if (vec_safe_length (vec) > `0`)
615	{
616	/ In a delegating constructor, return the target. /
617	constructor_elt ce = &(vec)[`0`];
618	if (ce->index == current_class_ptr)
619	{
620	body = ce->value;
621	vec_free (vec);
622	return body;
623	}
624	}
625	vec = sort_constexpr_mem_initializers (type, vec);
626	return build_constructor (type, vec);
627	}
628	else
629	return error_mark_node;
630	}
631
632	/ We have an expression tree T that represents a call, either CALL_EXPR*
633	or AGGR_INIT_EXPR. If the call is lexically to a named function,
634	retrun the _DECL for that function. /*
635
636	static tree
637	get_function_named_in_call (tree t)
638	{
639	tree fun = cp_get_callee (t);
640	if (fun && TREE_CODE (fun) == ADDR_EXPR
641	&& TREE_CODE (TREE_OPERAND (fun, `0`)) == FUNCTION_DECL)
642	fun = TREE_OPERAND (fun, `0`);
643	return fun;
644	}
645
646	/ Subroutine of register_constexpr_fundef. BODY is the body of a function*
647	declared to be constexpr, or a sub-statement thereof. Returns the
648	return value if suitable, error_mark_node for a statement not allowed in
649	a constexpr function, or NULL_TREE if no return value was found. /*
650
651	static tree
652	constexpr_fn_retval (tree body)
653	{
654	switch (TREE_CODE (body))
655	{
656	case STATEMENT_LIST:
657	{
658	tree_stmt_iterator i;
659	tree expr = NULL_TREE;
660	for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
661	{
662	tree s = constexpr_fn_retval (tsi_stmt (i));
663	if (s == error_mark_node)
664	return error_mark_node;
665	else if (s == NULL_TREE)
666	/ Keep iterating. /;
667	else if (expr)
668	/ Multiple return statements. /
669	return error_mark_node;
670	else
671	expr = s;
672	}
673	return expr;
674	}
675
676	case RETURN_EXPR:
677	return break_out_target_exprs (TREE_OPERAND (body, `0`));
678
679	case DECL_EXPR:
680	{
681	tree decl = DECL_EXPR_DECL (body);
682	if (TREE_CODE (decl) == USING_DECL
683	/ Accept __func__, __FUNCTION__, and __PRETTY_FUNCTION__. /
684	\|\| DECL_ARTIFICIAL (decl))
685	return NULL_TREE;
686	return error_mark_node;
687	}
688
689	case CLEANUP_POINT_EXPR:
690	return constexpr_fn_retval (TREE_OPERAND (body, `0`));
691
692	case BIND_EXPR:
693	if (!check_constexpr_bind_expr_vars (body))
694	return error_mark_node;
695	return constexpr_fn_retval (BIND_EXPR_BODY (body));
696
697	case USING_STMT:
698	case DEBUG_BEGIN_STMT:
699	return NULL_TREE;
700
701	case CALL_EXPR:
702	{
703	tree fun = get_function_named_in_call (body);
704	if (fun != NULL_TREE
705	&& DECL_FUNCTION_CODE (fun) == BUILT_IN_UNREACHABLE)
706	return NULL_TREE;
707	}
708	/ Fallthru. /
709
710	default:
711	return error_mark_node;
712	}
713	}
714
715	/ Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of*
716	FUN; do the necessary transformations to turn it into a single expression
717	that we can store in the hash table. /*
718
719	static tree
720	massage_constexpr_body (tree fun, tree body)
721	{
722	if (DECL_CONSTRUCTOR_P (fun))
723	body = build_constexpr_constructor_member_initializers
724	(DECL_CONTEXT (fun), body);
725	else if (cxx_dialect < cxx14)
726	{
727	if (TREE_CODE (body) == EH_SPEC_BLOCK)
728	body = EH_SPEC_STMTS (body);
729	if (TREE_CODE (body) == MUST_NOT_THROW_EXPR)
730	body = TREE_OPERAND (body, `0`);
731	body = constexpr_fn_retval (body);
732	}
733	return body;
734	}
735
736	/ CTYPE is a type constructed from BODY. Return true if some*
737	bases/fields are uninitialized, and complain if COMPLAIN. /*
738
739	static bool
740	cx_check_missing_mem_inits (tree ctype, tree body, bool complain)
741	{
742	unsigned nelts = `0`;
743
744	if (body)
745	{
746	if (TREE_CODE (body) != CONSTRUCTOR)
747	return false;
748	nelts = CONSTRUCTOR_NELTS (body);
749	}
750	tree field = TYPE_FIELDS (ctype);
751
752	if (TREE_CODE (ctype) == UNION_TYPE)
753	{
754	if (nelts == `0` && next_initializable_field (field))
755	{
756	if (complain)
757	error ("%<constexpr%> constructor for union %qT must "
758	"initialize exactly one non-static data member", ctype);
759	return true;
760	}
761	return false;
762	}
763
764	/ Iterate over the CONSTRUCTOR, checking any missing fields don't*
765	need an explicit initialization. /*
766	bool bad = false;
767	for (unsigned i = `0`; i <= nelts; ++i)
768	{
769	tree index = NULL_TREE;
770	if (i < nelts)
771	{
772	index = CONSTRUCTOR_ELT (body, i)->index;
773	/ Skip base and vtable inits. /
774	if (TREE_CODE (index) != FIELD_DECL
775	\|\| DECL_ARTIFICIAL (index))
776	continue;
777	}
778
779	for (; field != index; field = DECL_CHAIN (field))
780	{
781	tree ftype;
782	if (TREE_CODE (field) != FIELD_DECL)
783	continue;
784	if (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
785	continue;
786	if (DECL_ARTIFICIAL (field))
787	continue;
788	if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
789	{
790	/ Recurse to check the anonummous aggregate member. /
791	bad \|= cx_check_missing_mem_inits
792	(TREE_TYPE (field), NULL_TREE, complain);
793	if (bad && !complain)
794	return true;
795	continue;
796	}
797	ftype = strip_array_types (TREE_TYPE (field));
798	if (type_has_constexpr_default_constructor (ftype))
799	{
800	/ It's OK to skip a member with a trivial constexpr ctor.*
801	A constexpr ctor that isn't trivial should have been
802	added in by now. /*
803	gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype)
804	\|\| errorcount != `0`);
805	continue;
806	}
807	if (!complain)
808	return true;
809	error ("member %qD must be initialized by mem-initializer "
810	"in %<constexpr%> constructor", field);
811	inform (DECL_SOURCE_LOCATION (field), "declared here");
812	bad = true;
813	}
814	if (field == NULL_TREE)
815	break;
816
817	if (ANON_AGGR_TYPE_P (TREE_TYPE (index)))
818	{
819	/ Check the anonymous aggregate initializer is valid. /
820	bad \|= cx_check_missing_mem_inits
821	(TREE_TYPE (index), CONSTRUCTOR_ELT (body, i)->value, complain);
822	if (bad && !complain)
823	return true;
824	}
825	field = DECL_CHAIN (field);
826	}
827
828	return bad;
829	}
830
831	/ We are processing the definition of the constexpr function FUN.*
832	Check that its BODY fulfills the propriate requirements and
833	enter it in the constexpr function definition table.
834	For constructor BODY is actually the TREE_LIST of the
835	member-initializer list. /*
836
837	tree
838	register_constexpr_fundef (tree fun, tree body)
839	{
840	constexpr_fundef entry;
841	constexpr_fundef **slot;
842
843	if (!is_valid_constexpr_fn (fun, !DECL_GENERATED_P (fun)))
844	return NULL;
845
846	tree massaged = massage_constexpr_body (fun, body);
847	if (massaged == NULL_TREE \|\| massaged == error_mark_node)
848	{
849	if (!DECL_CONSTRUCTOR_P (fun))
850	error ("body of %<constexpr%> function %qD not a return-statement",
851	fun);
852	return NULL;
853	}
854
855	if (!potential_rvalue_constant_expression (massaged))
856	{
857	if (!DECL_GENERATED_P (fun))
858	require_potential_rvalue_constant_expression (massaged);
859	return NULL;
860	}
861
862	if (DECL_CONSTRUCTOR_P (fun)
863	&& cx_check_missing_mem_inits (DECL_CONTEXT (fun),
864	massaged, !DECL_GENERATED_P (fun)))
865	return NULL;
866
867	/ Create the constexpr function table if necessary. /
868	if (constexpr_fundef_table == NULL)
869	constexpr_fundef_table
870	= hash_table<constexpr_fundef_hasher>::create_ggc (`101`);
871
872	entry.decl = fun;
873	entry.body = body;
874	slot = constexpr_fundef_table->find_slot (&entry, INSERT);
875
876	gcc_assert (*slot == NULL);
877	*slot = ggc_alloc<constexpr_fundef> ();
878	**slot = entry;
879
880	return fun;
881	}
882
883	/ FUN is a non-constexpr function called in a context that requires a*
884	constant expression. If it comes from a constexpr template, explain why
885	the instantiation isn't constexpr. /*
886
887	void
888	explain_invalid_constexpr_fn (tree fun)
889	{
890	static hash_set<tree> *diagnosed;
891	tree body;
892	location_t save_loc;
893	/ Only diagnose defaulted functions, lambdas, or instantiations. /
894	if (!DECL_DEFAULTED_FN (fun)
895	&& !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun))
896	&& !is_instantiation_of_constexpr (fun))
897	return;
898	if (diagnosed == NULL)
899	diagnosed = new hash_set<tree>;
900	if (diagnosed->add (fun))
901	/ Already explained. /
902	return;
903
904	save_loc = input_location;
905	if (!lambda_static_thunk_p (fun))
906	{
907	/ Diagnostics should completely ignore the static thunk, so leave*
908	input_location set to our caller's location. /*
909	input_location = DECL_SOURCE_LOCATION (fun);
910	inform (input_location,
911	"%qD is not usable as a %<constexpr%> function because:", fun);
912	}
913	/ First check the declaration. /
914	if (is_valid_constexpr_fn (fun, true))
915	{
916	/ Then if it's OK, the body. /
917	if (!DECL_DECLARED_CONSTEXPR_P (fun)
918	&& !LAMBDA_TYPE_P (CP_DECL_CONTEXT (fun)))
919	explain_implicit_non_constexpr (fun);
920	else
921	{
922	body = massage_constexpr_body (fun, DECL_SAVED_TREE (fun));
923	require_potential_rvalue_constant_expression (body);
924	if (DECL_CONSTRUCTOR_P (fun))
925	cx_check_missing_mem_inits (DECL_CONTEXT (fun), body, true);
926	}
927	}
928	input_location = save_loc;
929	}
930
931	/ Objects of this type represent calls to constexpr functions*
932	along with the bindings of parameters to their arguments, for
933	the purpose of compile time evaluation. /*
934
935	struct GTY((for_user)) constexpr_call {
936	/ Description of the constexpr function definition. /
937	constexpr_fundef *fundef;
938	/ Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE*
939	is a parameter _DECL and the TREE_VALUE is the value of the parameter.
940	Note: This arrangement is made to accommodate the use of
941	iterative_hash_template_arg (see pt.c). If you change this
942	representation, also change the hash calculation in
943	cxx_eval_call_expression. /*
944	tree bindings;
945	/ Result of the call.*
946	NULL means the call is being evaluated.
947	error_mark_node means that the evaluation was erroneous;
948	otherwise, the actuall value of the call. /*
949	tree result;
950	/ The hash of this call; we remember it here to avoid having to*
951	recalculate it when expanding the hash table. /*
952	hashval_t hash;
953	};
954
955	struct constexpr_call_hasher : ggc_ptr_hash<constexpr_call>
956	{
957	static hashval_t hash (constexpr_call *);
958	static bool equal (constexpr_call , constexpr_call );
959	};
960
961	enum constexpr_switch_state {
962	/ Used when processing a switch for the first time by cxx_eval_switch_expr*
963	and default: label for that switch has not been seen yet. /*
964	css_default_not_seen,
965	/ Used when processing a switch for the first time by cxx_eval_switch_expr*
966	and default: label for that switch has been seen already. /*
967	css_default_seen,
968	/ Used when processing a switch for the second time by*
969	cxx_eval_switch_expr, where default: label should match. /*
970	css_default_processing
971	};
972
973	/ The constexpr expansion context. CALL is the current function*
974	expansion, CTOR is the current aggregate initializer, OBJECT is the
975	object being initialized by CTOR, either a VAR_DECL or a _REF. VALUES
976	is a map of values of variables initialized within the expression. /*
977
978	struct constexpr_ctx {
979	/ The innermost call we're evaluating. /
980	constexpr_call *call;
981	/ Values for any temporaries or local variables within the*
982	constant-expression. /*
983	hash_map<tree,tree> *values;
984	/ SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we*
985	aren't inside a loop. /*
986	hash_set<tree> *save_exprs;
987	/ The CONSTRUCTOR we're currently building up for an aggregate*
988	initializer. /*
989	tree ctor;
990	/ The object we're building the CONSTRUCTOR for. /
991	tree object;
992	/ If inside SWITCH_EXPR. /
993	constexpr_switch_state *css_state;
994	/ Whether we should error on a non-constant expression or fail quietly. /
995	bool quiet;
996	/ Whether we are strictly conforming to constant expression rules or*
997	trying harder to get a constant value. /*
998	bool strict;
999	};
1000
1001	/ A table of all constexpr calls that have been evaluated by the*
1002	compiler in this translation unit. /*
1003
1004	static GTY (()) hash_table<constexpr_call_hasher> *constexpr_call_table;
1005
1006	static tree cxx_eval_constant_expression (const constexpr_ctx *, tree,
1007	bool, bool , bool* , tree = NULL);
1008
1009	/ Compute a hash value for a constexpr call representation. /
1010
1011	inline hashval_t
1012	constexpr_call_hasher::hash (constexpr_call *info)
1013	{
1014	return info->hash;
1015	}
1016
1017	/ Return true if the objects pointed to by P and Q represent calls*
1018	to the same constexpr function with the same arguments.
1019	Otherwise, return false. /*
1020
1021	bool
1022	constexpr_call_hasher::equal (constexpr_call lhs, constexpr_call rhs)
1023	{
1024	tree lhs_bindings;
1025	tree rhs_bindings;
1026	if (lhs == rhs)
1027	return `1`;
1028	if (!constexpr_fundef_hasher::equal (lhs->fundef, rhs->fundef))
1029	return `0`;
1030	lhs_bindings = lhs->bindings;
1031	rhs_bindings = rhs->bindings;
1032	while (lhs_bindings != NULL && rhs_bindings != NULL)
1033	{
1034	tree lhs_arg = TREE_VALUE (lhs_bindings);
1035	tree rhs_arg = TREE_VALUE (rhs_bindings);
1036	gcc_assert (TREE_TYPE (lhs_arg) == TREE_TYPE (rhs_arg));
1037	if (!cp_tree_equal (lhs_arg, rhs_arg))
1038	return `0`;
1039	lhs_bindings = TREE_CHAIN (lhs_bindings);
1040	rhs_bindings = TREE_CHAIN (rhs_bindings);
1041	}
1042	return lhs_bindings == rhs_bindings;
1043	}
1044
1045	/ Initialize the constexpr call table, if needed. /
1046
1047	static void
1048	maybe_initialize_constexpr_call_table (void)
1049	{
1050	if (constexpr_call_table == NULL)
1051	constexpr_call_table = hash_table<constexpr_call_hasher>::create_ggc (`101`);
1052	}
1053
1054	/ During constexpr CALL_EXPR evaluation, to avoid issues with sharing when*
1055	a function happens to get called recursively, we unshare the callee
1056	function's body and evaluate this unshared copy instead of evaluating the
1057	original body.
1058
1059	FUNDEF_COPIES_TABLE is a per-function freelist of these unshared function
1060	copies. The underlying data structure of FUNDEF_COPIES_TABLE is a hash_map
1061	that's keyed off of the original FUNCTION_DECL and whose value is a
1062	TREE_LIST of this function's unused copies awaiting reuse.
1063
1064	This is not GC-deletable to avoid GC affecting UID generation. /*
1065
1066	static GTY(()) hash_map<tree, tree> *fundef_copies_table;
1067
1068	/ Initialize FUNDEF_COPIES_TABLE if it's not initialized. /
1069
1070	static void
1071	maybe_initialize_fundef_copies_table ()
1072	{
1073	if (fundef_copies_table == NULL)
1074	fundef_copies_table = hash_map<tree,tree>::create_ggc (`101`);
1075	}
1076
1077	/ Reuse a copy or create a new unshared copy of the function FUN.*
1078	Return this copy. We use a TREE_LIST whose PURPOSE is body, VALUE
1079	is parms, TYPE is result. /*
1080
1081	static tree
1082	get_fundef_copy (tree fun)
1083	{
1084	maybe_initialize_fundef_copies_table ();
1085
1086	tree copy;
1087	bool existed;
1088	tree *slot = &fundef_copies_table->get_or_insert (fun, &existed);
1089
1090	if (!existed)
1091	{
1092	/ There is no cached function available, or in use. We can use*
1093	the function directly. That the slot is now created records
1094	that this function is now in use. /*
1095	copy = build_tree_list (DECL_SAVED_TREE (fun), DECL_ARGUMENTS (fun));
1096	TREE_TYPE (copy) = DECL_RESULT (fun);
1097	}
1098	else if (*slot == NULL_TREE)
1099	{
1100	/ We've already used the function itself, so make a copy. /
1101	copy = build_tree_list (NULL, NULL);
1102	TREE_PURPOSE (copy) = copy_fn (fun, TREE_VALUE (copy), TREE_TYPE (copy));
1103	}
1104	else
1105	{
1106	/ We have a cached function available. /
1107	copy = *slot;
1108	*slot = TREE_CHAIN (copy);
1109	}
1110
1111	return copy;
1112	}
1113
1114	/ Save the copy COPY of function FUN for later reuse by*
1115	get_fundef_copy(). By construction, there will always be an entry
1116	to find. /*
1117
1118	static void
1119	save_fundef_copy (tree fun, tree copy)
1120	{
1121	tree *slot = fundef_copies_table->get (fun);
1122	TREE_CHAIN (copy) = *slot;
1123	*slot = copy;
1124	}
1125
1126	/ We have an expression tree T that represents a call, either CALL_EXPR*
1127	or AGGR_INIT_EXPR. Return the Nth argument. /*
1128
1129	static inline tree
1130	get_nth_callarg (tree t, int n)
1131	{
1132	switch (TREE_CODE (t))
1133	{
1134	case CALL_EXPR:
1135	return CALL_EXPR_ARG (t, n);
1136
1137	case AGGR_INIT_EXPR:
1138	return AGGR_INIT_EXPR_ARG (t, n);
1139
1140	default:
1141	gcc_unreachable ();
1142	return NULL;
1143	}
1144	}
1145
1146	/ Attempt to evaluate T which represents a call to a builtin function.*
1147	We assume here that all builtin functions evaluate to scalar types
1148	represented by _CST nodes. /*
1149
1150	static tree
1151	cxx_eval_builtin_function_call (const constexpr_ctx *ctx, tree t, tree fun,
1152	bool lval,
1153	bool non_constant_p, bool* *overflow_p)
1154	{
1155	const int nargs = call_expr_nargs (t);
1156	tree args = (tree ) alloca (nargs * sizeof (tree));
1157	tree new_call;
1158	int i;
1159
1160	/ Don't fold __builtin_constant_p within a constexpr function. /
1161	bool bi_const_p = (DECL_FUNCTION_CODE (fun) == BUILT_IN_CONSTANT_P);
1162
1163	if (bi_const_p
1164	&& current_function_decl
1165	&& DECL_DECLARED_CONSTEXPR_P (current_function_decl))
1166	{
1167	non_constant_p = true*;
1168	return t;
1169	}
1170
1171	/ Be permissive for arguments to built-ins; __builtin_constant_p should*
1172	return constant false for a non-constant argument. /*
1173	constexpr_ctx new_ctx = *ctx;
1174	new_ctx.quiet = true;
1175	bool dummy1 = false, dummy2 = false;
1176	for (i = `0`; i < nargs; ++i)
1177	{
1178	args[i] = cxx_eval_constant_expression (&new_ctx, CALL_EXPR_ARG (t, i),
1179	false, &dummy1, &dummy2);
1180	if (bi_const_p)
1181	/ For __built_in_constant_p, fold all expressions with constant values*
1182	even if they aren't C++ constant-expressions. /*
1183	args[i] = cp_fully_fold (args[i]);
1184	}
1185
1186	bool save_ffbcp = force_folding_builtin_constant_p;
1187	force_folding_builtin_constant_p = true;
1188	new_call = fold_builtin_call_array (EXPR_LOCATION (t), TREE_TYPE (t),
1189	CALL_EXPR_FN (t), nargs, args);
1190	force_folding_builtin_constant_p = save_ffbcp;
1191	if (new_call == NULL)
1192	{
1193	if (!*non_constant_p && !ctx->quiet)
1194	{
1195	/ Do not allow__builtin_unreachable in constexpr function.*
1196	The __builtin_unreachable call with BUILTINS_LOCATION
1197	comes from cp_maybe_instrument_return. /*
1198	if (DECL_FUNCTION_CODE (fun) == BUILT_IN_UNREACHABLE
1199	&& EXPR_LOCATION (t) == BUILTINS_LOCATION)
1200	error ("%<constexpr%> call flows off the end of the function");
1201	else
1202	{
1203	new_call = build_call_array_loc (EXPR_LOCATION (t), TREE_TYPE (t),
1204	CALL_EXPR_FN (t), nargs, args);
1205	error ("%q+E is not a constant expression", new_call);
1206	}
1207	}
1208	non_constant_p = true*;
1209	return t;
1210	}
1211
1212	if (!is_constant_expression (new_call))
1213	{
1214	if (!*non_constant_p && !ctx->quiet)
1215	error ("%q+E is not a constant expression", new_call);
1216	non_constant_p = true*;
1217	return t;
1218	}
1219
1220	return cxx_eval_constant_expression (&new_ctx, new_call, lval,
1221	non_constant_p, overflow_p);
1222	}
1223
1224	/ TEMP is the constant value of a temporary object of type TYPE. Adjust*
1225	the type of the value to match. /*
1226
1227	static tree
1228	adjust_temp_type (tree type, tree temp)
1229	{
1230	if (TREE_TYPE (temp) == type)
1231	return temp;
1232	/ Avoid wrapping an aggregate value in a NOP_EXPR. /
1233	if (TREE_CODE (temp) == CONSTRUCTOR)
1234	return build_constructor (type, CONSTRUCTOR_ELTS (temp));
1235	gcc_assert (scalarish_type_p (type));
1236	return cp_fold_convert (type, temp);
1237	}
1238
1239	/ Callback for walk_tree used by unshare_constructor. /
1240
1241	static tree
1242	find_constructor (tree tp, int* walk_subtrees, void* *)
1243	{
1244	if (TYPE_P (*tp))
1245	*walk_subtrees = `0`;
1246	if (TREE_CODE (*tp) == CONSTRUCTOR)
1247	return *tp;
1248	return NULL_TREE;
1249	}
1250
1251	/ If T is a CONSTRUCTOR or an expression that has a CONSTRUCTOR node as a*
1252	subexpression, return an unshared copy of T. Otherwise return T. /*
1253
1254	static tree
1255	unshare_constructor (tree t)
1256	{
1257	tree ctor = walk_tree (&t, find_constructor, NULL, NULL);
1258	if (ctor != NULL_TREE)
1259	return unshare_expr (t);
1260	return t;
1261	}
1262
1263	/ Subroutine of cxx_eval_call_expression.*
1264	We are processing a call expression (either CALL_EXPR or
1265	AGGR_INIT_EXPR) in the context of CTX. Evaluate
1266	all arguments and bind their values to correspondings
1267	parameters, making up the NEW_CALL context. /*
1268
1269	static void
1270	cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t,
1271	constexpr_call *new_call,
1272	bool non_constant_p, bool* *overflow_p,
1273	bool *non_constant_args)
1274	{
1275	const int nargs = call_expr_nargs (t);
1276	tree fun = new_call->fundef->decl;
1277	tree parms = DECL_ARGUMENTS (fun);
1278	int i;
1279	tree *p = &new_call->bindings;
1280	for (i = `0`; i < nargs; ++i)
1281	{
1282	tree x, arg;
1283	tree type = parms ? TREE_TYPE (parms) : void_type_node;
1284	x = get_nth_callarg (t, i);
1285	/ For member function, the first argument is a pointer to the implied*
1286	object. For a constructor, it might still be a dummy object, in
1287	which case we get the real argument from ctx. /*
1288	if (i == `0` && DECL_CONSTRUCTOR_P (fun)
1289	&& is_dummy_object (x))
1290	{
1291	x = ctx->object;
1292	x = build_address (x);
1293	}
1294	bool lval = false;
1295	arg = cxx_eval_constant_expression (ctx, x, lval,
1296	non_constant_p, overflow_p);
1297	/ Don't VERIFY_CONSTANT here. /
1298	if (*non_constant_p && ctx->quiet)
1299	return;
1300	/ Just discard ellipsis args after checking their constantitude. /
1301	if (!parms)
1302	continue;
1303
1304	if (!*non_constant_p)
1305	{
1306	/ Make sure the binding has the same type as the parm. But*
1307	only for constant args. /*
1308	if (TREE_CODE (type) != REFERENCE_TYPE)
1309	arg = adjust_temp_type (type, arg);
1310	if (!TREE_CONSTANT (arg))
1311	non_constant_args = true*;
1312	*p = build_tree_list (parms, arg);
1313	p = &TREE_CHAIN (*p);
1314	}
1315	parms = TREE_CHAIN (parms);
1316	}
1317	}
1318
1319	/ Variables and functions to manage constexpr call expansion context.*
1320	These do not need to be marked for PCH or GC. /*
1321
1322	/ FIXME remember and print actual constant arguments. /
1323	static vec<tree> call_stack;
1324	static int call_stack_tick;
1325	static int last_cx_error_tick;
1326
1327	static bool
1328	push_cx_call_context (tree call)
1329	{
1330	++call_stack_tick;
1331	if (!EXPR_HAS_LOCATION (call))
1332	SET_EXPR_LOCATION (call, input_location);
1333	call_stack.safe_push (call);
1334	if (call_stack.length () > (unsigned) max_constexpr_depth)
1335	return false;
1336	return true;
1337	}
1338
1339	static void
1340	pop_cx_call_context (void)
1341	{
1342	++call_stack_tick;
1343	call_stack.pop ();
1344	}
1345
1346	vec<tree>
1347	cx_error_context (void)
1348	{
1349	vec<tree> r = vNULL;
1350	if (call_stack_tick != last_cx_error_tick
1351	&& !call_stack.is_empty ())
1352	r = call_stack;
1353	last_cx_error_tick = call_stack_tick;
1354	return r;
1355	}
1356
1357	/ Evaluate a call T to a GCC internal function when possible and return*
1358	the evaluated result or, under the control of CTX, give an error, set
1359	NON_CONSTANT_P, and return the unevaluated call T otherwise. /*
1360
1361	static tree
1362	cxx_eval_internal_function (const constexpr_ctx *ctx, tree t,
1363	bool lval,
1364	bool non_constant_p, bool* *overflow_p)
1365	{
1366	enum tree_code opcode = ERROR_MARK;
1367
1368	switch (CALL_EXPR_IFN (t))
1369	{
1370	case IFN_UBSAN_NULL:
1371	case IFN_UBSAN_BOUNDS:
1372	case IFN_UBSAN_VPTR:
1373	case IFN_FALLTHROUGH:
1374	return void_node;
1375
1376	case IFN_ADD_OVERFLOW:
1377	opcode = PLUS_EXPR;
1378	break;
1379	case IFN_SUB_OVERFLOW:
1380	opcode = MINUS_EXPR;
1381	break;
1382	case IFN_MUL_OVERFLOW:
1383	opcode = MULT_EXPR;
1384	break;
1385
1386	case IFN_LAUNDER:
1387	return cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, `0`),
1388	false, non_constant_p, overflow_p);
1389
1390	default:
1391	if (!ctx->quiet)
1392	error_at (EXPR_LOC_OR_LOC (t, input_location),
1393	"call to internal function %qE", t);
1394	non_constant_p = true*;
1395	return t;
1396	}
1397
1398	/ Evaluate constant arguments using OPCODE and return a complex*
1399	number containing the result and the overflow bit. /*
1400	tree arg0 = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, `0`), lval,
1401	non_constant_p, overflow_p);
1402	tree arg1 = cxx_eval_constant_expression (ctx, CALL_EXPR_ARG (t, `1`), lval,
1403	non_constant_p, overflow_p);
1404
1405	if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1406	{
1407	location_t loc = EXPR_LOC_OR_LOC (t, input_location);
1408	tree type = TREE_TYPE (TREE_TYPE (t));
1409	tree result = fold_binary_loc (loc, opcode, type,
1410	fold_convert_loc (loc, type, arg0),
1411	fold_convert_loc (loc, type, arg1));
1412	tree ovf
1413	= build_int_cst (type, arith_overflowed_p (opcode, type, arg0, arg1));
1414	/ Reset TREE_OVERFLOW to avoid warnings for the overflow. /
1415	if (TREE_OVERFLOW (result))
1416	TREE_OVERFLOW (result) = `0`;
1417
1418	return build_complex (TREE_TYPE (t), result, ovf);
1419	}
1420
1421	non_constant_p = true*;
1422	return t;
1423	}
1424
1425	/ Clean CONSTRUCTOR_NO_IMPLICIT_ZERO from CTOR and its sub-aggregates. /
1426
1427	static void
1428	clear_no_implicit_zero (tree ctor)
1429	{
1430	if (CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor))
1431	{
1432	CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor) = false;
1433	tree elt; unsigned HOST_WIDE_INT idx;
1434	FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), idx, elt)
1435	if (TREE_CODE (elt) == CONSTRUCTOR)
1436	clear_no_implicit_zero (elt);
1437	}
1438	}
1439
1440	/ Subroutine of cxx_eval_constant_expression.*
1441	Evaluate the call expression tree T in the context of OLD_CALL expression
1442	evaluation. /*
1443
1444	static tree
1445	cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
1446	bool lval,
1447	bool non_constant_p, bool* *overflow_p)
1448	{
1449	location_t loc = EXPR_LOC_OR_LOC (t, input_location);
1450	tree fun = get_function_named_in_call (t);
1451	constexpr_call new_call = { NULL, NULL, NULL, `0` };
1452	bool depth_ok;
1453
1454	if (fun == NULL_TREE)
1455	return cxx_eval_internal_function (ctx, t, lval,
1456	non_constant_p, overflow_p);
1457
1458	if (TREE_CODE (fun) != FUNCTION_DECL)
1459	{
1460	/ Might be a constexpr function pointer. /
1461	fun = cxx_eval_constant_expression (ctx, fun,
1462	/lval/false, non_constant_p,
1463	overflow_p);
1464	STRIP_NOPS (fun);
1465	if (TREE_CODE (fun) == ADDR_EXPR)
1466	fun = TREE_OPERAND (fun, `0`);
1467	}
1468	if (TREE_CODE (fun) != FUNCTION_DECL)
1469	{
1470	if (!ctx->quiet && !*non_constant_p)
1471	error_at (loc, "expression %qE does not designate a %<constexpr%> "
1472	"function", fun);
1473	non_constant_p = true*;
1474	return t;
1475	}
1476	if (DECL_CLONED_FUNCTION_P (fun))
1477	fun = DECL_CLONED_FUNCTION (fun);
1478
1479	if (is_ubsan_builtin_p (fun))
1480	return void_node;
1481
1482	if (is_builtin_fn (fun))
1483	return cxx_eval_builtin_function_call (ctx, t, fun,
1484	lval, non_constant_p, overflow_p);
1485	if (!DECL_DECLARED_CONSTEXPR_P (fun))
1486	{
1487	if (!ctx->quiet)
1488	{
1489	if (!lambda_static_thunk_p (fun))
1490	error_at (loc, "call to non-%<constexpr%> function %qD", fun);
1491	explain_invalid_constexpr_fn (fun);
1492	}
1493	non_constant_p = true*;
1494	return t;
1495	}
1496
1497	constexpr_ctx new_ctx = *ctx;
1498	if (DECL_CONSTRUCTOR_P (fun) && !ctx->object
1499	&& TREE_CODE (t) == AGGR_INIT_EXPR)
1500	{
1501	/ We want to have an initialization target for an AGGR_INIT_EXPR.*
1502	If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. /*
1503	new_ctx.object = AGGR_INIT_EXPR_SLOT (t);
1504	tree ctor = new_ctx.ctor = build_constructor (DECL_CONTEXT (fun), NULL);
1505	CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor) = true;
1506	ctx->values->put (new_ctx.object, ctor);
1507	ctx = &new_ctx;
1508	}
1509
1510	/ Shortcut trivial constructor/op=. /
1511	if (trivial_fn_p (fun))
1512	{
1513	tree init = NULL_TREE;
1514	if (call_expr_nargs (t) == `2`)
1515	init = convert_from_reference (get_nth_callarg (t, `1`));
1516	else if (TREE_CODE (t) == AGGR_INIT_EXPR
1517	&& AGGR_INIT_ZERO_FIRST (t))
1518	init = build_zero_init (DECL_CONTEXT (fun), NULL_TREE, false);
1519	if (init)
1520	{
1521	tree op = get_nth_callarg (t, `0`);
1522	if (is_dummy_object (op))
1523	op = ctx->object;
1524	else
1525	op = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (op)), op);
1526	tree set = build2 (MODIFY_EXPR, TREE_TYPE (op), op, init);
1527	new_ctx.call = &new_call;
1528	return cxx_eval_constant_expression (&new_ctx, set, lval,
1529	non_constant_p, overflow_p);
1530	}
1531	}
1532
1533	/ We can't defer instantiating the function any longer. /
1534	if (!DECL_INITIAL (fun)
1535	&& DECL_TEMPLOID_INSTANTIATION (fun))
1536	{
1537	location_t save_loc = input_location;
1538	input_location = loc;
1539	++function_depth;
1540	instantiate_decl (fun, /defer_ok/false, /expl_inst/false);
1541	--function_depth;
1542	input_location = save_loc;
1543	}
1544
1545	/ If in direct recursive call, optimize definition search. /
1546	if (ctx && ctx->call && ctx->call->fundef && ctx->call->fundef->decl == fun)
1547	new_call.fundef = ctx->call->fundef;
1548	else
1549	{
1550	new_call.fundef = retrieve_constexpr_fundef (fun);
1551	if (new_call.fundef == NULL \|\| new_call.fundef->body == NULL
1552	\|\| fun == current_function_decl)
1553	{
1554	if (!ctx->quiet)
1555	{
1556	/ We need to check for current_function_decl here in case we're*
1557	being called during cp_fold_function, because at that point
1558	DECL_INITIAL is set properly and we have a fundef but we
1559	haven't lowered invisirefs yet (c++/70344). /*
1560	if (DECL_INITIAL (fun) == error_mark_node
1561	\|\| fun == current_function_decl)
1562	error_at (loc, "%qD called in a constant expression before its "
1563	"definition is complete", fun);
1564	else if (DECL_INITIAL (fun))
1565	{
1566	/ The definition of fun was somehow unsuitable. But pretend*
1567	that lambda static thunks don't exist. /*
1568	if (!lambda_static_thunk_p (fun))
1569	error_at (loc, "%qD called in a constant expression", fun);
1570	explain_invalid_constexpr_fn (fun);
1571	}
1572	else
1573	error_at (loc, "%qD used before its definition", fun);
1574	}
1575	non_constant_p = true*;
1576	return t;
1577	}
1578	}
1579
1580	bool non_constant_args = false;
1581	cxx_bind_parameters_in_call (ctx, t, &new_call,
1582	non_constant_p, overflow_p, &non_constant_args);
1583	if (*non_constant_p)
1584	return t;
1585
1586	depth_ok = push_cx_call_context (t);
1587
1588	tree result = NULL_TREE;
1589
1590	constexpr_call *entry = NULL;
1591	if (depth_ok && !non_constant_args)
1592	{
1593	new_call.hash = iterative_hash_template_arg
1594	(new_call.bindings, constexpr_fundef_hasher::hash (new_call.fundef));
1595
1596	/ If we have seen this call before, we are done. /
1597	maybe_initialize_constexpr_call_table ();
1598	constexpr_call **slot
1599	= constexpr_call_table->find_slot (&new_call, INSERT);
1600	entry = *slot;
1601	if (entry == NULL)
1602	{
1603	/ We need to keep a pointer to the entry, not just the slot, as the*
1604	slot can move in the call to cxx_eval_builtin_function_call. /*
1605	*slot = entry = ggc_alloc<constexpr_call> ();
1606	*entry = new_call;
1607	}
1608	/ Calls that are in progress have their result set to NULL,*
1609	so that we can detect circular dependencies. /*
1610	else if (entry->result == NULL)
1611	{
1612	if (!ctx->quiet)
1613	error ("call has circular dependency");
1614	non_constant_p = true*;
1615	entry->result = result = error_mark_node;
1616	}
1617	else
1618	result = entry->result;
1619	}
1620
1621	if (!depth_ok)
1622	{
1623	if (!ctx->quiet)
1624	error ("%<constexpr%> evaluation depth exceeds maximum of %d (use "
1625	"-fconstexpr-depth= to increase the maximum)",
1626	max_constexpr_depth);
1627	non_constant_p = true*;
1628	result = error_mark_node;
1629	}
1630	else
1631	{
1632	if (result && result != error_mark_node)
1633	/ OK /;
1634	else if (!DECL_SAVED_TREE (fun))
1635	{
1636	/ When at_eof >= 2, cgraph has started throwing away*
1637	DECL_SAVED_TREE, so fail quietly. FIXME we get here because of
1638	late code generation for VEC_INIT_EXPR, which needs to be
1639	completely reconsidered. /*
1640	gcc_assert (at_eof >= `2` && ctx->quiet);
1641	non_constant_p = true*;
1642	}
1643	else
1644	{
1645	tree body, parms, res;
1646
1647	/ Reuse or create a new unshared copy of this function's body. /
1648	tree copy = get_fundef_copy (fun);
1649	body = TREE_PURPOSE (copy);
1650	parms = TREE_VALUE (copy);
1651	res = TREE_TYPE (copy);
1652
1653	/ Associate the bindings with the remapped parms. /
1654	tree bound = new_call.bindings;
1655	tree remapped = parms;
1656	while (bound)
1657	{
1658	tree oparm = TREE_PURPOSE (bound);
1659	tree arg = TREE_VALUE (bound);
1660	gcc_assert (DECL_NAME (remapped) == DECL_NAME (oparm));
1661	/ Don't share a CONSTRUCTOR that might be changed. /
1662	arg = unshare_constructor (arg);
1663	ctx->values->put (remapped, arg);
1664	bound = TREE_CHAIN (bound);
1665	remapped = DECL_CHAIN (remapped);
1666	}
1667	/ Add the RESULT_DECL to the values map, too. /
1668	tree slot = NULL_TREE;
1669	if (DECL_BY_REFERENCE (res))
1670	{
1671	slot = AGGR_INIT_EXPR_SLOT (t);
1672	tree addr = build_address (slot);
1673	addr = build_nop (TREE_TYPE (res), addr);
1674	ctx->values->put (res, addr);
1675	ctx->values->put (slot, NULL_TREE);
1676	}
1677	else
1678	ctx->values->put (res, NULL_TREE);
1679
1680	/ Track the callee's evaluated SAVE_EXPRs so that we can forget*
1681	their values after the call. /*
1682	constexpr_ctx ctx_with_save_exprs = *ctx;
1683	hash_set<tree> save_exprs;
1684	ctx_with_save_exprs.save_exprs = &save_exprs;
1685	ctx_with_save_exprs.call = &new_call;
1686
1687	tree jump_target = NULL_TREE;
1688	cxx_eval_constant_expression (&ctx_with_save_exprs, body,
1689	lval, non_constant_p, overflow_p,
1690	&jump_target);
1691
1692	if (DECL_CONSTRUCTOR_P (fun))
1693	/ This can be null for a subobject constructor call, in*
1694	which case what we care about is the initialization
1695	side-effects rather than the value. We could get at the
1696	value by evaluating this, but we don't bother; there's*
1697	no need to put such a call in the hash table. /*
1698	result = lval ? ctx->object : ctx->ctor;
1699	else if (VOID_TYPE_P (TREE_TYPE (res)))
1700	result = void_node;
1701	else
1702	{
1703	result = *ctx->values->get (slot ? slot : res);
1704	if (result == NULL_TREE && !*non_constant_p)
1705	{
1706	if (!ctx->quiet)
1707	error ("%<constexpr%> call flows off the end "
1708	"of the function");
1709	non_constant_p = true*;
1710	}
1711	}
1712
1713	/ Forget the saved values of the callee's SAVE_EXPRs. /
1714	for (hash_set<tree>::iterator iter = save_exprs.begin();
1715	iter != save_exprs.end(); ++iter)
1716	ctx_with_save_exprs.values->remove (*iter);
1717
1718	/ Remove the parms/result from the values map. Is it worth*
1719	bothering to do this when the map itself is only live for
1720	one constexpr evaluation? If so, maybe also clear out
1721	other vars from call, maybe in BIND_EXPR handling? /*
1722	ctx->values->remove (res);
1723	if (slot)
1724	ctx->values->remove (slot);
1725	for (tree parm = parms; parm; parm = TREE_CHAIN (parm))
1726	ctx->values->remove (parm);
1727
1728	/ Make the unshared function copy we used available for re-use. /
1729	save_fundef_copy (fun, copy);
1730	}
1731
1732	if (result == error_mark_node)
1733	non_constant_p = true*;
1734	if (non_constant_p \|\| overflow_p)
1735	result = error_mark_node;
1736	else if (!result)
1737	result = void_node;
1738	if (entry)
1739	entry->result = result;
1740	}
1741
1742	/ The result of a constexpr function must be completely initialized. /
1743	if (TREE_CODE (result) == CONSTRUCTOR)
1744	clear_no_implicit_zero (result);
1745
1746	pop_cx_call_context ();
1747	return unshare_constructor (result);
1748	}
1749
1750	/ FIXME speed this up, it's taking 16% of compile time on sieve testcase. /
1751
1752	bool
1753	reduced_constant_expression_p (tree t)
1754	{
1755	switch (TREE_CODE (t))
1756	{
1757	case PTRMEM_CST:
1758	/ Even if we can't lower this yet, it's constant. /
1759	return true;
1760
1761	case CONSTRUCTOR:
1762	/ And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. /
1763	tree idx, val, field; unsigned HOST_WIDE_INT i;
1764	if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t))
1765	field = next_initializable_field (TYPE_FIELDS (TREE_TYPE (t)));
1766	else
1767	field = NULL_TREE;
1768	FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), i, idx, val)
1769	{
1770	if (!val)
1771	/ We're in the middle of initializing this element. /
1772	return false;
1773	if (!reduced_constant_expression_p (val))
1774	return false;
1775	if (field)
1776	{
1777	if (idx != field)
1778	return false;
1779	field = next_initializable_field (DECL_CHAIN (field));
1780	}
1781	}
1782	if (field)
1783	return false;
1784	else if (CONSTRUCTOR_NO_IMPLICIT_ZERO (t))
1785	/ All the fields are initialized. /
1786	CONSTRUCTOR_NO_IMPLICIT_ZERO (t) = false;
1787	return true;
1788
1789	default:
1790	/ FIXME are we calling this too much? /
1791	return initializer_constant_valid_p (t, TREE_TYPE (t)) != NULL_TREE;
1792	}
1793	}
1794
1795	/ Some expressions may have constant operands but are not constant*
1796	themselves, such as 1/0. Call this function (or rather, the macro
1797	following it) to check for that condition.
1798
1799	We only call this in places that require an arithmetic constant, not in
1800	places where we might have a non-constant expression that can be a
1801	component of a constant expression, such as the address of a constexpr
1802	variable that might be dereferenced later. /*
1803
1804	static bool
1805	verify_constant (tree t, bool allow_non_constant, bool *non_constant_p,
1806	bool *overflow_p)
1807	{
1808	if (!*non_constant_p && !reduced_constant_expression_p (t))
1809	{
1810	if (!allow_non_constant)
1811	error ("%q+E is not a constant expression", t);
1812	non_constant_p = true*;
1813	}
1814	if (TREE_OVERFLOW_P (t))
1815	{
1816	if (!allow_non_constant)
1817	{
1818	permerror (input_location, "overflow in constant expression");
1819	/ If we're being permissive (and are in an enforcing*
1820	context), ignore the overflow. /*
1821	if (flag_permissive)
1822	return *non_constant_p;
1823	}
1824	overflow_p = true*;
1825	}
1826	return *non_constant_p;
1827	}
1828
1829	/ Check whether the shift operation with code CODE and type TYPE on LHS*
1830	and RHS is undefined. If it is, give an error with an explanation,
1831	and return true; return false otherwise. /*
1832
1833	static bool
1834	cxx_eval_check_shift_p (location_t loc, const constexpr_ctx *ctx,
1835	enum tree_code code, tree type, tree lhs, tree rhs)
1836	{
1837	if ((code != LSHIFT_EXPR && code != RSHIFT_EXPR)
1838	\|\| TREE_CODE (lhs) != INTEGER_CST
1839	\|\| TREE_CODE (rhs) != INTEGER_CST)
1840	return false;
1841
1842	tree lhstype = TREE_TYPE (lhs);
1843	unsigned HOST_WIDE_INT uprec = TYPE_PRECISION (TREE_TYPE (lhs));
1844
1845	/ [expr.shift] The behavior is undefined if the right operand*
1846	is negative, or greater than or equal to the length in bits
1847	of the promoted left operand. /*
1848	if (tree_int_cst_sgn (rhs) == -`1`)
1849	{
1850	if (!ctx->quiet)
1851	permerror (loc, "right operand of shift expression %q+E is negative",
1852	build2_loc (loc, code, type, lhs, rhs));
1853	return (!flag_permissive \|\| ctx->quiet);
1854	}
1855	if (compare_tree_int (rhs, uprec) >= `0`)
1856	{
1857	if (!ctx->quiet)
1858	permerror (loc, "right operand of shift expression %q+E is >= than "
1859	"the precision of the left operand",
1860	build2_loc (loc, code, type, lhs, rhs));
1861	return (!flag_permissive \|\| ctx->quiet);
1862	}
1863
1864	/ The value of E1 << E2 is E1 left-shifted E2 bit positions; [...]*
1865	if E1 has a signed type and non-negative value, and E1x2^E2 is
1866	representable in the corresponding unsigned type of the result type,
1867	then that value, converted to the result type, is the resulting value;
1868	otherwise, the behavior is undefined. /*
1869	if (code == LSHIFT_EXPR && !TYPE_UNSIGNED (lhstype)
1870	&& (cxx_dialect >= cxx11))
1871	{
1872	if (tree_int_cst_sgn (lhs) == -`1`)
1873	{
1874	if (!ctx->quiet)
1875	permerror (loc,
1876	"left operand of shift expression %q+E is negative",
1877	build2_loc (loc, code, type, lhs, rhs));
1878	return (!flag_permissive \|\| ctx->quiet);
1879	}
1880	/ For signed x << y the following:*
1881	(unsigned) x >> ((prec (lhs) - 1) - y)
1882	if > 1, is undefined. The right-hand side of this formula
1883	is the highest bit of the LHS that can be set (starting from 0),
1884	so that the shift doesn't overflow. We then right-shift the LHS
1885	to see whether any other bit is set making the original shift
1886	undefined -- the result is not representable in the corresponding
1887	unsigned type. /*
1888	tree t = build_int_cst (unsigned_type_node, uprec - `1`);
1889	t = fold_build2 (MINUS_EXPR, unsigned_type_node, t, rhs);
1890	tree ulhs = fold_convert (unsigned_type_for (lhstype), lhs);
1891	t = fold_build2 (RSHIFT_EXPR, TREE_TYPE (ulhs), ulhs, t);
1892	if (tree_int_cst_lt (integer_one_node, t))
1893	{
1894	if (!ctx->quiet)
1895	permerror (loc, "shift expression %q+E overflows",
1896	build2_loc (loc, code, type, lhs, rhs));
1897	return (!flag_permissive \|\| ctx->quiet);
1898	}
1899	}
1900	return false;
1901	}
1902
1903	/ Subroutine of cxx_eval_constant_expression.*
1904	Attempt to reduce the unary expression tree T to a compile time value.
1905	If successful, return the value. Otherwise issue a diagnostic
1906	and return error_mark_node. /*
1907
1908	static tree
1909	cxx_eval_unary_expression (const constexpr_ctx *ctx, tree t,
1910	bool /lval/,
1911	bool non_constant_p, bool* *overflow_p)
1912	{
1913	tree r;
1914	tree orig_arg = TREE_OPERAND (t, `0`);
1915	tree arg = cxx_eval_constant_expression (ctx, orig_arg, /lval/false,
1916	non_constant_p, overflow_p);
1917	VERIFY_CONSTANT (arg);
1918	location_t loc = EXPR_LOCATION (t);
1919	enum tree_code code = TREE_CODE (t);
1920	tree type = TREE_TYPE (t);
1921	r = fold_unary_loc (loc, code, type, arg);
1922	if (r == NULL_TREE)
1923	{
1924	if (arg == orig_arg)
1925	r = t;
1926	else
1927	r = build1_loc (loc, code, type, arg);
1928	}
1929	VERIFY_CONSTANT (r);
1930	return r;
1931	}
1932
1933	/ Helper function for cxx_eval_binary_expression. Try to optimize*
1934	original POINTER_PLUS_EXPR T, LHS p+ RHS, return NULL_TREE if the
1935	generic folding should be used. /*
1936
1937	static tree
1938	cxx_fold_pointer_plus_expression (const constexpr_ctx *ctx, tree t,
1939	tree lhs, tree rhs, bool *non_constant_p,
1940	bool *overflow_p)
1941	{
1942	STRIP_NOPS (lhs);
1943	if (TREE_CODE (lhs) != ADDR_EXPR)
1944	return NULL_TREE;
1945
1946	lhs = TREE_OPERAND (lhs, `0`);
1947
1948	/ &A[i] p+ j => &A[i + j] /
1949	if (TREE_CODE (lhs) == ARRAY_REF
1950	&& TREE_CODE (TREE_OPERAND (lhs, `1`)) == INTEGER_CST
1951	&& TREE_CODE (rhs) == INTEGER_CST
1952	&& TYPE_SIZE_UNIT (TREE_TYPE (lhs))
1953	&& TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs))) == INTEGER_CST)
1954	{
1955	tree orig_type = TREE_TYPE (t);
1956	location_t loc = EXPR_LOCATION (t);
1957	tree type = TREE_TYPE (lhs);
1958
1959	t = fold_convert_loc (loc, ssizetype, TREE_OPERAND (lhs, `1`));
1960	tree nelts = array_type_nelts_top (TREE_TYPE (TREE_OPERAND (lhs, `0`)));
1961	nelts = cxx_eval_constant_expression (ctx, nelts, false, non_constant_p,
1962	overflow_p);
1963	if (*non_constant_p)
1964	return NULL_TREE;
1965	/ Don't fold an out-of-bound access. /
1966	if (!tree_int_cst_le (t, nelts))
1967	return NULL_TREE;
1968	rhs = cp_fold_convert (ssizetype, rhs);
1969	/ Don't fold if rhs can't be divided exactly by TYPE_SIZE_UNIT.*
1970	constexpr int A[1]; ... (char )&A[0] + 1 /
1971	if (!integer_zerop (fold_build2_loc (loc, TRUNC_MOD_EXPR, sizetype,
1972	rhs, TYPE_SIZE_UNIT (type))))
1973	return NULL_TREE;
1974	/ Make sure to treat the second operand of POINTER_PLUS_EXPR*
1975	as signed. /*
1976	rhs = fold_build2_loc (loc, EXACT_DIV_EXPR, ssizetype, rhs,
1977	TYPE_SIZE_UNIT (type));
1978	t = size_binop_loc (loc, PLUS_EXPR, rhs, t);
1979	t = build4_loc (loc, ARRAY_REF, type, TREE_OPERAND (lhs, `0`),
1980	t, NULL_TREE, NULL_TREE);
1981	t = cp_build_addr_expr (t, tf_warning_or_error);
1982	t = cp_fold_convert (orig_type, t);
1983	return cxx_eval_constant_expression (ctx, t, /lval/false,
1984	non_constant_p, overflow_p);
1985	}
1986
1987	return NULL_TREE;
1988	}
1989
1990	/ Subroutine of cxx_eval_constant_expression.*
1991	Like cxx_eval_unary_expression, except for binary expressions. /*
1992
1993	static tree
1994	cxx_eval_binary_expression (const constexpr_ctx *ctx, tree t,
1995	bool /lval/,
1996	bool non_constant_p, bool* *overflow_p)
1997	{
1998	tree r = NULL_TREE;
1999	tree orig_lhs = TREE_OPERAND (t, `0`);
2000	tree orig_rhs = TREE_OPERAND (t, `1`);
2001	tree lhs, rhs;
2002	lhs = cxx_eval_constant_expression (ctx, orig_lhs, /lval/false,
2003	non_constant_p, overflow_p);
2004	/ Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer*
2005	subtraction. /*
2006	if (*non_constant_p)
2007	return t;
2008	rhs = cxx_eval_constant_expression (ctx, orig_rhs, /lval/false,
2009	non_constant_p, overflow_p);
2010	if (*non_constant_p)
2011	return t;
2012
2013	location_t loc = EXPR_LOCATION (t);
2014	enum tree_code code = TREE_CODE (t);
2015	tree type = TREE_TYPE (t);
2016
2017	if (code == EQ_EXPR \|\| code == NE_EXPR)
2018	{
2019	bool is_code_eq = (code == EQ_EXPR);
2020
2021	if (TREE_CODE (lhs) == PTRMEM_CST
2022	&& TREE_CODE (rhs) == PTRMEM_CST)
2023	r = constant_boolean_node (cp_tree_equal (lhs, rhs) == is_code_eq,
2024	type);
2025	else if ((TREE_CODE (lhs) == PTRMEM_CST
2026	\|\| TREE_CODE (rhs) == PTRMEM_CST)
2027	&& (null_member_pointer_value_p (lhs)
2028	\|\| null_member_pointer_value_p (rhs)))
2029	r = constant_boolean_node (!is_code_eq, type);
2030	else if (TREE_CODE (lhs) == PTRMEM_CST)
2031	lhs = cplus_expand_constant (lhs);
2032	else if (TREE_CODE (rhs) == PTRMEM_CST)
2033	rhs = cplus_expand_constant (rhs);
2034	}
2035	if (code == POINTER_PLUS_EXPR && !*non_constant_p
2036	&& integer_zerop (lhs) && !integer_zerop (rhs))
2037	{
2038	if (!ctx->quiet)
2039	error ("arithmetic involving a null pointer in %qE", lhs);
2040	return t;
2041	}
2042	else if (code == POINTER_PLUS_EXPR)
2043	r = cxx_fold_pointer_plus_expression (ctx, t, lhs, rhs, non_constant_p,
2044	overflow_p);
2045
2046	if (r == NULL_TREE)
2047	r = fold_binary_loc (loc, code, type, lhs, rhs);
2048
2049	if (r == NULL_TREE)
2050	{
2051	if (lhs == orig_lhs && rhs == orig_rhs)
2052	r = t;
2053	else
2054	r = build2_loc (loc, code, type, lhs, rhs);
2055	}
2056	else if (cxx_eval_check_shift_p (loc, ctx, code, type, lhs, rhs))
2057	non_constant_p = true*;
2058	/ Don't VERIFY_CONSTANT if this might be dealing with a pointer to*
2059	a local array in a constexpr function. /*
2060	bool ptr = POINTER_TYPE_P (TREE_TYPE (lhs));
2061	if (!ptr)
2062	VERIFY_CONSTANT (r);
2063	return r;
2064	}
2065
2066	/ Subroutine of cxx_eval_constant_expression.*
2067	Attempt to evaluate condition expressions. Dead branches are not
2068	looked into. /*
2069
2070	static tree
2071	cxx_eval_conditional_expression (const constexpr_ctx *ctx, tree t,
2072	bool lval,
2073	bool non_constant_p, bool* *overflow_p,
2074	tree *jump_target)
2075	{
2076	tree val = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, `0`),
2077	/lval/false,
2078	non_constant_p, overflow_p);
2079	VERIFY_CONSTANT (val);
2080	/ Don't VERIFY_CONSTANT the other operands. /
2081	if (integer_zerop (val))
2082	return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, `2`),
2083	lval,
2084	non_constant_p, overflow_p,
2085	jump_target);
2086	return cxx_eval_constant_expression (ctx, TREE_OPERAND (t, `1`),
2087	lval,
2088	non_constant_p, overflow_p,
2089	jump_target);
2090	}
2091
2092	/ Subroutine of cxx_eval_constant_expression.*
2093	Attempt to evaluate vector condition expressions. Unlike
2094	cxx_eval_conditional_expression, VEC_COND_EXPR acts like a normal
2095	ternary arithmetics operation, where all 3 arguments have to be
2096	evaluated as constants and then folding computes the result from
2097	them. /*
2098
2099	static tree
2100	cxx_eval_vector_conditional_expression (const constexpr_ctx *ctx, tree t,
2101	bool non_constant_p, bool* *overflow_p)
2102	{
2103	tree arg1 = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, `0`),
2104	/lval/false,
2105	non_constant_p, overflow_p);
2106	VERIFY_CONSTANT (arg1);
2107	tree arg2 = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, `1`),
2108	/lval/false,
2109	non_constant_p, overflow_p);
2110	VERIFY_CONSTANT (arg2);
2111	tree arg3 = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, `2`),
2112	/lval/false,
2113	non_constant_p, overflow_p);
2114	VERIFY_CONSTANT (arg3);
2115	location_t loc = EXPR_LOCATION (t);
2116	tree type = TREE_TYPE (t);
2117	tree r = fold_ternary_loc (loc, VEC_COND_EXPR, type, arg1, arg2, arg3);
2118	if (r == NULL_TREE)
2119	{
2120	if (arg1 == TREE_OPERAND (t, `0`)
2121	&& arg2 == TREE_OPERAND (t, `1`)
2122	&& arg3 == TREE_OPERAND (t, `2`))
2123	r = t;
2124	else
2125	r = build3_loc (loc, VEC_COND_EXPR, type, arg1, arg2, arg3);
2126	}
2127	VERIFY_CONSTANT (r);
2128	return r;
2129	}
2130
2131	/ Returns less than, equal to, or greater than zero if KEY is found to be*
2132	less than, to match, or to be greater than the constructor_elt's INDEX. /*
2133
2134	static int
2135	array_index_cmp (tree key, tree index)
2136	{
2137	gcc_assert (TREE_CODE (key) == INTEGER_CST);
2138
2139	switch (TREE_CODE (index))
2140	{
2141	case INTEGER_CST:
2142	return tree_int_cst_compare (key, index);
2143	case RANGE_EXPR:
2144	{
2145	tree lo = TREE_OPERAND (index, `0`);
2146	tree hi = TREE_OPERAND (index, `1`);
2147	if (tree_int_cst_lt (key, lo))
2148	return -`1`;
2149	else if (tree_int_cst_lt (hi, key))
2150	return `1`;
2151	else
2152	return `0`;
2153	}
2154	default:
2155	gcc_unreachable ();
2156	}
2157	}
2158
2159	/ Returns the index of the constructor_elt of ARY which matches DINDEX, or -1*
2160	if none. If INSERT is true, insert a matching element rather than fail. /*
2161
2162	static HOST_WIDE_INT
2163	find_array_ctor_elt (tree ary, tree dindex, bool insert = false)
2164	{
2165	if (tree_int_cst_sgn (dindex) < `0`)
2166	return -`1`;
2167
2168	unsigned HOST_WIDE_INT i = tree_to_uhwi (dindex);
2169	vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (ary);
2170	unsigned HOST_WIDE_INT len = vec_safe_length (elts);
2171
2172	unsigned HOST_WIDE_INT end = len;
2173	unsigned HOST_WIDE_INT begin = `0`;
2174
2175	/ If the last element of the CONSTRUCTOR has its own index, we can assume*
2176	that the same is true of the other elements and index directly. /*
2177	if (end > `0`)
2178	{
2179	tree cindex = (*elts)[end-`1`].index;
2180	if (TREE_CODE (cindex) == INTEGER_CST
2181	&& compare_tree_int (cindex, end-`1`) == `0`)
2182	{
2183	if (i < end)
2184	return i;
2185	else
2186	begin = end;
2187	}
2188	}
2189
2190	/ Otherwise, find a matching index by means of a binary search. /
2191	while (begin != end)
2192	{
2193	unsigned HOST_WIDE_INT middle = (begin + end) / `2`;
2194	constructor_elt &elt = (*elts)[middle];
2195	tree idx = elt.index;
2196
2197	int cmp = array_index_cmp (dindex, idx);
2198	if (cmp < `0`)
2199	end = middle;
2200	else if (cmp > `0`)
2201	begin = middle + `1`;
2202	else
2203	{
2204	if (insert && TREE_CODE (idx) == RANGE_EXPR)
2205	{
2206	/ We need to split the range. /
2207	constructor_elt e;
2208	tree lo = TREE_OPERAND (idx, `0`);
2209	tree hi = TREE_OPERAND (idx, `1`);
2210	if (tree_int_cst_lt (lo, dindex))
2211	{
2212	/ There are still some lower elts; shorten the range. /
2213	tree new_hi = int_const_binop (MINUS_EXPR, dindex,
2214	size_one_node);
2215	if (tree_int_cst_equal (lo, new_hi))
2216	/ Only one element left, no longer a range. /
2217	elt.index = lo;
2218	else
2219	TREE_OPERAND (idx, `1`) = new_hi;
2220	/ Append the element we want to insert. /
2221	++middle;
2222	e.index = dindex;
2223	e.value = unshare_constructor (elt.value);
2224	vec_safe_insert (CONSTRUCTOR_ELTS (ary), middle, e);
2225	}
2226	else
2227	/ No lower elts, the range elt is now ours. /
2228	elt.index = dindex;
2229
2230	if (tree_int_cst_lt (dindex, hi))
2231	{
2232	/ There are still some higher elts; append a range. /
2233	tree new_lo = int_const_binop (PLUS_EXPR, dindex,
2234	size_one_node);
2235	if (tree_int_cst_equal (new_lo, hi))
2236	e.index = hi;
2237	else
2238	e.index = build2 (RANGE_EXPR, sizetype, new_lo, hi);
2239	e.value = unshare_constructor (elt.value);
2240	vec_safe_insert (CONSTRUCTOR_ELTS (ary), middle+`1`, e);
2241	}
2242	}
2243	return middle;
2244	}
2245	}
2246
2247	if (insert)
2248	{
2249	constructor_elt e = { dindex, NULL_TREE };
2250	vec_safe_insert (CONSTRUCTOR_ELTS (ary), end, e);
2251	return end;
2252	}
2253
2254	return -`1`;
2255	}
2256
2257	/ Under the control of CTX, issue a detailed diagnostic for*
2258	an out-of-bounds subscript INDEX into the expression ARRAY. /*
2259
2260	static void
2261	diag_array_subscript (const constexpr_ctx *ctx, tree array, tree index)
2262	{
2263	if (!ctx->quiet)
2264	{
2265	tree arraytype = TREE_TYPE (array);
2266
2267	/ Convert the unsigned array subscript to a signed integer to avoid*
2268	printing huge numbers for small negative values. /*
2269	tree sidx = fold_convert (ssizetype, index);
2270	if (DECL_P (array))
2271	{
2272	error ("array subscript value %qE is outside the bounds "
2273	"of array %qD of type %qT", sidx, array, arraytype);
2274	inform (DECL_SOURCE_LOCATION (array), "declared here");
2275	}
2276	else
2277	error ("array subscript value %qE is outside the bounds "
2278	"of array type %qT", sidx, arraytype);
2279	}
2280	}
2281
2282	/ Extract element INDEX consisting of CHARS_PER_ELT chars from*
2283	STRING_CST STRING. /*
2284
2285	static tree
2286	extract_string_elt (tree string, unsigned chars_per_elt, unsigned index)
2287	{
2288	tree type = cv_unqualified (TREE_TYPE (TREE_TYPE (string)));
2289	tree r;
2290
2291	if (chars_per_elt == `1`)
2292	r = build_int_cst (type, TREE_STRING_POINTER (string)[index]);
2293	else
2294	{
2295	const unsigned char *ptr
2296	= ((const unsigned char *)TREE_STRING_POINTER (string)
2297	+ index * chars_per_elt);
2298	r = native_interpret_expr (type, ptr, chars_per_elt);
2299	}
2300	return r;
2301	}
2302
2303	/ Subroutine of cxx_eval_constant_expression.*
2304	Attempt to reduce a reference to an array slot. /*
2305
2306	static tree
2307	cxx_eval_array_reference (const constexpr_ctx *ctx, tree t,
2308	bool lval,
2309	bool non_constant_p, bool* *overflow_p)
2310	{
2311	tree oldary = TREE_OPERAND (t, `0`);
2312	tree ary = cxx_eval_constant_expression (ctx, oldary,
2313	lval,
2314	non_constant_p, overflow_p);
2315	tree index, oldidx;
2316	HOST_WIDE_INT i = `0`;
2317	tree elem_type = NULL_TREE;
2318	unsigned len = `0`, elem_nchars = `1`;
2319	if (*non_constant_p)
2320	return t;
2321	oldidx = TREE_OPERAND (t, `1`);
2322	index = cxx_eval_constant_expression (ctx, oldidx,
2323	false,
2324	non_constant_p, overflow_p);
2325	VERIFY_CONSTANT (index);
2326	if (!lval)
2327	{
2328	elem_type = TREE_TYPE (TREE_TYPE (ary));
2329	if (TREE_CODE (ary) == VIEW_CONVERT_EXPR
2330	&& VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (ary, `0`)))
2331	&& TREE_TYPE (t) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (ary, `0`))))
2332	ary = TREE_OPERAND (ary, `0`);
2333	if (TREE_CODE (ary) == CONSTRUCTOR)
2334	len = CONSTRUCTOR_NELTS (ary);
2335	else if (TREE_CODE (ary) == STRING_CST)
2336	{
2337	elem_nchars = (TYPE_PRECISION (elem_type)
2338	/ TYPE_PRECISION (char_type_node));
2339	len = (unsigned) TREE_STRING_LENGTH (ary) / elem_nchars;
2340	}
2341	else if (TREE_CODE (ary) == VECTOR_CST)
2342	len = VECTOR_CST_NELTS (ary);
2343	else
2344	{
2345	/ We can't do anything with other tree codes, so use*
2346	VERIFY_CONSTANT to complain and fail. /*
2347	VERIFY_CONSTANT (ary);
2348	gcc_unreachable ();
2349	}
2350
2351	if (!tree_fits_shwi_p (index)
2352	\|\| (i = tree_to_shwi (index)) < `0`)
2353	{
2354	diag_array_subscript (ctx, ary, index);
2355	non_constant_p = true*;
2356	return t;
2357	}
2358	}
2359
2360	tree nelts;
2361	if (TREE_CODE (TREE_TYPE (ary)) == ARRAY_TYPE)
2362	nelts = array_type_nelts_top (TREE_TYPE (ary));
2363	else if (VECTOR_TYPE_P (TREE_TYPE (ary)))
2364	nelts = size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary)));
2365	else
2366	gcc_unreachable ();
2367
2368	/ For VLAs, the number of elements won't be an integer constant. /
2369	nelts = cxx_eval_constant_expression (ctx, nelts, false, non_constant_p,
2370	overflow_p);
2371	VERIFY_CONSTANT (nelts);
2372	if ((lval
2373	? !tree_int_cst_le (index, nelts)
2374	: !tree_int_cst_lt (index, nelts))
2375	\|\| tree_int_cst_sgn (index) < `0`)
2376	{
2377	diag_array_subscript (ctx, ary, index);
2378	non_constant_p = true*;
2379	return t;
2380	}
2381
2382	if (lval && ary == oldary && index == oldidx)
2383	return t;
2384	else if (lval)
2385	return build4 (ARRAY_REF, TREE_TYPE (t), ary, index, NULL, NULL);
2386
2387	bool found;
2388	if (TREE_CODE (ary) == CONSTRUCTOR)
2389	{
2390	HOST_WIDE_INT ix = find_array_ctor_elt (ary, index);
2391	found = (ix >= `0`);
2392	if (found)
2393	i = ix;
2394	}
2395	else
2396	found = (i < len);
2397
2398	if (found)
2399	{
2400	tree r;
2401	if (TREE_CODE (ary) == CONSTRUCTOR)
2402	r = (*CONSTRUCTOR_ELTS (ary))[i].value;
2403	else if (TREE_CODE (ary) == VECTOR_CST)
2404	r = VECTOR_CST_ELT (ary, i);
2405	else
2406	r = extract_string_elt (ary, elem_nchars, i);
2407
2408	if (r)
2409	/ Don't VERIFY_CONSTANT here. /
2410	return r;
2411
2412	/ Otherwise the element doesn't have a value yet. /
2413	}
2414
2415	/ Not found. /
2416
2417	if (TREE_CODE (ary) == CONSTRUCTOR
2418	&& CONSTRUCTOR_NO_IMPLICIT_ZERO (ary))
2419	{
2420	/ 'ary' is part of the aggregate initializer we're currently*
2421	building; if there's no initializer for this element yet,
2422	that's an error. /*
2423	if (!ctx->quiet)
2424	error ("accessing uninitialized array element");
2425	non_constant_p = true*;
2426	return t;
2427	}
2428
2429	/ If it's within the array bounds but doesn't have an explicit*
2430	initializer, it's value-initialized. /*
2431	tree val = build_value_init (elem_type, tf_warning_or_error);
2432	return cxx_eval_constant_expression (ctx, val, lval, non_constant_p,
2433	overflow_p);
2434	}
2435
2436	/ Subroutine of cxx_eval_constant_expression.*
2437	Attempt to reduce a field access of a value of class type. /*
2438
2439	static tree
2440	cxx_eval_component_reference (const constexpr_ctx *ctx, tree t,
2441	bool lval,
2442	bool non_constant_p, bool* *overflow_p)
2443	{
2444	unsigned HOST_WIDE_INT i;
2445	tree field;
2446	tree value;
2447	tree part = TREE_OPERAND (t, `1`);
2448	tree orig_whole = TREE_OPERAND (t, `0`);
2449	tree whole = cxx_eval_constant_expression (ctx, orig_whole,
2450	lval,
2451	non_constant_p, overflow_p);
2452	if (TREE_CODE (whole) == INDIRECT_REF
2453	&& integer_zerop (TREE_OPERAND (whole, `0`))
2454	&& !ctx->quiet)
2455	error ("dereferencing a null pointer in %qE", orig_whole);
2456
2457	if (TREE_CODE (whole) == PTRMEM_CST)
2458	whole = cplus_expand_constant (whole);
2459	if (whole == orig_whole)
2460	return t;
2461	if (lval)
2462	return fold_build3 (COMPONENT_REF, TREE_TYPE (t),
2463	whole, part, NULL_TREE);
2464	/ Don't VERIFY_CONSTANT here; we only want to check that we got a*
2465	CONSTRUCTOR. /*
2466	if (!*non_constant_p && TREE_CODE (whole) != CONSTRUCTOR)
2467	{
2468	if (!ctx->quiet)
2469	error ("%qE is not a constant expression", orig_whole);
2470	non_constant_p = true*;
2471	}
2472	if (DECL_MUTABLE_P (part))
2473	{
2474	if (!ctx->quiet)
2475	error ("mutable %qD is not usable in a constant expression", part);
2476	non_constant_p = true*;
2477	}
2478	if (*non_constant_p)
2479	return t;
2480	bool pmf = TYPE_PTRMEMFUNC_P (TREE_TYPE (whole));
2481	FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
2482	{
2483	/ Use name match for PMF fields, as a variant will have a*
2484	different FIELD_DECL with a different type. /*
2485	if (pmf ? DECL_NAME (field) == DECL_NAME (part)
2486	: field == part)
2487	{
2488	if (value)
2489	return value;
2490	else
2491	/ We're in the middle of initializing it. /
2492	break;
2493	}
2494	}
2495	if (TREE_CODE (TREE_TYPE (whole)) == UNION_TYPE
2496	&& CONSTRUCTOR_NELTS (whole) > `0`)
2497	{
2498	/ DR 1188 says we don't have to deal with this. /
2499	if (!ctx->quiet)
2500	error ("accessing %qD member instead of initialized %qD member in "
2501	"constant expression", part, CONSTRUCTOR_ELT (whole, `0`)->index);
2502	non_constant_p = true*;
2503	return t;
2504	}
2505
2506	/ We only create a CONSTRUCTOR for a subobject when we modify it, so empty*
2507	classes never get represented; throw together a value now. /*
2508	if (is_really_empty_class (TREE_TYPE (t)))
2509	return build_constructor (TREE_TYPE (t), NULL);
2510
2511	gcc_assert (DECL_CONTEXT (part) == TYPE_MAIN_VARIANT (TREE_TYPE (whole)));
2512
2513	if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole))
2514	{
2515	/ 'whole' is part of the aggregate initializer we're currently*
2516	building; if there's no initializer for this member yet, that's an
2517	error. /*
2518	if (!ctx->quiet)
2519	error ("accessing uninitialized member %qD", part);
2520	non_constant_p = true*;
2521	return t;
2522	}
2523
2524	/ If there's no explicit init for this field, it's value-initialized. /
2525	value = build_value_init (TREE_TYPE (t), tf_warning_or_error);
2526	return cxx_eval_constant_expression (ctx, value,
2527	lval,
2528	non_constant_p, overflow_p);
2529	}
2530
2531	/ Subroutine of cxx_eval_constant_expression.*
2532	Attempt to reduce a field access of a value of class type that is
2533	expressed as a BIT_FIELD_REF. /*
2534
2535	static tree
2536	cxx_eval_bit_field_ref (const constexpr_ctx *ctx, tree t,
2537	bool lval,
2538	bool non_constant_p, bool* *overflow_p)
2539	{
2540	tree orig_whole = TREE_OPERAND (t, `0`);
2541	tree retval, fldval, utype, mask;
2542	bool fld_seen = false;
2543	HOST_WIDE_INT istart, isize;
2544	tree whole = cxx_eval_constant_expression (ctx, orig_whole,
2545	lval,
2546	non_constant_p, overflow_p);
2547	tree start, field, value;
2548	unsigned HOST_WIDE_INT i;
2549
2550	if (whole == orig_whole)
2551	return t;
2552	/ Don't VERIFY_CONSTANT here; we only want to check that we got a*
2553	CONSTRUCTOR. /*
2554	if (!*non_constant_p
2555	&& TREE_CODE (whole) != VECTOR_CST
2556	&& TREE_CODE (whole) != CONSTRUCTOR)
2557	{
2558	if (!ctx->quiet)
2559	error ("%qE is not a constant expression", orig_whole);
2560	non_constant_p = true*;
2561	}
2562	if (*non_constant_p)
2563	return t;
2564
2565	if (TREE_CODE (whole) == VECTOR_CST)
2566	return fold_ternary (BIT_FIELD_REF, TREE_TYPE (t), whole,
2567	TREE_OPERAND (t, `1`), TREE_OPERAND (t, `2`));
2568
2569	start = TREE_OPERAND (t, `2`);
2570	istart = tree_to_shwi (start);
2571	isize = tree_to_shwi (TREE_OPERAND (t, `1`));
2572	utype = TREE_TYPE (t);
2573	if (!TYPE_UNSIGNED (utype))
2574	utype = build_nonstandard_integer_type (TYPE_PRECISION (utype), `1`);
2575	retval = build_int_cst (utype, `0`);
2576	FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
2577	{
2578	tree bitpos = bit_position (field);
2579	if (bitpos == start && DECL_SIZE (field) == TREE_OPERAND (t, `1`))
2580	return value;
2581	if (TREE_CODE (TREE_TYPE (field)) == INTEGER_TYPE
2582	&& TREE_CODE (value) == INTEGER_CST
2583	&& tree_fits_shwi_p (bitpos)
2584	&& tree_fits_shwi_p (DECL_SIZE (field)))
2585	{
2586	HOST_WIDE_INT bit = tree_to_shwi (bitpos);
2587	HOST_WIDE_INT sz = tree_to_shwi (DECL_SIZE (field));
2588	HOST_WIDE_INT shift;
2589	if (bit >= istart && bit + sz <= istart + isize)
2590	{
2591	fldval = fold_convert (utype, value);
2592	mask = build_int_cst_type (utype, -`1`);
2593	mask = fold_build2 (LSHIFT_EXPR, utype, mask,
2594	size_int (TYPE_PRECISION (utype) - sz));
2595	mask = fold_build2 (RSHIFT_EXPR, utype, mask,
2596	size_int (TYPE_PRECISION (utype) - sz));
2597	fldval = fold_build2 (BIT_AND_EXPR, utype, fldval, mask);
2598	shift = bit - istart;
2599	if (BYTES_BIG_ENDIAN)
2600	shift = TYPE_PRECISION (utype) - shift - sz;
2601	fldval = fold_build2 (LSHIFT_EXPR, utype, fldval,
2602	size_int (shift));
2603	retval = fold_build2 (BIT_IOR_EXPR, utype, retval, fldval);
2604	fld_seen = true;
2605	}
2606	}
2607	}
2608	if (fld_seen)
2609	return fold_convert (TREE_TYPE (t), retval);
2610	gcc_unreachable ();
2611	return error_mark_node;
2612	}
2613
2614	/ Subroutine of cxx_eval_constant_expression.*
2615	Evaluate a short-circuited logical expression T in the context
2616	of a given constexpr CALL. BAILOUT_VALUE is the value for
2617	early return. CONTINUE_VALUE is used here purely for
2618	sanity check purposes. /*
2619
2620	static tree
2621	cxx_eval_logical_expression (const constexpr_ctx *ctx, tree t,
2622	tree bailout_value, tree continue_value,
2623	bool lval,
2624	bool non_constant_p, bool* *overflow_p)
2625	{
2626	tree r;
2627	tree lhs = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, `0`),
2628	lval,
2629	non_constant_p, overflow_p);
2630	VERIFY_CONSTANT (lhs);
2631	if (tree_int_cst_equal (lhs, bailout_value))
2632	return lhs;
2633	gcc_assert (tree_int_cst_equal (lhs, continue_value));
2634	r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, `1`),
2635	lval, non_constant_p,
2636	overflow_p);
2637	VERIFY_CONSTANT (r);
2638	return r;
2639	}
2640
2641	/ REF is a COMPONENT_REF designating a particular field. V is a vector of*
2642	CONSTRUCTOR elements to initialize (part of) an object containing that
2643	field. Return a pointer to the constructor_elt corresponding to the
2644	initialization of the field. /*
2645
2646	static constructor_elt *
2647	base_field_constructor_elt (vec<constructor_elt, va_gc> *v, tree ref)
2648	{
2649	tree aggr = TREE_OPERAND (ref, `0`);
2650	tree field = TREE_OPERAND (ref, `1`);
2651	HOST_WIDE_INT i;
2652	constructor_elt *ce;
2653
2654	gcc_assert (TREE_CODE (ref) == COMPONENT_REF);
2655
2656	if (TREE_CODE (aggr) == COMPONENT_REF)
2657	{
2658	constructor_elt *base_ce
2659	= base_field_constructor_elt (v, aggr);
2660	v = CONSTRUCTOR_ELTS (base_ce->value);
2661	}
2662
2663	for (i = `0`; vec_safe_iterate (v, i, &ce); ++i)
2664	if (ce->index == field)
2665	return ce;
2666
2667	gcc_unreachable ();
2668	return NULL;
2669	}
2670
2671	/ Some of the expressions fed to the constexpr mechanism are calls to*
2672	constructors, which have type void. In that case, return the type being
2673	initialized by the constructor. /*
2674
2675	static tree
2676	initialized_type (tree t)
2677	{
2678	if (TYPE_P (t))
2679	return t;
2680	tree type = cv_unqualified (TREE_TYPE (t));
2681	if (TREE_CODE (t) == CALL_EXPR \|\| TREE_CODE (t) == AGGR_INIT_EXPR)
2682	{
2683	/ A constructor call has void type, so we need to look deeper. /
2684	tree fn = get_function_named_in_call (t);
2685	if (fn && TREE_CODE (fn) == FUNCTION_DECL
2686	&& DECL_CXX_CONSTRUCTOR_P (fn))
2687	type = DECL_CONTEXT (fn);
2688	}
2689	return type;
2690	}
2691
2692	/ We're about to initialize element INDEX of an array or class from VALUE.*
2693	Set up NEW_CTX appropriately by adjusting .object to refer to the
2694	subobject and creating a new CONSTRUCTOR if the element is itself
2695	a class or array. /*
2696
2697	static void
2698	init_subob_ctx (const constexpr_ctx *ctx, constexpr_ctx &new_ctx,
2699	tree index, tree &value)
2700	{
2701	new_ctx = *ctx;
2702
2703	if (index && TREE_CODE (index) != INTEGER_CST
2704	&& TREE_CODE (index) != FIELD_DECL)
2705	/ This won't have an element in the new CONSTRUCTOR. /
2706	return;
2707
2708	tree type = initialized_type (value);
2709	if (!AGGREGATE_TYPE_P (type) && !VECTOR_TYPE_P (type))
2710	/ A non-aggregate member doesn't get its own CONSTRUCTOR. /
2711	return;
2712
2713	/ The sub-aggregate initializer might contain a placeholder;*
2714	update object to refer to the subobject and ctor to refer to
2715	the (newly created) sub-initializer. /*
2716	if (ctx->object)
2717	new_ctx.object = build_ctor_subob_ref (index, type, ctx->object);
2718	tree elt = build_constructor (type, NULL);
2719	CONSTRUCTOR_NO_IMPLICIT_ZERO (elt) = true;
2720	new_ctx.ctor = elt;
2721
2722	if (TREE_CODE (value) == TARGET_EXPR)
2723	/ Avoid creating another CONSTRUCTOR when we expand the TARGET_EXPR. /
2724	value = TARGET_EXPR_INITIAL (value);
2725	}
2726
2727	/ We're about to process an initializer for a class or array TYPE. Make*
2728	sure that CTX is set up appropriately. /*
2729
2730	static void
2731	verify_ctor_sanity (const constexpr_ctx *ctx, tree type)
2732	{
2733	/ We don't bother building a ctor for an empty base subobject. /
2734	if (is_empty_class (type))
2735	return;
2736
2737	/ We're in the middle of an initializer that might involve placeholders;*
2738	our caller should have created a CONSTRUCTOR for us to put the
2739	initializer into. We will either return that constructor or T. /*
2740	gcc_assert (ctx->ctor);
2741	gcc_assert (same_type_ignoring_top_level_qualifiers_p
2742	(type, TREE_TYPE (ctx->ctor)));
2743	/ We used to check that ctx->ctor was empty, but that isn't the case when*
2744	the object is zero-initialized before calling the constructor. /*
2745	if (ctx->object)
2746	{
2747	tree otype = TREE_TYPE (ctx->object);
2748	gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, otype)
2749	/ Handle flexible array members. /
2750	\|\| (TREE_CODE (otype) == ARRAY_TYPE
2751	&& TYPE_DOMAIN (otype) == NULL_TREE
2752	&& TREE_CODE (type) == ARRAY_TYPE
2753	&& (same_type_ignoring_top_level_qualifiers_p
2754	(TREE_TYPE (type), TREE_TYPE (otype)))));
2755	}
2756	gcc_assert (!ctx->object \|\| !DECL_P (ctx->object)
2757	\|\| *(ctx->values->get (ctx->object)) == ctx->ctor);
2758	}
2759
2760	/ Subroutine of cxx_eval_constant_expression.*
2761	The expression tree T denotes a C-style array or a C-style
2762	aggregate. Reduce it to a constant expression. /*
2763
2764	static tree
2765	cxx_eval_bare_aggregate (const constexpr_ctx *ctx, tree t,
2766	bool lval,
2767	bool non_constant_p, bool* *overflow_p)
2768	{
2769	vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
2770	bool changed = false;
2771	gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t));
2772	tree type = TREE_TYPE (t);
2773
2774	constexpr_ctx new_ctx;
2775	if (TYPE_PTRMEMFUNC_P (type) \|\| VECTOR_TYPE_P (type))
2776	{
2777	/ We don't really need the ctx->ctor business for a PMF or*
2778	vector, but it's simpler to use the same code. /*
2779	new_ctx = *ctx;
2780	new_ctx.ctor = build_constructor (type, NULL);
2781	new_ctx.object = NULL_TREE;
2782	ctx = &new_ctx;
2783	};
2784	verify_ctor_sanity (ctx, type);
2785	vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor);
2786	vec_alloc (*p, vec_safe_length (v));
2787
2788	unsigned i;
2789	tree index, value;
2790	bool constant_p = true;
2791	bool side_effects_p = false;
2792	FOR_EACH_CONSTRUCTOR_ELT (v, i, index, value)
2793	{
2794	tree orig_value = value;
2795	init_subob_ctx (ctx, new_ctx, index, value);
2796	if (new_ctx.ctor != ctx->ctor)
2797	/ If we built a new CONSTRUCTOR, attach it now so that other*
2798	initializers can refer to it. /*
2799	CONSTRUCTOR_APPEND_ELT (*p, index, new_ctx.ctor);
2800	tree elt = cxx_eval_constant_expression (&new_ctx, value,
2801	lval,
2802	non_constant_p, overflow_p);
2803	/ Don't VERIFY_CONSTANT here. /
2804	if (ctx->quiet && *non_constant_p)
2805	break;
2806	if (elt != orig_value)
2807	changed = true;
2808
2809	if (!TREE_CONSTANT (elt))
2810	constant_p = false;
2811	if (TREE_SIDE_EFFECTS (elt))
2812	side_effects_p = true;
2813	if (index && TREE_CODE (index) == COMPONENT_REF)
2814	{
2815	/ This is an initialization of a vfield inside a base*
2816	subaggregate that we already initialized; push this
2817	initialization into the previous initialization. /*
2818	constructor_elt inner = base_field_constructor_elt (p, index);
2819	inner->value = elt;
2820	changed = true;
2821	}
2822	else if (index
2823	&& (TREE_CODE (index) == NOP_EXPR
2824	\|\| TREE_CODE (index) == POINTER_PLUS_EXPR))
2825	{
2826	/ This is an initializer for an empty base; now that we've*
2827	checked that it's constant, we can ignore it. /*
2828	gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (index))));
2829	changed = true;
2830	}
2831	else if (new_ctx.ctor != ctx->ctor)
2832	{
2833	/ We appended this element above; update the value. /
2834	gcc_assert ((*p)->last().index == index);
2835	(*p)->last().value = elt;
2836	}
2837	else
2838	CONSTRUCTOR_APPEND_ELT (*p, index, elt);
2839	}
2840	if (*non_constant_p \|\| !changed)
2841	return t;
2842	t = ctx->ctor;
2843	/ We're done building this CONSTRUCTOR, so now we can interpret an*
2844	element without an explicit initializer as value-initialized. /*
2845	CONSTRUCTOR_NO_IMPLICIT_ZERO (t) = false;
2846	TREE_CONSTANT (t) = constant_p;
2847	TREE_SIDE_EFFECTS (t) = side_effects_p;
2848	if (VECTOR_TYPE_P (type))
2849	t = fold (t);
2850	return t;
2851	}
2852
2853	/ Subroutine of cxx_eval_constant_expression.*
2854	The expression tree T is a VEC_INIT_EXPR which denotes the desired
2855	initialization of a non-static data member of array type. Reduce it to a
2856	CONSTRUCTOR.
2857
2858	Note that apart from value-initialization (when VALUE_INIT is true),
2859	this is only intended to support value-initialization and the
2860	initializations done by defaulted constructors for classes with
2861	non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
2862	will either be NULL_TREE for the default constructor, or a COMPONENT_REF
2863	for the copy/move constructor. /*
2864
2865	static tree
2866	cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init,
2867	bool value_init, bool lval,
2868	bool non_constant_p, bool* *overflow_p)
2869	{
2870	tree elttype = TREE_TYPE (atype);
2871	unsigned HOST_WIDE_INT max = tree_to_uhwi (array_type_nelts_top (atype));
2872	verify_ctor_sanity (ctx, atype);
2873	vec<constructor_elt, va_gc> **p = &CONSTRUCTOR_ELTS (ctx->ctor);
2874	vec_alloc (*p, max + `1`);
2875	bool pre_init = false;
2876	unsigned HOST_WIDE_INT i;
2877
2878	/ For the default constructor, build up a call to the default*
2879	constructor of the element type. We only need to handle class types
2880	here, as for a constructor to be constexpr, all members must be
2881	initialized, which for a defaulted default constructor means they must
2882	be of a class type with a constexpr default constructor. /*
2883	if (TREE_CODE (elttype) == ARRAY_TYPE)
2884	/ We only do this at the lowest level. /;
2885	else if (value_init)
2886	{
2887	init = build_value_init (elttype, tf_warning_or_error);
2888	pre_init = true;
2889	}
2890	else if (!init)
2891	{
2892	vec<tree, va_gc> *argvec = make_tree_vector ();
2893	init = build_special_member_call (NULL_TREE, complete_ctor_identifier,
2894	&argvec, elttype, LOOKUP_NORMAL,
2895	tf_warning_or_error);
2896	release_tree_vector (argvec);
2897	init = build_aggr_init_expr (TREE_TYPE (init), init);
2898	pre_init = true;
2899	}
2900
2901	for (i = `0`; i < max; ++i)
2902	{
2903	tree idx = build_int_cst (size_type_node, i);
2904	tree eltinit;
2905	bool reuse = false;
2906	constexpr_ctx new_ctx;
2907	init_subob_ctx (ctx, new_ctx, idx, pre_init ? init : elttype);
2908	if (new_ctx.ctor != ctx->ctor)
2909	CONSTRUCTOR_APPEND_ELT (*p, idx, new_ctx.ctor);
2910	if (TREE_CODE (elttype) == ARRAY_TYPE)
2911	{
2912	/ A multidimensional array; recurse. /
2913	if (value_init \|\| init == NULL_TREE)
2914	{
2915	eltinit = NULL_TREE;
2916	reuse = i == `0`;
2917	}
2918	else
2919	eltinit = cp_build_array_ref (input_location, init, idx,
2920	tf_warning_or_error);
2921	eltinit = cxx_eval_vec_init_1 (&new_ctx, elttype, eltinit, value_init,
2922	lval,
2923	non_constant_p, overflow_p);
2924	}
2925	else if (pre_init)
2926	{
2927	/ Initializing an element using value or default initialization*
2928	we just pre-built above. /*
2929	eltinit = cxx_eval_constant_expression (&new_ctx, init, lval,
2930	non_constant_p, overflow_p);
2931	reuse = i == `0`;
2932	}
2933	else
2934	{
2935	/ Copying an element. /
2936	gcc_assert (same_type_ignoring_top_level_qualifiers_p
2937	(atype, TREE_TYPE (init)));
2938	eltinit = cp_build_array_ref (input_location, init, idx,
2939	tf_warning_or_error);
2940	if (!lvalue_p (init))
2941	eltinit = move (eltinit);
2942	eltinit = force_rvalue (eltinit, tf_warning_or_error);
2943	eltinit = (cxx_eval_constant_expression
2944	(&new_ctx, eltinit, lval,
2945	non_constant_p, overflow_p));
2946	}
2947	if (*non_constant_p && !ctx->quiet)
2948	break;
2949	if (new_ctx.ctor != ctx->ctor)
2950	{
2951	/ We appended this element above; update the value. /
2952	gcc_assert ((*p)->last().index == idx);
2953	(*p)->last().value = eltinit;
2954	}
2955	else
2956	CONSTRUCTOR_APPEND_ELT (*p, idx, eltinit);
2957	/ Reuse the result of cxx_eval_constant_expression call*
2958	from the first iteration to all others if it is a constant
2959	initializer that doesn't require relocations. /*
2960	if (reuse
2961	&& max > `1`
2962	&& (initializer_constant_valid_p (eltinit, TREE_TYPE (eltinit))
2963	== null_pointer_node))
2964	{
2965	if (new_ctx.ctor != ctx->ctor)
2966	eltinit = new_ctx.ctor;
2967	for (i = `1`; i < max; ++i)
2968	{
2969	idx = build_int_cst (size_type_node, i);
2970	CONSTRUCTOR_APPEND_ELT (*p, idx, unshare_constructor (eltinit));
2971	}
2972	break;
2973	}
2974	}
2975
2976	if (!*non_constant_p)
2977	{
2978	init = ctx->ctor;
2979	CONSTRUCTOR_NO_IMPLICIT_ZERO (init) = false;
2980	}
2981	return init;
2982	}
2983
2984	static tree
2985	cxx_eval_vec_init (const constexpr_ctx *ctx, tree t,
2986	bool lval,
2987	bool non_constant_p, bool* *overflow_p)
2988	{
2989	tree atype = TREE_TYPE (t);
2990	tree init = VEC_INIT_EXPR_INIT (t);
2991	tree r = cxx_eval_vec_init_1 (ctx, atype, init,
2992	VEC_INIT_EXPR_VALUE_INIT (t),
2993	lval, non_constant_p, overflow_p);
2994	if (*non_constant_p)
2995	return t;
2996	else
2997	return r;
2998	}
2999
3000	/ A less strict version of fold_indirect_ref_1, which requires cv-quals to*
3001	match. We want to be less strict for simple & folding; if we have a*
3002	non-const temporary that we access through a const pointer, that should
3003	work. We handle this here rather than change fold_indirect_ref_1
3004	because we're dealing with things like ADDR_EXPR of INTEGER_CST which
3005	don't really make sense outside of constant expression evaluation. Also
3006	we want to allow folding to COMPONENT_REF, which could cause trouble
3007	with TBAA in fold_indirect_ref_1.
3008
3009	Try to keep this function synced with fold_indirect_ref_1. /*
3010
3011	static tree
3012	cxx_fold_indirect_ref (location_t loc, tree type, tree op0, bool *empty_base)
3013	{
3014	tree sub, subtype;
3015
3016	sub = op0;
3017	STRIP_NOPS (sub);
3018	subtype = TREE_TYPE (sub);
3019	if (!POINTER_TYPE_P (subtype))
3020	return NULL_TREE;
3021
3022	if (TREE_CODE (sub) == ADDR_EXPR)
3023	{
3024	tree op = TREE_OPERAND (sub, `0`);
3025	tree optype = TREE_TYPE (op);
3026
3027	/ &CONST_DECL -> to the value of the const decl. /*
3028	if (TREE_CODE (op) == CONST_DECL)
3029	return DECL_INITIAL (op);
3030	/ &p => p; make sure to handle &"str"[cst] here. /
3031	if (same_type_ignoring_top_level_qualifiers_p (optype, type)
3032	/ Also handle the case where the desired type is an array of unknown*
3033	bounds because the variable has had its bounds deduced since the
3034	ADDR_EXPR was created. /*
3035	\|\| (TREE_CODE (type) == ARRAY_TYPE
3036	&& TREE_CODE (optype) == ARRAY_TYPE
3037	&& TYPE_DOMAIN (type) == NULL_TREE
3038	&& same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (optype),
3039	TREE_TYPE (type))))
3040	{
3041	tree fop = fold_read_from_constant_string (op);
3042	if (fop)
3043	return fop;
3044	else
3045	return op;
3046	}
3047	/ (foo )&fooarray => fooarray[0] /
3048	else if (TREE_CODE (optype) == ARRAY_TYPE
3049	&& (same_type_ignoring_top_level_qualifiers_p
3050	(type, TREE_TYPE (optype))))
3051	{
3052	tree type_domain = TYPE_DOMAIN (optype);
3053	tree min_val = size_zero_node;
3054	if (type_domain && TYPE_MIN_VALUE (type_domain))
3055	min_val = TYPE_MIN_VALUE (type_domain);
3056	return build4_loc (loc, ARRAY_REF, type, op, min_val,
3057	NULL_TREE, NULL_TREE);
3058	}
3059	/ (foo )&complexfoo => __real__ complexfoo /
3060	else if (TREE_CODE (optype) == COMPLEX_TYPE
3061	&& (same_type_ignoring_top_level_qualifiers_p
3062	(type, TREE_TYPE (optype))))
3063	return fold_build1_loc (loc, REALPART_EXPR, type, op);
3064	/ (foo )&vectorfoo => BIT_FIELD_REF<vectorfoo,...> /
3065	else if (VECTOR_TYPE_P (optype)
3066	&& (same_type_ignoring_top_level_qualifiers_p
3067	(type, TREE_TYPE (optype))))
3068	{
3069	tree part_width = TYPE_SIZE (type);
3070	tree index = bitsize_int (`0`);
3071	return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, index);
3072	}
3073	/ Also handle conversion to an empty base class, which*
3074	is represented with a NOP_EXPR. /*
3075	else if (is_empty_class (type)
3076	&& CLASS_TYPE_P (optype)
3077	&& DERIVED_FROM_P (type, optype))
3078	{
3079	empty_base = true*;
3080	return op;
3081	}
3082	/ (foo )&struct_with_foo_field => COMPONENT_REF /
3083	else if (RECORD_OR_UNION_TYPE_P (optype))
3084	{
3085	tree field = TYPE_FIELDS (optype);
3086	for (; field; field = DECL_CHAIN (field))
3087	if (TREE_CODE (field) == FIELD_DECL
3088	&& TREE_TYPE (field) != error_mark_node
3089	&& integer_zerop (byte_position (field))
3090	&& (same_type_ignoring_top_level_qualifiers_p
3091	(TREE_TYPE (field), type)))
3092	return fold_build3 (COMPONENT_REF, type, op, field, NULL_TREE);
3093	}
3094	}
3095	else if (TREE_CODE (sub) == POINTER_PLUS_EXPR
3096	&& TREE_CODE (TREE_OPERAND (sub, `1`)) == INTEGER_CST)
3097	{
3098	tree op00 = TREE_OPERAND (sub, `0`);
3099	tree op01 = TREE_OPERAND (sub, `1`);
3100
3101	STRIP_NOPS (op00);
3102	if (TREE_CODE (op00) == ADDR_EXPR)
3103	{
3104	tree op00type;
3105	op00 = TREE_OPERAND (op00, `0`);
3106	op00type = TREE_TYPE (op00);
3107
3108	/ ((foo)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> /*
3109	if (VECTOR_TYPE_P (op00type)
3110	&& (same_type_ignoring_top_level_qualifiers_p
3111	(type, TREE_TYPE (op00type))))
3112	{
3113	HOST_WIDE_INT offset = tree_to_shwi (op01);
3114	tree part_width = TYPE_SIZE (type);
3115	unsigned HOST_WIDE_INT part_widthi = tree_to_shwi (part_width)/BITS_PER_UNIT;
3116	unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
3117	tree index = bitsize_int (indexi);
3118
3119	if (offset / part_widthi < TYPE_VECTOR_SUBPARTS (op00type))
3120	return fold_build3_loc (loc,
3121	BIT_FIELD_REF, type, op00,
3122	part_width, index);
3123
3124	}
3125	/ ((foo)&complexfoo)[1] => __imag__ complexfoo /*
3126	else if (TREE_CODE (op00type) == COMPLEX_TYPE
3127	&& (same_type_ignoring_top_level_qualifiers_p
3128	(type, TREE_TYPE (op00type))))
3129	{
3130	tree size = TYPE_SIZE_UNIT (type);
3131	if (tree_int_cst_equal (size, op01))
3132	return fold_build1_loc (loc, IMAGPART_EXPR, type, op00);
3133	}
3134	/ ((foo )&fooarray)[1] => fooarray[1] /*
3135	else if (TREE_CODE (op00type) == ARRAY_TYPE
3136	&& (same_type_ignoring_top_level_qualifiers_p
3137	(type, TREE_TYPE (op00type))))
3138	{
3139	tree type_domain = TYPE_DOMAIN (op00type);
3140	tree min_val = size_zero_node;
3141	if (type_domain && TYPE_MIN_VALUE (type_domain))
3142	min_val = TYPE_MIN_VALUE (type_domain);
3143	op01 = size_binop_loc (loc, EXACT_DIV_EXPR, op01,
3144	TYPE_SIZE_UNIT (type));
3145	op01 = size_binop_loc (loc, PLUS_EXPR, op01, min_val);
3146	return build4_loc (loc, ARRAY_REF, type, op00, op01,
3147	NULL_TREE, NULL_TREE);
3148	}
3149	/ Also handle conversion to an empty base class, which*
3150	is represented with a NOP_EXPR. /*
3151	else if (is_empty_class (type)
3152	&& CLASS_TYPE_P (op00type)
3153	&& DERIVED_FROM_P (type, op00type))
3154	{
3155	empty_base = true*;
3156	return op00;
3157	}
3158	/ ((foo )&struct_with_foo_field)[1] => COMPONENT_REF /*
3159	else if (RECORD_OR_UNION_TYPE_P (op00type))
3160	{
3161	tree field = TYPE_FIELDS (op00type);
3162	for (; field; field = DECL_CHAIN (field))
3163	if (TREE_CODE (field) == FIELD_DECL
3164	&& TREE_TYPE (field) != error_mark_node
3165	&& tree_int_cst_equal (byte_position (field), op01)
3166	&& (same_type_ignoring_top_level_qualifiers_p
3167	(TREE_TYPE (field), type)))
3168	return fold_build3 (COMPONENT_REF, type, op00,
3169	field, NULL_TREE);
3170	}
3171	}
3172	}
3173	/ (foo )fooarrptr => (fooarrptr)[0] /*
3174	else if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
3175	&& (same_type_ignoring_top_level_qualifiers_p
3176	(type, TREE_TYPE (TREE_TYPE (subtype)))))
3177	{
3178	tree type_domain;
3179	tree min_val = size_zero_node;
3180	tree newsub = cxx_fold_indirect_ref (loc, TREE_TYPE (subtype), sub, NULL);
3181	if (newsub)
3182	sub = newsub;
3183	else
3184	sub = build1_loc (loc, INDIRECT_REF, TREE_TYPE (subtype), sub);
3185	type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
3186	if (type_domain && TYPE_MIN_VALUE (type_domain))
3187	min_val = TYPE_MIN_VALUE (type_domain);
3188	return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
3189	NULL_TREE);
3190	}
3191
3192	return NULL_TREE;
3193	}
3194
3195	static tree
3196	cxx_eval_indirect_ref (const constexpr_ctx *ctx, tree t,
3197	bool lval,
3198	bool non_constant_p, bool* *overflow_p)
3199	{
3200	tree orig_op0 = TREE_OPERAND (t, `0`);
3201	bool empty_base = false;
3202
3203	/ We can handle a MEM_REF like an INDIRECT_REF, if MEM_REF's second*
3204	operand is an integer-zero. Otherwise reject the MEM_REF for now. /*
3205
3206	if (TREE_CODE (t) == MEM_REF
3207	&& (!TREE_OPERAND (t, `1`) \|\| !integer_zerop (TREE_OPERAND (t, `1`))))
3208	{
3209	gcc_assert (ctx->quiet);
3210	non_constant_p = true*;
3211	return t;
3212	}
3213
3214	/ First try to simplify it directly. /
3215	tree r = cxx_fold_indirect_ref (EXPR_LOCATION (t), TREE_TYPE (t), orig_op0,
3216	&empty_base);
3217	if (!r)
3218	{
3219	/ If that didn't work, evaluate the operand first. /
3220	tree op0 = cxx_eval_constant_expression (ctx, orig_op0,
3221	/lval/false, non_constant_p,
3222	overflow_p);
3223	/ Don't VERIFY_CONSTANT here. /
3224	if (*non_constant_p)
3225	return t;
3226
3227	if (!lval && integer_zerop (op0))
3228	{
3229	if (!ctx->quiet)
3230	error ("dereferencing a null pointer");
3231	non_constant_p = true*;
3232	return t;
3233	}
3234
3235	r = cxx_fold_indirect_ref (EXPR_LOCATION (t), TREE_TYPE (t), op0,
3236	&empty_base);
3237	if (r == NULL_TREE)
3238	{
3239	/ We couldn't fold to a constant value. Make sure it's not*
3240	something we should have been able to fold. /*
3241	tree sub = op0;
3242	STRIP_NOPS (sub);
3243	if (TREE_CODE (sub) == ADDR_EXPR)
3244	{
3245	gcc_assert (!same_type_ignoring_top_level_qualifiers_p
3246	(TREE_TYPE (TREE_TYPE (sub)), TREE_TYPE (t)));
3247	/ DR 1188 says we don't have to deal with this. /
3248	if (!ctx->quiet)
3249	error ("accessing value of %qE through a %qT glvalue in a "
3250	"constant expression", build_fold_indirect_ref (sub),
3251	TREE_TYPE (t));
3252	non_constant_p = true*;
3253	return t;
3254	}
3255
3256	if (lval && op0 != orig_op0)
3257	return build1 (INDIRECT_REF, TREE_TYPE (t), op0);
3258	if (!lval)
3259	VERIFY_CONSTANT (t);
3260	return t;
3261	}
3262	}
3263
3264	r = cxx_eval_constant_expression (ctx, r,
3265	lval, non_constant_p, overflow_p);
3266	if (*non_constant_p)
3267	return t;
3268
3269	/ If we're pulling out the value of an empty base, just return an empty*
3270	CONSTRUCTOR. /*
3271	if (empty_base && !lval)
3272	{
3273	r = build_constructor (TREE_TYPE (t), NULL);
3274	TREE_CONSTANT (r) = true;
3275	}
3276
3277	return r;
3278	}
3279
3280	/ Complain about R, a VAR_DECL, not being usable in a constant expression.*
3281	Shared between potential_constant_expression and
3282	cxx_eval_constant_expression. /*
3283
3284	static void
3285	non_const_var_error (tree r)
3286	{
3287	tree type = TREE_TYPE (r);
3288	error ("the value of %qD is not usable in a constant "
3289	"expression", r);
3290	/ Avoid error cascade. /
3291	if (DECL_INITIAL (r) == error_mark_node)
3292	return;
3293	if (DECL_DECLARED_CONSTEXPR_P (r))
3294	inform (DECL_SOURCE_LOCATION (r),
3295	"%qD used in its own initializer", r);
3296	else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
3297	{
3298	if (!CP_TYPE_CONST_P (type))
3299	inform (DECL_SOURCE_LOCATION (r),
3300	"%q#D is not const", r);
3301	else if (CP_TYPE_VOLATILE_P (type))
3302	inform (DECL_SOURCE_LOCATION (r),
3303	"%q#D is volatile", r);
3304	else if (!DECL_INITIAL (r)
3305	\|\| !TREE_CONSTANT (DECL_INITIAL (r))
3306	\|\| !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r))
3307	inform (DECL_SOURCE_LOCATION (r),
3308	"%qD was not initialized with a constant "
3309	"expression", r);
3310	else
3311	gcc_unreachable ();
3312	}
3313	else if (TREE_CODE (type) == REFERENCE_TYPE)
3314	inform (DECL_SOURCE_LOCATION (r),
3315	"%qD was not initialized with a constant "
3316	"expression", r);
3317	else
3318	{
3319	if (cxx_dialect >= cxx11 && !DECL_DECLARED_CONSTEXPR_P (r))
3320	inform (DECL_SOURCE_LOCATION (r),
3321	"%qD was not declared %<constexpr%>", r);
3322	else
3323	inform (DECL_SOURCE_LOCATION (r),
3324	"%qD does not have integral or enumeration type",
3325	r);
3326	}
3327	}
3328
3329	/ Subroutine of cxx_eval_constant_expression.*
3330	Like cxx_eval_unary_expression, except for trinary expressions. /*
3331
3332	static tree
3333	cxx_eval_trinary_expression (const constexpr_ctx *ctx, tree t,
3334	bool lval,
3335	bool non_constant_p, bool* *overflow_p)
3336	{
3337	int i;
3338	tree args[`3`];
3339	tree val;
3340
3341	for (i = `0`; i < `3`; i++)
3342	{
3343	args[i] = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, i),
3344	lval,
3345	non_constant_p, overflow_p);
3346	VERIFY_CONSTANT (args[i]);
3347	}
3348
3349	val = fold_ternary_loc (EXPR_LOCATION (t), TREE_CODE (t), TREE_TYPE (t),
3350	args[`0`], args[`1`], args[`2`]);
3351	if (val == NULL_TREE)
3352	return t;
3353	VERIFY_CONSTANT (val);
3354	return val;
3355	}
3356
3357	/ True if T was declared in a function declared to be constexpr, and*
3358	therefore potentially constant in C++14. /*
3359
3360	bool
3361	var_in_constexpr_fn (tree t)
3362	{
3363	tree ctx = DECL_CONTEXT (t);
3364	return (ctx && TREE_CODE (ctx) == FUNCTION_DECL
3365	&& DECL_DECLARED_CONSTEXPR_P (ctx));
3366	}
3367
3368	/ True if T was declared in a function that might be constexpr: either a*
3369	function that was declared constexpr, or a C++17 lambda op(). /*
3370
3371	bool
3372	var_in_maybe_constexpr_fn (tree t)
3373	{
3374	if (cxx_dialect >= cxx17
3375	&& DECL_FUNCTION_SCOPE_P (t)
3376	&& LAMBDA_FUNCTION_P (DECL_CONTEXT (t)))
3377	return true;
3378	return var_in_constexpr_fn (t);
3379	}
3380
3381	/ We're assigning INIT to TARGET. In do_build_copy_constructor and*
3382	build_over_call we implement trivial copy of a class with tail padding using
3383	assignment of character arrays, which is valid in normal code, but not in
3384	constexpr evaluation. We don't need to worry about clobbering tail padding
3385	in constexpr evaluation, so strip the type punning. /*
3386
3387	static void
3388	maybe_simplify_trivial_copy (tree &target, tree &init)
3389	{
3390	if (TREE_CODE (target) == MEM_REF
3391	&& TREE_CODE (init) == MEM_REF
3392	&& TREE_TYPE (target) == TREE_TYPE (init)
3393	&& TREE_CODE (TREE_TYPE (target)) == ARRAY_TYPE
3394	&& TREE_TYPE (TREE_TYPE (target)) == unsigned_char_type_node)
3395	{
3396	target = build_fold_indirect_ref (TREE_OPERAND (target, `0`));
3397	init = build_fold_indirect_ref (TREE_OPERAND (init, `0`));
3398	}
3399	}
3400
3401	/ Evaluate an INIT_EXPR or MODIFY_EXPR. /
3402
3403	static tree
3404	cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
3405	bool lval,
3406	bool non_constant_p, bool* *overflow_p)
3407	{
3408	constexpr_ctx new_ctx = *ctx;
3409
3410	tree init = TREE_OPERAND (t, `1`);
3411	if (TREE_CLOBBER_P (init))
3412	/ Just ignore clobbers. /
3413	return void_node;
3414
3415	/ First we figure out where we're storing to. /
3416	tree target = TREE_OPERAND (t, `0`);
3417
3418	maybe_simplify_trivial_copy (target, init);
3419
3420	tree type = TREE_TYPE (target);
3421	target = cxx_eval_constant_expression (ctx, target,
3422	true,
3423	non_constant_p, overflow_p);
3424	if (*non_constant_p)
3425	return t;
3426
3427	/ cxx_eval_array_reference for lval = true allows references one past*
3428	end of array, because it does not know if it is just taking address
3429	(which is valid), or actual dereference. Here we know it is
3430	a dereference, so diagnose it here. /*
3431	for (tree probe = target; probe; )
3432	{
3433	switch (TREE_CODE (probe))
3434	{
3435	case ARRAY_REF:
3436	tree nelts, ary;
3437	ary = TREE_OPERAND (probe, `0`);
3438	if (TREE_CODE (TREE_TYPE (ary)) == ARRAY_TYPE)
3439	nelts = array_type_nelts_top (TREE_TYPE (ary));
3440	else if (VECTOR_TYPE_P (TREE_TYPE (ary)))
3441	nelts = size_int (TYPE_VECTOR_SUBPARTS (TREE_TYPE (ary)));
3442	else
3443	gcc_unreachable ();
3444	nelts = cxx_eval_constant_expression (ctx, nelts, false,
3445	non_constant_p, overflow_p);
3446	VERIFY_CONSTANT (nelts);
3447	gcc_assert (TREE_CODE (nelts) == INTEGER_CST
3448	&& TREE_CODE (TREE_OPERAND (probe, `1`)) == INTEGER_CST);
3449	if (wi::to_widest (TREE_OPERAND (probe, `1`)) == wi::to_widest (nelts))
3450	{
3451	diag_array_subscript (ctx, ary, TREE_OPERAND (probe, `1`));
3452	non_constant_p = true*;
3453	return t;
3454	}
3455	/ FALLTHRU /
3456
3457	case BIT_FIELD_REF:
3458	case COMPONENT_REF:
3459	probe = TREE_OPERAND (probe, `0`);
3460	continue;
3461
3462	default:
3463	probe = NULL_TREE;
3464	continue;
3465	}
3466	}
3467
3468	if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (target), type))
3469	{
3470	/ For initialization of an empty base, the original target will be*
3471	(base)this, which the above evaluation resolves to the object
3472	argument, which has the derived type rather than the base type. In
3473	this situation, just evaluate the initializer and return, since
3474	there's no actual data to store. /*
3475	gcc_assert (is_empty_class (type));
3476	return cxx_eval_constant_expression (ctx, init, false,
3477	non_constant_p, overflow_p);
3478	}
3479
3480	/ And then find the underlying variable. /
3481	vec<tree,va_gc> *refs = make_tree_vector();
3482	tree object = NULL_TREE;
3483	for (tree probe = target; object == NULL_TREE; )
3484	{
3485	switch (TREE_CODE (probe))
3486	{
3487	case BIT_FIELD_REF:
3488	case COMPONENT_REF:
3489	case ARRAY_REF:
3490	vec_safe_push (refs, TREE_OPERAND (probe, `1`));
3491	vec_safe_push (refs, TREE_TYPE (probe));
3492	probe = TREE_OPERAND (probe, `0`);
3493	break;
3494
3495	default:
3496	object = probe;
3497	}
3498	}
3499
3500	/ And then find/build up our initializer for the path to the subobject*
3501	we're initializing. /*
3502	tree *valp;
3503	if (object == ctx->object && VAR_P (object)
3504	&& DECL_NAME (object) && ctx->call == NULL)
3505	/ The variable we're building up an aggregate initializer for is outside*
3506	the constant-expression, so don't evaluate the store. We check
3507	DECL_NAME to handle TARGET_EXPR temporaries, which are fair game. /*
3508	valp = NULL;
3509	else if (DECL_P (object))
3510	valp = ctx->values->get (object);
3511	else
3512	valp = NULL;
3513	if (!valp)
3514	{
3515	/ A constant-expression cannot modify objects from outside the*
3516	constant-expression. /*
3517	if (!ctx->quiet)
3518	error ("modification of %qE is not a constant expression", object);
3519	non_constant_p = true*;
3520	return t;
3521	}
3522	type = TREE_TYPE (object);
3523	bool no_zero_init = true;
3524
3525	vec<tree,va_gc> *ctors = make_tree_vector ();
3526	while (!refs->is_empty())
3527	{
3528	if (*valp == NULL_TREE)
3529	{
3530	*valp = build_constructor (type, NULL);
3531	CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp) = no_zero_init;
3532	}
3533	else if (TREE_CODE (*valp) == STRING_CST)
3534	{
3535	/ An array was initialized with a string constant, and now*
3536	we're writing into one of its elements. Explode the
3537	single initialization into a set of element
3538	initializations. /*
3539	gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
3540
3541	tree string = *valp;
3542	tree elt_type = TREE_TYPE (type);
3543	unsigned chars_per_elt = (TYPE_PRECISION (elt_type)
3544	/ TYPE_PRECISION (char_type_node));
3545	unsigned num_elts = TREE_STRING_LENGTH (string) / chars_per_elt;
3546	tree ary_ctor = build_constructor (type, NULL);
3547
3548	vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor), num_elts);
3549	for (unsigned ix = `0`; ix != num_elts; ix++)
3550	{
3551	constructor_elt elt =
3552	{
3553	build_int_cst (size_type_node, ix),
3554	extract_string_elt (string, chars_per_elt, ix)
3555	};
3556	CONSTRUCTOR_ELTS (ary_ctor)->quick_push (elt);
3557	}
3558
3559	*valp = ary_ctor;
3560	}
3561
3562	/ If the value of object is already zero-initialized, any new ctors for*
3563	subobjects will also be zero-initialized. /*
3564	no_zero_init = CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp);
3565
3566	vec_safe_push (ctors, *valp);
3567
3568	enum tree_code code = TREE_CODE (type);
3569	type = refs->pop();
3570	tree index = refs->pop();
3571
3572	constructor_elt *cep = NULL;
3573	if (code == ARRAY_TYPE)
3574	{
3575	HOST_WIDE_INT i
3576	= find_array_ctor_elt (valp, index, /insert/*true);
3577	gcc_assert (i >= `0`);
3578	cep = CONSTRUCTOR_ELT (*valp, i);
3579	gcc_assert (TREE_CODE (cep->index) != RANGE_EXPR);
3580	}
3581	else
3582	{
3583	gcc_assert (TREE_CODE (index) == FIELD_DECL);
3584
3585	/ We must keep the CONSTRUCTOR's ELTS in FIELD order.*
3586	Usually we meet initializers in that order, but it is
3587	possible for base types to be placed not in program
3588	order. /*
3589	tree fields = TYPE_FIELDS (DECL_CONTEXT (index));
3590	unsigned HOST_WIDE_INT idx;
3591
3592	if (code == UNION_TYPE && CONSTRUCTOR_NELTS (*valp)
3593	&& CONSTRUCTOR_ELT (*valp, `0`)->index != index)
3594	/ Changing active member. /
3595	vec_safe_truncate (CONSTRUCTOR_ELTS (*valp), `0`);
3596
3597	for (idx = `0`;
3598	vec_safe_iterate (CONSTRUCTOR_ELTS (*valp), idx, &cep);
3599	idx++, fields = DECL_CHAIN (fields))
3600	{
3601	if (index == cep->index)
3602	goto found;
3603
3604	/ The field we're initializing must be on the field*
3605	list. Look to see if it is present before the
3606	field the current ELT initializes. /*
3607	for (; fields != cep->index; fields = DECL_CHAIN (fields))
3608	if (index == fields)
3609	goto insert;
3610	}
3611
3612	/ We fell off the end of the CONSTRUCTOR, so insert a new*
3613	entry at the end. /*
3614	insert:
3615	{
3616	constructor_elt ce = { index, NULL_TREE };
3617
3618	vec_safe_insert (CONSTRUCTOR_ELTS (*valp), idx, ce);
3619	cep = CONSTRUCTOR_ELT (*valp, idx);
3620	}
3621	found:;
3622	}
3623	valp = &cep->value;
3624	}
3625	release_tree_vector (refs);
3626
3627	if (AGGREGATE_TYPE_P (type) \|\| VECTOR_TYPE_P (type))
3628	{
3629	/ Create a new CONSTRUCTOR in case evaluation of the initializer*
3630	wants to modify it. /*
3631	if (*valp == NULL_TREE)
3632	{
3633	*valp = build_constructor (type, NULL);
3634	CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp) = no_zero_init;
3635	}
3636	else if (TREE_CODE (*valp) == PTRMEM_CST)
3637	valp = cplus_expand_constant (valp);
3638	new_ctx.ctor = *valp;
3639	new_ctx.object = target;
3640	}
3641
3642	init = cxx_eval_constant_expression (&new_ctx, init, false,
3643	non_constant_p, overflow_p);
3644	/ Don't share a CONSTRUCTOR that might be changed later. /
3645	init = unshare_constructor (init);
3646	if (target == object)
3647	/ The hash table might have moved since the get earlier. /
3648	valp = ctx->values->get (object);
3649
3650	if (TREE_CODE (init) == CONSTRUCTOR)
3651	{
3652	/ An outer ctx->ctor might be pointing to valp, so replace
3653	its contents. /*
3654	CONSTRUCTOR_ELTS (*valp) = CONSTRUCTOR_ELTS (init);
3655	TREE_CONSTANT (*valp) = TREE_CONSTANT (init);
3656	TREE_SIDE_EFFECTS (*valp) = TREE_SIDE_EFFECTS (init);
3657	CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp)
3658	= CONSTRUCTOR_NO_IMPLICIT_ZERO (init);
3659	}
3660	else
3661	*valp = init;
3662
3663	/ Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing*
3664	CONSTRUCTORs, if any. /*
3665	tree elt;
3666	unsigned i;
3667	bool c = TREE_CONSTANT (init);
3668	bool s = TREE_SIDE_EFFECTS (init);
3669	if (!c \|\| s)
3670	FOR_EACH_VEC_SAFE_ELT (ctors, i, elt)
3671	{
3672	if (!c)
3673	TREE_CONSTANT (elt) = false;
3674	if (s)
3675	TREE_SIDE_EFFECTS (elt) = true;
3676	}
3677	release_tree_vector (ctors);
3678
3679	if (*non_constant_p)
3680	return t;
3681	else if (lval)
3682	return target;
3683	else
3684	return init;
3685	}
3686
3687	/ Evaluate a ++ or -- expression. /
3688
3689	static tree
3690	cxx_eval_increment_expression (const constexpr_ctx *ctx, tree t,
3691	bool lval,
3692	bool non_constant_p, bool* *overflow_p)
3693	{
3694	enum tree_code code = TREE_CODE (t);
3695	tree type = TREE_TYPE (t);
3696	tree op = TREE_OPERAND (t, `0`);
3697	tree offset = TREE_OPERAND (t, `1`);
3698	gcc_assert (TREE_CONSTANT (offset));
3699
3700	/ The operand as an lvalue. /
3701	op = cxx_eval_constant_expression (ctx, op, true,
3702	non_constant_p, overflow_p);
3703
3704	/ The operand as an rvalue. /
3705	tree val
3706	= cxx_eval_constant_expression (ctx, op, false,
3707	non_constant_p, overflow_p);
3708	/ Don't VERIFY_CONSTANT if this might be dealing with a pointer to*
3709	a local array in a constexpr function. /*
3710	bool ptr = POINTER_TYPE_P (TREE_TYPE (val));
3711	if (!ptr)
3712	VERIFY_CONSTANT (val);
3713
3714	/ The modified value. /
3715	bool inc = (code ==

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