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 Free Software Foundation, Inc.
   6    Hacked by Michael Tiemann (tiemann@cygnus.com)
   7
   8 This file is part of GCC.
   9
  10 GCC is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2, or (at your option)
  13 any later version.
  14
  15 GCC is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GCC; see the file COPYING.  If not, write to
  22 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  23 Boston, MA 02110-1301, USA.  */
  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 /* For AGGR_INIT_EXPR, operand 0 is function which performs initialization,
  78    operand 1 is argument list to initialization function,
  79    and operand 2 is the slot which was allocated for this expression.  */
  80 DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", tcc_expression, 3)
  81
  82 /* A throw expression.  operand 0 is the expression, if there was one,
  83    else it is NULL_TREE.  */
  84 DEFTREECODE (THROW_EXPR, "throw_expr", tcc_expression, 1)
  85
  86 /* An empty class object.  The TREE_TYPE gives the class type.  We use
  87    these to avoid actually creating instances of the empty classes.  */
  88 DEFTREECODE (EMPTY_CLASS_EXPR, "empty_class_expr", tcc_expression, 0)
  89
  90 /* A reference to a member function or member functions from a base
  91    class.  BASELINK_FUNCTIONS gives the FUNCTION_DECL,
  92    TEMPLATE_DECL, OVERLOAD, or TEMPLATE_ID_EXPR corresponding to the
  93    functions.  BASELINK_BINFO gives the base from which the functions
  94    come, i.e., the base to which the `this' pointer must be converted
  95    before the functions are called.  BASELINK_ACCESS_BINFO gives the
  96    base used to name the functions.
  97
  98    A BASELINK is an expression; the TREE_TYPE of the BASELINK gives
  99    the type of the expression.  This type is either a FUNCTION_TYPE,
 100    METHOD_TYPE, or `unknown_type_node' indicating that the function is
 101    overloaded.  */
 102 DEFTREECODE (BASELINK, "baselink", tcc_exceptional, 0)
 103
 104 /* Template definition.  The following fields have the specified uses,
 105    although there are other macros in cp-tree.h that should be used for
 106    accessing this data.
 107         DECL_ARGUMENTS          template parm vector
 108         DECL_TEMPLATE_INFO      template text &c
 109         DECL_VINDEX             list of instantiations already produced;
 110                                 only done for functions so far
 111    For class template:
 112         DECL_INITIAL            associated templates (methods &c)
 113         DECL_TEMPLATE_RESULT    null
 114    For non-class templates:
 115         TREE_TYPE               type of object to be constructed
 116         DECL_TEMPLATE_RESULT    decl for object to be created
 117                                 (e.g., FUNCTION_DECL with tmpl parms used)
 118  */
 119 DEFTREECODE (TEMPLATE_DECL, "template_decl", tcc_declaration, 0)
 120
 121 /* Index into a template parameter list.  The TEMPLATE_PARM_IDX gives
 122    the index (from 0) of the parameter, while the TEMPLATE_PARM_LEVEL
 123    gives the level (from 1) of the parameter.
 124
 125    Here's an example:
 126
 127    template <class T> // Index 0, Level 1.
 128    struct S
 129    {
 130       template <class U, // Index 0, Level 2.
 131                 class V> // Index 1, Level 2.
 132       void f();
 133    };
 134
 135    The DESCENDANTS will be a chain of TEMPLATE_PARM_INDEXs descended
 136    from this one.  The first descendant will have the same IDX, but
 137    its LEVEL will be one less.  The TREE_CHAIN field is used to chain
 138    together the descendants.  The TEMPLATE_PARM_DECL is the
 139    declaration of this parameter, either a TYPE_DECL or CONST_DECL.
 140    The TEMPLATE_PARM_ORIG_LEVEL is the LEVEL of the most distant
 141    parent, i.e., the LEVEL that the parameter originally had when it
 142    was declared.  For example, if we instantiate S<int>, we will have:
 143
 144    struct S<int>
 145    {
 146      template <class U, // Index 0, Level 1, Orig Level 2
 147                class V> // Index 1, Level 1, Orig Level 2
 148      void f();
 149    };
 150
 151    The LEVEL is the level of the parameter when we are worrying about
 152    the types of things; the ORIG_LEVEL is the level when we are
 153    worrying about instantiating things.  */
 154 DEFTREECODE (TEMPLATE_PARM_INDEX, "template_parm_index", tcc_exceptional, 0)
 155
 156 /* Index into a template parameter list for template template parameters.
 157    This parameter must be a type.  The TYPE_FIELDS value will be a
 158    TEMPLATE_PARM_INDEX.
 159
 160    It is used without template arguments like TT in C<TT>,
 161    TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO is NULL_TREE
 162    and TYPE_NAME is a TEMPLATE_DECL.  */
 163 DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", tcc_type, 0)
 164
 165 /* The ordering of the following codes is optimized for the checking
 166    macros in tree.h.  Changing the order will degrade the speed of the
 167    compiler.  TEMPLATE_TYPE_PARM, TYPENAME_TYPE, TYPEOF_TYPE,
 168    BOUND_TEMPLATE_TEMPLATE_PARM.  */
 169
 170 /* Index into a template parameter list.  This parameter must be a type.
 171    The type.values field will be a TEMPLATE_PARM_INDEX.  */
 172 DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", tcc_type, 0)
 173
 174 /* A type designated by `typename T::t'.  TYPE_CONTEXT is `T',
 175    TYPE_NAME is an IDENTIFIER_NODE for `t'.  If the type was named via
 176    template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR.
 177    TREE_TYPE is always NULL.  */
 178 DEFTREECODE (TYPENAME_TYPE, "typename_type", tcc_type, 0)
 179
 180 /* A type designated by `__typeof (expr)'.  TYPEOF_TYPE_EXPR is the
 181    expression in question.  */
 182 DEFTREECODE (TYPEOF_TYPE, "typeof_type", tcc_type, 0)
 183
 184 /* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments
 185    like TT<int>.
 186    In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the
 187    template name and its bound arguments.  TYPE_NAME is a TYPE_DECL.  */
 188 DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm",
 189              tcc_type, 0)
 190
 191 /* For template template argument of the form `T::template C'.
 192    TYPE_CONTEXT is `T', the template parameter dependent object.
 193    TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template.  */
 194 DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", tcc_type, 0)
 195
 196 /* A using declaration.  USING_DECL_SCOPE contains the specified
 197    scope.  In a member using decl, unless DECL_DEPENDENT_P is true,
 198    USING_DECL_DECLS contains the _DECL or OVERLOAD so named.  This is
 199    not an alias, but is later expanded into multiple aliases.  */
 200 DEFTREECODE (USING_DECL, "using_decl", tcc_declaration, 0)
 201
 202 /* A using directive. The operand is USING_STMT_NAMESPACE.  */
 203 DEFTREECODE (USING_STMT, "using_directive", tcc_statement, 1)
 204
 205 /* An un-parsed default argument.  Holds a vector of input tokens and
 206    a vector of places where the argument was instantiated before
 207    parsing had occurred.  */
 208 DEFTREECODE (DEFAULT_ARG, "default_arg", tcc_exceptional, 0)
 209
 210 /* A template-id, like foo<int>.  The first operand is the template.
 211    The second is NULL if there are no explicit arguments, or a
 212    TREE_VEC of arguments.  The template will be a FUNCTION_DECL,
 213    TEMPLATE_DECL, or an OVERLOAD.  If the template-id refers to a
 214    member template, the template may be an IDENTIFIER_NODE.  */
 215 DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", tcc_expression, 2)
 216
 217 /* A list-like node for chaining overloading candidates. TREE_TYPE is
 218    the original name, and the parameter is the FUNCTION_DECL.  */
 219 DEFTREECODE (OVERLOAD, "overload", tcc_exceptional, 0)
 220
 221 /* A pseudo-destructor, of the form "OBJECT.~DESTRUCTOR" or
 222    "OBJECT.SCOPE::~DESTRUCTOR.  The first operand is the OBJECT.  The
 223    second operand (if non-NULL) is the SCOPE.  The third operand is
 224    the TYPE node corresponding to the DESTRUCTOR.  The type of the
 225    first operand will always be a scalar type.
 226
 227    The type of a PSEUDO_DTOR_EXPR is always "void", even though it can
 228    be used as if it were a zero-argument function.  We handle the
 229    function-call case specially, and giving it "void" type prevents it
 230    being used in expressions in ways that are not permitted.  */
 231 DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", tcc_expression, 3)
 232
 233 /* A whole bunch of tree codes for the initial, superficial parsing of
 234    templates.  */
 235 DEFTREECODE (MODOP_EXPR, "modop_expr", tcc_expression, 3)
 236 DEFTREECODE (CAST_EXPR, "cast_expr", tcc_unary, 1)
 237 DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", tcc_unary, 1)
 238 DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", tcc_unary, 1)
 239 DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", tcc_unary, 1)
 240 DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", tcc_unary, 1)
 241 DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", tcc_expression, 2)
 242 DEFTREECODE (TYPEID_EXPR, "typeid_expr", tcc_expression, 1)
 243
 244 /* A placeholder for an expression that is not type-dependent, but
 245    does occur in a template.  When an expression that is not
 246    type-dependent appears in a larger expression, we must compute the
 247    type of that larger expression.  That computation would normally
 248    modify the original expression, which would change the mangling of
 249    that expression if it appeared in a template argument list.  In
 250    that situation, we create a NON_DEPENDENT_EXPR to take the place of
 251    the original expression.  The expression is the only operand -- it
 252    is only needed for diagnostics.  */
 253 DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", tcc_expression, 1)
 254
 255 /* CTOR_INITIALIZER is a placeholder in template code for a call to
 256    setup_vtbl_pointer (and appears in all functions, not just ctors).  */
 257 DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", tcc_expression, 1)
 258
 259 DEFTREECODE (TRY_BLOCK, "try_block", tcc_statement, 2)
 260
 261 DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", tcc_statement, 2)
 262
 263 /* A HANDLER wraps a catch handler for the HANDLER_TYPE.  If this is
 264    CATCH_ALL_TYPE, then the handler catches all types.  The declaration of
 265    the catch variable is in HANDLER_PARMS, and the body block in
 266    HANDLER_BODY.  */
 267 DEFTREECODE (HANDLER, "handler", tcc_statement, 2)
 268
 269 /* A MUST_NOT_THROW_EXPR wraps an expression that may not
 270    throw, and must call terminate if it does.  */
 271 DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", tcc_expression, 1)
 272
 273 /* A CLEANUP_STMT marks the point at which a declaration is fully
 274    constructed.  The CLEANUP_EXPR is run on behalf of CLEANUP_DECL
 275    when CLEANUP_BODY completes.  */
 276 DEFTREECODE (CLEANUP_STMT, "cleanup_stmt", tcc_statement, 3)
 277
 278 /* Represents an 'if' statement. The operands are IF_COND,
 279    THEN_CLAUSE, and ELSE_CLAUSE, respectively.  */
 280 /* ??? It is currently still necessary to distinguish between IF_STMT
 281    and COND_EXPR for the benefit of templates.  */
 282 DEFTREECODE (IF_STMT, "if_stmt", tcc_statement, 3)
 283
 284 /* Used to represent a `for' statement. The operands are
 285    FOR_INIT_STMT, FOR_COND, FOR_EXPR, and FOR_BODY, respectively.  */
 286 DEFTREECODE (FOR_STMT, "for_stmt", tcc_statement, 4)
 287
 288 /* Used to represent a 'while' statement. The operands are WHILE_COND
 289    and WHILE_BODY, respectively.  */
 290 DEFTREECODE (WHILE_STMT, "while_stmt", tcc_statement, 2)
 291
 292 /* Used to represent a 'do' statement. The operands are DO_BODY and
 293    DO_COND, respectively.  */
 294 DEFTREECODE (DO_STMT, "do_stmt", tcc_statement, 2)
 295
 296 /* Used to represent a 'break' statement.  */
 297 DEFTREECODE (BREAK_STMT, "break_stmt", tcc_statement, 0)
 298
 299 /* Used to represent a 'continue' statement.  */
 300 DEFTREECODE (CONTINUE_STMT, "continue_stmt", tcc_statement, 0)
 301
 302 /* Used to represent a 'switch' statement. The operands are
 303    SWITCH_STMT_COND, SWITCH_STMT_BODY and SWITCH_STMT_TYPE, respectively.  */
 304 DEFTREECODE (SWITCH_STMT, "switch_stmt", tcc_statement, 3)
 305
 306 /* Used to represent an expression statement.  Use `EXPR_STMT_EXPR' to
 307    obtain the expression.  */
 308 DEFTREECODE (EXPR_STMT, "expr_stmt", tcc_expression, 1)
 309
 310 DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0)
 311
 312 /* Template instantiation level node.
 313
 314    TINST_DECL contains the original DECL node.
 315    TINST_LOCATION contains the location where the template is instantiated.
 316    TINST_IN_SYSTEM_HEADER_P is true if the location is in a system header.
 317
 318    A stack of template instantiation nodes is kept through the TREE_CHAIN
 319    fields of these nodes.  */
 320
 321 DEFTREECODE (TINST_LEVEL, "TINST_LEVEL", tcc_exceptional, 0)
 322
 323 /* Represents an 'offsetof' expression during template expansion.  */
 324 DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 1)
 325
 326 /* Represents a 'sizeof' expression during template expansion.  */
 327 DEFTREECODE (SIZEOF_EXPR, "sizeof_expr", tcc_expression, 1)
 328
 329 /* Represents the -> operator during template expansion.  */
 330 DEFTREECODE (ARROW_EXPR, "arrow_expr", tcc_expression, 1)
 331
 332 /* Represents an '__alignof__' expression during template
 333    expansion.  */
 334 DEFTREECODE (ALIGNOF_EXPR, "alignof_expr", tcc_expression, 1)
 335
 336 /* A STMT_EXPR represents a statement-expression during template
 337    expansion.  This is the GCC extension { ( ... ) }.  The
 338    STMT_EXPR_STMT is the statement given by the expression.  */
 339 DEFTREECODE (STMT_EXPR, "stmt_expr", tcc_expression, 1)
 340
 341 /* Unary plus. Operand 0 is the expression to which the unary plus
 342    is applied.  */
 343 DEFTREECODE (UNARY_PLUS_EXPR, "unary_plus_expr", tcc_unary, 1)
 344
 345 /*
 346 Local variables:
 347 mode:c
 348 End:
 349 */