contrib/gcc-8.0/gcc/cp/cp-tree.h

   1 /* Definitions for C++ parsing and type checking.
   2    Copyright (C) 1987-2018 Free Software Foundation, Inc.
   3    Contributed by Michael Tiemann (tiemann@cygnus.com)
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 3, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #ifndef GCC_CP_TREE_H
  22 #define GCC_CP_TREE_H
  23
  24 #include "tm.h"
  25 #include "hard-reg-set.h"
  26 #include "function.h"
  27
  28 /* In order for the format checking to accept the C++ front end
  29    diagnostic framework extensions, you must include this file before
  30    diagnostic-core.h, not after.  We override the definition of GCC_DIAG_STYLE
  31    in c-common.h.  */
  32 #undef GCC_DIAG_STYLE
  33 #define GCC_DIAG_STYLE __gcc_cxxdiag__
  34 #if defined(GCC_DIAGNOSTIC_CORE_H) || defined (GCC_C_COMMON_H)
  35 #error \
  36 In order for the format checking to accept the C++ front end diagnostic \
  37 framework extensions, you must include this file before diagnostic-core.h and \
  38 c-common.h, not after.
  39 #endif
  40 #include "c-family/c-common.h"
  41 #include "diagnostic.h"
  42
  43 /* A tree node, together with a location, so that we can track locations
  44    (and ranges) during parsing.
  45
  46    The location is redundant for node kinds that have locations,
  47    but not all node kinds do (e.g. constants, and references to
  48    params, locals, etc), so we stash a copy here.  */
  49
  50 class cp_expr
  51 {
  52 public:
  53   cp_expr () :
  54     m_value (NULL), m_loc (UNKNOWN_LOCATION) {}
  55
  56   cp_expr (tree value) :
  57     m_value (value), m_loc (EXPR_LOCATION (m_value)) {}
  58
  59   cp_expr (tree value, location_t loc):
  60     m_value (value), m_loc (loc) {}
  61
  62   cp_expr (const cp_expr &other) :
  63     m_value (other.m_value), m_loc (other.m_loc) {}
  64
  65   /* Implicit conversions to tree.  */
  66   operator tree () const { return m_value; }
  67   tree & operator* () { return m_value; }
  68   tree operator* () const { return m_value; }
  69   tree & operator-> () { return m_value; }
  70   tree operator-> () const { return m_value; }
  71
  72   tree get_value () const { return m_value; }
  73   location_t get_location () const { return m_loc; }
  74   location_t get_start () const
  75   {
  76     source_range src_range = get_range_from_loc (line_table, m_loc);
  77     return src_range.m_start;
  78   }
  79   location_t get_finish () const
  80   {
  81     source_range src_range = get_range_from_loc (line_table, m_loc);
  82     return src_range.m_finish;
  83   }
  84
  85   void set_location (location_t loc)
  86   {
  87     protected_set_expr_location (m_value, loc);
  88     m_loc = loc;
  89   }
  90
  91   void set_range (location_t start, location_t finish)
  92   {
  93     set_location (make_location (m_loc, start, finish));
  94   }
  95
  96   cp_expr& maybe_add_location_wrapper ()
  97   {
  98     m_value = maybe_wrap_with_location (m_value, m_loc);
  99     return *this;
 100   }
 101
 102  private:
 103   tree m_value;
 104   location_t m_loc;
 105 };
 106
 107 inline bool
 108 operator == (const cp_expr &lhs, tree rhs)
 109 {
 110   return lhs.get_value () == rhs;
 111 }
 112
 113 \f
 114 enum cp_tree_index
 115 {
 116     CPTI_WCHAR_DECL,
 117     CPTI_VTABLE_ENTRY_TYPE,
 118     CPTI_DELTA_TYPE,
 119     CPTI_VTABLE_INDEX_TYPE,
 120     CPTI_CLEANUP_TYPE,
 121     CPTI_VTT_PARM_TYPE,
 122
 123     CPTI_CLASS_TYPE,
 124     CPTI_UNKNOWN_TYPE,
 125     CPTI_INIT_LIST_TYPE,
 126     CPTI_VTBL_TYPE,
 127     CPTI_VTBL_PTR_TYPE,
 128     CPTI_STD,
 129     CPTI_ABI,
 130     CPTI_GLOBAL,
 131     CPTI_GLOBAL_TYPE,
 132     CPTI_CONST_TYPE_INFO_TYPE,
 133     CPTI_TYPE_INFO_PTR_TYPE,
 134     CPTI_ABORT_FNDECL,
 135     CPTI_AGGR_TAG,
 136     CPTI_CONV_OP_MARKER,
 137
 138     CPTI_CTOR_IDENTIFIER,
 139     CPTI_COMPLETE_CTOR_IDENTIFIER,
 140     CPTI_BASE_CTOR_IDENTIFIER,
 141     CPTI_DTOR_IDENTIFIER,
 142     CPTI_COMPLETE_DTOR_IDENTIFIER,
 143     CPTI_BASE_DTOR_IDENTIFIER,
 144     CPTI_DELETING_DTOR_IDENTIFIER,
 145     CPTI_CONV_OP_IDENTIFIER,
 146     CPTI_DELTA_IDENTIFIER,
 147     CPTI_IN_CHARGE_IDENTIFIER,
 148     CPTI_VTT_PARM_IDENTIFIER,
 149     CPTI_THIS_IDENTIFIER,
 150     CPTI_PFN_IDENTIFIER,
 151     CPTI_VPTR_IDENTIFIER,
 152     CPTI_GLOBAL_IDENTIFIER,
 153     CPTI_STD_IDENTIFIER,
 154     CPTI_ANON_IDENTIFIER,
 155     CPTI_AUTO_IDENTIFIER,
 156     CPTI_DECLTYPE_AUTO_IDENTIFIER,
 157     CPTI_INIT_LIST_IDENTIFIER,
 158
 159     CPTI_LANG_NAME_C,
 160     CPTI_LANG_NAME_CPLUSPLUS,
 161
 162     CPTI_EMPTY_EXCEPT_SPEC,
 163     CPTI_NOEXCEPT_TRUE_SPEC,
 164     CPTI_NOEXCEPT_FALSE_SPEC,
 165     CPTI_NOEXCEPT_DEFERRED_SPEC,
 166
 167     CPTI_TERMINATE_FN,
 168     CPTI_CALL_UNEXPECTED_FN,
 169     CPTI_GET_EXCEPTION_PTR_FN,
 170     CPTI_BEGIN_CATCH_FN,
 171     CPTI_END_CATCH_FN,
 172     CPTI_ALLOCATE_EXCEPTION_FN,
 173     CPTI_FREE_EXCEPTION_FN,
 174     CPTI_THROW_FN,
 175     CPTI_RETHROW_FN,
 176     CPTI_ATEXIT_FN_PTR_TYPE,
 177     CPTI_ATEXIT,
 178     CPTI_DSO_HANDLE,
 179     CPTI_DCAST,
 180
 181     CPTI_NULLPTR,
 182     CPTI_NULLPTR_TYPE,
 183
 184     CPTI_ALIGN_TYPE,
 185
 186     CPTI_ANY_TARG,
 187
 188     CPTI_MAX
 189 };
 190
 191 extern GTY(()) tree cp_global_trees[CPTI_MAX];
 192
 193 #define wchar_decl_node                 cp_global_trees[CPTI_WCHAR_DECL]
 194 #define vtable_entry_type               cp_global_trees[CPTI_VTABLE_ENTRY_TYPE]
 195 /* The type used to represent an offset by which to adjust the `this'
 196    pointer in pointer-to-member types.  */
 197 #define delta_type_node                 cp_global_trees[CPTI_DELTA_TYPE]
 198 /* The type used to represent an index into the vtable.  */
 199 #define vtable_index_type               cp_global_trees[CPTI_VTABLE_INDEX_TYPE]
 200
 201 #define class_type_node                 cp_global_trees[CPTI_CLASS_TYPE]
 202 #define unknown_type_node               cp_global_trees[CPTI_UNKNOWN_TYPE]
 203 #define init_list_type_node             cp_global_trees[CPTI_INIT_LIST_TYPE]
 204 #define vtbl_type_node                  cp_global_trees[CPTI_VTBL_TYPE]
 205 #define vtbl_ptr_type_node              cp_global_trees[CPTI_VTBL_PTR_TYPE]
 206 #define std_node                        cp_global_trees[CPTI_STD]
 207 #define abi_node                        cp_global_trees[CPTI_ABI]
 208 #define global_namespace                cp_global_trees[CPTI_GLOBAL]
 209 #define global_type_node                cp_global_trees[CPTI_GLOBAL_TYPE]
 210 #define const_type_info_type_node       cp_global_trees[CPTI_CONST_TYPE_INFO_TYPE]
 211 #define type_info_ptr_type              cp_global_trees[CPTI_TYPE_INFO_PTR_TYPE]
 212 #define conv_op_marker                  cp_global_trees[CPTI_CONV_OP_MARKER]
 213 #define abort_fndecl                    cp_global_trees[CPTI_ABORT_FNDECL]
 214 #define current_aggr                    cp_global_trees[CPTI_AGGR_TAG]
 215 #define nullptr_node                    cp_global_trees[CPTI_NULLPTR]
 216 #define nullptr_type_node               cp_global_trees[CPTI_NULLPTR_TYPE]
 217 /* std::align_val_t */
 218 #define align_type_node                 cp_global_trees[CPTI_ALIGN_TYPE]
 219
 220 /* We cache these tree nodes so as to call get_identifier less frequently.
 221    For identifiers for functions, including special member functions such
 222    as ctors and assignment operators, the nodes can be used (among other
 223    things) to iterate over their overloads defined by/for a type.  For
 224    example:
 225
 226      tree ovlid = assign_op_identifier;
 227      tree overloads = get_class_binding (type, ovlid);
 228      for (ovl_iterator it (overloads); it; ++it) { ... }
 229
 230    iterates over the set of implicitly and explicitly defined overloads
 231    of the assignment operator for type (including the copy and move
 232    assignment operators, whether deleted or not).  */
 233
 234 /* The name of a constructor that takes an in-charge parameter to
 235    decide whether or not to construct virtual base classes.  */
 236 #define ctor_identifier                 cp_global_trees[CPTI_CTOR_IDENTIFIER]
 237 /* The name of a constructor that constructs virtual base classes.  */
 238 #define complete_ctor_identifier        cp_global_trees[CPTI_COMPLETE_CTOR_IDENTIFIER]
 239 /* The name of a constructor that does not construct virtual base classes.  */
 240 #define base_ctor_identifier            cp_global_trees[CPTI_BASE_CTOR_IDENTIFIER]
 241 /* The name of a destructor that takes an in-charge parameter to
 242    decide whether or not to destroy virtual base classes and whether
 243    or not to delete the object.  */
 244 #define dtor_identifier                 cp_global_trees[CPTI_DTOR_IDENTIFIER]
 245 /* The name of a destructor that destroys virtual base classes.  */
 246 #define complete_dtor_identifier        cp_global_trees[CPTI_COMPLETE_DTOR_IDENTIFIER]
 247 /* The name of a destructor that does not destroy virtual base
 248    classes.  */
 249 #define base_dtor_identifier            cp_global_trees[CPTI_BASE_DTOR_IDENTIFIER]
 250 /* The name of a destructor that destroys virtual base classes, and
 251    then deletes the entire object.  */
 252 #define deleting_dtor_identifier        cp_global_trees[CPTI_DELETING_DTOR_IDENTIFIER]
 253
 254 #define ovl_op_identifier(ISASS, CODE)  (OVL_OP_INFO(ISASS, CODE)->identifier)
 255 #define assign_op_identifier (ovl_op_info[true][OVL_OP_NOP_EXPR].identifier)
 256 #define call_op_identifier (ovl_op_info[false][OVL_OP_CALL_EXPR].identifier)
 257 /* The name used for conversion operators -- but note that actual
 258    conversion functions use special identifiers outside the identifier
 259    table.  */
 260 #define conv_op_identifier              cp_global_trees[CPTI_CONV_OP_IDENTIFIER]
 261
 262 #define delta_identifier                cp_global_trees[CPTI_DELTA_IDENTIFIER]
 263 #define in_charge_identifier            cp_global_trees[CPTI_IN_CHARGE_IDENTIFIER]
 264 /* The name of the parameter that contains a pointer to the VTT to use
 265    for this subobject constructor or destructor.  */
 266 #define vtt_parm_identifier             cp_global_trees[CPTI_VTT_PARM_IDENTIFIER]
 267 #define this_identifier                 cp_global_trees[CPTI_THIS_IDENTIFIER]
 268 #define pfn_identifier                  cp_global_trees[CPTI_PFN_IDENTIFIER]
 269 #define vptr_identifier                 cp_global_trees[CPTI_VPTR_IDENTIFIER]
 270 /* The name of the ::, std & anon namespaces.  */
 271 #define global_identifier               cp_global_trees[CPTI_GLOBAL_IDENTIFIER]
 272 #define std_identifier                  cp_global_trees[CPTI_STD_IDENTIFIER]
 273 #define anon_identifier                 cp_global_trees[CPTI_ANON_IDENTIFIER]
 274 /* auto and declspec(auto) identifiers.  */
 275 #define auto_identifier                 cp_global_trees[CPTI_AUTO_IDENTIFIER]
 276 #define decltype_auto_identifier        cp_global_trees[CPTI_DECLTYPE_AUTO_IDENTIFIER]
 277 #define init_list_identifier            cp_global_trees[CPTI_INIT_LIST_IDENTIFIER]
 278 #define lang_name_c                     cp_global_trees[CPTI_LANG_NAME_C]
 279 #define lang_name_cplusplus             cp_global_trees[CPTI_LANG_NAME_CPLUSPLUS]
 280
 281 /* Exception specifiers used for throw(), noexcept(true),
 282    noexcept(false) and deferred noexcept.  We rely on these being
 283    uncloned.  */
 284 #define empty_except_spec               cp_global_trees[CPTI_EMPTY_EXCEPT_SPEC]
 285 #define noexcept_true_spec              cp_global_trees[CPTI_NOEXCEPT_TRUE_SPEC]
 286 #define noexcept_false_spec             cp_global_trees[CPTI_NOEXCEPT_FALSE_SPEC]
 287 #define noexcept_deferred_spec          cp_global_trees[CPTI_NOEXCEPT_DEFERRED_SPEC]
 288
 289 /* Exception handling function declarations.  */
 290 #define terminate_fn                    cp_global_trees[CPTI_TERMINATE_FN]
 291 #define call_unexpected_fn              cp_global_trees[CPTI_CALL_UNEXPECTED_FN]
 292 #define get_exception_ptr_fn            cp_global_trees[CPTI_GET_EXCEPTION_PTR_FN]
 293 #define begin_catch_fn                  cp_global_trees[CPTI_BEGIN_CATCH_FN]
 294 #define end_catch_fn                    cp_global_trees[CPTI_END_CATCH_FN]
 295 #define allocate_exception_fn           cp_global_trees[CPTI_ALLOCATE_EXCEPTION_FN]
 296 #define free_exception_fn               cp_global_trees[CPTI_FREE_EXCEPTION_FN]
 297 #define throw_fn                        cp_global_trees[CPTI_THROW_FN]
 298 #define rethrow_fn                      cp_global_trees[CPTI_RETHROW_FN]
 299
 300 /* The type of the function-pointer argument to "__cxa_atexit" (or
 301    "std::atexit", if "__cxa_atexit" is not being used).  */
 302 #define atexit_fn_ptr_type_node         cp_global_trees[CPTI_ATEXIT_FN_PTR_TYPE]
 303
 304 /* A pointer to `std::atexit'.  */
 305 #define atexit_node                     cp_global_trees[CPTI_ATEXIT]
 306
 307 /* A pointer to `__dso_handle'.  */
 308 #define dso_handle_node                 cp_global_trees[CPTI_DSO_HANDLE]
 309
 310 /* The declaration of the dynamic_cast runtime.  */
 311 #define dynamic_cast_node               cp_global_trees[CPTI_DCAST]
 312
 313 /* The type of a destructor.  */
 314 #define cleanup_type                    cp_global_trees[CPTI_CLEANUP_TYPE]
 315
 316 /* The type of the vtt parameter passed to subobject constructors and
 317    destructors.  */
 318 #define vtt_parm_type                   cp_global_trees[CPTI_VTT_PARM_TYPE]
 319
 320 /* A node which matches any template argument.  */
 321 #define any_targ_node                   cp_global_trees[CPTI_ANY_TARG]
 322
 323 /* Node to indicate default access. This must be distinct from the
 324    access nodes in tree.h.  */
 325
 326 #define access_default_node             null_node
 327
 328 \f
 329 #include "name-lookup.h"
 330
 331 /* Usage of TREE_LANG_FLAG_?:
 332    0: IDENTIFIER_KIND_BIT_0 (in IDENTIFIER_NODE)
 333       NEW_EXPR_USE_GLOBAL (in NEW_EXPR).
 334       COND_EXPR_IS_VEC_DELETE (in COND_EXPR).
 335       DELETE_EXPR_USE_GLOBAL (in DELETE_EXPR).
 336       COMPOUND_EXPR_OVERLOADED (in COMPOUND_EXPR).
 337       CLEANUP_P (in TRY_BLOCK)
 338       AGGR_INIT_VIA_CTOR_P (in AGGR_INIT_EXPR)
 339       PTRMEM_OK_P (in ADDR_EXPR, OFFSET_REF, SCOPE_REF)
 340       PAREN_STRING_LITERAL (in STRING_CST)
 341       CP_DECL_THREAD_LOCAL_P (in VAR_DECL)
 342       KOENIG_LOOKUP_P (in CALL_EXPR)
 343       STATEMENT_LIST_NO_SCOPE (in STATEMENT_LIST).
 344       EXPR_STMT_STMT_EXPR_RESULT (in EXPR_STMT)
 345       STMT_EXPR_NO_SCOPE (in STMT_EXPR)
 346       BIND_EXPR_TRY_BLOCK (in BIND_EXPR)
 347       TYPENAME_IS_ENUM_P (in TYPENAME_TYPE)
 348       OMP_FOR_GIMPLIFYING_P (in OMP_FOR, OMP_SIMD, OMP_DISTRIBUTE,
 349                              and OMP_TASKLOOP)
 350       BASELINK_QUALIFIED_P (in BASELINK)
 351       TARGET_EXPR_IMPLICIT_P (in TARGET_EXPR)
 352       TEMPLATE_PARM_PARAMETER_PACK (in TEMPLATE_PARM_INDEX)
 353       ATTR_IS_DEPENDENT (in the TREE_LIST for an attribute)
 354       ABI_TAG_IMPLICIT (in the TREE_LIST for the argument of abi_tag)
 355       LAMBDA_CAPTURE_EXPLICIT_P (in a TREE_LIST in LAMBDA_EXPR_CAPTURE_LIST)
 356       CONSTRUCTOR_IS_DIRECT_INIT (in CONSTRUCTOR)
 357       LAMBDA_EXPR_CAPTURES_THIS_P (in LAMBDA_EXPR)
 358       DECLTYPE_FOR_LAMBDA_CAPTURE (in DECLTYPE_TYPE)
 359       VEC_INIT_EXPR_IS_CONSTEXPR (in VEC_INIT_EXPR)
 360       DECL_OVERRIDE_P (in FUNCTION_DECL)
 361       IMPLICIT_CONV_EXPR_DIRECT_INIT (in IMPLICIT_CONV_EXPR)
 362       TRANSACTION_EXPR_IS_STMT (in TRANSACTION_EXPR)
 363       CONVERT_EXPR_VBASE_PATH (in CONVERT_EXPR)
 364       PACK_EXPANSION_LOCAL_P (in *_PACK_EXPANSION)
 365       TINFO_HAS_ACCESS_ERRORS (in TEMPLATE_INFO)
 366       SIZEOF_EXPR_TYPE_P (in SIZEOF_EXPR)
 367       COMPOUND_REQ_NOEXCEPT_P (in COMPOUND_REQ)
 368       WILDCARD_PACK_P (in WILDCARD_DECL)
 369       BLOCK_OUTER_CURLY_BRACE_P (in BLOCK)
 370       FOLD_EXPR_MODOP_P (*_FOLD_EXPR)
 371       IF_STMT_CONSTEXPR_P (IF_STMT)
 372       TEMPLATE_TYPE_PARM_FOR_CLASS (TEMPLATE_TYPE_PARM)
 373       DECL_NAMESPACE_INLINE_P (in NAMESPACE_DECL)
 374       SWITCH_STMT_ALL_CASES_P (in SWITCH_STMT)
 375       REINTERPRET_CAST_P (in NOP_EXPR)
 376       ALIGNOF_EXPR_STD_P (in ALIGNOF_EXPR)
 377    1: IDENTIFIER_KIND_BIT_1 (in IDENTIFIER_NODE)
 378       TI_PENDING_TEMPLATE_FLAG.
 379       TEMPLATE_PARMS_FOR_INLINE.
 380       DELETE_EXPR_USE_VEC (in DELETE_EXPR).
 381       (TREE_CALLS_NEW) (in _EXPR or _REF) (commented-out).
 382       ICS_ELLIPSIS_FLAG (in _CONV)
 383       DECL_INITIALIZED_P (in VAR_DECL)
 384       TYPENAME_IS_CLASS_P (in TYPENAME_TYPE)
 385       STMT_IS_FULL_EXPR_P (in _STMT)
 386       TARGET_EXPR_LIST_INIT_P (in TARGET_EXPR)
 387       LAMBDA_EXPR_MUTABLE_P (in LAMBDA_EXPR)
 388       DECL_FINAL_P (in FUNCTION_DECL)
 389       QUALIFIED_NAME_IS_TEMPLATE (in SCOPE_REF)
 390       DECLTYPE_FOR_INIT_CAPTURE (in DECLTYPE_TYPE)
 391       CONSTRUCTOR_NO_IMPLICIT_ZERO (in CONSTRUCTOR)
 392       TINFO_USED_TEMPLATE_ID (in TEMPLATE_INFO)
 393       PACK_EXPANSION_SIZEOF_P (in *_PACK_EXPANSION)
 394       OVL_USING_P (in OVERLOAD)
 395       IMPLICIT_CONV_EXPR_NONTYPE_ARG (in IMPLICIT_CONV_EXPR)
 396    2: IDENTIFIER_KIND_BIT_2 (in IDENTIFIER_NODE)
 397       ICS_THIS_FLAG (in _CONV)
 398       DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (in VAR_DECL)
 399       STATEMENT_LIST_TRY_BLOCK (in STATEMENT_LIST)
 400       TYPENAME_IS_RESOLVING_P (in TYPE_NAME_TYPE)
 401       TARGET_EXPR_DIRECT_INIT_P (in TARGET_EXPR)
 402       FNDECL_USED_AUTO (in FUNCTION_DECL)
 403       DECLTYPE_FOR_LAMBDA_PROXY (in DECLTYPE_TYPE)
 404       REF_PARENTHESIZED_P (in COMPONENT_REF, INDIRECT_REF, SCOPE_REF)
 405       AGGR_INIT_ZERO_FIRST (in AGGR_INIT_EXPR)
 406       CONSTRUCTOR_MUTABLE_POISON (in CONSTRUCTOR)
 407       OVL_HIDDEN_P (in OVERLOAD)
 408       SWITCH_STMT_NO_BREAK_P (in SWITCH_STMT)
 409       LAMBDA_EXPR_CAPTURE_OPTIMIZED (in LAMBDA_EXPR)
 410    3: (TREE_REFERENCE_EXPR) (in NON_LVALUE_EXPR) (commented-out).
 411       ICS_BAD_FLAG (in _CONV)
 412       FN_TRY_BLOCK_P (in TRY_BLOCK)
 413       BIND_EXPR_BODY_BLOCK (in BIND_EXPR)
 414       DECL_NONTRIVIALLY_INITIALIZED_P (in VAR_DECL)
 415       CALL_EXPR_ORDERED_ARGS (in CALL_EXPR, AGGR_INIT_EXPR)
 416       DECLTYPE_FOR_REF_CAPTURE (in DECLTYPE_TYPE)
 417       CONSTRUCTOR_C99_COMPOUND_LITERAL (in CONSTRUCTOR)
 418       OVL_NESTED_P (in OVERLOAD)
 419    4: IDENTIFIER_MARKED (IDENTIFIER_NODEs)
 420       TREE_HAS_CONSTRUCTOR (in INDIRECT_REF, SAVE_EXPR, CONSTRUCTOR,
 421           CALL_EXPR, or FIELD_DECL).
 422       DECL_TINFO_P (in VAR_DECL)
 423       FUNCTION_REF_QUALIFIED (in FUNCTION_TYPE, METHOD_TYPE)
 424       OVL_LOOKUP_P (in OVERLOAD)
 425       LOOKUP_FOUND_P (in RECORD_TYPE, UNION_TYPE, NAMESPACE_DECL)
 426    5: IDENTIFIER_VIRTUAL_P (in IDENTIFIER_NODE)
 427       DECL_VTABLE_OR_VTT_P (in VAR_DECL)
 428       FUNCTION_RVALUE_QUALIFIED (in FUNCTION_TYPE, METHOD_TYPE)
 429       CALL_EXPR_REVERSE_ARGS (in CALL_EXPR, AGGR_INIT_EXPR)
 430       CONSTRUCTOR_PLACEHOLDER_BOUNDARY (in CONSTRUCTOR)
 431    6: IDENTIFIER_REPO_CHOSEN (in IDENTIFIER_NODE)
 432       DECL_CONSTRUCTION_VTABLE_P (in VAR_DECL)
 433       TYPE_MARKED_P (in _TYPE)
 434       RANGE_FOR_IVDEP (in RANGE_FOR_STMT)
 435       CALL_EXPR_OPERATOR_SYNTAX (in CALL_EXPR, AGGR_INIT_EXPR)
 436
 437    Usage of TYPE_LANG_FLAG_?:
 438    0: TYPE_DEPENDENT_P
 439    1: TYPE_HAS_USER_CONSTRUCTOR.
 440    2: TYPE_HAS_LATE_RETURN_TYPE (in FUNCTION_TYPE, METHOD_TYPE)
 441       TYPE_PTRMEMFUNC_FLAG (in RECORD_TYPE)
 442    4: TYPE_HAS_NONTRIVIAL_DESTRUCTOR
 443    5: CLASS_TYPE_P (in RECORD_TYPE and UNION_TYPE)
 444       ENUM_FIXED_UNDERLYING_TYPE_P (in ENUMERAL_TYPE)
 445       AUTO_IS_DECLTYPE (in TEMPLATE_TYPE_PARM)
 446       REFERENCE_VLA_OK (in REFERENCE_TYPE)
 447    6: TYPE_DEPENDENT_P_VALID
 448
 449    Usage of DECL_LANG_FLAG_?:
 450    0: DECL_ERROR_REPORTED (in VAR_DECL).
 451       DECL_TEMPLATE_PARM_P (in PARM_DECL, CONST_DECL, TYPE_DECL, or TEMPLATE_DECL)
 452       DECL_LOCAL_FUNCTION_P (in FUNCTION_DECL)
 453       DECL_MUTABLE_P (in FIELD_DECL)
 454       DECL_DEPENDENT_P (in USING_DECL)
 455       LABEL_DECL_BREAK (in LABEL_DECL)
 456    1: C_TYPEDEF_EXPLICITLY_SIGNED (in TYPE_DECL).
 457       DECL_TEMPLATE_INSTANTIATED (in a VAR_DECL or a FUNCTION_DECL)
 458       DECL_MEMBER_TEMPLATE_P (in TEMPLATE_DECL)
 459       USING_DECL_TYPENAME_P (in USING_DECL)
 460       DECL_VLA_CAPTURE_P (in FIELD_DECL)
 461       DECL_ARRAY_PARAMETER_P (in PARM_DECL)
 462       LABEL_DECL_CONTINUE (in LABEL_DECL)
 463    2: DECL_THIS_EXTERN (in VAR_DECL or FUNCTION_DECL).
 464       DECL_IMPLICIT_TYPEDEF_P (in a TYPE_DECL)
 465       DECL_CONSTRAINT_VAR_P (in a PARM_DECL)
 466       TEMPLATE_DECL_COMPLEX_ALIAS_P (in TEMPLATE_DECL)
 467       DECL_INSTANTIATING_NSDMI_P (in a FIELD_DECL)
 468       LABEL_DECL_CDTOR (in LABEL_DECL)
 469    3: DECL_IN_AGGR_P.
 470    4: DECL_C_BIT_FIELD (in a FIELD_DECL)
 471       DECL_ANON_UNION_VAR_P (in a VAR_DECL)
 472       DECL_SELF_REFERENCE_P (in a TYPE_DECL)
 473       DECL_INVALID_OVERRIDER_P (in a FUNCTION_DECL)
 474    5: DECL_INTERFACE_KNOWN.
 475    6: DECL_THIS_STATIC (in VAR_DECL or FUNCTION_DECL).
 476       DECL_FIELD_IS_BASE (in FIELD_DECL)
 477       TYPE_DECL_ALIAS_P (in TYPE_DECL)
 478    7: DECL_DEAD_FOR_LOCAL (in VAR_DECL).
 479       DECL_THUNK_P (in a member FUNCTION_DECL)
 480       DECL_NORMAL_CAPTURE_P (in FIELD_DECL)
 481    8: DECL_DECLARED_CONSTEXPR_P (in VAR_DECL, FUNCTION_DECL)
 482
 483    Usage of language-independent fields in a language-dependent manner:
 484
 485    TYPE_ALIAS_SET
 486      This field is used by TYPENAME_TYPEs, TEMPLATE_TYPE_PARMs, and so
 487      forth as a substitute for the mark bits provided in `lang_type'.
 488      At present, only the six low-order bits are used.
 489
 490    TYPE_LANG_SLOT_1
 491      For a FUNCTION_TYPE or METHOD_TYPE, this is TYPE_RAISES_EXCEPTIONS.
 492      For a POINTER_TYPE (to a METHOD_TYPE), this is TYPE_PTRMEMFUNC_TYPE.
 493      For an ENUMERAL_TYPE, BOUND_TEMPLATE_TEMPLATE_PARM_TYPE,
 494      RECORD_TYPE or UNION_TYPE this is TYPE_TEMPLATE_INFO,
 495
 496   BINFO_VIRTUALS
 497      For a binfo, this is a TREE_LIST.  There is an entry for each
 498      virtual function declared either in BINFO or its direct and
 499      indirect primary bases.
 500
 501      The BV_DELTA of each node gives the amount by which to adjust the
 502      `this' pointer when calling the function.  If the method is an
 503      overridden version of a base class method, then it is assumed
 504      that, prior to adjustment, the this pointer points to an object
 505      of the base class.
 506
 507      The BV_VCALL_INDEX of each node, if non-NULL, gives the vtable
 508      index of the vcall offset for this entry.
 509
 510      The BV_FN is the declaration for the virtual function itself.
 511
 512      If BV_LOST_PRIMARY is set, it means that this entry is for a lost
 513      primary virtual base and can be left null in the vtable.
 514
 515    BINFO_VTABLE
 516      This is an expression with POINTER_TYPE that gives the value
 517      to which the vptr should be initialized.  Use get_vtbl_decl_for_binfo
 518      to extract the VAR_DECL for the complete vtable.
 519
 520    DECL_VINDEX
 521      This field is NULL for a non-virtual function.  For a virtual
 522      function, it is eventually set to an INTEGER_CST indicating the
 523      index in the vtable at which this function can be found.  When
 524      a virtual function is declared, but before it is known what
 525      function is overridden, this field is the error_mark_node.
 526
 527      Temporarily, it may be set to a TREE_LIST whose TREE_VALUE is
 528      the virtual function this one overrides, and whose TREE_CHAIN is
 529      the old DECL_VINDEX.  */
 530
 531 /* Language-specific tree checkers.  */
 532
 533 #define VAR_OR_FUNCTION_DECL_CHECK(NODE) \
 534   TREE_CHECK2(NODE,VAR_DECL,FUNCTION_DECL)
 535
 536 #define TYPE_FUNCTION_OR_TEMPLATE_DECL_CHECK(NODE) \
 537   TREE_CHECK3(NODE,TYPE_DECL,TEMPLATE_DECL,FUNCTION_DECL)
 538
 539 #define TYPE_FUNCTION_OR_TEMPLATE_DECL_P(NODE) \
 540   (TREE_CODE (NODE) == TYPE_DECL || TREE_CODE (NODE) == TEMPLATE_DECL \
 541    || TREE_CODE (NODE) == FUNCTION_DECL)
 542
 543 #define VAR_FUNCTION_OR_PARM_DECL_CHECK(NODE) \
 544   TREE_CHECK3(NODE,VAR_DECL,FUNCTION_DECL,PARM_DECL)
 545
 546 #define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) \
 547   TREE_CHECK4(NODE,VAR_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL)
 548
 549 #define VAR_TEMPL_TYPE_FIELD_OR_FUNCTION_DECL_CHECK(NODE) \
 550   TREE_CHECK5(NODE,VAR_DECL,FIELD_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL)
 551
 552 #define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) \
 553   TREE_CHECK(NODE,BOUND_TEMPLATE_TEMPLATE_PARM)
 554
 555 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
 556 #define THUNK_FUNCTION_CHECK(NODE) __extension__                        \
 557 ({  __typeof (NODE) const __t = (NODE);                                 \
 558     if (TREE_CODE (__t) != FUNCTION_DECL || !__t->decl_common.lang_specific \
 559         || !__t->decl_common.lang_specific->u.fn.thunk_p)               \
 560       tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, 0);     \
 561      __t; })
 562 #else
 563 #define THUNK_FUNCTION_CHECK(NODE) (NODE)
 564 #endif
 565 \f
 566 /* Language-dependent contents of an identifier.  */
 567
 568 struct GTY(()) lang_identifier {
 569   struct c_common_identifier c_common;
 570   cxx_binding *bindings;
 571 };
 572
 573 /* Return a typed pointer version of T if it designates a
 574    C++ front-end identifier.  */
 575 inline lang_identifier*
 576 identifier_p (tree t)
 577 {
 578   if (TREE_CODE (t) == IDENTIFIER_NODE)
 579     return (lang_identifier*) t;
 580   return NULL;
 581 }
 582
 583 #define LANG_IDENTIFIER_CAST(NODE) \
 584         ((struct lang_identifier*)IDENTIFIER_NODE_CHECK (NODE))
 585
 586 struct GTY(()) template_parm_index {
 587   struct tree_common common;
 588   int index;
 589   int level;
 590   int orig_level;
 591   tree decl;
 592 };
 593
 594 struct GTY(()) ptrmem_cst {
 595   struct tree_common common;
 596   tree member;
 597 };
 598 typedef struct ptrmem_cst * ptrmem_cst_t;
 599
 600 #define CLEANUP_P(NODE)         TREE_LANG_FLAG_0 (TRY_BLOCK_CHECK (NODE))
 601
 602 #define BIND_EXPR_TRY_BLOCK(NODE) \
 603   TREE_LANG_FLAG_0 (BIND_EXPR_CHECK (NODE))
 604
 605 /* Used to mark the block around the member initializers and cleanups.  */
 606 #define BIND_EXPR_BODY_BLOCK(NODE) \
 607   TREE_LANG_FLAG_3 (BIND_EXPR_CHECK (NODE))
 608 #define FUNCTION_NEEDS_BODY_BLOCK(NODE) \
 609   (DECL_CONSTRUCTOR_P (NODE) || DECL_DESTRUCTOR_P (NODE) \
 610    || LAMBDA_FUNCTION_P (NODE))
 611
 612 #define STATEMENT_LIST_NO_SCOPE(NODE) \
 613   TREE_LANG_FLAG_0 (STATEMENT_LIST_CHECK (NODE))
 614 #define STATEMENT_LIST_TRY_BLOCK(NODE) \
 615   TREE_LANG_FLAG_2 (STATEMENT_LIST_CHECK (NODE))
 616
 617 /* Mark the outer curly brace BLOCK.  */
 618 #define BLOCK_OUTER_CURLY_BRACE_P(NODE) TREE_LANG_FLAG_0 (BLOCK_CHECK (NODE))
 619
 620 /* Nonzero if this statement should be considered a full-expression,
 621    i.e., if temporaries created during this statement should have
 622    their destructors run at the end of this statement.  */
 623 #define STMT_IS_FULL_EXPR_P(NODE) TREE_LANG_FLAG_1 ((NODE))
 624
 625 /* Marks the result of a statement expression.  */
 626 #define EXPR_STMT_STMT_EXPR_RESULT(NODE) \
 627   TREE_LANG_FLAG_0 (EXPR_STMT_CHECK (NODE))
 628
 629 /* Nonzero if this statement-expression does not have an associated scope.  */
 630 #define STMT_EXPR_NO_SCOPE(NODE) \
 631    TREE_LANG_FLAG_0 (STMT_EXPR_CHECK (NODE))
 632
 633 #define COND_EXPR_IS_VEC_DELETE(NODE) \
 634   TREE_LANG_FLAG_0 (COND_EXPR_CHECK (NODE))
 635
 636 /* Nonzero if this NOP_EXPR is a reinterpret_cast.  Such conversions
 637    are not constexprs.  Other NOP_EXPRs are.  */
 638 #define REINTERPRET_CAST_P(NODE)                \
 639   TREE_LANG_FLAG_0 (NOP_EXPR_CHECK (NODE))
 640
 641 /* Returns nonzero iff TYPE1 and TYPE2 are the same type, in the usual
 642    sense of `same'.  */
 643 #define same_type_p(TYPE1, TYPE2) \
 644   comptypes ((TYPE1), (TYPE2), COMPARE_STRICT)
 645
 646 /* Returns nonzero iff NODE is a declaration for the global function
 647    `main'.  */
 648 #define DECL_MAIN_P(NODE)                               \
 649    (DECL_EXTERN_C_FUNCTION_P (NODE)                     \
 650     && DECL_NAME (NODE) != NULL_TREE                    \
 651     && MAIN_NAME_P (DECL_NAME (NODE))                   \
 652     && flag_hosted)
 653
 654 /* Lookup walker marking.  */
 655 #define LOOKUP_SEEN_P(NODE) TREE_VISITED(NODE)
 656 #define LOOKUP_FOUND_P(NODE) \
 657   TREE_LANG_FLAG_4 (TREE_CHECK3(NODE,RECORD_TYPE,UNION_TYPE,NAMESPACE_DECL))
 658
 659 /* These two accessors should only be used by OVL manipulators.
 660    Other users should use iterators and convenience functions.  */
 661 #define OVL_FUNCTION(NODE) \
 662   (((struct tree_overload*)OVERLOAD_CHECK (NODE))->function)
 663 #define OVL_CHAIN(NODE) \
 664   (((struct tree_overload*)OVERLOAD_CHECK (NODE))->common.chain)
 665
 666 /* If set, this was imported in a using declaration.   */
 667 #define OVL_USING_P(NODE)       TREE_LANG_FLAG_1 (OVERLOAD_CHECK (NODE))
 668 /* If set, this overload is a hidden decl.  */
 669 #define OVL_HIDDEN_P(NODE)      TREE_LANG_FLAG_2 (OVERLOAD_CHECK (NODE))
 670 /* If set, this overload contains a nested overload.  */
 671 #define OVL_NESTED_P(NODE)      TREE_LANG_FLAG_3 (OVERLOAD_CHECK (NODE))
 672 /* If set, this overload was constructed during lookup.  */
 673 #define OVL_LOOKUP_P(NODE)      TREE_LANG_FLAG_4 (OVERLOAD_CHECK (NODE))
 674 /* If set, this is a persistant lookup. */
 675 #define OVL_USED_P(NODE)        TREE_USED (OVERLOAD_CHECK (NODE))
 676
 677 /* The first decl of an overload.  */
 678 #define OVL_FIRST(NODE) ovl_first (NODE)
 679 /* The name of the overload set.  */
 680 #define OVL_NAME(NODE) DECL_NAME (OVL_FIRST (NODE))
 681
 682 /* Whether this is a set of overloaded functions.  TEMPLATE_DECLS are
 683    always wrapped in an OVERLOAD, so we don't need to check them
 684    here.  */
 685 #define OVL_P(NODE) \
 686   (TREE_CODE (NODE) == FUNCTION_DECL || TREE_CODE (NODE) == OVERLOAD)
 687 /* Whether this is a single member overload.  */
 688 #define OVL_SINGLE_P(NODE) \
 689   (TREE_CODE (NODE) != OVERLOAD || !OVL_CHAIN (NODE))
 690
 691 /* OVL_HIDDEN_P nodes come first, then OVL_USING_P nodes, then regular
 692    fns.  */
 693
 694 struct GTY(()) tree_overload {
 695   struct tree_common common;
 696   tree function;
 697 };
 698
 699 /* Iterator for a 1 dimensional overload.  Permits iterating over the
 700    outer level of a 2-d overload when explicitly enabled.  */
 701
 702 class ovl_iterator
 703 {
 704   tree ovl;
 705   const bool allow_inner; /* Only used when checking.  */
 706
 707  public:
 708   explicit ovl_iterator (tree o, bool allow = false)
 709     : ovl (o), allow_inner (allow)
 710   {
 711   }
 712
 713  private:
 714   /* Do not duplicate.  */
 715   ovl_iterator &operator= (const ovl_iterator &);
 716   ovl_iterator (const ovl_iterator &);
 717
 718  public:
 719   operator bool () const
 720   {
 721     return ovl;
 722   }
 723   ovl_iterator &operator++ ()
 724   {
 725     ovl = TREE_CODE (ovl) != OVERLOAD ? NULL_TREE : OVL_CHAIN (ovl);
 726     return *this;
 727   }
 728   tree operator* () const
 729   {
 730     tree fn = TREE_CODE (ovl) != OVERLOAD ? ovl : OVL_FUNCTION (ovl);
 731
 732     /* Check this is not an unexpected 2-dimensional overload.  */
 733     gcc_checking_assert (allow_inner || TREE_CODE (fn) != OVERLOAD);
 734
 735     return fn;
 736   }
 737
 738  public:
 739   /* Whether this overload was introduced by a using decl.  */
 740   bool using_p () const
 741   {
 742     return TREE_CODE (ovl) == OVERLOAD && OVL_USING_P (ovl);
 743   }
 744   bool hidden_p () const
 745   {
 746     return TREE_CODE (ovl) == OVERLOAD && OVL_HIDDEN_P (ovl);
 747   }
 748
 749  public:
 750   tree remove_node (tree head)
 751   {
 752     return remove_node (head, ovl);
 753   }
 754   tree reveal_node (tree head)
 755   {
 756     return reveal_node (head, ovl);
 757   }
 758
 759  protected:
 760   /* If we have a nested overload, point at the inner overload and
 761      return the next link on the outer one.  */
 762   tree maybe_push ()
 763   {
 764     tree r = NULL_TREE;
 765
 766     if (ovl && TREE_CODE (ovl) == OVERLOAD && OVL_NESTED_P (ovl))
 767       {
 768         r = OVL_CHAIN (ovl);
 769         ovl = OVL_FUNCTION (ovl);
 770       }
 771     return r;
 772   }
 773   /* Restore an outer nested overload.  */
 774   void pop (tree outer)
 775   {
 776     gcc_checking_assert (!ovl);
 777     ovl = outer;
 778   }
 779
 780  private:
 781   /* We make these static functions to avoid the address of the
 782      iterator escaping the local context.  */
 783   static tree remove_node (tree head, tree node);
 784   static tree reveal_node (tree ovl, tree node);
 785 };
 786
 787 /* Iterator over a (potentially) 2 dimensional overload, which is
 788    produced by name lookup.  */
 789
 790 class lkp_iterator : public ovl_iterator
 791 {
 792   typedef ovl_iterator parent;
 793
 794   tree outer;
 795
 796  public:
 797   explicit lkp_iterator (tree o)
 798     : parent (o, true), outer (maybe_push ())
 799   {
 800   }
 801
 802  public:
 803   lkp_iterator &operator++ ()
 804   {
 805     bool repush = !outer;
 806
 807     if (!parent::operator++ () && !repush)
 808       {
 809         pop (outer);
 810         repush = true;
 811       }
 812
 813     if (repush)
 814       outer = maybe_push ();
 815
 816     return *this;
 817   }
 818 };
 819
 820 /* hash traits for declarations.  Hashes potential overload sets via
 821    DECL_NAME.  */
 822
 823 struct named_decl_hash : ggc_remove <tree>
 824 {
 825   typedef tree value_type; /* A DECL or OVERLOAD  */
 826   typedef tree compare_type; /* An identifier.  */
 827
 828   inline static hashval_t hash (const value_type decl);
 829   inline static bool equal (const value_type existing, compare_type candidate);
 830
 831   static inline void mark_empty (value_type &p) {p = NULL_TREE;}
 832   static inline bool is_empty (value_type p) {return !p;}
 833
 834   /* Nothing is deletable.  Everything is insertable.  */
 835   static bool is_deleted (value_type) { return false; }
 836   static void mark_deleted (value_type) { gcc_unreachable (); }
 837 };
 838
 839 struct GTY(()) tree_template_decl {
 840   struct tree_decl_common common;
 841   tree arguments;
 842   tree result;
 843 };
 844
 845 /* Returns true iff NODE is a BASELINK.  */
 846 #define BASELINK_P(NODE) \
 847   (TREE_CODE (NODE) == BASELINK)
 848 /* The BINFO indicating the base in which lookup found the
 849    BASELINK_FUNCTIONS.  */
 850 #define BASELINK_BINFO(NODE) \
 851   (((struct tree_baselink*) BASELINK_CHECK (NODE))->binfo)
 852 /* The functions referred to by the BASELINK; either a FUNCTION_DECL,
 853    a TEMPLATE_DECL, an OVERLOAD, or a TEMPLATE_ID_EXPR.  */
 854 #define BASELINK_FUNCTIONS(NODE) \
 855   (((struct tree_baselink*) BASELINK_CHECK (NODE))->functions)
 856 /* If T is a BASELINK, grab the functions, otherwise just T, which is
 857    expected to already be a (list of) functions.  */
 858 #define MAYBE_BASELINK_FUNCTIONS(T) \
 859   (BASELINK_P (T) ? BASELINK_FUNCTIONS (T) : T)
 860 /* The BINFO in which the search for the functions indicated by this baselink
 861    began.  This base is used to determine the accessibility of functions
 862    selected by overload resolution.  */
 863 #define BASELINK_ACCESS_BINFO(NODE) \
 864   (((struct tree_baselink*) BASELINK_CHECK (NODE))->access_binfo)
 865 /* For a type-conversion operator, the BASELINK_OPTYPE indicates the type
 866    to which the conversion should occur.  This value is important if
 867    the BASELINK_FUNCTIONS include a template conversion operator --
 868    the BASELINK_OPTYPE can be used to determine what type the user
 869    requested.  */
 870 #define BASELINK_OPTYPE(NODE) \
 871   (TREE_CHAIN (BASELINK_CHECK (NODE)))
 872 /* Nonzero if this baselink was from a qualified lookup.  */
 873 #define BASELINK_QUALIFIED_P(NODE) \
 874   TREE_LANG_FLAG_0 (BASELINK_CHECK (NODE))
 875
 876 struct GTY(()) tree_baselink {
 877   struct tree_common common;
 878   tree binfo;
 879   tree functions;
 880   tree access_binfo;
 881 };
 882
 883 /* The different kinds of ids that we encounter.  */
 884
 885 enum cp_id_kind
 886 {
 887   /* Not an id at all.  */
 888   CP_ID_KIND_NONE,
 889   /* An unqualified-id that is not a template-id.  */
 890   CP_ID_KIND_UNQUALIFIED,
 891   /* An unqualified-id that is a dependent name.  */
 892   CP_ID_KIND_UNQUALIFIED_DEPENDENT,
 893   /* An unqualified template-id.  */
 894   CP_ID_KIND_TEMPLATE_ID,
 895   /* A qualified-id.  */
 896   CP_ID_KIND_QUALIFIED
 897 };
 898
 899
 900 /* The various kinds of C++0x warnings we encounter. */
 901
 902 enum cpp0x_warn_str
 903 {
 904   /* extended initializer lists */
 905   CPP0X_INITIALIZER_LISTS,
 906   /* explicit conversion operators */
 907   CPP0X_EXPLICIT_CONVERSION,
 908   /* variadic templates */
 909   CPP0X_VARIADIC_TEMPLATES,
 910   /* lambda expressions */
 911   CPP0X_LAMBDA_EXPR,
 912   /* C++0x auto */
 913   CPP0X_AUTO,
 914   /* scoped enums */
 915   CPP0X_SCOPED_ENUMS,
 916   /* defaulted and deleted functions */
 917   CPP0X_DEFAULTED_DELETED,
 918   /* inline namespaces */
 919   CPP0X_INLINE_NAMESPACES,
 920   /* override controls, override/final */
 921   CPP0X_OVERRIDE_CONTROLS,
 922   /* non-static data member initializers */
 923   CPP0X_NSDMI,
 924   /* user defined literals */
 925   CPP0X_USER_DEFINED_LITERALS,
 926   /* delegating constructors */
 927   CPP0X_DELEGATING_CTORS,
 928   /* inheriting constructors */
 929   CPP0X_INHERITING_CTORS,
 930   /* C++11 attributes */
 931   CPP0X_ATTRIBUTES,
 932   /* ref-qualified member functions */
 933   CPP0X_REF_QUALIFIER
 934 };
 935
 936 /* The various kinds of operation used by composite_pointer_type. */
 937
 938 enum composite_pointer_operation
 939 {
 940   /* comparison */
 941   CPO_COMPARISON,
 942   /* conversion */
 943   CPO_CONVERSION,
 944   /* conditional expression */
 945   CPO_CONDITIONAL_EXPR
 946 };
 947
 948 /* Possible cases of expression list used by build_x_compound_expr_from_list. */
 949 enum expr_list_kind {
 950   ELK_INIT,             /* initializer */
 951   ELK_MEM_INIT,         /* member initializer */
 952   ELK_FUNC_CAST         /* functional cast */
 953 };
 954
 955 /* Possible cases of implicit bad rhs conversions. */
 956 enum impl_conv_rhs {
 957   ICR_DEFAULT_ARGUMENT, /* default argument */
 958   ICR_CONVERTING,       /* converting */
 959   ICR_INIT,             /* initialization */
 960   ICR_ARGPASS,          /* argument passing */
 961   ICR_RETURN,           /* return */
 962   ICR_ASSIGN            /* assignment */
 963 };
 964
 965 /* Possible cases of implicit or explicit bad conversions to void. */
 966 enum impl_conv_void {
 967   ICV_CAST,            /* (explicit) conversion to void */
 968   ICV_SECOND_OF_COND,  /* second operand of conditional expression */
 969   ICV_THIRD_OF_COND,   /* third operand of conditional expression */
 970   ICV_RIGHT_OF_COMMA,  /* right operand of comma operator */
 971   ICV_LEFT_OF_COMMA,   /* left operand of comma operator */
 972   ICV_STATEMENT,       /* statement */
 973   ICV_THIRD_IN_FOR     /* for increment expression */
 974 };
 975
 976 /* Possible invalid uses of an abstract class that might not have a
 977    specific associated declaration.  */
 978 enum GTY(()) abstract_class_use {
 979   ACU_UNKNOWN,                  /* unknown or decl provided */
 980   ACU_CAST,                     /* cast to abstract class */
 981   ACU_NEW,                      /* new-expression of abstract class */
 982   ACU_THROW,                    /* throw-expression of abstract class */
 983   ACU_CATCH,                    /* catch-parameter of abstract class */
 984   ACU_ARRAY,                    /* array of abstract class */
 985   ACU_RETURN,                   /* return type of abstract class */
 986   ACU_PARM                      /* parameter type of abstract class */
 987 };
 988
 989 /* Macros for access to language-specific slots in an identifier.  */
 990
 991 /* The IDENTIFIER_BINDING is the innermost cxx_binding for the
 992     identifier.  Its PREVIOUS is the next outermost binding.  Each
 993     VALUE field is a DECL for the associated declaration.  Thus,
 994     name lookup consists simply of pulling off the node at the front
 995     of the list (modulo oddities for looking up the names of types,
 996     and such.)  You can use SCOPE field to determine the scope
 997     that bound the name.  */
 998 #define IDENTIFIER_BINDING(NODE) \
 999   (LANG_IDENTIFIER_CAST (NODE)->bindings)
1000
1001 /* TREE_TYPE only indicates on local and class scope the current
1002    type. For namespace scope, the presence of a type in any namespace
1003    is indicated with global_type_node, and the real type behind must
1004    be found through lookup.  */
1005 #define IDENTIFIER_TYPE_VALUE(NODE) identifier_type_value (NODE)
1006 #define REAL_IDENTIFIER_TYPE_VALUE(NODE) TREE_TYPE (NODE)
1007 #define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = (TYPE))
1008 #define IDENTIFIER_HAS_TYPE_VALUE(NODE) (IDENTIFIER_TYPE_VALUE (NODE) ? 1 : 0)
1009
1010 /* Kinds of identifiers.  Values are carefully chosen.  */
1011 enum cp_identifier_kind {
1012   cik_normal = 0,       /* Not a special identifier.  */
1013   cik_keyword = 1,      /* A keyword.  */
1014   cik_ctor = 2,         /* Constructor (in-chg, complete or base).  */
1015   cik_dtor = 3,         /* Destructor (in-chg, deleting, complete or
1016                            base).  */
1017   cik_simple_op = 4,    /* Non-assignment operator name.  */
1018   cik_assign_op = 5,    /* An assignment operator name.  */
1019   cik_conv_op = 6,      /* Conversion operator name.  */
1020   cik_reserved_for_udlit = 7,   /* Not yet in use  */
1021   cik_max
1022 };
1023
1024 /* Kind bits.  */
1025 #define IDENTIFIER_KIND_BIT_0(NODE) \
1026   TREE_LANG_FLAG_0 (IDENTIFIER_NODE_CHECK (NODE))
1027 #define IDENTIFIER_KIND_BIT_1(NODE) \
1028   TREE_LANG_FLAG_1 (IDENTIFIER_NODE_CHECK (NODE))
1029 #define IDENTIFIER_KIND_BIT_2(NODE) \
1030   TREE_LANG_FLAG_2 (IDENTIFIER_NODE_CHECK (NODE))
1031
1032 /* Used by various search routines.  */
1033 #define IDENTIFIER_MARKED(NODE) \
1034   TREE_LANG_FLAG_4 (IDENTIFIER_NODE_CHECK (NODE))
1035
1036 /* Nonzero if this identifier is used as a virtual function name somewhere
1037    (optimizes searches).  */
1038 #define IDENTIFIER_VIRTUAL_P(NODE) \
1039   TREE_LANG_FLAG_5 (IDENTIFIER_NODE_CHECK (NODE))
1040
1041 /* True iff NAME is the DECL_ASSEMBLER_NAME for an entity with vague
1042    linkage which the prelinker has assigned to this translation
1043    unit.  */
1044 #define IDENTIFIER_REPO_CHOSEN(NAME) \
1045   (TREE_LANG_FLAG_6 (IDENTIFIER_NODE_CHECK (NAME)))
1046
1047 /* True if this identifier is a reserved word.  C_RID_CODE (node) is
1048    then the RID_* value of the keyword.  Value 1.  */
1049 #define IDENTIFIER_KEYWORD_P(NODE)              \
1050   ((!IDENTIFIER_KIND_BIT_2 (NODE))              \
1051    & (!IDENTIFIER_KIND_BIT_1 (NODE))            \
1052    & IDENTIFIER_KIND_BIT_0 (NODE))
1053
1054 /* True if this identifier is the name of a constructor or
1055    destructor.  Value 2 or 3.  */
1056 #define IDENTIFIER_CDTOR_P(NODE)                \
1057   ((!IDENTIFIER_KIND_BIT_2 (NODE))              \
1058    & IDENTIFIER_KIND_BIT_1 (NODE))
1059
1060 /* True if this identifier is the name of a constructor.  Value 2.  */
1061 #define IDENTIFIER_CTOR_P(NODE)                 \
1062   (IDENTIFIER_CDTOR_P(NODE)                     \
1063     & (!IDENTIFIER_KIND_BIT_0 (NODE)))
1064
1065 /* True if this identifier is the name of a destructor.  Value 3.  */
1066 #define IDENTIFIER_DTOR_P(NODE)                 \
1067   (IDENTIFIER_CDTOR_P(NODE)                     \
1068     & IDENTIFIER_KIND_BIT_0 (NODE))
1069
1070 /* True if this identifier is for any operator name (including
1071    conversions).  Value 4, 5, 6 or 7.  */
1072 #define IDENTIFIER_ANY_OP_P(NODE)               \
1073   (IDENTIFIER_KIND_BIT_2 (NODE))
1074
1075 /* True if this identifier is for an overloaded operator. Values 4, 5.  */
1076 #define IDENTIFIER_OVL_OP_P(NODE)               \
1077   (IDENTIFIER_ANY_OP_P (NODE)                   \
1078    & (!IDENTIFIER_KIND_BIT_1 (NODE)))
1079
1080 /* True if this identifier is for any assignment. Values 5.  */
1081 #define IDENTIFIER_ASSIGN_OP_P(NODE)            \
1082   (IDENTIFIER_OVL_OP_P (NODE)                   \
1083    & IDENTIFIER_KIND_BIT_0 (NODE))
1084
1085 /* True if this identifier is the name of a type-conversion
1086    operator.  Value 7.  */
1087 #define IDENTIFIER_CONV_OP_P(NODE)              \
1088   (IDENTIFIER_ANY_OP_P (NODE)                   \
1089    & IDENTIFIER_KIND_BIT_1 (NODE)               \
1090    & (!IDENTIFIER_KIND_BIT_0 (NODE)))
1091
1092 /* True if this identifier is a new or delete operator.  */
1093 #define IDENTIFIER_NEWDEL_OP_P(NODE)            \
1094   (IDENTIFIER_OVL_OP_P (NODE)                   \
1095    && IDENTIFIER_OVL_OP_FLAGS (NODE) & OVL_OP_FLAG_ALLOC)
1096
1097 /* True if this identifier is a new operator.  */
1098 #define IDENTIFIER_NEW_OP_P(NODE)                                       \
1099   (IDENTIFIER_OVL_OP_P (NODE)                                           \
1100    && (IDENTIFIER_OVL_OP_FLAGS (NODE)                                   \
1101        & (OVL_OP_FLAG_ALLOC | OVL_OP_FLAG_DELETE)) == OVL_OP_FLAG_ALLOC)
1102
1103 /* Access a C++-specific index for identifier NODE.
1104    Used to optimize operator mappings etc.  */
1105 #define IDENTIFIER_CP_INDEX(NODE)               \
1106   (IDENTIFIER_NODE_CHECK(NODE)->base.u.bits.address_space)
1107
1108 /* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only.  */
1109 #define C_TYPE_FIELDS_READONLY(TYPE) \
1110   (LANG_TYPE_CLASS_CHECK (TYPE)->fields_readonly)
1111
1112 /* The tokens stored in the default argument.  */
1113
1114 #define DEFARG_TOKENS(NODE) \
1115   (((struct tree_default_arg *)DEFAULT_ARG_CHECK (NODE))->tokens)
1116 #define DEFARG_INSTANTIATIONS(NODE) \
1117   (((struct tree_default_arg *)DEFAULT_ARG_CHECK (NODE))->instantiations)
1118
1119 struct GTY (()) tree_default_arg {
1120   struct tree_common common;
1121   struct cp_token_cache *tokens;
1122   vec<tree, va_gc> *instantiations;
1123 };
1124
1125
1126 #define DEFERRED_NOEXCEPT_PATTERN(NODE) \
1127   (((struct tree_deferred_noexcept *)DEFERRED_NOEXCEPT_CHECK (NODE))->pattern)
1128 #define DEFERRED_NOEXCEPT_ARGS(NODE) \
1129   (((struct tree_deferred_noexcept *)DEFERRED_NOEXCEPT_CHECK (NODE))->args)
1130 #define DEFERRED_NOEXCEPT_SPEC_P(NODE)                          \
1131   ((NODE) && (TREE_PURPOSE (NODE))                              \
1132    && (TREE_CODE (TREE_PURPOSE (NODE)) == DEFERRED_NOEXCEPT))
1133 #define UNEVALUATED_NOEXCEPT_SPEC_P(NODE)                               \
1134   (DEFERRED_NOEXCEPT_SPEC_P (NODE)                                      \
1135    && DEFERRED_NOEXCEPT_PATTERN (TREE_PURPOSE (NODE)) == NULL_TREE)
1136
1137 struct GTY (()) tree_deferred_noexcept {
1138   struct tree_base base;
1139   tree pattern;
1140   tree args;
1141 };
1142
1143
1144 /* The condition associated with the static assertion.  This must be
1145    an integral constant expression.  */
1146 #define STATIC_ASSERT_CONDITION(NODE) \
1147   (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->condition)
1148
1149 /* The message associated with the static assertion.  This must be a
1150    string constant, which will be emitted as an error message when the
1151    static assert condition is false.  */
1152 #define STATIC_ASSERT_MESSAGE(NODE) \
1153   (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->message)
1154
1155 /* Source location information for a static assertion.  */
1156 #define STATIC_ASSERT_SOURCE_LOCATION(NODE) \
1157   (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->location)
1158
1159 struct GTY (()) tree_static_assert {
1160   struct tree_common common;
1161   tree condition;
1162   tree message;
1163   location_t location;
1164 };
1165
1166 struct GTY (()) tree_argument_pack_select {
1167   struct tree_common common;
1168   tree argument_pack;
1169   int index;
1170 };
1171
1172 /* The different kinds of traits that we encounter.  */
1173
1174 enum cp_trait_kind
1175 {
1176   CPTK_BASES,
1177   CPTK_DIRECT_BASES,
1178   CPTK_HAS_NOTHROW_ASSIGN,
1179   CPTK_HAS_NOTHROW_CONSTRUCTOR,
1180   CPTK_HAS_NOTHROW_COPY,
1181   CPTK_HAS_TRIVIAL_ASSIGN,
1182   CPTK_HAS_TRIVIAL_CONSTRUCTOR,
1183   CPTK_HAS_TRIVIAL_COPY,
1184   CPTK_HAS_TRIVIAL_DESTRUCTOR,
1185   CPTK_HAS_UNIQUE_OBJ_REPRESENTATIONS,
1186   CPTK_HAS_VIRTUAL_DESTRUCTOR,
1187   CPTK_IS_ABSTRACT,
1188   CPTK_IS_AGGREGATE,
1189   CPTK_IS_BASE_OF,
1190   CPTK_IS_CLASS,
1191   CPTK_IS_EMPTY,
1192   CPTK_IS_ENUM,
1193   CPTK_IS_FINAL,
1194   CPTK_IS_LITERAL_TYPE,
1195   CPTK_IS_POD,
1196   CPTK_IS_POLYMORPHIC,
1197   CPTK_IS_SAME_AS,
1198   CPTK_IS_STD_LAYOUT,
1199   CPTK_IS_TRIVIAL,
1200   CPTK_IS_TRIVIALLY_ASSIGNABLE,
1201   CPTK_IS_TRIVIALLY_CONSTRUCTIBLE,
1202   CPTK_IS_TRIVIALLY_COPYABLE,
1203   CPTK_IS_UNION,
1204   CPTK_UNDERLYING_TYPE,
1205   CPTK_IS_ASSIGNABLE,
1206   CPTK_IS_CONSTRUCTIBLE
1207 };
1208
1209 /* The types that we are processing.  */
1210 #define TRAIT_EXPR_TYPE1(NODE) \
1211   (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type1)
1212
1213 #define TRAIT_EXPR_TYPE2(NODE) \
1214   (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type2)
1215
1216 /* The specific trait that we are processing.  */
1217 #define TRAIT_EXPR_KIND(NODE) \
1218   (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->kind)
1219
1220 struct GTY (()) tree_trait_expr {
1221   struct tree_common common;
1222   tree type1;
1223   tree type2;
1224   enum cp_trait_kind kind;
1225 };
1226
1227 /* Based off of TYPE_UNNAMED_P.  */
1228 #define LAMBDA_TYPE_P(NODE) \
1229   (CLASS_TYPE_P (NODE) && CLASSTYPE_LAMBDA_EXPR (NODE))
1230
1231 /* Test if FUNCTION_DECL is a lambda function.  */
1232 #define LAMBDA_FUNCTION_P(FNDECL)                               \
1233   (DECL_DECLARES_FUNCTION_P (FNDECL)                            \
1234    && DECL_OVERLOADED_OPERATOR_P (FNDECL)                       \
1235    && DECL_OVERLOADED_OPERATOR_IS (FNDECL, CALL_EXPR)           \
1236    && LAMBDA_TYPE_P (CP_DECL_CONTEXT (FNDECL)))
1237
1238 enum cp_lambda_default_capture_mode_type {
1239   CPLD_NONE,
1240   CPLD_COPY,
1241   CPLD_REFERENCE
1242 };
1243
1244 /* The method of default capture, if any.  */
1245 #define LAMBDA_EXPR_DEFAULT_CAPTURE_MODE(NODE) \
1246   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->default_capture_mode)
1247
1248 /* The capture-list, including `this'.  Each capture is stored as a FIELD_DECL
1249  * so that the name, type, and field are all together, whether or not it has
1250  * been added to the lambda's class type.
1251    TREE_LIST:
1252      TREE_PURPOSE: The FIELD_DECL for this capture.
1253      TREE_VALUE: The initializer. This is part of a GNU extension.  */
1254 #define LAMBDA_EXPR_CAPTURE_LIST(NODE) \
1255   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->capture_list)
1256
1257 /* During parsing of the lambda-introducer, the node in the capture-list
1258    that holds the 'this' capture.  During parsing of the body, the
1259    capture proxy for that node.  */
1260 #define LAMBDA_EXPR_THIS_CAPTURE(NODE) \
1261   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->this_capture)
1262
1263 /* Predicate tracking whether `this' is in the effective capture set.  */
1264 #define LAMBDA_EXPR_CAPTURES_THIS_P(NODE) \
1265   LAMBDA_EXPR_THIS_CAPTURE(NODE)
1266
1267 /* Predicate tracking whether the lambda was declared 'mutable'.  */
1268 #define LAMBDA_EXPR_MUTABLE_P(NODE) \
1269   TREE_LANG_FLAG_1 (LAMBDA_EXPR_CHECK (NODE))
1270
1271 /* True iff uses of a const variable capture were optimized away.  */
1272 #define LAMBDA_EXPR_CAPTURE_OPTIMIZED(NODE) \
1273   TREE_LANG_FLAG_2 (LAMBDA_EXPR_CHECK (NODE))
1274
1275 /* True if this TREE_LIST in LAMBDA_EXPR_CAPTURE_LIST is for an explicit
1276    capture.  */
1277 #define LAMBDA_CAPTURE_EXPLICIT_P(NODE) \
1278   TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
1279
1280 /* The source location of the lambda.  */
1281 #define LAMBDA_EXPR_LOCATION(NODE) \
1282   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->locus)
1283
1284 /* The mangling scope for the lambda: FUNCTION_DECL, PARM_DECL, VAR_DECL,
1285    FIELD_DECL or NULL_TREE.  If this is NULL_TREE, we have no linkage.  */
1286 #define LAMBDA_EXPR_EXTRA_SCOPE(NODE) \
1287   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->extra_scope)
1288
1289 /* If EXTRA_SCOPE, this is the number of the lambda within that scope.  */
1290 #define LAMBDA_EXPR_DISCRIMINATOR(NODE) \
1291   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->discriminator)
1292
1293 /* During parsing of the lambda, a vector of capture proxies which need
1294    to be pushed once we're done processing a nested lambda.  */
1295 #define LAMBDA_EXPR_PENDING_PROXIES(NODE) \
1296   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->pending_proxies)
1297
1298 /* The closure type of the lambda, which is also the type of the
1299    LAMBDA_EXPR.  */
1300 #define LAMBDA_EXPR_CLOSURE(NODE) \
1301   (TREE_TYPE (LAMBDA_EXPR_CHECK (NODE)))
1302
1303 struct GTY (()) tree_lambda_expr
1304 {
1305   struct tree_typed typed;
1306   tree capture_list;
1307   tree this_capture;
1308   tree extra_scope;
1309   vec<tree, va_gc> *pending_proxies;
1310   location_t locus;
1311   enum cp_lambda_default_capture_mode_type default_capture_mode;
1312   int discriminator;
1313 };
1314
1315 /* A (typedef,context,usage location) triplet.
1316    It represents a typedef used through a
1317    context at a given source location.
1318    e.g.
1319    struct foo {
1320      typedef int myint;
1321    };
1322
1323    struct bar {
1324     foo::myint v; // #1<-- this location.
1325    };
1326
1327    In bar, the triplet will be (myint, foo, #1).
1328    */
1329 struct GTY(()) qualified_typedef_usage_s {
1330   tree typedef_decl;
1331   tree context;
1332   location_t locus;
1333 };
1334 typedef struct qualified_typedef_usage_s qualified_typedef_usage_t;
1335
1336 /* Non-zero if this template specialization has access violations that
1337    should be rechecked when the function is instantiated outside argument
1338    deduction.  */
1339 #define TINFO_HAS_ACCESS_ERRORS(NODE) \
1340   (TREE_LANG_FLAG_0 (TEMPLATE_INFO_CHECK (NODE)))
1341 #define FNDECL_HAS_ACCESS_ERRORS(NODE) \
1342   (TINFO_HAS_ACCESS_ERRORS (DECL_TEMPLATE_INFO (NODE)))
1343
1344 /* Non-zero if this variable template specialization was specified using a
1345    template-id, so it's a partial or full specialization and not a definition
1346    of the member template of a particular class specialization.  */
1347 #define TINFO_USED_TEMPLATE_ID(NODE) \
1348   (TREE_LANG_FLAG_1 (TEMPLATE_INFO_CHECK (NODE)))
1349
1350 struct GTY(()) tree_template_info {
1351   struct tree_common common;
1352   vec<qualified_typedef_usage_t, va_gc> *typedefs_needing_access_checking;
1353 };
1354
1355 // Constraint information for a C++ declaration. Constraint information is
1356 // comprised of:
1357 //
1358 // - a constraint expression introduced by the template header
1359 // - a constraint expression introduced by a function declarator
1360 // - the associated constraints, which are the conjunction of those,
1361 //   and used for declaration matching
1362 //
1363 // The template and declarator requirements are kept to support pretty
1364 // printing constrained declarations.
1365 struct GTY(()) tree_constraint_info {
1366   struct tree_base base;
1367   tree template_reqs;
1368   tree declarator_reqs;
1369   tree associated_constr;
1370 };
1371
1372 // Require that pointer P is non-null before returning.
1373 template<typename T>
1374 inline T*
1375 check_nonnull (T* p)
1376 {
1377   gcc_assert (p);
1378   return p;
1379 }
1380
1381 // Returns true iff T is non-null and represents constraint info.
1382 inline tree_constraint_info *
1383 check_constraint_info (tree t)
1384 {
1385   if (t && TREE_CODE (t) == CONSTRAINT_INFO)
1386     return (tree_constraint_info *)t;
1387   return NULL;
1388 }
1389
1390 // Access the expression describing the template constraints. This may be
1391 // null if no constraints were introduced in the template parameter list,
1392 // a requirements clause after the template parameter list, or constraints
1393 // through a constrained-type-specifier.
1394 #define CI_TEMPLATE_REQS(NODE) \
1395   check_constraint_info (check_nonnull(NODE))->template_reqs
1396
1397 // Access the expression describing the trailing constraints. This is non-null
1398 // for any implicit instantiation of a constrained declaration. For a
1399 // templated declaration it is non-null only when a trailing requires-clause
1400 // was specified.
1401 #define CI_DECLARATOR_REQS(NODE) \
1402   check_constraint_info (check_nonnull(NODE))->declarator_reqs
1403
1404 // The computed associated constraint expression for a declaration.
1405 #define CI_ASSOCIATED_CONSTRAINTS(NODE) \
1406   check_constraint_info (check_nonnull(NODE))->associated_constr
1407
1408 // Access the logical constraints on the template parameters introduced
1409 // at a given template parameter list level indicated by NODE.
1410 #define TEMPLATE_PARMS_CONSTRAINTS(NODE) \
1411   TREE_TYPE (TREE_LIST_CHECK (NODE))
1412
1413 // Access the logical constraints on the template parameter declaration
1414 // indicated by NODE.
1415 #define TEMPLATE_PARM_CONSTRAINTS(NODE) \
1416   TREE_TYPE (TREE_LIST_CHECK (NODE))
1417
1418 /* Non-zero if the noexcept is present in a compound requirement. */
1419 #define COMPOUND_REQ_NOEXCEPT_P(NODE) \
1420   TREE_LANG_FLAG_0 (TREE_CHECK (NODE, COMPOUND_REQ))
1421
1422 /* The constraints on an 'auto' placeholder type, used in an argument deduction
1423    constraint.  */
1424 #define PLACEHOLDER_TYPE_CONSTRAINTS(NODE) \
1425   DECL_SIZE_UNIT (TYPE_NAME (NODE))
1426
1427 /* The expression evaluated by the predicate constraint. */
1428 #define PRED_CONSTR_EXPR(NODE) \
1429   TREE_OPERAND (TREE_CHECK (NODE, PRED_CONSTR), 0)
1430
1431 /* The concept of a concept check. */
1432 #define CHECK_CONSTR_CONCEPT(NODE) \
1433   TREE_OPERAND (TREE_CHECK (NODE, CHECK_CONSTR), 0)
1434
1435 /* The template arguments of a concept check. */
1436 #define CHECK_CONSTR_ARGS(NODE) \
1437   TREE_OPERAND (TREE_CHECK (NODE, CHECK_CONSTR), 1)
1438
1439 /* The expression validated by the predicate constraint. */
1440 #define EXPR_CONSTR_EXPR(NODE) \
1441   TREE_OPERAND (TREE_CHECK (NODE, EXPR_CONSTR), 0)
1442
1443 /* The type validated by the predicate constraint. */
1444 #define TYPE_CONSTR_TYPE(NODE) \
1445   TREE_OPERAND (TREE_CHECK (NODE, TYPE_CONSTR), 0)
1446
1447 /* In an implicit conversion constraint, the source expression. */
1448 #define ICONV_CONSTR_EXPR(NODE) \
1449   TREE_OPERAND (TREE_CHECK (NODE, ICONV_CONSTR), 0)
1450
1451 /* In an implicit conversion constraint, the target type. */
1452 #define ICONV_CONSTR_TYPE(NODE) \
1453   TREE_OPERAND (TREE_CHECK (NODE, ICONV_CONSTR), 1)
1454
1455 /* In an argument deduction constraint, the source expression. */
1456 #define DEDUCT_CONSTR_EXPR(NODE) \
1457   TREE_OPERAND (TREE_CHECK (NODE, DEDUCT_CONSTR), 0)
1458
1459 /* In an argument deduction constraint, the target type pattern. */
1460 #define DEDUCT_CONSTR_PATTERN(NODE) \
1461   TREE_OPERAND (TREE_CHECK (NODE, DEDUCT_CONSTR), 1)
1462
1463 /* In an argument deduction constraint, the list of placeholder nodes. */
1464 #define DEDUCT_CONSTR_PLACEHOLDER(NODE) \
1465   TREE_OPERAND (TREE_CHECK (NODE, DEDUCT_CONSTR), 2)
1466
1467 /* The expression of an exception constraint. */
1468 #define EXCEPT_CONSTR_EXPR(NODE) \
1469   TREE_OPERAND (TREE_CHECK (NODE, EXCEPT_CONSTR), 0)
1470
1471 /* In a parameterized constraint, the local parameters. */
1472 #define PARM_CONSTR_PARMS(NODE) \
1473   TREE_OPERAND (TREE_CHECK (NODE, PARM_CONSTR), 0)
1474
1475 /* In a parameterized constraint, the operand. */
1476 #define PARM_CONSTR_OPERAND(NODE) \
1477   TREE_OPERAND (TREE_CHECK (NODE, PARM_CONSTR), 1)
1478
1479 /* Whether a PARM_DECL represents a local parameter in a
1480    requires-expression.  */
1481 #define CONSTRAINT_VAR_P(NODE) \
1482   DECL_LANG_FLAG_2 (TREE_CHECK (NODE, PARM_DECL))
1483
1484 /* The concept constraining this constrained template-parameter.  */
1485 #define CONSTRAINED_PARM_CONCEPT(NODE) \
1486   DECL_SIZE_UNIT (TYPE_DECL_CHECK (NODE))
1487 /* Any extra template arguments specified for a constrained
1488    template-parameter.  */
1489 #define CONSTRAINED_PARM_EXTRA_ARGS(NODE) \
1490   DECL_SIZE (TYPE_DECL_CHECK (NODE))
1491 /* The first template parameter of CONSTRAINED_PARM_CONCEPT to be used as a
1492    prototype for the constrained parameter in finish_shorthand_constraint,
1493    attached for convenience.  */
1494 #define CONSTRAINED_PARM_PROTOTYPE(NODE) \
1495   DECL_INITIAL (TYPE_DECL_CHECK (NODE))
1496
1497 enum cp_tree_node_structure_enum {
1498   TS_CP_GENERIC,
1499   TS_CP_IDENTIFIER,
1500   TS_CP_TPI,
1501   TS_CP_PTRMEM,
1502   TS_CP_OVERLOAD,
1503   TS_CP_BASELINK,
1504   TS_CP_TEMPLATE_DECL,
1505   TS_CP_DEFAULT_ARG,
1506   TS_CP_DEFERRED_NOEXCEPT,
1507   TS_CP_STATIC_ASSERT,
1508   TS_CP_ARGUMENT_PACK_SELECT,
1509   TS_CP_TRAIT_EXPR,
1510   TS_CP_LAMBDA_EXPR,
1511   TS_CP_TEMPLATE_INFO,
1512   TS_CP_CONSTRAINT_INFO,
1513   TS_CP_USERDEF_LITERAL
1514 };
1515
1516 /* The resulting tree type.  */
1517 union GTY((desc ("cp_tree_node_structure (&%h)"),
1518        chain_next ("(union lang_tree_node *) c_tree_chain_next (&%h.generic)"))) lang_tree_node {
1519   union tree_node GTY ((tag ("TS_CP_GENERIC"),
1520                         desc ("tree_node_structure (&%h)"))) generic;
1521   struct template_parm_index GTY ((tag ("TS_CP_TPI"))) tpi;
1522   struct ptrmem_cst GTY ((tag ("TS_CP_PTRMEM"))) ptrmem;
1523   struct tree_overload GTY ((tag ("TS_CP_OVERLOAD"))) overload;
1524   struct tree_baselink GTY ((tag ("TS_CP_BASELINK"))) baselink;
1525   struct tree_template_decl GTY ((tag ("TS_CP_TEMPLATE_DECL"))) template_decl;
1526   struct tree_default_arg GTY ((tag ("TS_CP_DEFAULT_ARG"))) default_arg;
1527   struct tree_deferred_noexcept GTY ((tag ("TS_CP_DEFERRED_NOEXCEPT"))) deferred_noexcept;
1528   struct lang_identifier GTY ((tag ("TS_CP_IDENTIFIER"))) identifier;
1529   struct tree_static_assert GTY ((tag ("TS_CP_STATIC_ASSERT")))
1530     static_assertion;
1531   struct tree_argument_pack_select GTY ((tag ("TS_CP_ARGUMENT_PACK_SELECT")))
1532     argument_pack_select;
1533   struct tree_trait_expr GTY ((tag ("TS_CP_TRAIT_EXPR")))
1534     trait_expression;
1535   struct tree_lambda_expr GTY ((tag ("TS_CP_LAMBDA_EXPR")))
1536     lambda_expression;
1537   struct tree_template_info GTY ((tag ("TS_CP_TEMPLATE_INFO")))
1538     template_info;
1539   struct tree_constraint_info GTY ((tag ("TS_CP_CONSTRAINT_INFO")))
1540     constraint_info;
1541   struct tree_userdef_literal GTY ((tag ("TS_CP_USERDEF_LITERAL")))
1542     userdef_literal;
1543 };
1544
1545 \f
1546 /* Global state.  */
1547
1548 struct GTY(()) saved_scope {
1549   vec<cxx_saved_binding, va_gc> *old_bindings;
1550   tree old_namespace;
1551   vec<tree, va_gc> *decl_ns_list;
1552   tree class_name;
1553   tree class_type;
1554   tree access_specifier;
1555   tree function_decl;
1556   vec<tree, va_gc> *lang_base;
1557   tree lang_name;
1558   tree template_parms;
1559   cp_binding_level *x_previous_class_level;
1560   tree x_saved_tree;
1561
1562   /* Only used for uses of this in trailing return type.  */
1563   tree x_current_class_ptr;
1564   tree x_current_class_ref;
1565
1566   int x_processing_template_decl;
1567   int x_processing_specialization;
1568   BOOL_BITFIELD x_processing_explicit_instantiation : 1;
1569   BOOL_BITFIELD need_pop_function_context : 1;
1570
1571 /* Nonzero if we are parsing the discarded statement of a constexpr
1572    if-statement.  */
1573   BOOL_BITFIELD discarded_stmt : 1;
1574
1575   int unevaluated_operand;
1576   int inhibit_evaluation_warnings;
1577   int noexcept_operand;
1578   /* If non-zero, implicit "omp declare target" attribute is added into the
1579      attribute lists.  */
1580   int omp_declare_target_attribute;
1581
1582   struct stmt_tree_s x_stmt_tree;
1583
1584   cp_binding_level *class_bindings;
1585   cp_binding_level *bindings;
1586
1587   hash_map<tree, tree> *GTY((skip)) x_local_specializations;
1588
1589   struct saved_scope *prev;
1590 };
1591
1592 extern GTY(()) struct saved_scope *scope_chain;
1593
1594 /* The current open namespace.  */
1595
1596 #define current_namespace scope_chain->old_namespace
1597
1598 /* The stack for namespaces of current declarations.  */
1599
1600 #define decl_namespace_list scope_chain->decl_ns_list
1601
1602 /* IDENTIFIER_NODE: name of current class */
1603
1604 #define current_class_name scope_chain->class_name
1605
1606 /* _TYPE: the type of the current class */
1607
1608 #define current_class_type scope_chain->class_type
1609
1610 /* When parsing a class definition, the access specifier most recently
1611    given by the user, or, if no access specifier was given, the
1612    default value appropriate for the kind of class (i.e., struct,
1613    class, or union).  */
1614
1615 #define current_access_specifier scope_chain->access_specifier
1616
1617 /* Pointer to the top of the language name stack.  */
1618
1619 #define current_lang_base scope_chain->lang_base
1620 #define current_lang_name scope_chain->lang_name
1621
1622 /* When parsing a template declaration, a TREE_LIST represents the
1623    active template parameters.  Each node in the list represents one
1624    level of template parameters.  The innermost level is first in the
1625    list.  The depth of each level is stored as an INTEGER_CST in the
1626    TREE_PURPOSE of each node.  The parameters for that level are
1627    stored in the TREE_VALUE.  */
1628
1629 #define current_template_parms scope_chain->template_parms
1630
1631 #define processing_template_decl scope_chain->x_processing_template_decl
1632 #define processing_specialization scope_chain->x_processing_specialization
1633 #define processing_explicit_instantiation scope_chain->x_processing_explicit_instantiation
1634
1635 #define in_discarded_stmt scope_chain->discarded_stmt
1636
1637 /* RAII sentinel to handle clearing processing_template_decl and restoring
1638    it when done.  */
1639
1640 struct processing_template_decl_sentinel
1641 {
1642   int saved;
1643   processing_template_decl_sentinel (bool reset = true)
1644     : saved (processing_template_decl)
1645   {
1646     if (reset)
1647       processing_template_decl = 0;
1648   }
1649   ~processing_template_decl_sentinel()
1650   {
1651     processing_template_decl = saved;
1652   }
1653 };
1654
1655 /* RAII sentinel to disable certain warnings during template substitution
1656    and elsewhere.  */
1657
1658 struct warning_sentinel
1659 {
1660   int &flag;
1661   int val;
1662   warning_sentinel(int& flag, bool suppress=true)
1663     : flag(flag), val(flag) { if (suppress) flag = 0; }
1664   ~warning_sentinel() { flag = val; }
1665 };
1666
1667 /* RAII sentinel that saves the value of a variable, optionally
1668    overrides it right away, and restores its value when the sentinel
1669    id destructed.  */
1670
1671 template <typename T>
1672 class temp_override
1673 {
1674   T& overridden_variable;
1675   T saved_value;
1676 public:
1677   temp_override(T& var) : overridden_variable (var), saved_value (var) {}
1678   temp_override(T& var, T overrider)
1679     : overridden_variable (var), saved_value (var)
1680   {
1681     overridden_variable = overrider;
1682   }
1683   ~temp_override() { overridden_variable = saved_value; }
1684 };
1685
1686 /* The cached class binding level, from the most recently exited
1687    class, or NULL if none.  */
1688
1689 #define previous_class_level scope_chain->x_previous_class_level
1690
1691 /* A map from local variable declarations in the body of the template
1692    presently being instantiated to the corresponding instantiated
1693    local variables.  */
1694
1695 #define local_specializations scope_chain->x_local_specializations
1696
1697 /* Nonzero if we are parsing the operand of a noexcept operator.  */
1698
1699 #define cp_noexcept_operand scope_chain->noexcept_operand
1700
1701 /* A list of private types mentioned, for deferred access checking.  */
1702
1703 struct GTY((for_user)) cxx_int_tree_map {
1704   unsigned int uid;
1705   tree to;
1706 };
1707
1708 struct cxx_int_tree_map_hasher : ggc_ptr_hash<cxx_int_tree_map>
1709 {
1710   static hashval_t hash (cxx_int_tree_map *);
1711   static bool equal (cxx_int_tree_map *, cxx_int_tree_map *);
1712 };
1713
1714 struct named_label_entry; /* Defined in decl.c.  */
1715
1716 struct named_label_hash : ggc_remove <named_label_entry *>
1717 {
1718   typedef named_label_entry *value_type;
1719   typedef tree compare_type; /* An identifier.  */
1720
1721   inline static hashval_t hash (value_type);
1722   inline static bool equal (const value_type, compare_type);
1723
1724   inline static void mark_empty (value_type &p) {p = NULL;}
1725   inline static bool is_empty (value_type p) {return !p;}
1726
1727   /* Nothing is deletable.  Everything is insertable.  */
1728   inline static bool is_deleted (value_type) { return false; }
1729   inline static void mark_deleted (value_type) { gcc_unreachable (); }
1730 };
1731
1732 /* Global state pertinent to the current function.  */
1733
1734 struct GTY(()) language_function {
1735   struct c_language_function base;
1736
1737   tree x_cdtor_label;
1738   tree x_current_class_ptr;
1739   tree x_current_class_ref;
1740   tree x_eh_spec_block;
1741   tree x_in_charge_parm;
1742   tree x_vtt_parm;
1743   tree x_return_value;
1744   tree x_auto_return_pattern;
1745
1746   BOOL_BITFIELD returns_value : 1;
1747   BOOL_BITFIELD returns_null : 1;
1748   BOOL_BITFIELD returns_abnormally : 1;
1749   BOOL_BITFIELD infinite_loop: 1;
1750   BOOL_BITFIELD x_in_function_try_handler : 1;
1751   BOOL_BITFIELD x_in_base_initializer : 1;
1752
1753   /* True if this function can throw an exception.  */
1754   BOOL_BITFIELD can_throw : 1;
1755
1756   BOOL_BITFIELD invalid_constexpr : 1;
1757
1758   hash_table<named_label_hash> *x_named_labels;
1759
1760   cp_binding_level *bindings;
1761   vec<tree, va_gc> *x_local_names;
1762   /* Tracking possibly infinite loops.  This is a vec<tree> only because
1763      vec<bool> doesn't work with gtype.  */
1764   vec<tree, va_gc> *infinite_loops;
1765   hash_table<cxx_int_tree_map_hasher> *extern_decl_map;
1766 };
1767
1768 /* The current C++-specific per-function global variables.  */
1769
1770 #define cp_function_chain (cfun->language)
1771
1772 /* In a constructor destructor, the point at which all derived class
1773    destroying/construction has been done.  I.e., just before a
1774    constructor returns, or before any base class destroying will be done
1775    in a destructor.  */
1776
1777 #define cdtor_label cp_function_chain->x_cdtor_label
1778
1779 /* When we're processing a member function, current_class_ptr is the
1780    PARM_DECL for the `this' pointer.  The current_class_ref is an
1781    expression for `*this'.  */
1782
1783 #define current_class_ptr                       \
1784   (*(cfun && cp_function_chain                  \
1785      ? &cp_function_chain->x_current_class_ptr  \
1786      : &scope_chain->x_current_class_ptr))
1787 #define current_class_ref                       \
1788   (*(cfun && cp_function_chain                  \
1789      ? &cp_function_chain->x_current_class_ref  \
1790      : &scope_chain->x_current_class_ref))
1791
1792 /* The EH_SPEC_BLOCK for the exception-specifiers for the current
1793    function, if any.  */
1794
1795 #define current_eh_spec_block cp_function_chain->x_eh_spec_block
1796
1797 /* The `__in_chrg' parameter for the current function.  Only used for
1798    constructors and destructors.  */
1799
1800 #define current_in_charge_parm cp_function_chain->x_in_charge_parm
1801
1802 /* The `__vtt_parm' parameter for the current function.  Only used for
1803    constructors and destructors.  */
1804
1805 #define current_vtt_parm cp_function_chain->x_vtt_parm
1806
1807 /* Set to 0 at beginning of a function definition, set to 1 if
1808    a return statement that specifies a return value is seen.  */
1809
1810 #define current_function_returns_value cp_function_chain->returns_value
1811
1812 /* Set to 0 at beginning of a function definition, set to 1 if
1813    a return statement with no argument is seen.  */
1814
1815 #define current_function_returns_null cp_function_chain->returns_null
1816
1817 /* Set to 0 at beginning of a function definition, set to 1 if
1818    a call to a noreturn function is seen.  */
1819
1820 #define current_function_returns_abnormally \
1821   cp_function_chain->returns_abnormally
1822
1823 /* Set to 0 at beginning of a function definition, set to 1 if we see an
1824    obvious infinite loop.  This can have false positives and false
1825    negatives, so it should only be used as a heuristic.  */
1826
1827 #define current_function_infinite_loop cp_function_chain->infinite_loop
1828
1829 /* Nonzero if we are processing a base initializer.  Zero elsewhere.  */
1830 #define in_base_initializer cp_function_chain->x_in_base_initializer
1831
1832 #define in_function_try_handler cp_function_chain->x_in_function_try_handler
1833
1834 /* Expression always returned from function, or error_mark_node
1835    otherwise, for use by the automatic named return value optimization.  */
1836
1837 #define current_function_return_value \
1838   (cp_function_chain->x_return_value)
1839
1840 /* A type involving 'auto' to be used for return type deduction.  */
1841
1842 #define current_function_auto_return_pattern \
1843   (cp_function_chain->x_auto_return_pattern)
1844
1845 /* In parser.c.  */
1846 extern tree cp_literal_operator_id (const char *);
1847
1848 /* TRUE if a tree code represents a statement.  */
1849 extern bool statement_code_p[MAX_TREE_CODES];
1850
1851 #define STATEMENT_CODE_P(CODE) statement_code_p[(int) (CODE)]
1852
1853 enum languages { lang_c, lang_cplusplus };
1854
1855 /* Macros to make error reporting functions' lives easier.  */
1856 #define TYPE_LINKAGE_IDENTIFIER(NODE) \
1857   (TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (NODE)))
1858 #define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (TYPE_IDENTIFIER (NODE)))
1859 #define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (TYPE_IDENTIFIER (NODE)))
1860
1861 /* Nonzero if NODE has no name for linkage purposes.  */
1862 #define TYPE_UNNAMED_P(NODE) \
1863   (OVERLOAD_TYPE_P (NODE) && anon_aggrname_p (TYPE_LINKAGE_IDENTIFIER (NODE)))
1864
1865 /* The _DECL for this _TYPE.  */
1866 #define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE)))
1867
1868 /* Nonzero if T is a type that could resolve to any kind of concrete type
1869    at instantiation time.  */
1870 #define WILDCARD_TYPE_P(T)                              \
1871   (TREE_CODE (T) == TEMPLATE_TYPE_PARM                  \
1872    || TREE_CODE (T) == TYPENAME_TYPE                    \
1873    || TREE_CODE (T) == TYPEOF_TYPE                      \
1874    || TREE_CODE (T) == BOUND_TEMPLATE_TEMPLATE_PARM     \
1875    || TREE_CODE (T) == DECLTYPE_TYPE)
1876
1877 /* Nonzero if T is a class (or struct or union) type.  Also nonzero
1878    for template type parameters, typename types, and instantiated
1879    template template parameters.  Keep these checks in ascending code
1880    order.  */
1881 #define MAYBE_CLASS_TYPE_P(T) (WILDCARD_TYPE_P (T) || CLASS_TYPE_P (T))
1882
1883 /* Set CLASS_TYPE_P for T to VAL.  T must be a class, struct, or
1884    union type.  */
1885 #define SET_CLASS_TYPE_P(T, VAL) \
1886   (TYPE_LANG_FLAG_5 (RECORD_OR_UNION_CHECK (T)) = (VAL))
1887
1888 /* Nonzero if T is a class type.  Zero for template type parameters,
1889    typename types, and so forth.  */
1890 #define CLASS_TYPE_P(T) \
1891   (RECORD_OR_UNION_CODE_P (TREE_CODE (T)) && TYPE_LANG_FLAG_5 (T))
1892
1893 /* Nonzero if T is a class type but not an union.  */
1894 #define NON_UNION_CLASS_TYPE_P(T) \
1895   (TREE_CODE (T) == RECORD_TYPE && TYPE_LANG_FLAG_5 (T))
1896
1897 /* Keep these checks in ascending code order.  */
1898 #define RECORD_OR_UNION_CODE_P(T)       \
1899   ((T) == RECORD_TYPE || (T) == UNION_TYPE)
1900 #define OVERLOAD_TYPE_P(T) \
1901   (CLASS_TYPE_P (T) || TREE_CODE (T) == ENUMERAL_TYPE)
1902
1903 /* True if this type is dependent.  This predicate is only valid if
1904    TYPE_DEPENDENT_P_VALID is true.  */
1905 #define TYPE_DEPENDENT_P(NODE) TYPE_LANG_FLAG_0 (NODE)
1906
1907 /* True if dependent_type_p has been called for this type, with the
1908    result that TYPE_DEPENDENT_P is valid.  */
1909 #define TYPE_DEPENDENT_P_VALID(NODE) TYPE_LANG_FLAG_6(NODE)
1910
1911 /* Nonzero if this type is const-qualified.  */
1912 #define CP_TYPE_CONST_P(NODE)                           \
1913   ((cp_type_quals (NODE) & TYPE_QUAL_CONST) != 0)
1914
1915 /* Nonzero if this type is volatile-qualified.  */
1916 #define CP_TYPE_VOLATILE_P(NODE)                        \
1917   ((cp_type_quals (NODE) & TYPE_QUAL_VOLATILE) != 0)
1918
1919 /* Nonzero if this type is restrict-qualified.  */
1920 #define CP_TYPE_RESTRICT_P(NODE)                        \
1921   ((cp_type_quals (NODE) & TYPE_QUAL_RESTRICT) != 0)
1922
1923 /* Nonzero if this type is const-qualified, but not
1924    volatile-qualified.  Other qualifiers are ignored.  This macro is
1925    used to test whether or not it is OK to bind an rvalue to a
1926    reference.  */
1927 #define CP_TYPE_CONST_NON_VOLATILE_P(NODE)                              \
1928   ((cp_type_quals (NODE) & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE))      \
1929    == TYPE_QUAL_CONST)
1930
1931 #define FUNCTION_ARG_CHAIN(NODE) \
1932   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (NODE)))
1933
1934 /* Given a FUNCTION_DECL, returns the first TREE_LIST out of TYPE_ARG_TYPES
1935    which refers to a user-written parameter.  */
1936 #define FUNCTION_FIRST_USER_PARMTYPE(NODE) \
1937   skip_artificial_parms_for ((NODE), TYPE_ARG_TYPES (TREE_TYPE (NODE)))
1938
1939 /* Similarly, but for DECL_ARGUMENTS.  */
1940 #define FUNCTION_FIRST_USER_PARM(NODE) \
1941   skip_artificial_parms_for ((NODE), DECL_ARGUMENTS (NODE))
1942
1943 /* Nonzero iff TYPE is derived from PARENT. Ignores accessibility and
1944    ambiguity issues.  */
1945 #define DERIVED_FROM_P(PARENT, TYPE) \
1946   (lookup_base ((TYPE), (PARENT), ba_any, NULL, tf_none) != NULL_TREE)
1947
1948 /* Gives the visibility specification for a class type.  */
1949 #define CLASSTYPE_VISIBILITY(TYPE)              \
1950         DECL_VISIBILITY (TYPE_MAIN_DECL (TYPE))
1951 #define CLASSTYPE_VISIBILITY_SPECIFIED(TYPE)    \
1952         DECL_VISIBILITY_SPECIFIED (TYPE_MAIN_DECL (TYPE))
1953
1954 struct GTY (()) tree_pair_s {
1955   tree purpose;
1956   tree value;
1957 };
1958 typedef tree_pair_s *tree_pair_p;
1959
1960 /* This structure provides additional information above and beyond
1961    what is provide in the ordinary tree_type.  In the past, we used it
1962    for the types of class types, template parameters types, typename
1963    types, and so forth.  However, there can be many (tens to hundreds
1964    of thousands) of template parameter types in a compilation, and
1965    there's no need for this additional information in that case.
1966    Therefore, we now use this data structure only for class types.
1967
1968    In the past, it was thought that there would be relatively few
1969    class types.  However, in the presence of heavy use of templates,
1970    many (i.e., thousands) of classes can easily be generated.
1971    Therefore, we should endeavor to keep the size of this structure to
1972    a minimum.  */
1973 struct GTY(()) lang_type {
1974   unsigned char align;
1975
1976   unsigned has_type_conversion : 1;
1977   unsigned has_copy_ctor : 1;
1978   unsigned has_default_ctor : 1;
1979   unsigned const_needs_init : 1;
1980   unsigned ref_needs_init : 1;
1981   unsigned has_const_copy_assign : 1;
1982   unsigned use_template : 2;
1983
1984   unsigned has_mutable : 1;
1985   unsigned com_interface : 1;
1986   unsigned non_pod_class : 1;
1987   unsigned nearly_empty_p : 1;
1988   unsigned user_align : 1;
1989   unsigned has_copy_assign : 1;
1990   unsigned has_new : 1;
1991   unsigned has_array_new : 1;
1992
1993   unsigned gets_delete : 2;
1994   unsigned interface_only : 1;
1995   unsigned interface_unknown : 1;
1996   unsigned contains_empty_class_p : 1;
1997   unsigned anon_aggr : 1;
1998   unsigned non_zero_init : 1;
1999   unsigned empty_p : 1;
2000   /* 32 bits allocated.  */
2001
2002   unsigned vec_new_uses_cookie : 1;
2003   unsigned declared_class : 1;
2004   unsigned diamond_shaped : 1;
2005   unsigned repeated_base : 1;
2006   unsigned being_defined : 1;
2007   unsigned debug_requested : 1;
2008   unsigned fields_readonly : 1;
2009   unsigned ptrmemfunc_flag : 1;
2010
2011   unsigned was_anonymous : 1;
2012   unsigned lazy_default_ctor : 1;
2013   unsigned lazy_copy_ctor : 1;
2014   unsigned lazy_copy_assign : 1;
2015   unsigned lazy_destructor : 1;
2016   unsigned has_const_copy_ctor : 1;
2017   unsigned has_complex_copy_ctor : 1;
2018   unsigned has_complex_copy_assign : 1;
2019
2020   unsigned non_aggregate : 1;
2021   unsigned has_complex_dflt : 1;
2022   unsigned has_list_ctor : 1;
2023   unsigned non_std_layout : 1;
2024   unsigned is_literal : 1;
2025   unsigned lazy_move_ctor : 1;
2026   unsigned lazy_move_assign : 1;
2027   unsigned has_complex_move_ctor : 1;
2028
2029   unsigned has_complex_move_assign : 1;
2030   unsigned has_constexpr_ctor : 1;
2031   unsigned unique_obj_representations : 1;
2032   unsigned unique_obj_representations_set : 1;
2033
2034   /* When adding a flag here, consider whether or not it ought to
2035      apply to a template instance if it applies to the template.  If
2036      so, make sure to copy it in instantiate_class_template!  */
2037
2038   /* There are some bits left to fill out a 32-bit word.  Keep track
2039      of this by updating the size of this bitfield whenever you add or
2040      remove a flag.  */
2041   unsigned dummy : 4;
2042
2043   tree primary_base;
2044   vec<tree_pair_s, va_gc> *vcall_indices;
2045   tree vtables;
2046   tree typeinfo_var;
2047   vec<tree, va_gc> *vbases;
2048   binding_table nested_udts;
2049   tree as_base;
2050   vec<tree, va_gc> *pure_virtuals;
2051   tree friend_classes;
2052   vec<tree, va_gc> * GTY((reorder ("resort_type_member_vec"))) members;
2053   tree key_method;
2054   tree decl_list;
2055   tree befriending_classes;
2056   /* In a RECORD_TYPE, information specific to Objective-C++, such
2057      as a list of adopted protocols or a pointer to a corresponding
2058      @interface.  See objc/objc-act.h for details.  */
2059   tree objc_info;
2060   /* FIXME reuse another field?  */
2061   tree lambda_expr;
2062 };
2063
2064 /* We used to have a variant type for lang_type.  Keep the name of the
2065    checking accessor for the sole survivor.  */
2066 #define LANG_TYPE_CLASS_CHECK(NODE) (TYPE_LANG_SPECIFIC (NODE))
2067
2068 /* Nonzero for _CLASSTYPE means that operator delete is defined.  */
2069 #define TYPE_GETS_DELETE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->gets_delete)
2070 #define TYPE_GETS_REG_DELETE(NODE) (TYPE_GETS_DELETE (NODE) & 1)
2071
2072 /* Nonzero if `new NODE[x]' should cause the allocation of extra
2073    storage to indicate how many array elements are in use.  */
2074 #define TYPE_VEC_NEW_USES_COOKIE(NODE)                  \
2075   (CLASS_TYPE_P (NODE)                                  \
2076    && LANG_TYPE_CLASS_CHECK (NODE)->vec_new_uses_cookie)
2077
2078 /* Nonzero means that this _CLASSTYPE node defines ways of converting
2079    itself to other types.  */
2080 #define TYPE_HAS_CONVERSION(NODE) \
2081   (LANG_TYPE_CLASS_CHECK (NODE)->has_type_conversion)
2082
2083 /* Nonzero means that NODE (a class type) has a default constructor --
2084    but that it has not yet been declared.  */
2085 #define CLASSTYPE_LAZY_DEFAULT_CTOR(NODE) \
2086   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_default_ctor)
2087
2088 /* Nonzero means that NODE (a class type) has a copy constructor --
2089    but that it has not yet been declared.  */
2090 #define CLASSTYPE_LAZY_COPY_CTOR(NODE) \
2091   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_ctor)
2092
2093 /* Nonzero means that NODE (a class type) has a move constructor --
2094    but that it has not yet been declared.  */
2095 #define CLASSTYPE_LAZY_MOVE_CTOR(NODE) \
2096   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_move_ctor)
2097
2098 /* Nonzero means that NODE (a class type) has an assignment operator
2099    -- but that it has not yet been declared.  */
2100 #define CLASSTYPE_LAZY_COPY_ASSIGN(NODE) \
2101   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_assign)
2102
2103 /* Nonzero means that NODE (a class type) has an assignment operator
2104    -- but that it has not yet been declared.  */
2105 #define CLASSTYPE_LAZY_MOVE_ASSIGN(NODE) \
2106   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_move_assign)
2107
2108 /* Nonzero means that NODE (a class type) has a destructor -- but that
2109    it has not yet been declared.  */
2110 #define CLASSTYPE_LAZY_DESTRUCTOR(NODE) \
2111   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_destructor)
2112
2113 /* Nonzero means that NODE (a class type) is final */
2114 #define CLASSTYPE_FINAL(NODE) \
2115   TYPE_FINAL_P (NODE)
2116
2117
2118 /* Nonzero means that this _CLASSTYPE node overloads operator=(X&).  */
2119 #define TYPE_HAS_COPY_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_copy_assign)
2120
2121 /* True iff the class type NODE has an "operator =" whose parameter
2122    has a parameter of type "const X&".  */
2123 #define TYPE_HAS_CONST_COPY_ASSIGN(NODE) \
2124   (LANG_TYPE_CLASS_CHECK (NODE)->has_const_copy_assign)
2125
2126 /* Nonzero means that this _CLASSTYPE node has an X(X&) constructor.  */
2127 #define TYPE_HAS_COPY_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_copy_ctor)
2128 #define TYPE_HAS_CONST_COPY_CTOR(NODE) \
2129   (LANG_TYPE_CLASS_CHECK (NODE)->has_const_copy_ctor)
2130
2131 /* Nonzero if this class has an X(initializer_list<T>) constructor.  */
2132 #define TYPE_HAS_LIST_CTOR(NODE) \
2133   (LANG_TYPE_CLASS_CHECK (NODE)->has_list_ctor)
2134
2135 /* Nonzero if this class has a constexpr constructor other than a copy/move
2136    constructor.  Note that a class can have constexpr constructors for
2137    static initialization even if it isn't a literal class.  */
2138 #define TYPE_HAS_CONSTEXPR_CTOR(NODE) \
2139   (LANG_TYPE_CLASS_CHECK (NODE)->has_constexpr_ctor)
2140
2141 /* Nonzero if this class defines an overloaded operator new.  (An
2142    operator new [] doesn't count.)  */
2143 #define TYPE_HAS_NEW_OPERATOR(NODE) \
2144   (LANG_TYPE_CLASS_CHECK (NODE)->has_new)
2145
2146 /* Nonzero if this class defines an overloaded operator new[].  */
2147 #define TYPE_HAS_ARRAY_NEW_OPERATOR(NODE) \
2148   (LANG_TYPE_CLASS_CHECK (NODE)->has_array_new)
2149
2150 /* Nonzero means that this type is being defined.  I.e., the left brace
2151    starting the definition of this type has been seen.  */
2152 #define TYPE_BEING_DEFINED(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->being_defined)
2153
2154 /* Nonzero means that this type is either complete or being defined, so we
2155    can do lookup in it.  */
2156 #define COMPLETE_OR_OPEN_TYPE_P(NODE) \
2157   (COMPLETE_TYPE_P (NODE) || (CLASS_TYPE_P (NODE) && TYPE_BEING_DEFINED (NODE)))
2158
2159 /* Mark bits for repeated base checks.  */
2160 #define TYPE_MARKED_P(NODE) TREE_LANG_FLAG_6 (TYPE_CHECK (NODE))
2161
2162 /* Nonzero if the class NODE has multiple paths to the same (virtual)
2163    base object.  */
2164 #define CLASSTYPE_DIAMOND_SHAPED_P(NODE) \
2165   (LANG_TYPE_CLASS_CHECK(NODE)->diamond_shaped)
2166
2167 /* Nonzero if the class NODE has multiple instances of the same base
2168    type.  */
2169 #define CLASSTYPE_REPEATED_BASE_P(NODE) \
2170   (LANG_TYPE_CLASS_CHECK(NODE)->repeated_base)
2171
2172 /* The member function with which the vtable will be emitted:
2173    the first noninline non-pure-virtual member function.  NULL_TREE
2174    if there is no key function or if this is a class template */
2175 #define CLASSTYPE_KEY_METHOD(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->key_method)
2176
2177 /* Vector of members.  During definition, it is unordered and only
2178    member functions are present.  After completion it is sorted and
2179    contains both member functions and non-functions.  STAT_HACK is
2180    involved to preserve oneslot per name invariant.  */
2181 #define CLASSTYPE_MEMBER_VEC(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->members)
2182
2183 /* For class templates, this is a TREE_LIST of all member data,
2184    functions, types, and friends in the order of declaration.
2185    The TREE_PURPOSE of each TREE_LIST is NULL_TREE for a friend,
2186    and the RECORD_TYPE for the class template otherwise.  */
2187 #define CLASSTYPE_DECL_LIST(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->decl_list)
2188
2189 /* A FUNCTION_DECL or OVERLOAD for the constructors for NODE.  These
2190    are the constructors that take an in-charge parameter.  */
2191 #define CLASSTYPE_CONSTRUCTORS(NODE) \
2192   (get_class_binding_direct (NODE, ctor_identifier))
2193
2194 /* A FUNCTION_DECL for the destructor for NODE.  This is the
2195    destructors that take an in-charge parameter.  If
2196    CLASSTYPE_LAZY_DESTRUCTOR is true, then this entry will be NULL
2197    until the destructor is created with lazily_declare_fn.  */
2198 #define CLASSTYPE_DESTRUCTOR(NODE) \
2199   (get_class_binding_direct (NODE, dtor_identifier))
2200
2201 /* A dictionary of the nested user-defined-types (class-types, or enums)
2202    found within this class.  This table includes nested member class
2203    templates.  */
2204 #define CLASSTYPE_NESTED_UTDS(NODE) \
2205    (LANG_TYPE_CLASS_CHECK (NODE)->nested_udts)
2206
2207 /* Nonzero if NODE has a primary base class, i.e., a base class with
2208    which it shares the virtual function table pointer.  */
2209 #define CLASSTYPE_HAS_PRIMARY_BASE_P(NODE) \
2210   (CLASSTYPE_PRIMARY_BINFO (NODE) != NULL_TREE)
2211
2212 /* If non-NULL, this is the binfo for the primary base class, i.e.,
2213    the base class which contains the virtual function table pointer
2214    for this class.  */
2215 #define CLASSTYPE_PRIMARY_BINFO(NODE) \
2216   (LANG_TYPE_CLASS_CHECK (NODE)->primary_base)
2217
2218 /* A vector of BINFOs for the direct and indirect virtual base classes
2219    that this type uses in a post-order depth-first left-to-right
2220    order.  (In other words, these bases appear in the order that they
2221    should be initialized.)  */
2222 #define CLASSTYPE_VBASECLASSES(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->vbases)
2223
2224 /* The type corresponding to NODE when NODE is used as a base class,
2225    i.e., NODE without virtual base classes or tail padding.  */
2226 #define CLASSTYPE_AS_BASE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->as_base)
2227
2228 /* True iff NODE is the CLASSTYPE_AS_BASE version of some type.  */
2229 #define IS_FAKE_BASE_TYPE(NODE)                                 \
2230   (TREE_CODE (NODE) == RECORD_TYPE                              \
2231    && TYPE_CONTEXT (NODE) && CLASS_TYPE_P (TYPE_CONTEXT (NODE)) \
2232    && CLASSTYPE_AS_BASE (TYPE_CONTEXT (NODE)) == (NODE))
2233
2234 /* These are the size and alignment of the type without its virtual
2235    base classes, for when we use this type as a base itself.  */
2236 #define CLASSTYPE_SIZE(NODE) TYPE_SIZE (CLASSTYPE_AS_BASE (NODE))
2237 #define CLASSTYPE_SIZE_UNIT(NODE) TYPE_SIZE_UNIT (CLASSTYPE_AS_BASE (NODE))
2238 #define CLASSTYPE_ALIGN(NODE) TYPE_ALIGN (CLASSTYPE_AS_BASE (NODE))
2239 #define CLASSTYPE_USER_ALIGN(NODE) TYPE_USER_ALIGN (CLASSTYPE_AS_BASE (NODE))
2240
2241 /* The alignment of NODE, without its virtual bases, in bytes.  */
2242 #define CLASSTYPE_ALIGN_UNIT(NODE) \
2243   (CLASSTYPE_ALIGN (NODE) / BITS_PER_UNIT)
2244
2245 /* A vec<tree> of virtual functions which cannot be inherited by
2246    derived classes.  When deriving from this type, the derived
2247    class must provide its own definition for each of these functions.  */
2248 #define CLASSTYPE_PURE_VIRTUALS(NODE) \
2249   (LANG_TYPE_CLASS_CHECK (NODE)->pure_virtuals)
2250
2251 /* Nonzero means that this type is an abstract class type.  */
2252 #define ABSTRACT_CLASS_TYPE_P(NODE) \
2253   (CLASS_TYPE_P (NODE) && CLASSTYPE_PURE_VIRTUALS(NODE))
2254
2255 /* Nonzero means that this type has an X() constructor.  */
2256 #define TYPE_HAS_DEFAULT_CONSTRUCTOR(NODE) \
2257   (LANG_TYPE_CLASS_CHECK (NODE)->has_default_ctor)
2258
2259 /* Nonzero means that this type contains a mutable member.  */
2260 #define CLASSTYPE_HAS_MUTABLE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_mutable)
2261 #define TYPE_HAS_MUTABLE_P(NODE) (cp_has_mutable_p (NODE))
2262
2263 /* Nonzero means that this class type is not POD for the purpose of layout
2264    (as defined in the ABI).  This is different from the language's POD.  */
2265 #define CLASSTYPE_NON_LAYOUT_POD_P(NODE) \
2266   (LANG_TYPE_CLASS_CHECK (NODE)->non_pod_class)
2267
2268 /* Nonzero means that this class type is a non-standard-layout class.  */
2269 #define CLASSTYPE_NON_STD_LAYOUT(NODE) \
2270   (LANG_TYPE_CLASS_CHECK (NODE)->non_std_layout)
2271
2272 /* Nonzero means that this class type does have unique object
2273    representations.  */
2274 #define CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS(NODE) \
2275   (LANG_TYPE_CLASS_CHECK (NODE)->unique_obj_representations)
2276
2277 /* Nonzero means that this class type has
2278    CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS computed.  */
2279 #define CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET(NODE) \
2280   (LANG_TYPE_CLASS_CHECK (NODE)->unique_obj_representations_set)
2281
2282 /* Nonzero means that this class contains pod types whose default
2283    initialization is not a zero initialization (namely, pointers to
2284    data members).  */
2285 #define CLASSTYPE_NON_ZERO_INIT_P(NODE) \
2286   (LANG_TYPE_CLASS_CHECK (NODE)->non_zero_init)
2287
2288 /* Nonzero if this class is "empty" in the sense of the C++ ABI.  */
2289 #define CLASSTYPE_EMPTY_P(NODE) \
2290   (LANG_TYPE_CLASS_CHECK (NODE)->empty_p)
2291
2292 /* Nonzero if this class is "nearly empty", i.e., contains only a
2293    virtual function table pointer.  */
2294 #define CLASSTYPE_NEARLY_EMPTY_P(NODE) \
2295   (LANG_TYPE_CLASS_CHECK (NODE)->nearly_empty_p)
2296
2297 /* Nonzero if this class contains an empty subobject.  */
2298 #define CLASSTYPE_CONTAINS_EMPTY_CLASS_P(NODE) \
2299   (LANG_TYPE_CLASS_CHECK (NODE)->contains_empty_class_p)
2300
2301 /* A list of class types of which this type is a friend.  The
2302    TREE_VALUE is normally a TYPE, but will be a TEMPLATE_DECL in the
2303    case of a template friend.  */
2304 #define CLASSTYPE_FRIEND_CLASSES(NODE) \
2305   (LANG_TYPE_CLASS_CHECK (NODE)->friend_classes)
2306
2307 /* A list of the classes which grant friendship to this class.  */
2308 #define CLASSTYPE_BEFRIENDING_CLASSES(NODE) \
2309   (LANG_TYPE_CLASS_CHECK (NODE)->befriending_classes)
2310
2311 /* The associated LAMBDA_EXPR that made this class.  */
2312 #define CLASSTYPE_LAMBDA_EXPR(NODE) \
2313   (LANG_TYPE_CLASS_CHECK (NODE)->lambda_expr)
2314 /* The extra mangling scope for this closure type.  */
2315 #define LAMBDA_TYPE_EXTRA_SCOPE(NODE) \
2316   (LAMBDA_EXPR_EXTRA_SCOPE (CLASSTYPE_LAMBDA_EXPR (NODE)))
2317
2318 /* Say whether this node was declared as a "class" or a "struct".  */
2319 #define CLASSTYPE_DECLARED_CLASS(NODE) \
2320   (LANG_TYPE_CLASS_CHECK (NODE)->declared_class)
2321
2322 /* Nonzero if this class has const members
2323    which have no specified initialization.  */
2324 #define CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE)       \
2325   (TYPE_LANG_SPECIFIC (NODE)                            \
2326    ? LANG_TYPE_CLASS_CHECK (NODE)->const_needs_init : 0)
2327 #define SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE, VALUE) \
2328   (LANG_TYPE_CLASS_CHECK (NODE)->const_needs_init = (VALUE))
2329
2330 /* Nonzero if this class has ref members
2331    which have no specified initialization.  */
2332 #define CLASSTYPE_REF_FIELDS_NEED_INIT(NODE)            \
2333   (TYPE_LANG_SPECIFIC (NODE)                            \
2334    ? LANG_TYPE_CLASS_CHECK (NODE)->ref_needs_init : 0)
2335 #define SET_CLASSTYPE_REF_FIELDS_NEED_INIT(NODE, VALUE) \
2336   (LANG_TYPE_CLASS_CHECK (NODE)->ref_needs_init = (VALUE))
2337
2338 /* Nonzero if this class is included from a header file which employs
2339    `#pragma interface', and it is not included in its implementation file.  */
2340 #define CLASSTYPE_INTERFACE_ONLY(NODE) \
2341   (LANG_TYPE_CLASS_CHECK (NODE)->interface_only)
2342
2343 /* True if we have already determined whether or not vtables, VTTs,
2344    typeinfo, and other similar per-class data should be emitted in
2345    this translation unit.  This flag does not indicate whether or not
2346    these items should be emitted; it only indicates that we know one
2347    way or the other.  */
2348 #define CLASSTYPE_INTERFACE_KNOWN(NODE) \
2349   (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown == 0)
2350 /* The opposite of CLASSTYPE_INTERFACE_KNOWN.  */
2351 #define CLASSTYPE_INTERFACE_UNKNOWN(NODE) \
2352   (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown)
2353
2354 #define SET_CLASSTYPE_INTERFACE_UNKNOWN_X(NODE,X) \
2355   (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = !!(X))
2356 #define SET_CLASSTYPE_INTERFACE_UNKNOWN(NODE) \
2357   (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 1)
2358 #define SET_CLASSTYPE_INTERFACE_KNOWN(NODE) \
2359   (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 0)
2360
2361 /* Nonzero if a _DECL node requires us to output debug info for this class.  */
2362 #define CLASSTYPE_DEBUG_REQUESTED(NODE) \
2363   (LANG_TYPE_CLASS_CHECK (NODE)->debug_requested)
2364 \f
2365 /* Additional macros for inheritance information.  */
2366
2367 /* Nonzero means that this class is on a path leading to a new vtable.  */
2368 #define BINFO_VTABLE_PATH_MARKED(NODE) BINFO_FLAG_1 (NODE)
2369
2370 /* Nonzero means B (a BINFO) has its own vtable.  Any copies will not
2371    have this flag set.  */
2372 #define BINFO_NEW_VTABLE_MARKED(B) (BINFO_FLAG_2 (B))
2373
2374 /* Compare a BINFO_TYPE with another type for equality.  For a binfo,
2375    this is functionally equivalent to using same_type_p, but
2376    measurably faster.  At least one of the arguments must be a
2377    BINFO_TYPE.  The other can be a BINFO_TYPE or a regular type.  If
2378    BINFO_TYPE(T) ever stops being the main variant of the class the
2379    binfo is for, this macro must change.  */
2380 #define SAME_BINFO_TYPE_P(A, B) ((A) == (B))
2381
2382 /* Any subobject that needs a new vtable must have a vptr and must not
2383    be a non-virtual primary base (since it would then use the vtable from a
2384    derived class and never become non-primary.)  */
2385 #define SET_BINFO_NEW_VTABLE_MARKED(B)                                   \
2386   (BINFO_NEW_VTABLE_MARKED (B) = 1,                                      \
2387    gcc_assert (!BINFO_PRIMARY_P (B) || BINFO_VIRTUAL_P (B)),             \
2388    gcc_assert (TYPE_VFIELD (BINFO_TYPE (B))))
2389
2390 /* Nonzero if this binfo is for a dependent base - one that should not
2391    be searched.  */
2392 #define BINFO_DEPENDENT_BASE_P(NODE) BINFO_FLAG_3 (NODE)
2393
2394 /* Nonzero if this binfo has lost its primary base binfo (because that
2395    is a nearly-empty virtual base that has been taken by some other
2396    base in the complete hierarchy.  */
2397 #define BINFO_LOST_PRIMARY_P(NODE) BINFO_FLAG_4 (NODE)
2398
2399 /* Nonzero if this BINFO is a primary base class.  */
2400 #define BINFO_PRIMARY_P(NODE) BINFO_FLAG_5(NODE)
2401 \f
2402 /* A vec<tree_pair_s> of the vcall indices associated with the class
2403    NODE.  The PURPOSE of each element is a FUNCTION_DECL for a virtual
2404    function.  The VALUE is the index into the virtual table where the
2405    vcall offset for that function is stored, when NODE is a virtual
2406    base.  */
2407 #define CLASSTYPE_VCALL_INDICES(NODE) \
2408   (LANG_TYPE_CLASS_CHECK (NODE)->vcall_indices)
2409
2410 /* The various vtables for the class NODE.  The primary vtable will be
2411    first, followed by the construction vtables and VTT, if any.  */
2412 #define CLASSTYPE_VTABLES(NODE) \
2413   (LANG_TYPE_CLASS_CHECK (NODE)->vtables)
2414
2415 /* The std::type_info variable representing this class, or NULL if no
2416    such variable has been created.  This field is only set for the
2417    TYPE_MAIN_VARIANT of the class.  */
2418 #define CLASSTYPE_TYPEINFO_VAR(NODE) \
2419   (LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var)
2420
2421 /* Accessor macros for the BINFO_VIRTUALS list.  */
2422
2423 /* The number of bytes by which to adjust the `this' pointer when
2424    calling this virtual function.  Subtract this value from the this
2425    pointer. Always non-NULL, might be constant zero though.  */
2426 #define BV_DELTA(NODE) (TREE_PURPOSE (NODE))
2427
2428 /* If non-NULL, the vtable index at which to find the vcall offset
2429    when calling this virtual function.  Add the value at that vtable
2430    index to the this pointer.  */
2431 #define BV_VCALL_INDEX(NODE) (TREE_TYPE (NODE))
2432
2433 /* The function to call.  */
2434 #define BV_FN(NODE) (TREE_VALUE (NODE))
2435
2436 /* Whether or not this entry is for a lost primary virtual base.  */
2437 #define BV_LOST_PRIMARY(NODE) (TREE_LANG_FLAG_0 (NODE))
2438 \f
2439 /* For FUNCTION_TYPE or METHOD_TYPE, a list of the exceptions that
2440    this type can raise.  Each TREE_VALUE is a _TYPE.  The TREE_VALUE
2441    will be NULL_TREE to indicate a throw specification of `()', or
2442    no exceptions allowed.  For a noexcept specification, TREE_VALUE
2443    is NULL_TREE and TREE_PURPOSE is the constant-expression.  For
2444    a deferred noexcept-specification, TREE_PURPOSE is a DEFERRED_NOEXCEPT
2445    (for templates) or an OVERLOAD list of functions (for implicitly
2446    declared functions).  */
2447 #define TYPE_RAISES_EXCEPTIONS(NODE) \
2448   TYPE_LANG_SLOT_1 (FUNC_OR_METHOD_CHECK (NODE))
2449
2450 /* For FUNCTION_TYPE or METHOD_TYPE, return 1 iff it is declared `throw()'
2451    or noexcept(true).  */
2452 #define TYPE_NOTHROW_P(NODE) nothrow_spec_p (TYPE_RAISES_EXCEPTIONS (NODE))
2453
2454 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept.  This is the
2455    case for things declared noexcept(true) and, with -fnothrow-opt, for
2456    throw() functions.  */
2457 #define TYPE_NOEXCEPT_P(NODE) type_noexcept_p (NODE)
2458
2459 /* The binding level associated with the namespace.  */
2460 #define NAMESPACE_LEVEL(NODE) \
2461   (LANG_DECL_NS_CHECK (NODE)->level)
2462 \f
2463 /* Discriminator values for lang_decl.  */
2464
2465 enum lang_decl_selector
2466 {
2467   lds_min,
2468   lds_fn,
2469   lds_ns,
2470   lds_parm,
2471   lds_decomp
2472 };
2473
2474 /* Flags shared by all forms of DECL_LANG_SPECIFIC.
2475
2476    Some of the flags live here only to make lang_decl_min/fn smaller.  Do
2477    not make this struct larger than 32 bits; instead, make sel smaller.  */
2478
2479 struct GTY(()) lang_decl_base {
2480   /* Larger than necessary for faster access.  */
2481   ENUM_BITFIELD(lang_decl_selector) selector : 16;
2482   ENUM_BITFIELD(languages) language : 1;
2483   unsigned use_template : 2;
2484   unsigned not_really_extern : 1;          /* var or fn */
2485   unsigned initialized_in_class : 1;       /* var or fn */
2486   unsigned repo_available_p : 1;           /* var or fn */
2487   unsigned threadprivate_or_deleted_p : 1; /* var or fn */
2488   unsigned anticipated_p : 1;              /* fn, type or template */
2489   /* anticipated_p reused as DECL_OMP_PRIVATIZED_MEMBER in var */
2490   unsigned friend_or_tls : 1;              /* var, fn, type or template */
2491   unsigned unknown_bound_p : 1;            /* var */
2492   unsigned odr_used : 1;                   /* var or fn */
2493   unsigned u2sel : 1;
2494   unsigned concept_p : 1;                  /* applies to vars and functions */
2495   unsigned var_declared_inline_p : 1;      /* var */
2496   unsigned dependent_init_p : 1;           /* var */
2497   /* 1 spare bit */
2498 };
2499
2500 /* True for DECL codes which have template info and access.  */
2501 #define LANG_DECL_HAS_MIN(NODE)                 \
2502   (VAR_OR_FUNCTION_DECL_P (NODE)                \
2503    || TREE_CODE (NODE) == FIELD_DECL            \
2504    || TREE_CODE (NODE) == CONST_DECL            \
2505    || TREE_CODE (NODE) == TYPE_DECL             \
2506    || TREE_CODE (NODE) == TEMPLATE_DECL         \
2507    || TREE_CODE (NODE) == USING_DECL)
2508
2509 /* DECL_LANG_SPECIFIC for the above codes.  */
2510
2511 struct GTY(()) lang_decl_min {
2512   struct lang_decl_base base;
2513
2514   /* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is
2515      THUNK_ALIAS.
2516      In a FUNCTION_DECL for which DECL_THUNK_P does not hold,
2517      VAR_DECL, TYPE_DECL, or TEMPLATE_DECL, this is
2518      DECL_TEMPLATE_INFO.  */
2519   tree template_info;
2520
2521   union lang_decl_u2 {
2522     /* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is
2523        THUNK_VIRTUAL_OFFSET.
2524        In a VAR_DECL for which DECL_HAS_VALUE_EXPR_P holds,
2525        this is DECL_CAPTURED_VARIABLE.
2526        Otherwise this is DECL_ACCESS.  */
2527     tree GTY ((tag ("0"))) access;
2528
2529     /* For TREE_STATIC VAR_DECL in function, this is DECL_DISCRIMINATOR.  */
2530     int GTY ((tag ("1"))) discriminator;
2531   } GTY ((desc ("%0.u.base.u2sel"))) u2;
2532 };
2533
2534 /* Additional DECL_LANG_SPECIFIC information for functions.  */
2535
2536 struct GTY(()) lang_decl_fn {
2537   struct lang_decl_min min;
2538
2539   /* In a overloaded operator, this is the compressed operator code.  */
2540   unsigned ovl_op_code : 6;
2541   unsigned global_ctor_p : 1;
2542   unsigned global_dtor_p : 1;
2543
2544   unsigned static_function : 1;
2545   unsigned pure_virtual : 1;
2546   unsigned defaulted_p : 1;
2547   unsigned has_in_charge_parm_p : 1;
2548   unsigned has_vtt_parm_p : 1;
2549   unsigned pending_inline_p : 1;
2550   unsigned nonconverting : 1;
2551   unsigned thunk_p : 1;
2552
2553   unsigned this_thunk_p : 1;
2554   unsigned hidden_friend_p : 1;
2555   unsigned omp_declare_reduction_p : 1;
2556   unsigned spare : 13;
2557
2558   /* 32-bits padding on 64-bit host.  */
2559
2560   /* For a non-thunk function decl, this is a tree list of
2561      friendly classes. For a thunk function decl, it is the
2562      thunked to function decl.  */
2563   tree befriending_classes;
2564
2565   /* For a non-virtual FUNCTION_DECL, this is
2566      DECL_FRIEND_CONTEXT.  For a virtual FUNCTION_DECL for which
2567      DECL_THIS_THUNK_P does not hold, this is DECL_THUNKS. Both
2568      this pointer and result pointer adjusting thunks are
2569      chained here.  This pointer thunks to return pointer thunks
2570      will be chained on the return pointer thunk.  */
2571   tree context;
2572
2573   union lang_decl_u5
2574   {
2575     /* In a non-thunk FUNCTION_DECL or TEMPLATE_DECL, this is
2576        DECL_CLONED_FUNCTION.  */
2577     tree GTY ((tag ("0"))) cloned_function;
2578
2579     /* In a FUNCTION_DECL for which THUNK_P holds this is the
2580        THUNK_FIXED_OFFSET.  */
2581     HOST_WIDE_INT GTY ((tag ("1"))) fixed_offset;
2582   } GTY ((desc ("%1.thunk_p"))) u5;
2583
2584   union lang_decl_u3
2585   {
2586     struct cp_token_cache * GTY ((tag ("1"))) pending_inline_info;
2587     struct language_function * GTY ((tag ("0")))
2588       saved_language_function;
2589   } GTY ((desc ("%1.pending_inline_p"))) u;
2590
2591 };
2592
2593 /* DECL_LANG_SPECIFIC for namespaces.  */
2594
2595 struct GTY(()) lang_decl_ns {
2596   struct lang_decl_base base;
2597   cp_binding_level *level;
2598
2599   /* using directives and inline children.  These need to be va_gc,
2600      because of PCH.  */
2601   vec<tree, va_gc> *usings;
2602   vec<tree, va_gc> *inlinees;
2603
2604   /* Hash table of bound decls. It'd be nice to have this inline, but
2605      as the hash_map has a dtor, we can't then put this struct into a
2606      union (until moving to c++11).  */
2607   hash_table<named_decl_hash> *bindings;
2608 };
2609
2610 /* DECL_LANG_SPECIFIC for parameters.  */
2611
2612 struct GTY(()) lang_decl_parm {
2613   struct lang_decl_base base;
2614   int level;
2615   int index;
2616 };
2617
2618 /* Additional DECL_LANG_SPECIFIC information for structured bindings.  */
2619
2620 struct GTY(()) lang_decl_decomp {
2621   struct lang_decl_min min;
2622   /* The artificial underlying "e" variable of the structured binding
2623      variable.  */
2624   tree base;
2625 };
2626
2627 /* DECL_LANG_SPECIFIC for all types.  It would be nice to just make this a
2628    union rather than a struct containing a union as its only field, but
2629    tree.h declares it as a struct.  */
2630
2631 struct GTY(()) lang_decl {
2632   union GTY((desc ("%h.base.selector"))) lang_decl_u {
2633      /* Nothing of only the base type exists.  */
2634     struct lang_decl_base GTY ((default)) base;
2635     struct lang_decl_min GTY((tag ("lds_min"))) min;
2636     struct lang_decl_fn GTY ((tag ("lds_fn"))) fn;
2637     struct lang_decl_ns GTY((tag ("lds_ns"))) ns;
2638     struct lang_decl_parm GTY((tag ("lds_parm"))) parm;
2639     struct lang_decl_decomp GTY((tag ("lds_decomp"))) decomp;
2640   } u;
2641 };
2642
2643 /* Looks through a template (if present) to find what it declares.  */
2644 #define STRIP_TEMPLATE(NODE) \
2645   (TREE_CODE (NODE) == TEMPLATE_DECL ? DECL_TEMPLATE_RESULT (NODE) : NODE)
2646
2647 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
2648
2649 #define LANG_DECL_MIN_CHECK(NODE) __extension__                 \
2650 ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE);            \
2651    if (!LANG_DECL_HAS_MIN (NODE))                               \
2652      lang_check_failed (__FILE__, __LINE__, __FUNCTION__);      \
2653    &lt->u.min; })
2654
2655 /* We want to be able to check DECL_CONSTRUCTOR_P and such on a function
2656    template, not just on a FUNCTION_DECL.  So when looking for things in
2657    lang_decl_fn, look down through a TEMPLATE_DECL into its result.  */
2658 #define LANG_DECL_FN_CHECK(NODE) __extension__                          \
2659 ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (STRIP_TEMPLATE (NODE));   \
2660    if (!DECL_DECLARES_FUNCTION_P (NODE)                                 \
2661        || lt->u.base.selector != lds_fn)                                \
2662      lang_check_failed (__FILE__, __LINE__, __FUNCTION__);              \
2663    &lt->u.fn; })
2664
2665 #define LANG_DECL_NS_CHECK(NODE) __extension__                          \
2666 ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE);                    \
2667    if (TREE_CODE (NODE) != NAMESPACE_DECL                               \
2668        || lt->u.base.selector != lds_ns)                                \
2669      lang_check_failed (__FILE__, __LINE__, __FUNCTION__);              \
2670    &lt->u.ns; })
2671
2672 #define LANG_DECL_PARM_CHECK(NODE) __extension__                \
2673 ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE);            \
2674   if (TREE_CODE (NODE) != PARM_DECL                             \
2675       || lt->u.base.selector != lds_parm)                       \
2676     lang_check_failed (__FILE__, __LINE__, __FUNCTION__);       \
2677   &lt->u.parm; })
2678
2679 #define LANG_DECL_DECOMP_CHECK(NODE) __extension__              \
2680 ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE);            \
2681   if (!VAR_P (NODE)                                             \
2682       || lt->u.base.selector != lds_decomp)                     \
2683     lang_check_failed (__FILE__, __LINE__, __FUNCTION__);       \
2684   &lt->u.decomp; })
2685
2686 #define LANG_DECL_U2_CHECK(NODE, TF) __extension__              \
2687 ({  struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE);           \
2688     if (!LANG_DECL_HAS_MIN (NODE) || lt->u.base.u2sel != TF)    \
2689       lang_check_failed (__FILE__, __LINE__, __FUNCTION__);     \
2690     &lt->u.min.u2; })
2691
2692 #else
2693
2694 #define LANG_DECL_MIN_CHECK(NODE) \
2695   (&DECL_LANG_SPECIFIC (NODE)->u.min)
2696
2697 #define LANG_DECL_FN_CHECK(NODE) \
2698   (&DECL_LANG_SPECIFIC (STRIP_TEMPLATE (NODE))->u.fn)
2699
2700 #define LANG_DECL_NS_CHECK(NODE) \
2701   (&DECL_LANG_SPECIFIC (NODE)->u.ns)
2702
2703 #define LANG_DECL_PARM_CHECK(NODE) \
2704   (&DECL_LANG_SPECIFIC (NODE)->u.parm)
2705
2706 #define LANG_DECL_DECOMP_CHECK(NODE) \
2707   (&DECL_LANG_SPECIFIC (NODE)->u.decomp)
2708
2709 #define LANG_DECL_U2_CHECK(NODE, TF) \
2710   (&DECL_LANG_SPECIFIC (NODE)->u.min.u2)
2711
2712 #endif /* ENABLE_TREE_CHECKING */
2713
2714 /* For a FUNCTION_DECL or a VAR_DECL, the language linkage for the
2715    declaration.  Some entities (like a member function in a local
2716    class, or a local variable) do not have linkage at all, and this
2717    macro should not be used in those cases.
2718
2719    Implementation note: A FUNCTION_DECL without DECL_LANG_SPECIFIC was
2720    created by language-independent code, and has C linkage.  Most
2721    VAR_DECLs have C++ linkage, and do not have DECL_LANG_SPECIFIC, but
2722    we do create DECL_LANG_SPECIFIC for variables with non-C++ linkage.  */
2723 #define DECL_LANGUAGE(NODE)                             \
2724   (DECL_LANG_SPECIFIC (NODE)                            \
2725    ? DECL_LANG_SPECIFIC (NODE)->u.base.language         \
2726    : (TREE_CODE (NODE) == FUNCTION_DECL                 \
2727       ? lang_c : lang_cplusplus))
2728
2729 /* Set the language linkage for NODE to LANGUAGE.  */
2730 #define SET_DECL_LANGUAGE(NODE, LANGUAGE) \
2731   (DECL_LANG_SPECIFIC (NODE)->u.base.language = (LANGUAGE))
2732
2733 /* For FUNCTION_DECLs and TEMPLATE_DECLs: nonzero means that this function
2734    is a constructor.  */
2735 #define DECL_CONSTRUCTOR_P(NODE) \
2736   IDENTIFIER_CTOR_P (DECL_NAME (NODE))
2737
2738 /* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a complete
2739    object.  */
2740 #define DECL_COMPLETE_CONSTRUCTOR_P(NODE)               \
2741   (DECL_NAME (NODE) == complete_ctor_identifier)
2742
2743 /* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a base
2744    object.  */
2745 #define DECL_BASE_CONSTRUCTOR_P(NODE)           \
2746   (DECL_NAME (NODE) == base_ctor_identifier)
2747
2748 /* Nonzero if NODE (a FUNCTION_DECL) is a constructor, but not either the
2749    specialized in-charge constructor or the specialized not-in-charge
2750    constructor.  */
2751 #define DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P(NODE)                \
2752   (DECL_NAME (NODE) == ctor_identifier)
2753
2754 /* Nonzero if NODE (a FUNCTION_DECL) is a copy constructor.  */
2755 #define DECL_COPY_CONSTRUCTOR_P(NODE) \
2756   (DECL_CONSTRUCTOR_P (NODE) && copy_fn_p (NODE) > 0)
2757
2758 /* Nonzero if NODE (a FUNCTION_DECL) is a move constructor.  */
2759 #define DECL_MOVE_CONSTRUCTOR_P(NODE) \
2760   (DECL_CONSTRUCTOR_P (NODE) && move_fn_p (NODE))
2761
2762 /* Nonzero if NODE (a FUNCTION_DECL or TEMPLATE_DECL)
2763    is a destructor.  */
2764 #define DECL_DESTRUCTOR_P(NODE)                         \
2765   IDENTIFIER_DTOR_P (DECL_NAME (NODE))
2766
2767 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor, but not the
2768    specialized in-charge constructor, in-charge deleting constructor,
2769    or the base destructor.  */
2770 #define DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P(NODE)                 \
2771   (DECL_NAME (NODE) == dtor_identifier)
2772
2773 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete
2774    object.  */
2775 #define DECL_COMPLETE_DESTRUCTOR_P(NODE)                \
2776   (DECL_NAME (NODE) == complete_dtor_identifier)
2777
2778 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a base
2779    object.  */
2780 #define DECL_BASE_DESTRUCTOR_P(NODE)            \
2781   (DECL_NAME (NODE) == base_dtor_identifier)
2782
2783 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete
2784    object that deletes the object after it has been destroyed.  */
2785 #define DECL_DELETING_DESTRUCTOR_P(NODE)                \
2786   (DECL_NAME (NODE) == deleting_dtor_identifier)
2787
2788 /* Nonzero if NODE (a FUNCTION_DECL) is a cloned constructor or
2789    destructor.  */
2790 #define DECL_CLONED_FUNCTION_P(NODE) (!!decl_cloned_function_p (NODE, true))
2791
2792 /* If DECL_CLONED_FUNCTION_P holds, this is the function that was
2793    cloned.  */
2794 #define DECL_CLONED_FUNCTION(NODE) (*decl_cloned_function_p (NODE, false))
2795
2796 /* Perform an action for each clone of FN, if FN is a function with
2797    clones.  This macro should be used like:
2798
2799       FOR_EACH_CLONE (clone, fn)
2800         { ... }
2801
2802   */
2803 #define FOR_EACH_CLONE(CLONE, FN)                       \
2804   if (!(TREE_CODE (FN) == FUNCTION_DECL                 \
2805         && (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (FN)     \
2806             || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (FN))))\
2807     ;                                                   \
2808   else                                                  \
2809     for (CLONE = DECL_CHAIN (FN);                       \
2810          CLONE && DECL_CLONED_FUNCTION_P (CLONE);       \
2811          CLONE = DECL_CHAIN (CLONE))
2812
2813 /* Nonzero if NODE has DECL_DISCRIMINATOR and not DECL_ACCESS.  */
2814 #define DECL_DISCRIMINATOR_P(NODE)      \
2815   (VAR_P (NODE) && DECL_FUNCTION_SCOPE_P (NODE))
2816
2817 /* Discriminator for name mangling.  */
2818 #define DECL_DISCRIMINATOR(NODE) (LANG_DECL_U2_CHECK (NODE, 1)->discriminator)
2819
2820 /* True iff DECL_DISCRIMINATOR is set for a DECL_DISCRIMINATOR_P decl.  */
2821 #define DECL_DISCRIMINATOR_SET_P(NODE) \
2822   (DECL_LANG_SPECIFIC (NODE) && DECL_LANG_SPECIFIC (NODE)->u.base.u2sel == 1)
2823
2824 /* The index of a user-declared parameter in its function, starting at 1.
2825    All artificial parameters will have index 0.  */
2826 #define DECL_PARM_INDEX(NODE) \
2827   (LANG_DECL_PARM_CHECK (NODE)->index)
2828
2829 /* The level of a user-declared parameter in its function, starting at 1.
2830    A parameter of the function will have level 1; a parameter of the first
2831    nested function declarator (i.e. t in void f (void (*p)(T t))) will have
2832    level 2.  */
2833 #define DECL_PARM_LEVEL(NODE) \
2834   (LANG_DECL_PARM_CHECK (NODE)->level)
2835
2836 /* Nonzero if the VTT parm has been added to NODE.  */
2837 #define DECL_HAS_VTT_PARM_P(NODE) \
2838   (LANG_DECL_FN_CHECK (NODE)->has_vtt_parm_p)
2839
2840 /* Nonzero if NODE is a FUNCTION_DECL for which a VTT parameter is
2841    required.  */
2842 #define DECL_NEEDS_VTT_PARM_P(NODE)                     \
2843   (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (NODE))         \
2844    && (DECL_BASE_CONSTRUCTOR_P (NODE)                   \
2845        || DECL_BASE_DESTRUCTOR_P (NODE)))
2846
2847 /* Nonzero if NODE is a user-defined conversion operator.  */
2848 #define DECL_CONV_FN_P(NODE) IDENTIFIER_CONV_OP_P (DECL_NAME (NODE))
2849
2850 /* The type to which conversion operator FN converts to.   */
2851 #define DECL_CONV_FN_TYPE(FN) \
2852   TREE_TYPE ((gcc_checking_assert (DECL_CONV_FN_P (FN)), DECL_NAME (FN)))
2853
2854 /* Nonzero if NODE, a static data member, was declared in its class as an
2855    array of unknown bound.  */
2856 #define VAR_HAD_UNKNOWN_BOUND(NODE)                     \
2857   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))           \
2858    ? DECL_LANG_SPECIFIC (NODE)->u.base.unknown_bound_p  \
2859    : false)
2860 #define SET_VAR_HAD_UNKNOWN_BOUND(NODE) \
2861   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.unknown_bound_p = true)
2862
2863 /* True iff decl NODE is for an overloaded operator.  */
2864 #define DECL_OVERLOADED_OPERATOR_P(NODE)                \
2865   IDENTIFIER_ANY_OP_P (DECL_NAME (NODE))
2866
2867 /* Nonzero if NODE is an assignment operator (including += and such).  */
2868 #define DECL_ASSIGNMENT_OPERATOR_P(NODE)                 \
2869   IDENTIFIER_ASSIGN_OP_P (DECL_NAME (NODE))
2870
2871 /* NODE is a function_decl for an overloaded operator.  Return its
2872    compressed (raw) operator code.  Note that this is not a TREE_CODE.  */
2873 #define DECL_OVERLOADED_OPERATOR_CODE_RAW(NODE)         \
2874   (LANG_DECL_FN_CHECK (NODE)->ovl_op_code)
2875
2876 /* DECL is an overloaded operator.  Test whether it is for TREE_CODE
2877    (a literal constant).  */
2878 #define DECL_OVERLOADED_OPERATOR_IS(DECL, CODE)                 \
2879   (DECL_OVERLOADED_OPERATOR_CODE_RAW (DECL) == OVL_OP_##CODE)
2880
2881 /* For FUNCTION_DECLs: nonzero means that this function is a
2882    constructor or a destructor with an extra in-charge parameter to
2883    control whether or not virtual bases are constructed.  */
2884 #define DECL_HAS_IN_CHARGE_PARM_P(NODE) \
2885   (LANG_DECL_FN_CHECK (NODE)->has_in_charge_parm_p)
2886
2887 /* Nonzero if DECL is a declaration of __builtin_constant_p.  */
2888 #define DECL_IS_BUILTIN_CONSTANT_P(NODE)                \
2889  (TREE_CODE (NODE) == FUNCTION_DECL                     \
2890   && DECL_BUILT_IN_CLASS (NODE) == BUILT_IN_NORMAL      \
2891   && DECL_FUNCTION_CODE (NODE) == BUILT_IN_CONSTANT_P)
2892
2893 /* Nonzero for _DECL means that this decl appears in (or will appear
2894    in) as a member in a RECORD_TYPE or UNION_TYPE node.  It is also for
2895    detecting circularity in case members are multiply defined.  In the
2896    case of a VAR_DECL, it is also used to determine how program storage
2897    should be allocated.  */
2898 #define DECL_IN_AGGR_P(NODE) (DECL_LANG_FLAG_3 (NODE))
2899
2900 /* Nonzero for a VAR_DECL means that the variable's initialization (if
2901    any) has been processed.  (In general, DECL_INITIALIZED_P is
2902    !DECL_EXTERNAL, but static data members may be initialized even if
2903    not defined.)  */
2904 #define DECL_INITIALIZED_P(NODE) \
2905    (TREE_LANG_FLAG_1 (VAR_DECL_CHECK (NODE)))
2906
2907 /* Nonzero for a VAR_DECL iff an explicit initializer was provided
2908    or a non-trivial constructor is called.  */
2909 #define DECL_NONTRIVIALLY_INITIALIZED_P(NODE)   \
2910    (TREE_LANG_FLAG_3 (VAR_DECL_CHECK (NODE)))
2911
2912 /* Nonzero for a VAR_DECL that was initialized with a
2913    constant-expression.  */
2914 #define DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P(NODE) \
2915   (TREE_LANG_FLAG_2 (VAR_DECL_CHECK (NODE)))
2916
2917 /* Nonzero if the DECL was initialized in the class definition itself,
2918    rather than outside the class.  This is used for both static member
2919    VAR_DECLS, and FUNCTION_DECLS that are defined in the class.  */
2920 #define DECL_INITIALIZED_IN_CLASS_P(DECL) \
2921   (DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL)) \
2922    ->u.base.initialized_in_class)
2923
2924 /* Nonzero if the DECL is used in the sense of 3.2 [basic.def.odr].
2925    Only available for decls with DECL_LANG_SPECIFIC.  */
2926 #define DECL_ODR_USED(DECL) \
2927   (DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL)) \
2928    ->u.base.odr_used)
2929
2930 /* Nonzero for DECL means that this decl is just a friend declaration,
2931    and should not be added to the list of members for this class.  */
2932 #define DECL_FRIEND_P(NODE) \
2933   (DECL_LANG_SPECIFIC (TYPE_FUNCTION_OR_TEMPLATE_DECL_CHECK (NODE)) \
2934    ->u.base.friend_or_tls)
2935
2936 /* Nonzero if the thread-local variable was declared with __thread as
2937    opposed to thread_local.  */
2938 #define DECL_GNU_TLS_P(NODE)                            \
2939   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))           \
2940    && DECL_LANG_SPECIFIC (NODE)->u.base.friend_or_tls)
2941 #define SET_DECL_GNU_TLS_P(NODE)                                \
2942   (retrofit_lang_decl (VAR_DECL_CHECK (NODE)),                  \
2943    DECL_LANG_SPECIFIC (NODE)->u.base.friend_or_tls = true)
2944
2945 /* A TREE_LIST of the types which have befriended this FUNCTION_DECL.  */
2946 #define DECL_BEFRIENDING_CLASSES(NODE) \
2947   (LANG_DECL_FN_CHECK (NODE)->befriending_classes)
2948
2949 /* Nonzero for FUNCTION_DECL means that this decl is a static
2950    member function.  */
2951 #define DECL_STATIC_FUNCTION_P(NODE) \
2952   (LANG_DECL_FN_CHECK (NODE)->static_function)
2953
2954 /* Nonzero for FUNCTION_DECL means that this decl is a non-static
2955    member function.  */
2956 #define DECL_NONSTATIC_MEMBER_FUNCTION_P(NODE) \
2957   (TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE)
2958
2959 /* Nonzero for FUNCTION_DECL means that this decl is a member function
2960    (static or non-static).  */
2961 #define DECL_FUNCTION_MEMBER_P(NODE) \
2962   (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) || DECL_STATIC_FUNCTION_P (NODE))
2963
2964 /* Nonzero for FUNCTION_DECL means that this member function
2965    has `this' as const X *const.  */
2966 #define DECL_CONST_MEMFUNC_P(NODE)                                       \
2967   (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE)                               \
2968    && CP_TYPE_CONST_P (TREE_TYPE (TREE_VALUE                             \
2969                                   (TYPE_ARG_TYPES (TREE_TYPE (NODE))))))
2970
2971 /* Nonzero for FUNCTION_DECL means that this member function
2972    has `this' as volatile X *const.  */
2973 #define DECL_VOLATILE_MEMFUNC_P(NODE)                                    \
2974   (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE)                               \
2975    && CP_TYPE_VOLATILE_P (TREE_TYPE (TREE_VALUE                          \
2976                                   (TYPE_ARG_TYPES (TREE_TYPE (NODE))))))
2977
2978 /* Nonzero for a DECL means that this member is a non-static member.  */
2979 #define DECL_NONSTATIC_MEMBER_P(NODE)           \
2980   (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE)      \
2981    || TREE_CODE (NODE) == FIELD_DECL)
2982
2983 /* Nonzero for _DECL means that this member object type
2984    is mutable.  */
2985 #define DECL_MUTABLE_P(NODE) (DECL_LANG_FLAG_0 (NODE))
2986
2987 /* Nonzero for _DECL means that this constructor or conversion function is
2988    non-converting.  */
2989 #define DECL_NONCONVERTING_P(NODE) \
2990   (LANG_DECL_FN_CHECK (NODE)->nonconverting)
2991
2992 /* Nonzero for FUNCTION_DECL means that this member function is a pure
2993    virtual function.  */
2994 #define DECL_PURE_VIRTUAL_P(NODE) \
2995   (LANG_DECL_FN_CHECK (NODE)->pure_virtual)
2996
2997 /* True (in a FUNCTION_DECL) if NODE is a virtual function that is an
2998    invalid overrider for a function from a base class.  Once we have
2999    complained about an invalid overrider we avoid complaining about it
3000    again.  */
3001 #define DECL_INVALID_OVERRIDER_P(NODE) \
3002   (DECL_LANG_FLAG_4 (NODE))
3003
3004 /* True (in a FUNCTION_DECL) if NODE is a function declared with
3005    an override virt-specifier */
3006 #define DECL_OVERRIDE_P(NODE) (TREE_LANG_FLAG_0 (NODE))
3007
3008 /* The thunks associated with NODE, a FUNCTION_DECL.  */
3009 #define DECL_THUNKS(NODE) \
3010   (DECL_VIRTUAL_P (NODE) ? LANG_DECL_FN_CHECK (NODE)->context : NULL_TREE)
3011
3012 /* Set DECL_THUNKS.  */
3013 #define SET_DECL_THUNKS(NODE,THUNKS) \
3014   (LANG_DECL_FN_CHECK (NODE)->context = (THUNKS))
3015
3016 /* If NODE, a FUNCTION_DECL, is a C++11 inheriting constructor, then this
3017    is the constructor it inherits from.  */
3018 #define DECL_INHERITED_CTOR(NODE) \
3019   (DECL_DECLARES_FUNCTION_P (NODE) && DECL_CONSTRUCTOR_P (NODE) \
3020    ? LANG_DECL_FN_CHECK (NODE)->context : NULL_TREE)
3021
3022 /* And this is the base that constructor comes from.  */
3023 #define DECL_INHERITED_CTOR_BASE(NODE)                  \
3024   (DECL_INHERITED_CTOR (NODE)                           \
3025    ? DECL_CONTEXT (flag_new_inheriting_ctors            \
3026                    ? strip_inheriting_ctors (NODE)      \
3027                    : DECL_INHERITED_CTOR (NODE))        \
3028    : NULL_TREE)
3029
3030 /* Set the inherited base.  */
3031 #define SET_DECL_INHERITED_CTOR(NODE,INH) \
3032   (LANG_DECL_FN_CHECK (NODE)->context = (INH))
3033
3034 /* Nonzero if NODE is a thunk, rather than an ordinary function.  */
3035 #define DECL_THUNK_P(NODE)                      \
3036   (TREE_CODE (NODE) == FUNCTION_DECL            \
3037    && DECL_LANG_SPECIFIC (NODE)                 \
3038    && LANG_DECL_FN_CHECK (NODE)->thunk_p)
3039
3040 /* Set DECL_THUNK_P for node.  */
3041 #define SET_DECL_THUNK_P(NODE, THIS_ADJUSTING)                  \
3042   (LANG_DECL_FN_CHECK (NODE)->thunk_p = 1,                      \
3043    LANG_DECL_FN_CHECK (NODE)->this_thunk_p = (THIS_ADJUSTING))
3044
3045 /* Nonzero if NODE is a this pointer adjusting thunk.  */
3046 #define DECL_THIS_THUNK_P(NODE)                 \
3047   (DECL_THUNK_P (NODE) && LANG_DECL_FN_CHECK (NODE)->this_thunk_p)
3048
3049 /* Nonzero if NODE is a result pointer adjusting thunk.  */
3050 #define DECL_RESULT_THUNK_P(NODE)                       \
3051   (DECL_THUNK_P (NODE) && !LANG_DECL_FN_CHECK (NODE)->this_thunk_p)
3052
3053 /* Nonzero if NODE is a FUNCTION_DECL, but not a thunk.  */
3054 #define DECL_NON_THUNK_FUNCTION_P(NODE)                         \
3055   (TREE_CODE (NODE) == FUNCTION_DECL && !DECL_THUNK_P (NODE))
3056
3057 /* Nonzero if NODE is `extern "C"'.  */
3058 #define DECL_EXTERN_C_P(NODE) \
3059   (DECL_LANGUAGE (NODE) == lang_c)
3060
3061 /* Nonzero if NODE is an `extern "C"' function.  */
3062 #define DECL_EXTERN_C_FUNCTION_P(NODE) \
3063   (DECL_NON_THUNK_FUNCTION_P (NODE) && DECL_EXTERN_C_P (NODE))
3064
3065 /* True iff DECL is an entity with vague linkage whose definition is
3066    available in this translation unit.  */
3067 #define DECL_REPO_AVAILABLE_P(NODE) \
3068   (DECL_LANG_SPECIFIC (NODE)->u.base.repo_available_p)
3069
3070 /* True if DECL is declared 'constexpr'.  */
3071 #define DECL_DECLARED_CONSTEXPR_P(DECL) \
3072   DECL_LANG_FLAG_8 (VAR_OR_FUNCTION_DECL_CHECK (STRIP_TEMPLATE (DECL)))
3073
3074 // True if NODE was declared as 'concept'.  The flag implies that the
3075 // declaration is constexpr, that the declaration cannot be specialized or
3076 // refined, and that the result type must be convertible to bool.
3077 #define DECL_DECLARED_CONCEPT_P(NODE) \
3078   (DECL_LANG_SPECIFIC (NODE)->u.base.concept_p)
3079
3080 /* Nonzero if this DECL is the __PRETTY_FUNCTION__ variable in a
3081    template function.  */
3082 #define DECL_PRETTY_FUNCTION_P(NODE) \
3083   (DECL_NAME (NODE) \
3084    && id_equal (DECL_NAME (NODE), "__PRETTY_FUNCTION__"))
3085
3086 /* Nonzero if the variable was declared to be thread-local.
3087    We need a special C++ version of this test because the middle-end
3088    DECL_THREAD_LOCAL_P uses the symtab, so we can't use it for
3089    templates.  */
3090 #define CP_DECL_THREAD_LOCAL_P(NODE) \
3091   (TREE_LANG_FLAG_0 (VAR_DECL_CHECK (NODE)))
3092
3093 /* The _TYPE context in which this _DECL appears.  This field holds the
3094    class where a virtual function instance is actually defined.  */
3095 #define DECL_CLASS_CONTEXT(NODE) \
3096   (DECL_CLASS_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : NULL_TREE)
3097
3098 /* For a non-member friend function, the class (if any) in which this
3099    friend was defined.  For example, given:
3100
3101      struct S { friend void f () { ... } };
3102
3103    the DECL_FRIEND_CONTEXT for `f' will be `S'.  */
3104 #define DECL_FRIEND_CONTEXT(NODE)                               \
3105   ((DECL_DECLARES_FUNCTION_P (NODE)                             \
3106     && DECL_FRIEND_P (NODE) && !DECL_FUNCTION_MEMBER_P (NODE))  \
3107    ? LANG_DECL_FN_CHECK (NODE)->context                         \
3108    : NULL_TREE)
3109
3110 /* Set the DECL_FRIEND_CONTEXT for NODE to CONTEXT.  */
3111 #define SET_DECL_FRIEND_CONTEXT(NODE, CONTEXT) \
3112   (LANG_DECL_FN_CHECK (NODE)->context = (CONTEXT))
3113
3114 #define CP_DECL_CONTEXT(NODE) \
3115   (!DECL_FILE_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : global_namespace)
3116 #define CP_TYPE_CONTEXT(NODE) \
3117   (!TYPE_FILE_SCOPE_P (NODE) ? TYPE_CONTEXT (NODE) : global_namespace)
3118 #define FROB_CONTEXT(NODE) \
3119   ((NODE) == global_namespace ? DECL_CONTEXT (NODE) : (NODE))
3120
3121 /* 1 iff NODE has namespace scope, including the global namespace.  */
3122 #define DECL_NAMESPACE_SCOPE_P(NODE)                            \
3123   (!DECL_TEMPLATE_PARM_P (NODE)                                 \
3124    && TREE_CODE (CP_DECL_CONTEXT (NODE)) == NAMESPACE_DECL)
3125
3126 #define TYPE_NAMESPACE_SCOPE_P(NODE) \
3127   (TREE_CODE (CP_TYPE_CONTEXT (NODE)) == NAMESPACE_DECL)
3128
3129 #define NAMESPACE_SCOPE_P(NODE) \
3130   ((DECL_P (NODE) && DECL_NAMESPACE_SCOPE_P (NODE)) \
3131    || (TYPE_P (NODE) && TYPE_NAMESPACE_SCOPE_P (NODE)))
3132
3133 /* 1 iff NODE is a class member.  */
3134 #define DECL_CLASS_SCOPE_P(NODE) \
3135   (DECL_CONTEXT (NODE) && TYPE_P (DECL_CONTEXT (NODE)))
3136
3137 #define TYPE_CLASS_SCOPE_P(NODE) \
3138   (TYPE_CONTEXT (NODE) && TYPE_P (TYPE_CONTEXT (NODE)))
3139
3140 /* 1 iff NODE is function-local.  */
3141 #define DECL_FUNCTION_SCOPE_P(NODE) \
3142   (DECL_CONTEXT (NODE) \
3143    && TREE_CODE (DECL_CONTEXT (NODE)) == FUNCTION_DECL)
3144
3145 #define TYPE_FUNCTION_SCOPE_P(NODE) \
3146   (TYPE_CONTEXT (NODE) && TREE_CODE (TYPE_CONTEXT (NODE)) == FUNCTION_DECL)
3147
3148 /* 1 iff VAR_DECL node NODE is a type-info decl.  This flag is set for
3149    both the primary typeinfo object and the associated NTBS name.  */
3150 #define DECL_TINFO_P(NODE) TREE_LANG_FLAG_4 (VAR_DECL_CHECK (NODE))
3151
3152 /* 1 iff VAR_DECL node NODE is virtual table or VTT.  */
3153 #define DECL_VTABLE_OR_VTT_P(NODE) TREE_LANG_FLAG_5 (VAR_DECL_CHECK (NODE))
3154
3155 /* 1 iff FUNCTION_TYPE or METHOD_TYPE has a ref-qualifier (either & or &&). */
3156 #define FUNCTION_REF_QUALIFIED(NODE) \
3157   TREE_LANG_FLAG_4 (FUNC_OR_METHOD_CHECK (NODE))
3158
3159 /* 1 iff FUNCTION_TYPE or METHOD_TYPE has &&-ref-qualifier.  */
3160 #define FUNCTION_RVALUE_QUALIFIED(NODE) \
3161   TREE_LANG_FLAG_5 (FUNC_OR_METHOD_CHECK (NODE))
3162
3163 /* Returns 1 iff VAR_DECL is a construction virtual table.
3164    DECL_VTABLE_OR_VTT_P will be true in this case and must be checked
3165    before using this macro.  */
3166 #define DECL_CONSTRUCTION_VTABLE_P(NODE) \
3167   TREE_LANG_FLAG_6 (VAR_DECL_CHECK (NODE))
3168
3169 /* 1 iff NODE is function-local, but for types.  */
3170 #define LOCAL_CLASS_P(NODE)                             \
3171   (decl_function_context (TYPE_MAIN_DECL (NODE)) != NULL_TREE)
3172
3173 /* The nesting depth of namespace, class or function.  Makes is_ancestor much
3174    simpler.  Only 8 bits available.  */
3175 #define SCOPE_DEPTH(NODE) \
3176   (NAMESPACE_DECL_CHECK (NODE)->base.u.bits.address_space)
3177
3178 /* Whether the namepace is an inline namespace.  */
3179 #define DECL_NAMESPACE_INLINE_P(NODE) \
3180   TREE_LANG_FLAG_0 (NAMESPACE_DECL_CHECK (NODE))
3181
3182 /* In a NAMESPACE_DECL, a vector of using directives.  */
3183 #define DECL_NAMESPACE_USING(NODE) \
3184    (LANG_DECL_NS_CHECK (NODE)->usings)
3185
3186 /* In a NAMESPACE_DECL, a vector of inline namespaces.  */
3187 #define DECL_NAMESPACE_INLINEES(NODE) \
3188    (LANG_DECL_NS_CHECK (NODE)->inlinees)
3189
3190 /* Pointer to hash_map from IDENTIFIERS to DECLS  */
3191 #define DECL_NAMESPACE_BINDINGS(NODE) \
3192    (LANG_DECL_NS_CHECK (NODE)->bindings)
3193
3194 /* In a NAMESPACE_DECL, points to the original namespace if this is
3195    a namespace alias.  */
3196 #define DECL_NAMESPACE_ALIAS(NODE) \
3197         DECL_ABSTRACT_ORIGIN (NAMESPACE_DECL_CHECK (NODE))
3198 #define ORIGINAL_NAMESPACE(NODE)  \
3199   (DECL_NAMESPACE_ALIAS (NODE) ? DECL_NAMESPACE_ALIAS (NODE) : (NODE))
3200
3201 /* Nonzero if NODE is the std namespace.  */
3202 #define DECL_NAMESPACE_STD_P(NODE)                      \
3203   (TREE_CODE (NODE) == NAMESPACE_DECL                   \
3204    && CP_DECL_CONTEXT (NODE) == global_namespace        \
3205    && DECL_NAME (NODE) == std_identifier)
3206
3207 /* In a TREE_LIST in an attribute list, indicates that the attribute
3208    must be applied at instantiation time.  */
3209 #define ATTR_IS_DEPENDENT(NODE) TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
3210
3211 /* In a TREE_LIST in the argument of attribute abi_tag, indicates that the tag
3212    was inherited from a template parameter, not explicitly indicated.  */
3213 #define ABI_TAG_IMPLICIT(NODE) TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
3214
3215 extern tree decl_shadowed_for_var_lookup (tree);
3216 extern void decl_shadowed_for_var_insert (tree, tree);
3217
3218 /* Non zero if this is a using decl for a dependent scope. */
3219 #define DECL_DEPENDENT_P(NODE) DECL_LANG_FLAG_0 (USING_DECL_CHECK (NODE))
3220
3221 /* The scope named in a using decl.  */
3222 #define USING_DECL_SCOPE(NODE) TREE_TYPE (USING_DECL_CHECK (NODE))
3223
3224 /* The decls named by a using decl.  */
3225 #define USING_DECL_DECLS(NODE) DECL_INITIAL (USING_DECL_CHECK (NODE))
3226
3227 /* Non zero if the using decl refers to a dependent type.  */
3228 #define USING_DECL_TYPENAME_P(NODE) DECL_LANG_FLAG_1 (USING_DECL_CHECK (NODE))
3229
3230 /* In a VAR_DECL, true if we have a shadowed local variable
3231    in the shadowed var table for this VAR_DECL.  */
3232 #define DECL_HAS_SHADOWED_FOR_VAR_P(NODE) \
3233   (VAR_DECL_CHECK (NODE)->decl_with_vis.shadowed_for_var_p)
3234
3235 /* In a VAR_DECL for a variable declared in a for statement,
3236    this is the shadowed (local) variable.  */
3237 #define DECL_SHADOWED_FOR_VAR(NODE) \
3238   (DECL_HAS_SHADOWED_FOR_VAR_P(NODE) ? decl_shadowed_for_var_lookup (NODE) : NULL)
3239
3240 #define SET_DECL_SHADOWED_FOR_VAR(NODE, VAL) \
3241   (decl_shadowed_for_var_insert (NODE, VAL))
3242
3243 /* In a FUNCTION_DECL, this is nonzero if this function was defined in
3244    the class definition.  We have saved away the text of the function,
3245    but have not yet processed it.  */
3246 #define DECL_PENDING_INLINE_P(NODE) \
3247   (LANG_DECL_FN_CHECK (NODE)->pending_inline_p)
3248
3249 /* If DECL_PENDING_INLINE_P holds, this is the saved text of the
3250    function.  */
3251 #define DECL_PENDING_INLINE_INFO(NODE) \
3252   (LANG_DECL_FN_CHECK (NODE)->u.pending_inline_info)
3253
3254 /* Nonzero for TYPE_DECL means that it was written 'using name = type'.  */
3255 #define TYPE_DECL_ALIAS_P(NODE) \
3256   DECL_LANG_FLAG_6 (TYPE_DECL_CHECK (NODE))
3257
3258 /* Nonzero for TEMPLATE_DECL means that it is a 'complex' alias template.  */
3259 #define TEMPLATE_DECL_COMPLEX_ALIAS_P(NODE) \
3260   DECL_LANG_FLAG_2 (TEMPLATE_DECL_CHECK (NODE))
3261
3262 /* Nonzero for a type which is an alias for another type; i.e, a type
3263    which declaration was written 'using name-of-type =
3264    another-type'.  */
3265 #define TYPE_ALIAS_P(NODE)                      \
3266   (TYPE_P (NODE)                                \
3267    && TYPE_NAME (NODE)                          \
3268    && TREE_CODE (TYPE_NAME (NODE)) == TYPE_DECL \
3269    && TYPE_DECL_ALIAS_P (TYPE_NAME (NODE)))
3270
3271 /* If non-NULL for a VAR_DECL, FUNCTION_DECL, TYPE_DECL or
3272    TEMPLATE_DECL, the entity is either a template specialization (if
3273    DECL_USE_TEMPLATE is nonzero) or the abstract instance of the
3274    template itself.
3275
3276    In either case, DECL_TEMPLATE_INFO is a TREE_LIST, whose
3277    TREE_PURPOSE is the TEMPLATE_DECL of which this entity is a
3278    specialization or abstract instance.  The TREE_VALUE is the
3279    template arguments used to specialize the template.
3280
3281    Consider:
3282
3283       template <typename T> struct S { friend void f(T) {} };
3284
3285    In this case, S<int>::f is, from the point of view of the compiler,
3286    an instantiation of a template -- but, from the point of view of
3287    the language, each instantiation of S results in a wholly unrelated
3288    global function f.  In this case, DECL_TEMPLATE_INFO for S<int>::f
3289    will be non-NULL, but DECL_USE_TEMPLATE will be zero.  */
3290 #define DECL_TEMPLATE_INFO(NODE) \
3291   (DECL_LANG_SPECIFIC (VAR_TEMPL_TYPE_FIELD_OR_FUNCTION_DECL_CHECK (NODE)) \
3292    ->u.min.template_info)
3293
3294 /* For a lambda capture proxy, its captured variable.  */
3295 #define DECL_CAPTURED_VARIABLE(NODE) \
3296   (LANG_DECL_U2_CHECK (NODE, 0)->access)
3297
3298 /* For a VAR_DECL, indicates that the variable is actually a
3299    non-static data member of anonymous union that has been promoted to
3300    variable status.  */
3301 #define DECL_ANON_UNION_VAR_P(NODE) \
3302   (DECL_LANG_FLAG_4 (VAR_DECL_CHECK (NODE)))
3303
3304 /* Template information for a RECORD_TYPE or UNION_TYPE.  */
3305 #define CLASSTYPE_TEMPLATE_INFO(NODE) \
3306   (TYPE_LANG_SLOT_1 (RECORD_OR_UNION_CHECK (NODE)))
3307
3308 /* Template information for a template template parameter.  */
3309 #define TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO(NODE) \
3310   (TYPE_LANG_SLOT_1 (BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK (NODE)))
3311
3312 /* Template information for an ENUMERAL_, RECORD_, UNION_TYPE, or
3313    BOUND_TEMPLATE_TEMPLATE_PARM type.  This ignores any alias
3314    templateness of NODE.  It'd be nice if this could unconditionally
3315    access the slot, rather than return NULL if given a
3316    non-templatable type.  */
3317 #define TYPE_TEMPLATE_INFO(NODE)                                        \
3318   (TREE_CODE (NODE) == ENUMERAL_TYPE                                    \
3319    || TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM                  \
3320    || RECORD_OR_UNION_TYPE_P (NODE)                                     \
3321    ? TYPE_LANG_SLOT_1 (NODE) : NULL_TREE)
3322
3323 /* Template information (if any) for an alias type.  */
3324 #define TYPE_ALIAS_TEMPLATE_INFO(NODE)                                  \
3325   (DECL_LANG_SPECIFIC (TYPE_NAME (NODE))                                \
3326    ? DECL_TEMPLATE_INFO (TYPE_NAME (NODE))                              \
3327    : NULL_TREE)
3328
3329 /* If NODE is a type alias, this accessor returns the template info
3330    for the alias template (if any).  Otherwise behave as
3331    TYPE_TEMPLATE_INFO.  */
3332 #define TYPE_TEMPLATE_INFO_MAYBE_ALIAS(NODE)                            \
3333   (TYPE_ALIAS_P (NODE)                                                  \
3334    ? TYPE_ALIAS_TEMPLATE_INFO (NODE)                                    \
3335    : TYPE_TEMPLATE_INFO (NODE))
3336
3337 /* Set the template information for an ENUMERAL_, RECORD_, or
3338    UNION_TYPE to VAL.  */
3339 #define SET_TYPE_TEMPLATE_INFO(NODE, VAL)                               \
3340   (TREE_CODE (NODE) == ENUMERAL_TYPE                                    \
3341    || (CLASS_TYPE_P (NODE) && !TYPE_ALIAS_P (NODE))                     \
3342    ? (TYPE_LANG_SLOT_1 (NODE) = (VAL))                          \
3343    : (DECL_TEMPLATE_INFO (TYPE_NAME (NODE)) = (VAL)))
3344
3345 #define TI_TEMPLATE(NODE) TREE_TYPE (TEMPLATE_INFO_CHECK (NODE))
3346 #define TI_ARGS(NODE) TREE_CHAIN (TEMPLATE_INFO_CHECK (NODE))
3347 #define TI_PENDING_TEMPLATE_FLAG(NODE) TREE_LANG_FLAG_1 (NODE)
3348 /* For a given TREE_VEC containing a template argument list,
3349    this property contains the number of arguments that are not
3350    defaulted.  */
3351 #define NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) TREE_CHAIN (TREE_VEC_CHECK (NODE))
3352 /* Below are the setter and getter of the NON_DEFAULT_TEMPLATE_ARGS_COUNT
3353    property.  */
3354 #define SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE, INT_VALUE) \
3355   NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) = build_int_cst (NULL_TREE, INT_VALUE)
3356 #if CHECKING_P
3357 #define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \
3358     int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE))
3359 #else
3360 #define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \
3361   NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE) \
3362   ? int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE)) \
3363   : TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (NODE))
3364 #endif
3365 /* The list of typedefs - used in the template - that need
3366    access checking at template instantiation time.
3367
3368    FIXME this should be associated with the TEMPLATE_DECL, not the
3369    TEMPLATE_INFO.  */
3370 #define TI_TYPEDEFS_NEEDING_ACCESS_CHECKING(NODE) \
3371   ((struct tree_template_info*)TEMPLATE_INFO_CHECK \
3372      (NODE))->typedefs_needing_access_checking
3373
3374 /* We use TREE_VECs to hold template arguments.  If there is only one
3375    level of template arguments, then the TREE_VEC contains the
3376    arguments directly.  If there is more than one level of template
3377    arguments, then each entry in the TREE_VEC is itself a TREE_VEC,
3378    containing the template arguments for a single level.  The first
3379    entry in the outer TREE_VEC is the outermost level of template
3380    parameters; the last is the innermost.
3381
3382    It is incorrect to ever form a template argument vector containing
3383    only one level of arguments, but which is a TREE_VEC containing as
3384    its only entry the TREE_VEC for that level.
3385
3386    For each TREE_VEC containing the template arguments for a single
3387    level, it's possible to get or set the number of non defaulted
3388    template arguments by using the accessor macros
3389    GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT or
3390    SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT.  */
3391
3392 /* Nonzero if the template arguments is actually a vector of vectors,
3393    rather than just a vector.  */
3394 #define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE)                 \
3395   (NODE && TREE_VEC_LENGTH (NODE) && TREE_VEC_ELT (NODE, 0)  \
3396    && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC)
3397
3398 /* The depth of a template argument vector.  When called directly by
3399    the parser, we use a TREE_LIST rather than a TREE_VEC to represent
3400    template arguments.  In fact, we may even see NULL_TREE if there
3401    are no template arguments.  In both of those cases, there is only
3402    one level of template arguments.  */
3403 #define TMPL_ARGS_DEPTH(NODE)                                   \
3404   (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1)
3405
3406 /* The LEVELth level of the template ARGS.  The outermost level of
3407    args is level 1, not level 0.  */
3408 #define TMPL_ARGS_LEVEL(ARGS, LEVEL)            \
3409   (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS)        \
3410    ? TREE_VEC_ELT (ARGS, (LEVEL) - 1) : (ARGS))
3411
3412 /* Set the LEVELth level of the template ARGS to VAL.  This macro does
3413    not work with single-level argument vectors.  */
3414 #define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL)   \
3415   (TREE_VEC_ELT (ARGS, (LEVEL) - 1) = (VAL))
3416
3417 /* Accesses the IDXth parameter in the LEVELth level of the ARGS.  */
3418 #define TMPL_ARG(ARGS, LEVEL, IDX)                              \
3419   (TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX))
3420
3421 /* Given a single level of template arguments in NODE, return the
3422    number of arguments.  */
3423 #define NUM_TMPL_ARGS(NODE)                             \
3424   (TREE_VEC_LENGTH (NODE))
3425
3426 /* Returns the innermost level of template arguments in ARGS.  */
3427 #define INNERMOST_TEMPLATE_ARGS(NODE) \
3428   (get_innermost_template_args ((NODE), 1))
3429
3430 /* The number of levels of template parameters given by NODE.  */
3431 #define TMPL_PARMS_DEPTH(NODE) \
3432   ((HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_PURPOSE (NODE)))
3433
3434 /* The TEMPLATE_DECL instantiated or specialized by NODE.  This
3435    TEMPLATE_DECL will be the immediate parent, not the most general
3436    template.  For example, in:
3437
3438       template <class T> struct S { template <class U> void f(U); }
3439
3440    the FUNCTION_DECL for S<int>::f<double> will have, as its
3441    DECL_TI_TEMPLATE, `template <class U> S<int>::f<U>'.
3442
3443    As a special case, for a member friend template of a template
3444    class, this value will not be a TEMPLATE_DECL, but rather an
3445    IDENTIFIER_NODE or OVERLOAD indicating the name of the template and
3446    any explicit template arguments provided.  For example, in:
3447
3448      template <class T> struct S { friend void f<int>(int, double); }
3449
3450    the DECL_TI_TEMPLATE will be an IDENTIFIER_NODE for `f' and the
3451    DECL_TI_ARGS will be {int}.
3452
3453    For a FIELD_DECL with a non-static data member initializer, this value
3454    is the FIELD_DECL it was instantiated from.  */
3455 #define DECL_TI_TEMPLATE(NODE)      TI_TEMPLATE (DECL_TEMPLATE_INFO (NODE))
3456
3457 /* The template arguments used to obtain this decl from the most
3458    general form of DECL_TI_TEMPLATE.  For the example given for
3459    DECL_TI_TEMPLATE, the DECL_TI_ARGS will be {int, double}.  These
3460    are always the full set of arguments required to instantiate this
3461    declaration from the most general template specialized here.  */
3462 #define DECL_TI_ARGS(NODE)          TI_ARGS (DECL_TEMPLATE_INFO (NODE))
3463
3464 /* The TEMPLATE_DECL associated with NODE, a class type.  Even if NODE
3465    will be generated from a partial specialization, the TEMPLATE_DECL
3466    referred to here will be the original template.  For example,
3467    given:
3468
3469       template <typename T> struct S {};
3470       template <typename T> struct S<T*> {};
3471
3472    the CLASSTPYE_TI_TEMPLATE for S<int*> will be S, not the S<T*>.  */
3473 #define CLASSTYPE_TI_TEMPLATE(NODE) TI_TEMPLATE (CLASSTYPE_TEMPLATE_INFO (NODE))
3474 #define CLASSTYPE_TI_ARGS(NODE)     TI_ARGS (CLASSTYPE_TEMPLATE_INFO (NODE))
3475
3476 /* For a template instantiation TYPE, returns the TYPE corresponding
3477    to the primary template.  Otherwise returns TYPE itself.  */
3478 #define CLASSTYPE_PRIMARY_TEMPLATE_TYPE(TYPE)                           \
3479   ((CLASSTYPE_USE_TEMPLATE ((TYPE))                                     \
3480     && !CLASSTYPE_TEMPLATE_SPECIALIZATION ((TYPE)))                     \
3481    ? TREE_TYPE (DECL_TEMPLATE_RESULT (DECL_PRIMARY_TEMPLATE             \
3482                                       (CLASSTYPE_TI_TEMPLATE ((TYPE))))) \
3483    : (TYPE))
3484
3485 /* Like CLASS_TI_TEMPLATE, but also works for ENUMERAL_TYPEs.  */
3486 #define TYPE_TI_TEMPLATE(NODE)                  \
3487   (TI_TEMPLATE (TYPE_TEMPLATE_INFO (NODE)))
3488
3489 /* Like DECL_TI_ARGS, but for an ENUMERAL_, RECORD_, or UNION_TYPE.  */
3490 #define TYPE_TI_ARGS(NODE)                      \
3491   (TI_ARGS (TYPE_TEMPLATE_INFO (NODE)))
3492
3493 #define INNERMOST_TEMPLATE_PARMS(NODE)  TREE_VALUE (NODE)
3494
3495 /* Nonzero if NODE (a TEMPLATE_DECL) is a member template, in the
3496    sense of [temp.mem].  */
3497 #define DECL_MEMBER_TEMPLATE_P(NODE) \
3498   (DECL_LANG_FLAG_1 (TEMPLATE_DECL_CHECK (NODE)))
3499
3500 /* Nonzero if the NODE corresponds to the template parameters for a
3501    member template, whose inline definition is being processed after
3502    the class definition is complete.  */
3503 #define TEMPLATE_PARMS_FOR_INLINE(NODE) TREE_LANG_FLAG_1 (NODE)
3504
3505 /* Determine if a declaration (PARM_DECL or FIELD_DECL) is a pack.  */
3506 #define DECL_PACK_P(NODE) \
3507   (DECL_P (NODE) && PACK_EXPANSION_P (TREE_TYPE (NODE)))
3508
3509 /* Determines if NODE is an expansion of one or more parameter packs,
3510    e.g., a TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION.  */
3511 #define PACK_EXPANSION_P(NODE)                 \
3512   (TREE_CODE (NODE) == TYPE_PACK_EXPANSION     \
3513    || TREE_CODE (NODE) == EXPR_PACK_EXPANSION)
3514
3515 /* Extracts the type or expression pattern from a TYPE_PACK_EXPANSION or
3516    EXPR_PACK_EXPANSION.  */
3517 #define PACK_EXPANSION_PATTERN(NODE)                            \
3518   (TREE_CODE (NODE) == TYPE_PACK_EXPANSION ? TREE_TYPE (NODE)    \
3519    : TREE_OPERAND (NODE, 0))
3520
3521 /* Sets the type or expression pattern for a TYPE_PACK_EXPANSION or
3522    EXPR_PACK_EXPANSION.  */
3523 #define SET_PACK_EXPANSION_PATTERN(NODE,VALUE)  \
3524   if (TREE_CODE (NODE) == TYPE_PACK_EXPANSION)  \
3525     TREE_TYPE (NODE) = VALUE;                   \
3526   else                                          \
3527     TREE_OPERAND (NODE, 0) = VALUE
3528
3529 /* The list of parameter packs used in the PACK_EXPANSION_* node. The
3530    TREE_VALUE of each TREE_LIST contains the parameter packs.  */
3531 #define PACK_EXPANSION_PARAMETER_PACKS(NODE)            \
3532   *(TREE_CODE (NODE) == EXPR_PACK_EXPANSION             \
3533     ? &TREE_OPERAND (NODE, 1)                           \
3534     : &TYPE_MIN_VALUE_RAW (TYPE_PACK_EXPANSION_CHECK (NODE)))
3535
3536 /* Any additional template args to be applied when substituting into
3537    the pattern, set by tsubst_pack_expansion for partial instantiations.
3538    If this is a TREE_LIST, the TREE_VALUE of the first element is the
3539    usual template argument TREE_VEC, and the TREE_PURPOSE of later elements
3540    are enclosing functions that provided function parameter packs we'll need
3541    to map appropriately.  */
3542 #define PACK_EXPANSION_EXTRA_ARGS(NODE)         \
3543   *(TREE_CODE (NODE) == TYPE_PACK_EXPANSION     \
3544     ? &TYPE_MAX_VALUE_RAW (NODE)                        \
3545     : &TREE_OPERAND ((NODE), 2))
3546
3547 /* True iff this pack expansion is within a function context.  */
3548 #define PACK_EXPANSION_LOCAL_P(NODE) TREE_LANG_FLAG_0 (NODE)
3549
3550 /* True iff this pack expansion is for sizeof....  */
3551 #define PACK_EXPANSION_SIZEOF_P(NODE) TREE_LANG_FLAG_1 (NODE)
3552
3553 /* True iff the wildcard can match a template parameter pack.  */
3554 #define WILDCARD_PACK_P(NODE) TREE_LANG_FLAG_0 (NODE)
3555
3556 /* Determine if this is an argument pack.  */
3557 #define ARGUMENT_PACK_P(NODE)                          \
3558   (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK              \
3559    || TREE_CODE (NODE) == NONTYPE_ARGUMENT_PACK)
3560
3561 /* The arguments stored in an argument pack. Arguments are stored in a
3562    TREE_VEC, which may have length zero.  */
3563 #define ARGUMENT_PACK_ARGS(NODE)                               \
3564   (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK? TREE_TYPE (NODE)    \
3565    : TREE_OPERAND (NODE, 0))
3566
3567 /* Set the arguments stored in an argument pack. VALUE must be a
3568    TREE_VEC.  */
3569 #define SET_ARGUMENT_PACK_ARGS(NODE,VALUE)     \
3570   if (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK)  \
3571     TREE_TYPE (NODE) = VALUE;                           \
3572   else                                                  \
3573     TREE_OPERAND (NODE, 0) = VALUE
3574
3575 /* Whether the argument pack is "incomplete", meaning that more
3576    arguments can still be deduced. Incomplete argument packs are only
3577    used when the user has provided an explicit template argument list
3578    for a variadic function template. Some of the explicit template
3579    arguments will be placed into the beginning of the argument pack,
3580    but additional arguments might still be deduced.  */
3581 #define ARGUMENT_PACK_INCOMPLETE_P(NODE)        \
3582   TREE_ADDRESSABLE (ARGUMENT_PACK_ARGS (NODE))
3583
3584 /* When ARGUMENT_PACK_INCOMPLETE_P, stores the explicit template
3585    arguments used to fill this pack.  */
3586 #define ARGUMENT_PACK_EXPLICIT_ARGS(NODE)       \
3587   TREE_TYPE (ARGUMENT_PACK_ARGS (NODE))
3588
3589 /* In an ARGUMENT_PACK_SELECT, the argument pack from which an
3590    argument will be selected.  */
3591 #define ARGUMENT_PACK_SELECT_FROM_PACK(NODE)                            \
3592   (((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->argument_pack)
3593
3594 /* In an ARGUMENT_PACK_SELECT, the index of the argument we want to
3595    select.  */
3596 #define ARGUMENT_PACK_SELECT_INDEX(NODE)                                \
3597   (((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->index)
3598
3599 #define FOLD_EXPR_CHECK(NODE)                                           \
3600   TREE_CHECK4 (NODE, UNARY_LEFT_FOLD_EXPR, UNARY_RIGHT_FOLD_EXPR,       \
3601                BINARY_LEFT_FOLD_EXPR, BINARY_RIGHT_FOLD_EXPR)
3602
3603 #define BINARY_FOLD_EXPR_CHECK(NODE) \
3604   TREE_CHECK2 (NODE, BINARY_LEFT_FOLD_EXPR, BINARY_RIGHT_FOLD_EXPR)
3605
3606 /* True if NODE is UNARY_FOLD_EXPR or a BINARY_FOLD_EXPR */
3607 #define FOLD_EXPR_P(NODE)                               \
3608   (TREE_CODE (NODE) == UNARY_LEFT_FOLD_EXPR             \
3609    || TREE_CODE (NODE) == UNARY_RIGHT_FOLD_EXPR         \
3610    || TREE_CODE (NODE) == BINARY_LEFT_FOLD_EXPR         \
3611    || TREE_CODE (NODE) == BINARY_RIGHT_FOLD_EXPR)
3612
3613 /* True when NODE is a fold over a compound assignment operator. */
3614 #define FOLD_EXPR_MODIFY_P(NODE) \
3615   TREE_LANG_FLAG_0 (FOLD_EXPR_CHECK (NODE))
3616
3617 /* An INTEGER_CST containing the tree code of the folded operator. */
3618 #define FOLD_EXPR_OP(NODE) \
3619   TREE_OPERAND (FOLD_EXPR_CHECK (NODE), 0)
3620
3621 /* The expression containing an unexpanded parameter pack. */
3622 #define FOLD_EXPR_PACK(NODE) \
3623   TREE_OPERAND (FOLD_EXPR_CHECK (NODE), 1)
3624
3625 /* In a binary fold expression, the argument with no unexpanded
3626    parameter packs. */
3627 #define FOLD_EXPR_INIT(NODE) \
3628   TREE_OPERAND (BINARY_FOLD_EXPR_CHECK (NODE), 2)
3629
3630 /* In a FUNCTION_DECL, the saved language-specific per-function data.  */
3631 #define DECL_SAVED_FUNCTION_DATA(NODE)                  \
3632   (LANG_DECL_FN_CHECK (FUNCTION_DECL_CHECK (NODE))      \
3633    ->u.saved_language_function)
3634
3635 /* True if NODE is an implicit INDIRECT_EXPR from convert_from_reference.  */
3636 #define REFERENCE_REF_P(NODE)                           \
3637   (INDIRECT_REF_P (NODE)                                \
3638    && TREE_TYPE (TREE_OPERAND (NODE, 0))                \
3639    && (TREE_CODE (TREE_TYPE (TREE_OPERAND ((NODE), 0))) \
3640        == REFERENCE_TYPE))
3641
3642 /* True if NODE is a REFERENCE_TYPE which is OK to instantiate to be a
3643    reference to VLA type, because it's used for VLA capture.  */
3644 #define REFERENCE_VLA_OK(NODE) \
3645   (TYPE_LANG_FLAG_5 (REFERENCE_TYPE_CHECK (NODE)))
3646
3647 #define NEW_EXPR_USE_GLOBAL(NODE) \
3648   TREE_LANG_FLAG_0 (NEW_EXPR_CHECK (NODE))
3649 #define DELETE_EXPR_USE_GLOBAL(NODE) \
3650   TREE_LANG_FLAG_0 (DELETE_EXPR_CHECK (NODE))
3651 #define DELETE_EXPR_USE_VEC(NODE) \
3652   TREE_LANG_FLAG_1 (DELETE_EXPR_CHECK (NODE))
3653
3654 #define CALL_OR_AGGR_INIT_CHECK(NODE) \
3655   TREE_CHECK2 ((NODE), CALL_EXPR, AGGR_INIT_EXPR)
3656
3657 /* Indicates that this is a non-dependent COMPOUND_EXPR which will
3658    resolve to a function call.  */
3659 #define COMPOUND_EXPR_OVERLOADED(NODE) \
3660   TREE_LANG_FLAG_0 (COMPOUND_EXPR_CHECK (NODE))
3661
3662 /* In a CALL_EXPR appearing in a template, true if Koenig lookup
3663    should be performed at instantiation time.  */
3664 #define KOENIG_LOOKUP_P(NODE) TREE_LANG_FLAG_0 (CALL_EXPR_CHECK (NODE))
3665
3666 /* True if the arguments to NODE should be evaluated in left-to-right
3667    order regardless of PUSH_ARGS_REVERSED.  */
3668 #define CALL_EXPR_ORDERED_ARGS(NODE) \
3669   TREE_LANG_FLAG_3 (CALL_OR_AGGR_INIT_CHECK (NODE))
3670
3671 /* True if the arguments to NODE should be evaluated in right-to-left
3672    order regardless of PUSH_ARGS_REVERSED.  */
3673 #define CALL_EXPR_REVERSE_ARGS(NODE) \
3674   TREE_LANG_FLAG_5 (CALL_OR_AGGR_INIT_CHECK (NODE))
3675
3676 /* True if CALL_EXPR was written as an operator expression, not a function
3677    call.  */
3678 #define CALL_EXPR_OPERATOR_SYNTAX(NODE) \
3679   TREE_LANG_FLAG_6 (CALL_OR_AGGR_INIT_CHECK (NODE))
3680
3681 /* Indicates whether a string literal has been parenthesized. Such
3682    usages are disallowed in certain circumstances.  */
3683
3684 #define PAREN_STRING_LITERAL_P(NODE) \
3685   TREE_LANG_FLAG_0 (STRING_CST_CHECK (NODE))
3686
3687 /* Indicates whether a COMPONENT_REF or a SCOPE_REF has been parenthesized, or
3688    an INDIRECT_REF comes from parenthesizing a _DECL.  Currently only set some
3689    of the time in C++14 mode.  */
3690
3691 #define REF_PARENTHESIZED_P(NODE) \
3692   TREE_LANG_FLAG_2 (TREE_CHECK3 ((NODE), COMPONENT_REF, INDIRECT_REF, SCOPE_REF))
3693
3694 /* Nonzero if this AGGR_INIT_EXPR provides for initialization via a
3695    constructor call, rather than an ordinary function call.  */
3696 #define AGGR_INIT_VIA_CTOR_P(NODE) \
3697   TREE_LANG_FLAG_0 (AGGR_INIT_EXPR_CHECK (NODE))
3698
3699 /* Nonzero if expanding this AGGR_INIT_EXPR should first zero-initialize
3700    the object.  */
3701 #define AGGR_INIT_ZERO_FIRST(NODE) \
3702   TREE_LANG_FLAG_2 (AGGR_INIT_EXPR_CHECK (NODE))
3703
3704 /* Nonzero means that the call is the jump from a thunk to the
3705    thunked-to function.  */
3706 #define AGGR_INIT_FROM_THUNK_P(NODE) \
3707   (AGGR_INIT_EXPR_CHECK (NODE)->base.protected_flag)
3708
3709 /* AGGR_INIT_EXPR accessors.  These are equivalent to the CALL_EXPR
3710    accessors, except for AGGR_INIT_EXPR_SLOT (which takes the place of
3711    CALL_EXPR_STATIC_CHAIN).  */
3712
3713 #define AGGR_INIT_EXPR_FN(NODE) TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 1)
3714 #define AGGR_INIT_EXPR_SLOT(NODE) \
3715   TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 2)
3716 #define AGGR_INIT_EXPR_ARG(NODE, I) \
3717   TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), (I) + 3)
3718 #define aggr_init_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH(NODE) - 3)
3719
3720 /* AGGR_INIT_EXPR_ARGP returns a pointer to the argument vector for NODE.
3721    We can't use &AGGR_INIT_EXPR_ARG (NODE, 0) because that will complain if
3722    the argument count is zero when checking is enabled.  Instead, do
3723    the pointer arithmetic to advance past the 3 fixed operands in a
3724    AGGR_INIT_EXPR.  That produces a valid pointer to just past the end of
3725    the operand array, even if it's not valid to dereference it.  */
3726 #define AGGR_INIT_EXPR_ARGP(NODE) \
3727   (&(TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 0)) + 3)
3728
3729 /* Abstract iterators for AGGR_INIT_EXPRs.  */
3730
3731 /* Structure containing iterator state.  */
3732 struct aggr_init_expr_arg_iterator {
3733   tree t;       /* the aggr_init_expr */
3734   int n;        /* argument count */
3735   int i;        /* next argument index */
3736 };
3737
3738 /* Initialize the abstract argument list iterator object ITER with the
3739    arguments from AGGR_INIT_EXPR node EXP.  */
3740 inline void
3741 init_aggr_init_expr_arg_iterator (tree exp,
3742                                        aggr_init_expr_arg_iterator *iter)
3743 {
3744   iter->t = exp;
3745   iter->n = aggr_init_expr_nargs (exp);
3746   iter->i = 0;
3747 }
3748
3749 /* Return the next argument from abstract argument list iterator object ITER,
3750    and advance its state.  Return NULL_TREE if there are no more arguments.  */
3751 inline tree
3752 next_aggr_init_expr_arg (aggr_init_expr_arg_iterator *iter)
3753 {
3754   tree result;
3755   if (iter->i >= iter->n)
3756     return NULL_TREE;
3757   result = AGGR_INIT_EXPR_ARG (iter->t, iter->i);
3758   iter->i++;
3759   return result;
3760 }
3761
3762 /* Initialize the abstract argument list iterator object ITER, then advance
3763    past and return the first argument.  Useful in for expressions, e.g.
3764      for (arg = first_aggr_init_expr_arg (exp, &iter); arg;
3765           arg = next_aggr_init_expr_arg (&iter))   */
3766 inline tree
3767 first_aggr_init_expr_arg (tree exp, aggr_init_expr_arg_iterator *iter)
3768 {
3769   init_aggr_init_expr_arg_iterator (exp, iter);
3770   return next_aggr_init_expr_arg (iter);
3771 }
3772
3773 /* Test whether there are more arguments in abstract argument list iterator
3774    ITER, without changing its state.  */
3775 inline bool
3776 more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter)
3777 {
3778   return (iter->i < iter->n);
3779 }
3780
3781 /* Iterate through each argument ARG of AGGR_INIT_EXPR CALL, using variable
3782    ITER (of type aggr_init_expr_arg_iterator) to hold the iteration state.  */
3783 #define FOR_EACH_AGGR_INIT_EXPR_ARG(arg, iter, call)                    \
3784   for ((arg) = first_aggr_init_expr_arg ((call), &(iter)); (arg);       \
3785        (arg) = next_aggr_init_expr_arg (&(iter)))
3786
3787 /* VEC_INIT_EXPR accessors.  */
3788 #define VEC_INIT_EXPR_SLOT(NODE) TREE_OPERAND (VEC_INIT_EXPR_CHECK (NODE), 0)
3789 #define VEC_INIT_EXPR_INIT(NODE) TREE_OPERAND (VEC_INIT_EXPR_CHECK (NODE), 1)
3790
3791 /* Indicates that a VEC_INIT_EXPR is a potential constant expression.
3792    Only set when the current function is constexpr.  */
3793 #define VEC_INIT_EXPR_IS_CONSTEXPR(NODE) \
3794   TREE_LANG_FLAG_0 (VEC_INIT_EXPR_CHECK (NODE))
3795
3796 /* Indicates that a VEC_INIT_EXPR is expressing value-initialization.  */
3797 #define VEC_INIT_EXPR_VALUE_INIT(NODE) \
3798   TREE_LANG_FLAG_1 (VEC_INIT_EXPR_CHECK (NODE))
3799
3800 /* The condition under which this MUST_NOT_THROW_EXPR actually blocks
3801    exceptions.  NULL_TREE means 'true'.  */
3802 #define MUST_NOT_THROW_COND(NODE) \
3803   TREE_OPERAND (MUST_NOT_THROW_EXPR_CHECK (NODE), 1)
3804
3805 /* The TYPE_MAIN_DECL for a class template type is a TYPE_DECL, not a
3806    TEMPLATE_DECL.  This macro determines whether or not a given class
3807    type is really a template type, as opposed to an instantiation or
3808    specialization of one.  */
3809 #define CLASSTYPE_IS_TEMPLATE(NODE)  \
3810   (CLASSTYPE_TEMPLATE_INFO (NODE)    \
3811    && !CLASSTYPE_USE_TEMPLATE (NODE) \
3812    && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE)))
3813
3814 /* The name used by the user to name the typename type.  Typically,
3815    this is an IDENTIFIER_NODE, and the same as the DECL_NAME on the
3816    corresponding TYPE_DECL.  However, this may also be a
3817    TEMPLATE_ID_EXPR if we had something like `typename X::Y<T>'.  */
3818 #define TYPENAME_TYPE_FULLNAME(NODE) \
3819   (TYPE_VALUES_RAW (TYPENAME_TYPE_CHECK (NODE)))
3820
3821 /* True if a TYPENAME_TYPE was declared as an "enum".  */
3822 #define TYPENAME_IS_ENUM_P(NODE) \
3823   (TREE_LANG_FLAG_0 (TYPENAME_TYPE_CHECK (NODE)))
3824
3825 /* True if a TYPENAME_TYPE was declared as a "class", "struct", or
3826    "union".  */
3827 #define TYPENAME_IS_CLASS_P(NODE) \
3828   (TREE_LANG_FLAG_1 (TYPENAME_TYPE_CHECK (NODE)))
3829
3830 /* True if a TYPENAME_TYPE is in the process of being resolved.  */
3831 #define TYPENAME_IS_RESOLVING_P(NODE) \
3832   (TREE_LANG_FLAG_2 (TYPENAME_TYPE_CHECK (NODE)))
3833
3834 /* [class.virtual]
3835
3836    A class that declares or inherits a virtual function is called a
3837    polymorphic class.  */
3838 #define TYPE_POLYMORPHIC_P(NODE) (TREE_LANG_FLAG_2 (NODE))
3839
3840 /* Nonzero if this class has a virtual function table pointer.  */
3841 #define TYPE_CONTAINS_VPTR_P(NODE)              \
3842   (TYPE_POLYMORPHIC_P (NODE) || CLASSTYPE_VBASECLASSES (NODE))
3843
3844 /* This flag is true of a local VAR_DECL if it was declared in a for
3845    statement, but we are no longer in the scope of the for.  */
3846 #define DECL_DEAD_FOR_LOCAL(NODE) DECL_LANG_FLAG_7 (VAR_DECL_CHECK (NODE))
3847
3848 /* This flag is set on a VAR_DECL that is a DECL_DEAD_FOR_LOCAL
3849    if we already emitted a warning about using it.  */
3850 #define DECL_ERROR_REPORTED(NODE) DECL_LANG_FLAG_0 (VAR_DECL_CHECK (NODE))
3851
3852 /* Nonzero if NODE is a FUNCTION_DECL (for a function with global
3853    scope) declared in a local scope.  */
3854 #define DECL_LOCAL_FUNCTION_P(NODE) \
3855   DECL_LANG_FLAG_0 (FUNCTION_DECL_CHECK (NODE))
3856
3857 /* Nonzero if NODE is the target for genericization of 'break' stmts.  */
3858 #define LABEL_DECL_BREAK(NODE) \
3859   DECL_LANG_FLAG_0 (LABEL_DECL_CHECK (NODE))
3860
3861 /* Nonzero if NODE is the target for genericization of 'continue' stmts.  */
3862 #define LABEL_DECL_CONTINUE(NODE) \
3863   DECL_LANG_FLAG_1 (LABEL_DECL_CHECK (NODE))
3864
3865 /* Nonzero if NODE is the target for genericization of 'return' stmts
3866    in constructors/destructors of targetm.cxx.cdtor_returns_this targets.  */
3867 #define LABEL_DECL_CDTOR(NODE) \
3868   DECL_LANG_FLAG_2 (LABEL_DECL_CHECK (NODE))
3869
3870 /* True if NODE was declared with auto in its return type, but it has
3871    started compilation and so the return type might have been changed by
3872    return type deduction; its declared return type should be found in
3873    DECL_STRUCT_FUNCTION(NODE)->language->x_auto_return_pattern.  */
3874 #define FNDECL_USED_AUTO(NODE) \
3875   TREE_LANG_FLAG_2 (FUNCTION_DECL_CHECK (NODE))
3876
3877 /* Nonzero if NODE is a DECL which we know about but which has not
3878    been explicitly declared, such as a built-in function or a friend
3879    declared inside a class.  In the latter case DECL_HIDDEN_FRIEND_P
3880    will be set.  */
3881 #define DECL_ANTICIPATED(NODE) \
3882   (DECL_LANG_SPECIFIC (TYPE_FUNCTION_OR_TEMPLATE_DECL_CHECK (NODE)) \
3883    ->u.base.anticipated_p)
3884
3885 /* Is DECL NODE a hidden name?  */
3886 #define DECL_HIDDEN_P(NODE) \
3887   (DECL_LANG_SPECIFIC (NODE) && TYPE_FUNCTION_OR_TEMPLATE_DECL_P (NODE) \
3888    && DECL_ANTICIPATED (NODE))
3889
3890 /* True if this is a hidden class type.    */
3891 #define TYPE_HIDDEN_P(NODE) \
3892   (DECL_LANG_SPECIFIC (TYPE_NAME (NODE)) \
3893    && DECL_ANTICIPATED (TYPE_NAME (NODE)))
3894
3895 /* True for artificial decls added for OpenMP privatized non-static
3896    data members.  */
3897 #define DECL_OMP_PRIVATIZED_MEMBER(NODE) \
3898   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.anticipated_p)
3899
3900 /* Nonzero if NODE is a FUNCTION_DECL which was declared as a friend
3901    within a class but has not been declared in the surrounding scope.
3902    The function is invisible except via argument dependent lookup.  */
3903 #define DECL_HIDDEN_FRIEND_P(NODE) \
3904   (LANG_DECL_FN_CHECK (DECL_COMMON_CHECK (NODE))->hidden_friend_p)
3905
3906 /* Nonzero if NODE is an artificial FUNCTION_DECL for
3907    #pragma omp declare reduction.  */
3908 #define DECL_OMP_DECLARE_REDUCTION_P(NODE) \
3909   (LANG_DECL_FN_CHECK (DECL_COMMON_CHECK (NODE))->omp_declare_reduction_p)
3910
3911 /* Nonzero if DECL has been declared threadprivate by
3912    #pragma omp threadprivate.  */
3913 #define CP_DECL_THREADPRIVATE_P(DECL) \
3914   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (DECL))->u.base.threadprivate_or_deleted_p)
3915
3916 /* Nonzero if NODE is a VAR_DECL which has been declared inline.  */
3917 #define DECL_VAR_DECLARED_INLINE_P(NODE) \
3918   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))                   \
3919    ? DECL_LANG_SPECIFIC (NODE)->u.base.var_declared_inline_p    \
3920    : false)
3921 #define SET_DECL_VAR_DECLARED_INLINE_P(NODE) \
3922   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.var_declared_inline_p \
3923    = true)
3924
3925 /* True if NODE is a constant variable with a value-dependent initializer.  */
3926 #define DECL_DEPENDENT_INIT_P(NODE)                             \
3927   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))                   \
3928    && DECL_LANG_SPECIFIC (NODE)->u.base.dependent_init_p)
3929 #define SET_DECL_DEPENDENT_INIT_P(NODE, X) \
3930   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.dependent_init_p = (X))
3931
3932 /* Nonzero if NODE is an artificial VAR_DECL for a C++17 structured binding
3933    declaration or one of VAR_DECLs for the user identifiers in it.  */
3934 #define DECL_DECOMPOSITION_P(NODE) \
3935   (VAR_P (NODE) && DECL_LANG_SPECIFIC (NODE)                    \
3936    ? DECL_LANG_SPECIFIC (NODE)->u.base.selector == lds_decomp           \
3937    : false)
3938
3939 /* The underlying artificial VAR_DECL for structured binding.  */
3940 #define DECL_DECOMP_BASE(NODE) \
3941   (LANG_DECL_DECOMP_CHECK (NODE)->base)
3942
3943 /* Nonzero if NODE is an inline VAR_DECL.  In C++17, static data members
3944    declared with constexpr specifier are implicitly inline variables.  */
3945 #define DECL_INLINE_VAR_P(NODE) \
3946   (DECL_VAR_DECLARED_INLINE_P (NODE)                            \
3947    || (cxx_dialect >= cxx17                                     \
3948        && DECL_DECLARED_CONSTEXPR_P (NODE)                      \
3949        && DECL_CLASS_SCOPE_P (NODE)))
3950
3951 /* Nonzero if DECL was declared with '= delete'.  */
3952 #define DECL_DELETED_FN(DECL) \
3953   (LANG_DECL_FN_CHECK (DECL)->min.base.threadprivate_or_deleted_p)
3954
3955 /* Nonzero if DECL was declared with '= default' (maybe implicitly).  */
3956 #define DECL_DEFAULTED_FN(DECL) \
3957   (LANG_DECL_FN_CHECK (DECL)->defaulted_p)
3958
3959 /* Nonzero if DECL is explicitly defaulted in the class body.  */
3960 #define DECL_DEFAULTED_IN_CLASS_P(DECL)                                 \
3961   (DECL_DEFAULTED_FN (DECL) && DECL_INITIALIZED_IN_CLASS_P (DECL))
3962 /* Nonzero if DECL was defaulted outside the class body.  */
3963 #define DECL_DEFAULTED_OUTSIDE_CLASS_P(DECL)                            \
3964   (DECL_DEFAULTED_FN (DECL)                                             \
3965    && !(DECL_ARTIFICIAL (DECL) || DECL_INITIALIZED_IN_CLASS_P (DECL)))
3966
3967 /* Record whether a typedef for type `int' was actually `signed int'.  */
3968 #define C_TYPEDEF_EXPLICITLY_SIGNED(EXP) DECL_LANG_FLAG_1 (EXP)
3969
3970 /* Returns nonzero if DECL has external linkage, as specified by the
3971    language standard.  (This predicate may hold even when the
3972    corresponding entity is not actually given external linkage in the
3973    object file; see decl_linkage for details.)  */
3974 #define DECL_EXTERNAL_LINKAGE_P(DECL) \
3975   (decl_linkage (DECL) == lk_external)
3976
3977 /* Keep these codes in ascending code order.  */
3978
3979 #define INTEGRAL_CODE_P(CODE)   \
3980   ((CODE) == ENUMERAL_TYPE      \
3981    || (CODE) == BOOLEAN_TYPE    \
3982    || (CODE) == INTEGER_TYPE)
3983
3984 /* [basic.fundamental]
3985
3986    Types  bool, char, wchar_t, and the signed and unsigned integer types
3987    are collectively called integral types.
3988
3989    Note that INTEGRAL_TYPE_P, as defined in tree.h, allows enumeration
3990    types as well, which is incorrect in C++.  Keep these checks in
3991    ascending code order.  */
3992 #define CP_INTEGRAL_TYPE_P(TYPE)                \
3993   (TREE_CODE (TYPE) == BOOLEAN_TYPE             \
3994    || TREE_CODE (TYPE) == INTEGER_TYPE)
3995
3996 /* Returns true if TYPE is an integral or enumeration name.  Keep
3997    these checks in ascending code order.  */
3998 #define INTEGRAL_OR_ENUMERATION_TYPE_P(TYPE) \
3999    (TREE_CODE (TYPE) == ENUMERAL_TYPE || CP_INTEGRAL_TYPE_P (TYPE))
4000
4001 /* Returns true if TYPE is an integral or unscoped enumeration type.  */
4002 #define INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P(TYPE) \
4003    (UNSCOPED_ENUM_P (TYPE) || CP_INTEGRAL_TYPE_P (TYPE))
4004
4005 /* True if the class type TYPE is a literal type.  */
4006 #define CLASSTYPE_LITERAL_P(TYPE)              \
4007    (LANG_TYPE_CLASS_CHECK (TYPE)->is_literal)
4008
4009 /* [basic.fundamental]
4010
4011    Integral and floating types are collectively called arithmetic
4012    types.
4013
4014    As a GNU extension, we also accept complex types.
4015
4016    Keep these checks in ascending code order.  */
4017 #define ARITHMETIC_TYPE_P(TYPE) \
4018   (CP_INTEGRAL_TYPE_P (TYPE) \
4019    || TREE_CODE (TYPE) == REAL_TYPE \
4020    || TREE_CODE (TYPE) == COMPLEX_TYPE)
4021
4022 /* True iff TYPE is cv decltype(nullptr).  */
4023 #define NULLPTR_TYPE_P(TYPE) (TREE_CODE (TYPE) == NULLPTR_TYPE)
4024
4025 /* [basic.types]
4026
4027    Arithmetic types, enumeration types, pointer types,
4028    pointer-to-member types, and std::nullptr_t are collectively called
4029    scalar types.
4030
4031    Keep these checks in ascending code order.  */
4032 #define SCALAR_TYPE_P(TYPE)                     \
4033   (TYPE_PTRDATAMEM_P (TYPE)                     \
4034    || TREE_CODE (TYPE) == ENUMERAL_TYPE         \
4035    || ARITHMETIC_TYPE_P (TYPE)                  \
4036    || TYPE_PTR_P (TYPE)                         \
4037    || TYPE_PTRMEMFUNC_P (TYPE)                  \
4038    || NULLPTR_TYPE_P (TYPE))
4039
4040 /* Determines whether this type is a C++0x scoped enumeration
4041    type. Scoped enumerations types are introduced via "enum class" or
4042    "enum struct", e.g.,
4043
4044      enum class Color {
4045        Red, Green, Blue
4046      };
4047
4048    Scoped enumeration types are different from normal (unscoped)
4049    enumeration types in several ways:
4050
4051      - The enumerators of a scoped enumeration type are only available
4052        within the scope of the enumeration type and not in the
4053        enclosing scope. For example, the Red color can be referred to
4054        with "Color::Red" but not "Red".
4055
4056      - Scoped enumerators and enumerations do not implicitly convert
4057        to integers or 'bool'.
4058
4059      - The underlying type of the enum is well-defined.  */
4060 #define SCOPED_ENUM_P(TYPE)                                             \
4061   (TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_SCOPED (TYPE))
4062
4063 /* Determine whether this is an unscoped enumeration type.  */
4064 #define UNSCOPED_ENUM_P(TYPE)                                           \
4065   (TREE_CODE (TYPE) == ENUMERAL_TYPE && !ENUM_IS_SCOPED (TYPE))
4066
4067 /* Set the flag indicating whether an ENUMERAL_TYPE is a C++0x scoped
4068    enumeration type (1) or a normal (unscoped) enumeration type
4069    (0).  */
4070 #define SET_SCOPED_ENUM_P(TYPE, VAL)                    \
4071   (ENUM_IS_SCOPED (TYPE) = (VAL))
4072
4073 #define SET_OPAQUE_ENUM_P(TYPE, VAL)                    \
4074   (ENUM_IS_OPAQUE (TYPE) = (VAL))
4075
4076 #define OPAQUE_ENUM_P(TYPE)                             \
4077   (TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_OPAQUE (TYPE))
4078
4079 /* Determines whether an ENUMERAL_TYPE has an explicit
4080    underlying type.  */
4081 #define ENUM_FIXED_UNDERLYING_TYPE_P(NODE) (TYPE_LANG_FLAG_5 (NODE))
4082
4083 /* Returns the underlying type of the given enumeration type. The
4084    underlying type is determined in different ways, depending on the
4085    properties of the enum:
4086
4087      - In C++0x, the underlying type can be explicitly specified, e.g.,
4088
4089          enum E1 : char { ... } // underlying type is char
4090
4091      - In a C++0x scoped enumeration, the underlying type is int
4092        unless otherwises specified:
4093
4094          enum class E2 { ... } // underlying type is int
4095
4096      - Otherwise, the underlying type is determined based on the
4097        values of the enumerators. In this case, the
4098        ENUM_UNDERLYING_TYPE will not be set until after the definition
4099        of the enumeration is completed by finish_enum.  */
4100 #define ENUM_UNDERLYING_TYPE(TYPE) \
4101   TREE_TYPE (ENUMERAL_TYPE_CHECK (TYPE))
4102
4103 /* [dcl.init.aggr]
4104
4105    An aggregate is an array or a class with no user-provided
4106    constructors, no brace-or-equal-initializers for non-static data
4107    members, no private or protected non-static data members, no
4108    base classes, and no virtual functions.
4109
4110    As an extension, we also treat vectors as aggregates.  Keep these
4111    checks in ascending code order.  */
4112 #define CP_AGGREGATE_TYPE_P(TYPE)                               \
4113   (TREE_CODE (TYPE) == VECTOR_TYPE                              \
4114    ||TREE_CODE (TYPE) == ARRAY_TYPE                             \
4115    || (CLASS_TYPE_P (TYPE) && !CLASSTYPE_NON_AGGREGATE (TYPE)))
4116
4117 /* Nonzero for a class type means that the class type has a
4118    user-declared constructor.  */
4119 #define TYPE_HAS_USER_CONSTRUCTOR(NODE) (TYPE_LANG_FLAG_1 (NODE))
4120
4121 /* Nonzero means that the FUNCTION_TYPE or METHOD_TYPE has a
4122    late-specified return type.  */
4123 #define TYPE_HAS_LATE_RETURN_TYPE(NODE) \
4124   (TYPE_LANG_FLAG_2 (FUNC_OR_METHOD_CHECK (NODE)))
4125
4126 /* When appearing in an INDIRECT_REF, it means that the tree structure
4127    underneath is actually a call to a constructor.  This is needed
4128    when the constructor must initialize local storage (which can
4129    be automatically destroyed), rather than allowing it to allocate
4130    space from the heap.
4131
4132    When appearing in a SAVE_EXPR, it means that underneath
4133    is a call to a constructor.
4134
4135    When appearing in a CONSTRUCTOR, the expression is a
4136    compound literal.
4137
4138    When appearing in a FIELD_DECL, it means that this field
4139    has been duly initialized in its constructor.  */
4140 #define TREE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_4 (NODE))
4141
4142 /* True if NODE is a brace-enclosed initializer.  */
4143 #define BRACE_ENCLOSED_INITIALIZER_P(NODE) \
4144   (TREE_CODE (NODE) == CONSTRUCTOR && TREE_TYPE (NODE) == init_list_type_node)
4145
4146 /* True if NODE is a compound-literal, i.e., a brace-enclosed
4147    initializer cast to a particular type.  */
4148 #define COMPOUND_LITERAL_P(NODE) \
4149   (TREE_CODE (NODE) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (NODE))
4150
4151 #define EMPTY_CONSTRUCTOR_P(NODE) (TREE_CODE (NODE) == CONSTRUCTOR \
4152                                    && vec_safe_is_empty(CONSTRUCTOR_ELTS(NODE))\
4153                                    && !TREE_HAS_CONSTRUCTOR (NODE))
4154
4155 /* True if NODE is a init-list used as a direct-initializer, i.e.
4156    B b{1,2}, not B b({1,2}) or B b = {1,2}.  */
4157 #define CONSTRUCTOR_IS_DIRECT_INIT(NODE) (TREE_LANG_FLAG_0 (CONSTRUCTOR_CHECK (NODE)))
4158
4159 /* True if an uninitialized element in NODE should not be treated as
4160    implicitly value-initialized.  Only used in constexpr evaluation.  */
4161 #define CONSTRUCTOR_NO_IMPLICIT_ZERO(NODE) \
4162   (TREE_LANG_FLAG_1 (CONSTRUCTOR_CHECK (NODE)))
4163
4164 /* True if this CONSTRUCTOR should not be used as a variable initializer
4165    because it was loaded from a constexpr variable with mutable fields.  */
4166 #define CONSTRUCTOR_MUTABLE_POISON(NODE) \
4167   (TREE_LANG_FLAG_2 (CONSTRUCTOR_CHECK (NODE)))
4168
4169 /* True if this typed CONSTRUCTOR represents C99 compound-literal syntax rather
4170    than C++11 functional cast syntax.  */
4171 #define CONSTRUCTOR_C99_COMPOUND_LITERAL(NODE) \
4172   (TREE_LANG_FLAG_3 (CONSTRUCTOR_CHECK (NODE)))
4173
4174 /* True if this CONSTRUCTOR contains PLACEHOLDER_EXPRs referencing the
4175    CONSTRUCTOR's type not nested inside another CONSTRUCTOR marked with
4176    CONSTRUCTOR_PLACEHOLDER_BOUNDARY.  */
4177 #define CONSTRUCTOR_PLACEHOLDER_BOUNDARY(NODE) \
4178   (TREE_LANG_FLAG_5 (CONSTRUCTOR_CHECK (NODE)))
4179
4180 #define DIRECT_LIST_INIT_P(NODE) \
4181    (BRACE_ENCLOSED_INITIALIZER_P (NODE) && CONSTRUCTOR_IS_DIRECT_INIT (NODE))
4182
4183 /* True if NODE represents a conversion for direct-initialization in a
4184    template.  Set by perform_implicit_conversion_flags.  */
4185 #define IMPLICIT_CONV_EXPR_DIRECT_INIT(NODE) \
4186   (TREE_LANG_FLAG_0 (IMPLICIT_CONV_EXPR_CHECK (NODE)))
4187
4188 /* True if NODE represents a dependent conversion of a non-type template
4189    argument.  Set by maybe_convert_nontype_argument.  */
4190 #define IMPLICIT_CONV_EXPR_NONTYPE_ARG(NODE) \
4191   (TREE_LANG_FLAG_1 (IMPLICIT_CONV_EXPR_CHECK (NODE)))
4192
4193 /* Nonzero means that an object of this type can not be initialized using
4194    an initializer list.  */
4195 #define CLASSTYPE_NON_AGGREGATE(NODE) \
4196   (LANG_TYPE_CLASS_CHECK (NODE)->non_aggregate)
4197 #define TYPE_NON_AGGREGATE_CLASS(NODE) \
4198   (CLASS_TYPE_P (NODE) && CLASSTYPE_NON_AGGREGATE (NODE))
4199
4200 /* Nonzero if there is a non-trivial X::op=(cv X&) for this class.  */
4201 #define TYPE_HAS_COMPLEX_COPY_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_copy_assign)
4202
4203 /* Nonzero if there is a non-trivial X::X(cv X&) for this class.  */
4204 #define TYPE_HAS_COMPLEX_COPY_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_copy_ctor)
4205
4206 /* Nonzero if there is a non-trivial X::op=(X&&) for this class.  */
4207 #define TYPE_HAS_COMPLEX_MOVE_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_move_assign)
4208
4209 /* Nonzero if there is a non-trivial X::X(X&&) for this class.  */
4210 #define TYPE_HAS_COMPLEX_MOVE_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_move_ctor)
4211
4212 /* Nonzero if there is no trivial default constructor for this class.  */
4213 #define TYPE_HAS_COMPLEX_DFLT(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_dflt)
4214
4215 /* Nonzero if TYPE has a trivial destructor.  From [class.dtor]:
4216
4217      A destructor is trivial if it is an implicitly declared
4218      destructor and if:
4219
4220        - all of the direct base classes of its class have trivial
4221          destructors,
4222
4223        - for all of the non-static data members of its class that are
4224          of class type (or array thereof), each such class has a
4225          trivial destructor.  */
4226 #define TYPE_HAS_TRIVIAL_DESTRUCTOR(NODE) \
4227   (!TYPE_HAS_NONTRIVIAL_DESTRUCTOR (NODE))
4228
4229 /* Nonzero for _TYPE node means that this type does not have a trivial
4230    destructor.  Therefore, destroying an object of this type will
4231    involve a call to a destructor.  This can apply to objects of
4232    ARRAY_TYPE is the type of the elements needs a destructor.  */
4233 #define TYPE_HAS_NONTRIVIAL_DESTRUCTOR(NODE) \
4234   (TYPE_LANG_FLAG_4 (NODE))
4235
4236 /* Nonzero for class type means that the default constructor is trivial.  */
4237 #define TYPE_HAS_TRIVIAL_DFLT(NODE) \
4238   (TYPE_HAS_DEFAULT_CONSTRUCTOR (NODE) && ! TYPE_HAS_COMPLEX_DFLT (NODE))
4239
4240 /* Nonzero for class type means that copy initialization of this type can use
4241    a bitwise copy.  */
4242 #define TYPE_HAS_TRIVIAL_COPY_CTOR(NODE) \
4243   (TYPE_HAS_COPY_CTOR (NODE) && ! TYPE_HAS_COMPLEX_COPY_CTOR (NODE))
4244
4245 /* Nonzero for class type means that assignment of this type can use
4246    a bitwise copy.  */
4247 #define TYPE_HAS_TRIVIAL_COPY_ASSIGN(NODE) \
4248   (TYPE_HAS_COPY_ASSIGN (NODE) && ! TYPE_HAS_COMPLEX_COPY_ASSIGN (NODE))
4249
4250 /* Returns true if NODE is a pointer-to-data-member.  */
4251 #define TYPE_PTRDATAMEM_P(NODE)                 \
4252   (TREE_CODE (NODE) == OFFSET_TYPE)
4253 /* Returns true if NODE is a pointer.  */
4254 #define TYPE_PTR_P(NODE)                        \
4255   (TREE_CODE (NODE) == POINTER_TYPE)
4256
4257 /* Returns true if NODE is an object type:
4258
4259      [basic.types]
4260
4261      An object type is a (possibly cv-qualified) type that is not a
4262      function type, not a reference type, and not a void type.
4263
4264    Keep these checks in ascending order, for speed.  */
4265 #define TYPE_OBJ_P(NODE)                        \
4266   (TREE_CODE (NODE) != REFERENCE_TYPE           \
4267    && !VOID_TYPE_P (NODE)                       \
4268    && TREE_CODE (NODE) != FUNCTION_TYPE         \
4269    && TREE_CODE (NODE) != METHOD_TYPE)
4270
4271 /* Returns true if NODE is a pointer to an object.  Keep these checks
4272    in ascending tree code order.  */
4273 #define TYPE_PTROB_P(NODE)                                      \
4274   (TYPE_PTR_P (NODE) && TYPE_OBJ_P (TREE_TYPE (NODE)))
4275
4276 /* Returns true if NODE is a reference to an object.  Keep these checks
4277    in ascending tree code order.  */
4278 #define TYPE_REF_OBJ_P(NODE)                                    \
4279   (TREE_CODE (NODE) == REFERENCE_TYPE && TYPE_OBJ_P (TREE_TYPE (NODE)))
4280
4281 /* Returns true if NODE is a pointer to an object, or a pointer to
4282    void.  Keep these checks in ascending tree code order.  */
4283 #define TYPE_PTROBV_P(NODE)                                     \
4284   (TYPE_PTR_P (NODE)                                            \
4285    && !(TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE           \
4286         || TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE))
4287
4288 /* Returns true if NODE is a pointer to function type.  */
4289 #define TYPE_PTRFN_P(NODE)                              \
4290   (TYPE_PTR_P (NODE)                                    \
4291    && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE)
4292
4293 /* Returns true if NODE is a reference to function type.  */
4294 #define TYPE_REFFN_P(NODE)                              \
4295   (TREE_CODE (NODE) == REFERENCE_TYPE                   \
4296    && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE)
4297
4298 /* Returns true if NODE is a pointer to member function type.  */
4299 #define TYPE_PTRMEMFUNC_P(NODE)         \
4300   (TREE_CODE (NODE) == RECORD_TYPE      \
4301    && TYPE_PTRMEMFUNC_FLAG (NODE))
4302
4303 #define TYPE_PTRMEMFUNC_FLAG(NODE) \
4304   (TYPE_LANG_FLAG_2 (RECORD_TYPE_CHECK (NODE)))
4305
4306 /* Returns true if NODE is a pointer-to-member.  */
4307 #define TYPE_PTRMEM_P(NODE) \
4308   (TYPE_PTRDATAMEM_P (NODE) || TYPE_PTRMEMFUNC_P (NODE))
4309
4310 /* Returns true if NODE is a pointer or a pointer-to-member.  */
4311 #define TYPE_PTR_OR_PTRMEM_P(NODE) \
4312   (TYPE_PTR_P (NODE) || TYPE_PTRMEM_P (NODE))
4313
4314 /* Indicates when overload resolution may resolve to a pointer to
4315    member function. [expr.unary.op]/3 */
4316 #define PTRMEM_OK_P(NODE) \
4317   TREE_LANG_FLAG_0 (TREE_CHECK3 ((NODE), ADDR_EXPR, OFFSET_REF, SCOPE_REF))
4318
4319 /* Get the POINTER_TYPE to the METHOD_TYPE associated with this
4320    pointer to member function.  TYPE_PTRMEMFUNC_P _must_ be true,
4321    before using this macro.  */
4322 #define TYPE_PTRMEMFUNC_FN_TYPE(NODE) \
4323   (cp_build_qualified_type (TREE_TYPE (TYPE_FIELDS (NODE)),\
4324                             cp_type_quals (NODE)))
4325
4326 /* As above, but can be used in places that want an lvalue at the expense
4327    of not necessarily having the correct cv-qualifiers.  */
4328 #define TYPE_PTRMEMFUNC_FN_TYPE_RAW(NODE) \
4329   (TREE_TYPE (TYPE_FIELDS (NODE)))
4330
4331 /* Returns `A' for a type like `int (A::*)(double)' */
4332 #define TYPE_PTRMEMFUNC_OBJECT_TYPE(NODE) \
4333   TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE)))
4334
4335 /* The canonical internal RECORD_TYPE from the POINTER_TYPE to
4336    METHOD_TYPE.  */
4337 #define TYPE_PTRMEMFUNC_TYPE(NODE) \
4338   TYPE_LANG_SLOT_1 (NODE)
4339
4340 /* For a pointer-to-member type of the form `T X::*', this is `X'.
4341    For a type like `void (X::*)() const', this type is `X', not `const
4342    X'.  To get at the `const X' you have to look at the
4343    TYPE_PTRMEM_POINTED_TO_TYPE; there, the first parameter will have
4344    type `const X*'.  */
4345 #define TYPE_PTRMEM_CLASS_TYPE(NODE)                    \
4346   (TYPE_PTRDATAMEM_P (NODE)                                     \
4347    ? TYPE_OFFSET_BASETYPE (NODE)                \
4348    : TYPE_PTRMEMFUNC_OBJECT_TYPE (NODE))
4349
4350 /* For a pointer-to-member type of the form `T X::*', this is `T'.  */
4351 #define TYPE_PTRMEM_POINTED_TO_TYPE(NODE)               \
4352    (TYPE_PTRDATAMEM_P (NODE)                            \
4353     ? TREE_TYPE (NODE)                                  \
4354     : TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE)))
4355
4356 /* For a pointer-to-member constant `X::Y' this is the RECORD_TYPE for
4357    `X'.  */
4358 #define PTRMEM_CST_CLASS(NODE) \
4359   TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (PTRMEM_CST_CHECK (NODE)))
4360
4361 /* For a pointer-to-member constant `X::Y' this is the _DECL for
4362    `Y'.  */
4363 #define PTRMEM_CST_MEMBER(NODE) \
4364   (((ptrmem_cst_t)PTRMEM_CST_CHECK (NODE))->member)
4365
4366 /* The expression in question for a TYPEOF_TYPE.  */
4367 #define TYPEOF_TYPE_EXPR(NODE) (TYPE_VALUES_RAW (TYPEOF_TYPE_CHECK (NODE)))
4368
4369 /* The type in question for an UNDERLYING_TYPE.  */
4370 #define UNDERLYING_TYPE_TYPE(NODE) \
4371   (TYPE_VALUES_RAW (UNDERLYING_TYPE_CHECK (NODE)))
4372
4373 /* The type in question for BASES.  */
4374 #define BASES_TYPE(NODE) \
4375   (TYPE_VALUES_RAW (BASES_CHECK (NODE)))
4376
4377 #define BASES_DIRECT(NODE) \
4378   TREE_LANG_FLAG_0 (BASES_CHECK (NODE))
4379
4380 /* The expression in question for a DECLTYPE_TYPE.  */
4381 #define DECLTYPE_TYPE_EXPR(NODE) (TYPE_VALUES_RAW (DECLTYPE_TYPE_CHECK (NODE)))
4382
4383 /* Whether the DECLTYPE_TYPE_EXPR of NODE was originally parsed as an
4384    id-expression or a member-access expression. When false, it was
4385    parsed as a full expression.  */
4386 #define DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P(NODE) \
4387   (DECLTYPE_TYPE_CHECK (NODE))->type_common.string_flag
4388
4389 /* These flags indicate that we want different semantics from normal
4390    decltype: lambda capture just drops references, init capture
4391    uses auto semantics, lambda proxies look through implicit dereference.  */
4392 #define DECLTYPE_FOR_LAMBDA_CAPTURE(NODE) \
4393   TREE_LANG_FLAG_0 (DECLTYPE_TYPE_CHECK (NODE))
4394 #define DECLTYPE_FOR_INIT_CAPTURE(NODE) \
4395   TREE_LANG_FLAG_1 (DECLTYPE_TYPE_CHECK (NODE))
4396 #define DECLTYPE_FOR_LAMBDA_PROXY(NODE) \
4397   TREE_LANG_FLAG_2 (DECLTYPE_TYPE_CHECK (NODE))
4398 #define DECLTYPE_FOR_REF_CAPTURE(NODE) \
4399   TREE_LANG_FLAG_3 (DECLTYPE_TYPE_CHECK (NODE))
4400
4401 /* Nonzero for VAR_DECL and FUNCTION_DECL node means that `extern' was
4402    specified in its declaration.  This can also be set for an
4403    erroneously declared PARM_DECL.  */
4404 #define DECL_THIS_EXTERN(NODE) \
4405   DECL_LANG_FLAG_2 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE))
4406
4407 /* Nonzero for VAR_DECL and FUNCTION_DECL node means that `static' was
4408    specified in its declaration.  This can also be set for an
4409    erroneously declared PARM_DECL.  */
4410 #define DECL_THIS_STATIC(NODE) \
4411   DECL_LANG_FLAG_6 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE))
4412
4413 /* Nonzero for FIELD_DECL node means that this field is a lambda capture
4414    field for an array of runtime bound.  */
4415 #define DECL_VLA_CAPTURE_P(NODE) \
4416   DECL_LANG_FLAG_1 (FIELD_DECL_CHECK (NODE))
4417
4418 /* Nonzero for PARM_DECL node means that this is an array function
4419    parameter, i.e, a[] rather than *a.  */
4420 #define DECL_ARRAY_PARAMETER_P(NODE) \
4421   DECL_LANG_FLAG_1 (PARM_DECL_CHECK (NODE))
4422
4423 /* Nonzero for a FIELD_DECL who's NSMDI is currently being
4424    instantiated.  */
4425 #define DECL_INSTANTIATING_NSDMI_P(NODE) \
4426   DECL_LANG_FLAG_2 (FIELD_DECL_CHECK (NODE))
4427
4428 /* Nonzero for FIELD_DECL node means that this field is a base class
4429    of the parent object, as opposed to a member field.  */
4430 #define DECL_FIELD_IS_BASE(NODE) \
4431   DECL_LANG_FLAG_6 (FIELD_DECL_CHECK (NODE))
4432
4433 /* Nonzero for FIELD_DECL node means that this field is a simple (no
4434    explicit initializer) lambda capture field, making it invisible to
4435    name lookup in unevaluated contexts.  */
4436 #define DECL_NORMAL_CAPTURE_P(NODE) \
4437   DECL_LANG_FLAG_7 (FIELD_DECL_CHECK (NODE))
4438
4439 /* Nonzero if TYPE is an anonymous union or struct type.  We have to use a
4440    flag for this because "A union for which objects or pointers are
4441    declared is not an anonymous union" [class.union].  */
4442 #define ANON_AGGR_TYPE_P(NODE)                          \
4443   (CLASS_TYPE_P (NODE) && LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr)
4444 #define SET_ANON_AGGR_TYPE_P(NODE)                      \
4445   (LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr = 1)
4446
4447 /* Nonzero if TYPE is an anonymous union type.  */
4448 #define ANON_UNION_TYPE_P(NODE) \
4449   (TREE_CODE (NODE) == UNION_TYPE && ANON_AGGR_TYPE_P (NODE))
4450
4451 /* Define fields and accessors for nodes representing declared names.  */
4452
4453 /* Nonzero if TYPE is an unnamed class with a typedef for linkage purposes.  */
4454 #define TYPE_WAS_UNNAMED(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->was_anonymous)
4455
4456 /* C++: all of these are overloaded!  These apply only to TYPE_DECLs.  */
4457
4458 /* The format of each node in the DECL_FRIENDLIST is as follows:
4459
4460    The TREE_PURPOSE will be the name of a function, i.e., an
4461    IDENTIFIER_NODE.  The TREE_VALUE will be itself a TREE_LIST, whose
4462    TREE_VALUEs are friends with the given name.  */
4463 #define DECL_FRIENDLIST(NODE)           (DECL_INITIAL (NODE))
4464 #define FRIEND_NAME(LIST) (TREE_PURPOSE (LIST))
4465 #define FRIEND_DECLS(LIST) (TREE_VALUE (LIST))
4466
4467 /* The DECL_ACCESS, if non-NULL, is a TREE_LIST.  The TREE_PURPOSE of
4468    each node is a type; the TREE_VALUE is the access granted for this
4469    DECL in that type.  The DECL_ACCESS is set by access declarations.
4470    For example, if a member that would normally be public in a
4471    derived class is made protected, then the derived class and the
4472    protected_access_node will appear in the DECL_ACCESS for the node.  */
4473 #define DECL_ACCESS(NODE) (LANG_DECL_U2_CHECK (NODE, 0)->access)
4474
4475 /* Nonzero if the FUNCTION_DECL is a global constructor.  */
4476 #define DECL_GLOBAL_CTOR_P(NODE) \
4477   (LANG_DECL_FN_CHECK (NODE)->global_ctor_p)
4478
4479 /* Nonzero if the FUNCTION_DECL is a global destructor.  */
4480 #define DECL_GLOBAL_DTOR_P(NODE) \
4481   (LANG_DECL_FN_CHECK (NODE)->global_dtor_p)
4482
4483 /* Accessor macros for C++ template decl nodes.  */
4484
4485 /* The DECL_TEMPLATE_PARMS are a list.  The TREE_PURPOSE of each node
4486    is a INT_CST whose TREE_INT_CST_LOW indicates the level of the
4487    template parameters, with 1 being the outermost set of template
4488    parameters.  The TREE_VALUE is a vector, whose elements are the
4489    template parameters at each level.  Each element in the vector is a
4490    TREE_LIST, whose TREE_VALUE is a PARM_DECL (if the parameter is a
4491    non-type parameter), or a TYPE_DECL (if the parameter is a type
4492    parameter).  The TREE_PURPOSE is the default value, if any.  The
4493    TEMPLATE_PARM_INDEX for the parameter is available as the
4494    DECL_INITIAL (for a PARM_DECL) or as the TREE_TYPE (for a
4495    TYPE_DECL).
4496
4497    FIXME: CONST_CAST_TREE is a hack that hopefully will go away after
4498    tree is converted to C++ class hiearchy.  */
4499 #define DECL_TEMPLATE_PARMS(NODE)       \
4500    ((struct tree_template_decl *)CONST_CAST_TREE (TEMPLATE_DECL_CHECK (NODE)))->arguments
4501 #define DECL_INNERMOST_TEMPLATE_PARMS(NODE) \
4502    INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (NODE))
4503 #define DECL_NTPARMS(NODE) \
4504    TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (NODE))
4505 /* For function, method, class-data templates.
4506
4507    FIXME: CONST_CAST_TREE is a hack that hopefully will go away after
4508    tree is converted to C++ class hiearchy.  */
4509 #define DECL_TEMPLATE_RESULT(NODE)      \
4510    ((struct tree_template_decl *)CONST_CAST_TREE(TEMPLATE_DECL_CHECK (NODE)))->result
4511 /* For a function template at namespace scope, DECL_TEMPLATE_INSTANTIATIONS
4512    lists all instantiations and specializations of the function so that
4513    tsubst_friend_function can reassign them to another template if we find
4514    that the namespace-scope template is really a partial instantiation of a
4515    friend template.
4516
4517    For a class template the DECL_TEMPLATE_INSTANTIATIONS lists holds
4518    all instantiations and specializations of the class type, including
4519    partial instantiations and partial specializations, so that if we
4520    explicitly specialize a partial instantiation we can walk the list
4521    in maybe_process_partial_specialization and reassign them or complain
4522    as appropriate.
4523
4524    In both cases, the TREE_PURPOSE of each node contains the arguments
4525    used; the TREE_VALUE contains the generated variable.  The template
4526    arguments are always complete.  For example, given:
4527
4528       template <class T> struct S1 {
4529         template <class U> struct S2 {};
4530         template <class U> struct S2<U*> {};
4531       };
4532
4533    the record for the partial specialization will contain, as its
4534    argument list, { {T}, {U*} }, and will be on the
4535    DECL_TEMPLATE_INSTANTIATIONS list for `template <class T> template
4536    <class U> struct S1<T>::S2'.
4537
4538    This list is not used for other templates.  */
4539 #define DECL_TEMPLATE_INSTANTIATIONS(NODE) \
4540   DECL_SIZE_UNIT (TEMPLATE_DECL_CHECK (NODE))
4541
4542 /* For a class template, this list contains the partial
4543    specializations of this template.  (Full specializations are not
4544    recorded on this list.)  The TREE_PURPOSE holds the arguments used
4545    in the partial specialization (e.g., for `template <class T> struct
4546    S<T*, int>' this will be `T*, int'.)  The arguments will also include
4547    any outer template arguments.  The TREE_VALUE holds the TEMPLATE_DECL
4548    for the partial specialization.  The TREE_TYPE is the _TYPE node for
4549    the partial specialization.
4550
4551    This list is not used for other templates.  */
4552 #define DECL_TEMPLATE_SPECIALIZATIONS(NODE)     \
4553   DECL_SIZE (TEMPLATE_DECL_CHECK (NODE))
4554
4555 /* Nonzero for a DECL which is actually a template parameter.  Keep
4556    these checks in ascending tree code order.   */
4557 #define DECL_TEMPLATE_PARM_P(NODE)              \
4558   (DECL_LANG_FLAG_0 (NODE)                      \
4559    && (TREE_CODE (NODE) == CONST_DECL           \
4560        || TREE_CODE (NODE) == PARM_DECL         \
4561        || TREE_CODE (NODE) == TYPE_DECL         \
4562        || TREE_CODE (NODE) == TEMPLATE_DECL))
4563
4564 /* Nonzero for a raw template parameter node.  */
4565 #define TEMPLATE_PARM_P(NODE)                                   \
4566   (TREE_CODE (NODE) == TEMPLATE_TYPE_PARM                       \
4567    || TREE_CODE (NODE) == TEMPLATE_TEMPLATE_PARM                \
4568    || TREE_CODE (NODE) == TEMPLATE_PARM_INDEX)
4569
4570 /* Mark NODE as a template parameter.  */
4571 #define SET_DECL_TEMPLATE_PARM_P(NODE) \
4572   (DECL_LANG_FLAG_0 (NODE) = 1)
4573
4574 /* Nonzero if NODE is a template template parameter.  */
4575 #define DECL_TEMPLATE_TEMPLATE_PARM_P(NODE) \
4576   (TREE_CODE (NODE) == TEMPLATE_DECL && DECL_TEMPLATE_PARM_P (NODE))
4577
4578 /* Nonzero for a DECL that represents a function template.  */
4579 #define DECL_FUNCTION_TEMPLATE_P(NODE)                          \
4580   (TREE_CODE (NODE) == TEMPLATE_DECL                            \
4581    && DECL_TEMPLATE_RESULT (NODE) != NULL_TREE                  \
4582    && TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == FUNCTION_DECL)
4583
4584 /* Nonzero for a DECL that represents a class template or alias
4585    template.  */
4586 #define DECL_TYPE_TEMPLATE_P(NODE)                              \
4587   (TREE_CODE (NODE) == TEMPLATE_DECL                            \
4588    && DECL_TEMPLATE_RESULT (NODE) != NULL_TREE                  \
4589    && TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == TYPE_DECL)
4590
4591 /* Nonzero for a DECL that represents a class template.  */
4592 #define DECL_CLASS_TEMPLATE_P(NODE)                             \
4593   (DECL_TYPE_TEMPLATE_P (NODE)                                  \
4594    && DECL_IMPLICIT_TYPEDEF_P (DECL_TEMPLATE_RESULT (NODE)))
4595
4596 /* Nonzero for a TEMPLATE_DECL that represents an alias template.  */
4597 #define DECL_ALIAS_TEMPLATE_P(NODE)                     \
4598   (DECL_TYPE_TEMPLATE_P (NODE)                          \
4599    && !DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (NODE)))
4600
4601 /* Nonzero for a NODE which declares a type.  */
4602 #define DECL_DECLARES_TYPE_P(NODE) \
4603   (TREE_CODE (NODE) == TYPE_DECL || DECL_TYPE_TEMPLATE_P (NODE))
4604
4605 /* Nonzero if NODE declares a function.  */
4606 #define DECL_DECLARES_FUNCTION_P(NODE) \
4607   (TREE_CODE (NODE) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (NODE))
4608
4609 /* Nonzero if NODE is the typedef implicitly generated for a type when
4610    the type is declared.  In C++, `struct S {};' is roughly
4611    equivalent to `struct S {}; typedef struct S S;' in C.
4612    DECL_IMPLICIT_TYPEDEF_P will hold for the typedef indicated in this
4613    example.  In C++, there is a second implicit typedef for each
4614    class, called the injected-class-name, in the scope of `S' itself, so that
4615    you can say `S::S'.  DECL_SELF_REFERENCE_P will hold for that typedef.  */
4616 #define DECL_IMPLICIT_TYPEDEF_P(NODE) \
4617   (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_2 (NODE))
4618 #define SET_DECL_IMPLICIT_TYPEDEF_P(NODE) \
4619   (DECL_LANG_FLAG_2 (NODE) = 1)
4620 #define DECL_SELF_REFERENCE_P(NODE) \
4621   (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_4 (NODE))
4622 #define SET_DECL_SELF_REFERENCE_P(NODE) \
4623   (DECL_LANG_FLAG_4 (NODE) = 1)
4624
4625 /* A `primary' template is one that has its own template header and is not
4626    a partial specialization.  A member function of a class template is a
4627    template, but not primary.  A member template is primary.  Friend
4628    templates are primary, too.  */
4629
4630 /* Returns the primary template corresponding to these parameters.  */
4631 #define DECL_PRIMARY_TEMPLATE(NODE) \
4632   (TREE_TYPE (DECL_INNERMOST_TEMPLATE_PARMS (NODE)))
4633
4634 /* Returns nonzero if NODE is a primary template.  */
4635 #define PRIMARY_TEMPLATE_P(NODE) (DECL_PRIMARY_TEMPLATE (NODE) == (NODE))
4636
4637 /* Nonzero iff NODE is a specialization of a template.  The value
4638    indicates the type of specializations:
4639
4640      1=implicit instantiation
4641
4642      2=partial or explicit specialization, e.g.:
4643
4644         template <> int min<int> (int, int),
4645
4646      3=explicit instantiation, e.g.:
4647
4648         template int min<int> (int, int);
4649
4650    Note that NODE will be marked as a specialization even if the
4651    template it is instantiating is not a primary template.  For
4652    example, given:
4653
4654      template <typename T> struct O {
4655        void f();
4656        struct I {};
4657      };
4658
4659    both O<int>::f and O<int>::I will be marked as instantiations.
4660
4661    If DECL_USE_TEMPLATE is nonzero, then DECL_TEMPLATE_INFO will also
4662    be non-NULL.  */
4663 #define DECL_USE_TEMPLATE(NODE) (DECL_LANG_SPECIFIC (NODE)->u.base.use_template)
4664
4665 /* Like DECL_USE_TEMPLATE, but for class types.  */
4666 #define CLASSTYPE_USE_TEMPLATE(NODE) \
4667   (LANG_TYPE_CLASS_CHECK (NODE)->use_template)
4668
4669 /* True if NODE is a specialization of a primary template.  */
4670 #define CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P(NODE)    \
4671   (CLASS_TYPE_P (NODE)                                          \
4672    && CLASSTYPE_USE_TEMPLATE (NODE)                             \
4673    && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE)))
4674
4675 #define DECL_TEMPLATE_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) & 1)
4676 #define CLASSTYPE_TEMPLATE_INSTANTIATION(NODE) \
4677   (CLASSTYPE_USE_TEMPLATE (NODE) & 1)
4678
4679 #define DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) == 2)
4680 #define SET_DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) = 2)
4681
4682 /* Returns true for an explicit or partial specialization of a class
4683    template.  */
4684 #define CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \
4685   (CLASSTYPE_USE_TEMPLATE (NODE) == 2)
4686 #define SET_CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \
4687   (CLASSTYPE_USE_TEMPLATE (NODE) = 2)
4688
4689 #define DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 1)
4690 #define SET_DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 1)
4691 #define CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \
4692   (CLASSTYPE_USE_TEMPLATE (NODE) == 1)
4693 #define SET_CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \
4694   (CLASSTYPE_USE_TEMPLATE (NODE) = 1)
4695
4696 #define DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 3)
4697 #define SET_DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 3)
4698 #define CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \
4699   (CLASSTYPE_USE_TEMPLATE (NODE) == 3)
4700 #define SET_CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \
4701   (CLASSTYPE_USE_TEMPLATE (NODE) = 3)
4702
4703 /* Nonzero if DECL is a friend function which is an instantiation
4704    from the point of view of the compiler, but not from the point of
4705    view of the language.  For example given:
4706       template <class T> struct S { friend void f(T) {}; };
4707    the declaration of `void f(int)' generated when S<int> is
4708    instantiated will not be a DECL_TEMPLATE_INSTANTIATION, but will be
4709    a DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION.  */
4710 #define DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION(DECL) \
4711   (DECL_LANG_SPECIFIC (DECL) && DECL_TEMPLATE_INFO (DECL) \
4712    && !DECL_USE_TEMPLATE (DECL))
4713
4714 /* Nonzero if DECL is a function generated from a function 'temploid',
4715    i.e. template, member of class template, or dependent friend.  */
4716 #define DECL_TEMPLOID_INSTANTIATION(DECL)               \
4717   (DECL_TEMPLATE_INSTANTIATION (DECL)                   \
4718    || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (DECL))
4719
4720 /* Nonzero if DECL is either defined implicitly by the compiler or
4721    generated from a temploid.  */
4722 #define DECL_GENERATED_P(DECL) \
4723   (DECL_TEMPLOID_INSTANTIATION (DECL) || DECL_DEFAULTED_FN (DECL))
4724
4725 /* Nonzero iff we are currently processing a declaration for an
4726    entity with its own template parameter list, and which is not a
4727    full specialization.  */
4728 #define PROCESSING_REAL_TEMPLATE_DECL_P() \
4729   (!processing_template_parmlist \
4730    && processing_template_decl > template_class_depth (current_scope ()))
4731
4732 /* Nonzero if this VAR_DECL or FUNCTION_DECL has already been
4733    instantiated, i.e. its definition has been generated from the
4734    pattern given in the template.  */
4735 #define DECL_TEMPLATE_INSTANTIATED(NODE) \
4736   DECL_LANG_FLAG_1 (VAR_OR_FUNCTION_DECL_CHECK (NODE))
4737
4738 /* We know what we're doing with this decl now.  */
4739 #define DECL_INTERFACE_KNOWN(NODE) DECL_LANG_FLAG_5 (NODE)
4740
4741 /* DECL_EXTERNAL must be set on a decl until the decl is actually emitted,
4742    so that assemble_external will work properly.  So we have this flag to
4743    tell us whether the decl is really not external.
4744
4745    This flag does not indicate whether or not the decl is defined in the
4746    current translation unit; it indicates whether or not we should emit the
4747    decl at the end of compilation if it is defined and needed.  */
4748 #define DECL_NOT_REALLY_EXTERN(NODE) \
4749   (DECL_LANG_SPECIFIC (NODE)->u.base.not_really_extern)
4750
4751 #define DECL_REALLY_EXTERN(NODE) \
4752   (DECL_EXTERNAL (NODE)                         \
4753    && (!DECL_LANG_SPECIFIC (NODE) || !DECL_NOT_REALLY_EXTERN (NODE)))
4754
4755 /* A thunk is a stub function.
4756
4757    A thunk is an alternate entry point for an ordinary FUNCTION_DECL.
4758    The address of the ordinary FUNCTION_DECL is given by the
4759    DECL_INITIAL, which is always an ADDR_EXPR whose operand is a
4760    FUNCTION_DECL.  The job of the thunk is to either adjust the this
4761    pointer before transferring control to the FUNCTION_DECL, or call
4762    FUNCTION_DECL and then adjust the result value. Note, the result
4763    pointer adjusting thunk must perform a call to the thunked
4764    function, (or be implemented via passing some invisible parameter
4765    to the thunked function, which is modified to perform the
4766    adjustment just before returning).
4767
4768    A thunk may perform either, or both, of the following operations:
4769
4770    o Adjust the this or result pointer by a constant offset.
4771    o Adjust the this or result pointer by looking up a vcall or vbase offset
4772      in the vtable.
4773
4774    A this pointer adjusting thunk converts from a base to a derived
4775    class, and hence adds the offsets. A result pointer adjusting thunk
4776    converts from a derived class to a base, and hence subtracts the
4777    offsets.  If both operations are performed, then the constant
4778    adjustment is performed first for this pointer adjustment and last
4779    for the result pointer adjustment.
4780
4781    The constant adjustment is given by THUNK_FIXED_OFFSET.  If the
4782    vcall or vbase offset is required, THUNK_VIRTUAL_OFFSET is
4783    used. For this pointer adjusting thunks, it is the vcall offset
4784    into the vtable.  For result pointer adjusting thunks it is the
4785    binfo of the virtual base to convert to.  Use that binfo's vbase
4786    offset.
4787
4788    It is possible to have equivalent covariant thunks.  These are
4789    distinct virtual covariant thunks whose vbase offsets happen to
4790    have the same value.  THUNK_ALIAS is used to pick one as the
4791    canonical thunk, which will get all the this pointer adjusting
4792    thunks attached to it.  */
4793
4794 /* An integer indicating how many bytes should be subtracted from the
4795    this or result pointer when this function is called.  */
4796 #define THUNK_FIXED_OFFSET(DECL) \
4797   (DECL_LANG_SPECIFIC (THUNK_FUNCTION_CHECK (DECL))->u.fn.u5.fixed_offset)
4798
4799 /* A tree indicating how to perform the virtual adjustment. For a this
4800    adjusting thunk it is the number of bytes to be added to the vtable
4801    to find the vcall offset. For a result adjusting thunk, it is the
4802    binfo of the relevant virtual base.  If NULL, then there is no
4803    virtual adjust.  (The vptr is always located at offset zero from
4804    the this or result pointer.)  (If the covariant type is within the
4805    class hierarchy being laid out, the vbase index is not yet known
4806    at the point we need to create the thunks, hence the need to use
4807    binfos.)  */
4808
4809 #define THUNK_VIRTUAL_OFFSET(DECL) \
4810   (LANG_DECL_U2_CHECK (FUNCTION_DECL_CHECK (DECL), 0)->access)
4811
4812 /* A thunk which is equivalent to another thunk.  */
4813 #define THUNK_ALIAS(DECL) \
4814   (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->u.min.template_info)
4815
4816 /* For thunk NODE, this is the FUNCTION_DECL thunked to.  It is
4817    possible for the target to be a thunk too.  */
4818 #define THUNK_TARGET(NODE)                              \
4819   (LANG_DECL_FN_CHECK (NODE)->befriending_classes)
4820
4821 /* True for a SCOPE_REF iff the "template" keyword was used to
4822    indicate that the qualified name denotes a template.  */
4823 #define QUALIFIED_NAME_IS_TEMPLATE(NODE) \
4824   (TREE_LANG_FLAG_1 (SCOPE_REF_CHECK (NODE)))
4825
4826 /* True for an OMP_ATOMIC that has dependent parameters.  These are stored
4827    as an expr in operand 1, and integer_zero_node in operand 0.  */
4828 #define OMP_ATOMIC_DEPENDENT_P(NODE) \
4829   (TREE_CODE (TREE_OPERAND (OMP_ATOMIC_CHECK (NODE), 0)) == INTEGER_CST)
4830
4831 /* Used while gimplifying continue statements bound to OMP_FOR nodes.  */
4832 #define OMP_FOR_GIMPLIFYING_P(NODE) \
4833   (TREE_LANG_FLAG_0 (OMP_LOOP_CHECK (NODE)))
4834
4835 /* A language-specific token attached to the OpenMP data clauses to
4836    hold code (or code fragments) related to ctors, dtors, and op=.
4837    See semantics.c for details.  */
4838 #define CP_OMP_CLAUSE_INFO(NODE) \
4839   TREE_TYPE (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_PRIVATE, \
4840                                      OMP_CLAUSE_LINEAR))
4841
4842 /* Nonzero if this transaction expression's body contains statements.  */
4843 #define TRANSACTION_EXPR_IS_STMT(NODE) \
4844    TREE_LANG_FLAG_0 (TRANSACTION_EXPR_CHECK (NODE))
4845
4846 /* These macros provide convenient access to the various _STMT nodes
4847    created when parsing template declarations.  */
4848 #define TRY_STMTS(NODE)         TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 0)
4849 #define TRY_HANDLERS(NODE)      TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 1)
4850
4851 #define EH_SPEC_STMTS(NODE)     TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 0)
4852 #define EH_SPEC_RAISES(NODE)    TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 1)
4853
4854 #define USING_STMT_NAMESPACE(NODE) TREE_OPERAND (USING_STMT_CHECK (NODE), 0)
4855
4856 /* Nonzero if this try block is a function try block.  */
4857 #define FN_TRY_BLOCK_P(NODE)    TREE_LANG_FLAG_3 (TRY_BLOCK_CHECK (NODE))
4858 #define HANDLER_PARMS(NODE)     TREE_OPERAND (HANDLER_CHECK (NODE), 0)
4859 #define HANDLER_BODY(NODE)      TREE_OPERAND (HANDLER_CHECK (NODE), 1)
4860 #define HANDLER_TYPE(NODE)      TREE_TYPE (HANDLER_CHECK (NODE))
4861
4862 /* CLEANUP_STMT accessors.  The statement(s) covered, the cleanup to run
4863    and the VAR_DECL for which this cleanup exists.  */
4864 #define CLEANUP_BODY(NODE)      TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 0)
4865 #define CLEANUP_EXPR(NODE)      TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 1)
4866 #define CLEANUP_DECL(NODE)      TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 2)
4867
4868 /* IF_STMT accessors. These give access to the condition of the if
4869    statement, the then block of the if statement, and the else block
4870    of the if statement if it exists.  */
4871 #define IF_COND(NODE)           TREE_OPERAND (IF_STMT_CHECK (NODE), 0)
4872 #define THEN_CLAUSE(NODE)       TREE_OPERAND (IF_STMT_CHECK (NODE), 1)
4873 #define ELSE_CLAUSE(NODE)       TREE_OPERAND (IF_STMT_CHECK (NODE), 2)
4874 #define IF_SCOPE(NODE)          TREE_OPERAND (IF_STMT_CHECK (NODE), 3)
4875 #define IF_STMT_CONSTEXPR_P(NODE) TREE_LANG_FLAG_0 (IF_STMT_CHECK (NODE))
4876
4877 /* Like PACK_EXPANSION_EXTRA_ARGS, for constexpr if.  IF_SCOPE is used while
4878    building an IF_STMT; IF_STMT_EXTRA_ARGS is used after it is complete.  */
4879 #define IF_STMT_EXTRA_ARGS(NODE) IF_SCOPE (NODE)
4880
4881 /* WHILE_STMT accessors. These give access to the condition of the
4882    while statement and the body of the while statement, respectively.  */
4883 #define WHILE_COND(NODE)        TREE_OPERAND (WHILE_STMT_CHECK (NODE), 0)
4884 #define WHILE_BODY(NODE)        TREE_OPERAND (WHILE_STMT_CHECK (NODE), 1)
4885
4886 /* DO_STMT accessors. These give access to the condition of the do
4887    statement and the body of the do statement, respectively.  */
4888 #define DO_COND(NODE)           TREE_OPERAND (DO_STMT_CHECK (NODE), 0)
4889 #define DO_BODY(NODE)           TREE_OPERAND (DO_STMT_CHECK (NODE), 1)
4890
4891 /* FOR_STMT accessors. These give access to the init statement,
4892    condition, update expression, and body of the for statement,
4893    respectively.  */
4894 #define FOR_INIT_STMT(NODE)     TREE_OPERAND (FOR_STMT_CHECK (NODE), 0)
4895 #define FOR_COND(NODE)          TREE_OPERAND (FOR_STMT_CHECK (NODE), 1)
4896 #define FOR_EXPR(NODE)          TREE_OPERAND (FOR_STMT_CHECK (NODE), 2)
4897 #define FOR_BODY(NODE)          TREE_OPERAND (FOR_STMT_CHECK (NODE), 3)
4898 #define FOR_SCOPE(NODE)         TREE_OPERAND (FOR_STMT_CHECK (NODE), 4)
4899
4900 /* RANGE_FOR_STMT accessors. These give access to the declarator,
4901    expression, body, and scope of the statement, respectively.  */
4902 #define RANGE_FOR_DECL(NODE)    TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 0)
4903 #define RANGE_FOR_EXPR(NODE)    TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 1)
4904 #define RANGE_FOR_BODY(NODE)    TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 2)
4905 #define RANGE_FOR_SCOPE(NODE)   TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 3)
4906 #define RANGE_FOR_UNROLL(NODE)  TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 4)
4907 #define RANGE_FOR_IVDEP(NODE)   TREE_LANG_FLAG_6 (RANGE_FOR_STMT_CHECK (NODE))
4908
4909 #define SWITCH_STMT_COND(NODE)  TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 0)
4910 #define SWITCH_STMT_BODY(NODE)  TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 1)
4911 #define SWITCH_STMT_TYPE(NODE)  TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 2)
4912 #define SWITCH_STMT_SCOPE(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 3)
4913 /* True if there are case labels for all possible values of switch cond, either
4914    because there is a default: case label or because the case label ranges cover
4915    all values.  */
4916 #define SWITCH_STMT_ALL_CASES_P(NODE) \
4917   TREE_LANG_FLAG_0 (SWITCH_STMT_CHECK (NODE))
4918 /* True if the body of a switch stmt contains no BREAK_STMTs.  */
4919 #define SWITCH_STMT_NO_BREAK_P(NODE) \
4920   TREE_LANG_FLAG_2 (SWITCH_STMT_CHECK (NODE))
4921
4922 /* STMT_EXPR accessor.  */
4923 #define STMT_EXPR_STMT(NODE)    TREE_OPERAND (STMT_EXPR_CHECK (NODE), 0)
4924
4925 /* EXPR_STMT accessor. This gives the expression associated with an
4926    expression statement.  */
4927 #define EXPR_STMT_EXPR(NODE)    TREE_OPERAND (EXPR_STMT_CHECK (NODE), 0)
4928
4929 /* True if this TARGET_EXPR was created by build_cplus_new, and so we can
4930    discard it if it isn't useful.  */
4931 #define TARGET_EXPR_IMPLICIT_P(NODE) \
4932   TREE_LANG_FLAG_0 (TARGET_EXPR_CHECK (NODE))
4933
4934 /* True if this TARGET_EXPR is the result of list-initialization of a
4935    temporary.  */
4936 #define TARGET_EXPR_LIST_INIT_P(NODE) \
4937   TREE_LANG_FLAG_1 (TARGET_EXPR_CHECK (NODE))
4938
4939 /* True if this TARGET_EXPR expresses direct-initialization of an object
4940    to be named later.  */
4941 #define TARGET_EXPR_DIRECT_INIT_P(NODE) \
4942   TREE_LANG_FLAG_2 (TARGET_EXPR_CHECK (NODE))
4943
4944 /* True if NODE is a TARGET_EXPR that just expresses a copy of its INITIAL; if
4945    the initializer has void type, it's doing something more complicated.  */
4946 #define SIMPLE_TARGET_EXPR_P(NODE)                              \
4947   (TREE_CODE (NODE) == TARGET_EXPR                              \
4948    && !VOID_TYPE_P (TREE_TYPE (TARGET_EXPR_INITIAL (NODE))))
4949
4950 /* True if EXPR expresses direct-initialization of a TYPE.  */
4951 #define DIRECT_INIT_EXPR_P(TYPE,EXPR)                                   \
4952   (TREE_CODE (EXPR) == TARGET_EXPR && TREE_LANG_FLAG_2 (EXPR)           \
4953    && same_type_ignoring_top_level_qualifiers_p (TYPE, TREE_TYPE (EXPR)))
4954
4955 /* True if this CONVERT_EXPR is for a conversion to virtual base in
4956    an NSDMI, and should be re-evaluated when used in a constructor.  */
4957 #define CONVERT_EXPR_VBASE_PATH(NODE) \
4958   TREE_LANG_FLAG_0 (CONVERT_EXPR_CHECK (NODE))
4959
4960 /* True if SIZEOF_EXPR argument is type.  */
4961 #define SIZEOF_EXPR_TYPE_P(NODE) \
4962   TREE_LANG_FLAG_0 (SIZEOF_EXPR_CHECK (NODE))
4963
4964 /* True if the ALIGNOF_EXPR was spelled "alignof".  */
4965 #define ALIGNOF_EXPR_STD_P(NODE) \
4966   TREE_LANG_FLAG_0 (ALIGNOF_EXPR_CHECK (NODE))
4967
4968 /* An enumeration of the kind of tags that C++ accepts.  */
4969 enum tag_types {
4970   none_type = 0, /* Not a tag type.  */
4971   record_type,   /* "struct" types.  */
4972   class_type,    /* "class" types.  */
4973   union_type,    /* "union" types.  */
4974   enum_type,     /* "enum" types.  */
4975   typename_type, /* "typename" types.  */
4976   scope_type     /* namespace or tagged type name followed by :: */
4977 };
4978
4979 /* The various kinds of lvalues we distinguish.  */
4980 enum cp_lvalue_kind_flags {
4981   clk_none = 0,     /* Things that are not an lvalue.  */
4982   clk_ordinary = 1, /* An ordinary lvalue.  */
4983   clk_rvalueref = 2,/* An xvalue (rvalue formed using an rvalue reference) */
4984   clk_class = 4,    /* A prvalue of class or array type.  */
4985   clk_bitfield = 8, /* An lvalue for a bit-field.  */
4986   clk_packed = 16   /* An lvalue for a packed field.  */
4987 };
4988
4989 /* This type is used for parameters and variables which hold
4990    combinations of the flags in enum cp_lvalue_kind_flags.  */
4991 typedef int cp_lvalue_kind;
4992
4993 /* Various kinds of template specialization, instantiation, etc.  */
4994 enum tmpl_spec_kind {
4995   tsk_none,                /* Not a template at all.  */
4996   tsk_invalid_member_spec, /* An explicit member template
4997                               specialization, but the enclosing
4998                               classes have not all been explicitly
4999                               specialized.  */
5000   tsk_invalid_expl_inst,   /* An explicit instantiation containing
5001                               template parameter lists.  */
5002   tsk_excessive_parms,     /* A template declaration with too many
5003                               template parameter lists.  */
5004   tsk_insufficient_parms,  /* A template declaration with too few
5005                               parameter lists.  */
5006   tsk_template,            /* A template declaration.  */
5007   tsk_expl_spec,           /* An explicit specialization.  */
5008   tsk_expl_inst            /* An explicit instantiation.  */
5009 };
5010
5011 /* The various kinds of access.  BINFO_ACCESS depends on these being
5012    two bit quantities.  The numerical values are important; they are
5013    used to initialize RTTI data structures, so changing them changes
5014    the ABI.  */
5015 enum access_kind {
5016   ak_none = 0,             /* Inaccessible.  */
5017   ak_public = 1,           /* Accessible, as a `public' thing.  */
5018   ak_protected = 2,        /* Accessible, as a `protected' thing.  */
5019   ak_private = 3           /* Accessible, as a `private' thing.  */
5020 };
5021
5022 /* The various kinds of special functions.  If you add to this list,
5023    you should update special_function_p as well.  */
5024 enum special_function_kind {
5025   sfk_none = 0,            /* Not a special function.  This enumeral
5026                               must have value zero; see
5027                               special_function_p.  */
5028   sfk_constructor,         /* A constructor.  */
5029   sfk_copy_constructor,    /* A copy constructor.  */
5030   sfk_move_constructor,    /* A move constructor.  */
5031   sfk_copy_assignment,     /* A copy assignment operator.  */
5032   sfk_move_assignment,     /* A move assignment operator.  */
5033   sfk_destructor,          /* A destructor.  */
5034   sfk_complete_destructor, /* A destructor for complete objects.  */
5035   sfk_base_destructor,     /* A destructor for base subobjects.  */
5036   sfk_deleting_destructor, /* A destructor for complete objects that
5037                               deletes the object after it has been
5038                               destroyed.  */
5039   sfk_conversion,          /* A conversion operator.  */
5040   sfk_deduction_guide,     /* A class template deduction guide.  */
5041   sfk_inheriting_constructor /* An inheriting constructor */
5042 };
5043
5044 /* The various kinds of linkage.  From [basic.link],
5045
5046       A name is said to have linkage when it might denote the same
5047       object, reference, function, type, template, namespace or value
5048       as a name introduced in another scope:
5049
5050       -- When a name has external linkage, the entity it denotes can
5051          be referred to from scopes of other translation units or from
5052          other scopes of the same translation unit.
5053
5054       -- When a name has internal linkage, the entity it denotes can
5055          be referred to by names from other scopes in the same
5056          translation unit.
5057
5058       -- When a name has no linkage, the entity it denotes cannot be
5059          referred to by names from other scopes.  */
5060
5061 enum linkage_kind {
5062   lk_none,                      /* No linkage.  */
5063   lk_internal,                  /* Internal linkage.  */
5064   lk_external                   /* External linkage.  */
5065 };
5066
5067 enum duration_kind {
5068   dk_static,
5069   dk_thread,
5070   dk_auto,
5071   dk_dynamic
5072 };
5073
5074 /* Bitmask flags to control type substitution.  */
5075 enum tsubst_flags {
5076   tf_none = 0,                   /* nothing special */
5077   tf_error = 1 << 0,             /* give error messages  */
5078   tf_warning = 1 << 1,           /* give warnings too  */
5079   tf_ignore_bad_quals = 1 << 2,  /* ignore bad cvr qualifiers */
5080   tf_keep_type_decl = 1 << 3,    /* retain typedef type decls
5081                                     (make_typename_type use) */
5082   tf_ptrmem_ok = 1 << 4,         /* pointers to member ok (internal
5083                                     instantiate_type use) */
5084   tf_user = 1 << 5,              /* found template must be a user template
5085                                     (lookup_template_class use) */
5086   tf_conv = 1 << 6,              /* We are determining what kind of
5087                                     conversion might be permissible,
5088                                     not actually performing the
5089                                     conversion.  */
5090   tf_decltype = 1 << 7,          /* We are the operand of decltype.
5091                                     Used to implement the special rules
5092                                     for calls in decltype (5.2.2/11).  */
5093   tf_partial = 1 << 8,           /* Doing initial explicit argument
5094                                     substitution in fn_type_unification.  */
5095   tf_fndecl_type = 1 << 9,   /* Substituting the type of a function
5096                                 declaration.  */
5097   tf_no_cleanup = 1 << 10,   /* Do not build a cleanup
5098                                 (build_target_expr and friends) */
5099   /* Convenient substitution flags combinations.  */
5100   tf_warning_or_error = tf_warning | tf_error
5101 };
5102
5103 /* This type is used for parameters and variables which hold
5104    combinations of the flags in enum tsubst_flags.  */
5105 typedef int tsubst_flags_t;
5106
5107 /* The kind of checking we can do looking in a class hierarchy.  */
5108 enum base_access_flags {
5109   ba_any = 0,  /* Do not check access, allow an ambiguous base,
5110                       prefer a non-virtual base */
5111   ba_unique = 1 << 0,  /* Must be a unique base.  */
5112   ba_check_bit = 1 << 1,   /* Check access.  */
5113   ba_check = ba_unique | ba_check_bit,
5114   ba_ignore_scope = 1 << 2 /* Ignore access allowed by local scope.  */
5115 };
5116
5117 /* This type is used for parameters and variables which hold
5118    combinations of the flags in enum base_access_flags.  */
5119 typedef int base_access;
5120
5121 /* The various kinds of access check during parsing.  */
5122 enum deferring_kind {
5123   dk_no_deferred = 0, /* Check access immediately */
5124   dk_deferred = 1,    /* Deferred check */
5125   dk_no_check = 2     /* No access check */
5126 };
5127
5128 /* The kind of base we can find, looking in a class hierarchy.
5129    Values <0 indicate we failed.  */
5130 enum base_kind {
5131   bk_inaccessible = -3,   /* The base is inaccessible */
5132   bk_ambig = -2,          /* The base is ambiguous */
5133   bk_not_base = -1,       /* It is not a base */
5134   bk_same_type = 0,       /* It is the same type */
5135   bk_proper_base = 1,     /* It is a proper base */
5136   bk_via_virtual = 2      /* It is a proper base, but via a virtual
5137                              path. This might not be the canonical
5138                              binfo.  */
5139 };
5140
5141 /* Node for "pointer to (virtual) function".
5142    This may be distinct from ptr_type_node so gdb can distinguish them.  */
5143 #define vfunc_ptr_type_node  vtable_entry_type
5144
5145
5146 /* For building calls to `delete'.  */
5147 extern GTY(()) tree integer_two_node;
5148
5149 /* The number of function bodies which we are currently processing.
5150    (Zero if we are at namespace scope, one inside the body of a
5151    function, two inside the body of a function in a local class, etc.)  */
5152 extern int function_depth;
5153
5154 /* Nonzero if we are inside eq_specializations, which affects comparison of
5155    PARM_DECLs in cp_tree_equal.  */
5156 extern int comparing_specializations;
5157
5158 /* In parser.c.  */
5159
5160 /* Nonzero if we are parsing an unevaluated operand: an operand to
5161    sizeof, typeof, or alignof.  This is a count since operands to
5162    sizeof can be nested.  */
5163
5164 extern int cp_unevaluated_operand;
5165
5166 /* RAII class used to inhibit the evaluation of operands during parsing
5167    and template instantiation. Evaluation warnings are also inhibited. */
5168
5169 struct cp_unevaluated
5170 {
5171   cp_unevaluated ();
5172   ~cp_unevaluated ();
5173 };
5174
5175 /* in pt.c  */
5176
5177 /* These values are used for the `STRICT' parameter to type_unification and
5178    fn_type_unification.  Their meanings are described with the
5179    documentation for fn_type_unification.  */
5180
5181 enum unification_kind_t {
5182   DEDUCE_CALL,
5183   DEDUCE_CONV,
5184   DEDUCE_EXACT
5185 };
5186
5187 // An RAII class used to create a new pointer map for local
5188 // specializations. When the stack goes out of scope, the
5189 // previous pointer map is restored.
5190 enum lss_policy { lss_blank, lss_copy };
5191 struct local_specialization_stack
5192 {
5193   local_specialization_stack (lss_policy = lss_blank);
5194   ~local_specialization_stack ();
5195
5196   hash_map<tree, tree> *saved;
5197 };
5198
5199 /* in class.c */
5200
5201 extern int current_class_depth;
5202
5203 /* An array of all local classes present in this translation unit, in
5204    declaration order.  */
5205 extern GTY(()) vec<tree, va_gc> *local_classes;
5206
5207 /* in decl.c */
5208
5209 /* An array of static vars & fns.  */
5210 extern GTY(()) vec<tree, va_gc> *static_decls;
5211
5212 /* An array of vtable-needing types that have no key function, or have
5213    an emitted key function.  */
5214 extern GTY(()) vec<tree, va_gc> *keyed_classes;
5215 \f
5216 /* Here's where we control how name mangling takes place.  */
5217
5218 /* Cannot use '$' up front, because this confuses gdb
5219    (names beginning with '$' are gdb-local identifiers).
5220
5221    Note that all forms in which the '$' is significant are long enough
5222    for direct indexing (meaning that if we know there is a '$'
5223    at a particular location, we can index into the string at
5224    any other location that provides distinguishing characters).  */
5225
5226 /* Define NO_DOT_IN_LABEL in your favorite tm file if your assembler
5227    doesn't allow '.' in symbol names.  */
5228 #ifndef NO_DOT_IN_LABEL
5229
5230 #define JOINER '.'
5231
5232 #define AUTO_TEMP_NAME "_.tmp_"
5233 #define VFIELD_BASE ".vf"
5234 #define VFIELD_NAME "_vptr."
5235 #define VFIELD_NAME_FORMAT "_vptr.%s"
5236
5237 #else /* NO_DOT_IN_LABEL */
5238
5239 #ifndef NO_DOLLAR_IN_LABEL
5240
5241 #define JOINER '$'
5242
5243 #define AUTO_TEMP_NAME "_$tmp_"
5244 #define VFIELD_BASE "$vf"
5245 #define VFIELD_NAME "_vptr$"
5246 #define VFIELD_NAME_FORMAT "_vptr$%s"
5247
5248 #else /* NO_DOLLAR_IN_LABEL */
5249
5250 #define AUTO_TEMP_NAME "__tmp_"
5251 #define TEMP_NAME_P(ID_NODE) \
5252   (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, \
5253              sizeof (AUTO_TEMP_NAME) - 1))
5254 #define VTABLE_NAME "__vt_"
5255 #define VTABLE_NAME_P(ID_NODE) \
5256   (!strncmp (IDENTIFIER_POINTER (ID_NODE), VTABLE_NAME, \
5257              sizeof (VTABLE_NAME) - 1))
5258 #define VFIELD_BASE "__vfb"
5259 #define VFIELD_NAME "__vptr_"
5260 #define VFIELD_NAME_P(ID_NODE) \
5261   (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, \
5262             sizeof (VFIELD_NAME) - 1))
5263 #define VFIELD_NAME_FORMAT "__vptr_%s"
5264
5265 #endif  /* NO_DOLLAR_IN_LABEL */
5266 #endif  /* NO_DOT_IN_LABEL */
5267
5268 #define LAMBDANAME_PREFIX "__lambda"
5269 #define LAMBDANAME_FORMAT LAMBDANAME_PREFIX "%d"
5270
5271 #define UDLIT_OP_ANSI_PREFIX "operator\"\""
5272 #define UDLIT_OP_ANSI_FORMAT UDLIT_OP_ANSI_PREFIX "%s"
5273 #define UDLIT_OP_MANGLED_PREFIX "li"
5274 #define UDLIT_OP_MANGLED_FORMAT UDLIT_OP_MANGLED_PREFIX "%s"
5275 #define UDLIT_OPER_P(ID_NODE) \
5276   (!strncmp (IDENTIFIER_POINTER (ID_NODE), \
5277              UDLIT_OP_ANSI_PREFIX, \
5278              sizeof (UDLIT_OP_ANSI_PREFIX) - 1))
5279 #define UDLIT_OP_SUFFIX(ID_NODE) \
5280   (IDENTIFIER_POINTER (ID_NODE) + sizeof (UDLIT_OP_ANSI_PREFIX) - 1)
5281
5282 #if !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL)
5283
5284 #define VTABLE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == 'v' \
5285   && IDENTIFIER_POINTER (ID_NODE)[2] == 't' \
5286   && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER)
5287
5288 #define TEMP_NAME_P(ID_NODE) \
5289   (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, sizeof (AUTO_TEMP_NAME)-1))
5290 #define VFIELD_NAME_P(ID_NODE) \
5291   (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, sizeof(VFIELD_NAME)-1))
5292
5293 #endif /* !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL) */
5294
5295 \f
5296 /* Nonzero if we're done parsing and into end-of-file activities.
5297    Two if we're done with front-end processing.  */
5298
5299 extern int at_eof;
5300
5301 /* True if note_mangling_alias should enqueue mangling aliases for
5302    later generation, rather than emitting them right away.  */
5303
5304 extern bool defer_mangling_aliases;
5305
5306 /* True if noexcept is part of the type (i.e. in C++17).  */
5307
5308 extern bool flag_noexcept_type;
5309
5310 /* A list of namespace-scope objects which have constructors or
5311    destructors which reside in the global scope.  The decl is stored
5312    in the TREE_VALUE slot and the initializer is stored in the
5313    TREE_PURPOSE slot.  */
5314 extern GTY(()) tree static_aggregates;
5315 /* Likewise, for thread local storage.  */
5316 extern GTY(()) tree tls_aggregates;
5317
5318 enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, TYPENAME_FLAG };
5319
5320 /* These are uses as bits in flags passed to various functions to
5321    control their behavior.  Despite the LOOKUP_ prefix, many of these
5322    do not control name lookup.  ??? Functions using these flags should
5323    probably be modified to accept explicit boolean flags for the
5324    behaviors relevant to them.  */
5325 /* Check for access violations.  */
5326 #define LOOKUP_PROTECT (1 << 0)
5327 #define LOOKUP_NORMAL (LOOKUP_PROTECT)
5328 /* Even if the function found by lookup is a virtual function, it
5329    should be called directly.  */
5330 #define LOOKUP_NONVIRTUAL (1 << 1)
5331 /* Non-converting (i.e., "explicit") constructors are not tried.  This flag
5332    indicates that we are not performing direct-initialization.  */
5333 #define LOOKUP_ONLYCONVERTING (1 << 2)
5334 #define LOOKUP_IMPLICIT (LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING)
5335 /* If a temporary is created, it should be created so that it lives
5336    as long as the current variable bindings; otherwise it only lives
5337    until the end of the complete-expression.  It also forces
5338    direct-initialization in cases where other parts of the compiler
5339    have already generated a temporary, such as reference
5340    initialization and the catch parameter.  */
5341 #define DIRECT_BIND (1 << 3)
5342 /* We're performing a user-defined conversion, so more user-defined
5343    conversions are not permitted (only built-in conversions).  */
5344 #define LOOKUP_NO_CONVERSION (1 << 4)
5345 /* The user has explicitly called a destructor.  (Therefore, we do
5346    not need to check that the object is non-NULL before calling the
5347    destructor.)  */
5348 #define LOOKUP_DESTRUCTOR (1 << 5)
5349 /* Do not permit references to bind to temporaries.  */
5350 #define LOOKUP_NO_TEMP_BIND (1 << 6)
5351 /* Do not accept objects, and possibly namespaces.  */
5352 #define LOOKUP_PREFER_TYPES (1 << 7)
5353 /* Do not accept objects, and possibly types.   */
5354 #define LOOKUP_PREFER_NAMESPACES (1 << 8)
5355 /* Accept types or namespaces.  */
5356 #define LOOKUP_PREFER_BOTH (LOOKUP_PREFER_TYPES | LOOKUP_PREFER_NAMESPACES)
5357 /* Return friend declarations and un-declared builtin functions.
5358    (Normally, these entities are registered in the symbol table, but
5359    not found by lookup.)  */
5360 #define LOOKUP_HIDDEN (LOOKUP_PREFER_NAMESPACES << 1)
5361 /* We're trying to treat an lvalue as an rvalue.  */
5362 #define LOOKUP_PREFER_RVALUE (LOOKUP_HIDDEN << 1)
5363 /* We're inside an init-list, so narrowing conversions are ill-formed.  */
5364 #define LOOKUP_NO_NARROWING (LOOKUP_PREFER_RVALUE << 1)
5365 /* We're looking up a constructor for list-initialization.  */
5366 #define LOOKUP_LIST_INIT_CTOR (LOOKUP_NO_NARROWING << 1)
5367 /* This is the first parameter of a copy constructor.  */
5368 #define LOOKUP_COPY_PARM (LOOKUP_LIST_INIT_CTOR << 1)
5369 /* We only want to consider list constructors.  */
5370 #define LOOKUP_LIST_ONLY (LOOKUP_COPY_PARM << 1)
5371 /* Return after determining which function to call and checking access.
5372    Used by sythesized_method_walk to determine which functions will
5373    be called to initialize subobjects, in order to determine exception
5374    specification and possible implicit delete.
5375    This is kind of a hack, but exiting early avoids problems with trying
5376    to perform argument conversions when the class isn't complete yet.  */
5377 #define LOOKUP_SPECULATIVE (LOOKUP_LIST_ONLY << 1)
5378 /* Used by calls from defaulted functions to limit the overload set to avoid
5379    cycles trying to declare them (core issue 1092).  */
5380 #define LOOKUP_DEFAULTED (LOOKUP_SPECULATIVE << 1)
5381 /* Used in calls to store_init_value to suppress its usual call to
5382    digest_init.  */
5383 #define LOOKUP_ALREADY_DIGESTED (LOOKUP_DEFAULTED << 1)
5384 /* An instantiation with explicit template arguments.  */
5385 #define LOOKUP_EXPLICIT_TMPL_ARGS (LOOKUP_ALREADY_DIGESTED << 1)
5386 /* Like LOOKUP_NO_TEMP_BIND, but also prevent binding to xvalues.  */
5387 #define LOOKUP_NO_RVAL_BIND (LOOKUP_EXPLICIT_TMPL_ARGS << 1)
5388 /* Used by case_conversion to disregard non-integral conversions.  */
5389 #define LOOKUP_NO_NON_INTEGRAL (LOOKUP_NO_RVAL_BIND << 1)
5390 /* Used for delegating constructors in order to diagnose self-delegation.  */
5391 #define LOOKUP_DELEGATING_CONS (LOOKUP_NO_NON_INTEGRAL << 1)
5392
5393 #define LOOKUP_NAMESPACES_ONLY(F)  \
5394   (((F) & LOOKUP_PREFER_NAMESPACES) && !((F) & LOOKUP_PREFER_TYPES))
5395 #define LOOKUP_TYPES_ONLY(F)  \
5396   (!((F) & LOOKUP_PREFER_NAMESPACES) && ((F) & LOOKUP_PREFER_TYPES))
5397 #define LOOKUP_QUALIFIERS_ONLY(F)     ((F) & LOOKUP_PREFER_BOTH)
5398
5399
5400 /* These flags are used by the conversion code.
5401    CONV_IMPLICIT   :  Perform implicit conversions (standard and user-defined).
5402    CONV_STATIC     :  Perform the explicit conversions for static_cast.
5403    CONV_CONST      :  Perform the explicit conversions for const_cast.
5404    CONV_REINTERPRET:  Perform the explicit conversions for reinterpret_cast.
5405    CONV_PRIVATE    :  Perform upcasts to private bases.
5406    CONV_FORCE_TEMP :  Require a new temporary when converting to the same
5407                       aggregate type.  */
5408
5409 #define CONV_IMPLICIT    1
5410 #define CONV_STATIC      2
5411 #define CONV_CONST       4
5412 #define CONV_REINTERPRET 8
5413 #define CONV_PRIVATE     16
5414 /* #define CONV_NONCONVERTING 32 */
5415 #define CONV_FORCE_TEMP  64
5416 #define CONV_FOLD        128
5417 #define CONV_OLD_CONVERT (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \
5418                           | CONV_REINTERPRET)
5419 #define CONV_C_CAST      (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \
5420                           | CONV_REINTERPRET | CONV_PRIVATE | CONV_FORCE_TEMP)
5421 #define CONV_BACKEND_CONVERT (CONV_OLD_CONVERT | CONV_FOLD)
5422
5423 /* Used by build_expr_type_conversion to indicate which types are
5424    acceptable as arguments to the expression under consideration.  */
5425
5426 #define WANT_INT        1 /* integer types, including bool */
5427 #define WANT_FLOAT      2 /* floating point types */
5428 #define WANT_ENUM       4 /* enumerated types */
5429 #define WANT_POINTER    8 /* pointer types */
5430 #define WANT_NULL      16 /* null pointer constant */
5431 #define WANT_VECTOR_OR_COMPLEX 32 /* vector or complex types */
5432 #define WANT_ARITH      (WANT_INT | WANT_FLOAT | WANT_VECTOR_OR_COMPLEX)
5433
5434 /* Used with comptypes, and related functions, to guide type
5435    comparison.  */
5436
5437 #define COMPARE_STRICT        0 /* Just check if the types are the
5438                                    same.  */
5439 #define COMPARE_BASE          1 /* Check to see if the second type is
5440                                    derived from the first.  */
5441 #define COMPARE_DERIVED       2 /* Like COMPARE_BASE, but in
5442                                    reverse.  */
5443 #define COMPARE_REDECLARATION 4 /* The comparison is being done when
5444                                    another declaration of an existing
5445                                    entity is seen.  */
5446 #define COMPARE_STRUCTURAL    8 /* The comparison is intended to be
5447                                    structural. The actual comparison
5448                                    will be identical to
5449                                    COMPARE_STRICT.  */
5450
5451 /* Used with start function.  */
5452 #define SF_DEFAULT           0  /* No flags.  */
5453 #define SF_PRE_PARSED        1  /* The function declaration has
5454                                    already been parsed.  */
5455 #define SF_INCLASS_INLINE    2  /* The function is an inline, defined
5456                                    in the class body.  */
5457
5458 /* Used with start_decl's initialized parameter.  */
5459 #define SD_UNINITIALIZED     0
5460 #define SD_INITIALIZED       1
5461 #define SD_DEFAULTED         2
5462 #define SD_DELETED           3
5463
5464 /* Returns nonzero iff TYPE1 and TYPE2 are the same type, or if TYPE2
5465    is derived from TYPE1, or if TYPE2 is a pointer (reference) to a
5466    class derived from the type pointed to (referred to) by TYPE1.  */
5467 #define same_or_base_type_p(TYPE1, TYPE2) \
5468   comptypes ((TYPE1), (TYPE2), COMPARE_BASE)
5469
5470 /* These macros are used to access a TEMPLATE_PARM_INDEX.  */
5471 #define TEMPLATE_PARM_INDEX_CAST(NODE) \
5472         ((template_parm_index*)TEMPLATE_PARM_INDEX_CHECK (NODE))
5473 #define TEMPLATE_PARM_IDX(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->index)
5474 #define TEMPLATE_PARM_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->level)
5475 #define TEMPLATE_PARM_DESCENDANTS(NODE) (TREE_CHAIN (NODE))
5476 #define TEMPLATE_PARM_ORIG_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->orig_level)
5477 #define TEMPLATE_PARM_DECL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->decl)
5478 #define TEMPLATE_PARM_PARAMETER_PACK(NODE) \
5479   (TREE_LANG_FLAG_0 (TEMPLATE_PARM_INDEX_CHECK (NODE)))
5480
5481 /* These macros are for accessing the fields of TEMPLATE_TYPE_PARM,
5482    TEMPLATE_TEMPLATE_PARM and BOUND_TEMPLATE_TEMPLATE_PARM nodes.  */
5483 #define TEMPLATE_TYPE_PARM_INDEX(NODE)                                  \
5484   (TYPE_VALUES_RAW (TREE_CHECK3 ((NODE), TEMPLATE_TYPE_PARM,            \
5485                                  TEMPLATE_TEMPLATE_PARM,                \
5486                                  BOUND_TEMPLATE_TEMPLATE_PARM)))
5487 #define TEMPLATE_TYPE_IDX(NODE) \
5488   (TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (NODE)))
5489 #define TEMPLATE_TYPE_LEVEL(NODE) \
5490   (TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
5491 #define TEMPLATE_TYPE_ORIG_LEVEL(NODE) \
5492   (TEMPLATE_PARM_ORIG_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
5493 #define TEMPLATE_TYPE_DECL(NODE) \
5494   (TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
5495 #define TEMPLATE_TYPE_PARAMETER_PACK(NODE) \
5496   (TEMPLATE_PARM_PARAMETER_PACK (TEMPLATE_TYPE_PARM_INDEX (NODE)))
5497
5498 /* For a C++17 class deduction placeholder, the template it represents.  */
5499 #define CLASS_PLACEHOLDER_TEMPLATE(NODE) \
5500   (DECL_INITIAL (TYPE_NAME (TEMPLATE_TYPE_PARM_CHECK (NODE))))
5501
5502 /* Contexts in which auto deduction occurs. These flags are
5503    used to control diagnostics in do_auto_deduction.  */
5504
5505 enum auto_deduction_context
5506 {
5507   adc_unspecified,   /* Not given */
5508   adc_variable_type, /* Variable initializer deduction */
5509   adc_return_type,   /* Return type deduction */
5510   adc_unify,         /* Template argument deduction */
5511   adc_requirement,   /* Argument deduction constraint */
5512   adc_decomp_type    /* Decomposition declaration initializer deduction */
5513 };
5514
5515 /* True if this type-parameter belongs to a class template, used by C++17
5516    class template argument deduction.  */
5517 #define TEMPLATE_TYPE_PARM_FOR_CLASS(NODE) \
5518   (TREE_LANG_FLAG_0 (TEMPLATE_TYPE_PARM_CHECK (NODE)))
5519
5520 /* True iff this TEMPLATE_TYPE_PARM represents decltype(auto).  */
5521 #define AUTO_IS_DECLTYPE(NODE) \
5522   (TYPE_LANG_FLAG_5 (TEMPLATE_TYPE_PARM_CHECK (NODE)))
5523
5524 /* These constants can used as bit flags in the process of tree formatting.
5525
5526    TFF_PLAIN_IDENTIFIER: unqualified part of a name.
5527    TFF_SCOPE: include the class and namespace scope of the name.
5528    TFF_CHASE_TYPEDEF: print the original type-id instead of the typedef-name.
5529    TFF_DECL_SPECIFIERS: print decl-specifiers.
5530    TFF_CLASS_KEY_OR_ENUM: precede a class-type name (resp. enum name) with
5531        a class-key (resp. `enum').
5532    TFF_RETURN_TYPE: include function return type.
5533    TFF_FUNCTION_DEFAULT_ARGUMENTS: include function default parameter values.
5534    TFF_EXCEPTION_SPECIFICATION: show function exception specification.
5535    TFF_TEMPLATE_HEADER: show the template<...> header in a
5536        template-declaration.
5537    TFF_TEMPLATE_NAME: show only template-name.
5538    TFF_EXPR_IN_PARENS: parenthesize expressions.
5539    TFF_NO_FUNCTION_ARGUMENTS: don't show function arguments.
5540    TFF_UNQUALIFIED_NAME: do not print the qualifying scope of the
5541        top-level entity.
5542    TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS: do not omit template arguments
5543        identical to their defaults.
5544    TFF_NO_TEMPLATE_BINDINGS: do not print information about the template
5545        arguments for a function template specialization.
5546    TFF_POINTER: we are printing a pointer type.  */
5547
5548 #define TFF_PLAIN_IDENTIFIER                    (0)
5549 #define TFF_SCOPE                               (1)
5550 #define TFF_CHASE_TYPEDEF                       (1 << 1)
5551 #define TFF_DECL_SPECIFIERS                     (1 << 2)
5552 #define TFF_CLASS_KEY_OR_ENUM                   (1 << 3)
5553 #define TFF_RETURN_TYPE                         (1 << 4)
5554 #define TFF_FUNCTION_DEFAULT_ARGUMENTS          (1 << 5)
5555 #define TFF_EXCEPTION_SPECIFICATION             (1 << 6)
5556 #define TFF_TEMPLATE_HEADER                     (1 << 7)
5557 #define TFF_TEMPLATE_NAME                       (1 << 8)
5558 #define TFF_EXPR_IN_PARENS                      (1 << 9)
5559 #define TFF_NO_FUNCTION_ARGUMENTS               (1 << 10)
5560 #define TFF_UNQUALIFIED_NAME                    (1 << 11)
5561 #define TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS  (1 << 12)
5562 #define TFF_NO_TEMPLATE_BINDINGS                (1 << 13)
5563 #define TFF_POINTER                             (1 << 14)
5564
5565 /* Returns the TEMPLATE_DECL associated to a TEMPLATE_TEMPLATE_PARM
5566    node.  */
5567 #define TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL(NODE)      \
5568   ((TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM)   \
5569    ? TYPE_TI_TEMPLATE (NODE)                            \
5570    : TYPE_NAME (NODE))
5571
5572 /* in lex.c  */
5573
5574 extern void init_reswords (void);
5575
5576 /* Various flags for the overloaded operator information.  */
5577 enum ovl_op_flags
5578   {
5579     OVL_OP_FLAG_NONE = 0,       /* Don't care.  */
5580     OVL_OP_FLAG_UNARY = 1,      /* Is unary.  */
5581     OVL_OP_FLAG_BINARY = 2,     /* Is binary.  */
5582     OVL_OP_FLAG_AMBIARY = 3,    /* May be unary or binary.  */
5583     OVL_OP_FLAG_ALLOC = 4,      /* operator new or delete.  */
5584     OVL_OP_FLAG_DELETE = 1,     /* operator delete.  */
5585     OVL_OP_FLAG_VEC = 2         /* vector new or delete.  */
5586   };
5587
5588 /* Compressed operator codes.  Order is determined by operators.def
5589    and does not match that of tree_codes.  */
5590 enum ovl_op_code
5591   {
5592     OVL_OP_ERROR_MARK,
5593     OVL_OP_NOP_EXPR,
5594 #define DEF_OPERATOR(NAME, CODE, MANGLING, FLAGS) OVL_OP_##CODE,
5595 #define DEF_ASSN_OPERATOR(NAME, CODE, MANGLING) /* NOTHING */
5596 #include "operators.def"
5597     OVL_OP_MAX
5598   };
5599
5600 struct GTY(()) ovl_op_info_t {
5601   /* The IDENTIFIER_NODE for the operator.  */
5602   tree identifier;
5603   /* The name of the operator.  */
5604   const char *name;
5605   /* The mangled name of the operator.  */
5606   const char *mangled_name;
5607   /* The (regular) tree code.  */
5608   enum tree_code tree_code : 16;
5609   /* The (compressed) operator code.  */
5610   enum ovl_op_code ovl_op_code : 8;
5611   /* The ovl_op_flags of the operator */
5612   unsigned flags : 8;
5613 };
5614
5615 /* Overloaded operator info indexed by ass_op_p & ovl_op_code.  */
5616 extern GTY(()) ovl_op_info_t ovl_op_info[2][OVL_OP_MAX];
5617 /* Mapping from tree_codes to ovl_op_codes.  */
5618 extern GTY(()) unsigned char ovl_op_mapping[MAX_TREE_CODES];
5619 /* Mapping for ambi-ary operators from the binary to the unary.  */
5620 extern GTY(()) unsigned char ovl_op_alternate[OVL_OP_MAX];
5621
5622 /* Given an ass_op_p boolean and a tree code, return a pointer to its
5623    overloaded operator info.  Tree codes for non-overloaded operators
5624    map to the error-operator.  */
5625 #define OVL_OP_INFO(IS_ASS_P, TREE_CODE)                        \
5626   (&ovl_op_info[(IS_ASS_P) != 0][ovl_op_mapping[(TREE_CODE)]])
5627 /* Overloaded operator info for an identifier for which
5628    IDENTIFIER_OVL_OP_P is true.  */
5629 #define IDENTIFIER_OVL_OP_INFO(NODE) \
5630   (&ovl_op_info[IDENTIFIER_KIND_BIT_0 (NODE)][IDENTIFIER_CP_INDEX (NODE)])
5631 #define IDENTIFIER_OVL_OP_FLAGS(NODE) \
5632   (IDENTIFIER_OVL_OP_INFO (NODE)->flags)
5633
5634 /* A type-qualifier, or bitmask therefore, using the TYPE_QUAL
5635    constants.  */
5636
5637 typedef int cp_cv_quals;
5638
5639 /* Non-static member functions have an optional virt-specifier-seq.
5640    There is a VIRT_SPEC value for each virt-specifier.
5641    They can be combined by bitwise-or to form the complete set of
5642    virt-specifiers for a member function.  */
5643 enum virt_specifier
5644   {
5645     VIRT_SPEC_UNSPECIFIED = 0x0,
5646     VIRT_SPEC_FINAL       = 0x1,
5647     VIRT_SPEC_OVERRIDE    = 0x2
5648   };
5649
5650 /* A type-qualifier, or bitmask therefore, using the VIRT_SPEC
5651    constants.  */
5652
5653 typedef int cp_virt_specifiers;
5654
5655 /* Wherever there is a function-cv-qual, there could also be a ref-qualifier:
5656
5657    [dcl.fct]
5658    The return type, the parameter-type-list, the ref-qualifier, and
5659    the cv-qualifier-seq, but not the default arguments or the exception
5660    specification, are part of the function type.
5661
5662    REF_QUAL_NONE    Ordinary member function with no ref-qualifier
5663    REF_QUAL_LVALUE  Member function with the &-ref-qualifier
5664    REF_QUAL_RVALUE  Member function with the &&-ref-qualifier */
5665
5666 enum cp_ref_qualifier {
5667   REF_QUAL_NONE = 0,
5668   REF_QUAL_LVALUE = 1,
5669   REF_QUAL_RVALUE = 2
5670 };
5671
5672 /* A storage class.  */
5673
5674 enum cp_storage_class {
5675   /* sc_none must be zero so that zeroing a cp_decl_specifier_seq
5676      sets the storage_class field to sc_none.  */
5677   sc_none = 0,
5678   sc_auto,
5679   sc_register,
5680   sc_static,
5681   sc_extern,
5682   sc_mutable
5683 };
5684
5685 /* An individual decl-specifier.  This is used to index the array of
5686    locations for the declspecs in struct cp_decl_specifier_seq
5687    below.  */
5688
5689 enum cp_decl_spec {
5690   ds_first,
5691   ds_signed = ds_first,
5692   ds_unsigned,
5693   ds_short,
5694   ds_long,
5695   ds_const,
5696   ds_volatile,
5697   ds_restrict,
5698   ds_inline,
5699   ds_virtual,
5700   ds_explicit,
5701   ds_friend,
5702   ds_typedef,
5703   ds_alias,
5704   ds_constexpr,
5705   ds_complex,
5706   ds_thread,
5707   ds_type_spec,
5708   ds_redefined_builtin_type_spec,
5709   ds_attribute,
5710   ds_std_attribute,
5711   ds_storage_class,
5712   ds_long_long,
5713   ds_concept,
5714   ds_last /* This enumerator must always be the last one.  */
5715 };
5716
5717 /* A decl-specifier-seq.  */
5718
5719 struct cp_decl_specifier_seq {
5720   /* An array of locations for the declaration sepecifiers, indexed by
5721      enum cp_decl_spec_word.  */
5722   source_location locations[ds_last];
5723   /* The primary type, if any, given by the decl-specifier-seq.
5724      Modifiers, like "short", "const", and "unsigned" are not
5725      reflected here.  This field will be a TYPE, unless a typedef-name
5726      was used, in which case it will be a TYPE_DECL.  */
5727   tree type;
5728   /* The attributes, if any, provided with the specifier sequence.  */
5729   tree attributes;
5730   /* The c++11 attributes that follows the type specifier.  */
5731   tree std_attributes;
5732   /* If non-NULL, a built-in type that the user attempted to redefine
5733      to some other type.  */
5734   tree redefined_builtin_type;
5735   /* The storage class specified -- or sc_none if no storage class was
5736      explicitly specified.  */
5737   cp_storage_class storage_class;
5738   /* For the __intN declspec, this stores the index into the int_n_* arrays.  */
5739   int int_n_idx;
5740   /* True iff TYPE_SPEC defines a class or enum.  */
5741   BOOL_BITFIELD type_definition_p : 1;
5742   /* True iff multiple types were (erroneously) specified for this
5743      decl-specifier-seq.  */
5744   BOOL_BITFIELD multiple_types_p : 1;
5745   /* True iff multiple storage classes were (erroneously) specified
5746      for this decl-specifier-seq or a combination of a storage class
5747      with a typedef specifier.  */
5748   BOOL_BITFIELD conflicting_specifiers_p : 1;
5749   /* True iff at least one decl-specifier was found.  */
5750   BOOL_BITFIELD any_specifiers_p : 1;
5751   /* True iff at least one type-specifier was found.  */
5752   BOOL_BITFIELD any_type_specifiers_p : 1;
5753   /* True iff "int" was explicitly provided.  */
5754   BOOL_BITFIELD explicit_int_p : 1;
5755   /* True iff "__intN" was explicitly provided.  */
5756   BOOL_BITFIELD explicit_intN_p : 1;
5757   /* True iff "char" was explicitly provided.  */
5758   BOOL_BITFIELD explicit_char_p : 1;
5759   /* True iff ds_thread is set for __thread, not thread_local.  */
5760   BOOL_BITFIELD gnu_thread_keyword_p : 1;
5761   /* True iff the type is a decltype.  */
5762   BOOL_BITFIELD decltype_p : 1;
5763 };
5764
5765 /* The various kinds of declarators.  */
5766
5767 enum cp_declarator_kind {
5768   cdk_id,
5769   cdk_function,
5770   cdk_array,
5771   cdk_pointer,
5772   cdk_reference,
5773   cdk_ptrmem,
5774   cdk_decomp,
5775   cdk_error
5776 };
5777
5778 /* A declarator.  */
5779
5780 typedef struct cp_declarator cp_declarator;
5781
5782 typedef struct cp_parameter_declarator cp_parameter_declarator;
5783
5784 /* A parameter, before it has been semantically analyzed.  */
5785 struct cp_parameter_declarator {
5786   /* The next parameter, or NULL_TREE if none.  */
5787   cp_parameter_declarator *next;
5788   /* The decl-specifiers-seq for the parameter.  */
5789   cp_decl_specifier_seq decl_specifiers;
5790   /* The declarator for the parameter.  */
5791   cp_declarator *declarator;
5792   /* The default-argument expression, or NULL_TREE, if none.  */
5793   tree default_argument;
5794   /* True iff this is a template parameter pack.  */
5795   bool template_parameter_pack_p;
5796   /* Location within source.  */
5797   location_t loc;
5798 };
5799
5800 /* A declarator.  */
5801 struct cp_declarator {
5802   /* The kind of declarator.  */
5803   ENUM_BITFIELD (cp_declarator_kind) kind : 4;
5804   /* Whether we parsed an ellipsis (`...') just before the declarator,
5805      to indicate this is a parameter pack.  */
5806   BOOL_BITFIELD parameter_pack_p : 1;
5807   /* If this declarator is parenthesized, this the open-paren.  It is
5808      UNKNOWN_LOCATION when not parenthesized.  */
5809   location_t parenthesized;
5810
5811   location_t id_loc; /* Currently only set for cdk_id, cdk_decomp and
5812                         cdk_function. */
5813   /* GNU Attributes that apply to this declarator.  If the declarator
5814      is a pointer or a reference, these attribute apply to the type
5815      pointed to.  */
5816   tree attributes;
5817   /* Standard C++11 attributes that apply to this declarator.  If the
5818      declarator is a pointer or a reference, these attributes apply
5819      to the pointer, rather than to the type pointed to.  */
5820   tree std_attributes;
5821   /* For all but cdk_id, cdk_decomp and cdk_error, the contained declarator.
5822      For cdk_id, cdk_decomp and cdk_error, guaranteed to be NULL.  */
5823   cp_declarator *declarator;
5824   union {
5825     /* For identifiers.  */
5826     struct {
5827       /* If non-NULL, the qualifying scope (a NAMESPACE_DECL or
5828          *_TYPE) for this identifier.  */
5829       tree qualifying_scope;
5830       /* The unqualified name of the entity -- an IDENTIFIER_NODE,
5831          BIT_NOT_EXPR, or TEMPLATE_ID_EXPR.  */
5832       tree unqualified_name;
5833       /* If this is the name of a function, what kind of special
5834          function (if any).  */
5835       special_function_kind sfk;
5836     } id;
5837     /* For functions.  */
5838     struct {
5839       /* The parameters to the function as a TREE_LIST of decl/default.  */
5840       tree parameters;
5841       /* The cv-qualifiers for the function.  */
5842       cp_cv_quals qualifiers;
5843       /* The virt-specifiers for the function.  */
5844       cp_virt_specifiers virt_specifiers;
5845       /* The ref-qualifier for the function.  */
5846       cp_ref_qualifier ref_qualifier;
5847       /* The transaction-safety qualifier for the function.  */
5848       tree tx_qualifier;
5849       /* The exception-specification for the function.  */
5850       tree exception_specification;
5851       /* The late-specified return type, if any.  */
5852       tree late_return_type;
5853       /* The trailing requires-clause, if any. */
5854       tree requires_clause;
5855     } function;
5856     /* For arrays.  */
5857     struct {
5858       /* The bounds to the array.  */
5859       tree bounds;
5860     } array;
5861     /* For cdk_pointer and cdk_ptrmem.  */
5862     struct {
5863       /* The cv-qualifiers for the pointer.  */
5864       cp_cv_quals qualifiers;
5865       /* For cdk_ptrmem, the class type containing the member.  */
5866       tree class_type;
5867     } pointer;
5868     /* For cdk_reference */
5869     struct {
5870       /* The cv-qualifiers for the reference.  These qualifiers are
5871          only used to diagnose ill-formed code.  */
5872       cp_cv_quals qualifiers;
5873       /* Whether this is an rvalue reference */
5874       bool rvalue_ref;
5875     } reference;
5876   } u;
5877 };
5878
5879 /* A level of template instantiation.  */
5880 struct GTY((chain_next ("%h.next"))) tinst_level {
5881   /* The immediately deeper level in the chain.  */
5882   struct tinst_level *next;
5883
5884   /* The original node.  TLDCL can be a DECL (for a function or static
5885      data member), a TYPE (for a class), depending on what we were
5886      asked to instantiate, or a TREE_LIST with the template as PURPOSE
5887      and the template args as VALUE, if we are substituting for
5888      overload resolution.  In all these cases, TARGS is NULL.
5889      However, to avoid creating TREE_LIST objects for substitutions if
5890      we can help, we store PURPOSE and VALUE in TLDCL and TARGS,
5891      respectively.  So TLDCL stands for TREE_LIST or DECL (the
5892      template is a DECL too), whereas TARGS stands for the template
5893      arguments.  */
5894   tree tldcl, targs;
5895
5896  private:
5897   /* Return TRUE iff the original node is a split list.  */
5898   bool split_list_p () const { return targs; }
5899
5900   /* Return TRUE iff the original node is a TREE_LIST object.  */
5901   bool tree_list_p () const
5902   {
5903     return !split_list_p () && TREE_CODE (tldcl) == TREE_LIST;
5904   }
5905
5906   /* Return TRUE iff the original node is not a list, split or not.  */
5907   bool not_list_p () const
5908   {
5909     return !split_list_p () && !tree_list_p ();
5910   }
5911
5912   /* Convert (in place) the original node from a split list to a
5913      TREE_LIST.  */
5914   tree to_list ();
5915
5916  public:
5917   /* Release storage for OBJ and node, if it's a TREE_LIST.  */
5918   static void free (tinst_level *obj);
5919
5920   /* Return TRUE iff the original node is a list, split or not.  */
5921   bool list_p () const { return !not_list_p (); }
5922
5923   /* Return the original node; if it's a split list, make it a
5924      TREE_LIST first, so that it can be returned as a single tree
5925      object.  */
5926   tree get_node () {
5927     if (!split_list_p ()) return tldcl;
5928     else return to_list ();
5929   }
5930
5931   /* Return the original node if it's a DECL or a TREE_LIST, but do
5932      NOT convert a split list to a TREE_LIST: return NULL instead.  */
5933   tree maybe_get_node () const {
5934     if (!split_list_p ()) return tldcl;
5935     else return NULL_TREE;
5936   }
5937
5938   /* The location where the template is instantiated.  */
5939   location_t locus;
5940
5941   /* errorcount + sorrycount when we pushed this level.  */
5942   unsigned short errors;
5943
5944   /* Count references to this object.  If refcount reaches
5945      refcount_infinity value, we don't increment or decrement the
5946      refcount anymore, as the refcount isn't accurate anymore.
5947      The object can be still garbage collected if unreferenced from
5948      anywhere, which might keep referenced objects referenced longer than
5949      otherwise necessary.  Hitting the infinity is rare though.  */
5950   unsigned short refcount;
5951
5952   /* Infinity value for the above refcount.  */
5953   static const unsigned short refcount_infinity = (unsigned short) ~0;
5954 };
5955
5956 bool decl_spec_seq_has_spec_p (const cp_decl_specifier_seq *, cp_decl_spec);
5957
5958 /* Return the type of the `this' parameter of FNTYPE.  */
5959
5960 inline tree
5961 type_of_this_parm (const_tree fntype)
5962 {
5963   function_args_iterator iter;
5964   gcc_assert (TREE_CODE (fntype) == METHOD_TYPE);
5965   function_args_iter_init (&iter, fntype);
5966   return function_args_iter_cond (&iter);
5967 }
5968
5969 /* Return the class of the `this' parameter of FNTYPE.  */
5970
5971 inline tree
5972 class_of_this_parm (const_tree fntype)
5973 {
5974   return TREE_TYPE (type_of_this_parm (fntype));
5975 }
5976
5977 /* True iff T is a variable template declaration. */
5978 inline bool
5979 variable_template_p (tree t)
5980 {
5981   if (TREE_CODE (t) != TEMPLATE_DECL)
5982     return false;
5983   if (!PRIMARY_TEMPLATE_P (t))
5984     return false;
5985   if (tree r = DECL_TEMPLATE_RESULT (t))
5986     return VAR_P (r);
5987   return false;
5988 }
5989
5990 /* True iff T is a variable concept definition. That is, T is
5991    a variable template declared with the concept specifier. */
5992 inline bool
5993 variable_concept_p (tree t)
5994 {
5995   if (TREE_CODE (t) != TEMPLATE_DECL)
5996     return false;
5997   if (tree r = DECL_TEMPLATE_RESULT (t))
5998     return VAR_P (r) && DECL_DECLARED_CONCEPT_P (r);
5999   return false;
6000 }
6001
6002 /* True iff T is a concept definition. That is, T is a variable or function
6003    template declared with the concept specifier. */
6004 inline bool
6005 concept_template_p (tree t)
6006 {
6007   if (TREE_CODE (t) != TEMPLATE_DECL)
6008     return false;
6009   if (tree r = DECL_TEMPLATE_RESULT (t))
6010     return VAR_OR_FUNCTION_DECL_P (r) && DECL_DECLARED_CONCEPT_P (r);
6011   return false;
6012 }
6013
6014 /* A parameter list indicating for a function with no parameters,
6015    e.g  "int f(void)".  */
6016 extern cp_parameter_declarator *no_parameters;
6017
6018 /* Various dump ids.  */
6019 extern int class_dump_id;
6020 extern int raw_dump_id;
6021
6022 /* in call.c */
6023 extern bool check_dtor_name                     (tree, tree);
6024 int magic_varargs_p                             (tree);
6025
6026 extern tree build_conditional_expr              (location_t, tree, tree, tree,
6027                                                  tsubst_flags_t);
6028 extern tree build_addr_func                     (tree, tsubst_flags_t);
6029 extern void set_flags_from_callee               (tree);
6030 extern tree build_call_a                        (tree, int, tree*);
6031 extern tree build_call_n                        (tree, int, ...);
6032 extern bool null_ptr_cst_p                      (tree);
6033 extern bool null_member_pointer_value_p         (tree);
6034 extern bool sufficient_parms_p                  (const_tree);
6035 extern tree type_decays_to                      (tree);
6036 extern tree extract_call_expr                   (tree);
6037 extern tree build_user_type_conversion          (tree, tree, int,
6038                                                  tsubst_flags_t);
6039 extern tree build_new_function_call             (tree, vec<tree, va_gc> **,
6040                                                  tsubst_flags_t);
6041 extern tree build_operator_new_call             (tree, vec<tree, va_gc> **,
6042                                                  tree *, tree *, tree, tree,
6043                                                  tree *, tsubst_flags_t);
6044 extern tree build_new_method_call               (tree, tree,
6045                                                  vec<tree, va_gc> **, tree,
6046                                                  int, tree *, tsubst_flags_t);
6047 extern tree build_special_member_call           (tree, tree,
6048                                                  vec<tree, va_gc> **,
6049                                                  tree, int, tsubst_flags_t);
6050 extern tree build_new_op                        (location_t, enum tree_code,
6051                                                  int, tree, tree, tree, tree *,
6052                                                  tsubst_flags_t);
6053 extern tree build_op_call                       (tree, vec<tree, va_gc> **,
6054                                                  tsubst_flags_t);
6055 extern bool aligned_allocation_fn_p             (tree);
6056 extern bool usual_deallocation_fn_p             (tree);
6057 extern tree build_op_delete_call                (enum tree_code, tree, tree,
6058                                                  bool, tree, tree,
6059                                                  tsubst_flags_t);
6060 extern bool can_convert                         (tree, tree, tsubst_flags_t);
6061 extern bool can_convert_standard                (tree, tree, tsubst_flags_t);
6062 extern bool can_convert_arg                     (tree, tree, tree, int,
6063                                                  tsubst_flags_t);
6064 extern bool can_convert_arg_bad                 (tree, tree, tree, int,
6065                                                  tsubst_flags_t);
6066 extern location_t get_fndecl_argument_location  (tree, int);
6067
6068
6069 /* A class for recording information about access failures (e.g. private
6070    fields), so that we can potentially supply a fix-it hint about
6071    an accessor (from a context in which the constness of the object
6072    is known).  */
6073
6074 class access_failure_info
6075 {
6076  public:
6077   access_failure_info () : m_was_inaccessible (false), m_basetype_path (NULL_TREE),
6078     m_field_decl (NULL_TREE) {}
6079
6080   void record_access_failure (tree basetype_path, tree field_decl);
6081   void maybe_suggest_accessor (bool const_p) const;
6082
6083  private:
6084   bool m_was_inaccessible;
6085   tree m_basetype_path;
6086   tree m_field_decl;
6087 };
6088
6089 extern bool enforce_access                      (tree, tree, tree,
6090                                                  tsubst_flags_t,
6091                                                  access_failure_info *afi = NULL);
6092 extern void push_defarg_context                 (tree);
6093 extern void pop_defarg_context                  (void);
6094 extern tree convert_default_arg                 (tree, tree, tree, int,
6095                                                  tsubst_flags_t);
6096 extern tree convert_arg_to_ellipsis             (tree, tsubst_flags_t);
6097 extern tree build_x_va_arg                      (source_location, tree, tree);
6098 extern tree cxx_type_promotes_to                (tree);
6099 extern tree type_passed_as                      (tree);
6100 extern tree convert_for_arg_passing             (tree, tree, tsubst_flags_t);
6101 extern bool is_properly_derived_from            (tree, tree);
6102 extern tree initialize_reference                (tree, tree, int,
6103                                                  tsubst_flags_t);
6104 extern tree extend_ref_init_temps               (tree, tree, vec<tree, va_gc>**);
6105 extern tree make_temporary_var_for_ref_to_temp  (tree, tree);
6106 extern bool type_has_extended_temps             (tree);
6107 extern tree strip_top_quals                     (tree);
6108 extern bool reference_related_p                 (tree, tree);
6109 extern int remaining_arguments                  (tree);
6110 extern tree perform_implicit_conversion         (tree, tree, tsubst_flags_t);
6111 extern tree perform_implicit_conversion_flags   (tree, tree, tsubst_flags_t, int);
6112 extern tree build_converted_constant_expr       (tree, tree, tsubst_flags_t);
6113 extern tree perform_direct_initialization_if_possible (tree, tree, bool,
6114                                                        tsubst_flags_t);
6115 extern tree in_charge_arg_for_name              (tree);
6116 extern tree build_cxx_call                      (tree, int, tree *,
6117                                                  tsubst_flags_t);
6118 extern bool is_std_init_list                    (tree);
6119 extern bool is_list_ctor                        (tree);
6120 extern void validate_conversion_obstack         (void);
6121 extern void mark_versions_used                  (tree);
6122 extern tree get_function_version_dispatcher     (tree);
6123
6124 /* in class.c */
6125 extern tree build_vfield_ref                    (tree, tree);
6126 extern tree build_if_in_charge                  (tree true_stmt, tree false_stmt = void_node);
6127 extern tree build_base_path                     (enum tree_code, tree,
6128                                                  tree, int, tsubst_flags_t);
6129 extern tree convert_to_base                     (tree, tree, bool, bool,
6130                                                  tsubst_flags_t);
6131 extern tree convert_to_base_statically          (tree, tree);
6132 extern tree build_vtbl_ref                      (tree, tree);
6133 extern tree build_vfn_ref                       (tree, tree);
6134 extern tree get_vtable_decl                     (tree, int);
6135 extern bool add_method                          (tree, tree, bool);
6136 extern tree declared_access                     (tree);
6137 extern tree currently_open_class                (tree);
6138 extern tree currently_open_derived_class        (tree);
6139 extern tree outermost_open_class                (void);
6140 extern tree current_nonlambda_class_type        (void);
6141 extern tree finish_struct                       (tree, tree);
6142 extern void finish_struct_1                     (tree);
6143 extern int resolves_to_fixed_type_p             (tree, int *);
6144 extern void init_class_processing               (void);
6145 extern int is_empty_class                       (tree);
6146 extern bool is_really_empty_class               (tree);
6147 extern void pushclass                           (tree);
6148 extern void popclass                            (void);
6149 extern void push_nested_class                   (tree);
6150 extern void pop_nested_class                    (void);
6151 extern int current_lang_depth                   (void);
6152 extern void push_lang_context                   (tree);
6153 extern void pop_lang_context                    (void);
6154 extern tree instantiate_type                    (tree, tree, tsubst_flags_t);
6155 extern void build_self_reference                (void);
6156 extern int same_signature_p                     (const_tree, const_tree);
6157 extern void maybe_add_class_template_decl_list  (tree, tree, int);
6158 extern void unreverse_member_declarations       (tree);
6159 extern void invalidate_class_lookup_cache       (void);
6160 extern void maybe_note_name_used_in_class       (tree, tree);
6161 extern void note_name_declared_in_class         (tree, tree);
6162 extern tree get_vtbl_decl_for_binfo             (tree);
6163 extern bool vptr_via_virtual_p                  (tree);
6164 extern void debug_class                         (tree);
6165 extern void debug_thunks                        (tree);
6166 extern void set_linkage_according_to_type       (tree, tree);
6167 extern void determine_key_method                (tree);
6168 extern void check_for_override                  (tree, tree);
6169 extern void push_class_stack                    (void);
6170 extern void pop_class_stack                     (void);
6171 extern bool default_ctor_p                      (tree);
6172 extern bool type_has_user_nondefault_constructor (tree);
6173 extern tree in_class_defaulted_default_constructor (tree);
6174 extern bool user_provided_p                     (tree);
6175 extern bool type_has_user_provided_constructor  (tree);
6176 extern bool type_has_non_user_provided_default_constructor (tree);
6177 extern bool vbase_has_user_provided_move_assign (tree);
6178 extern tree default_init_uninitialized_part (tree);
6179 extern bool trivial_default_constructor_is_constexpr (tree);
6180 extern bool type_has_constexpr_default_constructor (tree);
6181 extern bool type_has_virtual_destructor         (tree);
6182 extern bool classtype_has_move_assign_or_move_ctor_p (tree, bool user_declared);
6183 extern bool classtype_has_non_deleted_move_ctor (tree);
6184 extern bool type_build_ctor_call                (tree);
6185 extern bool type_build_dtor_call                (tree);
6186 extern void explain_non_literal_class           (tree);
6187 extern void inherit_targ_abi_tags               (tree);
6188 extern void defaulted_late_check                (tree);
6189 extern bool defaultable_fn_check                (tree);
6190 extern void check_abi_tags                      (tree);
6191 extern tree missing_abi_tags                    (tree);
6192 extern void fixup_type_variants                 (tree);
6193 extern void fixup_attribute_variants            (tree);
6194 extern tree* decl_cloned_function_p             (const_tree, bool);
6195 extern void clone_function_decl                 (tree, bool);
6196 extern void adjust_clone_args                   (tree);
6197 extern void deduce_noexcept_on_destructor       (tree);
6198 extern bool uniquely_derived_from_p             (tree, tree);
6199 extern bool publicly_uniquely_derived_p         (tree, tree);
6200 extern tree common_enclosing_class              (tree, tree);
6201
6202 /* in cvt.c */
6203 extern tree convert_to_reference                (tree, tree, int, int, tree,
6204                                                  tsubst_flags_t);
6205 extern tree convert_from_reference              (tree);
6206 extern tree force_rvalue                        (tree, tsubst_flags_t);
6207 extern tree ocp_convert                         (tree, tree, int, int,
6208                                                  tsubst_flags_t);
6209 extern tree cp_convert                          (tree, tree, tsubst_flags_t);
6210 extern tree cp_convert_and_check                (tree, tree, tsubst_flags_t);
6211 extern tree cp_fold_convert                     (tree, tree);
6212 extern tree cp_get_callee                       (tree);
6213 extern tree cp_get_callee_fndecl                (tree);
6214 extern tree cp_get_callee_fndecl_nofold         (tree);
6215 extern tree cp_get_fndecl_from_callee           (tree, bool fold = true);
6216 extern tree convert_to_void                     (tree, impl_conv_void,
6217                                                  tsubst_flags_t);
6218 extern tree convert_force                       (tree, tree, int,
6219                                                  tsubst_flags_t);
6220 extern tree build_expr_type_conversion          (int, tree, bool);
6221 extern tree type_promotes_to                    (tree);
6222 extern bool can_convert_qual                    (tree, tree);
6223 extern tree perform_qualification_conversions   (tree, tree);
6224 extern bool tx_safe_fn_type_p                   (tree);
6225 extern tree tx_unsafe_fn_variant                (tree);
6226 extern bool fnptr_conv_p                        (tree, tree);
6227 extern tree strip_fnptr_conv                    (tree);
6228
6229 /* in name-lookup.c */
6230 extern void maybe_push_cleanup_level            (tree);
6231 extern tree make_anon_name                      (void);
6232 extern tree check_for_out_of_scope_variable     (tree);
6233 extern void dump                                (cp_binding_level &ref);
6234 extern void dump                                (cp_binding_level *ptr);
6235 extern void print_other_binding_stack           (cp_binding_level *);
6236 extern tree maybe_push_decl                     (tree);
6237 extern tree current_decl_namespace              (void);
6238
6239 /* decl.c */
6240 extern tree poplevel                            (int, int, int);
6241 extern void cxx_init_decl_processing            (void);
6242 enum cp_tree_node_structure_enum cp_tree_node_structure
6243                                                 (union lang_tree_node *);
6244 extern void finish_scope                        (void);
6245 extern void push_switch                         (tree);
6246 extern void pop_switch                          (void);
6247 extern void note_break_stmt                     (void);
6248 extern bool note_iteration_stmt_body_start      (void);
6249 extern void note_iteration_stmt_body_end        (bool);
6250 extern tree make_lambda_name                    (void);
6251 extern int decls_match                          (tree, tree, bool = true);
6252 extern bool maybe_version_functions             (tree, tree, bool);
6253 extern tree duplicate_decls                     (tree, tree, bool);
6254 extern tree declare_local_label                 (tree);
6255 extern tree define_label                        (location_t, tree);
6256 extern void check_goto                          (tree);
6257 extern bool check_omp_return                    (void);
6258 extern tree make_typename_type                  (tree, tree, enum tag_types, tsubst_flags_t);
6259 extern tree build_typename_type                 (tree, tree, tree, tag_types);
6260 extern tree make_unbound_class_template         (tree, tree, tree, tsubst_flags_t);
6261 extern tree build_library_fn_ptr                (const char *, tree, int);
6262 extern tree build_cp_library_fn_ptr             (const char *, tree, int);
6263 extern tree push_library_fn                     (tree, tree, tree, int);
6264 extern tree push_void_library_fn                (tree, tree, int);
6265 extern tree push_throw_library_fn               (tree, tree);
6266 extern void warn_misplaced_attr_for_class_type  (source_location location,
6267                                                  tree class_type);
6268 extern tree check_tag_decl                      (cp_decl_specifier_seq *, bool);
6269 extern tree shadow_tag                          (cp_decl_specifier_seq *);
6270 extern tree groktypename                        (cp_decl_specifier_seq *, const cp_declarator *, bool);
6271 extern tree start_decl                          (const cp_declarator *, cp_decl_specifier_seq *, int, tree, tree, tree *);
6272 extern void start_decl_1                        (tree, bool);
6273 extern bool check_array_initializer             (tree, tree, tree);
6274 extern void cp_finish_decl                      (tree, tree, bool, tree, int);
6275 extern tree lookup_decomp_type                  (tree);
6276 extern void cp_maybe_mangle_decomp              (tree, tree, unsigned int);
6277 extern void cp_finish_decomp                    (tree, tree, unsigned int);
6278 extern int cp_complete_array_type               (tree *, tree, bool);
6279 extern int cp_complete_array_type_or_error      (tree *, tree, bool, tsubst_flags_t);
6280 extern tree build_ptrmemfunc_type               (tree);
6281 extern tree build_ptrmem_type                   (tree, tree);
6282 /* the grokdeclarator prototype is in decl.h */
6283 extern tree build_this_parm                     (tree, tree, cp_cv_quals);
6284 extern tree grokparms                           (tree, tree *);
6285 extern int copy_fn_p                            (const_tree);
6286 extern bool move_fn_p                           (const_tree);
6287 extern bool move_signature_fn_p                 (const_tree);
6288 extern tree get_scope_of_declarator             (const cp_declarator *);
6289 extern void grok_special_member_properties      (tree);
6290 extern bool grok_ctor_properties                (const_tree, const_tree);
6291 extern bool grok_op_properties                  (tree, bool);
6292 extern tree xref_tag                            (enum tag_types, tree, tag_scope, bool);
6293 extern tree xref_tag_from_type                  (tree, tree, tag_scope);
6294 extern void xref_basetypes                      (tree, tree);
6295 extern tree start_enum                          (tree, tree, tree, tree, bool, bool *);
6296 extern void finish_enum_value_list              (tree);
6297 extern void finish_enum                         (tree);
6298 extern void build_enumerator                    (tree, tree, tree, tree, location_t);
6299 extern tree lookup_enumerator                   (tree, tree);
6300 extern bool start_preparsed_function            (tree, tree, int);
6301 extern bool start_function                      (cp_decl_specifier_seq *,
6302                                                  const cp_declarator *, tree);
6303 extern tree begin_function_body                 (void);
6304 extern void finish_function_body                (tree);
6305 extern tree outer_curly_brace_block             (tree);
6306 extern tree finish_function                     (bool);
6307 extern tree grokmethod                          (cp_decl_specifier_seq *, const cp_declarator *, tree);
6308 extern void maybe_register_incomplete_var       (tree);
6309 extern void maybe_commonize_var                 (tree);
6310 extern void complete_vars                       (tree);
6311 extern tree static_fn_type                      (tree);
6312 extern void revert_static_member_fn             (tree);
6313 extern void fixup_anonymous_aggr                (tree);
6314 extern tree compute_array_index_type            (tree, tree, tsubst_flags_t);
6315 extern tree check_default_argument              (tree, tree, tsubst_flags_t);
6316 extern int wrapup_namespace_globals             ();
6317 extern tree create_implicit_typedef             (tree, tree);
6318 extern int local_variable_p                     (const_tree);
6319 extern tree register_dtor_fn                    (tree);
6320 extern tmpl_spec_kind current_tmpl_spec_kind    (int);
6321 extern tree cp_fname_init                       (const char *, tree *);
6322 extern tree cxx_builtin_function                (tree decl);
6323 extern tree cxx_builtin_function_ext_scope      (tree decl);
6324 extern tree check_elaborated_type_specifier     (enum tag_types, tree, bool);
6325 extern void warn_extern_redeclared_static       (tree, tree);
6326 extern tree cxx_comdat_group                    (tree);
6327 extern bool cp_missing_noreturn_ok_p            (tree);
6328 extern bool is_direct_enum_init                 (tree, tree);
6329 extern void initialize_artificial_var           (tree, vec<constructor_elt, va_gc> *);
6330 extern tree check_var_type                      (tree, tree);
6331 extern tree reshape_init                        (tree, tree, tsubst_flags_t);
6332 extern tree next_initializable_field (tree);
6333 extern tree fndecl_declared_return_type         (tree);
6334 extern bool undeduced_auto_decl                 (tree);
6335 extern bool require_deduced_type                (tree, tsubst_flags_t = tf_warning_or_error);
6336
6337 extern tree finish_case_label                   (location_t, tree, tree);
6338 extern tree cxx_maybe_build_cleanup             (tree, tsubst_flags_t);
6339 extern bool check_array_designated_initializer  (constructor_elt *,
6340                                                  unsigned HOST_WIDE_INT);
6341 extern bool check_for_uninitialized_const_var   (tree, bool, tsubst_flags_t);
6342
6343 /* in decl2.c */
6344 extern void record_mangling                     (tree, bool);
6345 extern void overwrite_mangling                  (tree, tree);
6346 extern void note_mangling_alias                 (tree, tree);
6347 extern void generate_mangling_aliases           (void);
6348 extern tree build_memfn_type                    (tree, tree, cp_cv_quals, cp_ref_qualifier);
6349 extern tree build_pointer_ptrmemfn_type (tree);
6350 extern tree change_return_type                  (tree, tree);
6351 extern void maybe_retrofit_in_chrg              (tree);
6352 extern void maybe_make_one_only                 (tree);
6353 extern bool vague_linkage_p                     (tree);
6354 extern void grokclassfn                         (tree, tree,
6355                                                  enum overload_flags);
6356 extern tree grok_array_decl                     (location_t, tree, tree, bool);
6357 extern tree delete_sanity                       (tree, tree, bool, int, tsubst_flags_t);
6358 extern tree check_classfn                       (tree, tree, tree);
6359 extern void check_member_template               (tree);
6360 extern tree grokfield (const cp_declarator *, cp_decl_specifier_seq *,
6361                        tree, bool, tree, tree);
6362 extern tree grokbitfield (const cp_declarator *, cp_decl_specifier_seq *,
6363                           tree, tree, tree);
6364 extern bool any_dependent_type_attributes_p     (tree);
6365 extern tree cp_reconstruct_complex_type         (tree, tree);
6366 extern bool attributes_naming_typedef_ok        (tree);
6367 extern void cplus_decl_attributes               (tree *, tree, int);
6368 extern void finish_anon_union                   (tree);
6369 extern void cxx_post_compilation_parsing_cleanups (void);
6370 extern tree coerce_new_type                     (tree);
6371 extern tree coerce_delete_type                  (tree);
6372 extern void comdat_linkage                      (tree);
6373 extern void determine_visibility                (tree);
6374 extern void constrain_class_visibility          (tree);
6375 extern void reset_type_linkage                  (tree);
6376 extern void tentative_decl_linkage              (tree);
6377 extern void import_export_decl                  (tree);
6378 extern tree build_cleanup                       (tree);
6379 extern tree build_offset_ref_call_from_tree     (tree, vec<tree, va_gc> **,
6380                                                  tsubst_flags_t);
6381 extern bool decl_defined_p                      (tree);
6382 extern bool decl_constant_var_p                 (tree);
6383 extern bool decl_maybe_constant_var_p           (tree);
6384 extern void no_linkage_error                    (tree);
6385 extern void check_default_args                  (tree);
6386 extern bool mark_used                           (tree);
6387 extern bool mark_used                           (tree, tsubst_flags_t);
6388 extern void finish_static_data_member_decl      (tree, tree, bool, tree, int);
6389 extern tree cp_build_parm_decl                  (tree, tree, tree);
6390 extern tree get_guard                           (tree);
6391 extern tree get_guard_cond                      (tree, bool);
6392 extern tree set_guard                           (tree);
6393 extern tree get_tls_wrapper_fn                  (tree);
6394 extern void mark_needed                         (tree);
6395 extern bool decl_needed_p                       (tree);
6396 extern void note_vague_linkage_fn               (tree);
6397 extern void note_variable_template_instantiation (tree);
6398 extern tree build_artificial_parm               (tree, tree, tree);
6399 extern bool possibly_inlined_p                  (tree);
6400 extern int parm_index                           (tree);
6401 extern tree vtv_start_verification_constructor_init_function (void);
6402 extern tree vtv_finish_verification_constructor_init_function (tree);
6403 extern bool cp_omp_mappable_type                (tree);
6404
6405 /* in error.c */
6406 extern const char *type_as_string               (tree, int);
6407 extern const char *type_as_string_translate     (tree, int);
6408 extern const char *decl_as_string               (tree, int);
6409 extern const char *decl_as_string_translate     (tree, int);
6410 extern const char *decl_as_dwarf_string         (tree, int);
6411 extern const char *expr_as_string               (tree, int);
6412 extern const char *lang_decl_name               (tree, int, bool);
6413 extern const char *lang_decl_dwarf_name         (tree, int, bool);
6414 extern const char *language_to_string           (enum languages);
6415 extern const char *class_key_or_enum_as_string  (tree);
6416 extern void maybe_warn_variadic_templates       (void);
6417 extern void maybe_warn_cpp0x                    (cpp0x_warn_str str);
6418 extern bool pedwarn_cxx98                       (location_t, int, const char *, ...) ATTRIBUTE_GCC_DIAG(3,4);
6419 extern location_t location_of                   (tree);
6420 extern void qualified_name_lookup_error         (tree, tree, tree,
6421                                                  location_t);
6422
6423 /* in except.c */
6424 extern void init_exception_processing           (void);
6425 extern tree expand_start_catch_block            (tree);
6426 extern void expand_end_catch_block              (void);
6427 extern tree build_exc_ptr                       (void);
6428 extern tree build_throw                         (tree);
6429 extern int nothrow_libfn_p                      (const_tree);
6430 extern void check_handlers                      (tree);
6431 extern tree finish_noexcept_expr                (tree, tsubst_flags_t);
6432 extern bool expr_noexcept_p                     (tree, tsubst_flags_t);
6433 extern void perform_deferred_noexcept_checks    (void);
6434 extern bool nothrow_spec_p                      (const_tree);
6435 extern bool type_noexcept_p                     (const_tree);
6436 extern bool type_throw_all_p                    (const_tree);
6437 extern tree build_noexcept_spec                 (tree, int);
6438 extern void choose_personality_routine          (enum languages);
6439 extern tree build_must_not_throw_expr           (tree,tree);
6440 extern tree eh_type_info                        (tree);
6441 extern tree begin_eh_spec_block                 (void);
6442 extern void finish_eh_spec_block                (tree, tree);
6443 extern tree build_eh_type_type                  (tree);
6444 extern tree cp_protect_cleanup_actions          (void);
6445 extern tree create_try_catch_expr               (tree, tree);
6446
6447 /* in expr.c */
6448 extern tree cplus_expand_constant               (tree);
6449 extern tree mark_use (tree expr, bool rvalue_p, bool read_p,
6450                       location_t = UNKNOWN_LOCATION,
6451                       bool reject_builtin = true);
6452 extern tree mark_rvalue_use                     (tree,
6453                                                  location_t = UNKNOWN_LOCATION,
6454                                                  bool reject_builtin = true);
6455 extern tree mark_lvalue_use                     (tree);
6456 extern tree mark_lvalue_use_nonread             (tree);
6457 extern tree mark_type_use                       (tree);
6458 extern tree mark_discarded_use                  (tree);
6459 extern void mark_exp_read                       (tree);
6460
6461 /* friend.c */
6462 extern int is_friend                            (tree, tree);
6463 extern void make_friend_class                   (tree, tree, bool);
6464 extern void add_friend                          (tree, tree, bool);
6465 extern tree do_friend                           (tree, tree, tree, tree,
6466                                                  enum overload_flags, bool);
6467
6468 extern void set_global_friend                   (tree);
6469 extern bool is_global_friend                    (tree);
6470
6471 /* in init.c */
6472 extern tree expand_member_init                  (tree);
6473 extern void emit_mem_initializers               (tree);
6474 extern tree build_aggr_init                     (tree, tree, int,
6475                                                  tsubst_flags_t);
6476 extern int is_class_type                        (tree, int);
6477 extern tree get_type_value                      (tree);
6478 extern tree build_zero_init                     (tree, tree, bool);
6479 extern tree build_value_init                    (tree, tsubst_flags_t);
6480 extern tree build_value_init_noctor             (tree, tsubst_flags_t);
6481 extern tree get_nsdmi                           (tree, bool, tsubst_flags_t);
6482 extern tree build_offset_ref                    (tree, tree, bool,
6483                                                  tsubst_flags_t);
6484 extern tree throw_bad_array_new_length          (void);
6485 extern bool type_has_new_extended_alignment     (tree);
6486 extern unsigned malloc_alignment                (void);
6487 extern tree build_new                           (vec<tree, va_gc> **, tree, tree,
6488                                                  vec<tree, va_gc> **, int,
6489                                                  tsubst_flags_t);
6490 extern tree get_temp_regvar                     (tree, tree);
6491 extern tree build_vec_init                      (tree, tree, tree, bool, int,
6492                                                  tsubst_flags_t);
6493 extern tree build_delete                        (tree, tree,
6494                                                  special_function_kind,
6495                                                  int, int, tsubst_flags_t);
6496 extern void push_base_cleanups                  (void);
6497 extern tree build_vec_delete                    (tree, tree,
6498                                                  special_function_kind, int,
6499                                                  tsubst_flags_t);
6500 extern tree create_temporary_var                (tree);
6501 extern void initialize_vtbl_ptrs                (tree);
6502 extern tree scalar_constant_value               (tree);
6503 extern tree decl_really_constant_value          (tree);
6504 extern int diagnose_uninitialized_cst_or_ref_member (tree, bool, bool);
6505 extern tree build_vtbl_address                  (tree);
6506 extern bool maybe_reject_flexarray_init         (tree, tree);
6507
6508 /* in lex.c */
6509 extern void cxx_dup_lang_specific_decl          (tree);
6510 extern void yyungetc                            (int, int);
6511
6512 extern tree unqualified_name_lookup_error       (tree,
6513                                                  location_t = UNKNOWN_LOCATION);
6514 extern tree unqualified_fn_lookup_error         (cp_expr);
6515 extern tree make_conv_op_name                   (tree);
6516 extern tree build_lang_decl                     (enum tree_code, tree, tree);
6517 extern tree build_lang_decl_loc                 (location_t, enum tree_code, tree, tree);
6518 extern void retrofit_lang_decl                  (tree);
6519 extern void fit_decomposition_lang_decl         (tree, tree);
6520 extern tree copy_decl                           (tree CXX_MEM_STAT_INFO);
6521 extern tree copy_type                           (tree CXX_MEM_STAT_INFO);
6522 extern tree cxx_make_type                       (enum tree_code);
6523 extern tree make_class_type                     (enum tree_code);
6524 extern const char *get_identifier_kind_name     (tree);
6525 extern void set_identifier_kind                 (tree, cp_identifier_kind);
6526 extern bool cxx_init                            (void);
6527 extern void cxx_finish                          (void);
6528 extern bool in_main_input_context               (void);
6529
6530 /* in method.c */
6531 extern void init_method                         (void);
6532 extern tree make_thunk                          (tree, bool, tree, tree);
6533 extern void finish_thunk                        (tree);
6534 extern void use_thunk                           (tree, bool);
6535 extern bool trivial_fn_p                        (tree);
6536 extern tree forward_parm                        (tree);
6537 extern bool is_trivially_xible                  (enum tree_code, tree, tree);
6538 extern bool is_xible                            (enum tree_code, tree, tree);
6539 extern tree get_defaulted_eh_spec               (tree, tsubst_flags_t = tf_warning_or_error);
6540 extern void after_nsdmi_defaulted_late_checks   (tree);
6541 extern bool maybe_explain_implicit_delete       (tree);
6542 extern void explain_implicit_non_constexpr      (tree);
6543 extern void deduce_inheriting_ctor              (tree);
6544 extern void synthesize_method                   (tree);
6545 extern tree lazily_declare_fn                   (special_function_kind,
6546                                                  tree);
6547 extern tree skip_artificial_parms_for           (const_tree, tree);
6548 extern int num_artificial_parms_for             (const_tree);
6549 extern tree make_alias_for                      (tree, tree);
6550 extern tree get_copy_ctor                       (tree, tsubst_flags_t);
6551 extern tree get_copy_assign                     (tree);
6552 extern tree get_default_ctor                    (tree);
6553 extern tree get_dtor                            (tree, tsubst_flags_t);
6554 extern tree strip_inheriting_ctors              (tree);
6555 extern tree inherited_ctor_binfo                (tree);
6556 extern bool ctor_omit_inherited_parms           (tree);
6557 extern tree locate_ctor                         (tree);
6558 extern tree implicitly_declare_fn               (special_function_kind, tree,
6559                                                  bool, tree, tree);
6560
6561 /* In optimize.c */
6562 extern bool maybe_clone_body                    (tree);
6563
6564 /* In parser.c */
6565 extern tree cp_convert_range_for (tree, tree, tree, tree, unsigned int, bool,
6566                                   unsigned short);
6567 extern bool parsing_nsdmi (void);
6568 extern bool parsing_default_capturing_generic_lambda_in_template (void);
6569 extern void inject_this_parameter (tree, cp_cv_quals);
6570 extern location_t defarg_location (tree);
6571 extern void maybe_show_extern_c_location (void);
6572
6573 /* in pt.c */
6574 extern bool check_template_shadow               (tree);
6575 extern bool check_auto_in_tmpl_args             (tree, tree);
6576 extern tree get_innermost_template_args         (tree, int);
6577 extern void maybe_begin_member_template_processing (tree);
6578 extern void maybe_end_member_template_processing (void);
6579 extern tree finish_member_template_decl         (tree);
6580 extern void begin_template_parm_list            (void);
6581 extern bool begin_specialization                (void);
6582 extern void reset_specialization                (void);
6583 extern void end_specialization                  (void);
6584 extern void begin_explicit_instantiation        (void);
6585 extern void end_explicit_instantiation          (void);
6586 extern void check_unqualified_spec_or_inst      (tree, location_t);
6587 extern tree check_explicit_specialization       (tree, tree, int, int,
6588                                                  tree = NULL_TREE);
6589 extern int num_template_headers_for_class       (tree);
6590 extern void check_template_variable             (tree);
6591 extern tree make_auto                           (void);
6592 extern tree make_decltype_auto                  (void);
6593 extern tree make_template_placeholder           (tree);
6594 extern bool template_placeholder_p              (tree);
6595 extern tree do_auto_deduction                   (tree, tree, tree,
6596                                                  tsubst_flags_t
6597                                                  = tf_warning_or_error,
6598                                                  auto_deduction_context
6599                                                  = adc_unspecified,
6600                                                  tree = NULL_TREE,
6601                                                  int = LOOKUP_NORMAL);
6602 extern tree type_uses_auto                      (tree);
6603 extern tree type_uses_auto_or_concept           (tree);
6604 extern void append_type_to_template_for_access_check (tree, tree, tree,
6605                                                       location_t);
6606 extern tree convert_generic_types_to_packs      (tree, int, int);
6607 extern tree splice_late_return_type             (tree, tree);
6608 extern bool is_auto                             (const_tree);
6609 extern tree process_template_parm               (tree, location_t, tree,
6610                                                  bool, bool);
6611 extern tree end_template_parm_list              (tree);
6612 extern void end_template_parm_list              (void);
6613 extern void end_template_decl                   (void);
6614 extern tree maybe_update_decl_type              (tree, tree);
6615 extern bool check_default_tmpl_args             (tree, tree, bool, bool, int);
6616 extern tree push_template_decl                  (tree);
6617 extern tree push_template_decl_real             (tree, bool);
6618 extern tree add_inherited_template_parms        (tree, tree);
6619 extern bool redeclare_class_template            (tree, tree, tree);
6620 extern tree lookup_template_class               (tree, tree, tree, tree,
6621                                                  int, tsubst_flags_t);
6622 extern tree lookup_template_function            (tree, tree);
6623 extern tree lookup_template_variable            (tree, tree);
6624 extern int uses_template_parms                  (tree);
6625 extern bool uses_template_parms_level           (tree, int);
6626 extern bool in_template_function                (void);
6627 extern bool need_generic_capture                (void);
6628 extern tree instantiate_class_template          (tree);
6629 extern tree instantiate_template                (tree, tree, tsubst_flags_t);
6630 extern tree fn_type_unification                 (tree, tree, tree,
6631                                                  const tree *, unsigned int,
6632                                                  tree, unification_kind_t, int,
6633                                                  bool, bool);
6634 extern void mark_decl_instantiated              (tree, int);
6635 extern int more_specialized_fn                  (tree, tree, int);
6636 extern void do_decl_instantiation               (tree, tree);
6637 extern void do_type_instantiation               (tree, tree, tsubst_flags_t);
6638 extern bool always_instantiate_p                (tree);
6639 extern bool maybe_instantiate_noexcept          (tree, tsubst_flags_t = tf_warning_or_error);
6640 extern tree instantiate_decl                    (tree, bool, bool);
6641 extern int comp_template_parms                  (const_tree, const_tree);
6642 extern bool builtin_pack_fn_p                   (tree);
6643 extern bool uses_parameter_packs                (tree);
6644 extern bool template_parameter_pack_p           (const_tree);
6645 extern bool function_parameter_pack_p           (const_tree);
6646 extern bool function_parameter_expanded_from_pack_p (tree, tree);
6647 extern tree make_pack_expansion                 (tree, tsubst_flags_t = tf_warning_or_error);
6648 extern bool check_for_bare_parameter_packs      (tree, location_t = UNKNOWN_LOCATION);
6649 extern tree build_template_info                 (tree, tree);
6650 extern tree get_template_info                   (const_tree);
6651 extern vec<qualified_typedef_usage_t, va_gc> *get_types_needing_access_check (tree);
6652 extern int template_class_depth                 (tree);
6653 extern int is_specialization_of                 (tree, tree);
6654 extern bool is_specialization_of_friend         (tree, tree);
6655 extern tree get_pattern_parm                    (tree, tree);
6656 extern int comp_template_args                   (tree, tree, tree * = NULL,
6657                                                  tree * = NULL, bool = false);
6658 extern int template_args_equal                  (tree, tree, bool = false);
6659 extern tree maybe_process_partial_specialization (tree);
6660 extern tree most_specialized_instantiation      (tree);
6661 extern void print_candidates                    (tree);
6662 extern void instantiate_pending_templates       (int);
6663 extern tree tsubst_default_argument             (tree, int, tree, tree,
6664                                                  tsubst_flags_t);
6665 extern tree tsubst (tree, tree, tsubst_flags_t, tree);
6666 extern tree tsubst_copy_and_build               (tree, tree, tsubst_flags_t,
6667                                                  tree, bool, bool);
6668 extern tree tsubst_expr                         (tree, tree, tsubst_flags_t,
6669                                                  tree, bool);
6670 extern tree tsubst_pack_expansion               (tree, tree, tsubst_flags_t, tree);
6671 extern tree most_general_template               (tree);
6672 extern tree get_mostly_instantiated_function_type (tree);
6673 extern bool problematic_instantiation_changed   (void);
6674 extern void record_last_problematic_instantiation (void);
6675 extern struct tinst_level *current_instantiation(void);
6676 extern bool instantiating_current_function_p    (void);
6677 extern tree maybe_get_template_decl_from_type_decl (tree);
6678 extern int processing_template_parmlist;
6679 extern bool dependent_type_p                    (tree);
6680 extern bool dependent_scope_p                   (tree);
6681 extern bool any_dependent_template_arguments_p  (const_tree);
6682 extern bool any_erroneous_template_args_p       (const_tree);
6683 extern bool dependent_template_p                (tree);
6684 extern bool dependent_template_id_p             (tree, tree);
6685 extern bool type_dependent_expression_p         (tree);
6686 extern bool type_dependent_object_expression_p  (tree);
6687 extern bool any_type_dependent_arguments_p      (const vec<tree, va_gc> *);
6688 extern bool any_type_dependent_elements_p       (const_tree);
6689 extern bool type_dependent_expression_p_push    (tree);
6690 extern bool value_dependent_expression_p        (tree);
6691 extern bool instantiation_dependent_expression_p (tree);
6692 extern bool instantiation_dependent_uneval_expression_p (tree);
6693 extern bool any_value_dependent_elements_p      (const_tree);
6694 extern bool dependent_omp_for_p                 (tree, tree, tree, tree);
6695 extern tree resolve_typename_type               (tree, bool);
6696 extern tree template_for_substitution           (tree);
6697 extern tree build_non_dependent_expr            (tree);
6698 extern void make_args_non_dependent             (vec<tree, va_gc> *);
6699 extern bool reregister_specialization           (tree, tree, tree);
6700 extern tree instantiate_non_dependent_expr      (tree);
6701 extern tree instantiate_non_dependent_expr_sfinae (tree, tsubst_flags_t);
6702 extern tree instantiate_non_dependent_expr_internal (tree, tsubst_flags_t);
6703 extern tree instantiate_non_dependent_or_null   (tree);
6704 extern bool variable_template_specialization_p  (tree);
6705 extern bool alias_type_or_template_p            (tree);
6706 extern bool alias_template_specialization_p     (const_tree);
6707 extern bool dependent_alias_template_spec_p     (const_tree);
6708 extern bool explicit_class_specialization_p     (tree);
6709 extern bool push_tinst_level                    (tree);
6710 extern bool push_tinst_level_loc                (tree, location_t);
6711 extern void pop_tinst_level                     (void);
6712 extern struct tinst_level *outermost_tinst_level(void);
6713 extern void init_template_processing            (void);
6714 extern void print_template_statistics           (void);
6715 bool template_template_parameter_p              (const_tree);
6716 bool template_type_parameter_p                  (const_tree);
6717 extern bool primary_template_specialization_p   (const_tree);
6718 extern tree get_primary_template_innermost_parameters   (const_tree);
6719 extern tree get_template_parms_at_level (tree, int);
6720 extern tree get_template_innermost_arguments    (const_tree);
6721 extern tree get_template_argument_pack_elems    (const_tree);
6722 extern tree get_function_template_decl          (const_tree);
6723 extern tree resolve_nondeduced_context          (tree, tsubst_flags_t);
6724 extern hashval_t iterative_hash_template_arg (tree arg, hashval_t val);
6725 extern tree coerce_template_parms               (tree, tree, tree);
6726 extern tree coerce_template_parms               (tree, tree, tree, tsubst_flags_t);
6727 extern void register_local_specialization       (tree, tree);
6728 extern tree retrieve_local_specialization       (tree);
6729 extern tree extract_fnparm_pack                 (tree, tree *);
6730 extern tree template_parm_to_arg                (tree);
6731 extern tree dguide_name                         (tree);
6732 extern bool dguide_name_p                       (tree);
6733 extern bool deduction_guide_p                   (const_tree);
6734 extern bool copy_guide_p                        (const_tree);
6735 extern bool template_guide_p                    (const_tree);
6736
6737 /* in repo.c */
6738 extern void init_repo                           (void);
6739 extern int repo_emit_p                          (tree);
6740 extern bool repo_export_class_p                 (const_tree);
6741 extern void finish_repo                         (void);
6742
6743 /* in rtti.c */
6744 /* A vector of all tinfo decls that haven't been emitted yet.  */
6745 extern GTY(()) vec<tree, va_gc> *unemitted_tinfo_decls;
6746
6747 extern void init_rtti_processing                (void);
6748 extern tree build_typeid                        (tree, tsubst_flags_t);
6749 extern tree get_tinfo_decl                      (tree);
6750 extern tree get_typeid                          (tree, tsubst_flags_t);
6751 extern tree build_headof                        (tree);
6752 extern tree build_dynamic_cast                  (tree, tree, tsubst_flags_t);
6753 extern void emit_support_tinfos                 (void);
6754 extern bool emit_tinfo_decl                     (tree);
6755
6756 /* in search.c */
6757 extern bool accessible_base_p                   (tree, tree, bool);
6758 extern tree lookup_base                         (tree, tree, base_access,
6759                                                  base_kind *, tsubst_flags_t);
6760 extern tree dcast_base_hint                     (tree, tree);
6761 extern int accessible_p                         (tree, tree, bool);
6762 extern int accessible_in_template_p             (tree, tree);
6763 extern tree lookup_field                        (tree, tree, int, bool);
6764 extern tree lookup_fnfields                     (tree, tree, int);
6765 extern tree lookup_member                       (tree, tree, int, bool,
6766                                                  tsubst_flags_t,
6767                                                  access_failure_info *afi = NULL);
6768 extern tree lookup_member_fuzzy         (tree, tree, bool);
6769 extern tree locate_field_accessor               (tree, tree, bool);
6770 extern int look_for_overrides                   (tree, tree);
6771 extern void get_pure_virtuals                   (tree);
6772 extern void maybe_suppress_debug_info           (tree);
6773 extern void note_debug_info_needed              (tree);
6774 extern tree current_scope                       (void);
6775 extern int at_function_scope_p                  (void);
6776 extern bool at_class_scope_p                    (void);
6777 extern bool at_namespace_scope_p                (void);
6778 extern tree context_for_name_lookup             (tree);
6779 extern tree lookup_conversions                  (tree);
6780 extern tree binfo_from_vbase                    (tree);
6781 extern tree binfo_for_vbase                     (tree, tree);
6782 extern tree look_for_overrides_here             (tree, tree);
6783 #define dfs_skip_bases ((tree)1)
6784 extern tree dfs_walk_all (tree, tree (*) (tree, void *),
6785                           tree (*) (tree, void *), void *);
6786 extern tree dfs_walk_once (tree, tree (*) (tree, void *),
6787                            tree (*) (tree, void *), void *);
6788 extern tree binfo_via_virtual                   (tree, tree);
6789 extern bool binfo_direct_p                      (tree);
6790 extern tree build_baselink                      (tree, tree, tree, tree);
6791 extern tree adjust_result_of_qualified_name_lookup
6792                                                 (tree, tree, tree);
6793 extern tree copied_binfo                        (tree, tree);
6794 extern tree original_binfo                      (tree, tree);
6795 extern int shared_member_p                      (tree);
6796 extern bool any_dependent_bases_p (tree = current_nonlambda_class_type ());
6797
6798 /* The representation of a deferred access check.  */
6799
6800 struct GTY(()) deferred_access_check {
6801   /* The base class in which the declaration is referenced. */
6802   tree binfo;
6803   /* The declaration whose access must be checked.  */
6804   tree decl;
6805   /* The declaration that should be used in the error message.  */
6806   tree diag_decl;
6807   /* The location of this access.  */
6808   location_t loc;
6809 };
6810
6811 /* in semantics.c */
6812 extern void push_deferring_access_checks        (deferring_kind);
6813 extern void resume_deferring_access_checks      (void);
6814 extern void stop_deferring_access_checks        (void);
6815 extern void pop_deferring_access_checks         (void);
6816 extern vec<deferred_access_check, va_gc> *get_deferred_access_checks (void);
6817 extern void reopen_deferring_access_checks (vec<deferred_access_check, va_gc> *);
6818 extern void pop_to_parent_deferring_access_checks (void);
6819 extern bool perform_access_checks (vec<deferred_access_check, va_gc> *,
6820                                    tsubst_flags_t);
6821 extern bool perform_deferred_access_checks      (tsubst_flags_t);
6822 extern bool perform_or_defer_access_check       (tree, tree, tree,
6823                                                  tsubst_flags_t,
6824                                                  access_failure_info *afi = NULL);
6825
6826 /* RAII sentinel to ensures that deferred access checks are popped before
6827   a function returns.  */
6828
6829 struct deferring_access_check_sentinel
6830 {
6831   deferring_access_check_sentinel (enum deferring_kind kind = dk_deferred)
6832   {
6833     push_deferring_access_checks (kind);
6834   }
6835   ~deferring_access_check_sentinel ()
6836   {
6837     pop_deferring_access_checks ();
6838   }
6839 };
6840
6841 extern int stmts_are_full_exprs_p               (void);
6842 extern void init_cp_semantics                   (void);
6843 extern tree do_poplevel                         (tree);
6844 extern void break_maybe_infinite_loop           (void);
6845 extern void add_decl_expr                       (tree);
6846 extern tree maybe_cleanup_point_expr_void       (tree);
6847 extern tree finish_expr_stmt                    (tree);
6848 extern tree begin_if_stmt                       (void);
6849 extern tree finish_if_stmt_cond                 (tree, tree);
6850 extern tree finish_then_clause                  (tree);
6851 extern void begin_else_clause                   (tree);
6852 extern void finish_else_clause                  (tree);
6853 extern void finish_if_stmt                      (tree);
6854 extern tree begin_while_stmt                    (void);
6855 extern void finish_while_stmt_cond      (tree, tree, bool, unsigned short);
6856 extern void finish_while_stmt                   (tree);
6857 extern tree begin_do_stmt                       (void);
6858 extern void finish_do_body                      (tree);
6859 extern void finish_do_stmt              (tree, tree, bool, unsigned short);
6860 extern tree finish_return_stmt                  (tree);
6861 extern tree begin_for_scope                     (tree *);
6862 extern tree begin_for_stmt                      (tree, tree);
6863 extern void finish_init_stmt                    (tree);
6864 extern void finish_for_cond             (tree, tree, bool, unsigned short);
6865 extern void finish_for_expr                     (tree, tree);
6866 extern void finish_for_stmt                     (tree);
6867 extern tree begin_range_for_stmt                (tree, tree);
6868 extern void finish_range_for_decl               (tree, tree, tree);
6869 extern void finish_range_for_stmt               (tree);
6870 extern tree finish_break_stmt                   (void);
6871 extern tree finish_continue_stmt                (void);
6872 extern tree begin_switch_stmt                   (void);
6873 extern void finish_switch_cond                  (tree, tree);
6874 extern void finish_switch_stmt                  (tree);
6875 extern tree finish_goto_stmt                    (tree);
6876 extern tree begin_try_block                     (void);
6877 extern void finish_try_block                    (tree);
6878 extern void finish_handler_sequence             (tree);
6879 extern tree begin_function_try_block            (tree *);
6880 extern void finish_function_try_block           (tree);
6881 extern void finish_function_handler_sequence    (tree, tree);
6882 extern void finish_cleanup_try_block            (tree);
6883 extern tree begin_handler                       (void);
6884 extern void finish_handler_parms                (tree, tree);
6885 extern void finish_handler                      (tree);
6886 extern void finish_cleanup                      (tree, tree);
6887 extern bool is_this_parameter                   (tree);
6888
6889 enum {
6890   BCS_NORMAL = 0,
6891   BCS_NO_SCOPE = 1,
6892   BCS_TRY_BLOCK = 2,
6893   BCS_FN_BODY = 4,
6894   BCS_TRANSACTION = 8
6895 };
6896 extern tree begin_compound_stmt                 (unsigned int);
6897
6898 extern void finish_compound_stmt                (tree);
6899 extern tree finish_asm_stmt                     (int, tree, tree, tree, tree,
6900                                                  tree, bool);
6901 extern tree finish_label_stmt                   (tree);
6902 extern void finish_label_decl                   (tree);
6903 extern cp_expr finish_parenthesized_expr        (cp_expr);
6904 extern tree force_paren_expr                    (tree);
6905 extern tree maybe_undo_parenthesized_ref        (tree);
6906 extern tree finish_non_static_data_member       (tree, tree, tree);
6907 extern tree begin_stmt_expr                     (void);
6908 extern tree finish_stmt_expr_expr               (tree, tree);
6909 extern tree finish_stmt_expr                    (tree, bool);
6910 extern tree stmt_expr_value_expr                (tree);
6911 bool empty_expr_stmt_p                          (tree);
6912 extern cp_expr perform_koenig_lookup            (cp_expr, vec<tree, va_gc> *,
6913                                                  tsubst_flags_t);
6914 extern tree finish_call_expr                    (tree, vec<tree, va_gc> **, bool,
6915                                                  bool, tsubst_flags_t);
6916 extern tree lookup_and_finish_template_variable (tree, tree, tsubst_flags_t = tf_warning_or_error);
6917 extern tree finish_template_variable            (tree, tsubst_flags_t = tf_warning_or_error);
6918 extern cp_expr finish_increment_expr            (cp_expr, enum tree_code);
6919 extern tree finish_this_expr                    (void);
6920 extern tree finish_pseudo_destructor_expr       (tree, tree, tree, location_t);
6921 extern cp_expr finish_unary_op_expr             (location_t, enum tree_code, cp_expr,
6922                                                  tsubst_flags_t);
6923 /* Whether this call to finish_compound_literal represents a C++11 functional
6924    cast or a C99 compound literal.  */
6925 enum fcl_t { fcl_functional, fcl_c99 };
6926 extern tree finish_compound_literal             (tree, tree, tsubst_flags_t, fcl_t = fcl_functional);
6927 extern tree finish_fname                        (tree);
6928 extern void finish_translation_unit             (void);
6929 extern tree finish_template_type_parm           (tree, tree);
6930 extern tree finish_template_template_parm       (tree, tree);
6931 extern tree begin_class_definition              (tree);
6932 extern void finish_template_decl                (tree);
6933 extern tree finish_template_type                (tree, tree, int);
6934 extern tree finish_base_specifier               (tree, tree, bool);
6935 extern void finish_member_declaration           (tree);
6936 extern bool outer_automatic_var_p               (tree);
6937 extern tree process_outer_var_ref               (tree, tsubst_flags_t, bool force_use = false);
6938 extern cp_expr finish_id_expression             (tree, tree, tree,
6939                                                  cp_id_kind *,
6940                                                  bool, bool, bool *,
6941                                                  bool, bool, bool, bool,
6942                                                  const char **,
6943                                                  location_t);
6944 extern tree finish_typeof                       (tree);
6945 extern tree finish_underlying_type              (tree);
6946 extern tree calculate_bases                     (tree, tsubst_flags_t);
6947 extern tree finish_bases                        (tree, bool);
6948 extern tree calculate_direct_bases              (tree, tsubst_flags_t);
6949 extern tree finish_offsetof                     (tree, tree, location_t);
6950 extern void finish_decl_cleanup                 (tree, tree);
6951 extern void finish_eh_cleanup                   (tree);
6952 extern void emit_associated_thunks              (tree);
6953 extern void finish_mem_initializers             (tree);
6954 extern tree check_template_template_default_arg (tree);
6955 extern bool expand_or_defer_fn_1                (tree);
6956 extern void expand_or_defer_fn                  (tree);
6957 extern void add_typedef_to_current_template_for_access_check (tree, tree,
6958                                                               location_t);
6959 extern void check_accessibility_of_qualified_id (tree, tree, tree);
6960 extern tree finish_qualified_id_expr            (tree, tree, bool, bool,
6961                                                  bool, bool, tsubst_flags_t);
6962 extern void simplify_aggr_init_expr             (tree *);
6963 extern void finalize_nrv                        (tree *, tree, tree);
6964 extern tree omp_reduction_id                    (enum tree_code, tree, tree);
6965 extern tree cp_remove_omp_priv_cleanup_stmt     (tree *, int *, void *);
6966 extern void cp_check_omp_declare_reduction      (tree);
6967 extern void finish_omp_declare_simd_methods     (tree);
6968 extern tree finish_omp_clauses                  (tree, enum c_omp_region_type);
6969 extern tree push_omp_privatization_clauses      (bool);
6970 extern void pop_omp_privatization_clauses       (tree);
6971 extern void save_omp_privatization_clauses      (vec<tree> &);
6972 extern void restore_omp_privatization_clauses   (vec<tree> &);
6973 extern void finish_omp_threadprivate            (tree);
6974 extern tree begin_omp_structured_block          (void);
6975 extern tree finish_omp_structured_block         (tree);
6976 extern tree finish_oacc_data                    (tree, tree);
6977 extern tree finish_oacc_host_data               (tree, tree);
6978 extern tree finish_omp_construct                (enum tree_code, tree, tree);
6979 extern tree begin_omp_parallel                  (void);
6980 extern tree finish_omp_parallel                 (tree, tree);
6981 extern tree begin_omp_task                      (void);
6982 extern tree finish_omp_task                     (tree, tree);
6983 extern tree finish_omp_for                      (location_t, enum tree_code,
6984                                                  tree, tree, tree, tree, tree,
6985                                                  tree, tree, vec<tree> *, tree);
6986 extern void finish_omp_atomic                   (enum tree_code, enum tree_code,
6987                                                  tree, tree, tree, tree, tree,
6988                                                  bool);
6989 extern void finish_omp_barrier                  (void);
6990 extern void finish_omp_flush                    (void);
6991 extern void finish_omp_taskwait                 (void);
6992 extern void finish_omp_taskyield                (void);
6993 extern void finish_omp_cancel                   (tree);
6994 extern void finish_omp_cancellation_point       (tree);
6995 extern tree omp_privatize_field                 (tree, bool);
6996 extern tree begin_transaction_stmt              (location_t, tree *, int);
6997 extern void finish_transaction_stmt             (tree, tree, int, tree);
6998 extern tree build_transaction_expr              (location_t, tree, int, tree);
6999 extern bool cxx_omp_create_clause_info          (tree, tree, bool, bool,
7000                                                  bool, bool);
7001 extern tree baselink_for_fns                    (tree);
7002 extern void finish_static_assert                (tree, tree, location_t,
7003                                                  bool);
7004 extern tree finish_decltype_type                (tree, bool, tsubst_flags_t);
7005 extern tree finish_trait_expr                   (enum cp_trait_kind, tree, tree);
7006 extern tree build_lambda_expr                   (void);
7007 extern tree build_lambda_object                 (tree);
7008 extern tree begin_lambda_type                   (tree);
7009 extern tree lambda_capture_field_type           (tree, bool, bool);
7010 extern tree lambda_return_type                  (tree);
7011 extern tree lambda_proxy_type                   (tree);
7012 extern tree lambda_function                     (tree);
7013 extern void apply_deduced_return_type           (tree, tree);
7014 extern tree add_capture                         (tree, tree, tree, bool, bool);
7015 extern tree add_default_capture                 (tree, tree, tree);
7016 extern void insert_capture_proxy                (tree);
7017 extern void insert_pending_capture_proxies      (void);
7018 extern bool is_capture_proxy                    (tree);
7019 extern bool is_normal_capture_proxy             (tree);
7020 extern bool is_constant_capture_proxy           (tree);
7021 extern void register_capture_members            (tree);
7022 extern tree lambda_expr_this_capture            (tree, bool);
7023 extern void maybe_generic_this_capture          (tree, tree);
7024 extern tree maybe_resolve_dummy                 (tree, bool);
7025 extern tree current_nonlambda_function          (void);
7026 extern tree nonlambda_method_basetype           (void);
7027 extern tree current_nonlambda_scope             (void);
7028 extern tree current_lambda_expr                 (void);
7029 extern bool generic_lambda_fn_p                 (tree);
7030 extern tree do_dependent_capture                (tree, bool = false);
7031 extern bool lambda_fn_in_template_p             (tree);
7032 extern void maybe_add_lambda_conv_op            (tree);
7033 extern bool is_lambda_ignored_entity            (tree);
7034 extern bool lambda_static_thunk_p               (tree);
7035 extern tree finish_builtin_launder              (location_t, tree,
7036                                                  tsubst_flags_t);
7037 extern void start_lambda_scope                  (tree);
7038 extern void record_lambda_scope                 (tree);
7039 extern void record_null_lambda_scope            (tree);
7040 extern void finish_lambda_scope                 (void);
7041 extern tree start_lambda_function               (tree fn, tree lambda_expr);
7042 extern void finish_lambda_function              (tree body);
7043
7044 /* in tree.c */
7045 extern int cp_tree_operand_length               (const_tree);
7046 extern int cp_tree_code_length                  (enum tree_code);
7047 extern void cp_free_lang_data                   (tree t);
7048 extern tree force_target_expr                   (tree, tree, tsubst_flags_t);
7049 extern tree build_target_expr_with_type         (tree, tree, tsubst_flags_t);
7050 extern void lang_check_failed                   (const char *, int,
7051                                                  const char *) ATTRIBUTE_NORETURN
7052                                                  ATTRIBUTE_COLD;
7053 extern tree stabilize_expr                      (tree, tree *);
7054 extern void stabilize_call                      (tree, tree *);
7055 extern bool stabilize_init                      (tree, tree *);
7056 extern tree add_stmt_to_compound                (tree, tree);
7057 extern void init_tree                           (void);
7058 extern bool pod_type_p                          (const_tree);
7059 extern bool layout_pod_type_p                   (const_tree);
7060 extern bool std_layout_type_p                   (const_tree);
7061 extern bool trivial_type_p                      (const_tree);
7062 extern bool trivially_copyable_p                (const_tree);
7063 extern bool type_has_unique_obj_representations (const_tree);
7064 extern bool scalarish_type_p                    (const_tree);
7065 extern bool type_has_nontrivial_default_init    (const_tree);
7066 extern bool type_has_nontrivial_copy_init       (const_tree);
7067 extern void maybe_warn_parm_abi                 (tree, location_t);
7068 extern bool class_tmpl_impl_spec_p              (const_tree);
7069 extern int zero_init_p                          (const_tree);
7070 extern bool check_abi_tag_redeclaration         (const_tree, const_tree,
7071                                                  const_tree);
7072 extern bool check_abi_tag_args                  (tree, tree);
7073 extern tree strip_typedefs                      (tree, bool * = NULL);
7074 extern tree strip_typedefs_expr                 (tree, bool * = NULL);
7075 extern tree copy_binfo                          (tree, tree, tree,
7076                                                  tree *, int);
7077 extern int member_p                             (const_tree);
7078 extern cp_lvalue_kind real_lvalue_p             (const_tree);
7079 extern cp_lvalue_kind lvalue_kind               (const_tree);
7080 extern bool glvalue_p                           (const_tree);
7081 extern bool obvalue_p                           (const_tree);
7082 extern bool xvalue_p                            (const_tree);
7083 extern bool bitfield_p                          (const_tree);
7084 extern tree cp_stabilize_reference              (tree);
7085 extern bool builtin_valid_in_constant_expr_p    (const_tree);
7086 extern tree build_min                           (enum tree_code, tree, ...);
7087 extern tree build_min_nt_loc                    (location_t, enum tree_code,
7088                                                  ...);
7089 extern tree build_min_non_dep                   (enum tree_code, tree, ...);
7090 extern tree build_min_non_dep_op_overload       (enum tree_code, tree, tree, ...);
7091 extern tree build_min_nt_call_vec (tree, vec<tree, va_gc> *);
7092 extern tree build_min_non_dep_call_vec          (tree, tree, vec<tree, va_gc> *);
7093 extern vec<tree, va_gc>* vec_copy_and_insert    (vec<tree, va_gc>*, tree, unsigned);
7094 extern tree build_cplus_new                     (tree, tree, tsubst_flags_t);
7095 extern tree build_aggr_init_expr                (tree, tree);
7096 extern tree get_target_expr                     (tree);
7097 extern tree get_target_expr_sfinae              (tree, tsubst_flags_t);
7098 extern tree build_cplus_array_type              (tree, tree);
7099 extern tree build_array_of_n_type               (tree, int);
7100 extern bool array_of_runtime_bound_p            (tree);
7101 extern bool vla_type_p                          (tree);
7102 extern tree build_array_copy                    (tree);
7103 extern tree build_vec_init_expr                 (tree, tree, tsubst_flags_t);
7104 extern void diagnose_non_constexpr_vec_init     (tree);
7105 extern tree hash_tree_cons                      (tree, tree, tree);
7106 extern tree hash_tree_chain                     (tree, tree);
7107 extern tree build_qualified_name                (tree, tree, tree, bool);
7108 extern tree build_ref_qualified_type            (tree, cp_ref_qualifier);
7109 inline tree ovl_first                           (tree) ATTRIBUTE_PURE;
7110 extern tree ovl_make                            (tree fn,
7111                                                  tree next = NULL_TREE);
7112 extern tree ovl_insert                          (tree fn, tree maybe_ovl,
7113                                                  bool using_p = false);
7114 extern tree ovl_skip_hidden                     (tree) ATTRIBUTE_PURE;
7115 extern void lookup_mark                         (tree lookup, bool val);
7116 extern tree lookup_add                          (tree fns, tree lookup);
7117 extern tree lookup_maybe_add                    (tree fns, tree lookup,
7118                                                  bool deduping);
7119 extern void lookup_keep                         (tree lookup, bool keep);
7120 extern void lookup_list_keep                    (tree list, bool keep);
7121 extern int is_overloaded_fn                     (tree) ATTRIBUTE_PURE;
7122 extern bool really_overloaded_fn                (tree) ATTRIBUTE_PURE;
7123 extern tree dependent_name                      (tree);
7124 extern tree get_fns                             (tree) ATTRIBUTE_PURE;
7125 extern tree get_first_fn                        (tree) ATTRIBUTE_PURE;
7126 extern tree ovl_scope                           (tree);
7127 extern const char *cxx_printable_name           (tree, int);
7128 extern const char *cxx_printable_name_translate (tree, int);
7129 extern tree canonical_eh_spec                   (tree);
7130 extern tree build_exception_variant             (tree, tree);
7131 extern tree bind_template_template_parm         (tree, tree);
7132 extern tree array_type_nelts_total              (tree);
7133 extern tree array_type_nelts_top                (tree);
7134 extern tree break_out_target_exprs              (tree, bool = false);
7135 extern tree build_ctor_subob_ref                (tree, tree, tree);
7136 extern tree replace_placeholders                (tree, tree, bool * = NULL);
7137 extern bool find_placeholders                   (tree);
7138 extern tree get_type_decl                       (tree);
7139 extern tree decl_namespace_context              (tree);
7140 extern bool decl_anon_ns_mem_p                  (const_tree);
7141 extern tree lvalue_type                         (tree);
7142 extern tree error_type                          (tree);
7143 extern int varargs_function_p                   (const_tree);
7144 extern bool cp_tree_equal                       (tree, tree);
7145 extern tree no_linkage_check                    (tree, bool);
7146 extern void debug_binfo                         (tree);
7147 extern tree build_dummy_object                  (tree);
7148 extern tree maybe_dummy_object                  (tree, tree *);
7149 extern int is_dummy_object                      (const_tree);
7150 extern const struct attribute_spec cxx_attribute_table[];
7151 extern tree make_ptrmem_cst                     (tree, tree);
7152 extern tree cp_build_type_attribute_variant     (tree, tree);
7153 extern tree cp_build_reference_type             (tree, bool);
7154 extern tree move                                (tree);
7155 extern tree cp_build_qualified_type_real        (tree, int, tsubst_flags_t);
7156 #define cp_build_qualified_type(TYPE, QUALS) \
7157   cp_build_qualified_type_real ((TYPE), (QUALS), tf_warning_or_error)
7158 extern bool cv_qualified_p                      (const_tree);
7159 extern tree cv_unqualified                      (tree);
7160 extern special_function_kind special_function_p (const_tree);
7161 extern int count_trees                          (tree);
7162 extern int char_type_p                          (tree);
7163 extern void verify_stmt_tree                    (tree);
7164 extern linkage_kind decl_linkage                (tree);
7165 extern duration_kind decl_storage_duration      (tree);
7166 extern tree cp_walk_subtrees (tree*, int*, walk_tree_fn,
7167                               void*, hash_set<tree> *);
7168 #define cp_walk_tree(tp,func,data,pset) \
7169         walk_tree_1 (tp, func, data, pset, cp_walk_subtrees)
7170 #define cp_walk_tree_without_duplicates(tp,func,data) \
7171         walk_tree_without_duplicates_1 (tp, func, data, cp_walk_subtrees)
7172 extern tree rvalue                              (tree);
7173 extern tree convert_bitfield_to_declared_type   (tree);
7174 extern tree cp_save_expr                        (tree);
7175 extern bool cast_valid_in_integral_constant_expression_p (tree);
7176 extern bool cxx_type_hash_eq                    (const_tree, const_tree);
7177 extern tree cxx_copy_lang_qualifiers            (const_tree, const_tree);
7178
7179 extern void cxx_print_statistics                (void);
7180 extern bool maybe_warn_zero_as_null_pointer_constant (tree, location_t);
7181 extern void cp_warn_deprecated_use              (tree);
7182
7183 /* in ptree.c */
7184 extern void cxx_print_xnode                     (FILE *, tree, int);
7185 extern void cxx_print_decl                      (FILE *, tree, int);
7186 extern void cxx_print_type                      (FILE *, tree, int);
7187 extern void cxx_print_identifier                (FILE *, tree, int);
7188 extern void cxx_print_error_function            (diagnostic_context *,
7189                                                  const char *,
7190                                                  struct diagnostic_info *);
7191
7192 /* in typeck.c */
7193 extern bool cxx_mark_addressable                (tree, bool = false);
7194 extern int string_conv_p                        (const_tree, const_tree, int);
7195 extern tree cp_truthvalue_conversion            (tree);
7196 extern tree condition_conversion                (tree);
7197 extern tree require_complete_type               (tree);
7198 extern tree require_complete_type_sfinae        (tree, tsubst_flags_t);
7199 extern tree complete_type                       (tree);
7200 extern tree complete_type_or_else               (tree, tree);
7201 extern tree complete_type_or_maybe_complain     (tree, tree, tsubst_flags_t);
7202 inline bool type_unknown_p                      (const_tree);
7203 enum { ce_derived, ce_type, ce_normal, ce_exact };
7204 extern bool comp_except_specs                   (const_tree, const_tree, int);
7205 extern bool comptypes                           (tree, tree, int);
7206 extern bool same_type_ignoring_top_level_qualifiers_p (tree, tree);
7207 extern bool compparms                           (const_tree, const_tree);
7208 extern int comp_cv_qualification                (const_tree, const_tree);
7209 extern int comp_cv_qualification                (int, int);
7210 extern int comp_cv_qual_signature               (tree, tree);
7211 extern tree cxx_sizeof_or_alignof_expr          (tree, enum tree_code, bool);
7212 extern tree cxx_sizeof_or_alignof_type          (tree, enum tree_code, bool, bool);
7213 extern tree cxx_alignas_expr                    (tree);
7214 extern tree cxx_sizeof_nowarn                   (tree);
7215 extern tree is_bitfield_expr_with_lowered_type  (const_tree);
7216 extern tree unlowered_expr_type                 (const_tree);
7217 extern tree decay_conversion                    (tree,
7218                                                  tsubst_flags_t,
7219                                                  bool = true);
7220 extern tree build_class_member_access_expr      (cp_expr, tree, tree, bool,
7221                                                  tsubst_flags_t);
7222 extern tree finish_class_member_access_expr     (cp_expr, tree, bool,
7223                                                  tsubst_flags_t);
7224 extern tree build_x_indirect_ref                (location_t, tree,
7225                                                  ref_operator, tsubst_flags_t);
7226 extern tree cp_build_indirect_ref               (tree, ref_operator,
7227                                                  tsubst_flags_t);
7228 extern tree cp_build_fold_indirect_ref          (tree);
7229 extern tree build_array_ref                     (location_t, tree, tree);
7230 extern tree cp_build_array_ref                  (location_t, tree, tree,
7231                                                  tsubst_flags_t);
7232 extern tree get_member_function_from_ptrfunc    (tree *, tree, tsubst_flags_t);
7233 extern tree cp_build_function_call_nary         (tree, tsubst_flags_t, ...)
7234                                                 ATTRIBUTE_SENTINEL;
7235 extern tree cp_build_function_call_vec          (tree, vec<tree, va_gc> **,
7236                                                  tsubst_flags_t);
7237 extern tree build_x_binary_op                   (location_t,
7238                                                  enum tree_code, tree,
7239                                                  enum tree_code, tree,
7240                                                  enum tree_code, tree *,
7241                                                  tsubst_flags_t);
7242 extern tree build_x_array_ref                   (location_t, tree, tree,
7243                                                  tsubst_flags_t);
7244 extern tree build_x_unary_op                    (location_t,
7245                                                  enum tree_code, cp_expr,
7246                                                  tsubst_flags_t);
7247 extern tree cp_build_addressof                  (location_t, tree,
7248                                                  tsubst_flags_t);
7249 extern tree cp_build_addr_expr                  (tree, tsubst_flags_t);
7250 extern tree cp_build_unary_op                   (enum tree_code, tree, bool,
7251                                                  tsubst_flags_t);
7252 extern tree genericize_compound_lvalue          (tree);
7253 extern tree unary_complex_lvalue                (enum tree_code, tree);
7254 extern tree build_x_conditional_expr            (location_t, tree, tree, tree,
7255                                                  tsubst_flags_t);
7256 extern tree build_x_compound_expr_from_list     (tree, expr_list_kind,
7257                                                  tsubst_flags_t);
7258 extern tree build_x_compound_expr_from_vec      (vec<tree, va_gc> *,
7259                                                  const char *, tsubst_flags_t);
7260 extern tree build_x_compound_expr               (location_t, tree, tree,
7261                                                  tsubst_flags_t);
7262 extern tree build_compound_expr                 (location_t, tree, tree);
7263 extern tree cp_build_compound_expr              (tree, tree, tsubst_flags_t);
7264 extern tree build_static_cast                   (tree, tree, tsubst_flags_t);
7265 extern tree build_reinterpret_cast              (tree, tree, tsubst_flags_t);
7266 extern tree build_const_cast                    (tree, tree, tsubst_flags_t);
7267 extern tree build_c_cast                        (location_t, tree, tree);
7268 extern cp_expr build_c_cast                     (location_t loc, tree type,
7269                                                  cp_expr expr);
7270 extern tree cp_build_c_cast                     (tree, tree, tsubst_flags_t);
7271 extern cp_expr build_x_modify_expr              (location_t, tree,
7272                                                  enum tree_code, tree,
7273                                                  tsubst_flags_t);
7274 extern tree cp_build_modify_expr                (location_t, tree,
7275                                                  enum tree_code, tree,
7276                                                  tsubst_flags_t);
7277 extern tree convert_for_initialization          (tree, tree, tree, int,
7278                                                  impl_conv_rhs, tree, int,
7279                                                  tsubst_flags_t);
7280 extern int comp_ptr_ttypes                      (tree, tree);
7281 extern bool comp_ptr_ttypes_const               (tree, tree);
7282 extern bool error_type_p                        (const_tree);
7283 extern bool ptr_reasonably_similar              (const_tree, const_tree);
7284 extern tree build_ptrmemfunc                    (tree, tree, int, bool,
7285                                                  tsubst_flags_t);
7286 extern int cp_type_quals                        (const_tree);
7287 extern int type_memfn_quals                     (const_tree);
7288 extern cp_ref_qualifier type_memfn_rqual        (const_tree);
7289 extern tree apply_memfn_quals                   (tree, cp_cv_quals, cp_ref_qualifier);
7290 extern bool cp_has_mutable_p                    (const_tree);
7291 extern bool at_least_as_qualified_p             (const_tree, const_tree);
7292 extern void cp_apply_type_quals_to_decl         (int, tree);
7293 extern tree build_ptrmemfunc1                   (tree, tree, tree);
7294 extern void expand_ptrmemfunc_cst               (tree, tree *, tree *);
7295 extern tree type_after_usual_arithmetic_conversions (tree, tree);
7296 extern tree common_pointer_type                 (tree, tree);
7297 extern tree composite_pointer_type              (tree, tree, tree, tree,
7298                                                  composite_pointer_operation,
7299                                                  tsubst_flags_t);
7300 extern tree merge_types                         (tree, tree);
7301 extern tree strip_array_domain                  (tree);
7302 extern tree check_return_expr                   (tree, bool *);
7303 extern tree cp_build_binary_op                  (location_t,
7304                                                  enum tree_code, tree, tree,
7305                                                  tsubst_flags_t);
7306 extern tree build_x_vec_perm_expr               (location_t,
7307                                                  tree, tree, tree,
7308                                                  tsubst_flags_t);
7309 #define cxx_sizeof(T)  cxx_sizeof_or_alignof_type (T, SIZEOF_EXPR, false, true)
7310 extern tree build_simple_component_ref          (tree, tree);
7311 extern tree build_ptrmemfunc_access_expr        (tree, tree);
7312 extern tree build_address                       (tree);
7313 extern tree build_nop                           (tree, tree);
7314 extern tree non_reference                       (tree);
7315 extern tree lookup_anon_field                   (tree, tree);
7316 extern bool invalid_nonstatic_memfn_p           (location_t, tree,
7317                                                  tsubst_flags_t);
7318 extern tree convert_member_func_to_ptr          (tree, tree, tsubst_flags_t);
7319 extern tree convert_ptrmem                      (tree, tree, bool, bool,
7320                                                  tsubst_flags_t);
7321 extern int lvalue_or_else                       (tree, enum lvalue_use,
7322                                                  tsubst_flags_t);
7323 extern void check_template_keyword              (tree);
7324 extern bool check_raw_literal_operator          (const_tree decl);
7325 extern bool check_literal_operator_args         (const_tree, bool *, bool *);
7326 extern void maybe_warn_about_useless_cast       (tree, tree, tsubst_flags_t);
7327 extern tree cp_perform_integral_promotions      (tree, tsubst_flags_t);
7328
7329 extern tree finish_left_unary_fold_expr      (tree, int);
7330 extern tree finish_right_unary_fold_expr     (tree, int);
7331 extern tree finish_binary_fold_expr          (tree, tree, int);
7332
7333 /* in typeck2.c */
7334 extern void require_complete_eh_spec_types      (tree, tree);
7335 extern void cxx_incomplete_type_diagnostic      (location_t, const_tree,
7336                                                  const_tree, diagnostic_t);
7337 inline void
7338 cxx_incomplete_type_diagnostic (const_tree value, const_tree type,
7339                                 diagnostic_t diag_kind)
7340 {
7341   cxx_incomplete_type_diagnostic (EXPR_LOC_OR_LOC (value, input_location),
7342                                   value, type, diag_kind);
7343 }
7344
7345 extern void cxx_incomplete_type_error           (location_t, const_tree,
7346                                                  const_tree);
7347 inline void
7348 cxx_incomplete_type_error (const_tree value, const_tree type)
7349 {
7350   cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
7351 }
7352
7353 extern void cxx_incomplete_type_inform          (const_tree);
7354 extern tree error_not_base_type                 (tree, tree);
7355 extern tree binfo_or_else                       (tree, tree);
7356 extern void cxx_readonly_error                  (tree, enum lvalue_use);
7357 extern void complete_type_check_abstract        (tree);
7358 extern int abstract_virtuals_error              (tree, tree);
7359 extern int abstract_virtuals_error              (abstract_class_use, tree);
7360 extern int abstract_virtuals_error_sfinae       (tree, tree, tsubst_flags_t);
7361 extern int abstract_virtuals_error_sfinae       (abstract_class_use, tree, tsubst_flags_t);
7362
7363 extern tree store_init_value                    (tree, tree, vec<tree, va_gc>**, int);
7364 extern tree split_nonconstant_init              (tree, tree);
7365 extern bool check_narrowing                     (tree, tree, tsubst_flags_t);
7366 extern tree digest_init                         (tree, tree, tsubst_flags_t);
7367 extern tree digest_init_flags                   (tree, tree, int, tsubst_flags_t);
7368 extern tree digest_nsdmi_init                   (tree, tree, tsubst_flags_t);
7369 extern tree build_scoped_ref                    (tree, tree, tree *);
7370 extern tree build_x_arrow                       (location_t, tree,
7371                                                  tsubst_flags_t);
7372 extern tree build_m_component_ref               (tree, tree, tsubst_flags_t);
7373 extern tree build_functional_cast               (tree, tree, tsubst_flags_t);
7374 extern tree add_exception_specifier             (tree, tree, int);
7375 extern tree merge_exception_specifiers          (tree, tree);
7376
7377 /* in mangle.c */
7378 extern void init_mangle                         (void);
7379 extern void mangle_decl                         (tree);
7380 extern const char *mangle_type_string           (tree);
7381 extern tree mangle_typeinfo_for_type            (tree);
7382 extern tree mangle_typeinfo_string_for_type     (tree);
7383 extern tree mangle_vtbl_for_type                (tree);
7384 extern tree mangle_vtt_for_type                 (tree);
7385 extern tree mangle_ctor_vtbl_for_type           (tree, tree);
7386 extern tree mangle_thunk                        (tree, int, tree, tree, tree);
7387 extern tree mangle_guard_variable               (tree);
7388 extern tree mangle_tls_init_fn                  (tree);
7389 extern tree mangle_tls_wrapper_fn               (tree);
7390 extern bool decl_tls_wrapper_p                  (tree);
7391 extern tree mangle_ref_init_variable            (tree);
7392 extern char * get_mangled_vtable_map_var_name   (tree);
7393 extern bool mangle_return_type_p                (tree);
7394 extern tree mangle_decomp                       (tree, vec<tree> &);
7395
7396 /* in dump.c */
7397 extern bool cp_dump_tree                        (void *, tree);
7398
7399 /* In cp/cp-objcp-common.c.  */
7400
7401 extern alias_set_type cxx_get_alias_set         (tree);
7402 extern bool cxx_warn_unused_global_decl         (const_tree);
7403 extern size_t cp_tree_size                      (enum tree_code);
7404 extern bool cp_var_mod_type_p                   (tree, tree);
7405 extern void cxx_initialize_diagnostics          (diagnostic_context *);
7406 extern int cxx_types_compatible_p               (tree, tree);
7407 extern void init_shadowed_var_for_decl          (void);
7408 extern bool cxx_block_may_fallthru              (const_tree);
7409
7410 /* in cp-gimplify.c */
7411 extern int cp_gimplify_expr                     (tree *, gimple_seq *,
7412                                                  gimple_seq *);
7413 extern void cp_genericize                       (tree);
7414 extern bool cxx_omp_const_qual_no_mutable       (tree);
7415 extern enum omp_clause_default_kind cxx_omp_predetermined_sharing_1 (tree);
7416 extern enum omp_clause_default_kind cxx_omp_predetermined_sharing (tree);
7417 extern tree cxx_omp_clause_default_ctor         (tree, tree, tree);
7418 extern tree cxx_omp_clause_copy_ctor            (tree, tree, tree);
7419 extern tree cxx_omp_clause_assign_op            (tree, tree, tree);
7420 extern tree cxx_omp_clause_dtor                 (tree, tree);
7421 extern void cxx_omp_finish_clause               (tree, gimple_seq *);
7422 extern bool cxx_omp_privatize_by_reference      (const_tree);
7423 extern bool cxx_omp_disregard_value_expr        (tree, bool);
7424 extern void cp_fold_function                    (tree);
7425 extern tree cp_fully_fold                       (tree);
7426 extern void clear_fold_cache                    (void);
7427
7428 /* in name-lookup.c */
7429 extern void suggest_alternatives_for            (location_t, tree, bool);
7430 extern bool suggest_alternative_in_explicit_scope (location_t, tree, tree);
7431 extern tree strip_using_decl                    (tree);
7432
7433 /* Tell the binding oracle what kind of binding we are looking for.  */
7434
7435 enum cp_oracle_request
7436 {
7437   CP_ORACLE_IDENTIFIER
7438 };
7439
7440 /* If this is non-NULL, then it is a "binding oracle" which can lazily
7441    create bindings when needed by the C compiler.  The oracle is told
7442    the name and type of the binding to create.  It can call pushdecl
7443    or the like to ensure the binding is visible; or do nothing,
7444    leaving the binding untouched.  c-decl.c takes note of when the
7445    oracle has been called and will not call it again if it fails to
7446    create a given binding.  */
7447
7448 typedef void cp_binding_oracle_function (enum cp_oracle_request, tree identifier);
7449
7450 extern cp_binding_oracle_function *cp_binding_oracle;
7451
7452 /* in constraint.cc */
7453 extern void init_constraint_processing          ();
7454 extern bool constraint_p                        (tree);
7455 extern tree conjoin_constraints                 (tree, tree);
7456 extern tree conjoin_constraints                 (tree);
7457 extern tree get_constraints                     (tree);
7458 extern void set_constraints                     (tree, tree);
7459 extern void remove_constraints                  (tree);
7460 extern tree current_template_constraints        (void);
7461 extern tree associate_classtype_constraints     (tree);
7462 extern tree build_constraints                   (tree, tree);
7463 extern tree get_shorthand_constraints           (tree);
7464 extern tree build_concept_check                 (tree, tree, tree = NULL_TREE);
7465 extern tree build_constrained_parameter         (tree, tree, tree = NULL_TREE);
7466 extern tree make_constrained_auto               (tree, tree);
7467 extern void placeholder_extract_concept_and_args (tree, tree&, tree&);
7468 extern bool equivalent_placeholder_constraints  (tree, tree);
7469 extern hashval_t hash_placeholder_constraint    (tree);
7470 extern bool deduce_constrained_parameter        (tree, tree&, tree&);
7471 extern tree resolve_constraint_check            (tree);
7472 extern tree check_function_concept              (tree);
7473 extern tree finish_template_introduction        (tree, tree);
7474 extern bool valid_requirements_p                (tree);
7475 extern tree finish_concept_name                 (tree);
7476 extern tree finish_shorthand_constraint         (tree, tree);
7477 extern tree finish_requires_expr                (tree, tree);
7478 extern tree finish_simple_requirement           (tree);
7479 extern tree finish_type_requirement             (tree);
7480 extern tree finish_compound_requirement         (tree, tree, bool);
7481 extern tree finish_nested_requirement           (tree);
7482 extern void check_constrained_friend            (tree, tree);
7483 extern tree tsubst_requires_expr                (tree, tree, tsubst_flags_t, tree);
7484 extern tree tsubst_constraint                   (tree, tree, tsubst_flags_t, tree);
7485 extern tree tsubst_constraint_info              (tree, tree, tsubst_flags_t, tree);
7486 extern bool function_concept_check_p            (tree);
7487 extern tree normalize_expression                (tree);
7488 extern tree expand_concept                      (tree, tree);
7489 extern bool expanding_concept                   ();
7490 extern tree evaluate_constraints                (tree, tree);
7491 extern tree evaluate_function_concept           (tree, tree);
7492 extern tree evaluate_variable_concept           (tree, tree);
7493 extern tree evaluate_constraint_expression      (tree, tree);
7494 extern bool constraints_satisfied_p             (tree);
7495 extern bool constraints_satisfied_p             (tree, tree);
7496 extern tree lookup_constraint_satisfaction      (tree, tree);
7497 extern tree memoize_constraint_satisfaction     (tree, tree, tree);
7498 extern tree lookup_concept_satisfaction         (tree, tree);
7499 extern tree memoize_concept_satisfaction        (tree, tree, tree);
7500 extern tree get_concept_expansion               (tree, tree);
7501 extern tree save_concept_expansion              (tree, tree, tree);
7502 extern bool* lookup_subsumption_result          (tree, tree);
7503 extern bool save_subsumption_result             (tree, tree, bool);
7504
7505 extern bool equivalent_constraints              (tree, tree);
7506 extern bool equivalently_constrained            (tree, tree);
7507 extern bool subsumes_constraints                (tree, tree);
7508 extern bool strictly_subsumes                   (tree, tree);
7509 extern int more_constrained                     (tree, tree);
7510
7511 extern void diagnose_constraints                (location_t, tree, tree);
7512
7513 /* in logic.cc */
7514 extern tree decompose_conclusions               (tree);
7515 extern bool subsumes                            (tree, tree);
7516
7517 /* In class.c */
7518 extern void cp_finish_injected_record_type (tree);
7519
7520 /* in vtable-class-hierarchy.c */
7521 extern void vtv_compute_class_hierarchy_transitive_closure (void);
7522 extern void vtv_generate_init_routine           (void);
7523 extern void vtv_save_class_info                 (tree);
7524 extern void vtv_recover_class_info              (void);
7525 extern void vtv_build_vtable_verify_fndecl      (void);
7526
7527 /* In constexpr.c */
7528 extern void fini_constexpr                      (void);
7529 extern bool literal_type_p                      (tree);
7530 extern tree register_constexpr_fundef           (tree, tree);
7531 extern bool is_valid_constexpr_fn               (tree, bool);
7532 extern bool check_constexpr_ctor_body           (tree, tree, bool);
7533 extern tree constexpr_fn_retval         (tree);
7534 extern tree ensure_literal_type_for_constexpr_object (tree);
7535 extern bool potential_constant_expression       (tree);
7536 extern bool is_constant_expression (tree);
7537 extern bool is_nondependent_constant_expression (tree);
7538 extern bool is_nondependent_static_init_expression (tree);
7539 extern bool is_static_init_expression    (tree);
7540 extern bool potential_rvalue_constant_expression (tree);
7541 extern bool require_potential_constant_expression (tree);
7542 extern bool require_constant_expression (tree);
7543 extern bool require_rvalue_constant_expression (tree);
7544 extern bool require_potential_rvalue_constant_expression (tree);
7545 extern tree cxx_constant_value                  (tree, tree = NULL_TREE);
7546 extern tree cxx_constant_init                   (tree, tree = NULL_TREE);
7547 extern tree maybe_constant_value                (tree, tree = NULL_TREE);
7548 extern tree maybe_constant_init                 (tree, tree = NULL_TREE);
7549 extern tree fold_non_dependent_expr             (tree, tsubst_flags_t = tf_none);
7550 extern tree fold_simple                         (tree);
7551 extern bool is_sub_constant_expr                (tree);
7552 extern bool reduced_constant_expression_p       (tree);
7553 extern bool is_instantiation_of_constexpr       (tree);
7554 extern bool var_in_constexpr_fn                 (tree);
7555 extern bool var_in_maybe_constexpr_fn           (tree);
7556 extern void explain_invalid_constexpr_fn        (tree);
7557 extern vec<tree> cx_error_context               (void);
7558 extern tree fold_sizeof_expr                    (tree);
7559 extern void clear_cv_and_fold_caches            (void);
7560
7561 /* In cp-ubsan.c */
7562 extern void cp_ubsan_maybe_instrument_member_call (tree);
7563 extern void cp_ubsan_instrument_member_accesses (tree *);
7564 extern tree cp_ubsan_maybe_instrument_downcast  (location_t, tree, tree, tree);
7565 extern tree cp_ubsan_maybe_instrument_cast_to_vbase (location_t, tree, tree);
7566 extern void cp_ubsan_maybe_initialize_vtbl_ptrs (tree);
7567
7568 /* Inline bodies.  */
7569
7570 inline tree
7571 ovl_first (tree node)
7572 {
7573   while (TREE_CODE (node) == OVERLOAD)
7574     node = OVL_FUNCTION (node);
7575   return node;
7576 }
7577
7578 inline bool
7579 type_unknown_p (const_tree expr)
7580 {
7581   return TREE_TYPE (expr) == unknown_type_node;
7582 }
7583
7584 inline hashval_t
7585 named_decl_hash::hash (const value_type decl)
7586 {
7587   tree name = OVL_NAME (decl);
7588   return name ? IDENTIFIER_HASH_VALUE (name) : 0;
7589 }
7590
7591 inline bool
7592 named_decl_hash::equal (const value_type existing, compare_type candidate)
7593 {
7594   tree name = OVL_NAME (existing);
7595   return candidate == name;
7596 }
7597
7598 inline bool
7599 null_node_p (const_tree expr)
7600 {
7601   STRIP_ANY_LOCATION_WRAPPER (expr);
7602   return expr == null_node;
7603 }
7604
7605 #if CHECKING_P
7606 namespace selftest {
7607   extern void run_cp_tests (void);
7608
7609   /* Declarations for specific families of tests within cp,
7610      by source file, in alphabetical order.  */
7611   extern void cp_pt_c_tests ();
7612   extern void cp_tree_c_tests (void);
7613 } // namespace selftest
7614 #endif /* #if CHECKING_P */
7615
7616 /* -- end of C++ */
7617
7618 #endif /* ! GCC_CP_TREE_H */