cp-tree.h source code [gcc/cp/cp-tree.h]

1	/ Definitions for -- C++ -- parsing and type checking.*
2	Copyright (C) 1987-2026 Free Software Foundation, Inc.
3	Contributed by Michael Tiemann (tiemann@cygnus.com)
4
5	This file is part of GCC.
6
7	GCC is free software; you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by
9	the Free Software Foundation; either version 3, or (at your option)
10	any later version.
11
12	GCC is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.
16
17	You should have received a copy of the GNU General Public License
18	along with GCC; see the file COPYING3. If not see
19	<http://www.gnu.org/licenses/>. /*
20
21	#ifndef GCC_CP_TREE_H
22	#define GCC_CP_TREE_H
23
24	#include "tm.h"
25	#include "hard-reg-set.h"
26	#include "function.h"
27	#include "tristate.h"
28
29	/ In order for the format checking to accept the C++ front end*
30	diagnostic framework extensions, you must include this file before
31	diagnostic-core.h, not after. We override the definition of GCC_DIAG_STYLE
32	in c-common.h. /*
33	#undef GCC_DIAG_STYLE
34	#define GCC_DIAG_STYLE __gcc_cxxdiag__
35	#if defined(GCC_DIAGNOSTIC_CORE_H) \|\| defined (GCC_C_COMMON_H)
36	#error \
37	In order for the format checking to accept the C++ front end diagnostic \
38	framework extensions, you must include this file before diagnostic-core.h and \
39	c-common.h, not after.
40	#endif
41	#include "c-family/c-common.h"
42	#include "diagnostic.h"
43
44	/ A tree node, together with a location, so that we can track locations*
45	(and ranges) during parsing.
46
47	The location is redundant for node kinds that have locations,
48	but not all node kinds do (e.g. constants, and references to
49	params, locals, etc), so we stash a copy here. /*
50
51	inline location_t cp_expr_location (const_tree);
52
53	class cp_expr
54	{
55	public:
56	cp_expr () :
57	m_value (NULL), m_loc (UNKNOWN_LOCATION),
58	m_decimal (false)
59	{}
60
61	cp_expr (tree value) :
62	m_value (value), m_loc (cp_expr_location (m_value)),
63	m_decimal (false)
64	{}
65
66	cp_expr (tree value, location_t loc):
67	m_value (value), m_loc (loc), m_decimal (false)
68	{
69	protected_set_expr_location (value, loc);
70	}
71
72	cp_expr (tree value, location_t loc, bool decimal):
73	m_value (value), m_loc (loc), m_decimal (decimal)
74	{
75	protected_set_expr_location (value, loc);
76	}
77
78	/ Implicit conversions to tree. /
79	operator tree () const { return m_value; }
80	tree & operator* () { return m_value; }
81	tree operator* () const { return m_value; }
82	tree & operator-> () { return m_value; }
83	tree operator-> () const { return m_value; }
84
85	tree get_value () const { return m_value; }
86	location_t get_location () const { return m_loc; }
87	location_t get_start () const
88	{
89	source_range src_range = get_range_from_loc (set: line_table, loc: m_loc);
90	return src_range.m_start;
91	}
92	location_t get_finish () const
93	{
94	source_range src_range = get_range_from_loc (set: line_table, loc: m_loc);
95	return src_range.m_finish;
96	}
97
98	void set_location (location_t loc)
99	{
100	protected_set_expr_location (m_value, loc);
101	m_loc = loc;
102	}
103
104	void set_range (location_t start, location_t finish)
105	{
106	set_location (make_location (caret: m_loc, start, finish));
107	}
108
109	cp_expr& maybe_add_location_wrapper ()
110	{
111	m_value = maybe_wrap_with_location (m_value, m_loc);
112	return *this;
113	}
114
115	bool decimal_p () const { return m_decimal; }
116
117	private:
118	tree m_value;
119	location_t m_loc;
120	bool m_decimal : `1`;
121	};
122
123	inline bool
124	operator == (const cp_expr &lhs, tree rhs)
125	{
126	return lhs.get_value () == rhs;
127	}
128
129
130	enum cp_tree_index
131	{
132	CPTI_WCHAR_DECL,
133	CPTI_VTABLE_ENTRY_TYPE,
134	CPTI_DELTA_TYPE,
135	CPTI_VTABLE_INDEX_TYPE,
136	CPTI_CLEANUP_TYPE,
137	CPTI_VTT_PARM_TYPE,
138
139	CPTI_CLASS_TYPE,
140	CPTI_UNKNOWN_TYPE,
141	CPTI_INIT_LIST_TYPE,
142	CPTI_EXPLICIT_VOID_LIST,
143	CPTI_VTBL_TYPE,
144	CPTI_VTBL_PTR_TYPE,
145	CPTI_GLOBAL,
146	CPTI_ABORT_FNDECL,
147	CPTI_AGGR_TAG,
148	CPTI_CONV_OP_MARKER,
149
150	CPTI_CTOR_IDENTIFIER,
151	CPTI_COMPLETE_CTOR_IDENTIFIER,
152	CPTI_BASE_CTOR_IDENTIFIER,
153	CPTI_DTOR_IDENTIFIER,
154	CPTI_COMPLETE_DTOR_IDENTIFIER,
155	CPTI_BASE_DTOR_IDENTIFIER,
156	CPTI_DELETING_DTOR_IDENTIFIER,
157	CPTI_CONV_OP_IDENTIFIER,
158	CPTI_DELTA_IDENTIFIER,
159	CPTI_IN_CHARGE_IDENTIFIER,
160	CPTI_VTT_PARM_IDENTIFIER,
161	CPTI_AS_BASE_IDENTIFIER,
162	CPTI_THIS_IDENTIFIER,
163	CPTI_PFN_IDENTIFIER,
164	CPTI_VPTR_IDENTIFIER,
165	CPTI_GLOBAL_IDENTIFIER,
166	CPTI_ANON_IDENTIFIER,
167	CPTI_AUTO_IDENTIFIER,
168	CPTI_DECLTYPE_AUTO_IDENTIFIER,
169	CPTI_INIT_LIST_IDENTIFIER,
170	CPTI_FOR_RANGE__IDENTIFIER,
171	CPTI_FOR_BEGIN__IDENTIFIER,
172	CPTI_FOR_END__IDENTIFIER,
173	CPTI_FOR_RANGE_IDENTIFIER,
174	CPTI_FOR_BEGIN_IDENTIFIER,
175	CPTI_FOR_END_IDENTIFIER,
176	CPTI_ABI_TAG_IDENTIFIER,
177	CPTI_ALIGNED_IDENTIFIER,
178	CPTI_ANNOTATION_IDENTIFIER,
179	CPTI_BEGIN_IDENTIFIER,
180	CPTI_END_IDENTIFIER,
181	CPTI_GET_IDENTIFIER,
182	CPTI_GNU_IDENTIFIER,
183	CPTI_TUPLE_ELEMENT_IDENTIFIER,
184	CPTI_TUPLE_SIZE_IDENTIFIER,
185	CPTI_TYPE_IDENTIFIER,
186	CPTI_VALUE_IDENTIFIER,
187	CPTI_FUN_IDENTIFIER,
188	CPTI_CLOSURE_IDENTIFIER,
189	CPTI_HEAP_UNINIT_IDENTIFIER,
190	CPTI_HEAP_IDENTIFIER,
191	CPTI_HEAP_DELETED_IDENTIFIER,
192	CPTI_HEAP_VEC_UNINIT_IDENTIFIER,
193	CPTI_HEAP_VEC_IDENTIFIER,
194	CPTI_OMP_IDENTIFIER,
195	CPTI_INTERNAL_IDENTIFIER,
196
197	CPTI_LANG_NAME_C,
198	CPTI_LANG_NAME_CPLUSPLUS,
199
200	CPTI_EMPTY_EXCEPT_SPEC,
201	CPTI_NOEXCEPT_TRUE_SPEC,
202	CPTI_NOEXCEPT_FALSE_SPEC,
203	CPTI_NOEXCEPT_DEFERRED_SPEC,
204
205	CPTI_ANY_TARG,
206
207	CPTI_MODULE_HWM,
208	/ Nodes after here change during compilation, or should not be in*
209	the module's global tree table. Such nodes must be locatable
210	via name lookup or type-construction, as those are the only
211	cross-TU matching capabilities remaining. /*
212
213	/ We must find these via the global namespace. /
214	CPTI_STD,
215	CPTI_STD_META,
216	CPTI_ABI,
217
218	/ These are created at init time, but the library/headers provide*
219	definitions. /*
220	CPTI_ALIGN_TYPE,
221	CPTI_TERMINATE_FN,
222	CPTI_CALL_TERMINATE_FN,
223	CPTI_CALL_UNEXPECTED_FN,
224
225	/ These are lazily inited. /
226	CPTI_CONST_TYPE_INFO_TYPE,
227	CPTI_GET_EXCEPTION_PTR_FN,
228	CPTI_BEGIN_CATCH_FN,
229	CPTI_END_CATCH_FN,
230	CPTI_ALLOCATE_EXCEPTION_FN,
231	CPTI_FREE_EXCEPTION_FN,
232	CPTI_THROW_FN,
233	CPTI_RETHROW_FN,
234	CPTI_ATEXIT_FN_PTR_TYPE,
235	CPTI_ATEXIT,
236	CPTI_THREAD_ATEXIT,
237	CPTI_DSO_HANDLE,
238	CPTI_DCAST,
239	CPTI_META_INFO_TYPE,
240	CPTI_CONTRACT_VIOLATION_TYPE,
241
242	CPTI_MAX
243	};
244
245	extern GTY(()) tree cp_global_trees[CPTI_MAX];
246
247	#define wchar_decl_node cp_global_trees[CPTI_WCHAR_DECL]
248	#define vtable_entry_type cp_global_trees[CPTI_VTABLE_ENTRY_TYPE]
249	/ The type used to represent an offset by which to adjust the `this'*
250	pointer in pointer-to-member types. /*
251	#define delta_type_node cp_global_trees[CPTI_DELTA_TYPE]
252	/ The type used to represent an index into the vtable. /
253	#define vtable_index_type cp_global_trees[CPTI_VTABLE_INDEX_TYPE]
254
255	#define class_type_node cp_global_trees[CPTI_CLASS_TYPE]
256	#define unknown_type_node cp_global_trees[CPTI_UNKNOWN_TYPE]
257	#define init_list_type_node cp_global_trees[CPTI_INIT_LIST_TYPE]
258	#define explicit_void_list_node cp_global_trees[CPTI_EXPLICIT_VOID_LIST]
259	#define vtbl_type_node cp_global_trees[CPTI_VTBL_TYPE]
260	#define vtbl_ptr_type_node cp_global_trees[CPTI_VTBL_PTR_TYPE]
261	#define std_node cp_global_trees[CPTI_STD]
262	#define std_meta_node cp_global_trees[CPTI_STD_META]
263	#define abi_node cp_global_trees[CPTI_ABI]
264	#define global_namespace cp_global_trees[CPTI_GLOBAL]
265	#define const_type_info_type_node cp_global_trees[CPTI_CONST_TYPE_INFO_TYPE]
266	#define conv_op_marker cp_global_trees[CPTI_CONV_OP_MARKER]
267	#define abort_fndecl cp_global_trees[CPTI_ABORT_FNDECL]
268	#define current_aggr cp_global_trees[CPTI_AGGR_TAG]
269	/ std::align_val_t /
270	#define align_type_node cp_global_trees[CPTI_ALIGN_TYPE]
271	#define meta_info_type_node cp_global_trees[CPTI_META_INFO_TYPE]
272	#define builtin_contract_violation_type cp_global_trees[CPTI_CONTRACT_VIOLATION_TYPE]
273
274	/ We cache these tree nodes so as to call get_identifier less frequently.*
275	For identifiers for functions, including special member functions such
276	as ctors and assignment operators, the nodes can be used (among other
277	things) to iterate over their overloads defined by/for a type. For
278	example:
279
280	tree ovlid = assign_op_identifier;
281	tree overloads = get_class_binding (type, ovlid);
282	for (ovl_iterator it (overloads); it; ++it) { ... }
283
284	iterates over the set of implicitly and explicitly defined overloads
285	of the assignment operator for type (including the copy and move
286	assignment operators, whether deleted or not). /*
287
288	/ The name of a constructor that takes an in-charge parameter to*
289	decide whether or not to construct virtual base classes. /*
290	#define ctor_identifier cp_global_trees[CPTI_CTOR_IDENTIFIER]
291	/ The name of a constructor that constructs virtual base classes. /
292	#define complete_ctor_identifier cp_global_trees[CPTI_COMPLETE_CTOR_IDENTIFIER]
293	/ The name of a constructor that does not construct virtual base classes. /
294	#define base_ctor_identifier cp_global_trees[CPTI_BASE_CTOR_IDENTIFIER]
295	/ The name of a destructor that takes an in-charge parameter to*
296	decide whether or not to destroy virtual base classes. /*
297	#define dtor_identifier cp_global_trees[CPTI_DTOR_IDENTIFIER]
298	/ The name of a destructor that destroys virtual base classes. /
299	#define complete_dtor_identifier cp_global_trees[CPTI_COMPLETE_DTOR_IDENTIFIER]
300	/ The name of a destructor that does not destroy virtual base*
301	classes. /*
302	#define base_dtor_identifier cp_global_trees[CPTI_BASE_DTOR_IDENTIFIER]
303	/ The name of a destructor that destroys virtual base classes, and*
304	then deletes the entire object. /*
305	#define deleting_dtor_identifier cp_global_trees[CPTI_DELETING_DTOR_IDENTIFIER]
306
307	/ The name used for conversion operators -- but note that actual*
308	conversion functions use special identifiers outside the identifier
309	table. /*
310	#define conv_op_identifier cp_global_trees[CPTI_CONV_OP_IDENTIFIER]
311
312	#define delta_identifier cp_global_trees[CPTI_DELTA_IDENTIFIER]
313	#define in_charge_identifier cp_global_trees[CPTI_IN_CHARGE_IDENTIFIER]
314	/ The name of the parameter that contains a pointer to the VTT to use*
315	for this subobject constructor or destructor. /*
316	#define vtt_parm_identifier cp_global_trees[CPTI_VTT_PARM_IDENTIFIER]
317	#define as_base_identifier cp_global_trees[CPTI_AS_BASE_IDENTIFIER]
318	#define this_identifier cp_global_trees[CPTI_THIS_IDENTIFIER]
319	#define pfn_identifier cp_global_trees[CPTI_PFN_IDENTIFIER]
320	#define vptr_identifier cp_global_trees[CPTI_VPTR_IDENTIFIER]
321	/ The name of the ::, std & anon namespaces. /
322	#define global_identifier cp_global_trees[CPTI_GLOBAL_IDENTIFIER]
323	#define anon_identifier cp_global_trees[CPTI_ANON_IDENTIFIER]
324	/ auto and declspec(auto) identifiers. /
325	#define auto_identifier cp_global_trees[CPTI_AUTO_IDENTIFIER]
326	#define decltype_auto_identifier cp_global_trees[CPTI_DECLTYPE_AUTO_IDENTIFIER]
327	#define init_list_identifier cp_global_trees[CPTI_INIT_LIST_IDENTIFIER]
328	#define for_range__identifier cp_global_trees[CPTI_FOR_RANGE__IDENTIFIER]
329	#define for_begin__identifier cp_global_trees[CPTI_FOR_BEGIN__IDENTIFIER]
330	#define for_end__identifier cp_global_trees[CPTI_FOR_END__IDENTIFIER]
331	#define for_range_identifier cp_global_trees[CPTI_FOR_RANGE_IDENTIFIER]
332	#define for_begin_identifier cp_global_trees[CPTI_FOR_BEGIN_IDENTIFIER]
333	#define for_end_identifier cp_global_trees[CPTI_FOR_END_IDENTIFIER]
334	#define abi_tag_identifier cp_global_trees[CPTI_ABI_TAG_IDENTIFIER]
335	#define aligned_identifier cp_global_trees[CPTI_ALIGNED_IDENTIFIER]
336	#define annotation_identifier cp_global_trees[CPTI_ANNOTATION_IDENTIFIER]
337	#define begin_identifier cp_global_trees[CPTI_BEGIN_IDENTIFIER]
338	#define end_identifier cp_global_trees[CPTI_END_IDENTIFIER]
339	#define get__identifier cp_global_trees[CPTI_GET_IDENTIFIER]
340	#define gnu_identifier cp_global_trees[CPTI_GNU_IDENTIFIER]
341	#define tuple_element_identifier cp_global_trees[CPTI_TUPLE_ELEMENT_IDENTIFIER]
342	#define tuple_size_identifier cp_global_trees[CPTI_TUPLE_SIZE_IDENTIFIER]
343	#define type_identifier cp_global_trees[CPTI_TYPE_IDENTIFIER]
344	#define value_identifier cp_global_trees[CPTI_VALUE_IDENTIFIER]
345	#define fun_identifier cp_global_trees[CPTI_FUN_IDENTIFIER]
346	#define closure_identifier cp_global_trees[CPTI_CLOSURE_IDENTIFIER]
347	#define heap_uninit_identifier cp_global_trees[CPTI_HEAP_UNINIT_IDENTIFIER]
348	#define heap_identifier cp_global_trees[CPTI_HEAP_IDENTIFIER]
349	#define heap_deleted_identifier cp_global_trees[CPTI_HEAP_DELETED_IDENTIFIER]
350	#define heap_vec_uninit_identifier cp_global_trees[CPTI_HEAP_VEC_UNINIT_IDENTIFIER]
351	#define heap_vec_identifier cp_global_trees[CPTI_HEAP_VEC_IDENTIFIER]
352	#define omp_identifier cp_global_trees[CPTI_OMP_IDENTIFIER]
353	#define internal_identifier cp_global_trees[CPTI_INTERNAL_IDENTIFIER]
354	#define lang_name_c cp_global_trees[CPTI_LANG_NAME_C]
355	#define lang_name_cplusplus cp_global_trees[CPTI_LANG_NAME_CPLUSPLUS]
356
357	/ Exception specifiers used for throw(), noexcept(true),*
358	noexcept(false) and deferred noexcept. We rely on these being
359	uncloned. /*
360	#define empty_except_spec cp_global_trees[CPTI_EMPTY_EXCEPT_SPEC]
361	#define noexcept_true_spec cp_global_trees[CPTI_NOEXCEPT_TRUE_SPEC]
362	#define noexcept_false_spec cp_global_trees[CPTI_NOEXCEPT_FALSE_SPEC]
363	#define noexcept_deferred_spec cp_global_trees[CPTI_NOEXCEPT_DEFERRED_SPEC]
364
365	/ Exception handling function declarations. /
366	#define terminate_fn cp_global_trees[CPTI_TERMINATE_FN]
367	#define call_unexpected_fn cp_global_trees[CPTI_CALL_UNEXPECTED_FN]
368	#define call_terminate_fn cp_global_trees[CPTI_CALL_TERMINATE_FN]
369	#define get_exception_ptr_fn cp_global_trees[CPTI_GET_EXCEPTION_PTR_FN]
370	#define begin_catch_fn cp_global_trees[CPTI_BEGIN_CATCH_FN]
371	#define end_catch_fn cp_global_trees[CPTI_END_CATCH_FN]
372	#define allocate_exception_fn cp_global_trees[CPTI_ALLOCATE_EXCEPTION_FN]
373	#define free_exception_fn cp_global_trees[CPTI_FREE_EXCEPTION_FN]
374	#define throw_fn cp_global_trees[CPTI_THROW_FN]
375	#define rethrow_fn cp_global_trees[CPTI_RETHROW_FN]
376
377	/ The type of the function-pointer argument to "std::atexit". /
378	#define atexit_fn_ptr_type_node cp_global_trees[CPTI_ATEXIT_FN_PTR_TYPE]
379
380	/ A pointer to `std::atexit'. /
381	#define atexit_node cp_global_trees[CPTI_ATEXIT]
382
383	/ A pointer to `__cxa_thread_atexit'. /
384	#define thread_atexit_node cp_global_trees[CPTI_THREAD_ATEXIT]
385
386	/ A pointer to `__dso_handle'. /
387	#define dso_handle_node cp_global_trees[CPTI_DSO_HANDLE]
388
389	/ The declaration of the dynamic_cast runtime. /
390	#define dynamic_cast_node cp_global_trees[CPTI_DCAST]
391
392	/ The type of a destructor, passed to __cxa_atexit, __cxa_thread_atexit*
393	or __cxa_throw. /*
394	#define cleanup_type cp_global_trees[CPTI_CLEANUP_TYPE]
395
396	/ The type of the vtt parameter passed to subobject constructors and*
397	destructors. /*
398	#define vtt_parm_type cp_global_trees[CPTI_VTT_PARM_TYPE]
399
400	/ A node which matches any template argument. /
401	#define any_targ_node cp_global_trees[CPTI_ANY_TARG]
402
403	/ Node to indicate default access. This must be distinct from the*
404	access nodes in tree.h. /*
405
406	#define access_default_node null_node
407
408	#include "name-lookup.h"
409
410	/ Usage of TREE_LANG_FLAG_?:*
411	0: IDENTIFIER_KIND_BIT_0 (in IDENTIFIER_NODE)
412	NEW_EXPR_USE_GLOBAL (in NEW_EXPR).
413	COND_EXPR_IS_VEC_DELETE (in COND_EXPR).
414	DELETE_EXPR_USE_GLOBAL (in DELETE_EXPR).
415	CLEANUP_P (in TRY_BLOCK)
416	AGGR_INIT_VIA_CTOR_P (in AGGR_INIT_EXPR)
417	PTRMEM_OK_P (in ADDR_EXPR, OFFSET_REF, SCOPE_REF)
418	PAREN_STRING_LITERAL_P (in STRING_CST)
419	CP_DECL_THREAD_LOCAL_P (in VAR_DECL)
420	KOENIG_LOOKUP_P (in CALL_EXPR)
421	STATEMENT_LIST_NO_SCOPE (in STATEMENT_LIST).
422	EXPR_STMT_STMT_EXPR_RESULT (in EXPR_STMT)
423	STMT_EXPR_NO_SCOPE (in STMT_EXPR)
424	BIND_EXPR_TRY_BLOCK (in BIND_EXPR)
425	TYPENAME_TYPE_TAG_BIT_0 (in TYPENAME_TYPE)
426	OMP_FOR_GIMPLIFYING_P (in OMP_FOR, OMP_SIMD, OMP_DISTRIBUTE,
427	and OMP_TASKLOOP)
428	BASELINK_QUALIFIED_P (in BASELINK)
429	TARGET_EXPR_IMPLICIT_P (in TARGET_EXPR)
430	TEMPLATE_PARM_PARAMETER_PACK (in TEMPLATE_PARM_INDEX)
431	ATTR_IS_DEPENDENT (in the TREE_LIST for an attribute)
432	ABI_TAG_IMPLICIT (in the TREE_LIST for the argument of abi_tag)
433	LAMBDA_CAPTURE_EXPLICIT_P (in a TREE_LIST in LAMBDA_EXPR_CAPTURE_LIST)
434	PARENTHESIZED_LIST_P (in the TREE_LIST for a parameter-declaration-list)
435	CONSTRUCTOR_IS_DIRECT_INIT (in CONSTRUCTOR)
436	DECLTYPE_FOR_LAMBDA_CAPTURE (in DECLTYPE_TYPE)
437	VEC_INIT_EXPR_IS_CONSTEXPR (in VEC_INIT_EXPR)
438	DECL_OVERRIDE_P (in FUNCTION_DECL)
439	IMPLICIT_CONV_EXPR_DIRECT_INIT (in IMPLICIT_CONV_EXPR)
440	TRANSACTION_EXPR_IS_STMT (in TRANSACTION_EXPR)
441	CONVERT_EXPR_VBASE_PATH (in CONVERT_EXPR)
442	PACK_EXPANSION_LOCAL_P (in _PACK_EXPANSION)*
443	TINFO_HAS_ACCESS_ERRORS (in TEMPLATE_INFO)
444	SIZEOF_EXPR_TYPE_P (in SIZEOF_EXPR)
445	COMPOUND_REQ_NOEXCEPT_P (in COMPOUND_REQ)
446	BLOCK_OUTER_CURLY_BRACE_P (in BLOCK)
447	FOLD_EXPR_MODIFY_P (_FOLD_EXPR)*
448	IF_STMT_CONSTEXPR_P (IF_STMT)
449	DECL_NAMESPACE_INLINE_P (in NAMESPACE_DECL)
450	SWITCH_STMT_ALL_CASES_P (in SWITCH_STMT)
451	REINTERPRET_CAST_P (in NOP_EXPR)
452	ALIGNOF_EXPR_STD_P (in ALIGNOF_EXPR)
453	OVL_DEDUP_P (in OVERLOAD)
454	INIT_EXPR_NRV_P (in INIT_EXPR)
455	ATOMIC_CONSTR_MAP_INSTANTIATED_P (in ATOMIC_CONSTR)
456	RETURN_EXPR_LOCAL_ADDR_P (in RETURN_EXPR)
457	PACK_INDEX_PARENTHESIZED_P (in PACK_INDEX_)*
458	MUST_NOT_THROW_NOEXCEPT_P (in MUST_NOT_THROW_EXPR)
459	CONSTEVAL_BLOCK_P (in STATIC_ASSERT)
460	LAMBDA_EXPR_CONSTEVAL_BLOCK_P (in LAMBDA_EXPR)
461	SPLICE_EXPR_EXPRESSION_P (in SPLICE_EXPR)
462	OLD_PARM_DECL_P (in PARM_DECL)
463	COMPONENT_REF_SPLICE_P (in COMPONENT_REF)
464	1: IDENTIFIER_KIND_BIT_1 (in IDENTIFIER_NODE)
465	TI_PENDING_TEMPLATE_FLAG.
466	TEMPLATE_PARMS_FOR_INLINE.
467	DELETE_EXPR_USE_VEC (in DELETE_EXPR).
468	ICS_ELLIPSIS_FLAG (in _CONV)
469	DECL_INITIALIZED_P (in VAR_DECL)
470	TYPENAME_TYPE_TAG_BIT_1 (in TYPENAME_TYPE)
471	STMT_IS_FULL_EXPR_P (in _STMT)
472	TARGET_EXPR_LIST_INIT_P (in TARGET_EXPR)
473	DECL_FINAL_P (in FUNCTION_DECL)
474	QUALIFIED_NAME_IS_TEMPLATE (in SCOPE_REF)
475	CONSTRUCTOR_IS_DEPENDENT (in CONSTRUCTOR)
476	TINFO_USED_TEMPLATE_ID (in TEMPLATE_INFO)
477	PACK_EXPANSION_SIZEOF_P (in _PACK_EXPANSION)*
478	OVL_USING_P (in OVERLOAD)
479	IMPLICIT_CONV_EXPR_NONTYPE_ARG (in IMPLICIT_CONV_EXPR)
480	BASELINK_FUNCTIONS_MAYBE_INCOMPLETE_P (in BASELINK)
481	BIND_EXPR_VEC_DTOR (in BIND_EXPR)
482	ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (in ATOMIC_CONSTR)
483	STATIC_INIT_DECOMP_BASE_P (in the TREE_LIST for {static,tls}_aggregates)
484	MUST_NOT_THROW_THROW_P (in MUST_NOT_THROW_EXPR)
485	LAMBDA_EXPR_CONST_QUAL_P (in LAMBDA_EXPR)
486	SPLICE_EXPR_MEMBER_ACCESS_P (in SPLICE_EXPR)
487	2: IDENTIFIER_KIND_BIT_2 (in IDENTIFIER_NODE)
488	ICS_THIS_FLAG (in _CONV)
489	DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (in VAR_DECL)
490	STATEMENT_LIST_TRY_BLOCK (in STATEMENT_LIST)
491	TYPENAME_TYPE_TAG_BIT_2 (in TYPENAME_TYPE)
492	TYPE_POLYMORPHIC_P (in RECORD_TYPE and UNION_TYPE)
493	TARGET_EXPR_DIRECT_INIT_P (in TARGET_EXPR)
494	FNDECL_USED_AUTO (in FUNCTION_DECL)
495	DECLTYPE_FOR_LAMBDA_PROXY (in DECLTYPE_TYPE)
496	REF_PARENTHESIZED_P (in COMPONENT_REF, INDIRECT_REF, SCOPE_REF,
497	VIEW_CONVERT_EXPR, PAREN_EXPR)
498	AGGR_INIT_ZERO_FIRST (in AGGR_INIT_EXPR)
499	CONSTRUCTOR_MUTABLE_POISON (in CONSTRUCTOR)
500	OVL_HIDDEN_P (in OVERLOAD)
501	IF_STMT_CONSTEVAL_P (in IF_STMT)
502	SWITCH_STMT_NO_BREAK_P (in SWITCH_STMT)
503	LAMBDA_EXPR_CAPTURE_OPTIMIZED (in LAMBDA_EXPR)
504	IMPLICIT_CONV_EXPR_BRACED_INIT (in IMPLICIT_CONV_EXPR)
505	PACK_EXPANSION_AUTO_P (in _PACK_EXPANSION)*
506	STATIC_INIT_DECOMP_NONBASE_P (in the TREE_LIST
507	for {static,tls}_aggregates)
508	MUST_NOT_THROW_CATCH_P (in MUST_NOT_THROW_EXPR)
509	MULTIPLE_NAMES_PARM_P (in PARM_DECL)
510	SPLICE_EXPR_ADDRESS_P (in SPLICE_EXPR)
511	3: IMPLICIT_RVALUE_P (in NON_LVALUE_EXPR or STATIC_CAST_EXPR)
512	ICS_BAD_FLAG (in _CONV)
513	FN_TRY_BLOCK_P (in TRY_BLOCK)
514	BIND_EXPR_BODY_BLOCK (in BIND_EXPR)
515	CALL_EXPR_ORDERED_ARGS (in CALL_EXPR, AGGR_INIT_EXPR)
516	DECLTYPE_FOR_REF_CAPTURE (in DECLTYPE_TYPE)
517	CONSTRUCTOR_C99_COMPOUND_LITERAL (in CONSTRUCTOR)
518	OVL_NESTED_P (in OVERLOAD)
519	DECL_MODULE_EXPORT_P (in _DECL)
520	PACK_EXPANSION_FORCE_EXTRA_ARGS_P (in _PACK_EXPANSION)*
521	LAMBDA_EXPR_STATIC_P (in LAMBDA_EXPR)
522	TARGET_EXPR_ELIDING_P (in TARGET_EXPR)
523	IF_STMT_VACUOUS_INIT_P (IF_STMT)
524	TYPENAME_IS_RESOLVING_P (in TYPENAME_TYPE)
525	4: IDENTIFIER_MARKED (IDENTIFIER_NODEs)
526	TREE_HAS_CONSTRUCTOR (in INDIRECT_REF, SAVE_EXPR, CONSTRUCTOR,
527	CALL_EXPR, or FIELD_DECL).
528	DECL_TINFO_P (in VAR_DECL, TYPE_DECL)
529	FUNCTION_REF_QUALIFIED (in FUNCTION_TYPE, METHOD_TYPE)
530	OVL_LOOKUP_P (in OVERLOAD)
531	LOOKUP_FOUND_P (in RECORD_TYPE, UNION_TYPE, ENUMERAL_TYPE, NAMESPACE_DECL)
532	FNDECL_MANIFESTLY_CONST_EVALUATED (in FUNCTION_DECL)
533	TARGET_EXPR_INTERNAL_P (in TARGET_EXPR)
534	CONTRACT_CONST (in ASSERTION_, PRECONDITION_, POSTCONDITION_STMT)
535	5: IDENTIFIER_VIRTUAL_P (in IDENTIFIER_NODE)
536	FUNCTION_RVALUE_QUALIFIED (in FUNCTION_TYPE, METHOD_TYPE)
537	CALL_EXPR_REVERSE_ARGS (in CALL_EXPR, AGGR_INIT_EXPR)
538	CONSTRUCTOR_PLACEHOLDER_BOUNDARY (in CONSTRUCTOR)
539	OVL_EXPORT_P (in OVERLOAD)
540	DECL_NTTP_OBJECT_P (in VAR_DECL)
541	6: TYPE_MARKED_P (in _TYPE)
542	DECL_NONTRIVIALLY_INITIALIZED_P (in VAR_DECL)
543	RANGE_FOR_IVDEP (in RANGE_FOR_STMT)
544	CALL_EXPR_OPERATOR_SYNTAX (in CALL_EXPR, AGGR_INIT_EXPR)
545	CONSTRUCTOR_IS_DESIGNATED_INIT (in CONSTRUCTOR)
546	OVL_NAME_INDEPENDENT_DECL_P (in OVERLOAD)
547
548	Usage of TYPE_LANG_FLAG_?:
549	0: TYPE_DEPENDENT_P
550	1: TYPE_HAS_USER_CONSTRUCTOR.
551	2: TYPE_HAS_LATE_RETURN_TYPE (in FUNCTION_TYPE, METHOD_TYPE)
552	TYPE_PTRMEMFUNC_FLAG (in RECORD_TYPE)
553	ENUM_BEING_DEFINED_P (in ENUMERAL_TYPE)
554	4: TYPE_HAS_NONTRIVIAL_DESTRUCTOR
555	5: CLASS_TYPE_P (in RECORD_TYPE and UNION_TYPE)
556	ENUM_FIXED_UNDERLYING_TYPE_P (in ENUMERAL_TYPE)
557	AUTO_IS_DECLTYPE (in TEMPLATE_TYPE_PARM)
558	TEMPLATE_TEMPLATE_PARM_SIMPLE_P (in TEMPLATE_TEMPLATE_PARM)
559	6: TYPE_DEPENDENT_P_VALID
560
561	Usage of DECL_LANG_FLAG_?:
562	0: DECL_TEMPLATE_PARM_P (in PARM_DECL, CONST_DECL, TYPE_DECL, or TEMPLATE_DECL)
563	DECL_LOCAL_DECL_P (in FUNCTION_DECL, VAR_DECL)
564	DECL_MUTABLE_P (in FIELD_DECL)
565	DECL_DEPENDENT_P (in USING_DECL)
566	LABEL_DECL_BREAK (in LABEL_DECL)
567	1: C_TYPEDEF_EXPLICITLY_SIGNED (in TYPE_DECL).
568	DECL_TEMPLATE_INSTANTIATED (in a VAR_DECL or a FUNCTION_DECL)
569	DECL_MEMBER_TEMPLATE_P (in TEMPLATE_DECL)
570	USING_DECL_TYPENAME_P (in USING_DECL)
571	DECL_VLA_CAPTURE_P (in FIELD_DECL)
572	DECL_ARRAY_PARAMETER_P (in PARM_DECL)
573	LABEL_DECL_CONTINUE (in LABEL_DECL)
574	2: DECL_THIS_EXTERN (in VAR_DECL, FUNCTION_DECL or PARM_DECL)
575	DECL_IMPLICIT_TYPEDEF_P (in a TYPE_DECL)
576	DECL_CONSTRAINT_VAR_P (in a PARM_DECL)
577	DECL_INSTANTIATING_NSDMI_P (in a FIELD_DECL)
578	USING_DECL_UNRELATED_P (in USING_DECL)
579	3: DECL_IN_AGGR_P.
580	4: DECL_C_BIT_FIELD (in a FIELD_DECL)
581	DECL_ANON_UNION_VAR_P (in a VAR_DECL)
582	DECL_SELF_REFERENCE_P (in a TYPE_DECL)
583	DECL_INVALID_OVERRIDER_P (in a FUNCTION_DECL)
584	DECL_UNINSTANIATED_TEMPLATE_FRIEND_P (in TEMPLATE_DECL)
585	parm_used_in_post_p (in PARM_DECL)
586	5: DECL_INTERFACE_KNOWN.
587	6: DECL_THIS_STATIC (in VAR_DECL, FUNCTION_DECL or PARM_DECL)
588	DECL_FIELD_IS_BASE (in FIELD_DECL)
589	TYPE_DECL_ALIAS_P (in TYPE_DECL)
590	7: DECL_THUNK_P (in a member FUNCTION_DECL)
591	DECL_NORMAL_CAPTURE_P (in FIELD_DECL)
592	DECL_DECLARED_CONSTINIT_P (in VAR_DECL)
593	8: DECL_DECLARED_CONSTEXPR_P (in VAR_DECL, FUNCTION_DECL)
594
595	Usage of language-independent fields in a language-dependent manner:
596
597	TYPE_ALIAS_SET
598	This field is used by TYPENAME_TYPEs, TEMPLATE_TYPE_PARMs, and so
599	forth as a substitute for the mark bits provided in `lang_type'.
600	At present, only the six low-order bits are used.
601
602	TYPE_LANG_SLOT_1
603	For a FUNCTION_TYPE or METHOD_TYPE, this is TYPE_RAISES_EXCEPTIONS.
604	For a POINTER_TYPE (to a METHOD_TYPE), this is TYPE_PTRMEMFUNC_TYPE.
605	For an ENUMERAL_TYPE, BOUND_TEMPLATE_TEMPLATE_PARM_TYPE,
606	RECORD_TYPE or UNION_TYPE this is TYPE_TEMPLATE_INFO,
607
608	BINFO_VIRTUALS
609	For a binfo, this is a TREE_LIST. There is an entry for each
610	virtual function declared either in BINFO or its direct and
611	indirect primary bases.
612
613	The BV_DELTA of each node gives the amount by which to adjust the
614	`this' pointer when calling the function. If the method is an
615	overridden version of a base class method, then it is assumed
616	that, prior to adjustment, the this pointer points to an object
617	of the base class.
618
619	The BV_VCALL_INDEX of each node, if non-NULL, gives the vtable
620	index of the vcall offset for this entry.
621
622	The BV_FN is the declaration for the virtual function itself.
623
624	If BV_LOST_PRIMARY is set, it means that this entry is for a lost
625	primary virtual base and can be left null in the vtable.
626
627	BINFO_VTABLE
628	This is an expression with POINTER_TYPE that gives the value
629	to which the vptr should be initialized. Use get_vtbl_decl_for_binfo
630	to extract the VAR_DECL for the complete vtable.
631
632	DECL_VINDEX
633	This field is NULL for a non-virtual function. For a virtual
634	function, it is eventually set to an INTEGER_CST indicating the
635	index in the vtable at which this function can be found. When
636	a virtual function is declared, but before it is known what
637	function is overridden, this field is the error_mark_node.
638
639	Temporarily, it may be set to a TREE_LIST whose TREE_VALUE is
640	the virtual function this one overrides, and whose TREE_CHAIN is
641	the old DECL_VINDEX. /*
642
643	/ Language-specific tree checkers. /
644
645	#define VAR_OR_FUNCTION_DECL_CHECK(NODE) \
646	TREE_CHECK2(NODE,VAR_DECL,FUNCTION_DECL)
647
648	#define TYPE_FUNCTION_OR_TEMPLATE_DECL_CHECK(NODE) \
649	TREE_CHECK3(NODE,TYPE_DECL,TEMPLATE_DECL,FUNCTION_DECL)
650
651	#define TYPE_FUNCTION_OR_TEMPLATE_DECL_P(NODE) \
652	(TREE_CODE (NODE) == TYPE_DECL \|\| TREE_CODE (NODE) == TEMPLATE_DECL \
653	\|\| TREE_CODE (NODE) == FUNCTION_DECL)
654
655	#define VAR_FUNCTION_OR_PARM_DECL_CHECK(NODE) \
656	TREE_CHECK3(NODE,VAR_DECL,FUNCTION_DECL,PARM_DECL)
657
658	#define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) \
659	TREE_CHECK4(NODE,VAR_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL)
660
661	#define VAR_TEMPL_TYPE_FIELD_OR_FUNCTION_DECL_CHECK(NODE) \
662	TREE_CHECK5(NODE,VAR_DECL,FIELD_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL)
663
664	#define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) \
665	TREE_CHECK(NODE,BOUND_TEMPLATE_TEMPLATE_PARM)
666
667	#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
668
669	/ Returns t iff the node can have a TEMPLATE_INFO field. /
670
671	inline tree
672	template_info_decl_check (const_tree t, const char* f, int l, const char* fn)
673	{
674	switch (TREE_CODE (t))
675	{
676	case VAR_DECL:
677	case FUNCTION_DECL:
678	case FIELD_DECL:
679	case TYPE_DECL:
680	case CONCEPT_DECL:
681	case TEMPLATE_DECL:
682	return const_cast<tree>(t);
683	default:
684	break;
685	}
686	tree_check_failed (t, f, l, fn,
687	VAR_DECL, FUNCTION_DECL, FIELD_DECL, TYPE_DECL,
688	CONCEPT_DECL, TEMPLATE_DECL, `0`);
689	gcc_unreachable ();
690	}
691
692	#define TEMPLATE_INFO_DECL_CHECK(NODE) \
693	template_info_decl_check ((NODE), __FILE__, __LINE__, __FUNCTION__)
694
695	#define THUNK_FUNCTION_CHECK(NODE) __extension__ \
696	({ __typeof (NODE) const __t = (NODE); \
697	if (TREE_CODE (__t) != FUNCTION_DECL \|\| !__t->decl_common.lang_specific \
698	\|\| !__t->decl_common.lang_specific->u.fn.thunk_p) \
699	tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, 0); \
700	__t; })
701
702	#define DECL_TEMPLATE_PARM_CHECK(NODE) \
703	decl_template_parm_check ((NODE), __FILE__, __LINE__, __FUNCTION__)
704
705	#else /* ENABLE_TREE_CHECKING */
706
707	#define TEMPLATE_INFO_DECL_CHECK(NODE) (NODE)
708	#define THUNK_FUNCTION_CHECK(NODE) (NODE)
709	#define DECL_TEMPLATE_PARM_CHECK(NODE) (NODE)
710
711	#endif /* ENABLE_TREE_CHECKING */
712
713	/ Language-dependent contents of an identifier. /
714
715	struct GTY(()) lang_identifier {
716	struct c_common_identifier c_common;
717	cxx_binding *bindings;
718	};
719
720	/ Return a typed pointer version of T if it designates a*
721	C++ front-end identifier. /*
722	inline lang_identifier*
723	identifier_p (tree t)
724	{
725	if (TREE_CODE (t) == IDENTIFIER_NODE)
726	return (lang_identifier*) t;
727	return NULL;
728	}
729
730	#define LANG_IDENTIFIER_CAST(NODE) \
731	((struct lang_identifier*)IDENTIFIER_NODE_CHECK (NODE))
732
733	struct GTY(()) template_parm_index {
734	struct tree_common common;
735	int index;
736	int level;
737	int orig_level;
738	tree decl;
739	};
740
741	struct GTY(()) ptrmem_cst {
742	struct tree_typed typed;
743	tree member;
744	location_t locus;
745	};
746	typedef struct ptrmem_cst * ptrmem_cst_t;
747
748	#define CLEANUP_P(NODE) TREE_LANG_FLAG_0 (TRY_BLOCK_CHECK (NODE))
749
750	#define BIND_EXPR_TRY_BLOCK(NODE) \
751	TREE_LANG_FLAG_0 (BIND_EXPR_CHECK (NODE))
752
753	/ This BIND_EXPR is from build_vec_delete_1. /
754	#define BIND_EXPR_VEC_DTOR(NODE) \
755	TREE_LANG_FLAG_1 (BIND_EXPR_CHECK (NODE))
756
757	/ Used to mark the block around the member initializers and cleanups. /
758	#define BIND_EXPR_BODY_BLOCK(NODE) \
759	TREE_LANG_FLAG_3 (BIND_EXPR_CHECK (NODE))
760	#define FUNCTION_NEEDS_BODY_BLOCK(NODE) \
761	(DECL_CONSTRUCTOR_P (NODE) \|\| DECL_DESTRUCTOR_P (NODE) \
762	\|\| LAMBDA_FUNCTION_P (NODE))
763
764	#define STATEMENT_LIST_NO_SCOPE(NODE) \
765	TREE_LANG_FLAG_0 (STATEMENT_LIST_CHECK (NODE))
766	#define STATEMENT_LIST_TRY_BLOCK(NODE) \
767	TREE_LANG_FLAG_2 (STATEMENT_LIST_CHECK (NODE))
768
769	/ Mark the outer curly brace BLOCK. /
770	#define BLOCK_OUTER_CURLY_BRACE_P(NODE) TREE_LANG_FLAG_0 (BLOCK_CHECK (NODE))
771
772	/ Nonzero if this statement should be considered a full-expression,*
773	i.e., if temporaries created during this statement should have
774	their destructors run at the end of this statement. /*
775	#define STMT_IS_FULL_EXPR_P(NODE) TREE_LANG_FLAG_1 ((NODE))
776
777	/ Marks the result of a statement expression. /
778	#define EXPR_STMT_STMT_EXPR_RESULT(NODE) \
779	TREE_LANG_FLAG_0 (EXPR_STMT_CHECK (NODE))
780
781	/ Nonzero if this statement-expression does not have an associated scope. /
782	#define STMT_EXPR_NO_SCOPE(NODE) \
783	TREE_LANG_FLAG_0 (STMT_EXPR_CHECK (NODE))
784
785	#define COND_EXPR_IS_VEC_DELETE(NODE) \
786	TREE_LANG_FLAG_0 (COND_EXPR_CHECK (NODE))
787
788	/ Nonzero if this NOP_EXPR is a reinterpret_cast. Such conversions*
789	are not constexprs. Other NOP_EXPRs are. /*
790	#define REINTERPRET_CAST_P(NODE) \
791	TREE_LANG_FLAG_0 (NOP_EXPR_CHECK (NODE))
792
793	/ Returns nonzero iff TYPE1 and TYPE2 are the same type, in the usual*
794	sense of `same'. /*
795	#define same_type_p(TYPE1, TYPE2) \
796	comptypes ((TYPE1), (TYPE2), COMPARE_STRICT)
797
798	/ Returns nonzero iff NODE is a declaration for the global function*
799	`main'. /*
800	#define DECL_MAIN_ANY_P(NODE) \
801	(DECL_EXTERN_C_FUNCTION_P (NODE) \
802	&& DECL_NAME (NODE) != NULL_TREE \
803	&& MAIN_NAME_P (DECL_NAME (NODE)))
804
805	/ Nonzero iff NODE is a declaration for `int main', or we are hosted. /
806	#define DECL_MAIN_FREESTANDING_P(NODE) \
807	(DECL_MAIN_ANY_P(NODE) \
808	&& (flag_hosted \
809	\|\| TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (NODE))) \
810	== integer_type_node))
811
812	/ Nonzero iff NODE is a declaration for `main', and we are hosted. /
813	#define DECL_MAIN_P(NODE) (DECL_MAIN_ANY_P(NODE) && flag_hosted)
814
815	/ Lookup walker marking. /
816	#define LOOKUP_SEEN_P(NODE) TREE_VISITED (NODE)
817	#define LOOKUP_FOUND_P(NODE) \
818	TREE_LANG_FLAG_4 (TREE_CHECK4 (NODE,RECORD_TYPE,UNION_TYPE,ENUMERAL_TYPE,\
819	NAMESPACE_DECL))
820
821	/ These two accessors should only be used by OVL manipulators.*
822	Other users should use iterators and convenience functions. /*
823	#define OVL_FUNCTION(NODE) \
824	(((struct tree_overload*)OVERLOAD_CHECK (NODE))->function)
825	#define OVL_CHAIN(NODE) \
826	(((struct tree_overload*)OVERLOAD_CHECK (NODE))->common.chain)
827
828	/ If set, this or a subsequent overload contains decls that need deduping. /
829	#define OVL_DEDUP_P(NODE) TREE_LANG_FLAG_0 (OVERLOAD_CHECK (NODE))
830	/ If set, this was imported in a using declaration. /
831	#define OVL_USING_P(NODE) TREE_LANG_FLAG_1 (OVERLOAD_CHECK (NODE))
832	/ If set, this overload is a hidden decl. /
833	#define OVL_HIDDEN_P(NODE) TREE_LANG_FLAG_2 (OVERLOAD_CHECK (NODE))
834	/ If set, this overload contains a nested overload. /
835	#define OVL_NESTED_P(NODE) TREE_LANG_FLAG_3 (OVERLOAD_CHECK (NODE))
836	/ If set, this overload was constructed during lookup. /
837	#define OVL_LOOKUP_P(NODE) TREE_LANG_FLAG_4 (OVERLOAD_CHECK (NODE))
838	/ If set, this OVL_USING_P overload is exported. /
839	#define OVL_EXPORT_P(NODE) TREE_LANG_FLAG_5 (OVERLOAD_CHECK (NODE))
840	/ If set, this OVL_USING_P overload is in the module purview. /
841	#define OVL_PURVIEW_P(NODE) (OVERLOAD_CHECK (NODE)->base.public_flag)
842	/ If set, this overload includes name-independent declarations. /
843	#define OVL_NAME_INDEPENDENT_DECL_P(NODE) \
844	TREE_LANG_FLAG_6 (OVERLOAD_CHECK (NODE))
845
846	/ The first decl of an overload. /
847	#define OVL_FIRST(NODE) ovl_first (NODE)
848	/ The name of the overload set. /
849	#define OVL_NAME(NODE) DECL_NAME (OVL_FIRST (NODE))
850
851	/ Whether this is a set of overloaded functions. TEMPLATE_DECLS are*
852	always wrapped in an OVERLOAD, so we don't need to check them
853	here. /*
854	#define OVL_P(NODE) \
855	(TREE_CODE (NODE) == FUNCTION_DECL \|\| TREE_CODE (NODE) == OVERLOAD)
856	/ Whether this is a single member overload. /
857	#define OVL_SINGLE_P(NODE) \
858	(TREE_CODE (NODE) != OVERLOAD \|\| !OVL_CHAIN (NODE))
859
860	/ OVL_HIDDEN_P nodes come before other nodes. /
861
862	struct GTY(()) tree_overload {
863	struct tree_common common;
864	tree function;
865	};
866
867	/ Iterator for a 1 dimensional overload. Permits iterating over the*
868	outer level of a 2-d overload when explicitly enabled. /*
869
870	class ovl_iterator {
871	tree ovl;
872	const bool allow_inner; / Only used when checking. /
873
874	public:
875	explicit ovl_iterator (tree o, bool allow = false)
876	: ovl (o), allow_inner (allow)
877	{
878	}
879
880	public:
881	operator bool () const
882	{
883	return ovl;
884	}
885	ovl_iterator &operator++ ()
886	{
887	ovl = TREE_CODE (ovl) != OVERLOAD ? NULL_TREE : OVL_CHAIN (ovl);
888	return *this;
889	}
890	tree operator* () const
891	{
892	tree fn = TREE_CODE (ovl) != OVERLOAD ? ovl : OVL_FUNCTION (ovl);
893
894	/ Check this is not an unexpected 2-dimensional overload. /
895	gcc_checking_assert (allow_inner \|\| TREE_CODE (fn) != OVERLOAD);
896
897	return fn;
898	}
899	bool operator== (const ovl_iterator &o) const
900	{
901	return ovl == o.ovl;
902	}
903	tree get_using () const
904	{
905	gcc_checking_assert (using_p ());
906	return ovl;
907	}
908
909	public:
910	/ Whether this overload was introduced by a using decl. /
911	bool using_p () const
912	{
913	return (TREE_CODE (ovl) == USING_DECL
914	\|\| (TREE_CODE (ovl) == OVERLOAD && OVL_USING_P (ovl)));
915	}
916	bool hidden_p () const
917	{
918	return TREE_CODE (ovl) == OVERLOAD && OVL_HIDDEN_P (ovl);
919	}
920	bool purview_p () const;
921	bool exporting_p () const;
922
923	public:
924	tree remove_node (tree head)
925	{
926	return remove_node (head, node: ovl);
927	}
928	tree reveal_node (tree head)
929	{
930	return reveal_node (ovl: head, node: ovl);
931	}
932
933	protected:
934	/ If we have a nested overload, point at the inner overload and*
935	return the next link on the outer one. /*
936	tree maybe_push ()
937	{
938	tree r = NULL_TREE;
939
940	if (ovl && TREE_CODE (ovl) == OVERLOAD && OVL_NESTED_P (ovl))
941	{
942	r = OVL_CHAIN (ovl);
943	ovl = OVL_FUNCTION (ovl);
944	}
945	return r;
946	}
947	/ Restore an outer nested overload. /
948	void pop (tree outer)
949	{
950	gcc_checking_assert (!ovl);
951	ovl = outer;
952	}
953
954	private:
955	/ We make these static functions to avoid the address of the*
956	iterator escaping the local context. /*
957	static tree remove_node (tree head, tree node);
958	static tree reveal_node (tree ovl, tree node);
959	};
960
961	/ Treat a tree as a range of ovl_iterator, e.g.*
962	for (tree f : ovl_range (fns)) { ... } /*
963
964	class ovl_range
965	{
966	tree t;
967	bool allow;
968	public:
969	explicit ovl_range (tree t, bool allow = false): t(t), allow(allow) { }
970	ovl_iterator begin() { return ovl_iterator (t, allow); }
971	ovl_iterator end() { return ovl_iterator (NULL_TREE, allow); }
972	};
973
974	/ Iterator over a (potentially) 2 dimensional overload, which is*
975	produced by name lookup. /*
976
977	class lkp_iterator : public ovl_iterator {
978	typedef ovl_iterator parent;
979
980	tree outer;
981
982	public:
983	explicit lkp_iterator (tree o)
984	: parent (o, true), outer (maybe_push ())
985	{
986	}
987
988	public:
989	lkp_iterator &operator++ ()
990	{
991	bool repush = !outer;
992
993	if (!parent::operator++ () && !repush)
994	{
995	pop (outer);
996	repush = true;
997	}
998
999	if (repush)
1000	outer = maybe_push ();
1001
1002	return *this;
1003	}
1004	};
1005
1006	/ Treat a tree as a range of lkp_iterator, e.g.*
1007	for (tree f : lkp_range (fns)) { ... } /*
1008
1009	class lkp_range
1010	{
1011	tree t;
1012	public:
1013	lkp_range (tree t): t(t) { }
1014	lkp_iterator begin() { return lkp_iterator (t); }
1015	lkp_iterator end() { return lkp_iterator (NULL_TREE); }
1016	};
1017
1018	/ Iterator for a RAW_DATA_CST. /
1019
1020	class raw_data_iterator {
1021	tree t;
1022	unsigned int n;
1023
1024	public:
1025	explicit raw_data_iterator (tree t, unsigned int n)
1026	: t (t), n (n)
1027	{
1028	}
1029
1030	operator bool () const
1031	{
1032	return n < (unsigned) RAW_DATA_LENGTH (t);
1033	}
1034
1035	raw_data_iterator &operator++ ()
1036	{
1037	++n;
1038	return *this;
1039	}
1040
1041	tree operator* () const
1042	{
1043	return build_int_cst (TREE_TYPE (t), RAW_DATA_UCHAR_ELT (t, n));
1044	}
1045
1046	bool operator== (const raw_data_iterator &o) const
1047	{
1048	return t == o.t && n == o.n;
1049	}
1050	};
1051
1052	/ Treat a tree as a range of raw_data_iterator, e.g.*
1053	for (tree f : raw_data_range (d)) { ... } /*
1054
1055	class raw_data_range
1056	{
1057	tree t;
1058	public:
1059	raw_data_range (tree t) : t (t) { }
1060	raw_data_iterator begin () { return raw_data_iterator (t, `0`); }
1061	raw_data_iterator end ()
1062	{ return raw_data_iterator (t, RAW_DATA_LENGTH (t)); }
1063	};
1064
1065	/ hash traits for declarations. Hashes potential overload sets via*
1066	DECL_NAME. /*
1067
1068	struct named_decl_hash : ggc_remove <tree> {
1069	typedef tree value_type; / A DECL or OVERLOAD /
1070	typedef tree compare_type; / An identifier. /
1071
1072	inline static hashval_t hash (const value_type decl);
1073	inline static bool equal (const value_type existing, compare_type candidate);
1074
1075	static const bool empty_zero_p = true;
1076	static inline void mark_empty (value_type &p) {p = NULL_TREE;}
1077	static inline bool is_empty (value_type p) {return !p;}
1078
1079	/ Nothing is deletable. Everything is insertable. /
1080	static bool is_deleted (value_type) { return false; }
1081	static void mark_deleted (value_type) { gcc_unreachable (); }
1082	};
1083
1084	/ Simplified unique_ptr clone to release a tree vec on exit. /
1085
1086	class releasing_vec
1087	{
1088	public:
1089	typedef vec<tree, va_gc> vec_t;
1090
1091	releasing_vec (vec_t *v): v(v) { }
1092	releasing_vec (): v(make_tree_vector ()) { }
1093
1094	/ Copy ops are deliberately declared but not defined,*
1095	copies must always be elided. /*
1096	releasing_vec (const releasing_vec &);
1097	releasing_vec &operator= (const releasing_vec &);
1098
1099	vec_t &operator* () const { return *v; }
1100	vec_t *operator-> () const { return v; }
1101	vec_t get() const* { return v; }
1102	operator vec_t () const* { return v; }
1103	vec_t operator& () { return** &v; }
1104
1105	/ Breaks pointer/value consistency for convenience. This takes ptrdiff_t*
1106	rather than unsigned to avoid ambiguity with the built-in operator[]
1107	(bootstrap/91828). /*
1108	tree& operator[] (ptrdiff_t i) const { return (*v)[i]; }
1109
1110	tree begin() { return* ::begin (v); }
1111	tree end() { return* ::end (v); }
1112
1113	void release () { release_tree_vector (v); v = NULL; }
1114
1115	~releasing_vec () { release_tree_vector (v); }
1116	private:
1117	vec_t *v;
1118	};
1119	/ Forwarding functions for vec_safe_* that might reallocate. /
1120	inline tree* vec_safe_push (releasing_vec& r, const tree &t CXX_MEM_STAT_INFO)
1121	{ return vec_safe_push (v&: *&r, obj: t PASS_MEM_STAT); }
1122	inline bool vec_safe_reserve (releasing_vec& r, unsigned n, bool e = false CXX_MEM_STAT_INFO)
1123	{ return vec_safe_reserve (v&: *&r, nelems: n, exact: e PASS_MEM_STAT); }
1124	inline unsigned vec_safe_length (releasing_vec &r)
1125	{ return r ->length(); }
1126	inline void vec_safe_splice (releasing_vec &r, vec<tree, va_gc> *p CXX_MEM_STAT_INFO)
1127	{ vec_safe_splice (dst&: *&r, src: p PASS_MEM_STAT); }
1128	void release_tree_vector (releasing_vec &); // cause link error
1129
1130	struct GTY(()) tree_template_decl {
1131	struct tree_decl_common common;
1132	tree arguments;
1133	tree result;
1134	};
1135
1136	/ Returns true iff NODE is a BASELINK. /
1137	#define BASELINK_P(NODE) \
1138	(TREE_CODE (NODE) == BASELINK)
1139	/ The BINFO indicating the base in which lookup found the*
1140	BASELINK_FUNCTIONS. /*
1141	#define BASELINK_BINFO(NODE) \
1142	(((struct tree_baselink*) BASELINK_CHECK (NODE))->binfo)
1143	/ The functions referred to by the BASELINK; either a FUNCTION_DECL,*
1144	a TEMPLATE_DECL, an OVERLOAD, or a TEMPLATE_ID_EXPR. /*
1145	#define BASELINK_FUNCTIONS(NODE) \
1146	(((struct tree_baselink*) BASELINK_CHECK (NODE))->functions)
1147	/ If T is a BASELINK, grab the functions, otherwise just T, which is*
1148	expected to already be a (list of) functions. /*
1149	#define MAYBE_BASELINK_FUNCTIONS(T) \
1150	(BASELINK_P (T) ? BASELINK_FUNCTIONS (T) : T)
1151	/ The BINFO in which the search for the functions indicated by this baselink*
1152	began. This base is used to determine the accessibility of functions
1153	selected by overload resolution. /*
1154	#define BASELINK_ACCESS_BINFO(NODE) \
1155	(((struct tree_baselink*) BASELINK_CHECK (NODE))->access_binfo)
1156	/ For a type-conversion operator, the BASELINK_OPTYPE indicates the type*
1157	to which the conversion should occur. This value is important if
1158	the BASELINK_FUNCTIONS include a template conversion operator --
1159	the BASELINK_OPTYPE can be used to determine what type the user
1160	requested. /*
1161	#define BASELINK_OPTYPE(NODE) \
1162	(TREE_CHAIN (BASELINK_CHECK (NODE)))
1163	/ Nonzero if this baselink was from a qualified lookup. /
1164	#define BASELINK_QUALIFIED_P(NODE) \
1165	TREE_LANG_FLAG_0 (BASELINK_CHECK (NODE))
1166	/ Nonzero if the overload set for this baselink might be incomplete due*
1167	to the lookup being performed from an incomplete-class context. /*
1168	#define BASELINK_FUNCTIONS_MAYBE_INCOMPLETE_P(NODE) \
1169	TREE_LANG_FLAG_1 (BASELINK_CHECK (NODE))
1170
1171	struct GTY(()) tree_baselink {
1172	struct tree_common common;
1173	tree binfo;
1174	tree functions;
1175	tree access_binfo;
1176	};
1177
1178	/ The different kinds of ids that we encounter. /
1179
1180	enum cp_id_kind
1181	{
1182	/ Not an id at all. /
1183	CP_ID_KIND_NONE,
1184	/ An unqualified-id that is not a template-id. /
1185	CP_ID_KIND_UNQUALIFIED,
1186	/ An unqualified-id that is a dependent name. /
1187	CP_ID_KIND_UNQUALIFIED_DEPENDENT,
1188	/ An unqualified template-id. /
1189	CP_ID_KIND_TEMPLATE_ID,
1190	/ A qualified-id. /
1191	CP_ID_KIND_QUALIFIED
1192	};
1193
1194
1195	/ The various kinds of C++0x warnings we encounter. /
1196
1197	enum cpp0x_warn_str
1198	{
1199	/ extended initializer lists /
1200	CPP0X_INITIALIZER_LISTS,
1201	/ explicit conversion operators /
1202	CPP0X_EXPLICIT_CONVERSION,
1203	/ variadic templates /
1204	CPP0X_VARIADIC_TEMPLATES,
1205	/ lambda expressions /
1206	CPP0X_LAMBDA_EXPR,
1207	/ C++0x auto /
1208	CPP0X_AUTO,
1209	/ scoped enums /
1210	CPP0X_SCOPED_ENUMS,
1211	/ defaulted and deleted functions /
1212	CPP0X_DEFAULTED_DELETED,
1213	/ inline namespaces /
1214	CPP0X_INLINE_NAMESPACES,
1215	/ override controls, override/final /
1216	CPP0X_OVERRIDE_CONTROLS,
1217	/ non-static data member initializers /
1218	CPP0X_NSDMI,
1219	/ user defined literals /
1220	CPP0X_USER_DEFINED_LITERALS,
1221	/ delegating constructors /
1222	CPP0X_DELEGATING_CTORS,
1223	/ inheriting constructors /
1224	CPP0X_INHERITING_CTORS,
1225	/ C++11 attributes /
1226	CPP0X_ATTRIBUTES,
1227	/ ref-qualified member functions /
1228	CPP0X_REF_QUALIFIER
1229	};
1230
1231	/ The various kinds of operation used by composite_pointer_type. /
1232
1233	enum composite_pointer_operation
1234	{
1235	/ comparison /
1236	CPO_COMPARISON,
1237	/ conversion /
1238	CPO_CONVERSION,
1239	/ conditional expression /
1240	CPO_CONDITIONAL_EXPR
1241	};
1242
1243	/ Possible cases of expression list used by*
1244	build_x_compound_expr_from_list. /*
1245	enum expr_list_kind {
1246	ELK_INIT, / initializer /
1247	ELK_MEM_INIT, / member initializer /
1248	ELK_FUNC_CAST / functional cast /
1249	};
1250
1251	/ Possible cases of implicit bad rhs conversions. /
1252	enum impl_conv_rhs {
1253	ICR_DEFAULT_ARGUMENT, / default argument /
1254	ICR_CONVERTING, / converting /
1255	ICR_INIT, / initialization /
1256	ICR_ARGPASS, / argument passing /
1257	ICR_RETURN, / return /
1258	ICR_ASSIGN / assignment /
1259	};
1260
1261	/ Possible cases of implicit or explicit bad conversions to void. /
1262	enum impl_conv_void {
1263	ICV_CAST, / (explicit) conversion to void /
1264	ICV_SECOND_OF_COND, / second operand of conditional expression /
1265	ICV_THIRD_OF_COND, / third operand of conditional expression /
1266	ICV_RIGHT_OF_COMMA, / right operand of comma operator /
1267	ICV_LEFT_OF_COMMA, / left operand of comma operator /
1268	ICV_STATEMENT, / statement /
1269	ICV_THIRD_IN_FOR / for increment expression /
1270	};
1271
1272	/ Possible invalid uses of an abstract class that might not have a*
1273	specific associated declaration. /*
1274	enum GTY(()) abstract_class_use {
1275	ACU_UNKNOWN, / unknown or decl provided /
1276	ACU_CAST, / cast to abstract class /
1277	ACU_NEW, / new-expression of abstract class /
1278	ACU_THROW, / throw-expression of abstract class /
1279	ACU_CATCH, / catch-parameter of abstract class /
1280	ACU_ARRAY, / array of abstract class /
1281	ACU_RETURN, / return type of abstract class /
1282	ACU_PARM / parameter type of abstract class /
1283	};
1284
1285	/ Macros for access to language-specific slots in an identifier. /
1286
1287	/ Identifiers map directly to block or class-scope bindings.*
1288	Namespace-scope bindings are held in hash tables on the respective
1289	namespaces. The identifier bindings are the innermost active
1290	binding, from whence you can get the decl and/or implicit-typedef
1291	of an elaborated type. When not bound to a local entity the
1292	values are NULL. /*
1293	#define IDENTIFIER_BINDING(NODE) \
1294	(LANG_IDENTIFIER_CAST (NODE)->bindings)
1295	#define REAL_IDENTIFIER_TYPE_VALUE(NODE) TREE_TYPE (NODE)
1296	#define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = (TYPE))
1297
1298	/ Kinds of identifiers. Values are carefully chosen. /
1299	enum cp_identifier_kind {
1300	cik_normal = `0`, / Not a special identifier. /
1301	cik_keyword = `1`, / A keyword. /
1302	cik_ctor = `2`, / Constructor (in-chg, complete or base). /
1303	cik_dtor = `3`, / Destructor (in-chg, deleting, complete or*
1304	base). /*
1305	cik_simple_op = `4`, / Non-assignment operator name. /
1306	cik_assign_op = `5`, / An assignment operator name. /
1307	cik_conv_op = `6`, / Conversion operator name. /
1308	cik_trait = `7`, / Built-in trait name. /
1309	cik_max
1310	};
1311
1312	/ Kind bits. /
1313	#define IDENTIFIER_KIND_BIT_0(NODE) \
1314	TREE_LANG_FLAG_0 (IDENTIFIER_NODE_CHECK (NODE))
1315	#define IDENTIFIER_KIND_BIT_1(NODE) \
1316	TREE_LANG_FLAG_1 (IDENTIFIER_NODE_CHECK (NODE))
1317	#define IDENTIFIER_KIND_BIT_2(NODE) \
1318	TREE_LANG_FLAG_2 (IDENTIFIER_NODE_CHECK (NODE))
1319
1320	/ Used by various search routines. /
1321	#define IDENTIFIER_MARKED(NODE) \
1322	TREE_LANG_FLAG_4 (IDENTIFIER_NODE_CHECK (NODE))
1323
1324	/ Nonzero if this identifier is used as a virtual function name somewhere*
1325	(optimizes searches). /*
1326	#define IDENTIFIER_VIRTUAL_P(NODE) \
1327	TREE_LANG_FLAG_5 (IDENTIFIER_NODE_CHECK (NODE))
1328
1329	/ Return the cp_identifier_kind of the given IDENTIFIER node ID. /
1330
1331	ATTRIBUTE_PURE inline cp_identifier_kind
1332	get_identifier_kind (tree id)
1333	{
1334	unsigned bit0 = IDENTIFIER_KIND_BIT_0 (id);
1335	unsigned bit1 = IDENTIFIER_KIND_BIT_1 (id);
1336	unsigned bit2 = IDENTIFIER_KIND_BIT_2 (id);
1337	return cp_identifier_kind ((bit2 << `2`) \| (bit1 << `1`) \| bit0);
1338	}
1339
1340	/ True if this identifier is a reserved word. C_RID_CODE (node) is*
1341	then the RID_ value of the keyword. Value 1. /
1342	#define IDENTIFIER_KEYWORD_P(NODE) \
1343	(get_identifier_kind (NODE) == cik_keyword)
1344
1345	/ True if this identifier is the name of a constructor or*
1346	destructor. Value 2 or 3. /*
1347	#define IDENTIFIER_CDTOR_P(NODE) \
1348	(IDENTIFIER_CTOR_P (NODE) \|\| IDENTIFIER_DTOR_P (NODE))
1349
1350	/ True if this identifier is the name of a constructor. Value 2. /
1351	#define IDENTIFIER_CTOR_P(NODE) \
1352	(get_identifier_kind (NODE) == cik_ctor)
1353
1354	/ True if this identifier is the name of a destructor. Value 3. /
1355	#define IDENTIFIER_DTOR_P(NODE) \
1356	(get_identifier_kind (NODE) == cik_dtor)
1357
1358	/ True if this identifier is for any operator name (including*
1359	conversions). Value 4, 5, or 6. /*
1360	#define IDENTIFIER_ANY_OP_P(NODE) \
1361	(IDENTIFIER_OVL_OP_P (NODE) \|\| IDENTIFIER_CONV_OP_P (NODE))
1362
1363	/ True if this identifier is for an overloaded operator. Values 4, 5. /
1364	#define IDENTIFIER_OVL_OP_P(NODE) \
1365	(get_identifier_kind (NODE) == cik_simple_op \
1366	\|\| get_identifier_kind (NODE) == cik_assign_op)
1367
1368	/ True if this identifier is for any assignment. Values 5. /
1369	#define IDENTIFIER_ASSIGN_OP_P(NODE) \
1370	(get_identifier_kind (NODE) == cik_assign_op)
1371
1372	/ True if this identifier is the name of a type-conversion*
1373	operator. Value 6. /*
1374	#define IDENTIFIER_CONV_OP_P(NODE) \
1375	(get_identifier_kind (NODE) == cik_conv_op)
1376
1377	/ True if this identifier is the name of a built-in trait. /
1378	#define IDENTIFIER_TRAIT_P(NODE) \
1379	(get_identifier_kind (NODE) == cik_trait)
1380
1381	/ True if this identifier is a new or delete operator. /
1382	#define IDENTIFIER_NEWDEL_OP_P(NODE) \
1383	(IDENTIFIER_OVL_OP_P (NODE) \
1384	&& IDENTIFIER_OVL_OP_FLAGS (NODE) & OVL_OP_FLAG_ALLOC)
1385
1386	/ True if this identifier is a new operator. /
1387	#define IDENTIFIER_NEW_OP_P(NODE) \
1388	(IDENTIFIER_OVL_OP_P (NODE) \
1389	&& (IDENTIFIER_OVL_OP_FLAGS (NODE) \
1390	& (OVL_OP_FLAG_ALLOC \| OVL_OP_FLAG_DELETE)) == OVL_OP_FLAG_ALLOC)
1391
1392	/ Access a C++-specific index for identifier NODE.*
1393	Used to optimize operator mappings etc. /*
1394	#define IDENTIFIER_CP_INDEX(NODE) \
1395	(IDENTIFIER_NODE_CHECK(NODE)->base.u.bits.address_space)
1396
1397	/ In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only. /
1398	#define C_TYPE_FIELDS_READONLY(TYPE) \
1399	(LANG_TYPE_CLASS_CHECK (TYPE)->fields_readonly)
1400
1401	/ The tokens stored in the unparsed operand. /
1402
1403	#define DEFPARSE_TOKENS(NODE) \
1404	(((struct tree_deferred_parse *)DEFERRED_PARSE_CHECK (NODE))->tokens)
1405	#define DEFPARSE_INSTANTIATIONS(NODE) \
1406	(((struct tree_deferred_parse *)DEFERRED_PARSE_CHECK (NODE))->instantiations)
1407
1408	struct GTY (()) tree_deferred_parse {
1409	struct tree_base base;
1410	struct cp_token_cache *tokens;
1411	vec<tree, va_gc> *instantiations;
1412	};
1413
1414
1415	#define DEFERRED_NOEXCEPT_PATTERN(NODE) \
1416	(((struct tree_deferred_noexcept *)DEFERRED_NOEXCEPT_CHECK (NODE))->pattern)
1417	#define DEFERRED_NOEXCEPT_ARGS(NODE) \
1418	(((struct tree_deferred_noexcept *)DEFERRED_NOEXCEPT_CHECK (NODE))->args)
1419	#define DEFERRED_NOEXCEPT_SPEC_P(NODE) \
1420	((NODE) && (TREE_PURPOSE (NODE)) \
1421	&& (TREE_CODE (TREE_PURPOSE (NODE)) == DEFERRED_NOEXCEPT))
1422	#define UNEVALUATED_NOEXCEPT_SPEC_P(NODE) \
1423	(DEFERRED_NOEXCEPT_SPEC_P (NODE) \
1424	&& DEFERRED_NOEXCEPT_PATTERN (TREE_PURPOSE (NODE)) == NULL_TREE)
1425	#define UNPARSED_NOEXCEPT_SPEC_P(NODE) \
1426	((NODE) && (TREE_PURPOSE (NODE)) \
1427	&& (TREE_CODE (TREE_PURPOSE (NODE)) == DEFERRED_PARSE))
1428
1429	struct GTY (()) tree_deferred_noexcept {
1430	struct tree_base base;
1431	tree pattern;
1432	tree args;
1433	};
1434
1435
1436	/ The condition associated with the static assertion. This must be*
1437	an integral constant expression. /*
1438	#define STATIC_ASSERT_CONDITION(NODE) \
1439	(((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->condition)
1440
1441	/ The message associated with the static assertion. This must be a*
1442	string constant, which will be emitted as an error message when the
1443	static assert condition is false. /*
1444	#define STATIC_ASSERT_MESSAGE(NODE) \
1445	(((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->message)
1446
1447	/ Source location information for a static assertion. /
1448	#define STATIC_ASSERT_SOURCE_LOCATION(NODE) \
1449	(((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->location)
1450
1451	/ True if this static assert represents a C++26 consteval block. /
1452	#define CONSTEVAL_BLOCK_P(NODE) \
1453	TREE_LANG_FLAG_0 (STATIC_ASSERT_CHECK (NODE))
1454
1455	struct GTY (()) tree_static_assert {
1456	struct tree_base base;
1457	tree condition;
1458	tree message;
1459	location_t location;
1460	};
1461
1462	struct GTY (()) tree_argument_pack_select {
1463	struct tree_base base;
1464	tree argument_pack;
1465	int index;
1466	};
1467
1468	/ The different kinds of traits that we encounter. The size is limited to*
1469	addr_space_t since a trait is looked up by IDENTIFIER_CP_INDEX. /*
1470	enum cp_trait_kind : addr_space_t {
1471	#define DEFTRAIT(TCC, CODE, NAME, ARITY) \
1472	CPTK_##CODE,
1473	#include "cp-trait.def"
1474	#undef DEFTRAIT
1475	};
1476
1477	/ The trait type. /
1478	struct cp_trait {
1479	const char *name;
1480	cp_trait_kind kind;
1481	short arity;
1482	bool type;
1483	};
1484
1485	/ The trait table indexed by cp_trait_kind. /
1486	extern const struct cp_trait cp_traits[];
1487
1488	/ The types that we are processing. /
1489	#define TRAIT_EXPR_TYPE1(NODE) \
1490	(((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type1)
1491
1492	#define TRAIT_EXPR_TYPE2(NODE) \
1493	(((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type2)
1494
1495	/ The specific trait that we are processing. /
1496	#define TRAIT_EXPR_KIND(NODE) \
1497	(((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->kind)
1498
1499	#define TRAIT_EXPR_LOCATION(NODE) \
1500	(((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->locus)
1501
1502	struct GTY (()) tree_trait_expr {
1503	struct tree_typed typed;
1504	tree type1;
1505	tree type2;
1506	location_t locus;
1507	enum cp_trait_kind kind;
1508	};
1509
1510	/ An INTEGER_CST containing the kind of the trait type NODE. /
1511	#define TRAIT_TYPE_KIND_RAW(NODE) \
1512	TYPE_VALUES_RAW (TRAIT_TYPE_CHECK (NODE))
1513
1514	/ The kind of the trait type NODE. /
1515	#define TRAIT_TYPE_KIND(NODE) \
1516	((enum cp_trait_kind) TREE_INT_CST_LOW (TRAIT_TYPE_KIND_RAW (NODE)))
1517
1518	/ The first argument of the trait type NODE. /
1519	#define TRAIT_TYPE_TYPE1(NODE) \
1520	TYPE_MIN_VALUE_RAW (TRAIT_TYPE_CHECK (NODE))
1521
1522	/ The rest of the arguments of the trait type NODE. /
1523	#define TRAIT_TYPE_TYPE2(NODE) \
1524	TYPE_MAX_VALUE_RAW (TRAIT_TYPE_CHECK (NODE))
1525
1526	/ Identifiers used for lambda types are almost anonymous. Use this*
1527	spare flag to distinguish them (they also have the anonymous flag). /*
1528	#define IDENTIFIER_LAMBDA_P(NODE) \
1529	(IDENTIFIER_NODE_CHECK(NODE)->base.protected_flag)
1530
1531	/ Based off of TYPE_UNNAMED_P. /
1532	#define LAMBDA_TYPE_P(NODE) \
1533	(TREE_CODE (NODE) == RECORD_TYPE \
1534	&& TYPE_LINKAGE_IDENTIFIER (NODE) \
1535	&& IDENTIFIER_LAMBDA_P (TYPE_LINKAGE_IDENTIFIER (NODE)))
1536
1537	/ Test if FUNCTION_DECL is a lambda function. /
1538	#define LAMBDA_FUNCTION_P(FNDECL) \
1539	(DECL_DECLARES_FUNCTION_P (FNDECL) \
1540	&& DECL_OVERLOADED_OPERATOR_P (FNDECL) \
1541	&& DECL_OVERLOADED_OPERATOR_IS (FNDECL, CALL_EXPR) \
1542	&& LAMBDA_TYPE_P (CP_DECL_CONTEXT (FNDECL)))
1543
1544	enum cp_lambda_default_capture_mode_type {
1545	CPLD_NONE,
1546	CPLD_COPY,
1547	CPLD_REFERENCE
1548	};
1549
1550	/ The method of default capture, if any. /
1551	#define LAMBDA_EXPR_DEFAULT_CAPTURE_MODE(NODE) \
1552	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->default_capture_mode)
1553
1554	/ The capture-list, including `this'. Each capture is stored as a FIELD_DECL*
1555	* so that the name, type, and field are all together, whether or not it has
1556	* been added to the lambda's class type.
1557	TREE_LIST:
1558	TREE_PURPOSE: The FIELD_DECL for this capture.
1559	TREE_VALUE: The initializer. This is part of a GNU extension. /*
1560	#define LAMBDA_EXPR_CAPTURE_LIST(NODE) \
1561	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->capture_list)
1562
1563	/ During parsing of the lambda-introducer, the node in the capture-list*
1564	that holds the 'this' capture. During parsing of the body, the
1565	capture proxy for that node. /*
1566	#define LAMBDA_EXPR_THIS_CAPTURE(NODE) \
1567	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->this_capture)
1568
1569	/ True iff this lambda was created for a consteval block. /
1570	#define LAMBDA_EXPR_CONSTEVAL_BLOCK_P(NODE) \
1571	TREE_LANG_FLAG_0 (LAMBDA_EXPR_CHECK (NODE))
1572
1573	/ True if we should add "const" when figuring out the type of an entity*
1574	in a lambda. This is false in the parameter-declaration-clause of
1575	a lambda; after that, it will remain false if the mutable keyword is
1576	present. /*
1577	#define LAMBDA_EXPR_CONST_QUAL_P(NODE) \
1578	TREE_LANG_FLAG_1 (LAMBDA_EXPR_CHECK (NODE))
1579
1580	/ True iff uses of a const variable capture were optimized away. /
1581	#define LAMBDA_EXPR_CAPTURE_OPTIMIZED(NODE) \
1582	TREE_LANG_FLAG_2 (LAMBDA_EXPR_CHECK (NODE))
1583
1584	/ Predicate tracking whether the lambda was declared 'static'. /
1585	#define LAMBDA_EXPR_STATIC_P(NODE) \
1586	TREE_LANG_FLAG_3 (LAMBDA_EXPR_CHECK (NODE))
1587
1588	/ True if this TREE_LIST in LAMBDA_EXPR_CAPTURE_LIST is for an explicit*
1589	capture. /*
1590	#define LAMBDA_CAPTURE_EXPLICIT_P(NODE) \
1591	TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
1592
1593	/ The source location of the lambda. /
1594	#define LAMBDA_EXPR_LOCATION(NODE) \
1595	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->locus)
1596
1597	/ The mangling scope for the lambda: FUNCTION_DECL, PARM_DECL, VAR_DECL,*
1598	FIELD_DECL, TYPE_DECL, or NULL_TREE. If this is NULL_TREE, we have no
1599	linkage. /*
1600	#define LAMBDA_EXPR_EXTRA_SCOPE(NODE) \
1601	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->extra_scope)
1602
1603	/ Lambdas in the same extra scope might need a discriminating count.*
1604	For ABI 17, we have single per-scope count, for ABI 18, we have
1605	per-scope, per-signature numbering. /*
1606	#define LAMBDA_EXPR_SCOPE_ONLY_DISCRIMINATOR(NODE) \
1607	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->discriminator_scope)
1608	#define LAMBDA_EXPR_SCOPE_SIG_DISCRIMINATOR(NODE) \
1609	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->discriminator_sig)
1610
1611	/ During parsing of the lambda, a vector of capture proxies which need*
1612	to be pushed once we're done processing a nested lambda. /*
1613	#define LAMBDA_EXPR_PENDING_PROXIES(NODE) \
1614	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->pending_proxies)
1615
1616	/ If NODE was regenerated via tsubst_lambda_expr, this is a TEMPLATE_INFO*
1617	whose TI_TEMPLATE is the immediate LAMBDA_EXPR from which NODE was
1618	regenerated, and TI_ARGS is the full set of template arguments used
1619	to regenerate NODE from the most general lambda. /*
1620	#define LAMBDA_EXPR_REGEN_INFO(NODE) \
1621	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->regen_info)
1622
1623	/ Like PACK_EXPANSION_EXTRA_ARGS, for lambda-expressions. /
1624	#define LAMBDA_EXPR_EXTRA_ARGS(NODE) \
1625	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->extra_args)
1626
1627	/ The closure type of the lambda, which is also the type of the*
1628	LAMBDA_EXPR. /*
1629	#define LAMBDA_EXPR_CLOSURE(NODE) \
1630	(TREE_TYPE (LAMBDA_EXPR_CHECK (NODE)))
1631
1632	struct GTY (()) tree_lambda_expr
1633	{
1634	struct tree_typed typed;
1635	tree capture_list;
1636	tree this_capture;
1637	tree extra_scope;
1638	tree regen_info;
1639	tree extra_args;
1640	vec<tree, va_gc> *pending_proxies;
1641	location_t locus;
1642	enum cp_lambda_default_capture_mode_type default_capture_mode : `2`;
1643	unsigned discriminator_scope : `15`; // Per-scope discriminator
1644	unsigned discriminator_sig : `15`; // Per-scope, per-signature discriminator
1645	};
1646
1647	/ Non-zero if this template specialization has access violations that*
1648	should be rechecked when the function is instantiated outside argument
1649	deduction. /*
1650	#define TINFO_HAS_ACCESS_ERRORS(NODE) \
1651	(TREE_LANG_FLAG_0 (TEMPLATE_INFO_CHECK (NODE)))
1652	#define FNDECL_HAS_ACCESS_ERRORS(NODE) \
1653	(TINFO_HAS_ACCESS_ERRORS (DECL_TEMPLATE_INFO (NODE)))
1654
1655	/ Non-zero if this variable template specialization was specified using a*
1656	template-id, so it's a partial or full specialization and not a definition
1657	of the member template of a particular class specialization. /*
1658	#define TINFO_USED_TEMPLATE_ID(NODE) \
1659	(TREE_LANG_FLAG_1 (TEMPLATE_INFO_CHECK (NODE)))
1660
1661	/ The representation of a deferred access check. /
1662
1663	struct GTY(()) deferred_access_check {
1664	/ The base class in which the declaration is referenced. /
1665	tree binfo;
1666	/ The declaration whose access must be checked. /
1667	tree decl;
1668	/ The declaration that should be used in the error message. /
1669	tree diag_decl;
1670	/ The location of this access. /
1671	location_t loc;
1672	};
1673
1674	struct GTY(()) tree_template_info {
1675	struct tree_base base;
1676	tree tmpl;
1677	tree args;
1678	tree partial;
1679	vec<deferred_access_check, va_gc> *deferred_access_checks;
1680	};
1681
1682	// Constraint information for a C++ declaration. Constraint information is
1683	// comprised of:
1684	//
1685	// - a constraint expression introduced by the template header
1686	// - a constraint expression introduced by a function declarator
1687	// - the associated constraints, which are the conjunction of those,
1688	// and used for declaration matching
1689	//
1690	// The template and declarator requirements are kept to support pretty
1691	// printing constrained declarations.
1692	struct GTY(()) tree_constraint_info {
1693	struct tree_base base;
1694	tree template_reqs;
1695	tree declarator_reqs;
1696	tree associated_constr;
1697	};
1698
1699	// Require that pointer P is non-null before returning.
1700	template<typename T>
1701	inline T*
1702	check_nonnull (T* p)
1703	{
1704	gcc_assert (p);
1705	return p;
1706	}
1707
1708	/ Returns true iff T is non-null and represents constraint info. /
1709	inline tree_constraint_info *
1710	check_constraint_info (tree t)
1711	{
1712	if (t && TREE_CODE (t) == CONSTRAINT_INFO)
1713	return (tree_constraint_info *)t;
1714	return NULL;
1715	}
1716
1717	/ Access the expression describing the template constraints. This may be*
1718	null if no constraints were introduced in the template parameter list,
1719	a requirements clause after the template parameter list, or constraints
1720	through a constrained-type-specifier. /*
1721	#define CI_TEMPLATE_REQS(NODE) \
1722	check_constraint_info (check_nonnull (NODE))->template_reqs
1723
1724	/ Access the expression describing the trailing constraints. This is non-null*
1725	for any implicit instantiation of a constrained declaration. For a
1726	templated declaration it is non-null only when a trailing requires-clause
1727	was specified. /*
1728	#define CI_DECLARATOR_REQS(NODE) \
1729	check_constraint_info (check_nonnull (NODE))->declarator_reqs
1730
1731	/ The computed associated constraint expression for a declaration. /
1732	#define CI_ASSOCIATED_CONSTRAINTS(NODE) \
1733	check_constraint_info (check_nonnull (NODE))->associated_constr
1734
1735	/ Access the constraint-expression introduced by the requires-clause*
1736	associate the template parameter list NODE. /*
1737	#define TEMPLATE_PARMS_CONSTRAINTS(NODE) \
1738	TREE_TYPE (TREE_LIST_CHECK (NODE))
1739
1740	/ Access the logical constraints on the template parameter declaration*
1741	indicated by NODE. /*
1742	#define TEMPLATE_PARM_CONSTRAINTS(NODE) \
1743	TREE_TYPE (TREE_LIST_CHECK (NODE))
1744
1745	/ Non-zero if the noexcept is present in a compound requirement. /
1746	#define COMPOUND_REQ_NOEXCEPT_P(NODE) \
1747	TREE_LANG_FLAG_0 (TREE_CHECK (NODE, COMPOUND_REQ))
1748
1749	/ A TREE_LIST whose TREE_VALUE is the constraints on the 'auto' placeholder*
1750	type NODE, used in an argument deduction constraint. The TREE_PURPOSE
1751	holds the set of template parameters that were in-scope when this 'auto'
1752	was formed. /*
1753	#define PLACEHOLDER_TYPE_CONSTRAINTS_INFO(NODE) \
1754	DECL_SIZE_UNIT (TYPE_NAME (TEMPLATE_TYPE_PARM_CHECK (NODE)))
1755
1756	/ The constraints on the 'auto' placeholder type NODE. /
1757	#define PLACEHOLDER_TYPE_CONSTRAINTS(NODE) \
1758	(PLACEHOLDER_TYPE_CONSTRAINTS_INFO (NODE) \
1759	? TREE_VALUE (PLACEHOLDER_TYPE_CONSTRAINTS_INFO (NODE)) \
1760	: NULL_TREE)
1761
1762	/ True if NODE is a constraint. /
1763	#define CONSTR_P(NODE) \
1764	(TREE_CODE (NODE) == ATOMIC_CONSTR \
1765	\|\| TREE_CODE (NODE) == CONJ_CONSTR \
1766	\|\| TREE_CODE (NODE) == DISJ_CONSTR)
1767
1768	/ Valid for any normalized constraint. /
1769	#define CONSTR_CHECK(NODE) \
1770	TREE_CHECK3 (NODE, ATOMIC_CONSTR, CONJ_CONSTR, DISJ_CONSTR)
1771
1772	/ The CONSTR_INFO stores normalization data for a constraint. It refers to*
1773	the original expression and the expression or declaration
1774	from which the constraint was normalized.
1775
1776	This is TREE_LIST whose TREE_PURPOSE is the original expression and whose
1777	TREE_VALUE is a list of contexts. /*
1778	#define CONSTR_INFO(NODE) \
1779	TREE_TYPE (CONSTR_CHECK (NODE))
1780
1781	/ The expression evaluated by the constraint. /
1782	#define CONSTR_EXPR(NODE) \
1783	TREE_PURPOSE (CONSTR_INFO (NODE))
1784
1785	/ The expression or declaration from which this constraint was normalized.*
1786	This is a TREE_LIST whose TREE_VALUE is either a template-id expression
1787	denoting a concept check or the declaration introducing the constraint.
1788	These are chained to other context objects. /*
1789	#define CONSTR_CONTEXT(NODE) \
1790	TREE_VALUE (CONSTR_INFO (NODE))
1791
1792	/ The parameter mapping for an atomic constraint. /
1793	#define ATOMIC_CONSTR_MAP(NODE) \
1794	TREE_OPERAND (TREE_CHECK (NODE, ATOMIC_CONSTR), 0)
1795
1796	/ Whether the parameter mapping of this atomic constraint*
1797	is already instantiated with concrete template arguments.
1798	Used only in satisfy_atom and in the satisfaction cache. /*
1799	#define ATOMIC_CONSTR_MAP_INSTANTIATED_P(NODE) \
1800	TREE_LANG_FLAG_0 (ATOMIC_CONSTR_CHECK (NODE))
1801
1802	/ Whether the expression for this atomic constraint belongs to a*
1803	concept definition. /*
1804	#define ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P(NODE) \
1805	TREE_LANG_FLAG_1 (ATOMIC_CONSTR_CHECK (NODE))
1806
1807	/ The expression of an atomic constraint. /
1808	#define ATOMIC_CONSTR_EXPR(NODE) \
1809	CONSTR_EXPR (ATOMIC_CONSTR_CHECK (NODE))
1810
1811	/ Whether a PARM_DECL represents a local parameter in a*
1812	requires-expression. /*
1813	#define CONSTRAINT_VAR_P(NODE) \
1814	DECL_LANG_FLAG_2 (TREE_CHECK (NODE, PARM_DECL))
1815
1816	/ The concept constraining this constrained template-parameter. /
1817	#define CONSTRAINED_PARM_CONCEPT(NODE) \
1818	DECL_SIZE_UNIT (TYPE_DECL_CHECK (NODE))
1819	/ Any extra template arguments specified for a constrained*
1820	template-parameter. /*
1821	#define CONSTRAINED_PARM_EXTRA_ARGS(NODE) \
1822	DECL_SIZE (TYPE_DECL_CHECK (NODE))
1823	/ The first template parameter of CONSTRAINED_PARM_CONCEPT to be used as a*
1824	prototype for the constrained parameter in finish_shorthand_constraint,
1825	attached for convenience. /*
1826	#define CONSTRAINED_PARM_PROTOTYPE(NODE) \
1827	DECL_INITIAL (TYPE_DECL_CHECK (NODE))
1828
1829	/ Module flags on FUNCTION,VAR,TYPE,CONCEPT or NAMESPACE*
1830	A TEMPLATE_DECL holds them on the DECL_TEMPLATE_RESULT object --
1831	it's just not practical to keep them consistent. /*
1832	#define DECL_MODULE_CHECK(NODE) \
1833	TREE_NOT_CHECK (NODE, TEMPLATE_DECL)
1834
1835	/ In the purview of a named module (or in the purview of the*
1836	header-unit being compiled). /*
1837	#define DECL_MODULE_PURVIEW_P(N) \
1838	(DECL_LANG_SPECIFIC (DECL_MODULE_CHECK (N))->u.base.module_purview_p)
1839
1840	/ Attached to the named module it is in the purview of. Decls*
1841	attached to the global module will have this false. /*
1842	#define DECL_MODULE_ATTACH_P(N) \
1843	(DECL_LANG_SPECIFIC (DECL_MODULE_CHECK (N))->u.base.module_attach_p)
1844
1845	/ True if the live version of the decl was imported. /
1846	#define DECL_MODULE_IMPORT_P(NODE) \
1847	(DECL_LANG_SPECIFIC (DECL_MODULE_CHECK (NODE))->u.base.module_import_p)
1848
1849	/ True if this decl is in the entity hash & array. This means that*
1850	some variant was imported, even if DECL_MODULE_IMPORT_P is false. /*
1851	#define DECL_MODULE_ENTITY_P(NODE) \
1852	(DECL_LANG_SPECIFIC (DECL_MODULE_CHECK (NODE))->u.base.module_entity_p)
1853
1854	/ DECL that has attached decls for ODR-relatedness. /
1855	#define DECL_MODULE_KEYED_DECLS_P(NODE) \
1856	(DECL_LANG_SPECIFIC (DECL_MODULE_CHECK (NODE))->u.base.module_keyed_decls_p)
1857
1858	/ Whether this is an exported DECL. Held on any decl that can appear*
1859	at namespace scope (function, var, type, template, const or
1860	namespace). templates copy from their template_result, consts have
1861	it for unscoped enums. /*
1862	#define DECL_MODULE_EXPORT_P(NODE) TREE_LANG_FLAG_3 (NODE)
1863
1864	/ Represents a streamed-in translation-unit-local entity. Any use of*
1865	this node when instantiating a template should emit an error. /*
1866	struct GTY(()) tree_tu_local_entity {
1867	struct tree_base base;
1868	tree name;
1869	location_t loc;
1870	};
1871
1872	/ The human-readable name of a translation-unit-local entity as*
1873	an IDENTIFIER_NODE. /*
1874	#define TU_LOCAL_ENTITY_NAME(NODE) \
1875	(((struct tree_tu_local_entity *)TU_LOCAL_ENTITY_CHECK (NODE))->name)
1876
1877	/ The source location of the translation-unit-local entity. /
1878	#define TU_LOCAL_ENTITY_LOCATION(NODE) \
1879	(((struct tree_tu_local_entity *)TU_LOCAL_ENTITY_CHECK (NODE))->loc)
1880
1881
1882	/ The list of local parameters introduced by this requires-expression,*
1883	in the form of a chain of PARM_DECLs. /*
1884	#define REQUIRES_EXPR_PARMS(NODE) \
1885	TREE_OPERAND (TREE_CHECK (NODE, REQUIRES_EXPR), 0)
1886
1887	/ A TREE_LIST of the requirements for this requires-expression.*
1888	The requirements are stored in lexical order within the TREE_VALUE
1889	of each TREE_LIST node. The TREE_PURPOSE of each node is unused. /*
1890	#define REQUIRES_EXPR_REQS(NODE) \
1891	TREE_OPERAND (TREE_CHECK (NODE, REQUIRES_EXPR), 1)
1892
1893	/ Like PACK_EXPANSION_EXTRA_ARGS, for requires-expressions. /
1894	#define REQUIRES_EXPR_EXTRA_ARGS(NODE) \
1895	TREE_OPERAND (TREE_CHECK (NODE, REQUIRES_EXPR), 2)
1896
1897	/ True iff TYPE is cv decltype(^^int). /
1898	#define REFLECTION_TYPE_P(TYPE) (TREE_CODE (TYPE) == META_TYPE)
1899
1900	/ True if NODE is a REFLECT_EXPR. /
1901	#define REFLECT_EXPR_P(NODE) (TREE_CODE (NODE) == REFLECT_EXPR)
1902
1903	/ The handle of a reflection expression. /
1904	#define REFLECT_EXPR_HANDLE(NODE) \
1905	TREE_OPERAND (TREE_CHECK (NODE, REFLECT_EXPR), 0)
1906
1907	/ Various kinds of reflections. Sometimes we cannot simply look at the*
1908	handle and figure out the kind from it. For instance,
1909
1910	consteval void fn(int p) {
1911	constexpr auto rp = parameters_of(^^fn)[0];
1912	// is_variable(^^p) is true
1913	// is_function_parameter(^^p) is false
1914	// is_variable(rp) is false
1915	// is_function_parameter(rp) is true
1916	}
1917
1918	but we represent the handle p with a PARM_DECL in all cases.
1919
1920	The size is limited to addr_space_t because we only have 8 bits. /*
1921
1922	enum reflect_kind : addr_space_t {
1923	/ Detect the category from the handle. /
1924	REFLECT_UNDEF,
1925	/ The reflection represents an object. /
1926	REFLECT_OBJECT,
1927	/ The reflection represents a value. /
1928	REFLECT_VALUE,
1929	/ The reflection represents a variable. Used for underlying*
1930	variable of tuple structured binding. /*
1931	REFLECT_VAR,
1932	/ The reflection represents a function parameter. /
1933	REFLECT_PARM,
1934	/ The reflection represents a data member description. /
1935	REFLECT_DATA_MEMBER_SPEC,
1936	/ The reflection represents a direct base relationship. /
1937	REFLECT_BASE,
1938	/ The reflection represents an annotation. /
1939	REFLECT_ANNOTATION
1940	};
1941
1942	/ The reflect_kind of a REFLECT_EXPR. /
1943	#define REFLECT_EXPR_KIND(NODE) \
1944	(static_cast<reflect_kind> \
1945	(REFLECT_EXPR_CHECK (NODE)->base.u.bits.address_space))
1946
1947	#define SET_REFLECT_EXPR_KIND(NODE, VAL) \
1948	(REFLECT_EXPR_CHECK (NODE)->base.u.bits.address_space = VAL)
1949
1950	/ True if this SPLICE_EXPR represents a splice-expression (as opposed to*
1951	a splice-specifier), so it cannot expand to e.g. a type. /*
1952	#define SPLICE_EXPR_EXPRESSION_P(NODE) \
1953	TREE_LANG_FLAG_0 (SPLICE_EXPR_CHECK (NODE))
1954
1955	/ Helper macro to set SPLICE_EXPR_EXPRESSION_P. This macro handles*
1956	dependent_splice_p trees: either [:T:] or [:T:]<arg>. /*
1957	#define SET_SPLICE_EXPR_EXPRESSION_P(NODE) \
1958	(SPLICE_EXPR_EXPRESSION_P (TREE_CODE (NODE) == SPLICE_EXPR \
1959	? NODE : TREE_OPERAND (NODE, 0)) = true)
1960
1961	/ True if this SPLICE_EXPR is used in foo.[: bar :] or foo->[: bar :]*
1962	context. /*
1963	#define SPLICE_EXPR_MEMBER_ACCESS_P(NODE) \
1964	TREE_LANG_FLAG_1 (SPLICE_EXPR_CHECK (NODE))
1965
1966	/ Helper macro to set SPLICE_EXPR_MEMBER_ACCESS_P. /
1967	#define SET_SPLICE_EXPR_MEMBER_ACCESS_P(NODE, VAL) \
1968	(SPLICE_EXPR_MEMBER_ACCESS_P (TREE_CODE (NODE) == SPLICE_EXPR \
1969	? NODE : TREE_OPERAND (NODE, 0)) = (VAL))
1970
1971	/ True if we are taking the address of this SPLICE_EXPR. /
1972	#define SPLICE_EXPR_ADDRESS_P(NODE) \
1973	TREE_LANG_FLAG_2 (SPLICE_EXPR_CHECK (NODE))
1974
1975	/ Helper macro to set SPLICE_EXPR_ADDRESS_P. /
1976	#define SET_SPLICE_EXPR_ADDRESS_P(NODE, VAL) \
1977	(SPLICE_EXPR_ADDRESS_P (TREE_CODE (NODE) == SPLICE_EXPR \
1978	? NODE : TREE_OPERAND (NODE, 0)) = (VAL))
1979
1980	/ The expression in question for a SPLICE_SCOPE. /
1981	#define SPLICE_SCOPE_EXPR(NODE) \
1982	(TYPE_VALUES_RAW (SPLICE_SCOPE_CHECK (NODE)))
1983
1984	/ True if this splice represents a splice-type-specifier rather than*
1985	a splice-scope-specifier. /*
1986	#define SPLICE_SCOPE_TYPE_P(NODE) \
1987	(SPLICE_SCOPE_CHECK (NODE))->type_common.string_flag
1988
1989	enum cp_tree_node_structure_enum {
1990	TS_CP_GENERIC,
1991	TS_CP_IDENTIFIER,
1992	TS_CP_TPI,
1993	TS_CP_PTRMEM,
1994	TS_CP_OVERLOAD,
1995	TS_CP_BINDING_VECTOR,
1996	TS_CP_BASELINK,
1997	TS_CP_TEMPLATE_DECL,
1998	TS_CP_DEFERRED_PARSE,
1999	TS_CP_DEFERRED_NOEXCEPT,
2000	TS_CP_STATIC_ASSERT,
2001	TS_CP_ARGUMENT_PACK_SELECT,
2002	TS_CP_TRAIT_EXPR,
2003	TS_CP_LAMBDA_EXPR,
2004	TS_CP_TEMPLATE_INFO,
2005	TS_CP_CONSTRAINT_INFO,
2006	TS_CP_USERDEF_LITERAL,
2007	TS_CP_TU_LOCAL_ENTITY
2008	};
2009
2010	/ The resulting tree type. /
2011	union GTY((desc ("cp_tree_node_structure (&%h)"),
2012	chain_next ("(union lang_tree_node *) c_tree_chain_next (&%h.generic)"))) lang_tree_node {
2013	union tree_node GTY ((tag ("TS_CP_GENERIC"),
2014	desc ("tree_node_structure (&%h)"))) generic;
2015	struct template_parm_index GTY ((tag ("TS_CP_TPI"))) tpi;
2016	struct ptrmem_cst GTY ((tag ("TS_CP_PTRMEM"))) ptrmem;
2017	struct tree_overload GTY ((tag ("TS_CP_OVERLOAD"))) overload;
2018	struct tree_binding_vec GTY ((tag ("TS_CP_BINDING_VECTOR"))) binding_vec;
2019	struct tree_baselink GTY ((tag ("TS_CP_BASELINK"))) baselink;
2020	struct tree_template_decl GTY ((tag ("TS_CP_TEMPLATE_DECL"))) template_decl;
2021	struct tree_deferred_parse GTY ((tag ("TS_CP_DEFERRED_PARSE"))) deferred_parse;
2022	struct tree_deferred_noexcept GTY ((tag ("TS_CP_DEFERRED_NOEXCEPT"))) deferred_noexcept;
2023	struct lang_identifier GTY ((tag ("TS_CP_IDENTIFIER"))) identifier;
2024	struct tree_static_assert GTY ((tag ("TS_CP_STATIC_ASSERT")))
2025	static_assertion;
2026	struct tree_argument_pack_select GTY ((tag ("TS_CP_ARGUMENT_PACK_SELECT")))
2027	argument_pack_select;
2028	struct tree_trait_expr GTY ((tag ("TS_CP_TRAIT_EXPR")))
2029	trait_expression;
2030	struct tree_lambda_expr GTY ((tag ("TS_CP_LAMBDA_EXPR")))
2031	lambda_expression;
2032	struct tree_template_info GTY ((tag ("TS_CP_TEMPLATE_INFO")))
2033	template_info;
2034	struct tree_constraint_info GTY ((tag ("TS_CP_CONSTRAINT_INFO")))
2035	constraint_info;
2036	struct tree_userdef_literal GTY ((tag ("TS_CP_USERDEF_LITERAL")))
2037	userdef_literal;
2038	struct tree_tu_local_entity GTY ((tag ("TS_CP_TU_LOCAL_ENTITY")))
2039	tu_local_entity;
2040	};
2041
2042
2043	struct GTY(()) cp_omp_declare_target_attr {
2044	bool attr_syntax;
2045	int device_type;
2046	bool indirect;
2047	};
2048
2049	struct GTY(()) cp_omp_begin_assumes_data {
2050	bool attr_syntax;
2051	};
2052
2053	struct GTY(()) cp_omp_declare_variant_attr {
2054	bool attr_syntax;
2055	tree selector;
2056	};
2057
2058	/ Global state. /
2059
2060	struct GTY(()) saved_scope {
2061	vec<cxx_saved_binding, va_gc> *old_bindings;
2062	tree old_namespace;
2063	vec<tree, va_gc> *decl_ns_list;
2064	tree class_name;
2065	tree class_type;
2066	tree access_specifier;
2067	tree function_decl;
2068	vec<tree, va_gc> *lang_base;
2069	tree lang_name;
2070	tree template_parms;
2071	cp_binding_level *x_previous_class_level;
2072	tree x_saved_tree;
2073
2074	/ Only used for uses of this in trailing return type. /
2075	tree x_current_class_ptr;
2076	tree x_current_class_ref;
2077
2078	/ Only used for uses of this in contract assertion. /
2079	tree x_contract_class_ptr;
2080
2081	int x_processing_template_decl;
2082	int x_processing_specialization;
2083	int x_processing_constraint;
2084	int suppress_location_wrappers;
2085	BOOL_BITFIELD x_processing_postcondition : `1`;
2086	BOOL_BITFIELD x_processing_explicit_instantiation : `1`;
2087	BOOL_BITFIELD need_pop_function_context : `1`;
2088	BOOL_BITFIELD x_processing_omp_trait_property_expr : `1`;
2089
2090	/ Nonzero if we are parsing the discarded statement of a constexpr*
2091	if-statement. /*
2092	BOOL_BITFIELD discarded_stmt : `1`;
2093	/ Nonzero if we are parsing or instantiating the compound-statement*
2094	of consteval if statement. Also set while processing an immediate
2095	invocation. /*
2096	BOOL_BITFIELD consteval_if_p : `1`;
2097	/ Nonzero if we are parsing the substatement of expansion-statement. /
2098	BOOL_BITFIELD expansion_stmt : `1`;
2099
2100	int unevaluated_operand;
2101	int inhibit_evaluation_warnings;
2102	int noexcept_operand;
2103	int ref_temp_count;
2104
2105	struct stmt_tree_s x_stmt_tree;
2106
2107	cp_binding_level *class_bindings;
2108	cp_binding_level *bindings;
2109
2110	hash_map<tree, tree> *GTY((skip)) x_local_specializations;
2111	vec<cp_omp_declare_target_attr, va_gc> *omp_declare_target_attribute;
2112	vec<cp_omp_begin_assumes_data, va_gc> *omp_begin_assumes;
2113	vec<cp_omp_declare_variant_attr, va_gc> *omp_declare_variant_attribute;
2114
2115	struct saved_scope *prev;
2116	};
2117
2118	extern GTY(()) struct saved_scope *scope_chain;
2119
2120	/ The current open namespace. /
2121
2122	#define current_namespace scope_chain->old_namespace
2123
2124	/ The stack for namespaces of current declarations. /
2125
2126	#define decl_namespace_list scope_chain->decl_ns_list
2127
2128	/ IDENTIFIER_NODE: name of current class /
2129
2130	#define current_class_name scope_chain->class_name
2131
2132	/ _TYPE: the type of the current class /
2133
2134	#define current_class_type scope_chain->class_type
2135
2136	/ When parsing a class definition, the access specifier most recently*
2137	given by the user, or, if no access specifier was given, the
2138	default value appropriate for the kind of class (i.e., struct,
2139	class, or union). /*
2140
2141	#define current_access_specifier scope_chain->access_specifier
2142
2143	/ Pointer to the top of the language name stack. /
2144
2145	#define current_lang_base scope_chain->lang_base
2146	#define current_lang_name scope_chain->lang_name
2147
2148	/ When parsing a template declaration, a TREE_LIST represents the*
2149	active template parameters. Each node in the list represents one
2150	level of template parameters. The innermost level is first in the
2151	list. The depth of each level is stored as an INTEGER_CST in the
2152	TREE_PURPOSE of each node. The parameters for that level are
2153	stored in the TREE_VALUE. /*
2154
2155	#define current_template_parms scope_chain->template_parms
2156	#define current_template_depth \
2157	(current_template_parms ? TMPL_PARMS_DEPTH (current_template_parms) : 0)
2158	#define in_template_context (current_template_parms != NULL_TREE)
2159
2160	#define processing_template_decl scope_chain->x_processing_template_decl
2161	#define processing_specialization scope_chain->x_processing_specialization
2162	#define processing_explicit_instantiation scope_chain->x_processing_explicit_instantiation
2163	#define processing_omp_trait_property_expr scope_chain->x_processing_omp_trait_property_expr
2164
2165	/ Nonzero if we are parsing the expression of a contract condition. These*
2166	expressions appear outside the parameter list (like a trailing return
2167	type), but are potentially evaluated. /*
2168
2169	#define processing_contract_condition \
2170	(scope_chain->bindings->kind == sk_contract)
2171
2172	#define processing_postcondition scope_chain->x_processing_postcondition
2173
2174	#define in_discarded_stmt scope_chain->discarded_stmt
2175	#define in_consteval_if_p scope_chain->consteval_if_p
2176	#define in_expansion_stmt scope_chain->expansion_stmt
2177
2178	#define current_ref_temp_count scope_chain->ref_temp_count
2179
2180	/ Nonzero if we're parsing a precondition on a constructor or postcondition*
2181	on destructor. /*
2182	#define contract_class_ptr scope_chain->x_contract_class_ptr
2183
2184	/ RAII sentinel to handle clearing processing_template_decl and restoring*
2185	it when done. /*
2186
2187	class processing_template_decl_sentinel
2188	{
2189	public:
2190	int saved;
2191	processing_template_decl_sentinel (bool reset = true)
2192	: saved (processing_template_decl)
2193	{
2194	if (reset)
2195	processing_template_decl = `0`;
2196	}
2197	~processing_template_decl_sentinel()
2198	{
2199	processing_template_decl = saved;
2200	}
2201	};
2202
2203	/ RAII sentinel to disable certain warnings during template substitution*
2204	and elsewhere. /*
2205
2206	class warning_sentinel
2207	{
2208	public:
2209	int &flag;
2210	int val;
2211	warning_sentinel(int& flag, bool suppress=true)
2212	: flag(flag), val(flag) { if (suppress) flag = `0`; }
2213	~warning_sentinel() { flag = val; }
2214	};
2215
2216	/ RAII sentinel to temporarily override input_location. This will not set*
2217	input_location to UNKNOWN_LOCATION or BUILTINS_LOCATION. /*
2218
2219	class iloc_sentinel
2220	{
2221	location_t saved_loc;
2222	public:
2223	iloc_sentinel (location_t loc): saved_loc (input_location)
2224	{
2225	if (loc >= RESERVED_LOCATION_COUNT)
2226	input_location = loc;
2227	}
2228	~iloc_sentinel ()
2229	{
2230	input_location = saved_loc;
2231	}
2232	};
2233
2234	/ RAII sentinel that saves the value of a variable, optionally*
2235	overrides it right away, and restores its value when the sentinel
2236	id destructed. /*
2237
2238	template <typename T>
2239	class temp_override
2240	{
2241	T& overridden_variable;
2242	T saved_value;
2243	public:
2244	temp_override(T& var) : overridden_variable (var), saved_value (var) {}
2245	temp_override(T& var, T overrider)
2246	: overridden_variable (var), saved_value (var)
2247	{
2248	overridden_variable = overrider;
2249	}
2250	~temp_override() { overridden_variable = saved_value; }
2251	};
2252
2253	/ Wrapping a template parameter in type_identity_t hides it from template*
2254	argument deduction. /*
2255	#if __cpp_lib_type_identity
2256	using std::type_identity_t;
2257	#else
2258	template <typename T>
2259	struct type_identity { typedef T type; };
2260	template <typename T>
2261	using type_identity_t = typename type_identity<T>::type;
2262	#endif
2263
2264	/ Object generator function for temp_override, so you don't need to write the*
2265	type of the object as a template argument.
2266
2267	Use as auto x = make_temp_override (flag); /*
2268
2269	template <typename T>
2270	inline temp_override<T>
2271	make_temp_override (T& var)
2272	{
2273	return { var };
2274	}
2275
2276	/ Likewise, but use as auto x = make_temp_override (flag, value); /
2277
2278	template <typename T>
2279	inline temp_override<T>
2280	make_temp_override (T& var, type_identity_t<T> overrider)
2281	{
2282	return { var, overrider };
2283	}
2284
2285	/ temp_override for in_consteval_if_p, which can't use make_temp_override*
2286	because it is a bitfield. /*
2287
2288	struct in_consteval_if_p_temp_override {
2289	bool save_in_consteval_if_p;
2290	in_consteval_if_p_temp_override ()
2291	: save_in_consteval_if_p (in_consteval_if_p) {}
2292	void reset () { in_consteval_if_p = save_in_consteval_if_p; }
2293	~in_consteval_if_p_temp_override ()
2294	{ reset (); }
2295	};
2296
2297	/ The cached class binding level, from the most recently exited*
2298	class, or NULL if none. /*
2299
2300	#define previous_class_level scope_chain->x_previous_class_level
2301
2302	/ A map from local variable declarations in the body of the template*
2303	presently being instantiated to the corresponding instantiated
2304	local variables. /*
2305
2306	#define local_specializations scope_chain->x_local_specializations
2307
2308	/ Nonzero if we are parsing the operand of a noexcept operator. /
2309
2310	#define cp_noexcept_operand scope_chain->noexcept_operand
2311
2312	struct named_label_entry; / Defined in decl.cc. /
2313
2314	struct named_label_hash : ggc_remove <named_label_entry *>
2315	{
2316	typedef named_label_entry *value_type;
2317	typedef tree compare_type; / An identifier. /
2318
2319	inline static hashval_t hash (value_type);
2320	inline static bool equal (const value_type, compare_type);
2321
2322	static const bool empty_zero_p = true;
2323	inline static void mark_empty (value_type &p) {p = NULL;}
2324	inline static bool is_empty (value_type p) {return !p;}
2325
2326	/ Nothing is deletable. Everything is insertable. /
2327	inline static bool is_deleted (value_type) { return false; }
2328	inline static void mark_deleted (value_type) { gcc_unreachable (); }
2329	};
2330
2331	/ Global state pertinent to the current function. /
2332
2333	struct GTY(()) language_function {
2334	struct c_language_function base;
2335
2336	tree x_current_class_ptr;
2337	tree x_current_class_ref;
2338	tree x_eh_spec_block;
2339	tree x_in_charge_parm;
2340	tree x_vtt_parm;
2341	tree x_return_value;
2342
2343	BOOL_BITFIELD returns_value : `1`;
2344	BOOL_BITFIELD returns_null : `1`;
2345	BOOL_BITFIELD returns_abnormally : `1`;
2346	BOOL_BITFIELD infinite_loop: `1`;
2347	BOOL_BITFIELD x_in_function_try_handler : `1`;
2348	BOOL_BITFIELD x_in_base_initializer : `1`;
2349
2350	/ True if this function can throw an exception. /
2351	BOOL_BITFIELD can_throw : `1`;
2352
2353	BOOL_BITFIELD invalid_constexpr : `1`;
2354	BOOL_BITFIELD throwing_cleanup : `1`;
2355	/ True if we gave any errors in this function. /
2356	BOOL_BITFIELD erroneous : `1`;
2357
2358	hash_table<named_label_hash> *x_named_labels;
2359
2360	cp_binding_level *bindings;
2361
2362	/ Tracking possibly infinite loops. This is a vec<tree> only because*
2363	vec<bool> doesn't work with gtype. /*
2364	vec<tree, va_gc> *infinite_loops;
2365	};
2366
2367	/ The current C++-specific per-function global variables. /
2368
2369	#define cp_function_chain (cfun->language)
2370
2371	/ When we're processing a member function, current_class_ptr is the*
2372	PARM_DECL for the `this' pointer. The current_class_ref is an
2373	expression for `this'. /
2374
2375	#define current_class_ptr \
2376	(*(cfun && cp_function_chain \
2377	? &cp_function_chain->x_current_class_ptr \
2378	: &scope_chain->x_current_class_ptr))
2379	#define current_class_ref \
2380	(*(cfun && cp_function_chain \
2381	? &cp_function_chain->x_current_class_ref \
2382	: &scope_chain->x_current_class_ref))
2383
2384	/ The EH_SPEC_BLOCK for the exception-specifiers for the current*
2385	function, if any. /*
2386
2387	#define current_eh_spec_block cp_function_chain->x_eh_spec_block
2388
2389	/ The `__in_chrg' parameter for the current function. Only used for*
2390	constructors and destructors. /*
2391
2392	#define current_in_charge_parm cp_function_chain->x_in_charge_parm
2393
2394	/ The `__vtt_parm' parameter for the current function. Only used for*
2395	constructors and destructors. /*
2396
2397	#define current_vtt_parm cp_function_chain->x_vtt_parm
2398
2399	/ A boolean flag to control whether we need to clean up the return value if a*
2400	local destructor throws. Only used in functions that return by value a
2401	class with a destructor. Which 'tors don't, so we can use the same
2402	field as current_vtt_parm. /*
2403
2404	#define current_retval_sentinel current_vtt_parm
2405
2406	/ Set to 0 at beginning of a function definition, set to 1 if*
2407	a return statement that specifies a return value is seen. /*
2408
2409	#define current_function_returns_value cp_function_chain->returns_value
2410
2411	/ Set to 0 at beginning of a function definition, set to 1 if*
2412	a return statement with no argument is seen. /*
2413
2414	#define current_function_returns_null cp_function_chain->returns_null
2415
2416	/ Set to 0 at beginning of a function definition, set to 1 if*
2417	a call to a noreturn function is seen. /*
2418
2419	#define current_function_returns_abnormally \
2420	cp_function_chain->returns_abnormally
2421
2422	/ Set to 0 at beginning of a function definition, set to 1 if we see an*
2423	obvious infinite loop. This can have false positives and false
2424	negatives, so it should only be used as a heuristic. /*
2425
2426	#define current_function_infinite_loop cp_function_chain->infinite_loop
2427
2428	/ Nonzero if we are processing a base initializer. Zero elsewhere. /
2429	#define in_base_initializer cp_function_chain->x_in_base_initializer
2430
2431	#define in_function_try_handler cp_function_chain->x_in_function_try_handler
2432
2433	/ Expression always returned from function, or error_mark_node*
2434	otherwise, for use by the automatic named return value optimization. /*
2435
2436	#define current_function_return_value \
2437	(cp_function_chain->x_return_value)
2438
2439	/ In parser.cc. /
2440	extern tree cp_literal_operator_id (const char *);
2441
2442	#define NON_ERROR(NODE) ((NODE) == error_mark_node ? NULL_TREE : (NODE))
2443
2444	/ TRUE if a tree code represents a statement. /
2445	extern bool statement_code_p[MAX_TREE_CODES];
2446
2447	#define STATEMENT_CODE_P(CODE) statement_code_p[(int) (CODE)]
2448
2449	enum languages { lang_c, lang_cplusplus };
2450
2451	/ Macros to make error reporting functions' lives easier. /
2452	#define TYPE_LINKAGE_IDENTIFIER(NODE) \
2453	(TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (NODE)))
2454	#define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (TYPE_IDENTIFIER (NODE)))
2455	#define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (TYPE_IDENTIFIER (NODE)))
2456
2457	/ Any kind of anonymous type. /
2458	#define TYPE_ANON_P(NODE) \
2459	(TYPE_LINKAGE_IDENTIFIER (NODE) \
2460	&& IDENTIFIER_ANON_P (TYPE_LINKAGE_IDENTIFIER (NODE)))
2461
2462	/ Nonzero if NODE, a TYPE, has no name for linkage purposes. /
2463	#define TYPE_UNNAMED_P(NODE) \
2464	(TYPE_ANON_P (NODE) \
2465	&& !IDENTIFIER_LAMBDA_P (TYPE_LINKAGE_IDENTIFIER (NODE)) \
2466	&& !enum_with_enumerator_for_linkage_p (NODE))
2467
2468	/ The _DECL for this _TYPE. /
2469	#define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE)))
2470
2471	/ Nonzero if T is a type that could resolve to any kind of concrete type*
2472	at instantiation time. /*
2473	#define WILDCARD_TYPE_P(T) \
2474	(TREE_CODE (T) == TEMPLATE_TYPE_PARM \
2475	\|\| TREE_CODE (T) == TYPENAME_TYPE \
2476	\|\| TREE_CODE (T) == TYPEOF_TYPE \
2477	\|\| TREE_CODE (T) == BOUND_TEMPLATE_TEMPLATE_PARM \
2478	\|\| TREE_CODE (T) == UNBOUND_CLASS_TEMPLATE \
2479	\|\| TREE_CODE (T) == DECLTYPE_TYPE \
2480	\|\| TREE_CODE (T) == TRAIT_TYPE \
2481	\|\| TREE_CODE (T) == DEPENDENT_OPERATOR_TYPE \
2482	\|\| TREE_CODE (T) == SPLICE_SCOPE \
2483	\|\| TREE_CODE (T) == PACK_INDEX_TYPE)
2484
2485	/ Nonzero if T is a class (or struct or union) type. Also nonzero*
2486	for template type parameters, typename types, and instantiated
2487	template template parameters. Keep these checks in ascending code
2488	order. /*
2489	#define MAYBE_CLASS_TYPE_P(T) (WILDCARD_TYPE_P (T) \|\| CLASS_TYPE_P (T))
2490
2491	/ Set CLASS_TYPE_P for T to VAL. T must be a class, struct, or*
2492	union type. /*
2493	#define SET_CLASS_TYPE_P(T, VAL) \
2494	(TYPE_LANG_FLAG_5 (RECORD_OR_UNION_CHECK (T)) = (VAL))
2495
2496	/ Nonzero if T is a class type. Zero for template type parameters,*
2497	typename types, and so forth. /*
2498	#define CLASS_TYPE_P(T) \
2499	(RECORD_OR_UNION_CODE_P (TREE_CODE (T)) && TYPE_LANG_FLAG_5 (T))
2500
2501	/ Nonzero if T is a class type but not a union. /
2502	#define NON_UNION_CLASS_TYPE_P(T) \
2503	(TREE_CODE (T) == RECORD_TYPE && TYPE_LANG_FLAG_5 (T))
2504
2505	/ Nonzero if T is a class type and is a union. /
2506	#define UNION_TYPE_P(T) \
2507	(TREE_CODE (T) == UNION_TYPE && TYPE_LANG_FLAG_5 (T))
2508
2509	/ Keep these checks in ascending code order. /
2510	#define RECORD_OR_UNION_CODE_P(T) \
2511	((T) == RECORD_TYPE \|\| (T) == UNION_TYPE)
2512	#define OVERLOAD_TYPE_P(T) \
2513	(CLASS_TYPE_P (T) \|\| TREE_CODE (T) == ENUMERAL_TYPE)
2514
2515	/ True if this type is dependent. This predicate is only valid if*
2516	TYPE_DEPENDENT_P_VALID is true. /*
2517	#define TYPE_DEPENDENT_P(NODE) TYPE_LANG_FLAG_0 (NODE)
2518
2519	/ True if dependent_type_p has been called for this type, with the*
2520	result that TYPE_DEPENDENT_P is valid. /*
2521	#define TYPE_DEPENDENT_P_VALID(NODE) TYPE_LANG_FLAG_6(NODE)
2522
2523	/ Nonzero if this type is const-qualified. /
2524	#define CP_TYPE_CONST_P(NODE) \
2525	((cp_type_quals (NODE) & TYPE_QUAL_CONST) != 0)
2526
2527	/ Nonzero if this type is volatile-qualified. /
2528	#define CP_TYPE_VOLATILE_P(NODE) \
2529	((cp_type_quals (NODE) & TYPE_QUAL_VOLATILE) != 0)
2530
2531	/ Nonzero if this type is restrict-qualified. /
2532	#define CP_TYPE_RESTRICT_P(NODE) \
2533	((cp_type_quals (NODE) & TYPE_QUAL_RESTRICT) != 0)
2534
2535	/ Nonzero if this type is const-qualified, but not*
2536	volatile-qualified. Other qualifiers are ignored. This macro is
2537	used to test whether or not it is OK to bind an rvalue to a
2538	reference. /*
2539	#define CP_TYPE_CONST_NON_VOLATILE_P(NODE) \
2540	((cp_type_quals (NODE) & (TYPE_QUAL_CONST \| TYPE_QUAL_VOLATILE)) \
2541	== TYPE_QUAL_CONST)
2542
2543	#define FUNCTION_ARG_CHAIN(NODE) \
2544	TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (NODE)))
2545
2546	/ Given a FUNCTION_DECL, returns the first TREE_LIST out of TYPE_ARG_TYPES*
2547	which refers to a user-written parameter. /*
2548	#define FUNCTION_FIRST_USER_PARMTYPE(NODE) \
2549	skip_artificial_parms_for ((NODE), TYPE_ARG_TYPES (TREE_TYPE (NODE)))
2550
2551	/ Similarly, but for DECL_ARGUMENTS. /
2552	#define FUNCTION_FIRST_USER_PARM(NODE) \
2553	skip_artificial_parms_for ((NODE), DECL_ARGUMENTS (NODE))
2554
2555	/ Nonzero iff TYPE is derived from PARENT. Ignores accessibility and*
2556	ambiguity issues. /*
2557	#define DERIVED_FROM_P(PARENT, TYPE) \
2558	(lookup_base ((TYPE), (PARENT), ba_any, NULL, tf_none) != NULL_TREE)
2559
2560	/ Gives the visibility specification for a class type. /
2561	#define CLASSTYPE_VISIBILITY(TYPE) \
2562	DECL_VISIBILITY (TYPE_MAIN_DECL (TYPE))
2563	#define CLASSTYPE_VISIBILITY_SPECIFIED(TYPE) \
2564	DECL_VISIBILITY_SPECIFIED (TYPE_MAIN_DECL (TYPE))
2565
2566	struct GTY (()) tree_pair_s {
2567	tree purpose;
2568	tree value;
2569	};
2570	typedef tree_pair_s *tree_pair_p;
2571
2572	/ This structure provides additional information above and beyond*
2573	what is provide in the ordinary tree_type. In the past, we used it
2574	for the types of class types, template parameters types, typename
2575	types, and so forth. However, there can be many (tens to hundreds
2576	of thousands) of template parameter types in a compilation, and
2577	there's no need for this additional information in that case.
2578	Therefore, we now use this data structure only for class types.
2579
2580	In the past, it was thought that there would be relatively few
2581	class types. However, in the presence of heavy use of templates,
2582	many (i.e., thousands) of classes can easily be generated.
2583	Therefore, we should endeavor to keep the size of this structure to
2584	a minimum. /*
2585	struct GTY(()) lang_type {
2586	unsigned char align;
2587
2588	unsigned has_type_conversion : `1`;
2589	unsigned has_copy_ctor : `1`;
2590	unsigned has_default_ctor : `1`;
2591	unsigned const_needs_init : `1`;
2592	unsigned ref_needs_init : `1`;
2593	unsigned has_const_copy_assign : `1`;
2594	unsigned use_template : `2`;
2595
2596	unsigned has_mutable : `1`;
2597	unsigned com_interface : `1`;
2598	unsigned non_pod_class : `1`;
2599	unsigned nearly_empty_p : `1`;
2600	unsigned user_align : `1`;
2601	unsigned has_copy_assign : `1`;
2602	unsigned has_new : `1`;
2603	unsigned has_array_new : `1`;
2604
2605	unsigned gets_delete : `2`;
2606	unsigned interface_only : `1`;
2607	unsigned interface_unknown : `1`;
2608	unsigned contains_empty_class_p : `1`;
2609	unsigned anon_aggr : `1`;
2610	unsigned non_zero_init : `1`;
2611	unsigned empty_p : `1`;
2612	/ 32 bits allocated. /
2613
2614	unsigned vec_new_uses_cookie : `1`;
2615	unsigned declared_class : `1`;
2616	unsigned diamond_shaped : `1`;
2617	unsigned repeated_base : `1`;
2618	unsigned being_defined : `1`;
2619	unsigned debug_requested : `1`;
2620	unsigned fields_readonly : `1`;
2621	unsigned ptrmemfunc_flag : `1`;
2622
2623	unsigned lazy_default_ctor : `1`;
2624	unsigned lazy_copy_ctor : `1`;
2625	unsigned lazy_copy_assign : `1`;
2626	unsigned lazy_destructor : `1`;
2627	unsigned has_const_copy_ctor : `1`;
2628	unsigned has_complex_copy_ctor : `1`;
2629	unsigned has_complex_copy_assign : `1`;
2630	unsigned non_aggregate : `1`;
2631
2632	unsigned has_complex_dflt : `1`;
2633	unsigned has_list_ctor : `1`;
2634	unsigned non_std_layout : `1`;
2635	unsigned is_literal : `1`;
2636	unsigned lazy_move_ctor : `1`;
2637	unsigned lazy_move_assign : `1`;
2638	unsigned has_complex_move_ctor : `1`;
2639	unsigned has_complex_move_assign : `1`;
2640
2641	unsigned has_constexpr_ctor : `1`;
2642	unsigned unique_obj_representations : `1`;
2643	unsigned unique_obj_representations_set : `1`;
2644	bool erroneous : `1`;
2645	bool non_pod_aggregate : `1`;
2646	bool non_aggregate_pod : `1`;
2647
2648	/ When adding a flag here, consider whether or not it ought to*
2649	apply to a template instance if it applies to the template. If
2650	so, make sure to copy it in instantiate_class_template!
2651
2652	Also make sure new flags here are streamed in module.cc. /*
2653
2654	/ There are some bits left to fill out a 32-bit word. Keep track*
2655	of this by updating the size of this bitfield whenever you add or
2656	remove a flag. /*
2657	unsigned dummy : `2`;
2658
2659	tree primary_base;
2660	vec<tree_pair_s, va_gc> *vcall_indices;
2661	tree vtables;
2662	tree typeinfo_var;
2663	vec<tree, va_gc> *vbases;
2664	tree as_base;
2665	vec<tree, va_gc> *pure_virtuals;
2666	tree friend_classes;
2667	vec<tree, va_gc> * GTY((reorder ("resort_type_member_vec"))) members;
2668	/ CLASSTYPE_KEY_METHOD for TYPE_POLYMORPHIC_P types, CLASSTYPE_LAMBDA_EXPR*
2669	otherwise. /*
2670	tree key_method;
2671	tree decl_list;
2672	tree befriending_classes;
2673	union maybe_objc_info {
2674	/ If not c_dialect_objc, this part is not even allocated. /
2675	char GTY((tag ("0"))) non_objc;
2676	/ In a RECORD_TYPE, information specific to Objective-C, such*
2677	as a list of adopted protocols or a pointer to a corresponding
2678	@interface. See objc/objc-act.h for details. /*
2679	tree GTY((tag ("1"))) objc_info;
2680	} GTY ((desc ("c_dialect_objc ()"))) info;
2681	};
2682
2683	/ We used to have a variant type for lang_type. Keep the name of the*
2684	checking accessor for the sole survivor. /*
2685	#define LANG_TYPE_CLASS_CHECK(NODE) (TYPE_LANG_SPECIFIC (NODE))
2686
2687	/ Nonzero for _CLASSTYPE means that operator delete is defined. /
2688	#define TYPE_GETS_DELETE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->gets_delete)
2689	#define TYPE_GETS_REG_DELETE(NODE) (TYPE_GETS_DELETE (NODE) & 1)
2690	#define TYPE_GETS_VEC_DELETE(NODE) (TYPE_GETS_DELETE (NODE) & 2)
2691
2692	/ Nonzero if `new NODE[x]' should cause the allocation of extra*
2693	storage to indicate how many array elements are in use. /*
2694	#define TYPE_VEC_NEW_USES_COOKIE(NODE) \
2695	(CLASS_TYPE_P (NODE) \
2696	&& LANG_TYPE_CLASS_CHECK (NODE)->vec_new_uses_cookie)
2697
2698	/ Nonzero means that this _CLASSTYPE node defines ways of converting*
2699	itself to other types. /*
2700	#define TYPE_HAS_CONVERSION(NODE) \
2701	(LANG_TYPE_CLASS_CHECK (NODE)->has_type_conversion)
2702
2703	/ Nonzero means that NODE (a class type) has a default constructor --*
2704	but that it has not yet been declared. /*
2705	#define CLASSTYPE_LAZY_DEFAULT_CTOR(NODE) \
2706	(LANG_TYPE_CLASS_CHECK (NODE)->lazy_default_ctor)
2707
2708	/ Nonzero means that NODE (a class type) has a copy constructor --*
2709	but that it has not yet been declared. /*
2710	#define CLASSTYPE_LAZY_COPY_CTOR(NODE) \
2711	(LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_ctor)
2712
2713	/ Nonzero means that NODE (a class type) has a move constructor --*
2714	but that it has not yet been declared. /*
2715	#define CLASSTYPE_LAZY_MOVE_CTOR(NODE) \
2716	(LANG_TYPE_CLASS_CHECK (NODE)->lazy_move_ctor)
2717
2718	/ Nonzero means that NODE (a class type) has an assignment operator*
2719	-- but that it has not yet been declared. /*
2720	#define CLASSTYPE_LAZY_COPY_ASSIGN(NODE) \
2721	(LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_assign)
2722
2723	/ Nonzero means that NODE (a class type) has an assignment operator*
2724	-- but that it has not yet been declared. /*
2725	#define CLASSTYPE_LAZY_MOVE_ASSIGN(NODE) \
2726	(LANG_TYPE_CLASS_CHECK (NODE)->lazy_move_assign)
2727
2728	/ Nonzero means that NODE (a class type) has a destructor -- but that*
2729	it has not yet been declared. /*
2730	#define CLASSTYPE_LAZY_DESTRUCTOR(NODE) \
2731	(LANG_TYPE_CLASS_CHECK (NODE)->lazy_destructor)
2732
2733	/ Nonzero means that NODE (a class type) is final /
2734	#define CLASSTYPE_FINAL(NODE) \
2735	TYPE_FINAL_P (NODE)
2736
2737
2738	/ Nonzero means that this _CLASSTYPE node overloads operator=(X&). /
2739	#define TYPE_HAS_COPY_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_copy_assign)
2740
2741	/ True iff the class type NODE has an "operator =" whose parameter*
2742	has a parameter of type "const X&". /*
2743	#define TYPE_HAS_CONST_COPY_ASSIGN(NODE) \
2744	(LANG_TYPE_CLASS_CHECK (NODE)->has_const_copy_assign)
2745
2746	/ Nonzero means that this _CLASSTYPE node has an X(X&) constructor. /
2747	#define TYPE_HAS_COPY_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_copy_ctor)
2748	#define TYPE_HAS_CONST_COPY_CTOR(NODE) \
2749	(LANG_TYPE_CLASS_CHECK (NODE)->has_const_copy_ctor)
2750
2751	/ Nonzero if this class has an X(initializer_list<T>) constructor. /
2752	#define TYPE_HAS_LIST_CTOR(NODE) \
2753	(LANG_TYPE_CLASS_CHECK (NODE)->has_list_ctor)
2754
2755	/ Nonzero if this class has a constexpr constructor other than a copy/move*
2756	constructor. Note that a class can have constexpr constructors for
2757	static initialization even if it isn't a literal class. /*
2758	#define TYPE_HAS_CONSTEXPR_CTOR(NODE) \
2759	(LANG_TYPE_CLASS_CHECK (NODE)->has_constexpr_ctor)
2760
2761	/ Nonzero if this class defines an overloaded operator new. (An*
2762	operator new [] doesn't count.) /*
2763	#define TYPE_HAS_NEW_OPERATOR(NODE) \
2764	(LANG_TYPE_CLASS_CHECK (NODE)->has_new)
2765
2766	/ Nonzero if this class defines an overloaded operator new[]. /
2767	#define TYPE_HAS_ARRAY_NEW_OPERATOR(NODE) \
2768	(LANG_TYPE_CLASS_CHECK (NODE)->has_array_new)
2769
2770	/ Nonzero means that this type is being defined. I.e., the left brace*
2771	starting the definition of this type has been seen. /*
2772	#define TYPE_BEING_DEFINED(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->being_defined)
2773
2774	/ Nonzero means that this type is either complete or being defined, so we*
2775	can do lookup in it. /*
2776	#define COMPLETE_OR_OPEN_TYPE_P(NODE) \
2777	(COMPLETE_TYPE_P (NODE) \|\| (CLASS_TYPE_P (NODE) && TYPE_BEING_DEFINED (NODE)))
2778
2779	/ Mark bits for repeated base checks. /
2780	#define TYPE_MARKED_P(NODE) TREE_LANG_FLAG_6 (TYPE_CHECK (NODE))
2781
2782	/ Nonzero if the class NODE has multiple paths to the same (virtual)*
2783	base object. /*
2784	#define CLASSTYPE_DIAMOND_SHAPED_P(NODE) \
2785	(LANG_TYPE_CLASS_CHECK(NODE)->diamond_shaped)
2786
2787	/ Nonzero if the class NODE has multiple instances of the same base*
2788	type. /*
2789	#define CLASSTYPE_REPEATED_BASE_P(NODE) \
2790	(LANG_TYPE_CLASS_CHECK(NODE)->repeated_base)
2791
2792	/ The member function with which the vtable will be emitted:*
2793	the first noninline non-pure-virtual member function. NULL_TREE
2794	if there is no key function or if this is a class template /*
2795	#define CLASSTYPE_KEY_METHOD(NODE) \
2796	(TYPE_POLYMORPHIC_P (NODE) \
2797	? LANG_TYPE_CLASS_CHECK (NODE)->key_method \
2798	: NULL_TREE)
2799	#define SET_CLASSTYPE_KEY_METHOD(NODE, VALUE) \
2800	(gcc_checking_assert (TYPE_POLYMORPHIC_P (NODE)), \
2801	LANG_TYPE_CLASS_CHECK (NODE)->key_method = (VALUE))
2802
2803	/ Vector of members. During definition, it is unordered and only*
2804	member functions are present. After completion it is sorted and
2805	contains both member functions and non-functions. STAT_HACK is
2806	involved to preserve oneslot per name invariant. /*
2807	#define CLASSTYPE_MEMBER_VEC(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->members)
2808
2809	/ For class templates, this is a TREE_LIST of all member data,*
2810	functions, types, and friends in the order of declaration.
2811	The TREE_PURPOSE of each TREE_LIST is NULL_TREE for a friend,
2812	and the RECORD_TYPE for the class template otherwise. /*
2813	#define CLASSTYPE_DECL_LIST(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->decl_list)
2814
2815	/ A FUNCTION_DECL or OVERLOAD for the constructors for NODE. These*
2816	are the constructors that take an in-charge parameter. /*
2817	#define CLASSTYPE_CONSTRUCTORS(NODE) \
2818	(get_class_binding_direct (NODE, ctor_identifier))
2819
2820	/ A FUNCTION_DECL for the destructor for NODE. This is the*
2821	destructors that take an in-charge parameter. If
2822	CLASSTYPE_LAZY_DESTRUCTOR is true, then this entry will be NULL
2823	until the destructor is created with lazily_declare_fn. /*
2824	#define CLASSTYPE_DESTRUCTOR(NODE) \
2825	(get_class_binding_direct (NODE, dtor_identifier))
2826
2827	/ Nonzero if NODE has a primary base class, i.e., a base class with*
2828	which it shares the virtual function table pointer. /*
2829	#define CLASSTYPE_HAS_PRIMARY_BASE_P(NODE) \
2830	(CLASSTYPE_PRIMARY_BINFO (NODE) != NULL_TREE)
2831
2832	/ If non-NULL, this is the binfo for the primary base class, i.e.,*
2833	the base class which contains the virtual function table pointer
2834	for this class. /*
2835	#define CLASSTYPE_PRIMARY_BINFO(NODE) \
2836	(LANG_TYPE_CLASS_CHECK (NODE)->primary_base)
2837
2838	/ A vector of BINFOs for the direct and indirect virtual base classes*
2839	that this type uses in a post-order depth-first left-to-right
2840	order. (In other words, these bases appear in the order that they
2841	should be initialized.) /*
2842	#define CLASSTYPE_VBASECLASSES(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->vbases)
2843
2844	/ The type corresponding to NODE when NODE is used as a base class,*
2845	i.e., NODE without virtual base classes or tail padding. /*
2846	#define CLASSTYPE_AS_BASE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->as_base)
2847
2848	/ True iff NODE is the CLASSTYPE_AS_BASE version of some type. /
2849	#define IS_FAKE_BASE_TYPE(NODE) \
2850	(RECORD_OR_UNION_TYPE_P (NODE) \
2851	&& TYPE_CONTEXT (NODE) && CLASS_TYPE_P (TYPE_CONTEXT (NODE)) \
2852	&& CLASSTYPE_AS_BASE (TYPE_CONTEXT (NODE)) == (NODE))
2853
2854	/ These are the size and alignment of the type without its virtual*
2855	base classes, for when we use this type as a base itself. /*
2856	#define CLASSTYPE_SIZE(NODE) TYPE_SIZE (CLASSTYPE_AS_BASE (NODE))
2857	#define CLASSTYPE_SIZE_UNIT(NODE) TYPE_SIZE_UNIT (CLASSTYPE_AS_BASE (NODE))
2858	#define CLASSTYPE_ALIGN(NODE) TYPE_ALIGN (CLASSTYPE_AS_BASE (NODE))
2859	#define CLASSTYPE_USER_ALIGN(NODE) TYPE_USER_ALIGN (CLASSTYPE_AS_BASE (NODE))
2860
2861	/ The alignment of NODE, without its virtual bases, in bytes. /
2862	#define CLASSTYPE_ALIGN_UNIT(NODE) \
2863	(CLASSTYPE_ALIGN (NODE) / BITS_PER_UNIT)
2864
2865	/ A vec<tree> of virtual functions which cannot be inherited by*
2866	derived classes. When deriving from this type, the derived
2867	class must provide its own definition for each of these functions. /*
2868	#define CLASSTYPE_PURE_VIRTUALS(NODE) \
2869	(LANG_TYPE_CLASS_CHECK (NODE)->pure_virtuals)
2870
2871	/ Nonzero means that this type is an abstract class type. /
2872	#define ABSTRACT_CLASS_TYPE_P(NODE) \
2873	(CLASS_TYPE_P (NODE) && CLASSTYPE_PURE_VIRTUALS(NODE))
2874
2875	/ Nonzero means that this type has an X() constructor. /
2876	#define TYPE_HAS_DEFAULT_CONSTRUCTOR(NODE) \
2877	(LANG_TYPE_CLASS_CHECK (NODE)->has_default_ctor)
2878
2879	/ Nonzero means that this type contains a mutable member. /
2880	#define CLASSTYPE_HAS_MUTABLE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_mutable)
2881	#define TYPE_HAS_MUTABLE_P(NODE) (cp_has_mutable_p (NODE))
2882
2883	/ Nonzero means that this class type is not POD for the purpose of layout*
2884	(as defined in the ABI). This is different from the language's POD. /*
2885	#define CLASSTYPE_NON_LAYOUT_POD_P(NODE) \
2886	(LANG_TYPE_CLASS_CHECK (NODE)->non_pod_class)
2887
2888	/ Nonzero means that this class type is a non-standard-layout class. /
2889	#define CLASSTYPE_NON_STD_LAYOUT(NODE) \
2890	(LANG_TYPE_CLASS_CHECK (NODE)->non_std_layout)
2891
2892	/ Nonzero means that this class type does have unique object*
2893	representations. /*
2894	#define CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS(NODE) \
2895	(LANG_TYPE_CLASS_CHECK (NODE)->unique_obj_representations)
2896
2897	/ Nonzero means that this class type has*
2898	CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS computed. /*
2899	#define CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET(NODE) \
2900	(LANG_TYPE_CLASS_CHECK (NODE)->unique_obj_representations_set)
2901
2902	/ Nonzero means that this class contains pod types whose default*
2903	initialization is not a zero initialization (namely, pointers to
2904	data members). /*
2905	#define CLASSTYPE_NON_ZERO_INIT_P(NODE) \
2906	(LANG_TYPE_CLASS_CHECK (NODE)->non_zero_init)
2907
2908	/ Nonzero if this class is "empty" in the sense of the C++ ABI. /
2909	#define CLASSTYPE_EMPTY_P(NODE) \
2910	(LANG_TYPE_CLASS_CHECK (NODE)->empty_p)
2911
2912	/ Nonzero if this class is "nearly empty", i.e., contains only a*
2913	virtual function table pointer. /*
2914	#define CLASSTYPE_NEARLY_EMPTY_P(NODE) \
2915	(LANG_TYPE_CLASS_CHECK (NODE)->nearly_empty_p)
2916
2917	/ Nonzero if this class contains an empty subobject. /
2918	#define CLASSTYPE_CONTAINS_EMPTY_CLASS_P(NODE) \
2919	(LANG_TYPE_CLASS_CHECK (NODE)->contains_empty_class_p)
2920
2921	/ A list of class types of which this type is a friend. The*
2922	TREE_VALUE is normally a TYPE, but will be a TEMPLATE_DECL in the
2923	case of a template friend. /*
2924	#define CLASSTYPE_FRIEND_CLASSES(NODE) \
2925	(LANG_TYPE_CLASS_CHECK (NODE)->friend_classes)
2926
2927	/ A list of the classes which grant friendship to this class. /
2928	#define CLASSTYPE_BEFRIENDING_CLASSES(NODE) \
2929	(LANG_TYPE_CLASS_CHECK (NODE)->befriending_classes)
2930
2931	/ The associated LAMBDA_EXPR that made this class. /
2932	#define CLASSTYPE_LAMBDA_EXPR(NODE) \
2933	(CLASS_TYPE_P (NODE) && TYPE_POLYMORPHIC_P (NODE) \
2934	? NULL_TREE \
2935	: LANG_TYPE_CLASS_CHECK (NODE)->key_method)
2936	#define SET_CLASSTYPE_LAMBDA_EXPR(NODE, VALUE) \
2937	(gcc_checking_assert (!TYPE_POLYMORPHIC_P (NODE)), \
2938	LANG_TYPE_CLASS_CHECK (NODE)->key_method = (VALUE))
2939	/ The extra mangling scope for this closure type. /
2940	#define LAMBDA_TYPE_EXTRA_SCOPE(NODE) \
2941	(LAMBDA_EXPR_EXTRA_SCOPE (CLASSTYPE_LAMBDA_EXPR (NODE)))
2942
2943	/ Say whether this node was declared as a "class" or a "struct". /
2944	#define CLASSTYPE_DECLARED_CLASS(NODE) \
2945	(LANG_TYPE_CLASS_CHECK (NODE)->declared_class)
2946
2947	/ Nonzero if this class has const members*
2948	which have no specified initialization. /*
2949	#define CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE) \
2950	(TYPE_LANG_SPECIFIC (NODE) \
2951	? LANG_TYPE_CLASS_CHECK (NODE)->const_needs_init : 0)
2952	#define SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE, VALUE) \
2953	(LANG_TYPE_CLASS_CHECK (NODE)->const_needs_init = (VALUE))
2954
2955	/ Nonzero if this class has ref members*
2956	which have no specified initialization. /*
2957	#define CLASSTYPE_REF_FIELDS_NEED_INIT(NODE) \
2958	(TYPE_LANG_SPECIFIC (NODE) \
2959	? LANG_TYPE_CLASS_CHECK (NODE)->ref_needs_init : 0)
2960	#define SET_CLASSTYPE_REF_FIELDS_NEED_INIT(NODE, VALUE) \
2961	(LANG_TYPE_CLASS_CHECK (NODE)->ref_needs_init = (VALUE))
2962
2963	/ Nonzero if this class is included from a header file which employs*
2964	`#pragma interface', and it is not included in its implementation file. /*
2965	#define CLASSTYPE_INTERFACE_ONLY(NODE) \
2966	(LANG_TYPE_CLASS_CHECK (NODE)->interface_only)
2967
2968	/ True if we have already determined whether or not vtables, VTTs,*
2969	typeinfo, and other similar per-class data should be emitted in
2970	this translation unit. This flag does not indicate whether or not
2971	these items should be emitted; it only indicates that we know one
2972	way or the other. /*
2973	#define CLASSTYPE_INTERFACE_KNOWN(NODE) \
2974	(LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown == 0)
2975	/ The opposite of CLASSTYPE_INTERFACE_KNOWN. /
2976	#define CLASSTYPE_INTERFACE_UNKNOWN(NODE) \
2977	(LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown)
2978
2979	#define SET_CLASSTYPE_INTERFACE_UNKNOWN_X(NODE,X) \
2980	(LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = !!(X))
2981	#define SET_CLASSTYPE_INTERFACE_UNKNOWN(NODE) \
2982	(LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 1)
2983	#define SET_CLASSTYPE_INTERFACE_KNOWN(NODE) \
2984	(LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 0)
2985
2986	/ Nonzero if a _DECL node requires us to output debug info for this class. /
2987	#define CLASSTYPE_DEBUG_REQUESTED(NODE) \
2988	(LANG_TYPE_CLASS_CHECK (NODE)->debug_requested)
2989
2990	/ True if we saw errors while instantiating this class. /
2991	#define CLASSTYPE_ERRONEOUS(NODE) \
2992	(LANG_TYPE_CLASS_CHECK (NODE)->erroneous)
2993
2994	/ True if this class is non-layout-POD only because it was not an aggregate*
2995	before C++14. If we run out of bits in lang_type, this could be replaced
2996	with a hash_set only filled in when abi_version_crosses (17). /*
2997	#define CLASSTYPE_NON_POD_AGGREGATE(NODE) \
2998	(LANG_TYPE_CLASS_CHECK (NODE)->non_pod_aggregate)
2999
3000	/ True if this class is layout-POD though it's not an aggregate in C++20 and*
3001	above (c++/120012). This could also be a hash_set. /*
3002	#define CLASSTYPE_NON_AGGREGATE_POD(NODE) \
3003	(LANG_TYPE_CLASS_CHECK (NODE)->non_aggregate_pod)
3004
3005	/ Additional macros for inheritance information. /
3006
3007	/ Nonzero means that this class is on a path leading to a new vtable. /
3008	#define BINFO_VTABLE_PATH_MARKED(NODE) BINFO_FLAG_1 (NODE)
3009
3010	/ Nonzero means B (a BINFO) has its own vtable. Any copies will not*
3011	have this flag set. /*
3012	#define BINFO_NEW_VTABLE_MARKED(B) (BINFO_FLAG_2 (B))
3013
3014	/ Compare a BINFO_TYPE with another type for equality. For a binfo,*
3015	this is functionally equivalent to using same_type_p, but
3016	measurably faster. At least one of the arguments must be a
3017	BINFO_TYPE. The other can be a BINFO_TYPE or a regular type. If
3018	BINFO_TYPE(T) ever stops being the main variant of the class the
3019	binfo is for, this macro must change. /*
3020	#define SAME_BINFO_TYPE_P(A, B) ((A) == (B))
3021
3022	/ Any subobject that needs a new vtable must have a vptr and must not*
3023	be a non-virtual primary base (since it would then use the vtable from a
3024	derived class and never become non-primary.) /*
3025	#define SET_BINFO_NEW_VTABLE_MARKED(B) \
3026	(BINFO_NEW_VTABLE_MARKED (B) = 1, \
3027	gcc_assert (!BINFO_PRIMARY_P (B) \|\| BINFO_VIRTUAL_P (B)), \
3028	gcc_assert (TYPE_VFIELD (BINFO_TYPE (B))))
3029
3030	/ Nonzero if this binfo is for a dependent base - one that should not*
3031	be searched. /*
3032	#define BINFO_DEPENDENT_BASE_P(NODE) BINFO_FLAG_3 (NODE)
3033
3034	/ Nonzero if this binfo has lost its primary base binfo (because that*
3035	is a nearly-empty virtual base that has been taken by some other
3036	base in the complete hierarchy. /*
3037	#define BINFO_LOST_PRIMARY_P(NODE) BINFO_FLAG_4 (NODE)
3038
3039	/ Nonzero if this BINFO is a primary base class. /
3040	#define BINFO_PRIMARY_P(NODE) BINFO_FLAG_5(NODE)
3041
3042	/ A vec<tree_pair_s> of the vcall indices associated with the class*
3043	NODE. The PURPOSE of each element is a FUNCTION_DECL for a virtual
3044	function. The VALUE is the index into the virtual table where the
3045	vcall offset for that function is stored, when NODE is a virtual
3046	base. /*
3047	#define CLASSTYPE_VCALL_INDICES(NODE) \
3048	(LANG_TYPE_CLASS_CHECK (NODE)->vcall_indices)
3049
3050	/ The various vtables for the class NODE. The primary vtable will be*
3051	first, followed by the construction vtables and VTT, if any. /*
3052	#define CLASSTYPE_VTABLES(NODE) \
3053	(LANG_TYPE_CLASS_CHECK (NODE)->vtables)
3054
3055	/ The std::type_info variable representing this class, or NULL if no*
3056	such variable has been created. This field is only set for the
3057	TYPE_MAIN_VARIANT of the class. /*
3058	#define CLASSTYPE_TYPEINFO_VAR(NODE) \
3059	(LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var)
3060
3061	/ Accessor macros for the BINFO_VIRTUALS list. /
3062
3063	/ The number of bytes by which to adjust the `this' pointer when*
3064	calling this virtual function. Subtract this value from the this
3065	pointer. Always non-NULL, might be constant zero though. /*
3066	#define BV_DELTA(NODE) (TREE_PURPOSE (NODE))
3067
3068	/ If non-NULL, the vtable index at which to find the vcall offset*
3069	when calling this virtual function. Add the value at that vtable
3070	index to the this pointer. /*
3071	#define BV_VCALL_INDEX(NODE) (TREE_TYPE (NODE))
3072
3073	/ The function to call. /
3074	#define BV_FN(NODE) (TREE_VALUE (NODE))
3075
3076	/ Whether or not this entry is for a lost primary virtual base. /
3077	#define BV_LOST_PRIMARY(NODE) (TREE_LANG_FLAG_0 (NODE))
3078
3079	/ For FUNCTION_TYPE or METHOD_TYPE, a list of the exceptions that*
3080	this type can raise. Each TREE_VALUE is a _TYPE. The TREE_VALUE
3081	will be NULL_TREE to indicate a throw specification of `()', or
3082	no exceptions allowed. For a noexcept specification, TREE_VALUE
3083	is NULL_TREE and TREE_PURPOSE is the constant-expression. For
3084	a deferred noexcept-specification, TREE_PURPOSE is a DEFERRED_NOEXCEPT
3085	(for templates) or an OVERLOAD list of functions (for implicitly
3086	declared functions). /*
3087	#define TYPE_RAISES_EXCEPTIONS(NODE) \
3088	TYPE_LANG_SLOT_1 (FUNC_OR_METHOD_CHECK (NODE))
3089
3090	/ For FUNCTION_TYPE or METHOD_TYPE, return 1 iff it is declared `throw()'*
3091	or noexcept(true). /*
3092	#define TYPE_NOTHROW_P(NODE) nothrow_spec_p (TYPE_RAISES_EXCEPTIONS (NODE))
3093
3094	/ For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the*
3095	case for things declared noexcept(true) and, with -fnothrow-opt, for
3096	throw() functions. /*
3097	#define TYPE_NOEXCEPT_P(NODE) type_noexcept_p (NODE)
3098
3099	/ The binding level associated with the namespace. /
3100	#define NAMESPACE_LEVEL(NODE) \
3101	(LANG_DECL_NS_CHECK (NODE)->level)
3102
3103	/ Discriminator values for lang_decl. /
3104
3105	enum lang_decl_selector
3106	{
3107	lds_min,
3108	lds_fn,
3109	lds_ns,
3110	lds_parm,
3111	lds_decomp
3112	};
3113
3114	/ Flags shared by all forms of DECL_LANG_SPECIFIC.*
3115
3116	Some of the flags live here only to make lang_decl_min/fn smaller. Do
3117	not make this struct larger than 32 bits. /*
3118
3119	struct GTY(()) lang_decl_base {
3120	ENUM_BITFIELD(lang_decl_selector) selector : `3`;
3121	ENUM_BITFIELD(languages) language : `1`;
3122	unsigned use_template : `2`;
3123	unsigned not_really_extern : `1`; / var or fn /
3124	unsigned initialized_in_class : `1`; / var or fn /
3125
3126	unsigned threadprivate_or_deleted_p : `1`; / var or fn /
3127	/ anticipated_p is no longer used for anticipated_decls (fn, type*
3128	or template). It is used as DECL_OMP_PRIVATIZED_MEMBER in
3129	var. /*
3130	unsigned anticipated_p : `1`;
3131	unsigned friend_or_tls : `1`; / var, fn, type or template /
3132	unsigned unknown_bound_p : `1`; / var /
3133	unsigned odr_used : `1`; / var or fn /
3134	unsigned concept_p : `1`; / applies to vars and functions /
3135	unsigned var_declared_inline_p : `1`; / var /
3136	unsigned dependent_init_p : `1`; / var /
3137
3138	/ The following four apply to VAR, FUNCTION, TYPE, CONCEPT, & NAMESPACE*
3139	decls. /*
3140	unsigned module_purview_p : `1`; / in named-module purview /
3141	unsigned module_attach_p : `1`; / attached to named module /
3142	unsigned module_import_p : `1`; / from an import /
3143	unsigned module_entity_p : `1`; / is in the entitity ary & hash /
3144
3145	unsigned module_keyed_decls_p : `1`; / has keys, applies to all decls /
3146
3147	/ VAR_DECL being used to represent an OpenMP declared mapper. /
3148	unsigned omp_declare_mapper_p : `1`;
3149
3150	/ 10 spare bits. /
3151	};
3152
3153	/ True for DECL codes which have template info and access. /
3154	#define LANG_DECL_HAS_MIN(NODE) \
3155	(VAR_OR_FUNCTION_DECL_P (NODE) \
3156	\|\| TREE_CODE (NODE) == FIELD_DECL \
3157	\|\| TREE_CODE (NODE) == CONST_DECL \
3158	\|\| TREE_CODE (NODE) == TYPE_DECL \
3159	\|\| TREE_CODE (NODE) == TEMPLATE_DECL \
3160	\|\| TREE_CODE (NODE) == USING_DECL \
3161	\|\| TREE_CODE (NODE) == CONCEPT_DECL)
3162
3163	/ DECL_LANG_SPECIFIC for the above codes. /
3164
3165	struct GTY(()) lang_decl_min {
3166	struct lang_decl_base base; / 32-bits. /
3167
3168	/ In a FUNCTION_DECL for which DECL_THUNK_P holds, this is*
3169	THUNK_ALIAS.
3170	In a FUNCTION_DECL for which DECL_THUNK_P does not hold,
3171	VAR_DECL, TYPE_DECL, or TEMPLATE_DECL, this is
3172	DECL_TEMPLATE_INFO. /*
3173	tree template_info;
3174
3175	/ In a DECL_THUNK_P FUNCTION_DECL, this is THUNK_VIRTUAL_OFFSET.*
3176	In a lambda-capture proxy VAR_DECL, this is DECL_CAPTURED_VARIABLE.
3177	In a function-scope TREE_STATIC VAR_DECL or IMPLICIT_TYPEDEF_P TYPE_DECL,
3178	this is DECL_DISCRIMINATOR.
3179	In constexpr exception artificial VAR_DECL, this is
3180	DECL_EXCEPTION_REFCOUNT.
3181	In a DECL_LOCAL_DECL_P decl, this is the namespace decl it aliases.
3182	Otherwise, in a class-scope DECL, this is DECL_ACCESS. /*
3183	tree access;
3184	};
3185
3186	enum lang_contract_helper
3187	{
3188	ldf_contract_none = `0`,
3189	ldf_contract_pre,
3190	ldf_contract_post
3191	};
3192
3193	/ Additional DECL_LANG_SPECIFIC information for functions. /
3194
3195	struct GTY(()) lang_decl_fn {
3196	struct lang_decl_min min;
3197
3198	/ In a overloaded operator, this is the compressed operator code. /
3199	unsigned ovl_op_code : `6`;
3200	unsigned global_ctor_p : `1`;
3201	unsigned global_dtor_p : `1`;
3202
3203	unsigned static_function : `1`;
3204	unsigned pure_virtual : `1`;
3205	unsigned defaulted_p : `1`;
3206	unsigned has_in_charge_parm_p : `1`;
3207	unsigned has_vtt_parm_p : `1`;
3208	unsigned pending_inline_p : `1`;
3209	unsigned nonconverting : `1`;
3210	unsigned thunk_p : `1`;
3211
3212	unsigned this_thunk_p : `1`;
3213	unsigned omp_declare_reduction_p : `1`;
3214	unsigned has_dependent_explicit_spec_p : `1`;
3215	unsigned immediate_fn_p : `1`;
3216	unsigned maybe_deleted : `1`;
3217	unsigned coroutine_p : `1`;
3218	unsigned implicit_constexpr : `1`;
3219	unsigned escalated_p : `1`;
3220
3221	unsigned xobj_func : `1`;
3222	unsigned contract_wrapper : `1`;
3223	ENUM_BITFIELD(lang_contract_helper) contract_helper : `2`;
3224
3225	unsigned spare : `4`;
3226
3227	/ 32-bits padding on 64-bit host. /
3228
3229	/ For a non-thunk function decl, this is a tree list of*
3230	friendly classes. For a thunk function decl, it is the
3231	thunked to function decl. /*
3232	tree befriending_classes;
3233
3234	/ For a virtual FUNCTION_DECL for which*
3235	DECL_THIS_THUNK_P does not hold, this is DECL_THUNKS. Both
3236	this pointer and result pointer adjusting thunks are
3237	chained here. This pointer thunks to return pointer thunks
3238	will be chained on the return pointer thunk.
3239	For a DECL_CONSTRUCTOR_P or deduction_guide_p FUNCTION_DECL,
3240	this is the base from whence we inherit.
3241	Otherwise, it is the class in which a (namespace-scope) friend
3242	is defined (if any). /*
3243	tree context;
3244
3245	union lang_decl_u5
3246	{
3247	/ In a non-thunk FUNCTION_DECL, this is DECL_CLONED_FUNCTION. /
3248	tree GTY ((tag ("0"))) cloned_function;
3249
3250	/ In a FUNCTION_DECL for which THUNK_P holds this is the*
3251	THUNK_FIXED_OFFSET. /*
3252	HOST_WIDE_INT GTY ((tag ("1"))) fixed_offset;
3253	} GTY ((desc ("%1.thunk_p"))) u5;
3254
3255	union lang_decl_u3
3256	{
3257	struct cp_token_cache * GTY ((tag ("1"))) pending_inline_info;
3258	tree GTY ((tag ("0"))) saved_auto_return_type;
3259	} GTY ((desc ("%1.pending_inline_p"))) u;
3260
3261	};
3262
3263	/ DECL_LANG_SPECIFIC for namespaces. /
3264
3265	struct GTY(()) lang_decl_ns {
3266	struct lang_decl_base base; / 32 bits. /
3267	cp_binding_level *level;
3268
3269	/ Inline children. Needs to be va_gc, because of PCH. /
3270	vec<tree, va_gc> *inlinees;
3271
3272	/ Hash table of bound decls. It'd be nice to have this inline, but*
3273	as the hash_map has a dtor, we can't then put this struct into a
3274	union (until moving to c++11). /*
3275	hash_table<named_decl_hash> *bindings;
3276	};
3277
3278	/ DECL_LANG_SPECIFIC for parameters. /
3279
3280	struct GTY(()) lang_decl_parm {
3281	struct lang_decl_base base; / 32 bits. /
3282	int level;
3283	int index;
3284	};
3285
3286	/ Additional DECL_LANG_SPECIFIC information for structured bindings. /
3287
3288	struct GTY(()) lang_decl_decomp {
3289	struct lang_decl_min min;
3290	/ The artificial underlying "e" variable of the structured binding*
3291	variable. /*
3292	tree base;
3293	};
3294
3295	/ DECL_LANG_SPECIFIC for all types. It would be nice to just make this a*
3296	union rather than a struct containing a union as its only field, but
3297	tree.h declares it as a struct. /*
3298
3299	struct GTY(()) lang_decl {
3300	union GTY((desc ("%h.base.selector"))) lang_decl_u {
3301	/ Nothing of only the base type exists. /
3302	struct lang_decl_base GTY ((default)) base;
3303	struct lang_decl_min GTY((tag ("lds_min"))) min;
3304	struct lang_decl_fn GTY ((tag ("lds_fn"))) fn;
3305	struct lang_decl_ns GTY((tag ("lds_ns"))) ns;
3306	struct lang_decl_parm GTY((tag ("lds_parm"))) parm;
3307	struct lang_decl_decomp GTY((tag ("lds_decomp"))) decomp;
3308	} u;
3309	};
3310
3311	/ Looks through a template (if present) to find what it declares. /
3312	#define STRIP_TEMPLATE(NODE) \
3313	(TREE_CODE (NODE) == TEMPLATE_DECL ? DECL_TEMPLATE_RESULT (NODE) : NODE)
3314
3315	#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3316
3317	#define LANG_DECL_MIN_CHECK(NODE) __extension__ \
3318	({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \
3319	if (!LANG_DECL_HAS_MIN (NODE)) \
3320	lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
3321	&lt->u.min; })
3322
3323	/ We want to be able to check DECL_CONSTRUCTOR_P and such on a function*
3324	template, not just on a FUNCTION_DECL. So when looking for things in
3325	lang_decl_fn, look down through a TEMPLATE_DECL into its result. /*
3326	#define LANG_DECL_FN_CHECK(NODE) __extension__ \
3327	({ struct lang_decl *lt = DECL_LANG_SPECIFIC (STRIP_TEMPLATE (NODE)); \
3328	if (!DECL_DECLARES_FUNCTION_P (NODE) \
3329	\|\| lt->u.base.selector != lds_fn) \
3330	lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
3331	&lt->u.fn; })
3332
3333	#define LANG_DECL_NS_CHECK(NODE) __extension__ \
3334	({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \
3335	if (TREE_CODE (NODE) != NAMESPACE_DECL \
3336	\|\| lt->u.base.selector != lds_ns) \
3337	lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
3338	&lt->u.ns; })
3339
3340	#define LANG_DECL_PARM_CHECK(NODE) __extension__ \
3341	({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \
3342	if (TREE_CODE (NODE) != PARM_DECL \
3343	\|\| lt->u.base.selector != lds_parm) \
3344	lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
3345	&lt->u.parm; })
3346
3347	#define LANG_DECL_DECOMP_CHECK(NODE) __extension__ \
3348	({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \
3349	if (!VAR_P (NODE) \
3350	\|\| lt->u.base.selector != lds_decomp) \
3351	lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
3352	&lt->u.decomp; })
3353
3354	#else
3355
3356	#define LANG_DECL_MIN_CHECK(NODE) \
3357	(&DECL_LANG_SPECIFIC (NODE)->u.min)
3358
3359	#define LANG_DECL_FN_CHECK(NODE) \
3360	(&DECL_LANG_SPECIFIC (STRIP_TEMPLATE (NODE))->u.fn)
3361
3362	#define LANG_DECL_NS_CHECK(NODE) \
3363	(&DECL_LANG_SPECIFIC (NODE)->u.ns)
3364
3365	#define LANG_DECL_PARM_CHECK(NODE) \
3366	(&DECL_LANG_SPECIFIC (NODE)->u.parm)
3367
3368	#define LANG_DECL_DECOMP_CHECK(NODE) \
3369	(&DECL_LANG_SPECIFIC (NODE)->u.decomp)
3370
3371	#endif /* ENABLE_TREE_CHECKING */
3372
3373	#define CONTRACT_HELPER(NODE) \
3374	(LANG_DECL_FN_CHECK (NODE)->contract_helper)
3375
3376	/ For a FUNCTION_DECL or a VAR_DECL, the language linkage for the*
3377	declaration. Some entities (like a member function in a local
3378	class, or a local variable) do not have linkage at all, and this
3379	macro should not be used in those cases.
3380
3381	Implementation note: A FUNCTION_DECL without DECL_LANG_SPECIFIC was
3382	created by language-independent code, and has C linkage. Most
3383	VAR_DECLs have C++ linkage, and do not have DECL_LANG_SPECIFIC, but
3384	we do create DECL_LANG_SPECIFIC for variables with non-C++ linkage. /*
3385	#define DECL_LANGUAGE(NODE) \
3386	(DECL_LANG_SPECIFIC (NODE) \
3387	? DECL_LANG_SPECIFIC (NODE)->u.base.language \
3388	: (TREE_CODE (NODE) == FUNCTION_DECL \
3389	? lang_c : lang_cplusplus))
3390
3391	/ Set the language linkage for NODE to LANGUAGE. /
3392	#define SET_DECL_LANGUAGE(NODE, LANGUAGE) \
3393	(DECL_LANG_SPECIFIC (NODE)->u.base.language = (LANGUAGE))
3394
3395	/ For FUNCTION_DECLs and TEMPLATE_DECLs: nonzero means that this function*
3396	is a constructor. /*
3397	#define DECL_CONSTRUCTOR_P(NODE) \
3398	DECL_CXX_CONSTRUCTOR_P (STRIP_TEMPLATE (NODE))
3399
3400	/ Nonzero if NODE (a FUNCTION_DECL) is a constructor for a complete*
3401	object. /*
3402	#define DECL_COMPLETE_CONSTRUCTOR_P(NODE) \
3403	(DECL_NAME (NODE) == complete_ctor_identifier)
3404
3405	/ Nonzero if NODE (a FUNCTION_DECL) is a constructor for a base*
3406	object. /*
3407	#define DECL_BASE_CONSTRUCTOR_P(NODE) \
3408	(DECL_NAME (NODE) == base_ctor_identifier)
3409
3410	/ Nonzero if NODE (a FUNCTION_DECL) is a constructor, but not either the*
3411	specialized in-charge constructor or the specialized not-in-charge
3412	constructor. /*
3413	#define DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P(NODE) \
3414	(DECL_NAME (NODE) == ctor_identifier)
3415
3416	/ Nonzero if NODE (a FUNCTION_DECL) is a copy constructor. /
3417	#define DECL_COPY_CONSTRUCTOR_P(NODE) \
3418	(DECL_CONSTRUCTOR_P (NODE) && copy_fn_p (NODE) > 0)
3419
3420	/ Nonzero if NODE (a FUNCTION_DECL) is a move constructor. /
3421	#define DECL_MOVE_CONSTRUCTOR_P(NODE) \
3422	(DECL_CONSTRUCTOR_P (NODE) && move_fn_p (NODE))
3423
3424	/ Nonzero if NODE (a FUNCTION_DECL or TEMPLATE_DECL)*
3425	is a destructor. /*
3426	#define DECL_DESTRUCTOR_P(NODE) \
3427	DECL_CXX_DESTRUCTOR_P (STRIP_TEMPLATE (NODE))
3428
3429	/ Nonzero if NODE (a FUNCTION_DECL) is a destructor, but not the*
3430	specialized in-charge constructor, in-charge deleting constructor,
3431	or the base destructor. /*
3432	#define DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P(NODE) \
3433	(DECL_NAME (NODE) == dtor_identifier)
3434
3435	/ Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete*
3436	object. /*
3437	#define DECL_COMPLETE_DESTRUCTOR_P(NODE) \
3438	(DECL_NAME (NODE) == complete_dtor_identifier)
3439
3440	/ Nonzero if NODE (a FUNCTION_DECL) is a destructor for a base*
3441	object. /*
3442	#define DECL_BASE_DESTRUCTOR_P(NODE) \
3443	(DECL_NAME (NODE) == base_dtor_identifier)
3444
3445	/ Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete*
3446	object that deletes the object after it has been destroyed. /*
3447	#define DECL_DELETING_DESTRUCTOR_P(NODE) \
3448	(DECL_NAME (NODE) == deleting_dtor_identifier)
3449
3450	/ Nonzero if either DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P or*
3451	DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P is true of NODE. /*
3452	#define DECL_MAYBE_IN_CHARGE_CDTOR_P(NODE) \
3453	(DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (NODE) \
3454	\|\| DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (NODE))
3455
3456	/ Nonzero if NODE (a _DECL) is a cloned constructor or*
3457	destructor. /*
3458	#define DECL_CLONED_FUNCTION_P(NODE) \
3459	(DECL_NAME (NODE) \
3460	&& IDENTIFIER_CDTOR_P (DECL_NAME (NODE)) \
3461	&& !DECL_MAYBE_IN_CHARGE_CDTOR_P (NODE))
3462
3463	/ If DECL_CLONED_FUNCTION_P holds, this is the function that was*
3464	cloned. /*
3465	#define DECL_CLONED_FUNCTION(NODE) \
3466	(DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (NODE))->u.fn.u5.cloned_function)
3467
3468	/ Perform an action for each clone of FN, if FN is a function with*
3469	clones. This macro should be used like:
3470
3471	FOR_EACH_CLONE (clone, fn)
3472	{ ... }
3473
3474	*/
3475	#define FOR_EACH_CLONE(CLONE, FN) \
3476	if (!(TREE_CODE (FN) == FUNCTION_DECL \
3477	&& DECL_MAYBE_IN_CHARGE_CDTOR_P (FN))) \
3478	; \
3479	else \
3480	for (CLONE = DECL_CHAIN (FN); \
3481	CLONE && DECL_CLONED_FUNCTION_P (CLONE); \
3482	CLONE = DECL_CHAIN (CLONE))
3483
3484	/ Nonzero if NODE has DECL_DISCRIMINATOR and not DECL_ACCESS. /
3485	#define DECL_DISCRIMINATOR_P(NODE) \
3486	(((VAR_P (NODE) && TREE_STATIC (NODE)) \
3487	\|\| DECL_IMPLICIT_TYPEDEF_P (NODE)) \
3488	&& DECL_FUNCTION_SCOPE_P (NODE))
3489
3490	/ Discriminator for name mangling. /
3491	#define DECL_DISCRIMINATOR(NODE) (LANG_DECL_MIN_CHECK (NODE)->access)
3492
3493	/ The index of a user-declared parameter in its function, starting at 1.*
3494	All artificial parameters will have index 0. /*
3495	#define DECL_PARM_INDEX(NODE) \
3496	(LANG_DECL_PARM_CHECK (NODE)->index)
3497
3498	/ The level of a user-declared parameter in its function, starting at 1.*
3499	A parameter of the function will have level 1; a parameter of the first
3500	nested function declarator (i.e. t in void f (void (p)(T t))) will have*
3501	level 2. /*
3502	#define DECL_PARM_LEVEL(NODE) \
3503	(LANG_DECL_PARM_CHECK (NODE)->level)
3504
3505	/ Nonzero if the VTT parm has been added to NODE. /
3506	#define DECL_HAS_VTT_PARM_P(NODE) \
3507	(LANG_DECL_FN_CHECK (NODE)->has_vtt_parm_p)
3508
3509	/ Nonzero if NODE is a user-defined conversion operator. /
3510	#define DECL_CONV_FN_P(NODE) IDENTIFIER_CONV_OP_P (DECL_NAME (NODE))
3511
3512	/ The type to which conversion operator FN converts to. /
3513	#define DECL_CONV_FN_TYPE(FN) \
3514	TREE_TYPE ((gcc_checking_assert (DECL_CONV_FN_P (FN)), DECL_NAME (FN)))
3515
3516	/ Nonzero if NODE, a templated variable, was declared as an*
3517	array of unknown bound. /*
3518	#define VAR_HAD_UNKNOWN_BOUND(NODE) \
3519	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE)) \
3520	? DECL_LANG_SPECIFIC (NODE)->u.base.unknown_bound_p \
3521	: false)
3522	#define SET_VAR_HAD_UNKNOWN_BOUND(NODE) \
3523	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.unknown_bound_p = true)
3524
3525	/ True iff decl NODE is for an overloaded operator. /
3526	#define DECL_OVERLOADED_OPERATOR_P(NODE) \
3527	IDENTIFIER_ANY_OP_P (DECL_NAME (NODE))
3528
3529	/ Nonzero if NODE is an assignment operator (including += and such). /
3530	#define DECL_ASSIGNMENT_OPERATOR_P(NODE) \
3531	IDENTIFIER_ASSIGN_OP_P (DECL_NAME (NODE))
3532
3533	/ NODE is a function_decl for an overloaded operator. Return its*
3534	compressed (raw) operator code. Note that this is not a TREE_CODE. /*
3535	#define DECL_OVERLOADED_OPERATOR_CODE_RAW(NODE) \
3536	(LANG_DECL_FN_CHECK (NODE)->ovl_op_code)
3537
3538	/ DECL is an overloaded operator. Test whether it is for TREE_CODE*
3539	(a literal constant). /*
3540	#define DECL_OVERLOADED_OPERATOR_IS(DECL, CODE) \
3541	(DECL_OVERLOADED_OPERATOR_CODE_RAW (DECL) == OVL_OP_##CODE)
3542
3543	/ For FUNCTION_DECLs: nonzero means that this function is a*
3544	constructor or a destructor with an extra in-charge parameter to
3545	control whether or not virtual bases are constructed. /*
3546	#define DECL_HAS_IN_CHARGE_PARM_P(NODE) \
3547	(LANG_DECL_FN_CHECK (NODE)->has_in_charge_parm_p)
3548
3549	/ Nonzero if DECL is a declaration of __builtin_constant_p. /
3550	#define DECL_IS_BUILTIN_CONSTANT_P(NODE) \
3551	(TREE_CODE (NODE) == FUNCTION_DECL \
3552	&& DECL_BUILT_IN_CLASS (NODE) == BUILT_IN_NORMAL \
3553	&& DECL_FUNCTION_CODE (NODE) == BUILT_IN_CONSTANT_P)
3554
3555	/ Nonzero for _DECL means that this decl appears in (or will appear*
3556	in) as a member in a RECORD_TYPE or UNION_TYPE node. It is also for
3557	detecting circularity in case members are multiply defined. In the
3558	case of a VAR_DECL, it means that no definition has been seen, even
3559	if an initializer has been. /*
3560	#define DECL_IN_AGGR_P(NODE) (DECL_LANG_FLAG_3 (NODE))
3561
3562	/ Nonzero for a VAR_DECL means that the variable's initialization (if*
3563	any) has been processed. (In general, DECL_INITIALIZED_P is
3564	!DECL_EXTERNAL, but static data members may be initialized even if
3565	not defined.) /*
3566	#define DECL_INITIALIZED_P(NODE) \
3567	(TREE_LANG_FLAG_1 (VAR_DECL_CHECK (NODE)))
3568
3569	/ Nonzero for a VAR_DECL iff an explicit initializer was provided*
3570	or a non-trivial constructor is called. /*
3571	#define DECL_NONTRIVIALLY_INITIALIZED_P(NODE) \
3572	(TREE_LANG_FLAG_6 (VAR_DECL_CHECK (NODE)))
3573
3574	/ Nonzero for a VAR_DECL that was initialized with a*
3575	constant-expression. /*
3576	#define DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P(NODE) \
3577	(TREE_LANG_FLAG_2 (VAR_DECL_CHECK (NODE)))
3578
3579	/ Nonzero if the DECL was initialized in the class definition itself,*
3580	rather than outside the class. This is used for both static member
3581	VAR_DECLS, and FUNCTION_DECLS that are defined in the class. /*
3582	#define DECL_INITIALIZED_IN_CLASS_P(DECL) \
3583	(DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL)) \
3584	->u.base.initialized_in_class)
3585
3586	/ Nonzero if the DECL is used in the sense of 3.2 [basic.def.odr].*
3587	Only available for decls with DECL_LANG_SPECIFIC. /*
3588	#define DECL_ODR_USED(DECL) \
3589	(DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL)) \
3590	->u.base.odr_used)
3591
3592	/ Nonzero for FUNCTION_DECL means that this is a friend that is*
3593	either not pushed into a namespace/looked up in a class (because it
3594	is a dependent type, in an uninstantiated template), or it has
3595	/only/ been subject to hidden friend injection from one or more
3596	befriending classes. Once another decl matches, the flag is
3597	cleared. There are requirements on its default parms. /*
3598	#define DECL_UNIQUE_FRIEND_P(NODE) \
3599	(DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (NODE)) \
3600	->u.base.friend_or_tls)
3601
3602	/ True of a TEMPLATE_DECL that is a template class friend. Such*
3603	decls are not pushed until instantiated (as they may depend on
3604	parameters of the befriending class). DECL_CHAIN is the
3605	befriending class. /*
3606	#define DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P(NODE) \
3607	(DECL_LANG_FLAG_4 (TEMPLATE_DECL_CHECK (NODE)))
3608
3609	/ Nonzero if the thread-local variable was declared with __thread as*
3610	opposed to thread_local. /*
3611	#define DECL_GNU_TLS_P(NODE) \
3612	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE)) \
3613	&& DECL_LANG_SPECIFIC (NODE)->u.base.friend_or_tls)
3614	#define SET_DECL_GNU_TLS_P(NODE) \
3615	(retrofit_lang_decl (VAR_DECL_CHECK (NODE)), \
3616	DECL_LANG_SPECIFIC (NODE)->u.base.friend_or_tls = true)
3617
3618	/ A TREE_LIST of the types which have befriended this FUNCTION_DECL. /
3619	#define DECL_BEFRIENDING_CLASSES(NODE) \
3620	(LANG_DECL_FN_CHECK (NODE)->befriending_classes)
3621
3622	/ Nonzero for FUNCTION_DECL means that this decl is a static*
3623	member function. /*
3624	#define DECL_STATIC_FUNCTION_P(NODE) \
3625	(LANG_DECL_FN_CHECK (NODE)->static_function)
3626
3627	/ Nonzero for FUNCTION_DECL means that this decl is a non-static member*
3628	function. C++23 explicit object member functions are also considered
3629	non-static, but most former uses of this macro meant implicit object member
3630	function. Instead of this macro, use DECL_IOBJ_MEMBER_FUNCTION_P or
3631	DECL_OBJECT_MEMBER_FUNCTION_P. /*
3632	#define DECL_NONSTATIC_MEMBER_FUNCTION_P(NODE) did_you_mean_object_or_iobj
3633
3634	/ Nonzero for FUNCTION_DECL means that this decl is an implicit object*
3635	member function. /*
3636	#define DECL_IOBJ_MEMBER_FUNCTION_P(NODE) \
3637	(TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE)
3638
3639	/ Simple member access, only valid for FUNCTION_DECL nodes. /
3640	#define DECL_FUNCTION_XOBJ_FLAG(NODE) \
3641	(LANG_DECL_FN_CHECK (NODE)->xobj_func)
3642
3643	/ Nonzero if NODE is an xobj member function,*
3644	safely evaluates to false for all non FUNCTION_DECL nodes. /*
3645	#define DECL_XOBJ_MEMBER_FUNCTION_P(NODE) \
3646	(TREE_CODE (STRIP_TEMPLATE (NODE)) == FUNCTION_DECL \
3647	&& DECL_FUNCTION_XOBJ_FLAG (NODE) == 1)
3648
3649	/ Nonzero for FUNCTION_DECL means that this decl is a contract*
3650	wrapper function. /*
3651	#define DECL_CONTRACT_WRAPPER(NODE) \
3652	LANG_DECL_FN_CHECK (NODE)->contract_wrapper
3653
3654	/ Nonzero if NODE is a member function with an object argument,*
3655	in other words, a non-static member function. /*
3656	#define DECL_OBJECT_MEMBER_FUNCTION_P(NODE) \
3657	(DECL_IOBJ_MEMBER_FUNCTION_P (NODE) \|\| DECL_XOBJ_MEMBER_FUNCTION_P (NODE))
3658
3659	/ Nonzero for FUNCTION_DECL means that this decl is a member function*
3660	(static or non-static). /*
3661	#define DECL_FUNCTION_MEMBER_P(NODE) \
3662	(DECL_OBJECT_MEMBER_FUNCTION_P (NODE) \|\| DECL_STATIC_FUNCTION_P (NODE)) \
3663
3664	/ Nonzero for FUNCTION_DECL means that this member function*
3665	has `this' as const X const. /
3666	#define DECL_CONST_MEMFUNC_P(NODE) \
3667	(DECL_IOBJ_MEMBER_FUNCTION_P (NODE) \
3668	&& CP_TYPE_CONST_P (TREE_TYPE (TREE_VALUE \
3669	(TYPE_ARG_TYPES (TREE_TYPE (NODE))))))
3670
3671	/ Nonzero for FUNCTION_DECL means that this member function*
3672	has `this' as volatile X const. /
3673	#define DECL_VOLATILE_MEMFUNC_P(NODE) \
3674	(DECL_IOBJ_MEMBER_FUNCTION_P (NODE) \
3675	&& CP_TYPE_VOLATILE_P (TREE_TYPE (TREE_VALUE \
3676	(TYPE_ARG_TYPES (TREE_TYPE (NODE))))))
3677
3678	/ Nonzero for a DECL means that this member is a non-static member. /
3679	#define DECL_NONSTATIC_MEMBER_P(NODE) \
3680	(DECL_OBJECT_MEMBER_FUNCTION_P (NODE) \
3681	\|\| TREE_CODE (NODE) == FIELD_DECL)
3682
3683	/ Nonzero for a FIELD_DECL means that this member object type*
3684	is mutable. /*
3685	#define DECL_MUTABLE_P(NODE) (DECL_LANG_FLAG_0 (FIELD_DECL_CHECK (NODE)))
3686
3687	/ Nonzero for _DECL means that this constructor or conversion function is*
3688	non-converting. /*
3689	#define DECL_NONCONVERTING_P(NODE) \
3690	(LANG_DECL_FN_CHECK (NODE)->nonconverting)
3691
3692	/ Nonzero for FUNCTION_DECL means that this member function is a pure*
3693	virtual function. /*
3694	#define DECL_PURE_VIRTUAL_P(NODE) \
3695	(LANG_DECL_FN_CHECK (NODE)->pure_virtual)
3696
3697	/ Nonzero for FUNCTION_DECL means that this member function (either*
3698	a constructor or a conversion function) has an explicit specifier
3699	with a value-dependent expression. /*
3700	#define DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P(NODE) \
3701	(LANG_DECL_FN_CHECK (NODE)->has_dependent_explicit_spec_p)
3702
3703	/ Nonzero for a defaulted FUNCTION_DECL for which we haven't decided yet if*
3704	it's deleted; we will decide in synthesize_method. /*
3705	#define DECL_MAYBE_DELETED(NODE) \
3706	(LANG_DECL_FN_CHECK (NODE)->maybe_deleted)
3707
3708	/ Nonzero for FUNCTION_DECL means that this function's body has been*
3709	checked for immediate-escalating expressions and maybe promoted. It
3710	does not* mean the function is consteval. It must not be set in*
3711	a function that was marked consteval by the user, so that we can
3712	distinguish between explicitly consteval functions and promoted consteval
3713	functions. /*
3714	#define DECL_ESCALATION_CHECKED_P(NODE) (LANG_DECL_FN_CHECK (NODE)->escalated_p)
3715
3716	/ True (in a FUNCTION_DECL) if NODE is a virtual function that is an*
3717	invalid overrider for a function from a base class. Once we have
3718	complained about an invalid overrider we avoid complaining about it
3719	again. /*
3720	#define DECL_INVALID_OVERRIDER_P(NODE) \
3721	(DECL_LANG_FLAG_4 (NODE))
3722
3723	/ True (in a FUNCTION_DECL) if NODE is a function declared with*
3724	an override virt-specifier /*
3725	#define DECL_OVERRIDE_P(NODE) (TREE_LANG_FLAG_0 (NODE))
3726
3727	/ The thunks associated with NODE, a FUNCTION_DECL. /
3728	#define DECL_THUNKS(NODE) \
3729	(DECL_VIRTUAL_P (NODE) ? LANG_DECL_FN_CHECK (NODE)->context : NULL_TREE)
3730
3731	/ Set DECL_THUNKS. /
3732	#define SET_DECL_THUNKS(NODE,THUNKS) \
3733	(LANG_DECL_FN_CHECK (NODE)->context = (THUNKS))
3734
3735	/ If NODE, a FUNCTION_DECL, is a C++11 inheriting constructor, then this*
3736	is the constructor it inherits from. /*
3737	#define DECL_INHERITED_CTOR(NODE) \
3738	(DECL_DECLARES_FUNCTION_P (NODE) && DECL_CONSTRUCTOR_P (NODE) \
3739	? LANG_DECL_FN_CHECK (NODE)->context : NULL_TREE)
3740
3741	/ And this is the base that constructor comes from. /
3742	#define DECL_INHERITED_CTOR_BASE(NODE) \
3743	(DECL_INHERITED_CTOR (NODE) \
3744	? DECL_CONTEXT (flag_new_inheriting_ctors \
3745	? strip_inheriting_ctors (NODE) \
3746	: DECL_INHERITED_CTOR (NODE)) \
3747	: NULL_TREE)
3748
3749	/ Set the inherited base. /
3750	#define SET_DECL_INHERITED_CTOR(NODE,INH) \
3751	(LANG_DECL_FN_CHECK (NODE)->context = (INH))
3752
3753	/ Nonzero if NODE is a thunk, rather than an ordinary function. /
3754	#define DECL_THUNK_P(NODE) \
3755	(TREE_CODE (NODE) == FUNCTION_DECL \
3756	&& DECL_LANG_SPECIFIC (NODE) \
3757	&& LANG_DECL_FN_CHECK (NODE)->thunk_p)
3758
3759	/ Set DECL_THUNK_P for node. /
3760	#define SET_DECL_THUNK_P(NODE, THIS_ADJUSTING) \
3761	(LANG_DECL_FN_CHECK (NODE)->thunk_p = 1, \
3762	LANG_DECL_FN_CHECK (NODE)->this_thunk_p = (THIS_ADJUSTING))
3763
3764	/ Nonzero if NODE is a this pointer adjusting thunk. /
3765	#define DECL_THIS_THUNK_P(NODE) \
3766	(DECL_THUNK_P (NODE) && LANG_DECL_FN_CHECK (NODE)->this_thunk_p)
3767
3768	/ Nonzero if NODE is a result pointer adjusting thunk. /
3769	#define DECL_RESULT_THUNK_P(NODE) \
3770	(DECL_THUNK_P (NODE) && !LANG_DECL_FN_CHECK (NODE)->this_thunk_p)
3771
3772	/ Nonzero if NODE is a FUNCTION_DECL, but not a thunk. /
3773	#define DECL_NON_THUNK_FUNCTION_P(NODE) \
3774	(TREE_CODE (NODE) == FUNCTION_DECL && !DECL_THUNK_P (NODE))
3775
3776	/ Nonzero if NODE is `extern "C"'. /
3777	#define DECL_EXTERN_C_P(NODE) \
3778	(DECL_LANGUAGE (NODE) == lang_c)
3779
3780	/ Nonzero if NODE is an `extern "C"' function. /
3781	#define DECL_EXTERN_C_FUNCTION_P(NODE) \
3782	(DECL_NON_THUNK_FUNCTION_P (NODE) && DECL_EXTERN_C_P (NODE))
3783
3784	/ Non-zero if this variable is declared `constinit' specifier. /
3785	#define DECL_DECLARED_CONSTINIT_P(NODE) \
3786	(DECL_LANG_FLAG_7 (VAR_DECL_CHECK (NODE)))
3787
3788	/ True if DECL is declared 'constexpr'. /
3789	#define DECL_DECLARED_CONSTEXPR_P(DECL) \
3790	DECL_LANG_FLAG_8 (VAR_OR_FUNCTION_DECL_CHECK (STRIP_TEMPLATE (DECL)))
3791
3792	/ True if FNDECL is an immediate function. /
3793	#define DECL_IMMEDIATE_FUNCTION_P(NODE) \
3794	(DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (STRIP_TEMPLATE (NODE))) \
3795	? LANG_DECL_FN_CHECK (NODE)->immediate_fn_p \
3796	: false)
3797	#define SET_DECL_IMMEDIATE_FUNCTION_P(NODE) \
3798	(retrofit_lang_decl (FUNCTION_DECL_CHECK (NODE)), \
3799	LANG_DECL_FN_CHECK (NODE)->immediate_fn_p = true)
3800
3801	/ Nonzero if this DECL is the __PRETTY_FUNCTION__ variable in a*
3802	template function. /*
3803	#define DECL_PRETTY_FUNCTION_P(NODE) \
3804	(DECL_NAME (NODE) \
3805	&& id_equal (DECL_NAME (NODE), "__PRETTY_FUNCTION__"))
3806
3807	/ For a DECL, true if it is __func__ or similar. /
3808	#define DECL_FNAME_P(NODE) \
3809	(VAR_P (NODE) && DECL_NAME (NODE) && DECL_ARTIFICIAL (NODE) \
3810	&& DECL_HAS_VALUE_EXPR_P (NODE) \
3811	&& (id_equal (DECL_NAME (NODE), "__PRETTY_FUNCTION__") \
3812	\|\| id_equal (DECL_NAME (NODE), "__FUNCTION__") \
3813	\|\| id_equal (DECL_NAME (NODE), "__func__")))
3814
3815	/ Nonzero if the variable was declared to be thread-local.*
3816	We need a special C++ version of this test because the middle-end
3817	DECL_THREAD_LOCAL_P uses the symtab, so we can't use it for
3818	templates. /*
3819	#define CP_DECL_THREAD_LOCAL_P(NODE) \
3820	(TREE_LANG_FLAG_0 (VAR_DECL_CHECK (NODE)))
3821
3822	/ The _TYPE context in which this _DECL appears. This field holds the*
3823	class where a virtual function instance is actually defined. /*
3824	#define DECL_CLASS_CONTEXT(NODE) \
3825	(DECL_CLASS_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : NULL_TREE)
3826
3827	/ For a non-member friend function, the class (if any) in which this*
3828	friend was defined. For example, given:
3829
3830	struct S { friend void f () { ... } };
3831
3832	the DECL_FRIEND_CONTEXT for `f' will be `S'. /*
3833	#define DECL_FRIEND_CONTEXT(NODE) \
3834	((DECL_DECLARES_FUNCTION_P (NODE) && !DECL_VIRTUAL_P (NODE) \
3835	&& !DECL_CONSTRUCTOR_P (NODE) \
3836	&& (cxx_dialect < cxx23 \|\| !deduction_guide_p (NODE))) \
3837	? LANG_DECL_FN_CHECK (NODE)->context \
3838	: NULL_TREE)
3839
3840	/ Set the DECL_FRIEND_CONTEXT for NODE to CONTEXT. /
3841	#define SET_DECL_FRIEND_CONTEXT(NODE, CONTEXT) \
3842	(LANG_DECL_FN_CHECK (NODE)->context = (CONTEXT))
3843
3844	#define CP_DECL_CONTEXT(NODE) \
3845	(!DECL_FILE_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : global_namespace)
3846	#define CP_TYPE_CONTEXT(NODE) \
3847	(!TYPE_FILE_SCOPE_P (NODE) ? TYPE_CONTEXT (NODE) : global_namespace)
3848	#define FROB_CONTEXT(NODE) \
3849	((NODE) == global_namespace ? DECL_CONTEXT (NODE) : (NODE))
3850
3851	/ 1 iff NODE has namespace scope, including the global namespace. /
3852	#define DECL_NAMESPACE_SCOPE_P(NODE) \
3853	(!DECL_TEMPLATE_PARM_P (NODE) \
3854	&& TREE_CODE (CP_DECL_CONTEXT (NODE)) == NAMESPACE_DECL)
3855
3856	#define TYPE_NAMESPACE_SCOPE_P(NODE) \
3857	(TREE_CODE (CP_TYPE_CONTEXT (NODE)) == NAMESPACE_DECL)
3858
3859	#define NAMESPACE_SCOPE_P(NODE) \
3860	((DECL_P (NODE) && DECL_NAMESPACE_SCOPE_P (NODE)) \
3861	\|\| (TYPE_P (NODE) && TYPE_NAMESPACE_SCOPE_P (NODE)))
3862
3863	/ 1 iff NODE is a class member. /
3864	#define DECL_CLASS_SCOPE_P(NODE) \
3865	(DECL_CONTEXT (NODE) && TYPE_P (DECL_CONTEXT (NODE)))
3866
3867	#define TYPE_CLASS_SCOPE_P(NODE) \
3868	(TYPE_CONTEXT (NODE) && TYPE_P (TYPE_CONTEXT (NODE)))
3869
3870	/ 1 iff NODE is function-local. /
3871	#define DECL_FUNCTION_SCOPE_P(NODE) \
3872	(DECL_CONTEXT (NODE) \
3873	&& TREE_CODE (DECL_CONTEXT (NODE)) == FUNCTION_DECL)
3874
3875	#define TYPE_FUNCTION_SCOPE_P(NODE) \
3876	(TYPE_CONTEXT (NODE) && TREE_CODE (TYPE_CONTEXT (NODE)) == FUNCTION_DECL)
3877
3878	/ 1 iff VAR_DECL node NODE is a type-info decl. This flag is set for*
3879	both the primary typeinfo object and the associated NTBS name. /*
3880	#define DECL_TINFO_P(NODE) \
3881	TREE_LANG_FLAG_4 (TREE_CHECK2 (NODE,VAR_DECL,TYPE_DECL))
3882
3883	/ true iff VAR_DECL node NODE is a NTTP object decl. /
3884	#define DECL_NTTP_OBJECT_P(NODE) \
3885	TREE_LANG_FLAG_5 (TREE_CHECK (NODE,VAR_DECL))
3886
3887	/ 1 iff VAR_DECL node NODE is virtual table or VTT. We forward to*
3888	DECL_VIRTUAL_P from the common code, as that has the semantics we
3889	need. But we want a more descriptive name. /*
3890	#define DECL_VTABLE_OR_VTT_P(NODE) DECL_VIRTUAL_P (VAR_DECL_CHECK (NODE))
3891
3892	/ 1 iff a _DECL for a template parameter came from*
3893	synthesize_implicit_template_parm. /*
3894	#define DECL_IMPLICIT_TEMPLATE_PARM_P(NODE) \
3895	DECL_VIRTUAL_P (DECL_TEMPLATE_PARM_CHECK (NODE))
3896
3897	/ 1 iff FUNCTION_TYPE or METHOD_TYPE has a ref-qualifier (either & or &&). /
3898	#define FUNCTION_REF_QUALIFIED(NODE) \
3899	TREE_LANG_FLAG_4 (FUNC_OR_METHOD_CHECK (NODE))
3900
3901	/ 1 iff FUNCTION_TYPE or METHOD_TYPE has &&-ref-qualifier. /
3902	#define FUNCTION_RVALUE_QUALIFIED(NODE) \
3903	TREE_LANG_FLAG_5 (FUNC_OR_METHOD_CHECK (NODE))
3904
3905	/ 1 iff NODE is function-local, but for types. /
3906	#define LOCAL_CLASS_P(NODE) \
3907	(decl_function_context (TYPE_MAIN_DECL (NODE)) != NULL_TREE)
3908
3909	/ The nesting depth of namespace, class or function. Makes is_ancestor much*
3910	simpler. Only 8 bits available. /*
3911	#define SCOPE_DEPTH(NODE) \
3912	(NAMESPACE_DECL_CHECK (NODE)->base.u.bits.address_space)
3913
3914	/ Whether the namepace is an inline namespace. /
3915	#define DECL_NAMESPACE_INLINE_P(NODE) \
3916	TREE_LANG_FLAG_0 (NAMESPACE_DECL_CHECK (NODE))
3917
3918	/ In a NAMESPACE_DECL, a vector of inline namespaces. /
3919	#define DECL_NAMESPACE_INLINEES(NODE) \
3920	(LANG_DECL_NS_CHECK (NODE)->inlinees)
3921
3922	/ Pointer to hash_map from IDENTIFIERS to DECLS /
3923	#define DECL_NAMESPACE_BINDINGS(NODE) \
3924	(LANG_DECL_NS_CHECK (NODE)->bindings)
3925
3926	/ In a NAMESPACE_DECL, points to the original namespace if this is*
3927	a namespace alias. /*
3928	#define DECL_NAMESPACE_ALIAS(NODE) \
3929	DECL_ABSTRACT_ORIGIN (NAMESPACE_DECL_CHECK (NODE))
3930	#define ORIGINAL_NAMESPACE(NODE) \
3931	(DECL_NAMESPACE_ALIAS (NODE) ? DECL_NAMESPACE_ALIAS (NODE) : (NODE))
3932
3933	/ Nonzero if NODE is the std namespace. /
3934	#define DECL_NAMESPACE_STD_P(NODE) \
3935	((NODE) == std_node)
3936
3937	/ In a TREE_LIST in an attribute list, indicates that the attribute*
3938	must be applied at instantiation time. /*
3939	#define ATTR_IS_DEPENDENT(NODE) TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
3940
3941	/ In a TREE_LIST in the argument of attribute abi_tag, indicates that the tag*
3942	was inherited from a template parameter, not explicitly indicated. /*
3943	#define ABI_TAG_IMPLICIT(NODE) TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
3944
3945	/ In a TREE_LIST for a parameter-declaration-list, indicates that all the*
3946	parameters in the list have declarators enclosed in (). /*
3947	#define PARENTHESIZED_LIST_P(NODE) TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
3948
3949	/ Non zero if this is a using decl for a dependent scope. /
3950	#define DECL_DEPENDENT_P(NODE) DECL_LANG_FLAG_0 (USING_DECL_CHECK (NODE))
3951
3952	/ The scope named in a using decl. /
3953	#define USING_DECL_SCOPE(NODE) DECL_RESULT_FLD (USING_DECL_CHECK (NODE))
3954
3955	/ The decls named by a using decl. /
3956	#define USING_DECL_DECLS(NODE) DECL_INITIAL (USING_DECL_CHECK (NODE))
3957
3958	/ Non zero if the using decl refers to a dependent type. /
3959	#define USING_DECL_TYPENAME_P(NODE) DECL_LANG_FLAG_1 (USING_DECL_CHECK (NODE))
3960
3961	/ True if member using decl NODE refers to a non-inherited NODE. /
3962	#define USING_DECL_UNRELATED_P(NODE) DECL_LANG_FLAG_2 (USING_DECL_CHECK (NODE))
3963
3964	/ True iff the CONST_DECL is a class-scope clone from C++20 using enum,*
3965	created by handle_using_decl. /*
3966	#define CONST_DECL_USING_P(NODE) \
3967	(TREE_CODE (NODE) == CONST_DECL \
3968	&& TREE_TYPE (NODE) \
3969	&& TREE_CODE (TREE_TYPE (NODE)) == ENUMERAL_TYPE \
3970	&& DECL_CONTEXT (NODE) != TREE_TYPE (NODE))
3971
3972	/ In a FUNCTION_DECL, this is nonzero if this function was defined in*
3973	the class definition. We have saved away the text of the function,
3974	but have not yet processed it. /*
3975	#define DECL_PENDING_INLINE_P(NODE) \
3976	(LANG_DECL_FN_CHECK (NODE)->pending_inline_p)
3977
3978	/ If DECL_PENDING_INLINE_P holds, this is the saved text of the*
3979	function. /*
3980	#define DECL_PENDING_INLINE_INFO(NODE) \
3981	(LANG_DECL_FN_CHECK (NODE)->u.pending_inline_info)
3982
3983	/ True if NODE is a non-gnu_inline inline function; gnu_inline overrides the*
3984	usual vague linkage effects of inline. /*
3985	#define DECL_NONGNU_INLINE_P(NODE) \
3986	(DECL_DECLARED_INLINE_P (NODE) \
3987	&& !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (NODE)))
3988
3989	/ Nonzero for TYPE_DECL means that it was written 'using name = type'. /
3990	#define TYPE_DECL_ALIAS_P(NODE) \
3991	DECL_LANG_FLAG_6 (TYPE_DECL_CHECK (NODE))
3992
3993	/ Nonzero for a type which is an alias for another type; i.e, a type*
3994	which declaration was written 'using name-of-type =
3995	another-type'. /*
3996	#define TYPE_ALIAS_P(NODE) \
3997	(TYPE_P (NODE) \
3998	&& TYPE_NAME (NODE) \
3999	&& TREE_CODE (TYPE_NAME (NODE)) == TYPE_DECL \
4000	&& TYPE_DECL_ALIAS_P (TYPE_NAME (NODE)))
4001
4002	/ If non-NULL for a VAR_DECL, FUNCTION_DECL, TYPE_DECL, TEMPLATE_DECL,*
4003	or CONCEPT_DECL, the entity is either a template specialization (if
4004	DECL_USE_TEMPLATE is nonzero) or the abstract instance of the
4005	template itself.
4006
4007	In either case, DECL_TEMPLATE_INFO is a TEMPLATE_INFO, whose
4008	TI_TEMPLATE is the TEMPLATE_DECL of which this entity is a
4009	specialization or abstract instance. The TI_ARGS is the
4010	template arguments used to specialize the template.
4011
4012	Consider:
4013
4014	template <typename T> struct S { friend void f(T) {} };
4015
4016	In this case, S<int>::f is, from the point of view of the compiler,
4017	an instantiation of a template -- but, from the point of view of
4018	the language, each instantiation of S results in a wholly unrelated
4019	global function f. In this case, DECL_TEMPLATE_INFO for S<int>::f
4020	will be non-NULL, but DECL_USE_TEMPLATE will be zero.
4021
4022	In a friend declaration, TI_TEMPLATE can be an overload set, or
4023	identifier. /*
4024	#define DECL_TEMPLATE_INFO(NODE) \
4025	(DECL_LANG_SPECIFIC (TEMPLATE_INFO_DECL_CHECK (NODE)) \
4026	->u.min.template_info)
4027
4028	/ For a lambda capture proxy, its captured variable. /
4029	#define DECL_CAPTURED_VARIABLE(NODE) \
4030	(LANG_DECL_MIN_CHECK (NODE)->access)
4031
4032	/ For a VAR_DECL, indicates that the variable is actually a*
4033	non-static data member of anonymous union that has been promoted to
4034	variable status. /*
4035	#define DECL_ANON_UNION_VAR_P(NODE) \
4036	(DECL_LANG_FLAG_4 (VAR_DECL_CHECK (NODE)))
4037
4038	/ Template information for a RECORD_TYPE or UNION_TYPE. /
4039	#define CLASSTYPE_TEMPLATE_INFO(NODE) \
4040	(TYPE_LANG_SLOT_1 (RECORD_OR_UNION_CHECK (NODE)))
4041
4042	/ Template information for a template template parameter. /
4043	#define TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO(NODE) \
4044	(TYPE_LANG_SLOT_1 (BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK (NODE)))
4045
4046	/ Template information for an ENUMERAL_, RECORD_, UNION_TYPE, or*
4047	BOUND_TEMPLATE_TEMPLATE_PARM type. This ignores any alias
4048	templateness of NODE. It'd be nice if this could unconditionally
4049	access the slot, rather than return NULL if given a
4050	non-templatable type. /*
4051	#define TYPE_TEMPLATE_INFO(NODE) \
4052	(TREE_CODE (NODE) == ENUMERAL_TYPE \
4053	\|\| TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM \
4054	\|\| RECORD_OR_UNION_TYPE_P (NODE) \
4055	? TYPE_LANG_SLOT_1 (NODE) : NULL_TREE)
4056
4057	/ Template information (if any) for an alias type. /
4058	#define TYPE_ALIAS_TEMPLATE_INFO(NODE) \
4059	(DECL_LANG_SPECIFIC (TYPE_NAME (NODE)) \
4060	? DECL_TEMPLATE_INFO (TYPE_NAME (NODE)) \
4061	: NULL_TREE)
4062
4063	/ If NODE is a type alias, this accessor returns the template info*
4064	for the alias template (if any). Otherwise behave as
4065	TYPE_TEMPLATE_INFO. /*
4066	#define TYPE_TEMPLATE_INFO_MAYBE_ALIAS(NODE) \
4067	(typedef_variant_p (NODE) \
4068	? TYPE_ALIAS_TEMPLATE_INFO (NODE) \
4069	: TYPE_TEMPLATE_INFO (NODE))
4070
4071	/ Set the template information for a non-alias n ENUMERAL_, RECORD_,*
4072	or UNION_TYPE to VAL. ALIAS's are dealt with separately. /*
4073	#define SET_TYPE_TEMPLATE_INFO(NODE, VAL) \
4074	(TREE_CODE (NODE) == ENUMERAL_TYPE \
4075	\|\| (CLASS_TYPE_P (NODE) && !TYPE_ALIAS_P (NODE)) \
4076	? (TYPE_LANG_SLOT_1 (NODE) = (VAL)) \
4077	: (DECL_TEMPLATE_INFO (TYPE_NAME (NODE)) = (VAL))) \
4078
4079	#define TI_TEMPLATE(NODE) \
4080	((struct tree_template_info*)TEMPLATE_INFO_CHECK (NODE))->tmpl
4081	#define TI_ARGS(NODE) \
4082	((struct tree_template_info*)TEMPLATE_INFO_CHECK (NODE))->args
4083	#define TI_PENDING_TEMPLATE_FLAG(NODE) \
4084	TREE_LANG_FLAG_1 (TEMPLATE_INFO_CHECK (NODE))
4085
4086	/ For a class or variable template specialization, this contains the*
4087	TEMPLATE_INFO result of most_specialized_partial_spec, i.e. the selected
4088	partial template specialization and arguments relative to it. /*
4089	#define TI_PARTIAL_INFO(NODE) \
4090	(gcc_checking_assert (PRIMARY_TEMPLATE_P (TI_TEMPLATE (NODE))), \
4091	((struct tree_template_info*)NODE)->partial)
4092
4093	/ For a given TREE_VEC containing a template argument list,*
4094	this property contains the number of arguments that are not
4095	defaulted. /*
4096	#define NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \
4097	TREE_CHAIN (TREE_VEC_CHECK (NODE))
4098
4099	/ Below are the setter and getter of the NON_DEFAULT_TEMPLATE_ARGS_COUNT*
4100	property. /*
4101	#define SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE, INT_VALUE) \
4102	NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) = build_int_cst (NULL_TREE, INT_VALUE)
4103	#if CHECKING_P
4104	#define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \
4105	int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE))
4106	#else
4107	#define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \
4108	NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE) \
4109	? int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE)) \
4110	: TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (NODE))
4111	#endif
4112
4113	/ True iff NODE represents the template args for a type-constraint,*
4114	in which case the first one represents the constrained type.
4115	Currently only set during mangling. /*
4116	#define TEMPLATE_ARGS_TYPE_CONSTRAINT_P(NODE) \
4117	TREE_PRIVATE (TREE_VEC_CHECK (NODE))
4118
4119	/ The list of access checks that were deferred during parsing*
4120	which need to be performed at template instantiation time.
4121
4122	FIXME this should be associated with the TEMPLATE_DECL, not the
4123	TEMPLATE_INFO. /*
4124	#define TI_DEFERRED_ACCESS_CHECKS(NODE) \
4125	((struct tree_template_info*)TEMPLATE_INFO_CHECK \
4126	(NODE))->deferred_access_checks
4127
4128	/ We use TREE_VECs to hold template arguments. If there is only one*
4129	level of template arguments, then the TREE_VEC contains the
4130	arguments directly. If there is more than one level of template
4131	arguments, then each entry in the TREE_VEC is itself a TREE_VEC,
4132	containing the template arguments for a single level. The first
4133	entry in the outer TREE_VEC is the outermost level of template
4134	parameters; the last is the innermost.
4135
4136	It is incorrect to ever form a template argument vector containing
4137	only one level of arguments, but which is a TREE_VEC containing as
4138	its only entry the TREE_VEC for that level.
4139
4140	For each TREE_VEC containing the template arguments for a single
4141	level, it's possible to get or set the number of non defaulted
4142	template arguments by using the accessor macros
4143	GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT or
4144	SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT. /*
4145
4146	/ Nonzero if the template arguments is actually a vector of vectors,*
4147	rather than just a vector. /*
4148	#define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \
4149	(NODE && TREE_VEC_LENGTH (NODE) && TREE_VEC_ELT (NODE, 0) \
4150	&& TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC)
4151
4152	/ The depth of a template argument vector. When called directly by*
4153	the parser, we use a TREE_LIST rather than a TREE_VEC to represent
4154	template arguments. In that case, there is only one level of template
4155	arguments. We may even see NULL_TREE if there are 0 levels of
4156	template arguments, as in cp_parser_requires_expression. /*
4157	#define TMPL_ARGS_DEPTH(NODE) \
4158	((NODE) == NULL_TREE ? 0 \
4159	: TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) \
4160	: 1)
4161
4162	/ The LEVELth level of the template ARGS. The outermost level of*
4163	args is level 1, not level 0. /*
4164	#define TMPL_ARGS_LEVEL(ARGS, LEVEL) \
4165	(TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS) \
4166	? TREE_VEC_ELT (ARGS, (LEVEL) - 1) \
4167	: (gcc_checking_assert ((LEVEL) == 1), (ARGS)))
4168
4169	/ Set the LEVELth level of the template ARGS to VAL. This macro does*
4170	not work with single-level argument vectors. /*
4171	#define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL) \
4172	(TREE_VEC_ELT (ARGS, (LEVEL) - 1) = (VAL))
4173
4174	/ Accesses the IDXth parameter in the LEVELth level of the ARGS. /
4175	#define TMPL_ARG(ARGS, LEVEL, IDX) \
4176	(TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX))
4177
4178	/ Given a single level of template arguments in NODE, return the*
4179	number of arguments. /*
4180	#define NUM_TMPL_ARGS(NODE) \
4181	(TREE_VEC_LENGTH (NODE))
4182
4183	/ Returns the innermost level of template arguments in ARGS. /
4184	#define INNERMOST_TEMPLATE_ARGS(NODE) \
4185	(get_innermost_template_args ((NODE), 1))
4186
4187	/ The number of levels of template parameters given by NODE. /
4188	#define TMPL_PARMS_DEPTH(NODE) \
4189	((HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_PURPOSE (NODE)))
4190
4191	/ The TEMPLATE_DECL instantiated or specialized by NODE. This*
4192	TEMPLATE_DECL will be the immediate parent, not the most general
4193	template. For example, in:
4194
4195	template <class T> struct S { template <class U> void f(U); }
4196
4197	the FUNCTION_DECL for S<int>::f<double> will have, as its
4198	DECL_TI_TEMPLATE, `template <class U> S<int>::f<U>'.
4199
4200	As a special case, for a member friend template of a template
4201	class, this value will not be a TEMPLATE_DECL, but rather an
4202	IDENTIFIER_NODE or OVERLOAD indicating the name of the template and
4203	any explicit template arguments provided. For example, in:
4204
4205	template <class T> struct S { friend void f<int>(int, double); }
4206
4207	the DECL_TI_TEMPLATE will be an IDENTIFIER_NODE for `f' and the
4208	DECL_TI_ARGS will be {int}.
4209
4210	For a FIELD_DECL with a non-static data member initializer, this value
4211	is the FIELD_DECL it was instantiated from. /*
4212	#define DECL_TI_TEMPLATE(NODE) TI_TEMPLATE (DECL_TEMPLATE_INFO (NODE))
4213
4214	/ The template arguments used to obtain this decl from the most*
4215	general form of DECL_TI_TEMPLATE. For the example given for
4216	DECL_TI_TEMPLATE, the DECL_TI_ARGS will be {int, double}. These
4217	are always the full set of arguments required to instantiate this
4218	declaration from the most general template specialized here. /*
4219	#define DECL_TI_ARGS(NODE) TI_ARGS (DECL_TEMPLATE_INFO (NODE))
4220
4221	/ The TEMPLATE_DECL associated with NODE, a class type. Even if NODE*
4222	will be generated from a partial specialization, the TEMPLATE_DECL
4223	referred to here will be the original template. For example,
4224	given:
4225
4226	template <typename T> struct S {};
4227	template <typename T> struct S<T> {};*
4228
4229	the CLASSTYPE_TI_TEMPLATE for S<int> will be S, not the S<T>.
4230
4231	For a member class template, CLASSTYPE_TI_TEMPLATE always refers to the
4232	partial instantiation rather than the primary template. CLASSTYPE_TI_ARGS
4233	are for the primary template if the partial instantiation isn't
4234	specialized, or for the explicit specialization if it is, e.g.
4235
4236	template <class T> class C { template <class U> class D; }
4237	template <> template <class U> class C<int>::D; /*
4238	#define CLASSTYPE_TI_TEMPLATE(NODE) TI_TEMPLATE (CLASSTYPE_TEMPLATE_INFO (NODE))
4239	#define CLASSTYPE_TI_ARGS(NODE) TI_ARGS (CLASSTYPE_TEMPLATE_INFO (NODE))
4240
4241	/ For a template instantiation TYPE, returns the TYPE corresponding*
4242	to the primary template. Otherwise returns TYPE itself. /*
4243	#define CLASSTYPE_PRIMARY_TEMPLATE_TYPE(TYPE) \
4244	((CLASSTYPE_USE_TEMPLATE ((TYPE)) \
4245	&& !CLASSTYPE_TEMPLATE_SPECIALIZATION ((TYPE))) \
4246	? TREE_TYPE (DECL_TEMPLATE_RESULT (DECL_PRIMARY_TEMPLATE \
4247	(CLASSTYPE_TI_TEMPLATE ((TYPE))))) \
4248	: (TYPE))
4249
4250	/ Like CLASS_TI_TEMPLATE, but also works for ENUMERAL_TYPEs. /
4251	#define TYPE_TI_TEMPLATE(NODE) \
4252	(TI_TEMPLATE (TYPE_TEMPLATE_INFO (NODE)))
4253
4254	/ Like DECL_TI_ARGS, but for an ENUMERAL_, RECORD_, or UNION_TYPE. /
4255	#define TYPE_TI_ARGS(NODE) \
4256	(TI_ARGS (TYPE_TEMPLATE_INFO (NODE)))
4257
4258	#define INNERMOST_TEMPLATE_PARMS(NODE) TREE_VALUE (NODE)
4259
4260	/ Nonzero if NODE (a TEMPLATE_DECL) is a member template, in the*
4261	sense of [temp.mem]. /*
4262	#define DECL_MEMBER_TEMPLATE_P(NODE) \
4263	(DECL_LANG_FLAG_1 (TEMPLATE_DECL_CHECK (NODE)))
4264
4265	/ Nonzero if the NODE corresponds to the template parameters for a*
4266	member template, whose inline definition is being processed after
4267	the class definition is complete. /*
4268	#define TEMPLATE_PARMS_FOR_INLINE(NODE) TREE_LANG_FLAG_1 (NODE)
4269
4270	/ Determine if a declaration (PARM_DECL or FIELD_DECL) is a pack. /
4271	#define DECL_PACK_P(NODE) \
4272	(DECL_P (NODE) && PACK_EXPANSION_P (TREE_TYPE (NODE)))
4273
4274	/ Determines if NODE is an expansion of one or more parameter packs,*
4275	e.g., a TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION. /*
4276	#define PACK_EXPANSION_P(NODE) \
4277	(TREE_CODE (NODE) == TYPE_PACK_EXPANSION \
4278	\|\| TREE_CODE (NODE) == EXPR_PACK_EXPANSION)
4279
4280	#define PACK_EXPANSION_CHECK(NODE) \
4281	TREE_CHECK2 (NODE, TYPE_PACK_EXPANSION, EXPR_PACK_EXPANSION)
4282
4283	#define PACK_INDEX_CHECK(NODE) \
4284	TREE_CHECK2 (NODE, PACK_INDEX_TYPE, PACK_INDEX_EXPR)
4285
4286	/ Extracts the type or expression pattern from a TYPE_PACK_EXPANSION or*
4287	EXPR_PACK_EXPANSION. /*
4288	#define PACK_EXPANSION_PATTERN(NODE) \
4289	(TREE_CODE (PACK_EXPANSION_CHECK (NODE)) == TYPE_PACK_EXPANSION \
4290	? TREE_TYPE (NODE) : TREE_OPERAND (NODE, 0))
4291
4292	/ The list of parameter packs used in the PACK_EXPANSION_* node. The*
4293	TREE_VALUE of each TREE_LIST contains the parameter packs. /*
4294	#define PACK_EXPANSION_PARAMETER_PACKS(NODE) \
4295	*(TREE_CODE (PACK_EXPANSION_CHECK (NODE)) == EXPR_PACK_EXPANSION \
4296	? &TREE_OPERAND (NODE, 1) \
4297	: &TYPE_MIN_VALUE_RAW (TYPE_PACK_EXPANSION_CHECK (NODE)))
4298
4299	/ Any additional template args to be applied when substituting into*
4300	the pattern, set by tsubst_pack_expansion for partial instantiations.
4301	If this is a TREE_LIST, the TREE_VALUE of the first element is the
4302	usual template argument TREE_VEC, and the TREE_PURPOSE of later elements
4303	are enclosing functions that provided function parameter packs we'll need
4304	to map appropriately. /*
4305	#define PACK_EXPANSION_EXTRA_ARGS(NODE) \
4306	*(TREE_CODE (PACK_EXPANSION_CHECK (NODE)) == TYPE_PACK_EXPANSION \
4307	? &TYPE_MAX_VALUE_RAW (NODE) \
4308	: &TREE_OPERAND ((NODE), 2))
4309
4310	/ True if NODE is a pack index. /
4311	#define PACK_INDEX_P(NODE) \
4312	(TREE_CODE (NODE) == PACK_INDEX_TYPE \
4313	\|\| TREE_CODE (NODE) == PACK_INDEX_EXPR)
4314
4315	/ For a pack index T...[N], the pack expansion 'T...'. /
4316	#define PACK_INDEX_PACK(NODE) \
4317	(TREE_CODE (PACK_INDEX_CHECK (NODE)) == PACK_INDEX_TYPE \
4318	? TREE_TYPE (NODE) : TREE_OPERAND (NODE, 0))
4319
4320	/ For a pack index T...[N], the index N. /
4321	#define PACK_INDEX_INDEX(NODE) \
4322	*(TREE_CODE (PACK_INDEX_CHECK (NODE)) == PACK_INDEX_TYPE \
4323	? &TYPE_MAX_VALUE_RAW (NODE) \
4324	: &TREE_OPERAND ((NODE), 1))
4325
4326	/ True iff this pack expansion is within a function context. /
4327	#define PACK_EXPANSION_LOCAL_P(NODE) \
4328	TREE_LANG_FLAG_0 (PACK_EXPANSION_CHECK (NODE))
4329
4330	/ True iff this pack expansion is for sizeof.... /
4331	#define PACK_EXPANSION_SIZEOF_P(NODE) \
4332	TREE_LANG_FLAG_1 (PACK_EXPANSION_CHECK (NODE))
4333
4334	/ True iff this pack expansion is for auto... in lambda init-capture. /
4335	#define PACK_EXPANSION_AUTO_P(NODE) \
4336	TREE_LANG_FLAG_2 (PACK_EXPANSION_CHECK (NODE))
4337
4338	/ True if we must use PACK_EXPANSION_EXTRA_ARGS and avoid partial*
4339	instantiation of this pack expansion. /*
4340	#define PACK_EXPANSION_FORCE_EXTRA_ARGS_P(NODE) \
4341	TREE_LANG_FLAG_3 (PACK_EXPANSION_CHECK (NODE))
4342
4343	/ Indicates whether a pack expansion has been parenthesized. Used for*
4344	a pack expansion in a decltype. /*
4345	#define PACK_INDEX_PARENTHESIZED_P(NODE) \
4346	TREE_LANG_FLAG_1 (TREE_CHECK (NODE, PACK_INDEX_EXPR))
4347
4348	/ Determine if this is an argument pack. /
4349	#define ARGUMENT_PACK_P(NODE) \
4350	(TREE_CODE (NODE) == TYPE_ARGUMENT_PACK \
4351	\|\| TREE_CODE (NODE) == NONTYPE_ARGUMENT_PACK)
4352
4353	#define ARGUMENT_PACK_CHECK(NODE) \
4354	TREE_CHECK2 (NODE, TYPE_ARGUMENT_PACK, NONTYPE_ARGUMENT_PACK)
4355
4356	/ The arguments stored in an argument pack. Arguments are stored in a*
4357	TREE_VEC, which may have length zero. /*
4358	#define ARGUMENT_PACK_ARGS(NODE) \
4359	(TREE_CODE (ARGUMENT_PACK_CHECK (NODE)) == TYPE_ARGUMENT_PACK \
4360	? TREE_TYPE (NODE) : TREE_OPERAND (NODE, 0))
4361
4362	/ Whether the argument pack is "incomplete", meaning that more*
4363	arguments can still be deduced. Incomplete argument packs are only
4364	used when the user has provided an explicit template argument list
4365	for a variadic function template. Some of the explicit template
4366	arguments will be placed into the beginning of the argument pack,
4367	but additional arguments might still be deduced. /*
4368	#define ARGUMENT_PACK_INCOMPLETE_P(NODE) \
4369	TREE_ADDRESSABLE (ARGUMENT_PACK_ARGS (NODE))
4370
4371	/ When ARGUMENT_PACK_INCOMPLETE_P, stores the explicit template*
4372	arguments used to fill this pack. /*
4373	#define ARGUMENT_PACK_EXPLICIT_ARGS(NODE) \
4374	TREE_TYPE (ARGUMENT_PACK_ARGS (NODE))
4375
4376	/ In an ARGUMENT_PACK_SELECT, the argument pack from which an*
4377	argument will be selected. /*
4378	#define ARGUMENT_PACK_SELECT_FROM_PACK(NODE) \
4379	(((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->argument_pack)
4380
4381	/ In an ARGUMENT_PACK_SELECT, the index of the argument we want to*
4382	select. /*
4383	#define ARGUMENT_PACK_SELECT_INDEX(NODE) \
4384	(((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->index)
4385
4386	#define FOLD_EXPR_CHECK(NODE) \
4387	TREE_CHECK4 (NODE, UNARY_LEFT_FOLD_EXPR, UNARY_RIGHT_FOLD_EXPR, \
4388	BINARY_LEFT_FOLD_EXPR, BINARY_RIGHT_FOLD_EXPR)
4389
4390	#define BINARY_FOLD_EXPR_CHECK(NODE) \
4391	TREE_CHECK2 (NODE, BINARY_LEFT_FOLD_EXPR, BINARY_RIGHT_FOLD_EXPR)
4392
4393	/ True if NODE is UNARY_FOLD_EXPR or a BINARY_FOLD_EXPR /
4394	#define FOLD_EXPR_P(NODE) \
4395	(TREE_CODE (NODE) == UNARY_LEFT_FOLD_EXPR \
4396	\|\| TREE_CODE (NODE) == UNARY_RIGHT_FOLD_EXPR \
4397	\|\| TREE_CODE (NODE) == BINARY_LEFT_FOLD_EXPR \
4398	\|\| TREE_CODE (NODE) == BINARY_RIGHT_FOLD_EXPR)
4399
4400	/ True when NODE is a fold over a compound assignment operator. /
4401	#define FOLD_EXPR_MODIFY_P(NODE) \
4402	TREE_LANG_FLAG_0 (FOLD_EXPR_CHECK (NODE))
4403
4404	/ An INTEGER_CST containing the tree code of the folded operator. /
4405	#define FOLD_EXPR_OP_RAW(NODE) \
4406	TREE_OPERAND (FOLD_EXPR_CHECK (NODE), 0)
4407
4408	/ The tree code of the folded operator. /
4409	#define FOLD_EXPR_OP(NODE) \
4410	((enum tree_code) TREE_INT_CST_LOW (FOLD_EXPR_OP_RAW (NODE)))
4411
4412	/ The expression containing an unexpanded parameter pack. /
4413	#define FOLD_EXPR_PACK(NODE) \
4414	TREE_OPERAND (FOLD_EXPR_CHECK (NODE), 1)
4415
4416	/ In a binary fold expression, the argument with no unexpanded*
4417	parameter packs. /*
4418	#define FOLD_EXPR_INIT(NODE) \
4419	TREE_OPERAND (BINARY_FOLD_EXPR_CHECK (NODE), 2)
4420
4421	/ In a FUNCTION_DECL, the saved auto-return pattern. /
4422	#define DECL_SAVED_AUTO_RETURN_TYPE(NODE) \
4423	(LANG_DECL_FN_CHECK (FUNCTION_DECL_CHECK (NODE)) \
4424	->u.saved_auto_return_type)
4425
4426	/ In a RETURN_EXPR, whether the expression refers to the address*
4427	of a local variable. /*
4428	#define RETURN_EXPR_LOCAL_ADDR_P(NODE) \
4429	TREE_LANG_FLAG_0 (RETURN_EXPR_CHECK (NODE))
4430
4431	/ True if NODE is an implicit INDIRECT_REF from convert_from_reference. /
4432	#define REFERENCE_REF_P(NODE) \
4433	(INDIRECT_REF_P (NODE) \
4434	&& TREE_TYPE (TREE_OPERAND (NODE, 0)) \
4435	&& TYPE_REF_P (TREE_TYPE (TREE_OPERAND ((NODE), 0))))
4436
4437	/ Look through an implicit INDIRECT_REF from convert_from_reference. /
4438	#define STRIP_REFERENCE_REF(NODE) \
4439	(REFERENCE_REF_P (NODE) ? TREE_OPERAND (NODE, 0) : NODE)
4440
4441	/ True iff this represents an lvalue being treated as an rvalue during return*
4442	or throw as per [class.copy.elision]. /*
4443	#define IMPLICIT_RVALUE_P(NODE) \
4444	TREE_LANG_FLAG_3 (TREE_CHECK2 ((NODE), NON_LVALUE_EXPR, STATIC_CAST_EXPR))
4445
4446	#define NEW_EXPR_USE_GLOBAL(NODE) \
4447	TREE_LANG_FLAG_0 (NEW_EXPR_CHECK (NODE))
4448	#define DELETE_EXPR_USE_GLOBAL(NODE) \
4449	TREE_LANG_FLAG_0 (DELETE_EXPR_CHECK (NODE))
4450	#define DELETE_EXPR_USE_VEC(NODE) \
4451	TREE_LANG_FLAG_1 (DELETE_EXPR_CHECK (NODE))
4452
4453	/ True iff this represents returning a potential named return value. /
4454	#define INIT_EXPR_NRV_P(NODE) \
4455	TREE_LANG_FLAG_0 (INIT_EXPR_CHECK (NODE))
4456
4457	#define CALL_OR_AGGR_INIT_CHECK(NODE) \
4458	TREE_CHECK2 ((NODE), CALL_EXPR, AGGR_INIT_EXPR)
4459
4460	/ In a CALL_EXPR appearing in a template, true if Koenig lookup*
4461	should be performed at instantiation time. /*
4462	#define KOENIG_LOOKUP_P(NODE) TREE_LANG_FLAG_0 (CALL_EXPR_CHECK (NODE))
4463
4464	/ True if the arguments to NODE should be evaluated in left-to-right*
4465	order regardless of PUSH_ARGS_REVERSED. /*
4466	#define CALL_EXPR_ORDERED_ARGS(NODE) \
4467	TREE_LANG_FLAG_3 (CALL_OR_AGGR_INIT_CHECK (NODE))
4468
4469	/ True if the arguments to NODE should be evaluated in right-to-left*
4470	order regardless of PUSH_ARGS_REVERSED. /*
4471	#define CALL_EXPR_REVERSE_ARGS(NODE) \
4472	TREE_LANG_FLAG_5 (CALL_OR_AGGR_INIT_CHECK (NODE))
4473
4474	/ True if CALL_EXPR was written as an operator expression, not a function*
4475	call. /*
4476	#define CALL_EXPR_OPERATOR_SYNTAX(NODE) \
4477	TREE_LANG_FLAG_6 (CALL_OR_AGGR_INIT_CHECK (NODE))
4478
4479	/ A TREE_LIST containing the result of phase 1 name lookup of the operator*
4480	overloads that are pertinent to the dependent operator expression whose
4481	type is NODE. Each TREE_PURPOSE is an IDENTIFIER_NODE and TREE_VALUE is
4482	the corresponding (possibly empty) lookup result. The TREE_TYPE of the
4483	first TREE_LIST node points back to NODE. /*
4484	#define DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS(NODE) \
4485	TYPE_VALUES_RAW (DEPENDENT_OPERATOR_TYPE_CHECK (NODE))
4486
4487	/ Guarded helper for the above accessor macro that takes a (templated)*
4488	operator expression instead of the type thereof. /*
4489	inline tree
4490	templated_operator_saved_lookups (tree t)
4491	{
4492	tree type = TREE_TYPE (EXPR_CHECK (t));
4493	if (type && TREE_CODE (type) == DEPENDENT_OPERATOR_TYPE)
4494	return DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS (type);
4495	else
4496	return NULL_TREE;
4497	}
4498
4499	/ Indicates whether a string literal has been parenthesized. Such*
4500	usages are disallowed in certain circumstances. /*
4501
4502	#define PAREN_STRING_LITERAL_P(NODE) \
4503	TREE_LANG_FLAG_0 (STRING_CST_CHECK (NODE))
4504
4505	/ Indicates whether a COMPONENT_REF or a SCOPE_REF has been parenthesized, an*
4506	INDIRECT_REF comes from parenthesizing a _DECL, or a PAREN_EXPR identifies a
4507	parenthesized initializer relevant for decltype(auto). Currently only set
4508	some of the time in C++14 mode. /*
4509
4510	#define REF_PARENTHESIZED_P(NODE) \
4511	TREE_LANG_FLAG_2 (TREE_CHECK5 ((NODE), COMPONENT_REF, INDIRECT_REF, SCOPE_REF, VIEW_CONVERT_EXPR, PAREN_EXPR))
4512
4513	/ True on a dependent COMPONENT_REF with a splice expression. /
4514
4515	#define COMPONENT_REF_SPLICE_P(NODE) \
4516	TREE_LANG_FLAG_0 (COMPONENT_REF_CHECK (NODE))
4517
4518	/ Nonzero if this AGGR_INIT_EXPR provides for initialization via a*
4519	constructor call, rather than an ordinary function call. /*
4520	#define AGGR_INIT_VIA_CTOR_P(NODE) \
4521	TREE_LANG_FLAG_0 (AGGR_INIT_EXPR_CHECK (NODE))
4522
4523	/ Nonzero if expanding this AGGR_INIT_EXPR should first zero-initialize*
4524	the object. /*
4525	#define AGGR_INIT_ZERO_FIRST(NODE) \
4526	TREE_LANG_FLAG_2 (AGGR_INIT_EXPR_CHECK (NODE))
4527
4528	/ Nonzero means that the call is the jump from a thunk to the*
4529	thunked-to function. /*
4530	#define AGGR_INIT_FROM_THUNK_P(NODE) \
4531	(AGGR_INIT_EXPR_CHECK (NODE)->base.protected_flag)
4532
4533	/ Nonzero means that the call was marked musttail. /
4534	#define AGGR_INIT_EXPR_MUST_TAIL(NODE) \
4535	(AGGR_INIT_EXPR_CHECK (NODE)->base.static_flag)
4536
4537	/ AGGR_INIT_EXPR accessors. These are equivalent to the CALL_EXPR*
4538	accessors, except for AGGR_INIT_EXPR_SLOT (which takes the place of
4539	CALL_EXPR_STATIC_CHAIN). /*
4540
4541	#define AGGR_INIT_EXPR_FN(NODE) TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 1)
4542	#define AGGR_INIT_EXPR_SLOT(NODE) \
4543	TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 2)
4544	#define AGGR_INIT_EXPR_ARG(NODE, I) \
4545	TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), (I) + 3)
4546	#define aggr_init_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH(NODE) - 3)
4547
4548	/ AGGR_INIT_EXPR_ARGP returns a pointer to the argument vector for NODE.*
4549	We can't use &AGGR_INIT_EXPR_ARG (NODE, 0) because that will complain if
4550	the argument count is zero when checking is enabled. Instead, do
4551	the pointer arithmetic to advance past the 3 fixed operands in a
4552	AGGR_INIT_EXPR. That produces a valid pointer to just past the end of
4553	the operand array, even if it's not valid to dereference it. /*
4554	#define AGGR_INIT_EXPR_ARGP(NODE) \
4555	(&(TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 0)) + 3)
4556
4557	/ Abstract iterators for AGGR_INIT_EXPRs. /
4558
4559	/ Structure containing iterator state. /
4560	struct aggr_init_expr_arg_iterator {
4561	tree t; / the aggr_init_expr /
4562	int n; / argument count /
4563	int i; / next argument index /
4564	};
4565
4566	/ Initialize the abstract argument list iterator object ITER with the*
4567	arguments from AGGR_INIT_EXPR node EXP. /*
4568	inline void
4569	init_aggr_init_expr_arg_iterator (tree exp,
4570	aggr_init_expr_arg_iterator *iter)
4571	{
4572	iter->t = exp;
4573	iter->n = aggr_init_expr_nargs (exp);
4574	iter->i = `0`;
4575	}
4576
4577	/ Return the next argument from abstract argument list iterator object ITER,*
4578	and advance its state. Return NULL_TREE if there are no more arguments. /*
4579	inline tree
4580	next_aggr_init_expr_arg (aggr_init_expr_arg_iterator *iter)
4581	{
4582	tree result;
4583	if (iter->i >= iter->n)
4584	return NULL_TREE;
4585	result = AGGR_INIT_EXPR_ARG (iter->t, iter->i);
4586	iter->i++;
4587	return result;
4588	}
4589
4590	/ Initialize the abstract argument list iterator object ITER, then advance*
4591	past and return the first argument. Useful in for expressions, e.g.
4592	for (arg = first_aggr_init_expr_arg (exp, &iter); arg;
4593	arg = next_aggr_init_expr_arg (&iter)) /*
4594	inline tree
4595	first_aggr_init_expr_arg (tree exp, aggr_init_expr_arg_iterator *iter)
4596	{
4597	init_aggr_init_expr_arg_iterator (exp, iter);
4598	return next_aggr_init_expr_arg (iter);
4599	}
4600
4601	/ Test whether there are more arguments in abstract argument list iterator*
4602	ITER, without changing its state. /*
4603	inline bool
4604	more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter)
4605	{
4606	return (iter->i < iter->n);
4607	}
4608
4609	/ Iterate through each argument ARG of AGGR_INIT_EXPR CALL, using variable*
4610	ITER (of type aggr_init_expr_arg_iterator) to hold the iteration state. /*
4611	#define FOR_EACH_AGGR_INIT_EXPR_ARG(arg, iter, call) \
4612	for ((arg) = first_aggr_init_expr_arg ((call), &(iter)); (arg); \
4613	(arg) = next_aggr_init_expr_arg (&(iter)))
4614
4615	/ We have an expression tree T that represents a call, either CALL_EXPR*
4616	or AGGR_INIT_EXPR. Return a reference to the Nth argument. /*
4617
4618	inline tree&
4619	get_nth_callarg (tree t, int n)
4620	{
4621	switch (TREE_CODE (t))
4622	{
4623	case CALL_EXPR:
4624	return CALL_EXPR_ARG (t, n);
4625
4626	case AGGR_INIT_EXPR:
4627	return AGGR_INIT_EXPR_ARG (t, n);
4628
4629	default:
4630	gcc_unreachable ();
4631	}
4632	}
4633
4634	/ VEC_INIT_EXPR accessors. /
4635	#define VEC_INIT_EXPR_SLOT(NODE) TREE_OPERAND (VEC_INIT_EXPR_CHECK (NODE), 0)
4636	#define VEC_INIT_EXPR_INIT(NODE) TREE_OPERAND (VEC_INIT_EXPR_CHECK (NODE), 1)
4637
4638	/ Indicates that a VEC_INIT_EXPR is a potential constant expression.*
4639	Only set when the current function is constexpr. /*
4640	#define VEC_INIT_EXPR_IS_CONSTEXPR(NODE) \
4641	TREE_LANG_FLAG_0 (VEC_INIT_EXPR_CHECK (NODE))
4642
4643	/ Indicates that a VEC_INIT_EXPR is expressing value-initialization. /
4644	#define VEC_INIT_EXPR_VALUE_INIT(NODE) \
4645	TREE_LANG_FLAG_1 (VEC_INIT_EXPR_CHECK (NODE))
4646
4647	/ If T is a VEC_INIT_EXPR, return it, possibly stripping a TARGET_EXPR*
4648	wrapper. Otherwise, return null. /*
4649	inline tree
4650	get_vec_init_expr (tree t)
4651	{
4652	if (t && TREE_CODE (t) == TARGET_EXPR)
4653	t = TARGET_EXPR_INITIAL (t);
4654	if (t && TREE_CODE (t) == VEC_INIT_EXPR)
4655	return t;
4656	return NULL_TREE;
4657	}
4658
4659	/ The condition under which this MUST_NOT_THROW_EXPR actually blocks*
4660	exceptions. NULL_TREE means 'true'. /*
4661	#define MUST_NOT_THROW_COND(NODE) \
4662	TREE_OPERAND (MUST_NOT_THROW_EXPR_CHECK (NODE), 1)
4663
4664	/ Reasons why MUST_NOT_THROW_EXPR has been created. /
4665
4666	/ Indicates MUST_NOT_THROW_EXPR has been created to wrap body of*
4667	a noexcept function. /*
4668	#define MUST_NOT_THROW_NOEXCEPT_P(NODE) \
4669	TREE_LANG_FLAG_0 (MUST_NOT_THROW_EXPR_CHECK (NODE))
4670
4671	/ Indicates MUST_NOT_THROW_EXPR has been created to wrap construction of*
4672	exception object during throw. /*
4673	#define MUST_NOT_THROW_THROW_P(NODE) \
4674	TREE_LANG_FLAG_1 (MUST_NOT_THROW_EXPR_CHECK (NODE))
4675
4676	/ Indicates MUST_NOT_THROW_EXPR has been created to wrap construction of*
4677	handler parameter during catch. /*
4678	#define MUST_NOT_THROW_CATCH_P(NODE) \
4679	TREE_LANG_FLAG_2 (MUST_NOT_THROW_EXPR_CHECK (NODE))
4680
4681	/ The TYPE_MAIN_DECL for a class template type is a TYPE_DECL, not a*
4682	TEMPLATE_DECL. This macro determines whether or not a given class
4683	type is really a template type, as opposed to an instantiation or
4684	specialization of one. /*
4685	#define CLASSTYPE_IS_TEMPLATE(NODE) \
4686	(CLASSTYPE_TEMPLATE_INFO (NODE) \
4687	&& !CLASSTYPE_USE_TEMPLATE (NODE) \
4688	&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE)))
4689
4690	/ The name used by the user to name the typename type. Typically,*
4691	this is an IDENTIFIER_NODE, and the same as the DECL_NAME on the
4692	corresponding TYPE_DECL. However, this may also be a
4693	TEMPLATE_ID_EXPR if we had something like `typename X::Y<T>'. /*
4694	#define TYPENAME_TYPE_FULLNAME(NODE) \
4695	(TYPE_VALUES_RAW (TYPENAME_TYPE_CHECK (NODE)))
4696
4697	/ Storage for the tag type of a TYPENAME_TYPE. /
4698	#define TYPENAME_TYPE_TAG_BIT_0(NODE) \
4699	(TREE_LANG_FLAG_0 (TYPENAME_TYPE_CHECK (NODE)))
4700	#define TYPENAME_TYPE_TAG_BIT_1(NODE) \
4701	(TREE_LANG_FLAG_1 (TYPENAME_TYPE_CHECK (NODE)))
4702	#define TYPENAME_TYPE_TAG_BIT_2(NODE) \
4703	(TREE_LANG_FLAG_2 (TYPENAME_TYPE_CHECK (NODE)))
4704
4705	/ True if a TYPENAME_TYPE was declared as an "enum". /
4706	#define TYPENAME_IS_ENUM_P(NODE) \
4707	(get_typename_tag (NODE) == enum_type)
4708
4709	/ True if a TYPENAME_TYPE was declared as a "class" or "struct". /
4710	#define TYPENAME_IS_CLASS_OR_STRUCT_P(NODE) \
4711	(get_typename_tag (NODE) == class_type \
4712	\|\| get_typename_tag (NODE) == record_type)
4713
4714	/ True if a TYPENAME_TYPE was declared as a "union". /
4715	#define TYPENAME_IS_UNION_P(NODE) \
4716	(get_typename_tag (NODE) == union_type)
4717
4718	/ True if a TYPENAME_TYPE is in the process of being resolved. /
4719	#define TYPENAME_IS_RESOLVING_P(NODE) \
4720	(TREE_LANG_FLAG_3 (TYPENAME_TYPE_CHECK (NODE)))
4721
4722	/ [class.virtual]*
4723
4724	A class that declares or inherits a virtual function is called a
4725	polymorphic class. /*
4726	#define TYPE_POLYMORPHIC_P(NODE) \
4727	(TREE_LANG_FLAG_2 (RECORD_OR_UNION_CHECK (NODE)))
4728
4729	/ Nonzero if this class has a virtual function table pointer. /
4730	#define TYPE_CONTAINS_VPTR_P(NODE) \
4731	(TYPE_POLYMORPHIC_P (NODE) \|\| CLASSTYPE_VBASECLASSES (NODE))
4732
4733	/ Nonzero if NODE is a FUNCTION_DECL or VAR_DECL (for a decl*
4734	with namespace scope) declared in a local scope. /*
4735	#define DECL_LOCAL_DECL_P(NODE) \
4736	DECL_LANG_FLAG_0 (VAR_OR_FUNCTION_DECL_CHECK (NODE))
4737
4738	/ The namespace-scope decl a DECL_LOCAL_DECL_P aliases. /
4739	#define DECL_LOCAL_DECL_ALIAS(NODE) \
4740	DECL_ACCESS ((gcc_checking_assert (DECL_LOCAL_DECL_P (NODE)), NODE))
4741
4742	/ True if NODE was declared with auto in its return type, but it has*
4743	started compilation and so the return type might have been changed by
4744	return type deduction; its declared return type should be found in
4745	DECL_SAVED_AUTO_RETURN_TYPE (NODE). /*
4746	#define FNDECL_USED_AUTO(NODE) \
4747	TREE_LANG_FLAG_2 (FUNCTION_DECL_CHECK (NODE))
4748
4749	/ True if NODE is needed for a manifestly constant-evaluated expression.*
4750	This doesn't especially need to be a flag, since currently it's only
4751	used for error recovery; if we run out of function flags it could move
4752	to an attribute. /*
4753	#define FNDECL_MANIFESTLY_CONST_EVALUATED(NODE) \
4754	TREE_LANG_FLAG_4 (FUNCTION_DECL_CHECK (NODE))
4755
4756	/ True for artificial decls added for OpenMP privatized non-static*
4757	data members. /*
4758	#define DECL_OMP_PRIVATIZED_MEMBER(NODE) \
4759	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.anticipated_p)
4760
4761	/ Nonzero if NODE is an artificial FUNCTION_DECL for*
4762	#pragma omp declare reduction. /*
4763	#define DECL_OMP_DECLARE_REDUCTION_P(NODE) \
4764	(LANG_DECL_FN_CHECK (DECL_COMMON_CHECK (NODE))->omp_declare_reduction_p)
4765
4766	/ Nonzero if NODE is an artificial FUNCTION_DECL for*
4767	#pragma omp declare mapper. /*
4768	#define DECL_OMP_DECLARE_MAPPER_P(NODE) \
4769	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.omp_declare_mapper_p)
4770
4771	/ Nonzero if DECL has been declared threadprivate by*
4772	#pragma omp threadprivate. /*
4773	#define CP_DECL_THREADPRIVATE_P(DECL) \
4774	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (DECL))->u.base.threadprivate_or_deleted_p)
4775
4776	/ Nonzero if NODE is a VAR_DECL which has been declared inline. /
4777	#define DECL_VAR_DECLARED_INLINE_P(NODE) \
4778	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE)) \
4779	? DECL_LANG_SPECIFIC (NODE)->u.base.var_declared_inline_p \
4780	: false)
4781	#define SET_DECL_VAR_DECLARED_INLINE_P(NODE) \
4782	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.var_declared_inline_p \
4783	= true)
4784
4785	/ True if NODE is a constant variable with a value-dependent initializer. /
4786	#define DECL_DEPENDENT_INIT_P(NODE) \
4787	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE)) \
4788	&& DECL_LANG_SPECIFIC (NODE)->u.base.dependent_init_p)
4789	#define SET_DECL_DEPENDENT_INIT_P(NODE, X) \
4790	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.dependent_init_p = (X))
4791
4792	/ Nonzero if NODE is an artificial VAR_DECL for a C++17 structured binding*
4793	declaration or one of VAR_DECLs for the user identifiers in it. /*
4794	#define DECL_DECOMPOSITION_P(NODE) \
4795	(VAR_P (NODE) && DECL_LANG_SPECIFIC (NODE) \
4796	? DECL_LANG_SPECIFIC (NODE)->u.base.selector == lds_decomp \
4797	: false)
4798
4799	/ The underlying artificial VAR_DECL for structured binding. On the*
4800	artificial base VAR_DECL this can be NULL, or integer_{zero,one}_node
4801	for structured binding used in if/while/for resp. switch conditions,
4802	or a TARGET_EXPR with the condition value after cp_finish_decomp in
4803	those cases. /*
4804	#define DECL_DECOMP_BASE(NODE) \
4805	(LANG_DECL_DECOMP_CHECK (NODE)->base)
4806
4807	/ True for the artificial VAR_DECL for structured binding. /
4808	#define DECL_DECOMP_IS_BASE(NODE) \
4809	(!DECL_DECOMP_BASE (NODE) \|\| !VAR_P (DECL_DECOMP_BASE (NODE)))
4810
4811	/ Nonzero if NODE is an inline VAR_DECL. In C++17, static data members*
4812	declared with constexpr specifier are implicitly inline variables. /*
4813	#define DECL_INLINE_VAR_P(NODE) \
4814	(DECL_VAR_DECLARED_INLINE_P (NODE) \
4815	\|\| (cxx_dialect >= cxx17 \
4816	&& DECL_DECLARED_CONSTEXPR_P (NODE) \
4817	&& DECL_CLASS_SCOPE_P (NODE)))
4818
4819	/ Nonzero if DECL was declared with '= delete'.*
4820	= delete("reason") is represented in addition to this flag by DECL_INITIAL
4821	being STRING_CST with the reason and TREE_TYPE of the STRING_CST the
4822	RID_DELETE IDENTIFIER_NODE. /*
4823	#define DECL_DELETED_FN(DECL) \
4824	(LANG_DECL_FN_CHECK (DECL)->min.base.threadprivate_or_deleted_p)
4825
4826	/ Nonzero if DECL was declared with '= default' (maybe implicitly). /
4827	#define DECL_DEFAULTED_FN(DECL) \
4828	(LANG_DECL_FN_CHECK (DECL)->defaulted_p)
4829
4830	/ Nonzero if DECL is explicitly defaulted in the class body. /
4831	#define DECL_DEFAULTED_IN_CLASS_P(DECL) \
4832	(DECL_DEFAULTED_FN (DECL) && DECL_INITIALIZED_IN_CLASS_P (DECL))
4833	/ Nonzero if DECL was defaulted outside the class body. /
4834	#define DECL_DEFAULTED_OUTSIDE_CLASS_P(DECL) \
4835	(DECL_DEFAULTED_FN (DECL) \
4836	&& !(DECL_ARTIFICIAL (DECL) \|\| DECL_INITIALIZED_IN_CLASS_P (DECL)))
4837
4838	/ Record whether a typedef for type `int' was actually `signed int'. /
4839	#define C_TYPEDEF_EXPLICITLY_SIGNED(EXP) DECL_LANG_FLAG_1 (EXP)
4840
4841	/ Returns nonzero if DECL has external linkage, as specified by the*
4842	language standard. (This predicate may hold even when the
4843	corresponding entity is not actually given external linkage in the
4844	object file; see decl_linkage for details.) /*
4845	#define DECL_EXTERNAL_LINKAGE_P(DECL) \
4846	(decl_linkage (DECL) == lk_external)
4847
4848	/ Keep these codes in ascending code order. /
4849
4850	#define INTEGRAL_CODE_P(CODE) \
4851	((CODE) == ENUMERAL_TYPE \
4852	\|\| (CODE) == BOOLEAN_TYPE \
4853	\|\| (CODE) == INTEGER_TYPE)
4854
4855	/ [basic.fundamental]*
4856
4857	Types bool, char, wchar_t, and the signed and unsigned integer types
4858	are collectively called integral types.
4859
4860	Note that INTEGRAL_TYPE_P, as defined in tree.h, allows enumeration
4861	types as well, which is incorrect in C++. Keep these checks in
4862	ascending code order. /*
4863	#define CP_INTEGRAL_TYPE_P(TYPE) \
4864	(TREE_CODE (TYPE) == BOOLEAN_TYPE \
4865	\|\| TREE_CODE (TYPE) == INTEGER_TYPE)
4866
4867	/ Returns true if TYPE is an integral or enumeration name. Keep*
4868	these checks in ascending code order. /*
4869	#define INTEGRAL_OR_ENUMERATION_TYPE_P(TYPE) \
4870	(TREE_CODE (TYPE) == ENUMERAL_TYPE \|\| CP_INTEGRAL_TYPE_P (TYPE))
4871
4872	/ Returns true if TYPE is an integral or unscoped enumeration type. /
4873	#define INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P(TYPE) \
4874	(UNSCOPED_ENUM_P (TYPE) \|\| CP_INTEGRAL_TYPE_P (TYPE))
4875
4876	/ True if the class type TYPE is a literal type. /
4877	#define CLASSTYPE_LITERAL_P(TYPE) \
4878	(LANG_TYPE_CLASS_CHECK (TYPE)->is_literal)
4879
4880	/ [basic.fundamental]*
4881
4882	Integral and floating types are collectively called arithmetic
4883	types.
4884
4885	As a GNU extension, we also accept complex types.
4886
4887	Keep these checks in ascending code order. /*
4888	#define ARITHMETIC_TYPE_P(TYPE) \
4889	(CP_INTEGRAL_TYPE_P (TYPE) \
4890	\|\| SCALAR_FLOAT_TYPE_P (TYPE) \
4891	\|\| TREE_CODE (TYPE) == COMPLEX_TYPE)
4892
4893	/ [basic.types]*
4894
4895	Arithmetic types, enumeration types, pointer types, pointer-to-member types,
4896	std::meta::info, std::nullptr_t and cv-qualified versions of these types
4897	are collectively called scalar types.
4898
4899	Keep these checks in ascending code order. /*
4900	#define SCALAR_TYPE_P(TYPE) \
4901	(TYPE_PTRDATAMEM_P (TYPE) \
4902	\|\| TREE_CODE (TYPE) == ENUMERAL_TYPE \
4903	\|\| ARITHMETIC_TYPE_P (TYPE) \
4904	\|\| TYPE_PTR_P (TYPE) \
4905	\|\| TYPE_PTRMEMFUNC_P (TYPE) \
4906	\|\| NULLPTR_TYPE_P (TYPE) \
4907	\|\| REFLECTION_TYPE_P (TYPE))
4908
4909	/ Determines whether this type is a C++0x scoped enumeration*
4910	type. Scoped enumerations types are introduced via "enum class" or
4911	"enum struct", e.g.,
4912
4913	enum class Color {
4914	Red, Green, Blue
4915	};
4916
4917	Scoped enumeration types are different from normal (unscoped)
4918	enumeration types in several ways:
4919
4920	- The enumerators of a scoped enumeration type are only available
4921	within the scope of the enumeration type and not in the
4922	enclosing scope. For example, the Red color can be referred to
4923	with "Color::Red" but not "Red".
4924
4925	- Scoped enumerators and enumerations do not implicitly convert
4926	to integers or 'bool'.
4927
4928	- The underlying type of the enum is well-defined. /*
4929	#define SCOPED_ENUM_P(TYPE) \
4930	(TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_SCOPED (TYPE))
4931
4932	/ Determine whether this is an unscoped enumeration type. /
4933	#define UNSCOPED_ENUM_P(TYPE) \
4934	(TREE_CODE (TYPE) == ENUMERAL_TYPE && !ENUM_IS_SCOPED (TYPE))
4935
4936	/ Set the flag indicating whether an ENUMERAL_TYPE is a C++0x scoped*
4937	enumeration type (1) or a normal (unscoped) enumeration type
4938	(0). /*
4939	#define SET_SCOPED_ENUM_P(TYPE, VAL) \
4940	(ENUM_IS_SCOPED (TYPE) = (VAL))
4941
4942	#define SET_OPAQUE_ENUM_P(TYPE, VAL) \
4943	(ENUM_IS_OPAQUE (TYPE) = (VAL))
4944
4945	#define OPAQUE_ENUM_P(TYPE) \
4946	(TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_OPAQUE (TYPE))
4947
4948	/ Nonzero when the ENUMERAL_TYPE is being defined (enumerators parsed*
4949	or instantiated). /*
4950	#define ENUM_BEING_DEFINED_P(NODE) \
4951	(TYPE_LANG_FLAG_2 (ENUMERAL_TYPE_CHECK (NODE)))
4952
4953	/ [dcl.init.aggr]*
4954
4955	An aggregate is an array or a class with no user-provided
4956	constructors, no brace-or-equal-initializers for non-static data
4957	members, no private or protected non-static data members, no
4958	base classes, and no virtual functions.
4959
4960	As an extension, we also treat vectors as aggregates. Keep these
4961	checks in ascending code order. /*
4962	#define CP_AGGREGATE_TYPE_P(TYPE) \
4963	(gnu_vector_type_p (TYPE) \
4964	\|\| TREE_CODE (TYPE) == ARRAY_TYPE \
4965	\|\| (CLASS_TYPE_P (TYPE) && COMPLETE_TYPE_P (TYPE) && !CLASSTYPE_NON_AGGREGATE (TYPE)))
4966
4967	/ Nonzero for a class type means that the class type has a*
4968	user-declared constructor. /*
4969	#define TYPE_HAS_USER_CONSTRUCTOR(NODE) (TYPE_LANG_FLAG_1 (NODE))
4970
4971	/ Nonzero means that the FUNCTION_TYPE or METHOD_TYPE has a*
4972	late-specified return type. /*
4973	#define TYPE_HAS_LATE_RETURN_TYPE(NODE) \
4974	(TYPE_LANG_FLAG_2 (FUNC_OR_METHOD_CHECK (NODE)))
4975
4976	/ When appearing in an INDIRECT_REF, it means that the tree structure*
4977	underneath is actually a call to a constructor. This is needed
4978	when the constructor must initialize local storage (which can
4979	be automatically destroyed), rather than allowing it to allocate
4980	space from the heap.
4981
4982	When appearing in a SAVE_EXPR, it means that underneath
4983	is a call to a constructor.
4984
4985	When appearing in a CONSTRUCTOR, the expression is an unconverted
4986	compound literal.
4987
4988	When appearing in a CALL_EXPR, it means that it is a call to
4989	a constructor.
4990
4991	When appearing in a FIELD_DECL, it means that this field
4992	has been duly initialized in its constructor. /*
4993	#define TREE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_4 (NODE))
4994
4995	/ True if NODE is a brace-enclosed initializer. /
4996	#define BRACE_ENCLOSED_INITIALIZER_P(NODE) \
4997	(TREE_CODE (NODE) == CONSTRUCTOR && TREE_TYPE (NODE) == init_list_type_node)
4998
4999	/ True if NODE is a compound-literal, i.e., a brace-enclosed*
5000	initializer cast to a particular type. This is mostly only set during
5001	template parsing; once the initializer has been digested into an actual
5002	value of the type, the expression is represented by a TARGET_EXPR. /*
5003	#define COMPOUND_LITERAL_P(NODE) \
5004	(TREE_CODE (NODE) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (NODE))
5005
5006	#define EMPTY_CONSTRUCTOR_P(NODE) (TREE_CODE (NODE) == CONSTRUCTOR \
5007	&& vec_safe_is_empty(CONSTRUCTOR_ELTS(NODE))\
5008	&& !TREE_HAS_CONSTRUCTOR (NODE))
5009
5010	/ True if NODE is a init-list used as a direct-initializer, i.e.*
5011	B b{1,2}, not B b({1,2}) or B b = {1,2}. /*
5012	#define CONSTRUCTOR_IS_DIRECT_INIT(NODE) (TREE_LANG_FLAG_0 (CONSTRUCTOR_CHECK (NODE)))
5013
5014	/ True if this CONSTRUCTOR is instantiation-dependent and needs to be*
5015	substituted. /*
5016	#define CONSTRUCTOR_IS_DEPENDENT(NODE) \
5017	(TREE_LANG_FLAG_1 (CONSTRUCTOR_CHECK (NODE)))
5018
5019	/ True if this CONSTRUCTOR should not be used as a variable initializer*
5020	because it was loaded from a constexpr variable with mutable fields. /*
5021	#define CONSTRUCTOR_MUTABLE_POISON(NODE) \
5022	(TREE_LANG_FLAG_2 (CONSTRUCTOR_CHECK (NODE)))
5023
5024	/ True if this typed CONSTRUCTOR represents C99 compound-literal syntax rather*
5025	than C++11 functional cast syntax. /*
5026	#define CONSTRUCTOR_C99_COMPOUND_LITERAL(NODE) \
5027	(TREE_LANG_FLAG_3 (CONSTRUCTOR_CHECK (NODE)))
5028
5029	/ True if this CONSTRUCTOR contains PLACEHOLDER_EXPRs referencing the*
5030	CONSTRUCTOR's type not nested inside another CONSTRUCTOR marked with
5031	CONSTRUCTOR_PLACEHOLDER_BOUNDARY. /*
5032	#define CONSTRUCTOR_PLACEHOLDER_BOUNDARY(NODE) \
5033	(TREE_LANG_FLAG_5 (CONSTRUCTOR_CHECK (NODE)))
5034
5035	#define DIRECT_LIST_INIT_P(NODE) \
5036	(BRACE_ENCLOSED_INITIALIZER_P (NODE) && CONSTRUCTOR_IS_DIRECT_INIT (NODE))
5037
5038	/ True if this is a designated initializer (when we allow initializer-clauses*
5039	mixed with designated-initializer-clauses set whenever there is at least
5040	one designated-initializer-clause), or a C99 designator. /*
5041	#define CONSTRUCTOR_IS_DESIGNATED_INIT(NODE) \
5042	(TREE_LANG_FLAG_6 (CONSTRUCTOR_CHECK (NODE)))
5043
5044	/ True if this CONSTRUCTOR comes from a parenthesized list of values, e.g.*
5045	A(1, 2, 3). /*
5046	#define CONSTRUCTOR_IS_PAREN_INIT(NODE) \
5047	(CONSTRUCTOR_CHECK(NODE)->base.private_flag)
5048
5049	/ True if reshape_init built this sub-CONSTRUCTOR to undo the brace elision*
5050	of the original CONSTRUCTOR. This flag is used during C++20 aggregate
5051	CTAD. /*
5052	#define CONSTRUCTOR_BRACES_ELIDED_P(NODE) \
5053	(CONSTRUCTOR_CHECK (NODE)->base.protected_flag)
5054
5055	/ True if NODE represents a conversion for direct-initialization in a*
5056	template. Set by perform_implicit_conversion_flags. /*
5057	#define IMPLICIT_CONV_EXPR_DIRECT_INIT(NODE) \
5058	(TREE_LANG_FLAG_0 (IMPLICIT_CONV_EXPR_CHECK (NODE)))
5059
5060	/ True if NODE represents a dependent conversion of a non-type template*
5061	argument. Set by maybe_convert_nontype_argument. /*
5062	#define IMPLICIT_CONV_EXPR_NONTYPE_ARG(NODE) \
5063	(TREE_LANG_FLAG_1 (IMPLICIT_CONV_EXPR_CHECK (NODE)))
5064
5065	/ True if NODE represents a conversion for braced-init-list in a*
5066	template. Set by perform_implicit_conversion_flags. /*
5067	#define IMPLICIT_CONV_EXPR_BRACED_INIT(NODE) \
5068	(TREE_LANG_FLAG_2 (IMPLICIT_CONV_EXPR_CHECK (NODE)))
5069
5070	/ True if NODE represents a conversion forced to be represented in*
5071	maybe_convert_nontype_argument, i.e. for an alias template. /*
5072	#define IMPLICIT_CONV_EXPR_FORCED(NODE) \
5073	(TREE_LANG_FLAG_3 (IMPLICIT_CONV_EXPR_CHECK (NODE)))
5074
5075	/ Nonzero means that an object of this type cannot be initialized using*
5076	an initializer list. /*
5077	#define CLASSTYPE_NON_AGGREGATE(NODE) \
5078	(LANG_TYPE_CLASS_CHECK (NODE)->non_aggregate)
5079	#define TYPE_NON_AGGREGATE_CLASS(NODE) \
5080	(CLASS_TYPE_P (NODE) && CLASSTYPE_NON_AGGREGATE (NODE))
5081
5082	/ Nonzero if there is a non-trivial X::op=(cv X&) for this class. /
5083	#define TYPE_HAS_COMPLEX_COPY_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_copy_assign)
5084
5085	/ Nonzero if there is a non-trivial X::X(cv X&) for this class. /
5086	#define TYPE_HAS_COMPLEX_COPY_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_copy_ctor)
5087
5088	/ Nonzero if there is a non-trivial X::op=(X&&) for this class. /
5089	#define TYPE_HAS_COMPLEX_MOVE_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_move_assign)
5090
5091	/ Nonzero if there is a non-trivial X::X(X&&) for this class. /
5092	#define TYPE_HAS_COMPLEX_MOVE_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_move_ctor)
5093
5094	/ Nonzero if there is no trivial default constructor for this class. /
5095	#define TYPE_HAS_COMPLEX_DFLT(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_dflt)
5096
5097	/ Nonzero if TYPE has a trivial destructor. From [class.dtor]:*
5098
5099	A destructor is trivial if it is an implicitly declared
5100	destructor and if:
5101
5102	- all of the direct base classes of its class have trivial
5103	destructors,
5104
5105	- for all of the non-static data members of its class that are
5106	of class type (or array thereof), each such class has a
5107	trivial destructor. /*
5108	#define TYPE_HAS_TRIVIAL_DESTRUCTOR(NODE) \
5109	(!TYPE_HAS_NONTRIVIAL_DESTRUCTOR (NODE))
5110
5111	/ Nonzero for _TYPE node means that this type does not have a trivial*
5112	destructor. Therefore, destroying an object of this type will
5113	involve a call to a destructor. This can apply to objects of
5114	ARRAY_TYPE if the type of the elements needs a destructor. /*
5115	#define TYPE_HAS_NONTRIVIAL_DESTRUCTOR(NODE) \
5116	(TYPE_LANG_FLAG_4 (NODE))
5117
5118	/ Nonzero for class type means that the default constructor is trivial. /
5119	#define TYPE_HAS_TRIVIAL_DFLT(NODE) \
5120	(TYPE_HAS_DEFAULT_CONSTRUCTOR (NODE) && ! TYPE_HAS_COMPLEX_DFLT (NODE))
5121
5122	/ Nonzero for class type means that copy initialization of this type can use*
5123	a bitwise copy. /*
5124	#define TYPE_HAS_TRIVIAL_COPY_CTOR(NODE) \
5125	(TYPE_HAS_COPY_CTOR (NODE) && ! TYPE_HAS_COMPLEX_COPY_CTOR (NODE))
5126
5127	/ Nonzero for class type means that assignment of this type can use*
5128	a bitwise copy. /*
5129	#define TYPE_HAS_TRIVIAL_COPY_ASSIGN(NODE) \
5130	(TYPE_HAS_COPY_ASSIGN (NODE) && ! TYPE_HAS_COMPLEX_COPY_ASSIGN (NODE))
5131
5132	/ Returns true if NODE is a pointer-to-data-member. /
5133	#define TYPE_PTRDATAMEM_P(NODE) \
5134	(TREE_CODE (NODE) == OFFSET_TYPE)
5135
5136	/ Returns true if NODE is a pointer. /
5137	#define TYPE_PTR_P(NODE) \
5138	(TREE_CODE (NODE) == POINTER_TYPE)
5139
5140	/ Returns true if NODE is a reference. /
5141	#define TYPE_REF_P(NODE) \
5142	(TREE_CODE (NODE) == REFERENCE_TYPE)
5143
5144	/ Returns true if NODE is a pointer or a reference. /
5145	#define INDIRECT_TYPE_P(NODE) \
5146	(TYPE_PTR_P (NODE) \|\| TYPE_REF_P (NODE))
5147
5148	/ Returns true if NODE is an object type:*
5149
5150	[basic.types]
5151
5152	An object type is a (possibly cv-qualified) type that is not a
5153	function type, not a reference type, and not a void type.
5154
5155	Keep these checks in ascending order, for speed. /*
5156	#define TYPE_OBJ_P(NODE) \
5157	(!TYPE_REF_P (NODE) \
5158	&& !VOID_TYPE_P (NODE) \
5159	&& !FUNC_OR_METHOD_TYPE_P (NODE))
5160
5161	/ Returns true if NODE is a pointer to an object. Keep these checks*
5162	in ascending tree code order. /*
5163	#define TYPE_PTROB_P(NODE) \
5164	(TYPE_PTR_P (NODE) && TYPE_OBJ_P (TREE_TYPE (NODE)))
5165
5166	/ Returns true if NODE is a reference to an object. Keep these checks*
5167	in ascending tree code order. /*
5168	#define TYPE_REF_OBJ_P(NODE) \
5169	(TYPE_REF_P (NODE) && TYPE_OBJ_P (TREE_TYPE (NODE)))
5170
5171	/ Returns true if NODE is a pointer to an object, or a pointer to*
5172	void. Keep these checks in ascending tree code order. /*
5173	#define TYPE_PTROBV_P(NODE) \
5174	(TYPE_PTR_P (NODE) \
5175	&& !FUNC_OR_METHOD_TYPE_P (TREE_TYPE (NODE)))
5176
5177	/ Returns true if NODE is a pointer to function type. /
5178	#define TYPE_PTRFN_P(NODE) \
5179	(TYPE_PTR_P (NODE) \
5180	&& TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE)
5181
5182	/ Returns true if NODE is a reference to function type. /
5183	#define TYPE_REFFN_P(NODE) \
5184	(TYPE_REF_P (NODE) \
5185	&& TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE)
5186
5187	/ Returns true if NODE is a pointer to member function type. /
5188	#define TYPE_PTRMEMFUNC_P(NODE) \
5189	(TREE_CODE (NODE) == RECORD_TYPE \
5190	&& TYPE_PTRMEMFUNC_FLAG (NODE))
5191
5192	#define TYPE_PTRMEMFUNC_FLAG(NODE) \
5193	(TYPE_LANG_FLAG_2 (RECORD_TYPE_CHECK (NODE)))
5194
5195	/ Returns true if NODE is a pointer-to-member. /
5196	#define TYPE_PTRMEM_P(NODE) \
5197	(TYPE_PTRDATAMEM_P (NODE) \|\| TYPE_PTRMEMFUNC_P (NODE))
5198
5199	/ Returns true if NODE is a pointer or a pointer-to-member. /
5200	#define TYPE_PTR_OR_PTRMEM_P(NODE) \
5201	(TYPE_PTR_P (NODE) \|\| TYPE_PTRMEM_P (NODE))
5202
5203	/ Indicates when overload resolution may resolve to a pointer to*
5204	member function. [expr.unary.op]/3 /*
5205	#define PTRMEM_OK_P(NODE) \
5206	TREE_LANG_FLAG_0 (TREE_CHECK3 ((NODE), ADDR_EXPR, OFFSET_REF, SCOPE_REF))
5207
5208	/ True if this ADDR_EXPR denotes a function call; that is, it's*
5209	fn() rather than &fn. /*
5210	#define ADDR_EXPR_DENOTES_CALL_P(NODE) \
5211	(ADDR_EXPR_CHECK(NODE)->base.protected_flag)
5212
5213	/ Get the POINTER_TYPE to the METHOD_TYPE associated with this*
5214	pointer to member function. TYPE_PTRMEMFUNC_P _must_ be true,
5215	before using this macro. /*
5216	#define TYPE_PTRMEMFUNC_FN_TYPE(NODE) \
5217	(cp_build_qualified_type (TREE_TYPE (TYPE_FIELDS (NODE)),\
5218	cp_type_quals (NODE)))
5219
5220	/ As above, but can be used in places that want an lvalue at the expense*
5221	of not necessarily having the correct cv-qualifiers. /*
5222	#define TYPE_PTRMEMFUNC_FN_TYPE_RAW(NODE) \
5223	(TREE_TYPE (TYPE_FIELDS (NODE)))
5224
5225	/ Returns `A' for a type like `int (A::)(double)' /*
5226	#define TYPE_PTRMEMFUNC_OBJECT_TYPE(NODE) \
5227	TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE)))
5228
5229	/ The canonical internal RECORD_TYPE from the POINTER_TYPE to*
5230	METHOD_TYPE. /*
5231	#define TYPE_PTRMEMFUNC_TYPE(NODE) \
5232	TYPE_LANG_SLOT_1 (NODE)
5233
5234	/ For a pointer-to-member type of the form `T X::', this is `X'.
5235	For a type like `void (X::)() const', this type is `X', not `const*
5236	X'. To get at the `const X' you have to look at the
5237	TYPE_PTRMEM_POINTED_TO_TYPE; there, the first parameter will have
5238	type `const X'. /
5239	#define TYPE_PTRMEM_CLASS_TYPE(NODE) \
5240	(TYPE_PTRDATAMEM_P (NODE) \
5241	? TYPE_OFFSET_BASETYPE (NODE) \
5242	: TYPE_PTRMEMFUNC_OBJECT_TYPE (NODE))
5243
5244	/ For a pointer-to-member type of the form `T X::', this is `T'. /*
5245	#define TYPE_PTRMEM_POINTED_TO_TYPE(NODE) \
5246	(TYPE_PTRDATAMEM_P (NODE) \
5247	? TREE_TYPE (NODE) \
5248	: TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE)))
5249
5250	/ For a pointer-to-member constant `X::Y' this is the RECORD_TYPE for*
5251	`X'. /*
5252	#define PTRMEM_CST_CLASS(NODE) \
5253	TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (PTRMEM_CST_CHECK (NODE)))
5254
5255	/ For a pointer-to-member constant `X::Y' this is the _DECL for*
5256	`Y'. /*
5257	#define PTRMEM_CST_MEMBER(NODE) \
5258	(((ptrmem_cst_t)PTRMEM_CST_CHECK (NODE))->member)
5259
5260	/ For a pointer-to-member constant `X::Y' this is a location where*
5261	the address of the member has been taken. /*
5262	#define PTRMEM_CST_LOCATION(NODE) \
5263	(((ptrmem_cst_t)PTRMEM_CST_CHECK (NODE))->locus)
5264
5265	/ The expression in question for a TYPEOF_TYPE. /
5266	#define TYPEOF_TYPE_EXPR(NODE) (TYPE_VALUES_RAW (TYPEOF_TYPE_CHECK (NODE)))
5267
5268	/ The type in question for an UNDERLYING_TYPE. /
5269	#define UNDERLYING_TYPE_TYPE(NODE) \
5270	(TYPE_VALUES_RAW (UNDERLYING_TYPE_CHECK (NODE)))
5271
5272	/ The type in question for BASES. /
5273	#define BASES_TYPE(NODE) \
5274	(TYPE_VALUES_RAW (BASES_CHECK (NODE)))
5275
5276	#define BASES_DIRECT(NODE) \
5277	TREE_LANG_FLAG_0 (BASES_CHECK (NODE))
5278
5279	/ The expression in question for a DECLTYPE_TYPE. /
5280	#define DECLTYPE_TYPE_EXPR(NODE) (TYPE_VALUES_RAW (DECLTYPE_TYPE_CHECK (NODE)))
5281
5282	/ Whether the DECLTYPE_TYPE_EXPR of NODE was originally parsed as an*
5283	id-expression or a member-access expression. When false, it was
5284	parsed as a full expression. /*
5285	#define DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P(NODE) \
5286	(DECLTYPE_TYPE_CHECK (NODE))->type_common.string_flag
5287
5288	/ These flags indicate that we want different semantics from normal*
5289	decltype: lambda capture just drops references,
5290	lambda proxies look through implicit dereference. /*
5291	#define DECLTYPE_FOR_LAMBDA_CAPTURE(NODE) \
5292	TREE_LANG_FLAG_0 (DECLTYPE_TYPE_CHECK (NODE))
5293	#define DECLTYPE_FOR_LAMBDA_PROXY(NODE) \
5294	TREE_LANG_FLAG_2 (DECLTYPE_TYPE_CHECK (NODE))
5295	#define DECLTYPE_FOR_REF_CAPTURE(NODE) \
5296	TREE_LANG_FLAG_3 (DECLTYPE_TYPE_CHECK (NODE))
5297
5298	/ Nonzero for VAR_DECL and FUNCTION_DECL node means that `extern' was*
5299	specified in its declaration. This can also be set for an
5300	erroneously declared PARM_DECL. /*
5301	#define DECL_THIS_EXTERN(NODE) \
5302	DECL_LANG_FLAG_2 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE))
5303
5304	/ Nonzero for VAR_DECL and FUNCTION_DECL node means that `static' was*
5305	specified in its declaration. This can also be set for an
5306	erroneously declared PARM_DECL. /*
5307	#define DECL_THIS_STATIC(NODE) \
5308	DECL_LANG_FLAG_6 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE))
5309
5310	/ Nonzero for FIELD_DECL node means that this field is a lambda capture*
5311	field for an array of runtime bound. /*
5312	#define DECL_VLA_CAPTURE_P(NODE) \
5313	DECL_LANG_FLAG_1 (FIELD_DECL_CHECK (NODE))
5314
5315	/ Nonzero for PARM_DECL node means that this is an array function*
5316	parameter, i.e, a[] rather than a. /
5317	#define DECL_ARRAY_PARAMETER_P(NODE) \
5318	DECL_LANG_FLAG_1 (PARM_DECL_CHECK (NODE))
5319
5320	/ Nonzero for PARM_DECL node means it is a parameter of an earlier*
5321	declaration which is no longer in DECL_ARGUMENTS (DECL_CONTEXT (NODE))
5322	chain because a function definition has been parsed later. /*
5323	#define OLD_PARM_DECL_P(NODE) \
5324	TREE_LANG_FLAG_0 (PARM_DECL_CHECK (NODE))
5325
5326	/ Nonzero for PARM_DECL node means it has different names on different*
5327	declarations of the same FUNCTION_DECL. If it is unnamed on one and
5328	named on another, that is still fine. /*
5329	#define MULTIPLE_NAMES_PARM_P(NODE) \
5330	TREE_LANG_FLAG_2 (PARM_DECL_CHECK (NODE))
5331
5332	/ Nonzero for a FIELD_DECL who's NSMDI is currently being*
5333	instantiated. /*
5334	#define DECL_INSTANTIATING_NSDMI_P(NODE) \
5335	DECL_LANG_FLAG_2 (FIELD_DECL_CHECK (NODE))
5336
5337	/ Nonzero for FIELD_DECL node means that this field is a base class*
5338	of the parent object, as opposed to a member field. /*
5339	#define DECL_FIELD_IS_BASE(NODE) \
5340	DECL_LANG_FLAG_6 (FIELD_DECL_CHECK (NODE))
5341
5342	/ Nonzero for FIELD_DECL node means that this field is a simple (no*
5343	explicit initializer) lambda capture field, making it invisible to
5344	name lookup in unevaluated contexts. /*
5345	#define DECL_NORMAL_CAPTURE_P(NODE) \
5346	DECL_LANG_FLAG_7 (FIELD_DECL_CHECK (NODE))
5347
5348	/ Nonzero if TYPE is an anonymous union or struct type. We have to use a*
5349	flag for this because "A union for which objects or pointers are
5350	declared is not an anonymous union" [class.union]. /*
5351	#define ANON_AGGR_TYPE_P(NODE) \
5352	(CLASS_TYPE_P (NODE) && LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr)
5353	#define SET_ANON_AGGR_TYPE_P(NODE) \
5354	(LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr = 1)
5355
5356	/ Nonzero if TYPE is an anonymous union type. /
5357	#define ANON_UNION_TYPE_P(NODE) \
5358	(TREE_CODE (NODE) == UNION_TYPE && ANON_AGGR_TYPE_P (NODE))
5359
5360	/ For an ANON_AGGR_TYPE_P the single FIELD_DECL it is used with. /
5361	#define ANON_AGGR_TYPE_FIELD(NODE) \
5362	(LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var)
5363
5364	/ Define fields and accessors for nodes representing declared names. /
5365
5366	/ True if TYPE is an unnamed structured type with a typedef for*
5367	linkage purposes. In that case TYPE_NAME and TYPE_STUB_DECL of the
5368	MAIN-VARIANT are different. /*
5369	#define TYPE_WAS_UNNAMED(NODE) \
5370	(TYPE_NAME (TYPE_MAIN_VARIANT (NODE)) \
5371	!= TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE)))
5372
5373	/ C++: all of these are overloaded! These apply only to TYPE_DECLs. /
5374
5375	/ The format of each node in the DECL_FRIENDLIST is as follows:*
5376
5377	The TREE_PURPOSE will be the name of a function, i.e., an
5378	IDENTIFIER_NODE. The TREE_VALUE will be itself a TREE_LIST, whose
5379	TREE_VALUEs are friends with the given name. /*
5380	#define DECL_FRIENDLIST(NODE) (DECL_INITIAL (NODE))
5381	#define FRIEND_NAME(LIST) (TREE_PURPOSE (LIST))
5382	#define FRIEND_DECLS(LIST) (TREE_VALUE (LIST))
5383
5384	/ The DECL_ACCESS, if non-NULL, is a TREE_LIST. The TREE_PURPOSE of*
5385	each node is a type; the TREE_VALUE is the access granted for this
5386	DECL in that type. The DECL_ACCESS is set by access declarations.
5387	For example, if a member that would normally be public in a
5388	derived class is made protected, then the derived class and the
5389	protected_access_node will appear in the DECL_ACCESS for the node. /*
5390	#define DECL_ACCESS(NODE) (LANG_DECL_MIN_CHECK (NODE)->access)
5391
5392	/ In artificial VAR_DECL created by cxa_allocate_exception*
5393	this is reference count. /*
5394	#define DECL_EXCEPTION_REFCOUNT(NODE) (LANG_DECL_MIN_CHECK (NODE)->access)
5395
5396	/ Nonzero if the FUNCTION_DECL is a global constructor. /
5397	#define DECL_GLOBAL_CTOR_P(NODE) \
5398	(LANG_DECL_FN_CHECK (NODE)->global_ctor_p)
5399
5400	/ Nonzero if the FUNCTION_DECL is a global destructor. /
5401	#define DECL_GLOBAL_DTOR_P(NODE) \
5402	(LANG_DECL_FN_CHECK (NODE)->global_dtor_p)
5403
5404	/ Accessor macros for C++ template decl nodes. /
5405
5406	/ The DECL_TEMPLATE_PARMS are a list. The TREE_PURPOSE of each node*
5407	is a INT_CST whose TREE_INT_CST_LOW indicates the level of the
5408	template parameters, with 1 being the outermost set of template
5409	parameters. The TREE_TYPE is TEMPLATE_PARMS_CONSTRAINTS.
5410	The TREE_VALUE is a vector, whose elements are the
5411	template parameters at each level. Each element in the vector is a
5412	TREE_LIST, whose TREE_VALUE is a PARM_DECL (if the parameter is a
5413	non-type parameter), or a TYPE_DECL (if the parameter is a type
5414	parameter) or a TEMPLATE_DECL (if the parameter is a template
5415	parameter). The TREE_PURPOSE is the default value, if any.
5416	The TREE_TYPE is TEMPLATE_PARM_CONSTRAINTS. The
5417	TEMPLATE_PARM_INDEX for the parameter is available as the
5418	DECL_INITIAL (for a PARM_DECL) or as the TREE_TYPE (for a
5419	TYPE_DECL).
5420
5421	FIXME: const_cast<tree> is a hack that hopefully will go away after
5422	tree is converted to C++ class hiearchy. /*
5423	#define DECL_TEMPLATE_PARMS(NODE) \
5424	((struct tree_template_decl *)const_cast<tree> (TEMPLATE_DECL_CHECK \
5425	(NODE)))->arguments
5426	#define DECL_INNERMOST_TEMPLATE_PARMS(NODE) \
5427	INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (NODE))
5428	#define DECL_NTPARMS(NODE) \
5429	TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (NODE))
5430	/ For function, method, class-data templates.*
5431
5432	FIXME: const_cast<tree> is a hack that hopefully will go away after
5433	tree is converted to C++ class hiearchy. /*
5434	#define DECL_TEMPLATE_RESULT(NODE) \
5435	((struct tree_template_decl *)const_cast<tree> (TEMPLATE_DECL_CHECK \
5436	(NODE)))->result
5437	/ For a forward-declared function template at namespace scope, or for any*
5438	function template in an exporting module, DECL_TEMPLATE_INSTANTIATIONS lists
5439	all instantiations and specializations of the function so that
5440	tsubst_friend_function can reassign them to another template if we find that
5441	the namespace-scope template is really a partial instantiation of a friend
5442	template.
5443
5444	For a class or variable template the DECL_TEMPLATE_INSTANTIATIONS lists
5445	holds all instantiations and specializations, including partial
5446	instantiations and partial specializations, so that if we explicitly
5447	specialize a partial instantiation we can walk the list in
5448	maybe_process_partial_specialization and reassign them or complain as
5449	appropriate.
5450
5451	In both cases, the TREE_PURPOSE of each node contains the arguments
5452	used; the TREE_VALUE contains the generated variable. The template
5453	arguments are always complete. For example, given:
5454
5455	template <class T> struct S1 {
5456	template <class U> struct S2 {};
5457	template <class U> struct S2<U> {};*
5458	};
5459
5460	the record for the partial specialization will contain, as its
5461	argument list, { {T}, {U} }, and will be on the*
5462	DECL_TEMPLATE_INSTANTIATIONS list for `template <class T> template
5463	<class U> struct S1<T>::S2'.
5464
5465	This list is not used for other templates. /*
5466	#define DECL_TEMPLATE_INSTANTIATIONS(NODE) \
5467	DECL_SIZE_UNIT (TEMPLATE_DECL_CHECK (NODE))
5468
5469	/ For a class template, this list contains the partial*
5470	specializations of this template. (Full specializations are not
5471	recorded on this list.) The TREE_PURPOSE holds the arguments used
5472	in the partial specialization (e.g., for `template <class T> struct
5473	S<T, int>' this will be `T, int'.) The arguments will also include
5474	any outer template arguments. The TREE_VALUE holds the TEMPLATE_DECL
5475	for the partial specialization. The TREE_TYPE is the _TYPE node for
5476	the partial specialization.
5477
5478	This list is not used for other templates. /*
5479	#define DECL_TEMPLATE_SPECIALIZATIONS(NODE) \
5480	DECL_SIZE (TEMPLATE_DECL_CHECK (NODE))
5481
5482	/ Nonzero for a DECL which is actually a template parameter. Keep*
5483	these checks in ascending tree code order. /*
5484	#define DECL_TEMPLATE_PARM_P(NODE) \
5485	(DECL_LANG_FLAG_0 (NODE) \
5486	&& (TREE_CODE (NODE) == CONST_DECL \
5487	\|\| TREE_CODE (NODE) == PARM_DECL \
5488	\|\| TREE_CODE (NODE) == TYPE_DECL \
5489	\|\| TREE_CODE (NODE) == TEMPLATE_DECL))
5490
5491	#if ENABLE_TREE_CHECKING
5492	inline tree
5493	decl_template_parm_check (const_tree t, const char f, int* l, const char *fn)
5494	{
5495	if (!DECL_TEMPLATE_PARM_P (t))
5496	tree_check_failed (t, f, l, fn, `0`);
5497	return const_cast<tree>(t);
5498	}
5499	#endif
5500
5501	/ Nonzero for a raw template parameter node. /
5502	#define TEMPLATE_PARM_P(NODE) \
5503	(TREE_CODE (NODE) == TEMPLATE_TYPE_PARM \
5504	\|\| TREE_CODE (NODE) == TEMPLATE_TEMPLATE_PARM \
5505	\|\| TREE_CODE (NODE) == TEMPLATE_PARM_INDEX)
5506
5507	/ Mark NODE as a template parameter. /
5508	#define SET_DECL_TEMPLATE_PARM_P(NODE) \
5509	(DECL_LANG_FLAG_0 (NODE) = 1)
5510
5511	/ Nonzero if NODE is a template template parameter. /
5512	#define DECL_TEMPLATE_TEMPLATE_PARM_P(NODE) \
5513	(TREE_CODE (NODE) == TEMPLATE_DECL && DECL_TEMPLATE_PARM_P (NODE))
5514
5515	/ Nonzero for a DECL that represents a function template. /
5516	#define DECL_FUNCTION_TEMPLATE_P(NODE) \
5517	(TREE_CODE (NODE) == TEMPLATE_DECL \
5518	&& DECL_TEMPLATE_RESULT (NODE) != NULL_TREE \
5519	&& TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == FUNCTION_DECL)
5520
5521	/ Nonzero for a DECL that represents a class template or alias*
5522	template. /*
5523	#define DECL_TYPE_TEMPLATE_P(NODE) \
5524	(TREE_CODE (NODE) == TEMPLATE_DECL \
5525	&& DECL_TEMPLATE_RESULT (NODE) != NULL_TREE \
5526	&& TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == TYPE_DECL)
5527
5528	/ Nonzero for a DECL that represents a class template. /
5529	#define DECL_CLASS_TEMPLATE_P(NODE) \
5530	(DECL_TYPE_TEMPLATE_P (NODE) \
5531	&& DECL_IMPLICIT_TYPEDEF_P (DECL_TEMPLATE_RESULT (NODE)))
5532
5533	/ Nonzero for a TEMPLATE_DECL that represents an alias template. /
5534	#define DECL_ALIAS_TEMPLATE_P(NODE) \
5535	(DECL_TYPE_TEMPLATE_P (NODE) \
5536	&& !DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (NODE)))
5537
5538	/ Nonzero for a NODE which declares a type. /
5539	#define DECL_DECLARES_TYPE_P(NODE) \
5540	(TREE_CODE (NODE) == TYPE_DECL \|\| DECL_TYPE_TEMPLATE_P (NODE))
5541
5542	/ Nonzero if NODE declares a function. /
5543	#define DECL_DECLARES_FUNCTION_P(NODE) \
5544	(TREE_CODE (NODE) == FUNCTION_DECL \|\| DECL_FUNCTION_TEMPLATE_P (NODE))
5545
5546	/ Nonzero if NODE is the typedef implicitly generated for a type when*
5547	the type is declared. In C++, `struct S {};' is roughly
5548	equivalent to `struct S {}; typedef struct S S;' in C.
5549	DECL_IMPLICIT_TYPEDEF_P will hold for the typedef indicated in this
5550	example. In C++, there is a second implicit typedef for each
5551	class, called the injected-class-name, in the scope of `S' itself, so that
5552	you can say `S::S'. DECL_SELF_REFERENCE_P will hold for that typedef. /*
5553	#define DECL_IMPLICIT_TYPEDEF_P(NODE) \
5554	(TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_2 (NODE))
5555	#define SET_DECL_IMPLICIT_TYPEDEF_P(NODE) \
5556	(DECL_LANG_FLAG_2 (NODE) = 1)
5557	#define DECL_SELF_REFERENCE_P(NODE) \
5558	(TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_4 (NODE))
5559	#define SET_DECL_SELF_REFERENCE_P(NODE) \
5560	(DECL_LANG_FLAG_4 (NODE) = 1)
5561
5562	/ A `primary' template is one that has its own template header and is not*
5563	a partial specialization. A member function of a class template is a
5564	template, but not primary. A member template is primary. Friend
5565	templates are primary, too. /*
5566
5567	/ Returns the primary template corresponding to these parameters. /
5568	#define TPARMS_PRIMARY_TEMPLATE(NODE) (TREE_TYPE (TREE_VEC_CHECK (NODE)))
5569
5570	#define DECL_PRIMARY_TEMPLATE(NODE) \
5571	(TPARMS_PRIMARY_TEMPLATE (DECL_INNERMOST_TEMPLATE_PARMS (NODE)))
5572
5573	/ Returns nonzero if NODE is a primary template. /
5574	#define PRIMARY_TEMPLATE_P(NODE) (DECL_PRIMARY_TEMPLATE (NODE) == (NODE))
5575
5576	/ Nonzero iff NODE is a specialization of a template. The value*
5577	indicates the type of specializations:
5578
5579	1=implicit instantiation
5580
5581	2=partial or explicit specialization, e.g.:
5582
5583	template <> int min<int> (int, int),
5584
5585	3=explicit instantiation, e.g.:
5586
5587	template int min<int> (int, int);
5588
5589	Note that NODE will be marked as a specialization even if the
5590	template it is instantiating is not a primary template. For
5591	example, given:
5592
5593	template <typename T> struct O {
5594	void f();
5595	struct I {};
5596	};
5597
5598	both O<int>::f and O<int>::I will be marked as instantiations.
5599
5600	If DECL_USE_TEMPLATE is nonzero, then DECL_TEMPLATE_INFO will also
5601	be non-NULL. /*
5602	#define DECL_USE_TEMPLATE(NODE) (DECL_LANG_SPECIFIC (NODE)->u.base.use_template)
5603
5604	/ Like DECL_USE_TEMPLATE, but for class types. /
5605	#define CLASSTYPE_USE_TEMPLATE(NODE) \
5606	(LANG_TYPE_CLASS_CHECK (NODE)->use_template)
5607
5608	/ True if NODE is a specialization of a primary template. /
5609	#define CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P(NODE) \
5610	(CLASS_TYPE_P (NODE) \
5611	&& CLASSTYPE_USE_TEMPLATE (NODE) \
5612	&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE)))
5613
5614	#define DECL_TEMPLATE_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) & 1)
5615	#define CLASSTYPE_TEMPLATE_INSTANTIATION(NODE) \
5616	(CLASSTYPE_USE_TEMPLATE (NODE) & 1)
5617
5618	#define DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) == 2)
5619	#define SET_DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) = 2)
5620
5621	/ Returns true for an explicit or partial specialization of a class*
5622	template. /*
5623	#define CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \
5624	(CLASSTYPE_USE_TEMPLATE (NODE) == 2)
5625	#define SET_CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \
5626	(CLASSTYPE_USE_TEMPLATE (NODE) = 2)
5627
5628	#define DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 1)
5629	#define SET_DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 1)
5630	#define CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \
5631	(CLASSTYPE_USE_TEMPLATE (NODE) == 1)
5632	#define SET_CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \
5633	(CLASSTYPE_USE_TEMPLATE (NODE) = 1)
5634
5635	#define DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 3)
5636	#define SET_DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 3)
5637	#define CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \
5638	(CLASSTYPE_USE_TEMPLATE (NODE) == 3)
5639	#define SET_CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \
5640	(CLASSTYPE_USE_TEMPLATE (NODE) = 3)
5641
5642	/ Nonzero if DECL is a friend function which is an instantiation*
5643	from the point of view of the compiler, but not from the point of
5644	view of the language. For example given:
5645	template <class T> struct S { friend void f(T) {}; };
5646	the declaration of `void f(int)' generated when S<int> is
5647	instantiated will not be a DECL_TEMPLATE_INSTANTIATION, but will be
5648	a DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION. /*
5649	#define DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION(DECL) \
5650	(DECL_LANG_SPECIFIC (DECL) && DECL_TEMPLATE_INFO (DECL) \
5651	&& !DECL_USE_TEMPLATE (DECL))
5652
5653	/ Nonzero if DECL is a function generated from a function 'temploid',*
5654	i.e. template, member of class template, or dependent friend. /*
5655	#define DECL_TEMPLOID_INSTANTIATION(DECL) \
5656	(DECL_TEMPLATE_INSTANTIATION (DECL) \
5657	\|\| DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (DECL))
5658
5659	/ Nonzero if DECL is either defined implicitly by the compiler or*
5660	generated from a temploid. /*
5661	#define DECL_GENERATED_P(DECL) \
5662	(DECL_TEMPLOID_INSTANTIATION (DECL) \|\| DECL_DEFAULTED_FN (DECL))
5663
5664	/ Nonzero iff we are currently processing a declaration for an*
5665	entity with its own template parameter list, and which is not a
5666	full specialization. /*
5667	#define PROCESSING_REAL_TEMPLATE_DECL_P() \
5668	(!processing_template_parmlist \
5669	&& current_template_depth > template_class_depth (current_scope ()))
5670
5671	/ Nonzero if this VAR_DECL or FUNCTION_DECL has already been*
5672	instantiated, i.e. its definition has been generated from the
5673	pattern given in the template. /*
5674	#define DECL_TEMPLATE_INSTANTIATED(NODE) \
5675	DECL_LANG_FLAG_1 (VAR_OR_FUNCTION_DECL_CHECK (NODE))
5676
5677	/ We know what we're doing with this decl now. /
5678	#define DECL_INTERFACE_KNOWN(NODE) DECL_LANG_FLAG_5 (NODE)
5679
5680	/ DECL_EXTERNAL must be set on a decl until the decl is actually emitted,*
5681	so that assemble_external will work properly. So we have this flag to
5682	tell us whether the decl is really not external.
5683
5684	This flag does not indicate whether or not the decl is defined in the
5685	current translation unit; it indicates whether or not we should emit the
5686	decl at the end of compilation if it is defined and needed. /*
5687	#define DECL_NOT_REALLY_EXTERN(NODE) \
5688	(DECL_LANG_SPECIFIC (NODE)->u.base.not_really_extern)
5689
5690	#define DECL_REALLY_EXTERN(NODE) \
5691	(DECL_EXTERNAL (NODE) \
5692	&& (!DECL_LANG_SPECIFIC (NODE) \|\| !DECL_NOT_REALLY_EXTERN (NODE)))
5693
5694	/ A thunk is a stub function.*
5695
5696	A thunk is an alternate entry point for an ordinary FUNCTION_DECL.
5697	The address of the ordinary FUNCTION_DECL is given by the
5698	DECL_INITIAL, which is always an ADDR_EXPR whose operand is a
5699	FUNCTION_DECL. The job of the thunk is to either adjust the this
5700	pointer before transferring control to the FUNCTION_DECL, or call
5701	FUNCTION_DECL and then adjust the result value. Note, the result
5702	pointer adjusting thunk must perform a call to the thunked
5703	function, (or be implemented via passing some invisible parameter
5704	to the thunked function, which is modified to perform the
5705	adjustment just before returning).
5706
5707	A thunk may perform either, or both, of the following operations:
5708
5709	o Adjust the this or result pointer by a constant offset.
5710	o Adjust the this or result pointer by looking up a vcall or vbase offset
5711	in the vtable.
5712
5713	A this pointer adjusting thunk converts from a base to a derived
5714	class, and hence adds the offsets. A result pointer adjusting thunk
5715	converts from a derived class to a base, and hence subtracts the
5716	offsets. If both operations are performed, then the constant
5717	adjustment is performed first for this pointer adjustment and last
5718	for the result pointer adjustment.
5719
5720	The constant adjustment is given by THUNK_FIXED_OFFSET. If the
5721	vcall or vbase offset is required, THUNK_VIRTUAL_OFFSET is
5722	used. For this pointer adjusting thunks, it is the vcall offset
5723	into the vtable. For result pointer adjusting thunks it is the
5724	binfo of the virtual base to convert to. Use that binfo's vbase
5725	offset.
5726
5727	It is possible to have equivalent covariant thunks. These are
5728	distinct virtual covariant thunks whose vbase offsets happen to
5729	have the same value. THUNK_ALIAS is used to pick one as the
5730	canonical thunk, which will get all the this pointer adjusting
5731	thunks attached to it. /*
5732
5733	/ An integer indicating how many bytes should be subtracted from the*
5734	this or result pointer when this function is called. /*
5735	#define THUNK_FIXED_OFFSET(DECL) \
5736	(DECL_LANG_SPECIFIC (THUNK_FUNCTION_CHECK (DECL))->u.fn.u5.fixed_offset)
5737
5738	/ A tree indicating how to perform the virtual adjustment. For a this*
5739	adjusting thunk it is the number of bytes to be added to the vtable
5740	to find the vcall offset. For a result adjusting thunk, it is the
5741	binfo of the relevant virtual base. If NULL, then there is no
5742	virtual adjust. (The vptr is always located at offset zero from
5743	the this or result pointer.) (If the covariant type is within the
5744	class hierarchy being laid out, the vbase index is not yet known
5745	at the point we need to create the thunks, hence the need to use
5746	binfos.) /*
5747
5748	#define THUNK_VIRTUAL_OFFSET(DECL) \
5749	(LANG_DECL_MIN_CHECK (FUNCTION_DECL_CHECK (DECL))->access)
5750
5751	/ A thunk which is equivalent to another thunk. /
5752	#define THUNK_ALIAS(DECL) \
5753	(DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->u.min.template_info)
5754
5755	/ For thunk NODE, this is the FUNCTION_DECL thunked to. It is*
5756	possible for the target to be a thunk too. /*
5757	#define THUNK_TARGET(NODE) \
5758	(LANG_DECL_FN_CHECK (NODE)->befriending_classes)
5759
5760	/ True for a SCOPE_REF iff the "template" keyword was used to*
5761	indicate that the qualified name denotes a template. /*
5762	#define QUALIFIED_NAME_IS_TEMPLATE(NODE) \
5763	(TREE_LANG_FLAG_1 (SCOPE_REF_CHECK (NODE)))
5764
5765	/ [coroutines]*
5766	*/
5767
5768	/ True if NODE is a co-routine FUNCTION_DECL. /
5769	#define DECL_COROUTINE_P(NODE) \
5770	(LANG_DECL_FN_CHECK (DECL_COMMON_CHECK (NODE))->coroutine_p)
5771
5772	/ For a FUNCTION_DECL of a coroutine, this holds the ACTOR helper function*
5773	decl. /*
5774	#define DECL_ACTOR_FN(NODE) \
5775	(coro_get_actor_function ((NODE)))
5776
5777	/ For a FUNCTION_DECL of a coroutine, this holds the DESTROY helper function*
5778	decl. /*
5779	#define DECL_DESTROY_FN(NODE) \
5780	(coro_get_destroy_function ((NODE)))
5781
5782	/ For a FUNCTION_DECL of a coroutine helper (ACTOR or DESTROY), this points*
5783	back to the original (ramp) function. /*
5784	#define DECL_RAMP_FN(NODE) \
5785	(coro_get_ramp_function (NODE))
5786
5787	/ For a FUNCTION_DECL this is true if it is a coroutine ramp. /
5788	#define DECL_RAMP_P(NODE) \
5789	DECL_COROUTINE_P (NODE) && !DECL_RAMP_FN (NODE)
5790
5791	/ True for an OMP_ATOMIC that has dependent parameters. These are stored*
5792	as an expr in operand 1, and integer_zero_node or clauses in operand 0. /*
5793	#define OMP_ATOMIC_DEPENDENT_P(NODE) \
5794	(TREE_CODE (TREE_OPERAND (OMP_ATOMIC_CHECK (NODE), 0)) == INTEGER_CST \
5795	\|\| TREE_CODE (TREE_OPERAND (OMP_ATOMIC_CHECK (NODE), 0)) == OMP_CLAUSE)
5796
5797	/ Used while gimplifying continue statements bound to OMP_FOR nodes. /
5798	#define OMP_FOR_GIMPLIFYING_P(NODE) \
5799	(TREE_LANG_FLAG_0 (OMP_LOOPING_CHECK (NODE)))
5800
5801	/ A language-specific token attached to the OpenMP data clauses to*
5802	hold code (or code fragments) related to ctors, dtors, and op=.
5803	See semantics.cc for details. /*
5804	#define CP_OMP_CLAUSE_INFO(NODE) \
5805	TREE_TYPE (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_PRIVATE, \
5806	OMP_CLAUSE__CONDTEMP_))
5807
5808	/ Nonzero if this transaction expression's body contains statements. /
5809	#define TRANSACTION_EXPR_IS_STMT(NODE) \
5810	TREE_LANG_FLAG_0 (TRANSACTION_EXPR_CHECK (NODE))
5811
5812	/ These macros provide convenient access to the various _STMT nodes*
5813	created when parsing template declarations. /*
5814	#define TRY_STMTS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 0)
5815	#define TRY_HANDLERS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 1)
5816
5817	#define EH_SPEC_STMTS(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 0)
5818	#define EH_SPEC_RAISES(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 1)
5819
5820	#define USING_STMT_NAMESPACE(NODE) TREE_OPERAND (USING_STMT_CHECK (NODE), 0)
5821
5822	/ Nonzero if this try block is a function try block. /
5823	#define FN_TRY_BLOCK_P(NODE) TREE_LANG_FLAG_3 (TRY_BLOCK_CHECK (NODE))
5824	#define HANDLER_PARMS(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 0)
5825	#define HANDLER_BODY(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 1)
5826	#define HANDLER_TYPE(NODE) TREE_TYPE (HANDLER_CHECK (NODE))
5827
5828	/ CLEANUP_STMT accessors. The statement(s) covered, the cleanup to run*
5829	and the VAR_DECL for which this cleanup exists. /*
5830	#define CLEANUP_BODY(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 0)
5831	#define CLEANUP_EXPR(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 1)
5832	#define CLEANUP_DECL(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 2)
5833
5834	/ IF_STMT accessors. These give access to the condition of the if*
5835	statement, the then block of the if statement, and the else block
5836	of the if statement if it exists. /*
5837	#define IF_COND(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 0)
5838	#define THEN_CLAUSE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 1)
5839	#define ELSE_CLAUSE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 2)
5840	#define IF_SCOPE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 3)
5841	#define IF_STMT_CONSTEXPR_P(NODE) TREE_LANG_FLAG_0 (IF_STMT_CHECK (NODE))
5842	#define IF_STMT_CONSTEVAL_P(NODE) TREE_LANG_FLAG_2 (IF_STMT_CHECK (NODE))
5843	/ True on artificial if (0) around .DEFERRED_INIT calls added for*
5844	!!flag_auto_var_init. /*
5845	#define IF_STMT_VACUOUS_INIT_P(NODE) TREE_LANG_FLAG_3 (IF_STMT_CHECK (NODE))
5846
5847	/ Like PACK_EXPANSION_EXTRA_ARGS, for constexpr if. IF_SCOPE is used while*
5848	building an IF_STMT; IF_STMT_EXTRA_ARGS is used after it is complete. /*
5849	#define IF_STMT_EXTRA_ARGS(NODE) IF_SCOPE (NODE)
5850
5851	/ RANGE_FOR_STMT accessors. These give access to the declarator,*
5852	expression, body, and scope of the statement, respectively. /*
5853	#define RANGE_FOR_DECL(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 0)
5854	#define RANGE_FOR_EXPR(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 1)
5855	#define RANGE_FOR_BODY(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 2)
5856	#define RANGE_FOR_SCOPE(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 3)
5857	#define RANGE_FOR_UNROLL(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 4)
5858	#define RANGE_FOR_INIT_STMT(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 5)
5859	#define RANGE_FOR_IVDEP(NODE) TREE_LANG_FLAG_6 (RANGE_FOR_STMT_CHECK (NODE))
5860	#define RANGE_FOR_NOVECTOR(NODE) TREE_LANG_FLAG_5 (RANGE_FOR_STMT_CHECK (NODE))
5861
5862	/ TEMPLATE_FOR_STMT accessors. These give access to the declarator,*
5863	expression, body, and scope of the statement, respectively. /*
5864	#define TEMPLATE_FOR_DECL(NODE) \
5865	TREE_OPERAND (TEMPLATE_FOR_STMT_CHECK (NODE), 0)
5866	#define TEMPLATE_FOR_EXPR(NODE) \
5867	TREE_OPERAND (TEMPLATE_FOR_STMT_CHECK (NODE), 1)
5868	#define TEMPLATE_FOR_BODY(NODE) \
5869	TREE_OPERAND (TEMPLATE_FOR_STMT_CHECK (NODE), 2)
5870	#define TEMPLATE_FOR_SCOPE(NODE) \
5871	TREE_OPERAND (TEMPLATE_FOR_STMT_CHECK (NODE), 3)
5872	#define TEMPLATE_FOR_INIT_STMT(NODE) \
5873	TREE_OPERAND (TEMPLATE_FOR_STMT_CHECK (NODE), 4)
5874
5875	/ STMT_EXPR accessor. /
5876	#define STMT_EXPR_STMT(NODE) TREE_OPERAND (STMT_EXPR_CHECK (NODE), 0)
5877
5878	/ EXPR_STMT accessor. This gives the expression associated with an*
5879	expression statement. /*
5880	#define EXPR_STMT_EXPR(NODE) TREE_OPERAND (EXPR_STMT_CHECK (NODE), 0)
5881
5882	/ True if this TARGET_EXPR was created by build_cplus_new, and so we can*
5883	discard it if it isn't useful. /*
5884	#define TARGET_EXPR_IMPLICIT_P(NODE) \
5885	TREE_LANG_FLAG_0 (TARGET_EXPR_CHECK (NODE))
5886
5887	/ True if this TARGET_EXPR is the result of list-initialization of a*
5888	temporary. /*
5889	#define TARGET_EXPR_LIST_INIT_P(NODE) \
5890	TREE_LANG_FLAG_1 (TARGET_EXPR_CHECK (NODE))
5891
5892	/ True if this TARGET_EXPR expresses direct-initialization of an object*
5893	to be named later. /*
5894	#define TARGET_EXPR_DIRECT_INIT_P(NODE) \
5895	TREE_LANG_FLAG_2 (TARGET_EXPR_CHECK (NODE))
5896
5897	/ True if we expect this TARGET_EXPR to be used as an initializer, not to*
5898	materialize as a temporary. /*
5899	#define TARGET_EXPR_ELIDING_P(NODE) \
5900	TREE_LANG_FLAG_3 (TARGET_EXPR_CHECK (NODE))
5901
5902	/ True if this TARGET_EXPR is for holding an implementation detail like a*
5903	cleanup flag or loop index, and should be ignored by extend_all_temps. /*
5904	#define TARGET_EXPR_INTERNAL_P(NODE) \
5905	TREE_LANG_FLAG_4 (TARGET_EXPR_CHECK (NODE))
5906
5907	/ True if NODE is a TARGET_EXPR that just expresses a copy of its INITIAL; if*
5908	the initializer has void type, it's doing something more complicated. /*
5909	#define SIMPLE_TARGET_EXPR_P(NODE) \
5910	(TREE_CODE (NODE) == TARGET_EXPR \
5911	&& TARGET_EXPR_INITIAL (NODE) \
5912	&& !VOID_TYPE_P (TREE_TYPE (TARGET_EXPR_INITIAL (NODE))))
5913
5914	/ True if T is a TARGET_EXPR for which we'll need to replace_decl to use it as*
5915	an initializer. /*
5916	inline bool
5917	target_expr_needs_replace (tree t)
5918	{
5919	if (!t \|\| TREE_CODE (t) != TARGET_EXPR)
5920	return false;
5921	tree init = TARGET_EXPR_INITIAL (t);
5922	if (!init \|\| !VOID_TYPE_P (TREE_TYPE (init)))
5923	return false;
5924	while (TREE_CODE (init) == COMPOUND_EXPR)
5925	init = TREE_OPERAND (init, `1`);
5926	return (TREE_CODE (init) != AGGR_INIT_EXPR
5927	&& TREE_CODE (init) != VEC_INIT_EXPR);
5928	}
5929
5930	/ True if EXPR expresses direct-initialization of a TYPE. /
5931	#define DIRECT_INIT_EXPR_P(TYPE,EXPR) \
5932	(TREE_CODE (EXPR) == TARGET_EXPR && TREE_LANG_FLAG_2 (EXPR) \
5933	&& same_type_ignoring_top_level_qualifiers_p (TYPE, TREE_TYPE (EXPR)))
5934
5935	/ True if this CONVERT_EXPR is for a conversion to virtual base in*
5936	an NSDMI, and should be re-evaluated when used in a constructor. /*
5937	#define CONVERT_EXPR_VBASE_PATH(NODE) \
5938	TREE_LANG_FLAG_0 (CONVERT_EXPR_CHECK (NODE))
5939
5940	/ True if SIZEOF_EXPR argument is type. /
5941	#define SIZEOF_EXPR_TYPE_P(NODE) \
5942	TREE_LANG_FLAG_0 (SIZEOF_EXPR_CHECK (NODE))
5943
5944	/ True if the ALIGNOF_EXPR was spelled "alignof". /
5945	#define ALIGNOF_EXPR_STD_P(NODE) \
5946	TREE_LANG_FLAG_0 (ALIGNOF_EXPR_CHECK (NODE))
5947
5948	/ OMP_DEPOBJ accessors. These give access to the depobj expression of the*
5949	#pragma omp depobj directive and the clauses, respectively. If
5950	OMP_DEPOBJ_CLAUSES is INTEGER_CST, it is instead the update clause kind
5951	or OMP_CLAUSE_DEPEND_LAST for destroy clause. /*
5952	#define OMP_DEPOBJ_DEPOBJ(NODE) TREE_OPERAND (OMP_DEPOBJ_CHECK (NODE), 0)
5953	#define OMP_DEPOBJ_CLAUSES(NODE) TREE_OPERAND (OMP_DEPOBJ_CHECK (NODE), 1)
5954
5955	/ An enumeration of the kind of tags that C++ accepts. /
5956	enum tag_types {
5957	none_type = `0`, / Not a tag type. /
5958	record_type, / "struct" types. /
5959	class_type, / "class" types. /
5960	union_type, / "union" types. /
5961	enum_type, / "enum" types. /
5962	typename_type, / "typename" types. /
5963	scope_type / namespace or tagged type name followed by :: /
5964	};
5965
5966	/ Return the tag type of the given TYPENAME_TYPE. /
5967
5968	inline tag_types
5969	get_typename_tag (tree t)
5970	{
5971	unsigned bit0 = TYPENAME_TYPE_TAG_BIT_0 (t);
5972	unsigned bit1 = TYPENAME_TYPE_TAG_BIT_1 (t);
5973	unsigned bit2 = TYPENAME_TYPE_TAG_BIT_2 (t);
5974	return tag_types ((bit2 << `2`) \| (bit1 << `1`) \| bit0);
5975	}
5976
5977	/ Set the tag type of the given TYPENAME_TYPE. /
5978
5979	inline void
5980	set_typename_tag (tree t, tag_types tag)
5981	{
5982	gcc_checking_assert ((tag & `7`) == tag);
5983	TYPENAME_TYPE_TAG_BIT_0 (t) = (tag >> `0`) & `1`;
5984	TYPENAME_TYPE_TAG_BIT_1 (t) = (tag >> `1`) & `1`;
5985	TYPENAME_TYPE_TAG_BIT_2 (t) = (tag >> `2`) & `1`;
5986	}
5987
5988	/ The various kinds of lvalues we distinguish. /
5989	enum cp_lvalue_kind_flags {
5990	clk_none = `0`, / Things that are not an lvalue. /
5991	clk_ordinary = `1`, / An ordinary lvalue. /
5992	clk_rvalueref = `2`,/ An xvalue (rvalue formed using an rvalue reference) /
5993	clk_class = `4`, / A prvalue of class or array type. /
5994	clk_bitfield = `8`, / An lvalue for a bit-field. /
5995	clk_packed = `16`, / An lvalue for a packed field. /
5996	clk_implicit_rval = `1`<<`5`, / An lvalue being treated as an xvalue. /
5997	clk_mergeable = `1`<<`6`
5998	};
5999
6000	/ This type is used for parameters and variables which hold*
6001	combinations of the flags in enum cp_lvalue_kind_flags. /*
6002	typedef int cp_lvalue_kind;
6003
6004	/ Various kinds of template specialization, instantiation, etc. /
6005	enum tmpl_spec_kind {
6006	tsk_none, / Not a template at all. /
6007	tsk_invalid_member_spec, / An explicit member template*
6008	specialization, but the enclosing
6009	classes have not all been explicitly
6010	specialized. /*
6011	tsk_invalid_expl_inst, / An explicit instantiation containing*
6012	template parameter lists. /*
6013	tsk_excessive_parms, / A template declaration with too many*
6014	template parameter lists. /*
6015	tsk_insufficient_parms, / A template declaration with too few*
6016	parameter lists. /*
6017	tsk_template, / A template declaration. /
6018	tsk_expl_spec, / An explicit specialization. /
6019	tsk_expl_inst / An explicit instantiation. /
6020	};
6021
6022	/ The various kinds of access. BINFO_ACCESS depends on these being*
6023	two bit quantities. The numerical values are important; they are
6024	used to initialize RTTI data structures, so changing them changes
6025	the ABI. /*
6026	enum access_kind {
6027	ak_none = `0`, / Inaccessible. /
6028	ak_public = `1`, / Accessible, as a `public' thing. /
6029	ak_protected = `2`, / Accessible, as a `protected' thing. /
6030	ak_private = `3` / Accessible, as a `private' thing. /
6031	};
6032
6033	/ The various kinds of special functions. If you add to this list,*
6034	you should update special_function_p as well. /*
6035	enum special_function_kind {
6036	sfk_none = `0`, / Not a special function. This enumeral*
6037	must have value zero; see
6038	special_function_p. /*
6039	/ The following are ordered, for use by member synthesis fns. /
6040	sfk_destructor, / A destructor. /
6041	sfk_constructor, / A constructor. /
6042	sfk_inheriting_constructor, / An inheriting constructor /
6043	sfk_copy_constructor, / A copy constructor. /
6044	sfk_move_constructor, / A move constructor. /
6045	sfk_copy_assignment, / A copy assignment operator. /
6046	sfk_move_assignment, / A move assignment operator. /
6047	/ The following are unordered. /
6048	sfk_complete_destructor, / A destructor for complete objects. /
6049	sfk_base_destructor, / A destructor for base subobjects. /
6050	sfk_deleting_destructor, / A destructor for complete objects that*
6051	deletes the object after it has been
6052	destroyed. /*
6053	sfk_conversion, / A conversion operator. /
6054	sfk_deduction_guide, / A class template deduction guide. /
6055	sfk_comparison, / A comparison operator (e.g. ==, <, <=>). /
6056	sfk_virtual_destructor / Used by member synthesis fns. /
6057	};
6058
6059	/ The various kinds of linkage. From [basic.link],*
6060
6061	A name is said to have linkage when it might denote the same
6062	object, reference, function, type, template, namespace or value
6063	as a name introduced in another scope:
6064
6065	-- When a name has external linkage, the entity it denotes can
6066	be referred to from scopes of other translation units or from
6067	other scopes of the same translation unit.
6068
6069	-- When a name has internal linkage, the entity it denotes can
6070	be referred to by names from other scopes in the same
6071	translation unit.
6072
6073	-- When a name has no linkage, the entity it denotes cannot be
6074	referred to by names from other scopes. /*
6075
6076	enum linkage_kind {
6077	lk_none, / No linkage. /
6078	lk_internal, / Internal linkage. /
6079	lk_external / External linkage. /
6080	};
6081
6082	enum duration_kind {
6083	dk_static,
6084	dk_thread,
6085	dk_auto,
6086	dk_dynamic
6087	};
6088
6089	/ Bitmask flags to control type substitution. /
6090	enum tsubst_flags {
6091	tf_none = `0`, / nothing special /
6092	tf_error = `1` << `0`, / give error messages /
6093	tf_warning = `1` << `1`, / give warnings too /
6094	tf_ignore_bad_quals = `1` << `2`, / ignore bad cvr qualifiers /
6095	tf_keep_type_decl = `1` << `3`, / retain typedef type decls*
6096	(make_typename_type use) /*
6097	tf_ptrmem_ok = `1` << `4`, / pointers to member ok (internal*
6098	instantiate_type use) /*
6099	tf_user = `1` << `5`, / found template must be a user template*
6100	(lookup_template_class use) /*
6101	tf_conv = `1` << `6`, / We are determining what kind of*
6102	conversion might be permissible,
6103	not actually performing the
6104	conversion. /*
6105	tf_decltype = `1` << `7`, / We are the operand of decltype.*
6106	Used to implement the special rules
6107	for calls in decltype (5.2.2/11). /*
6108	tf_partial = `1` << `8`, / Doing initial explicit argument*
6109	substitution in fn_type_unification. /*
6110	tf_fndecl_type = `1` << `9`, / Substituting the type of a function*
6111	declaration. /*
6112	tf_no_cleanup = `1` << `10`, / Do not build a cleanup*
6113	(build_target_expr and friends) /*
6114	/ 1 << 11 is available. /
6115	tf_tst_ok = `1` << `12`, / Allow a typename-specifier to name*
6116	a template (C++17 or later). /*
6117	tf_dguide = `1` << `13`, / Building a deduction guide from a ctor. /
6118	tf_qualifying_scope = `1` << `14`, / Substituting the LHS of the :: operator.*
6119	Affects TYPENAME_TYPE resolution from
6120	make_typename_type. /*
6121	tf_no_name_lookup = `1` << `15`, / Don't look up the terminal name of an*
6122	outermost id-expression, or resolve its
6123	constituent template-ids or qualified-ids. /*
6124	/ Convenient substitution flags combinations. /
6125	tf_warning_or_error = tf_warning \| tf_error
6126	};
6127
6128	/ This type is used for parameters and variables which hold*
6129	combinations of the flags in enum tsubst_flags. /*
6130	typedef int tsubst_flags_t;
6131
6132	/ The kind of checking we can do looking in a class hierarchy. /
6133	enum base_access_flags {
6134	ba_any = `0`, / Do not check access, allow an ambiguous base,*
6135	prefer a non-virtual base /*
6136	ba_unique = `1` << `0`, / Must be a unique base. /
6137	ba_check_bit = `1` << `1`, / Check access. /
6138	ba_check = ba_unique \| ba_check_bit,
6139	ba_ignore_scope = `1` << `2`, / Ignore access allowed by local scope. /
6140	ba_require_virtual = `1` << `3` / Require a virtual base. /
6141	};
6142
6143	/ This type is used for parameters and variables which hold*
6144	combinations of the flags in enum base_access_flags. /*
6145	typedef int base_access;
6146
6147	/ The various kinds of access check during parsing. /
6148	enum deferring_kind {
6149	dk_no_deferred = `0`, / Check access immediately /
6150	dk_deferred = `1`, / Deferred check /
6151	dk_no_check = `2` / No access check /
6152	};
6153
6154	/ The kind of base we can find, looking in a class hierarchy.*
6155	Values <0 indicate we failed. /*
6156	enum base_kind {
6157	bk_inaccessible = -`3`, / The base is inaccessible /
6158	bk_ambig = -`2`, / The base is ambiguous /
6159	bk_not_base = -`1`, / It is not a base /
6160	bk_same_type = `0`, / It is the same type /
6161	bk_proper_base = `1`, / It is a proper base /
6162	bk_via_virtual = `2` / It is a proper base, but via a virtual*
6163	path. This might not be the canonical
6164	binfo. /*
6165	};
6166
6167	/ Node for "pointer to (virtual) function".*
6168	This may be distinct from ptr_type_node so gdb can distinguish them. /*
6169	#define vfunc_ptr_type_node vtable_entry_type
6170
6171
6172	/ For building calls to `delete'. /
6173	extern GTY(()) tree integer_two_node;
6174
6175	/ The number of function bodies which we are currently processing.*
6176	(Zero if we are at namespace scope, one inside the body of a
6177	function, two inside the body of a function in a local class, etc.) /*
6178	extern int function_depth;
6179
6180	/ Nonzero if we are inside spec_hasher::equal, which affects*
6181	comparison of PARM_DECLs in cp_tree_equal. /*
6182	extern int comparing_specializations;
6183
6184	/ Nonzero if we want different dependent aliases to compare as unequal.*
6185	FIXME we should always do this except during deduction/ordering. /*
6186	extern int comparing_dependent_aliases;
6187
6188	/ True if we are matching contracts of two functions. Depending on*
6189	whether a decl has been genericized or not, PARM_DECL may be adjusted
6190	to be an invisible reference. /*
6191	extern bool comparing_contracts;
6192
6193	/ In parser.cc. /
6194
6195	extern bool cp_preserve_using_decl;
6196
6197	/ Nonzero if we are parsing an unevaluated operand: an operand to*
6198	sizeof, typeof, or alignof. This is a count since operands to
6199	sizeof can be nested. /*
6200
6201	extern int cp_unevaluated_operand;
6202
6203	/ RAII class used to inhibit the evaluation of operands during parsing*
6204	and template instantiation. Evaluation warnings are also inhibited. /*
6205
6206	class cp_unevaluated
6207	{
6208	public:
6209	cp_unevaluated ();
6210	~cp_unevaluated ();
6211	};
6212
6213	/ The reverse: an RAII class used for nested contexts that are evaluated even*
6214	if the enclosing context is not. /*
6215
6216	class cp_evaluated
6217	{
6218	public:
6219	int uneval;
6220	int inhibit;
6221	cp_evaluated (bool reset = true)
6222	: uneval(cp_unevaluated_operand), inhibit(c_inhibit_evaluation_warnings)
6223	{ if (reset)
6224	cp_unevaluated_operand = c_inhibit_evaluation_warnings = `0`; }
6225	~cp_evaluated ()
6226	{ cp_unevaluated_operand = uneval;
6227	c_inhibit_evaluation_warnings = inhibit; }
6228	};
6229
6230	/ in pt.cc /
6231
6232	/ These values are used for the `STRICT' parameter to type_unification and*
6233	fn_type_unification. Their meanings are described with the
6234	documentation for fn_type_unification. /*
6235
6236	enum unification_kind_t {
6237	DEDUCE_CALL,
6238	DEDUCE_CONV,
6239	DEDUCE_EXACT
6240	};
6241
6242	// An RAII class used to create a new pointer map for local
6243	// specializations. When the stack goes out of scope, the
6244	// previous pointer map is restored.
6245	enum lss_policy { lss_blank, lss_copy, lss_nop };
6246	class local_specialization_stack
6247	{
6248	public:
6249	local_specialization_stack (lss_policy = lss_blank);
6250	~local_specialization_stack ();
6251
6252	hash_map<tree, tree> *saved;
6253	};
6254
6255	/ Entry in the specialization hash table. /
6256	struct GTY((for_user)) spec_entry
6257	{
6258	/ The general template this is a specialization of. /
6259	tree tmpl;
6260	/ The args for this (maybe-partial) specialization. /
6261	tree args;
6262	/ The specialization itself. /
6263	tree spec = NULL_TREE;
6264	/ The cached result of hash_tmpl_and_args (tmpl, args). /
6265	hashval_t hash = `0`;
6266	};
6267
6268	/ in class.cc /
6269
6270	extern int current_class_depth;
6271
6272	/ in decl.cc /
6273
6274	/ An array of static vars & fns. /
6275	extern GTY(()) vec<tree, va_gc> *static_decls;
6276
6277	/ An array of vtable-needing types that have no key function, or have*
6278	an emitted key function. /*
6279	extern GTY(()) vec<tree, va_gc> *keyed_classes;
6280
6281	/ Here's where we control how name mangling takes place. /
6282
6283	/ Cannot use '$' up front, because this confuses gdb*
6284	(names beginning with '$' are gdb-local identifiers).
6285
6286	Note that all forms in which the '$' is significant are long enough
6287	for direct indexing (meaning that if we know there is a '$'
6288	at a particular location, we can index into the string at
6289	any other location that provides distinguishing characters). /*
6290
6291	/ Define NO_DOT_IN_LABEL in your favorite tm file if your assembler*
6292	doesn't allow '.' in symbol names. /*
6293	#ifndef NO_DOT_IN_LABEL
6294
6295	#define JOINER '.'
6296	#define JOIN_STR "."
6297
6298	#define AUTO_TEMP_NAME "_.tmp_"
6299	#define VFIELD_BASE ".vf"
6300	#define VFIELD_NAME "_vptr."
6301	#define VFIELD_NAME_FORMAT "_vptr.%s"
6302
6303	#else /* NO_DOT_IN_LABEL */
6304
6305	#ifndef NO_DOLLAR_IN_LABEL
6306
6307	#define JOINER '$'
6308	#define JOIN_STR "$"
6309
6310	#define AUTO_TEMP_NAME "_$tmp_"
6311	#define VFIELD_BASE "$vf"
6312	#define VFIELD_NAME "_vptr$"
6313	#define VFIELD_NAME_FORMAT "_vptr$%s"
6314
6315	#else /* NO_DOLLAR_IN_LABEL */
6316
6317	#define JOIN_STR "_"
6318
6319	#define VTABLE_NAME "__vt_"
6320	#define VTABLE_NAME_P(ID_NODE) \
6321	(!strncmp (IDENTIFIER_POINTER (ID_NODE), VTABLE_NAME, \
6322	sizeof (VTABLE_NAME) - 1))
6323	#define VFIELD_BASE "__vfb"
6324	#define VFIELD_NAME "__vptr_"
6325	#define VFIELD_NAME_P(ID_NODE) \
6326	(!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, \
6327	sizeof (VFIELD_NAME) - 1))
6328	#define VFIELD_NAME_FORMAT "__vptr_%s"
6329
6330	#endif /* NO_DOLLAR_IN_LABEL */
6331	#endif /* NO_DOT_IN_LABEL */
6332
6333	#define UDLIT_OP_ANSI_PREFIX "operator\"\""
6334	#define UDLIT_OP_ANSI_FORMAT UDLIT_OP_ANSI_PREFIX "%s"
6335	#define UDLIT_OP_MANGLED_PREFIX "li"
6336	#define UDLIT_OP_MANGLED_FORMAT UDLIT_OP_MANGLED_PREFIX "%s"
6337	#define UDLIT_OPER_P(ID_NODE) \
6338	(!strncmp (IDENTIFIER_POINTER (ID_NODE), \
6339	UDLIT_OP_ANSI_PREFIX, \
6340	sizeof (UDLIT_OP_ANSI_PREFIX) - 1))
6341	#define UDLIT_OP_SUFFIX(ID_NODE) \
6342	(IDENTIFIER_POINTER (ID_NODE) + sizeof (UDLIT_OP_ANSI_PREFIX) - 1)
6343
6344	#if !defined(NO_DOLLAR_IN_LABEL) \|\| !defined(NO_DOT_IN_LABEL)
6345
6346	#define VTABLE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == 'v' \
6347	&& IDENTIFIER_POINTER (ID_NODE)[2] == 't' \
6348	&& IDENTIFIER_POINTER (ID_NODE)[3] == JOINER)
6349
6350	#define VFIELD_NAME_P(ID_NODE) \
6351	(!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, sizeof(VFIELD_NAME)-1))
6352
6353	#endif /* !defined(NO_DOLLAR_IN_LABEL) \|\| !defined(NO_DOT_IN_LABEL) */
6354
6355
6356	/ Nonzero if we're done parsing and into end-of-file activities.*
6357	2 if all templates have been instantiated.
6358	3 if we're done with front-end processing. /*
6359
6360	extern int at_eof;
6361
6362	/ True if note_mangling_alias should enqueue mangling aliases for*
6363	later generation, rather than emitting them right away. /*
6364
6365	extern bool defer_mangling_aliases;
6366
6367	/ True if noexcept is part of the type (i.e. in C++17). /
6368
6369	extern bool flag_noexcept_type;
6370
6371	/ True if this TREE_LIST in {static,tls}_aggregates is a for dynamic*
6372	initialization of namespace scope structured binding base or related
6373	extended ref init temps. Temporaries from the initialization of
6374	STATIC_INIT_DECOMP_BASE_P dynamic initializers should be destroyed only
6375	after the last STATIC_INIT_DECOMP_NONBASE_P dynamic initializer following
6376	it. /*
6377	#define STATIC_INIT_DECOMP_BASE_P(NODE) \
6378	TREE_LANG_FLAG_1 (TREE_LIST_CHECK (NODE))
6379
6380	/ True if this TREE_LIST in {static,tls}_aggregates is a for dynamic*
6381	initialization of namespace scope structured binding non-base
6382	variable using get. /*
6383	#define STATIC_INIT_DECOMP_NONBASE_P(NODE) \
6384	TREE_LANG_FLAG_2 (TREE_LIST_CHECK (NODE))
6385
6386	/ A list of namespace-scope objects which have constructors or*
6387	destructors which reside in the global scope. The decl is stored
6388	in the TREE_VALUE slot and the initializer is stored in the
6389	TREE_PURPOSE slot. /*
6390	extern GTY(()) tree static_aggregates;
6391	/ Likewise, for thread local storage. /
6392	extern GTY(()) tree tls_aggregates;
6393
6394	/ A hash-map mapping from variable decls to the dynamic initializer for*
6395	the decl. This is currently only used by OpenMP. /*
6396	extern GTY(()) decl_tree_map *dynamic_initializers;
6397
6398	enum overload_flags { NO_SPECIAL = `0`, DTOR_FLAG, TYPENAME_FLAG };
6399
6400	/ These are uses as bits in flags passed to various functions to*
6401	control their behavior. Despite the LOOKUP_ prefix, many of these
6402	do not control name lookup. ??? Functions using these flags should
6403	probably be modified to accept explicit boolean flags for the
6404	behaviors relevant to them. /*
6405	/ Check for access violations. /
6406	#define LOOKUP_PROTECT (1 << 0)
6407	#define LOOKUP_NORMAL (LOOKUP_PROTECT)
6408	/ Even if the function found by lookup is a virtual function, it*
6409	should be called directly. /*
6410	#define LOOKUP_NONVIRTUAL (1 << 1)
6411	/ Non-converting (i.e., "explicit") constructors are not tried. This flag*
6412	indicates that we are not performing direct-initialization. /*
6413	#define LOOKUP_ONLYCONVERTING (1 << 2)
6414	#define LOOKUP_IMPLICIT (LOOKUP_NORMAL \| LOOKUP_ONLYCONVERTING)
6415	/ If a temporary is created, it should be created so that it lives*
6416	as long as the current variable bindings; otherwise it only lives
6417	until the end of the complete-expression. It also forces
6418	direct-initialization in cases where other parts of the compiler
6419	have already generated a temporary, such as reference
6420	initialization and the catch parameter. /*
6421	#define DIRECT_BIND (1 << 3)
6422	/ We're performing a user-defined conversion, so more user-defined*
6423	conversions are not permitted (only built-in conversions). /*
6424	#define LOOKUP_NO_CONVERSION (1 << 4)
6425	/ The user has explicitly called a destructor. (Therefore, we do*
6426	not need to check that the object is non-NULL before calling the
6427	destructor.) /*
6428	#define LOOKUP_DESTRUCTOR (1 << 5)
6429	/ Do not permit references to bind to temporaries. /
6430	#define LOOKUP_NO_TEMP_BIND (1 << 6)
6431	/ We're inside an init-list, so narrowing conversions are ill-formed. /
6432	#define LOOKUP_NO_NARROWING (LOOKUP_NO_TEMP_BIND << 1)
6433	/ We're looking up a constructor for list-initialization. /
6434	#define LOOKUP_LIST_INIT_CTOR (LOOKUP_NO_NARROWING << 1)
6435	/ This is the first parameter of a copy constructor. /
6436	#define LOOKUP_COPY_PARM (LOOKUP_LIST_INIT_CTOR << 1)
6437	/ We only want to consider list constructors. /
6438	#define LOOKUP_LIST_ONLY (LOOKUP_COPY_PARM << 1)
6439	/ Return after determining which function to call and checking access.*
6440	Used by sythesized_method_walk to determine which functions will
6441	be called to initialize subobjects, in order to determine exception
6442	specification and possible implicit delete.
6443	This is kind of a hack, but exiting early avoids problems with trying
6444	to perform argument conversions when the class isn't complete yet. /*
6445	#define LOOKUP_SPECULATIVE (LOOKUP_LIST_ONLY << 1)
6446	/ Used by calls from defaulted functions to limit the overload set to avoid*
6447	cycles trying to declare them (core issue 1092). /*
6448	#define LOOKUP_DEFAULTED (LOOKUP_SPECULATIVE << 1)
6449	/ Used in calls to store_init_value to suppress its usual call to*
6450	digest_init. /*
6451	#define LOOKUP_ALREADY_DIGESTED (LOOKUP_DEFAULTED << 1)
6452	/ Like LOOKUP_NO_TEMP_BIND, but also prevent binding to xvalues. /
6453	#define LOOKUP_NO_RVAL_BIND (LOOKUP_ALREADY_DIGESTED << 1)
6454	/ Used by case_conversion to disregard non-integral conversions. /
6455	#define LOOKUP_NO_NON_INTEGRAL (LOOKUP_NO_RVAL_BIND << 1)
6456	/ Used for delegating constructors in order to diagnose self-delegation. /
6457	#define LOOKUP_DELEGATING_CONS (LOOKUP_NO_NON_INTEGRAL << 1)
6458	/ Allow initialization of a flexible array members. /
6459	#define LOOKUP_ALLOW_FLEXARRAY_INIT (LOOKUP_DELEGATING_CONS << 1)
6460	/ We're looking for either a rewritten comparison operator candidate or the*
6461	operator to use on the former's result. We distinguish between the two by
6462	knowing that comparisons other than == and <=> must be the latter, as must
6463	a <=> expression trying to rewrite to <=> without reversing. /*
6464	#define LOOKUP_REWRITTEN (LOOKUP_ALLOW_FLEXARRAY_INIT << 1)
6465	/ Reverse the order of the two arguments for comparison rewriting. First we*
6466	swap the arguments in add_operator_candidates, then we swap the conversions
6467	in add_candidate (so that they correspond to the original order of the
6468	args), then we swap the conversions back in build_new_op_1 (so they
6469	correspond to the order of the args in the candidate). /*
6470	#define LOOKUP_REVERSED (LOOKUP_REWRITTEN << 1)
6471	/ We're initializing an aggregate from a parenthesized list of values. /
6472	#define LOOKUP_AGGREGATE_PAREN_INIT (LOOKUP_REVERSED << 1)
6473	/ We're computing conversions as part of a first pass of overload resolution*
6474	wherein we don't try to distinguish an unviable candidate from a
6475	non-strictly viable candidate and thus can avoid computing unnecessary
6476	bad conversions. /*
6477	#define LOOKUP_SHORTCUT_BAD_CONVS (LOOKUP_AGGREGATE_PAREN_INIT << 1)
6478
6479	/ These flags are used by the conversion code.*
6480	CONV_IMPLICIT : Perform implicit conversions (standard and user-defined).
6481	CONV_STATIC : Perform the explicit conversions for static_cast.
6482	CONV_CONST : Perform the explicit conversions for const_cast.
6483	CONV_REINTERPRET: Perform the explicit conversions for reinterpret_cast.
6484	CONV_PRIVATE : Perform upcasts to private bases.
6485	CONV_FORCE_TEMP : Require a new temporary when converting to the same
6486	aggregate type. /*
6487
6488	#define CONV_IMPLICIT 1
6489	#define CONV_STATIC 2
6490	#define CONV_CONST 4
6491	#define CONV_REINTERPRET 8
6492	#define CONV_PRIVATE 16
6493	#define CONV_FORCE_TEMP 32
6494	#define CONV_FOLD 64
6495	#define CONV_OLD_CONVERT (CONV_IMPLICIT \| CONV_STATIC \| CONV_CONST \
6496	\| CONV_REINTERPRET)
6497	#define CONV_C_CAST (CONV_IMPLICIT \| CONV_STATIC \| CONV_CONST \
6498	\| CONV_REINTERPRET \| CONV_PRIVATE \| CONV_FORCE_TEMP)
6499	#define CONV_BACKEND_CONVERT (CONV_OLD_CONVERT \| CONV_FOLD)
6500
6501	/ Used by build_expr_type_conversion to indicate which types are*
6502	acceptable as arguments to the expression under consideration. /*
6503
6504	#define WANT_INT 1 /* integer types, including bool */
6505	#define WANT_FLOAT 2 /* floating point types */
6506	#define WANT_ENUM 4 /* enumerated types */
6507	#define WANT_POINTER 8 /* pointer types */
6508	#define WANT_NULL 16 /* null pointer constant */
6509	#define WANT_VECTOR_OR_COMPLEX 32 /* vector or complex types */
6510	#define WANT_ARITH (WANT_INT \| WANT_FLOAT \| WANT_VECTOR_OR_COMPLEX)
6511
6512	/ Used with comptypes, and related functions, to guide type*
6513	comparison. /*
6514
6515	#define COMPARE_STRICT 0 /* Just check if the types are the
6516	same. */
6517	#define COMPARE_BASE 1 /* Check to see if the second type is
6518	derived from the first. */
6519	#define COMPARE_DERIVED 2 /* Like COMPARE_BASE, but in
6520	reverse. */
6521	#define COMPARE_REDECLARATION 4 /* The comparison is being done when
6522	another declaration of an existing
6523	entity is seen. */
6524	#define COMPARE_STRUCTURAL 8 /* The comparison is intended to be
6525	structural. The actual comparison
6526	will be identical to
6527	COMPARE_STRICT. */
6528
6529	/ Used with start function. /
6530	#define SF_DEFAULT 0 /* No flags. */
6531	#define SF_PRE_PARSED 1 /* The function declaration has
6532	already been parsed. */
6533	#define SF_INCLASS_INLINE 2 /* The function is an inline, defined
6534	in the class body. */
6535
6536	/ Used with start_decl's initialized parameter. /
6537	#define SD_UNINITIALIZED 0
6538	#define SD_INITIALIZED 1
6539	/ Like SD_INITIALIZED, but also mark the new decl as DECL_DECOMPOSITION_P. /
6540	#define SD_DECOMPOSITION 2
6541	#define SD_DEFAULTED 3
6542	#define SD_DELETED 4
6543
6544	/ Returns nonzero iff TYPE1 and TYPE2 are the same type, or if TYPE2*
6545	is derived from TYPE1, or if TYPE2 is a pointer (reference) to a
6546	class derived from the type pointed to (referred to) by TYPE1. /*
6547	#define same_or_base_type_p(TYPE1, TYPE2) \
6548	comptypes ((TYPE1), (TYPE2), COMPARE_BASE)
6549
6550	/ These macros are used to access a TEMPLATE_PARM_INDEX. /
6551	#define TEMPLATE_PARM_INDEX_CAST(NODE) \
6552	((template_parm_index*)TEMPLATE_PARM_INDEX_CHECK (NODE))
6553	#define TEMPLATE_PARM_IDX(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->index)
6554	#define TEMPLATE_PARM_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->level)
6555	#define TEMPLATE_PARM_DESCENDANTS(NODE) (TREE_CHAIN (TEMPLATE_PARM_INDEX_CHECK (NODE)))
6556	#define TEMPLATE_PARM_ORIG_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->orig_level)
6557	#define TEMPLATE_PARM_DECL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->decl)
6558	#define TEMPLATE_PARM_PARAMETER_PACK(NODE) \
6559	(TREE_LANG_FLAG_0 (TEMPLATE_PARM_INDEX_CHECK (NODE)))
6560
6561	/ These macros are for accessing the fields of TEMPLATE_TYPE_PARM,*
6562	TEMPLATE_TEMPLATE_PARM and BOUND_TEMPLATE_TEMPLATE_PARM nodes. /*
6563	#define TEMPLATE_TYPE_PARM_INDEX(NODE) \
6564	(TYPE_VALUES_RAW (TREE_CHECK3 ((NODE), TEMPLATE_TYPE_PARM, \
6565	TEMPLATE_TEMPLATE_PARM, \
6566	BOUND_TEMPLATE_TEMPLATE_PARM)))
6567	#define TEMPLATE_TYPE_IDX(NODE) \
6568	(TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (NODE)))
6569	#define TEMPLATE_TYPE_LEVEL(NODE) \
6570	(TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
6571	#define TEMPLATE_TYPE_ORIG_LEVEL(NODE) \
6572	(TEMPLATE_PARM_ORIG_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
6573	#define TEMPLATE_TYPE_DESCENDANTS(NODE) \
6574	(TEMPLATE_PARM_DESCENDANTS (TEMPLATE_TYPE_PARM_INDEX (NODE)))
6575	#define TEMPLATE_TYPE_DECL(NODE) \
6576	(TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
6577	#define TEMPLATE_TYPE_PARAMETER_PACK(NODE) \
6578	(TEMPLATE_PARM_PARAMETER_PACK (TEMPLATE_TYPE_PARM_INDEX (NODE)))
6579
6580	/ For a C++17 class deduction placeholder, the template it represents. /
6581	#define CLASS_PLACEHOLDER_TEMPLATE(NODE) \
6582	(DECL_INITIAL (TYPE_NAME (TEMPLATE_TYPE_PARM_CHECK (NODE))))
6583
6584	/ True iff the template parameters of this TEMPLATE_TEMPLATE_PARM don't*
6585	use any outer template parameters. /*
6586	#define TEMPLATE_TEMPLATE_PARM_SIMPLE_P(NODE) \
6587	(TYPE_LANG_FLAG_5 (TEMPLATE_TEMPLATE_PARM_CHECK (NODE)))
6588
6589	/ Contexts in which auto deduction occurs. These flags are*
6590	used to control diagnostics in do_auto_deduction. /*
6591
6592	enum auto_deduction_context
6593	{
6594	adc_unspecified, / Not given /
6595	adc_variable_type, / Variable initializer deduction /
6596	adc_return_type, / Return type deduction /
6597	adc_unify, / Template argument deduction /
6598	adc_requirement, / Argument deduction constraint /
6599	adc_decomp_type / Decomposition declaration initializer deduction /
6600	};
6601
6602	/ True iff this TEMPLATE_TYPE_PARM represents decltype(auto). /
6603	#define AUTO_IS_DECLTYPE(NODE) \
6604	(TYPE_LANG_FLAG_5 (TEMPLATE_TYPE_PARM_CHECK (NODE)))
6605
6606	/ These constants can used as bit flags in the process of tree formatting.*
6607
6608	TFF_PLAIN_IDENTIFIER: unqualified part of a name.
6609	TFF_SCOPE: include the class and namespace scope of the name.
6610	TFF_CHASE_TYPEDEF: print the original type-id instead of the typedef-name.
6611	TFF_DECL_SPECIFIERS: print decl-specifiers.
6612	TFF_CLASS_KEY_OR_ENUM: precede a class-type name (resp. enum name) with
6613	a class-key (resp. `enum').
6614	TFF_RETURN_TYPE: include function return type.
6615	TFF_FUNCTION_DEFAULT_ARGUMENTS: include function default parameter values.
6616	TFF_EXCEPTION_SPECIFICATION: show function exception specification.
6617	TFF_TEMPLATE_HEADER: show the template<...> header in a
6618	template-declaration.
6619	TFF_TEMPLATE_NAME: show only template-name.
6620	TFF_EXPR_IN_PARENS: parenthesize expressions.
6621	TFF_NO_FUNCTION_ARGUMENTS: don't show function arguments.
6622	TFF_UNQUALIFIED_NAME: do not print the qualifying scope of the
6623	top-level entity.
6624	TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS: do not omit template arguments
6625	identical to their defaults.
6626	TFF_NO_TEMPLATE_BINDINGS: do not print information about the template
6627	arguments for a function template specialization.
6628	TFF_POINTER: we are printing a pointer type.
6629	TFF_XOBJ_FUNC: we are printing an explicit object member function's
6630	parameters. /*
6631
6632	#define TFF_PLAIN_IDENTIFIER (0)
6633	#define TFF_SCOPE (1)
6634	#define TFF_CHASE_TYPEDEF (1 << 1)
6635	#define TFF_DECL_SPECIFIERS (1 << 2)
6636	#define TFF_CLASS_KEY_OR_ENUM (1 << 3)
6637	#define TFF_RETURN_TYPE (1 << 4)
6638	#define TFF_FUNCTION_DEFAULT_ARGUMENTS (1 << 5)
6639	#define TFF_EXCEPTION_SPECIFICATION (1 << 6)
6640	#define TFF_TEMPLATE_HEADER (1 << 7)
6641	#define TFF_TEMPLATE_NAME (1 << 8)
6642	#define TFF_EXPR_IN_PARENS (1 << 9)
6643	#define TFF_NO_FUNCTION_ARGUMENTS (1 << 10)
6644	#define TFF_UNQUALIFIED_NAME (1 << 11)
6645	#define TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS (1 << 12)
6646	#define TFF_NO_TEMPLATE_BINDINGS (1 << 13)
6647	#define TFF_POINTER (1 << 14)
6648	#define TFF_XOBJ_FUNC (1 << 15)
6649
6650	/ These constants can be used as bit flags to control strip_typedefs.*
6651
6652	STF_USER_VISIBLE: use heuristics to try to avoid stripping user-facing
6653	aliases of internal details. This is intended for diagnostics,
6654	where it should (for example) give more useful "aka" types.
6655
6656	STF_STRIP_DEPENDENT: allow the stripping of aliases with dependent
6657	template parameters, relying on code elsewhere to report any
6658	appropriate diagnostics.
6659
6660	STF_KEEP_INJ_CLASS_NAME: don't strip injected-class-name typedefs
6661	because we're dealing with a non-coerced template argument.
6662	*/
6663	const unsigned int STF_USER_VISIBLE = `1U`;
6664	const unsigned int STF_STRIP_DEPENDENT = `1U` << `1`;
6665	const unsigned int STF_KEEP_INJ_CLASS_NAME = `1U` << `2`;
6666
6667	/ Returns the TEMPLATE_DECL associated to a TEMPLATE_TEMPLATE_PARM*
6668	node. /*
6669	#define TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL(NODE) \
6670	((TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM) \
6671	? TYPE_TI_TEMPLATE (NODE) \
6672	: TYPE_NAME (TEMPLATE_TEMPLATE_PARM_CHECK (NODE)))
6673
6674	/ in lex.cc /
6675
6676	extern void init_reswords (void);
6677
6678	/ Various flags for the overloaded operator information. /
6679	enum ovl_op_flags {
6680	OVL_OP_FLAG_NONE = `0`, / Don't care. /
6681	OVL_OP_FLAG_UNARY = `1`, / Is unary. /
6682	OVL_OP_FLAG_BINARY = `2`, / Is binary. /
6683	OVL_OP_FLAG_AMBIARY = `3`, / May be unary or binary. /
6684	OVL_OP_FLAG_ALLOC = `4`, / operator new or delete. /
6685	OVL_OP_FLAG_DELETE = `1`, / operator delete. /
6686	OVL_OP_FLAG_VEC = `2` / vector new or delete. /
6687	};
6688
6689	/ Compressed operator codes. Order is determined by operators.def*
6690	and does not match that of tree_codes. /*
6691	enum ovl_op_code {
6692	OVL_OP_ERROR_MARK,
6693	OVL_OP_NOP_EXPR,
6694	#define DEF_OPERATOR(NAME, CODE, MANGLING, FLAGS, META) OVL_OP_##CODE,
6695	#define DEF_ASSN_OPERATOR(NAME, CODE, MANGLING, META) /* NOTHING */
6696	#include "operators.def"
6697	OVL_OP_MAX
6698	};
6699
6700	/ Make sure it fits in lang_decl_fn::ovl_op_code. /
6701	STATIC_ASSERT (OVL_OP_MAX < (`1` << `6`));
6702
6703	struct GTY(()) ovl_op_info_t {
6704	/ The IDENTIFIER_NODE for the operator. /
6705	tree identifier;
6706	/ The name of the operator. /
6707	const char *name;
6708	/ The mangled name of the operator. /
6709	const char *mangled_name;
6710	/ The name of the std::meta::operators enumerator without*
6711	the "op_" prefix if any (otherwise NULL). /*
6712	const char *meta_name;
6713	/ The (regular) tree code. /
6714	enum tree_code tree_code : `16`;
6715	/ The (compressed) operator code. /
6716	enum ovl_op_code ovl_op_code : `8`;
6717	/ The ovl_op_flags of the operator /
6718	unsigned flags : `8`;
6719	};
6720
6721	/ Overloaded operator info indexed by ass_op_p & ovl_op_code. /
6722	extern GTY(()) ovl_op_info_t ovl_op_info[`2`][OVL_OP_MAX];
6723	/ Mapping from tree_codes to ovl_op_codes. /
6724	extern GTY(()) unsigned char ovl_op_mapping[MAX_TREE_CODES];
6725	/ Mapping for ambi-ary operators from the binary to the unary. /
6726	extern GTY(()) unsigned char ovl_op_alternate[OVL_OP_MAX];
6727
6728	/ Given an ass_op_p boolean and a tree code, return a pointer to its*
6729	overloaded operator info. Tree codes for non-overloaded operators
6730	map to the error-operator. /*
6731	#define OVL_OP_INFO(IS_ASS_P, TREE_CODE) \
6732	(&ovl_op_info[(IS_ASS_P) != 0][ovl_op_mapping[(TREE_CODE)]])
6733	/ Overloaded operator info for an identifier for which*
6734	IDENTIFIER_OVL_OP_P is true. /*
6735	#define IDENTIFIER_OVL_OP_INFO(NODE) \
6736	(&ovl_op_info[IDENTIFIER_KIND_BIT_0 (NODE)][IDENTIFIER_CP_INDEX (NODE)])
6737	#define IDENTIFIER_OVL_OP_FLAGS(NODE) \
6738	(IDENTIFIER_OVL_OP_INFO (NODE)->flags)
6739
6740	inline tree ovl_op_identifier (bool isass, tree_code code)
6741	{ return OVL_OP_INFO(isass, code)->identifier; }
6742	inline tree ovl_op_identifier (tree_code code) { return ovl_op_identifier (isass: false, code); }
6743	#define assign_op_identifier (ovl_op_info[true][OVL_OP_NOP_EXPR].identifier)
6744	#define call_op_identifier (ovl_op_info[false][OVL_OP_CALL_EXPR].identifier)
6745
6746	/ A type-qualifier, or bitmask therefore, using the TYPE_QUAL*
6747	constants. /*
6748
6749	typedef int cp_cv_quals;
6750
6751	/ Non-static member functions have an optional virt-specifier-seq.*
6752	There is a VIRT_SPEC value for each virt-specifier.
6753	They can be combined by bitwise-or to form the complete set of
6754	virt-specifiers for a member function. /*
6755	enum virt_specifier
6756	{
6757	VIRT_SPEC_UNSPECIFIED = `0x0`,
6758	VIRT_SPEC_FINAL = `0x1`,
6759	VIRT_SPEC_OVERRIDE = `0x2`
6760	};
6761
6762	/ A type-qualifier, or bitmask therefore, using the VIRT_SPEC*
6763	constants. /*
6764
6765	typedef int cp_virt_specifiers;
6766
6767	/ Wherever there is a function-cv-qual, there could also be a ref-qualifier:*
6768
6769	[dcl.fct]
6770	The return type, the parameter-type-list, the ref-qualifier, and
6771	the cv-qualifier-seq, but not the default arguments or the exception
6772	specification, are part of the function type.
6773
6774	REF_QUAL_NONE Ordinary member function with no ref-qualifier
6775	REF_QUAL_LVALUE Member function with the &-ref-qualifier
6776	REF_QUAL_RVALUE Member function with the &&-ref-qualifier /*
6777
6778	enum cp_ref_qualifier {
6779	REF_QUAL_NONE = `0`,
6780	REF_QUAL_LVALUE = `1`,
6781	REF_QUAL_RVALUE = `2`
6782	};
6783
6784	/ A storage class. /
6785
6786	enum cp_storage_class {
6787	/ sc_none must be zero so that zeroing a cp_decl_specifier_seq*
6788	sets the storage_class field to sc_none. /*
6789	sc_none = `0`,
6790	sc_auto,
6791	sc_register,
6792	sc_static,
6793	sc_extern,
6794	sc_mutable
6795	};
6796
6797	/ An individual decl-specifier. This is used to index the array of*
6798	locations for the declspecs in struct cp_decl_specifier_seq
6799	below.
6800	A subset of these enums also corresponds to elements of
6801	cp_parser_set_decl_spec_type:decl_spec_names in parser.cc. /*
6802
6803	enum cp_decl_spec {
6804	ds_first,
6805	ds_signed = ds_first, / Index of first element of decl_spec_names. /
6806	ds_unsigned,
6807	ds_short,
6808	ds_long,
6809	ds_const,
6810	ds_volatile,
6811	ds_restrict,
6812	ds_inline,
6813	ds_virtual,
6814	ds_explicit,
6815	ds_friend,
6816	ds_typedef,
6817	ds_alias,
6818	ds_constexpr,
6819	ds_complex,
6820	ds_constinit,
6821	ds_consteval,
6822	ds_this, / Index of last element of decl_spec_names. /
6823	ds_thread,
6824	ds_type_spec,
6825	ds_redefined_builtin_type_spec,
6826	ds_attribute,
6827	ds_std_attribute,
6828	ds_storage_class,
6829	ds_long_long,
6830	ds_concept,
6831	ds_last / This enumerator must always be the last one. /
6832	};
6833
6834	/ A decl-specifier-seq. /
6835
6836	struct cp_decl_specifier_seq {
6837	/ An array of locations for the declaration sepecifiers, indexed by*
6838	enum cp_decl_spec_word. /*
6839	location_t locations[ds_last];
6840	/ The primary type, if any, given by the decl-specifier-seq.*
6841	Modifiers, like "short", "const", and "unsigned" are not
6842	reflected here. This field will be a TYPE, unless a typedef-name
6843	was used, in which case it will be a TYPE_DECL. /*
6844	tree type;
6845	/ The attributes, if any, provided with the specifier sequence. /
6846	tree attributes;
6847	/ The c++11 attributes that follows the type specifier. /
6848	tree std_attributes;
6849	/ If non-NULL, a built-in type that the user attempted to redefine*
6850	to some other type. /*
6851	tree redefined_builtin_type;
6852	/ The explicit-specifier, if any. /
6853	tree explicit_specifier;
6854	/ The storage class specified -- or sc_none if no storage class was*
6855	explicitly specified. /*
6856	cp_storage_class storage_class;
6857	/ For the __intN declspec, this stores the index into the int_n_* arrays. /
6858	int int_n_idx;
6859	/ True iff TYPE_SPEC defines a class or enum. /
6860	BOOL_BITFIELD type_definition_p : `1`;
6861	/ True iff multiple types were (erroneously) specified for this*
6862	decl-specifier-seq. /*
6863	BOOL_BITFIELD multiple_types_p : `1`;
6864	/ True iff multiple storage classes were (erroneously) specified*
6865	for this decl-specifier-seq or a combination of a storage class
6866	with a typedef specifier. /*
6867	BOOL_BITFIELD conflicting_specifiers_p : `1`;
6868	/ True iff at least one decl-specifier was found. /
6869	BOOL_BITFIELD any_specifiers_p : `1`;
6870	/ True iff at least one type-specifier was found. /
6871	BOOL_BITFIELD any_type_specifiers_p : `1`;
6872	/ True iff "int" was explicitly provided. /
6873	BOOL_BITFIELD explicit_int_p : `1`;
6874	/ True iff "__intN" was explicitly provided. /
6875	BOOL_BITFIELD explicit_intN_p : `1`;
6876	/ True iff "char" was explicitly provided. /
6877	BOOL_BITFIELD explicit_char_p : `1`;
6878	/ True iff ds_thread is set for __thread, not thread_local. /
6879	BOOL_BITFIELD gnu_thread_keyword_p : `1`;
6880	/ True iff the type is a decltype. /
6881	BOOL_BITFIELD decltype_p : `1`;
6882	/ True iff the alternate "__intN__" form of the __intN type has been*
6883	used. /*
6884	BOOL_BITFIELD int_n_alt: `1`;
6885	};
6886
6887	/ The various kinds of declarators. /
6888
6889	enum cp_declarator_kind {
6890	cdk_id,
6891	cdk_function,
6892	cdk_array,
6893	cdk_pointer,
6894	cdk_reference,
6895	cdk_ptrmem,
6896	cdk_decomp,
6897	cdk_error
6898	};
6899
6900	/ A declarator. /
6901
6902	typedef struct cp_declarator cp_declarator;
6903
6904	typedef struct cp_parameter_declarator cp_parameter_declarator;
6905
6906	/ A parameter, before it has been semantically analyzed. /
6907	struct cp_parameter_declarator {
6908	/ The next parameter, or NULL_TREE if none. /
6909	cp_parameter_declarator *next;
6910	/ The decl-specifiers-seq for the parameter. /
6911	cp_decl_specifier_seq decl_specifiers;
6912	/ The declarator for the parameter. /
6913	cp_declarator *declarator;
6914	/ The default-argument expression, or NULL_TREE, if none. /
6915	tree default_argument;
6916	/ True iff this is a template parameter pack. /
6917	bool template_parameter_pack_p;
6918	/ Location within source. /
6919	location_t loc;
6920	};
6921
6922	/ A declarator. /
6923	struct cp_declarator {
6924	/ The kind of declarator. /
6925	ENUM_BITFIELD (cp_declarator_kind) kind : `4`;
6926	/ Whether we parsed an ellipsis (`...') just before the declarator,*
6927	to indicate this is a parameter pack. /*
6928	BOOL_BITFIELD parameter_pack_p : `1`;
6929	/ If this declarator is parenthesized, this the open-paren. It is*
6930	UNKNOWN_LOCATION when not parenthesized. /*
6931	location_t parenthesized;
6932	/ Currently only set for cdk_id, cdk_decomp and cdk_function. /
6933	location_t id_loc;
6934	/ If this declarator is part of an init-declarator, the location of the*
6935	initializer. /*
6936	location_t init_loc;
6937	/ GNU Attributes that apply to this declarator. If the declarator*
6938	is a pointer or a reference, these attribute apply to the type
6939	pointed to. /*
6940	tree attributes;
6941	/ Standard C++11 attributes that apply to this declarator. If the*
6942	declarator is a pointer or a reference, these attributes apply
6943	to the pointer, rather than to the type pointed to. /*
6944	tree std_attributes;
6945	/ For all but cdk_id, cdk_decomp and cdk_error, the contained declarator.*
6946	For cdk_id, cdk_decomp and cdk_error, guaranteed to be NULL. /*
6947	cp_declarator *declarator;
6948	union {
6949	/ For identifiers. /
6950	struct {
6951	/ If non-NULL, the qualifying scope (a NAMESPACE_DECL or*
6952	_TYPE) for this identifier. /
6953	tree qualifying_scope;
6954	/ The unqualified name of the entity -- an IDENTIFIER_NODE,*
6955	BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. /*
6956	tree unqualified_name;
6957	/ If this is the name of a function, what kind of special*
6958	function (if any). /*
6959	special_function_kind sfk;
6960	} id;
6961	/ For functions. /
6962	struct {
6963	/ The parameters to the function as a TREE_LIST of decl/default. /
6964	tree parameters;
6965	/ The cv-qualifiers for the function. /
6966	cp_cv_quals qualifiers;
6967	/ The virt-specifiers for the function. /
6968	cp_virt_specifiers virt_specifiers;
6969	/ The ref-qualifier for the function. /
6970	cp_ref_qualifier ref_qualifier;
6971	/ The transaction-safety qualifier for the function. /
6972	tree tx_qualifier;
6973	/ The exception-specification for the function. /
6974	tree exception_specification;
6975	/ The late-specified return type, if any. /
6976	tree late_return_type;
6977	/ The trailing requires-clause, if any. /
6978	tree requires_clause;
6979	/ The function-contract-specifier-seq, if any. /
6980	tree contract_specifiers;
6981	/ The position of the opening brace for a function definition. /
6982	location_t parens_loc;
6983	} function;
6984	/ For arrays. /
6985	struct {
6986	/ The bounds to the array. /
6987	tree bounds;
6988	} array;
6989	/ For cdk_pointer and cdk_ptrmem. /
6990	struct {
6991	/ The cv-qualifiers for the pointer. /
6992	cp_cv_quals qualifiers;
6993	/ For cdk_ptrmem, the class type containing the member. /
6994	tree class_type;
6995	} pointer;
6996	/ For cdk_reference /
6997	struct {
6998	/ The cv-qualifiers for the reference. These qualifiers are*
6999	only used to diagnose ill-formed code. /*
7000	cp_cv_quals qualifiers;
7001	/ Whether this is an rvalue reference /
7002	bool rvalue_ref;
7003	} reference;
7004	} u;
7005	};
7006
7007	/ A level of template instantiation. /
7008	struct GTY((chain_next ("%h.next"))) tinst_level {
7009	/ The immediately deeper level in the chain. /
7010	struct tinst_level *next;
7011
7012	/ The original node. TLDCL can be a DECL (for a function or static*
7013	data member), a TYPE (for a class), depending on what we were
7014	asked to instantiate, a TEMPLATE_FOR_STMT (for instantiation
7015	of expansion stmt body outside of templates) or a TREE_LIST with
7016	the template as PURPOSE and the template args as VALUE, if we are
7017	substituting for overload resolution. In all these cases, TARGS
7018	is NULL.
7019	However, to avoid creating TREE_LIST objects for substitutions if
7020	we can help, we store PURPOSE and VALUE in TLDCL and TARGS,
7021	respectively. So TLDCL stands for TREE_LIST or DECL (the
7022	template is a DECL too), whereas TARGS stands for the template
7023	arguments. /*
7024	tree tldcl, targs;
7025
7026	/ For modules we need to know (a) the modules on the path of*
7027	instantiation and (b) the transitive imports along that path.
7028	Note that these two bitmaps may be inherited from NEXT, if this
7029	decl is in the same module as NEXT (or has no new information). /*
7030	bitmap path;
7031	bitmap visible;
7032
7033	private:
7034	/ Return TRUE iff the original node is a split list. /
7035	bool split_list_p () const { return targs; }
7036
7037	/ Return TRUE iff the original node is a TREE_LIST object. /
7038	bool tree_list_p () const
7039	{
7040	return !split_list_p () && TREE_CODE (tldcl) == TREE_LIST;
7041	}
7042
7043	/ Return TRUE iff the original node is not a list, split or not. /
7044	bool not_list_p () const
7045	{
7046	return !split_list_p () && !tree_list_p ();
7047	}
7048
7049	/ Convert (in place) the original node from a split list to a*
7050	TREE_LIST. /*
7051	tree to_list ();
7052
7053	public:
7054	/ Release storage for OBJ and node, if it's a TREE_LIST. /
7055	static void free (tinst_level *obj);
7056
7057	/ Return TRUE iff the original node is a list, split or not. /
7058	bool list_p () const { return !not_list_p (); }
7059
7060	/ Return the original node; if it's a split list, make it a*
7061	TREE_LIST first, so that it can be returned as a single tree
7062	object. /*
7063	tree get_node () {
7064	if (!split_list_p ()) return tldcl;
7065	else return to_list ();
7066	}
7067
7068	/ Return the original node if it's a DECL or a TREE_LIST, but do*
7069	NOT convert a split list to a TREE_LIST: return NULL instead. /*
7070	tree maybe_get_node () const {
7071	if (!split_list_p ()) return tldcl;
7072	else return NULL_TREE;
7073	}
7074
7075	/ The location where the template is instantiated. /
7076	location_t locus;
7077
7078	/ errorcount + sorrycount when we pushed this level. If the value*
7079	overflows, it will always seem like we currently have more errors, so we
7080	will limit template recursion even from non-erroneous templates. In a TU
7081	with over 32k errors, that's fine. /*
7082	unsigned short errors : `15`;
7083
7084	/ set in pop_tinst_level if there have been errors since we pushed. /
7085	bool had_errors : `1`;
7086
7087	/ Count references to this object. If refcount reaches*
7088	refcount_infinity value, we don't increment or decrement the
7089	refcount anymore, as the refcount isn't accurate anymore.
7090	The object can be still garbage collected if unreferenced from
7091	anywhere, which might keep referenced objects referenced longer than
7092	otherwise necessary. Hitting the infinity is rare though. /*
7093	unsigned short refcount;
7094
7095	/ Infinity value for the above refcount. /
7096	static const unsigned short refcount_infinity = (unsigned short) ~`0`;
7097	};
7098
7099	/ BUILT_IN_FRONTEND function codes. /
7100	enum cp_built_in_function {
7101	CP_BUILT_IN_IS_CONSTANT_EVALUATED,
7102	CP_BUILT_IN_INTEGER_PACK,
7103	CP_BUILT_IN_IS_CORRESPONDING_MEMBER,
7104	CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS,
7105	CP_BUILT_IN_SOURCE_LOCATION,
7106	CP_BUILT_IN_EH_PTR_ADJUST_REF,
7107	CP_BUILT_IN_IS_STRING_LITERAL,
7108	CP_BUILT_IN_LAST
7109	};
7110
7111	bool decl_spec_seq_has_spec_p (const cp_decl_specifier_seq *, cp_decl_spec);
7112
7113	/ Return the type of the `this' parameter of FNTYPE. /
7114
7115	inline tree
7116	type_of_this_parm (const_tree fntype)
7117	{
7118	function_args_iterator iter;
7119	gcc_assert (TREE_CODE (fntype) == METHOD_TYPE);
7120	function_args_iter_init (i: &iter, fntype);
7121	return function_args_iter_cond (i: &iter);
7122	}
7123
7124	/ Return the class of the `this' parameter of FNTYPE. /
7125
7126	inline tree
7127	class_of_this_parm (const_tree fntype)
7128	{
7129	return TREE_TYPE (type_of_this_parm (fntype));
7130	}
7131
7132	/ A parameter list indicating for a function with no parameters,*
7133	e.g "int f(void)". /*
7134	extern cp_parameter_declarator *no_parameters;
7135
7136	/ Various dump ids. /
7137	extern int class_dump_id;
7138	extern int module_dump_id;
7139	extern int raw_dump_id;
7140	extern int coro_dump_id;
7141	extern int tinst_dump_id;
7142
7143	/ Whether the current context is manifestly constant-evaluated.*
7144	Used by the constexpr machinery to control folding of
7145	__builtin_is_constant_evaluated. /*
7146
7147	enum class mce_value
7148	{
7149	/ Unknown, so treat __builtin_is_constant_evaluated as non-constant. /
7150	mce_unknown = `0`,
7151	/ Fold it to true. /
7152	mce_true = `1`,
7153	/ Fold it to false. Primarily used during cp_fold_function and*
7154	cp_fully_fold_init. /*
7155	mce_false = -`1`,
7156	};
7157	constexpr mce_value mce_unknown = mce_value::mce_unknown;
7158	constexpr mce_value mce_true = mce_value::mce_true;
7159	constexpr mce_value mce_false = mce_value::mce_false;
7160
7161	/ in call.cc /
7162	extern bool check_dtor_name (tree, tree);
7163	int magic_varargs_p (tree);
7164
7165	extern tree build_conditional_expr (const op_location_t &,
7166	tree, tree, tree,
7167	tsubst_flags_t);
7168	extern tree build_addr_func (tree, tsubst_flags_t);
7169	extern void set_flags_from_callee (tree);
7170	extern tree build_call_a (tree, int, tree*);
7171	extern tree build_call_n (tree, int, ...);
7172	extern bool null_ptr_cst_p (tree);
7173	extern bool null_member_pointer_value_p (tree);
7174	extern bool sufficient_parms_p (const_tree);
7175	extern tree type_decays_to (tree);
7176	extern tree extract_call_expr (tree);
7177	extern tree build_trivial_dtor_call (tree, bool = false);
7178	extern tristate ref_conv_binds_to_temporary (tree, tree, bool = false);
7179	extern unsigned HOST_WIDE_INT count_ctor_elements (tree);
7180	extern tree build_user_type_conversion (tree, tree, int,
7181	tsubst_flags_t);
7182	extern tree build_new_function_call (tree, vec<tree, va_gc> **,
7183	tsubst_flags_t);
7184	extern tree build_operator_new_call (tree, vec<tree, va_gc> **,
7185	tree , tree , tree, tree,
7186	tree *, tsubst_flags_t);
7187	extern tree build_new_method_call (tree, tree,
7188	vec<tree, va_gc> **, tree,
7189	int, tree *, tsubst_flags_t);
7190	extern tree build_special_member_call (tree, tree,
7191	vec<tree, va_gc> **,
7192	tree, int, tsubst_flags_t);
7193	extern tree build_new_op (const op_location_t &,
7194	enum tree_code,
7195	int, tree, tree, tree, tree,
7196	tree *, tsubst_flags_t);
7197	/ Wrapper that leaves out the usually-null op3 and overload parms. /
7198	inline tree build_new_op (const op_location_t &loc, enum tree_code code,
7199	int flags, tree arg1, tree arg2,
7200	tsubst_flags_t complain)
7201	{
7202	return build_new_op (loc, code, flags, arg1, arg2, NULL_TREE, NULL_TREE,
7203	NULL, complain);
7204	}
7205	extern tree keep_unused_object_arg (tree, tree, tree);
7206	extern tree build_op_call (tree, vec<tree, va_gc> **,
7207	tsubst_flags_t);
7208	extern tree build_op_subscript (const op_location_t &, tree,
7209	vec<tree, va_gc> *, tree ,
7210	tsubst_flags_t);
7211	extern bool aligned_allocation_fn_p (tree);
7212	extern tree destroying_delete_p (tree);
7213	extern bool usual_deallocation_fn_p (tree);
7214	extern tree build_op_delete_call (enum tree_code, tree, tree,
7215	bool, tree, tree,
7216	tsubst_flags_t);
7217	extern tree build_coroutine_op_delete_call (enum tree_code, tree, tree,
7218	bool, tree, tree,
7219	tsubst_flags_t complain);
7220	extern bool can_convert (tree, tree, tsubst_flags_t);
7221	extern bool can_convert_standard (tree, tree, tsubst_flags_t);
7222	extern bool can_convert_arg (tree, tree, tree, int,
7223	tsubst_flags_t);
7224	extern bool can_convert_arg_bad (tree, tree, tree, int,
7225	tsubst_flags_t);
7226	extern int conv_flags (int, int, tree, tree, int);
7227	extern struct conversion * good_conversion (tree, tree, tree, int, tsubst_flags_t);
7228	extern location_t get_fndecl_argument_location (tree, int);
7229	extern void complain_about_bad_argument (location_t arg_loc,
7230	tree from_type, tree to_type,
7231	tree fndecl, int parmnum);
7232	extern void maybe_inform_about_fndecl_for_bogus_argument_init (tree, int,
7233	const char * = nullptr);
7234	extern tree perform_dguide_overload_resolution (tree, const vec<tree, va_gc> *,
7235	tsubst_flags_t);
7236
7237
7238	/ A class for recording information about access failures (e.g. private*
7239	fields), so that we can potentially supply a fix-it hint about
7240	an accessor (from a context in which the constness of the object
7241	is known). /*
7242
7243	class access_failure_info
7244	{
7245	public:
7246	access_failure_info () : m_was_inaccessible (false),
7247	m_basetype_path (NULL_TREE),
7248	m_decl (NULL_TREE), m_diag_decl (NULL_TREE) {}
7249
7250	void record_access_failure (tree basetype_path, tree decl, tree diag_decl);
7251
7252	bool was_inaccessible_p () const { return m_was_inaccessible; }
7253	tree get_decl () const { return m_decl; }
7254	tree get_diag_decl () const { return m_diag_decl; }
7255	tree get_any_accessor (bool const_p) const;
7256	void maybe_suggest_accessor (bool const_p) const;
7257	static void add_fixit_hint (rich_location *richloc, tree accessor);
7258
7259	private:
7260	bool m_was_inaccessible;
7261	tree m_basetype_path;
7262	tree m_decl;
7263	tree m_diag_decl;
7264	};
7265
7266	extern void complain_about_access (tree, tree, tree, bool,
7267	access_kind);
7268	extern void push_defarg_context (tree);
7269	extern void pop_defarg_context (void);
7270	extern tree convert_default_arg (tree, tree, tree, int,
7271	tsubst_flags_t);
7272	extern tree convert_arg_to_ellipsis (tree, tsubst_flags_t);
7273	extern tree build_x_va_arg (location_t, tree, tree);
7274	extern tree cxx_type_promotes_to (tree);
7275	extern tree type_passed_as (tree);
7276	extern tree convert_for_arg_passing (tree, tree, tsubst_flags_t);
7277	extern bool is_properly_derived_from (tree, tree);
7278	extern tree initialize_reference (tree, tree, int,
7279	tsubst_flags_t);
7280	extern tree extend_ref_init_temps (tree, tree,
7281	vec<tree, va_gc>**,
7282	tree * = NULL);
7283	extern tree make_temporary_var_for_ref_to_temp (tree, tree);
7284	extern bool type_has_extended_temps (tree);
7285	extern tree strip_top_quals (tree);
7286	extern bool reference_related_p (tree, tree);
7287	extern bool reference_compatible_p (tree, tree);
7288	extern bool handler_match_for_exception_type (tree, tree);
7289	extern int remaining_arguments (tree);
7290	extern tree build_implicit_conv_flags (tree, tree, int);
7291	extern tree perform_implicit_conversion (tree, tree, tsubst_flags_t);
7292	extern tree perform_implicit_conversion_flags (tree, tree, tsubst_flags_t, int);
7293	extern tree build_converted_constant_expr (tree, tree, tsubst_flags_t);
7294	extern tree build_converted_constant_bool_expr (tree, tsubst_flags_t);
7295	extern tree perform_direct_initialization_if_possible (tree, tree, bool,
7296	tsubst_flags_t);
7297	extern vec<tree,va_gc> resolve_args (vec<tree,va_gc>, tsubst_flags_t);
7298	extern tree in_charge_arg_for_name (tree);
7299	extern bool in_immediate_context ();
7300	extern bool immediate_invocation_p (tree);
7301	extern tree build_cxx_call (tree, int, tree *,
7302	tsubst_flags_t,
7303	tree = NULL_TREE);
7304	extern bool is_std_init_list (tree);
7305	extern bool is_list_ctor (tree);
7306	extern void validate_conversion_obstack (void);
7307	extern void mark_versions_used (tree);
7308	extern int unsafe_return_slot_p (tree);
7309	extern bool unsafe_copy_elision_p (tree, tree);
7310	extern bool make_safe_copy_elision (tree, tree);
7311	extern bool cp_handle_deprecated_or_unavailable (tree, tsubst_flags_t = tf_warning_or_error);
7312	extern void cp_warn_deprecated_use_scopes (tree);
7313	extern tree get_function_version_dispatcher (tree);
7314	extern bool any_template_arguments_need_structural_equality_p (tree);
7315	extern void maybe_show_nonconverting_candidate (tree, tree, tree, int);
7316	extern bool conv_binds_to_reference_parm_p (tree, tree);
7317
7318	/ in class.cc /
7319	extern tree build_vfield_ref (tree, tree);
7320	extern tree build_if_in_charge (tree true_stmt, tree false_stmt = void_node);
7321	extern tree build_base_path (enum tree_code, tree,
7322	tree, int, tsubst_flags_t);
7323	extern tree convert_to_base (tree, tree, bool, bool,
7324	tsubst_flags_t);
7325	extern tree convert_to_base_statically (tree, tree);
7326	extern bool is_empty_base_ref (tree);
7327	extern tree build_vtbl_ref (tree, tree);
7328	extern tree build_vfn_ref (tree, tree);
7329	extern tree get_vtable_decl (tree, int);
7330	extern bool object_parms_correspond (tree, tree, tree);
7331	extern bool iobj_parm_corresponds_to (tree, tree, tree);
7332	extern bool add_method (tree, tree, bool);
7333	extern tree declared_access (tree);
7334	extern bool maybe_push_used_methods (tree);
7335	extern tree currently_open_class (tree);
7336	extern tree currently_open_derived_class (tree);
7337	extern tree outermost_open_class (void);
7338	extern tree current_nonlambda_class_type (void);
7339	extern tree finish_struct (tree, tree);
7340	extern void finish_struct_1 (tree);
7341	extern int resolves_to_fixed_type_p (tree, int * = NULL);
7342	extern void init_class_processing (void);
7343	extern int is_empty_class (tree);
7344	extern bool is_really_empty_class (tree, bool);
7345	extern void pushclass (tree);
7346	extern void popclass (void);
7347	extern void push_nested_class (tree);
7348	extern void pop_nested_class (void);
7349	extern int current_lang_depth (void);
7350	extern void push_lang_context (tree);
7351	extern void pop_lang_context (void);
7352	extern tree instantiate_type (tree, tree, tsubst_flags_t);
7353	extern void build_self_reference (void);
7354	extern int same_signature_p (const_tree, const_tree);
7355	extern tree lookup_vfn_in_binfo (tree, tree);
7356	extern void maybe_add_class_template_decl_list (tree, tree, int);
7357	extern void unreverse_member_declarations (tree);
7358	extern bool is_empty_field (tree);
7359	extern void invalidate_class_lookup_cache (void);
7360	extern void maybe_note_name_used_in_class (tree, tree);
7361	extern void note_name_declared_in_class (tree, tree);
7362	extern tree get_vtbl_decl_for_binfo (tree);
7363	extern bool vptr_via_virtual_p (tree);
7364	extern void debug_class (tree);
7365	extern void debug_thunks (tree);
7366	extern void set_linkage_according_to_type (tree, tree);
7367	extern void determine_key_method (tree);
7368	extern void check_for_override (tree, tree);
7369	extern void push_class_stack (void);
7370	extern void pop_class_stack (void);
7371	extern bool default_ctor_p (const_tree);
7372	extern bool type_has_user_nondefault_constructor (tree);
7373	extern tree in_class_defaulted_default_constructor (tree);
7374	extern bool user_provided_p (tree);
7375	extern bool type_has_user_provided_constructor (tree);
7376	extern bool type_has_non_user_provided_default_constructor (tree);
7377	extern bool type_has_converting_constructor (tree);
7378	extern bool vbase_has_user_provided_move_assign (tree);
7379	extern tree default_init_uninitialized_part (tree);
7380	extern bool trivial_default_constructor_is_constexpr (tree);
7381	extern bool type_has_constexpr_default_constructor (tree);
7382	extern bool type_has_constexpr_destructor (tree);
7383	extern bool type_has_virtual_destructor (tree);
7384	extern bool type_has_non_deleted_trivial_default_ctor (tree);
7385	extern bool classtype_has_move_assign_or_move_ctor_p (tree, bool user_declared);
7386	extern bool classtype_has_non_deleted_move_ctor (tree);
7387	extern tree classtype_has_depr_implicit_copy (tree);
7388	extern bool classtype_has_op (tree, tree_code);
7389	extern tree classtype_has_defaulted_op (tree, tree_code);
7390	extern bool type_build_ctor_call (tree);
7391	extern bool type_build_dtor_call (tree);
7392	extern void explain_non_literal_class (tree);
7393	extern void inherit_targ_abi_tags (tree);
7394	extern void defaulted_late_check (tree, tristate = tristate::unknown ());
7395	extern bool defaultable_fn_check (tree);
7396	extern void check_abi_tags (tree);
7397	extern tree missing_abi_tags (tree);
7398	extern void fixup_type_variants (tree);
7399	extern void fixup_attribute_variants (tree);
7400	extern void build_cdtor_clones (tree, bool, bool, bool);
7401	extern void clone_cdtor (tree, bool);
7402	extern tree copy_operator_fn (tree, tree_code code);
7403	extern void adjust_clone_args (tree);
7404	extern void deduce_noexcept_on_destructor (tree);
7405	extern bool uniquely_derived_from_p (tree, tree);
7406	extern bool publicly_uniquely_derived_p (tree, tree);
7407	extern bool publicly_virtually_derived_p (tree, tree);
7408	extern tree common_enclosing_class (tree, tree);
7409
7410	/ in cvt.cc /
7411	extern tree convert_to_reference (tree, tree, int, int, tree,
7412	tsubst_flags_t);
7413	extern tree convert_from_reference (tree);
7414	extern tree force_rvalue (tree, tsubst_flags_t);
7415	extern tree force_lvalue (tree, tsubst_flags_t);
7416	extern tree ocp_convert (tree, tree, int, int,
7417	tsubst_flags_t);
7418	extern tree cp_convert (tree, tree, tsubst_flags_t);
7419	extern tree cp_convert_and_check (tree, tree, tsubst_flags_t);
7420	extern tree cp_fold_convert (tree, tree);
7421	extern tree cp_get_callee (tree);
7422	extern tree cp_get_callee_fndecl (tree);
7423	extern tree cp_get_callee_fndecl_nofold (tree);
7424	extern tree cp_get_fndecl_from_callee (tree, bool fold = true);
7425	extern tree convert_to_void (tree, impl_conv_void,
7426	tsubst_flags_t);
7427	extern tree convert_force (tree, tree, int,
7428	tsubst_flags_t);
7429	extern tree build_expr_type_conversion (int, tree, bool);
7430	extern tree type_promotes_to (tree);
7431	extern bool can_convert_qual (tree, tree);
7432	extern tree perform_qualification_conversions (tree, tree);
7433	extern bool tx_safe_fn_type_p (tree);
7434	extern tree tx_unsafe_fn_variant (tree);
7435	extern bool fnptr_conv_p (tree, tree);
7436	extern tree strip_fnptr_conv (tree);
7437
7438	/ in name-lookup.cc /
7439	extern void maybe_push_cleanup_level (tree);
7440	extern tree maybe_push_decl (tree);
7441	extern tree current_decl_namespace (void);
7442
7443	/ decl.cc /
7444	extern tree poplevel (int, int, int);
7445	extern void cxx_init_decl_processing (void);
7446	enum cp_tree_node_structure_enum cp_tree_node_structure
7447	(union lang_tree_node *);
7448	extern void finish_scope (void);
7449	extern void push_switch (tree);
7450	extern void pop_switch (void);
7451	extern void note_break_stmt (void);
7452	extern bool note_iteration_stmt_body_start (void);
7453	extern void note_iteration_stmt_body_end (bool);
7454	extern void determine_local_discriminator (tree, tree = NULL_TREE);
7455	extern bool member_like_constrained_friend_p (tree);
7456	extern bool fns_correspond (tree, tree);
7457	extern int decls_match (tree, tree, bool = true);
7458	extern bool maybe_version_functions (tree, tree);
7459	extern bool validate_constexpr_redeclaration (tree, tree);
7460	extern bool merge_default_template_args (tree, tree, bool);
7461	extern void merge_decl_arguments (tree, tree, bool, bool, bool);
7462	extern tree duplicate_decls (tree, tree,
7463	bool hiding = false,
7464	bool was_hidden = false);
7465	extern void mark_label_addressed (tree);
7466	extern tree declare_local_label (tree);
7467	extern tree define_label (location_t, tree);
7468	extern void check_goto (tree *);
7469	extern bool check_omp_return (void);
7470	extern tree make_typename_type (tree, tree, enum tag_types, tsubst_flags_t);
7471	extern tree build_typename_type (tree, tree, tree, tag_types);
7472	extern tree make_unbound_class_template (tree, tree, tree, tsubst_flags_t);
7473	extern tree make_unbound_class_template_raw (tree, tree, tree);
7474	extern unsigned push_abi_namespace (tree node = abi_node);
7475	extern void pop_abi_namespace (unsigned flags,
7476	tree node = abi_node);
7477	extern tree build_library_fn_ptr (const char , tree, int*);
7478	extern tree build_cp_library_fn_ptr (const char , tree, int*);
7479	extern tree push_library_fn (tree, tree, tree, int);
7480	extern tree push_throw_library_fn (tree, tree);
7481	extern void warn_misplaced_attr_for_class_type (location_t location,
7482	tree class_type);
7483	extern tree check_tag_decl (cp_decl_specifier_seq , bool*);
7484	extern tree shadow_tag (cp_decl_specifier_seq *);
7485	extern tree groktypename (cp_decl_specifier_seq , const* cp_declarator , bool*);
7486	extern tree start_decl (const cp_declarator , cp_decl_specifier_seq , int, tree, tree, tree *);
7487	extern void start_decl_1 (tree, bool);
7488	extern bool check_array_initializer (tree, tree, tree);
7489	extern void omp_declare_variant_finalize (tree, tree);
7490	struct cp_decomp { tree decl; unsigned int count; };
7491	extern void cp_finish_decl (tree, tree, bool, tree, int, cp_decomp * = nullptr);
7492	extern tree lookup_decomp_type (tree);
7493	HOST_WIDE_INT cp_decomp_size (location_t, tree, tsubst_flags_t);
7494	extern bool cp_finish_decomp (tree, cp_decomp , bool* = false);
7495	extern int cp_complete_array_type (tree , tree, bool*);
7496	extern int cp_complete_array_type_or_error (tree , tree, bool*, tsubst_flags_t);
7497	extern tree build_ptrmemfunc_type (tree);
7498	extern tree build_ptrmem_type (tree, tree);
7499	/ the grokdeclarator prototype is in decl.h /
7500	extern tree build_this_parm (tree, tree, cp_cv_quals);
7501	extern tree grokparms (tree, tree *);
7502	extern int copy_fn_p (const_tree);
7503	extern bool move_fn_p (const_tree);
7504	extern bool move_signature_fn_p (const_tree);
7505	extern tree get_scope_of_declarator (const cp_declarator *);
7506	extern void grok_special_member_properties (tree);
7507	extern bool grok_ctor_properties (const_tree, const_tree);
7508	extern bool grok_op_properties (tree, bool);
7509	extern tree xref_tag (tag_types, tree,
7510	TAG_how = TAG_how::CURRENT_ONLY,
7511	bool tpl_header_p = false);
7512	extern void xref_basetypes (tree, tree);
7513	extern tree start_enum (tree, tree, tree, tree, bool, bool *);
7514	extern bool enum_with_enumerator_for_linkage_p (tree);
7515	extern void finish_enum_value_list (tree);
7516	extern void finish_enum (tree);
7517	extern tree build_enumerator (tree, tree, tree, tree, location_t);
7518	extern tree lookup_enumerator (tree, tree);
7519	extern bool start_preparsed_function (tree, tree, int);
7520	extern bool start_function (cp_decl_specifier_seq *,
7521	const cp_declarator *, tree);
7522	extern tree maybe_prepare_return_this (tree);
7523	extern void maybe_return_this (void);
7524	extern tree begin_function_body (void);
7525	extern void finish_function_body (tree);
7526	extern tree outer_curly_brace_block (tree);
7527	extern tree finish_function (bool);
7528	extern tree grokmethod (cp_decl_specifier_seq , const* cp_declarator *, tree);
7529	extern void maybe_register_incomplete_var (tree);
7530	extern void maybe_commonize_var (tree);
7531	extern void complete_vars (tree);
7532	extern tree static_fn_type (tree);
7533	extern void revert_static_member_fn (tree);
7534	extern void fixup_anonymous_aggr (tree);
7535	extern tree compute_array_index_type (tree, tree, tsubst_flags_t);
7536	extern tree check_default_argument (tree, tree, tsubst_flags_t);
7537	extern int wrapup_namespace_globals ();
7538	extern tree create_implicit_typedef (tree, tree);
7539	extern int local_variable_p (const_tree);
7540	extern tree get_cxa_atexit_fn_ptr_type ();
7541	extern tree register_dtor_fn (tree, bool = false);
7542	extern tmpl_spec_kind current_tmpl_spec_kind (int);
7543	extern tree cxx_builtin_function (tree decl);
7544	extern tree cxx_builtin_function_ext_scope (tree decl);
7545	extern tree cxx_simulate_builtin_function_decl (tree);
7546	extern tree check_elaborated_type_specifier (enum tag_types, tree, bool);
7547	extern void warn_extern_redeclared_static (tree, tree);
7548	extern tree cxx_comdat_group (tree);
7549	extern bool cp_missing_noreturn_ok_p (tree);
7550	extern bool is_direct_enum_init (tree, tree);
7551	extern void initialize_artificial_var (tree, vec<constructor_elt, va_gc> *);
7552	extern tree check_var_type (tree, tree, location_t);
7553	extern tree reshape_init (tree, tree, tsubst_flags_t);
7554	extern tree next_aggregate_field (tree);
7555	extern tree next_subobject_field (tree);
7556	extern tree first_field (const_tree);
7557	extern tree fndecl_declared_return_type (tree);
7558	extern bool undeduced_auto_decl (tree);
7559	extern bool require_deduced_type (tree, tsubst_flags_t = tf_warning_or_error);
7560
7561	extern tree finish_case_label (location_t, tree, tree);
7562	extern tree cxx_maybe_build_cleanup (tree, tsubst_flags_t);
7563	extern bool check_array_designated_initializer (constructor_elt *,
7564	unsigned HOST_WIDE_INT);
7565	extern bool check_for_uninitialized_const_var (tree, bool, tsubst_flags_t);
7566	extern tree build_explicit_specifier (tree, tsubst_flags_t);
7567	extern bool use_eh_spec_block (tree);
7568	extern void do_push_parm_decls (tree, tree, tree *);
7569	extern tree do_aggregate_paren_init (tree, tree);
7570	extern void maybe_mark_function_versioned (tree);
7571	extern const char tag_name (enum* tag_types);
7572
7573	/ in decl2.cc /
7574	extern void record_mangling (tree, bool);
7575	extern void overwrite_mangling (tree, tree);
7576	extern void note_mangling_alias (tree, tree);
7577	extern void generate_mangling_aliases (void);
7578	extern tree build_memfn_type (tree, tree, cp_cv_quals, cp_ref_qualifier);
7579	extern tree build_pointer_ptrmemfn_type (tree);
7580	extern tree change_return_type (tree, tree);
7581	extern void maybe_retrofit_in_chrg (tree);
7582	extern void maybe_make_one_only (tree);
7583	extern bool vague_linkage_p (tree);
7584	extern void grokclassfn (tree, tree,
7585	enum overload_flags);
7586	extern tree grok_array_decl (location_t, tree, tree,
7587	vec<tree, va_gc> **, tsubst_flags_t);
7588	extern tree grok_omp_array_section (location_t, tree, tree, tree);
7589	extern tree delete_sanity (location_t, tree, tree, bool,
7590	int, tsubst_flags_t);
7591	extern tree check_classfn (tree, tree, tree);
7592	extern void check_member_template (tree);
7593	extern tree grokfield (const cp_declarator , cp_decl_specifier_seq ,
7594	tree, bool, tree, tree);
7595	extern tree grokbitfield (const cp_declarator , cp_decl_specifier_seq ,
7596	tree, tree, tree);
7597	extern tree start_initialized_static_member (const cp_declarator *,
7598	cp_decl_specifier_seq *, tree);
7599	extern bool is_static_data_member_initialized_in_class (tree decl);
7600	extern void finish_initialized_static_member (tree, tree, tree);
7601	extern tree splice_template_attributes (tree *, tree);
7602	extern bool any_dependent_type_attributes_p (tree);
7603	extern tree cp_reconstruct_complex_type (tree, tree);
7604	extern bool attributes_naming_typedef_ok (tree);
7605	extern void cplus_decl_attributes (tree , tree, int*);
7606	extern void finish_anon_union (tree);
7607	extern void cxx_post_compilation_parsing_cleanups (void);
7608	extern tree coerce_new_type (tree, location_t);
7609	extern void coerce_delete_type (tree, location_t);
7610	extern void comdat_linkage (tree);
7611	extern void determine_visibility (tree);
7612	extern void constrain_class_visibility (tree);
7613	extern void reset_type_linkage (tree);
7614	extern void tentative_decl_linkage (tree);
7615	extern void import_export_decl (tree);
7616	extern tree build_cleanup (tree);
7617	extern tree build_offset_ref_call_from_tree (tree, vec<tree, va_gc> **,
7618	tsubst_flags_t);
7619	extern bool decl_defined_p (tree);
7620	extern bool decl_constant_var_p (tree);
7621	extern bool decl_maybe_constant_var_p (tree);
7622	extern void no_linkage_error (tree);
7623	extern void check_default_args (tree);
7624	extern bool mark_used (tree,
7625	tsubst_flags_t = tf_warning_or_error);
7626	extern bool mark_single_function (tree, tsubst_flags_t);
7627	extern void finish_static_data_member_decl (tree, tree, bool, tree, int);
7628	extern tree cp_build_parm_decl (tree, tree, tree);
7629	extern void copy_linkage (tree, tree);
7630	extern tree get_guard (tree);
7631	extern tree get_guard_cond (tree, bool);
7632	extern tree set_guard (tree);
7633	extern bool var_needs_tls_wrapper (tree);
7634	extern tree maybe_get_tls_wrapper_call (tree);
7635	extern void mark_needed (tree);
7636	extern bool decl_needed_p (tree);
7637	extern void note_vague_linkage_fn (tree);
7638	extern void note_vague_linkage_variable (tree);
7639	extern tree build_artificial_parm (tree, tree, tree);
7640	extern bool possibly_inlined_p (tree);
7641	extern int parm_index (tree);
7642	extern tree vtv_start_verification_constructor_init_function (void);
7643	extern tree vtv_finish_verification_constructor_init_function (tree);
7644	extern void cp_check_const_attributes (tree);
7645	extern void maybe_propagate_warmth_attributes (tree, tree);
7646
7647	/ in error.cc /
7648	/ A class for pretty-printing to -flang-dump-XXX files. Used like*
7649
7650	if (cxx_dump_pretty_printer pp {foo_dump_id})
7651	{
7652	pp_printf (&pp, ...);
7653	}
7654
7655	If the dump is enabled, the pretty printer will open the dump file and
7656	attach to it, and flush and close the file on destruction. /*
7657
7658	class cxx_dump_pretty_printer: public pretty_printer
7659	{
7660	int phase;
7661	FILE *outf;
7662	dump_flags_t flags;
7663
7664	public:
7665	cxx_dump_pretty_printer (int phase);
7666	operator bool() { return outf != nullptr; }
7667	bool has_flag (dump_flags_t f) { return (flags & f); }
7668	~cxx_dump_pretty_printer ();
7669	};
7670
7671	extern const char type_as_string (tree, int*);
7672	extern const char type_as_string_translate (tree, int*);
7673	extern const char decl_as_string (tree, int*);
7674	extern const char decl_as_string_translate (tree, int*);
7675	extern const char decl_as_dwarf_string (tree, int*);
7676	extern const char expr_as_string (tree, int*);
7677	extern const char *expr_to_string (tree);
7678	extern const char lang_decl_name (tree, int, bool*);
7679	extern const char lang_decl_dwarf_name (tree, int, bool*);
7680	extern const char language_to_string (enum* languages);
7681	extern const char *class_key_or_enum_as_string (tree);
7682	extern void maybe_warn_variadic_templates (void);
7683	extern void maybe_warn_cpp0x (cpp0x_warn_str str,
7684	location_t = input_location);
7685	extern bool pedwarn_cxx98 (location_t,
7686	diagnostics::option_id option_id,
7687	const char *, ...) ATTRIBUTE_GCC_DIAG(`3`,`4`);
7688	extern location_t location_of (tree);
7689	extern void qualified_name_lookup_error (tree, tree, tree,
7690	location_t);
7691
7692	struct decl_location_traits
7693	: simple_cache_map_traits<tree_decl_hash, location_t> { };
7694	typedef hash_map<tree, location_t, decl_location_traits> erroneous_templates_t;
7695	extern GTY((cache)) erroneous_templates_t *erroneous_templates;
7696
7697	extern bool cp_seen_error ();
7698	#define seen_error() cp_seen_error ()
7699
7700	/ in except.cc /
7701	extern void init_terminate_fn (void);
7702	extern void init_exception_processing (void);
7703	extern tree expand_start_catch_block (tree);
7704	extern void expand_end_catch_block (void);
7705	extern tree build_exc_ptr (void);
7706	extern tree build_throw (location_t, tree,
7707	tsubst_flags_t);
7708	extern int nothrow_libfn_p (const_tree);
7709	extern void check_handlers (tree);
7710	extern tree finish_noexcept_expr (tree, tsubst_flags_t);
7711	extern bool expr_noexcept_p (tree, tsubst_flags_t);
7712	extern void explain_not_noexcept (tree);
7713	extern void perform_deferred_noexcept_checks (void);
7714	extern bool nothrow_spec_p (const_tree);
7715	extern bool type_noexcept_p (const_tree);
7716	extern bool type_throw_all_p (const_tree);
7717	extern tree build_noexcept_spec (tree, tsubst_flags_t);
7718	extern void choose_personality_routine (enum languages);
7719	extern tree build_must_not_throw_expr (tree,tree);
7720	extern tree eh_type_info (tree);
7721	extern tree begin_eh_spec_block (void);
7722	extern void finish_eh_spec_block (tree, tree);
7723	extern tree build_eh_type_type (tree);
7724	extern tree cp_protect_cleanup_actions (void);
7725	extern void maybe_splice_retval_cleanup (tree, bool);
7726	extern tree maybe_set_retval_sentinel (void);
7727
7728	extern tree template_parms_to_args (tree);
7729	extern tree template_parms_level_to_args (tree);
7730	extern tree generic_targs_for (tree);
7731	extern tree outer_template_args (const_tree);
7732
7733	/ in expr.cc /
7734	extern tree cplus_expand_constant (tree);
7735	extern tree mark_use (tree expr, bool rvalue_p, bool read_p,
7736	location_t = UNKNOWN_LOCATION,
7737	bool reject_builtin = true);
7738	extern tree mark_rvalue_use (tree,
7739	location_t = UNKNOWN_LOCATION,
7740	bool reject_builtin = true);
7741	extern tree mark_lvalue_use (tree);
7742	extern tree mark_lvalue_use_nonread (tree);
7743	extern tree mark_type_use (tree);
7744	extern tree mark_discarded_use (tree);
7745	extern void mark_exp_read (tree);
7746	extern tree wrap_with_if_consteval (tree);
7747
7748	/ friend.cc /
7749	extern int is_friend (tree, tree);
7750	extern void make_friend_class (tree, tree, bool);
7751	extern void add_friend (tree, tree, bool);
7752	extern tree do_friend (tree, tree, tree,
7753	enum overload_flags, bool);
7754
7755	extern void set_global_friend (tree);
7756	extern bool is_global_friend (tree);
7757
7758	/ in init.cc /
7759	extern tree find_temps_r (tree , int* , void* *);
7760	extern tree expand_member_init (tree);
7761	extern void emit_mem_initializers (tree);
7762	extern tree build_aggr_init (tree, tree, int,
7763	tsubst_flags_t);
7764	extern int is_class_type (tree, int);
7765	extern bool is_copy_initialization (tree);
7766	extern tree build_zero_init (tree, tree, bool);
7767	extern tree build_value_init (tree, tsubst_flags_t);
7768	extern tree build_value_init_noctor (tree, tsubst_flags_t);
7769	extern tree maybe_instantiate_nsdmi_init (tree, tsubst_flags_t);
7770	extern tree get_nsdmi (tree, bool, tsubst_flags_t);
7771	extern tree build_offset_ref (tree, tree, bool,
7772	tsubst_flags_t);
7773	extern tree throw_bad_array_new_length (void);
7774	extern bool type_has_new_extended_alignment (tree);
7775	extern unsigned malloc_alignment (void);
7776	extern bool std_placement_new_fn_p (tree);
7777	extern tree build_new_constexpr_heap_type (tree, tree, tree);
7778	extern tree build_new (location_t,
7779	vec<tree, va_gc> **, tree,
7780	tree, vec<tree, va_gc> **,
7781	int, tsubst_flags_t);
7782	extern tree get_temp_regvar (tree, tree);
7783	extern tree build_vec_init (tree, tree, tree, bool, int,
7784	tsubst_flags_t,
7785	vec<tree, va_gc> = nullptr**);
7786	extern tree build_delete (location_t, tree, tree,
7787	special_function_kind,
7788	int, int, tsubst_flags_t);
7789	extern void push_base_cleanups (void);
7790	extern tree build_vec_delete (location_t, tree, tree,
7791	special_function_kind, int,
7792	tsubst_flags_t);
7793	extern tree create_temporary_var (tree);
7794	extern void initialize_vtbl_ptrs (tree);
7795	extern tree scalar_constant_value (tree);
7796	extern tree decl_constant_value (tree, bool);
7797	extern tree decl_really_constant_value (tree, bool = true);
7798	extern int diagnose_uninitialized_cst_or_ref_member (tree, bool, bool);
7799	extern tree build_vtbl_address (tree);
7800	extern bool maybe_reject_flexarray_init (tree, tree);
7801
7802	/ in lex.cc /
7803	extern void cxx_dup_lang_specific_decl (tree);
7804	extern tree unqualified_name_lookup_error (tree,
7805	location_t = UNKNOWN_LOCATION);
7806	extern tree unqualified_fn_lookup_error (cp_expr);
7807	extern tree make_conv_op_name (tree);
7808	extern tree build_lang_decl (enum tree_code, tree, tree);
7809	extern tree build_lang_decl_loc (location_t, enum tree_code, tree, tree);
7810	extern bool maybe_add_lang_decl_raw (tree, bool decomp_p);
7811	extern bool maybe_add_lang_type_raw (tree);
7812	extern void retrofit_lang_decl (tree);
7813	extern void fit_decomposition_lang_decl (tree, tree);
7814	extern tree copy_decl (tree CXX_MEM_STAT_INFO);
7815	extern tree copy_type (tree CXX_MEM_STAT_INFO);
7816	extern tree cxx_make_type (enum tree_code CXX_MEM_STAT_INFO);
7817	extern tree make_class_type (enum tree_code CXX_MEM_STAT_INFO);
7818	extern const char *get_identifier_kind_name (tree);
7819	extern void set_identifier_kind (tree, cp_identifier_kind);
7820	extern bool cxx_init (void);
7821	extern void cxx_finish (void);
7822	extern bool in_main_input_context (void);
7823	extern uintptr_t module_token_pre (cpp_reader , const* cpp_token *, uintptr_t);
7824	extern uintptr_t module_token_cdtor (cpp_reader *, uintptr_t);
7825	extern uintptr_t module_token_lang (int type, int keyword, tree value,
7826	location_t, uintptr_t);
7827
7828	/ in method.cc /
7829	extern void init_method (void);
7830	extern tree make_thunk (tree, bool, tree, tree);
7831	extern void finish_thunk (tree);
7832	extern void use_thunk (tree, bool);
7833	extern bool trivial_fn_p (tree);
7834	extern tree forward_parm (tree);
7835	extern bool is_trivially_xible (enum tree_code, tree, tree,
7836	bool = false);
7837	extern bool is_nothrow_xible (enum tree_code, tree, tree,
7838	bool = false);
7839	extern bool is_xible (enum tree_code, tree, tree,
7840	bool = false);
7841	extern bool is_convertible (tree, tree, bool = false);
7842	extern bool is_nothrow_convertible (tree, tree, bool = false);
7843	extern bool ref_xes_from_temporary (tree, tree, bool);
7844	extern tree get_defaulted_eh_spec (tree, tsubst_flags_t = tf_warning_or_error);
7845	extern bool maybe_explain_implicit_delete (tree);
7846	extern void explain_implicit_non_constexpr (tree);
7847	extern bool deduce_inheriting_ctor (tree);
7848	extern bool decl_remember_implicit_trigger_p (tree);
7849	extern void synthesize_method (tree);
7850	extern void maybe_synthesize_method (tree);
7851	extern tree lazily_declare_fn (special_function_kind,
7852	tree);
7853	extern tree skip_artificial_parms_for (const_tree, tree);
7854	extern int num_artificial_parms_for (const_tree);
7855	extern tree make_alias_for (tree, tree);
7856	extern tree get_copy_ctor (tree, tsubst_flags_t);
7857	extern tree get_copy_assign (tree);
7858	extern tree get_default_ctor (tree);
7859	extern tree get_dtor (tree, tsubst_flags_t);
7860	extern tree build_stub_type (tree, int, bool);
7861	extern tree build_stub_object (tree);
7862	extern bool is_stub_object (tree);
7863	extern tree build_invoke (tree, const_tree,
7864	tsubst_flags_t);
7865	extern tree strip_inheriting_ctors (tree);
7866	extern tree inherited_ctor_binfo (tree);
7867	extern bool base_ctor_omit_inherited_parms (tree);
7868	extern bool ctor_omit_inherited_parms (tree);
7869	extern tree locate_ctor (tree);
7870	extern tree implicitly_declare_fn (special_function_kind, tree,
7871	bool, tree, tree);
7872	extern tree type_order_value (tree, tree);
7873
7874	/ True iff DECL represents a declaration of a friend template*
7875	specialization, e.g. friend void f<>(). /*
7876
7877	inline bool
7878	decl_specialization_friend_p (tree decl)
7879	{
7880	return (TREE_CODE (decl) == FUNCTION_DECL
7881	&& DECL_UNIQUE_FRIEND_P (decl)
7882	&& DECL_IMPLICIT_INSTANTIATION (decl)
7883	&& TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL);
7884	}
7885
7886	/ In module.cc /
7887	class module_state; / Forward declare. /
7888	inline bool modules_p () { return flag_modules != `0`; }
7889
7890	/ The kind of module or part thereof that we're in. /
7891	enum module_kind_bits
7892	{
7893	MK_NAMED = `1` << `0`, // TU is a named module
7894	MK_HEADER = `1` << `1`, // TU is a header unit
7895	MK_INTERFACE = `1` << `2`, // TU is an interface
7896	MK_PARTITION = `1` << `3`, // TU is a partition
7897
7898	MK_PURVIEW = `1` << `4`, // In purview of current module
7899	MK_ATTACH = `1` << `5`, // Attaching to named module
7900
7901	MK_EXPORTING = `1` << `6`, / We are in an export region. /
7902	};
7903
7904	/ We do lots of bit-manipulation, so an unsigned is easier. /
7905	extern unsigned module_kind;
7906
7907	inline bool module_p ()
7908	{ return module_kind & (MK_NAMED \| MK_HEADER); }
7909	inline bool named_module_p ()
7910	{ return module_kind & MK_NAMED; }
7911	inline bool header_module_p ()
7912	{ return module_kind & MK_HEADER; }
7913	inline bool module_interface_p ()
7914	{ return module_kind & MK_INTERFACE; }
7915	inline bool module_partition_p ()
7916	{ return module_kind & MK_PARTITION; }
7917	inline bool module_has_cmi_p ()
7918	{ return module_kind & (MK_INTERFACE \| MK_PARTITION \| MK_HEADER); }
7919
7920	inline bool module_purview_p ()
7921	{ return module_kind & MK_PURVIEW; }
7922	inline bool module_attach_p ()
7923	{ return module_kind & MK_ATTACH; }
7924
7925	inline bool named_module_purview_p ()
7926	{ return named_module_p () && module_purview_p (); }
7927	inline bool named_module_attach_p ()
7928	{ return named_module_p () && module_attach_p (); }
7929
7930	/ Like module_has_cmi_p, but tentatively assumes that this TU may have a*
7931	CMI if we haven't seen the module-declaration yet. /*
7932	inline bool module_maybe_has_cmi_p ()
7933	{ return module_has_cmi_p () \|\| (named_module_p () && !module_purview_p ()); }
7934
7935	/ We're currently exporting declarations. /
7936	inline bool module_exporting_p ()
7937	{ return module_kind & MK_EXPORTING; }
7938
7939	extern module_state get_module (tree name, module_state parent = NULL,
7940	bool partition = false);
7941	extern bool module_may_redeclare (tree olddecl, tree newdecl = NULL);
7942
7943	extern bool instantiating_tu_local_entity (tree decl);
7944
7945	extern bool module_global_init_needed ();
7946	extern bool module_determine_import_inits ();
7947	extern void module_add_import_initializers ();
7948
7949	/ Where the namespace-scope decl was originally declared. /
7950	extern void set_originating_module (tree, bool friend_p = false);
7951	extern tree get_originating_module_decl (tree) ATTRIBUTE_PURE;
7952	extern int get_originating_module (tree, bool global_m1 = false) ATTRIBUTE_PURE;
7953	extern unsigned get_importing_module (tree, bool = false) ATTRIBUTE_PURE;
7954	extern void check_module_decl_linkage (tree);
7955
7956	/ Where current instance of the decl got declared/defined/instantiated. /
7957	extern void set_instantiating_module (tree);
7958	extern void set_defining_module (tree);
7959	extern void set_defining_module_for_partial_spec (tree);
7960	extern void maybe_key_decl (tree ctx, tree decl);
7961	extern void propagate_defining_module (tree decl, tree orig);
7962	extern void transfer_defining_module (tree olddecl, tree newdecl);
7963	extern void remove_defining_module (tree decl);
7964
7965	extern void mangle_module (int m, bool include_partition);
7966	extern void mangle_module_fini ();
7967	extern void lazy_load_binding (unsigned mod, tree ns, tree id,
7968	binding_slot *bslot);
7969	extern void lazy_load_pendings (tree decl);
7970	extern module_state preprocess_module (module_state , location_t,
7971	bool in_purview,
7972	bool is_import, bool export_p,
7973	cpp_reader *reader);
7974	extern void preprocessed_module (cpp_reader *reader);
7975	extern void import_module (module_state , location_t, bool* export_p,
7976	tree attr, cpp_reader *);
7977	extern void declare_module (module_state , location_t, bool* export_p,
7978	tree attr, cpp_reader *);
7979	extern void init_modules (cpp_reader *);
7980	extern void fini_modules (cpp_reader , void* cookie, bool*);
7981	extern void maybe_check_all_macros (cpp_reader *);
7982	extern void finish_module_processing (cpp_reader );
7983	extern char const module_name (unsigned, bool* header_ok);
7984	extern bitmap get_import_bitmap ();
7985	extern bitmap visible_instantiation_path (bitmap *);
7986	extern bitmap visible_from_instantiation_origination (unsigned *);
7987	extern void module_begin_main_file (cpp_reader , line_maps ,
7988	const line_map_ordinary *);
7989	extern void module_preprocess_options (cpp_reader *);
7990	extern bool handle_module_option (unsigned opt, const char arg, int* value);
7991
7992	/ In optimize.cc /
7993	extern tree clone_attrs (tree);
7994	extern bool maybe_clone_body (tree);
7995
7996	/ In parser.cc /
7997	extern tree cp_build_range_for_decls (location_t, tree, tree , bool*);
7998	extern tree cp_convert_range_for (tree, tree, tree, cp_decomp , bool*,
7999	tree, bool);
8000	extern tree build_range_temp (tree, bool = false);
8001	extern tree cp_perform_range_for_lookup (tree, tree , tree ,
8002	tsubst_flags_t = tf_warning_or_error);
8003	extern void cp_convert_omp_range_for (tree &, tree &, tree &,
8004	tree &, tree &, tree &, tree &, tree &,
8005	bool);
8006	extern void cp_finish_omp_range_for (tree, tree);
8007	extern bool cp_maybe_parse_omp_decl (tree, tree);
8008	extern bool parsing_nsdmi (void);
8009	extern bool parsing_function_declarator ();
8010	extern void inject_this_parameter (tree, cp_cv_quals);
8011	extern location_t defparse_location (tree);
8012	extern void maybe_show_extern_c_location (void);
8013	extern bool literal_integer_zerop (const_tree);
8014	extern tree attr_chainon (tree, tree);
8015	extern tree maybe_add_dummy_lambda_op (tree);
8016	extern void remove_dummy_lambda_op (tree, tree);
8017
8018	/ in pt.cc /
8019	extern tree canonical_type_parameter (tree);
8020	extern void push_access_scope (tree);
8021	extern void pop_access_scope (tree);
8022	extern tree current_function_decl_without_access_scope ();
8023	extern bool check_template_shadow (tree);
8024	extern tree get_innermost_template_args (tree, int);
8025	extern void maybe_begin_member_template_processing (tree);
8026	extern void maybe_end_member_template_processing (void);
8027	extern tree finish_member_template_decl (tree);
8028	extern void begin_template_parm_list (void);
8029	extern bool begin_specialization (void);
8030	extern void reset_specialization (void);
8031	extern void end_specialization (void);
8032	extern void begin_explicit_instantiation (void);
8033	extern void end_explicit_instantiation (void);
8034	extern void check_unqualified_spec_or_inst (tree, location_t);
8035	extern tree check_explicit_specialization (tree, tree, int, int,
8036	tree = NULL_TREE);
8037	extern int num_template_headers_for_class (tree);
8038	extern void check_template_variable (tree);
8039	extern tree make_auto (void);
8040	extern tree make_decltype_auto (void);
8041	extern tree make_constrained_auto (tree, tree);
8042	extern tree make_constrained_decltype_auto (tree, tree);
8043	extern tree make_template_placeholder (tree);
8044	extern tree make_cast_auto (void);
8045	extern tree make_auto_pack (void);
8046	extern bool template_placeholder_p (tree);
8047	extern bool ctad_template_p (tree);
8048	extern bool unparenthesized_id_or_class_member_access_p (tree);
8049	extern tree do_auto_deduction (tree, tree, tree,
8050	tsubst_flags_t
8051	= tf_warning_or_error,
8052	auto_deduction_context
8053	= adc_unspecified,
8054	tree = NULL_TREE,
8055	int = LOOKUP_NORMAL,
8056	tree = NULL_TREE);
8057	extern tree type_uses_auto (tree);
8058	extern tree convert_generic_types_to_packs (tree, int, int);
8059	extern tree splice_late_return_type (tree, tree);
8060	extern bool is_auto (const_tree);
8061	extern tree process_template_parm (tree, location_t, tree,
8062	bool, bool);
8063	extern tree end_template_parm_list (tree);
8064	extern void end_template_parm_list (void);
8065	extern void end_template_decl (void);
8066	extern tree maybe_update_decl_type (tree, tree);
8067	extern bool check_default_tmpl_args (tree, tree, bool, bool, int);
8068	extern tree push_template_decl (tree, bool is_friend = false);
8069	extern tree add_inherited_template_parms (tree, tree);
8070	extern void template_parm_level_and_index (tree, int, int**);
8071	extern bool redeclare_class_template (tree, tree, tree);
8072	extern tree adjust_type_for_entering_scope (tree);
8073	extern tree lookup_template_class (tree, tree, tree, tree,
8074	tsubst_flags_t);
8075	extern tree lookup_template_function (tree, tree);
8076	extern tree lookup_template_variable (tree, tree, tsubst_flags_t);
8077	extern bool uses_template_parms (tree);
8078	extern bool uses_template_parms_level (tree, int);
8079	extern bool uses_outer_template_parms_in_constraints (tree, tree = NULL_TREE);
8080	extern bool need_generic_capture (void);
8081	extern tree instantiate_class_template (tree);
8082	extern tree instantiate_template (tree, tree, tsubst_flags_t);
8083	extern tree fn_type_unification (tree, tree, tree,
8084	const tree , unsigned* int,
8085	tree, unification_kind_t, int,
8086	struct conversion **,
8087	bool, bool);
8088	extern void setup_explicit_instantiation_definition_linkage (tree);
8089	extern void mark_decl_instantiated (tree, int);
8090	extern int more_specialized_fn (tree, tree, int);
8091	extern tree type_targs_deducible_from (tree, tree);
8092	extern void do_decl_instantiation (tree, tree);
8093	extern void do_type_instantiation (tree, tree, tsubst_flags_t);
8094	extern bool always_instantiate_p (tree);
8095	extern bool maybe_instantiate_noexcept (tree, tsubst_flags_t = tf_warning_or_error);
8096	extern tree instantiate_decl (tree, bool, bool);
8097	extern void maybe_instantiate_decl (tree);
8098	extern int comp_template_parms (const_tree, const_tree);
8099	extern bool template_heads_equivalent_p (const_tree, const_tree);
8100	extern bool builtin_pack_fn_p (tree);
8101	extern tree uses_parameter_packs (tree);
8102	extern bool template_parameter_pack_p (const_tree);
8103	extern bool function_parameter_pack_p (const_tree);
8104	extern bool function_parameter_expanded_from_pack_p (tree, tree);
8105	extern tree make_pack_expansion (tree, tsubst_flags_t = tf_warning_or_error);
8106	extern tree make_pack_index (tree, tree);
8107	extern bool check_for_bare_parameter_packs (tree, location_t = UNKNOWN_LOCATION);
8108	extern tree build_template_info (tree, tree);
8109	extern tree get_template_info (const_tree);
8110	extern int template_class_depth (tree);
8111	extern int is_specialization_of (tree, tree);
8112	extern bool is_specialization_of_friend (tree, tree);
8113	extern bool comp_template_args (tree, tree, tree * = NULL,
8114	tree * = NULL);
8115	extern int template_args_equal (tree, tree);
8116	extern tree maybe_process_partial_specialization (tree);
8117	extern tree most_specialized_instantiation (tree);
8118	extern tree most_specialized_partial_spec (tree, tsubst_flags_t, bool = false);
8119	extern tree most_constrained_function (tree);
8120	extern void inform_num_candidates (location_t, int);
8121
8122	/ Abstract base class for optionally providing extra diagnostic note(s)*
8123	about a candidate in calls to print_candidates. /*
8124
8125	class candidate_context
8126	{
8127	public:
8128	virtual ~candidate_context () {}
8129	virtual void emit_any_notes_for_candidate (tree cand_fndecl) = `0`;
8130	};
8131
8132	extern void print_candidates (location_t, tree,
8133	candidate_context * = nullptr);
8134
8135	extern void instantiate_pending_templates (int);
8136	extern tree tsubst_default_argument (tree, int, tree, tree,
8137	tsubst_flags_t);
8138	extern tree tsubst (tree, tree, tsubst_flags_t, tree);
8139	extern tree tsubst_expr (tree, tree, tsubst_flags_t, tree);
8140	extern tree tsubst_pack_expansion (tree, tree, tsubst_flags_t, tree);
8141	extern tree tsubst_argument_pack (tree, tree, tsubst_flags_t, tree);
8142	extern tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
8143	extern tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
8144	extern tree tsubst_function_parms (tree, tree, tsubst_flags_t, tree);
8145	extern tree most_general_template (const_tree);
8146	extern tree get_mostly_instantiated_function_type (tree);
8147	extern bool problematic_instantiation_changed (void);
8148	extern void record_last_problematic_instantiation (void);
8149	extern struct tinst_level current_instantiation(void*);
8150	extern bool instantiating_current_function_p (void);
8151	extern tree maybe_get_template_decl_from_type_decl (tree);
8152	extern int processing_template_parmlist;
8153	extern bool dependent_type_p (tree);
8154	extern bool dependent_scope_p (tree);
8155	extern bool dependentish_scope_p (tree);
8156	extern bool dependent_namespace_p (tree);
8157	extern bool any_dependent_template_arguments_p (const_tree);
8158	extern bool any_erroneous_template_args_p (const_tree);
8159	extern bool dependent_template_p (tree);
8160	extern bool dependent_template_id_p (tree, tree);
8161	extern bool type_dependent_expression_p (tree);
8162	extern bool type_dependent_object_expression_p (tree);
8163	extern bool any_type_dependent_arguments_p (const vec<tree, va_gc> *);
8164	extern bool any_type_dependent_elements_p (const_tree);
8165	extern bool type_dependent_expression_p_push (tree);
8166	extern bool value_dependent_expression_p (tree);
8167	extern bool instantiation_dependent_uneval_expression_p (tree);
8168	extern bool any_value_dependent_elements_p (const_tree);
8169	extern bool dependent_template_arg_p (tree);
8170	extern bool dependent_omp_for_p (tree, tree, tree, tree, tree);
8171	extern tree resolve_typename_type (tree, bool);
8172	extern tree template_for_substitution (tree);
8173	extern bool reregister_specialization (tree, tree, tree);
8174	extern tree instantiate_non_dependent_expr (tree, tsubst_flags_t = tf_error);
8175	extern tree instantiate_non_dependent_expr_internal (tree, tsubst_flags_t);
8176	extern tree instantiate_non_dependent_or_null (tree);
8177	extern bool variable_template_specialization_p (tree);
8178	extern bool alias_type_or_template_p (tree);
8179	enum { nt_opaque = false, nt_transparent = true };
8180	extern tree alias_template_specialization_p (const_tree, bool);
8181	extern tree dependent_alias_template_spec_p (const_tree, bool);
8182	extern bool dependent_opaque_alias_p (const_tree);
8183	extern tree get_template_parm_object (tree expr, tree mangle,
8184	bool check_init = true);
8185	extern tree tparm_object_argument (tree);
8186	extern bool explicit_class_specialization_p (tree);
8187	extern bool push_tinst_level (tree);
8188	extern bool push_tinst_level (tree, tree);
8189	extern bool push_tinst_level_loc (tree, location_t);
8190	extern bool push_tinst_level_loc (tree, tree, location_t);
8191	extern void pop_tinst_level (void);
8192	extern struct tinst_level outermost_tinst_level(void*);
8193	extern bool non_templated_friend_p (tree);
8194	extern void init_template_processing (void);
8195	extern void print_template_statistics (void);
8196	bool template_template_parameter_p (const_tree);
8197	bool template_type_parameter_p (const_tree);
8198	extern bool primary_template_specialization_p (const_tree);
8199	extern tree get_primary_template_innermost_parameters (const_tree);
8200	extern tree get_template_innermost_arguments (const_tree);
8201	extern tree get_template_argument_pack_elems (const_tree);
8202	extern tree get_function_template_decl (const_tree);
8203	extern tree resolve_nondeduced_context (tree, tsubst_flags_t);
8204	extern tree resolve_nondeduced_context_or_error (tree, tsubst_flags_t);
8205	extern hashval_t iterative_hash_template_arg (tree arg, hashval_t val);
8206	extern tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
8207	bool = true);
8208	extern tree canonicalize_type_argument (tree, tsubst_flags_t);
8209	extern void register_local_identity (tree);
8210	extern void register_local_specialization (tree, tree);
8211	extern tree retrieve_local_specialization (tree);
8212	extern void register_parameter_specializations (tree, tree);
8213	extern tree extract_fnparm_pack (tree, tree *);
8214	extern tree template_parm_to_arg (tree);
8215	extern tree dguide_name (tree);
8216	extern bool dguide_name_p (tree);
8217	extern bool deduction_guide_p (const_tree);
8218	extern bool copy_guide_p (const_tree);
8219	extern bool template_guide_p (const_tree);
8220	extern bool builtin_guide_p (const_tree);
8221	extern bool inherited_guide_p (const_tree);
8222	extern void store_explicit_specifier (tree, tree);
8223	extern tree lookup_explicit_specifier (tree);
8224	extern tree lookup_imported_hidden_friend (tree);
8225	extern void walk_specializations (bool,
8226	void ()(bool, spec_entry ,
8227	void *),
8228	void *);
8229	extern tree match_mergeable_specialization (bool is_decl, spec_entry *);
8230	extern unsigned get_mergeable_specialization_flags (bool is_decl, tree tmpl,
8231	tree spec);
8232	extern void add_mergeable_specialization (bool is_decl, spec_entry *,
8233	tree outer, unsigned);
8234	extern tree add_to_template_args (tree, tree);
8235	extern tree add_outermost_template_args (tree, tree);
8236	extern tree add_extra_args (tree, tree, tsubst_flags_t, tree);
8237	extern tree build_extra_args (tree, tree, tsubst_flags_t);
8238	extern void finish_expansion_stmt (tree, tree, tsubst_flags_t, tree);
8239	extern tree convert_reflect_constant_arg (tree, tree);
8240
8241	/ in rtti.cc /
8242	/ A vector of all tinfo decls that haven't been emitted yet. /
8243	extern GTY(()) vec<tree, va_gc> *unemitted_tinfo_decls;
8244
8245	extern void init_rtti_processing (void);
8246	extern tree build_typeid (tree, tsubst_flags_t);
8247	extern tree get_tinfo_decl_direct (tree, tree, int);
8248	extern tree get_tinfo_decl (tree);
8249	extern tree get_typeid (tree, tsubst_flags_t);
8250	extern tree build_headof (tree);
8251	extern tree build_dynamic_cast (location_t, tree, tree,
8252	tsubst_flags_t);
8253	extern void emit_support_tinfos (void);
8254	extern bool emit_tinfo_decl (tree);
8255	extern unsigned get_pseudo_tinfo_index (tree);
8256	extern tree get_pseudo_tinfo_type (unsigned);
8257	extern tree build_if_nonnull (tree, tree, tsubst_flags_t);
8258
8259	/ in search.cc /
8260	extern tree get_parent_with_private_access (tree decl, tree binfo);
8261	extern bool accessible_base_p (tree, tree, bool);
8262	extern tree lookup_base (tree, tree, base_access,
8263	base_kind *, tsubst_flags_t,
8264	HOST_WIDE_INT = -`1`);
8265	extern tree dcast_base_hint (tree, tree);
8266	extern int accessible_p (tree, tree, bool);
8267	extern int accessible_in_template_p (tree, tree);
8268	extern tree lookup_field (tree, tree, int, bool);
8269	extern tree lookup_fnfields (tree, tree, int, tsubst_flags_t);
8270	extern tree lookup_member (tree, tree, int, bool,
8271	tsubst_flags_t,
8272	access_failure_info *afi = NULL);
8273	extern tree lookup_member_fuzzy (tree, tree, bool);
8274	extern tree locate_field_accessor (tree, tree, bool);
8275	extern int look_for_overrides (tree, tree);
8276	extern void get_pure_virtuals (tree);
8277	extern void maybe_suppress_debug_info (tree);
8278	extern void note_debug_info_needed (tree);
8279	extern tree current_scope (void);
8280	extern int at_function_scope_p (void);
8281	extern bool at_class_scope_p (void);
8282	extern bool at_namespace_scope_p (void);
8283	extern tree context_for_name_lookup (tree);
8284	extern tree type_context_for_name_lookup (tree);
8285	extern tree lookup_conversions (tree);
8286	extern tree binfo_from_vbase (tree);
8287	extern tree binfo_for_vbase (tree, tree);
8288	extern tree look_for_overrides_here (tree, tree);
8289	#define dfs_skip_bases ((tree)1)
8290	extern tree dfs_walk_all (tree, tree () (tree, void* *),
8291	tree () (tree, void* ), void* *);
8292	extern tree dfs_walk_once (tree, tree () (tree, void* *),
8293	tree () (tree, void* ), void* *);
8294	extern tree binfo_via_virtual (tree, tree);
8295	extern bool binfo_direct_p (tree);
8296	extern tree build_baselink (tree, tree, tree, tree);
8297	extern tree adjust_result_of_qualified_name_lookup
8298	(tree, tree, tree);
8299	extern tree copied_binfo (tree, tree);
8300	extern tree original_binfo (tree, tree);
8301	extern bool shared_member_p (tree);
8302	extern bool any_dependent_bases_p (tree = current_nonlambda_class_type ());
8303	extern bool maybe_check_overriding_exception_spec (tree, tree);
8304
8305	/ in semantics.cc /
8306	extern void push_deferring_access_checks (deferring_kind);
8307	extern void resume_deferring_access_checks (void);
8308	extern void stop_deferring_access_checks (void);
8309	extern void pop_deferring_access_checks (void);
8310	extern vec<deferred_access_check, va_gc> get_deferred_access_checks (void*);
8311	extern void reopen_deferring_access_checks (vec<deferred_access_check, va_gc> *);
8312	extern void pop_to_parent_deferring_access_checks (void);
8313	extern bool perform_access_checks (vec<deferred_access_check, va_gc> *,
8314	tsubst_flags_t);
8315	extern bool perform_deferred_access_checks (tsubst_flags_t);
8316	extern bool perform_or_defer_access_check (tree, tree, tree,
8317	tsubst_flags_t,
8318	access_failure_info *afi = NULL);
8319	extern tree maybe_convert_cond (tree);
8320
8321	/ RAII sentinel to ensures that deferred access checks are popped before*
8322	a function returns. /*
8323
8324	class deferring_access_check_sentinel
8325	{
8326	public:
8327	deferring_access_check_sentinel (enum deferring_kind kind = dk_deferred)
8328	{
8329	push_deferring_access_checks (kind);
8330	}
8331	~deferring_access_check_sentinel ()
8332	{
8333	pop_deferring_access_checks ();
8334	}
8335	};
8336
8337	extern int stmts_are_full_exprs_p (void);
8338	extern void init_cp_semantics (void);
8339	extern tree do_poplevel (tree);
8340	extern tree do_pushlevel (scope_kind);
8341	extern void break_maybe_infinite_loop (void);
8342	extern void add_decl_expr (tree);
8343	extern tree maybe_cleanup_point_expr_void (tree);
8344	extern tree finish_expr_stmt (tree);
8345	extern tree begin_if_stmt (void);
8346	extern tree finish_if_stmt_cond (tree, tree);
8347	extern tree finish_then_clause (tree);
8348	extern void begin_else_clause (tree);
8349	extern void finish_else_clause (tree);
8350	extern void finish_if_stmt (tree);
8351	extern tree begin_while_stmt (void);
8352	extern void finish_while_stmt_cond (tree, tree, bool, tree, bool);
8353	extern void finish_while_stmt (tree);
8354	extern tree begin_do_stmt (void);
8355	extern void finish_do_body (tree);
8356	extern void finish_do_stmt (tree, tree, bool, tree, bool);
8357	extern tree finish_return_stmt (tree);
8358	extern tree begin_for_scope (tree *);
8359	extern tree begin_for_stmt (tree, tree);
8360	extern void finish_init_stmt (tree);
8361	extern void finish_for_cond (tree, tree, bool, tree, bool);
8362	extern void finish_for_expr (tree, tree);
8363	extern void find_range_for_decls (tree[`3`]);
8364	extern void finish_for_stmt (tree);
8365	extern tree begin_range_for_stmt (tree, tree);
8366	extern void finish_range_for_decl (tree, tree, tree);
8367	extern tree begin_template_for_scope (tree *);
8368	extern tree finish_break_stmt (void);
8369	extern tree finish_continue_stmt (void);
8370	extern tree begin_switch_stmt (void);
8371	extern void finish_switch_cond (tree, tree);
8372	extern void finish_switch_stmt (tree);
8373	extern tree finish_goto_stmt (tree);
8374	extern tree begin_try_block (void);
8375	extern void finish_try_block (tree);
8376	extern void finish_handler_sequence (tree);
8377	extern tree begin_function_try_block (tree *);
8378	extern void finish_function_try_block (tree);
8379	extern void finish_function_handler_sequence (tree, tree);
8380	extern void finish_cleanup_try_block (tree);
8381	extern tree begin_handler (void);
8382	extern void finish_handler_parms (tree, tree);
8383	extern void finish_handler (tree);
8384	extern void finish_cleanup (tree, tree);
8385	extern bool is_this_parameter (tree);
8386	extern bool is_object_parameter (tree);
8387
8388	enum {
8389	BCS_NORMAL = `0`,
8390	BCS_NO_SCOPE = `1`,
8391	BCS_TRY_BLOCK = `2`,
8392	BCS_FN_BODY = `4`,
8393	BCS_TRANSACTION = `8`,
8394	BCS_STMT_EXPR = `16`
8395	};
8396	extern tree begin_compound_stmt (unsigned int);
8397
8398	extern void finish_compound_stmt (tree);
8399	extern tree finish_asm_string_expression (location_t, tree);
8400	extern tree finish_asm_stmt (location_t, int, tree, tree,
8401	tree, tree, tree, bool, bool);
8402	extern tree finish_label_stmt (tree);
8403	extern void finish_label_decl (tree);
8404	extern cp_expr finish_parenthesized_expr (cp_expr);
8405	extern tree force_paren_expr (tree, bool = false);
8406	inline tree force_paren_expr_uneval (tree t)
8407	{ return force_paren_expr (t, true); }
8408	extern tree maybe_undo_parenthesized_ref (tree);
8409	extern tree finish_non_static_data_member (tree, tree, tree,
8410	tsubst_flags_t = tf_warning_or_error);
8411	extern tree begin_stmt_expr (void);
8412	extern tree finish_stmt_expr_expr (tree, tree);
8413	extern tree finish_stmt_expr (tree, bool);
8414	extern tree stmt_expr_value_expr (tree);
8415	bool empty_expr_stmt_p (tree);
8416	extern cp_expr perform_koenig_lookup (cp_expr, vec<tree, va_gc> *,
8417	tsubst_flags_t);
8418	extern tree finish_call_expr (tree, vec<tree, va_gc> *, bool*,
8419	bool, tsubst_flags_t);
8420	extern tree lookup_and_finish_template_variable (tree, tree, tsubst_flags_t = tf_warning_or_error);
8421	extern tree finish_template_variable (tree, tsubst_flags_t = tf_warning_or_error);
8422	extern cp_expr finish_increment_expr (cp_expr, enum tree_code);
8423	extern tree finish_this_expr (void);
8424	extern tree finish_pseudo_destructor_expr (tree, tree, tree, location_t, tsubst_flags_t);
8425	extern cp_expr finish_unary_op_expr (location_t, enum tree_code, cp_expr,
8426	tsubst_flags_t);
8427	/ Whether this call to finish_compound_literal represents a C++11 functional*
8428	cast or a C99 compound literal. /*
8429	enum fcl_t { fcl_functional, fcl_c99 };
8430	extern tree finish_compound_literal (tree, tree, tsubst_flags_t, fcl_t = fcl_functional);
8431	extern tree finish_fname (tree);
8432	extern void finish_translation_unit (void);
8433	extern tree finish_template_type_parm (tree, tree);
8434	extern tree finish_template_template_parm (tree, tree);
8435	extern tree begin_class_definition (tree);
8436	extern void finish_template_decl (tree);
8437	extern tree finish_template_type (tree, tree, int);
8438	extern tree finish_base_specifier (tree, tree, bool, tree);
8439	extern void finish_member_declaration (tree);
8440	extern bool outer_automatic_var_p (tree);
8441	extern bool parsing_lambda_declarator ();
8442	extern tree process_outer_var_ref (tree, tsubst_flags_t, bool force_use = false);
8443	extern cp_expr finish_id_expression (tree, tree, tree,
8444	cp_id_kind *,
8445	bool, bool, bool *,
8446	bool, bool, bool, bool,
8447	const char **,
8448	location_t);
8449	extern tree finish_typeof (tree);
8450	extern tree finish_underlying_type (tree);
8451	extern tree calculate_bases (tree, tsubst_flags_t);
8452	extern tree finish_bases (tree, bool);
8453	extern tree calculate_direct_bases (tree, tsubst_flags_t);
8454	extern tree pack_index_element (tree, tree, bool,
8455	tsubst_flags_t);
8456	extern tree finish_offsetof (tree, tree, location_t);
8457	extern void finish_decl_cleanup (tree, tree);
8458	extern void finish_eh_cleanup (tree);
8459	extern void emit_associated_thunks (tree);
8460	extern void finish_mem_initializers (tree);
8461	extern tree check_template_template_default_arg (tree);
8462	extern bool expand_or_defer_fn_1 (tree);
8463	extern void expand_or_defer_fn (tree);
8464	extern bool check_accessibility_of_qualified_id (tree, tree, tree, tsubst_flags_t);
8465	extern tree finish_qualified_id_expr (tree, tree, bool, bool,
8466	bool, bool, tsubst_flags_t);
8467	extern void simplify_aggr_init_expr (tree *);
8468	extern void finalize_nrv (tree, tree);
8469	extern tree omp_reduction_id (enum tree_code, tree, tree);
8470	extern tree omp_mapper_id (tree, tree);
8471	extern tree cp_remove_omp_priv_cleanup_stmt (tree , int* , void* *);
8472	extern bool cp_check_omp_declare_reduction (tree);
8473	extern bool cp_check_omp_declare_mapper (tree);
8474	extern void finish_omp_declare_simd_methods (tree);
8475	extern tree cp_finish_omp_init_prefer_type (tree);
8476	extern tree finish_omp_clauses (tree, enum c_omp_region_type);
8477	extern tree omp_instantiate_mappers (tree);
8478	extern tree push_omp_privatization_clauses (bool);
8479	extern void pop_omp_privatization_clauses (tree);
8480	extern void save_omp_privatization_clauses (vec<tree> &);
8481	extern void restore_omp_privatization_clauses (vec<tree> &);
8482	extern void finish_omp_threadprivate (tree);
8483	extern tree begin_omp_structured_block (void);
8484	extern tree finish_omp_structured_block (tree);
8485	extern tree finish_oacc_data (tree, tree);
8486	extern tree finish_oacc_host_data (tree, tree);
8487	extern tree finish_omp_construct (enum tree_code, tree, tree);
8488	extern tree begin_omp_parallel (void);
8489	extern tree finish_omp_parallel (tree, tree);
8490	extern tree begin_omp_task (void);
8491	extern tree finish_omp_task (tree, tree);
8492	extern tree finish_omp_for (location_t, enum tree_code,
8493	tree, tree, tree, tree, tree,
8494	tree, tree, vec<tree> *, tree);
8495	extern tree finish_omp_for_block (tree, tree);
8496	extern void finish_omp_atomic (location_t, enum tree_code,
8497	enum tree_code, tree, tree,
8498	tree, tree, tree, tree, tree,
8499	enum omp_memory_order, bool);
8500	extern void finish_omp_barrier (void);
8501	extern void finish_omp_depobj (location_t, tree,
8502	enum omp_clause_depend_kind,
8503	tree);
8504	extern void finish_omp_flush (int);
8505	extern void finish_omp_taskwait (void);
8506	extern void finish_omp_taskyield (void);
8507	extern void finish_omp_cancel (tree);
8508	extern void finish_omp_cancellation_point (tree);
8509	extern tree omp_privatize_field (tree, bool);
8510	extern tree begin_transaction_stmt (location_t, tree , int*);
8511	extern void finish_transaction_stmt (tree, tree, int, tree);
8512	extern tree build_transaction_expr (location_t, tree, int, tree);
8513	extern bool cxx_omp_create_clause_info (tree, tree, bool, bool,
8514	bool, bool);
8515	extern tree baselink_for_fns (tree);
8516	extern void finish_static_assert (tree, tree, location_t,
8517	bool, bool, bool = false);
8518	extern tree finish_decltype_type (tree, bool, tsubst_flags_t);
8519	extern tree fold_builtin_is_corresponding_member (location_t, int, tree *);
8520	extern bool pointer_interconvertible_base_of_p (tree, tree, bool = false);
8521	extern tree fold_builtin_is_pointer_inverconvertible_with_class (location_t, int, tree *);
8522	extern tree fold_builtin_is_string_literal (location_t, int, tree *);
8523	extern tree finish_structured_binding_size (location_t, tree, tsubst_flags_t);
8524	extern tree finish_trait_expr (location_t, enum cp_trait_kind, tree, tree);
8525	extern tree finish_trait_type (enum cp_trait_kind, tree, tree, tsubst_flags_t);
8526	extern tree build_lambda_expr (void);
8527	extern tree build_lambda_object (tree);
8528	extern tree begin_lambda_type (tree);
8529	extern tree lambda_capture_field_type (tree, bool, bool);
8530	extern tree lambda_proxy_type (tree);
8531	extern tree lambda_function (tree);
8532	extern void apply_deduced_return_type (tree, tree);
8533	extern tree add_capture (tree, tree, tree, bool, bool, unsigned *);
8534	extern tree add_default_capture (tree, tree, tree);
8535	extern void insert_capture_proxy (tree);
8536	extern void insert_pending_capture_proxies (void);
8537	extern bool is_capture_proxy (tree);
8538	extern bool is_normal_capture_proxy (tree);
8539	extern tree strip_normal_capture_proxy (tree);
8540	extern bool is_constant_capture_proxy (tree);
8541	extern void register_capture_members (tree);
8542	extern tree lambda_expr_this_capture (tree, int);
8543	extern void maybe_generic_this_capture (tree, tree);
8544	extern tree maybe_resolve_dummy (tree, bool);
8545	extern tree current_nonlambda_function (bool = false);
8546	extern tree nonlambda_method_basetype (void);
8547	extern tree current_nonlambda_scope (bool = false);
8548	extern tree current_lambda_expr (void);
8549	extern bool generic_lambda_fn_p (tree);
8550	extern tree do_dependent_capture (tree, bool = false);
8551	extern bool lambda_fn_in_template_p (tree);
8552	extern void maybe_add_lambda_conv_op (tree);
8553	extern bool is_lambda_ignored_entity (tree);
8554	extern bool lambda_static_thunk_p (tree);
8555	extern bool call_from_lambda_thunk_p (tree);
8556	extern tree finish_builtin_launder (location_t, tree,
8557	tsubst_flags_t);
8558	extern tree cp_build_vec_convert (tree, location_t, tree,
8559	tsubst_flags_t);
8560	extern tree cp_build_bit_cast (location_t, tree, tree,
8561	tsubst_flags_t);
8562	extern void start_lambda_scope (tree decl);
8563	extern void finish_lambda_scope (void);
8564	extern void record_lambda_scope (tree lambda);
8565	extern void record_lambda_scope_discriminator (tree lambda);
8566	extern void record_lambda_scope_sig_discriminator (tree lambda, tree fn);
8567	extern tree start_lambda_function (tree fn, tree lambda_expr);
8568	extern void push_capture_proxies (tree, bool = false);
8569	extern void finish_lambda_function (tree body);
8570	extern bool regenerated_lambda_fn_p (tree);
8571	extern tree lambda_regenerating_args (tree);
8572	extern tree most_general_lambda (tree);
8573	extern tree finish_omp_target (location_t, tree, tree, bool);
8574	extern void finish_omp_target_clauses (location_t, tree, tree *);
8575	extern void maybe_warn_unparenthesized_assignment (tree, bool, tsubst_flags_t);
8576	extern tree cp_check_pragma_unroll (location_t, tree);
8577
8578	/ in tree.cc /
8579	extern int cp_tree_operand_length (const_tree);
8580	extern int cp_tree_code_length (enum tree_code);
8581	extern void cp_free_lang_data (tree t);
8582	extern tree force_target_expr (tree, tree, tsubst_flags_t);
8583	extern tree build_target_expr_with_type (tree, tree, tsubst_flags_t);
8584	extern void lang_check_failed (const char , int*,
8585	const char *) ATTRIBUTE_NORETURN
8586	ATTRIBUTE_COLD;
8587	extern tree stabilize_expr (tree, tree *);
8588	extern void stabilize_call (tree, tree *);
8589	extern bool stabilize_init (tree, tree *);
8590	extern tree add_stmt_to_compound (tree, tree);
8591	extern void init_tree (void);
8592	extern bool pod_type_p (const_tree);
8593	extern bool layout_pod_type_p (const_tree);
8594	extern bool std_layout_type_p (const_tree);
8595	extern bool trivial_type_p (const_tree);
8596	extern bool implicit_lifetime_type_p (tree);
8597	extern bool trivially_copyable_p (const_tree);
8598	extern bool type_has_unique_obj_representations (const_tree, bool = false);
8599	extern bool scalarish_type_p (const_tree);
8600	extern bool structural_type_p (tree, bool = false);
8601	extern bool type_has_nontrivial_default_init (const_tree);
8602	extern bool type_has_nontrivial_copy_init (const_tree);
8603	extern void maybe_warn_parm_abi (tree, location_t);
8604	extern bool class_tmpl_impl_spec_p (const_tree);
8605	extern int zero_init_p (const_tree);
8606	extern bool zero_init_expr_p (tree);
8607	extern bool check_abi_tag_redeclaration (const_tree, const_tree,
8608	const_tree);
8609	extern bool check_abi_tag_args (tree, tree);
8610	extern tree strip_typedefs (tree, bool * = NULL,
8611	unsigned int = `0`);
8612	extern tree strip_typedefs_expr (tree, bool * = NULL,
8613	unsigned int = `0`);
8614	extern tree copy_binfo (tree, tree, tree,
8615	tree , int*);
8616	extern int member_p (const_tree);
8617	extern cp_lvalue_kind real_lvalue_p (const_tree);
8618	extern cp_lvalue_kind lvalue_kind (const_tree);
8619	extern bool glvalue_p (const_tree);
8620	extern bool obvalue_p (const_tree);
8621	extern bool xvalue_p (const_tree);
8622	extern bool bitfield_p (const_tree);
8623	extern bool non_mergeable_glvalue_p (const_tree);
8624	extern tree cp_stabilize_reference (tree);
8625	extern bool builtin_valid_in_constant_expr_p (const_tree);
8626	extern tree build_min (enum tree_code, tree, ...);
8627	extern tree build_min_nt_loc (location_t, enum tree_code,
8628	...);
8629	extern tree build_min_non_dep (enum tree_code, tree, ...);
8630	extern tree build_min_non_dep_op_overload (enum tree_code, tree, tree, ...);
8631	extern tree build_min_non_dep_op_overload (tree, tree, tree,
8632	vec<tree, va_gc> *);
8633	extern tree build_min_nt_call_vec (tree, vec<tree, va_gc> *);
8634	extern tree build_min_non_dep_call_vec (tree, tree, vec<tree, va_gc> *);
8635	extern vec<tree, va_gc>* vec_copy_and_insert (vec<tree, va_gc>, tree, unsigned*);
8636	extern tree build_cplus_new (tree, tree, tsubst_flags_t);
8637	extern tree build_local_temp (tree);
8638	extern bool is_local_temp (tree);
8639	extern tree build_aggr_init_expr (tree, tree);
8640	extern tree get_target_expr (tree,
8641	tsubst_flags_t = tf_warning_or_error);
8642	extern tree get_internal_target_expr (tree);
8643	extern tree build_cplus_array_type (tree, tree, int is_dep = -`1`);
8644	extern tree build_array_of_n_type (tree, unsigned HOST_WIDE_INT);
8645	extern bool array_of_runtime_bound_p (tree);
8646	extern bool vla_type_p (tree);
8647	extern tree build_array_copy (tree);
8648	extern tree build_vec_init_expr (tree, tree, tsubst_flags_t);
8649	extern tree expand_vec_init_expr (tree, tree, tsubst_flags_t,
8650	vec<tree,va_gc> = nullptr**);
8651	extern void diagnose_non_constexpr_vec_init (tree);
8652	extern tree hash_tree_cons (tree, tree, tree);
8653	extern tree hash_tree_chain (tree, tree);
8654	extern tree build_qualified_name (tree, tree, tree, bool);
8655	extern tree build_ref_qualified_type (tree, cp_ref_qualifier);
8656	extern tree make_binding_vec (tree, unsigned clusters CXX_MEM_STAT_INFO);
8657	inline tree ovl_first (tree) ATTRIBUTE_PURE;
8658	extern tree ovl_make (tree fn,
8659	tree next = NULL_TREE);
8660	extern tree ovl_insert (tree fn, tree maybe_ovl,
8661	int using_or_hidden = `0`);
8662	extern tree ovl_skip_hidden (tree) ATTRIBUTE_PURE;
8663	extern void lookup_mark (tree lookup, bool val);
8664	extern tree lookup_add (tree fns, tree lookup);
8665	extern tree lookup_maybe_add (tree fns, tree lookup,
8666	bool deduping);
8667	extern int is_overloaded_fn (tree) ATTRIBUTE_PURE;
8668	extern bool really_overloaded_fn (tree) ATTRIBUTE_PURE;
8669	extern tree dependent_name (tree);
8670	extern tree call_expr_dependent_name (tree);
8671	extern tree maybe_get_fns (tree) ATTRIBUTE_PURE;
8672	extern tree get_fns (tree) ATTRIBUTE_PURE;
8673	extern tree get_first_fn (tree) ATTRIBUTE_PURE;
8674	extern tree maybe_get_first_fn (tree) ATTRIBUTE_PURE;
8675	extern tree ovl_scope (tree);
8676	extern const char cxx_printable_name (tree, int*);
8677	extern const char cxx_printable_name_translate (tree, int*);
8678	extern tree canonical_eh_spec (tree);
8679	extern tree build_cp_fntype_variant (tree, cp_ref_qualifier, tree, bool);
8680	extern tree build_exception_variant (tree, tree);
8681	extern void fixup_deferred_exception_variants (tree, tree);
8682	extern tree bind_template_template_parm (tree, tree);
8683	extern tree array_type_nelts_total (tree);
8684	extern bool array_of_unknown_bound_p (const_tree);
8685	extern tree break_out_target_exprs (tree, bool = false);
8686	extern tree build_ctor_subob_ref (tree, tree, tree);
8687	extern tree replace_placeholders (tree, tree, bool * = NULL);
8688	extern bool find_placeholders (tree);
8689	extern tree get_type_decl (tree);
8690	extern tree decl_namespace_context (tree);
8691	extern bool decl_anon_ns_mem_p (tree);
8692	extern bool decl_internal_context_p (const_tree);
8693	extern tree lvalue_type (tree);
8694	extern tree error_type (tree);
8695	extern int varargs_function_p (const_tree);
8696	extern bool cp_tree_equal (tree, tree);
8697	extern tree no_linkage_check (tree, bool);
8698	extern void debug_binfo (tree);
8699	extern tree build_dummy_object (tree);
8700	extern tree maybe_dummy_object (tree, tree *);
8701	extern bool is_dummy_object (const_tree);
8702	extern bool is_byte_access_type (tree);
8703	extern bool is_byte_access_type_not_plain_char (tree);
8704	extern const struct scoped_attribute_specs cxx_gnu_attribute_table;
8705	extern const struct scoped_attribute_specs std_attribute_table;
8706	extern const struct scoped_attribute_specs internal_attribute_table;
8707	extern tree make_ptrmem_cst (tree, tree);
8708	extern tree cp_build_type_attribute_variant (tree, tree);
8709	extern tree cp_build_reference_type (tree, bool);
8710	extern tree move (tree);
8711	extern tree cp_build_qualified_type (tree, int,
8712	tsubst_flags_t = tf_warning_or_error);
8713	extern tree cp_build_function_type (tree, tree);
8714	extern bool cv_qualified_p (const_tree);
8715	extern tree cv_unqualified (tree);
8716	extern special_function_kind special_function_p (const_tree);
8717	extern special_function_kind special_memfn_p (const_tree);
8718	extern int count_trees (tree);
8719	extern int char_type_p (tree);
8720	extern void verify_stmt_tree (tree);
8721	extern linkage_kind decl_linkage (tree);
8722	extern duration_kind decl_storage_duration (tree);
8723	extern tree cp_walk_subtrees (tree, int**, walk_tree_fn,
8724	void, hash_set<tree> );
8725	#define cp_walk_tree(tp,func,data,pset) \
8726	walk_tree_1 (tp, func, data, pset, cp_walk_subtrees)
8727	#define cp_walk_tree_without_duplicates(tp,func,data) \
8728	walk_tree_without_duplicates_1 (tp, func, data, cp_walk_subtrees)
8729	extern tree rvalue (tree);
8730	extern tree convert_bitfield_to_declared_type (tree);
8731	extern tree cp_save_expr (tree);
8732	extern bool cast_valid_in_integral_constant_expression_p (tree);
8733	extern bool cxx_type_hash_eq (const_tree, const_tree);
8734	extern tree cxx_copy_lang_qualifiers (const_tree, const_tree);
8735
8736	extern void cxx_print_statistics (void);
8737	extern bool maybe_warn_zero_as_null_pointer_constant (tree, location_t);
8738	extern bool annotation_p (tree) ATTRIBUTE_PURE;
8739
8740	/ in ptree.cc /
8741	extern void cxx_print_xnode (FILE , tree, int*);
8742	extern void cxx_print_decl (FILE , tree, int*);
8743	extern void cxx_print_type (FILE , tree, int*);
8744	extern void cxx_print_identifier (FILE , tree, int*);
8745	extern void cxx_print_error_function (diagnostics::text_sink &,
8746	const char *,
8747	const diagnostics::diagnostic_info *);
8748
8749	/ in typeck.cc /
8750	/ Says how we should behave when comparing two arrays one of which*
8751	has unknown bounds. /*
8752	enum compare_bounds_t { bounds_none, bounds_either, bounds_first };
8753
8754	extern bool cxx_mark_addressable (tree, bool = false);
8755	extern int string_conv_p (const_tree, const_tree, int);
8756	extern tree cp_truthvalue_conversion (tree, tsubst_flags_t);
8757	extern tree contextual_conv_bool (tree, tsubst_flags_t);
8758	extern tree condition_conversion (tree);
8759	extern tree require_complete_type (tree,
8760	tsubst_flags_t = tf_warning_or_error);
8761	extern tree complete_type (tree);
8762	extern tree complete_type_or_else (tree, tree);
8763	extern tree complete_type_or_maybe_complain (tree, tree, tsubst_flags_t);
8764	extern int cp_compare_floating_point_conversion_ranks (tree, tree);
8765	inline bool type_unknown_p (const_tree);
8766	enum { ce_derived, ce_type, ce_normal, ce_exact };
8767	extern bool comp_except_specs (const_tree, const_tree, int);
8768	extern bool comptypes (tree, tree, int);
8769	extern bool same_type_ignoring_top_level_qualifiers_p (tree, tree);
8770	extern bool similar_type_p (tree, tree);
8771	extern bool cp_comp_parm_types (tree, tree);
8772	extern bool next_common_initial_sequence (tree &, tree &);
8773	extern bool layout_compatible_type_p (tree, tree, bool = false);
8774	extern bool compparms (const_tree, const_tree);
8775	extern int comp_cv_qualification (const_tree, const_tree);
8776	extern int comp_cv_qualification (int, int);
8777	extern int comp_cv_qual_signature (tree, tree);
8778	extern tree cxx_sizeof_or_alignof_expr (location_t, tree,
8779	enum tree_code, bool, bool);
8780	extern tree cxx_sizeof_or_alignof_type (location_t, tree,
8781	enum tree_code, bool, bool);
8782	extern tree cxx_alignas_expr (tree);
8783	extern tree cxx_sizeof_nowarn (tree);
8784	extern tree is_bitfield_expr_with_lowered_type (const_tree);
8785	extern tree unlowered_expr_type (const_tree);
8786	extern tree decay_conversion (tree,
8787	tsubst_flags_t,
8788	bool = true);
8789	extern tree build_class_member_access_expr (cp_expr, tree, tree, bool,
8790	tsubst_flags_t);
8791	extern tree finish_class_member_access_expr (cp_expr, tree, bool,
8792	tsubst_flags_t, bool = false);
8793	extern tree lookup_destructor (tree, tree, tree, tsubst_flags_t);
8794	extern tree build_dependent_operator_type (tree, enum tree_code, bool);
8795	extern tree build_x_indirect_ref (location_t, tree,
8796	ref_operator, tree,
8797	tsubst_flags_t);
8798	extern tree cp_build_indirect_ref (location_t, tree,
8799	ref_operator,
8800	tsubst_flags_t);
8801	extern tree cp_build_fold_indirect_ref (tree);
8802	extern tree build_array_ref (location_t, tree, tree);
8803	extern tree cp_build_array_ref (location_t, tree, tree,
8804	tsubst_flags_t);
8805	extern tree get_member_function_from_ptrfunc (tree *, tree, tsubst_flags_t);
8806	extern tree cp_build_function_call_nary (tree, tsubst_flags_t, ...)
8807	ATTRIBUTE_SENTINEL;
8808	extern tree cp_build_function_call_vec (tree, vec<tree, va_gc> **,
8809	tsubst_flags_t,
8810	tree = NULL_TREE);
8811	extern tree build_x_binary_op (const op_location_t &,
8812	enum tree_code, tree,
8813	enum tree_code, tree,
8814	enum tree_code, tree,
8815	tree *, tsubst_flags_t);
8816	inline tree build_x_binary_op (const op_location_t &loc,
8817	enum tree_code code, tree arg1, tree arg2,
8818	tsubst_flags_t complain)
8819	{
8820	return build_x_binary_op (loc, code, arg1, TREE_CODE (arg1), arg2,
8821	TREE_CODE (arg2), NULL_TREE, NULL, complain);
8822	}
8823	extern tree build_x_array_ref (location_t, tree, tree,
8824	tsubst_flags_t);
8825	extern tree build_omp_array_section (location_t, tree, tree, tree);
8826	extern tree build_x_unary_op (location_t,
8827	enum tree_code, cp_expr,
8828	tree, tsubst_flags_t);
8829	extern tree cp_build_addressof (location_t, tree,
8830	tsubst_flags_t);
8831	extern tree cp_build_addr_expr (tree, tsubst_flags_t);
8832	extern tree cp_build_unary_op (enum tree_code, tree, bool,
8833	tsubst_flags_t);
8834	extern tree genericize_compound_lvalue (tree);
8835	extern tree unary_complex_lvalue (enum tree_code, tree);
8836	extern tree build_x_conditional_expr (location_t, tree, tree, tree,
8837	tsubst_flags_t);
8838	extern tree build_x_compound_expr_from_list (tree, expr_list_kind,
8839	tsubst_flags_t);
8840	extern tree build_x_compound_expr_from_vec (vec<tree, va_gc> *,
8841	const char *, tsubst_flags_t);
8842	extern tree build_x_compound_expr (location_t, tree, tree,
8843	tree, tsubst_flags_t);
8844	extern tree build_compound_expr (location_t, tree, tree);
8845	extern tree cp_build_compound_expr (tree, tree, tsubst_flags_t);
8846	extern tree build_static_cast (location_t, tree, tree,
8847	tsubst_flags_t);
8848	extern tree build_reinterpret_cast (location_t, tree, tree,
8849	tsubst_flags_t);
8850	extern tree build_const_cast (location_t, tree, tree,
8851	tsubst_flags_t);
8852	extern tree build_c_cast (location_t, tree, tree);
8853	extern cp_expr build_c_cast (location_t loc, tree type,
8854	cp_expr expr);
8855	extern tree cp_build_c_cast (location_t, tree, tree,
8856	tsubst_flags_t);
8857	extern bool maybe_warn_self_move (location_t, tree, tree);
8858	extern cp_expr build_x_modify_expr (location_t, tree,
8859	enum tree_code, tree,
8860	tree, tsubst_flags_t);
8861	extern tree cp_build_modify_expr (location_t, tree,
8862	enum tree_code, tree,
8863	tsubst_flags_t);
8864	extern tree convert_for_initialization (tree, tree, tree, int,
8865	impl_conv_rhs, tree, int,
8866	tsubst_flags_t);
8867	extern int comp_ptr_ttypes (tree, tree);
8868	extern bool comp_ptr_ttypes_const (tree, tree, compare_bounds_t);
8869	extern bool error_type_p (const_tree);
8870	extern bool ptr_reasonably_similar (const_tree, const_tree);
8871	extern tree build_ptrmemfunc (tree, tree, int, bool,
8872	tsubst_flags_t);
8873	extern int cp_type_quals (const_tree);
8874	extern int type_memfn_quals (const_tree);
8875	extern cp_ref_qualifier type_memfn_rqual (const_tree);
8876	extern tree apply_memfn_quals (tree, cp_cv_quals,
8877	cp_ref_qualifier = REF_QUAL_NONE);
8878	extern bool cp_has_mutable_p (const_tree);
8879	extern bool at_least_as_qualified_p (const_tree, const_tree);
8880	extern void cp_apply_type_quals_to_decl (int, tree);
8881	extern tree build_ptrmemfunc1 (tree, tree, tree);
8882	extern void expand_ptrmemfunc_cst (tree, tree , tree );
8883	extern tree type_after_usual_arithmetic_conversions (tree, tree);
8884	extern tree common_pointer_type (tree, tree);
8885	extern tree composite_pointer_type (const op_location_t &,
8886	tree, tree, tree, tree,
8887	composite_pointer_operation,
8888	tsubst_flags_t);
8889	extern tree merge_types (tree, tree);
8890	extern tree strip_array_domain (tree);
8891	extern tree check_return_expr (tree, bool , bool* *);
8892	extern tree spaceship_type (tree, tsubst_flags_t = tf_warning_or_error);
8893	extern tree genericize_spaceship (location_t, tree, tree, tree);
8894	extern tree cp_build_binary_op (const op_location_t &,
8895	enum tree_code, tree, tree,
8896	tsubst_flags_t);
8897	extern tree build_x_vec_perm_expr (location_t,
8898	tree, tree, tree,
8899	tsubst_flags_t);
8900	extern tree build_x_shufflevector (location_t,
8901	vec<tree, va_gc> *,
8902	tsubst_flags_t);
8903	#define cxx_sizeof(T) cxx_sizeof_or_alignof_type (input_location, T, SIZEOF_EXPR, false, true)
8904	extern tree build_simple_component_ref (tree, tree);
8905	extern tree build_ptrmemfunc_access_expr (tree, tree);
8906	extern tree build_address (tree);
8907	extern tree build_nop (tree, tree CXX_MEM_STAT_INFO);
8908	extern tree non_reference (tree);
8909	extern tree lookup_anon_field (tree, tree);
8910	extern bool invalid_nonstatic_memfn_p (location_t, tree,
8911	tsubst_flags_t);
8912	extern tree convert_member_func_to_ptr (tree, tree, tsubst_flags_t);
8913	extern tree convert_ptrmem (tree, tree, bool, bool,
8914	tsubst_flags_t);
8915	extern int lvalue_or_else (tree, enum lvalue_use,
8916	tsubst_flags_t);
8917	extern void check_template_keyword (tree);
8918	extern bool check_raw_literal_operator (const_tree decl);
8919	extern bool check_literal_operator_args (const_tree, bool , bool* *);
8920	extern void maybe_warn_about_useless_cast (location_t, tree, tree,
8921	tsubst_flags_t);
8922	extern tree cp_perform_integral_promotions (tree, tsubst_flags_t);
8923
8924	extern tree finish_left_unary_fold_expr (location_t, tree, int);
8925	extern tree finish_right_unary_fold_expr (location_t, tree, int);
8926	extern tree finish_binary_fold_expr (location_t, tree, tree, int);
8927	extern tree treat_lvalue_as_rvalue_p (tree, bool);
8928	extern bool decl_in_std_namespace_p (tree);
8929	extern void maybe_warn_pessimizing_move (tree, tree, bool);
8930
8931	/ in typeck2.cc /
8932	extern void require_complete_eh_spec_types (tree, tree);
8933	extern bool cxx_incomplete_type_diagnostic (location_t, const_tree,
8934	const_tree, enum diagnostics::kind);
8935	inline location_t
8936	loc_or_input_loc (location_t loc)
8937	{
8938	return loc == UNKNOWN_LOCATION ? input_location : loc;
8939	}
8940
8941	/ Like EXPR_LOCATION, but also handle some tcc_exceptional that have*
8942	locations. /*
8943
8944	inline location_t
8945	cp_expr_location (const_tree t_)
8946	{
8947	tree t = const_cast<tree> (t_);
8948	if (t == NULL_TREE)
8949	return UNKNOWN_LOCATION;
8950	switch (TREE_CODE (t))
8951	{
8952	case LAMBDA_EXPR:
8953	return LAMBDA_EXPR_LOCATION (t);
8954	case STATIC_ASSERT:
8955	return STATIC_ASSERT_SOURCE_LOCATION (t);
8956	case TRAIT_EXPR:
8957	return TRAIT_EXPR_LOCATION (t);
8958	case PTRMEM_CST:
8959	return PTRMEM_CST_LOCATION (t);
8960	default:
8961	return EXPR_LOCATION (t);
8962	}
8963	}
8964
8965	inline location_t
8966	cp_expr_loc_or_loc (const_tree t, location_t or_loc)
8967	{
8968	location_t loc = cp_expr_location (t_: t);
8969	if (loc == UNKNOWN_LOCATION)
8970	loc = or_loc;
8971	return loc;
8972	}
8973
8974	inline location_t
8975	cp_expr_loc_or_input_loc (const_tree t)
8976	{
8977	return cp_expr_loc_or_loc (t, or_loc: input_location);
8978	}
8979
8980	inline bool
8981	cxx_incomplete_type_diagnostic (const_tree value, const_tree type,
8982	enum diagnostics::kind diag_kind)
8983	{
8984	return cxx_incomplete_type_diagnostic (cp_expr_loc_or_input_loc (t: value),
8985	value, type, diag_kind);
8986	}
8987
8988	extern void cxx_incomplete_type_error (location_t, const_tree,
8989	const_tree);
8990	inline void
8991	cxx_incomplete_type_error (const_tree value, const_tree type)
8992	{
8993	cxx_incomplete_type_diagnostic (value, type, diag_kind: diagnostics::kind::error);
8994	}
8995
8996	extern void cxx_incomplete_type_inform (const_tree);
8997	extern tree error_not_base_type (tree, tree);
8998	extern tree binfo_or_else (tree, tree);
8999	extern void cxx_readonly_error (location_t, tree,
9000	enum lvalue_use);
9001	extern void complete_type_check_abstract (tree);
9002	extern int abstract_virtuals_error (tree, tree,
9003	tsubst_flags_t = tf_warning_or_error);
9004	extern int abstract_virtuals_error (abstract_class_use, tree,
9005	tsubst_flags_t = tf_warning_or_error);
9006
9007	extern tree store_init_value (tree, tree, vec<tree, va_gc>*, int*);
9008	extern tree build_disable_temp_cleanup (tree);
9009	extern tree split_nonconstant_init (tree, tree);
9010	extern bool check_narrowing (tree, tree, tsubst_flags_t,
9011	bool = false);
9012	extern bool ordinary_char_type_p (tree);
9013	extern bool array_string_literal_compatible_p (tree, tree);
9014	extern tree digest_init (tree, tree, tsubst_flags_t);
9015	extern tree digest_init_flags (tree, tree, int, tsubst_flags_t);
9016	extern tree digest_nsdmi_init (tree, tree, tsubst_flags_t);
9017	extern tree build_scoped_ref (tree, tree, tree *);
9018	extern tree build_x_arrow (location_t, tree,
9019	tsubst_flags_t);
9020	extern tree build_m_component_ref (tree, tree, tsubst_flags_t);
9021	extern tree build_functional_cast (location_t, tree, tree,
9022	tsubst_flags_t);
9023	extern tree add_exception_specifier (tree, tree, tsubst_flags_t);
9024	extern tree merge_exception_specifiers (tree, tree);
9025	extern void set_target_expr_eliding (tree);
9026	extern tree cp_build_init_expr (location_t, tree, tree);
9027	inline tree cp_build_init_expr (tree t, tree i)
9028	{ return cp_build_init_expr (input_location, t, i); }
9029
9030	/ in mangle.cc /
9031	extern void init_mangle (void);
9032	extern void mangle_decl (tree);
9033	extern const char *mangle_type_string (tree);
9034	extern tree mangle_typeinfo_for_type (tree);
9035	extern tree mangle_typeinfo_string_for_type (tree);
9036	extern tree mangle_vtbl_for_type (tree);
9037	extern tree mangle_vtt_for_type (tree);
9038	extern tree mangle_ctor_vtbl_for_type (tree, tree);
9039	extern tree mangle_thunk (tree, int, tree, tree, tree);
9040	extern tree mangle_guard_variable (tree);
9041	extern tree mangle_tls_init_fn (tree);
9042	extern tree mangle_tls_wrapper_fn (tree);
9043	extern bool decl_tls_wrapper_p (tree);
9044	extern tree mangle_ref_init_variable (tree);
9045	extern tree mangle_template_parm_object (tree);
9046	extern char *get_mangled_vtable_map_var_name (tree);
9047	extern bool mangle_return_type_p (tree);
9048	extern tree mangle_decomp (tree, vec<tree> &);
9049	extern void mangle_module_substitution (int);
9050	extern int mangle_module_component (tree id, bool partition);
9051	extern tree mangle_module_global_init (int);
9052	extern unsigned HOST_WIDE_INT range_expr_nelts (tree);
9053	extern bool equal_abi_tags (tree, tree);
9054
9055	/ in dump.cc /
9056	extern bool cp_dump_tree (void *, tree);
9057
9058	/ In cp/cp-objcp-common.cc. /
9059
9060	extern alias_set_type cxx_get_alias_set (tree);
9061	extern bool cxx_warn_unused_global_decl (const_tree);
9062	extern size_t cp_tree_size (enum tree_code);
9063	extern bool cp_var_mod_type_p (tree, tree);
9064	extern void cxx_initialize_diagnostics (diagnostics::context *);
9065	extern int cxx_types_compatible_p (tree, tree);
9066	extern bool cxx_block_may_fallthru (const_tree);
9067
9068	/ in cp-gimplify.cc /
9069	extern int cp_gimplify_expr (tree , gimple_seq ,
9070	gimple_seq *);
9071	extern void cp_genericize (tree);
9072	extern bool cxx_omp_const_qual_no_mutable (tree);
9073	extern enum omp_clause_default_kind cxx_omp_predetermined_sharing_1 (tree);
9074	extern enum omp_clause_default_kind cxx_omp_predetermined_sharing (tree);
9075	extern enum omp_clause_defaultmap_kind cxx_omp_predetermined_mapping (tree);
9076	extern tree cxx_omp_clause_default_ctor (tree, tree, tree);
9077	extern tree cxx_omp_clause_copy_ctor (tree, tree, tree);
9078	extern tree cxx_omp_clause_assign_op (tree, tree, tree);
9079	extern tree cxx_omp_clause_dtor (tree, tree);
9080	extern void cxx_omp_finish_clause (tree, gimple_seq , bool*);
9081	extern tree cxx_omp_finish_mapper_clauses (tree);
9082	extern tree cxx_omp_mapper_lookup (tree, tree);
9083	extern tree cxx_omp_extract_mapper_directive (tree);
9084	extern tree cxx_omp_map_array_section (location_t, tree);
9085	extern bool cxx_omp_privatize_by_reference (const_tree);
9086	extern bool cxx_omp_disregard_value_expr (tree, bool);
9087	extern void cp_fold_function (tree);
9088	extern void cp_fold_function_non_odr_use (tree);
9089	extern tree cp_fold_maybe_rvalue (tree, bool);
9090	extern tree cp_fold_rvalue (tree);
9091	extern tree cp_fold_non_odr_use (tree, bool);
9092	extern tree cp_fully_fold (tree);
9093	extern tree cp_fully_fold_init (tree);
9094	extern tree predeclare_vla (tree);
9095	extern void clear_fold_cache (void);
9096	extern tree lookup_hotness_attribute (tree);
9097	extern tree process_stmt_hotness_attribute (tree, location_t);
9098	extern tree build_assume_call (location_t, tree);
9099	extern tree process_stmt_assume_attribute (tree, tree, location_t);
9100	extern bool simple_empty_class_p (tree, tree, tree_code);
9101	extern tree build_source_location_impl (location_t, tree, tree);
9102	extern tree fold_builtin_source_location (const_tree);
9103	extern tree get_source_location_impl_type ();
9104	extern bool immediate_escalating_function_p (tree);
9105	extern void promote_function_to_consteval (tree);
9106	extern tree cp_fold_immediate (tree *, mce_value,
9107	tree = current_function_decl);
9108	extern void process_and_check_pending_immediate_escalating_fns ();
9109	extern bool is_invisiref_parm (const_tree);
9110
9111	/ in name-lookup.cc /
9112	extern tree strip_using_decl (tree);
9113	extern void diagnose_name_conflict (tree, tree);
9114	extern bool dependent_local_decl_p (tree);
9115
9116	/ Tell the binding oracle what kind of binding we are looking for. /
9117
9118	enum cp_oracle_request
9119	{
9120	CP_ORACLE_IDENTIFIER
9121	};
9122
9123	/ If this is non-NULL, then it is a "binding oracle" which can lazily*
9124	create bindings when needed by the C compiler. The oracle is told
9125	the name and type of the binding to create. It can call pushdecl
9126	or the like to ensure the binding is visible; or do nothing,
9127	leaving the binding untouched. c-decl.cc takes note of when the
9128	oracle has been called and will not call it again if it fails to
9129	create a given binding. /*
9130
9131	typedef void cp_binding_oracle_function (enum cp_oracle_request, tree identifier);
9132
9133	extern cp_binding_oracle_function *cp_binding_oracle;
9134
9135	/ Set during diagnostics to record the failed constraint. This is a*
9136	TREE_LIST whose VALUE is the constraint and whose PURPOSE are the
9137	instantiation arguments Defined in pt.cc. /*
9138
9139	extern tree current_failed_constraint;
9140
9141	/ An RAII class to manage the failed constraint. /
9142
9143	struct diagnosing_failed_constraint
9144	{
9145	diagnosing_failed_constraint (tree, tree, bool);
9146	~diagnosing_failed_constraint ();
9147	static bool replay_errors_p ();
9148
9149	bool diagnosing_error;
9150	};
9151
9152	/ in constraint.cc /
9153
9154	extern cp_expr finish_constraint_or_expr (location_t, cp_expr, cp_expr);
9155	extern cp_expr finish_constraint_and_expr (location_t, cp_expr, cp_expr);
9156	extern cp_expr finish_constraint_primary_expr (cp_expr);
9157	extern tree start_concept_definition (cp_expr);
9158	extern tree finish_concept_definition (tree, tree, tree);
9159	extern tree combine_constraint_expressions (tree, tree);
9160	extern tree append_constraint (tree, tree);
9161	extern tree get_constraints (const_tree);
9162	extern void set_constraints (tree, tree);
9163	extern void remove_constraints (tree);
9164	extern tree current_template_constraints (void);
9165	extern tree associate_classtype_constraints (tree);
9166	extern tree build_constraints (tree, tree);
9167	extern tree maybe_substitute_reqs_for (tree, const_tree);
9168	extern tree get_trailing_function_requirements (tree);
9169	extern tree get_shorthand_constraints (tree);
9170
9171	extern tree build_concept_id (tree);
9172	extern tree build_type_constraint (tree, tree, tsubst_flags_t);
9173	extern tree build_concept_check (tree, tree, tsubst_flags_t);
9174	extern tree build_concept_check (tree, tree, tree, tsubst_flags_t);
9175
9176	extern tree build_constrained_parameter (tree, tree, tree = NULL_TREE);
9177	extern bool equivalent_placeholder_constraints (tree, tree);
9178	extern hashval_t iterative_hash_placeholder_constraint (tree, hashval_t);
9179	extern tree finish_shorthand_constraint (tree, tree);
9180	extern tree finish_requires_expr (location_t, tree, tree);
9181	extern tree finish_simple_requirement (location_t, tree);
9182	extern tree finish_type_requirement (location_t, tree);
9183	extern tree finish_compound_requirement (location_t, tree, tree, bool);
9184	extern tree finish_nested_requirement (location_t, tree);
9185	extern tree tsubst_requires_expr (tree, tree, tsubst_flags_t, tree);
9186	extern tree evaluate_requires_expr (tree);
9187	extern tree tsubst_constraint (tree, tree, tsubst_flags_t, tree);
9188	extern tree tsubst_constraint_info (tree, tree, tsubst_flags_t, tree);
9189	extern tree tsubst_parameter_mapping (tree, tree, tsubst_flags_t, tree);
9190
9191	struct processing_constraint_expression_sentinel
9192	{
9193	processing_constraint_expression_sentinel ();
9194	~processing_constraint_expression_sentinel ();
9195	};
9196
9197	extern bool processing_constraint_expression_p ();
9198
9199	extern tree get_concept_check_template (tree);
9200	extern tree evaluate_concept_check (tree);
9201	extern bool constraints_satisfied_p (tree, tree = NULL_TREE);
9202	extern bool* lookup_subsumption_result (tree, tree);
9203	extern bool save_subsumption_result (tree, tree, bool);
9204	extern tree find_template_parameters (tree, tree);
9205	extern bool equivalent_constraints (tree, tree);
9206	extern bool equivalently_constrained (tree, tree);
9207	extern bool strictly_subsumes (tree, tree);
9208	extern bool ttp_subsumes (tree, tree);
9209	extern int more_constrained (tree, tree);
9210	extern bool at_least_as_constrained (tree, tree);
9211	extern bool constraints_equivalent_p (tree, tree);
9212	extern bool atomic_constraints_identical_p (tree, tree);
9213	extern hashval_t iterative_hash_constraint (tree, hashval_t);
9214	extern hashval_t hash_atomic_constraint (tree);
9215	extern void diagnose_trait_expr (location_t, tree, tree);
9216	extern bool maybe_diagnose_standard_trait (location_t, tree);
9217	extern void diagnose_constraints (location_t, tree, tree);
9218
9219	extern void note_failed_type_completion (tree, tsubst_flags_t);
9220	extern location_t failed_completion_location (tree);
9221
9222	/ in logic.cc /
9223	extern bool subsumes (tree, tree);
9224
9225	/ In class.cc /
9226	extern void set_current_access_from_decl (tree);
9227	extern void cp_finish_injected_record_type (tree);
9228
9229	/ in vtable-class-hierarchy.cc /
9230	extern void vtv_compute_class_hierarchy_transitive_closure (void);
9231	extern void vtv_generate_init_routine (void);
9232	extern void vtv_save_class_info (tree);
9233	extern void vtv_recover_class_info (void);
9234	extern void vtv_build_vtable_verify_fndecl (void);
9235
9236	/ In constexpr.cc /
9237	/ Representation of entries in the constexpr function definition table. /
9238
9239	struct GTY((for_user)) constexpr_fundef {
9240	tree decl;
9241	tree body;
9242	tree parms;
9243	tree result;
9244	};
9245
9246	extern void fini_constexpr (void);
9247	extern bool literal_type_p (tree);
9248	extern void maybe_save_constexpr_fundef (tree);
9249	extern void register_constexpr_fundef (const constexpr_fundef &);
9250	extern constexpr_fundef *retrieve_constexpr_fundef (tree);
9251	extern bool is_valid_constexpr_fn (tree, bool);
9252	extern bool check_constexpr_ctor_body (tree, tree, bool);
9253	extern tree constexpr_fn_retval (tree);
9254	extern tree ensure_literal_type_for_constexpr_object (tree);
9255	extern bool potential_constant_expression (tree);
9256	extern bool is_constant_expression (tree);
9257	extern bool is_rvalue_constant_expression (tree);
9258	extern bool is_nondependent_constant_expression (tree);
9259	extern bool is_nondependent_static_init_expression (tree);
9260	extern bool is_static_init_expression (tree);
9261	extern bool is_std_class (tree, const char *);
9262	extern bool is_std_allocator (tree);
9263	extern bool potential_rvalue_constant_expression (tree);
9264	extern bool require_potential_constant_expression (tree);
9265	extern bool require_constant_expression (tree);
9266	extern bool require_rvalue_constant_expression (tree);
9267	extern bool require_potential_rvalue_constant_expression (tree);
9268	extern bool require_potential_rvalue_constant_expression_fncheck (tree);
9269	extern tree cxx_constant_value (tree, tree = NULL_TREE,
9270	tsubst_flags_t = tf_error);
9271	inline tree cxx_constant_value (tree t, tsubst_flags_t complain)
9272	{ return cxx_constant_value (t, NULL_TREE, complain); }
9273	extern void cxx_constant_dtor (tree, tree);
9274	extern tree cxx_constant_init (tree, tree = NULL_TREE);
9275	extern tree maybe_constant_value (tree, tree = NULL_TREE, mce_value = mce_unknown);
9276	extern tree maybe_constant_init (tree, tree = NULL_TREE, bool = false);
9277	extern tree maybe_constant_init (tree, tree, mce_value);
9278	extern tree fold_non_dependent_expr (tree,
9279	tsubst_flags_t = tf_warning_or_error,
9280	bool = false, tree = NULL_TREE);
9281	extern tree maybe_fold_non_dependent_expr (tree,
9282	tsubst_flags_t = tf_warning_or_error);
9283	extern tree fold_non_dependent_init (tree,
9284	tsubst_flags_t = tf_warning_or_error,
9285	bool = false, tree = NULL_TREE);
9286	extern tree fold_simple (tree);
9287	extern tree fold_to_constant (tree);
9288	extern bool reduced_constant_expression_p (tree, tree = NULL_TREE);
9289	extern bool is_instantiation_of_constexpr (tree);
9290	extern bool var_in_constexpr_fn (tree);
9291	extern bool var_in_maybe_constexpr_fn (tree);
9292	extern bool maybe_constexpr_fn (tree);
9293	extern void explain_invalid_constexpr_fn (tree);
9294	extern vec<tree> cx_error_context (void);
9295	extern tree fold_sizeof_expr (tree);
9296	extern void clear_cv_and_fold_caches (void);
9297	extern tree unshare_constructor (tree CXX_MEM_STAT_INFO);
9298	extern bool decl_implicit_constexpr_p (tree);
9299	struct constexpr_ctx;
9300	extern tree find_failing_clause (const constexpr_ctx *ctx, tree);
9301	extern void diagnose_failing_condition (tree, location_t, bool,
9302	const constexpr_ctx * = nullptr);
9303	extern bool replace_decl (tree *, tree, tree);
9304	extern tree cxa_allocate_and_throw_exception (location_t, const constexpr_ctx *,
9305	tree);
9306
9307	/ Whether our evaluation wants a prvalue (e.g. CONSTRUCTOR or _CST),*
9308	a glvalue (e.g. VAR_DECL or _REF), or nothing. /*
9309	enum value_cat {
9310	vc_prvalue = `0`,
9311	vc_glvalue = `1`,
9312	vc_discard = `2`
9313	};
9314
9315	extern tree cxx_eval_constant_expression (const constexpr_ctx *, tree,
9316	value_cat, bool , bool* *,
9317	tree *);
9318	extern bool cxx_constexpr_quiet_p (const constexpr_ctx *);
9319	extern mce_value cxx_constexpr_manifestly_const_eval (const constexpr_ctx *);
9320	extern tree cxx_constexpr_caller (const constexpr_ctx *);
9321	extern tree cxx_constexpr_consteval_block (const constexpr_ctx *);
9322
9323	/ An RAII sentinel used to restrict constexpr evaluation so that it*
9324	doesn't do anything that causes extra DECL_UID generation. /*
9325
9326	struct uid_sensitive_constexpr_evaluation_sentinel
9327	{
9328	temp_override<bool> ovr;
9329	uid_sensitive_constexpr_evaluation_sentinel ();
9330	};
9331
9332	/ Used to determine whether uid_sensitive_constexpr_evaluation_p was*
9333	called and returned true, indicating that we've restricted constexpr
9334	evaluation in order to avoid UID generation. We use this to control
9335	updates to the fold_cache and cv_cache. /*
9336
9337	struct uid_sensitive_constexpr_evaluation_checker
9338	{
9339	const unsigned saved_counter;
9340	uid_sensitive_constexpr_evaluation_checker ();
9341	bool evaluation_restricted_p () const;
9342	};
9343
9344	void cp_tree_c_finish_parsing ();
9345
9346	/ In cp-ubsan.cc /
9347	extern void cp_ubsan_maybe_instrument_member_call (tree);
9348	extern void cp_ubsan_instrument_member_accesses (tree *);
9349	extern tree cp_ubsan_maybe_instrument_downcast (location_t, tree, tree, tree);
9350	extern tree cp_ubsan_maybe_instrument_cast_to_vbase (location_t, tree, tree);
9351	extern void cp_ubsan_maybe_initialize_vtbl_ptrs (tree);
9352
9353	/ In coroutines.cc /
9354	extern tree finish_co_return_stmt (location_t, tree);
9355	extern tree finish_co_await_expr (location_t, tree);
9356	extern tree finish_co_yield_expr (location_t, tree);
9357	extern tree coro_validate_builtin_call (tree,
9358	tsubst_flags_t = tf_warning_or_error);
9359	extern tree coro_get_actor_function (tree);
9360	extern tree coro_get_destroy_function (tree);
9361	extern tree coro_get_ramp_function (tree);
9362
9363	extern tree co_await_get_resume_call (tree await_expr);
9364
9365	/ Only for use by modules. /
9366	extern void coro_set_transform_functions (tree, tree, tree);
9367	extern void coro_set_ramp_function (tree, tree);
9368
9369	/ In reflect.cc /
9370	extern void init_reflection ();
9371	extern bool metafunction_p (tree) ATTRIBUTE_PURE;
9372	extern tree direct_base_derived (tree) ATTRIBUTE_PURE;
9373	extern tree process_metafunction (const constexpr_ctx *, tree, tree,
9374	bool , bool* , tree );
9375	extern tree get_reflection (location_t, tree, reflect_kind = REFLECT_UNDEF);
9376	extern tree get_null_reflection () ATTRIBUTE_PURE;
9377	extern tree splice (tree);
9378	extern bool check_out_of_consteval_use (tree, bool = true);
9379	extern bool consteval_only_p (tree) ATTRIBUTE_PURE;
9380	extern bool compare_reflections (tree, tree) ATTRIBUTE_PURE;
9381	extern bool valid_splice_type_p (const_tree) ATTRIBUTE_PURE;
9382	extern bool valid_splice_scope_p (const_tree) ATTRIBUTE_PURE;
9383	extern bool check_splice_expr (location_t, location_t, tree, bool, bool, bool)
9384	ATTRIBUTE_PURE;
9385	extern tree make_splice_scope (tree, bool);
9386	extern bool dependent_splice_p (const_tree) ATTRIBUTE_PURE;
9387	extern tree reflection_mangle_prefix (tree, char [`3`]);
9388	extern void check_consteval_only_fn (tree);
9389
9390	/ Inline bodies. /
9391
9392	inline tree
9393	ovl_first (tree node)
9394	{
9395	while (TREE_CODE (node) == OVERLOAD)
9396	node = OVL_FUNCTION (node);
9397	return node;
9398	}
9399
9400	inline bool
9401	type_unknown_p (const_tree expr)
9402	{
9403	return TREE_TYPE (expr) == unknown_type_node;
9404	}
9405
9406	inline hashval_t
9407	named_decl_hash::hash (const value_type decl)
9408	{
9409	tree name = (TREE_CODE (decl) == BINDING_VECTOR
9410	? BINDING_VECTOR_NAME (decl) : OVL_NAME (decl));
9411	return name ? IDENTIFIER_HASH_VALUE (name) : `0`;
9412	}
9413
9414	inline bool
9415	named_decl_hash::equal (const value_type existing, compare_type candidate)
9416	{
9417	tree name = (TREE_CODE (existing) == BINDING_VECTOR
9418	? BINDING_VECTOR_NAME (existing) : OVL_NAME (existing));
9419	return candidate == name;
9420	}
9421
9422	inline bool
9423	null_node_p (const_tree expr)
9424	{
9425	STRIP_ANY_LOCATION_WRAPPER (expr);
9426	return expr == null_node;
9427	}
9428
9429	/ True iff T is a variable template declaration. /
9430	inline bool
9431	variable_template_p (tree t)
9432	{
9433	if (TREE_CODE (t) != TEMPLATE_DECL)
9434	return false;
9435	if (!PRIMARY_TEMPLATE_P (t))
9436	return false;
9437	if (tree r = DECL_TEMPLATE_RESULT (t))
9438	return VAR_P (r);
9439	return false;
9440	}
9441
9442	/ True iff T is a concept. /
9443
9444	inline bool
9445	concept_definition_p (const_tree t)
9446	{
9447	return TREE_CODE (STRIP_TEMPLATE (t)) == CONCEPT_DECL;
9448	}
9449
9450	/ True if t is an expression that checks a concept. /
9451
9452	inline bool
9453	concept_check_p (const_tree t)
9454	{
9455	if (t && TREE_CODE (t) == TEMPLATE_ID_EXPR)
9456	return concept_definition_p (TREE_OPERAND (t, `0`));
9457	return false;
9458	}
9459
9460	/ Return the prototype parameter of the concept T,*
9461	i.e. its first declared template parameter. /*
9462
9463	inline tree
9464	concept_prototype_parameter (const_tree t)
9465	{
9466	gcc_checking_assert (concept_definition_p (t));
9467	if (TREE_CODE (t) == CONCEPT_DECL)
9468	t = DECL_TI_TEMPLATE (t);
9469	tree parms = DECL_INNERMOST_TEMPLATE_PARMS (t);
9470	return TREE_VALUE (TREE_VEC_ELT (parms, `0`));
9471	}
9472
9473	/ Helpers for IMPLICIT_RVALUE_P to look through automatic dereference. /
9474
9475	inline bool
9476	implicit_rvalue_p (const_tree t)
9477	{
9478	if (REFERENCE_REF_P (t))
9479	t = TREE_OPERAND (t, `0`);
9480	return ((TREE_CODE (t) == NON_LVALUE_EXPR
9481	\|\| TREE_CODE (t) == STATIC_CAST_EXPR)
9482	&& IMPLICIT_RVALUE_P (t));
9483	}
9484	inline tree
9485	set_implicit_rvalue_p (tree ot)
9486	{
9487	tree t = ot;
9488	if (REFERENCE_REF_P (t))
9489	t = TREE_OPERAND (t, `0`);
9490	IMPLICIT_RVALUE_P (t) = `1`;
9491	return ot;
9492	}
9493
9494	/ True if t is a "constrained auto" type-specifier. /
9495
9496	inline bool
9497	is_constrained_auto (const_tree t)
9498	{
9499	return is_auto (t) && PLACEHOLDER_TYPE_CONSTRAINTS_INFO (t);
9500	}
9501
9502	/ True if CODE, a tree code, denotes a tree whose operand is not evaluated*
9503	as per [expr.context], i.e., an operand to sizeof, typeof, decltype, or
9504	alignof. /*
9505
9506	inline bool
9507	unevaluated_p (tree_code code)
9508	{
9509	return (code == DECLTYPE_TYPE
9510	\|\| code == ALIGNOF_EXPR
9511	\|\| code == SIZEOF_EXPR
9512	\|\| code == NOEXCEPT_EXPR
9513	\|\| code == REQUIRES_EXPR);
9514	}
9515
9516	/ RAII class to push/pop the access scope for T. /
9517
9518	struct push_access_scope_guard
9519	{
9520	tree decl;
9521	push_access_scope_guard (tree t)
9522	: decl (t)
9523	{
9524	if (VAR_OR_FUNCTION_DECL_P (decl)
9525	\|\| TREE_CODE (decl) == TYPE_DECL)
9526	push_access_scope (decl);
9527	else
9528	decl = NULL_TREE;
9529	}
9530	~push_access_scope_guard ()
9531	{
9532	if (decl)
9533	pop_access_scope (decl);
9534	}
9535	};
9536
9537	/ Extracting strings from constexpr. /
9538
9539	class cexpr_str
9540	{
9541	public:
9542	cexpr_str (tree message) : message (message) {}
9543	cexpr_str (const cexpr_str &) = delete;
9544	~cexpr_str () { XDELETEVEC (buf); }
9545
9546	bool type_check (location_t location);
9547	bool extract (location_t location, const char * & msg, int &len);
9548	bool extract (location_t location, tree &str);
9549	tree message;
9550	private:
9551	tree message_data = NULL_TREE;
9552	tree message_sz = NULL_TREE;
9553	char buf = nullptr*;
9554	};
9555
9556	/ True if TYPE is an extended floating-point type. /
9557
9558	inline bool
9559	extended_float_type_p (tree type)
9560	{
9561	type = TYPE_MAIN_VARIANT (type);
9562	for (int i = `0`; i < NUM_FLOATN_NX_TYPES; ++i)
9563	if (type == FLOATN_TYPE_NODE (i))
9564	return true;
9565	if (type == bfloat16_type_node)
9566	return true;
9567	return false;
9568	}
9569
9570	/ True if DECL is name-independent declaration. /
9571
9572	inline bool
9573	name_independent_decl_p (tree decl)
9574	{
9575	return ((VAR_P (decl) \|\| TREE_CODE (decl) == FIELD_DECL)
9576	&& DECL_NAME (decl)
9577	&& id_equal (DECL_NAME (decl), str: "_")
9578	&& !TREE_STATIC (decl)
9579	&& !DECL_EXTERNAL (decl));
9580	}
9581
9582	namespace highlight_colors {
9583
9584	/ Color names for highlighting "%qH" vs "%qI" values,*
9585	and ranges corresponding to them. /*
9586	extern const char *const percent_h;
9587	extern const char *const percent_i;
9588
9589	} // namespace highlight_colors
9590
9591	#if CHECKING_P
9592	namespace selftest {
9593	extern void run_cp_tests (void);
9594
9595	/ Declarations for specific families of tests within cp,*
9596	by source file, in alphabetical order. /*
9597	extern void cp_pt_cc_tests ();
9598	extern void cp_tree_cc_tests (void);
9599	} // namespace selftest
9600	#endif /* #if CHECKING_P */
9601
9602	/ -- end of C++ /
9603
9604	#endif /* ! GCC_CP_TREE_H */
9605

source code of gcc/cp/cp-tree.h