|
111
|
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).
|
|
131
|
4 Copyright (C) 1987-2018 Free Software Foundation, Inc.
|
|
111
|
5 Hacked by Michael Tiemann (tiemann@cygnus.com)
|
|
|
6
|
|
|
7 This file is part of GCC.
|
|
|
8
|
|
|
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)
|
|
|
12 any later version.
|
|
|
13
|
|
|
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.
|
|
|
18
|
|
|
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/>. */
|
|
|
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. */
|
|
|
41 DEFTREECODE (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'. */
|
|
|
46 DEFTREECODE (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. */
|
|
|
52 DEFTREECODE (NEW_EXPR, "nw_expr", tcc_expression, 4)
|
|
|
53 DEFTREECODE (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. */
|
|
|
58 DEFTREECODE (DELETE_EXPR, "dl_expr", tcc_expression, 2)
|
|
|
59 DEFTREECODE (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). */
|
|
|
64 DEFTREECODE (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). */
|
|
|
69 DEFTREECODE (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. */
|
|
|
73 DEFTREECODE (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. */
|
|
|
80 DEFTREECODE (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. */
|
|
|
85 DEFTREECODE (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. */
|
|
|
89 DEFTREECODE (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. */
|
|
|
93 DEFTREECODE (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. */
|
|
|
107 DEFTREECODE (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 */
|
|
|
124 DEFTREECODE (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. */
|
|
|
159 DEFTREECODE (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. */
|
|
|
167 DEFTREECODE (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. */
|
|
|
176 DEFTREECODE (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. */
|
|
|
182 DEFTREECODE (TYPENAME_TYPE, "typename_type", tcc_type, 0)
|
|
|
183
|
|
|
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)
|
|
|
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. */
|
|
|
192 DEFTREECODE (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. */
|
|
|
198 DEFTREECODE (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. */
|
|
|
205 DEFTREECODE (USING_DECL, "using_decl", tcc_declaration, 0)
|
|
|
206
|
|
|
207 /* A using directive. The operand is USING_STMT_NAMESPACE. */
|
|
|
208 DEFTREECODE (USING_STMT, "using_stmt", tcc_statement, 1)
|
|
|
209
|
|
|
210 /* An un-parsed default argument. Holds a vector of input tokens and
|
|
|
211 a vector of places where the argument was instantiated before
|
|
|
212 parsing had occurred. */
|
|
|
213 DEFTREECODE (DEFAULT_ARG, "default_arg", tcc_exceptional, 0)
|
|
|
214
|
|
|
215 /* An uninstantiated/unevaluated noexcept-specification. For the
|
|
|
216 uninstantiated case, DEFERRED_NOEXCEPT_PATTERN is the pattern from the
|
|
|
217 template, and DEFERRED_NOEXCEPT_ARGS are the template arguments to
|
|
|
218 substitute into the pattern when needed. For the unevaluated case,
|
|
|
219 those slots are NULL_TREE and we use get_defaulted_eh_spec to find
|
|
|
220 the exception-specification. */
|
|
|
221 DEFTREECODE (DEFERRED_NOEXCEPT, "deferred_noexcept", tcc_exceptional, 0)
|
|
|
222
|
|
|
223 /* A template-id, like foo<int>. The first operand is the template.
|
|
|
224 The second is NULL if there are no explicit arguments, or a
|
|
|
225 TREE_VEC of arguments. The template will be a FUNCTION_DECL,
|
|
|
226 TEMPLATE_DECL, or an OVERLOAD. If the template-id refers to a
|
|
|
227 member template, the template may be an IDENTIFIER_NODE. */
|
|
|
228 DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", tcc_expression, 2)
|
|
|
229
|
|
|
230 /* One of a set of overloaded functions. */
|
|
|
231 DEFTREECODE (OVERLOAD, "overload", tcc_exceptional, 0)
|
|
|
232
|
|
|
233 /* A pseudo-destructor, of the form "OBJECT.~DESTRUCTOR" or
|
|
|
234 "OBJECT.SCOPE::~DESTRUCTOR. The first operand is the OBJECT. The
|
|
|
235 second operand (if non-NULL) is the SCOPE. The third operand is
|
|
|
236 the TYPE node corresponding to the DESTRUCTOR. The type of the
|
|
|
237 first operand will always be a scalar type.
|
|
|
238
|
|
|
239 The type of a PSEUDO_DTOR_EXPR is always "void", even though it can
|
|
|
240 be used as if it were a zero-argument function. We handle the
|
|
|
241 function-call case specially, and giving it "void" type prevents it
|
|
|
242 being used in expressions in ways that are not permitted. */
|
|
|
243 DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", tcc_expression, 3)
|
|
|
244
|
|
|
245 /* A whole bunch of tree codes for the initial, superficial parsing of
|
|
|
246 templates. */
|
|
|
247 DEFTREECODE (MODOP_EXPR, "modop_expr", tcc_expression, 3)
|
|
|
248 DEFTREECODE (CAST_EXPR, "cast_expr", tcc_unary, 1)
|
|
|
249 DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", tcc_unary, 1)
|
|
|
250 DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", tcc_unary, 1)
|
|
|
251 DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", tcc_unary, 1)
|
|
|
252 DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", tcc_unary, 1)
|
|
|
253 DEFTREECODE (IMPLICIT_CONV_EXPR, "implicit_conv_expr", tcc_unary, 1)
|
|
|
254 DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", tcc_expression, 2)
|
|
|
255 DEFTREECODE (TYPEID_EXPR, "typeid_expr", tcc_expression, 1)
|
|
|
256 DEFTREECODE (NOEXCEPT_EXPR, "noexcept_expr", tcc_unary, 1)
|
|
|
257
|
|
|
258 /* A placeholder for an expression that is not type-dependent, but
|
|
|
259 does occur in a template. When an expression that is not
|
|
|
260 type-dependent appears in a larger expression, we must compute the
|
|
|
261 type of that larger expression. That computation would normally
|
|
|
262 modify the original expression, which would change the mangling of
|
|
|
263 that expression if it appeared in a template argument list. In
|
|
|
264 that situation, we create a NON_DEPENDENT_EXPR to take the place of
|
|
|
265 the original expression. The expression is the only operand -- it
|
|
|
266 is only needed for diagnostics. */
|
|
|
267 DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", tcc_expression, 1)
|
|
|
268
|
|
|
269 /* CTOR_INITIALIZER is a placeholder in template code for a call to
|
|
|
270 setup_vtbl_pointer (and appears in all functions, not just ctors). */
|
|
|
271 DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", tcc_expression, 1)
|
|
|
272
|
|
|
273 DEFTREECODE (TRY_BLOCK, "try_block", tcc_statement, 2)
|
|
|
274
|
|
|
275 DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", tcc_statement, 2)
|
|
|
276
|
|
|
277 /* A HANDLER wraps a catch handler for the HANDLER_TYPE. If this is
|
|
|
278 CATCH_ALL_TYPE, then the handler catches all types. The declaration of
|
|
|
279 the catch variable is in HANDLER_PARMS, and the body block in
|
|
|
280 HANDLER_BODY. */
|
|
|
281 DEFTREECODE (HANDLER, "handler", tcc_statement, 2)
|
|
|
282
|
|
|
283 /* A MUST_NOT_THROW_EXPR wraps an expression that may not
|
|
|
284 throw, and must call terminate if it does. The second argument
|
|
|
285 is a condition, used in templates to express noexcept (condition). */
|
|
|
286 DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", tcc_expression, 2)
|
|
|
287
|
|
|
288 /* A CLEANUP_STMT marks the point at which a declaration is fully
|
|
|
289 constructed. The CLEANUP_EXPR is run on behalf of CLEANUP_DECL
|
|
|
290 when CLEANUP_BODY completes. */
|
|
|
291 DEFTREECODE (CLEANUP_STMT, "cleanup_stmt", tcc_statement, 3)
|
|
|
292
|
|
|
293 /* Represents an 'if' statement. The operands are IF_COND,
|
|
|
294 THEN_CLAUSE, and ELSE_CLAUSE, and the current scope, respectively. */
|
|
|
295 /* ??? It is currently still necessary to distinguish between IF_STMT
|
|
|
296 and COND_EXPR for the benefit of templates. */
|
|
|
297 DEFTREECODE (IF_STMT, "if_stmt", tcc_statement, 4)
|
|
|
298
|
|
|
299 /* Used to represent a `for' statement. The operands are
|
|
|
300 FOR_INIT_STMT, FOR_COND, FOR_EXPR, and FOR_BODY, respectively. */
|
|
|
301 DEFTREECODE (FOR_STMT, "for_stmt", tcc_statement, 5)
|
|
|
302
|
|
|
303 /* Used to represent a range-based `for' statement. The operands are
|
|
131
|
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
|
|
|
306 templates. */
|
|
|
307 DEFTREECODE (RANGE_FOR_STMT, "range_for_stmt", tcc_statement, 6)
|
|
111
|
308
|
|
|
309 /* Used to represent a 'while' statement. The operands are WHILE_COND
|
|
|
310 and WHILE_BODY, respectively. */
|
|
|
311 DEFTREECODE (WHILE_STMT, "while_stmt", tcc_statement, 2)
|
|
|
312
|
|
|
313 /* Used to represent a 'do' statement. The operands are DO_BODY and
|
|
|
314 DO_COND, respectively. */
|
|
|
315 DEFTREECODE (DO_STMT, "do_stmt", tcc_statement, 2)
|
|
|
316
|
|
|
317 /* Used to represent a 'break' statement. */
|
|
|
318 DEFTREECODE (BREAK_STMT, "break_stmt", tcc_statement, 0)
|
|
|
319
|
|
|
320 /* Used to represent a 'continue' statement. */
|
|
|
321 DEFTREECODE (CONTINUE_STMT, "continue_stmt", tcc_statement, 0)
|
|
|
322
|
|
|
323 /* Used to represent a 'switch' statement. The operands are
|
|
|
324 SWITCH_STMT_COND, SWITCH_STMT_BODY, SWITCH_STMT_TYPE, and
|
|
|
325 SWITCH_STMT_SCOPE, respectively. */
|
|
|
326 DEFTREECODE (SWITCH_STMT, "switch_stmt", tcc_statement, 4)
|
|
|
327
|
|
|
328 /* Used to represent an expression statement. Use `EXPR_STMT_EXPR' to
|
|
|
329 obtain the expression. */
|
|
|
330 DEFTREECODE (EXPR_STMT, "expr_stmt", tcc_expression, 1)
|
|
|
331
|
|
|
332 DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0)
|
|
|
333
|
|
|
334 /* Represents an 'offsetof' expression during template expansion. */
|
|
|
335 DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 2)
|
|
|
336
|
|
|
337 /* Represents an '__builtin_addressof' expression during template
|
|
|
338 expansion. This is similar to ADDR_EXPR, but it doesn't invoke
|
|
|
339 overloaded & operators. */
|
|
|
340 DEFTREECODE (ADDRESSOF_EXPR, "addressof_expr", tcc_expression, 1)
|
|
|
341
|
|
|
342 /* Represents the -> operator during template expansion. */
|
|
|
343 DEFTREECODE (ARROW_EXPR, "arrow_expr", tcc_expression, 1)
|
|
|
344
|
|
|
345 /* Represents an '__alignof__' expression during template
|
|
|
346 expansion. */
|
|
|
347 DEFTREECODE (ALIGNOF_EXPR, "alignof_expr", tcc_expression, 1)
|
|
|
348
|
|
|
349 /* Represents an Objective-C++ '@encode' expression during template
|
|
|
350 expansion. */
|
|
|
351 DEFTREECODE (AT_ENCODE_EXPR, "at_encode_expr", tcc_expression, 1)
|
|
|
352
|
|
|
353 /* A STMT_EXPR represents a statement-expression during template
|
|
|
354 expansion. This is the GCC extension { ( ... ) }. The
|
|
|
355 STMT_EXPR_STMT is the statement given by the expression. */
|
|
|
356 DEFTREECODE (STMT_EXPR, "stmt_expr", tcc_expression, 1)
|
|
|
357
|
|
|
358 /* Unary plus. Operand 0 is the expression to which the unary plus
|
|
|
359 is applied. */
|
|
|
360 DEFTREECODE (UNARY_PLUS_EXPR, "unary_plus_expr", tcc_unary, 1)
|
|
|
361
|
|
|
362 /** C++11 extensions. */
|
|
|
363
|
|
|
364 /* A static assertion. This is a C++11 extension.
|
|
|
365 STATIC_ASSERT_CONDITION contains the condition that is being
|
|
|
366 checked. STATIC_ASSERT_MESSAGE contains the message (a string
|
|
|
367 literal) to be displayed if the condition fails to hold. */
|
|
|
368 DEFTREECODE (STATIC_ASSERT, "static_assert", tcc_exceptional, 0)
|
|
|
369
|
|
|
370 /* Represents an argument pack of types (or templates). An argument
|
|
|
371 pack stores zero or more arguments that will be used to instantiate
|
|
|
372 a parameter pack.
|
|
|
373
|
|
|
374 ARGUMENT_PACK_ARGS retrieves the arguments stored in the argument
|
|
|
375 pack.
|
|
|
376
|
|
|
377 Example:
|
|
|
378 template<typename... Values>
|
|
|
379 class tuple { ... };
|
|
|
380
|
|
|
381 tuple<int, float, double> t;
|
|
|
382
|
|
|
383 Values is a (template) parameter pack. When tuple<int, float,
|
|
|
384 double> is instantiated, the Values parameter pack is instantiated
|
|
|
385 with the argument pack <int, float, double>. ARGUMENT_PACK_ARGS will
|
|
|
386 be a TREE_VEC containing int, float, and double. */
|
|
|
387 DEFTREECODE (TYPE_ARGUMENT_PACK, "type_argument_pack", tcc_type, 0)
|
|
|
388
|
|
|
389 /* Represents an argument pack of values, which can be used either for
|
|
|
390 non-type template arguments or function call arguments.
|
|
|
391
|
|
|
392 NONTYPE_ARGUMENT_PACK plays precisely the same role as
|
|
|
393 TYPE_ARGUMENT_PACK, but will be used for packing non-type template
|
|
|
394 arguments (e.g., "int... Dimensions") or function arguments ("const
|
|
|
395 Args&... args"). */
|
|
|
396 DEFTREECODE (NONTYPE_ARGUMENT_PACK, "nontype_argument_pack", tcc_expression, 1)
|
|
|
397
|
|
|
398 /* Represents a type expression that will be expanded into a list of
|
|
|
399 types when instantiated with one or more argument packs.
|
|
|
400
|
|
|
401 PACK_EXPANSION_PATTERN retrieves the expansion pattern. This is
|
|
|
402 the type or expression that we will substitute into with each
|
|
|
403 argument in an argument pack.
|
|
|
404
|
|
|
405 SET_PACK_EXPANSION_PATTERN sets the expansion pattern.
|
|
|
406
|
|
|
407 PACK_EXPANSION_PARAMETER_PACKS contains a TREE_LIST of the parameter
|
|
|
408 packs that are used in this pack expansion.
|
|
|
409
|
|
|
410 Example:
|
|
|
411 template<typename... Values>
|
|
|
412 struct tied : tuple<Values&...> {
|
|
|
413 // ...
|
|
|
414 };
|
|
|
415
|
|
|
416 The derivation from tuple contains a TYPE_PACK_EXPANSION for the
|
|
|
417 template arguments. Its PACK_EXPANSION_PATTERN is "Values&" and its
|
|
|
418 PACK_EXPANSION_PARAMETER_PACKS will contain "Values". */
|
|
|
419 DEFTREECODE (TYPE_PACK_EXPANSION, "type_pack_expansion", tcc_type, 0)
|
|
|
420
|
|
|
421 /* Represents an expression that will be expanded into a list of
|
|
|
422 expressions when instantiated with one or more argument packs.
|
|
|
423
|
|
|
424 EXPR_PACK_EXPANSION plays precisely the same role as TYPE_PACK_EXPANSION,
|
|
|
425 but will be used for expressions. */
|
|
|
426 DEFTREECODE (EXPR_PACK_EXPANSION, "expr_pack_expansion", tcc_expression, 3)
|
|
|
427
|
|
|
428 /* Selects the Ith parameter out of an argument pack. This node will
|
|
|
429 be used when instantiating pack expansions; see
|
|
|
430 tsubst_pack_expansion.
|
|
|
431
|
|
|
432 ARGUMENT_PACK_SELECT_FROM_PACK contains the *_ARGUMENT_PACK node
|
|
|
433 from which the argument will be selected.
|
|
|
434
|
|
|
435 ARGUMENT_PACK_SELECT_INDEX contains the index into the argument
|
|
|
436 pack that will be returned by this ARGUMENT_PACK_SELECT node. The
|
|
|
437 index is a machine integer. */
|
|
|
438 DEFTREECODE (ARGUMENT_PACK_SELECT, "argument_pack_select", tcc_exceptional, 0)
|
|
|
439
|
|
|
440 /* Fold expressions allow the expansion of a template argument pack
|
|
|
441 over a binary operator.
|
|
|
442
|
|
|
443 FOLD_EXPR_MOD_P is true when the fold operation is a compound assignment
|
|
|
444 operator.
|
|
|
445
|
|
|
446 FOLD_EXPR_OP is an INTEGER_CST storing the tree code for the folded
|
|
|
447 expression. Note that when FOLDEXPR_MOD_P is true, the operator is
|
|
|
448 a compound assignment operator for that kind of expression.
|
|
|
449
|
|
|
450 FOLD_EXPR_PACK is an expression containing an unexpanded parameter pack;
|
|
|
451 when expanded, each term becomes an argument of the folded expression.
|
|
|
452
|
|
|
453 In a BINARY_FOLD_EXPRESSION, FOLD_EXPR_INIT is the non-pack argument. */
|
|
|
454 DEFTREECODE (UNARY_LEFT_FOLD_EXPR, "unary_left_fold_expr", tcc_expression, 2)
|
|
|
455 DEFTREECODE (UNARY_RIGHT_FOLD_EXPR, "unary_right_fold_expr", tcc_expression, 2)
|
|
|
456 DEFTREECODE (BINARY_LEFT_FOLD_EXPR, "binary_left_fold_expr", tcc_expression, 3)
|
|
|
457 DEFTREECODE (BINARY_RIGHT_FOLD_EXPR, "binary_right_fold_expr", tcc_expression, 3)
|
|
|
458
|
|
|
459
|
|
|
460 /** C++ extensions. */
|
|
|
461
|
|
|
462 /* Represents a trait expression during template expansion. */
|
|
|
463 DEFTREECODE (TRAIT_EXPR, "trait_expr", tcc_exceptional, 0)
|
|
|
464
|
|
|
465 /* A lambda expression. This is a C++0x extension.
|
|
|
466 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE is an enum for the default, which may be
|
|
|
467 none.
|
|
|
468 LAMBDA_EXPR_CAPTURE_LIST holds the capture-list, including `this'.
|
|
|
469 LAMBDA_EXPR_THIS_CAPTURE goes straight to the capture of `this', if it exists.
|
|
|
470 LAMBDA_EXPR_PENDING_PROXIES is a vector of capture proxies which need to
|
|
|
471 be pushed once scope returns to the lambda.
|
|
|
472 LAMBDA_EXPR_MUTABLE_P signals whether this lambda was declared mutable. */
|
|
|
473 DEFTREECODE (LAMBDA_EXPR, "lambda_expr", tcc_exceptional, 0)
|
|
|
474
|
|
|
475 /* The declared type of an expression. This is a C++0x extension.
|
|
|
476 DECLTYPE_TYPE_EXPR is the expression whose type we are computing.
|
|
|
477 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P states whether the
|
|
|
478 expression was parsed as an id-expression or a member access
|
|
|
479 expression. When false, it was parsed as a full expression.
|
|
|
480 DECLTYPE_FOR_LAMBDA_CAPTURE is set if we want lambda capture semantics.
|
|
|
481 DECLTYPE_FOR_LAMBDA_RETURN is set if we want lambda return deduction. */
|
|
|
482 DEFTREECODE (DECLTYPE_TYPE, "decltype_type", tcc_type, 0)
|
|
|
483
|
|
|
484 /* A type designated by `__underlying_type (type)'.
|
|
|
485 UNDERLYING_TYPE_TYPE is the type in question. */
|
|
|
486 DEFTREECODE (UNDERLYING_TYPE, "underlying_type", tcc_type, 0)
|
|
|
487
|
|
|
488 /* A type designated by one of the bases type traits.
|
|
|
489 BASES_TYPE is the type in question. */
|
|
|
490 DEFTREECODE (BASES, "bases", tcc_type, 0)
|
|
|
491
|
|
|
492 /* Used to represent the template information stored by template
|
|
|
493 specializations.
|
|
|
494 The accessors are:
|
|
|
495 TI_TEMPLATE the template declaration associated to the specialization
|
|
|
496 TI_ARGS the arguments of the template specialization
|
|
|
497 TI_TYPEDEFS_NEEDING_ACCESS_CHECKING the vector of typedefs used in
|
|
|
498 the pattern of the template for which access check is needed at template
|
|
|
499 instantiation time. */
|
|
|
500 DEFTREECODE (TEMPLATE_INFO, "template_info", tcc_exceptional, 0)
|
|
|
501
|
|
|
502 /* Extensions for Concepts. */
|
|
|
503
|
|
|
504 /* Used to represent information associated with constrained declarations. */
|
|
|
505 DEFTREECODE (CONSTRAINT_INFO, "constraint_info", tcc_exceptional, 0)
|
|
|
506
|
|
|
507 /* A wildcard declaration is a placeholder for a template parameter
|
|
|
508 used to resolve constrained-type-names in concepts. During
|
|
|
509 resolution, the matching argument is saved as the TREE_TYPE
|
|
|
510 of the wildcard. */
|
|
|
511 DEFTREECODE (WILDCARD_DECL, "wildcard_decl", tcc_declaration, 0)
|
|
|
512
|
|
|
513 /* A requires-expr is a binary expression. The first operand is
|
|
|
514 its parameter list (possibly NULL). The second is a list of
|
|
|
515 requirements, which are denoted by the _REQ* tree codes
|
|
|
516 below. */
|
|
|
517 DEFTREECODE (REQUIRES_EXPR, "requires_expr", tcc_expression, 2)
|
|
|
518
|
|
|
519 /* A requirement for an expression. */
|
|
|
520 DEFTREECODE (SIMPLE_REQ, "simple_req", tcc_expression, 1)
|
|
|
521
|
|
|
522 /* A requirement for a type. */
|
|
|
523 DEFTREECODE (TYPE_REQ, "type_req", tcc_expression, 1)
|
|
|
524
|
|
|
525 /* A requirement for an expression and its properties. The
|
|
|
526 first operand is the expression, and the 2nd is its type.
|
|
|
527 The accessor COMPOUND_REQ_NOEXCEPT determines whether
|
|
|
528 the noexcept keyword was present. */
|
|
|
529 DEFTREECODE (COMPOUND_REQ, "compound_req", tcc_expression, 2)
|
|
|
530
|
|
|
531 /* A requires clause within a requires expression. */
|
|
|
532 DEFTREECODE (NESTED_REQ, "nested_req", tcc_expression, 1)
|
|
|
533
|
|
|
534 /* Constraints are modeled as kinds of expressions.
|
|
|
535 The operands of a constraint can be either types or expressions.
|
|
|
536 Unlike expressions, constraints do not have a type. */
|
|
|
537
|
|
|
538 /* A predicate constraint evaluates an expression E.
|
|
|
539
|
|
|
540 PRED_CONSTR_EXPR has the expression to be evaluated. */
|
|
|
541 DEFTREECODE (PRED_CONSTR, "pred_constr", tcc_expression, 1)
|
|
|
542
|
|
|
543 /* A check constraint represents the checking of a concept
|
|
|
544 C. It has two operands: the template defining the concept
|
|
|
545 and a sequence of template arguments.
|
|
|
546
|
|
|
547 CHECK_CONSTR_CONCEPT has the concept definition
|
|
|
548 CHECK_CONSTR_ARGUMENTS are the template arguments */
|
|
|
549 DEFTREECODE (CHECK_CONSTR, "check_constr", tcc_expression, 2)
|
|
|
550
|
|
|
551 /* An expression constraint determines the validity of a expression E.
|
|
|
552
|
|
|
553 EXPR_CONST_EXPR has the expression being validated. */
|
|
|
554 DEFTREECODE (EXPR_CONSTR, "expr_constr", tcc_expression, 1)
|
|
|
555
|
|
|
556 /* A type constraint determines the validity of a type T. Note that
|
|
|
557
|
|
|
558 TYPE_CONST_TYPE has the type being validated */
|
|
|
559 DEFTREECODE (TYPE_CONSTR, "type_constr", tcc_expression, 1)
|
|
|
560
|
|
|
561 /* An implicit conversion constraint determines if an expression
|
|
|
562 E is implicitly convertible to a type T. Note that T may
|
|
|
563 be dependent but does not contain any placeholders.
|
|
|
564
|
|
|
565 ICONV_CONSTR_EXPR has the expression E.
|
|
|
566 ICONV_CONSTR_TYPE has the type T.
|
|
|
567 */
|
|
|
568 DEFTREECODE (ICONV_CONSTR, "iconv_constr", tcc_expression, 2)
|
|
|
569
|
|
|
570 /* An argument deduction constraint determines if the type of an
|
|
|
571 expression E can be deduced from a type pattern T. Note that
|
|
|
572 T must contain at least one place holder.
|
|
|
573
|
|
|
574 DEDUCT_CONSTR_EXPR has the expression E
|
|
|
575 DEDUCT_CONSTR_PATTERN has the type pattern T.
|
|
|
576 DEDUCT_CONSTR_PLACEHOLDERS has the list of placeholder nodes in T. */
|
|
|
577 DEFTREECODE (DEDUCT_CONSTR, "deduct_constr", tcc_expression, 3)
|
|
|
578
|
|
|
579 /* An exception constraint determines if, for an expression E,
|
|
|
580 noexcept(E) is true.
|
|
|
581
|
|
|
582 EXCEPT_CONSTR_EXPR has the expression E. */
|
|
|
583 DEFTREECODE (EXCEPT_CONSTR, "except_constr", tcc_expression, 1)
|
|
|
584
|
|
|
585 /* A parameterized constraint declares constraint variables, which
|
|
|
586 are used in expression, type, and exception constraints.
|
|
|
587
|
|
|
588 PARM_CONSTR_PARMS has a TREE_LIST of parameter declarations.
|
|
|
589 PARM_CONSTR_OPERAND has the nested constraint. */
|
|
|
590 DEFTREECODE (PARM_CONSTR, "parm_constr", tcc_expression, 2)
|
|
|
591
|
|
|
592 /* The conjunction and disjunction of two constraints, respectively.
|
|
|
593 Operands are accessed using TREE_OPERAND. */
|
|
|
594 DEFTREECODE (CONJ_CONSTR, "conj_constr", tcc_expression, 2)
|
|
|
595 DEFTREECODE (DISJ_CONSTR, "disj_constr", tcc_expression, 2)
|
|
|
596
|
|
|
597
|
|
|
598 /*
|
|
|
599 Local variables:
|
|
|
600 mode:c
|
|
|
601 End:
|
|
|
602 */
|
