1 /* Definitions for C++ parsing and type checking.
2 Copyright (C) 1987-2016 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
11
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
20
21 #ifndef GCC_CP_TREE_H
22 #define GCC_CP_TREE_H
23
24 #include "tm.h"
25 #include "hard-reg-set.h"
26 #include "function.h"
27
28 /* In order for the format checking to accept the C++ front end
29 diagnostic framework extensions, you must include this file before
30 diagnostic-core.h, not after. We override the definition of GCC_DIAG_STYLE
31 in c-common.h. */
32 #undef GCC_DIAG_STYLE
33 #define GCC_DIAG_STYLE __gcc_cxxdiag__
34 #if defined(GCC_DIAGNOSTIC_CORE_H) || defined (GCC_C_COMMON_H)
35 #error \
36 In order for the format checking to accept the C++ front end diagnostic \
37 framework extensions, you must include this file before diagnostic-core.h and \
38 c-common.h, not after.
39 #endif
40 #include "c-family/c-common.h"
41 #include "diagnostic.h"
42
43 /* A tree node, together with a location, so that we can track locations
44 (and ranges) during parsing.
45
46 The location is redundant for node kinds that have locations,
47 but not all node kinds do (e.g. constants, and references to
48 params, locals, etc), so we stash a copy here. */
49
50 class cp_expr
51 {
52 public:
cp_expr()53 cp_expr () :
54 m_value (NULL), m_loc (UNKNOWN_LOCATION) {}
55
cp_expr(tree value)56 cp_expr (tree value) :
57 m_value (value), m_loc (EXPR_LOCATION (m_value)) {}
58
cp_expr(tree value,location_t loc)59 cp_expr (tree value, location_t loc):
60 m_value (value), m_loc (loc) {}
61
cp_expr(const cp_expr & other)62 cp_expr (const cp_expr &other) :
63 m_value (other.m_value), m_loc (other.m_loc) {}
64
65 /* Implicit conversions to tree. */
tree()66 operator tree () const { return m_value; }
67 tree & operator* () { return m_value; }
68 tree & operator-> () { return m_value; }
69
get_value()70 tree get_value () const { return m_value; }
get_location()71 location_t get_location () const { return m_loc; }
get_start()72 location_t get_start () const
73 {
74 source_range src_range = get_range_from_loc (line_table, m_loc);
75 return src_range.m_start;
76 }
get_finish()77 location_t get_finish () const
78 {
79 source_range src_range = get_range_from_loc (line_table, m_loc);
80 return src_range.m_finish;
81 }
82
set_location(location_t loc)83 void set_location (location_t loc)
84 {
85 protected_set_expr_location (m_value, loc);
86 m_loc = loc;
87 }
88
set_range(location_t start,location_t finish)89 void set_range (location_t start, location_t finish)
90 {
91 set_location (make_location (m_loc, start, finish));
92 }
93
94 private:
95 tree m_value;
96 location_t m_loc;
97 };
98
99 inline bool
100 operator == (const cp_expr &lhs, tree rhs)
101 {
102 return lhs.get_value () == rhs;
103 }
104
105 #include "name-lookup.h"
106
107 /* Usage of TREE_LANG_FLAG_?:
108 0: IDENTIFIER_MARKED (IDENTIFIER_NODEs)
109 NEW_EXPR_USE_GLOBAL (in NEW_EXPR).
110 COND_EXPR_IS_VEC_DELETE (in COND_EXPR).
111 DELETE_EXPR_USE_GLOBAL (in DELETE_EXPR).
112 COMPOUND_EXPR_OVERLOADED (in COMPOUND_EXPR).
113 CLEANUP_P (in TRY_BLOCK)
114 AGGR_INIT_VIA_CTOR_P (in AGGR_INIT_EXPR)
115 PTRMEM_OK_P (in ADDR_EXPR, OFFSET_REF, SCOPE_REF)
116 PAREN_STRING_LITERAL (in STRING_CST)
117 CP_DECL_THREAD_LOCAL_P (in VAR_DECL)
118 KOENIG_LOOKUP_P (in CALL_EXPR)
119 STATEMENT_LIST_NO_SCOPE (in STATEMENT_LIST).
120 EXPR_STMT_STMT_EXPR_RESULT (in EXPR_STMT)
121 STMT_EXPR_NO_SCOPE (in STMT_EXPR)
122 BIND_EXPR_TRY_BLOCK (in BIND_EXPR)
123 TYPENAME_IS_ENUM_P (in TYPENAME_TYPE)
124 OMP_FOR_GIMPLIFYING_P (in OMP_FOR, OMP_SIMD, OMP_DISTRIBUTE,
125 and OMP_TASKLOOP)
126 BASELINK_QUALIFIED_P (in BASELINK)
127 TARGET_EXPR_IMPLICIT_P (in TARGET_EXPR)
128 TEMPLATE_PARM_PARAMETER_PACK (in TEMPLATE_PARM_INDEX)
129 TREE_INDIRECT_USING (in a TREE_LIST of using-directives)
130 ATTR_IS_DEPENDENT (in the TREE_LIST for an attribute)
131 ABI_TAG_IMPLICIT (in the TREE_LIST for the argument of abi_tag)
132 CONSTRUCTOR_IS_DIRECT_INIT (in CONSTRUCTOR)
133 LAMBDA_EXPR_CAPTURES_THIS_P (in LAMBDA_EXPR)
134 DECLTYPE_FOR_LAMBDA_CAPTURE (in DECLTYPE_TYPE)
135 VEC_INIT_EXPR_IS_CONSTEXPR (in VEC_INIT_EXPR)
136 DECL_OVERRIDE_P (in FUNCTION_DECL)
137 IMPLICIT_CONV_EXPR_DIRECT_INIT (in IMPLICIT_CONV_EXPR)
138 TRANSACTION_EXPR_IS_STMT (in TRANSACTION_EXPR)
139 CONVERT_EXPR_VBASE_PATH (in CONVERT_EXPR)
140 OVL_ARG_DEPENDENT (in OVERLOAD)
141 PACK_EXPANSION_LOCAL_P (in *_PACK_EXPANSION)
142 TINFO_HAS_ACCESS_ERRORS (in TEMPLATE_INFO)
143 SIZEOF_EXPR_TYPE_P (in SIZEOF_EXPR)
144 COMPOUND_REQ_NOEXCEPT_P (in COMPOUND_REQ)
145 WILDCARD_PACK_P (in WILDCARD_DECL)
146 BLOCK_OUTER_CURLY_BRACE_P (in BLOCK)
147 FOLD_EXPR_MODOP_P (*_FOLD_EXPR)
148 1: IDENTIFIER_VIRTUAL_P (in IDENTIFIER_NODE)
149 TI_PENDING_TEMPLATE_FLAG.
150 TEMPLATE_PARMS_FOR_INLINE.
151 DELETE_EXPR_USE_VEC (in DELETE_EXPR).
152 (TREE_CALLS_NEW) (in _EXPR or _REF) (commented-out).
153 ICS_ELLIPSIS_FLAG (in _CONV)
154 DECL_INITIALIZED_P (in VAR_DECL)
155 TYPENAME_IS_CLASS_P (in TYPENAME_TYPE)
156 STMT_IS_FULL_EXPR_P (in _STMT)
157 TARGET_EXPR_LIST_INIT_P (in TARGET_EXPR)
158 LAMBDA_EXPR_MUTABLE_P (in LAMBDA_EXPR)
159 DECL_FINAL_P (in FUNCTION_DECL)
160 QUALIFIED_NAME_IS_TEMPLATE (in SCOPE_REF)
161 DECLTYPE_FOR_INIT_CAPTURE (in DECLTYPE_TYPE)
162 CONSTRUCTOR_NO_IMPLICIT_ZERO (in CONSTRUCTOR)
163 TINFO_USED_TEMPLATE_ID (in TEMPLATE_INFO)
164 PACK_EXPANSION_SIZEOF_P (in *_PACK_EXPANSION)
165 2: IDENTIFIER_OPNAME_P (in IDENTIFIER_NODE)
166 ICS_THIS_FLAG (in _CONV)
167 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (in VAR_DECL)
168 STATEMENT_LIST_TRY_BLOCK (in STATEMENT_LIST)
169 TYPENAME_IS_RESOLVING_P (in TYPE_NAME_TYPE)
170 TARGET_EXPR_DIRECT_INIT_P (in TARGET_EXPR)
171 FNDECL_USED_AUTO (in FUNCTION_DECL)
172 DECLTYPE_FOR_LAMBDA_PROXY (in DECLTYPE_TYPE)
173 REF_PARENTHESIZED_P (in COMPONENT_REF, INDIRECT_REF, SCOPE_REF)
174 AGGR_INIT_ZERO_FIRST (in AGGR_INIT_EXPR)
175 CONSTRUCTOR_MUTABLE_POISON (in CONSTRUCTOR)
176 3: (TREE_REFERENCE_EXPR) (in NON_LVALUE_EXPR) (commented-out).
177 ICS_BAD_FLAG (in _CONV)
178 FN_TRY_BLOCK_P (in TRY_BLOCK)
179 IDENTIFIER_CTOR_OR_DTOR_P (in IDENTIFIER_NODE)
180 BIND_EXPR_BODY_BLOCK (in BIND_EXPR)
181 DECL_NON_TRIVIALLY_INITIALIZED_P (in VAR_DECL)
182 CALL_EXPR_LIST_INIT_P (in CALL_EXPR, AGGR_INIT_EXPR)
183 4: TREE_HAS_CONSTRUCTOR (in INDIRECT_REF, SAVE_EXPR, CONSTRUCTOR,
184 or FIELD_DECL).
185 IDENTIFIER_TYPENAME_P (in IDENTIFIER_NODE)
186 DECL_TINFO_P (in VAR_DECL)
187 FUNCTION_REF_QUALIFIED (in FUNCTION_TYPE, METHOD_TYPE)
188 5: C_IS_RESERVED_WORD (in IDENTIFIER_NODE)
189 DECL_VTABLE_OR_VTT_P (in VAR_DECL)
190 FUNCTION_RVALUE_QUALIFIED (in FUNCTION_TYPE, METHOD_TYPE)
191 6: IDENTIFIER_REPO_CHOSEN (in IDENTIFIER_NODE)
192 DECL_CONSTRUCTION_VTABLE_P (in VAR_DECL)
193 TYPE_MARKED_P (in _TYPE)
194 RANGE_FOR_IVDEP (in RANGE_FOR_STMT)
195
196 Usage of TYPE_LANG_FLAG_?:
197 0: TYPE_DEPENDENT_P
198 1: TYPE_HAS_USER_CONSTRUCTOR.
199 2: TYPE_HAS_LATE_RETURN_TYPE (in FUNCTION_TYPE, METHOD_TYPE)
200 TYPE_PTRMEMFUNC_FLAG (in RECORD_TYPE)
201 3: TYPE_FOR_JAVA.
202 4: TYPE_HAS_NONTRIVIAL_DESTRUCTOR
203 5: CLASS_TYPE_P (in RECORD_TYPE and UNION_TYPE)
204 ENUM_FIXED_UNDERLYING_TYPE_P (in ENUMERAL_TYPE)
205 AUTO_IS_DECLTYPE (in TEMPLATE_TYPE_PARM)
206 REFERENCE_VLA_OK (in REFERENCE_TYPE)
207 6: TYPE_DEPENDENT_P_VALID
208
209 Usage of DECL_LANG_FLAG_?:
210 0: DECL_ERROR_REPORTED (in VAR_DECL).
211 DECL_TEMPLATE_PARM_P (in PARM_DECL, CONST_DECL, TYPE_DECL, or TEMPLATE_DECL)
212 DECL_LOCAL_FUNCTION_P (in FUNCTION_DECL)
213 DECL_MUTABLE_P (in FIELD_DECL)
214 DECL_DEPENDENT_P (in USING_DECL)
215 LABEL_DECL_BREAK (in LABEL_DECL)
216 1: C_TYPEDEF_EXPLICITLY_SIGNED (in TYPE_DECL).
217 DECL_TEMPLATE_INSTANTIATED (in a VAR_DECL or a FUNCTION_DECL)
218 DECL_MEMBER_TEMPLATE_P (in TEMPLATE_DECL)
219 USING_DECL_TYPENAME_P (in USING_DECL)
220 DECL_VLA_CAPTURE_P (in FIELD_DECL)
221 DECL_ARRAY_PARAMETER_P (in PARM_DECL)
222 LABEL_DECL_CONTINUE (in LABEL_DECL)
223 2: DECL_THIS_EXTERN (in VAR_DECL or FUNCTION_DECL).
224 DECL_IMPLICIT_TYPEDEF_P (in a TYPE_DECL)
225 DECL_CONSTRAINT_VAR_P (in a PARM_DECL)
226 TEMPLATE_DECL_COMPLEX_ALIAS_P (in TEMPLATE_DECL)
227 DECL_INSTANTIATING_NSDMI_P (in a FIELD_DECL)
228 3: DECL_IN_AGGR_P.
229 4: DECL_C_BIT_FIELD (in a FIELD_DECL)
230 DECL_ANON_UNION_VAR_P (in a VAR_DECL)
231 DECL_SELF_REFERENCE_P (in a TYPE_DECL)
232 DECL_INVALID_OVERRIDER_P (in a FUNCTION_DECL)
233 5: DECL_INTERFACE_KNOWN.
234 6: DECL_THIS_STATIC (in VAR_DECL or FUNCTION_DECL).
235 DECL_FIELD_IS_BASE (in FIELD_DECL)
236 TYPE_DECL_ALIAS_P (in TYPE_DECL)
237 7: DECL_DEAD_FOR_LOCAL (in VAR_DECL).
238 DECL_THUNK_P (in a member FUNCTION_DECL)
239 DECL_NORMAL_CAPTURE_P (in FIELD_DECL)
240 8: DECL_DECLARED_CONSTEXPR_P (in VAR_DECL, FUNCTION_DECL)
241
242 Usage of language-independent fields in a language-dependent manner:
243
244 TYPE_ALIAS_SET
245 This field is used by TYPENAME_TYPEs, TEMPLATE_TYPE_PARMs, and so
246 forth as a substitute for the mark bits provided in `lang_type'.
247 At present, only the six low-order bits are used.
248
249 TYPE_LANG_SLOT_1
250 For an ENUMERAL_TYPE, this is ENUM_TEMPLATE_INFO.
251 For a FUNCTION_TYPE or METHOD_TYPE, this is TYPE_RAISES_EXCEPTIONS
252
253 BINFO_VIRTUALS
254 For a binfo, this is a TREE_LIST. There is an entry for each
255 virtual function declared either in BINFO or its direct and
256 indirect primary bases.
257
258 The BV_DELTA of each node gives the amount by which to adjust the
259 `this' pointer when calling the function. If the method is an
260 overridden version of a base class method, then it is assumed
261 that, prior to adjustment, the this pointer points to an object
262 of the base class.
263
264 The BV_VCALL_INDEX of each node, if non-NULL, gives the vtable
265 index of the vcall offset for this entry.
266
267 The BV_FN is the declaration for the virtual function itself.
268
269 If BV_LOST_PRIMARY is set, it means that this entry is for a lost
270 primary virtual base and can be left null in the vtable.
271
272 BINFO_VTABLE
273 This is an expression with POINTER_TYPE that gives the value
274 to which the vptr should be initialized. Use get_vtbl_decl_for_binfo
275 to extract the VAR_DECL for the complete vtable.
276
277 DECL_VINDEX
278 This field is NULL for a non-virtual function. For a virtual
279 function, it is eventually set to an INTEGER_CST indicating the
280 index in the vtable at which this function can be found. When
281 a virtual function is declared, but before it is known what
282 function is overridden, this field is the error_mark_node.
283
284 Temporarily, it may be set to a TREE_LIST whose TREE_VALUE is
285 the virtual function this one overrides, and whose TREE_CHAIN is
286 the old DECL_VINDEX. */
287
288 /* Language-specific tree checkers. */
289
290 #define VAR_OR_FUNCTION_DECL_CHECK(NODE) \
291 TREE_CHECK2(NODE,VAR_DECL,FUNCTION_DECL)
292
293 #define TYPE_FUNCTION_OR_TEMPLATE_DECL_CHECK(NODE) \
294 TREE_CHECK3(NODE,TYPE_DECL,TEMPLATE_DECL,FUNCTION_DECL)
295
296 #define TYPE_FUNCTION_OR_TEMPLATE_DECL_P(NODE) \
297 (TREE_CODE (NODE) == TYPE_DECL || TREE_CODE (NODE) == TEMPLATE_DECL \
298 || TREE_CODE (NODE) == FUNCTION_DECL)
299
300 #define VAR_FUNCTION_OR_PARM_DECL_CHECK(NODE) \
301 TREE_CHECK3(NODE,VAR_DECL,FUNCTION_DECL,PARM_DECL)
302
303 #define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) \
304 TREE_CHECK4(NODE,VAR_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL)
305
306 #define VAR_TEMPL_TYPE_FIELD_OR_FUNCTION_DECL_CHECK(NODE) \
307 TREE_CHECK5(NODE,VAR_DECL,FIELD_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL)
308
309 #define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) \
310 TREE_CHECK(NODE,BOUND_TEMPLATE_TEMPLATE_PARM)
311
312 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
313 #define THUNK_FUNCTION_CHECK(NODE) __extension__ \
314 ({ __typeof (NODE) const __t = (NODE); \
315 if (TREE_CODE (__t) != FUNCTION_DECL || !__t->decl_common.lang_specific \
316 || !__t->decl_common.lang_specific->u.fn.thunk_p) \
317 tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, 0); \
318 __t; })
319 #else
320 #define THUNK_FUNCTION_CHECK(NODE) (NODE)
321 #endif
322
323 /* Language-dependent contents of an identifier. */
324
325 struct GTY(()) lang_identifier {
326 struct c_common_identifier c_common;
327 cxx_binding *namespace_bindings;
328 cxx_binding *bindings;
329 tree class_template_info;
330 tree label_value;
331 };
332
333 /* Return a typed pointer version of T if it designates a
334 C++ front-end identifier. */
335 inline lang_identifier*
identifier_p(tree t)336 identifier_p (tree t)
337 {
338 if (TREE_CODE (t) == IDENTIFIER_NODE)
339 return (lang_identifier*) t;
340 return NULL;
341 }
342
343 /* In an IDENTIFIER_NODE, nonzero if this identifier is actually a
344 keyword. C_RID_CODE (node) is then the RID_* value of the keyword,
345 and C_RID_YYCODE is the token number wanted by Yacc. */
346
347 #define C_IS_RESERVED_WORD(ID) TREE_LANG_FLAG_5 (ID)
348
349 #define LANG_IDENTIFIER_CAST(NODE) \
350 ((struct lang_identifier*)IDENTIFIER_NODE_CHECK (NODE))
351
352 struct GTY(()) template_parm_index {
353 struct tree_common common;
354 int index;
355 int level;
356 int orig_level;
357 tree decl;
358 };
359
360 struct GTY(()) ptrmem_cst {
361 struct tree_common common;
362 tree member;
363 };
364 typedef struct ptrmem_cst * ptrmem_cst_t;
365
366 #define IDENTIFIER_GLOBAL_VALUE(NODE) \
367 namespace_binding ((NODE), global_namespace)
368 #define SET_IDENTIFIER_GLOBAL_VALUE(NODE, VAL) \
369 set_namespace_binding ((NODE), global_namespace, (VAL))
370 #define IDENTIFIER_NAMESPACE_VALUE(NODE) \
371 namespace_binding ((NODE), current_namespace)
372 #define SET_IDENTIFIER_NAMESPACE_VALUE(NODE, VAL) \
373 set_namespace_binding ((NODE), current_namespace, (VAL))
374
375 #define CLEANUP_P(NODE) TREE_LANG_FLAG_0 (TRY_BLOCK_CHECK (NODE))
376
377 #define BIND_EXPR_TRY_BLOCK(NODE) \
378 TREE_LANG_FLAG_0 (BIND_EXPR_CHECK (NODE))
379
380 /* Used to mark the block around the member initializers and cleanups. */
381 #define BIND_EXPR_BODY_BLOCK(NODE) \
382 TREE_LANG_FLAG_3 (BIND_EXPR_CHECK (NODE))
383 #define FUNCTION_NEEDS_BODY_BLOCK(NODE) \
384 (DECL_CONSTRUCTOR_P (NODE) || DECL_DESTRUCTOR_P (NODE) \
385 || LAMBDA_FUNCTION_P (NODE))
386
387 #define STATEMENT_LIST_NO_SCOPE(NODE) \
388 TREE_LANG_FLAG_0 (STATEMENT_LIST_CHECK (NODE))
389 #define STATEMENT_LIST_TRY_BLOCK(NODE) \
390 TREE_LANG_FLAG_2 (STATEMENT_LIST_CHECK (NODE))
391
392 /* Mark the outer curly brace BLOCK. */
393 #define BLOCK_OUTER_CURLY_BRACE_P(NODE) TREE_LANG_FLAG_0 (BLOCK_CHECK (NODE))
394
395 /* Nonzero if this statement should be considered a full-expression,
396 i.e., if temporaries created during this statement should have
397 their destructors run at the end of this statement. */
398 #define STMT_IS_FULL_EXPR_P(NODE) TREE_LANG_FLAG_1 ((NODE))
399
400 /* Marks the result of a statement expression. */
401 #define EXPR_STMT_STMT_EXPR_RESULT(NODE) \
402 TREE_LANG_FLAG_0 (EXPR_STMT_CHECK (NODE))
403
404 /* Nonzero if this statement-expression does not have an associated scope. */
405 #define STMT_EXPR_NO_SCOPE(NODE) \
406 TREE_LANG_FLAG_0 (STMT_EXPR_CHECK (NODE))
407
408 #define COND_EXPR_IS_VEC_DELETE(NODE) \
409 TREE_LANG_FLAG_0 (COND_EXPR_CHECK (NODE))
410
411 /* Returns nonzero iff TYPE1 and TYPE2 are the same type, in the usual
412 sense of `same'. */
413 #define same_type_p(TYPE1, TYPE2) \
414 comptypes ((TYPE1), (TYPE2), COMPARE_STRICT)
415
416 /* Returns nonzero iff NODE is a declaration for the global function
417 `main'. */
418 #define DECL_MAIN_P(NODE) \
419 (DECL_EXTERN_C_FUNCTION_P (NODE) \
420 && DECL_NAME (NODE) != NULL_TREE \
421 && MAIN_NAME_P (DECL_NAME (NODE)) \
422 && flag_hosted)
423
424 /* The overloaded FUNCTION_DECL. */
425 #define OVL_FUNCTION(NODE) \
426 (((struct tree_overload*)OVERLOAD_CHECK (NODE))->function)
427 #define OVL_CHAIN(NODE) TREE_CHAIN (NODE)
428 /* Polymorphic access to FUNCTION and CHAIN. */
429 #define OVL_CURRENT(NODE) \
430 ((TREE_CODE (NODE) == OVERLOAD) ? OVL_FUNCTION (NODE) : (NODE))
431 #define OVL_NEXT(NODE) \
432 ((TREE_CODE (NODE) == OVERLOAD) ? TREE_CHAIN (NODE) : NULL_TREE)
433 /* If set, this was imported in a using declaration.
434 This is not to confuse with being used somewhere, which
435 is not important for this node. */
436 #define OVL_USED(NODE) TREE_USED (OVERLOAD_CHECK (NODE))
437 /* If set, this OVERLOAD was created for argument-dependent lookup
438 and can be freed afterward. */
439 #define OVL_ARG_DEPENDENT(NODE) TREE_LANG_FLAG_0 (OVERLOAD_CHECK (NODE))
440
441 struct GTY(()) tree_overload {
442 struct tree_common common;
443 tree function;
444 };
445
446 struct GTY(()) tree_template_decl {
447 struct tree_decl_common common;
448 tree arguments;
449 tree result;
450 };
451
452 /* Returns true iff NODE is a BASELINK. */
453 #define BASELINK_P(NODE) \
454 (TREE_CODE (NODE) == BASELINK)
455 /* The BINFO indicating the base in which lookup found the
456 BASELINK_FUNCTIONS. */
457 #define BASELINK_BINFO(NODE) \
458 (((struct tree_baselink*) BASELINK_CHECK (NODE))->binfo)
459 /* The functions referred to by the BASELINK; either a FUNCTION_DECL,
460 a TEMPLATE_DECL, an OVERLOAD, or a TEMPLATE_ID_EXPR. */
461 #define BASELINK_FUNCTIONS(NODE) \
462 (((struct tree_baselink*) BASELINK_CHECK (NODE))->functions)
463 /* The BINFO in which the search for the functions indicated by this baselink
464 began. This base is used to determine the accessibility of functions
465 selected by overload resolution. */
466 #define BASELINK_ACCESS_BINFO(NODE) \
467 (((struct tree_baselink*) BASELINK_CHECK (NODE))->access_binfo)
468 /* For a type-conversion operator, the BASELINK_OPTYPE indicates the type
469 to which the conversion should occur. This value is important if
470 the BASELINK_FUNCTIONS include a template conversion operator --
471 the BASELINK_OPTYPE can be used to determine what type the user
472 requested. */
473 #define BASELINK_OPTYPE(NODE) \
474 (TREE_CHAIN (BASELINK_CHECK (NODE)))
475 /* Nonzero if this baselink was from a qualified lookup. */
476 #define BASELINK_QUALIFIED_P(NODE) \
477 TREE_LANG_FLAG_0 (BASELINK_CHECK (NODE))
478
479 struct GTY(()) tree_baselink {
480 struct tree_common common;
481 tree binfo;
482 tree functions;
483 tree access_binfo;
484 };
485
486 /* The different kinds of ids that we encounter. */
487
488 enum cp_id_kind
489 {
490 /* Not an id at all. */
491 CP_ID_KIND_NONE,
492 /* An unqualified-id that is not a template-id. */
493 CP_ID_KIND_UNQUALIFIED,
494 /* An unqualified-id that is a dependent name. */
495 CP_ID_KIND_UNQUALIFIED_DEPENDENT,
496 /* An unqualified template-id. */
497 CP_ID_KIND_TEMPLATE_ID,
498 /* A qualified-id. */
499 CP_ID_KIND_QUALIFIED
500 };
501
502
503 /* The various kinds of C++0x warnings we encounter. */
504
505 enum cpp0x_warn_str
506 {
507 /* extended initializer lists */
508 CPP0X_INITIALIZER_LISTS,
509 /* explicit conversion operators */
510 CPP0X_EXPLICIT_CONVERSION,
511 /* variadic templates */
512 CPP0X_VARIADIC_TEMPLATES,
513 /* lambda expressions */
514 CPP0X_LAMBDA_EXPR,
515 /* C++0x auto */
516 CPP0X_AUTO,
517 /* scoped enums */
518 CPP0X_SCOPED_ENUMS,
519 /* defaulted and deleted functions */
520 CPP0X_DEFAULTED_DELETED,
521 /* inline namespaces */
522 CPP0X_INLINE_NAMESPACES,
523 /* override controls, override/final */
524 CPP0X_OVERRIDE_CONTROLS,
525 /* non-static data member initializers */
526 CPP0X_NSDMI,
527 /* user defined literals */
528 CPP0X_USER_DEFINED_LITERALS,
529 /* delegating constructors */
530 CPP0X_DELEGATING_CTORS,
531 /* inheriting constructors */
532 CPP0X_INHERITING_CTORS,
533 /* C++11 attributes */
534 CPP0X_ATTRIBUTES,
535 /* ref-qualified member functions */
536 CPP0X_REF_QUALIFIER
537 };
538
539 /* The various kinds of operation used by composite_pointer_type. */
540
541 enum composite_pointer_operation
542 {
543 /* comparison */
544 CPO_COMPARISON,
545 /* conversion */
546 CPO_CONVERSION,
547 /* conditional expression */
548 CPO_CONDITIONAL_EXPR
549 };
550
551 /* Possible cases of expression list used by build_x_compound_expr_from_list. */
552 enum expr_list_kind {
553 ELK_INIT, /* initializer */
554 ELK_MEM_INIT, /* member initializer */
555 ELK_FUNC_CAST /* functional cast */
556 };
557
558 /* Possible cases of implicit bad rhs conversions. */
559 enum impl_conv_rhs {
560 ICR_DEFAULT_ARGUMENT, /* default argument */
561 ICR_CONVERTING, /* converting */
562 ICR_INIT, /* initialization */
563 ICR_ARGPASS, /* argument passing */
564 ICR_RETURN, /* return */
565 ICR_ASSIGN /* assignment */
566 };
567
568 /* Possible cases of implicit or explicit bad conversions to void. */
569 enum impl_conv_void {
570 ICV_CAST, /* (explicit) conversion to void */
571 ICV_SECOND_OF_COND, /* second operand of conditional expression */
572 ICV_THIRD_OF_COND, /* third operand of conditional expression */
573 ICV_RIGHT_OF_COMMA, /* right operand of comma operator */
574 ICV_LEFT_OF_COMMA, /* left operand of comma operator */
575 ICV_STATEMENT, /* statement */
576 ICV_THIRD_IN_FOR /* for increment expression */
577 };
578
579 /* Possible invalid uses of an abstract class that might not have a
580 specific associated declaration. */
581 enum GTY(()) abstract_class_use {
582 ACU_UNKNOWN, /* unknown or decl provided */
583 ACU_CAST, /* cast to abstract class */
584 ACU_NEW, /* new-expression of abstract class */
585 ACU_THROW, /* throw-expression of abstract class */
586 ACU_CATCH, /* catch-parameter of abstract class */
587 ACU_ARRAY, /* array of abstract class */
588 ACU_RETURN, /* return type of abstract class */
589 ACU_PARM /* parameter type of abstract class */
590 };
591
592 /* Macros for access to language-specific slots in an identifier. */
593
594 #define IDENTIFIER_NAMESPACE_BINDINGS(NODE) \
595 (LANG_IDENTIFIER_CAST (NODE)->namespace_bindings)
596 #define IDENTIFIER_TEMPLATE(NODE) \
597 (LANG_IDENTIFIER_CAST (NODE)->class_template_info)
598
599 /* The IDENTIFIER_BINDING is the innermost cxx_binding for the
600 identifier. It's PREVIOUS is the next outermost binding. Each
601 VALUE field is a DECL for the associated declaration. Thus,
602 name lookup consists simply of pulling off the node at the front
603 of the list (modulo oddities for looking up the names of types,
604 and such.) You can use SCOPE field to determine the scope
605 that bound the name. */
606 #define IDENTIFIER_BINDING(NODE) \
607 (LANG_IDENTIFIER_CAST (NODE)->bindings)
608
609 /* TREE_TYPE only indicates on local and class scope the current
610 type. For namespace scope, the presence of a type in any namespace
611 is indicated with global_type_node, and the real type behind must
612 be found through lookup. */
613 #define IDENTIFIER_TYPE_VALUE(NODE) identifier_type_value (NODE)
614 #define REAL_IDENTIFIER_TYPE_VALUE(NODE) TREE_TYPE (NODE)
615 #define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = (TYPE))
616 #define IDENTIFIER_HAS_TYPE_VALUE(NODE) (IDENTIFIER_TYPE_VALUE (NODE) ? 1 : 0)
617
618 #define IDENTIFIER_LABEL_VALUE(NODE) \
619 (LANG_IDENTIFIER_CAST (NODE)->label_value)
620 #define SET_IDENTIFIER_LABEL_VALUE(NODE, VALUE) \
621 IDENTIFIER_LABEL_VALUE (NODE) = (VALUE)
622
623 /* Nonzero if this identifier is used as a virtual function name somewhere
624 (optimizes searches). */
625 #define IDENTIFIER_VIRTUAL_P(NODE) TREE_LANG_FLAG_1 (NODE)
626
627 /* Nonzero if this identifier is the prefix for a mangled C++ operator
628 name. */
629 #define IDENTIFIER_OPNAME_P(NODE) TREE_LANG_FLAG_2 (NODE)
630
631 /* Nonzero if this identifier is the name of a type-conversion
632 operator. */
633 #define IDENTIFIER_TYPENAME_P(NODE) \
634 TREE_LANG_FLAG_4 (NODE)
635
636 /* Nonzero if this identifier is the name of a constructor or
637 destructor. */
638 #define IDENTIFIER_CTOR_OR_DTOR_P(NODE) \
639 TREE_LANG_FLAG_3 (NODE)
640
641 /* True iff NAME is the DECL_ASSEMBLER_NAME for an entity with vague
642 linkage which the prelinker has assigned to this translation
643 unit. */
644 #define IDENTIFIER_REPO_CHOSEN(NAME) \
645 (TREE_LANG_FLAG_6 (NAME))
646
647 /* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only. */
648 #define C_TYPE_FIELDS_READONLY(TYPE) \
649 (LANG_TYPE_CLASS_CHECK (TYPE)->fields_readonly)
650
651 /* The tokens stored in the default argument. */
652
653 #define DEFARG_TOKENS(NODE) \
654 (((struct tree_default_arg *)DEFAULT_ARG_CHECK (NODE))->tokens)
655 #define DEFARG_INSTANTIATIONS(NODE) \
656 (((struct tree_default_arg *)DEFAULT_ARG_CHECK (NODE))->instantiations)
657
658 struct GTY (()) tree_default_arg {
659 struct tree_common common;
660 struct cp_token_cache *tokens;
661 vec<tree, va_gc> *instantiations;
662 };
663
664
665 #define DEFERRED_NOEXCEPT_PATTERN(NODE) \
666 (((struct tree_deferred_noexcept *)DEFERRED_NOEXCEPT_CHECK (NODE))->pattern)
667 #define DEFERRED_NOEXCEPT_ARGS(NODE) \
668 (((struct tree_deferred_noexcept *)DEFERRED_NOEXCEPT_CHECK (NODE))->args)
669 #define DEFERRED_NOEXCEPT_SPEC_P(NODE) \
670 ((NODE) && (TREE_PURPOSE (NODE)) \
671 && (TREE_CODE (TREE_PURPOSE (NODE)) == DEFERRED_NOEXCEPT))
672 #define UNEVALUATED_NOEXCEPT_SPEC_P(NODE) \
673 (DEFERRED_NOEXCEPT_SPEC_P (NODE) \
674 && DEFERRED_NOEXCEPT_PATTERN (TREE_PURPOSE (NODE)) == NULL_TREE)
675
676 struct GTY (()) tree_deferred_noexcept {
677 struct tree_base base;
678 tree pattern;
679 tree args;
680 };
681
682
683 /* The condition associated with the static assertion. This must be
684 an integral constant expression. */
685 #define STATIC_ASSERT_CONDITION(NODE) \
686 (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->condition)
687
688 /* The message associated with the static assertion. This must be a
689 string constant, which will be emitted as an error message when the
690 static assert condition is false. */
691 #define STATIC_ASSERT_MESSAGE(NODE) \
692 (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->message)
693
694 /* Source location information for a static assertion. */
695 #define STATIC_ASSERT_SOURCE_LOCATION(NODE) \
696 (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->location)
697
698 struct GTY (()) tree_static_assert {
699 struct tree_common common;
700 tree condition;
701 tree message;
702 location_t location;
703 };
704
705 struct GTY (()) tree_argument_pack_select {
706 struct tree_common common;
707 tree argument_pack;
708 int index;
709 };
710
711 /* The different kinds of traits that we encounter. */
712
713 enum cp_trait_kind
714 {
715 CPTK_BASES,
716 CPTK_DIRECT_BASES,
717 CPTK_HAS_NOTHROW_ASSIGN,
718 CPTK_HAS_NOTHROW_CONSTRUCTOR,
719 CPTK_HAS_NOTHROW_COPY,
720 CPTK_HAS_TRIVIAL_ASSIGN,
721 CPTK_HAS_TRIVIAL_CONSTRUCTOR,
722 CPTK_HAS_TRIVIAL_COPY,
723 CPTK_HAS_TRIVIAL_DESTRUCTOR,
724 CPTK_HAS_VIRTUAL_DESTRUCTOR,
725 CPTK_IS_ABSTRACT,
726 CPTK_IS_BASE_OF,
727 CPTK_IS_CLASS,
728 CPTK_IS_EMPTY,
729 CPTK_IS_ENUM,
730 CPTK_IS_FINAL,
731 CPTK_IS_LITERAL_TYPE,
732 CPTK_IS_POD,
733 CPTK_IS_POLYMORPHIC,
734 CPTK_IS_SAME_AS,
735 CPTK_IS_STD_LAYOUT,
736 CPTK_IS_TRIVIAL,
737 CPTK_IS_TRIVIALLY_ASSIGNABLE,
738 CPTK_IS_TRIVIALLY_CONSTRUCTIBLE,
739 CPTK_IS_TRIVIALLY_COPYABLE,
740 CPTK_IS_UNION,
741 CPTK_UNDERLYING_TYPE
742 };
743
744 /* The types that we are processing. */
745 #define TRAIT_EXPR_TYPE1(NODE) \
746 (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type1)
747
748 #define TRAIT_EXPR_TYPE2(NODE) \
749 (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type2)
750
751 /* The specific trait that we are processing. */
752 #define TRAIT_EXPR_KIND(NODE) \
753 (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->kind)
754
755 struct GTY (()) tree_trait_expr {
756 struct tree_common common;
757 tree type1;
758 tree type2;
759 enum cp_trait_kind kind;
760 };
761
762 /* Based off of TYPE_ANONYMOUS_P. */
763 #define LAMBDA_TYPE_P(NODE) \
764 (CLASS_TYPE_P (NODE) && CLASSTYPE_LAMBDA_EXPR (NODE))
765
766 /* Test if FUNCTION_DECL is a lambda function. */
767 #define LAMBDA_FUNCTION_P(FNDECL) \
768 (DECL_OVERLOADED_OPERATOR_P (FNDECL) == CALL_EXPR \
769 && LAMBDA_TYPE_P (CP_DECL_CONTEXT (FNDECL)))
770
771 enum cp_lambda_default_capture_mode_type {
772 CPLD_NONE,
773 CPLD_COPY,
774 CPLD_REFERENCE
775 };
776
777 /* The method of default capture, if any. */
778 #define LAMBDA_EXPR_DEFAULT_CAPTURE_MODE(NODE) \
779 (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->default_capture_mode)
780
781 /* The capture-list, including `this'. Each capture is stored as a FIELD_DECL
782 * so that the name, type, and field are all together, whether or not it has
783 * been added to the lambda's class type.
784 TREE_LIST:
785 TREE_PURPOSE: The FIELD_DECL for this capture.
786 TREE_VALUE: The initializer. This is part of a GNU extension. */
787 #define LAMBDA_EXPR_CAPTURE_LIST(NODE) \
788 (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->capture_list)
789
790 /* During parsing of the lambda-introducer, the node in the capture-list
791 that holds the 'this' capture. During parsing of the body, the
792 capture proxy for that node. */
793 #define LAMBDA_EXPR_THIS_CAPTURE(NODE) \
794 (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->this_capture)
795
796 /* Predicate tracking whether `this' is in the effective capture set. */
797 #define LAMBDA_EXPR_CAPTURES_THIS_P(NODE) \
798 LAMBDA_EXPR_THIS_CAPTURE(NODE)
799
800 /* Predicate tracking whether the lambda was declared 'mutable'. */
801 #define LAMBDA_EXPR_MUTABLE_P(NODE) \
802 TREE_LANG_FLAG_1 (LAMBDA_EXPR_CHECK (NODE))
803
804 /* The return type in the expression.
805 * NULL_TREE indicates that none was specified. */
806 #define LAMBDA_EXPR_RETURN_TYPE(NODE) \
807 (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->return_type)
808
809 /* The source location of the lambda. */
810 #define LAMBDA_EXPR_LOCATION(NODE) \
811 (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->locus)
812
813 /* The mangling scope for the lambda: FUNCTION_DECL, PARM_DECL, VAR_DECL,
814 FIELD_DECL or NULL_TREE. If this is NULL_TREE, we have no linkage. */
815 #define LAMBDA_EXPR_EXTRA_SCOPE(NODE) \
816 (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->extra_scope)
817
818 /* If EXTRA_SCOPE, this is the number of the lambda within that scope. */
819 #define LAMBDA_EXPR_DISCRIMINATOR(NODE) \
820 (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->discriminator)
821
822 /* During parsing of the lambda, a vector of capture proxies which need
823 to be pushed once we're done processing a nested lambda. */
824 #define LAMBDA_EXPR_PENDING_PROXIES(NODE) \
825 (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->pending_proxies)
826
827 /* The closure type of the lambda. Note that the TREE_TYPE of a
828 LAMBDA_EXPR is always NULL_TREE, because we need to instantiate the
829 LAMBDA_EXPR in order to instantiate the type. */
830 #define LAMBDA_EXPR_CLOSURE(NODE) \
831 (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->closure)
832
833 struct GTY (()) tree_lambda_expr
834 {
835 struct tree_typed typed;
836 tree capture_list;
837 tree this_capture;
838 tree return_type;
839 tree extra_scope;
840 tree closure;
841 vec<tree, va_gc> *pending_proxies;
842 location_t locus;
843 enum cp_lambda_default_capture_mode_type default_capture_mode;
844 int discriminator;
845 };
846
847 /* A (typedef,context,usage location) triplet.
848 It represents a typedef used through a
849 context at a given source location.
850 e.g.
851 struct foo {
852 typedef int myint;
853 };
854
855 struct bar {
856 foo::myint v; // #1<-- this location.
857 };
858
859 In bar, the triplet will be (myint, foo, #1).
860 */
861 struct GTY(()) qualified_typedef_usage_s {
862 tree typedef_decl;
863 tree context;
864 location_t locus;
865 };
866 typedef struct qualified_typedef_usage_s qualified_typedef_usage_t;
867
868 /* Non-zero if this template specialization has access violations that
869 should be rechecked when the function is instantiated outside argument
870 deduction. */
871 #define TINFO_HAS_ACCESS_ERRORS(NODE) \
872 (TREE_LANG_FLAG_0 (TEMPLATE_INFO_CHECK (NODE)))
873 #define FNDECL_HAS_ACCESS_ERRORS(NODE) \
874 (TINFO_HAS_ACCESS_ERRORS (DECL_TEMPLATE_INFO (NODE)))
875
876 /* Non-zero if this variable template specialization was specified using a
877 template-id, so it's a partial or full specialization and not a definition
878 of the member template of a particular class specialization. */
879 #define TINFO_USED_TEMPLATE_ID(NODE) \
880 (TREE_LANG_FLAG_1 (TEMPLATE_INFO_CHECK (NODE)))
881
882 struct GTY(()) tree_template_info {
883 struct tree_common common;
884 vec<qualified_typedef_usage_t, va_gc> *typedefs_needing_access_checking;
885 };
886
887 // Constraint information for a C++ declaration. Constraint information is
888 // comprised of:
889 //
890 // - a constraint expression introduced by the template header
891 // - a constraint expression introduced by a function declarator
892 // - the associated constraints, which are the conjunction of those,
893 // and used for declaration matching
894 //
895 // The template and declarator requirements are kept to support pretty
896 // printing constrained declarations.
897 struct GTY(()) tree_constraint_info {
898 struct tree_base base;
899 tree template_reqs;
900 tree declarator_reqs;
901 tree associated_constr;
902 };
903
904 // Require that pointer P is non-null before returning.
905 template<typename T>
906 inline T*
check_nonnull(T * p)907 check_nonnull (T* p)
908 {
909 gcc_assert (p);
910 return p;
911 }
912
913 // Returns true iff T is non-null and represents constraint info.
914 inline tree_constraint_info *
check_constraint_info(tree t)915 check_constraint_info (tree t)
916 {
917 if (t && TREE_CODE (t) == CONSTRAINT_INFO)
918 return (tree_constraint_info *)t;
919 return NULL;
920 }
921
922 // Access the expression describing the template constraints. This may be
923 // null if no constraints were introduced in the template parameter list,
924 // a requirements clause after the template parameter list, or constraints
925 // through a constrained-type-specifier.
926 #define CI_TEMPLATE_REQS(NODE) \
927 check_constraint_info (check_nonnull(NODE))->template_reqs
928
929 // Access the expression describing the trailing constraints. This is non-null
930 // for any implicit instantiation of a constrained declaration. For a
931 // templated declaration it is non-null only when a trailing requires-clause
932 // was specified.
933 #define CI_DECLARATOR_REQS(NODE) \
934 check_constraint_info (check_nonnull(NODE))->declarator_reqs
935
936 // The computed associated constraint expression for a declaration.
937 #define CI_ASSOCIATED_CONSTRAINTS(NODE) \
938 check_constraint_info (check_nonnull(NODE))->associated_constr
939
940 // Access the logical constraints on the template parameters introduced
941 // at a given template parameter list level indicated by NODE.
942 #define TEMPLATE_PARMS_CONSTRAINTS(NODE) \
943 TREE_TYPE (TREE_LIST_CHECK (NODE))
944
945 // Access the logical constraints on the template parameter declaration
946 // indicated by NODE.
947 #define TEMPLATE_PARM_CONSTRAINTS(NODE) \
948 TREE_TYPE (TREE_LIST_CHECK (NODE))
949
950 /* Non-zero if the noexcept is present in a compound requirement. */
951 #define COMPOUND_REQ_NOEXCEPT_P(NODE) \
952 TREE_LANG_FLAG_0 (TREE_CHECK (NODE, COMPOUND_REQ))
953
954 /* The constraints on an 'auto' placeholder type, used in an argument deduction
955 constraint. */
956 #define PLACEHOLDER_TYPE_CONSTRAINTS(NODE) \
957 DECL_SIZE_UNIT (TYPE_NAME (NODE))
958
959 /* The expression evaluated by the predicate constraint. */
960 #define PRED_CONSTR_EXPR(NODE) \
961 TREE_OPERAND (TREE_CHECK (NODE, PRED_CONSTR), 0)
962
963 /* The concept of a concept check. */
964 #define CHECK_CONSTR_CONCEPT(NODE) \
965 TREE_OPERAND (TREE_CHECK (NODE, CHECK_CONSTR), 0)
966
967 /* The template arguments of a concept check. */
968 #define CHECK_CONSTR_ARGS(NODE) \
969 TREE_OPERAND (TREE_CHECK (NODE, CHECK_CONSTR), 1)
970
971 /* The expression validated by the predicate constraint. */
972 #define EXPR_CONSTR_EXPR(NODE) \
973 TREE_OPERAND (TREE_CHECK (NODE, EXPR_CONSTR), 0)
974
975 /* The type validated by the predicate constraint. */
976 #define TYPE_CONSTR_TYPE(NODE) \
977 TREE_OPERAND (TREE_CHECK (NODE, TYPE_CONSTR), 0)
978
979 /* In an implicit conversion constraint, the source expression. */
980 #define ICONV_CONSTR_EXPR(NODE) \
981 TREE_OPERAND (TREE_CHECK (NODE, ICONV_CONSTR), 0)
982
983 /* In an implicit conversion constraint, the target type. */
984 #define ICONV_CONSTR_TYPE(NODE) \
985 TREE_OPERAND (TREE_CHECK (NODE, ICONV_CONSTR), 1)
986
987 /* In an argument deduction constraint, the source expression. */
988 #define DEDUCT_CONSTR_EXPR(NODE) \
989 TREE_OPERAND (TREE_CHECK (NODE, DEDUCT_CONSTR), 0)
990
991 /* In an argument deduction constraint, the target type pattern. */
992 #define DEDUCT_CONSTR_PATTERN(NODE) \
993 TREE_OPERAND (TREE_CHECK (NODE, DEDUCT_CONSTR), 1)
994
995 /* In an argument deduction constraint, the list of placeholder nodes. */
996 #define DEDUCT_CONSTR_PLACEHOLDER(NODE) \
997 TREE_OPERAND (TREE_CHECK (NODE, DEDUCT_CONSTR), 2)
998
999 /* The expression of an exception constraint. */
1000 #define EXCEPT_CONSTR_EXPR(NODE) \
1001 TREE_OPERAND (TREE_CHECK (NODE, EXCEPT_CONSTR), 0)
1002
1003 /* In a parameterized constraint, the local parameters. */
1004 #define PARM_CONSTR_PARMS(NODE) \
1005 TREE_OPERAND (TREE_CHECK (NODE, PARM_CONSTR), 0)
1006
1007 /* In a parameterized constraint, the operand. */
1008 #define PARM_CONSTR_OPERAND(NODE) \
1009 TREE_OPERAND (TREE_CHECK (NODE, PARM_CONSTR), 1)
1010
1011 /* Whether a PARM_DECL represents a local parameter in a
1012 requires-expression. */
1013 #define CONSTRAINT_VAR_P(NODE) \
1014 DECL_LANG_FLAG_2 (TREE_CHECK (NODE, PARM_DECL))
1015
1016 /* The concept constraining this constrained template-parameter. */
1017 #define CONSTRAINED_PARM_CONCEPT(NODE) \
1018 DECL_SIZE_UNIT (TYPE_DECL_CHECK (NODE))
1019 /* Any extra template arguments specified for a constrained
1020 template-parameter. */
1021 #define CONSTRAINED_PARM_EXTRA_ARGS(NODE) \
1022 DECL_SIZE (TYPE_DECL_CHECK (NODE))
1023 /* The first template parameter of CONSTRAINED_PARM_CONCEPT to be used as a
1024 prototype for the constrained parameter in finish_shorthand_constraint,
1025 attached for convenience. */
1026 #define CONSTRAINED_PARM_PROTOTYPE(NODE) \
1027 DECL_INITIAL (TYPE_DECL_CHECK (NODE))
1028
1029 enum cp_tree_node_structure_enum {
1030 TS_CP_GENERIC,
1031 TS_CP_IDENTIFIER,
1032 TS_CP_TPI,
1033 TS_CP_PTRMEM,
1034 TS_CP_BINDING,
1035 TS_CP_OVERLOAD,
1036 TS_CP_BASELINK,
1037 TS_CP_TEMPLATE_DECL,
1038 TS_CP_WRAPPER,
1039 TS_CP_DEFAULT_ARG,
1040 TS_CP_DEFERRED_NOEXCEPT,
1041 TS_CP_STATIC_ASSERT,
1042 TS_CP_ARGUMENT_PACK_SELECT,
1043 TS_CP_TRAIT_EXPR,
1044 TS_CP_LAMBDA_EXPR,
1045 TS_CP_TEMPLATE_INFO,
1046 TS_CP_CONSTRAINT_INFO,
1047 TS_CP_USERDEF_LITERAL,
1048 LAST_TS_CP_ENUM
1049 };
1050
1051 /* The resulting tree type. */
1052 union GTY((desc ("cp_tree_node_structure (&%h)"),
1053 chain_next ("(union lang_tree_node *) c_tree_chain_next (&%h.generic)"))) lang_tree_node {
1054 union tree_node GTY ((tag ("TS_CP_GENERIC"),
1055 desc ("tree_node_structure (&%h)"))) generic;
1056 struct template_parm_index GTY ((tag ("TS_CP_TPI"))) tpi;
1057 struct ptrmem_cst GTY ((tag ("TS_CP_PTRMEM"))) ptrmem;
1058 struct tree_overload GTY ((tag ("TS_CP_OVERLOAD"))) overload;
1059 struct tree_baselink GTY ((tag ("TS_CP_BASELINK"))) baselink;
1060 struct tree_template_decl GTY ((tag ("TS_CP_TEMPLATE_DECL"))) template_decl;
1061 struct tree_default_arg GTY ((tag ("TS_CP_DEFAULT_ARG"))) default_arg;
1062 struct tree_deferred_noexcept GTY ((tag ("TS_CP_DEFERRED_NOEXCEPT"))) deferred_noexcept;
1063 struct lang_identifier GTY ((tag ("TS_CP_IDENTIFIER"))) identifier;
1064 struct tree_static_assert GTY ((tag ("TS_CP_STATIC_ASSERT")))
1065 static_assertion;
1066 struct tree_argument_pack_select GTY ((tag ("TS_CP_ARGUMENT_PACK_SELECT")))
1067 argument_pack_select;
1068 struct tree_trait_expr GTY ((tag ("TS_CP_TRAIT_EXPR")))
1069 trait_expression;
1070 struct tree_lambda_expr GTY ((tag ("TS_CP_LAMBDA_EXPR")))
1071 lambda_expression;
1072 struct tree_template_info GTY ((tag ("TS_CP_TEMPLATE_INFO")))
1073 template_info;
1074 struct tree_constraint_info GTY ((tag ("TS_CP_CONSTRAINT_INFO")))
1075 constraint_info;
1076 struct tree_userdef_literal GTY ((tag ("TS_CP_USERDEF_LITERAL")))
1077 userdef_literal;
1078 };
1079
1080
1081 enum cp_tree_index
1082 {
1083 CPTI_JAVA_BYTE_TYPE,
1084 CPTI_JAVA_SHORT_TYPE,
1085 CPTI_JAVA_INT_TYPE,
1086 CPTI_JAVA_LONG_TYPE,
1087 CPTI_JAVA_FLOAT_TYPE,
1088 CPTI_JAVA_DOUBLE_TYPE,
1089 CPTI_JAVA_CHAR_TYPE,
1090 CPTI_JAVA_BOOLEAN_TYPE,
1091
1092 CPTI_WCHAR_DECL,
1093 CPTI_VTABLE_ENTRY_TYPE,
1094 CPTI_DELTA_TYPE,
1095 CPTI_VTABLE_INDEX_TYPE,
1096 CPTI_CLEANUP_TYPE,
1097 CPTI_VTT_PARM_TYPE,
1098
1099 CPTI_CLASS_TYPE,
1100 CPTI_UNKNOWN_TYPE,
1101 CPTI_INIT_LIST_TYPE,
1102 CPTI_VTBL_TYPE,
1103 CPTI_VTBL_PTR_TYPE,
1104 CPTI_STD,
1105 CPTI_ABI,
1106 CPTI_CONST_TYPE_INFO_TYPE,
1107 CPTI_TYPE_INFO_PTR_TYPE,
1108 CPTI_ABORT_FNDECL,
1109 CPTI_AGGR_TAG,
1110
1111 CPTI_CTOR_IDENTIFIER,
1112 CPTI_COMPLETE_CTOR_IDENTIFIER,
1113 CPTI_BASE_CTOR_IDENTIFIER,
1114 CPTI_DTOR_IDENTIFIER,
1115 CPTI_COMPLETE_DTOR_IDENTIFIER,
1116 CPTI_BASE_DTOR_IDENTIFIER,
1117 CPTI_DELETING_DTOR_IDENTIFIER,
1118 CPTI_DELTA_IDENTIFIER,
1119 CPTI_IN_CHARGE_IDENTIFIER,
1120 CPTI_VTT_PARM_IDENTIFIER,
1121 CPTI_NELTS_IDENTIFIER,
1122 CPTI_THIS_IDENTIFIER,
1123 CPTI_PFN_IDENTIFIER,
1124 CPTI_VPTR_IDENTIFIER,
1125 CPTI_STD_IDENTIFIER,
1126
1127 CPTI_LANG_NAME_C,
1128 CPTI_LANG_NAME_CPLUSPLUS,
1129 CPTI_LANG_NAME_JAVA,
1130
1131 CPTI_EMPTY_EXCEPT_SPEC,
1132 CPTI_NOEXCEPT_TRUE_SPEC,
1133 CPTI_NOEXCEPT_FALSE_SPEC,
1134 CPTI_JCLASS,
1135 CPTI_TERMINATE,
1136 CPTI_CALL_UNEXPECTED,
1137 CPTI_ATEXIT_FN_PTR_TYPE,
1138 CPTI_ATEXIT,
1139 CPTI_DSO_HANDLE,
1140 CPTI_DCAST,
1141
1142 CPTI_KEYED_CLASSES,
1143
1144 CPTI_NULLPTR,
1145 CPTI_NULLPTR_TYPE,
1146
1147 CPTI_MAX
1148 };
1149
1150 extern GTY(()) tree cp_global_trees[CPTI_MAX];
1151
1152 #define java_byte_type_node cp_global_trees[CPTI_JAVA_BYTE_TYPE]
1153 #define java_short_type_node cp_global_trees[CPTI_JAVA_SHORT_TYPE]
1154 #define java_int_type_node cp_global_trees[CPTI_JAVA_INT_TYPE]
1155 #define java_long_type_node cp_global_trees[CPTI_JAVA_LONG_TYPE]
1156 #define java_float_type_node cp_global_trees[CPTI_JAVA_FLOAT_TYPE]
1157 #define java_double_type_node cp_global_trees[CPTI_JAVA_DOUBLE_TYPE]
1158 #define java_char_type_node cp_global_trees[CPTI_JAVA_CHAR_TYPE]
1159 #define java_boolean_type_node cp_global_trees[CPTI_JAVA_BOOLEAN_TYPE]
1160
1161 #define wchar_decl_node cp_global_trees[CPTI_WCHAR_DECL]
1162 #define vtable_entry_type cp_global_trees[CPTI_VTABLE_ENTRY_TYPE]
1163 /* The type used to represent an offset by which to adjust the `this'
1164 pointer in pointer-to-member types. */
1165 #define delta_type_node cp_global_trees[CPTI_DELTA_TYPE]
1166 /* The type used to represent an index into the vtable. */
1167 #define vtable_index_type cp_global_trees[CPTI_VTABLE_INDEX_TYPE]
1168
1169 #define class_type_node cp_global_trees[CPTI_CLASS_TYPE]
1170 #define unknown_type_node cp_global_trees[CPTI_UNKNOWN_TYPE]
1171 #define init_list_type_node cp_global_trees[CPTI_INIT_LIST_TYPE]
1172 #define vtbl_type_node cp_global_trees[CPTI_VTBL_TYPE]
1173 #define vtbl_ptr_type_node cp_global_trees[CPTI_VTBL_PTR_TYPE]
1174 #define std_node cp_global_trees[CPTI_STD]
1175 #define abi_node cp_global_trees[CPTI_ABI]
1176 #define const_type_info_type_node cp_global_trees[CPTI_CONST_TYPE_INFO_TYPE]
1177 #define type_info_ptr_type cp_global_trees[CPTI_TYPE_INFO_PTR_TYPE]
1178 #define abort_fndecl cp_global_trees[CPTI_ABORT_FNDECL]
1179 #define current_aggr cp_global_trees[CPTI_AGGR_TAG]
1180 #define nullptr_node cp_global_trees[CPTI_NULLPTR]
1181 #define nullptr_type_node cp_global_trees[CPTI_NULLPTR_TYPE]
1182
1183 /* We cache these tree nodes so as to call get_identifier less
1184 frequently. */
1185
1186 /* The name of a constructor that takes an in-charge parameter to
1187 decide whether or not to construct virtual base classes. */
1188 #define ctor_identifier cp_global_trees[CPTI_CTOR_IDENTIFIER]
1189 /* The name of a constructor that constructs virtual base classes. */
1190 #define complete_ctor_identifier cp_global_trees[CPTI_COMPLETE_CTOR_IDENTIFIER]
1191 /* The name of a constructor that does not construct virtual base classes. */
1192 #define base_ctor_identifier cp_global_trees[CPTI_BASE_CTOR_IDENTIFIER]
1193 /* The name of a destructor that takes an in-charge parameter to
1194 decide whether or not to destroy virtual base classes and whether
1195 or not to delete the object. */
1196 #define dtor_identifier cp_global_trees[CPTI_DTOR_IDENTIFIER]
1197 /* The name of a destructor that destroys virtual base classes. */
1198 #define complete_dtor_identifier cp_global_trees[CPTI_COMPLETE_DTOR_IDENTIFIER]
1199 /* The name of a destructor that does not destroy virtual base
1200 classes. */
1201 #define base_dtor_identifier cp_global_trees[CPTI_BASE_DTOR_IDENTIFIER]
1202 /* The name of a destructor that destroys virtual base classes, and
1203 then deletes the entire object. */
1204 #define deleting_dtor_identifier cp_global_trees[CPTI_DELETING_DTOR_IDENTIFIER]
1205 #define delta_identifier cp_global_trees[CPTI_DELTA_IDENTIFIER]
1206 #define in_charge_identifier cp_global_trees[CPTI_IN_CHARGE_IDENTIFIER]
1207 /* The name of the parameter that contains a pointer to the VTT to use
1208 for this subobject constructor or destructor. */
1209 #define vtt_parm_identifier cp_global_trees[CPTI_VTT_PARM_IDENTIFIER]
1210 #define nelts_identifier cp_global_trees[CPTI_NELTS_IDENTIFIER]
1211 #define this_identifier cp_global_trees[CPTI_THIS_IDENTIFIER]
1212 #define pfn_identifier cp_global_trees[CPTI_PFN_IDENTIFIER]
1213 #define vptr_identifier cp_global_trees[CPTI_VPTR_IDENTIFIER]
1214 /* The name of the std namespace. */
1215 #define std_identifier cp_global_trees[CPTI_STD_IDENTIFIER]
1216 #define lang_name_c cp_global_trees[CPTI_LANG_NAME_C]
1217 #define lang_name_cplusplus cp_global_trees[CPTI_LANG_NAME_CPLUSPLUS]
1218 #define lang_name_java cp_global_trees[CPTI_LANG_NAME_JAVA]
1219
1220 /* Exception specifier used for throw(). */
1221 #define empty_except_spec cp_global_trees[CPTI_EMPTY_EXCEPT_SPEC]
1222 #define noexcept_true_spec cp_global_trees[CPTI_NOEXCEPT_TRUE_SPEC]
1223 #define noexcept_false_spec cp_global_trees[CPTI_NOEXCEPT_FALSE_SPEC]
1224
1225 /* If non-NULL, a POINTER_TYPE equivalent to (java::lang::Class*). */
1226 #define jclass_node cp_global_trees[CPTI_JCLASS]
1227
1228 /* The declaration for `std::terminate'. */
1229 #define terminate_node cp_global_trees[CPTI_TERMINATE]
1230
1231 /* The declaration for "__cxa_call_unexpected". */
1232 #define call_unexpected_node cp_global_trees[CPTI_CALL_UNEXPECTED]
1233
1234 /* The type of the function-pointer argument to "__cxa_atexit" (or
1235 "std::atexit", if "__cxa_atexit" is not being used). */
1236 #define atexit_fn_ptr_type_node cp_global_trees[CPTI_ATEXIT_FN_PTR_TYPE]
1237
1238 /* A pointer to `std::atexit'. */
1239 #define atexit_node cp_global_trees[CPTI_ATEXIT]
1240
1241 /* A pointer to `__dso_handle'. */
1242 #define dso_handle_node cp_global_trees[CPTI_DSO_HANDLE]
1243
1244 /* The declaration of the dynamic_cast runtime. */
1245 #define dynamic_cast_node cp_global_trees[CPTI_DCAST]
1246
1247 /* The type of a destructor. */
1248 #define cleanup_type cp_global_trees[CPTI_CLEANUP_TYPE]
1249
1250 /* The type of the vtt parameter passed to subobject constructors and
1251 destructors. */
1252 #define vtt_parm_type cp_global_trees[CPTI_VTT_PARM_TYPE]
1253
1254 /* A TREE_LIST of the dynamic classes whose vtables may have to be
1255 emitted in this translation unit. */
1256
1257 #define keyed_classes cp_global_trees[CPTI_KEYED_CLASSES]
1258
1259 /* Node to indicate default access. This must be distinct from the
1260 access nodes in tree.h. */
1261
1262 #define access_default_node null_node
1263
1264 /* Global state. */
1265
1266 struct GTY(()) saved_scope {
1267 vec<cxx_saved_binding, va_gc> *old_bindings;
1268 tree old_namespace;
1269 vec<tree, va_gc> *decl_ns_list;
1270 tree class_name;
1271 tree class_type;
1272 tree access_specifier;
1273 tree function_decl;
1274 vec<tree, va_gc> *lang_base;
1275 tree lang_name;
1276 tree template_parms;
1277 cp_binding_level *x_previous_class_level;
1278 tree x_saved_tree;
1279
1280 /* Only used for uses of this in trailing return type. */
1281 tree x_current_class_ptr;
1282 tree x_current_class_ref;
1283
1284 int x_processing_template_decl;
1285 int x_processing_specialization;
1286 BOOL_BITFIELD x_processing_explicit_instantiation : 1;
1287 BOOL_BITFIELD need_pop_function_context : 1;
1288
1289 int unevaluated_operand;
1290 int inhibit_evaluation_warnings;
1291 int noexcept_operand;
1292 /* If non-zero, implicit "omp declare target" attribute is added into the
1293 attribute lists. */
1294 int omp_declare_target_attribute;
1295
1296 struct stmt_tree_s x_stmt_tree;
1297
1298 cp_binding_level *class_bindings;
1299 cp_binding_level *bindings;
1300
1301 hash_map<tree, tree> *GTY((skip)) x_local_specializations;
1302
1303 struct saved_scope *prev;
1304 };
1305
1306 extern GTY(()) struct saved_scope *scope_chain;
1307
1308 /* The current open namespace. */
1309
1310 #define current_namespace scope_chain->old_namespace
1311
1312 /* The stack for namespaces of current declarations. */
1313
1314 #define decl_namespace_list scope_chain->decl_ns_list
1315
1316 /* IDENTIFIER_NODE: name of current class */
1317
1318 #define current_class_name scope_chain->class_name
1319
1320 /* _TYPE: the type of the current class */
1321
1322 #define current_class_type scope_chain->class_type
1323
1324 /* When parsing a class definition, the access specifier most recently
1325 given by the user, or, if no access specifier was given, the
1326 default value appropriate for the kind of class (i.e., struct,
1327 class, or union). */
1328
1329 #define current_access_specifier scope_chain->access_specifier
1330
1331 /* Pointer to the top of the language name stack. */
1332
1333 #define current_lang_base scope_chain->lang_base
1334 #define current_lang_name scope_chain->lang_name
1335
1336 /* When parsing a template declaration, a TREE_LIST represents the
1337 active template parameters. Each node in the list represents one
1338 level of template parameters. The innermost level is first in the
1339 list. The depth of each level is stored as an INTEGER_CST in the
1340 TREE_PURPOSE of each node. The parameters for that level are
1341 stored in the TREE_VALUE. */
1342
1343 #define current_template_parms scope_chain->template_parms
1344
1345 #define processing_template_decl scope_chain->x_processing_template_decl
1346 #define processing_specialization scope_chain->x_processing_specialization
1347 #define processing_explicit_instantiation scope_chain->x_processing_explicit_instantiation
1348
1349 /* RAII sentinel to handle clearing processing_template_decl and restoring
1350 it when done. */
1351
1352 struct processing_template_decl_sentinel
1353 {
1354 int saved;
1355 processing_template_decl_sentinel (bool reset = true)
savedprocessing_template_decl_sentinel1356 : saved (processing_template_decl)
1357 {
1358 if (reset)
1359 processing_template_decl = 0;
1360 }
~processing_template_decl_sentinelprocessing_template_decl_sentinel1361 ~processing_template_decl_sentinel()
1362 {
1363 processing_template_decl = saved;
1364 }
1365 };
1366
1367 /* RAII sentinel to disable certain warnings during template substitution
1368 and elsewhere. */
1369
1370 struct warning_sentinel
1371 {
1372 int &flag;
1373 int val;
1374 warning_sentinel(int& flag, bool suppress=true)
flagwarning_sentinel1375 : flag(flag), val(flag) { if (suppress) flag = 0; }
~warning_sentinelwarning_sentinel1376 ~warning_sentinel() { flag = val; }
1377 };
1378
1379 /* The cached class binding level, from the most recently exited
1380 class, or NULL if none. */
1381
1382 #define previous_class_level scope_chain->x_previous_class_level
1383
1384 /* A map from local variable declarations in the body of the template
1385 presently being instantiated to the corresponding instantiated
1386 local variables. */
1387
1388 #define local_specializations scope_chain->x_local_specializations
1389
1390 /* Nonzero if we are parsing the operand of a noexcept operator. */
1391
1392 #define cp_noexcept_operand scope_chain->noexcept_operand
1393
1394 /* A list of private types mentioned, for deferred access checking. */
1395
1396 struct GTY((for_user)) cxx_int_tree_map {
1397 unsigned int uid;
1398 tree to;
1399 };
1400
1401 struct cxx_int_tree_map_hasher : ggc_ptr_hash<cxx_int_tree_map>
1402 {
1403 static hashval_t hash (cxx_int_tree_map *);
1404 static bool equal (cxx_int_tree_map *, cxx_int_tree_map *);
1405 };
1406
1407 struct named_label_entry;
1408
1409 struct named_label_hasher : ggc_ptr_hash<named_label_entry>
1410 {
1411 static hashval_t hash (named_label_entry *);
1412 static bool equal (named_label_entry *, named_label_entry *);
1413 };
1414
1415 /* Global state pertinent to the current function. */
1416
1417 struct GTY(()) language_function {
1418 struct c_language_function base;
1419
1420 tree x_cdtor_label;
1421 tree x_current_class_ptr;
1422 tree x_current_class_ref;
1423 tree x_eh_spec_block;
1424 tree x_in_charge_parm;
1425 tree x_vtt_parm;
1426 tree x_return_value;
1427 tree x_auto_return_pattern;
1428
1429 BOOL_BITFIELD returns_value : 1;
1430 BOOL_BITFIELD returns_null : 1;
1431 BOOL_BITFIELD returns_abnormally : 1;
1432 BOOL_BITFIELD infinite_loop: 1;
1433 BOOL_BITFIELD x_in_function_try_handler : 1;
1434 BOOL_BITFIELD x_in_base_initializer : 1;
1435
1436 /* True if this function can throw an exception. */
1437 BOOL_BITFIELD can_throw : 1;
1438
1439 BOOL_BITFIELD invalid_constexpr : 1;
1440
1441 hash_table<named_label_hasher> *x_named_labels;
1442 cp_binding_level *bindings;
1443 vec<tree, va_gc> *x_local_names;
1444 /* Tracking possibly infinite loops. This is a vec<tree> only because
1445 vec<bool> doesn't work with gtype. */
1446 vec<tree, va_gc> *infinite_loops;
1447 hash_table<cxx_int_tree_map_hasher> *extern_decl_map;
1448 };
1449
1450 /* The current C++-specific per-function global variables. */
1451
1452 #define cp_function_chain (cfun->language)
1453
1454 /* In a constructor destructor, the point at which all derived class
1455 destroying/construction has been done. I.e., just before a
1456 constructor returns, or before any base class destroying will be done
1457 in a destructor. */
1458
1459 #define cdtor_label cp_function_chain->x_cdtor_label
1460
1461 /* When we're processing a member function, current_class_ptr is the
1462 PARM_DECL for the `this' pointer. The current_class_ref is an
1463 expression for `*this'. */
1464
1465 #define current_class_ptr \
1466 (*(cfun && cp_function_chain \
1467 ? &cp_function_chain->x_current_class_ptr \
1468 : &scope_chain->x_current_class_ptr))
1469 #define current_class_ref \
1470 (*(cfun && cp_function_chain \
1471 ? &cp_function_chain->x_current_class_ref \
1472 : &scope_chain->x_current_class_ref))
1473
1474 /* The EH_SPEC_BLOCK for the exception-specifiers for the current
1475 function, if any. */
1476
1477 #define current_eh_spec_block cp_function_chain->x_eh_spec_block
1478
1479 /* The `__in_chrg' parameter for the current function. Only used for
1480 constructors and destructors. */
1481
1482 #define current_in_charge_parm cp_function_chain->x_in_charge_parm
1483
1484 /* The `__vtt_parm' parameter for the current function. Only used for
1485 constructors and destructors. */
1486
1487 #define current_vtt_parm cp_function_chain->x_vtt_parm
1488
1489 /* Set to 0 at beginning of a function definition, set to 1 if
1490 a return statement that specifies a return value is seen. */
1491
1492 #define current_function_returns_value cp_function_chain->returns_value
1493
1494 /* Set to 0 at beginning of a function definition, set to 1 if
1495 a return statement with no argument is seen. */
1496
1497 #define current_function_returns_null cp_function_chain->returns_null
1498
1499 /* Set to 0 at beginning of a function definition, set to 1 if
1500 a call to a noreturn function is seen. */
1501
1502 #define current_function_returns_abnormally \
1503 cp_function_chain->returns_abnormally
1504
1505 /* Set to 0 at beginning of a function definition, set to 1 if we see an
1506 obvious infinite loop. This can have false positives and false
1507 negatives, so it should only be used as a heuristic. */
1508
1509 #define current_function_infinite_loop cp_function_chain->infinite_loop
1510
1511 /* Nonzero if we are processing a base initializer. Zero elsewhere. */
1512 #define in_base_initializer cp_function_chain->x_in_base_initializer
1513
1514 #define in_function_try_handler cp_function_chain->x_in_function_try_handler
1515
1516 /* Expression always returned from function, or error_mark_node
1517 otherwise, for use by the automatic named return value optimization. */
1518
1519 #define current_function_return_value \
1520 (cp_function_chain->x_return_value)
1521
1522 /* A type involving 'auto' to be used for return type deduction. */
1523
1524 #define current_function_auto_return_pattern \
1525 (cp_function_chain->x_auto_return_pattern)
1526
1527 /* True if NAME is the IDENTIFIER_NODE for an overloaded "operator
1528 new" or "operator delete". */
1529 #define NEW_DELETE_OPNAME_P(NAME) \
1530 ((NAME) == ansi_opname (NEW_EXPR) \
1531 || (NAME) == ansi_opname (VEC_NEW_EXPR) \
1532 || (NAME) == ansi_opname (DELETE_EXPR) \
1533 || (NAME) == ansi_opname (VEC_DELETE_EXPR))
1534
1535 #define ansi_opname(CODE) \
1536 (operator_name_info[(int) (CODE)].identifier)
1537 #define ansi_assopname(CODE) \
1538 (assignment_operator_name_info[(int) (CODE)].identifier)
1539
1540 /* TRUE if a tree code represents a statement. */
1541 extern bool statement_code_p[MAX_TREE_CODES];
1542
1543 #define STATEMENT_CODE_P(CODE) statement_code_p[(int) (CODE)]
1544
1545 enum languages { lang_c, lang_cplusplus, lang_java };
1546
1547 /* Macros to make error reporting functions' lives easier. */
1548 #define TYPE_LINKAGE_IDENTIFIER(NODE) \
1549 (TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (NODE)))
1550 #define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (TYPE_IDENTIFIER (NODE)))
1551 #define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (TYPE_IDENTIFIER (NODE)))
1552
1553 /* Nonzero if NODE has no name for linkage purposes. */
1554 #define TYPE_ANONYMOUS_P(NODE) \
1555 (OVERLOAD_TYPE_P (NODE) && anon_aggrname_p (TYPE_LINKAGE_IDENTIFIER (NODE)))
1556
1557 /* The _DECL for this _TYPE. */
1558 #define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE)))
1559
1560 /* Nonzero if T is a type that could resolve to any kind of concrete type
1561 at instantiation time. */
1562 #define WILDCARD_TYPE_P(T) \
1563 (TREE_CODE (T) == TEMPLATE_TYPE_PARM \
1564 || TREE_CODE (T) == TYPENAME_TYPE \
1565 || TREE_CODE (T) == TYPEOF_TYPE \
1566 || TREE_CODE (T) == BOUND_TEMPLATE_TEMPLATE_PARM \
1567 || TREE_CODE (T) == DECLTYPE_TYPE)
1568
1569 /* Nonzero if T is a class (or struct or union) type. Also nonzero
1570 for template type parameters, typename types, and instantiated
1571 template template parameters. Keep these checks in ascending code
1572 order. */
1573 #define MAYBE_CLASS_TYPE_P(T) (WILDCARD_TYPE_P (T) || CLASS_TYPE_P (T))
1574
1575 /* Set CLASS_TYPE_P for T to VAL. T must be a class, struct, or
1576 union type. */
1577 #define SET_CLASS_TYPE_P(T, VAL) \
1578 (TYPE_LANG_FLAG_5 (T) = (VAL))
1579
1580 /* Nonzero if T is a class type. Zero for template type parameters,
1581 typename types, and so forth. */
1582 #define CLASS_TYPE_P(T) \
1583 (RECORD_OR_UNION_CODE_P (TREE_CODE (T)) && TYPE_LANG_FLAG_5 (T))
1584
1585 /* Nonzero if T is a class type but not an union. */
1586 #define NON_UNION_CLASS_TYPE_P(T) \
1587 (CLASS_TYPE_P (T) && TREE_CODE (T) != UNION_TYPE)
1588
1589 /* Keep these checks in ascending code order. */
1590 #define RECORD_OR_UNION_CODE_P(T) \
1591 ((T) == RECORD_TYPE || (T) == UNION_TYPE)
1592 #define OVERLOAD_TYPE_P(T) \
1593 (CLASS_TYPE_P (T) || TREE_CODE (T) == ENUMERAL_TYPE)
1594
1595 /* True if this a "Java" type, defined in 'extern "Java"'. */
1596 #define TYPE_FOR_JAVA(NODE) TYPE_LANG_FLAG_3 (NODE)
1597
1598 /* True if this type is dependent. This predicate is only valid if
1599 TYPE_DEPENDENT_P_VALID is true. */
1600 #define TYPE_DEPENDENT_P(NODE) TYPE_LANG_FLAG_0 (NODE)
1601
1602 /* True if dependent_type_p has been called for this type, with the
1603 result that TYPE_DEPENDENT_P is valid. */
1604 #define TYPE_DEPENDENT_P_VALID(NODE) TYPE_LANG_FLAG_6(NODE)
1605
1606 /* Nonzero if this type is const-qualified. */
1607 #define CP_TYPE_CONST_P(NODE) \
1608 ((cp_type_quals (NODE) & TYPE_QUAL_CONST) != 0)
1609
1610 /* Nonzero if this type is volatile-qualified. */
1611 #define CP_TYPE_VOLATILE_P(NODE) \
1612 ((cp_type_quals (NODE) & TYPE_QUAL_VOLATILE) != 0)
1613
1614 /* Nonzero if this type is restrict-qualified. */
1615 #define CP_TYPE_RESTRICT_P(NODE) \
1616 ((cp_type_quals (NODE) & TYPE_QUAL_RESTRICT) != 0)
1617
1618 /* Nonzero if this type is const-qualified, but not
1619 volatile-qualified. Other qualifiers are ignored. This macro is
1620 used to test whether or not it is OK to bind an rvalue to a
1621 reference. */
1622 #define CP_TYPE_CONST_NON_VOLATILE_P(NODE) \
1623 ((cp_type_quals (NODE) & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)) \
1624 == TYPE_QUAL_CONST)
1625
1626 #define FUNCTION_ARG_CHAIN(NODE) \
1627 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (NODE)))
1628
1629 /* Given a FUNCTION_DECL, returns the first TREE_LIST out of TYPE_ARG_TYPES
1630 which refers to a user-written parameter. */
1631 #define FUNCTION_FIRST_USER_PARMTYPE(NODE) \
1632 skip_artificial_parms_for ((NODE), TYPE_ARG_TYPES (TREE_TYPE (NODE)))
1633
1634 /* Similarly, but for DECL_ARGUMENTS. */
1635 #define FUNCTION_FIRST_USER_PARM(NODE) \
1636 skip_artificial_parms_for ((NODE), DECL_ARGUMENTS (NODE))
1637
1638 /* Nonzero iff TYPE is derived from PARENT. Ignores accessibility and
1639 ambiguity issues. */
1640 #define DERIVED_FROM_P(PARENT, TYPE) \
1641 (lookup_base ((TYPE), (PARENT), ba_any, NULL, tf_none) != NULL_TREE)
1642
1643 /* Gives the visibility specification for a class type. */
1644 #define CLASSTYPE_VISIBILITY(TYPE) \
1645 DECL_VISIBILITY (TYPE_MAIN_DECL (TYPE))
1646 #define CLASSTYPE_VISIBILITY_SPECIFIED(TYPE) \
1647 DECL_VISIBILITY_SPECIFIED (TYPE_MAIN_DECL (TYPE))
1648
1649 struct GTY (()) tree_pair_s {
1650 tree purpose;
1651 tree value;
1652 };
1653 typedef tree_pair_s *tree_pair_p;
1654
1655 /* This is a few header flags for 'struct lang_type'. Actually,
1656 all but the first are used only for lang_type_class; they
1657 are put in this structure to save space. */
1658 struct GTY(()) lang_type_header {
1659 BOOL_BITFIELD is_lang_type_class : 1;
1660
1661 BOOL_BITFIELD has_type_conversion : 1;
1662 BOOL_BITFIELD has_copy_ctor : 1;
1663 BOOL_BITFIELD has_default_ctor : 1;
1664 BOOL_BITFIELD const_needs_init : 1;
1665 BOOL_BITFIELD ref_needs_init : 1;
1666 BOOL_BITFIELD has_const_copy_assign : 1;
1667
1668 BOOL_BITFIELD spare : 1;
1669 };
1670
1671 /* This structure provides additional information above and beyond
1672 what is provide in the ordinary tree_type. In the past, we used it
1673 for the types of class types, template parameters types, typename
1674 types, and so forth. However, there can be many (tens to hundreds
1675 of thousands) of template parameter types in a compilation, and
1676 there's no need for this additional information in that case.
1677 Therefore, we now use this data structure only for class types.
1678
1679 In the past, it was thought that there would be relatively few
1680 class types. However, in the presence of heavy use of templates,
1681 many (i.e., thousands) of classes can easily be generated.
1682 Therefore, we should endeavor to keep the size of this structure to
1683 a minimum. */
1684 struct GTY(()) lang_type_class {
1685 struct lang_type_header h;
1686
1687 unsigned char align;
1688
1689 unsigned has_mutable : 1;
1690 unsigned com_interface : 1;
1691 unsigned non_pod_class : 1;
1692 unsigned nearly_empty_p : 1;
1693 unsigned user_align : 1;
1694 unsigned has_copy_assign : 1;
1695 unsigned has_new : 1;
1696 unsigned has_array_new : 1;
1697
1698 unsigned gets_delete : 2;
1699 unsigned interface_only : 1;
1700 unsigned interface_unknown : 1;
1701 unsigned contains_empty_class_p : 1;
1702 unsigned anon_aggr : 1;
1703 unsigned non_zero_init : 1;
1704 unsigned empty_p : 1;
1705
1706 unsigned vec_new_uses_cookie : 1;
1707 unsigned declared_class : 1;
1708 unsigned diamond_shaped : 1;
1709 unsigned repeated_base : 1;
1710 unsigned being_defined : 1;
1711 unsigned java_interface : 1;
1712 unsigned debug_requested : 1;
1713 unsigned fields_readonly : 1;
1714
1715 unsigned use_template : 2;
1716 unsigned ptrmemfunc_flag : 1;
1717 unsigned was_anonymous : 1;
1718 unsigned lazy_default_ctor : 1;
1719 unsigned lazy_copy_ctor : 1;
1720 unsigned lazy_copy_assign : 1;
1721 unsigned lazy_destructor : 1;
1722
1723 unsigned has_const_copy_ctor : 1;
1724 unsigned has_complex_copy_ctor : 1;
1725 unsigned has_complex_copy_assign : 1;
1726 unsigned non_aggregate : 1;
1727 unsigned has_complex_dflt : 1;
1728 unsigned has_list_ctor : 1;
1729 unsigned non_std_layout : 1;
1730 unsigned is_literal : 1;
1731
1732 unsigned lazy_move_ctor : 1;
1733 unsigned lazy_move_assign : 1;
1734 unsigned has_complex_move_ctor : 1;
1735 unsigned has_complex_move_assign : 1;
1736 unsigned has_constexpr_ctor : 1;
1737
1738 /* When adding a flag here, consider whether or not it ought to
1739 apply to a template instance if it applies to the template. If
1740 so, make sure to copy it in instantiate_class_template! */
1741
1742 /* There are some bits left to fill out a 32-bit word. Keep track
1743 of this by updating the size of this bitfield whenever you add or
1744 remove a flag. */
1745 unsigned dummy : 3;
1746
1747 tree primary_base;
1748 vec<tree_pair_s, va_gc> *vcall_indices;
1749 tree vtables;
1750 tree typeinfo_var;
1751 vec<tree, va_gc> *vbases;
1752 binding_table nested_udts;
1753 tree as_base;
1754 vec<tree, va_gc> *pure_virtuals;
1755 tree friend_classes;
1756 vec<tree, va_gc> * GTY((reorder ("resort_type_method_vec"))) methods;
1757 tree key_method;
1758 tree decl_list;
1759 tree template_info;
1760 tree befriending_classes;
1761 /* In a RECORD_TYPE, information specific to Objective-C++, such
1762 as a list of adopted protocols or a pointer to a corresponding
1763 @interface. See objc/objc-act.h for details. */
1764 tree objc_info;
1765 /* sorted_fields is sorted based on a pointer, so we need to be able
1766 to resort it if pointers get rearranged. */
1767 struct sorted_fields_type * GTY ((reorder ("resort_sorted_fields")))
1768 sorted_fields;
1769 /* FIXME reuse another field? */
1770 tree lambda_expr;
1771 };
1772
1773 struct GTY(()) lang_type_ptrmem {
1774 struct lang_type_header h;
1775 tree record;
1776 };
1777
1778 struct GTY(()) lang_type {
1779 union lang_type_u
1780 {
1781 struct lang_type_header GTY((skip (""))) h;
1782 struct lang_type_class GTY((tag ("1"))) c;
1783 struct lang_type_ptrmem GTY((tag ("0"))) ptrmem;
1784 } GTY((desc ("%h.h.is_lang_type_class"))) u;
1785 };
1786
1787 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
1788
1789 #define LANG_TYPE_CLASS_CHECK(NODE) __extension__ \
1790 ({ struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE); \
1791 if (! lt->u.h.is_lang_type_class) \
1792 lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
1793 <->u.c; })
1794
1795 #define LANG_TYPE_PTRMEM_CHECK(NODE) __extension__ \
1796 ({ struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE); \
1797 if (lt->u.h.is_lang_type_class) \
1798 lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
1799 <->u.ptrmem; })
1800
1801 #else
1802
1803 #define LANG_TYPE_CLASS_CHECK(NODE) (&TYPE_LANG_SPECIFIC (NODE)->u.c)
1804 #define LANG_TYPE_PTRMEM_CHECK(NODE) (&TYPE_LANG_SPECIFIC (NODE)->u.ptrmem)
1805
1806 #endif /* ENABLE_TREE_CHECKING */
1807
1808 /* Nonzero for _CLASSTYPE means that operator delete is defined. */
1809 #define TYPE_GETS_DELETE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->gets_delete)
1810 #define TYPE_GETS_REG_DELETE(NODE) (TYPE_GETS_DELETE (NODE) & 1)
1811
1812 /* Nonzero if `new NODE[x]' should cause the allocation of extra
1813 storage to indicate how many array elements are in use. */
1814 #define TYPE_VEC_NEW_USES_COOKIE(NODE) \
1815 (CLASS_TYPE_P (NODE) \
1816 && LANG_TYPE_CLASS_CHECK (NODE)->vec_new_uses_cookie)
1817
1818 /* Nonzero means that this _CLASSTYPE node defines ways of converting
1819 itself to other types. */
1820 #define TYPE_HAS_CONVERSION(NODE) \
1821 (LANG_TYPE_CLASS_CHECK (NODE)->h.has_type_conversion)
1822
1823 /* Nonzero means that NODE (a class type) has a default constructor --
1824 but that it has not yet been declared. */
1825 #define CLASSTYPE_LAZY_DEFAULT_CTOR(NODE) \
1826 (LANG_TYPE_CLASS_CHECK (NODE)->lazy_default_ctor)
1827
1828 /* Nonzero means that NODE (a class type) has a copy constructor --
1829 but that it has not yet been declared. */
1830 #define CLASSTYPE_LAZY_COPY_CTOR(NODE) \
1831 (LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_ctor)
1832
1833 /* Nonzero means that NODE (a class type) has a move constructor --
1834 but that it has not yet been declared. */
1835 #define CLASSTYPE_LAZY_MOVE_CTOR(NODE) \
1836 (LANG_TYPE_CLASS_CHECK (NODE)->lazy_move_ctor)
1837
1838 /* Nonzero means that NODE (a class type) has an assignment operator
1839 -- but that it has not yet been declared. */
1840 #define CLASSTYPE_LAZY_COPY_ASSIGN(NODE) \
1841 (LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_assign)
1842
1843 /* Nonzero means that NODE (a class type) has an assignment operator
1844 -- but that it has not yet been declared. */
1845 #define CLASSTYPE_LAZY_MOVE_ASSIGN(NODE) \
1846 (LANG_TYPE_CLASS_CHECK (NODE)->lazy_move_assign)
1847
1848 /* Nonzero means that NODE (a class type) has a destructor -- but that
1849 it has not yet been declared. */
1850 #define CLASSTYPE_LAZY_DESTRUCTOR(NODE) \
1851 (LANG_TYPE_CLASS_CHECK (NODE)->lazy_destructor)
1852
1853 /* Nonzero means that NODE (a class type) is final */
1854 #define CLASSTYPE_FINAL(NODE) \
1855 TYPE_FINAL_P (NODE)
1856
1857
1858 /* Nonzero means that this _CLASSTYPE node overloads operator=(X&). */
1859 #define TYPE_HAS_COPY_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_copy_assign)
1860
1861 /* True iff the class type NODE has an "operator =" whose parameter
1862 has a parameter of type "const X&". */
1863 #define TYPE_HAS_CONST_COPY_ASSIGN(NODE) \
1864 (LANG_TYPE_CLASS_CHECK (NODE)->h.has_const_copy_assign)
1865
1866 /* Nonzero means that this _CLASSTYPE node has an X(X&) constructor. */
1867 #define TYPE_HAS_COPY_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->h.has_copy_ctor)
1868 #define TYPE_HAS_CONST_COPY_CTOR(NODE) \
1869 (LANG_TYPE_CLASS_CHECK (NODE)->has_const_copy_ctor)
1870
1871 /* Nonzero if this class has an X(initializer_list<T>) constructor. */
1872 #define TYPE_HAS_LIST_CTOR(NODE) \
1873 (LANG_TYPE_CLASS_CHECK (NODE)->has_list_ctor)
1874
1875 /* Nonzero if this class has a constexpr constructor other than a copy/move
1876 constructor. Note that a class can have constexpr constructors for
1877 static initialization even if it isn't a literal class. */
1878 #define TYPE_HAS_CONSTEXPR_CTOR(NODE) \
1879 (LANG_TYPE_CLASS_CHECK (NODE)->has_constexpr_ctor)
1880
1881 /* Nonzero if this class defines an overloaded operator new. (An
1882 operator new [] doesn't count.) */
1883 #define TYPE_HAS_NEW_OPERATOR(NODE) \
1884 (LANG_TYPE_CLASS_CHECK (NODE)->has_new)
1885
1886 /* Nonzero if this class defines an overloaded operator new[]. */
1887 #define TYPE_HAS_ARRAY_NEW_OPERATOR(NODE) \
1888 (LANG_TYPE_CLASS_CHECK (NODE)->has_array_new)
1889
1890 /* Nonzero means that this type is being defined. I.e., the left brace
1891 starting the definition of this type has been seen. */
1892 #define TYPE_BEING_DEFINED(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->being_defined)
1893
1894 /* Nonzero means that this type is either complete or being defined, so we
1895 can do lookup in it. */
1896 #define COMPLETE_OR_OPEN_TYPE_P(NODE) \
1897 (COMPLETE_TYPE_P (NODE) || (CLASS_TYPE_P (NODE) && TYPE_BEING_DEFINED (NODE)))
1898
1899 /* Mark bits for repeated base checks. */
1900 #define TYPE_MARKED_P(NODE) TREE_LANG_FLAG_6 (TYPE_CHECK (NODE))
1901
1902 /* Nonzero if the class NODE has multiple paths to the same (virtual)
1903 base object. */
1904 #define CLASSTYPE_DIAMOND_SHAPED_P(NODE) \
1905 (LANG_TYPE_CLASS_CHECK(NODE)->diamond_shaped)
1906
1907 /* Nonzero if the class NODE has multiple instances of the same base
1908 type. */
1909 #define CLASSTYPE_REPEATED_BASE_P(NODE) \
1910 (LANG_TYPE_CLASS_CHECK(NODE)->repeated_base)
1911
1912 /* The member function with which the vtable will be emitted:
1913 the first noninline non-pure-virtual member function. NULL_TREE
1914 if there is no key function or if this is a class template */
1915 #define CLASSTYPE_KEY_METHOD(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->key_method)
1916
1917 /* Vector member functions defined in this class. Each element is
1918 either a FUNCTION_DECL, a TEMPLATE_DECL, or an OVERLOAD. All
1919 functions with the same name end up in the same slot. The first
1920 two elements are for constructors, and destructors, respectively.
1921 All template conversion operators to innermost template dependent
1922 types are overloaded on the next slot, if they exist. Note, the
1923 names for these functions will not all be the same. The
1924 non-template conversion operators & templated conversions to
1925 non-innermost template types are next, followed by ordinary member
1926 functions. There may be empty entries at the end of the vector.
1927 The conversion operators are unsorted. The ordinary member
1928 functions are sorted, once the class is complete. */
1929 #define CLASSTYPE_METHOD_VEC(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->methods)
1930
1931 /* For class templates, this is a TREE_LIST of all member data,
1932 functions, types, and friends in the order of declaration.
1933 The TREE_PURPOSE of each TREE_LIST is NULL_TREE for a friend,
1934 and the RECORD_TYPE for the class template otherwise. */
1935 #define CLASSTYPE_DECL_LIST(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->decl_list)
1936
1937 /* The slot in the CLASSTYPE_METHOD_VEC where constructors go. */
1938 #define CLASSTYPE_CONSTRUCTOR_SLOT 0
1939
1940 /* The slot in the CLASSTYPE_METHOD_VEC where destructors go. */
1941 #define CLASSTYPE_DESTRUCTOR_SLOT 1
1942
1943 /* The first slot in the CLASSTYPE_METHOD_VEC where conversion
1944 operators can appear. */
1945 #define CLASSTYPE_FIRST_CONVERSION_SLOT 2
1946
1947 /* A FUNCTION_DECL or OVERLOAD for the constructors for NODE. These
1948 are the constructors that take an in-charge parameter. */
1949 #define CLASSTYPE_CONSTRUCTORS(NODE) \
1950 ((*CLASSTYPE_METHOD_VEC (NODE))[CLASSTYPE_CONSTRUCTOR_SLOT])
1951
1952 /* A FUNCTION_DECL for the destructor for NODE. These are the
1953 destructors that take an in-charge parameter. If
1954 CLASSTYPE_LAZY_DESTRUCTOR is true, then this entry will be NULL
1955 until the destructor is created with lazily_declare_fn. */
1956 #define CLASSTYPE_DESTRUCTORS(NODE) \
1957 (CLASSTYPE_METHOD_VEC (NODE) \
1958 ? (*CLASSTYPE_METHOD_VEC (NODE))[CLASSTYPE_DESTRUCTOR_SLOT] \
1959 : NULL_TREE)
1960
1961 /* A dictionary of the nested user-defined-types (class-types, or enums)
1962 found within this class. This table includes nested member class
1963 templates. */
1964 #define CLASSTYPE_NESTED_UTDS(NODE) \
1965 (LANG_TYPE_CLASS_CHECK (NODE)->nested_udts)
1966
1967 /* Nonzero if NODE has a primary base class, i.e., a base class with
1968 which it shares the virtual function table pointer. */
1969 #define CLASSTYPE_HAS_PRIMARY_BASE_P(NODE) \
1970 (CLASSTYPE_PRIMARY_BINFO (NODE) != NULL_TREE)
1971
1972 /* If non-NULL, this is the binfo for the primary base class, i.e.,
1973 the base class which contains the virtual function table pointer
1974 for this class. */
1975 #define CLASSTYPE_PRIMARY_BINFO(NODE) \
1976 (LANG_TYPE_CLASS_CHECK (NODE)->primary_base)
1977
1978 /* A vector of BINFOs for the direct and indirect virtual base classes
1979 that this type uses in a post-order depth-first left-to-right
1980 order. (In other words, these bases appear in the order that they
1981 should be initialized.) */
1982 #define CLASSTYPE_VBASECLASSES(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->vbases)
1983
1984 /* The type corresponding to NODE when NODE is used as a base class,
1985 i.e., NODE without virtual base classes or tail padding. */
1986
1987 #define CLASSTYPE_AS_BASE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->as_base)
1988
1989 /* True iff NODE is the CLASSTYPE_AS_BASE version of some type. */
1990
1991 #define IS_FAKE_BASE_TYPE(NODE) \
1992 (TREE_CODE (NODE) == RECORD_TYPE \
1993 && TYPE_CONTEXT (NODE) && CLASS_TYPE_P (TYPE_CONTEXT (NODE)) \
1994 && CLASSTYPE_AS_BASE (TYPE_CONTEXT (NODE)) == (NODE))
1995
1996 /* These are the size and alignment of the type without its virtual
1997 base classes, for when we use this type as a base itself. */
1998 #define CLASSTYPE_SIZE(NODE) TYPE_SIZE (CLASSTYPE_AS_BASE (NODE))
1999 #define CLASSTYPE_SIZE_UNIT(NODE) TYPE_SIZE_UNIT (CLASSTYPE_AS_BASE (NODE))
2000 #define CLASSTYPE_ALIGN(NODE) TYPE_ALIGN (CLASSTYPE_AS_BASE (NODE))
2001 #define CLASSTYPE_USER_ALIGN(NODE) TYPE_USER_ALIGN (CLASSTYPE_AS_BASE (NODE))
2002
2003 /* The alignment of NODE, without its virtual bases, in bytes. */
2004 #define CLASSTYPE_ALIGN_UNIT(NODE) \
2005 (CLASSTYPE_ALIGN (NODE) / BITS_PER_UNIT)
2006
2007 /* True if this a Java interface type, declared with
2008 '__attribute__ ((java_interface))'. */
2009 #define TYPE_JAVA_INTERFACE(NODE) \
2010 (LANG_TYPE_CLASS_CHECK (NODE)->java_interface)
2011
2012 /* A vec<tree> of virtual functions which cannot be inherited by
2013 derived classes. When deriving from this type, the derived
2014 class must provide its own definition for each of these functions. */
2015 #define CLASSTYPE_PURE_VIRTUALS(NODE) \
2016 (LANG_TYPE_CLASS_CHECK (NODE)->pure_virtuals)
2017
2018 /* Nonzero means that this type is an abstract class type. */
2019 #define ABSTRACT_CLASS_TYPE_P(NODE) \
2020 (CLASS_TYPE_P (NODE) && CLASSTYPE_PURE_VIRTUALS(NODE))
2021
2022 /* Nonzero means that this type has an X() constructor. */
2023 #define TYPE_HAS_DEFAULT_CONSTRUCTOR(NODE) \
2024 (LANG_TYPE_CLASS_CHECK (NODE)->h.has_default_ctor)
2025
2026 /* Nonzero means that this type contains a mutable member. */
2027 #define CLASSTYPE_HAS_MUTABLE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_mutable)
2028 #define TYPE_HAS_MUTABLE_P(NODE) (cp_has_mutable_p (NODE))
2029
2030 /* Nonzero means that this class type is not POD for the purpose of layout
2031 (as defined in the ABI). This is different from the language's POD. */
2032 #define CLASSTYPE_NON_LAYOUT_POD_P(NODE) \
2033 (LANG_TYPE_CLASS_CHECK (NODE)->non_pod_class)
2034
2035 /* Nonzero means that this class type is a non-standard-layout class. */
2036 #define CLASSTYPE_NON_STD_LAYOUT(NODE) \
2037 (LANG_TYPE_CLASS_CHECK (NODE)->non_std_layout)
2038
2039 /* Nonzero means that this class contains pod types whose default
2040 initialization is not a zero initialization (namely, pointers to
2041 data members). */
2042 #define CLASSTYPE_NON_ZERO_INIT_P(NODE) \
2043 (LANG_TYPE_CLASS_CHECK (NODE)->non_zero_init)
2044
2045 /* Nonzero if this class is "empty" in the sense of the C++ ABI. */
2046 #define CLASSTYPE_EMPTY_P(NODE) \
2047 (LANG_TYPE_CLASS_CHECK (NODE)->empty_p)
2048
2049 /* Nonzero if this class is "nearly empty", i.e., contains only a
2050 virtual function table pointer. */
2051 #define CLASSTYPE_NEARLY_EMPTY_P(NODE) \
2052 (LANG_TYPE_CLASS_CHECK (NODE)->nearly_empty_p)
2053
2054 /* Nonzero if this class contains an empty subobject. */
2055 #define CLASSTYPE_CONTAINS_EMPTY_CLASS_P(NODE) \
2056 (LANG_TYPE_CLASS_CHECK (NODE)->contains_empty_class_p)
2057
2058 /* A list of class types of which this type is a friend. The
2059 TREE_VALUE is normally a TYPE, but will be a TEMPLATE_DECL in the
2060 case of a template friend. */
2061 #define CLASSTYPE_FRIEND_CLASSES(NODE) \
2062 (LANG_TYPE_CLASS_CHECK (NODE)->friend_classes)
2063
2064 /* A list of the classes which grant friendship to this class. */
2065 #define CLASSTYPE_BEFRIENDING_CLASSES(NODE) \
2066 (LANG_TYPE_CLASS_CHECK (NODE)->befriending_classes)
2067
2068 /* The associated LAMBDA_EXPR that made this class. */
2069 #define CLASSTYPE_LAMBDA_EXPR(NODE) \
2070 (LANG_TYPE_CLASS_CHECK (NODE)->lambda_expr)
2071 /* The extra mangling scope for this closure type. */
2072 #define LAMBDA_TYPE_EXTRA_SCOPE(NODE) \
2073 (LAMBDA_EXPR_EXTRA_SCOPE (CLASSTYPE_LAMBDA_EXPR (NODE)))
2074
2075 /* Say whether this node was declared as a "class" or a "struct". */
2076 #define CLASSTYPE_DECLARED_CLASS(NODE) \
2077 (LANG_TYPE_CLASS_CHECK (NODE)->declared_class)
2078
2079 /* Nonzero if this class has const members
2080 which have no specified initialization. */
2081 #define CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE) \
2082 (TYPE_LANG_SPECIFIC (NODE) \
2083 ? LANG_TYPE_CLASS_CHECK (NODE)->h.const_needs_init : 0)
2084 #define SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE, VALUE) \
2085 (LANG_TYPE_CLASS_CHECK (NODE)->h.const_needs_init = (VALUE))
2086
2087 /* Nonzero if this class has ref members
2088 which have no specified initialization. */
2089 #define CLASSTYPE_REF_FIELDS_NEED_INIT(NODE) \
2090 (TYPE_LANG_SPECIFIC (NODE) \
2091 ? LANG_TYPE_CLASS_CHECK (NODE)->h.ref_needs_init : 0)
2092 #define SET_CLASSTYPE_REF_FIELDS_NEED_INIT(NODE, VALUE) \
2093 (LANG_TYPE_CLASS_CHECK (NODE)->h.ref_needs_init = (VALUE))
2094
2095 /* Nonzero if this class is included from a header file which employs
2096 `#pragma interface', and it is not included in its implementation file. */
2097 #define CLASSTYPE_INTERFACE_ONLY(NODE) \
2098 (LANG_TYPE_CLASS_CHECK (NODE)->interface_only)
2099
2100 /* True if we have already determined whether or not vtables, VTTs,
2101 typeinfo, and other similar per-class data should be emitted in
2102 this translation unit. This flag does not indicate whether or not
2103 these items should be emitted; it only indicates that we know one
2104 way or the other. */
2105 #define CLASSTYPE_INTERFACE_KNOWN(NODE) \
2106 (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown == 0)
2107 /* The opposite of CLASSTYPE_INTERFACE_KNOWN. */
2108 #define CLASSTYPE_INTERFACE_UNKNOWN(NODE) \
2109 (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown)
2110
2111 #define SET_CLASSTYPE_INTERFACE_UNKNOWN_X(NODE,X) \
2112 (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = !!(X))
2113 #define SET_CLASSTYPE_INTERFACE_UNKNOWN(NODE) \
2114 (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 1)
2115 #define SET_CLASSTYPE_INTERFACE_KNOWN(NODE) \
2116 (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 0)
2117
2118 /* Nonzero if a _DECL node requires us to output debug info for this class. */
2119 #define CLASSTYPE_DEBUG_REQUESTED(NODE) \
2120 (LANG_TYPE_CLASS_CHECK (NODE)->debug_requested)
2121
2122 /* Additional macros for inheritance information. */
2123
2124 /* Nonzero means that this class is on a path leading to a new vtable. */
2125 #define BINFO_VTABLE_PATH_MARKED(NODE) BINFO_FLAG_1 (NODE)
2126
2127 /* Nonzero means B (a BINFO) has its own vtable. Any copies will not
2128 have this flag set. */
2129 #define BINFO_NEW_VTABLE_MARKED(B) (BINFO_FLAG_2 (B))
2130
2131 /* Compare a BINFO_TYPE with another type for equality. For a binfo,
2132 this is functionally equivalent to using same_type_p, but
2133 measurably faster. At least one of the arguments must be a
2134 BINFO_TYPE. The other can be a BINFO_TYPE or a regular type. If
2135 BINFO_TYPE(T) ever stops being the main variant of the class the
2136 binfo is for, this macro must change. */
2137 #define SAME_BINFO_TYPE_P(A, B) ((A) == (B))
2138
2139 /* Any subobject that needs a new vtable must have a vptr and must not
2140 be a non-virtual primary base (since it would then use the vtable from a
2141 derived class and never become non-primary.) */
2142 #define SET_BINFO_NEW_VTABLE_MARKED(B) \
2143 (BINFO_NEW_VTABLE_MARKED (B) = 1, \
2144 gcc_assert (!BINFO_PRIMARY_P (B) || BINFO_VIRTUAL_P (B)), \
2145 gcc_assert (TYPE_VFIELD (BINFO_TYPE (B))))
2146
2147 /* Nonzero if this binfo is for a dependent base - one that should not
2148 be searched. */
2149 #define BINFO_DEPENDENT_BASE_P(NODE) BINFO_FLAG_3 (NODE)
2150
2151 /* Nonzero if this binfo has lost its primary base binfo (because that
2152 is a nearly-empty virtual base that has been taken by some other
2153 base in the complete hierarchy. */
2154 #define BINFO_LOST_PRIMARY_P(NODE) BINFO_FLAG_4 (NODE)
2155
2156 /* Nonzero if this BINFO is a primary base class. */
2157 #define BINFO_PRIMARY_P(NODE) BINFO_FLAG_5(NODE)
2158
2159 /* Used by various search routines. */
2160 #define IDENTIFIER_MARKED(NODE) TREE_LANG_FLAG_0 (NODE)
2161
2162 /* A vec<tree_pair_s> of the vcall indices associated with the class
2163 NODE. The PURPOSE of each element is a FUNCTION_DECL for a virtual
2164 function. The VALUE is the index into the virtual table where the
2165 vcall offset for that function is stored, when NODE is a virtual
2166 base. */
2167 #define CLASSTYPE_VCALL_INDICES(NODE) \
2168 (LANG_TYPE_CLASS_CHECK (NODE)->vcall_indices)
2169
2170 /* The various vtables for the class NODE. The primary vtable will be
2171 first, followed by the construction vtables and VTT, if any. */
2172 #define CLASSTYPE_VTABLES(NODE) \
2173 (LANG_TYPE_CLASS_CHECK (NODE)->vtables)
2174
2175 /* The std::type_info variable representing this class, or NULL if no
2176 such variable has been created. This field is only set for the
2177 TYPE_MAIN_VARIANT of the class. */
2178 #define CLASSTYPE_TYPEINFO_VAR(NODE) \
2179 (LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var)
2180
2181 /* Accessor macros for the BINFO_VIRTUALS list. */
2182
2183 /* The number of bytes by which to adjust the `this' pointer when
2184 calling this virtual function. Subtract this value from the this
2185 pointer. Always non-NULL, might be constant zero though. */
2186 #define BV_DELTA(NODE) (TREE_PURPOSE (NODE))
2187
2188 /* If non-NULL, the vtable index at which to find the vcall offset
2189 when calling this virtual function. Add the value at that vtable
2190 index to the this pointer. */
2191 #define BV_VCALL_INDEX(NODE) (TREE_TYPE (NODE))
2192
2193 /* The function to call. */
2194 #define BV_FN(NODE) (TREE_VALUE (NODE))
2195
2196 /* Whether or not this entry is for a lost primary virtual base. */
2197 #define BV_LOST_PRIMARY(NODE) (TREE_LANG_FLAG_0 (NODE))
2198
2199 /* For FUNCTION_TYPE or METHOD_TYPE, a list of the exceptions that
2200 this type can raise. Each TREE_VALUE is a _TYPE. The TREE_VALUE
2201 will be NULL_TREE to indicate a throw specification of `()', or
2202 no exceptions allowed. For a noexcept specification, TREE_VALUE
2203 is NULL_TREE and TREE_PURPOSE is the constant-expression. For
2204 a deferred noexcept-specification, TREE_PURPOSE is a DEFERRED_NOEXCEPT
2205 (for templates) or an OVERLOAD list of functions (for implicitly
2206 declared functions). */
2207 #define TYPE_RAISES_EXCEPTIONS(NODE) \
2208 TYPE_LANG_SLOT_1 (FUNC_OR_METHOD_CHECK (NODE))
2209
2210 /* For FUNCTION_TYPE or METHOD_TYPE, return 1 iff it is declared `throw()'
2211 or noexcept(true). */
2212 #define TYPE_NOTHROW_P(NODE) nothrow_spec_p (TYPE_RAISES_EXCEPTIONS (NODE))
2213
2214 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
2215 case for things declared noexcept(true) and, with -fnothrow-opt, for
2216 throw() functions. */
2217 #define TYPE_NOEXCEPT_P(NODE) type_noexcept_p (NODE)
2218
2219 /* The binding level associated with the namespace. */
2220 #define NAMESPACE_LEVEL(NODE) \
2221 (LANG_DECL_NS_CHECK (NODE)->level)
2222
2223 /* Flags shared by all forms of DECL_LANG_SPECIFIC.
2224
2225 Some of the flags live here only to make lang_decl_min/fn smaller. Do
2226 not make this struct larger than 32 bits; instead, make sel smaller. */
2227
2228 struct GTY(()) lang_decl_base {
2229 unsigned selector : 16; /* Larger than necessary for faster access. */
2230 ENUM_BITFIELD(languages) language : 4;
2231 unsigned use_template : 2;
2232 unsigned not_really_extern : 1; /* var or fn */
2233 unsigned initialized_in_class : 1; /* var or fn */
2234 unsigned repo_available_p : 1; /* var or fn */
2235 unsigned threadprivate_or_deleted_p : 1; /* var or fn */
2236 unsigned anticipated_p : 1; /* fn, type or template */
2237 /* anticipated_p reused as DECL_OMP_PRIVATIZED_MEMBER in var */
2238 unsigned friend_or_tls : 1; /* var, fn, type or template */
2239 unsigned template_conv_p : 1; /* var or template */
2240 unsigned odr_used : 1; /* var or fn */
2241 unsigned u2sel : 1;
2242 unsigned concept_p : 1; /* applies to vars and functions */
2243 /* 0 spare bits */
2244 };
2245
2246 /* True for DECL codes which have template info and access. */
2247 #define LANG_DECL_HAS_MIN(NODE) \
2248 (VAR_OR_FUNCTION_DECL_P (NODE) \
2249 || TREE_CODE (NODE) == FIELD_DECL \
2250 || TREE_CODE (NODE) == CONST_DECL \
2251 || TREE_CODE (NODE) == TYPE_DECL \
2252 || TREE_CODE (NODE) == TEMPLATE_DECL \
2253 || TREE_CODE (NODE) == USING_DECL)
2254
2255 /* DECL_LANG_SPECIFIC for the above codes. */
2256
2257 struct GTY(()) lang_decl_min {
2258 struct lang_decl_base base;
2259
2260 /* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is
2261 THUNK_ALIAS.
2262 In a FUNCTION_DECL for which DECL_THUNK_P does not hold,
2263 VAR_DECL, TYPE_DECL, or TEMPLATE_DECL, this is
2264 DECL_TEMPLATE_INFO. */
2265 tree template_info;
2266
2267 union lang_decl_u2 {
2268 /* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is
2269 THUNK_VIRTUAL_OFFSET.
2270 Otherwise this is DECL_ACCESS. */
2271 tree GTY ((tag ("0"))) access;
2272
2273 /* For VAR_DECL in function, this is DECL_DISCRIMINATOR. */
2274 int GTY ((tag ("1"))) discriminator;
2275 } GTY ((desc ("%0.u.base.u2sel"))) u2;
2276 };
2277
2278 /* Additional DECL_LANG_SPECIFIC information for functions. */
2279
2280 struct GTY(()) lang_decl_fn {
2281 struct lang_decl_min min;
2282
2283 /* In an overloaded operator, this is the value of
2284 DECL_OVERLOADED_OPERATOR_P. */
2285 ENUM_BITFIELD (tree_code) operator_code : 16;
2286
2287 unsigned global_ctor_p : 1;
2288 unsigned global_dtor_p : 1;
2289 unsigned assignment_operator_p : 1;
2290 unsigned static_function : 1;
2291 unsigned pure_virtual : 1;
2292 unsigned defaulted_p : 1;
2293
2294 unsigned has_in_charge_parm_p : 1;
2295 unsigned has_vtt_parm_p : 1;
2296 unsigned pending_inline_p : 1;
2297 unsigned nonconverting : 1;
2298 unsigned thunk_p : 1;
2299 unsigned this_thunk_p : 1;
2300 unsigned hidden_friend_p : 1;
2301 unsigned omp_declare_reduction_p : 1;
2302 /* 2 spare bits on 32-bit hosts, 34 on 64-bit hosts. */
2303
2304 /* For a non-thunk function decl, this is a tree list of
2305 friendly classes. For a thunk function decl, it is the
2306 thunked to function decl. */
2307 tree befriending_classes;
2308
2309 /* For a non-virtual FUNCTION_DECL, this is
2310 DECL_FRIEND_CONTEXT. For a virtual FUNCTION_DECL for which
2311 DECL_THIS_THUNK_P does not hold, this is DECL_THUNKS. Both
2312 this pointer and result pointer adjusting thunks are
2313 chained here. This pointer thunks to return pointer thunks
2314 will be chained on the return pointer thunk. */
2315 tree context;
2316
2317 union lang_decl_u5
2318 {
2319 /* In a non-thunk FUNCTION_DECL or TEMPLATE_DECL, this is
2320 DECL_CLONED_FUNCTION. */
2321 tree GTY ((tag ("0"))) cloned_function;
2322
2323 /* In a FUNCTION_DECL for which THUNK_P holds this is the
2324 THUNK_FIXED_OFFSET. */
2325 HOST_WIDE_INT GTY ((tag ("1"))) fixed_offset;
2326 } GTY ((desc ("%1.thunk_p"))) u5;
2327
2328 union lang_decl_u3
2329 {
2330 struct cp_token_cache * GTY ((tag ("1"))) pending_inline_info;
2331 struct language_function * GTY ((tag ("0")))
2332 saved_language_function;
2333 } GTY ((desc ("%1.pending_inline_p"))) u;
2334
2335 };
2336
2337 /* DECL_LANG_SPECIFIC for namespaces. */
2338
2339 struct GTY(()) lang_decl_ns {
2340 struct lang_decl_base base;
2341 cp_binding_level *level;
2342 tree ns_using;
2343 tree ns_users;
2344 };
2345
2346 /* DECL_LANG_SPECIFIC for parameters. */
2347
2348 struct GTY(()) lang_decl_parm {
2349 struct lang_decl_base base;
2350 int level;
2351 int index;
2352 };
2353
2354 /* DECL_LANG_SPECIFIC for all types. It would be nice to just make this a
2355 union rather than a struct containing a union as its only field, but
2356 tree.h declares it as a struct. */
2357
2358 struct GTY(()) lang_decl {
2359 union GTY((desc ("%h.base.selector"))) lang_decl_u {
2360 struct lang_decl_base GTY ((default)) base;
2361 struct lang_decl_min GTY((tag ("0"))) min;
2362 struct lang_decl_fn GTY ((tag ("1"))) fn;
2363 struct lang_decl_ns GTY((tag ("2"))) ns;
2364 struct lang_decl_parm GTY((tag ("3"))) parm;
2365 } u;
2366 };
2367
2368 /* Looks through a template (if present) to find what it declares. */
2369 #define STRIP_TEMPLATE(NODE) \
2370 (TREE_CODE (NODE) == TEMPLATE_DECL ? DECL_TEMPLATE_RESULT (NODE) : NODE)
2371
2372 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
2373
2374 #define LANG_DECL_MIN_CHECK(NODE) __extension__ \
2375 ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \
2376 if (!LANG_DECL_HAS_MIN (NODE)) \
2377 lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
2378 <->u.min; })
2379
2380 /* We want to be able to check DECL_CONSTRUCTOR_P and such on a function
2381 template, not just on a FUNCTION_DECL. So when looking for things in
2382 lang_decl_fn, look down through a TEMPLATE_DECL into its result. */
2383 #define LANG_DECL_FN_CHECK(NODE) __extension__ \
2384 ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (STRIP_TEMPLATE (NODE)); \
2385 if (!DECL_DECLARES_FUNCTION_P (NODE) || lt->u.base.selector != 1) \
2386 lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
2387 <->u.fn; })
2388
2389 #define LANG_DECL_NS_CHECK(NODE) __extension__ \
2390 ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \
2391 if (TREE_CODE (NODE) != NAMESPACE_DECL || lt->u.base.selector != 2) \
2392 lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
2393 <->u.ns; })
2394
2395 #define LANG_DECL_PARM_CHECK(NODE) __extension__ \
2396 ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \
2397 if (TREE_CODE (NODE) != PARM_DECL) \
2398 lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
2399 <->u.parm; })
2400
2401 #define LANG_DECL_U2_CHECK(NODE, TF) __extension__ \
2402 ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \
2403 if (!LANG_DECL_HAS_MIN (NODE) || lt->u.base.u2sel != TF) \
2404 lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
2405 <->u.min.u2; })
2406
2407 #else
2408
2409 #define LANG_DECL_MIN_CHECK(NODE) \
2410 (&DECL_LANG_SPECIFIC (NODE)->u.min)
2411
2412 #define LANG_DECL_FN_CHECK(NODE) \
2413 (&DECL_LANG_SPECIFIC (STRIP_TEMPLATE (NODE))->u.fn)
2414
2415 #define LANG_DECL_NS_CHECK(NODE) \
2416 (&DECL_LANG_SPECIFIC (NODE)->u.ns)
2417
2418 #define LANG_DECL_PARM_CHECK(NODE) \
2419 (&DECL_LANG_SPECIFIC (NODE)->u.parm)
2420
2421 #define LANG_DECL_U2_CHECK(NODE, TF) \
2422 (&DECL_LANG_SPECIFIC (NODE)->u.min.u2)
2423
2424 #endif /* ENABLE_TREE_CHECKING */
2425
2426 /* For a FUNCTION_DECL or a VAR_DECL, the language linkage for the
2427 declaration. Some entities (like a member function in a local
2428 class, or a local variable) do not have linkage at all, and this
2429 macro should not be used in those cases.
2430
2431 Implementation note: A FUNCTION_DECL without DECL_LANG_SPECIFIC was
2432 created by language-independent code, and has C linkage. Most
2433 VAR_DECLs have C++ linkage, and do not have DECL_LANG_SPECIFIC, but
2434 we do create DECL_LANG_SPECIFIC for variables with non-C++ linkage. */
2435 #define DECL_LANGUAGE(NODE) \
2436 (DECL_LANG_SPECIFIC (NODE) \
2437 ? DECL_LANG_SPECIFIC (NODE)->u.base.language \
2438 : (TREE_CODE (NODE) == FUNCTION_DECL \
2439 ? lang_c : lang_cplusplus))
2440
2441 /* Set the language linkage for NODE to LANGUAGE. */
2442 #define SET_DECL_LANGUAGE(NODE, LANGUAGE) \
2443 (DECL_LANG_SPECIFIC (NODE)->u.base.language = (LANGUAGE))
2444
2445 /* For FUNCTION_DECLs and TEMPLATE_DECLs: nonzero means that this function
2446 is a constructor. */
2447 #define DECL_CONSTRUCTOR_P(NODE) \
2448 DECL_CXX_CONSTRUCTOR_P (STRIP_TEMPLATE (NODE))
2449
2450 /* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a complete
2451 object. */
2452 #define DECL_COMPLETE_CONSTRUCTOR_P(NODE) \
2453 (DECL_CONSTRUCTOR_P (NODE) \
2454 && DECL_NAME (NODE) == complete_ctor_identifier)
2455
2456 /* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a base
2457 object. */
2458 #define DECL_BASE_CONSTRUCTOR_P(NODE) \
2459 (DECL_CONSTRUCTOR_P (NODE) \
2460 && DECL_NAME (NODE) == base_ctor_identifier)
2461
2462 /* Nonzero if NODE (a FUNCTION_DECL) is a constructor, but not either the
2463 specialized in-charge constructor or the specialized not-in-charge
2464 constructor. */
2465 #define DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P(NODE) \
2466 (DECL_DECLARES_FUNCTION_P (NODE) && DECL_CONSTRUCTOR_P (NODE) \
2467 && !DECL_CLONED_FUNCTION_P (NODE))
2468
2469 /* Nonzero if NODE (a FUNCTION_DECL) is a copy constructor. */
2470 #define DECL_COPY_CONSTRUCTOR_P(NODE) \
2471 (DECL_CONSTRUCTOR_P (NODE) && copy_fn_p (NODE) > 0)
2472
2473 /* Nonzero if NODE (a FUNCTION_DECL) is a move constructor. */
2474 #define DECL_MOVE_CONSTRUCTOR_P(NODE) \
2475 (DECL_CONSTRUCTOR_P (NODE) && move_fn_p (NODE))
2476
2477 /* Nonzero if NODE (a FUNCTION_DECL or TEMPLATE_DECL)
2478 is a destructor. */
2479 #define DECL_DESTRUCTOR_P(NODE) \
2480 DECL_CXX_DESTRUCTOR_P (STRIP_TEMPLATE (NODE))
2481
2482 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor, but not the
2483 specialized in-charge constructor, in-charge deleting constructor,
2484 or the base destructor. */
2485 #define DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P(NODE) \
2486 (DECL_DECLARES_FUNCTION_P (NODE) && DECL_DESTRUCTOR_P (NODE) \
2487 && !DECL_CLONED_FUNCTION_P (NODE))
2488
2489 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete
2490 object. */
2491 #define DECL_COMPLETE_DESTRUCTOR_P(NODE) \
2492 (DECL_DESTRUCTOR_P (NODE) \
2493 && DECL_NAME (NODE) == complete_dtor_identifier)
2494
2495 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a base
2496 object. */
2497 #define DECL_BASE_DESTRUCTOR_P(NODE) \
2498 (DECL_DESTRUCTOR_P (NODE) \
2499 && DECL_NAME (NODE) == base_dtor_identifier)
2500
2501 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete
2502 object that deletes the object after it has been destroyed. */
2503 #define DECL_DELETING_DESTRUCTOR_P(NODE) \
2504 (DECL_DESTRUCTOR_P (NODE) \
2505 && DECL_NAME (NODE) == deleting_dtor_identifier)
2506
2507 /* Nonzero if NODE (a FUNCTION_DECL) is a cloned constructor or
2508 destructor. */
2509 #define DECL_CLONED_FUNCTION_P(NODE) (!!decl_cloned_function_p (NODE, true))
2510
2511 /* If DECL_CLONED_FUNCTION_P holds, this is the function that was
2512 cloned. */
2513 #define DECL_CLONED_FUNCTION(NODE) (*decl_cloned_function_p (NODE, false))
2514
2515 /* Perform an action for each clone of FN, if FN is a function with
2516 clones. This macro should be used like:
2517
2518 FOR_EACH_CLONE (clone, fn)
2519 { ... }
2520
2521 */
2522 #define FOR_EACH_CLONE(CLONE, FN) \
2523 if (!(TREE_CODE (FN) == FUNCTION_DECL \
2524 && (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (FN) \
2525 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (FN))))\
2526 ; \
2527 else \
2528 for (CLONE = DECL_CHAIN (FN); \
2529 CLONE && DECL_CLONED_FUNCTION_P (CLONE); \
2530 CLONE = DECL_CHAIN (CLONE))
2531
2532 /* Nonzero if NODE has DECL_DISCRIMINATOR and not DECL_ACCESS. */
2533 #define DECL_DISCRIMINATOR_P(NODE) \
2534 (VAR_P (NODE) && DECL_FUNCTION_SCOPE_P (NODE))
2535
2536 /* Discriminator for name mangling. */
2537 #define DECL_DISCRIMINATOR(NODE) (LANG_DECL_U2_CHECK (NODE, 1)->discriminator)
2538
2539 /* True iff DECL_DISCRIMINATOR is set for a DECL_DISCRIMINATOR_P decl. */
2540 #define DECL_DISCRIMINATOR_SET_P(NODE) \
2541 (DECL_LANG_SPECIFIC (NODE) && DECL_LANG_SPECIFIC (NODE)->u.base.u2sel == 1)
2542
2543 /* The index of a user-declared parameter in its function, starting at 1.
2544 All artificial parameters will have index 0. */
2545 #define DECL_PARM_INDEX(NODE) \
2546 (LANG_DECL_PARM_CHECK (NODE)->index)
2547
2548 /* The level of a user-declared parameter in its function, starting at 1.
2549 A parameter of the function will have level 1; a parameter of the first
2550 nested function declarator (i.e. t in void f (void (*p)(T t))) will have
2551 level 2. */
2552 #define DECL_PARM_LEVEL(NODE) \
2553 (LANG_DECL_PARM_CHECK (NODE)->level)
2554
2555 /* Nonzero if the VTT parm has been added to NODE. */
2556 #define DECL_HAS_VTT_PARM_P(NODE) \
2557 (LANG_DECL_FN_CHECK (NODE)->has_vtt_parm_p)
2558
2559 /* Nonzero if NODE is a FUNCTION_DECL for which a VTT parameter is
2560 required. */
2561 #define DECL_NEEDS_VTT_PARM_P(NODE) \
2562 (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (NODE)) \
2563 && (DECL_BASE_CONSTRUCTOR_P (NODE) \
2564 || DECL_BASE_DESTRUCTOR_P (NODE)))
2565
2566 /* Nonzero if NODE is a user-defined conversion operator. */
2567 #define DECL_CONV_FN_P(NODE) \
2568 (DECL_NAME (NODE) && IDENTIFIER_TYPENAME_P (DECL_NAME (NODE)))
2569
2570 /* If FN is a conversion operator, the type to which it converts.
2571 Otherwise, NULL_TREE. */
2572 #define DECL_CONV_FN_TYPE(FN) \
2573 (DECL_CONV_FN_P (FN) ? TREE_TYPE (DECL_NAME (FN)) : NULL_TREE)
2574
2575 /* Nonzero if NODE, which is a TEMPLATE_DECL, is a template
2576 conversion operator to a type dependent on the innermost template
2577 args. */
2578 #define DECL_TEMPLATE_CONV_FN_P(NODE) \
2579 (DECL_LANG_SPECIFIC (TEMPLATE_DECL_CHECK (NODE))->u.base.template_conv_p)
2580
2581 /* Nonzero if NODE, a static data member, was declared in its class as an
2582 array of unknown bound. */
2583 #define VAR_HAD_UNKNOWN_BOUND(NODE) \
2584 (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE)) \
2585 ? DECL_LANG_SPECIFIC (NODE)->u.base.template_conv_p \
2586 : false)
2587 #define SET_VAR_HAD_UNKNOWN_BOUND(NODE) \
2588 (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.template_conv_p = true)
2589
2590 /* Set the overloaded operator code for NODE to CODE. */
2591 #define SET_OVERLOADED_OPERATOR_CODE(NODE, CODE) \
2592 (LANG_DECL_FN_CHECK (NODE)->operator_code = (CODE))
2593
2594 /* If NODE is an overloaded operator, then this returns the TREE_CODE
2595 associated with the overloaded operator.
2596 DECL_ASSIGNMENT_OPERATOR_P must also be checked to determine
2597 whether or not NODE is an assignment operator. If NODE is not an
2598 overloaded operator, ERROR_MARK is returned. Since the numerical
2599 value of ERROR_MARK is zero, this macro can be used as a predicate
2600 to test whether or not NODE is an overloaded operator. */
2601 #define DECL_OVERLOADED_OPERATOR_P(NODE) \
2602 (IDENTIFIER_OPNAME_P (DECL_NAME (NODE)) \
2603 ? LANG_DECL_FN_CHECK (NODE)->operator_code : ERROR_MARK)
2604
2605 /* Nonzero if NODE is an assignment operator (including += and such). */
2606 #define DECL_ASSIGNMENT_OPERATOR_P(NODE) \
2607 (LANG_DECL_FN_CHECK (NODE)->assignment_operator_p)
2608
2609 /* For FUNCTION_DECLs: nonzero means that this function is a
2610 constructor or a destructor with an extra in-charge parameter to
2611 control whether or not virtual bases are constructed. */
2612 #define DECL_HAS_IN_CHARGE_PARM_P(NODE) \
2613 (LANG_DECL_FN_CHECK (NODE)->has_in_charge_parm_p)
2614
2615 /* Nonzero if DECL is a declaration of __builtin_constant_p. */
2616 #define DECL_IS_BUILTIN_CONSTANT_P(NODE) \
2617 (TREE_CODE (NODE) == FUNCTION_DECL \
2618 && DECL_BUILT_IN_CLASS (NODE) == BUILT_IN_NORMAL \
2619 && DECL_FUNCTION_CODE (NODE) == BUILT_IN_CONSTANT_P)
2620
2621 /* Nonzero for _DECL means that this decl appears in (or will appear
2622 in) as a member in a RECORD_TYPE or UNION_TYPE node. It is also for
2623 detecting circularity in case members are multiply defined. In the
2624 case of a VAR_DECL, it is also used to determine how program storage
2625 should be allocated. */
2626 #define DECL_IN_AGGR_P(NODE) (DECL_LANG_FLAG_3 (NODE))
2627
2628 /* Nonzero for a VAR_DECL means that the variable's initialization (if
2629 any) has been processed. (In general, DECL_INITIALIZED_P is
2630 !DECL_EXTERNAL, but static data members may be initialized even if
2631 not defined.) */
2632 #define DECL_INITIALIZED_P(NODE) \
2633 (TREE_LANG_FLAG_1 (VAR_DECL_CHECK (NODE)))
2634
2635 /* Nonzero for a VAR_DECL iff an explicit initializer was provided
2636 or a non-trivial constructor is called. */
2637 #define DECL_NONTRIVIALLY_INITIALIZED_P(NODE) \
2638 (TREE_LANG_FLAG_3 (VAR_DECL_CHECK (NODE)))
2639
2640 /* Nonzero for a VAR_DECL that was initialized with a
2641 constant-expression. */
2642 #define DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P(NODE) \
2643 (TREE_LANG_FLAG_2 (VAR_DECL_CHECK (NODE)))
2644
2645 /* Nonzero if the DECL was initialized in the class definition itself,
2646 rather than outside the class. This is used for both static member
2647 VAR_DECLS, and FUNCTION_DECLS that are defined in the class. */
2648 #define DECL_INITIALIZED_IN_CLASS_P(DECL) \
2649 (DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL)) \
2650 ->u.base.initialized_in_class)
2651
2652 /* Nonzero if the DECL is used in the sense of 3.2 [basic.def.odr].
2653 Only available for decls with DECL_LANG_SPECIFIC. */
2654 #define DECL_ODR_USED(DECL) \
2655 (DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL)) \
2656 ->u.base.odr_used)
2657
2658 /* Nonzero for DECL means that this decl is just a friend declaration,
2659 and should not be added to the list of members for this class. */
2660 #define DECL_FRIEND_P(NODE) \
2661 (DECL_LANG_SPECIFIC (TYPE_FUNCTION_OR_TEMPLATE_DECL_CHECK (NODE)) \
2662 ->u.base.friend_or_tls)
2663
2664 /* Nonzero if the thread-local variable was declared with __thread as
2665 opposed to thread_local. */
2666 #define DECL_GNU_TLS_P(NODE) \
2667 (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE)) \
2668 && DECL_LANG_SPECIFIC (NODE)->u.base.friend_or_tls)
2669 #define SET_DECL_GNU_TLS_P(NODE) \
2670 (retrofit_lang_decl (VAR_DECL_CHECK (NODE)), \
2671 DECL_LANG_SPECIFIC (NODE)->u.base.friend_or_tls = true)
2672
2673 /* A TREE_LIST of the types which have befriended this FUNCTION_DECL. */
2674 #define DECL_BEFRIENDING_CLASSES(NODE) \
2675 (LANG_DECL_FN_CHECK (NODE)->befriending_classes)
2676
2677 /* Nonzero for FUNCTION_DECL means that this decl is a static
2678 member function. */
2679 #define DECL_STATIC_FUNCTION_P(NODE) \
2680 (LANG_DECL_FN_CHECK (NODE)->static_function)
2681
2682 /* Nonzero for FUNCTION_DECL means that this decl is a non-static
2683 member function. */
2684 #define DECL_NONSTATIC_MEMBER_FUNCTION_P(NODE) \
2685 (TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE)
2686
2687 /* Nonzero for FUNCTION_DECL means that this decl is a member function
2688 (static or non-static). */
2689 #define DECL_FUNCTION_MEMBER_P(NODE) \
2690 (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) || DECL_STATIC_FUNCTION_P (NODE))
2691
2692 /* Nonzero for FUNCTION_DECL means that this member function
2693 has `this' as const X *const. */
2694 #define DECL_CONST_MEMFUNC_P(NODE) \
2695 (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \
2696 && CP_TYPE_CONST_P (TREE_TYPE (TREE_VALUE \
2697 (TYPE_ARG_TYPES (TREE_TYPE (NODE))))))
2698
2699 /* Nonzero for FUNCTION_DECL means that this member function
2700 has `this' as volatile X *const. */
2701 #define DECL_VOLATILE_MEMFUNC_P(NODE) \
2702 (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \
2703 && CP_TYPE_VOLATILE_P (TREE_TYPE (TREE_VALUE \
2704 (TYPE_ARG_TYPES (TREE_TYPE (NODE))))))
2705
2706 /* Nonzero for a DECL means that this member is a non-static member. */
2707 #define DECL_NONSTATIC_MEMBER_P(NODE) \
2708 (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \
2709 || TREE_CODE (NODE) == FIELD_DECL)
2710
2711 /* Nonzero for _DECL means that this member object type
2712 is mutable. */
2713 #define DECL_MUTABLE_P(NODE) (DECL_LANG_FLAG_0 (NODE))
2714
2715 /* Nonzero for _DECL means that this constructor or conversion function is
2716 non-converting. */
2717 #define DECL_NONCONVERTING_P(NODE) \
2718 (LANG_DECL_FN_CHECK (NODE)->nonconverting)
2719
2720 /* Nonzero for FUNCTION_DECL means that this member function is a pure
2721 virtual function. */
2722 #define DECL_PURE_VIRTUAL_P(NODE) \
2723 (LANG_DECL_FN_CHECK (NODE)->pure_virtual)
2724
2725 /* True (in a FUNCTION_DECL) if NODE is a virtual function that is an
2726 invalid overrider for a function from a base class. Once we have
2727 complained about an invalid overrider we avoid complaining about it
2728 again. */
2729 #define DECL_INVALID_OVERRIDER_P(NODE) \
2730 (DECL_LANG_FLAG_4 (NODE))
2731
2732 /* True (in a FUNCTION_DECL) if NODE is a function declared with
2733 an override virt-specifier */
2734 #define DECL_OVERRIDE_P(NODE) (TREE_LANG_FLAG_0 (NODE))
2735
2736 /* The thunks associated with NODE, a FUNCTION_DECL. */
2737 #define DECL_THUNKS(NODE) \
2738 (DECL_VIRTUAL_P (NODE) ? LANG_DECL_FN_CHECK (NODE)->context : NULL_TREE)
2739
2740 /* Set DECL_THUNKS. */
2741 #define SET_DECL_THUNKS(NODE,THUNKS) \
2742 (LANG_DECL_FN_CHECK (NODE)->context = (THUNKS))
2743
2744 /* If NODE, a FUNCTION_DECL, is a C++11 inheriting constructor, then this
2745 is the base it inherits from. */
2746 #define DECL_INHERITED_CTOR_BASE(NODE) \
2747 (DECL_CONSTRUCTOR_P (NODE) ? LANG_DECL_FN_CHECK (NODE)->context : NULL_TREE)
2748
2749 /* Set the inherited base. */
2750 #define SET_DECL_INHERITED_CTOR_BASE(NODE,INH) \
2751 (LANG_DECL_FN_CHECK (NODE)->context = (INH))
2752
2753 /* Nonzero if NODE is a thunk, rather than an ordinary function. */
2754 #define DECL_THUNK_P(NODE) \
2755 (TREE_CODE (NODE) == FUNCTION_DECL \
2756 && DECL_LANG_SPECIFIC (NODE) \
2757 && LANG_DECL_FN_CHECK (NODE)->thunk_p)
2758
2759 /* Set DECL_THUNK_P for node. */
2760 #define SET_DECL_THUNK_P(NODE, THIS_ADJUSTING) \
2761 (LANG_DECL_FN_CHECK (NODE)->thunk_p = 1, \
2762 LANG_DECL_FN_CHECK (NODE)->this_thunk_p = (THIS_ADJUSTING))
2763
2764 /* Nonzero if NODE is a this pointer adjusting thunk. */
2765 #define DECL_THIS_THUNK_P(NODE) \
2766 (DECL_THUNK_P (NODE) && LANG_DECL_FN_CHECK (NODE)->this_thunk_p)
2767
2768 /* Nonzero if NODE is a result pointer adjusting thunk. */
2769 #define DECL_RESULT_THUNK_P(NODE) \
2770 (DECL_THUNK_P (NODE) && !LANG_DECL_FN_CHECK (NODE)->this_thunk_p)
2771
2772 /* Nonzero if NODE is a FUNCTION_DECL, but not a thunk. */
2773 #define DECL_NON_THUNK_FUNCTION_P(NODE) \
2774 (TREE_CODE (NODE) == FUNCTION_DECL && !DECL_THUNK_P (NODE))
2775
2776 /* Nonzero if NODE is `extern "C"'. */
2777 #define DECL_EXTERN_C_P(NODE) \
2778 (DECL_LANGUAGE (NODE) == lang_c)
2779
2780 /* Nonzero if NODE is an `extern "C"' function. */
2781 #define DECL_EXTERN_C_FUNCTION_P(NODE) \
2782 (DECL_NON_THUNK_FUNCTION_P (NODE) && DECL_EXTERN_C_P (NODE))
2783
2784 /* True iff DECL is an entity with vague linkage whose definition is
2785 available in this translation unit. */
2786 #define DECL_REPO_AVAILABLE_P(NODE) \
2787 (DECL_LANG_SPECIFIC (NODE)->u.base.repo_available_p)
2788
2789 /* True if DECL is declared 'constexpr'. */
2790 #define DECL_DECLARED_CONSTEXPR_P(DECL) \
2791 DECL_LANG_FLAG_8 (VAR_OR_FUNCTION_DECL_CHECK (STRIP_TEMPLATE (DECL)))
2792
2793 // True if NODE was declared as 'concept'. The flag implies that the
2794 // declaration is constexpr, that the declaration cannot be specialized or
2795 // refined, and that the result type must be convertible to bool.
2796 #define DECL_DECLARED_CONCEPT_P(NODE) \
2797 (DECL_LANG_SPECIFIC (NODE)->u.base.concept_p)
2798
2799 /* Nonzero if this DECL is the __PRETTY_FUNCTION__ variable in a
2800 template function. */
2801 #define DECL_PRETTY_FUNCTION_P(NODE) \
2802 (DECL_NAME (NODE) \
2803 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__PRETTY_FUNCTION__"))
2804
2805 /* Nonzero if the variable was declared to be thread-local.
2806 We need a special C++ version of this test because the middle-end
2807 DECL_THREAD_LOCAL_P uses the symtab, so we can't use it for
2808 templates. */
2809 #define CP_DECL_THREAD_LOCAL_P(NODE) \
2810 (TREE_LANG_FLAG_0 (VAR_DECL_CHECK (NODE)))
2811
2812 /* The _TYPE context in which this _DECL appears. This field holds the
2813 class where a virtual function instance is actually defined. */
2814 #define DECL_CLASS_CONTEXT(NODE) \
2815 (DECL_CLASS_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : NULL_TREE)
2816
2817 /* For a non-member friend function, the class (if any) in which this
2818 friend was defined. For example, given:
2819
2820 struct S { friend void f (); };
2821
2822 the DECL_FRIEND_CONTEXT for `f' will be `S'. */
2823 #define DECL_FRIEND_CONTEXT(NODE) \
2824 ((DECL_DECLARES_FUNCTION_P (NODE) \
2825 && DECL_FRIEND_P (NODE) && !DECL_FUNCTION_MEMBER_P (NODE)) \
2826 ? LANG_DECL_FN_CHECK (NODE)->context \
2827 : NULL_TREE)
2828
2829 /* Set the DECL_FRIEND_CONTEXT for NODE to CONTEXT. */
2830 #define SET_DECL_FRIEND_CONTEXT(NODE, CONTEXT) \
2831 (LANG_DECL_FN_CHECK (NODE)->context = (CONTEXT))
2832
2833 #define CP_DECL_CONTEXT(NODE) \
2834 (!DECL_FILE_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : global_namespace)
2835 #define CP_TYPE_CONTEXT(NODE) \
2836 (!TYPE_FILE_SCOPE_P (NODE) ? TYPE_CONTEXT (NODE) : global_namespace)
2837 #define FROB_CONTEXT(NODE) \
2838 ((NODE) == global_namespace ? DECL_CONTEXT (NODE) : (NODE))
2839
2840 /* 1 iff NODE has namespace scope, including the global namespace. */
2841 #define DECL_NAMESPACE_SCOPE_P(NODE) \
2842 (!DECL_TEMPLATE_PARM_P (NODE) \
2843 && TREE_CODE (CP_DECL_CONTEXT (NODE)) == NAMESPACE_DECL)
2844
2845 #define TYPE_NAMESPACE_SCOPE_P(NODE) \
2846 (TREE_CODE (CP_TYPE_CONTEXT (NODE)) == NAMESPACE_DECL)
2847
2848 #define NAMESPACE_SCOPE_P(NODE) \
2849 ((DECL_P (NODE) && DECL_NAMESPACE_SCOPE_P (NODE)) \
2850 || (TYPE_P (NODE) && TYPE_NAMESPACE_SCOPE_P (NODE)))
2851
2852 /* 1 iff NODE is a class member. */
2853 #define DECL_CLASS_SCOPE_P(NODE) \
2854 (DECL_CONTEXT (NODE) && TYPE_P (DECL_CONTEXT (NODE)))
2855
2856 #define TYPE_CLASS_SCOPE_P(NODE) \
2857 (TYPE_CONTEXT (NODE) && TYPE_P (TYPE_CONTEXT (NODE)))
2858
2859 /* 1 iff NODE is function-local. */
2860 #define DECL_FUNCTION_SCOPE_P(NODE) \
2861 (DECL_CONTEXT (NODE) \
2862 && TREE_CODE (DECL_CONTEXT (NODE)) == FUNCTION_DECL)
2863
2864 #define TYPE_FUNCTION_SCOPE_P(NODE) \
2865 (TYPE_CONTEXT (NODE) && TREE_CODE (TYPE_CONTEXT (NODE)) == FUNCTION_DECL)
2866
2867 /* 1 iff VAR_DECL node NODE is a type-info decl. This flag is set for
2868 both the primary typeinfo object and the associated NTBS name. */
2869 #define DECL_TINFO_P(NODE) TREE_LANG_FLAG_4 (VAR_DECL_CHECK (NODE))
2870
2871 /* 1 iff VAR_DECL node NODE is virtual table or VTT. */
2872 #define DECL_VTABLE_OR_VTT_P(NODE) TREE_LANG_FLAG_5 (VAR_DECL_CHECK (NODE))
2873
2874 /* 1 iff FUNCTION_TYPE or METHOD_TYPE has a ref-qualifier (either & or &&). */
2875 #define FUNCTION_REF_QUALIFIED(NODE) \
2876 TREE_LANG_FLAG_4 (FUNC_OR_METHOD_CHECK (NODE))
2877
2878 /* 1 iff FUNCTION_TYPE or METHOD_TYPE has &&-ref-qualifier. */
2879 #define FUNCTION_RVALUE_QUALIFIED(NODE) \
2880 TREE_LANG_FLAG_5 (FUNC_OR_METHOD_CHECK (NODE))
2881
2882 /* Returns 1 iff VAR_DECL is a construction virtual table.
2883 DECL_VTABLE_OR_VTT_P will be true in this case and must be checked
2884 before using this macro. */
2885 #define DECL_CONSTRUCTION_VTABLE_P(NODE) \
2886 TREE_LANG_FLAG_6 (VAR_DECL_CHECK (NODE))
2887
2888 /* 1 iff NODE is function-local, but for types. */
2889 #define LOCAL_CLASS_P(NODE) \
2890 (decl_function_context (TYPE_MAIN_DECL (NODE)) != NULL_TREE)
2891
2892 /* For a NAMESPACE_DECL: the list of using namespace directives
2893 The PURPOSE is the used namespace, the value is the namespace
2894 that is the common ancestor. */
2895 #define DECL_NAMESPACE_USING(NODE) (LANG_DECL_NS_CHECK (NODE)->ns_using)
2896
2897 /* In a NAMESPACE_DECL, the DECL_INITIAL is used to record all users
2898 of a namespace, to record the transitive closure of using namespace. */
2899 #define DECL_NAMESPACE_USERS(NODE) (LANG_DECL_NS_CHECK (NODE)->ns_users)
2900
2901 /* In a NAMESPACE_DECL, the list of namespaces which have associated
2902 themselves with this one. */
2903 #define DECL_NAMESPACE_ASSOCIATIONS(NODE) \
2904 DECL_INITIAL (NAMESPACE_DECL_CHECK (NODE))
2905
2906 /* In a NAMESPACE_DECL, points to the original namespace if this is
2907 a namespace alias. */
2908 #define DECL_NAMESPACE_ALIAS(NODE) \
2909 DECL_ABSTRACT_ORIGIN (NAMESPACE_DECL_CHECK (NODE))
2910 #define ORIGINAL_NAMESPACE(NODE) \
2911 (DECL_NAMESPACE_ALIAS (NODE) ? DECL_NAMESPACE_ALIAS (NODE) : (NODE))
2912
2913 /* Nonzero if NODE is the std namespace. */
2914 #define DECL_NAMESPACE_STD_P(NODE) \
2915 (TREE_CODE (NODE) == NAMESPACE_DECL \
2916 && CP_DECL_CONTEXT (NODE) == global_namespace \
2917 && DECL_NAME (NODE) == std_identifier)
2918
2919 /* In a TREE_LIST concatenating using directives, indicate indirect
2920 directives */
2921 #define TREE_INDIRECT_USING(NODE) TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
2922
2923 /* In a TREE_LIST in an attribute list, indicates that the attribute
2924 must be applied at instantiation time. */
2925 #define ATTR_IS_DEPENDENT(NODE) TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
2926
2927 /* In a TREE_LIST in the argument of attribute abi_tag, indicates that the tag
2928 was inherited from a template parameter, not explicitly indicated. */
2929 #define ABI_TAG_IMPLICIT(NODE) TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
2930
2931 extern tree decl_shadowed_for_var_lookup (tree);
2932 extern void decl_shadowed_for_var_insert (tree, tree);
2933
2934 /* Non zero if this is a using decl for a dependent scope. */
2935 #define DECL_DEPENDENT_P(NODE) DECL_LANG_FLAG_0 (USING_DECL_CHECK (NODE))
2936
2937 /* The scope named in a using decl. */
2938 #define USING_DECL_SCOPE(NODE) TREE_TYPE (USING_DECL_CHECK (NODE))
2939
2940 /* The decls named by a using decl. */
2941 #define USING_DECL_DECLS(NODE) DECL_INITIAL (USING_DECL_CHECK (NODE))
2942
2943 /* Non zero if the using decl refers to a dependent type. */
2944 #define USING_DECL_TYPENAME_P(NODE) DECL_LANG_FLAG_1 (USING_DECL_CHECK (NODE))
2945
2946 /* In a VAR_DECL, true if we have a shadowed local variable
2947 in the shadowed var table for this VAR_DECL. */
2948 #define DECL_HAS_SHADOWED_FOR_VAR_P(NODE) \
2949 (VAR_DECL_CHECK (NODE)->decl_with_vis.shadowed_for_var_p)
2950
2951 /* In a VAR_DECL for a variable declared in a for statement,
2952 this is the shadowed (local) variable. */
2953 #define DECL_SHADOWED_FOR_VAR(NODE) \
2954 (DECL_HAS_SHADOWED_FOR_VAR_P(NODE) ? decl_shadowed_for_var_lookup (NODE) : NULL)
2955
2956 #define SET_DECL_SHADOWED_FOR_VAR(NODE, VAL) \
2957 (decl_shadowed_for_var_insert (NODE, VAL))
2958
2959 /* In a FUNCTION_DECL, this is nonzero if this function was defined in
2960 the class definition. We have saved away the text of the function,
2961 but have not yet processed it. */
2962 #define DECL_PENDING_INLINE_P(NODE) \
2963 (LANG_DECL_FN_CHECK (NODE)->pending_inline_p)
2964
2965 /* If DECL_PENDING_INLINE_P holds, this is the saved text of the
2966 function. */
2967 #define DECL_PENDING_INLINE_INFO(NODE) \
2968 (LANG_DECL_FN_CHECK (NODE)->u.pending_inline_info)
2969
2970 /* Nonzero for TYPE_DECL means that it was written 'using name = type'. */
2971 #define TYPE_DECL_ALIAS_P(NODE) \
2972 DECL_LANG_FLAG_6 (TYPE_DECL_CHECK (NODE))
2973
2974 /* Nonzero for TEMPLATE_DECL means that it is a 'complex' alias template. */
2975 #define TEMPLATE_DECL_COMPLEX_ALIAS_P(NODE) \
2976 DECL_LANG_FLAG_2 (TEMPLATE_DECL_CHECK (NODE))
2977
2978 /* Nonzero for a type which is an alias for another type; i.e, a type
2979 which declaration was written 'using name-of-type =
2980 another-type'. */
2981 #define TYPE_ALIAS_P(NODE) \
2982 (TYPE_P (NODE) \
2983 && TYPE_NAME (NODE) \
2984 && TREE_CODE (TYPE_NAME (NODE)) == TYPE_DECL \
2985 && TYPE_DECL_ALIAS_P (TYPE_NAME (NODE)))
2986
2987 /* For a class type: if this structure has many fields, we'll sort them
2988 and put them into a TREE_VEC. */
2989 #define CLASSTYPE_SORTED_FIELDS(NODE) \
2990 (LANG_TYPE_CLASS_CHECK (NODE)->sorted_fields)
2991
2992 /* If non-NULL for a VAR_DECL, FUNCTION_DECL, TYPE_DECL or
2993 TEMPLATE_DECL, the entity is either a template specialization (if
2994 DECL_USE_TEMPLATE is nonzero) or the abstract instance of the
2995 template itself.
2996
2997 In either case, DECL_TEMPLATE_INFO is a TREE_LIST, whose
2998 TREE_PURPOSE is the TEMPLATE_DECL of which this entity is a
2999 specialization or abstract instance. The TREE_VALUE is the
3000 template arguments used to specialize the template.
3001
3002 Consider:
3003
3004 template <typename T> struct S { friend void f(T) {} };
3005
3006 In this case, S<int>::f is, from the point of view of the compiler,
3007 an instantiation of a template -- but, from the point of view of
3008 the language, each instantiation of S results in a wholly unrelated
3009 global function f. In this case, DECL_TEMPLATE_INFO for S<int>::f
3010 will be non-NULL, but DECL_USE_TEMPLATE will be zero. */
3011 #define DECL_TEMPLATE_INFO(NODE) \
3012 (DECL_LANG_SPECIFIC (VAR_TEMPL_TYPE_FIELD_OR_FUNCTION_DECL_CHECK (NODE)) \
3013 ->u.min.template_info)
3014
3015 /* For a VAR_DECL, indicates that the variable is actually a
3016 non-static data member of anonymous union that has been promoted to
3017 variable status. */
3018 #define DECL_ANON_UNION_VAR_P(NODE) \
3019 (DECL_LANG_FLAG_4 (VAR_DECL_CHECK (NODE)))
3020
3021 /* Template information for a RECORD_TYPE or UNION_TYPE. */
3022 #define CLASSTYPE_TEMPLATE_INFO(NODE) \
3023 (LANG_TYPE_CLASS_CHECK (RECORD_OR_UNION_CHECK (NODE))->template_info)
3024
3025 /* Template information for an ENUMERAL_TYPE. Although an enumeration may
3026 not be a primary template, it may be declared within the scope of a
3027 primary template and the enumeration constants may depend on
3028 non-type template parameters. */
3029 #define ENUM_TEMPLATE_INFO(NODE) \
3030 (TYPE_LANG_SLOT_1 (ENUMERAL_TYPE_CHECK (NODE)))
3031
3032 /* Template information for a template template parameter. */
3033 #define TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO(NODE) \
3034 (LANG_TYPE_CLASS_CHECK (BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK (NODE)) \
3035 ->template_info)
3036
3037 /* Template information for an ENUMERAL_, RECORD_, UNION_TYPE, or
3038 BOUND_TEMPLATE_TEMPLATE_PARM type. Note that if NODE is a
3039 specialization of an alias template, this accessor returns the
3040 template info for the alias template, not the one (if any) for the
3041 template of the underlying type. */
3042 #define TYPE_TEMPLATE_INFO(NODE) \
3043 ((TYPE_ALIAS_P (NODE) && DECL_LANG_SPECIFIC (TYPE_NAME (NODE))) \
3044 ? (DECL_LANG_SPECIFIC (TYPE_NAME (NODE)) \
3045 ? DECL_TEMPLATE_INFO (TYPE_NAME (NODE)) \
3046 : NULL_TREE) \
3047 : ((TREE_CODE (NODE) == ENUMERAL_TYPE) \
3048 ? ENUM_TEMPLATE_INFO (NODE) \
3049 : ((TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM) \
3050 ? TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (NODE) \
3051 : (CLASS_TYPE_P (NODE) \
3052 ? CLASSTYPE_TEMPLATE_INFO (NODE) \
3053 : NULL_TREE))))
3054
3055
3056 /* Set the template information for an ENUMERAL_, RECORD_, or
3057 UNION_TYPE to VAL. */
3058 #define SET_TYPE_TEMPLATE_INFO(NODE, VAL) \
3059 (TREE_CODE (NODE) == ENUMERAL_TYPE \
3060 ? (ENUM_TEMPLATE_INFO (NODE) = (VAL)) \
3061 : ((CLASS_TYPE_P (NODE) && !TYPE_ALIAS_P (NODE)) \
3062 ? (CLASSTYPE_TEMPLATE_INFO (NODE) = (VAL)) \
3063 : (DECL_TEMPLATE_INFO (TYPE_NAME (NODE)) = (VAL))))
3064
3065 #define TI_TEMPLATE(NODE) TREE_TYPE (TEMPLATE_INFO_CHECK (NODE))
3066 #define TI_ARGS(NODE) TREE_CHAIN (TEMPLATE_INFO_CHECK (NODE))
3067 #define TI_PENDING_TEMPLATE_FLAG(NODE) TREE_LANG_FLAG_1 (NODE)
3068 /* For a given TREE_VEC containing a template argument list,
3069 this property contains the number of arguments that are not
3070 defaulted. */
3071 #define NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) TREE_CHAIN (TREE_VEC_CHECK (NODE))
3072 /* Below are the setter and getter of the NON_DEFAULT_TEMPLATE_ARGS_COUNT
3073 property. */
3074 #define SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE, INT_VALUE) \
3075 NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) = build_int_cst (NULL_TREE, INT_VALUE)
3076 #if CHECKING_P
3077 #define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \
3078 int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE))
3079 #else
3080 #define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \
3081 NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE) \
3082 ? int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE)) \
3083 : TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (NODE))
3084 #endif
3085 /* The list of typedefs - used in the template - that need
3086 access checking at template instantiation time.
3087
3088 FIXME this should be associated with the TEMPLATE_DECL, not the
3089 TEMPLATE_INFO. */
3090 #define TI_TYPEDEFS_NEEDING_ACCESS_CHECKING(NODE) \
3091 ((struct tree_template_info*)TEMPLATE_INFO_CHECK \
3092 (NODE))->typedefs_needing_access_checking
3093
3094 /* We use TREE_VECs to hold template arguments. If there is only one
3095 level of template arguments, then the TREE_VEC contains the
3096 arguments directly. If there is more than one level of template
3097 arguments, then each entry in the TREE_VEC is itself a TREE_VEC,
3098 containing the template arguments for a single level. The first
3099 entry in the outer TREE_VEC is the outermost level of template
3100 parameters; the last is the innermost.
3101
3102 It is incorrect to ever form a template argument vector containing
3103 only one level of arguments, but which is a TREE_VEC containing as
3104 its only entry the TREE_VEC for that level.
3105
3106 For each TREE_VEC containing the template arguments for a single
3107 level, it's possible to get or set the number of non defaulted
3108 template arguments by using the accessor macros
3109 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT or
3110 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT. */
3111
3112 /* Nonzero if the template arguments is actually a vector of vectors,
3113 rather than just a vector. */
3114 #define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \
3115 (NODE && TREE_VEC_LENGTH (NODE) && TREE_VEC_ELT (NODE, 0) \
3116 && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC)
3117
3118 /* The depth of a template argument vector. When called directly by
3119 the parser, we use a TREE_LIST rather than a TREE_VEC to represent
3120 template arguments. In fact, we may even see NULL_TREE if there
3121 are no template arguments. In both of those cases, there is only
3122 one level of template arguments. */
3123 #define TMPL_ARGS_DEPTH(NODE) \
3124 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1)
3125
3126 /* The LEVELth level of the template ARGS. The outermost level of
3127 args is level 1, not level 0. */
3128 #define TMPL_ARGS_LEVEL(ARGS, LEVEL) \
3129 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS) \
3130 ? TREE_VEC_ELT (ARGS, (LEVEL) - 1) : (ARGS))
3131
3132 /* Set the LEVELth level of the template ARGS to VAL. This macro does
3133 not work with single-level argument vectors. */
3134 #define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL) \
3135 (TREE_VEC_ELT (ARGS, (LEVEL) - 1) = (VAL))
3136
3137 /* Accesses the IDXth parameter in the LEVELth level of the ARGS. */
3138 #define TMPL_ARG(ARGS, LEVEL, IDX) \
3139 (TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX))
3140
3141 /* Given a single level of template arguments in NODE, return the
3142 number of arguments. */
3143 #define NUM_TMPL_ARGS(NODE) \
3144 (TREE_VEC_LENGTH (NODE))
3145
3146 /* Returns the innermost level of template arguments in ARGS. */
3147 #define INNERMOST_TEMPLATE_ARGS(NODE) \
3148 (get_innermost_template_args ((NODE), 1))
3149
3150 /* The number of levels of template parameters given by NODE. */
3151 #define TMPL_PARMS_DEPTH(NODE) \
3152 ((HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_PURPOSE (NODE)))
3153
3154 /* The TEMPLATE_DECL instantiated or specialized by NODE. This
3155 TEMPLATE_DECL will be the immediate parent, not the most general
3156 template. For example, in:
3157
3158 template <class T> struct S { template <class U> void f(U); }
3159
3160 the FUNCTION_DECL for S<int>::f<double> will have, as its
3161 DECL_TI_TEMPLATE, `template <class U> S<int>::f<U>'.
3162
3163 As a special case, for a member friend template of a template
3164 class, this value will not be a TEMPLATE_DECL, but rather an
3165 IDENTIFIER_NODE or OVERLOAD indicating the name of the template and
3166 any explicit template arguments provided. For example, in:
3167
3168 template <class T> struct S { friend void f<int>(int, double); }
3169
3170 the DECL_TI_TEMPLATE will be an IDENTIFIER_NODE for `f' and the
3171 DECL_TI_ARGS will be {int}.
3172
3173 For a FIELD_DECL with a non-static data member initializer, this value
3174 is the FIELD_DECL it was instantiated from. */
3175 #define DECL_TI_TEMPLATE(NODE) TI_TEMPLATE (DECL_TEMPLATE_INFO (NODE))
3176
3177 /* The template arguments used to obtain this decl from the most
3178 general form of DECL_TI_TEMPLATE. For the example given for
3179 DECL_TI_TEMPLATE, the DECL_TI_ARGS will be {int, double}. These
3180 are always the full set of arguments required to instantiate this
3181 declaration from the most general template specialized here. */
3182 #define DECL_TI_ARGS(NODE) TI_ARGS (DECL_TEMPLATE_INFO (NODE))
3183
3184 /* The TEMPLATE_DECL associated with NODE, a class type. Even if NODE
3185 will be generated from a partial specialization, the TEMPLATE_DECL
3186 referred to here will be the original template. For example,
3187 given:
3188
3189 template <typename T> struct S {};
3190 template <typename T> struct S<T*> {};
3191
3192 the CLASSTPYE_TI_TEMPLATE for S<int*> will be S, not the S<T*>. */
3193 #define CLASSTYPE_TI_TEMPLATE(NODE) TI_TEMPLATE (CLASSTYPE_TEMPLATE_INFO (NODE))
3194 #define CLASSTYPE_TI_ARGS(NODE) TI_ARGS (CLASSTYPE_TEMPLATE_INFO (NODE))
3195
3196 /* For a template instantiation TYPE, returns the TYPE corresponding
3197 to the primary template. Otherwise returns TYPE itself. */
3198 #define CLASSTYPE_PRIMARY_TEMPLATE_TYPE(TYPE) \
3199 ((CLASSTYPE_USE_TEMPLATE ((TYPE)) \
3200 && !CLASSTYPE_TEMPLATE_SPECIALIZATION ((TYPE))) \
3201 ? TREE_TYPE (DECL_TEMPLATE_RESULT (DECL_PRIMARY_TEMPLATE \
3202 (CLASSTYPE_TI_TEMPLATE ((TYPE))))) \
3203 : (TYPE))
3204
3205 /* Like CLASS_TI_TEMPLATE, but also works for ENUMERAL_TYPEs. */
3206 #define TYPE_TI_TEMPLATE(NODE) \
3207 (TI_TEMPLATE (TYPE_TEMPLATE_INFO (NODE)))
3208
3209 /* Like DECL_TI_ARGS, but for an ENUMERAL_, RECORD_, or UNION_TYPE. */
3210 #define TYPE_TI_ARGS(NODE) \
3211 (TI_ARGS (TYPE_TEMPLATE_INFO (NODE)))
3212
3213 #define INNERMOST_TEMPLATE_PARMS(NODE) TREE_VALUE (NODE)
3214
3215 /* Nonzero if NODE (a TEMPLATE_DECL) is a member template, in the
3216 sense of [temp.mem]. */
3217 #define DECL_MEMBER_TEMPLATE_P(NODE) \
3218 (DECL_LANG_FLAG_1 (TEMPLATE_DECL_CHECK (NODE)))
3219
3220 /* Nonzero if the NODE corresponds to the template parameters for a
3221 member template, whose inline definition is being processed after
3222 the class definition is complete. */
3223 #define TEMPLATE_PARMS_FOR_INLINE(NODE) TREE_LANG_FLAG_1 (NODE)
3224
3225 /* Determine if a declaration (PARM_DECL or FIELD_DECL) is a pack. */
3226 #define DECL_PACK_P(NODE) \
3227 (DECL_P (NODE) && PACK_EXPANSION_P (TREE_TYPE (NODE)))
3228
3229 /* Determines if NODE is an expansion of one or more parameter packs,
3230 e.g., a TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION. */
3231 #define PACK_EXPANSION_P(NODE) \
3232 (TREE_CODE (NODE) == TYPE_PACK_EXPANSION \
3233 || TREE_CODE (NODE) == EXPR_PACK_EXPANSION)
3234
3235 /* Extracts the type or expression pattern from a TYPE_PACK_EXPANSION or
3236 EXPR_PACK_EXPANSION. */
3237 #define PACK_EXPANSION_PATTERN(NODE) \
3238 (TREE_CODE (NODE) == TYPE_PACK_EXPANSION? TREE_TYPE (NODE) \
3239 : TREE_OPERAND (NODE, 0))
3240
3241 /* Sets the type or expression pattern for a TYPE_PACK_EXPANSION or
3242 EXPR_PACK_EXPANSION. */
3243 #define SET_PACK_EXPANSION_PATTERN(NODE,VALUE) \
3244 if (TREE_CODE (NODE) == TYPE_PACK_EXPANSION) \
3245 TREE_TYPE (NODE) = VALUE; \
3246 else \
3247 TREE_OPERAND (NODE, 0) = VALUE
3248
3249 /* The list of parameter packs used in the PACK_EXPANSION_* node. The
3250 TREE_VALUE of each TREE_LIST contains the parameter packs. */
3251 #define PACK_EXPANSION_PARAMETER_PACKS(NODE) \
3252 *(TREE_CODE (NODE) == EXPR_PACK_EXPANSION \
3253 ? &TREE_OPERAND (NODE, 1) \
3254 : &TYPE_MINVAL (TYPE_PACK_EXPANSION_CHECK (NODE)))
3255
3256 /* Any additional template args to be applied when substituting into
3257 the pattern, set by tsubst_pack_expansion for partial instantiations. */
3258 #define PACK_EXPANSION_EXTRA_ARGS(NODE) \
3259 *(TREE_CODE (NODE) == TYPE_PACK_EXPANSION \
3260 ? &TYPE_MAXVAL (NODE) \
3261 : &TREE_OPERAND ((NODE), 2))
3262
3263 /* True iff this pack expansion is within a function context. */
3264 #define PACK_EXPANSION_LOCAL_P(NODE) TREE_LANG_FLAG_0 (NODE)
3265
3266 /* True iff this pack expansion is for sizeof.... */
3267 #define PACK_EXPANSION_SIZEOF_P(NODE) TREE_LANG_FLAG_1 (NODE)
3268
3269 /* True iff the wildcard can match a template parameter pack. */
3270 #define WILDCARD_PACK_P(NODE) TREE_LANG_FLAG_0 (NODE)
3271
3272 /* Determine if this is an argument pack. */
3273 #define ARGUMENT_PACK_P(NODE) \
3274 (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK \
3275 || TREE_CODE (NODE) == NONTYPE_ARGUMENT_PACK)
3276
3277 /* The arguments stored in an argument pack. Arguments are stored in a
3278 TREE_VEC, which may have length zero. */
3279 #define ARGUMENT_PACK_ARGS(NODE) \
3280 (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK? TREE_TYPE (NODE) \
3281 : TREE_OPERAND (NODE, 0))
3282
3283 /* Set the arguments stored in an argument pack. VALUE must be a
3284 TREE_VEC. */
3285 #define SET_ARGUMENT_PACK_ARGS(NODE,VALUE) \
3286 if (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK) \
3287 TREE_TYPE (NODE) = VALUE; \
3288 else \
3289 TREE_OPERAND (NODE, 0) = VALUE
3290
3291 /* Whether the argument pack is "incomplete", meaning that more
3292 arguments can still be deduced. Incomplete argument packs are only
3293 used when the user has provided an explicit template argument list
3294 for a variadic function template. Some of the explicit template
3295 arguments will be placed into the beginning of the argument pack,
3296 but additional arguments might still be deduced. */
3297 #define ARGUMENT_PACK_INCOMPLETE_P(NODE) \
3298 TREE_ADDRESSABLE (ARGUMENT_PACK_ARGS (NODE))
3299
3300 /* When ARGUMENT_PACK_INCOMPLETE_P, stores the explicit template
3301 arguments used to fill this pack. */
3302 #define ARGUMENT_PACK_EXPLICIT_ARGS(NODE) \
3303 TREE_TYPE (ARGUMENT_PACK_ARGS (NODE))
3304
3305 /* In an ARGUMENT_PACK_SELECT, the argument pack from which an
3306 argument will be selected. */
3307 #define ARGUMENT_PACK_SELECT_FROM_PACK(NODE) \
3308 (((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->argument_pack)
3309
3310 /* In an ARGUMENT_PACK_SELECT, the index of the argument we want to
3311 select. */
3312 #define ARGUMENT_PACK_SELECT_INDEX(NODE) \
3313 (((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->index)
3314
3315 /* In an ARGUMENT_PACK_SELECT, the actual underlying argument that the
3316 ARGUMENT_PACK_SELECT represents. */
3317 #define ARGUMENT_PACK_SELECT_ARG(NODE) \
3318 TREE_VEC_ELT (ARGUMENT_PACK_ARGS (ARGUMENT_PACK_SELECT_FROM_PACK (NODE)), \
3319 ARGUMENT_PACK_SELECT_INDEX (NODE))
3320
3321 #define FOLD_EXPR_CHECK(NODE) \
3322 TREE_CHECK4 (NODE, UNARY_LEFT_FOLD_EXPR, UNARY_RIGHT_FOLD_EXPR, \
3323 BINARY_LEFT_FOLD_EXPR, BINARY_RIGHT_FOLD_EXPR)
3324
3325 #define BINARY_FOLD_EXPR_CHECK(NODE) \
3326 TREE_CHECK2 (NODE, BINARY_LEFT_FOLD_EXPR, BINARY_RIGHT_FOLD_EXPR)
3327
3328 /* True if NODE is UNARY_FOLD_EXPR or a BINARY_FOLD_EXPR */
3329 #define FOLD_EXPR_P(NODE) \
3330 (TREE_CODE (NODE) == UNARY_LEFT_FOLD_EXPR \
3331 || TREE_CODE (NODE) == UNARY_RIGHT_FOLD_EXPR \
3332 || TREE_CODE (NODE) == BINARY_LEFT_FOLD_EXPR \
3333 || TREE_CODE (NODE) == BINARY_RIGHT_FOLD_EXPR)
3334
3335 /* True when NODE is a fold over a compound assignment operator. */
3336 #define FOLD_EXPR_MODIFY_P(NODE) \
3337 TREE_LANG_FLAG_0 (FOLD_EXPR_CHECK (NODE))
3338
3339 /* An INTEGER_CST containing the tree code of the folded operator. */
3340 #define FOLD_EXPR_OP(NODE) \
3341 TREE_OPERAND (FOLD_EXPR_CHECK (NODE), 0)
3342
3343 /* The expression containing an unexpanded parameter pack. */
3344 #define FOLD_EXPR_PACK(NODE) \
3345 TREE_OPERAND (FOLD_EXPR_CHECK (NODE), 1)
3346
3347 /* In a binary fold expression, the argument with no unexpanded
3348 parameter packs. */
3349 #define FOLD_EXPR_INIT(NODE) \
3350 TREE_OPERAND (BINARY_FOLD_EXPR_CHECK (NODE), 2)
3351
3352 /* In a FUNCTION_DECL, the saved language-specific per-function data. */
3353 #define DECL_SAVED_FUNCTION_DATA(NODE) \
3354 (LANG_DECL_FN_CHECK (FUNCTION_DECL_CHECK (NODE)) \
3355 ->u.saved_language_function)
3356
3357 /* True if NODE is an implicit INDIRECT_EXPR from convert_from_reference. */
3358 #define REFERENCE_REF_P(NODE) \
3359 (INDIRECT_REF_P (NODE) \
3360 && TREE_TYPE (TREE_OPERAND (NODE, 0)) \
3361 && (TREE_CODE (TREE_TYPE (TREE_OPERAND ((NODE), 0))) \
3362 == REFERENCE_TYPE))
3363
3364 /* True if NODE is a REFERENCE_TYPE which is OK to instantiate to be a
3365 reference to VLA type, because it's used for VLA capture. */
3366 #define REFERENCE_VLA_OK(NODE) \
3367 (TYPE_LANG_FLAG_5 (REFERENCE_TYPE_CHECK (NODE)))
3368
3369 #define NEW_EXPR_USE_GLOBAL(NODE) \
3370 TREE_LANG_FLAG_0 (NEW_EXPR_CHECK (NODE))
3371 #define DELETE_EXPR_USE_GLOBAL(NODE) \
3372 TREE_LANG_FLAG_0 (DELETE_EXPR_CHECK (NODE))
3373 #define DELETE_EXPR_USE_VEC(NODE) \
3374 TREE_LANG_FLAG_1 (DELETE_EXPR_CHECK (NODE))
3375
3376 /* Indicates that this is a non-dependent COMPOUND_EXPR which will
3377 resolve to a function call. */
3378 #define COMPOUND_EXPR_OVERLOADED(NODE) \
3379 TREE_LANG_FLAG_0 (COMPOUND_EXPR_CHECK (NODE))
3380
3381 /* In a CALL_EXPR appearing in a template, true if Koenig lookup
3382 should be performed at instantiation time. */
3383 #define KOENIG_LOOKUP_P(NODE) TREE_LANG_FLAG_0 (CALL_EXPR_CHECK (NODE))
3384
3385 /* True if CALL_EXPR expresses list-initialization of an object. */
3386 #define CALL_EXPR_LIST_INIT_P(NODE) \
3387 TREE_LANG_FLAG_3 (TREE_CHECK2 ((NODE),CALL_EXPR,AGGR_INIT_EXPR))
3388
3389 /* Indicates whether a string literal has been parenthesized. Such
3390 usages are disallowed in certain circumstances. */
3391
3392 #define PAREN_STRING_LITERAL_P(NODE) \
3393 TREE_LANG_FLAG_0 (STRING_CST_CHECK (NODE))
3394
3395 /* Indicates whether a COMPONENT_REF or a SCOPE_REF has been parenthesized, or
3396 an INDIRECT_REF comes from parenthesizing a _DECL. Currently only set some
3397 of the time in C++14 mode. */
3398
3399 #define REF_PARENTHESIZED_P(NODE) \
3400 TREE_LANG_FLAG_2 (TREE_CHECK3 ((NODE), COMPONENT_REF, INDIRECT_REF, SCOPE_REF))
3401
3402 /* Nonzero if this AGGR_INIT_EXPR provides for initialization via a
3403 constructor call, rather than an ordinary function call. */
3404 #define AGGR_INIT_VIA_CTOR_P(NODE) \
3405 TREE_LANG_FLAG_0 (AGGR_INIT_EXPR_CHECK (NODE))
3406
3407 /* Nonzero if expanding this AGGR_INIT_EXPR should first zero-initialize
3408 the object. */
3409 #define AGGR_INIT_ZERO_FIRST(NODE) \
3410 TREE_LANG_FLAG_2 (AGGR_INIT_EXPR_CHECK (NODE))
3411
3412 /* Nonzero means that the call is the jump from a thunk to the
3413 thunked-to function. */
3414 #define AGGR_INIT_FROM_THUNK_P(NODE) \
3415 (AGGR_INIT_EXPR_CHECK (NODE)->base.protected_flag)
3416
3417 /* AGGR_INIT_EXPR accessors. These are equivalent to the CALL_EXPR
3418 accessors, except for AGGR_INIT_EXPR_SLOT (which takes the place of
3419 CALL_EXPR_STATIC_CHAIN). */
3420
3421 #define AGGR_INIT_EXPR_FN(NODE) TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 1)
3422 #define AGGR_INIT_EXPR_SLOT(NODE) \
3423 TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 2)
3424 #define AGGR_INIT_EXPR_ARG(NODE, I) \
3425 TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), (I) + 3)
3426 #define aggr_init_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH(NODE) - 3)
3427
3428 /* AGGR_INIT_EXPR_ARGP returns a pointer to the argument vector for NODE.
3429 We can't use &AGGR_INIT_EXPR_ARG (NODE, 0) because that will complain if
3430 the argument count is zero when checking is enabled. Instead, do
3431 the pointer arithmetic to advance past the 3 fixed operands in a
3432 AGGR_INIT_EXPR. That produces a valid pointer to just past the end of
3433 the operand array, even if it's not valid to dereference it. */
3434 #define AGGR_INIT_EXPR_ARGP(NODE) \
3435 (&(TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 0)) + 3)
3436
3437 /* Abstract iterators for AGGR_INIT_EXPRs. */
3438
3439 /* Structure containing iterator state. */
3440 struct aggr_init_expr_arg_iterator {
3441 tree t; /* the aggr_init_expr */
3442 int n; /* argument count */
3443 int i; /* next argument index */
3444 };
3445
3446 /* Initialize the abstract argument list iterator object ITER with the
3447 arguments from AGGR_INIT_EXPR node EXP. */
3448 inline void
init_aggr_init_expr_arg_iterator(tree exp,aggr_init_expr_arg_iterator * iter)3449 init_aggr_init_expr_arg_iterator (tree exp,
3450 aggr_init_expr_arg_iterator *iter)
3451 {
3452 iter->t = exp;
3453 iter->n = aggr_init_expr_nargs (exp);
3454 iter->i = 0;
3455 }
3456
3457 /* Return the next argument from abstract argument list iterator object ITER,
3458 and advance its state. Return NULL_TREE if there are no more arguments. */
3459 inline tree
next_aggr_init_expr_arg(aggr_init_expr_arg_iterator * iter)3460 next_aggr_init_expr_arg (aggr_init_expr_arg_iterator *iter)
3461 {
3462 tree result;
3463 if (iter->i >= iter->n)
3464 return NULL_TREE;
3465 result = AGGR_INIT_EXPR_ARG (iter->t, iter->i);
3466 iter->i++;
3467 return result;
3468 }
3469
3470 /* Initialize the abstract argument list iterator object ITER, then advance
3471 past and return the first argument. Useful in for expressions, e.g.
3472 for (arg = first_aggr_init_expr_arg (exp, &iter); arg;
3473 arg = next_aggr_init_expr_arg (&iter)) */
3474 inline tree
first_aggr_init_expr_arg(tree exp,aggr_init_expr_arg_iterator * iter)3475 first_aggr_init_expr_arg (tree exp, aggr_init_expr_arg_iterator *iter)
3476 {
3477 init_aggr_init_expr_arg_iterator (exp, iter);
3478 return next_aggr_init_expr_arg (iter);
3479 }
3480
3481 /* Test whether there are more arguments in abstract argument list iterator
3482 ITER, without changing its state. */
3483 inline bool
more_aggr_init_expr_args_p(const aggr_init_expr_arg_iterator * iter)3484 more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter)
3485 {
3486 return (iter->i < iter->n);
3487 }
3488
3489 /* Iterate through each argument ARG of AGGR_INIT_EXPR CALL, using variable
3490 ITER (of type aggr_init_expr_arg_iterator) to hold the iteration state. */
3491 #define FOR_EACH_AGGR_INIT_EXPR_ARG(arg, iter, call) \
3492 for ((arg) = first_aggr_init_expr_arg ((call), &(iter)); (arg); \
3493 (arg) = next_aggr_init_expr_arg (&(iter)))
3494
3495 /* VEC_INIT_EXPR accessors. */
3496 #define VEC_INIT_EXPR_SLOT(NODE) TREE_OPERAND (VEC_INIT_EXPR_CHECK (NODE), 0)
3497 #define VEC_INIT_EXPR_INIT(NODE) TREE_OPERAND (VEC_INIT_EXPR_CHECK (NODE), 1)
3498
3499 /* Indicates that a VEC_INIT_EXPR is a potential constant expression.
3500 Only set when the current function is constexpr. */
3501 #define VEC_INIT_EXPR_IS_CONSTEXPR(NODE) \
3502 TREE_LANG_FLAG_0 (VEC_INIT_EXPR_CHECK (NODE))
3503
3504 /* Indicates that a VEC_INIT_EXPR is expressing value-initialization. */
3505 #define VEC_INIT_EXPR_VALUE_INIT(NODE) \
3506 TREE_LANG_FLAG_1 (VEC_INIT_EXPR_CHECK (NODE))
3507
3508 /* The condition under which this MUST_NOT_THROW_EXPR actually blocks
3509 exceptions. NULL_TREE means 'true'. */
3510 #define MUST_NOT_THROW_COND(NODE) \
3511 TREE_OPERAND (MUST_NOT_THROW_EXPR_CHECK (NODE), 1)
3512
3513 /* The TYPE_MAIN_DECL for a class template type is a TYPE_DECL, not a
3514 TEMPLATE_DECL. This macro determines whether or not a given class
3515 type is really a template type, as opposed to an instantiation or
3516 specialization of one. */
3517 #define CLASSTYPE_IS_TEMPLATE(NODE) \
3518 (CLASSTYPE_TEMPLATE_INFO (NODE) \
3519 && !CLASSTYPE_USE_TEMPLATE (NODE) \
3520 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE)))
3521
3522 /* The name used by the user to name the typename type. Typically,
3523 this is an IDENTIFIER_NODE, and the same as the DECL_NAME on the
3524 corresponding TYPE_DECL. However, this may also be a
3525 TEMPLATE_ID_EXPR if we had something like `typename X::Y<T>'. */
3526 #define TYPENAME_TYPE_FULLNAME(NODE) \
3527 (TYPE_VALUES_RAW (TYPENAME_TYPE_CHECK (NODE)))
3528
3529 /* True if a TYPENAME_TYPE was declared as an "enum". */
3530 #define TYPENAME_IS_ENUM_P(NODE) \
3531 (TREE_LANG_FLAG_0 (TYPENAME_TYPE_CHECK (NODE)))
3532
3533 /* True if a TYPENAME_TYPE was declared as a "class", "struct", or
3534 "union". */
3535 #define TYPENAME_IS_CLASS_P(NODE) \
3536 (TREE_LANG_FLAG_1 (TYPENAME_TYPE_CHECK (NODE)))
3537
3538 /* True if a TYPENAME_TYPE is in the process of being resolved. */
3539 #define TYPENAME_IS_RESOLVING_P(NODE) \
3540 (TREE_LANG_FLAG_2 (TYPENAME_TYPE_CHECK (NODE)))
3541
3542 /* [class.virtual]
3543
3544 A class that declares or inherits a virtual function is called a
3545 polymorphic class. */
3546 #define TYPE_POLYMORPHIC_P(NODE) (TREE_LANG_FLAG_2 (NODE))
3547
3548 /* Nonzero if this class has a virtual function table pointer. */
3549 #define TYPE_CONTAINS_VPTR_P(NODE) \
3550 (TYPE_POLYMORPHIC_P (NODE) || CLASSTYPE_VBASECLASSES (NODE))
3551
3552 /* This flag is true of a local VAR_DECL if it was declared in a for
3553 statement, but we are no longer in the scope of the for. */
3554 #define DECL_DEAD_FOR_LOCAL(NODE) DECL_LANG_FLAG_7 (VAR_DECL_CHECK (NODE))
3555
3556 /* This flag is set on a VAR_DECL that is a DECL_DEAD_FOR_LOCAL
3557 if we already emitted a warning about using it. */
3558 #define DECL_ERROR_REPORTED(NODE) DECL_LANG_FLAG_0 (VAR_DECL_CHECK (NODE))
3559
3560 /* Nonzero if NODE is a FUNCTION_DECL (for a function with global
3561 scope) declared in a local scope. */
3562 #define DECL_LOCAL_FUNCTION_P(NODE) \
3563 DECL_LANG_FLAG_0 (FUNCTION_DECL_CHECK (NODE))
3564
3565 /* Nonzero if NODE is the target for genericization of 'break' stmts. */
3566 #define LABEL_DECL_BREAK(NODE) \
3567 DECL_LANG_FLAG_0 (LABEL_DECL_CHECK (NODE))
3568
3569 /* Nonzero if NODE is the target for genericization of 'continue' stmts. */
3570 #define LABEL_DECL_CONTINUE(NODE) \
3571 DECL_LANG_FLAG_1 (LABEL_DECL_CHECK (NODE))
3572
3573 /* True if NODE was declared with auto in its return type, but it has
3574 started compilation and so the return type might have been changed by
3575 return type deduction; its declared return type should be found in
3576 DECL_STRUCT_FUNCTION(NODE)->language->x_auto_return_pattern. */
3577 #define FNDECL_USED_AUTO(NODE) \
3578 TREE_LANG_FLAG_2 (FUNCTION_DECL_CHECK (NODE))
3579
3580 /* Nonzero if NODE is a DECL which we know about but which has not
3581 been explicitly declared, such as a built-in function or a friend
3582 declared inside a class. In the latter case DECL_HIDDEN_FRIEND_P
3583 will be set. */
3584 #define DECL_ANTICIPATED(NODE) \
3585 (DECL_LANG_SPECIFIC (TYPE_FUNCTION_OR_TEMPLATE_DECL_CHECK (NODE)) \
3586 ->u.base.anticipated_p)
3587
3588 /* True for artificial decls added for OpenMP privatized non-static
3589 data members. */
3590 #define DECL_OMP_PRIVATIZED_MEMBER(NODE) \
3591 (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.anticipated_p)
3592
3593 /* Nonzero if NODE is a FUNCTION_DECL which was declared as a friend
3594 within a class but has not been declared in the surrounding scope.
3595 The function is invisible except via argument dependent lookup. */
3596 #define DECL_HIDDEN_FRIEND_P(NODE) \
3597 (LANG_DECL_FN_CHECK (DECL_COMMON_CHECK (NODE))->hidden_friend_p)
3598
3599 /* Nonzero if NODE is an artificial FUNCTION_DECL for
3600 #pragma omp declare reduction. */
3601 #define DECL_OMP_DECLARE_REDUCTION_P(NODE) \
3602 (LANG_DECL_FN_CHECK (DECL_COMMON_CHECK (NODE))->omp_declare_reduction_p)
3603
3604 /* Nonzero if DECL has been declared threadprivate by
3605 #pragma omp threadprivate. */
3606 #define CP_DECL_THREADPRIVATE_P(DECL) \
3607 (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (DECL))->u.base.threadprivate_or_deleted_p)
3608
3609 /* Nonzero if DECL was declared with '= delete'. */
3610 #define DECL_DELETED_FN(DECL) \
3611 (LANG_DECL_FN_CHECK (DECL)->min.base.threadprivate_or_deleted_p)
3612
3613 /* Nonzero if DECL was declared with '= default' (maybe implicitly). */
3614 #define DECL_DEFAULTED_FN(DECL) \
3615 (LANG_DECL_FN_CHECK (DECL)->defaulted_p)
3616
3617 /* Nonzero if DECL is explicitly defaulted in the class body. */
3618 #define DECL_DEFAULTED_IN_CLASS_P(DECL) \
3619 (DECL_DEFAULTED_FN (DECL) && DECL_INITIALIZED_IN_CLASS_P (DECL))
3620 /* Nonzero if DECL was defaulted outside the class body. */
3621 #define DECL_DEFAULTED_OUTSIDE_CLASS_P(DECL) \
3622 (DECL_DEFAULTED_FN (DECL) \
3623 && !(DECL_ARTIFICIAL (DECL) || DECL_INITIALIZED_IN_CLASS_P (DECL)))
3624
3625 /* Record whether a typedef for type `int' was actually `signed int'. */
3626 #define C_TYPEDEF_EXPLICITLY_SIGNED(EXP) DECL_LANG_FLAG_1 (EXP)
3627
3628 /* Returns nonzero if DECL has external linkage, as specified by the
3629 language standard. (This predicate may hold even when the
3630 corresponding entity is not actually given external linkage in the
3631 object file; see decl_linkage for details.) */
3632 #define DECL_EXTERNAL_LINKAGE_P(DECL) \
3633 (decl_linkage (DECL) == lk_external)
3634
3635 /* Keep these codes in ascending code order. */
3636
3637 #define INTEGRAL_CODE_P(CODE) \
3638 ((CODE) == ENUMERAL_TYPE \
3639 || (CODE) == BOOLEAN_TYPE \
3640 || (CODE) == INTEGER_TYPE)
3641
3642 /* [basic.fundamental]
3643
3644 Types bool, char, wchar_t, and the signed and unsigned integer types
3645 are collectively called integral types.
3646
3647 Note that INTEGRAL_TYPE_P, as defined in tree.h, allows enumeration
3648 types as well, which is incorrect in C++. Keep these checks in
3649 ascending code order. */
3650 #define CP_INTEGRAL_TYPE_P(TYPE) \
3651 (TREE_CODE (TYPE) == BOOLEAN_TYPE \
3652 || TREE_CODE (TYPE) == INTEGER_TYPE)
3653
3654 /* Returns true if TYPE is an integral or enumeration name. Keep
3655 these checks in ascending code order. */
3656 #define INTEGRAL_OR_ENUMERATION_TYPE_P(TYPE) \
3657 (TREE_CODE (TYPE) == ENUMERAL_TYPE || CP_INTEGRAL_TYPE_P (TYPE))
3658
3659 /* Returns true if TYPE is an integral or unscoped enumeration type. */
3660 #define INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P(TYPE) \
3661 (UNSCOPED_ENUM_P (TYPE) || CP_INTEGRAL_TYPE_P (TYPE))
3662
3663 /* True if the class type TYPE is a literal type. */
3664 #define CLASSTYPE_LITERAL_P(TYPE) \
3665 (LANG_TYPE_CLASS_CHECK (TYPE)->is_literal)
3666
3667 /* [basic.fundamental]
3668
3669 Integral and floating types are collectively called arithmetic
3670 types.
3671
3672 As a GNU extension, we also accept complex types.
3673
3674 Keep these checks in ascending code order. */
3675 #define ARITHMETIC_TYPE_P(TYPE) \
3676 (CP_INTEGRAL_TYPE_P (TYPE) \
3677 || TREE_CODE (TYPE) == REAL_TYPE \
3678 || TREE_CODE (TYPE) == COMPLEX_TYPE)
3679
3680 /* True iff TYPE is cv decltype(nullptr). */
3681 #define NULLPTR_TYPE_P(TYPE) (TREE_CODE (TYPE) == NULLPTR_TYPE)
3682
3683 /* [basic.types]
3684
3685 Arithmetic types, enumeration types, pointer types,
3686 pointer-to-member types, and std::nullptr_t are collectively called
3687 scalar types.
3688
3689 Keep these checks in ascending code order. */
3690 #define SCALAR_TYPE_P(TYPE) \
3691 (TYPE_PTRDATAMEM_P (TYPE) \
3692 || TREE_CODE (TYPE) == ENUMERAL_TYPE \
3693 || ARITHMETIC_TYPE_P (TYPE) \
3694 || TYPE_PTR_P (TYPE) \
3695 || TYPE_PTRMEMFUNC_P (TYPE) \
3696 || NULLPTR_TYPE_P (TYPE))
3697
3698 /* Determines whether this type is a C++0x scoped enumeration
3699 type. Scoped enumerations types are introduced via "enum class" or
3700 "enum struct", e.g.,
3701
3702 enum class Color {
3703 Red, Green, Blue
3704 };
3705
3706 Scoped enumeration types are different from normal (unscoped)
3707 enumeration types in several ways:
3708
3709 - The enumerators of a scoped enumeration type are only available
3710 within the scope of the enumeration type and not in the
3711 enclosing scope. For example, the Red color can be referred to
3712 with "Color::Red" but not "Red".
3713
3714 - Scoped enumerators and enumerations do not implicitly convert
3715 to integers or 'bool'.
3716
3717 - The underlying type of the enum is well-defined. */
3718 #define SCOPED_ENUM_P(TYPE) \
3719 (TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_SCOPED (TYPE))
3720
3721 /* Determine whether this is an unscoped enumeration type. */
3722 #define UNSCOPED_ENUM_P(TYPE) \
3723 (TREE_CODE (TYPE) == ENUMERAL_TYPE && !ENUM_IS_SCOPED (TYPE))
3724
3725 /* Set the flag indicating whether an ENUMERAL_TYPE is a C++0x scoped
3726 enumeration type (1) or a normal (unscoped) enumeration type
3727 (0). */
3728 #define SET_SCOPED_ENUM_P(TYPE, VAL) \
3729 (ENUM_IS_SCOPED (TYPE) = (VAL))
3730
3731 #define SET_OPAQUE_ENUM_P(TYPE, VAL) \
3732 (ENUM_IS_OPAQUE (TYPE) = (VAL))
3733
3734 #define OPAQUE_ENUM_P(TYPE) \
3735 (TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_OPAQUE (TYPE))
3736
3737 /* Determines whether an ENUMERAL_TYPE has an explicit
3738 underlying type. */
3739 #define ENUM_FIXED_UNDERLYING_TYPE_P(NODE) (TYPE_LANG_FLAG_5 (NODE))
3740
3741 /* Returns the underlying type of the given enumeration type. The
3742 underlying type is determined in different ways, depending on the
3743 properties of the enum:
3744
3745 - In C++0x, the underlying type can be explicitly specified, e.g.,
3746
3747 enum E1 : char { ... } // underlying type is char
3748
3749 - In a C++0x scoped enumeration, the underlying type is int
3750 unless otherwises specified:
3751
3752 enum class E2 { ... } // underlying type is int
3753
3754 - Otherwise, the underlying type is determined based on the
3755 values of the enumerators. In this case, the
3756 ENUM_UNDERLYING_TYPE will not be set until after the definition
3757 of the enumeration is completed by finish_enum. */
3758 #define ENUM_UNDERLYING_TYPE(TYPE) \
3759 TREE_TYPE (ENUMERAL_TYPE_CHECK (TYPE))
3760
3761 /* [dcl.init.aggr]
3762
3763 An aggregate is an array or a class with no user-provided
3764 constructors, no brace-or-equal-initializers for non-static data
3765 members, no private or protected non-static data members, no
3766 base classes, and no virtual functions.
3767
3768 As an extension, we also treat vectors as aggregates. Keep these
3769 checks in ascending code order. */
3770 #define CP_AGGREGATE_TYPE_P(TYPE) \
3771 (TREE_CODE (TYPE) == VECTOR_TYPE \
3772 ||TREE_CODE (TYPE) == ARRAY_TYPE \
3773 || (CLASS_TYPE_P (TYPE) && !CLASSTYPE_NON_AGGREGATE (TYPE)))
3774
3775 /* Nonzero for a class type means that the class type has a
3776 user-declared constructor. */
3777 #define TYPE_HAS_USER_CONSTRUCTOR(NODE) (TYPE_LANG_FLAG_1 (NODE))
3778
3779 /* Nonzero means that the FUNCTION_TYPE or METHOD_TYPE has a
3780 late-specified return type. */
3781 #define TYPE_HAS_LATE_RETURN_TYPE(NODE) \
3782 (TYPE_LANG_FLAG_2 (FUNC_OR_METHOD_CHECK (NODE)))
3783
3784 /* When appearing in an INDIRECT_REF, it means that the tree structure
3785 underneath is actually a call to a constructor. This is needed
3786 when the constructor must initialize local storage (which can
3787 be automatically destroyed), rather than allowing it to allocate
3788 space from the heap.
3789
3790 When appearing in a SAVE_EXPR, it means that underneath
3791 is a call to a constructor.
3792
3793 When appearing in a CONSTRUCTOR, the expression is a
3794 compound literal.
3795
3796 When appearing in a FIELD_DECL, it means that this field
3797 has been duly initialized in its constructor. */
3798 #define TREE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_4 (NODE))
3799
3800 /* True if NODE is a brace-enclosed initializer. */
3801 #define BRACE_ENCLOSED_INITIALIZER_P(NODE) \
3802 (TREE_CODE (NODE) == CONSTRUCTOR && TREE_TYPE (NODE) == init_list_type_node)
3803
3804 /* True if NODE is a compound-literal, i.e., a brace-enclosed
3805 initializer cast to a particular type. */
3806 #define COMPOUND_LITERAL_P(NODE) \
3807 (TREE_CODE (NODE) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (NODE))
3808
3809 #define EMPTY_CONSTRUCTOR_P(NODE) (TREE_CODE (NODE) == CONSTRUCTOR \
3810 && vec_safe_is_empty(CONSTRUCTOR_ELTS(NODE))\
3811 && !TREE_HAS_CONSTRUCTOR (NODE))
3812
3813 /* True if NODE is a init-list used as a direct-initializer, i.e.
3814 B b{1,2}, not B b({1,2}) or B b = {1,2}. */
3815 #define CONSTRUCTOR_IS_DIRECT_INIT(NODE) (TREE_LANG_FLAG_0 (CONSTRUCTOR_CHECK (NODE)))
3816
3817 /* True if an uninitialized element in NODE should not be treated as
3818 implicitly value-initialized. Only used in constexpr evaluation. */
3819 #define CONSTRUCTOR_NO_IMPLICIT_ZERO(NODE) \
3820 (TREE_LANG_FLAG_1 (CONSTRUCTOR_CHECK (NODE)))
3821
3822 /* True if this CONSTRUCTOR should not be used as a variable initializer
3823 because it was loaded from a constexpr variable with mutable fields. */
3824 #define CONSTRUCTOR_MUTABLE_POISON(NODE) \
3825 (TREE_LANG_FLAG_2 (CONSTRUCTOR_CHECK (NODE)))
3826
3827 #define DIRECT_LIST_INIT_P(NODE) \
3828 (BRACE_ENCLOSED_INITIALIZER_P (NODE) && CONSTRUCTOR_IS_DIRECT_INIT (NODE))
3829
3830 /* True if NODE represents a conversion for direct-initialization in a
3831 template. Set by perform_implicit_conversion_flags. */
3832 #define IMPLICIT_CONV_EXPR_DIRECT_INIT(NODE) \
3833 (TREE_LANG_FLAG_0 (IMPLICIT_CONV_EXPR_CHECK (NODE)))
3834
3835 /* Nonzero means that an object of this type can not be initialized using
3836 an initializer list. */
3837 #define CLASSTYPE_NON_AGGREGATE(NODE) \
3838 (LANG_TYPE_CLASS_CHECK (NODE)->non_aggregate)
3839 #define TYPE_NON_AGGREGATE_CLASS(NODE) \
3840 (CLASS_TYPE_P (NODE) && CLASSTYPE_NON_AGGREGATE (NODE))
3841
3842 /* Nonzero if there is a non-trivial X::op=(cv X&) for this class. */
3843 #define TYPE_HAS_COMPLEX_COPY_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_copy_assign)
3844
3845 /* Nonzero if there is a non-trivial X::X(cv X&) for this class. */
3846 #define TYPE_HAS_COMPLEX_COPY_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_copy_ctor)
3847
3848 /* Nonzero if there is a non-trivial X::op=(X&&) for this class. */
3849 #define TYPE_HAS_COMPLEX_MOVE_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_move_assign)
3850
3851 /* Nonzero if there is a non-trivial X::X(X&&) for this class. */
3852 #define TYPE_HAS_COMPLEX_MOVE_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_move_ctor)
3853
3854 /* Nonzero if there is no trivial default constructor for this class. */
3855 #define TYPE_HAS_COMPLEX_DFLT(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_dflt)
3856
3857 /* Nonzero if TYPE has a trivial destructor. From [class.dtor]:
3858
3859 A destructor is trivial if it is an implicitly declared
3860 destructor and if:
3861
3862 - all of the direct base classes of its class have trivial
3863 destructors,
3864
3865 - for all of the non-static data members of its class that are
3866 of class type (or array thereof), each such class has a
3867 trivial destructor. */
3868 #define TYPE_HAS_TRIVIAL_DESTRUCTOR(NODE) \
3869 (!TYPE_HAS_NONTRIVIAL_DESTRUCTOR (NODE))
3870
3871 /* Nonzero for _TYPE node means that this type does not have a trivial
3872 destructor. Therefore, destroying an object of this type will
3873 involve a call to a destructor. This can apply to objects of
3874 ARRAY_TYPE is the type of the elements needs a destructor. */
3875 #define TYPE_HAS_NONTRIVIAL_DESTRUCTOR(NODE) \
3876 (TYPE_LANG_FLAG_4 (NODE))
3877
3878 /* Nonzero for class type means that the default constructor is trivial. */
3879 #define TYPE_HAS_TRIVIAL_DFLT(NODE) \
3880 (TYPE_HAS_DEFAULT_CONSTRUCTOR (NODE) && ! TYPE_HAS_COMPLEX_DFLT (NODE))
3881
3882 /* Nonzero for class type means that copy initialization of this type can use
3883 a bitwise copy. */
3884 #define TYPE_HAS_TRIVIAL_COPY_CTOR(NODE) \
3885 (TYPE_HAS_COPY_CTOR (NODE) && ! TYPE_HAS_COMPLEX_COPY_CTOR (NODE))
3886
3887 /* Nonzero for class type means that assignment of this type can use
3888 a bitwise copy. */
3889 #define TYPE_HAS_TRIVIAL_COPY_ASSIGN(NODE) \
3890 (TYPE_HAS_COPY_ASSIGN (NODE) && ! TYPE_HAS_COMPLEX_COPY_ASSIGN (NODE))
3891
3892 /* Returns true if NODE is a pointer-to-data-member. */
3893 #define TYPE_PTRDATAMEM_P(NODE) \
3894 (TREE_CODE (NODE) == OFFSET_TYPE)
3895 /* Returns true if NODE is a pointer. */
3896 #define TYPE_PTR_P(NODE) \
3897 (TREE_CODE (NODE) == POINTER_TYPE)
3898
3899 /* Returns true if NODE is an object type:
3900
3901 [basic.types]
3902
3903 An object type is a (possibly cv-qualified) type that is not a
3904 function type, not a reference type, and not a void type.
3905
3906 Keep these checks in ascending order, for speed. */
3907 #define TYPE_OBJ_P(NODE) \
3908 (TREE_CODE (NODE) != REFERENCE_TYPE \
3909 && !VOID_TYPE_P (NODE) \
3910 && TREE_CODE (NODE) != FUNCTION_TYPE \
3911 && TREE_CODE (NODE) != METHOD_TYPE)
3912
3913 /* Returns true if NODE is a pointer to an object. Keep these checks
3914 in ascending tree code order. */
3915 #define TYPE_PTROB_P(NODE) \
3916 (TYPE_PTR_P (NODE) && TYPE_OBJ_P (TREE_TYPE (NODE)))
3917
3918 /* Returns true if NODE is a reference to an object. Keep these checks
3919 in ascending tree code order. */
3920 #define TYPE_REF_OBJ_P(NODE) \
3921 (TREE_CODE (NODE) == REFERENCE_TYPE && TYPE_OBJ_P (TREE_TYPE (NODE)))
3922
3923 /* Returns true if NODE is a pointer to an object, or a pointer to
3924 void. Keep these checks in ascending tree code order. */
3925 #define TYPE_PTROBV_P(NODE) \
3926 (TYPE_PTR_P (NODE) \
3927 && !(TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE \
3928 || TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE))
3929
3930 /* Returns true if NODE is a pointer to function type. */
3931 #define TYPE_PTRFN_P(NODE) \
3932 (TYPE_PTR_P (NODE) \
3933 && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE)
3934
3935 /* Returns true if NODE is a reference to function type. */
3936 #define TYPE_REFFN_P(NODE) \
3937 (TREE_CODE (NODE) == REFERENCE_TYPE \
3938 && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE)
3939
3940 /* Returns true if NODE is a pointer to member function type. */
3941 #define TYPE_PTRMEMFUNC_P(NODE) \
3942 (TREE_CODE (NODE) == RECORD_TYPE \
3943 && TYPE_PTRMEMFUNC_FLAG (NODE))
3944
3945 #define TYPE_PTRMEMFUNC_FLAG(NODE) \
3946 (TYPE_LANG_FLAG_2 (RECORD_TYPE_CHECK (NODE)))
3947
3948 /* Returns true if NODE is a pointer-to-member. */
3949 #define TYPE_PTRMEM_P(NODE) \
3950 (TYPE_PTRDATAMEM_P (NODE) || TYPE_PTRMEMFUNC_P (NODE))
3951
3952 /* Returns true if NODE is a pointer or a pointer-to-member. */
3953 #define TYPE_PTR_OR_PTRMEM_P(NODE) \
3954 (TYPE_PTR_P (NODE) || TYPE_PTRMEM_P (NODE))
3955
3956 /* Indicates when overload resolution may resolve to a pointer to
3957 member function. [expr.unary.op]/3 */
3958 #define PTRMEM_OK_P(NODE) \
3959 TREE_LANG_FLAG_0 (TREE_CHECK3 ((NODE), ADDR_EXPR, OFFSET_REF, SCOPE_REF))
3960
3961 /* Get the POINTER_TYPE to the METHOD_TYPE associated with this
3962 pointer to member function. TYPE_PTRMEMFUNC_P _must_ be true,
3963 before using this macro. */
3964 #define TYPE_PTRMEMFUNC_FN_TYPE(NODE) \
3965 (cp_build_qualified_type (TREE_TYPE (TYPE_FIELDS (NODE)),\
3966 cp_type_quals (NODE)))
3967
3968 /* As above, but can be used in places that want an lvalue at the expense
3969 of not necessarily having the correct cv-qualifiers. */
3970 #define TYPE_PTRMEMFUNC_FN_TYPE_RAW(NODE) \
3971 (TREE_TYPE (TYPE_FIELDS (NODE)))
3972
3973 /* Returns `A' for a type like `int (A::*)(double)' */
3974 #define TYPE_PTRMEMFUNC_OBJECT_TYPE(NODE) \
3975 TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE)))
3976
3977 /* These are use to manipulate the canonical RECORD_TYPE from the
3978 hashed POINTER_TYPE, and can only be used on the POINTER_TYPE. */
3979 #define TYPE_GET_PTRMEMFUNC_TYPE(NODE) \
3980 (TYPE_LANG_SPECIFIC (NODE) ? LANG_TYPE_PTRMEM_CHECK (NODE)->record : NULL)
3981 #define TYPE_SET_PTRMEMFUNC_TYPE(NODE, VALUE) \
3982 do { \
3983 if (TYPE_LANG_SPECIFIC (NODE) == NULL) \
3984 { \
3985 TYPE_LANG_SPECIFIC (NODE) \
3986 = (struct lang_type *) ggc_internal_cleared_alloc \
3987 (sizeof (struct lang_type_ptrmem)); \
3988 TYPE_LANG_SPECIFIC (NODE)->u.ptrmem.h.is_lang_type_class = 0; \
3989 } \
3990 TYPE_LANG_SPECIFIC (NODE)->u.ptrmem.record = (VALUE); \
3991 } while (0)
3992
3993 /* For a pointer-to-member type of the form `T X::*', this is `X'.
3994 For a type like `void (X::*)() const', this type is `X', not `const
3995 X'. To get at the `const X' you have to look at the
3996 TYPE_PTRMEM_POINTED_TO_TYPE; there, the first parameter will have
3997 type `const X*'. */
3998 #define TYPE_PTRMEM_CLASS_TYPE(NODE) \
3999 (TYPE_PTRDATAMEM_P (NODE) \
4000 ? TYPE_OFFSET_BASETYPE (NODE) \
4001 : TYPE_PTRMEMFUNC_OBJECT_TYPE (NODE))
4002
4003 /* For a pointer-to-member type of the form `T X::*', this is `T'. */
4004 #define TYPE_PTRMEM_POINTED_TO_TYPE(NODE) \
4005 (TYPE_PTRDATAMEM_P (NODE) \
4006 ? TREE_TYPE (NODE) \
4007 : TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE)))
4008
4009 /* For a pointer-to-member constant `X::Y' this is the RECORD_TYPE for
4010 `X'. */
4011 #define PTRMEM_CST_CLASS(NODE) \
4012 TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (PTRMEM_CST_CHECK (NODE)))
4013
4014 /* For a pointer-to-member constant `X::Y' this is the _DECL for
4015 `Y'. */
4016 #define PTRMEM_CST_MEMBER(NODE) (((ptrmem_cst_t)PTRMEM_CST_CHECK (NODE))->member)
4017
4018 /* The expression in question for a TYPEOF_TYPE. */
4019 #define TYPEOF_TYPE_EXPR(NODE) (TYPE_VALUES_RAW (TYPEOF_TYPE_CHECK (NODE)))
4020
4021 /* The type in question for an UNDERLYING_TYPE. */
4022 #define UNDERLYING_TYPE_TYPE(NODE) \
4023 (TYPE_VALUES_RAW (UNDERLYING_TYPE_CHECK (NODE)))
4024
4025 /* The type in question for BASES. */
4026 #define BASES_TYPE(NODE) \
4027 (TYPE_VALUES_RAW (BASES_CHECK (NODE)))
4028
4029 #define BASES_DIRECT(NODE) \
4030 TREE_LANG_FLAG_0 (BASES_CHECK (NODE))
4031
4032 /* The expression in question for a DECLTYPE_TYPE. */
4033 #define DECLTYPE_TYPE_EXPR(NODE) (TYPE_VALUES_RAW (DECLTYPE_TYPE_CHECK (NODE)))
4034
4035 /* Whether the DECLTYPE_TYPE_EXPR of NODE was originally parsed as an
4036 id-expression or a member-access expression. When false, it was
4037 parsed as a full expression. */
4038 #define DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P(NODE) \
4039 (DECLTYPE_TYPE_CHECK (NODE))->type_common.string_flag
4040
4041 /* These flags indicate that we want different semantics from normal
4042 decltype: lambda capture just drops references, init capture
4043 uses auto semantics, lambda proxies look through implicit dereference. */
4044 #define DECLTYPE_FOR_LAMBDA_CAPTURE(NODE) \
4045 TREE_LANG_FLAG_0 (DECLTYPE_TYPE_CHECK (NODE))
4046 #define DECLTYPE_FOR_INIT_CAPTURE(NODE) \
4047 TREE_LANG_FLAG_1 (DECLTYPE_TYPE_CHECK (NODE))
4048 #define DECLTYPE_FOR_LAMBDA_PROXY(NODE) \
4049 TREE_LANG_FLAG_2 (DECLTYPE_TYPE_CHECK (NODE))
4050
4051 /* Nonzero for VAR_DECL and FUNCTION_DECL node means that `extern' was
4052 specified in its declaration. This can also be set for an
4053 erroneously declared PARM_DECL. */
4054 #define DECL_THIS_EXTERN(NODE) \
4055 DECL_LANG_FLAG_2 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE))
4056
4057 /* Nonzero for VAR_DECL and FUNCTION_DECL node means that `static' was
4058 specified in its declaration. This can also be set for an
4059 erroneously declared PARM_DECL. */
4060 #define DECL_THIS_STATIC(NODE) \
4061 DECL_LANG_FLAG_6 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE))
4062
4063 /* Nonzero for FIELD_DECL node means that this field is a lambda capture
4064 field for an array of runtime bound. */
4065 #define DECL_VLA_CAPTURE_P(NODE) \
4066 DECL_LANG_FLAG_1 (FIELD_DECL_CHECK (NODE))
4067
4068 /* Nonzero for PARM_DECL node means that this is an array function
4069 parameter, i.e, a[] rather than *a. */
4070 #define DECL_ARRAY_PARAMETER_P(NODE) \
4071 DECL_LANG_FLAG_1 (PARM_DECL_CHECK (NODE))
4072
4073 /* Nonzero for a FIELD_DECL who's NSMDI is currently being
4074 instantiated. */
4075 #define DECL_INSTANTIATING_NSDMI_P(NODE) \
4076 DECL_LANG_FLAG_2 (FIELD_DECL_CHECK (NODE))
4077
4078 /* Nonzero for FIELD_DECL node means that this field is a base class
4079 of the parent object, as opposed to a member field. */
4080 #define DECL_FIELD_IS_BASE(NODE) \
4081 DECL_LANG_FLAG_6 (FIELD_DECL_CHECK (NODE))
4082
4083 /* Nonzero for FIELD_DECL node means that this field is a simple (no
4084 explicit initializer) lambda capture field, making it invisible to
4085 name lookup in unevaluated contexts. */
4086 #define DECL_NORMAL_CAPTURE_P(NODE) \
4087 DECL_LANG_FLAG_7 (FIELD_DECL_CHECK (NODE))
4088
4089 /* Nonzero if TYPE is an anonymous union or struct type. We have to use a
4090 flag for this because "A union for which objects or pointers are
4091 declared is not an anonymous union" [class.union]. */
4092 #define ANON_AGGR_TYPE_P(NODE) \
4093 (CLASS_TYPE_P (NODE) && LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr)
4094 #define SET_ANON_AGGR_TYPE_P(NODE) \
4095 (LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr = 1)
4096
4097 /* Nonzero if TYPE is an anonymous union type. */
4098 #define ANON_UNION_TYPE_P(NODE) \
4099 (TREE_CODE (NODE) == UNION_TYPE && ANON_AGGR_TYPE_P (NODE))
4100
4101 /* Define fields and accessors for nodes representing declared names. */
4102
4103 #define TYPE_WAS_ANONYMOUS(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->was_anonymous)
4104
4105 /* C++: all of these are overloaded! These apply only to TYPE_DECLs. */
4106
4107 /* The format of each node in the DECL_FRIENDLIST is as follows:
4108
4109 The TREE_PURPOSE will be the name of a function, i.e., an
4110 IDENTIFIER_NODE. The TREE_VALUE will be itself a TREE_LIST, whose
4111 TREE_VALUEs are friends with the given name. */
4112 #define DECL_FRIENDLIST(NODE) (DECL_INITIAL (NODE))
4113 #define FRIEND_NAME(LIST) (TREE_PURPOSE (LIST))
4114 #define FRIEND_DECLS(LIST) (TREE_VALUE (LIST))
4115
4116 /* The DECL_ACCESS, if non-NULL, is a TREE_LIST. The TREE_PURPOSE of
4117 each node is a type; the TREE_VALUE is the access granted for this
4118 DECL in that type. The DECL_ACCESS is set by access declarations.
4119 For example, if a member that would normally be public in a
4120 derived class is made protected, then the derived class and the
4121 protected_access_node will appear in the DECL_ACCESS for the node. */
4122 #define DECL_ACCESS(NODE) (LANG_DECL_U2_CHECK (NODE, 0)->access)
4123
4124 /* Nonzero if the FUNCTION_DECL is a global constructor. */
4125 #define DECL_GLOBAL_CTOR_P(NODE) \
4126 (LANG_DECL_FN_CHECK (NODE)->global_ctor_p)
4127
4128 /* Nonzero if the FUNCTION_DECL is a global destructor. */
4129 #define DECL_GLOBAL_DTOR_P(NODE) \
4130 (LANG_DECL_FN_CHECK (NODE)->global_dtor_p)
4131
4132 /* Accessor macros for C++ template decl nodes. */
4133
4134 /* The DECL_TEMPLATE_PARMS are a list. The TREE_PURPOSE of each node
4135 is a INT_CST whose TREE_INT_CST_LOW indicates the level of the
4136 template parameters, with 1 being the outermost set of template
4137 parameters. The TREE_VALUE is a vector, whose elements are the
4138 template parameters at each level. Each element in the vector is a
4139 TREE_LIST, whose TREE_VALUE is a PARM_DECL (if the parameter is a
4140 non-type parameter), or a TYPE_DECL (if the parameter is a type
4141 parameter). The TREE_PURPOSE is the default value, if any. The
4142 TEMPLATE_PARM_INDEX for the parameter is available as the
4143 DECL_INITIAL (for a PARM_DECL) or as the TREE_TYPE (for a
4144 TYPE_DECL).
4145
4146 FIXME: CONST_CAST_TREE is a hack that hopefully will go away after
4147 tree is converted to C++ class hiearchy. */
4148 #define DECL_TEMPLATE_PARMS(NODE) \
4149 ((struct tree_template_decl *)CONST_CAST_TREE (TEMPLATE_DECL_CHECK (NODE)))->arguments
4150 #define DECL_INNERMOST_TEMPLATE_PARMS(NODE) \
4151 INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (NODE))
4152 #define DECL_NTPARMS(NODE) \
4153 TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (NODE))
4154 /* For function, method, class-data templates.
4155
4156 FIXME: CONST_CAST_TREE is a hack that hopefully will go away after
4157 tree is converted to C++ class hiearchy. */
4158 #define DECL_TEMPLATE_RESULT(NODE) \
4159 ((struct tree_template_decl *)CONST_CAST_TREE(TEMPLATE_DECL_CHECK (NODE)))->result
4160 /* For a function template at namespace scope, DECL_TEMPLATE_INSTANTIATIONS
4161 lists all instantiations and specializations of the function so that
4162 tsubst_friend_function can reassign them to another template if we find
4163 that the namespace-scope template is really a partial instantiation of a
4164 friend template.
4165
4166 For a class template the DECL_TEMPLATE_INSTANTIATIONS lists holds
4167 all instantiations and specializations of the class type, including
4168 partial instantiations and partial specializations, so that if we
4169 explicitly specialize a partial instantiation we can walk the list
4170 in maybe_process_partial_specialization and reassign them or complain
4171 as appropriate.
4172
4173 In both cases, the TREE_PURPOSE of each node contains the arguments
4174 used; the TREE_VALUE contains the generated variable. The template
4175 arguments are always complete. For example, given:
4176
4177 template <class T> struct S1 {
4178 template <class U> struct S2 {};
4179 template <class U> struct S2<U*> {};
4180 };
4181
4182 the record for the partial specialization will contain, as its
4183 argument list, { {T}, {U*} }, and will be on the
4184 DECL_TEMPLATE_INSTANTIATIONS list for `template <class T> template
4185 <class U> struct S1<T>::S2'.
4186
4187 This list is not used for other templates. */
4188 #define DECL_TEMPLATE_INSTANTIATIONS(NODE) \
4189 DECL_SIZE_UNIT (TEMPLATE_DECL_CHECK (NODE))
4190
4191 /* For a class template, this list contains the partial
4192 specializations of this template. (Full specializations are not
4193 recorded on this list.) The TREE_PURPOSE holds the arguments used
4194 in the partial specialization (e.g., for `template <class T> struct
4195 S<T*, int>' this will be `T*, int'.) The arguments will also include
4196 any outer template arguments. The TREE_VALUE holds the TEMPLATE_DECL
4197 for the partial specialization. The TREE_TYPE is the _TYPE node for
4198 the partial specialization.
4199
4200 This list is not used for other templates. */
4201 #define DECL_TEMPLATE_SPECIALIZATIONS(NODE) \
4202 DECL_SIZE (TEMPLATE_DECL_CHECK (NODE))
4203
4204 /* Nonzero for a DECL which is actually a template parameter. Keep
4205 these checks in ascending tree code order. */
4206 #define DECL_TEMPLATE_PARM_P(NODE) \
4207 (DECL_LANG_FLAG_0 (NODE) \
4208 && (TREE_CODE (NODE) == CONST_DECL \
4209 || TREE_CODE (NODE) == PARM_DECL \
4210 || TREE_CODE (NODE) == TYPE_DECL \
4211 || TREE_CODE (NODE) == TEMPLATE_DECL))
4212
4213 /* Mark NODE as a template parameter. */
4214 #define SET_DECL_TEMPLATE_PARM_P(NODE) \
4215 (DECL_LANG_FLAG_0 (NODE) = 1)
4216
4217 /* Nonzero if NODE is a template template parameter. */
4218 #define DECL_TEMPLATE_TEMPLATE_PARM_P(NODE) \
4219 (TREE_CODE (NODE) == TEMPLATE_DECL && DECL_TEMPLATE_PARM_P (NODE))
4220
4221 /* Nonzero for a DECL that represents a function template. */
4222 #define DECL_FUNCTION_TEMPLATE_P(NODE) \
4223 (TREE_CODE (NODE) == TEMPLATE_DECL \
4224 && DECL_TEMPLATE_RESULT (NODE) != NULL_TREE \
4225 && TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == FUNCTION_DECL)
4226
4227 /* Nonzero for a DECL that represents a class template or alias
4228 template. */
4229 #define DECL_TYPE_TEMPLATE_P(NODE) \
4230 (TREE_CODE (NODE) == TEMPLATE_DECL \
4231 && DECL_TEMPLATE_RESULT (NODE) != NULL_TREE \
4232 && TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == TYPE_DECL)
4233
4234 /* Nonzero for a DECL that represents a class template. */
4235 #define DECL_CLASS_TEMPLATE_P(NODE) \
4236 (DECL_TYPE_TEMPLATE_P (NODE) \
4237 && DECL_IMPLICIT_TYPEDEF_P (DECL_TEMPLATE_RESULT (NODE)))
4238
4239 /* Nonzero for a TEMPLATE_DECL that represents an alias template. */
4240 #define DECL_ALIAS_TEMPLATE_P(NODE) \
4241 (DECL_TYPE_TEMPLATE_P (NODE) \
4242 && !DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (NODE)))
4243
4244 /* Nonzero for a NODE which declares a type. */
4245 #define DECL_DECLARES_TYPE_P(NODE) \
4246 (TREE_CODE (NODE) == TYPE_DECL || DECL_TYPE_TEMPLATE_P (NODE))
4247
4248 /* Nonzero if NODE declares a function. */
4249 #define DECL_DECLARES_FUNCTION_P(NODE) \
4250 (TREE_CODE (NODE) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (NODE))
4251
4252 /* Nonzero if NODE is the typedef implicitly generated for a type when
4253 the type is declared. In C++, `struct S {};' is roughly
4254 equivalent to `struct S {}; typedef struct S S;' in C.
4255 DECL_IMPLICIT_TYPEDEF_P will hold for the typedef indicated in this
4256 example. In C++, there is a second implicit typedef for each
4257 class, in the scope of `S' itself, so that you can say `S::S'.
4258 DECL_SELF_REFERENCE_P will hold for that second typedef. */
4259 #define DECL_IMPLICIT_TYPEDEF_P(NODE) \
4260 (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_2 (NODE))
4261 #define SET_DECL_IMPLICIT_TYPEDEF_P(NODE) \
4262 (DECL_LANG_FLAG_2 (NODE) = 1)
4263 #define DECL_SELF_REFERENCE_P(NODE) \
4264 (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_4 (NODE))
4265 #define SET_DECL_SELF_REFERENCE_P(NODE) \
4266 (DECL_LANG_FLAG_4 (NODE) = 1)
4267
4268 /* A `primary' template is one that has its own template header and is not
4269 a partial specialization. A member function of a class template is a
4270 template, but not primary. A member template is primary. Friend
4271 templates are primary, too. */
4272
4273 /* Returns the primary template corresponding to these parameters. */
4274 #define DECL_PRIMARY_TEMPLATE(NODE) \
4275 (TREE_TYPE (DECL_INNERMOST_TEMPLATE_PARMS (NODE)))
4276
4277 /* Returns nonzero if NODE is a primary template. */
4278 #define PRIMARY_TEMPLATE_P(NODE) (DECL_PRIMARY_TEMPLATE (NODE) == (NODE))
4279
4280 /* Nonzero iff NODE is a specialization of a template. The value
4281 indicates the type of specializations:
4282
4283 1=implicit instantiation
4284
4285 2=partial or explicit specialization, e.g.:
4286
4287 template <> int min<int> (int, int),
4288
4289 3=explicit instantiation, e.g.:
4290
4291 template int min<int> (int, int);
4292
4293 Note that NODE will be marked as a specialization even if the
4294 template it is instantiating is not a primary template. For
4295 example, given:
4296
4297 template <typename T> struct O {
4298 void f();
4299 struct I {};
4300 };
4301
4302 both O<int>::f and O<int>::I will be marked as instantiations.
4303
4304 If DECL_USE_TEMPLATE is nonzero, then DECL_TEMPLATE_INFO will also
4305 be non-NULL. */
4306 #define DECL_USE_TEMPLATE(NODE) (DECL_LANG_SPECIFIC (NODE)->u.base.use_template)
4307
4308 /* Like DECL_USE_TEMPLATE, but for class types. */
4309 #define CLASSTYPE_USE_TEMPLATE(NODE) \
4310 (LANG_TYPE_CLASS_CHECK (NODE)->use_template)
4311
4312 /* True if NODE is a specialization of a primary template. */
4313 #define CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P(NODE) \
4314 (CLASS_TYPE_P (NODE) \
4315 && CLASSTYPE_USE_TEMPLATE (NODE) \
4316 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE)))
4317
4318 #define DECL_TEMPLATE_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) & 1)
4319 #define CLASSTYPE_TEMPLATE_INSTANTIATION(NODE) \
4320 (CLASSTYPE_USE_TEMPLATE (NODE) & 1)
4321
4322 #define DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) == 2)
4323 #define SET_DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) = 2)
4324
4325 /* Returns true for an explicit or partial specialization of a class
4326 template. */
4327 #define CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \
4328 (CLASSTYPE_USE_TEMPLATE (NODE) == 2)
4329 #define SET_CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \
4330 (CLASSTYPE_USE_TEMPLATE (NODE) = 2)
4331
4332 #define DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 1)
4333 #define SET_DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 1)
4334 #define CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \
4335 (CLASSTYPE_USE_TEMPLATE (NODE) == 1)
4336 #define SET_CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \
4337 (CLASSTYPE_USE_TEMPLATE (NODE) = 1)
4338
4339 #define DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 3)
4340 #define SET_DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 3)
4341 #define CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \
4342 (CLASSTYPE_USE_TEMPLATE (NODE) == 3)
4343 #define SET_CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \
4344 (CLASSTYPE_USE_TEMPLATE (NODE) = 3)
4345
4346 /* Nonzero if DECL is a friend function which is an instantiation
4347 from the point of view of the compiler, but not from the point of
4348 view of the language. For example given:
4349 template <class T> struct S { friend void f(T) {}; };
4350 the declaration of `void f(int)' generated when S<int> is
4351 instantiated will not be a DECL_TEMPLATE_INSTANTIATION, but will be
4352 a DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION. */
4353 #define DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION(DECL) \
4354 (DECL_TEMPLATE_INFO (DECL) && !DECL_USE_TEMPLATE (DECL))
4355
4356 /* Nonzero if DECL is a function generated from a function 'temploid',
4357 i.e. template, member of class template, or dependent friend. */
4358 #define DECL_TEMPLOID_INSTANTIATION(DECL) \
4359 (DECL_TEMPLATE_INSTANTIATION (DECL) \
4360 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (DECL))
4361
4362 /* Nonzero if DECL is either defined implicitly by the compiler or
4363 generated from a temploid. */
4364 #define DECL_GENERATED_P(DECL) \
4365 (DECL_TEMPLOID_INSTANTIATION (DECL) || DECL_DEFAULTED_FN (DECL))
4366
4367 /* Nonzero iff we are currently processing a declaration for an
4368 entity with its own template parameter list, and which is not a
4369 full specialization. */
4370 #define PROCESSING_REAL_TEMPLATE_DECL_P() \
4371 (processing_template_decl > template_class_depth (current_scope ()))
4372
4373 /* Nonzero if this VAR_DECL or FUNCTION_DECL has already been
4374 instantiated, i.e. its definition has been generated from the
4375 pattern given in the template. */
4376 #define DECL_TEMPLATE_INSTANTIATED(NODE) \
4377 DECL_LANG_FLAG_1 (VAR_OR_FUNCTION_DECL_CHECK (NODE))
4378
4379 /* We know what we're doing with this decl now. */
4380 #define DECL_INTERFACE_KNOWN(NODE) DECL_LANG_FLAG_5 (NODE)
4381
4382 /* DECL_EXTERNAL must be set on a decl until the decl is actually emitted,
4383 so that assemble_external will work properly. So we have this flag to
4384 tell us whether the decl is really not external.
4385
4386 This flag does not indicate whether or not the decl is defined in the
4387 current translation unit; it indicates whether or not we should emit the
4388 decl at the end of compilation if it is defined and needed. */
4389 #define DECL_NOT_REALLY_EXTERN(NODE) \
4390 (DECL_LANG_SPECIFIC (NODE)->u.base.not_really_extern)
4391
4392 #define DECL_REALLY_EXTERN(NODE) \
4393 (DECL_EXTERNAL (NODE) \
4394 && (!DECL_LANG_SPECIFIC (NODE) || !DECL_NOT_REALLY_EXTERN (NODE)))
4395
4396 /* A thunk is a stub function.
4397
4398 A thunk is an alternate entry point for an ordinary FUNCTION_DECL.
4399 The address of the ordinary FUNCTION_DECL is given by the
4400 DECL_INITIAL, which is always an ADDR_EXPR whose operand is a
4401 FUNCTION_DECL. The job of the thunk is to either adjust the this
4402 pointer before transferring control to the FUNCTION_DECL, or call
4403 FUNCTION_DECL and then adjust the result value. Note, the result
4404 pointer adjusting thunk must perform a call to the thunked
4405 function, (or be implemented via passing some invisible parameter
4406 to the thunked function, which is modified to perform the
4407 adjustment just before returning).
4408
4409 A thunk may perform either, or both, of the following operations:
4410
4411 o Adjust the this or result pointer by a constant offset.
4412 o Adjust the this or result pointer by looking up a vcall or vbase offset
4413 in the vtable.
4414
4415 A this pointer adjusting thunk converts from a base to a derived
4416 class, and hence adds the offsets. A result pointer adjusting thunk
4417 converts from a derived class to a base, and hence subtracts the
4418 offsets. If both operations are performed, then the constant
4419 adjustment is performed first for this pointer adjustment and last
4420 for the result pointer adjustment.
4421
4422 The constant adjustment is given by THUNK_FIXED_OFFSET. If the
4423 vcall or vbase offset is required, THUNK_VIRTUAL_OFFSET is
4424 used. For this pointer adjusting thunks, it is the vcall offset
4425 into the vtable. For result pointer adjusting thunks it is the
4426 binfo of the virtual base to convert to. Use that binfo's vbase
4427 offset.
4428
4429 It is possible to have equivalent covariant thunks. These are
4430 distinct virtual covariant thunks whose vbase offsets happen to
4431 have the same value. THUNK_ALIAS is used to pick one as the
4432 canonical thunk, which will get all the this pointer adjusting
4433 thunks attached to it. */
4434
4435 /* An integer indicating how many bytes should be subtracted from the
4436 this or result pointer when this function is called. */
4437 #define THUNK_FIXED_OFFSET(DECL) \
4438 (DECL_LANG_SPECIFIC (THUNK_FUNCTION_CHECK (DECL))->u.fn.u5.fixed_offset)
4439
4440 /* A tree indicating how to perform the virtual adjustment. For a this
4441 adjusting thunk it is the number of bytes to be added to the vtable
4442 to find the vcall offset. For a result adjusting thunk, it is the
4443 binfo of the relevant virtual base. If NULL, then there is no
4444 virtual adjust. (The vptr is always located at offset zero from
4445 the this or result pointer.) (If the covariant type is within the
4446 class hierarchy being laid out, the vbase index is not yet known
4447 at the point we need to create the thunks, hence the need to use
4448 binfos.) */
4449
4450 #define THUNK_VIRTUAL_OFFSET(DECL) \
4451 (LANG_DECL_U2_CHECK (FUNCTION_DECL_CHECK (DECL), 0)->access)
4452
4453 /* A thunk which is equivalent to another thunk. */
4454 #define THUNK_ALIAS(DECL) \
4455 (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->u.min.template_info)
4456
4457 /* For thunk NODE, this is the FUNCTION_DECL thunked to. It is
4458 possible for the target to be a thunk too. */
4459 #define THUNK_TARGET(NODE) \
4460 (LANG_DECL_FN_CHECK (NODE)->befriending_classes)
4461
4462 /* True for a SCOPE_REF iff the "template" keyword was used to
4463 indicate that the qualified name denotes a template. */
4464 #define QUALIFIED_NAME_IS_TEMPLATE(NODE) \
4465 (TREE_LANG_FLAG_1 (SCOPE_REF_CHECK (NODE)))
4466
4467 /* True for an OMP_ATOMIC that has dependent parameters. These are stored
4468 as an expr in operand 1, and integer_zero_node in operand 0. */
4469 #define OMP_ATOMIC_DEPENDENT_P(NODE) \
4470 (TREE_CODE (TREE_OPERAND (OMP_ATOMIC_CHECK (NODE), 0)) == INTEGER_CST)
4471
4472 /* Used while gimplifying continue statements bound to OMP_FOR nodes. */
4473 #define OMP_FOR_GIMPLIFYING_P(NODE) \
4474 (TREE_LANG_FLAG_0 (OMP_LOOP_CHECK (NODE)))
4475
4476 /* A language-specific token attached to the OpenMP data clauses to
4477 hold code (or code fragments) related to ctors, dtors, and op=.
4478 See semantics.c for details. */
4479 #define CP_OMP_CLAUSE_INFO(NODE) \
4480 TREE_TYPE (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_PRIVATE, \
4481 OMP_CLAUSE_LINEAR))
4482
4483 /* Nonzero if this transaction expression's body contains statements. */
4484 #define TRANSACTION_EXPR_IS_STMT(NODE) \
4485 TREE_LANG_FLAG_0 (TRANSACTION_EXPR_CHECK (NODE))
4486
4487 /* These macros provide convenient access to the various _STMT nodes
4488 created when parsing template declarations. */
4489 #define TRY_STMTS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 0)
4490 #define TRY_HANDLERS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 1)
4491
4492 #define EH_SPEC_STMTS(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 0)
4493 #define EH_SPEC_RAISES(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 1)
4494
4495 #define USING_STMT_NAMESPACE(NODE) TREE_OPERAND (USING_STMT_CHECK (NODE), 0)
4496
4497 /* Nonzero if this try block is a function try block. */
4498 #define FN_TRY_BLOCK_P(NODE) TREE_LANG_FLAG_3 (TRY_BLOCK_CHECK (NODE))
4499 #define HANDLER_PARMS(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 0)
4500 #define HANDLER_BODY(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 1)
4501 #define HANDLER_TYPE(NODE) TREE_TYPE (HANDLER_CHECK (NODE))
4502
4503 /* CLEANUP_STMT accessors. The statement(s) covered, the cleanup to run
4504 and the VAR_DECL for which this cleanup exists. */
4505 #define CLEANUP_BODY(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 0)
4506 #define CLEANUP_EXPR(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 1)
4507 #define CLEANUP_DECL(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 2)
4508
4509 /* IF_STMT accessors. These give access to the condition of the if
4510 statement, the then block of the if statement, and the else block
4511 of the if statement if it exists. */
4512 #define IF_COND(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 0)
4513 #define THEN_CLAUSE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 1)
4514 #define ELSE_CLAUSE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 2)
4515 #define IF_SCOPE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 3)
4516
4517 /* WHILE_STMT accessors. These give access to the condition of the
4518 while statement and the body of the while statement, respectively. */
4519 #define WHILE_COND(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 0)
4520 #define WHILE_BODY(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 1)
4521
4522 /* DO_STMT accessors. These give access to the condition of the do
4523 statement and the body of the do statement, respectively. */
4524 #define DO_COND(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 0)
4525 #define DO_BODY(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 1)
4526
4527 /* FOR_STMT accessors. These give access to the init statement,
4528 condition, update expression, and body of the for statement,
4529 respectively. */
4530 #define FOR_INIT_STMT(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 0)
4531 #define FOR_COND(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 1)
4532 #define FOR_EXPR(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 2)
4533 #define FOR_BODY(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 3)
4534 #define FOR_SCOPE(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 4)
4535
4536 /* RANGE_FOR_STMT accessors. These give access to the declarator,
4537 expression, body, and scope of the statement, respectively. */
4538 #define RANGE_FOR_DECL(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 0)
4539 #define RANGE_FOR_EXPR(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 1)
4540 #define RANGE_FOR_BODY(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 2)
4541 #define RANGE_FOR_SCOPE(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 3)
4542 #define RANGE_FOR_IVDEP(NODE) TREE_LANG_FLAG_6 (RANGE_FOR_STMT_CHECK (NODE))
4543
4544 #define SWITCH_STMT_COND(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 0)
4545 #define SWITCH_STMT_BODY(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 1)
4546 #define SWITCH_STMT_TYPE(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 2)
4547 #define SWITCH_STMT_SCOPE(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 3)
4548
4549 /* STMT_EXPR accessor. */
4550 #define STMT_EXPR_STMT(NODE) TREE_OPERAND (STMT_EXPR_CHECK (NODE), 0)
4551
4552 /* EXPR_STMT accessor. This gives the expression associated with an
4553 expression statement. */
4554 #define EXPR_STMT_EXPR(NODE) TREE_OPERAND (EXPR_STMT_CHECK (NODE), 0)
4555
4556 /* True if this TARGET_EXPR was created by build_cplus_new, and so we can
4557 discard it if it isn't useful. */
4558 #define TARGET_EXPR_IMPLICIT_P(NODE) \
4559 TREE_LANG_FLAG_0 (TARGET_EXPR_CHECK (NODE))
4560
4561 /* True if this TARGET_EXPR is the result of list-initialization of a
4562 temporary. */
4563 #define TARGET_EXPR_LIST_INIT_P(NODE) \
4564 TREE_LANG_FLAG_1 (TARGET_EXPR_CHECK (NODE))
4565
4566 /* True if this TARGET_EXPR expresses direct-initialization of an object
4567 to be named later. */
4568 #define TARGET_EXPR_DIRECT_INIT_P(NODE) \
4569 TREE_LANG_FLAG_2 (TARGET_EXPR_CHECK (NODE))
4570
4571 /* True if NODE is a TARGET_EXPR that just expresses a copy of its INITIAL; if
4572 the initializer has void type, it's doing something more complicated. */
4573 #define SIMPLE_TARGET_EXPR_P(NODE) \
4574 (TREE_CODE (NODE) == TARGET_EXPR \
4575 && !VOID_TYPE_P (TREE_TYPE (TARGET_EXPR_INITIAL (NODE))))
4576
4577 /* True if EXPR expresses direct-initialization of a TYPE. */
4578 #define DIRECT_INIT_EXPR_P(TYPE,EXPR) \
4579 (TREE_CODE (EXPR) == TARGET_EXPR && TREE_LANG_FLAG_2 (EXPR) \
4580 && same_type_ignoring_top_level_qualifiers_p (TYPE, TREE_TYPE (EXPR)))
4581
4582 /* True if this CONVERT_EXPR is for a conversion to virtual base in
4583 an NSDMI, and should be re-evaluated when used in a constructor. */
4584 #define CONVERT_EXPR_VBASE_PATH(NODE) \
4585 TREE_LANG_FLAG_0 (CONVERT_EXPR_CHECK (NODE))
4586
4587 /* True if SIZEOF_EXPR argument is type. */
4588 #define SIZEOF_EXPR_TYPE_P(NODE) \
4589 TREE_LANG_FLAG_0 (SIZEOF_EXPR_CHECK (NODE))
4590
4591 /* An enumeration of the kind of tags that C++ accepts. */
4592 enum tag_types {
4593 none_type = 0, /* Not a tag type. */
4594 record_type, /* "struct" types. */
4595 class_type, /* "class" types. */
4596 union_type, /* "union" types. */
4597 enum_type, /* "enum" types. */
4598 typename_type, /* "typename" types. */
4599 scope_type /* namespace or tagged type name followed by :: */
4600 };
4601
4602 /* The various kinds of lvalues we distinguish. */
4603 enum cp_lvalue_kind_flags {
4604 clk_none = 0, /* Things that are not an lvalue. */
4605 clk_ordinary = 1, /* An ordinary lvalue. */
4606 clk_rvalueref = 2,/* An xvalue (rvalue formed using an rvalue reference) */
4607 clk_class = 4, /* A prvalue of class-type. */
4608 clk_bitfield = 8, /* An lvalue for a bit-field. */
4609 clk_packed = 16 /* An lvalue for a packed field. */
4610 };
4611
4612 /* This type is used for parameters and variables which hold
4613 combinations of the flags in enum cp_lvalue_kind_flags. */
4614 typedef int cp_lvalue_kind;
4615
4616 /* Various kinds of template specialization, instantiation, etc. */
4617 enum tmpl_spec_kind {
4618 tsk_none, /* Not a template at all. */
4619 tsk_invalid_member_spec, /* An explicit member template
4620 specialization, but the enclosing
4621 classes have not all been explicitly
4622 specialized. */
4623 tsk_invalid_expl_inst, /* An explicit instantiation containing
4624 template parameter lists. */
4625 tsk_excessive_parms, /* A template declaration with too many
4626 template parameter lists. */
4627 tsk_insufficient_parms, /* A template declaration with too few
4628 parameter lists. */
4629 tsk_template, /* A template declaration. */
4630 tsk_expl_spec, /* An explicit specialization. */
4631 tsk_expl_inst /* An explicit instantiation. */
4632 };
4633
4634 /* The various kinds of access. BINFO_ACCESS depends on these being
4635 two bit quantities. The numerical values are important; they are
4636 used to initialize RTTI data structures, so changing them changes
4637 the ABI. */
4638 enum access_kind {
4639 ak_none = 0, /* Inaccessible. */
4640 ak_public = 1, /* Accessible, as a `public' thing. */
4641 ak_protected = 2, /* Accessible, as a `protected' thing. */
4642 ak_private = 3 /* Accessible, as a `private' thing. */
4643 };
4644
4645 /* The various kinds of special functions. If you add to this list,
4646 you should update special_function_p as well. */
4647 enum special_function_kind {
4648 sfk_none = 0, /* Not a special function. This enumeral
4649 must have value zero; see
4650 special_function_p. */
4651 sfk_constructor, /* A constructor. */
4652 sfk_copy_constructor, /* A copy constructor. */
4653 sfk_move_constructor, /* A move constructor. */
4654 sfk_copy_assignment, /* A copy assignment operator. */
4655 sfk_move_assignment, /* A move assignment operator. */
4656 sfk_destructor, /* A destructor. */
4657 sfk_complete_destructor, /* A destructor for complete objects. */
4658 sfk_base_destructor, /* A destructor for base subobjects. */
4659 sfk_deleting_destructor, /* A destructor for complete objects that
4660 deletes the object after it has been
4661 destroyed. */
4662 sfk_conversion, /* A conversion operator. */
4663 sfk_inheriting_constructor /* An inheriting constructor */
4664 };
4665
4666 /* The various kinds of linkage. From [basic.link],
4667
4668 A name is said to have linkage when it might denote the same
4669 object, reference, function, type, template, namespace or value
4670 as a name introduced in another scope:
4671
4672 -- When a name has external linkage, the entity it denotes can
4673 be referred to from scopes of other translation units or from
4674 other scopes of the same translation unit.
4675
4676 -- When a name has internal linkage, the entity it denotes can
4677 be referred to by names from other scopes in the same
4678 translation unit.
4679
4680 -- When a name has no linkage, the entity it denotes cannot be
4681 referred to by names from other scopes. */
4682
4683 enum linkage_kind {
4684 lk_none, /* No linkage. */
4685 lk_internal, /* Internal linkage. */
4686 lk_external /* External linkage. */
4687 };
4688
4689 enum duration_kind {
4690 dk_static,
4691 dk_thread,
4692 dk_auto,
4693 dk_dynamic
4694 };
4695
4696 /* Bitmask flags to control type substitution. */
4697 enum tsubst_flags {
4698 tf_none = 0, /* nothing special */
4699 tf_error = 1 << 0, /* give error messages */
4700 tf_warning = 1 << 1, /* give warnings too */
4701 tf_ignore_bad_quals = 1 << 2, /* ignore bad cvr qualifiers */
4702 tf_keep_type_decl = 1 << 3, /* retain typedef type decls
4703 (make_typename_type use) */
4704 tf_ptrmem_ok = 1 << 4, /* pointers to member ok (internal
4705 instantiate_type use) */
4706 tf_user = 1 << 5, /* found template must be a user template
4707 (lookup_template_class use) */
4708 tf_conv = 1 << 6, /* We are determining what kind of
4709 conversion might be permissible,
4710 not actually performing the
4711 conversion. */
4712 tf_decltype = 1 << 7, /* We are the operand of decltype.
4713 Used to implement the special rules
4714 for calls in decltype (5.2.2/11). */
4715 tf_partial = 1 << 8, /* Doing initial explicit argument
4716 substitution in fn_type_unification. */
4717 /* Convenient substitution flags combinations. */
4718 tf_warning_or_error = tf_warning | tf_error
4719 };
4720
4721 /* This type is used for parameters and variables which hold
4722 combinations of the flags in enum tsubst_flags. */
4723 typedef int tsubst_flags_t;
4724
4725 /* The kind of checking we can do looking in a class hierarchy. */
4726 enum base_access_flags {
4727 ba_any = 0, /* Do not check access, allow an ambiguous base,
4728 prefer a non-virtual base */
4729 ba_unique = 1 << 0, /* Must be a unique base. */
4730 ba_check_bit = 1 << 1, /* Check access. */
4731 ba_check = ba_unique | ba_check_bit,
4732 ba_ignore_scope = 1 << 2 /* Ignore access allowed by local scope. */
4733 };
4734
4735 /* This type is used for parameters and variables which hold
4736 combinations of the flags in enum base_access_flags. */
4737 typedef int base_access;
4738
4739 /* The various kinds of access check during parsing. */
4740 enum deferring_kind {
4741 dk_no_deferred = 0, /* Check access immediately */
4742 dk_deferred = 1, /* Deferred check */
4743 dk_no_check = 2 /* No access check */
4744 };
4745
4746 /* The kind of base we can find, looking in a class hierarchy.
4747 Values <0 indicate we failed. */
4748 enum base_kind {
4749 bk_inaccessible = -3, /* The base is inaccessible */
4750 bk_ambig = -2, /* The base is ambiguous */
4751 bk_not_base = -1, /* It is not a base */
4752 bk_same_type = 0, /* It is the same type */
4753 bk_proper_base = 1, /* It is a proper base */
4754 bk_via_virtual = 2 /* It is a proper base, but via a virtual
4755 path. This might not be the canonical
4756 binfo. */
4757 };
4758
4759 /* Node for "pointer to (virtual) function".
4760 This may be distinct from ptr_type_node so gdb can distinguish them. */
4761 #define vfunc_ptr_type_node vtable_entry_type
4762
4763
4764 /* For building calls to `delete'. */
4765 extern GTY(()) tree integer_two_node;
4766
4767 /* The number of function bodies which we are currently processing.
4768 (Zero if we are at namespace scope, one inside the body of a
4769 function, two inside the body of a function in a local class, etc.) */
4770 extern int function_depth;
4771
4772 /* Nonzero if we are inside eq_specializations, which affects comparison of
4773 PARM_DECLs in cp_tree_equal. */
4774 extern int comparing_specializations;
4775
4776 /* In parser.c. */
4777
4778 /* Nonzero if we are parsing an unevaluated operand: an operand to
4779 sizeof, typeof, or alignof. This is a count since operands to
4780 sizeof can be nested. */
4781
4782 extern int cp_unevaluated_operand;
4783
4784 /* RAII class used to inhibit the evaluation of operands during parsing
4785 and template instantiation. Evaluation warnings are also inhibited. */
4786
4787 struct cp_unevaluated
4788 {
4789 cp_unevaluated ();
4790 ~cp_unevaluated ();
4791 };
4792
4793 /* in pt.c */
4794
4795 /* These values are used for the `STRICT' parameter to type_unification and
4796 fn_type_unification. Their meanings are described with the
4797 documentation for fn_type_unification. */
4798
4799 enum unification_kind_t {
4800 DEDUCE_CALL,
4801 DEDUCE_CONV,
4802 DEDUCE_EXACT
4803 };
4804
4805 // An RAII class used to create a new pointer map for local
4806 // specializations. When the stack goes out of scope, the
4807 // previous pointer map is restored.
4808 struct local_specialization_stack
4809 {
4810 local_specialization_stack ();
4811 ~local_specialization_stack ();
4812
4813 hash_map<tree, tree> *saved;
4814 };
4815
4816 /* in class.c */
4817
4818 extern int current_class_depth;
4819
4820 /* An array of all local classes present in this translation unit, in
4821 declaration order. */
4822 extern GTY(()) vec<tree, va_gc> *local_classes;
4823
4824 /* Here's where we control how name mangling takes place. */
4825
4826 /* Cannot use '$' up front, because this confuses gdb
4827 (names beginning with '$' are gdb-local identifiers).
4828
4829 Note that all forms in which the '$' is significant are long enough
4830 for direct indexing (meaning that if we know there is a '$'
4831 at a particular location, we can index into the string at
4832 any other location that provides distinguishing characters). */
4833
4834 /* Define NO_DOT_IN_LABEL in your favorite tm file if your assembler
4835 doesn't allow '.' in symbol names. */
4836 #ifndef NO_DOT_IN_LABEL
4837
4838 #define JOINER '.'
4839
4840 #define AUTO_TEMP_NAME "_.tmp_"
4841 #define VFIELD_BASE ".vf"
4842 #define VFIELD_NAME "_vptr."
4843 #define VFIELD_NAME_FORMAT "_vptr.%s"
4844
4845 #else /* NO_DOT_IN_LABEL */
4846
4847 #ifndef NO_DOLLAR_IN_LABEL
4848
4849 #define JOINER '$'
4850
4851 #define AUTO_TEMP_NAME "_$tmp_"
4852 #define VFIELD_BASE "$vf"
4853 #define VFIELD_NAME "_vptr$"
4854 #define VFIELD_NAME_FORMAT "_vptr$%s"
4855
4856 #else /* NO_DOLLAR_IN_LABEL */
4857
4858 #define AUTO_TEMP_NAME "__tmp_"
4859 #define TEMP_NAME_P(ID_NODE) \
4860 (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, \
4861 sizeof (AUTO_TEMP_NAME) - 1))
4862 #define VTABLE_NAME "__vt_"
4863 #define VTABLE_NAME_P(ID_NODE) \
4864 (!strncmp (IDENTIFIER_POINTER (ID_NODE), VTABLE_NAME, \
4865 sizeof (VTABLE_NAME) - 1))
4866 #define VFIELD_BASE "__vfb"
4867 #define VFIELD_NAME "__vptr_"
4868 #define VFIELD_NAME_P(ID_NODE) \
4869 (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, \
4870 sizeof (VFIELD_NAME) - 1))
4871 #define VFIELD_NAME_FORMAT "__vptr_%s"
4872
4873 #endif /* NO_DOLLAR_IN_LABEL */
4874 #endif /* NO_DOT_IN_LABEL */
4875
4876 #define THIS_NAME "this"
4877
4878 #define IN_CHARGE_NAME "__in_chrg"
4879
4880 #define VTBL_PTR_TYPE "__vtbl_ptr_type"
4881 #define VTABLE_DELTA_NAME "__delta"
4882 #define VTABLE_PFN_NAME "__pfn"
4883
4884 #define LAMBDANAME_PREFIX "__lambda"
4885 #define LAMBDANAME_FORMAT LAMBDANAME_PREFIX "%d"
4886
4887 #define UDLIT_OP_ANSI_PREFIX "operator\"\""
4888 #define UDLIT_OP_ANSI_FORMAT UDLIT_OP_ANSI_PREFIX "%s"
4889 #define UDLIT_OP_MANGLED_PREFIX "li"
4890 #define UDLIT_OP_MANGLED_FORMAT UDLIT_OP_MANGLED_PREFIX "%s"
4891 #define UDLIT_OPER_P(ID_NODE) \
4892 (!strncmp (IDENTIFIER_POINTER (ID_NODE), \
4893 UDLIT_OP_ANSI_PREFIX, \
4894 sizeof (UDLIT_OP_ANSI_PREFIX) - 1))
4895 #define UDLIT_OP_SUFFIX(ID_NODE) \
4896 (IDENTIFIER_POINTER (ID_NODE) + sizeof (UDLIT_OP_ANSI_PREFIX) - 1)
4897
4898 #if !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL)
4899
4900 #define VTABLE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == 'v' \
4901 && IDENTIFIER_POINTER (ID_NODE)[2] == 't' \
4902 && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER)
4903
4904 #define TEMP_NAME_P(ID_NODE) \
4905 (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, sizeof (AUTO_TEMP_NAME)-1))
4906 #define VFIELD_NAME_P(ID_NODE) \
4907 (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, sizeof(VFIELD_NAME)-1))
4908
4909 #endif /* !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL) */
4910
4911
4912 /* Nonzero if we're done parsing and into end-of-file activities.
4913 Two if we're done with front-end processing. */
4914
4915 extern int at_eof;
4916
4917 /* True if note_mangling_alias should enqueue mangling aliases for
4918 later generation, rather than emitting them right away. */
4919
4920 extern bool defer_mangling_aliases;
4921
4922 /* A list of namespace-scope objects which have constructors or
4923 destructors which reside in the global scope. The decl is stored
4924 in the TREE_VALUE slot and the initializer is stored in the
4925 TREE_PURPOSE slot. */
4926 extern GTY(()) tree static_aggregates;
4927 /* Likewise, for thread local storage. */
4928 extern GTY(()) tree tls_aggregates;
4929
4930 enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, TYPENAME_FLAG };
4931
4932 /* These are uses as bits in flags passed to various functions to
4933 control their behavior. Despite the LOOKUP_ prefix, many of these
4934 do not control name lookup. ??? Functions using these flags should
4935 probably be modified to accept explicit boolean flags for the
4936 behaviors relevant to them. */
4937 /* Check for access violations. */
4938 #define LOOKUP_PROTECT (1 << 0)
4939 #define LOOKUP_NORMAL (LOOKUP_PROTECT)
4940 /* Even if the function found by lookup is a virtual function, it
4941 should be called directly. */
4942 #define LOOKUP_NONVIRTUAL (1 << 1)
4943 /* Non-converting (i.e., "explicit") constructors are not tried. This flag
4944 indicates that we are not performing direct-initialization. */
4945 #define LOOKUP_ONLYCONVERTING (1 << 2)
4946 #define LOOKUP_IMPLICIT (LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING)
4947 /* If a temporary is created, it should be created so that it lives
4948 as long as the current variable bindings; otherwise it only lives
4949 until the end of the complete-expression. It also forces
4950 direct-initialization in cases where other parts of the compiler
4951 have already generated a temporary, such as reference
4952 initialization and the catch parameter. */
4953 #define DIRECT_BIND (1 << 3)
4954 /* We're performing a user-defined conversion, so more user-defined
4955 conversions are not permitted (only built-in conversions). */
4956 #define LOOKUP_NO_CONVERSION (1 << 4)
4957 /* The user has explicitly called a destructor. (Therefore, we do
4958 not need to check that the object is non-NULL before calling the
4959 destructor.) */
4960 #define LOOKUP_DESTRUCTOR (1 << 5)
4961 /* Do not permit references to bind to temporaries. */
4962 #define LOOKUP_NO_TEMP_BIND (1 << 6)
4963 /* Do not accept objects, and possibly namespaces. */
4964 #define LOOKUP_PREFER_TYPES (1 << 7)
4965 /* Do not accept objects, and possibly types. */
4966 #define LOOKUP_PREFER_NAMESPACES (1 << 8)
4967 /* Accept types or namespaces. */
4968 #define LOOKUP_PREFER_BOTH (LOOKUP_PREFER_TYPES | LOOKUP_PREFER_NAMESPACES)
4969 /* Return friend declarations and un-declared builtin functions.
4970 (Normally, these entities are registered in the symbol table, but
4971 not found by lookup.) */
4972 #define LOOKUP_HIDDEN (LOOKUP_PREFER_NAMESPACES << 1)
4973 /* Prefer that the lvalue be treated as an rvalue. */
4974 #define LOOKUP_PREFER_RVALUE (LOOKUP_HIDDEN << 1)
4975 /* We're inside an init-list, so narrowing conversions are ill-formed. */
4976 #define LOOKUP_NO_NARROWING (LOOKUP_PREFER_RVALUE << 1)
4977 /* We're looking up a constructor for list-initialization. */
4978 #define LOOKUP_LIST_INIT_CTOR (LOOKUP_NO_NARROWING << 1)
4979 /* This is the first parameter of a copy constructor. */
4980 #define LOOKUP_COPY_PARM (LOOKUP_LIST_INIT_CTOR << 1)
4981 /* We only want to consider list constructors. */
4982 #define LOOKUP_LIST_ONLY (LOOKUP_COPY_PARM << 1)
4983 /* Return after determining which function to call and checking access.
4984 Used by sythesized_method_walk to determine which functions will
4985 be called to initialize subobjects, in order to determine exception
4986 specification and possible implicit delete.
4987 This is kind of a hack, but exiting early avoids problems with trying
4988 to perform argument conversions when the class isn't complete yet. */
4989 #define LOOKUP_SPECULATIVE (LOOKUP_LIST_ONLY << 1)
4990 /* Used by calls from defaulted functions to limit the overload set to avoid
4991 cycles trying to declare them (core issue 1092). */
4992 #define LOOKUP_DEFAULTED (LOOKUP_SPECULATIVE << 1)
4993 /* Used in calls to store_init_value to suppress its usual call to
4994 digest_init. */
4995 #define LOOKUP_ALREADY_DIGESTED (LOOKUP_DEFAULTED << 1)
4996 /* An instantiation with explicit template arguments. */
4997 #define LOOKUP_EXPLICIT_TMPL_ARGS (LOOKUP_ALREADY_DIGESTED << 1)
4998 /* Like LOOKUP_NO_TEMP_BIND, but also prevent binding to xvalues. */
4999 #define LOOKUP_NO_RVAL_BIND (LOOKUP_EXPLICIT_TMPL_ARGS << 1)
5000 /* Used by case_conversion to disregard non-integral conversions. */
5001 #define LOOKUP_NO_NON_INTEGRAL (LOOKUP_NO_RVAL_BIND << 1)
5002 /* Used for delegating constructors in order to diagnose self-delegation. */
5003 #define LOOKUP_DELEGATING_CONS (LOOKUP_NO_NON_INTEGRAL << 1)
5004
5005 #define LOOKUP_NAMESPACES_ONLY(F) \
5006 (((F) & LOOKUP_PREFER_NAMESPACES) && !((F) & LOOKUP_PREFER_TYPES))
5007 #define LOOKUP_TYPES_ONLY(F) \
5008 (!((F) & LOOKUP_PREFER_NAMESPACES) && ((F) & LOOKUP_PREFER_TYPES))
5009 #define LOOKUP_QUALIFIERS_ONLY(F) ((F) & LOOKUP_PREFER_BOTH)
5010
5011
5012 /* These flags are used by the conversion code.
5013 CONV_IMPLICIT : Perform implicit conversions (standard and user-defined).
5014 CONV_STATIC : Perform the explicit conversions for static_cast.
5015 CONV_CONST : Perform the explicit conversions for const_cast.
5016 CONV_REINTERPRET: Perform the explicit conversions for reinterpret_cast.
5017 CONV_PRIVATE : Perform upcasts to private bases.
5018 CONV_FORCE_TEMP : Require a new temporary when converting to the same
5019 aggregate type. */
5020
5021 #define CONV_IMPLICIT 1
5022 #define CONV_STATIC 2
5023 #define CONV_CONST 4
5024 #define CONV_REINTERPRET 8
5025 #define CONV_PRIVATE 16
5026 /* #define CONV_NONCONVERTING 32 */
5027 #define CONV_FORCE_TEMP 64
5028 #define CONV_FOLD 128
5029 #define CONV_OLD_CONVERT (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \
5030 | CONV_REINTERPRET)
5031 #define CONV_C_CAST (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \
5032 | CONV_REINTERPRET | CONV_PRIVATE | CONV_FORCE_TEMP)
5033 #define CONV_BACKEND_CONVERT (CONV_OLD_CONVERT | CONV_FOLD)
5034
5035 /* Used by build_expr_type_conversion to indicate which types are
5036 acceptable as arguments to the expression under consideration. */
5037
5038 #define WANT_INT 1 /* integer types, including bool */
5039 #define WANT_FLOAT 2 /* floating point types */
5040 #define WANT_ENUM 4 /* enumerated types */
5041 #define WANT_POINTER 8 /* pointer types */
5042 #define WANT_NULL 16 /* null pointer constant */
5043 #define WANT_VECTOR_OR_COMPLEX 32 /* vector or complex types */
5044 #define WANT_ARITH (WANT_INT | WANT_FLOAT | WANT_VECTOR_OR_COMPLEX)
5045
5046 /* Used with comptypes, and related functions, to guide type
5047 comparison. */
5048
5049 #define COMPARE_STRICT 0 /* Just check if the types are the
5050 same. */
5051 #define COMPARE_BASE 1 /* Check to see if the second type is
5052 derived from the first. */
5053 #define COMPARE_DERIVED 2 /* Like COMPARE_BASE, but in
5054 reverse. */
5055 #define COMPARE_REDECLARATION 4 /* The comparison is being done when
5056 another declaration of an existing
5057 entity is seen. */
5058 #define COMPARE_STRUCTURAL 8 /* The comparison is intended to be
5059 structural. The actual comparison
5060 will be identical to
5061 COMPARE_STRICT. */
5062
5063 /* Used with push_overloaded_decl. */
5064 #define PUSH_GLOBAL 0 /* Push the DECL into namespace scope,
5065 regardless of the current scope. */
5066 #define PUSH_LOCAL 1 /* Push the DECL into the current
5067 scope. */
5068 #define PUSH_USING 2 /* We are pushing this DECL as the
5069 result of a using declaration. */
5070
5071 /* Used with start function. */
5072 #define SF_DEFAULT 0 /* No flags. */
5073 #define SF_PRE_PARSED 1 /* The function declaration has
5074 already been parsed. */
5075 #define SF_INCLASS_INLINE 2 /* The function is an inline, defined
5076 in the class body. */
5077
5078 /* Used with start_decl's initialized parameter. */
5079 #define SD_UNINITIALIZED 0
5080 #define SD_INITIALIZED 1
5081 #define SD_DEFAULTED 2
5082 #define SD_DELETED 3
5083
5084 /* Returns nonzero iff TYPE1 and TYPE2 are the same type, or if TYPE2
5085 is derived from TYPE1, or if TYPE2 is a pointer (reference) to a
5086 class derived from the type pointed to (referred to) by TYPE1. */
5087 #define same_or_base_type_p(TYPE1, TYPE2) \
5088 comptypes ((TYPE1), (TYPE2), COMPARE_BASE)
5089
5090 /* These macros are used to access a TEMPLATE_PARM_INDEX. */
5091 #define TEMPLATE_PARM_INDEX_CAST(NODE) \
5092 ((template_parm_index*)TEMPLATE_PARM_INDEX_CHECK (NODE))
5093 #define TEMPLATE_PARM_IDX(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->index)
5094 #define TEMPLATE_PARM_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->level)
5095 #define TEMPLATE_PARM_DESCENDANTS(NODE) (TREE_CHAIN (NODE))
5096 #define TEMPLATE_PARM_ORIG_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->orig_level)
5097 #define TEMPLATE_PARM_DECL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->decl)
5098 #define TEMPLATE_PARM_PARAMETER_PACK(NODE) \
5099 (TREE_LANG_FLAG_0 (TEMPLATE_PARM_INDEX_CHECK (NODE)))
5100
5101 /* These macros are for accessing the fields of TEMPLATE_TYPE_PARM,
5102 TEMPLATE_TEMPLATE_PARM and BOUND_TEMPLATE_TEMPLATE_PARM nodes. */
5103 #define TEMPLATE_TYPE_PARM_INDEX(NODE) \
5104 (TYPE_VALUES_RAW (TREE_CHECK3 ((NODE), TEMPLATE_TYPE_PARM, \
5105 TEMPLATE_TEMPLATE_PARM, \
5106 BOUND_TEMPLATE_TEMPLATE_PARM)))
5107 #define TEMPLATE_TYPE_IDX(NODE) \
5108 (TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (NODE)))
5109 #define TEMPLATE_TYPE_LEVEL(NODE) \
5110 (TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
5111 #define TEMPLATE_TYPE_ORIG_LEVEL(NODE) \
5112 (TEMPLATE_PARM_ORIG_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
5113 #define TEMPLATE_TYPE_DECL(NODE) \
5114 (TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
5115 #define TEMPLATE_TYPE_PARAMETER_PACK(NODE) \
5116 (TEMPLATE_PARM_PARAMETER_PACK (TEMPLATE_TYPE_PARM_INDEX (NODE)))
5117
5118 /* Contexts in which auto deduction occurs. These flags are
5119 used to control diagnostics in do_auto_deduction. */
5120
5121 enum auto_deduction_context
5122 {
5123 adc_unspecified, /* Not given */
5124 adc_variable_type, /* Variable initializer deduction */
5125 adc_return_type, /* Return type deduction */
5126 adc_requirement /* Argument dedution constraint */
5127 };
5128
5129 /* True iff this TEMPLATE_TYPE_PARM represents decltype(auto). */
5130 #define AUTO_IS_DECLTYPE(NODE) \
5131 (TYPE_LANG_FLAG_5 (TEMPLATE_TYPE_PARM_CHECK (NODE)))
5132
5133 /* These constants can used as bit flags in the process of tree formatting.
5134
5135 TFF_PLAIN_IDENTIFIER: unqualified part of a name.
5136 TFF_SCOPE: include the class and namespace scope of the name.
5137 TFF_CHASE_TYPEDEF: print the original type-id instead of the typedef-name.
5138 TFF_DECL_SPECIFIERS: print decl-specifiers.
5139 TFF_CLASS_KEY_OR_ENUM: precede a class-type name (resp. enum name) with
5140 a class-key (resp. `enum').
5141 TFF_RETURN_TYPE: include function return type.
5142 TFF_FUNCTION_DEFAULT_ARGUMENTS: include function default parameter values.
5143 TFF_EXCEPTION_SPECIFICATION: show function exception specification.
5144 TFF_TEMPLATE_HEADER: show the template<...> header in a
5145 template-declaration.
5146 TFF_TEMPLATE_NAME: show only template-name.
5147 TFF_EXPR_IN_PARENS: parenthesize expressions.
5148 TFF_NO_FUNCTION_ARGUMENTS: don't show function arguments.
5149 TFF_UNQUALIFIED_NAME: do not print the qualifying scope of the
5150 top-level entity.
5151 TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS: do not omit template arguments
5152 identical to their defaults.
5153 TFF_NO_TEMPLATE_BINDINGS: do not print information about the template
5154 arguments for a function template specialization.
5155 TFF_POINTER: we are printing a pointer type. */
5156
5157 #define TFF_PLAIN_IDENTIFIER (0)
5158 #define TFF_SCOPE (1)
5159 #define TFF_CHASE_TYPEDEF (1 << 1)
5160 #define TFF_DECL_SPECIFIERS (1 << 2)
5161 #define TFF_CLASS_KEY_OR_ENUM (1 << 3)
5162 #define TFF_RETURN_TYPE (1 << 4)
5163 #define TFF_FUNCTION_DEFAULT_ARGUMENTS (1 << 5)
5164 #define TFF_EXCEPTION_SPECIFICATION (1 << 6)
5165 #define TFF_TEMPLATE_HEADER (1 << 7)
5166 #define TFF_TEMPLATE_NAME (1 << 8)
5167 #define TFF_EXPR_IN_PARENS (1 << 9)
5168 #define TFF_NO_FUNCTION_ARGUMENTS (1 << 10)
5169 #define TFF_UNQUALIFIED_NAME (1 << 11)
5170 #define TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS (1 << 12)
5171 #define TFF_NO_TEMPLATE_BINDINGS (1 << 13)
5172 #define TFF_POINTER (1 << 14)
5173
5174 /* Returns the TEMPLATE_DECL associated to a TEMPLATE_TEMPLATE_PARM
5175 node. */
5176 #define TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL(NODE) \
5177 ((TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM) \
5178 ? TYPE_TI_TEMPLATE (NODE) \
5179 : TYPE_NAME (NODE))
5180
5181 /* in lex.c */
5182
5183 extern void init_reswords (void);
5184
5185 typedef struct GTY(()) operator_name_info_t {
5186 /* The IDENTIFIER_NODE for the operator. */
5187 tree identifier;
5188 /* The name of the operator. */
5189 const char *name;
5190 /* The mangled name of the operator. */
5191 const char *mangled_name;
5192 /* The arity of the operator. */
5193 int arity;
5194 } operator_name_info_t;
5195
5196 /* A mapping from tree codes to operator name information. */
5197 extern GTY(()) operator_name_info_t operator_name_info
5198 [(int) MAX_TREE_CODES];
5199 /* Similar, but for assignment operators. */
5200 extern GTY(()) operator_name_info_t assignment_operator_name_info
5201 [(int) MAX_TREE_CODES];
5202
5203 /* A type-qualifier, or bitmask therefore, using the TYPE_QUAL
5204 constants. */
5205
5206 typedef int cp_cv_quals;
5207
5208 /* Non-static member functions have an optional virt-specifier-seq.
5209 There is a VIRT_SPEC value for each virt-specifier.
5210 They can be combined by bitwise-or to form the complete set of
5211 virt-specifiers for a member function. */
5212 enum virt_specifier
5213 {
5214 VIRT_SPEC_UNSPECIFIED = 0x0,
5215 VIRT_SPEC_FINAL = 0x1,
5216 VIRT_SPEC_OVERRIDE = 0x2
5217 };
5218
5219 /* A type-qualifier, or bitmask therefore, using the VIRT_SPEC
5220 constants. */
5221
5222 typedef int cp_virt_specifiers;
5223
5224 /* Wherever there is a function-cv-qual, there could also be a ref-qualifier:
5225
5226 [dcl.fct]
5227 The return type, the parameter-type-list, the ref-qualifier, and
5228 the cv-qualifier-seq, but not the default arguments or the exception
5229 specification, are part of the function type.
5230
5231 REF_QUAL_NONE Ordinary member function with no ref-qualifier
5232 REF_QUAL_LVALUE Member function with the &-ref-qualifier
5233 REF_QUAL_RVALUE Member function with the &&-ref-qualifier */
5234
5235 enum cp_ref_qualifier {
5236 REF_QUAL_NONE = 0,
5237 REF_QUAL_LVALUE = 1,
5238 REF_QUAL_RVALUE = 2
5239 };
5240
5241 /* A storage class. */
5242
5243 enum cp_storage_class {
5244 /* sc_none must be zero so that zeroing a cp_decl_specifier_seq
5245 sets the storage_class field to sc_none. */
5246 sc_none = 0,
5247 sc_auto,
5248 sc_register,
5249 sc_static,
5250 sc_extern,
5251 sc_mutable
5252 };
5253
5254 /* An individual decl-specifier. This is used to index the array of
5255 locations for the declspecs in struct cp_decl_specifier_seq
5256 below. */
5257
5258 enum cp_decl_spec {
5259 ds_first,
5260 ds_signed = ds_first,
5261 ds_unsigned,
5262 ds_short,
5263 ds_long,
5264 ds_const,
5265 ds_volatile,
5266 ds_restrict,
5267 ds_inline,
5268 ds_virtual,
5269 ds_explicit,
5270 ds_friend,
5271 ds_typedef,
5272 ds_alias,
5273 ds_constexpr,
5274 ds_complex,
5275 ds_thread,
5276 ds_type_spec,
5277 ds_redefined_builtin_type_spec,
5278 ds_attribute,
5279 ds_std_attribute,
5280 ds_storage_class,
5281 ds_long_long,
5282 ds_concept,
5283 ds_last /* This enumerator must always be the last one. */
5284 };
5285
5286 /* A decl-specifier-seq. */
5287
5288 struct cp_decl_specifier_seq {
5289 /* An array of locations for the declaration sepecifiers, indexed by
5290 enum cp_decl_spec_word. */
5291 source_location locations[ds_last];
5292 /* The primary type, if any, given by the decl-specifier-seq.
5293 Modifiers, like "short", "const", and "unsigned" are not
5294 reflected here. This field will be a TYPE, unless a typedef-name
5295 was used, in which case it will be a TYPE_DECL. */
5296 tree type;
5297 /* The attributes, if any, provided with the specifier sequence. */
5298 tree attributes;
5299 /* The c++11 attributes that follows the type specifier. */
5300 tree std_attributes;
5301 /* If non-NULL, a built-in type that the user attempted to redefine
5302 to some other type. */
5303 tree redefined_builtin_type;
5304 /* The storage class specified -- or sc_none if no storage class was
5305 explicitly specified. */
5306 cp_storage_class storage_class;
5307 /* For the __intN declspec, this stores the index into the int_n_* arrays. */
5308 int int_n_idx;
5309 /* True iff TYPE_SPEC defines a class or enum. */
5310 BOOL_BITFIELD type_definition_p : 1;
5311 /* True iff multiple types were (erroneously) specified for this
5312 decl-specifier-seq. */
5313 BOOL_BITFIELD multiple_types_p : 1;
5314 /* True iff multiple storage classes were (erroneously) specified
5315 for this decl-specifier-seq or a combination of a storage class
5316 with a typedef specifier. */
5317 BOOL_BITFIELD conflicting_specifiers_p : 1;
5318 /* True iff at least one decl-specifier was found. */
5319 BOOL_BITFIELD any_specifiers_p : 1;
5320 /* True iff at least one type-specifier was found. */
5321 BOOL_BITFIELD any_type_specifiers_p : 1;
5322 /* True iff "int" was explicitly provided. */
5323 BOOL_BITFIELD explicit_int_p : 1;
5324 /* True iff "__intN" was explicitly provided. */
5325 BOOL_BITFIELD explicit_intN_p : 1;
5326 /* True iff "char" was explicitly provided. */
5327 BOOL_BITFIELD explicit_char_p : 1;
5328 /* True iff ds_thread is set for __thread, not thread_local. */
5329 BOOL_BITFIELD gnu_thread_keyword_p : 1;
5330 /* True iff the type is a decltype. */
5331 BOOL_BITFIELD decltype_p : 1;
5332 };
5333
5334 /* The various kinds of declarators. */
5335
5336 enum cp_declarator_kind {
5337 cdk_id,
5338 cdk_function,
5339 cdk_array,
5340 cdk_pointer,
5341 cdk_reference,
5342 cdk_ptrmem,
5343 cdk_error
5344 };
5345
5346 /* A declarator. */
5347
5348 typedef struct cp_declarator cp_declarator;
5349
5350 typedef struct cp_parameter_declarator cp_parameter_declarator;
5351
5352 /* A parameter, before it has been semantically analyzed. */
5353 struct cp_parameter_declarator {
5354 /* The next parameter, or NULL_TREE if none. */
5355 cp_parameter_declarator *next;
5356 /* The decl-specifiers-seq for the parameter. */
5357 cp_decl_specifier_seq decl_specifiers;
5358 /* The declarator for the parameter. */
5359 cp_declarator *declarator;
5360 /* The default-argument expression, or NULL_TREE, if none. */
5361 tree default_argument;
5362 /* True iff this is a template parameter pack. */
5363 bool template_parameter_pack_p;
5364 };
5365
5366 /* A declarator. */
5367 struct cp_declarator {
5368 /* The kind of declarator. */
5369 ENUM_BITFIELD (cp_declarator_kind) kind : 4;
5370 /* Whether we parsed an ellipsis (`...') just before the declarator,
5371 to indicate this is a parameter pack. */
5372 BOOL_BITFIELD parameter_pack_p : 1;
5373 location_t id_loc; /* Currently only set for cdk_id and cdk_function. */
5374 /* GNU Attributes that apply to this declarator. If the declarator
5375 is a pointer or a reference, these attribute apply to the type
5376 pointed to. */
5377 tree attributes;
5378 /* Standard C++11 attributes that apply to this declarator. If the
5379 declarator is a pointer or a reference, these attributes apply
5380 to the pointer, rather than to the type pointed to. */
5381 tree std_attributes;
5382 /* For all but cdk_id and cdk_error, the contained declarator. For
5383 cdk_id and cdk_error, guaranteed to be NULL. */
5384 cp_declarator *declarator;
5385 union {
5386 /* For identifiers. */
5387 struct {
5388 /* If non-NULL, the qualifying scope (a NAMESPACE_DECL or
5389 *_TYPE) for this identifier. */
5390 tree qualifying_scope;
5391 /* The unqualified name of the entity -- an IDENTIFIER_NODE,
5392 BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
5393 tree unqualified_name;
5394 /* If this is the name of a function, what kind of special
5395 function (if any). */
5396 special_function_kind sfk;
5397 } id;
5398 /* For functions. */
5399 struct {
5400 /* The parameters to the function as a TREE_LIST of decl/default. */
5401 tree parameters;
5402 /* The cv-qualifiers for the function. */
5403 cp_cv_quals qualifiers;
5404 /* The virt-specifiers for the function. */
5405 cp_virt_specifiers virt_specifiers;
5406 /* The ref-qualifier for the function. */
5407 cp_ref_qualifier ref_qualifier;
5408 /* The transaction-safety qualifier for the function. */
5409 tree tx_qualifier;
5410 /* The exception-specification for the function. */
5411 tree exception_specification;
5412 /* The late-specified return type, if any. */
5413 tree late_return_type;
5414 /* The trailing requires-clause, if any. */
5415 tree requires_clause;
5416 } function;
5417 /* For arrays. */
5418 struct {
5419 /* The bounds to the array. */
5420 tree bounds;
5421 } array;
5422 /* For cdk_pointer and cdk_ptrmem. */
5423 struct {
5424 /* The cv-qualifiers for the pointer. */
5425 cp_cv_quals qualifiers;
5426 /* For cdk_ptrmem, the class type containing the member. */
5427 tree class_type;
5428 } pointer;
5429 /* For cdk_reference */
5430 struct {
5431 /* The cv-qualifiers for the reference. These qualifiers are
5432 only used to diagnose ill-formed code. */
5433 cp_cv_quals qualifiers;
5434 /* Whether this is an rvalue reference */
5435 bool rvalue_ref;
5436 } reference;
5437 } u;
5438 };
5439
5440 /* A level of template instantiation. */
5441 struct GTY((chain_next ("%h.next"))) tinst_level {
5442 /* The immediately deeper level in the chain. */
5443 struct tinst_level *next;
5444
5445 /* The original node. Can be either a DECL (for a function or static
5446 data member) or a TYPE (for a class), depending on what we were
5447 asked to instantiate. */
5448 tree decl;
5449
5450 /* The location where the template is instantiated. */
5451 location_t locus;
5452
5453 /* errorcount+sorrycount when we pushed this level. */
5454 int errors;
5455
5456 /* True if the location is in a system header. */
5457 bool in_system_header_p;
5458 };
5459
5460 bool decl_spec_seq_has_spec_p (const cp_decl_specifier_seq *, cp_decl_spec);
5461
5462 /* Return the type of the `this' parameter of FNTYPE. */
5463
5464 inline tree
type_of_this_parm(const_tree fntype)5465 type_of_this_parm (const_tree fntype)
5466 {
5467 function_args_iterator iter;
5468 gcc_assert (TREE_CODE (fntype) == METHOD_TYPE);
5469 function_args_iter_init (&iter, fntype);
5470 return function_args_iter_cond (&iter);
5471 }
5472
5473 /* Return the class of the `this' parameter of FNTYPE. */
5474
5475 inline tree
class_of_this_parm(const_tree fntype)5476 class_of_this_parm (const_tree fntype)
5477 {
5478 return TREE_TYPE (type_of_this_parm (fntype));
5479 }
5480
5481 /* True iff T is a variable template declaration. */
5482 inline bool
variable_template_p(tree t)5483 variable_template_p (tree t)
5484 {
5485 if (TREE_CODE (t) != TEMPLATE_DECL)
5486 return false;
5487 if (!PRIMARY_TEMPLATE_P (t))
5488 return false;
5489 if (tree r = DECL_TEMPLATE_RESULT (t))
5490 return VAR_P (r);
5491 return false;
5492 }
5493
5494 /* True iff T is a variable concept definition. That is, T is
5495 a variable template declared with the concept specifier. */
5496 inline bool
variable_concept_p(tree t)5497 variable_concept_p (tree t)
5498 {
5499 if (TREE_CODE (t) != TEMPLATE_DECL)
5500 return false;
5501 if (tree r = DECL_TEMPLATE_RESULT (t))
5502 return VAR_P (r) && DECL_DECLARED_CONCEPT_P (r);
5503 return false;
5504 }
5505
5506 /* True iff T is a concept definition. That is, T is a variable or function
5507 template declared with the concept specifier. */
5508 inline bool
concept_template_p(tree t)5509 concept_template_p (tree t)
5510 {
5511 if (TREE_CODE (t) != TEMPLATE_DECL)
5512 return false;
5513 if (tree r = DECL_TEMPLATE_RESULT (t))
5514 return VAR_OR_FUNCTION_DECL_P (r) && DECL_DECLARED_CONCEPT_P (r);
5515 return false;
5516 }
5517
5518 /* A parameter list indicating for a function with no parameters,
5519 e.g "int f(void)". */
5520 extern cp_parameter_declarator *no_parameters;
5521
5522 /* True if we saw "#pragma GCC java_exceptions". */
5523 extern bool pragma_java_exceptions;
5524
5525 /* in call.c */
5526 extern bool check_dtor_name (tree, tree);
5527 int magic_varargs_p (tree);
5528
5529 extern tree build_conditional_expr (location_t, tree, tree, tree,
5530 tsubst_flags_t);
5531 extern tree build_addr_func (tree, tsubst_flags_t);
5532 extern void set_flags_from_callee (tree);
5533 extern tree build_call_a (tree, int, tree*);
5534 extern tree build_call_n (tree, int, ...);
5535 extern bool null_ptr_cst_p (tree);
5536 extern bool null_member_pointer_value_p (tree);
5537 extern bool sufficient_parms_p (const_tree);
5538 extern tree type_decays_to (tree);
5539 extern tree build_user_type_conversion (tree, tree, int,
5540 tsubst_flags_t);
5541 extern tree build_new_function_call (tree, vec<tree, va_gc> **, bool,
5542 tsubst_flags_t);
5543 extern tree build_operator_new_call (tree, vec<tree, va_gc> **, tree *,
5544 tree *, tree, tree *,
5545 tsubst_flags_t);
5546 extern tree build_new_method_call (tree, tree, vec<tree, va_gc> **,
5547 tree, int, tree *,
5548 tsubst_flags_t);
5549 extern tree build_special_member_call (tree, tree, vec<tree, va_gc> **,
5550 tree, int, tsubst_flags_t);
5551 extern tree build_new_op (location_t, enum tree_code,
5552 int, tree, tree, tree, tree *,
5553 tsubst_flags_t);
5554 extern tree build_op_call (tree, vec<tree, va_gc> **,
5555 tsubst_flags_t);
5556 extern bool non_placement_deallocation_fn_p (tree);
5557 extern tree build_op_delete_call (enum tree_code, tree, tree,
5558 bool, tree, tree,
5559 tsubst_flags_t);
5560 extern bool can_convert (tree, tree, tsubst_flags_t);
5561 extern bool can_convert_standard (tree, tree, tsubst_flags_t);
5562 extern bool can_convert_arg (tree, tree, tree, int,
5563 tsubst_flags_t);
5564 extern bool can_convert_arg_bad (tree, tree, tree, int,
5565 tsubst_flags_t);
5566 extern bool enforce_access (tree, tree, tree,
5567 tsubst_flags_t);
5568 extern void push_defarg_context (tree);
5569 extern void pop_defarg_context (void);
5570 extern tree convert_default_arg (tree, tree, tree, int,
5571 tsubst_flags_t);
5572 extern tree convert_arg_to_ellipsis (tree, tsubst_flags_t);
5573 extern tree build_x_va_arg (source_location, tree, tree);
5574 extern tree cxx_type_promotes_to (tree);
5575 extern tree type_passed_as (tree);
5576 extern tree convert_for_arg_passing (tree, tree, tsubst_flags_t);
5577 extern bool is_properly_derived_from (tree, tree);
5578 extern tree initialize_reference (tree, tree, int,
5579 tsubst_flags_t);
5580 extern tree extend_ref_init_temps (tree, tree, vec<tree, va_gc>**);
5581 extern tree make_temporary_var_for_ref_to_temp (tree, tree);
5582 extern bool type_has_extended_temps (tree);
5583 extern tree strip_top_quals (tree);
5584 extern bool reference_related_p (tree, tree);
5585 extern int remaining_arguments (tree);
5586 extern tree perform_implicit_conversion (tree, tree, tsubst_flags_t);
5587 extern tree perform_implicit_conversion_flags (tree, tree, tsubst_flags_t, int);
5588 extern tree build_integral_nontype_arg_conv (tree, tree, tsubst_flags_t);
5589 extern tree perform_direct_initialization_if_possible (tree, tree, bool,
5590 tsubst_flags_t);
5591 extern tree in_charge_arg_for_name (tree);
5592 extern tree build_cxx_call (tree, int, tree *,
5593 tsubst_flags_t);
5594 extern bool is_std_init_list (tree);
5595 extern bool is_list_ctor (tree);
5596 extern void validate_conversion_obstack (void);
5597 extern void mark_versions_used (tree);
5598 extern tree get_function_version_dispatcher (tree);
5599
5600 /* in class.c */
5601 extern tree build_vfield_ref (tree, tree);
5602 extern tree build_if_in_charge (tree true_stmt, tree false_stmt = void_node);
5603 extern tree build_base_path (enum tree_code, tree,
5604 tree, int, tsubst_flags_t);
5605 extern tree convert_to_base (tree, tree, bool, bool,
5606 tsubst_flags_t);
5607 extern tree convert_to_base_statically (tree, tree);
5608 extern tree build_vtbl_ref (tree, tree);
5609 extern tree build_vfn_ref (tree, tree);
5610 extern tree get_vtable_decl (tree, int);
5611 extern void resort_type_method_vec (void *, void *,
5612 gt_pointer_operator, void *);
5613 extern bool add_method (tree, tree, tree);
5614 extern tree currently_open_class (tree);
5615 extern tree currently_open_derived_class (tree);
5616 extern tree outermost_open_class (void);
5617 extern tree current_nonlambda_class_type (void);
5618 extern tree finish_struct (tree, tree);
5619 extern void finish_struct_1 (tree);
5620 extern int resolves_to_fixed_type_p (tree, int *);
5621 extern void init_class_processing (void);
5622 extern int is_empty_class (tree);
5623 extern bool is_really_empty_class (tree);
5624 extern void pushclass (tree);
5625 extern void popclass (void);
5626 extern void push_nested_class (tree);
5627 extern void pop_nested_class (void);
5628 extern int current_lang_depth (void);
5629 extern void push_lang_context (tree);
5630 extern void pop_lang_context (void);
5631 extern tree instantiate_type (tree, tree, tsubst_flags_t);
5632 extern void print_class_statistics (void);
5633 extern void build_self_reference (void);
5634 extern int same_signature_p (const_tree, const_tree);
5635 extern void maybe_add_class_template_decl_list (tree, tree, int);
5636 extern void unreverse_member_declarations (tree);
5637 extern void invalidate_class_lookup_cache (void);
5638 extern void maybe_note_name_used_in_class (tree, tree);
5639 extern void note_name_declared_in_class (tree, tree);
5640 extern tree get_vtbl_decl_for_binfo (tree);
5641 extern bool vptr_via_virtual_p (tree);
5642 extern void debug_class (tree);
5643 extern void debug_thunks (tree);
5644 extern void set_linkage_according_to_type (tree, tree);
5645 extern void determine_key_method (tree);
5646 extern void check_for_override (tree, tree);
5647 extern void push_class_stack (void);
5648 extern void pop_class_stack (void);
5649 extern bool type_has_user_nondefault_constructor (tree);
5650 extern tree in_class_defaulted_default_constructor (tree);
5651 extern bool user_provided_p (tree);
5652 extern bool type_has_user_provided_constructor (tree);
5653 extern bool type_has_user_provided_or_explicit_constructor (tree);
5654 extern bool type_has_non_user_provided_default_constructor (tree);
5655 extern bool vbase_has_user_provided_move_assign (tree);
5656 extern tree default_init_uninitialized_part (tree);
5657 extern bool trivial_default_constructor_is_constexpr (tree);
5658 extern bool type_has_constexpr_default_constructor (tree);
5659 extern bool type_has_virtual_destructor (tree);
5660 extern bool type_has_move_constructor (tree);
5661 extern bool type_has_move_assign (tree);
5662 extern bool type_has_user_declared_move_constructor (tree);
5663 extern bool type_has_user_declared_move_assign(tree);
5664 extern bool type_build_ctor_call (tree);
5665 extern bool type_build_dtor_call (tree);
5666 extern void explain_non_literal_class (tree);
5667 extern void inherit_targ_abi_tags (tree);
5668 extern void defaulted_late_check (tree);
5669 extern bool defaultable_fn_check (tree);
5670 extern void check_abi_tags (tree);
5671 extern void fixup_type_variants (tree);
5672 extern void fixup_attribute_variants (tree);
5673 extern tree* decl_cloned_function_p (const_tree, bool);
5674 extern void clone_function_decl (tree, int);
5675 extern void adjust_clone_args (tree);
5676 extern void deduce_noexcept_on_destructor (tree);
5677 extern void insert_late_enum_def_into_classtype_sorted_fields (tree, tree);
5678 extern bool uniquely_derived_from_p (tree, tree);
5679 extern bool publicly_uniquely_derived_p (tree, tree);
5680 extern tree common_enclosing_class (tree, tree);
5681
5682 /* in cvt.c */
5683 extern tree convert_to_reference (tree, tree, int, int, tree,
5684 tsubst_flags_t);
5685 extern tree convert_from_reference (tree);
5686 extern tree force_rvalue (tree, tsubst_flags_t);
5687 extern tree ocp_convert (tree, tree, int, int,
5688 tsubst_flags_t);
5689 extern tree cp_convert (tree, tree, tsubst_flags_t);
5690 extern tree cp_convert_and_check (tree, tree, tsubst_flags_t);
5691 extern tree cp_fold_convert (tree, tree);
5692 extern tree convert_to_void (tree, impl_conv_void,
5693 tsubst_flags_t);
5694 extern tree convert_force (tree, tree, int,
5695 tsubst_flags_t);
5696 extern tree build_expr_type_conversion (int, tree, bool);
5697 extern tree type_promotes_to (tree);
5698 extern tree perform_qualification_conversions (tree, tree);
5699 extern bool tx_safe_fn_type_p (tree);
5700 extern tree tx_unsafe_fn_variant (tree);
5701 extern bool can_convert_tx_safety (tree, tree);
5702
5703 /* in name-lookup.c */
5704 extern tree pushdecl (tree);
5705 extern tree pushdecl_maybe_friend (tree, bool);
5706 extern void maybe_push_cleanup_level (tree);
5707 extern tree pushtag (tree, tree, tag_scope);
5708 extern tree make_anon_name (void);
5709 extern tree pushdecl_top_level_maybe_friend (tree, bool);
5710 extern tree pushdecl_top_level_and_finish (tree, tree);
5711 extern tree check_for_out_of_scope_variable (tree);
5712 extern void dump (cp_binding_level &ref);
5713 extern void dump (cp_binding_level *ptr);
5714 extern void print_other_binding_stack (cp_binding_level *);
5715 extern tree maybe_push_decl (tree);
5716 extern tree current_decl_namespace (void);
5717
5718 /* decl.c */
5719 extern tree poplevel (int, int, int);
5720 extern void cxx_init_decl_processing (void);
5721 enum cp_tree_node_structure_enum cp_tree_node_structure
5722 (union lang_tree_node *);
5723 extern void finish_scope (void);
5724 extern void push_switch (tree);
5725 extern void pop_switch (void);
5726 extern tree make_lambda_name (void);
5727 extern int decls_match (tree, tree);
5728 extern tree duplicate_decls (tree, tree, bool);
5729 extern tree declare_local_label (tree);
5730 extern tree define_label (location_t, tree);
5731 extern void check_goto (tree);
5732 extern bool check_omp_return (void);
5733 extern tree make_typename_type (tree, tree, enum tag_types, tsubst_flags_t);
5734 extern tree make_unbound_class_template (tree, tree, tree, tsubst_flags_t);
5735 extern tree build_library_fn_ptr (const char *, tree, int);
5736 extern tree build_cp_library_fn_ptr (const char *, tree, int);
5737 extern tree push_library_fn (tree, tree, tree, int);
5738 extern tree push_void_library_fn (tree, tree, int);
5739 extern tree push_throw_library_fn (tree, tree);
5740 extern void warn_misplaced_attr_for_class_type (source_location location,
5741 tree class_type);
5742 extern tree check_tag_decl (cp_decl_specifier_seq *, bool);
5743 extern tree shadow_tag (cp_decl_specifier_seq *);
5744 extern tree groktypename (cp_decl_specifier_seq *, const cp_declarator *, bool);
5745 extern tree start_decl (const cp_declarator *, cp_decl_specifier_seq *, int, tree, tree, tree *);
5746 extern void start_decl_1 (tree, bool);
5747 extern bool check_array_initializer (tree, tree, tree);
5748 extern void cp_finish_decl (tree, tree, bool, tree, int);
5749 extern int cp_complete_array_type (tree *, tree, bool);
5750 extern int cp_complete_array_type_or_error (tree *, tree, bool, tsubst_flags_t);
5751 extern tree build_ptrmemfunc_type (tree);
5752 extern tree build_ptrmem_type (tree, tree);
5753 /* the grokdeclarator prototype is in decl.h */
5754 extern tree build_this_parm (tree, cp_cv_quals);
5755 extern tree grokparms (tree, tree *);
5756 extern int copy_fn_p (const_tree);
5757 extern bool move_fn_p (const_tree);
5758 extern bool move_signature_fn_p (const_tree);
5759 extern tree get_scope_of_declarator (const cp_declarator *);
5760 extern void grok_special_member_properties (tree);
5761 extern int grok_ctor_properties (const_tree, const_tree);
5762 extern bool grok_op_properties (tree, bool);
5763 extern tree xref_tag (enum tag_types, tree, tag_scope, bool);
5764 extern tree xref_tag_from_type (tree, tree, tag_scope);
5765 extern bool xref_basetypes (tree, tree);
5766 extern tree start_enum (tree, tree, tree, tree, bool, bool *);
5767 extern void finish_enum_value_list (tree);
5768 extern void finish_enum (tree);
5769 extern void build_enumerator (tree, tree, tree, tree, location_t);
5770 extern tree lookup_enumerator (tree, tree);
5771 extern bool start_preparsed_function (tree, tree, int);
5772 extern bool start_function (cp_decl_specifier_seq *,
5773 const cp_declarator *, tree);
5774 extern tree begin_function_body (void);
5775 extern void finish_function_body (tree);
5776 extern tree outer_curly_brace_block (tree);
5777 extern tree finish_function (int);
5778 extern tree grokmethod (cp_decl_specifier_seq *, const cp_declarator *, tree);
5779 extern void maybe_register_incomplete_var (tree);
5780 extern void maybe_commonize_var (tree);
5781 extern void complete_vars (tree);
5782 extern tree static_fn_type (tree);
5783 extern void revert_static_member_fn (tree);
5784 extern void fixup_anonymous_aggr (tree);
5785 extern tree compute_array_index_type (tree, tree, tsubst_flags_t);
5786 extern tree check_default_argument (tree, tree, tsubst_flags_t);
5787 typedef int (*walk_namespaces_fn) (tree, void *);
5788 extern int walk_namespaces (walk_namespaces_fn,
5789 void *);
5790 extern int wrapup_globals_for_namespace (tree, void *);
5791 extern tree create_implicit_typedef (tree, tree);
5792 extern int local_variable_p (const_tree);
5793 extern tree register_dtor_fn (tree);
5794 extern tmpl_spec_kind current_tmpl_spec_kind (int);
5795 extern tree cp_fname_init (const char *, tree *);
5796 extern tree cxx_builtin_function (tree decl);
5797 extern tree cxx_builtin_function_ext_scope (tree decl);
5798 extern tree check_elaborated_type_specifier (enum tag_types, tree, bool);
5799 extern void warn_extern_redeclared_static (tree, tree);
5800 extern tree cxx_comdat_group (tree);
5801 extern bool cp_missing_noreturn_ok_p (tree);
5802 extern void initialize_artificial_var (tree, vec<constructor_elt, va_gc> *);
5803 extern tree check_var_type (tree, tree);
5804 extern tree reshape_init (tree, tree, tsubst_flags_t);
5805 extern tree next_initializable_field (tree);
5806 extern tree fndecl_declared_return_type (tree);
5807 extern bool undeduced_auto_decl (tree);
5808 extern void require_deduced_type (tree);
5809
5810 extern tree finish_case_label (location_t, tree, tree);
5811 extern tree cxx_maybe_build_cleanup (tree, tsubst_flags_t);
5812
5813 /* in decl2.c */
5814 extern void note_mangling_alias (tree, tree);
5815 extern void generate_mangling_aliases (void);
5816 extern bool check_java_method (tree);
5817 extern tree build_memfn_type (tree, tree, cp_cv_quals, cp_ref_qualifier);
5818 extern tree build_pointer_ptrmemfn_type (tree);
5819 extern tree change_return_type (tree, tree);
5820 extern void maybe_retrofit_in_chrg (tree);
5821 extern void maybe_make_one_only (tree);
5822 extern bool vague_linkage_p (tree);
5823 extern void grokclassfn (tree, tree,
5824 enum overload_flags);
5825 extern tree grok_array_decl (location_t, tree, tree, bool);
5826 extern tree delete_sanity (tree, tree, bool, int, tsubst_flags_t);
5827 extern tree check_classfn (tree, tree, tree);
5828 extern void check_member_template (tree);
5829 extern tree grokfield (const cp_declarator *, cp_decl_specifier_seq *,
5830 tree, bool, tree, tree);
5831 extern tree grokbitfield (const cp_declarator *, cp_decl_specifier_seq *,
5832 tree, tree);
5833 extern tree cp_reconstruct_complex_type (tree, tree);
5834 extern bool attributes_naming_typedef_ok (tree);
5835 extern void cplus_decl_attributes (tree *, tree, int);
5836 extern void finish_anon_union (tree);
5837 extern void cxx_post_compilation_parsing_cleanups (void);
5838 extern tree coerce_new_type (tree);
5839 extern tree coerce_delete_type (tree);
5840 extern void comdat_linkage (tree);
5841 extern void determine_visibility (tree);
5842 extern void constrain_class_visibility (tree);
5843 extern void reset_type_linkage (tree);
5844 extern void tentative_decl_linkage (tree);
5845 extern void import_export_decl (tree);
5846 extern tree build_cleanup (tree);
5847 extern tree build_offset_ref_call_from_tree (tree, vec<tree, va_gc> **,
5848 tsubst_flags_t);
5849 extern bool decl_constant_var_p (tree);
5850 extern bool decl_maybe_constant_var_p (tree);
5851 extern void no_linkage_error (tree);
5852 extern void check_default_args (tree);
5853 extern bool mark_used (tree);
5854 extern bool mark_used (tree, tsubst_flags_t);
5855 extern void finish_static_data_member_decl (tree, tree, bool, tree, int);
5856 extern tree cp_build_parm_decl (tree, tree);
5857 extern tree get_guard (tree);
5858 extern tree get_guard_cond (tree, bool);
5859 extern tree set_guard (tree);
5860 extern tree get_tls_wrapper_fn (tree);
5861 extern void mark_needed (tree);
5862 extern bool decl_needed_p (tree);
5863 extern void note_vague_linkage_fn (tree);
5864 extern void note_variable_template_instantiation (tree);
5865 extern tree build_artificial_parm (tree, tree);
5866 extern bool possibly_inlined_p (tree);
5867 extern int parm_index (tree);
5868 extern tree vtv_start_verification_constructor_init_function (void);
5869 extern tree vtv_finish_verification_constructor_init_function (tree);
5870 extern bool cp_omp_mappable_type (tree);
5871
5872 /* in error.c */
5873 extern const char *type_as_string (tree, int);
5874 extern const char *type_as_string_translate (tree, int);
5875 extern const char *decl_as_string (tree, int);
5876 extern const char *decl_as_string_translate (tree, int);
5877 extern const char *decl_as_dwarf_string (tree, int);
5878 extern const char *expr_as_string (tree, int);
5879 extern const char *lang_decl_name (tree, int, bool);
5880 extern const char *lang_decl_dwarf_name (tree, int, bool);
5881 extern const char *language_to_string (enum languages);
5882 extern const char *class_key_or_enum_as_string (tree);
5883 extern void maybe_warn_variadic_templates (void);
5884 extern void maybe_warn_cpp0x (cpp0x_warn_str str);
5885 extern bool pedwarn_cxx98 (location_t, int, const char *, ...) ATTRIBUTE_GCC_DIAG(3,4);
5886 extern location_t location_of (tree);
5887 extern void qualified_name_lookup_error (tree, tree, tree,
5888 location_t);
5889
5890 /* in except.c */
5891 extern void init_exception_processing (void);
5892 extern tree expand_start_catch_block (tree);
5893 extern void expand_end_catch_block (void);
5894 extern tree build_exc_ptr (void);
5895 extern tree build_throw (tree);
5896 extern int nothrow_libfn_p (const_tree);
5897 extern void check_handlers (tree);
5898 extern tree finish_noexcept_expr (tree, tsubst_flags_t);
5899 extern bool expr_noexcept_p (tree, tsubst_flags_t);
5900 extern void perform_deferred_noexcept_checks (void);
5901 extern bool nothrow_spec_p (const_tree);
5902 extern bool type_noexcept_p (const_tree);
5903 extern bool type_throw_all_p (const_tree);
5904 extern tree build_noexcept_spec (tree, int);
5905 extern void choose_personality_routine (enum languages);
5906 extern tree build_must_not_throw_expr (tree,tree);
5907 extern tree eh_type_info (tree);
5908 extern tree begin_eh_spec_block (void);
5909 extern void finish_eh_spec_block (tree, tree);
5910 extern tree build_eh_type_type (tree);
5911 extern tree cp_protect_cleanup_actions (void);
5912 extern tree create_try_catch_expr (tree, tree);
5913
5914 /* in expr.c */
5915 extern tree cplus_expand_constant (tree);
5916 extern tree mark_rvalue_use (tree,
5917 location_t = UNKNOWN_LOCATION,
5918 bool = true);
5919 extern tree mark_lvalue_use (tree);
5920 extern tree mark_type_use (tree);
5921 extern void mark_exp_read (tree);
5922
5923 /* friend.c */
5924 extern int is_friend (tree, tree);
5925 extern void make_friend_class (tree, tree, bool);
5926 extern void add_friend (tree, tree, bool);
5927 extern tree do_friend (tree, tree, tree, tree, enum overload_flags, bool);
5928
5929 /* in init.c */
5930 extern tree expand_member_init (tree);
5931 extern void emit_mem_initializers (tree);
5932 extern tree build_aggr_init (tree, tree, int,
5933 tsubst_flags_t);
5934 extern int is_class_type (tree, int);
5935 extern tree get_type_value (tree);
5936 extern tree build_zero_init (tree, tree, bool);
5937 extern tree build_value_init (tree, tsubst_flags_t);
5938 extern tree build_value_init_noctor (tree, tsubst_flags_t);
5939 extern tree get_nsdmi (tree, bool);
5940 extern tree build_offset_ref (tree, tree, bool,
5941 tsubst_flags_t);
5942 extern tree throw_bad_array_new_length (void);
5943 extern tree build_new (vec<tree, va_gc> **, tree, tree,
5944 vec<tree, va_gc> **, int,
5945 tsubst_flags_t);
5946 extern tree get_temp_regvar (tree, tree);
5947 extern tree build_vec_init (tree, tree, tree, bool, int,
5948 tsubst_flags_t);
5949 extern tree build_delete (tree, tree,
5950 special_function_kind,
5951 int, int, tsubst_flags_t);
5952 extern void push_base_cleanups (void);
5953 extern tree build_vec_delete (tree, tree,
5954 special_function_kind, int,
5955 tsubst_flags_t);
5956 extern tree create_temporary_var (tree);
5957 extern void initialize_vtbl_ptrs (tree);
5958 extern tree build_java_class_ref (tree);
5959 extern tree scalar_constant_value (tree);
5960 extern tree decl_really_constant_value (tree);
5961 extern int diagnose_uninitialized_cst_or_ref_member (tree, bool, bool);
5962 extern tree build_vtbl_address (tree);
5963
5964 /* in lex.c */
5965 extern void cxx_dup_lang_specific_decl (tree);
5966 extern void yyungetc (int, int);
5967
5968 extern tree unqualified_name_lookup_error (tree);
5969 extern tree unqualified_fn_lookup_error (tree);
5970 extern tree build_lang_decl (enum tree_code, tree, tree);
5971 extern tree build_lang_decl_loc (location_t, enum tree_code, tree, tree);
5972 extern void retrofit_lang_decl (tree);
5973 extern tree copy_decl (tree);
5974 extern tree copy_type (tree);
5975 extern tree cxx_make_type (enum tree_code);
5976 extern tree make_class_type (enum tree_code);
5977 extern bool cxx_init (void);
5978 extern void cxx_finish (void);
5979 extern bool in_main_input_context (void);
5980
5981 /* in method.c */
5982 extern void init_method (void);
5983 extern tree make_thunk (tree, bool, tree, tree);
5984 extern void finish_thunk (tree);
5985 extern void use_thunk (tree, bool);
5986 extern bool trivial_fn_p (tree);
5987 extern tree forward_parm (tree);
5988 extern bool is_trivially_xible (enum tree_code, tree, tree);
5989 extern tree get_defaulted_eh_spec (tree);
5990 extern tree unevaluated_noexcept_spec (void);
5991 extern void after_nsdmi_defaulted_late_checks (tree);
5992 extern bool maybe_explain_implicit_delete (tree);
5993 extern void explain_implicit_non_constexpr (tree);
5994 extern void deduce_inheriting_ctor (tree);
5995 extern void synthesize_method (tree);
5996 extern tree lazily_declare_fn (special_function_kind,
5997 tree);
5998 extern tree skip_artificial_parms_for (const_tree, tree);
5999 extern int num_artificial_parms_for (const_tree);
6000 extern tree make_alias_for (tree, tree);
6001 extern tree get_copy_ctor (tree, tsubst_flags_t);
6002 extern tree get_copy_assign (tree);
6003 extern tree get_default_ctor (tree);
6004 extern tree get_dtor (tree, tsubst_flags_t);
6005 extern tree get_inherited_ctor (tree);
6006 extern tree locate_ctor (tree);
6007 extern tree implicitly_declare_fn (special_function_kind, tree,
6008 bool, tree, tree);
6009
6010 /* In optimize.c */
6011 extern bool maybe_clone_body (tree);
6012
6013 /* In parser.c */
6014 extern tree cp_convert_range_for (tree, tree, tree, bool);
6015 extern bool parsing_nsdmi (void);
6016 extern void inject_this_parameter (tree, cp_cv_quals);
6017
6018 /* in pt.c */
6019 extern bool check_template_shadow (tree);
6020 extern tree get_innermost_template_args (tree, int);
6021 extern void maybe_begin_member_template_processing (tree);
6022 extern void maybe_end_member_template_processing (void);
6023 extern tree finish_member_template_decl (tree);
6024 extern void begin_template_parm_list (void);
6025 extern bool begin_specialization (void);
6026 extern void reset_specialization (void);
6027 extern void end_specialization (void);
6028 extern void begin_explicit_instantiation (void);
6029 extern void end_explicit_instantiation (void);
6030 extern tree check_explicit_specialization (tree, tree, int, int);
6031 extern int num_template_headers_for_class (tree);
6032 extern void check_template_variable (tree);
6033 extern tree make_auto (void);
6034 extern tree make_decltype_auto (void);
6035 extern tree do_auto_deduction (tree, tree, tree);
6036 extern tree do_auto_deduction (tree, tree, tree,
6037 tsubst_flags_t,
6038 auto_deduction_context);
6039 extern tree type_uses_auto (tree);
6040 extern tree type_uses_auto_or_concept (tree);
6041 extern void append_type_to_template_for_access_check (tree, tree, tree,
6042 location_t);
6043 extern tree convert_generic_types_to_packs (tree, int, int);
6044 extern tree splice_late_return_type (tree, tree);
6045 extern bool is_auto (const_tree);
6046 extern bool is_auto_or_concept (const_tree);
6047 extern tree process_template_parm (tree, location_t, tree,
6048 bool, bool);
6049 extern tree end_template_parm_list (tree);
6050 extern void end_template_parm_list (void);
6051 extern void end_template_decl (void);
6052 extern tree maybe_update_decl_type (tree, tree);
6053 extern bool check_default_tmpl_args (tree, tree, bool, bool, int);
6054 extern tree push_template_decl (tree);
6055 extern tree push_template_decl_real (tree, bool);
6056 extern tree add_inherited_template_parms (tree, tree);
6057 extern bool redeclare_class_template (tree, tree, tree);
6058 extern tree lookup_template_class (tree, tree, tree, tree,
6059 int, tsubst_flags_t);
6060 extern tree lookup_template_function (tree, tree);
6061 extern tree lookup_template_variable (tree, tree);
6062 extern int uses_template_parms (tree);
6063 extern bool uses_template_parms_level (tree, int);
6064 extern bool in_template_function (void);
6065 extern tree instantiate_class_template (tree);
6066 extern tree instantiate_template (tree, tree, tsubst_flags_t);
6067 extern tree fn_type_unification (tree, tree, tree,
6068 const tree *, unsigned int,
6069 tree, unification_kind_t, int,
6070 bool, bool);
6071 extern void mark_decl_instantiated (tree, int);
6072 extern int more_specialized_fn (tree, tree, int);
6073 extern void do_decl_instantiation (tree, tree);
6074 extern void do_type_instantiation (tree, tree, tsubst_flags_t);
6075 extern bool always_instantiate_p (tree);
6076 extern void maybe_instantiate_noexcept (tree);
6077 extern tree instantiate_decl (tree, int, bool);
6078 extern int comp_template_parms (const_tree, const_tree);
6079 extern bool uses_parameter_packs (tree);
6080 extern bool template_parameter_pack_p (const_tree);
6081 extern bool function_parameter_pack_p (const_tree);
6082 extern bool function_parameter_expanded_from_pack_p (tree, tree);
6083 extern tree make_pack_expansion (tree);
6084 extern bool check_for_bare_parameter_packs (tree);
6085 extern tree build_template_info (tree, tree);
6086 extern tree get_template_info (const_tree);
6087 extern vec<qualified_typedef_usage_t, va_gc> *get_types_needing_access_check (tree);
6088 extern int template_class_depth (tree);
6089 extern int is_specialization_of (tree, tree);
6090 extern bool is_specialization_of_friend (tree, tree);
6091 extern tree get_pattern_parm (tree, tree);
6092 extern int comp_template_args (tree, tree, tree * = NULL,
6093 tree * = NULL);
6094 extern int template_args_equal (tree, tree);
6095 extern tree maybe_process_partial_specialization (tree);
6096 extern tree most_specialized_instantiation (tree);
6097 extern void print_candidates (tree);
6098 extern void instantiate_pending_templates (int);
6099 extern tree tsubst_default_argument (tree, tree, tree,
6100 tsubst_flags_t);
6101 extern tree tsubst (tree, tree, tsubst_flags_t, tree);
6102 extern tree tsubst_copy_and_build (tree, tree, tsubst_flags_t,
6103 tree, bool, bool);
6104 extern tree tsubst_expr (tree, tree, tsubst_flags_t,
6105 tree, bool);
6106 extern tree tsubst_pack_expansion (tree, tree, tsubst_flags_t, tree);
6107 extern tree most_general_template (tree);
6108 extern tree get_mostly_instantiated_function_type (tree);
6109 extern bool problematic_instantiation_changed (void);
6110 extern void record_last_problematic_instantiation (void);
6111 extern struct tinst_level *current_instantiation(void);
6112 extern bool instantiating_current_function_p (void);
6113 extern tree maybe_get_template_decl_from_type_decl (tree);
6114 extern int processing_template_parmlist;
6115 extern bool dependent_type_p (tree);
6116 extern bool dependent_scope_p (tree);
6117 extern bool any_dependent_template_arguments_p (const_tree);
6118 extern bool dependent_template_p (tree);
6119 extern bool dependent_template_id_p (tree, tree);
6120 extern bool type_dependent_expression_p (tree);
6121 extern bool any_type_dependent_arguments_p (const vec<tree, va_gc> *);
6122 extern bool any_type_dependent_elements_p (const_tree);
6123 extern bool type_dependent_expression_p_push (tree);
6124 extern bool value_dependent_expression_p (tree);
6125 extern bool instantiation_dependent_expression_p (tree);
6126 extern bool instantiation_dependent_uneval_expression_p (tree);
6127 extern bool any_value_dependent_elements_p (const_tree);
6128 extern bool dependent_omp_for_p (tree, tree, tree, tree);
6129 extern tree resolve_typename_type (tree, bool);
6130 extern tree template_for_substitution (tree);
6131 extern tree build_non_dependent_expr (tree);
6132 extern void make_args_non_dependent (vec<tree, va_gc> *);
6133 extern bool reregister_specialization (tree, tree, tree);
6134 extern tree instantiate_non_dependent_expr (tree);
6135 extern tree instantiate_non_dependent_expr_sfinae (tree, tsubst_flags_t);
6136 extern tree instantiate_non_dependent_expr_internal (tree, tsubst_flags_t);
6137 extern tree instantiate_non_dependent_or_null (tree);
6138 extern bool variable_template_specialization_p (tree);
6139 extern bool alias_type_or_template_p (tree);
6140 extern bool alias_template_specialization_p (const_tree);
6141 extern bool dependent_alias_template_spec_p (const_tree);
6142 extern bool explicit_class_specialization_p (tree);
6143 extern bool push_tinst_level (tree);
6144 extern bool push_tinst_level_loc (tree, location_t);
6145 extern void pop_tinst_level (void);
6146 extern struct tinst_level *outermost_tinst_level(void);
6147 extern void init_template_processing (void);
6148 extern void print_template_statistics (void);
6149 bool template_template_parameter_p (const_tree);
6150 bool template_type_parameter_p (const_tree);
6151 extern bool primary_template_instantiation_p (const_tree);
6152 extern tree get_primary_template_innermost_parameters (const_tree);
6153 extern tree get_template_parms_at_level (tree, int);
6154 extern tree get_template_innermost_arguments (const_tree);
6155 extern tree get_template_argument_pack_elems (const_tree);
6156 extern tree get_function_template_decl (const_tree);
6157 extern tree resolve_nondeduced_context (tree, tsubst_flags_t);
6158 extern hashval_t iterative_hash_template_arg (tree arg, hashval_t val);
6159 extern tree coerce_template_parms (tree, tree, tree);
6160 extern tree coerce_template_parms (tree, tree, tree, tsubst_flags_t);
6161 extern void register_local_specialization (tree, tree);
6162 extern tree retrieve_local_specialization (tree);
6163 extern tree extract_fnparm_pack (tree, tree *);
6164 extern tree template_parm_to_arg (tree);
6165
6166 /* in repo.c */
6167 extern void init_repo (void);
6168 extern int repo_emit_p (tree);
6169 extern bool repo_export_class_p (const_tree);
6170 extern void finish_repo (void);
6171
6172 /* in rtti.c */
6173 /* A vector of all tinfo decls that haven't been emitted yet. */
6174 extern GTY(()) vec<tree, va_gc> *unemitted_tinfo_decls;
6175
6176 extern void init_rtti_processing (void);
6177 extern tree build_typeid (tree, tsubst_flags_t);
6178 extern tree get_tinfo_decl (tree);
6179 extern tree get_typeid (tree, tsubst_flags_t);
6180 extern tree build_headof (tree);
6181 extern tree build_dynamic_cast (tree, tree, tsubst_flags_t);
6182 extern void emit_support_tinfos (void);
6183 extern bool emit_tinfo_decl (tree);
6184
6185 /* in search.c */
6186 extern bool accessible_base_p (tree, tree, bool);
6187 extern tree lookup_base (tree, tree, base_access,
6188 base_kind *, tsubst_flags_t);
6189 extern tree dcast_base_hint (tree, tree);
6190 extern int accessible_p (tree, tree, bool);
6191 extern int accessible_in_template_p (tree, tree);
6192 extern tree lookup_field_1 (tree, tree, bool);
6193 extern tree lookup_field (tree, tree, int, bool);
6194 extern int lookup_fnfields_1 (tree, tree);
6195 extern tree lookup_fnfields_slot (tree, tree);
6196 extern tree lookup_fnfields_slot_nolazy (tree, tree);
6197 extern int class_method_index_for_fn (tree, tree);
6198 extern tree lookup_fnfields (tree, tree, int);
6199 extern tree lookup_member (tree, tree, int, bool,
6200 tsubst_flags_t);
6201 extern tree lookup_member_fuzzy (tree, tree, bool);
6202 extern int look_for_overrides (tree, tree);
6203 extern void get_pure_virtuals (tree);
6204 extern void maybe_suppress_debug_info (tree);
6205 extern void note_debug_info_needed (tree);
6206 extern void print_search_statistics (void);
6207 extern void reinit_search_statistics (void);
6208 extern tree current_scope (void);
6209 extern int at_function_scope_p (void);
6210 extern bool at_class_scope_p (void);
6211 extern bool at_namespace_scope_p (void);
6212 extern tree context_for_name_lookup (tree);
6213 extern tree lookup_conversions (tree);
6214 extern tree binfo_from_vbase (tree);
6215 extern tree binfo_for_vbase (tree, tree);
6216 extern tree look_for_overrides_here (tree, tree);
6217 #define dfs_skip_bases ((tree)1)
6218 extern tree dfs_walk_all (tree, tree (*) (tree, void *),
6219 tree (*) (tree, void *), void *);
6220 extern tree dfs_walk_once (tree, tree (*) (tree, void *),
6221 tree (*) (tree, void *), void *);
6222 extern tree binfo_via_virtual (tree, tree);
6223 extern tree build_baselink (tree, tree, tree, tree);
6224 extern tree adjust_result_of_qualified_name_lookup
6225 (tree, tree, tree);
6226 extern tree copied_binfo (tree, tree);
6227 extern tree original_binfo (tree, tree);
6228 extern int shared_member_p (tree);
6229
6230 /* The representation of a deferred access check. */
6231
6232 struct GTY(()) deferred_access_check {
6233 /* The base class in which the declaration is referenced. */
6234 tree binfo;
6235 /* The declaration whose access must be checked. */
6236 tree decl;
6237 /* The declaration that should be used in the error message. */
6238 tree diag_decl;
6239 /* The location of this access. */
6240 location_t loc;
6241 };
6242
6243 /* in semantics.c */
6244 extern void push_deferring_access_checks (deferring_kind);
6245 extern void resume_deferring_access_checks (void);
6246 extern void stop_deferring_access_checks (void);
6247 extern void pop_deferring_access_checks (void);
6248 extern vec<deferred_access_check, va_gc> *get_deferred_access_checks (void);
6249 extern void reopen_deferring_access_checks (vec<deferred_access_check, va_gc> *);
6250 extern void pop_to_parent_deferring_access_checks (void);
6251 extern bool perform_access_checks (vec<deferred_access_check, va_gc> *,
6252 tsubst_flags_t);
6253 extern bool perform_deferred_access_checks (tsubst_flags_t);
6254 extern bool perform_or_defer_access_check (tree, tree, tree,
6255 tsubst_flags_t);
6256
6257 /* RAII sentinel to ensures that deferred access checks are popped before
6258 a function returns. */
6259
6260 struct deferring_access_check_sentinel
6261 {
deferring_access_check_sentineldeferring_access_check_sentinel6262 deferring_access_check_sentinel ()
6263 {
6264 push_deferring_access_checks (dk_deferred);
6265 }
~deferring_access_check_sentineldeferring_access_check_sentinel6266 ~deferring_access_check_sentinel ()
6267 {
6268 pop_deferring_access_checks ();
6269 }
6270 };
6271
6272 extern int stmts_are_full_exprs_p (void);
6273 extern void init_cp_semantics (void);
6274 extern tree do_poplevel (tree);
6275 extern void break_maybe_infinite_loop (void);
6276 extern void add_decl_expr (tree);
6277 extern tree maybe_cleanup_point_expr_void (tree);
6278 extern tree finish_expr_stmt (tree);
6279 extern tree begin_if_stmt (void);
6280 extern void finish_if_stmt_cond (tree, tree);
6281 extern tree finish_then_clause (tree);
6282 extern void begin_else_clause (tree);
6283 extern void finish_else_clause (tree);
6284 extern void finish_if_stmt (tree);
6285 extern tree begin_while_stmt (void);
6286 extern void finish_while_stmt_cond (tree, tree, bool);
6287 extern void finish_while_stmt (tree);
6288 extern tree begin_do_stmt (void);
6289 extern void finish_do_body (tree);
6290 extern void finish_do_stmt (tree, tree, bool);
6291 extern tree finish_return_stmt (tree);
6292 extern tree begin_for_scope (tree *);
6293 extern tree begin_for_stmt (tree, tree);
6294 extern void finish_for_init_stmt (tree);
6295 extern void finish_for_cond (tree, tree, bool);
6296 extern void finish_for_expr (tree, tree);
6297 extern void finish_for_stmt (tree);
6298 extern tree begin_range_for_stmt (tree, tree);
6299 extern void finish_range_for_decl (tree, tree, tree);
6300 extern void finish_range_for_stmt (tree);
6301 extern tree finish_break_stmt (void);
6302 extern tree finish_continue_stmt (void);
6303 extern tree begin_switch_stmt (void);
6304 extern void finish_switch_cond (tree, tree);
6305 extern void finish_switch_stmt (tree);
6306 extern tree finish_goto_stmt (tree);
6307 extern tree begin_try_block (void);
6308 extern void finish_try_block (tree);
6309 extern void finish_handler_sequence (tree);
6310 extern tree begin_function_try_block (tree *);
6311 extern void finish_function_try_block (tree);
6312 extern void finish_function_handler_sequence (tree, tree);
6313 extern void finish_cleanup_try_block (tree);
6314 extern tree begin_handler (void);
6315 extern void finish_handler_parms (tree, tree);
6316 extern void finish_handler (tree);
6317 extern void finish_cleanup (tree, tree);
6318 extern bool is_this_parameter (tree);
6319
6320 enum {
6321 BCS_NORMAL = 0,
6322 BCS_NO_SCOPE = 1,
6323 BCS_TRY_BLOCK = 2,
6324 BCS_FN_BODY = 4,
6325 BCS_TRANSACTION = 8
6326 };
6327 extern tree begin_compound_stmt (unsigned int);
6328
6329 extern void finish_compound_stmt (tree);
6330 extern tree finish_asm_stmt (int, tree, tree, tree, tree,
6331 tree);
6332 extern tree finish_label_stmt (tree);
6333 extern void finish_label_decl (tree);
6334 extern cp_expr finish_parenthesized_expr (cp_expr);
6335 extern tree force_paren_expr (tree);
6336 extern tree maybe_undo_parenthesized_ref (tree);
6337 extern tree finish_non_static_data_member (tree, tree, tree);
6338 extern tree begin_stmt_expr (void);
6339 extern tree finish_stmt_expr_expr (tree, tree);
6340 extern tree finish_stmt_expr (tree, bool);
6341 extern tree stmt_expr_value_expr (tree);
6342 bool empty_expr_stmt_p (tree);
6343 extern cp_expr perform_koenig_lookup (cp_expr, vec<tree, va_gc> *,
6344 tsubst_flags_t);
6345 extern tree finish_call_expr (tree, vec<tree, va_gc> **, bool,
6346 bool, tsubst_flags_t);
6347 extern tree finish_template_variable (tree, tsubst_flags_t = tf_warning_or_error);
6348 extern cp_expr finish_increment_expr (cp_expr, enum tree_code);
6349 extern tree finish_this_expr (void);
6350 extern tree finish_pseudo_destructor_expr (tree, tree, tree, location_t);
6351 extern cp_expr finish_unary_op_expr (location_t, enum tree_code, cp_expr,
6352 tsubst_flags_t);
6353 extern tree finish_compound_literal (tree, tree, tsubst_flags_t);
6354 extern tree finish_fname (tree);
6355 extern void finish_translation_unit (void);
6356 extern tree finish_template_type_parm (tree, tree);
6357 extern tree finish_template_template_parm (tree, tree);
6358 extern tree begin_class_definition (tree);
6359 extern void finish_template_decl (tree);
6360 extern tree finish_template_type (tree, tree, int);
6361 extern tree finish_base_specifier (tree, tree, bool);
6362 extern void finish_member_declaration (tree);
6363 extern bool outer_automatic_var_p (tree);
6364 extern tree process_outer_var_ref (tree, tsubst_flags_t);
6365 extern cp_expr finish_id_expression (tree, tree, tree,
6366 cp_id_kind *,
6367 bool, bool, bool *,
6368 bool, bool, bool, bool,
6369 const char **,
6370 location_t);
6371 extern tree finish_typeof (tree);
6372 extern tree finish_underlying_type (tree);
6373 extern tree calculate_bases (tree);
6374 extern tree finish_bases (tree, bool);
6375 extern tree calculate_direct_bases (tree);
6376 extern tree finish_offsetof (tree, location_t);
6377 extern void finish_decl_cleanup (tree, tree);
6378 extern void finish_eh_cleanup (tree);
6379 extern void emit_associated_thunks (tree);
6380 extern void finish_mem_initializers (tree);
6381 extern tree check_template_template_default_arg (tree);
6382 extern bool expand_or_defer_fn_1 (tree);
6383 extern void expand_or_defer_fn (tree);
6384 extern void add_typedef_to_current_template_for_access_check (tree, tree,
6385 location_t);
6386 extern void check_accessibility_of_qualified_id (tree, tree, tree);
6387 extern tree finish_qualified_id_expr (tree, tree, bool, bool,
6388 bool, bool, tsubst_flags_t);
6389 extern void simplify_aggr_init_expr (tree *);
6390 extern void finalize_nrv (tree *, tree, tree);
6391 extern tree omp_reduction_id (enum tree_code, tree, tree);
6392 extern tree cp_remove_omp_priv_cleanup_stmt (tree *, int *, void *);
6393 extern void cp_check_omp_declare_reduction (tree);
6394 extern void finish_omp_declare_simd_methods (tree);
6395 extern tree finish_omp_clauses (tree, bool, bool = false);
6396 extern tree push_omp_privatization_clauses (bool);
6397 extern void pop_omp_privatization_clauses (tree);
6398 extern void save_omp_privatization_clauses (vec<tree> &);
6399 extern void restore_omp_privatization_clauses (vec<tree> &);
6400 extern void finish_omp_threadprivate (tree);
6401 extern tree begin_omp_structured_block (void);
6402 extern tree finish_omp_structured_block (tree);
6403 extern tree finish_oacc_data (tree, tree);
6404 extern tree finish_oacc_host_data (tree, tree);
6405 extern tree finish_omp_construct (enum tree_code, tree, tree);
6406 extern tree begin_omp_parallel (void);
6407 extern tree finish_omp_parallel (tree, tree);
6408 extern tree begin_omp_task (void);
6409 extern tree finish_omp_task (tree, tree);
6410 extern tree finish_omp_for (location_t, enum tree_code,
6411 tree, tree, tree, tree, tree,
6412 tree, tree, vec<tree> *, tree);
6413 extern void finish_omp_atomic (enum tree_code, enum tree_code,
6414 tree, tree, tree, tree, tree,
6415 bool);
6416 extern void finish_omp_barrier (void);
6417 extern void finish_omp_flush (void);
6418 extern void finish_omp_taskwait (void);
6419 extern void finish_omp_taskyield (void);
6420 extern void finish_omp_cancel (tree);
6421 extern void finish_omp_cancellation_point (tree);
6422 extern tree omp_privatize_field (tree, bool);
6423 extern tree begin_transaction_stmt (location_t, tree *, int);
6424 extern void finish_transaction_stmt (tree, tree, int, tree);
6425 extern tree build_transaction_expr (location_t, tree, int, tree);
6426 extern bool cxx_omp_create_clause_info (tree, tree, bool, bool,
6427 bool, bool);
6428 extern tree baselink_for_fns (tree);
6429 extern void finish_static_assert (tree, tree, location_t,
6430 bool);
6431 extern tree finish_decltype_type (tree, bool, tsubst_flags_t);
6432 extern tree finish_trait_expr (enum cp_trait_kind, tree, tree);
6433 extern tree build_lambda_expr (void);
6434 extern tree build_lambda_object (tree);
6435 extern tree begin_lambda_type (tree);
6436 extern tree lambda_capture_field_type (tree, bool);
6437 extern tree lambda_return_type (tree);
6438 extern tree lambda_proxy_type (tree);
6439 extern tree lambda_function (tree);
6440 extern void apply_deduced_return_type (tree, tree);
6441 extern tree add_capture (tree, tree, tree, bool, bool);
6442 extern tree add_default_capture (tree, tree, tree);
6443 extern tree build_capture_proxy (tree);
6444 extern void insert_capture_proxy (tree);
6445 extern void insert_pending_capture_proxies (void);
6446 extern bool is_capture_proxy (tree);
6447 extern bool is_normal_capture_proxy (tree);
6448 extern void register_capture_members (tree);
6449 extern tree lambda_expr_this_capture (tree, bool);
6450 extern void maybe_generic_this_capture (tree, tree);
6451 extern tree maybe_resolve_dummy (tree, bool);
6452 extern tree current_nonlambda_function (void);
6453 extern tree nonlambda_method_basetype (void);
6454 extern tree current_nonlambda_scope (void);
6455 extern bool generic_lambda_fn_p (tree);
6456 extern void maybe_add_lambda_conv_op (tree);
6457 extern bool is_lambda_ignored_entity (tree);
6458
6459 /* in tree.c */
6460 extern int cp_tree_operand_length (const_tree);
6461 extern int cp_tree_code_length (enum tree_code);
6462 void cp_free_lang_data (tree t);
6463 extern tree force_target_expr (tree, tree, tsubst_flags_t);
6464 extern tree build_target_expr_with_type (tree, tree, tsubst_flags_t);
6465 extern void lang_check_failed (const char *, int,
6466 const char *) ATTRIBUTE_NORETURN;
6467 extern tree stabilize_expr (tree, tree *);
6468 extern void stabilize_call (tree, tree *);
6469 extern bool stabilize_init (tree, tree *);
6470 extern tree add_stmt_to_compound (tree, tree);
6471 extern void init_tree (void);
6472 extern bool pod_type_p (const_tree);
6473 extern bool layout_pod_type_p (const_tree);
6474 extern bool std_layout_type_p (const_tree);
6475 extern bool trivial_type_p (const_tree);
6476 extern bool trivially_copyable_p (const_tree);
6477 extern bool scalarish_type_p (const_tree);
6478 extern bool type_has_nontrivial_default_init (const_tree);
6479 extern bool type_has_nontrivial_copy_init (const_tree);
6480 extern bool class_tmpl_impl_spec_p (const_tree);
6481 extern int zero_init_p (const_tree);
6482 extern bool check_abi_tag_redeclaration (const_tree, const_tree, const_tree);
6483 extern bool check_abi_tag_args (tree, tree);
6484 extern tree strip_typedefs (tree, bool * = NULL);
6485 extern tree strip_typedefs_expr (tree, bool * = NULL);
6486 extern tree copy_binfo (tree, tree, tree,
6487 tree *, int);
6488 extern int member_p (const_tree);
6489 extern cp_lvalue_kind real_lvalue_p (const_tree);
6490 extern cp_lvalue_kind lvalue_kind (const_tree);
6491 extern bool lvalue_or_rvalue_with_address_p (const_tree);
6492 extern bool xvalue_p (const_tree);
6493 extern bool builtin_valid_in_constant_expr_p (const_tree);
6494 extern tree build_min (enum tree_code, tree, ...);
6495 extern tree build_min_nt_loc (location_t, enum tree_code,
6496 ...);
6497 extern tree build_min_non_dep (enum tree_code, tree, ...);
6498 extern tree build_min_non_dep_op_overload (enum tree_code, tree, tree, ...);
6499 extern tree build_min_non_dep_call_vec (tree, tree, vec<tree, va_gc> *);
6500 extern tree build_cplus_new (tree, tree, tsubst_flags_t);
6501 extern tree build_aggr_init_expr (tree, tree);
6502 extern tree get_target_expr (tree);
6503 extern tree get_target_expr_sfinae (tree, tsubst_flags_t);
6504 extern tree build_cplus_array_type (tree, tree);
6505 extern tree build_array_of_n_type (tree, int);
6506 extern bool array_of_runtime_bound_p (tree);
6507 extern tree build_array_copy (tree);
6508 extern tree build_vec_init_expr (tree, tree, tsubst_flags_t);
6509 extern void diagnose_non_constexpr_vec_init (tree);
6510 extern tree hash_tree_cons (tree, tree, tree);
6511 extern tree hash_tree_chain (tree, tree);
6512 extern tree build_qualified_name (tree, tree, tree, bool);
6513 extern tree build_ref_qualified_type (tree, cp_ref_qualifier);
6514 extern int is_overloaded_fn (tree);
6515 extern tree dependent_name (tree);
6516 extern tree get_fns (tree);
6517 extern tree get_first_fn (tree);
6518 extern tree ovl_cons (tree, tree);
6519 extern tree build_overload (tree, tree);
6520 extern tree ovl_scope (tree);
6521 extern bool non_static_member_function_p (tree);
6522 extern const char *cxx_printable_name (tree, int);
6523 extern const char *cxx_printable_name_translate (tree, int);
6524 extern tree build_exception_variant (tree, tree);
6525 extern tree bind_template_template_parm (tree, tree);
6526 extern tree array_type_nelts_total (tree);
6527 extern tree array_type_nelts_top (tree);
6528 extern tree break_out_target_exprs (tree);
6529 extern tree build_ctor_subob_ref (tree, tree, tree);
6530 extern tree replace_placeholders (tree, tree);
6531 extern tree get_type_decl (tree);
6532 extern tree decl_namespace_context (tree);
6533 extern bool decl_anon_ns_mem_p (const_tree);
6534 extern tree lvalue_type (tree);
6535 extern tree error_type (tree);
6536 extern int varargs_function_p (const_tree);
6537 extern bool really_overloaded_fn (tree);
6538 extern bool cp_tree_equal (tree, tree);
6539 extern tree no_linkage_check (tree, bool);
6540 extern void debug_binfo (tree);
6541 extern tree build_dummy_object (tree);
6542 extern tree maybe_dummy_object (tree, tree *);
6543 extern int is_dummy_object (const_tree);
6544 extern const struct attribute_spec cxx_attribute_table[];
6545 extern tree make_ptrmem_cst (tree, tree);
6546 extern tree cp_build_type_attribute_variant (tree, tree);
6547 extern tree cp_build_reference_type (tree, bool);
6548 extern tree move (tree);
6549 extern tree cp_build_qualified_type_real (tree, int, tsubst_flags_t);
6550 #define cp_build_qualified_type(TYPE, QUALS) \
6551 cp_build_qualified_type_real ((TYPE), (QUALS), tf_warning_or_error)
6552 extern bool cv_qualified_p (const_tree);
6553 extern tree cv_unqualified (tree);
6554 extern special_function_kind special_function_p (const_tree);
6555 extern int count_trees (tree);
6556 extern int char_type_p (tree);
6557 extern void verify_stmt_tree (tree);
6558 extern linkage_kind decl_linkage (tree);
6559 extern duration_kind decl_storage_duration (tree);
6560 extern tree cp_walk_subtrees (tree*, int*, walk_tree_fn,
6561 void*, hash_set<tree> *);
6562 #define cp_walk_tree(tp,func,data,pset) \
6563 walk_tree_1 (tp, func, data, pset, cp_walk_subtrees)
6564 #define cp_walk_tree_without_duplicates(tp,func,data) \
6565 walk_tree_without_duplicates_1 (tp, func, data, cp_walk_subtrees)
6566 extern tree rvalue (tree);
6567 extern tree convert_bitfield_to_declared_type (tree);
6568 extern tree cp_save_expr (tree);
6569 extern bool cast_valid_in_integral_constant_expression_p (tree);
6570 extern bool cxx_type_hash_eq (const_tree, const_tree);
6571
6572 extern void cxx_print_statistics (void);
6573 extern bool maybe_warn_zero_as_null_pointer_constant (tree, location_t);
6574
6575 /* in ptree.c */
6576 extern void cxx_print_xnode (FILE *, tree, int);
6577 extern void cxx_print_decl (FILE *, tree, int);
6578 extern void cxx_print_type (FILE *, tree, int);
6579 extern void cxx_print_identifier (FILE *, tree, int);
6580 extern void cxx_print_error_function (diagnostic_context *,
6581 const char *,
6582 struct diagnostic_info *);
6583
6584 /* in typeck.c */
6585 extern bool cxx_mark_addressable (tree);
6586 extern int string_conv_p (const_tree, const_tree, int);
6587 extern tree cp_truthvalue_conversion (tree);
6588 extern tree condition_conversion (tree);
6589 extern tree require_complete_type (tree);
6590 extern tree require_complete_type_sfinae (tree, tsubst_flags_t);
6591 extern tree complete_type (tree);
6592 extern tree complete_type_or_else (tree, tree);
6593 extern tree complete_type_or_maybe_complain (tree, tree, tsubst_flags_t);
6594 extern int type_unknown_p (const_tree);
6595 enum { ce_derived, ce_normal, ce_exact };
6596 extern bool comp_except_specs (const_tree, const_tree, int);
6597 extern bool comptypes (tree, tree, int);
6598 extern bool same_type_ignoring_top_level_qualifiers_p (tree, tree);
6599 extern bool compparms (const_tree, const_tree);
6600 extern int comp_cv_qualification (const_tree, const_tree);
6601 extern int comp_cv_qualification (int, int);
6602 extern int comp_cv_qual_signature (tree, tree);
6603 extern tree cxx_sizeof_or_alignof_expr (tree, enum tree_code, bool);
6604 extern tree cxx_sizeof_or_alignof_type (tree, enum tree_code, bool);
6605 extern tree cxx_alignas_expr (tree);
6606 extern tree cxx_sizeof_nowarn (tree);
6607 extern tree is_bitfield_expr_with_lowered_type (const_tree);
6608 extern tree unlowered_expr_type (const_tree);
6609 extern tree decay_conversion (tree,
6610 tsubst_flags_t,
6611 bool = true);
6612 extern tree build_class_member_access_expr (cp_expr, tree, tree, bool,
6613 tsubst_flags_t);
6614 extern tree finish_class_member_access_expr (cp_expr, tree, bool,
6615 tsubst_flags_t);
6616 extern tree build_x_indirect_ref (location_t, tree,
6617 ref_operator, tsubst_flags_t);
6618 extern tree cp_build_indirect_ref (tree, ref_operator,
6619 tsubst_flags_t);
6620 extern tree build_array_ref (location_t, tree, tree);
6621 extern tree cp_build_array_ref (location_t, tree, tree,
6622 tsubst_flags_t);
6623 extern tree get_member_function_from_ptrfunc (tree *, tree, tsubst_flags_t);
6624 extern tree cp_build_function_call_nary (tree, tsubst_flags_t, ...)
6625 ATTRIBUTE_SENTINEL;
6626 extern tree cp_build_function_call_vec (tree, vec<tree, va_gc> **,
6627 tsubst_flags_t);
6628 extern tree build_x_binary_op (location_t,
6629 enum tree_code, tree,
6630 enum tree_code, tree,
6631 enum tree_code, tree *,
6632 tsubst_flags_t);
6633 extern tree build_x_array_ref (location_t, tree, tree,
6634 tsubst_flags_t);
6635 extern tree build_x_unary_op (location_t,
6636 enum tree_code, cp_expr,
6637 tsubst_flags_t);
6638 extern tree cp_build_addr_expr (tree, tsubst_flags_t);
6639 extern tree cp_build_unary_op (enum tree_code, tree, int,
6640 tsubst_flags_t);
6641 extern tree unary_complex_lvalue (enum tree_code, tree);
6642 extern tree build_x_conditional_expr (location_t, tree, tree, tree,
6643 tsubst_flags_t);
6644 extern tree build_x_compound_expr_from_list (tree, expr_list_kind,
6645 tsubst_flags_t);
6646 extern tree build_x_compound_expr_from_vec (vec<tree, va_gc> *,
6647 const char *, tsubst_flags_t);
6648 extern tree build_x_compound_expr (location_t, tree, tree,
6649 tsubst_flags_t);
6650 extern tree build_compound_expr (location_t, tree, tree);
6651 extern tree cp_build_compound_expr (tree, tree, tsubst_flags_t);
6652 extern tree build_static_cast (tree, tree, tsubst_flags_t);
6653 extern tree build_reinterpret_cast (tree, tree, tsubst_flags_t);
6654 extern tree build_const_cast (tree, tree, tsubst_flags_t);
6655 extern tree build_c_cast (location_t, tree, tree);
6656 extern cp_expr build_c_cast (location_t loc, tree type,
6657 cp_expr expr);
6658 extern tree cp_build_c_cast (tree, tree, tsubst_flags_t);
6659 extern cp_expr build_x_modify_expr (location_t, tree,
6660 enum tree_code, tree,
6661 tsubst_flags_t);
6662 extern tree cp_build_modify_expr (tree, enum tree_code, tree,
6663 tsubst_flags_t);
6664 extern tree convert_for_initialization (tree, tree, tree, int,
6665 impl_conv_rhs, tree, int,
6666 tsubst_flags_t);
6667 extern int comp_ptr_ttypes (tree, tree);
6668 extern bool comp_ptr_ttypes_const (tree, tree);
6669 extern bool error_type_p (const_tree);
6670 extern bool ptr_reasonably_similar (const_tree, const_tree);
6671 extern tree build_ptrmemfunc (tree, tree, int, bool,
6672 tsubst_flags_t);
6673 extern int cp_type_quals (const_tree);
6674 extern int type_memfn_quals (const_tree);
6675 extern cp_ref_qualifier type_memfn_rqual (const_tree);
6676 extern tree apply_memfn_quals (tree, cp_cv_quals, cp_ref_qualifier);
6677 extern bool cp_has_mutable_p (const_tree);
6678 extern bool at_least_as_qualified_p (const_tree, const_tree);
6679 extern void cp_apply_type_quals_to_decl (int, tree);
6680 extern tree build_ptrmemfunc1 (tree, tree, tree);
6681 extern void expand_ptrmemfunc_cst (tree, tree *, tree *);
6682 extern tree type_after_usual_arithmetic_conversions (tree, tree);
6683 extern tree common_pointer_type (tree, tree);
6684 extern tree composite_pointer_type (tree, tree, tree, tree,
6685 composite_pointer_operation,
6686 tsubst_flags_t);
6687 extern tree merge_types (tree, tree);
6688 extern tree strip_array_domain (tree);
6689 extern tree check_return_expr (tree, bool *);
6690 extern tree cp_build_binary_op (location_t,
6691 enum tree_code, tree, tree,
6692 tsubst_flags_t);
6693 extern tree build_x_vec_perm_expr (location_t,
6694 tree, tree, tree,
6695 tsubst_flags_t);
6696 #define cxx_sizeof(T) cxx_sizeof_or_alignof_type (T, SIZEOF_EXPR, true)
6697 extern tree build_simple_component_ref (tree, tree);
6698 extern tree build_ptrmemfunc_access_expr (tree, tree);
6699 extern tree build_address (tree);
6700 extern tree build_nop (tree, tree);
6701 extern tree non_reference (tree);
6702 extern tree lookup_anon_field (tree, tree);
6703 extern bool invalid_nonstatic_memfn_p (location_t, tree,
6704 tsubst_flags_t);
6705 extern tree convert_member_func_to_ptr (tree, tree, tsubst_flags_t);
6706 extern tree convert_ptrmem (tree, tree, bool, bool,
6707 tsubst_flags_t);
6708 extern int lvalue_or_else (tree, enum lvalue_use,
6709 tsubst_flags_t);
6710 extern void check_template_keyword (tree);
6711 extern bool check_raw_literal_operator (const_tree decl);
6712 extern bool check_literal_operator_args (const_tree, bool *, bool *);
6713 extern void maybe_warn_about_useless_cast (tree, tree, tsubst_flags_t);
6714 extern tree cp_perform_integral_promotions (tree, tsubst_flags_t);
6715
6716 extern tree finish_left_unary_fold_expr (tree, int);
6717 extern tree finish_right_unary_fold_expr (tree, int);
6718 extern tree finish_binary_fold_expr (tree, tree, int);
6719
6720 /* in typeck2.c */
6721 extern void require_complete_eh_spec_types (tree, tree);
6722 extern void cxx_incomplete_type_diagnostic (const_tree, const_tree, diagnostic_t);
6723 #undef cxx_incomplete_type_error
6724 extern void cxx_incomplete_type_error (const_tree, const_tree);
6725 #define cxx_incomplete_type_error(V,T) \
6726 (cxx_incomplete_type_diagnostic ((V), (T), DK_ERROR))
6727 extern void cxx_incomplete_type_inform (const_tree);
6728 extern tree error_not_base_type (tree, tree);
6729 extern tree binfo_or_else (tree, tree);
6730 extern void cxx_readonly_error (tree, enum lvalue_use);
6731 extern void complete_type_check_abstract (tree);
6732 extern int abstract_virtuals_error (tree, tree);
6733 extern int abstract_virtuals_error (abstract_class_use, tree);
6734 extern int abstract_virtuals_error_sfinae (tree, tree, tsubst_flags_t);
6735 extern int abstract_virtuals_error_sfinae (abstract_class_use, tree, tsubst_flags_t);
6736
6737 extern tree store_init_value (tree, tree, vec<tree, va_gc>**, int);
6738 extern tree split_nonconstant_init (tree, tree);
6739 extern bool check_narrowing (tree, tree, tsubst_flags_t);
6740 extern tree digest_init (tree, tree, tsubst_flags_t);
6741 extern tree digest_init_flags (tree, tree, int, tsubst_flags_t);
6742 extern tree digest_nsdmi_init (tree, tree);
6743 extern tree build_scoped_ref (tree, tree, tree *);
6744 extern tree build_x_arrow (location_t, tree,
6745 tsubst_flags_t);
6746 extern tree build_m_component_ref (tree, tree, tsubst_flags_t);
6747 extern tree build_functional_cast (tree, tree, tsubst_flags_t);
6748 extern tree add_exception_specifier (tree, tree, int);
6749 extern tree merge_exception_specifiers (tree, tree);
6750
6751 /* in mangle.c */
6752 extern bool maybe_remove_implicit_alias (tree);
6753 extern void init_mangle (void);
6754 extern void mangle_decl (tree);
6755 extern const char *mangle_type_string (tree);
6756 extern tree mangle_typeinfo_for_type (tree);
6757 extern tree mangle_typeinfo_string_for_type (tree);
6758 extern tree mangle_vtbl_for_type (tree);
6759 extern tree mangle_vtt_for_type (tree);
6760 extern tree mangle_ctor_vtbl_for_type (tree, tree);
6761 extern tree mangle_thunk (tree, int, tree, tree);
6762 extern tree mangle_conv_op_name_for_type (tree);
6763 extern tree mangle_guard_variable (tree);
6764 extern tree mangle_tls_init_fn (tree);
6765 extern tree mangle_tls_wrapper_fn (tree);
6766 extern bool decl_tls_wrapper_p (tree);
6767 extern tree mangle_ref_init_variable (tree);
6768 extern char * get_mangled_vtable_map_var_name (tree);
6769 extern bool mangle_return_type_p (tree);
6770
6771 /* in dump.c */
6772 extern bool cp_dump_tree (void *, tree);
6773
6774 /* In cp/cp-objcp-common.c. */
6775
6776 extern alias_set_type cxx_get_alias_set (tree);
6777 extern bool cxx_warn_unused_global_decl (const_tree);
6778 extern size_t cp_tree_size (enum tree_code);
6779 extern bool cp_var_mod_type_p (tree, tree);
6780 extern void cxx_initialize_diagnostics (diagnostic_context *);
6781 extern int cxx_types_compatible_p (tree, tree);
6782 extern void init_shadowed_var_for_decl (void);
6783 extern bool cxx_block_may_fallthru (const_tree);
6784
6785 /* in cp-gimplify.c */
6786 extern int cp_gimplify_expr (tree *, gimple_seq *,
6787 gimple_seq *);
6788 extern void cp_genericize (tree);
6789 extern bool cxx_omp_const_qual_no_mutable (tree);
6790 extern enum omp_clause_default_kind cxx_omp_predetermined_sharing (tree);
6791 extern tree cxx_omp_clause_default_ctor (tree, tree, tree);
6792 extern tree cxx_omp_clause_copy_ctor (tree, tree, tree);
6793 extern tree cxx_omp_clause_assign_op (tree, tree, tree);
6794 extern tree cxx_omp_clause_dtor (tree, tree);
6795 extern void cxx_omp_finish_clause (tree, gimple_seq *);
6796 extern bool cxx_omp_privatize_by_reference (const_tree);
6797 extern bool cxx_omp_disregard_value_expr (tree, bool);
6798 extern void cp_fold_function (tree);
6799 extern tree cp_fully_fold (tree);
6800 extern void clear_fold_cache (void);
6801
6802 /* in name-lookup.c */
6803 extern void suggest_alternatives_for (location_t, tree);
6804 extern tree strip_using_decl (tree);
6805
6806 /* in constraint.cc */
6807 extern void init_constraint_processing ();
6808 extern bool constraint_p (tree);
6809 extern tree conjoin_constraints (tree, tree);
6810 extern tree conjoin_constraints (tree);
6811 extern tree get_constraints (tree);
6812 extern void set_constraints (tree, tree);
6813 extern void remove_constraints (tree);
6814 extern tree current_template_constraints (void);
6815 extern tree associate_classtype_constraints (tree);
6816 extern tree build_constraints (tree, tree);
6817 extern tree get_shorthand_constraints (tree);
6818 extern tree build_concept_check (tree, tree, tree = NULL_TREE);
6819 extern tree build_constrained_parameter (tree, tree, tree = NULL_TREE);
6820 extern tree make_constrained_auto (tree, tree);
6821 extern void placeholder_extract_concept_and_args (tree, tree&, tree&);
6822 extern bool equivalent_placeholder_constraints (tree, tree);
6823 extern hashval_t hash_placeholder_constraint (tree);
6824 extern bool deduce_constrained_parameter (tree, tree&, tree&);
6825 extern tree resolve_constraint_check (tree);
6826 extern tree check_function_concept (tree);
6827 extern tree finish_template_introduction (tree, tree);
6828 extern bool valid_requirements_p (tree);
6829 extern tree finish_concept_name (tree);
6830 extern tree finish_shorthand_constraint (tree, tree);
6831 extern tree finish_requires_expr (tree, tree);
6832 extern tree finish_simple_requirement (tree);
6833 extern tree finish_type_requirement (tree);
6834 extern tree finish_compound_requirement (tree, tree, bool);
6835 extern tree finish_nested_requirement (tree);
6836 extern void check_constrained_friend (tree, tree);
6837 extern tree tsubst_requires_expr (tree, tree, tsubst_flags_t, tree);
6838 extern tree tsubst_constraint (tree, tree, tsubst_flags_t, tree);
6839 extern tree tsubst_constraint_info (tree, tree, tsubst_flags_t, tree);
6840 extern bool function_concept_check_p (tree);
6841 extern tree normalize_expression (tree);
6842 extern tree expand_concept (tree, tree);
6843 extern bool expanding_concept ();
6844 extern tree evaluate_constraints (tree, tree);
6845 extern tree evaluate_function_concept (tree, tree);
6846 extern tree evaluate_variable_concept (tree, tree);
6847 extern tree evaluate_constraint_expression (tree, tree);
6848 extern bool constraints_satisfied_p (tree);
6849 extern bool constraints_satisfied_p (tree, tree);
6850 extern tree lookup_constraint_satisfaction (tree, tree);
6851 extern tree memoize_constraint_satisfaction (tree, tree, tree);
6852 extern tree lookup_concept_satisfaction (tree, tree);
6853 extern tree memoize_concept_satisfaction (tree, tree, tree);
6854 extern tree get_concept_expansion (tree, tree);
6855 extern tree save_concept_expansion (tree, tree, tree);
6856 extern bool* lookup_subsumption_result (tree, tree);
6857 extern bool save_subsumption_result (tree, tree, bool);
6858
6859 extern bool equivalent_constraints (tree, tree);
6860 extern bool equivalently_constrained (tree, tree);
6861 extern bool subsumes_constraints (tree, tree);
6862 extern bool strictly_subsumes (tree, tree);
6863 extern int more_constrained (tree, tree);
6864
6865 extern void diagnose_constraints (location_t, tree, tree);
6866
6867 /* in logic.cc */
6868 extern tree decompose_conclusions (tree);
6869 extern bool subsumes (tree, tree);
6870
6871 /* in vtable-class-hierarchy.c */
6872 extern void vtv_compute_class_hierarchy_transitive_closure (void);
6873 extern void vtv_generate_init_routine (void);
6874 extern void vtv_save_class_info (tree);
6875 extern void vtv_recover_class_info (void);
6876 extern void vtv_build_vtable_verify_fndecl (void);
6877
6878 /* In cp-cilkplus.c. */
6879 extern bool cpp_validate_cilk_plus_loop (tree);
6880
6881 /* In cp/cp-array-notations.c */
6882 extern tree expand_array_notation_exprs (tree);
6883 bool cilkplus_an_triplet_types_ok_p (location_t, tree, tree, tree,
6884 tree);
6885
6886 /* In constexpr.c */
6887 extern void fini_constexpr (void);
6888 extern bool literal_type_p (tree);
6889 extern tree register_constexpr_fundef (tree, tree);
6890 extern bool check_constexpr_ctor_body (tree, tree, bool);
6891 extern tree ensure_literal_type_for_constexpr_object (tree);
6892 extern bool potential_constant_expression (tree);
6893 extern bool potential_nondependent_constant_expression (tree);
6894 extern bool potential_nondependent_static_init_expression (tree);
6895 extern bool potential_static_init_expression (tree);
6896 extern bool potential_rvalue_constant_expression (tree);
6897 extern bool require_potential_constant_expression (tree);
6898 extern bool require_potential_rvalue_constant_expression (tree);
6899 extern tree cxx_constant_value (tree, tree = NULL_TREE);
6900 extern tree maybe_constant_value (tree, tree = NULL_TREE);
6901 extern tree maybe_constant_init (tree, tree = NULL_TREE);
6902 extern tree fold_non_dependent_expr (tree);
6903 extern tree fold_simple (tree);
6904 extern bool is_sub_constant_expr (tree);
6905 extern bool reduced_constant_expression_p (tree);
6906 extern bool is_instantiation_of_constexpr (tree);
6907 extern bool var_in_constexpr_fn (tree);
6908 extern void explain_invalid_constexpr_fn (tree);
6909 extern vec<tree> cx_error_context (void);
6910 extern tree fold_sizeof_expr (tree);
6911 extern void clear_cv_and_fold_caches (void);
6912
6913 /* In c-family/cilk.c */
6914 extern bool cilk_valid_spawn (tree);
6915
6916 /* In cp-ubsan.c */
6917 extern void cp_ubsan_maybe_instrument_member_call (tree);
6918 extern void cp_ubsan_instrument_member_accesses (tree *);
6919 extern tree cp_ubsan_maybe_instrument_downcast (location_t, tree, tree, tree);
6920 extern tree cp_ubsan_maybe_instrument_cast_to_vbase (location_t, tree, tree);
6921 extern void cp_ubsan_maybe_initialize_vtbl_ptrs (tree);
6922
6923 /* -- end of C++ */
6924
6925 #endif /* ! GCC_CP_TREE_H */
6926