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)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* An OFFSET_REF is used in two situations:
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').
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
35 This form is only used during the parsing phase; once semantic
36 analysis has taken place they are eliminated.
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. */
41 DEFTREECODE (OFFSET_REF, "offset_ref", tcc_reference, 2)
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'. */
46 DEFTREECODE (PTRMEM_CST, "ptrmem_cst", tcc_constant, 0)
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. */
52 DEFTREECODE (NEW_EXPR, "nw_expr", tcc_expression, 4)
53 DEFTREECODE (VEC_NEW_EXPR, "vec_nw_expr", tcc_expression, 3)
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. */
58 DEFTREECODE (DELETE_EXPR, "dl_expr", tcc_expression, 2)
59 DEFTREECODE (VEC_DELETE_EXPR, "vec_dl_expr", tcc_expression, 2)
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). */
64 DEFTREECODE (SCOPE_REF, "scope_ref", tcc_reference, 2)
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). */
69 DEFTREECODE (MEMBER_REF, "member_ref", tcc_reference, 2)
71 /* Type conversion operator in C++. TREE_TYPE is type that this
72 operator converts to. Operand is expression to be converted. */
73 DEFTREECODE (TYPE_EXPR, "type_expr", tcc_expression, 1)
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. */
80 DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", tcc_vl_exp, 3)
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. */
85 DEFTREECODE (VEC_INIT_EXPR, "vec_init_expr", tcc_expression, 2)
87 /* A throw expression. operand 0 is the expression, if there was one,
88 else it is NULL_TREE. */
89 DEFTREECODE (THROW_EXPR, "throw_expr", tcc_expression, 1)
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. */
93 DEFTREECODE (EMPTY_CLASS_EXPR, "empty_class_expr", tcc_expression, 0)
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.
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
107 DEFTREECODE (BASELINK, "baselink", tcc_exceptional, 0)
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
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
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)
124 DEFTREECODE (TEMPLATE_DECL, "template_decl", tcc_declaration, 0)
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.
132 template <class T> // Index 0, Level 1.
135 template <class U, // Index 0, Level 2.
136 class V> // Index 1, Level 2.
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:
151 template <class U, // Index 0, Level 1, Orig Level 2
152 class V> // Index 1, Level 1, Orig Level 2
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. */
159 DEFTREECODE (TEMPLATE_PARM_INDEX, "template_parm_index", tcc_exceptional, 0)
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
165 It is used without template arguments like TT in C<TT>,
166 TYPE_NAME is a TEMPLATE_DECL. */
167 DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", tcc_type, 0)
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. */
174 /* Index into a template parameter list. This parameter must be a type.
175 The type.values field will be a TEMPLATE_PARM_INDEX. */
176 DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", tcc_type, 0)
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. */
182 DEFTREECODE (TYPENAME_TYPE, "typename_type", tcc_type, 0)
184 /* A type designated by `__typeof (expr)'. TYPEOF_TYPE_EXPR is the
185 expression in question. */
186 DEFTREECODE (TYPEOF_TYPE, "typeof_type", tcc_type, 0)
188 /* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments
190 In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the
191 template name and its bound arguments. TYPE_NAME is a TYPE_DECL. */
192 DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm",
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 a TEMPLATE_DECL, whose DECL_TEMPLATE_PARMS are any
198 template parms of the instantiation. That decl's DECL_NAME is the
199 IDENTIFIER_NODE for `C', the member class template. */
200 DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", tcc_type, 0)
202 /* A using declaration. USING_DECL_SCOPE contains the specified
203 scope. In a variadic using-declaration, this is a TYPE_PACK_EXPANSION.
204 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)
209 /* A using directive. The operand is USING_STMT_NAMESPACE. */
210 DEFTREECODE (USING_STMT, "using_stmt", tcc_statement, 1)
212 /* An un-parsed operand. Holds a vector of input tokens and
213 a vector of places where the argument was instantiated before
214 parsing had occurred. This is used for default arguments, delayed
215 NSDMIs, and noexcept-specifier parsing. */
216 DEFTREECODE (DEFERRED_PARSE, "deferred_parse", tcc_exceptional, 0)
218 /* An uninstantiated/unevaluated noexcept-specification. For the
219 uninstantiated case, DEFERRED_NOEXCEPT_PATTERN is the pattern from the
220 template, and DEFERRED_NOEXCEPT_ARGS are the template arguments to
221 substitute into the pattern when needed. For the unevaluated case,
222 those slots are NULL_TREE and we use get_defaulted_eh_spec to find
223 the exception-specification. */
224 DEFTREECODE (DEFERRED_NOEXCEPT, "deferred_noexcept", tcc_exceptional, 0)
226 /* A template-id, like foo<int>. The first operand is the template.
227 The second is NULL if there are no explicit arguments, or a
228 TREE_VEC of arguments. The template will be a FUNCTION_DECL,
229 TEMPLATE_DECL, or an OVERLOAD. If the template-id refers to a
230 member template, the template may be an IDENTIFIER_NODE. */
231 DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", tcc_expression, 2)
233 /* One of a set of overloaded functions. */
234 DEFTREECODE (OVERLOAD, "overload", tcc_exceptional, 0)
236 /* A pseudo-destructor, of the form "OBJECT.~DESTRUCTOR" or
237 "OBJECT.SCOPE::~DESTRUCTOR. The first operand is the OBJECT. The
238 second operand (if non-NULL) is the SCOPE. The third operand is
239 the TYPE node corresponding to the DESTRUCTOR. The type of the
240 first operand will always be a scalar type.
242 The type of a PSEUDO_DTOR_EXPR is always "void", even though it can
243 be used as if it were a zero-argument function. We handle the
244 function-call case specially, and giving it "void" type prevents it
245 being used in expressions in ways that are not permitted. */
246 DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", tcc_expression, 3)
248 /* A whole bunch of tree codes for the initial, superficial parsing of
250 DEFTREECODE (MODOP_EXPR, "modop_expr", tcc_expression, 3)
251 DEFTREECODE (CAST_EXPR, "cast_expr", tcc_unary, 1)
252 DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", tcc_unary, 1)
253 DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", tcc_unary, 1)
254 DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", tcc_unary, 1)
255 DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", tcc_unary, 1)
256 DEFTREECODE (IMPLICIT_CONV_EXPR, "implicit_conv_expr", tcc_unary, 1)
257 DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", tcc_expression, 2)
258 DEFTREECODE (TYPEID_EXPR, "typeid_expr", tcc_expression, 1)
259 DEFTREECODE (NOEXCEPT_EXPR, "noexcept_expr", tcc_unary, 1)
260 DEFTREECODE (SPACESHIP_EXPR, "spaceship_expr", tcc_expression, 2)
262 /* A placeholder for an expression that is not type-dependent, but
263 does occur in a template. When an expression that is not
264 type-dependent appears in a larger expression, we must compute the
265 type of that larger expression. That computation would normally
266 modify the original expression, which would change the mangling of
267 that expression if it appeared in a template argument list. In
268 that situation, we create a NON_DEPENDENT_EXPR to take the place of
269 the original expression. The expression is the only operand -- it
270 is only needed for diagnostics. */
271 DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", tcc_expression, 1)
273 /* CTOR_INITIALIZER is a placeholder in template code for a call to
274 setup_vtbl_pointer (and appears in all functions, not just ctors). */
275 DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", tcc_expression, 1)
277 DEFTREECODE (TRY_BLOCK, "try_block", tcc_statement, 2)
279 DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", tcc_statement, 2)
281 /* A HANDLER wraps a catch handler for the HANDLER_TYPE. If this is
282 CATCH_ALL_TYPE, then the handler catches all types. The declaration of
283 the catch variable is in HANDLER_PARMS, and the body block in
285 DEFTREECODE (HANDLER, "handler", tcc_statement, 2)
287 /* A MUST_NOT_THROW_EXPR wraps an expression that may not
288 throw, and must call terminate if it does. The second argument
289 is a condition, used in templates to express noexcept (condition). */
290 DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", tcc_expression, 2)
292 /* A CLEANUP_STMT marks the point at which a declaration is fully
293 constructed. The CLEANUP_EXPR is run on behalf of CLEANUP_DECL
294 when CLEANUP_BODY completes. */
295 DEFTREECODE (CLEANUP_STMT, "cleanup_stmt", tcc_statement, 3)
297 /* Represents an 'if' statement. The operands are IF_COND,
298 THEN_CLAUSE, and ELSE_CLAUSE, and the current scope, respectively. */
299 /* ??? It is currently still necessary to distinguish between IF_STMT
300 and COND_EXPR for the benefit of templates. */
301 DEFTREECODE (IF_STMT, "if_stmt", tcc_statement, 4)
303 /* Used to represent a range-based `for' statement. The operands are
304 RANGE_FOR_DECL, RANGE_FOR_EXPR, RANGE_FOR_BODY, RANGE_FOR_SCOPE,
305 RANGE_FOR_UNROLL, and RANGE_FOR_INIT_STMT, respectively. Only used in
307 DEFTREECODE (RANGE_FOR_STMT, "range_for_stmt", tcc_statement, 6)
309 /* Used to represent an expression statement. Use `EXPR_STMT_EXPR' to
310 obtain the expression. */
311 DEFTREECODE (EXPR_STMT, "expr_stmt", tcc_expression, 1)
313 DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0)
315 /* Represents an 'offsetof' expression during template expansion. */
316 DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 2)
318 /* Represents an '__builtin_addressof' expression during template
319 expansion. This is similar to ADDR_EXPR, but it doesn't invoke
320 overloaded & operators. */
321 DEFTREECODE (ADDRESSOF_EXPR, "addressof_expr", tcc_expression, 1)
323 /* Represents the -> operator during template expansion. */
324 DEFTREECODE (ARROW_EXPR, "arrow_expr", tcc_expression, 1)
326 /* Represents an '__alignof__' expression during template
328 DEFTREECODE (ALIGNOF_EXPR, "alignof_expr", tcc_expression, 1)
330 /* Represents an Objective-C++ '@encode' expression during template
332 DEFTREECODE (AT_ENCODE_EXPR, "at_encode_expr", tcc_expression, 1)
334 /* A STMT_EXPR represents a statement-expression during template
335 expansion. This is the GCC extension { ( ... ) }. The
336 STMT_EXPR_STMT is the statement given by the expression. */
337 DEFTREECODE (STMT_EXPR, "stmt_expr", tcc_expression, 1)
339 /* Unary plus. Operand 0 is the expression to which the unary plus
341 DEFTREECODE (UNARY_PLUS_EXPR, "unary_plus_expr", tcc_unary, 1)
343 /** C++11 extensions. */
345 /* A static assertion. This is a C++11 extension.
346 STATIC_ASSERT_CONDITION contains the condition that is being
347 checked. STATIC_ASSERT_MESSAGE contains the message (a string
348 literal) to be displayed if the condition fails to hold. */
349 DEFTREECODE (STATIC_ASSERT, "static_assert", tcc_exceptional, 0)
351 /* Represents an argument pack of types (or templates). An argument
352 pack stores zero or more arguments that will be used to instantiate
355 ARGUMENT_PACK_ARGS retrieves the arguments stored in the argument
359 template<typename... Values>
362 tuple<int, float, double> t;
364 Values is a (template) parameter pack. When tuple<int, float,
365 double> is instantiated, the Values parameter pack is instantiated
366 with the argument pack <int, float, double>. ARGUMENT_PACK_ARGS will
367 be a TREE_VEC containing int, float, and double. */
368 DEFTREECODE (TYPE_ARGUMENT_PACK, "type_argument_pack", tcc_type, 0)
370 /* Represents an argument pack of values, which can be used either for
371 non-type template arguments or function call arguments.
373 NONTYPE_ARGUMENT_PACK plays precisely the same role as
374 TYPE_ARGUMENT_PACK, but will be used for packing non-type template
375 arguments (e.g., "int... Dimensions") or function arguments ("const
377 DEFTREECODE (NONTYPE_ARGUMENT_PACK, "nontype_argument_pack", tcc_expression, 1)
379 /* Represents a type expression that will be expanded into a list of
380 types when instantiated with one or more argument packs.
382 PACK_EXPANSION_PATTERN retrieves the expansion pattern. This is
383 the type or expression that we will substitute into with each
384 argument in an argument pack.
386 SET_PACK_EXPANSION_PATTERN sets the expansion pattern.
388 PACK_EXPANSION_PARAMETER_PACKS contains a TREE_LIST of the parameter
389 packs that are used in this pack expansion.
392 template<typename... Values>
393 struct tied : tuple<Values&...> {
397 The derivation from tuple contains a TYPE_PACK_EXPANSION for the
398 template arguments. Its PACK_EXPANSION_PATTERN is "Values&" and its
399 PACK_EXPANSION_PARAMETER_PACKS will contain "Values". */
400 DEFTREECODE (TYPE_PACK_EXPANSION, "type_pack_expansion", tcc_type, 0)
402 /* Represents an expression that will be expanded into a list of
403 expressions when instantiated with one or more argument packs.
405 EXPR_PACK_EXPANSION plays precisely the same role as TYPE_PACK_EXPANSION,
406 but will be used for expressions. */
407 DEFTREECODE (EXPR_PACK_EXPANSION, "expr_pack_expansion", tcc_expression, 3)
409 /* Selects the Ith parameter out of an argument pack. This node will
410 be used when instantiating pack expansions; see
411 tsubst_pack_expansion.
413 ARGUMENT_PACK_SELECT_FROM_PACK contains the *_ARGUMENT_PACK node
414 from which the argument will be selected.
416 ARGUMENT_PACK_SELECT_INDEX contains the index into the argument
417 pack that will be returned by this ARGUMENT_PACK_SELECT node. The
418 index is a machine integer. */
419 DEFTREECODE (ARGUMENT_PACK_SELECT, "argument_pack_select", tcc_exceptional, 0)
421 /* Fold expressions allow the expansion of a template argument pack
422 over a binary operator.
424 FOLD_EXPR_MOD_P is true when the fold operation is a compound assignment
427 FOLD_EXPR_OP is an INTEGER_CST storing the tree code for the folded
428 expression. Note that when FOLDEXPR_MOD_P is true, the operator is
429 a compound assignment operator for that kind of expression.
431 FOLD_EXPR_PACK is an expression containing an unexpanded parameter pack;
432 when expanded, each term becomes an argument of the folded expression.
434 In a BINARY_FOLD_EXPRESSION, FOLD_EXPR_INIT is the non-pack argument. */
435 DEFTREECODE (UNARY_LEFT_FOLD_EXPR, "unary_left_fold_expr", tcc_expression, 2)
436 DEFTREECODE (UNARY_RIGHT_FOLD_EXPR, "unary_right_fold_expr", tcc_expression, 2)
437 DEFTREECODE (BINARY_LEFT_FOLD_EXPR, "binary_left_fold_expr", tcc_expression, 3)
438 DEFTREECODE (BINARY_RIGHT_FOLD_EXPR, "binary_right_fold_expr", tcc_expression, 3)
441 /** C++ extensions. */
443 /* Represents a trait expression during template expansion. */
444 DEFTREECODE (TRAIT_EXPR, "trait_expr", tcc_exceptional, 0)
446 /* A lambda expression. This is a C++0x extension.
447 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE is an enum for the default, which may be
449 LAMBDA_EXPR_CAPTURE_LIST holds the capture-list, including `this'.
450 LAMBDA_EXPR_THIS_CAPTURE goes straight to the capture of `this', if it exists.
451 LAMBDA_EXPR_PENDING_PROXIES is a vector of capture proxies which need to
452 be pushed once scope returns to the lambda.
453 LAMBDA_EXPR_MUTABLE_P signals whether this lambda was declared mutable. */
454 DEFTREECODE (LAMBDA_EXPR, "lambda_expr", tcc_exceptional, 0)
456 /* The declared type of an expression. This is a C++0x extension.
457 DECLTYPE_TYPE_EXPR is the expression whose type we are computing.
458 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P states whether the
459 expression was parsed as an id-expression or a member access
460 expression. When false, it was parsed as a full expression.
461 DECLTYPE_FOR_LAMBDA_CAPTURE is set if we want lambda capture semantics.
462 DECLTYPE_FOR_LAMBDA_RETURN is set if we want lambda return deduction. */
463 DEFTREECODE (DECLTYPE_TYPE, "decltype_type", tcc_type, 0)
465 /* A type designated by `__underlying_type (type)'.
466 UNDERLYING_TYPE_TYPE is the type in question. */
467 DEFTREECODE (UNDERLYING_TYPE, "underlying_type", tcc_type, 0)
469 /* A type designated by one of the bases type traits.
470 BASES_TYPE is the type in question. */
471 DEFTREECODE (BASES, "bases", tcc_type, 0)
473 /* Used to represent the template information stored by template
476 TI_TEMPLATE the template declaration associated to the specialization
477 TI_ARGS the arguments of the template specialization
478 TI_TYPEDEFS_NEEDING_ACCESS_CHECKING the vector of typedefs used in
479 the pattern of the template for which access check is needed at template
480 instantiation time. */
481 DEFTREECODE (TEMPLATE_INFO, "template_info", tcc_exceptional, 0)
483 /* OpenMP - #pragma omp depobj
484 Operand 0: OMP_DEPOBJ_DEPOBJ: Depobj expression
485 Operand 1: OMP_DEPOBJ_CLAUSES: List of clauses. */
486 DEFTREECODE (OMP_DEPOBJ, "omp_depobj", tcc_statement, 2)
488 /* Extensions for Concepts. */
490 /* Concept definition. This is not entirely different than a VAR_DECL
491 except that a) it must be a template, and b) doesn't have the wide
492 range of value and linkage options available to variables. */
493 DEFTREECODE (CONCEPT_DECL, "concept_decl", tcc_declaration, 0)
495 /* Used to represent information associated with constrained declarations. */
496 DEFTREECODE (CONSTRAINT_INFO, "constraint_info", tcc_exceptional, 0)
498 /* A wildcard declaration is a placeholder for a template parameter
499 used to resolve constrained-type-names in concepts. During
500 resolution, the matching argument is saved as the TREE_TYPE
502 DEFTREECODE (WILDCARD_DECL, "wildcard_decl", tcc_declaration, 0)
504 /* A requires-expr has three operands. The first operand is
505 its parameter list (possibly NULL). The second is a list of
506 requirements, which are denoted by the _REQ* tree codes
507 below. The third is a TREE_VEC of template arguments to
508 be applied when substituting into the parameter list and
509 requirements, set by tsubst_requires_expr for partial instantiations. */
510 DEFTREECODE (REQUIRES_EXPR, "requires_expr", tcc_expression, 3)
512 /* A requirement for an expression. */
513 DEFTREECODE (SIMPLE_REQ, "simple_req", tcc_expression, 1)
515 /* A requirement for a type. */
516 DEFTREECODE (TYPE_REQ, "type_req", tcc_expression, 1)
518 /* A requirement for an expression and its properties. The
519 first operand is the expression, and the 2nd is its type.
520 The accessor COMPOUND_REQ_NOEXCEPT determines whether
521 the noexcept keyword was present. */
522 DEFTREECODE (COMPOUND_REQ, "compound_req", tcc_expression, 2)
524 /* A requires clause within a requires expression. */
525 DEFTREECODE (NESTED_REQ, "nested_req", tcc_expression, 1)
527 /* Constraints are modeled as kinds of expressions.
528 The operands of a constraint can be either types or expressions.
529 Unlike expressions, constraints do not have a type. */
531 /* An atomic constraint evaluates an expression E. The operand of the
532 constraint is its parameter mapping. The actual expression is stored
535 ATOMIC_CONSTR_INFO provides source info to support diagnostics.
536 ATOMIC_CONSTR_EXPR has the expression to be evaluated.
537 ATOMIC_CONSTR_PARMS is the parameter mapping for the atomic constraint
538 and is stored in the type field. */
539 DEFTREECODE (ATOMIC_CONSTR, "atomic_constr", tcc_expression, 1)
541 /* The conjunction and disjunction of two constraints, respectively.
542 Operands are accessed using TREE_OPERAND. The third operand provides
543 source info for diagnostics.
545 CONJ_CONSTR_INFO and DISJ_CONSTR_INFO provide access to the source
546 information of constraints, which is stored in the TREE_TYPE. */
547 DEFTREECODE (CONJ_CONSTR, "conj_constr", tcc_expression, 2)
548 DEFTREECODE (DISJ_CONSTR, "disj_constr", tcc_expression, 2)
550 /* A check constraint represents the checking of a concept
551 C. It has two operands: the template defining the concept
552 and a sequence of template arguments.
554 CHECK_CONSTR_CONCEPT has the concept definition
555 CHECK_CONSTR_ARGUMENTS are the template arguments */
556 DEFTREECODE (CHECK_CONSTR, "check_constr", tcc_expression, 2)
558 /* The co_await expression is used to support coroutines.
560 Op 0 is the cast expresssion (potentially modified by the
561 promise "await_transform()" method).
562 Op1 is a proxy for the temp / coro frame slot 'e' value.
563 Op2 is the initialiser for Op1 (Op0, potentially modified by any
564 applicable 'co_await' operator).
565 Op3 is a vector of the [0] e.ready, [1] e.suspend and [2] e.resume calls.
566 Op4 is a mode : 0 (await) 1 (yield) 2 (initial) 3 (final) */
567 DEFTREECODE (CO_AWAIT_EXPR, "co_await", tcc_expression, 5)
569 /* The co_yield expression is used to support coroutines.
571 Op0 is the original expr (for use in diagnostics)
572 Op2 is the co_await derived from this. */
573 DEFTREECODE (CO_YIELD_EXPR, "co_yield", tcc_expression, 2)
575 /* The co_return expression is used to support coroutines.
577 Op0 is the original expr, can be void (for use in diagnostics)
578 Op1 is the promise return_xxxx call for for the expression given. */
580 DEFTREECODE (CO_RETURN_EXPR, "co_return", tcc_statement, 2)