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, 1988, 1990, 1993, 1997, 1998, 2003, 2004, 2005,
   5    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
   6    Free Software Foundation, Inc.
   7    Hacked by Michael Tiemann (tiemann@cygnus.com)
   8
   9 This file is part of GCC.
  10
  11 GCC is free software; you can redistribute it and/or modify
  12 it under the terms of the GNU General Public License as published by
  13 the Free Software Foundation; either version 3, or (at your option)
  14 any later version.
  15
  16 GCC is distributed in the hope that it will be useful,
  17 but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 GNU General Public License for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with GCC; see the file COPYING3.  If not see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25
  26 /* An OFFSET_REF is used in two situations:
  27
  28    1. An expression of the form `A::m' where `A' is a class and `m' is
  29       a non-static member.  In this case, operand 0 will be a TYPE
  30       (corresponding to `A') and operand 1 will be a FIELD_DECL,
  31       BASELINK, or TEMPLATE_ID_EXPR (corresponding to `m').
  32
  33       The expression is a pointer-to-member if its address is taken,
  34       but simply denotes a member of the object if its address is not
  35       taken.
  36
  37       This form is only used during the parsing phase; once semantic
  38       analysis has taken place they are eliminated.
  39
  40    2. An expression of the form `x.*p'.  In this case, operand 0 will
  41       be an expression corresponding to `x' and operand 1 will be an
  42       expression with pointer-to-member type.  */
  43 DEFTREECODE (OFFSET_REF, "offset_ref", tcc_reference, 2)
  44
  45 /* A pointer-to-member constant.  For a pointer-to-member constant
  46    `X::Y' The PTRMEM_CST_CLASS is the RECORD_TYPE for `X' and the
  47    PTRMEM_CST_MEMBER is the _DECL for `Y'.  */
  48 DEFTREECODE (PTRMEM_CST, "ptrmem_cst", tcc_constant, 0)
  49
  50 /* For NEW_EXPR, operand 0 is the placement list.
  51    Operand 1 is the new-declarator.
  52    Operand 2 is the number of elements in the array.
  53    Operand 3 is the initializer.  */
  54 DEFTREECODE (NEW_EXPR, "nw_expr", tcc_expression, 4)
  55 DEFTREECODE (VEC_NEW_EXPR, "vec_nw_expr", tcc_expression, 3)
  56
  57 /* For DELETE_EXPR, operand 0 is the store to be destroyed.
  58    Operand 1 is the value to pass to the destroying function
  59    saying whether the store should be deallocated as well.  */
  60 DEFTREECODE (DELETE_EXPR, "dl_expr", tcc_expression, 2)
  61 DEFTREECODE (VEC_DELETE_EXPR, "vec_dl_expr", tcc_expression, 2)
  62
  63 /* Value is reference to particular overloaded class method.
  64    Operand 0 is the class, operand 1 is the field
  65    The COMPLEXITY field holds the class level (usually 0).  */
  66 DEFTREECODE (SCOPE_REF, "scope_ref", tcc_reference, 2)
  67
  68 /* When composing an object with a member, this is the result.
  69    Operand 0 is the object.  Operand 1 is the member (usually
  70    a dereferenced pointer to member).  */
  71 DEFTREECODE (MEMBER_REF, "member_ref", tcc_reference, 2)
  72
  73 /* Type conversion operator in C++.  TREE_TYPE is type that this
  74    operator converts to.  Operand is expression to be converted.  */
  75 DEFTREECODE (TYPE_EXPR, "type_expr", tcc_expression, 1)
  76
  77 /* AGGR_INIT_EXPRs have a variably-sized representation similar to
  78    that of CALL_EXPRs.  Operand 0 is an INTEGER_CST node containing the
  79    operand count, operand 1 is the function which performs initialization,
  80    operand 2 is the slot which was allocated for this expression, and
  81    the remaining operands are the arguments to the initialization function.  */
  82 DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", tcc_vl_exp, 3)
  83
  84 /* A throw expression.  operand 0 is the expression, if there was one,
  85    else it is NULL_TREE.  */
  86 DEFTREECODE (THROW_EXPR, "throw_expr", tcc_expression, 1)
  87
  88 /* An empty class object.  The TREE_TYPE gives the class type.  We use
  89    these to avoid actually creating instances of the empty classes.  */
  90 DEFTREECODE (EMPTY_CLASS_EXPR, "empty_class_expr", tcc_expression, 0)
  91
  92 /* A reference to a member function or member functions from a base
  93    class.  BASELINK_FUNCTIONS gives the FUNCTION_DECL,
  94    TEMPLATE_DECL, OVERLOAD, or TEMPLATE_ID_EXPR corresponding to the
  95    functions.  BASELINK_BINFO gives the base from which the functions
  96    come, i.e., the base to which the `this' pointer must be converted
  97    before the functions are called.  BASELINK_ACCESS_BINFO gives the
  98    base used to name the functions.
  99
 100    A BASELINK is an expression; the TREE_TYPE of the BASELINK gives
 101    the type of the expression.  This type is either a FUNCTION_TYPE,
 102    METHOD_TYPE, or `unknown_type_node' indicating that the function is
 103    overloaded.  */
 104 DEFTREECODE (BASELINK, "baselink", tcc_exceptional, 0)
 105
 106 /* Template definition.  The following fields have the specified uses,
 107    although there are other macros in cp-tree.h that should be used for
 108    accessing this data.
 109         DECL_ARGUMENTS          template parm vector
 110         DECL_TEMPLATE_INFO      template text &c
 111         DECL_VINDEX             list of instantiations already produced;
 112                                 only done for functions so far
 113    For class template:
 114         DECL_INITIAL            associated templates (methods &c)
 115         DECL_TEMPLATE_RESULT    null
 116    For non-class templates:
 117         TREE_TYPE               type of object to be constructed
 118         DECL_TEMPLATE_RESULT    decl for object to be created
 119                                 (e.g., FUNCTION_DECL with tmpl parms used)
 120  */
 121 DEFTREECODE (TEMPLATE_DECL, "template_decl", tcc_declaration, 0)
 122
 123 /* Index into a template parameter list.  The TEMPLATE_PARM_IDX gives
 124    the index (from 0) of the parameter, while the TEMPLATE_PARM_LEVEL
 125    gives the level (from 1) of the parameter.
 126
 127    Here's an example:
 128
 129    template <class T> // Index 0, Level 1.
 130    struct S
 131    {
 132       template <class U, // Index 0, Level 2.
 133                 class V> // Index 1, Level 2.
 134       void f();
 135    };
 136
 137    The DESCENDANTS will be a chain of TEMPLATE_PARM_INDEXs descended
 138    from this one.  The first descendant will have the same IDX, but
 139    its LEVEL will be one less.  The TREE_CHAIN field is used to chain
 140    together the descendants.  The TEMPLATE_PARM_DECL is the
 141    declaration of this parameter, either a TYPE_DECL or CONST_DECL.
 142    The TEMPLATE_PARM_ORIG_LEVEL is the LEVEL of the most distant
 143    parent, i.e., the LEVEL that the parameter originally had when it
 144    was declared.  For example, if we instantiate S<int>, we will have:
 145
 146    struct S<int>
 147    {
 148      template <class U, // Index 0, Level 1, Orig Level 2
 149                class V> // Index 1, Level 1, Orig Level 2
 150      void f();
 151    };
 152
 153    The LEVEL is the level of the parameter when we are worrying about
 154    the types of things; the ORIG_LEVEL is the level when we are
 155    worrying about instantiating things.  */
 156 DEFTREECODE (TEMPLATE_PARM_INDEX, "template_parm_index", tcc_exceptional, 0)
 157
 158 /* Index into a template parameter list for template template parameters.
 159    This parameter must be a type.  The TYPE_FIELDS value will be a
 160    TEMPLATE_PARM_INDEX.
 161
 162    It is used without template arguments like TT in C<TT>,
 163    TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO is NULL_TREE
 164    and TYPE_NAME is a TEMPLATE_DECL.  */
 165 DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", tcc_type, 0)
 166
 167 /* The ordering of the following codes is optimized for the checking
 168    macros in tree.h.  Changing the order will degrade the speed of the
 169    compiler.  TEMPLATE_TYPE_PARM, TYPENAME_TYPE, TYPEOF_TYPE,
 170    BOUND_TEMPLATE_TEMPLATE_PARM.  */
 171
 172 /* Index into a template parameter list.  This parameter must be a type.
 173    The type.values field will be a TEMPLATE_PARM_INDEX.  */
 174 DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", tcc_type, 0)
 175
 176 /* A type designated by `typename T::t'.  TYPE_CONTEXT is `T',
 177    TYPE_NAME is an IDENTIFIER_NODE for `t'.  If the type was named via
 178    template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR.
 179    TREE_TYPE is always NULL.  */
 180 DEFTREECODE (TYPENAME_TYPE, "typename_type", tcc_type, 0)
 181
 182 /* A type designated by `__typeof (expr)'.  TYPEOF_TYPE_EXPR is the
 183    expression in question.  */
 184 DEFTREECODE (TYPEOF_TYPE, "typeof_type", tcc_type, 0)
 185
 186 /* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments
 187    like TT<int>.
 188    In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the
 189    template name and its bound arguments.  TYPE_NAME is a TYPE_DECL.  */
 190 DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm",
 191              tcc_type, 0)
 192
 193 /* For template template argument of the form `T::template C'.
 194    TYPE_CONTEXT is `T', the template parameter dependent object.
 195    TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template.  */
 196 DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", tcc_type, 0)
 197
 198 /* A using declaration.  USING_DECL_SCOPE contains the specified
 199    scope.  In a member using decl, unless DECL_DEPENDENT_P is true,
 200    USING_DECL_DECLS contains the _DECL or OVERLOAD so named.  This is
 201    not an alias, but is later expanded into multiple aliases.  */
 202 DEFTREECODE (USING_DECL, "using_decl", tcc_declaration, 0)
 203
 204 /* A using directive. The operand is USING_STMT_NAMESPACE.  */
 205 DEFTREECODE (USING_STMT, "using_directive", tcc_statement, 1)
 206
 207 /* An un-parsed default argument.  Holds a vector of input tokens and
 208    a vector of places where the argument was instantiated before
 209    parsing had occurred.  */
 210 DEFTREECODE (DEFAULT_ARG, "default_arg", tcc_exceptional, 0)
 211
 212 /* A template-id, like foo<int>.  The first operand is the template.
 213    The second is NULL if there are no explicit arguments, or a
 214    TREE_VEC of arguments.  The template will be a FUNCTION_DECL,
 215    TEMPLATE_DECL, or an OVERLOAD.  If the template-id refers to a
 216    member template, the template may be an IDENTIFIER_NODE.  */
 217 DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", tcc_expression, 2)
 218
 219 /* A list-like node for chaining overloading candidates. TREE_TYPE is
 220    the original name, and the parameter is the FUNCTION_DECL.  */
 221 DEFTREECODE (OVERLOAD, "overload", tcc_exceptional, 0)
 222
 223 /* A pseudo-destructor, of the form "OBJECT.~DESTRUCTOR" or
 224    "OBJECT.SCOPE::~DESTRUCTOR.  The first operand is the OBJECT.  The
 225    second operand (if non-NULL) is the SCOPE.  The third operand is
 226    the TYPE node corresponding to the DESTRUCTOR.  The type of the
 227    first operand will always be a scalar type.
 228
 229    The type of a PSEUDO_DTOR_EXPR is always "void", even though it can
 230    be used as if it were a zero-argument function.  We handle the
 231    function-call case specially, and giving it "void" type prevents it
 232    being used in expressions in ways that are not permitted.  */
 233 DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", tcc_expression, 3)
 234
 235 /* A whole bunch of tree codes for the initial, superficial parsing of
 236    templates.  */
 237 DEFTREECODE (MODOP_EXPR, "modop_expr", tcc_expression, 3)
 238 DEFTREECODE (CAST_EXPR, "cast_expr", tcc_unary, 1)
 239 DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", tcc_unary, 1)
 240 DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", tcc_unary, 1)
 241 DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", tcc_unary, 1)
 242 DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", tcc_unary, 1)
 243 DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", tcc_expression, 2)
 244 DEFTREECODE (TYPEID_EXPR, "typeid_expr", tcc_expression, 1)
 245
 246 /* A placeholder for an expression that is not type-dependent, but
 247    does occur in a template.  When an expression that is not
 248    type-dependent appears in a larger expression, we must compute the
 249    type of that larger expression.  That computation would normally
 250    modify the original expression, which would change the mangling of
 251    that expression if it appeared in a template argument list.  In
 252    that situation, we create a NON_DEPENDENT_EXPR to take the place of
 253    the original expression.  The expression is the only operand -- it
 254    is only needed for diagnostics.  */
 255 DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", tcc_expression, 1)
 256
 257 /* CTOR_INITIALIZER is a placeholder in template code for a call to
 258    setup_vtbl_pointer (and appears in all functions, not just ctors).  */
 259 DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", tcc_expression, 1)
 260
 261 DEFTREECODE (TRY_BLOCK, "try_block", tcc_statement, 2)
 262
 263 DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", tcc_statement, 2)
 264
 265 /* A HANDLER wraps a catch handler for the HANDLER_TYPE.  If this is
 266    CATCH_ALL_TYPE, then the handler catches all types.  The declaration of
 267    the catch variable is in HANDLER_PARMS, and the body block in
 268    HANDLER_BODY.  */
 269 DEFTREECODE (HANDLER, "handler", tcc_statement, 2)
 270
 271 /* A MUST_NOT_THROW_EXPR wraps an expression that may not
 272    throw, and must call terminate if it does.  */
 273 DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", tcc_expression, 1)
 274
 275 /* A CLEANUP_STMT marks the point at which a declaration is fully
 276    constructed.  The CLEANUP_EXPR is run on behalf of CLEANUP_DECL
 277    when CLEANUP_BODY completes.  */
 278 DEFTREECODE (CLEANUP_STMT, "cleanup_stmt", tcc_statement, 3)
 279
 280 /* Represents an 'if' statement. The operands are IF_COND,
 281    THEN_CLAUSE, and ELSE_CLAUSE, respectively.  */
 282 /* ??? It is currently still necessary to distinguish between IF_STMT
 283    and COND_EXPR for the benefit of templates.  */
 284 DEFTREECODE (IF_STMT, "if_stmt", tcc_statement, 3)
 285
 286 /* Used to represent a `for' statement. The operands are
 287    FOR_INIT_STMT, FOR_COND, FOR_EXPR, and FOR_BODY, respectively.  */
 288 DEFTREECODE (FOR_STMT, "for_stmt", tcc_statement, 4)
 289
 290 /* Used to represent a 'while' statement. The operands are WHILE_COND
 291    and WHILE_BODY, respectively.  */
 292 DEFTREECODE (WHILE_STMT, "while_stmt", tcc_statement, 2)
 293
 294 /* Used to represent a 'do' statement. The operands are DO_BODY and
 295    DO_COND, respectively.  */
 296 DEFTREECODE (DO_STMT, "do_stmt", tcc_statement, 2)
 297
 298 /* Used to represent a 'break' statement.  */
 299 DEFTREECODE (BREAK_STMT, "break_stmt", tcc_statement, 0)
 300
 301 /* Used to represent a 'continue' statement.  */
 302 DEFTREECODE (CONTINUE_STMT, "continue_stmt", tcc_statement, 0)
 303
 304 /* Used to represent a 'switch' statement. The operands are
 305    SWITCH_STMT_COND, SWITCH_STMT_BODY and SWITCH_STMT_TYPE, respectively.  */
 306 DEFTREECODE (SWITCH_STMT, "switch_stmt", tcc_statement, 3)
 307
 308 /* Used to represent an expression statement.  Use `EXPR_STMT_EXPR' to
 309    obtain the expression.  */
 310 DEFTREECODE (EXPR_STMT, "expr_stmt", tcc_expression, 1)
 311
 312 DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0)
 313
 314 /* Represents an 'offsetof' expression during template expansion.  */
 315 DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 1)
 316
 317 /* Represents a 'sizeof' expression during template expansion.  */
 318 DEFTREECODE (SIZEOF_EXPR, "sizeof_expr", tcc_expression, 1)
 319
 320 /* Represents the -> operator during template expansion.  */
 321 DEFTREECODE (ARROW_EXPR, "arrow_expr", tcc_expression, 1)
 322
 323 /* Represents an '__alignof__' expression during template
 324    expansion.  */
 325 DEFTREECODE (ALIGNOF_EXPR, "alignof_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++0x extensions. */
 337
 338 /* A static assertion.  This is a C++0x 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    SET_PACK_EXPANSION_PATTERN sets the expansion pattern.
 380
 381    PACK_EXPANSION_PARAMETER_PACKS contains a TREE_LIST of the parameter
 382    packs that are used in this pack expansion.
 383
 384    Example:
 385      template<typename... Values>
 386      struct tied : tuple<Values&...> {
 387        // ...
 388      };
 389
 390    The derivation from tuple contains a TYPE_PACK_EXPANSION for the
 391    template arguments. Its EXPR_PACK_EXPANSION is "Values&" and its
 392    PACK_EXPANSION_PARAMETER_PACKS will contain "Values".  */
 393 DEFTREECODE (TYPE_PACK_EXPANSION, "type_pack_expansion", tcc_type, 0)
 394
 395 /* Represents an expression that will be expanded into a list of
 396    expressions when instantiated with one or more argument packs.
 397
 398    EXPR_PACK_EXPANSION plays precisely the same role as TYPE_PACK_EXPANSION,
 399    but will be used for expressions.  */
 400 DEFTREECODE (EXPR_PACK_EXPANSION, "expr_pack_expansion", tcc_expression, 1)
 401
 402 /* Selects the Ith parameter out of an argument pack. This node will
 403    be used when instantiating pack expansions; see
 404    tsubst_pack_expansion.
 405
 406    ARGUMENT_PACK_SELECT_FROM_PACK contains the *_ARGUMENT_PACK node
 407    from which the argument will be selected.
 408
 409    ARGUMENT_PACK_SELECT_INDEX contains the index into the argument
 410    pack that will be returned by this ARGUMENT_PACK_SELECT node. The
 411    index is a machine integer.  */
 412 DEFTREECODE (ARGUMENT_PACK_SELECT, "argument_pack_select", tcc_exceptional, 0)
 413
 414 /** C++ extensions. */
 415
 416 /* Represents a trait expression during template expansion.  */
 417 DEFTREECODE (TRAIT_EXPR, "trait_expr", tcc_exceptional, 0)
 418
 419 /* The declared type of an expression.  This is a C++0x extension.
 420    DECLTYPE_TYPE_EXPR is the expression whose type we are computing.
 421    DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P states whether the
 422    expression was parsed as an id-expression or a member access
 423    expression. When false, it was parsed as a full expression.  */
 424 DEFTREECODE (DECLTYPE_TYPE, "decltype_type", tcc_type, 0)
 425
 426 /*
 427 Local variables:
 428 mode:c
 429 End:
 430 */