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)
8 This file is part of GCC.
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)
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.
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. */
26 /* An OFFSET_REF is used in two situations:
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'.
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
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.
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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.
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
108 DEFTREECODE (BASELINK, "baselink", 'x', 3)
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
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
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)
125 DEFTREECODE (TEMPLATE_DECL, "template_decl", 'd', 0)
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.
133 template <class T> // Index 0, Level 1.
136 template <class U, // Index 0, Level 2.
137 class V> // Index 1, Level 2.
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:
152 template <class U, // Index 0, Level 1, Orig Level 2
153 class V> // Index 1, Level 1, Orig Level 2
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
167 ((sizeof (template_parm_index) - sizeof (struct tree_common))
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)
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
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)
184 /* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments
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)
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
196 DEFTREECODE (TYPENAME_TYPE, "typename_type", 't', 0)
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)
203 /* A type designated by `__typeof (expr)'. TYPE_FIELDS is the
204 expression in question. */
205 DEFTREECODE (TYPEOF_TYPE, "typeof_type", 't', 0)
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)
211 /* A using directive. The operand is USING_STMT_NAMESPACE. */
212 DEFTREECODE (USING_STMT, "using_directive", 'e', 1)
214 /* An un-parsed default argument. Looks like an IDENTIFIER_NODE. */
215 DEFTREECODE (DEFAULT_ARG, "default_arg", 'x', 2)
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)
225 /* An association between name and entity. Parameters are the scope
226 and the (non-type) value. TREE_TYPE indicates the type bound to
228 DEFTREECODE (CPLUS_BINDING, "binding", 'x', 2)
230 /* A list-like node for chaining overloading candidates. TREE_TYPE is
231 the original name, and the parameter is the FUNCTION_DECL. */
232 DEFTREECODE (OVERLOAD, "overload", 'x', 1)
234 /* A generic wrapper for something not tree that we want to include in
236 DEFTREECODE (WRAPPER, "wrapper", 'x', 1)
238 /* Used to represent deferred name lookup for dependent names while
239 parsing a template declaration. The first argument is an
240 IDENTIFIER_NODE for the name in question. The TREE_TYPE is
242 DEFTREECODE (LOOKUP_EXPR, "lookup_expr", 'e', 1)
244 /* A whole bunch of tree codes for the initial, superficial parsing of
246 DEFTREECODE (MODOP_EXPR, "modop_expr", 'e', 3)
247 DEFTREECODE (CAST_EXPR, "cast_expr", '1', 1)
248 DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", '1', 1)
249 DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", '1', 1)
250 DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", '1', 1)
251 DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", '1', 1)
252 DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", 'e', 2)
253 DEFTREECODE (TYPEID_EXPR, "typeid_expr", 'e', 1)
254 DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", 'e', 3)
256 /* CTOR_INITIALIZER is a placeholder in template code for a call to
257 setup_vtbl_pointer (and appears in all functions, not just ctors). */
258 DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", 'e', 1)
259 DEFTREECODE (TRY_BLOCK, "try_block", 'e', 2)
260 DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", 'e', 2)
261 /* A HANDLER wraps a catch handler for the HANDLER_TYPE. If this is
262 CATCH_ALL_TYPE, then the handler catches all types. The declaration of
263 the catch variable is in HANDLER_PARMS, and the body block in
265 DEFTREECODE (HANDLER, "handler", 'e', 2)
267 /* A MUST_NOT_THROW_EXPR wraps an expression that may not
268 throw, and must call terminate if it does. */
269 DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", 'e', 1)
271 DEFTREECODE (TAG_DEFN, "tag_defn", 'e', 0)
273 /* The following codes are used to represent implicit conversion
274 sequences, in the sense of [over.best.ics]. The conversion
275 sequences are connected through their first operands, with the
276 first conversion to be performed at the end of the chain.
278 The innermost conversion (i.e, the one at the end of the chain) is
279 always an IDENTITY_CONV, corresponding to the identity conversion. */
281 DEFTREECODE (IDENTITY_CONV, "identity_conv", 'e', 1)
282 DEFTREECODE (LVALUE_CONV, "lvalue_conv", 'e', 1)
283 DEFTREECODE (QUAL_CONV, "qual_conv", 'e', 1)
284 DEFTREECODE (STD_CONV, "std_conv", 'e', 1)
285 DEFTREECODE (PTR_CONV, "ptr_conv", 'e', 1)
286 DEFTREECODE (PMEM_CONV, "pmem_conv", 'e', 1)
287 DEFTREECODE (BASE_CONV, "base_conv", 'e', 1)
288 DEFTREECODE (REF_BIND, "ref_bind", 'e', 1)
289 DEFTREECODE (USER_CONV, "user_conv", 'e', 2)
290 DEFTREECODE (AMBIG_CONV, "ambig_conv", 'e', 1)
291 DEFTREECODE (RVALUE_CONV, "rvalue_conv", 'e', 1)