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
)
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 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
').
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 This form is only used during the parsing phase; once semantic
40 analysis has taken place they are eliminated.
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", tcc_reference, 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", tcc_constant
, 0)
52 /* For NEW_EXPR
, operand
0 is the placement list.
53 Operand
1 is the new
-declarator.
54 Operand
2 is the number of elements in the array.
55 Operand
3 is the initializer.
*/
56 DEFTREECODE (NEW_EXPR
, "nw_expr", tcc_expression
, 4)
57 DEFTREECODE (VEC_NEW_EXPR
, "vec_nw_expr", tcc_expression
, 3)
59 /* For DELETE_EXPR
, operand
0 is the store to be destroyed.
60 Operand
1 is the value to pass to the destroying function
61 saying whether the store should be deallocated as well.
*/
62 DEFTREECODE (DELETE_EXPR
, "dl_expr", tcc_expression
, 2)
63 DEFTREECODE (VEC_DELETE_EXPR
, "vec_dl_expr", tcc_expression
, 2)
65 /* Value is reference to particular overloaded class method.
66 Operand
0 is the class
, operand
1 is the field
67 The COMPLEXITY field holds the class
level (usually
0).
*/
68 DEFTREECODE (SCOPE_REF
, "scope_ref", tcc_reference
, 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", tcc_reference
, 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", tcc_expression
, 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", tcc_expression
, 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", tcc_expression
, 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", tcc_expression
, 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", tcc_declaration
, 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", tcc_exceptional
, 0)
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", tcc_declaration
, 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", tcc_exceptional, 0)
162 /* Index into a template parameter list for template template parameters.
163 This parameter must be a type. The TYPE_FIELDS value will be a
166 It is used without template arguments like TT in C<TT>,
167 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO is NULL_TREE
168 and TYPE_NAME is a TEMPLATE_DECL. */
169 DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", tcc_type, 0)
171 /* The ordering of the following codes is optimized for the checking
172 macros in tree.h. Changing the order will degrade the speed of the
173 compiler. TEMPLATE_TYPE_PARM, TYPENAME_TYPE, TYPEOF_TYPE,
174 BOUND_TEMPLATE_TEMPLATE_PARM. */
176 /* Index into a template parameter list. This parameter must be a type.
177 The type.value field will be a TEMPLATE_PARM_INDEX. */
178 DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", tcc_type, 0)
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 TREE_TYPE is always NULL.
*/
184 DEFTREECODE (TYPENAME_TYPE
, "typename_type", tcc_type
, 0)
186 /* A type designated by `
__typeof (expr
)'. TYPEOF_TYPE_EXPR is the
187 expression in question. */
188 DEFTREECODE (TYPEOF_TYPE, "typeof_type", tcc_type, 0)
190 /* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments
192 In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the
193 template name and its bound arguments. TYPE_NAME is a TYPE_DECL. */
194 DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm",
197 /* For template template argument of the form `T::template C'.
198 TYPE_CONTEXT is `T
', the template parameter dependent object.
199 TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template.
*/
200 DEFTREECODE (UNBOUND_CLASS_TEMPLATE
, "unbound_class_template", tcc_type
, 0)
202 /* A using declaration. DECL_INITIAL contains the specified scope.
203 This is not an alias
, but is later expanded into multiple aliases.
204 The decl will have a NULL_TYPE iff the scope is a dependent scope
,
205 otherwise it will have a void type.
*/
206 DEFTREECODE (USING_DECL
, "using_decl", tcc_declaration
, 0)
208 /* A using directive. The operand is USING_STMT_NAMESPACE.
*/
209 DEFTREECODE (USING_STMT
, "using_directive", tcc_expression
, 1)
211 /* An un
-parsed default argument. Looks like an IDENTIFIER_NODE.
*/
212 DEFTREECODE (DEFAULT_ARG
, "default_arg", tcc_exceptional
, 0)
214 /* A template
-id
, like foo
<int
>. The first operand is the template.
215 The second is NULL if there are no explicit arguments
, or a
216 TREE_VEC of arguments. The template will be a FUNCTION_DECL
,
217 TEMPLATE_DECL
, or an OVERLOAD. If the template
-id refers to a
218 member template
, the template may be an IDENTIFIER_NODE.
*/
219 DEFTREECODE (TEMPLATE_ID_EXPR
, "template_id_expr", tcc_expression
, 2)
221 /* A list
-like node for chaining overloading candidates. TREE_TYPE is
222 the original name
, and the parameter is the FUNCTION_DECL.
*/
223 DEFTREECODE (OVERLOAD
, "overload", tcc_exceptional
, 0)
225 /* A whole bunch of tree codes for the initial
, superficial parsing of
227 DEFTREECODE (MODOP_EXPR
, "modop_expr", tcc_expression
, 3)
228 DEFTREECODE (CAST_EXPR
, "cast_expr", tcc_unary
, 1)
229 DEFTREECODE (REINTERPRET_CAST_EXPR
, "reinterpret_cast_expr", tcc_unary
, 1)
230 DEFTREECODE (CONST_CAST_EXPR
, "const_cast_expr", tcc_unary
, 1)
231 DEFTREECODE (STATIC_CAST_EXPR
, "static_cast_expr", tcc_unary
, 1)
232 DEFTREECODE (DYNAMIC_CAST_EXPR
, "dynamic_cast_expr", tcc_unary
, 1)
233 DEFTREECODE (DOTSTAR_EXPR
, "dotstar_expr", tcc_expression
, 2)
234 DEFTREECODE (TYPEID_EXPR
, "typeid_expr", tcc_expression
, 1)
235 DEFTREECODE (PSEUDO_DTOR_EXPR
, "pseudo_dtor_expr", tcc_expression
, 3)
237 /* A placeholder for an expression that is not type
-dependent
, but
238 does occur in a template. When an expression that is not
239 type
-dependent appears in a larger expression
, we must compute the
240 type of that larger expression. That computation would normally
241 modify the original expression
, which would change the mangling of
242 that expression if it appeared in a template argument list. In
243 that situation
, we create a NON_DEPENDENT_EXPR to take the place of
244 the original expression. The expression is the only operand
-- it
245 is only needed for diagnostics.
*/
246 DEFTREECODE (NON_DEPENDENT_EXPR
, "non_dependent_expr", tcc_expression
, 1)
248 /* CTOR_INITIALIZER is a placeholder in template code for a call to
249 setup_vtbl_pointer (and appears in all functions
, not just ctors
).
*/
250 DEFTREECODE (CTOR_INITIALIZER
, "ctor_initializer", tcc_expression
, 1)
252 DEFTREECODE (TRY_BLOCK
, "try_block", tcc_expression
, 2)
254 DEFTREECODE (EH_SPEC_BLOCK
, "eh_spec_block", tcc_expression
, 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
260 DEFTREECODE (HANDLER
, "handler", tcc_expression
, 2)
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", tcc_expression
, 1)
266 /* A CLEANUP_STMT marks the point at which a declaration is fully
267 constructed. The CLEANUP_EXPR is run on behalf of CLEANUP_DECL
268 when CLEANUP_BODY completes.
*/
269 DEFTREECODE (CLEANUP_STMT
, "cleanup_stmt", tcc_expression
, 3)
271 /* Represents an
'if' statement. The operands are IF_COND
,
272 THEN_CLAUSE
, and ELSE_CLAUSE
, respectively.
*/
273 /* ??? It is currently still necessary to distinguish between IF_STMT
274 and COND_EXPR for the benefit of templates.
*/
275 DEFTREECODE (IF_STMT
, "if_stmt", tcc_expression
, 3)
277 DEFTREECODE (TAG_DEFN
, "tag_defn", tcc_expression
, 0)
279 /* Template instantiation level node.
281 TINST_DECL contains the original DECL node.
282 TINST_LOCATION contains the location where the template is instantiated.
284 A stack of template instantiation nodes is kept through the TREE_CHAIN
285 fields of these nodes.
*/
287 DEFTREECODE (TINST_LEVEL
, "TINST_LEVEL", tcc_exceptional
, 0)
289 /* Represents an
'offsetof' expression during template expansion.
*/
290 DEFTREECODE (OFFSETOF_EXPR
, "offsetof_expr", tcc_expression
, 1)