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