OSDN Git Service

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