OSDN Git Service

f4438165b4bbde622330a5025d9f482422a74e32
[pf3gnuchains/gcc-fork.git] / gcc / cp / cp-tree.h
1 /* Definitions for C++ parsing and type checking.
2    Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4    Free Software Foundation, Inc.
5    Contributed by Michael Tiemann (tiemann@cygnus.com)
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
13
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
22
23 #ifndef GCC_CP_TREE_H
24 #define GCC_CP_TREE_H
25
26 #include "ggc.h"
27 #include "function.h"
28 #include "hashtab.h"
29 #include "vec.h"
30
31 /* In order for the format checking to accept the C++ front end
32    diagnostic framework extensions, you must include this file before
33    diagnostic-core.h, not after.  We override the definition of GCC_DIAG_STYLE
34    in c-common.h.  */
35 #undef GCC_DIAG_STYLE
36 #define GCC_DIAG_STYLE __gcc_cxxdiag__
37 #if defined(GCC_DIAGNOSTIC_CORE_H) || defined (GCC_C_COMMON_H)
38 #error \
39 In order for the format checking to accept the C++ front end diagnostic \
40 framework extensions, you must include this file before diagnostic-core.h and \
41 c-common.h, not after.
42 #endif
43 #include "c-family/c-common.h"
44 #include "diagnostic.h"
45
46 #include "name-lookup.h"
47
48 /* Usage of TREE_LANG_FLAG_?:
49    0: IDENTIFIER_MARKED (IDENTIFIER_NODEs)
50       NEW_EXPR_USE_GLOBAL (in NEW_EXPR).
51       DELETE_EXPR_USE_GLOBAL (in DELETE_EXPR).
52       COMPOUND_EXPR_OVERLOADED (in COMPOUND_EXPR).
53       TREE_INDIRECT_USING (in NAMESPACE_DECL).
54       CLEANUP_P (in TRY_BLOCK)
55       AGGR_INIT_VIA_CTOR_P (in AGGR_INIT_EXPR)
56       PTRMEM_OK_P (in ADDR_EXPR, OFFSET_REF, SCOPE_REF)
57       PAREN_STRING_LITERAL (in STRING_CST)
58       DECL_PRETTY_FUNCTION_P (in VAR_DECL)
59       KOENIG_LOOKUP_P (in CALL_EXPR)
60       STATEMENT_LIST_NO_SCOPE (in STATEMENT_LIST).
61       EXPR_STMT_STMT_EXPR_RESULT (in EXPR_STMT)
62       STMT_EXPR_NO_SCOPE (in STMT_EXPR)
63       BIND_EXPR_TRY_BLOCK (in BIND_EXPR)
64       TYPENAME_IS_ENUM_P (in TYPENAME_TYPE)
65       OMP_FOR_GIMPLIFYING_P (in OMP_FOR)
66       BASELINK_QUALIFIED_P (in BASELINK)
67       TARGET_EXPR_IMPLICIT_P (in TARGET_EXPR)
68       TEMPLATE_PARM_PARAMETER_PACK (in TEMPLATE_PARM_INDEX)
69       ATTR_IS_DEPENDENT (in the TREE_LIST for an attribute)
70       CONSTRUCTOR_IS_DIRECT_INIT (in CONSTRUCTOR)
71       LAMBDA_EXPR_CAPTURES_THIS_P (in LAMBDA_EXPR)
72       DECLTYPE_FOR_LAMBDA_CAPTURE (in DECLTYPE_TYPE)
73       VEC_INIT_EXPR_IS_CONSTEXPR (in VEC_INIT_EXPR)
74       DECL_OVERRIDE_P (in FUNCTION_DECL)
75       IMPLICIT_CONV_EXPR_DIRECT_INIT (in IMPLICIT_CONV_EXPR)
76       TRANSACTION_EXPR_IS_STMT (in TRANSACTION_EXPR)
77    1: IDENTIFIER_VIRTUAL_P (in IDENTIFIER_NODE)
78       TI_PENDING_TEMPLATE_FLAG.
79       TEMPLATE_PARMS_FOR_INLINE.
80       DELETE_EXPR_USE_VEC (in DELETE_EXPR).
81       (TREE_CALLS_NEW) (in _EXPR or _REF) (commented-out).
82       ICS_ELLIPSIS_FLAG (in _CONV)
83       DECL_INITIALIZED_P (in VAR_DECL)
84       TYPENAME_IS_CLASS_P (in TYPENAME_TYPE)
85       STMT_IS_FULL_EXPR_P (in _STMT)
86       TARGET_EXPR_LIST_INIT_P (in TARGET_EXPR)
87       LAMBDA_EXPR_MUTABLE_P (in LAMBDA_EXPR)
88       DECL_FINAL_P (in FUNCTION_DECL)
89       QUALIFIED_NAME_IS_TEMPLATE (in SCOPE_REF)
90    2: IDENTIFIER_OPNAME_P (in IDENTIFIER_NODE)
91       ICS_THIS_FLAG (in _CONV)
92       DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (in VAR_DECL)
93       STATEMENT_LIST_TRY_BLOCK (in STATEMENT_LIST)
94       TYPENAME_IS_RESOLVING_P (in TYPE_NAME_TYPE)
95       LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P (in LAMBDA_EXPR)
96       TARGET_EXPR_DIRECT_INIT_P (in TARGET_EXPR)
97    3: (TREE_REFERENCE_EXPR) (in NON_LVALUE_EXPR) (commented-out).
98       ICS_BAD_FLAG (in _CONV)
99       FN_TRY_BLOCK_P (in TRY_BLOCK)
100       IDENTIFIER_CTOR_OR_DTOR_P (in IDENTIFIER_NODE)
101       BIND_EXPR_BODY_BLOCK (in BIND_EXPR)
102       DECL_NON_TRIVIALLY_INITIALIZED_P (in VAR_DECL)
103    4: TREE_HAS_CONSTRUCTOR (in INDIRECT_REF, SAVE_EXPR, CONSTRUCTOR,
104           or FIELD_DECL).
105       IDENTIFIER_TYPENAME_P (in IDENTIFIER_NODE)
106       DECL_TINFO_P (in VAR_DECL)
107    5: C_IS_RESERVED_WORD (in IDENTIFIER_NODE)
108       DECL_VTABLE_OR_VTT_P (in VAR_DECL)
109    6: IDENTIFIER_REPO_CHOSEN (in IDENTIFIER_NODE)
110       DECL_CONSTRUCTION_VTABLE_P (in VAR_DECL)
111       TYPE_MARKED_P (in _TYPE)
112
113    Usage of TYPE_LANG_FLAG_?:
114    0: TYPE_DEPENDENT_P
115    1: TYPE_HAS_USER_CONSTRUCTOR.
116    2: unused
117    3: TYPE_FOR_JAVA.
118    4: TYPE_HAS_NONTRIVIAL_DESTRUCTOR
119    5: CLASS_TYPE_P (in RECORD_TYPE and UNION_TYPE)
120       ENUM_FIXED_UNDERLYING_TYPE_P (in ENUMERAL_TYPE)
121    6: TYPE_DEPENDENT_P_VALID
122
123    Usage of DECL_LANG_FLAG_?:
124    0: DECL_ERROR_REPORTED (in VAR_DECL).
125       DECL_TEMPLATE_PARM_P (in PARM_DECL, CONST_DECL, TYPE_DECL, or TEMPLATE_DECL)
126       DECL_LOCAL_FUNCTION_P (in FUNCTION_DECL)
127       DECL_MUTABLE_P (in FIELD_DECL)
128       DECL_DEPENDENT_P (in USING_DECL)
129    1: C_TYPEDEF_EXPLICITLY_SIGNED (in TYPE_DECL).
130       DECL_TEMPLATE_INSTANTIATED (in a VAR_DECL or a FUNCTION_DECL)
131       DECL_MEMBER_TEMPLATE_P (in TEMPLATE_DECL)
132       FUNCTION_PARAMETER_PACK_P (in PARM_DECL)
133    2: DECL_THIS_EXTERN (in VAR_DECL or FUNCTION_DECL).
134       DECL_IMPLICIT_TYPEDEF_P (in a TYPE_DECL)
135    3: DECL_IN_AGGR_P.
136    4: DECL_C_BIT_FIELD (in a FIELD_DECL)
137       DECL_ANON_UNION_VAR_P (in a VAR_DECL)
138       DECL_SELF_REFERENCE_P (in a TYPE_DECL)
139       DECL_INVALID_OVERRIDER_P (in a FUNCTION_DECL)
140    5: DECL_INTERFACE_KNOWN.
141    6: DECL_THIS_STATIC (in VAR_DECL or FUNCTION_DECL).
142       DECL_FIELD_IS_BASE (in FIELD_DECL)
143       TYPE_DECL_ALIAS_P (in TYPE_DECL)
144    7: DECL_DEAD_FOR_LOCAL (in VAR_DECL).
145       DECL_THUNK_P (in a member FUNCTION_DECL)
146       DECL_NORMAL_CAPTURE_P (in FIELD_DECL)
147    8: DECL_DECLARED_CONSTEXPR_P (in VAR_DECL, FUNCTION_DECL)
148
149    Usage of language-independent fields in a language-dependent manner:
150
151    TYPE_ALIAS_SET
152      This field is used by TYPENAME_TYPEs, TEMPLATE_TYPE_PARMs, and so
153      forth as a substitute for the mark bits provided in `lang_type'.
154      At present, only the six low-order bits are used.
155
156    TYPE_LANG_SLOT_1
157      For an ENUMERAL_TYPE, this is ENUM_TEMPLATE_INFO.
158      For a FUNCTION_TYPE or METHOD_TYPE, this is TYPE_RAISES_EXCEPTIONS
159
160   BINFO_VIRTUALS
161      For a binfo, this is a TREE_LIST.  There is an entry for each
162      virtual function declared either in BINFO or its direct and
163      indirect primary bases.
164
165      The BV_DELTA of each node gives the amount by which to adjust the
166      `this' pointer when calling the function.  If the method is an
167      overridden version of a base class method, then it is assumed
168      that, prior to adjustment, the this pointer points to an object
169      of the base class.
170
171      The BV_VCALL_INDEX of each node, if non-NULL, gives the vtable
172      index of the vcall offset for this entry.
173
174      The BV_FN is the declaration for the virtual function itself.
175
176      If BV_LOST_PRIMARY is set, it means that this entry is for a lost
177      primary virtual base and can be left null in the vtable.
178
179    BINFO_VTABLE
180      This is an expression with POINTER_TYPE that gives the value
181      to which the vptr should be initialized.  Use get_vtbl_decl_for_binfo
182      to extract the VAR_DECL for the complete vtable.
183
184    DECL_VINDEX
185      This field is NULL for a non-virtual function.  For a virtual
186      function, it is eventually set to an INTEGER_CST indicating the
187      index in the vtable at which this function can be found.  When
188      a virtual function is declared, but before it is known what
189      function is overridden, this field is the error_mark_node.
190
191      Temporarily, it may be set to a TREE_LIST whose TREE_VALUE is
192      the virtual function this one overrides, and whose TREE_CHAIN is
193      the old DECL_VINDEX.  */
194
195 /* Language-specific tree checkers.  */
196
197 #define VAR_OR_FUNCTION_DECL_CHECK(NODE) \
198   TREE_CHECK2(NODE,VAR_DECL,FUNCTION_DECL)
199
200 #define VAR_FUNCTION_OR_PARM_DECL_CHECK(NODE) \
201   TREE_CHECK3(NODE,VAR_DECL,FUNCTION_DECL,PARM_DECL)
202
203 #define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) \
204   TREE_CHECK4(NODE,VAR_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL)
205
206 #define VAR_TEMPL_TYPE_FIELD_OR_FUNCTION_DECL_CHECK(NODE) \
207   TREE_CHECK5(NODE,VAR_DECL,FIELD_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL)
208
209 #define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) \
210   TREE_CHECK(NODE,BOUND_TEMPLATE_TEMPLATE_PARM)
211
212 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
213 #define THUNK_FUNCTION_CHECK(NODE) __extension__                        \
214 ({  __typeof (NODE) const __t = (NODE);                                 \
215     if (TREE_CODE (__t) != FUNCTION_DECL || !__t->decl_common.lang_specific \
216         || !__t->decl_common.lang_specific->u.fn.thunk_p)               \
217       tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, 0);     \
218      __t; })
219 #else
220 #define THUNK_FUNCTION_CHECK(NODE) (NODE)
221 #endif
222 \f
223 /* Language-dependent contents of an identifier.  */
224
225 struct GTY(()) lang_identifier {
226   struct c_common_identifier c_common;
227   cxx_binding *namespace_bindings;
228   cxx_binding *bindings;
229   tree class_template_info;
230   tree label_value;
231 };
232
233 /* In an IDENTIFIER_NODE, nonzero if this identifier is actually a
234    keyword.  C_RID_CODE (node) is then the RID_* value of the keyword,
235    and C_RID_YYCODE is the token number wanted by Yacc.  */
236
237 #define C_IS_RESERVED_WORD(ID) TREE_LANG_FLAG_5 (ID)
238
239 #define LANG_IDENTIFIER_CAST(NODE) \
240         ((struct lang_identifier*)IDENTIFIER_NODE_CHECK (NODE))
241
242 struct GTY(()) template_parm_index_s {
243   struct tree_common common;
244   int index;
245   int level;
246   int orig_level;
247   int num_siblings;
248   tree decl;
249 };
250 typedef struct template_parm_index_s template_parm_index;
251
252 struct GTY(()) ptrmem_cst {
253   struct tree_common common;
254   tree member;
255 };
256 typedef struct ptrmem_cst * ptrmem_cst_t;
257
258 #define IDENTIFIER_GLOBAL_VALUE(NODE) \
259   namespace_binding ((NODE), global_namespace)
260 #define SET_IDENTIFIER_GLOBAL_VALUE(NODE, VAL) \
261   set_namespace_binding ((NODE), global_namespace, (VAL))
262 #define IDENTIFIER_NAMESPACE_VALUE(NODE) \
263   namespace_binding ((NODE), current_namespace)
264 #define SET_IDENTIFIER_NAMESPACE_VALUE(NODE, VAL) \
265   set_namespace_binding ((NODE), current_namespace, (VAL))
266
267 #define CLEANUP_P(NODE)         TREE_LANG_FLAG_0 (TRY_BLOCK_CHECK (NODE))
268
269 #define BIND_EXPR_TRY_BLOCK(NODE) \
270   TREE_LANG_FLAG_0 (BIND_EXPR_CHECK (NODE))
271
272 /* Used to mark the block around the member initializers and cleanups.  */
273 #define BIND_EXPR_BODY_BLOCK(NODE) \
274   TREE_LANG_FLAG_3 (BIND_EXPR_CHECK (NODE))
275 #define FUNCTION_NEEDS_BODY_BLOCK(NODE) \
276   (DECL_CONSTRUCTOR_P (NODE) || DECL_DESTRUCTOR_P (NODE) \
277    || LAMBDA_FUNCTION_P (NODE))
278
279 #define STATEMENT_LIST_NO_SCOPE(NODE) \
280   TREE_LANG_FLAG_0 (STATEMENT_LIST_CHECK (NODE))
281 #define STATEMENT_LIST_TRY_BLOCK(NODE) \
282   TREE_LANG_FLAG_2 (STATEMENT_LIST_CHECK (NODE))
283
284 /* Nonzero if this statement should be considered a full-expression,
285    i.e., if temporaries created during this statement should have
286    their destructors run at the end of this statement.  */
287 #define STMT_IS_FULL_EXPR_P(NODE) TREE_LANG_FLAG_1 ((NODE))
288
289 /* Marks the result of a statement expression.  */
290 #define EXPR_STMT_STMT_EXPR_RESULT(NODE) \
291   TREE_LANG_FLAG_0 (EXPR_STMT_CHECK (NODE))
292
293 /* Nonzero if this statement-expression does not have an associated scope.  */
294 #define STMT_EXPR_NO_SCOPE(NODE) \
295    TREE_LANG_FLAG_0 (STMT_EXPR_CHECK (NODE))
296
297 /* Returns nonzero iff TYPE1 and TYPE2 are the same type, in the usual
298    sense of `same'.  */
299 #define same_type_p(TYPE1, TYPE2) \
300   comptypes ((TYPE1), (TYPE2), COMPARE_STRICT)
301
302 /* Returns nonzero iff NODE is a declaration for the global function
303    `main'.  */
304 #define DECL_MAIN_P(NODE)                               \
305    (DECL_EXTERN_C_FUNCTION_P (NODE)                     \
306     && DECL_NAME (NODE) != NULL_TREE                    \
307     && MAIN_NAME_P (DECL_NAME (NODE))                   \
308     && flag_hosted)
309
310 /* The overloaded FUNCTION_DECL.  */
311 #define OVL_FUNCTION(NODE) \
312   (((struct tree_overload*)OVERLOAD_CHECK (NODE))->function)
313 #define OVL_CHAIN(NODE)      TREE_CHAIN (NODE)
314 /* Polymorphic access to FUNCTION and CHAIN.  */
315 #define OVL_CURRENT(NODE)       \
316   ((TREE_CODE (NODE) == OVERLOAD) ? OVL_FUNCTION (NODE) : (NODE))
317 #define OVL_NEXT(NODE)          \
318   ((TREE_CODE (NODE) == OVERLOAD) ? TREE_CHAIN (NODE) : NULL_TREE)
319 /* If set, this was imported in a using declaration.
320    This is not to confuse with being used somewhere, which
321    is not important for this node.  */
322 #define OVL_USED(NODE)          TREE_USED (NODE)
323 /* If set, this OVERLOAD was created for argument-dependent lookup
324    and can be freed afterward.  */
325 #define OVL_ARG_DEPENDENT(NODE) TREE_LANG_FLAG_0 (OVERLOAD_CHECK (NODE))
326
327 struct GTY(()) tree_overload {
328   struct tree_common common;
329   tree function;
330 };
331
332 /* Returns true iff NODE is a BASELINK.  */
333 #define BASELINK_P(NODE) \
334   (TREE_CODE (NODE) == BASELINK)
335 /* The BINFO indicating the base from which the BASELINK_FUNCTIONS came.  */
336 #define BASELINK_BINFO(NODE) \
337   (((struct tree_baselink*) BASELINK_CHECK (NODE))->binfo)
338 /* The functions referred to by the BASELINK; either a FUNCTION_DECL,
339    a TEMPLATE_DECL, an OVERLOAD, or a TEMPLATE_ID_EXPR.  */
340 #define BASELINK_FUNCTIONS(NODE) \
341   (((struct tree_baselink*) BASELINK_CHECK (NODE))->functions)
342 /* The BINFO in which the search for the functions indicated by this baselink
343    began.  This base is used to determine the accessibility of functions
344    selected by overload resolution.  */
345 #define BASELINK_ACCESS_BINFO(NODE) \
346   (((struct tree_baselink*) BASELINK_CHECK (NODE))->access_binfo)
347 /* For a type-conversion operator, the BASELINK_OPTYPE indicates the type
348    to which the conversion should occur.  This value is important if
349    the BASELINK_FUNCTIONS include a template conversion operator --
350    the BASELINK_OPTYPE can be used to determine what type the user
351    requested.  */
352 #define BASELINK_OPTYPE(NODE) \
353   (TREE_CHAIN (BASELINK_CHECK (NODE)))
354 /* Nonzero if this baselink was from a qualified lookup.  */
355 #define BASELINK_QUALIFIED_P(NODE) \
356   TREE_LANG_FLAG_0 (BASELINK_CHECK (NODE))
357
358 struct GTY(()) tree_baselink {
359   struct tree_common common;
360   tree binfo;
361   tree functions;
362   tree access_binfo;
363 };
364
365 /* The different kinds of ids that we encounter.  */
366
367 typedef enum cp_id_kind
368 {
369   /* Not an id at all.  */
370   CP_ID_KIND_NONE,
371   /* An unqualified-id that is not a template-id.  */
372   CP_ID_KIND_UNQUALIFIED,
373   /* An unqualified-id that is a dependent name.  */
374   CP_ID_KIND_UNQUALIFIED_DEPENDENT,
375   /* An unqualified template-id.  */
376   CP_ID_KIND_TEMPLATE_ID,
377   /* A qualified-id.  */
378   CP_ID_KIND_QUALIFIED
379 } cp_id_kind;
380
381
382 /* The various kinds of C++0x warnings we encounter. */
383
384 typedef enum cpp0x_warn_str
385 {
386   /* extended initializer lists */
387   CPP0X_INITIALIZER_LISTS,
388   /* explicit conversion operators */
389   CPP0X_EXPLICIT_CONVERSION,
390   /* variadic templates */
391   CPP0X_VARIADIC_TEMPLATES,
392   /* lambda expressions */
393   CPP0X_LAMBDA_EXPR,
394   /* C++0x auto */
395   CPP0X_AUTO,
396   /* scoped enums */
397   CPP0X_SCOPED_ENUMS,
398   /* defaulted and deleted functions */
399   CPP0X_DEFAULTED_DELETED,
400   /* inline namespaces */
401   CPP0X_INLINE_NAMESPACES,
402   /* override controls, override/final */
403   CPP0X_OVERRIDE_CONTROLS,
404   /* non-static data member initializers */
405   CPP0X_NSDMI,
406   /* user defined literals */
407   CPP0X_USER_DEFINED_LITERALS,
408   /* delegating constructors */
409   CPP0X_DELEGATING_CTORS
410 } cpp0x_warn_str;
411   
412 /* The various kinds of operation used by composite_pointer_type. */
413
414 typedef enum composite_pointer_operation
415 {
416   /* comparison */
417   CPO_COMPARISON,
418   /* conversion */
419   CPO_CONVERSION,
420   /* conditional expression */
421   CPO_CONDITIONAL_EXPR
422 } composite_pointer_operation;
423
424 /* Possible cases of expression list used by build_x_compound_expr_from_list. */
425 typedef enum expr_list_kind {
426   ELK_INIT,             /* initializer */
427   ELK_MEM_INIT,         /* member initializer */
428   ELK_FUNC_CAST         /* functional cast */
429 } expr_list_kind; 
430
431 /* Possible cases of implicit bad rhs conversions. */
432 typedef enum impl_conv_rhs {
433   ICR_DEFAULT_ARGUMENT, /* default argument */
434   ICR_CONVERTING,       /* converting */
435   ICR_INIT,             /* initialization */
436   ICR_ARGPASS,          /* argument passing */
437   ICR_RETURN,           /* return */
438   ICR_ASSIGN            /* assignment */
439 } impl_conv_rhs;
440
441 /* Possible cases of implicit or explicit bad conversions to void. */
442 typedef enum impl_conv_void {
443   ICV_CAST,            /* (explicit) conversion to void */
444   ICV_SECOND_OF_COND,  /* second operand of conditional expression */
445   ICV_THIRD_OF_COND,   /* third operand of conditional expression */
446   ICV_RIGHT_OF_COMMA,  /* right operand of comma operator */
447   ICV_LEFT_OF_COMMA,   /* left operand of comma operator */
448   ICV_STATEMENT,       /* statement */
449   ICV_THIRD_IN_FOR     /* for increment expression */
450 } impl_conv_void;
451
452 /* Macros for access to language-specific slots in an identifier.  */
453
454 #define IDENTIFIER_NAMESPACE_BINDINGS(NODE)     \
455   (LANG_IDENTIFIER_CAST (NODE)->namespace_bindings)
456 #define IDENTIFIER_TEMPLATE(NODE)       \
457   (LANG_IDENTIFIER_CAST (NODE)->class_template_info)
458
459 /* The IDENTIFIER_BINDING is the innermost cxx_binding for the
460     identifier.  It's PREVIOUS is the next outermost binding.  Each
461     VALUE field is a DECL for the associated declaration.  Thus,
462     name lookup consists simply of pulling off the node at the front
463     of the list (modulo oddities for looking up the names of types,
464     and such.)  You can use SCOPE field to determine the scope
465     that bound the name.  */
466 #define IDENTIFIER_BINDING(NODE) \
467   (LANG_IDENTIFIER_CAST (NODE)->bindings)
468
469 /* TREE_TYPE only indicates on local and class scope the current
470    type. For namespace scope, the presence of a type in any namespace
471    is indicated with global_type_node, and the real type behind must
472    be found through lookup.  */
473 #define IDENTIFIER_TYPE_VALUE(NODE) identifier_type_value (NODE)
474 #define REAL_IDENTIFIER_TYPE_VALUE(NODE) TREE_TYPE (NODE)
475 #define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = (TYPE))
476 #define IDENTIFIER_HAS_TYPE_VALUE(NODE) (IDENTIFIER_TYPE_VALUE (NODE) ? 1 : 0)
477
478 #define IDENTIFIER_LABEL_VALUE(NODE) \
479   (LANG_IDENTIFIER_CAST (NODE)->label_value)
480 #define SET_IDENTIFIER_LABEL_VALUE(NODE, VALUE)   \
481   IDENTIFIER_LABEL_VALUE (NODE) = (VALUE)
482
483 /* Nonzero if this identifier is used as a virtual function name somewhere
484    (optimizes searches).  */
485 #define IDENTIFIER_VIRTUAL_P(NODE) TREE_LANG_FLAG_1 (NODE)
486
487 /* Nonzero if this identifier is the prefix for a mangled C++ operator
488    name.  */
489 #define IDENTIFIER_OPNAME_P(NODE) TREE_LANG_FLAG_2 (NODE)
490
491 /* Nonzero if this identifier is the name of a type-conversion
492    operator.  */
493 #define IDENTIFIER_TYPENAME_P(NODE) \
494   TREE_LANG_FLAG_4 (NODE)
495
496 /* Nonzero if this identifier is the name of a constructor or
497    destructor.  */
498 #define IDENTIFIER_CTOR_OR_DTOR_P(NODE) \
499   TREE_LANG_FLAG_3 (NODE)
500
501 /* True iff NAME is the DECL_ASSEMBLER_NAME for an entity with vague
502    linkage which the prelinker has assigned to this translation
503    unit.  */
504 #define IDENTIFIER_REPO_CHOSEN(NAME) \
505   (TREE_LANG_FLAG_6 (NAME))
506
507 /* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only.  */
508 #define C_TYPE_FIELDS_READONLY(TYPE) \
509   (LANG_TYPE_CLASS_CHECK (TYPE)->fields_readonly)
510
511 /* The tokens stored in the default argument.  */
512
513 #define DEFARG_TOKENS(NODE) \
514   (((struct tree_default_arg *)DEFAULT_ARG_CHECK (NODE))->tokens)
515 #define DEFARG_INSTANTIATIONS(NODE) \
516   (((struct tree_default_arg *)DEFAULT_ARG_CHECK (NODE))->instantiations)
517
518 struct GTY (()) tree_default_arg {
519   struct tree_common common;
520   struct cp_token_cache *tokens;
521   VEC(tree,gc) *instantiations;
522 };
523
524
525 #define DEFERRED_NOEXCEPT_PATTERN(NODE) \
526   (((struct tree_deferred_noexcept *)DEFERRED_NOEXCEPT_CHECK (NODE))->pattern)
527 #define DEFERRED_NOEXCEPT_ARGS(NODE) \
528   (((struct tree_deferred_noexcept *)DEFERRED_NOEXCEPT_CHECK (NODE))->args)
529 #define DEFERRED_NOEXCEPT_SPEC_P(NODE)                          \
530   ((NODE) && (TREE_PURPOSE (NODE))                              \
531   && (TREE_CODE (TREE_PURPOSE (NODE)) == DEFERRED_NOEXCEPT      \
532       || is_overloaded_fn (TREE_PURPOSE (NODE))))
533
534 struct GTY (()) tree_deferred_noexcept {
535   struct tree_base base;
536   tree pattern;
537   tree args;
538 };
539
540
541 /* The condition associated with the static assertion.  This must be
542    an integral constant expression.  */
543 #define STATIC_ASSERT_CONDITION(NODE) \
544   (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->condition)
545
546 /* The message associated with the static assertion.  This must be a
547    string constant, which will be emitted as an error message when the
548    static assert condition is false.  */
549 #define STATIC_ASSERT_MESSAGE(NODE) \
550   (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->message)
551
552 /* Source location information for a static assertion.  */
553 #define STATIC_ASSERT_SOURCE_LOCATION(NODE) \
554   (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->location)
555
556 struct GTY (()) tree_static_assert {
557   struct tree_common common;
558   tree condition;
559   tree message;
560   location_t location;
561 };
562
563 struct GTY (()) tree_argument_pack_select {
564   struct tree_common common;
565   tree argument_pack;
566   int index;
567 };
568
569 /* The different kinds of traits that we encounter.  */
570
571 typedef enum cp_trait_kind
572 {
573   CPTK_BASES,
574   CPTK_DIRECT_BASES,
575   CPTK_HAS_NOTHROW_ASSIGN,
576   CPTK_HAS_NOTHROW_CONSTRUCTOR,
577   CPTK_HAS_NOTHROW_COPY,
578   CPTK_HAS_TRIVIAL_ASSIGN,
579   CPTK_HAS_TRIVIAL_CONSTRUCTOR,
580   CPTK_HAS_TRIVIAL_COPY,
581   CPTK_HAS_TRIVIAL_DESTRUCTOR,
582   CPTK_HAS_VIRTUAL_DESTRUCTOR,
583   CPTK_IS_ABSTRACT,
584   CPTK_IS_BASE_OF,
585   CPTK_IS_CLASS,
586   CPTK_IS_CONVERTIBLE_TO,
587   CPTK_IS_EMPTY,
588   CPTK_IS_ENUM,
589   CPTK_IS_LITERAL_TYPE,
590   CPTK_IS_POD,
591   CPTK_IS_POLYMORPHIC,
592   CPTK_IS_STD_LAYOUT,
593   CPTK_IS_TRIVIAL,
594   CPTK_IS_UNION,
595   CPTK_UNDERLYING_TYPE
596 } cp_trait_kind;
597
598 /* The types that we are processing.  */
599 #define TRAIT_EXPR_TYPE1(NODE) \
600   (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type1)
601
602 #define TRAIT_EXPR_TYPE2(NODE) \
603   (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type2)
604
605 /* The specific trait that we are processing.  */
606 #define TRAIT_EXPR_KIND(NODE) \
607   (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->kind)
608
609 struct GTY (()) tree_trait_expr {
610   struct tree_common common;
611   tree type1;
612   tree type2;  
613   enum cp_trait_kind kind;
614 };
615
616 /* Based off of TYPE_ANONYMOUS_P.  */
617 #define LAMBDA_TYPE_P(NODE) \
618   (CLASS_TYPE_P (NODE) && LAMBDANAME_P (TYPE_LINKAGE_IDENTIFIER (NODE)))
619
620 /* Test if FUNCTION_DECL is a lambda function.  */
621 #define LAMBDA_FUNCTION_P(FNDECL) \
622   (DECL_OVERLOADED_OPERATOR_P (FNDECL) == CALL_EXPR \
623    && LAMBDA_TYPE_P (CP_DECL_CONTEXT (FNDECL)))
624
625 enum cp_lambda_default_capture_mode_type {
626   CPLD_NONE,
627   CPLD_COPY,
628   CPLD_REFERENCE
629 };
630
631 /* The method of default capture, if any.  */
632 #define LAMBDA_EXPR_DEFAULT_CAPTURE_MODE(NODE) \
633   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->default_capture_mode)
634
635 /* The capture-list, including `this'.  Each capture is stored as a FIELD_DECL
636  * so that the name, type, and field are all together, whether or not it has
637  * been added to the lambda's class type.
638    TREE_LIST:
639      TREE_PURPOSE: The FIELD_DECL for this capture.
640      TREE_VALUE: The initializer. This is part of a GNU extension.  */
641 #define LAMBDA_EXPR_CAPTURE_LIST(NODE) \
642   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->capture_list)
643
644 /* During parsing of the lambda, the node in the capture-list that holds
645    the 'this' capture.  */
646 #define LAMBDA_EXPR_THIS_CAPTURE(NODE) \
647   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->this_capture)
648
649 /* Predicate tracking whether `this' is in the effective capture set.  */
650 #define LAMBDA_EXPR_CAPTURES_THIS_P(NODE) \
651   LAMBDA_EXPR_THIS_CAPTURE(NODE)
652
653 /* Predicate tracking whether the lambda was declared 'mutable'.  */
654 #define LAMBDA_EXPR_MUTABLE_P(NODE) \
655   TREE_LANG_FLAG_1 (LAMBDA_EXPR_CHECK (NODE))
656
657 /* True iff we should try to deduce the lambda return type from any return
658    statement.  */
659 #define LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P(NODE) \
660   TREE_LANG_FLAG_2 (LAMBDA_EXPR_CHECK (NODE))
661
662 /* The return type in the expression.
663  * NULL_TREE indicates that none was specified.  */
664 #define LAMBDA_EXPR_RETURN_TYPE(NODE) \
665   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->return_type)
666
667 /* The source location of the lambda.  */
668 #define LAMBDA_EXPR_LOCATION(NODE) \
669   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->locus)
670
671 /* The mangling scope for the lambda: FUNCTION_DECL, PARM_DECL, VAR_DECL,
672    FIELD_DECL or NULL_TREE.  If this is NULL_TREE, we have no linkage.  */
673 #define LAMBDA_EXPR_EXTRA_SCOPE(NODE) \
674   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->extra_scope)
675
676 /* If EXTRA_SCOPE, this is the number of the lambda within that scope.  */
677 #define LAMBDA_EXPR_DISCRIMINATOR(NODE) \
678   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->discriminator)
679
680 /* During parsing of the lambda, a vector of capture proxies which need
681    to be pushed once we're done processing a nested lambda.  */
682 #define LAMBDA_EXPR_PENDING_PROXIES(NODE) \
683   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->pending_proxies)
684
685 /* The closure type of the lambda.  Note that the TREE_TYPE of a
686    LAMBDA_EXPR is always NULL_TREE, because we need to instantiate the
687    LAMBDA_EXPR in order to instantiate the type.  */
688 #define LAMBDA_EXPR_CLOSURE(NODE) \
689   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->closure)
690
691 struct GTY (()) tree_lambda_expr
692 {
693   struct tree_typed typed;
694   tree capture_list;
695   tree this_capture;
696   tree return_type;
697   tree extra_scope;
698   tree closure;
699   VEC(tree,gc)* pending_proxies;
700   location_t locus;
701   enum cp_lambda_default_capture_mode_type default_capture_mode;
702   int discriminator;
703 };
704
705 /* A (typedef,context,usage location) triplet.
706    It represents a typedef used through a
707    context at a given source location.
708    e.g.
709    struct foo {
710      typedef int myint;
711    };
712
713    struct bar {
714     foo::myint v; // #1<-- this location.
715    };
716
717    In bar, the triplet will be (myint, foo, #1).
718    */
719 struct GTY(()) qualified_typedef_usage_s {
720   tree typedef_decl;
721   tree context;
722   location_t locus;
723 };
724 typedef struct qualified_typedef_usage_s qualified_typedef_usage_t;
725 DEF_VEC_O (qualified_typedef_usage_t);
726 DEF_VEC_ALLOC_O (qualified_typedef_usage_t,gc);
727
728 struct GTY(()) tree_template_info {
729   struct tree_common common;
730   VEC(qualified_typedef_usage_t,gc) *typedefs_needing_access_checking;
731 };
732
733 enum cp_tree_node_structure_enum {
734   TS_CP_GENERIC,
735   TS_CP_IDENTIFIER,
736   TS_CP_TPI,
737   TS_CP_PTRMEM,
738   TS_CP_BINDING,
739   TS_CP_OVERLOAD,
740   TS_CP_BASELINK,
741   TS_CP_WRAPPER,
742   TS_CP_DEFAULT_ARG,
743   TS_CP_DEFERRED_NOEXCEPT,
744   TS_CP_STATIC_ASSERT,
745   TS_CP_ARGUMENT_PACK_SELECT,
746   TS_CP_TRAIT_EXPR,
747   TS_CP_LAMBDA_EXPR,
748   TS_CP_TEMPLATE_INFO,
749   TS_CP_USERDEF_LITERAL,
750   LAST_TS_CP_ENUM
751 };
752
753 /* The resulting tree type.  */
754 union GTY((desc ("cp_tree_node_structure (&%h)"),
755        chain_next ("(union lang_tree_node *) c_tree_chain_next (&%h.generic)"))) lang_tree_node {
756   union tree_node GTY ((tag ("TS_CP_GENERIC"),
757                         desc ("tree_node_structure (&%h)"))) generic;
758   struct template_parm_index_s GTY ((tag ("TS_CP_TPI"))) tpi;
759   struct ptrmem_cst GTY ((tag ("TS_CP_PTRMEM"))) ptrmem;
760   struct tree_overload GTY ((tag ("TS_CP_OVERLOAD"))) overload;
761   struct tree_baselink GTY ((tag ("TS_CP_BASELINK"))) baselink;
762   struct tree_default_arg GTY ((tag ("TS_CP_DEFAULT_ARG"))) default_arg;
763   struct tree_deferred_noexcept GTY ((tag ("TS_CP_DEFERRED_NOEXCEPT"))) deferred_noexcept;
764   struct lang_identifier GTY ((tag ("TS_CP_IDENTIFIER"))) identifier;
765   struct tree_static_assert GTY ((tag ("TS_CP_STATIC_ASSERT"))) 
766     static_assertion;
767   struct tree_argument_pack_select GTY ((tag ("TS_CP_ARGUMENT_PACK_SELECT")))
768     argument_pack_select;
769   struct tree_trait_expr GTY ((tag ("TS_CP_TRAIT_EXPR")))
770     trait_expression;
771   struct tree_lambda_expr GTY ((tag ("TS_CP_LAMBDA_EXPR")))
772     lambda_expression;
773   struct tree_template_info GTY ((tag ("TS_CP_TEMPLATE_INFO")))
774     template_info;
775   struct tree_userdef_literal GTY ((tag ("TS_CP_USERDEF_LITERAL")))
776     userdef_literal;
777 };
778
779 \f
780 enum cp_tree_index
781 {
782     CPTI_JAVA_BYTE_TYPE,
783     CPTI_JAVA_SHORT_TYPE,
784     CPTI_JAVA_INT_TYPE,
785     CPTI_JAVA_LONG_TYPE,
786     CPTI_JAVA_FLOAT_TYPE,
787     CPTI_JAVA_DOUBLE_TYPE,
788     CPTI_JAVA_CHAR_TYPE,
789     CPTI_JAVA_BOOLEAN_TYPE,
790
791     CPTI_WCHAR_DECL,
792     CPTI_VTABLE_ENTRY_TYPE,
793     CPTI_DELTA_TYPE,
794     CPTI_VTABLE_INDEX_TYPE,
795     CPTI_CLEANUP_TYPE,
796     CPTI_VTT_PARM_TYPE,
797
798     CPTI_CLASS_TYPE,
799     CPTI_UNKNOWN_TYPE,
800     CPTI_INIT_LIST_TYPE,
801     CPTI_DEPENDENT_LAMBDA_RETURN_TYPE,
802     CPTI_VTBL_TYPE,
803     CPTI_VTBL_PTR_TYPE,
804     CPTI_STD,
805     CPTI_ABI,
806     CPTI_CONST_TYPE_INFO_TYPE,
807     CPTI_TYPE_INFO_PTR_TYPE,
808     CPTI_ABORT_FNDECL,
809     CPTI_GLOBAL_DELETE_FNDECL,
810     CPTI_AGGR_TAG,
811
812     CPTI_CTOR_IDENTIFIER,
813     CPTI_COMPLETE_CTOR_IDENTIFIER,
814     CPTI_BASE_CTOR_IDENTIFIER,
815     CPTI_DTOR_IDENTIFIER,
816     CPTI_COMPLETE_DTOR_IDENTIFIER,
817     CPTI_BASE_DTOR_IDENTIFIER,
818     CPTI_DELETING_DTOR_IDENTIFIER,
819     CPTI_DELTA_IDENTIFIER,
820     CPTI_IN_CHARGE_IDENTIFIER,
821     CPTI_VTT_PARM_IDENTIFIER,
822     CPTI_NELTS_IDENTIFIER,
823     CPTI_THIS_IDENTIFIER,
824     CPTI_PFN_IDENTIFIER,
825     CPTI_VPTR_IDENTIFIER,
826     CPTI_STD_IDENTIFIER,
827
828     CPTI_LANG_NAME_C,
829     CPTI_LANG_NAME_CPLUSPLUS,
830     CPTI_LANG_NAME_JAVA,
831
832     CPTI_EMPTY_EXCEPT_SPEC,
833     CPTI_NOEXCEPT_TRUE_SPEC,
834     CPTI_NOEXCEPT_FALSE_SPEC,
835     CPTI_JCLASS,
836     CPTI_TERMINATE,
837     CPTI_CALL_UNEXPECTED,
838     CPTI_ATEXIT_FN_PTR_TYPE,
839     CPTI_ATEXIT,
840     CPTI_DSO_HANDLE,
841     CPTI_DCAST,
842
843     CPTI_KEYED_CLASSES,
844
845     CPTI_NULLPTR,
846     CPTI_NULLPTR_TYPE,
847
848     CPTI_MAX
849 };
850
851 extern GTY(()) tree cp_global_trees[CPTI_MAX];
852
853 #define java_byte_type_node             cp_global_trees[CPTI_JAVA_BYTE_TYPE]
854 #define java_short_type_node            cp_global_trees[CPTI_JAVA_SHORT_TYPE]
855 #define java_int_type_node              cp_global_trees[CPTI_JAVA_INT_TYPE]
856 #define java_long_type_node             cp_global_trees[CPTI_JAVA_LONG_TYPE]
857 #define java_float_type_node            cp_global_trees[CPTI_JAVA_FLOAT_TYPE]
858 #define java_double_type_node           cp_global_trees[CPTI_JAVA_DOUBLE_TYPE]
859 #define java_char_type_node             cp_global_trees[CPTI_JAVA_CHAR_TYPE]
860 #define java_boolean_type_node          cp_global_trees[CPTI_JAVA_BOOLEAN_TYPE]
861
862 #define wchar_decl_node                 cp_global_trees[CPTI_WCHAR_DECL]
863 #define vtable_entry_type               cp_global_trees[CPTI_VTABLE_ENTRY_TYPE]
864 /* The type used to represent an offset by which to adjust the `this'
865    pointer in pointer-to-member types.  */
866 #define delta_type_node                 cp_global_trees[CPTI_DELTA_TYPE]
867 /* The type used to represent an index into the vtable.  */
868 #define vtable_index_type               cp_global_trees[CPTI_VTABLE_INDEX_TYPE]
869
870 #define class_type_node                 cp_global_trees[CPTI_CLASS_TYPE]
871 #define unknown_type_node               cp_global_trees[CPTI_UNKNOWN_TYPE]
872 #define init_list_type_node             cp_global_trees[CPTI_INIT_LIST_TYPE]
873 #define dependent_lambda_return_type_node cp_global_trees[CPTI_DEPENDENT_LAMBDA_RETURN_TYPE]
874 #define vtbl_type_node                  cp_global_trees[CPTI_VTBL_TYPE]
875 #define vtbl_ptr_type_node              cp_global_trees[CPTI_VTBL_PTR_TYPE]
876 #define std_node                        cp_global_trees[CPTI_STD]
877 #define abi_node                        cp_global_trees[CPTI_ABI]
878 #define const_type_info_type_node       cp_global_trees[CPTI_CONST_TYPE_INFO_TYPE]
879 #define type_info_ptr_type              cp_global_trees[CPTI_TYPE_INFO_PTR_TYPE]
880 #define abort_fndecl                    cp_global_trees[CPTI_ABORT_FNDECL]
881 #define global_delete_fndecl            cp_global_trees[CPTI_GLOBAL_DELETE_FNDECL]
882 #define current_aggr                    cp_global_trees[CPTI_AGGR_TAG]
883 #define nullptr_node                    cp_global_trees[CPTI_NULLPTR]
884 #define nullptr_type_node               cp_global_trees[CPTI_NULLPTR_TYPE]
885
886 /* We cache these tree nodes so as to call get_identifier less
887    frequently.  */
888
889 /* The name of a constructor that takes an in-charge parameter to
890    decide whether or not to construct virtual base classes.  */
891 #define ctor_identifier                 cp_global_trees[CPTI_CTOR_IDENTIFIER]
892 /* The name of a constructor that constructs virtual base classes.  */
893 #define complete_ctor_identifier        cp_global_trees[CPTI_COMPLETE_CTOR_IDENTIFIER]
894 /* The name of a constructor that does not construct virtual base classes.  */
895 #define base_ctor_identifier            cp_global_trees[CPTI_BASE_CTOR_IDENTIFIER]
896 /* The name of a destructor that takes an in-charge parameter to
897    decide whether or not to destroy virtual base classes and whether
898    or not to delete the object.  */
899 #define dtor_identifier                 cp_global_trees[CPTI_DTOR_IDENTIFIER]
900 /* The name of a destructor that destroys virtual base classes.  */
901 #define complete_dtor_identifier        cp_global_trees[CPTI_COMPLETE_DTOR_IDENTIFIER]
902 /* The name of a destructor that does not destroy virtual base
903    classes.  */
904 #define base_dtor_identifier            cp_global_trees[CPTI_BASE_DTOR_IDENTIFIER]
905 /* The name of a destructor that destroys virtual base classes, and
906    then deletes the entire object.  */
907 #define deleting_dtor_identifier        cp_global_trees[CPTI_DELETING_DTOR_IDENTIFIER]
908 #define delta_identifier                cp_global_trees[CPTI_DELTA_IDENTIFIER]
909 #define in_charge_identifier            cp_global_trees[CPTI_IN_CHARGE_IDENTIFIER]
910 /* The name of the parameter that contains a pointer to the VTT to use
911    for this subobject constructor or destructor.  */
912 #define vtt_parm_identifier             cp_global_trees[CPTI_VTT_PARM_IDENTIFIER]
913 #define nelts_identifier                cp_global_trees[CPTI_NELTS_IDENTIFIER]
914 #define this_identifier                 cp_global_trees[CPTI_THIS_IDENTIFIER]
915 #define pfn_identifier                  cp_global_trees[CPTI_PFN_IDENTIFIER]
916 #define vptr_identifier                 cp_global_trees[CPTI_VPTR_IDENTIFIER]
917 /* The name of the std namespace.  */
918 #define std_identifier                  cp_global_trees[CPTI_STD_IDENTIFIER]
919 #define lang_name_c                     cp_global_trees[CPTI_LANG_NAME_C]
920 #define lang_name_cplusplus             cp_global_trees[CPTI_LANG_NAME_CPLUSPLUS]
921 #define lang_name_java                  cp_global_trees[CPTI_LANG_NAME_JAVA]
922
923 /* Exception specifier used for throw().  */
924 #define empty_except_spec               cp_global_trees[CPTI_EMPTY_EXCEPT_SPEC]
925 #define noexcept_true_spec              cp_global_trees[CPTI_NOEXCEPT_TRUE_SPEC]
926 #define noexcept_false_spec             cp_global_trees[CPTI_NOEXCEPT_FALSE_SPEC]
927
928 /* If non-NULL, a POINTER_TYPE equivalent to (java::lang::Class*).  */
929 #define jclass_node                     cp_global_trees[CPTI_JCLASS]
930
931 /* The declaration for `std::terminate'.  */
932 #define terminate_node                  cp_global_trees[CPTI_TERMINATE]
933
934 /* The declaration for "__cxa_call_unexpected".  */
935 #define call_unexpected_node            cp_global_trees[CPTI_CALL_UNEXPECTED]
936
937 /* The type of the function-pointer argument to "__cxa_atexit" (or
938    "std::atexit", if "__cxa_atexit" is not being used).  */
939 #define atexit_fn_ptr_type_node         cp_global_trees[CPTI_ATEXIT_FN_PTR_TYPE]
940
941 /* A pointer to `std::atexit'.  */
942 #define atexit_node                     cp_global_trees[CPTI_ATEXIT]
943
944 /* A pointer to `__dso_handle'.  */
945 #define dso_handle_node                 cp_global_trees[CPTI_DSO_HANDLE]
946
947 /* The declaration of the dynamic_cast runtime.  */
948 #define dynamic_cast_node               cp_global_trees[CPTI_DCAST]
949
950 /* The type of a destructor.  */
951 #define cleanup_type                    cp_global_trees[CPTI_CLEANUP_TYPE]
952
953 /* The type of the vtt parameter passed to subobject constructors and
954    destructors.  */
955 #define vtt_parm_type                   cp_global_trees[CPTI_VTT_PARM_TYPE]
956
957 /* A TREE_LIST of the dynamic classes whose vtables may have to be
958    emitted in this translation unit.  */
959
960 #define keyed_classes                   cp_global_trees[CPTI_KEYED_CLASSES]
961
962 /* Node to indicate default access. This must be distinct from the
963    access nodes in tree.h.  */
964
965 #define access_default_node             null_node
966
967 /* Global state.  */
968
969 struct GTY(()) saved_scope {
970   VEC(cxx_saved_binding,gc) *old_bindings;
971   tree old_namespace;
972   VEC(tree,gc) *decl_ns_list;
973   tree class_name;
974   tree class_type;
975   tree access_specifier;
976   tree function_decl;
977   VEC(tree,gc) *lang_base;
978   tree lang_name;
979   tree template_parms;
980   cp_binding_level *x_previous_class_level;
981   tree x_saved_tree;
982
983   /* Only used for uses of this in trailing return type.  */
984   tree x_current_class_ptr;
985   tree x_current_class_ref;
986
987   int x_processing_template_decl;
988   int x_processing_specialization;
989   BOOL_BITFIELD x_processing_explicit_instantiation : 1;
990   BOOL_BITFIELD need_pop_function_context : 1;
991
992   int unevaluated_operand;
993   int inhibit_evaluation_warnings;
994
995   struct stmt_tree_s x_stmt_tree;
996
997   cp_binding_level *class_bindings;
998   cp_binding_level *bindings;
999
1000   struct saved_scope *prev;
1001 };
1002
1003 /* The current open namespace.  */
1004
1005 #define current_namespace scope_chain->old_namespace
1006
1007 /* The stack for namespaces of current declarations.  */
1008
1009 #define decl_namespace_list scope_chain->decl_ns_list
1010
1011 /* IDENTIFIER_NODE: name of current class */
1012
1013 #define current_class_name scope_chain->class_name
1014
1015 /* _TYPE: the type of the current class */
1016
1017 #define current_class_type scope_chain->class_type
1018
1019 /* When parsing a class definition, the access specifier most recently
1020    given by the user, or, if no access specifier was given, the
1021    default value appropriate for the kind of class (i.e., struct,
1022    class, or union).  */
1023
1024 #define current_access_specifier scope_chain->access_specifier
1025
1026 /* Pointer to the top of the language name stack.  */
1027
1028 #define current_lang_base scope_chain->lang_base
1029 #define current_lang_name scope_chain->lang_name
1030
1031 /* When parsing a template declaration, a TREE_LIST represents the
1032    active template parameters.  Each node in the list represents one
1033    level of template parameters.  The innermost level is first in the
1034    list.  The depth of each level is stored as an INTEGER_CST in the
1035    TREE_PURPOSE of each node.  The parameters for that level are
1036    stored in the TREE_VALUE.  */
1037
1038 #define current_template_parms scope_chain->template_parms
1039
1040 #define processing_template_decl scope_chain->x_processing_template_decl
1041 #define processing_specialization scope_chain->x_processing_specialization
1042 #define processing_explicit_instantiation scope_chain->x_processing_explicit_instantiation
1043
1044 /* The cached class binding level, from the most recently exited
1045    class, or NULL if none.  */
1046
1047 #define previous_class_level scope_chain->x_previous_class_level
1048
1049 /* A list of private types mentioned, for deferred access checking.  */
1050
1051 extern GTY(()) struct saved_scope *scope_chain;
1052
1053 struct GTY(()) cxx_int_tree_map {
1054   unsigned int uid;
1055   tree to;
1056 };
1057
1058 extern unsigned int cxx_int_tree_map_hash (const void *);
1059 extern int cxx_int_tree_map_eq (const void *, const void *);
1060
1061 /* Global state pertinent to the current function.  */
1062
1063 struct GTY(()) language_function {
1064   struct c_language_function base;
1065
1066   tree x_cdtor_label;
1067   tree x_current_class_ptr;
1068   tree x_current_class_ref;
1069   tree x_eh_spec_block;
1070   tree x_in_charge_parm;
1071   tree x_vtt_parm;
1072   tree x_return_value;
1073
1074   BOOL_BITFIELD returns_value : 1;
1075   BOOL_BITFIELD returns_null : 1;
1076   BOOL_BITFIELD returns_abnormally : 1;
1077   BOOL_BITFIELD x_in_function_try_handler : 1;
1078   BOOL_BITFIELD x_in_base_initializer : 1;
1079
1080   /* True if this function can throw an exception.  */
1081   BOOL_BITFIELD can_throw : 1;
1082
1083   htab_t GTY((param_is(struct named_label_entry))) x_named_labels;
1084   cp_binding_level *bindings;
1085   VEC(tree,gc) *x_local_names;
1086   htab_t GTY((param_is (struct cxx_int_tree_map))) extern_decl_map;
1087 };
1088
1089 /* The current C++-specific per-function global variables.  */
1090
1091 #define cp_function_chain (cfun->language)
1092
1093 /* In a constructor destructor, the point at which all derived class
1094    destroying/construction has been done.  I.e., just before a
1095    constructor returns, or before any base class destroying will be done
1096    in a destructor.  */
1097
1098 #define cdtor_label cp_function_chain->x_cdtor_label
1099
1100 /* When we're processing a member function, current_class_ptr is the
1101    PARM_DECL for the `this' pointer.  The current_class_ref is an
1102    expression for `*this'.  */
1103
1104 #define current_class_ptr                       \
1105   (*(cfun && cp_function_chain                  \
1106      ? &cp_function_chain->x_current_class_ptr  \
1107      : &scope_chain->x_current_class_ptr))
1108 #define current_class_ref                       \
1109   (*(cfun && cp_function_chain                  \
1110      ? &cp_function_chain->x_current_class_ref  \
1111      : &scope_chain->x_current_class_ref))
1112
1113 /* The EH_SPEC_BLOCK for the exception-specifiers for the current
1114    function, if any.  */
1115
1116 #define current_eh_spec_block cp_function_chain->x_eh_spec_block
1117
1118 /* The `__in_chrg' parameter for the current function.  Only used for
1119    constructors and destructors.  */
1120
1121 #define current_in_charge_parm cp_function_chain->x_in_charge_parm
1122
1123 /* The `__vtt_parm' parameter for the current function.  Only used for
1124    constructors and destructors.  */
1125
1126 #define current_vtt_parm cp_function_chain->x_vtt_parm
1127
1128 /* Set to 0 at beginning of a function definition, set to 1 if
1129    a return statement that specifies a return value is seen.  */
1130
1131 #define current_function_returns_value cp_function_chain->returns_value
1132
1133 /* Set to 0 at beginning of a function definition, set to 1 if
1134    a return statement with no argument is seen.  */
1135
1136 #define current_function_returns_null cp_function_chain->returns_null
1137
1138 /* Set to 0 at beginning of a function definition, set to 1 if
1139    a call to a noreturn function is seen.  */
1140
1141 #define current_function_returns_abnormally \
1142   cp_function_chain->returns_abnormally
1143
1144 /* Nonzero if we are processing a base initializer.  Zero elsewhere.  */
1145 #define in_base_initializer cp_function_chain->x_in_base_initializer
1146
1147 #define in_function_try_handler cp_function_chain->x_in_function_try_handler
1148
1149 /* Expression always returned from function, or error_mark_node
1150    otherwise, for use by the automatic named return value optimization.  */
1151
1152 #define current_function_return_value \
1153   (cp_function_chain->x_return_value)
1154
1155 /* True if NAME is the IDENTIFIER_NODE for an overloaded "operator
1156    new" or "operator delete".  */
1157 #define NEW_DELETE_OPNAME_P(NAME)               \
1158   ((NAME) == ansi_opname (NEW_EXPR)             \
1159    || (NAME) == ansi_opname (VEC_NEW_EXPR)      \
1160    || (NAME) == ansi_opname (DELETE_EXPR)       \
1161    || (NAME) == ansi_opname (VEC_DELETE_EXPR))
1162
1163 #define ansi_opname(CODE) \
1164   (operator_name_info[(int) (CODE)].identifier)
1165 #define ansi_assopname(CODE) \
1166   (assignment_operator_name_info[(int) (CODE)].identifier)
1167
1168 /* TRUE if a tree code represents a statement.  */
1169 extern bool statement_code_p[MAX_TREE_CODES];
1170
1171 #define STATEMENT_CODE_P(CODE) statement_code_p[(int) (CODE)]
1172
1173 enum languages { lang_c, lang_cplusplus, lang_java };
1174
1175 /* Macros to make error reporting functions' lives easier.  */
1176 #define TYPE_IDENTIFIER(NODE) (DECL_NAME (TYPE_NAME (NODE)))
1177 #define TYPE_LINKAGE_IDENTIFIER(NODE) \
1178   (TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (NODE)))
1179 #define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (TYPE_IDENTIFIER (NODE)))
1180 #define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (TYPE_IDENTIFIER (NODE)))
1181
1182 /* Nonzero if NODE has no name for linkage purposes.  */
1183 #define TYPE_ANONYMOUS_P(NODE) \
1184   (TAGGED_TYPE_P (NODE) && ANON_AGGRNAME_P (TYPE_LINKAGE_IDENTIFIER (NODE)))
1185
1186 /* The _DECL for this _TYPE.  */
1187 #define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE)))
1188
1189 /* Nonzero if T is a class (or struct or union) type.  Also nonzero
1190    for template type parameters, typename types, and instantiated
1191    template template parameters.  Keep these checks in ascending code
1192    order.  */
1193 #define MAYBE_CLASS_TYPE_P(T)                                   \
1194   (TREE_CODE (T) == TEMPLATE_TYPE_PARM                  \
1195    || TREE_CODE (T) == TYPENAME_TYPE                    \
1196    || TREE_CODE (T) == TYPEOF_TYPE                      \
1197    || TREE_CODE (T) == BOUND_TEMPLATE_TEMPLATE_PARM     \
1198    || TREE_CODE (T) == DECLTYPE_TYPE                    \
1199    || CLASS_TYPE_P (T))
1200
1201 /* Set CLASS_TYPE_P for T to VAL.  T must be a class, struct, or
1202    union type.  */
1203 #define SET_CLASS_TYPE_P(T, VAL) \
1204   (TYPE_LANG_FLAG_5 (T) = (VAL))
1205
1206 /* Nonzero if T is a class type.  Zero for template type parameters,
1207    typename types, and so forth.  */
1208 #define CLASS_TYPE_P(T) \
1209   (RECORD_OR_UNION_CODE_P (TREE_CODE (T)) && TYPE_LANG_FLAG_5 (T))
1210
1211 /* Nonzero if T is a class type but not an union.  */
1212 #define NON_UNION_CLASS_TYPE_P(T) \
1213   (CLASS_TYPE_P (T) && TREE_CODE (T) != UNION_TYPE)
1214
1215 /* Keep these checks in ascending code order.  */
1216 #define RECORD_OR_UNION_CODE_P(T)       \
1217   ((T) == RECORD_TYPE || (T) == UNION_TYPE)
1218 #define TAGGED_TYPE_P(T) \
1219   (CLASS_TYPE_P (T) || TREE_CODE (T) == ENUMERAL_TYPE)
1220 #define IS_OVERLOAD_TYPE(T) TAGGED_TYPE_P (T)
1221
1222 /* True if this a "Java" type, defined in 'extern "Java"'.  */
1223 #define TYPE_FOR_JAVA(NODE) TYPE_LANG_FLAG_3 (NODE)
1224
1225 /* True if this type is dependent.  This predicate is only valid if
1226    TYPE_DEPENDENT_P_VALID is true.  */
1227 #define TYPE_DEPENDENT_P(NODE) TYPE_LANG_FLAG_0 (NODE)
1228
1229 /* True if dependent_type_p has been called for this type, with the
1230    result that TYPE_DEPENDENT_P is valid.  */
1231 #define TYPE_DEPENDENT_P_VALID(NODE) TYPE_LANG_FLAG_6(NODE)
1232
1233 /* Nonzero if this type is const-qualified.  */
1234 #define CP_TYPE_CONST_P(NODE)                           \
1235   ((cp_type_quals (NODE) & TYPE_QUAL_CONST) != 0)
1236
1237 /* Nonzero if this type is volatile-qualified.  */
1238 #define CP_TYPE_VOLATILE_P(NODE)                        \
1239   ((cp_type_quals (NODE) & TYPE_QUAL_VOLATILE) != 0)
1240
1241 /* Nonzero if this type is restrict-qualified.  */
1242 #define CP_TYPE_RESTRICT_P(NODE)                        \
1243   ((cp_type_quals (NODE) & TYPE_QUAL_RESTRICT) != 0)
1244
1245 /* Nonzero if this type is const-qualified, but not
1246    volatile-qualified.  Other qualifiers are ignored.  This macro is
1247    used to test whether or not it is OK to bind an rvalue to a
1248    reference.  */
1249 #define CP_TYPE_CONST_NON_VOLATILE_P(NODE)                              \
1250   ((cp_type_quals (NODE) & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE))      \
1251    == TYPE_QUAL_CONST)
1252
1253 #define FUNCTION_ARG_CHAIN(NODE) \
1254   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (NODE)))
1255
1256 /* Given a FUNCTION_DECL, returns the first TREE_LIST out of TYPE_ARG_TYPES
1257    which refers to a user-written parameter.  */
1258 #define FUNCTION_FIRST_USER_PARMTYPE(NODE) \
1259   skip_artificial_parms_for ((NODE), TYPE_ARG_TYPES (TREE_TYPE (NODE)))
1260
1261 /* Similarly, but for DECL_ARGUMENTS.  */
1262 #define FUNCTION_FIRST_USER_PARM(NODE) \
1263   skip_artificial_parms_for ((NODE), DECL_ARGUMENTS (NODE))
1264
1265 /* Nonzero iff TYPE is derived from PARENT. Ignores accessibility and
1266    ambiguity issues.  */
1267 #define DERIVED_FROM_P(PARENT, TYPE) \
1268   (lookup_base ((TYPE), (PARENT), ba_any, NULL) != NULL_TREE)
1269 /* Nonzero iff TYPE is uniquely derived from PARENT. Ignores
1270    accessibility.  */
1271 #define UNIQUELY_DERIVED_FROM_P(PARENT, TYPE) \
1272   (lookup_base ((TYPE), (PARENT), ba_unique | ba_quiet, NULL) != NULL_TREE)
1273 /* Nonzero iff TYPE is publicly & uniquely derived from PARENT.  */
1274 #define PUBLICLY_UNIQUELY_DERIVED_P(PARENT, TYPE) \
1275   (lookup_base ((TYPE), (PARENT), ba_ignore_scope | ba_check | ba_quiet, \
1276                 NULL) != NULL_TREE)
1277
1278 /* Gives the visibility specification for a class type.  */
1279 #define CLASSTYPE_VISIBILITY(TYPE)              \
1280         DECL_VISIBILITY (TYPE_MAIN_DECL (TYPE))
1281 #define CLASSTYPE_VISIBILITY_SPECIFIED(TYPE)    \
1282         DECL_VISIBILITY_SPECIFIED (TYPE_MAIN_DECL (TYPE))
1283
1284 typedef struct GTY (()) tree_pair_s {
1285   tree purpose;
1286   tree value;
1287 } tree_pair_s;
1288 typedef tree_pair_s *tree_pair_p;
1289 DEF_VEC_O (tree_pair_s);
1290 DEF_VEC_ALLOC_O (tree_pair_s,gc);
1291
1292 /* This is a few header flags for 'struct lang_type'.  Actually,
1293    all but the first are used only for lang_type_class; they
1294    are put in this structure to save space.  */
1295 struct GTY(()) lang_type_header {
1296   BOOL_BITFIELD is_lang_type_class : 1;
1297
1298   BOOL_BITFIELD has_type_conversion : 1;
1299   BOOL_BITFIELD has_copy_ctor : 1;
1300   BOOL_BITFIELD has_default_ctor : 1;
1301   BOOL_BITFIELD const_needs_init : 1;
1302   BOOL_BITFIELD ref_needs_init : 1;
1303   BOOL_BITFIELD has_const_copy_assign : 1;
1304
1305   BOOL_BITFIELD spare : 1;
1306 };
1307
1308 /* This structure provides additional information above and beyond
1309    what is provide in the ordinary tree_type.  In the past, we used it
1310    for the types of class types, template parameters types, typename
1311    types, and so forth.  However, there can be many (tens to hundreds
1312    of thousands) of template parameter types in a compilation, and
1313    there's no need for this additional information in that case.
1314    Therefore, we now use this data structure only for class types.
1315
1316    In the past, it was thought that there would be relatively few
1317    class types.  However, in the presence of heavy use of templates,
1318    many (i.e., thousands) of classes can easily be generated.
1319    Therefore, we should endeavor to keep the size of this structure to
1320    a minimum.  */
1321 struct GTY(()) lang_type_class {
1322   struct lang_type_header h;
1323
1324   unsigned char align;
1325
1326   unsigned has_mutable : 1;
1327   unsigned com_interface : 1;
1328   unsigned non_pod_class : 1;
1329   unsigned nearly_empty_p : 1;
1330   unsigned user_align : 1;
1331   unsigned has_copy_assign : 1;
1332   unsigned has_new : 1;
1333   unsigned has_array_new : 1;
1334
1335   unsigned gets_delete : 2;
1336   unsigned interface_only : 1;
1337   unsigned interface_unknown : 1;
1338   unsigned contains_empty_class_p : 1;
1339   unsigned anon_aggr : 1;
1340   unsigned non_zero_init : 1;
1341   unsigned empty_p : 1;
1342
1343   unsigned vec_new_uses_cookie : 1;
1344   unsigned declared_class : 1;
1345   unsigned diamond_shaped : 1;
1346   unsigned repeated_base : 1;
1347   unsigned being_defined : 1;
1348   unsigned java_interface : 1;
1349   unsigned debug_requested : 1;
1350   unsigned fields_readonly : 1;
1351
1352   unsigned use_template : 2;
1353   unsigned ptrmemfunc_flag : 1;
1354   unsigned was_anonymous : 1;
1355   unsigned lazy_default_ctor : 1;
1356   unsigned lazy_copy_ctor : 1;
1357   unsigned lazy_copy_assign : 1;
1358   unsigned lazy_destructor : 1;
1359
1360   unsigned has_const_copy_ctor : 1;
1361   unsigned has_complex_copy_ctor : 1;
1362   unsigned has_complex_copy_assign : 1;
1363   unsigned non_aggregate : 1;
1364   unsigned has_complex_dflt : 1;
1365   unsigned has_list_ctor : 1;
1366   unsigned non_std_layout : 1;
1367   unsigned is_literal : 1;
1368
1369   unsigned lazy_move_ctor : 1;
1370   unsigned lazy_move_assign : 1;
1371   unsigned has_complex_move_ctor : 1;
1372   unsigned has_complex_move_assign : 1;
1373   unsigned has_constexpr_ctor : 1;
1374   unsigned is_final : 1;
1375
1376   /* When adding a flag here, consider whether or not it ought to
1377      apply to a template instance if it applies to the template.  If
1378      so, make sure to copy it in instantiate_class_template!  */
1379
1380   /* There are some bits left to fill out a 32-bit word.  Keep track
1381      of this by updating the size of this bitfield whenever you add or
1382      remove a flag.  */
1383   unsigned dummy : 2;
1384
1385   tree primary_base;
1386   VEC(tree_pair_s,gc) *vcall_indices;
1387   tree vtables;
1388   tree typeinfo_var;
1389   VEC(tree,gc) *vbases;
1390   binding_table nested_udts;
1391   tree as_base;
1392   VEC(tree,gc) *pure_virtuals;
1393   tree friend_classes;
1394   VEC(tree,gc) * GTY((reorder ("resort_type_method_vec"))) methods;
1395   tree key_method;
1396   tree decl_list;
1397   tree template_info;
1398   tree befriending_classes;
1399   /* In a RECORD_TYPE, information specific to Objective-C++, such
1400      as a list of adopted protocols or a pointer to a corresponding
1401      @interface.  See objc/objc-act.h for details.  */
1402   tree objc_info;
1403   /* sorted_fields is sorted based on a pointer, so we need to be able
1404      to resort it if pointers get rearranged.  */
1405   struct sorted_fields_type * GTY ((reorder ("resort_sorted_fields")))
1406     sorted_fields;
1407   /* FIXME reuse another field?  */
1408   tree lambda_expr;
1409 };
1410
1411 struct GTY(()) lang_type_ptrmem {
1412   struct lang_type_header h;
1413   tree record;
1414 };
1415
1416 struct GTY((variable_size)) lang_type {
1417   union lang_type_u
1418   {
1419     struct lang_type_header GTY((skip (""))) h;
1420     struct lang_type_class  GTY((tag ("1"))) c;
1421     struct lang_type_ptrmem GTY((tag ("0"))) ptrmem;
1422   } GTY((desc ("%h.h.is_lang_type_class"))) u;
1423 };
1424
1425 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
1426
1427 #define LANG_TYPE_CLASS_CHECK(NODE) __extension__               \
1428 ({  struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE);           \
1429     if (! lt->u.h.is_lang_type_class)                           \
1430       lang_check_failed (__FILE__, __LINE__, __FUNCTION__);     \
1431     &lt->u.c; })
1432
1433 #define LANG_TYPE_PTRMEM_CHECK(NODE) __extension__              \
1434 ({  struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE);           \
1435     if (lt->u.h.is_lang_type_class)                             \
1436       lang_check_failed (__FILE__, __LINE__, __FUNCTION__);     \
1437     &lt->u.ptrmem; })
1438
1439 #else
1440
1441 #define LANG_TYPE_CLASS_CHECK(NODE) (&TYPE_LANG_SPECIFIC (NODE)->u.c)
1442 #define LANG_TYPE_PTRMEM_CHECK(NODE) (&TYPE_LANG_SPECIFIC (NODE)->u.ptrmem)
1443
1444 #endif /* ENABLE_TREE_CHECKING */
1445
1446 /* Nonzero for _CLASSTYPE means that operator delete is defined.  */
1447 #define TYPE_GETS_DELETE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->gets_delete)
1448 #define TYPE_GETS_REG_DELETE(NODE) (TYPE_GETS_DELETE (NODE) & 1)
1449
1450 /* Nonzero if `new NODE[x]' should cause the allocation of extra
1451    storage to indicate how many array elements are in use.  */
1452 #define TYPE_VEC_NEW_USES_COOKIE(NODE)                  \
1453   (CLASS_TYPE_P (NODE)                                  \
1454    && LANG_TYPE_CLASS_CHECK (NODE)->vec_new_uses_cookie)
1455
1456 /* Nonzero means that this _CLASSTYPE node defines ways of converting
1457    itself to other types.  */
1458 #define TYPE_HAS_CONVERSION(NODE) \
1459   (LANG_TYPE_CLASS_CHECK (NODE)->h.has_type_conversion)
1460
1461 /* Nonzero means that NODE (a class type) has a default constructor --
1462    but that it has not yet been declared.  */
1463 #define CLASSTYPE_LAZY_DEFAULT_CTOR(NODE) \
1464   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_default_ctor)
1465
1466 /* Nonzero means that NODE (a class type) has a copy constructor --
1467    but that it has not yet been declared.  */
1468 #define CLASSTYPE_LAZY_COPY_CTOR(NODE) \
1469   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_ctor)
1470
1471 /* Nonzero means that NODE (a class type) has a move constructor --
1472    but that it has not yet been declared.  */
1473 #define CLASSTYPE_LAZY_MOVE_CTOR(NODE) \
1474   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_move_ctor)
1475
1476 /* Nonzero means that NODE (a class type) has an assignment operator
1477    -- but that it has not yet been declared.  */
1478 #define CLASSTYPE_LAZY_COPY_ASSIGN(NODE) \
1479   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_assign)
1480
1481 /* Nonzero means that NODE (a class type) has an assignment operator
1482    -- but that it has not yet been declared.  */
1483 #define CLASSTYPE_LAZY_MOVE_ASSIGN(NODE) \
1484   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_move_assign)
1485
1486 /* Nonzero means that NODE (a class type) has a destructor -- but that
1487    it has not yet been declared.  */
1488 #define CLASSTYPE_LAZY_DESTRUCTOR(NODE) \
1489   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_destructor)
1490
1491 /* Nonzero means that NODE (a class type) is final */
1492 #define CLASSTYPE_FINAL(NODE) \
1493   (LANG_TYPE_CLASS_CHECK (NODE)->is_final)
1494
1495
1496 /* Nonzero means that this _CLASSTYPE node overloads operator=(X&).  */
1497 #define TYPE_HAS_COPY_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_copy_assign)
1498
1499 /* True iff the class type NODE has an "operator =" whose parameter
1500    has a parameter of type "const X&".  */
1501 #define TYPE_HAS_CONST_COPY_ASSIGN(NODE) \
1502   (LANG_TYPE_CLASS_CHECK (NODE)->h.has_const_copy_assign)
1503
1504 /* Nonzero means that this _CLASSTYPE node has an X(X&) constructor.  */
1505 #define TYPE_HAS_COPY_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->h.has_copy_ctor)
1506 #define TYPE_HAS_CONST_COPY_CTOR(NODE) \
1507   (LANG_TYPE_CLASS_CHECK (NODE)->has_const_copy_ctor)
1508
1509 /* Nonzero if this class has an X(initializer_list<T>) constructor.  */
1510 #define TYPE_HAS_LIST_CTOR(NODE) \
1511   (LANG_TYPE_CLASS_CHECK (NODE)->has_list_ctor)
1512
1513 /* Nonzero if this class has a constexpr constructor other than a copy/move
1514    constructor.  Note that a class can have constexpr constructors for
1515    static initialization even if it isn't a literal class.  */
1516 #define TYPE_HAS_CONSTEXPR_CTOR(NODE) \
1517   (LANG_TYPE_CLASS_CHECK (NODE)->has_constexpr_ctor)
1518
1519 /* Nonzero if this class defines an overloaded operator new.  (An
1520    operator new [] doesn't count.)  */
1521 #define TYPE_HAS_NEW_OPERATOR(NODE) \
1522   (LANG_TYPE_CLASS_CHECK (NODE)->has_new)
1523
1524 /* Nonzero if this class defines an overloaded operator new[].  */
1525 #define TYPE_HAS_ARRAY_NEW_OPERATOR(NODE) \
1526   (LANG_TYPE_CLASS_CHECK (NODE)->has_array_new)
1527
1528 /* Nonzero means that this type is being defined.  I.e., the left brace
1529    starting the definition of this type has been seen.  */
1530 #define TYPE_BEING_DEFINED(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->being_defined)
1531
1532 /* Nonzero means that this type is either complete or being defined, so we
1533    can do lookup in it.  */
1534 #define COMPLETE_OR_OPEN_TYPE_P(NODE) \
1535   (COMPLETE_TYPE_P (NODE) || (CLASS_TYPE_P (NODE) && TYPE_BEING_DEFINED (NODE)))
1536
1537 /* Mark bits for repeated base checks.  */
1538 #define TYPE_MARKED_P(NODE) TREE_LANG_FLAG_6 (TYPE_CHECK (NODE))
1539
1540 /* Nonzero if the class NODE has multiple paths to the same (virtual)
1541    base object.  */
1542 #define CLASSTYPE_DIAMOND_SHAPED_P(NODE) \
1543   (LANG_TYPE_CLASS_CHECK(NODE)->diamond_shaped)
1544
1545 /* Nonzero if the class NODE has multiple instances of the same base
1546    type.  */
1547 #define CLASSTYPE_REPEATED_BASE_P(NODE) \
1548   (LANG_TYPE_CLASS_CHECK(NODE)->repeated_base)
1549
1550 /* The member function with which the vtable will be emitted:
1551    the first noninline non-pure-virtual member function.  NULL_TREE
1552    if there is no key function or if this is a class template */
1553 #define CLASSTYPE_KEY_METHOD(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->key_method)
1554
1555 /* Vector member functions defined in this class.  Each element is
1556    either a FUNCTION_DECL, a TEMPLATE_DECL, or an OVERLOAD.  All
1557    functions with the same name end up in the same slot.  The first
1558    two elements are for constructors, and destructors, respectively.
1559    All template conversion operators to innermost template dependent
1560    types are overloaded on the next slot, if they exist.  Note, the
1561    names for these functions will not all be the same.  The
1562    non-template conversion operators & templated conversions to
1563    non-innermost template types are next, followed by ordinary member
1564    functions.  There may be empty entries at the end of the vector.
1565    The conversion operators are unsorted. The ordinary member
1566    functions are sorted, once the class is complete.  */
1567 #define CLASSTYPE_METHOD_VEC(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->methods)
1568
1569 /* For class templates, this is a TREE_LIST of all member data,
1570    functions, types, and friends in the order of declaration.
1571    The TREE_PURPOSE of each TREE_LIST is NULL_TREE for a friend,
1572    and the RECORD_TYPE for the class template otherwise.  */
1573 #define CLASSTYPE_DECL_LIST(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->decl_list)
1574
1575 /* The slot in the CLASSTYPE_METHOD_VEC where constructors go.  */
1576 #define CLASSTYPE_CONSTRUCTOR_SLOT 0
1577
1578 /* The slot in the CLASSTYPE_METHOD_VEC where destructors go.  */
1579 #define CLASSTYPE_DESTRUCTOR_SLOT 1
1580
1581 /* The first slot in the CLASSTYPE_METHOD_VEC where conversion
1582    operators can appear.  */
1583 #define CLASSTYPE_FIRST_CONVERSION_SLOT 2
1584
1585 /* A FUNCTION_DECL or OVERLOAD for the constructors for NODE.  These
1586    are the constructors that take an in-charge parameter.  */
1587 #define CLASSTYPE_CONSTRUCTORS(NODE) \
1588   (VEC_index (tree, CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_CONSTRUCTOR_SLOT))
1589
1590 /* A FUNCTION_DECL for the destructor for NODE.  These are the
1591    destructors that take an in-charge parameter.  If
1592    CLASSTYPE_LAZY_DESTRUCTOR is true, then this entry will be NULL
1593    until the destructor is created with lazily_declare_fn.  */
1594 #define CLASSTYPE_DESTRUCTORS(NODE) \
1595   (CLASSTYPE_METHOD_VEC (NODE)                                                \
1596    ? VEC_index (tree, CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_DESTRUCTOR_SLOT) \
1597    : NULL_TREE)
1598
1599 /* A dictionary of the nested user-defined-types (class-types, or enums)
1600    found within this class.  This table includes nested member class
1601    templates.  */
1602 #define CLASSTYPE_NESTED_UTDS(NODE) \
1603    (LANG_TYPE_CLASS_CHECK (NODE)->nested_udts)
1604
1605 /* Nonzero if NODE has a primary base class, i.e., a base class with
1606    which it shares the virtual function table pointer.  */
1607 #define CLASSTYPE_HAS_PRIMARY_BASE_P(NODE) \
1608   (CLASSTYPE_PRIMARY_BINFO (NODE) != NULL_TREE)
1609
1610 /* If non-NULL, this is the binfo for the primary base class, i.e.,
1611    the base class which contains the virtual function table pointer
1612    for this class.  */
1613 #define CLASSTYPE_PRIMARY_BINFO(NODE) \
1614   (LANG_TYPE_CLASS_CHECK (NODE)->primary_base)
1615
1616 /* A vector of BINFOs for the direct and indirect virtual base classes
1617    that this type uses in a post-order depth-first left-to-right
1618    order.  (In other words, these bases appear in the order that they
1619    should be initialized.)  */
1620 #define CLASSTYPE_VBASECLASSES(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->vbases)
1621
1622 /* The type corresponding to NODE when NODE is used as a base class,
1623    i.e., NODE without virtual base classes.  */
1624
1625 #define CLASSTYPE_AS_BASE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->as_base)
1626
1627 /* True iff NODE is the CLASSTYPE_AS_BASE version of some type.  */
1628
1629 #define IS_FAKE_BASE_TYPE(NODE)                                 \
1630   (TREE_CODE (NODE) == RECORD_TYPE                              \
1631    && TYPE_CONTEXT (NODE) && CLASS_TYPE_P (TYPE_CONTEXT (NODE)) \
1632    && CLASSTYPE_AS_BASE (TYPE_CONTEXT (NODE)) == (NODE))
1633
1634 /* These are the size and alignment of the type without its virtual
1635    base classes, for when we use this type as a base itself.  */
1636 #define CLASSTYPE_SIZE(NODE) TYPE_SIZE (CLASSTYPE_AS_BASE (NODE))
1637 #define CLASSTYPE_SIZE_UNIT(NODE) TYPE_SIZE_UNIT (CLASSTYPE_AS_BASE (NODE))
1638 #define CLASSTYPE_ALIGN(NODE) TYPE_ALIGN (CLASSTYPE_AS_BASE (NODE))
1639 #define CLASSTYPE_USER_ALIGN(NODE) TYPE_USER_ALIGN (CLASSTYPE_AS_BASE (NODE))
1640
1641 /* The alignment of NODE, without its virtual bases, in bytes.  */
1642 #define CLASSTYPE_ALIGN_UNIT(NODE) \
1643   (CLASSTYPE_ALIGN (NODE) / BITS_PER_UNIT)
1644
1645 /* True if this a Java interface type, declared with
1646    '__attribute__ ((java_interface))'.  */
1647 #define TYPE_JAVA_INTERFACE(NODE) \
1648   (LANG_TYPE_CLASS_CHECK (NODE)->java_interface)
1649
1650 /* A VEC(tree) of virtual functions which cannot be inherited by
1651    derived classes.  When deriving from this type, the derived
1652    class must provide its own definition for each of these functions.  */
1653 #define CLASSTYPE_PURE_VIRTUALS(NODE) \
1654   (LANG_TYPE_CLASS_CHECK (NODE)->pure_virtuals)
1655
1656 /* Nonzero means that this type has an X() constructor.  */
1657 #define TYPE_HAS_DEFAULT_CONSTRUCTOR(NODE) \
1658   (LANG_TYPE_CLASS_CHECK (NODE)->h.has_default_ctor)
1659
1660 /* Nonzero means that this type contains a mutable member.  */
1661 #define CLASSTYPE_HAS_MUTABLE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_mutable)
1662 #define TYPE_HAS_MUTABLE_P(NODE) (cp_has_mutable_p (NODE))
1663
1664 /* Nonzero means that this class type is not POD for the purpose of layout
1665    (as defined in the ABI).  This is different from the language's POD.  */
1666 #define CLASSTYPE_NON_LAYOUT_POD_P(NODE) \
1667   (LANG_TYPE_CLASS_CHECK (NODE)->non_pod_class)
1668
1669 /* Nonzero means that this class type is a non-standard-layout class.  */
1670 #define CLASSTYPE_NON_STD_LAYOUT(NODE) \
1671   (LANG_TYPE_CLASS_CHECK (NODE)->non_std_layout)
1672
1673 /* Nonzero means that this class contains pod types whose default
1674    initialization is not a zero initialization (namely, pointers to
1675    data members).  */
1676 #define CLASSTYPE_NON_ZERO_INIT_P(NODE) \
1677   (LANG_TYPE_CLASS_CHECK (NODE)->non_zero_init)
1678
1679 /* Nonzero if this class is "empty" in the sense of the C++ ABI.  */
1680 #define CLASSTYPE_EMPTY_P(NODE) \
1681   (LANG_TYPE_CLASS_CHECK (NODE)->empty_p)
1682
1683 /* Nonzero if this class is "nearly empty", i.e., contains only a
1684    virtual function table pointer.  */
1685 #define CLASSTYPE_NEARLY_EMPTY_P(NODE) \
1686   (LANG_TYPE_CLASS_CHECK (NODE)->nearly_empty_p)
1687
1688 /* Nonzero if this class contains an empty subobject.  */
1689 #define CLASSTYPE_CONTAINS_EMPTY_CLASS_P(NODE) \
1690   (LANG_TYPE_CLASS_CHECK (NODE)->contains_empty_class_p)
1691
1692 /* A list of class types of which this type is a friend.  The
1693    TREE_VALUE is normally a TYPE, but will be a TEMPLATE_DECL in the
1694    case of a template friend.  */
1695 #define CLASSTYPE_FRIEND_CLASSES(NODE) \
1696   (LANG_TYPE_CLASS_CHECK (NODE)->friend_classes)
1697
1698 /* A list of the classes which grant friendship to this class.  */
1699 #define CLASSTYPE_BEFRIENDING_CLASSES(NODE) \
1700   (LANG_TYPE_CLASS_CHECK (NODE)->befriending_classes)
1701
1702 /* The associated LAMBDA_EXPR that made this class.  */
1703 #define CLASSTYPE_LAMBDA_EXPR(NODE) \
1704   (LANG_TYPE_CLASS_CHECK (NODE)->lambda_expr)
1705 /* The extra mangling scope for this closure type.  */
1706 #define LAMBDA_TYPE_EXTRA_SCOPE(NODE) \
1707   (LAMBDA_EXPR_EXTRA_SCOPE (CLASSTYPE_LAMBDA_EXPR (NODE)))
1708
1709 /* Say whether this node was declared as a "class" or a "struct".  */
1710 #define CLASSTYPE_DECLARED_CLASS(NODE) \
1711   (LANG_TYPE_CLASS_CHECK (NODE)->declared_class)
1712
1713 /* Nonzero if this class has const members
1714    which have no specified initialization.  */
1715 #define CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE)       \
1716   (TYPE_LANG_SPECIFIC (NODE)                            \
1717    ? LANG_TYPE_CLASS_CHECK (NODE)->h.const_needs_init : 0)
1718 #define SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE, VALUE) \
1719   (LANG_TYPE_CLASS_CHECK (NODE)->h.const_needs_init = (VALUE))
1720
1721 /* Nonzero if this class has ref members
1722    which have no specified initialization.  */
1723 #define CLASSTYPE_REF_FIELDS_NEED_INIT(NODE)            \
1724   (TYPE_LANG_SPECIFIC (NODE)                            \
1725    ? LANG_TYPE_CLASS_CHECK (NODE)->h.ref_needs_init : 0)
1726 #define SET_CLASSTYPE_REF_FIELDS_NEED_INIT(NODE, VALUE) \
1727   (LANG_TYPE_CLASS_CHECK (NODE)->h.ref_needs_init = (VALUE))
1728
1729 /* Nonzero if this class is included from a header file which employs
1730    `#pragma interface', and it is not included in its implementation file.  */
1731 #define CLASSTYPE_INTERFACE_ONLY(NODE) \
1732   (LANG_TYPE_CLASS_CHECK (NODE)->interface_only)
1733
1734 /* True if we have already determined whether or not vtables, VTTs,
1735    typeinfo, and other similar per-class data should be emitted in
1736    this translation unit.  This flag does not indicate whether or not
1737    these items should be emitted; it only indicates that we know one
1738    way or the other.  */
1739 #define CLASSTYPE_INTERFACE_KNOWN(NODE) \
1740   (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown == 0)
1741 /* The opposite of CLASSTYPE_INTERFACE_KNOWN.  */
1742 #define CLASSTYPE_INTERFACE_UNKNOWN(NODE) \
1743   (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown)
1744
1745 #define SET_CLASSTYPE_INTERFACE_UNKNOWN_X(NODE,X) \
1746   (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = !!(X))
1747 #define SET_CLASSTYPE_INTERFACE_UNKNOWN(NODE) \
1748   (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 1)
1749 #define SET_CLASSTYPE_INTERFACE_KNOWN(NODE) \
1750   (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 0)
1751
1752 /* Nonzero if a _DECL node requires us to output debug info for this class.  */
1753 #define CLASSTYPE_DEBUG_REQUESTED(NODE) \
1754   (LANG_TYPE_CLASS_CHECK (NODE)->debug_requested)
1755 \f
1756 /* Additional macros for inheritance information.  */
1757
1758 /* Nonzero means that this class is on a path leading to a new vtable.  */
1759 #define BINFO_VTABLE_PATH_MARKED(NODE) BINFO_FLAG_1 (NODE)
1760
1761 /* Nonzero means B (a BINFO) has its own vtable.  Any copies will not
1762    have this flag set.  */
1763 #define BINFO_NEW_VTABLE_MARKED(B) (BINFO_FLAG_2 (B))
1764
1765 /* Compare a BINFO_TYPE with another type for equality.  For a binfo,
1766    this is functionally equivalent to using same_type_p, but
1767    measurably faster.  At least one of the arguments must be a
1768    BINFO_TYPE.  The other can be a BINFO_TYPE or a regular type.  If
1769    BINFO_TYPE(T) ever stops being the main variant of the class the
1770    binfo is for, this macro must change.  */
1771 #define SAME_BINFO_TYPE_P(A, B) ((A) == (B))
1772
1773 /* Any subobject that needs a new vtable must have a vptr and must not
1774    be a non-virtual primary base (since it would then use the vtable from a
1775    derived class and never become non-primary.)  */
1776 #define SET_BINFO_NEW_VTABLE_MARKED(B)                                   \
1777   (BINFO_NEW_VTABLE_MARKED (B) = 1,                                      \
1778    gcc_assert (!BINFO_PRIMARY_P (B) || BINFO_VIRTUAL_P (B)),             \
1779    gcc_assert (TYPE_VFIELD (BINFO_TYPE (B))))
1780
1781 /* Nonzero if this binfo is for a dependent base - one that should not
1782    be searched.  */
1783 #define BINFO_DEPENDENT_BASE_P(NODE) BINFO_FLAG_3 (NODE)
1784
1785 /* Nonzero if this binfo has lost its primary base binfo (because that
1786    is a nearly-empty virtual base that has been taken by some other
1787    base in the complete hierarchy.  */
1788 #define BINFO_LOST_PRIMARY_P(NODE) BINFO_FLAG_4 (NODE)
1789
1790 /* Nonzero if this BINFO is a primary base class.  */
1791 #define BINFO_PRIMARY_P(NODE) BINFO_FLAG_5(NODE)
1792
1793 /* Used by various search routines.  */
1794 #define IDENTIFIER_MARKED(NODE) TREE_LANG_FLAG_0 (NODE)
1795 \f
1796 /* A VEC(tree_pair_s) of the vcall indices associated with the class
1797    NODE.  The PURPOSE of each element is a FUNCTION_DECL for a virtual
1798    function.  The VALUE is the index into the virtual table where the
1799    vcall offset for that function is stored, when NODE is a virtual
1800    base.  */
1801 #define CLASSTYPE_VCALL_INDICES(NODE) \
1802   (LANG_TYPE_CLASS_CHECK (NODE)->vcall_indices)
1803
1804 /* The various vtables for the class NODE.  The primary vtable will be
1805    first, followed by the construction vtables and VTT, if any.  */
1806 #define CLASSTYPE_VTABLES(NODE) \
1807   (LANG_TYPE_CLASS_CHECK (NODE)->vtables)
1808
1809 /* The std::type_info variable representing this class, or NULL if no
1810    such variable has been created.  This field is only set for the
1811    TYPE_MAIN_VARIANT of the class.  */
1812 #define CLASSTYPE_TYPEINFO_VAR(NODE) \
1813   (LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var)
1814
1815 /* Accessor macros for the BINFO_VIRTUALS list.  */
1816
1817 /* The number of bytes by which to adjust the `this' pointer when
1818    calling this virtual function.  Subtract this value from the this
1819    pointer. Always non-NULL, might be constant zero though.  */
1820 #define BV_DELTA(NODE) (TREE_PURPOSE (NODE))
1821
1822 /* If non-NULL, the vtable index at which to find the vcall offset
1823    when calling this virtual function.  Add the value at that vtable
1824    index to the this pointer.  */
1825 #define BV_VCALL_INDEX(NODE) (TREE_TYPE (NODE))
1826
1827 /* The function to call.  */
1828 #define BV_FN(NODE) (TREE_VALUE (NODE))
1829
1830 /* Whether or not this entry is for a lost primary virtual base.  */
1831 #define BV_LOST_PRIMARY(NODE) (TREE_LANG_FLAG_0 (NODE))
1832 \f
1833 /* For FUNCTION_TYPE or METHOD_TYPE, a list of the exceptions that
1834    this type can raise.  Each TREE_VALUE is a _TYPE.  The TREE_VALUE
1835    will be NULL_TREE to indicate a throw specification of `()', or
1836    no exceptions allowed.  For a noexcept specification, TREE_VALUE
1837    is NULL_TREE and TREE_PURPOSE is the constant-expression.  For
1838    a deferred noexcept-specification, TREE_PURPOSE is a DEFERRED_NOEXCEPT
1839    (for templates) or an OVERLOAD list of functions (for implicitly
1840    declared functions).  */
1841 #define TYPE_RAISES_EXCEPTIONS(NODE) TYPE_LANG_SLOT_1 (NODE)
1842
1843 /* For FUNCTION_TYPE or METHOD_TYPE, return 1 iff it is declared `throw()'
1844    or noexcept(true).  */
1845 #define TYPE_NOTHROW_P(NODE) nothrow_spec_p (TYPE_RAISES_EXCEPTIONS (NODE))
1846
1847 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept.  This is the
1848    case for things declared noexcept(true) and, with -fnothrow-opt, for
1849    throw() functions.  */
1850 #define TYPE_NOEXCEPT_P(NODE) type_noexcept_p (NODE)
1851
1852 /* The binding level associated with the namespace.  */
1853 #define NAMESPACE_LEVEL(NODE) \
1854   (LANG_DECL_NS_CHECK (NODE)->level)
1855 \f
1856 /* Flags shared by all forms of DECL_LANG_SPECIFIC.
1857
1858    Some of the flags live here only to make lang_decl_min/fn smaller.  Do
1859    not make this struct larger than 32 bits; instead, make sel smaller.  */
1860
1861 struct GTY(()) lang_decl_base {
1862   unsigned selector : 16;   /* Larger than necessary for faster access.  */
1863   ENUM_BITFIELD(languages) language : 4;
1864   unsigned use_template : 2;
1865   unsigned not_really_extern : 1;          /* var or fn */
1866   unsigned initialized_in_class : 1;       /* var or fn */
1867   unsigned repo_available_p : 1;           /* var or fn */
1868   unsigned threadprivate_or_deleted_p : 1; /* var or fn */
1869   unsigned anticipated_p : 1;              /* fn or type */
1870   unsigned friend_attr : 1;                /* fn or type */
1871   unsigned template_conv_p : 1;            /* var or template */
1872   unsigned odr_used : 1;                   /* var or fn */
1873   unsigned u2sel : 1;
1874   /* 1 spare bit */
1875 };
1876
1877 /* True for DECL codes which have template info and access.  */
1878 #define LANG_DECL_HAS_MIN(NODE)                 \
1879   (TREE_CODE (NODE) == FUNCTION_DECL            \
1880    || TREE_CODE (NODE) == FIELD_DECL            \
1881    || TREE_CODE (NODE) == VAR_DECL              \
1882    || TREE_CODE (NODE) == CONST_DECL            \
1883    || TREE_CODE (NODE) == TYPE_DECL             \
1884    || TREE_CODE (NODE) == TEMPLATE_DECL         \
1885    || TREE_CODE (NODE) == USING_DECL)
1886
1887 /* DECL_LANG_SPECIFIC for the above codes.  */
1888
1889 struct GTY(()) lang_decl_min {
1890   struct lang_decl_base base;
1891
1892   /* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is
1893      THUNK_ALIAS.
1894      In a FUNCTION_DECL for which DECL_THUNK_P does not hold,
1895      VAR_DECL, TYPE_DECL, or TEMPLATE_DECL, this is
1896      DECL_TEMPLATE_INFO.  */
1897   tree template_info;
1898
1899   union lang_decl_u2 {
1900     /* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is
1901        THUNK_VIRTUAL_OFFSET.
1902        Otherwise this is DECL_ACCESS.  */
1903     tree GTY ((tag ("0"))) access;
1904
1905     /* For VAR_DECL in function, this is DECL_DISCRIMINATOR.  */
1906     int GTY ((tag ("1"))) discriminator;
1907   } GTY ((desc ("%0.u.base.u2sel"))) u2;
1908 };
1909
1910 /* Additional DECL_LANG_SPECIFIC information for functions.  */
1911
1912 struct GTY(()) lang_decl_fn {
1913   struct lang_decl_min min;
1914
1915   /* In an overloaded operator, this is the value of
1916      DECL_OVERLOADED_OPERATOR_P.  */
1917   ENUM_BITFIELD (tree_code) operator_code : 16;
1918
1919   unsigned global_ctor_p : 1;
1920   unsigned global_dtor_p : 1;
1921   unsigned constructor_attr : 1;
1922   unsigned destructor_attr : 1;
1923   unsigned assignment_operator_p : 1;
1924   unsigned static_function : 1;
1925   unsigned pure_virtual : 1;
1926   unsigned defaulted_p : 1;
1927
1928   unsigned has_in_charge_parm_p : 1;
1929   unsigned has_vtt_parm_p : 1;
1930   unsigned pending_inline_p : 1;
1931   unsigned nonconverting : 1;
1932   unsigned thunk_p : 1;
1933   unsigned this_thunk_p : 1;
1934   unsigned hidden_friend_p : 1;
1935   /* 1 spare bit.  */
1936
1937   /* For a non-thunk function decl, this is a tree list of
1938      friendly classes. For a thunk function decl, it is the
1939      thunked to function decl.  */
1940   tree befriending_classes;
1941
1942   /* For a non-virtual FUNCTION_DECL, this is
1943      DECL_FRIEND_CONTEXT.  For a virtual FUNCTION_DECL for which
1944      DECL_THIS_THUNK_P does not hold, this is DECL_THUNKS. Both
1945      this pointer and result pointer adjusting thunks are
1946      chained here.  This pointer thunks to return pointer thunks
1947      will be chained on the return pointer thunk.  */
1948   tree context;
1949
1950   union lang_decl_u5
1951   {
1952     /* In a non-thunk FUNCTION_DECL or TEMPLATE_DECL, this is
1953        DECL_CLONED_FUNCTION.  */
1954     tree GTY ((tag ("0"))) cloned_function;
1955
1956     /* In a FUNCTION_DECL for which THUNK_P holds this is the
1957        THUNK_FIXED_OFFSET.  */
1958     HOST_WIDE_INT GTY ((tag ("1"))) fixed_offset;
1959   } GTY ((desc ("%1.thunk_p"))) u5;
1960
1961   union lang_decl_u3
1962   {
1963     struct cp_token_cache * GTY ((tag ("1"))) pending_inline_info;
1964     struct language_function * GTY ((tag ("0")))
1965       saved_language_function;
1966   } GTY ((desc ("%1.pending_inline_p"))) u;
1967
1968 };
1969
1970 /* DECL_LANG_SPECIFIC for namespaces.  */
1971
1972 struct GTY(()) lang_decl_ns {
1973   struct lang_decl_base base;
1974   cp_binding_level *level;
1975 };
1976
1977 /* DECL_LANG_SPECIFIC for parameters.  */
1978
1979 struct GTY(()) lang_decl_parm {
1980   struct lang_decl_base base;
1981   int level;
1982   int index;
1983 };
1984
1985 /* DECL_LANG_SPECIFIC for all types.  It would be nice to just make this a
1986    union rather than a struct containing a union as its only field, but
1987    tree.h declares it as a struct.  */
1988
1989 struct GTY((variable_size)) lang_decl {
1990   union GTY((desc ("%h.base.selector"))) lang_decl_u {
1991     struct lang_decl_base GTY ((default)) base;
1992     struct lang_decl_min GTY((tag ("0"))) min;
1993     struct lang_decl_fn GTY ((tag ("1"))) fn;
1994     struct lang_decl_ns GTY((tag ("2"))) ns;
1995     struct lang_decl_parm GTY((tag ("3"))) parm;
1996   } u;
1997 };
1998
1999 /* Looks through a template (if present) to find what it declares.  */
2000 #define STRIP_TEMPLATE(NODE) \
2001   (TREE_CODE (NODE) == TEMPLATE_DECL ? DECL_TEMPLATE_RESULT (NODE) : NODE)
2002
2003 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
2004
2005 #define LANG_DECL_MIN_CHECK(NODE) __extension__                 \
2006 ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE);            \
2007    if (!LANG_DECL_HAS_MIN (NODE))                               \
2008      lang_check_failed (__FILE__, __LINE__, __FUNCTION__);      \
2009    &lt->u.min; })
2010
2011 /* We want to be able to check DECL_CONSTRUCTOR_P and such on a function
2012    template, not just on a FUNCTION_DECL.  So when looking for things in
2013    lang_decl_fn, look down through a TEMPLATE_DECL into its result.  */
2014 #define LANG_DECL_FN_CHECK(NODE) __extension__                          \
2015 ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (STRIP_TEMPLATE (NODE));   \
2016    if (!DECL_DECLARES_FUNCTION_P (NODE) || lt->u.base.selector != 1)    \
2017      lang_check_failed (__FILE__, __LINE__, __FUNCTION__);              \
2018    &lt->u.fn; })
2019
2020 #define LANG_DECL_NS_CHECK(NODE) __extension__                          \
2021 ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE);                    \
2022    if (TREE_CODE (NODE) != NAMESPACE_DECL || lt->u.base.selector != 2)  \
2023      lang_check_failed (__FILE__, __LINE__, __FUNCTION__);              \
2024    &lt->u.ns; })
2025
2026 #define LANG_DECL_PARM_CHECK(NODE) __extension__                \
2027 ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE);            \
2028   if (TREE_CODE (NODE) != PARM_DECL)                            \
2029     lang_check_failed (__FILE__, __LINE__, __FUNCTION__);       \
2030   &lt->u.parm; })
2031
2032 #define LANG_DECL_U2_CHECK(NODE, TF) __extension__              \
2033 ({  struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE);           \
2034     if (!LANG_DECL_HAS_MIN (NODE) || lt->u.base.u2sel != TF)    \
2035       lang_check_failed (__FILE__, __LINE__, __FUNCTION__);     \
2036     &lt->u.min.u2; })
2037
2038 #else
2039
2040 #define LANG_DECL_MIN_CHECK(NODE) \
2041   (&DECL_LANG_SPECIFIC (NODE)->u.min)
2042
2043 #define LANG_DECL_FN_CHECK(NODE) \
2044   (&DECL_LANG_SPECIFIC (STRIP_TEMPLATE (NODE))->u.fn)
2045
2046 #define LANG_DECL_NS_CHECK(NODE) \
2047   (&DECL_LANG_SPECIFIC (NODE)->u.ns)
2048
2049 #define LANG_DECL_PARM_CHECK(NODE) \
2050   (&DECL_LANG_SPECIFIC (NODE)->u.parm)
2051
2052 #define LANG_DECL_U2_CHECK(NODE, TF) \
2053   (&DECL_LANG_SPECIFIC (NODE)->u.min.u2)
2054
2055 #endif /* ENABLE_TREE_CHECKING */
2056
2057 /* For a FUNCTION_DECL or a VAR_DECL, the language linkage for the
2058    declaration.  Some entities (like a member function in a local
2059    class, or a local variable) do not have linkage at all, and this
2060    macro should not be used in those cases.
2061
2062    Implementation note: A FUNCTION_DECL without DECL_LANG_SPECIFIC was
2063    created by language-independent code, and has C linkage.  Most
2064    VAR_DECLs have C++ linkage, and do not have DECL_LANG_SPECIFIC, but
2065    we do create DECL_LANG_SPECIFIC for variables with non-C++ linkage.  */
2066 #define DECL_LANGUAGE(NODE)                             \
2067   (DECL_LANG_SPECIFIC (NODE)                            \
2068    ? DECL_LANG_SPECIFIC (NODE)->u.base.language         \
2069    : (TREE_CODE (NODE) == FUNCTION_DECL                 \
2070       ? lang_c : lang_cplusplus))
2071
2072 /* Set the language linkage for NODE to LANGUAGE.  */
2073 #define SET_DECL_LANGUAGE(NODE, LANGUAGE) \
2074   (DECL_LANG_SPECIFIC (NODE)->u.base.language = (LANGUAGE))
2075
2076 /* For FUNCTION_DECLs: nonzero means that this function is a constructor.  */
2077 #define DECL_CONSTRUCTOR_P(NODE) \
2078   (LANG_DECL_FN_CHECK (NODE)->constructor_attr)
2079
2080 /* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a complete
2081    object.  */
2082 #define DECL_COMPLETE_CONSTRUCTOR_P(NODE)               \
2083   (DECL_CONSTRUCTOR_P (NODE)                            \
2084    && DECL_NAME (NODE) == complete_ctor_identifier)
2085
2086 /* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a base
2087    object.  */
2088 #define DECL_BASE_CONSTRUCTOR_P(NODE)           \
2089   (DECL_CONSTRUCTOR_P (NODE)                    \
2090    && DECL_NAME (NODE) == base_ctor_identifier)
2091
2092 /* Nonzero if NODE (a FUNCTION_DECL) is a constructor, but not either the
2093    specialized in-charge constructor or the specialized not-in-charge
2094    constructor.  */
2095 #define DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P(NODE)                \
2096   (DECL_DECLARES_FUNCTION_P (NODE) && DECL_CONSTRUCTOR_P (NODE) \
2097    && !DECL_CLONED_FUNCTION_P (NODE))
2098
2099 /* Nonzero if NODE (a FUNCTION_DECL) is a copy constructor.  */
2100 #define DECL_COPY_CONSTRUCTOR_P(NODE) \
2101   (DECL_CONSTRUCTOR_P (NODE) && copy_fn_p (NODE) > 0)
2102
2103 /* Nonzero if NODE (a FUNCTION_DECL) is a move constructor.  */
2104 #define DECL_MOVE_CONSTRUCTOR_P(NODE) \
2105   (DECL_CONSTRUCTOR_P (NODE) && move_fn_p (NODE))
2106
2107 /* Nonzero if NODE is a destructor.  */
2108 #define DECL_DESTRUCTOR_P(NODE)                         \
2109   (LANG_DECL_FN_CHECK (NODE)->destructor_attr)
2110
2111 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor, but not the
2112    specialized in-charge constructor, in-charge deleting constructor,
2113    or the base destructor.  */
2114 #define DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P(NODE)                 \
2115   (DECL_DECLARES_FUNCTION_P (NODE) && DECL_DESTRUCTOR_P (NODE)  \
2116    && !DECL_CLONED_FUNCTION_P (NODE))
2117
2118 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete
2119    object.  */
2120 #define DECL_COMPLETE_DESTRUCTOR_P(NODE)                \
2121   (DECL_DESTRUCTOR_P (NODE)                             \
2122    && DECL_NAME (NODE) == complete_dtor_identifier)
2123
2124 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a base
2125    object.  */
2126 #define DECL_BASE_DESTRUCTOR_P(NODE)            \
2127   (DECL_DESTRUCTOR_P (NODE)                     \
2128    && DECL_NAME (NODE) == base_dtor_identifier)
2129
2130 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete
2131    object that deletes the object after it has been destroyed.  */
2132 #define DECL_DELETING_DESTRUCTOR_P(NODE)                \
2133   (DECL_DESTRUCTOR_P (NODE)                             \
2134    && DECL_NAME (NODE) == deleting_dtor_identifier)
2135
2136 /* Nonzero if NODE (a FUNCTION_DECL) is a cloned constructor or
2137    destructor.  */
2138 #define DECL_CLONED_FUNCTION_P(NODE) (!!decl_cloned_function_p (NODE, true))
2139
2140 /* If DECL_CLONED_FUNCTION_P holds, this is the function that was
2141    cloned.  */
2142 #define DECL_CLONED_FUNCTION(NODE) (*decl_cloned_function_p (NODE, false))
2143
2144 /* Perform an action for each clone of FN, if FN is a function with
2145    clones.  This macro should be used like:
2146
2147       FOR_EACH_CLONE (clone, fn)
2148         { ... }
2149
2150   */
2151 #define FOR_EACH_CLONE(CLONE, FN)                       \
2152   if (TREE_CODE (FN) == FUNCTION_DECL                   \
2153       && (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (FN)       \
2154           || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (FN)))   \
2155      for (CLONE = DECL_CHAIN (FN);                      \
2156           CLONE && DECL_CLONED_FUNCTION_P (CLONE);      \
2157           CLONE = DECL_CHAIN (CLONE))
2158
2159 /* Nonzero if NODE has DECL_DISCRIMINATOR and not DECL_ACCESS.  */
2160 #define DECL_DISCRIMINATOR_P(NODE)      \
2161   (TREE_CODE (NODE) == VAR_DECL         \
2162    && DECL_FUNCTION_SCOPE_P (NODE))
2163
2164 /* Discriminator for name mangling.  */
2165 #define DECL_DISCRIMINATOR(NODE) (LANG_DECL_U2_CHECK (NODE, 1)->discriminator)
2166
2167 /* True iff DECL_DISCRIMINATOR is set for a DECL_DISCRIMINATOR_P decl.  */
2168 #define DECL_DISCRIMINATOR_SET_P(NODE) \
2169   (DECL_LANG_SPECIFIC (NODE) && DECL_LANG_SPECIFIC (NODE)->u.base.u2sel == 1)
2170
2171 /* The index of a user-declared parameter in its function, starting at 1.
2172    All artificial parameters will have index 0.  */
2173 #define DECL_PARM_INDEX(NODE) \
2174   (LANG_DECL_PARM_CHECK (NODE)->index)
2175
2176 /* The level of a user-declared parameter in its function, starting at 1.
2177    A parameter of the function will have level 1; a parameter of the first
2178    nested function declarator (i.e. t in void f (void (*p)(T t))) will have
2179    level 2.  */
2180 #define DECL_PARM_LEVEL(NODE) \
2181   (LANG_DECL_PARM_CHECK (NODE)->level)
2182
2183 /* Nonzero if the VTT parm has been added to NODE.  */
2184 #define DECL_HAS_VTT_PARM_P(NODE) \
2185   (LANG_DECL_FN_CHECK (NODE)->has_vtt_parm_p)
2186
2187 /* Nonzero if NODE is a FUNCTION_DECL for which a VTT parameter is
2188    required.  */
2189 #define DECL_NEEDS_VTT_PARM_P(NODE)                     \
2190   (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (NODE))         \
2191    && (DECL_BASE_CONSTRUCTOR_P (NODE)                   \
2192        || DECL_BASE_DESTRUCTOR_P (NODE)))
2193
2194 /* Nonzero if NODE is a user-defined conversion operator.  */
2195 #define DECL_CONV_FN_P(NODE) \
2196   (DECL_NAME (NODE) && IDENTIFIER_TYPENAME_P (DECL_NAME (NODE)))
2197
2198 /* If FN is a conversion operator, the type to which it converts.
2199    Otherwise, NULL_TREE.  */
2200 #define DECL_CONV_FN_TYPE(FN) \
2201   (DECL_CONV_FN_P (FN) ? TREE_TYPE (DECL_NAME (FN)) : NULL_TREE)
2202
2203 /* Nonzero if NODE, which is a TEMPLATE_DECL, is a template
2204    conversion operator to a type dependent on the innermost template
2205    args.  */
2206 #define DECL_TEMPLATE_CONV_FN_P(NODE) \
2207   (DECL_LANG_SPECIFIC (TEMPLATE_DECL_CHECK (NODE))->u.base.template_conv_p)
2208
2209 /* Nonzero if NODE, a static data member, was declared in its class as an
2210    array of unknown bound.  */
2211 #define VAR_HAD_UNKNOWN_BOUND(NODE)                     \
2212   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))           \
2213    ? DECL_LANG_SPECIFIC (NODE)->u.base.template_conv_p  \
2214    : false)
2215 #define SET_VAR_HAD_UNKNOWN_BOUND(NODE) \
2216   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.template_conv_p = true)
2217
2218 /* Set the overloaded operator code for NODE to CODE.  */
2219 #define SET_OVERLOADED_OPERATOR_CODE(NODE, CODE) \
2220   (LANG_DECL_FN_CHECK (NODE)->operator_code = (CODE))
2221
2222 /* If NODE is an overloaded operator, then this returns the TREE_CODE
2223    associated with the overloaded operator.
2224    DECL_ASSIGNMENT_OPERATOR_P must also be checked to determine
2225    whether or not NODE is an assignment operator.  If NODE is not an
2226    overloaded operator, ERROR_MARK is returned.  Since the numerical
2227    value of ERROR_MARK is zero, this macro can be used as a predicate
2228    to test whether or not NODE is an overloaded operator.  */
2229 #define DECL_OVERLOADED_OPERATOR_P(NODE)                \
2230   (IDENTIFIER_OPNAME_P (DECL_NAME (NODE))               \
2231    ? LANG_DECL_FN_CHECK (NODE)->operator_code : ERROR_MARK)
2232
2233 /* Nonzero if NODE is an assignment operator (including += and such).  */
2234 #define DECL_ASSIGNMENT_OPERATOR_P(NODE) \
2235   (LANG_DECL_FN_CHECK (NODE)->assignment_operator_p)
2236
2237 /* For FUNCTION_DECLs: nonzero means that this function is a
2238    constructor or a destructor with an extra in-charge parameter to
2239    control whether or not virtual bases are constructed.  */
2240 #define DECL_HAS_IN_CHARGE_PARM_P(NODE) \
2241   (LANG_DECL_FN_CHECK (NODE)->has_in_charge_parm_p)
2242
2243 /* Nonzero if DECL is a declaration of __builtin_constant_p.  */
2244 #define DECL_IS_BUILTIN_CONSTANT_P(NODE)                \
2245  (TREE_CODE (NODE) == FUNCTION_DECL                     \
2246   && DECL_BUILT_IN_CLASS (NODE) == BUILT_IN_NORMAL      \
2247   && DECL_FUNCTION_CODE (NODE) == BUILT_IN_CONSTANT_P)
2248
2249 /* Nonzero for _DECL means that this decl appears in (or will appear
2250    in) as a member in a RECORD_TYPE or UNION_TYPE node.  It is also for
2251    detecting circularity in case members are multiply defined.  In the
2252    case of a VAR_DECL, it is also used to determine how program storage
2253    should be allocated.  */
2254 #define DECL_IN_AGGR_P(NODE) (DECL_LANG_FLAG_3 (NODE))
2255
2256 /* Nonzero for a VAR_DECL means that the variable's initialization (if
2257    any) has been processed.  (In general, DECL_INITIALIZED_P is
2258    !DECL_EXTERN, but static data members may be initialized even if
2259    not defined.)  */
2260 #define DECL_INITIALIZED_P(NODE) \
2261    (TREE_LANG_FLAG_1 (VAR_DECL_CHECK (NODE)))
2262
2263 /* Nonzero for a VAR_DECL iff an explicit initializer was provided.  */
2264 #define DECL_NONTRIVIALLY_INITIALIZED_P(NODE)   \
2265    (TREE_LANG_FLAG_3 (VAR_DECL_CHECK (NODE)))
2266
2267 /* Nonzero for a VAR_DECL that was initialized with a
2268    constant-expression.  */
2269 #define DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P(NODE) \
2270   (TREE_LANG_FLAG_2 (VAR_DECL_CHECK (NODE)))
2271
2272 /* Nonzero if the DECL was initialized in the class definition itself,
2273    rather than outside the class.  This is used for both static member
2274    VAR_DECLS, and FUNCTION_DECLS that are defined in the class.  */
2275 #define DECL_INITIALIZED_IN_CLASS_P(DECL) \
2276   (DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL)) \
2277    ->u.base.initialized_in_class)
2278
2279 /* Nonzero if the DECL is used in the sense of 3.2 [basic.def.odr].
2280    Only available for decls with DECL_LANG_SPECIFIC.  */
2281 #define DECL_ODR_USED(DECL) \
2282   (DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL)) \
2283    ->u.base.odr_used)
2284
2285 /* Nonzero for DECL means that this decl is just a friend declaration,
2286    and should not be added to the list of members for this class.  */
2287 #define DECL_FRIEND_P(NODE) (DECL_LANG_SPECIFIC (NODE)->u.base.friend_attr)
2288
2289 /* A TREE_LIST of the types which have befriended this FUNCTION_DECL.  */
2290 #define DECL_BEFRIENDING_CLASSES(NODE) \
2291   (LANG_DECL_FN_CHECK (NODE)->befriending_classes)
2292
2293 /* Nonzero for FUNCTION_DECL means that this decl is a static
2294    member function.  */
2295 #define DECL_STATIC_FUNCTION_P(NODE) \
2296   (LANG_DECL_FN_CHECK (NODE)->static_function)
2297
2298 /* Nonzero for FUNCTION_DECL means that this decl is a non-static
2299    member function.  */
2300 #define DECL_NONSTATIC_MEMBER_FUNCTION_P(NODE) \
2301   (TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE)
2302
2303 /* Nonzero for FUNCTION_DECL means that this decl is a member function
2304    (static or non-static).  */
2305 #define DECL_FUNCTION_MEMBER_P(NODE) \
2306   (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) || DECL_STATIC_FUNCTION_P (NODE))
2307
2308 /* Nonzero for FUNCTION_DECL means that this member function
2309    has `this' as const X *const.  */
2310 #define DECL_CONST_MEMFUNC_P(NODE)                                       \
2311   (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE)                               \
2312    && CP_TYPE_CONST_P (TREE_TYPE (TREE_VALUE                             \
2313                                   (TYPE_ARG_TYPES (TREE_TYPE (NODE))))))
2314
2315 /* Nonzero for FUNCTION_DECL means that this member function
2316    has `this' as volatile X *const.  */
2317 #define DECL_VOLATILE_MEMFUNC_P(NODE)                                    \
2318   (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE)                               \
2319    && CP_TYPE_VOLATILE_P (TREE_TYPE (TREE_VALUE                          \
2320                                   (TYPE_ARG_TYPES (TREE_TYPE (NODE))))))
2321
2322 /* Nonzero for a DECL means that this member is a non-static member.  */
2323 #define DECL_NONSTATIC_MEMBER_P(NODE)           \
2324   (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE)      \
2325    || TREE_CODE (NODE) == FIELD_DECL)
2326
2327 /* Nonzero for _DECL means that this member object type
2328    is mutable.  */
2329 #define DECL_MUTABLE_P(NODE) (DECL_LANG_FLAG_0 (NODE))
2330
2331 /* Nonzero for _DECL means that this constructor or conversion function is
2332    non-converting.  */
2333 #define DECL_NONCONVERTING_P(NODE) \
2334   (LANG_DECL_FN_CHECK (NODE)->nonconverting)
2335
2336 /* Nonzero for FUNCTION_DECL means that this member function is a pure
2337    virtual function.  */
2338 #define DECL_PURE_VIRTUAL_P(NODE) \
2339   (LANG_DECL_FN_CHECK (NODE)->pure_virtual)
2340
2341 /* True (in a FUNCTION_DECL) if NODE is a virtual function that is an
2342    invalid overrider for a function from a base class.  Once we have
2343    complained about an invalid overrider we avoid complaining about it
2344    again.  */
2345 #define DECL_INVALID_OVERRIDER_P(NODE) \
2346   (DECL_LANG_FLAG_4 (NODE))
2347
2348 /* True (in a FUNCTION_DECL) if NODE is a function declared with
2349    an override virt-specifier */
2350 #define DECL_OVERRIDE_P(NODE) (TREE_LANG_FLAG_0 (NODE))
2351
2352 /* True (in a FUNCTION_DECL) if NODE is a function declared with
2353    a final virt-specifier */
2354 #define DECL_FINAL_P(NODE) (TREE_LANG_FLAG_1 (NODE))
2355
2356 /* The thunks associated with NODE, a FUNCTION_DECL.  */
2357 #define DECL_THUNKS(NODE) \
2358   (LANG_DECL_FN_CHECK (NODE)->context)
2359
2360 /* Nonzero if NODE is a thunk, rather than an ordinary function.  */
2361 #define DECL_THUNK_P(NODE)                      \
2362   (TREE_CODE (NODE) == FUNCTION_DECL            \
2363    && DECL_LANG_SPECIFIC (NODE)                 \
2364    && LANG_DECL_FN_CHECK (NODE)->thunk_p)
2365
2366 /* Set DECL_THUNK_P for node.  */
2367 #define SET_DECL_THUNK_P(NODE, THIS_ADJUSTING)                  \
2368   (LANG_DECL_FN_CHECK (NODE)->thunk_p = 1,                      \
2369    LANG_DECL_FN_CHECK (NODE)->this_thunk_p = (THIS_ADJUSTING))
2370
2371 /* Nonzero if NODE is a this pointer adjusting thunk.  */
2372 #define DECL_THIS_THUNK_P(NODE)                 \
2373   (DECL_THUNK_P (NODE) && LANG_DECL_FN_CHECK (NODE)->this_thunk_p)
2374
2375 /* Nonzero if NODE is a result pointer adjusting thunk.  */
2376 #define DECL_RESULT_THUNK_P(NODE)                       \
2377   (DECL_THUNK_P (NODE) && !LANG_DECL_FN_CHECK (NODE)->this_thunk_p)
2378
2379 /* Nonzero if NODE is a FUNCTION_DECL, but not a thunk.  */
2380 #define DECL_NON_THUNK_FUNCTION_P(NODE)                         \
2381   (TREE_CODE (NODE) == FUNCTION_DECL && !DECL_THUNK_P (NODE))
2382
2383 /* Nonzero if NODE is `extern "C"'.  */
2384 #define DECL_EXTERN_C_P(NODE) \
2385   (DECL_LANGUAGE (NODE) == lang_c)
2386
2387 /* Nonzero if NODE is an `extern "C"' function.  */
2388 #define DECL_EXTERN_C_FUNCTION_P(NODE) \
2389   (DECL_NON_THUNK_FUNCTION_P (NODE) && DECL_EXTERN_C_P (NODE))
2390
2391 /* True iff DECL is an entity with vague linkage whose definition is
2392    available in this translation unit.  */
2393 #define DECL_REPO_AVAILABLE_P(NODE) \
2394   (DECL_LANG_SPECIFIC (NODE)->u.base.repo_available_p)
2395
2396 /* True if DECL is declared 'constexpr'.  */
2397 #define DECL_DECLARED_CONSTEXPR_P(DECL) \
2398   DECL_LANG_FLAG_8 (VAR_OR_FUNCTION_DECL_CHECK (STRIP_TEMPLATE (DECL)))
2399
2400 /* Nonzero if this DECL is the __PRETTY_FUNCTION__ variable in a
2401    template function.  */
2402 #define DECL_PRETTY_FUNCTION_P(NODE) \
2403   (TREE_LANG_FLAG_0 (VAR_DECL_CHECK (NODE)))
2404
2405 /* The _TYPE context in which this _DECL appears.  This field holds the
2406    class where a virtual function instance is actually defined.  */
2407 #define DECL_CLASS_CONTEXT(NODE) \
2408   (DECL_CLASS_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : NULL_TREE)
2409
2410 /* For a non-member friend function, the class (if any) in which this
2411    friend was defined.  For example, given:
2412
2413      struct S { friend void f (); };
2414
2415    the DECL_FRIEND_CONTEXT for `f' will be `S'.  */
2416 #define DECL_FRIEND_CONTEXT(NODE)                               \
2417   ((DECL_DECLARES_FUNCTION_P (NODE)                             \
2418     && DECL_FRIEND_P (NODE) && !DECL_FUNCTION_MEMBER_P (NODE))  \
2419    ? LANG_DECL_FN_CHECK (NODE)->context                         \
2420    : NULL_TREE)
2421
2422 /* Set the DECL_FRIEND_CONTEXT for NODE to CONTEXT.  */
2423 #define SET_DECL_FRIEND_CONTEXT(NODE, CONTEXT) \
2424   (LANG_DECL_FN_CHECK (NODE)->context = (CONTEXT))
2425
2426 #define CP_DECL_CONTEXT(NODE) \
2427   (!DECL_FILE_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : global_namespace)
2428 #define CP_TYPE_CONTEXT(NODE) \
2429   (!TYPE_FILE_SCOPE_P (NODE) ? TYPE_CONTEXT (NODE) : global_namespace)
2430 #define FROB_CONTEXT(NODE) \
2431   ((NODE) == global_namespace ? DECL_CONTEXT (NODE) : (NODE))
2432
2433 /* 1 iff NODE has namespace scope, including the global namespace.  */
2434 #define DECL_NAMESPACE_SCOPE_P(NODE)                            \
2435   (!DECL_TEMPLATE_PARM_P (NODE)                                 \
2436    && TREE_CODE (CP_DECL_CONTEXT (NODE)) == NAMESPACE_DECL)
2437
2438 #define TYPE_NAMESPACE_SCOPE_P(NODE) \
2439   (TREE_CODE (CP_TYPE_CONTEXT (NODE)) == NAMESPACE_DECL)
2440
2441 #define NAMESPACE_SCOPE_P(NODE) \
2442   ((DECL_P (NODE) && DECL_NAMESPACE_SCOPE_P (NODE)) \
2443    || (TYPE_P (NODE) && TYPE_NAMESPACE_SCOPE_P (NODE)))
2444
2445 /* 1 iff NODE is a class member.  */
2446 #define DECL_CLASS_SCOPE_P(NODE) \
2447   (DECL_CONTEXT (NODE) && TYPE_P (DECL_CONTEXT (NODE)))
2448
2449 #define TYPE_CLASS_SCOPE_P(NODE) \
2450   (TYPE_CONTEXT (NODE) && TYPE_P (TYPE_CONTEXT (NODE)))
2451
2452 /* 1 iff NODE is function-local.  */
2453 #define DECL_FUNCTION_SCOPE_P(NODE) \
2454   (DECL_CONTEXT (NODE) \
2455    && TREE_CODE (DECL_CONTEXT (NODE)) == FUNCTION_DECL)
2456
2457 #define TYPE_FUNCTION_SCOPE_P(NODE) \
2458   (TYPE_CONTEXT (NODE) && TREE_CODE (TYPE_CONTEXT (NODE)) == FUNCTION_DECL)
2459
2460 /* 1 iff VAR_DECL node NODE is a type-info decl.  This flag is set for
2461    both the primary typeinfo object and the associated NTBS name.  */
2462 #define DECL_TINFO_P(NODE) TREE_LANG_FLAG_4 (VAR_DECL_CHECK (NODE))
2463
2464 /* 1 iff VAR_DECL node NODE is virtual table or VTT.  */
2465 #define DECL_VTABLE_OR_VTT_P(NODE) TREE_LANG_FLAG_5 (VAR_DECL_CHECK (NODE))
2466
2467 /* Returns 1 iff VAR_DECL is a construction virtual table.
2468    DECL_VTABLE_OR_VTT_P will be true in this case and must be checked
2469    before using this macro.  */
2470 #define DECL_CONSTRUCTION_VTABLE_P(NODE) \
2471   TREE_LANG_FLAG_6 (VAR_DECL_CHECK (NODE))
2472
2473 /* 1 iff NODE is function-local, but for types.  */
2474 #define LOCAL_CLASS_P(NODE)                             \
2475   (decl_function_context (TYPE_MAIN_DECL (NODE)) != NULL_TREE)
2476
2477 /* For a NAMESPACE_DECL: the list of using namespace directives
2478    The PURPOSE is the used namespace, the value is the namespace
2479    that is the common ancestor.  */
2480 #define DECL_NAMESPACE_USING(NODE) DECL_VINDEX (NAMESPACE_DECL_CHECK (NODE))
2481
2482 /* In a NAMESPACE_DECL, the DECL_INITIAL is used to record all users
2483    of a namespace, to record the transitive closure of using namespace.  */
2484 #define DECL_NAMESPACE_USERS(NODE) DECL_INITIAL (NAMESPACE_DECL_CHECK (NODE))
2485
2486 /* In a NAMESPACE_DECL, the list of namespaces which have associated
2487    themselves with this one.  */
2488 #define DECL_NAMESPACE_ASSOCIATIONS(NODE) \
2489   (NAMESPACE_DECL_CHECK (NODE)->decl_non_common.saved_tree)
2490
2491 /* In a NAMESPACE_DECL, points to the original namespace if this is
2492    a namespace alias.  */
2493 #define DECL_NAMESPACE_ALIAS(NODE) \
2494         DECL_ABSTRACT_ORIGIN (NAMESPACE_DECL_CHECK (NODE))
2495 #define ORIGINAL_NAMESPACE(NODE)  \
2496   (DECL_NAMESPACE_ALIAS (NODE) ? DECL_NAMESPACE_ALIAS (NODE) : (NODE))
2497
2498 /* Nonzero if NODE is the std namespace.  */
2499 #define DECL_NAMESPACE_STD_P(NODE)                      \
2500   (TREE_CODE (NODE) == NAMESPACE_DECL                   \
2501    && CP_DECL_CONTEXT (NODE) == global_namespace        \
2502    && DECL_NAME (NODE) == std_identifier)
2503
2504 /* In a TREE_LIST concatenating using directives, indicate indirect
2505    directives  */
2506 #define TREE_INDIRECT_USING(NODE) (TREE_LIST_CHECK (NODE)->base.lang_flag_0)
2507
2508 /* In a TREE_LIST in an attribute list, indicates that the attribute
2509    must be applied at instantiation time.  */
2510 #define ATTR_IS_DEPENDENT(NODE) (TREE_LIST_CHECK (NODE)->base.lang_flag_0)
2511
2512 extern tree decl_shadowed_for_var_lookup (tree);
2513 extern void decl_shadowed_for_var_insert (tree, tree);
2514
2515 /* Non zero if this is a using decl for a dependent scope. */
2516 #define DECL_DEPENDENT_P(NODE) DECL_LANG_FLAG_0 (USING_DECL_CHECK (NODE))
2517
2518 /* The scope named in a using decl.  */
2519 #define USING_DECL_SCOPE(NODE) TREE_TYPE (USING_DECL_CHECK (NODE))
2520
2521 /* The decls named by a using decl.  */
2522 #define USING_DECL_DECLS(NODE) DECL_INITIAL (USING_DECL_CHECK (NODE))
2523
2524 /* In a VAR_DECL, true if we have a shadowed local variable
2525    in the shadowed var table for this VAR_DECL.  */
2526 #define DECL_HAS_SHADOWED_FOR_VAR_P(NODE) \
2527   (VAR_DECL_CHECK (NODE)->decl_with_vis.shadowed_for_var_p)
2528
2529 /* In a VAR_DECL for a variable declared in a for statement,
2530    this is the shadowed (local) variable.  */
2531 #define DECL_SHADOWED_FOR_VAR(NODE) \
2532   (DECL_HAS_SHADOWED_FOR_VAR_P(NODE) ? decl_shadowed_for_var_lookup (NODE) : NULL)
2533
2534 #define SET_DECL_SHADOWED_FOR_VAR(NODE, VAL) \
2535   (decl_shadowed_for_var_insert (NODE, VAL))
2536
2537 /* In a FUNCTION_DECL, this is nonzero if this function was defined in
2538    the class definition.  We have saved away the text of the function,
2539    but have not yet processed it.  */
2540 #define DECL_PENDING_INLINE_P(NODE) \
2541   (LANG_DECL_FN_CHECK (NODE)->pending_inline_p)
2542
2543 /* If DECL_PENDING_INLINE_P holds, this is the saved text of the
2544    function.  */
2545 #define DECL_PENDING_INLINE_INFO(NODE) \
2546   (LANG_DECL_FN_CHECK (NODE)->u.pending_inline_info)
2547
2548 /* Nonzero for TYPE_DECL means that it was written 'using name = type'.  */
2549 #define TYPE_DECL_ALIAS_P(NODE) \
2550   DECL_LANG_FLAG_6 (TYPE_DECL_CHECK (NODE))
2551
2552 /* Nonzero for a type which is an alias for another type; i.e, a type
2553    which declaration was written 'using name-of-type =
2554    another-type'.  */
2555 #define TYPE_ALIAS_P(NODE)                      \
2556   (TYPE_P (NODE)                                \
2557    && TYPE_NAME (NODE)                          \
2558    && TREE_CODE (TYPE_NAME (NODE)) == TYPE_DECL \
2559    && TYPE_DECL_ALIAS_P (TYPE_NAME (NODE)))
2560
2561 /* For a class type: if this structure has many fields, we'll sort them
2562    and put them into a TREE_VEC.  */
2563 #define CLASSTYPE_SORTED_FIELDS(NODE) \
2564   (LANG_TYPE_CLASS_CHECK (NODE)->sorted_fields)
2565
2566 /* If non-NULL for a VAR_DECL, FUNCTION_DECL, TYPE_DECL or
2567    TEMPLATE_DECL, the entity is either a template specialization (if
2568    DECL_USE_TEMPLATE is nonzero) or the abstract instance of the
2569    template itself.
2570
2571    In either case, DECL_TEMPLATE_INFO is a TREE_LIST, whose
2572    TREE_PURPOSE is the TEMPLATE_DECL of which this entity is a
2573    specialization or abstract instance.  The TREE_VALUE is the
2574    template arguments used to specialize the template.
2575    
2576    Consider:
2577
2578       template <typename T> struct S { friend void f(T) {} };
2579
2580    In this case, S<int>::f is, from the point of view of the compiler,
2581    an instantiation of a template -- but, from the point of view of
2582    the language, each instantiation of S results in a wholly unrelated
2583    global function f.  In this case, DECL_TEMPLATE_INFO for S<int>::f
2584    will be non-NULL, but DECL_USE_TEMPLATE will be zero.  */
2585 #define DECL_TEMPLATE_INFO(NODE) \
2586   (DECL_LANG_SPECIFIC (VAR_TEMPL_TYPE_FIELD_OR_FUNCTION_DECL_CHECK (NODE)) \
2587    ->u.min.template_info)
2588
2589 /* For a VAR_DECL, indicates that the variable is actually a
2590    non-static data member of anonymous union that has been promoted to
2591    variable status.  */
2592 #define DECL_ANON_UNION_VAR_P(NODE) \
2593   (DECL_LANG_FLAG_4 (VAR_DECL_CHECK (NODE)))
2594
2595 /* Template information for a RECORD_TYPE or UNION_TYPE.  */
2596 #define CLASSTYPE_TEMPLATE_INFO(NODE) \
2597   (LANG_TYPE_CLASS_CHECK (RECORD_OR_UNION_CHECK (NODE))->template_info)
2598
2599 /* Template information for an ENUMERAL_TYPE.  Although an enumeration may
2600    not be a primary template, it may be declared within the scope of a
2601    primary template and the enumeration constants may depend on
2602    non-type template parameters.  */
2603 #define ENUM_TEMPLATE_INFO(NODE) \
2604   (TYPE_LANG_SLOT_1 (ENUMERAL_TYPE_CHECK (NODE)))
2605
2606 /* Template information for a template template parameter.  */
2607 #define TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO(NODE) \
2608   (LANG_TYPE_CLASS_CHECK (BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK (NODE)) \
2609    ->template_info)
2610
2611 /* Template information for an ENUMERAL_, RECORD_, UNION_TYPE, or
2612    BOUND_TEMPLATE_TEMPLATE_PARM type.  Note that if NODE is a
2613    specialization of an alias template, this accessor returns the
2614    template info for the alias template, not the one (if any) for the
2615    template of the underlying type.  */
2616 #define TYPE_TEMPLATE_INFO(NODE)                                        \
2617   (TYPE_ALIAS_P (NODE)                                                  \
2618    ? ((TYPE_NAME (NODE) && DECL_LANG_SPECIFIC (TYPE_NAME (NODE)))       \
2619       ? DECL_TEMPLATE_INFO (TYPE_NAME (NODE))                           \
2620       : NULL_TREE)                                                      \
2621    : ((TREE_CODE (NODE) == ENUMERAL_TYPE)                               \
2622       ? ENUM_TEMPLATE_INFO (NODE)                                       \
2623       : ((TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM)             \
2624          ? TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (NODE)                  \
2625          : (CLASS_TYPE_P (NODE)                                         \
2626             ? CLASSTYPE_TEMPLATE_INFO (NODE)                            \
2627             : NULL_TREE))))
2628
2629
2630 /* Set the template information for an ENUMERAL_, RECORD_, or
2631    UNION_TYPE to VAL.  */
2632 #define SET_TYPE_TEMPLATE_INFO(NODE, VAL)                               \
2633   (TREE_CODE (NODE) == ENUMERAL_TYPE                                    \
2634    ? (ENUM_TEMPLATE_INFO (NODE) = (VAL))                                \
2635    : ((CLASS_TYPE_P (NODE) && !TYPE_ALIAS_P (NODE))                     \
2636       ? (CLASSTYPE_TEMPLATE_INFO (NODE) = (VAL))                        \
2637       : (DECL_TEMPLATE_INFO (TYPE_NAME (NODE)) = (VAL))))
2638
2639 #define TI_TEMPLATE(NODE) TREE_TYPE (TEMPLATE_INFO_CHECK (NODE))
2640 #define TI_ARGS(NODE) TREE_CHAIN (TEMPLATE_INFO_CHECK (NODE))
2641 #define TI_PENDING_TEMPLATE_FLAG(NODE) TREE_LANG_FLAG_1 (NODE)
2642 /* For a given TREE_VEC containing a template argument list,
2643    this property contains the number of arguments that are not
2644    defaulted.  */
2645 #define NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) TREE_CHAIN (TREE_VEC_CHECK (NODE))
2646 /* Below are the setter and getter of the NON_DEFAULT_TEMPLATE_ARGS_COUNT
2647    property.  */
2648 #define SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE, INT_VALUE) \
2649   NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) = build_int_cst (NULL_TREE, INT_VALUE)
2650 #ifdef ENABLE_CHECKING
2651 #define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \
2652     int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE))
2653 #else
2654 #define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \
2655   NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE) \
2656   ? int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE)) \
2657   : TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (NODE))
2658 #endif
2659 /* The list of typedefs - used in the template - that need
2660    access checking at template instantiation time.  */
2661 #define TI_TYPEDEFS_NEEDING_ACCESS_CHECKING(NODE) \
2662   ((struct tree_template_info*)TEMPLATE_INFO_CHECK \
2663      (NODE))->typedefs_needing_access_checking
2664
2665 /* We use TREE_VECs to hold template arguments.  If there is only one
2666    level of template arguments, then the TREE_VEC contains the
2667    arguments directly.  If there is more than one level of template
2668    arguments, then each entry in the TREE_VEC is itself a TREE_VEC,
2669    containing the template arguments for a single level.  The first
2670    entry in the outer TREE_VEC is the outermost level of template
2671    parameters; the last is the innermost.
2672
2673    It is incorrect to ever form a template argument vector containing
2674    only one level of arguments, but which is a TREE_VEC containing as
2675    its only entry the TREE_VEC for that level.
2676
2677    For each TREE_VEC containing the template arguments for a single
2678    level, it's possible to get or set the number of non defaulted
2679    template arguments by using the accessor macros
2680    GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT or
2681    SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT.  */
2682
2683 /* Nonzero if the template arguments is actually a vector of vectors,
2684    rather than just a vector.  */
2685 #define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE)                 \
2686   (NODE && TREE_VEC_LENGTH (NODE) && TREE_VEC_ELT (NODE, 0)  \
2687    && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC)
2688
2689 /* The depth of a template argument vector.  When called directly by
2690    the parser, we use a TREE_LIST rather than a TREE_VEC to represent
2691    template arguments.  In fact, we may even see NULL_TREE if there
2692    are no template arguments.  In both of those cases, there is only
2693    one level of template arguments.  */
2694 #define TMPL_ARGS_DEPTH(NODE)                                   \
2695   (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1)
2696
2697 /* The LEVELth level of the template ARGS.  The outermost level of
2698    args is level 1, not level 0.  */
2699 #define TMPL_ARGS_LEVEL(ARGS, LEVEL)            \
2700   (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS)        \
2701    ? TREE_VEC_ELT (ARGS, (LEVEL) - 1) : (ARGS))
2702
2703 /* Set the LEVELth level of the template ARGS to VAL.  This macro does
2704    not work with single-level argument vectors.  */
2705 #define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL)   \
2706   (TREE_VEC_ELT (ARGS, (LEVEL) - 1) = (VAL))
2707
2708 /* Accesses the IDXth parameter in the LEVELth level of the ARGS.  */
2709 #define TMPL_ARG(ARGS, LEVEL, IDX)                              \
2710   (TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX))
2711
2712 /* Given a single level of template arguments in NODE, return the
2713    number of arguments.  */
2714 #define NUM_TMPL_ARGS(NODE)                             \
2715   (TREE_VEC_LENGTH (NODE))
2716
2717 /* Returns the innermost level of template arguments in ARGS.  */
2718 #define INNERMOST_TEMPLATE_ARGS(NODE) \
2719   (get_innermost_template_args ((NODE), 1))
2720
2721 /* The number of levels of template parameters given by NODE.  */
2722 #define TMPL_PARMS_DEPTH(NODE) \
2723   ((HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_PURPOSE (NODE)))
2724
2725 /* The TEMPLATE_DECL instantiated or specialized by NODE.  This
2726    TEMPLATE_DECL will be the immediate parent, not the most general
2727    template.  For example, in:
2728
2729       template <class T> struct S { template <class U> void f(U); }
2730
2731    the FUNCTION_DECL for S<int>::f<double> will have, as its
2732    DECL_TI_TEMPLATE, `template <class U> S<int>::f<U>'.
2733
2734    As a special case, for a member friend template of a template
2735    class, this value will not be a TEMPLATE_DECL, but rather an
2736    IDENTIFIER_NODE or OVERLOAD indicating the name of the template and
2737    any explicit template arguments provided.  For example, in:
2738
2739      template <class T> struct S { friend void f<int>(int, double); }
2740
2741    the DECL_TI_TEMPLATE will be an IDENTIFIER_NODE for `f' and the
2742    DECL_TI_ARGS will be {int}.
2743
2744    For a FIELD_DECL with a non-static data member initializer, this value
2745    is the FIELD_DECL it was instantiated from.  */
2746 #define DECL_TI_TEMPLATE(NODE)      TI_TEMPLATE (DECL_TEMPLATE_INFO (NODE))
2747
2748 /* The template arguments used to obtain this decl from the most
2749    general form of DECL_TI_TEMPLATE.  For the example given for
2750    DECL_TI_TEMPLATE, the DECL_TI_ARGS will be {int, double}.  These
2751    are always the full set of arguments required to instantiate this
2752    declaration from the most general template specialized here.  */
2753 #define DECL_TI_ARGS(NODE)          TI_ARGS (DECL_TEMPLATE_INFO (NODE))
2754
2755 /* The TEMPLATE_DECL associated with NODE, a class type.  Even if NODE
2756    will be generated from a partial specialization, the TEMPLATE_DECL
2757    referred to here will be the original template.  For example,
2758    given:
2759
2760       template <typename T> struct S {};
2761       template <typename T> struct S<T*> {};
2762       
2763    the CLASSTPYE_TI_TEMPLATE for S<int*> will be S, not the S<T*>.  */
2764 #define CLASSTYPE_TI_TEMPLATE(NODE) TI_TEMPLATE (CLASSTYPE_TEMPLATE_INFO (NODE))
2765 #define CLASSTYPE_TI_ARGS(NODE)     TI_ARGS (CLASSTYPE_TEMPLATE_INFO (NODE))
2766
2767 /* For a template instantiation TYPE, returns the TYPE corresponding
2768    to the primary template.  Otherwise returns TYPE itself.  */
2769 #define CLASSTYPE_PRIMARY_TEMPLATE_TYPE(TYPE)                           \
2770   ((CLASSTYPE_USE_TEMPLATE ((TYPE))                                     \
2771     && !CLASSTYPE_TEMPLATE_SPECIALIZATION ((TYPE)))                     \
2772    ? TREE_TYPE (DECL_TEMPLATE_RESULT (DECL_PRIMARY_TEMPLATE             \
2773                                       (CLASSTYPE_TI_TEMPLATE ((TYPE))))) \
2774    : (TYPE))
2775
2776 /* Like CLASS_TI_TEMPLATE, but also works for ENUMERAL_TYPEs.  */
2777 #define TYPE_TI_TEMPLATE(NODE)                  \
2778   (TI_TEMPLATE (TYPE_TEMPLATE_INFO (NODE)))
2779
2780 /* Like DECL_TI_ARGS, but for an ENUMERAL_, RECORD_, or UNION_TYPE.  */
2781 #define TYPE_TI_ARGS(NODE)                      \
2782   (TI_ARGS (TYPE_TEMPLATE_INFO (NODE)))
2783
2784 #define INNERMOST_TEMPLATE_PARMS(NODE)  TREE_VALUE (NODE)
2785
2786 /* Nonzero if NODE (a TEMPLATE_DECL) is a member template, in the
2787    sense of [temp.mem].  */
2788 #define DECL_MEMBER_TEMPLATE_P(NODE) \
2789   (DECL_LANG_FLAG_1 (TEMPLATE_DECL_CHECK (NODE)))
2790
2791 /* Nonzero if the NODE corresponds to the template parameters for a
2792    member template, whose inline definition is being processed after
2793    the class definition is complete.  */
2794 #define TEMPLATE_PARMS_FOR_INLINE(NODE) TREE_LANG_FLAG_1 (NODE)
2795
2796 /* Determine if a parameter (i.e., a PARM_DECL) is a function
2797    parameter pack.  */
2798 #define FUNCTION_PARAMETER_PACK_P(NODE) \
2799   (DECL_LANG_FLAG_1 (PARM_DECL_CHECK (NODE)))
2800
2801 /* Determines if NODE is an expansion of one or more parameter packs,
2802    e.g., a TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION.  */
2803 #define PACK_EXPANSION_P(NODE)                 \
2804   (TREE_CODE (NODE) == TYPE_PACK_EXPANSION     \
2805    || TREE_CODE (NODE) == EXPR_PACK_EXPANSION)
2806
2807 /* Extracts the type or expression pattern from a TYPE_PACK_EXPANSION or
2808    EXPR_PACK_EXPANSION.  */
2809 #define PACK_EXPANSION_PATTERN(NODE)                            \
2810   (TREE_CODE (NODE) == TYPE_PACK_EXPANSION? TREE_TYPE (NODE)    \
2811    : TREE_OPERAND (NODE, 0))
2812
2813 /* Sets the type or expression pattern for a TYPE_PACK_EXPANSION or
2814    EXPR_PACK_EXPANSION.  */
2815 #define SET_PACK_EXPANSION_PATTERN(NODE,VALUE)  \
2816   if (TREE_CODE (NODE) == TYPE_PACK_EXPANSION)  \
2817     TREE_TYPE (NODE) = VALUE;                   \
2818   else                                          \
2819     TREE_OPERAND (NODE, 0) = VALUE
2820
2821 /* The list of parameter packs used in the PACK_EXPANSION_* node. The
2822    TREE_VALUE of each TREE_LIST contains the parameter packs.  */
2823 #define PACK_EXPANSION_PARAMETER_PACKS(NODE)            \
2824   *(TREE_CODE (NODE) == EXPR_PACK_EXPANSION             \
2825     ? &TREE_OPERAND (NODE, 1)                           \
2826     : &TYPE_MINVAL (TYPE_PACK_EXPANSION_CHECK (NODE)))
2827
2828 /* Any additional template args to be applied when substituting into
2829    the pattern, set by tsubst_pack_expansion for partial instantiations.  */
2830 #define PACK_EXPANSION_EXTRA_ARGS(NODE)         \
2831   *(TREE_CODE (NODE) == TYPE_PACK_EXPANSION     \
2832     ? &TYPE_MAXVAL (NODE)                       \
2833     : &TREE_OPERAND ((NODE), 2))
2834
2835 /* Determine if this is an argument pack.  */
2836 #define ARGUMENT_PACK_P(NODE)                          \
2837   (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK              \
2838    || TREE_CODE (NODE) == NONTYPE_ARGUMENT_PACK)
2839
2840 /* The arguments stored in an argument pack. Arguments are stored in a
2841    TREE_VEC, which may have length zero.  */
2842 #define ARGUMENT_PACK_ARGS(NODE)                               \
2843   (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK? TREE_TYPE (NODE)    \
2844    : TREE_OPERAND (NODE, 0))
2845
2846 /* Set the arguments stored in an argument pack. VALUE must be a
2847    TREE_VEC.  */
2848 #define SET_ARGUMENT_PACK_ARGS(NODE,VALUE)     \
2849   if (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK)  \
2850     TREE_TYPE (NODE) = VALUE;                           \
2851   else                                                  \
2852     TREE_OPERAND (NODE, 0) = VALUE
2853
2854 /* Whether the argument pack is "incomplete", meaning that more
2855    arguments can still be deduced. Incomplete argument packs are only
2856    used when the user has provided an explicit template argument list
2857    for a variadic function template. Some of the explicit template
2858    arguments will be placed into the beginning of the argument pack,
2859    but additional arguments might still be deduced.  */
2860 #define ARGUMENT_PACK_INCOMPLETE_P(NODE)        \
2861   TREE_LANG_FLAG_0 (ARGUMENT_PACK_ARGS (NODE))
2862
2863 /* When ARGUMENT_PACK_INCOMPLETE_P, stores the explicit template
2864    arguments used to fill this pack.  */
2865 #define ARGUMENT_PACK_EXPLICIT_ARGS(NODE)       \
2866   TREE_TYPE (ARGUMENT_PACK_ARGS (NODE))
2867
2868 /* In an ARGUMENT_PACK_SELECT, the argument pack from which an
2869    argument will be selected.  */
2870 #define ARGUMENT_PACK_SELECT_FROM_PACK(NODE)                            \
2871   (((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->argument_pack)
2872
2873 /* In an ARGUMENT_PACK_SELECT, the index of the argument we want to
2874    select.  */
2875 #define ARGUMENT_PACK_SELECT_INDEX(NODE)                                \
2876   (((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->index)
2877   
2878 /* In an ARGUMENT_PACK_SELECT, the actual underlying argument that the
2879    ARGUMENT_PACK_SELECT represents. */
2880 #define ARGUMENT_PACK_SELECT_ARG(NODE)                                  \
2881   TREE_VEC_ELT (ARGUMENT_PACK_ARGS (ARGUMENT_PACK_SELECT_FROM_PACK (NODE)), \
2882                 ARGUMENT_PACK_SELECT_INDEX (NODE));
2883
2884 /* In a FUNCTION_DECL, the saved language-specific per-function data.  */
2885 #define DECL_SAVED_FUNCTION_DATA(NODE)                  \
2886   (LANG_DECL_FN_CHECK (FUNCTION_DECL_CHECK (NODE))      \
2887    ->u.saved_language_function)
2888
2889 /* True if NODE is an implicit INDIRECT_EXPR from convert_from_reference.  */
2890 #define REFERENCE_REF_P(NODE)                           \
2891   (TREE_CODE (NODE) == INDIRECT_REF                     \
2892    && TREE_TYPE (TREE_OPERAND (NODE, 0))                \
2893    && (TREE_CODE (TREE_TYPE (TREE_OPERAND ((NODE), 0))) \
2894        == REFERENCE_TYPE))
2895
2896 #define NEW_EXPR_USE_GLOBAL(NODE) \
2897   TREE_LANG_FLAG_0 (NEW_EXPR_CHECK (NODE))
2898 #define DELETE_EXPR_USE_GLOBAL(NODE) \
2899   TREE_LANG_FLAG_0 (DELETE_EXPR_CHECK (NODE))
2900 #define DELETE_EXPR_USE_VEC(NODE) \
2901   TREE_LANG_FLAG_1 (DELETE_EXPR_CHECK (NODE))
2902
2903 /* Indicates that this is a non-dependent COMPOUND_EXPR which will
2904    resolve to a function call.  */
2905 #define COMPOUND_EXPR_OVERLOADED(NODE) \
2906   TREE_LANG_FLAG_0 (COMPOUND_EXPR_CHECK (NODE))
2907
2908 /* In a CALL_EXPR appearing in a template, true if Koenig lookup
2909    should be performed at instantiation time.  */
2910 #define KOENIG_LOOKUP_P(NODE) TREE_LANG_FLAG_0 (CALL_EXPR_CHECK (NODE))
2911
2912 /* Indicates whether a string literal has been parenthesized. Such
2913    usages are disallowed in certain circumstances.  */
2914
2915 #define PAREN_STRING_LITERAL_P(NODE) \
2916   TREE_LANG_FLAG_0 (STRING_CST_CHECK (NODE))
2917
2918 /* Nonzero if this AGGR_INIT_EXPR provides for initialization via a
2919    constructor call, rather than an ordinary function call.  */
2920 #define AGGR_INIT_VIA_CTOR_P(NODE) \
2921   TREE_LANG_FLAG_0 (AGGR_INIT_EXPR_CHECK (NODE))
2922
2923 /* Nonzero if expanding this AGGR_INIT_EXPR should first zero-initialize
2924    the object.  */
2925 #define AGGR_INIT_ZERO_FIRST(NODE) \
2926   TREE_LANG_FLAG_2 (AGGR_INIT_EXPR_CHECK (NODE))
2927
2928 /* AGGR_INIT_EXPR accessors.  These are equivalent to the CALL_EXPR
2929    accessors, except for AGGR_INIT_EXPR_SLOT (which takes the place of
2930    CALL_EXPR_STATIC_CHAIN).  */
2931
2932 #define AGGR_INIT_EXPR_FN(NODE) TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 1)
2933 #define AGGR_INIT_EXPR_SLOT(NODE) \
2934   TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 2)
2935 #define AGGR_INIT_EXPR_ARG(NODE, I) \
2936   TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), (I) + 3)
2937 #define aggr_init_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH(NODE) - 3)
2938
2939 /* AGGR_INIT_EXPR_ARGP returns a pointer to the argument vector for NODE.
2940    We can't use &AGGR_INIT_EXPR_ARG (NODE, 0) because that will complain if
2941    the argument count is zero when checking is enabled.  Instead, do
2942    the pointer arithmetic to advance past the 3 fixed operands in a
2943    AGGR_INIT_EXPR.  That produces a valid pointer to just past the end of
2944    the operand array, even if it's not valid to dereference it.  */
2945 #define AGGR_INIT_EXPR_ARGP(NODE) \
2946   (&(TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 0)) + 3)
2947
2948 /* Abstract iterators for AGGR_INIT_EXPRs.  */
2949
2950 /* Structure containing iterator state.  */
2951 typedef struct aggr_init_expr_arg_iterator_d {
2952   tree t;       /* the aggr_init_expr */
2953   int n;        /* argument count */
2954   int i;        /* next argument index */
2955 } aggr_init_expr_arg_iterator;
2956
2957 /* Initialize the abstract argument list iterator object ITER with the
2958    arguments from AGGR_INIT_EXPR node EXP.  */
2959 static inline void
2960 init_aggr_init_expr_arg_iterator (tree exp,
2961                                        aggr_init_expr_arg_iterator *iter)
2962 {
2963   iter->t = exp;
2964   iter->n = aggr_init_expr_nargs (exp);
2965   iter->i = 0;
2966 }
2967
2968 /* Return the next argument from abstract argument list iterator object ITER,
2969    and advance its state.  Return NULL_TREE if there are no more arguments.  */
2970 static inline tree
2971 next_aggr_init_expr_arg (aggr_init_expr_arg_iterator *iter)
2972 {
2973   tree result;
2974   if (iter->i >= iter->n)
2975     return NULL_TREE;
2976   result = AGGR_INIT_EXPR_ARG (iter->t, iter->i);
2977   iter->i++;
2978   return result;
2979 }
2980
2981 /* Initialize the abstract argument list iterator object ITER, then advance
2982    past and return the first argument.  Useful in for expressions, e.g.
2983      for (arg = first_aggr_init_expr_arg (exp, &iter); arg;
2984           arg = next_aggr_init_expr_arg (&iter))   */
2985 static inline tree
2986 first_aggr_init_expr_arg (tree exp, aggr_init_expr_arg_iterator *iter)
2987 {
2988   init_aggr_init_expr_arg_iterator (exp, iter);
2989   return next_aggr_init_expr_arg (iter);
2990 }
2991
2992 /* Test whether there are more arguments in abstract argument list iterator
2993    ITER, without changing its state.  */
2994 static inline bool
2995 more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter)
2996 {
2997   return (iter->i < iter->n);
2998 }
2999
3000 /* Iterate through each argument ARG of AGGR_INIT_EXPR CALL, using variable
3001    ITER (of type aggr_init_expr_arg_iterator) to hold the iteration state.  */
3002 #define FOR_EACH_AGGR_INIT_EXPR_ARG(arg, iter, call)                    \
3003   for ((arg) = first_aggr_init_expr_arg ((call), &(iter)); (arg);       \
3004        (arg) = next_aggr_init_expr_arg (&(iter)))
3005
3006 /* VEC_INIT_EXPR accessors.  */
3007 #define VEC_INIT_EXPR_SLOT(NODE) TREE_OPERAND (VEC_INIT_EXPR_CHECK (NODE), 0)
3008 #define VEC_INIT_EXPR_INIT(NODE) TREE_OPERAND (VEC_INIT_EXPR_CHECK (NODE), 1)
3009
3010 /* Indicates that a VEC_INIT_EXPR is a potential constant expression.
3011    Only set when the current function is constexpr.  */
3012 #define VEC_INIT_EXPR_IS_CONSTEXPR(NODE) \
3013   TREE_LANG_FLAG_0 (VEC_INIT_EXPR_CHECK (NODE))
3014
3015 /* Indicates that a VEC_INIT_EXPR is expressing value-initialization.  */
3016 #define VEC_INIT_EXPR_VALUE_INIT(NODE) \
3017   TREE_LANG_FLAG_1 (VEC_INIT_EXPR_CHECK (NODE))
3018
3019 /* The condition under which this MUST_NOT_THROW_EXPR actually blocks
3020    exceptions.  NULL_TREE means 'true'.  */
3021 #define MUST_NOT_THROW_COND(NODE) \
3022   TREE_OPERAND (MUST_NOT_THROW_EXPR_CHECK (NODE), 1)
3023
3024 /* The TYPE_MAIN_DECL for a class template type is a TYPE_DECL, not a
3025    TEMPLATE_DECL.  This macro determines whether or not a given class
3026    type is really a template type, as opposed to an instantiation or
3027    specialization of one.  */
3028 #define CLASSTYPE_IS_TEMPLATE(NODE)  \
3029   (CLASSTYPE_TEMPLATE_INFO (NODE)    \
3030    && !CLASSTYPE_USE_TEMPLATE (NODE) \
3031    && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE)))
3032
3033 /* The name used by the user to name the typename type.  Typically,
3034    this is an IDENTIFIER_NODE, and the same as the DECL_NAME on the
3035    corresponding TYPE_DECL.  However, this may also be a
3036    TEMPLATE_ID_EXPR if we had something like `typename X::Y<T>'.  */
3037 #define TYPENAME_TYPE_FULLNAME(NODE) \
3038   (TYPE_VALUES_RAW (TYPENAME_TYPE_CHECK (NODE)))
3039
3040 /* True if a TYPENAME_TYPE was declared as an "enum".  */
3041 #define TYPENAME_IS_ENUM_P(NODE) \
3042   (TREE_LANG_FLAG_0 (TYPENAME_TYPE_CHECK (NODE)))
3043
3044 /* True if a TYPENAME_TYPE was declared as a "class", "struct", or
3045    "union".  */
3046 #define TYPENAME_IS_CLASS_P(NODE) \
3047   (TREE_LANG_FLAG_1 (TYPENAME_TYPE_CHECK (NODE)))
3048
3049 /* True if a TYPENAME_TYPE is in the process of being resolved.  */
3050 #define TYPENAME_IS_RESOLVING_P(NODE) \
3051   (TREE_LANG_FLAG_2 (TYPENAME_TYPE_CHECK (NODE)))
3052
3053 /* [class.virtual]
3054
3055    A class that declares or inherits a virtual function is called a
3056    polymorphic class.  */
3057 #define TYPE_POLYMORPHIC_P(NODE) (TREE_LANG_FLAG_2 (NODE))
3058
3059 /* Nonzero if this class has a virtual function table pointer.  */
3060 #define TYPE_CONTAINS_VPTR_P(NODE)              \
3061   (TYPE_POLYMORPHIC_P (NODE) || CLASSTYPE_VBASECLASSES (NODE))
3062
3063 /* This flag is true of a local VAR_DECL if it was declared in a for
3064    statement, but we are no longer in the scope of the for.  */
3065 #define DECL_DEAD_FOR_LOCAL(NODE) DECL_LANG_FLAG_7 (VAR_DECL_CHECK (NODE))
3066
3067 /* This flag is set on a VAR_DECL that is a DECL_DEAD_FOR_LOCAL
3068    if we already emitted a warning about using it.  */
3069 #define DECL_ERROR_REPORTED(NODE) DECL_LANG_FLAG_0 (VAR_DECL_CHECK (NODE))
3070
3071 /* Nonzero if NODE is a FUNCTION_DECL (for a function with global
3072    scope) declared in a local scope.  */
3073 #define DECL_LOCAL_FUNCTION_P(NODE) \
3074   DECL_LANG_FLAG_0 (FUNCTION_DECL_CHECK (NODE))
3075
3076 /* Nonzero if NODE is a DECL which we know about but which has not
3077    been explicitly declared, such as a built-in function or a friend
3078    declared inside a class.  In the latter case DECL_HIDDEN_FRIEND_P
3079    will be set.  */
3080 #define DECL_ANTICIPATED(NODE) \
3081   (DECL_LANG_SPECIFIC (DECL_COMMON_CHECK (NODE))->u.base.anticipated_p)
3082
3083 /* Nonzero if NODE is a FUNCTION_DECL which was declared as a friend
3084    within a class but has not been declared in the surrounding scope.
3085    The function is invisible except via argument dependent lookup.  */
3086 #define DECL_HIDDEN_FRIEND_P(NODE) \
3087   (LANG_DECL_FN_CHECK (DECL_COMMON_CHECK (NODE))->hidden_friend_p)
3088
3089 /* Nonzero if DECL has been declared threadprivate by
3090    #pragma omp threadprivate.  */
3091 #define CP_DECL_THREADPRIVATE_P(DECL) \
3092   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (DECL))->u.base.threadprivate_or_deleted_p)
3093
3094 /* Nonzero if DECL was declared with '= delete'.  */
3095 #define DECL_DELETED_FN(DECL) \
3096   (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->u.base.threadprivate_or_deleted_p)
3097
3098 /* Nonzero if DECL was declared with '= default' (maybe implicitly).  */
3099 #define DECL_DEFAULTED_FN(DECL) \
3100   (LANG_DECL_FN_CHECK (DECL)->defaulted_p)
3101
3102 /* Nonzero if DECL is explicitly defaulted in the class body.  */
3103 #define DECL_DEFAULTED_IN_CLASS_P(DECL)                                 \
3104   (DECL_DEFAULTED_FN (DECL) && DECL_INITIALIZED_IN_CLASS_P (DECL))
3105 /* Nonzero if DECL was defaulted outside the class body.  */
3106 #define DECL_DEFAULTED_OUTSIDE_CLASS_P(DECL)                            \
3107   (DECL_DEFAULTED_FN (DECL)                                             \
3108    && !(DECL_ARTIFICIAL (DECL) || DECL_INITIALIZED_IN_CLASS_P (DECL)))
3109
3110 /* Record whether a typedef for type `int' was actually `signed int'.  */
3111 #define C_TYPEDEF_EXPLICITLY_SIGNED(EXP) DECL_LANG_FLAG_1 (EXP)
3112
3113 /* Returns nonzero if DECL has external linkage, as specified by the
3114    language standard.  (This predicate may hold even when the
3115    corresponding entity is not actually given external linkage in the
3116    object file; see decl_linkage for details.)  */
3117 #define DECL_EXTERNAL_LINKAGE_P(DECL) \
3118   (decl_linkage (DECL) == lk_external)
3119
3120 /* Keep these codes in ascending code order.  */
3121
3122 #define INTEGRAL_CODE_P(CODE)   \
3123   ((CODE) == ENUMERAL_TYPE      \
3124    || (CODE) == BOOLEAN_TYPE    \
3125    || (CODE) == INTEGER_TYPE)
3126
3127 /* [basic.fundamental]
3128
3129    Types  bool, char, wchar_t, and the signed and unsigned integer types
3130    are collectively called integral types.
3131
3132    Note that INTEGRAL_TYPE_P, as defined in tree.h, allows enumeration
3133    types as well, which is incorrect in C++.  Keep these checks in
3134    ascending code order.  */
3135 #define CP_INTEGRAL_TYPE_P(TYPE)                \
3136   (TREE_CODE (TYPE) == BOOLEAN_TYPE             \
3137    || TREE_CODE (TYPE) == INTEGER_TYPE)
3138
3139 /* Returns true if TYPE is an integral or enumeration name.  Keep
3140    these checks in ascending code order.  */
3141 #define INTEGRAL_OR_ENUMERATION_TYPE_P(TYPE) \
3142    (TREE_CODE (TYPE) == ENUMERAL_TYPE || CP_INTEGRAL_TYPE_P (TYPE))
3143
3144 /* Returns true if TYPE is an integral or unscoped enumeration type.  */
3145 #define INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P(TYPE) \
3146    (UNSCOPED_ENUM_P (TYPE) || CP_INTEGRAL_TYPE_P (TYPE))
3147
3148 /* True if the class type TYPE is a literal type.  */
3149 #define CLASSTYPE_LITERAL_P(TYPE)              \
3150    (LANG_TYPE_CLASS_CHECK (TYPE)->is_literal)
3151
3152 /* [basic.fundamental]
3153
3154    Integral and floating types are collectively called arithmetic
3155    types.  
3156
3157    As a GNU extension, we also accept complex types.
3158
3159    Keep these checks in ascending code order.  */
3160 #define ARITHMETIC_TYPE_P(TYPE) \
3161   (CP_INTEGRAL_TYPE_P (TYPE) \
3162    || TREE_CODE (TYPE) == REAL_TYPE \
3163    || TREE_CODE (TYPE) == COMPLEX_TYPE)
3164
3165 /* True iff TYPE is cv decltype(nullptr).  */
3166 #define NULLPTR_TYPE_P(TYPE) (TREE_CODE (TYPE) == NULLPTR_TYPE)
3167
3168 /* [basic.types]
3169
3170    Arithmetic types, enumeration types, pointer types,
3171    pointer-to-member types, and std::nullptr_t are collectively called
3172    scalar types.
3173    
3174    Keep these checks in ascending code order.  */
3175 #define SCALAR_TYPE_P(TYPE)                     \
3176   (TYPE_PTRMEM_P (TYPE)                         \
3177    || TREE_CODE (TYPE) == ENUMERAL_TYPE         \
3178    || ARITHMETIC_TYPE_P (TYPE)                  \
3179    || TYPE_PTR_P (TYPE)                         \
3180    || TYPE_PTRMEMFUNC_P (TYPE)                  \
3181    || NULLPTR_TYPE_P (TYPE))
3182
3183 /* Determines whether this type is a C++0x scoped enumeration
3184    type. Scoped enumerations types are introduced via "enum class" or
3185    "enum struct", e.g.,
3186
3187      enum class Color {
3188        Red, Green, Blue
3189      };
3190
3191    Scoped enumeration types are different from normal (unscoped)
3192    enumeration types in several ways:
3193    
3194      - The enumerators of a scoped enumeration type are only available
3195        within the scope of the enumeration type and not in the
3196        enclosing scope. For example, the Red color can be referred to
3197        with "Color::Red" but not "Red".
3198
3199      - Scoped enumerators and enumerations do not implicitly convert
3200        to integers or 'bool'.
3201
3202      - The underlying type of the enum is well-defined.  */
3203 #define SCOPED_ENUM_P(TYPE)                                             \
3204   (TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_SCOPED (TYPE))
3205
3206 /* Determine whether this is an unscoped enumeration type.  */
3207 #define UNSCOPED_ENUM_P(TYPE)                                           \
3208   (TREE_CODE (TYPE) == ENUMERAL_TYPE && !ENUM_IS_SCOPED (TYPE))
3209
3210 /* Set the flag indicating whether an ENUMERAL_TYPE is a C++0x scoped
3211    enumeration type (1) or a normal (unscoped) enumeration type
3212    (0).  */
3213 #define SET_SCOPED_ENUM_P(TYPE, VAL)                    \
3214   (ENUM_IS_SCOPED (TYPE) = (VAL))
3215
3216 #define SET_OPAQUE_ENUM_P(TYPE, VAL)                    \
3217   (ENUM_IS_OPAQUE (TYPE) = (VAL))
3218
3219 #define OPAQUE_ENUM_P(TYPE)                             \
3220   (TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_OPAQUE (TYPE))
3221
3222 /* Determines whether an ENUMERAL_TYPE has an explicit
3223    underlying type.  */
3224 #define ENUM_FIXED_UNDERLYING_TYPE_P(NODE) (TYPE_LANG_FLAG_5 (NODE))
3225
3226 /* Returns the underlying type of the given enumeration type. The
3227    underlying type is determined in different ways, depending on the
3228    properties of the enum:
3229
3230      - In C++0x, the underlying type can be explicitly specified, e.g.,
3231
3232          enum E1 : char { ... } // underlying type is char
3233
3234      - In a C++0x scoped enumeration, the underlying type is int
3235        unless otherwises specified:
3236
3237          enum class E2 { ... } // underlying type is int
3238
3239      - Otherwise, the underlying type is determined based on the
3240        values of the enumerators. In this case, the
3241        ENUM_UNDERLYING_TYPE will not be set until after the definition
3242        of the enumeration is completed by finish_enum.  */
3243 #define ENUM_UNDERLYING_TYPE(TYPE) \
3244   TREE_TYPE (ENUMERAL_TYPE_CHECK (TYPE))
3245
3246 /* [dcl.init.aggr]
3247
3248    An aggregate is an array or a class with no user-provided
3249    constructors, no brace-or-equal-initializers for non-static data
3250    members, no private or protected non-static data members, no
3251    base classes, and no virtual functions.
3252
3253    As an extension, we also treat vectors as aggregates.  Keep these
3254    checks in ascending code order.  */
3255 #define CP_AGGREGATE_TYPE_P(TYPE)                               \
3256   (TREE_CODE (TYPE) == VECTOR_TYPE                              \
3257    ||TREE_CODE (TYPE) == ARRAY_TYPE                             \
3258    || (CLASS_TYPE_P (TYPE) && !CLASSTYPE_NON_AGGREGATE (TYPE)))
3259
3260 /* Nonzero for a class type means that the class type has a
3261    user-declared constructor.  */
3262 #define TYPE_HAS_USER_CONSTRUCTOR(NODE) (TYPE_LANG_FLAG_1 (NODE))
3263
3264 /* When appearing in an INDIRECT_REF, it means that the tree structure
3265    underneath is actually a call to a constructor.  This is needed
3266    when the constructor must initialize local storage (which can
3267    be automatically destroyed), rather than allowing it to allocate
3268    space from the heap.
3269
3270    When appearing in a SAVE_EXPR, it means that underneath
3271    is a call to a constructor.
3272
3273    When appearing in a CONSTRUCTOR, the expression is a
3274    compound literal.
3275
3276    When appearing in a FIELD_DECL, it means that this field
3277    has been duly initialized in its constructor.  */
3278 #define TREE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_4 (NODE))
3279
3280 /* True if NODE is a brace-enclosed initializer.  */
3281 #define BRACE_ENCLOSED_INITIALIZER_P(NODE) \
3282   (TREE_CODE (NODE) == CONSTRUCTOR && TREE_TYPE (NODE) == init_list_type_node)
3283
3284 /* True if NODE is a compound-literal, i.e., a brace-enclosed
3285    initializer cast to a particular type.  */
3286 #define COMPOUND_LITERAL_P(NODE) \
3287   (TREE_CODE (NODE) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (NODE))
3288
3289 #define EMPTY_CONSTRUCTOR_P(NODE) (TREE_CODE (NODE) == CONSTRUCTOR \
3290                                    && VEC_empty (constructor_elt, \
3291                                                  CONSTRUCTOR_ELTS (NODE)) \
3292                                    && !TREE_HAS_CONSTRUCTOR (NODE))
3293
3294 /* True if NODE is a init-list used as a direct-initializer, i.e.
3295    B b{1,2}, not B b({1,2}) or B b = {1,2}.  */
3296 #define CONSTRUCTOR_IS_DIRECT_INIT(NODE) (TREE_LANG_FLAG_0 (CONSTRUCTOR_CHECK (NODE)))
3297
3298 /* True if NODE represents a conversion for direct-initialization in a
3299    template.  Set by perform_implicit_conversion_flags.  */
3300 #define IMPLICIT_CONV_EXPR_DIRECT_INIT(NODE) \
3301   (TREE_LANG_FLAG_0 (IMPLICIT_CONV_EXPR_CHECK (NODE)))
3302
3303 /* Nonzero means that an object of this type can not be initialized using
3304    an initializer list.  */
3305 #define CLASSTYPE_NON_AGGREGATE(NODE) \
3306   (LANG_TYPE_CLASS_CHECK (NODE)->non_aggregate)
3307 #define TYPE_NON_AGGREGATE_CLASS(NODE) \
3308   (CLASS_TYPE_P (NODE) && CLASSTYPE_NON_AGGREGATE (NODE))
3309
3310 /* Nonzero if there is a non-trivial X::op=(cv X&) for this class.  */
3311 #define TYPE_HAS_COMPLEX_COPY_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_copy_assign)
3312
3313 /* Nonzero if there is a non-trivial X::X(cv X&) for this class.  */
3314 #define TYPE_HAS_COMPLEX_COPY_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_copy_ctor)
3315
3316 /* Nonzero if there is a non-trivial X::op=(X&&) for this class.  */
3317 #define TYPE_HAS_COMPLEX_MOVE_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_move_assign)
3318
3319 /* Nonzero if there is a non-trivial X::X(X&&) for this class.  */
3320 #define TYPE_HAS_COMPLEX_MOVE_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_move_ctor)
3321
3322 /* Nonzero if there is a non-trivial default constructor for this class.  */
3323 #define TYPE_HAS_COMPLEX_DFLT(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_dflt)
3324
3325 /* Nonzero if TYPE has a trivial destructor.  From [class.dtor]:
3326
3327      A destructor is trivial if it is an implicitly declared
3328      destructor and if:
3329
3330        - all of the direct base classes of its class have trivial
3331          destructors,
3332
3333        - for all of the non-static data members of its class that are
3334          of class type (or array thereof), each such class has a
3335          trivial destructor.  */
3336 #define TYPE_HAS_TRIVIAL_DESTRUCTOR(NODE) \
3337   (!TYPE_HAS_NONTRIVIAL_DESTRUCTOR (NODE))
3338
3339 /* Nonzero for _TYPE node means that this type does not have a trivial
3340    destructor.  Therefore, destroying an object of this type will
3341    involve a call to a destructor.  This can apply to objects of
3342    ARRAY_TYPE is the type of the elements needs a destructor.  */
3343 #define TYPE_HAS_NONTRIVIAL_DESTRUCTOR(NODE) \
3344   (TYPE_LANG_FLAG_4 (NODE))
3345
3346 /* Nonzero for class type means that the default constructor is trivial.  */
3347 #define TYPE_HAS_TRIVIAL_DFLT(NODE) \
3348   (TYPE_HAS_DEFAULT_CONSTRUCTOR (NODE) && ! TYPE_HAS_COMPLEX_DFLT (NODE))
3349
3350 /* Nonzero for class type means that copy initialization of this type can use
3351    a bitwise copy.  */
3352 #define TYPE_HAS_TRIVIAL_COPY_CTOR(NODE) \
3353   (TYPE_HAS_COPY_CTOR (NODE) && ! TYPE_HAS_COMPLEX_COPY_CTOR (NODE))
3354
3355 /* Nonzero for class type means that assignment of this type can use
3356    a bitwise copy.  */
3357 #define TYPE_HAS_TRIVIAL_COPY_ASSIGN(NODE) \
3358   (TYPE_HAS_COPY_ASSIGN (NODE) && ! TYPE_HAS_COMPLEX_COPY_ASSIGN (NODE))
3359
3360 /* Returns true if NODE is a pointer-to-data-member.  */
3361 #define TYPE_PTRMEM_P(NODE)                     \
3362   (TREE_CODE (NODE) == OFFSET_TYPE)
3363 /* Returns true if NODE is a pointer.  */
3364 #define TYPE_PTR_P(NODE)                        \
3365   (TREE_CODE (NODE) == POINTER_TYPE)
3366
3367 /* Returns true if NODE is an object type:
3368
3369      [basic.types]
3370
3371      An object type is a (possibly cv-qualified) type that is not a
3372      function type, not a reference type, and not a void type.
3373
3374    Keep these checks in ascending order, for speed.  */
3375 #define TYPE_OBJ_P(NODE)                        \
3376   (TREE_CODE (NODE) != REFERENCE_TYPE           \
3377    && TREE_CODE (NODE) != VOID_TYPE             \
3378    && TREE_CODE (NODE) != FUNCTION_TYPE         \
3379    && TREE_CODE (NODE) != METHOD_TYPE)
3380
3381 /* Returns true if NODE is a pointer to an object.  Keep these checks
3382    in ascending tree code order.  */
3383 #define TYPE_PTROB_P(NODE)                                      \
3384   (TYPE_PTR_P (NODE) && TYPE_OBJ_P (TREE_TYPE (NODE)))
3385
3386 /* Returns true if NODE is a reference to an object.  Keep these checks
3387    in ascending tree code order.  */
3388 #define TYPE_REF_OBJ_P(NODE)                                    \
3389   (TREE_CODE (NODE) == REFERENCE_TYPE && TYPE_OBJ_P (TREE_TYPE (NODE)))
3390
3391 /* Returns true if NODE is a pointer to an object, or a pointer to
3392    void.  Keep these checks in ascending tree code order.  */
3393 #define TYPE_PTROBV_P(NODE)                                     \
3394   (TYPE_PTR_P (NODE)                                            \
3395    && !(TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE           \
3396         || TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE))
3397
3398 /* Returns true if NODE is a pointer to function.  */
3399 #define TYPE_PTRFN_P(NODE)                              \
3400   (TREE_CODE (NODE) == POINTER_TYPE                     \
3401    && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE)
3402
3403 /* Returns true if NODE is a reference to function.  */
3404 #define TYPE_REFFN_P(NODE)                              \
3405   (TREE_CODE (NODE) == REFERENCE_TYPE                   \
3406    && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE)
3407
3408 /* Nonzero for _TYPE node means that this type is a pointer to member
3409    function type.  */
3410 #define TYPE_PTRMEMFUNC_P(NODE)         \
3411   (TREE_CODE (NODE) == RECORD_TYPE      \
3412    && TYPE_LANG_SPECIFIC (NODE)         \
3413    && TYPE_PTRMEMFUNC_FLAG (NODE))
3414
3415 #define TYPE_PTRMEMFUNC_FLAG(NODE) \
3416   (LANG_TYPE_CLASS_CHECK (NODE)->ptrmemfunc_flag)
3417
3418 /* Returns true if NODE is a pointer-to-member.  */
3419 #define TYPE_PTR_TO_MEMBER_P(NODE) \
3420   (TYPE_PTRMEM_P (NODE) || TYPE_PTRMEMFUNC_P (NODE))
3421
3422 /* Indicates when overload resolution may resolve to a pointer to
3423    member function. [expr.unary.op]/3 */
3424 #define PTRMEM_OK_P(NODE) \
3425   TREE_LANG_FLAG_0 (TREE_CHECK3 ((NODE), ADDR_EXPR, OFFSET_REF, SCOPE_REF))
3426
3427 /* Get the POINTER_TYPE to the METHOD_TYPE associated with this
3428    pointer to member function.  TYPE_PTRMEMFUNC_P _must_ be true,
3429    before using this macro.  */
3430 #define TYPE_PTRMEMFUNC_FN_TYPE(NODE) \
3431   (TREE_TYPE (TYPE_FIELDS (NODE)))
3432
3433 /* Returns `A' for a type like `int (A::*)(double)' */
3434 #define TYPE_PTRMEMFUNC_OBJECT_TYPE(NODE) \
3435   TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE)))
3436
3437 /* These are use to manipulate the canonical RECORD_TYPE from the
3438    hashed POINTER_TYPE, and can only be used on the POINTER_TYPE.  */
3439 #define TYPE_GET_PTRMEMFUNC_TYPE(NODE) \
3440   (TYPE_LANG_SPECIFIC (NODE) ? LANG_TYPE_PTRMEM_CHECK (NODE)->record : NULL)
3441 #define TYPE_SET_PTRMEMFUNC_TYPE(NODE, VALUE)                           \
3442   do {                                                                  \
3443     if (TYPE_LANG_SPECIFIC (NODE) == NULL)                              \
3444       {                                                                 \
3445         TYPE_LANG_SPECIFIC (NODE) = ggc_alloc_cleared_lang_type         \
3446          (sizeof (struct lang_type_ptrmem));                            \
3447         TYPE_LANG_SPECIFIC (NODE)->u.ptrmem.h.is_lang_type_class = 0;   \
3448       }                                                                 \
3449     TYPE_LANG_SPECIFIC (NODE)->u.ptrmem.record = (VALUE);               \
3450   } while (0)
3451
3452 /* For a pointer-to-member type of the form `T X::*', this is `X'.
3453    For a type like `void (X::*)() const', this type is `X', not `const
3454    X'.  To get at the `const X' you have to look at the
3455    TYPE_PTRMEM_POINTED_TO_TYPE; there, the first parameter will have
3456    type `const X*'.  */
3457 #define TYPE_PTRMEM_CLASS_TYPE(NODE)                    \
3458   (TYPE_PTRMEM_P (NODE)                                 \
3459    ? TYPE_OFFSET_BASETYPE (NODE)                \
3460    : TYPE_PTRMEMFUNC_OBJECT_TYPE (NODE))
3461
3462 /* For a pointer-to-member type of the form `T X::*', this is `T'.  */
3463 #define TYPE_PTRMEM_POINTED_TO_TYPE(NODE)               \
3464    (TYPE_PTRMEM_P (NODE)                                \
3465     ? TREE_TYPE (NODE)                                  \
3466     : TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE)))
3467
3468 /* For a pointer-to-member constant `X::Y' this is the RECORD_TYPE for
3469    `X'.  */
3470 #define PTRMEM_CST_CLASS(NODE) \
3471   TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (PTRMEM_CST_CHECK (NODE)))
3472
3473 /* For a pointer-to-member constant `X::Y' this is the _DECL for
3474    `Y'.  */
3475 #define PTRMEM_CST_MEMBER(NODE) (((ptrmem_cst_t)PTRMEM_CST_CHECK (NODE))->member)
3476
3477 /* The expression in question for a TYPEOF_TYPE.  */
3478 #define TYPEOF_TYPE_EXPR(NODE) (TYPE_VALUES_RAW (TYPEOF_TYPE_CHECK (NODE)))
3479
3480 /* The type in question for an UNDERLYING_TYPE.  */
3481 #define UNDERLYING_TYPE_TYPE(NODE) \
3482   (TYPE_VALUES_RAW (UNDERLYING_TYPE_CHECK (NODE)))
3483
3484 /* The type in question for BASES.  */
3485 #define BASES_TYPE(NODE) \
3486   (TYPE_VALUES_RAW (BASES_CHECK (NODE)))
3487
3488 #define BASES_DIRECT(NODE) \
3489   TREE_LANG_FLAG_0 (BASES_CHECK (NODE))
3490
3491 /* The expression in question for a DECLTYPE_TYPE.  */
3492 #define DECLTYPE_TYPE_EXPR(NODE) (TYPE_VALUES_RAW (DECLTYPE_TYPE_CHECK (NODE)))
3493
3494 /* Whether the DECLTYPE_TYPE_EXPR of NODE was originally parsed as an
3495    id-expression or a member-access expression. When false, it was
3496    parsed as a full expression.  */
3497 #define DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P(NODE) \
3498   (DECLTYPE_TYPE_CHECK (NODE))->type_common.string_flag
3499
3500 /* These flags indicate that we want different semantics from normal
3501    decltype: lambda capture just drops references, lambda proxies look
3502    through implicit dereference.  */
3503 #define DECLTYPE_FOR_LAMBDA_CAPTURE(NODE) \
3504   TREE_LANG_FLAG_0 (DECLTYPE_TYPE_CHECK (NODE))
3505 #define DECLTYPE_FOR_LAMBDA_PROXY(NODE) \
3506   TREE_LANG_FLAG_2 (DECLTYPE_TYPE_CHECK (NODE))
3507
3508 /* Nonzero for VAR_DECL and FUNCTION_DECL node means that `extern' was
3509    specified in its declaration.  This can also be set for an
3510    erroneously declared PARM_DECL.  */
3511 #define DECL_THIS_EXTERN(NODE) \
3512   DECL_LANG_FLAG_2 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE))
3513
3514 /* Nonzero for VAR_DECL and FUNCTION_DECL node means that `static' was
3515    specified in its declaration.  This can also be set for an
3516    erroneously declared PARM_DECL.  */
3517 #define DECL_THIS_STATIC(NODE) \
3518   DECL_LANG_FLAG_6 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE))
3519
3520 /* Nonzero for FIELD_DECL node means that this field is a base class
3521    of the parent object, as opposed to a member field.  */
3522 #define DECL_FIELD_IS_BASE(NODE) \
3523   DECL_LANG_FLAG_6 (FIELD_DECL_CHECK (NODE))
3524
3525 /* Nonzero for FIELD_DECL node means that this field is a simple (no
3526    explicit initializer) lambda capture field, making it invisible to
3527    name lookup in unevaluated contexts.  */
3528 #define DECL_NORMAL_CAPTURE_P(NODE) \
3529   DECL_LANG_FLAG_7 (FIELD_DECL_CHECK (NODE))
3530
3531 /* Nonzero if TYPE is an anonymous union or struct type.  We have to use a
3532    flag for this because "A union for which objects or pointers are
3533    declared is not an anonymous union" [class.union].  */
3534 #define ANON_AGGR_TYPE_P(NODE)                          \
3535   (CLASS_TYPE_P (NODE) && LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr)
3536 #define SET_ANON_AGGR_TYPE_P(NODE)                      \
3537   (LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr = 1)
3538
3539 /* Nonzero if TYPE is an anonymous union type.  */
3540 #define ANON_UNION_TYPE_P(NODE) \
3541   (TREE_CODE (NODE) == UNION_TYPE && ANON_AGGR_TYPE_P (NODE))
3542
3543 /* Define fields and accessors for nodes representing declared names.  */
3544
3545 #define TYPE_WAS_ANONYMOUS(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->was_anonymous)
3546
3547 /* C++: all of these are overloaded!  These apply only to TYPE_DECLs.  */
3548
3549 /* The format of each node in the DECL_FRIENDLIST is as follows:
3550
3551    The TREE_PURPOSE will be the name of a function, i.e., an
3552    IDENTIFIER_NODE.  The TREE_VALUE will be itself a TREE_LIST, whose
3553    TREE_VALUEs are friends with the given name.  */
3554 #define DECL_FRIENDLIST(NODE)           (DECL_INITIAL (NODE))
3555 #define FRIEND_NAME(LIST) (TREE_PURPOSE (LIST))
3556 #define FRIEND_DECLS(LIST) (TREE_VALUE (LIST))
3557
3558 /* The DECL_ACCESS, if non-NULL, is a TREE_LIST.  The TREE_PURPOSE of
3559    each node is a type; the TREE_VALUE is the access granted for this
3560    DECL in that type.  The DECL_ACCESS is set by access declarations.
3561    For example, if a member that would normally be public in a
3562    derived class is made protected, then the derived class and the
3563    protected_access_node will appear in the DECL_ACCESS for the node.  */
3564 #define DECL_ACCESS(NODE) (LANG_DECL_U2_CHECK (NODE, 0)->access)
3565
3566 /* Nonzero if the FUNCTION_DECL is a global constructor.  */
3567 #define DECL_GLOBAL_CTOR_P(NODE) \
3568   (LANG_DECL_FN_CHECK (NODE)->global_ctor_p)
3569
3570 /* Nonzero if the FUNCTION_DECL is a global destructor.  */
3571 #define DECL_GLOBAL_DTOR_P(NODE) \
3572   (LANG_DECL_FN_CHECK (NODE)->global_dtor_p)
3573
3574 /* Accessor macros for C++ template decl nodes.  */
3575
3576 /* The DECL_TEMPLATE_PARMS are a list.  The TREE_PURPOSE of each node
3577    is a INT_CST whose TREE_INT_CST_LOW indicates the level of the
3578    template parameters, with 1 being the outermost set of template
3579    parameters.  The TREE_VALUE is a vector, whose elements are the
3580    template parameters at each level.  Each element in the vector is a
3581    TREE_LIST, whose TREE_VALUE is a PARM_DECL (if the parameter is a
3582    non-type parameter), or a TYPE_DECL (if the parameter is a type
3583    parameter).  The TREE_PURPOSE is the default value, if any.  The
3584    TEMPLATE_PARM_INDEX for the parameter is available as the
3585    DECL_INITIAL (for a PARM_DECL) or as the TREE_TYPE (for a
3586    TYPE_DECL).  */
3587 #define DECL_TEMPLATE_PARMS(NODE)       DECL_NON_COMMON_CHECK (NODE)->decl_non_common.arguments
3588 #define DECL_INNERMOST_TEMPLATE_PARMS(NODE) \
3589    INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (NODE))
3590 #define DECL_NTPARMS(NODE) \
3591    TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (NODE))
3592 /* For function, method, class-data templates.  */
3593 #define DECL_TEMPLATE_RESULT(NODE)      DECL_RESULT_FLD (NODE)
3594 /* For a function template at namespace scope, DECL_TEMPLATE_INSTANTIATIONS
3595    lists all instantiations and specializations of the function so that
3596    tsubst_friend_function can reassign them to another template if we find
3597    that the namespace-scope template is really a partial instantiation of a
3598    friend template.
3599
3600    For a class template the DECL_TEMPLATE_INSTANTIATIONS lists holds
3601    all instantiations and specializations of the class type, including
3602    partial instantiations and partial specializations, so that if we
3603    explicitly specialize a partial instantiation we can walk the list
3604    in maybe_process_partial_specialization and reassign them or complain
3605    as appropriate.
3606
3607    In both cases, the TREE_PURPOSE of each node contains the arguments
3608    used; the TREE_VALUE contains the generated variable.  The template
3609    arguments are always complete.  For example, given:
3610
3611       template <class T> struct S1 {
3612         template <class U> struct S2 {};
3613         template <class U> struct S2<U*> {};
3614       };
3615
3616    the record for the partial specialization will contain, as its
3617    argument list, { {T}, {U*} }, and will be on the
3618    DECL_TEMPLATE_INSTANTIATIONS list for `template <class T> template
3619    <class U> struct S1<T>::S2'.
3620
3621    This list is not used for other templates.  */
3622 #define DECL_TEMPLATE_INSTANTIATIONS(NODE) DECL_VINDEX (NODE)
3623 /* For a class template, this list contains the partial
3624    specializations of this template.  (Full specializations are not
3625    recorded on this list.)  The TREE_PURPOSE holds the arguments used
3626    in the partial specialization (e.g., for `template <class T> struct
3627    S<T*, int>' this will be `T*'.)  The arguments will also include
3628    any outer template arguments.  The TREE_VALUE holds the innermost
3629    template parameters for the specialization (e.g., `T' in the
3630    example above.)  The TREE_TYPE is the _TYPE node for the partial
3631    specialization.
3632
3633    This list is not used for other templates.  */
3634 #define DECL_TEMPLATE_SPECIALIZATIONS(NODE)     DECL_SIZE (NODE)
3635
3636 /* Nonzero for a DECL which is actually a template parameter.  Keep
3637    these checks in ascending tree code order.   */
3638 #define DECL_TEMPLATE_PARM_P(NODE)              \
3639   (DECL_LANG_FLAG_0 (NODE)                      \
3640    && (TREE_CODE (NODE) == CONST_DECL           \
3641        || TREE_CODE (NODE) == PARM_DECL         \
3642        || TREE_CODE (NODE) == TYPE_DECL         \
3643        || TREE_CODE (NODE) == TEMPLATE_DECL))
3644
3645 /* Mark NODE as a template parameter.  */
3646 #define SET_DECL_TEMPLATE_PARM_P(NODE) \
3647   (DECL_LANG_FLAG_0 (NODE) = 1)
3648
3649 /* Nonzero if NODE is a template template parameter.  */
3650 #define DECL_TEMPLATE_TEMPLATE_PARM_P(NODE) \
3651   (TREE_CODE (NODE) == TEMPLATE_DECL && DECL_TEMPLATE_PARM_P (NODE))
3652
3653 /* Nonzero if NODE is a TEMPLATE_DECL representing an
3654    UNBOUND_CLASS_TEMPLATE tree node.  */
3655 #define DECL_UNBOUND_CLASS_TEMPLATE_P(NODE) \
3656   (TREE_CODE (NODE) == TEMPLATE_DECL && !DECL_TEMPLATE_RESULT (NODE))
3657
3658 #define DECL_FUNCTION_TEMPLATE_P(NODE)  \
3659   (TREE_CODE (NODE) == TEMPLATE_DECL \
3660    && !DECL_UNBOUND_CLASS_TEMPLATE_P (NODE) \
3661    && TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == FUNCTION_DECL)
3662
3663 /* Nonzero for a DECL that represents a class template or alias
3664    template.  */
3665 #define DECL_TYPE_TEMPLATE_P(NODE)                              \
3666   (TREE_CODE (NODE) == TEMPLATE_DECL                            \
3667    && DECL_TEMPLATE_RESULT (NODE) != NULL_TREE                  \
3668    && TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == TYPE_DECL)
3669
3670 /* Nonzero for a DECL that represents a class template.  */
3671 #define DECL_CLASS_TEMPLATE_P(NODE)                             \
3672   (DECL_TYPE_TEMPLATE_P (NODE)                                  \
3673    && DECL_IMPLICIT_TYPEDEF_P (DECL_TEMPLATE_RESULT (NODE)))
3674
3675 /* Nonzero for a TEMPLATE_DECL that represents an alias template.  */
3676 #define DECL_ALIAS_TEMPLATE_P(NODE)                     \
3677   (DECL_TYPE_TEMPLATE_P (NODE)                          \
3678    && !DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (NODE)))
3679
3680 /* Nonzero for a NODE which declares a type.  */
3681 #define DECL_DECLARES_TYPE_P(NODE) \
3682   (TREE_CODE (NODE) == TYPE_DECL || DECL_CLASS_TEMPLATE_P (NODE))
3683
3684 /* Nonzero if NODE declares a function.  */
3685 #define DECL_DECLARES_FUNCTION_P(NODE) \
3686   (TREE_CODE (NODE) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (NODE))
3687
3688 /* Nonzero if NODE is the typedef implicitly generated for a type when
3689    the type is declared.  In C++, `struct S {};' is roughly
3690    equivalent to `struct S {}; typedef struct S S;' in C.
3691    DECL_IMPLICIT_TYPEDEF_P will hold for the typedef indicated in this
3692    example.  In C++, there is a second implicit typedef for each
3693    class, in the scope of `S' itself, so that you can say `S::S'.
3694    DECL_SELF_REFERENCE_P will hold for that second typedef.  */
3695 #define DECL_IMPLICIT_TYPEDEF_P(NODE) \
3696   (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_2 (NODE))
3697 #define SET_DECL_IMPLICIT_TYPEDEF_P(NODE) \
3698   (DECL_LANG_FLAG_2 (NODE) = 1)
3699 #define DECL_SELF_REFERENCE_P(NODE) \
3700   (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_4 (NODE))
3701 #define SET_DECL_SELF_REFERENCE_P(NODE) \
3702   (DECL_LANG_FLAG_4 (NODE) = 1)
3703
3704 /* A `primary' template is one that has its own template header.  A
3705    member function of a class template is a template, but not primary.
3706    A member template is primary.  Friend templates are primary, too.  */
3707
3708 /* Returns the primary template corresponding to these parameters.  */
3709 #define DECL_PRIMARY_TEMPLATE(NODE) \
3710   (TREE_TYPE (DECL_INNERMOST_TEMPLATE_PARMS (NODE)))
3711
3712 /* Returns nonzero if NODE is a primary template.  */
3713 #define PRIMARY_TEMPLATE_P(NODE) (DECL_PRIMARY_TEMPLATE (NODE) == (NODE))
3714
3715 /* Nonzero iff NODE is a specialization of a template.  The value
3716    indicates the type of specializations:
3717
3718      1=implicit instantiation
3719
3720      2=partial or explicit specialization, e.g.:
3721
3722         template <> int min<int> (int, int),
3723
3724      3=explicit instantiation, e.g.:
3725   
3726         template int min<int> (int, int);
3727
3728    Note that NODE will be marked as a specialization even if the
3729    template it is instantiating is not a primary template.  For
3730    example, given:
3731
3732      template <typename T> struct O { 
3733        void f();
3734        struct I {}; 
3735      };
3736     
3737    both O<int>::f and O<int>::I will be marked as instantiations.
3738
3739    If DECL_USE_TEMPLATE is nonzero, then DECL_TEMPLATE_INFO will also
3740    be non-NULL.  */
3741 #define DECL_USE_TEMPLATE(NODE) (DECL_LANG_SPECIFIC (NODE)->u.base.use_template)
3742
3743 /* Like DECL_USE_TEMPLATE, but for class types.  */
3744 #define CLASSTYPE_USE_TEMPLATE(NODE) \
3745   (LANG_TYPE_CLASS_CHECK (NODE)->use_template)
3746
3747 /* True if NODE is a specialization of a primary template.  */
3748 #define CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P(NODE)    \
3749   (CLASS_TYPE_P (NODE)                                          \
3750    && CLASSTYPE_USE_TEMPLATE (NODE)                             \
3751    && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE)))
3752
3753 #define DECL_TEMPLATE_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) & 1)
3754 #define CLASSTYPE_TEMPLATE_INSTANTIATION(NODE) \
3755   (CLASSTYPE_USE_TEMPLATE (NODE) & 1)
3756
3757 #define DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) == 2)
3758 #define SET_DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) = 2)
3759
3760 /* Returns true for an explicit or partial specialization of a class
3761    template.  */
3762 #define CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \
3763   (CLASSTYPE_USE_TEMPLATE (NODE) == 2)
3764 #define SET_CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \
3765   (CLASSTYPE_USE_TEMPLATE (NODE) = 2)
3766
3767 #define DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 1)
3768 #define SET_DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 1)
3769 #define CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \
3770   (CLASSTYPE_USE_TEMPLATE (NODE) == 1)
3771 #define SET_CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \
3772   (CLASSTYPE_USE_TEMPLATE (NODE) = 1)
3773
3774 #define DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 3)
3775 #define SET_DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 3)
3776 #define CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \
3777   (CLASSTYPE_USE_TEMPLATE (NODE) == 3)
3778 #define SET_CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \
3779   (CLASSTYPE_USE_TEMPLATE (NODE) = 3)
3780
3781 /* Nonzero if DECL is a friend function which is an instantiation
3782    from the point of view of the compiler, but not from the point of
3783    view of the language.  For example given:
3784       template <class T> struct S { friend void f(T) {}; };
3785    the declaration of `void f(int)' generated when S<int> is
3786    instantiated will not be a DECL_TEMPLATE_INSTANTIATION, but will be
3787    a DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION.  */
3788 #define DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION(DECL) \
3789   (DECL_TEMPLATE_INFO (DECL) && !DECL_USE_TEMPLATE (DECL))
3790
3791 /* Nonzero if DECL is a function generated from a function 'temploid',
3792    i.e. template, member of class template, or dependent friend.  */
3793 #define DECL_TEMPLOID_INSTANTIATION(DECL)               \
3794   (DECL_TEMPLATE_INSTANTIATION (DECL)                   \
3795    || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (DECL))
3796
3797 /* Nonzero if DECL is either defined implicitly by the compiler or
3798    generated from a temploid.  */
3799 #define DECL_GENERATED_P(DECL) \
3800   (DECL_TEMPLOID_INSTANTIATION (DECL) || DECL_DEFAULTED_FN (DECL))
3801
3802 /* Nonzero iff we are currently processing a declaration for an
3803    entity with its own template parameter list, and which is not a
3804    full specialization.  */
3805 #define PROCESSING_REAL_TEMPLATE_DECL_P() \
3806   (processing_template_decl > template_class_depth (current_scope ()))
3807
3808 /* Nonzero if this VAR_DECL or FUNCTION_DECL has already been
3809    instantiated, i.e. its definition has been generated from the
3810    pattern given in the template.  */
3811 #define DECL_TEMPLATE_INSTANTIATED(NODE) \
3812   DECL_LANG_FLAG_1 (VAR_OR_FUNCTION_DECL_CHECK (NODE))
3813
3814 /* We know what we're doing with this decl now.  */
3815 #define DECL_INTERFACE_KNOWN(NODE) DECL_LANG_FLAG_5 (NODE)
3816
3817 /* DECL_EXTERNAL must be set on a decl until the decl is actually emitted,
3818    so that assemble_external will work properly.  So we have this flag to
3819    tell us whether the decl is really not external.
3820
3821    This flag does not indicate whether or not the decl is defined in the
3822    current translation unit; it indicates whether or not we should emit the
3823    decl at the end of compilation if it is defined and needed.  */
3824 #define DECL_NOT_REALLY_EXTERN(NODE) \
3825   (DECL_LANG_SPECIFIC (NODE)->u.base.not_really_extern)
3826
3827 #define DECL_REALLY_EXTERN(NODE) \
3828   (DECL_EXTERNAL (NODE) && ! DECL_NOT_REALLY_EXTERN (NODE))
3829
3830 /* A thunk is a stub function.
3831
3832    A thunk is an alternate entry point for an ordinary FUNCTION_DECL.
3833    The address of the ordinary FUNCTION_DECL is given by the
3834    DECL_INITIAL, which is always an ADDR_EXPR whose operand is a
3835    FUNCTION_DECL.  The job of the thunk is to either adjust the this
3836    pointer before transferring control to the FUNCTION_DECL, or call
3837    FUNCTION_DECL and then adjust the result value. Note, the result
3838    pointer adjusting thunk must perform a call to the thunked
3839    function, (or be implemented via passing some invisible parameter
3840    to the thunked function, which is modified to perform the
3841    adjustment just before returning).
3842
3843    A thunk may perform either, or both, of the following operations:
3844
3845    o Adjust the this or result pointer by a constant offset.
3846    o Adjust the this or result pointer by looking up a vcall or vbase offset
3847      in the vtable.
3848
3849    A this pointer adjusting thunk converts from a base to a derived
3850    class, and hence adds the offsets. A result pointer adjusting thunk
3851    converts from a derived class to a base, and hence subtracts the
3852    offsets.  If both operations are performed, then the constant
3853    adjustment is performed first for this pointer adjustment and last
3854    for the result pointer adjustment.
3855
3856    The constant adjustment is given by THUNK_FIXED_OFFSET.  If the
3857    vcall or vbase offset is required, THUNK_VIRTUAL_OFFSET is
3858    used. For this pointer adjusting thunks, it is the vcall offset
3859    into the vtable.  For result pointer adjusting thunks it is the
3860    binfo of the virtual base to convert to.  Use that binfo's vbase
3861    offset.
3862
3863    It is possible to have equivalent covariant thunks.  These are
3864    distinct virtual covariant thunks whose vbase offsets happen to
3865    have the same value.  THUNK_ALIAS is used to pick one as the
3866    canonical thunk, which will get all the this pointer adjusting
3867    thunks attached to it.  */
3868
3869 /* An integer indicating how many bytes should be subtracted from the
3870    this or result pointer when this function is called.  */
3871 #define THUNK_FIXED_OFFSET(DECL) \
3872   (DECL_LANG_SPECIFIC (THUNK_FUNCTION_CHECK (DECL))->u.fn.u5.fixed_offset)
3873
3874 /* A tree indicating how to perform the virtual adjustment. For a this
3875    adjusting thunk it is the number of bytes to be added to the vtable
3876    to find the vcall offset. For a result adjusting thunk, it is the
3877    binfo of the relevant virtual base.  If NULL, then there is no
3878    virtual adjust.  (The vptr is always located at offset zero from
3879    the this or result pointer.)  (If the covariant type is within the
3880    class hierarchy being laid out, the vbase index is not yet known
3881    at the point we need to create the thunks, hence the need to use
3882    binfos.)  */
3883
3884 #define THUNK_VIRTUAL_OFFSET(DECL) \
3885   (LANG_DECL_U2_CHECK (FUNCTION_DECL_CHECK (DECL), 0)->access)
3886
3887 /* A thunk which is equivalent to another thunk.  */
3888 #define THUNK_ALIAS(DECL) \
3889   (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->u.min.template_info)
3890
3891 /* For thunk NODE, this is the FUNCTION_DECL thunked to.  It is
3892    possible for the target to be a thunk too.  */
3893 #define THUNK_TARGET(NODE)                              \
3894   (LANG_DECL_FN_CHECK (NODE)->befriending_classes)
3895
3896 /* True for a SCOPE_REF iff the "template" keyword was used to
3897    indicate that the qualified name denotes a template.  */
3898 #define QUALIFIED_NAME_IS_TEMPLATE(NODE) \
3899   (TREE_LANG_FLAG_1 (SCOPE_REF_CHECK (NODE)))
3900
3901 /* True for an OMP_ATOMIC that has dependent parameters.  These are stored
3902    as an expr in operand 1, and integer_zero_node in operand 0.  */
3903 #define OMP_ATOMIC_DEPENDENT_P(NODE) \
3904   (TREE_CODE (TREE_OPERAND (OMP_ATOMIC_CHECK (NODE), 0)) == INTEGER_CST)
3905
3906 /* Used while gimplifying continue statements bound to OMP_FOR nodes.  */
3907 #define OMP_FOR_GIMPLIFYING_P(NODE) \
3908   (TREE_LANG_FLAG_0 (OMP_FOR_CHECK (NODE)))
3909
3910 /* A language-specific token attached to the OpenMP data clauses to
3911    hold code (or code fragments) related to ctors, dtors, and op=.
3912    See semantics.c for details.  */
3913 #define CP_OMP_CLAUSE_INFO(NODE) \
3914   TREE_TYPE (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_PRIVATE, \
3915                                      OMP_CLAUSE_COPYPRIVATE))
3916
3917 /* Nonzero if this transaction expression's body contains statements.  */
3918 #define TRANSACTION_EXPR_IS_STMT(NODE) \
3919    TREE_LANG_FLAG_0 (TRANSACTION_EXPR_CHECK (NODE))
3920
3921 /* These macros provide convenient access to the various _STMT nodes
3922    created when parsing template declarations.  */
3923 #define TRY_STMTS(NODE)         TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 0)
3924 #define TRY_HANDLERS(NODE)      TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 1)
3925
3926 #define EH_SPEC_STMTS(NODE)     TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 0)
3927 #define EH_SPEC_RAISES(NODE)    TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 1)
3928
3929 #define USING_STMT_NAMESPACE(NODE) TREE_OPERAND (USING_STMT_CHECK (NODE), 0)
3930
3931 /* Nonzero if this try block is a function try block.  */
3932 #define FN_TRY_BLOCK_P(NODE)    TREE_LANG_FLAG_3 (TRY_BLOCK_CHECK (NODE))
3933 #define HANDLER_PARMS(NODE)     TREE_OPERAND (HANDLER_CHECK (NODE), 0)
3934 #define HANDLER_BODY(NODE)      TREE_OPERAND (HANDLER_CHECK (NODE), 1)
3935 #define HANDLER_TYPE(NODE)      TREE_TYPE (HANDLER_CHECK (NODE))
3936
3937 /* CLEANUP_STMT accessors.  The statement(s) covered, the cleanup to run
3938    and the VAR_DECL for which this cleanup exists.  */
3939 #define CLEANUP_BODY(NODE)      TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 0)
3940 #define CLEANUP_EXPR(NODE)      TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 1)
3941 #define CLEANUP_DECL(NODE)      TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 2)
3942
3943 /* IF_STMT accessors. These give access to the condition of the if
3944    statement, the then block of the if statement, and the else block
3945    of the if statement if it exists.  */
3946 #define IF_COND(NODE)           TREE_OPERAND (IF_STMT_CHECK (NODE), 0)
3947 #define THEN_CLAUSE(NODE)       TREE_OPERAND (IF_STMT_CHECK (NODE), 1)
3948 #define ELSE_CLAUSE(NODE)       TREE_OPERAND (IF_STMT_CHECK (NODE), 2)
3949 #define IF_SCOPE(NODE)          TREE_OPERAND (IF_STMT_CHECK (NODE), 3)
3950
3951 /* WHILE_STMT accessors. These give access to the condition of the
3952    while statement and the body of the while statement, respectively.  */
3953 #define WHILE_COND(NODE)        TREE_OPERAND (WHILE_STMT_CHECK (NODE), 0)
3954 #define WHILE_BODY(NODE)        TREE_OPERAND (WHILE_STMT_CHECK (NODE), 1)
3955
3956 /* DO_STMT accessors. These give access to the condition of the do
3957    statement and the body of the do statement, respectively.  */
3958 #define DO_COND(NODE)           TREE_OPERAND (DO_STMT_CHECK (NODE), 0)
3959 #define DO_BODY(NODE)           TREE_OPERAND (DO_STMT_CHECK (NODE), 1)
3960
3961 /* FOR_STMT accessors. These give access to the init statement,
3962    condition, update expression, and body of the for statement,
3963    respectively.  */
3964 #define FOR_INIT_STMT(NODE)     TREE_OPERAND (FOR_STMT_CHECK (NODE), 0)
3965 #define FOR_COND(NODE)          TREE_OPERAND (FOR_STMT_CHECK (NODE), 1)
3966 #define FOR_EXPR(NODE)          TREE_OPERAND (FOR_STMT_CHECK (NODE), 2)
3967 #define FOR_BODY(NODE)          TREE_OPERAND (FOR_STMT_CHECK (NODE), 3)
3968 #define FOR_SCOPE(NODE)         TREE_OPERAND (FOR_STMT_CHECK (NODE), 4)
3969
3970 /* RANGE_FOR_STMT accessors. These give access to the declarator,
3971    expression, body, and scope of the statement, respectively.  */
3972 #define RANGE_FOR_DECL(NODE)    TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 0)
3973 #define RANGE_FOR_EXPR(NODE)    TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 1)
3974 #define RANGE_FOR_BODY(NODE)    TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 2)
3975 #define RANGE_FOR_SCOPE(NODE)   TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 3)
3976
3977 #define SWITCH_STMT_COND(NODE)  TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 0)
3978 #define SWITCH_STMT_BODY(NODE)  TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 1)
3979 #define SWITCH_STMT_TYPE(NODE)  TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 2)
3980 #define SWITCH_STMT_SCOPE(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 3)
3981
3982 /* STMT_EXPR accessor.  */
3983 #define STMT_EXPR_STMT(NODE)    TREE_OPERAND (STMT_EXPR_CHECK (NODE), 0)
3984
3985 /* EXPR_STMT accessor. This gives the expression associated with an
3986    expression statement.  */
3987 #define EXPR_STMT_EXPR(NODE)    TREE_OPERAND (EXPR_STMT_CHECK (NODE), 0)
3988
3989 /* True if this TARGET_EXPR was created by build_cplus_new, and so we can
3990    discard it if it isn't useful.  */
3991 #define TARGET_EXPR_IMPLICIT_P(NODE) \
3992   TREE_LANG_FLAG_0 (TARGET_EXPR_CHECK (NODE))
3993
3994 /* True if this TARGET_EXPR is the result of list-initialization of a
3995    temporary.  */
3996 #define TARGET_EXPR_LIST_INIT_P(NODE) \
3997   TREE_LANG_FLAG_1 (TARGET_EXPR_CHECK (NODE))
3998
3999 /* True if this TARGET_EXPR expresses direct-initialization of an object
4000    to be named later.  */
4001 #define TARGET_EXPR_DIRECT_INIT_P(NODE) \
4002   TREE_LANG_FLAG_2 (TARGET_EXPR_CHECK (NODE))
4003
4004 /* True if EXPR expresses direct-initialization of a TYPE.  */
4005 #define DIRECT_INIT_EXPR_P(TYPE,EXPR)                                   \
4006   (TREE_CODE (EXPR) == TARGET_EXPR && TREE_LANG_FLAG_2 (EXPR)           \
4007    && same_type_ignoring_top_level_qualifiers_p (TYPE, TREE_TYPE (EXPR)))
4008
4009 /* An enumeration of the kind of tags that C++ accepts.  */
4010 enum tag_types {
4011   none_type = 0, /* Not a tag type.  */
4012   record_type,   /* "struct" types.  */
4013   class_type,    /* "class" types.  */
4014   union_type,    /* "union" types.  */
4015   enum_type,     /* "enum" types.  */
4016   typename_type  /* "typename" types.  */
4017 };
4018
4019 /* The various kinds of lvalues we distinguish.  */
4020 enum cp_lvalue_kind_flags {
4021   clk_none = 0,     /* Things that are not an lvalue.  */
4022   clk_ordinary = 1, /* An ordinary lvalue.  */
4023   clk_rvalueref = 2,/* An rvalue formed using an rvalue reference */
4024   clk_class = 4,    /* An rvalue of class-type.  */
4025   clk_bitfield = 8, /* An lvalue for a bit-field.  */
4026   clk_packed = 16   /* An lvalue for a packed field.  */
4027 };
4028
4029 /* This type is used for parameters and variables which hold
4030    combinations of the flags in enum cp_lvalue_kind_flags.  */
4031 typedef int cp_lvalue_kind;
4032
4033 /* Various kinds of template specialization, instantiation, etc.  */
4034 typedef enum tmpl_spec_kind {
4035   tsk_none,                /* Not a template at all.  */
4036   tsk_invalid_member_spec, /* An explicit member template
4037                               specialization, but the enclosing
4038                               classes have not all been explicitly
4039                               specialized.  */
4040   tsk_invalid_expl_inst,   /* An explicit instantiation containing
4041                               template parameter lists.  */
4042   tsk_excessive_parms,     /* A template declaration with too many
4043                               template parameter lists.  */
4044   tsk_insufficient_parms,  /* A template declaration with too few
4045                               parameter lists.  */
4046   tsk_template,            /* A template declaration.  */
4047   tsk_expl_spec,           /* An explicit specialization.  */
4048   tsk_expl_inst            /* An explicit instantiation.  */
4049 } tmpl_spec_kind;
4050
4051 /* The various kinds of access.  BINFO_ACCESS depends on these being
4052    two bit quantities.  The numerical values are important; they are
4053    used to initialize RTTI data structures, so changing them changes
4054    the ABI.  */
4055 typedef enum access_kind {
4056   ak_none = 0,             /* Inaccessible.  */
4057   ak_public = 1,           /* Accessible, as a `public' thing.  */
4058   ak_protected = 2,        /* Accessible, as a `protected' thing.  */
4059   ak_private = 3           /* Accessible, as a `private' thing.  */
4060 } access_kind;
4061
4062 /* The various kinds of special functions.  If you add to this list,
4063    you should update special_function_p as well.  */
4064 typedef enum special_function_kind {
4065   sfk_none = 0,            /* Not a special function.  This enumeral
4066                               must have value zero; see
4067                               special_function_p.  */
4068   sfk_constructor,         /* A constructor.  */
4069   sfk_copy_constructor,    /* A copy constructor.  */
4070   sfk_move_constructor,    /* A move constructor.  */
4071   sfk_copy_assignment,     /* A copy assignment operator.  */
4072   sfk_move_assignment,     /* A move assignment operator.  */
4073   sfk_destructor,          /* A destructor.  */
4074   sfk_complete_destructor, /* A destructor for complete objects.  */
4075   sfk_base_destructor,     /* A destructor for base subobjects.  */
4076   sfk_deleting_destructor, /* A destructor for complete objects that
4077                               deletes the object after it has been
4078                               destroyed.  */
4079   sfk_conversion           /* A conversion operator.  */
4080 } special_function_kind;
4081
4082 /* The various kinds of linkage.  From [basic.link],
4083
4084       A name is said to have linkage when it might denote the same
4085       object, reference, function, type, template, namespace or value
4086       as a name introduced in another scope:
4087
4088   &nb