source: arduino-1-6-7/trunk/fuentes/arduino-ide-amd64/hardware/tools/avr/lib/gcc/avr/4.9.2/plugin/include/cp/cp-tree.def @ 4837

Last change on this file since 4837 was 4837, checked in by daduve, 2 years ago

Adding new version

File size: 21.0 KB
Line 
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-2014 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   TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO is NULL_TREE
167   and TYPE_NAME is a TEMPLATE_DECL.  */
168DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", tcc_type, 0)
169
170/* The ordering of the following codes is optimized for the checking
171   macros in tree.h.  Changing the order will degrade the speed of the
172   compiler.  TEMPLATE_TYPE_PARM, TYPENAME_TYPE, TYPEOF_TYPE,
173   BOUND_TEMPLATE_TEMPLATE_PARM.  */
174
175/* Index into a template parameter list.  This parameter must be a type.
176   The type.values field will be a TEMPLATE_PARM_INDEX.  */
177DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", tcc_type, 0)
178
179/* A type designated by `typename T::t'.  TYPE_CONTEXT is `T',
180   TYPE_NAME is an IDENTIFIER_NODE for `t'.  If the type was named via
181   template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR.
182   TREE_TYPE is always NULL.  */
183DEFTREECODE (TYPENAME_TYPE, "typename_type", tcc_type, 0)
184
185/* A type designated by `__typeof (expr)'.  TYPEOF_TYPE_EXPR is the
186   expression in question.  */
187DEFTREECODE (TYPEOF_TYPE, "typeof_type", tcc_type, 0)
188
189/* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments
190   like TT<int>.
191   In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the
192   template name and its bound arguments.  TYPE_NAME is a TYPE_DECL.  */
193DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm",
194             tcc_type, 0)
195
196/* For template template argument of the form `T::template C'.
197   TYPE_CONTEXT is `T', the template parameter dependent object.
198   TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template.  */
199DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", tcc_type, 0)
200
201/* A using declaration.  USING_DECL_SCOPE contains the specified
202   scope.  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 default argument.  Holds a vector of input tokens and
211   a vector of places where the argument was instantiated before
212   parsing had occurred.  */
213DEFTREECODE (DEFAULT_ARG, "default_arg", tcc_exceptional, 0)
214
215/* An uninstantiated noexcept-specification.  DEFERRED_NOEXCEPT_PATTERN is
216   the pattern from the template, and DEFERRED_NOEXCEPT_ARGS are the
217   template arguments to substitute into the pattern when needed.  */
218DEFTREECODE (DEFERRED_NOEXCEPT, "deferred_noexcept", tcc_exceptional, 0)
219
220/* A template-id, like foo<int>.  The first operand is the template.
221   The second is NULL if there are no explicit arguments, or a
222   TREE_VEC of arguments.  The template will be a FUNCTION_DECL,
223   TEMPLATE_DECL, or an OVERLOAD.  If the template-id refers to a
224   member template, the template may be an IDENTIFIER_NODE.  */
225DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", tcc_expression, 2)
226
227/* A list-like node for chaining overloading candidates. TREE_TYPE is
228   the original name, and the parameter is the FUNCTION_DECL.  */
229DEFTREECODE (OVERLOAD, "overload", tcc_exceptional, 0)
230
231/* A pseudo-destructor, of the form "OBJECT.~DESTRUCTOR" or
232   "OBJECT.SCOPE::~DESTRUCTOR.  The first operand is the OBJECT.  The
233   second operand (if non-NULL) is the SCOPE.  The third operand is
234   the TYPE node corresponding to the DESTRUCTOR.  The type of the
235   first operand will always be a scalar type.
236
237   The type of a PSEUDO_DTOR_EXPR is always "void", even though it can
238   be used as if it were a zero-argument function.  We handle the
239   function-call case specially, and giving it "void" type prevents it
240   being used in expressions in ways that are not permitted.  */
241DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", tcc_expression, 3)
242
243/* A whole bunch of tree codes for the initial, superficial parsing of
244   templates.  */
245DEFTREECODE (MODOP_EXPR, "modop_expr", tcc_expression, 3)
246DEFTREECODE (CAST_EXPR, "cast_expr", tcc_unary, 1)
247DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", tcc_unary, 1)
248DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", tcc_unary, 1)
249DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", tcc_unary, 1)
250DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", tcc_unary, 1)
251DEFTREECODE (IMPLICIT_CONV_EXPR, "implicit_conv_expr", tcc_unary, 1)
252DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", tcc_expression, 2)
253DEFTREECODE (TYPEID_EXPR, "typeid_expr", tcc_expression, 1)
254DEFTREECODE (NOEXCEPT_EXPR, "noexcept_expr", tcc_unary, 1)
255
256/* A placeholder for an expression that is not type-dependent, but
257   does occur in a template.  When an expression that is not
258   type-dependent appears in a larger expression, we must compute the
259   type of that larger expression.  That computation would normally
260   modify the original expression, which would change the mangling of
261   that expression if it appeared in a template argument list.  In
262   that situation, we create a NON_DEPENDENT_EXPR to take the place of
263   the original expression.  The expression is the only operand -- it
264   is only needed for diagnostics.  */
265DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", tcc_expression, 1)
266
267/* CTOR_INITIALIZER is a placeholder in template code for a call to
268   setup_vtbl_pointer (and appears in all functions, not just ctors).  */
269DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", tcc_expression, 1)
270
271DEFTREECODE (TRY_BLOCK, "try_block", tcc_statement, 2)
272
273DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", tcc_statement, 2)
274
275/* A HANDLER wraps a catch handler for the HANDLER_TYPE.  If this is
276   CATCH_ALL_TYPE, then the handler catches all types.  The declaration of
277   the catch variable is in HANDLER_PARMS, and the body block in
278   HANDLER_BODY.  */
279DEFTREECODE (HANDLER, "handler", tcc_statement, 2)
280
281/* A MUST_NOT_THROW_EXPR wraps an expression that may not
282   throw, and must call terminate if it does.  The second argument
283   is a condition, used in templates to express noexcept (condition).  */
284DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", tcc_expression, 2)
285
286/* A CLEANUP_STMT marks the point at which a declaration is fully
287   constructed.  The CLEANUP_EXPR is run on behalf of CLEANUP_DECL
288   when CLEANUP_BODY completes.  */
289DEFTREECODE (CLEANUP_STMT, "cleanup_stmt", tcc_statement, 3)
290
291/* Represents an 'if' statement. The operands are IF_COND,
292   THEN_CLAUSE, and ELSE_CLAUSE, and the current scope, respectively.  */
293/* ??? It is currently still necessary to distinguish between IF_STMT
294   and COND_EXPR for the benefit of templates.  */
295DEFTREECODE (IF_STMT, "if_stmt", tcc_statement, 4)
296
297/* Used to represent a `for' statement. The operands are
298   FOR_INIT_STMT, FOR_COND, FOR_EXPR, and FOR_BODY, respectively.  */
299DEFTREECODE (FOR_STMT, "for_stmt", tcc_statement, 5)
300
301/* Used to represent a range-based `for' statement. The operands are
302   RANGE_FOR_DECL, RANGE_FOR_EXPR, RANGE_FOR_BODY, and RANGE_FOR_SCOPE,
303   respectively.  Only used in templates.  */
304DEFTREECODE (RANGE_FOR_STMT, "range_for_stmt", tcc_statement, 4)
305
306/* Used to represent a 'while' statement. The operands are WHILE_COND
307   and WHILE_BODY, respectively.  */
308DEFTREECODE (WHILE_STMT, "while_stmt", tcc_statement, 2)
309
310/* Used to represent a 'do' statement. The operands are DO_BODY and
311   DO_COND, respectively.  */
312DEFTREECODE (DO_STMT, "do_stmt", tcc_statement, 2)
313
314/* Used to represent a 'break' statement.  */
315DEFTREECODE (BREAK_STMT, "break_stmt", tcc_statement, 0)
316
317/* Used to represent a 'continue' statement.  */
318DEFTREECODE (CONTINUE_STMT, "continue_stmt", tcc_statement, 0)
319
320/* Used to represent a 'switch' statement. The operands are
321   SWITCH_STMT_COND, SWITCH_STMT_BODY, SWITCH_STMT_TYPE, and
322   SWITCH_STMT_SCOPE, respectively.  */
323DEFTREECODE (SWITCH_STMT, "switch_stmt", tcc_statement, 4)
324
325/* Used to represent an expression statement.  Use `EXPR_STMT_EXPR' to
326   obtain the expression.  */
327DEFTREECODE (EXPR_STMT, "expr_stmt", tcc_expression, 1)
328
329DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0)
330
331/* Represents an 'offsetof' expression during template expansion.  */
332DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 1)
333
334/* Represents the -> operator during template expansion.  */
335DEFTREECODE (ARROW_EXPR, "arrow_expr", tcc_expression, 1)
336
337/* Represents an '__alignof__' expression during template
338   expansion.  */
339DEFTREECODE (ALIGNOF_EXPR, "alignof_expr", tcc_expression, 1)
340
341/* Represents an Objective-C++ '@encode' expression during template
342   expansion.  */
343DEFTREECODE (AT_ENCODE_EXPR, "at_encode_expr", tcc_expression, 1)
344
345/* A STMT_EXPR represents a statement-expression during template
346   expansion.  This is the GCC extension { ( ... ) }.  The
347   STMT_EXPR_STMT is the statement given by the expression.  */
348DEFTREECODE (STMT_EXPR, "stmt_expr", tcc_expression, 1)
349
350/* Unary plus. Operand 0 is the expression to which the unary plus
351   is applied.  */
352DEFTREECODE (UNARY_PLUS_EXPR, "unary_plus_expr", tcc_unary, 1)
353
354/** C++0x extensions. */
355
356/* A static assertion.  This is a C++0x extension.
357   STATIC_ASSERT_CONDITION contains the condition that is being
358   checked.  STATIC_ASSERT_MESSAGE contains the message (a string
359   literal) to be displayed if the condition fails to hold.  */
360DEFTREECODE (STATIC_ASSERT, "static_assert", tcc_exceptional, 0)
361
362/* Represents an argument pack of types (or templates). An argument
363   pack stores zero or more arguments that will be used to instantiate
364   a parameter pack.
365
366   ARGUMENT_PACK_ARGS retrieves the arguments stored in the argument
367   pack.
368
369   Example:
370     template<typename... Values>
371     class tuple { ... };
372
373     tuple<int, float, double> t;
374
375   Values is a (template) parameter pack. When tuple<int, float,
376   double> is instantiated, the Values parameter pack is instantiated
377   with the argument pack <int, float, double>. ARGUMENT_PACK_ARGS will
378   be a TREE_VEC containing int, float, and double.  */
379DEFTREECODE (TYPE_ARGUMENT_PACK, "type_argument_pack", tcc_type, 0)
380
381/* Represents an argument pack of values, which can be used either for
382   non-type template arguments or function call arguments.
383
384   NONTYPE_ARGUMENT_PACK plays precisely the same role as
385   TYPE_ARGUMENT_PACK, but will be used for packing non-type template
386   arguments (e.g., "int... Dimensions") or function arguments ("const
387   Args&... args"). */
388DEFTREECODE (NONTYPE_ARGUMENT_PACK, "nontype_argument_pack", tcc_expression, 1)
389
390/* Represents a type expression that will be expanded into a list of
391   types when instantiated with one or more argument packs.
392
393   PACK_EXPANSION_PATTERN retrieves the expansion pattern. This is
394   the type or expression that we will substitute into with each
395   argument in an argument pack.
396
397   SET_PACK_EXPANSION_PATTERN sets the expansion pattern.
398
399   PACK_EXPANSION_PARAMETER_PACKS contains a TREE_LIST of the parameter
400   packs that are used in this pack expansion.
401
402   Example:
403     template<typename... Values>
404     struct tied : tuple<Values&...> {
405       // ...
406     };
407
408   The derivation from tuple contains a TYPE_PACK_EXPANSION for the
409   template arguments. Its PACK_EXPANSION_PATTERN is "Values&" and its
410   PACK_EXPANSION_PARAMETER_PACKS will contain "Values".  */
411DEFTREECODE (TYPE_PACK_EXPANSION, "type_pack_expansion", tcc_type, 0)
412
413/* Represents an expression that will be expanded into a list of
414   expressions when instantiated with one or more argument packs.
415
416   EXPR_PACK_EXPANSION plays precisely the same role as TYPE_PACK_EXPANSION,
417   but will be used for expressions.  */
418DEFTREECODE (EXPR_PACK_EXPANSION, "expr_pack_expansion", tcc_expression, 3)
419
420/* Selects the Ith parameter out of an argument pack. This node will
421   be used when instantiating pack expansions; see
422   tsubst_pack_expansion.
423
424   ARGUMENT_PACK_SELECT_FROM_PACK contains the *_ARGUMENT_PACK node
425   from which the argument will be selected.
426
427   ARGUMENT_PACK_SELECT_INDEX contains the index into the argument
428   pack that will be returned by this ARGUMENT_PACK_SELECT node. The
429   index is a machine integer.  */
430DEFTREECODE (ARGUMENT_PACK_SELECT, "argument_pack_select", tcc_exceptional, 0)
431
432/** C++ extensions. */
433
434/* Represents a trait expression during template expansion.  */
435DEFTREECODE (TRAIT_EXPR, "trait_expr", tcc_exceptional, 0)
436
437/* A lambda expression.  This is a C++0x extension.
438   LAMBDA_EXPR_DEFAULT_CAPTURE_MODE is an enum for the default, which may be
439   none.
440   LAMBDA_EXPR_CAPTURE_LIST holds the capture-list, including `this'.
441   LAMBDA_EXPR_THIS_CAPTURE goes straight to the capture of `this', if it exists.
442   LAMBDA_EXPR_PENDING_PROXIES is a vector of capture proxies which need to
443   be pushed once scope returns to the lambda.
444   LAMBDA_EXPR_MUTABLE_P signals whether this lambda was declared mutable.
445   LAMBDA_EXPR_RETURN_TYPE holds the return type, if it was specified.  */
446DEFTREECODE (LAMBDA_EXPR, "lambda_expr", tcc_exceptional, 0)
447
448/* The declared type of an expression.  This is a C++0x extension.
449   DECLTYPE_TYPE_EXPR is the expression whose type we are computing.
450   DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P states whether the
451   expression was parsed as an id-expression or a member access
452   expression. When false, it was parsed as a full expression.
453   DECLTYPE_FOR_LAMBDA_CAPTURE is set if we want lambda capture semantics.
454   DECLTYPE_FOR_LAMBDA_RETURN is set if we want lambda return deduction.  */
455DEFTREECODE (DECLTYPE_TYPE, "decltype_type", tcc_type, 0)
456
457/* A type designated by `__underlying_type (type)'.
458   UNDERLYING_TYPE_TYPE is the type in question.  */
459DEFTREECODE (UNDERLYING_TYPE, "underlying_type", tcc_type, 0)
460
461/* A type designated by one of the bases type traits.
462   BASES_TYPE is the type in question.  */
463DEFTREECODE (BASES, "bases", tcc_type, 0)
464
465/* Used to represent the template information stored by template
466   specializations.
467   The accessors are:
468   TI_TEMPLATE the template declaration associated to the specialization
469   TI_ARGS the arguments of the template specialization
470   TI_TYPEDEFS_NEEDING_ACCESS_CHECKING the vector of typedefs used in
471   the pattern of the template for which access check is needed at template
472   instantiation time.  */
473DEFTREECODE (TEMPLATE_INFO, "template_info", tcc_exceptional, 0)
474
475/*
476Local variables:
477mode:c
478End:
479*/
Note: See TracBrowser for help on using the repository browser.