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