gcc/cp/cp-tree.h

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