gcc/cp/cp-tree.def

   1 /* This file contains the definitions and documentation for the
   2    additional tree codes used in the GNU C++ compiler (see tree.def
   3    for the standard codes).
   4    Copyright (C) 1987-2024 Free Software Foundation, Inc.
   5    Hacked by Michael Tiemann (tiemann@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 3, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23
  24 /* An OFFSET_REF is used in two situations:
  25
  26    1. An expression of the form `A::m' where `A' is a class and `m' is
  27       a non-static member or an overload set.  In this case, operand 0
  28       will be a TYPE (corresponding to `A') and operand 1 will be a
  29       FIELD_DECL, BASELINK, or TEMPLATE_ID_EXPR (corresponding to `m').
  30
  31       The expression is a pointer-to-member if its address is taken (and
  32       if, after any overload resolution, 'm' does not designate a
  33       static or explicit object member function).  It simply denotes a
  34       member of the object if its address is not taken.
  35
  36       This form is only used during the parsing phase; once semantic
  37       analysis has taken place they are eliminated.
  38
  39    2. An expression of the form `x.*p'.  In this case, operand 0 will
  40       be an expression corresponding to `x' and operand 1 will be an
  41       expression with pointer-to-member type.  */
  42 DEFTREECODE (OFFSET_REF, "offset_ref", tcc_reference, 2)
  43
  44 /* A pointer-to-member constant.  For a pointer-to-member constant
  45    `X::Y' The PTRMEM_CST_CLASS is the RECORD_TYPE for `X' and the
  46    PTRMEM_CST_MEMBER is the _DECL for `Y'.  */
  47 DEFTREECODE (PTRMEM_CST, "ptrmem_cst", tcc_constant, 0)
  48
  49 /* For NEW_EXPR, operand 0 is the placement list.
  50    Operand 1 is the new-declarator.
  51    Operand 2 is the number of elements in the array.
  52    Operand 3 is the initializer.  */
  53 DEFTREECODE (NEW_EXPR, "nw_expr", tcc_expression, 4)
  54 DEFTREECODE (VEC_NEW_EXPR, "vec_nw_expr", tcc_expression, 3)
  55
  56 /* For DELETE_EXPR, operand 0 is the store to be destroyed.
  57    Operand 1 is the value to pass to the destroying function
  58    saying whether the store should be deallocated as well.  */
  59 DEFTREECODE (DELETE_EXPR, "dl_expr", tcc_expression, 2)
  60 DEFTREECODE (VEC_DELETE_EXPR, "vec_dl_expr", tcc_expression, 2)
  61
  62 /* Value is reference to particular overloaded class method.
  63    Operand 0 is the class, operand 1 is the field
  64    The COMPLEXITY field holds the class level (usually 0).  */
  65 DEFTREECODE (SCOPE_REF, "scope_ref", tcc_reference, 2)
  66
  67 /* When composing an object with a member, this is the result.
  68    Operand 0 is the object.  Operand 1 is the member (usually
  69    a dereferenced pointer to member).  */
  70 DEFTREECODE (MEMBER_REF, "member_ref", tcc_reference, 2)
  71
  72 /* Type conversion operator in C++.  TREE_TYPE is type that this
  73    operator converts to.  Operand is expression to be converted.  */
  74 DEFTREECODE (TYPE_EXPR, "type_expr", tcc_expression, 1)
  75
  76 /* AGGR_INIT_EXPRs have a variably-sized representation similar to
  77    that of CALL_EXPRs.  Operand 0 is an INTEGER_CST node containing the
  78    operand count, operand 1 is the function which performs initialization,
  79    operand 2 is the slot which was allocated for this expression, and
  80    the remaining operands are the arguments to the initialization function.  */
  81 DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", tcc_vl_exp, 3)
  82
  83 /* Initialization of an array from another array, expressed at a high level
  84    so that it works with TARGET_EXPR.  Operand 0 is the target, operand 1
  85    is the initializer.  */
  86 DEFTREECODE (VEC_INIT_EXPR, "vec_init_expr", tcc_expression, 2)
  87
  88 /* A throw expression.  operand 0 is the expression, if there was one,
  89    else it is NULL_TREE.  */
  90 DEFTREECODE (THROW_EXPR, "throw_expr", tcc_expression, 1)
  91
  92 /* An empty class object.  The TREE_TYPE gives the class type.  We use
  93    these to avoid actually creating instances of the empty classes.  */
  94 DEFTREECODE (EMPTY_CLASS_EXPR, "empty_class_expr", tcc_expression, 0)
  95
  96 /* A reference to a member function or member functions from a base
  97    class.  BASELINK_FUNCTIONS gives the FUNCTION_DECL,
  98    TEMPLATE_DECL, OVERLOAD, or TEMPLATE_ID_EXPR corresponding to the
  99    functions.  BASELINK_BINFO gives the base from which the functions
 100    come, i.e., the base to which the `this' pointer must be converted
 101    before the functions are called.  BASELINK_ACCESS_BINFO gives the
 102    base used to name the functions.
 103
 104    A BASELINK is an expression; the TREE_TYPE of the BASELINK gives
 105    the type of the expression.  This type is either a FUNCTION_TYPE,
 106    METHOD_TYPE, or `unknown_type_node' indicating that the function is
 107    overloaded.  */
 108 DEFTREECODE (BASELINK, "baselink", tcc_exceptional, 0)
 109
 110 /* Template definition.  The following fields have the specified uses,
 111    although there are other macros in cp-tree.h that should be used for
 112    accessing this data.
 113         DECL_ARGUMENTS          template parm vector
 114         DECL_TEMPLATE_INFO      template text &c
 115         DECL_VINDEX             list of instantiations already produced;
 116                                 only done for functions so far
 117    For class template:
 118         DECL_INITIAL            associated templates (methods &c)
 119         DECL_TEMPLATE_RESULT    null
 120    For non-class templates:
 121         TREE_TYPE               type of object to be constructed
 122         DECL_TEMPLATE_RESULT    decl for object to be created
 123                                 (e.g., FUNCTION_DECL with tmpl parms used)
 124  */
 125 DEFTREECODE (TEMPLATE_DECL, "template_decl", tcc_declaration, 0)
 126
 127 /* Index into a template parameter list.  The TEMPLATE_PARM_IDX gives
 128    the index (from 0) of the parameter, while the TEMPLATE_PARM_LEVEL
 129    gives the level (from 1) of the parameter.
 130
 131    Here's an example:
 132
 133    template <class T> // Index 0, Level 1.
 134    struct S
 135    {
 136       template <class U, // Index 0, Level 2.
 137                 class V> // Index 1, Level 2.
 138       void f();
 139    };
 140
 141    The DESCENDANTS will be a chain of TEMPLATE_PARM_INDEXs descended
 142    from this one.  The first descendant will have the same IDX, but
 143    its LEVEL will be one less.  The TREE_CHAIN field is used to chain
 144    together the descendants.  The TEMPLATE_PARM_DECL is the
 145    declaration of this parameter, either a TYPE_DECL or CONST_DECL.
 146    The TEMPLATE_PARM_ORIG_LEVEL is the LEVEL of the most distant
 147    parent, i.e., the LEVEL that the parameter originally had when it
 148    was declared.  For example, if we instantiate S<int>, we will have:
 149
 150    struct S<int>
 151    {
 152      template <class U, // Index 0, Level 1, Orig Level 2
 153                class V> // Index 1, Level 1, Orig Level 2
 154      void f();
 155    };
 156
 157    The LEVEL is the level of the parameter when we are worrying about
 158    the types of things; the ORIG_LEVEL is the level when we are
 159    worrying about instantiating things.  */
 160 DEFTREECODE (TEMPLATE_PARM_INDEX, "template_parm_index", tcc_exceptional, 0)
 161
 162 /* Index into a template parameter list for template template parameters.
 163    This parameter must be a type.  The TYPE_FIELDS value will be a
 164    TEMPLATE_PARM_INDEX.
 165
 166    It is used without template arguments like TT in C<TT>,
 167    TYPE_NAME is a TEMPLATE_DECL.  */
 168 DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", tcc_type, 0)
 169
 170 /* The ordering of the following codes is optimized for the checking
 171    macros in tree.h.  Changing the order will degrade the speed of the
 172    compiler.  TEMPLATE_TYPE_PARM, TYPENAME_TYPE, TYPEOF_TYPE,
 173    BOUND_TEMPLATE_TEMPLATE_PARM.  */
 174
 175 /* Index into a template parameter list.  This parameter must be a type.
 176    The type.values field will be a TEMPLATE_PARM_INDEX.  */
 177 DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", tcc_type, 0)
 178
 179 /* A type designated by `typename T::t'.  TYPE_CONTEXT is `T',
 180    TYPE_NAME is an IDENTIFIER_NODE for `t'.  If the type was named via
 181    template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR.
 182    TREE_TYPE is always NULL.  */
 183 DEFTREECODE (TYPENAME_TYPE, "typename_type", tcc_type, 0)
 184
 185 /* A type designated by `__typeof (expr)'.  TYPEOF_TYPE_EXPR is the
 186    expression in question.  */
 187 DEFTREECODE (TYPEOF_TYPE, "typeof_type", tcc_type, 0)
 188
 189 /* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments
 190    like TT<int>.
 191    In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the
 192    template name and its bound arguments.  TYPE_NAME is a TYPE_DECL.  */
 193 DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm",
 194              tcc_type, 0)
 195
 196 /* For template template argument of the form `T::template C'.
 197    TYPE_CONTEXT is `T', the template parameter dependent object.
 198    TYPE_NAME is a TEMPLATE_DECL, whose DECL_TEMPLATE_PARMS are any
 199    template parms of the instantiation.  That decl's DECL_NAME is the
 200    IDENTIFIER_NODE for `C', the member class template.  */
 201 DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", tcc_type, 0)
 202
 203 /* A using declaration.  USING_DECL_SCOPE contains the specified
 204    scope.  In a variadic using-declaration, this is a TYPE_PACK_EXPANSION.
 205    In a member using decl, unless DECL_DEPENDENT_P is true,
 206    USING_DECL_DECLS contains the _DECL or OVERLOAD so named.  This is
 207    not an alias, but is later expanded into multiple aliases.  */
 208 DEFTREECODE (USING_DECL, "using_decl", tcc_declaration, 0)
 209
 210 /* A using directive. The operand is USING_STMT_NAMESPACE.  */
 211 DEFTREECODE (USING_STMT, "using_stmt", tcc_statement, 1)
 212
 213 /* An un-parsed operand.  Holds a vector of input tokens and
 214    a vector of places where the argument was instantiated before
 215    parsing had occurred.  This is used for default arguments, delayed
 216    NSDMIs, and noexcept-specifier parsing.  */
 217 DEFTREECODE (DEFERRED_PARSE, "deferred_parse", tcc_exceptional, 0)
 218
 219 /* An uninstantiated/unevaluated noexcept-specification.  For the
 220    uninstantiated case, DEFERRED_NOEXCEPT_PATTERN is the pattern from the
 221    template, and DEFERRED_NOEXCEPT_ARGS are the template arguments to
 222    substitute into the pattern when needed.  For the unevaluated case,
 223    those slots are NULL_TREE and we use get_defaulted_eh_spec to find
 224    the exception-specification.  */
 225 DEFTREECODE (DEFERRED_NOEXCEPT, "deferred_noexcept", tcc_exceptional, 0)
 226
 227 /* A template-id, like foo<int>.  The first operand is the template.
 228    The second is NULL if there are no explicit arguments, or a
 229    TREE_VEC of arguments.  The template will be a FUNCTION_DECL,
 230    TEMPLATE_DECL, or an OVERLOAD.  If the template-id refers to a
 231    member template, the template may be an IDENTIFIER_NODE.  */
 232 DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", tcc_expression, 2)
 233
 234 /* One of a set of overloaded functions.  */
 235 DEFTREECODE (OVERLOAD, "overload", tcc_exceptional, 0)
 236
 237 /* A vector of binding slots.  */
 238 DEFTREECODE (BINDING_VECTOR, "binding_vector", tcc_exceptional, 0)
 239
 240 /* A pseudo-destructor, of the form "OBJECT.~DESTRUCTOR" or
 241    "OBJECT.SCOPE::~DESTRUCTOR.  The first operand is the OBJECT.  The
 242    second operand (if non-NULL) is the SCOPE.  The third operand is
 243    the TYPE node corresponding to the DESTRUCTOR.  The type of the
 244    first operand will always be a scalar type.
 245
 246    The type of a PSEUDO_DTOR_EXPR is always "void", even though it can
 247    be used as if it were a zero-argument function.  We handle the
 248    function-call case specially, and giving it "void" type prevents it
 249    being used in expressions in ways that are not permitted.  */
 250 DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", tcc_expression, 3)
 251
 252 /* A whole bunch of tree codes for the initial, superficial parsing of
 253    templates.  */
 254 DEFTREECODE (MODOP_EXPR, "modop_expr", tcc_expression, 3)
 255 DEFTREECODE (CAST_EXPR, "cast_expr", tcc_unary, 1)
 256 DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", tcc_unary, 1)
 257 DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", tcc_unary, 1)
 258 DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", tcc_unary, 1)
 259 DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", tcc_unary, 1)
 260 DEFTREECODE (IMPLICIT_CONV_EXPR, "implicit_conv_expr", tcc_unary, 1)
 261 DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", tcc_expression, 2)
 262 DEFTREECODE (TYPEID_EXPR, "typeid_expr", tcc_expression, 1)
 263 DEFTREECODE (NOEXCEPT_EXPR, "noexcept_expr", tcc_unary, 1)
 264 DEFTREECODE (SPACESHIP_EXPR, "spaceship_expr", tcc_expression, 2)
 265
 266 /* CTOR_INITIALIZER is a placeholder in template code for a call to
 267    setup_vtbl_pointer (and appears in all functions, not just ctors).  */
 268 DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", tcc_expression, 1)
 269
 270 DEFTREECODE (TRY_BLOCK, "try_block", tcc_statement, 2)
 271
 272 DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", tcc_statement, 2)
 273
 274 /* A HANDLER wraps a catch handler for the HANDLER_TYPE.  If this is
 275    CATCH_ALL_TYPE, then the handler catches all types.  The declaration of
 276    the catch variable is in HANDLER_PARMS, and the body block in
 277    HANDLER_BODY.  */
 278 DEFTREECODE (HANDLER, "handler", tcc_statement, 2)
 279
 280 /* A MUST_NOT_THROW_EXPR wraps an expression that may not
 281    throw, and must call terminate if it does.  The second argument
 282    is a condition, used in templates to express noexcept (condition).  */
 283 DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", tcc_expression, 2)
 284
 285 /* A CLEANUP_STMT marks the point at which a declaration is fully
 286    constructed.  The CLEANUP_EXPR is run on behalf of CLEANUP_DECL
 287    when CLEANUP_BODY completes.  */
 288 DEFTREECODE (CLEANUP_STMT, "cleanup_stmt", tcc_statement, 3)
 289
 290 /* Represents an 'if' statement. The operands are IF_COND,
 291    THEN_CLAUSE, and ELSE_CLAUSE, and the current scope, respectively.  */
 292 /* ??? It is currently still necessary to distinguish between IF_STMT
 293    and COND_EXPR for the benefit of templates.  */
 294 DEFTREECODE (IF_STMT, "if_stmt", tcc_statement, 4)
 295
 296 /* Used to represent a range-based `for' statement. The operands are
 297    RANGE_FOR_DECL, RANGE_FOR_EXPR, RANGE_FOR_BODY, RANGE_FOR_SCOPE,
 298    RANGE_FOR_UNROLL, and RANGE_FOR_INIT_STMT, respectively.  Only used in
 299    templates.  */
 300 DEFTREECODE (RANGE_FOR_STMT, "range_for_stmt", tcc_statement, 6)
 301
 302 /* Used to represent an expression statement.  Use `EXPR_STMT_EXPR' to
 303    obtain the expression.  */
 304 DEFTREECODE (EXPR_STMT, "expr_stmt", tcc_expression, 1)
 305
 306 DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0)
 307
 308 /* Represents an 'offsetof' expression during template expansion.  */
 309 DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 2)
 310
 311 /* Represents an '__builtin_addressof' expression during template
 312    expansion.  This is similar to ADDR_EXPR, but it doesn't invoke
 313    overloaded & operators.  */
 314 DEFTREECODE (ADDRESSOF_EXPR, "addressof_expr", tcc_expression, 1)
 315
 316 /* Represents the -> operator during template expansion.  */
 317 DEFTREECODE (ARROW_EXPR, "arrow_expr", tcc_expression, 1)
 318
 319 /* Represents an '__alignof__' expression during template
 320    expansion.  */
 321 DEFTREECODE (ALIGNOF_EXPR, "alignof_expr", tcc_expression, 1)
 322
 323 /* Represents an Objective-C++ '@encode' expression during template
 324    expansion.  */
 325 DEFTREECODE (AT_ENCODE_EXPR, "at_encode_expr", tcc_expression, 1)
 326
 327 /* A STMT_EXPR represents a statement-expression during template
 328    expansion.  This is the GCC extension { ( ... ) }.  The
 329    STMT_EXPR_STMT is the statement given by the expression.  */
 330 DEFTREECODE (STMT_EXPR, "stmt_expr", tcc_expression, 1)
 331
 332 /* Unary plus. Operand 0 is the expression to which the unary plus
 333    is applied.  */
 334 DEFTREECODE (UNARY_PLUS_EXPR, "unary_plus_expr", tcc_unary, 1)
 335
 336 /** C++11 extensions. */
 337
 338 /* A static assertion.  This is a C++11 extension.
 339    STATIC_ASSERT_CONDITION contains the condition that is being
 340    checked.  STATIC_ASSERT_MESSAGE contains the message (a string
 341    literal) to be displayed if the condition fails to hold.  */
 342 DEFTREECODE (STATIC_ASSERT, "static_assert", tcc_exceptional, 0)
 343
 344 /* Represents an argument pack of types (or templates). An argument
 345    pack stores zero or more arguments that will be used to instantiate
 346    a parameter pack.
 347
 348    ARGUMENT_PACK_ARGS retrieves the arguments stored in the argument
 349    pack.
 350
 351    Example:
 352      template<typename... Values>
 353      class tuple { ... };
 354
 355      tuple<int, float, double> t;
 356
 357    Values is a (template) parameter pack. When tuple<int, float,
 358    double> is instantiated, the Values parameter pack is instantiated
 359    with the argument pack <int, float, double>. ARGUMENT_PACK_ARGS will
 360    be a TREE_VEC containing int, float, and double.  */
 361 DEFTREECODE (TYPE_ARGUMENT_PACK, "type_argument_pack", tcc_type, 0)
 362
 363 /* Represents an argument pack of values, which can be used either for
 364    non-type template arguments or function call arguments.
 365
 366    NONTYPE_ARGUMENT_PACK plays precisely the same role as
 367    TYPE_ARGUMENT_PACK, but will be used for packing non-type template
 368    arguments (e.g., "int... Dimensions") or function arguments ("const
 369    Args&... args"). */
 370 DEFTREECODE (NONTYPE_ARGUMENT_PACK, "nontype_argument_pack", tcc_expression, 1)
 371
 372 /* Represents a type expression that will be expanded into a list of
 373    types when instantiated with one or more argument packs.
 374
 375    PACK_EXPANSION_PATTERN retrieves the expansion pattern. This is
 376    the type or expression that we will substitute into with each
 377    argument in an argument pack.
 378
 379    PACK_EXPANSION_PARAMETER_PACKS contains a TREE_LIST of the parameter
 380    packs that are used in this pack expansion.
 381
 382    Example:
 383      template<typename... Values>
 384      struct tied : tuple<Values&...> {
 385        // ...
 386      };
 387
 388    The derivation from tuple contains a TYPE_PACK_EXPANSION for the
 389    template arguments. Its PACK_EXPANSION_PATTERN is "Values&" and its
 390    PACK_EXPANSION_PARAMETER_PACKS will contain "Values".  */
 391 DEFTREECODE (TYPE_PACK_EXPANSION, "type_pack_expansion", tcc_type, 0)
 392
 393 /* Represents an expression that will be expanded into a list of
 394    expressions when instantiated with one or more argument packs.
 395
 396    EXPR_PACK_EXPANSION plays precisely the same role as TYPE_PACK_EXPANSION,
 397    but will be used for expressions.  */
 398 DEFTREECODE (EXPR_PACK_EXPANSION, "expr_pack_expansion", tcc_expression, 3)
 399
 400 /* Selects the Ith parameter out of an argument pack. This node will
 401    be used when instantiating pack expansions; see
 402    tsubst_pack_expansion.
 403
 404    ARGUMENT_PACK_SELECT_FROM_PACK contains the *_ARGUMENT_PACK node
 405    from which the argument will be selected.
 406
 407    ARGUMENT_PACK_SELECT_INDEX contains the index into the argument
 408    pack that will be returned by this ARGUMENT_PACK_SELECT node. The
 409    index is a machine integer.  */
 410 DEFTREECODE (ARGUMENT_PACK_SELECT, "argument_pack_select", tcc_exceptional, 0)
 411
 412 /* Fold expressions allow the expansion of a template argument pack
 413    over a binary operator.
 414
 415    FOLD_EXPR_MOD_P is true when the fold operation is a compound assignment
 416    operator.
 417
 418    FOLD_EXPR_OP is an INTEGER_CST storing the tree code for the folded
 419    expression. Note that when FOLDEXPR_MOD_P is true, the operator is
 420    a compound assignment operator for that kind of expression.
 421
 422    FOLD_EXPR_PACK is an expression containing an unexpanded parameter pack;
 423    when expanded, each term becomes an argument of the folded expression.
 424
 425    In a BINARY_FOLD_EXPRESSION, FOLD_EXPR_INIT is the non-pack argument. */
 426 DEFTREECODE (UNARY_LEFT_FOLD_EXPR, "unary_left_fold_expr", tcc_expression, 2)
 427 DEFTREECODE (UNARY_RIGHT_FOLD_EXPR, "unary_right_fold_expr", tcc_expression, 2)
 428 DEFTREECODE (BINARY_LEFT_FOLD_EXPR, "binary_left_fold_expr", tcc_expression, 3)
 429 DEFTREECODE (BINARY_RIGHT_FOLD_EXPR, "binary_right_fold_expr", tcc_expression, 3)
 430
 431 /* Represents the __builtin_bit_cast (type, expr) expression.
 432    The type is in TREE_TYPE, expression in TREE_OPERAND (bitcast, 0).  */
 433 DEFTREECODE (BIT_CAST_EXPR, "bit_cast_expr", tcc_expression, 1)
 434
 435 /** C++ extensions. */
 436
 437 /* Represents a templated trait that yields an expression.  */
 438 DEFTREECODE (TRAIT_EXPR, "trait_expr", tcc_exceptional, 0)
 439
 440 /* Represents a templated trait that yields a type.  */
 441 DEFTREECODE (TRAIT_TYPE, "trait_type", tcc_type, 0)
 442
 443 /* A lambda expression.  This is a C++0x extension.
 444    LAMBDA_EXPR_DEFAULT_CAPTURE_MODE is an enum for the default, which may be
 445    none.
 446    LAMBDA_EXPR_CAPTURE_LIST holds the capture-list, including `this'.
 447    LAMBDA_EXPR_THIS_CAPTURE goes straight to the capture of `this', if it exists.
 448    LAMBDA_EXPR_PENDING_PROXIES is a vector of capture proxies which need to
 449    be pushed once scope returns to the lambda.  */
 450 DEFTREECODE (LAMBDA_EXPR, "lambda_expr", tcc_exceptional, 0)
 451
 452 /* The declared type of an expression.  This is a C++0x extension.
 453    DECLTYPE_TYPE_EXPR is the expression whose type we are computing.
 454    DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P states whether the
 455    expression was parsed as an id-expression or a member access
 456    expression. When false, it was parsed as a full expression.
 457    DECLTYPE_FOR_LAMBDA_CAPTURE is set if we want lambda capture semantics.
 458    DECLTYPE_FOR_LAMBDA_RETURN is set if we want lambda return deduction.  */
 459 DEFTREECODE (DECLTYPE_TYPE, "decltype_type", tcc_type, 0)
 460
 461 /* A type designated by one of the bases type traits.
 462    BASES_TYPE is the type in question.  */
 463 DEFTREECODE (BASES, "bases", tcc_type, 0)
 464
 465 /* Dependent operator expressions are given this type rather than a NULL_TREE
 466    type so that we have somewhere to stash the result of phase 1 name lookup
 467    (namely into DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS).  */
 468 DEFTREECODE (DEPENDENT_OPERATOR_TYPE, "dependent_operator_type", tcc_type, 0)
 469
 470 /* Used to represent the template information stored by template
 471    specializations.
 472    The accessors are:
 473    TI_TEMPLATE the template declaration associated to the specialization
 474    TI_ARGS the arguments of the template specialization
 475    TI_TYPEDEFS_NEEDING_ACCESS_CHECKING the vector of typedefs used in
 476    the pattern of the template for which access check is needed at template
 477    instantiation time.  */
 478 DEFTREECODE (TEMPLATE_INFO, "template_info", tcc_exceptional, 0)
 479
 480 /* OpenMP - #pragma omp depobj
 481    Operand 0: OMP_DEPOBJ_DEPOBJ: Depobj expression
 482    Operand 1: OMP_DEPOBJ_CLAUSES: List of clauses.  */
 483 DEFTREECODE (OMP_DEPOBJ, "omp_depobj", tcc_statement, 2)
 484
 485 /* Extensions for Concepts. */
 486
 487 /* Used to represent information associated with constrained declarations. */
 488 DEFTREECODE (CONSTRAINT_INFO, "constraint_info", tcc_exceptional, 0)
 489
 490 /* A wildcard declaration is a placeholder for a template parameter
 491    used to resolve constrained-type-names in concepts.  During
 492    resolution, the matching argument is saved as the TREE_TYPE
 493    of the wildcard.  */
 494 DEFTREECODE (WILDCARD_DECL, "wildcard_decl", tcc_declaration, 0)
 495
 496 /* A requires-expr has three operands. The first operand is
 497    its parameter list (possibly NULL). The second is a list of
 498    requirements, which are denoted by the _REQ* tree codes
 499    below.  The third is a TREE_VEC of template arguments to
 500    be applied when substituting into the parameter list and
 501    requirements, set by tsubst_requires_expr for partial instantiations.  */
 502 DEFTREECODE (REQUIRES_EXPR,   "requires_expr", tcc_expression, 3)
 503
 504 /* A requirement for an expression. */
 505 DEFTREECODE (SIMPLE_REQ, "simple_req", tcc_expression, 1)
 506
 507 /* A requirement for a type. */
 508 DEFTREECODE (TYPE_REQ, "type_req", tcc_expression, 1)
 509
 510 /* A requirement for an expression and its properties. The
 511    first operand is the expression, and the 2nd is its type.
 512    The accessor COMPOUND_REQ_NOEXCEPT determines whether
 513    the noexcept keyword was present. */
 514 DEFTREECODE (COMPOUND_REQ, "compound_req", tcc_expression, 2)
 515
 516 /* A requires clause within a requires expression. */
 517 DEFTREECODE (NESTED_REQ, "nested_req", tcc_expression, 1)
 518
 519 /* Constraints are modeled as kinds of expressions.
 520    The operands of a constraint can be either types or expressions.
 521    Unlike expressions, constraints do not have a type. */
 522
 523 /* An atomic constraint evaluates an expression E. The operand of the
 524    constraint is its parameter mapping. The actual expression is stored
 525    in the context.
 526
 527    ATOMIC_CONSTR_INFO provides source info to support diagnostics.
 528    ATOMIC_CONSTR_EXPR has the expression to be evaluated.
 529    ATOMIC_CONSTR_PARMS is the parameter mapping for the atomic constraint
 530    and is stored in the type field.  */
 531 DEFTREECODE (ATOMIC_CONSTR, "atomic_constr", tcc_expression, 1)
 532
 533 /* The conjunction and disjunction of two constraints, respectively.
 534    Operands are accessed using TREE_OPERAND. The third operand provides
 535    source info for diagnostics.
 536
 537    CONJ_CONSTR_INFO and DISJ_CONSTR_INFO provide access to the source
 538    information of constraints, which is stored in the TREE_TYPE.  */
 539 DEFTREECODE (CONJ_CONSTR, "conj_constr", tcc_expression, 2)
 540 DEFTREECODE (DISJ_CONSTR, "disj_constr", tcc_expression, 2)
 541
 542 /* A check constraint represents the checking of a concept
 543    C. It has two operands: the template defining the concept
 544    and a sequence of template arguments.
 545
 546    CHECK_CONSTR_CONCEPT has the concept definition
 547    CHECK_CONSTR_ARGUMENTS are the template arguments */
 548 DEFTREECODE (CHECK_CONSTR, "check_constr", tcc_expression, 2)
 549
 550 /* The co_await expression is used to support coroutines.
 551
 552   Op 0 is the cast expresssion (potentially modified by the
 553   promise "await_transform()" method).
 554   Op1 is a proxy for the temp / coro frame slot 'e' value.
 555   Op2 is the initialiser for Op1 (Op0, potentially modified by any
 556   applicable 'co_await' operator).
 557   Op3 is a vector of the [0] e.ready, [1] e.suspend and [2] e.resume calls.
 558   Op4 is a mode : 0 (await) 1 (yield) 2 (initial) 3 (final) */
 559 DEFTREECODE (CO_AWAIT_EXPR, "co_await", tcc_expression, 5)
 560
 561 /* The co_yield expression is used to support coroutines.
 562
 563    Op0 is the original expr (for use in diagnostics)
 564    Op2 is the co_await derived from this. */
 565 DEFTREECODE (CO_YIELD_EXPR, "co_yield", tcc_expression, 2)
 566
 567 /* The co_return expression is used to support coroutines.
 568
 569    Op0 is the original expr, can be void (for use in diagnostics)
 570    Op1 is the promise return_xxxx call for for the expression given. */
 571
 572 DEFTREECODE (CO_RETURN_EXPR, "co_return", tcc_statement, 2)
 573
 574 /* Different flavors of contracts.
 575
 576    Assertions and preconditions have two operands: a node containing
 577    the their mode and condition. Postconditions have an additional
 578    operand to store the optional name for the result value.
 579
 580    CONTRACT_SEMANTIC has the computed behavior of the contract.  */
 581 DEFTREECODE (ASSERTION_STMT, "assertion_stmt", tcc_statement, 3)
 582 DEFTREECODE (PRECONDITION_STMT, "precondition_stmt", tcc_statement, 3)
 583 DEFTREECODE (POSTCONDITION_STMT, "postcondition_stmt", tcc_statement, 4)
 584
 585 /*
 586 Local variables:
 587 mode:c
 588 End:
 589 */