OSDN Git Service

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