From 40d7cd0fd78fe2004e2a53c4618c148339b02733 Mon Sep 17 00:00:00 2001 From: Jing Yu Date: Mon, 19 Dec 2011 16:56:54 -0800 Subject: Add gcc-4.6. Synced to @180989 Change-Id: Ie3676586e1d8e3c8cd9f07d022f450d05fa08439 svn://gcc.gnu.org/svn/gcc/branches/google/gcc-4_6-mobile --- gcc-4.6/gcc/cp/cp-tree.h | 5682 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 5682 insertions(+) create mode 100644 gcc-4.6/gcc/cp/cp-tree.h (limited to 'gcc-4.6/gcc/cp/cp-tree.h') diff --git a/gcc-4.6/gcc/cp/cp-tree.h b/gcc-4.6/gcc/cp/cp-tree.h new file mode 100644 index 000000000..9745797a4 --- /dev/null +++ b/gcc-4.6/gcc/cp/cp-tree.h @@ -0,0 +1,5682 @@ +/* Definitions for C++ parsing and type checking. + Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, + 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 + Free Software Foundation, Inc. + Contributed by Michael Tiemann (tiemann@cygnus.com) + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +#ifndef GCC_CP_TREE_H +#define GCC_CP_TREE_H + +#include "ggc.h" +#include "function.h" +#include "hashtab.h" +#include "vec.h" +#include "l-ipo.h" + +/* In order for the format checking to accept the C++ front end + diagnostic framework extensions, you must include this file before + diagnostic-core.h, not after. We override the definition of GCC_DIAG_STYLE + in c-common.h. */ +#undef GCC_DIAG_STYLE +#define GCC_DIAG_STYLE __gcc_cxxdiag__ +#if defined(GCC_DIAGNOSTIC_CORE_H) || defined (GCC_C_COMMON_H) +#error \ +In order for the format checking to accept the C++ front end diagnostic \ +framework extensions, you must include this file before diagnostic-core.h and \ +c-common.h, not after. +#endif +#include "c-family/c-common.h" +#include "diagnostic.h" + +#include "name-lookup.h" + +/* Usage of TREE_LANG_FLAG_?: + 0: IDENTIFIER_MARKED (IDENTIFIER_NODEs) + NEW_EXPR_USE_GLOBAL (in NEW_EXPR). + DELETE_EXPR_USE_GLOBAL (in DELETE_EXPR). + COMPOUND_EXPR_OVERLOADED (in COMPOUND_EXPR). + TREE_INDIRECT_USING (in NAMESPACE_DECL). + CLEANUP_P (in TRY_BLOCK) + AGGR_INIT_VIA_CTOR_P (in AGGR_INIT_EXPR) + PTRMEM_OK_P (in ADDR_EXPR, OFFSET_REF) + PAREN_STRING_LITERAL (in STRING_CST) + DECL_PRETTY_FUNCTION_P (in VAR_DECL) + KOENIG_LOOKUP_P (in CALL_EXPR) + STATEMENT_LIST_NO_SCOPE (in STATEMENT_LIST). + EXPR_STMT_STMT_EXPR_RESULT (in EXPR_STMT) + STMT_EXPR_NO_SCOPE (in STMT_EXPR) + BIND_EXPR_TRY_BLOCK (in BIND_EXPR) + TYPENAME_IS_ENUM_P (in TYPENAME_TYPE) + REFERENCE_REF_P (in INDIRECT_EXPR) + QUALIFIED_NAME_IS_TEMPLATE (in SCOPE_REF) + OMP_FOR_GIMPLIFYING_P (in OMP_FOR) + BASELINK_QUALIFIED_P (in BASELINK) + TARGET_EXPR_IMPLICIT_P (in TARGET_EXPR) + TEMPLATE_PARM_PARAMETER_PACK (in TEMPLATE_PARM_INDEX) + ATTR_IS_DEPENDENT (in the TREE_LIST for an attribute) + CONSTRUCTOR_IS_DIRECT_INIT (in CONSTRUCTOR) + LAMBDA_EXPR_CAPTURES_THIS_P (in LAMBDA_EXPR) + DECLTYPE_FOR_LAMBDA_CAPTURE (in DECLTYPE_TYPE) + VEC_INIT_EXPR_IS_CONSTEXPR (in VEC_INIT_EXPR) + 1: IDENTIFIER_VIRTUAL_P (in IDENTIFIER_NODE) + TI_PENDING_TEMPLATE_FLAG. + TEMPLATE_PARMS_FOR_INLINE. + DELETE_EXPR_USE_VEC (in DELETE_EXPR). + (TREE_CALLS_NEW) (in _EXPR or _REF) (commented-out). + ICS_ELLIPSIS_FLAG (in _CONV) + DECL_INITIALIZED_P (in VAR_DECL) + TYPENAME_IS_CLASS_P (in TYPENAME_TYPE) + STMT_IS_FULL_EXPR_P (in _STMT) + TARGET_EXPR_LIST_INIT_P (in TARGET_EXPR) + LAMBDA_EXPR_MUTABLE_P (in LAMBDA_EXPR) + DECLTYPE_FOR_LAMBDA_RETURN (in DECLTYPE_TYPE) + 2: IDENTIFIER_OPNAME_P (in IDENTIFIER_NODE) + ICS_THIS_FLAG (in _CONV) + DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (in VAR_DECL) + STATEMENT_LIST_TRY_BLOCK (in STATEMENT_LIST) + TYPENAME_IS_RESOLVING_P (in TYPE_NAME_TYPE) + LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P (in LAMBDA_EXPR) + TARGET_EXPR_DIRECT_INIT_P (in TARGET_EXPR) + 3: (TREE_REFERENCE_EXPR) (in NON_LVALUE_EXPR) (commented-out). + ICS_BAD_FLAG (in _CONV) + FN_TRY_BLOCK_P (in TRY_BLOCK) + IDENTIFIER_CTOR_OR_DTOR_P (in IDENTIFIER_NODE) + BIND_EXPR_BODY_BLOCK (in BIND_EXPR) + DECL_NON_TRIVIALLY_INITIALIZED_P (in VAR_DECL) + 4: TREE_HAS_CONSTRUCTOR (in INDIRECT_REF, SAVE_EXPR, CONSTRUCTOR, + or FIELD_DECL). + IDENTIFIER_TYPENAME_P (in IDENTIFIER_NODE) + DECL_TINFO_P (in VAR_DECL) + 5: C_IS_RESERVED_WORD (in IDENTIFIER_NODE) + DECL_VTABLE_OR_VTT_P (in VAR_DECL) + 6: IDENTIFIER_REPO_CHOSEN (in IDENTIFIER_NODE) + DECL_CONSTRUCTION_VTABLE_P (in VAR_DECL) + TYPE_MARKED_P (in _TYPE) + + Usage of TYPE_LANG_FLAG_?: + 0: TYPE_DEPENDENT_P + 1: TYPE_HAS_USER_CONSTRUCTOR. + 2: unused + 3: TYPE_FOR_JAVA. + 4: TYPE_HAS_NONTRIVIAL_DESTRUCTOR + 5: CLASS_TYPE_P (in RECORD_TYPE and UNION_TYPE) + ENUM_FIXED_UNDERLYING_TYPE_P (in ENUMERAL_TYPE) + 6: TYPE_DEPENDENT_P_VALID + + Usage of DECL_LANG_FLAG_?: + 0: DECL_ERROR_REPORTED (in VAR_DECL). + DECL_TEMPLATE_PARM_P (in PARM_DECL, CONST_DECL, TYPE_DECL, or TEMPLATE_DECL) + DECL_LOCAL_FUNCTION_P (in FUNCTION_DECL) + DECL_MUTABLE_P (in FIELD_DECL) + DECL_DEPENDENT_P (in USING_DECL) + 1: C_TYPEDEF_EXPLICITLY_SIGNED (in TYPE_DECL). + DECL_TEMPLATE_INSTANTIATED (in a VAR_DECL or a FUNCTION_DECL) + DECL_MEMBER_TEMPLATE_P (in TEMPLATE_DECL) + FUNCTION_PARAMETER_PACK_P (in PARM_DECL) + 2: DECL_THIS_EXTERN (in VAR_DECL or FUNCTION_DECL). + DECL_IMPLICIT_TYPEDEF_P (in a TYPE_DECL) + 3: DECL_IN_AGGR_P. + 4: DECL_C_BIT_FIELD (in a FIELD_DECL) + DECL_ANON_UNION_VAR_P (in a VAR_DECL) + DECL_SELF_REFERENCE_P (in a TYPE_DECL) + DECL_INVALID_OVERRIDER_P (in a FUNCTION_DECL) + 5: DECL_INTERFACE_KNOWN. + 6: DECL_THIS_STATIC (in VAR_DECL or FUNCTION_DECL). + DECL_FIELD_IS_BASE (in FIELD_DECL) + 7: DECL_DEAD_FOR_LOCAL (in VAR_DECL). + DECL_THUNK_P (in a member FUNCTION_DECL) + DECL_NORMAL_CAPTURE_P (in FIELD_DECL) + 8: DECL_DECLARED_CONSTEXPR_P (in VAR_DECL, FUNCTION_DECL) + + Usage of language-independent fields in a language-dependent manner: + + TYPE_ALIAS_SET + This field is used by TYPENAME_TYPEs, TEMPLATE_TYPE_PARMs, and so + forth as a substitute for the mark bits provided in `lang_type'. + At present, only the six low-order bits are used. + + TYPE_LANG_SLOT_1 + For an ENUMERAL_TYPE, this is ENUM_TEMPLATE_INFO. + For a FUNCTION_TYPE or METHOD_TYPE, this is TYPE_RAISES_EXCEPTIONS + + BINFO_VIRTUALS + For a binfo, this is a TREE_LIST. There is an entry for each + virtual function declared either in BINFO or its direct and + indirect primary bases. + + The BV_DELTA of each node gives the amount by which to adjust the + `this' pointer when calling the function. If the method is an + overridden version of a base class method, then it is assumed + that, prior to adjustment, the this pointer points to an object + of the base class. + + The BV_VCALL_INDEX of each node, if non-NULL, gives the vtable + index of the vcall offset for this entry. + + The BV_FN is the declaration for the virtual function itself. + + If BV_LOST_PRIMARY is set, it means that this entry is for a lost + primary virtual base and can be left null in the vtable. + + BINFO_VTABLE + This is an expression with POINTER_TYPE that gives the value + to which the vptr should be initialized. Use get_vtbl_decl_for_binfo + to extract the VAR_DECL for the complete vtable. + + DECL_VINDEX + This field is NULL for a non-virtual function. For a virtual + function, it is eventually set to an INTEGER_CST indicating the + index in the vtable at which this function can be found. When + a virtual function is declared, but before it is known what + function is overridden, this field is the error_mark_node. + + Temporarily, it may be set to a TREE_LIST whose TREE_VALUE is + the virtual function this one overrides, and whose TREE_CHAIN is + the old DECL_VINDEX. */ + +/* Language-specific tree checkers. */ + +#define VAR_OR_FUNCTION_DECL_CHECK(NODE) \ + TREE_CHECK2(NODE,VAR_DECL,FUNCTION_DECL) + +#define VAR_FUNCTION_OR_PARM_DECL_CHECK(NODE) \ + TREE_CHECK3(NODE,VAR_DECL,FUNCTION_DECL,PARM_DECL) + +#define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) \ + TREE_CHECK4(NODE,VAR_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL) + +#define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) \ + TREE_CHECK(NODE,BOUND_TEMPLATE_TEMPLATE_PARM) + +#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) +#define THUNK_FUNCTION_CHECK(NODE) __extension__ \ +({ __typeof (NODE) const __t = (NODE); \ + if (TREE_CODE (__t) != FUNCTION_DECL || !__t->decl_common.lang_specific \ + || !__t->decl_common.lang_specific->u.fn.thunk_p) \ + tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, 0); \ + __t; }) +#else +#define THUNK_FUNCTION_CHECK(NODE) (NODE) +#endif + +/* Language-dependent contents of an identifier. */ + +struct GTY(()) lang_identifier { + struct c_common_identifier c_common; + cxx_binding *namespace_bindings; + cxx_binding *bindings; + tree class_template_info; + tree label_value; +}; + +/* In an IDENTIFIER_NODE, nonzero if this identifier is actually a + keyword. C_RID_CODE (node) is then the RID_* value of the keyword, + and C_RID_YYCODE is the token number wanted by Yacc. */ + +#define C_IS_RESERVED_WORD(ID) TREE_LANG_FLAG_5 (ID) + +#define LANG_IDENTIFIER_CAST(NODE) \ + ((struct lang_identifier*)IDENTIFIER_NODE_CHECK (NODE)) + +struct GTY(()) template_parm_index_s { + struct tree_common common; + int index; + int level; + int orig_level; + int num_siblings; + tree decl; +}; +typedef struct template_parm_index_s template_parm_index; + +struct GTY(()) ptrmem_cst { + struct tree_common common; + tree member; +}; +typedef struct ptrmem_cst * ptrmem_cst_t; + +#define IDENTIFIER_GLOBAL_VALUE(NODE) \ + namespace_binding ((NODE), global_namespace) +#define SET_IDENTIFIER_GLOBAL_VALUE(NODE, VAL) \ + set_namespace_binding ((NODE), global_namespace, (VAL)) +#define IDENTIFIER_NAMESPACE_VALUE(NODE) \ + namespace_binding ((NODE), current_namespace) +#define SET_IDENTIFIER_NAMESPACE_VALUE(NODE, VAL) \ + set_namespace_binding ((NODE), current_namespace, (VAL)) + +#define CLEANUP_P(NODE) TREE_LANG_FLAG_0 (TRY_BLOCK_CHECK (NODE)) + +#define BIND_EXPR_TRY_BLOCK(NODE) \ + TREE_LANG_FLAG_0 (BIND_EXPR_CHECK (NODE)) + +/* Used to mark the block around the member initializers and cleanups. */ +#define BIND_EXPR_BODY_BLOCK(NODE) \ + TREE_LANG_FLAG_3 (BIND_EXPR_CHECK (NODE)) +#define FUNCTION_NEEDS_BODY_BLOCK(NODE) \ + (DECL_CONSTRUCTOR_P (NODE) || DECL_DESTRUCTOR_P (NODE)) + +#define STATEMENT_LIST_NO_SCOPE(NODE) \ + TREE_LANG_FLAG_0 (STATEMENT_LIST_CHECK (NODE)) +#define STATEMENT_LIST_TRY_BLOCK(NODE) \ + TREE_LANG_FLAG_2 (STATEMENT_LIST_CHECK (NODE)) + +/* Nonzero if this statement should be considered a full-expression, + i.e., if temporaries created during this statement should have + their destructors run at the end of this statement. */ +#define STMT_IS_FULL_EXPR_P(NODE) TREE_LANG_FLAG_1 ((NODE)) + +/* Marks the result of a statement expression. */ +#define EXPR_STMT_STMT_EXPR_RESULT(NODE) \ + TREE_LANG_FLAG_0 (EXPR_STMT_CHECK (NODE)) + +/* Nonzero if this statement-expression does not have an associated scope. */ +#define STMT_EXPR_NO_SCOPE(NODE) \ + TREE_LANG_FLAG_0 (STMT_EXPR_CHECK (NODE)) + +/* Returns nonzero iff TYPE1 and TYPE2 are the same type, in the usual + sense of `same'. */ +#define same_type_p(TYPE1, TYPE2) \ + comptypes ((TYPE1), (TYPE2), COMPARE_STRICT) + +/* Nonzero if we are presently building a statement tree, rather + than expanding each statement as we encounter it. */ +#define building_stmt_tree() (cur_stmt_list != NULL_TREE) + +/* Returns nonzero iff NODE is a declaration for the global function + `main'. */ +#define DECL_MAIN_P(NODE) \ + (DECL_EXTERN_C_FUNCTION_P (NODE) \ + && DECL_NAME (NODE) != NULL_TREE \ + && MAIN_NAME_P (DECL_NAME (NODE)) \ + && flag_hosted) + +/* The overloaded FUNCTION_DECL. */ +#define OVL_FUNCTION(NODE) \ + (((struct tree_overload*)OVERLOAD_CHECK (NODE))->function) +#define OVL_CHAIN(NODE) TREE_CHAIN (NODE) +/* Polymorphic access to FUNCTION and CHAIN. */ +#define OVL_CURRENT(NODE) \ + ((TREE_CODE (NODE) == OVERLOAD) ? OVL_FUNCTION (NODE) : (NODE)) +#define OVL_NEXT(NODE) \ + ((TREE_CODE (NODE) == OVERLOAD) ? TREE_CHAIN (NODE) : NULL_TREE) +/* If set, this was imported in a using declaration. + This is not to confuse with being used somewhere, which + is not important for this node. */ +#define OVL_USED(NODE) TREE_USED (NODE) + +struct GTY(()) tree_overload { + struct tree_common common; + tree function; +}; + +/* Returns true iff NODE is a BASELINK. */ +#define BASELINK_P(NODE) \ + (TREE_CODE (NODE) == BASELINK) +/* The BINFO indicating the base from which the BASELINK_FUNCTIONS came. */ +#define BASELINK_BINFO(NODE) \ + (((struct tree_baselink*) BASELINK_CHECK (NODE))->binfo) +/* The functions referred to by the BASELINK; either a FUNCTION_DECL, + a TEMPLATE_DECL, an OVERLOAD, or a TEMPLATE_ID_EXPR. */ +#define BASELINK_FUNCTIONS(NODE) \ + (((struct tree_baselink*) BASELINK_CHECK (NODE))->functions) +/* The BINFO in which the search for the functions indicated by this baselink + began. This base is used to determine the accessibility of functions + selected by overload resolution. */ +#define BASELINK_ACCESS_BINFO(NODE) \ + (((struct tree_baselink*) BASELINK_CHECK (NODE))->access_binfo) +/* For a type-conversion operator, the BASELINK_OPTYPE indicates the type + to which the conversion should occur. This value is important if + the BASELINK_FUNCTIONS include a template conversion operator -- + the BASELINK_OPTYPE can be used to determine what type the user + requested. */ +#define BASELINK_OPTYPE(NODE) \ + (TREE_CHAIN (BASELINK_CHECK (NODE))) +/* Nonzero if this baselink was from a qualified lookup. */ +#define BASELINK_QUALIFIED_P(NODE) \ + TREE_LANG_FLAG_0 (BASELINK_CHECK (NODE)) + +struct GTY(()) tree_baselink { + struct tree_common common; + tree binfo; + tree functions; + tree access_binfo; +}; + +/* The different kinds of ids that we encounter. */ + +typedef enum cp_id_kind +{ + /* Not an id at all. */ + CP_ID_KIND_NONE, + /* An unqualified-id that is not a template-id. */ + CP_ID_KIND_UNQUALIFIED, + /* An unqualified-id that is a dependent name. */ + CP_ID_KIND_UNQUALIFIED_DEPENDENT, + /* An unqualified template-id. */ + CP_ID_KIND_TEMPLATE_ID, + /* A qualified-id. */ + CP_ID_KIND_QUALIFIED +} cp_id_kind; + + +/* The various kinds of C++0x warnings we encounter. */ + +typedef enum cpp0x_warn_str +{ + /* extended initializer lists */ + CPP0X_INITIALIZER_LISTS, + /* explicit conversion operators */ + CPP0X_EXPLICIT_CONVERSION, + /* variadic templates */ + CPP0X_VARIADIC_TEMPLATES, + /* lambda expressions */ + CPP0X_LAMBDA_EXPR, + /* C++0x auto */ + CPP0X_AUTO, + /* scoped enums */ + CPP0X_SCOPED_ENUMS, + /* defaulted and deleted functions */ + CPP0X_DEFAULTED_DELETED, + /* inline namespaces */ + CPP0X_INLINE_NAMESPACES +} cpp0x_warn_str; + +/* The various kinds of operation used by composite_pointer_type. */ + +typedef enum composite_pointer_operation +{ + /* comparison */ + CPO_COMPARISON, + /* conversion */ + CPO_CONVERSION, + /* conditional expression */ + CPO_CONDITIONAL_EXPR +} composite_pointer_operation; + +/* Possible cases of expression list used by build_x_compound_expr_from_list. */ +typedef enum expr_list_kind { + ELK_INIT, /* initializer */ + ELK_MEM_INIT, /* member initializer */ + ELK_FUNC_CAST /* functional cast */ +} expr_list_kind; + +/* Possible cases of implicit bad rhs conversions. */ +typedef enum impl_conv_rhs { + ICR_DEFAULT_ARGUMENT, /* default argument */ + ICR_CONVERTING, /* converting */ + ICR_INIT, /* initialization */ + ICR_ARGPASS, /* argument passing */ + ICR_RETURN, /* return */ + ICR_ASSIGN /* assignment */ +} impl_conv_rhs; + +/* Possible cases of implicit or explicit bad conversions to void. */ +typedef enum impl_conv_void { + ICV_CAST, /* (explicit) conversion to void */ + ICV_SECOND_OF_COND, /* second operand of conditional expression */ + ICV_THIRD_OF_COND, /* third operand of conditional expression */ + ICV_RIGHT_OF_COMMA, /* right operand of comma operator */ + ICV_LEFT_OF_COMMA, /* left operand of comma operator */ + ICV_STATEMENT, /* statement */ + ICV_THIRD_IN_FOR /* for increment expression */ +} impl_conv_void; + +/* Macros for access to language-specific slots in an identifier. */ + +#define IDENTIFIER_NAMESPACE_BINDINGS(NODE) \ + (LANG_IDENTIFIER_CAST (NODE)->namespace_bindings) +#define IDENTIFIER_TEMPLATE(NODE) \ + (LANG_IDENTIFIER_CAST (NODE)->class_template_info) + +/* The IDENTIFIER_BINDING is the innermost cxx_binding for the + identifier. It's PREVIOUS is the next outermost binding. Each + VALUE field is a DECL for the associated declaration. Thus, + name lookup consists simply of pulling off the node at the front + of the list (modulo oddities for looking up the names of types, + and such.) You can use SCOPE field to determine the scope + that bound the name. */ +#define IDENTIFIER_BINDING(NODE) \ + (LANG_IDENTIFIER_CAST (NODE)->bindings) + +/* TREE_TYPE only indicates on local and class scope the current + type. For namespace scope, the presence of a type in any namespace + is indicated with global_type_node, and the real type behind must + be found through lookup. */ +#define IDENTIFIER_TYPE_VALUE(NODE) identifier_type_value (NODE) +#define REAL_IDENTIFIER_TYPE_VALUE(NODE) TREE_TYPE (NODE) +#define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = (TYPE)) +#define IDENTIFIER_HAS_TYPE_VALUE(NODE) (IDENTIFIER_TYPE_VALUE (NODE) ? 1 : 0) + +#define IDENTIFIER_LABEL_VALUE(NODE) \ + (LANG_IDENTIFIER_CAST (NODE)->label_value) +#define SET_IDENTIFIER_LABEL_VALUE(NODE, VALUE) \ + IDENTIFIER_LABEL_VALUE (NODE) = (VALUE) + +/* Nonzero if this identifier is used as a virtual function name somewhere + (optimizes searches). */ +#define IDENTIFIER_VIRTUAL_P(NODE) TREE_LANG_FLAG_1 (NODE) + +/* Nonzero if this identifier is the prefix for a mangled C++ operator + name. */ +#define IDENTIFIER_OPNAME_P(NODE) TREE_LANG_FLAG_2 (NODE) + +/* Nonzero if this identifier is the name of a type-conversion + operator. */ +#define IDENTIFIER_TYPENAME_P(NODE) \ + TREE_LANG_FLAG_4 (NODE) + +/* Nonzero if this identifier is the name of a constructor or + destructor. */ +#define IDENTIFIER_CTOR_OR_DTOR_P(NODE) \ + TREE_LANG_FLAG_3 (NODE) + +/* True iff NAME is the DECL_ASSEMBLER_NAME for an entity with vague + linkage which the prelinker has assigned to this translation + unit. */ +#define IDENTIFIER_REPO_CHOSEN(NAME) \ + (TREE_LANG_FLAG_6 (NAME)) + +/* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only. */ +#define C_TYPE_FIELDS_READONLY(TYPE) \ + (LANG_TYPE_CLASS_CHECK (TYPE)->fields_readonly) + +/* The tokens stored in the default argument. */ + +#define DEFARG_TOKENS(NODE) \ + (((struct tree_default_arg *)DEFAULT_ARG_CHECK (NODE))->tokens) +#define DEFARG_INSTANTIATIONS(NODE) \ + (((struct tree_default_arg *)DEFAULT_ARG_CHECK (NODE))->instantiations) + +struct GTY (()) tree_default_arg { + struct tree_common common; + struct cp_token_cache *tokens; + VEC(tree,gc) *instantiations; +}; + +/* The condition associated with the static assertion. This must be + an integral constant expression. */ +#define STATIC_ASSERT_CONDITION(NODE) \ + (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->condition) + +/* The message associated with the static assertion. This must be a + string constant, which will be emitted as an error message when the + static assert condition is false. */ +#define STATIC_ASSERT_MESSAGE(NODE) \ + (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->message) + +/* Source location information for a static assertion. */ +#define STATIC_ASSERT_SOURCE_LOCATION(NODE) \ + (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->location) + +struct GTY (()) tree_static_assert { + struct tree_common common; + tree condition; + tree message; + location_t location; +}; + +struct GTY (()) tree_argument_pack_select { + struct tree_common common; + tree argument_pack; + int index; +}; + +/* The different kinds of traits that we encounter. */ + +typedef enum cp_trait_kind +{ + CPTK_HAS_NOTHROW_ASSIGN, + CPTK_HAS_NOTHROW_CONSTRUCTOR, + CPTK_HAS_NOTHROW_COPY, + CPTK_HAS_TRIVIAL_ASSIGN, + CPTK_HAS_TRIVIAL_CONSTRUCTOR, + CPTK_HAS_TRIVIAL_COPY, + CPTK_HAS_TRIVIAL_DESTRUCTOR, + CPTK_HAS_VIRTUAL_DESTRUCTOR, + CPTK_IS_ABSTRACT, + CPTK_IS_BASE_OF, + CPTK_IS_CLASS, + CPTK_IS_CONVERTIBLE_TO, + CPTK_IS_EMPTY, + CPTK_IS_ENUM, + CPTK_IS_POD, + CPTK_IS_POLYMORPHIC, + CPTK_IS_STD_LAYOUT, + CPTK_IS_TRIVIAL, + CPTK_IS_LITERAL_TYPE, + CPTK_IS_UNION +} cp_trait_kind; + +/* The types that we are processing. */ +#define TRAIT_EXPR_TYPE1(NODE) \ + (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type1) + +#define TRAIT_EXPR_TYPE2(NODE) \ + (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type2) + +/* The specific trait that we are processing. */ +#define TRAIT_EXPR_KIND(NODE) \ + (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->kind) + +struct GTY (()) tree_trait_expr { + struct tree_common common; + tree type1; + tree type2; + enum cp_trait_kind kind; +}; + +/* Based off of TYPE_ANONYMOUS_P. */ +#define LAMBDA_TYPE_P(NODE) \ + (CLASS_TYPE_P (NODE) && LAMBDANAME_P (TYPE_LINKAGE_IDENTIFIER (NODE))) + +/* Test if FUNCTION_DECL is a lambda function. */ +#define LAMBDA_FUNCTION_P(FNDECL) \ + (DECL_OVERLOADED_OPERATOR_P (FNDECL) == CALL_EXPR \ + && LAMBDA_TYPE_P (CP_DECL_CONTEXT (FNDECL))) + +enum cp_lambda_default_capture_mode_type { + CPLD_NONE, + CPLD_COPY, + CPLD_REFERENCE +}; + +/* The method of default capture, if any. */ +#define LAMBDA_EXPR_DEFAULT_CAPTURE_MODE(NODE) \ + (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->default_capture_mode) + +/* The capture-list, including `this'. Each capture is stored as a FIELD_DECL + * so that the name, type, and field are all together, whether or not it has + * been added to the lambda's class type. + TREE_LIST: + TREE_PURPOSE: The FIELD_DECL for this capture. + TREE_VALUE: The initializer. This is part of a GNU extension. */ +#define LAMBDA_EXPR_CAPTURE_LIST(NODE) \ + (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->capture_list) + +/* The node in the capture-list that holds the 'this' capture. */ +#define LAMBDA_EXPR_THIS_CAPTURE(NODE) \ + (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->this_capture) + +/* Predicate tracking whether `this' is in the effective capture set. */ +#define LAMBDA_EXPR_CAPTURES_THIS_P(NODE) \ + LAMBDA_EXPR_THIS_CAPTURE(NODE) + +/* Predicate tracking whether the lambda was declared 'mutable'. */ +#define LAMBDA_EXPR_MUTABLE_P(NODE) \ + TREE_LANG_FLAG_1 (LAMBDA_EXPR_CHECK (NODE)) + +/* True iff we should try to deduce the lambda return type from any return + statement. */ +#define LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P(NODE) \ + TREE_LANG_FLAG_2 (LAMBDA_EXPR_CHECK (NODE)) + +/* The return type in the expression. + * NULL_TREE indicates that none was specified. */ +#define LAMBDA_EXPR_RETURN_TYPE(NODE) \ + (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->return_type) + +/* The source location of the lambda. */ +#define LAMBDA_EXPR_LOCATION(NODE) \ + (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->locus) + +/* The mangling scope for the lambda: FUNCTION_DECL, PARM_DECL, VAR_DECL, + FIELD_DECL or NULL_TREE. If this is NULL_TREE, we have no linkage. */ +#define LAMBDA_EXPR_EXTRA_SCOPE(NODE) \ + (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->extra_scope) + +/* If EXTRA_SCOPE, this is the number of the lambda within that scope. */ +#define LAMBDA_EXPR_DISCRIMINATOR(NODE) \ + (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->discriminator) + +struct GTY (()) tree_lambda_expr +{ + struct tree_common common; + location_t locus; + enum cp_lambda_default_capture_mode_type default_capture_mode; + tree capture_list; + tree this_capture; + tree return_type; + tree extra_scope; + int discriminator; +}; + +/* A (typedef,context,usage location) triplet. + It represents a typedef used through a + context at a given source location. + e.g. + struct foo { + typedef int myint; + }; + + struct bar { + foo::myint v; // #1<-- this location. + }; + + In bar, the triplet will be (myint, foo, #1). + */ +struct GTY(()) qualified_typedef_usage_s { + tree typedef_decl; + tree context; + location_t locus; +}; +typedef struct qualified_typedef_usage_s qualified_typedef_usage_t; +DEF_VEC_O (qualified_typedef_usage_t); +DEF_VEC_ALLOC_O (qualified_typedef_usage_t,gc); + +struct GTY(()) tree_template_info { + struct tree_common common; + VEC(qualified_typedef_usage_t,gc) *typedefs_needing_access_checking; +}; + +enum cp_tree_node_structure_enum { + TS_CP_GENERIC, + TS_CP_IDENTIFIER, + TS_CP_TPI, + TS_CP_PTRMEM, + TS_CP_BINDING, + TS_CP_OVERLOAD, + TS_CP_BASELINK, + TS_CP_WRAPPER, + TS_CP_DEFAULT_ARG, + TS_CP_STATIC_ASSERT, + TS_CP_ARGUMENT_PACK_SELECT, + TS_CP_TRAIT_EXPR, + TS_CP_LAMBDA_EXPR, + TS_CP_TEMPLATE_INFO, + LAST_TS_CP_ENUM +}; + +/* The resulting tree type. */ +union GTY((desc ("cp_tree_node_structure (&%h)"), + chain_next ("(union lang_tree_node *)TREE_CHAIN (&%h.generic)"))) lang_tree_node { + union tree_node GTY ((tag ("TS_CP_GENERIC"), + desc ("tree_node_structure (&%h)"))) generic; + struct template_parm_index_s GTY ((tag ("TS_CP_TPI"))) tpi; + struct ptrmem_cst GTY ((tag ("TS_CP_PTRMEM"))) ptrmem; + struct tree_overload GTY ((tag ("TS_CP_OVERLOAD"))) overload; + struct tree_baselink GTY ((tag ("TS_CP_BASELINK"))) baselink; + struct tree_default_arg GTY ((tag ("TS_CP_DEFAULT_ARG"))) default_arg; + struct lang_identifier GTY ((tag ("TS_CP_IDENTIFIER"))) identifier; + struct tree_static_assert GTY ((tag ("TS_CP_STATIC_ASSERT"))) + static_assertion; + struct tree_argument_pack_select GTY ((tag ("TS_CP_ARGUMENT_PACK_SELECT"))) + argument_pack_select; + struct tree_trait_expr GTY ((tag ("TS_CP_TRAIT_EXPR"))) + trait_expression; + struct tree_lambda_expr GTY ((tag ("TS_CP_LAMBDA_EXPR"))) + lambda_expression; + struct tree_template_info GTY ((tag ("TS_CP_TEMPLATE_INFO"))) + template_info; +}; + + +enum cp_tree_index +{ + CPTI_JAVA_BYTE_TYPE, + CPTI_JAVA_SHORT_TYPE, + CPTI_JAVA_INT_TYPE, + CPTI_JAVA_LONG_TYPE, + CPTI_JAVA_FLOAT_TYPE, + CPTI_JAVA_DOUBLE_TYPE, + CPTI_JAVA_CHAR_TYPE, + CPTI_JAVA_BOOLEAN_TYPE, + + CPTI_WCHAR_DECL, + CPTI_VTABLE_ENTRY_TYPE, + CPTI_DELTA_TYPE, + CPTI_VTABLE_INDEX_TYPE, + CPTI_CLEANUP_TYPE, + CPTI_VTT_PARM_TYPE, + + CPTI_CLASS_TYPE, + CPTI_UNKNOWN_TYPE, + CPTI_INIT_LIST_TYPE, + CPTI_VTBL_TYPE, + CPTI_VTBL_PTR_TYPE, + CPTI_STD, + CPTI_ABI, + CPTI_CONST_TYPE_INFO_TYPE, + CPTI_TYPE_INFO_PTR_TYPE, + CPTI_ABORT_FNDECL, + CPTI_GLOBAL_DELETE_FNDECL, + CPTI_AGGR_TAG, + + CPTI_CTOR_IDENTIFIER, + CPTI_COMPLETE_CTOR_IDENTIFIER, + CPTI_BASE_CTOR_IDENTIFIER, + CPTI_DTOR_IDENTIFIER, + CPTI_COMPLETE_DTOR_IDENTIFIER, + CPTI_BASE_DTOR_IDENTIFIER, + CPTI_DELETING_DTOR_IDENTIFIER, + CPTI_DELTA_IDENTIFIER, + CPTI_IN_CHARGE_IDENTIFIER, + CPTI_VTT_PARM_IDENTIFIER, + CPTI_NELTS_IDENTIFIER, + CPTI_THIS_IDENTIFIER, + CPTI_PFN_IDENTIFIER, + CPTI_VPTR_IDENTIFIER, + CPTI_STD_IDENTIFIER, + + CPTI_LANG_NAME_C, + CPTI_LANG_NAME_CPLUSPLUS, + CPTI_LANG_NAME_JAVA, + + CPTI_EMPTY_EXCEPT_SPEC, + CPTI_NOEXCEPT_TRUE_SPEC, + CPTI_NOEXCEPT_FALSE_SPEC, + CPTI_JCLASS, + CPTI_TERMINATE, + CPTI_CALL_UNEXPECTED, + CPTI_ATEXIT_FN_PTR_TYPE, + CPTI_ATEXIT, + CPTI_DSO_HANDLE, + CPTI_DCAST, + + CPTI_KEYED_CLASSES, + + CPTI_NULLPTR, + CPTI_NULLPTR_TYPE, + + CPTI_MAX +}; + +extern GTY(()) tree cp_global_trees[CPTI_MAX]; + +#define java_byte_type_node cp_global_trees[CPTI_JAVA_BYTE_TYPE] +#define java_short_type_node cp_global_trees[CPTI_JAVA_SHORT_TYPE] +#define java_int_type_node cp_global_trees[CPTI_JAVA_INT_TYPE] +#define java_long_type_node cp_global_trees[CPTI_JAVA_LONG_TYPE] +#define java_float_type_node cp_global_trees[CPTI_JAVA_FLOAT_TYPE] +#define java_double_type_node cp_global_trees[CPTI_JAVA_DOUBLE_TYPE] +#define java_char_type_node cp_global_trees[CPTI_JAVA_CHAR_TYPE] +#define java_boolean_type_node cp_global_trees[CPTI_JAVA_BOOLEAN_TYPE] + +#define wchar_decl_node cp_global_trees[CPTI_WCHAR_DECL] +#define vtable_entry_type cp_global_trees[CPTI_VTABLE_ENTRY_TYPE] +/* The type used to represent an offset by which to adjust the `this' + pointer in pointer-to-member types. */ +#define delta_type_node cp_global_trees[CPTI_DELTA_TYPE] +/* The type used to represent an index into the vtable. */ +#define vtable_index_type cp_global_trees[CPTI_VTABLE_INDEX_TYPE] + +#define class_type_node cp_global_trees[CPTI_CLASS_TYPE] +#define unknown_type_node cp_global_trees[CPTI_UNKNOWN_TYPE] +#define init_list_type_node cp_global_trees[CPTI_INIT_LIST_TYPE] +#define vtbl_type_node cp_global_trees[CPTI_VTBL_TYPE] +#define vtbl_ptr_type_node cp_global_trees[CPTI_VTBL_PTR_TYPE] +#define std_node cp_global_trees[CPTI_STD] +#define abi_node cp_global_trees[CPTI_ABI] +#define const_type_info_type_node cp_global_trees[CPTI_CONST_TYPE_INFO_TYPE] +#define type_info_ptr_type cp_global_trees[CPTI_TYPE_INFO_PTR_TYPE] +#define abort_fndecl cp_global_trees[CPTI_ABORT_FNDECL] +#define global_delete_fndecl cp_global_trees[CPTI_GLOBAL_DELETE_FNDECL] +#define current_aggr cp_global_trees[CPTI_AGGR_TAG] +#define nullptr_node cp_global_trees[CPTI_NULLPTR] +#define nullptr_type_node cp_global_trees[CPTI_NULLPTR_TYPE] + +/* We cache these tree nodes so as to call get_identifier less + frequently. */ + +/* The name of a constructor that takes an in-charge parameter to + decide whether or not to construct virtual base classes. */ +#define ctor_identifier cp_global_trees[CPTI_CTOR_IDENTIFIER] +/* The name of a constructor that constructs virtual base classes. */ +#define complete_ctor_identifier cp_global_trees[CPTI_COMPLETE_CTOR_IDENTIFIER] +/* The name of a constructor that does not construct virtual base classes. */ +#define base_ctor_identifier cp_global_trees[CPTI_BASE_CTOR_IDENTIFIER] +/* The name of a destructor that takes an in-charge parameter to + decide whether or not to destroy virtual base classes and whether + or not to delete the object. */ +#define dtor_identifier cp_global_trees[CPTI_DTOR_IDENTIFIER] +/* The name of a destructor that destroys virtual base classes. */ +#define complete_dtor_identifier cp_global_trees[CPTI_COMPLETE_DTOR_IDENTIFIER] +/* The name of a destructor that does not destroy virtual base + classes. */ +#define base_dtor_identifier cp_global_trees[CPTI_BASE_DTOR_IDENTIFIER] +/* The name of a destructor that destroys virtual base classes, and + then deletes the entire object. */ +#define deleting_dtor_identifier cp_global_trees[CPTI_DELETING_DTOR_IDENTIFIER] +#define delta_identifier cp_global_trees[CPTI_DELTA_IDENTIFIER] +#define in_charge_identifier cp_global_trees[CPTI_IN_CHARGE_IDENTIFIER] +/* The name of the parameter that contains a pointer to the VTT to use + for this subobject constructor or destructor. */ +#define vtt_parm_identifier cp_global_trees[CPTI_VTT_PARM_IDENTIFIER] +#define nelts_identifier cp_global_trees[CPTI_NELTS_IDENTIFIER] +#define this_identifier cp_global_trees[CPTI_THIS_IDENTIFIER] +#define pfn_identifier cp_global_trees[CPTI_PFN_IDENTIFIER] +#define vptr_identifier cp_global_trees[CPTI_VPTR_IDENTIFIER] +/* The name of the std namespace. */ +#define std_identifier cp_global_trees[CPTI_STD_IDENTIFIER] +#define lang_name_c cp_global_trees[CPTI_LANG_NAME_C] +#define lang_name_cplusplus cp_global_trees[CPTI_LANG_NAME_CPLUSPLUS] +#define lang_name_java cp_global_trees[CPTI_LANG_NAME_JAVA] + +/* Exception specifier used for throw(). */ +#define empty_except_spec cp_global_trees[CPTI_EMPTY_EXCEPT_SPEC] +#define noexcept_true_spec cp_global_trees[CPTI_NOEXCEPT_TRUE_SPEC] +#define noexcept_false_spec cp_global_trees[CPTI_NOEXCEPT_FALSE_SPEC] + +/* If non-NULL, a POINTER_TYPE equivalent to (java::lang::Class*). */ +#define jclass_node cp_global_trees[CPTI_JCLASS] + +/* The declaration for `std::terminate'. */ +#define terminate_node cp_global_trees[CPTI_TERMINATE] + +/* The declaration for "__cxa_call_unexpected". */ +#define call_unexpected_node cp_global_trees[CPTI_CALL_UNEXPECTED] + +/* The type of the function-pointer argument to "__cxa_atexit" (or + "std::atexit", if "__cxa_atexit" is not being used). */ +#define atexit_fn_ptr_type_node cp_global_trees[CPTI_ATEXIT_FN_PTR_TYPE] + +/* A pointer to `std::atexit'. */ +#define atexit_node cp_global_trees[CPTI_ATEXIT] + +/* A pointer to `__dso_handle'. */ +#define dso_handle_node cp_global_trees[CPTI_DSO_HANDLE] + +/* The declaration of the dynamic_cast runtime. */ +#define dynamic_cast_node cp_global_trees[CPTI_DCAST] + +/* The type of a destructor. */ +#define cleanup_type cp_global_trees[CPTI_CLEANUP_TYPE] + +/* The type of the vtt parameter passed to subobject constructors and + destructors. */ +#define vtt_parm_type cp_global_trees[CPTI_VTT_PARM_TYPE] + +/* A TREE_LIST of the dynamic classes whose vtables may have to be + emitted in this translation unit. */ + +#define keyed_classes cp_global_trees[CPTI_KEYED_CLASSES] + +/* Node to indicate default access. This must be distinct from the + access nodes in tree.h. */ + +#define access_default_node null_node + +/* Global state. */ + +struct GTY(()) saved_scope { + VEC(cxx_saved_binding,gc) *old_bindings; + tree old_namespace; + VEC(tree,gc) *decl_ns_list; + tree class_name; + tree class_type; + tree access_specifier; + tree function_decl; + VEC(tree,gc) *lang_base; + tree lang_name; + tree template_parms; + struct cp_binding_level *x_previous_class_level; + tree x_saved_tree; + + int x_processing_template_decl; + int x_processing_specialization; + BOOL_BITFIELD x_processing_explicit_instantiation : 1; + BOOL_BITFIELD need_pop_function_context : 1; + + int unevaluated_operand; + int inhibit_evaluation_warnings; + + struct stmt_tree_s x_stmt_tree; + + struct cp_binding_level *class_bindings; + struct cp_binding_level *bindings; + + struct saved_scope *prev; +}; + +/* The current open namespace. */ + +#define current_namespace scope_chain->old_namespace + +/* The stack for namespaces of current declarations. */ + +#define decl_namespace_list scope_chain->decl_ns_list + +/* IDENTIFIER_NODE: name of current class */ + +#define current_class_name scope_chain->class_name + +/* _TYPE: the type of the current class */ + +#define current_class_type scope_chain->class_type + +/* When parsing a class definition, the access specifier most recently + given by the user, or, if no access specifier was given, the + default value appropriate for the kind of class (i.e., struct, + class, or union). */ + +#define current_access_specifier scope_chain->access_specifier + +/* Pointer to the top of the language name stack. */ + +#define current_lang_base scope_chain->lang_base +#define current_lang_name scope_chain->lang_name + +/* When parsing a template declaration, a TREE_LIST represents the + active template parameters. Each node in the list represents one + level of template parameters. The innermost level is first in the + list. The depth of each level is stored as an INTEGER_CST in the + TREE_PURPOSE of each node. The parameters for that level are + stored in the TREE_VALUE. */ + +#define current_template_parms scope_chain->template_parms + +#define processing_template_decl scope_chain->x_processing_template_decl +#define processing_specialization scope_chain->x_processing_specialization +#define processing_explicit_instantiation scope_chain->x_processing_explicit_instantiation + +/* The cached class binding level, from the most recently exited + class, or NULL if none. */ + +#define previous_class_level scope_chain->x_previous_class_level + +/* A list of private types mentioned, for deferred access checking. */ + +extern GTY(()) struct saved_scope *scope_chain; + +struct GTY(()) cxx_int_tree_map { + unsigned int uid; + tree to; +}; + +extern unsigned int cxx_int_tree_map_hash (const void *); +extern int cxx_int_tree_map_eq (const void *, const void *); + +/* Global state pertinent to the current function. */ + +struct GTY(()) language_function { + struct c_language_function base; + + tree x_cdtor_label; + tree x_current_class_ptr; + tree x_current_class_ref; + tree x_eh_spec_block; + tree x_in_charge_parm; + tree x_vtt_parm; + tree x_return_value; + + BOOL_BITFIELD returns_value : 1; + BOOL_BITFIELD returns_null : 1; + BOOL_BITFIELD returns_abnormally : 1; + BOOL_BITFIELD in_function_try_handler : 1; + BOOL_BITFIELD in_base_initializer : 1; + + /* True if this function can throw an exception. */ + BOOL_BITFIELD can_throw : 1; + + htab_t GTY((param_is(struct named_label_entry))) x_named_labels; + struct cp_binding_level *bindings; + VEC(tree,gc) *x_local_names; + htab_t GTY((param_is (struct cxx_int_tree_map))) extern_decl_map; +}; + +/* The current C++-specific per-function global variables. */ + +#define cp_function_chain (cfun->language) + +/* In a constructor destructor, the point at which all derived class + destroying/construction has been done. I.e., just before a + constructor returns, or before any base class destroying will be done + in a destructor. */ + +#define cdtor_label cp_function_chain->x_cdtor_label + +/* When we're processing a member function, current_class_ptr is the + PARM_DECL for the `this' pointer. The current_class_ref is an + expression for `*this'. */ + +#define current_class_ptr \ + (cfun && cp_function_chain \ + ? cp_function_chain->x_current_class_ptr : NULL_TREE) +#define current_class_ref \ + ((cfun && cp_function_chain) \ + ? cp_function_chain->x_current_class_ref : NULL_TREE) + +/* The EH_SPEC_BLOCK for the exception-specifiers for the current + function, if any. */ + +#define current_eh_spec_block cp_function_chain->x_eh_spec_block + +/* The `__in_chrg' parameter for the current function. Only used for + constructors and destructors. */ + +#define current_in_charge_parm cp_function_chain->x_in_charge_parm + +/* The `__vtt_parm' parameter for the current function. Only used for + constructors and destructors. */ + +#define current_vtt_parm cp_function_chain->x_vtt_parm + +/* Set to 0 at beginning of a function definition, set to 1 if + a return statement that specifies a return value is seen. */ + +#define current_function_returns_value cp_function_chain->returns_value + +/* Set to 0 at beginning of a function definition, set to 1 if + a return statement with no argument is seen. */ + +#define current_function_returns_null cp_function_chain->returns_null + +/* Set to 0 at beginning of a function definition, set to 1 if + a call to a noreturn function is seen. */ + +#define current_function_returns_abnormally \ + cp_function_chain->returns_abnormally + +/* Nonzero if we are processing a base initializer. Zero elsewhere. */ +#define in_base_initializer cp_function_chain->in_base_initializer + +#define in_function_try_handler cp_function_chain->in_function_try_handler + +/* Expression always returned from function, or error_mark_node + otherwise, for use by the automatic named return value optimization. */ + +#define current_function_return_value \ + (cp_function_chain->x_return_value) + +/* True if NAME is the IDENTIFIER_NODE for an overloaded "operator + new" or "operator delete". */ +#define NEW_DELETE_OPNAME_P(NAME) \ + ((NAME) == ansi_opname (NEW_EXPR) \ + || (NAME) == ansi_opname (VEC_NEW_EXPR) \ + || (NAME) == ansi_opname (DELETE_EXPR) \ + || (NAME) == ansi_opname (VEC_DELETE_EXPR)) + +#define ansi_opname(CODE) \ + (operator_name_info[(int) (CODE)].identifier) +#define ansi_assopname(CODE) \ + (assignment_operator_name_info[(int) (CODE)].identifier) + +/* True if NODE is an erroneous expression. */ + +#define error_operand_p(NODE) \ + ((NODE) == error_mark_node \ + || ((NODE) && TREE_TYPE ((NODE)) == error_mark_node)) + +/* TRUE if a tree code represents a statement. */ +extern bool statement_code_p[MAX_TREE_CODES]; + +#define STATEMENT_CODE_P(CODE) statement_code_p[(int) (CODE)] + +enum languages { lang_c, lang_cplusplus, lang_java }; + +/* Macros to make error reporting functions' lives easier. */ +#define TYPE_IDENTIFIER(NODE) (DECL_NAME (TYPE_NAME (NODE))) +#define TYPE_LINKAGE_IDENTIFIER(NODE) \ + (TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (NODE))) +#define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (TYPE_IDENTIFIER (NODE))) +#define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (TYPE_IDENTIFIER (NODE))) + +/* Nonzero if NODE has no name for linkage purposes. */ +#define TYPE_ANONYMOUS_P(NODE) \ + (TAGGED_TYPE_P (NODE) && ANON_AGGRNAME_P (TYPE_LINKAGE_IDENTIFIER (NODE))) + +/* The _DECL for this _TYPE. */ +#define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE))) + +/* Nonzero if T is a class (or struct or union) type. Also nonzero + for template type parameters, typename types, and instantiated + template template parameters. Keep these checks in ascending code + order. */ +#define MAYBE_CLASS_TYPE_P(T) \ + (TREE_CODE (T) == TEMPLATE_TYPE_PARM \ + || TREE_CODE (T) == TYPENAME_TYPE \ + || TREE_CODE (T) == TYPEOF_TYPE \ + || TREE_CODE (T) == BOUND_TEMPLATE_TEMPLATE_PARM \ + || TREE_CODE (T) == DECLTYPE_TYPE \ + || CLASS_TYPE_P (T)) + +/* Set CLASS_TYPE_P for T to VAL. T must be a class, struct, or + union type. */ +#define SET_CLASS_TYPE_P(T, VAL) \ + (TYPE_LANG_FLAG_5 (T) = (VAL)) + +/* Nonzero if T is a class type. Zero for template type parameters, + typename types, and so forth. */ +#define CLASS_TYPE_P(T) \ + (RECORD_OR_UNION_CODE_P (TREE_CODE (T)) && TYPE_LANG_FLAG_5 (T)) + +/* Nonzero if T is a class type but not an union. */ +#define NON_UNION_CLASS_TYPE_P(T) \ + (CLASS_TYPE_P (T) && TREE_CODE (T) != UNION_TYPE) + +/* Keep these checks in ascending code order. */ +#define RECORD_OR_UNION_CODE_P(T) \ + ((T) == RECORD_TYPE || (T) == UNION_TYPE) +#define TAGGED_TYPE_P(T) \ + (CLASS_TYPE_P (T) || TREE_CODE (T) == ENUMERAL_TYPE) +#define IS_OVERLOAD_TYPE(T) TAGGED_TYPE_P (T) + +/* True if this a "Java" type, defined in 'extern "Java"'. */ +#define TYPE_FOR_JAVA(NODE) TYPE_LANG_FLAG_3 (NODE) + +/* True if this type is dependent. This predicate is only valid if + TYPE_DEPENDENT_P_VALID is true. */ +#define TYPE_DEPENDENT_P(NODE) TYPE_LANG_FLAG_0 (NODE) + +/* True if dependent_type_p has been called for this type, with the + result that TYPE_DEPENDENT_P is valid. */ +#define TYPE_DEPENDENT_P_VALID(NODE) TYPE_LANG_FLAG_6(NODE) + +/* Nonzero if this type is const-qualified. */ +#define CP_TYPE_CONST_P(NODE) \ + ((cp_type_quals (NODE) & TYPE_QUAL_CONST) != 0) + +/* Nonzero if this type is volatile-qualified. */ +#define CP_TYPE_VOLATILE_P(NODE) \ + ((cp_type_quals (NODE) & TYPE_QUAL_VOLATILE) != 0) + +/* Nonzero if this type is restrict-qualified. */ +#define CP_TYPE_RESTRICT_P(NODE) \ + ((cp_type_quals (NODE) & TYPE_QUAL_RESTRICT) != 0) + +/* Nonzero if this type is const-qualified, but not + volatile-qualified. Other qualifiers are ignored. This macro is + used to test whether or not it is OK to bind an rvalue to a + reference. */ +#define CP_TYPE_CONST_NON_VOLATILE_P(NODE) \ + ((cp_type_quals (NODE) & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)) \ + == TYPE_QUAL_CONST) + +#define FUNCTION_ARG_CHAIN(NODE) \ + TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (NODE))) + +/* Given a FUNCTION_DECL, returns the first TREE_LIST out of TYPE_ARG_TYPES + which refers to a user-written parameter. */ +#define FUNCTION_FIRST_USER_PARMTYPE(NODE) \ + skip_artificial_parms_for ((NODE), TYPE_ARG_TYPES (TREE_TYPE (NODE))) + +/* Similarly, but for DECL_ARGUMENTS. */ +#define FUNCTION_FIRST_USER_PARM(NODE) \ + skip_artificial_parms_for ((NODE), DECL_ARGUMENTS (NODE)) + +/* Nonzero iff TYPE is derived from PARENT. Ignores accessibility and + ambiguity issues. */ +#define DERIVED_FROM_P(PARENT, TYPE) \ + (lookup_base ((TYPE), (PARENT), ba_any, NULL) != NULL_TREE) +/* Nonzero iff TYPE is uniquely derived from PARENT. Ignores + accessibility. */ +#define UNIQUELY_DERIVED_FROM_P(PARENT, TYPE) \ + (lookup_base ((TYPE), (PARENT), ba_unique | ba_quiet, NULL) != NULL_TREE) +/* Nonzero iff TYPE is publicly & uniquely derived from PARENT. */ +#define PUBLICLY_UNIQUELY_DERIVED_P(PARENT, TYPE) \ + (lookup_base ((TYPE), (PARENT), ba_ignore_scope | ba_check | ba_quiet, \ + NULL) != NULL_TREE) + +/* Gives the visibility specification for a class type. */ +#define CLASSTYPE_VISIBILITY(TYPE) \ + DECL_VISIBILITY (TYPE_MAIN_DECL (TYPE)) +#define CLASSTYPE_VISIBILITY_SPECIFIED(TYPE) \ + DECL_VISIBILITY_SPECIFIED (TYPE_MAIN_DECL (TYPE)) + +typedef struct GTY (()) tree_pair_s { + tree purpose; + tree value; +} tree_pair_s; +typedef tree_pair_s *tree_pair_p; +DEF_VEC_O (tree_pair_s); +DEF_VEC_ALLOC_O (tree_pair_s,gc); + +/* This is a few header flags for 'struct lang_type'. Actually, + all but the first are used only for lang_type_class; they + are put in this structure to save space. */ +struct GTY(()) lang_type_header { + BOOL_BITFIELD is_lang_type_class : 1; + + BOOL_BITFIELD has_type_conversion : 1; + BOOL_BITFIELD has_copy_ctor : 1; + BOOL_BITFIELD has_default_ctor : 1; + BOOL_BITFIELD const_needs_init : 1; + BOOL_BITFIELD ref_needs_init : 1; + BOOL_BITFIELD has_const_copy_assign : 1; + + BOOL_BITFIELD spare : 1; +}; + +/* This structure provides additional information above and beyond + what is provide in the ordinary tree_type. In the past, we used it + for the types of class types, template parameters types, typename + types, and so forth. However, there can be many (tens to hundreds + of thousands) of template parameter types in a compilation, and + there's no need for this additional information in that case. + Therefore, we now use this data structure only for class types. + + In the past, it was thought that there would be relatively few + class types. However, in the presence of heavy use of templates, + many (i.e., thousands) of classes can easily be generated. + Therefore, we should endeavor to keep the size of this structure to + a minimum. */ +struct GTY(()) lang_type_class { + struct lang_type_header h; + + unsigned char align; + + unsigned has_mutable : 1; + unsigned com_interface : 1; + unsigned non_pod_class : 1; + unsigned nearly_empty_p : 1; + unsigned user_align : 1; + unsigned has_copy_assign : 1; + unsigned has_new : 1; + unsigned has_array_new : 1; + + unsigned gets_delete : 2; + unsigned interface_only : 1; + unsigned interface_unknown : 1; + unsigned contains_empty_class_p : 1; + unsigned anon_aggr : 1; + unsigned non_zero_init : 1; + unsigned empty_p : 1; + + unsigned vec_new_uses_cookie : 1; + unsigned declared_class : 1; + unsigned diamond_shaped : 1; + unsigned repeated_base : 1; + unsigned being_defined : 1; + unsigned java_interface : 1; + unsigned debug_requested : 1; + unsigned fields_readonly : 1; + + unsigned use_template : 2; + unsigned ptrmemfunc_flag : 1; + unsigned was_anonymous : 1; + unsigned lazy_default_ctor : 1; + unsigned lazy_copy_ctor : 1; + unsigned lazy_copy_assign : 1; + unsigned lazy_destructor : 1; + + unsigned has_const_copy_ctor : 1; + unsigned has_complex_copy_ctor : 1; + unsigned has_complex_copy_assign : 1; + unsigned non_aggregate : 1; + unsigned has_complex_dflt : 1; + unsigned has_list_ctor : 1; + unsigned non_std_layout : 1; + unsigned is_literal : 1; + + unsigned lazy_move_ctor : 1; + unsigned lazy_move_assign : 1; + unsigned has_complex_move_ctor : 1; + unsigned has_complex_move_assign : 1; + unsigned has_constexpr_ctor : 1; + + /* When adding a flag here, consider whether or not it ought to + apply to a template instance if it applies to the template. If + so, make sure to copy it in instantiate_class_template! */ + + /* There are some bits left to fill out a 32-bit word. Keep track + of this by updating the size of this bitfield whenever you add or + remove a flag. */ + unsigned dummy : 3; + + tree primary_base; + VEC(tree_pair_s,gc) *vcall_indices; + tree vtables; + tree typeinfo_var; + VEC(tree,gc) *vbases; + binding_table nested_udts; + tree as_base; + VEC(tree,gc) *pure_virtuals; + tree friend_classes; + VEC(tree,gc) * GTY((reorder ("resort_type_method_vec"))) methods; + tree key_method; + tree decl_list; + tree template_info; + tree befriending_classes; + /* In a RECORD_TYPE, information specific to Objective-C++, such + as a list of adopted protocols or a pointer to a corresponding + @interface. See objc/objc-act.h for details. */ + tree objc_info; + /* sorted_fields is sorted based on a pointer, so we need to be able + to resort it if pointers get rearranged. */ + struct sorted_fields_type * GTY ((reorder ("resort_sorted_fields"))) + sorted_fields; + /* FIXME reuse another field? */ + tree lambda_expr; +}; + +struct GTY(()) lang_type_ptrmem { + struct lang_type_header h; + tree record; +}; + +struct GTY((variable_size)) lang_type { + union lang_type_u + { + struct lang_type_header GTY((skip (""))) h; + struct lang_type_class GTY((tag ("1"))) c; + struct lang_type_ptrmem GTY((tag ("0"))) ptrmem; + } GTY((desc ("%h.h.is_lang_type_class"))) u; +}; + +#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) + +#define LANG_TYPE_CLASS_CHECK(NODE) __extension__ \ +({ struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE); \ + if (! lt->u.h.is_lang_type_class) \ + lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ + <->u.c; }) + +#define LANG_TYPE_PTRMEM_CHECK(NODE) __extension__ \ +({ struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE); \ + if (lt->u.h.is_lang_type_class) \ + lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ + <->u.ptrmem; }) + +#else + +#define LANG_TYPE_CLASS_CHECK(NODE) (&TYPE_LANG_SPECIFIC (NODE)->u.c) +#define LANG_TYPE_PTRMEM_CHECK(NODE) (&TYPE_LANG_SPECIFIC (NODE)->u.ptrmem) + +#endif /* ENABLE_TREE_CHECKING */ + +/* Nonzero for _CLASSTYPE means that operator delete is defined. */ +#define TYPE_GETS_DELETE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->gets_delete) +#define TYPE_GETS_REG_DELETE(NODE) (TYPE_GETS_DELETE (NODE) & 1) + +/* Nonzero if `new NODE[x]' should cause the allocation of extra + storage to indicate how many array elements are in use. */ +#define TYPE_VEC_NEW_USES_COOKIE(NODE) \ + (CLASS_TYPE_P (NODE) \ + && LANG_TYPE_CLASS_CHECK (NODE)->vec_new_uses_cookie) + +/* Nonzero means that this _CLASSTYPE node defines ways of converting + itself to other types. */ +#define TYPE_HAS_CONVERSION(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->h.has_type_conversion) + +/* Nonzero means that NODE (a class type) has a default constructor -- + but that it has not yet been declared. */ +#define CLASSTYPE_LAZY_DEFAULT_CTOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->lazy_default_ctor) + +/* Nonzero means that NODE (a class type) has a copy constructor -- + but that it has not yet been declared. */ +#define CLASSTYPE_LAZY_COPY_CTOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_ctor) + +/* Nonzero means that NODE (a class type) has a move constructor -- + but that it has not yet been declared. */ +#define CLASSTYPE_LAZY_MOVE_CTOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->lazy_move_ctor) + +/* Nonzero means that NODE (a class type) has an assignment operator + -- but that it has not yet been declared. */ +#define CLASSTYPE_LAZY_COPY_ASSIGN(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_assign) + +/* Nonzero means that NODE (a class type) has an assignment operator + -- but that it has not yet been declared. */ +#define CLASSTYPE_LAZY_MOVE_ASSIGN(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->lazy_move_assign) + +/* Nonzero means that NODE (a class type) has a destructor -- but that + it has not yet been declared. */ +#define CLASSTYPE_LAZY_DESTRUCTOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->lazy_destructor) + +/* Nonzero means that this _CLASSTYPE node overloads operator=(X&). */ +#define TYPE_HAS_COPY_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_copy_assign) + +/* True iff the class type NODE has an "operator =" whose parameter + has a parameter of type "const X&". */ +#define TYPE_HAS_CONST_COPY_ASSIGN(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->h.has_const_copy_assign) + +/* Nonzero means that this _CLASSTYPE node has an X(X&) constructor. */ +#define TYPE_HAS_COPY_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->h.has_copy_ctor) +#define TYPE_HAS_CONST_COPY_CTOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->has_const_copy_ctor) + +/* Nonzero if this class has an X(initializer_list) constructor. */ +#define TYPE_HAS_LIST_CTOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->has_list_ctor) + +/* Nonzero if this class has a constexpr constructor other than a copy/move + constructor. Note that a class can have constexpr constructors for + static initialization even if it isn't a literal class. */ +#define TYPE_HAS_CONSTEXPR_CTOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->has_constexpr_ctor) + +/* Nonzero if this class defines an overloaded operator new. (An + operator new [] doesn't count.) */ +#define TYPE_HAS_NEW_OPERATOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->has_new) + +/* Nonzero if this class defines an overloaded operator new[]. */ +#define TYPE_HAS_ARRAY_NEW_OPERATOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->has_array_new) + +/* Nonzero means that this type is being defined. I.e., the left brace + starting the definition of this type has been seen. */ +#define TYPE_BEING_DEFINED(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->being_defined) + +/* Nonzero means that this type is either complete or being defined, so we + can do lookup in it. */ +#define COMPLETE_OR_OPEN_TYPE_P(NODE) \ + (COMPLETE_TYPE_P (NODE) || (CLASS_TYPE_P (NODE) && TYPE_BEING_DEFINED (NODE))) + +/* Mark bits for repeated base checks. */ +#define TYPE_MARKED_P(NODE) TREE_LANG_FLAG_6 (TYPE_CHECK (NODE)) + +/* Nonzero if the class NODE has multiple paths to the same (virtual) + base object. */ +#define CLASSTYPE_DIAMOND_SHAPED_P(NODE) \ + (LANG_TYPE_CLASS_CHECK(NODE)->diamond_shaped) + +/* Nonzero if the class NODE has multiple instances of the same base + type. */ +#define CLASSTYPE_REPEATED_BASE_P(NODE) \ + (LANG_TYPE_CLASS_CHECK(NODE)->repeated_base) + +/* The member function with which the vtable will be emitted: + the first noninline non-pure-virtual member function. NULL_TREE + if there is no key function or if this is a class template */ +#define CLASSTYPE_KEY_METHOD(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->key_method) + +/* Vector member functions defined in this class. Each element is + either a FUNCTION_DECL, a TEMPLATE_DECL, or an OVERLOAD. All + functions with the same name end up in the same slot. The first + two elements are for constructors, and destructors, respectively. + All template conversion operators to innermost template dependent + types are overloaded on the next slot, if they exist. Note, the + names for these functions will not all be the same. The + non-template conversion operators & templated conversions to + non-innermost template types are next, followed by ordinary member + functions. There may be empty entries at the end of the vector. + The conversion operators are unsorted. The ordinary member + functions are sorted, once the class is complete. */ +#define CLASSTYPE_METHOD_VEC(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->methods) + +/* For class templates, this is a TREE_LIST of all member data, + functions, types, and friends in the order of declaration. + The TREE_PURPOSE of each TREE_LIST is NULL_TREE for a friend, + and the RECORD_TYPE for the class template otherwise. */ +#define CLASSTYPE_DECL_LIST(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->decl_list) + +/* The slot in the CLASSTYPE_METHOD_VEC where constructors go. */ +#define CLASSTYPE_CONSTRUCTOR_SLOT 0 + +/* The slot in the CLASSTYPE_METHOD_VEC where destructors go. */ +#define CLASSTYPE_DESTRUCTOR_SLOT 1 + +/* The first slot in the CLASSTYPE_METHOD_VEC where conversion + operators can appear. */ +#define CLASSTYPE_FIRST_CONVERSION_SLOT 2 + +/* A FUNCTION_DECL or OVERLOAD for the constructors for NODE. These + are the constructors that take an in-charge parameter. */ +#define CLASSTYPE_CONSTRUCTORS(NODE) \ + (VEC_index (tree, CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_CONSTRUCTOR_SLOT)) + +/* A FUNCTION_DECL for the destructor for NODE. These are the + destructors that take an in-charge parameter. If + CLASSTYPE_LAZY_DESTRUCTOR is true, then this entry will be NULL + until the destructor is created with lazily_declare_fn. */ +#define CLASSTYPE_DESTRUCTORS(NODE) \ + (CLASSTYPE_METHOD_VEC (NODE) \ + ? VEC_index (tree, CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_DESTRUCTOR_SLOT) \ + : NULL_TREE) + +/* A dictionary of the nested user-defined-types (class-types, or enums) + found within this class. This table includes nested member class + templates. */ +#define CLASSTYPE_NESTED_UTDS(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->nested_udts) + +/* Nonzero if NODE has a primary base class, i.e., a base class with + which it shares the virtual function table pointer. */ +#define CLASSTYPE_HAS_PRIMARY_BASE_P(NODE) \ + (CLASSTYPE_PRIMARY_BINFO (NODE) != NULL_TREE) + +/* If non-NULL, this is the binfo for the primary base class, i.e., + the base class which contains the virtual function table pointer + for this class. */ +#define CLASSTYPE_PRIMARY_BINFO(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->primary_base) + +/* A vector of BINFOs for the direct and indirect virtual base classes + that this type uses in a post-order depth-first left-to-right + order. (In other words, these bases appear in the order that they + should be initialized.) */ +#define CLASSTYPE_VBASECLASSES(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->vbases) + +/* The type corresponding to NODE when NODE is used as a base class, + i.e., NODE without virtual base classes. */ + +#define CLASSTYPE_AS_BASE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->as_base) + +/* True iff NODE is the CLASSTYPE_AS_BASE version of some type. */ + +#define IS_FAKE_BASE_TYPE(NODE) \ + (TREE_CODE (NODE) == RECORD_TYPE \ + && TYPE_CONTEXT (NODE) && CLASS_TYPE_P (TYPE_CONTEXT (NODE)) \ + && CLASSTYPE_AS_BASE (TYPE_CONTEXT (NODE)) == (NODE)) + +/* These are the size and alignment of the type without its virtual + base classes, for when we use this type as a base itself. */ +#define CLASSTYPE_SIZE(NODE) TYPE_SIZE (CLASSTYPE_AS_BASE (NODE)) +#define CLASSTYPE_SIZE_UNIT(NODE) TYPE_SIZE_UNIT (CLASSTYPE_AS_BASE (NODE)) +#define CLASSTYPE_ALIGN(NODE) TYPE_ALIGN (CLASSTYPE_AS_BASE (NODE)) +#define CLASSTYPE_USER_ALIGN(NODE) TYPE_USER_ALIGN (CLASSTYPE_AS_BASE (NODE)) + +/* The alignment of NODE, without its virtual bases, in bytes. */ +#define CLASSTYPE_ALIGN_UNIT(NODE) \ + (CLASSTYPE_ALIGN (NODE) / BITS_PER_UNIT) + +/* True if this a Java interface type, declared with + '__attribute__ ((java_interface))'. */ +#define TYPE_JAVA_INTERFACE(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->java_interface) + +/* A VEC(tree) of virtual functions which cannot be inherited by + derived classes. When deriving from this type, the derived + class must provide its own definition for each of these functions. */ +#define CLASSTYPE_PURE_VIRTUALS(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->pure_virtuals) + +/* Nonzero means that this type has an X() constructor. */ +#define TYPE_HAS_DEFAULT_CONSTRUCTOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->h.has_default_ctor) + +/* Nonzero means that this type contains a mutable member. */ +#define CLASSTYPE_HAS_MUTABLE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_mutable) +#define TYPE_HAS_MUTABLE_P(NODE) (cp_has_mutable_p (NODE)) + +/* Nonzero means that this class type is not POD for the purpose of layout + (as defined in the ABI). This is different from the language's POD. */ +#define CLASSTYPE_NON_LAYOUT_POD_P(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->non_pod_class) + +/* Nonzero means that this class type is a non-standard-layout class. */ +#define CLASSTYPE_NON_STD_LAYOUT(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->non_std_layout) + +/* Nonzero means that this class contains pod types whose default + initialization is not a zero initialization (namely, pointers to + data members). */ +#define CLASSTYPE_NON_ZERO_INIT_P(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->non_zero_init) + +/* Nonzero if this class is "empty" in the sense of the C++ ABI. */ +#define CLASSTYPE_EMPTY_P(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->empty_p) + +/* Nonzero if this class is "nearly empty", i.e., contains only a + virtual function table pointer. */ +#define CLASSTYPE_NEARLY_EMPTY_P(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->nearly_empty_p) + +/* Nonzero if this class contains an empty subobject. */ +#define CLASSTYPE_CONTAINS_EMPTY_CLASS_P(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->contains_empty_class_p) + +/* A list of class types of which this type is a friend. The + TREE_VALUE is normally a TYPE, but will be a TEMPLATE_DECL in the + case of a template friend. */ +#define CLASSTYPE_FRIEND_CLASSES(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->friend_classes) + +/* A list of the classes which grant friendship to this class. */ +#define CLASSTYPE_BEFRIENDING_CLASSES(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->befriending_classes) + +/* The associated LAMBDA_EXPR that made this class. */ +#define CLASSTYPE_LAMBDA_EXPR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->lambda_expr) +/* The extra mangling scope for this closure type. */ +#define LAMBDA_TYPE_EXTRA_SCOPE(NODE) \ + (LAMBDA_EXPR_EXTRA_SCOPE (CLASSTYPE_LAMBDA_EXPR (NODE))) + +/* Say whether this node was declared as a "class" or a "struct". */ +#define CLASSTYPE_DECLARED_CLASS(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->declared_class) + +/* Nonzero if this class has const members + which have no specified initialization. */ +#define CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE) \ + (TYPE_LANG_SPECIFIC (NODE) \ + ? LANG_TYPE_CLASS_CHECK (NODE)->h.const_needs_init : 0) +#define SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE, VALUE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->h.const_needs_init = (VALUE)) + +/* Nonzero if this class has ref members + which have no specified initialization. */ +#define CLASSTYPE_REF_FIELDS_NEED_INIT(NODE) \ + (TYPE_LANG_SPECIFIC (NODE) \ + ? LANG_TYPE_CLASS_CHECK (NODE)->h.ref_needs_init : 0) +#define SET_CLASSTYPE_REF_FIELDS_NEED_INIT(NODE, VALUE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->h.ref_needs_init = (VALUE)) + +/* Nonzero if this class is included from a header file which employs + `#pragma interface', and it is not included in its implementation file. */ +#define CLASSTYPE_INTERFACE_ONLY(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->interface_only) + +/* True if we have already determined whether or not vtables, VTTs, + typeinfo, and other similar per-class data should be emitted in + this translation unit. This flag does not indicate whether or not + these items should be emitted; it only indicates that we know one + way or the other. */ +#define CLASSTYPE_INTERFACE_KNOWN(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown == 0) +/* The opposite of CLASSTYPE_INTERFACE_KNOWN. */ +#define CLASSTYPE_INTERFACE_UNKNOWN(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown) + +#define SET_CLASSTYPE_INTERFACE_UNKNOWN_X(NODE,X) \ + (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = !!(X)) +#define SET_CLASSTYPE_INTERFACE_UNKNOWN(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 1) +#define SET_CLASSTYPE_INTERFACE_KNOWN(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 0) + +/* Nonzero if a _DECL node requires us to output debug info for this class. */ +#define CLASSTYPE_DEBUG_REQUESTED(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->debug_requested) + +/* Additional macros for inheritance information. */ + +/* Nonzero means that this class is on a path leading to a new vtable. */ +#define BINFO_VTABLE_PATH_MARKED(NODE) BINFO_FLAG_1 (NODE) + +/* Nonzero means B (a BINFO) has its own vtable. Any copies will not + have this flag set. */ +#define BINFO_NEW_VTABLE_MARKED(B) (BINFO_FLAG_2 (B)) + +/* Compare a BINFO_TYPE with another type for equality. For a binfo, + this is functionally equivalent to using same_type_p, but + measurably faster. At least one of the arguments must be a + BINFO_TYPE. The other can be a BINFO_TYPE or a regular type. If + BINFO_TYPE(T) ever stops being the main variant of the class the + binfo is for, this macro must change. */ +#define SAME_BINFO_TYPE_P(A, B) ((A) == (B)) + +/* Any subobject that needs a new vtable must have a vptr and must not + be a non-virtual primary base (since it would then use the vtable from a + derived class and never become non-primary.) */ +#define SET_BINFO_NEW_VTABLE_MARKED(B) \ + (BINFO_NEW_VTABLE_MARKED (B) = 1, \ + gcc_assert (!BINFO_PRIMARY_P (B) || BINFO_VIRTUAL_P (B)), \ + gcc_assert (TYPE_VFIELD (BINFO_TYPE (B)))) + +/* Nonzero if this binfo is for a dependent base - one that should not + be searched. */ +#define BINFO_DEPENDENT_BASE_P(NODE) BINFO_FLAG_3 (NODE) + +/* Nonzero if this binfo has lost its primary base binfo (because that + is a nearly-empty virtual base that has been taken by some other + base in the complete hierarchy. */ +#define BINFO_LOST_PRIMARY_P(NODE) BINFO_FLAG_4 (NODE) + +/* Nonzero if this BINFO is a primary base class. */ +#define BINFO_PRIMARY_P(NODE) BINFO_FLAG_5(NODE) + +/* Used by various search routines. */ +#define IDENTIFIER_MARKED(NODE) TREE_LANG_FLAG_0 (NODE) + +/* A VEC(tree_pair_s) of the vcall indices associated with the class + NODE. The PURPOSE of each element is a FUNCTION_DECL for a virtual + function. The VALUE is the index into the virtual table where the + vcall offset for that function is stored, when NODE is a virtual + base. */ +#define CLASSTYPE_VCALL_INDICES(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->vcall_indices) + +/* The various vtables for the class NODE. The primary vtable will be + first, followed by the construction vtables and VTT, if any. */ +#define CLASSTYPE_VTABLES(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->vtables) + +/* The std::type_info variable representing this class, or NULL if no + such variable has been created. This field is only set for the + TYPE_MAIN_VARIANT of the class. */ +#define CLASSTYPE_TYPEINFO_VAR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var) + +/* Accessor macros for the BINFO_VIRTUALS list. */ + +/* The number of bytes by which to adjust the `this' pointer when + calling this virtual function. Subtract this value from the this + pointer. Always non-NULL, might be constant zero though. */ +#define BV_DELTA(NODE) (TREE_PURPOSE (NODE)) + +/* If non-NULL, the vtable index at which to find the vcall offset + when calling this virtual function. Add the value at that vtable + index to the this pointer. */ +#define BV_VCALL_INDEX(NODE) (TREE_TYPE (NODE)) + +/* The function to call. */ +#define BV_FN(NODE) (TREE_VALUE (NODE)) + +/* Whether or not this entry is for a lost primary virtual base. */ +#define BV_LOST_PRIMARY(NODE) (TREE_LANG_FLAG_0 (NODE)) + +/* For FUNCTION_TYPE or METHOD_TYPE, a list of the exceptions that + this type can raise. Each TREE_VALUE is a _TYPE. The TREE_VALUE + will be NULL_TREE to indicate a throw specification of `()', or + no exceptions allowed. For a noexcept specification, TREE_VALUE + is NULL_TREE and TREE_PURPOSE is the constant-expression. */ +#define TYPE_RAISES_EXCEPTIONS(NODE) TYPE_LANG_SLOT_1 (NODE) + +/* For FUNCTION_TYPE or METHOD_TYPE, return 1 iff it is declared `throw()' + or noexcept(true). */ +#define TYPE_NOTHROW_P(NODE) nothrow_spec_p (TYPE_RAISES_EXCEPTIONS (NODE)) + +/* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the + case for things declared noexcept(true) and, with -fnothrow-opt, for + throw() functions. */ +#define TYPE_NOEXCEPT_P(NODE) type_noexcept_p (NODE) + +/* The binding level associated with the namespace. */ +#define NAMESPACE_LEVEL(NODE) \ + (LANG_DECL_NS_CHECK (NODE)->level) + +/* Flags shared by all forms of DECL_LANG_SPECIFIC. + + Some of the flags live here only to make lang_decl_min/fn smaller. Do + not make this struct larger than 32 bits; instead, make sel smaller. */ + +struct GTY(()) lang_decl_base { + unsigned selector : 16; /* Larger than necessary for faster access. */ + ENUM_BITFIELD(languages) language : 4; + unsigned use_template : 2; + unsigned not_really_extern : 1; /* var or fn */ + unsigned initialized_in_class : 1; /* var or fn */ + unsigned repo_available_p : 1; /* var or fn */ + unsigned threadprivate_or_deleted_p : 1; /* var or fn */ + unsigned anticipated_p : 1; /* fn or type */ + unsigned friend_attr : 1; /* fn or type */ + unsigned template_conv_p : 1; /* var or template */ + unsigned odr_used : 1; /* var or fn */ + unsigned u2sel : 1; + /* 1 spare bit */ +}; + +/* True for DECL codes which have template info and access. */ +#define LANG_DECL_HAS_MIN(NODE) \ + (TREE_CODE (NODE) == FUNCTION_DECL \ + || TREE_CODE (NODE) == FIELD_DECL \ + || TREE_CODE (NODE) == VAR_DECL \ + || TREE_CODE (NODE) == CONST_DECL \ + || TREE_CODE (NODE) == TYPE_DECL \ + || TREE_CODE (NODE) == TEMPLATE_DECL \ + || TREE_CODE (NODE) == USING_DECL) + +/* DECL_LANG_SPECIFIC for the above codes. */ + +struct GTY(()) lang_decl_min { + struct lang_decl_base base; + + /* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is + THUNK_ALIAS. + In a FUNCTION_DECL for which DECL_THUNK_P does not hold, + VAR_DECL, TYPE_DECL, or TEMPLATE_DECL, this is + DECL_TEMPLATE_INFO. */ + tree template_info; + + union lang_decl_u2 { + /* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is + THUNK_VIRTUAL_OFFSET. + Otherwise this is DECL_ACCESS. */ + tree GTY ((tag ("0"))) access; + + /* For VAR_DECL in function, this is DECL_DISCRIMINATOR. */ + int GTY ((tag ("1"))) discriminator; + } GTY ((desc ("%0.u.base.u2sel"))) u2; +}; + +/* Additional DECL_LANG_SPECIFIC information for functions. */ + +struct GTY(()) lang_decl_fn { + struct lang_decl_min min; + + /* In an overloaded operator, this is the value of + DECL_OVERLOADED_OPERATOR_P. */ + ENUM_BITFIELD (tree_code) operator_code : 16; + + unsigned global_ctor_p : 1; + unsigned global_dtor_p : 1; + unsigned constructor_attr : 1; + unsigned destructor_attr : 1; + unsigned assignment_operator_p : 1; + unsigned static_function : 1; + unsigned pure_virtual : 1; + unsigned defaulted_p : 1; + + unsigned has_in_charge_parm_p : 1; + unsigned has_vtt_parm_p : 1; + unsigned pending_inline_p : 1; + unsigned nonconverting : 1; + unsigned thunk_p : 1; + unsigned this_thunk_p : 1; + unsigned hidden_friend_p : 1; + /* 1 spare bit. */ + + /* For a non-thunk function decl, this is a tree list of + friendly classes. For a thunk function decl, it is the + thunked to function decl. */ + tree befriending_classes; + + /* For a non-virtual FUNCTION_DECL, this is + DECL_FRIEND_CONTEXT. For a virtual FUNCTION_DECL for which + DECL_THIS_THUNK_P does not hold, this is DECL_THUNKS. Both + this pointer and result pointer adjusting thunks are + chained here. This pointer thunks to return pointer thunks + will be chained on the return pointer thunk. */ + tree context; + + union lang_decl_u5 + { + /* In a non-thunk FUNCTION_DECL or TEMPLATE_DECL, this is + DECL_CLONED_FUNCTION. */ + tree GTY ((tag ("0"))) cloned_function; + + /* In a FUNCTION_DECL for which THUNK_P holds this is the + THUNK_FIXED_OFFSET. */ + HOST_WIDE_INT GTY ((tag ("1"))) fixed_offset; + } GTY ((desc ("%1.thunk_p"))) u5; + + union lang_decl_u3 + { + struct cp_token_cache * GTY ((tag ("1"))) pending_inline_info; + struct language_function * GTY ((tag ("0"))) + saved_language_function; + } GTY ((desc ("%1.pending_inline_p"))) u; + +}; + +/* DECL_LANG_SPECIFIC for namespaces. */ + +struct GTY(()) lang_decl_ns { + struct lang_decl_base base; + struct cp_binding_level *level; +}; + +/* DECL_LANG_SPECIFIC for parameters. */ + +struct GTY(()) lang_decl_parm { + struct lang_decl_base base; + int level; + int index; +}; + +/* DECL_LANG_SPECIFIC for all types. It would be nice to just make this a + union rather than a struct containing a union as its only field, but + tree.h declares it as a struct. */ + +struct GTY((variable_size)) lang_decl { + union GTY((desc ("%h.base.selector"))) lang_decl_u { + struct lang_decl_base GTY ((default)) base; + struct lang_decl_min GTY((tag ("0"))) min; + struct lang_decl_fn GTY ((tag ("1"))) fn; + struct lang_decl_ns GTY((tag ("2"))) ns; + struct lang_decl_parm GTY((tag ("3"))) parm; + } u; +}; + +/* Looks through a template (if present) to find what it declares. */ +#define STRIP_TEMPLATE(NODE) \ + (TREE_CODE (NODE) == TEMPLATE_DECL ? DECL_TEMPLATE_RESULT (NODE) : NODE) + +#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) + +#define LANG_DECL_MIN_CHECK(NODE) __extension__ \ +({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \ + if (!LANG_DECL_HAS_MIN (NODE)) \ + lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ + <->u.min; }) + +/* We want to be able to check DECL_CONSTRUCTOR_P and such on a function + template, not just on a FUNCTION_DECL. So when looking for things in + lang_decl_fn, look down through a TEMPLATE_DECL into its result. */ +#define LANG_DECL_FN_CHECK(NODE) __extension__ \ +({ struct lang_decl *lt = DECL_LANG_SPECIFIC (STRIP_TEMPLATE (NODE)); \ + if (!DECL_DECLARES_FUNCTION_P (NODE) || lt->u.base.selector != 1) \ + lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ + <->u.fn; }) + +#define LANG_DECL_NS_CHECK(NODE) __extension__ \ +({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \ + if (TREE_CODE (NODE) != NAMESPACE_DECL || lt->u.base.selector != 2) \ + lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ + <->u.ns; }) + +#define LANG_DECL_PARM_CHECK(NODE) __extension__ \ +({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \ + if (TREE_CODE (NODE) != PARM_DECL) \ + lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ + <->u.parm; }) + +#define LANG_DECL_U2_CHECK(NODE, TF) __extension__ \ +({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \ + if (!LANG_DECL_HAS_MIN (NODE) || lt->u.base.u2sel != TF) \ + lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ + <->u.min.u2; }) + +#else + +#define LANG_DECL_MIN_CHECK(NODE) \ + (&DECL_LANG_SPECIFIC (NODE)->u.min) + +#define LANG_DECL_FN_CHECK(NODE) \ + (&DECL_LANG_SPECIFIC (STRIP_TEMPLATE (NODE))->u.fn) + +#define LANG_DECL_NS_CHECK(NODE) \ + (&DECL_LANG_SPECIFIC (NODE)->u.ns) + +#define LANG_DECL_PARM_CHECK(NODE) \ + (&DECL_LANG_SPECIFIC (NODE)->u.parm) + +#define LANG_DECL_U2_CHECK(NODE, TF) \ + (&DECL_LANG_SPECIFIC (NODE)->u.min.u2) + +#endif /* ENABLE_TREE_CHECKING */ + +/* For a FUNCTION_DECL or a VAR_DECL, the language linkage for the + declaration. Some entities (like a member function in a local + class, or a local variable) do not have linkage at all, and this + macro should not be used in those cases. + + Implementation note: A FUNCTION_DECL without DECL_LANG_SPECIFIC was + created by language-independent code, and has C linkage. Most + VAR_DECLs have C++ linkage, and do not have DECL_LANG_SPECIFIC, but + we do create DECL_LANG_SPECIFIC for variables with non-C++ linkage. */ +#define DECL_LANGUAGE(NODE) \ + (DECL_LANG_SPECIFIC (NODE) \ + ? DECL_LANG_SPECIFIC (NODE)->u.base.language \ + : (TREE_CODE (NODE) == FUNCTION_DECL \ + ? lang_c : lang_cplusplus)) + +/* Set the language linkage for NODE to LANGUAGE. */ +#define SET_DECL_LANGUAGE(NODE, LANGUAGE) \ + (DECL_LANG_SPECIFIC (NODE)->u.base.language = (LANGUAGE)) + +/* For FUNCTION_DECLs: nonzero means that this function is a constructor. */ +#define DECL_CONSTRUCTOR_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->constructor_attr) + +/* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a complete + object. */ +#define DECL_COMPLETE_CONSTRUCTOR_P(NODE) \ + (DECL_CONSTRUCTOR_P (NODE) \ + && DECL_NAME (NODE) == complete_ctor_identifier) + +/* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a base + object. */ +#define DECL_BASE_CONSTRUCTOR_P(NODE) \ + (DECL_CONSTRUCTOR_P (NODE) \ + && DECL_NAME (NODE) == base_ctor_identifier) + +/* Nonzero if NODE (a FUNCTION_DECL) is a constructor, but not either the + specialized in-charge constructor or the specialized not-in-charge + constructor. */ +#define DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P(NODE) \ + (DECL_DECLARES_FUNCTION_P (NODE) && DECL_CONSTRUCTOR_P (NODE) \ + && !DECL_CLONED_FUNCTION_P (NODE)) + +/* Nonzero if NODE (a FUNCTION_DECL) is a copy constructor. */ +#define DECL_COPY_CONSTRUCTOR_P(NODE) \ + (DECL_CONSTRUCTOR_P (NODE) && copy_fn_p (NODE) > 0) + +/* Nonzero if NODE (a FUNCTION_DECL) is a move constructor. */ +#define DECL_MOVE_CONSTRUCTOR_P(NODE) \ + (DECL_CONSTRUCTOR_P (NODE) && move_fn_p (NODE)) + +/* Nonzero if NODE is a destructor. */ +#define DECL_DESTRUCTOR_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->destructor_attr) + +/* Nonzero if NODE (a FUNCTION_DECL) is a destructor, but not the + specialized in-charge constructor, in-charge deleting constructor, + or the base destructor. */ +#define DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P(NODE) \ + (DECL_DECLARES_FUNCTION_P (NODE) && DECL_DESTRUCTOR_P (NODE) \ + && !DECL_CLONED_FUNCTION_P (NODE)) + +/* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete + object. */ +#define DECL_COMPLETE_DESTRUCTOR_P(NODE) \ + (DECL_DESTRUCTOR_P (NODE) \ + && DECL_NAME (NODE) == complete_dtor_identifier) + +/* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a base + object. */ +#define DECL_BASE_DESTRUCTOR_P(NODE) \ + (DECL_DESTRUCTOR_P (NODE) \ + && DECL_NAME (NODE) == base_dtor_identifier) + +/* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete + object that deletes the object after it has been destroyed. */ +#define DECL_DELETING_DESTRUCTOR_P(NODE) \ + (DECL_DESTRUCTOR_P (NODE) \ + && DECL_NAME (NODE) == deleting_dtor_identifier) + +/* Nonzero if NODE (a FUNCTION_DECL) is a cloned constructor or + destructor. */ +#define DECL_CLONED_FUNCTION_P(NODE) (!!decl_cloned_function_p (NODE, true)) + +/* If DECL_CLONED_FUNCTION_P holds, this is the function that was + cloned. */ +#define DECL_CLONED_FUNCTION(NODE) (*decl_cloned_function_p (NODE, false)) + +/* Perform an action for each clone of FN, if FN is a function with + clones. This macro should be used like: + + FOR_EACH_CLONE (clone, fn) + { ... } + + */ +#define FOR_EACH_CLONE(CLONE, FN) \ + if (TREE_CODE (FN) == FUNCTION_DECL \ + && (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (FN) \ + || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (FN))) \ + for (CLONE = DECL_CHAIN (FN); \ + CLONE && DECL_CLONED_FUNCTION_P (CLONE); \ + CLONE = DECL_CHAIN (CLONE)) + +/* Nonzero if NODE has DECL_DISCRIMINATOR and not DECL_ACCESS. */ +#define DECL_DISCRIMINATOR_P(NODE) \ + (TREE_CODE (NODE) == VAR_DECL \ + && DECL_FUNCTION_SCOPE_P (NODE)) + +/* Discriminator for name mangling. */ +#define DECL_DISCRIMINATOR(NODE) (LANG_DECL_U2_CHECK (NODE, 1)->discriminator) + +/* True iff DECL_DISCRIMINATOR is set for a DECL_DISCRIMINATOR_P decl. */ +#define DECL_DISCRIMINATOR_SET_P(NODE) \ + (DECL_LANG_SPECIFIC (NODE) && DECL_LANG_SPECIFIC (NODE)->u.base.u2sel == 1) + +/* The index of a user-declared parameter in its function, starting at 1. + All artificial parameters will have index 0. */ +#define DECL_PARM_INDEX(NODE) \ + (LANG_DECL_PARM_CHECK (NODE)->index) + +/* The level of a user-declared parameter in its function, starting at 1. + A parameter of the function will have level 1; a parameter of the first + nested function declarator (i.e. t in void f (void (*p)(T t))) will have + level 2. */ +#define DECL_PARM_LEVEL(NODE) \ + (LANG_DECL_PARM_CHECK (NODE)->level) + +/* Nonzero if the VTT parm has been added to NODE. */ +#define DECL_HAS_VTT_PARM_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->has_vtt_parm_p) + +/* Nonzero if NODE is a FUNCTION_DECL for which a VTT parameter is + required. */ +#define DECL_NEEDS_VTT_PARM_P(NODE) \ + (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (NODE)) \ + && (DECL_BASE_CONSTRUCTOR_P (NODE) \ + || DECL_BASE_DESTRUCTOR_P (NODE))) + +/* Nonzero if NODE is a user-defined conversion operator. */ +#define DECL_CONV_FN_P(NODE) \ + (DECL_NAME (NODE) && IDENTIFIER_TYPENAME_P (DECL_NAME (NODE))) + +/* If FN is a conversion operator, the type to which it converts. + Otherwise, NULL_TREE. */ +#define DECL_CONV_FN_TYPE(FN) \ + (DECL_CONV_FN_P (FN) ? TREE_TYPE (DECL_NAME (FN)) : NULL_TREE) + +/* Nonzero if NODE, which is a TEMPLATE_DECL, is a template + conversion operator to a type dependent on the innermost template + args. */ +#define DECL_TEMPLATE_CONV_FN_P(NODE) \ + (DECL_LANG_SPECIFIC (TEMPLATE_DECL_CHECK (NODE))->u.base.template_conv_p) + +/* Nonzero if NODE, a static data member, was declared in its class as an + array of unknown bound. */ +#define VAR_HAD_UNKNOWN_BOUND(NODE) \ + (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE)) \ + ? DECL_LANG_SPECIFIC (NODE)->u.base.template_conv_p \ + : false) +#define SET_VAR_HAD_UNKNOWN_BOUND(NODE) \ + (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.template_conv_p = true) + +/* Set the overloaded operator code for NODE to CODE. */ +#define SET_OVERLOADED_OPERATOR_CODE(NODE, CODE) \ + (LANG_DECL_FN_CHECK (NODE)->operator_code = (CODE)) + +/* If NODE is an overloaded operator, then this returns the TREE_CODE + associated with the overloaded operator. + DECL_ASSIGNMENT_OPERATOR_P must also be checked to determine + whether or not NODE is an assignment operator. If NODE is not an + overloaded operator, ERROR_MARK is returned. Since the numerical + value of ERROR_MARK is zero, this macro can be used as a predicate + to test whether or not NODE is an overloaded operator. */ +#define DECL_OVERLOADED_OPERATOR_P(NODE) \ + (IDENTIFIER_OPNAME_P (DECL_NAME (NODE)) \ + ? LANG_DECL_FN_CHECK (NODE)->operator_code : ERROR_MARK) + +/* Nonzero if NODE is an assignment operator (including += and such). */ +#define DECL_ASSIGNMENT_OPERATOR_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->assignment_operator_p) + +/* For FUNCTION_DECLs: nonzero means that this function is a + constructor or a destructor with an extra in-charge parameter to + control whether or not virtual bases are constructed. */ +#define DECL_HAS_IN_CHARGE_PARM_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->has_in_charge_parm_p) + +/* Nonzero if DECL is a declaration of __builtin_constant_p. */ +#define DECL_IS_BUILTIN_CONSTANT_P(NODE) \ + (TREE_CODE (NODE) == FUNCTION_DECL \ + && DECL_BUILT_IN_CLASS (NODE) == BUILT_IN_NORMAL \ + && DECL_FUNCTION_CODE (NODE) == BUILT_IN_CONSTANT_P) + +/* Nonzero for _DECL means that this decl appears in (or will appear + in) as a member in a RECORD_TYPE or UNION_TYPE node. It is also for + detecting circularity in case members are multiply defined. In the + case of a VAR_DECL, it is also used to determine how program storage + should be allocated. */ +#define DECL_IN_AGGR_P(NODE) (DECL_LANG_FLAG_3 (NODE)) + +/* Nonzero for a VAR_DECL means that the variable's initialization (if + any) has been processed. (In general, DECL_INITIALIZED_P is + !DECL_EXTERN, but static data members may be initialized even if + not defined.) */ +#define DECL_INITIALIZED_P(NODE) \ + (TREE_LANG_FLAG_1 (VAR_DECL_CHECK (NODE))) + +/* Nonzero for a VAR_DECL iff an explicit initializer was provided. */ +#define DECL_NONTRIVIALLY_INITIALIZED_P(NODE) \ + (TREE_LANG_FLAG_3 (VAR_DECL_CHECK (NODE))) + +/* Nonzero for a VAR_DECL that was initialized with a + constant-expression. */ +#define DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P(NODE) \ + (TREE_LANG_FLAG_2 (VAR_DECL_CHECK (NODE))) + +/* Nonzero if the DECL was initialized in the class definition itself, + rather than outside the class. This is used for both static member + VAR_DECLS, and FUNCTION_DECLS that are defined in the class. */ +#define DECL_INITIALIZED_IN_CLASS_P(DECL) \ + (DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL)) \ + ->u.base.initialized_in_class) + +/* Nonzero if the DECL is used in the sense of 3.2 [basic.def.odr]. + Only available for decls with DECL_LANG_SPECIFIC. */ +#define DECL_ODR_USED(DECL) \ + (DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL)) \ + ->u.base.odr_used) + +/* Nonzero for DECL means that this decl is just a friend declaration, + and should not be added to the list of members for this class. */ +#define DECL_FRIEND_P(NODE) (DECL_LANG_SPECIFIC (NODE)->u.base.friend_attr) + +/* A TREE_LIST of the types which have befriended this FUNCTION_DECL. */ +#define DECL_BEFRIENDING_CLASSES(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->befriending_classes) + +/* Nonzero for FUNCTION_DECL means that this decl is a static + member function. */ +#define DECL_STATIC_FUNCTION_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->static_function) + +/* Nonzero for FUNCTION_DECL means that this decl is a non-static + member function. */ +#define DECL_NONSTATIC_MEMBER_FUNCTION_P(NODE) \ + (TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE) + +/* Nonzero for FUNCTION_DECL means that this decl is a member function + (static or non-static). */ +#define DECL_FUNCTION_MEMBER_P(NODE) \ + (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) || DECL_STATIC_FUNCTION_P (NODE)) + +/* Nonzero for FUNCTION_DECL means that this member function + has `this' as const X *const. */ +#define DECL_CONST_MEMFUNC_P(NODE) \ + (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \ + && CP_TYPE_CONST_P (TREE_TYPE (TREE_VALUE \ + (TYPE_ARG_TYPES (TREE_TYPE (NODE)))))) + +/* Nonzero for FUNCTION_DECL means that this member function + has `this' as volatile X *const. */ +#define DECL_VOLATILE_MEMFUNC_P(NODE) \ + (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \ + && CP_TYPE_VOLATILE_P (TREE_TYPE (TREE_VALUE \ + (TYPE_ARG_TYPES (TREE_TYPE (NODE)))))) + +/* Nonzero for a DECL means that this member is a non-static member. */ +#define DECL_NONSTATIC_MEMBER_P(NODE) \ + (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \ + || TREE_CODE (NODE) == FIELD_DECL) + +/* Nonzero for _DECL means that this member object type + is mutable. */ +#define DECL_MUTABLE_P(NODE) (DECL_LANG_FLAG_0 (NODE)) + +/* Nonzero for _DECL means that this constructor or conversion function is + non-converting. */ +#define DECL_NONCONVERTING_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->nonconverting) + +/* Nonzero for FUNCTION_DECL means that this member function is a pure + virtual function. */ +#define DECL_PURE_VIRTUAL_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->pure_virtual) + +/* True (in a FUNCTION_DECL) if NODE is a virtual function that is an + invalid overrider for a function from a base class. Once we have + complained about an invalid overrider we avoid complaining about it + again. */ +#define DECL_INVALID_OVERRIDER_P(NODE) \ + (DECL_LANG_FLAG_4 (NODE)) + +/* The thunks associated with NODE, a FUNCTION_DECL. */ +#define DECL_THUNKS(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->context) + +/* Nonzero if NODE is a thunk, rather than an ordinary function. */ +#define DECL_THUNK_P(NODE) \ + (TREE_CODE (NODE) == FUNCTION_DECL \ + && DECL_LANG_SPECIFIC (NODE) \ + && LANG_DECL_FN_CHECK (NODE)->thunk_p) + +/* Set DECL_THUNK_P for node. */ +#define SET_DECL_THUNK_P(NODE, THIS_ADJUSTING) \ + (LANG_DECL_FN_CHECK (NODE)->thunk_p = 1, \ + LANG_DECL_FN_CHECK (NODE)->this_thunk_p = (THIS_ADJUSTING)) + +/* Nonzero if NODE is a this pointer adjusting thunk. */ +#define DECL_THIS_THUNK_P(NODE) \ + (DECL_THUNK_P (NODE) && LANG_DECL_FN_CHECK (NODE)->this_thunk_p) + +/* Nonzero if NODE is a result pointer adjusting thunk. */ +#define DECL_RESULT_THUNK_P(NODE) \ + (DECL_THUNK_P (NODE) && !LANG_DECL_FN_CHECK (NODE)->this_thunk_p) + +/* Nonzero if NODE is a FUNCTION_DECL, but not a thunk. */ +#define DECL_NON_THUNK_FUNCTION_P(NODE) \ + (TREE_CODE (NODE) == FUNCTION_DECL && !DECL_THUNK_P (NODE)) + +/* Nonzero if NODE is `extern "C"'. */ +#define DECL_EXTERN_C_P(NODE) \ + (DECL_LANGUAGE (NODE) == lang_c) + +/* Nonzero if NODE is an `extern "C"' function. */ +#define DECL_EXTERN_C_FUNCTION_P(NODE) \ + (DECL_NON_THUNK_FUNCTION_P (NODE) && DECL_EXTERN_C_P (NODE)) + +/* True iff DECL is an entity with vague linkage whose definition is + available in this translation unit. */ +#define DECL_REPO_AVAILABLE_P(NODE) \ + (DECL_LANG_SPECIFIC (NODE)->u.base.repo_available_p) + +/* True if DECL is declared 'constexpr'. */ +#define DECL_DECLARED_CONSTEXPR_P(DECL) \ + DECL_LANG_FLAG_8 (VAR_OR_FUNCTION_DECL_CHECK (STRIP_TEMPLATE (DECL))) + +/* Nonzero if this DECL is the __PRETTY_FUNCTION__ variable in a + template function. */ +#define DECL_PRETTY_FUNCTION_P(NODE) \ + (TREE_LANG_FLAG_0 (VAR_DECL_CHECK (NODE))) + +/* The _TYPE context in which this _DECL appears. This field holds the + class where a virtual function instance is actually defined. */ +#define DECL_CLASS_CONTEXT(NODE) \ + (DECL_CLASS_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : NULL_TREE) + +/* For a non-member friend function, the class (if any) in which this + friend was defined. For example, given: + + struct S { friend void f (); }; + + the DECL_FRIEND_CONTEXT for `f' will be `S'. */ +#define DECL_FRIEND_CONTEXT(NODE) \ + ((DECL_DECLARES_FUNCTION_P (NODE) \ + && DECL_FRIEND_P (NODE) && !DECL_FUNCTION_MEMBER_P (NODE)) \ + ? LANG_DECL_FN_CHECK (NODE)->context \ + : NULL_TREE) + +/* Set the DECL_FRIEND_CONTEXT for NODE to CONTEXT. */ +#define SET_DECL_FRIEND_CONTEXT(NODE, CONTEXT) \ + (LANG_DECL_FN_CHECK (NODE)->context = (CONTEXT)) + +#define CP_DECL_CONTEXT(NODE) \ + (!DECL_FILE_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : global_namespace) +#define CP_TYPE_CONTEXT(NODE) \ + (!TYPE_FILE_SCOPE_P (NODE) ? TYPE_CONTEXT (NODE) : global_namespace) +#define FROB_CONTEXT(NODE) \ + ((NODE) == global_namespace ? DECL_CONTEXT (NODE) : (NODE)) + +/* 1 iff NODE has namespace scope, including the global namespace. */ +#define DECL_NAMESPACE_SCOPE_P(NODE) \ + (!DECL_TEMPLATE_PARM_P (NODE) \ + && TREE_CODE (CP_DECL_CONTEXT (NODE)) == NAMESPACE_DECL) + +#define TYPE_NAMESPACE_SCOPE_P(NODE) \ + (TREE_CODE (CP_TYPE_CONTEXT (NODE)) == NAMESPACE_DECL) + +#define NAMESPACE_SCOPE_P(NODE) \ + ((DECL_P (NODE) && DECL_NAMESPACE_SCOPE_P (NODE)) \ + || (TYPE_P (NODE) && TYPE_NAMESPACE_SCOPE_P (NODE))) + +/* 1 iff NODE is a class member. */ +#define DECL_CLASS_SCOPE_P(NODE) \ + (DECL_CONTEXT (NODE) && TYPE_P (DECL_CONTEXT (NODE))) + +#define TYPE_CLASS_SCOPE_P(NODE) \ + (TYPE_CONTEXT (NODE) && TYPE_P (TYPE_CONTEXT (NODE))) + +/* 1 iff NODE is function-local. */ +#define DECL_FUNCTION_SCOPE_P(NODE) \ + (DECL_CONTEXT (NODE) \ + && TREE_CODE (DECL_CONTEXT (NODE)) == FUNCTION_DECL) + +#define TYPE_FUNCTION_SCOPE_P(NODE) \ + (TYPE_CONTEXT (NODE) && TREE_CODE (TYPE_CONTEXT (NODE)) == FUNCTION_DECL) + +/* 1 iff VAR_DECL node NODE is a type-info decl. This flag is set for + both the primary typeinfo object and the associated NTBS name. */ +#define DECL_TINFO_P(NODE) TREE_LANG_FLAG_4 (VAR_DECL_CHECK (NODE)) + +/* 1 iff VAR_DECL node NODE is virtual table or VTT. */ +#define DECL_VTABLE_OR_VTT_P(NODE) TREE_LANG_FLAG_5 (VAR_DECL_CHECK (NODE)) + +/* Returns 1 iff VAR_DECL is a construction virtual table. + DECL_VTABLE_OR_VTT_P will be true in this case and must be checked + before using this macro. */ +#define DECL_CONSTRUCTION_VTABLE_P(NODE) \ + TREE_LANG_FLAG_6 (VAR_DECL_CHECK (NODE)) + +/* 1 iff NODE is function-local, but for types. */ +#define LOCAL_CLASS_P(NODE) \ + (decl_function_context (TYPE_MAIN_DECL (NODE)) != NULL_TREE) + +/* For a NAMESPACE_DECL: the list of using namespace directives + The PURPOSE is the used namespace, the value is the namespace + that is the common ancestor. */ +#define DECL_NAMESPACE_USING(NODE) DECL_VINDEX (NAMESPACE_DECL_CHECK (NODE)) + +/* In a NAMESPACE_DECL, the DECL_INITIAL is used to record all users + of a namespace, to record the transitive closure of using namespace. */ +#define DECL_NAMESPACE_USERS(NODE) DECL_INITIAL (NAMESPACE_DECL_CHECK (NODE)) + +/* In a NAMESPACE_DECL, the list of namespaces which have associated + themselves with this one. */ +#define DECL_NAMESPACE_ASSOCIATIONS(NODE) \ + (NAMESPACE_DECL_CHECK (NODE)->decl_non_common.saved_tree) + +/* In a NAMESPACE_DECL, points to the original namespace if this is + a namespace alias. */ +#define DECL_NAMESPACE_ALIAS(NODE) \ + DECL_ABSTRACT_ORIGIN (NAMESPACE_DECL_CHECK (NODE)) +#define ORIGINAL_NAMESPACE(NODE) \ + (DECL_NAMESPACE_ALIAS (NODE) ? DECL_NAMESPACE_ALIAS (NODE) : (NODE)) + +/* Nonzero if NODE is the std namespace. */ +#define DECL_NAMESPACE_STD_P(NODE) \ + (TREE_CODE (NODE) == NAMESPACE_DECL \ + && CP_DECL_CONTEXT (NODE) == global_namespace \ + && DECL_NAME (NODE) == std_identifier) + +/* In a TREE_LIST concatenating using directives, indicate indirect + directives */ +#define TREE_INDIRECT_USING(NODE) (TREE_LIST_CHECK (NODE)->base.lang_flag_0) + +/* In a TREE_LIST in an attribute list, indicates that the attribute + must be applied at instantiation time. */ +#define ATTR_IS_DEPENDENT(NODE) (TREE_LIST_CHECK (NODE)->base.lang_flag_0) + +extern tree decl_shadowed_for_var_lookup (tree); +extern void decl_shadowed_for_var_insert (tree, tree); + +/* Non zero if this is a using decl for a dependent scope. */ +#define DECL_DEPENDENT_P(NODE) DECL_LANG_FLAG_0 (USING_DECL_CHECK (NODE)) + +/* The scope named in a using decl. */ +#define USING_DECL_SCOPE(NODE) TREE_TYPE (USING_DECL_CHECK (NODE)) + +/* The decls named by a using decl. */ +#define USING_DECL_DECLS(NODE) DECL_INITIAL (USING_DECL_CHECK (NODE)) + +/* In a VAR_DECL, true if we have a shadowed local variable + in the shadowed var table for this VAR_DECL. */ +#define DECL_HAS_SHADOWED_FOR_VAR_P(NODE) \ + (VAR_DECL_CHECK (NODE)->decl_with_vis.shadowed_for_var_p) + +/* In a VAR_DECL for a variable declared in a for statement, + this is the shadowed (local) variable. */ +#define DECL_SHADOWED_FOR_VAR(NODE) \ + (DECL_HAS_SHADOWED_FOR_VAR_P(NODE) ? decl_shadowed_for_var_lookup (NODE) : NULL) + +#define SET_DECL_SHADOWED_FOR_VAR(NODE, VAL) \ + (decl_shadowed_for_var_insert (NODE, VAL)) + +/* In a FUNCTION_DECL, this is nonzero if this function was defined in + the class definition. We have saved away the text of the function, + but have not yet processed it. */ +#define DECL_PENDING_INLINE_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->pending_inline_p) + +/* If DECL_PENDING_INLINE_P holds, this is the saved text of the + function. */ +#define DECL_PENDING_INLINE_INFO(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->u.pending_inline_info) + +/* For a class type: if this structure has many fields, we'll sort them + and put them into a TREE_VEC. */ +#define CLASSTYPE_SORTED_FIELDS(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->sorted_fields) + +/* If non-NULL for a VAR_DECL, FUNCTION_DECL, TYPE_DECL or + TEMPLATE_DECL, the entity is either a template specialization (if + DECL_USE_TEMPLATE is nonzero) or the abstract instance of the + template itself. + + In either case, DECL_TEMPLATE_INFO is a TREE_LIST, whose + TREE_PURPOSE is the TEMPLATE_DECL of which this entity is a + specialization or abstract instance. The TREE_VALUE is the + template arguments used to specialize the template. + + Consider: + + template struct S { friend void f(T) {} }; + + In this case, S::f is, from the point of view of the compiler, + an instantiation of a template -- but, from the point of view of + the language, each instantiation of S results in a wholly unrelated + global function f. In this case, DECL_TEMPLATE_INFO for S::f + will be non-NULL, but DECL_USE_TEMPLATE will be zero. */ +#define DECL_TEMPLATE_INFO(NODE) \ + (DECL_LANG_SPECIFIC (VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK (NODE)) \ + ->u.min.template_info) + +/* For a VAR_DECL, indicates that the variable is actually a + non-static data member of anonymous union that has been promoted to + variable status. */ +#define DECL_ANON_UNION_VAR_P(NODE) \ + (DECL_LANG_FLAG_4 (VAR_DECL_CHECK (NODE))) + +/* Template information for a RECORD_TYPE or UNION_TYPE. */ +#define CLASSTYPE_TEMPLATE_INFO(NODE) \ + (LANG_TYPE_CLASS_CHECK (RECORD_OR_UNION_CHECK (NODE))->template_info) + +/* Template information for an ENUMERAL_TYPE. Although an enumeration may + not be a primary template, it may be declared within the scope of a + primary template and the enumeration constants may depend on + non-type template parameters. */ +#define ENUM_TEMPLATE_INFO(NODE) \ + (TYPE_LANG_SLOT_1 (ENUMERAL_TYPE_CHECK (NODE))) + +/* Template information for a template template parameter. */ +#define TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO(NODE) \ + (LANG_TYPE_CLASS_CHECK (BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK (NODE)) \ + ->template_info) + +/* Template information for an ENUMERAL_, RECORD_, or UNION_TYPE. */ +#define TYPE_TEMPLATE_INFO(NODE) \ + (TREE_CODE (NODE) == ENUMERAL_TYPE \ + ? ENUM_TEMPLATE_INFO (NODE) : \ + (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM \ + ? TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (NODE) : \ + (TYPE_LANG_SPECIFIC (NODE) \ + ? CLASSTYPE_TEMPLATE_INFO (NODE) \ + : NULL_TREE))) + +/* Set the template information for an ENUMERAL_, RECORD_, or + UNION_TYPE to VAL. */ +#define SET_TYPE_TEMPLATE_INFO(NODE, VAL) \ + (TREE_CODE (NODE) == ENUMERAL_TYPE \ + ? (ENUM_TEMPLATE_INFO (NODE) = (VAL)) \ + : (CLASSTYPE_TEMPLATE_INFO (NODE) = (VAL))) + +#define TI_TEMPLATE(NODE) TREE_TYPE (TEMPLATE_INFO_CHECK (NODE)) +#define TI_ARGS(NODE) TREE_CHAIN (TEMPLATE_INFO_CHECK (NODE)) +#define TI_PENDING_TEMPLATE_FLAG(NODE) TREE_LANG_FLAG_1 (NODE) +/* For a given TREE_VEC containing a template argument list, + this property contains the number of arguments that are not + defaulted. */ +#define NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) TREE_CHAIN (TREE_VEC_CHECK (NODE)) +/* Below are the setter and getter of the NON_DEFAULT_TEMPLATE_ARGS_COUNT + property. */ +#define SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE, INT_VALUE) \ + NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) = build_int_cst (NULL_TREE, INT_VALUE) +#ifdef ENABLE_CHECKING +#define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \ + int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE)) +#else +#define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \ + NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE) \ + ? int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE)) \ + : TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (NODE)) +#endif +/* The list of typedefs - used in the template - that need + access checking at template instantiation time. */ +#define TI_TYPEDEFS_NEEDING_ACCESS_CHECKING(NODE) \ + ((struct tree_template_info*)TEMPLATE_INFO_CHECK \ + (NODE))->typedefs_needing_access_checking + +/* We use TREE_VECs to hold template arguments. If there is only one + level of template arguments, then the TREE_VEC contains the + arguments directly. If there is more than one level of template + arguments, then each entry in the TREE_VEC is itself a TREE_VEC, + containing the template arguments for a single level. The first + entry in the outer TREE_VEC is the outermost level of template + parameters; the last is the innermost. + + It is incorrect to ever form a template argument vector containing + only one level of arguments, but which is a TREE_VEC containing as + its only entry the TREE_VEC for that level. + + For each TREE_VEC containing the template arguments for a single + level, it's possible to get or set the number of non defaulted + template arguments by using the accessor macros + GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT or + SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT. */ + +/* Nonzero if the template arguments is actually a vector of vectors, + rather than just a vector. */ +#define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \ + (NODE && TREE_VEC_LENGTH (NODE) && TREE_VEC_ELT (NODE, 0) \ + && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC) + +/* The depth of a template argument vector. When called directly by + the parser, we use a TREE_LIST rather than a TREE_VEC to represent + template arguments. In fact, we may even see NULL_TREE if there + are no template arguments. In both of those cases, there is only + one level of template arguments. */ +#define TMPL_ARGS_DEPTH(NODE) \ + (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1) + +/* The LEVELth level of the template ARGS. The outermost level of + args is level 1, not level 0. */ +#define TMPL_ARGS_LEVEL(ARGS, LEVEL) \ + (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS) \ + ? TREE_VEC_ELT (ARGS, (LEVEL) - 1) : (ARGS)) + +/* Set the LEVELth level of the template ARGS to VAL. This macro does + not work with single-level argument vectors. */ +#define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL) \ + (TREE_VEC_ELT (ARGS, (LEVEL) - 1) = (VAL)) + +/* Accesses the IDXth parameter in the LEVELth level of the ARGS. */ +#define TMPL_ARG(ARGS, LEVEL, IDX) \ + (TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX)) + +/* Given a single level of template arguments in NODE, return the + number of arguments. */ +#define NUM_TMPL_ARGS(NODE) \ + (TREE_VEC_LENGTH (NODE)) + +/* Returns the innermost level of template arguments in ARGS. */ +#define INNERMOST_TEMPLATE_ARGS(NODE) \ + (get_innermost_template_args ((NODE), 1)) + +/* The number of levels of template parameters given by NODE. */ +#define TMPL_PARMS_DEPTH(NODE) \ + ((HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_PURPOSE (NODE))) + +/* The TEMPLATE_DECL instantiated or specialized by NODE. This + TEMPLATE_DECL will be the immediate parent, not the most general + template. For example, in: + + template struct S { template void f(U); } + + the FUNCTION_DECL for S::f will have, as its + DECL_TI_TEMPLATE, `template S::f'. + + As a special case, for a member friend template of a template + class, this value will not be a TEMPLATE_DECL, but rather an + IDENTIFIER_NODE or OVERLOAD indicating the name of the template and + any explicit template arguments provided. For example, in: + + template struct S { friend void f(int, double); } + + the DECL_TI_TEMPLATE will be an IDENTIFIER_NODE for `f' and the + DECL_TI_ARGS will be {int}. */ +#define DECL_TI_TEMPLATE(NODE) TI_TEMPLATE (DECL_TEMPLATE_INFO (NODE)) + +/* The template arguments used to obtain this decl from the most + general form of DECL_TI_TEMPLATE. For the example given for + DECL_TI_TEMPLATE, the DECL_TI_ARGS will be {int, double}. These + are always the full set of arguments required to instantiate this + declaration from the most general template specialized here. */ +#define DECL_TI_ARGS(NODE) TI_ARGS (DECL_TEMPLATE_INFO (NODE)) + +/* The TEMPLATE_DECL associated with NODE, a class type. Even if NODE + will be generated from a partial specialization, the TEMPLATE_DECL + referred to here will be the original template. For example, + given: + + template struct S {}; + template struct S {}; + + the CLASSTPYE_TI_TEMPLATE for S will be S, not the S. */ +#define CLASSTYPE_TI_TEMPLATE(NODE) TI_TEMPLATE (CLASSTYPE_TEMPLATE_INFO (NODE)) +#define CLASSTYPE_TI_ARGS(NODE) TI_ARGS (CLASSTYPE_TEMPLATE_INFO (NODE)) + +/* For a template instantiation TYPE, returns the TYPE corresponding + to the primary template. Otherwise returns TYPE itself. */ +#define CLASSTYPE_PRIMARY_TEMPLATE_TYPE(TYPE) \ + ((CLASSTYPE_USE_TEMPLATE ((TYPE)) \ + && !CLASSTYPE_TEMPLATE_SPECIALIZATION ((TYPE))) \ + ? TREE_TYPE (DECL_TEMPLATE_RESULT (DECL_PRIMARY_TEMPLATE \ + (CLASSTYPE_TI_TEMPLATE ((TYPE))))) \ + : (TYPE)) + +/* Like CLASS_TI_TEMPLATE, but also works for ENUMERAL_TYPEs. */ +#define TYPE_TI_TEMPLATE(NODE) \ + (TI_TEMPLATE (TYPE_TEMPLATE_INFO (NODE))) + +/* Like DECL_TI_ARGS, but for an ENUMERAL_, RECORD_, or UNION_TYPE. */ +#define TYPE_TI_ARGS(NODE) \ + (TI_ARGS (TYPE_TEMPLATE_INFO (NODE))) + +#define INNERMOST_TEMPLATE_PARMS(NODE) TREE_VALUE (NODE) + +/* Nonzero if NODE (a TEMPLATE_DECL) is a member template, in the + sense of [temp.mem]. */ +#define DECL_MEMBER_TEMPLATE_P(NODE) \ + (DECL_LANG_FLAG_1 (TEMPLATE_DECL_CHECK (NODE))) + +/* Nonzero if the NODE corresponds to the template parameters for a + member template, whose inline definition is being processed after + the class definition is complete. */ +#define TEMPLATE_PARMS_FOR_INLINE(NODE) TREE_LANG_FLAG_1 (NODE) + +/* Determine if a parameter (i.e., a PARM_DECL) is a function + parameter pack. */ +#define FUNCTION_PARAMETER_PACK_P(NODE) \ + (DECL_LANG_FLAG_1 (PARM_DECL_CHECK (NODE))) + +/* Determines if NODE is an expansion of one or more parameter packs, + e.g., a TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION. */ +#define PACK_EXPANSION_P(NODE) \ + (TREE_CODE (NODE) == TYPE_PACK_EXPANSION \ + || TREE_CODE (NODE) == EXPR_PACK_EXPANSION) + +/* Extracts the type or expression pattern from a TYPE_PACK_EXPANSION or + EXPR_PACK_EXPANSION. */ +#define PACK_EXPANSION_PATTERN(NODE) \ + (TREE_CODE (NODE) == TYPE_PACK_EXPANSION? TREE_TYPE (NODE) \ + : TREE_OPERAND (NODE, 0)) + +/* Sets the type or expression pattern for a TYPE_PACK_EXPANSION or + EXPR_PACK_EXPANSION. */ +#define SET_PACK_EXPANSION_PATTERN(NODE,VALUE) \ + if (TREE_CODE (NODE) == TYPE_PACK_EXPANSION) \ + TREE_TYPE (NODE) = VALUE; \ + else \ + TREE_OPERAND (NODE, 0) = VALUE + +/* The list of parameter packs used in the PACK_EXPANSION_* node. The + TREE_VALUE of each TREE_LIST contains the parameter packs. */ +#define PACK_EXPANSION_PARAMETER_PACKS(NODE) TREE_CHAIN (NODE) + +/* Determine if this is an argument pack. */ +#define ARGUMENT_PACK_P(NODE) \ + (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK \ + || TREE_CODE (NODE) == NONTYPE_ARGUMENT_PACK) + +/* The arguments stored in an argument pack. Arguments are stored in a + TREE_VEC, which may have length zero. */ +#define ARGUMENT_PACK_ARGS(NODE) \ + (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK? TREE_TYPE (NODE) \ + : TREE_OPERAND (NODE, 0)) + +/* Set the arguments stored in an argument pack. VALUE must be a + TREE_VEC. */ +#define SET_ARGUMENT_PACK_ARGS(NODE,VALUE) \ + if (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK) \ + TREE_TYPE (NODE) = VALUE; \ + else \ + TREE_OPERAND (NODE, 0) = VALUE + +/* Whether the argument pack is "incomplete", meaning that more + arguments can still be deduced. Incomplete argument packs are only + used when the user has provided an explicit template argument list + for a variadic function template. Some of the explicit template + arguments will be placed into the beginning of the argument pack, + but additional arguments might still be deduced. */ +#define ARGUMENT_PACK_INCOMPLETE_P(NODE) \ + TREE_LANG_FLAG_0 (ARGUMENT_PACK_ARGS (NODE)) + +/* When ARGUMENT_PACK_INCOMPLETE_P, stores the explicit template + arguments used to fill this pack. */ +#define ARGUMENT_PACK_EXPLICIT_ARGS(NODE) \ + TREE_TYPE (ARGUMENT_PACK_ARGS (NODE)) + +/* In an ARGUMENT_PACK_SELECT, the argument pack from which an + argument will be selected. */ +#define ARGUMENT_PACK_SELECT_FROM_PACK(NODE) \ + (((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->argument_pack) + +/* In an ARGUMENT_PACK_SELECT, the index of the argument we want to + select. */ +#define ARGUMENT_PACK_SELECT_INDEX(NODE) \ + (((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->index) + +/* In an ARGUMENT_PACK_SELECT, the actual underlying argument that the + ARGUMENT_PACK_SELECT represents. */ +#define ARGUMENT_PACK_SELECT_ARG(NODE) \ + TREE_VEC_ELT (ARGUMENT_PACK_ARGS (ARGUMENT_PACK_SELECT_FROM_PACK (NODE)), \ + ARGUMENT_PACK_SELECT_INDEX (NODE)); + +/* In a FUNCTION_DECL, the saved language-specific per-function data. */ +#define DECL_SAVED_FUNCTION_DATA(NODE) \ + (LANG_DECL_FN_CHECK (FUNCTION_DECL_CHECK (NODE)) \ + ->u.saved_language_function) + +/* Indicates an indirect_expr is for converting a reference. */ +#define REFERENCE_REF_P(NODE) \ + TREE_LANG_FLAG_0 (INDIRECT_REF_CHECK (NODE)) + +#define NEW_EXPR_USE_GLOBAL(NODE) \ + TREE_LANG_FLAG_0 (NEW_EXPR_CHECK (NODE)) +#define DELETE_EXPR_USE_GLOBAL(NODE) \ + TREE_LANG_FLAG_0 (DELETE_EXPR_CHECK (NODE)) +#define DELETE_EXPR_USE_VEC(NODE) \ + TREE_LANG_FLAG_1 (DELETE_EXPR_CHECK (NODE)) + +/* Indicates that this is a non-dependent COMPOUND_EXPR which will + resolve to a function call. */ +#define COMPOUND_EXPR_OVERLOADED(NODE) \ + TREE_LANG_FLAG_0 (COMPOUND_EXPR_CHECK (NODE)) + +/* In a CALL_EXPR appearing in a template, true if Koenig lookup + should be performed at instantiation time. */ +#define KOENIG_LOOKUP_P(NODE) TREE_LANG_FLAG_0 (CALL_EXPR_CHECK (NODE)) + +/* Indicates whether a string literal has been parenthesized. Such + usages are disallowed in certain circumstances. */ + +#define PAREN_STRING_LITERAL_P(NODE) \ + TREE_LANG_FLAG_0 (STRING_CST_CHECK (NODE)) + +/* Nonzero if this AGGR_INIT_EXPR provides for initialization via a + constructor call, rather than an ordinary function call. */ +#define AGGR_INIT_VIA_CTOR_P(NODE) \ + TREE_LANG_FLAG_0 (AGGR_INIT_EXPR_CHECK (NODE)) + +/* Nonzero if expanding this AGGR_INIT_EXPR should first zero-initialize + the object. */ +#define AGGR_INIT_ZERO_FIRST(NODE) \ + TREE_LANG_FLAG_2 (AGGR_INIT_EXPR_CHECK (NODE)) + +/* AGGR_INIT_EXPR accessors. These are equivalent to the CALL_EXPR + accessors, except for AGGR_INIT_EXPR_SLOT (which takes the place of + CALL_EXPR_STATIC_CHAIN). */ + +#define AGGR_INIT_EXPR_FN(NODE) TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 1) +#define AGGR_INIT_EXPR_SLOT(NODE) \ + TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 2) +#define AGGR_INIT_EXPR_ARG(NODE, I) \ + TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), (I) + 3) +#define aggr_init_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH(NODE) - 3) + +/* AGGR_INIT_EXPR_ARGP returns a pointer to the argument vector for NODE. + We can't use &AGGR_INIT_EXPR_ARG (NODE, 0) because that will complain if + the argument count is zero when checking is enabled. Instead, do + the pointer arithmetic to advance past the 3 fixed operands in a + AGGR_INIT_EXPR. That produces a valid pointer to just past the end of + the operand array, even if it's not valid to dereference it. */ +#define AGGR_INIT_EXPR_ARGP(NODE) \ + (&(TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 0)) + 3) + +/* Abstract iterators for AGGR_INIT_EXPRs. */ + +/* Structure containing iterator state. */ +typedef struct aggr_init_expr_arg_iterator_d { + tree t; /* the aggr_init_expr */ + int n; /* argument count */ + int i; /* next argument index */ +} aggr_init_expr_arg_iterator; + +/* Initialize the abstract argument list iterator object ITER with the + arguments from AGGR_INIT_EXPR node EXP. */ +static inline void +init_aggr_init_expr_arg_iterator (tree exp, + aggr_init_expr_arg_iterator *iter) +{ + iter->t = exp; + iter->n = aggr_init_expr_nargs (exp); + iter->i = 0; +} + +/* Return the next argument from abstract argument list iterator object ITER, + and advance its state. Return NULL_TREE if there are no more arguments. */ +static inline tree +next_aggr_init_expr_arg (aggr_init_expr_arg_iterator *iter) +{ + tree result; + if (iter->i >= iter->n) + return NULL_TREE; + result = AGGR_INIT_EXPR_ARG (iter->t, iter->i); + iter->i++; + return result; +} + +/* Initialize the abstract argument list iterator object ITER, then advance + past and return the first argument. Useful in for expressions, e.g. + for (arg = first_aggr_init_expr_arg (exp, &iter); arg; + arg = next_aggr_init_expr_arg (&iter)) */ +static inline tree +first_aggr_init_expr_arg (tree exp, aggr_init_expr_arg_iterator *iter) +{ + init_aggr_init_expr_arg_iterator (exp, iter); + return next_aggr_init_expr_arg (iter); +} + +/* Test whether there are more arguments in abstract argument list iterator + ITER, without changing its state. */ +static inline bool +more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter) +{ + return (iter->i < iter->n); +} + +/* Iterate through each argument ARG of AGGR_INIT_EXPR CALL, using variable + ITER (of type aggr_init_expr_arg_iterator) to hold the iteration state. */ +#define FOR_EACH_AGGR_INIT_EXPR_ARG(arg, iter, call) \ + for ((arg) = first_aggr_init_expr_arg ((call), &(iter)); (arg); \ + (arg) = next_aggr_init_expr_arg (&(iter))) + +/* VEC_INIT_EXPR accessors. */ +#define VEC_INIT_EXPR_SLOT(NODE) TREE_OPERAND (NODE, 0) +#define VEC_INIT_EXPR_INIT(NODE) TREE_OPERAND (NODE, 1) + +/* Indicates that a VEC_INIT_EXPR is a potential constant expression. + Only set when the current function is constexpr. */ +#define VEC_INIT_EXPR_IS_CONSTEXPR(NODE) \ + TREE_LANG_FLAG_0 (VEC_INIT_EXPR_CHECK (NODE)) + +/* Indicates that a VEC_INIT_EXPR is expressing value-initialization. */ +#define VEC_INIT_EXPR_VALUE_INIT(NODE) \ + TREE_LANG_FLAG_1 (VEC_INIT_EXPR_CHECK (NODE)) + +/* The TYPE_MAIN_DECL for a class template type is a TYPE_DECL, not a + TEMPLATE_DECL. This macro determines whether or not a given class + type is really a template type, as opposed to an instantiation or + specialization of one. */ +#define CLASSTYPE_IS_TEMPLATE(NODE) \ + (CLASSTYPE_TEMPLATE_INFO (NODE) \ + && !CLASSTYPE_USE_TEMPLATE (NODE) \ + && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))) + +/* The name used by the user to name the typename type. Typically, + this is an IDENTIFIER_NODE, and the same as the DECL_NAME on the + corresponding TYPE_DECL. However, this may also be a + TEMPLATE_ID_EXPR if we had something like `typename X::Y'. */ +#define TYPENAME_TYPE_FULLNAME(NODE) (TYPENAME_TYPE_CHECK (NODE))->type.values + +/* True if a TYPENAME_TYPE was declared as an "enum". */ +#define TYPENAME_IS_ENUM_P(NODE) \ + (TREE_LANG_FLAG_0 (TYPENAME_TYPE_CHECK (NODE))) + +/* True if a TYPENAME_TYPE was declared as a "class", "struct", or + "union". */ +#define TYPENAME_IS_CLASS_P(NODE) \ + (TREE_LANG_FLAG_1 (TYPENAME_TYPE_CHECK (NODE))) + +/* True if a TYPENAME_TYPE is in the process of being resolved. */ +#define TYPENAME_IS_RESOLVING_P(NODE) \ + (TREE_LANG_FLAG_2 (TYPENAME_TYPE_CHECK (NODE))) + +/* Nonzero in INTEGER_CST means that this int is negative by dint of + using a twos-complement negated operand. */ +#define TREE_NEGATED_INT(NODE) TREE_LANG_FLAG_0 (INTEGER_CST_CHECK (NODE)) + +/* [class.virtual] + + A class that declares or inherits a virtual function is called a + polymorphic class. */ +#define TYPE_POLYMORPHIC_P(NODE) (TREE_LANG_FLAG_2 (NODE)) + +/* Nonzero if this class has a virtual function table pointer. */ +#define TYPE_CONTAINS_VPTR_P(NODE) \ + (TYPE_POLYMORPHIC_P (NODE) || CLASSTYPE_VBASECLASSES (NODE)) + +/* This flag is true of a local VAR_DECL if it was declared in a for + statement, but we are no longer in the scope of the for. */ +#define DECL_DEAD_FOR_LOCAL(NODE) DECL_LANG_FLAG_7 (VAR_DECL_CHECK (NODE)) + +/* This flag is set on a VAR_DECL that is a DECL_DEAD_FOR_LOCAL + if we already emitted a warning about using it. */ +#define DECL_ERROR_REPORTED(NODE) DECL_LANG_FLAG_0 (VAR_DECL_CHECK (NODE)) + +/* Nonzero if NODE is a FUNCTION_DECL (for a function with global + scope) declared in a local scope. */ +#define DECL_LOCAL_FUNCTION_P(NODE) \ + DECL_LANG_FLAG_0 (FUNCTION_DECL_CHECK (NODE)) + +/* Nonzero if NODE is a DECL which we know about but which has not + been explicitly declared, such as a built-in function or a friend + declared inside a class. In the latter case DECL_HIDDEN_FRIEND_P + will be set. */ +#define DECL_ANTICIPATED(NODE) \ + (DECL_LANG_SPECIFIC (DECL_COMMON_CHECK (NODE))->u.base.anticipated_p) + +/* Nonzero if NODE is a FUNCTION_DECL which was declared as a friend + within a class but has not been declared in the surrounding scope. + The function is invisible except via argument dependent lookup. */ +#define DECL_HIDDEN_FRIEND_P(NODE) \ + (LANG_DECL_FN_CHECK (DECL_COMMON_CHECK (NODE))->hidden_friend_p) + +/* Nonzero if DECL has been declared threadprivate by + #pragma omp threadprivate. */ +#define CP_DECL_THREADPRIVATE_P(DECL) \ + (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (DECL))->u.base.threadprivate_or_deleted_p) + +/* Nonzero if DECL was declared with '= delete'. */ +#define DECL_DELETED_FN(DECL) \ + (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->u.base.threadprivate_or_deleted_p) + +/* Nonzero if DECL was declared with '= default' (maybe implicitly). */ +#define DECL_DEFAULTED_FN(DECL) \ + (LANG_DECL_FN_CHECK (DECL)->defaulted_p) + +/* Nonzero if DECL is explicitly defaulted in the class body. */ +#define DECL_DEFAULTED_IN_CLASS_P(DECL) \ + (DECL_DEFAULTED_FN (DECL) && DECL_INITIALIZED_IN_CLASS_P (DECL)) +/* Nonzero if DECL was defaulted outside the class body. */ +#define DECL_DEFAULTED_OUTSIDE_CLASS_P(DECL) \ + (DECL_DEFAULTED_FN (DECL) \ + && !(DECL_ARTIFICIAL (DECL) || DECL_INITIALIZED_IN_CLASS_P (DECL))) + +/* Record whether a typedef for type `int' was actually `signed int'. */ +#define C_TYPEDEF_EXPLICITLY_SIGNED(EXP) DECL_LANG_FLAG_1 (EXP) + +/* Returns nonzero if DECL has external linkage, as specified by the + language standard. (This predicate may hold even when the + corresponding entity is not actually given external linkage in the + object file; see decl_linkage for details.) */ +#define DECL_EXTERNAL_LINKAGE_P(DECL) \ + (decl_linkage (DECL) == lk_external) + +/* Keep these codes in ascending code order. */ + +#define INTEGRAL_CODE_P(CODE) \ + ((CODE) == ENUMERAL_TYPE \ + || (CODE) == BOOLEAN_TYPE \ + || (CODE) == INTEGER_TYPE) + +/* [basic.fundamental] + + Types bool, char, wchar_t, and the signed and unsigned integer types + are collectively called integral types. + + Note that INTEGRAL_TYPE_P, as defined in tree.h, allows enumeration + types as well, which is incorrect in C++. Keep these checks in + ascending code order. */ +#define CP_INTEGRAL_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == BOOLEAN_TYPE \ + || TREE_CODE (TYPE) == INTEGER_TYPE) + +/* Returns true if TYPE is an integral or enumeration name. Keep + these checks in ascending code order. */ +#define INTEGRAL_OR_ENUMERATION_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == ENUMERAL_TYPE || CP_INTEGRAL_TYPE_P (TYPE)) + +/* Returns true if TYPE is an integral or unscoped enumeration type. */ +#define INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P(TYPE) \ + (UNSCOPED_ENUM_P (TYPE) || CP_INTEGRAL_TYPE_P (TYPE)) + +/* True if the class type TYPE is a literal type. */ +#define CLASSTYPE_LITERAL_P(TYPE) \ + (LANG_TYPE_CLASS_CHECK (TYPE)->is_literal) + +/* [basic.fundamental] + + Integral and floating types are collectively called arithmetic + types. + + As a GNU extension, we also accept complex types. + + Keep these checks in ascending code order. */ +#define ARITHMETIC_TYPE_P(TYPE) \ + (CP_INTEGRAL_TYPE_P (TYPE) \ + || TREE_CODE (TYPE) == REAL_TYPE \ + || TREE_CODE (TYPE) == COMPLEX_TYPE) + +/* True iff TYPE is cv decltype(nullptr). */ +#define NULLPTR_TYPE_P(TYPE) (TREE_CODE (TYPE) == NULLPTR_TYPE) + +/* [basic.types] + + Arithmetic types, enumeration types, pointer types, + pointer-to-member types, and std::nullptr_t are collectively called + scalar types. + + Keep these checks in ascending code order. */ +#define SCALAR_TYPE_P(TYPE) \ + (TYPE_PTRMEM_P (TYPE) \ + || TREE_CODE (TYPE) == ENUMERAL_TYPE \ + || ARITHMETIC_TYPE_P (TYPE) \ + || TYPE_PTR_P (TYPE) \ + || TYPE_PTRMEMFUNC_P (TYPE) \ + || NULLPTR_TYPE_P (TYPE)) + +/* Determines whether this type is a C++0x scoped enumeration + type. Scoped enumerations types are introduced via "enum class" or + "enum struct", e.g., + + enum class Color { + Red, Green, Blue + }; + + Scoped enumeration types are different from normal (unscoped) + enumeration types in several ways: + + - The enumerators of a scoped enumeration type are only available + within the scope of the enumeration type and not in the + enclosing scope. For example, the Red color can be referred to + with "Color::Red" but not "Red". + + - Scoped enumerators and enumerations do not implicitly convert + to integers or 'bool'. + + - The underlying type of the enum is well-defined. */ +#define SCOPED_ENUM_P(TYPE) \ + (TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_SCOPED (TYPE)) + +/* Determine whether this is an unscoped enumeration type. */ +#define UNSCOPED_ENUM_P(TYPE) \ + (TREE_CODE (TYPE) == ENUMERAL_TYPE && !ENUM_IS_SCOPED (TYPE)) + +/* Set the flag indicating whether an ENUMERAL_TYPE is a C++0x scoped + enumeration type (1) or a normal (unscoped) enumeration type + (0). */ +#define SET_SCOPED_ENUM_P(TYPE, VAL) \ + (ENUM_IS_SCOPED (TYPE) = (VAL)) + +#define SET_OPAQUE_ENUM_P(TYPE, VAL) \ + (ENUM_IS_OPAQUE (TYPE) = (VAL)) + +#define OPAQUE_ENUM_P(TYPE) \ + (TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_OPAQUE (TYPE)) + +/* Determines whether an ENUMERAL_TYPE has an explicit + underlying type. */ +#define ENUM_FIXED_UNDERLYING_TYPE_P(NODE) (TYPE_LANG_FLAG_5 (NODE)) + +/* Returns the underlying type of the given enumeration type. The + underlying type is determined in different ways, depending on the + properties of the enum: + + - In C++0x, the underlying type can be explicitly specified, e.g., + + enum E1 : char { ... } // underlying type is char + + - In a C++0x scoped enumeration, the underlying type is int + unless otherwises specified: + + enum class E2 { ... } // underlying type is int + + - Otherwise, the underlying type is determined based on the + values of the enumerators. In this case, the + ENUM_UNDERLYING_TYPE will not be set until after the definition + of the enumeration is completed by finish_enum. */ +#define ENUM_UNDERLYING_TYPE(TYPE) \ + TREE_TYPE (ENUMERAL_TYPE_CHECK (TYPE)) + +/* [dcl.init.aggr] + + An aggregate is an array or a class with no user-declared + constructors, no private or protected non-static data members, no + base classes, and no virtual functions. + + As an extension, we also treat vectors as aggregates. Keep these + checks in ascending code order. */ +#define CP_AGGREGATE_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == VECTOR_TYPE \ + ||TREE_CODE (TYPE) == ARRAY_TYPE \ + || (CLASS_TYPE_P (TYPE) && !CLASSTYPE_NON_AGGREGATE (TYPE))) + +/* Nonzero for a class type means that the class type has a + user-declared constructor. */ +#define TYPE_HAS_USER_CONSTRUCTOR(NODE) (TYPE_LANG_FLAG_1 (NODE)) + +/* When appearing in an INDIRECT_REF, it means that the tree structure + underneath is actually a call to a constructor. This is needed + when the constructor must initialize local storage (which can + be automatically destroyed), rather than allowing it to allocate + space from the heap. + + When appearing in a SAVE_EXPR, it means that underneath + is a call to a constructor. + + When appearing in a CONSTRUCTOR, the expression is a + compound literal. + + When appearing in a FIELD_DECL, it means that this field + has been duly initialized in its constructor. */ +#define TREE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_4 (NODE)) + +/* True if NODE is a brace-enclosed initializer. */ +#define BRACE_ENCLOSED_INITIALIZER_P(NODE) \ + (TREE_CODE (NODE) == CONSTRUCTOR && TREE_TYPE (NODE) == init_list_type_node) + +/* True if NODE is a compound-literal, i.e., a brace-enclosed + initializer cast to a particular type. */ +#define COMPOUND_LITERAL_P(NODE) \ + (TREE_CODE (NODE) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (NODE)) + +#define EMPTY_CONSTRUCTOR_P(NODE) (TREE_CODE (NODE) == CONSTRUCTOR \ + && VEC_empty (constructor_elt, \ + CONSTRUCTOR_ELTS (NODE)) \ + && !TREE_HAS_CONSTRUCTOR (NODE)) + +/* True if NODE is a init-list used as a direct-initializer, i.e. + B b{1,2}, not B b({1,2}) or B b = {1,2}. */ +#define CONSTRUCTOR_IS_DIRECT_INIT(NODE) (TREE_LANG_FLAG_0 (CONSTRUCTOR_CHECK (NODE))) + +/* Nonzero means that an object of this type can not be initialized using + an initializer list. */ +#define CLASSTYPE_NON_AGGREGATE(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->non_aggregate) +#define TYPE_NON_AGGREGATE_CLASS(NODE) \ + (CLASS_TYPE_P (NODE) && CLASSTYPE_NON_AGGREGATE (NODE)) + +/* Nonzero if there is a non-trivial X::op=(cv X&) for this class. */ +#define TYPE_HAS_COMPLEX_COPY_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_copy_assign) + +/* Nonzero if there is a non-trivial X::X(cv X&) for this class. */ +#define TYPE_HAS_COMPLEX_COPY_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_copy_ctor) + +/* Nonzero if there is a non-trivial X::op=(X&&) for this class. */ +#define TYPE_HAS_COMPLEX_MOVE_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_move_assign) + +/* Nonzero if there is a non-trivial X::X(X&&) for this class. */ +#define TYPE_HAS_COMPLEX_MOVE_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_move_ctor) + +/* Nonzero if there is a non-trivial default constructor for this class. */ +#define TYPE_HAS_COMPLEX_DFLT(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_dflt) + +/* Nonzero if TYPE has a trivial destructor. From [class.dtor]: + + A destructor is trivial if it is an implicitly declared + destructor and if: + + - all of the direct base classes of its class have trivial + destructors, + + - for all of the non-static data members of its class that are + of class type (or array thereof), each such class has a + trivial destructor. */ +#define TYPE_HAS_TRIVIAL_DESTRUCTOR(NODE) \ + (!TYPE_HAS_NONTRIVIAL_DESTRUCTOR (NODE)) + +/* Nonzero for _TYPE node means that this type does not have a trivial + destructor. Therefore, destroying an object of this type will + involve a call to a destructor. This can apply to objects of + ARRAY_TYPE is the type of the elements needs a destructor. */ +#define TYPE_HAS_NONTRIVIAL_DESTRUCTOR(NODE) \ + (TYPE_LANG_FLAG_4 (NODE)) + +/* Nonzero for class type means that the default constructor is trivial. */ +#define TYPE_HAS_TRIVIAL_DFLT(NODE) \ + (TYPE_HAS_DEFAULT_CONSTRUCTOR (NODE) && ! TYPE_HAS_COMPLEX_DFLT (NODE)) + +/* Nonzero for class type means that copy initialization of this type can use + a bitwise copy. */ +#define TYPE_HAS_TRIVIAL_COPY_CTOR(NODE) \ + (TYPE_HAS_COPY_CTOR (NODE) && ! TYPE_HAS_COMPLEX_COPY_CTOR (NODE)) + +/* Nonzero for class type means that assignment of this type can use + a bitwise copy. */ +#define TYPE_HAS_TRIVIAL_COPY_ASSIGN(NODE) \ + (TYPE_HAS_COPY_ASSIGN (NODE) && ! TYPE_HAS_COMPLEX_COPY_ASSIGN (NODE)) + +/* Returns true if NODE is a pointer-to-data-member. */ +#define TYPE_PTRMEM_P(NODE) \ + (TREE_CODE (NODE) == OFFSET_TYPE) +/* Returns true if NODE is a pointer. */ +#define TYPE_PTR_P(NODE) \ + (TREE_CODE (NODE) == POINTER_TYPE) + +/* Returns true if NODE is an object type: + + [basic.types] + + An object type is a (possibly cv-qualified) type that is not a + function type, not a reference type, and not a void type. + + Keep these checks in ascending order, for speed. */ +#define TYPE_OBJ_P(NODE) \ + (TREE_CODE (NODE) != REFERENCE_TYPE \ + && TREE_CODE (NODE) != VOID_TYPE \ + && TREE_CODE (NODE) != FUNCTION_TYPE \ + && TREE_CODE (NODE) != METHOD_TYPE) + +/* Returns true if NODE is a pointer to an object. Keep these checks + in ascending tree code order. */ +#define TYPE_PTROB_P(NODE) \ + (TYPE_PTR_P (NODE) && TYPE_OBJ_P (TREE_TYPE (NODE))) + +/* Returns true if NODE is a reference to an object. Keep these checks + in ascending tree code order. */ +#define TYPE_REF_OBJ_P(NODE) \ + (TREE_CODE (NODE) == REFERENCE_TYPE && TYPE_OBJ_P (TREE_TYPE (NODE))) + +/* Returns true if NODE is a pointer to an object, or a pointer to + void. Keep these checks in ascending tree code order. */ +#define TYPE_PTROBV_P(NODE) \ + (TYPE_PTR_P (NODE) \ + && !(TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE \ + || TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE)) + +/* Returns true if NODE is a pointer to function. */ +#define TYPE_PTRFN_P(NODE) \ + (TREE_CODE (NODE) == POINTER_TYPE \ + && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE) + +/* Returns true if NODE is a reference to function. */ +#define TYPE_REFFN_P(NODE) \ + (TREE_CODE (NODE) == REFERENCE_TYPE \ + && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE) + +/* Nonzero for _TYPE node means that this type is a pointer to member + function type. */ +#define TYPE_PTRMEMFUNC_P(NODE) \ + (TREE_CODE (NODE) == RECORD_TYPE \ + && TYPE_LANG_SPECIFIC (NODE) \ + && TYPE_PTRMEMFUNC_FLAG (NODE)) + +#define TYPE_PTRMEMFUNC_FLAG(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->ptrmemfunc_flag) + +/* Returns true if NODE is a pointer-to-member. */ +#define TYPE_PTR_TO_MEMBER_P(NODE) \ + (TYPE_PTRMEM_P (NODE) || TYPE_PTRMEMFUNC_P (NODE)) + +/* Indicates when overload resolution may resolve to a pointer to + member function. [expr.unary.op]/3 */ +#define PTRMEM_OK_P(NODE) \ + TREE_LANG_FLAG_0 (TREE_CHECK2 ((NODE), ADDR_EXPR, OFFSET_REF)) + +/* Get the POINTER_TYPE to the METHOD_TYPE associated with this + pointer to member function. TYPE_PTRMEMFUNC_P _must_ be true, + before using this macro. */ +#define TYPE_PTRMEMFUNC_FN_TYPE(NODE) \ + (TREE_TYPE (TYPE_FIELDS (NODE))) + +/* Returns `A' for a type like `int (A::*)(double)' */ +#define TYPE_PTRMEMFUNC_OBJECT_TYPE(NODE) \ + TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE))) + +/* These are use to manipulate the canonical RECORD_TYPE from the + hashed POINTER_TYPE, and can only be used on the POINTER_TYPE. */ +#define TYPE_GET_PTRMEMFUNC_TYPE(NODE) \ + (TYPE_LANG_SPECIFIC (NODE) ? LANG_TYPE_PTRMEM_CHECK (NODE)->record : NULL) +#define TYPE_SET_PTRMEMFUNC_TYPE(NODE, VALUE) \ + do { \ + if (TYPE_LANG_SPECIFIC (NODE) == NULL) \ + { \ + TYPE_LANG_SPECIFIC (NODE) = ggc_alloc_cleared_lang_type \ + (sizeof (struct lang_type_ptrmem)); \ + TYPE_LANG_SPECIFIC (NODE)->u.ptrmem.h.is_lang_type_class = 0; \ + } \ + TYPE_LANG_SPECIFIC (NODE)->u.ptrmem.record = (VALUE); \ + } while (0) + +/* For a pointer-to-member type of the form `T X::*', this is `X'. + For a type like `void (X::*)() const', this type is `X', not `const + X'. To get at the `const X' you have to look at the + TYPE_PTRMEM_POINTED_TO_TYPE; there, the first parameter will have + type `const X*'. */ +#define TYPE_PTRMEM_CLASS_TYPE(NODE) \ + (TYPE_PTRMEM_P (NODE) \ + ? TYPE_OFFSET_BASETYPE (NODE) \ + : TYPE_PTRMEMFUNC_OBJECT_TYPE (NODE)) + +/* For a pointer-to-member type of the form `T X::*', this is `T'. */ +#define TYPE_PTRMEM_POINTED_TO_TYPE(NODE) \ + (TYPE_PTRMEM_P (NODE) \ + ? TREE_TYPE (NODE) \ + : TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE))) + +/* For a pointer-to-member constant `X::Y' this is the RECORD_TYPE for + `X'. */ +#define PTRMEM_CST_CLASS(NODE) \ + TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (PTRMEM_CST_CHECK (NODE))) + +/* For a pointer-to-member constant `X::Y' this is the _DECL for + `Y'. */ +#define PTRMEM_CST_MEMBER(NODE) (((ptrmem_cst_t)PTRMEM_CST_CHECK (NODE))->member) + +/* The expression in question for a TYPEOF_TYPE. */ +#define TYPEOF_TYPE_EXPR(NODE) (TYPEOF_TYPE_CHECK (NODE))->type.values + +/* The expression in question for a DECLTYPE_TYPE. */ +#define DECLTYPE_TYPE_EXPR(NODE) (DECLTYPE_TYPE_CHECK (NODE))->type.values + +/* Whether the DECLTYPE_TYPE_EXPR of NODE was originally parsed as an + id-expression or a member-access expression. When false, it was + parsed as a full expression. */ +#define DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P(NODE) \ + (DECLTYPE_TYPE_CHECK (NODE))->type.string_flag + +/* These flags indicate that we want different semantics from normal + decltype: lambda capture just drops references, lambda return also does + type decay. */ +#define DECLTYPE_FOR_LAMBDA_CAPTURE(NODE) \ + TREE_LANG_FLAG_0 (DECLTYPE_TYPE_CHECK (NODE)) +#define DECLTYPE_FOR_LAMBDA_RETURN(NODE) \ + TREE_LANG_FLAG_1 (DECLTYPE_TYPE_CHECK (NODE)) + +/* Nonzero for VAR_DECL and FUNCTION_DECL node means that `extern' was + specified in its declaration. This can also be set for an + erroneously declared PARM_DECL. */ +#define DECL_THIS_EXTERN(NODE) \ + DECL_LANG_FLAG_2 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE)) + +/* Nonzero for VAR_DECL and FUNCTION_DECL node means that `static' was + specified in its declaration. This can also be set for an + erroneously declared PARM_DECL. */ +#define DECL_THIS_STATIC(NODE) \ + DECL_LANG_FLAG_6 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE)) + +/* Nonzero for FIELD_DECL node means that this field is a base class + of the parent object, as opposed to a member field. */ +#define DECL_FIELD_IS_BASE(NODE) \ + DECL_LANG_FLAG_6 (FIELD_DECL_CHECK (NODE)) + +/* Nonzero for FIELD_DECL node means that this field is a simple (no + explicit initializer) lambda capture field, making it invisible to + name lookup in unevaluated contexts. */ +#define DECL_NORMAL_CAPTURE_P(NODE) \ + DECL_LANG_FLAG_7 (FIELD_DECL_CHECK (NODE)) + +/* Nonzero if TYPE is an anonymous union or struct type. We have to use a + flag for this because "A union for which objects or pointers are + declared is not an anonymous union" [class.union]. */ +#define ANON_AGGR_TYPE_P(NODE) \ + (CLASS_TYPE_P (NODE) && LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr) +#define SET_ANON_AGGR_TYPE_P(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr = 1) + +/* Nonzero if TYPE is an anonymous union type. */ +#define ANON_UNION_TYPE_P(NODE) \ + (TREE_CODE (NODE) == UNION_TYPE && ANON_AGGR_TYPE_P (NODE)) + +/* Define fields and accessors for nodes representing declared names. */ + +#define TYPE_WAS_ANONYMOUS(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->was_anonymous) + +/* C++: all of these are overloaded! These apply only to TYPE_DECLs. */ + +/* The format of each node in the DECL_FRIENDLIST is as follows: + + The TREE_PURPOSE will be the name of a function, i.e., an + IDENTIFIER_NODE. The TREE_VALUE will be itself a TREE_LIST, whose + TREE_VALUEs are friends with the given name. */ +#define DECL_FRIENDLIST(NODE) (DECL_INITIAL (NODE)) +#define FRIEND_NAME(LIST) (TREE_PURPOSE (LIST)) +#define FRIEND_DECLS(LIST) (TREE_VALUE (LIST)) + +/* The DECL_ACCESS, if non-NULL, is a TREE_LIST. The TREE_PURPOSE of + each node is a type; the TREE_VALUE is the access granted for this + DECL in that type. The DECL_ACCESS is set by access declarations. + For example, if a member that would normally be public in a + derived class is made protected, then the derived class and the + protected_access_node will appear in the DECL_ACCESS for the node. */ +#define DECL_ACCESS(NODE) (LANG_DECL_U2_CHECK (NODE, 0)->access) + +/* Nonzero if the FUNCTION_DECL is a global constructor. */ +#define DECL_GLOBAL_CTOR_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->global_ctor_p) + +/* Nonzero if the FUNCTION_DECL is a global destructor. */ +#define DECL_GLOBAL_DTOR_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->global_dtor_p) + +/* Accessor macros for C++ template decl nodes. */ + +/* The DECL_TEMPLATE_PARMS are a list. The TREE_PURPOSE of each node + is a INT_CST whose TREE_INT_CST_LOW indicates the level of the + template parameters, with 1 being the outermost set of template + parameters. The TREE_VALUE is a vector, whose elements are the + template parameters at each level. Each element in the vector is a + TREE_LIST, whose TREE_VALUE is a PARM_DECL (if the parameter is a + non-type parameter), or a TYPE_DECL (if the parameter is a type + parameter). The TREE_PURPOSE is the default value, if any. The + TEMPLATE_PARM_INDEX for the parameter is available as the + DECL_INITIAL (for a PARM_DECL) or as the TREE_TYPE (for a + TYPE_DECL). */ +#define DECL_TEMPLATE_PARMS(NODE) DECL_NON_COMMON_CHECK (NODE)->decl_non_common.arguments +#define DECL_INNERMOST_TEMPLATE_PARMS(NODE) \ + INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (NODE)) +#define DECL_NTPARMS(NODE) \ + TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (NODE)) +/* For function, method, class-data templates. */ +#define DECL_TEMPLATE_RESULT(NODE) DECL_RESULT_FLD (NODE) +/* For a function template at namespace scope, DECL_TEMPLATE_INSTANTIATIONS + lists all instantiations and specializations of the function so that + tsubst_friend_function can reassign them to another template if we find + that the namespace-scope template is really a partial instantiation of a + friend template. + + For a class template the DECL_TEMPLATE_INSTANTIATIONS lists holds + all instantiations and specializations of the class type, including + partial instantiations and partial specializations, so that if we + explicitly specialize a partial instantiation we can walk the list + in maybe_process_partial_specialization and reassign them or complain + as appropriate. + + In both cases, the TREE_PURPOSE of each node contains the arguments + used; the TREE_VALUE contains the generated variable. The template + arguments are always complete. For example, given: + + template struct S1 { + template struct S2 {}; + template struct S2 {}; + }; + + the record for the partial specialization will contain, as its + argument list, { {T}, {U*} }, and will be on the + DECL_TEMPLATE_INSTANTIATIONS list for `template template + struct S1::S2'. + + This list is not used for other templates. */ +#define DECL_TEMPLATE_INSTANTIATIONS(NODE) DECL_VINDEX (NODE) +/* For a class template, this list contains the partial + specializations of this template. (Full specializations are not + recorded on this list.) The TREE_PURPOSE holds the arguments used + in the partial specialization (e.g., for `template struct + S' this will be `T*'.) The arguments will also include + any outer template arguments. The TREE_VALUE holds the innermost + template parameters for the specialization (e.g., `T' in the + example above.) The TREE_TYPE is the _TYPE node for the partial + specialization. + + This list is not used for other templates. */ +#define DECL_TEMPLATE_SPECIALIZATIONS(NODE) DECL_SIZE (NODE) + +/* Nonzero for a DECL which is actually a template parameter. Keep + these checks in ascending tree code order. */ +#define DECL_TEMPLATE_PARM_P(NODE) \ + (DECL_LANG_FLAG_0 (NODE) \ + && (TREE_CODE (NODE) == CONST_DECL \ + || TREE_CODE (NODE) == PARM_DECL \ + || TREE_CODE (NODE) == TYPE_DECL \ + || TREE_CODE (NODE) == TEMPLATE_DECL)) + +/* Mark NODE as a template parameter. */ +#define SET_DECL_TEMPLATE_PARM_P(NODE) \ + (DECL_LANG_FLAG_0 (NODE) = 1) + +/* Nonzero if NODE is a template template parameter. */ +#define DECL_TEMPLATE_TEMPLATE_PARM_P(NODE) \ + (TREE_CODE (NODE) == TEMPLATE_DECL && DECL_TEMPLATE_PARM_P (NODE)) + +/* Nonzero if NODE is a TEMPLATE_DECL representing an + UNBOUND_CLASS_TEMPLATE tree node. */ +#define DECL_UNBOUND_CLASS_TEMPLATE_P(NODE) \ + (TREE_CODE (NODE) == TEMPLATE_DECL && !DECL_TEMPLATE_RESULT (NODE)) + +#define DECL_FUNCTION_TEMPLATE_P(NODE) \ + (TREE_CODE (NODE) == TEMPLATE_DECL \ + && !DECL_UNBOUND_CLASS_TEMPLATE_P (NODE) \ + && TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == FUNCTION_DECL) + +/* Nonzero for a DECL that represents a template class. */ +#define DECL_CLASS_TEMPLATE_P(NODE) \ + (TREE_CODE (NODE) == TEMPLATE_DECL \ + && DECL_TEMPLATE_RESULT (NODE) != NULL_TREE \ + && DECL_IMPLICIT_TYPEDEF_P (DECL_TEMPLATE_RESULT (NODE))) + +/* Nonzero if NODE which declares a type. */ +#define DECL_DECLARES_TYPE_P(NODE) \ + (TREE_CODE (NODE) == TYPE_DECL || DECL_CLASS_TEMPLATE_P (NODE)) + +/* Nonzero if NODE declares a function. */ +#define DECL_DECLARES_FUNCTION_P(NODE) \ + (TREE_CODE (NODE) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (NODE)) + +/* Nonzero if NODE is the typedef implicitly generated for a type when + the type is declared. In C++, `struct S {};' is roughly + equivalent to `struct S {}; typedef struct S S;' in C. + DECL_IMPLICIT_TYPEDEF_P will hold for the typedef indicated in this + example. In C++, there is a second implicit typedef for each + class, in the scope of `S' itself, so that you can say `S::S'. + DECL_SELF_REFERENCE_P will hold for that second typedef. */ +#define DECL_IMPLICIT_TYPEDEF_P(NODE) \ + (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_2 (NODE)) +#define SET_DECL_IMPLICIT_TYPEDEF_P(NODE) \ + (DECL_LANG_FLAG_2 (NODE) = 1) +#define DECL_SELF_REFERENCE_P(NODE) \ + (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_4 (NODE)) +#define SET_DECL_SELF_REFERENCE_P(NODE) \ + (DECL_LANG_FLAG_4 (NODE) = 1) + +/* A `primary' template is one that has its own template header. A + member function of a class template is a template, but not primary. + A member template is primary. Friend templates are primary, too. */ + +/* Returns the primary template corresponding to these parameters. */ +#define DECL_PRIMARY_TEMPLATE(NODE) \ + (TREE_TYPE (DECL_INNERMOST_TEMPLATE_PARMS (NODE))) + +/* Returns nonzero if NODE is a primary template. */ +#define PRIMARY_TEMPLATE_P(NODE) (DECL_PRIMARY_TEMPLATE (NODE) == (NODE)) + +/* Nonzero iff NODE is a specialization of a template. The value + indicates the type of specializations: + + 1=implicit instantiation + + 2=partial or explicit specialization, e.g.: + + template <> int min (int, int), + + 3=explicit instantiation, e.g.: + + template int min (int, int); + + Note that NODE will be marked as a specialization even if the + template it is instantiating is not a primary template. For + example, given: + + template struct O { + void f(); + struct I {}; + }; + + both O::f and O::I will be marked as instantiations. + + If DECL_USE_TEMPLATE is nonzero, then DECL_TEMPLATE_INFO will also + be non-NULL. */ +#define DECL_USE_TEMPLATE(NODE) (DECL_LANG_SPECIFIC (NODE)->u.base.use_template) + +/* Like DECL_USE_TEMPLATE, but for class types. */ +#define CLASSTYPE_USE_TEMPLATE(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->use_template) + +/* True if NODE is a specialization of a primary template. */ +#define CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P(NODE) \ + (CLASS_TYPE_P (NODE) \ + && CLASSTYPE_USE_TEMPLATE (NODE) \ + && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))) + +#define DECL_TEMPLATE_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) & 1) +#define CLASSTYPE_TEMPLATE_INSTANTIATION(NODE) \ + (CLASSTYPE_USE_TEMPLATE (NODE) & 1) + +#define DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) == 2) +#define SET_DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) = 2) + +/* Returns true for an explicit or partial specialization of a class + template. */ +#define CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \ + (CLASSTYPE_USE_TEMPLATE (NODE) == 2) +#define SET_CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \ + (CLASSTYPE_USE_TEMPLATE (NODE) = 2) + +#define DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 1) +#define SET_DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 1) +#define CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \ + (CLASSTYPE_USE_TEMPLATE (NODE) == 1) +#define SET_CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \ + (CLASSTYPE_USE_TEMPLATE (NODE) = 1) + +#define DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 3) +#define SET_DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 3) +#define CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \ + (CLASSTYPE_USE_TEMPLATE (NODE) == 3) +#define SET_CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \ + (CLASSTYPE_USE_TEMPLATE (NODE) = 3) + +/* Nonzero if DECL is a friend function which is an instantiation + from the point of view of the compiler, but not from the point of + view of the language. For example given: + template struct S { friend void f(T) {}; }; + the declaration of `void f(int)' generated when S is + instantiated will not be a DECL_TEMPLATE_INSTANTIATION, but will be + a DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION. */ +#define DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION(DECL) \ + (DECL_TEMPLATE_INFO (DECL) && !DECL_USE_TEMPLATE (DECL)) + +/* Nonzero iff we are currently processing a declaration for an + entity with its own template parameter list, and which is not a + full specialization. */ +#define PROCESSING_REAL_TEMPLATE_DECL_P() \ + (processing_template_decl > template_class_depth (current_scope ())) + +/* Nonzero if this VAR_DECL or FUNCTION_DECL has already been + instantiated, i.e. its definition has been generated from the + pattern given in the template. */ +#define DECL_TEMPLATE_INSTANTIATED(NODE) \ + DECL_LANG_FLAG_1 (VAR_OR_FUNCTION_DECL_CHECK (NODE)) + +/* We know what we're doing with this decl now. */ +#define DECL_INTERFACE_KNOWN(NODE) DECL_LANG_FLAG_5 (NODE) + +/* DECL_EXTERNAL must be set on a decl until the decl is actually emitted, + so that assemble_external will work properly. So we have this flag to + tell us whether the decl is really not external. + + This flag does not indicate whether or not the decl is defined in the + current translation unit; it indicates whether or not we should emit the + decl at the end of compilation if it is defined and needed. */ +#define DECL_NOT_REALLY_EXTERN(NODE) \ + (DECL_LANG_SPECIFIC (NODE)->u.base.not_really_extern) + +#define DECL_REALLY_EXTERN(NODE) \ + (DECL_EXTERNAL (NODE) && ! DECL_NOT_REALLY_EXTERN (NODE)) + +/* A thunk is a stub function. + + A thunk is an alternate entry point for an ordinary FUNCTION_DECL. + The address of the ordinary FUNCTION_DECL is given by the + DECL_INITIAL, which is always an ADDR_EXPR whose operand is a + FUNCTION_DECL. The job of the thunk is to either adjust the this + pointer before transferring control to the FUNCTION_DECL, or call + FUNCTION_DECL and then adjust the result value. Note, the result + pointer adjusting thunk must perform a call to the thunked + function, (or be implemented via passing some invisible parameter + to the thunked function, which is modified to perform the + adjustment just before returning). + + A thunk may perform either, or both, of the following operations: + + o Adjust the this or result pointer by a constant offset. + o Adjust the this or result pointer by looking up a vcall or vbase offset + in the vtable. + + A this pointer adjusting thunk converts from a base to a derived + class, and hence adds the offsets. A result pointer adjusting thunk + converts from a derived class to a base, and hence subtracts the + offsets. If both operations are performed, then the constant + adjustment is performed first for this pointer adjustment and last + for the result pointer adjustment. + + The constant adjustment is given by THUNK_FIXED_OFFSET. If the + vcall or vbase offset is required, THUNK_VIRTUAL_OFFSET is + used. For this pointer adjusting thunks, it is the vcall offset + into the vtable. For result pointer adjusting thunks it is the + binfo of the virtual base to convert to. Use that binfo's vbase + offset. + + It is possible to have equivalent covariant thunks. These are + distinct virtual covariant thunks whose vbase offsets happen to + have the same value. THUNK_ALIAS is used to pick one as the + canonical thunk, which will get all the this pointer adjusting + thunks attached to it. */ + +/* An integer indicating how many bytes should be subtracted from the + this or result pointer when this function is called. */ +#define THUNK_FIXED_OFFSET(DECL) \ + (DECL_LANG_SPECIFIC (THUNK_FUNCTION_CHECK (DECL))->u.fn.u5.fixed_offset) + +/* A tree indicating how to perform the virtual adjustment. For a this + adjusting thunk it is the number of bytes to be added to the vtable + to find the vcall offset. For a result adjusting thunk, it is the + binfo of the relevant virtual base. If NULL, then there is no + virtual adjust. (The vptr is always located at offset zero from + the this or result pointer.) (If the covariant type is within the + class hierarchy being laid out, the vbase index is not yet known + at the point we need to create the thunks, hence the need to use + binfos.) */ + +#define THUNK_VIRTUAL_OFFSET(DECL) \ + (LANG_DECL_U2_CHECK (FUNCTION_DECL_CHECK (DECL), 0)->access) + +/* A thunk which is equivalent to another thunk. */ +#define THUNK_ALIAS(DECL) \ + (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->u.min.template_info) + +/* For thunk NODE, this is the FUNCTION_DECL thunked to. It is + possible for the target to be a thunk too. */ +#define THUNK_TARGET(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->befriending_classes) + +/* True for a SCOPE_REF iff the "template" keyword was used to + indicate that the qualified name denotes a template. */ +#define QUALIFIED_NAME_IS_TEMPLATE(NODE) \ + (TREE_LANG_FLAG_0 (SCOPE_REF_CHECK (NODE))) + +/* True for an OMP_ATOMIC that has dependent parameters. These are stored + as an expr in operand 1, and integer_zero_node in operand 0. */ +#define OMP_ATOMIC_DEPENDENT_P(NODE) \ + (TREE_CODE (TREE_OPERAND (OMP_ATOMIC_CHECK (NODE), 0)) == INTEGER_CST) + +/* Used while gimplifying continue statements bound to OMP_FOR nodes. */ +#define OMP_FOR_GIMPLIFYING_P(NODE) \ + (TREE_LANG_FLAG_0 (OMP_FOR_CHECK (NODE))) + +/* A language-specific token attached to the OpenMP data clauses to + hold code (or code fragments) related to ctors, dtors, and op=. + See semantics.c for details. */ +#define CP_OMP_CLAUSE_INFO(NODE) \ + TREE_TYPE (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_PRIVATE, \ + OMP_CLAUSE_COPYPRIVATE)) + +/* These macros provide convenient access to the various _STMT nodes + created when parsing template declarations. */ +#define TRY_STMTS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 0) +#define TRY_HANDLERS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 1) + +#define EH_SPEC_STMTS(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 0) +#define EH_SPEC_RAISES(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 1) + +#define USING_STMT_NAMESPACE(NODE) TREE_OPERAND (USING_STMT_CHECK (NODE), 0) + +/* Nonzero if this try block is a function try block. */ +#define FN_TRY_BLOCK_P(NODE) TREE_LANG_FLAG_3 (TRY_BLOCK_CHECK (NODE)) +#define HANDLER_PARMS(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 0) +#define HANDLER_BODY(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 1) +#define HANDLER_TYPE(NODE) TREE_TYPE (HANDLER_CHECK (NODE)) + +/* CLEANUP_STMT accessors. The statement(s) covered, the cleanup to run + and the VAR_DECL for which this cleanup exists. */ +#define CLEANUP_BODY(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 0) +#define CLEANUP_EXPR(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 1) +#define CLEANUP_DECL(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 2) + +/* IF_STMT accessors. These give access to the condition of the if + statement, the then block of the if statement, and the else block + of the if statement if it exists. */ +#define IF_COND(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 0) +#define THEN_CLAUSE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 1) +#define ELSE_CLAUSE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 2) + +/* WHILE_STMT accessors. These give access to the condition of the + while statement and the body of the while statement, respectively. */ +#define WHILE_COND(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 0) +#define WHILE_BODY(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 1) + +/* DO_STMT accessors. These give access to the condition of the do + statement and the body of the do statement, respectively. */ +#define DO_COND(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 0) +#define DO_BODY(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 1) + +/* FOR_STMT accessors. These give access to the init statement, + condition, update expression, and body of the for statement, + respectively. */ +#define FOR_INIT_STMT(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 0) +#define FOR_COND(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 1) +#define FOR_EXPR(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 2) +#define FOR_BODY(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 3) + +/* RANGE_FOR_STMT accessors. These give access to the declarator, + expression and body of the statement, respectively. */ +#define RANGE_FOR_DECL(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 0) +#define RANGE_FOR_EXPR(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 1) +#define RANGE_FOR_BODY(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 2) + +#define SWITCH_STMT_COND(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 0) +#define SWITCH_STMT_BODY(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 1) +#define SWITCH_STMT_TYPE(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 2) + +/* STMT_EXPR accessor. */ +#define STMT_EXPR_STMT(NODE) TREE_OPERAND (STMT_EXPR_CHECK (NODE), 0) + +/* EXPR_STMT accessor. This gives the expression associated with an + expression statement. */ +#define EXPR_STMT_EXPR(NODE) TREE_OPERAND (EXPR_STMT_CHECK (NODE), 0) + +/* True if this TARGET_EXPR was created by build_cplus_new, and so we can + discard it if it isn't useful. */ +#define TARGET_EXPR_IMPLICIT_P(NODE) \ + TREE_LANG_FLAG_0 (TARGET_EXPR_CHECK (NODE)) + +/* True if this TARGET_EXPR is the result of list-initialization of a + temporary. */ +#define TARGET_EXPR_LIST_INIT_P(NODE) \ + TREE_LANG_FLAG_1 (TARGET_EXPR_CHECK (NODE)) + +/* True if this TARGET_EXPR expresses direct-initialization of an object + to be named later. */ +#define TARGET_EXPR_DIRECT_INIT_P(NODE) \ + TREE_LANG_FLAG_2 (TARGET_EXPR_CHECK (NODE)) + +/* True if EXPR expresses direct-initialization of a TYPE. */ +#define DIRECT_INIT_EXPR_P(TYPE,EXPR) \ + (TREE_CODE (EXPR) == TARGET_EXPR && TREE_LANG_FLAG_2 (EXPR) \ + && same_type_ignoring_top_level_qualifiers_p (TYPE, TREE_TYPE (EXPR))) + +/* An enumeration of the kind of tags that C++ accepts. */ +enum tag_types { + none_type = 0, /* Not a tag type. */ + record_type, /* "struct" types. */ + class_type, /* "class" types. */ + union_type, /* "union" types. */ + enum_type, /* "enum" types. */ + typename_type /* "typename" types. */ +}; + +/* The various kinds of lvalues we distinguish. */ +enum cp_lvalue_kind_flags { + clk_none = 0, /* Things that are not an lvalue. */ + clk_ordinary = 1, /* An ordinary lvalue. */ + clk_rvalueref = 2,/* An rvalue formed using an rvalue reference */ + clk_class = 4, /* An rvalue of class-type. */ + clk_bitfield = 8, /* An lvalue for a bit-field. */ + clk_packed = 16 /* An lvalue for a packed field. */ +}; + +/* This type is used for parameters and variables which hold + combinations of the flags in enum cp_lvalue_kind_flags. */ +typedef int cp_lvalue_kind; + +/* Various kinds of template specialization, instantiation, etc. */ +typedef enum tmpl_spec_kind { + tsk_none, /* Not a template at all. */ + tsk_invalid_member_spec, /* An explicit member template + specialization, but the enclosing + classes have not all been explicitly + specialized. */ + tsk_invalid_expl_inst, /* An explicit instantiation containing + template parameter lists. */ + tsk_excessive_parms, /* A template declaration with too many + template parameter lists. */ + tsk_insufficient_parms, /* A template declaration with too few + parameter lists. */ + tsk_template, /* A template declaration. */ + tsk_expl_spec, /* An explicit specialization. */ + tsk_expl_inst /* An explicit instantiation. */ +} tmpl_spec_kind; + +/* The various kinds of access. BINFO_ACCESS depends on these being + two bit quantities. The numerical values are important; they are + used to initialize RTTI data structures, so changing them changes + the ABI. */ +typedef enum access_kind { + ak_none = 0, /* Inaccessible. */ + ak_public = 1, /* Accessible, as a `public' thing. */ + ak_protected = 2, /* Accessible, as a `protected' thing. */ + ak_private = 3 /* Accessible, as a `private' thing. */ +} access_kind; + +/* The various kinds of special functions. If you add to this list, + you should update special_function_p as well. */ +typedef enum special_function_kind { + sfk_none = 0, /* Not a special function. This enumeral + must have value zero; see + special_function_p. */ + sfk_constructor, /* A constructor. */ + sfk_copy_constructor, /* A copy constructor. */ + sfk_move_constructor, /* A move constructor. */ + sfk_copy_assignment, /* A copy assignment operator. */ + sfk_move_assignment, /* A move assignment operator. */ + sfk_destructor, /* A destructor. */ + sfk_complete_destructor, /* A destructor for complete objects. */ + sfk_base_destructor, /* A destructor for base subobjects. */ + sfk_deleting_destructor, /* A destructor for complete objects that + deletes the object after it has been + destroyed. */ + sfk_conversion /* A conversion operator. */ +} special_function_kind; + +/* The various kinds of linkage. From [basic.link], + + A name is said to have linkage when it might denote the same + object, reference, function, type, template, namespace or value + as a name introduced in another scope: + + -- When a name has external linkage, the entity it denotes can + be referred to from scopes of other translation units or from + other scopes of the same translation unit. + + -- When a name has internal linkage, the entity it denotes can + be referred to by names from other scopes in the same + translation unit. + + -- When a name has no linkage, the entity it denotes cannot be + referred to by names from other scopes. */ + +typedef enum linkage_kind { + lk_none, /* No linkage. */ + lk_internal, /* Internal linkage. */ + lk_external /* External linkage. */ +} linkage_kind; + +typedef enum duration_kind { + dk_static, + dk_thread, + dk_auto, + dk_dynamic +} duration_kind; + +/* Bitmask flags to control type substitution. */ +enum tsubst_flags { + tf_none = 0, /* nothing special */ + tf_error = 1 << 0, /* give error messages */ + tf_warning = 1 << 1, /* give warnings too */ + tf_ignore_bad_quals = 1 << 2, /* ignore bad cvr qualifiers */ + tf_keep_type_decl = 1 << 3, /* retain typedef type decls + (make_typename_type use) */ + tf_ptrmem_ok = 1 << 4, /* pointers to member ok (internal + instantiate_type use) */ + tf_user = 1 << 5, /* found template must be a user template + (lookup_template_class use) */ + tf_conv = 1 << 6, /* We are determining what kind of + conversion might be permissible, + not actually performing the + conversion. */ + tf_no_access_control = 1 << 7, /* Do not perform access checks, even + when issuing other errors. */ + /* Convenient substitution flags combinations. */ + tf_warning_or_error = tf_warning | tf_error +}; + +/* This type is used for parameters and variables which hold + combinations of the flags in enum tsubst_flags. */ +typedef int tsubst_flags_t; + +/* The kind of checking we can do looking in a class hierarchy. */ +enum base_access_flags { + ba_any = 0, /* Do not check access, allow an ambiguous base, + prefer a non-virtual base */ + ba_unique = 1 << 0, /* Must be a unique base. */ + ba_check_bit = 1 << 1, /* Check access. */ + ba_check = ba_unique | ba_check_bit, + ba_ignore_scope = 1 << 2, /* Ignore access allowed by local scope. */ + ba_quiet = 1 << 3 /* Do not issue error messages. */ +}; + +/* This type is used for parameters and variables which hold + combinations of the flags in enum base_access_flags. */ +typedef int base_access; + +/* The various kinds of access check during parsing. */ +typedef enum deferring_kind { + dk_no_deferred = 0, /* Check access immediately */ + dk_deferred = 1, /* Deferred check */ + dk_no_check = 2 /* No access check */ +} deferring_kind; + +/* The kind of base we can find, looking in a class hierarchy. + Values <0 indicate we failed. */ +typedef enum base_kind { + bk_inaccessible = -3, /* The base is inaccessible */ + bk_ambig = -2, /* The base is ambiguous */ + bk_not_base = -1, /* It is not a base */ + bk_same_type = 0, /* It is the same type */ + bk_proper_base = 1, /* It is a proper base */ + bk_via_virtual = 2 /* It is a proper base, but via a virtual + path. This might not be the canonical + binfo. */ +} base_kind; + +/* Node for "pointer to (virtual) function". + This may be distinct from ptr_type_node so gdb can distinguish them. */ +#define vfunc_ptr_type_node vtable_entry_type + + +/* For building calls to `delete'. */ +extern GTY(()) tree integer_two_node; + +/* The number of function bodies which we are currently processing. + (Zero if we are at namespace scope, one inside the body of a + function, two inside the body of a function in a local class, etc.) */ +extern int function_depth; + +/* In parser.c. */ + +/* Nonzero if we are parsing an unevaluated operand: an operand to + sizeof, typeof, or alignof. This is a count since operands to + sizeof can be nested. */ + +extern int cp_unevaluated_operand; +extern tree cp_convert_range_for (tree, tree, tree); + +/* in pt.c */ + +/* These values are used for the `STRICT' parameter to type_unification and + fn_type_unification. Their meanings are described with the + documentation for fn_type_unification. */ + +typedef enum unification_kind_t { + DEDUCE_CALL, + DEDUCE_CONV, + DEDUCE_EXACT +} unification_kind_t; + +/* in class.c */ + +extern int current_class_depth; + +/* An array of all local classes present in this translation unit, in + declaration order. */ +extern GTY(()) VEC(tree,gc) *local_classes; + +/* Here's where we control how name mangling takes place. */ + +/* Cannot use '$' up front, because this confuses gdb + (names beginning with '$' are gdb-local identifiers). + + Note that all forms in which the '$' is significant are long enough + for direct indexing (meaning that if we know there is a '$' + at a particular location, we can index into the string at + any other location that provides distinguishing characters). */ + +/* Define NO_DOT_IN_LABEL in your favorite tm file if your assembler + doesn't allow '.' in symbol names. */ +#ifndef NO_DOT_IN_LABEL + +#define JOINER '.' + +#define AUTO_TEMP_NAME "_.tmp_" +#define VFIELD_BASE ".vf" +#define VFIELD_NAME "_vptr." +#define VFIELD_NAME_FORMAT "_vptr.%s" + +#define ANON_AGGRNAME_FORMAT "._%d" + +#else /* NO_DOT_IN_LABEL */ + +#ifndef NO_DOLLAR_IN_LABEL + +#define JOINER '$' + +#define AUTO_TEMP_NAME "_$tmp_" +#define VFIELD_BASE "$vf" +#define VFIELD_NAME "_vptr$" +#define VFIELD_NAME_FORMAT "_vptr$%s" +#define ANON_AGGRNAME_FORMAT "$_%d" + +#else /* NO_DOLLAR_IN_LABEL */ + +#define IN_CHARGE_NAME "__in_chrg" +#define AUTO_TEMP_NAME "__tmp_" +#define TEMP_NAME_P(ID_NODE) \ + (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, \ + sizeof (AUTO_TEMP_NAME) - 1)) +#define VTABLE_NAME "__vt_" +#define VTABLE_NAME_P(ID_NODE) \ + (!strncmp (IDENTIFIER_POINTER (ID_NODE), VTABLE_NAME, \ + sizeof (VTABLE_NAME) - 1)) +#define VFIELD_BASE "__vfb" +#define VFIELD_NAME "__vptr_" +#define VFIELD_NAME_P(ID_NODE) \ + (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, \ + sizeof (VFIELD_NAME) - 1)) +#define VFIELD_NAME_FORMAT "__vptr_%s" + +#define ANON_AGGRNAME_PREFIX "__anon_" +#define ANON_AGGRNAME_P(ID_NODE) \ + (!strncmp (IDENTIFIER_POINTER (ID_NODE), ANON_AGGRNAME_PREFIX, \ + sizeof (ANON_AGGRNAME_PREFIX) - 1)) +#define ANON_AGGRNAME_FORMAT "__anon_%d" + +#endif /* NO_DOLLAR_IN_LABEL */ +#endif /* NO_DOT_IN_LABEL */ + +#define THIS_NAME "this" + +#define IN_CHARGE_NAME "__in_chrg" + +#define VTBL_PTR_TYPE "__vtbl_ptr_type" +#define VTABLE_DELTA_NAME "__delta" +#define VTABLE_PFN_NAME "__pfn" + +#define LAMBDANAME_PREFIX "__lambda" +#define LAMBDANAME_FORMAT LAMBDANAME_PREFIX "%d" +#define LAMBDANAME_P(ID_NODE) \ + (!strncmp (IDENTIFIER_POINTER (ID_NODE), \ + LAMBDANAME_PREFIX, \ + sizeof (LAMBDANAME_PREFIX) - 1)) + +#if !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL) + +#define VTABLE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == 'v' \ + && IDENTIFIER_POINTER (ID_NODE)[2] == 't' \ + && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER) + +#define TEMP_NAME_P(ID_NODE) \ + (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, sizeof (AUTO_TEMP_NAME)-1)) +#define VFIELD_NAME_P(ID_NODE) \ + (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, sizeof(VFIELD_NAME)-1)) + +/* For anonymous aggregate types, we need some sort of name to + hold on to. In practice, this should not appear, but it should + not be harmful if it does. */ +#define ANON_AGGRNAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER \ + && IDENTIFIER_POINTER (ID_NODE)[1] == '_') +#endif /* !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL) */ + + +/* Nonzero if we're done parsing and into end-of-file activities. */ + +extern int at_eof; + +/* A list of namespace-scope objects which have constructors or + destructors which reside in the global scope. The decl is stored + in the TREE_VALUE slot and the initializer is stored in the + TREE_PURPOSE slot. */ +extern GTY(()) tree static_aggregates; + +enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, TYPENAME_FLAG }; + +/* These are uses as bits in flags passed to various functions to + control their behavior. Despite the LOOKUP_ prefix, many of these + do not control name lookup. ??? Functions using these flags should + probably be modified to accept explicit boolean flags for the + behaviors relevant to them. */ +/* Check for access violations. */ +#define LOOKUP_PROTECT (1 << 0) +/* Complain if no suitable member function matching the arguments is + found. */ +#define LOOKUP_COMPLAIN (1 << 1) +#define LOOKUP_NORMAL (LOOKUP_PROTECT | LOOKUP_COMPLAIN) +/* Even if the function found by lookup is a virtual function, it + should be called directly. */ +#define LOOKUP_NONVIRTUAL (1 << 2) +/* Non-converting (i.e., "explicit") constructors are not tried. This flag + indicates that we are not performing direct-initialization. */ +#define LOOKUP_ONLYCONVERTING (1 << 3) +#define LOOKUP_IMPLICIT (LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING) +/* If a temporary is created, it should be created so that it lives + as long as the current variable bindings; otherwise it only lives + until the end of the complete-expression. It also forces + direct-initialization in cases where other parts of the compiler + have already generated a temporary, such as reference + initialization and the catch parameter. */ +#define DIRECT_BIND (1 << 4) +/* We're performing a user-defined conversion, so more user-defined + conversions are not permitted (only built-in conversions). */ +#define LOOKUP_NO_CONVERSION (1 << 5) +/* The user has explicitly called a destructor. (Therefore, we do + not need to check that the object is non-NULL before calling the + destructor.) */ +#define LOOKUP_DESTRUCTOR (1 << 6) +/* Do not permit references to bind to temporaries. */ +#define LOOKUP_NO_TEMP_BIND (1 << 7) +/* Do not accept objects, and possibly namespaces. */ +#define LOOKUP_PREFER_TYPES (1 << 8) +/* Do not accept objects, and possibly types. */ +#define LOOKUP_PREFER_NAMESPACES (1 << 9) +/* Accept types or namespaces. */ +#define LOOKUP_PREFER_BOTH (LOOKUP_PREFER_TYPES | LOOKUP_PREFER_NAMESPACES) +/* Return friend declarations and un-declared builtin functions. + (Normally, these entities are registered in the symbol table, but + not found by lookup.) */ +#define LOOKUP_HIDDEN (LOOKUP_PREFER_NAMESPACES << 1) +/* Prefer that the lvalue be treated as an rvalue. */ +#define LOOKUP_PREFER_RVALUE (LOOKUP_HIDDEN << 1) +/* We're inside an init-list, so narrowing conversions are ill-formed. */ +#define LOOKUP_NO_NARROWING (LOOKUP_PREFER_RVALUE << 1) +/* Avoid user-defined conversions for the first parameter of a copy + constructor (or move constructor). */ +#define LOOKUP_NO_COPY_CTOR_CONVERSION (LOOKUP_NO_NARROWING << 1) +/* This is the first parameter of a copy constructor. */ +#define LOOKUP_COPY_PARM (LOOKUP_NO_COPY_CTOR_CONVERSION << 1) +/* We only want to consider list constructors. */ +#define LOOKUP_LIST_ONLY (LOOKUP_COPY_PARM << 1) +/* Return after determining which function to call and checking access. + Used by sythesized_method_walk to determine which functions will + be called to initialize subobjects, in order to determine exception + specification and possible implicit delete. + This is kind of a hack, but since access control doesn't respect SFINAE + we can't just use tf_none to avoid access control errors, we need + another mechanism. Exiting early also avoids problems with trying + to perform argument conversions when the class isn't complete yet. */ +#define LOOKUP_SPECULATIVE (LOOKUP_LIST_ONLY << 1) +/* Used by calls from defaulted functions to limit the overload set to avoid + cycles trying to declare them (core issue 1092). */ +#define LOOKUP_DEFAULTED (LOOKUP_SPECULATIVE << 1) +/* Used in calls to store_init_value to suppress its usual call to + digest_init. */ +#define LOOKUP_ALREADY_DIGESTED (LOOKUP_DEFAULTED << 1) +/* An instantiation with explicit template arguments. */ +#define LOOKUP_EXPLICIT_TMPL_ARGS (LOOKUP_ALREADY_DIGESTED << 1) + +#define LOOKUP_NAMESPACES_ONLY(F) \ + (((F) & LOOKUP_PREFER_NAMESPACES) && !((F) & LOOKUP_PREFER_TYPES)) +#define LOOKUP_TYPES_ONLY(F) \ + (!((F) & LOOKUP_PREFER_NAMESPACES) && ((F) & LOOKUP_PREFER_TYPES)) +#define LOOKUP_QUALIFIERS_ONLY(F) ((F) & LOOKUP_PREFER_BOTH) + + +/* These flags are used by the conversion code. + CONV_IMPLICIT : Perform implicit conversions (standard and user-defined). + CONV_STATIC : Perform the explicit conversions for static_cast. + CONV_CONST : Perform the explicit conversions for const_cast. + CONV_REINTERPRET: Perform the explicit conversions for reinterpret_cast. + CONV_PRIVATE : Perform upcasts to private bases. + CONV_FORCE_TEMP : Require a new temporary when converting to the same + aggregate type. */ + +#define CONV_IMPLICIT 1 +#define CONV_STATIC 2 +#define CONV_CONST 4 +#define CONV_REINTERPRET 8 +#define CONV_PRIVATE 16 +/* #define CONV_NONCONVERTING 32 */ +#define CONV_FORCE_TEMP 64 +#define CONV_OLD_CONVERT (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \ + | CONV_REINTERPRET) +#define CONV_C_CAST (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \ + | CONV_REINTERPRET | CONV_PRIVATE | CONV_FORCE_TEMP) + +/* Used by build_expr_type_conversion to indicate which types are + acceptable as arguments to the expression under consideration. */ + +#define WANT_INT 1 /* integer types, including bool */ +#define WANT_FLOAT 2 /* floating point types */ +#define WANT_ENUM 4 /* enumerated types */ +#define WANT_POINTER 8 /* pointer types */ +#define WANT_NULL 16 /* null pointer constant */ +#define WANT_VECTOR_OR_COMPLEX 32 /* vector or complex types */ +#define WANT_ARITH (WANT_INT | WANT_FLOAT | WANT_VECTOR_OR_COMPLEX) + +/* Used with comptypes, and related functions, to guide type + comparison. */ + +#define COMPARE_STRICT 0 /* Just check if the types are the + same. */ +#define COMPARE_BASE 1 /* Check to see if the second type is + derived from the first. */ +#define COMPARE_DERIVED 2 /* Like COMPARE_BASE, but in + reverse. */ +#define COMPARE_REDECLARATION 4 /* The comparison is being done when + another declaration of an existing + entity is seen. */ +#define COMPARE_STRUCTURAL 8 /* The comparison is intended to be + structural. The actual comparison + will be identical to + COMPARE_STRICT. */ + +/* Used with push_overloaded_decl. */ +#define PUSH_GLOBAL 0 /* Push the DECL into namespace scope, + regardless of the current scope. */ +#define PUSH_LOCAL 1 /* Push the DECL into the current + scope. */ +#define PUSH_USING 2 /* We are pushing this DECL as the + result of a using declaration. */ + +/* Used with start function. */ +#define SF_DEFAULT 0 /* No flags. */ +#define SF_PRE_PARSED 1 /* The function declaration has + already been parsed. */ +#define SF_INCLASS_INLINE 2 /* The function is an inline, defined + in the class body. */ + +/* Used with start_decl's initialized parameter. */ +#define SD_UNINITIALIZED 0 +#define SD_INITIALIZED 1 +#define SD_DEFAULTED 2 +#define SD_DELETED 3 + +/* Returns nonzero iff TYPE1 and TYPE2 are the same type, or if TYPE2 + is derived from TYPE1, or if TYPE2 is a pointer (reference) to a + class derived from the type pointed to (referred to) by TYPE1. */ +#define same_or_base_type_p(TYPE1, TYPE2) \ + comptypes ((TYPE1), (TYPE2), COMPARE_BASE) + +/* These macros are used to access a TEMPLATE_PARM_INDEX. */ +#define TEMPLATE_PARM_INDEX_CAST(NODE) \ + ((template_parm_index*)TEMPLATE_PARM_INDEX_CHECK (NODE)) +#define TEMPLATE_PARM_IDX(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->index) +#define TEMPLATE_PARM_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->level) +/* The Number of sibling parms this template parm has. */ +#define TEMPLATE_PARM_NUM_SIBLINGS(NODE) \ + (TEMPLATE_PARM_INDEX_CAST (NODE)->num_siblings) +#define TEMPLATE_PARM_DESCENDANTS(NODE) (TREE_CHAIN (NODE)) +#define TEMPLATE_PARM_ORIG_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->orig_level) +#define TEMPLATE_PARM_DECL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->decl) +#define TEMPLATE_PARM_PARAMETER_PACK(NODE) \ + (TREE_LANG_FLAG_0 (TEMPLATE_PARM_INDEX_CHECK (NODE))) + +/* These macros are for accessing the fields of TEMPLATE_TYPE_PARM, + TEMPLATE_TEMPLATE_PARM and BOUND_TEMPLATE_TEMPLATE_PARM nodes. */ +#define TEMPLATE_TYPE_PARM_INDEX(NODE) \ + (TREE_CHECK3 ((NODE), TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM, \ + BOUND_TEMPLATE_TEMPLATE_PARM))->type.values +#define TEMPLATE_TYPE_IDX(NODE) \ + (TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (NODE))) +#define TEMPLATE_TYPE_LEVEL(NODE) \ + (TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE))) +#define TEMPLATE_TYPE_ORIG_LEVEL(NODE) \ + (TEMPLATE_PARM_ORIG_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE))) +#define TEMPLATE_TYPE_DECL(NODE) \ + (TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (NODE))) +#define TEMPLATE_TYPE_PARAMETER_PACK(NODE) \ + (TEMPLATE_PARM_PARAMETER_PACK (TEMPLATE_TYPE_PARM_INDEX (NODE))) + +/* These constants can used as bit flags in the process of tree formatting. + + TFF_PLAIN_IDENTIFIER: unqualified part of a name. + TFF_SCOPE: include the class and namespace scope of the name. + TFF_CHASE_TYPEDEF: print the original type-id instead of the typedef-name. + TFF_DECL_SPECIFIERS: print decl-specifiers. + TFF_CLASS_KEY_OR_ENUM: precede a class-type name (resp. enum name) with + a class-key (resp. `enum'). + TFF_RETURN_TYPE: include function return type. + TFF_FUNCTION_DEFAULT_ARGUMENTS: include function default parameter values. + TFF_EXCEPTION_SPECIFICATION: show function exception specification. + TFF_TEMPLATE_HEADER: show the template<...> header in a + template-declaration. + TFF_TEMPLATE_NAME: show only template-name. + TFF_EXPR_IN_PARENS: parenthesize expressions. + TFF_NO_FUNCTION_ARGUMENTS: don't show function arguments. + TFF_UNQUALIFIED_NAME: do not print the qualifying scope of the + top-level entity. + TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS: do not omit template arguments + identical to their defaults. */ + +#define TFF_PLAIN_IDENTIFIER (0) +#define TFF_SCOPE (1) +#define TFF_CHASE_TYPEDEF (1 << 1) +#define TFF_DECL_SPECIFIERS (1 << 2) +#define TFF_CLASS_KEY_OR_ENUM (1 << 3) +#define TFF_RETURN_TYPE (1 << 4) +#define TFF_FUNCTION_DEFAULT_ARGUMENTS (1 << 5) +#define TFF_EXCEPTION_SPECIFICATION (1 << 6) +#define TFF_TEMPLATE_HEADER (1 << 7) +#define TFF_TEMPLATE_NAME (1 << 8) +#define TFF_EXPR_IN_PARENS (1 << 9) +#define TFF_NO_FUNCTION_ARGUMENTS (1 << 10) +#define TFF_UNQUALIFIED_NAME (1 << 11) +#define TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS (1 << 12) + +/* Returns the TEMPLATE_DECL associated to a TEMPLATE_TEMPLATE_PARM + node. */ +#define TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL(NODE) \ + ((TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM) \ + ? TYPE_TI_TEMPLATE (NODE) \ + : TYPE_NAME (NODE)) + +/* in lex.c */ + +extern void init_reswords (void); + +typedef struct GTY(()) operator_name_info_t { + /* The IDENTIFIER_NODE for the operator. */ + tree identifier; + /* The name of the operator. */ + const char *name; + /* The mangled name of the operator. */ + const char *mangled_name; + /* The arity of the operator. */ + int arity; +} operator_name_info_t; + +/* A mapping from tree codes to operator name information. */ +extern GTY(()) operator_name_info_t operator_name_info + [(int) MAX_TREE_CODES]; +/* Similar, but for assignment operators. */ +extern GTY(()) operator_name_info_t assignment_operator_name_info + [(int) MAX_TREE_CODES]; + +/* A type-qualifier, or bitmask therefore, using the TYPE_QUAL + constants. */ + +typedef int cp_cv_quals; + +/* A storage class. */ + +typedef enum cp_storage_class { + /* sc_none must be zero so that zeroing a cp_decl_specifier_seq + sets the storage_class field to sc_none. */ + sc_none = 0, + sc_auto, + sc_register, + sc_static, + sc_extern, + sc_mutable +} cp_storage_class; + +/* An individual decl-specifier. */ + +typedef enum cp_decl_spec { + ds_first, + ds_signed = ds_first, + ds_unsigned, + ds_short, + ds_long, + ds_const, + ds_volatile, + ds_restrict, + ds_inline, + ds_virtual, + ds_explicit, + ds_friend, + ds_typedef, + ds_constexpr, + ds_complex, + ds_thread, + ds_last +} cp_decl_spec; + +/* A decl-specifier-seq. */ + +typedef struct cp_decl_specifier_seq { + /* The number of times each of the keywords has been seen. */ + unsigned specs[(int) ds_last]; + /* The location of the primary type. Mainly used for error + reporting. */ + location_t type_location; + /* The primary type, if any, given by the decl-specifier-seq. + Modifiers, like "short", "const", and "unsigned" are not + reflected here. This field will be a TYPE, unless a typedef-name + was used, in which case it will be a TYPE_DECL. */ + tree type; + /* The attributes, if any, provided with the specifier sequence. */ + tree attributes; + /* If non-NULL, a built-in type that the user attempted to redefine + to some other type. */ + tree redefined_builtin_type; + /* The storage class specified -- or sc_none if no storage class was + explicitly specified. */ + cp_storage_class storage_class; + /* True iff TYPE_SPEC indicates a user-defined type. */ + BOOL_BITFIELD user_defined_type_p : 1; + /* True iff multiple types were (erroneously) specified for this + decl-specifier-seq. */ + BOOL_BITFIELD multiple_types_p : 1; + /* True iff multiple storage classes were (erroneously) specified + for this decl-specifier-seq or a combination of a storage class + with a typedef specifier. */ + BOOL_BITFIELD conflicting_specifiers_p : 1; + /* True iff at least one decl-specifier was found. */ + BOOL_BITFIELD any_specifiers_p : 1; + /* True iff at least one type-specifier was found. */ + BOOL_BITFIELD any_type_specifiers_p : 1; + /* True iff "int" was explicitly provided. */ + BOOL_BITFIELD explicit_int_p : 1; + /* True iff "__int128" was explicitly provided. */ + BOOL_BITFIELD explicit_int128_p : 1; + /* True iff "char" was explicitly provided. */ + BOOL_BITFIELD explicit_char_p : 1; +} cp_decl_specifier_seq; + +/* The various kinds of declarators. */ + +typedef enum cp_declarator_kind { + cdk_id, + cdk_function, + cdk_array, + cdk_pointer, + cdk_reference, + cdk_ptrmem, + cdk_error +} cp_declarator_kind; + +/* A declarator. */ + +typedef struct cp_declarator cp_declarator; + +typedef struct cp_parameter_declarator cp_parameter_declarator; + +/* A parameter, before it has been semantically analyzed. */ +struct cp_parameter_declarator { + /* The next parameter, or NULL_TREE if none. */ + cp_parameter_declarator *next; + /* The decl-specifiers-seq for the parameter. */ + cp_decl_specifier_seq decl_specifiers; + /* The declarator for the parameter. */ + cp_declarator *declarator; + /* The default-argument expression, or NULL_TREE, if none. */ + tree default_argument; + /* True iff this is the first parameter in the list and the + parameter sequence ends with an ellipsis. */ + bool ellipsis_p; +}; + +/* A declarator. */ +struct cp_declarator { + /* The kind of declarator. */ + ENUM_BITFIELD (cp_declarator_kind) kind : 4; + /* Whether we parsed an ellipsis (`...') just before the declarator, + to indicate this is a parameter pack. */ + BOOL_BITFIELD parameter_pack_p : 1; + location_t id_loc; /* Currently only set for cdk_id and cdk_function. */ + /* Attributes that apply to this declarator. */ + tree attributes; + /* For all but cdk_id and cdk_error, the contained declarator. For + cdk_id and cdk_error, guaranteed to be NULL. */ + cp_declarator *declarator; + union { + /* For identifiers. */ + struct { + /* If non-NULL, the qualifying scope (a NAMESPACE_DECL or + *_TYPE) for this identifier. */ + tree qualifying_scope; + /* The unqualified name of the entity -- an IDENTIFIER_NODE, + BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */ + tree unqualified_name; + /* If this is the name of a function, what kind of special + function (if any). */ + special_function_kind sfk; + } id; + /* For functions. */ + struct { + /* The parameters to the function as a TREE_LIST of decl/default. */ + tree parameters; + /* The cv-qualifiers for the function. */ + cp_cv_quals qualifiers; + /* The exception-specification for the function. */ + tree exception_specification; + /* The late-specified return type, if any. */ + tree late_return_type; + } function; + /* For arrays. */ + struct { + /* The bounds to the array. */ + tree bounds; + } array; + /* For cdk_pointer and cdk_ptrmem. */ + struct { + /* The cv-qualifiers for the pointer. */ + cp_cv_quals qualifiers; + /* For cdk_ptrmem, the class type containing the member. */ + tree class_type; + } pointer; + /* For cdk_reference */ + struct { + /* The cv-qualifiers for the reference. These qualifiers are + only used to diagnose ill-formed code. */ + cp_cv_quals qualifiers; + /* Whether this is an rvalue reference */ + bool rvalue_ref; + } reference; + } u; +}; + +/* A level of template instantiation. */ +struct GTY(()) tinst_level { + /* The immediately deeper level in the chain. */ + struct tinst_level *next; + + /* The original node. Can be either a DECL (for a function or static + data member) or a TYPE (for a class), depending on what we were + asked to instantiate. */ + tree decl; + + /* The location where the template is instantiated. */ + location_t locus; + + /* True if the location is in a system header. */ + bool in_system_header_p; +}; + +/* A parameter list indicating for a function with no parameters, + e.g "int f(void)". */ +extern cp_parameter_declarator *no_parameters; + +/* True if we saw "#pragma GCC java_exceptions". */ +extern bool pragma_java_exceptions; + +/* in call.c */ +extern bool check_dtor_name (tree, tree); + +extern tree build_conditional_expr (tree, tree, tree, + tsubst_flags_t); +extern tree build_addr_func (tree); +extern tree build_call_a (tree, int, tree*); +extern tree build_call_n (tree, int, ...); +extern bool null_ptr_cst_p (tree); +extern bool sufficient_parms_p (const_tree); +extern tree type_decays_to (tree); +extern tree build_user_type_conversion (tree, tree, int); +extern tree build_new_function_call (tree, VEC(tree,gc) **, bool, + tsubst_flags_t); +extern tree build_operator_new_call (tree, VEC(tree,gc) **, tree *, + tree *, tree *); +extern tree build_new_method_call (tree, tree, VEC(tree,gc) **, + tree, int, tree *, + tsubst_flags_t); +extern tree build_special_member_call (tree, tree, VEC(tree,gc) **, + tree, int, tsubst_flags_t); +extern tree build_new_op (enum tree_code, int, tree, + tree, tree, bool *, + tsubst_flags_t); +extern tree build_op_call (tree, VEC(tree,gc) **, + tsubst_flags_t); +extern tree build_op_delete_call (enum tree_code, tree, tree, bool, tree, tree); +extern bool can_convert (tree, tree); +extern bool can_convert_arg (tree, tree, tree, int); +extern bool can_convert_arg_bad (tree, tree, tree, int); +extern bool enforce_access (tree, tree, tree); +extern tree convert_default_arg (tree, tree, tree, int); +extern tree convert_arg_to_ellipsis (tree); +extern tree build_x_va_arg (tree, tree); +extern tree cxx_type_promotes_to (tree); +extern tree type_passed_as (tree); +extern tree convert_for_arg_passing (tree, tree); +extern bool is_properly_derived_from (tree, tree); +extern tree set_up_extended_ref_temp (tree, tree, tree *, tree *); +extern tree initialize_reference (tree, tree, tree, tree *, tsubst_flags_t); +extern tree make_temporary_var_for_ref_to_temp (tree, tree); +extern tree strip_top_quals (tree); +extern bool reference_related_p (tree, tree); +extern tree perform_implicit_conversion (tree, tree, tsubst_flags_t); +extern tree perform_implicit_conversion_flags (tree, tree, tsubst_flags_t, int); +extern tree build_integral_nontype_arg_conv (tree, tree, tsubst_flags_t); +extern tree perform_direct_initialization_if_possible (tree, tree, bool, + tsubst_flags_t); +extern tree in_charge_arg_for_name (tree); +extern tree build_cxx_call (tree, int, tree *); +extern bool is_std_init_list (tree); +extern bool is_list_ctor (tree); +#ifdef ENABLE_CHECKING +extern void validate_conversion_obstack (void); +#endif /* ENABLE_CHECKING */ + +/* in class.c */ +extern tree build_vfield_ref (tree, tree); +extern tree build_base_path (enum tree_code, tree, + tree, int); +extern tree convert_to_base (tree, tree, bool, bool, + tsubst_flags_t); +extern tree convert_to_base_statically (tree, tree); +extern tree build_vtbl_ref (tree, tree); +extern tree build_vfn_ref (tree, tree); +extern tree get_vtable_decl (tree, int); +extern void resort_type_method_vec (void *, void *, + gt_pointer_operator, void *); +extern bool add_method (tree, tree, tree); +extern bool currently_open_class (tree); +extern tree currently_open_derived_class (tree); +extern tree current_nonlambda_class_type (void); +extern tree finish_struct (tree, tree); +extern void finish_struct_1 (tree); +extern int resolves_to_fixed_type_p (tree, int *); +extern void init_class_processing (void); +extern int is_empty_class (tree); +extern bool is_really_empty_class (tree); +extern void pushclass (tree); +extern void popclass (void); +extern void push_nested_class (tree); +extern void pop_nested_class (void); +extern int current_lang_depth (void); +extern void push_lang_context (tree); +extern void pop_lang_context (void); +extern tree instantiate_type (tree, tree, tsubst_flags_t); +extern void print_class_statistics (void); +extern void build_self_reference (void); +extern int same_signature_p (const_tree, const_tree); +extern void maybe_add_class_template_decl_list (tree, tree, int); +extern void unreverse_member_declarations (tree); +extern void invalidate_class_lookup_cache (void); +extern void maybe_note_name_used_in_class (tree, tree); +extern void note_name_declared_in_class (tree, tree); +extern tree get_vtbl_decl_for_binfo (tree); +extern void debug_class (tree); +extern void debug_thunks (tree); +extern tree cp_get_virtual_function_decl (tree, tree); +extern tree cp_fold_obj_type_ref (tree, tree); +extern bool cp_decl_is_base_field (tree); +extern bool cp_decl_is_constructor (tree); +extern bool cp_decl_is_destructor (tree); +extern int cp_decl_is_const_member_func (tree); +extern void set_linkage_according_to_type (tree, tree); +extern void determine_key_method (tree); +extern void check_for_override (tree, tree); +extern void push_class_stack (void); +extern void pop_class_stack (void); +extern bool type_has_user_nondefault_constructor (tree); +extern tree in_class_defaulted_default_constructor (tree); +extern bool user_provided_p (tree); +extern bool type_has_user_provided_constructor (tree); +extern bool type_has_user_provided_default_constructor (tree); +extern bool synthesized_default_constructor_is_constexpr (tree); +extern bool type_has_constexpr_default_constructor (tree); +extern bool type_has_virtual_destructor (tree); +extern bool type_has_move_constructor (tree); +extern bool type_has_move_assign (tree); +extern void defaulted_late_check (tree); +extern bool defaultable_fn_check (tree); +extern void fixup_type_variants (tree); +extern void fixup_attribute_variants (tree); +extern tree* decl_cloned_function_p (const_tree, bool); +extern void clone_function_decl (tree, int); +extern void adjust_clone_args (tree); + +/* in cvt.c */ +extern tree convert_to_reference (tree, tree, int, int, tree); +extern tree convert_from_reference (tree); +extern tree force_rvalue (tree); +extern tree ocp_convert (tree, tree, int, int); +extern tree cp_convert (tree, tree); +extern tree cp_convert_and_check (tree, tree); +extern tree cp_fold_convert (tree, tree); +extern tree convert_to_void (tree, impl_conv_void, + tsubst_flags_t); +extern tree convert_force (tree, tree, int); +extern tree build_expr_type_conversion (int, tree, bool); +extern tree type_promotes_to (tree); +extern tree perform_qualification_conversions (tree, tree); + +/* in name-lookup.c */ +extern tree pushdecl (tree); +extern tree pushdecl_maybe_friend (tree, bool); +extern void maybe_push_cleanup_level (tree); +extern tree pushtag (tree, tree, tag_scope); +extern tree make_anon_name (void); +extern tree pushdecl_top_level_maybe_friend (tree, bool); +extern tree pushdecl_top_level_and_finish (tree, tree); +extern tree check_for_out_of_scope_variable (tree); +extern void print_other_binding_stack (struct cp_binding_level *); +extern tree maybe_push_decl (tree); +extern tree current_decl_namespace (void); + +/* decl.c */ +extern tree poplevel (int, int, int); +extern void cxx_init_decl_processing (void); +enum cp_tree_node_structure_enum cp_tree_node_structure + (union lang_tree_node *); +extern void finish_scope (void); +extern void push_switch (tree); +extern void pop_switch (void); +extern tree make_lambda_name (void); +extern int decls_match (tree, tree); +extern tree duplicate_decls (tree, tree, bool); +extern tree declare_local_label (tree); +extern tree define_label (location_t, tree); +extern void check_goto (tree); +extern bool check_omp_return (void); +extern tree make_typename_type (tree, tree, enum tag_types, tsubst_flags_t); +extern tree make_unbound_class_template (tree, tree, tree, tsubst_flags_t); +extern tree build_library_fn_ptr (const char *, tree); +extern tree build_cp_library_fn_ptr (const char *, tree); +extern tree push_library_fn (tree, tree, tree); +extern tree push_void_library_fn (tree, tree); +extern tree push_throw_library_fn (tree, tree); +extern tree check_tag_decl (cp_decl_specifier_seq *); +extern tree shadow_tag (cp_decl_specifier_seq *); +extern tree groktypename (cp_decl_specifier_seq *, const cp_declarator *, bool); +extern tree start_decl (const cp_declarator *, cp_decl_specifier_seq *, int, tree, tree, tree *); +extern void start_decl_1 (tree, bool); +extern bool check_array_initializer (tree, tree, tree); +extern void cp_finish_decl (tree, tree, bool, tree, int); +extern int cp_complete_array_type (tree *, tree, bool); +extern tree build_ptrmemfunc_type (tree); +extern tree build_ptrmem_type (tree, tree); +/* the grokdeclarator prototype is in decl.h */ +extern tree build_this_parm (tree, cp_cv_quals); +extern int copy_fn_p (const_tree); +extern bool move_fn_p (const_tree); +extern tree get_scope_of_declarator (const cp_declarator *); +extern void grok_special_member_properties (tree); +extern int grok_ctor_properties (const_tree, const_tree); +extern bool grok_op_properties (tree, bool); +extern tree xref_tag (enum tag_types, tree, tag_scope, bool); +extern tree xref_tag_from_type (tree, tree, tag_scope); +extern bool xref_basetypes (tree, tree); +extern tree start_enum (tree, tree, tree, bool, bool *); +extern void finish_enum_value_list (tree); +extern void finish_enum (tree); +extern void build_enumerator (tree, tree, tree, location_t); +extern tree lookup_enumerator (tree, tree); +extern void start_preparsed_function (tree, tree, int); +extern int start_function (cp_decl_specifier_seq *, const cp_declarator *, tree); +extern tree begin_function_body (void); +extern void finish_function_body (tree); +extern tree outer_curly_brace_block (tree); +extern tree finish_function (int); +extern tree grokmethod (cp_decl_specifier_seq *, const cp_declarator *, tree); +extern void maybe_register_incomplete_var (tree); +extern void maybe_commonize_var (tree); +extern void complete_vars (tree); +extern void finish_stmt (void); +extern tree static_fn_type (tree); +extern void revert_static_member_fn (tree); +extern void fixup_anonymous_aggr (tree); +extern int check_static_variable_definition (tree, tree); +extern tree compute_array_index_type (tree, tree, tsubst_flags_t); +extern tree check_default_argument (tree, tree); +typedef int (*walk_namespaces_fn) (tree, void *); +extern int walk_namespaces (walk_namespaces_fn, + void *); +extern int wrapup_globals_for_namespace (tree, void *); +extern tree create_implicit_typedef (tree, tree); +extern int local_variable_p (const_tree); +extern tree register_dtor_fn (tree); +extern tmpl_spec_kind current_tmpl_spec_kind (int); +extern tree cp_fname_init (const char *, tree *); +extern tree cxx_builtin_function (tree decl); +extern tree cxx_builtin_function_ext_scope (tree decl); +extern tree check_elaborated_type_specifier (enum tag_types, tree, bool); +extern void warn_extern_redeclared_static (tree, tree); +extern tree cxx_comdat_group (tree); +extern bool cp_missing_noreturn_ok_p (tree); +extern void initialize_artificial_var (tree, VEC(constructor_elt,gc) *); +extern tree check_var_type (tree, tree); +extern tree reshape_init (tree, tree); +extern tree next_initializable_field (tree); + +extern bool defer_mark_used_calls; +extern GTY(()) VEC(tree, gc) *deferred_mark_used_calls; +extern tree finish_case_label (location_t, tree, tree); +extern tree cxx_maybe_build_cleanup (tree); + +/* in decl2.c */ +extern bool check_java_method (tree); +extern tree build_memfn_type (tree, tree, cp_cv_quals); +extern tree change_return_type (tree, tree); +extern void maybe_retrofit_in_chrg (tree); +extern void maybe_make_one_only (tree); +extern bool vague_linkage_p (tree); +extern void grokclassfn (tree, tree, + enum overload_flags); +extern tree grok_array_decl (tree, tree); +extern tree delete_sanity (tree, tree, bool, int); +extern tree check_classfn (tree, tree, tree); +extern void check_member_template (tree); +extern tree grokfield (const cp_declarator *, cp_decl_specifier_seq *, + tree, bool, tree, tree); +extern tree grokbitfield (const cp_declarator *, cp_decl_specifier_seq *, + tree, tree); +extern tree cp_reconstruct_complex_type (tree, tree); +extern void cplus_decl_attributes (tree *, tree, int); +extern void finish_anon_union (tree); +extern void cp_write_global_declarations (void); +extern void cp_process_pending_declarations (location_t); +extern void cp_clear_deferred_fns (void); +extern void cp_clear_conv_type_map (void); +extern tree coerce_new_type (tree); +extern tree coerce_delete_type (tree); +extern void comdat_linkage (tree); +extern void determine_visibility (tree); +extern void constrain_class_visibility (tree); +extern void import_export_decl (tree); +extern tree build_cleanup (tree); +extern tree build_offset_ref_call_from_tree (tree, VEC(tree,gc) **); +extern bool decl_constant_var_p (tree); +extern bool decl_maybe_constant_var_p (tree); +extern void check_default_args (tree); +extern void mark_used (tree); +extern void finish_static_data_member_decl (tree, tree, bool, tree, int); +extern tree cp_build_parm_decl (tree, tree); +extern tree get_guard (tree); +extern tree get_guard_cond (tree); +extern tree set_guard (tree); +extern tree cxx_callgraph_analyze_expr (tree *, int *); +extern void mark_needed (tree); +extern bool decl_needed_p (tree); +extern void note_vague_linkage_fn (tree); +extern tree build_artificial_parm (tree, tree); +extern bool possibly_inlined_p (tree); +extern int parm_index (tree); + +/* in error.c */ +extern void init_error (void); +extern const char *type_as_string (tree, int); +extern const char *type_as_string_translate (tree, int); +extern const char *decl_as_string (tree, int); +extern const char *decl_as_string_translate (tree, int); +extern const char *expr_as_string (tree, int); +extern const char *lang_decl_name (tree, int, bool); +extern const char *language_to_string (enum languages); +extern const char *class_key_or_enum_as_string (tree); +extern void print_instantiation_context (void); +extern void maybe_warn_variadic_templates (void); +extern void maybe_warn_cpp0x (cpp0x_warn_str str); +extern bool pedwarn_cxx98 (location_t, int, const char *, ...) ATTRIBUTE_GCC_DIAG(3,4); +extern location_t location_of (tree); +extern void qualified_name_lookup_error (tree, tree, tree, + location_t); + +/* in except.c */ +extern void init_exception_processing (void); +extern tree expand_start_catch_block (tree); +extern void expand_end_catch_block (void); +extern tree build_exc_ptr (void); +extern tree build_throw (tree); +extern int nothrow_libfn_p (const_tree); +extern void check_handlers (tree); +extern tree finish_noexcept_expr (tree, tsubst_flags_t); +extern void perform_deferred_noexcept_checks (void); +extern bool nothrow_spec_p (const_tree); +extern bool type_noexcept_p (const_tree); +extern bool type_throw_all_p (const_tree); +extern tree build_noexcept_spec (tree, int); +extern void choose_personality_routine (enum languages); +extern tree eh_type_info (tree); +extern tree begin_eh_spec_block (void); +extern void finish_eh_spec_block (tree, tree); +extern tree build_eh_type_type (tree); +extern tree cp_protect_cleanup_actions (void); + +/* in expr.c */ +extern tree cplus_expand_constant (tree); +extern tree mark_rvalue_use (tree); +extern tree mark_lvalue_use (tree); +extern tree mark_type_use (tree); +extern void mark_exp_read (tree); + +/* friend.c */ +extern int is_friend (tree, tree); +extern void make_friend_class (tree, tree, bool); +extern void add_friend (tree, tree, bool); +extern tree do_friend (tree, tree, tree, tree, enum overload_flags, bool); + +/* in init.c */ +extern tree expand_member_init (tree); +extern void emit_mem_initializers (tree); +extern tree build_aggr_init (tree, tree, int, + tsubst_flags_t); +extern int is_class_type (tree, int); +extern tree get_type_value (tree); +extern tree build_zero_init (tree, tree, bool); +extern tree build_value_init (tree, tsubst_flags_t); +extern tree build_value_init_noctor (tree, tsubst_flags_t); +extern tree build_offset_ref (tree, tree, bool); +extern tree build_new (VEC(tree,gc) **, tree, tree, + VEC(tree,gc) **, int, + tsubst_flags_t); +extern tree get_temp_regvar (tree, tree); +extern tree build_vec_init (tree, tree, tree, bool, int, + tsubst_flags_t); +extern tree build_delete (tree, tree, + special_function_kind, + int, int); +extern void push_base_cleanups (void); +extern tree build_vec_delete (tree, tree, + special_function_kind, int); +extern tree create_temporary_var (tree); +extern void initialize_vtbl_ptrs (tree); +extern tree build_java_class_ref (tree); +extern tree integral_constant_value (tree); +extern int diagnose_uninitialized_cst_or_ref_member (tree, bool, bool); + +/* in lex.c */ +extern void cxx_dup_lang_specific_decl (tree); +extern void yyungetc (int, int); + +extern tree unqualified_name_lookup_error (tree); +extern tree unqualified_fn_lookup_error (tree); +extern tree build_lang_decl (enum tree_code, tree, tree); +extern tree build_lang_decl_loc (location_t, enum tree_code, tree, tree); +extern void retrofit_lang_decl (tree); +extern tree copy_decl (tree); +extern tree copy_type (tree); +extern tree cxx_make_type (enum tree_code); +extern tree make_class_type (enum tree_code); +extern bool cxx_init (void); +extern void cxx_finish (void); +extern bool in_main_input_context (void); + +/* in method.c */ +extern void init_method (void); +extern tree make_thunk (tree, bool, tree, tree); +extern void finish_thunk (tree); +extern void use_thunk (tree, bool); +extern bool trivial_fn_p (tree); +extern bool maybe_explain_implicit_delete (tree); +extern void synthesize_method (tree); +extern tree lazily_declare_fn (special_function_kind, + tree); +extern tree skip_artificial_parms_for (const_tree, tree); +extern int num_artificial_parms_for (const_tree); +extern tree make_alias_for (tree, tree); +extern tree get_copy_ctor (tree, tsubst_flags_t); +extern tree get_copy_assign (tree); +extern tree get_default_ctor (tree); +extern tree get_dtor (tree, tsubst_flags_t); +extern tree locate_ctor (tree); + +/* In optimize.c */ +extern bool maybe_clone_body (tree); + +/* in pt.c */ +extern bool check_template_shadow (tree); +extern tree get_innermost_template_args (tree, int); +extern void maybe_begin_member_template_processing (tree); +extern void maybe_end_member_template_processing (void); +extern tree finish_member_template_decl (tree); +extern void begin_template_parm_list (void); +extern bool begin_specialization (void); +extern void reset_specialization (void); +extern void end_specialization (void); +extern void begin_explicit_instantiation (void); +extern void end_explicit_instantiation (void); +extern tree check_explicit_specialization (tree, tree, int, int); +extern tree make_auto (void); +extern tree do_auto_deduction (tree, tree, tree); +extern tree type_uses_auto (tree); +extern void append_type_to_template_for_access_check (tree, tree, tree, + location_t); +extern tree splice_late_return_type (tree, tree); +extern bool is_auto (const_tree); +extern tree process_template_parm (tree, location_t, tree, + bool, bool, unsigned); +extern tree end_template_parm_list (tree); +void fixup_template_parms (void); +extern void end_template_decl (void); +extern tree maybe_update_decl_type (tree, tree); +extern bool check_default_tmpl_args (tree, tree, int, int, int); +extern tree push_template_decl (tree); +extern tree push_template_decl_real (tree, bool); +extern bool redeclare_class_template (tree, tree); +extern tree lookup_template_class (tree, tree, tree, tree, + int, tsubst_flags_t); +extern tree lookup_template_function (tree, tree); +extern int uses_template_parms (tree); +extern int uses_template_parms_level (tree, int); +extern tree instantiate_class_template (tree); +extern tree instantiate_template (tree, tree, tsubst_flags_t); +extern int fn_type_unification (tree, tree, tree, + const tree *, unsigned int, + tree, unification_kind_t, int); +extern void mark_decl_instantiated (tree, int); +extern int more_specialized_fn (tree, tree, int); +extern void do_decl_instantiation (tree, tree); +extern void do_type_instantiation (tree, tree, tsubst_flags_t); +extern bool always_instantiate_p (tree); +extern tree instantiate_decl (tree, int, bool); +extern int comp_template_parms (const_tree, const_tree); +extern bool uses_parameter_packs (tree); +extern bool template_parameter_pack_p (const_tree); +extern bool function_parameter_pack_p (const_tree); +extern bool function_parameter_expanded_from_pack_p (tree, tree); +extern tree make_pack_expansion (tree); +extern bool check_for_bare_parameter_packs (tree); +extern tree build_template_info (tree, tree); +extern tree get_template_info (const_tree); +extern VEC(qualified_typedef_usage_t,gc)* get_types_needing_access_check (tree); +extern int template_class_depth (tree); +extern int is_specialization_of (tree, tree); +extern bool is_specialization_of_friend (tree, tree); +extern tree get_pattern_parm (tree, tree); +extern int comp_template_args (tree, tree); +extern tree maybe_process_partial_specialization (tree); +extern tree most_specialized_instantiation (tree); +extern void print_candidates (tree); +extern void instantiate_pending_templates (int); +extern tree tsubst_default_argument (tree, tree, tree); +extern tree tsubst (tree, tree, tsubst_flags_t, tree); +extern tree tsubst_copy_and_build (tree, tree, tsubst_flags_t, + tree, bool, bool); +extern tree most_general_template (tree); +extern tree get_mostly_instantiated_function_type (tree); +extern int problematic_instantiation_changed (void); +extern void record_last_problematic_instantiation (void); +extern struct tinst_level *current_instantiation(void); +extern tree maybe_get_template_decl_from_type_decl (tree); +extern int processing_template_parmlist; +extern bool dependent_type_p (tree); +extern bool dependent_scope_p (tree); +extern bool any_dependent_template_arguments_p (const_tree); +extern bool dependent_template_p (tree); +extern bool dependent_template_id_p (tree, tree); +extern bool type_dependent_expression_p (tree); +extern bool any_type_dependent_arguments_p (const VEC(tree,gc) *); +extern bool type_dependent_expression_p_push (tree); +extern bool value_dependent_expression_p (tree); +extern bool any_value_dependent_elements_p (const_tree); +extern bool dependent_omp_for_p (tree, tree, tree, tree); +extern tree resolve_typename_type (tree, bool); +extern tree template_for_substitution (tree); +extern tree build_non_dependent_expr (tree); +extern void make_args_non_dependent (VEC(tree,gc) *); +extern bool reregister_specialization (tree, tree, tree); +extern tree fold_non_dependent_expr (tree); +extern bool explicit_class_specialization_p (tree); +extern int push_tinst_level (tree); +extern void pop_tinst_level (void); +extern struct tinst_level *outermost_tinst_level(void); +extern bool parameter_of_template_p (tree, tree); +extern void init_template_processing (void); +extern void print_template_statistics (void); +bool template_template_parameter_p (const_tree); +extern bool primary_template_instantiation_p (const_tree); +extern tree get_primary_template_innermost_parameters (const_tree); +extern tree get_template_parms_at_level (tree, int); +extern tree get_template_innermost_arguments (const_tree); +extern tree get_template_argument_pack_elems (const_tree); +extern tree get_function_template_decl (const_tree); +extern tree resolve_nondeduced_context (tree); +extern hashval_t iterative_hash_template_arg (tree arg, hashval_t val); + +/* in repo.c */ +extern void init_repo (void); +extern int repo_emit_p (tree); +extern bool repo_export_class_p (const_tree); +extern void finish_repo (void); + +/* in rtti.c */ +/* A vector of all tinfo decls that haven't been emitted yet. */ +extern GTY(()) VEC(tree,gc) *unemitted_tinfo_decls; + +extern void init_rtti_processing (void); +extern tree build_typeid (tree); +extern tree get_tinfo_decl (tree); +extern tree get_typeid (tree); +extern tree build_headof (tree); +extern tree build_dynamic_cast (tree, tree, tsubst_flags_t); +extern void emit_support_tinfos (void); +extern bool emit_tinfo_decl (tree); + +/* in search.c */ +extern bool accessible_base_p (tree, tree, bool); +extern tree lookup_base (tree, tree, base_access, + base_kind *); +extern tree dcast_base_hint (tree, tree); +extern int accessible_p (tree, tree, bool); +extern tree lookup_field_1 (tree, tree, bool); +extern tree lookup_field (tree, tree, int, bool); +extern int lookup_fnfields_1 (tree, tree); +extern tree lookup_fnfields_slot (tree, tree); +extern int class_method_index_for_fn (tree, tree); +extern tree lookup_fnfields (tree, tree, int); +extern tree lookup_member (tree, tree, int, bool); +extern int look_for_overrides (tree, tree); +extern void get_pure_virtuals (tree); +extern void maybe_suppress_debug_info (tree); +extern void note_debug_info_needed (tree); +extern void print_search_statistics (void); +extern void reinit_search_statistics (void); +extern tree current_scope (void); +extern int at_function_scope_p (void); +extern bool at_class_scope_p (void); +extern bool at_namespace_scope_p (void); +extern tree context_for_name_lookup (tree); +extern tree lookup_conversions (tree); +extern tree binfo_from_vbase (tree); +extern tree binfo_for_vbase (tree, tree); +extern tree look_for_overrides_here (tree, tree); +#define dfs_skip_bases ((tree)1) +extern tree dfs_walk_all (tree, tree (*) (tree, void *), + tree (*) (tree, void *), void *); +extern tree dfs_walk_once (tree, tree (*) (tree, void *), + tree (*) (tree, void *), void *); +extern tree binfo_via_virtual (tree, tree); +extern tree build_baselink (tree, tree, tree, tree); +extern tree adjust_result_of_qualified_name_lookup + (tree, tree, tree); +extern tree copied_binfo (tree, tree); +extern tree original_binfo (tree, tree); +extern int shared_member_p (tree); + + +/* The representation of a deferred access check. */ + +typedef struct GTY(()) deferred_access_check { + /* The base class in which the declaration is referenced. */ + tree binfo; + /* The declaration whose access must be checked. */ + tree decl; + /* The declaration that should be used in the error message. */ + tree diag_decl; +} deferred_access_check; +DEF_VEC_O(deferred_access_check); +DEF_VEC_ALLOC_O(deferred_access_check,gc); + +/* in semantics.c */ +extern void push_deferring_access_checks (deferring_kind); +extern void resume_deferring_access_checks (void); +extern void stop_deferring_access_checks (void); +extern void pop_deferring_access_checks (void); +extern VEC (deferred_access_check,gc)* get_deferred_access_checks (void); +extern void pop_to_parent_deferring_access_checks (void); +extern void perform_access_checks (VEC (deferred_access_check,gc)*); +extern void perform_deferred_access_checks (void); +extern void perform_or_defer_access_check (tree, tree, tree); +extern bool speculative_access_check (tree, tree, tree, bool); +extern int stmts_are_full_exprs_p (void); +extern void init_cp_semantics (void); +extern tree do_poplevel (tree); +extern void add_decl_expr (tree); +extern tree finish_expr_stmt (tree); +extern tree begin_if_stmt (void); +extern void finish_if_stmt_cond (tree, tree); +extern tree finish_then_clause (tree); +extern void begin_else_clause (tree); +extern void finish_else_clause (tree); +extern void finish_if_stmt (tree); +extern tree begin_while_stmt (void); +extern void finish_while_stmt_cond (tree, tree); +extern void finish_while_stmt (tree); +extern tree begin_do_stmt (void); +extern void finish_do_body (tree); +extern void finish_do_stmt (tree, tree); +extern tree finish_return_stmt (tree); +extern tree begin_for_scope (tree *); +extern tree begin_for_stmt (tree, tree); +extern void finish_for_init_stmt (tree); +extern void finish_for_cond (tree, tree); +extern void finish_for_expr (tree, tree); +extern void finish_for_stmt (tree); +extern tree begin_range_for_stmt (tree, tree); +extern void finish_range_for_decl (tree, tree, tree); +extern void finish_range_for_stmt (tree); +extern tree finish_break_stmt (void); +extern tree finish_continue_stmt (void); +extern tree begin_switch_stmt (void); +extern void finish_switch_cond (tree, tree); +extern void finish_switch_stmt (tree); +extern tree finish_goto_stmt (tree); +extern tree begin_try_block (void); +extern void finish_try_block (tree); +extern void finish_handler_sequence (tree); +extern tree begin_function_try_block (tree *); +extern void finish_function_try_block (tree); +extern void finish_function_handler_sequence (tree, tree); +extern void finish_cleanup_try_block (tree); +extern tree begin_handler (void); +extern void finish_handler_parms (tree, tree); +extern void finish_handler (tree); +extern void finish_cleanup (tree, tree); +extern bool literal_type_p (tree); +extern tree validate_constexpr_fundecl (tree); +extern tree register_constexpr_fundef (tree, tree); +extern bool check_constexpr_ctor_body (tree, tree); +extern tree ensure_literal_type_for_constexpr_object (tree); +extern bool potential_constant_expression (tree); +extern bool potential_rvalue_constant_expression (tree); +extern bool require_potential_constant_expression (tree); +extern bool require_potential_rvalue_constant_expression (tree); +extern tree cxx_constant_value (tree); +extern tree maybe_constant_value (tree); +extern tree maybe_constant_init (tree); +extern bool is_sub_constant_expr (tree); +extern bool reduced_constant_expression_p (tree); +extern VEC(tree,heap)* cx_error_context (void); + +enum { + BCS_NO_SCOPE = 1, + BCS_TRY_BLOCK = 2, + BCS_FN_BODY = 4 +}; +extern tree begin_compound_stmt (unsigned int); + +extern void finish_compound_stmt (tree); +extern tree finish_asm_stmt (int, tree, tree, tree, tree, + tree); +extern tree finish_label_stmt (tree); +extern void finish_label_decl (tree); +extern tree finish_parenthesized_expr (tree); +extern tree finish_non_static_data_member (tree, tree, tree); +extern tree begin_stmt_expr (void); +extern tree finish_stmt_expr_expr (tree, tree); +extern tree finish_stmt_expr (tree, bool); +extern tree stmt_expr_value_expr (tree); +bool empty_expr_stmt_p (tree); +extern tree perform_koenig_lookup (tree, VEC(tree,gc) *, bool); +extern tree finish_call_expr (tree, VEC(tree,gc) **, bool, + bool, tsubst_flags_t); +extern tree finish_increment_expr (tree, enum tree_code); +extern tree finish_this_expr (void); +extern tree finish_pseudo_destructor_expr (tree, tree, tree); +extern tree finish_unary_op_expr (enum tree_code, tree); +extern tree finish_compound_literal (tree, tree); +extern tree finish_fname (tree); +extern void finish_translation_unit (void); +extern tree finish_template_type_parm (tree, tree); +extern tree finish_template_template_parm (tree, tree); +extern tree begin_class_definition (tree, tree); +extern void finish_template_decl (tree); +extern tree finish_template_type (tree, tree, int); +extern tree finish_base_specifier (tree, tree, bool); +extern void finish_member_declaration (tree); +extern tree finish_id_expression (tree, tree, tree, + cp_id_kind *, + bool, bool, bool *, + bool, bool, bool, bool, + const char **, + location_t); +extern tree finish_typeof (tree); +extern tree finish_offsetof (tree); +extern void finish_decl_cleanup (tree, tree); +extern void finish_eh_cleanup (tree); +extern void emit_associated_thunks (tree); +extern void finish_mem_initializers (tree); +extern tree check_template_template_default_arg (tree); +extern bool expand_or_defer_fn_1 (tree); +extern void expand_or_defer_fn (tree); +extern void add_typedef_to_current_template_for_access_check (tree, tree, + location_t); +extern void check_accessibility_of_qualified_id (tree, tree, tree); +extern tree finish_qualified_id_expr (tree, tree, bool, bool, + bool, bool); +extern void simplify_aggr_init_expr (tree *); +extern void finalize_nrv (tree *, tree, tree); +extern void note_decl_for_pch (tree); +extern tree finish_omp_clauses (tree); +extern void finish_omp_threadprivate (tree); +extern tree begin_omp_structured_block (void); +extern tree finish_omp_structured_block (tree); +extern tree begin_omp_parallel (void); +extern tree finish_omp_parallel (tree, tree); +extern tree begin_omp_task (void); +extern tree finish_omp_task (tree, tree); +extern tree finish_omp_for (location_t, tree, tree, + tree, tree, tree, tree, tree); +extern void finish_omp_atomic (enum tree_code, tree, tree); +extern void finish_omp_barrier (void); +extern void finish_omp_flush (void); +extern void finish_omp_taskwait (void); +extern bool cxx_omp_create_clause_info (tree, tree, bool, bool, bool); +extern tree baselink_for_fns (tree); +extern void finish_static_assert (tree, tree, location_t, + bool); +extern tree describable_type (tree); +extern tree finish_decltype_type (tree, bool, tsubst_flags_t); +extern tree finish_trait_expr (enum cp_trait_kind, tree, tree); +extern tree build_lambda_expr (void); +extern tree build_lambda_object (tree); +extern tree begin_lambda_type (tree); +extern tree lambda_capture_field_type (tree); +extern tree lambda_return_type (tree); +extern tree lambda_function (tree); +extern void apply_lambda_return_type (tree, tree); +extern tree add_capture (tree, tree, tree, bool, bool); +extern tree add_default_capture (tree, tree, tree); +extern void register_capture_members (tree); +extern tree lambda_expr_this_capture (tree); +extern tree nonlambda_method_basetype (void); +extern void maybe_add_lambda_conv_op (tree); + +/* in tree.c */ +void cp_free_lang_data (tree t); +extern tree force_target_expr (tree, tree); +extern tree build_target_expr_with_type (tree, tree); +extern void lang_check_failed (const char *, int, + const char *) ATTRIBUTE_NORETURN; +extern tree stabilize_expr (tree, tree *); +extern void stabilize_call (tree, tree *); +extern void stabilize_aggr_init (tree, tree *); +extern bool stabilize_init (tree, tree *); +extern tree add_stmt_to_compound (tree, tree); +extern void init_tree (void); +extern bool pod_type_p (const_tree); +extern bool layout_pod_type_p (const_tree); +extern bool std_layout_type_p (const_tree); +extern bool trivial_type_p (const_tree); +extern bool trivially_copyable_p (const_tree); +extern bool type_has_nontrivial_default_init (const_tree); +extern bool type_has_nontrivial_copy_init (const_tree); +extern bool class_tmpl_impl_spec_p (const_tree); +extern int zero_init_p (const_tree); +extern tree strip_typedefs (tree); +extern tree copy_binfo (tree, tree, tree, + tree *, int); +extern int member_p (const_tree); +extern cp_lvalue_kind real_lvalue_p (const_tree); +extern cp_lvalue_kind lvalue_kind (const_tree); +extern bool lvalue_or_rvalue_with_address_p (const_tree); +extern bool builtin_valid_in_constant_expr_p (const_tree); +extern tree build_min (enum tree_code, tree, ...); +extern tree build_min_nt (enum tree_code, ...); +extern tree build_min_non_dep (enum tree_code, tree, ...); +extern tree build_min_non_dep_call_vec (tree, tree, VEC(tree,gc) *); +extern tree build_cplus_new (tree, tree); +extern tree build_aggr_init_expr (tree, tree); +extern tree get_target_expr (tree); +extern tree build_cplus_array_type (tree, tree); +extern tree build_array_of_n_type (tree, int); +extern tree build_array_copy (tree); +extern tree build_vec_init_expr (tree, tree); +extern void diagnose_non_constexpr_vec_init (tree); +extern tree hash_tree_cons (tree, tree, tree); +extern tree hash_tree_chain (tree, tree); +extern tree build_qualified_name (tree, tree, tree, bool); +extern int is_overloaded_fn (tree); +extern tree get_fns (tree); +extern tree get_first_fn (tree); +extern tree ovl_cons (tree, tree); +extern tree build_overload (tree, tree); +extern bool non_static_member_function_p (tree); +extern const char *cxx_printable_name (tree, int); +extern const char *cxx_printable_name_translate (tree, int); +extern tree build_exception_variant (tree, tree); +extern tree bind_template_template_parm (tree, tree); +extern tree array_type_nelts_total (tree); +extern tree array_type_nelts_top (tree); +extern tree break_out_target_exprs (tree); +extern tree get_type_decl (tree); +extern tree decl_namespace_context (tree); +extern bool decl_anon_ns_mem_p (const_tree); +extern tree lvalue_type (tree); +extern tree error_type (tree); +extern int varargs_function_p (const_tree); +extern bool really_overloaded_fn (tree); +extern bool cp_tree_equal (tree, tree); +extern tree no_linkage_check (tree, bool); +extern void debug_binfo (tree); +extern tree build_dummy_object (tree); +extern tree maybe_dummy_object (tree, tree *); +extern int is_dummy_object (const_tree); +extern const struct attribute_spec cxx_attribute_table[]; +extern tree make_ptrmem_cst (tree, tree); +extern tree cp_build_type_attribute_variant (tree, tree); +extern tree cp_build_reference_type (tree, bool); +extern tree move (tree); +extern tree cp_build_qualified_type_real (tree, int, tsubst_flags_t); +#define cp_build_qualified_type(TYPE, QUALS) \ + cp_build_qualified_type_real ((TYPE), (QUALS), tf_warning_or_error) +extern bool cv_qualified_p (const_tree); +extern tree cv_unqualified (tree); +extern special_function_kind special_function_p (const_tree); +extern int count_trees (tree); +extern int char_type_p (tree); +extern void verify_stmt_tree (tree); +extern linkage_kind decl_linkage (tree); +extern duration_kind decl_storage_duration (tree); +extern tree cp_walk_subtrees (tree*, int*, walk_tree_fn, + void*, struct pointer_set_t*); +#define cp_walk_tree(a,b,c,d) \ + walk_tree_1 (a, b, c, d, cp_walk_subtrees) +#define cp_walk_tree_without_duplicates(a,b,c) \ + walk_tree_without_duplicates_1 (a, b, c, cp_walk_subtrees) +extern tree fold_if_not_in_template (tree); +extern tree rvalue (tree); +extern tree convert_bitfield_to_declared_type (tree); +extern tree cp_save_expr (tree); +extern bool cast_valid_in_integral_constant_expression_p (tree); +extern bool cxx_type_hash_eq (const_tree, const_tree); + +extern void cxx_print_statistics (void); + +/* in ptree.c */ +extern void cxx_print_xnode (FILE *, tree, int); +extern void cxx_print_decl (FILE *, tree, int); +extern void cxx_print_type (FILE *, tree, int); +extern void cxx_print_identifier (FILE *, tree, int); +extern void cxx_print_error_function (diagnostic_context *, + const char *, + struct diagnostic_info *); + +/* in typeck.c */ +extern bool cxx_mark_addressable (tree); +extern int string_conv_p (const_tree, const_tree, int); +extern tree cp_truthvalue_conversion (tree); +extern tree condition_conversion (tree); +extern tree require_complete_type (tree); +extern tree require_complete_type_sfinae (tree, tsubst_flags_t); +extern tree complete_type (tree); +extern tree complete_type_or_else (tree, tree); +extern tree complete_type_or_maybe_complain (tree, tree, tsubst_flags_t); +extern int type_unknown_p (const_tree); +enum { ce_derived, ce_normal, ce_exact }; +extern bool comp_except_specs (const_tree, const_tree, int); +extern bool comptypes (tree, tree, int); +extern bool same_type_ignoring_top_level_qualifiers_p (tree, tree); +extern bool compparms (const_tree, const_tree); +extern int comp_cv_qualification (const_tree, const_tree); +extern int comp_cv_qual_signature (tree, tree); +extern tree cxx_sizeof_or_alignof_expr (tree, enum tree_code, bool); +extern tree cxx_sizeof_or_alignof_type (tree, enum tree_code, bool); +extern tree cxx_sizeof_nowarn (tree); +extern tree is_bitfield_expr_with_lowered_type (const_tree); +extern tree unlowered_expr_type (const_tree); +extern tree decay_conversion (tree); +extern tree build_class_member_access_expr (tree, tree, tree, bool, + tsubst_flags_t); +extern tree finish_class_member_access_expr (tree, tree, bool, + tsubst_flags_t); +extern tree build_x_indirect_ref (tree, ref_operator, + tsubst_flags_t); +extern tree cp_build_indirect_ref (tree, ref_operator, + tsubst_flags_t); +extern tree build_array_ref (location_t, tree, tree); +extern tree cp_build_array_ref (location_t, tree, tree, + tsubst_flags_t); +extern tree get_member_function_from_ptrfunc (tree *, tree); +extern tree cp_build_function_call (tree, tree, tsubst_flags_t); +extern tree cp_build_function_call_nary (tree, tsubst_flags_t, ...) + ATTRIBUTE_SENTINEL; +extern tree cp_build_function_call_vec (tree, VEC(tree,gc) **, + tsubst_flags_t); +extern tree build_x_binary_op (enum tree_code, tree, + enum tree_code, tree, + enum tree_code, bool *, + tsubst_flags_t); +extern tree build_x_array_ref (tree, tree, tsubst_flags_t); +extern tree build_x_unary_op (enum tree_code, tree, + tsubst_flags_t); +extern tree cp_build_addr_expr (tree, tsubst_flags_t); +extern tree cp_build_addr_expr_strict (tree, tsubst_flags_t); +extern tree cp_build_unary_op (enum tree_code, tree, int, + tsubst_flags_t); +extern tree unary_complex_lvalue (enum tree_code, tree); +extern tree build_x_conditional_expr (tree, tree, tree, + tsubst_flags_t); +extern tree build_x_compound_expr_from_list (tree, expr_list_kind, + tsubst_flags_t); +extern tree build_x_compound_expr_from_vec (VEC(tree,gc) *, const char *); +extern tree build_x_compound_expr (tree, tree, tsubst_flags_t); +extern tree build_compound_expr (location_t, tree, tree); +extern tree cp_build_compound_expr (tree, tree, tsubst_flags_t); +extern tree build_static_cast (tree, tree, tsubst_flags_t); +extern tree build_reinterpret_cast (tree, tree, tsubst_flags_t); +extern tree build_const_cast (tree, tree, tsubst_flags_t); +extern tree build_c_cast (location_t, tree, tree); +extern tree cp_build_c_cast (tree, tree, tsubst_flags_t); +extern tree build_x_modify_expr (tree, enum tree_code, tree, + tsubst_flags_t); +extern tree cp_build_modify_expr (tree, enum tree_code, tree, + tsubst_flags_t); +extern tree convert_for_initialization (tree, tree, tree, int, + impl_conv_rhs, tree, int, + tsubst_flags_t); +extern int comp_ptr_ttypes (tree, tree); +extern bool comp_ptr_ttypes_const (tree, tree); +extern bool error_type_p (const_tree); +extern int ptr_reasonably_similar (const_tree, const_tree); +extern tree build_ptrmemfunc (tree, tree, int, bool, + tsubst_flags_t); +extern int cp_type_quals (const_tree); +extern int type_memfn_quals (const_tree); +extern tree apply_memfn_quals (tree, cp_cv_quals); +extern bool cp_has_mutable_p (const_tree); +extern bool at_least_as_qualified_p (const_tree, const_tree); +extern void cp_apply_type_quals_to_decl (int, tree); +extern tree build_ptrmemfunc1 (tree, tree, tree); +extern void expand_ptrmemfunc_cst (tree, tree *, tree *); +extern tree type_after_usual_arithmetic_conversions (tree, tree); +extern tree common_pointer_type (tree, tree); +extern tree composite_pointer_type (tree, tree, tree, tree, + composite_pointer_operation, + tsubst_flags_t); +extern tree merge_types (tree, tree); +extern tree strip_array_domain (tree); +extern tree check_return_expr (tree, bool *); +extern tree cp_build_binary_op (location_t, + enum tree_code, tree, tree, + tsubst_flags_t); +#define cxx_sizeof(T) cxx_sizeof_or_alignof_type (T, SIZEOF_EXPR, true) +extern tree build_ptrmemfunc_access_expr (tree, tree); +extern tree build_address (tree); +extern tree build_typed_address (tree, tree); +extern tree build_nop (tree, tree); +extern tree non_reference (tree); +extern tree lookup_anon_field (tree, tree); +extern bool invalid_nonstatic_memfn_p (const_tree, tsubst_flags_t); +extern tree convert_member_func_to_ptr (tree, tree); +extern tree convert_ptrmem (tree, tree, bool, bool, + tsubst_flags_t); +extern int lvalue_or_else (tree, enum lvalue_use, + tsubst_flags_t); +extern void check_template_keyword (tree); + +/* in typeck2.c */ +extern void require_complete_eh_spec_types (tree, tree); +extern void cxx_incomplete_type_diagnostic (const_tree, const_tree, diagnostic_t); +#undef cxx_incomplete_type_error +extern void cxx_incomplete_type_error (const_tree, const_tree); +#define cxx_incomplete_type_error(V,T) \ + (cxx_incomplete_type_diagnostic ((V), (T), DK_ERROR)) +extern tree error_not_base_type (tree, tree); +extern tree binfo_or_else (tree, tree); +extern void cxx_readonly_error (tree, enum lvalue_use); +extern void complete_type_check_abstract (tree); +extern int abstract_virtuals_error (tree, tree); + +extern tree store_init_value (tree, tree, int); +extern void check_narrowing (tree, tree); +extern tree digest_init (tree, tree); +extern tree digest_init_flags (tree, tree, int); +extern tree build_scoped_ref (tree, tree, tree *); +extern tree build_x_arrow (tree); +extern tree build_m_component_ref (tree, tree); +extern tree build_functional_cast (tree, tree, tsubst_flags_t); +extern tree add_exception_specifier (tree, tree, int); +extern tree merge_exception_specifiers (tree, tree); + +/* in mangle.c */ +extern void init_mangle (void); +extern void mangle_decl (tree); +extern const char *mangle_type_string (tree); +extern tree mangle_typeinfo_for_type (tree); +extern tree mangle_typeinfo_string_for_type (tree); +extern tree mangle_vtbl_for_type (tree); +extern tree mangle_vtt_for_type (tree); +extern tree mangle_ctor_vtbl_for_type (tree, tree); +extern tree mangle_thunk (tree, int, tree, tree); +extern tree mangle_conv_op_name_for_type (tree); +extern tree mangle_guard_variable (tree); +extern tree mangle_ref_init_variable (tree); + +/* in dump.c */ +extern bool cp_dump_tree (void *, tree); + +/* In cp/cp-objcp-common.c. */ + +extern alias_set_type cxx_get_alias_set (tree); +extern bool cxx_warn_unused_global_decl (const_tree); +extern size_t cp_tree_size (enum tree_code); +extern bool cp_var_mod_type_p (tree, tree); +extern void cxx_initialize_diagnostics (diagnostic_context *); +extern int cxx_types_compatible_p (tree, tree); +extern void init_shadowed_var_for_decl (void); + +/* LIPO support. */ +extern bool cp_is_compiler_generated_type (tree); +extern void cp_clear_global_name_bindings (tree); +extern bool +cp_is_non_sharable_global_decl (tree, void *); +extern void cp_lipo_dup_lang_type (tree, tree); +extern void cp_lipo_copy_lang_type (tree, tree); +extern int cp_get_lang_decl_size (tree); +extern int cp_cmp_lang_type (tree, tree); +extern void cp_add_built_in_decl (tree); +extern void cp_save_built_in_decl_pre_parsing (void); +extern void cp_restore_built_in_decl_pre_parsing (void); +extern void cp_save_built_in_decl_post_parsing (void); +extern void cp_restore_built_in_decl_post_parsing (void); + + +/* in cp-gimplify.c */ +extern int cp_gimplify_expr (tree *, gimple_seq *, + gimple_seq *); +extern void cp_genericize (tree); +extern enum omp_clause_default_kind cxx_omp_predetermined_sharing (tree); +extern tree cxx_omp_clause_default_ctor (tree, tree, tree); +extern tree cxx_omp_clause_copy_ctor (tree, tree, tree); +extern tree cxx_omp_clause_assign_op (tree, tree, tree); +extern tree cxx_omp_clause_dtor (tree, tree); +extern void cxx_omp_finish_clause (tree); +extern bool cxx_omp_privatize_by_reference (const_tree); + +/* in name-lookup.c */ +extern void suggest_alternatives_for (location_t, tree); + +/* -- end of C++ */ + +#endif /* ! GCC_CP_TREE_H */ -- cgit v1.2.3