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,
   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 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 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       This form is only used during the parsing phase; once semantic
  40       analysis has taken place they are eliminated.
  41
  42    2. An expression of the form `x.*p'.  In this case, operand 0 will
  43       be an expression corresponding to `x' and operand 1 will be an
  44       expression with pointer-to-member type.  */
  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', 0)
  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, operand 1 is the field
  66    The COMPLEXITY field holds the class level (usually 0).  */
  67 DEFTREECODE (SCOPE_REF, "scope_ref", 'r', 2)
  68
  69 /* When composing an object with a member, this is the result.
  70    Operand 0 is the object.  Operand 1 is the member (usually
  71    a dereferenced pointer to member).  */
  72 DEFTREECODE (MEMBER_REF, "member_ref", 'r', 2)
  73
  74 /* Type conversion operator in C++.  TREE_TYPE is type that this
  75    operator converts to.  Operand is expression to be converted.  */
  76 DEFTREECODE (TYPE_EXPR, "type_expr", 'e', 1)
  77
  78 /* For AGGR_INIT_EXPR, operand 0 is function which performs initialization,
  79    operand 1 is argument list to initialization function,
  80    and operand 2 is the slot which was allocated for this expression.  */
  81 DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", 'e', 3)
  82
  83 /* A throw expression.  operand 0 is the expression, if there was one,
  84    else it is NULL_TREE.  */
  85 DEFTREECODE (THROW_EXPR, "throw_expr", 'e', 1)
  86
  87 /* An empty class object.  The TREE_TYPE gives the class type.  We use
  88    these to avoid actually creating instances of the empty classes.  */
  89 DEFTREECODE (EMPTY_CLASS_EXPR, "empty_class_expr", 'e', 0)
  90
  91 /* A DECL which is really just a placeholder for an expression.  Used to
  92    implement non-class scope anonymous unions.  */
  93 DEFTREECODE (ALIAS_DECL, "alias_decl", 'd', 0)
  94
  95 /* A reference to a member function or member functions from a base
  96    class.  BASELINK_FUNCTIONS gives the FUNCTION_DECL,
  97    TEMPLATE_DECL, OVERLOAD, or TEMPLATE_ID_EXPR corresponding to the
  98    functions.  BASELINK_BINFO gives the base from which the functions
  99    come, i.e., the base to which the `this' pointer must be converted
 100    before the functions are called.  BASELINK_ACCESS_BINFO gives the
 101    base used to name the functions.
 102
 103    A BASELINK is an expression; the TREE_TYPE of the BASELINK gives
 104    the type of the expression.  This type is either a FUNCTION_TYPE,
 105    METHOD_TYPE, or `unknown_type_node' indicating that the function is
 106    overloaded. */
 107 DEFTREECODE (BASELINK, "baselink", 'x', 0)
 108
 109 /* Template definition.  The following fields have the specified uses,
 110    although there are other macros in cp-tree.h that should be used for
 111    accessing this data.
 112         DECL_ARGUMENTS          template parm vector
 113         DECL_TEMPLATE_INFO      template text &c
 114         DECL_VINDEX             list of instantiations already produced;
 115                                 only done for functions so far
 116    For class template:
 117         DECL_INITIAL            associated templates (methods &c)
 118         DECL_TEMPLATE_RESULT    null
 119    For non-class templates:
 120         TREE_TYPE               type of object to be constructed
 121         DECL_TEMPLATE_RESULT    decl for object to be created
 122                                 (e.g., FUNCTION_DECL with tmpl parms used)
 123  */
 124 DEFTREECODE (TEMPLATE_DECL, "template_decl", 'd', 0)
 125
 126 /* Index into a template parameter list.  The TEMPLATE_PARM_IDX gives
 127    the index (from 0) of the parameter, while the TEMPLATE_PARM_LEVEL
 128    gives the level (from 1) of the parameter.
 129
 130    Here's an example:
 131
 132    template <class T> // Index 0, Level 1.
 133    struct S
 134    {
 135       template <class U, // Index 0, Level 2.
 136                 class V> // Index 1, Level 2.
 137       void f();
 138    };
 139
 140    The DESCENDANTS will be a chain of TEMPLATE_PARM_INDEXs descended
 141    from this one.  The first descendant will have the same IDX, but
 142    its LEVEL will be one less.  The TREE_CHAIN field is used to chain
 143    together the descendants.  The TEMPLATE_PARM_DECL is the
 144    declaration of this parameter, either a TYPE_DECL or CONST_DECL.
 145    The TEMPLATE_PARM_ORIG_LEVEL is the LEVEL of the most distant
 146    parent, i.e., the LEVEL that the parameter originally had when it
 147    was declared.  For example, if we instantiate S<int>, we will have:
 148
 149    struct S<int>
 150    {
 151      template <class U, // Index 0, Level 1, Orig Level 2
 152                class V> // Index 1, Level 1, Orig Level 2
 153      void f();
 154    };
 155
 156    The LEVEL is the level of the parameter when we are worrying about
 157    the types of things; the ORIG_LEVEL is the level when we are
 158    worrying about instantiating things.  */
 159 DEFTREECODE (TEMPLATE_PARM_INDEX, "template_parm_index", 'x', 0)
 160
 161 /* Index into a template parameter list.  This parameter must be a type.
 162    The type.value field will be a TEMPLATE_PARM_INDEX.  */
 163 DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", 't', 0)
 164
 165 /* Index into a template parameter list for template template parameters.
 166    This parameter must be a type.  The TYPE_FIELDS value will be a
 167    TEMPLATE_PARM_INDEX.
 168
 169    It is used without template arguments like TT in C<TT>,
 170    TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO is NULL_TREE
 171    and TYPE_NAME is a TEMPLATE_DECL.  */
 172 DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", 't', 0)
 173
 174 /* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments
 175    like TT<int>.
 176    In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the
 177    template name and its bound arguments.  TYPE_NAME is a TYPE_DECL.  */
 178 DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm", 't', 0)
 179
 180 /* A type designated by `typename T::t'.  TYPE_CONTEXT is `T',
 181    TYPE_NAME is an IDENTIFIER_NODE for `t'.  If the type was named via
 182    template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR.
 183    If TREE_TYPE is present, this type was generated by the implicit
 184    typename extension, and the TREE_TYPE is a _TYPE from a baseclass
 185    of `T'.  */
 186 DEFTREECODE (TYPENAME_TYPE, "typename_type", 't', 0)
 187
 188 /* For template template argument of the form `T::template C'.
 189    TYPE_CONTEXT is `T', the template parameter dependent object.
 190    TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template.  */
 191 DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", 't', 0)
 192
 193 /* A type designated by `__typeof (expr)'.  TYPEOF_TYPE_EXPR is the
 194    expression in question.  */
 195 DEFTREECODE (TYPEOF_TYPE, "typeof_type", 't', 0)
 196
 197 /* A using declaration.  DECL_INITIAL contains the specified scope.
 198    This is not an alias, but is later expanded into multiple aliases.
 199    The decl will have a NULL_TYPE iff the scope is a dependent scope,
 200    otherwise it will have a void type. */
 201 DEFTREECODE (USING_DECL, "using_decl", 'd', 0)
 202
 203 /* A using directive. The operand is USING_STMT_NAMESPACE. */
 204 DEFTREECODE (USING_STMT, "using_directive", 'e', 1)
 205
 206 /* An un-parsed default argument.  Looks like an IDENTIFIER_NODE.  */
 207 DEFTREECODE (DEFAULT_ARG, "default_arg", 'x', 0)
 208
 209 /* A template-id, like foo<int>.  The first operand is the template.
 210    The second is NULL if there are no explicit arguments, or a
 211    TREE_VEC of arguments.  The template will be a FUNCTION_DECL,
 212    TEMPLATE_DECL, or an OVERLOAD.  If the template-id refers to a
 213    member template, the template may be an IDENTIFIER_NODE.  */
 214 DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", 'e', 2)
 215
 216 /* A list-like node for chaining overloading candidates. TREE_TYPE is
 217    the original name, and the parameter is the FUNCTION_DECL.  */
 218 DEFTREECODE (OVERLOAD, "overload", 'x', 0)
 219
 220 /* A whole bunch of tree codes for the initial, superficial parsing of
 221    templates.  */
 222 DEFTREECODE (MODOP_EXPR, "modop_expr", 'e', 3)
 223 DEFTREECODE (CAST_EXPR, "cast_expr", '1', 1)
 224 DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", '1', 1)
 225 DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", '1', 1)
 226 DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", '1', 1)
 227 DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", '1', 1)
 228 DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", 'e', 2)
 229 DEFTREECODE (TYPEID_EXPR, "typeid_expr", 'e', 1)
 230 DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", 'e', 3)
 231
 232 /* A placeholder for an expression that is not type-dependent, but
 233    does occur in a template.  When an expression that is not
 234    type-dependent appears in a larger expression, we must compute the
 235    type of that larger expression.  That computation would normally
 236    modify the original expression, which would change the mangling of
 237    that expression if it appeared in a template argument list.  In
 238    that situation, we create a NON_DEPENDENT_EXPR to take the place of
 239    the original expression.  The expression is the only operand -- it
 240    is only needed for diagnostics.   */
 241 DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", 'e', 1)
 242
 243 /* CTOR_INITIALIZER is a placeholder in template code for a call to
 244    setup_vtbl_pointer (and appears in all functions, not just ctors).  */
 245 DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", 'e', 1)
 246 DEFTREECODE (TRY_BLOCK, "try_block", 'e', 2)
 247 DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", 'e', 2)
 248 /* A HANDLER wraps a catch handler for the HANDLER_TYPE.  If this is
 249    CATCH_ALL_TYPE, then the handler catches all types.  The declaration of
 250    the catch variable is in HANDLER_PARMS, and the body block in
 251    HANDLER_BODY.  */
 252 DEFTREECODE (HANDLER, "handler", 'e', 2)
 253
 254 /* A MUST_NOT_THROW_EXPR wraps an expression that may not
 255    throw, and must call terminate if it does.  */
 256 DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", 'e', 1)
 257
 258 DEFTREECODE (TAG_DEFN, "tag_defn", 'e', 0)
 259
 260 /*
 261 Local variables:
 262 mode:c
 263 End:
 264 */