source: arduino-1-6-7/trunk/fuentes/arduino-ide-amd64/hardware/tools/avr/lib/gcc/avr/4.9.2/plugin/include/cp/cp-tree.h @ 4837

Last change on this file since 4837 was 4837, checked in by daduve, 2 years ago

Adding new version

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