1 /* Definitions for C++ parsing and type checking. 2 Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 4 Free Software Foundation, Inc. 5 Contributed 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 #ifndef GCC_CP_TREE_H 24 #define GCC_CP_TREE_H 25 26 #include "ggc.h" 27 #include "function.h" 28 #include "hashtab.h" 29 #include "splay-tree.h" 30 #include "vec.h" 31 #include "varray.h" 32 #include "c-common.h" 33 #include "name-lookup.h" 34 #include "l-ipo.h" 35 36 /* In order for the format checking to accept the C++ front end 37 diagnostic framework extensions, you must include this file before 38 toplev.h, not after. We override the definition of GCC_DIAG_STYLE 39 in c-common.h. */ 40 #undef GCC_DIAG_STYLE 41 #define GCC_DIAG_STYLE __gcc_cxxdiag__ 42 #if GCC_VERSION >= 4001 43 #define ATTRIBUTE_GCC_CXXDIAG(m, n) __attribute__ ((__format__ (GCC_DIAG_STYLE, m, n))) ATTRIBUTE_NONNULL(m) 44 #else 45 #define ATTRIBUTE_GCC_CXXDIAG(m, n) ATTRIBUTE_NONNULL(m) 46 #endif 47 extern void cp_cpp_error (cpp_reader *, int, 48 const char *, va_list *) 49 ATTRIBUTE_GCC_CXXDIAG(3,0); 50 #ifdef GCC_TOPLEV_H 51 #error \ 52 In order for the format checking to accept the C++ front end diagnostic \ 53 framework extensions, you must include this file before toplev.h, not after. 54 #endif 55 #include "toplev.h" 56 #include "diagnostic.h" 57 58 /* Usage of TREE_LANG_FLAG_?: 59 0: IDENTIFIER_MARKED (IDENTIFIER_NODEs) 60 NEW_EXPR_USE_GLOBAL (in NEW_EXPR). 61 DELETE_EXPR_USE_GLOBAL (in DELETE_EXPR). 62 COMPOUND_EXPR_OVERLOADED (in COMPOUND_EXPR). 63 TREE_INDIRECT_USING (in NAMESPACE_DECL). 64 CLEANUP_P (in TRY_BLOCK) 65 AGGR_INIT_VIA_CTOR_P (in AGGR_INIT_EXPR) 66 PTRMEM_OK_P (in ADDR_EXPR, OFFSET_REF) 67 PAREN_STRING_LITERAL (in STRING_CST) 68 DECL_PRETTY_FUNCTION_P (in VAR_DECL) 69 KOENIG_LOOKUP_P (in CALL_EXPR) 70 STATEMENT_LIST_NO_SCOPE (in STATEMENT_LIST). 71 EXPR_STMT_STMT_EXPR_RESULT (in EXPR_STMT) 72 STMT_EXPR_NO_SCOPE (in STMT_EXPR) 73 BIND_EXPR_TRY_BLOCK (in BIND_EXPR) 74 TYPENAME_IS_ENUM_P (in TYPENAME_TYPE) 75 REFERENCE_REF_P (in INDIRECT_EXPR) 76 QUALIFIED_NAME_IS_TEMPLATE (in SCOPE_REF) 77 OMP_FOR_GIMPLIFYING_P (in OMP_FOR) 78 BASELINK_QUALIFIED_P (in BASELINK) 79 TARGET_EXPR_IMPLICIT_P (in TARGET_EXPR) 80 TEMPLATE_PARM_PARAMETER_PACK (in TEMPLATE_PARM_INDEX) 81 TYPE_REF_IS_RVALUE (in REFERENCE_TYPE) 82 ATTR_IS_DEPENDENT (in the TREE_LIST for an attribute) 83 CONSTRUCTOR_IS_DIRECT_INIT (in CONSTRUCTOR) 84 1: IDENTIFIER_VIRTUAL_P (in IDENTIFIER_NODE) 85 TI_PENDING_TEMPLATE_FLAG. 86 TEMPLATE_PARMS_FOR_INLINE. 87 DELETE_EXPR_USE_VEC (in DELETE_EXPR). 88 (TREE_CALLS_NEW) (in _EXPR or _REF) (commented-out). 89 ICS_ELLIPSIS_FLAG (in _CONV) 90 DECL_INITIALIZED_P (in VAR_DECL) 91 TYPENAME_IS_CLASS_P (in TYPENAME_TYPE) 92 STMT_IS_FULL_EXPR_P (in _STMT) 93 TARGET_EXPR_LIST_INIT_P (in TARGET_EXPR) 94 2: IDENTIFIER_OPNAME_P (in IDENTIFIER_NODE) 95 ICS_THIS_FLAG (in _CONV) 96 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (in VAR_DECL) 97 STATEMENT_LIST_TRY_BLOCK (in STATEMENT_LIST) 98 TYPENAME_IS_RESOLVING_P (in TYPE_NAME_TYPE) 99 3: (TREE_REFERENCE_EXPR) (in NON_LVALUE_EXPR) (commented-out). 100 ICS_BAD_FLAG (in _CONV) 101 FN_TRY_BLOCK_P (in TRY_BLOCK) 102 IDENTIFIER_CTOR_OR_DTOR_P (in IDENTIFIER_NODE) 103 BIND_EXPR_BODY_BLOCK (in BIND_EXPR) 104 DECL_NON_TRIVIALLY_INITIALIZED_P (in VAR_DECL) 105 4: TREE_HAS_CONSTRUCTOR (in INDIRECT_REF, SAVE_EXPR, CONSTRUCTOR, 106 or FIELD_DECL). 107 IDENTIFIER_TYPENAME_P (in IDENTIFIER_NODE) 108 DECL_TINFO_P (in VAR_DECL) 109 5: C_IS_RESERVED_WORD (in IDENTIFIER_NODE) 110 DECL_VTABLE_OR_VTT_P (in VAR_DECL) 111 6: IDENTIFIER_REPO_CHOSEN (in IDENTIFIER_NODE) 112 DECL_CONSTRUCTION_VTABLE_P (in VAR_DECL) 113 TYPE_MARKED_P (in _TYPE) 114 115 Usage of TYPE_LANG_FLAG_?: 116 0: TYPE_DEPENDENT_P 117 1: TYPE_HAS_USER_CONSTRUCTOR. 118 2: Unused 119 3: TYPE_FOR_JAVA. 120 4: TYPE_HAS_NONTRIVIAL_DESTRUCTOR 121 5: CLASS_TYPE_P (in RECORD_TYPE and UNION_TYPE) 122 SCOPED_ENUM_P (in ENUMERAL_TYPE) 123 6: TYPE_DEPENDENT_P_VALID 124 125 Usage of DECL_LANG_FLAG_?: 126 0: DECL_ERROR_REPORTED (in VAR_DECL). 127 DECL_TEMPLATE_PARM_P (in PARM_DECL, CONST_DECL, TYPE_DECL, or TEMPLATE_DECL) 128 DECL_LOCAL_FUNCTION_P (in FUNCTION_DECL) 129 DECL_MUTABLE_P (in FIELD_DECL) 130 DECL_DEPENDENT_P (in USING_DECL) 131 1: C_TYPEDEF_EXPLICITLY_SIGNED (in TYPE_DECL). 132 DECL_TEMPLATE_INSTANTIATED (in a VAR_DECL or a FUNCTION_DECL) 133 DECL_MEMBER_TEMPLATE_P (in TEMPLATE_DECL) 134 FUNCTION_PARAMETER_PACK_P (in PARM_DECL) 135 2: DECL_THIS_EXTERN (in VAR_DECL or FUNCTION_DECL). 136 DECL_IMPLICIT_TYPEDEF_P (in a TYPE_DECL) 137 3: DECL_IN_AGGR_P. 138 4: DECL_C_BIT_FIELD (in a FIELD_DECL) 139 DECL_ANON_UNION_VAR_P (in a VAR_DECL) 140 DECL_SELF_REFERENCE_P (in a TYPE_DECL) 141 DECL_INVALID_OVERRIDER_P (in a FUNCTION_DECL) 142 5: DECL_INTERFACE_KNOWN. 143 6: DECL_THIS_STATIC (in VAR_DECL or FUNCTION_DECL). 144 DECL_FIELD_IS_BASE (in FIELD_DECL) 145 7: DECL_DEAD_FOR_LOCAL (in VAR_DECL). 146 DECL_THUNK_P (in a member FUNCTION_DECL) 147 148 Usage of language-independent fields in a language-dependent manner: 149 150 TYPE_ALIAS_SET 151 This field is used by TYPENAME_TYPEs, TEMPLATE_TYPE_PARMs, and so 152 forth as a substitute for the mark bits provided in `lang_type'. 153 At present, only the six low-order bits are used. 154 155 TYPE_LANG_SLOT_1 156 For an ENUMERAL_TYPE, this is ENUM_TEMPLATE_INFO. 157 For a FUNCTION_TYPE or METHOD_TYPE, this is TYPE_RAISES_EXCEPTIONS 158 159 BINFO_VIRTUALS 160 For a binfo, this is a TREE_LIST. There is an entry for each 161 virtual function declared either in BINFO or its direct and 162 indirect primary bases. 163 164 The BV_DELTA of each node gives the amount by which to adjust the 165 `this' pointer when calling the function. If the method is an 166 overridden version of a base class method, then it is assumed 167 that, prior to adjustment, the this pointer points to an object 168 of the base class. 169 170 The BV_VCALL_INDEX of each node, if non-NULL, gives the vtable 171 index of the vcall offset for this entry. 172 173 The BV_FN is the declaration for the virtual function itself. 174 175 BINFO_VTABLE 176 This is an expression with POINTER_TYPE that gives the value 177 to which the vptr should be initialized. Use get_vtbl_decl_for_binfo 178 to extract the VAR_DECL for the complete vtable. 179 180 DECL_VINDEX 181 This field is NULL for a non-virtual function. For a virtual 182 function, it is eventually set to an INTEGER_CST indicating the 183 index in the vtable at which this function can be found. When 184 a virtual function is declared, but before it is known what 185 function is overridden, this field is the error_mark_node. 186 187 Temporarily, it may be set to a TREE_LIST whose TREE_VALUE is 188 the virtual function this one overrides, and whose TREE_CHAIN is 189 the old DECL_VINDEX. */ 190 191 /* Language-specific tree checkers. */ 192 193 #define VAR_OR_FUNCTION_DECL_CHECK(NODE) \ 194 TREE_CHECK2(NODE,VAR_DECL,FUNCTION_DECL) 195 196 #define VAR_FUNCTION_OR_PARM_DECL_CHECK(NODE) \ 197 TREE_CHECK3(NODE,VAR_DECL,FUNCTION_DECL,PARM_DECL) 198 199 #define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) \ 200 TREE_CHECK4(NODE,VAR_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL) 201 202 #define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) \ 203 TREE_CHECK(NODE,BOUND_TEMPLATE_TEMPLATE_PARM) 204 205 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) 206 #define NON_THUNK_FUNCTION_CHECK(NODE) __extension__ \ 207 ({ __typeof(NODE) const __t = (NODE); \ 208 if (TREE_CODE (__t) != FUNCTION_DECL && \ 209 TREE_CODE (__t) != TEMPLATE_DECL && __t->decl_common.lang_specific \ 210 && __t->decl_common.lang_specific->decl_flags.thunk_p) \ 211 tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, 0); \ 212 __t; }) 213 #define THUNK_FUNCTION_CHECK(NODE) __extension__ \ 214 ({ __typeof (NODE) const __t = (NODE); \ 215 if (TREE_CODE (__t) != FUNCTION_DECL || !__t->decl_common.lang_specific \ 216 || !__t->decl_common.lang_specific->decl_flags.thunk_p) \ 217 tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, 0); \ 218 __t; }) 219 #else 220 #define NON_THUNK_FUNCTION_CHECK(NODE) (NODE) 221 #define THUNK_FUNCTION_CHECK(NODE) (NODE) 222 #endif 223 224 /* Language-dependent contents of an identifier. */ 226 227 struct lang_identifier GTY(()) 228 { 229 struct c_common_identifier c_common; 230 cxx_binding *namespace_bindings; 231 cxx_binding *bindings; 232 tree class_template_info; 233 tree label_value; 234 }; 235 236 /* In an IDENTIFIER_NODE, nonzero if this identifier is actually a 237 keyword. C_RID_CODE (node) is then the RID_* value of the keyword, 238 and C_RID_YYCODE is the token number wanted by Yacc. */ 239 240 #define C_IS_RESERVED_WORD(ID) TREE_LANG_FLAG_5 (ID) 241 242 #define LANG_IDENTIFIER_CAST(NODE) \ 243 ((struct lang_identifier*)IDENTIFIER_NODE_CHECK (NODE)) 244 245 struct template_parm_index_s GTY(()) 246 { 247 struct tree_common common; 248 int index; 249 int level; 250 int orig_level; 251 tree decl; 252 }; 253 typedef struct template_parm_index_s template_parm_index; 254 255 struct ptrmem_cst GTY(()) 256 { 257 struct tree_common common; 258 /* This isn't used, but the middle-end expects all constants to have 259 this field. */ 260 rtx rtl; 261 tree member; 262 }; 263 typedef struct ptrmem_cst * ptrmem_cst_t; 264 265 #define IDENTIFIER_GLOBAL_VALUE(NODE) \ 266 namespace_binding ((NODE), global_namespace) 267 #define SET_IDENTIFIER_GLOBAL_VALUE(NODE, VAL) \ 268 set_namespace_binding ((NODE), global_namespace, (VAL)) 269 #define IDENTIFIER_NAMESPACE_VALUE(NODE) \ 270 namespace_binding ((NODE), current_namespace) 271 #define SET_IDENTIFIER_NAMESPACE_VALUE(NODE, VAL) \ 272 set_namespace_binding ((NODE), current_namespace, (VAL)) 273 274 #define CLEANUP_P(NODE) TREE_LANG_FLAG_0 (TRY_BLOCK_CHECK (NODE)) 275 276 #define BIND_EXPR_TRY_BLOCK(NODE) \ 277 TREE_LANG_FLAG_0 (BIND_EXPR_CHECK (NODE)) 278 279 /* Used to mark the block around the member initializers and cleanups. */ 280 #define BIND_EXPR_BODY_BLOCK(NODE) \ 281 TREE_LANG_FLAG_3 (BIND_EXPR_CHECK (NODE)) 282 #define FUNCTION_NEEDS_BODY_BLOCK(NODE) \ 283 (DECL_CONSTRUCTOR_P (NODE) || DECL_DESTRUCTOR_P (NODE)) 284 285 #define STATEMENT_LIST_NO_SCOPE(NODE) \ 286 TREE_LANG_FLAG_0 (STATEMENT_LIST_CHECK (NODE)) 287 #define STATEMENT_LIST_TRY_BLOCK(NODE) \ 288 TREE_LANG_FLAG_2 (STATEMENT_LIST_CHECK (NODE)) 289 290 /* Nonzero if this statement should be considered a full-expression, 291 i.e., if temporaries created during this statement should have 292 their destructors run at the end of this statement. */ 293 #define STMT_IS_FULL_EXPR_P(NODE) TREE_LANG_FLAG_1 ((NODE)) 294 295 /* Marks the result of a statement expression. */ 296 #define EXPR_STMT_STMT_EXPR_RESULT(NODE) \ 297 TREE_LANG_FLAG_0 (EXPR_STMT_CHECK (NODE)) 298 299 /* Nonzero if this statement-expression does not have an associated scope. */ 300 #define STMT_EXPR_NO_SCOPE(NODE) \ 301 TREE_LANG_FLAG_0 (STMT_EXPR_CHECK (NODE)) 302 303 /* Returns nonzero iff TYPE1 and TYPE2 are the same type, in the usual 304 sense of `same'. */ 305 #define same_type_p(TYPE1, TYPE2) \ 306 comptypes ((TYPE1), (TYPE2), COMPARE_STRICT) 307 308 /* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring 309 top-level qualifiers. */ 310 #define same_type_ignoring_top_level_qualifiers_p(TYPE1, TYPE2) \ 311 same_type_p (TYPE_MAIN_VARIANT (TYPE1), TYPE_MAIN_VARIANT (TYPE2)) 312 313 /* Nonzero if we are presently building a statement tree, rather 314 than expanding each statement as we encounter it. */ 315 #define building_stmt_tree() (cur_stmt_list != NULL_TREE) 316 317 /* Returns nonzero iff NODE is a declaration for the global function 318 `main'. */ 319 #define DECL_MAIN_P(NODE) \ 320 (DECL_EXTERN_C_FUNCTION_P (NODE) \ 321 && DECL_NAME (NODE) != NULL_TREE \ 322 && MAIN_NAME_P (DECL_NAME (NODE)) \ 323 && flag_hosted) 324 325 /* The overloaded FUNCTION_DECL. */ 326 #define OVL_FUNCTION(NODE) \ 327 (((struct tree_overload*)OVERLOAD_CHECK (NODE))->function) 328 #define OVL_CHAIN(NODE) TREE_CHAIN (NODE) 329 /* Polymorphic access to FUNCTION and CHAIN. */ 330 #define OVL_CURRENT(NODE) \ 331 ((TREE_CODE (NODE) == OVERLOAD) ? OVL_FUNCTION (NODE) : (NODE)) 332 #define OVL_NEXT(NODE) \ 333 ((TREE_CODE (NODE) == OVERLOAD) ? TREE_CHAIN (NODE) : NULL_TREE) 334 /* If set, this was imported in a using declaration. 335 This is not to confuse with being used somewhere, which 336 is not important for this node. */ 337 #define OVL_USED(NODE) TREE_USED (NODE) 338 339 struct tree_overload GTY(()) 340 { 341 struct tree_common common; 342 tree function; 343 }; 344 345 /* Returns true iff NODE is a BASELINK. */ 346 #define BASELINK_P(NODE) \ 347 (TREE_CODE (NODE) == BASELINK) 348 /* The BINFO indicating the base from which the BASELINK_FUNCTIONS came. */ 349 #define BASELINK_BINFO(NODE) \ 350 (((struct tree_baselink*) BASELINK_CHECK (NODE))->binfo) 351 /* The functions referred to by the BASELINK; either a FUNCTION_DECL, 352 a TEMPLATE_DECL, an OVERLOAD, or a TEMPLATE_ID_EXPR. */ 353 #define BASELINK_FUNCTIONS(NODE) \ 354 (((struct tree_baselink*) BASELINK_CHECK (NODE))->functions) 355 /* The BINFO in which the search for the functions indicated by this baselink 356 began. This base is used to determine the accessibility of functions 357 selected by overload resolution. */ 358 #define BASELINK_ACCESS_BINFO(NODE) \ 359 (((struct tree_baselink*) BASELINK_CHECK (NODE))->access_binfo) 360 /* For a type-conversion operator, the BASELINK_OPTYPE indicates the type 361 to which the conversion should occur. This value is important if 362 the BASELINK_FUNCTIONS include a template conversion operator -- 363 the BASELINK_OPTYPE can be used to determine what type the user 364 requested. */ 365 #define BASELINK_OPTYPE(NODE) \ 366 (TREE_CHAIN (BASELINK_CHECK (NODE))) 367 /* Nonzero if this baselink was from a qualified lookup. */ 368 #define BASELINK_QUALIFIED_P(NODE) \ 369 TREE_LANG_FLAG_0 (BASELINK_CHECK (NODE)) 370 371 struct tree_baselink GTY(()) 372 { 373 struct tree_common common; 374 tree binfo; 375 tree functions; 376 tree access_binfo; 377 }; 378 379 /* The different kinds of ids that we encounter. */ 380 381 typedef enum cp_id_kind 382 { 383 /* Not an id at all. */ 384 CP_ID_KIND_NONE, 385 /* An unqualified-id that is not a template-id. */ 386 CP_ID_KIND_UNQUALIFIED, 387 /* An unqualified-id that is a dependent name. */ 388 CP_ID_KIND_UNQUALIFIED_DEPENDENT, 389 /* An unqualified template-id. */ 390 CP_ID_KIND_TEMPLATE_ID, 391 /* A qualified-id. */ 392 CP_ID_KIND_QUALIFIED 393 } cp_id_kind; 394 395 /* Macros for access to language-specific slots in an identifier. */ 396 397 #define IDENTIFIER_NAMESPACE_BINDINGS(NODE) \ 398 (LANG_IDENTIFIER_CAST (NODE)->namespace_bindings) 399 #define IDENTIFIER_TEMPLATE(NODE) \ 400 (LANG_IDENTIFIER_CAST (NODE)->class_template_info) 401 402 /* The IDENTIFIER_BINDING is the innermost cxx_binding for the 403 identifier. It's PREVIOUS is the next outermost binding. Each 404 VALUE field is a DECL for the associated declaration. Thus, 405 name lookup consists simply of pulling off the node at the front 406 of the list (modulo oddities for looking up the names of types, 407 and such.) You can use SCOPE field to determine the scope 408 that bound the name. */ 409 #define IDENTIFIER_BINDING(NODE) \ 410 (LANG_IDENTIFIER_CAST (NODE)->bindings) 411 412 /* TREE_TYPE only indicates on local and class scope the current 413 type. For namespace scope, the presence of a type in any namespace 414 is indicated with global_type_node, and the real type behind must 415 be found through lookup. */ 416 #define IDENTIFIER_TYPE_VALUE(NODE) identifier_type_value (NODE) 417 #define REAL_IDENTIFIER_TYPE_VALUE(NODE) TREE_TYPE (NODE) 418 #define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = (TYPE)) 419 #define IDENTIFIER_HAS_TYPE_VALUE(NODE) (IDENTIFIER_TYPE_VALUE (NODE) ? 1 : 0) 420 421 #define IDENTIFIER_LABEL_VALUE(NODE) \ 422 (LANG_IDENTIFIER_CAST (NODE)->label_value) 423 #define SET_IDENTIFIER_LABEL_VALUE(NODE, VALUE) \ 424 IDENTIFIER_LABEL_VALUE (NODE) = (VALUE) 425 426 /* Nonzero if this identifier is used as a virtual function name somewhere 427 (optimizes searches). */ 428 #define IDENTIFIER_VIRTUAL_P(NODE) TREE_LANG_FLAG_1 (NODE) 429 430 /* Nonzero if this identifier is the prefix for a mangled C++ operator 431 name. */ 432 #define IDENTIFIER_OPNAME_P(NODE) TREE_LANG_FLAG_2 (NODE) 433 434 /* Nonzero if this identifier is the name of a type-conversion 435 operator. */ 436 #define IDENTIFIER_TYPENAME_P(NODE) \ 437 TREE_LANG_FLAG_4 (NODE) 438 439 /* Nonzero if this identifier is the name of a constructor or 440 destructor. */ 441 #define IDENTIFIER_CTOR_OR_DTOR_P(NODE) \ 442 TREE_LANG_FLAG_3 (NODE) 443 444 /* True iff NAME is the DECL_ASSEMBLER_NAME for an entity with vague 445 linkage which the prelinker has assigned to this translation 446 unit. */ 447 #define IDENTIFIER_REPO_CHOSEN(NAME) \ 448 (TREE_LANG_FLAG_6 (NAME)) 449 450 /* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only. */ 451 #define C_TYPE_FIELDS_READONLY(TYPE) \ 452 (LANG_TYPE_CLASS_CHECK (TYPE)->fields_readonly) 453 454 /* The tokens stored in the default argument. */ 455 456 #define DEFARG_TOKENS(NODE) \ 457 (((struct tree_default_arg *)DEFAULT_ARG_CHECK (NODE))->tokens) 458 #define DEFARG_INSTANTIATIONS(NODE) \ 459 (((struct tree_default_arg *)DEFAULT_ARG_CHECK (NODE))->instantiations) 460 461 struct tree_default_arg GTY (()) 462 { 463 struct tree_common common; 464 struct cp_token_cache *tokens; 465 VEC(tree,gc) *instantiations; 466 }; 467 468 /* The condition associated with the static assertion. This must be 469 an integral constant expression. */ 470 #define STATIC_ASSERT_CONDITION(NODE) \ 471 (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->condition) 472 473 /* The message associated with the static assertion. This must be a 474 string constant, which will be emitted as an error message when the 475 static assert condition is false. */ 476 #define STATIC_ASSERT_MESSAGE(NODE) \ 477 (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->message) 478 479 /* Source location information for a static assertion. */ 480 #define STATIC_ASSERT_SOURCE_LOCATION(NODE) \ 481 (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->location) 482 483 struct tree_static_assert GTY (()) 484 { 485 struct tree_common common; 486 tree condition; 487 tree message; 488 location_t location; 489 }; 490 491 struct tree_argument_pack_select GTY (()) 492 { 493 struct tree_common common; 494 tree argument_pack; 495 int index; 496 }; 497 498 /* The different kinds of traits that we encounter. */ 499 500 typedef enum cp_trait_kind 501 { 502 CPTK_HAS_NOTHROW_ASSIGN, 503 CPTK_HAS_NOTHROW_CONSTRUCTOR, 504 CPTK_HAS_NOTHROW_COPY, 505 CPTK_HAS_TRIVIAL_ASSIGN, 506 CPTK_HAS_TRIVIAL_CONSTRUCTOR, 507 CPTK_HAS_TRIVIAL_COPY, 508 CPTK_HAS_TRIVIAL_DESTRUCTOR, 509 CPTK_HAS_VIRTUAL_DESTRUCTOR, 510 CPTK_IS_ABSTRACT, 511 CPTK_IS_BASE_OF, 512 CPTK_IS_CLASS, 513 CPTK_IS_CONVERTIBLE_TO, 514 CPTK_IS_EMPTY, 515 CPTK_IS_ENUM, 516 CPTK_IS_POD, 517 CPTK_IS_POLYMORPHIC, 518 CPTK_IS_UNION 519 } cp_trait_kind; 520 521 /* The types that we are processing. */ 522 #define TRAIT_EXPR_TYPE1(NODE) \ 523 (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type1) 524 525 #define TRAIT_EXPR_TYPE2(NODE) \ 526 (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type2) 527 528 /* The specific trait that we are processing. */ 529 #define TRAIT_EXPR_KIND(NODE) \ 530 (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->kind) 531 532 struct tree_trait_expr GTY (()) 533 { 534 struct tree_common common; 535 tree type1; 536 tree type2; 537 enum cp_trait_kind kind; 538 }; 539 540 enum cp_tree_node_structure_enum { 541 TS_CP_GENERIC, 542 TS_CP_IDENTIFIER, 543 TS_CP_TPI, 544 TS_CP_PTRMEM, 545 TS_CP_BINDING, 546 TS_CP_OVERLOAD, 547 TS_CP_BASELINK, 548 TS_CP_WRAPPER, 549 TS_CP_DEFAULT_ARG, 550 TS_CP_STATIC_ASSERT, 551 TS_CP_ARGUMENT_PACK_SELECT, 552 TS_CP_TRAIT_EXPR, 553 LAST_TS_CP_ENUM 554 }; 555 556 /* The resulting tree type. */ 557 union lang_tree_node GTY((desc ("cp_tree_node_structure (&%h)"), 558 chain_next ("(union lang_tree_node *)TREE_CHAIN (&%h.generic)"))) 559 { 560 union tree_node GTY ((tag ("TS_CP_GENERIC"), 561 desc ("tree_node_structure (&%h)"))) generic; 562 struct template_parm_index_s GTY ((tag ("TS_CP_TPI"))) tpi; 563 struct ptrmem_cst GTY ((tag ("TS_CP_PTRMEM"))) ptrmem; 564 struct tree_overload GTY ((tag ("TS_CP_OVERLOAD"))) overload; 565 struct tree_baselink GTY ((tag ("TS_CP_BASELINK"))) baselink; 566 struct tree_default_arg GTY ((tag ("TS_CP_DEFAULT_ARG"))) default_arg; 567 struct lang_identifier GTY ((tag ("TS_CP_IDENTIFIER"))) identifier; 568 struct tree_static_assert GTY ((tag ("TS_CP_STATIC_ASSERT"))) 569 static_assertion; 570 struct tree_argument_pack_select GTY ((tag ("TS_CP_ARGUMENT_PACK_SELECT"))) 571 argument_pack_select; 572 struct tree_trait_expr GTY ((tag ("TS_CP_TRAIT_EXPR"))) 573 trait_expression; 574 }; 575 576 577 enum cp_tree_index 579 { 580 CPTI_JAVA_BYTE_TYPE, 581 CPTI_JAVA_SHORT_TYPE, 582 CPTI_JAVA_INT_TYPE, 583 CPTI_JAVA_LONG_TYPE, 584 CPTI_JAVA_FLOAT_TYPE, 585 CPTI_JAVA_DOUBLE_TYPE, 586 CPTI_JAVA_CHAR_TYPE, 587 CPTI_JAVA_BOOLEAN_TYPE, 588 589 CPTI_WCHAR_DECL, 590 CPTI_VTABLE_ENTRY_TYPE, 591 CPTI_DELTA_TYPE, 592 CPTI_VTABLE_INDEX_TYPE, 593 CPTI_CLEANUP_TYPE, 594 CPTI_VTT_PARM_TYPE, 595 596 CPTI_CLASS_TYPE, 597 CPTI_UNKNOWN_TYPE, 598 CPTI_INIT_LIST_TYPE, 599 CPTI_VTBL_TYPE, 600 CPTI_VTBL_PTR_TYPE, 601 CPTI_STD, 602 CPTI_ABI, 603 CPTI_CONST_TYPE_INFO_TYPE, 604 CPTI_TYPE_INFO_PTR_TYPE, 605 CPTI_ABORT_FNDECL, 606 CPTI_GLOBAL_DELETE_FNDECL, 607 CPTI_AGGR_TAG, 608 609 CPTI_CTOR_IDENTIFIER, 610 CPTI_COMPLETE_CTOR_IDENTIFIER, 611 CPTI_BASE_CTOR_IDENTIFIER, 612 CPTI_DTOR_IDENTIFIER, 613 CPTI_COMPLETE_DTOR_IDENTIFIER, 614 CPTI_BASE_DTOR_IDENTIFIER, 615 CPTI_DELETING_DTOR_IDENTIFIER, 616 CPTI_DELTA_IDENTIFIER, 617 CPTI_IN_CHARGE_IDENTIFIER, 618 CPTI_VTT_PARM_IDENTIFIER, 619 CPTI_NELTS_IDENTIFIER, 620 CPTI_THIS_IDENTIFIER, 621 CPTI_PFN_IDENTIFIER, 622 CPTI_VPTR_IDENTIFIER, 623 CPTI_STD_IDENTIFIER, 624 625 CPTI_LANG_NAME_C, 626 CPTI_LANG_NAME_CPLUSPLUS, 627 CPTI_LANG_NAME_JAVA, 628 629 CPTI_EMPTY_EXCEPT_SPEC, 630 CPTI_JCLASS, 631 CPTI_TERMINATE, 632 CPTI_CALL_UNEXPECTED, 633 CPTI_ATEXIT_FN_PTR_TYPE, 634 CPTI_ATEXIT, 635 CPTI_DSO_HANDLE, 636 CPTI_DCAST, 637 638 CPTI_KEYED_CLASSES, 639 640 CPTI_MAX 641 }; 642 643 extern GTY(()) tree cp_global_trees[CPTI_MAX]; 644 645 #define java_byte_type_node cp_global_trees[CPTI_JAVA_BYTE_TYPE] 646 #define java_short_type_node cp_global_trees[CPTI_JAVA_SHORT_TYPE] 647 #define java_int_type_node cp_global_trees[CPTI_JAVA_INT_TYPE] 648 #define java_long_type_node cp_global_trees[CPTI_JAVA_LONG_TYPE] 649 #define java_float_type_node cp_global_trees[CPTI_JAVA_FLOAT_TYPE] 650 #define java_double_type_node cp_global_trees[CPTI_JAVA_DOUBLE_TYPE] 651 #define java_char_type_node cp_global_trees[CPTI_JAVA_CHAR_TYPE] 652 #define java_boolean_type_node cp_global_trees[CPTI_JAVA_BOOLEAN_TYPE] 653 654 #define wchar_decl_node cp_global_trees[CPTI_WCHAR_DECL] 655 #define vtable_entry_type cp_global_trees[CPTI_VTABLE_ENTRY_TYPE] 656 /* The type used to represent an offset by which to adjust the `this' 657 pointer in pointer-to-member types. */ 658 #define delta_type_node cp_global_trees[CPTI_DELTA_TYPE] 659 /* The type used to represent an index into the vtable. */ 660 #define vtable_index_type cp_global_trees[CPTI_VTABLE_INDEX_TYPE] 661 662 #define class_type_node cp_global_trees[CPTI_CLASS_TYPE] 663 #define unknown_type_node cp_global_trees[CPTI_UNKNOWN_TYPE] 664 #define init_list_type_node cp_global_trees[CPTI_INIT_LIST_TYPE] 665 #define vtbl_type_node cp_global_trees[CPTI_VTBL_TYPE] 666 #define vtbl_ptr_type_node cp_global_trees[CPTI_VTBL_PTR_TYPE] 667 #define std_node cp_global_trees[CPTI_STD] 668 #define abi_node cp_global_trees[CPTI_ABI] 669 #define const_type_info_type_node cp_global_trees[CPTI_CONST_TYPE_INFO_TYPE] 670 #define type_info_ptr_type cp_global_trees[CPTI_TYPE_INFO_PTR_TYPE] 671 #define abort_fndecl cp_global_trees[CPTI_ABORT_FNDECL] 672 #define global_delete_fndecl cp_global_trees[CPTI_GLOBAL_DELETE_FNDECL] 673 #define current_aggr cp_global_trees[CPTI_AGGR_TAG] 674 675 /* We cache these tree nodes so as to call get_identifier less 676 frequently. */ 677 678 /* The name of a constructor that takes an in-charge parameter to 679 decide whether or not to construct virtual base classes. */ 680 #define ctor_identifier cp_global_trees[CPTI_CTOR_IDENTIFIER] 681 /* The name of a constructor that constructs virtual base classes. */ 682 #define complete_ctor_identifier cp_global_trees[CPTI_COMPLETE_CTOR_IDENTIFIER] 683 /* The name of a constructor that does not construct virtual base classes. */ 684 #define base_ctor_identifier cp_global_trees[CPTI_BASE_CTOR_IDENTIFIER] 685 /* The name of a destructor that takes an in-charge parameter to 686 decide whether or not to destroy virtual base classes and whether 687 or not to delete the object. */ 688 #define dtor_identifier cp_global_trees[CPTI_DTOR_IDENTIFIER] 689 /* The name of a destructor that destroys virtual base classes. */ 690 #define complete_dtor_identifier cp_global_trees[CPTI_COMPLETE_DTOR_IDENTIFIER] 691 /* The name of a destructor that does not destroy virtual base 692 classes. */ 693 #define base_dtor_identifier cp_global_trees[CPTI_BASE_DTOR_IDENTIFIER] 694 /* The name of a destructor that destroys virtual base classes, and 695 then deletes the entire object. */ 696 #define deleting_dtor_identifier cp_global_trees[CPTI_DELETING_DTOR_IDENTIFIER] 697 #define delta_identifier cp_global_trees[CPTI_DELTA_IDENTIFIER] 698 #define in_charge_identifier cp_global_trees[CPTI_IN_CHARGE_IDENTIFIER] 699 /* The name of the parameter that contains a pointer to the VTT to use 700 for this subobject constructor or destructor. */ 701 #define vtt_parm_identifier cp_global_trees[CPTI_VTT_PARM_IDENTIFIER] 702 #define nelts_identifier cp_global_trees[CPTI_NELTS_IDENTIFIER] 703 #define this_identifier cp_global_trees[CPTI_THIS_IDENTIFIER] 704 #define pfn_identifier cp_global_trees[CPTI_PFN_IDENTIFIER] 705 #define vptr_identifier cp_global_trees[CPTI_VPTR_IDENTIFIER] 706 /* The name of the std namespace. */ 707 #define std_identifier cp_global_trees[CPTI_STD_IDENTIFIER] 708 #define lang_name_c cp_global_trees[CPTI_LANG_NAME_C] 709 #define lang_name_cplusplus cp_global_trees[CPTI_LANG_NAME_CPLUSPLUS] 710 #define lang_name_java cp_global_trees[CPTI_LANG_NAME_JAVA] 711 712 /* Exception specifier used for throw(). */ 713 #define empty_except_spec cp_global_trees[CPTI_EMPTY_EXCEPT_SPEC] 714 715 /* If non-NULL, a POINTER_TYPE equivalent to (java::lang::Class*). */ 716 #define jclass_node cp_global_trees[CPTI_JCLASS] 717 718 /* The declaration for `std::terminate'. */ 719 #define terminate_node cp_global_trees[CPTI_TERMINATE] 720 721 /* The declaration for "__cxa_call_unexpected". */ 722 #define call_unexpected_node cp_global_trees[CPTI_CALL_UNEXPECTED] 723 724 /* The type of the function-pointer argument to "__cxa_atexit" (or 725 "std::atexit", if "__cxa_atexit" is not being used). */ 726 #define atexit_fn_ptr_type_node cp_global_trees[CPTI_ATEXIT_FN_PTR_TYPE] 727 728 /* A pointer to `std::atexit'. */ 729 #define atexit_node cp_global_trees[CPTI_ATEXIT] 730 731 /* A pointer to `__dso_handle'. */ 732 #define dso_handle_node cp_global_trees[CPTI_DSO_HANDLE] 733 734 /* The declaration of the dynamic_cast runtime. */ 735 #define dynamic_cast_node cp_global_trees[CPTI_DCAST] 736 737 /* The type of a destructor. */ 738 #define cleanup_type cp_global_trees[CPTI_CLEANUP_TYPE] 739 740 /* The type of the vtt parameter passed to subobject constructors and 741 destructors. */ 742 #define vtt_parm_type cp_global_trees[CPTI_VTT_PARM_TYPE] 743 744 /* A TREE_LIST of the dynamic classes whose vtables may have to be 745 emitted in this translation unit. */ 746 747 #define keyed_classes cp_global_trees[CPTI_KEYED_CLASSES] 748 749 /* Node to indicate default access. This must be distinct from the 750 access nodes in tree.h. */ 751 752 #define access_default_node null_node 753 754 /* Global state. */ 755 756 struct saved_scope GTY(()) 757 { 758 VEC(cxx_saved_binding,gc) *old_bindings; 759 tree old_namespace; 760 tree decl_ns_list; 761 tree class_name; 762 tree class_type; 763 tree access_specifier; 764 tree function_decl; 765 VEC(tree,gc) *lang_base; 766 tree lang_name; 767 tree template_parms; 768 struct cp_binding_level *x_previous_class_level; 769 tree x_saved_tree; 770 771 int x_processing_template_decl; 772 int x_processing_specialization; 773 BOOL_BITFIELD x_processing_explicit_instantiation : 1; 774 BOOL_BITFIELD need_pop_function_context : 1; 775 BOOL_BITFIELD skip_evaluation : 1; 776 777 struct stmt_tree_s x_stmt_tree; 778 779 struct cp_binding_level *class_bindings; 780 struct cp_binding_level *bindings; 781 782 struct saved_scope *prev; 783 }; 784 785 /* The current open namespace. */ 786 787 #define current_namespace scope_chain->old_namespace 788 789 /* The stack for namespaces of current declarations. */ 790 791 #define decl_namespace_list scope_chain->decl_ns_list 792 793 /* IDENTIFIER_NODE: name of current class */ 794 795 #define current_class_name scope_chain->class_name 796 797 /* _TYPE: the type of the current class */ 798 799 #define current_class_type scope_chain->class_type 800 801 /* When parsing a class definition, the access specifier most recently 802 given by the user, or, if no access specifier was given, the 803 default value appropriate for the kind of class (i.e., struct, 804 class, or union). */ 805 806 #define current_access_specifier scope_chain->access_specifier 807 808 /* Pointer to the top of the language name stack. */ 809 810 #define current_lang_base scope_chain->lang_base 811 #define current_lang_name scope_chain->lang_name 812 813 /* When parsing a template declaration, a TREE_LIST represents the 814 active template parameters. Each node in the list represents one 815 level of template parameters. The innermost level is first in the 816 list. The depth of each level is stored as an INTEGER_CST in the 817 TREE_PURPOSE of each node. The parameters for that level are 818 stored in the TREE_VALUE. */ 819 820 #define current_template_parms scope_chain->template_parms 821 822 #define processing_template_decl scope_chain->x_processing_template_decl 823 #define processing_specialization scope_chain->x_processing_specialization 824 #define processing_explicit_instantiation scope_chain->x_processing_explicit_instantiation 825 826 /* The cached class binding level, from the most recently exited 827 class, or NULL if none. */ 828 829 #define previous_class_level scope_chain->x_previous_class_level 830 831 /* A list of private types mentioned, for deferred access checking. */ 832 833 extern GTY(()) struct saved_scope *scope_chain; 834 835 struct cxx_int_tree_map GTY(()) 836 { 837 unsigned int uid; 838 tree to; 839 }; 840 841 extern unsigned int cxx_int_tree_map_hash (const void *); 842 extern int cxx_int_tree_map_eq (const void *, const void *); 843 844 /* Global state pertinent to the current function. */ 845 846 struct language_function GTY(()) 847 { 848 struct c_language_function base; 849 850 tree x_cdtor_label; 851 tree x_current_class_ptr; 852 tree x_current_class_ref; 853 tree x_eh_spec_block; 854 tree x_in_charge_parm; 855 tree x_vtt_parm; 856 tree x_return_value; 857 858 BOOL_BITFIELD returns_value : 1; 859 BOOL_BITFIELD returns_null : 1; 860 BOOL_BITFIELD returns_abnormally : 1; 861 BOOL_BITFIELD in_function_try_handler : 1; 862 BOOL_BITFIELD in_base_initializer : 1; 863 864 /* True if this function can throw an exception. */ 865 BOOL_BITFIELD can_throw : 1; 866 867 htab_t GTY((param_is(struct named_label_entry))) x_named_labels; 868 struct cp_binding_level *bindings; 869 VEC(tree,gc) *x_local_names; 870 htab_t GTY((param_is (struct cxx_int_tree_map))) extern_decl_map; 871 }; 872 873 /* The current C++-specific per-function global variables. */ 874 875 #define cp_function_chain (cfun->language) 876 877 /* In a constructor destructor, the point at which all derived class 878 destroying/construction has been done. I.e., just before a 879 constructor returns, or before any base class destroying will be done 880 in a destructor. */ 881 882 #define cdtor_label cp_function_chain->x_cdtor_label 883 884 /* When we're processing a member function, current_class_ptr is the 885 PARM_DECL for the `this' pointer. The current_class_ref is an 886 expression for `*this'. */ 887 888 #define current_class_ptr \ 889 (cfun ? cp_function_chain->x_current_class_ptr : NULL_TREE) 890 #define current_class_ref \ 891 (cfun ? cp_function_chain->x_current_class_ref : NULL_TREE) 892 893 /* The EH_SPEC_BLOCK for the exception-specifiers for the current 894 function, if any. */ 895 896 #define current_eh_spec_block cp_function_chain->x_eh_spec_block 897 898 /* The `__in_chrg' parameter for the current function. Only used for 899 constructors and destructors. */ 900 901 #define current_in_charge_parm cp_function_chain->x_in_charge_parm 902 903 /* The `__vtt_parm' parameter for the current function. Only used for 904 constructors and destructors. */ 905 906 #define current_vtt_parm cp_function_chain->x_vtt_parm 907 908 /* Set to 0 at beginning of a function definition, set to 1 if 909 a return statement that specifies a return value is seen. */ 910 911 #define current_function_returns_value cp_function_chain->returns_value 912 913 /* Set to 0 at beginning of a function definition, set to 1 if 914 a return statement with no argument is seen. */ 915 916 #define current_function_returns_null cp_function_chain->returns_null 917 918 /* Set to 0 at beginning of a function definition, set to 1 if 919 a call to a noreturn function is seen. */ 920 921 #define current_function_returns_abnormally \ 922 cp_function_chain->returns_abnormally 923 924 /* Nonzero if we are processing a base initializer. Zero elsewhere. */ 925 #define in_base_initializer cp_function_chain->in_base_initializer 926 927 #define in_function_try_handler cp_function_chain->in_function_try_handler 928 929 /* Expression always returned from function, or error_mark_node 930 otherwise, for use by the automatic named return value optimization. */ 931 932 #define current_function_return_value \ 933 (cp_function_chain->x_return_value) 934 935 /* True if NAME is the IDENTIFIER_NODE for an overloaded "operator 936 new" or "operator delete". */ 937 #define NEW_DELETE_OPNAME_P(NAME) \ 938 ((NAME) == ansi_opname (NEW_EXPR) \ 939 || (NAME) == ansi_opname (VEC_NEW_EXPR) \ 940 || (NAME) == ansi_opname (DELETE_EXPR) \ 941 || (NAME) == ansi_opname (VEC_DELETE_EXPR)) 942 943 #define ansi_opname(CODE) \ 944 (operator_name_info[(int) (CODE)].identifier) 945 #define ansi_assopname(CODE) \ 946 (assignment_operator_name_info[(int) (CODE)].identifier) 947 948 /* True if NODE is an erroneous expression. */ 949 950 #define error_operand_p(NODE) \ 951 ((NODE) == error_mark_node \ 952 || ((NODE) && TREE_TYPE ((NODE)) == error_mark_node)) 953 954 /* TRUE if a tree code represents a statement. */ 956 extern bool statement_code_p[MAX_TREE_CODES]; 957 958 #define STATEMENT_CODE_P(CODE) statement_code_p[(int) (CODE)] 959 960 enum languages { lang_c, lang_cplusplus, lang_java }; 961 962 /* Macros to make error reporting functions' lives easier. */ 963 #define TYPE_IDENTIFIER(NODE) (DECL_NAME (TYPE_NAME (NODE))) 964 #define TYPE_LINKAGE_IDENTIFIER(NODE) \ 965 (TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (NODE))) 966 #define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (TYPE_IDENTIFIER (NODE))) 967 #define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (TYPE_IDENTIFIER (NODE))) 968 969 /* Nonzero if NODE has no name for linkage purposes. */ 970 #define TYPE_ANONYMOUS_P(NODE) \ 971 (TAGGED_TYPE_P (NODE) && ANON_AGGRNAME_P (TYPE_LINKAGE_IDENTIFIER (NODE))) 972 973 /* The _DECL for this _TYPE. */ 974 #define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE))) 975 976 /* Nonzero if T is a class (or struct or union) type. Also nonzero 977 for template type parameters, typename types, and instantiated 978 template template parameters. Keep these checks in ascending code 979 order. */ 980 #define MAYBE_CLASS_TYPE_P(T) \ 981 (TREE_CODE (T) == TEMPLATE_TYPE_PARM \ 982 || TREE_CODE (T) == TYPENAME_TYPE \ 983 || TREE_CODE (T) == TYPEOF_TYPE \ 984 || TREE_CODE (T) == BOUND_TEMPLATE_TEMPLATE_PARM \ 985 || TREE_CODE (T) == DECLTYPE_TYPE \ 986 || CLASS_TYPE_P (T)) 987 988 /* Set CLASS_TYPE_P for T to VAL. T must be a class, struct, or 989 union type. */ 990 #define SET_CLASS_TYPE_P(T, VAL) \ 991 (TYPE_LANG_FLAG_5 (T) = (VAL)) 992 993 /* Nonzero if T is a class type. Zero for template type parameters, 994 typename types, and so forth. */ 995 #define CLASS_TYPE_P(T) \ 996 (RECORD_OR_UNION_CODE_P (TREE_CODE (T)) && TYPE_LANG_FLAG_5 (T)) 997 998 /* Nonzero if T is a class type but not an union. */ 999 #define NON_UNION_CLASS_TYPE_P(T) \ 1000 (CLASS_TYPE_P (T) && TREE_CODE (T) != UNION_TYPE) 1001 1002 /* Keep these checks in ascending code order. */ 1003 #define RECORD_OR_UNION_CODE_P(T) \ 1004 ((T) == RECORD_TYPE || (T) == UNION_TYPE) 1005 #define TAGGED_TYPE_P(T) \ 1006 (CLASS_TYPE_P (T) || TREE_CODE (T) == ENUMERAL_TYPE) 1007 #define IS_OVERLOAD_TYPE(T) TAGGED_TYPE_P (T) 1008 1009 /* True if this a "Java" type, defined in 'extern "Java"'. */ 1010 #define TYPE_FOR_JAVA(NODE) TYPE_LANG_FLAG_3 (NODE) 1011 1012 /* True if this type is dependent. This predicate is only valid if 1013 TYPE_DEPENDENT_P_VALID is true. */ 1014 #define TYPE_DEPENDENT_P(NODE) TYPE_LANG_FLAG_0 (NODE) 1015 1016 /* True if dependent_type_p has been called for this type, with the 1017 result that TYPE_DEPENDENT_P is valid. */ 1018 #define TYPE_DEPENDENT_P_VALID(NODE) TYPE_LANG_FLAG_6(NODE) 1019 1020 /* Nonzero if this type is const-qualified. */ 1021 #define CP_TYPE_CONST_P(NODE) \ 1022 ((cp_type_quals (NODE) & TYPE_QUAL_CONST) != 0) 1023 1024 /* Nonzero if this type is volatile-qualified. */ 1025 #define CP_TYPE_VOLATILE_P(NODE) \ 1026 ((cp_type_quals (NODE) & TYPE_QUAL_VOLATILE) != 0) 1027 1028 /* Nonzero if this type is restrict-qualified. */ 1029 #define CP_TYPE_RESTRICT_P(NODE) \ 1030 ((cp_type_quals (NODE) & TYPE_QUAL_RESTRICT) != 0) 1031 1032 /* Nonzero if this type is const-qualified, but not 1033 volatile-qualified. Other qualifiers are ignored. This macro is 1034 used to test whether or not it is OK to bind an rvalue to a 1035 reference. */ 1036 #define CP_TYPE_CONST_NON_VOLATILE_P(NODE) \ 1037 ((cp_type_quals (NODE) & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)) \ 1038 == TYPE_QUAL_CONST) 1039 1040 #define FUNCTION_ARG_CHAIN(NODE) \ 1041 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (NODE))) 1042 1043 /* Given a FUNCTION_DECL, returns the first TREE_LIST out of TYPE_ARG_TYPES 1044 which refers to a user-written parameter. */ 1045 #define FUNCTION_FIRST_USER_PARMTYPE(NODE) \ 1046 skip_artificial_parms_for ((NODE), TYPE_ARG_TYPES (TREE_TYPE (NODE))) 1047 1048 /* Similarly, but for DECL_ARGUMENTS. */ 1049 #define FUNCTION_FIRST_USER_PARM(NODE) \ 1050 skip_artificial_parms_for ((NODE), DECL_ARGUMENTS (NODE)) 1051 1052 /* Nonzero iff TYPE is derived from PARENT. Ignores accessibility and 1053 ambiguity issues. */ 1054 #define DERIVED_FROM_P(PARENT, TYPE) \ 1055 (lookup_base ((TYPE), (PARENT), ba_any, NULL) != NULL_TREE) 1056 /* Nonzero iff TYPE is uniquely derived from PARENT. Ignores 1057 accessibility. */ 1058 #define UNIQUELY_DERIVED_FROM_P(PARENT, TYPE) \ 1059 (lookup_base ((TYPE), (PARENT), ba_unique | ba_quiet, NULL) != NULL_TREE) 1060 /* Nonzero iff TYPE is publicly & uniquely derived from PARENT. */ 1061 #define PUBLICLY_UNIQUELY_DERIVED_P(PARENT, TYPE) \ 1062 (lookup_base ((TYPE), (PARENT), ba_ignore_scope | ba_check | ba_quiet, \ 1063 NULL) != NULL_TREE) 1064 1065 /* Gives the visibility specification for a class type. */ 1066 #define CLASSTYPE_VISIBILITY(TYPE) \ 1067 DECL_VISIBILITY (TYPE_NAME (TYPE)) 1068 #define CLASSTYPE_VISIBILITY_SPECIFIED(TYPE) \ 1069 DECL_VISIBILITY_SPECIFIED (TYPE_NAME (TYPE)) 1070 1071 typedef struct tree_pair_s GTY (()) 1072 { 1073 tree purpose; 1074 tree value; 1075 } tree_pair_s; 1076 typedef tree_pair_s *tree_pair_p; 1077 DEF_VEC_O (tree_pair_s); 1078 DEF_VEC_ALLOC_O (tree_pair_s,gc); 1079 1080 /* This is a few header flags for 'struct lang_type'. Actually, 1081 all but the first are used only for lang_type_class; they 1082 are put in this structure to save space. */ 1083 struct lang_type_header GTY(()) 1084 { 1085 BOOL_BITFIELD is_lang_type_class : 1; 1086 1087 BOOL_BITFIELD has_type_conversion : 1; 1088 BOOL_BITFIELD has_init_ref : 1; 1089 BOOL_BITFIELD has_default_ctor : 1; 1090 BOOL_BITFIELD const_needs_init : 1; 1091 BOOL_BITFIELD ref_needs_init : 1; 1092 BOOL_BITFIELD has_const_assign_ref : 1; 1093 1094 BOOL_BITFIELD spare : 1; 1095 }; 1096 1097 /* This structure provides additional information above and beyond 1098 what is provide in the ordinary tree_type. In the past, we used it 1099 for the types of class types, template parameters types, typename 1100 types, and so forth. However, there can be many (tens to hundreds 1101 of thousands) of template parameter types in a compilation, and 1102 there's no need for this additional information in that case. 1103 Therefore, we now use this data structure only for class types. 1104 1105 In the past, it was thought that there would be relatively few 1106 class types. However, in the presence of heavy use of templates, 1107 many (i.e., thousands) of classes can easily be generated. 1108 Therefore, we should endeavor to keep the size of this structure to 1109 a minimum. */ 1110 struct lang_type_class GTY(()) 1111 { 1112 struct lang_type_header h; 1113 1114 unsigned char align; 1115 1116 unsigned has_mutable : 1; 1117 unsigned com_interface : 1; 1118 unsigned non_pod_class : 1; 1119 unsigned nearly_empty_p : 1; 1120 unsigned user_align : 1; 1121 unsigned has_assign_ref : 1; 1122 unsigned has_new : 1; 1123 unsigned has_array_new : 1; 1124 1125 unsigned gets_delete : 2; 1126 unsigned interface_only : 1; 1127 unsigned interface_unknown : 1; 1128 unsigned contains_empty_class_p : 1; 1129 unsigned anon_aggr : 1; 1130 unsigned non_zero_init : 1; 1131 unsigned empty_p : 1; 1132 1133 unsigned vec_new_uses_cookie : 1; 1134 unsigned declared_class : 1; 1135 unsigned diamond_shaped : 1; 1136 unsigned repeated_base : 1; 1137 unsigned being_defined : 1; 1138 unsigned java_interface : 1; 1139 unsigned debug_requested : 1; 1140 unsigned fields_readonly : 1; 1141 1142 unsigned use_template : 2; 1143 unsigned ptrmemfunc_flag : 1; 1144 unsigned was_anonymous : 1; 1145 unsigned lazy_default_ctor : 1; 1146 unsigned lazy_copy_ctor : 1; 1147 unsigned lazy_assignment_op : 1; 1148 unsigned lazy_destructor : 1; 1149 1150 unsigned has_const_init_ref : 1; 1151 unsigned has_complex_init_ref : 1; 1152 unsigned has_complex_assign_ref : 1; 1153 unsigned non_aggregate : 1; 1154 unsigned has_complex_dflt : 1; 1155 unsigned has_list_ctor : 1; 1156 1157 /* When adding a flag here, consider whether or not it ought to 1158 apply to a template instance if it applies to the template. If 1159 so, make sure to copy it in instantiate_class_template! */ 1160 1161 /* There are some bits left to fill out a 32-bit word. Keep track 1162 of this by updating the size of this bitfield whenever you add or 1163 remove a flag. */ 1164 unsigned dummy : 10; 1165 1166 tree primary_base; 1167 VEC(tree_pair_s,gc) *vcall_indices; 1168 tree vtables; 1169 tree typeinfo_var; 1170 VEC(tree,gc) *vbases; 1171 binding_table nested_udts; 1172 tree as_base; 1173 VEC(tree,gc) *pure_virtuals; 1174 tree friend_classes; 1175 VEC(tree,gc) * GTY((reorder ("resort_type_method_vec"))) methods; 1176 tree key_method; 1177 tree decl_list; 1178 tree template_info; 1179 tree befriending_classes; 1180 /* In a RECORD_TYPE, information specific to Objective-C++, such 1181 as a list of adopted protocols or a pointer to a corresponding 1182 @interface. See objc/objc-act.h for details. */ 1183 tree objc_info; 1184 }; 1185 1186 struct lang_type_ptrmem GTY(()) 1187 { 1188 struct lang_type_header h; 1189 tree record; 1190 }; 1191 1192 struct lang_type GTY(()) 1193 { 1194 union lang_type_u 1195 { 1196 struct lang_type_header GTY((skip (""))) h; 1197 struct lang_type_class GTY((tag ("1"))) c; 1198 struct lang_type_ptrmem GTY((tag ("0"))) ptrmem; 1199 } GTY((desc ("%h.h.is_lang_type_class"))) u; 1200 }; 1201 1202 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) 1203 1204 #define LANG_TYPE_CLASS_CHECK(NODE) __extension__ \ 1205 ({ struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE); \ 1206 if (! lt->u.h.is_lang_type_class) \ 1207 lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ 1208 <->u.c; }) 1209 1210 #define LANG_TYPE_PTRMEM_CHECK(NODE) __extension__ \ 1211 ({ struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE); \ 1212 if (lt->u.h.is_lang_type_class) \ 1213 lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ 1214 <->u.ptrmem; }) 1215 1216 #else 1217 1218 #define LANG_TYPE_CLASS_CHECK(NODE) (&TYPE_LANG_SPECIFIC (NODE)->u.c) 1219 #define LANG_TYPE_PTRMEM_CHECK(NODE) (&TYPE_LANG_SPECIFIC (NODE)->u.ptrmem) 1220 1221 #endif /* ENABLE_TREE_CHECKING */ 1222 1223 /* Fields used for storing information before the class is defined. 1224 After the class is defined, these fields hold other information. */ 1225 1226 /* VEC(tree) of friends which were defined inline in this class 1227 definition. */ 1228 #define CLASSTYPE_INLINE_FRIENDS(NODE) CLASSTYPE_PURE_VIRTUALS (NODE) 1229 1230 /* Nonzero for _CLASSTYPE means that operator delete is defined. */ 1231 #define TYPE_GETS_DELETE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->gets_delete) 1232 #define TYPE_GETS_REG_DELETE(NODE) (TYPE_GETS_DELETE (NODE) & 1) 1233 1234 /* Nonzero if `new NODE[x]' should cause the allocation of extra 1235 storage to indicate how many array elements are in use. */ 1236 #define TYPE_VEC_NEW_USES_COOKIE(NODE) \ 1237 (CLASS_TYPE_P (NODE) \ 1238 && LANG_TYPE_CLASS_CHECK (NODE)->vec_new_uses_cookie) 1239 1240 /* Nonzero means that this _CLASSTYPE node defines ways of converting 1241 itself to other types. */ 1242 #define TYPE_HAS_CONVERSION(NODE) \ 1243 (LANG_TYPE_CLASS_CHECK (NODE)->h.has_type_conversion) 1244 1245 /* Nonzero means that NODE (a class type) has a default constructor -- 1246 but that it has not yet been declared. */ 1247 #define CLASSTYPE_LAZY_DEFAULT_CTOR(NODE) \ 1248 (LANG_TYPE_CLASS_CHECK (NODE)->lazy_default_ctor) 1249 1250 /* Nonzero means that NODE (a class type) has a copy constructor -- 1251 but that it has not yet been declared. */ 1252 #define CLASSTYPE_LAZY_COPY_CTOR(NODE) \ 1253 (LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_ctor) 1254 1255 /* Nonzero means that NODE (a class type) has an assignment operator 1256 -- but that it has not yet been declared. */ 1257 #define CLASSTYPE_LAZY_ASSIGNMENT_OP(NODE) \ 1258 (LANG_TYPE_CLASS_CHECK (NODE)->lazy_assignment_op) 1259 1260 /* Nonzero means that NODE (a class type) has a destructor -- but that 1261 it has not yet been declared. */ 1262 #define CLASSTYPE_LAZY_DESTRUCTOR(NODE) \ 1263 (LANG_TYPE_CLASS_CHECK (NODE)->lazy_destructor) 1264 1265 /* Nonzero means that this _CLASSTYPE node overloads operator=(X&). */ 1266 #define TYPE_HAS_ASSIGN_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_assign_ref) 1267 1268 /* True iff the class type NODE has an "operator =" whose parameter 1269 has a parameter of type "const X&". */ 1270 #define TYPE_HAS_CONST_ASSIGN_REF(NODE) \ 1271 (LANG_TYPE_CLASS_CHECK (NODE)->h.has_const_assign_ref) 1272 1273 /* Nonzero means that this _CLASSTYPE node has an X(X&) constructor. */ 1274 #define TYPE_HAS_INIT_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->h.has_init_ref) 1275 #define TYPE_HAS_CONST_INIT_REF(NODE) \ 1276 (LANG_TYPE_CLASS_CHECK (NODE)->has_const_init_ref) 1277 1278 /* Nonzero if this class has an X(initializer_list<T>) constructor. */ 1279 #define TYPE_HAS_LIST_CTOR(NODE) \ 1280 (LANG_TYPE_CLASS_CHECK (NODE)->has_list_ctor) 1281 1282 /* Nonzero if this class defines an overloaded operator new. (An 1283 operator new [] doesn't count.) */ 1284 #define TYPE_HAS_NEW_OPERATOR(NODE) \ 1285 (LANG_TYPE_CLASS_CHECK (NODE)->has_new) 1286 1287 /* Nonzero if this class defines an overloaded operator new[]. */ 1288 #define TYPE_HAS_ARRAY_NEW_OPERATOR(NODE) \ 1289 (LANG_TYPE_CLASS_CHECK (NODE)->has_array_new) 1290 1291 /* Nonzero means that this type is being defined. I.e., the left brace 1292 starting the definition of this type has been seen. */ 1293 #define TYPE_BEING_DEFINED(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->being_defined) 1294 1295 /* Mark bits for repeated base checks. */ 1296 #define TYPE_MARKED_P(NODE) TREE_LANG_FLAG_6 (TYPE_CHECK (NODE)) 1297 1298 /* Nonzero if the class NODE has multiple paths to the same (virtual) 1299 base object. */ 1300 #define CLASSTYPE_DIAMOND_SHAPED_P(NODE) \ 1301 (LANG_TYPE_CLASS_CHECK(NODE)->diamond_shaped) 1302 1303 /* Nonzero if the class NODE has multiple instances of the same base 1304 type. */ 1305 #define CLASSTYPE_REPEATED_BASE_P(NODE) \ 1306 (LANG_TYPE_CLASS_CHECK(NODE)->repeated_base) 1307 1308 /* The member function with which the vtable will be emitted: 1309 the first noninline non-pure-virtual member function. NULL_TREE 1310 if there is no key function or if this is a class template */ 1311 #define CLASSTYPE_KEY_METHOD(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->key_method) 1312 1313 /* Vector member functions defined in this class. Each element is 1314 either a FUNCTION_DECL, a TEMPLATE_DECL, or an OVERLOAD. All 1315 functions with the same name end up in the same slot. The first 1316 two elements are for constructors, and destructors, respectively. 1317 All template conversion operators to innermost template dependent 1318 types are overloaded on the next slot, if they exist. Note, the 1319 names for these functions will not all be the same. The 1320 non-template conversion operators & templated conversions to 1321 non-innermost template types are next, followed by ordinary member 1322 functions. There may be empty entries at the end of the vector. 1323 The conversion operators are unsorted. The ordinary member 1324 functions are sorted, once the class is complete. */ 1325 #define CLASSTYPE_METHOD_VEC(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->methods) 1326 1327 /* For class templates, this is a TREE_LIST of all member data, 1328 functions, types, and friends in the order of declaration. 1329 The TREE_PURPOSE of each TREE_LIST is NULL_TREE for a friend, 1330 and the RECORD_TYPE for the class template otherwise. */ 1331 #define CLASSTYPE_DECL_LIST(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->decl_list) 1332 1333 /* The slot in the CLASSTYPE_METHOD_VEC where constructors go. */ 1334 #define CLASSTYPE_CONSTRUCTOR_SLOT 0 1335 1336 /* The slot in the CLASSTYPE_METHOD_VEC where destructors go. */ 1337 #define CLASSTYPE_DESTRUCTOR_SLOT 1 1338 1339 /* The first slot in the CLASSTYPE_METHOD_VEC where conversion 1340 operators can appear. */ 1341 #define CLASSTYPE_FIRST_CONVERSION_SLOT 2 1342 1343 /* A FUNCTION_DECL or OVERLOAD for the constructors for NODE. These 1344 are the constructors that take an in-charge parameter. */ 1345 #define CLASSTYPE_CONSTRUCTORS(NODE) \ 1346 (VEC_index (tree, CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_CONSTRUCTOR_SLOT)) 1347 1348 /* A FUNCTION_DECL for the destructor for NODE. These are the 1349 destructors that take an in-charge parameter. If 1350 CLASSTYPE_LAZY_DESTRUCTOR is true, then this entry will be NULL 1351 until the destructor is created with lazily_declare_fn. */ 1352 #define CLASSTYPE_DESTRUCTORS(NODE) \ 1353 (CLASSTYPE_METHOD_VEC (NODE) \ 1354 ? VEC_index (tree, CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_DESTRUCTOR_SLOT) \ 1355 : NULL_TREE) 1356 1357 /* A dictionary of the nested user-defined-types (class-types, or enums) 1358 found within this class. This table includes nested member class 1359 templates. */ 1360 #define CLASSTYPE_NESTED_UTDS(NODE) \ 1361 (LANG_TYPE_CLASS_CHECK (NODE)->nested_udts) 1362 1363 /* Nonzero if NODE has a primary base class, i.e., a base class with 1364 which it shares the virtual function table pointer. */ 1365 #define CLASSTYPE_HAS_PRIMARY_BASE_P(NODE) \ 1366 (CLASSTYPE_PRIMARY_BINFO (NODE) != NULL_TREE) 1367 1368 /* If non-NULL, this is the binfo for the primary base class, i.e., 1369 the base class which contains the virtual function table pointer 1370 for this class. */ 1371 #define CLASSTYPE_PRIMARY_BINFO(NODE) \ 1372 (LANG_TYPE_CLASS_CHECK (NODE)->primary_base) 1373 1374 /* A vector of BINFOs for the direct and indirect virtual base classes 1375 that this type uses in a post-order depth-first left-to-right 1376 order. (In other words, these bases appear in the order that they 1377 should be initialized.) */ 1378 #define CLASSTYPE_VBASECLASSES(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->vbases) 1379 1380 /* The type corresponding to NODE when NODE is used as a base class, 1381 i.e., NODE without virtual base classes. */ 1382 1383 #define CLASSTYPE_AS_BASE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->as_base) 1384 1385 /* True iff NODE is the CLASSTYPE_AS_BASE version of some type. */ 1386 1387 #define IS_FAKE_BASE_TYPE(NODE) \ 1388 (TREE_CODE (NODE) == RECORD_TYPE \ 1389 && TYPE_CONTEXT (NODE) && CLASS_TYPE_P (TYPE_CONTEXT (NODE)) \ 1390 && CLASSTYPE_AS_BASE (TYPE_CONTEXT (NODE)) == (NODE)) 1391 1392 /* These are the size and alignment of the type without its virtual 1393 base classes, for when we use this type as a base itself. */ 1394 #define CLASSTYPE_SIZE(NODE) TYPE_SIZE (CLASSTYPE_AS_BASE (NODE)) 1395 #define CLASSTYPE_SIZE_UNIT(NODE) TYPE_SIZE_UNIT (CLASSTYPE_AS_BASE (NODE)) 1396 #define CLASSTYPE_ALIGN(NODE) TYPE_ALIGN (CLASSTYPE_AS_BASE (NODE)) 1397 #define CLASSTYPE_USER_ALIGN(NODE) TYPE_USER_ALIGN (CLASSTYPE_AS_BASE (NODE)) 1398 1399 /* The alignment of NODE, without its virtual bases, in bytes. */ 1400 #define CLASSTYPE_ALIGN_UNIT(NODE) \ 1401 (CLASSTYPE_ALIGN (NODE) / BITS_PER_UNIT) 1402 1403 /* True if this a Java interface type, declared with 1404 '__attribute__ ((java_interface))'. */ 1405 #define TYPE_JAVA_INTERFACE(NODE) \ 1406 (LANG_TYPE_CLASS_CHECK (NODE)->java_interface) 1407 1408 /* A VEC(tree) of virtual functions which cannot be inherited by 1409 derived classes. When deriving from this type, the derived 1410 class must provide its own definition for each of these functions. */ 1411 #define CLASSTYPE_PURE_VIRTUALS(NODE) \ 1412 (LANG_TYPE_CLASS_CHECK (NODE)->pure_virtuals) 1413 1414 /* Nonzero means that this type has an X() constructor. */ 1415 #define TYPE_HAS_DEFAULT_CONSTRUCTOR(NODE) \ 1416 (LANG_TYPE_CLASS_CHECK (NODE)->h.has_default_ctor) 1417 1418 /* Nonzero means that this type contains a mutable member. */ 1419 #define CLASSTYPE_HAS_MUTABLE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_mutable) 1420 #define TYPE_HAS_MUTABLE_P(NODE) (cp_has_mutable_p (NODE)) 1421 1422 /* Nonzero means that this class type is a non-POD class. */ 1423 #define CLASSTYPE_NON_POD_P(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->non_pod_class) 1424 1425 /* Nonzero means that this class contains pod types whose default 1426 initialization is not a zero initialization (namely, pointers to 1427 data members). */ 1428 #define CLASSTYPE_NON_ZERO_INIT_P(NODE) \ 1429 (LANG_TYPE_CLASS_CHECK (NODE)->non_zero_init) 1430 1431 /* Nonzero if this class is "empty" in the sense of the C++ ABI. */ 1432 #define CLASSTYPE_EMPTY_P(NODE) \ 1433 (LANG_TYPE_CLASS_CHECK (NODE)->empty_p) 1434 1435 /* Nonzero if this class is "nearly empty", i.e., contains only a 1436 virtual function table pointer. */ 1437 #define CLASSTYPE_NEARLY_EMPTY_P(NODE) \ 1438 (LANG_TYPE_CLASS_CHECK (NODE)->nearly_empty_p) 1439 1440 /* Nonzero if this class contains an empty subobject. */ 1441 #define CLASSTYPE_CONTAINS_EMPTY_CLASS_P(NODE) \ 1442 (LANG_TYPE_CLASS_CHECK (NODE)->contains_empty_class_p) 1443 1444 /* A list of class types of which this type is a friend. The 1445 TREE_VALUE is normally a TYPE, but will be a TEMPLATE_DECL in the 1446 case of a template friend. */ 1447 #define CLASSTYPE_FRIEND_CLASSES(NODE) \ 1448 (LANG_TYPE_CLASS_CHECK (NODE)->friend_classes) 1449 1450 /* A list of the classes which grant friendship to this class. */ 1451 #define CLASSTYPE_BEFRIENDING_CLASSES(NODE) \ 1452 (LANG_TYPE_CLASS_CHECK (NODE)->befriending_classes) 1453 1454 /* Say whether this node was declared as a "class" or a "struct". */ 1455 #define CLASSTYPE_DECLARED_CLASS(NODE) \ 1456 (LANG_TYPE_CLASS_CHECK (NODE)->declared_class) 1457 1458 /* Nonzero if this class has const members 1459 which have no specified initialization. */ 1460 #define CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE) \ 1461 (TYPE_LANG_SPECIFIC (NODE) \ 1462 ? LANG_TYPE_CLASS_CHECK (NODE)->h.const_needs_init : 0) 1463 #define SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE, VALUE) \ 1464 (LANG_TYPE_CLASS_CHECK (NODE)->h.const_needs_init = (VALUE)) 1465 1466 /* Nonzero if this class has ref members 1467 which have no specified initialization. */ 1468 #define CLASSTYPE_REF_FIELDS_NEED_INIT(NODE) \ 1469 (TYPE_LANG_SPECIFIC (NODE) \ 1470 ? LANG_TYPE_CLASS_CHECK (NODE)->h.ref_needs_init : 0) 1471 #define SET_CLASSTYPE_REF_FIELDS_NEED_INIT(NODE, VALUE) \ 1472 (LANG_TYPE_CLASS_CHECK (NODE)->h.ref_needs_init = (VALUE)) 1473 1474 /* Nonzero if this class is included from a header file which employs 1475 `#pragma interface', and it is not included in its implementation file. */ 1476 #define CLASSTYPE_INTERFACE_ONLY(NODE) \ 1477 (LANG_TYPE_CLASS_CHECK (NODE)->interface_only) 1478 1479 /* True if we have already determined whether or not vtables, VTTs, 1480 typeinfo, and other similar per-class data should be emitted in 1481 this translation unit. This flag does not indicate whether or not 1482 these items should be emitted; it only indicates that we know one 1483 way or the other. */ 1484 #define CLASSTYPE_INTERFACE_KNOWN(NODE) \ 1485 (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown == 0) 1486 /* The opposite of CLASSTYPE_INTERFACE_KNOWN. */ 1487 #define CLASSTYPE_INTERFACE_UNKNOWN(NODE) \ 1488 (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown) 1489 1490 #define SET_CLASSTYPE_INTERFACE_UNKNOWN_X(NODE,X) \ 1491 (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = !!(X)) 1492 #define SET_CLASSTYPE_INTERFACE_UNKNOWN(NODE) \ 1493 (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 1) 1494 #define SET_CLASSTYPE_INTERFACE_KNOWN(NODE) \ 1495 (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 0) 1496 1497 /* Nonzero if a _DECL node requires us to output debug info for this class. */ 1498 #define CLASSTYPE_DEBUG_REQUESTED(NODE) \ 1499 (LANG_TYPE_CLASS_CHECK (NODE)->debug_requested) 1500 1501 /* Additional macros for inheritance information. */ 1503 1504 /* Nonzero means that this class is on a path leading to a new vtable. */ 1505 #define BINFO_VTABLE_PATH_MARKED(NODE) BINFO_FLAG_1 (NODE) 1506 1507 /* Nonzero means B (a BINFO) has its own vtable. Any copies will not 1508 have this flag set. */ 1509 #define BINFO_NEW_VTABLE_MARKED(B) (BINFO_FLAG_2 (B)) 1510 1511 /* Compare a BINFO_TYPE with another type for equality. For a binfo, 1512 this is functionally equivalent to using same_type_p, but 1513 measurably faster. At least one of the arguments must be a 1514 BINFO_TYPE. The other can be a BINFO_TYPE or a regular type. If 1515 BINFO_TYPE(T) ever stops being the main variant of the class the 1516 binfo is for, this macro must change. */ 1517 #define SAME_BINFO_TYPE_P(A, B) ((A) == (B)) 1518 1519 /* Any subobject that needs a new vtable must have a vptr and must not 1520 be a non-virtual primary base (since it would then use the vtable from a 1521 derived class and never become non-primary.) */ 1522 #define SET_BINFO_NEW_VTABLE_MARKED(B) \ 1523 (BINFO_NEW_VTABLE_MARKED (B) = 1, \ 1524 gcc_assert (!BINFO_PRIMARY_P (B) || BINFO_VIRTUAL_P (B)), \ 1525 gcc_assert (TYPE_VFIELD (BINFO_TYPE (B)))) 1526 1527 /* Nonzero if this binfo is for a dependent base - one that should not 1528 be searched. */ 1529 #define BINFO_DEPENDENT_BASE_P(NODE) BINFO_FLAG_3 (NODE) 1530 1531 /* Nonzero if this binfo has lost its primary base binfo (because that 1532 is a nearly-empty virtual base that has been taken by some other 1533 base in the complete hierarchy. */ 1534 #define BINFO_LOST_PRIMARY_P(NODE) BINFO_FLAG_4 (NODE) 1535 1536 /* Nonzero if this BINFO is a primary base class. */ 1537 #define BINFO_PRIMARY_P(NODE) BINFO_FLAG_5(NODE) 1538 1539 /* Used by various search routines. */ 1540 #define IDENTIFIER_MARKED(NODE) TREE_LANG_FLAG_0 (NODE) 1541 1542 /* A VEC(tree_pair_s) of the vcall indices associated with the class 1544 NODE. The PURPOSE of each element is a FUNCTION_DECL for a virtual 1545 function. The VALUE is the index into the virtual table where the 1546 vcall offset for that function is stored, when NODE is a virtual 1547 base. */ 1548 #define CLASSTYPE_VCALL_INDICES(NODE) \ 1549 (LANG_TYPE_CLASS_CHECK (NODE)->vcall_indices) 1550 1551 /* The various vtables for the class NODE. The primary vtable will be 1552 first, followed by the construction vtables and VTT, if any. */ 1553 #define CLASSTYPE_VTABLES(NODE) \ 1554 (LANG_TYPE_CLASS_CHECK (NODE)->vtables) 1555 1556 /* The std::type_info variable representing this class, or NULL if no 1557 such variable has been created. This field is only set for the 1558 TYPE_MAIN_VARIANT of the class. */ 1559 #define CLASSTYPE_TYPEINFO_VAR(NODE) \ 1560 (LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var) 1561 1562 /* Accessor macros for the BINFO_VIRTUALS list. */ 1563 1564 /* The number of bytes by which to adjust the `this' pointer when 1565 calling this virtual function. Subtract this value from the this 1566 pointer. Always non-NULL, might be constant zero though. */ 1567 #define BV_DELTA(NODE) (TREE_PURPOSE (NODE)) 1568 1569 /* If non-NULL, the vtable index at which to find the vcall offset 1570 when calling this virtual function. Add the value at that vtable 1571 index to the this pointer. */ 1572 #define BV_VCALL_INDEX(NODE) (TREE_TYPE (NODE)) 1573 1574 /* The function to call. */ 1575 #define BV_FN(NODE) (TREE_VALUE (NODE)) 1576 1577 1578 /* For FUNCTION_TYPE or METHOD_TYPE, a list of the exceptions that 1580 this type can raise. Each TREE_VALUE is a _TYPE. The TREE_VALUE 1581 will be NULL_TREE to indicate a throw specification of `()', or 1582 no exceptions allowed. */ 1583 #define TYPE_RAISES_EXCEPTIONS(NODE) TYPE_LANG_SLOT_1 (NODE) 1584 1585 /* For FUNCTION_TYPE or METHOD_TYPE, return 1 iff it is declared `throw()'. */ 1586 #define TYPE_NOTHROW_P(NODE) \ 1587 (TYPE_RAISES_EXCEPTIONS (NODE) \ 1588 && TREE_VALUE (TYPE_RAISES_EXCEPTIONS (NODE)) == NULL_TREE) 1589 1590 /* The binding level associated with the namespace. */ 1591 #define NAMESPACE_LEVEL(NODE) \ 1592 (DECL_LANG_SPECIFIC (NODE)->decl_flags.u.level) 1593 1594 1596 /* If a DECL has DECL_LANG_SPECIFIC, it is either a lang_decl_flags or 1597 a lang_decl (which has lang_decl_flags as its initial prefix). 1598 This macro is nonzero for tree nodes whose DECL_LANG_SPECIFIC is 1599 the full lang_decl, and not just lang_decl_flags. Keep these 1600 checks in ascending code order. */ 1601 #define CAN_HAVE_FULL_LANG_DECL_P(NODE) \ 1602 (!(TREE_CODE (NODE) == FIELD_DECL \ 1603 || TREE_CODE (NODE) == VAR_DECL \ 1604 || TREE_CODE (NODE) == CONST_DECL \ 1605 || TREE_CODE (NODE) == USING_DECL)) 1606 1607 struct lang_decl_flags GTY(()) 1608 { 1609 ENUM_BITFIELD(languages) language : 4; 1610 unsigned global_ctor_p : 1; 1611 unsigned global_dtor_p : 1; 1612 unsigned anticipated_p : 1; 1613 unsigned template_conv_p : 1; 1614 1615 unsigned operator_attr : 1; 1616 unsigned constructor_attr : 1; 1617 unsigned destructor_attr : 1; 1618 unsigned friend_attr : 1; 1619 unsigned static_function : 1; 1620 unsigned pure_virtual : 1; 1621 unsigned has_in_charge_parm_p : 1; 1622 unsigned has_vtt_parm_p : 1; 1623 1624 unsigned deferred : 1; 1625 unsigned use_template : 2; 1626 unsigned nonconverting : 1; 1627 unsigned not_really_extern : 1; 1628 unsigned initialized_in_class : 1; 1629 unsigned assignment_operator_p : 1; 1630 unsigned u1sel : 1; 1631 1632 unsigned u2sel : 1; 1633 unsigned can_be_full : 1; 1634 unsigned thunk_p : 1; 1635 unsigned this_thunk_p : 1; 1636 unsigned repo_available_p : 1; 1637 unsigned hidden_friend_p : 1; 1638 unsigned threadprivate_or_deleted_p : 1; 1639 unsigned defaulted_p : 1; 1640 1641 union lang_decl_u { 1642 /* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is 1643 THUNK_ALIAS. 1644 In a FUNCTION_DECL for which DECL_THUNK_P does not hold, 1645 VAR_DECL, TYPE_DECL, or TEMPLATE_DECL, this is 1646 DECL_TEMPLATE_INFO. */ 1647 tree GTY ((tag ("0"))) template_info; 1648 1649 /* In a NAMESPACE_DECL, this is NAMESPACE_LEVEL. */ 1650 struct cp_binding_level * GTY ((tag ("1"))) level; 1651 } GTY ((desc ("%1.u1sel"))) u; 1652 1653 union lang_decl_u2 { 1654 /* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is 1655 THUNK_VIRTUAL_OFFSET. 1656 Otherwise this is DECL_ACCESS. */ 1657 tree GTY ((tag ("0"))) access; 1658 1659 /* For VAR_DECL in function, this is DECL_DISCRIMINATOR. */ 1660 int GTY ((tag ("1"))) discriminator; 1661 } GTY ((desc ("%1.u2sel"))) u2; 1662 }; 1663 1664 /* sorted_fields is sorted based on a pointer, so we need to be able 1665 to resort it if pointers get rearranged. */ 1666 1667 struct lang_decl GTY(()) 1668 { 1669 struct lang_decl_flags decl_flags; 1670 1671 union lang_decl_u4 1672 { 1673 struct full_lang_decl 1674 { 1675 /* In an overloaded operator, this is the value of 1676 DECL_OVERLOADED_OPERATOR_P. */ 1677 ENUM_BITFIELD (tree_code) operator_code : 16; 1678 1679 unsigned u3sel : 1; 1680 unsigned pending_inline_p : 1; 1681 unsigned spare : 14; 1682 1683 /* For a non-thunk function decl, this is a tree list of 1684 friendly classes. For a thunk function decl, it is the 1685 thunked to function decl. */ 1686 tree befriending_classes; 1687 1688 /* For a non-virtual FUNCTION_DECL, this is 1689 DECL_FRIEND_CONTEXT. For a virtual FUNCTION_DECL for which 1690 DECL_THIS_THUNK_P does not hold, this is DECL_THUNKS. Both 1691 this pointer and result pointer adjusting thunks are 1692 chained here. This pointer thunks to return pointer thunks 1693 will be chained on the return pointer thunk. */ 1694 tree context; 1695 1696 union lang_decl_u5 1697 { 1698 /* In a non-thunk FUNCTION_DECL or TEMPLATE_DECL, this is 1699 DECL_CLONED_FUNCTION. */ 1700 tree GTY ((tag ("0"))) cloned_function; 1701 1702 /* In a FUNCTION_DECL for which THUNK_P holds this is the 1703 THUNK_FIXED_OFFSET. */ 1704 HOST_WIDE_INT GTY ((tag ("1"))) fixed_offset; 1705 } GTY ((desc ("%0.decl_flags.thunk_p"))) u5; 1706 1707 union lang_decl_u3 1708 { 1709 struct sorted_fields_type * GTY ((tag ("0"), reorder ("resort_sorted_fields"))) 1710 sorted_fields; 1711 struct cp_token_cache * GTY ((tag ("2"))) pending_inline_info; 1712 struct language_function * GTY ((tag ("1"))) 1713 saved_language_function; 1714 } GTY ((desc ("%1.u3sel + %1.pending_inline_p"))) u; 1715 } GTY ((tag ("1"))) f; 1716 } GTY ((desc ("%1.decl_flags.can_be_full"))) u; 1717 }; 1718 1719 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) 1720 1721 #define LANG_DECL_U2_CHECK(NODE, TF) __extension__ \ 1722 ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \ 1723 if (lt->decl_flags.u2sel != TF) \ 1724 lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ 1725 <->decl_flags.u2; }) 1726 1727 #else 1728 1729 #define LANG_DECL_U2_CHECK(NODE, TF) \ 1730 (&DECL_LANG_SPECIFIC (NODE)->decl_flags.u2) 1731 1732 #endif /* ENABLE_TREE_CHECKING */ 1733 1734 /* For a FUNCTION_DECL or a VAR_DECL, the language linkage for the 1735 declaration. Some entities (like a member function in a local 1736 class, or a local variable) do not have linkage at all, and this 1737 macro should not be used in those cases. 1738 1739 Implementation note: A FUNCTION_DECL without DECL_LANG_SPECIFIC was 1740 created by language-independent code, and has C linkage. Most 1741 VAR_DECLs have C++ linkage, and do not have DECL_LANG_SPECIFIC, but 1742 we do create DECL_LANG_SPECIFIC for variables with non-C++ linkage. */ 1743 #define DECL_LANGUAGE(NODE) \ 1744 (DECL_LANG_SPECIFIC (NODE) \ 1745 ? DECL_LANG_SPECIFIC (NODE)->decl_flags.language \ 1746 : (TREE_CODE (NODE) == FUNCTION_DECL \ 1747 ? lang_c : lang_cplusplus)) 1748 1749 /* Set the language linkage for NODE to LANGUAGE. */ 1750 #define SET_DECL_LANGUAGE(NODE, LANGUAGE) \ 1751 (DECL_LANG_SPECIFIC (NODE)->decl_flags.language = (LANGUAGE)) 1752 1753 /* For FUNCTION_DECLs: nonzero means that this function is a constructor. */ 1754 #define DECL_CONSTRUCTOR_P(NODE) \ 1755 (DECL_LANG_SPECIFIC (NODE)->decl_flags.constructor_attr) 1756 1757 /* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a complete 1758 object. */ 1759 #define DECL_COMPLETE_CONSTRUCTOR_P(NODE) \ 1760 (DECL_CONSTRUCTOR_P (NODE) \ 1761 && DECL_NAME (NODE) == complete_ctor_identifier) 1762 1763 /* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a base 1764 object. */ 1765 #define DECL_BASE_CONSTRUCTOR_P(NODE) \ 1766 (DECL_CONSTRUCTOR_P (NODE) \ 1767 && DECL_NAME (NODE) == base_ctor_identifier) 1768 1769 /* Nonzero if NODE (a FUNCTION_DECL) is a constructor, but not either the 1770 specialized in-charge constructor or the specialized not-in-charge 1771 constructor. */ 1772 #define DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P(NODE) \ 1773 (DECL_CONSTRUCTOR_P (NODE) && !DECL_CLONED_FUNCTION_P (NODE)) 1774 1775 /* Nonzero if NODE (a FUNCTION_DECL) is a copy constructor. */ 1776 #define DECL_COPY_CONSTRUCTOR_P(NODE) \ 1777 (DECL_CONSTRUCTOR_P (NODE) && copy_fn_p (NODE) > 0) 1778 1779 /* Nonzero if NODE (a FUNCTION_DECL) is a move constructor. */ 1780 #define DECL_MOVE_CONSTRUCTOR_P(NODE) \ 1781 (DECL_CONSTRUCTOR_P (NODE) && move_fn_p (NODE)) 1782 1783 /* Nonzero if NODE is a destructor. */ 1784 #define DECL_DESTRUCTOR_P(NODE) \ 1785 (DECL_LANG_SPECIFIC (NODE)->decl_flags.destructor_attr) 1786 1787 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor, but not the 1788 specialized in-charge constructor, in-charge deleting constructor, 1789 or the base destructor. */ 1790 #define DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P(NODE) \ 1791 (DECL_DESTRUCTOR_P (NODE) && !DECL_CLONED_FUNCTION_P (NODE)) 1792 1793 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete 1794 object. */ 1795 #define DECL_COMPLETE_DESTRUCTOR_P(NODE) \ 1796 (DECL_DESTRUCTOR_P (NODE) \ 1797 && DECL_NAME (NODE) == complete_dtor_identifier) 1798 1799 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a base 1800 object. */ 1801 #define DECL_BASE_DESTRUCTOR_P(NODE) \ 1802 (DECL_DESTRUCTOR_P (NODE) \ 1803 && DECL_NAME (NODE) == base_dtor_identifier) 1804 1805 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete 1806 object that deletes the object after it has been destroyed. */ 1807 #define DECL_DELETING_DESTRUCTOR_P(NODE) \ 1808 (DECL_DESTRUCTOR_P (NODE) \ 1809 && DECL_NAME (NODE) == deleting_dtor_identifier) 1810 1811 /* Nonzero if NODE (a FUNCTION_DECL) is a cloned constructor or 1812 destructor. */ 1813 #define DECL_CLONED_FUNCTION_P(NODE) \ 1814 ((TREE_CODE (NODE) == FUNCTION_DECL \ 1815 || TREE_CODE (NODE) == TEMPLATE_DECL) \ 1816 && DECL_LANG_SPECIFIC (NODE) \ 1817 && !DECL_LANG_SPECIFIC (NODE)->decl_flags.thunk_p \ 1818 && DECL_CLONED_FUNCTION (NODE) != NULL_TREE) 1819 1820 /* If DECL_CLONED_FUNCTION_P holds, this is the function that was 1821 cloned. */ 1822 #define DECL_CLONED_FUNCTION(NODE) \ 1823 (DECL_LANG_SPECIFIC (NON_THUNK_FUNCTION_CHECK(NODE))->u.f.u5.cloned_function) 1824 1825 /* Perform an action for each clone of FN, if FN is a function with 1826 clones. This macro should be used like: 1827 1828 FOR_EACH_CLONE (clone, fn) 1829 { ... } 1830 1831 */ 1832 #define FOR_EACH_CLONE(CLONE, FN) \ 1833 if (TREE_CODE (FN) == FUNCTION_DECL \ 1834 && (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (FN) \ 1835 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (FN))) \ 1836 for (CLONE = TREE_CHAIN (FN); \ 1837 CLONE && DECL_CLONED_FUNCTION_P (CLONE); \ 1838 CLONE = TREE_CHAIN (CLONE)) 1839 1840 /* Nonzero if NODE has DECL_DISCRIMINATOR and not DECL_ACCESS. */ 1841 #define DECL_DISCRIMINATOR_P(NODE) \ 1842 (TREE_CODE (NODE) == VAR_DECL \ 1843 && DECL_FUNCTION_SCOPE_P (NODE)) 1844 1845 /* Discriminator for name mangling. */ 1846 #define DECL_DISCRIMINATOR(NODE) (LANG_DECL_U2_CHECK (NODE, 1)->discriminator) 1847 1848 /* Nonzero if the VTT parm has been added to NODE. */ 1849 #define DECL_HAS_VTT_PARM_P(NODE) \ 1850 (DECL_LANG_SPECIFIC (NODE)->decl_flags.has_vtt_parm_p) 1851 1852 /* Nonzero if NODE is a FUNCTION_DECL for which a VTT parameter is 1853 required. */ 1854 #define DECL_NEEDS_VTT_PARM_P(NODE) \ 1855 (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (NODE)) \ 1856 && (DECL_BASE_CONSTRUCTOR_P (NODE) \ 1857 || DECL_BASE_DESTRUCTOR_P (NODE))) 1858 1859 /* Nonzero if NODE is a user-defined conversion operator. */ 1860 #define DECL_CONV_FN_P(NODE) \ 1861 (DECL_NAME (NODE) && IDENTIFIER_TYPENAME_P (DECL_NAME (NODE))) 1862 1863 /* If FN is a conversion operator, the type to which it converts. 1864 Otherwise, NULL_TREE. */ 1865 #define DECL_CONV_FN_TYPE(FN) \ 1866 (DECL_CONV_FN_P (FN) ? TREE_TYPE (DECL_NAME (FN)) : NULL_TREE) 1867 1868 /* Nonzero if NODE, which is a TEMPLATE_DECL, is a template 1869 conversion operator to a type dependent on the innermost template 1870 args. */ 1871 #define DECL_TEMPLATE_CONV_FN_P(NODE) \ 1872 (DECL_LANG_SPECIFIC (NODE)->decl_flags.template_conv_p) 1873 1874 /* Set the overloaded operator code for NODE to CODE. */ 1875 #define SET_OVERLOADED_OPERATOR_CODE(NODE, CODE) \ 1876 (DECL_LANG_SPECIFIC (NODE)->u.f.operator_code = (CODE)) 1877 1878 /* If NODE is an overloaded operator, then this returns the TREE_CODE 1879 associated with the overloaded operator. 1880 DECL_ASSIGNMENT_OPERATOR_P must also be checked to determine 1881 whether or not NODE is an assignment operator. If NODE is not an 1882 overloaded operator, ERROR_MARK is returned. Since the numerical 1883 value of ERROR_MARK is zero, this macro can be used as a predicate 1884 to test whether or not NODE is an overloaded operator. */ 1885 #define DECL_OVERLOADED_OPERATOR_P(NODE) \ 1886 (IDENTIFIER_OPNAME_P (DECL_NAME (NODE)) \ 1887 ? DECL_LANG_SPECIFIC (NODE)->u.f.operator_code : ERROR_MARK) 1888 1889 /* Nonzero if NODE is an assignment operator (including += and such). */ 1890 #define DECL_ASSIGNMENT_OPERATOR_P(NODE) \ 1891 (DECL_LANG_SPECIFIC (NODE)->decl_flags.assignment_operator_p) 1892 1893 /* For FUNCTION_DECLs: nonzero means that this function is a 1894 constructor or a destructor with an extra in-charge parameter to 1895 control whether or not virtual bases are constructed. */ 1896 #define DECL_HAS_IN_CHARGE_PARM_P(NODE) \ 1897 (DECL_LANG_SPECIFIC (NODE)->decl_flags.has_in_charge_parm_p) 1898 1899 /* Nonzero if DECL is a declaration of __builtin_constant_p. */ 1900 #define DECL_IS_BUILTIN_CONSTANT_P(NODE) \ 1901 (TREE_CODE (NODE) == FUNCTION_DECL \ 1902 && DECL_BUILT_IN_CLASS (NODE) == BUILT_IN_NORMAL \ 1903 && DECL_FUNCTION_CODE (NODE) == BUILT_IN_CONSTANT_P) 1904 1905 /* Nonzero for _DECL means that this decl appears in (or will appear 1906 in) as a member in a RECORD_TYPE or UNION_TYPE node. It is also for 1907 detecting circularity in case members are multiply defined. In the 1908 case of a VAR_DECL, it is also used to determine how program storage 1909 should be allocated. */ 1910 #define DECL_IN_AGGR_P(NODE) (DECL_LANG_FLAG_3 (NODE)) 1911 1912 /* Nonzero for a VAR_DECL means that the variable's initialization (if 1913 any) has been processed. (In general, DECL_INITIALIZED_P is 1914 !DECL_EXTERN, but static data members may be initialized even if 1915 not defined.) */ 1916 #define DECL_INITIALIZED_P(NODE) \ 1917 (TREE_LANG_FLAG_1 (VAR_DECL_CHECK (NODE))) 1918 1919 /* Nonzero for a VAR_DECL iff an explicit initializer was provided. */ 1920 #define DECL_NONTRIVIALLY_INITIALIZED_P(NODE) \ 1921 (TREE_LANG_FLAG_3 (VAR_DECL_CHECK (NODE))) 1922 1923 /* Nonzero for a VAR_DECL that was initialized with a 1924 constant-expression. */ 1925 #define DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P(NODE) \ 1926 (TREE_LANG_FLAG_2 (VAR_DECL_CHECK (NODE))) 1927 1928 /* Nonzero for a VAR_DECL that can be used in an integral constant 1929 expression. 1930 1931 [expr.const] 1932 1933 An integral constant-expression can only involve ... const 1934 variables of static or enumeration types initialized with 1935 constant expressions ... 1936 1937 The standard does not require that the expression be non-volatile. 1938 G++ implements the proposed correction in DR 457. */ 1939 #define DECL_INTEGRAL_CONSTANT_VAR_P(NODE) \ 1940 (TREE_CODE (NODE) == VAR_DECL \ 1941 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (NODE)) \ 1942 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (NODE)) \ 1943 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (NODE)) 1944 1945 /* Nonzero if the DECL was initialized in the class definition itself, 1946 rather than outside the class. This is used for both static member 1947 VAR_DECLS, and FUNCTION_DECLS that are defined in the class. */ 1948 #define DECL_INITIALIZED_IN_CLASS_P(DECL) \ 1949 (DECL_LANG_SPECIFIC (DECL)->decl_flags.initialized_in_class) 1950 1951 /* Nonzero for DECL means that this decl is just a friend declaration, 1952 and should not be added to the list of members for this class. */ 1953 #define DECL_FRIEND_P(NODE) (DECL_LANG_SPECIFIC (NODE)->decl_flags.friend_attr) 1954 1955 /* A TREE_LIST of the types which have befriended this FUNCTION_DECL. */ 1956 #define DECL_BEFRIENDING_CLASSES(NODE) \ 1957 (DECL_LANG_SPECIFIC (NODE)->u.f.befriending_classes) 1958 1959 /* Nonzero for FUNCTION_DECL means that this decl is a static 1960 member function. */ 1961 #define DECL_STATIC_FUNCTION_P(NODE) \ 1962 (DECL_LANG_SPECIFIC (NODE)->decl_flags.static_function) 1963 1964 /* Nonzero for FUNCTION_DECL means that this decl is a non-static 1965 member function. */ 1966 #define DECL_NONSTATIC_MEMBER_FUNCTION_P(NODE) \ 1967 (TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE) 1968 1969 /* Nonzero for FUNCTION_DECL means that this decl is a member function 1970 (static or non-static). */ 1971 #define DECL_FUNCTION_MEMBER_P(NODE) \ 1972 (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) || DECL_STATIC_FUNCTION_P (NODE)) 1973 1974 /* Nonzero for FUNCTION_DECL means that this member function 1975 has `this' as const X *const. */ 1976 #define DECL_CONST_MEMFUNC_P(NODE) \ 1977 (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \ 1978 && CP_TYPE_CONST_P (TREE_TYPE (TREE_VALUE \ 1979 (TYPE_ARG_TYPES (TREE_TYPE (NODE)))))) 1980 1981 /* Nonzero for FUNCTION_DECL means that this member function 1982 has `this' as volatile X *const. */ 1983 #define DECL_VOLATILE_MEMFUNC_P(NODE) \ 1984 (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \ 1985 && CP_TYPE_VOLATILE_P (TREE_TYPE (TREE_VALUE \ 1986 (TYPE_ARG_TYPES (TREE_TYPE (NODE)))))) 1987 1988 /* Nonzero for a DECL means that this member is a non-static member. */ 1989 #define DECL_NONSTATIC_MEMBER_P(NODE) \ 1990 (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \ 1991 || TREE_CODE (NODE) == FIELD_DECL) 1992 1993 /* Nonzero for _DECL means that this member object type 1994 is mutable. */ 1995 #define DECL_MUTABLE_P(NODE) (DECL_LANG_FLAG_0 (NODE)) 1996 1997 /* Nonzero for _DECL means that this constructor is a non-converting 1998 constructor. */ 1999 #define DECL_NONCONVERTING_P(NODE) \ 2000 (DECL_LANG_SPECIFIC (NODE)->decl_flags.nonconverting) 2001 2002 /* Nonzero for FUNCTION_DECL means that this member function is a pure 2003 virtual function. */ 2004 #define DECL_PURE_VIRTUAL_P(NODE) \ 2005 (DECL_LANG_SPECIFIC (NODE)->decl_flags.pure_virtual) 2006 2007 /* True (in a FUNCTION_DECL) if NODE is a virtual function that is an 2008 invalid overrider for a function from a base class. Once we have 2009 complained about an invalid overrider we avoid complaining about it 2010 again. */ 2011 #define DECL_INVALID_OVERRIDER_P(NODE) \ 2012 (DECL_LANG_FLAG_4 (NODE)) 2013 2014 /* The thunks associated with NODE, a FUNCTION_DECL. */ 2015 #define DECL_THUNKS(NODE) \ 2016 (DECL_LANG_SPECIFIC (NODE)->u.f.context) 2017 2018 /* Nonzero if NODE is a thunk, rather than an ordinary function. */ 2019 #define DECL_THUNK_P(NODE) \ 2020 (TREE_CODE (NODE) == FUNCTION_DECL \ 2021 && DECL_LANG_SPECIFIC (NODE) \ 2022 && DECL_LANG_SPECIFIC (NODE)->decl_flags.thunk_p) 2023 2024 /* Set DECL_THUNK_P for node. */ 2025 #define SET_DECL_THUNK_P(NODE, THIS_ADJUSTING) \ 2026 (DECL_LANG_SPECIFIC (NODE)->decl_flags.thunk_p = 1, \ 2027 DECL_LANG_SPECIFIC (NODE)->u.f.u3sel = 1, \ 2028 DECL_LANG_SPECIFIC (NODE)->decl_flags.this_thunk_p = (THIS_ADJUSTING)) 2029 2030 /* Nonzero if NODE is a this pointer adjusting thunk. */ 2031 #define DECL_THIS_THUNK_P(NODE) \ 2032 (DECL_THUNK_P (NODE) && DECL_LANG_SPECIFIC (NODE)->decl_flags.this_thunk_p) 2033 2034 /* Nonzero if NODE is a result pointer adjusting thunk. */ 2035 #define DECL_RESULT_THUNK_P(NODE) \ 2036 (DECL_THUNK_P (NODE) && !DECL_LANG_SPECIFIC (NODE)->decl_flags.this_thunk_p) 2037 2038 /* Nonzero if NODE is a FUNCTION_DECL, but not a thunk. */ 2039 #define DECL_NON_THUNK_FUNCTION_P(NODE) \ 2040 (TREE_CODE (NODE) == FUNCTION_DECL && !DECL_THUNK_P (NODE)) 2041 2042 /* Nonzero if NODE is `extern "C"'. */ 2043 #define DECL_EXTERN_C_P(NODE) \ 2044 (DECL_LANGUAGE (NODE) == lang_c) 2045 2046 /* Nonzero if NODE is an `extern "C"' function. */ 2047 #define DECL_EXTERN_C_FUNCTION_P(NODE) \ 2048 (DECL_NON_THUNK_FUNCTION_P (NODE) && DECL_EXTERN_C_P (NODE)) 2049 2050 /* True iff DECL is an entity with vague linkage whose definition is 2051 available in this translation unit. */ 2052 #define DECL_REPO_AVAILABLE_P(NODE) \ 2053 (DECL_LANG_SPECIFIC (NODE)->decl_flags.repo_available_p) 2054 2055 /* Nonzero if this DECL is the __PRETTY_FUNCTION__ variable in a 2056 template function. */ 2057 #define DECL_PRETTY_FUNCTION_P(NODE) \ 2058 (TREE_LANG_FLAG_0 (VAR_DECL_CHECK (NODE))) 2059 2060 /* The _TYPE context in which this _DECL appears. This field holds the 2061 class where a virtual function instance is actually defined. */ 2062 #define DECL_CLASS_CONTEXT(NODE) \ 2063 (DECL_CLASS_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : NULL_TREE) 2064 2065 /* For a non-member friend function, the class (if any) in which this 2066 friend was defined. For example, given: 2067 2068 struct S { friend void f (); }; 2069 2070 the DECL_FRIEND_CONTEXT for `f' will be `S'. */ 2071 #define DECL_FRIEND_CONTEXT(NODE) \ 2072 ((DECL_FRIEND_P (NODE) && !DECL_FUNCTION_MEMBER_P (NODE)) \ 2073 ? DECL_LANG_SPECIFIC (NODE)->u.f.context \ 2074 : NULL_TREE) 2075 2076 /* Set the DECL_FRIEND_CONTEXT for NODE to CONTEXT. */ 2077 #define SET_DECL_FRIEND_CONTEXT(NODE, CONTEXT) \ 2078 (DECL_LANG_SPECIFIC (NODE)->u.f.context = (CONTEXT)) 2079 2080 /* NULL_TREE in DECL_CONTEXT represents the global namespace. */ 2081 #define CP_DECL_CONTEXT(NODE) \ 2082 (DECL_CONTEXT (NODE) ? DECL_CONTEXT (NODE) : global_namespace) 2083 #define CP_TYPE_CONTEXT(NODE) \ 2084 (TYPE_CONTEXT (NODE) ? TYPE_CONTEXT (NODE) : global_namespace) 2085 #define FROB_CONTEXT(NODE) ((NODE) == global_namespace ? NULL_TREE : (NODE)) 2086 2087 /* 1 iff NODE has namespace scope, including the global namespace. */ 2088 #define DECL_NAMESPACE_SCOPE_P(NODE) \ 2089 (!DECL_TEMPLATE_PARM_P (NODE) \ 2090 && TREE_CODE (CP_DECL_CONTEXT (NODE)) == NAMESPACE_DECL) 2091 2092 /* 1 iff NODE is a class member. */ 2093 #define DECL_CLASS_SCOPE_P(NODE) \ 2094 (DECL_CONTEXT (NODE) && TYPE_P (DECL_CONTEXT (NODE))) 2095 2096 #define TYPE_CLASS_SCOPE_P(NODE) \ 2097 (TYPE_CONTEXT (NODE) && TYPE_P (TYPE_CONTEXT (NODE))) 2098 2099 /* 1 iff NODE is function-local. */ 2100 #define DECL_FUNCTION_SCOPE_P(NODE) \ 2101 (DECL_CONTEXT (NODE) \ 2102 && TREE_CODE (DECL_CONTEXT (NODE)) == FUNCTION_DECL) 2103 2104 /* 1 iff VAR_DECL node NODE is a type-info decl. This flag is set for 2105 both the primary typeinfo object and the associated NTBS name. */ 2106 #define DECL_TINFO_P(NODE) TREE_LANG_FLAG_4 (VAR_DECL_CHECK (NODE)) 2107 2108 /* 1 iff VAR_DECL node NODE is virtual table or VTT. */ 2109 #define DECL_VTABLE_OR_VTT_P(NODE) TREE_LANG_FLAG_5 (VAR_DECL_CHECK (NODE)) 2110 2111 /* Returns 1 iff VAR_DECL is a construction virtual table. 2112 DECL_VTABLE_OR_VTT_P will be true in this case and must be checked 2113 before using this macro. */ 2114 #define DECL_CONSTRUCTION_VTABLE_P(NODE) \ 2115 TREE_LANG_FLAG_6 (VAR_DECL_CHECK (NODE)) 2116 2117 /* 1 iff NODE is function-local, but for types. */ 2118 #define LOCAL_CLASS_P(NODE) \ 2119 (decl_function_context (TYPE_MAIN_DECL (NODE)) != NULL_TREE) 2120 2121 /* For a NAMESPACE_DECL: the list of using namespace directives 2122 The PURPOSE is the used namespace, the value is the namespace 2123 that is the common ancestor. */ 2124 #define DECL_NAMESPACE_USING(NODE) DECL_VINDEX (NAMESPACE_DECL_CHECK (NODE)) 2125 2126 /* In a NAMESPACE_DECL, the DECL_INITIAL is used to record all users 2127 of a namespace, to record the transitive closure of using namespace. */ 2128 #define DECL_NAMESPACE_USERS(NODE) DECL_INITIAL (NAMESPACE_DECL_CHECK (NODE)) 2129 2130 /* In a NAMESPACE_DECL, the list of namespaces which have associated 2131 themselves with this one. */ 2132 #define DECL_NAMESPACE_ASSOCIATIONS(NODE) \ 2133 (NAMESPACE_DECL_CHECK (NODE)->decl_non_common.saved_tree) 2134 2135 /* In a NAMESPACE_DECL, points to the original namespace if this is 2136 a namespace alias. */ 2137 #define DECL_NAMESPACE_ALIAS(NODE) \ 2138 DECL_ABSTRACT_ORIGIN (NAMESPACE_DECL_CHECK (NODE)) 2139 #define ORIGINAL_NAMESPACE(NODE) \ 2140 (DECL_NAMESPACE_ALIAS (NODE) ? DECL_NAMESPACE_ALIAS (NODE) : (NODE)) 2141 2142 /* Nonzero if NODE is the std namespace. */ 2143 #define DECL_NAMESPACE_STD_P(NODE) \ 2144 (TREE_CODE (NODE) == NAMESPACE_DECL \ 2145 && CP_DECL_CONTEXT (NODE) == global_namespace \ 2146 && DECL_NAME (NODE) == std_identifier) 2147 2148 /* In a TREE_LIST concatenating using directives, indicate indirect 2149 directives */ 2150 #define TREE_INDIRECT_USING(NODE) (TREE_LIST_CHECK (NODE)->base.lang_flag_0) 2151 2152 /* In a TREE_LIST in an attribute list, indicates that the attribute 2153 must be applied at instantiation time. */ 2154 #define ATTR_IS_DEPENDENT(NODE) (TREE_LIST_CHECK (NODE)->base.lang_flag_0) 2155 2156 extern tree decl_shadowed_for_var_lookup (tree); 2157 extern void decl_shadowed_for_var_insert (tree, tree); 2158 2159 /* Non zero if this is a using decl for a dependent scope. */ 2160 #define DECL_DEPENDENT_P(NODE) DECL_LANG_FLAG_0 (USING_DECL_CHECK (NODE)) 2161 2162 /* The scope named in a using decl. */ 2163 #define USING_DECL_SCOPE(NODE) TREE_TYPE (USING_DECL_CHECK (NODE)) 2164 2165 /* The decls named by a using decl. */ 2166 #define USING_DECL_DECLS(NODE) DECL_INITIAL (USING_DECL_CHECK (NODE)) 2167 2168 /* In a VAR_DECL, true if we have a shadowed local variable 2169 in the shadowed var table for this VAR_DECL. */ 2170 #define DECL_HAS_SHADOWED_FOR_VAR_P(NODE) \ 2171 (VAR_DECL_CHECK (NODE)->decl_with_vis.shadowed_for_var_p) 2172 2173 /* In a VAR_DECL for a variable declared in a for statement, 2174 this is the shadowed (local) variable. */ 2175 #define DECL_SHADOWED_FOR_VAR(NODE) \ 2176 (DECL_HAS_SHADOWED_FOR_VAR_P(NODE) ? decl_shadowed_for_var_lookup (NODE) : NULL) 2177 2178 #define SET_DECL_SHADOWED_FOR_VAR(NODE, VAL) \ 2179 (decl_shadowed_for_var_insert (NODE, VAL)) 2180 2181 /* In a FUNCTION_DECL, this is nonzero if this function was defined in 2182 the class definition. We have saved away the text of the function, 2183 but have not yet processed it. */ 2184 #define DECL_PENDING_INLINE_P(NODE) \ 2185 (DECL_LANG_SPECIFIC (NODE)->u.f.pending_inline_p) 2186 2187 /* If DECL_PENDING_INLINE_P holds, this is the saved text of the 2188 function. */ 2189 #define DECL_PENDING_INLINE_INFO(NODE) \ 2190 (DECL_LANG_SPECIFIC (NODE)->u.f.u.pending_inline_info) 2191 2192 /* For a TYPE_DECL: if this structure has many fields, we'll sort them 2193 and put them into a TREE_VEC. */ 2194 #define DECL_SORTED_FIELDS(NODE) \ 2195 (DECL_LANG_SPECIFIC (TYPE_DECL_CHECK (NODE))->u.f.u.sorted_fields) 2196 2197 /* True if on the deferred_fns (see decl2.c) list. */ 2198 #define DECL_DEFERRED_FN(DECL) \ 2199 (DECL_LANG_SPECIFIC (DECL)->decl_flags.deferred) 2200 2201 /* If non-NULL for a VAR_DECL, FUNCTION_DECL, TYPE_DECL or 2202 TEMPLATE_DECL, the entity is either a template specialization (if 2203 DECL_USE_TEMPLATE is nonzero) or the abstract instance of the 2204 template itself. 2205 2206 In either case, DECL_TEMPLATE_INFO is a TREE_LIST, whose 2207 TREE_PURPOSE is the TEMPLATE_DECL of which this entity is a 2208 specialization or abstract instance. The TREE_VALUE is the 2209 template arguments used to specialize the template. 2210 2211 Consider: 2212 2213 template <typename T> struct S { friend void f(T) {} }; 2214 2215 In this case, S<int>::f is, from the point of view of the compiler, 2216 an instantiation of a template -- but, from the point of view of 2217 the language, each instantiation of S results in a wholly unrelated 2218 global function f. In this case, DECL_TEMPLATE_INFO for S<int>::f 2219 will be non-NULL, but DECL_USE_TEMPLATE will be zero. */ 2220 #define DECL_TEMPLATE_INFO(NODE) \ 2221 (DECL_LANG_SPECIFIC (VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK (NODE)) \ 2222 ->decl_flags.u.template_info) 2223 2224 /* For a VAR_DECL, indicates that the variable is actually a 2225 non-static data member of anonymous union that has been promoted to 2226 variable status. */ 2227 #define DECL_ANON_UNION_VAR_P(NODE) \ 2228 (DECL_LANG_FLAG_4 (VAR_DECL_CHECK (NODE))) 2229 2230 /* Template information for a RECORD_TYPE or UNION_TYPE. */ 2231 #define CLASSTYPE_TEMPLATE_INFO(NODE) \ 2232 (LANG_TYPE_CLASS_CHECK (RECORD_OR_UNION_CHECK (NODE))->template_info) 2233 2234 /* Template information for an ENUMERAL_TYPE. Although an enumeration may 2235 not be a primary template, it may be declared within the scope of a 2236 primary template and the enumeration constants may depend on 2237 non-type template parameters. */ 2238 #define ENUM_TEMPLATE_INFO(NODE) \ 2239 (TYPE_LANG_SLOT_1 (ENUMERAL_TYPE_CHECK (NODE))) 2240 2241 /* Template information for a template template parameter. */ 2242 #define TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO(NODE) \ 2243 (LANG_TYPE_CLASS_CHECK (BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK (NODE)) \ 2244 ->template_info) 2245 2246 /* Template information for an ENUMERAL_, RECORD_, or UNION_TYPE. */ 2247 #define TYPE_TEMPLATE_INFO(NODE) \ 2248 (TREE_CODE (NODE) == ENUMERAL_TYPE \ 2249 ? ENUM_TEMPLATE_INFO (NODE) : \ 2250 (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM \ 2251 ? TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (NODE) : \ 2252 (TYPE_LANG_SPECIFIC (NODE) \ 2253 ? CLASSTYPE_TEMPLATE_INFO (NODE) \ 2254 : NULL_TREE))) 2255 2256 /* Set the template information for an ENUMERAL_, RECORD_, or 2257 UNION_TYPE to VAL. */ 2258 #define SET_TYPE_TEMPLATE_INFO(NODE, VAL) \ 2259 (TREE_CODE (NODE) == ENUMERAL_TYPE \ 2260 ? (ENUM_TEMPLATE_INFO (NODE) = (VAL)) \ 2261 : (CLASSTYPE_TEMPLATE_INFO (NODE) = (VAL))) 2262 2263 #define TI_TEMPLATE(NODE) (TREE_PURPOSE (NODE)) 2264 #define TI_ARGS(NODE) (TREE_VALUE (NODE)) 2265 #define TI_PENDING_TEMPLATE_FLAG(NODE) TREE_LANG_FLAG_1 (NODE) 2266 2267 /* We use TREE_VECs to hold template arguments. If there is only one 2268 level of template arguments, then the TREE_VEC contains the 2269 arguments directly. If there is more than one level of template 2270 arguments, then each entry in the TREE_VEC is itself a TREE_VEC, 2271 containing the template arguments for a single level. The first 2272 entry in the outer TREE_VEC is the outermost level of template 2273 parameters; the last is the innermost. 2274 2275 It is incorrect to ever form a template argument vector containing 2276 only one level of arguments, but which is a TREE_VEC containing as 2277 its only entry the TREE_VEC for that level. */ 2278 2279 /* Nonzero if the template arguments is actually a vector of vectors, 2280 rather than just a vector. */ 2281 #define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \ 2282 (NODE && TREE_VEC_LENGTH (NODE) && TREE_VEC_ELT (NODE, 0) \ 2283 && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC) 2284 2285 /* The depth of a template argument vector. When called directly by 2286 the parser, we use a TREE_LIST rather than a TREE_VEC to represent 2287 template arguments. In fact, we may even see NULL_TREE if there 2288 are no template arguments. In both of those cases, there is only 2289 one level of template arguments. */ 2290 #define TMPL_ARGS_DEPTH(NODE) \ 2291 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1) 2292 2293 /* The LEVELth level of the template ARGS. The outermost level of 2294 args is level 1, not level 0. */ 2295 #define TMPL_ARGS_LEVEL(ARGS, LEVEL) \ 2296 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS) \ 2297 ? TREE_VEC_ELT (ARGS, (LEVEL) - 1) : (ARGS)) 2298 2299 /* Set the LEVELth level of the template ARGS to VAL. This macro does 2300 not work with single-level argument vectors. */ 2301 #define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL) \ 2302 (TREE_VEC_ELT (ARGS, (LEVEL) - 1) = (VAL)) 2303 2304 /* Accesses the IDXth parameter in the LEVELth level of the ARGS. */ 2305 #define TMPL_ARG(ARGS, LEVEL, IDX) \ 2306 (TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX)) 2307 2308 /* Given a single level of template arguments in NODE, return the 2309 number of arguments. */ 2310 #define NUM_TMPL_ARGS(NODE) \ 2311 (TREE_VEC_LENGTH (NODE)) 2312 2313 /* Returns the innermost level of template arguments in ARGS. */ 2314 #define INNERMOST_TEMPLATE_ARGS(NODE) \ 2315 (get_innermost_template_args ((NODE), 1)) 2316 2317 /* The number of levels of template parameters given by NODE. */ 2318 #define TMPL_PARMS_DEPTH(NODE) \ 2319 ((HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_PURPOSE (NODE))) 2320 2321 /* The TEMPLATE_DECL instantiated or specialized by NODE. This 2322 TEMPLATE_DECL will be the immediate parent, not the most general 2323 template. For example, in: 2324 2325 template <class T> struct S { template <class U> void f(U); } 2326 2327 the FUNCTION_DECL for S<int>::f<double> will have, as its 2328 DECL_TI_TEMPLATE, `template <class U> S<int>::f<U>'. 2329 2330 As a special case, for a member friend template of a template 2331 class, this value will not be a TEMPLATE_DECL, but rather an 2332 IDENTIFIER_NODE or OVERLOAD indicating the name of the template and 2333 any explicit template arguments provided. For example, in: 2334 2335 template <class T> struct S { friend void f<int>(int, double); } 2336 2337 the DECL_TI_TEMPLATE will be an IDENTIFIER_NODE for `f' and the 2338 DECL_TI_ARGS will be {int}. */ 2339 #define DECL_TI_TEMPLATE(NODE) TI_TEMPLATE (DECL_TEMPLATE_INFO (NODE)) 2340 2341 /* The template arguments used to obtain this decl from the most 2342 general form of DECL_TI_TEMPLATE. For the example given for 2343 DECL_TI_TEMPLATE, the DECL_TI_ARGS will be {int, double}. These 2344 are always the full set of arguments required to instantiate this 2345 declaration from the most general template specialized here. */ 2346 #define DECL_TI_ARGS(NODE) TI_ARGS (DECL_TEMPLATE_INFO (NODE)) 2347 2348 /* The TEMPLATE_DECL associated with NODE, a class type. Even if NODE 2349 will be generated from a partial specialization, the TEMPLATE_DECL 2350 referred to here will be the original template. For example, 2351 given: 2352 2353 template <typename T> struct S {}; 2354 template <typename T> struct S<T*> {}; 2355 2356 the CLASSTPYE_TI_TEMPLATE for S<int*> will be S, not the S<T*>. */ 2357 #define CLASSTYPE_TI_TEMPLATE(NODE) TI_TEMPLATE (CLASSTYPE_TEMPLATE_INFO (NODE)) 2358 #define CLASSTYPE_TI_ARGS(NODE) TI_ARGS (CLASSTYPE_TEMPLATE_INFO (NODE)) 2359 2360 /* For a template instantiation TYPE, returns the TYPE corresponding 2361 to the primary template. Otherwise returns TYPE itself. */ 2362 #define CLASSTYPE_PRIMARY_TEMPLATE_TYPE(TYPE) \ 2363 ((CLASSTYPE_USE_TEMPLATE ((TYPE)) \ 2364 && !CLASSTYPE_TEMPLATE_SPECIALIZATION ((TYPE))) \ 2365 ? TREE_TYPE (DECL_TEMPLATE_RESULT (DECL_PRIMARY_TEMPLATE \ 2366 (CLASSTYPE_TI_TEMPLATE ((TYPE))))) \ 2367 : (TYPE)) 2368 2369 /* Like CLASS_TI_TEMPLATE, but also works for ENUMERAL_TYPEs. */ 2370 #define TYPE_TI_TEMPLATE(NODE) \ 2371 (TI_TEMPLATE (TYPE_TEMPLATE_INFO (NODE))) 2372 2373 /* Like DECL_TI_ARGS, but for an ENUMERAL_, RECORD_, or UNION_TYPE. */ 2374 #define TYPE_TI_ARGS(NODE) \ 2375 (TI_ARGS (TYPE_TEMPLATE_INFO (NODE))) 2376 2377 #define INNERMOST_TEMPLATE_PARMS(NODE) TREE_VALUE (NODE) 2378 2379 /* Nonzero if NODE (a TEMPLATE_DECL) is a member template, in the 2380 sense of [temp.mem]. */ 2381 #define DECL_MEMBER_TEMPLATE_P(NODE) \ 2382 (DECL_LANG_FLAG_1 (TEMPLATE_DECL_CHECK (NODE))) 2383 2384 /* Nonzero if the NODE corresponds to the template parameters for a 2385 member template, whose inline definition is being processed after 2386 the class definition is complete. */ 2387 #define TEMPLATE_PARMS_FOR_INLINE(NODE) TREE_LANG_FLAG_1 (NODE) 2388 2389 /* Determine if a parameter (i.e., a PARM_DECL) is a function 2390 parameter pack. */ 2391 #define FUNCTION_PARAMETER_PACK_P(NODE) \ 2392 (DECL_LANG_FLAG_1 (PARM_DECL_CHECK (NODE))) 2393 2394 /* Determines if NODE is an expansion of one or more parameter packs, 2395 e.g., a TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION. */ 2396 #define PACK_EXPANSION_P(NODE) \ 2397 (TREE_CODE (NODE) == TYPE_PACK_EXPANSION \ 2398 || TREE_CODE (NODE) == EXPR_PACK_EXPANSION) 2399 2400 /* Extracts the type or expression pattern from a TYPE_PACK_EXPANSION or 2401 EXPR_PACK_EXPANSION. */ 2402 #define PACK_EXPANSION_PATTERN(NODE) \ 2403 (TREE_CODE (NODE) == TYPE_PACK_EXPANSION? TREE_TYPE (NODE) \ 2404 : TREE_OPERAND (NODE, 0)) 2405 2406 /* Sets the type or expression pattern for a TYPE_PACK_EXPANSION or 2407 EXPR_PACK_EXPANSION. */ 2408 #define SET_PACK_EXPANSION_PATTERN(NODE,VALUE) \ 2409 if (TREE_CODE (NODE) == TYPE_PACK_EXPANSION) \ 2410 TREE_TYPE (NODE) = VALUE; \ 2411 else \ 2412 TREE_OPERAND (NODE, 0) = VALUE 2413 2414 /* The list of parameter packs used in the PACK_EXPANSION_* node. The 2415 TREE_VALUE of each TREE_LIST contains the parameter packs. */ 2416 #define PACK_EXPANSION_PARAMETER_PACKS(NODE) TREE_CHAIN (NODE) 2417 2418 /* Determine if this is an argument pack. */ 2419 #define ARGUMENT_PACK_P(NODE) \ 2420 (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK \ 2421 || TREE_CODE (NODE) == NONTYPE_ARGUMENT_PACK) 2422 2423 /* The arguments stored in an argument pack. Arguments are stored in a 2424 TREE_VEC, which may have length zero. */ 2425 #define ARGUMENT_PACK_ARGS(NODE) \ 2426 (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK? TREE_TYPE (NODE) \ 2427 : TREE_OPERAND (NODE, 0)) 2428 2429 /* Set the arguments stored in an argument pack. VALUE must be a 2430 TREE_VEC. */ 2431 #define SET_ARGUMENT_PACK_ARGS(NODE,VALUE) \ 2432 if (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK) \ 2433 TREE_TYPE (NODE) = VALUE; \ 2434 else \ 2435 TREE_OPERAND (NODE, 0) = VALUE 2436 2437 /* Whether the argument pack is "incomplete", meaning that more 2438 arguments can still be deduced. Incomplete argument packs are only 2439 used when the user has provided an explicit template argument list 2440 for a variadic function template. Some of the explicit template 2441 arguments will be placed into the beginning of the argument pack, 2442 but additional arguments might still be deduced. */ 2443 #define ARGUMENT_PACK_INCOMPLETE_P(NODE) \ 2444 TREE_LANG_FLAG_0 (ARGUMENT_PACK_ARGS (NODE)) 2445 2446 /* When ARGUMENT_PACK_INCOMPLETE_P, stores the explicit template 2447 arguments used to fill this pack. */ 2448 #define ARGUMENT_PACK_EXPLICIT_ARGS(NODE) \ 2449 TREE_TYPE (ARGUMENT_PACK_ARGS (NODE)) 2450 2451 /* In an ARGUMENT_PACK_SELECT, the argument pack from which an 2452 argument will be selected. */ 2453 #define ARGUMENT_PACK_SELECT_FROM_PACK(NODE) \ 2454 (((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->argument_pack) 2455 2456 /* In an ARGUMENT_PACK_SELECT, the index of the argument we want to 2457 select. */ 2458 #define ARGUMENT_PACK_SELECT_INDEX(NODE) \ 2459 (((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->index) 2460 2461 /* In an ARGUMENT_PACK_SELECT, the actual underlying argument that the 2462 ARGUMENT_PACK_SELECT represents. */ 2463 #define ARGUMENT_PACK_SELECT_ARG(NODE) \ 2464 TREE_VEC_ELT (ARGUMENT_PACK_ARGS (ARGUMENT_PACK_SELECT_FROM_PACK (NODE)), \ 2465 ARGUMENT_PACK_SELECT_INDEX (NODE)); 2466 2467 /* In a FUNCTION_DECL, the saved language-specific per-function data. */ 2468 #define DECL_SAVED_FUNCTION_DATA(NODE) \ 2469 (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (NODE)) \ 2470 ->u.f.u.saved_language_function) 2471 2472 /* Indicates an indirect_expr is for converting a reference. */ 2473 #define REFERENCE_REF_P(NODE) \ 2474 TREE_LANG_FLAG_0 (INDIRECT_REF_CHECK (NODE)) 2475 2476 #define NEW_EXPR_USE_GLOBAL(NODE) \ 2477 TREE_LANG_FLAG_0 (NEW_EXPR_CHECK (NODE)) 2478 #define DELETE_EXPR_USE_GLOBAL(NODE) \ 2479 TREE_LANG_FLAG_0 (DELETE_EXPR_CHECK (NODE)) 2480 #define DELETE_EXPR_USE_VEC(NODE) \ 2481 TREE_LANG_FLAG_1 (DELETE_EXPR_CHECK (NODE)) 2482 2483 /* Indicates that this is a non-dependent COMPOUND_EXPR which will 2484 resolve to a function call. */ 2485 #define COMPOUND_EXPR_OVERLOADED(NODE) \ 2486 TREE_LANG_FLAG_0 (COMPOUND_EXPR_CHECK (NODE)) 2487 2488 /* In a CALL_EXPR appearing in a template, true if Koenig lookup 2489 should be performed at instantiation time. */ 2490 #define KOENIG_LOOKUP_P(NODE) TREE_LANG_FLAG_0 (CALL_EXPR_CHECK (NODE)) 2491 2492 /* Indicates whether a string literal has been parenthesized. Such 2493 usages are disallowed in certain circumstances. */ 2494 2495 #define PAREN_STRING_LITERAL_P(NODE) \ 2496 TREE_LANG_FLAG_0 (STRING_CST_CHECK (NODE)) 2497 2498 /* Nonzero if this AGGR_INIT_EXPR provides for initialization via a 2499 constructor call, rather than an ordinary function call. */ 2500 #define AGGR_INIT_VIA_CTOR_P(NODE) \ 2501 TREE_LANG_FLAG_0 (AGGR_INIT_EXPR_CHECK (NODE)) 2502 2503 /* Nonzero if expanding this AGGR_INIT_EXPR should first zero-initialize 2504 the object. */ 2505 #define AGGR_INIT_ZERO_FIRST(NODE) \ 2506 TREE_LANG_FLAG_2 (AGGR_INIT_EXPR_CHECK (NODE)) 2507 2508 /* AGGR_INIT_EXPR accessors. These are equivalent to the CALL_EXPR 2509 accessors, except for AGGR_INIT_EXPR_SLOT (which takes the place of 2510 CALL_EXPR_STATIC_CHAIN). */ 2511 2512 #define AGGR_INIT_EXPR_FN(NODE) TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 1) 2513 #define AGGR_INIT_EXPR_SLOT(NODE) \ 2514 TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 2) 2515 #define AGGR_INIT_EXPR_ARG(NODE, I) \ 2516 TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), (I) + 3) 2517 #define aggr_init_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH(NODE) - 3) 2518 2519 /* AGGR_INIT_EXPR_ARGP returns a pointer to the argument vector for NODE. 2520 We can't use &AGGR_INIT_EXPR_ARG (NODE, 0) because that will complain if 2521 the argument count is zero when checking is enabled. Instead, do 2522 the pointer arithmetic to advance past the 3 fixed operands in a 2523 AGGR_INIT_EXPR. That produces a valid pointer to just past the end of 2524 the operand array, even if it's not valid to dereference it. */ 2525 #define AGGR_INIT_EXPR_ARGP(NODE) \ 2526 (&(TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 0)) + 3) 2527 2528 /* Abstract iterators for AGGR_INIT_EXPRs. */ 2529 2530 /* Structure containing iterator state. */ 2531 typedef struct aggr_init_expr_arg_iterator_d GTY (()) 2532 { 2533 tree t; /* the aggr_init_expr */ 2534 int n; /* argument count */ 2535 int i; /* next argument index */ 2536 } aggr_init_expr_arg_iterator; 2537 2538 /* Initialize the abstract argument list iterator object ITER with the 2539 arguments from AGGR_INIT_EXPR node EXP. */ 2540 static inline void 2541 init_aggr_init_expr_arg_iterator (tree exp, 2542 aggr_init_expr_arg_iterator *iter) 2543 { 2544 iter->t = exp; 2545 iter->n = aggr_init_expr_nargs (exp); 2546 iter->i = 0; 2547 } 2548 2549 /* Return the next argument from abstract argument list iterator object ITER, 2550 and advance its state. Return NULL_TREE if there are no more arguments. */ 2551 static inline tree 2552 next_aggr_init_expr_arg (aggr_init_expr_arg_iterator *iter) 2553 { 2554 tree result; 2555 if (iter->i >= iter->n) 2556 return NULL_TREE; 2557 result = AGGR_INIT_EXPR_ARG (iter->t, iter->i); 2558 iter->i++; 2559 return result; 2560 } 2561 2562 /* Initialize the abstract argument list iterator object ITER, then advance 2563 past and return the first argument. Useful in for expressions, e.g. 2564 for (arg = first_aggr_init_expr_arg (exp, &iter); arg; 2565 arg = next_aggr_init_expr_arg (&iter)) */ 2566 static inline tree 2567 first_aggr_init_expr_arg (tree exp, aggr_init_expr_arg_iterator *iter) 2568 { 2569 init_aggr_init_expr_arg_iterator (exp, iter); 2570 return next_aggr_init_expr_arg (iter); 2571 } 2572 2573 /* Test whether there are more arguments in abstract argument list iterator 2574 ITER, without changing its state. */ 2575 static inline bool 2576 more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter) 2577 { 2578 return (iter->i < iter->n); 2579 } 2580 2581 /* Iterate through each argument ARG of AGGR_INIT_EXPR CALL, using variable 2582 ITER (of type aggr_init_expr_arg_iterator) to hold the iteration state. */ 2583 #define FOR_EACH_AGGR_INIT_EXPR_ARG(arg, iter, call) \ 2584 for ((arg) = first_aggr_init_expr_arg ((call), &(iter)); (arg); \ 2585 (arg) = next_aggr_init_expr_arg (&(iter))) 2586 2587 /* The TYPE_MAIN_DECL for a class template type is a TYPE_DECL, not a 2588 TEMPLATE_DECL. This macro determines whether or not a given class 2589 type is really a template type, as opposed to an instantiation or 2590 specialization of one. */ 2591 #define CLASSTYPE_IS_TEMPLATE(NODE) \ 2592 (CLASSTYPE_TEMPLATE_INFO (NODE) \ 2593 && !CLASSTYPE_USE_TEMPLATE (NODE) \ 2594 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))) 2595 2596 /* The name used by the user to name the typename type. Typically, 2597 this is an IDENTIFIER_NODE, and the same as the DECL_NAME on the 2598 corresponding TYPE_DECL. However, this may also be a 2599 TEMPLATE_ID_EXPR if we had something like `typename X::Y<T>'. */ 2600 #define TYPENAME_TYPE_FULLNAME(NODE) (TYPENAME_TYPE_CHECK (NODE))->type.values 2601 2602 /* True if a TYPENAME_TYPE was declared as an "enum". */ 2603 #define TYPENAME_IS_ENUM_P(NODE) \ 2604 (TREE_LANG_FLAG_0 (TYPENAME_TYPE_CHECK (NODE))) 2605 2606 /* True if a TYPENAME_TYPE was declared as a "class", "struct", or 2607 "union". */ 2608 #define TYPENAME_IS_CLASS_P(NODE) \ 2609 (TREE_LANG_FLAG_1 (TYPENAME_TYPE_CHECK (NODE))) 2610 2611 /* True if a TYPENAME_TYPE is in the process of being resolved. */ 2612 #define TYPENAME_IS_RESOLVING_P(NODE) \ 2613 (TREE_LANG_FLAG_2 (TYPENAME_TYPE_CHECK (NODE))) 2614 2615 /* Nonzero in INTEGER_CST means that this int is negative by dint of 2616 using a twos-complement negated operand. */ 2617 #define TREE_NEGATED_INT(NODE) TREE_LANG_FLAG_0 (INTEGER_CST_CHECK (NODE)) 2618 2619 /* [class.virtual] 2620 2621 A class that declares or inherits a virtual function is called a 2622 polymorphic class. */ 2623 #define TYPE_POLYMORPHIC_P(NODE) (TREE_LANG_FLAG_2 (NODE)) 2624 2625 /* Nonzero if this class has a virtual function table pointer. */ 2626 #define TYPE_CONTAINS_VPTR_P(NODE) \ 2627 (TYPE_POLYMORPHIC_P (NODE) || CLASSTYPE_VBASECLASSES (NODE)) 2628 2629 /* This flag is true of a local VAR_DECL if it was declared in a for 2630 statement, but we are no longer in the scope of the for. */ 2631 #define DECL_DEAD_FOR_LOCAL(NODE) DECL_LANG_FLAG_7 (VAR_DECL_CHECK (NODE)) 2632 2633 /* This flag is set on a VAR_DECL that is a DECL_DEAD_FOR_LOCAL 2634 if we already emitted a warning about using it. */ 2635 #define DECL_ERROR_REPORTED(NODE) DECL_LANG_FLAG_0 (VAR_DECL_CHECK (NODE)) 2636 2637 /* Nonzero if NODE is a FUNCTION_DECL (for a function with global 2638 scope) declared in a local scope. */ 2639 #define DECL_LOCAL_FUNCTION_P(NODE) \ 2640 DECL_LANG_FLAG_0 (FUNCTION_DECL_CHECK (NODE)) 2641 2642 /* Nonzero if NODE is a DECL which we know about but which has not 2643 been explicitly declared, such as a built-in function or a friend 2644 declared inside a class. In the latter case DECL_HIDDEN_FRIEND_P 2645 will be set. */ 2646 #define DECL_ANTICIPATED(NODE) \ 2647 (DECL_LANG_SPECIFIC (DECL_COMMON_CHECK (NODE))->decl_flags.anticipated_p) 2648 2649 /* Nonzero if NODE is a FUNCTION_DECL which was declared as a friend 2650 within a class but has not been declared in the surrounding scope. 2651 The function is invisible except via argument dependent lookup. */ 2652 #define DECL_HIDDEN_FRIEND_P(NODE) \ 2653 (DECL_LANG_SPECIFIC (DECL_COMMON_CHECK (NODE))->decl_flags.hidden_friend_p) 2654 2655 /* Nonzero if DECL has been declared threadprivate by 2656 #pragma omp threadprivate. */ 2657 #define CP_DECL_THREADPRIVATE_P(DECL) \ 2658 (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (DECL))->decl_flags.threadprivate_or_deleted_p) 2659 2660 /* Nonzero if DECL was declared with '= delete'. */ 2661 #define DECL_DELETED_FN(DECL) \ 2662 (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->decl_flags.threadprivate_or_deleted_p) 2663 2664 /* Nonzero if DECL was declared with '= default'. */ 2665 #define DECL_DEFAULTED_FN(DECL) \ 2666 (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->decl_flags.defaulted_p) 2667 2668 /* Record whether a typedef for type `int' was actually `signed int'. */ 2669 #define C_TYPEDEF_EXPLICITLY_SIGNED(EXP) DECL_LANG_FLAG_1 (EXP) 2670 2671 /* Returns nonzero if DECL has external linkage, as specified by the 2672 language standard. (This predicate may hold even when the 2673 corresponding entity is not actually given external linkage in the 2674 object file; see decl_linkage for details.) */ 2675 #define DECL_EXTERNAL_LINKAGE_P(DECL) \ 2676 (decl_linkage (DECL) == lk_external) 2677 2678 /* Keep these codes in ascending code order. */ 2679 2680 #define INTEGRAL_CODE_P(CODE) \ 2681 ((CODE) == ENUMERAL_TYPE \ 2682 || (CODE) == BOOLEAN_TYPE \ 2683 || (CODE) == INTEGER_TYPE) 2684 2685 /* [basic.fundamental] 2686 2687 Types bool, char, wchar_t, and the signed and unsigned integer types 2688 are collectively called integral types. 2689 2690 Note that INTEGRAL_TYPE_P, as defined in tree.h, allows enumeration 2691 types as well, which is incorrect in C++. Keep these checks in 2692 ascending code order. */ 2693 #define CP_INTEGRAL_TYPE_P(TYPE) \ 2694 (TREE_CODE (TYPE) == BOOLEAN_TYPE \ 2695 || TREE_CODE (TYPE) == INTEGER_TYPE) 2696 2697 /* Returns true if TYPE is an integral or enumeration name. Keep 2698 these checks in ascending code order. */ 2699 #define INTEGRAL_OR_ENUMERATION_TYPE_P(TYPE) \ 2700 (TREE_CODE (TYPE) == ENUMERAL_TYPE || CP_INTEGRAL_TYPE_P (TYPE)) 2701 2702 /* Returns true if TYPE is an integral or unscoped enumeration type. */ 2703 #define INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P(TYPE) \ 2704 (UNSCOPED_ENUM_P (TYPE) || CP_INTEGRAL_TYPE_P (TYPE)) 2705 2706 /* [basic.fundamental] 2707 2708 Integral and floating types are collectively called arithmetic 2709 types. 2710 2711 As a GNU extension, we also accept complex types. 2712 2713 Keep these checks in ascending code order. */ 2714 #define ARITHMETIC_TYPE_P(TYPE) \ 2715 (CP_INTEGRAL_TYPE_P (TYPE) \ 2716 || TREE_CODE (TYPE) == REAL_TYPE \ 2717 || TREE_CODE (TYPE) == COMPLEX_TYPE) 2718 2719 /* [basic.types] 2720 2721 Arithmetic types, enumeration types, pointer types, and 2722 pointer-to-member types, are collectively called scalar types. 2723 2724 Keep these checks in ascending code order. */ 2725 #define SCALAR_TYPE_P(TYPE) \ 2726 (TYPE_PTRMEM_P (TYPE) \ 2727 || TREE_CODE (TYPE) == ENUMERAL_TYPE \ 2728 || ARITHMETIC_TYPE_P (TYPE) \ 2729 || TYPE_PTR_P (TYPE) \ 2730 || TYPE_PTRMEMFUNC_P (TYPE)) 2731 2732 /* Determines whether this type is a C++0x scoped enumeration 2733 type. Scoped enumerations types are introduced via "enum class" or 2734 "enum struct", e.g., 2735 2736 enum class Color { 2737 Red, Green, Blue 2738 }; 2739 2740 Scoped enumeration types are different from normal (unscoped) 2741 enumeration types in several ways: 2742 2743 - The enumerators of a scoped enumeration type are only available 2744 within the scope of the enumeration type and not in the 2745 enclosing scope. For example, the Red color can be referred to 2746 with "Color::Red" but not "Red". 2747 2748 - Scoped enumerators and enumerations do not implicitly convert 2749 to integers or 'bool'. 2750 2751 - The underlying type of the enum is well-defined. */ 2752 #define SCOPED_ENUM_P(TYPE) \ 2753 (TREE_CODE (TYPE) == ENUMERAL_TYPE && TYPE_LANG_FLAG_5 (TYPE)) 2754 2755 /* Determine whether this is an unscoped enumeration type. */ 2756 #define UNSCOPED_ENUM_P(TYPE) \ 2757 (TREE_CODE (TYPE) == ENUMERAL_TYPE && !TYPE_LANG_FLAG_5 (TYPE)) 2758 2759 /* Set the flag indicating whether an ENUMERAL_TYPE is a C++0x scoped 2760 enumeration type (1) or a normal (unscoped) enumeration type 2761 (0). */ 2762 #define SET_SCOPED_ENUM_P(TYPE, VAL) \ 2763 (TYPE_LANG_FLAG_5 (ENUMERAL_TYPE_CHECK (TYPE)) = (VAL)) 2764 2765 /* Returns the underlying type of the given enumeration type. The 2766 underlying type is determined in different ways, depending on the 2767 properties of the enum: 2768 2769 - In C++0x, the underlying type can be explicitly specified, e.g., 2770 2771 enum E1 : char { ... } // underlying type is char 2772 2773 - In a C++0x scoped enumeration, the underlying type is int 2774 unless otherwises specified: 2775 2776 enum class E2 { ... } // underlying type is int 2777 2778 - Otherwise, the underlying type is determined based on the 2779 values of the enumerators. In this case, the 2780 ENUM_UNDERLYING_TYPE will not be set until after the definition 2781 of the enumeration is completed by finish_enum. */ 2782 #define ENUM_UNDERLYING_TYPE(TYPE) \ 2783 TREE_TYPE (ENUMERAL_TYPE_CHECK (TYPE)) 2784 2785 /* [dcl.init.aggr] 2786 2787 An aggregate is an array or a class with no user-declared 2788 constructors, no private or protected non-static data members, no 2789 base classes, and no virtual functions. 2790 2791 As an extension, we also treat vectors as aggregates. Keep these 2792 checks in ascending code order. */ 2793 #define CP_AGGREGATE_TYPE_P(TYPE) \ 2794 (TREE_CODE (TYPE) == VECTOR_TYPE \ 2795 ||TREE_CODE (TYPE) == ARRAY_TYPE \ 2796 || (CLASS_TYPE_P (TYPE) && !CLASSTYPE_NON_AGGREGATE (TYPE))) 2797 2798 /* Nonzero for a class type means that the class type has a 2799 user-declared constructor. */ 2800 #define TYPE_HAS_USER_CONSTRUCTOR(NODE) (TYPE_LANG_FLAG_1 (NODE)) 2801 2802 /* When appearing in an INDIRECT_REF, it means that the tree structure 2803 underneath is actually a call to a constructor. This is needed 2804 when the constructor must initialize local storage (which can 2805 be automatically destroyed), rather than allowing it to allocate 2806 space from the heap. 2807 2808 When appearing in a SAVE_EXPR, it means that underneath 2809 is a call to a constructor. 2810 2811 When appearing in a CONSTRUCTOR, the expression is a 2812 compound literal. 2813 2814 When appearing in a FIELD_DECL, it means that this field 2815 has been duly initialized in its constructor. */ 2816 #define TREE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_4 (NODE)) 2817 2818 /* True if NODE is a brace-enclosed initializer. */ 2819 #define BRACE_ENCLOSED_INITIALIZER_P(NODE) \ 2820 (TREE_CODE (NODE) == CONSTRUCTOR && TREE_TYPE (NODE) == init_list_type_node) 2821 2822 /* True if NODE is a compound-literal, i.e., a brace-enclosed 2823 initializer cast to a particular type. */ 2824 #define COMPOUND_LITERAL_P(NODE) \ 2825 (TREE_CODE (NODE) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (NODE)) 2826 2827 #define EMPTY_CONSTRUCTOR_P(NODE) (TREE_CODE (NODE) == CONSTRUCTOR \ 2828 && VEC_empty (constructor_elt, \ 2829 CONSTRUCTOR_ELTS (NODE)) \ 2830 && !TREE_HAS_CONSTRUCTOR (NODE)) 2831 2832 /* True if NODE is a init-list used as a direct-initializer, i.e. 2833 B b{1,2}, not B b({1,2}) or B b = {1,2}. */ 2834 #define CONSTRUCTOR_IS_DIRECT_INIT(NODE) (TREE_LANG_FLAG_0 (CONSTRUCTOR_CHECK (NODE))) 2835 2836 /* Nonzero means that an object of this type can not be initialized using 2837 an initializer list. */ 2838 #define CLASSTYPE_NON_AGGREGATE(NODE) \ 2839 (LANG_TYPE_CLASS_CHECK (NODE)->non_aggregate) 2840 #define TYPE_NON_AGGREGATE_CLASS(NODE) \ 2841 (CLASS_TYPE_P (NODE) && CLASSTYPE_NON_AGGREGATE (NODE)) 2842 2843 /* Nonzero if there is a user-defined X::op=(x&) for this class. */ 2844 #define TYPE_HAS_COMPLEX_ASSIGN_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_assign_ref) 2845 2846 /* Nonzero if there is a user-defined X::X(x&) for this class. */ 2847 #define TYPE_HAS_COMPLEX_INIT_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_init_ref) 2848 2849 /* Nonzero if there is a user-defined default constructor for this class. */ 2850 #define TYPE_HAS_COMPLEX_DFLT(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_dflt) 2851 2852 /* Nonzero if TYPE has a trivial destructor. From [class.dtor]: 2853 2854 A destructor is trivial if it is an implicitly declared 2855 destructor and if: 2856 2857 - all of the direct base classes of its class have trivial 2858 destructors, 2859 2860 - for all of the non-static data members of its class that are 2861 of class type (or array thereof), each such class has a 2862 trivial destructor. */ 2863 #define TYPE_HAS_TRIVIAL_DESTRUCTOR(NODE) \ 2864 (!TYPE_HAS_NONTRIVIAL_DESTRUCTOR (NODE)) 2865 2866 /* Nonzero for _TYPE node means that this type does not have a trivial 2867 destructor. Therefore, destroying an object of this type will 2868 involve a call to a destructor. This can apply to objects of 2869 ARRAY_TYPE is the type of the elements needs a destructor. */ 2870 #define TYPE_HAS_NONTRIVIAL_DESTRUCTOR(NODE) \ 2871 (TYPE_LANG_FLAG_4 (NODE)) 2872 2873 /* Nonzero for class type means that the default constructor is trivial. */ 2874 #define TYPE_HAS_TRIVIAL_DFLT(NODE) \ 2875 (TYPE_HAS_DEFAULT_CONSTRUCTOR (NODE) && ! TYPE_HAS_COMPLEX_DFLT (NODE)) 2876 2877 /* Nonzero for class type means that copy initialization of this type can use 2878 a bitwise copy. */ 2879 #define TYPE_HAS_TRIVIAL_INIT_REF(NODE) \ 2880 (TYPE_HAS_INIT_REF (NODE) && ! TYPE_HAS_COMPLEX_INIT_REF (NODE)) 2881 2882 /* Nonzero for class type means that assignment of this type can use 2883 a bitwise copy. */ 2884 #define TYPE_HAS_TRIVIAL_ASSIGN_REF(NODE) \ 2885 (TYPE_HAS_ASSIGN_REF (NODE) && ! TYPE_HAS_COMPLEX_ASSIGN_REF (NODE)) 2886 2887 /* Returns true if NODE is a pointer-to-data-member. */ 2888 #define TYPE_PTRMEM_P(NODE) \ 2889 (TREE_CODE (NODE) == OFFSET_TYPE) 2890 /* Returns true if NODE is a pointer. */ 2891 #define TYPE_PTR_P(NODE) \ 2892 (TREE_CODE (NODE) == POINTER_TYPE) 2893 2894 /* Returns true if NODE is an object type: 2895 2896 [basic.types] 2897 2898 An object type is a (possibly cv-qualified) type that is not a 2899 function type, not a reference type, and not a void type. 2900 2901 Keep these checks in ascending order, for speed. */ 2902 #define TYPE_OBJ_P(NODE) \ 2903 (TREE_CODE (NODE) != REFERENCE_TYPE \ 2904 && TREE_CODE (NODE) != VOID_TYPE \ 2905 && TREE_CODE (NODE) != FUNCTION_TYPE \ 2906 && TREE_CODE (NODE) != METHOD_TYPE) 2907 2908 /* Returns true if NODE is a pointer to an object. Keep these checks 2909 in ascending tree code order. */ 2910 #define TYPE_PTROB_P(NODE) \ 2911 (TYPE_PTR_P (NODE) && TYPE_OBJ_P (TREE_TYPE (NODE))) 2912 2913 /* Returns true if NODE is a reference to an object. Keep these checks 2914 in ascending tree code order. */ 2915 #define TYPE_REF_OBJ_P(NODE) \ 2916 (TREE_CODE (NODE) == REFERENCE_TYPE && TYPE_OBJ_P (TREE_TYPE (NODE))) 2917 2918 /* True if reference type NODE is an rvalue reference */ 2919 #define TYPE_REF_IS_RVALUE(NODE) \ 2920 TREE_LANG_FLAG_0 (REFERENCE_TYPE_CHECK (NODE)) 2921 2922 /* Returns true if NODE is a pointer to an object, or a pointer to 2923 void. Keep these checks in ascending tree code order. */ 2924 #define TYPE_PTROBV_P(NODE) \ 2925 (TYPE_PTR_P (NODE) \ 2926 && !(TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE \ 2927 || TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE)) 2928 2929 /* Returns true if NODE is a pointer to function. */ 2930 #define TYPE_PTRFN_P(NODE) \ 2931 (TREE_CODE (NODE) == POINTER_TYPE \ 2932 && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE) 2933 2934 /* Returns true if NODE is a reference to function. */ 2935 #define TYPE_REFFN_P(NODE) \ 2936 (TREE_CODE (NODE) == REFERENCE_TYPE \ 2937 && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE) 2938 2939 /* Nonzero for _TYPE node means that this type is a pointer to member 2940 function type. */ 2941 #define TYPE_PTRMEMFUNC_P(NODE) \ 2942 (TREE_CODE (NODE) == RECORD_TYPE \ 2943 && TYPE_LANG_SPECIFIC (NODE) \ 2944 && TYPE_PTRMEMFUNC_FLAG (NODE)) 2945 2946 #define TYPE_PTRMEMFUNC_FLAG(NODE) \ 2947 (LANG_TYPE_CLASS_CHECK (NODE)->ptrmemfunc_flag) 2948 2949 /* Returns true if NODE is a pointer-to-member. */ 2950 #define TYPE_PTR_TO_MEMBER_P(NODE) \ 2951 (TYPE_PTRMEM_P (NODE) || TYPE_PTRMEMFUNC_P (NODE)) 2952 2953 /* Indicates when overload resolution may resolve to a pointer to 2954 member function. [expr.unary.op]/3 */ 2955 #define PTRMEM_OK_P(NODE) \ 2956 TREE_LANG_FLAG_0 (TREE_CHECK2 ((NODE), ADDR_EXPR, OFFSET_REF)) 2957 2958 /* Get the POINTER_TYPE to the METHOD_TYPE associated with this 2959 pointer to member function. TYPE_PTRMEMFUNC_P _must_ be true, 2960 before using this macro. */ 2961 #define TYPE_PTRMEMFUNC_FN_TYPE(NODE) \ 2962 (TREE_TYPE (TYPE_FIELDS (NODE))) 2963 2964 /* Returns `A' for a type like `int (A::*)(double)' */ 2965 #define TYPE_PTRMEMFUNC_OBJECT_TYPE(NODE) \ 2966 TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE))) 2967 2968 /* These are use to manipulate the canonical RECORD_TYPE from the 2969 hashed POINTER_TYPE, and can only be used on the POINTER_TYPE. */ 2970 #define TYPE_GET_PTRMEMFUNC_TYPE(NODE) \ 2971 (TYPE_LANG_SPECIFIC (NODE) ? LANG_TYPE_PTRMEM_CHECK (NODE)->record : NULL) 2972 #define TYPE_SET_PTRMEMFUNC_TYPE(NODE, VALUE) \ 2973 do { \ 2974 if (TYPE_LANG_SPECIFIC (NODE) == NULL) \ 2975 { \ 2976 TYPE_LANG_SPECIFIC (NODE) = GGC_CNEWVAR \ 2977 (struct lang_type, sizeof (struct lang_type_ptrmem)); \ 2978 TYPE_LANG_SPECIFIC (NODE)->u.ptrmem.h.is_lang_type_class = 0; \ 2979 } \ 2980 TYPE_LANG_SPECIFIC (NODE)->u.ptrmem.record = (VALUE); \ 2981 } while (0) 2982 2983 /* For a pointer-to-member type of the form `T X::*', this is `X'. 2984 For a type like `void (X::*)() const', this type is `X', not `const 2985 X'. To get at the `const X' you have to look at the 2986 TYPE_PTRMEM_POINTED_TO_TYPE; there, the first parameter will have 2987 type `const X*'. */ 2988 #define TYPE_PTRMEM_CLASS_TYPE(NODE) \ 2989 (TYPE_PTRMEM_P (NODE) \ 2990 ? TYPE_OFFSET_BASETYPE (NODE) \ 2991 : TYPE_PTRMEMFUNC_OBJECT_TYPE (NODE)) 2992 2993 /* For a pointer-to-member type of the form `T X::*', this is `T'. */ 2994 #define TYPE_PTRMEM_POINTED_TO_TYPE(NODE) \ 2995 (TYPE_PTRMEM_P (NODE) \ 2996 ? TREE_TYPE (NODE) \ 2997 : TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE))) 2998 2999 /* For a pointer-to-member constant `X::Y' this is the RECORD_TYPE for 3000 `X'. */ 3001 #define PTRMEM_CST_CLASS(NODE) \ 3002 TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (PTRMEM_CST_CHECK (NODE))) 3003 3004 /* For a pointer-to-member constant `X::Y' this is the _DECL for 3005 `Y'. */ 3006 #define PTRMEM_CST_MEMBER(NODE) (((ptrmem_cst_t)PTRMEM_CST_CHECK (NODE))->member) 3007 3008 /* The expression in question for a TYPEOF_TYPE. */ 3009 #define TYPEOF_TYPE_EXPR(NODE) (TYPEOF_TYPE_CHECK (NODE))->type.values 3010 3011 /* The expression in question for a DECLTYPE_TYPE. */ 3012 #define DECLTYPE_TYPE_EXPR(NODE) (DECLTYPE_TYPE_CHECK (NODE))->type.values 3013 3014 /* Whether the DECLTYPE_TYPE_EXPR of NODE was originally parsed as an 3015 id-expression or a member-access expression. When false, it was 3016 parsed as a full expression. */ 3017 #define DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P(NODE) \ 3018 (DECLTYPE_TYPE_CHECK (NODE))->type.string_flag 3019 3020 /* Nonzero for VAR_DECL and FUNCTION_DECL node means that `extern' was 3021 specified in its declaration. This can also be set for an 3022 erroneously declared PARM_DECL. */ 3023 #define DECL_THIS_EXTERN(NODE) \ 3024 DECL_LANG_FLAG_2 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE)) 3025 3026 /* Nonzero for VAR_DECL and FUNCTION_DECL node means that `static' was 3027 specified in its declaration. This can also be set for an 3028 erroneously declared PARM_DECL. */ 3029 #define DECL_THIS_STATIC(NODE) \ 3030 DECL_LANG_FLAG_6 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE)) 3031 3032 /* Nonzero for FIELD_DECL node means that this field is a base class 3033 of the parent object, as opposed to a member field. */ 3034 #define DECL_FIELD_IS_BASE(NODE) \ 3035 DECL_LANG_FLAG_6 (FIELD_DECL_CHECK (NODE)) 3036 3037 /* Nonzero if TYPE is an anonymous union or struct type. We have to use a 3038 flag for this because "A union for which objects or pointers are 3039 declared is not an anonymous union" [class.union]. */ 3040 #define ANON_AGGR_TYPE_P(NODE) \ 3041 (CLASS_TYPE_P (NODE) && LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr) 3042 #define SET_ANON_AGGR_TYPE_P(NODE) \ 3043 (LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr = 1) 3044 3045 /* Nonzero if TYPE is an anonymous union type. */ 3046 #define ANON_UNION_TYPE_P(NODE) \ 3047 (TREE_CODE (NODE) == UNION_TYPE && ANON_AGGR_TYPE_P (NODE)) 3048 3049 #define UNKNOWN_TYPE LANG_TYPE 3050 3051 /* Define fields and accessors for nodes representing declared names. */ 3052 3053 #define TYPE_WAS_ANONYMOUS(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->was_anonymous) 3054 3055 /* C++: all of these are overloaded! These apply only to TYPE_DECLs. */ 3056 3057 /* The format of each node in the DECL_FRIENDLIST is as follows: 3058 3059 The TREE_PURPOSE will be the name of a function, i.e., an 3060 IDENTIFIER_NODE. The TREE_VALUE will be itself a TREE_LIST, whose 3061 TREE_VALUEs are friends with the given name. */ 3062 #define DECL_FRIENDLIST(NODE) (DECL_INITIAL (NODE)) 3063 #define FRIEND_NAME(LIST) (TREE_PURPOSE (LIST)) 3064 #define FRIEND_DECLS(LIST) (TREE_VALUE (LIST)) 3065 3066 /* The DECL_ACCESS, if non-NULL, is a TREE_LIST. The TREE_PURPOSE of 3067 each node is a type; the TREE_VALUE is the access granted for this 3068 DECL in that type. The DECL_ACCESS is set by access declarations. 3069 For example, if a member that would normally be public in a 3070 derived class is made protected, then the derived class and the 3071 protected_access_node will appear in the DECL_ACCESS for the node. */ 3072 #define DECL_ACCESS(NODE) (LANG_DECL_U2_CHECK (NODE, 0)->access) 3073 3074 /* Nonzero if the FUNCTION_DECL is a global constructor. */ 3075 #define DECL_GLOBAL_CTOR_P(NODE) \ 3076 (DECL_LANG_SPECIFIC (NODE)->decl_flags.global_ctor_p) 3077 3078 /* Nonzero if the FUNCTION_DECL is a global destructor. */ 3079 #define DECL_GLOBAL_DTOR_P(NODE) \ 3080 (DECL_LANG_SPECIFIC (NODE)->decl_flags.global_dtor_p) 3081 3082 /* Accessor macros for C++ template decl nodes. */ 3083 3084 /* The DECL_TEMPLATE_PARMS are a list. The TREE_PURPOSE of each node 3085 is a INT_CST whose TREE_INT_CST_LOW indicates the level of the 3086 template parameters, with 1 being the outermost set of template 3087 parameters. The TREE_VALUE is a vector, whose elements are the 3088 template parameters at each level. Each element in the vector is a 3089 TREE_LIST, whose TREE_VALUE is a PARM_DECL (if the parameter is a 3090 non-type parameter), or a TYPE_DECL (if the parameter is a type 3091 parameter). The TREE_PURPOSE is the default value, if any. The 3092 TEMPLATE_PARM_INDEX for the parameter is available as the 3093 DECL_INITIAL (for a PARM_DECL) or as the TREE_TYPE (for a 3094 TYPE_DECL). */ 3095 #define DECL_TEMPLATE_PARMS(NODE) DECL_NON_COMMON_CHECK (NODE)->decl_non_common.arguments 3096 #define DECL_INNERMOST_TEMPLATE_PARMS(NODE) \ 3097 INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (NODE)) 3098 #define DECL_NTPARMS(NODE) \ 3099 TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (NODE)) 3100 /* For function, method, class-data templates. */ 3101 #define DECL_TEMPLATE_RESULT(NODE) DECL_RESULT_FLD (NODE) 3102 /* For a static member variable template, the 3103 DECL_TEMPLATE_INSTANTIATIONS list contains the explicitly and 3104 implicitly generated instantiations of the variable. There are no 3105 partial instantiations of static member variables, so all of these 3106 will be full instantiations. 3107 3108 For a class template the DECL_TEMPLATE_INSTANTIATIONS lists holds 3109 all instantiations and specializations of the class type, including 3110 partial instantiations and partial specializations. 3111 3112 In both cases, the TREE_PURPOSE of each node contains the arguments 3113 used; the TREE_VALUE contains the generated variable. The template 3114 arguments are always complete. For example, given: 3115 3116 template <class T> struct S1 { 3117 template <class U> struct S2 {}; 3118 template <class U> struct S2<U*> {}; 3119 }; 3120 3121 the record for the partial specialization will contain, as its 3122 argument list, { {T}, {U*} }, and will be on the 3123 DECL_TEMPLATE_INSTANTIATIONS list for `template <class T> template 3124 <class U> struct S1<T>::S2'. 3125 3126 This list is not used for function templates. */ 3127 #define DECL_TEMPLATE_INSTANTIATIONS(NODE) DECL_VINDEX (NODE) 3128 /* For a function template, the DECL_TEMPLATE_SPECIALIZATIONS lists 3129 contains all instantiations and specializations of the function, 3130 including partial instantiations. For a partial instantiation 3131 which is a specialization, this list holds only full 3132 specializations of the template that are instantiations of the 3133 partial instantiation. For example, given: 3134 3135 template <class T> struct S { 3136 template <class U> void f(U); 3137 template <> void f(T); 3138 }; 3139 3140 the `S<int>::f<int>(int)' function will appear on the 3141 DECL_TEMPLATE_SPECIALIZATIONS list for both `template <class T> 3142 template <class U> void S<T>::f(U)' and `template <class T> void 3143 S<int>::f(T)'. In the latter case, however, it will have only the 3144 innermost set of arguments (T, in this case). The DECL_TI_TEMPLATE 3145 for the function declaration will point at the specialization, not 3146 the fully general template. 3147 3148 For a class template, this list contains the partial 3149 specializations of this template. (Full specializations are not 3150 recorded on this list.) The TREE_PURPOSE holds the arguments used 3151 in the partial specialization (e.g., for `template <class T> struct 3152 S<T*, int>' this will be `T*'.) The arguments will also include 3153 any outer template arguments. The TREE_VALUE holds the innermost 3154 template parameters for the specialization (e.g., `T' in the 3155 example above.) The TREE_TYPE is the _TYPE node for the partial 3156 specialization. 3157 3158 This list is not used for static variable templates. */ 3159 #define DECL_TEMPLATE_SPECIALIZATIONS(NODE) DECL_SIZE (NODE) 3160 3161 /* Nonzero for a DECL which is actually a template parameter. Keep 3162 these checks in ascending tree code order. */ 3163 #define DECL_TEMPLATE_PARM_P(NODE) \ 3164 (DECL_LANG_FLAG_0 (NODE) \ 3165 && (TREE_CODE (NODE) == CONST_DECL \ 3166 || TREE_CODE (NODE) == PARM_DECL \ 3167 || TREE_CODE (NODE) == TYPE_DECL \ 3168 || TREE_CODE (NODE) == TEMPLATE_DECL)) 3169 3170 /* Mark NODE as a template parameter. */ 3171 #define SET_DECL_TEMPLATE_PARM_P(NODE) \ 3172 (DECL_LANG_FLAG_0 (NODE) = 1) 3173 3174 /* Nonzero if NODE is a template template parameter. */ 3175 #define DECL_TEMPLATE_TEMPLATE_PARM_P(NODE) \ 3176 (TREE_CODE (NODE) == TEMPLATE_DECL && DECL_TEMPLATE_PARM_P (NODE)) 3177 3178 /* Nonzero if NODE is a TEMPLATE_DECL representing an 3179 UNBOUND_CLASS_TEMPLATE tree node. */ 3180 #define DECL_UNBOUND_CLASS_TEMPLATE_P(NODE) \ 3181 (TREE_CODE (NODE) == TEMPLATE_DECL && !DECL_TEMPLATE_RESULT (NODE)) 3182 3183 #define DECL_FUNCTION_TEMPLATE_P(NODE) \ 3184 (TREE_CODE (NODE) == TEMPLATE_DECL \ 3185 && !DECL_UNBOUND_CLASS_TEMPLATE_P (NODE) \ 3186 && TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == FUNCTION_DECL) 3187 3188 /* Nonzero for a DECL that represents a template class. */ 3189 #define DECL_CLASS_TEMPLATE_P(NODE) \ 3190 (TREE_CODE (NODE) == TEMPLATE_DECL \ 3191 && !DECL_UNBOUND_CLASS_TEMPLATE_P (NODE) \ 3192 && TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == TYPE_DECL \ 3193 && !DECL_TEMPLATE_TEMPLATE_PARM_P (NODE)) 3194 3195 /* Nonzero if NODE which declares a type. */ 3196 #define DECL_DECLARES_TYPE_P(NODE) \ 3197 (TREE_CODE (NODE) == TYPE_DECL || DECL_CLASS_TEMPLATE_P (NODE)) 3198 3199 /* Nonzero if NODE is the typedef implicitly generated for a type when 3200 the type is declared. In C++, `struct S {};' is roughly 3201 equivalent to `struct S {}; typedef struct S S;' in C. 3202 DECL_IMPLICIT_TYPEDEF_P will hold for the typedef indicated in this 3203 example. In C++, there is a second implicit typedef for each 3204 class, in the scope of `S' itself, so that you can say `S::S'. 3205 DECL_SELF_REFERENCE_P will hold for that second typedef. */ 3206 #define DECL_IMPLICIT_TYPEDEF_P(NODE) \ 3207 (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_2 (NODE)) 3208 #define SET_DECL_IMPLICIT_TYPEDEF_P(NODE) \ 3209 (DECL_LANG_FLAG_2 (NODE) = 1) 3210 #define DECL_SELF_REFERENCE_P(NODE) \ 3211 (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_4 (NODE)) 3212 #define SET_DECL_SELF_REFERENCE_P(NODE) \ 3213 (DECL_LANG_FLAG_4 (NODE) = 1) 3214 3215 /* A `primary' template is one that has its own template header. A 3216 member function of a class template is a template, but not primary. 3217 A member template is primary. Friend templates are primary, too. */ 3218 3219 /* Returns the primary template corresponding to these parameters. */ 3220 #define DECL_PRIMARY_TEMPLATE(NODE) \ 3221 (TREE_TYPE (DECL_INNERMOST_TEMPLATE_PARMS (NODE))) 3222 3223 /* Returns nonzero if NODE is a primary template. */ 3224 #define PRIMARY_TEMPLATE_P(NODE) (DECL_PRIMARY_TEMPLATE (NODE) == (NODE)) 3225 3226 /* Nonzero iff NODE is a specialization of a template. The value 3227 indicates the type of specializations: 3228 3229 1=implicit instantiation 3230 3231 2=partial or explicit specialization, e.g.: 3232 3233 template <> int min<int> (int, int), 3234 3235 3=explicit instantiation, e.g.: 3236 3237 template int min<int> (int, int); 3238 3239 Note that NODE will be marked as a specialization even if the 3240 template it is instantiating is not a primary template. For 3241 example, given: 3242 3243 template <typename T> struct O { 3244 void f(); 3245 struct I {}; 3246 }; 3247 3248 both O<int>::f and O<int>::I will be marked as instantiations. 3249 3250 If DECL_USE_TEMPLATE is nonzero, then DECL_TEMPLATE_INFO will also 3251 be non-NULL. */ 3252 #define DECL_USE_TEMPLATE(NODE) (DECL_LANG_SPECIFIC (NODE)->decl_flags.use_template) 3253 3254 /* Like DECL_USE_TEMPLATE, but for class types. */ 3255 #define CLASSTYPE_USE_TEMPLATE(NODE) \ 3256 (LANG_TYPE_CLASS_CHECK (NODE)->use_template) 3257 3258 /* True if NODE is a specialization of a primary template. */ 3259 #define CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P(NODE) \ 3260 (CLASS_TYPE_P (NODE) \ 3261 && CLASSTYPE_USE_TEMPLATE (NODE) \ 3262 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (arg))) 3263 3264 #define DECL_TEMPLATE_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) & 1) 3265 #define CLASSTYPE_TEMPLATE_INSTANTIATION(NODE) \ 3266 (CLASSTYPE_USE_TEMPLATE (NODE) & 1) 3267 3268 #define DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) == 2) 3269 #define SET_DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) = 2) 3270 3271 /* Returns true for an explicit or partial specialization of a class 3272 template. */ 3273 #define CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \ 3274 (CLASSTYPE_USE_TEMPLATE (NODE) == 2) 3275 #define SET_CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \ 3276 (CLASSTYPE_USE_TEMPLATE (NODE) = 2) 3277 3278 #define DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 1) 3279 #define SET_DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 1) 3280 #define CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \ 3281 (CLASSTYPE_USE_TEMPLATE (NODE) == 1) 3282 #define SET_CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \ 3283 (CLASSTYPE_USE_TEMPLATE (NODE) = 1) 3284 3285 #define DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 3) 3286 #define SET_DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 3) 3287 #define CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \ 3288 (CLASSTYPE_USE_TEMPLATE (NODE) == 3) 3289 #define SET_CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \ 3290 (CLASSTYPE_USE_TEMPLATE (NODE) = 3) 3291 3292 /* Nonzero if DECL is a friend function which is an instantiation 3293 from the point of view of the compiler, but not from the point of 3294 view of the language. For example given: 3295 template <class T> struct S { friend void f(T) {}; }; 3296 the declaration of `void f(int)' generated when S<int> is 3297 instantiated will not be a DECL_TEMPLATE_INSTANTIATION, but will be 3298 a DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION. */ 3299 #define DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION(DECL) \ 3300 (DECL_TEMPLATE_INFO (DECL) && !DECL_USE_TEMPLATE (DECL)) 3301 3302 /* Nonzero iff we are currently processing a declaration for an 3303 entity with its own template parameter list, and which is not a 3304 full specialization. */ 3305 #define PROCESSING_REAL_TEMPLATE_DECL_P() \ 3306 (processing_template_decl > template_class_depth (current_scope ())) 3307 3308 /* Nonzero if this VAR_DECL or FUNCTION_DECL has already been 3309 instantiated, i.e. its definition has been generated from the 3310 pattern given in the template. */ 3311 #define DECL_TEMPLATE_INSTANTIATED(NODE) \ 3312 DECL_LANG_FLAG_1 (VAR_OR_FUNCTION_DECL_CHECK (NODE)) 3313 3314 /* We know what we're doing with this decl now. */ 3315 #define DECL_INTERFACE_KNOWN(NODE) DECL_LANG_FLAG_5 (NODE) 3316 3317 /* DECL_EXTERNAL must be set on a decl until the decl is actually emitted, 3318 so that assemble_external will work properly. So we have this flag to 3319 tell us whether the decl is really not external. 3320 3321 This flag does not indicate whether or not the decl is defined in the 3322 current translation unit; it indicates whether or not we should emit the 3323 decl at the end of compilation if it is defined and needed. */ 3324 #define DECL_NOT_REALLY_EXTERN(NODE) \ 3325 (DECL_LANG_SPECIFIC (NODE)->decl_flags.not_really_extern) 3326 3327 #define DECL_REALLY_EXTERN(NODE) \ 3328 (DECL_EXTERNAL (NODE) && ! DECL_NOT_REALLY_EXTERN (NODE)) 3329 3330 /* A thunk is a stub function. 3331 3332 A thunk is an alternate entry point for an ordinary FUNCTION_DECL. 3333 The address of the ordinary FUNCTION_DECL is given by the 3334 DECL_INITIAL, which is always an ADDR_EXPR whose operand is a 3335 FUNCTION_DECL. The job of the thunk is to either adjust the this 3336 pointer before transferring control to the FUNCTION_DECL, or call 3337 FUNCTION_DECL and then adjust the result value. Note, the result 3338 pointer adjusting thunk must perform a call to the thunked 3339 function, (or be implemented via passing some invisible parameter 3340 to the thunked function, which is modified to perform the 3341 adjustment just before returning). 3342 3343 A thunk may perform either, or both, of the following operations: 3344 3345 o Adjust the this or result pointer by a constant offset. 3346 o Adjust the this or result pointer by looking up a vcall or vbase offset 3347 in the vtable. 3348 3349 A this pointer adjusting thunk converts from a base to a derived 3350 class, and hence adds the offsets. A result pointer adjusting thunk 3351 converts from a derived class to a base, and hence subtracts the 3352 offsets. If both operations are performed, then the constant 3353 adjustment is performed first for this pointer adjustment and last 3354 for the result pointer adjustment. 3355 3356 The constant adjustment is given by THUNK_FIXED_OFFSET. If the 3357 vcall or vbase offset is required, THUNK_VIRTUAL_OFFSET is 3358 used. For this pointer adjusting thunks, it is the vcall offset 3359 into the vtable. For result pointer adjusting thunks it is the 3360 binfo of the virtual base to convert to. Use that binfo's vbase 3361 offset. 3362 3363 It is possible to have equivalent covariant thunks. These are 3364 distinct virtual covariant thunks whose vbase offsets happen to 3365 have the same value. THUNK_ALIAS is used to pick one as the 3366 canonical thunk, which will get all the this pointer adjusting 3367 thunks attached to it. */ 3368 3369 /* An integer indicating how many bytes should be subtracted from the 3370 this or result pointer when this function is called. */ 3371 #define THUNK_FIXED_OFFSET(DECL) \ 3372 (DECL_LANG_SPECIFIC (THUNK_FUNCTION_CHECK (DECL))->u.f.u5.fixed_offset) 3373 3374 /* A tree indicating how to perform the virtual adjustment. For a this 3375 adjusting thunk it is the number of bytes to be added to the vtable 3376 to find the vcall offset. For a result adjusting thunk, it is the 3377 binfo of the relevant virtual base. If NULL, then there is no 3378 virtual adjust. (The vptr is always located at offset zero from 3379 the this or result pointer.) (If the covariant type is within the 3380 class hierarchy being laid out, the vbase index is not yet known 3381 at the point we need to create the thunks, hence the need to use 3382 binfos.) */ 3383 3384 #define THUNK_VIRTUAL_OFFSET(DECL) \ 3385 (LANG_DECL_U2_CHECK (FUNCTION_DECL_CHECK (DECL), 0)->access) 3386 3387 /* A thunk which is equivalent to another thunk. */ 3388 #define THUNK_ALIAS(DECL) \ 3389 (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->decl_flags.u.template_info) 3390 3391 /* For thunk NODE, this is the FUNCTION_DECL thunked to. It is 3392 possible for the target to be a thunk too. */ 3393 #define THUNK_TARGET(NODE) \ 3394 (DECL_LANG_SPECIFIC (NODE)->u.f.befriending_classes) 3395 3396 /* True for a SCOPE_REF iff the "template" keyword was used to 3397 indicate that the qualified name denotes a template. */ 3398 #define QUALIFIED_NAME_IS_TEMPLATE(NODE) \ 3399 (TREE_LANG_FLAG_0 (SCOPE_REF_CHECK (NODE))) 3400 3401 /* True for an OMP_ATOMIC that has dependent parameters. These are stored 3402 as an expr in operand 1, and integer_zero_node in operand 0. */ 3403 #define OMP_ATOMIC_DEPENDENT_P(NODE) \ 3404 (TREE_CODE (TREE_OPERAND (OMP_ATOMIC_CHECK (NODE), 0)) == INTEGER_CST) 3405 3406 /* Used while gimplifying continue statements bound to OMP_FOR nodes. */ 3407 #define OMP_FOR_GIMPLIFYING_P(NODE) \ 3408 (TREE_LANG_FLAG_0 (OMP_FOR_CHECK (NODE))) 3409 3410 /* A language-specific token attached to the OpenMP data clauses to 3411 hold code (or code fragments) related to ctors, dtors, and op=. 3412 See semantics.c for details. */ 3413 #define CP_OMP_CLAUSE_INFO(NODE) \ 3414 TREE_TYPE (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_PRIVATE, \ 3415 OMP_CLAUSE_COPYPRIVATE)) 3416 3417 /* These macros provide convenient access to the various _STMT nodes 3418 created when parsing template declarations. */ 3419 #define TRY_STMTS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 0) 3420 #define TRY_HANDLERS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 1) 3421 3422 #define EH_SPEC_STMTS(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 0) 3423 #define EH_SPEC_RAISES(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 1) 3424 3425 #define USING_STMT_NAMESPACE(NODE) TREE_OPERAND (USING_STMT_CHECK (NODE), 0) 3426 3427 /* Nonzero if this try block is a function try block. */ 3428 #define FN_TRY_BLOCK_P(NODE) TREE_LANG_FLAG_3 (TRY_BLOCK_CHECK (NODE)) 3429 #define HANDLER_PARMS(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 0) 3430 #define HANDLER_BODY(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 1) 3431 #define HANDLER_TYPE(NODE) TREE_TYPE (HANDLER_CHECK (NODE)) 3432 3433 /* CLEANUP_STMT accessors. The statement(s) covered, the cleanup to run 3434 and the VAR_DECL for which this cleanup exists. */ 3435 #define CLEANUP_BODY(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 0) 3436 #define CLEANUP_EXPR(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 1) 3437 #define CLEANUP_DECL(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 2) 3438 3439 /* IF_STMT accessors. These give access to the condition of the if 3440 statement, the then block of the if statement, and the else block 3441 of the if statement if it exists. */ 3442 #define IF_COND(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 0) 3443 #define THEN_CLAUSE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 1) 3444 #define ELSE_CLAUSE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 2) 3445 3446 /* WHILE_STMT accessors. These give access to the condition of the 3447 while statement and the body of the while statement, respectively. */ 3448 #define WHILE_COND(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 0) 3449 #define WHILE_BODY(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 1) 3450 3451 /* DO_STMT accessors. These give access to the condition of the do 3452 statement and the body of the do statement, respectively. */ 3453 #define DO_COND(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 0) 3454 #define DO_BODY(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 1) 3455 3456 /* FOR_STMT accessors. These give access to the init statement, 3457 condition, update expression, and body of the for statement, 3458 respectively. */ 3459 #define FOR_INIT_STMT(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 0) 3460 #define FOR_COND(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 1) 3461 #define FOR_EXPR(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 2) 3462 #define FOR_BODY(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 3) 3463 3464 #define SWITCH_STMT_COND(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 0) 3465 #define SWITCH_STMT_BODY(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 1) 3466 #define SWITCH_STMT_TYPE(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 2) 3467 3468 /* STMT_EXPR accessor. */ 3469 #define STMT_EXPR_STMT(NODE) TREE_OPERAND (STMT_EXPR_CHECK (NODE), 0) 3470 3471 /* EXPR_STMT accessor. This gives the expression associated with an 3472 expression statement. */ 3473 #define EXPR_STMT_EXPR(NODE) TREE_OPERAND (EXPR_STMT_CHECK (NODE), 0) 3474 3475 /* True if this TARGET_EXPR was created by build_cplus_new, and so we can 3476 discard it if it isn't useful. */ 3477 #define TARGET_EXPR_IMPLICIT_P(NODE) \ 3478 TREE_LANG_FLAG_0 (TARGET_EXPR_CHECK (NODE)) 3479 3480 /* True if this TARGET_EXPR is the result of list-initialization of a 3481 temporary. */ 3482 #define TARGET_EXPR_LIST_INIT_P(NODE) \ 3483 TREE_LANG_FLAG_1 (TARGET_EXPR_CHECK (NODE)) 3484 3485 /* An enumeration of the kind of tags that C++ accepts. */ 3486 enum tag_types { 3487 none_type = 0, /* Not a tag type. */ 3488 record_type, /* "struct" types. */ 3489 class_type, /* "class" types. */ 3490 union_type, /* "union" types. */ 3491 enum_type, /* "enum" types. */ 3492 typename_type /* "typename" types. */ 3493 }; 3494 3495 /* The various kinds of lvalues we distinguish. */ 3496 typedef enum cp_lvalue_kind { 3497 clk_none = 0, /* Things that are not an lvalue. */ 3498 clk_ordinary = 1, /* An ordinary lvalue. */ 3499 clk_class = 2, /* An rvalue of class-type. */ 3500 clk_bitfield = 4, /* An lvalue for a bit-field. */ 3501 clk_packed = 8 /* An lvalue for a packed field. */ 3502 } cp_lvalue_kind; 3503 3504 /* Various kinds of template specialization, instantiation, etc. */ 3505 typedef enum tmpl_spec_kind { 3506 tsk_none, /* Not a template at all. */ 3507 tsk_invalid_member_spec, /* An explicit member template 3508 specialization, but the enclosing 3509 classes have not all been explicitly 3510 specialized. */ 3511 tsk_invalid_expl_inst, /* An explicit instantiation containing 3512 template parameter lists. */ 3513 tsk_excessive_parms, /* A template declaration with too many 3514 template parameter lists. */ 3515 tsk_insufficient_parms, /* A template declaration with too few 3516 parameter lists. */ 3517 tsk_template, /* A template declaration. */ 3518 tsk_expl_spec, /* An explicit specialization. */ 3519 tsk_expl_inst /* An explicit instantiation. */ 3520 } tmpl_spec_kind; 3521 3522 /* The various kinds of access. BINFO_ACCESS depends on these being 3523 two bit quantities. The numerical values are important; they are 3524 used to initialize RTTI data structures, so changing them changes 3525 the ABI. */ 3526 typedef enum access_kind { 3527 ak_none = 0, /* Inaccessible. */ 3528 ak_public = 1, /* Accessible, as a `public' thing. */ 3529 ak_protected = 2, /* Accessible, as a `protected' thing. */ 3530 ak_private = 3 /* Accessible, as a `private' thing. */ 3531 } access_kind; 3532 3533 /* The various kinds of special functions. If you add to this list, 3534 you should update special_function_p as well. */ 3535 typedef enum special_function_kind { 3536 sfk_none = 0, /* Not a special function. This enumeral 3537 must have value zero; see 3538 special_function_p. */ 3539 sfk_constructor, /* A constructor. */ 3540 sfk_copy_constructor, /* A copy constructor. */ 3541 sfk_assignment_operator, /* An assignment operator. */ 3542 sfk_destructor, /* A destructor. */ 3543 sfk_complete_destructor, /* A destructor for complete objects. */ 3544 sfk_base_destructor, /* A destructor for base subobjects. */ 3545 sfk_deleting_destructor, /* A destructor for complete objects that 3546 deletes the object after it has been 3547 destroyed. */ 3548 sfk_conversion /* A conversion operator. */ 3549 } special_function_kind; 3550 3551 /* The various kinds of linkage. From [basic.link], 3552 3553 A name is said to have linkage when it might denote the same 3554 object, reference, function, type, template, namespace or value 3555 as a name introduced in another scope: 3556 3557 -- When a name has external linkage, the entity it denotes can 3558 be referred to from scopes of other translation units or from 3559 other scopes of the same translation unit. 3560 3561 -- When a name has internal linkage, the entity it denotes can 3562 be referred to by names from other scopes in the same 3563 translation unit. 3564 3565 -- When a name has no linkage, the entity it denotes cannot be 3566 referred to by names from other scopes. */ 3567 3568 typedef enum linkage_kind { 3569 lk_none, /* No linkage. */ 3570 lk_internal, /* Internal linkage. */ 3571 lk_external /* External linkage. */ 3572 } linkage_kind; 3573 3574 /* Bitmask flags to control type substitution. */ 3575 typedef enum tsubst_flags_t { 3576 tf_none = 0, /* nothing special */ 3577 tf_error = 1 << 0, /* give error messages */ 3578 tf_warning = 1 << 1, /* give warnings too */ 3579 tf_ignore_bad_quals = 1 << 2, /* ignore bad cvr qualifiers */ 3580 tf_keep_type_decl = 1 << 3, /* retain typedef type decls 3581 (make_typename_type use) */ 3582 tf_ptrmem_ok = 1 << 4, /* pointers to member ok (internal 3583 instantiate_type use) */ 3584 tf_user = 1 << 5, /* found template must be a user template 3585 (lookup_template_class use) */ 3586 tf_conv = 1 << 6, /* We are determining what kind of 3587 conversion might be permissible, 3588 not actually performing the 3589 conversion. */ 3590 tf_no_access_control = 1 << 7, /* Do not perform access checks, even 3591 when issuing other errors. */ 3592 /* Convenient substitution flags combinations. */ 3593 tf_warning_or_error = tf_warning | tf_error 3594 } tsubst_flags_t; 3595 3596 /* The kind of checking we can do looking in a class hierarchy. */ 3597 typedef enum base_access { 3598 ba_any = 0, /* Do not check access, allow an ambiguous base, 3599 prefer a non-virtual base */ 3600 ba_unique = 1 << 0, /* Must be a unique base. */ 3601 ba_check_bit = 1 << 1, /* Check access. */ 3602 ba_check = ba_unique | ba_check_bit, 3603 ba_ignore_scope = 1 << 2, /* Ignore access allowed by local scope. */ 3604 ba_quiet = 1 << 3 /* Do not issue error messages. */ 3605 } base_access; 3606 3607 /* The various kinds of access check during parsing. */ 3608 typedef enum deferring_kind { 3609 dk_no_deferred = 0, /* Check access immediately */ 3610 dk_deferred = 1, /* Deferred check */ 3611 dk_no_check = 2 /* No access check */ 3612 } deferring_kind; 3613 3614 /* The kind of base we can find, looking in a class hierarchy. 3615 Values <0 indicate we failed. */ 3616 typedef enum base_kind { 3617 bk_inaccessible = -3, /* The base is inaccessible */ 3618 bk_ambig = -2, /* The base is ambiguous */ 3619 bk_not_base = -1, /* It is not a base */ 3620 bk_same_type = 0, /* It is the same type */ 3621 bk_proper_base = 1, /* It is a proper base */ 3622 bk_via_virtual = 2 /* It is a proper base, but via a virtual 3623 path. This might not be the canonical 3624 binfo. */ 3625 } base_kind; 3626 3627 /* Node for "pointer to (virtual) function". 3628 This may be distinct from ptr_type_node so gdb can distinguish them. */ 3629 #define vfunc_ptr_type_node vtable_entry_type 3630 3631 3632 /* For building calls to `delete'. */ 3633 extern GTY(()) tree integer_two_node; 3634 extern GTY(()) tree integer_three_node; 3635 3636 /* The number of function bodies which we are currently processing. 3637 (Zero if we are at namespace scope, one inside the body of a 3638 function, two inside the body of a function in a local class, etc.) */ 3639 extern int function_depth; 3640 3641 /* in pt.c */ 3642 3643 /* These values are used for the `STRICT' parameter to type_unification and 3644 fn_type_unification. Their meanings are described with the 3645 documentation for fn_type_unification. */ 3646 3647 typedef enum unification_kind_t { 3648 DEDUCE_CALL, 3649 DEDUCE_CONV, 3650 DEDUCE_EXACT 3651 } unification_kind_t; 3652 3653 /* in class.c */ 3654 3655 extern int current_class_depth; 3656 3657 /* An array of all local classes present in this translation unit, in 3658 declaration order. */ 3659 extern GTY(()) VEC(tree,gc) *local_classes; 3660 3661 /* Here's where we control how name mangling takes place. */ 3663 3664 /* Cannot use '$' up front, because this confuses gdb 3665 (names beginning with '$' are gdb-local identifiers). 3666 3667 Note that all forms in which the '$' is significant are long enough 3668 for direct indexing (meaning that if we know there is a '$' 3669 at a particular location, we can index into the string at 3670 any other location that provides distinguishing characters). */ 3671 3672 /* Define NO_DOT_IN_LABEL in your favorite tm file if your assembler 3673 doesn't allow '.' in symbol names. */ 3674 #ifndef NO_DOT_IN_LABEL 3675 3676 #define JOINER '.' 3677 3678 #define AUTO_TEMP_NAME "_.tmp_" 3679 #define VFIELD_BASE ".vf" 3680 #define VFIELD_NAME "_vptr." 3681 #define VFIELD_NAME_FORMAT "_vptr.%s" 3682 3683 #define ANON_AGGRNAME_FORMAT "._%d" 3684 3685 #else /* NO_DOT_IN_LABEL */ 3686 3687 #ifndef NO_DOLLAR_IN_LABEL 3688 3689 #define JOINER '$' 3690 3691 #define AUTO_TEMP_NAME "_$tmp_" 3692 #define VFIELD_BASE "$vf" 3693 #define VFIELD_NAME "_vptr$" 3694 #define VFIELD_NAME_FORMAT "_vptr$%s" 3695 #define ANON_AGGRNAME_FORMAT "$_%d" 3696 3697 #else /* NO_DOLLAR_IN_LABEL */ 3698 3699 #define IN_CHARGE_NAME "__in_chrg" 3700 #define AUTO_TEMP_NAME "__tmp_" 3701 #define TEMP_NAME_P(ID_NODE) \ 3702 (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, \ 3703 sizeof (AUTO_TEMP_NAME) - 1)) 3704 #define VTABLE_NAME "__vt_" 3705 #define VTABLE_NAME_P(ID_NODE) \ 3706 (!strncmp (IDENTIFIER_POINTER (ID_NODE), VTABLE_NAME, \ 3707 sizeof (VTABLE_NAME) - 1)) 3708 #define VFIELD_BASE "__vfb" 3709 #define VFIELD_NAME "__vptr_" 3710 #define VFIELD_NAME_P(ID_NODE) \ 3711 (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, \ 3712 sizeof (VFIELD_NAME) - 1)) 3713 #define VFIELD_NAME_FORMAT "__vptr_%s" 3714 3715 #define ANON_AGGRNAME_PREFIX "__anon_" 3716 #define ANON_AGGRNAME_P(ID_NODE) \ 3717 (!strncmp (IDENTIFIER_POINTER (ID_NODE), ANON_AGGRNAME_PREFIX, \ 3718 sizeof (ANON_AGGRNAME_PREFIX) - 1)) 3719 #define ANON_AGGRNAME_FORMAT "__anon_%d" 3720 3721 #endif /* NO_DOLLAR_IN_LABEL */ 3722 #endif /* NO_DOT_IN_LABEL */ 3723 3724 #define THIS_NAME "this" 3725 3726 #define IN_CHARGE_NAME "__in_chrg" 3727 3728 #define VTBL_PTR_TYPE "__vtbl_ptr_type" 3729 #define VTABLE_DELTA_NAME "__delta" 3730 #define VTABLE_PFN_NAME "__pfn" 3731 3732 #if !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL) 3733 3734 #define VTABLE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == 'v' \ 3735 && IDENTIFIER_POINTER (ID_NODE)[2] == 't' \ 3736 && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER) 3737 3738 #define TEMP_NAME_P(ID_NODE) \ 3739 (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, sizeof (AUTO_TEMP_NAME)-1)) 3740 #define VFIELD_NAME_P(ID_NODE) \ 3741 (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, sizeof(VFIELD_NAME)-1)) 3742 3743 /* For anonymous aggregate types, we need some sort of name to 3744 hold on to. In practice, this should not appear, but it should 3745 not be harmful if it does. */ 3746 #define ANON_AGGRNAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER \ 3747 && IDENTIFIER_POINTER (ID_NODE)[1] == '_') 3748 #endif /* !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL) */ 3749 3750 3751 /* Nonzero if we're done parsing and into end-of-file activities. */ 3753 3754 extern int at_eof; 3755 3756 /* A list of namespace-scope objects which have constructors or 3757 destructors which reside in the global scope. The decl is stored 3758 in the TREE_VALUE slot and the initializer is stored in the 3759 TREE_PURPOSE slot. */ 3760 extern GTY(()) tree static_aggregates; 3761 3762 enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, OP_FLAG, TYPENAME_FLAG }; 3763 3764 /* These are uses as bits in flags passed to various functions to 3765 control their behavior. Despite the LOOKUP_ prefix, many of these 3766 do not control name lookup. ??? Functions using these flags should 3767 probably be modified to accept explicit boolean flags for the 3768 behaviors relevant to them. */ 3769 /* Check for access violations. */ 3770 #define LOOKUP_PROTECT (1 << 0) 3771 /* Complain if no suitable member function matching the arguments is 3772 found. */ 3773 #define LOOKUP_COMPLAIN (1 << 1) 3774 #define LOOKUP_NORMAL (LOOKUP_PROTECT | LOOKUP_COMPLAIN) 3775 /* Even if the function found by lookup is a virtual function, it 3776 should be called directly. */ 3777 #define LOOKUP_NONVIRTUAL (1 << 2) 3778 /* Non-converting (i.e., "explicit") constructors are not tried. */ 3779 #define LOOKUP_ONLYCONVERTING (1 << 3) 3780 /* If a temporary is created, it should be created so that it lives 3781 as long as the current variable bindings; otherwise it only lives 3782 until the end of the complete-expression. It also forces 3783 direct-initialization in cases where other parts of the compiler 3784 have already generated a temporary, such as reference 3785 initialization and the catch parameter. */ 3786 #define DIRECT_BIND (1 << 4) 3787 /* User-defined conversions are not permitted. (Built-in conversions 3788 are permitted.) */ 3789 #define LOOKUP_NO_CONVERSION (1 << 5) 3790 /* The user has explicitly called a destructor. (Therefore, we do 3791 not need to check that the object is non-NULL before calling the 3792 destructor.) */ 3793 #define LOOKUP_DESTRUCTOR (1 << 6) 3794 /* Do not permit references to bind to temporaries. */ 3795 #define LOOKUP_NO_TEMP_BIND (1 << 7) 3796 /* Do not accept objects, and possibly namespaces. */ 3797 #define LOOKUP_PREFER_TYPES (1 << 8) 3798 /* Do not accept objects, and possibly types. */ 3799 #define LOOKUP_PREFER_NAMESPACES (1 << 9) 3800 /* Accept types or namespaces. */ 3801 #define LOOKUP_PREFER_BOTH (LOOKUP_PREFER_TYPES | LOOKUP_PREFER_NAMESPACES) 3802 /* Return friend declarations and un-declared builtin functions. 3803 (Normally, these entities are registered in the symbol table, but 3804 not found by lookup.) */ 3805 #define LOOKUP_HIDDEN (LOOKUP_PREFER_NAMESPACES << 1) 3806 /* Prefer that the lvalue be treated as an rvalue. */ 3807 #define LOOKUP_PREFER_RVALUE (LOOKUP_HIDDEN << 1) 3808 /* We're inside an init-list, so narrowing conversions are ill-formed. */ 3809 #define LOOKUP_NO_NARROWING (LOOKUP_PREFER_RVALUE << 1) 3810 /* Avoid user-defined conversions for the first parameter of a copy 3811 constructor. */ 3812 #define LOOKUP_NO_COPY_CTOR_CONVERSION (LOOKUP_NO_NARROWING << 1) 3813 3814 #define LOOKUP_NAMESPACES_ONLY(F) \ 3815 (((F) & LOOKUP_PREFER_NAMESPACES) && !((F) & LOOKUP_PREFER_TYPES)) 3816 #define LOOKUP_TYPES_ONLY(F) \ 3817 (!((F) & LOOKUP_PREFER_NAMESPACES) && ((F) & LOOKUP_PREFER_TYPES)) 3818 #define LOOKUP_QUALIFIERS_ONLY(F) ((F) & LOOKUP_PREFER_BOTH) 3819 3820 3821 /* These flags are used by the conversion code. 3822 CONV_IMPLICIT : Perform implicit conversions (standard and user-defined). 3823 CONV_STATIC : Perform the explicit conversions for static_cast. 3824 CONV_CONST : Perform the explicit conversions for const_cast. 3825 CONV_REINTERPRET: Perform the explicit conversions for reinterpret_cast. 3826 CONV_PRIVATE : Perform upcasts to private bases. 3827 CONV_FORCE_TEMP : Require a new temporary when converting to the same 3828 aggregate type. */ 3829 3830 #define CONV_IMPLICIT 1 3831 #define CONV_STATIC 2 3832 #define CONV_CONST 4 3833 #define CONV_REINTERPRET 8 3834 #define CONV_PRIVATE 16 3835 /* #define CONV_NONCONVERTING 32 */ 3836 #define CONV_FORCE_TEMP 64 3837 #define CONV_OLD_CONVERT (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \ 3838 | CONV_REINTERPRET) 3839 #define CONV_C_CAST (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \ 3840 | CONV_REINTERPRET | CONV_PRIVATE | CONV_FORCE_TEMP) 3841 3842 /* Used by build_expr_type_conversion to indicate which types are 3843 acceptable as arguments to the expression under consideration. */ 3844 3845 #define WANT_INT 1 /* integer types, including bool */ 3846 #define WANT_FLOAT 2 /* floating point types */ 3847 #define WANT_ENUM 4 /* enumerated types */ 3848 #define WANT_POINTER 8 /* pointer types */ 3849 #define WANT_NULL 16 /* null pointer constant */ 3850 #define WANT_VECTOR 32 /* vector types */ 3851 #define WANT_ARITH (WANT_INT | WANT_FLOAT | WANT_VECTOR) 3852 3853 /* Used with comptypes, and related functions, to guide type 3854 comparison. */ 3855 3856 #define COMPARE_STRICT 0 /* Just check if the types are the 3857 same. */ 3858 #define COMPARE_BASE 1 /* Check to see if the second type is 3859 derived from the first. */ 3860 #define COMPARE_DERIVED 2 /* Like COMPARE_BASE, but in 3861 reverse. */ 3862 #define COMPARE_REDECLARATION 4 /* The comparison is being done when 3863 another declaration of an existing 3864 entity is seen. */ 3865 #define COMPARE_STRUCTURAL 8 /* The comparison is intended to be 3866 structural. The actual comparison 3867 will be identical to 3868 COMPARE_STRICT. */ 3869 3870 /* Used with push_overloaded_decl. */ 3871 #define PUSH_GLOBAL 0 /* Push the DECL into namespace scope, 3872 regardless of the current scope. */ 3873 #define PUSH_LOCAL 1 /* Push the DECL into the current 3874 scope. */ 3875 #define PUSH_USING 2 /* We are pushing this DECL as the 3876 result of a using declaration. */ 3877 3878 /* Used with start function. */ 3879 #define SF_DEFAULT 0 /* No flags. */ 3880 #define SF_PRE_PARSED 1 /* The function declaration has 3881 already been parsed. */ 3882 #define SF_INCLASS_INLINE 2 /* The function is an inline, defined 3883 in the class body. */ 3884 3885 /* Used with start_decl's initialized parameter. */ 3886 #define SD_UNINITIALIZED 0 3887 #define SD_INITIALIZED 1 3888 #define SD_DEFAULTED 2 3889 #define SD_DELETED 3 3890 3891 /* Returns nonzero iff TYPE1 and TYPE2 are the same type, or if TYPE2 3892 is derived from TYPE1, or if TYPE2 is a pointer (reference) to a 3893 class derived from the type pointed to (referred to) by TYPE1. */ 3894 #define same_or_base_type_p(TYPE1, TYPE2) \ 3895 comptypes ((TYPE1), (TYPE2), COMPARE_BASE) 3896 3897 /* These macros are used to access a TEMPLATE_PARM_INDEX. */ 3898 #define TEMPLATE_PARM_INDEX_CAST(NODE) \ 3899 ((template_parm_index*)TEMPLATE_PARM_INDEX_CHECK (NODE)) 3900 #define TEMPLATE_PARM_IDX(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->index) 3901 #define TEMPLATE_PARM_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->level) 3902 #define TEMPLATE_PARM_DESCENDANTS(NODE) (TREE_CHAIN (NODE)) 3903 #define TEMPLATE_PARM_ORIG_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->orig_level) 3904 #define TEMPLATE_PARM_DECL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->decl) 3905 #define TEMPLATE_PARM_PARAMETER_PACK(NODE) \ 3906 (TREE_LANG_FLAG_0 (TEMPLATE_PARM_INDEX_CHECK (NODE))) 3907 3908 /* These macros are for accessing the fields of TEMPLATE_TYPE_PARM, 3909 TEMPLATE_TEMPLATE_PARM and BOUND_TEMPLATE_TEMPLATE_PARM nodes. */ 3910 #define TEMPLATE_TYPE_PARM_INDEX(NODE) \ 3911 (TREE_CHECK3 ((NODE), TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM, \ 3912 BOUND_TEMPLATE_TEMPLATE_PARM))->type.values 3913 #define TEMPLATE_TYPE_IDX(NODE) \ 3914 (TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (NODE))) 3915 #define TEMPLATE_TYPE_LEVEL(NODE) \ 3916 (TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE))) 3917 #define TEMPLATE_TYPE_ORIG_LEVEL(NODE) \ 3918 (TEMPLATE_PARM_ORIG_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE))) 3919 #define TEMPLATE_TYPE_DECL(NODE) \ 3920 (TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (NODE))) 3921 #define TEMPLATE_TYPE_PARAMETER_PACK(NODE) \ 3922 (TEMPLATE_PARM_PARAMETER_PACK (TEMPLATE_TYPE_PARM_INDEX (NODE))) 3923 3924 /* These constants can used as bit flags in the process of tree formatting. 3925 3926 TFF_PLAIN_IDENTIFIER: unqualified part of a name. 3927 TFF_SCOPE: include the class and namespace scope of the name. 3928 TFF_CHASE_TYPEDEF: print the original type-id instead of the typedef-name. 3929 TFF_DECL_SPECIFIERS: print decl-specifiers. 3930 TFF_CLASS_KEY_OR_ENUM: precede a class-type name (resp. enum name) with 3931 a class-key (resp. `enum'). 3932 TFF_RETURN_TYPE: include function return type. 3933 TFF_FUNCTION_DEFAULT_ARGUMENTS: include function default parameter values. 3934 TFF_EXCEPTION_SPECIFICATION: show function exception specification. 3935 TFF_TEMPLATE_HEADER: show the template<...> header in a 3936 template-declaration. 3937 TFF_TEMPLATE_NAME: show only template-name. 3938 TFF_EXPR_IN_PARENS: parenthesize expressions. 3939 TFF_NO_FUNCTION_ARGUMENTS: don't show function arguments. 3940 TFF_UNQUALIFIED_NAME: do not print the qualifying scope of the 3941 top-level entity. */ 3942 3943 #define TFF_PLAIN_IDENTIFIER (0) 3944 #define TFF_SCOPE (1) 3945 #define TFF_CHASE_TYPEDEF (1 << 1) 3946 #define TFF_DECL_SPECIFIERS (1 << 2) 3947 #define TFF_CLASS_KEY_OR_ENUM (1 << 3) 3948 #define TFF_RETURN_TYPE (1 << 4) 3949 #define TFF_FUNCTION_DEFAULT_ARGUMENTS (1 << 5) 3950 #define TFF_EXCEPTION_SPECIFICATION (1 << 6) 3951 #define TFF_TEMPLATE_HEADER (1 << 7) 3952 #define TFF_TEMPLATE_NAME (1 << 8) 3953 #define TFF_EXPR_IN_PARENS (1 << 9) 3954 #define TFF_NO_FUNCTION_ARGUMENTS (1 << 10) 3955 #define TFF_UNQUALIFIED_NAME (1 << 11) 3956 3957 /* Returns the TEMPLATE_DECL associated to a TEMPLATE_TEMPLATE_PARM 3958 node. */ 3959 #define TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL(NODE) \ 3960 ((TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM) \ 3961 ? TYPE_TI_TEMPLATE (NODE) \ 3962 : TYPE_NAME (NODE)) 3963 3964 /* in lex.c */ 3965 3966 extern void init_reswords (void); 3967 3968 /* Indexed by TREE_CODE, these tables give C-looking names to 3969 operators represented by TREE_CODES. For example, 3970 opname_tab[(int) MINUS_EXPR] == "-". */ 3971 extern const char **opname_tab, **assignop_tab; 3972 3973 typedef struct operator_name_info_t GTY(()) 3974 { 3975 /* The IDENTIFIER_NODE for the operator. */ 3976 tree identifier; 3977 /* The name of the operator. */ 3978 const char *name; 3979 /* The mangled name of the operator. */ 3980 const char *mangled_name; 3981 /* The arity of the operator. */ 3982 int arity; 3983 } operator_name_info_t; 3984 3985 /* A mapping from tree codes to operator name information. */ 3986 extern GTY(()) operator_name_info_t operator_name_info 3987 [(int) MAX_TREE_CODES]; 3988 /* Similar, but for assignment operators. */ 3989 extern GTY(()) operator_name_info_t assignment_operator_name_info 3990 [(int) MAX_TREE_CODES]; 3991 3992 /* A type-qualifier, or bitmask therefore, using the TYPE_QUAL 3993 constants. */ 3994 3995 typedef int cp_cv_quals; 3996 3997 /* A storage class. */ 3998 3999 typedef enum cp_storage_class { 4000 /* sc_none must be zero so that zeroing a cp_decl_specifier_seq 4001 sets the storage_class field to sc_none. */ 4002 sc_none = 0, 4003 sc_auto, 4004 sc_register, 4005 sc_static, 4006 sc_extern, 4007 sc_mutable 4008 } cp_storage_class; 4009 4010 /* An individual decl-specifier. */ 4011 4012 typedef enum cp_decl_spec { 4013 ds_first, 4014 ds_signed = ds_first, 4015 ds_unsigned, 4016 ds_short, 4017 ds_long, 4018 ds_const, 4019 ds_volatile, 4020 ds_restrict, 4021 ds_inline, 4022 ds_virtual, 4023 ds_explicit, 4024 ds_friend, 4025 ds_typedef, 4026 ds_complex, 4027 ds_thread, 4028 ds_last 4029 } cp_decl_spec; 4030 4031 /* A decl-specifier-seq. */ 4032 4033 typedef struct cp_decl_specifier_seq { 4034 /* The number of times each of the keywords has been seen. */ 4035 unsigned specs[(int) ds_last]; 4036 /* The primary type, if any, given by the decl-specifier-seq. 4037 Modifiers, like "short", "const", and "unsigned" are not 4038 reflected here. This field will be a TYPE, unless a typedef-name 4039 was used, in which case it will be a TYPE_DECL. */ 4040 tree type; 4041 /* The location of the primary type. Mainly used for error 4042 reporting. */ 4043 location_t type_location; 4044 /* The attributes, if any, provided with the specifier sequence. */ 4045 tree attributes; 4046 /* If non-NULL, a built-in type that the user attempted to redefine 4047 to some other type. */ 4048 tree redefined_builtin_type; 4049 /* The storage class specified -- or sc_none if no storage class was 4050 explicitly specified. */ 4051 cp_storage_class storage_class; 4052 /* True iff TYPE_SPEC indicates a user-defined type. */ 4053 BOOL_BITFIELD user_defined_type_p : 1; 4054 /* True iff multiple types were (erroneously) specified for this 4055 decl-specifier-seq. */ 4056 BOOL_BITFIELD multiple_types_p : 1; 4057 /* True iff multiple storage classes were (erroneously) specified 4058 for this decl-specifier-seq or a combination of a storage class 4059 with a typedef specifier. */ 4060 BOOL_BITFIELD conflicting_specifiers_p : 1; 4061 /* True iff at least one decl-specifier was found. */ 4062 BOOL_BITFIELD any_specifiers_p : 1; 4063 /* True iff "int" was explicitly provided. */ 4064 BOOL_BITFIELD explicit_int_p : 1; 4065 /* True iff "char" was explicitly provided. */ 4066 BOOL_BITFIELD explicit_char_p : 1; 4067 } cp_decl_specifier_seq; 4068 4069 /* The various kinds of declarators. */ 4070 4071 typedef enum cp_declarator_kind { 4072 cdk_id, 4073 cdk_function, 4074 cdk_array, 4075 cdk_pointer, 4076 cdk_reference, 4077 cdk_ptrmem, 4078 cdk_error 4079 } cp_declarator_kind; 4080 4081 /* A declarator. */ 4082 4083 typedef struct cp_declarator cp_declarator; 4084 4085 typedef struct cp_parameter_declarator cp_parameter_declarator; 4086 4087 /* A parameter, before it has been semantically analyzed. */ 4088 struct cp_parameter_declarator { 4089 /* The next parameter, or NULL_TREE if none. */ 4090 cp_parameter_declarator *next; 4091 /* The decl-specifiers-seq for the parameter. */ 4092 cp_decl_specifier_seq decl_specifiers; 4093 /* The declarator for the parameter. */ 4094 cp_declarator *declarator; 4095 /* The default-argument expression, or NULL_TREE, if none. */ 4096 tree default_argument; 4097 /* True iff this is the first parameter in the list and the 4098 parameter sequence ends with an ellipsis. */ 4099 bool ellipsis_p; 4100 }; 4101 4102 /* A declarator. */ 4103 struct cp_declarator { 4104 /* The kind of declarator. */ 4105 ENUM_BITFIELD (cp_declarator_kind) kind : 4; 4106 /* Whether we parsed an ellipsis (`...') just before the declarator, 4107 to indicate this is a parameter pack. */ 4108 BOOL_BITFIELD parameter_pack_p : 1; 4109 /* Attributes that apply to this declarator. */ 4110 tree attributes; 4111 /* For all but cdk_id and cdk_error, the contained declarator. For 4112 cdk_id and cdk_error, guaranteed to be NULL. */ 4113 cp_declarator *declarator; 4114 location_t id_loc; /* Currently only set for cdk_id and cdk_function. */ 4115 union { 4116 /* For identifiers. */ 4117 struct { 4118 /* If non-NULL, the qualifying scope (a NAMESPACE_DECL or 4119 *_TYPE) for this identifier. */ 4120 tree qualifying_scope; 4121 /* The unqualified name of the entity -- an IDENTIFIER_NODE, 4122 BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */ 4123 tree unqualified_name; 4124 /* If this is the name of a function, what kind of special 4125 function (if any). */ 4126 special_function_kind sfk; 4127 } id; 4128 /* For functions. */ 4129 struct { 4130 /* The parameters to the function as a TREE_LIST of decl/default. */ 4131 tree parameters; 4132 /* The cv-qualifiers for the function. */ 4133 cp_cv_quals qualifiers; 4134 /* The exception-specification for the function. */ 4135 tree exception_specification; 4136 /* The late-specified return type, if any. */ 4137 tree late_return_type; 4138 } function; 4139 /* For arrays. */ 4140 struct { 4141 /* The bounds to the array. */ 4142 tree bounds; 4143 } array; 4144 /* For cdk_pointer and cdk_ptrmem. */ 4145 struct { 4146 /* The cv-qualifiers for the pointer. */ 4147 cp_cv_quals qualifiers; 4148 /* For cdk_ptrmem, the class type containing the member. */ 4149 tree class_type; 4150 } pointer; 4151 /* For cdk_reference */ 4152 struct { 4153 /* The cv-qualifiers for the reference. These qualifiers are 4154 only used to diagnose ill-formed code. */ 4155 cp_cv_quals qualifiers; 4156 /* Whether this is an rvalue reference */ 4157 bool rvalue_ref; 4158 } reference; 4159 } u; 4160 }; 4161 4162 /* A level of template instantiation. */ 4163 struct tinst_level GTY(()) 4164 { 4165 /* The immediately deeper level in the chain. */ 4166 struct tinst_level *next; 4167 4168 /* The original node. Can be either a DECL (for a function or static 4169 data member) or a TYPE (for a class), depending on what we were 4170 asked to instantiate. */ 4171 tree decl; 4172 4173 /* The location where the template is instantiated. */ 4174 location_t locus; 4175 4176 /* True if the location is in a system header. */ 4177 bool in_system_header_p; 4178 }; 4179 4180 /* A parameter list indicating for a function with no parameters, 4181 e.g "int f(void)". */ 4182 extern cp_parameter_declarator *no_parameters; 4183 4184 /* True if we saw "#pragma GCC java_exceptions". */ 4185 extern bool pragma_java_exceptions; 4186 4187 /* in call.c */ 4188 extern bool check_dtor_name (tree, tree); 4189 4190 extern tree build_vfield_ref (tree, tree); 4191 extern tree build_conditional_expr (tree, tree, tree, 4192 tsubst_flags_t); 4193 extern tree build_addr_func (tree); 4194 extern tree build_call_a (tree, int, tree*); 4195 extern tree build_call_n (tree, int, ...); 4196 extern bool null_ptr_cst_p (tree); 4197 extern bool sufficient_parms_p (const_tree); 4198 extern tree type_decays_to (tree); 4199 extern tree build_user_type_conversion (tree, tree, int); 4200 extern tree build_new_function_call (tree, tree, bool, 4201 tsubst_flags_t); 4202 extern tree build_operator_new_call (tree, tree, tree *, tree *, 4203 tree *); 4204 extern tree build_new_method_call (tree, tree, tree, tree, int, 4205 tree *, tsubst_flags_t); 4206 extern tree build_special_member_call (tree, tree, tree, tree, int, 4207 tsubst_flags_t); 4208 extern tree build_new_op (enum tree_code, int, tree, 4209 tree, tree, bool *, 4210 tsubst_flags_t); 4211 extern tree build_op_delete_call (enum tree_code, tree, tree, bool, tree, tree); 4212 extern bool can_convert (tree, tree); 4213 extern bool can_convert_arg (tree, tree, tree, int); 4214 extern bool can_convert_arg_bad (tree, tree, tree); 4215 extern bool enforce_access (tree, tree, tree); 4216 extern tree convert_default_arg (tree, tree, tree, int); 4217 extern tree convert_arg_to_ellipsis (tree); 4218 extern tree build_x_va_arg (tree, tree); 4219 extern tree cxx_type_promotes_to (tree); 4220 extern tree type_passed_as (tree); 4221 extern tree convert_for_arg_passing (tree, tree); 4222 extern bool is_properly_derived_from (tree, tree); 4223 extern tree set_up_extended_ref_temp (tree, tree, tree *, tree *); 4224 extern tree initialize_reference (tree, tree, tree, tree *); 4225 extern tree make_temporary_var_for_ref_to_temp (tree, tree); 4226 extern tree strip_top_quals (tree); 4227 extern tree perform_implicit_conversion (tree, tree, tsubst_flags_t); 4228 extern tree perform_direct_initialization_if_possible (tree, tree, bool, 4229 tsubst_flags_t); 4230 extern tree in_charge_arg_for_name (tree); 4231 extern tree build_cxx_call (tree, int, tree *); 4232 extern bool is_std_init_list (tree); 4233 extern bool is_list_ctor (tree); 4234 #ifdef ENABLE_CHECKING 4235 extern void validate_conversion_obstack (void); 4236 #endif /* ENABLE_CHECKING */ 4237 4238 /* in class.c */ 4239 extern tree build_base_path (enum tree_code, tree, 4240 tree, int); 4241 extern tree convert_to_base (tree, tree, bool, bool); 4242 extern tree convert_to_base_statically (tree, tree); 4243 extern tree build_vtbl_ref (tree, tree); 4244 extern tree build_vfn_ref (tree, tree); 4245 extern tree get_vtable_decl (tree, int); 4246 extern void resort_type_method_vec (void *, void *, 4247 gt_pointer_operator, void *); 4248 extern bool add_method (tree, tree, tree); 4249 extern bool currently_open_class (tree); 4250 extern tree currently_open_derived_class (tree); 4251 extern tree finish_struct (tree, tree); 4252 extern void finish_struct_1 (tree); 4253 extern int resolves_to_fixed_type_p (tree, int *); 4254 extern void init_class_processing (void); 4255 extern int is_empty_class (tree); 4256 extern bool is_really_empty_class (tree); 4257 extern void pushclass (tree); 4258 extern void popclass (void); 4259 extern void push_nested_class (tree); 4260 extern void pop_nested_class (void); 4261 extern int current_lang_depth (void); 4262 extern void push_lang_context (tree); 4263 extern void pop_lang_context (void); 4264 extern tree instantiate_type (tree, tree, tsubst_flags_t); 4265 extern void print_class_statistics (void); 4266 extern void cxx_print_statistics (void); 4267 extern void cxx_print_xnode (FILE *, tree, int); 4268 extern void cxx_print_decl (FILE *, tree, int); 4269 extern void cxx_print_type (FILE *, tree, int); 4270 extern void cxx_print_identifier (FILE *, tree, int); 4271 extern void cxx_print_error_function (struct diagnostic_context *, 4272 const char *, 4273 struct diagnostic_info *); 4274 extern void build_self_reference (void); 4275 extern int same_signature_p (const_tree, const_tree); 4276 extern void maybe_add_class_template_decl_list (tree, tree, int); 4277 extern void unreverse_member_declarations (tree); 4278 extern void invalidate_class_lookup_cache (void); 4279 extern void maybe_note_name_used_in_class (tree, tree); 4280 extern void note_name_declared_in_class (tree, tree); 4281 extern tree get_vtbl_decl_for_binfo (tree); 4282 extern void debug_class (tree); 4283 extern void debug_thunks (tree); 4284 extern tree cp_fold_obj_type_ref (tree, tree); 4285 extern void set_linkage_according_to_type (tree, tree); 4286 extern void determine_key_method (tree); 4287 extern void check_for_override (tree, tree); 4288 extern void push_class_stack (void); 4289 extern void pop_class_stack (void); 4290 extern bool type_has_user_nondefault_constructor (tree); 4291 extern bool type_has_user_provided_constructor (tree); 4292 extern bool type_has_user_provided_default_constructor (tree); 4293 extern bool defaultable_fn_p (tree); 4294 4295 /* in cvt.c */ 4296 extern tree convert_to_reference (tree, tree, int, int, tree); 4297 extern tree convert_from_reference (tree); 4298 extern tree force_rvalue (tree); 4299 extern tree ocp_convert (tree, tree, int, int); 4300 extern tree cp_convert (tree, tree); 4301 extern tree cp_convert_and_check (tree, tree); 4302 extern tree convert_to_void (tree, const char */*implicit context*/, 4303 tsubst_flags_t); 4304 extern tree convert_force (tree, tree, int); 4305 extern tree build_expr_type_conversion (int, tree, bool); 4306 extern tree type_promotes_to (tree); 4307 extern tree perform_qualification_conversions (tree, tree); 4308 extern void clone_function_decl (tree, int); 4309 extern void adjust_clone_args (tree); 4310 4311 /* decl.c */ 4312 extern tree poplevel (int, int, int); 4313 extern void insert_block (tree); 4314 extern tree pushdecl (tree); 4315 extern tree pushdecl_maybe_friend (tree, bool); 4316 extern void cxx_init_decl_processing (void); 4317 enum cp_tree_node_structure_enum cp_tree_node_structure 4318 (union lang_tree_node *); 4319 extern bool cxx_mark_addressable (tree); 4320 extern void maybe_push_cleanup_level (tree); 4321 extern void finish_scope (void); 4322 extern void push_switch (tree); 4323 extern void pop_switch (void); 4324 extern tree pushtag (tree, tree, tag_scope); 4325 extern tree make_anon_name (void); 4326 extern int decls_match (tree, tree); 4327 extern tree duplicate_decls (tree, tree, bool); 4328 extern tree pushdecl_top_level_maybe_friend (tree, bool); 4329 extern tree pushdecl_top_level_and_finish (tree, tree); 4330 extern tree declare_local_label (tree); 4331 extern tree define_label (location_t, tree); 4332 extern void check_goto (tree); 4333 extern bool check_omp_return (void); 4334 extern tree make_typename_type (tree, tree, enum tag_types, tsubst_flags_t); 4335 extern tree make_unbound_class_template (tree, tree, tree, tsubst_flags_t); 4336 extern tree check_for_out_of_scope_variable (tree); 4337 extern tree build_library_fn_ptr (const char *, tree); 4338 extern tree build_cp_library_fn_ptr (const char *, tree); 4339 extern tree push_library_fn (tree, tree, tree); 4340 extern tree push_void_library_fn (tree, tree); 4341 extern tree push_throw_library_fn (tree, tree); 4342 extern tree check_tag_decl (cp_decl_specifier_seq *); 4343 extern tree shadow_tag (cp_decl_specifier_seq *); 4344 extern tree groktypename (cp_decl_specifier_seq *, const cp_declarator *, bool); 4345 extern tree start_decl (const cp_declarator *, cp_decl_specifier_seq *, int, tree, tree, tree *); 4346 extern void start_decl_1 (tree, bool); 4347 extern bool check_array_initializer (tree, tree, tree); 4348 extern void cp_finish_decl (tree, tree, bool, tree, int); 4349 extern void finish_decl (tree, tree, tree); 4350 extern int cp_complete_array_type (tree *, tree, bool); 4351 extern tree build_ptrmemfunc_type (tree); 4352 extern tree build_ptrmem_type (tree, tree); 4353 /* the grokdeclarator prototype is in decl.h */ 4354 extern tree build_this_parm (tree, cp_cv_quals); 4355 extern int copy_fn_p (const_tree); 4356 extern bool move_fn_p (const_tree); 4357 extern tree get_scope_of_declarator (const cp_declarator *); 4358 extern void grok_special_member_properties (tree); 4359 extern int grok_ctor_properties (const_tree, const_tree); 4360 extern bool grok_op_properties (tree, bool); 4361 extern tree xref_tag (enum tag_types, tree, tag_scope, bool); 4362 extern tree xref_tag_from_type (tree, tree, tag_scope); 4363 extern bool xref_basetypes (tree, tree); 4364 extern tree start_enum (tree, tree, bool); 4365 extern void finish_enum (tree); 4366 extern void build_enumerator (tree, tree, tree); 4367 extern tree lookup_enumerator (tree, tree); 4368 extern void start_preparsed_function (tree, tree, int); 4369 extern int start_function (cp_decl_specifier_seq *, const cp_declarator *, tree); 4370 extern tree begin_function_body (void); 4371 extern void finish_function_body (tree); 4372 extern tree outer_curly_brace_block (tree); 4373 extern tree finish_function (int); 4374 extern tree start_method (cp_decl_specifier_seq *, const cp_declarator *, tree); 4375 extern tree finish_method (tree); 4376 extern void maybe_register_incomplete_var (tree); 4377 extern void maybe_commonize_var (tree); 4378 extern void complete_vars (tree); 4379 extern void finish_stmt (void); 4380 extern void print_other_binding_stack (struct cp_binding_level *); 4381 extern void revert_static_member_fn (tree); 4382 extern void fixup_anonymous_aggr (tree); 4383 extern int check_static_variable_definition (tree, tree); 4384 extern tree compute_array_index_type (tree, tree); 4385 extern tree check_default_argument (tree, tree); 4386 typedef int (*walk_namespaces_fn) (tree, void *); 4387 extern int walk_namespaces (walk_namespaces_fn, 4388 void *); 4389 extern int wrapup_globals_for_namespace (tree, void *); 4390 extern tree create_implicit_typedef (tree, tree); 4391 extern tree maybe_push_decl (tree); 4392 extern tree force_target_expr (tree, tree); 4393 extern tree build_target_expr_with_type (tree, tree); 4394 extern int local_variable_p (const_tree); 4395 extern tree register_dtor_fn (tree); 4396 extern tmpl_spec_kind current_tmpl_spec_kind (int); 4397 extern tree cp_fname_init (const char *, tree *); 4398 extern tree cxx_builtin_function (tree decl); 4399 extern tree cxx_builtin_function_ext_scope (tree decl); 4400 extern tree check_elaborated_type_specifier (enum tag_types, tree, bool); 4401 extern void warn_extern_redeclared_static (tree, tree); 4402 extern const char *cxx_comdat_group (tree); 4403 extern bool cp_missing_noreturn_ok_p (tree); 4404 extern void initialize_artificial_var (tree, tree); 4405 extern tree check_var_type (tree, tree); 4406 extern tree reshape_init (tree, tree); 4407 4408 extern bool defer_mark_used_calls; 4409 extern GTY(()) VEC(tree, gc) *deferred_mark_used_calls; 4410 4411 /* in decl2.c */ 4412 extern bool check_java_method (tree); 4413 extern tree build_memfn_type (tree, tree, cp_cv_quals); 4414 extern void maybe_retrofit_in_chrg (tree); 4415 extern void maybe_make_one_only (tree); 4416 extern void grokclassfn (tree, tree, 4417 enum overload_flags); 4418 extern tree grok_array_decl (tree, tree); 4419 extern tree delete_sanity (tree, tree, bool, int); 4420 extern tree check_classfn (tree, tree, tree); 4421 extern void check_member_template (tree); 4422 extern tree grokfield (const cp_declarator *, cp_decl_specifier_seq *, 4423 tree, bool, tree, tree); 4424 extern tree grokbitfield (const cp_declarator *, cp_decl_specifier_seq *, 4425 tree, tree); 4426 extern tree cp_reconstruct_complex_type (tree, tree); 4427 extern void cplus_decl_attributes (tree *, tree, int); 4428 extern void finish_anon_union (tree); 4429 extern void cp_write_global_declarations (void); 4430 extern void cp_process_pending_declarations (location_t); 4431 extern void cp_clear_deferred_fns (void); 4432 extern void cp_clear_conv_type_map (void); 4433 extern tree coerce_new_type (tree); 4434 extern tree coerce_delete_type (tree); 4435 extern void comdat_linkage (tree); 4436 extern void determine_visibility (tree); 4437 extern void constrain_class_visibility (tree); 4438 extern void update_member_visibility (tree); 4439 extern void import_export_decl (tree); 4440 extern tree build_cleanup (tree); 4441 extern tree build_offset_ref_call_from_tree (tree, tree); 4442 extern void check_default_args (tree); 4443 extern void mark_used (tree); 4444 extern void finish_static_data_member_decl (tree, tree, bool, tree, int); 4445 extern tree cp_build_parm_decl (tree, tree); 4446 extern tree get_guard (tree); 4447 extern tree get_guard_cond (tree); 4448 extern tree set_guard (tree); 4449 extern tree cxx_callgraph_analyze_expr (tree *, int *); 4450 extern void mark_needed (tree); 4451 extern bool decl_needed_p (tree); 4452 extern void note_vague_linkage_fn (tree); 4453 extern tree build_artificial_parm (tree, tree); 4454 extern bool possibly_inlined_p (tree); 4455 extern int parm_index (tree); 4456 4457 /* in error.c */ 4458 extern void init_error (void); 4459 extern const char *type_as_string (tree, int); 4460 extern const char *decl_as_string (tree, int); 4461 extern const char *expr_as_string (tree, int); 4462 extern const char *lang_decl_name (tree, int); 4463 extern const char *language_to_string (enum languages); 4464 extern const char *class_key_or_enum_as_string (tree); 4465 extern void print_instantiation_context (void); 4466 extern void maybe_warn_variadic_templates (void); 4467 extern void maybe_warn_cpp0x (const char *); 4468 4469 /* in except.c */ 4470 extern void init_exception_processing (void); 4471 extern tree expand_start_catch_block (tree); 4472 extern void expand_end_catch_block (void); 4473 extern tree build_exc_ptr (void); 4474 extern tree build_throw (tree); 4475 extern int nothrow_libfn_p (const_tree); 4476 extern void check_handlers (tree); 4477 extern void choose_personality_routine (enum languages); 4478 extern tree eh_type_info (tree); 4479 4480 /* in expr.c */ 4481 extern tree cplus_expand_constant (tree); 4482 4483 /* friend.c */ 4484 extern int is_friend (tree, tree); 4485 extern void make_friend_class (tree, tree, bool); 4486 extern void add_friend (tree, tree, bool); 4487 extern tree do_friend (tree, tree, tree, tree, enum overload_flags, bool); 4488 4489 /* in init.c */ 4490 extern tree expand_member_init (tree); 4491 extern void emit_mem_initializers (tree); 4492 extern tree build_aggr_init (tree, tree, int, 4493 tsubst_flags_t); 4494 extern int is_class_type (tree, int); 4495 extern tree get_type_value (tree); 4496 extern tree build_zero_init (tree, tree, bool); 4497 extern tree build_value_init (tree); 4498 extern tree build_value_init_noctor (tree); 4499 extern tree build_offset_ref (tree, tree, bool); 4500 extern tree build_new (tree, tree, tree, tree, int, 4501 tsubst_flags_t); 4502 extern tree build_vec_init (tree, tree, tree, bool, int, 4503 tsubst_flags_t); 4504 extern tree build_delete (tree, tree, 4505 special_function_kind, 4506 int, int); 4507 extern void push_base_cleanups (void); 4508 extern tree build_vec_delete (tree, tree, 4509 special_function_kind, int); 4510 extern tree create_temporary_var (tree); 4511 extern void initialize_vtbl_ptrs (tree); 4512 extern tree build_java_class_ref (tree); 4513 extern tree integral_constant_value (tree); 4514 4515 /* in lex.c */ 4516 extern void cxx_dup_lang_specific_decl (tree); 4517 extern void yyungetc (int, int); 4518 4519 extern tree unqualified_name_lookup_error (tree); 4520 extern tree unqualified_fn_lookup_error (tree); 4521 extern tree build_lang_decl (enum tree_code, tree, tree); 4522 extern void retrofit_lang_decl (tree); 4523 extern tree copy_decl (tree); 4524 extern tree copy_type (tree); 4525 extern tree cxx_make_type (enum tree_code); 4526 extern tree make_class_type (enum tree_code); 4527 extern void yyerror (const char *); 4528 extern void yyhook (int); 4529 extern bool cxx_init (void); 4530 extern void cxx_finish (void); 4531 extern bool in_main_input_context (void); 4532 4533 /* in method.c */ 4534 extern void init_method (void); 4535 extern tree make_thunk (tree, bool, tree, tree); 4536 extern void finish_thunk (tree); 4537 extern void use_thunk (tree, bool); 4538 extern void synthesize_method (tree); 4539 extern tree lazily_declare_fn (special_function_kind, 4540 tree); 4541 extern tree skip_artificial_parms_for (const_tree, tree); 4542 extern int num_artificial_parms_for (const_tree); 4543 extern tree make_alias_for (tree, tree); 4544 extern tree locate_copy (tree, void *); 4545 extern tree locate_ctor (tree, void *); 4546 extern tree locate_dtor (tree, void *); 4547 4548 /* In optimize.c */ 4549 extern bool maybe_clone_body (tree); 4550 4551 /* in pt.c */ 4552 extern bool check_template_shadow (tree); 4553 extern tree get_innermost_template_args (tree, int); 4554 extern void maybe_begin_member_template_processing (tree); 4555 extern void maybe_end_member_template_processing (void); 4556 extern tree finish_member_template_decl (tree); 4557 extern void begin_template_parm_list (void); 4558 extern bool begin_specialization (void); 4559 extern void reset_specialization (void); 4560 extern void end_specialization (void); 4561 extern void begin_explicit_instantiation (void); 4562 extern void end_explicit_instantiation (void); 4563 extern tree check_explicit_specialization (tree, tree, int, int); 4564 extern tree make_auto (void); 4565 extern tree do_auto_deduction (tree, tree, tree); 4566 extern tree type_uses_auto (tree); 4567 extern tree splice_late_return_type (tree, tree); 4568 extern bool is_auto (const_tree); 4569 extern tree process_template_parm (tree, tree, bool, bool); 4570 extern tree end_template_parm_list (tree); 4571 extern void end_template_decl (void); 4572 extern bool check_default_tmpl_args (tree, tree, int, int, int); 4573 extern tree push_template_decl (tree); 4574 extern tree push_template_decl_real (tree, bool); 4575 extern bool redeclare_class_template (tree, tree); 4576 extern tree lookup_template_class (tree, tree, tree, tree, 4577 int, tsubst_flags_t); 4578 extern tree lookup_template_function (tree, tree); 4579 extern int uses_template_parms (tree); 4580 extern int uses_template_parms_level (tree, int); 4581 extern tree instantiate_class_template (tree); 4582 extern tree instantiate_template (tree, tree, tsubst_flags_t); 4583 extern int fn_type_unification (tree, tree, tree, tree, 4584 tree, unification_kind_t, int); 4585 extern void mark_decl_instantiated (tree, int); 4586 extern int more_specialized_fn (tree, tree, int); 4587 extern void do_decl_instantiation (tree, tree); 4588 extern void do_type_instantiation (tree, tree, tsubst_flags_t); 4589 extern tree instantiate_decl (tree, int, bool); 4590 extern int comp_template_parms (const_tree, const_tree); 4591 extern bool uses_parameter_packs (tree); 4592 extern bool template_parameter_pack_p (const_tree); 4593 extern tree make_pack_expansion (tree); 4594 extern bool check_for_bare_parameter_packs (tree); 4595 extern tree get_template_info (tree); 4596 extern int template_class_depth (tree); 4597 extern int is_specialization_of (tree, tree); 4598 extern bool is_specialization_of_friend (tree, tree); 4599 extern int comp_template_args (tree, tree); 4600 extern tree maybe_process_partial_specialization (tree); 4601 extern tree most_specialized_instantiation (tree); 4602 extern void print_candidates (tree); 4603 extern void instantiate_pending_templates (int); 4604 extern tree tsubst_default_argument (tree, tree, tree); 4605 extern tree tsubst_copy_and_build (tree, tree, tsubst_flags_t, 4606 tree, bool, bool); 4607 extern tree most_general_template (tree); 4608 extern tree get_mostly_instantiated_function_type (tree); 4609 extern int problematic_instantiation_changed (void); 4610 extern void record_last_problematic_instantiation (void); 4611 extern struct tinst_level *current_instantiation(void); 4612 extern tree maybe_get_template_decl_from_type_decl (tree); 4613 extern int processing_template_parmlist; 4614 extern bool dependent_type_p (tree); 4615 extern bool dependent_scope_p (tree); 4616 extern bool any_dependent_template_arguments_p (const_tree); 4617 extern bool dependent_template_p (tree); 4618 extern bool dependent_template_id_p (tree, tree); 4619 extern bool type_dependent_expression_p (tree); 4620 extern bool any_type_dependent_arguments_p (const_tree); 4621 extern bool type_dependent_expression_p_push (tree); 4622 extern bool value_dependent_expression_p (tree); 4623 extern bool any_value_dependent_elements_p (const_tree); 4624 extern bool dependent_omp_for_p (tree, tree, tree, tree); 4625 extern tree resolve_typename_type (tree, bool); 4626 extern tree template_for_substitution (tree); 4627 extern tree build_non_dependent_expr (tree); 4628 extern tree build_non_dependent_args (tree); 4629 extern bool reregister_specialization (tree, tree, tree); 4630 extern tree fold_non_dependent_expr (tree); 4631 extern bool explicit_class_specialization_p (tree); 4632 extern struct tinst_level *outermost_tinst_level(void); 4633 extern bool parameter_of_template_p (tree, tree); 4634 4635 /* in repo.c */ 4636 extern void init_repo (void); 4637 extern int repo_emit_p (tree); 4638 extern bool repo_export_class_p (const_tree); 4639 extern void finish_repo (void); 4640 4641 /* in rtti.c */ 4642 /* A vector of all tinfo decls that haven't been emitted yet. */ 4643 extern GTY(()) VEC(tree,gc) *unemitted_tinfo_decls; 4644 4645 extern void init_rtti_processing (void); 4646 extern tree build_typeid (tree); 4647 extern tree get_tinfo_decl (tree); 4648 extern tree get_typeid (tree); 4649 extern tree build_headof (tree); 4650 extern tree build_dynamic_cast (tree, tree, tsubst_flags_t); 4651 extern void emit_support_tinfos (void); 4652 extern bool emit_tinfo_decl (tree); 4653 4654 /* in search.c */ 4655 extern bool accessible_base_p (tree, tree, bool); 4656 extern tree lookup_base (tree, tree, base_access, 4657 base_kind *); 4658 extern tree dcast_base_hint (tree, tree); 4659 extern int accessible_p (tree, tree, bool); 4660 extern tree lookup_field_1 (tree, tree, bool); 4661 extern tree lookup_field (tree, tree, int, bool); 4662 extern int lookup_fnfields_1 (tree, tree); 4663 extern int class_method_index_for_fn (tree, tree); 4664 extern tree lookup_fnfields (tree, tree, int); 4665 extern tree lookup_member (tree, tree, int, bool); 4666 extern int look_for_overrides (tree, tree); 4667 extern void get_pure_virtuals (tree); 4668 extern void maybe_suppress_debug_info (tree); 4669 extern void note_debug_info_needed (tree); 4670 extern void print_search_statistics (void); 4671 extern void reinit_search_statistics (void); 4672 extern tree current_scope (void); 4673 extern int at_function_scope_p (void); 4674 extern bool at_class_scope_p (void); 4675 extern bool at_namespace_scope_p (void); 4676 extern tree context_for_name_lookup (tree); 4677 extern tree lookup_conversions (tree); 4678 extern tree binfo_from_vbase (tree); 4679 extern tree binfo_for_vbase (tree, tree); 4680 extern tree look_for_overrides_here (tree, tree); 4681 #define dfs_skip_bases ((tree)1) 4682 extern tree dfs_walk_all (tree, tree (*) (tree, void *), 4683 tree (*) (tree, void *), void *); 4684 extern tree dfs_walk_once (tree, tree (*) (tree, void *), 4685 tree (*) (tree, void *), void *); 4686 extern tree binfo_via_virtual (tree, tree); 4687 extern tree build_baselink (tree, tree, tree, tree); 4688 extern tree adjust_result_of_qualified_name_lookup 4689 (tree, tree, tree); 4690 extern tree copied_binfo (tree, tree); 4691 extern tree original_binfo (tree, tree); 4692 extern int shared_member_p (tree); 4693 4694 4695 /* The representation of a deferred access check. */ 4696 4697 typedef struct deferred_access_check GTY(()) 4698 { 4699 /* The base class in which the declaration is referenced. */ 4700 tree binfo; 4701 /* The declaration whose access must be checked. */ 4702 tree decl; 4703 /* The declaration that should be used in the error message. */ 4704 tree diag_decl; 4705 } deferred_access_check; 4706 DEF_VEC_O(deferred_access_check); 4707 DEF_VEC_ALLOC_O(deferred_access_check,gc); 4708 4709 /* in semantics.c */ 4710 extern void push_deferring_access_checks (deferring_kind); 4711 extern void resume_deferring_access_checks (void); 4712 extern void stop_deferring_access_checks (void); 4713 extern void pop_deferring_access_checks (void); 4714 extern VEC (deferred_access_check,gc)* get_deferred_access_checks (void); 4715 extern void pop_to_parent_deferring_access_checks (void); 4716 extern void perform_access_checks (VEC (deferred_access_check,gc)*); 4717 extern void perform_deferred_access_checks (void); 4718 extern void perform_or_defer_access_check (tree, tree, tree); 4719 extern int stmts_are_full_exprs_p (void); 4720 extern void init_cp_semantics (void); 4721 extern tree do_poplevel (tree); 4722 extern void add_decl_expr (tree); 4723 extern tree finish_expr_stmt (tree); 4724 extern tree begin_if_stmt (void); 4725 extern void finish_if_stmt_cond (tree, tree); 4726 extern tree finish_then_clause (tree); 4727 extern void begin_else_clause (tree); 4728 extern void finish_else_clause (tree); 4729 extern void finish_if_stmt (tree); 4730 extern tree begin_while_stmt (void); 4731 extern void finish_while_stmt_cond (tree, tree); 4732 extern void finish_while_stmt (tree); 4733 extern tree begin_do_stmt (void); 4734 extern void finish_do_body (tree); 4735 extern void finish_do_stmt (tree, tree); 4736 extern tree finish_return_stmt (tree); 4737 extern tree begin_for_stmt (void); 4738 extern void finish_for_init_stmt (tree); 4739 extern void finish_for_cond (tree, tree); 4740 extern void finish_for_expr (tree, tree); 4741 extern void finish_for_stmt (tree); 4742 extern tree finish_break_stmt (void); 4743 extern tree finish_continue_stmt (void); 4744 extern tree begin_switch_stmt (void); 4745 extern void finish_switch_cond (tree, tree); 4746 extern void finish_switch_stmt (tree); 4747 extern tree finish_case_label (tree, tree); 4748 extern tree finish_goto_stmt (tree); 4749 extern tree begin_try_block (void); 4750 extern void finish_try_block (tree); 4751 extern tree begin_eh_spec_block (void); 4752 extern void finish_eh_spec_block (tree, tree); 4753 extern void finish_handler_sequence (tree); 4754 extern tree begin_function_try_block (tree *); 4755 extern void finish_function_try_block (tree); 4756 extern void finish_function_handler_sequence (tree, tree); 4757 extern void finish_cleanup_try_block (tree); 4758 extern tree begin_handler (void); 4759 extern void finish_handler_parms (tree, tree); 4760 extern void finish_handler (tree); 4761 extern void finish_cleanup (tree, tree); 4762 4763 enum { 4764 BCS_NO_SCOPE = 1, 4765 BCS_TRY_BLOCK = 2, 4766 BCS_FN_BODY = 4 4767 }; 4768 extern tree begin_compound_stmt (unsigned int); 4769 4770 extern void finish_compound_stmt (tree); 4771 extern tree finish_asm_stmt (int, tree, tree, tree, tree); 4772 extern tree finish_label_stmt (tree); 4773 extern void finish_label_decl (tree); 4774 extern tree finish_parenthesized_expr (tree); 4775 extern tree finish_non_static_data_member (tree, tree, tree); 4776 extern tree begin_stmt_expr (void); 4777 extern tree finish_stmt_expr_expr (tree, tree); 4778 extern tree finish_stmt_expr (tree, bool); 4779 extern tree stmt_expr_value_expr (tree); 4780 extern tree perform_koenig_lookup (tree, tree); 4781 extern tree finish_call_expr (tree, tree, bool, bool, 4782 tsubst_flags_t); 4783 extern tree finish_increment_expr (tree, enum tree_code); 4784 extern tree finish_this_expr (void); 4785 extern tree finish_pseudo_destructor_expr (tree, tree, tree); 4786 extern tree finish_unary_op_expr (enum tree_code, tree); 4787 extern tree finish_compound_literal (tree, tree); 4788 extern tree finish_fname (tree); 4789 extern void finish_translation_unit (void); 4790 extern tree finish_template_type_parm (tree, tree); 4791 extern tree finish_template_template_parm (tree, tree); 4792 extern tree begin_class_definition (tree, tree); 4793 extern void finish_template_decl (tree); 4794 extern tree finish_template_type (tree, tree, int); 4795 extern tree finish_base_specifier (tree, tree, bool); 4796 extern void finish_member_declaration (tree); 4797 extern void qualified_name_lookup_error (tree, tree, tree, 4798 location_t); 4799 extern void check_template_keyword (tree); 4800 extern tree finish_id_expression (tree, tree, tree, 4801 cp_id_kind *, 4802 bool, bool, bool *, 4803 bool, bool, bool, bool, 4804 const char **, 4805 location_t); 4806 extern tree finish_typeof (tree); 4807 extern tree finish_offsetof (tree); 4808 extern void finish_decl_cleanup (tree, tree); 4809 extern void finish_eh_cleanup (tree); 4810 extern void emit_associated_thunks (tree); 4811 extern void finish_mem_initializers (tree); 4812 extern tree check_template_template_default_arg (tree); 4813 extern void expand_or_defer_fn (tree); 4814 extern void check_accessibility_of_qualified_id (tree, tree, tree); 4815 extern tree finish_qualified_id_expr (tree, tree, bool, bool, 4816 bool, bool); 4817 extern void simplify_aggr_init_expr (tree *); 4818 extern void finalize_nrv (tree *, tree, tree); 4819 extern void note_decl_for_pch (tree); 4820 extern tree finish_omp_clauses (tree); 4821 extern void finish_omp_threadprivate (tree); 4822 extern tree begin_omp_structured_block (void); 4823 extern tree finish_omp_structured_block (tree); 4824 extern tree begin_omp_parallel (void); 4825 extern tree finish_omp_parallel (tree, tree); 4826 extern tree begin_omp_task (void); 4827 extern tree finish_omp_task (tree, tree); 4828 extern tree finish_omp_for (location_t, tree, tree, 4829 tree, tree, tree, tree, tree); 4830 extern void finish_omp_atomic (enum tree_code, tree, tree); 4831 extern void finish_omp_barrier (void); 4832 extern void finish_omp_flush (void); 4833 extern void finish_omp_taskwait (void); 4834 extern enum omp_clause_default_kind cxx_omp_predetermined_sharing (tree); 4835 extern tree cxx_omp_clause_default_ctor (tree, tree, tree); 4836 extern tree cxx_omp_clause_copy_ctor (tree, tree, tree); 4837 extern tree cxx_omp_clause_assign_op (tree, tree, tree); 4838 extern tree cxx_omp_clause_dtor (tree, tree); 4839 extern void cxx_omp_finish_clause (tree); 4840 extern bool cxx_omp_privatize_by_reference (const_tree); 4841 extern bool cxx_omp_create_clause_info (tree, tree, bool, bool, bool); 4842 extern tree baselink_for_fns (tree); 4843 extern void finish_static_assert (tree, tree, location_t, 4844 bool); 4845 extern tree describable_type (tree); 4846 extern tree finish_decltype_type (tree, bool); 4847 extern tree finish_trait_expr (enum cp_trait_kind, tree, tree); 4848 4849 /* in tree.c */ 4850 extern void lang_check_failed (const char *, int, 4851 const char *) ATTRIBUTE_NORETURN; 4852 extern tree stabilize_expr (tree, tree *); 4853 extern void stabilize_call (tree, tree *); 4854 extern void stabilize_aggr_init (tree, tree *); 4855 extern bool stabilize_init (tree, tree *); 4856 extern tree add_stmt_to_compound (tree, tree); 4857 extern tree cxx_maybe_build_cleanup (tree); 4858 extern void init_tree (void); 4859 extern int pod_type_p (const_tree); 4860 extern bool class_tmpl_impl_spec_p (const_tree); 4861 extern int zero_init_p (const_tree); 4862 extern tree canonical_type_variant (tree); 4863 extern tree copy_binfo (tree, tree, tree, 4864 tree *, int); 4865 extern int member_p (const_tree); 4866 extern cp_lvalue_kind real_lvalue_p (tree); 4867 extern bool builtin_valid_in_constant_expr_p (const_tree); 4868 extern tree build_min (enum tree_code, tree, ...); 4869 extern tree build_min_nt (enum tree_code, ...); 4870 extern tree build_min_non_dep (enum tree_code, tree, ...); 4871 extern tree build_min_non_dep_call_list (tree, tree, tree); 4872 extern tree build_cplus_new (tree, tree); 4873 extern tree build_aggr_init_expr (tree, tree); 4874 extern tree get_target_expr (tree); 4875 extern tree build_cplus_array_type (tree, tree); 4876 extern tree build_array_of_n_type (tree, int); 4877 extern tree hash_tree_cons (tree, tree, tree); 4878 extern tree hash_tree_chain (tree, tree); 4879 extern tree build_qualified_name (tree, tree, tree, bool); 4880 extern int is_overloaded_fn (tree); 4881 extern tree get_first_fn (tree); 4882 extern tree ovl_cons (tree, tree); 4883 extern tree build_overload (tree, tree); 4884 extern const char *cxx_printable_name (tree, int); 4885 extern tree build_exception_variant (tree, tree); 4886 extern tree bind_template_template_parm (tree, tree); 4887 extern tree array_type_nelts_total (tree); 4888 extern tree array_type_nelts_top (tree); 4889 extern tree break_out_target_exprs (tree); 4890 extern tree get_type_decl (tree); 4891 extern tree decl_namespace_context (tree); 4892 extern bool decl_anon_ns_mem_p (const_tree); 4893 extern tree lvalue_type (tree); 4894 extern tree error_type (tree); 4895 extern int varargs_function_p (const_tree); 4896 extern bool really_overloaded_fn (tree); 4897 extern bool cp_tree_equal (tree, tree); 4898 extern tree no_linkage_check (tree, bool); 4899 extern void debug_binfo (tree); 4900 extern tree build_dummy_object (tree); 4901 extern tree maybe_dummy_object (tree, tree *); 4902 extern int is_dummy_object (const_tree); 4903 extern const struct attribute_spec cxx_attribute_table[]; 4904 extern tree make_ptrmem_cst (tree, tree); 4905 extern tree cp_build_type_attribute_variant (tree, tree); 4906 extern tree cp_build_reference_type (tree, bool); 4907 extern tree cp_build_qualified_type_real (tree, int, tsubst_flags_t); 4908 #define cp_build_qualified_type(TYPE, QUALS) \ 4909 cp_build_qualified_type_real ((TYPE), (QUALS), tf_warning_or_error) 4910 extern special_function_kind special_function_p (const_tree); 4911 extern int count_trees (tree); 4912 extern int char_type_p (tree); 4913 extern void verify_stmt_tree (tree); 4914 extern linkage_kind decl_linkage (tree); 4915 extern tree cp_walk_subtrees (tree*, int*, walk_tree_fn, 4916 void*, struct pointer_set_t*); 4917 #define cp_walk_tree(a,b,c,d) \ 4918 walk_tree_1 (a, b, c, d, cp_walk_subtrees) 4919 #define cp_walk_tree_without_duplicates(a,b,c) \ 4920 walk_tree_without_duplicates_1 (a, b, c, cp_walk_subtrees) 4921 extern tree fold_if_not_in_template (tree); 4922 extern tree rvalue (tree); 4923 extern tree convert_bitfield_to_declared_type (tree); 4924 extern tree cp_save_expr (tree); 4925 extern bool cast_valid_in_integral_constant_expression_p (tree); 4926 extern bool cxx_type_hash_eq (const_tree, const_tree); 4927 4928 /* in typeck.c */ 4929 extern int string_conv_p (const_tree, const_tree, int); 4930 extern tree cp_truthvalue_conversion (tree); 4931 extern tree condition_conversion (tree); 4932 extern tree require_complete_type (tree); 4933 extern tree complete_type (tree); 4934 extern tree complete_type_or_else (tree, tree); 4935 extern int type_unknown_p (const_tree); 4936 extern bool comp_except_specs (const_tree, const_tree, bool); 4937 extern bool comptypes (tree, tree, int); 4938 extern bool compparms (const_tree, const_tree); 4939 extern int comp_cv_qualification (const_tree, const_tree); 4940 extern int comp_cv_qual_signature (tree, tree); 4941 extern tree cxx_sizeof_or_alignof_expr (tree, enum tree_code, bool); 4942 extern tree cxx_sizeof_or_alignof_type (tree, enum tree_code, bool); 4943 extern tree cxx_sizeof_nowarn (tree); 4944 extern tree is_bitfield_expr_with_lowered_type (const_tree); 4945 extern tree unlowered_expr_type (const_tree); 4946 extern tree decay_conversion (tree); 4947 extern tree build_class_member_access_expr (tree, tree, tree, bool, 4948 tsubst_flags_t); 4949 extern tree finish_class_member_access_expr (tree, tree, bool, 4950 tsubst_flags_t); 4951 extern tree build_x_indirect_ref (tree, const char *, 4952 tsubst_flags_t); 4953 extern tree cp_build_indirect_ref (tree, const char *, 4954 tsubst_flags_t); 4955 extern tree build_array_ref (tree, tree, location_t); 4956 extern tree get_member_function_from_ptrfunc (tree *, tree); 4957 extern tree cp_build_function_call (tree, tree, tsubst_flags_t); 4958 extern tree build_x_binary_op (enum tree_code, tree, 4959 enum tree_code, tree, 4960 enum tree_code, bool *, 4961 tsubst_flags_t); 4962 extern tree build_x_array_ref (tree, tree, tsubst_flags_t); 4963 extern tree build_x_unary_op (enum tree_code, tree, 4964 tsubst_flags_t); 4965 extern tree cp_build_unary_op (enum tree_code, tree, int, 4966 tsubst_flags_t); 4967 extern tree unary_complex_lvalue (enum tree_code, tree); 4968 extern tree build_x_conditional_expr (tree, tree, tree, 4969 tsubst_flags_t); 4970 extern tree build_x_compound_expr_from_list (tree, const char *); 4971 extern tree build_x_compound_expr (tree, tree, tsubst_flags_t); 4972 extern tree build_compound_expr (tree, tree); 4973 extern tree cp_build_compound_expr (tree, tree, tsubst_flags_t); 4974 extern tree build_static_cast (tree, tree, tsubst_flags_t); 4975 extern tree build_reinterpret_cast (tree, tree, tsubst_flags_t); 4976 extern tree build_const_cast (tree, tree, tsubst_flags_t); 4977 extern tree build_c_cast (tree, tree); 4978 extern tree cp_build_c_cast (tree, tree, tsubst_flags_t); 4979 extern tree build_x_modify_expr (tree, enum tree_code, tree, 4980 tsubst_flags_t); 4981 extern tree cp_build_modify_expr (tree, enum tree_code, tree, 4982 tsubst_flags_t); 4983 extern tree convert_for_initialization (tree, tree, tree, int, 4984 const char *, tree, int, 4985 tsubst_flags_t); 4986 extern int comp_ptr_ttypes (tree, tree); 4987 extern bool comp_ptr_ttypes_const (tree, tree); 4988 extern int ptr_reasonably_similar (const_tree, const_tree); 4989 extern tree build_ptrmemfunc (tree, tree, int, bool); 4990 extern int cp_type_quals (const_tree); 4991 extern bool cp_type_readonly (const_tree); 4992 extern bool cp_has_mutable_p (const_tree); 4993 extern bool at_least_as_qualified_p (const_tree, const_tree); 4994 extern void cp_apply_type_quals_to_decl (int, tree); 4995 extern tree build_ptrmemfunc1 (tree, tree, tree); 4996 extern void expand_ptrmemfunc_cst (tree, tree *, tree *); 4997 extern tree type_after_usual_arithmetic_conversions (tree, tree); 4998 extern tree common_pointer_type (tree, tree); 4999 extern tree composite_pointer_type (tree, tree, tree, tree, 5000 const char*, tsubst_flags_t); 5001 extern tree merge_types (tree, tree); 5002 extern tree check_return_expr (tree, bool *); 5003 extern tree cp_build_binary_op (location_t, 5004 enum tree_code, tree, tree, 5005 tsubst_flags_t); 5006 #define cxx_sizeof(T) cxx_sizeof_or_alignof_type (T, SIZEOF_EXPR, true) 5007 extern tree build_ptrmemfunc_access_expr (tree, tree); 5008 extern tree build_address (tree); 5009 extern tree build_nop (tree, tree); 5010 extern tree non_reference (tree); 5011 extern tree lookup_anon_field (tree, tree); 5012 extern bool invalid_nonstatic_memfn_p (const_tree, tsubst_flags_t); 5013 extern tree convert_member_func_to_ptr (tree, tree); 5014 extern tree convert_ptrmem (tree, tree, bool, bool); 5015 extern int lvalue_or_else (tree, enum lvalue_use, 5016 tsubst_flags_t); 5017 extern int lvalue_p (tree); 5018 5019 /* in typeck2.c */ 5020 extern void require_complete_eh_spec_types (tree, tree); 5021 extern void cxx_incomplete_type_diagnostic (const_tree, const_tree, diagnostic_t); 5022 #undef cxx_incomplete_type_error 5023 extern void cxx_incomplete_type_error (const_tree, const_tree); 5024 #define cxx_incomplete_type_error(V,T) \ 5025 (cxx_incomplete_type_diagnostic ((V), (T), DK_ERROR)) 5026 extern tree error_not_base_type (tree, tree); 5027 extern tree binfo_or_else (tree, tree); 5028 extern void readonly_error (tree, const char *); 5029 extern void complete_type_check_abstract (tree); 5030 extern int abstract_virtuals_error (tree, tree); 5031 5032 extern tree store_init_value (tree, tree); 5033 extern void check_narrowing (tree, tree); 5034 extern tree digest_init (tree, tree); 5035 extern tree build_scoped_ref (tree, tree, tree *); 5036 extern tree build_x_arrow (tree); 5037 extern tree build_m_component_ref (tree, tree); 5038 extern tree build_functional_cast (tree, tree, tsubst_flags_t); 5039 extern tree add_exception_specifier (tree, tree, int); 5040 extern tree merge_exception_specifiers (tree, tree); 5041 5042 /* in mangle.c */ 5043 extern void init_mangle (void); 5044 extern void mangle_decl (tree); 5045 extern const char *mangle_type_string (tree); 5046 extern tree mangle_typeinfo_for_type (tree); 5047 extern tree mangle_typeinfo_string_for_type (tree); 5048 extern tree mangle_vtbl_for_type (tree); 5049 extern tree mangle_vtt_for_type (tree); 5050 extern tree mangle_ctor_vtbl_for_type (tree, tree); 5051 extern tree mangle_thunk (tree, int, tree, tree); 5052 extern tree mangle_conv_op_name_for_type (tree); 5053 extern tree mangle_guard_variable (tree); 5054 extern tree mangle_ref_init_variable (tree); 5055 extern tree mangle_compound_literal (void); 5056 5057 /* in dump.c */ 5058 extern bool cp_dump_tree (void *, tree); 5059 5060 /* In cp/cp-objcp-common.c. */ 5061 5062 extern alias_set_type cxx_get_alias_set (tree); 5063 extern bool cxx_warn_unused_global_decl (const_tree); 5064 extern tree cp_expr_size (const_tree); 5065 extern size_t cp_tree_size (enum tree_code); 5066 extern bool cp_var_mod_type_p (tree, tree); 5067 extern void cxx_initialize_diagnostics (struct diagnostic_context *); 5068 extern int cxx_types_compatible_p (tree, tree); 5069 extern void init_shadowed_var_for_decl (void); 5070 extern tree cxx_staticp (tree); 5071 5072 /* LIPO support. */ 5073 extern bool cp_is_compiler_generated_type (tree); 5074 extern void cp_clear_global_name_bindings (tree); 5075 extern bool 5076 cp_is_non_sharable_global_decl (tree, void *); 5077 extern void cp_lipo_dup_lang_type (tree, tree); 5078 extern void cp_lipo_copy_lang_type (tree, tree); 5079 extern int cp_get_lang_decl_size (tree); 5080 extern int cp_cmp_lang_type (tree, tree); 5081 extern void cp_add_built_in_decl (tree); 5082 extern void cp_save_built_in_decl_pre_parsing (void); 5083 extern void cp_restore_built_in_decl_pre_parsing (void); 5084 extern void cp_save_built_in_decl_post_parsing (void); 5085 extern void cp_restore_built_in_decl_post_parsing (void); 5086 5087 5088 /* in cp-gimplify.c */ 5089 extern int cp_gimplify_expr (tree *, gimple_seq *, 5090 gimple_seq *); 5091 extern void cp_genericize (tree); 5092 5093 /* -- end of C++ */ 5094 5095 #endif /* ! GCC_CP_TREE_H */ 5096
