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,
   5    1999, 2000, 2001, 2002, 2003 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, 59 Temple Place - Suite 330,
  23 Boston, MA 02111-1307, 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 data member.  In this case, operand 0 will be a
  30       TYPE (corresponding to `A') and operand 1 will be a FIELD_DECL
  31       (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 isnot
  35       taken.  In the latter case, resolve_offset_ref is used to
  36       convert it to a representation of the member referred to by the
  37       OFFSET_REF.
  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
  43    OFFSET_REFs are only used during the parsing phase; once semantic
  44    analysis has taken place they are eliminated.  */
  45 DEFTREECODE (OFFSET_REF, "offset_ref", 'r', 2)
  46
  47 /* A pointer-to-member constant.  For a pointer-to-member constant
  48    `X::Y' The PTRMEM_CST_CLASS is the RECORD_TYPE for `X' and the
  49    PTRMEM_CST_MEMBER is the _DECL for `Y'.  */
  50 DEFTREECODE (PTRMEM_CST, "ptrmem_cst", 'c', 2)
  51
  52 /* For NEW_EXPR, operand 0 is the placement list.
  53    Operand 1 is the new-declarator.
  54    Operand 2 is the initializer.  */
  55 DEFTREECODE (NEW_EXPR, "nw_expr", 'e', 3)
  56 DEFTREECODE (VEC_NEW_EXPR, "vec_nw_expr", 'e', 3)
  57
  58 /* For DELETE_EXPR, operand 0 is the store to be destroyed.
  59    Operand 1 is the value to pass to the destroying function
  60    saying whether the store should be deallocated as well.  */
  61 DEFTREECODE (DELETE_EXPR, "dl_expr", 'e', 2)
  62 DEFTREECODE (VEC_DELETE_EXPR, "vec_dl_expr", 'e', 2)
  63
  64 /* Value is reference to particular overloaded class method.
  65    Operand 0 is the class name (an IDENTIFIER_NODE);
  66    operand 1 is the field (also an IDENTIFIER_NODE).
  67    The COMPLEXITY field holds the class level (usually 0).  */
  68 DEFTREECODE (SCOPE_REF, "scope_ref", 'r', 2)
  69
  70 /* When composing an object with a member, this is the result.
  71    Operand 0 is the object.  Operand 1 is the member (usually
  72    a dereferenced pointer to member).  */
  73 DEFTREECODE (MEMBER_REF, "member_ref", 'r', 2)
  74
  75 /* Type conversion operator in C++.  TREE_TYPE is type that this
  76    operator converts to.  Operand is expression to be converted.  */
  77 DEFTREECODE (TYPE_EXPR, "type_expr", 'e', 1)
  78
  79 /* For AGGR_INIT_EXPR, operand 0 is function which performs initialization,
  80    operand 1 is argument list to initialization function,
  81    and operand 2 is the slot which was allocated for this expression.  */
  82 DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", 'e', 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", 'e', 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", 'e', 0)
  91
  92 /* A DECL which is really just a placeholder for an expression.  Used to
  93    implement non-class scope anonymous unions.  */
  94 DEFTREECODE (ALIAS_DECL, "alias_decl", 'd', 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", 'x', 3)
 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", 'd', 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", 'x',
 161              /* The addition of (sizeof(tree) - 1) in the next expression
 162                 is to handle the case when padding pushes us past an even
 163                 multiple of sizeof(tree).  */
 164              /* We used to try to calculate this using
 165                 1+3*sizeof(HOST_WIDE_INT), but that fails if alignment
 166                 makes it bigger.  */
 167              ((sizeof (template_parm_index) - sizeof (struct tree_common))
 168               + sizeof (tree) - 1)
 169              / sizeof (tree))
 170
 171 /* Index into a template parameter list.  This parameter must be a type.
 172    The TYPE_FIELDS value will be a TEMPLATE_PARM_INDEX.  */
 173 DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", 't', 0)
 174
 175 /* Index into a template parameter list for template template parameters.
 176    This parameter must be a type.  The TYPE_FIELDS value will be a
 177    TEMPLATE_PARM_INDEX.
 178
 179    It is used without template arguments like TT in C<TT>,
 180    TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO is NULL_TREE
 181    and TYPE_NAME is a TEMPLATE_DECL.  */
 182 DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", 't', 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", 't', 0)
 189
 190 /* A type designated by `typename T::t'.  TYPE_CONTEXT is `T',
 191    TYPE_NAME is an IDENTIFIER_NODE for `t'.  If the type was named via
 192    template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR.
 193    If TREE_TYPE is present, this type was generated by the implicit
 194    typename extension, and the TREE_TYPE is a _TYPE from a baseclass
 195    of `T'.  */
 196 DEFTREECODE (TYPENAME_TYPE, "typename_type", 't', 0)
 197
 198 /* For template template argument of the form `T::template C'.
 199    TYPE_CONTEXT is `T', the template parameter dependent object.
 200    TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template.  */
 201 DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", 't', 0)
 202
 203 /* A type designated by `__typeof (expr)'.  TYPE_FIELDS is the
 204    expression in question.  */
 205 DEFTREECODE (TYPEOF_TYPE, "typeof_type", 't', 0)
 206
 207 /* A using declaration.  DECL_INITIAL contains the specified scope.
 208    This is not an alias, but is later expanded into multiple aliases.  */
 209 DEFTREECODE (USING_DECL, "using_decl", 'd', 0)
 210
 211 /* A using directive. The operand is USING_STMT_NAMESPACE. */
 212 DEFTREECODE (USING_STMT, "using_directive", 'e', 1)
 213
 214 /* An un-parsed default argument.  Looks like an IDENTIFIER_NODE.  */
 215 DEFTREECODE (DEFAULT_ARG, "default_arg", 'x', 2)
 216
 217 /* A template-id, like foo<int>.  The first operand is the template.
 218    The second is the TREE_LIST or TREE_VEC of explicitly specified
 219    arguments.  The template will be a FUNCTION_DECL, TEMPLATE_DECL, or
 220    an OVERLOAD.  If the template-id refers to a member template, the
 221    template may be an IDENTIFIER_NODE.  In an uninstantiated template,
 222    the template may be a LOOKUP_EXPR.  */
 223 DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", 'e', 2)
 224
 225 /* A list-like node for chaining overloading candidates. TREE_TYPE is
 226    the original name, and the parameter is the FUNCTION_DECL.  */
 227 DEFTREECODE (OVERLOAD, "overload", 'x', 1)
 228
 229 /* A generic wrapper for something not tree that we want to include in
 230    tree structure.  */
 231 DEFTREECODE (WRAPPER, "wrapper", 'x', 1)
 232
 233 /* Used to represent deferred name lookup for dependent names while
 234    parsing a template declaration.  The first argument is an
 235    IDENTIFIER_NODE for the name in question.  The TREE_TYPE is
 236    unused.  */
 237 DEFTREECODE (LOOKUP_EXPR, "lookup_expr", 'e', 1)
 238
 239 /* A whole bunch of tree codes for the initial, superficial parsing of
 240    templates.  */
 241 DEFTREECODE (MODOP_EXPR, "modop_expr", 'e', 3)
 242 DEFTREECODE (CAST_EXPR, "cast_expr", '1', 1)
 243 DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", '1', 1)
 244 DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", '1', 1)
 245 DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", '1', 1)
 246 DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", '1', 1)
 247 DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", 'e', 2)
 248 DEFTREECODE (TYPEID_EXPR, "typeid_expr", 'e', 1)
 249 DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", 'e', 3)
 250
 251 /* CTOR_INITIALIZER is a placeholder in template code for a call to
 252    setup_vtbl_pointer (and appears in all functions, not just ctors).  */
 253 DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", 'e', 1)
 254 DEFTREECODE (TRY_BLOCK, "try_block", 'e', 2)
 255 DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", 'e', 2)
 256 /* A HANDLER wraps a catch handler for the HANDLER_TYPE.  If this is
 257    CATCH_ALL_TYPE, then the handler catches all types.  The declaration of
 258    the catch variable is in HANDLER_PARMS, and the body block in
 259    HANDLER_BODY.  */
 260 DEFTREECODE (HANDLER, "handler", 'e', 2)
 261
 262 /* A MUST_NOT_THROW_EXPR wraps an expression that may not
 263    throw, and must call terminate if it does.  */
 264 DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", 'e', 1)
 265
 266 DEFTREECODE (TAG_DEFN, "tag_defn", 'e', 0)
 267
 268 /* The following codes are used to represent implicit conversion
 269    sequences, in the sense of [over.best.ics].  The conversion
 270    sequences are connected through their first operands, with the
 271    first conversion to be performed at the end of the chain.
 272
 273    The innermost conversion (i.e, the one at the end of the chain) is
 274    always an IDENTITY_CONV, corresponding to the identity conversion.  */
 275
 276 DEFTREECODE (IDENTITY_CONV, "identity_conv", 'e', 1)
 277 DEFTREECODE (LVALUE_CONV, "lvalue_conv", 'e', 1)
 278 DEFTREECODE (QUAL_CONV, "qual_conv", 'e', 1)
 279 DEFTREECODE (STD_CONV, "std_conv", 'e', 1)
 280 DEFTREECODE (PTR_CONV, "ptr_conv", 'e', 1)
 281 DEFTREECODE (PMEM_CONV, "pmem_conv", 'e', 1)
 282 DEFTREECODE (BASE_CONV, "base_conv", 'e', 1)
 283 DEFTREECODE (REF_BIND, "ref_bind", 'e', 1)
 284 DEFTREECODE (USER_CONV, "user_conv", 'e', 2)
 285 DEFTREECODE (AMBIG_CONV, "ambig_conv", 'e', 1)
 286 DEFTREECODE (RVALUE_CONV, "rvalue_conv", 'e', 1)
 287
 288 /*
 289 Local variables:
 290 mode:c
 291 End:
 292 */