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, 2007 6 Free Software Foundation, Inc. 7 Hacked by Michael Tiemann (tiemann (at) cygnus.com) 8 9 This file is part of GCC. 10 11 GCC is free software; you can redistribute it and/or modify 12 it under the terms of the GNU General Public License as published by 13 the Free Software Foundation; either version 3, or (at your option) 14 any later version. 15 16 GCC is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 GNU General Public License for more details. 20 21 You should have received a copy of the GNU General Public License 22 along with GCC; see the file COPYING3. If not see 23 <http://www.gnu.org/licenses/>. */ 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 /* AGGR_INIT_EXPRs have a variably-sized representation similar to 78 that of CALL_EXPRs. Operand 0 is an INTEGER_CST node containing the 79 operand count, operand 1 is the function which performs initialization, 80 operand 2 is the slot which was allocated for this expression, and 81 the remaining operands are the arguments to the initialization function. */ 82 DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", tcc_vl_exp, 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", tcc_expression, 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", tcc_expression, 0) 91 92 /* A reference to a member function or member functions from a base 93 class. BASELINK_FUNCTIONS gives the FUNCTION_DECL, 94 TEMPLATE_DECL, OVERLOAD, or TEMPLATE_ID_EXPR corresponding to the 95 functions. BASELINK_BINFO gives the base from which the functions 96 come, i.e., the base to which the `this' pointer must be converted 97 before the functions are called. BASELINK_ACCESS_BINFO gives the 98 base used to name the functions. 99 100 A BASELINK is an expression; the TREE_TYPE of the BASELINK gives 101 the type of the expression. This type is either a FUNCTION_TYPE, 102 METHOD_TYPE, or `unknown_type_node' indicating that the function is 103 overloaded. */ 104 DEFTREECODE (BASELINK, "baselink", tcc_exceptional, 0) 105 106 /* Template definition. The following fields have the specified uses, 107 although there are other macros in cp-tree.h that should be used for 108 accessing this data. 109 DECL_ARGUMENTS template parm vector 110 DECL_TEMPLATE_INFO template text &c 111 DECL_VINDEX list of instantiations already produced; 112 only done for functions so far 113 For class template: 114 DECL_INITIAL associated templates (methods &c) 115 DECL_TEMPLATE_RESULT null 116 For non-class templates: 117 TREE_TYPE type of object to be constructed 118 DECL_TEMPLATE_RESULT decl for object to be created 119 (e.g., FUNCTION_DECL with tmpl parms used) 120 */ 121 DEFTREECODE (TEMPLATE_DECL, "template_decl", tcc_declaration, 0) 122 123 /* Index into a template parameter list. The TEMPLATE_PARM_IDX gives 124 the index (from 0) of the parameter, while the TEMPLATE_PARM_LEVEL 125 gives the level (from 1) of the parameter. 126 127 Here's an example: 128 129 template <class T> // Index 0, Level 1. 130 struct S 131 { 132 template <class U, // Index 0, Level 2. 133 class V> // Index 1, Level 2. 134 void f(); 135 }; 136 137 The DESCENDANTS will be a chain of TEMPLATE_PARM_INDEXs descended 138 from this one. The first descendant will have the same IDX, but 139 its LEVEL will be one less. The TREE_CHAIN field is used to chain 140 together the descendants. The TEMPLATE_PARM_DECL is the 141 declaration of this parameter, either a TYPE_DECL or CONST_DECL. 142 The TEMPLATE_PARM_ORIG_LEVEL is the LEVEL of the most distant 143 parent, i.e., the LEVEL that the parameter originally had when it 144 was declared. For example, if we instantiate S<int>, we will have: 145 146 struct S<int> 147 { 148 template <class U, // Index 0, Level 1, Orig Level 2 149 class V> // Index 1, Level 1, Orig Level 2 150 void f(); 151 }; 152 153 The LEVEL is the level of the parameter when we are worrying about 154 the types of things; the ORIG_LEVEL is the level when we are 155 worrying about instantiating things. */ 156 DEFTREECODE (TEMPLATE_PARM_INDEX, "template_parm_index", tcc_exceptional, 0) 157 158 /* Index into a template parameter list for template template parameters. 159 This parameter must be a type. The TYPE_FIELDS value will be a 160 TEMPLATE_PARM_INDEX. 161 162 It is used without template arguments like TT in C<TT>, 163 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO is NULL_TREE 164 and TYPE_NAME is a TEMPLATE_DECL. */ 165 DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", tcc_type, 0) 166 167 /* The ordering of the following codes is optimized for the checking 168 macros in tree.h. Changing the order will degrade the speed of the 169 compiler. TEMPLATE_TYPE_PARM, TYPENAME_TYPE, TYPEOF_TYPE, 170 BOUND_TEMPLATE_TEMPLATE_PARM. */ 171 172 /* Index into a template parameter list. This parameter must be a type. 173 The type.values field will be a TEMPLATE_PARM_INDEX. */ 174 DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", tcc_type, 0) 175 176 /* A type designated by `typename T::t'. TYPE_CONTEXT is `T', 177 TYPE_NAME is an IDENTIFIER_NODE for `t'. If the type was named via 178 template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR. 179 TREE_TYPE is always NULL. */ 180 DEFTREECODE (TYPENAME_TYPE, "typename_type", tcc_type, 0) 181 182 /* A type designated by `__typeof (expr)'. TYPEOF_TYPE_EXPR is the 183 expression in question. */ 184 DEFTREECODE (TYPEOF_TYPE, "typeof_type", tcc_type, 0) 185 186 /* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments 187 like TT<int>. 188 In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the 189 template name and its bound arguments. TYPE_NAME is a TYPE_DECL. */ 190 DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm", 191 tcc_type, 0) 192 193 /* For template template argument of the form `T::template C'. 194 TYPE_CONTEXT is `T', the template parameter dependent object. 195 TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template. */ 196 DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", tcc_type, 0) 197 198 /* A using declaration. USING_DECL_SCOPE contains the specified 199 scope. In a member using decl, unless DECL_DEPENDENT_P is true, 200 USING_DECL_DECLS contains the _DECL or OVERLOAD so named. This is 201 not an alias, but is later expanded into multiple aliases. */ 202 DEFTREECODE (USING_DECL, "using_decl", tcc_declaration, 0) 203 204 /* A using directive. The operand is USING_STMT_NAMESPACE. */ 205 DEFTREECODE (USING_STMT, "using_directive", tcc_statement, 1) 206 207 /* An un-parsed default argument. Holds a vector of input tokens and 208 a vector of places where the argument was instantiated before 209 parsing had occurred. */ 210 DEFTREECODE (DEFAULT_ARG, "default_arg", tcc_exceptional, 0) 211 212 /* A template-id, like foo<int>. The first operand is the template. 213 The second is NULL if there are no explicit arguments, or a 214 TREE_VEC of arguments. The template will be a FUNCTION_DECL, 215 TEMPLATE_DECL, or an OVERLOAD. If the template-id refers to a 216 member template, the template may be an IDENTIFIER_NODE. */ 217 DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", tcc_expression, 2) 218 219 /* A list-like node for chaining overloading candidates. TREE_TYPE is 220 the original name, and the parameter is the FUNCTION_DECL. */ 221 DEFTREECODE (OVERLOAD, "overload", tcc_exceptional, 0) 222 223 /* A pseudo-destructor, of the form "OBJECT.~DESTRUCTOR" or 224 "OBJECT.SCOPE::~DESTRUCTOR. The first operand is the OBJECT. The 225 second operand (if non-NULL) is the SCOPE. The third operand is 226 the TYPE node corresponding to the DESTRUCTOR. The type of the 227 first operand will always be a scalar type. 228 229 The type of a PSEUDO_DTOR_EXPR is always "void", even though it can 230 be used as if it were a zero-argument function. We handle the 231 function-call case specially, and giving it "void" type prevents it 232 being used in expressions in ways that are not permitted. */ 233 DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", tcc_expression, 3) 234 235 /* A whole bunch of tree codes for the initial, superficial parsing of 236 templates. */ 237 DEFTREECODE (MODOP_EXPR, "modop_expr", tcc_expression, 3) 238 DEFTREECODE (CAST_EXPR, "cast_expr", tcc_unary, 1) 239 DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", tcc_unary, 1) 240 DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", tcc_unary, 1) 241 DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", tcc_unary, 1) 242 DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", tcc_unary, 1) 243 DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", tcc_expression, 2) 244 DEFTREECODE (TYPEID_EXPR, "typeid_expr", tcc_expression, 1) 245 246 /* A placeholder for an expression that is not type-dependent, but 247 does occur in a template. When an expression that is not 248 type-dependent appears in a larger expression, we must compute the 249 type of that larger expression. That computation would normally 250 modify the original expression, which would change the mangling of 251 that expression if it appeared in a template argument list. In 252 that situation, we create a NON_DEPENDENT_EXPR to take the place of 253 the original expression. The expression is the only operand -- it 254 is only needed for diagnostics. */ 255 DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", tcc_expression, 1) 256 257 /* CTOR_INITIALIZER is a placeholder in template code for a call to 258 setup_vtbl_pointer (and appears in all functions, not just ctors). */ 259 DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", tcc_expression, 1) 260 261 DEFTREECODE (TRY_BLOCK, "try_block", tcc_statement, 2) 262 263 DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", tcc_statement, 2) 264 265 /* A HANDLER wraps a catch handler for the HANDLER_TYPE. If this is 266 CATCH_ALL_TYPE, then the handler catches all types. The declaration of 267 the catch variable is in HANDLER_PARMS, and the body block in 268 HANDLER_BODY. */ 269 DEFTREECODE (HANDLER, "handler", tcc_statement, 2) 270 271 /* A MUST_NOT_THROW_EXPR wraps an expression that may not 272 throw, and must call terminate if it does. */ 273 DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", tcc_expression, 1) 274 275 /* A CLEANUP_STMT marks the point at which a declaration is fully 276 constructed. The CLEANUP_EXPR is run on behalf of CLEANUP_DECL 277 when CLEANUP_BODY completes. */ 278 DEFTREECODE (CLEANUP_STMT, "cleanup_stmt", tcc_statement, 3) 279 280 /* Represents an 'if' statement. The operands are IF_COND, 281 THEN_CLAUSE, and ELSE_CLAUSE, respectively. */ 282 /* ??? It is currently still necessary to distinguish between IF_STMT 283 and COND_EXPR for the benefit of templates. */ 284 DEFTREECODE (IF_STMT, "if_stmt", tcc_statement, 3) 285 286 /* Used to represent a `for' statement. The operands are 287 FOR_INIT_STMT, FOR_COND, FOR_EXPR, and FOR_BODY, respectively. */ 288 DEFTREECODE (FOR_STMT, "for_stmt", tcc_statement, 4) 289 290 /* Used to represent a 'while' statement. The operands are WHILE_COND 291 and WHILE_BODY, respectively. */ 292 DEFTREECODE (WHILE_STMT, "while_stmt", tcc_statement, 2) 293 294 /* Used to represent a 'do' statement. The operands are DO_BODY and 295 DO_COND, respectively. */ 296 DEFTREECODE (DO_STMT, "do_stmt", tcc_statement, 2) 297 298 /* Used to represent a 'break' statement. */ 299 DEFTREECODE (BREAK_STMT, "break_stmt", tcc_statement, 0) 300 301 /* Used to represent a 'continue' statement. */ 302 DEFTREECODE (CONTINUE_STMT, "continue_stmt", tcc_statement, 0) 303 304 /* Used to represent a 'switch' statement. The operands are 305 SWITCH_STMT_COND, SWITCH_STMT_BODY and SWITCH_STMT_TYPE, respectively. */ 306 DEFTREECODE (SWITCH_STMT, "switch_stmt", tcc_statement, 3) 307 308 /* Used to represent an expression statement. Use `EXPR_STMT_EXPR' to 309 obtain the expression. */ 310 DEFTREECODE (EXPR_STMT, "expr_stmt", tcc_expression, 1) 311 312 DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0) 313 314 /* Represents an 'offsetof' expression during template expansion. */ 315 DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 1) 316 317 /* Represents a 'sizeof' expression during template expansion. */ 318 DEFTREECODE (SIZEOF_EXPR, "sizeof_expr", tcc_expression, 1) 319 320 /* Represents the -> operator during template expansion. */ 321 DEFTREECODE (ARROW_EXPR, "arrow_expr", tcc_expression, 1) 322 323 /* Represents an '__alignof__' expression during template 324 expansion. */ 325 DEFTREECODE (ALIGNOF_EXPR, "alignof_expr", tcc_expression, 1) 326 327 /* A STMT_EXPR represents a statement-expression during template 328 expansion. This is the GCC extension { ( ... ) }. The 329 STMT_EXPR_STMT is the statement given by the expression. */ 330 DEFTREECODE (STMT_EXPR, "stmt_expr", tcc_expression, 1) 331 332 /* Unary plus. Operand 0 is the expression to which the unary plus 333 is applied. */ 334 DEFTREECODE (UNARY_PLUS_EXPR, "unary_plus_expr", tcc_unary, 1) 335 336 /** C++0x extensions. */ 337 338 /* A static assertion. This is a C++0x extension. 339 STATIC_ASSERT_CONDITION contains the condition that is being 340 checked. STATIC_ASSERT_MESSAGE contains the message (a string 341 literal) to be displayed if the condition fails to hold. */ 342 DEFTREECODE (STATIC_ASSERT, "static_assert", tcc_exceptional, 0) 343 344 /* Represents an argument pack of types (or templates). An argument 345 pack stores zero or more arguments that will be used to instantiate 346 a parameter pack. 347 348 ARGUMENT_PACK_ARGS retrieves the arguments stored in the argument 349 pack. 350 351 Example: 352 template<typename... Values> 353 class tuple { ... }; 354 355 tuple<int, float, double> t; 356 357 Values is a (template) parameter pack. When tuple<int, float, 358 double> is instantiated, the Values parameter pack is instantiated 359 with the argument pack <int, float, double>. ARGUMENT_PACK_ARGS will 360 be a TREE_VEC containing int, float, and double. */ 361 DEFTREECODE (TYPE_ARGUMENT_PACK, "type_argument_pack", tcc_type, 0) 362 363 /* Represents an argument pack of values, which can be used either for 364 non-type template arguments or function call arguments. 365 366 NONTYPE_ARGUMENT_PACK plays precisely the same role as 367 TYPE_ARGUMENT_PACK, but will be used for packing non-type template 368 arguments (e.g., "int... Dimensions") or function arguments ("const 369 Args&... args"). */ 370 DEFTREECODE (NONTYPE_ARGUMENT_PACK, "nontype_argument_pack", tcc_expression, 1) 371 372 /* Represents a type expression that will be expanded into a list of 373 types when instantiated with one or more argument packs. 374 375 PACK_EXPANSION_PATTERN retrieves the expansion pattern. This is 376 the type or expression that we will substitute into with each 377 argument in an argument pack. 378 379 SET_PACK_EXPANSION_PATTERN sets the expansion pattern. 380 381 PACK_EXPANSION_PARAMETER_PACKS contains a TREE_LIST of the parameter 382 packs that are used in this pack expansion. 383 384 Example: 385 template<typename... Values> 386 struct tied : tuple<Values&...> { 387 // ... 388 }; 389 390 The derivation from tuple contains a TYPE_PACK_EXPANSION for the 391 template arguments. Its EXPR_PACK_EXPANSION is "Values&" and its 392 PACK_EXPANSION_PARAMETER_PACKS will contain "Values". */ 393 DEFTREECODE (TYPE_PACK_EXPANSION, "type_pack_expansion", tcc_type, 0) 394 395 /* Represents an expression that will be expanded into a list of 396 expressions when instantiated with one or more argument packs. 397 398 EXPR_PACK_EXPANSION plays precisely the same role as TYPE_PACK_EXPANSION, 399 but will be used for expressions. */ 400 DEFTREECODE (EXPR_PACK_EXPANSION, "expr_pack_expansion", tcc_expression, 1) 401 402 /* Selects the Ith parameter out of an argument pack. This node will 403 be used when instantiating pack expansions; see 404 tsubst_pack_expansion. 405 406 ARGUMENT_PACK_SELECT_FROM_PACK contains the *_ARGUMENT_PACK node 407 from which the argument will be selected. 408 409 ARGUMENT_PACK_SELECT_INDEX contains the index into the argument 410 pack that will be returned by this ARGUMENT_PACK_SELECT node. The 411 index is a machine integer. */ 412 DEFTREECODE (ARGUMENT_PACK_SELECT, "argument_pack_select", tcc_exceptional, 0) 413 414 /** C++ extensions. */ 415 416 /* Represents a trait expression during template expansion. */ 417 DEFTREECODE (TRAIT_EXPR, "trait_expr", tcc_exceptional, 0) 418 419 /* The declared type of an expression. This is a C++0x extension. 420 DECLTYPE_TYPE_EXPR is the expression whose type we are computing. 421 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P states whether the 422 expression was parsed as an id-expression or a member access 423 expression. When false, it was parsed as a full expression. */ 424 DEFTREECODE (DECLTYPE_TYPE, "decltype_type", tcc_type, 0) 425 426 /* 427 Local variables: 428 mode:c 429 End: 430 */ 431