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-2020 Free Software Foundation, Inc. 5 Hacked by Michael Tiemann (tiemann@cygnus.com) 6 7This file is part of GCC. 8 9GCC is free software; you can redistribute it and/or modify 10it under the terms of the GNU General Public License as published by 11the Free Software Foundation; either version 3, or (at your option) 12any later version. 13 14GCC is distributed in the hope that it will be useful, 15but WITHOUT ANY WARRANTY; without even the implied warranty of 16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17GNU General Public License for more details. 18 19You should have received a copy of the GNU General Public License 20along with GCC; see the file COPYING3. If not see 21<http://www.gnu.org/licenses/>. */ 22 23 24/* An OFFSET_REF is used in two situations: 25 26 1. An expression of the form `A::m' where `A' is a class and `m' is 27 a non-static member. In this case, operand 0 will be a TYPE 28 (corresponding to `A') and operand 1 will be a FIELD_DECL, 29 BASELINK, or TEMPLATE_ID_EXPR (corresponding to `m'). 30 31 The expression is a pointer-to-member if its address is taken, 32 but simply denotes a member of the object if its address is not 33 taken. 34 35 This form is only used during the parsing phase; once semantic 36 analysis has taken place they are eliminated. 37 38 2. An expression of the form `x.*p'. In this case, operand 0 will 39 be an expression corresponding to `x' and operand 1 will be an 40 expression with pointer-to-member type. */ 41DEFTREECODE (OFFSET_REF, "offset_ref", tcc_reference, 2) 42 43/* A pointer-to-member constant. For a pointer-to-member constant 44 `X::Y' The PTRMEM_CST_CLASS is the RECORD_TYPE for `X' and the 45 PTRMEM_CST_MEMBER is the _DECL for `Y'. */ 46DEFTREECODE (PTRMEM_CST, "ptrmem_cst", tcc_constant, 0) 47 48/* For NEW_EXPR, operand 0 is the placement list. 49 Operand 1 is the new-declarator. 50 Operand 2 is the number of elements in the array. 51 Operand 3 is the initializer. */ 52DEFTREECODE (NEW_EXPR, "nw_expr", tcc_expression, 4) 53DEFTREECODE (VEC_NEW_EXPR, "vec_nw_expr", tcc_expression, 3) 54 55/* For DELETE_EXPR, operand 0 is the store to be destroyed. 56 Operand 1 is the value to pass to the destroying function 57 saying whether the store should be deallocated as well. */ 58DEFTREECODE (DELETE_EXPR, "dl_expr", tcc_expression, 2) 59DEFTREECODE (VEC_DELETE_EXPR, "vec_dl_expr", tcc_expression, 2) 60 61/* Value is reference to particular overloaded class method. 62 Operand 0 is the class, operand 1 is the field 63 The COMPLEXITY field holds the class level (usually 0). */ 64DEFTREECODE (SCOPE_REF, "scope_ref", tcc_reference, 2) 65 66/* When composing an object with a member, this is the result. 67 Operand 0 is the object. Operand 1 is the member (usually 68 a dereferenced pointer to member). */ 69DEFTREECODE (MEMBER_REF, "member_ref", tcc_reference, 2) 70 71/* Type conversion operator in C++. TREE_TYPE is type that this 72 operator converts to. Operand is expression to be converted. */ 73DEFTREECODE (TYPE_EXPR, "type_expr", tcc_expression, 1) 74 75/* AGGR_INIT_EXPRs have a variably-sized representation similar to 76 that of CALL_EXPRs. Operand 0 is an INTEGER_CST node containing the 77 operand count, operand 1 is the function which performs initialization, 78 operand 2 is the slot which was allocated for this expression, and 79 the remaining operands are the arguments to the initialization function. */ 80DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", tcc_vl_exp, 3) 81 82/* Initialization of an array from another array, expressed at a high level 83 so that it works with TARGET_EXPR. Operand 0 is the target, operand 1 84 is the initializer. */ 85DEFTREECODE (VEC_INIT_EXPR, "vec_init_expr", tcc_expression, 2) 86 87/* A throw expression. operand 0 is the expression, if there was one, 88 else it is NULL_TREE. */ 89DEFTREECODE (THROW_EXPR, "throw_expr", tcc_expression, 1) 90 91/* An empty class object. The TREE_TYPE gives the class type. We use 92 these to avoid actually creating instances of the empty classes. */ 93DEFTREECODE (EMPTY_CLASS_EXPR, "empty_class_expr", tcc_expression, 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. */ 107DEFTREECODE (BASELINK, "baselink", tcc_exceptional, 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 */ 124DEFTREECODE (TEMPLATE_DECL, "template_decl", tcc_declaration, 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. */ 159DEFTREECODE (TEMPLATE_PARM_INDEX, "template_parm_index", tcc_exceptional, 0) 160 161/* Index into a template parameter list for template template parameters. 162 This parameter must be a type. The TYPE_FIELDS value will be a 163 TEMPLATE_PARM_INDEX. 164 165 It is used without template arguments like TT in C<TT>, 166 TYPE_NAME is a TEMPLATE_DECL. */ 167DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", tcc_type, 0) 168 169/* The ordering of the following codes is optimized for the checking 170 macros in tree.h. Changing the order will degrade the speed of the 171 compiler. TEMPLATE_TYPE_PARM, TYPENAME_TYPE, TYPEOF_TYPE, 172 BOUND_TEMPLATE_TEMPLATE_PARM. */ 173 174/* Index into a template parameter list. This parameter must be a type. 175 The type.values field will be a TEMPLATE_PARM_INDEX. */ 176DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", tcc_type, 0) 177 178/* A type designated by `typename T::t'. TYPE_CONTEXT is `T', 179 TYPE_NAME is an IDENTIFIER_NODE for `t'. If the type was named via 180 template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR. 181 TREE_TYPE is always NULL. */ 182DEFTREECODE (TYPENAME_TYPE, "typename_type", tcc_type, 0) 183 184/* A type designated by `__typeof (expr)'. TYPEOF_TYPE_EXPR is the 185 expression in question. */ 186DEFTREECODE (TYPEOF_TYPE, "typeof_type", tcc_type, 0) 187 188/* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments 189 like TT<int>. 190 In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the 191 template name and its bound arguments. TYPE_NAME is a TYPE_DECL. */ 192DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm", 193 tcc_type, 0) 194 195/* For template template argument of the form `T::template C'. 196 TYPE_CONTEXT is `T', the template parameter dependent object. 197 TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template. */ 198DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", tcc_type, 0) 199 200/* A using declaration. USING_DECL_SCOPE contains the specified 201 scope. In a variadic using-declaration, this is a TYPE_PACK_EXPANSION. 202 In a member using decl, unless DECL_DEPENDENT_P is true, 203 USING_DECL_DECLS contains the _DECL or OVERLOAD so named. This is 204 not an alias, but is later expanded into multiple aliases. */ 205DEFTREECODE (USING_DECL, "using_decl", tcc_declaration, 0) 206 207/* A using directive. The operand is USING_STMT_NAMESPACE. */ 208DEFTREECODE (USING_STMT, "using_stmt", tcc_statement, 1) 209 210/* An un-parsed operand. Holds a vector of input tokens and 211 a vector of places where the argument was instantiated before 212 parsing had occurred. This is used for default arguments, delayed 213 NSDMIs, and noexcept-specifier parsing. */ 214DEFTREECODE (DEFERRED_PARSE, "deferred_parse", tcc_exceptional, 0) 215 216/* An uninstantiated/unevaluated noexcept-specification. For the 217 uninstantiated case, DEFERRED_NOEXCEPT_PATTERN is the pattern from the 218 template, and DEFERRED_NOEXCEPT_ARGS are the template arguments to 219 substitute into the pattern when needed. For the unevaluated case, 220 those slots are NULL_TREE and we use get_defaulted_eh_spec to find 221 the exception-specification. */ 222DEFTREECODE (DEFERRED_NOEXCEPT, "deferred_noexcept", tcc_exceptional, 0) 223 224/* A template-id, like foo<int>. The first operand is the template. 225 The second is NULL if there are no explicit arguments, or a 226 TREE_VEC of arguments. The template will be a FUNCTION_DECL, 227 TEMPLATE_DECL, or an OVERLOAD. If the template-id refers to a 228 member template, the template may be an IDENTIFIER_NODE. */ 229DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", tcc_expression, 2) 230 231/* One of a set of overloaded functions. */ 232DEFTREECODE (OVERLOAD, "overload", tcc_exceptional, 0) 233 234/* A pseudo-destructor, of the form "OBJECT.~DESTRUCTOR" or 235 "OBJECT.SCOPE::~DESTRUCTOR. The first operand is the OBJECT. The 236 second operand (if non-NULL) is the SCOPE. The third operand is 237 the TYPE node corresponding to the DESTRUCTOR. The type of the 238 first operand will always be a scalar type. 239 240 The type of a PSEUDO_DTOR_EXPR is always "void", even though it can 241 be used as if it were a zero-argument function. We handle the 242 function-call case specially, and giving it "void" type prevents it 243 being used in expressions in ways that are not permitted. */ 244DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", tcc_expression, 3) 245 246/* A whole bunch of tree codes for the initial, superficial parsing of 247 templates. */ 248DEFTREECODE (MODOP_EXPR, "modop_expr", tcc_expression, 3) 249DEFTREECODE (CAST_EXPR, "cast_expr", tcc_unary, 1) 250DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", tcc_unary, 1) 251DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", tcc_unary, 1) 252DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", tcc_unary, 1) 253DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", tcc_unary, 1) 254DEFTREECODE (IMPLICIT_CONV_EXPR, "implicit_conv_expr", tcc_unary, 1) 255DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", tcc_expression, 2) 256DEFTREECODE (TYPEID_EXPR, "typeid_expr", tcc_expression, 1) 257DEFTREECODE (NOEXCEPT_EXPR, "noexcept_expr", tcc_unary, 1) 258DEFTREECODE (SPACESHIP_EXPR, "spaceship_expr", tcc_expression, 2) 259 260/* A placeholder for an expression that is not type-dependent, but 261 does occur in a template. When an expression that is not 262 type-dependent appears in a larger expression, we must compute the 263 type of that larger expression. That computation would normally 264 modify the original expression, which would change the mangling of 265 that expression if it appeared in a template argument list. In 266 that situation, we create a NON_DEPENDENT_EXPR to take the place of 267 the original expression. The expression is the only operand -- it 268 is only needed for diagnostics. */ 269DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", tcc_expression, 1) 270 271/* CTOR_INITIALIZER is a placeholder in template code for a call to 272 setup_vtbl_pointer (and appears in all functions, not just ctors). */ 273DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", tcc_expression, 1) 274 275DEFTREECODE (TRY_BLOCK, "try_block", tcc_statement, 2) 276 277DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", tcc_statement, 2) 278 279/* A HANDLER wraps a catch handler for the HANDLER_TYPE. If this is 280 CATCH_ALL_TYPE, then the handler catches all types. The declaration of 281 the catch variable is in HANDLER_PARMS, and the body block in 282 HANDLER_BODY. */ 283DEFTREECODE (HANDLER, "handler", tcc_statement, 2) 284 285/* A MUST_NOT_THROW_EXPR wraps an expression that may not 286 throw, and must call terminate if it does. The second argument 287 is a condition, used in templates to express noexcept (condition). */ 288DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", tcc_expression, 2) 289 290/* A CLEANUP_STMT marks the point at which a declaration is fully 291 constructed. The CLEANUP_EXPR is run on behalf of CLEANUP_DECL 292 when CLEANUP_BODY completes. */ 293DEFTREECODE (CLEANUP_STMT, "cleanup_stmt", tcc_statement, 3) 294 295/* Represents an 'if' statement. The operands are IF_COND, 296 THEN_CLAUSE, and ELSE_CLAUSE, and the current scope, respectively. */ 297/* ??? It is currently still necessary to distinguish between IF_STMT 298 and COND_EXPR for the benefit of templates. */ 299DEFTREECODE (IF_STMT, "if_stmt", tcc_statement, 4) 300 301/* Used to represent a `for' statement. The operands are 302 FOR_INIT_STMT, FOR_COND, FOR_EXPR, and FOR_BODY, respectively. */ 303DEFTREECODE (FOR_STMT, "for_stmt", tcc_statement, 5) 304 305/* Used to represent a range-based `for' statement. The operands are 306 RANGE_FOR_DECL, RANGE_FOR_EXPR, RANGE_FOR_BODY, RANGE_FOR_SCOPE, 307 RANGE_FOR_UNROLL, and RANGE_FOR_INIT_STMT, respectively. Only used in 308 templates. */ 309DEFTREECODE (RANGE_FOR_STMT, "range_for_stmt", tcc_statement, 6) 310 311/* Used to represent a 'while' statement. The operands are WHILE_COND 312 and WHILE_BODY, respectively. */ 313DEFTREECODE (WHILE_STMT, "while_stmt", tcc_statement, 2) 314 315/* Used to represent a 'do' statement. The operands are DO_BODY and 316 DO_COND, respectively. */ 317DEFTREECODE (DO_STMT, "do_stmt", tcc_statement, 2) 318 319/* Used to represent a 'break' statement. */ 320DEFTREECODE (BREAK_STMT, "break_stmt", tcc_statement, 0) 321 322/* Used to represent a 'continue' statement. */ 323DEFTREECODE (CONTINUE_STMT, "continue_stmt", tcc_statement, 0) 324 325/* Used to represent a 'switch' statement. The operands are 326 SWITCH_STMT_COND, SWITCH_STMT_BODY, SWITCH_STMT_TYPE, and 327 SWITCH_STMT_SCOPE, respectively. */ 328DEFTREECODE (SWITCH_STMT, "switch_stmt", tcc_statement, 4) 329 330/* Used to represent an expression statement. Use `EXPR_STMT_EXPR' to 331 obtain the expression. */ 332DEFTREECODE (EXPR_STMT, "expr_stmt", tcc_expression, 1) 333 334DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0) 335 336/* Represents an 'offsetof' expression during template expansion. */ 337DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 2) 338 339/* Represents an '__builtin_addressof' expression during template 340 expansion. This is similar to ADDR_EXPR, but it doesn't invoke 341 overloaded & operators. */ 342DEFTREECODE (ADDRESSOF_EXPR, "addressof_expr", tcc_expression, 1) 343 344/* Represents the -> operator during template expansion. */ 345DEFTREECODE (ARROW_EXPR, "arrow_expr", tcc_expression, 1) 346 347/* Represents an '__alignof__' expression during template 348 expansion. */ 349DEFTREECODE (ALIGNOF_EXPR, "alignof_expr", tcc_expression, 1) 350 351/* Represents an Objective-C++ '@encode' expression during template 352 expansion. */ 353DEFTREECODE (AT_ENCODE_EXPR, "at_encode_expr", tcc_expression, 1) 354 355/* A STMT_EXPR represents a statement-expression during template 356 expansion. This is the GCC extension { ( ... ) }. The 357 STMT_EXPR_STMT is the statement given by the expression. */ 358DEFTREECODE (STMT_EXPR, "stmt_expr", tcc_expression, 1) 359 360/* Unary plus. Operand 0 is the expression to which the unary plus 361 is applied. */ 362DEFTREECODE (UNARY_PLUS_EXPR, "unary_plus_expr", tcc_unary, 1) 363 364/** C++11 extensions. */ 365 366/* A static assertion. This is a C++11 extension. 367 STATIC_ASSERT_CONDITION contains the condition that is being 368 checked. STATIC_ASSERT_MESSAGE contains the message (a string 369 literal) to be displayed if the condition fails to hold. */ 370DEFTREECODE (STATIC_ASSERT, "static_assert", tcc_exceptional, 0) 371 372/* Represents an argument pack of types (or templates). An argument 373 pack stores zero or more arguments that will be used to instantiate 374 a parameter pack. 375 376 ARGUMENT_PACK_ARGS retrieves the arguments stored in the argument 377 pack. 378 379 Example: 380 template<typename... Values> 381 class tuple { ... }; 382 383 tuple<int, float, double> t; 384 385 Values is a (template) parameter pack. When tuple<int, float, 386 double> is instantiated, the Values parameter pack is instantiated 387 with the argument pack <int, float, double>. ARGUMENT_PACK_ARGS will 388 be a TREE_VEC containing int, float, and double. */ 389DEFTREECODE (TYPE_ARGUMENT_PACK, "type_argument_pack", tcc_type, 0) 390 391/* Represents an argument pack of values, which can be used either for 392 non-type template arguments or function call arguments. 393 394 NONTYPE_ARGUMENT_PACK plays precisely the same role as 395 TYPE_ARGUMENT_PACK, but will be used for packing non-type template 396 arguments (e.g., "int... Dimensions") or function arguments ("const 397 Args&... args"). */ 398DEFTREECODE (NONTYPE_ARGUMENT_PACK, "nontype_argument_pack", tcc_expression, 1) 399 400/* Represents a type expression that will be expanded into a list of 401 types when instantiated with one or more argument packs. 402 403 PACK_EXPANSION_PATTERN retrieves the expansion pattern. This is 404 the type or expression that we will substitute into with each 405 argument in an argument pack. 406 407 SET_PACK_EXPANSION_PATTERN sets the expansion pattern. 408 409 PACK_EXPANSION_PARAMETER_PACKS contains a TREE_LIST of the parameter 410 packs that are used in this pack expansion. 411 412 Example: 413 template<typename... Values> 414 struct tied : tuple<Values&...> { 415 // ... 416 }; 417 418 The derivation from tuple contains a TYPE_PACK_EXPANSION for the 419 template arguments. Its PACK_EXPANSION_PATTERN is "Values&" and its 420 PACK_EXPANSION_PARAMETER_PACKS will contain "Values". */ 421DEFTREECODE (TYPE_PACK_EXPANSION, "type_pack_expansion", tcc_type, 0) 422 423/* Represents an expression that will be expanded into a list of 424 expressions when instantiated with one or more argument packs. 425 426 EXPR_PACK_EXPANSION plays precisely the same role as TYPE_PACK_EXPANSION, 427 but will be used for expressions. */ 428DEFTREECODE (EXPR_PACK_EXPANSION, "expr_pack_expansion", tcc_expression, 3) 429 430/* Selects the Ith parameter out of an argument pack. This node will 431 be used when instantiating pack expansions; see 432 tsubst_pack_expansion. 433 434 ARGUMENT_PACK_SELECT_FROM_PACK contains the *_ARGUMENT_PACK node 435 from which the argument will be selected. 436 437 ARGUMENT_PACK_SELECT_INDEX contains the index into the argument 438 pack that will be returned by this ARGUMENT_PACK_SELECT node. The 439 index is a machine integer. */ 440DEFTREECODE (ARGUMENT_PACK_SELECT, "argument_pack_select", tcc_exceptional, 0) 441 442/* Fold expressions allow the expansion of a template argument pack 443 over a binary operator. 444 445 FOLD_EXPR_MOD_P is true when the fold operation is a compound assignment 446 operator. 447 448 FOLD_EXPR_OP is an INTEGER_CST storing the tree code for the folded 449 expression. Note that when FOLDEXPR_MOD_P is true, the operator is 450 a compound assignment operator for that kind of expression. 451 452 FOLD_EXPR_PACK is an expression containing an unexpanded parameter pack; 453 when expanded, each term becomes an argument of the folded expression. 454 455 In a BINARY_FOLD_EXPRESSION, FOLD_EXPR_INIT is the non-pack argument. */ 456DEFTREECODE (UNARY_LEFT_FOLD_EXPR, "unary_left_fold_expr", tcc_expression, 2) 457DEFTREECODE (UNARY_RIGHT_FOLD_EXPR, "unary_right_fold_expr", tcc_expression, 2) 458DEFTREECODE (BINARY_LEFT_FOLD_EXPR, "binary_left_fold_expr", tcc_expression, 3) 459DEFTREECODE (BINARY_RIGHT_FOLD_EXPR, "binary_right_fold_expr", tcc_expression, 3) 460 461 462/** C++ extensions. */ 463 464/* Represents a trait expression during template expansion. */ 465DEFTREECODE (TRAIT_EXPR, "trait_expr", tcc_exceptional, 0) 466 467/* A lambda expression. This is a C++0x extension. 468 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE is an enum for the default, which may be 469 none. 470 LAMBDA_EXPR_CAPTURE_LIST holds the capture-list, including `this'. 471 LAMBDA_EXPR_THIS_CAPTURE goes straight to the capture of `this', if it exists. 472 LAMBDA_EXPR_PENDING_PROXIES is a vector of capture proxies which need to 473 be pushed once scope returns to the lambda. 474 LAMBDA_EXPR_MUTABLE_P signals whether this lambda was declared mutable. */ 475DEFTREECODE (LAMBDA_EXPR, "lambda_expr", tcc_exceptional, 0) 476 477/* The declared type of an expression. This is a C++0x extension. 478 DECLTYPE_TYPE_EXPR is the expression whose type we are computing. 479 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P states whether the 480 expression was parsed as an id-expression or a member access 481 expression. When false, it was parsed as a full expression. 482 DECLTYPE_FOR_LAMBDA_CAPTURE is set if we want lambda capture semantics. 483 DECLTYPE_FOR_LAMBDA_RETURN is set if we want lambda return deduction. */ 484DEFTREECODE (DECLTYPE_TYPE, "decltype_type", tcc_type, 0) 485 486/* A type designated by `__underlying_type (type)'. 487 UNDERLYING_TYPE_TYPE is the type in question. */ 488DEFTREECODE (UNDERLYING_TYPE, "underlying_type", tcc_type, 0) 489 490/* A type designated by one of the bases type traits. 491 BASES_TYPE is the type in question. */ 492DEFTREECODE (BASES, "bases", tcc_type, 0) 493 494/* Used to represent the template information stored by template 495 specializations. 496 The accessors are: 497 TI_TEMPLATE the template declaration associated to the specialization 498 TI_ARGS the arguments of the template specialization 499 TI_TYPEDEFS_NEEDING_ACCESS_CHECKING the vector of typedefs used in 500 the pattern of the template for which access check is needed at template 501 instantiation time. */ 502DEFTREECODE (TEMPLATE_INFO, "template_info", tcc_exceptional, 0) 503 504/* OpenMP - #pragma omp depobj 505 Operand 0: OMP_DEPOBJ_DEPOBJ: Depobj expression 506 Operand 1: OMP_DEPOBJ_CLAUSES: List of clauses. */ 507DEFTREECODE (OMP_DEPOBJ, "omp_depobj", tcc_statement, 2) 508 509/* Extensions for Concepts. */ 510 511/* Concept definition. This is not entirely different than a VAR_DECL 512 except that a) it must be a template, and b) doesn't have the wide 513 range of value and linkage options available to variables. */ 514DEFTREECODE (CONCEPT_DECL, "concept_decl", tcc_declaration, 0) 515 516/* Used to represent information associated with constrained declarations. */ 517DEFTREECODE (CONSTRAINT_INFO, "constraint_info", tcc_exceptional, 0) 518 519/* A wildcard declaration is a placeholder for a template parameter 520 used to resolve constrained-type-names in concepts. During 521 resolution, the matching argument is saved as the TREE_TYPE 522 of the wildcard. */ 523DEFTREECODE (WILDCARD_DECL, "wildcard_decl", tcc_declaration, 0) 524 525/* A requires-expr is a binary expression. The first operand is 526 its parameter list (possibly NULL). The second is a list of 527 requirements, which are denoted by the _REQ* tree codes 528 below. */ 529DEFTREECODE (REQUIRES_EXPR, "requires_expr", tcc_expression, 2) 530 531/* A requirement for an expression. */ 532DEFTREECODE (SIMPLE_REQ, "simple_req", tcc_expression, 1) 533 534/* A requirement for a type. */ 535DEFTREECODE (TYPE_REQ, "type_req", tcc_expression, 1) 536 537/* A requirement for an expression and its properties. The 538 first operand is the expression, and the 2nd is its type. 539 The accessor COMPOUND_REQ_NOEXCEPT determines whether 540 the noexcept keyword was present. */ 541DEFTREECODE (COMPOUND_REQ, "compound_req", tcc_expression, 2) 542 543/* A requires clause within a requires expression. */ 544DEFTREECODE (NESTED_REQ, "nested_req", tcc_expression, 1) 545 546/* Constraints are modeled as kinds of expressions. 547 The operands of a constraint can be either types or expressions. 548 Unlike expressions, constraints do not have a type. */ 549 550/* An atomic constraint evaluates an expression E. The operand of the 551 constraint is its parameter mapping. The actual expression is stored 552 in the context. 553 554 ATOMIC_CONSTR_INFO provides source info to support diagnostics. 555 ATOMIC_CONSTR_EXPR has the expression to be evaluated. 556 ATOMIC_CONSTR_PARMS is the parameter mapping for the atomic constraint 557 and is stored in the type field. */ 558DEFTREECODE (ATOMIC_CONSTR, "atomic_constr", tcc_expression, 1) 559 560/* The conjunction and disjunction of two constraints, respectively. 561 Operands are accessed using TREE_OPERAND. The third operand provides 562 source info for diagnostics. 563 564 CONJ_CONSTR_INFO and DISJ_CONSTR_INFO provide access to the source 565 information of constraints, which is stored in the TREE_TYPE. */ 566DEFTREECODE (CONJ_CONSTR, "conj_constr", tcc_expression, 2) 567DEFTREECODE (DISJ_CONSTR, "disj_constr", tcc_expression, 2) 568 569/* A check constraint represents the checking of a concept 570 C. It has two operands: the template defining the concept 571 and a sequence of template arguments. 572 573 CHECK_CONSTR_CONCEPT has the concept definition 574 CHECK_CONSTR_ARGUMENTS are the template arguments */ 575DEFTREECODE (CHECK_CONSTR, "check_constr", tcc_expression, 2) 576 577/* The co_await expression is used to support coroutines. 578 579 Op 0 is the cast expresssion (potentially modified by the 580 promise "await_transform()" method). 581 Op1 is a proxy for the temp / coro frame slot 'e' value. 582 Op2 is the initialiser for Op1 (Op0, potentially modified by any 583 applicable 'co_await' operator). 584 Op3 is a vector of the [0] e.ready, [1] e.suspend and [2] e.resume calls. 585 Op4 is a mode : 0 (await) 1 (yield) 2 (initial) 3 (final) */ 586DEFTREECODE (CO_AWAIT_EXPR, "co_await", tcc_expression, 5) 587 588/* The co_yield expression is used to support coroutines. 589 590 Op0 is the original expr (for use in diagnostics) 591 Op2 is the co_await derived from this. */ 592DEFTREECODE (CO_YIELD_EXPR, "co_yield", tcc_expression, 2) 593 594/* The co_return expression is used to support coroutines. 595 596 Op0 is the original expr, can be void (for use in diagnostics) 597 Op1 is the promise return_xxxx call for for the expression given. */ 598 599DEFTREECODE (CO_RETURN_EXPR, "co_return", tcc_statement, 2) 600 601/* 602Local variables: 603mode:c 604End: 605*/ 606