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-2013 Free Software Foundation, Inc. 5 Hacked by Michael Tiemann (tiemann (at) 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 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO is NULL_TREE 167 and TYPE_NAME is a TEMPLATE_DECL. */ 168 DEFTREECODE (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. */ 177 DEFTREECODE (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. */ 183 DEFTREECODE (TYPENAME_TYPE, "typename_type", tcc_type, 0) 184 185 /* A type designated by `__typeof (expr)'. TYPEOF_TYPE_EXPR is the 186 expression in question. */ 187 DEFTREECODE (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. */ 193 DEFTREECODE (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. */ 199 DEFTREECODE (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. */ 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 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. */ 218 DEFTREECODE (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. */ 225 DEFTREECODE (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. */ 229 DEFTREECODE (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. */ 241 DEFTREECODE (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. */ 245 DEFTREECODE (MODOP_EXPR, "modop_expr", tcc_expression, 3) 246 DEFTREECODE (CAST_EXPR, "cast_expr", tcc_unary, 1) 247 DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", tcc_unary, 1) 248 DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", tcc_unary, 1) 249 DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", tcc_unary, 1) 250 DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", tcc_unary, 1) 251 DEFTREECODE (IMPLICIT_CONV_EXPR, "implicit_conv_expr", tcc_unary, 1) 252 DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", tcc_expression, 2) 253 DEFTREECODE (TYPEID_EXPR, "typeid_expr", tcc_expression, 1) 254 DEFTREECODE (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. */ 265 DEFTREECODE (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). */ 269 DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", tcc_expression, 1) 270 271 DEFTREECODE (TRY_BLOCK, "try_block", tcc_statement, 2) 272 273 DEFTREECODE (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. */ 279 DEFTREECODE (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). */ 284 DEFTREECODE (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. */ 289 DEFTREECODE (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. */ 295 DEFTREECODE (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. */ 299 DEFTREECODE (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. */ 304 DEFTREECODE (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. */ 308 DEFTREECODE (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. */ 312 DEFTREECODE (DO_STMT, "do_stmt", tcc_statement, 2) 313 314 /* Used to represent a 'break' statement. */ 315 DEFTREECODE (BREAK_STMT, "break_stmt", tcc_statement, 0) 316 317 /* Used to represent a 'continue' statement. */ 318 DEFTREECODE (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. */ 323 DEFTREECODE (SWITCH_STMT, "switch_stmt", tcc_statement, 4) 324 325 /* Used to represent an expression statement. Use `EXPR_STMT_EXPR' to 326 obtain the expression. */ 327 DEFTREECODE (EXPR_STMT, "expr_stmt", tcc_expression, 1) 328 329 DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0) 330 331 /* Represents an 'offsetof' expression during template expansion. */ 332 DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 1) 333 334 /* Represents the -> operator during template expansion. */ 335 DEFTREECODE (ARROW_EXPR, "arrow_expr", tcc_expression, 1) 336 337 /* Represents an '__alignof__' expression during template 338 expansion. */ 339 DEFTREECODE (ALIGNOF_EXPR, "alignof_expr", tcc_expression, 1) 340 341 /* Represents an Objective-C++ '@encode' expression during template 342 expansion. */ 343 DEFTREECODE (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. */ 348 DEFTREECODE (STMT_EXPR, "stmt_expr", tcc_expression, 1) 349 350 /* Unary plus. Operand 0 is the expression to which the unary plus 351 is applied. */ 352 DEFTREECODE (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. */ 360 DEFTREECODE (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. */ 379 DEFTREECODE (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"). */ 388 DEFTREECODE (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". */ 411 DEFTREECODE (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. */ 418 DEFTREECODE (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. */ 430 DEFTREECODE (ARGUMENT_PACK_SELECT, "argument_pack_select", tcc_exceptional, 0) 431 432 /** C++ extensions. */ 433 434 /* Represents a trait expression during template expansion. */ 435 DEFTREECODE (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. */ 446 DEFTREECODE (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. */ 455 DEFTREECODE (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. */ 459 DEFTREECODE (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. */ 463 DEFTREECODE (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. */ 473 DEFTREECODE (TEMPLATE_INFO, "template_info", tcc_exceptional, 0) 474 475 /* 476 Local variables: 477 mode:c 478 End: 479 */ 480
