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

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