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

1	/ Definitions for -- C++ -- parsing and type checking.*
2	Copyright (C) 1987-2024 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	#include "contracts.h"
29
30	/ In order for the format checking to accept the C++ front end*
31	diagnostic framework extensions, you must include this file before
32	diagnostic-core.h, not after. We override the definition of GCC_DIAG_STYLE
33	in c-common.h. /*
34	#undef GCC_DIAG_STYLE
35	#define GCC_DIAG_STYLE __gcc_cxxdiag__
36	#if defined(GCC_DIAGNOSTIC_CORE_H) \|\| defined (GCC_C_COMMON_H)
37	#error \
38	In order for the format checking to accept the C++ front end diagnostic \
39	framework extensions, you must include this file before diagnostic-core.h and \
40	c-common.h, not after.
41	#endif
42	#include "c-family/c-common.h"
43	#include "diagnostic.h"
44
45	/ A tree node, together with a location, so that we can track locations*
46	(and ranges) during parsing.
47
48	The location is redundant for node kinds that have locations,
49	but not all node kinds do (e.g. constants, and references to
50	params, locals, etc), so we stash a copy here. /*
51
52	inline location_t cp_expr_location (const_tree);
53
54	class cp_expr
55	{
56	public:
57	cp_expr () :
58	m_value (NULL), m_loc (UNKNOWN_LOCATION),
59	m_decimal (false)
60	{}
61
62	cp_expr (tree value) :
63	m_value (value), m_loc (cp_expr_location (m_value)),
64	m_decimal (false)
65	{}
66
67	cp_expr (tree value, location_t loc):
68	m_value (value), m_loc (loc), m_decimal (false)
69	{
70	protected_set_expr_location (value, loc);
71	}
72
73	cp_expr (tree value, location_t loc, bool decimal):
74	m_value (value), m_loc (loc), m_decimal (decimal)
75	{
76	protected_set_expr_location (value, loc);
77	}
78
79	/ Implicit conversions to tree. /
80	operator tree () const { return m_value; }
81	tree & operator* () { return m_value; }
82	tree operator* () const { return m_value; }
83	tree & operator-> () { return m_value; }
84	tree operator-> () const { return m_value; }
85
86	tree get_value () const { return m_value; }
87	location_t get_location () const { return m_loc; }
88	location_t get_start () const
89	{
90	source_range src_range = get_range_from_loc (set: line_table, loc: m_loc);
91	return src_range.m_start;
92	}
93	location_t get_finish () const
94	{
95	source_range src_range = get_range_from_loc (set: line_table, loc: m_loc);
96	return src_range.m_finish;
97	}
98
99	void set_location (location_t loc)
100	{
101	protected_set_expr_location (m_value, loc);
102	m_loc = loc;
103	}
104
105	void set_range (location_t start, location_t finish)
106	{
107	set_location (make_location (caret: m_loc, start, finish));
108	}
109
110	cp_expr& maybe_add_location_wrapper ()
111	{
112	m_value = maybe_wrap_with_location (m_value, m_loc);
113	return *this;
114	}
115
116	bool decimal_p () const { return m_decimal; }
117
118	private:
119	tree m_value;
120	location_t m_loc;
121	bool m_decimal : `1`;
122	};
123
124	inline bool
125	operator == (const cp_expr &lhs, tree rhs)
126	{
127	return lhs.get_value () == rhs;
128	}
129
130
131	enum cp_tree_index
132	{
133	CPTI_WCHAR_DECL,
134	CPTI_VTABLE_ENTRY_TYPE,
135	CPTI_DELTA_TYPE,
136	CPTI_VTABLE_INDEX_TYPE,
137	CPTI_CLEANUP_TYPE,
138	CPTI_VTT_PARM_TYPE,
139
140	CPTI_CLASS_TYPE,
141	CPTI_UNKNOWN_TYPE,
142	CPTI_INIT_LIST_TYPE,
143	CPTI_EXPLICIT_VOID_LIST,
144	CPTI_VTBL_TYPE,
145	CPTI_VTBL_PTR_TYPE,
146	CPTI_GLOBAL,
147	CPTI_ABORT_FNDECL,
148	CPTI_AGGR_TAG,
149	CPTI_CONV_OP_MARKER,
150
151	CPTI_CTOR_IDENTIFIER,
152	CPTI_COMPLETE_CTOR_IDENTIFIER,
153	CPTI_BASE_CTOR_IDENTIFIER,
154	CPTI_DTOR_IDENTIFIER,
155	CPTI_COMPLETE_DTOR_IDENTIFIER,
156	CPTI_BASE_DTOR_IDENTIFIER,
157	CPTI_DELETING_DTOR_IDENTIFIER,
158	CPTI_CONV_OP_IDENTIFIER,
159	CPTI_DELTA_IDENTIFIER,
160	CPTI_IN_CHARGE_IDENTIFIER,
161	CPTI_VTT_PARM_IDENTIFIER,
162	CPTI_AS_BASE_IDENTIFIER,
163	CPTI_THIS_IDENTIFIER,
164	CPTI_PFN_IDENTIFIER,
165	CPTI_VPTR_IDENTIFIER,
166	CPTI_GLOBAL_IDENTIFIER,
167	CPTI_ANON_IDENTIFIER,
168	CPTI_AUTO_IDENTIFIER,
169	CPTI_DECLTYPE_AUTO_IDENTIFIER,
170	CPTI_INIT_LIST_IDENTIFIER,
171	CPTI_FOR_RANGE__IDENTIFIER,
172	CPTI_FOR_BEGIN__IDENTIFIER,
173	CPTI_FOR_END__IDENTIFIER,
174	CPTI_FOR_RANGE_IDENTIFIER,
175	CPTI_FOR_BEGIN_IDENTIFIER,
176	CPTI_FOR_END_IDENTIFIER,
177	CPTI_ABI_TAG_IDENTIFIER,
178	CPTI_ALIGNED_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
196	CPTI_LANG_NAME_C,
197	CPTI_LANG_NAME_CPLUSPLUS,
198
199	CPTI_EMPTY_EXCEPT_SPEC,
200	CPTI_NOEXCEPT_TRUE_SPEC,
201	CPTI_NOEXCEPT_FALSE_SPEC,
202	CPTI_NOEXCEPT_DEFERRED_SPEC,
203
204	CPTI_ANY_TARG,
205
206	CPTI_MODULE_HWM,
207	/ Nodes after here change during compilation, or should not be in*
208	the module's global tree table. Such nodes must be locatable
209	via name lookup or type-construction, as those are the only
210	cross-TU matching capabilities remaining. /*
211
212	/ We must find these via the global namespace. /
213	CPTI_STD,
214	CPTI_ABI,
215
216	/ These are created at init time, but the library/headers provide*
217	definitions. /*
218	CPTI_ALIGN_TYPE,
219	CPTI_TERMINATE_FN,
220	CPTI_CALL_TERMINATE_FN,
221	CPTI_CALL_UNEXPECTED_FN,
222
223	/ These are lazily inited. /
224	CPTI_CONST_TYPE_INFO_TYPE,
225	CPTI_GET_EXCEPTION_PTR_FN,
226	CPTI_BEGIN_CATCH_FN,
227	CPTI_END_CATCH_FN,
228	CPTI_ALLOCATE_EXCEPTION_FN,
229	CPTI_FREE_EXCEPTION_FN,
230	CPTI_THROW_FN,
231	CPTI_RETHROW_FN,
232	CPTI_ATEXIT_FN_PTR_TYPE,
233	CPTI_ATEXIT,
234	CPTI_THREAD_ATEXIT,
235	CPTI_DSO_HANDLE,
236	CPTI_DCAST,
237
238	CPTI_PSEUDO_CONTRACT_VIOLATION,
239
240	CPTI_MAX
241	};
242
243	extern GTY(()) tree cp_global_trees[CPTI_MAX];
244
245	#define wchar_decl_node cp_global_trees[CPTI_WCHAR_DECL]
246	#define vtable_entry_type cp_global_trees[CPTI_VTABLE_ENTRY_TYPE]
247	/ The type used to represent an offset by which to adjust the `this'*
248	pointer in pointer-to-member types. /*
249	#define delta_type_node cp_global_trees[CPTI_DELTA_TYPE]
250	/ The type used to represent an index into the vtable. /
251	#define vtable_index_type cp_global_trees[CPTI_VTABLE_INDEX_TYPE]
252
253	#define class_type_node cp_global_trees[CPTI_CLASS_TYPE]
254	#define unknown_type_node cp_global_trees[CPTI_UNKNOWN_TYPE]
255	#define init_list_type_node cp_global_trees[CPTI_INIT_LIST_TYPE]
256	#define explicit_void_list_node cp_global_trees[CPTI_EXPLICIT_VOID_LIST]
257	#define vtbl_type_node cp_global_trees[CPTI_VTBL_TYPE]
258	#define vtbl_ptr_type_node cp_global_trees[CPTI_VTBL_PTR_TYPE]
259	#define std_node cp_global_trees[CPTI_STD]
260	#define abi_node cp_global_trees[CPTI_ABI]
261	#define global_namespace cp_global_trees[CPTI_GLOBAL]
262	#define const_type_info_type_node cp_global_trees[CPTI_CONST_TYPE_INFO_TYPE]
263	#define conv_op_marker cp_global_trees[CPTI_CONV_OP_MARKER]
264	#define abort_fndecl cp_global_trees[CPTI_ABORT_FNDECL]
265	#define current_aggr cp_global_trees[CPTI_AGGR_TAG]
266	/ std::align_val_t /
267	#define align_type_node cp_global_trees[CPTI_ALIGN_TYPE]
268	#define pseudo_contract_violation_type cp_global_trees[CPTI_PSEUDO_CONTRACT_VIOLATION]
269
270	/ We cache these tree nodes so as to call get_identifier less frequently.*
271	For identifiers for functions, including special member functions such
272	as ctors and assignment operators, the nodes can be used (among other
273	things) to iterate over their overloads defined by/for a type. For
274	example:
275
276	tree ovlid = assign_op_identifier;
277	tree overloads = get_class_binding (type, ovlid);
278	for (ovl_iterator it (overloads); it; ++it) { ... }
279
280	iterates over the set of implicitly and explicitly defined overloads
281	of the assignment operator for type (including the copy and move
282	assignment operators, whether deleted or not). /*
283
284	/ The name of a constructor that takes an in-charge parameter to*
285	decide whether or not to construct virtual base classes. /*
286	#define ctor_identifier cp_global_trees[CPTI_CTOR_IDENTIFIER]
287	/ The name of a constructor that constructs virtual base classes. /
288	#define complete_ctor_identifier cp_global_trees[CPTI_COMPLETE_CTOR_IDENTIFIER]
289	/ The name of a constructor that does not construct virtual base classes. /
290	#define base_ctor_identifier cp_global_trees[CPTI_BASE_CTOR_IDENTIFIER]
291	/ The name of a destructor that takes an in-charge parameter to*
292	decide whether or not to destroy virtual base classes and whether
293	or not to delete the object. /*
294	#define dtor_identifier cp_global_trees[CPTI_DTOR_IDENTIFIER]
295	/ The name of a destructor that destroys virtual base classes. /
296	#define complete_dtor_identifier cp_global_trees[CPTI_COMPLETE_DTOR_IDENTIFIER]
297	/ The name of a destructor that does not destroy virtual base*
298	classes. /*
299	#define base_dtor_identifier cp_global_trees[CPTI_BASE_DTOR_IDENTIFIER]
300	/ The name of a destructor that destroys virtual base classes, and*
301	then deletes the entire object. /*
302	#define deleting_dtor_identifier cp_global_trees[CPTI_DELETING_DTOR_IDENTIFIER]
303
304	/ The name used for conversion operators -- but note that actual*
305	conversion functions use special identifiers outside the identifier
306	table. /*
307	#define conv_op_identifier cp_global_trees[CPTI_CONV_OP_IDENTIFIER]
308
309	#define delta_identifier cp_global_trees[CPTI_DELTA_IDENTIFIER]
310	#define in_charge_identifier cp_global_trees[CPTI_IN_CHARGE_IDENTIFIER]
311	/ The name of the parameter that contains a pointer to the VTT to use*
312	for this subobject constructor or destructor. /*
313	#define vtt_parm_identifier cp_global_trees[CPTI_VTT_PARM_IDENTIFIER]
314	#define as_base_identifier cp_global_trees[CPTI_AS_BASE_IDENTIFIER]
315	#define this_identifier cp_global_trees[CPTI_THIS_IDENTIFIER]
316	#define pfn_identifier cp_global_trees[CPTI_PFN_IDENTIFIER]
317	#define vptr_identifier cp_global_trees[CPTI_VPTR_IDENTIFIER]
318	/ The name of the ::, std & anon namespaces. /
319	#define global_identifier cp_global_trees[CPTI_GLOBAL_IDENTIFIER]
320	#define anon_identifier cp_global_trees[CPTI_ANON_IDENTIFIER]
321	/ auto and declspec(auto) identifiers. /
322	#define auto_identifier cp_global_trees[CPTI_AUTO_IDENTIFIER]
323	#define decltype_auto_identifier cp_global_trees[CPTI_DECLTYPE_AUTO_IDENTIFIER]
324	#define init_list_identifier cp_global_trees[CPTI_INIT_LIST_IDENTIFIER]
325	#define for_range__identifier cp_global_trees[CPTI_FOR_RANGE__IDENTIFIER]
326	#define for_begin__identifier cp_global_trees[CPTI_FOR_BEGIN__IDENTIFIER]
327	#define for_end__identifier cp_global_trees[CPTI_FOR_END__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 abi_tag_identifier cp_global_trees[CPTI_ABI_TAG_IDENTIFIER]
332	#define aligned_identifier cp_global_trees[CPTI_ALIGNED_IDENTIFIER]
333	#define begin_identifier cp_global_trees[CPTI_BEGIN_IDENTIFIER]
334	#define end_identifier cp_global_trees[CPTI_END_IDENTIFIER]
335	#define get__identifier cp_global_trees[CPTI_GET_IDENTIFIER]
336	#define gnu_identifier cp_global_trees[CPTI_GNU_IDENTIFIER]
337	#define tuple_element_identifier cp_global_trees[CPTI_TUPLE_ELEMENT_IDENTIFIER]
338	#define tuple_size_identifier cp_global_trees[CPTI_TUPLE_SIZE_IDENTIFIER]
339	#define type_identifier cp_global_trees[CPTI_TYPE_IDENTIFIER]
340	#define value_identifier cp_global_trees[CPTI_VALUE_IDENTIFIER]
341	#define fun_identifier cp_global_trees[CPTI_FUN_IDENTIFIER]
342	#define closure_identifier cp_global_trees[CPTI_CLOSURE_IDENTIFIER]
343	#define heap_uninit_identifier cp_global_trees[CPTI_HEAP_UNINIT_IDENTIFIER]
344	#define heap_identifier cp_global_trees[CPTI_HEAP_IDENTIFIER]
345	#define heap_deleted_identifier cp_global_trees[CPTI_HEAP_DELETED_IDENTIFIER]
346	#define heap_vec_uninit_identifier cp_global_trees[CPTI_HEAP_VEC_UNINIT_IDENTIFIER]
347	#define heap_vec_identifier cp_global_trees[CPTI_HEAP_VEC_IDENTIFIER]
348	#define omp_identifier cp_global_trees[CPTI_OMP_IDENTIFIER]
349	#define lang_name_c cp_global_trees[CPTI_LANG_NAME_C]
350	#define lang_name_cplusplus cp_global_trees[CPTI_LANG_NAME_CPLUSPLUS]
351
352	/ Exception specifiers used for throw(), noexcept(true),*
353	noexcept(false) and deferred noexcept. We rely on these being
354	uncloned. /*
355	#define empty_except_spec cp_global_trees[CPTI_EMPTY_EXCEPT_SPEC]
356	#define noexcept_true_spec cp_global_trees[CPTI_NOEXCEPT_TRUE_SPEC]
357	#define noexcept_false_spec cp_global_trees[CPTI_NOEXCEPT_FALSE_SPEC]
358	#define noexcept_deferred_spec cp_global_trees[CPTI_NOEXCEPT_DEFERRED_SPEC]
359
360	/ Exception handling function declarations. /
361	#define terminate_fn cp_global_trees[CPTI_TERMINATE_FN]
362	#define call_unexpected_fn cp_global_trees[CPTI_CALL_UNEXPECTED_FN]
363	#define call_terminate_fn cp_global_trees[CPTI_CALL_TERMINATE_FN]
364	#define get_exception_ptr_fn cp_global_trees[CPTI_GET_EXCEPTION_PTR_FN]
365	#define begin_catch_fn cp_global_trees[CPTI_BEGIN_CATCH_FN]
366	#define end_catch_fn cp_global_trees[CPTI_END_CATCH_FN]
367	#define allocate_exception_fn cp_global_trees[CPTI_ALLOCATE_EXCEPTION_FN]
368	#define free_exception_fn cp_global_trees[CPTI_FREE_EXCEPTION_FN]
369	#define throw_fn cp_global_trees[CPTI_THROW_FN]
370	#define rethrow_fn cp_global_trees[CPTI_RETHROW_FN]
371
372	/ The type of the function-pointer argument to "__cxa_atexit" (or*
373	"std::atexit", if "__cxa_atexit" is not being used). /*
374	#define atexit_fn_ptr_type_node cp_global_trees[CPTI_ATEXIT_FN_PTR_TYPE]
375
376	/ A pointer to `std::atexit'. /
377	#define atexit_node cp_global_trees[CPTI_ATEXIT]
378
379	/ A pointer to `__cxa_thread_atexit'. /
380	#define thread_atexit_node cp_global_trees[CPTI_THREAD_ATEXIT]
381
382	/ A pointer to `__dso_handle'. /
383	#define dso_handle_node cp_global_trees[CPTI_DSO_HANDLE]
384
385	/ The declaration of the dynamic_cast runtime. /
386	#define dynamic_cast_node cp_global_trees[CPTI_DCAST]
387
388	/ The type of a destructor. /
389	#define cleanup_type cp_global_trees[CPTI_CLEANUP_TYPE]
390
391	/ The type of the vtt parameter passed to subobject constructors and*
392	destructors. /*
393	#define vtt_parm_type cp_global_trees[CPTI_VTT_PARM_TYPE]
394
395	/ A node which matches any template argument. /
396	#define any_targ_node cp_global_trees[CPTI_ANY_TARG]
397
398	/ Node to indicate default access. This must be distinct from the*
399	access nodes in tree.h. /*
400
401	#define access_default_node null_node
402
403	#include "name-lookup.h"
404
405	/ Usage of TREE_LANG_FLAG_?:*
406	0: IDENTIFIER_KIND_BIT_0 (in IDENTIFIER_NODE)
407	NEW_EXPR_USE_GLOBAL (in NEW_EXPR).
408	COND_EXPR_IS_VEC_DELETE (in COND_EXPR).
409	DELETE_EXPR_USE_GLOBAL (in DELETE_EXPR).
410	CLEANUP_P (in TRY_BLOCK)
411	AGGR_INIT_VIA_CTOR_P (in AGGR_INIT_EXPR)
412	PTRMEM_OK_P (in ADDR_EXPR, OFFSET_REF, SCOPE_REF)
413	PAREN_STRING_LITERAL_P (in STRING_CST)
414	CP_DECL_THREAD_LOCAL_P (in VAR_DECL)
415	KOENIG_LOOKUP_P (in CALL_EXPR)
416	STATEMENT_LIST_NO_SCOPE (in STATEMENT_LIST).
417	EXPR_STMT_STMT_EXPR_RESULT (in EXPR_STMT)
418	STMT_EXPR_NO_SCOPE (in STMT_EXPR)
419	BIND_EXPR_TRY_BLOCK (in BIND_EXPR)
420	TYPENAME_IS_ENUM_P (in TYPENAME_TYPE)
421	OMP_FOR_GIMPLIFYING_P (in OMP_FOR, OMP_SIMD, OMP_DISTRIBUTE,
422	and OMP_TASKLOOP)
423	BASELINK_QUALIFIED_P (in BASELINK)
424	TARGET_EXPR_IMPLICIT_P (in TARGET_EXPR)
425	TEMPLATE_PARM_PARAMETER_PACK (in TEMPLATE_PARM_INDEX)
426	ATTR_IS_DEPENDENT (in the TREE_LIST for an attribute)
427	ABI_TAG_IMPLICIT (in the TREE_LIST for the argument of abi_tag)
428	LAMBDA_CAPTURE_EXPLICIT_P (in a TREE_LIST in LAMBDA_EXPR_CAPTURE_LIST)
429	PARENTHESIZED_LIST_P (in the TREE_LIST for a parameter-declaration-list)
430	CONSTRUCTOR_IS_DIRECT_INIT (in CONSTRUCTOR)
431	LAMBDA_EXPR_CAPTURES_THIS_P (in LAMBDA_EXPR)
432	DECLTYPE_FOR_LAMBDA_CAPTURE (in DECLTYPE_TYPE)
433	VEC_INIT_EXPR_IS_CONSTEXPR (in VEC_INIT_EXPR)
434	DECL_OVERRIDE_P (in FUNCTION_DECL)
435	IMPLICIT_CONV_EXPR_DIRECT_INIT (in IMPLICIT_CONV_EXPR)
436	TRANSACTION_EXPR_IS_STMT (in TRANSACTION_EXPR)
437	CONVERT_EXPR_VBASE_PATH (in CONVERT_EXPR)
438	PACK_EXPANSION_LOCAL_P (in _PACK_EXPANSION)*
439	TINFO_HAS_ACCESS_ERRORS (in TEMPLATE_INFO)
440	SIZEOF_EXPR_TYPE_P (in SIZEOF_EXPR)
441	COMPOUND_REQ_NOEXCEPT_P (in COMPOUND_REQ)
442	WILDCARD_PACK_P (in WILDCARD_DECL)
443	BLOCK_OUTER_CURLY_BRACE_P (in BLOCK)
444	FOLD_EXPR_MODOP_P (_FOLD_EXPR)*
445	IF_STMT_CONSTEXPR_P (IF_STMT)
446	DECL_NAMESPACE_INLINE_P (in NAMESPACE_DECL)
447	SWITCH_STMT_ALL_CASES_P (in SWITCH_STMT)
448	REINTERPRET_CAST_P (in NOP_EXPR)
449	ALIGNOF_EXPR_STD_P (in ALIGNOF_EXPR)
450	OVL_DEDUP_P (in OVERLOAD)
451	INIT_EXPR_NRV_P (in INIT_EXPR)
452	ATOMIC_CONSTR_MAP_INSTANTIATED_P (in ATOMIC_CONSTR)
453	contract_semantic (in ASSERTION_, PRECONDITION_, POSTCONDITION_STMT)
454	RETURN_EXPR_LOCAL_ADDR_P (in RETURN_EXPR)
455	1: IDENTIFIER_KIND_BIT_1 (in IDENTIFIER_NODE)
456	TI_PENDING_TEMPLATE_FLAG.
457	TEMPLATE_PARMS_FOR_INLINE.
458	DELETE_EXPR_USE_VEC (in DELETE_EXPR).
459	ICS_ELLIPSIS_FLAG (in _CONV)
460	DECL_INITIALIZED_P (in VAR_DECL)
461	TYPENAME_IS_CLASS_P (in TYPENAME_TYPE)
462	STMT_IS_FULL_EXPR_P (in _STMT)
463	TARGET_EXPR_LIST_INIT_P (in TARGET_EXPR)
464	DECL_FINAL_P (in FUNCTION_DECL)
465	QUALIFIED_NAME_IS_TEMPLATE (in SCOPE_REF)
466	CONSTRUCTOR_IS_DEPENDENT (in CONSTRUCTOR)
467	TINFO_USED_TEMPLATE_ID (in TEMPLATE_INFO)
468	PACK_EXPANSION_SIZEOF_P (in _PACK_EXPANSION)*
469	OVL_USING_P (in OVERLOAD)
470	IMPLICIT_CONV_EXPR_NONTYPE_ARG (in IMPLICIT_CONV_EXPR)
471	BASELINK_FUNCTIONS_MAYBE_INCOMPLETE_P (in BASELINK)
472	BIND_EXPR_VEC_DTOR (in BIND_EXPR)
473	ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (in ATOMIC_CONSTR)
474	2: IDENTIFIER_KIND_BIT_2 (in IDENTIFIER_NODE)
475	ICS_THIS_FLAG (in _CONV)
476	DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (in VAR_DECL)
477	STATEMENT_LIST_TRY_BLOCK (in STATEMENT_LIST)
478	TYPENAME_IS_RESOLVING_P (in TYPENAME_TYPE)
479	TARGET_EXPR_DIRECT_INIT_P (in TARGET_EXPR)
480	FNDECL_USED_AUTO (in FUNCTION_DECL)
481	DECLTYPE_FOR_LAMBDA_PROXY (in DECLTYPE_TYPE)
482	REF_PARENTHESIZED_P (in COMPONENT_REF, INDIRECT_REF, SCOPE_REF,
483	VIEW_CONVERT_EXPR, PAREN_EXPR)
484	AGGR_INIT_ZERO_FIRST (in AGGR_INIT_EXPR)
485	CONSTRUCTOR_MUTABLE_POISON (in CONSTRUCTOR)
486	OVL_HIDDEN_P (in OVERLOAD)
487	IF_STMT_CONSTEVAL_P (in IF_STMT)
488	SWITCH_STMT_NO_BREAK_P (in SWITCH_STMT)
489	LAMBDA_EXPR_CAPTURE_OPTIMIZED (in LAMBDA_EXPR)
490	IMPLICIT_CONV_EXPR_BRACED_INIT (in IMPLICIT_CONV_EXPR)
491	PACK_EXPANSION_AUTO_P (in _PACK_EXPANSION)*
492	contract_semantic (in ASSERTION_, PRECONDITION_, POSTCONDITION_STMT)
493	3: IMPLICIT_RVALUE_P (in NON_LVALUE_EXPR or STATIC_CAST_EXPR)
494	ICS_BAD_FLAG (in _CONV)
495	FN_TRY_BLOCK_P (in TRY_BLOCK)
496	BIND_EXPR_BODY_BLOCK (in BIND_EXPR)
497	CALL_EXPR_ORDERED_ARGS (in CALL_EXPR, AGGR_INIT_EXPR)
498	DECLTYPE_FOR_REF_CAPTURE (in DECLTYPE_TYPE)
499	CONSTRUCTOR_C99_COMPOUND_LITERAL (in CONSTRUCTOR)
500	OVL_NESTED_P (in OVERLOAD)
501	DECL_MODULE_EXPORT_P (in _DECL)
502	PACK_EXPANSION_FORCE_EXTRA_ARGS_P (in _PACK_EXPANSION)*
503	LAMBDA_EXPR_STATIC_P (in LAMBDA_EXPR)
504	TARGET_EXPR_ELIDING_P (in TARGET_EXPR)
505	contract_semantic (in ASSERTION_, PRECONDITION_, POSTCONDITION_STMT)
506	4: IDENTIFIER_MARKED (IDENTIFIER_NODEs)
507	TREE_HAS_CONSTRUCTOR (in INDIRECT_REF, SAVE_EXPR, CONSTRUCTOR,
508	CALL_EXPR, or FIELD_DECL).
509	DECL_TINFO_P (in VAR_DECL, TYPE_DECL)
510	FUNCTION_REF_QUALIFIED (in FUNCTION_TYPE, METHOD_TYPE)
511	OVL_LOOKUP_P (in OVERLOAD)
512	LOOKUP_FOUND_P (in RECORD_TYPE, UNION_TYPE, ENUMERAL_TYPE, NAMESPACE_DECL)
513	FNDECL_MANIFESTLY_CONST_EVALUATED (in FUNCTION_DECL)
514	5: IDENTIFIER_VIRTUAL_P (in IDENTIFIER_NODE)
515	FUNCTION_RVALUE_QUALIFIED (in FUNCTION_TYPE, METHOD_TYPE)
516	CALL_EXPR_REVERSE_ARGS (in CALL_EXPR, AGGR_INIT_EXPR)
517	CONSTRUCTOR_PLACEHOLDER_BOUNDARY (in CONSTRUCTOR)
518	OVL_EXPORT_P (in OVERLOAD)
519	DECL_NTTP_OBJECT_P (in VAR_DECL)
520	6: TYPE_MARKED_P (in _TYPE)
521	DECL_NONTRIVIALLY_INITIALIZED_P (in VAR_DECL)
522	RANGE_FOR_IVDEP (in RANGE_FOR_STMT)
523	CALL_EXPR_OPERATOR_SYNTAX (in CALL_EXPR, AGGR_INIT_EXPR)
524	CONSTRUCTOR_IS_DESIGNATED_INIT (in CONSTRUCTOR)
525	OVL_NAME_INDEPENDENT_DECL_P (in OVERLOAD)
526
527	Usage of TYPE_LANG_FLAG_?:
528	0: TYPE_DEPENDENT_P
529	1: TYPE_HAS_USER_CONSTRUCTOR.
530	2: TYPE_HAS_LATE_RETURN_TYPE (in FUNCTION_TYPE, METHOD_TYPE)
531	TYPE_PTRMEMFUNC_FLAG (in RECORD_TYPE)
532	4: TYPE_HAS_NONTRIVIAL_DESTRUCTOR
533	5: CLASS_TYPE_P (in RECORD_TYPE and UNION_TYPE)
534	ENUM_FIXED_UNDERLYING_TYPE_P (in ENUMERAL_TYPE)
535	AUTO_IS_DECLTYPE (in TEMPLATE_TYPE_PARM)
536	TEMPLATE_TEMPLATE_PARM_SIMPLE_P (in TEMPLATE_TEMPLATE_PARM)
537	6: TYPE_DEPENDENT_P_VALID
538
539	Usage of DECL_LANG_FLAG_?:
540	0: DECL_TEMPLATE_PARM_P (in PARM_DECL, CONST_DECL, TYPE_DECL, or TEMPLATE_DECL)
541	DECL_LOCAL_DECL_P (in FUNCTION_DECL, VAR_DECL)
542	DECL_MUTABLE_P (in FIELD_DECL)
543	DECL_DEPENDENT_P (in USING_DECL)
544	LABEL_DECL_BREAK (in LABEL_DECL)
545	1: C_TYPEDEF_EXPLICITLY_SIGNED (in TYPE_DECL).
546	DECL_TEMPLATE_INSTANTIATED (in a VAR_DECL or a FUNCTION_DECL)
547	DECL_MEMBER_TEMPLATE_P (in TEMPLATE_DECL)
548	USING_DECL_TYPENAME_P (in USING_DECL)
549	DECL_VLA_CAPTURE_P (in FIELD_DECL)
550	DECL_ARRAY_PARAMETER_P (in PARM_DECL)
551	LABEL_DECL_CONTINUE (in LABEL_DECL)
552	2: DECL_THIS_EXTERN (in VAR_DECL, FUNCTION_DECL or PARM_DECL)
553	DECL_IMPLICIT_TYPEDEF_P (in a TYPE_DECL)
554	DECL_CONSTRAINT_VAR_P (in a PARM_DECL)
555	DECL_INSTANTIATING_NSDMI_P (in a FIELD_DECL)
556	USING_DECL_UNRELATED_P (in USING_DECL)
557	3: DECL_IN_AGGR_P.
558	4: DECL_C_BIT_FIELD (in a FIELD_DECL)
559	DECL_ANON_UNION_VAR_P (in a VAR_DECL)
560	DECL_SELF_REFERENCE_P (in a TYPE_DECL)
561	DECL_INVALID_OVERRIDER_P (in a FUNCTION_DECL)
562	DECL_UNINSTANIATED_TEMPLATE_FRIEND_P (in TEMPLATE_DECL)
563	5: DECL_INTERFACE_KNOWN.
564	6: DECL_THIS_STATIC (in VAR_DECL, FUNCTION_DECL or PARM_DECL)
565	DECL_FIELD_IS_BASE (in FIELD_DECL)
566	TYPE_DECL_ALIAS_P (in TYPE_DECL)
567	7: DECL_THUNK_P (in a member FUNCTION_DECL)
568	DECL_NORMAL_CAPTURE_P (in FIELD_DECL)
569	DECL_DECLARED_CONSTINIT_P (in VAR_DECL)
570	8: DECL_DECLARED_CONSTEXPR_P (in VAR_DECL, FUNCTION_DECL)
571
572	Usage of language-independent fields in a language-dependent manner:
573
574	TYPE_ALIAS_SET
575	This field is used by TYPENAME_TYPEs, TEMPLATE_TYPE_PARMs, and so
576	forth as a substitute for the mark bits provided in `lang_type'.
577	At present, only the six low-order bits are used.
578
579	TYPE_LANG_SLOT_1
580	For a FUNCTION_TYPE or METHOD_TYPE, this is TYPE_RAISES_EXCEPTIONS.
581	For a POINTER_TYPE (to a METHOD_TYPE), this is TYPE_PTRMEMFUNC_TYPE.
582	For an ENUMERAL_TYPE, BOUND_TEMPLATE_TEMPLATE_PARM_TYPE,
583	RECORD_TYPE or UNION_TYPE this is TYPE_TEMPLATE_INFO,
584
585	BINFO_VIRTUALS
586	For a binfo, this is a TREE_LIST. There is an entry for each
587	virtual function declared either in BINFO or its direct and
588	indirect primary bases.
589
590	The BV_DELTA of each node gives the amount by which to adjust the
591	`this' pointer when calling the function. If the method is an
592	overridden version of a base class method, then it is assumed
593	that, prior to adjustment, the this pointer points to an object
594	of the base class.
595
596	The BV_VCALL_INDEX of each node, if non-NULL, gives the vtable
597	index of the vcall offset for this entry.
598
599	The BV_FN is the declaration for the virtual function itself.
600
601	If BV_LOST_PRIMARY is set, it means that this entry is for a lost
602	primary virtual base and can be left null in the vtable.
603
604	BINFO_VTABLE
605	This is an expression with POINTER_TYPE that gives the value
606	to which the vptr should be initialized. Use get_vtbl_decl_for_binfo
607	to extract the VAR_DECL for the complete vtable.
608
609	DECL_VINDEX
610	This field is NULL for a non-virtual function. For a virtual
611	function, it is eventually set to an INTEGER_CST indicating the
612	index in the vtable at which this function can be found. When
613	a virtual function is declared, but before it is known what
614	function is overridden, this field is the error_mark_node.
615
616	Temporarily, it may be set to a TREE_LIST whose TREE_VALUE is
617	the virtual function this one overrides, and whose TREE_CHAIN is
618	the old DECL_VINDEX. /*
619
620	/ Language-specific tree checkers. /
621
622	#define VAR_OR_FUNCTION_DECL_CHECK(NODE) \
623	TREE_CHECK2(NODE,VAR_DECL,FUNCTION_DECL)
624
625	#define TYPE_FUNCTION_OR_TEMPLATE_DECL_CHECK(NODE) \
626	TREE_CHECK3(NODE,TYPE_DECL,TEMPLATE_DECL,FUNCTION_DECL)
627
628	#define TYPE_FUNCTION_OR_TEMPLATE_DECL_P(NODE) \
629	(TREE_CODE (NODE) == TYPE_DECL \|\| TREE_CODE (NODE) == TEMPLATE_DECL \
630	\|\| TREE_CODE (NODE) == FUNCTION_DECL)
631
632	#define VAR_FUNCTION_OR_PARM_DECL_CHECK(NODE) \
633	TREE_CHECK3(NODE,VAR_DECL,FUNCTION_DECL,PARM_DECL)
634
635	#define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) \
636	TREE_CHECK4(NODE,VAR_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL)
637
638	#define VAR_TEMPL_TYPE_FIELD_OR_FUNCTION_DECL_CHECK(NODE) \
639	TREE_CHECK5(NODE,VAR_DECL,FIELD_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL)
640
641	#define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) \
642	TREE_CHECK(NODE,BOUND_TEMPLATE_TEMPLATE_PARM)
643
644	#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
645
646	/ Returns t iff the node can have a TEMPLATE_INFO field. /
647
648	inline tree
649	template_info_decl_check (const_tree t, const char* f, int l, const char* fn)
650	{
651	switch (TREE_CODE (t))
652	{
653	case VAR_DECL:
654	case FUNCTION_DECL:
655	case FIELD_DECL:
656	case TYPE_DECL:
657	case CONCEPT_DECL:
658	case TEMPLATE_DECL:
659	return const_cast<tree>(t);
660	default:
661	break;
662	}
663	tree_check_failed (t, f, l, fn,
664	VAR_DECL, FUNCTION_DECL, FIELD_DECL, TYPE_DECL,
665	CONCEPT_DECL, TEMPLATE_DECL, `0`);
666	gcc_unreachable ();
667	}
668
669	#define TEMPLATE_INFO_DECL_CHECK(NODE) \
670	template_info_decl_check ((NODE), __FILE__, __LINE__, __FUNCTION__)
671
672	#define THUNK_FUNCTION_CHECK(NODE) __extension__ \
673	({ __typeof (NODE) const __t = (NODE); \
674	if (TREE_CODE (__t) != FUNCTION_DECL \|\| !__t->decl_common.lang_specific \
675	\|\| !__t->decl_common.lang_specific->u.fn.thunk_p) \
676	tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, 0); \
677	__t; })
678
679	#define DECL_TEMPLATE_PARM_CHECK(NODE) \
680	decl_template_parm_check ((NODE), __FILE__, __LINE__, __FUNCTION__)
681
682	#else /* ENABLE_TREE_CHECKING */
683
684	#define TEMPLATE_INFO_DECL_CHECK(NODE) (NODE)
685	#define THUNK_FUNCTION_CHECK(NODE) (NODE)
686	#define DECL_TEMPLATE_PARM_CHECK(NODE) (NODE)
687
688	#endif /* ENABLE_TREE_CHECKING */
689
690	/ Language-dependent contents of an identifier. /
691
692	struct GTY(()) lang_identifier {
693	struct c_common_identifier c_common;
694	cxx_binding *bindings;
695	};
696
697	/ Return a typed pointer version of T if it designates a*
698	C++ front-end identifier. /*
699	inline lang_identifier*
700	identifier_p (tree t)
701	{
702	if (TREE_CODE (t) == IDENTIFIER_NODE)
703	return (lang_identifier*) t;
704	return NULL;
705	}
706
707	#define LANG_IDENTIFIER_CAST(NODE) \
708	((struct lang_identifier*)IDENTIFIER_NODE_CHECK (NODE))
709
710	struct GTY(()) template_parm_index {
711	struct tree_common common;
712	int index;
713	int level;
714	int orig_level;
715	tree decl;
716	};
717
718	struct GTY(()) ptrmem_cst {
719	struct tree_common common;
720	tree member;
721	location_t locus;
722	};
723	typedef struct ptrmem_cst * ptrmem_cst_t;
724
725	#define CLEANUP_P(NODE) TREE_LANG_FLAG_0 (TRY_BLOCK_CHECK (NODE))
726
727	#define BIND_EXPR_TRY_BLOCK(NODE) \
728	TREE_LANG_FLAG_0 (BIND_EXPR_CHECK (NODE))
729
730	/ This BIND_EXPR is from build_vec_delete_1. /
731	#define BIND_EXPR_VEC_DTOR(NODE) \
732	TREE_LANG_FLAG_1 (BIND_EXPR_CHECK (NODE))
733
734	/ Used to mark the block around the member initializers and cleanups. /
735	#define BIND_EXPR_BODY_BLOCK(NODE) \
736	TREE_LANG_FLAG_3 (BIND_EXPR_CHECK (NODE))
737	#define FUNCTION_NEEDS_BODY_BLOCK(NODE) \
738	(DECL_CONSTRUCTOR_P (NODE) \|\| DECL_DESTRUCTOR_P (NODE) \
739	\|\| LAMBDA_FUNCTION_P (NODE))
740
741	#define STATEMENT_LIST_NO_SCOPE(NODE) \
742	TREE_LANG_FLAG_0 (STATEMENT_LIST_CHECK (NODE))
743	#define STATEMENT_LIST_TRY_BLOCK(NODE) \
744	TREE_LANG_FLAG_2 (STATEMENT_LIST_CHECK (NODE))
745
746	/ Mark the outer curly brace BLOCK. /
747	#define BLOCK_OUTER_CURLY_BRACE_P(NODE) TREE_LANG_FLAG_0 (BLOCK_CHECK (NODE))
748
749	/ Nonzero if this statement should be considered a full-expression,*
750	i.e., if temporaries created during this statement should have
751	their destructors run at the end of this statement. /*
752	#define STMT_IS_FULL_EXPR_P(NODE) TREE_LANG_FLAG_1 ((NODE))
753
754	/ Marks the result of a statement expression. /
755	#define EXPR_STMT_STMT_EXPR_RESULT(NODE) \
756	TREE_LANG_FLAG_0 (EXPR_STMT_CHECK (NODE))
757
758	/ Nonzero if this statement-expression does not have an associated scope. /
759	#define STMT_EXPR_NO_SCOPE(NODE) \
760	TREE_LANG_FLAG_0 (STMT_EXPR_CHECK (NODE))
761
762	#define COND_EXPR_IS_VEC_DELETE(NODE) \
763	TREE_LANG_FLAG_0 (COND_EXPR_CHECK (NODE))
764
765	/ Nonzero if this NOP_EXPR is a reinterpret_cast. Such conversions*
766	are not constexprs. Other NOP_EXPRs are. /*
767	#define REINTERPRET_CAST_P(NODE) \
768	TREE_LANG_FLAG_0 (NOP_EXPR_CHECK (NODE))
769
770	/ Returns nonzero iff TYPE1 and TYPE2 are the same type, in the usual*
771	sense of `same'. /*
772	#define same_type_p(TYPE1, TYPE2) \
773	comptypes ((TYPE1), (TYPE2), COMPARE_STRICT)
774
775	/ Returns nonzero iff NODE is a declaration for the global function*
776	`main'. /*
777	#define DECL_MAIN_ANY_P(NODE) \
778	(DECL_EXTERN_C_FUNCTION_P (NODE) \
779	&& DECL_NAME (NODE) != NULL_TREE \
780	&& MAIN_NAME_P (DECL_NAME (NODE)))
781
782	/ Nonzero iff NODE is a declaration for `int main', or we are hosted. /
783	#define DECL_MAIN_FREESTANDING_P(NODE) \
784	(DECL_MAIN_ANY_P(NODE) \
785	&& (flag_hosted \
786	\|\| TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (NODE))) \
787	== integer_type_node))
788
789	/ Nonzero iff NODE is a declaration for `main', and we are hosted. /
790	#define DECL_MAIN_P(NODE) (DECL_MAIN_ANY_P(NODE) && flag_hosted)
791
792	/ Lookup walker marking. /
793	#define LOOKUP_SEEN_P(NODE) TREE_VISITED (NODE)
794	#define LOOKUP_FOUND_P(NODE) \
795	TREE_LANG_FLAG_4 (TREE_CHECK4 (NODE,RECORD_TYPE,UNION_TYPE,ENUMERAL_TYPE,\
796	NAMESPACE_DECL))
797
798	/ These two accessors should only be used by OVL manipulators.*
799	Other users should use iterators and convenience functions. /*
800	#define OVL_FUNCTION(NODE) \
801	(((struct tree_overload*)OVERLOAD_CHECK (NODE))->function)
802	#define OVL_CHAIN(NODE) \
803	(((struct tree_overload*)OVERLOAD_CHECK (NODE))->common.chain)
804
805	/ If set, this or a subsequent overload contains decls that need deduping. /
806	#define OVL_DEDUP_P(NODE) TREE_LANG_FLAG_0 (OVERLOAD_CHECK (NODE))
807	/ If set, this was imported in a using declaration. /
808	#define OVL_USING_P(NODE) TREE_LANG_FLAG_1 (OVERLOAD_CHECK (NODE))
809	/ If set, this overload is a hidden decl. /
810	#define OVL_HIDDEN_P(NODE) TREE_LANG_FLAG_2 (OVERLOAD_CHECK (NODE))
811	/ If set, this overload contains a nested overload. /
812	#define OVL_NESTED_P(NODE) TREE_LANG_FLAG_3 (OVERLOAD_CHECK (NODE))
813	/ If set, this overload was constructed during lookup. /
814	#define OVL_LOOKUP_P(NODE) TREE_LANG_FLAG_4 (OVERLOAD_CHECK (NODE))
815	/ If set, this OVL_USING_P overload is exported. /
816	#define OVL_EXPORT_P(NODE) TREE_LANG_FLAG_5 (OVERLOAD_CHECK (NODE))
817	/ If set, this overload includes name-independent declarations. /
818	#define OVL_NAME_INDEPENDENT_DECL_P(NODE) \
819	TREE_LANG_FLAG_6 (OVERLOAD_CHECK (NODE))
820
821	/ The first decl of an overload. /
822	#define OVL_FIRST(NODE) ovl_first (NODE)
823	/ The name of the overload set. /
824	#define OVL_NAME(NODE) DECL_NAME (OVL_FIRST (NODE))
825
826	/ Whether this is a set of overloaded functions. TEMPLATE_DECLS are*
827	always wrapped in an OVERLOAD, so we don't need to check them
828	here. /*
829	#define OVL_P(NODE) \
830	(TREE_CODE (NODE) == FUNCTION_DECL \|\| TREE_CODE (NODE) == OVERLOAD)
831	/ Whether this is a single member overload. /
832	#define OVL_SINGLE_P(NODE) \
833	(TREE_CODE (NODE) != OVERLOAD \|\| !OVL_CHAIN (NODE))
834
835	/ OVL_HIDDEN_P nodes come before other nodes. /
836
837	struct GTY(()) tree_overload {
838	struct tree_common common;
839	tree function;
840	};
841
842	/ Iterator for a 1 dimensional overload. Permits iterating over the*
843	outer level of a 2-d overload when explicitly enabled. /*
844
845	class ovl_iterator {
846	tree ovl;
847	const bool allow_inner; / Only used when checking. /
848
849	public:
850	explicit ovl_iterator (tree o, bool allow = false)
851	: ovl (o), allow_inner (allow)
852	{
853	}
854
855	public:
856	operator bool () const
857	{
858	return ovl;
859	}
860	ovl_iterator &operator++ ()
861	{
862	ovl = TREE_CODE (ovl) != OVERLOAD ? NULL_TREE : OVL_CHAIN (ovl);
863	return *this;
864	}
865	tree operator* () const
866	{
867	tree fn = TREE_CODE (ovl) != OVERLOAD ? ovl : OVL_FUNCTION (ovl);
868
869	/ Check this is not an unexpected 2-dimensional overload. /
870	gcc_checking_assert (allow_inner \|\| TREE_CODE (fn) != OVERLOAD);
871
872	return fn;
873	}
874	bool operator== (const ovl_iterator &o) const
875	{
876	return ovl == o.ovl;
877	}
878	tree get_using () const
879	{
880	gcc_checking_assert (using_p ());
881	return ovl;
882	}
883
884	public:
885	/ Whether this overload was introduced by a using decl. /
886	bool using_p () const
887	{
888	return (TREE_CODE (ovl) == USING_DECL
889	\|\| (TREE_CODE (ovl) == OVERLOAD && OVL_USING_P (ovl)));
890	}
891	/ Whether this using is being exported. /
892	bool exporting_p () const
893	{
894	return OVL_EXPORT_P (get_using ());
895	}
896
897	bool hidden_p () const
898	{
899	return TREE_CODE (ovl) == OVERLOAD && OVL_HIDDEN_P (ovl);
900	}
901
902	public:
903	tree remove_node (tree head)
904	{
905	return remove_node (head, node: ovl);
906	}
907	tree reveal_node (tree head)
908	{
909	return reveal_node (ovl: head, node: ovl);
910	}
911
912	protected:
913	/ If we have a nested overload, point at the inner overload and*
914	return the next link on the outer one. /*
915	tree maybe_push ()
916	{
917	tree r = NULL_TREE;
918
919	if (ovl && TREE_CODE (ovl) == OVERLOAD && OVL_NESTED_P (ovl))
920	{
921	r = OVL_CHAIN (ovl);
922	ovl = OVL_FUNCTION (ovl);
923	}
924	return r;
925	}
926	/ Restore an outer nested overload. /
927	void pop (tree outer)
928	{
929	gcc_checking_assert (!ovl);
930	ovl = outer;
931	}
932
933	private:
934	/ We make these static functions to avoid the address of the*
935	iterator escaping the local context. /*
936	static tree remove_node (tree head, tree node);
937	static tree reveal_node (tree ovl, tree node);
938	};
939
940	/ Treat a tree as a range of ovl_iterator, e.g.*
941	for (tree f : ovl_range (fns)) { ... } /*
942
943	class ovl_range
944	{
945	tree t;
946	bool allow;
947	public:
948	explicit ovl_range (tree t, bool allow = false): t(t), allow(allow) { }
949	ovl_iterator begin() { return ovl_iterator (t, allow); }
950	ovl_iterator end() { return ovl_iterator (NULL_TREE, allow); }
951	};
952
953	/ Iterator over a (potentially) 2 dimensional overload, which is*
954	produced by name lookup. /*
955
956	class lkp_iterator : public ovl_iterator {
957	typedef ovl_iterator parent;
958
959	tree outer;
960
961	public:
962	explicit lkp_iterator (tree o)
963	: parent (o, true), outer (maybe_push ())
964	{
965	}
966
967	public:
968	lkp_iterator &operator++ ()
969	{
970	bool repush = !outer;
971
972	if (!parent::operator++ () && !repush)
973	{
974	pop (outer);
975	repush = true;
976	}
977
978	if (repush)
979	outer = maybe_push ();
980
981	return *this;
982	}
983	};
984
985	/ Treat a tree as a range of lkp_iterator, e.g.*
986	for (tree f : lkp_range (fns)) { ... } /*
987
988	class lkp_range
989	{
990	tree t;
991	public:
992	lkp_range (tree t): t(t) { }
993	lkp_iterator begin() { return lkp_iterator (t); }
994	lkp_iterator end() { return lkp_iterator (NULL_TREE); }
995	};
996
997	/ hash traits for declarations. Hashes potential overload sets via*
998	DECL_NAME. /*
999
1000	struct named_decl_hash : ggc_remove <tree> {
1001	typedef tree value_type; / A DECL or OVERLOAD /
1002	typedef tree compare_type; / An identifier. /
1003
1004	inline static hashval_t hash (const value_type decl);
1005	inline static bool equal (const value_type existing, compare_type candidate);
1006
1007	static const bool empty_zero_p = true;
1008	static inline void mark_empty (value_type &p) {p = NULL_TREE;}
1009	static inline bool is_empty (value_type p) {return !p;}
1010
1011	/ Nothing is deletable. Everything is insertable. /
1012	static bool is_deleted (value_type) { return false; }
1013	static void mark_deleted (value_type) { gcc_unreachable (); }
1014	};
1015
1016	/ Simplified unique_ptr clone to release a tree vec on exit. /
1017
1018	class releasing_vec
1019	{
1020	public:
1021	typedef vec<tree, va_gc> vec_t;
1022
1023	releasing_vec (vec_t *v): v(v) { }
1024	releasing_vec (): v(make_tree_vector ()) { }
1025
1026	/ Copy ops are deliberately declared but not defined,*
1027	copies must always be elided. /*
1028	releasing_vec (const releasing_vec &);
1029	releasing_vec &operator= (const releasing_vec &);
1030
1031	vec_t &operator* () const { return *v; }
1032	vec_t *operator-> () const { return v; }
1033	vec_t get() const* { return v; }
1034	operator vec_t () const* { return v; }
1035	vec_t operator& () { return** &v; }
1036
1037	/ Breaks pointer/value consistency for convenience. This takes ptrdiff_t*
1038	rather than unsigned to avoid ambiguity with the built-in operator[]
1039	(bootstrap/91828). /*
1040	tree& operator[] (ptrdiff_t i) const { return (*v)[i]; }
1041
1042	tree begin() { return* ::begin (v); }
1043	tree end() { return* ::end (v); }
1044
1045	void release () { release_tree_vector (v); v = NULL; }
1046
1047	~releasing_vec () { release_tree_vector (v); }
1048	private:
1049	vec_t *v;
1050	};
1051	/ Forwarding functions for vec_safe_* that might reallocate. /
1052	inline tree* vec_safe_push (releasing_vec& r, const tree &t CXX_MEM_STAT_INFO)
1053	{ return vec_safe_push (v&: *&r, obj: t PASS_MEM_STAT); }
1054	inline bool vec_safe_reserve (releasing_vec& r, unsigned n, bool e = false CXX_MEM_STAT_INFO)
1055	{ return vec_safe_reserve (v&: *&r, nelems: n, exact: e PASS_MEM_STAT); }
1056	inline unsigned vec_safe_length (releasing_vec &r)
1057	{ return r ->length(); }
1058	inline void vec_safe_splice (releasing_vec &r, vec<tree, va_gc> *p CXX_MEM_STAT_INFO)
1059	{ vec_safe_splice (dst&: *&r, src: p PASS_MEM_STAT); }
1060	void release_tree_vector (releasing_vec &); // cause link error
1061
1062	struct GTY(()) tree_template_decl {
1063	struct tree_decl_common common;
1064	tree arguments;
1065	tree result;
1066	};
1067
1068	/ Returns true iff NODE is a BASELINK. /
1069	#define BASELINK_P(NODE) \
1070	(TREE_CODE (NODE) == BASELINK)
1071	/ The BINFO indicating the base in which lookup found the*
1072	BASELINK_FUNCTIONS. /*
1073	#define BASELINK_BINFO(NODE) \
1074	(((struct tree_baselink*) BASELINK_CHECK (NODE))->binfo)
1075	/ The functions referred to by the BASELINK; either a FUNCTION_DECL,*
1076	a TEMPLATE_DECL, an OVERLOAD, or a TEMPLATE_ID_EXPR. /*
1077	#define BASELINK_FUNCTIONS(NODE) \
1078	(((struct tree_baselink*) BASELINK_CHECK (NODE))->functions)
1079	/ If T is a BASELINK, grab the functions, otherwise just T, which is*
1080	expected to already be a (list of) functions. /*
1081	#define MAYBE_BASELINK_FUNCTIONS(T) \
1082	(BASELINK_P (T) ? BASELINK_FUNCTIONS (T) : T)
1083	/ The BINFO in which the search for the functions indicated by this baselink*
1084	began. This base is used to determine the accessibility of functions
1085	selected by overload resolution. /*
1086	#define BASELINK_ACCESS_BINFO(NODE) \
1087	(((struct tree_baselink*) BASELINK_CHECK (NODE))->access_binfo)
1088	/ For a type-conversion operator, the BASELINK_OPTYPE indicates the type*
1089	to which the conversion should occur. This value is important if
1090	the BASELINK_FUNCTIONS include a template conversion operator --
1091	the BASELINK_OPTYPE can be used to determine what type the user
1092	requested. /*
1093	#define BASELINK_OPTYPE(NODE) \
1094	(TREE_CHAIN (BASELINK_CHECK (NODE)))
1095	/ Nonzero if this baselink was from a qualified lookup. /
1096	#define BASELINK_QUALIFIED_P(NODE) \
1097	TREE_LANG_FLAG_0 (BASELINK_CHECK (NODE))
1098	/ Nonzero if the overload set for this baselink might be incomplete due*
1099	to the lookup being performed from an incomplete-class context. /*
1100	#define BASELINK_FUNCTIONS_MAYBE_INCOMPLETE_P(NODE) \
1101	TREE_LANG_FLAG_1 (BASELINK_CHECK (NODE))
1102
1103	struct GTY(()) tree_baselink {
1104	struct tree_common common;
1105	tree binfo;
1106	tree functions;
1107	tree access_binfo;
1108	};
1109
1110	/ The different kinds of ids that we encounter. /
1111
1112	enum cp_id_kind
1113	{
1114	/ Not an id at all. /
1115	CP_ID_KIND_NONE,
1116	/ An unqualified-id that is not a template-id. /
1117	CP_ID_KIND_UNQUALIFIED,
1118	/ An unqualified-id that is a dependent name. /
1119	CP_ID_KIND_UNQUALIFIED_DEPENDENT,
1120	/ An unqualified template-id. /
1121	CP_ID_KIND_TEMPLATE_ID,
1122	/ A qualified-id. /
1123	CP_ID_KIND_QUALIFIED
1124	};
1125
1126
1127	/ The various kinds of C++0x warnings we encounter. /
1128
1129	enum cpp0x_warn_str
1130	{
1131	/ extended initializer lists /
1132	CPP0X_INITIALIZER_LISTS,
1133	/ explicit conversion operators /
1134	CPP0X_EXPLICIT_CONVERSION,
1135	/ variadic templates /
1136	CPP0X_VARIADIC_TEMPLATES,
1137	/ lambda expressions /
1138	CPP0X_LAMBDA_EXPR,
1139	/ C++0x auto /
1140	CPP0X_AUTO,
1141	/ scoped enums /
1142	CPP0X_SCOPED_ENUMS,
1143	/ defaulted and deleted functions /
1144	CPP0X_DEFAULTED_DELETED,
1145	/ inline namespaces /
1146	CPP0X_INLINE_NAMESPACES,
1147	/ override controls, override/final /
1148	CPP0X_OVERRIDE_CONTROLS,
1149	/ non-static data member initializers /
1150	CPP0X_NSDMI,
1151	/ user defined literals /
1152	CPP0X_USER_DEFINED_LITERALS,
1153	/ delegating constructors /
1154	CPP0X_DELEGATING_CTORS,
1155	/ inheriting constructors /
1156	CPP0X_INHERITING_CTORS,
1157	/ C++11 attributes /
1158	CPP0X_ATTRIBUTES,
1159	/ ref-qualified member functions /
1160	CPP0X_REF_QUALIFIER
1161	};
1162
1163	/ The various kinds of operation used by composite_pointer_type. /
1164
1165	enum composite_pointer_operation
1166	{
1167	/ comparison /
1168	CPO_COMPARISON,
1169	/ conversion /
1170	CPO_CONVERSION,
1171	/ conditional expression /
1172	CPO_CONDITIONAL_EXPR
1173	};
1174
1175	/ Possible cases of expression list used by build_x_compound_expr_from_list. /
1176	enum expr_list_kind {
1177	ELK_INIT, / initializer /
1178	ELK_MEM_INIT, / member initializer /
1179	ELK_FUNC_CAST / functional cast /
1180	};
1181
1182	/ Possible cases of implicit bad rhs conversions. /
1183	enum impl_conv_rhs {
1184	ICR_DEFAULT_ARGUMENT, / default argument /
1185	ICR_CONVERTING, / converting /
1186	ICR_INIT, / initialization /
1187	ICR_ARGPASS, / argument passing /
1188	ICR_RETURN, / return /
1189	ICR_ASSIGN / assignment /
1190	};
1191
1192	/ Possible cases of implicit or explicit bad conversions to void. /
1193	enum impl_conv_void {
1194	ICV_CAST, / (explicit) conversion to void /
1195	ICV_SECOND_OF_COND, / second operand of conditional expression /
1196	ICV_THIRD_OF_COND, / third operand of conditional expression /
1197	ICV_RIGHT_OF_COMMA, / right operand of comma operator /
1198	ICV_LEFT_OF_COMMA, / left operand of comma operator /
1199	ICV_STATEMENT, / statement /
1200	ICV_THIRD_IN_FOR / for increment expression /
1201	};
1202
1203	/ Possible invalid uses of an abstract class that might not have a*
1204	specific associated declaration. /*
1205	enum GTY(()) abstract_class_use {
1206	ACU_UNKNOWN, / unknown or decl provided /
1207	ACU_CAST, / cast to abstract class /
1208	ACU_NEW, / new-expression of abstract class /
1209	ACU_THROW, / throw-expression of abstract class /
1210	ACU_CATCH, / catch-parameter of abstract class /
1211	ACU_ARRAY, / array of abstract class /
1212	ACU_RETURN, / return type of abstract class /
1213	ACU_PARM / parameter type of abstract class /
1214	};
1215
1216	/ Macros for access to language-specific slots in an identifier. /
1217
1218	/ Identifiers map directly to block or class-scope bindings.*
1219	Namespace-scope bindings are held in hash tables on the respective
1220	namespaces. The identifier bindings are the innermost active
1221	binding, from whence you can get the decl and/or implicit-typedef
1222	of an elaborated type. When not bound to a local entity the
1223	values are NULL. /*
1224	#define IDENTIFIER_BINDING(NODE) \
1225	(LANG_IDENTIFIER_CAST (NODE)->bindings)
1226	#define REAL_IDENTIFIER_TYPE_VALUE(NODE) TREE_TYPE (NODE)
1227	#define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = (TYPE))
1228
1229	/ Kinds of identifiers. Values are carefully chosen. /
1230	enum cp_identifier_kind {
1231	cik_normal = `0`, / Not a special identifier. /
1232	cik_keyword = `1`, / A keyword. /
1233	cik_ctor = `2`, / Constructor (in-chg, complete or base). /
1234	cik_dtor = `3`, / Destructor (in-chg, deleting, complete or*
1235	base). /*
1236	cik_simple_op = `4`, / Non-assignment operator name. /
1237	cik_assign_op = `5`, / An assignment operator name. /
1238	cik_conv_op = `6`, / Conversion operator name. /
1239	cik_trait = `7`, / Built-in trait name. /
1240	cik_max
1241	};
1242
1243	/ Kind bits. /
1244	#define IDENTIFIER_KIND_BIT_0(NODE) \
1245	TREE_LANG_FLAG_0 (IDENTIFIER_NODE_CHECK (NODE))
1246	#define IDENTIFIER_KIND_BIT_1(NODE) \
1247	TREE_LANG_FLAG_1 (IDENTIFIER_NODE_CHECK (NODE))
1248	#define IDENTIFIER_KIND_BIT_2(NODE) \
1249	TREE_LANG_FLAG_2 (IDENTIFIER_NODE_CHECK (NODE))
1250
1251	/ Used by various search routines. /
1252	#define IDENTIFIER_MARKED(NODE) \
1253	TREE_LANG_FLAG_4 (IDENTIFIER_NODE_CHECK (NODE))
1254
1255	/ Nonzero if this identifier is used as a virtual function name somewhere*
1256	(optimizes searches). /*
1257	#define IDENTIFIER_VIRTUAL_P(NODE) \
1258	TREE_LANG_FLAG_5 (IDENTIFIER_NODE_CHECK (NODE))
1259
1260	/ True if this identifier is a reserved word. C_RID_CODE (node) is*
1261	then the RID_ value of the keyword. Value 1. /
1262	#define IDENTIFIER_KEYWORD_P(NODE) \
1263	((!IDENTIFIER_KIND_BIT_2 (NODE)) \
1264	& (!IDENTIFIER_KIND_BIT_1 (NODE)) \
1265	& IDENTIFIER_KIND_BIT_0 (NODE))
1266
1267	/ True if this identifier is the name of a constructor or*
1268	destructor. Value 2 or 3. /*
1269	#define IDENTIFIER_CDTOR_P(NODE) \
1270	((!IDENTIFIER_KIND_BIT_2 (NODE)) \
1271	& IDENTIFIER_KIND_BIT_1 (NODE))
1272
1273	/ True if this identifier is the name of a constructor. Value 2. /
1274	#define IDENTIFIER_CTOR_P(NODE) \
1275	(IDENTIFIER_CDTOR_P(NODE) \
1276	& (!IDENTIFIER_KIND_BIT_0 (NODE)))
1277
1278	/ True if this identifier is the name of a destructor. Value 3. /
1279	#define IDENTIFIER_DTOR_P(NODE) \
1280	(IDENTIFIER_CDTOR_P(NODE) \
1281	& IDENTIFIER_KIND_BIT_0 (NODE))
1282
1283	/ True if this identifier is for any operator name (including*
1284	conversions). Value 4, 5, or 6. /*
1285	#define IDENTIFIER_ANY_OP_P(NODE) \
1286	(IDENTIFIER_KIND_BIT_2 (NODE) && !IDENTIFIER_TRAIT_P (NODE))
1287
1288	/ True if this identifier is for an overloaded operator. Values 4, 5. /
1289	#define IDENTIFIER_OVL_OP_P(NODE) \
1290	(IDENTIFIER_ANY_OP_P (NODE) \
1291	& (!IDENTIFIER_KIND_BIT_1 (NODE)))
1292
1293	/ True if this identifier is for any assignment. Values 5. /
1294	#define IDENTIFIER_ASSIGN_OP_P(NODE) \
1295	(IDENTIFIER_OVL_OP_P (NODE) \
1296	& IDENTIFIER_KIND_BIT_0 (NODE))
1297
1298	/ True if this identifier is the name of a type-conversion*
1299	operator. Value 6. /*
1300	#define IDENTIFIER_CONV_OP_P(NODE) \
1301	(IDENTIFIER_ANY_OP_P (NODE) \
1302	& IDENTIFIER_KIND_BIT_1 (NODE) \
1303	& (!IDENTIFIER_KIND_BIT_0 (NODE)))
1304
1305	/ True if this identifier is the name of a built-in trait. /
1306	#define IDENTIFIER_TRAIT_P(NODE) \
1307	(IDENTIFIER_KIND_BIT_0 (NODE) \
1308	& IDENTIFIER_KIND_BIT_1 (NODE) \
1309	& IDENTIFIER_KIND_BIT_2 (NODE))
1310
1311	/ True if this identifier is a new or delete operator. /
1312	#define IDENTIFIER_NEWDEL_OP_P(NODE) \
1313	(IDENTIFIER_OVL_OP_P (NODE) \
1314	&& IDENTIFIER_OVL_OP_FLAGS (NODE) & OVL_OP_FLAG_ALLOC)
1315
1316	/ True if this identifier is a new operator. /
1317	#define IDENTIFIER_NEW_OP_P(NODE) \
1318	(IDENTIFIER_OVL_OP_P (NODE) \
1319	&& (IDENTIFIER_OVL_OP_FLAGS (NODE) \
1320	& (OVL_OP_FLAG_ALLOC \| OVL_OP_FLAG_DELETE)) == OVL_OP_FLAG_ALLOC)
1321
1322	/ Access a C++-specific index for identifier NODE.*
1323	Used to optimize operator mappings etc. /*
1324	#define IDENTIFIER_CP_INDEX(NODE) \
1325	(IDENTIFIER_NODE_CHECK(NODE)->base.u.bits.address_space)
1326
1327	/ In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only. /
1328	#define C_TYPE_FIELDS_READONLY(TYPE) \
1329	(LANG_TYPE_CLASS_CHECK (TYPE)->fields_readonly)
1330
1331	/ The tokens stored in the unparsed operand. /
1332
1333	#define DEFPARSE_TOKENS(NODE) \
1334	(((struct tree_deferred_parse *)DEFERRED_PARSE_CHECK (NODE))->tokens)
1335	#define DEFPARSE_INSTANTIATIONS(NODE) \
1336	(((struct tree_deferred_parse *)DEFERRED_PARSE_CHECK (NODE))->instantiations)
1337
1338	struct GTY (()) tree_deferred_parse {
1339	struct tree_base base;
1340	struct cp_token_cache *tokens;
1341	vec<tree, va_gc> *instantiations;
1342	};
1343
1344
1345	#define DEFERRED_NOEXCEPT_PATTERN(NODE) \
1346	(((struct tree_deferred_noexcept *)DEFERRED_NOEXCEPT_CHECK (NODE))->pattern)
1347	#define DEFERRED_NOEXCEPT_ARGS(NODE) \
1348	(((struct tree_deferred_noexcept *)DEFERRED_NOEXCEPT_CHECK (NODE))->args)
1349	#define DEFERRED_NOEXCEPT_SPEC_P(NODE) \
1350	((NODE) && (TREE_PURPOSE (NODE)) \
1351	&& (TREE_CODE (TREE_PURPOSE (NODE)) == DEFERRED_NOEXCEPT))
1352	#define UNEVALUATED_NOEXCEPT_SPEC_P(NODE) \
1353	(DEFERRED_NOEXCEPT_SPEC_P (NODE) \
1354	&& DEFERRED_NOEXCEPT_PATTERN (TREE_PURPOSE (NODE)) == NULL_TREE)
1355	#define UNPARSED_NOEXCEPT_SPEC_P(NODE) \
1356	((NODE) && (TREE_PURPOSE (NODE)) \
1357	&& (TREE_CODE (TREE_PURPOSE (NODE)) == DEFERRED_PARSE))
1358
1359	struct GTY (()) tree_deferred_noexcept {
1360	struct tree_base base;
1361	tree pattern;
1362	tree args;
1363	};
1364
1365
1366	/ The condition associated with the static assertion. This must be*
1367	an integral constant expression. /*
1368	#define STATIC_ASSERT_CONDITION(NODE) \
1369	(((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->condition)
1370
1371	/ The message associated with the static assertion. This must be a*
1372	string constant, which will be emitted as an error message when the
1373	static assert condition is false. /*
1374	#define STATIC_ASSERT_MESSAGE(NODE) \
1375	(((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->message)
1376
1377	/ Source location information for a static assertion. /
1378	#define STATIC_ASSERT_SOURCE_LOCATION(NODE) \
1379	(((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->location)
1380
1381	struct GTY (()) tree_static_assert {
1382	struct tree_common common;
1383	tree condition;
1384	tree message;
1385	location_t location;
1386	};
1387
1388	struct GTY (()) tree_argument_pack_select {
1389	struct tree_common common;
1390	tree argument_pack;
1391	int index;
1392	};
1393
1394	/ The different kinds of traits that we encounter. The size is limited to*
1395	addr_space_t since a trait is looked up by IDENTIFIER_CP_INDEX. /*
1396	enum cp_trait_kind : addr_space_t {
1397	#define DEFTRAIT(TCC, CODE, NAME, ARITY) \
1398	CPTK_##CODE,
1399	#include "cp-trait.def"
1400	#undef DEFTRAIT
1401	};
1402
1403	/ The trait type. /
1404	struct cp_trait {
1405	const char *name;
1406	cp_trait_kind kind;
1407	short arity;
1408	bool type;
1409	};
1410
1411	/ The trait table indexed by cp_trait_kind. /
1412	extern const struct cp_trait cp_traits[];
1413
1414	/ The types that we are processing. /
1415	#define TRAIT_EXPR_TYPE1(NODE) \
1416	(((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type1)
1417
1418	#define TRAIT_EXPR_TYPE2(NODE) \
1419	(((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type2)
1420
1421	/ The specific trait that we are processing. /
1422	#define TRAIT_EXPR_KIND(NODE) \
1423	(((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->kind)
1424
1425	#define TRAIT_EXPR_LOCATION(NODE) \
1426	(((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->locus)
1427
1428	struct GTY (()) tree_trait_expr {
1429	struct tree_common common;
1430	tree type1;
1431	tree type2;
1432	location_t locus;
1433	enum cp_trait_kind kind;
1434	};
1435
1436	/ An INTEGER_CST containing the kind of the trait type NODE. /
1437	#define TRAIT_TYPE_KIND_RAW(NODE) \
1438	TYPE_VALUES_RAW (TRAIT_TYPE_CHECK (NODE))
1439
1440	/ The kind of the trait type NODE. /
1441	#define TRAIT_TYPE_KIND(NODE) \
1442	((enum cp_trait_kind) TREE_INT_CST_LOW (TRAIT_TYPE_KIND_RAW (NODE)))
1443
1444	/ The first argument of the trait type NODE. /
1445	#define TRAIT_TYPE_TYPE1(NODE) \
1446	TYPE_MIN_VALUE_RAW (TRAIT_TYPE_CHECK (NODE))
1447
1448	/ The rest of the arguments of the trait type NODE. /
1449	#define TRAIT_TYPE_TYPE2(NODE) \
1450	TYPE_MAX_VALUE_RAW (TRAIT_TYPE_CHECK (NODE))
1451
1452	/ Identifiers used for lambda types are almost anonymous. Use this*
1453	spare flag to distinguish them (they also have the anonymous flag). /*
1454	#define IDENTIFIER_LAMBDA_P(NODE) \
1455	(IDENTIFIER_NODE_CHECK(NODE)->base.protected_flag)
1456
1457	/ Based off of TYPE_UNNAMED_P. /
1458	#define LAMBDA_TYPE_P(NODE) \
1459	(TREE_CODE (NODE) == RECORD_TYPE \
1460	&& TYPE_LINKAGE_IDENTIFIER (NODE) \
1461	&& IDENTIFIER_LAMBDA_P (TYPE_LINKAGE_IDENTIFIER (NODE)))
1462
1463	/ Test if FUNCTION_DECL is a lambda function. /
1464	#define LAMBDA_FUNCTION_P(FNDECL) \
1465	(DECL_DECLARES_FUNCTION_P (FNDECL) \
1466	&& DECL_OVERLOADED_OPERATOR_P (FNDECL) \
1467	&& DECL_OVERLOADED_OPERATOR_IS (FNDECL, CALL_EXPR) \
1468	&& LAMBDA_TYPE_P (CP_DECL_CONTEXT (FNDECL)))
1469
1470	enum cp_lambda_default_capture_mode_type {
1471	CPLD_NONE,
1472	CPLD_COPY,
1473	CPLD_REFERENCE
1474	};
1475
1476	/ The method of default capture, if any. /
1477	#define LAMBDA_EXPR_DEFAULT_CAPTURE_MODE(NODE) \
1478	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->default_capture_mode)
1479
1480	/ The capture-list, including `this'. Each capture is stored as a FIELD_DECL*
1481	* so that the name, type, and field are all together, whether or not it has
1482	* been added to the lambda's class type.
1483	TREE_LIST:
1484	TREE_PURPOSE: The FIELD_DECL for this capture.
1485	TREE_VALUE: The initializer. This is part of a GNU extension. /*
1486	#define LAMBDA_EXPR_CAPTURE_LIST(NODE) \
1487	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->capture_list)
1488
1489	/ During parsing of the lambda-introducer, the node in the capture-list*
1490	that holds the 'this' capture. During parsing of the body, the
1491	capture proxy for that node. /*
1492	#define LAMBDA_EXPR_THIS_CAPTURE(NODE) \
1493	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->this_capture)
1494
1495	/ Predicate tracking whether `this' is in the effective capture set. /
1496	#define LAMBDA_EXPR_CAPTURES_THIS_P(NODE) \
1497	LAMBDA_EXPR_THIS_CAPTURE(NODE)
1498
1499	/ True iff uses of a const variable capture were optimized away. /
1500	#define LAMBDA_EXPR_CAPTURE_OPTIMIZED(NODE) \
1501	TREE_LANG_FLAG_2 (LAMBDA_EXPR_CHECK (NODE))
1502
1503	/ Predicate tracking whether the lambda was declared 'static'. /
1504	#define LAMBDA_EXPR_STATIC_P(NODE) \
1505	TREE_LANG_FLAG_3 (LAMBDA_EXPR_CHECK (NODE))
1506
1507	/ True if this TREE_LIST in LAMBDA_EXPR_CAPTURE_LIST is for an explicit*
1508	capture. /*
1509	#define LAMBDA_CAPTURE_EXPLICIT_P(NODE) \
1510	TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
1511
1512	/ The source location of the lambda. /
1513	#define LAMBDA_EXPR_LOCATION(NODE) \
1514	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->locus)
1515
1516	/ The mangling scope for the lambda: FUNCTION_DECL, PARM_DECL, VAR_DECL,*
1517	FIELD_DECL or NULL_TREE. If this is NULL_TREE, we have no linkage. /*
1518	#define LAMBDA_EXPR_EXTRA_SCOPE(NODE) \
1519	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->extra_scope)
1520
1521	/ Lambdas in the same extra scope might need a discriminating count.*
1522	For ABI 17, we have single per-scope count, for ABI 18, we have
1523	per-scope, per-signature numbering. /*
1524	#define LAMBDA_EXPR_SCOPE_ONLY_DISCRIMINATOR(NODE) \
1525	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->discriminator_scope)
1526	#define LAMBDA_EXPR_SCOPE_SIG_DISCRIMINATOR(NODE) \
1527	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->discriminator_sig)
1528
1529	/ During parsing of the lambda, a vector of capture proxies which need*
1530	to be pushed once we're done processing a nested lambda. /*
1531	#define LAMBDA_EXPR_PENDING_PROXIES(NODE) \
1532	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->pending_proxies)
1533
1534	/ If NODE was regenerated via tsubst_lambda_expr, this is a TEMPLATE_INFO*
1535	whose TI_TEMPLATE is the immediate LAMBDA_EXPR from which NODE was
1536	regenerated, and TI_ARGS is the full set of template arguments used
1537	to regenerate NODE from the most general lambda. /*
1538	#define LAMBDA_EXPR_REGEN_INFO(NODE) \
1539	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->regen_info)
1540
1541	/ Like PACK_EXPANSION_EXTRA_ARGS, for lambda-expressions. /
1542	#define LAMBDA_EXPR_EXTRA_ARGS(NODE) \
1543	(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->extra_args)
1544
1545	/ The closure type of the lambda, which is also the type of the*
1546	LAMBDA_EXPR. /*
1547	#define LAMBDA_EXPR_CLOSURE(NODE) \
1548	(TREE_TYPE (LAMBDA_EXPR_CHECK (NODE)))
1549
1550	struct GTY (()) tree_lambda_expr
1551	{
1552	struct tree_typed typed;
1553	tree capture_list;
1554	tree this_capture;
1555	tree extra_scope;
1556	tree regen_info;
1557	tree extra_args;
1558	vec<tree, va_gc> *pending_proxies;
1559	location_t locus;
1560	enum cp_lambda_default_capture_mode_type default_capture_mode : `2`;
1561	unsigned discriminator_scope : `15`; // Per-scope discriminator
1562	unsigned discriminator_sig : `15`; // Per-scope, per-signature discriminator
1563	};
1564
1565	/ Non-zero if this template specialization has access violations that*
1566	should be rechecked when the function is instantiated outside argument
1567	deduction. /*
1568	#define TINFO_HAS_ACCESS_ERRORS(NODE) \
1569	(TREE_LANG_FLAG_0 (TEMPLATE_INFO_CHECK (NODE)))
1570	#define FNDECL_HAS_ACCESS_ERRORS(NODE) \
1571	(TINFO_HAS_ACCESS_ERRORS (DECL_TEMPLATE_INFO (NODE)))
1572
1573	/ Non-zero if this variable template specialization was specified using a*
1574	template-id, so it's a partial or full specialization and not a definition
1575	of the member template of a particular class specialization. /*
1576	#define TINFO_USED_TEMPLATE_ID(NODE) \
1577	(TREE_LANG_FLAG_1 (TEMPLATE_INFO_CHECK (NODE)))
1578
1579	/ The representation of a deferred access check. /
1580
1581	struct GTY(()) deferred_access_check {
1582	/ The base class in which the declaration is referenced. /
1583	tree binfo;
1584	/ The declaration whose access must be checked. /
1585	tree decl;
1586	/ The declaration that should be used in the error message. /
1587	tree diag_decl;
1588	/ The location of this access. /
1589	location_t loc;
1590	};
1591
1592	struct GTY(()) tree_template_info {
1593	struct tree_base base;
1594	tree tmpl;
1595	tree args;
1596	tree partial;
1597	vec<deferred_access_check, va_gc> *deferred_access_checks;
1598	};
1599
1600	// Constraint information for a C++ declaration. Constraint information is
1601	// comprised of:
1602	//
1603	// - a constraint expression introduced by the template header
1604	// - a constraint expression introduced by a function declarator
1605	// - the associated constraints, which are the conjunction of those,
1606	// and used for declaration matching
1607	//
1608	// The template and declarator requirements are kept to support pretty
1609	// printing constrained declarations.
1610	struct GTY(()) tree_constraint_info {
1611	struct tree_base base;
1612	tree template_reqs;
1613	tree declarator_reqs;
1614	tree associated_constr;
1615	};
1616
1617	// Require that pointer P is non-null before returning.
1618	template<typename T>
1619	inline T*
1620	check_nonnull (T* p)
1621	{
1622	gcc_assert (p);
1623	return p;
1624	}
1625
1626	/ Returns true iff T is non-null and represents constraint info. /
1627	inline tree_constraint_info *
1628	check_constraint_info (tree t)
1629	{
1630	if (t && TREE_CODE (t) == CONSTRAINT_INFO)
1631	return (tree_constraint_info *)t;
1632	return NULL;
1633	}
1634
1635	/ Access the expression describing the template constraints. This may be*
1636	null if no constraints were introduced in the template parameter list,
1637	a requirements clause after the template parameter list, or constraints
1638	through a constrained-type-specifier. /*
1639	#define CI_TEMPLATE_REQS(NODE) \
1640	check_constraint_info (check_nonnull (NODE))->template_reqs
1641
1642	/ Access the expression describing the trailing constraints. This is non-null*
1643	for any implicit instantiation of a constrained declaration. For a
1644	templated declaration it is non-null only when a trailing requires-clause
1645	was specified. /*
1646	#define CI_DECLARATOR_REQS(NODE) \
1647	check_constraint_info (check_nonnull (NODE))->declarator_reqs
1648
1649	/ The computed associated constraint expression for a declaration. /
1650	#define CI_ASSOCIATED_CONSTRAINTS(NODE) \
1651	check_constraint_info (check_nonnull (NODE))->associated_constr
1652
1653	/ Access the constraint-expression introduced by the requires-clause*
1654	associate the template parameter list NODE. /*
1655	#define TEMPLATE_PARMS_CONSTRAINTS(NODE) \
1656	TREE_TYPE (TREE_LIST_CHECK (NODE))
1657
1658	/ Access the logical constraints on the template parameter declaration*
1659	indicated by NODE. /*
1660	#define TEMPLATE_PARM_CONSTRAINTS(NODE) \
1661	TREE_TYPE (TREE_LIST_CHECK (NODE))
1662
1663	/ Non-zero if the noexcept is present in a compound requirement. /
1664	#define COMPOUND_REQ_NOEXCEPT_P(NODE) \
1665	TREE_LANG_FLAG_0 (TREE_CHECK (NODE, COMPOUND_REQ))
1666
1667	/ A TREE_LIST whose TREE_VALUE is the constraints on the 'auto' placeholder*
1668	type NODE, used in an argument deduction constraint. The TREE_PURPOSE
1669	holds the set of template parameters that were in-scope when this 'auto'
1670	was formed. /*
1671	#define PLACEHOLDER_TYPE_CONSTRAINTS_INFO(NODE) \
1672	DECL_SIZE_UNIT (TYPE_NAME (TEMPLATE_TYPE_PARM_CHECK (NODE)))
1673
1674	/ The constraints on the 'auto' placeholder type NODE. /
1675	#define PLACEHOLDER_TYPE_CONSTRAINTS(NODE) \
1676	(PLACEHOLDER_TYPE_CONSTRAINTS_INFO (NODE) \
1677	? TREE_VALUE (PLACEHOLDER_TYPE_CONSTRAINTS_INFO (NODE)) \
1678	: NULL_TREE)
1679
1680	/ True if NODE is a constraint. /
1681	#define CONSTR_P(NODE) \
1682	(TREE_CODE (NODE) == ATOMIC_CONSTR \
1683	\|\| TREE_CODE (NODE) == CONJ_CONSTR \
1684	\|\| TREE_CODE (NODE) == DISJ_CONSTR)
1685
1686	/ Valid for any normalized constraint. /
1687	#define CONSTR_CHECK(NODE) \
1688	TREE_CHECK3 (NODE, ATOMIC_CONSTR, CONJ_CONSTR, DISJ_CONSTR)
1689
1690	/ The CONSTR_INFO stores normalization data for a constraint. It refers to*
1691	the original expression and the expression or declaration
1692	from which the constraint was normalized.
1693
1694	This is TREE_LIST whose TREE_PURPOSE is the original expression and whose
1695	TREE_VALUE is a list of contexts. /*
1696	#define CONSTR_INFO(NODE) \
1697	TREE_TYPE (CONSTR_CHECK (NODE))
1698
1699	/ The expression evaluated by the constraint. /
1700	#define CONSTR_EXPR(NODE) \
1701	TREE_PURPOSE (CONSTR_INFO (NODE))
1702
1703	/ The expression or declaration from which this constraint was normalized.*
1704	This is a TREE_LIST whose TREE_VALUE is either a template-id expression
1705	denoting a concept check or the declaration introducing the constraint.
1706	These are chained to other context objects. /*
1707	#define CONSTR_CONTEXT(NODE) \
1708	TREE_VALUE (CONSTR_INFO (NODE))
1709
1710	/ The parameter mapping for an atomic constraint. /
1711	#define ATOMIC_CONSTR_MAP(NODE) \
1712	TREE_OPERAND (TREE_CHECK (NODE, ATOMIC_CONSTR), 0)
1713
1714	/ Whether the parameter mapping of this atomic constraint*
1715	is already instantiated with concrete template arguments.
1716	Used only in satisfy_atom and in the satisfaction cache. /*
1717	#define ATOMIC_CONSTR_MAP_INSTANTIATED_P(NODE) \
1718	TREE_LANG_FLAG_0 (ATOMIC_CONSTR_CHECK (NODE))
1719
1720	/ Whether the expression for this atomic constraint belongs to a*
1721	concept definition. /*
1722	#define ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P(NODE) \
1723	TREE_LANG_FLAG_1 (ATOMIC_CONSTR_CHECK (NODE))
1724
1725	/ The expression of an atomic constraint. /
1726	#define ATOMIC_CONSTR_EXPR(NODE) \
1727	CONSTR_EXPR (ATOMIC_CONSTR_CHECK (NODE))
1728
1729	/ The concept of a concept check. /
1730	#define CHECK_CONSTR_CONCEPT(NODE) \
1731	TREE_OPERAND (TREE_CHECK (NODE, CHECK_CONSTR), 0)
1732
1733	/ The template arguments of a concept check. /
1734	#define CHECK_CONSTR_ARGS(NODE) \
1735	TREE_OPERAND (TREE_CHECK (NODE, CHECK_CONSTR), 1)
1736
1737	/ Whether a PARM_DECL represents a local parameter in a*
1738	requires-expression. /*
1739	#define CONSTRAINT_VAR_P(NODE) \
1740	DECL_LANG_FLAG_2 (TREE_CHECK (NODE, PARM_DECL))
1741
1742	/ The concept constraining this constrained template-parameter. /
1743	#define CONSTRAINED_PARM_CONCEPT(NODE) \
1744	DECL_SIZE_UNIT (TYPE_DECL_CHECK (NODE))
1745	/ Any extra template arguments specified for a constrained*
1746	template-parameter. /*
1747	#define CONSTRAINED_PARM_EXTRA_ARGS(NODE) \
1748	DECL_SIZE (TYPE_DECL_CHECK (NODE))
1749	/ The first template parameter of CONSTRAINED_PARM_CONCEPT to be used as a*
1750	prototype for the constrained parameter in finish_shorthand_constraint,
1751	attached for convenience. /*
1752	#define CONSTRAINED_PARM_PROTOTYPE(NODE) \
1753	DECL_INITIAL (TYPE_DECL_CHECK (NODE))
1754
1755	/ Module flags on FUNCTION,VAR,TYPE,CONCEPT or NAMESPACE*
1756	A TEMPLATE_DECL holds them on the DECL_TEMPLATE_RESULT object --
1757	it's just not practical to keep them consistent. /*
1758	#define DECL_MODULE_CHECK(NODE) \
1759	TREE_NOT_CHECK (NODE, TEMPLATE_DECL)
1760
1761	/ In the purview of a named module (or in the purview of the*
1762	header-unit being compiled). /*
1763	#define DECL_MODULE_PURVIEW_P(N) \
1764	(DECL_LANG_SPECIFIC (DECL_MODULE_CHECK (N))->u.base.module_purview_p)
1765
1766	/ Attached to the named module it is in the purview of. Decls*
1767	attached to the global module will have this false. /*
1768	#define DECL_MODULE_ATTACH_P(N) \
1769	(DECL_LANG_SPECIFIC (DECL_MODULE_CHECK (N))->u.base.module_attach_p)
1770
1771	/ True if the live version of the decl was imported. /
1772	#define DECL_MODULE_IMPORT_P(NODE) \
1773	(DECL_LANG_SPECIFIC (DECL_MODULE_CHECK (NODE))->u.base.module_import_p)
1774
1775	/ True if this decl is in the entity hash & array. This means that*
1776	some variant was imported, even if DECL_MODULE_IMPORT_P is false. /*
1777	#define DECL_MODULE_ENTITY_P(NODE) \
1778	(DECL_LANG_SPECIFIC (DECL_MODULE_CHECK (NODE))->u.base.module_entity_p)
1779
1780	/ DECL that has attached decls for ODR-relatedness. /
1781	#define DECL_MODULE_KEYED_DECLS_P(NODE) \
1782	(DECL_LANG_SPECIFIC (DECL_MODULE_CHECK (NODE))->u.base.module_keyed_decls_p)
1783
1784	/ Whether this is an exported DECL. Held on any decl that can appear*
1785	at namespace scope (function, var, type, template, const or
1786	namespace). templates copy from their template_result, consts have
1787	it for unscoped enums. /*
1788	#define DECL_MODULE_EXPORT_P(NODE) TREE_LANG_FLAG_3 (NODE)
1789
1790
1791	/ The list of local parameters introduced by this requires-expression,*
1792	in the form of a chain of PARM_DECLs. /*
1793	#define REQUIRES_EXPR_PARMS(NODE) \
1794	TREE_OPERAND (TREE_CHECK (NODE, REQUIRES_EXPR), 0)
1795
1796	/ A TREE_LIST of the requirements for this requires-expression.*
1797	The requirements are stored in lexical order within the TREE_VALUE
1798	of each TREE_LIST node. The TREE_PURPOSE of each node is unused. /*
1799	#define REQUIRES_EXPR_REQS(NODE) \
1800	TREE_OPERAND (TREE_CHECK (NODE, REQUIRES_EXPR), 1)
1801
1802	/ Like PACK_EXPANSION_EXTRA_ARGS, for requires-expressions. /
1803	#define REQUIRES_EXPR_EXTRA_ARGS(NODE) \
1804	TREE_OPERAND (TREE_CHECK (NODE, REQUIRES_EXPR), 2)
1805
1806	enum cp_tree_node_structure_enum {
1807	TS_CP_GENERIC,
1808	TS_CP_IDENTIFIER,
1809	TS_CP_TPI,
1810	TS_CP_PTRMEM,
1811	TS_CP_OVERLOAD,
1812	TS_CP_BINDING_VECTOR,
1813	TS_CP_BASELINK,
1814	TS_CP_TEMPLATE_DECL,
1815	TS_CP_DEFERRED_PARSE,
1816	TS_CP_DEFERRED_NOEXCEPT,
1817	TS_CP_STATIC_ASSERT,
1818	TS_CP_ARGUMENT_PACK_SELECT,
1819	TS_CP_TRAIT_EXPR,
1820	TS_CP_LAMBDA_EXPR,
1821	TS_CP_TEMPLATE_INFO,
1822	TS_CP_CONSTRAINT_INFO,
1823	TS_CP_USERDEF_LITERAL
1824	};
1825
1826	/ The resulting tree type. /
1827	union GTY((desc ("cp_tree_node_structure (&%h)"),
1828	chain_next ("(union lang_tree_node *) c_tree_chain_next (&%h.generic)"))) lang_tree_node {
1829	union tree_node GTY ((tag ("TS_CP_GENERIC"),
1830	desc ("tree_node_structure (&%h)"))) generic;
1831	struct template_parm_index GTY ((tag ("TS_CP_TPI"))) tpi;
1832	struct ptrmem_cst GTY ((tag ("TS_CP_PTRMEM"))) ptrmem;
1833	struct tree_overload GTY ((tag ("TS_CP_OVERLOAD"))) overload;
1834	struct tree_binding_vec GTY ((tag ("TS_CP_BINDING_VECTOR"))) binding_vec;
1835	struct tree_baselink GTY ((tag ("TS_CP_BASELINK"))) baselink;
1836	struct tree_template_decl GTY ((tag ("TS_CP_TEMPLATE_DECL"))) template_decl;
1837	struct tree_deferred_parse GTY ((tag ("TS_CP_DEFERRED_PARSE"))) deferred_parse;
1838	struct tree_deferred_noexcept GTY ((tag ("TS_CP_DEFERRED_NOEXCEPT"))) deferred_noexcept;
1839	struct lang_identifier GTY ((tag ("TS_CP_IDENTIFIER"))) identifier;
1840	struct tree_static_assert GTY ((tag ("TS_CP_STATIC_ASSERT")))
1841	static_assertion;
1842	struct tree_argument_pack_select GTY ((tag ("TS_CP_ARGUMENT_PACK_SELECT")))
1843	argument_pack_select;
1844	struct tree_trait_expr GTY ((tag ("TS_CP_TRAIT_EXPR")))
1845	trait_expression;
1846	struct tree_lambda_expr GTY ((tag ("TS_CP_LAMBDA_EXPR")))
1847	lambda_expression;
1848	struct tree_template_info GTY ((tag ("TS_CP_TEMPLATE_INFO")))
1849	template_info;
1850	struct tree_constraint_info GTY ((tag ("TS_CP_CONSTRAINT_INFO")))
1851	constraint_info;
1852	struct tree_userdef_literal GTY ((tag ("TS_CP_USERDEF_LITERAL")))
1853	userdef_literal;
1854	};
1855
1856
1857	struct GTY(()) cp_omp_declare_target_attr {
1858	bool attr_syntax;
1859	int device_type;
1860	bool indirect;
1861	};
1862
1863	struct GTY(()) cp_omp_begin_assumes_data {
1864	bool attr_syntax;
1865	};
1866
1867	/ Global state. /
1868
1869	struct GTY(()) saved_scope {
1870	vec<cxx_saved_binding, va_gc> *old_bindings;
1871	tree old_namespace;
1872	vec<tree, va_gc> *decl_ns_list;
1873	tree class_name;
1874	tree class_type;
1875	tree access_specifier;
1876	tree function_decl;
1877	vec<tree, va_gc> *lang_base;
1878	tree lang_name;
1879	tree template_parms;
1880	cp_binding_level *x_previous_class_level;
1881	tree x_saved_tree;
1882
1883	/ Only used for uses of this in trailing return type. /
1884	tree x_current_class_ptr;
1885	tree x_current_class_ref;
1886
1887	int x_processing_template_decl;
1888	int x_processing_specialization;
1889	int x_processing_constraint;
1890	int x_processing_contract_condition;
1891	int suppress_location_wrappers;
1892	BOOL_BITFIELD x_processing_explicit_instantiation : `1`;
1893	BOOL_BITFIELD need_pop_function_context : `1`;
1894
1895	/ Nonzero if we are parsing the discarded statement of a constexpr*
1896	if-statement. /*
1897	BOOL_BITFIELD discarded_stmt : `1`;
1898	/ Nonzero if we are parsing or instantiating the compound-statement*
1899	of consteval if statement. Also set while processing an immediate
1900	invocation. /*
1901	BOOL_BITFIELD consteval_if_p : `1`;
1902
1903	int unevaluated_operand;
1904	int inhibit_evaluation_warnings;
1905	int noexcept_operand;
1906	int ref_temp_count;
1907
1908	struct stmt_tree_s x_stmt_tree;
1909
1910	cp_binding_level *class_bindings;
1911	cp_binding_level *bindings;
1912
1913	hash_map<tree, tree> *GTY((skip)) x_local_specializations;
1914	vec<cp_omp_declare_target_attr, va_gc> *omp_declare_target_attribute;
1915	vec<cp_omp_begin_assumes_data, va_gc> *omp_begin_assumes;
1916
1917	struct saved_scope *prev;
1918	};
1919
1920	extern GTY(()) struct saved_scope *scope_chain;
1921
1922	/ The current open namespace. /
1923
1924	#define current_namespace scope_chain->old_namespace
1925
1926	/ The stack for namespaces of current declarations. /
1927
1928	#define decl_namespace_list scope_chain->decl_ns_list
1929
1930	/ IDENTIFIER_NODE: name of current class /
1931
1932	#define current_class_name scope_chain->class_name
1933
1934	/ _TYPE: the type of the current class /
1935
1936	#define current_class_type scope_chain->class_type
1937
1938	/ When parsing a class definition, the access specifier most recently*
1939	given by the user, or, if no access specifier was given, the
1940	default value appropriate for the kind of class (i.e., struct,
1941	class, or union). /*
1942
1943	#define current_access_specifier scope_chain->access_specifier
1944
1945	/ Pointer to the top of the language name stack. /
1946
1947	#define current_lang_base scope_chain->lang_base
1948	#define current_lang_name scope_chain->lang_name
1949
1950	/ When parsing a template declaration, a TREE_LIST represents the*
1951	active template parameters. Each node in the list represents one
1952	level of template parameters. The innermost level is first in the
1953	list. The depth of each level is stored as an INTEGER_CST in the
1954	TREE_PURPOSE of each node. The parameters for that level are
1955	stored in the TREE_VALUE. /*
1956
1957	#define current_template_parms scope_chain->template_parms
1958	#define current_template_depth \
1959	(current_template_parms ? TMPL_PARMS_DEPTH (current_template_parms) : 0)
1960	#define in_template_context (current_template_parms != NULL_TREE)
1961
1962	#define processing_template_decl scope_chain->x_processing_template_decl
1963	#define processing_specialization scope_chain->x_processing_specialization
1964	#define processing_explicit_instantiation scope_chain->x_processing_explicit_instantiation
1965
1966	/ Nonzero if we are parsing the conditional expression of a contract*
1967	condition. These expressions appear outside the paramter list (like a
1968	trailing return type), but are potentially evaluated. /*
1969
1970	#define processing_contract_condition scope_chain->x_processing_contract_condition
1971
1972	#define in_discarded_stmt scope_chain->discarded_stmt
1973	#define in_consteval_if_p scope_chain->consteval_if_p
1974
1975	#define current_ref_temp_count scope_chain->ref_temp_count
1976
1977	/ RAII sentinel to handle clearing processing_template_decl and restoring*
1978	it when done. /*
1979
1980	class processing_template_decl_sentinel
1981	{
1982	public:
1983	int saved;
1984	processing_template_decl_sentinel (bool reset = true)
1985	: saved (processing_template_decl)
1986	{
1987	if (reset)
1988	processing_template_decl = `0`;
1989	}
1990	~processing_template_decl_sentinel()
1991	{
1992	processing_template_decl = saved;
1993	}
1994	};
1995
1996	/ RAII sentinel to disable certain warnings during template substitution*
1997	and elsewhere. /*
1998
1999	class warning_sentinel
2000	{
2001	public:
2002	int &flag;
2003	int val;
2004	warning_sentinel(int& flag, bool suppress=true)
2005	: flag(flag), val(flag) { if (suppress) flag = `0`; }
2006	~warning_sentinel() { flag = val; }
2007	};
2008
2009	/ RAII sentinel to temporarily override input_location. This will not set*
2010	input_location to UNKNOWN_LOCATION or BUILTINS_LOCATION. /*
2011
2012	class iloc_sentinel
2013	{
2014	location_t saved_loc;
2015	public:
2016	iloc_sentinel (location_t loc): saved_loc (input_location)
2017	{
2018	if (loc >= RESERVED_LOCATION_COUNT)
2019	input_location = loc;
2020	}
2021	~iloc_sentinel ()
2022	{
2023	input_location = saved_loc;
2024	}
2025	};
2026
2027	/ RAII sentinel that saves the value of a variable, optionally*
2028	overrides it right away, and restores its value when the sentinel
2029	id destructed. /*
2030
2031	template <typename T>
2032	class temp_override
2033	{
2034	T& overridden_variable;
2035	T saved_value;
2036	public:
2037	temp_override(T& var) : overridden_variable (var), saved_value (var) {}
2038	temp_override(T& var, T overrider)
2039	: overridden_variable (var), saved_value (var)
2040	{
2041	overridden_variable = overrider;
2042	}
2043	~temp_override() { overridden_variable = saved_value; }
2044	};
2045
2046	/ Wrapping a template parameter in type_identity_t hides it from template*
2047	argument deduction. /*
2048	#if __cpp_lib_type_identity
2049	using std::type_identity_t;
2050	#else
2051	template <typename T>
2052	struct type_identity { typedef T type; };
2053	template <typename T>
2054	using type_identity_t = typename type_identity<T>::type;
2055	#endif
2056
2057	/ Object generator function for temp_override, so you don't need to write the*
2058	type of the object as a template argument.
2059
2060	Use as auto x = make_temp_override (flag); /*
2061
2062	template <typename T>
2063	inline temp_override<T>
2064	make_temp_override (T& var)
2065	{
2066	return { var };
2067	}
2068
2069	/ Likewise, but use as auto x = make_temp_override (flag, value); /
2070
2071	template <typename T>
2072	inline temp_override<T>
2073	make_temp_override (T& var, type_identity_t<T> overrider)
2074	{
2075	return { var, overrider };
2076	}
2077
2078	/ temp_override for in_consteval_if_p, which can't use make_temp_override*
2079	because it is a bitfield. /*
2080
2081	struct in_consteval_if_p_temp_override {
2082	bool save_in_consteval_if_p;
2083	in_consteval_if_p_temp_override ()
2084	: save_in_consteval_if_p (in_consteval_if_p) {}
2085	void reset () { in_consteval_if_p = save_in_consteval_if_p; }
2086	~in_consteval_if_p_temp_override ()
2087	{ reset (); }
2088	};
2089
2090	/ The cached class binding level, from the most recently exited*
2091	class, or NULL if none. /*
2092
2093	#define previous_class_level scope_chain->x_previous_class_level
2094
2095	/ A map from local variable declarations in the body of the template*
2096	presently being instantiated to the corresponding instantiated
2097	local variables. /*
2098
2099	#define local_specializations scope_chain->x_local_specializations
2100
2101	/ Nonzero if we are parsing the operand of a noexcept operator. /
2102
2103	#define cp_noexcept_operand scope_chain->noexcept_operand
2104
2105	struct named_label_entry; / Defined in decl.cc. /
2106
2107	struct named_label_hash : ggc_remove <named_label_entry *>
2108	{
2109	typedef named_label_entry *value_type;
2110	typedef tree compare_type; / An identifier. /
2111
2112	inline static hashval_t hash (value_type);
2113	inline static bool equal (const value_type, compare_type);
2114
2115	static const bool empty_zero_p = true;
2116	inline static void mark_empty (value_type &p) {p = NULL;}
2117	inline static bool is_empty (value_type p) {return !p;}
2118
2119	/ Nothing is deletable. Everything is insertable. /
2120	inline static bool is_deleted (value_type) { return false; }
2121	inline static void mark_deleted (value_type) { gcc_unreachable (); }
2122	};
2123
2124	/ Global state pertinent to the current function. /
2125
2126	struct GTY(()) language_function {
2127	struct c_language_function base;
2128
2129	tree x_current_class_ptr;
2130	tree x_current_class_ref;
2131	tree x_eh_spec_block;
2132	tree x_in_charge_parm;
2133	tree x_vtt_parm;
2134	tree x_return_value;
2135
2136	BOOL_BITFIELD returns_value : `1`;
2137	BOOL_BITFIELD returns_null : `1`;
2138	BOOL_BITFIELD returns_abnormally : `1`;
2139	BOOL_BITFIELD infinite_loop: `1`;
2140	BOOL_BITFIELD x_in_function_try_handler : `1`;
2141	BOOL_BITFIELD x_in_base_initializer : `1`;
2142
2143	/ True if this function can throw an exception. /
2144	BOOL_BITFIELD can_throw : `1`;
2145
2146	BOOL_BITFIELD invalid_constexpr : `1`;
2147	BOOL_BITFIELD throwing_cleanup : `1`;
2148
2149	hash_table<named_label_hash> *x_named_labels;
2150
2151	cp_binding_level *bindings;
2152
2153	/ Tracking possibly infinite loops. This is a vec<tree> only because*
2154	vec<bool> doesn't work with gtype. /*
2155	vec<tree, va_gc> *infinite_loops;
2156	};
2157
2158	/ The current C++-specific per-function global variables. /
2159
2160	#define cp_function_chain (cfun->language)
2161
2162	/ When we're processing a member function, current_class_ptr is the*
2163	PARM_DECL for the `this' pointer. The current_class_ref is an
2164	expression for `this'. /
2165
2166	#define current_class_ptr \
2167	(*(cfun && cp_function_chain \
2168	? &cp_function_chain->x_current_class_ptr \
2169	: &scope_chain->x_current_class_ptr))
2170	#define current_class_ref \
2171	(*(cfun && cp_function_chain \
2172	? &cp_function_chain->x_current_class_ref \
2173	: &scope_chain->x_current_class_ref))
2174
2175	/ The EH_SPEC_BLOCK for the exception-specifiers for the current*
2176	function, if any. /*
2177
2178	#define current_eh_spec_block cp_function_chain->x_eh_spec_block
2179
2180	/ The `__in_chrg' parameter for the current function. Only used for*
2181	constructors and destructors. /*
2182
2183	#define current_in_charge_parm cp_function_chain->x_in_charge_parm
2184
2185	/ The `__vtt_parm' parameter for the current function. Only used for*
2186	constructors and destructors. /*
2187
2188	#define current_vtt_parm cp_function_chain->x_vtt_parm
2189
2190	/ A boolean flag to control whether we need to clean up the return value if a*
2191	local destructor throws. Only used in functions that return by value a
2192	class with a destructor. Which 'tors don't, so we can use the same
2193	field as current_vtt_parm. /*
2194
2195	#define current_retval_sentinel current_vtt_parm
2196
2197	/ Set to 0 at beginning of a function definition, set to 1 if*
2198	a return statement that specifies a return value is seen. /*
2199
2200	#define current_function_returns_value cp_function_chain->returns_value
2201
2202	/ Set to 0 at beginning of a function definition, set to 1 if*
2203	a return statement with no argument is seen. /*
2204
2205	#define current_function_returns_null cp_function_chain->returns_null
2206
2207	/ Set to 0 at beginning of a function definition, set to 1 if*
2208	a call to a noreturn function is seen. /*
2209
2210	#define current_function_returns_abnormally \
2211	cp_function_chain->returns_abnormally
2212
2213	/ Set to 0 at beginning of a function definition, set to 1 if we see an*
2214	obvious infinite loop. This can have false positives and false
2215	negatives, so it should only be used as a heuristic. /*
2216
2217	#define current_function_infinite_loop cp_function_chain->infinite_loop
2218
2219	/ Nonzero if we are processing a base initializer. Zero elsewhere. /
2220	#define in_base_initializer cp_function_chain->x_in_base_initializer
2221
2222	#define in_function_try_handler cp_function_chain->x_in_function_try_handler
2223
2224	/ Expression always returned from function, or error_mark_node*
2225	otherwise, for use by the automatic named return value optimization. /*
2226
2227	#define current_function_return_value \
2228	(cp_function_chain->x_return_value)
2229
2230	/ In parser.cc. /
2231	extern tree cp_literal_operator_id (const char *);
2232
2233	#define NON_ERROR(NODE) ((NODE) == error_mark_node ? NULL_TREE : (NODE))
2234
2235	/ TRUE if a tree code represents a statement. /
2236	extern bool statement_code_p[MAX_TREE_CODES];
2237
2238	#define STATEMENT_CODE_P(CODE) statement_code_p[(int) (CODE)]
2239
2240	enum languages { lang_c, lang_cplusplus };
2241
2242	/ Macros to make error reporting functions' lives easier. /
2243	#define TYPE_LINKAGE_IDENTIFIER(NODE) \
2244	(TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (NODE)))
2245	#define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (TYPE_IDENTIFIER (NODE)))
2246	#define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (TYPE_IDENTIFIER (NODE)))
2247
2248	/ Any kind of anonymous type. /
2249	#define TYPE_ANON_P(NODE) \
2250	(TYPE_LINKAGE_IDENTIFIER (NODE) \
2251	&& IDENTIFIER_ANON_P (TYPE_LINKAGE_IDENTIFIER (NODE)))
2252
2253	/ Nonzero if NODE, a TYPE, has no name for linkage purposes. /
2254	#define TYPE_UNNAMED_P(NODE) \
2255	(TYPE_ANON_P (NODE) \
2256	&& !IDENTIFIER_LAMBDA_P (TYPE_LINKAGE_IDENTIFIER (NODE)))
2257
2258	/ The _DECL for this _TYPE. /
2259	#define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE)))
2260
2261	/ Nonzero if T is a type that could resolve to any kind of concrete type*
2262	at instantiation time. /*
2263	#define WILDCARD_TYPE_P(T) \
2264	(TREE_CODE (T) == TEMPLATE_TYPE_PARM \
2265	\|\| TREE_CODE (T) == TYPENAME_TYPE \
2266	\|\| TREE_CODE (T) == TYPEOF_TYPE \
2267	\|\| TREE_CODE (T) == BOUND_TEMPLATE_TEMPLATE_PARM \
2268	\|\| TREE_CODE (T) == DECLTYPE_TYPE \
2269	\|\| TREE_CODE (T) == TRAIT_TYPE \
2270	\|\| TREE_CODE (T) == DEPENDENT_OPERATOR_TYPE)
2271
2272	/ Nonzero if T is a class (or struct or union) type. Also nonzero*
2273	for template type parameters, typename types, and instantiated
2274	template template parameters. Keep these checks in ascending code
2275	order. /*
2276	#define MAYBE_CLASS_TYPE_P(T) (WILDCARD_TYPE_P (T) \|\| CLASS_TYPE_P (T))
2277
2278	/ Set CLASS_TYPE_P for T to VAL. T must be a class, struct, or*
2279	union type. /*
2280	#define SET_CLASS_TYPE_P(T, VAL) \
2281	(TYPE_LANG_FLAG_5 (RECORD_OR_UNION_CHECK (T)) = (VAL))
2282
2283	/ Nonzero if T is a class type. Zero for template type parameters,*
2284	typename types, and so forth. /*
2285	#define CLASS_TYPE_P(T) \
2286	(RECORD_OR_UNION_CODE_P (TREE_CODE (T)) && TYPE_LANG_FLAG_5 (T))
2287
2288	/ Nonzero if T is a class type but not a union. /
2289	#define NON_UNION_CLASS_TYPE_P(T) \
2290	(TREE_CODE (T) == RECORD_TYPE && TYPE_LANG_FLAG_5 (T))
2291
2292	/ Keep these checks in ascending code order. /
2293	#define RECORD_OR_UNION_CODE_P(T) \
2294	((T) == RECORD_TYPE \|\| (T) == UNION_TYPE)
2295	#define OVERLOAD_TYPE_P(T) \
2296	(CLASS_TYPE_P (T) \|\| TREE_CODE (T) == ENUMERAL_TYPE)
2297
2298	/ True if this type is dependent. This predicate is only valid if*
2299	TYPE_DEPENDENT_P_VALID is true. /*
2300	#define TYPE_DEPENDENT_P(NODE) TYPE_LANG_FLAG_0 (NODE)
2301
2302	/ True if dependent_type_p has been called for this type, with the*
2303	result that TYPE_DEPENDENT_P is valid. /*
2304	#define TYPE_DEPENDENT_P_VALID(NODE) TYPE_LANG_FLAG_6(NODE)
2305
2306	/ Nonzero if this type is const-qualified. /
2307	#define CP_TYPE_CONST_P(NODE) \
2308	((cp_type_quals (NODE) & TYPE_QUAL_CONST) != 0)
2309
2310	/ Nonzero if this type is volatile-qualified. /
2311	#define CP_TYPE_VOLATILE_P(NODE) \
2312	((cp_type_quals (NODE) & TYPE_QUAL_VOLATILE) != 0)
2313
2314	/ Nonzero if this type is restrict-qualified. /
2315	#define CP_TYPE_RESTRICT_P(NODE) \
2316	((cp_type_quals (NODE) & TYPE_QUAL_RESTRICT) != 0)
2317
2318	/ Nonzero if this type is const-qualified, but not*
2319	volatile-qualified. Other qualifiers are ignored. This macro is
2320	used to test whether or not it is OK to bind an rvalue to a
2321	reference. /*
2322	#define CP_TYPE_CONST_NON_VOLATILE_P(NODE) \
2323	((cp_type_quals (NODE) & (TYPE_QUAL_CONST \| TYPE_QUAL_VOLATILE)) \
2324	== TYPE_QUAL_CONST)
2325
2326	#define FUNCTION_ARG_CHAIN(NODE) \
2327	TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (NODE)))
2328
2329	/ Given a FUNCTION_DECL, returns the first TREE_LIST out of TYPE_ARG_TYPES*
2330	which refers to a user-written parameter. /*
2331	#define FUNCTION_FIRST_USER_PARMTYPE(NODE) \
2332	skip_artificial_parms_for ((NODE), TYPE_ARG_TYPES (TREE_TYPE (NODE)))
2333
2334	/ Similarly, but for DECL_ARGUMENTS. /
2335	#define FUNCTION_FIRST_USER_PARM(NODE) \
2336	skip_artificial_parms_for ((NODE), DECL_ARGUMENTS (NODE))
2337
2338	/ Nonzero iff TYPE is derived from PARENT. Ignores accessibility and*
2339	ambiguity issues. /*
2340	#define DERIVED_FROM_P(PARENT, TYPE) \
2341	(lookup_base ((TYPE), (PARENT), ba_any, NULL, tf_none) != NULL_TREE)
2342
2343	/ Gives the visibility specification for a class type. /
2344	#define CLASSTYPE_VISIBILITY(TYPE) \
2345	DECL_VISIBILITY (TYPE_MAIN_DECL (TYPE))
2346	#define CLASSTYPE_VISIBILITY_SPECIFIED(TYPE) \
2347	DECL_VISIBILITY_SPECIFIED (TYPE_MAIN_DECL (TYPE))
2348
2349	struct GTY (()) tree_pair_s {
2350	tree purpose;
2351	tree value;
2352	};
2353	typedef tree_pair_s *tree_pair_p;
2354
2355	/ This structure provides additional information above and beyond*
2356	what is provide in the ordinary tree_type. In the past, we used it
2357	for the types of class types, template parameters types, typename
2358	types, and so forth. However, there can be many (tens to hundreds
2359	of thousands) of template parameter types in a compilation, and
2360	there's no need for this additional information in that case.
2361	Therefore, we now use this data structure only for class types.
2362
2363	In the past, it was thought that there would be relatively few
2364	class types. However, in the presence of heavy use of templates,
2365	many (i.e., thousands) of classes can easily be generated.
2366	Therefore, we should endeavor to keep the size of this structure to
2367	a minimum. /*
2368	struct GTY(()) lang_type {
2369	unsigned char align;
2370
2371	unsigned has_type_conversion : `1`;
2372	unsigned has_copy_ctor : `1`;
2373	unsigned has_default_ctor : `1`;
2374	unsigned const_needs_init : `1`;
2375	unsigned ref_needs_init : `1`;
2376	unsigned has_const_copy_assign : `1`;
2377	unsigned use_template : `2`;
2378
2379	unsigned has_mutable : `1`;
2380	unsigned com_interface : `1`;
2381	unsigned non_pod_class : `1`;
2382	unsigned nearly_empty_p : `1`;
2383	unsigned user_align : `1`;
2384	unsigned has_copy_assign : `1`;
2385	unsigned has_new : `1`;
2386	unsigned has_array_new : `1`;
2387
2388	unsigned gets_delete : `2`;
2389	unsigned interface_only : `1`;
2390	unsigned interface_unknown : `1`;
2391	unsigned contains_empty_class_p : `1`;
2392	unsigned anon_aggr : `1`;
2393	unsigned non_zero_init : `1`;
2394	unsigned empty_p : `1`;
2395	/ 32 bits allocated. /
2396
2397	unsigned vec_new_uses_cookie : `1`;
2398	unsigned declared_class : `1`;
2399	unsigned diamond_shaped : `1`;
2400	unsigned repeated_base : `1`;
2401	unsigned being_defined : `1`;
2402	unsigned debug_requested : `1`;
2403	unsigned fields_readonly : `1`;
2404	unsigned ptrmemfunc_flag : `1`;
2405
2406	unsigned lazy_default_ctor : `1`;
2407	unsigned lazy_copy_ctor : `1`;
2408	unsigned lazy_copy_assign : `1`;
2409	unsigned lazy_destructor : `1`;
2410	unsigned has_const_copy_ctor : `1`;
2411	unsigned has_complex_copy_ctor : `1`;
2412	unsigned has_complex_copy_assign : `1`;
2413	unsigned non_aggregate : `1`;
2414
2415	unsigned has_complex_dflt : `1`;
2416	unsigned has_list_ctor : `1`;
2417	unsigned non_std_layout : `1`;
2418	unsigned is_literal : `1`;
2419	unsigned lazy_move_ctor : `1`;
2420	unsigned lazy_move_assign : `1`;
2421	unsigned has_complex_move_ctor : `1`;
2422	unsigned has_complex_move_assign : `1`;
2423
2424	unsigned has_constexpr_ctor : `1`;
2425	unsigned unique_obj_representations : `1`;
2426	unsigned unique_obj_representations_set : `1`;
2427	bool erroneous : `1`;
2428	bool non_pod_aggregate : `1`;
2429
2430	/ When adding a flag here, consider whether or not it ought to*
2431	apply to a template instance if it applies to the template. If
2432	so, make sure to copy it in instantiate_class_template! /*
2433
2434	/ There are some bits left to fill out a 32-bit word. Keep track*
2435	of this by updating the size of this bitfield whenever you add or
2436	remove a flag. /*
2437	unsigned dummy : `3`;
2438
2439	tree primary_base;
2440	vec<tree_pair_s, va_gc> *vcall_indices;
2441	tree vtables;
2442	tree typeinfo_var;
2443	vec<tree, va_gc> *vbases;
2444	tree as_base;
2445	vec<tree, va_gc> *pure_virtuals;
2446	tree friend_classes;
2447	vec<tree, va_gc> * GTY((reorder ("resort_type_member_vec"))) members;
2448	tree key_method;
2449	tree decl_list;
2450	tree befriending_classes;
2451	/ In a RECORD_TYPE, information specific to Objective-C++, such*
2452	as a list of adopted protocols or a pointer to a corresponding
2453	@interface. See objc/objc-act.h for details. /*
2454	tree objc_info;
2455	/ FIXME reuse another field? /
2456	tree lambda_expr;
2457	};
2458
2459	/ We used to have a variant type for lang_type. Keep the name of the*
2460	checking accessor for the sole survivor. /*
2461	#define LANG_TYPE_CLASS_CHECK(NODE) (TYPE_LANG_SPECIFIC (NODE))
2462
2463	/ Nonzero for _CLASSTYPE means that operator delete is defined. /
2464	#define TYPE_GETS_DELETE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->gets_delete)
2465	#define TYPE_GETS_REG_DELETE(NODE) (TYPE_GETS_DELETE (NODE) & 1)
2466	#define TYPE_GETS_VEC_DELETE(NODE) (TYPE_GETS_DELETE (NODE) & 2)
2467
2468	/ Nonzero if `new NODE[x]' should cause the allocation of extra*
2469	storage to indicate how many array elements are in use. /*
2470	#define TYPE_VEC_NEW_USES_COOKIE(NODE) \
2471	(CLASS_TYPE_P (NODE) \
2472	&& LANG_TYPE_CLASS_CHECK (NODE)->vec_new_uses_cookie)
2473
2474	/ Nonzero means that this _CLASSTYPE node defines ways of converting*
2475	itself to other types. /*
2476	#define TYPE_HAS_CONVERSION(NODE) \
2477	(LANG_TYPE_CLASS_CHECK (NODE)->has_type_conversion)
2478
2479	/ Nonzero means that NODE (a class type) has a default constructor --*
2480	but that it has not yet been declared. /*
2481	#define CLASSTYPE_LAZY_DEFAULT_CTOR(NODE) \
2482	(LANG_TYPE_CLASS_CHECK (NODE)->lazy_default_ctor)
2483
2484	/ Nonzero means that NODE (a class type) has a copy constructor --*
2485	but that it has not yet been declared. /*
2486	#define CLASSTYPE_LAZY_COPY_CTOR(NODE) \
2487	(LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_ctor)
2488
2489	/ Nonzero means that NODE (a class type) has a move constructor --*
2490	but that it has not yet been declared. /*
2491	#define CLASSTYPE_LAZY_MOVE_CTOR(NODE) \
2492	(LANG_TYPE_CLASS_CHECK (NODE)->lazy_move_ctor)
2493
2494	/ Nonzero means that NODE (a class type) has an assignment operator*
2495	-- but that it has not yet been declared. /*
2496	#define CLASSTYPE_LAZY_COPY_ASSIGN(NODE) \
2497	(LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_assign)
2498
2499	/ Nonzero means that NODE (a class type) has an assignment operator*
2500	-- but that it has not yet been declared. /*
2501	#define CLASSTYPE_LAZY_MOVE_ASSIGN(NODE) \
2502	(LANG_TYPE_CLASS_CHECK (NODE)->lazy_move_assign)
2503
2504	/ Nonzero means that NODE (a class type) has a destructor -- but that*
2505	it has not yet been declared. /*
2506	#define CLASSTYPE_LAZY_DESTRUCTOR(NODE) \
2507	(LANG_TYPE_CLASS_CHECK (NODE)->lazy_destructor)
2508
2509	/ Nonzero means that NODE (a class type) is final /
2510	#define CLASSTYPE_FINAL(NODE) \
2511	TYPE_FINAL_P (NODE)
2512
2513
2514	/ Nonzero means that this _CLASSTYPE node overloads operator=(X&). /
2515	#define TYPE_HAS_COPY_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_copy_assign)
2516
2517	/ True iff the class type NODE has an "operator =" whose parameter*
2518	has a parameter of type "const X&". /*
2519	#define TYPE_HAS_CONST_COPY_ASSIGN(NODE) \
2520	(LANG_TYPE_CLASS_CHECK (NODE)->has_const_copy_assign)
2521
2522	/ Nonzero means that this _CLASSTYPE node has an X(X&) constructor. /
2523	#define TYPE_HAS_COPY_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_copy_ctor)
2524	#define TYPE_HAS_CONST_COPY_CTOR(NODE) \
2525	(LANG_TYPE_CLASS_CHECK (NODE)->has_const_copy_ctor)
2526
2527	/ Nonzero if this class has an X(initializer_list<T>) constructor. /
2528	#define TYPE_HAS_LIST_CTOR(NODE) \
2529	(LANG_TYPE_CLASS_CHECK (NODE)->has_list_ctor)
2530
2531	/ Nonzero if this class has a constexpr constructor other than a copy/move*
2532	constructor. Note that a class can have constexpr constructors for
2533	static initialization even if it isn't a literal class. /*
2534	#define TYPE_HAS_CONSTEXPR_CTOR(NODE) \
2535	(LANG_TYPE_CLASS_CHECK (NODE)->has_constexpr_ctor)
2536
2537	/ Nonzero if this class defines an overloaded operator new. (An*
2538	operator new [] doesn't count.) /*
2539	#define TYPE_HAS_NEW_OPERATOR(NODE) \
2540	(LANG_TYPE_CLASS_CHECK (NODE)->has_new)
2541
2542	/ Nonzero if this class defines an overloaded operator new[]. /
2543	#define TYPE_HAS_ARRAY_NEW_OPERATOR(NODE) \
2544	(LANG_TYPE_CLASS_CHECK (NODE)->has_array_new)
2545
2546	/ Nonzero means that this type is being defined. I.e., the left brace*
2547	starting the definition of this type has been seen. /*
2548	#define TYPE_BEING_DEFINED(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->being_defined)
2549
2550	/ Nonzero means that this type is either complete or being defined, so we*
2551	can do lookup in it. /*
2552	#define COMPLETE_OR_OPEN_TYPE_P(NODE) \
2553	(COMPLETE_TYPE_P (NODE) \|\| (CLASS_TYPE_P (NODE) && TYPE_BEING_DEFINED (NODE)))
2554
2555	/ Mark bits for repeated base checks. /
2556	#define TYPE_MARKED_P(NODE) TREE_LANG_FLAG_6 (TYPE_CHECK (NODE))
2557
2558	/ Nonzero if the class NODE has multiple paths to the same (virtual)*
2559	base object. /*
2560	#define CLASSTYPE_DIAMOND_SHAPED_P(NODE) \
2561	(LANG_TYPE_CLASS_CHECK(NODE)->diamond_shaped)
2562
2563	/ Nonzero if the class NODE has multiple instances of the same base*
2564	type. /*
2565	#define CLASSTYPE_REPEATED_BASE_P(NODE) \
2566	(LANG_TYPE_CLASS_CHECK(NODE)->repeated_base)
2567
2568	/ The member function with which the vtable will be emitted:*
2569	the first noninline non-pure-virtual member function. NULL_TREE
2570	if there is no key function or if this is a class template /*
2571	#define CLASSTYPE_KEY_METHOD(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->key_method)
2572
2573	/ Vector of members. During definition, it is unordered and only*
2574	member functions are present. After completion it is sorted and
2575	contains both member functions and non-functions. STAT_HACK is
2576	involved to preserve oneslot per name invariant. /*
2577	#define CLASSTYPE_MEMBER_VEC(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->members)
2578
2579	/ For class templates, this is a TREE_LIST of all member data,*
2580	functions, types, and friends in the order of declaration.
2581	The TREE_PURPOSE of each TREE_LIST is NULL_TREE for a friend,
2582	and the RECORD_TYPE for the class template otherwise. /*
2583	#define CLASSTYPE_DECL_LIST(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->decl_list)
2584
2585	/ A FUNCTION_DECL or OVERLOAD for the constructors for NODE. These*
2586	are the constructors that take an in-charge parameter. /*
2587	#define CLASSTYPE_CONSTRUCTORS(NODE) \
2588	(get_class_binding_direct (NODE, ctor_identifier))
2589
2590	/ A FUNCTION_DECL for the destructor for NODE. This is the*
2591	destructors that take an in-charge parameter. If
2592	CLASSTYPE_LAZY_DESTRUCTOR is true, then this entry will be NULL
2593	until the destructor is created with lazily_declare_fn. /*
2594	#define CLASSTYPE_DESTRUCTOR(NODE) \
2595	(get_class_binding_direct (NODE, dtor_identifier))
2596
2597	/ Nonzero if NODE has a primary base class, i.e., a base class with*
2598	which it shares the virtual function table pointer. /*
2599	#define CLASSTYPE_HAS_PRIMARY_BASE_P(NODE) \
2600	(CLASSTYPE_PRIMARY_BINFO (NODE) != NULL_TREE)
2601
2602	/ If non-NULL, this is the binfo for the primary base class, i.e.,*
2603	the base class which contains the virtual function table pointer
2604	for this class. /*
2605	#define CLASSTYPE_PRIMARY_BINFO(NODE) \
2606	(LANG_TYPE_CLASS_CHECK (NODE)->primary_base)
2607
2608	/ A vector of BINFOs for the direct and indirect virtual base classes*
2609	that this type uses in a post-order depth-first left-to-right
2610	order. (In other words, these bases appear in the order that they
2611	should be initialized.) /*
2612	#define CLASSTYPE_VBASECLASSES(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->vbases)
2613
2614	/ The type corresponding to NODE when NODE is used as a base class,*
2615	i.e., NODE without virtual base classes or tail padding. /*
2616	#define CLASSTYPE_AS_BASE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->as_base)
2617
2618	/ True iff NODE is the CLASSTYPE_AS_BASE version of some type. /
2619	#define IS_FAKE_BASE_TYPE(NODE) \
2620	(TREE_CODE (NODE) == RECORD_TYPE \
2621	&& TYPE_CONTEXT (NODE) && CLASS_TYPE_P (TYPE_CONTEXT (NODE)) \
2622	&& CLASSTYPE_AS_BASE (TYPE_CONTEXT (NODE)) == (NODE))
2623
2624	/ These are the size and alignment of the type without its virtual*
2625	base classes, for when we use this type as a base itself. /*
2626	#define CLASSTYPE_SIZE(NODE) TYPE_SIZE (CLASSTYPE_AS_BASE (NODE))
2627	#define CLASSTYPE_SIZE_UNIT(NODE) TYPE_SIZE_UNIT (CLASSTYPE_AS_BASE (NODE))
2628	#define CLASSTYPE_ALIGN(NODE) TYPE_ALIGN (CLASSTYPE_AS_BASE (NODE))
2629	#define CLASSTYPE_USER_ALIGN(NODE) TYPE_USER_ALIGN (CLASSTYPE_AS_BASE (NODE))
2630
2631	/ The alignment of NODE, without its virtual bases, in bytes. /
2632	#define CLASSTYPE_ALIGN_UNIT(NODE) \
2633	(CLASSTYPE_ALIGN (NODE) / BITS_PER_UNIT)
2634
2635	/ A vec<tree> of virtual functions which cannot be inherited by*
2636	derived classes. When deriving from this type, the derived
2637	class must provide its own definition for each of these functions. /*
2638	#define CLASSTYPE_PURE_VIRTUALS(NODE) \
2639	(LANG_TYPE_CLASS_CHECK (NODE)->pure_virtuals)
2640
2641	/ Nonzero means that this type is an abstract class type. /
2642	#define ABSTRACT_CLASS_TYPE_P(NODE) \
2643	(CLASS_TYPE_P (NODE) && CLASSTYPE_PURE_VIRTUALS(NODE))
2644
2645	/ Nonzero means that this type has an X() constructor. /
2646	#define TYPE_HAS_DEFAULT_CONSTRUCTOR(NODE) \
2647	(LANG_TYPE_CLASS_CHECK (NODE)->has_default_ctor)
2648
2649	/ Nonzero means that this type contains a mutable member. /
2650	#define CLASSTYPE_HAS_MUTABLE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_mutable)
2651	#define TYPE_HAS_MUTABLE_P(NODE) (cp_has_mutable_p (NODE))
2652
2653	/ Nonzero means that this class type is not POD for the purpose of layout*
2654	(as defined in the ABI). This is different from the language's POD. /*
2655	#define CLASSTYPE_NON_LAYOUT_POD_P(NODE) \
2656	(LANG_TYPE_CLASS_CHECK (NODE)->non_pod_class)
2657
2658	/ Nonzero means that this class type is a non-standard-layout class. /
2659	#define CLASSTYPE_NON_STD_LAYOUT(NODE) \
2660	(LANG_TYPE_CLASS_CHECK (NODE)->non_std_layout)
2661
2662	/ Nonzero means that this class type does have unique object*
2663	representations. /*
2664	#define CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS(NODE) \
2665	(LANG_TYPE_CLASS_CHECK (NODE)->unique_obj_representations)
2666
2667	/ Nonzero means that this class type has*
2668	CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS computed. /*
2669	#define CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET(NODE) \
2670	(LANG_TYPE_CLASS_CHECK (NODE)->unique_obj_representations_set)
2671
2672	/ Nonzero means that this class contains pod types whose default*
2673	initialization is not a zero initialization (namely, pointers to
2674	data members). /*
2675	#define CLASSTYPE_NON_ZERO_INIT_P(NODE) \
2676	(LANG_TYPE_CLASS_CHECK (NODE)->non_zero_init)
2677
2678	/ Nonzero if this class is "empty" in the sense of the C++ ABI. /
2679	#define CLASSTYPE_EMPTY_P(NODE) \
2680	(LANG_TYPE_CLASS_CHECK (NODE)->empty_p)
2681
2682	/ Nonzero if this class is "nearly empty", i.e., contains only a*
2683	virtual function table pointer. /*
2684	#define CLASSTYPE_NEARLY_EMPTY_P(NODE) \
2685	(LANG_TYPE_CLASS_CHECK (NODE)->nearly_empty_p)
2686
2687	/ Nonzero if this class contains an empty subobject. /
2688	#define CLASSTYPE_CONTAINS_EMPTY_CLASS_P(NODE) \
2689	(LANG_TYPE_CLASS_CHECK (NODE)->contains_empty_class_p)
2690
2691	/ A list of class types of which this type is a friend. The*
2692	TREE_VALUE is normally a TYPE, but will be a TEMPLATE_DECL in the
2693	case of a template friend. /*
2694	#define CLASSTYPE_FRIEND_CLASSES(NODE) \
2695	(LANG_TYPE_CLASS_CHECK (NODE)->friend_classes)
2696
2697	/ A list of the classes which grant friendship to this class. /
2698	#define CLASSTYPE_BEFRIENDING_CLASSES(NODE) \
2699	(LANG_TYPE_CLASS_CHECK (NODE)->befriending_classes)
2700
2701	/ The associated LAMBDA_EXPR that made this class. /
2702	#define CLASSTYPE_LAMBDA_EXPR(NODE) \
2703	(LANG_TYPE_CLASS_CHECK (NODE)->lambda_expr)
2704	/ The extra mangling scope for this closure type. /
2705	#define LAMBDA_TYPE_EXTRA_SCOPE(NODE) \
2706	(LAMBDA_EXPR_EXTRA_SCOPE (CLASSTYPE_LAMBDA_EXPR (NODE)))
2707
2708	/ Say whether this node was declared as a "class" or a "struct". /
2709	#define CLASSTYPE_DECLARED_CLASS(NODE) \
2710	(LANG_TYPE_CLASS_CHECK (NODE)->declared_class)
2711
2712	/ Nonzero if this class has const members*
2713	which have no specified initialization. /*
2714	#define CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE) \
2715	(TYPE_LANG_SPECIFIC (NODE) \
2716	? LANG_TYPE_CLASS_CHECK (NODE)->const_needs_init : 0)
2717	#define SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE, VALUE) \
2718	(LANG_TYPE_CLASS_CHECK (NODE)->const_needs_init = (VALUE))
2719
2720	/ Nonzero if this class has ref members*
2721	which have no specified initialization. /*
2722	#define CLASSTYPE_REF_FIELDS_NEED_INIT(NODE) \
2723	(TYPE_LANG_SPECIFIC (NODE) \
2724	? LANG_TYPE_CLASS_CHECK (NODE)->ref_needs_init : 0)
2725	#define SET_CLASSTYPE_REF_FIELDS_NEED_INIT(NODE, VALUE) \
2726	(LANG_TYPE_CLASS_CHECK (NODE)->ref_needs_init = (VALUE))
2727
2728	/ Nonzero if this class is included from a header file which employs*
2729	`#pragma interface', and it is not included in its implementation file. /*
2730	#define CLASSTYPE_INTERFACE_ONLY(NODE) \
2731	(LANG_TYPE_CLASS_CHECK (NODE)->interface_only)
2732
2733	/ True if we have already determined whether or not vtables, VTTs,*
2734	typeinfo, and other similar per-class data should be emitted in
2735	this translation unit. This flag does not indicate whether or not
2736	these items should be emitted; it only indicates that we know one
2737	way or the other. /*
2738	#define CLASSTYPE_INTERFACE_KNOWN(NODE) \
2739	(LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown == 0)
2740	/ The opposite of CLASSTYPE_INTERFACE_KNOWN. /
2741	#define CLASSTYPE_INTERFACE_UNKNOWN(NODE) \
2742	(LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown)
2743
2744	#define SET_CLASSTYPE_INTERFACE_UNKNOWN_X(NODE,X) \
2745	(LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = !!(X))
2746	#define SET_CLASSTYPE_INTERFACE_UNKNOWN(NODE) \
2747	(LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 1)
2748	#define SET_CLASSTYPE_INTERFACE_KNOWN(NODE) \
2749	(LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 0)
2750
2751	/ Nonzero if a _DECL node requires us to output debug info for this class. /
2752	#define CLASSTYPE_DEBUG_REQUESTED(NODE) \
2753	(LANG_TYPE_CLASS_CHECK (NODE)->debug_requested)
2754
2755	/ True if we saw errors while instantiating this class. /
2756	#define CLASSTYPE_ERRONEOUS(NODE) \
2757	(LANG_TYPE_CLASS_CHECK (NODE)->erroneous)
2758
2759	/ True if this class is non-layout-POD only because it was not an aggregate*
2760	before C++14. If we run out of bits in lang_type, this could be replaced
2761	with a hash_set only filled in when abi_version_crosses (17). /*
2762	#define CLASSTYPE_NON_POD_AGGREGATE(NODE) \
2763	(LANG_TYPE_CLASS_CHECK (NODE)->non_pod_aggregate)
2764
2765	/ Additional macros for inheritance information. /
2766
2767	/ Nonzero means that this class is on a path leading to a new vtable. /
2768	#define BINFO_VTABLE_PATH_MARKED(NODE) BINFO_FLAG_1 (NODE)
2769
2770	/ Nonzero means B (a BINFO) has its own vtable. Any copies will not*
2771	have this flag set. /*
2772	#define BINFO_NEW_VTABLE_MARKED(B) (BINFO_FLAG_2 (B))
2773
2774	/ Compare a BINFO_TYPE with another type for equality. For a binfo,*
2775	this is functionally equivalent to using same_type_p, but
2776	measurably faster. At least one of the arguments must be a
2777	BINFO_TYPE. The other can be a BINFO_TYPE or a regular type. If
2778	BINFO_TYPE(T) ever stops being the main variant of the class the
2779	binfo is for, this macro must change. /*
2780	#define SAME_BINFO_TYPE_P(A, B) ((A) == (B))
2781
2782	/ Any subobject that needs a new vtable must have a vptr and must not*
2783	be a non-virtual primary base (since it would then use the vtable from a
2784	derived class and never become non-primary.) /*
2785	#define SET_BINFO_NEW_VTABLE_MARKED(B) \
2786	(BINFO_NEW_VTABLE_MARKED (B) = 1, \
2787	gcc_assert (!BINFO_PRIMARY_P (B) \|\| BINFO_VIRTUAL_P (B)), \
2788	gcc_assert (TYPE_VFIELD (BINFO_TYPE (B))))
2789
2790	/ Nonzero if this binfo is for a dependent base - one that should not*
2791	be searched. /*
2792	#define BINFO_DEPENDENT_BASE_P(NODE) BINFO_FLAG_3 (NODE)
2793
2794	/ Nonzero if this binfo has lost its primary base binfo (because that*
2795	is a nearly-empty virtual base that has been taken by some other
2796	base in the complete hierarchy. /*
2797	#define BINFO_LOST_PRIMARY_P(NODE) BINFO_FLAG_4 (NODE)
2798
2799	/ Nonzero if this BINFO is a primary base class. /
2800	#define BINFO_PRIMARY_P(NODE) BINFO_FLAG_5(NODE)
2801
2802	/ A vec<tree_pair_s> of the vcall indices associated with the class*
2803	NODE. The PURPOSE of each element is a FUNCTION_DECL for a virtual
2804	function. The VALUE is the index into the virtual table where the
2805	vcall offset for that function is stored, when NODE is a virtual
2806	base. /*
2807	#define CLASSTYPE_VCALL_INDICES(NODE) \
2808	(LANG_TYPE_CLASS_CHECK (NODE)->vcall_indices)
2809
2810	/ The various vtables for the class NODE. The primary vtable will be*
2811	first, followed by the construction vtables and VTT, if any. /*
2812	#define CLASSTYPE_VTABLES(NODE) \
2813	(LANG_TYPE_CLASS_CHECK (NODE)->vtables)
2814
2815	/ The std::type_info variable representing this class, or NULL if no*
2816	such variable has been created. This field is only set for the
2817	TYPE_MAIN_VARIANT of the class. /*
2818	#define CLASSTYPE_TYPEINFO_VAR(NODE) \
2819	(LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var)
2820
2821	/ Accessor macros for the BINFO_VIRTUALS list. /
2822
2823	/ The number of bytes by which to adjust the `this' pointer when*
2824	calling this virtual function. Subtract this value from the this
2825	pointer. Always non-NULL, might be constant zero though. /*
2826	#define BV_DELTA(NODE) (TREE_PURPOSE (NODE))
2827
2828	/ If non-NULL, the vtable index at which to find the vcall offset*
2829	when calling this virtual function. Add the value at that vtable
2830	index to the this pointer. /*
2831	#define BV_VCALL_INDEX(NODE) (TREE_TYPE (NODE))
2832
2833	/ The function to call. /
2834	#define BV_FN(NODE) (TREE_VALUE (NODE))
2835
2836	/ Whether or not this entry is for a lost primary virtual base. /
2837	#define BV_LOST_PRIMARY(NODE) (TREE_LANG_FLAG_0 (NODE))
2838
2839	/ For FUNCTION_TYPE or METHOD_TYPE, a list of the exceptions that*
2840	this type can raise. Each TREE_VALUE is a _TYPE. The TREE_VALUE
2841	will be NULL_TREE to indicate a throw specification of `()', or
2842	no exceptions allowed. For a noexcept specification, TREE_VALUE
2843	is NULL_TREE and TREE_PURPOSE is the constant-expression. For
2844	a deferred noexcept-specification, TREE_PURPOSE is a DEFERRED_NOEXCEPT
2845	(for templates) or an OVERLOAD list of functions (for implicitly
2846	declared functions). /*
2847	#define TYPE_RAISES_EXCEPTIONS(NODE) \
2848	TYPE_LANG_SLOT_1 (FUNC_OR_METHOD_CHECK (NODE))
2849
2850	/ For FUNCTION_TYPE or METHOD_TYPE, return 1 iff it is declared `throw()'*
2851	or noexcept(true). /*
2852	#define TYPE_NOTHROW_P(NODE) nothrow_spec_p (TYPE_RAISES_EXCEPTIONS (NODE))
2853
2854	/ For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the*
2855	case for things declared noexcept(true) and, with -fnothrow-opt, for
2856	throw() functions. /*
2857	#define TYPE_NOEXCEPT_P(NODE) type_noexcept_p (NODE)
2858
2859	/ The binding level associated with the namespace. /
2860	#define NAMESPACE_LEVEL(NODE) \
2861	(LANG_DECL_NS_CHECK (NODE)->level)
2862
2863	/ Discriminator values for lang_decl. /
2864
2865	enum lang_decl_selector
2866	{
2867	lds_min,
2868	lds_fn,
2869	lds_ns,
2870	lds_parm,
2871	lds_decomp
2872	};
2873
2874	/ Flags shared by all forms of DECL_LANG_SPECIFIC.*
2875
2876	Some of the flags live here only to make lang_decl_min/fn smaller. Do
2877	not make this struct larger than 32 bits. /*
2878
2879	struct GTY(()) lang_decl_base {
2880	ENUM_BITFIELD(lang_decl_selector) selector : `3`;
2881	ENUM_BITFIELD(languages) language : `1`;
2882	unsigned use_template : `2`;
2883	unsigned not_really_extern : `1`; / var or fn /
2884	unsigned initialized_in_class : `1`; / var or fn /
2885
2886	unsigned threadprivate_or_deleted_p : `1`; / var or fn /
2887	/ anticipated_p is no longer used for anticipated_decls (fn, type*
2888	or template). It is used as DECL_OMP_PRIVATIZED_MEMBER in
2889	var. /*
2890	unsigned anticipated_p : `1`;
2891	unsigned friend_or_tls : `1`; / var, fn, type or template /
2892	unsigned unknown_bound_p : `1`; / var /
2893	unsigned odr_used : `1`; / var or fn /
2894	unsigned concept_p : `1`; / applies to vars and functions /
2895	unsigned var_declared_inline_p : `1`; / var /
2896	unsigned dependent_init_p : `1`; / var /
2897
2898	/ The following four apply to VAR, FUNCTION, TYPE, CONCEPT, & NAMESPACE*
2899	decls. /*
2900	unsigned module_purview_p : `1`; / in named-module purview /
2901	unsigned module_attach_p : `1`; / attached to named module /
2902	unsigned module_import_p : `1`; / from an import /
2903	unsigned module_entity_p : `1`; / is in the entitity ary & hash /
2904
2905	unsigned module_keyed_decls_p : `1`; / has keys, applies to all decls /
2906
2907	/ 11 spare bits. /
2908	};
2909
2910	/ True for DECL codes which have template info and access. /
2911	#define LANG_DECL_HAS_MIN(NODE) \
2912	(VAR_OR_FUNCTION_DECL_P (NODE) \
2913	\|\| TREE_CODE (NODE) == FIELD_DECL \
2914	\|\| TREE_CODE (NODE) == CONST_DECL \
2915	\|\| TREE_CODE (NODE) == TYPE_DECL \
2916	\|\| TREE_CODE (NODE) == TEMPLATE_DECL \
2917	\|\| TREE_CODE (NODE) == USING_DECL \
2918	\|\| TREE_CODE (NODE) == CONCEPT_DECL)
2919
2920	/ DECL_LANG_SPECIFIC for the above codes. /
2921
2922	struct GTY(()) lang_decl_min {
2923	struct lang_decl_base base; / 32-bits. /
2924
2925	/ In a FUNCTION_DECL for which DECL_THUNK_P holds, this is*
2926	THUNK_ALIAS.
2927	In a FUNCTION_DECL for which DECL_THUNK_P does not hold,
2928	VAR_DECL, TYPE_DECL, or TEMPLATE_DECL, this is
2929	DECL_TEMPLATE_INFO. /*
2930	tree template_info;
2931
2932	/ In a DECL_THUNK_P FUNCTION_DECL, this is THUNK_VIRTUAL_OFFSET.*
2933	In a lambda-capture proxy VAR_DECL, this is DECL_CAPTURED_VARIABLE.
2934	In a function-scope TREE_STATIC VAR_DECL or IMPLICIT_TYPEDEF_P TYPE_DECL,
2935	this is DECL_DISCRIMINATOR.
2936	In a DECL_LOCAL_DECL_P decl, this is the namespace decl it aliases.
2937	Otherwise, in a class-scope DECL, this is DECL_ACCESS. /*
2938	tree access;
2939	};
2940
2941	/ Additional DECL_LANG_SPECIFIC information for functions. /
2942
2943	struct GTY(()) lang_decl_fn {
2944	struct lang_decl_min min;
2945
2946	/ In a overloaded operator, this is the compressed operator code. /
2947	unsigned ovl_op_code : `6`;
2948	unsigned global_ctor_p : `1`;
2949	unsigned global_dtor_p : `1`;
2950
2951	unsigned static_function : `1`;
2952	unsigned pure_virtual : `1`;
2953	unsigned defaulted_p : `1`;
2954	unsigned has_in_charge_parm_p : `1`;
2955	unsigned has_vtt_parm_p : `1`;
2956	unsigned pending_inline_p : `1`;
2957	unsigned nonconverting : `1`;
2958	unsigned thunk_p : `1`;
2959
2960	unsigned this_thunk_p : `1`;
2961	unsigned omp_declare_reduction_p : `1`;
2962	unsigned has_dependent_explicit_spec_p : `1`;
2963	unsigned immediate_fn_p : `1`;
2964	unsigned maybe_deleted : `1`;
2965	unsigned coroutine_p : `1`;
2966	unsigned implicit_constexpr : `1`;
2967	unsigned escalated_p : `1`;
2968	unsigned xobj_func : `1`;
2969
2970	unsigned spare : `7`;
2971
2972	/ 32-bits padding on 64-bit host. /
2973
2974	/ For a non-thunk function decl, this is a tree list of*
2975	friendly classes. For a thunk function decl, it is the
2976	thunked to function decl. /*
2977	tree befriending_classes;
2978
2979	/ For a virtual FUNCTION_DECL for which*
2980	DECL_THIS_THUNK_P does not hold, this is DECL_THUNKS. Both
2981	this pointer and result pointer adjusting thunks are
2982	chained here. This pointer thunks to return pointer thunks
2983	will be chained on the return pointer thunk.
2984	For a DECL_CONSTUCTOR_P FUNCTION_DECL, this is the base from
2985	whence we inherit. Otherwise, it is the class in which a
2986	(namespace-scope) friend is defined (if any). /*
2987	tree context;
2988
2989	union lang_decl_u5
2990	{
2991	/ In a non-thunk FUNCTION_DECL, this is DECL_CLONED_FUNCTION. /
2992	tree GTY ((tag ("0"))) cloned_function;
2993
2994	/ In a FUNCTION_DECL for which THUNK_P holds this is the*
2995	THUNK_FIXED_OFFSET. /*
2996	HOST_WIDE_INT GTY ((tag ("1"))) fixed_offset;
2997	} GTY ((desc ("%1.thunk_p"))) u5;
2998
2999	union lang_decl_u3
3000	{
3001	struct cp_token_cache * GTY ((tag ("1"))) pending_inline_info;
3002	tree GTY ((tag ("0"))) saved_auto_return_type;
3003	} GTY ((desc ("%1.pending_inline_p"))) u;
3004
3005	};
3006
3007	/ DECL_LANG_SPECIFIC for namespaces. /
3008
3009	struct GTY(()) lang_decl_ns {
3010	struct lang_decl_base base; / 32 bits. /
3011	cp_binding_level *level;
3012
3013	/ Inline children. Needs to be va_gc, because of PCH. /
3014	vec<tree, va_gc> *inlinees;
3015
3016	/ Hash table of bound decls. It'd be nice to have this inline, but*
3017	as the hash_map has a dtor, we can't then put this struct into a
3018	union (until moving to c++11). /*
3019	hash_table<named_decl_hash> *bindings;
3020	};
3021
3022	/ DECL_LANG_SPECIFIC for parameters. /
3023
3024	struct GTY(()) lang_decl_parm {
3025	struct lang_decl_base base; / 32 bits. /
3026	int level;
3027	int index;
3028	};
3029
3030	/ Additional DECL_LANG_SPECIFIC information for structured bindings. /
3031
3032	struct GTY(()) lang_decl_decomp {
3033	struct lang_decl_min min;
3034	/ The artificial underlying "e" variable of the structured binding*
3035	variable. /*
3036	tree base;
3037	};
3038
3039	/ DECL_LANG_SPECIFIC for all types. It would be nice to just make this a*
3040	union rather than a struct containing a union as its only field, but
3041	tree.h declares it as a struct. /*
3042
3043	struct GTY(()) lang_decl {
3044	union GTY((desc ("%h.base.selector"))) lang_decl_u {
3045	/ Nothing of only the base type exists. /
3046	struct lang_decl_base GTY ((default)) base;
3047	struct lang_decl_min GTY((tag ("lds_min"))) min;
3048	struct lang_decl_fn GTY ((tag ("lds_fn"))) fn;
3049	struct lang_decl_ns GTY((tag ("lds_ns"))) ns;
3050	struct lang_decl_parm GTY((tag ("lds_parm"))) parm;
3051	struct lang_decl_decomp GTY((tag ("lds_decomp"))) decomp;
3052	} u;
3053	};
3054
3055	/ Looks through a template (if present) to find what it declares. /
3056	#define STRIP_TEMPLATE(NODE) \
3057	(TREE_CODE (NODE) == TEMPLATE_DECL ? DECL_TEMPLATE_RESULT (NODE) : NODE)
3058
3059	#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3060
3061	#define LANG_DECL_MIN_CHECK(NODE) __extension__ \
3062	({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \
3063	if (!LANG_DECL_HAS_MIN (NODE)) \
3064	lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
3065	&lt->u.min; })
3066
3067	/ We want to be able to check DECL_CONSTRUCTOR_P and such on a function*
3068	template, not just on a FUNCTION_DECL. So when looking for things in
3069	lang_decl_fn, look down through a TEMPLATE_DECL into its result. /*
3070	#define LANG_DECL_FN_CHECK(NODE) __extension__ \
3071	({ struct lang_decl *lt = DECL_LANG_SPECIFIC (STRIP_TEMPLATE (NODE)); \
3072	if (!DECL_DECLARES_FUNCTION_P (NODE) \
3073	\|\| lt->u.base.selector != lds_fn) \
3074	lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
3075	&lt->u.fn; })
3076
3077	#define LANG_DECL_NS_CHECK(NODE) __extension__ \
3078	({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \
3079	if (TREE_CODE (NODE) != NAMESPACE_DECL \
3080	\|\| lt->u.base.selector != lds_ns) \
3081	lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
3082	&lt->u.ns; })
3083
3084	#define LANG_DECL_PARM_CHECK(NODE) __extension__ \
3085	({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \
3086	if (TREE_CODE (NODE) != PARM_DECL \
3087	\|\| lt->u.base.selector != lds_parm) \
3088	lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
3089	&lt->u.parm; })
3090
3091	#define LANG_DECL_DECOMP_CHECK(NODE) __extension__ \
3092	({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \
3093	if (!VAR_P (NODE) \
3094	\|\| lt->u.base.selector != lds_decomp) \
3095	lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
3096	&lt->u.decomp; })
3097
3098	#else
3099
3100	#define LANG_DECL_MIN_CHECK(NODE) \
3101	(&DECL_LANG_SPECIFIC (NODE)->u.min)
3102
3103	#define LANG_DECL_FN_CHECK(NODE) \
3104	(&DECL_LANG_SPECIFIC (STRIP_TEMPLATE (NODE))->u.fn)
3105
3106	#define LANG_DECL_NS_CHECK(NODE) \
3107	(&DECL_LANG_SPECIFIC (NODE)->u.ns)
3108
3109	#define LANG_DECL_PARM_CHECK(NODE) \
3110	(&DECL_LANG_SPECIFIC (NODE)->u.parm)
3111
3112	#define LANG_DECL_DECOMP_CHECK(NODE) \
3113	(&DECL_LANG_SPECIFIC (NODE)->u.decomp)
3114
3115	#endif /* ENABLE_TREE_CHECKING */
3116
3117	/ For a FUNCTION_DECL or a VAR_DECL, the language linkage for the*
3118	declaration. Some entities (like a member function in a local
3119	class, or a local variable) do not have linkage at all, and this
3120	macro should not be used in those cases.
3121
3122	Implementation note: A FUNCTION_DECL without DECL_LANG_SPECIFIC was
3123	created by language-independent code, and has C linkage. Most
3124	VAR_DECLs have C++ linkage, and do not have DECL_LANG_SPECIFIC, but
3125	we do create DECL_LANG_SPECIFIC for variables with non-C++ linkage. /*
3126	#define DECL_LANGUAGE(NODE) \
3127	(DECL_LANG_SPECIFIC (NODE) \
3128	? DECL_LANG_SPECIFIC (NODE)->u.base.language \
3129	: (TREE_CODE (NODE) == FUNCTION_DECL \
3130	? lang_c : lang_cplusplus))
3131
3132	/ Set the language linkage for NODE to LANGUAGE. /
3133	#define SET_DECL_LANGUAGE(NODE, LANGUAGE) \
3134	(DECL_LANG_SPECIFIC (NODE)->u.base.language = (LANGUAGE))
3135
3136	/ For FUNCTION_DECLs and TEMPLATE_DECLs: nonzero means that this function*
3137	is a constructor. /*
3138	#define DECL_CONSTRUCTOR_P(NODE) \
3139	DECL_CXX_CONSTRUCTOR_P (STRIP_TEMPLATE (NODE))
3140
3141	/ Nonzero if NODE (a FUNCTION_DECL) is a constructor for a complete*
3142	object. /*
3143	#define DECL_COMPLETE_CONSTRUCTOR_P(NODE) \
3144	(DECL_NAME (NODE) == complete_ctor_identifier)
3145
3146	/ Nonzero if NODE (a FUNCTION_DECL) is a constructor for a base*
3147	object. /*
3148	#define DECL_BASE_CONSTRUCTOR_P(NODE) \
3149	(DECL_NAME (NODE) == base_ctor_identifier)
3150
3151	/ Nonzero if NODE (a FUNCTION_DECL) is a constructor, but not either the*
3152	specialized in-charge constructor or the specialized not-in-charge
3153	constructor. /*
3154	#define DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P(NODE) \
3155	(DECL_NAME (NODE) == ctor_identifier)
3156
3157	/ Nonzero if NODE (a FUNCTION_DECL) is a copy constructor. /
3158	#define DECL_COPY_CONSTRUCTOR_P(NODE) \
3159	(DECL_CONSTRUCTOR_P (NODE) && copy_fn_p (NODE) > 0)
3160
3161	/ Nonzero if NODE (a FUNCTION_DECL) is a move constructor. /
3162	#define DECL_MOVE_CONSTRUCTOR_P(NODE) \
3163	(DECL_CONSTRUCTOR_P (NODE) && move_fn_p (NODE))
3164
3165	/ Nonzero if NODE (a FUNCTION_DECL or TEMPLATE_DECL)*
3166	is a destructor. /*
3167	#define DECL_DESTRUCTOR_P(NODE) \
3168	DECL_CXX_DESTRUCTOR_P (STRIP_TEMPLATE (NODE))
3169
3170	/ Nonzero if NODE (a FUNCTION_DECL) is a destructor, but not the*
3171	specialized in-charge constructor, in-charge deleting constructor,
3172	or the base destructor. /*
3173	#define DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P(NODE) \
3174	(DECL_NAME (NODE) == dtor_identifier)
3175
3176	/ Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete*
3177	object. /*
3178	#define DECL_COMPLETE_DESTRUCTOR_P(NODE) \
3179	(DECL_NAME (NODE) == complete_dtor_identifier)
3180
3181	/ Nonzero if NODE (a FUNCTION_DECL) is a destructor for a base*
3182	object. /*
3183	#define DECL_BASE_DESTRUCTOR_P(NODE) \
3184	(DECL_NAME (NODE) == base_dtor_identifier)
3185
3186	/ Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete*
3187	object that deletes the object after it has been destroyed. /*
3188	#define DECL_DELETING_DESTRUCTOR_P(NODE) \
3189	(DECL_NAME (NODE) == deleting_dtor_identifier)
3190
3191	/ Nonzero if either DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P or*
3192	DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P is true of NODE. /*
3193	#define DECL_MAYBE_IN_CHARGE_CDTOR_P(NODE) \
3194	(DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (NODE) \
3195	\|\| DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (NODE))
3196
3197	/ Nonzero if NODE (a _DECL) is a cloned constructor or*
3198	destructor. /*
3199	#define DECL_CLONED_FUNCTION_P(NODE) \
3200	(DECL_NAME (NODE) \
3201	&& IDENTIFIER_CDTOR_P (DECL_NAME (NODE)) \
3202	&& !DECL_MAYBE_IN_CHARGE_CDTOR_P (NODE))
3203
3204	/ If DECL_CLONED_FUNCTION_P holds, this is the function that was*
3205	cloned. /*
3206	#define DECL_CLONED_FUNCTION(NODE) \
3207	(DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (NODE))->u.fn.u5.cloned_function)
3208
3209	/ Perform an action for each clone of FN, if FN is a function with*
3210	clones. This macro should be used like:
3211
3212	FOR_EACH_CLONE (clone, fn)
3213	{ ... }
3214
3215	*/
3216	#define FOR_EACH_CLONE(CLONE, FN) \
3217	if (!(TREE_CODE (FN) == FUNCTION_DECL \
3218	&& DECL_MAYBE_IN_CHARGE_CDTOR_P (FN))) \
3219	; \
3220	else \
3221	for (CLONE = DECL_CHAIN (FN); \
3222	CLONE && DECL_CLONED_FUNCTION_P (CLONE); \
3223	CLONE = DECL_CHAIN (CLONE))
3224
3225	/ Nonzero if NODE has DECL_DISCRIMINATOR and not DECL_ACCESS. /
3226	#define DECL_DISCRIMINATOR_P(NODE) \
3227	(((VAR_P (NODE) && TREE_STATIC (NODE)) \
3228	\|\| DECL_IMPLICIT_TYPEDEF_P (NODE)) \
3229	&& DECL_FUNCTION_SCOPE_P (NODE))
3230
3231	/ Discriminator for name mangling. /
3232	#define DECL_DISCRIMINATOR(NODE) (LANG_DECL_MIN_CHECK (NODE)->access)
3233
3234	/ The index of a user-declared parameter in its function, starting at 1.*
3235	All artificial parameters will have index 0. /*
3236	#define DECL_PARM_INDEX(NODE) \
3237	(LANG_DECL_PARM_CHECK (NODE)->index)
3238
3239	/ The level of a user-declared parameter in its function, starting at 1.*
3240	A parameter of the function will have level 1; a parameter of the first
3241	nested function declarator (i.e. t in void f (void (p)(T t))) will have*
3242	level 2. /*
3243	#define DECL_PARM_LEVEL(NODE) \
3244	(LANG_DECL_PARM_CHECK (NODE)->level)
3245
3246	/ Nonzero if the VTT parm has been added to NODE. /
3247	#define DECL_HAS_VTT_PARM_P(NODE) \
3248	(LANG_DECL_FN_CHECK (NODE)->has_vtt_parm_p)
3249
3250	/ Nonzero if NODE is a user-defined conversion operator. /
3251	#define DECL_CONV_FN_P(NODE) IDENTIFIER_CONV_OP_P (DECL_NAME (NODE))
3252
3253	/ The type to which conversion operator FN converts to. /
3254	#define DECL_CONV_FN_TYPE(FN) \
3255	TREE_TYPE ((gcc_checking_assert (DECL_CONV_FN_P (FN)), DECL_NAME (FN)))
3256
3257	/ Nonzero if NODE, a templated variable, was declared as an*
3258	array of unknown bound. /*
3259	#define VAR_HAD_UNKNOWN_BOUND(NODE) \
3260	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE)) \
3261	? DECL_LANG_SPECIFIC (NODE)->u.base.unknown_bound_p \
3262	: false)
3263	#define SET_VAR_HAD_UNKNOWN_BOUND(NODE) \
3264	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.unknown_bound_p = true)
3265
3266	/ True iff decl NODE is for an overloaded operator. /
3267	#define DECL_OVERLOADED_OPERATOR_P(NODE) \
3268	IDENTIFIER_ANY_OP_P (DECL_NAME (NODE))
3269
3270	/ Nonzero if NODE is an assignment operator (including += and such). /
3271	#define DECL_ASSIGNMENT_OPERATOR_P(NODE) \
3272	IDENTIFIER_ASSIGN_OP_P (DECL_NAME (NODE))
3273
3274	/ NODE is a function_decl for an overloaded operator. Return its*
3275	compressed (raw) operator code. Note that this is not a TREE_CODE. /*
3276	#define DECL_OVERLOADED_OPERATOR_CODE_RAW(NODE) \
3277	(LANG_DECL_FN_CHECK (NODE)->ovl_op_code)
3278
3279	/ DECL is an overloaded operator. Test whether it is for TREE_CODE*
3280	(a literal constant). /*
3281	#define DECL_OVERLOADED_OPERATOR_IS(DECL, CODE) \
3282	(DECL_OVERLOADED_OPERATOR_CODE_RAW (DECL) == OVL_OP_##CODE)
3283
3284	/ For FUNCTION_DECLs: nonzero means that this function is a*
3285	constructor or a destructor with an extra in-charge parameter to
3286	control whether or not virtual bases are constructed. /*
3287	#define DECL_HAS_IN_CHARGE_PARM_P(NODE) \
3288	(LANG_DECL_FN_CHECK (NODE)->has_in_charge_parm_p)
3289
3290	/ Nonzero if DECL is a declaration of __builtin_constant_p. /
3291	#define DECL_IS_BUILTIN_CONSTANT_P(NODE) \
3292	(TREE_CODE (NODE) == FUNCTION_DECL \
3293	&& DECL_BUILT_IN_CLASS (NODE) == BUILT_IN_NORMAL \
3294	&& DECL_FUNCTION_CODE (NODE) == BUILT_IN_CONSTANT_P)
3295
3296	/ Nonzero for _DECL means that this decl appears in (or will appear*
3297	in) as a member in a RECORD_TYPE or UNION_TYPE node. It is also for
3298	detecting circularity in case members are multiply defined. In the
3299	case of a VAR_DECL, it means that no definition has been seen, even
3300	if an initializer has been. /*
3301	#define DECL_IN_AGGR_P(NODE) (DECL_LANG_FLAG_3 (NODE))
3302
3303	/ Nonzero for a VAR_DECL means that the variable's initialization (if*
3304	any) has been processed. (In general, DECL_INITIALIZED_P is
3305	!DECL_EXTERNAL, but static data members may be initialized even if
3306	not defined.) /*
3307	#define DECL_INITIALIZED_P(NODE) \
3308	(TREE_LANG_FLAG_1 (VAR_DECL_CHECK (NODE)))
3309
3310	/ Nonzero for a VAR_DECL iff an explicit initializer was provided*
3311	or a non-trivial constructor is called. /*
3312	#define DECL_NONTRIVIALLY_INITIALIZED_P(NODE) \
3313	(TREE_LANG_FLAG_6 (VAR_DECL_CHECK (NODE)))
3314
3315	/ Nonzero for a VAR_DECL that was initialized with a*
3316	constant-expression. /*
3317	#define DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P(NODE) \
3318	(TREE_LANG_FLAG_2 (VAR_DECL_CHECK (NODE)))
3319
3320	/ Nonzero if the DECL was initialized in the class definition itself,*
3321	rather than outside the class. This is used for both static member
3322	VAR_DECLS, and FUNCTION_DECLS that are defined in the class. /*
3323	#define DECL_INITIALIZED_IN_CLASS_P(DECL) \
3324	(DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL)) \
3325	->u.base.initialized_in_class)
3326
3327	/ Nonzero if the DECL is used in the sense of 3.2 [basic.def.odr].*
3328	Only available for decls with DECL_LANG_SPECIFIC. /*
3329	#define DECL_ODR_USED(DECL) \
3330	(DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL)) \
3331	->u.base.odr_used)
3332
3333	/ Nonzero for FUNCTION_DECL means that this is a friend that is*
3334	either not pushed into a namespace/looked up in a class (because it
3335	is a dependent type, in an uninstantiated template), or it has
3336	/only/ been subject to hidden friend injection from one or more
3337	befriending classes. Once another decl matches, the flag is
3338	cleared. There are requirements on its default parms. /*
3339	#define DECL_UNIQUE_FRIEND_P(NODE) \
3340	(DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (NODE)) \
3341	->u.base.friend_or_tls)
3342
3343	/ True of a TEMPLATE_DECL that is a template class friend. Such*
3344	decls are not pushed until instantiated (as they may depend on
3345	parameters of the befriending class). DECL_CHAIN is the
3346	befriending class. /*
3347	#define DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P(NODE) \
3348	(DECL_LANG_FLAG_4 (TEMPLATE_DECL_CHECK (NODE)))
3349
3350	/ Nonzero if the thread-local variable was declared with __thread as*
3351	opposed to thread_local. /*
3352	#define DECL_GNU_TLS_P(NODE) \
3353	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE)) \
3354	&& DECL_LANG_SPECIFIC (NODE)->u.base.friend_or_tls)
3355	#define SET_DECL_GNU_TLS_P(NODE) \
3356	(retrofit_lang_decl (VAR_DECL_CHECK (NODE)), \
3357	DECL_LANG_SPECIFIC (NODE)->u.base.friend_or_tls = true)
3358
3359	/ A TREE_LIST of the types which have befriended this FUNCTION_DECL. /
3360	#define DECL_BEFRIENDING_CLASSES(NODE) \
3361	(LANG_DECL_FN_CHECK (NODE)->befriending_classes)
3362
3363	/ Nonzero for FUNCTION_DECL means that this decl is a static*
3364	member function. /*
3365	#define DECL_STATIC_FUNCTION_P(NODE) \
3366	(LANG_DECL_FN_CHECK (NODE)->static_function)
3367
3368	/ Nonzero for FUNCTION_DECL means that this decl is a non-static member*
3369	function. C++23 explicit object member functions are also considered
3370	non-static, but most former uses of this macro meant implicit object member
3371	function. Instead of this macro, use DECL_IOBJ_MEMBER_FUNCTION_P or
3372	DECL_OBJECT_MEMBER_FUNCTION_P. /*
3373	#define DECL_NONSTATIC_MEMBER_FUNCTION_P(NODE) did_you_mean_object_or_iobj
3374
3375	/ Nonzero for FUNCTION_DECL means that this decl is an implicit object*
3376	member function. /*
3377	#define DECL_IOBJ_MEMBER_FUNCTION_P(NODE) \
3378	(TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE)
3379
3380	/ Simple member access, only valid for FUNCTION_DECL nodes. /
3381	#define DECL_FUNCTION_XOBJ_FLAG(NODE) \
3382	(LANG_DECL_FN_CHECK (NODE)->xobj_func)
3383
3384	/ Nonzero if NODE is an xobj member function,*
3385	safely evaluates to false for all non FUNCTION_DECL nodes. /*
3386	#define DECL_XOBJ_MEMBER_FUNCTION_P(NODE) \
3387	(TREE_CODE (STRIP_TEMPLATE (NODE)) == FUNCTION_DECL \
3388	&& DECL_FUNCTION_XOBJ_FLAG (NODE) == 1)
3389
3390	/ Nonzero if NODE is a member function with an object argument,*
3391	in other words, a non-static member function. /*
3392	#define DECL_OBJECT_MEMBER_FUNCTION_P(NODE) \
3393	(DECL_IOBJ_MEMBER_FUNCTION_P (NODE) \|\| DECL_XOBJ_MEMBER_FUNCTION_P (NODE))
3394
3395	/ Nonzero for FUNCTION_DECL means that this decl is a member function*
3396	(static or non-static). /*
3397	#define DECL_FUNCTION_MEMBER_P(NODE) \
3398	(DECL_OBJECT_MEMBER_FUNCTION_P (NODE) \|\| DECL_STATIC_FUNCTION_P (NODE)) \
3399
3400	/ Nonzero for FUNCTION_DECL means that this member function*
3401	has `this' as const X const. /
3402	#define DECL_CONST_MEMFUNC_P(NODE) \
3403	(DECL_IOBJ_MEMBER_FUNCTION_P (NODE) \
3404	&& CP_TYPE_CONST_P (TREE_TYPE (TREE_VALUE \
3405	(TYPE_ARG_TYPES (TREE_TYPE (NODE))))))
3406
3407	/ Nonzero for FUNCTION_DECL means that this member function*
3408	has `this' as volatile X const. /
3409	#define DECL_VOLATILE_MEMFUNC_P(NODE) \
3410	(DECL_IOBJ_MEMBER_FUNCTION_P (NODE) \
3411	&& CP_TYPE_VOLATILE_P (TREE_TYPE (TREE_VALUE \
3412	(TYPE_ARG_TYPES (TREE_TYPE (NODE))))))
3413
3414	/ Nonzero for a DECL means that this member is a non-static member. /
3415	#define DECL_NONSTATIC_MEMBER_P(NODE) \
3416	(DECL_OBJECT_MEMBER_FUNCTION_P (NODE) \
3417	\|\| TREE_CODE (NODE) == FIELD_DECL)
3418
3419	/ Nonzero for a FIELD_DECL means that this member object type*
3420	is mutable. /*
3421	#define DECL_MUTABLE_P(NODE) (DECL_LANG_FLAG_0 (FIELD_DECL_CHECK (NODE)))
3422
3423	/ Nonzero for _DECL means that this constructor or conversion function is*
3424	non-converting. /*
3425	#define DECL_NONCONVERTING_P(NODE) \
3426	(LANG_DECL_FN_CHECK (NODE)->nonconverting)
3427
3428	/ Nonzero for FUNCTION_DECL means that this member function is a pure*
3429	virtual function. /*
3430	#define DECL_PURE_VIRTUAL_P(NODE) \
3431	(LANG_DECL_FN_CHECK (NODE)->pure_virtual)
3432
3433	/ Nonzero for FUNCTION_DECL means that this member function (either*
3434	a constructor or a conversion function) has an explicit specifier
3435	with a value-dependent expression. /*
3436	#define DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P(NODE) \
3437	(LANG_DECL_FN_CHECK (NODE)->has_dependent_explicit_spec_p)
3438
3439	/ Nonzero for a defaulted FUNCTION_DECL for which we haven't decided yet if*
3440	it's deleted; we will decide in synthesize_method. /*
3441	#define DECL_MAYBE_DELETED(NODE) \
3442	(LANG_DECL_FN_CHECK (NODE)->maybe_deleted)
3443
3444	/ Nonzero for FUNCTION_DECL means that this function's body has been*
3445	checked for immediate-escalating expressions and maybe promoted. It
3446	does not* mean the function is consteval. It must not be set in*
3447	a function that was marked consteval by the user, so that we can
3448	distinguish between explicitly consteval functions and promoted consteval
3449	functions. /*
3450	#define DECL_ESCALATION_CHECKED_P(NODE) (LANG_DECL_FN_CHECK (NODE)->escalated_p)
3451
3452	/ True (in a FUNCTION_DECL) if NODE is a virtual function that is an*
3453	invalid overrider for a function from a base class. Once we have
3454	complained about an invalid overrider we avoid complaining about it
3455	again. /*
3456	#define DECL_INVALID_OVERRIDER_P(NODE) \
3457	(DECL_LANG_FLAG_4 (NODE))
3458
3459	/ True (in a FUNCTION_DECL) if NODE is a function declared with*
3460	an override virt-specifier /*
3461	#define DECL_OVERRIDE_P(NODE) (TREE_LANG_FLAG_0 (NODE))
3462
3463	/ The thunks associated with NODE, a FUNCTION_DECL. /
3464	#define DECL_THUNKS(NODE) \
3465	(DECL_VIRTUAL_P (NODE) ? LANG_DECL_FN_CHECK (NODE)->context : NULL_TREE)
3466
3467	/ Set DECL_THUNKS. /
3468	#define SET_DECL_THUNKS(NODE,THUNKS) \
3469	(LANG_DECL_FN_CHECK (NODE)->context = (THUNKS))
3470
3471	/ If NODE, a FUNCTION_DECL, is a C++11 inheriting constructor, then this*
3472	is the constructor it inherits from. /*
3473	#define DECL_INHERITED_CTOR(NODE) \
3474	(DECL_DECLARES_FUNCTION_P (NODE) && DECL_CONSTRUCTOR_P (NODE) \
3475	? LANG_DECL_FN_CHECK (NODE)->context : NULL_TREE)
3476
3477	/ And this is the base that constructor comes from. /
3478	#define DECL_INHERITED_CTOR_BASE(NODE) \
3479	(DECL_INHERITED_CTOR (NODE) \
3480	? DECL_CONTEXT (flag_new_inheriting_ctors \
3481	? strip_inheriting_ctors (NODE) \
3482	: DECL_INHERITED_CTOR (NODE)) \
3483	: NULL_TREE)
3484
3485	/ Set the inherited base. /
3486	#define SET_DECL_INHERITED_CTOR(NODE,INH) \
3487	(LANG_DECL_FN_CHECK (NODE)->context = (INH))
3488
3489	/ Nonzero if NODE is a thunk, rather than an ordinary function. /
3490	#define DECL_THUNK_P(NODE) \
3491	(TREE_CODE (NODE) == FUNCTION_DECL \
3492	&& DECL_LANG_SPECIFIC (NODE) \
3493	&& LANG_DECL_FN_CHECK (NODE)->thunk_p)
3494
3495	/ Set DECL_THUNK_P for node. /
3496	#define SET_DECL_THUNK_P(NODE, THIS_ADJUSTING) \
3497	(LANG_DECL_FN_CHECK (NODE)->thunk_p = 1, \
3498	LANG_DECL_FN_CHECK (NODE)->this_thunk_p = (THIS_ADJUSTING))
3499
3500	/ Nonzero if NODE is a this pointer adjusting thunk. /
3501	#define DECL_THIS_THUNK_P(NODE) \
3502	(DECL_THUNK_P (NODE) && LANG_DECL_FN_CHECK (NODE)->this_thunk_p)
3503
3504	/ Nonzero if NODE is a result pointer adjusting thunk. /
3505	#define DECL_RESULT_THUNK_P(NODE) \
3506	(DECL_THUNK_P (NODE) && !LANG_DECL_FN_CHECK (NODE)->this_thunk_p)
3507
3508	/ Nonzero if NODE is a FUNCTION_DECL, but not a thunk. /
3509	#define DECL_NON_THUNK_FUNCTION_P(NODE) \
3510	(TREE_CODE (NODE) == FUNCTION_DECL && !DECL_THUNK_P (NODE))
3511
3512	/ Nonzero if NODE is `extern "C"'. /
3513	#define DECL_EXTERN_C_P(NODE) \
3514	(DECL_LANGUAGE (NODE) == lang_c)
3515
3516	/ Nonzero if NODE is an `extern "C"' function. /
3517	#define DECL_EXTERN_C_FUNCTION_P(NODE) \
3518	(DECL_NON_THUNK_FUNCTION_P (NODE) && DECL_EXTERN_C_P (NODE))
3519
3520	/ Non-zero if this variable is declared `constinit' specifier. /
3521	#define DECL_DECLARED_CONSTINIT_P(NODE) \
3522	(DECL_LANG_FLAG_7 (VAR_DECL_CHECK (NODE)))
3523
3524	/ True if DECL is declared 'constexpr'. /
3525	#define DECL_DECLARED_CONSTEXPR_P(DECL) \
3526	DECL_LANG_FLAG_8 (VAR_OR_FUNCTION_DECL_CHECK (STRIP_TEMPLATE (DECL)))
3527
3528	/ True if FNDECL is an immediate function. /
3529	#define DECL_IMMEDIATE_FUNCTION_P(NODE) \
3530	(DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (STRIP_TEMPLATE (NODE))) \
3531	? LANG_DECL_FN_CHECK (NODE)->immediate_fn_p \
3532	: false)
3533	#define SET_DECL_IMMEDIATE_FUNCTION_P(NODE) \
3534	(retrofit_lang_decl (FUNCTION_DECL_CHECK (NODE)), \
3535	LANG_DECL_FN_CHECK (NODE)->immediate_fn_p = true)
3536
3537	// True if NODE was declared as 'concept'. The flag implies that the
3538	// declaration is constexpr, that the declaration cannot be specialized or
3539	// refined, and that the result type must be convertible to bool.
3540	#define DECL_DECLARED_CONCEPT_P(NODE) \
3541	(DECL_LANG_SPECIFIC (NODE)->u.base.concept_p)
3542
3543	/ Nonzero if this DECL is the __PRETTY_FUNCTION__ variable in a*
3544	template function. /*
3545	#define DECL_PRETTY_FUNCTION_P(NODE) \
3546	(DECL_NAME (NODE) \
3547	&& id_equal (DECL_NAME (NODE), "__PRETTY_FUNCTION__"))
3548
3549	/ For a DECL, true if it is __func__ or similar. /
3550	#define DECL_FNAME_P(NODE) \
3551	(VAR_P (NODE) && DECL_NAME (NODE) && DECL_ARTIFICIAL (NODE) \
3552	&& DECL_HAS_VALUE_EXPR_P (NODE) \
3553	&& (id_equal (DECL_NAME (NODE), "__PRETTY_FUNCTION__") \
3554	\|\| id_equal (DECL_NAME (NODE), "__FUNCTION__") \
3555	\|\| id_equal (DECL_NAME (NODE), "__func__")))
3556
3557	/ Nonzero if the variable was declared to be thread-local.*
3558	We need a special C++ version of this test because the middle-end
3559	DECL_THREAD_LOCAL_P uses the symtab, so we can't use it for
3560	templates. /*
3561	#define CP_DECL_THREAD_LOCAL_P(NODE) \
3562	(TREE_LANG_FLAG_0 (VAR_DECL_CHECK (NODE)))
3563
3564	/ The _TYPE context in which this _DECL appears. This field holds the*
3565	class where a virtual function instance is actually defined. /*
3566	#define DECL_CLASS_CONTEXT(NODE) \
3567	(DECL_CLASS_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : NULL_TREE)
3568
3569	/ For a non-member friend function, the class (if any) in which this*
3570	friend was defined. For example, given:
3571
3572	struct S { friend void f () { ... } };
3573
3574	the DECL_FRIEND_CONTEXT for `f' will be `S'. /*
3575	#define DECL_FRIEND_CONTEXT(NODE) \
3576	((DECL_DECLARES_FUNCTION_P (NODE) && !DECL_VIRTUAL_P (NODE) \
3577	&& !DECL_CONSTRUCTOR_P (NODE)) \
3578	? LANG_DECL_FN_CHECK (NODE)->context \
3579	: NULL_TREE)
3580
3581	/ Set the DECL_FRIEND_CONTEXT for NODE to CONTEXT. /
3582	#define SET_DECL_FRIEND_CONTEXT(NODE, CONTEXT) \
3583	(LANG_DECL_FN_CHECK (NODE)->context = (CONTEXT))
3584
3585	#define CP_DECL_CONTEXT(NODE) \
3586	(!DECL_FILE_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : global_namespace)
3587	#define CP_TYPE_CONTEXT(NODE) \
3588	(!TYPE_FILE_SCOPE_P (NODE) ? TYPE_CONTEXT (NODE) : global_namespace)
3589	#define FROB_CONTEXT(NODE) \
3590	((NODE) == global_namespace ? DECL_CONTEXT (NODE) : (NODE))
3591
3592	/ 1 iff NODE has namespace scope, including the global namespace. /
3593	#define DECL_NAMESPACE_SCOPE_P(NODE) \
3594	(!DECL_TEMPLATE_PARM_P (NODE) \
3595	&& TREE_CODE (CP_DECL_CONTEXT (NODE)) == NAMESPACE_DECL)
3596
3597	#define TYPE_NAMESPACE_SCOPE_P(NODE) \
3598	(TREE_CODE (CP_TYPE_CONTEXT (NODE)) == NAMESPACE_DECL)
3599
3600	#define NAMESPACE_SCOPE_P(NODE) \
3601	((DECL_P (NODE) && DECL_NAMESPACE_SCOPE_P (NODE)) \
3602	\|\| (TYPE_P (NODE) && TYPE_NAMESPACE_SCOPE_P (NODE)))
3603
3604	/ 1 iff NODE is a class member. /
3605	#define DECL_CLASS_SCOPE_P(NODE) \
3606	(DECL_CONTEXT (NODE) && TYPE_P (DECL_CONTEXT (NODE)))
3607
3608	#define TYPE_CLASS_SCOPE_P(NODE) \
3609	(TYPE_CONTEXT (NODE) && TYPE_P (TYPE_CONTEXT (NODE)))
3610
3611	/ 1 iff NODE is function-local. /
3612	#define DECL_FUNCTION_SCOPE_P(NODE) \
3613	(DECL_CONTEXT (NODE) \
3614	&& TREE_CODE (DECL_CONTEXT (NODE)) == FUNCTION_DECL)
3615
3616	#define TYPE_FUNCTION_SCOPE_P(NODE) \
3617	(TYPE_CONTEXT (NODE) && TREE_CODE (TYPE_CONTEXT (NODE)) == FUNCTION_DECL)
3618
3619	/ 1 iff VAR_DECL node NODE is a type-info decl. This flag is set for*
3620	both the primary typeinfo object and the associated NTBS name. /*
3621	#define DECL_TINFO_P(NODE) \
3622	TREE_LANG_FLAG_4 (TREE_CHECK2 (NODE,VAR_DECL,TYPE_DECL))
3623
3624	/ true iff VAR_DECL node NODE is a NTTP object decl. /
3625	#define DECL_NTTP_OBJECT_P(NODE) \
3626	TREE_LANG_FLAG_5 (TREE_CHECK (NODE,VAR_DECL))
3627
3628	/ 1 iff VAR_DECL node NODE is virtual table or VTT. We forward to*
3629	DECL_VIRTUAL_P from the common code, as that has the semantics we
3630	need. But we want a more descriptive name. /*
3631	#define DECL_VTABLE_OR_VTT_P(NODE) DECL_VIRTUAL_P (VAR_DECL_CHECK (NODE))
3632
3633	/ 1 iff a _DECL for a template parameter came from*
3634	synthesize_implicit_template_parm. /*
3635	#define DECL_IMPLICIT_TEMPLATE_PARM_P(NODE) \
3636	DECL_VIRTUAL_P (DECL_TEMPLATE_PARM_CHECK (NODE))
3637
3638	/ 1 iff FUNCTION_TYPE or METHOD_TYPE has a ref-qualifier (either & or &&). /
3639	#define FUNCTION_REF_QUALIFIED(NODE) \
3640	TREE_LANG_FLAG_4 (FUNC_OR_METHOD_CHECK (NODE))
3641
3642	/ 1 iff FUNCTION_TYPE or METHOD_TYPE has &&-ref-qualifier. /
3643	#define FUNCTION_RVALUE_QUALIFIED(NODE) \
3644	TREE_LANG_FLAG_5 (FUNC_OR_METHOD_CHECK (NODE))
3645
3646	/ 1 iff NODE is function-local, but for types. /
3647	#define LOCAL_CLASS_P(NODE) \
3648	(decl_function_context (TYPE_MAIN_DECL (NODE)) != NULL_TREE)
3649
3650	/ The nesting depth of namespace, class or function. Makes is_ancestor much*
3651	simpler. Only 8 bits available. /*
3652	#define SCOPE_DEPTH(NODE) \
3653	(NAMESPACE_DECL_CHECK (NODE)->base.u.bits.address_space)
3654
3655	/ Whether the namepace is an inline namespace. /
3656	#define DECL_NAMESPACE_INLINE_P(NODE) \
3657	TREE_LANG_FLAG_0 (NAMESPACE_DECL_CHECK (NODE))
3658
3659	/ In a NAMESPACE_DECL, a vector of inline namespaces. /
3660	#define DECL_NAMESPACE_INLINEES(NODE) \
3661	(LANG_DECL_NS_CHECK (NODE)->inlinees)
3662
3663	/ Pointer to hash_map from IDENTIFIERS to DECLS /
3664	#define DECL_NAMESPACE_BINDINGS(NODE) \
3665	(LANG_DECL_NS_CHECK (NODE)->bindings)
3666
3667	/ In a NAMESPACE_DECL, points to the original namespace if this is*
3668	a namespace alias. /*
3669	#define DECL_NAMESPACE_ALIAS(NODE) \
3670	DECL_ABSTRACT_ORIGIN (NAMESPACE_DECL_CHECK (NODE))
3671	#define ORIGINAL_NAMESPACE(NODE) \
3672	(DECL_NAMESPACE_ALIAS (NODE) ? DECL_NAMESPACE_ALIAS (NODE) : (NODE))
3673
3674	/ Nonzero if NODE is the std namespace. /
3675	#define DECL_NAMESPACE_STD_P(NODE) \
3676	((NODE) == std_node)
3677
3678	/ In a TREE_LIST in an attribute list, indicates that the attribute*
3679	must be applied at instantiation time. /*
3680	#define ATTR_IS_DEPENDENT(NODE) TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
3681
3682	/ In a TREE_LIST in the argument of attribute abi_tag, indicates that the tag*
3683	was inherited from a template parameter, not explicitly indicated. /*
3684	#define ABI_TAG_IMPLICIT(NODE) TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
3685
3686	/ In a TREE_LIST for a parameter-declaration-list, indicates that all the*
3687	parameters in the list have declarators enclosed in (). /*
3688	#define PARENTHESIZED_LIST_P(NODE) TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
3689
3690	/ Non zero if this is a using decl for a dependent scope. /
3691	#define DECL_DEPENDENT_P(NODE) DECL_LANG_FLAG_0 (USING_DECL_CHECK (NODE))
3692
3693	/ The scope named in a using decl. /
3694	#define USING_DECL_SCOPE(NODE) DECL_RESULT_FLD (USING_DECL_CHECK (NODE))
3695
3696	/ The decls named by a using decl. /
3697	#define USING_DECL_DECLS(NODE) DECL_INITIAL (USING_DECL_CHECK (NODE))
3698
3699	/ Non zero if the using decl refers to a dependent type. /
3700	#define USING_DECL_TYPENAME_P(NODE) DECL_LANG_FLAG_1 (USING_DECL_CHECK (NODE))
3701
3702	/ True if member using decl NODE refers to a non-inherited NODE. /
3703	#define USING_DECL_UNRELATED_P(NODE) DECL_LANG_FLAG_2 (USING_DECL_CHECK (NODE))
3704
3705	/ True iff the CONST_DECL is a class-scope clone from C++20 using enum,*
3706	created by handle_using_decl. /*
3707	#define CONST_DECL_USING_P(NODE) \
3708	(TREE_CODE (NODE) == CONST_DECL \
3709	&& TREE_TYPE (NODE) \
3710	&& TREE_CODE (TREE_TYPE (NODE)) == ENUMERAL_TYPE \
3711	&& DECL_CONTEXT (NODE) != TREE_TYPE (NODE))
3712
3713	/ In a FUNCTION_DECL, this is nonzero if this function was defined in*
3714	the class definition. We have saved away the text of the function,
3715	but have not yet processed it. /*
3716	#define DECL_PENDING_INLINE_P(NODE) \
3717	(LANG_DECL_FN_CHECK (NODE)->pending_inline_p)
3718
3719	/ If DECL_PENDING_INLINE_P holds, this is the saved text of the*
3720	function. /*
3721	#define DECL_PENDING_INLINE_INFO(NODE) \
3722	(LANG_DECL_FN_CHECK (NODE)->u.pending_inline_info)
3723
3724	/ Nonzero for TYPE_DECL means that it was written 'using name = type'. /
3725	#define TYPE_DECL_ALIAS_P(NODE) \
3726	DECL_LANG_FLAG_6 (TYPE_DECL_CHECK (NODE))
3727
3728	/ Nonzero for a type which is an alias for another type; i.e, a type*
3729	which declaration was written 'using name-of-type =
3730	another-type'. /*
3731	#define TYPE_ALIAS_P(NODE) \
3732	(TYPE_P (NODE) \
3733	&& TYPE_NAME (NODE) \
3734	&& TREE_CODE (TYPE_NAME (NODE)) == TYPE_DECL \
3735	&& TYPE_DECL_ALIAS_P (TYPE_NAME (NODE)))
3736
3737	/ If non-NULL for a VAR_DECL, FUNCTION_DECL, TYPE_DECL, TEMPLATE_DECL,*
3738	or CONCEPT_DECL, the entity is either a template specialization (if
3739	DECL_USE_TEMPLATE is nonzero) or the abstract instance of the
3740	template itself.
3741
3742	In either case, DECL_TEMPLATE_INFO is a TEMPLATE_INFO, whose
3743	TI_TEMPLATE is the TEMPLATE_DECL of which this entity is a
3744	specialization or abstract instance. The TI_ARGS is the
3745	template arguments used to specialize the template.
3746
3747	Consider:
3748
3749	template <typename T> struct S { friend void f(T) {} };
3750
3751	In this case, S<int>::f is, from the point of view of the compiler,
3752	an instantiation of a template -- but, from the point of view of
3753	the language, each instantiation of S results in a wholly unrelated
3754	global function f. In this case, DECL_TEMPLATE_INFO for S<int>::f
3755	will be non-NULL, but DECL_USE_TEMPLATE will be zero.
3756
3757	In a friend declaration, TI_TEMPLATE can be an overload set, or
3758	identifier. /*
3759	#define DECL_TEMPLATE_INFO(NODE) \
3760	(DECL_LANG_SPECIFIC (TEMPLATE_INFO_DECL_CHECK (NODE)) \
3761	->u.min.template_info)
3762
3763	/ For a lambda capture proxy, its captured variable. /
3764	#define DECL_CAPTURED_VARIABLE(NODE) \
3765	(LANG_DECL_MIN_CHECK (NODE)->access)
3766
3767	/ For a VAR_DECL, indicates that the variable is actually a*
3768	non-static data member of anonymous union that has been promoted to
3769	variable status. /*
3770	#define DECL_ANON_UNION_VAR_P(NODE) \
3771	(DECL_LANG_FLAG_4 (VAR_DECL_CHECK (NODE)))
3772
3773	/ Template information for a RECORD_TYPE or UNION_TYPE. /
3774	#define CLASSTYPE_TEMPLATE_INFO(NODE) \
3775	(TYPE_LANG_SLOT_1 (RECORD_OR_UNION_CHECK (NODE)))
3776
3777	/ Template information for a template template parameter. /
3778	#define TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO(NODE) \
3779	(TYPE_LANG_SLOT_1 (BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK (NODE)))
3780
3781	/ Template information for an ENUMERAL_, RECORD_, UNION_TYPE, or*
3782	BOUND_TEMPLATE_TEMPLATE_PARM type. This ignores any alias
3783	templateness of NODE. It'd be nice if this could unconditionally
3784	access the slot, rather than return NULL if given a
3785	non-templatable type. /*
3786	#define TYPE_TEMPLATE_INFO(NODE) \
3787	(TREE_CODE (NODE) == ENUMERAL_TYPE \
3788	\|\| TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM \
3789	\|\| RECORD_OR_UNION_TYPE_P (NODE) \
3790	? TYPE_LANG_SLOT_1 (NODE) : NULL_TREE)
3791
3792	/ Template information (if any) for an alias type. /
3793	#define TYPE_ALIAS_TEMPLATE_INFO(NODE) \
3794	(DECL_LANG_SPECIFIC (TYPE_NAME (NODE)) \
3795	? DECL_TEMPLATE_INFO (TYPE_NAME (NODE)) \
3796	: NULL_TREE)
3797
3798	/ If NODE is a type alias, this accessor returns the template info*
3799	for the alias template (if any). Otherwise behave as
3800	TYPE_TEMPLATE_INFO. /*
3801	#define TYPE_TEMPLATE_INFO_MAYBE_ALIAS(NODE) \
3802	(typedef_variant_p (NODE) \
3803	? TYPE_ALIAS_TEMPLATE_INFO (NODE) \
3804	: TYPE_TEMPLATE_INFO (NODE))
3805
3806	/ Set the template information for a non-alias n ENUMERAL_, RECORD_,*
3807	or UNION_TYPE to VAL. ALIAS's are dealt with separately. /*
3808	#define SET_TYPE_TEMPLATE_INFO(NODE, VAL) \
3809	(TREE_CODE (NODE) == ENUMERAL_TYPE \
3810	\|\| (CLASS_TYPE_P (NODE) && !TYPE_ALIAS_P (NODE)) \
3811	? (TYPE_LANG_SLOT_1 (NODE) = (VAL)) \
3812	: (DECL_TEMPLATE_INFO (TYPE_NAME (NODE)) = (VAL))) \
3813
3814	#define TI_TEMPLATE(NODE) \
3815	((struct tree_template_info*)TEMPLATE_INFO_CHECK (NODE))->tmpl
3816	#define TI_ARGS(NODE) \
3817	((struct tree_template_info*)TEMPLATE_INFO_CHECK (NODE))->args
3818	#define TI_PENDING_TEMPLATE_FLAG(NODE) \
3819	TREE_LANG_FLAG_1 (TEMPLATE_INFO_CHECK (NODE))
3820
3821	/ For a class or variable template specialization, this contains the*
3822	TEMPLATE_INFO result of most_specialized_partial_spec, i.e. the selected
3823	partial template specialization and arguments relative to it. /*
3824	#define TI_PARTIAL_INFO(NODE) \
3825	(gcc_checking_assert (PRIMARY_TEMPLATE_P (TI_TEMPLATE (NODE))), \
3826	((struct tree_template_info*)NODE)->partial)
3827
3828	/ For a given TREE_VEC containing a template argument list,*
3829	this property contains the number of arguments that are not
3830	defaulted. /*
3831	#define NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \
3832	TREE_CHAIN (TREE_VEC_CHECK (NODE))
3833
3834	/ Below are the setter and getter of the NON_DEFAULT_TEMPLATE_ARGS_COUNT*
3835	property. /*
3836	#define SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE, INT_VALUE) \
3837	NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) = build_int_cst (NULL_TREE, INT_VALUE)
3838	#if CHECKING_P
3839	#define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \
3840	int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE))
3841	#else
3842	#define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \
3843	NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE) \
3844	? int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE)) \
3845	: TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (NODE))
3846	#endif
3847
3848	/ True iff NODE represents the template args for a type-constraint,*
3849	in which case the first one represents the constrained type.
3850	Currently only set during mangling. /*
3851	#define TEMPLATE_ARGS_TYPE_CONSTRAINT_P(NODE) \
3852	TREE_PRIVATE (TREE_VEC_CHECK (NODE))
3853
3854	/ The list of access checks that were deferred during parsing*
3855	which need to be performed at template instantiation time.
3856
3857	FIXME this should be associated with the TEMPLATE_DECL, not the
3858	TEMPLATE_INFO. /*
3859	#define TI_DEFERRED_ACCESS_CHECKS(NODE) \
3860	((struct tree_template_info*)TEMPLATE_INFO_CHECK \
3861	(NODE))->deferred_access_checks
3862
3863	/ We use TREE_VECs to hold template arguments. If there is only one*
3864	level of template arguments, then the TREE_VEC contains the
3865	arguments directly. If there is more than one level of template
3866	arguments, then each entry in the TREE_VEC is itself a TREE_VEC,
3867	containing the template arguments for a single level. The first
3868	entry in the outer TREE_VEC is the outermost level of template
3869	parameters; the last is the innermost.
3870
3871	It is incorrect to ever form a template argument vector containing
3872	only one level of arguments, but which is a TREE_VEC containing as
3873	its only entry the TREE_VEC for that level.
3874
3875	For each TREE_VEC containing the template arguments for a single
3876	level, it's possible to get or set the number of non defaulted
3877	template arguments by using the accessor macros
3878	GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT or
3879	SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT. /*
3880
3881	/ Nonzero if the template arguments is actually a vector of vectors,*
3882	rather than just a vector. /*
3883	#define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \
3884	(NODE && TREE_VEC_LENGTH (NODE) && TREE_VEC_ELT (NODE, 0) \
3885	&& TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC)
3886
3887	/ The depth of a template argument vector. When called directly by*
3888	the parser, we use a TREE_LIST rather than a TREE_VEC to represent
3889	template arguments. In that case, there is only one level of template
3890	arguments. We may even see NULL_TREE if there are 0 levels of
3891	template arguments, as in cp_parser_requires_expression. /*
3892	#define TMPL_ARGS_DEPTH(NODE) \
3893	((NODE) == NULL_TREE ? 0 \
3894	: TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) \
3895	: 1)
3896
3897	/ The LEVELth level of the template ARGS. The outermost level of*
3898	args is level 1, not level 0. /*
3899	#define TMPL_ARGS_LEVEL(ARGS, LEVEL) \
3900	(TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS) \
3901	? TREE_VEC_ELT (ARGS, (LEVEL) - 1) \
3902	: (gcc_checking_assert ((LEVEL) == 1), (ARGS)))
3903
3904	/ Set the LEVELth level of the template ARGS to VAL. This macro does*
3905	not work with single-level argument vectors. /*
3906	#define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL) \
3907	(TREE_VEC_ELT (ARGS, (LEVEL) - 1) = (VAL))
3908
3909	/ Accesses the IDXth parameter in the LEVELth level of the ARGS. /
3910	#define TMPL_ARG(ARGS, LEVEL, IDX) \
3911	(TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX))
3912
3913	/ Given a single level of template arguments in NODE, return the*
3914	number of arguments. /*
3915	#define NUM_TMPL_ARGS(NODE) \
3916	(TREE_VEC_LENGTH (NODE))
3917
3918	/ Returns the innermost level of template arguments in ARGS. /
3919	#define INNERMOST_TEMPLATE_ARGS(NODE) \
3920	(get_innermost_template_args ((NODE), 1))
3921
3922	/ The number of levels of template parameters given by NODE. /
3923	#define TMPL_PARMS_DEPTH(NODE) \
3924	((HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_PURPOSE (NODE)))
3925
3926	/ The TEMPLATE_DECL instantiated or specialized by NODE. This*
3927	TEMPLATE_DECL will be the immediate parent, not the most general
3928	template. For example, in:
3929
3930	template <class T> struct S { template <class U> void f(U); }
3931
3932	the FUNCTION_DECL for S<int>::f<double> will have, as its
3933	DECL_TI_TEMPLATE, `template <class U> S<int>::f<U>'.
3934
3935	As a special case, for a member friend template of a template
3936	class, this value will not be a TEMPLATE_DECL, but rather an
3937	IDENTIFIER_NODE or OVERLOAD indicating the name of the template and
3938	any explicit template arguments provided. For example, in:
3939
3940	template <class T> struct S { friend void f<int>(int, double); }
3941
3942	the DECL_TI_TEMPLATE will be an IDENTIFIER_NODE for `f' and the
3943	DECL_TI_ARGS will be {int}.
3944
3945	For a FIELD_DECL with a non-static data member initializer, this value
3946	is the FIELD_DECL it was instantiated from. /*
3947	#define DECL_TI_TEMPLATE(NODE) TI_TEMPLATE (DECL_TEMPLATE_INFO (NODE))
3948
3949	/ The template arguments used to obtain this decl from the most*
3950	general form of DECL_TI_TEMPLATE. For the example given for
3951	DECL_TI_TEMPLATE, the DECL_TI_ARGS will be {int, double}. These
3952	are always the full set of arguments required to instantiate this
3953	declaration from the most general template specialized here. /*
3954	#define DECL_TI_ARGS(NODE) TI_ARGS (DECL_TEMPLATE_INFO (NODE))
3955
3956	/ The TEMPLATE_DECL associated with NODE, a class type. Even if NODE*
3957	will be generated from a partial specialization, the TEMPLATE_DECL
3958	referred to here will be the original template. For example,
3959	given:
3960
3961	template <typename T> struct S {};
3962	template <typename T> struct S<T> {};*
3963
3964	the CLASSTYPE_TI_TEMPLATE for S<int> will be S, not the S<T>.
3965
3966	For a member class template, CLASSTYPE_TI_TEMPLATE always refers to the
3967	partial instantiation rather than the primary template. CLASSTYPE_TI_ARGS
3968	are for the primary template if the partial instantiation isn't
3969	specialized, or for the explicit specialization if it is, e.g.
3970
3971	template <class T> class C { template <class U> class D; }
3972	template <> template <class U> class C<int>::D; /*
3973	#define CLASSTYPE_TI_TEMPLATE(NODE) TI_TEMPLATE (CLASSTYPE_TEMPLATE_INFO (NODE))
3974	#define CLASSTYPE_TI_ARGS(NODE) TI_ARGS (CLASSTYPE_TEMPLATE_INFO (NODE))
3975
3976	/ For a template instantiation TYPE, returns the TYPE corresponding*
3977	to the primary template. Otherwise returns TYPE itself. /*
3978	#define CLASSTYPE_PRIMARY_TEMPLATE_TYPE(TYPE) \
3979	((CLASSTYPE_USE_TEMPLATE ((TYPE)) \
3980	&& !CLASSTYPE_TEMPLATE_SPECIALIZATION ((TYPE))) \
3981	? TREE_TYPE (DECL_TEMPLATE_RESULT (DECL_PRIMARY_TEMPLATE \
3982	(CLASSTYPE_TI_TEMPLATE ((TYPE))))) \
3983	: (TYPE))
3984
3985	/ Like CLASS_TI_TEMPLATE, but also works for ENUMERAL_TYPEs. /
3986	#define TYPE_TI_TEMPLATE(NODE) \
3987	(TI_TEMPLATE (TYPE_TEMPLATE_INFO (NODE)))
3988
3989	/ Like DECL_TI_ARGS, but for an ENUMERAL_, RECORD_, or UNION_TYPE. /
3990	#define TYPE_TI_ARGS(NODE) \
3991	(TI_ARGS (TYPE_TEMPLATE_INFO (NODE)))
3992
3993	#define INNERMOST_TEMPLATE_PARMS(NODE) TREE_VALUE (NODE)
3994
3995	/ Nonzero if NODE (a TEMPLATE_DECL) is a member template, in the*
3996	sense of [temp.mem]. /*
3997	#define DECL_MEMBER_TEMPLATE_P(NODE) \
3998	(DECL_LANG_FLAG_1 (TEMPLATE_DECL_CHECK (NODE)))
3999
4000	/ Nonzero if the NODE corresponds to the template parameters for a*
4001	member template, whose inline definition is being processed after
4002	the class definition is complete. /*
4003	#define TEMPLATE_PARMS_FOR_INLINE(NODE) TREE_LANG_FLAG_1 (NODE)
4004
4005	/ Determine if a declaration (PARM_DECL or FIELD_DECL) is a pack. /
4006	#define DECL_PACK_P(NODE) \
4007	(DECL_P (NODE) && PACK_EXPANSION_P (TREE_TYPE (NODE)))
4008
4009	/ Determines if NODE is an expansion of one or more parameter packs,*
4010	e.g., a TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION. /*
4011	#define PACK_EXPANSION_P(NODE) \
4012	(TREE_CODE (NODE) == TYPE_PACK_EXPANSION \
4013	\|\| TREE_CODE (NODE) == EXPR_PACK_EXPANSION)
4014
4015	#define PACK_EXPANSION_CHECK(NODE) \
4016	TREE_CHECK2 (NODE, TYPE_PACK_EXPANSION, EXPR_PACK_EXPANSION)
4017
4018	/ Extracts the type or expression pattern from a TYPE_PACK_EXPANSION or*
4019	EXPR_PACK_EXPANSION. /*
4020	#define PACK_EXPANSION_PATTERN(NODE) \
4021	(TREE_CODE (PACK_EXPANSION_CHECK (NODE)) == TYPE_PACK_EXPANSION \
4022	? TREE_TYPE (NODE) : TREE_OPERAND (NODE, 0))
4023
4024	/ The list of parameter packs used in the PACK_EXPANSION_* node. The*
4025	TREE_VALUE of each TREE_LIST contains the parameter packs. /*
4026	#define PACK_EXPANSION_PARAMETER_PACKS(NODE) \
4027	*(TREE_CODE (PACK_EXPANSION_CHECK (NODE)) == EXPR_PACK_EXPANSION \
4028	? &TREE_OPERAND (NODE, 1) \
4029	: &TYPE_MIN_VALUE_RAW (TYPE_PACK_EXPANSION_CHECK (NODE)))
4030
4031	/ Any additional template args to be applied when substituting into*
4032	the pattern, set by tsubst_pack_expansion for partial instantiations.
4033	If this is a TREE_LIST, the TREE_VALUE of the first element is the
4034	usual template argument TREE_VEC, and the TREE_PURPOSE of later elements
4035	are enclosing functions that provided function parameter packs we'll need
4036	to map appropriately. /*
4037	#define PACK_EXPANSION_EXTRA_ARGS(NODE) \
4038	*(TREE_CODE (PACK_EXPANSION_CHECK (NODE)) == TYPE_PACK_EXPANSION \
4039	? &TYPE_MAX_VALUE_RAW (NODE) \
4040	: &TREE_OPERAND ((NODE), 2))
4041
4042	/ True iff this pack expansion is within a function context. /
4043	#define PACK_EXPANSION_LOCAL_P(NODE) \
4044	TREE_LANG_FLAG_0 (PACK_EXPANSION_CHECK (NODE))
4045
4046	/ True iff this pack expansion is for sizeof.... /
4047	#define PACK_EXPANSION_SIZEOF_P(NODE) \
4048	TREE_LANG_FLAG_1 (PACK_EXPANSION_CHECK (NODE))
4049
4050	/ True iff this pack expansion is for auto... in lambda init-capture. /
4051	#define PACK_EXPANSION_AUTO_P(NODE) \
4052	TREE_LANG_FLAG_2 (PACK_EXPANSION_CHECK (NODE))
4053
4054	/ True if we must use PACK_EXPANSION_EXTRA_ARGS and avoid partial*
4055	instantiation of this pack expansion. /*
4056	#define PACK_EXPANSION_FORCE_EXTRA_ARGS_P(NODE) \
4057	TREE_LANG_FLAG_3 (PACK_EXPANSION_CHECK (NODE))
4058
4059	/ True iff the wildcard can match a template parameter pack. /
4060	#define WILDCARD_PACK_P(NODE) TREE_LANG_FLAG_0 (NODE)
4061
4062	/ Determine if this is an argument pack. /
4063	#define ARGUMENT_PACK_P(NODE) \
4064	(TREE_CODE (NODE) == TYPE_ARGUMENT_PACK \
4065	\|\| TREE_CODE (NODE) == NONTYPE_ARGUMENT_PACK)
4066
4067	#define ARGUMENT_PACK_CHECK(NODE) \
4068	TREE_CHECK2 (NODE, TYPE_ARGUMENT_PACK, NONTYPE_ARGUMENT_PACK)
4069
4070	/ The arguments stored in an argument pack. Arguments are stored in a*
4071	TREE_VEC, which may have length zero. /*
4072	#define ARGUMENT_PACK_ARGS(NODE) \
4073	(TREE_CODE (ARGUMENT_PACK_CHECK (NODE)) == TYPE_ARGUMENT_PACK \
4074	? TREE_TYPE (NODE) : TREE_OPERAND (NODE, 0))
4075
4076	/ Whether the argument pack is "incomplete", meaning that more*
4077	arguments can still be deduced. Incomplete argument packs are only
4078	used when the user has provided an explicit template argument list
4079	for a variadic function template. Some of the explicit template
4080	arguments will be placed into the beginning of the argument pack,
4081	but additional arguments might still be deduced. /*
4082	#define ARGUMENT_PACK_INCOMPLETE_P(NODE) \
4083	TREE_ADDRESSABLE (ARGUMENT_PACK_ARGS (NODE))
4084
4085	/ When ARGUMENT_PACK_INCOMPLETE_P, stores the explicit template*
4086	arguments used to fill this pack. /*
4087	#define ARGUMENT_PACK_EXPLICIT_ARGS(NODE) \
4088	TREE_TYPE (ARGUMENT_PACK_ARGS (NODE))
4089
4090	/ In an ARGUMENT_PACK_SELECT, the argument pack from which an*
4091	argument will be selected. /*
4092	#define ARGUMENT_PACK_SELECT_FROM_PACK(NODE) \
4093	(((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->argument_pack)
4094
4095	/ In an ARGUMENT_PACK_SELECT, the index of the argument we want to*
4096	select. /*
4097	#define ARGUMENT_PACK_SELECT_INDEX(NODE) \
4098	(((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->index)
4099
4100	#define FOLD_EXPR_CHECK(NODE) \
4101	TREE_CHECK4 (NODE, UNARY_LEFT_FOLD_EXPR, UNARY_RIGHT_FOLD_EXPR, \
4102	BINARY_LEFT_FOLD_EXPR, BINARY_RIGHT_FOLD_EXPR)
4103
4104	#define BINARY_FOLD_EXPR_CHECK(NODE) \
4105	TREE_CHECK2 (NODE, BINARY_LEFT_FOLD_EXPR, BINARY_RIGHT_FOLD_EXPR)
4106
4107	/ True if NODE is UNARY_FOLD_EXPR or a BINARY_FOLD_EXPR /
4108	#define FOLD_EXPR_P(NODE) \
4109	(TREE_CODE (NODE) == UNARY_LEFT_FOLD_EXPR \
4110	\|\| TREE_CODE (NODE) == UNARY_RIGHT_FOLD_EXPR \
4111	\|\| TREE_CODE (NODE) == BINARY_LEFT_FOLD_EXPR \
4112	\|\| TREE_CODE (NODE) == BINARY_RIGHT_FOLD_EXPR)
4113
4114	/ True when NODE is a fold over a compound assignment operator. /
4115	#define FOLD_EXPR_MODIFY_P(NODE) \
4116	TREE_LANG_FLAG_0 (FOLD_EXPR_CHECK (NODE))
4117
4118	/ An INTEGER_CST containing the tree code of the folded operator. /
4119	#define FOLD_EXPR_OP_RAW(NODE) \
4120	TREE_OPERAND (FOLD_EXPR_CHECK (NODE), 0)
4121
4122	/ The tree code of the folded operator. /
4123	#define FOLD_EXPR_OP(NODE) \
4124	((enum tree_code) TREE_INT_CST_LOW (FOLD_EXPR_OP_RAW (NODE)))
4125
4126	/ The expression containing an unexpanded parameter pack. /
4127	#define FOLD_EXPR_PACK(NODE) \
4128	TREE_OPERAND (FOLD_EXPR_CHECK (NODE), 1)
4129
4130	/ In a binary fold expression, the argument with no unexpanded*
4131	parameter packs. /*
4132	#define FOLD_EXPR_INIT(NODE) \
4133	TREE_OPERAND (BINARY_FOLD_EXPR_CHECK (NODE), 2)
4134
4135	/ In a FUNCTION_DECL, the saved auto-return pattern. /
4136	#define DECL_SAVED_AUTO_RETURN_TYPE(NODE) \
4137	(LANG_DECL_FN_CHECK (FUNCTION_DECL_CHECK (NODE)) \
4138	->u.saved_auto_return_type)
4139
4140	/ In a RETURN_EXPR, whether the expression refers to the address*
4141	of a local variable. /*
4142	#define RETURN_EXPR_LOCAL_ADDR_P(NODE) \
4143	TREE_LANG_FLAG_0 (RETURN_EXPR_CHECK (NODE))
4144
4145	/ True if NODE is an implicit INDIRECT_REF from convert_from_reference. /
4146	#define REFERENCE_REF_P(NODE) \
4147	(INDIRECT_REF_P (NODE) \
4148	&& TREE_TYPE (TREE_OPERAND (NODE, 0)) \
4149	&& TYPE_REF_P (TREE_TYPE (TREE_OPERAND ((NODE), 0))))
4150
4151	/ Look through an implicit INDIRECT_REF from convert_from_reference. /
4152	#define STRIP_REFERENCE_REF(NODE) \
4153	(REFERENCE_REF_P (NODE) ? TREE_OPERAND (NODE, 0) : NODE)
4154
4155	/ True iff this represents an lvalue being treated as an rvalue during return*
4156	or throw as per [class.copy.elision]. /*
4157	#define IMPLICIT_RVALUE_P(NODE) \
4158	TREE_LANG_FLAG_3 (TREE_CHECK2 ((NODE), NON_LVALUE_EXPR, STATIC_CAST_EXPR))
4159
4160	#define NEW_EXPR_USE_GLOBAL(NODE) \
4161	TREE_LANG_FLAG_0 (NEW_EXPR_CHECK (NODE))
4162	#define DELETE_EXPR_USE_GLOBAL(NODE) \
4163	TREE_LANG_FLAG_0 (DELETE_EXPR_CHECK (NODE))
4164	#define DELETE_EXPR_USE_VEC(NODE) \
4165	TREE_LANG_FLAG_1 (DELETE_EXPR_CHECK (NODE))
4166
4167	/ True iff this represents returning a potential named return value. /
4168	#define INIT_EXPR_NRV_P(NODE) \
4169	TREE_LANG_FLAG_0 (INIT_EXPR_CHECK (NODE))
4170
4171	#define CALL_OR_AGGR_INIT_CHECK(NODE) \
4172	TREE_CHECK2 ((NODE), CALL_EXPR, AGGR_INIT_EXPR)
4173
4174	/ In a CALL_EXPR appearing in a template, true if Koenig lookup*
4175	should be performed at instantiation time. /*
4176	#define KOENIG_LOOKUP_P(NODE) TREE_LANG_FLAG_0 (CALL_EXPR_CHECK (NODE))
4177
4178	/ True if the arguments to NODE should be evaluated in left-to-right*
4179	order regardless of PUSH_ARGS_REVERSED. /*
4180	#define CALL_EXPR_ORDERED_ARGS(NODE) \
4181	TREE_LANG_FLAG_3 (CALL_OR_AGGR_INIT_CHECK (NODE))
4182
4183	/ True if the arguments to NODE should be evaluated in right-to-left*
4184	order regardless of PUSH_ARGS_REVERSED. /*
4185	#define CALL_EXPR_REVERSE_ARGS(NODE) \
4186	TREE_LANG_FLAG_5 (CALL_OR_AGGR_INIT_CHECK (NODE))
4187
4188	/ True if CALL_EXPR was written as an operator expression, not a function*
4189	call. /*
4190	#define CALL_EXPR_OPERATOR_SYNTAX(NODE) \
4191	TREE_LANG_FLAG_6 (CALL_OR_AGGR_INIT_CHECK (NODE))
4192
4193	/ A TREE_LIST containing the result of phase 1 name lookup of the operator*
4194	overloads that are pertinent to the dependent operator expression whose
4195	type is NODE. Each TREE_PURPOSE is an IDENTIFIER_NODE and TREE_VALUE is
4196	the corresponding (possibly empty) lookup result. The TREE_TYPE of the
4197	first TREE_LIST node points back to NODE. /*
4198	#define DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS(NODE) \
4199	TYPE_VALUES_RAW (DEPENDENT_OPERATOR_TYPE_CHECK (NODE))
4200
4201	/ Guarded helper for the above accessor macro that takes a (templated)*
4202	operator expression instead of the type thereof. /*
4203	inline tree
4204	templated_operator_saved_lookups (tree t)
4205	{
4206	tree type = TREE_TYPE (EXPR_CHECK (t));
4207	if (type && TREE_CODE (type) == DEPENDENT_OPERATOR_TYPE)
4208	return DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS (type);
4209	else
4210	return NULL_TREE;
4211	}
4212
4213	/ Indicates whether a string literal has been parenthesized. Such*
4214	usages are disallowed in certain circumstances. /*
4215
4216	#define PAREN_STRING_LITERAL_P(NODE) \
4217	TREE_LANG_FLAG_0 (STRING_CST_CHECK (NODE))
4218
4219	/ Indicates whether a COMPONENT_REF or a SCOPE_REF has been parenthesized, an*
4220	INDIRECT_REF comes from parenthesizing a _DECL, or a PAREN_EXPR identifies a
4221	parenthesized initializer relevant for decltype(auto). Currently only set
4222	some of the time in C++14 mode. /*
4223
4224	#define REF_PARENTHESIZED_P(NODE) \
4225	TREE_LANG_FLAG_2 (TREE_CHECK5 ((NODE), COMPONENT_REF, INDIRECT_REF, SCOPE_REF, VIEW_CONVERT_EXPR, PAREN_EXPR))
4226
4227	/ Nonzero if this AGGR_INIT_EXPR provides for initialization via a*
4228	constructor call, rather than an ordinary function call. /*
4229	#define AGGR_INIT_VIA_CTOR_P(NODE) \
4230	TREE_LANG_FLAG_0 (AGGR_INIT_EXPR_CHECK (NODE))
4231
4232	/ Nonzero if expanding this AGGR_INIT_EXPR should first zero-initialize*
4233	the object. /*
4234	#define AGGR_INIT_ZERO_FIRST(NODE) \
4235	TREE_LANG_FLAG_2 (AGGR_INIT_EXPR_CHECK (NODE))
4236
4237	/ Nonzero means that the call is the jump from a thunk to the*
4238	thunked-to function. /*
4239	#define AGGR_INIT_FROM_THUNK_P(NODE) \
4240	(AGGR_INIT_EXPR_CHECK (NODE)->base.protected_flag)
4241
4242	/ AGGR_INIT_EXPR accessors. These are equivalent to the CALL_EXPR*
4243	accessors, except for AGGR_INIT_EXPR_SLOT (which takes the place of
4244	CALL_EXPR_STATIC_CHAIN). /*
4245
4246	#define AGGR_INIT_EXPR_FN(NODE) TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 1)
4247	#define AGGR_INIT_EXPR_SLOT(NODE) \
4248	TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 2)
4249	#define AGGR_INIT_EXPR_ARG(NODE, I) \
4250	TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), (I) + 3)
4251	#define aggr_init_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH(NODE) - 3)
4252
4253	/ AGGR_INIT_EXPR_ARGP returns a pointer to the argument vector for NODE.*
4254	We can't use &AGGR_INIT_EXPR_ARG (NODE, 0) because that will complain if
4255	the argument count is zero when checking is enabled. Instead, do
4256	the pointer arithmetic to advance past the 3 fixed operands in a
4257	AGGR_INIT_EXPR. That produces a valid pointer to just past the end of
4258	the operand array, even if it's not valid to dereference it. /*
4259	#define AGGR_INIT_EXPR_ARGP(NODE) \
4260	(&(TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 0)) + 3)
4261
4262	/ Abstract iterators for AGGR_INIT_EXPRs. /
4263
4264	/ Structure containing iterator state. /
4265	struct aggr_init_expr_arg_iterator {
4266	tree t; / the aggr_init_expr /
4267	int n; / argument count /
4268	int i; / next argument index /
4269	};
4270
4271	/ Initialize the abstract argument list iterator object ITER with the*
4272	arguments from AGGR_INIT_EXPR node EXP. /*
4273	inline void
4274	init_aggr_init_expr_arg_iterator (tree exp,
4275	aggr_init_expr_arg_iterator *iter)
4276	{
4277	iter->t = exp;
4278	iter->n = aggr_init_expr_nargs (exp);
4279	iter->i = `0`;
4280	}
4281
4282	/ Return the next argument from abstract argument list iterator object ITER,*
4283	and advance its state. Return NULL_TREE if there are no more arguments. /*
4284	inline tree
4285	next_aggr_init_expr_arg (aggr_init_expr_arg_iterator *iter)
4286	{
4287	tree result;
4288	if (iter->i >= iter->n)
4289	return NULL_TREE;
4290	result = AGGR_INIT_EXPR_ARG (iter->t, iter->i);
4291	iter->i++;
4292	return result;
4293	}
4294
4295	/ Initialize the abstract argument list iterator object ITER, then advance*
4296	past and return the first argument. Useful in for expressions, e.g.
4297	for (arg = first_aggr_init_expr_arg (exp, &iter); arg;
4298	arg = next_aggr_init_expr_arg (&iter)) /*
4299	inline tree
4300	first_aggr_init_expr_arg (tree exp, aggr_init_expr_arg_iterator *iter)
4301	{
4302	init_aggr_init_expr_arg_iterator (exp, iter);
4303	return next_aggr_init_expr_arg (iter);
4304	}
4305
4306	/ Test whether there are more arguments in abstract argument list iterator*
4307	ITER, without changing its state. /*
4308	inline bool
4309	more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter)
4310	{
4311	return (iter->i < iter->n);
4312	}
4313
4314	/ Iterate through each argument ARG of AGGR_INIT_EXPR CALL, using variable*
4315	ITER (of type aggr_init_expr_arg_iterator) to hold the iteration state. /*
4316	#define FOR_EACH_AGGR_INIT_EXPR_ARG(arg, iter, call) \
4317	for ((arg) = first_aggr_init_expr_arg ((call), &(iter)); (arg); \
4318	(arg) = next_aggr_init_expr_arg (&(iter)))
4319
4320	/ We have an expression tree T that represents a call, either CALL_EXPR*
4321	or AGGR_INIT_EXPR. Return a reference to the Nth argument. /*
4322
4323	inline tree&
4324	get_nth_callarg (tree t, int n)
4325	{
4326	switch (TREE_CODE (t))
4327	{
4328	case CALL_EXPR:
4329	return CALL_EXPR_ARG (t, n);
4330
4331	case AGGR_INIT_EXPR:
4332	return AGGR_INIT_EXPR_ARG (t, n);
4333
4334	default:
4335	gcc_unreachable ();
4336	}
4337	}
4338
4339	/ VEC_INIT_EXPR accessors. /
4340	#define VEC_INIT_EXPR_SLOT(NODE) TREE_OPERAND (VEC_INIT_EXPR_CHECK (NODE), 0)
4341	#define VEC_INIT_EXPR_INIT(NODE) TREE_OPERAND (VEC_INIT_EXPR_CHECK (NODE), 1)
4342
4343	/ Indicates that a VEC_INIT_EXPR is a potential constant expression.*
4344	Only set when the current function is constexpr. /*
4345	#define VEC_INIT_EXPR_IS_CONSTEXPR(NODE) \
4346	TREE_LANG_FLAG_0 (VEC_INIT_EXPR_CHECK (NODE))
4347
4348	/ Indicates that a VEC_INIT_EXPR is expressing value-initialization. /
4349	#define VEC_INIT_EXPR_VALUE_INIT(NODE) \
4350	TREE_LANG_FLAG_1 (VEC_INIT_EXPR_CHECK (NODE))
4351
4352	/ If T is a VEC_INIT_EXPR, return it, possibly stripping a TARGET_EXPR*
4353	wrapper. Otherwise, return null. /*
4354	inline tree
4355	get_vec_init_expr (tree t)
4356	{
4357	if (t && TREE_CODE (t) == TARGET_EXPR)
4358	t = TARGET_EXPR_INITIAL (t);
4359	if (t && TREE_CODE (t) == VEC_INIT_EXPR)
4360	return t;
4361	return NULL_TREE;
4362	}
4363
4364	/ The condition under which this MUST_NOT_THROW_EXPR actually blocks*
4365	exceptions. NULL_TREE means 'true'. /*
4366	#define MUST_NOT_THROW_COND(NODE) \
4367	TREE_OPERAND (MUST_NOT_THROW_EXPR_CHECK (NODE), 1)
4368
4369	/ The TYPE_MAIN_DECL for a class template type is a TYPE_DECL, not a*
4370	TEMPLATE_DECL. This macro determines whether or not a given class
4371	type is really a template type, as opposed to an instantiation or
4372	specialization of one. /*
4373	#define CLASSTYPE_IS_TEMPLATE(NODE) \
4374	(CLASSTYPE_TEMPLATE_INFO (NODE) \
4375	&& !CLASSTYPE_USE_TEMPLATE (NODE) \
4376	&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE)))
4377
4378	/ The name used by the user to name the typename type. Typically,*
4379	this is an IDENTIFIER_NODE, and the same as the DECL_NAME on the
4380	corresponding TYPE_DECL. However, this may also be a
4381	TEMPLATE_ID_EXPR if we had something like `typename X::Y<T>'. /*
4382	#define TYPENAME_TYPE_FULLNAME(NODE) \
4383	(TYPE_VALUES_RAW (TYPENAME_TYPE_CHECK (NODE)))
4384
4385	/ True if a TYPENAME_TYPE was declared as an "enum". /
4386	#define TYPENAME_IS_ENUM_P(NODE) \
4387	(TREE_LANG_FLAG_0 (TYPENAME_TYPE_CHECK (NODE)))
4388
4389	/ True if a TYPENAME_TYPE was declared as a "class", "struct", or*
4390	"union". /*
4391	#define TYPENAME_IS_CLASS_P(NODE) \
4392	(TREE_LANG_FLAG_1 (TYPENAME_TYPE_CHECK (NODE)))
4393
4394	/ True if a TYPENAME_TYPE is in the process of being resolved. /
4395	#define TYPENAME_IS_RESOLVING_P(NODE) \
4396	(TREE_LANG_FLAG_2 (TYPENAME_TYPE_CHECK (NODE)))
4397
4398	/ [class.virtual]*
4399
4400	A class that declares or inherits a virtual function is called a
4401	polymorphic class. /*
4402	#define TYPE_POLYMORPHIC_P(NODE) (TREE_LANG_FLAG_2 (NODE))
4403
4404	/ Nonzero if this class has a virtual function table pointer. /
4405	#define TYPE_CONTAINS_VPTR_P(NODE) \
4406	(TYPE_POLYMORPHIC_P (NODE) \|\| CLASSTYPE_VBASECLASSES (NODE))
4407
4408	/ Nonzero if NODE is a FUNCTION_DECL or VARIABLE_DECL (for a decl*
4409	with namespace scope) declared in a local scope. /*
4410	#define DECL_LOCAL_DECL_P(NODE) \
4411	DECL_LANG_FLAG_0 (VAR_OR_FUNCTION_DECL_CHECK (NODE))
4412
4413	/ The namespace-scope decl a DECL_LOCAL_DECL_P aliases. /
4414	#define DECL_LOCAL_DECL_ALIAS(NODE) \
4415	DECL_ACCESS ((gcc_checking_assert (DECL_LOCAL_DECL_P (NODE)), NODE))
4416
4417	/ True if NODE was declared with auto in its return type, but it has*
4418	started compilation and so the return type might have been changed by
4419	return type deduction; its declared return type should be found in
4420	DECL_SAVED_AUTO_RETURN_TYPE (NODE). /*
4421	#define FNDECL_USED_AUTO(NODE) \
4422	TREE_LANG_FLAG_2 (FUNCTION_DECL_CHECK (NODE))
4423
4424	/ True if NODE is needed for a manifestly constant-evaluated expression.*
4425	This doesn't especially need to be a flag, since currently it's only
4426	used for error recovery; if we run out of function flags it could move
4427	to an attribute. /*
4428	#define FNDECL_MANIFESTLY_CONST_EVALUATED(NODE) \
4429	TREE_LANG_FLAG_4 (FUNCTION_DECL_CHECK (NODE))
4430
4431	/ True for artificial decls added for OpenMP privatized non-static*
4432	data members. /*
4433	#define DECL_OMP_PRIVATIZED_MEMBER(NODE) \
4434	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.anticipated_p)
4435
4436	/ Nonzero if NODE is an artificial FUNCTION_DECL for*
4437	#pragma omp declare reduction. /*
4438	#define DECL_OMP_DECLARE_REDUCTION_P(NODE) \
4439	(LANG_DECL_FN_CHECK (DECL_COMMON_CHECK (NODE))->omp_declare_reduction_p)
4440
4441	/ Nonzero if DECL has been declared threadprivate by*
4442	#pragma omp threadprivate. /*
4443	#define CP_DECL_THREADPRIVATE_P(DECL) \
4444	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (DECL))->u.base.threadprivate_or_deleted_p)
4445
4446	/ Nonzero if NODE is a VAR_DECL which has been declared inline. /
4447	#define DECL_VAR_DECLARED_INLINE_P(NODE) \
4448	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE)) \
4449	? DECL_LANG_SPECIFIC (NODE)->u.base.var_declared_inline_p \
4450	: false)
4451	#define SET_DECL_VAR_DECLARED_INLINE_P(NODE) \
4452	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.var_declared_inline_p \
4453	= true)
4454
4455	/ True if NODE is a constant variable with a value-dependent initializer. /
4456	#define DECL_DEPENDENT_INIT_P(NODE) \
4457	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE)) \
4458	&& DECL_LANG_SPECIFIC (NODE)->u.base.dependent_init_p)
4459	#define SET_DECL_DEPENDENT_INIT_P(NODE, X) \
4460	(DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.dependent_init_p = (X))
4461
4462	/ Nonzero if NODE is an artificial VAR_DECL for a C++17 structured binding*
4463	declaration or one of VAR_DECLs for the user identifiers in it. /*
4464	#define DECL_DECOMPOSITION_P(NODE) \
4465	(VAR_P (NODE) && DECL_LANG_SPECIFIC (NODE) \
4466	? DECL_LANG_SPECIFIC (NODE)->u.base.selector == lds_decomp \
4467	: false)
4468
4469	/ The underlying artificial VAR_DECL for structured binding. /
4470	#define DECL_DECOMP_BASE(NODE) \
4471	(LANG_DECL_DECOMP_CHECK (NODE)->base)
4472
4473	/ Nonzero if NODE is an inline VAR_DECL. In C++17, static data members*
4474	declared with constexpr specifier are implicitly inline variables. /*
4475	#define DECL_INLINE_VAR_P(NODE) \
4476	(DECL_VAR_DECLARED_INLINE_P (NODE) \
4477	\|\| (cxx_dialect >= cxx17 \
4478	&& DECL_DECLARED_CONSTEXPR_P (NODE) \
4479	&& DECL_CLASS_SCOPE_P (NODE)))
4480
4481	/ Nonzero if DECL was declared with '= delete'. /
4482	#define DECL_DELETED_FN(DECL) \
4483	(LANG_DECL_FN_CHECK (DECL)->min.base.threadprivate_or_deleted_p)
4484
4485	/ Nonzero if DECL was declared with '= default' (maybe implicitly). /
4486	#define DECL_DEFAULTED_FN(DECL) \
4487	(LANG_DECL_FN_CHECK (DECL)->defaulted_p)
4488
4489	/ Nonzero if DECL is explicitly defaulted in the class body. /
4490	#define DECL_DEFAULTED_IN_CLASS_P(DECL) \
4491	(DECL_DEFAULTED_FN (DECL) && DECL_INITIALIZED_IN_CLASS_P (DECL))
4492	/ Nonzero if DECL was defaulted outside the class body. /
4493	#define DECL_DEFAULTED_OUTSIDE_CLASS_P(DECL) \
4494	(DECL_DEFAULTED_FN (DECL) \
4495	&& !(DECL_ARTIFICIAL (DECL) \|\| DECL_INITIALIZED_IN_CLASS_P (DECL)))
4496
4497	/ Record whether a typedef for type `int' was actually `signed int'. /
4498	#define C_TYPEDEF_EXPLICITLY_SIGNED(EXP) DECL_LANG_FLAG_1 (EXP)
4499
4500	/ Returns nonzero if DECL has external linkage, as specified by the*
4501	language standard. (This predicate may hold even when the
4502	corresponding entity is not actually given external linkage in the
4503	object file; see decl_linkage for details.) /*
4504	#define DECL_EXTERNAL_LINKAGE_P(DECL) \
4505	(decl_linkage (DECL) == lk_external)
4506
4507	/ Keep these codes in ascending code order. /
4508
4509	#define INTEGRAL_CODE_P(CODE) \
4510	((CODE) == ENUMERAL_TYPE \
4511	\|\| (CODE) == BOOLEAN_TYPE \
4512	\|\| (CODE) == INTEGER_TYPE)
4513
4514	/ [basic.fundamental]*
4515
4516	Types bool, char, wchar_t, and the signed and unsigned integer types
4517	are collectively called integral types.
4518
4519	Note that INTEGRAL_TYPE_P, as defined in tree.h, allows enumeration
4520	types as well, which is incorrect in C++. Keep these checks in
4521	ascending code order. /*
4522	#define CP_INTEGRAL_TYPE_P(TYPE) \
4523	(TREE_CODE (TYPE) == BOOLEAN_TYPE \
4524	\|\| TREE_CODE (TYPE) == INTEGER_TYPE)
4525
4526	/ Returns true if TYPE is an integral or enumeration name. Keep*
4527	these checks in ascending code order. /*
4528	#define INTEGRAL_OR_ENUMERATION_TYPE_P(TYPE) \
4529	(TREE_CODE (TYPE) == ENUMERAL_TYPE \|\| CP_INTEGRAL_TYPE_P (TYPE))
4530
4531	/ Returns true if TYPE is an integral or unscoped enumeration type. /
4532	#define INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P(TYPE) \
4533	(UNSCOPED_ENUM_P (TYPE) \|\| CP_INTEGRAL_TYPE_P (TYPE))
4534
4535	/ True if the class type TYPE is a literal type. /
4536	#define CLASSTYPE_LITERAL_P(TYPE) \
4537	(LANG_TYPE_CLASS_CHECK (TYPE)->is_literal)
4538
4539	/ [basic.fundamental]*
4540
4541	Integral and floating types are collectively called arithmetic
4542	types.
4543
4544	As a GNU extension, we also accept complex types.
4545
4546	Keep these checks in ascending code order. /*
4547	#define ARITHMETIC_TYPE_P(TYPE) \
4548	(CP_INTEGRAL_TYPE_P (TYPE) \
4549	\|\| SCALAR_FLOAT_TYPE_P (TYPE) \
4550	\|\| TREE_CODE (TYPE) == COMPLEX_TYPE)
4551
4552	/ [basic.types]*
4553
4554	Arithmetic types, enumeration types, pointer types,
4555	pointer-to-member types, and std::nullptr_t are collectively called
4556	scalar types.
4557
4558	Keep these checks in ascending code order. /*
4559	#define SCALAR_TYPE_P(TYPE) \
4560	(TYPE_PTRDATAMEM_P (TYPE) \
4561	\|\| TREE_CODE (TYPE) == ENUMERAL_TYPE \
4562	\|\| ARITHMETIC_TYPE_P (TYPE) \
4563	\|\| TYPE_PTR_P (TYPE) \
4564	\|\| TYPE_PTRMEMFUNC_P (TYPE) \
4565	\|\| NULLPTR_TYPE_P (TYPE))
4566
4567	/ Determines whether this type is a C++0x scoped enumeration*
4568	type. Scoped enumerations types are introduced via "enum class" or
4569	"enum struct", e.g.,
4570
4571	enum class Color {
4572	Red, Green, Blue
4573	};
4574
4575	Scoped enumeration types are different from normal (unscoped)
4576	enumeration types in several ways:
4577
4578	- The enumerators of a scoped enumeration type are only available
4579	within the scope of the enumeration type and not in the
4580	enclosing scope. For example, the Red color can be referred to
4581	with "Color::Red" but not "Red".
4582
4583	- Scoped enumerators and enumerations do not implicitly convert
4584	to integers or 'bool'.
4585
4586	- The underlying type of the enum is well-defined. /*
4587	#define SCOPED_ENUM_P(TYPE) \
4588	(TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_SCOPED (TYPE))
4589
4590	/ Determine whether this is an unscoped enumeration type. /
4591	#define UNSCOPED_ENUM_P(TYPE) \
4592	(TREE_CODE (TYPE) == ENUMERAL_TYPE && !ENUM_IS_SCOPED (TYPE))
4593
4594	/ Set the flag indicating whether an ENUMERAL_TYPE is a C++0x scoped*
4595	enumeration type (1) or a normal (unscoped) enumeration type
4596	(0). /*
4597	#define SET_SCOPED_ENUM_P(TYPE, VAL) \
4598	(ENUM_IS_SCOPED (TYPE) = (VAL))
4599
4600	#define SET_OPAQUE_ENUM_P(TYPE, VAL) \
4601	(ENUM_IS_OPAQUE (TYPE) = (VAL))
4602
4603	#define OPAQUE_ENUM_P(TYPE) \
4604	(TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_OPAQUE (TYPE))
4605
4606	/ [dcl.init.aggr]*
4607
4608	An aggregate is an array or a class with no user-provided
4609	constructors, no brace-or-equal-initializers for non-static data
4610	members, no private or protected non-static data members, no
4611	base classes, and no virtual functions.
4612
4613	As an extension, we also treat vectors as aggregates. Keep these
4614	checks in ascending code order. /*
4615	#define CP_AGGREGATE_TYPE_P(TYPE) \
4616	(gnu_vector_type_p (TYPE) \
4617	\|\| TREE_CODE (TYPE) == ARRAY_TYPE \
4618	\|\| (CLASS_TYPE_P (TYPE) && COMPLETE_TYPE_P (TYPE) && !CLASSTYPE_NON_AGGREGATE (TYPE)))
4619
4620	/ Nonzero for a class type means that the class type has a*
4621	user-declared constructor. /*
4622	#define TYPE_HAS_USER_CONSTRUCTOR(NODE) (TYPE_LANG_FLAG_1 (NODE))
4623
4624	/ Nonzero means that the FUNCTION_TYPE or METHOD_TYPE has a*
4625	late-specified return type. /*
4626	#define TYPE_HAS_LATE_RETURN_TYPE(NODE) \
4627	(TYPE_LANG_FLAG_2 (FUNC_OR_METHOD_CHECK (NODE)))
4628
4629	/ When appearing in an INDIRECT_REF, it means that the tree structure*
4630	underneath is actually a call to a constructor. This is needed
4631	when the constructor must initialize local storage (which can
4632	be automatically destroyed), rather than allowing it to allocate
4633	space from the heap.
4634
4635	When appearing in a SAVE_EXPR, it means that underneath
4636	is a call to a constructor.
4637
4638	When appearing in a CONSTRUCTOR, the expression is an unconverted
4639	compound literal.
4640
4641	When appearing in a CALL_EXPR, it means that it is a call to
4642	a constructor.
4643
4644	When appearing in a FIELD_DECL, it means that this field
4645	has been duly initialized in its constructor. /*
4646	#define TREE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_4 (NODE))
4647
4648	/ True if NODE is a brace-enclosed initializer. /
4649	#define BRACE_ENCLOSED_INITIALIZER_P(NODE) \
4650	(TREE_CODE (NODE) == CONSTRUCTOR && TREE_TYPE (NODE) == init_list_type_node)
4651
4652	/ True if NODE is a compound-literal, i.e., a brace-enclosed*
4653	initializer cast to a particular type. This is mostly only set during
4654	template parsing; once the initializer has been digested into an actual
4655	value of the type, the expression is represented by a TARGET_EXPR. /*
4656	#define COMPOUND_LITERAL_P(NODE) \
4657	(TREE_CODE (NODE) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (NODE))
4658
4659	#define EMPTY_CONSTRUCTOR_P(NODE) (TREE_CODE (NODE) == CONSTRUCTOR \
4660	&& vec_safe_is_empty(CONSTRUCTOR_ELTS(NODE))\
4661	&& !TREE_HAS_CONSTRUCTOR (NODE))
4662
4663	/ True if NODE is a init-list used as a direct-initializer, i.e.*
4664	B b{1,2}, not B b({1,2}) or B b = {1,2}. /*
4665	#define CONSTRUCTOR_IS_DIRECT_INIT(NODE) (TREE_LANG_FLAG_0 (CONSTRUCTOR_CHECK (NODE)))
4666
4667	/ True if this CONSTRUCTOR is instantiation-dependent and needs to be*
4668	substituted. /*
4669	#define CONSTRUCTOR_IS_DEPENDENT(NODE) \
4670	(TREE_LANG_FLAG_1 (CONSTRUCTOR_CHECK (NODE)))
4671
4672	/ True if this CONSTRUCTOR should not be used as a variable initializer*
4673	because it was loaded from a constexpr variable with mutable fields. /*
4674	#define CONSTRUCTOR_MUTABLE_POISON(NODE) \
4675	(TREE_LANG_FLAG_2 (CONSTRUCTOR_CHECK (NODE)))
4676
4677	/ True if this typed CONSTRUCTOR represents C99 compound-literal syntax rather*
4678	than C++11 functional cast syntax. /*
4679	#define CONSTRUCTOR_C99_COMPOUND_LITERAL(NODE) \
4680	(TREE_LANG_FLAG_3 (CONSTRUCTOR_CHECK (NODE)))
4681
4682	/ True if this CONSTRUCTOR contains PLACEHOLDER_EXPRs referencing the*
4683	CONSTRUCTOR's type not nested inside another CONSTRUCTOR marked with
4684	CONSTRUCTOR_PLACEHOLDER_BOUNDARY. /*
4685	#define CONSTRUCTOR_PLACEHOLDER_BOUNDARY(NODE) \
4686	(TREE_LANG_FLAG_5 (CONSTRUCTOR_CHECK (NODE)))
4687
4688	#define DIRECT_LIST_INIT_P(NODE) \
4689	(BRACE_ENCLOSED_INITIALIZER_P (NODE) && CONSTRUCTOR_IS_DIRECT_INIT (NODE))
4690
4691	/ True if this is a designated initializer (when we allow initializer-clauses*
4692	mixed with designated-initializer-clauses set whenever there is at least
4693	one designated-initializer-clause), or a C99 designator. /*
4694	#define CONSTRUCTOR_IS_DESIGNATED_INIT(NODE) \
4695	(TREE_LANG_FLAG_6 (CONSTRUCTOR_CHECK (NODE)))
4696
4697	/ True if this CONSTRUCTOR comes from a parenthesized list of values, e.g.*
4698	A(1, 2, 3). /*
4699	#define CONSTRUCTOR_IS_PAREN_INIT(NODE) \
4700	(CONSTRUCTOR_CHECK(NODE)->base.private_flag)
4701
4702	/ True if reshape_init built this sub-CONSTRUCTOR to undo the brace elision*
4703	of the original CONSTRUCTOR. This flag is used during C++20 aggregate
4704	CTAD. /*
4705	#define CONSTRUCTOR_BRACES_ELIDED_P(NODE) \
4706	(CONSTRUCTOR_CHECK (NODE)->base.protected_flag)
4707
4708	/ True if NODE represents a conversion for direct-initialization in a*
4709	template. Set by perform_implicit_conversion_flags. /*
4710	#define IMPLICIT_CONV_EXPR_DIRECT_INIT(NODE) \
4711	(TREE_LANG_FLAG_0 (IMPLICIT_CONV_EXPR_CHECK (NODE)))
4712
4713	/ True if NODE represents a dependent conversion of a non-type template*
4714	argument. Set by maybe_convert_nontype_argument. /*
4715	#define IMPLICIT_CONV_EXPR_NONTYPE_ARG(NODE) \
4716	(TREE_LANG_FLAG_1 (IMPLICIT_CONV_EXPR_CHECK (NODE)))
4717
4718	/ True if NODE represents a conversion for braced-init-list in a*
4719	template. Set by perform_implicit_conversion_flags. /*
4720	#define IMPLICIT_CONV_EXPR_BRACED_INIT(NODE) \
4721	(TREE_LANG_FLAG_2 (IMPLICIT_CONV_EXPR_CHECK (NODE)))
4722
4723	/ True if NODE represents a conversion forced to be represented in*
4724	maybe_convert_nontype_argument, i.e. for an alias template. /*
4725	#define IMPLICIT_CONV_EXPR_FORCED(NODE) \
4726	(TREE_LANG_FLAG_3 (IMPLICIT_CONV_EXPR_CHECK (NODE)))
4727
4728	/ Nonzero means that an object of this type cannot be initialized using*
4729	an initializer list. /*
4730	#define CLASSTYPE_NON_AGGREGATE(NODE) \
4731	(LANG_TYPE_CLASS_CHECK (NODE)->non_aggregate)
4732	#define TYPE_NON_AGGREGATE_CLASS(NODE) \
4733	(CLASS_TYPE_P (NODE) && CLASSTYPE_NON_AGGREGATE (NODE))
4734
4735	/ Nonzero if there is a non-trivial X::op=(cv X&) for this class. /
4736	#define TYPE_HAS_COMPLEX_COPY_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_copy_assign)
4737
4738	/ Nonzero if there is a non-trivial X::X(cv X&) for this class. /
4739	#define TYPE_HAS_COMPLEX_COPY_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_copy_ctor)
4740
4741	/ Nonzero if there is a non-trivial X::op=(X&&) for this class. /
4742	#define TYPE_HAS_COMPLEX_MOVE_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_move_assign)
4743
4744	/ Nonzero if there is a non-trivial X::X(X&&) for this class. /
4745	#define TYPE_HAS_COMPLEX_MOVE_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_move_ctor)
4746
4747	/ Nonzero if there is no trivial default constructor for this class. /
4748	#define TYPE_HAS_COMPLEX_DFLT(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_dflt)
4749
4750	/ Nonzero if TYPE has a trivial destructor. From [class.dtor]:*
4751
4752	A destructor is trivial if it is an implicitly declared
4753	destructor and if:
4754
4755	- all of the direct base classes of its class have trivial
4756	destructors,
4757
4758	- for all of the non-static data members of its class that are
4759	of class type (or array thereof), each such class has a
4760	trivial destructor. /*
4761	#define TYPE_HAS_TRIVIAL_DESTRUCTOR(NODE) \
4762	(!TYPE_HAS_NONTRIVIAL_DESTRUCTOR (NODE))
4763
4764	/ Nonzero for _TYPE node means that this type does not have a trivial*
4765	destructor. Therefore, destroying an object of this type will
4766	involve a call to a destructor. This can apply to objects of
4767	ARRAY_TYPE if the type of the elements needs a destructor. /*
4768	#define TYPE_HAS_NONTRIVIAL_DESTRUCTOR(NODE) \
4769	(TYPE_LANG_FLAG_4 (NODE))
4770
4771	/ Nonzero for class type means that the default constructor is trivial. /
4772	#define TYPE_HAS_TRIVIAL_DFLT(NODE) \
4773	(TYPE_HAS_DEFAULT_CONSTRUCTOR (NODE) && ! TYPE_HAS_COMPLEX_DFLT (NODE))
4774
4775	/ Nonzero for class type means that copy initialization of this type can use*
4776	a bitwise copy. /*
4777	#define TYPE_HAS_TRIVIAL_COPY_CTOR(NODE) \
4778	(TYPE_HAS_COPY_CTOR (NODE) && ! TYPE_HAS_COMPLEX_COPY_CTOR (NODE))
4779
4780	/ Nonzero for class type means that assignment of this type can use*
4781	a bitwise copy. /*
4782	#define TYPE_HAS_TRIVIAL_COPY_ASSIGN(NODE) \
4783	(TYPE_HAS_COPY_ASSIGN (NODE) && ! TYPE_HAS_COMPLEX_COPY_ASSIGN (NODE))
4784
4785	/ Returns true if NODE is a pointer-to-data-member. /
4786	#define TYPE_PTRDATAMEM_P(NODE) \
4787	(TREE_CODE (NODE) == OFFSET_TYPE)
4788
4789	/ Returns true if NODE is a pointer. /
4790	#define TYPE_PTR_P(NODE) \
4791	(TREE_CODE (NODE) == POINTER_TYPE)
4792
4793	/ Returns true if NODE is a reference. /
4794	#define TYPE_REF_P(NODE) \
4795	(TREE_CODE (NODE) == REFERENCE_TYPE)
4796
4797	/ Returns true if NODE is a pointer or a reference. /
4798	#define INDIRECT_TYPE_P(NODE) \
4799	(TYPE_PTR_P (NODE) \|\| TYPE_REF_P (NODE))
4800
4801	/ Returns true if NODE is an object type:*
4802
4803	[basic.types]
4804
4805	An object type is a (possibly cv-qualified) type that is not a
4806	function type, not a reference type, and not a void type.
4807
4808	Keep these checks in ascending order, for speed. /*
4809	#define TYPE_OBJ_P(NODE) \
4810	(!TYPE_REF_P (NODE) \
4811	&& !VOID_TYPE_P (NODE) \
4812	&& !FUNC_OR_METHOD_TYPE_P (NODE))
4813
4814	/ Returns true if NODE is a pointer to an object. Keep these checks*
4815	in ascending tree code order. /*
4816	#define TYPE_PTROB_P(NODE) \
4817	(TYPE_PTR_P (NODE) && TYPE_OBJ_P (TREE_TYPE (NODE)))
4818
4819	/ Returns true if NODE is a reference to an object. Keep these checks*
4820	in ascending tree code order. /*
4821	#define TYPE_REF_OBJ_P(NODE) \
4822	(TYPE_REF_P (NODE) && TYPE_OBJ_P (TREE_TYPE (NODE)))
4823
4824	/ Returns true if NODE is a pointer to an object, or a pointer to*
4825	void. Keep these checks in ascending tree code order. /*
4826	#define TYPE_PTROBV_P(NODE) \
4827	(TYPE_PTR_P (NODE) \
4828	&& !FUNC_OR_METHOD_TYPE_P (TREE_TYPE (NODE)))
4829
4830	/ Returns true if NODE is a pointer to function type. /
4831	#define TYPE_PTRFN_P(NODE) \
4832	(TYPE_PTR_P (NODE) \
4833	&& TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE)
4834
4835	/ Returns true if NODE is a reference to function type. /
4836	#define TYPE_REFFN_P(NODE) \
4837	(TYPE_REF_P (NODE) \
4838	&& TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE)
4839
4840	/ Returns true if NODE is a pointer to member function type. /
4841	#define TYPE_PTRMEMFUNC_P(NODE) \
4842	(TREE_CODE (NODE) == RECORD_TYPE \
4843	&& TYPE_PTRMEMFUNC_FLAG (NODE))
4844
4845	#define TYPE_PTRMEMFUNC_FLAG(NODE) \
4846	(TYPE_LANG_FLAG_2 (RECORD_TYPE_CHECK (NODE)))
4847
4848	/ Returns true if NODE is a pointer-to-member. /
4849	#define TYPE_PTRMEM_P(NODE) \
4850	(TYPE_PTRDATAMEM_P (NODE) \|\| TYPE_PTRMEMFUNC_P (NODE))
4851
4852	/ Returns true if NODE is a pointer or a pointer-to-member. /
4853	#define TYPE_PTR_OR_PTRMEM_P(NODE) \
4854	(TYPE_PTR_P (NODE) \|\| TYPE_PTRMEM_P (NODE))
4855
4856	/ Indicates when overload resolution may resolve to a pointer to*
4857	member function. [expr.unary.op]/3 /*
4858	#define PTRMEM_OK_P(NODE) \
4859	TREE_LANG_FLAG_0 (TREE_CHECK3 ((NODE), ADDR_EXPR, OFFSET_REF, SCOPE_REF))
4860
4861	/ True if this ADDR_EXPR denotes a function call; that is, it's*
4862	fn() rather than &fn. /*
4863	#define ADDR_EXPR_DENOTES_CALL_P(NODE) \
4864	(ADDR_EXPR_CHECK(NODE)->base.protected_flag)
4865
4866	/ Get the POINTER_TYPE to the METHOD_TYPE associated with this*
4867	pointer to member function. TYPE_PTRMEMFUNC_P _must_ be true,
4868	before using this macro. /*
4869	#define TYPE_PTRMEMFUNC_FN_TYPE(NODE) \
4870	(cp_build_qualified_type (TREE_TYPE (TYPE_FIELDS (NODE)),\
4871	cp_type_quals (NODE)))
4872
4873	/ As above, but can be used in places that want an lvalue at the expense*
4874	of not necessarily having the correct cv-qualifiers. /*
4875	#define TYPE_PTRMEMFUNC_FN_TYPE_RAW(NODE) \
4876	(TREE_TYPE (TYPE_FIELDS (NODE)))
4877
4878	/ Returns `A' for a type like `int (A::)(double)' /*
4879	#define TYPE_PTRMEMFUNC_OBJECT_TYPE(NODE) \
4880	TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE)))
4881
4882	/ The canonical internal RECORD_TYPE from the POINTER_TYPE to*
4883	METHOD_TYPE. /*
4884	#define TYPE_PTRMEMFUNC_TYPE(NODE) \
4885	TYPE_LANG_SLOT_1 (NODE)
4886
4887	/ For a pointer-to-member type of the form `T X::', this is `X'.
4888	For a type like `void (X::)() const', this type is `X', not `const*
4889	X'. To get at the `const X' you have to look at the
4890	TYPE_PTRMEM_POINTED_TO_TYPE; there, the first parameter will have
4891	type `const X'. /
4892	#define TYPE_PTRMEM_CLASS_TYPE(NODE) \
4893	(TYPE_PTRDATAMEM_P (NODE) \
4894	? TYPE_OFFSET_BASETYPE (NODE) \
4895	: TYPE_PTRMEMFUNC_OBJECT_TYPE (NODE))
4896
4897	/ For a pointer-to-member type of the form `T X::', this is `T'. /*
4898	#define TYPE_PTRMEM_POINTED_TO_TYPE(NODE) \
4899	(TYPE_PTRDATAMEM_P (NODE) \
4900	? TREE_TYPE (NODE) \
4901	: TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE)))
4902
4903	/ For a pointer-to-member constant `X::Y' this is the RECORD_TYPE for*
4904	`X'. /*
4905	#define PTRMEM_CST_CLASS(NODE) \
4906	TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (PTRMEM_CST_CHECK (NODE)))
4907
4908	/ For a pointer-to-member constant `X::Y' this is the _DECL for*
4909	`Y'. /*
4910	#define PTRMEM_CST_MEMBER(NODE) \
4911	(((ptrmem_cst_t)PTRMEM_CST_CHECK (NODE))->member)
4912
4913	/ For a pointer-to-member constant `X::Y' this is a location where*
4914	the address of the member has been taken. /*
4915	#define PTRMEM_CST_LOCATION(NODE) \
4916	(((ptrmem_cst_t)PTRMEM_CST_CHECK (NODE))->locus)
4917
4918	/ The expression in question for a TYPEOF_TYPE. /
4919	#define TYPEOF_TYPE_EXPR(NODE) (TYPE_VALUES_RAW (TYPEOF_TYPE_CHECK (NODE)))
4920
4921	/ The type in question for an UNDERLYING_TYPE. /
4922	#define UNDERLYING_TYPE_TYPE(NODE) \
4923	(TYPE_VALUES_RAW (UNDERLYING_TYPE_CHECK (NODE)))
4924
4925	/ The type in question for BASES. /
4926	#define BASES_TYPE(NODE) \
4927	(TYPE_VALUES_RAW (BASES_CHECK (NODE)))
4928
4929	#define BASES_DIRECT(NODE) \
4930	TREE_LANG_FLAG_0 (BASES_CHECK (NODE))
4931
4932	/ The expression in question for a DECLTYPE_TYPE. /
4933	#define DECLTYPE_TYPE_EXPR(NODE) (TYPE_VALUES_RAW (DECLTYPE_TYPE_CHECK (NODE)))
4934
4935	/ Whether the DECLTYPE_TYPE_EXPR of NODE was originally parsed as an*
4936	id-expression or a member-access expression. When false, it was
4937	parsed as a full expression. /*
4938	#define DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P(NODE) \
4939	(DECLTYPE_TYPE_CHECK (NODE))->type_common.string_flag
4940
4941	/ These flags indicate that we want different semantics from normal*
4942	decltype: lambda capture just drops references,
4943	lambda proxies look through implicit dereference. /*
4944	#define DECLTYPE_FOR_LAMBDA_CAPTURE(NODE) \
4945	TREE_LANG_FLAG_0 (DECLTYPE_TYPE_CHECK (NODE))
4946	#define DECLTYPE_FOR_LAMBDA_PROXY(NODE) \
4947	TREE_LANG_FLAG_2 (DECLTYPE_TYPE_CHECK (NODE))
4948	#define DECLTYPE_FOR_REF_CAPTURE(NODE) \
4949	TREE_LANG_FLAG_3 (DECLTYPE_TYPE_CHECK (NODE))
4950
4951	/ Nonzero for VAR_DECL and FUNCTION_DECL node means that `extern' was*
4952	specified in its declaration. This can also be set for an
4953	erroneously declared PARM_DECL. /*
4954	#define DECL_THIS_EXTERN(NODE) \
4955	DECL_LANG_FLAG_2 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE))
4956
4957	/ Nonzero for VAR_DECL and FUNCTION_DECL node means that `static' was*
4958	specified in its declaration. This can also be set for an
4959	erroneously declared PARM_DECL. /*
4960	#define DECL_THIS_STATIC(NODE) \
4961	DECL_LANG_FLAG_6 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE))
4962
4963	/ Nonzero for FIELD_DECL node means that this field is a lambda capture*
4964	field for an array of runtime bound. /*
4965	#define DECL_VLA_CAPTURE_P(NODE) \
4966	DECL_LANG_FLAG_1 (FIELD_DECL_CHECK (NODE))
4967
4968	/ Nonzero for PARM_DECL node means that this is an array function*
4969	parameter, i.e, a[] rather than a. /
4970	#define DECL_ARRAY_PARAMETER_P(NODE) \
4971	DECL_LANG_FLAG_1 (PARM_DECL_CHECK (NODE))
4972
4973	/ Nonzero for a FIELD_DECL who's NSMDI is currently being*
4974	instantiated. /*
4975	#define DECL_INSTANTIATING_NSDMI_P(NODE) \
4976	DECL_LANG_FLAG_2 (FIELD_DECL_CHECK (NODE))
4977
4978	/ Nonzero for FIELD_DECL node means that this field is a base class*
4979	of the parent object, as opposed to a member field. /*
4980	#define DECL_FIELD_IS_BASE(NODE) \
4981	DECL_LANG_FLAG_6 (FIELD_DECL_CHECK (NODE))
4982
4983	/ Nonzero for FIELD_DECL node means that this field is a simple (no*
4984	explicit initializer) lambda capture field, making it invisible to
4985	name lookup in unevaluated contexts. /*
4986	#define DECL_NORMAL_CAPTURE_P(NODE) \
4987	DECL_LANG_FLAG_7 (FIELD_DECL_CHECK (NODE))
4988
4989	/ Nonzero if TYPE is an anonymous union or struct type. We have to use a*
4990	flag for this because "A union for which objects or pointers are
4991	declared is not an anonymous union" [class.union]. /*
4992	#define ANON_AGGR_TYPE_P(NODE) \
4993	(CLASS_TYPE_P (NODE) && LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr)
4994	#define SET_ANON_AGGR_TYPE_P(NODE) \
4995	(LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr = 1)
4996
4997	/ Nonzero if TYPE is an anonymous union type. /
4998	#define ANON_UNION_TYPE_P(NODE) \
4999	(TREE_CODE (NODE) == UNION_TYPE && ANON_AGGR_TYPE_P (NODE))
5000
5001	/ For an ANON_AGGR_TYPE_P the single FIELD_DECL it is used with. /
5002	#define ANON_AGGR_TYPE_FIELD(NODE) \
5003	(LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var)
5004
5005	/ Define fields and accessors for nodes representing declared names. /
5006
5007	/ True if TYPE is an unnamed structured type with a typedef for*
5008	linkage purposes. In that case TYPE_NAME and TYPE_STUB_DECL of the
5009	MAIN-VARIANT are different. /*
5010	#define TYPE_WAS_UNNAMED(NODE) \
5011	(TYPE_NAME (TYPE_MAIN_VARIANT (NODE)) \
5012	!= TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE)))
5013
5014	/ C++: all of these are overloaded! These apply only to TYPE_DECLs. /
5015
5016	/ The format of each node in the DECL_FRIENDLIST is as follows:*
5017
5018	The TREE_PURPOSE will be the name of a function, i.e., an
5019	IDENTIFIER_NODE. The TREE_VALUE will be itself a TREE_LIST, whose
5020	TREE_VALUEs are friends with the given name. /*
5021	#define DECL_FRIENDLIST(NODE) (DECL_INITIAL (NODE))
5022	#define FRIEND_NAME(LIST) (TREE_PURPOSE (LIST))
5023	#define FRIEND_DECLS(LIST) (TREE_VALUE (LIST))
5024
5025	/ The DECL_ACCESS, if non-NULL, is a TREE_LIST. The TREE_PURPOSE of*
5026	each node is a type; the TREE_VALUE is the access granted for this
5027	DECL in that type. The DECL_ACCESS is set by access declarations.
5028	For example, if a member that would normally be public in a
5029	derived class is made protected, then the derived class and the
5030	protected_access_node will appear in the DECL_ACCESS for the node. /*
5031	#define DECL_ACCESS(NODE) (LANG_DECL_MIN_CHECK (NODE)->access)
5032
5033	/ Nonzero if the FUNCTION_DECL is a global constructor. /
5034	#define DECL_GLOBAL_CTOR_P(NODE) \
5035	(LANG_DECL_FN_CHECK (NODE)->global_ctor_p)
5036
5037	/ Nonzero if the FUNCTION_DECL is a global destructor. /
5038	#define DECL_GLOBAL_DTOR_P(NODE) \
5039	(LANG_DECL_FN_CHECK (NODE)->global_dtor_p)
5040
5041	/ Accessor macros for C++ template decl nodes. /
5042
5043	/ The DECL_TEMPLATE_PARMS are a list. The TREE_PURPOSE of each node*
5044	is a INT_CST whose TREE_INT_CST_LOW indicates the level of the
5045	template parameters, with 1 being the outermost set of template
5046	parameters. The TREE_TYPE is TEMPLATE_PARMS_CONSTRAINTS.
5047	The TREE_VALUE is a vector, whose elements are the
5048	template parameters at each level. Each element in the vector is a
5049	TREE_LIST, whose TREE_VALUE is a PARM_DECL (if the parameter is a
5050	non-type parameter), or a TYPE_DECL (if the parameter is a type
5051	parameter) or a TEMPLATE_DECL (if the parameter is a template
5052	parameter). The TREE_PURPOSE is the default value, if any.
5053	The TREE_TYPE is TEMPLATE_PARM_CONSTRAINTS. The
5054	TEMPLATE_PARM_INDEX for the parameter is available as the
5055	DECL_INITIAL (for a PARM_DECL) or as the TREE_TYPE (for a
5056	TYPE_DECL).
5057
5058	FIXME: CONST_CAST_TREE is a hack that hopefully will go away after
5059	tree is converted to C++ class hiearchy. /*
5060	#define DECL_TEMPLATE_PARMS(NODE) \
5061	((struct tree_template_decl *)CONST_CAST_TREE (TEMPLATE_DECL_CHECK (NODE)))->arguments
5062	#define DECL_INNERMOST_TEMPLATE_PARMS(NODE) \
5063	INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (NODE))
5064	#define DECL_NTPARMS(NODE) \
5065	TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (NODE))
5066	/ For function, method, class-data templates.*
5067
5068	FIXME: CONST_CAST_TREE is a hack that hopefully will go away after
5069	tree is converted to C++ class hiearchy. /*
5070	#define DECL_TEMPLATE_RESULT(NODE) \
5071	((struct tree_template_decl *)CONST_CAST_TREE(TEMPLATE_DECL_CHECK (NODE)))->result
5072	/ For a function template at namespace scope, DECL_TEMPLATE_INSTANTIATIONS*
5073	lists all instantiations and specializations of the function so that
5074	tsubst_friend_function can reassign them to another template if we find
5075	that the namespace-scope template is really a partial instantiation of a
5076	friend template.
5077
5078	For a class template the DECL_TEMPLATE_INSTANTIATIONS lists holds
5079	all instantiations and specializations of the class type, including
5080	partial instantiations and partial specializations, so that if we
5081	explicitly specialize a partial instantiation we can walk the list
5082	in maybe_process_partial_specialization and reassign them or complain
5083	as appropriate.
5084
5085	In both cases, the TREE_PURPOSE of each node contains the arguments
5086	used; the TREE_VALUE contains the generated variable. The template
5087	arguments are always complete. For example, given:
5088
5089	template <class T> struct S1 {
5090	template <class U> struct S2 {};
5091	template <class U> struct S2<U> {};*
5092	};
5093
5094	the record for the partial specialization will contain, as its
5095	argument list, { {T}, {U} }, and will be on the*
5096	DECL_TEMPLATE_INSTANTIATIONS list for `template <class T> template
5097	<class U> struct S1<T>::S2'.
5098
5099	This list is not used for other templates. /*
5100	#define DECL_TEMPLATE_INSTANTIATIONS(NODE) \
5101	DECL_SIZE_UNIT (TEMPLATE_DECL_CHECK (NODE))
5102
5103	/ For a class template, this list contains the partial*
5104	specializations of this template. (Full specializations are not
5105	recorded on this list.) The TREE_PURPOSE holds the arguments used
5106	in the partial specialization (e.g., for `template <class T> struct
5107	S<T, int>' this will be `T, int'.) The arguments will also include
5108	any outer template arguments. The TREE_VALUE holds the TEMPLATE_DECL
5109	for the partial specialization. The TREE_TYPE is the _TYPE node for
5110	the partial specialization.
5111
5112	This list is not used for other templates. /*
5113	#define DECL_TEMPLATE_SPECIALIZATIONS(NODE) \
5114	DECL_SIZE (TEMPLATE_DECL_CHECK (NODE))
5115
5116	/ Nonzero for a DECL which is actually a template parameter. Keep*
5117	these checks in ascending tree code order. /*
5118	#define DECL_TEMPLATE_PARM_P(NODE) \
5119	(DECL_LANG_FLAG_0 (NODE) \
5120	&& (TREE_CODE (NODE) == CONST_DECL \
5121	\|\| TREE_CODE (NODE) == PARM_DECL \
5122	\|\| TREE_CODE (NODE) == TYPE_DECL \
5123	\|\| TREE_CODE (NODE) == TEMPLATE_DECL))
5124
5125	#if ENABLE_TREE_CHECKING
5126	inline tree
5127	decl_template_parm_check (const_tree t, const char f, int* l, const char *fn)
5128	{
5129	if (!DECL_TEMPLATE_PARM_P (t))
5130	tree_check_failed (t, f, l, fn, `0`);
5131	return const_cast<tree>(t);
5132	}
5133	#endif
5134
5135	/ Nonzero for a raw template parameter node. /
5136	#define TEMPLATE_PARM_P(NODE) \
5137	(TREE_CODE (NODE) == TEMPLATE_TYPE_PARM \
5138	\|\| TREE_CODE (NODE) == TEMPLATE_TEMPLATE_PARM \
5139	\|\| TREE_CODE (NODE) == TEMPLATE_PARM_INDEX)
5140
5141	/ Mark NODE as a template parameter. /
5142	#define SET_DECL_TEMPLATE_PARM_P(NODE) \
5143	(DECL_LANG_FLAG_0 (NODE) = 1)
5144
5145	/ Nonzero if NODE is a template template parameter. /
5146	#define DECL_TEMPLATE_TEMPLATE_PARM_P(NODE) \
5147	(TREE_CODE (NODE) == TEMPLATE_DECL && DECL_TEMPLATE_PARM_P (NODE))
5148
5149	/ Nonzero for a DECL that represents a function template. /
5150	#define DECL_FUNCTION_TEMPLATE_P(NODE) \
5151	(TREE_CODE (NODE) == TEMPLATE_DECL \
5152	&& DECL_TEMPLATE_RESULT (NODE) != NULL_TREE \
5153	&& TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == FUNCTION_DECL)
5154
5155	/ Nonzero for a DECL that represents a class template or alias*
5156	template. /*
5157	#define DECL_TYPE_TEMPLATE_P(NODE) \
5158	(TREE_CODE (NODE) == TEMPLATE_DECL \
5159	&& DECL_TEMPLATE_RESULT (NODE) != NULL_TREE \
5160	&& TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == TYPE_DECL)
5161
5162	/ Nonzero for a DECL that represents a class template. /
5163	#define DECL_CLASS_TEMPLATE_P(NODE) \
5164	(DECL_TYPE_TEMPLATE_P (NODE) \
5165	&& DECL_IMPLICIT_TYPEDEF_P (DECL_TEMPLATE_RESULT (NODE)))
5166
5167	/ Nonzero for a TEMPLATE_DECL that represents an alias template. /
5168	#define DECL_ALIAS_TEMPLATE_P(NODE) \
5169	(DECL_TYPE_TEMPLATE_P (NODE) \
5170	&& !DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (NODE)))
5171
5172	/ Nonzero for a NODE which declares a type. /
5173	#define DECL_DECLARES_TYPE_P(NODE) \
5174	(TREE_CODE (NODE) == TYPE_DECL \|\| DECL_TYPE_TEMPLATE_P (NODE))
5175
5176	/ Nonzero if NODE declares a function. /
5177	#define DECL_DECLARES_FUNCTION_P(NODE) \
5178	(TREE_CODE (NODE) == FUNCTION_DECL \|\| DECL_FUNCTION_TEMPLATE_P (NODE))
5179
5180	/ Nonzero if NODE is the typedef implicitly generated for a type when*
5181	the type is declared. In C++, `struct S {};' is roughly
5182	equivalent to `struct S {}; typedef struct S S;' in C.
5183	DECL_IMPLICIT_TYPEDEF_P will hold for the typedef indicated in this
5184	example. In C++, there is a second implicit typedef for each
5185	class, called the injected-class-name, in the scope of `S' itself, so that
5186	you can say `S::S'. DECL_SELF_REFERENCE_P will hold for that typedef. /*
5187	#define DECL_IMPLICIT_TYPEDEF_P(NODE) \
5188	(TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_2 (NODE))
5189	#define SET_DECL_IMPLICIT_TYPEDEF_P(NODE) \
5190	(DECL_LANG_FLAG_2 (NODE) = 1)
5191	#define DECL_SELF_REFERENCE_P(NODE) \
5192	(TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_4 (NODE))
5193	#define SET_DECL_SELF_REFERENCE_P(NODE) \
5194	(DECL_LANG_FLAG_4 (NODE) = 1)
5195
5196	/ A `primary' template is one that has its own template header and is not*
5197	a partial specialization. A member function of a class template is a
5198	template, but not primary. A member template is primary. Friend
5199	templates are primary, too. /*
5200
5201	/ Returns the primary template corresponding to these parameters. /
5202	#define TPARMS_PRIMARY_TEMPLATE(NODE) (TREE_TYPE (TREE_VEC_CHECK (NODE)))
5203
5204	#define DECL_PRIMARY_TEMPLATE(NODE) \
5205	(TPARMS_PRIMARY_TEMPLATE (DECL_INNERMOST_TEMPLATE_PARMS (NODE)))
5206
5207	/ Returns nonzero if NODE is a primary template. /
5208	#define PRIMARY_TEMPLATE_P(NODE) (DECL_PRIMARY_TEMPLATE (NODE) == (NODE))
5209
5210	/ Nonzero iff NODE is a specialization of a template. The value*
5211	indicates the type of specializations:
5212
5213	1=implicit instantiation
5214
5215	2=partial or explicit specialization, e.g.:
5216
5217	template <> int min<int> (int, int),
5218
5219	3=explicit instantiation, e.g.:
5220
5221	template int min<int> (int, int);
5222
5223	Note that NODE will be marked as a specialization even if the
5224	template it is instantiating is not a primary template. For
5225	example, given:
5226
5227	template <typename T> struct O {
5228	void f();
5229	struct I {};
5230	};
5231
5232	both O<int>::f and O<int>::I will be marked as instantiations.
5233
5234	If DECL_USE_TEMPLATE is nonzero, then DECL_TEMPLATE_INFO will also
5235	be non-NULL. /*
5236	#define DECL_USE_TEMPLATE(NODE) (DECL_LANG_SPECIFIC (NODE)->u.base.use_template)
5237
5238	/ Like DECL_USE_TEMPLATE, but for class types. /
5239	#define CLASSTYPE_USE_TEMPLATE(NODE) \
5240	(LANG_TYPE_CLASS_CHECK (NODE)->use_template)
5241
5242	/ True if NODE is a specialization of a primary template. /
5243	#define CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P(NODE) \
5244	(CLASS_TYPE_P (NODE) \
5245	&& CLASSTYPE_USE_TEMPLATE (NODE) \
5246	&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE)))
5247
5248	#define DECL_TEMPLATE_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) & 1)
5249	#define CLASSTYPE_TEMPLATE_INSTANTIATION(NODE) \
5250	(CLASSTYPE_USE_TEMPLATE (NODE) & 1)
5251
5252	#define DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) == 2)
5253	#define SET_DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) = 2)
5254
5255	/ Returns true for an explicit or partial specialization of a class*
5256	template. /*
5257	#define CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \
5258	(CLASSTYPE_USE_TEMPLATE (NODE) == 2)
5259	#define SET_CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \
5260	(CLASSTYPE_USE_TEMPLATE (NODE) = 2)
5261
5262	#define DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 1)
5263	#define SET_DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 1)
5264	#define CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \
5265	(CLASSTYPE_USE_TEMPLATE (NODE) == 1)
5266	#define SET_CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \
5267	(CLASSTYPE_USE_TEMPLATE (NODE) = 1)
5268
5269	#define DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 3)
5270	#define SET_DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 3)
5271	#define CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \
5272	(CLASSTYPE_USE_TEMPLATE (NODE) == 3)
5273	#define SET_CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \
5274	(CLASSTYPE_USE_TEMPLATE (NODE) = 3)
5275
5276	/ Nonzero if DECL is a friend function which is an instantiation*
5277	from the point of view of the compiler, but not from the point of
5278	view of the language. For example given:
5279	template <class T> struct S { friend void f(T) {}; };
5280	the declaration of `void f(int)' generated when S<int> is
5281	instantiated will not be a DECL_TEMPLATE_INSTANTIATION, but will be
5282	a DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION. /*
5283	#define DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION(DECL) \
5284	(DECL_LANG_SPECIFIC (DECL) && DECL_TEMPLATE_INFO (DECL) \
5285	&& !DECL_USE_TEMPLATE (DECL))
5286
5287	/ Nonzero if DECL is a function generated from a function 'temploid',*
5288	i.e. template, member of class template, or dependent friend. /*
5289	#define DECL_TEMPLOID_INSTANTIATION(DECL) \
5290	(DECL_TEMPLATE_INSTANTIATION (DECL) \
5291	\|\| DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (DECL))
5292
5293	/ Nonzero if DECL is either defined implicitly by the compiler or*
5294	generated from a temploid. /*
5295	#define DECL_GENERATED_P(DECL) \
5296	(DECL_TEMPLOID_INSTANTIATION (DECL) \|\| DECL_DEFAULTED_FN (DECL))
5297
5298	/ Nonzero iff we are currently processing a declaration for an*
5299	entity with its own template parameter list, and which is not a
5300	full specialization. /*
5301	#define PROCESSING_REAL_TEMPLATE_DECL_P() \
5302	(!processing_template_parmlist \
5303	&& current_template_depth > template_class_depth (current_scope ()))
5304
5305	/ Nonzero if this VAR_DECL or FUNCTION_DECL has already been*
5306	instantiated, i.e. its definition has been generated from the
5307	pattern given in the template. /*
5308	#define DECL_TEMPLATE_INSTANTIATED(NODE) \
5309	DECL_LANG_FLAG_1 (VAR_OR_FUNCTION_DECL_CHECK (NODE))
5310
5311	/ We know what we're doing with this decl now. /
5312	#define DECL_INTERFACE_KNOWN(NODE) DECL_LANG_FLAG_5 (NODE)
5313
5314	/ DECL_EXTERNAL must be set on a decl until the decl is actually emitted,*
5315	so that assemble_external will work properly. So we have this flag to
5316	tell us whether the decl is really not external.
5317
5318	This flag does not indicate whether or not the decl is defined in the
5319	current translation unit; it indicates whether or not we should emit the
5320	decl at the end of compilation if it is defined and needed. /*
5321	#define DECL_NOT_REALLY_EXTERN(NODE) \
5322	(DECL_LANG_SPECIFIC (NODE)->u.base.not_really_extern)
5323
5324	#define DECL_REALLY_EXTERN(NODE) \
5325	(DECL_EXTERNAL (NODE) \
5326	&& (!DECL_LANG_SPECIFIC (NODE) \|\| !DECL_NOT_REALLY_EXTERN (NODE)))
5327
5328	/ A thunk is a stub function.*
5329
5330	A thunk is an alternate entry point for an ordinary FUNCTION_DECL.
5331	The address of the ordinary FUNCTION_DECL is given by the
5332	DECL_INITIAL, which is always an ADDR_EXPR whose operand is a
5333	FUNCTION_DECL. The job of the thunk is to either adjust the this
5334	pointer before transferring control to the FUNCTION_DECL, or call
5335	FUNCTION_DECL and then adjust the result value. Note, the result
5336	pointer adjusting thunk must perform a call to the thunked
5337	function, (or be implemented via passing some invisible parameter
5338	to the thunked function, which is modified to perform the
5339	adjustment just before returning).
5340
5341	A thunk may perform either, or both, of the following operations:
5342
5343	o Adjust the this or result pointer by a constant offset.
5344	o Adjust the this or result pointer by looking up a vcall or vbase offset
5345	in the vtable.
5346
5347	A this pointer adjusting thunk converts from a base to a derived
5348	class, and hence adds the offsets. A result pointer adjusting thunk
5349	converts from a derived class to a base, and hence subtracts the
5350	offsets. If both operations are performed, then the constant
5351	adjustment is performed first for this pointer adjustment and last
5352	for the result pointer adjustment.
5353
5354	The constant adjustment is given by THUNK_FIXED_OFFSET. If the
5355	vcall or vbase offset is required, THUNK_VIRTUAL_OFFSET is
5356	used. For this pointer adjusting thunks, it is the vcall offset
5357	into the vtable. For result pointer adjusting thunks it is the
5358	binfo of the virtual base to convert to. Use that binfo's vbase
5359	offset.
5360
5361	It is possible to have equivalent covariant thunks. These are
5362	distinct virtual covariant thunks whose vbase offsets happen to
5363	have the same value. THUNK_ALIAS is used to pick one as the
5364	canonical thunk, which will get all the this pointer adjusting
5365	thunks attached to it. /*
5366
5367	/ An integer indicating how many bytes should be subtracted from the*
5368	this or result pointer when this function is called. /*
5369	#define THUNK_FIXED_OFFSET(DECL) \
5370	(DECL_LANG_SPECIFIC (THUNK_FUNCTION_CHECK (DECL))->u.fn.u5.fixed_offset)
5371
5372	/ A tree indicating how to perform the virtual adjustment. For a this*
5373	adjusting thunk it is the number of bytes to be added to the vtable
5374	to find the vcall offset. For a result adjusting thunk, it is the
5375	binfo of the relevant virtual base. If NULL, then there is no
5376	virtual adjust. (The vptr is always located at offset zero from
5377	the this or result pointer.) (If the covariant type is within the
5378	class hierarchy being laid out, the vbase index is not yet known
5379	at the point we need to create the thunks, hence the need to use
5380	binfos.) /*
5381
5382	#define THUNK_VIRTUAL_OFFSET(DECL) \
5383	(LANG_DECL_MIN_CHECK (FUNCTION_DECL_CHECK (DECL))->access)
5384
5385	/ A thunk which is equivalent to another thunk. /
5386	#define THUNK_ALIAS(DECL) \
5387	(DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->u.min.template_info)
5388
5389	/ For thunk NODE, this is the FUNCTION_DECL thunked to. It is*
5390	possible for the target to be a thunk too. /*
5391	#define THUNK_TARGET(NODE) \
5392	(LANG_DECL_FN_CHECK (NODE)->befriending_classes)
5393
5394	/ True for a SCOPE_REF iff the "template" keyword was used to*
5395	indicate that the qualified name denotes a template. /*
5396	#define QUALIFIED_NAME_IS_TEMPLATE(NODE) \
5397	(TREE_LANG_FLAG_1 (SCOPE_REF_CHECK (NODE)))
5398
5399	/ [coroutines]*
5400	*/
5401
5402	/ True if NODE is a co-routine FUNCTION_DECL. /
5403	#define DECL_COROUTINE_P(NODE) \
5404	(LANG_DECL_FN_CHECK (DECL_COMMON_CHECK (NODE))->coroutine_p)
5405
5406	/ For a FUNCTION_DECL of a coroutine, this holds the ACTOR helper function*
5407	decl. /*
5408	#define DECL_ACTOR_FN(NODE) \
5409	(coro_get_actor_function ((NODE)))
5410
5411	/ For a FUNCTION_DECL of a coroutine, this holds the DESTROY helper function*
5412	decl. /*
5413	#define DECL_DESTROY_FN(NODE) \
5414	(coro_get_destroy_function ((NODE)))
5415
5416	/ For a FUNCTION_DECL of a coroutine helper (ACTOR or DESTROY), this points*
5417	back to the original (ramp) function. /*
5418	#define DECL_RAMP_FN(NODE) \
5419	(coro_get_ramp_function (NODE))
5420
5421	/ True for an OMP_ATOMIC that has dependent parameters. These are stored*
5422	as an expr in operand 1, and integer_zero_node or clauses in operand 0. /*
5423	#define OMP_ATOMIC_DEPENDENT_P(NODE) \
5424	(TREE_CODE (TREE_OPERAND (OMP_ATOMIC_CHECK (NODE), 0)) == INTEGER_CST \
5425	\|\| TREE_CODE (TREE_OPERAND (OMP_ATOMIC_CHECK (NODE), 0)) == OMP_CLAUSE)
5426
5427	/ Used while gimplifying continue statements bound to OMP_FOR nodes. /
5428	#define OMP_FOR_GIMPLIFYING_P(NODE) \
5429	(TREE_LANG_FLAG_0 (OMP_LOOPING_CHECK (NODE)))
5430
5431	/ A language-specific token attached to the OpenMP data clauses to*
5432	hold code (or code fragments) related to ctors, dtors, and op=.
5433	See semantics.cc for details. /*
5434	#define CP_OMP_CLAUSE_INFO(NODE) \
5435	TREE_TYPE (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_PRIVATE, \
5436	OMP_CLAUSE__CONDTEMP_))
5437
5438	/ Nonzero if this transaction expression's body contains statements. /
5439	#define TRANSACTION_EXPR_IS_STMT(NODE) \
5440	TREE_LANG_FLAG_0 (TRANSACTION_EXPR_CHECK (NODE))
5441
5442	/ These macros provide convenient access to the various _STMT nodes*
5443	created when parsing template declarations. /*
5444	#define TRY_STMTS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 0)
5445	#define TRY_HANDLERS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 1)
5446
5447	#define EH_SPEC_STMTS(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 0)
5448	#define EH_SPEC_RAISES(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 1)
5449
5450	#define USING_STMT_NAMESPACE(NODE) TREE_OPERAND (USING_STMT_CHECK (NODE), 0)
5451
5452	/ Nonzero if this try block is a function try block. /
5453	#define FN_TRY_BLOCK_P(NODE) TREE_LANG_FLAG_3 (TRY_BLOCK_CHECK (NODE))
5454	#define HANDLER_PARMS(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 0)
5455	#define HANDLER_BODY(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 1)
5456	#define HANDLER_TYPE(NODE) TREE_TYPE (HANDLER_CHECK (NODE))
5457
5458	/ CLEANUP_STMT accessors. The statement(s) covered, the cleanup to run*
5459	and the VAR_DECL for which this cleanup exists. /*
5460	#define CLEANUP_BODY(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 0)
5461	#define CLEANUP_EXPR(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 1)
5462	#define CLEANUP_DECL(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 2)
5463
5464	/ IF_STMT accessors. These give access to the condition of the if*
5465	statement, the then block of the if statement, and the else block
5466	of the if statement if it exists. /*
5467	#define IF_COND(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 0)
5468	#define THEN_CLAUSE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 1)
5469	#define ELSE_CLAUSE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 2)
5470	#define IF_SCOPE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 3)
5471	#define IF_STMT_CONSTEXPR_P(NODE) TREE_LANG_FLAG_0 (IF_STMT_CHECK (NODE))
5472	#define IF_STMT_CONSTEVAL_P(NODE) TREE_LANG_FLAG_2 (IF_STMT_CHECK (NODE))
5473
5474	/ Like PACK_EXPANSION_EXTRA_ARGS, for constexpr if. IF_SCOPE is used while*
5475	building an IF_STMT; IF_STMT_EXTRA_ARGS is used after it is complete. /*
5476	#define IF_STMT_EXTRA_ARGS(NODE) IF_SCOPE (NODE)
5477
5478	/ RANGE_FOR_STMT accessors. These give access to the declarator,*
5479	expression, body, and scope of the statement, respectively. /*
5480	#define RANGE_FOR_DECL(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 0)
5481	#define RANGE_FOR_EXPR(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 1)
5482	#define RANGE_FOR_BODY(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 2)
5483	#define RANGE_FOR_SCOPE(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 3)
5484	#define RANGE_FOR_UNROLL(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 4)
5485	#define RANGE_FOR_INIT_STMT(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 5)
5486	#define RANGE_FOR_IVDEP(NODE) TREE_LANG_FLAG_6 (RANGE_FOR_STMT_CHECK (NODE))
5487	#define RANGE_FOR_NOVECTOR(NODE) TREE_LANG_FLAG_5 (RANGE_FOR_STMT_CHECK (NODE))
5488
5489	/ STMT_EXPR accessor. /
5490	#define STMT_EXPR_STMT(NODE) TREE_OPERAND (STMT_EXPR_CHECK (NODE), 0)
5491
5492	/ EXPR_STMT accessor. This gives the expression associated with an*
5493	expression statement. /*
5494	#define EXPR_STMT_EXPR(NODE) TREE_OPERAND (EXPR_STMT_CHECK (NODE), 0)
5495
5496	/ True if this TARGET_EXPR was created by build_cplus_new, and so we can*
5497	discard it if it isn't useful. /*
5498	#define TARGET_EXPR_IMPLICIT_P(NODE) \
5499	TREE_LANG_FLAG_0 (TARGET_EXPR_CHECK (NODE))
5500
5501	/ True if this TARGET_EXPR is the result of list-initialization of a*
5502	temporary. /*
5503	#define TARGET_EXPR_LIST_INIT_P(NODE) \
5504	TREE_LANG_FLAG_1 (TARGET_EXPR_CHECK (NODE))
5505
5506	/ True if this TARGET_EXPR expresses direct-initialization of an object*
5507	to be named later. /*
5508	#define TARGET_EXPR_DIRECT_INIT_P(NODE) \
5509	TREE_LANG_FLAG_2 (TARGET_EXPR_CHECK (NODE))
5510
5511	/ True if we expect this TARGET_EXPR to be used as an initializer, not to*
5512	materialize as a temporary. /*
5513	#define TARGET_EXPR_ELIDING_P(NODE) \
5514	TREE_LANG_FLAG_3 (TARGET_EXPR_CHECK (NODE))
5515
5516	/ True if NODE is a TARGET_EXPR that just expresses a copy of its INITIAL; if*
5517	the initializer has void type, it's doing something more complicated. /*
5518	#define SIMPLE_TARGET_EXPR_P(NODE) \
5519	(TREE_CODE (NODE) == TARGET_EXPR \
5520	&& TARGET_EXPR_INITIAL (NODE) \
5521	&& !VOID_TYPE_P (TREE_TYPE (TARGET_EXPR_INITIAL (NODE))))
5522
5523	/ True if T is a TARGET_EXPR for which we'll need to replace_decl to use it as*
5524	an initializer. /*
5525	inline bool
5526	target_expr_needs_replace (tree t)
5527	{
5528	if (!t \|\| TREE_CODE (t) != TARGET_EXPR)
5529	return false;
5530	tree init = TARGET_EXPR_INITIAL (t);
5531	if (!init \|\| !VOID_TYPE_P (TREE_TYPE (init)))
5532	return false;
5533	while (TREE_CODE (init) == COMPOUND_EXPR)
5534	init = TREE_OPERAND (init, `1`);
5535	return (TREE_CODE (init) != AGGR_INIT_EXPR
5536	&& TREE_CODE (init) != VEC_INIT_EXPR);
5537	}
5538
5539	/ True if EXPR expresses direct-initialization of a TYPE. /
5540	#define DIRECT_INIT_EXPR_P(TYPE,EXPR) \
5541	(TREE_CODE (EXPR) == TARGET_EXPR && TREE_LANG_FLAG_2 (EXPR) \
5542	&& same_type_ignoring_top_level_qualifiers_p (TYPE, TREE_TYPE (EXPR)))
5543
5544	/ True if this CONVERT_EXPR is for a conversion to virtual base in*
5545	an NSDMI, and should be re-evaluated when used in a constructor. /*
5546	#define CONVERT_EXPR_VBASE_PATH(NODE) \
5547	TREE_LANG_FLAG_0 (CONVERT_EXPR_CHECK (NODE))
5548
5549	/ True if SIZEOF_EXPR argument is type. /
5550	#define SIZEOF_EXPR_TYPE_P(NODE) \
5551	TREE_LANG_FLAG_0 (SIZEOF_EXPR_CHECK (NODE))
5552
5553	/ True if the ALIGNOF_EXPR was spelled "alignof". /
5554	#define ALIGNOF_EXPR_STD_P(NODE) \
5555	TREE_LANG_FLAG_0 (ALIGNOF_EXPR_CHECK (NODE))
5556
5557	/ OMP_DEPOBJ accessors. These give access to the depobj expression of the*
5558	#pragma omp depobj directive and the clauses, respectively. If
5559	OMP_DEPOBJ_CLAUSES is INTEGER_CST, it is instead the update clause kind
5560	or OMP_CLAUSE_DEPEND_LAST for destroy clause. /*
5561	#define OMP_DEPOBJ_DEPOBJ(NODE) TREE_OPERAND (OMP_DEPOBJ_CHECK (NODE), 0)
5562	#define OMP_DEPOBJ_CLAUSES(NODE) TREE_OPERAND (OMP_DEPOBJ_CHECK (NODE), 1)
5563
5564	/ An enumeration of the kind of tags that C++ accepts. /
5565	enum tag_types {
5566	none_type = `0`, / Not a tag type. /
5567	record_type, / "struct" types. /
5568	class_type, / "class" types. /
5569	union_type, / "union" types. /
5570	enum_type, / "enum" types. /
5571	typename_type, / "typename" types. /
5572	scope_type / namespace or tagged type name followed by :: /
5573	};
5574
5575	/ The various kinds of lvalues we distinguish. /
5576	enum cp_lvalue_kind_flags {
5577	clk_none = `0`, / Things that are not an lvalue. /
5578	clk_ordinary = `1`, / An ordinary lvalue. /
5579	clk_rvalueref = `2`,/ An xvalue (rvalue formed using an rvalue reference) /
5580	clk_class = `4`, / A prvalue of class or array type. /
5581	clk_bitfield = `8`, / An lvalue for a bit-field. /
5582	clk_packed = `16`, / An lvalue for a packed field. /
5583	clk_implicit_rval = `1`<<`5` / An lvalue being treated as an xvalue. /
5584	};
5585
5586	/ This type is used for parameters and variables which hold*
5587	combinations of the flags in enum cp_lvalue_kind_flags. /*
5588	typedef int cp_lvalue_kind;
5589
5590	/ Various kinds of template specialization, instantiation, etc. /
5591	enum tmpl_spec_kind {
5592	tsk_none, / Not a template at all. /
5593	tsk_invalid_member_spec, / An explicit member template*
5594	specialization, but the enclosing
5595	classes have not all been explicitly
5596	specialized. /*
5597	tsk_invalid_expl_inst, / An explicit instantiation containing*
5598	template parameter lists. /*
5599	tsk_excessive_parms, / A template declaration with too many*
5600	template parameter lists. /*
5601	tsk_insufficient_parms, / A template declaration with too few*
5602	parameter lists. /*
5603	tsk_template, / A template declaration. /
5604	tsk_expl_spec, / An explicit specialization. /
5605	tsk_expl_inst / An explicit instantiation. /
5606	};
5607
5608	/ The various kinds of access. BINFO_ACCESS depends on these being*
5609	two bit quantities. The numerical values are important; they are
5610	used to initialize RTTI data structures, so changing them changes
5611	the ABI. /*
5612	enum access_kind {
5613	ak_none = `0`, / Inaccessible. /
5614	ak_public = `1`, / Accessible, as a `public' thing. /
5615	ak_protected = `2`, / Accessible, as a `protected' thing. /
5616	ak_private = `3` / Accessible, as a `private' thing. /
5617	};
5618
5619	/ The various kinds of special functions. If you add to this list,*
5620	you should update special_function_p as well. /*
5621	enum special_function_kind {
5622	sfk_none = `0`, / Not a special function. This enumeral*
5623	must have value zero; see
5624	special_function_p. /*
5625	/ The following are ordered, for use by member synthesis fns. /
5626	sfk_destructor, / A destructor. /
5627	sfk_constructor, / A constructor. /
5628	sfk_inheriting_constructor, / An inheriting constructor /
5629	sfk_copy_constructor, / A copy constructor. /
5630	sfk_move_constructor, / A move constructor. /
5631	sfk_copy_assignment, / A copy assignment operator. /
5632	sfk_move_assignment, / A move assignment operator. /
5633	/ The following are unordered. /
5634	sfk_complete_destructor, / A destructor for complete objects. /
5635	sfk_base_destructor, / A destructor for base subobjects. /
5636	sfk_deleting_destructor, / A destructor for complete objects that*
5637	deletes the object after it has been
5638	destroyed. /*
5639	sfk_conversion, / A conversion operator. /
5640	sfk_deduction_guide, / A class template deduction guide. /
5641	sfk_comparison, / A comparison operator (e.g. ==, <, <=>). /
5642	sfk_virtual_destructor / Used by member synthesis fns. /
5643	};
5644
5645	/ The various kinds of linkage. From [basic.link],*
5646
5647	A name is said to have linkage when it might denote the same
5648	object, reference, function, type, template, namespace or value
5649	as a name introduced in another scope:
5650
5651	-- When a name has external linkage, the entity it denotes can
5652	be referred to from scopes of other translation units or from
5653	other scopes of the same translation unit.
5654
5655	-- When a name has internal linkage, the entity it denotes can
5656	be referred to by names from other scopes in the same
5657	translation unit.
5658
5659	-- When a name has no linkage, the entity it denotes cannot be
5660	referred to by names from other scopes. /*
5661
5662	enum linkage_kind {
5663	lk_none, / No linkage. /
5664	lk_internal, / Internal linkage. /
5665	lk_external / External linkage. /
5666	};
5667
5668	enum duration_kind {
5669	dk_static,
5670	dk_thread,
5671	dk_auto,
5672	dk_dynamic
5673	};
5674
5675	/ Bitmask flags to control type substitution. /
5676	enum tsubst_flags {
5677	tf_none = `0`, / nothing special /
5678	tf_error = `1` << `0`, / give error messages /
5679	tf_warning = `1` << `1`, / give warnings too /
5680	tf_ignore_bad_quals = `1` << `2`, / ignore bad cvr qualifiers /
5681	tf_keep_type_decl = `1` << `3`, / retain typedef type decls*
5682	(make_typename_type use) /*
5683	tf_ptrmem_ok = `1` << `4`, / pointers to member ok (internal*
5684	instantiate_type use) /*
5685	tf_user = `1` << `5`, / found template must be a user template*
5686	(lookup_template_class use) /*
5687	tf_conv = `1` << `6`, / We are determining what kind of*
5688	conversion might be permissible,
5689	not actually performing the
5690	conversion. /*
5691	tf_decltype = `1` << `7`, / We are the operand of decltype.*
5692	Used to implement the special rules
5693	for calls in decltype (5.2.2/11). /*
5694	tf_partial = `1` << `8`, / Doing initial explicit argument*
5695	substitution in fn_type_unification. /*
5696	tf_fndecl_type = `1` << `9`, / Substituting the type of a function*
5697	declaration. /*
5698	tf_no_cleanup = `1` << `10`, / Do not build a cleanup*
5699	(build_target_expr and friends) /*
5700	tf_norm = `1` << `11`, / Build diagnostic information during*
5701	constraint normalization. /*
5702	tf_tst_ok = `1` << `12`, / Allow a typename-specifier to name*
5703	a template (C++17 or later). /*
5704	tf_dguide = `1` << `13`, / Building a deduction guide from a ctor. /
5705	tf_qualifying_scope = `1` << `14`, / Substituting the LHS of the :: operator.*
5706	Affects TYPENAME_TYPE resolution from
5707	make_typename_type. /*
5708	tf_no_name_lookup = `1` << `15`, / Don't look up the terminal name of an*
5709	outermost id-expression, or resolve its
5710	constituent template-ids or qualified-ids. /*
5711	/ Convenient substitution flags combinations. /
5712	tf_warning_or_error = tf_warning \| tf_error
5713	};
5714
5715	/ This type is used for parameters and variables which hold*
5716	combinations of the flags in enum tsubst_flags. /*
5717	typedef int tsubst_flags_t;
5718
5719	/ The kind of checking we can do looking in a class hierarchy. /
5720	enum base_access_flags {
5721	ba_any = `0`, / Do not check access, allow an ambiguous base,*
5722	prefer a non-virtual base /*
5723	ba_unique = `1` << `0`, / Must be a unique base. /
5724	ba_check_bit = `1` << `1`, / Check access. /
5725	ba_check = ba_unique \| ba_check_bit,
5726	ba_ignore_scope = `1` << `2` / Ignore access allowed by local scope. /
5727	};
5728
5729	/ This type is used for parameters and variables which hold*
5730	combinations of the flags in enum base_access_flags. /*
5731	typedef int base_access;
5732
5733	/ The various kinds of access check during parsing. /
5734	enum deferring_kind {
5735	dk_no_deferred = `0`, / Check access immediately /
5736	dk_deferred = `1`, / Deferred check /
5737	dk_no_check = `2` / No access check /
5738	};
5739
5740	/ The kind of base we can find, looking in a class hierarchy.*
5741	Values <0 indicate we failed. /*
5742	enum base_kind {
5743	bk_inaccessible = -`3`, / The base is inaccessible /
5744	bk_ambig = -`2`, / The base is ambiguous /
5745	bk_not_base = -`1`, / It is not a base /
5746	bk_same_type = `0`, / It is the same type /
5747	bk_proper_base = `1`, / It is a proper base /
5748	bk_via_virtual = `2` / It is a proper base, but via a virtual*
5749	path. This might not be the canonical
5750	binfo. /*
5751	};
5752
5753	/ Node for "pointer to (virtual) function".*
5754	This may be distinct from ptr_type_node so gdb can distinguish them. /*
5755	#define vfunc_ptr_type_node vtable_entry_type
5756
5757
5758	/ For building calls to `delete'. /
5759	extern GTY(()) tree integer_two_node;
5760
5761	/ The number of function bodies which we are currently processing.*
5762	(Zero if we are at namespace scope, one inside the body of a
5763	function, two inside the body of a function in a local class, etc.) /*
5764	extern int function_depth;
5765
5766	/ Nonzero if we are inside spec_hasher::equal, which affects*
5767	comparison of PARM_DECLs in cp_tree_equal. /*
5768	extern int comparing_specializations;
5769
5770	/ Nonzero if we want different dependent aliases to compare as unequal.*
5771	FIXME we should always do this except during deduction/ordering. /*
5772	extern int comparing_dependent_aliases;
5773
5774	/ Nonzero if we want to consider different member expressions to compare*
5775	equal if they designate the same entity. This is set when comparing
5776	contract conditions of overrides. /*
5777	extern bool comparing_override_contracts;
5778
5779	/ In parser.cc. /
5780
5781	/ Nonzero if we are parsing an unevaluated operand: an operand to*
5782	sizeof, typeof, or alignof. This is a count since operands to
5783	sizeof can be nested. /*
5784
5785	extern int cp_unevaluated_operand;
5786
5787	/ RAII class used to inhibit the evaluation of operands during parsing*
5788	and template instantiation. Evaluation warnings are also inhibited. /*
5789
5790	class cp_unevaluated
5791	{
5792	public:
5793	cp_unevaluated ();
5794	~cp_unevaluated ();
5795	};
5796
5797	/ The reverse: an RAII class used for nested contexts that are evaluated even*
5798	if the enclosing context is not. /*
5799
5800	class cp_evaluated
5801	{
5802	public:
5803	int uneval;
5804	int inhibit;
5805	cp_evaluated (bool reset = true)
5806	: uneval(cp_unevaluated_operand), inhibit(c_inhibit_evaluation_warnings)
5807	{ if (reset)
5808	cp_unevaluated_operand = c_inhibit_evaluation_warnings = `0`; }
5809	~cp_evaluated ()
5810	{ cp_unevaluated_operand = uneval;
5811	c_inhibit_evaluation_warnings = inhibit; }
5812	};
5813
5814	/ in pt.cc /
5815
5816	/ These values are used for the `STRICT' parameter to type_unification and*
5817	fn_type_unification. Their meanings are described with the
5818	documentation for fn_type_unification. /*
5819
5820	enum unification_kind_t {
5821	DEDUCE_CALL,
5822	DEDUCE_CONV,
5823	DEDUCE_EXACT
5824	};
5825
5826	// An RAII class used to create a new pointer map for local
5827	// specializations. When the stack goes out of scope, the
5828	// previous pointer map is restored.
5829	enum lss_policy { lss_blank, lss_copy, lss_nop };
5830	class local_specialization_stack
5831	{
5832	public:
5833	local_specialization_stack (lss_policy = lss_blank);
5834	~local_specialization_stack ();
5835
5836	hash_map<tree, tree> *saved;
5837	};
5838
5839	/ Entry in the specialization hash table. /
5840	struct GTY((for_user)) spec_entry
5841	{
5842	tree tmpl; / The general template this is a specialization of. /
5843	tree args; / The args for this (maybe-partial) specialization. /
5844	tree spec; / The specialization itself. /
5845	};
5846
5847	/ in class.cc /
5848
5849	extern int current_class_depth;
5850
5851	/ in decl.cc /
5852
5853	/ An array of static vars & fns. /
5854	extern GTY(()) vec<tree, va_gc> *static_decls;
5855
5856	/ An array of vtable-needing types that have no key function, or have*
5857	an emitted key function. /*
5858	extern GTY(()) vec<tree, va_gc> *keyed_classes;
5859
5860	/ Here's where we control how name mangling takes place. /
5861
5862	/ Cannot use '$' up front, because this confuses gdb*
5863	(names beginning with '$' are gdb-local identifiers).
5864
5865	Note that all forms in which the '$' is significant are long enough
5866	for direct indexing (meaning that if we know there is a '$'
5867	at a particular location, we can index into the string at
5868	any other location that provides distinguishing characters). /*
5869
5870	/ Define NO_DOT_IN_LABEL in your favorite tm file if your assembler*
5871	doesn't allow '.' in symbol names. /*
5872	#ifndef NO_DOT_IN_LABEL
5873
5874	#define JOINER '.'
5875	#define JOIN_STR "."
5876
5877	#define AUTO_TEMP_NAME "_.tmp_"
5878	#define VFIELD_BASE ".vf"
5879	#define VFIELD_NAME "_vptr."
5880	#define VFIELD_NAME_FORMAT "_vptr.%s"
5881
5882	#else /* NO_DOT_IN_LABEL */
5883
5884	#ifndef NO_DOLLAR_IN_LABEL
5885
5886	#define JOINER '$'
5887	#define JOIN_STR "$"
5888
5889	#define AUTO_TEMP_NAME "_$tmp_"
5890	#define VFIELD_BASE "$vf"
5891	#define VFIELD_NAME "_vptr$"
5892	#define VFIELD_NAME_FORMAT "_vptr$%s"
5893
5894	#else /* NO_DOLLAR_IN_LABEL */
5895
5896	#define JOIN_STR "_"
5897
5898	#define VTABLE_NAME "__vt_"
5899	#define VTABLE_NAME_P(ID_NODE) \
5900	(!strncmp (IDENTIFIER_POINTER (ID_NODE), VTABLE_NAME, \
5901	sizeof (VTABLE_NAME) - 1))
5902	#define VFIELD_BASE "__vfb"
5903	#define VFIELD_NAME "__vptr_"
5904	#define VFIELD_NAME_P(ID_NODE) \
5905	(!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, \
5906	sizeof (VFIELD_NAME) - 1))
5907	#define VFIELD_NAME_FORMAT "__vptr_%s"
5908
5909	#endif /* NO_DOLLAR_IN_LABEL */
5910	#endif /* NO_DOT_IN_LABEL */
5911
5912	#define UDLIT_OP_ANSI_PREFIX "operator\"\""
5913	#define UDLIT_OP_ANSI_FORMAT UDLIT_OP_ANSI_PREFIX "%s"
5914	#define UDLIT_OP_MANGLED_PREFIX "li"
5915	#define UDLIT_OP_MANGLED_FORMAT UDLIT_OP_MANGLED_PREFIX "%s"
5916	#define UDLIT_OPER_P(ID_NODE) \
5917	(!strncmp (IDENTIFIER_POINTER (ID_NODE), \
5918	UDLIT_OP_ANSI_PREFIX, \
5919	sizeof (UDLIT_OP_ANSI_PREFIX) - 1))
5920	#define UDLIT_OP_SUFFIX(ID_NODE) \
5921	(IDENTIFIER_POINTER (ID_NODE) + sizeof (UDLIT_OP_ANSI_PREFIX) - 1)
5922
5923	#if !defined(NO_DOLLAR_IN_LABEL) \|\| !defined(NO_DOT_IN_LABEL)
5924
5925	#define VTABLE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == 'v' \
5926	&& IDENTIFIER_POINTER (ID_NODE)[2] == 't' \
5927	&& IDENTIFIER_POINTER (ID_NODE)[3] == JOINER)
5928
5929	#define VFIELD_NAME_P(ID_NODE) \
5930	(!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, sizeof(VFIELD_NAME)-1))
5931
5932	#endif /* !defined(NO_DOLLAR_IN_LABEL) \|\| !defined(NO_DOT_IN_LABEL) */
5933
5934
5935	/ Nonzero if we're done parsing and into end-of-file activities.*
5936	2 if all templates have been instantiated.
5937	3 if we're done with front-end processing. /*
5938
5939	extern int at_eof;
5940
5941	/ True if note_mangling_alias should enqueue mangling aliases for*
5942	later generation, rather than emitting them right away. /*
5943
5944	extern bool defer_mangling_aliases;
5945
5946	/ True if noexcept is part of the type (i.e. in C++17). /
5947
5948	extern bool flag_noexcept_type;
5949
5950	/ A list of namespace-scope objects which have constructors or*
5951	destructors which reside in the global scope. The decl is stored
5952	in the TREE_VALUE slot and the initializer is stored in the
5953	TREE_PURPOSE slot. /*
5954	extern GTY(()) tree static_aggregates;
5955	/ Likewise, for thread local storage. /
5956	extern GTY(()) tree tls_aggregates;
5957
5958	/ A hash-map mapping from variable decls to the dynamic initializer for*
5959	the decl. This is currently only used by OpenMP. /*
5960	extern GTY(()) decl_tree_map *dynamic_initializers;
5961
5962	enum overload_flags { NO_SPECIAL = `0`, DTOR_FLAG, TYPENAME_FLAG };
5963
5964	/ These are uses as bits in flags passed to various functions to*
5965	control their behavior. Despite the LOOKUP_ prefix, many of these
5966	do not control name lookup. ??? Functions using these flags should
5967	probably be modified to accept explicit boolean flags for the
5968	behaviors relevant to them. /*
5969	/ Check for access violations. /
5970	#define LOOKUP_PROTECT (1 << 0)
5971	#define LOOKUP_NORMAL (LOOKUP_PROTECT)
5972	/ Even if the function found by lookup is a virtual function, it*
5973	should be called directly. /*
5974	#define LOOKUP_NONVIRTUAL (1 << 1)
5975	/ Non-converting (i.e., "explicit") constructors are not tried. This flag*
5976	indicates that we are not performing direct-initialization. /*
5977	#define LOOKUP_ONLYCONVERTING (1 << 2)
5978	#define LOOKUP_IMPLICIT (LOOKUP_NORMAL \| LOOKUP_ONLYCONVERTING)
5979	/ If a temporary is created, it should be created so that it lives*
5980	as long as the current variable bindings; otherwise it only lives
5981	until the end of the complete-expression. It also forces
5982	direct-initialization in cases where other parts of the compiler
5983	have already generated a temporary, such as reference
5984	initialization and the catch parameter. /*
5985	#define DIRECT_BIND (1 << 3)
5986	/ We're performing a user-defined conversion, so more user-defined*
5987	conversions are not permitted (only built-in conversions). /*
5988	#define LOOKUP_NO_CONVERSION (1 << 4)
5989	/ The user has explicitly called a destructor. (Therefore, we do*
5990	not need to check that the object is non-NULL before calling the
5991	destructor.) /*
5992	#define LOOKUP_DESTRUCTOR (1 << 5)
5993	/ Do not permit references to bind to temporaries. /
5994	#define LOOKUP_NO_TEMP_BIND (1 << 6)
5995	/ We're inside an init-list, so narrowing conversions are ill-formed. /
5996	#define LOOKUP_NO_NARROWING (LOOKUP_NO_TEMP_BIND << 1)
5997	/ We're looking up a constructor for list-initialization. /
5998	#define LOOKUP_LIST_INIT_CTOR (LOOKUP_NO_NARROWING << 1)
5999	/ This is the first parameter of a copy constructor. /
6000	#define LOOKUP_COPY_PARM (LOOKUP_LIST_INIT_CTOR << 1)
6001	/ We only want to consider list constructors. /
6002	#define LOOKUP_LIST_ONLY (LOOKUP_COPY_PARM << 1)
6003	/ Return after determining which function to call and checking access.*
6004	Used by sythesized_method_walk to determine which functions will
6005	be called to initialize subobjects, in order to determine exception
6006	specification and possible implicit delete.
6007	This is kind of a hack, but exiting early avoids problems with trying
6008	to perform argument conversions when the class isn't complete yet. /*
6009	#define LOOKUP_SPECULATIVE (LOOKUP_LIST_ONLY << 1)
6010	/ Used by calls from defaulted functions to limit the overload set to avoid*
6011	cycles trying to declare them (core issue 1092). /*
6012	#define LOOKUP_DEFAULTED (LOOKUP_SPECULATIVE << 1)
6013	/ Used in calls to store_init_value to suppress its usual call to*
6014	digest_init. /*
6015	#define LOOKUP_ALREADY_DIGESTED (LOOKUP_DEFAULTED << 1)
6016	/ Like LOOKUP_NO_TEMP_BIND, but also prevent binding to xvalues. /
6017	#define LOOKUP_NO_RVAL_BIND (LOOKUP_ALREADY_DIGESTED << 1)
6018	/ Used by case_conversion to disregard non-integral conversions. /
6019	#define LOOKUP_NO_NON_INTEGRAL (LOOKUP_NO_RVAL_BIND << 1)
6020	/ Used for delegating constructors in order to diagnose self-delegation. /
6021	#define LOOKUP_DELEGATING_CONS (LOOKUP_NO_NON_INTEGRAL << 1)
6022	/ Allow initialization of a flexible array members. /
6023	#define LOOKUP_ALLOW_FLEXARRAY_INIT (LOOKUP_DELEGATING_CONS << 1)
6024	/ We're looking for either a rewritten comparison operator candidate or the*
6025	operator to use on the former's result. We distinguish between the two by
6026	knowing that comparisons other than == and <=> must be the latter, as must
6027	a <=> expression trying to rewrite to <=> without reversing. /*
6028	#define LOOKUP_REWRITTEN (LOOKUP_ALLOW_FLEXARRAY_INIT << 1)
6029	/ Reverse the order of the two arguments for comparison rewriting. First we*
6030	swap the arguments in add_operator_candidates, then we swap the conversions
6031	in add_candidate (so that they correspond to the original order of the
6032	args), then we swap the conversions back in build_new_op_1 (so they
6033	correspond to the order of the args in the candidate). /*
6034	#define LOOKUP_REVERSED (LOOKUP_REWRITTEN << 1)
6035	/ We're initializing an aggregate from a parenthesized list of values. /
6036	#define LOOKUP_AGGREGATE_PAREN_INIT (LOOKUP_REVERSED << 1)
6037	/ We're computing conversions as part of a first pass of overload resolution*
6038	wherein we don't try to distinguish an unviable candidate from a
6039	non-strictly viable candidate and thus can avoid computing unnecessary
6040	bad conversions. /*
6041	#define LOOKUP_SHORTCUT_BAD_CONVS (LOOKUP_AGGREGATE_PAREN_INIT << 1)
6042
6043	/ These flags are used by the conversion code.*
6044	CONV_IMPLICIT : Perform implicit conversions (standard and user-defined).
6045	CONV_STATIC : Perform the explicit conversions for static_cast.
6046	CONV_CONST : Perform the explicit conversions for const_cast.
6047	CONV_REINTERPRET: Perform the explicit conversions for reinterpret_cast.
6048	CONV_PRIVATE : Perform upcasts to private bases.
6049	CONV_FORCE_TEMP : Require a new temporary when converting to the same
6050	aggregate type. /*
6051
6052	#define CONV_IMPLICIT 1
6053	#define CONV_STATIC 2
6054	#define CONV_CONST 4
6055	#define CONV_REINTERPRET 8
6056	#define CONV_PRIVATE 16
6057	#define CONV_FORCE_TEMP 32
6058	#define CONV_FOLD 64
6059	#define CONV_OLD_CONVERT (CONV_IMPLICIT \| CONV_STATIC \| CONV_CONST \
6060	\| CONV_REINTERPRET)
6061	#define CONV_C_CAST (CONV_IMPLICIT \| CONV_STATIC \| CONV_CONST \
6062	\| CONV_REINTERPRET \| CONV_PRIVATE \| CONV_FORCE_TEMP)
6063	#define CONV_BACKEND_CONVERT (CONV_OLD_CONVERT \| CONV_FOLD)
6064
6065	/ Used by build_expr_type_conversion to indicate which types are*
6066	acceptable as arguments to the expression under consideration. /*
6067
6068	#define WANT_INT 1 /* integer types, including bool */
6069	#define WANT_FLOAT 2 /* floating point types */
6070	#define WANT_ENUM 4 /* enumerated types */
6071	#define WANT_POINTER 8 /* pointer types */
6072	#define WANT_NULL 16 /* null pointer constant */
6073	#define WANT_VECTOR_OR_COMPLEX 32 /* vector or complex types */
6074	#define WANT_ARITH (WANT_INT \| WANT_FLOAT \| WANT_VECTOR_OR_COMPLEX)
6075
6076	/ Used with comptypes, and related functions, to guide type*
6077	comparison. /*
6078
6079	#define COMPARE_STRICT 0 /* Just check if the types are the
6080	same. */
6081	#define COMPARE_BASE 1 /* Check to see if the second type is
6082	derived from the first. */
6083	#define COMPARE_DERIVED 2 /* Like COMPARE_BASE, but in
6084	reverse. */
6085	#define COMPARE_REDECLARATION 4 /* The comparison is being done when
6086	another declaration of an existing
6087	entity is seen. */
6088	#define COMPARE_STRUCTURAL 8 /* The comparison is intended to be
6089	structural. The actual comparison
6090	will be identical to
6091	COMPARE_STRICT. */
6092
6093	/ Used with start function. /
6094	#define SF_DEFAULT 0 /* No flags. */
6095	#define SF_PRE_PARSED 1 /* The function declaration has
6096	already been parsed. */
6097	#define SF_INCLASS_INLINE 2 /* The function is an inline, defined
6098	in the class body. */
6099
6100	/ Used with start_decl's initialized parameter. /
6101	#define SD_UNINITIALIZED 0
6102	#define SD_INITIALIZED 1
6103	/ Like SD_INITIALIZED, but also mark the new decl as DECL_DECOMPOSITION_P. /
6104	#define SD_DECOMPOSITION 2
6105	#define SD_DEFAULTED 3
6106	#define SD_DELETED 4
6107
6108	/ Returns nonzero iff TYPE1 and TYPE2 are the same type, or if TYPE2*
6109	is derived from TYPE1, or if TYPE2 is a pointer (reference) to a
6110	class derived from the type pointed to (referred to) by TYPE1. /*
6111	#define same_or_base_type_p(TYPE1, TYPE2) \
6112	comptypes ((TYPE1), (TYPE2), COMPARE_BASE)
6113
6114	/ These macros are used to access a TEMPLATE_PARM_INDEX. /
6115	#define TEMPLATE_PARM_INDEX_CAST(NODE) \
6116	((template_parm_index*)TEMPLATE_PARM_INDEX_CHECK (NODE))
6117	#define TEMPLATE_PARM_IDX(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->index)
6118	#define TEMPLATE_PARM_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->level)
6119	#define TEMPLATE_PARM_DESCENDANTS(NODE) (TREE_CHAIN (TEMPLATE_PARM_INDEX_CHECK (NODE)))
6120	#define TEMPLATE_PARM_ORIG_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->orig_level)
6121	#define TEMPLATE_PARM_DECL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->decl)
6122	#define TEMPLATE_PARM_PARAMETER_PACK(NODE) \
6123	(TREE_LANG_FLAG_0 (TEMPLATE_PARM_INDEX_CHECK (NODE)))
6124
6125	/ These macros are for accessing the fields of TEMPLATE_TYPE_PARM,*
6126	TEMPLATE_TEMPLATE_PARM and BOUND_TEMPLATE_TEMPLATE_PARM nodes. /*
6127	#define TEMPLATE_TYPE_PARM_INDEX(NODE) \
6128	(TYPE_VALUES_RAW (TREE_CHECK3 ((NODE), TEMPLATE_TYPE_PARM, \
6129	TEMPLATE_TEMPLATE_PARM, \
6130	BOUND_TEMPLATE_TEMPLATE_PARM)))
6131	#define TEMPLATE_TYPE_IDX(NODE) \
6132	(TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (NODE)))
6133	#define TEMPLATE_TYPE_LEVEL(NODE) \
6134	(TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
6135	#define TEMPLATE_TYPE_ORIG_LEVEL(NODE) \
6136	(TEMPLATE_PARM_ORIG_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
6137	#define TEMPLATE_TYPE_DESCENDANTS(NODE) \
6138	(TEMPLATE_PARM_DESCENDANTS (TEMPLATE_TYPE_PARM_INDEX (NODE)))
6139	#define TEMPLATE_TYPE_DECL(NODE) \
6140	(TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
6141	#define TEMPLATE_TYPE_PARAMETER_PACK(NODE) \
6142	(TEMPLATE_PARM_PARAMETER_PACK (TEMPLATE_TYPE_PARM_INDEX (NODE)))
6143
6144	/ For a C++17 class deduction placeholder, the template it represents. /
6145	#define CLASS_PLACEHOLDER_TEMPLATE(NODE) \
6146	(DECL_INITIAL (TYPE_NAME (TEMPLATE_TYPE_PARM_CHECK (NODE))))
6147
6148	/ True iff the template parameters of this TEMPLATE_TEMPLATE_PARM don't*
6149	use any outer template parameters. /*
6150	#define TEMPLATE_TEMPLATE_PARM_SIMPLE_P(NODE) \
6151	(TYPE_LANG_FLAG_5 (TEMPLATE_TEMPLATE_PARM_CHECK (NODE)))
6152
6153	/ Contexts in which auto deduction occurs. These flags are*
6154	used to control diagnostics in do_auto_deduction. /*
6155
6156	enum auto_deduction_context
6157	{
6158	adc_unspecified, / Not given /
6159	adc_variable_type, / Variable initializer deduction /
6160	adc_return_type, / Return type deduction /
6161	adc_unify, / Template argument deduction /
6162	adc_requirement, / Argument deduction constraint /
6163	adc_decomp_type / Decomposition declaration initializer deduction /
6164	};
6165
6166	/ True iff this TEMPLATE_TYPE_PARM represents decltype(auto). /
6167	#define AUTO_IS_DECLTYPE(NODE) \
6168	(TYPE_LANG_FLAG_5 (TEMPLATE_TYPE_PARM_CHECK (NODE)))
6169
6170	/ These constants can used as bit flags in the process of tree formatting.*
6171
6172	TFF_PLAIN_IDENTIFIER: unqualified part of a name.
6173	TFF_SCOPE: include the class and namespace scope of the name.
6174	TFF_CHASE_TYPEDEF: print the original type-id instead of the typedef-name.
6175	TFF_DECL_SPECIFIERS: print decl-specifiers.
6176	TFF_CLASS_KEY_OR_ENUM: precede a class-type name (resp. enum name) with
6177	a class-key (resp. `enum').
6178	TFF_RETURN_TYPE: include function return type.
6179	TFF_FUNCTION_DEFAULT_ARGUMENTS: include function default parameter values.
6180	TFF_EXCEPTION_SPECIFICATION: show function exception specification.
6181	TFF_TEMPLATE_HEADER: show the template<...> header in a
6182	template-declaration.
6183	TFF_TEMPLATE_NAME: show only template-name.
6184	TFF_EXPR_IN_PARENS: parenthesize expressions.
6185	TFF_NO_FUNCTION_ARGUMENTS: don't show function arguments.
6186	TFF_UNQUALIFIED_NAME: do not print the qualifying scope of the
6187	top-level entity.
6188	TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS: do not omit template arguments
6189	identical to their defaults.
6190	TFF_NO_TEMPLATE_BINDINGS: do not print information about the template
6191	arguments for a function template specialization.
6192	TFF_POINTER: we are printing a pointer type.
6193	TFF_XOBJ_FUNC: we are printing an explicit object member function's
6194	parameters. /*
6195
6196	#define TFF_PLAIN_IDENTIFIER (0)
6197	#define TFF_SCOPE (1)
6198	#define TFF_CHASE_TYPEDEF (1 << 1)
6199	#define TFF_DECL_SPECIFIERS (1 << 2)
6200	#define TFF_CLASS_KEY_OR_ENUM (1 << 3)
6201	#define TFF_RETURN_TYPE (1 << 4)
6202	#define TFF_FUNCTION_DEFAULT_ARGUMENTS (1 << 5)
6203	#define TFF_EXCEPTION_SPECIFICATION (1 << 6)
6204	#define TFF_TEMPLATE_HEADER (1 << 7)
6205	#define TFF_TEMPLATE_NAME (1 << 8)
6206	#define TFF_EXPR_IN_PARENS (1 << 9)
6207	#define TFF_NO_FUNCTION_ARGUMENTS (1 << 10)
6208	#define TFF_UNQUALIFIED_NAME (1 << 11)
6209	#define TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS (1 << 12)
6210	#define TFF_NO_TEMPLATE_BINDINGS (1 << 13)
6211	#define TFF_POINTER (1 << 14)
6212	#define TFF_XOBJ_FUNC (1 << 15)
6213
6214	/ These constants can be used as bit flags to control strip_typedefs.*
6215
6216	STF_USER_VISIBLE: use heuristics to try to avoid stripping user-facing
6217	aliases of internal details. This is intended for diagnostics,
6218	where it should (for example) give more useful "aka" types.
6219
6220	STF_STRIP_DEPENDENT: allow the stripping of aliases with dependent
6221	template parameters, relying on code elsewhere to report any
6222	appropriate diagnostics. /*
6223	const unsigned int STF_USER_VISIBLE = `1U`;
6224	const unsigned int STF_STRIP_DEPENDENT = `1U` << `1`;
6225
6226	/ Returns the TEMPLATE_DECL associated to a TEMPLATE_TEMPLATE_PARM*
6227	node. /*
6228	#define TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL(NODE) \
6229	((TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM) \
6230	? TYPE_TI_TEMPLATE (NODE) \
6231	: TYPE_NAME (TEMPLATE_TEMPLATE_PARM_CHECK (NODE)))
6232
6233	/ in lex.cc /
6234
6235	extern void init_reswords (void);
6236
6237	/ Various flags for the overloaded operator information. /
6238	enum ovl_op_flags {
6239	OVL_OP_FLAG_NONE = `0`, / Don't care. /
6240	OVL_OP_FLAG_UNARY = `1`, / Is unary. /
6241	OVL_OP_FLAG_BINARY = `2`, / Is binary. /
6242	OVL_OP_FLAG_AMBIARY = `3`, / May be unary or binary. /
6243	OVL_OP_FLAG_ALLOC = `4`, / operator new or delete. /
6244	OVL_OP_FLAG_DELETE = `1`, / operator delete. /
6245	OVL_OP_FLAG_VEC = `2` / vector new or delete. /
6246	};
6247
6248	/ Compressed operator codes. Order is determined by operators.def*
6249	and does not match that of tree_codes. /*
6250	enum ovl_op_code {
6251	OVL_OP_ERROR_MARK,
6252	OVL_OP_NOP_EXPR,
6253	#define DEF_OPERATOR(NAME, CODE, MANGLING, FLAGS) OVL_OP_##CODE,
6254	#define DEF_ASSN_OPERATOR(NAME, CODE, MANGLING) /* NOTHING */
6255	#include "operators.def"
6256	OVL_OP_MAX
6257	};
6258
6259	/ Make sure it fits in lang_decl_fn::ovl_op_code. /
6260	STATIC_ASSERT (OVL_OP_MAX < (`1` << `6`));
6261
6262	struct GTY(()) ovl_op_info_t {
6263	/ The IDENTIFIER_NODE for the operator. /
6264	tree identifier;
6265	/ The name of the operator. /
6266	const char *name;
6267	/ The mangled name of the operator. /
6268	const char *mangled_name;
6269	/ The (regular) tree code. /
6270	enum tree_code tree_code : `16`;
6271	/ The (compressed) operator code. /
6272	enum ovl_op_code ovl_op_code : `8`;
6273	/ The ovl_op_flags of the operator /
6274	unsigned flags : `8`;
6275	};
6276
6277	/ Overloaded operator info indexed by ass_op_p & ovl_op_code. /
6278	extern GTY(()) ovl_op_info_t ovl_op_info[`2`][OVL_OP_MAX];
6279	/ Mapping from tree_codes to ovl_op_codes. /
6280	extern GTY(()) unsigned char ovl_op_mapping[MAX_TREE_CODES];
6281	/ Mapping for ambi-ary operators from the binary to the unary. /
6282	extern GTY(()) unsigned char ovl_op_alternate[OVL_OP_MAX];
6283
6284	/ Given an ass_op_p boolean and a tree code, return a pointer to its*
6285	overloaded operator info. Tree codes for non-overloaded operators
6286	map to the error-operator. /*
6287	#define OVL_OP_INFO(IS_ASS_P, TREE_CODE) \
6288	(&ovl_op_info[(IS_ASS_P) != 0][ovl_op_mapping[(TREE_CODE)]])
6289	/ Overloaded operator info for an identifier for which*
6290	IDENTIFIER_OVL_OP_P is true. /*
6291	#define IDENTIFIER_OVL_OP_INFO(NODE) \
6292	(&ovl_op_info[IDENTIFIER_KIND_BIT_0 (NODE)][IDENTIFIER_CP_INDEX (NODE)])
6293	#define IDENTIFIER_OVL_OP_FLAGS(NODE) \
6294	(IDENTIFIER_OVL_OP_INFO (NODE)->flags)
6295
6296	inline tree ovl_op_identifier (bool isass, tree_code code)
6297	{ return OVL_OP_INFO(isass, code)->identifier; }
6298	inline tree ovl_op_identifier (tree_code code) { return ovl_op_identifier (isass: false, code); }
6299	#define assign_op_identifier (ovl_op_info[true][OVL_OP_NOP_EXPR].identifier)
6300	#define call_op_identifier (ovl_op_info[false][OVL_OP_CALL_EXPR].identifier)
6301
6302	/ A type-qualifier, or bitmask therefore, using the TYPE_QUAL*
6303	constants. /*
6304
6305	typedef int cp_cv_quals;
6306
6307	/ Non-static member functions have an optional virt-specifier-seq.*
6308	There is a VIRT_SPEC value for each virt-specifier.
6309	They can be combined by bitwise-or to form the complete set of
6310	virt-specifiers for a member function. /*
6311	enum virt_specifier
6312	{
6313	VIRT_SPEC_UNSPECIFIED = `0x0`,
6314	VIRT_SPEC_FINAL = `0x1`,
6315	VIRT_SPEC_OVERRIDE = `0x2`
6316	};
6317
6318	/ A type-qualifier, or bitmask therefore, using the VIRT_SPEC*
6319	constants. /*
6320
6321	typedef int cp_virt_specifiers;
6322
6323	/ Wherever there is a function-cv-qual, there could also be a ref-qualifier:*
6324
6325	[dcl.fct]
6326	The return type, the parameter-type-list, the ref-qualifier, and
6327	the cv-qualifier-seq, but not the default arguments or the exception
6328	specification, are part of the function type.
6329
6330	REF_QUAL_NONE Ordinary member function with no ref-qualifier
6331	REF_QUAL_LVALUE Member function with the &-ref-qualifier
6332	REF_QUAL_RVALUE Member function with the &&-ref-qualifier /*
6333
6334	enum cp_ref_qualifier {
6335	REF_QUAL_NONE = `0`,
6336	REF_QUAL_LVALUE = `1`,
6337	REF_QUAL_RVALUE = `2`
6338	};
6339
6340	/ A storage class. /
6341
6342	enum cp_storage_class {
6343	/ sc_none must be zero so that zeroing a cp_decl_specifier_seq*
6344	sets the storage_class field to sc_none. /*
6345	sc_none = `0`,
6346	sc_auto,
6347	sc_register,
6348	sc_static,
6349	sc_extern,
6350	sc_mutable
6351	};
6352
6353	/ An individual decl-specifier. This is used to index the array of*
6354	locations for the declspecs in struct cp_decl_specifier_seq
6355	below.
6356	A subset of these enums also corresponds to elements of
6357	cp_parser_set_decl_spec_type:decl_spec_names in parser.cc. /*
6358
6359	enum cp_decl_spec {
6360	ds_first,
6361	ds_signed = ds_first, / Index of first element of decl_spec_names. /
6362	ds_unsigned,
6363	ds_short,
6364	ds_long,
6365	ds_const,
6366	ds_volatile,
6367	ds_restrict,
6368	ds_inline,
6369	ds_virtual,
6370	ds_explicit,
6371	ds_friend,
6372	ds_typedef,
6373	ds_alias,
6374	ds_constexpr,
6375	ds_complex,
6376	ds_constinit,
6377	ds_consteval,
6378	ds_this, / Index of last element of decl_spec_names. /
6379	ds_thread,
6380	ds_type_spec,
6381	ds_redefined_builtin_type_spec,
6382	ds_attribute,
6383	ds_std_attribute,
6384	ds_storage_class,
6385	ds_long_long,
6386	ds_concept,
6387	ds_last / This enumerator must always be the last one. /
6388	};
6389
6390	/ A decl-specifier-seq. /
6391
6392	struct cp_decl_specifier_seq {
6393	/ An array of locations for the declaration sepecifiers, indexed by*
6394	enum cp_decl_spec_word. /*
6395	location_t locations[ds_last];
6396	/ The primary type, if any, given by the decl-specifier-seq.*
6397	Modifiers, like "short", "const", and "unsigned" are not
6398	reflected here. This field will be a TYPE, unless a typedef-name
6399	was used, in which case it will be a TYPE_DECL. /*
6400	tree type;
6401	/ The attributes, if any, provided with the specifier sequence. /
6402	tree attributes;
6403	/ The c++11 attributes that follows the type specifier. /
6404	tree std_attributes;
6405	/ If non-NULL, a built-in type that the user attempted to redefine*
6406	to some other type. /*
6407	tree redefined_builtin_type;
6408	/ The explicit-specifier, if any. /
6409	tree explicit_specifier;
6410	/ The storage class specified -- or sc_none if no storage class was*
6411	explicitly specified. /*
6412	cp_storage_class storage_class;
6413	/ For the __intN declspec, this stores the index into the int_n_* arrays. /
6414	int int_n_idx;
6415	/ True iff TYPE_SPEC defines a class or enum. /
6416	BOOL_BITFIELD type_definition_p : `1`;
6417	/ True iff multiple types were (erroneously) specified for this*
6418	decl-specifier-seq. /*
6419	BOOL_BITFIELD multiple_types_p : `1`;
6420	/ True iff multiple storage classes were (erroneously) specified*
6421	for this decl-specifier-seq or a combination of a storage class
6422	with a typedef specifier. /*
6423	BOOL_BITFIELD conflicting_specifiers_p : `1`;
6424	/ True iff at least one decl-specifier was found. /
6425	BOOL_BITFIELD any_specifiers_p : `1`;
6426	/ True iff at least one type-specifier was found. /
6427	BOOL_BITFIELD any_type_specifiers_p : `1`;
6428	/ True iff "int" was explicitly provided. /
6429	BOOL_BITFIELD explicit_int_p : `1`;
6430	/ True iff "__intN" was explicitly provided. /
6431	BOOL_BITFIELD explicit_intN_p : `1`;
6432	/ True iff "char" was explicitly provided. /
6433	BOOL_BITFIELD explicit_char_p : `1`;
6434	/ True iff ds_thread is set for __thread, not thread_local. /
6435	BOOL_BITFIELD gnu_thread_keyword_p : `1`;
6436	/ True iff the type is a decltype. /
6437	BOOL_BITFIELD decltype_p : `1`;
6438	/ True iff the alternate "__intN__" form of the __intN type has been*
6439	used. /*
6440	BOOL_BITFIELD int_n_alt: `1`;
6441	};
6442
6443	/ The various kinds of declarators. /
6444
6445	enum cp_declarator_kind {
6446	cdk_id,
6447	cdk_function,
6448	cdk_array,
6449	cdk_pointer,
6450	cdk_reference,
6451	cdk_ptrmem,
6452	cdk_decomp,
6453	cdk_error
6454	};
6455
6456	/ A declarator. /
6457
6458	typedef struct cp_declarator cp_declarator;
6459
6460	typedef struct cp_parameter_declarator cp_parameter_declarator;
6461
6462	/ A parameter, before it has been semantically analyzed. /
6463	struct cp_parameter_declarator {
6464	/ The next parameter, or NULL_TREE if none. /
6465	cp_parameter_declarator *next;
6466	/ The decl-specifiers-seq for the parameter. /
6467	cp_decl_specifier_seq decl_specifiers;
6468	/ The declarator for the parameter. /
6469	cp_declarator *declarator;
6470	/ The default-argument expression, or NULL_TREE, if none. /
6471	tree default_argument;
6472	/ True iff this is a template parameter pack. /
6473	bool template_parameter_pack_p;
6474	/ Location within source. /
6475	location_t loc;
6476	};
6477
6478	/ A declarator. /
6479	struct cp_declarator {
6480	/ The kind of declarator. /
6481	ENUM_BITFIELD (cp_declarator_kind) kind : `4`;
6482	/ Whether we parsed an ellipsis (`...') just before the declarator,*
6483	to indicate this is a parameter pack. /*
6484	BOOL_BITFIELD parameter_pack_p : `1`;
6485	/ If this declarator is parenthesized, this the open-paren. It is*
6486	UNKNOWN_LOCATION when not parenthesized. /*
6487	location_t parenthesized;
6488	/ Currently only set for cdk_id, cdk_decomp and cdk_function. /
6489	location_t id_loc;
6490	/ If this declarator is part of an init-declarator, the location of the*
6491	initializer. /*
6492	location_t init_loc;
6493	/ GNU Attributes that apply to this declarator. If the declarator*
6494	is a pointer or a reference, these attribute apply to the type
6495	pointed to. /*
6496	tree attributes;
6497	/ Standard C++11 attributes that apply to this declarator. If the*
6498	declarator is a pointer or a reference, these attributes apply
6499	to the pointer, rather than to the type pointed to. /*
6500	tree std_attributes;
6501	/ For all but cdk_id, cdk_decomp and cdk_error, the contained declarator.*
6502	For cdk_id, cdk_decomp and cdk_error, guaranteed to be NULL. /*
6503	cp_declarator *declarator;
6504	union {
6505	/ For identifiers. /
6506	struct {
6507	/ If non-NULL, the qualifying scope (a NAMESPACE_DECL or*
6508	_TYPE) for this identifier. /
6509	tree qualifying_scope;
6510	/ The unqualified name of the entity -- an IDENTIFIER_NODE,*
6511	BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. /*
6512	tree unqualified_name;
6513	/ If this is the name of a function, what kind of special*
6514	function (if any). /*
6515	special_function_kind sfk;
6516	} id;
6517	/ For functions. /
6518	struct {
6519	/ The parameters to the function as a TREE_LIST of decl/default. /
6520	tree parameters;
6521	/ The cv-qualifiers for the function. /
6522	cp_cv_quals qualifiers;
6523	/ The virt-specifiers for the function. /
6524	cp_virt_specifiers virt_specifiers;
6525	/ The ref-qualifier for the function. /
6526	cp_ref_qualifier ref_qualifier;
6527	/ The transaction-safety qualifier for the function. /
6528	tree tx_qualifier;
6529	/ The exception-specification for the function. /
6530	tree exception_specification;
6531	/ The late-specified return type, if any. /
6532	tree late_return_type;
6533	/ The trailing requires-clause, if any. /
6534	tree requires_clause;
6535	location_t parens_loc;
6536	} function;
6537	/ For arrays. /
6538	struct {
6539	/ The bounds to the array. /
6540	tree bounds;
6541	} array;
6542	/ For cdk_pointer and cdk_ptrmem. /
6543	struct {
6544	/ The cv-qualifiers for the pointer. /
6545	cp_cv_quals qualifiers;
6546	/ For cdk_ptrmem, the class type containing the member. /
6547	tree class_type;
6548	} pointer;
6549	/ For cdk_reference /
6550	struct {
6551	/ The cv-qualifiers for the reference. These qualifiers are*
6552	only used to diagnose ill-formed code. /*
6553	cp_cv_quals qualifiers;
6554	/ Whether this is an rvalue reference /
6555	bool rvalue_ref;
6556	} reference;
6557	} u;
6558	};
6559
6560	/ A level of template instantiation. /
6561	struct GTY((chain_next ("%h.next"))) tinst_level {
6562	/ The immediately deeper level in the chain. /
6563	struct tinst_level *next;
6564
6565	/ The original node. TLDCL can be a DECL (for a function or static*
6566	data member), a TYPE (for a class), depending on what we were
6567	asked to instantiate, or a TREE_LIST with the template as PURPOSE
6568	and the template args as VALUE, if we are substituting for
6569	overload resolution. In all these cases, TARGS is NULL.
6570	However, to avoid creating TREE_LIST objects for substitutions if
6571	we can help, we store PURPOSE and VALUE in TLDCL and TARGS,
6572	respectively. So TLDCL stands for TREE_LIST or DECL (the
6573	template is a DECL too), whereas TARGS stands for the template
6574	arguments. /*
6575	tree tldcl, targs;
6576
6577	/ For modules we need to know (a) the modules on the path of*
6578	instantiation and (b) the transitive imports along that path.
6579	Note that these two bitmaps may be inherited from NEXT, if this
6580	decl is in the same module as NEXT (or has no new information). /*
6581	bitmap path;
6582	bitmap visible;
6583
6584	private:
6585	/ Return TRUE iff the original node is a split list. /
6586	bool split_list_p () const { return targs; }
6587
6588	/ Return TRUE iff the original node is a TREE_LIST object. /
6589	bool tree_list_p () const
6590	{
6591	return !split_list_p () && TREE_CODE (tldcl) == TREE_LIST;
6592	}
6593
6594	/ Return TRUE iff the original node is not a list, split or not. /
6595	bool not_list_p () const
6596	{
6597	return !split_list_p () && !tree_list_p ();
6598	}
6599
6600	/ Convert (in place) the original node from a split list to a*
6601	TREE_LIST. /*
6602	tree to_list ();
6603
6604	public:
6605	/ Release storage for OBJ and node, if it's a TREE_LIST. /
6606	static void free (tinst_level *obj);
6607
6608	/ Return TRUE iff the original node is a list, split or not. /
6609	bool list_p () const { return !not_list_p (); }
6610
6611	/ Return the original node; if it's a split list, make it a*
6612	TREE_LIST first, so that it can be returned as a single tree
6613	object. /*
6614	tree get_node () {
6615	if (!split_list_p ()) return tldcl;
6616	else return to_list ();
6617	}
6618
6619	/ Return the original node if it's a DECL or a TREE_LIST, but do*
6620	NOT convert a split list to a TREE_LIST: return NULL instead. /*
6621	tree maybe_get_node () const {
6622	if (!split_list_p ()) return tldcl;
6623	else return NULL_TREE;
6624	}
6625
6626	/ The location where the template is instantiated. /
6627	location_t locus;
6628
6629	/ errorcount + sorrycount when we pushed this level. /
6630	unsigned short errors;
6631
6632	/ Count references to this object. If refcount reaches*
6633	refcount_infinity value, we don't increment or decrement the
6634	refcount anymore, as the refcount isn't accurate anymore.
6635	The object can be still garbage collected if unreferenced from
6636	anywhere, which might keep referenced objects referenced longer than
6637	otherwise necessary. Hitting the infinity is rare though. /*
6638	unsigned short refcount;
6639
6640	/ Infinity value for the above refcount. /
6641	static const unsigned short refcount_infinity = (unsigned short) ~`0`;
6642	};
6643
6644	/ BUILT_IN_FRONTEND function codes. /
6645	enum cp_built_in_function {
6646	CP_BUILT_IN_IS_CONSTANT_EVALUATED,
6647	CP_BUILT_IN_INTEGER_PACK,
6648	CP_BUILT_IN_IS_CORRESPONDING_MEMBER,
6649	CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS,
6650	CP_BUILT_IN_SOURCE_LOCATION,
6651	CP_BUILT_IN_LAST
6652	};
6653
6654	bool decl_spec_seq_has_spec_p (const cp_decl_specifier_seq *, cp_decl_spec);
6655
6656	/ Return the type of the `this' parameter of FNTYPE. /
6657
6658	inline tree
6659	type_of_this_parm (const_tree fntype)
6660	{
6661	function_args_iterator iter;
6662	gcc_assert (TREE_CODE (fntype) == METHOD_TYPE);
6663	function_args_iter_init (i: &iter, fntype);
6664	return function_args_iter_cond (i: &iter);
6665	}
6666
6667	/ Return the class of the `this' parameter of FNTYPE. /
6668
6669	inline tree
6670	class_of_this_parm (const_tree fntype)
6671	{
6672	return TREE_TYPE (type_of_this_parm (fntype));
6673	}
6674
6675	/ A parameter list indicating for a function with no parameters,*
6676	e.g "int f(void)". /*
6677	extern cp_parameter_declarator *no_parameters;
6678
6679	/ Various dump ids. /
6680	extern int class_dump_id;
6681	extern int module_dump_id;
6682	extern int raw_dump_id;
6683
6684	/ Whether the current context is manifestly constant-evaluated.*
6685	Used by the constexpr machinery to control folding of
6686	__builtin_is_constant_evaluated. /*
6687
6688	enum class mce_value
6689	{
6690	/ Unknown, so treat __builtin_is_constant_evaluated as non-constant. /
6691	mce_unknown = `0`,
6692	/ Fold it to true. /
6693	mce_true = `1`,
6694	/ Fold it to false. Primarily used during cp_fold_function and*
6695	cp_fully_fold_init. /*
6696	mce_false = -`1`,
6697	};
6698	constexpr mce_value mce_unknown = mce_value::mce_unknown;
6699	constexpr mce_value mce_true = mce_value::mce_true;
6700	constexpr mce_value mce_false = mce_value::mce_false;
6701
6702	/ in call.cc /
6703	extern bool check_dtor_name (tree, tree);
6704	int magic_varargs_p (tree);
6705
6706	extern tree build_conditional_expr (const op_location_t &,
6707	tree, tree, tree,
6708	tsubst_flags_t);
6709	extern tree build_addr_func (tree, tsubst_flags_t);
6710	extern void set_flags_from_callee (tree);
6711	extern tree build_call_a (tree, int, tree*);
6712	extern tree build_call_n (tree, int, ...);
6713	extern bool null_ptr_cst_p (tree);
6714	extern bool null_member_pointer_value_p (tree);
6715	extern bool sufficient_parms_p (const_tree);
6716	extern tree type_decays_to (tree);
6717	extern tree extract_call_expr (tree);
6718	extern tree build_trivial_dtor_call (tree, bool = false);
6719	extern tristate ref_conv_binds_to_temporary (tree, tree, bool = false);
6720	extern tree build_user_type_conversion (tree, tree, int,
6721	tsubst_flags_t);
6722	extern tree build_new_function_call (tree, vec<tree, va_gc> **,
6723	tsubst_flags_t);
6724	extern tree build_operator_new_call (tree, vec<tree, va_gc> **,
6725	tree , tree , tree, tree,
6726	tree *, tsubst_flags_t);
6727	extern tree build_new_method_call (tree, tree,
6728	vec<tree, va_gc> **, tree,
6729	int, tree *, tsubst_flags_t);
6730	extern tree build_special_member_call (tree, tree,
6731	vec<tree, va_gc> **,
6732	tree, int, tsubst_flags_t);
6733	extern tree build_new_op (const op_location_t &,
6734	enum tree_code,
6735	int, tree, tree, tree, tree,
6736	tree *, tsubst_flags_t);
6737	/ Wrapper that leaves out the usually-null op3 and overload parms. /
6738	inline tree build_new_op (const op_location_t &loc, enum tree_code code,
6739	int flags, tree arg1, tree arg2,
6740	tsubst_flags_t complain)
6741	{
6742	return build_new_op (loc, code, flags, arg1, arg2, NULL_TREE, NULL_TREE,
6743	NULL, complain);
6744	}
6745	extern tree keep_unused_object_arg (tree, tree, tree);
6746	extern tree build_op_call (tree, vec<tree, va_gc> **,
6747	tsubst_flags_t);
6748	extern tree build_op_subscript (const op_location_t &, tree,
6749	vec<tree, va_gc> *, tree ,
6750	tsubst_flags_t);
6751	extern bool aligned_allocation_fn_p (tree);
6752	extern tree destroying_delete_p (tree);
6753	extern bool usual_deallocation_fn_p (tree);
6754	extern tree build_op_delete_call (enum tree_code, tree, tree,
6755	bool, tree, tree,
6756	tsubst_flags_t);
6757	extern bool can_convert (tree, tree, tsubst_flags_t);
6758	extern bool can_convert_standard (tree, tree, tsubst_flags_t);
6759	extern bool can_convert_arg (tree, tree, tree, int,
6760	tsubst_flags_t);
6761	extern bool can_convert_arg_bad (tree, tree, tree, int,
6762	tsubst_flags_t);
6763	extern int conv_flags (int, int, tree, tree, int);
6764	extern struct conversion * good_conversion (tree, tree, tree, int, tsubst_flags_t);
6765	extern location_t get_fndecl_argument_location (tree, int);
6766	extern void complain_about_bad_argument (location_t arg_loc,
6767	tree from_type, tree to_type,
6768	tree fndecl, int parmnum);
6769	extern void maybe_inform_about_fndecl_for_bogus_argument_init (tree, int);
6770	extern tree perform_dguide_overload_resolution (tree, const vec<tree, va_gc> *,
6771	tsubst_flags_t);
6772
6773
6774	/ A class for recording information about access failures (e.g. private*
6775	fields), so that we can potentially supply a fix-it hint about
6776	an accessor (from a context in which the constness of the object
6777	is known). /*
6778
6779	class access_failure_info
6780	{
6781	public:
6782	access_failure_info () : m_was_inaccessible (false),
6783	m_basetype_path (NULL_TREE),
6784	m_decl (NULL_TREE), m_diag_decl (NULL_TREE) {}
6785
6786	void record_access_failure (tree basetype_path, tree decl, tree diag_decl);
6787
6788	bool was_inaccessible_p () const { return m_was_inaccessible; }
6789	tree get_decl () const { return m_decl; }
6790	tree get_diag_decl () const { return m_diag_decl; }
6791	tree get_any_accessor (bool const_p) const;
6792	void maybe_suggest_accessor (bool const_p) const;
6793	static void add_fixit_hint (rich_location *richloc, tree accessor);
6794
6795	private:
6796	bool m_was_inaccessible;
6797	tree m_basetype_path;
6798	tree m_decl;
6799	tree m_diag_decl;
6800	};
6801
6802	extern void complain_about_access (tree, tree, tree, bool,
6803	access_kind);
6804	extern void push_defarg_context (tree);
6805	extern void pop_defarg_context (void);
6806	extern tree convert_default_arg (tree, tree, tree, int,
6807	tsubst_flags_t);
6808	extern tree convert_arg_to_ellipsis (tree, tsubst_flags_t);
6809	extern tree build_x_va_arg (location_t, tree, tree);
6810	extern tree cxx_type_promotes_to (tree);
6811	extern tree type_passed_as (tree);
6812	extern tree convert_for_arg_passing (tree, tree, tsubst_flags_t);
6813	extern bool is_properly_derived_from (tree, tree);
6814	extern tree initialize_reference (tree, tree, int,
6815	tsubst_flags_t);
6816	extern tree extend_ref_init_temps (tree, tree,
6817	vec<tree, va_gc>**,
6818	tree * = NULL);
6819	extern tree make_temporary_var_for_ref_to_temp (tree, tree);
6820	extern bool type_has_extended_temps (tree);
6821	extern tree strip_top_quals (tree);
6822	extern bool reference_related_p (tree, tree);
6823	extern bool reference_compatible_p (tree, tree);
6824	extern int remaining_arguments (tree);
6825	extern tree build_implicit_conv_flags (tree, tree, int);
6826	extern tree perform_implicit_conversion (tree, tree, tsubst_flags_t);
6827	extern tree perform_implicit_conversion_flags (tree, tree, tsubst_flags_t, int);
6828	extern tree build_converted_constant_expr (tree, tree, tsubst_flags_t);
6829	extern tree build_converted_constant_bool_expr (tree, tsubst_flags_t);
6830	extern tree perform_direct_initialization_if_possible (tree, tree, bool,
6831	tsubst_flags_t);
6832	extern vec<tree,va_gc> resolve_args (vec<tree,va_gc>, tsubst_flags_t);
6833	extern tree in_charge_arg_for_name (tree);
6834	extern bool in_immediate_context ();
6835	extern bool immediate_invocation_p (tree);
6836	extern tree build_cxx_call (tree, int, tree *,
6837	tsubst_flags_t,
6838	tree = NULL_TREE);
6839	extern bool is_std_init_list (tree);
6840	extern bool is_list_ctor (tree);
6841	extern void validate_conversion_obstack (void);
6842	extern void mark_versions_used (tree);
6843	extern int unsafe_return_slot_p (tree);
6844	extern bool unsafe_copy_elision_p (tree, tree);
6845	extern bool make_safe_copy_elision (tree, tree);
6846	extern bool cp_handle_deprecated_or_unavailable (tree, tsubst_flags_t = tf_warning_or_error);
6847	extern void cp_warn_deprecated_use_scopes (tree);
6848	extern tree get_function_version_dispatcher (tree);
6849	extern bool any_template_arguments_need_structural_equality_p (tree);
6850	extern void maybe_show_nonconverting_candidate (tree, tree, tree, int);
6851	extern bool conv_binds_to_reference_parm_p (tree, tree);
6852
6853	/ in class.cc /
6854	extern tree build_vfield_ref (tree, tree);
6855	extern tree build_if_in_charge (tree true_stmt, tree false_stmt = void_node);
6856	extern tree build_base_path (enum tree_code, tree,
6857	tree, int, tsubst_flags_t);
6858	extern tree convert_to_base (tree, tree, bool, bool,
6859	tsubst_flags_t);
6860	extern tree convert_to_base_statically (tree, tree);
6861	extern bool is_empty_base_ref (tree);
6862	extern tree build_vtbl_ref (tree, tree);
6863	extern tree build_vfn_ref (tree, tree);
6864	extern tree get_vtable_decl (tree, int);
6865	extern bool object_parms_correspond (tree, tree, tree);
6866	extern bool iobj_parm_corresponds_to (tree, tree, tree);
6867	extern bool add_method (tree, tree, bool);
6868	extern tree declared_access (tree);
6869	extern bool maybe_push_used_methods (tree);
6870	extern tree currently_open_class (tree);
6871	extern tree currently_open_derived_class (tree);
6872	extern tree outermost_open_class (void);
6873	extern tree current_nonlambda_class_type (void);
6874	extern tree finish_struct (tree, tree);
6875	extern void finish_struct_1 (tree);
6876	extern int resolves_to_fixed_type_p (tree, int * = NULL);
6877	extern void init_class_processing (void);
6878	extern int is_empty_class (tree);
6879	extern bool is_really_empty_class (tree, bool);
6880	extern void pushclass (tree);
6881	extern void popclass (void);
6882	extern void push_nested_class (tree);
6883	extern void pop_nested_class (void);
6884	extern int current_lang_depth (void);
6885	extern void push_lang_context (tree);
6886	extern void pop_lang_context (void);
6887	extern tree instantiate_type (tree, tree, tsubst_flags_t);
6888	extern void build_self_reference (void);
6889	extern int same_signature_p (const_tree, const_tree);
6890	extern tree lookup_vfn_in_binfo (tree, tree);
6891	extern void maybe_add_class_template_decl_list (tree, tree, int);
6892	extern void unreverse_member_declarations (tree);
6893	extern bool is_empty_field (tree);
6894	extern void invalidate_class_lookup_cache (void);
6895	extern void maybe_note_name_used_in_class (tree, tree);
6896	extern void note_name_declared_in_class (tree, tree);
6897	extern tree get_vtbl_decl_for_binfo (tree);
6898	extern bool vptr_via_virtual_p (tree);
6899	extern void debug_class (tree);
6900	extern void debug_thunks (tree);
6901	extern void set_linkage_according_to_type (tree, tree);
6902	extern void determine_key_method (tree);
6903	extern void check_for_override (tree, tree);
6904	extern void push_class_stack (void);
6905	extern void pop_class_stack (void);
6906	extern bool default_ctor_p (const_tree);
6907	extern bool type_has_user_nondefault_constructor (tree);
6908	extern tree in_class_defaulted_default_constructor (tree);
6909	extern bool user_provided_p (tree);
6910	extern bool type_has_user_provided_constructor (tree);
6911	extern bool type_has_non_user_provided_default_constructor (tree);
6912	extern bool vbase_has_user_provided_move_assign (tree);
6913	extern tree default_init_uninitialized_part (tree);
6914	extern bool trivial_default_constructor_is_constexpr (tree);
6915	extern bool type_has_constexpr_default_constructor (tree);
6916	extern bool type_has_constexpr_destructor (tree);
6917	extern bool type_has_virtual_destructor (tree);
6918	extern bool type_has_non_deleted_trivial_default_ctor (tree);
6919	extern bool classtype_has_move_assign_or_move_ctor_p (tree, bool user_declared);
6920	extern bool classtype_has_non_deleted_move_ctor (tree);
6921	extern tree classtype_has_depr_implicit_copy (tree);
6922	extern bool classtype_has_op (tree, tree_code);
6923	extern tree classtype_has_defaulted_op (tree, tree_code);
6924	extern bool type_build_ctor_call (tree);
6925	extern bool type_build_dtor_call (tree);
6926	extern void explain_non_literal_class (tree);
6927	extern void inherit_targ_abi_tags (tree);
6928	extern void defaulted_late_check (tree);
6929	extern bool defaultable_fn_check (tree);
6930	extern void check_abi_tags (tree);
6931	extern tree missing_abi_tags (tree);
6932	extern void fixup_type_variants (tree);
6933	extern void fixup_attribute_variants (tree);
6934	extern void build_cdtor_clones (tree, bool, bool, bool);
6935	extern void clone_cdtor (tree, bool);
6936	extern tree copy_operator_fn (tree, tree_code code);
6937	extern void adjust_clone_args (tree);
6938	extern void deduce_noexcept_on_destructor (tree);
6939	extern bool uniquely_derived_from_p (tree, tree);
6940	extern bool publicly_uniquely_derived_p (tree, tree);
6941	extern tree common_enclosing_class (tree, tree);
6942
6943	/ in cvt.cc /
6944	extern tree convert_to_reference (tree, tree, int, int, tree,
6945	tsubst_flags_t);
6946	extern tree convert_from_reference (tree);
6947	extern tree force_rvalue (tree, tsubst_flags_t);
6948	extern tree ocp_convert (tree, tree, int, int,
6949	tsubst_flags_t);
6950	extern tree cp_convert (tree, tree, tsubst_flags_t);
6951	extern tree cp_convert_and_check (tree, tree, tsubst_flags_t);
6952	extern tree cp_fold_convert (tree, tree);
6953	extern tree cp_get_callee (tree);
6954	extern tree cp_get_callee_fndecl (tree);
6955	extern tree cp_get_callee_fndecl_nofold (tree);
6956	extern tree cp_get_fndecl_from_callee (tree, bool fold = true);
6957	extern tree convert_to_void (tree, impl_conv_void,
6958	tsubst_flags_t);
6959	extern tree convert_force (tree, tree, int,
6960	tsubst_flags_t);
6961	extern tree build_expr_type_conversion (int, tree, bool);
6962	extern tree type_promotes_to (tree);
6963	extern bool can_convert_qual (tree, tree);
6964	extern tree perform_qualification_conversions (tree, tree);
6965	extern bool tx_safe_fn_type_p (tree);
6966	extern tree tx_unsafe_fn_variant (tree);
6967	extern bool fnptr_conv_p (tree, tree);
6968	extern tree strip_fnptr_conv (tree);
6969
6970	/ in name-lookup.cc /
6971	extern void maybe_push_cleanup_level (tree);
6972	extern tree maybe_push_decl (tree);
6973	extern tree current_decl_namespace (void);
6974
6975	/ decl.cc /
6976	extern tree poplevel (int, int, int);
6977	extern void cxx_init_decl_processing (void);
6978	enum cp_tree_node_structure_enum cp_tree_node_structure
6979	(union lang_tree_node *);
6980	extern void finish_scope (void);
6981	extern void push_switch (tree);
6982	extern void pop_switch (void);
6983	extern void note_break_stmt (void);
6984	extern bool note_iteration_stmt_body_start (void);
6985	extern void note_iteration_stmt_body_end (bool);
6986	extern void determine_local_discriminator (tree, tree = NULL_TREE);
6987	extern bool member_like_constrained_friend_p (tree);
6988	extern bool fns_correspond (tree, tree);
6989	extern int decls_match (tree, tree, bool = true);
6990	extern bool maybe_version_functions (tree, tree, bool);
6991	extern bool merge_default_template_args (tree, tree, bool);
6992	extern tree duplicate_decls (tree, tree,
6993	bool hiding = false,
6994	bool was_hidden = false);
6995	extern void mark_label_addressed (tree);
6996	extern tree declare_local_label (tree);
6997	extern tree define_label (location_t, tree);
6998	extern void check_goto (tree);
6999	extern bool check_omp_return (void);
7000	extern tree make_typename_type (tree, tree, enum tag_types, tsubst_flags_t);
7001	extern tree build_typename_type (tree, tree, tree, tag_types);
7002	extern tree make_unbound_class_template (tree, tree, tree, tsubst_flags_t);
7003	extern