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 Free Software Foundation, Inc. 4 Contributed by Michael Tiemann (tiemann@cygnus.com) 5 6 This file is part of GNU CC. 7 8 GNU CC is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2, or (at your option) 11 any later version. 12 13 GNU CC is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GNU CC; see the file COPYING. If not, write to 20 the Free Software Foundation, 59 Temple Place - Suite 330, 21 Boston, MA 02111-1307, USA. */ 22 23 #ifndef GCC_CP_TREE_H 24 #define GCC_CP_TREE_H 25 26 #include "function.h" 27 #include "hashtab.h" 28 #include "splay-tree.h" 29 #include "varray.h" 30 31 #ifndef __GNUC__ 32 #error "You should be using 'make bootstrap' -- see installation instructions" 33 #endif 34 35 #include "c-common.h" 36 37 struct diagnostic_context; 38 39 /* Usage of TREE_LANG_FLAG_?: 40 0: BINFO_MARKED (BINFO nodes). 41 IDENTIFIER_MARKED (IDENTIFIER_NODEs) 42 NEW_EXPR_USE_GLOBAL (in NEW_EXPR). 43 DELETE_EXPR_USE_GLOBAL (in DELETE_EXPR). 44 LOOKUP_EXPR_GLOBAL (in LOOKUP_EXPR). 45 TREE_INDIRECT_USING (in NAMESPACE_DECL). 46 ICS_USER_FLAG (in _CONV) 47 CLEANUP_P (in TRY_BLOCK) 48 AGGR_INIT_VIA_CTOR_P (in AGGR_INIT_EXPR) 49 PTRMEM_OK_P (in ADDR_EXPR, OFFSET_REF) 50 PARMLIST_ELLIPSIS_P (in PARMLIST) 51 1: IDENTIFIER_VIRTUAL_P. 52 TI_PENDING_TEMPLATE_FLAG. 53 TEMPLATE_PARMS_FOR_INLINE. 54 DELETE_EXPR_USE_VEC (in DELETE_EXPR). 55 (TREE_CALLS_NEW) (in _EXPR or _REF) (commented-out). 56 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (in _TYPE). 57 ICS_ELLIPSIS_FLAG (in _CONV) 58 BINFO_ACCESS (in BINFO) 59 DECL_INITIALIZED_P (in VAR_DECL) 60 2: IDENTIFIER_OPNAME_P. 61 TYPE_POLYMORPHIC_P (in _TYPE) 62 ICS_THIS_FLAG (in _CONV) 63 BINFO_LOST_PRIMARY_P (in BINFO) 64 TREE_PARMLIST (in TREE_LIST) 65 3: TYPE_USES_VIRTUAL_BASECLASSES (in a class TYPE). 66 BINFO_VTABLE_PATH_MARKED. 67 BINFO_PUSHDECLS_MARKED. 68 (TREE_REFERENCE_EXPR) (in NON_LVALUE_EXPR) (commented-out). 69 ICS_BAD_FLAG (in _CONV) 70 FN_TRY_BLOCK_P (in TRY_BLOCK) 71 IDENTIFIER_CTOR_OR_DTOR_P (in IDENTIFIER_NODE) 72 4: BINFO_NEW_VTABLE_MARKED. 73 TREE_HAS_CONSTRUCTOR (in INDIRECT_REF, SAVE_EXPR, CONSTRUCTOR, 74 or FIELD_DECL). 75 NEED_TEMPORARY_P (in REF_BIND, BASE_CONV) 76 IDENTIFIER_TYPENAME_P (in IDENTIFIER_NODE) 77 5: C_IS_RESERVED_WORD (in IDENTIFIER_NODE) 78 6: BINFO_ACCESS (in BINFO) 79 80 Usage of TYPE_LANG_FLAG_?: 81 0: C_TYPE_FIELDS_READONLY (in RECORD_TYPE or UNION_TYPE). 82 1: TYPE_HAS_CONSTRUCTOR. 83 2: TYPE_HAS_DESTRUCTOR. 84 3: TYPE_FOR_JAVA. 85 4: TYPE_HAS_NONTRIVIAL_DESTRUCTOR 86 5: IS_AGGR_TYPE. 87 6: TYPE_BUILT_IN. 88 89 Usage of DECL_LANG_FLAG_?: 90 0: DECL_ERROR_REPORTED (in VAR_DECL). 91 DECL_TEMPLATE_PARM_P (in PARM_DECL, CONST_DECL, TYPE_DECL, or TEMPLATE_DECL) 92 DECL_LOCAL_FUNCTION_P (in FUNCTION_DECL) 93 DECL_MUTABLE_P (in FIELD_DECL) 94 1: C_TYPEDEF_EXPLICITLY_SIGNED (in TYPE_DECL). 95 DECL_TEMPLATE_INSTANTIATED (in a VAR_DECL or a FUNCTION_DECL) 96 2: DECL_THIS_EXTERN (in VAR_DECL or FUNCTION_DECL). 97 DECL_IMPLICIT_TYPEDEF_P (in a TYPE_DECL) 98 3: DECL_IN_AGGR_P. 99 4: DECL_C_BIT_FIELD (in a FIELD_DECL) 100 DECL_VAR_MARKED_P (in a VAR_DECL) 101 DECL_SELF_REFERENCE_P (in a TYPE_DECL) 102 5: DECL_INTERFACE_KNOWN. 103 6: DECL_THIS_STATIC (in VAR_DECL or FUNCTION_DECL). 104 7: DECL_DEAD_FOR_LOCAL (in VAR_DECL). 105 DECL_THUNK_P (in a member FUNCTION_DECL) 106 107 Usage of language-independent fields in a language-dependent manner: 108 109 TREE_USED 110 This field is BINFO_INDIRECT_PRIMARY_P in a BINFO. 111 112 TYPE_ALIAS_SET 113 This field is used by TYPENAME_TYPEs, TEMPLATE_TYPE_PARMs, and so 114 forth as a substitute for the mark bits provided in `lang_type'. 115 At present, only the six low-order bits are used. 116 117 TYPE_BINFO 118 For an ENUMERAL_TYPE, this is ENUM_TEMPLATE_INFO. 119 For a FUNCTION_TYPE or METHOD_TYPE, this is TYPE_RAISES_EXCEPTIONS 120 121 BINFO_VIRTUALS 122 For a binfo, this is a TREE_LIST. There is an entry for each 123 virtual function declared either in BINFO or its direct and 124 indirect primary bases. 125 126 The BV_DELTA of each node gives the amount by which to adjust the 127 `this' pointer when calling the function. If the method is an 128 overriden version of a base class method, then it is assumed 129 that, prior to adjustment, the this pointer points to an object 130 of the base class. 131 132 The BV_VCALL_INDEX of each node, if non-NULL, gives the vtable 133 index of the vcall offset for this entry. 134 135 The BV_FN is the declaration for the virtual function itself. 136 137 BINFO_VTABLE 138 This is an expression with POINTER_TYPE that gives the value 139 to which the vptr should be initialized. Use get_vtbl_decl_for_binfo 140 to extract the VAR_DECL for the complete vtable. 141 142 DECL_ARGUMENTS 143 For a VAR_DECL this is DECL_ANON_UNION_ELEMS. 144 145 DECL_VINDEX 146 This field is NULL for a non-virtual function. For a virtual 147 function, it is eventually set to an INTEGER_CST indicating the 148 index in the vtable at which this function can be found. When 149 a virtual function is declared, but before it is known what 150 function is overriden, this field is the error_mark_node. 151 152 Temporarily, it may be set to a TREE_LIST whose TREE_VALUE is 153 the virtual function this one overrides, and whose TREE_CHAIN is 154 the old DECL_VINDEX. */ 155 156 /* Language-specific tree checkers. */ 157 158 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) 159 160 #define VAR_OR_FUNCTION_DECL_CHECK(NODE) \ 161 ({ const tree __t = (NODE); \ 162 enum tree_code const __c = TREE_CODE(__t); \ 163 if (__c != VAR_DECL && __c != FUNCTION_DECL) \ 164 tree_check_failed (__t, VAR_DECL, __FILE__, __LINE__, \ 165 __FUNCTION__); \ 166 __t; }) 167 168 #define VAR_FUNCTION_OR_PARM_DECL_CHECK(NODE) \ 169 ({ const tree __t = (NODE); \ 170 enum tree_code const __c = TREE_CODE(__t); \ 171 if (__c != VAR_DECL \ 172 && __c != FUNCTION_DECL \ 173 && __c != PARM_DECL) \ 174 tree_check_failed (__t, VAR_DECL, __FILE__, __LINE__, \ 175 __FUNCTION__); \ 176 __t; }) 177 178 #define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) \ 179 ({ const tree __t = (NODE); \ 180 enum tree_code const __c = TREE_CODE(__t); \ 181 if (__c != VAR_DECL \ 182 && __c != FUNCTION_DECL \ 183 && __c != TYPE_DECL \ 184 && __c != TEMPLATE_DECL) \ 185 tree_check_failed (__t, VAR_DECL, __FILE__, __LINE__, \ 186 __FUNCTION__); \ 187 __t; }) 188 189 #define RECORD_OR_UNION_TYPE_CHECK(NODE) \ 190 ({ const tree __t = (NODE); \ 191 enum tree_code const __c = TREE_CODE(__t); \ 192 if (__c != RECORD_TYPE && __c != UNION_TYPE) \ 193 tree_check_failed (__t, RECORD_TYPE, __FILE__, __LINE__, \ 194 __FUNCTION__); \ 195 __t; }) 196 197 #define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) \ 198 ({ const tree __t = (NODE); \ 199 enum tree_code const __c = TREE_CODE(__t); \ 200 if (__c != BOUND_TEMPLATE_TEMPLATE_PARM) \ 201 tree_check_failed (__t, BOUND_TEMPLATE_TEMPLATE_PARM, \ 202 __FILE__, __LINE__, __FUNCTION__); \ 203 __t; }) 204 205 #else /* not ENABLE_TREE_CHECKING, or not gcc */ 206 207 #define VAR_OR_FUNCTION_DECL_CHECK(NODE) (NODE) 208 #define VAR_FUNCTION_OR_PARM_DECL_CHECK(NODE) (NODE) 209 #define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) (NODE) 210 #define RECORD_OR_UNION_TYPE_CHECK(NODE) (NODE) 211 #define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) (NODE) 212 213 #endif 214 215 /* Returns TRUE if generated code should match ABI version N or 216 greater is in use. */ 217 218 #define abi_version_at_least(N) \ 219 (flag_abi_version == 0 || flag_abi_version >= (N)) 220 221 222 /* Datatype used to temporarily save C++ bindings (for implicit 223 instantiations purposes and like). Implemented in decl.c. */ 224 typedef struct cxx_saved_binding cxx_saved_binding; 225 226 /* Datatype that represents binding established by a declaration between 227 a name and a C++ entity. */ 228 typedef struct cxx_binding cxx_binding; 229 230 /* (GC-)allocate a cxx_binding object. */ 231 #define cxx_binding_make() (ggc_alloc (sizeof (cxx_binding))) 232 233 /* Zero out a cxx_binding pointed to by B. */ 234 #define cxx_binding_clear(B) memset ((B), 0, sizeof (cxx_binding)) 235 236 struct cxx_binding GTY(()) 237 { 238 /* Link to chain together various bindings for this name. */ 239 cxx_binding *previous; 240 /* The non-type entity this name is bound to. */ 241 tree value; 242 /* The type entity this name is bound to. */ 243 tree type; 244 union tree_binding_u { 245 tree GTY ((tag ("0"))) scope; 246 struct cp_binding_level * GTY ((tag ("1"))) level; 247 } GTY ((desc ("%0.has_level"))) scope; 248 unsigned has_level : 1; 249 unsigned value_is_inherited : 1; 250 unsigned is_local : 1; 251 }; 252 253 /* The type of dictionary used to map names to types declared at 254 a given scope. */ 255 typedef struct binding_table_s *binding_table; 256 typedef struct binding_entry_s *binding_entry; 257 258 /* The type of a routine repeatedly called by binding_table_foreach. */ 259 typedef void (*bt_foreach_proc) (binding_entry, void *); 260 261 struct binding_entry_s GTY(()) 262 { 263 binding_entry chain; 264 tree name; 265 tree type; 266 }; 267 268 extern void binding_table_foreach (binding_table, bt_foreach_proc, void *); 269 extern binding_entry binding_table_find (binding_table, tree); 270 extern void cxx_remember_type_decls (binding_table); 271 272 /* Language-dependent contents of an identifier. */ 273 274 struct lang_identifier GTY(()) 275 { 276 struct c_common_identifier c_common; 277 cxx_binding *namespace_bindings; 278 cxx_binding *bindings; 279 tree class_value; 280 tree class_template_info; 281 struct lang_id2 *x; 282 }; 283 284 /* In an IDENTIFIER_NODE, nonzero if this identifier is actually a 285 keyword. C_RID_CODE (node) is then the RID_* value of the keyword, 286 and C_RID_YYCODE is the token number wanted by Yacc. */ 287 288 #define C_IS_RESERVED_WORD(ID) TREE_LANG_FLAG_5 (ID) 289 290 extern const short rid_to_yy[RID_MAX]; 291 #define C_RID_YYCODE(ID) rid_to_yy[C_RID_CODE (ID)] 292 293 #define LANG_IDENTIFIER_CAST(NODE) \ 294 ((struct lang_identifier*)IDENTIFIER_NODE_CHECK (NODE)) 295 296 struct lang_id2 GTY(()) 297 { 298 tree label_value; 299 tree implicit_decl; 300 tree error_locus; 301 }; 302 303 typedef struct flagged_type_tree_s GTY(()) 304 { 305 tree t; 306 int new_type_flag; 307 tree lookups; 308 } flagged_type_tree; 309 310 typedef struct template_parm_index_s GTY(()) 311 { 312 struct tree_common common; 313 HOST_WIDE_INT index; 314 HOST_WIDE_INT level; 315 HOST_WIDE_INT orig_level; 316 tree decl; 317 } template_parm_index; 318 319 struct ptrmem_cst GTY(()) 320 { 321 struct tree_common common; 322 /* This isn't used, but the middle-end expects all constants to have 323 this field. */ 324 rtx rtl; 325 tree member; 326 }; 327 typedef struct ptrmem_cst * ptrmem_cst_t; 328 329 /* Nonzero if this binding is for a local scope, as opposed to a class 330 or namespace scope. */ 331 #define LOCAL_BINDING_P(NODE) ((NODE)->is_local) 332 333 /* Nonzero if BINDING_VALUE is from a base class of the class which is 334 currently being defined. */ 335 #define INHERITED_VALUE_BINDING_P(NODE) ((NODE)->value_is_inherited) 336 337 /* For a binding between a name and an entity at a non-local scope, 338 defines the scope where the binding is declared. (Either a class 339 _TYPE node, or a NAMESPACE_DECL.) This macro should be used only 340 for namespace-level bindings; on the IDENTIFIER_BINDING list 341 BINDING_LEVEL is used instead. */ 342 #define BINDING_SCOPE(NODE) ((NODE)->scope.scope) 343 344 /* Nonzero if NODE has BINDING_LEVEL, rather than BINDING_SCOPE. */ 345 #define BINDING_HAS_LEVEL_P(NODE) ((NODE)->has_level) 346 347 /* This is the declaration bound to the name. Possible values: 348 variable, overloaded function, namespace, template, enumerator. */ 349 #define BINDING_VALUE(NODE) ((NODE)->value) 350 351 /* If name is bound to a type, this is the type (struct, union, enum). */ 352 #define BINDING_TYPE(NODE) ((NODE)->type) 353 354 #define IDENTIFIER_GLOBAL_VALUE(NODE) \ 355 namespace_binding ((NODE), global_namespace) 356 #define SET_IDENTIFIER_GLOBAL_VALUE(NODE, VAL) \ 357 set_namespace_binding ((NODE), global_namespace, (VAL)) 358 #define IDENTIFIER_NAMESPACE_VALUE(NODE) \ 359 namespace_binding ((NODE), current_namespace) 360 #define SET_IDENTIFIER_NAMESPACE_VALUE(NODE, VAL) \ 361 set_namespace_binding ((NODE), current_namespace, (VAL)) 362 363 #define CLEANUP_P(NODE) TREE_LANG_FLAG_0 (TRY_BLOCK_CHECK (NODE)) 364 365 /* Returns nonzero iff TYPE1 and TYPE2 are the same type, in the usual 366 sense of `same'. */ 367 #define same_type_p(TYPE1, TYPE2) \ 368 comptypes ((TYPE1), (TYPE2), COMPARE_STRICT) 369 370 /* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring 371 top-level qualifiers. */ 372 #define same_type_ignoring_top_level_qualifiers_p(TYPE1, TYPE2) \ 373 same_type_p (TYPE_MAIN_VARIANT (TYPE1), TYPE_MAIN_VARIANT (TYPE2)) 374 375 /* Nonzero if we are presently building a statement tree, rather 376 than expanding each statement as we encounter it. */ 377 #define building_stmt_tree() (last_tree != NULL_TREE) 378 379 /* Returns nonzero iff NODE is a declaration for the global function 380 `main'. */ 381 #define DECL_MAIN_P(NODE) \ 382 (DECL_EXTERN_C_FUNCTION_P (NODE) \ 383 && DECL_NAME (NODE) != NULL_TREE \ 384 && MAIN_NAME_P (DECL_NAME (NODE))) 385 386 /* The overloaded FUNCTION_DECL. */ 387 #define OVL_FUNCTION(NODE) \ 388 (((struct tree_overload*)OVERLOAD_CHECK (NODE))->function) 389 #define OVL_CHAIN(NODE) TREE_CHAIN (NODE) 390 /* Polymorphic access to FUNCTION and CHAIN. */ 391 #define OVL_CURRENT(NODE) \ 392 ((TREE_CODE (NODE) == OVERLOAD) ? OVL_FUNCTION (NODE) : (NODE)) 393 #define OVL_NEXT(NODE) \ 394 ((TREE_CODE (NODE) == OVERLOAD) ? TREE_CHAIN (NODE) : NULL_TREE) 395 /* If set, this was imported in a using declaration. 396 This is not to confuse with being used somewhere, which 397 is not important for this node. */ 398 #define OVL_USED(NODE) TREE_USED (NODE) 399 400 struct tree_overload GTY(()) 401 { 402 struct tree_common common; 403 tree function; 404 }; 405 406 /* Returns true iff NODE is a BASELINK. */ 407 #define BASELINK_P(NODE) \ 408 (TREE_CODE (NODE) == BASELINK) 409 /* The BINFO indicating the base from which the BASELINK_FUNCTIONS came. */ 410 #define BASELINK_BINFO(NODE) \ 411 (TREE_OPERAND (BASELINK_CHECK (NODE), 0)) 412 /* The functions referred to by the BASELINK; either a FUNCTION_DECL, 413 a TEMPLATE_DECL, an OVERLOAD, or a TEMPLATE_ID_EXPR. */ 414 #define BASELINK_FUNCTIONS(NODE) \ 415 (TREE_OPERAND (BASELINK_CHECK (NODE), 1)) 416 /* The BINFO in which the search for the functions indicated by this baselink 417 began. This base is used to determine the accessibility of functions 418 selected by overload resolution. */ 419 #define BASELINK_ACCESS_BINFO(NODE) \ 420 (TREE_OPERAND (BASELINK_CHECK (NODE), 2)) 421 /* For a type-conversion operator, the BASELINK_OPTYPE indicates the type 422 to which the conversion should occur. This value is important if 423 the BASELINK_FUNCTIONS include a template conversion operator -- 424 the BASELINK_OPTYPE can be used to determine what type the user 425 requested. */ 426 #define BASELINK_OPTYPE(NODE) \ 427 (TREE_CHAIN (BASELINK_CHECK (NODE))) 428 429 #define WRAPPER_ZC(NODE) (((struct tree_wrapper*)WRAPPER_CHECK (NODE))->z_c) 430 431 struct tree_wrapper GTY(()) 432 { 433 struct tree_common common; 434 struct z_candidate *z_c; 435 }; 436 437 #define SRCLOC_FILE(NODE) (((struct tree_srcloc*)SRCLOC_CHECK (NODE))->filename) 438 #define SRCLOC_LINE(NODE) (((struct tree_srcloc*)SRCLOC_CHECK (NODE))->linenum) 439 struct tree_srcloc GTY(()) 440 { 441 struct tree_common common; 442 const char *filename; 443 int linenum; 444 }; 445 446 /* Macros for access to language-specific slots in an identifier. */ 447 448 #define IDENTIFIER_NAMESPACE_BINDINGS(NODE) \ 449 (LANG_IDENTIFIER_CAST (NODE)->namespace_bindings) 450 #define IDENTIFIER_TEMPLATE(NODE) \ 451 (LANG_IDENTIFIER_CAST (NODE)->class_template_info) 452 453 /* The IDENTIFIER_BINDING is the innermost cxx_binding for the 454 identifier. It's PREVIOUS is the next outermost binding. Each 455 BINDING_VALUE is a DECL for the associated declaration. Thus, 456 name lookup consists simply of pulling off the node at the front 457 of the list (modulo oddities for looking up the names of types, 458 and such.) You can use BINDING_SCOPE or BINDING_LEVEL to 459 determine the scope that bound the name. */ 460 #define IDENTIFIER_BINDING(NODE) \ 461 (LANG_IDENTIFIER_CAST (NODE)->bindings) 462 463 /* The IDENTIFIER_VALUE is the value of the IDENTIFIER_BINDING, or 464 NULL_TREE if there is no binding. */ 465 #define IDENTIFIER_VALUE(NODE) \ 466 (IDENTIFIER_BINDING (NODE) ? BINDING_VALUE (IDENTIFIER_BINDING (NODE)) : 0) 467 468 /* If IDENTIFIER_CLASS_VALUE is set, then NODE is bound in the current 469 class, and IDENTIFIER_CLASS_VALUE is the value binding. This is 470 just a pointer to the BINDING_VALUE of one of the bindings in the 471 IDENTIFIER_BINDINGs list, so any time that this is non-NULL so is 472 IDENTIFIER_BINDING. */ 473 #define IDENTIFIER_CLASS_VALUE(NODE) \ 474 (LANG_IDENTIFIER_CAST (NODE)->class_value) 475 476 /* TREE_TYPE only indicates on local and class scope the current 477 type. For namespace scope, the presence of a type in any namespace 478 is indicated with global_type_node, and the real type behind must 479 be found through lookup. */ 480 #define IDENTIFIER_TYPE_VALUE(NODE) identifier_type_value (NODE) 481 #define REAL_IDENTIFIER_TYPE_VALUE(NODE) TREE_TYPE (NODE) 482 #define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = (TYPE)) 483 #define IDENTIFIER_HAS_TYPE_VALUE(NODE) (IDENTIFIER_TYPE_VALUE (NODE) ? 1 : 0) 484 485 #define LANG_ID_FIELD(NAME, NODE) \ 486 (LANG_IDENTIFIER_CAST (NODE)->x \ 487 ? LANG_IDENTIFIER_CAST (NODE)->x->NAME : 0) 488 489 #define SET_LANG_ID(NODE, VALUE, NAME) \ 490 (LANG_IDENTIFIER_CAST (NODE)->x == 0 \ 491 ? LANG_IDENTIFIER_CAST (NODE)->x \ 492 = (struct lang_id2 *)ggc_alloc_cleared (sizeof (struct lang_id2)) : 0, \ 493 LANG_IDENTIFIER_CAST (NODE)->x->NAME = (VALUE)) 494 495 #define IDENTIFIER_LABEL_VALUE(NODE) \ 496 LANG_ID_FIELD (label_value, NODE) 497 #define SET_IDENTIFIER_LABEL_VALUE(NODE, VALUE) \ 498 SET_LANG_ID (NODE, VALUE, label_value) 499 500 #define IDENTIFIER_IMPLICIT_DECL(NODE) \ 501 LANG_ID_FIELD (implicit_decl, NODE) 502 #define SET_IDENTIFIER_IMPLICIT_DECL(NODE, VALUE) \ 503 SET_LANG_ID (NODE, VALUE, implicit_decl) 504 505 #define IDENTIFIER_ERROR_LOCUS(NODE) \ 506 LANG_ID_FIELD (error_locus, NODE) 507 #define SET_IDENTIFIER_ERROR_LOCUS(NODE, VALUE) \ 508 SET_LANG_ID (NODE, VALUE, error_locus) 509 510 /* Nonzero if this identifier is used as a virtual function name somewhere 511 (optimizes searches). */ 512 #define IDENTIFIER_VIRTUAL_P(NODE) TREE_LANG_FLAG_1 (NODE) 513 514 /* Nonzero if this identifier is the prefix for a mangled C++ operator 515 name. */ 516 #define IDENTIFIER_OPNAME_P(NODE) TREE_LANG_FLAG_2 (NODE) 517 518 /* Nonzero if this identifier is the name of a type-conversion 519 operator. */ 520 #define IDENTIFIER_TYPENAME_P(NODE) \ 521 TREE_LANG_FLAG_4 (NODE) 522 523 /* Nonzero if this identifier is the name of a constructor or 524 destructor. */ 525 #define IDENTIFIER_CTOR_OR_DTOR_P(NODE) \ 526 TREE_LANG_FLAG_3 (NODE) 527 528 /* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only. */ 529 #define C_TYPE_FIELDS_READONLY(TYPE) TYPE_LANG_FLAG_0 (TYPE) 530 531 /* Store a value in that field. */ 532 #define C_SET_EXP_ORIGINAL_CODE(EXP, CODE) \ 533 (TREE_COMPLEXITY (EXP) = (int)(CODE)) 534 535 enum cp_tree_node_structure_enum { 536 TS_CP_COMMON, 537 TS_CP_GENERIC, 538 TS_CP_IDENTIFIER, 539 TS_CP_TPI, 540 TS_CP_PTRMEM, 541 TS_CP_OVERLOAD, 542 TS_CP_WRAPPER, 543 TS_CP_SRCLOC, 544 LAST_TS_CP_ENUM 545 }; 546 547 /* The resulting tree type. */ 548 union lang_tree_node GTY((desc ("cp_tree_node_structure (&%h)"), 549 chain_next ("(union lang_tree_node *)TREE_CHAIN (&%h.generic)"))) 550 { 551 struct tree_common GTY ((tag ("TS_CP_COMMON"))) common; 552 union tree_node GTY ((tag ("TS_CP_GENERIC"), 553 desc ("tree_node_structure (&%h)"))) generic; 554 struct template_parm_index_s GTY ((tag ("TS_CP_TPI"))) tpi; 555 struct ptrmem_cst GTY ((tag ("TS_CP_PTRMEM"))) ptrmem; 556 struct tree_overload GTY ((tag ("TS_CP_OVERLOAD"))) overload; 557 struct tree_wrapper GTY ((tag ("TS_CP_WRAPPER"))) wrapper; 558 struct tree_srcloc GTY ((tag ("TS_CP_SRCLOC"))) srcloc; 559 struct lang_identifier GTY ((tag ("TS_CP_IDENTIFIER"))) identifier; 560 }; 561 562 563 enum cp_tree_index 564 { 565 CPTI_JAVA_BYTE_TYPE, 566 CPTI_JAVA_SHORT_TYPE, 567 CPTI_JAVA_INT_TYPE, 568 CPTI_JAVA_LONG_TYPE, 569 CPTI_JAVA_FLOAT_TYPE, 570 CPTI_JAVA_DOUBLE_TYPE, 571 CPTI_JAVA_CHAR_TYPE, 572 CPTI_JAVA_BOOLEAN_TYPE, 573 574 CPTI_WCHAR_DECL, 575 CPTI_VTABLE_ENTRY_TYPE, 576 CPTI_DELTA_TYPE, 577 CPTI_VTABLE_INDEX_TYPE, 578 CPTI_CLEANUP_TYPE, 579 CPTI_VTT_PARM_TYPE, 580 581 CPTI_TI_DESC_TYPE, 582 CPTI_BLTN_DESC_TYPE, 583 CPTI_PTR_DESC_TYPE, 584 CPTI_ARY_DESC_TYPE, 585 CPTI_FUNC_DESC_TYPE, 586 CPTI_ENUM_DESC_TYPE, 587 CPTI_CLASS_DESC_TYPE, 588 CPTI_SI_CLASS_DESC_TYPE, 589 CPTI_VMI_CLASS_DESC_TYPE, 590 CPTI_PTM_DESC_TYPE, 591 CPTI_BASE_DESC_TYPE, 592 593 CPTI_CLASS_TYPE, 594 CPTI_RECORD_TYPE, 595 CPTI_UNION_TYPE, 596 CPTI_ENUM_TYPE, 597 CPTI_UNKNOWN_TYPE, 598 CPTI_VTBL_TYPE, 599 CPTI_VTBL_PTR_TYPE, 600 CPTI_STD, 601 CPTI_ABI, 602 CPTI_TYPE_INFO_TYPE, 603 CPTI_TYPE_INFO_PTR_TYPE, 604 CPTI_ABORT_FNDECL, 605 CPTI_GLOBAL_DELETE_FNDECL, 606 CPTI_AGGR_TAG, 607 608 CPTI_ACCESS_DEFAULT, 609 CPTI_ACCESS_PUBLIC, 610 CPTI_ACCESS_PROTECTED, 611 CPTI_ACCESS_PRIVATE, 612 CPTI_ACCESS_DEFAULT_VIRTUAL, 613 CPTI_ACCESS_PUBLIC_VIRTUAL, 614 CPTI_ACCESS_PROTECTED_VIRTUAL, 615 CPTI_ACCESS_PRIVATE_VIRTUAL, 616 617 CPTI_CTOR_IDENTIFIER, 618 CPTI_COMPLETE_CTOR_IDENTIFIER, 619 CPTI_BASE_CTOR_IDENTIFIER, 620 CPTI_DTOR_IDENTIFIER, 621 CPTI_COMPLETE_DTOR_IDENTIFIER, 622 CPTI_BASE_DTOR_IDENTIFIER, 623 CPTI_DELETING_DTOR_IDENTIFIER, 624 CPTI_DELTA_IDENTIFIER, 625 CPTI_IN_CHARGE_IDENTIFIER, 626 CPTI_VTT_PARM_IDENTIFIER, 627 CPTI_NELTS_IDENTIFIER, 628 CPTI_THIS_IDENTIFIER, 629 CPTI_PFN_IDENTIFIER, 630 CPTI_VPTR_IDENTIFIER, 631 CPTI_STD_IDENTIFIER, 632 633 CPTI_LANG_NAME_C, 634 CPTI_LANG_NAME_CPLUSPLUS, 635 CPTI_LANG_NAME_JAVA, 636 637 CPTI_EMPTY_EXCEPT_SPEC, 638 CPTI_NULL, 639 CPTI_JCLASS, 640 CPTI_TERMINATE, 641 CPTI_CALL_UNEXPECTED, 642 CPTI_ATEXIT, 643 CPTI_DSO_HANDLE, 644 CPTI_DCAST, 645 646 CPTI_KEYED_CLASSES, 647 648 CPTI_MAX 649 }; 650 651 extern GTY(()) tree cp_global_trees[CPTI_MAX]; 652 653 #define java_byte_type_node cp_global_trees[CPTI_JAVA_BYTE_TYPE] 654 #define java_short_type_node cp_global_trees[CPTI_JAVA_SHORT_TYPE] 655 #define java_int_type_node cp_global_trees[CPTI_JAVA_INT_TYPE] 656 #define java_long_type_node cp_global_trees[CPTI_JAVA_LONG_TYPE] 657 #define java_float_type_node cp_global_trees[CPTI_JAVA_FLOAT_TYPE] 658 #define java_double_type_node cp_global_trees[CPTI_JAVA_DOUBLE_TYPE] 659 #define java_char_type_node cp_global_trees[CPTI_JAVA_CHAR_TYPE] 660 #define java_boolean_type_node cp_global_trees[CPTI_JAVA_BOOLEAN_TYPE] 661 662 #define wchar_decl_node cp_global_trees[CPTI_WCHAR_DECL] 663 #define vtable_entry_type cp_global_trees[CPTI_VTABLE_ENTRY_TYPE] 664 /* The type used to represent an offset by which to adjust the `this' 665 pointer in pointer-to-member types. */ 666 #define delta_type_node cp_global_trees[CPTI_DELTA_TYPE] 667 /* The type used to represent an index into the vtable. */ 668 #define vtable_index_type cp_global_trees[CPTI_VTABLE_INDEX_TYPE] 669 670 #define ti_desc_type_node cp_global_trees[CPTI_TI_DESC_TYPE] 671 #define bltn_desc_type_node cp_global_trees[CPTI_BLTN_DESC_TYPE] 672 #define ptr_desc_type_node cp_global_trees[CPTI_PTR_DESC_TYPE] 673 #define ary_desc_type_node cp_global_trees[CPTI_ARY_DESC_TYPE] 674 #define func_desc_type_node cp_global_trees[CPTI_FUNC_DESC_TYPE] 675 #define enum_desc_type_node cp_global_trees[CPTI_ENUM_DESC_TYPE] 676 #define class_desc_type_node cp_global_trees[CPTI_CLASS_DESC_TYPE] 677 #define si_class_desc_type_node cp_global_trees[CPTI_SI_CLASS_DESC_TYPE] 678 #define vmi_class_desc_type_node cp_global_trees[CPTI_VMI_CLASS_DESC_TYPE] 679 #define ptm_desc_type_node cp_global_trees[CPTI_PTM_DESC_TYPE] 680 #define base_desc_type_node cp_global_trees[CPTI_BASE_DESC_TYPE] 681 682 #define class_type_node cp_global_trees[CPTI_CLASS_TYPE] 683 #define record_type_node cp_global_trees[CPTI_RECORD_TYPE] 684 #define union_type_node cp_global_trees[CPTI_UNION_TYPE] 685 #define enum_type_node cp_global_trees[CPTI_ENUM_TYPE] 686 #define unknown_type_node cp_global_trees[CPTI_UNKNOWN_TYPE] 687 #define vtbl_type_node cp_global_trees[CPTI_VTBL_TYPE] 688 #define vtbl_ptr_type_node cp_global_trees[CPTI_VTBL_PTR_TYPE] 689 #define std_node cp_global_trees[CPTI_STD] 690 #define abi_node cp_global_trees[CPTI_ABI] 691 #define type_info_type_node cp_global_trees[CPTI_TYPE_INFO_TYPE] 692 #define type_info_ptr_type cp_global_trees[CPTI_TYPE_INFO_PTR_TYPE] 693 #define abort_fndecl cp_global_trees[CPTI_ABORT_FNDECL] 694 #define global_delete_fndecl cp_global_trees[CPTI_GLOBAL_DELETE_FNDECL] 695 #define current_aggr cp_global_trees[CPTI_AGGR_TAG] 696 697 /* Define the sets of attributes that member functions and baseclasses 698 can have. These are sensible combinations of {public,private,protected} 699 cross {virtual,non-virtual}. */ 700 701 #define access_default_node cp_global_trees[CPTI_ACCESS_DEFAULT] 702 #define access_public_node cp_global_trees[CPTI_ACCESS_PUBLIC] 703 #define access_protected_node cp_global_trees[CPTI_ACCESS_PROTECTED] 704 #define access_private_node cp_global_trees[CPTI_ACCESS_PRIVATE] 705 #define access_default_virtual_node cp_global_trees[CPTI_ACCESS_DEFAULT_VIRTUAL] 706 #define access_public_virtual_node cp_global_trees[CPTI_ACCESS_PUBLIC_VIRTUAL] 707 #define access_protected_virtual_node cp_global_trees[CPTI_ACCESS_PROTECTED_VIRTUAL] 708 #define access_private_virtual_node cp_global_trees[CPTI_ACCESS_PRIVATE_VIRTUAL] 709 710 /* We cache these tree nodes so as to call get_identifier less 711 frequently. */ 712 713 /* The name of a constructor that takes an in-charge parameter to 714 decide whether or not to construct virtual base classes. */ 715 #define ctor_identifier cp_global_trees[CPTI_CTOR_IDENTIFIER] 716 /* The name of a constructor that constructs virtual base classes. */ 717 #define complete_ctor_identifier cp_global_trees[CPTI_COMPLETE_CTOR_IDENTIFIER] 718 /* The name of a constructor that does not construct virtual base classes. */ 719 #define base_ctor_identifier cp_global_trees[CPTI_BASE_CTOR_IDENTIFIER] 720 /* The name of a destructor that takes an in-charge parameter to 721 decide whether or not to destroy virtual base classes and whether 722 or not to delete the object. */ 723 #define dtor_identifier cp_global_trees[CPTI_DTOR_IDENTIFIER] 724 /* The name of a destructor that destroys virtual base classes. */ 725 #define complete_dtor_identifier cp_global_trees[CPTI_COMPLETE_DTOR_IDENTIFIER] 726 /* The name of a destructor that does not destroy virtual base 727 classes. */ 728 #define base_dtor_identifier cp_global_trees[CPTI_BASE_DTOR_IDENTIFIER] 729 /* The name of a destructor that destroys virtual base classes, and 730 then deletes the entire object. */ 731 #define deleting_dtor_identifier cp_global_trees[CPTI_DELETING_DTOR_IDENTIFIER] 732 #define delta_identifier cp_global_trees[CPTI_DELTA_IDENTIFIER] 733 #define in_charge_identifier cp_global_trees[CPTI_IN_CHARGE_IDENTIFIER] 734 /* The name of the parameter that contains a pointer to the VTT to use 735 for this subobject constructor or destructor. */ 736 #define vtt_parm_identifier cp_global_trees[CPTI_VTT_PARM_IDENTIFIER] 737 #define nelts_identifier cp_global_trees[CPTI_NELTS_IDENTIFIER] 738 #define this_identifier cp_global_trees[CPTI_THIS_IDENTIFIER] 739 #define pfn_identifier cp_global_trees[CPTI_PFN_IDENTIFIER] 740 #define vptr_identifier cp_global_trees[CPTI_VPTR_IDENTIFIER] 741 /* The name of the std namespace. */ 742 #define std_identifier cp_global_trees[CPTI_STD_IDENTIFIER] 743 #define lang_name_c cp_global_trees[CPTI_LANG_NAME_C] 744 #define lang_name_cplusplus cp_global_trees[CPTI_LANG_NAME_CPLUSPLUS] 745 #define lang_name_java cp_global_trees[CPTI_LANG_NAME_JAVA] 746 747 /* Exception specifier used for throw(). */ 748 #define empty_except_spec cp_global_trees[CPTI_EMPTY_EXCEPT_SPEC] 749 750 /* The node for `__null'. */ 751 #define null_node cp_global_trees[CPTI_NULL] 752 753 /* If non-NULL, a POINTER_TYPE equivalent to (java::lang::Class*). */ 754 #define jclass_node cp_global_trees[CPTI_JCLASS] 755 756 /* The declaration for `std::terminate'. */ 757 #define terminate_node cp_global_trees[CPTI_TERMINATE] 758 759 /* The declaration for "__cxa_call_unexpected". */ 760 #define call_unexpected_node cp_global_trees[CPTI_CALL_UNEXPECTED] 761 762 /* A pointer to `std::atexit'. */ 763 #define atexit_node cp_global_trees[CPTI_ATEXIT] 764 765 /* A pointer to `__dso_handle'. */ 766 #define dso_handle_node cp_global_trees[CPTI_DSO_HANDLE] 767 768 /* The declaration of the dynamic_cast runtime. */ 769 #define dynamic_cast_node cp_global_trees[CPTI_DCAST] 770 771 /* The type of a destructor. */ 772 #define cleanup_type cp_global_trees[CPTI_CLEANUP_TYPE] 773 774 /* The type of the vtt parameter passed to subobject constructors and 775 destructors. */ 776 #define vtt_parm_type cp_global_trees[CPTI_VTT_PARM_TYPE] 777 778 /* A TREE_LIST of the dynamic classes whose vtables may have to be 779 emitted in this translation unit. */ 780 781 #define keyed_classes cp_global_trees[CPTI_KEYED_CLASSES] 782 783 /* Global state. */ 784 785 struct saved_scope GTY(()) 786 { 787 cxx_saved_binding *old_bindings; 788 tree old_namespace; 789 tree decl_ns_list; 790 tree class_name; 791 tree class_type; 792 tree access_specifier; 793 tree function_decl; 794 varray_type lang_base; 795 tree lang_name; 796 tree template_parms; 797 tree x_previous_class_type; 798 tree x_previous_class_values; 799 tree x_saved_tree; 800 tree lookups; 801 tree last_parms; 802 803 HOST_WIDE_INT x_processing_template_decl; 804 int x_processing_specialization; 805 int x_processing_explicit_instantiation; 806 int need_pop_function_context; 807 808 struct stmt_tree_s x_stmt_tree; 809 810 struct cp_binding_level *class_bindings; 811 struct cp_binding_level *bindings; 812 813 struct saved_scope *prev; 814 }; 815 816 /* The current open namespace. */ 817 818 #define current_namespace scope_chain->old_namespace 819 820 /* The stack for namespaces of current declarations. */ 821 822 #define decl_namespace_list scope_chain->decl_ns_list 823 824 /* IDENTIFIER_NODE: name of current class */ 825 826 #define current_class_name scope_chain->class_name 827 828 /* _TYPE: the type of the current class */ 829 830 #define current_class_type scope_chain->class_type 831 832 /* When parsing a class definition, the access specifier most recently 833 given by the user, or, if no access specifier was given, the 834 default value appropriate for the kind of class (i.e., struct, 835 class, or union). */ 836 837 #define current_access_specifier scope_chain->access_specifier 838 839 /* Pointer to the top of the language name stack. */ 840 841 #define current_lang_base scope_chain->lang_base 842 #define current_lang_name scope_chain->lang_name 843 844 /* Parsing a function declarator leaves a list of parameter names 845 or a chain or parameter decls here. */ 846 847 #define current_template_parms scope_chain->template_parms 848 849 #define processing_template_decl scope_chain->x_processing_template_decl 850 #define processing_specialization scope_chain->x_processing_specialization 851 #define processing_explicit_instantiation scope_chain->x_processing_explicit_instantiation 852 853 /* _TYPE: the previous type that was a class */ 854 855 #define previous_class_type scope_chain->x_previous_class_type 856 857 /* This is a copy of the class_shadowed list of the previous class 858 binding contour when at global scope. It's used to reset 859 IDENTIFIER_CLASS_VALUEs when entering another class scope (i.e. a 860 cache miss). */ 861 862 #define previous_class_values scope_chain->x_previous_class_values 863 864 /* A list of private types mentioned, for deferred access checking. */ 865 866 #define type_lookups scope_chain->lookups 867 868 extern GTY(()) struct saved_scope *scope_chain; 869 870 struct unparsed_text; 871 872 /* Global state pertinent to the current function. */ 873 874 struct language_function GTY(()) 875 { 876 struct c_language_function base; 877 878 tree x_dtor_label; 879 tree x_current_class_ptr; 880 tree x_current_class_ref; 881 tree x_eh_spec_block; 882 tree x_in_charge_parm; 883 tree x_vtt_parm; 884 tree x_return_value; 885 886 int returns_value; 887 int returns_null; 888 int returns_abnormally; 889 int in_function_try_handler; 890 int in_base_initializer; 891 int x_expanding_p; 892 893 /* True if this function can throw an exception. */ 894 bool can_throw : 1; 895 896 struct named_label_use_list *x_named_label_uses; 897 struct named_label_list *x_named_labels; 898 struct cp_binding_level *bindings; 899 varray_type x_local_names; 900 901 const char *cannot_inline; 902 struct unparsed_text *unparsed_inlines; 903 }; 904 905 /* The current C++-specific per-function global variables. */ 906 907 #define cp_function_chain (cfun->language) 908 909 /* In a destructor, the point at which all derived class destroying 910 has been done, just before any base class destroying will be done. */ 911 912 #define dtor_label cp_function_chain->x_dtor_label 913 914 /* When we're processing a member function, current_class_ptr is the 915 PARM_DECL for the `this' pointer. The current_class_ref is an 916 expression for `*this'. */ 917 918 #define current_class_ptr \ 919 (cfun ? cp_function_chain->x_current_class_ptr : NULL_TREE) 920 #define current_class_ref \ 921 (cfun ? cp_function_chain->x_current_class_ref : NULL_TREE) 922 923 /* The EH_SPEC_BLOCK for the exception-specifiers for the current 924 function, if any. */ 925 926 #define current_eh_spec_block cp_function_chain->x_eh_spec_block 927 928 /* The `__in_chrg' parameter for the current function. Only used for 929 constructors and destructors. */ 930 931 #define current_in_charge_parm cp_function_chain->x_in_charge_parm 932 933 /* The `__vtt_parm' parameter for the current function. Only used for 934 constructors and destructors. */ 935 936 #define current_vtt_parm cp_function_chain->x_vtt_parm 937 938 /* Set to 0 at beginning of a function definition, set to 1 if 939 a return statement that specifies a return value is seen. */ 940 941 #define current_function_returns_value cp_function_chain->returns_value 942 943 /* Set to 0 at beginning of a function definition, set to 1 if 944 a return statement with no argument is seen. */ 945 946 #define current_function_returns_null cp_function_chain->returns_null 947 948 /* Set to 0 at beginning of a function definition, set to 1 if 949 a call to a noreturn function is seen. */ 950 951 #define current_function_returns_abnormally \ 952 cp_function_chain->returns_abnormally 953 954 /* Nonzero if we should generate RTL for functions that we process. 955 When this is zero, we just accumulate tree structure, without 956 interacting with the back end. */ 957 958 #define expanding_p cp_function_chain->x_expanding_p 959 960 /* Nonzero if we are in the semantic analysis phase for the current 961 function. */ 962 963 #define doing_semantic_analysis_p() (!expanding_p) 964 965 /* Non-zero if we are processing a base initializer. Zero elsewhere. */ 966 #define in_base_initializer cp_function_chain->in_base_initializer 967 968 #define in_function_try_handler cp_function_chain->in_function_try_handler 969 970 /* Expression always returned from function, or error_mark_node 971 otherwise, for use by the automatic named return value optimization. */ 972 973 #define current_function_return_value \ 974 (cp_function_chain->x_return_value) 975 976 extern GTY(()) tree global_namespace; 977 978 #define ansi_opname(CODE) \ 979 (operator_name_info[(int) (CODE)].identifier) 980 #define ansi_assopname(CODE) \ 981 (assignment_operator_name_info[(int) (CODE)].identifier) 982 983 /* True if NODE is an erroneous expression. */ 984 985 #define error_operand_p(NODE) \ 986 ((NODE) == error_mark_node \ 987 || ((NODE) && TREE_TYPE ((NODE)) == error_mark_node)) 988 989 /* INTERFACE_ONLY nonzero means that we are in an "interface" 990 section of the compiler. INTERFACE_UNKNOWN nonzero means 991 we cannot trust the value of INTERFACE_ONLY. If INTERFACE_UNKNOWN 992 is zero and INTERFACE_ONLY is zero, it means that we are responsible 993 for exporting definitions that others might need. */ 994 extern int interface_only, interface_unknown; 995 996 /* C++ language-specific tree codes. */ 997 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) SYM, 998 enum cplus_tree_code { 999 CP_DUMMY_TREE_CODE = LAST_C_TREE_CODE, 1000 #include "cp-tree.def" 1001 LAST_CPLUS_TREE_CODE 1002 }; 1003 #undef DEFTREECODE 1004 1005 enum languages { lang_c, lang_cplusplus, lang_java }; 1006 1007 /* Macros to make error reporting functions' lives easier. */ 1008 #define TYPE_IDENTIFIER(NODE) (DECL_NAME (TYPE_NAME (NODE))) 1009 #define TYPE_LINKAGE_IDENTIFIER(NODE) \ 1010 (TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (NODE))) 1011 #define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (TYPE_IDENTIFIER (NODE))) 1012 #define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (TYPE_IDENTIFIER (NODE))) 1013 1014 #define TYPE_ASSEMBLER_NAME_STRING(NODE) \ 1015 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (TYPE_NAME (NODE)))) 1016 #define TYPE_ASSEMBLER_NAME_LENGTH(NODE) \ 1017 (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (TYPE_NAME (NODE)))) 1018 1019 /* Nonzero if NODE has no name for linkage purposes. */ 1020 #define TYPE_ANONYMOUS_P(NODE) \ 1021 (TAGGED_TYPE_P (NODE) && ANON_AGGRNAME_P (TYPE_LINKAGE_IDENTIFIER (NODE))) 1022 1023 /* The _DECL for this _TYPE. */ 1024 #define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE))) 1025 1026 /* Nonzero if T is a class (or struct or union) type. Also nonzero 1027 for template type parameters, typename types, and instantiated 1028 template template parameters. Despite its name, 1029 this macro has nothing to do with the definition of aggregate given 1030 in the standard. Think of this macro as MAYBE_CLASS_TYPE_P. */ 1031 #define IS_AGGR_TYPE(T) \ 1032 (TREE_CODE (T) == TEMPLATE_TYPE_PARM \ 1033 || TREE_CODE (T) == TYPENAME_TYPE \ 1034 || TREE_CODE (T) == TYPEOF_TYPE \ 1035 || TREE_CODE (T) == BOUND_TEMPLATE_TEMPLATE_PARM \ 1036 || TYPE_LANG_FLAG_5 (T)) 1037 1038 /* Set IS_AGGR_TYPE for T to VAL. T must be a class, struct, or 1039 union type. */ 1040 #define SET_IS_AGGR_TYPE(T, VAL) \ 1041 (TYPE_LANG_FLAG_5 (T) = (VAL)) 1042 1043 /* Nonzero if T is a class type. Zero for template type parameters, 1044 typename types, and so forth. */ 1045 #define CLASS_TYPE_P(T) \ 1046 (IS_AGGR_TYPE_CODE (TREE_CODE (T)) && IS_AGGR_TYPE (T)) 1047 1048 #define IS_AGGR_TYPE_CODE(T) ((T) == RECORD_TYPE || (T) == UNION_TYPE) 1049 #define IS_AGGR_TYPE_2(TYPE1, TYPE2) \ 1050 (TREE_CODE (TYPE1) == TREE_CODE (TYPE2) \ 1051 && IS_AGGR_TYPE (TYPE1) && IS_AGGR_TYPE (TYPE2)) 1052 #define TAGGED_TYPE_P(T) \ 1053 (CLASS_TYPE_P (T) || TREE_CODE (T) == ENUMERAL_TYPE) 1054 #define IS_OVERLOAD_TYPE(T) TAGGED_TYPE_P (T) 1055 1056 /* In a *_TYPE, nonzero means a built-in type. */ 1057 #define TYPE_BUILT_IN(NODE) TYPE_LANG_FLAG_6 (NODE) 1058 1059 /* True if this a "Java" type, defined in 'extern "Java"'. */ 1060 #define TYPE_FOR_JAVA(NODE) TYPE_LANG_FLAG_3 (NODE) 1061 1062 /* Nonzero if this type is const-qualified. */ 1063 #define CP_TYPE_CONST_P(NODE) \ 1064 ((cp_type_quals (NODE) & TYPE_QUAL_CONST) != 0) 1065 1066 /* Nonzero if this type is volatile-qualified. */ 1067 #define CP_TYPE_VOLATILE_P(NODE) \ 1068 ((cp_type_quals (NODE) & TYPE_QUAL_VOLATILE) != 0) 1069 1070 /* Nonzero if this type is restrict-qualified. */ 1071 #define CP_TYPE_RESTRICT_P(NODE) \ 1072 ((cp_type_quals (NODE) & TYPE_QUAL_RESTRICT) != 0) 1073 1074 /* Nonzero if this type is const-qualified, but not 1075 volatile-qualified. Other qualifiers are ignored. This macro is 1076 used to test whether or not it is OK to bind an rvalue to a 1077 reference. */ 1078 #define CP_TYPE_CONST_NON_VOLATILE_P(NODE) \ 1079 ((cp_type_quals (NODE) & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)) \ 1080 == TYPE_QUAL_CONST) 1081 1082 #define FUNCTION_ARG_CHAIN(NODE) \ 1083 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (NODE))) 1084 1085 /* Given a FUNCTION_DECL, returns the first TREE_LIST out of TYPE_ARG_TYPES 1086 which refers to a user-written parameter. */ 1087 #define FUNCTION_FIRST_USER_PARMTYPE(NODE) \ 1088 skip_artificial_parms_for ((NODE), TYPE_ARG_TYPES (TREE_TYPE (NODE))) 1089 1090 /* Similarly, but for DECL_ARGUMENTS. */ 1091 #define FUNCTION_FIRST_USER_PARM(NODE) \ 1092 skip_artificial_parms_for ((NODE), DECL_ARGUMENTS (NODE)) 1093 1094 #define PROMOTES_TO_AGGR_TYPE(NODE, CODE) \ 1095 (((CODE) == TREE_CODE (NODE) \ 1096 && IS_AGGR_TYPE (TREE_TYPE (NODE))) \ 1097 || IS_AGGR_TYPE (NODE)) 1098 1099 /* Nonzero iff TYPE is derived from PARENT. Ignores accessibility and 1100 ambiguity issues. */ 1101 #define DERIVED_FROM_P(PARENT, TYPE) \ 1102 (lookup_base ((TYPE), PARENT, ba_any, NULL) != NULL_TREE) 1103 /* Nonzero iff TYPE is uniquely derived from PARENT. Ignores 1104 accessibility. */ 1105 #define UNIQUELY_DERIVED_FROM_P(PARENT, TYPE) \ 1106 (lookup_base ((TYPE), (PARENT), ba_ignore | ba_quiet, NULL) != NULL_TREE) 1107 /* Nonzero iff TYPE is accessible in the current scope and uniquely 1108 derived from PARENT. */ 1109 #define ACCESSIBLY_UNIQUELY_DERIVED_P(PARENT, TYPE) \ 1110 (lookup_base ((TYPE), (PARENT), ba_check | ba_quiet, NULL) != NULL_TREE) 1111 /* Nonzero iff TYPE is publicly & uniquely derived from PARENT. */ 1112 #define PUBLICLY_UNIQUELY_DERIVED_P(PARENT, TYPE) \ 1113 (lookup_base ((TYPE), (PARENT), ba_not_special | ba_quiet, NULL) \ 1114 != NULL_TREE) 1115 1116 /* This is a few header flags for 'struct lang_type'. Actually, 1117 all but the first are used only for lang_type_class; they 1118 are put in this structure to save space. */ 1119 struct lang_type_header GTY(()) 1120 { 1121 unsigned is_lang_type_class : 1; 1122 1123 unsigned has_type_conversion : 1; 1124 unsigned has_init_ref : 1; 1125 unsigned has_default_ctor : 1; 1126 unsigned uses_multiple_inheritance : 1; 1127 unsigned const_needs_init : 1; 1128 unsigned ref_needs_init : 1; 1129 unsigned has_const_assign_ref : 1; 1130 }; 1131 1132 /* This structure provides additional information above and beyond 1133 what is provide in the ordinary tree_type. In the past, we used it 1134 for the types of class types, template parameters types, typename 1135 types, and so forth. However, there can be many (tens to hundreds 1136 of thousands) of template parameter types in a compilation, and 1137 there's no need for this additional information in that case. 1138 Therefore, we now use this data structure only for class types. 1139 1140 In the past, it was thought that there would be relatively few 1141 class types. However, in the presence of heavy use of templates, 1142 many (i.e., thousands) of classes can easily be generated. 1143 Therefore, we should endeavor to keep the size of this structure to 1144 a minimum. */ 1145 struct lang_type_class GTY(()) 1146 { 1147 struct lang_type_header h; 1148 1149 unsigned char align; 1150 1151 unsigned has_mutable : 1; 1152 unsigned com_interface : 1; 1153 unsigned non_pod_class : 1; 1154 unsigned nearly_empty_p : 1; 1155 unsigned user_align : 1; 1156 unsigned has_assign_ref : 1; 1157 unsigned has_new : 1; 1158 unsigned has_array_new : 1; 1159 1160 unsigned gets_delete : 2; 1161 unsigned has_call_overloaded : 1; 1162 unsigned has_array_ref_overloaded : 1; 1163 unsigned has_arrow_overloaded : 1; 1164 unsigned interface_only : 1; 1165 unsigned interface_unknown : 1; 1166 1167 unsigned marks: 6; 1168 unsigned vec_new_uses_cookie : 1; 1169 unsigned declared_class : 1; 1170 1171 unsigned being_defined : 1; 1172 unsigned redefined : 1; 1173 unsigned debug_requested : 1; 1174 unsigned use_template : 2; 1175 unsigned got_semicolon : 1; 1176 unsigned ptrmemfunc_flag : 1; 1177 unsigned was_anonymous : 1; 1178 1179 unsigned has_real_assign_ref : 1; 1180 unsigned has_const_init_ref : 1; 1181 unsigned has_complex_init_ref : 1; 1182 unsigned has_complex_assign_ref : 1; 1183 unsigned has_abstract_assign_ref : 1; 1184 unsigned non_aggregate : 1; 1185 unsigned is_partial_instantiation : 1; 1186 unsigned java_interface : 1; 1187 1188 unsigned anon_aggr : 1; 1189 unsigned non_zero_init : 1; 1190 unsigned empty_p : 1; 1191 unsigned contains_empty_class_p : 1; 1192 1193 /* When adding a flag here, consider whether or not it ought to 1194 apply to a template instance if it applies to the template. If 1195 so, make sure to copy it in instantiate_class_template! */ 1196 1197 /* There are some bits left to fill out a 32-bit word. Keep track 1198 of this by updating the size of this bitfield whenever you add or 1199 remove a flag. */ 1200 unsigned dummy : 5; 1201 1202 tree primary_base; 1203 tree vfields; 1204 tree vcall_indices; 1205 tree vtables; 1206 tree typeinfo_var; 1207 tree vbases; 1208 binding_table nested_udts; 1209 tree as_base; 1210 tree pure_virtuals; 1211 tree friend_classes; 1212 tree methods; 1213 tree key_method; 1214 tree decl_list; 1215 tree template_info; 1216 tree befriending_classes; 1217 }; 1218 1219 struct lang_type_ptrmem GTY(()) 1220 { 1221 struct lang_type_header h; 1222 tree record; 1223 }; 1224 1225 struct lang_type GTY(()) 1226 { 1227 union lang_type_u 1228 { 1229 struct lang_type_header GTY((tag ("2"))) h; 1230 struct lang_type_class GTY((tag ("1"))) c; 1231 struct lang_type_ptrmem GTY((tag ("0"))) ptrmem; 1232 } GTY((desc ("%h.h.is_lang_type_class"))) u; 1233 }; 1234 1235 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) 1236 1237 #define LANG_TYPE_CLASS_CHECK(NODE) \ 1238 ({ struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE); \ 1239 if (! lt->u.h.is_lang_type_class) \ 1240 lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ 1241 <->u.c; }) 1242 1243 #define LANG_TYPE_PTRMEM_CHECK(NODE) \ 1244 ({ struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE); \ 1245 if (lt->u.h.is_lang_type_class) \ 1246 lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ 1247 <->u.ptrmem; }) 1248 1249 #else 1250 1251 #define LANG_TYPE_CLASS_CHECK(NODE) (&TYPE_LANG_SPECIFIC (NODE)->u.c) 1252 #define LANG_TYPE_PTRMEM_CHECK(NODE) (&TYPE_LANG_SPECIFIC (NODE)->u.ptrmem) 1253 1254 #endif /* ENABLE_TREE_CHECKING */ 1255 1256 /* Indicates whether or not (and how) a template was expanded for this class. 1257 0=no information yet/non-template class 1258 1=implicit template instantiation 1259 2=explicit template specialization 1260 3=explicit template instantiation */ 1261 #define CLASSTYPE_USE_TEMPLATE(NODE) \ 1262 (LANG_TYPE_CLASS_CHECK (NODE)->use_template) 1263 1264 /* Fields used for storing information before the class is defined. 1265 After the class is defined, these fields hold other information. */ 1266 1267 /* List of friends which were defined inline in this class definition. */ 1268 #define CLASSTYPE_INLINE_FRIENDS(NODE) CLASSTYPE_PURE_VIRTUALS (NODE) 1269 1270 /* Nonzero for _CLASSTYPE means that operator delete is defined. */ 1271 #define TYPE_GETS_DELETE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->gets_delete) 1272 #define TYPE_GETS_REG_DELETE(NODE) (TYPE_GETS_DELETE (NODE) & 1) 1273 1274 /* Nonzero if `new NODE[x]' should cause the allocation of extra 1275 storage to indicate how many array elements are in use. */ 1276 #define TYPE_VEC_NEW_USES_COOKIE(NODE) \ 1277 (CLASS_TYPE_P (NODE) \ 1278 && LANG_TYPE_CLASS_CHECK (NODE)->vec_new_uses_cookie) 1279 1280 /* Nonzero means that this _CLASSTYPE node defines ways of converting 1281 itself to other types. */ 1282 #define TYPE_HAS_CONVERSION(NODE) \ 1283 (LANG_TYPE_CLASS_CHECK (NODE)->h.has_type_conversion) 1284 1285 /* Nonzero means that this _CLASSTYPE node overloads operator=(X&). */ 1286 #define TYPE_HAS_ASSIGN_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_assign_ref) 1287 #define TYPE_HAS_CONST_ASSIGN_REF(NODE) \ 1288 (LANG_TYPE_CLASS_CHECK (NODE)->h.has_const_assign_ref) 1289 1290 /* Nonzero means that this _CLASSTYPE node has an X(X&) constructor. */ 1291 #define TYPE_HAS_INIT_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->h.has_init_ref) 1292 #define TYPE_HAS_CONST_INIT_REF(NODE) \ 1293 (LANG_TYPE_CLASS_CHECK (NODE)->has_const_init_ref) 1294 1295 /* Nonzero if this class defines an overloaded operator new. (An 1296 operator new [] doesn't count.) */ 1297 #define TYPE_HAS_NEW_OPERATOR(NODE) \ 1298 (LANG_TYPE_CLASS_CHECK (NODE)->has_new) 1299 1300 /* Nonzero if this class defines an overloaded operator new[]. */ 1301 #define TYPE_HAS_ARRAY_NEW_OPERATOR(NODE) \ 1302 (LANG_TYPE_CLASS_CHECK (NODE)->has_array_new) 1303 1304 /* Nonzero means that this type is being defined. I.e., the left brace 1305 starting the definition of this type has been seen. */ 1306 #define TYPE_BEING_DEFINED(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->being_defined) 1307 /* Nonzero means that this type has been redefined. In this case, if 1308 convenient, don't reprocess any methods that appear in its redefinition. */ 1309 #define TYPE_REDEFINED(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->redefined) 1310 1311 /* Nonzero means that this _CLASSTYPE node overloads operator(). */ 1312 #define TYPE_OVERLOADS_CALL_EXPR(NODE) \ 1313 (LANG_TYPE_CLASS_CHECK (NODE)->has_call_overloaded) 1314 1315 /* Nonzero means that this _CLASSTYPE node overloads operator[]. */ 1316 #define TYPE_OVERLOADS_ARRAY_REF(NODE) \ 1317 (LANG_TYPE_CLASS_CHECK (NODE)->has_array_ref_overloaded) 1318 1319 /* Nonzero means that this _CLASSTYPE node overloads operator->. */ 1320 #define TYPE_OVERLOADS_ARROW(NODE) \ 1321 (LANG_TYPE_CLASS_CHECK (NODE)->has_arrow_overloaded) 1322 1323 /* Nonzero means that this _CLASSTYPE (or one of its ancestors) uses 1324 multiple inheritance. If this is 0 for the root of a type 1325 hierarchy, then we can use more efficient search techniques. */ 1326 #define TYPE_USES_MULTIPLE_INHERITANCE(NODE) \ 1327 (LANG_TYPE_CLASS_CHECK (NODE)->h.uses_multiple_inheritance) 1328 1329 /* Nonzero means that this _CLASSTYPE (or one of its ancestors) uses 1330 virtual base classes. If this is 0 for the root of a type 1331 hierarchy, then we can use more efficient search techniques. */ 1332 #define TYPE_USES_VIRTUAL_BASECLASSES(NODE) (TREE_LANG_FLAG_3 (NODE)) 1333 1334 /* The member function with which the vtable will be emitted: 1335 the first noninline non-pure-virtual member function. NULL_TREE 1336 if there is no key function or if this is a class template */ 1337 #define CLASSTYPE_KEY_METHOD(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->key_method) 1338 1339 /* Vector member functions defined in this class. Each element is 1340 either a FUNCTION_DECL, a TEMPLATE_DECL, or an OVERLOAD. All 1341 functions with the same name end up in the same slot. The first 1342 two elements are for constructors, and destructors, respectively. 1343 All template conversion operators to innermost template dependent 1344 types are overloaded on the next slot, if they exist. Note, the 1345 names for these functions will not all be the same. The 1346 non-template conversion operators & templated conversions to 1347 non-innermost template types are next, followed by ordinary member 1348 functions. There may be empty entries at the end of the vector. 1349 The conversion operators are unsorted. The ordinary member 1350 functions are sorted, once the class is complete. */ 1351 #define CLASSTYPE_METHOD_VEC(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->methods) 1352 1353 /* For class templates, this is a TREE_LIST of all member data, 1354 functions, types, and friends in the order of declaration. 1355 The TREE_PURPOSE of each TREE_LIST is NULL_TREE for a friend, 1356 and the RECORD_TYPE for the class template otherwise. */ 1357 #define CLASSTYPE_DECL_LIST(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->decl_list) 1358 1359 /* The slot in the CLASSTYPE_METHOD_VEC where constructors go. */ 1360 #define CLASSTYPE_CONSTRUCTOR_SLOT 0 1361 1362 /* The slot in the CLASSTYPE_METHOD_VEC where destructors go. */ 1363 #define CLASSTYPE_DESTRUCTOR_SLOT 1 1364 1365 /* The first slot in the CLASSTYPE_METHOD_VEC where conversion 1366 operators can appear. */ 1367 #define CLASSTYPE_FIRST_CONVERSION_SLOT 2 1368 1369 /* A FUNCTION_DECL or OVERLOAD for the constructors for NODE. These 1370 are the constructors that take an in-charge parameter. */ 1371 #define CLASSTYPE_CONSTRUCTORS(NODE) \ 1372 (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_CONSTRUCTOR_SLOT)) 1373 1374 /* A FUNCTION_DECL for the destructor for NODE. These are the 1375 destructors that take an in-charge parameter. */ 1376 #define CLASSTYPE_DESTRUCTORS(NODE) \ 1377 (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_DESTRUCTOR_SLOT)) 1378 1379 /* Mark bits for depth-first and breath-first searches. */ 1380 1381 /* Get the value of the Nth mark bit. */ 1382 #define CLASSTYPE_MARKED_N(NODE, N) \ 1383 (((CLASS_TYPE_P (NODE) ? LANG_TYPE_CLASS_CHECK (NODE)->marks \ 1384 : ((unsigned) TYPE_ALIAS_SET (NODE))) & (1 << (N))) != 0) 1385 1386 /* Set the Nth mark bit. */ 1387 #define SET_CLASSTYPE_MARKED_N(NODE, N) \ 1388 (CLASS_TYPE_P (NODE) \ 1389 ? (void) (LANG_TYPE_CLASS_CHECK (NODE)->marks |= (1 << (N))) \ 1390 : (void) (TYPE_ALIAS_SET (NODE) |= (1 << (N)))) 1391 1392 /* Clear the Nth mark bit. */ 1393 #define CLEAR_CLASSTYPE_MARKED_N(NODE, N) \ 1394 (CLASS_TYPE_P (NODE) \ 1395 ? (void) (LANG_TYPE_CLASS_CHECK (NODE)->marks &= ~(1 << (N))) \ 1396 : (void) (TYPE_ALIAS_SET (NODE) &= ~(1 << (N)))) 1397 1398 /* Get the value of the mark bits. */ 1399 #define CLASSTYPE_MARKED(NODE) CLASSTYPE_MARKED_N (NODE, 0) 1400 #define CLASSTYPE_MARKED2(NODE) CLASSTYPE_MARKED_N (NODE, 1) 1401 #define CLASSTYPE_MARKED3(NODE) CLASSTYPE_MARKED_N (NODE, 2) 1402 #define CLASSTYPE_MARKED4(NODE) CLASSTYPE_MARKED_N (NODE, 3) 1403 #define CLASSTYPE_MARKED5(NODE) CLASSTYPE_MARKED_N (NODE, 4) 1404 #define CLASSTYPE_MARKED6(NODE) CLASSTYPE_MARKED_N (NODE, 5) 1405 1406 /* Macros to modify the above flags */ 1407 #define SET_CLASSTYPE_MARKED(NODE) SET_CLASSTYPE_MARKED_N (NODE, 0) 1408 #define CLEAR_CLASSTYPE_MARKED(NODE) CLEAR_CLASSTYPE_MARKED_N (NODE, 0) 1409 #define SET_CLASSTYPE_MARKED2(NODE) SET_CLASSTYPE_MARKED_N (NODE, 1) 1410 #define CLEAR_CLASSTYPE_MARKED2(NODE) CLEAR_CLASSTYPE_MARKED_N (NODE, 1) 1411 #define SET_CLASSTYPE_MARKED3(NODE) SET_CLASSTYPE_MARKED_N (NODE, 2) 1412 #define CLEAR_CLASSTYPE_MARKED3(NODE) CLEAR_CLASSTYPE_MARKED_N (NODE, 2) 1413 #define SET_CLASSTYPE_MARKED4(NODE) SET_CLASSTYPE_MARKED_N (NODE, 3) 1414 #define CLEAR_CLASSTYPE_MARKED4(NODE) CLEAR_CLASSTYPE_MARKED_N (NODE, 3) 1415 #define SET_CLASSTYPE_MARKED5(NODE) SET_CLASSTYPE_MARKED_N (NODE, 4) 1416 #define CLEAR_CLASSTYPE_MARKED5(NODE) CLEAR_CLASSTYPE_MARKED_N (NODE, 4) 1417 #define SET_CLASSTYPE_MARKED6(NODE) SET_CLASSTYPE_MARKED_N (NODE, 5) 1418 #define CLEAR_CLASSTYPE_MARKED6(NODE) CLEAR_CLASSTYPE_MARKED_N (NODE, 5) 1419 1420 /* A binding_table of the nested tag-types (class, struct, union, or enum) 1421 found within this class. The ENTRY->name of each node is the name 1422 of the type; the ENTRY->type is the type itself. This table includes 1423 nested member class templates. */ 1424 #define CLASSTYPE_NESTED_UDTS(NODE) \ 1425 (LANG_TYPE_CLASS_CHECK (NODE)->nested_udts) 1426 1427 /* Nonzero if NODE has a primary base class, i.e., a base class with 1428 which it shares the virtual function table pointer. */ 1429 #define CLASSTYPE_HAS_PRIMARY_BASE_P(NODE) \ 1430 (CLASSTYPE_PRIMARY_BINFO (NODE) != NULL_TREE) 1431 1432 /* If non-NULL, this is the binfo for the primary base class, i.e., 1433 the base class which contains the virtual function table pointer 1434 for this class. */ 1435 #define CLASSTYPE_PRIMARY_BINFO(NODE) \ 1436 (LANG_TYPE_CLASS_CHECK (NODE)->primary_base) 1437 1438 /* A chain of BINFOs for the direct and indirect virtual base classes 1439 that this type uses in a post-order depth-first left-to-right 1440 order. (In other words, these bases appear in the order that they 1441 should be initialized.) If a virtual base is primary, then the 1442 primary copy will appear on this list. Thus, the BINFOs on this 1443 list are all "real"; they are the same BINFOs that will be 1444 encountered when using dfs_unmarked_real_bases_queue_p and related 1445 functions. */ 1446 #define CLASSTYPE_VBASECLASSES(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->vbases) 1447 1448 /* For a non-virtual BINFO, the BINFO itself; for a virtual BINFO, the 1449 binfo_for_vbase. C is the most derived class for the hierarchy 1450 containing BINFO. */ 1451 #define CANONICAL_BINFO(BINFO, C) \ 1452 (TREE_VIA_VIRTUAL (BINFO) \ 1453 ? binfo_for_vbase (BINFO_TYPE (BINFO), C) \ 1454 : (BINFO)) 1455 1456 /* Number of direct baseclasses of NODE. */ 1457 #define CLASSTYPE_N_BASECLASSES(NODE) \ 1458 (BINFO_N_BASETYPES (TYPE_BINFO (NODE))) 1459 1460 /* The type corresponding to NODE when NODE is used as a base class, 1461 i.e., NODE without virtual base classes. */ 1462 1463 #define CLASSTYPE_AS_BASE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->as_base) 1464 1465 /* These are the size and alignment of the type without its virtual 1466 base classes, for when we use this type as a base itself. */ 1467 #define CLASSTYPE_SIZE(NODE) TYPE_SIZE (CLASSTYPE_AS_BASE (NODE)) 1468 #define CLASSTYPE_SIZE_UNIT(NODE) TYPE_SIZE_UNIT (CLASSTYPE_AS_BASE (NODE)) 1469 #define CLASSTYPE_ALIGN(NODE) TYPE_ALIGN (CLASSTYPE_AS_BASE (NODE)) 1470 #define CLASSTYPE_USER_ALIGN(NODE) TYPE_USER_ALIGN (CLASSTYPE_AS_BASE (NODE)) 1471 1472 /* The alignment of NODE, without its virtual bases, in bytes. */ 1473 #define CLASSTYPE_ALIGN_UNIT(NODE) \ 1474 (CLASSTYPE_ALIGN (NODE) / BITS_PER_UNIT) 1475 1476 /* True if this a Java interface type, declared with 1477 '__attribute__ ((java_interface))'. */ 1478 #define TYPE_JAVA_INTERFACE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->java_interface) 1479 1480 /* A cons list of virtual functions which cannot be inherited by 1481 derived classes. When deriving from this type, the derived 1482 class must provide its own definition for each of these functions. */ 1483 #define CLASSTYPE_PURE_VIRTUALS(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->pure_virtuals) 1484 1485 /* Nonzero means that this aggr type has been `closed' by a semicolon. */ 1486 #define CLASSTYPE_GOT_SEMICOLON(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->got_semicolon) 1487 1488 /* Nonzero means that this type has an X() constructor. */ 1489 #define TYPE_HAS_DEFAULT_CONSTRUCTOR(NODE) \ 1490 (LANG_TYPE_CLASS_CHECK (NODE)->h.has_default_ctor) 1491 1492 /* Nonzero means that this type contains a mutable member */ 1493 #define CLASSTYPE_HAS_MUTABLE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_mutable) 1494 #define TYPE_HAS_MUTABLE_P(NODE) (cp_has_mutable_p (NODE)) 1495 1496 /* Nonzero means that this class type is a non-POD class. */ 1497 #define CLASSTYPE_NON_POD_P(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->non_pod_class) 1498 1499 /* Nonzero means that this class contains pod types whose default 1500 initialization is not a zero initialization (namely, pointers to 1501 data members). */ 1502 #define CLASSTYPE_NON_ZERO_INIT_P(NODE) \ 1503 (LANG_TYPE_CLASS_CHECK (NODE)->non_zero_init) 1504 1505 /* Nonzero if this class is "empty" in the sense of the C++ ABI. */ 1506 #define CLASSTYPE_EMPTY_P(NODE) \ 1507 (LANG_TYPE_CLASS_CHECK (NODE)->empty_p) 1508 1509 /* Nonzero if this class is "nearly empty", i.e., contains only a 1510 virtual function table pointer. */ 1511 #define CLASSTYPE_NEARLY_EMPTY_P(NODE) \ 1512 (LANG_TYPE_CLASS_CHECK (NODE)->nearly_empty_p) 1513 1514 /* Nonzero if this class contains an empty subobject. */ 1515 #define CLASSTYPE_CONTAINS_EMPTY_CLASS_P(NODE) \ 1516 (LANG_TYPE_CLASS_CHECK (NODE)->contains_empty_class_p) 1517 1518 /* A list of class types of which this type is a friend. The 1519 TREE_VALUE is normally a TYPE, but will be a TEMPLATE_DECL in the 1520 case of a template friend. */ 1521 #define CLASSTYPE_FRIEND_CLASSES(NODE) \ 1522 (LANG_TYPE_CLASS_CHECK (NODE)->friend_classes) 1523 1524 /* A list of the classes which grant friendship to this class. */ 1525 #define CLASSTYPE_BEFRIENDING_CLASSES(NODE) \ 1526 (LANG_TYPE_CLASS_CHECK (NODE)->befriending_classes) 1527 1528 /* Say whether this node was declared as a "class" or a "struct". */ 1529 #define CLASSTYPE_DECLARED_CLASS(NODE) \ 1530 (LANG_TYPE_CLASS_CHECK (NODE)->declared_class) 1531 1532 /* Nonzero if this class has const members 1533 which have no specified initialization. */ 1534 #define CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE) \ 1535 (TYPE_LANG_SPECIFIC (NODE) \ 1536 ? LANG_TYPE_CLASS_CHECK (NODE)->h.const_needs_init : 0) 1537 #define SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE, VALUE) \ 1538 (LANG_TYPE_CLASS_CHECK (NODE)->h.const_needs_init = (VALUE)) 1539 1540 /* Nonzero if this class has ref members 1541 which have no specified initialization. */ 1542 #define CLASSTYPE_REF_FIELDS_NEED_INIT(NODE) \ 1543 (TYPE_LANG_SPECIFIC (NODE) \ 1544 ? LANG_TYPE_CLASS_CHECK (NODE)->h.ref_needs_init : 0) 1545 #define SET_CLASSTYPE_REF_FIELDS_NEED_INIT(NODE, VALUE) \ 1546 (LANG_TYPE_CLASS_CHECK (NODE)->h.ref_needs_init = (VALUE)) 1547 1548 /* Nonzero if this class is included from a header file which employs 1549 `#pragma interface', and it is not included in its implementation file. */ 1550 #define CLASSTYPE_INTERFACE_ONLY(NODE) \ 1551 (LANG_TYPE_CLASS_CHECK (NODE)->interface_only) 1552 1553 /* True if we have already determined whether or not vtables, VTTs, 1554 typeinfo, and other similar per-class data should be emitted in 1555 this translation unit. This flag does not indicate whether or not 1556 these items should be emitted; it only indicates that we know one 1557 way or the other. */ 1558 #define CLASSTYPE_INTERFACE_KNOWN(NODE) \ 1559 (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown == 0) 1560 /* The opposite of CLASSTYPE_INTERFANCE_KNOWN. */ 1561 #define CLASSTYPE_INTERFACE_UNKNOWN(NODE) \ 1562 (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown) 1563 1564 #define SET_CLASSTYPE_INTERFACE_UNKNOWN_X(NODE,X) \ 1565 (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = !!(X)) 1566 #define SET_CLASSTYPE_INTERFACE_UNKNOWN(NODE) \ 1567 (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 1) 1568 #define SET_CLASSTYPE_INTERFACE_KNOWN(NODE) \ 1569 (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 0) 1570 1571 /* Nonzero if a _DECL node requires us to output debug info for this class. */ 1572 #define CLASSTYPE_DEBUG_REQUESTED(NODE) \ 1573 (LANG_TYPE_CLASS_CHECK (NODE)->debug_requested) 1574 1575 /* Additional macros for inheritance information. */ 1576 1577 /* The BINFO_INHERITANCE_CHAIN is used opposite to the description in 1578 gcc/tree.h. In particular if D is derived from B then the BINFO 1579 for B (in D) will have a BINFO_INHERITANCE_CHAIN pointing to 1580 D. In tree.h, this pointer is described as pointing in other 1581 direction. There is a different BINFO for each path to a virtual 1582 base; BINFOs for virtual bases are not shared. 1583 1584 We use TREE_VIA_PROTECTED and TREE_VIA_PUBLIC, but private 1585 inheritance is indicated by the absence of the other two flags, not 1586 by TREE_VIA_PRIVATE, which is unused. */ 1587 1588 /* Mark the binfo, whether shared or not. Each instance of a virtual 1589 base can be separately marked. */ 1590 #define BINFO_UNSHARED_MARKED(NODE) TREE_LANG_FLAG_0 (NODE) 1591 1592 /* Nonzero means marked by DFS or BFS search. */ 1593 #define BINFO_MARKED(NODE) \ 1594 (TREE_VIA_VIRTUAL (NODE) \ 1595 ? CLASSTYPE_MARKED (BINFO_TYPE (NODE)) \ 1596 : TREE_LANG_FLAG_0 (NODE)) 1597 /* Macros needed because of C compilers that don't allow conditional 1598 expressions to be lvalues. Grr! */ 1599 #define SET_BINFO_MARKED(NODE) \ 1600 (TREE_VIA_VIRTUAL(NODE) \ 1601 ? SET_CLASSTYPE_MARKED (BINFO_TYPE (NODE)) \ 1602 : (void)(TREE_LANG_FLAG_0 (NODE) = 1)) 1603 #define CLEAR_BINFO_MARKED(NODE) \ 1604 (TREE_VIA_VIRTUAL (NODE) \ 1605 ? CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (NODE)) \ 1606 : (void)(TREE_LANG_FLAG_0 (NODE) = 0)) 1607 1608 /* Nonzero means that this class is on a path leading to a new vtable. */ 1609 #define BINFO_VTABLE_PATH_MARKED(NODE) \ 1610 (TREE_VIA_VIRTUAL (NODE) \ 1611 ? CLASSTYPE_MARKED3 (BINFO_TYPE (NODE)) \ 1612 : TREE_LANG_FLAG_3 (NODE)) 1613 #define SET_BINFO_VTABLE_PATH_MARKED(NODE) \ 1614 (TREE_VIA_VIRTUAL(NODE) \ 1615 ? SET_CLASSTYPE_MARKED3 (BINFO_TYPE (NODE)) \ 1616 : (TREE_LANG_FLAG_3 (NODE) = 1)) 1617 #define CLEAR_BINFO_VTABLE_PATH_MARKED(NODE) \ 1618 (TREE_VIA_VIRTUAL (NODE) \ 1619 ? CLEAR_CLASSTYPE_MARKED3 (BINFO_TYPE (NODE))\ 1620 : (TREE_LANG_FLAG_3 (NODE) = 0)) 1621 1622 /* Nonzero means B (a BINFO) has its own vtable. Under the old ABI, 1623 secondary vtables are sometimes shared. Any copies will not have 1624 this flag set. 1625 1626 B is part of the hierarchy dominated by C. */ 1627 #define BINFO_NEW_VTABLE_MARKED(B, C) \ 1628 (TREE_LANG_FLAG_4 (CANONICAL_BINFO (B, C))) 1629 1630 /* Any subobject that needs a new vtable must have a vptr and must not 1631 be a non-virtual primary base (since it would then use the vtable from a 1632 derived class and never become non-primary.) */ 1633 #define SET_BINFO_NEW_VTABLE_MARKED(B, C) \ 1634 (BINFO_NEW_VTABLE_MARKED (B, C) = 1, \ 1635 my_friendly_assert (!BINFO_PRIMARY_P (B) \ 1636 || TREE_VIA_VIRTUAL (B), 20000517), \ 1637 my_friendly_assert (CLASSTYPE_VFIELDS (BINFO_TYPE (B)) != NULL_TREE, \ 1638 20000517)) 1639 1640 /* Nonzero means this class has done dfs_pushdecls. */ 1641 #define BINFO_PUSHDECLS_MARKED(NODE) BINFO_VTABLE_PATH_MARKED (NODE) 1642 #define SET_BINFO_PUSHDECLS_MARKED(NODE) SET_BINFO_VTABLE_PATH_MARKED (NODE) 1643 #define CLEAR_BINFO_PUSHDECLS_MARKED(NODE) CLEAR_BINFO_VTABLE_PATH_MARKED (NODE) 1644 1645 /* Nonzero if this BINFO is a primary base class. Note, this can be 1646 set for non-canononical virtual bases. For a virtual primary base 1647 you might also need to check whether it is canonical. */ 1648 1649 #define BINFO_PRIMARY_P(NODE) \ 1650 (BINFO_PRIMARY_BASE_OF (NODE) != NULL_TREE) 1651 1652 /* The index in the VTT where this subobject's sub-VTT can be found. 1653 NULL_TREE if there is no sub-VTT. */ 1654 #define BINFO_SUBVTT_INDEX(NODE) TREE_VEC_ELT (NODE, 8) 1655 1656 /* The index in the VTT where the vptr for this subobject can be 1657 found. NULL_TREE if there is no secondary vptr in the VTT. */ 1658 #define BINFO_VPTR_INDEX(NODE) TREE_VEC_ELT (NODE, 9) 1659 1660 /* The binfo of which NODE is a primary base. (This is different from 1661 BINFO_INHERITANCE_CHAIN for virtual base because a virtual base is 1662 sometimes a primary base for a class for which it is not an 1663 immediate base.) */ 1664 #define BINFO_PRIMARY_BASE_OF(NODE) TREE_VEC_ELT (NODE, 10) 1665 1666 /* Nonzero if this binfo has lost its primary base binfo (because that 1667 is a nearly-empty virtual base that has been taken by some other 1668 base in the complete hierarchy. */ 1669 #define BINFO_LOST_PRIMARY_P(NODE) TREE_LANG_FLAG_2 (NODE) 1670 1671 /* Nonzero if this binfo is an indirect primary base, i.e. a virtual 1672 base that is a primary base of some of other class in the 1673 hierarchy. */ 1674 #define BINFO_INDIRECT_PRIMARY_P(NODE) TREE_USED (NODE) 1675 1676 /* Used by various search routines. */ 1677 #define IDENTIFIER_MARKED(NODE) TREE_LANG_FLAG_0 (NODE) 1678 1679 /* A TREE_LIST of the vcall indices associated with the class NODE. 1680 The TREE_PURPOSE of each node is a FUNCTION_DECL for a virtual 1681 function. The TREE_VALUE is the index into the virtual table where 1682 the vcall offset for that function is stored, when NODE is a 1683 virtual base. */ 1684 #define CLASSTYPE_VCALL_INDICES(NODE) \ 1685 (LANG_TYPE_CLASS_CHECK (NODE)->vcall_indices) 1686 1687 /* The various vtables for the class NODE. The primary vtable will be 1688 first, followed by the construction vtables and VTT, if any. */ 1689 #define CLASSTYPE_VTABLES(NODE) \ 1690 (LANG_TYPE_CLASS_CHECK (NODE)->vtables) 1691 1692 /* The std::type_info variable representing this class, or NULL if no 1693 such variable has been created. This field is only set for the 1694 TYPE_MAIN_VARIANT of the class. */ 1695 #define CLASSTYPE_TYPEINFO_VAR(NODE) \ 1696 (LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var) 1697 1698 /* Accessor macros for the vfield slots in structures. */ 1699 1700 /* List of virtual table fields that this type contains (both the primary 1701 and secondaries). The TREE_VALUE is the class type where the vtable 1702 field was introduced. For a vtable field inherited from the primary 1703 base, or introduced by this class, the TREE_PURPOSE is NULL. For 1704 other vtable fields (those from non-primary bases), the 1705 TREE_PURPOSE is the BINFO of the base through which the vtable was 1706 inherited. */ 1707 #define CLASSTYPE_VFIELDS(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->vfields) 1708 1709 /* Get the BINFO that introduced this vtable into the hierarchy (will 1710 be NULL for those created at this level, or from a primary 1711 hierarchy). */ 1712 #define VF_BINFO_VALUE(NODE) TREE_PURPOSE (NODE) 1713 1714 /* Get the TYPE that introduced this vtable into the hierarchy (always 1715 non-NULL). */ 1716 #define VF_BASETYPE_VALUE(NODE) TREE_VALUE (NODE) 1717 1718 /* Accessor macros for the BINFO_VIRTUALS list. */ 1719 1720 /* The number of bytes by which to adjust the `this' pointer when 1721 calling this virtual function. Subtract this value from the this 1722 pointer. Always non-NULL, might be constant zero though. */ 1723 #define BV_DELTA(NODE) (TREE_PURPOSE (NODE)) 1724 1725 /* If non-NULL, the vtable index at which to find the vcall offset 1726 when calling this virtual function. Add the value at that vtable 1727 index to the this pointer. */ 1728 #define BV_VCALL_INDEX(NODE) (TREE_TYPE (NODE)) 1729 1730 /* The function to call. */ 1731 #define BV_FN(NODE) (TREE_VALUE (NODE)) 1732 1733 1734 /* Nonzero for TREE_LIST node means that this list of things 1735 is a list of parameters, as opposed to a list of expressions. */ 1736 #define TREE_PARMLIST(NODE) (TREE_LANG_FLAG_2 (NODE)) 1737 1738 /* Nonzero for a parmlist means that this parmlist ended in ... */ 1739 #define PARMLIST_ELLIPSIS_P(NODE) TREE_LANG_FLAG_0 (NODE) 1740 1741 /* For FUNCTION_TYPE or METHOD_TYPE, a list of the exceptions that 1742 this type can raise. Each TREE_VALUE is a _TYPE. The TREE_VALUE 1743 will be NULL_TREE to indicate a throw specification of `()', or 1744 no exceptions allowed. */ 1745 #define TYPE_RAISES_EXCEPTIONS(NODE) TYPE_BINFO (NODE) 1746 1747 /* For FUNCTION_TYPE or METHOD_TYPE, return 1 iff it is declared `throw()'. */ 1748 #define TYPE_NOTHROW_P(NODE) \ 1749 (TYPE_RAISES_EXCEPTIONS (NODE) \ 1750 && TREE_VALUE (TYPE_RAISES_EXCEPTIONS (NODE)) == NULL_TREE) 1751 1752 /* The binding level associated with the namespace. */ 1753 #define NAMESPACE_LEVEL(NODE) \ 1754 (DECL_LANG_SPECIFIC (NODE)->decl_flags.u.level) 1755 1756 1757 /* If a DECL has DECL_LANG_SPECIFIC, it is either a lang_decl_flags or 1758 a lang_decl (which has lang_decl_flags as its initial prefix). 1759 This macro is nonzero for tree nodes whose DECL_LANG_SPECIFIC is 1760 the full lang_decl, and not just lang_decl_flags. */ 1761 #define CAN_HAVE_FULL_LANG_DECL_P(NODE) \ 1762 (!(TREE_CODE (NODE) == VAR_DECL \ 1763 || TREE_CODE (NODE) == CONST_DECL \ 1764 || TREE_CODE (NODE) == FIELD_DECL \ 1765 || TREE_CODE (NODE) == USING_DECL)) 1766 1767 struct lang_decl_flags GTY(()) 1768 { 1769 struct c_lang_decl base; 1770 1771 ENUM_BITFIELD(languages) language : 8; 1772 1773 unsigned operator_attr : 1; 1774 unsigned constructor_attr : 1; 1775 unsigned destructor_attr : 1; 1776 unsigned friend_attr : 1; 1777 unsigned static_function : 1; 1778 unsigned pure_virtual : 1; 1779 unsigned has_in_charge_parm_p : 1; 1780 unsigned has_vtt_parm_p : 1; 1781 1782 unsigned deferred : 1; 1783 unsigned use_template : 2; 1784 unsigned nonconverting : 1; 1785 unsigned not_really_extern : 1; 1786 unsigned needs_final_overrider : 1; 1787 unsigned initialized_in_class : 1; 1788 unsigned assignment_operator_p : 1; 1789 1790 unsigned global_ctor_p : 1; 1791 unsigned global_dtor_p : 1; 1792 unsigned anticipated_p : 1; 1793 unsigned template_conv_p : 1; 1794 unsigned u1sel : 1; 1795 unsigned u2sel : 1; 1796 unsigned can_be_full : 1; 1797 unsigned unused : 1; /* One unused bit. */ 1798 1799 union lang_decl_u { 1800 /* In a FUNCTION_DECL, VAR_DECL, TYPE_DECL, or TEMPLATE_DECL, this 1801 is DECL_TEMPLATE_INFO. */ 1802 tree GTY ((tag ("0"))) template_info; 1803 1804 /* In a NAMESPACE_DECL, this is NAMESPACE_LEVEL. */ 1805 struct cp_binding_level * GTY ((tag ("1"))) level; 1806 } GTY ((desc ("%1.u1sel"))) u; 1807 1808 union lang_decl_u2 { 1809 /* This is DECL_ACCESS. */ 1810 tree GTY ((tag ("0"))) access; 1811 1812 /* For VAR_DECL in function, this is DECL_DISCRIMINATOR. */ 1813 int discriminator; 1814 1815 /* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is 1816 THUNK_VCALL_OFFSET. */ 1817 tree GTY((tag ("2"))) vcall_offset; 1818 } GTY ((desc ("%1.u2sel"))) u2; 1819 }; 1820 1821 struct lang_decl GTY(()) 1822 { 1823 struct lang_decl_flags decl_flags; 1824 1825 union lang_decl_u4 1826 { 1827 struct full_lang_decl 1828 { 1829 tree befriending_classes; 1830 1831 /* For a non-virtual FUNCTION_DECL, this is 1832 DECL_FRIEND_CONTEXT. For a virtual FUNCTION_DECL for which 1833 DECL_THUNK_P does not hold, this is DECL_THUNKS. */ 1834 tree context; 1835 1836 /* In a FUNCTION_DECL, this is DECL_CLONED_FUNCTION. */ 1837 tree cloned_function; 1838 1839 /* In a FUNCTION_DECL for which THUNK_P holds, this is 1840 THUNK_DELTA. */ 1841 HOST_WIDE_INT delta; 1842 1843 /* In an overloaded operator, this is the value of 1844 DECL_OVERLOADED_OPERATOR_P. */ 1845 enum tree_code operator_code; 1846 1847 unsigned u3sel : 1; 1848 unsigned pending_inline_p : 1; 1849 1850 union lang_decl_u3 1851 { 1852 tree GTY ((tag ("0"))) sorted_fields; 1853 struct unparsed_text * GTY ((tag ("2"))) pending_inline_info; 1854 struct language_function * GTY ((tag ("1"))) 1855 saved_language_function; 1856 } GTY ((desc ("%1.u3sel + %1.pending_inline_p"))) u; 1857 } GTY ((tag ("1"))) f; 1858 } GTY ((desc ("%1.decl_flags.can_be_full"))) u; 1859 }; 1860 1861 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) 1862 1863 #define LANG_DECL_U2_CHECK(NODE, TF) \ 1864 ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \ 1865 if (lt->decl_flags.u2sel != TF) \ 1866 lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ 1867 <->decl_flags.u2; }) 1868 1869 #else 1870 1871 #define LANG_DECL_U2_CHECK(NODE, TF) \ 1872 (&DECL_LANG_SPECIFIC (NODE)->decl_flags.u2) 1873 1874 #endif /* ENABLE_TREE_CHECKING */ 1875 1876 #define DEFARG_POINTER(NODE) (DEFAULT_ARG_CHECK (NODE)->identifier.id.str) 1877 1878 /* DECL_NEEDED_P holds of a declaration when we need to emit its 1879 definition. This is true when the back-end tells us that 1880 the symbol has been referenced in the generated code. If, however, 1881 we are not generating code, then it is also true when a symbol has 1882 just been used somewhere, even if it's not really needed. We need 1883 anything that isn't comdat, but we don't know for sure whether or 1884 not something is comdat until end-of-file. */ 1885 #define DECL_NEEDED_P(DECL) \ 1886 ((at_eof && TREE_PUBLIC (DECL) && !DECL_COMDAT (DECL)) \ 1887 || (DECL_ASSEMBLER_NAME_SET_P (DECL) \ 1888 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (DECL))) \ 1889 || (flag_syntax_only && TREE_USED (DECL))) 1890 1891 /* Nonzero iff DECL is memory-based. The DECL_RTL of 1892 certain const variables might be a CONST_INT, or a REG 1893 in some cases. We cannot use `memory_operand' as a test 1894 here because on most RISC machines, a variable's address 1895 is not, by itself, a legitimate address. */ 1896 #define DECL_IN_MEMORY_P(NODE) \ 1897 (DECL_RTL_SET_P (NODE) && GET_CODE (DECL_RTL (NODE)) == MEM) 1898 1899 /* For a FUNCTION_DECL or a VAR_DECL, the language linkage for the 1900 declaration. Some entities (like a member function in a local 1901 class, or a local variable) do not have linkage at all, and this 1902 macro should not be used in those cases. 1903 1904 Implementation note: A FUNCTION_DECL without DECL_LANG_SPECIFIC was 1905 created by language-independent code, and has C linkage. Most 1906 VAR_DECLs have C++ linkage, and do not have DECL_LANG_SPECIFIC, but 1907 we do create DECL_LANG_SPECIFIC for variables with non-C++ linkage. */ 1908 #define DECL_LANGUAGE(NODE) \ 1909 (DECL_LANG_SPECIFIC (NODE) \ 1910 ? DECL_LANG_SPECIFIC (NODE)->decl_flags.language \ 1911 : (TREE_CODE (NODE) == FUNCTION_DECL \ 1912 ? lang_c : lang_cplusplus)) 1913 1914 /* Set the language linkage for NODE to LANGUAGE. */ 1915 #define SET_DECL_LANGUAGE(NODE, LANGUAGE) \ 1916 (DECL_LANG_SPECIFIC (NODE)->decl_flags.language = (LANGUAGE)) 1917 1918 /* For FUNCTION_DECLs: nonzero means that this function is a constructor. */ 1919 #define DECL_CONSTRUCTOR_P(NODE) \ 1920 (DECL_LANG_SPECIFIC (NODE)->decl_flags.constructor_attr) 1921 1922 /* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a complete 1923 object. */ 1924 #define DECL_COMPLETE_CONSTRUCTOR_P(NODE) \ 1925 (DECL_CONSTRUCTOR_P (NODE) \ 1926 && DECL_NAME (NODE) == complete_ctor_identifier) 1927 1928 /* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a base 1929 object. */ 1930 #define DECL_BASE_CONSTRUCTOR_P(NODE) \ 1931 (DECL_CONSTRUCTOR_P (NODE) \ 1932 && DECL_NAME (NODE) == base_ctor_identifier) 1933 1934 /* Nonzero if NODE (a FUNCTION_DECL) is a constructor, but not either the 1935 specialized in-charge constructor or the specialized not-in-charge 1936 constructor. */ 1937 #define DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P(NODE) \ 1938 (DECL_CONSTRUCTOR_P (NODE) && !DECL_CLONED_FUNCTION_P (NODE)) 1939 1940 /* Nonzero if NODE (a FUNCTION_DECL) is a copy constructor. */ 1941 #define DECL_COPY_CONSTRUCTOR_P(NODE) \ 1942 (DECL_CONSTRUCTOR_P (NODE) && copy_fn_p (NODE) > 0) 1943 1944 /* Nonzero if NODE is a destructor. */ 1945 #define DECL_DESTRUCTOR_P(NODE) \ 1946 (DECL_LANG_SPECIFIC (NODE)->decl_flags.destructor_attr) 1947 1948 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor, but not the 1949 specialized in-charge constructor, in-charge deleting constructor, 1950 or the the base destructor. */ 1951 #define DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P(NODE) \ 1952 (DECL_DESTRUCTOR_P (NODE) && !DECL_CLONED_FUNCTION_P (NODE)) 1953 1954 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete 1955 object. */ 1956 #define DECL_COMPLETE_DESTRUCTOR_P(NODE) \ 1957 (DECL_DESTRUCTOR_P (NODE) \ 1958 && DECL_NAME (NODE) == complete_dtor_identifier) 1959 1960 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a base 1961 object. */ 1962 #define DECL_BASE_DESTRUCTOR_P(NODE) \ 1963 (DECL_DESTRUCTOR_P (NODE) \ 1964 && DECL_NAME (NODE) == base_dtor_identifier) 1965 1966 /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete 1967 object that deletes the object after it has been destroyed. */ 1968 #define DECL_DELETING_DESTRUCTOR_P(NODE) \ 1969 (DECL_DESTRUCTOR_P (NODE) \ 1970 && DECL_NAME (NODE) == deleting_dtor_identifier) 1971 1972 /* Nonzero if NODE (a FUNCTION_DECL) is a cloned constructor or 1973 destructor. */ 1974 #define DECL_CLONED_FUNCTION_P(NODE) \ 1975 ((TREE_CODE (NODE) == FUNCTION_DECL \ 1976 || TREE_CODE (NODE) == TEMPLATE_DECL) \ 1977 && DECL_LANG_SPECIFIC (NODE) \ 1978 && DECL_CLONED_FUNCTION (NODE) != NULL_TREE) 1979 1980 /* If DECL_CLONED_FUNCTION_P holds, this is the function that was 1981 cloned. */ 1982 #define DECL_CLONED_FUNCTION(NODE) \ 1983 (DECL_LANG_SPECIFIC (NODE)->u.f.cloned_function) 1984 1985 /* Nonzero if NODE has DECL_DISCRIMINATOR and not DECL_ACCESS. */ 1986 #define DECL_DISCRIMINATOR_P(NODE) \ 1987 (TREE_CODE (NODE) == VAR_DECL \ 1988 && DECL_FUNCTION_SCOPE_P (NODE)) 1989 1990 /* Discriminator for name mangling. */ 1991 #define DECL_DISCRIMINATOR(NODE) (LANG_DECL_U2_CHECK (NODE, 1)->discriminator) 1992 1993 /* Nonzero if the VTT parm has been added to NODE. */ 1994 #define DECL_HAS_VTT_PARM_P(NODE) \ 1995 (DECL_LANG_SPECIFIC (NODE)->decl_flags.has_vtt_parm_p) 1996 1997 /* Nonzero if NODE is a FUNCTION_DECL for which a VTT parameter is 1998 required. */ 1999 #define DECL_NEEDS_VTT_PARM_P(NODE) \ 2000 (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (NODE)) \ 2001 && (DECL_BASE_CONSTRUCTOR_P (NODE) \ 2002 || DECL_BASE_DESTRUCTOR_P (NODE))) 2003 2004 /* Nonzero if NODE is a user-defined conversion operator. */ 2005 #define DECL_CONV_FN_P(NODE) \ 2006 (IDENTIFIER_TYPENAME_P (DECL_NAME (NODE))) 2007 2008 /* If FN is a conversion operator, the type to which it converts. 2009 Otherwise, NULL_TREE. */ 2010 #define DECL_CONV_FN_TYPE(FN) \ 2011 (DECL_CONV_FN_P (FN) ? TREE_TYPE (DECL_NAME (FN)) : NULL_TREE) 2012 2013 /* Nonzero if NODE, which is a TEMPLATE_DECL, is a template 2014 conversion operator to a type dependent on the innermost template 2015 args. */ 2016 #define DECL_TEMPLATE_CONV_FN_P(NODE) \ 2017 (DECL_LANG_SPECIFIC (NODE)->decl_flags.template_conv_p) 2018 2019 /* Set the overloaded operator code for NODE to CODE. */ 2020 #define SET_OVERLOADED_OPERATOR_CODE(NODE, CODE) \ 2021 (DECL_LANG_SPECIFIC (NODE)->u.f.operator_code = (CODE)) 2022 2023 /* If NODE is an overloaded operator, then this returns the TREE_CODE 2024 associcated with the overloaded operator. 2025 DECL_ASSIGNMENT_OPERATOR_P must also be checked to determine 2026 whether or not NODE is an assignment operator. If NODE is not an 2027 overloaded operator, ERROR_MARK is returned. Since the numerical 2028 value of ERROR_MARK is zero, this macro can be used as a predicate 2029 to test whether or not NODE is an overloaded operator. */ 2030 #define DECL_OVERLOADED_OPERATOR_P(NODE) \ 2031 (IDENTIFIER_OPNAME_P (DECL_NAME (NODE)) \ 2032 ? DECL_LANG_SPECIFIC (NODE)->u.f.operator_code : ERROR_MARK) 2033 2034 /* Nonzero if NODE is an assignment operator. */ 2035 #define DECL_ASSIGNMENT_OPERATOR_P(NODE) \ 2036 (DECL_LANG_SPECIFIC (NODE)->decl_flags.assignment_operator_p) 2037 2038 /* For FUNCTION_DECLs: nonzero means that this function is a 2039 constructor or a destructor with an extra in-charge parameter to 2040 control whether or not virtual bases are constructed. */ 2041 #define DECL_HAS_IN_CHARGE_PARM_P(NODE) \ 2042 (DECL_LANG_SPECIFIC (NODE)->decl_flags.has_in_charge_parm_p) 2043 2044 /* Nonzero if NODE is an overloaded `operator delete[]' function. */ 2045 #define DECL_ARRAY_DELETE_OPERATOR_P(NODE) \ 2046 (DECL_OVERLOADED_OPERATOR_P (NODE) == VEC_DELETE_EXPR) 2047 2048 /* Nonzero for _DECL means that this decl appears in (or will appear 2049 in) as a member in a RECORD_TYPE or UNION_TYPE node. It is also for 2050 detecting circularity in case members are multiply defined. In the 2051 case of a VAR_DECL, it is also used to determine how program storage 2052 should be allocated. */ 2053 #define DECL_IN_AGGR_P(NODE) (DECL_LANG_FLAG_3 (NODE)) 2054 2055 /* Nonzero for a VAR_DECL means that the variable's initialization has 2056 been processed. */ 2057 #define DECL_INITIALIZED_P(NODE) \ 2058 (TREE_LANG_FLAG_1 (VAR_DECL_CHECK (NODE))) 2059 2060 /* Nonzero if the DECL was initialized in the class definition itself, 2061 rather than outside the class. This is used for both static member 2062 VAR_DECLS, and FUNTION_DECLS that are defined in the class. */ 2063 #define DECL_INITIALIZED_IN_CLASS_P(DECL) \ 2064 (DECL_LANG_SPECIFIC (DECL)->decl_flags.initialized_in_class) 2065 2066 /* Nonzero for FUNCTION_DECL means that this decl is just a 2067 friend declaration, and should not be added to the list of 2068 member functions for this class. */ 2069 #define DECL_FRIEND_P(NODE) (DECL_LANG_SPECIFIC (NODE)->decl_flags.friend_attr) 2070 2071 /* A TREE_LIST of the types which have befriended this FUNCTION_DECL. */ 2072 #define DECL_BEFRIENDING_CLASSES(NODE) \ 2073 (DECL_LANG_SPECIFIC (NODE)->u.f.befriending_classes) 2074 2075 /* Nonzero for FUNCTION_DECL means that this decl is a static 2076 member function. */ 2077 #define DECL_STATIC_FUNCTION_P(NODE) \ 2078 (DECL_LANG_SPECIFIC (NODE)->decl_flags.static_function) 2079 2080 /* Nonzero for FUNCTION_DECL means that this decl is a non-static 2081 member function. */ 2082 #define DECL_NONSTATIC_MEMBER_FUNCTION_P(NODE) \ 2083 (TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE) 2084 2085 /* Nonzero for FUNCTION_DECL means that this decl is a member function 2086 (static or non-static). */ 2087 #define DECL_FUNCTION_MEMBER_P(NODE) \ 2088 (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) || DECL_STATIC_FUNCTION_P (NODE)) 2089 2090 /* Nonzero for FUNCTION_DECL means that this member function 2091 has `this' as const X *const. */ 2092 #define DECL_CONST_MEMFUNC_P(NODE) \ 2093 (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \ 2094 && CP_TYPE_CONST_P (TREE_TYPE (TREE_VALUE \ 2095 (TYPE_ARG_TYPES (TREE_TYPE (NODE)))))) 2096 2097 /* Nonzero for FUNCTION_DECL means that this member function 2098 has `this' as volatile X *const. */ 2099 #define DECL_VOLATILE_MEMFUNC_P(NODE) \ 2100 (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \ 2101 && CP_TYPE_VOLATILE_P (TREE_TYPE (TREE_VALUE \ 2102 (TYPE_ARG_TYPES (TREE_TYPE (NODE)))))) 2103 2104 /* Nonzero for a DECL means that this member is a non-static member. */ 2105 #define DECL_NONSTATIC_MEMBER_P(NODE) \ 2106 ((TREE_CODE (NODE) == FUNCTION_DECL \ 2107 && DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE)) \ 2108 || TREE_CODE (NODE) == FIELD_DECL) 2109 2110 /* Nonzero for _DECL means that this member object type 2111 is mutable. */ 2112 #define DECL_MUTABLE_P(NODE) (DECL_LANG_FLAG_0 (NODE)) 2113 2114 /* Nonzero for _DECL means that this constructor is a non-converting 2115 constructor. */ 2116 #define DECL_NONCONVERTING_P(NODE) \ 2117 (DECL_LANG_SPECIFIC (NODE)->decl_flags.nonconverting) 2118 2119 /* Nonzero for FUNCTION_DECL means that this member function is a pure 2120 virtual function. */ 2121 #define DECL_PURE_VIRTUAL_P(NODE) \ 2122 (DECL_LANG_SPECIFIC (NODE)->decl_flags.pure_virtual) 2123 2124 /* Nonzero for FUNCTION_DECL means that this member function 2125 must be overridden by derived classes. */ 2126 #define DECL_NEEDS_FINAL_OVERRIDER_P(NODE) \ 2127 (DECL_LANG_SPECIFIC (NODE)->decl_flags.needs_final_overrider) 2128 2129 /* The thunks associated with NODE, a FUNCTION_DECL that is not itself 2130 a thunk. */ 2131 #define DECL_THUNKS(NODE) \ 2132 (DECL_LANG_SPECIFIC (NODE)->u.f.context) 2133 2134 /* Nonzero if NODE is a thunk, rather than an ordinary function. */ 2135 #define DECL_THUNK_P(NODE) \ 2136 (TREE_CODE (NODE) == FUNCTION_DECL \ 2137 && DECL_LANG_FLAG_7 (NODE)) 2138 2139 /* Nonzero if NODE is a FUNCTION_DECL, but not a thunk. */ 2140 #define DECL_NON_THUNK_FUNCTION_P(NODE) \ 2141 (TREE_CODE (NODE) == FUNCTION_DECL && !DECL_THUNK_P (NODE)) 2142 2143 /* Nonzero if NODE is `extern "C"'. */ 2144 #define DECL_EXTERN_C_P(NODE) \ 2145 (DECL_LANGUAGE (NODE) == lang_c) 2146 2147 /* Nonzero if NODE is an `extern "C"' function. */ 2148 #define DECL_EXTERN_C_FUNCTION_P(NODE) \ 2149 (DECL_NON_THUNK_FUNCTION_P (NODE) && DECL_EXTERN_C_P (NODE)) 2150 2151 /* Set DECL_THUNK_P for node. */ 2152 #define SET_DECL_THUNK_P(NODE) \ 2153 (DECL_LANG_FLAG_7 (NODE) = 1, \ 2154 DECL_LANG_SPECIFIC (NODE)->u.f.u3sel = 1) 2155 2156 /* Nonzero if this DECL is the __PRETTY_FUNCTION__ variable in a 2157 template function. */ 2158 #define DECL_PRETTY_FUNCTION_P(NODE) \ 2159 (TREE_LANG_FLAG_0 (NODE)) 2160 2161 /* The _TYPE context in which this _DECL appears. This field holds the 2162 class where a virtual function instance is actually defined. */ 2163 #define DECL_CLASS_CONTEXT(NODE) \ 2164 (DECL_CLASS_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : NULL_TREE) 2165 2166 /* For a non-member friend function, the class (if any) in which this 2167 friend was defined. For example, given: 2168 2169 struct S { friend void f (); }; 2170 2171 the DECL_FRIEND_CONTEXT for `f' will be `S'. */ 2172 #define DECL_FRIEND_CONTEXT(NODE) \ 2173 ((DECL_FRIEND_P (NODE) && !DECL_FUNCTION_MEMBER_P (NODE)) \ 2174 ? DECL_LANG_SPECIFIC (NODE)->u.f.context \ 2175 : NULL_TREE) 2176 2177 /* Set the DECL_FRIEND_CONTEXT for NODE to CONTEXT. */ 2178 #define SET_DECL_FRIEND_CONTEXT(NODE, CONTEXT) \ 2179 (DECL_LANG_SPECIFIC (NODE)->u.f.context = (CONTEXT)) 2180 2181 /* NULL_TREE in DECL_CONTEXT represents the global namespace. */ 2182 #define CP_DECL_CONTEXT(NODE) \ 2183 (DECL_CONTEXT (NODE) ? DECL_CONTEXT (NODE) : global_namespace) 2184 #define FROB_CONTEXT(NODE) ((NODE) == global_namespace ? NULL_TREE : (NODE)) 2185 2186 /* 1 iff NODE has namespace scope, including the global namespace. */ 2187 #define DECL_NAMESPACE_SCOPE_P(NODE) \ 2188 (!DECL_TEMPLATE_PARM_P (NODE) \ 2189 && TREE_CODE (CP_DECL_CONTEXT (NODE)) == NAMESPACE_DECL) 2190 2191 /* 1 iff NODE is a class member. */ 2192 #define DECL_CLASS_SCOPE_P(NODE) \ 2193 (DECL_CONTEXT (NODE) && TYPE_P (DECL_CONTEXT (NODE))) 2194 2195 /* 1 iff NODE is function-local. */ 2196 #define DECL_FUNCTION_SCOPE_P(NODE) \ 2197 (DECL_CONTEXT (NODE) \ 2198 && TREE_CODE (DECL_CONTEXT (NODE)) == FUNCTION_DECL) 2199 2200 /* 1 iff NODE is function-local, but for types. */ 2201 #define LOCAL_CLASS_P(NODE) \ 2202 (decl_function_context (TYPE_MAIN_DECL (NODE)) != NULL_TREE) 2203 2204 /* For a NAMESPACE_DECL: the list of using namespace directives 2205 The PURPOSE is the used namespace, the value is the namespace 2206 that is the common ancestor. */ 2207 #define DECL_NAMESPACE_USING(NODE) DECL_VINDEX (NAMESPACE_DECL_CHECK (NODE)) 2208 2209 /* In a NAMESPACE_DECL, the DECL_INITIAL is used to record all users 2210 of a namespace, to record the transitive closure of using namespace. */ 2211 #define DECL_NAMESPACE_USERS(NODE) DECL_INITIAL (NAMESPACE_DECL_CHECK (NODE)) 2212 2213 /* In a NAMESPACE_DECL, points to the original namespace if this is 2214 a namespace alias. */ 2215 #define DECL_NAMESPACE_ALIAS(NODE) \ 2216 DECL_ABSTRACT_ORIGIN (NAMESPACE_DECL_CHECK (NODE)) 2217 #define ORIGINAL_NAMESPACE(NODE) \ 2218 (DECL_NAMESPACE_ALIAS (NODE) ? DECL_NAMESPACE_ALIAS (NODE) : (NODE)) 2219 2220 /* Nonzero if NODE is the std namespace. */ 2221 #define DECL_NAMESPACE_STD_P(NODE) \ 2222 (TREE_CODE (NODE) == NAMESPACE_DECL \ 2223 && CP_DECL_CONTEXT (NODE) == global_namespace \ 2224 && DECL_NAME (NODE) == std_identifier) 2225 2226 /* In a non-local VAR_DECL with static storage duration, this is the 2227 initialization priority. If this value is zero, the NODE will be 2228 initialized at the DEFAULT_INIT_PRIORITY. */ 2229 #define DECL_INIT_PRIORITY(NODE) (VAR_DECL_CHECK (NODE)->decl.u2.i) 2230 2231 /* In a TREE_LIST concatenating using directives, indicate indirect 2232 directives */ 2233 #define TREE_INDIRECT_USING(NODE) (TREE_LIST_CHECK (NODE)->common.lang_flag_0) 2234 2235 /* In a VAR_DECL for a variable declared in a for statement, 2236 this is the shadowed (local) variable. */ 2237 #define DECL_SHADOWED_FOR_VAR(NODE) DECL_RESULT_FLD(VAR_DECL_CHECK (NODE)) 2238 2239 /* In a FUNCTION_DECL, this is nonzero if this function was defined in 2240 the class definition. We have saved away the text of the function, 2241 but have not yet processed it. */ 2242 #define DECL_PENDING_INLINE_P(NODE) \ 2243 (DECL_LANG_SPECIFIC (NODE)->u.f.pending_inline_p) 2244 2245 /* If DECL_PENDING_INLINE_P holds, this is the saved text of the 2246 function. */ 2247 #define DECL_PENDING_INLINE_INFO(NODE) \ 2248 (DECL_LANG_SPECIFIC (NODE)->u.f.u.pending_inline_info) 2249 2250 /* For a TYPE_DECL: if this structure has many fields, we'll sort them 2251 and put them into a TREE_VEC. */ 2252 #define DECL_SORTED_FIELDS(NODE) \ 2253 (DECL_LANG_SPECIFIC (TYPE_DECL_CHECK (NODE))->u.f.u.sorted_fields) 2254 2255 /* True if on the deferred_fns (see decl2.c) list. */ 2256 #define DECL_DEFERRED_FN(DECL) \ 2257 (DECL_LANG_SPECIFIC (DECL)->decl_flags.deferred) 2258 2259 /* For a VAR_DECL, FUNCTION_DECL, TYPE_DECL or TEMPLATE_DECL: 2260 template-specific information. */ 2261 #define DECL_TEMPLATE_INFO(NODE) \ 2262 (DECL_LANG_SPECIFIC (VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK (NODE)) \ 2263 ->decl_flags.u.template_info) 2264 2265 /* For a VAR_DECL, indicates that the variable has been processed. 2266 This flag is set and unset throughout the code; it is always 2267 used for a temporary purpose. */ 2268 #define DECL_VAR_MARKED_P(NODE) \ 2269 (DECL_LANG_FLAG_4 (VAR_DECL_CHECK (NODE))) 2270 2271 /* Template information for a RECORD_TYPE or UNION_TYPE. */ 2272 #define CLASSTYPE_TEMPLATE_INFO(NODE) \ 2273 (LANG_TYPE_CLASS_CHECK (RECORD_OR_UNION_TYPE_CHECK (NODE))->template_info) 2274 2275 /* Template information for an ENUMERAL_TYPE. Although an enumeration may 2276 not be a primary template, it may be declared within the scope of a 2277 primary template and the enumeration constants may depend on 2278 non-type template parameters. */ 2279 #define ENUM_TEMPLATE_INFO(NODE) (TYPE_BINFO (ENUMERAL_TYPE_CHECK (NODE))) 2280 2281 /* Template information for a template template parameter. */ 2282 #define TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO(NODE) \ 2283 (LANG_TYPE_CLASS_CHECK (BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK (NODE)) \ 2284 ->template_info) 2285 2286 /* Template information for an ENUMERAL_, RECORD_, or UNION_TYPE. */ 2287 #define TYPE_TEMPLATE_INFO(NODE) \ 2288 (TREE_CODE (NODE) == ENUMERAL_TYPE \ 2289 ? ENUM_TEMPLATE_INFO (NODE) : \ 2290 (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM \ 2291 ? TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (NODE) : \ 2292 (TYPE_LANG_SPECIFIC (NODE) \ 2293 ? CLASSTYPE_TEMPLATE_INFO (NODE) \ 2294 : NULL_TREE))) 2295 2296 /* Set the template information for an ENUMERAL_, RECORD_, or 2297 UNION_TYPE to VAL. */ 2298 #define SET_TYPE_TEMPLATE_INFO(NODE, VAL) \ 2299 (TREE_CODE (NODE) == ENUMERAL_TYPE \ 2300 ? (ENUM_TEMPLATE_INFO (NODE) = (VAL)) \ 2301 : (CLASSTYPE_TEMPLATE_INFO (NODE) = (VAL))) 2302 2303 #define TI_TEMPLATE(NODE) (TREE_PURPOSE (NODE)) 2304 #define TI_ARGS(NODE) (TREE_VALUE (NODE)) 2305 #define TI_PENDING_TEMPLATE_FLAG(NODE) TREE_LANG_FLAG_1 (NODE) 2306 2307 /* We use TREE_VECs to hold template arguments. If there is only one 2308 level of template arguments, then the TREE_VEC contains the 2309 arguments directly. If there is more than one level of template 2310 arguments, then each entry in the TREE_VEC is itself a TREE_VEC, 2311 containing the template arguments for a single level. The first 2312 entry in the outer TREE_VEC is the outermost level of template 2313 parameters; the last is the innermost. 2314 2315 It is incorrect to ever form a template argument vector containing 2316 only one level of arguments, but which is a TREE_VEC containing as 2317 its only entry the TREE_VEC for that level. */ 2318 2319 /* Nonzero if the template arguments is actually a vector of vectors, 2320 rather than just a vector. */ 2321 #define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \ 2322 ((NODE) != NULL_TREE \ 2323 && TREE_CODE (NODE) == TREE_VEC \ 2324 && TREE_VEC_LENGTH (NODE) > 0 \ 2325 && TREE_VEC_ELT (NODE, 0) != NULL_TREE \ 2326 && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC) 2327 2328 /* The depth of a template argument vector. When called directly by 2329 the parser, we use a TREE_LIST rather than a TREE_VEC to represent 2330 template arguments. In fact, we may even see NULL_TREE if there 2331 are no template arguments. In both of those cases, there is only 2332 one level of template arguments. */ 2333 #define TMPL_ARGS_DEPTH(NODE) \ 2334 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1) 2335 2336 /* The LEVELth level of the template ARGS. The outermost level of 2337 args is level 1, not level 0. */ 2338 #define TMPL_ARGS_LEVEL(ARGS, LEVEL) \ 2339 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS) \ 2340 ? TREE_VEC_ELT (ARGS, (LEVEL) - 1) : (ARGS)) 2341 2342 /* Set the LEVELth level of the template ARGS to VAL. This macro does 2343 not work with single-level argument vectors. */ 2344 #define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL) \ 2345 (TREE_VEC_ELT (ARGS, (LEVEL) - 1) = (VAL)) 2346 2347 /* Accesses the IDXth parameter in the LEVELth level of the ARGS. */ 2348 #define TMPL_ARG(ARGS, LEVEL, IDX) \ 2349 (TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX)) 2350 2351 /* Set the IDXth element in the LEVELth level of ARGS to VAL. This 2352 macro does not work with single-level argument vectors. */ 2353 #define SET_TMPL_ARG(ARGS, LEVEL, IDX, VAL) \ 2354 (TREE_VEC_ELT (TREE_VEC_ELT ((ARGS), (LEVEL) - 1), (IDX)) = (VAL)) 2355 2356 /* Given a single level of template arguments in NODE, return the 2357 number of arguments. */ 2358 #define NUM_TMPL_ARGS(NODE) \ 2359 ((NODE) == NULL_TREE ? 0 \ 2360 : (TREE_CODE (NODE) == TREE_VEC \ 2361 ? TREE_VEC_LENGTH (NODE) : list_length (NODE))) 2362 2363 /* Returns the innermost level of template arguments in ARGS. */ 2364 #define INNERMOST_TEMPLATE_ARGS(NODE) \ 2365 (get_innermost_template_args ((NODE), 1)) 2366 2367 /* The number of levels of template parameters given by NODE. */ 2368 #define TMPL_PARMS_DEPTH(NODE) \ 2369 ((HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_PURPOSE (NODE))) 2370 2371 /* The TEMPLATE_DECL instantiated or specialized by NODE. This 2372 TEMPLATE_DECL will be the immediate parent, not the most general 2373 template. For example, in: 2374 2375 template <class T> struct S { template <class U> void f(U); } 2376 2377 the FUNCTION_DECL for S<int>::f<double> will have, as its 2378 DECL_TI_TEMPLATE, `template <class U> S<int>::f<U>'. 2379 2380 As a special case, for a member friend template of a template 2381 class, this value will not be a TEMPLATE_DECL, but rather a 2382 LOOKUP_EXPR, IDENTIFIER_NODE or OVERLOAD indicating the name of 2383 the template and any explicit template arguments provided. For 2384 example, in: 2385 2386 template <class T> struct S { friend void f<int>(int, double); } 2387 2388 the DECL_TI_TEMPLATE will be a LOOKUP_EXPR for `f' and the 2389 DECL_TI_ARGS will be {int}. */ 2390 #define DECL_TI_TEMPLATE(NODE) TI_TEMPLATE (DECL_TEMPLATE_INFO (NODE)) 2391 2392 /* The template arguments used to obtain this decl from the most 2393 general form of DECL_TI_TEMPLATE. For the example given for 2394 DECL_TI_TEMPLATE, the DECL_TI_ARGS will be {int, double}. These 2395 are always the full set of arguments required to instantiate this 2396 declaration from the most general template specialized here. */ 2397 #define DECL_TI_ARGS(NODE) TI_ARGS (DECL_TEMPLATE_INFO (NODE)) 2398 #define CLASSTYPE_TI_TEMPLATE(NODE) TI_TEMPLATE (CLASSTYPE_TEMPLATE_INFO (NODE)) 2399 #define CLASSTYPE_TI_ARGS(NODE) TI_ARGS (CLASSTYPE_TEMPLATE_INFO (NODE)) 2400 #define ENUM_TI_TEMPLATE(NODE) \ 2401 TI_TEMPLATE (ENUM_TEMPLATE_INFO (NODE)) 2402 #define ENUM_TI_ARGS(NODE) \ 2403 TI_ARGS (ENUM_TEMPLATE_INFO (NODE)) 2404 2405 /* Like DECL_TI_TEMPLATE, but for an ENUMERAL_, RECORD_, or UNION_TYPE. */ 2406 #define TYPE_TI_TEMPLATE(NODE) \ 2407 (TI_TEMPLATE (TYPE_TEMPLATE_INFO (NODE))) 2408 2409 /* Like DECL_TI_ARGS, but for an ENUMERAL_, RECORD_, or UNION_TYPE. */ 2410 #define TYPE_TI_ARGS(NODE) \ 2411 (TI_ARGS (TYPE_TEMPLATE_INFO (NODE))) 2412 2413 #define INNERMOST_TEMPLATE_PARMS(NODE) TREE_VALUE (NODE) 2414 2415 /* Nonzero if the NODE corresponds to the template parameters for a 2416 member template, whose inline definition is being processed after 2417 the class definition is complete. */ 2418 #define TEMPLATE_PARMS_FOR_INLINE(NODE) TREE_LANG_FLAG_1 (NODE) 2419 2420 /* In a FUNCTION_DECL, the saved language-specific per-function data. */ 2421 #define DECL_SAVED_FUNCTION_DATA(NODE) \ 2422 (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (NODE)) \ 2423 ->u.f.u.saved_language_function) 2424 2425 #define NEW_EXPR_USE_GLOBAL(NODE) TREE_LANG_FLAG_0 (NODE) 2426 #define DELETE_EXPR_USE_GLOBAL(NODE) TREE_LANG_FLAG_0 (NODE) 2427 #define DELETE_EXPR_USE_VEC(NODE) TREE_LANG_FLAG_1 (NODE) 2428 #define LOOKUP_EXPR_GLOBAL(NODE) TREE_LANG_FLAG_0 (NODE) 2429 2430 /* Nonzero if this AGGR_INIT_EXPR provides for initialization via a 2431 constructor call, rather than an ordinary function call. */ 2432 #define AGGR_INIT_VIA_CTOR_P(NODE) \ 2433 TREE_LANG_FLAG_0 (AGGR_INIT_EXPR_CHECK (NODE)) 2434 2435 /* The TYPE_MAIN_DECL for a class template type is a TYPE_DECL, not a 2436 TEMPLATE_DECL. This macro determines whether or not a given class 2437 type is really a template type, as opposed to an instantiation or 2438 specialization of one. */ 2439 #define CLASSTYPE_IS_TEMPLATE(NODE) \ 2440 (CLASSTYPE_TEMPLATE_INFO (NODE) \ 2441 && !CLASSTYPE_USE_TEMPLATE (NODE) \ 2442 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))) 2443 2444 /* The name used by the user to name the typename type. Typically, 2445 this is an IDENTIFIER_NODE, and the same as the DECL_NAME on the 2446 corresponding TYPE_DECL. However, this may also be a 2447 TEMPLATE_ID_EXPR if we had something like `typename X::Y<T>'. */ 2448 #define TYPENAME_TYPE_FULLNAME(NODE) (TYPE_FIELDS (NODE)) 2449 2450 /* Nonzero if NODE is an implicit typename. */ 2451 #define IMPLICIT_TYPENAME_P(NODE) \ 2452 (TREE_CODE (NODE) == TYPENAME_TYPE && TREE_TYPE (NODE)) 2453 2454 /* Nonzero if NODE is a TYPE_DECL that should not be visible because 2455 it is from a dependent base class. */ 2456 #define IMPLICIT_TYPENAME_TYPE_DECL_P(NODE) \ 2457 (TREE_CODE (NODE) == TYPE_DECL \ 2458 && DECL_ARTIFICIAL (NODE) \ 2459 && IMPLICIT_TYPENAME_P (TREE_TYPE (NODE))) 2460 2461 /* Nonzero in INTEGER_CST means that this int is negative by dint of 2462 using a twos-complement negated operand. */ 2463 #define TREE_NEGATED_INT(NODE) TREE_LANG_FLAG_0 (INTEGER_CST_CHECK (NODE)) 2464 2465 /* Nonzero in any kind of _TYPE where conversions to base-classes may 2466 involve pointer arithmetic. If this is zero, then converting to 2467 a base-class never requires changing the value of the pointer. */ 2468 #define TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P(NODE) (TREE_LANG_FLAG_1 (NODE)) 2469 2470 /* [class.virtual] 2471 2472 A class that declares or inherits a virtual function is called a 2473 polymorphic class. */ 2474 #define TYPE_POLYMORPHIC_P(NODE) (TREE_LANG_FLAG_2 (NODE)) 2475 2476 /* Nonzero if this class has a virtual function table pointer. */ 2477 #define TYPE_CONTAINS_VPTR_P(NODE) \ 2478 (TYPE_POLYMORPHIC_P (NODE) \ 2479 || TYPE_USES_VIRTUAL_BASECLASSES (NODE)) 2480 2481 /* This flag is true of a local VAR_DECL if it was declared in a for 2482 statement, but we are no longer in the scope of the for. */ 2483 #define DECL_DEAD_FOR_LOCAL(NODE) DECL_LANG_FLAG_7 (VAR_DECL_CHECK (NODE)) 2484 2485 /* This flag is set on a VAR_DECL that is a DECL_DEAD_FOR_LOCAL 2486 if we already emitted a warning about using it. */ 2487 #define DECL_ERROR_REPORTED(NODE) DECL_LANG_FLAG_0 (VAR_DECL_CHECK (NODE)) 2488 2489 /* Nonzero if NODE is a FUNCTION_DECL (for a function with global 2490 scope) declared in a local scope. */ 2491 #define DECL_LOCAL_FUNCTION_P(NODE) \ 2492 DECL_LANG_FLAG_0 (FUNCTION_DECL_CHECK (NODE)) 2493 2494 /* Nonzero if NODE is a FUNCTION_DECL for a built-in function, and we have 2495 not yet seen a prototype for that function. */ 2496 #define DECL_ANTICIPATED(NODE) \ 2497 (DECL_LANG_SPECIFIC (DECL_CHECK (NODE))->decl_flags.anticipated_p) 2498 2499 /* Record whether a typedef for type `int' was actually `signed int'. */ 2500 #define C_TYPEDEF_EXPLICITLY_SIGNED(EXP) DECL_LANG_FLAG_1 (EXP) 2501 2502 /* Returns nonzero if DECL has external linkage, as specified by the 2503 language standard. (This predicate may hold even when the 2504 corresponding entity is not actually given external linkage in the 2505 object file; see decl_linkage for details.) */ 2506 #define DECL_EXTERNAL_LINKAGE_P(DECL) \ 2507 (decl_linkage (DECL) == lk_external) 2508 2509 #define INTEGRAL_CODE_P(CODE) \ 2510 ((CODE) == INTEGER_TYPE || (CODE) == ENUMERAL_TYPE || (CODE) == BOOLEAN_TYPE) 2511 2512 /* [basic.fundamental] 2513 2514 Types bool, char, wchar_t, and the signed and unsigned integer types 2515 are collectively called integral types. 2516 2517 Note that INTEGRAL_TYPE_P, as defined in tree.h, allows enumeration 2518 types as well, which is incorrect in C++. */ 2519 #define CP_INTEGRAL_TYPE_P(TYPE) \ 2520 (TREE_CODE (TYPE) == BOOLEAN_TYPE \ 2521 || TREE_CODE (TYPE) == INTEGER_TYPE) 2522 2523 /* Returns true if TYPE is an integral or enumeration name. */ 2524 #define INTEGRAL_OR_ENUMERATION_TYPE_P(TYPE) \ 2525 (CP_INTEGRAL_TYPE_P (TYPE) || TREE_CODE (TYPE) == ENUMERAL_TYPE) 2526 2527 /* [basic.fundamental] 2528 2529 Integral and floating types are collectively called arithmetic 2530 types. */ 2531 #define ARITHMETIC_TYPE_P(TYPE) \ 2532 (CP_INTEGRAL_TYPE_P (TYPE) || TREE_CODE (TYPE) == REAL_TYPE) 2533 2534 /* [basic.types] 2535 2536 Arithmetic types, enumeration types, pointer types, and 2537 pointer-to-member types, are collectively called scalar types. */ 2538 #define SCALAR_TYPE_P(TYPE) \ 2539 (ARITHMETIC_TYPE_P (TYPE) \ 2540 || TREE_CODE (TYPE) == ENUMERAL_TYPE \ 2541 || TYPE_PTR_P (TYPE) \ 2542 || TYPE_PTRMEM_P (TYPE) \ 2543 || TYPE_PTRMEMFUNC_P (TYPE)) 2544 2545 /* [dcl.init.aggr] 2546 2547 An aggregate is an array or a class with no user-declared 2548 constructors, no private or protected non-static data members, no 2549 base classes, and no virtual functions. 2550 2551 As an extension, we also treat vectors as aggregates. */ 2552 #define CP_AGGREGATE_TYPE_P(TYPE) \ 2553 (TREE_CODE (TYPE) == ARRAY_TYPE \ 2554 || TREE_CODE (TYPE) == VECTOR_TYPE \ 2555 || (CLASS_TYPE_P (TYPE) \ 2556 && !CLASSTYPE_NON_AGGREGATE (TYPE))) 2557 2558 /* Nonzero for a class type means that the class type has a 2559 user-declared constructor. */ 2560 #define TYPE_HAS_CONSTRUCTOR(NODE) (TYPE_LANG_FLAG_1 (NODE)) 2561 2562 /* When appearing in an INDIRECT_REF, it means that the tree structure 2563 underneath is actually a call to a constructor. This is needed 2564 when the constructor must initialize local storage (which can 2565 be automatically destroyed), rather than allowing it to allocate 2566 space from the heap. 2567 2568 When appearing in a SAVE_EXPR, it means that underneath 2569 is a call to a constructor. 2570 2571 When appearing in a CONSTRUCTOR, it means that it was 2572 a GNU C constructor expression. 2573 2574 When appearing in a FIELD_DECL, it means that this field 2575 has been duly initialized in its constructor. */ 2576 #define TREE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_4 (NODE)) 2577 2578 #define EMPTY_CONSTRUCTOR_P(NODE) (TREE_CODE (NODE) == CONSTRUCTOR \ 2579 && CONSTRUCTOR_ELTS (NODE) == NULL_TREE \ 2580 && ! TREE_HAS_CONSTRUCTOR (NODE)) 2581 2582 /* Nonzero for _TYPE means that the _TYPE defines a destructor. */ 2583 #define TYPE_HAS_DESTRUCTOR(NODE) (TYPE_LANG_FLAG_2 (NODE)) 2584 2585 /* Nonzero means that an object of this type can not be initialized using 2586 an initializer list. */ 2587 #define CLASSTYPE_NON_AGGREGATE(NODE) \ 2588 (LANG_TYPE_CLASS_CHECK (NODE)->non_aggregate) 2589 #define TYPE_NON_AGGREGATE_CLASS(NODE) \ 2590 (IS_AGGR_TYPE (NODE) && CLASSTYPE_NON_AGGREGATE (NODE)) 2591 2592 /* Nonzero if there is a user-defined X::op=(x&) for this class. */ 2593 #define TYPE_HAS_REAL_ASSIGN_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_real_assign_ref) 2594 #define TYPE_HAS_COMPLEX_ASSIGN_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_assign_ref) 2595 #define TYPE_HAS_ABSTRACT_ASSIGN_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_abstract_assign_ref) 2596 #define TYPE_HAS_COMPLEX_INIT_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_init_ref) 2597 2598 /* Nonzero if TYPE has a trivial destructor. From [class.dtor]: 2599 2600 A destructor is trivial if it is an implicitly declared 2601 destructor and if: 2602 2603 - all of the direct base classes of its class have trivial 2604 destructors, 2605 2606 - for all of the non-static data members of its class that are 2607 of class type (or array thereof), each such class has a 2608 trivial destructor. */ 2609 #define TYPE_HAS_TRIVIAL_DESTRUCTOR(NODE) \ 2610 (!TYPE_HAS_NONTRIVIAL_DESTRUCTOR (NODE)) 2611 2612 /* Nonzero for _TYPE node means that this type does not have a trivial 2613 destructor. Therefore, destroying an object of this type will 2614 involve a call to a destructor. This can apply to objects of 2615 ARRAY_TYPE is the type of the elements needs a destructor. */ 2616 #define TYPE_HAS_NONTRIVIAL_DESTRUCTOR(NODE) \ 2617 (TYPE_LANG_FLAG_4 (NODE)) 2618 2619 /* Nonzero for class type means that copy initialization of this type can use 2620 a bitwise copy. */ 2621 #define TYPE_HAS_TRIVIAL_INIT_REF(NODE) \ 2622 (TYPE_HAS_INIT_REF (NODE) && ! TYPE_HAS_COMPLEX_INIT_REF (NODE)) 2623 2624 /* Nonzero for class type means that assignment of this type can use 2625 a bitwise copy. */ 2626 #define TYPE_HAS_TRIVIAL_ASSIGN_REF(NODE) \ 2627 (TYPE_HAS_ASSIGN_REF (NODE) && ! TYPE_HAS_COMPLEX_ASSIGN_REF (NODE)) 2628 2629 #define TYPE_PTRMEM_P(NODE) \ 2630 (TREE_CODE (NODE) == POINTER_TYPE \ 2631 && TREE_CODE (TREE_TYPE (NODE)) == OFFSET_TYPE) 2632 #define TYPE_PTR_P(NODE) \ 2633 (TREE_CODE (NODE) == POINTER_TYPE \ 2634 && TREE_CODE (TREE_TYPE (NODE)) != OFFSET_TYPE) 2635 #define TYPE_PTROB_P(NODE) \ 2636 (TYPE_PTR_P (NODE) && TREE_CODE (TREE_TYPE (NODE)) != FUNCTION_TYPE \ 2637 && TREE_CODE (TREE_TYPE (NODE)) != VOID_TYPE) 2638 #define TYPE_PTROBV_P(NODE) \ 2639 (TYPE_PTR_P (NODE) && TREE_CODE (TREE_TYPE (NODE)) != FUNCTION_TYPE) 2640 #define TYPE_PTRFN_P(NODE) \ 2641 (TREE_CODE (NODE) == POINTER_TYPE \ 2642 && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE) 2643 #define TYPE_REFFN_P(NODE) \ 2644 (TREE_CODE (NODE) == REFERENCE_TYPE \ 2645 && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE) 2646 2647 /* Nonzero for _TYPE node means that this type is a pointer to member 2648 function type. */ 2649 #define TYPE_PTRMEMFUNC_P(NODE) \ 2650 (TREE_CODE (NODE) == RECORD_TYPE \ 2651 && TYPE_LANG_SPECIFIC (NODE) \ 2652 && TYPE_PTRMEMFUNC_FLAG (NODE)) 2653 2654 #define TYPE_PTRMEMFUNC_FLAG(NODE) \ 2655 (LANG_TYPE_CLASS_CHECK (NODE)->ptrmemfunc_flag) 2656 2657 /* Indicates when overload resolution may resolve to a pointer to 2658 member function. [expr.unary.op]/3 */ 2659 #define PTRMEM_OK_P(NODE) TREE_LANG_FLAG_0 (NODE) 2660 2661 /* Get the POINTER_TYPE to the METHOD_TYPE associated with this 2662 pointer to member function. TYPE_PTRMEMFUNC_P _must_ be true, 2663 before using this macro. */ 2664 #define TYPE_PTRMEMFUNC_FN_TYPE(NODE) \ 2665 (TREE_TYPE (TYPE_FIELDS (NODE))) 2666 2667 /* Returns `A' for a type like `int (A::*)(double)' */ 2668 #define TYPE_PTRMEMFUNC_OBJECT_TYPE(NODE) \ 2669 TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE))) 2670 2671 /* These are use to manipulate the canonical RECORD_TYPE from the 2672 hashed POINTER_TYPE, and can only be used on the POINTER_TYPE. */ 2673 #define TYPE_GET_PTRMEMFUNC_TYPE(NODE) \ 2674 (TYPE_LANG_SPECIFIC (NODE) ? LANG_TYPE_PTRMEM_CHECK (NODE)->record : NULL) 2675 #define TYPE_SET_PTRMEMFUNC_TYPE(NODE, VALUE) \ 2676 do { \ 2677 if (TYPE_LANG_SPECIFIC (NODE) == NULL) \ 2678 { \ 2679 TYPE_LANG_SPECIFIC (NODE) = \ 2680 ggc_alloc_cleared (sizeof (struct lang_type_ptrmem)); \ 2681 TYPE_LANG_SPECIFIC (NODE)->u.ptrmem.h.is_lang_type_class = 0; \ 2682 } \ 2683 TYPE_LANG_SPECIFIC (NODE)->u.ptrmem.record = (VALUE); \ 2684 } while (0) 2685 /* Returns the pfn field from a TYPE_PTRMEMFUNC_P. */ 2686 #define PFN_FROM_PTRMEMFUNC(NODE) pfn_from_ptrmemfunc ((NODE)) 2687 2688 /* For a pointer-to-member type of the form `T X::*', this is `X'. 2689 For a type like `void (X::*)() const', this type is `X', not `const 2690 X'. To get at the `const X' you have to look at the 2691 TYPE_PTRMEM_POINTED_TO_TYPE; there, the first parameter will have 2692 type `const X*'. */ 2693 #define TYPE_PTRMEM_CLASS_TYPE(NODE) \ 2694 (TYPE_PTRMEM_P (NODE) \ 2695 ? TYPE_OFFSET_BASETYPE (TREE_TYPE (NODE)) \ 2696 : TYPE_PTRMEMFUNC_OBJECT_TYPE (NODE)) 2697 2698 /* For a pointer-to-member type of the form `T X::*', this is `T'. */ 2699 #define TYPE_PTRMEM_POINTED_TO_TYPE(NODE) \ 2700 (TYPE_PTRMEM_P (NODE) \ 2701 ? TREE_TYPE (TREE_TYPE (NODE)) \ 2702 : TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE))) 2703 2704 /* For a pointer-to-member constant `X::Y' this is the RECORD_TYPE for 2705 `X'. */ 2706 #define PTRMEM_CST_CLASS(NODE) \ 2707 TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (PTRMEM_CST_CHECK (NODE))) 2708 2709 /* For a pointer-to-member constant `X::Y' this is the _DECL for 2710 `Y'. */ 2711 #define PTRMEM_CST_MEMBER(NODE) (((ptrmem_cst_t)PTRMEM_CST_CHECK (NODE))->member) 2712 2713 /* Nonzero for VAR_DECL and FUNCTION_DECL node means that `extern' was 2714 specified in its declaration. This can also be set for an 2715 erroneously declared PARM_DECL. */ 2716 #define DECL_THIS_EXTERN(NODE) \ 2717 DECL_LANG_FLAG_2 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE)) 2718 2719 /* Nonzero for VAR_DECL and FUNCTION_DECL node means that `static' was 2720 specified in its declaration. This can also be set for an 2721 erroneously declared PARM_DECL. */ 2722 #define DECL_THIS_STATIC(NODE) \ 2723 DECL_LANG_FLAG_6 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE)) 2724 2725 /* Nonzero if TYPE is an anonymous union or struct type. We have to use a 2726 flag for this because "A union for which objects or pointers are 2727 declared is not an anonymous union" [class.union]. */ 2728 #define ANON_AGGR_TYPE_P(NODE) \ 2729 (CLASS_TYPE_P (NODE) && LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr) 2730 #define SET_ANON_AGGR_TYPE_P(NODE) \ 2731 (LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr = 1) 2732 2733 /* Nonzero if TYPE is an anonymous union type. */ 2734 #define ANON_UNION_TYPE_P(NODE) \ 2735 (TREE_CODE (NODE) == UNION_TYPE && ANON_AGGR_TYPE_P (NODE)) 2736 2737 #define UNKNOWN_TYPE LANG_TYPE 2738 2739 /* Define fields and accessors for nodes representing declared names. */ 2740 2741 #define TYPE_WAS_ANONYMOUS(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->was_anonymous) 2742 2743 /* C++: all of these are overloaded! These apply only to TYPE_DECLs. */ 2744 2745 /* The format of each node in the DECL_FRIENDLIST is as follows: 2746 2747 The TREE_PURPOSE will be the name of a function, i.e., an 2748 IDENTIFIER_NODE. The TREE_VALUE will be itself a TREE_LIST, the 2749 list of functions with that name which are friends. The 2750 TREE_PURPOSE of each node in this sublist will be error_mark_node, 2751 if the function was declared a friend individually, in which case 2752 the TREE_VALUE will be the function_decl. If, however, all 2753 functions with a given name in a class were declared to be friends, 2754 the TREE_PUROSE will be the class type, and the TREE_VALUE will be 2755 NULL_TREE. */ 2756 #define DECL_FRIENDLIST(NODE) (DECL_INITIAL (NODE)) 2757 #define FRIEND_NAME(LIST) (TREE_PURPOSE (LIST)) 2758 #define FRIEND_DECLS(LIST) (TREE_VALUE (LIST)) 2759 2760 /* The DECL_ACCESS, if non-NULL, is a TREE_LIST. The TREE_PURPOSE of 2761 each node is a type; the TREE_VALUE is the access granted for this 2762 DECL in that type. The DECL_ACCESS is set by access declarations. 2763 For example, if a member that would normally be public in a 2764 derived class is made protected, then the derived class and the 2765 protected_access_node will appear in the DECL_ACCESS for the node. */ 2766 #define DECL_ACCESS(NODE) (LANG_DECL_U2_CHECK (NODE, 0)->access) 2767 2768 /* Nonzero if the FUNCTION_DECL is a global constructor. */ 2769 #define DECL_GLOBAL_CTOR_P(NODE) \ 2770 (DECL_LANG_SPECIFIC (NODE)->decl_flags.global_ctor_p) 2771 2772 /* Nonzero if the FUNCTION_DECL is a global destructor. */ 2773 #define DECL_GLOBAL_DTOR_P(NODE) \ 2774 (DECL_LANG_SPECIFIC (NODE)->decl_flags.global_dtor_p) 2775 2776 /* Accessor macros for C++ template decl nodes. */ 2777 2778 /* The DECL_TEMPLATE_PARMS are a list. The TREE_PURPOSE of each node 2779 is a INT_CST whose TREE_INT_CST_LOW indicates the level of the 2780 template parameters, with 1 being the outermost set of template 2781 parameters. The TREE_VALUE is a vector, whose elements are the 2782 template parameters at each level. Each element in the vector is a 2783 TREE_LIST, whose TREE_VALUE is a PARM_DECL (if the parameter is a 2784 non-type parameter), or a TYPE_DECL (if the parameter is a type 2785 parameter). The TREE_PURPOSE is the default value, if any. The 2786 TEMPLATE_PARM_INDEX for the parameter is avilable as the 2787 DECL_INITIAL (for a PARM_DECL) or as the TREE_TYPE (for a 2788 TYPE_DECL). */ 2789 #define DECL_TEMPLATE_PARMS(NODE) DECL_ARGUMENTS (NODE) 2790 #define DECL_INNERMOST_TEMPLATE_PARMS(NODE) \ 2791 INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (NODE)) 2792 #define DECL_NTPARMS(NODE) \ 2793 TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (NODE)) 2794 /* For function, method, class-data templates. */ 2795 #define DECL_TEMPLATE_RESULT(NODE) DECL_RESULT_FLD (NODE) 2796 /* For a static member variable template, the 2797 DECL_TEMPLATE_INSTANTIATIONS list contains the explicitly and 2798 implicitly generated instantiations of the variable. There are no 2799 partial instantiations of static member variables, so all of these 2800 will be full instantiations. 2801 2802 For a class template the DECL_TEMPLATE_INSTANTIATIONS lists holds 2803 all instantiations and specializations of the class type, including 2804 partial instantiations and partial specializations. 2805 2806 In both cases, the TREE_PURPOSE of each node contains the arguments 2807 used; the TREE_VALUE contains the generated variable. The template 2808 arguments are always complete. For example, given: 2809 2810 template <class T> struct S1 { 2811 template <class U> struct S2 {}; 2812 template <class U> struct S2<U*> {}; 2813 }; 2814 2815 the record for the partial specialization will contain, as its 2816 argument list, { {T}, {U*} }, and will be on the 2817 DECL_TEMPLATE_INSTANTIATIONS list for `template <class T> template 2818 <class U> struct S1<T>::S2'. 2819 2820 This list is not used for function templates. */ 2821 #define DECL_TEMPLATE_INSTANTIATIONS(NODE) DECL_VINDEX (NODE) 2822 /* For a function template, the DECL_TEMPLATE_SPECIALIZATIONS lists 2823 contains all instantiations and specializations of the function, 2824 including partial instantiations. For a partial instantiation 2825 which is a specialization, this list holds only full 2826 specializations of the template that are instantiations of the 2827 partial instantiation. For example, given: 2828 2829 template <class T> struct S { 2830 template <class U> void f(U); 2831 template <> void f(T); 2832 }; 2833 2834 the `S<int>::f<int>(int)' function will appear on the 2835 DECL_TEMPLATE_SPECIALIZATIONS list for both `template <class T> 2836 template <class U> void S<T>::f(U)' and `template <class T> void 2837 S<int>::f(T)'. In the latter case, however, it will have only the 2838 innermost set of arguments (T, in this case). The DECL_TI_TEMPLATE 2839 for the function declaration will point at the specialization, not 2840 the fully general template. 2841 2842 For a class template, this list contains the partial 2843 specializations of this template. (Full specializations are not 2844 recorded on this list.) The TREE_PURPOSE holds the innermost 2845 arguments used in the partial specialization (e.g., for `template 2846 <class T> struct S<T*, int>' this will be `T*'.) The TREE_VALUE 2847 holds the innermost template parameters for the specialization 2848 (e.g., `T' in the example above.) The TREE_TYPE is the _TYPE node 2849 for the partial specialization. 2850 2851 This list is not used for static variable templates. */ 2852 #define DECL_TEMPLATE_SPECIALIZATIONS(NODE) DECL_SIZE (NODE) 2853 2854 /* Nonzero for a DECL which is actually a template parameter. */ 2855 #define DECL_TEMPLATE_PARM_P(NODE) \ 2856 (DECL_LANG_FLAG_0 (NODE) \ 2857 && (TREE_CODE (NODE) == CONST_DECL \ 2858 || TREE_CODE (NODE) == PARM_DECL \ 2859 || TREE_CODE (NODE) == TYPE_DECL \ 2860 || TREE_CODE (NODE) == TEMPLATE_DECL)) 2861 2862 /* Mark NODE as a template parameter. */ 2863 #define SET_DECL_TEMPLATE_PARM_P(NODE) \ 2864 (DECL_LANG_FLAG_0 (NODE) = 1) 2865 2866 /* Nonzero if NODE is a template template parameter. */ 2867 #define DECL_TEMPLATE_TEMPLATE_PARM_P(NODE) \ 2868 (TREE_CODE (NODE) == TEMPLATE_DECL && DECL_TEMPLATE_PARM_P (NODE)) 2869 2870 #define DECL_FUNCTION_TEMPLATE_P(NODE) \ 2871 (TREE_CODE (NODE) == TEMPLATE_DECL \ 2872 && TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == FUNCTION_DECL) 2873 2874 /* Nonzero for a DECL that represents a template class. */ 2875 #define DECL_CLASS_TEMPLATE_P(NODE) \ 2876 (TREE_CODE (NODE) == TEMPLATE_DECL \ 2877 && TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == TYPE_DECL \ 2878 && !DECL_TEMPLATE_TEMPLATE_PARM_P (NODE)) 2879 2880 /* Nonzero if NODE which declares a type. */ 2881 #define DECL_DECLARES_TYPE_P(NODE) \ 2882 (TREE_CODE (NODE) == TYPE_DECL || DECL_CLASS_TEMPLATE_P (NODE)) 2883 2884 /* Nonzero if NODE is the typedef implicitly generated for a type when 2885 the type is declared. In C++, `struct S {};' is roughly 2886 equivalent to `struct S {}; typedef struct S S;' in C. 2887 DECL_IMPLICIT_TYPEDEF_P will hold for the typedef indicated in this 2888 example. In C++, there is a second implicit typedef for each 2889 class, in the scope of `S' itself, so that you can say `S::S'. 2890 DECL_SELF_REFERENCE_P will hold for that second typedef. */ 2891 #define DECL_IMPLICIT_TYPEDEF_P(NODE) \ 2892 (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_2 (NODE)) 2893 #define SET_DECL_IMPLICIT_TYPEDEF_P(NODE) \ 2894 (DECL_LANG_FLAG_2 (NODE) = 1) 2895 #define DECL_SELF_REFERENCE_P(NODE) \ 2896 (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_4 (NODE)) 2897 #define SET_DECL_SELF_REFERENCE_P(NODE) \ 2898 (DECL_LANG_FLAG_4 (NODE) = 1) 2899 2900 /* A `primary' template is one that has its own template header. A 2901 member function of a class template is a template, but not primary. 2902 A member template is primary. Friend templates are primary, too. */ 2903 2904 /* Returns the primary template corresponding to these parameters. */ 2905 #define DECL_PRIMARY_TEMPLATE(NODE) \ 2906 (TREE_TYPE (DECL_INNERMOST_TEMPLATE_PARMS (NODE))) 2907 2908 /* Returns nonzero if NODE is a primary template. */ 2909 #define PRIMARY_TEMPLATE_P(NODE) (DECL_PRIMARY_TEMPLATE (NODE) == (NODE)) 2910 2911 #define CLASSTYPE_TEMPLATE_LEVEL(NODE) \ 2912 (TREE_INT_CST_LOW (TREE_PURPOSE (CLASSTYPE_TI_TEMPLATE (NODE)))) 2913 2914 /* Indicates whether or not (and how) a template was expanded for this 2915 FUNCTION_DECL or VAR_DECL. 2916 0=normal declaration, e.g. int min (int, int); 2917 1=implicit template instantiation 2918 2=explicit template specialization, e.g. int min<int> (int, int); 2919 3=explicit template instantiation, e.g. template int min<int> (int, int); */ 2920 #define DECL_USE_TEMPLATE(NODE) (DECL_LANG_SPECIFIC (NODE)->decl_flags.use_template) 2921 2922 #define DECL_TEMPLATE_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) & 1) 2923 #define CLASSTYPE_TEMPLATE_INSTANTIATION(NODE) \ 2924 (CLASSTYPE_USE_TEMPLATE (NODE) & 1) 2925 2926 #define DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) == 2) 2927 #define SET_DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) = 2) 2928 #define CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \ 2929 (CLASSTYPE_USE_TEMPLATE (NODE) == 2) 2930 #define SET_CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \ 2931 (CLASSTYPE_USE_TEMPLATE (NODE) = 2) 2932 2933 #define DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 1) 2934 #define SET_DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 1) 2935 #define CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \ 2936 (CLASSTYPE_USE_TEMPLATE (NODE) == 1) 2937 #define SET_CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \ 2938 (CLASSTYPE_USE_TEMPLATE (NODE) = 1) 2939 2940 #define DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 3) 2941 #define SET_DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 3) 2942 #define CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \ 2943 (CLASSTYPE_USE_TEMPLATE (NODE) == 3) 2944 #define SET_CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \ 2945 (CLASSTYPE_USE_TEMPLATE (NODE) = 3) 2946 2947 /* Nonzero if DECL is a friend function which is an instantiation 2948 from the point of view of the compiler, but not from the point of 2949 view of the language. For example given: 2950 template <class T> struct S { friend void f(T) {}; }; 2951 the declaration of `void f(int)' generated when S<int> is 2952 instantiated will not be a DECL_TEMPLATE_INSTANTIATION, but will be 2953 a DECL_FRIEND_PSUEDO_TEMPLATE_INSTANTIATION. */ 2954 #define DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION(DECL) \ 2955 (DECL_TEMPLATE_INFO (DECL) && !DECL_USE_TEMPLATE (DECL)) 2956 2957 /* Nonzero if TYPE is a partial instantiation of a template class, 2958 i.e., an instantiation whose instantiation arguments involve 2959 template types. */ 2960 #define PARTIAL_INSTANTIATION_P(TYPE) \ 2961 (LANG_TYPE_CLASS_CHECK (TYPE)->is_partial_instantiation) 2962 2963 /* Nonzero iff we are currently processing a declaration for an 2964 entity with its own template parameter list, and which is not a 2965 full specialization. */ 2966 #define PROCESSING_REAL_TEMPLATE_DECL_P() \ 2967 (processing_template_decl > template_class_depth (current_scope ())) 2968 2969 /* Nonzero if this VAR_DECL or FUNCTION_DECL has already been 2970 instantiated, i.e. its definition has been generated from the 2971 pattern given in the the template. */ 2972 #define DECL_TEMPLATE_INSTANTIATED(NODE) \ 2973 DECL_LANG_FLAG_1 (VAR_OR_FUNCTION_DECL_CHECK (NODE)) 2974 2975 /* We know what we're doing with this decl now. */ 2976 #define DECL_INTERFACE_KNOWN(NODE) DECL_LANG_FLAG_5 (NODE) 2977 2978 /* This function was declared inline. This flag controls the linkage 2979 semantics of 'inline'; whether or not the function is inlined is 2980 controlled by DECL_INLINE. */ 2981 #define DECL_DECLARED_INLINE_P(NODE) \ 2982 (DECL_LANG_SPECIFIC (NODE)->decl_flags.base.declared_inline) 2983 2984 /* DECL_EXTERNAL must be set on a decl until the decl is actually emitted, 2985 so that assemble_external will work properly. So we have this flag to 2986 tell us whether the decl is really not external. */ 2987 #define DECL_NOT_REALLY_EXTERN(NODE) \ 2988 (DECL_LANG_SPECIFIC (NODE)->decl_flags.not_really_extern) 2989 2990 #define DECL_REALLY_EXTERN(NODE) \ 2991 (DECL_EXTERNAL (NODE) && ! DECL_NOT_REALLY_EXTERN (NODE)) 2992 2993 /* A thunk is a stub function. 2994 2995 A thunk is an alternate entry point for an ordinary FUNCTION_DECL. 2996 The address of the ordinary FUNCTION_DECL is given by the 2997 DECL_INITIAL, which is always an ADDR_EXPR whose operand is a 2998 FUNCTION_DECL. The job of the thunk is to adjust the `this' 2999 pointer before transferring control to the FUNCTION_DECL. 3000 3001 A thunk may perform either, or both, of the following operations: 3002 3003 o Adjust the `this' pointer by a constant offset. 3004 o Adjust the `this' pointer by looking up a vcall-offset 3005 in the vtable. 3006 3007 If both operations are performed, then the constant adjument to 3008 `this' is performed first. 3009 3010 The constant adjustment is given by THUNK_DELTA. If the 3011 vcall-offset is required, the index into the vtable is given by 3012 THUNK_VCALL_OFFSET. */ 3013 3014 /* An integer indicating how many bytes should be subtracted from the 3015 `this' pointer when this function is called. */ 3016 #define THUNK_DELTA(DECL) \ 3017 (DECL_LANG_SPECIFIC (DECL)->u.f.delta) 3018 3019 /* A tree indicating how many bytes should be subtracted from the 3020 vtable for the `this' pointer to find the vcall offset. (The vptr 3021 is always located at offset zero from the f `this' pointer.) If 3022 NULL, then there is no vcall offset. */ 3023 #define THUNK_VCALL_OFFSET(DECL) \ 3024 (LANG_DECL_U2_CHECK (DECL, 0)->vcall_offset) 3025 3026 /* These macros provide convenient access to the various _STMT nodes 3027 created when parsing template declarations. */ 3028 #define TRY_STMTS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 0) 3029 #define TRY_HANDLERS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 1) 3030 3031 #define EH_SPEC_STMTS(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 0) 3032 #define EH_SPEC_RAISES(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 1) 3033 3034 #define USING_STMT_NAMESPACE(NODE) TREE_OPERAND (USING_STMT_CHECK (NODE), 0) 3035 3036 /* Nonzero if this try block is a function try block. */ 3037 #define FN_TRY_BLOCK_P(NODE) TREE_LANG_FLAG_3 (TRY_BLOCK_CHECK (NODE)) 3038 #define HANDLER_PARMS(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 0) 3039 #define HANDLER_BODY(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 1) 3040 #define HANDLER_TYPE(NODE) TREE_TYPE (HANDLER_CHECK (NODE)) 3041 3042 /* The parameters for a call-declarator. */ 3043 #define CALL_DECLARATOR_PARMS(NODE) \ 3044 (TREE_PURPOSE (TREE_OPERAND (NODE, 1))) 3045 3046 /* The cv-qualifiers for a call-declarator. */ 3047 #define CALL_DECLARATOR_QUALS(NODE) \ 3048 (TREE_VALUE (TREE_OPERAND (NODE, 1))) 3049 3050 /* The exception-specification for a call-declarator. */ 3051 #define CALL_DECLARATOR_EXCEPTION_SPEC(NODE) \ 3052 (TREE_TYPE (NODE)) 3053 3054 /* An enumeration of the kind of tags that C++ accepts. */ 3055 enum tag_types { record_type, class_type, union_type, enum_type }; 3056 3057 /* The various kinds of lvalues we distinguish. */ 3058 typedef enum cp_lvalue_kind { 3059 clk_none = 0, /* Things that are not an lvalue. */ 3060 clk_ordinary = 1, /* An ordinary lvalue. */ 3061 clk_class = 2, /* An rvalue of class-type. */ 3062 clk_bitfield = 4, /* An lvalue for a bit-field. */ 3063 } cp_lvalue_kind; 3064 3065 /* The kinds of scopes we recognize. */ 3066 typedef enum scope_kind { 3067 sk_template_parms, /* A scope for template parameters. */ 3068 sk_template_spec /* A scope corresponding to a template 3069 specialization. There is never anything in 3070 this scope. */ 3071 } scope_kind; 3072 3073 /* Various kinds of template specialization, instantiation, etc. */ 3074 typedef enum tmpl_spec_kind { 3075 tsk_none, /* Not a template at all. */ 3076 tsk_invalid_member_spec, /* An explicit member template 3077 specialization, but the enclosing 3078 classes have not all been explicitly 3079 specialized. */ 3080 tsk_invalid_expl_inst, /* An explicit instantiation containing 3081 template parameter lists. */ 3082 tsk_excessive_parms, /* A template declaration with too many 3083 template parameter lists. */ 3084 tsk_insufficient_parms, /* A template declaration with too few 3085 parameter lists. */ 3086 tsk_template, /* A template declaration. */ 3087 tsk_expl_spec, /* An explicit specialization. */ 3088 tsk_expl_inst /* An explicit instantiation. */ 3089 } tmpl_spec_kind; 3090 3091 /* The various kinds of access. BINFO_ACCESS depends on these being 3092 two bit quantities. The numerical values are important; they are 3093 used to initialize RTTI data structures, so changing them changes 3094 the ABI. */ 3095 typedef enum access_kind { 3096 ak_none = 0, /* Inaccessible. */ 3097 ak_public = 1, /* Accessible, as a `public' thing. */ 3098 ak_protected = 2, /* Accessible, as a `protected' thing. */ 3099 ak_private = 3 /* Accessible, as a `private' thing. */ 3100 } access_kind; 3101 3102 /* The various kinds of special functions. If you add to this list, 3103 you should update special_function_p as well. */ 3104 typedef enum special_function_kind { 3105 sfk_none = 0, /* Not a special function. This enumeral 3106 must have value zero; see 3107 special_function_p. */ 3108 sfk_constructor, /* A constructor. */ 3109 sfk_copy_constructor, /* A copy constructor. */ 3110 sfk_assignment_operator, /* An assignment operator. */ 3111 sfk_destructor, /* A destructor. */ 3112 sfk_complete_destructor, /* A destructor for complete objects. */ 3113 sfk_base_destructor, /* A destructor for base subobjects. */ 3114 sfk_deleting_destructor, /* A destructor for complete objects that 3115 deletes the object after it has been 3116 destroyed. */ 3117 sfk_conversion /* A conversion operator. */ 3118 } special_function_kind; 3119 3120 /* The various kinds of linkage. From [basic.link], 3121 3122 A name is said to have linkage when it might denote the same 3123 object, reference, function, type, template, namespace or value 3124 as a name introduced in another scope: 3125 3126 -- When a name has external linkage, the entity it denotes can 3127 be referred to from scopes of other translation units or from 3128 other scopes of the same translation unit. 3129 3130 -- When a name has internal linkage, the entity it denotes can 3131 be referred to by names from other scopes in the same 3132 translation unit. 3133 3134 -- When a name has no linkage, the entity it denotes cannot be 3135 referred to by names from other scopes. */ 3136 3137 typedef enum linkage_kind { 3138 lk_none, /* No linkage. */ 3139 lk_internal, /* Internal linkage. */ 3140 lk_external /* External linkage. */ 3141 } linkage_kind; 3142 3143 /* Bitmask flags to control type substitution. */ 3144 typedef enum tsubst_flags_t { 3145 tf_none = 0, /* nothing special */ 3146 tf_error = 1 << 0, /* give error messages */ 3147 tf_warning = 1 << 1, /* give warnings too */ 3148 tf_no_attributes = 1 << 2, /* ignore attributes on comparisons 3149 (instantiate_type use) */ 3150 tf_ignore_bad_quals = 1 << 3, /* ignore bad cvr qualifiers */ 3151 tf_keep_type_decl = 1 << 4, /* retain typedef type decls 3152 (make_typename_type use) */ 3153 tf_ptrmem_ok = 1 << 5, /* pointers to member ok (internal 3154 instantiate_type use) */ 3155 tf_parsing = 1 << 6, /* called from parser 3156 (make_typename_type use) */ 3157 tf_conv = 1 << 8, /* We are determining what kind of 3158 conversion might be permissible, not 3159 actually performing the 3160 conversion. */ 3161 } tsubst_flags_t; 3162 3163 /* The kind of checking we can do looking in a class hierarchy. */ 3164 typedef enum base_access { 3165 ba_any = 0, /* Do not check access, allow an ambiguous base, 3166 prefer a non-virtual base */ 3167 ba_ignore = 1, /* Do not check access */ 3168 ba_check = 2, /* Check access */ 3169 ba_not_special = 3, /* Do not consider special privilege 3170 current_class_type might give. */ 3171 ba_quiet = 4, /* Do not issue error messages (bit mask). */ 3172 } base_access; 3173 3174 /* The kind of base we can find, looking in a class hierarchy. 3175 Values <0 indicate we failed. */ 3176 typedef enum base_kind { 3177 bk_inaccessible = -3, /* The base is inaccessible */ 3178 bk_ambig = -2, /* The base is ambiguous */ 3179 bk_not_base = -1, /* It is not a base */ 3180 bk_same_type = 0, /* It is the same type */ 3181 bk_proper_base = 1, /* It is a proper base */ 3182 bk_via_virtual = 2 /* It is a proper base, but via a virtual 3183 path. This might not be the canonical 3184 binfo. */ 3185 } base_kind; 3186 3187 /* Set by add_implicitly_declared_members() to keep those members from 3188 being flagged as deprecated or reported as using deprecated 3189 types. */ 3190 extern int adding_implicit_members; 3191 3192 /* in decl{2}.c */ 3193 /* A node that is a list (length 1) of error_mark_nodes. */ 3194 extern GTY(()) tree error_mark_list; 3195 3196 /* Node for "pointer to (virtual) function". 3197 This may be distinct from ptr_type_node so gdb can distinguish them. */ 3198 #define vfunc_ptr_type_node vtable_entry_type 3199 3200 3201 /* For building calls to `delete'. */ 3202 extern GTY(()) tree integer_two_node; 3203 extern GTY(()) tree integer_three_node; 3204 3205 extern GTY(()) tree anonymous_namespace_name; 3206 3207 /* The number of function bodies which we are currently processing. 3208 (Zero if we are at namespace scope, one inside the body of a 3209 function, two inside the body of a function in a local class, etc.) */ 3210 extern int function_depth; 3211 3212 /* in pt.c */ 3213 3214 /* These values are used for the `STRICT' parameter to type_unification and 3215 fn_type_unification. Their meanings are described with the 3216 documentation for fn_type_unification. */ 3217 3218 typedef enum unification_kind_t { 3219 DEDUCE_CALL, 3220 DEDUCE_CONV, 3221 DEDUCE_EXACT, 3222 DEDUCE_ORDER 3223 } unification_kind_t; 3224 3225 /* Macros for operating on a template instantiation level node, represented 3226 by an EXPR_WITH_FILE_LOCATION. */ 3227 3228 #define TINST_DECL(NODE) EXPR_WFL_NODE (NODE) 3229 #define TINST_LINE(NODE) EXPR_WFL_LINENO (NODE) 3230 #define TINST_FILE(NODE) EXPR_WFL_FILENAME (NODE) 3231 3232 /* in class.c */ 3233 3234 extern int current_class_depth; 3235 3236 /* An array of all local classes present in this translation unit, in 3237 declaration order. */ 3238 extern GTY(()) varray_type local_classes; 3239 3240 /* Here's where we control how name mangling takes place. */ 3241 3242 /* Cannot use '$' up front, because this confuses gdb 3243 (names beginning with '$' are gdb-local identifiers). 3244 3245 Note that all forms in which the '$' is significant are long enough 3246 for direct indexing (meaning that if we know there is a '$' 3247 at a particular location, we can index into the string at 3248 any other location that provides distinguishing characters). */ 3249 3250 /* Define NO_DOLLAR_IN_LABEL in your favorite tm file if your assembler 3251 doesn't allow '$' in symbol names. */ 3252 #ifndef NO_DOLLAR_IN_LABEL 3253 3254 #define JOINER '$' 3255 3256 #define VPTR_NAME "$v" 3257 #define THROW_NAME "$eh_throw" 3258 #define AUTO_VTABLE_NAME "__vtbl$me__" 3259 #define AUTO_TEMP_NAME "_$tmp_" 3260 #define AUTO_TEMP_FORMAT "_$tmp_%d" 3261 #define VTABLE_BASE "$vb" 3262 #define VTABLE_NAME_PREFIX "__vt_" 3263 #define VFIELD_BASE "$vf" 3264 #define VFIELD_NAME "_vptr$" 3265 #define VFIELD_NAME_FORMAT "_vptr$%s" 3266 #define STATIC_NAME_FORMAT "_%s$%s" 3267 #define ANON_AGGRNAME_FORMAT "$_%d" 3268 3269 #else /* NO_DOLLAR_IN_LABEL */ 3270 3271 #ifndef NO_DOT_IN_LABEL 3272 3273 #define JOINER '.' 3274 3275 #define VPTR_NAME ".v" 3276 #define THROW_NAME ".eh_throw" 3277 #define AUTO_VTABLE_NAME "__vtbl.me__" 3278 #define AUTO_TEMP_NAME "_.tmp_" 3279 #define AUTO_TEMP_FORMAT "_.tmp_%d" 3280 #define VTABLE_BASE ".vb" 3281 #define VTABLE_NAME_PREFIX "__vt_" 3282 #define VFIELD_BASE ".vf" 3283 #define VFIELD_NAME "_vptr." 3284 #define VFIELD_NAME_FORMAT "_vptr.%s" 3285 #define STATIC_NAME_FORMAT "_%s.%s" 3286 3287 #define ANON_AGGRNAME_FORMAT "._%d" 3288 3289 #else /* NO_DOT_IN_LABEL */ 3290 3291 #define VPTR_NAME "__vptr" 3292 #define VPTR_NAME_P(ID_NODE) \ 3293 (!strncmp (IDENTIFIER_POINTER (ID_NODE), VPTR_NAME, sizeof (VPTR_NAME) - 1)) 3294 #define THROW_NAME "__eh_throw" 3295 #define IN_CHARGE_NAME "__in_chrg" 3296 #define AUTO_VTABLE_NAME "__vtbl_me__" 3297 #define AUTO_TEMP_NAME "__tmp_" 3298 #define TEMP_NAME_P(ID_NODE) \ 3299 (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, \ 3300 sizeof (AUTO_TEMP_NAME) - 1)) 3301 #define AUTO_TEMP_FORMAT "__tmp_%d" 3302 #define VTABLE_BASE "__vtb" 3303 #define VTABLE_NAME "__vt_" 3304 #define VTABLE_NAME_PREFIX "__vt_" 3305 #define VTABLE_NAME_P(ID_NODE) \ 3306 (!strncmp (IDENTIFIER_POINTER (ID_NODE), VTABLE_NAME, \ 3307 sizeof (VTABLE_NAME) - 1)) 3308 #define VFIELD_BASE "__vfb" 3309 #define VFIELD_NAME "__vptr_" 3310 #define VFIELD_NAME_P(ID_NODE) \ 3311 (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, \ 3312 sizeof (VFIELD_NAME) - 1)) 3313 #define VFIELD_NAME_FORMAT "__vptr_%s" 3314 #define STATIC_NAME_FORMAT "__static_%s_%s" 3315 3316 #define ANON_AGGRNAME_PREFIX "__anon_" 3317 #define ANON_AGGRNAME_P(ID_NODE) \ 3318 (!strncmp (IDENTIFIER_POINTER (ID_NODE), ANON_AGGRNAME_PREFIX, \ 3319 sizeof (ANON_AGGRNAME_PREFIX) - 1)) 3320 #define ANON_AGGRNAME_FORMAT "__anon_%d" 3321 3322 #endif /* NO_DOT_IN_LABEL */ 3323 #endif /* NO_DOLLAR_IN_LABEL */ 3324 3325 #define THIS_NAME "this" 3326 #define CTOR_NAME "__ct" 3327 #define DTOR_NAME "__dt" 3328 3329 #define IN_CHARGE_NAME "__in_chrg" 3330 3331 #define VTBL_PTR_TYPE "__vtbl_ptr_type" 3332 #define VTABLE_DELTA_NAME "__delta" 3333 #define VTABLE_PFN_NAME "__pfn" 3334 3335 #define EXCEPTION_CLEANUP_NAME "exception cleanup" 3336 3337 #if !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL) 3338 3339 #define VPTR_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER \ 3340 && IDENTIFIER_POINTER (ID_NODE)[1] == 'v') 3341 3342 #define VTABLE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == 'v' \ 3343 && IDENTIFIER_POINTER (ID_NODE)[2] == 't' \ 3344 && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER) 3345 3346 #define TEMP_NAME_P(ID_NODE) \ 3347 (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, sizeof (AUTO_TEMP_NAME)-1)) 3348 #define VFIELD_NAME_P(ID_NODE) \ 3349 (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, sizeof(VFIELD_NAME)-1)) 3350 3351 /* For anonymous aggregate types, we need some sort of name to 3352 hold on to. In practice, this should not appear, but it should 3353 not be harmful if it does. */ 3354 #define ANON_AGGRNAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER \ 3355 && IDENTIFIER_POINTER (ID_NODE)[1] == '_') 3356 #endif /* !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL) */ 3357 3358 /* Returns nonzero iff NODE is a declaration for the global function 3359 `main'. */ 3360 #define DECL_MAIN_P(NODE) \ 3361 (DECL_EXTERN_C_FUNCTION_P (NODE) \ 3362 && DECL_NAME (NODE) != NULL_TREE \ 3363 && MAIN_NAME_P (DECL_NAME (NODE))) 3364 3365 3366 /* Nonzero if we're done parsing and into end-of-file activities. */ 3367 3368 extern int at_eof; 3369 3370 /* A list of namespace-scope objects which have constructors or 3371 destructors which reside in the global scope. The decl is stored 3372 in the TREE_VALUE slot and the initializer is stored in the 3373 TREE_PURPOSE slot. */ 3374 extern GTY(()) tree static_aggregates; 3375 3376 /* Functions called along with real static constructors and destructors. */ 3377 3378 extern GTY(()) tree static_ctors; 3379 extern GTY(()) tree static_dtors; 3380 3381 enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, OP_FLAG, TYPENAME_FLAG }; 3382 3383 /* Some macros for char-based bitfields. */ 3384 #define B_SET(A,X) ((A)[(X)>>3] |= (1 << ((X)&7))) 3385 #define B_CLR(A,X) ((A)[(X)>>3] &= ~(1 << ((X)&7))) 3386 #define B_TST(A,X) ((A)[(X)>>3] & (1 << ((X)&7))) 3387 3388 /* These are uses as bits in flags passed to build_method_call 3389 to control its error reporting behavior. 3390 3391 LOOKUP_PROTECT means flag access violations. 3392 LOOKUP_COMPLAIN mean complain if no suitable member function 3393 matching the arguments is found. 3394 LOOKUP_NORMAL is just a combination of these two. 3395 LOOKUP_NONVIRTUAL means make a direct call to the member function found 3396 LOOKUP_GLOBAL means search through the space of overloaded functions, 3397 as well as the space of member functions. 3398 LOOKUP_ONLYCONVERTING means that non-conversion constructors are not tried. 3399 DIRECT_BIND means that if a temporary is created, it should be created so 3400 that it lives as long as the current variable bindings; otherwise it 3401 only lives until the end of the complete-expression. It also forces 3402 direct-initialization in cases where other parts of the compiler have 3403 already generated a temporary, such as reference initialization and the 3404 catch parameter. 3405 LOOKUP_SPECULATIVELY means return NULL_TREE if we cannot find what we are 3406 after. Note, LOOKUP_COMPLAIN is checked and error messages printed 3407 before LOOKUP_SPECULATIVELY is checked. 3408 LOOKUP_NO_CONVERSION means that user-defined conversions are not 3409 permitted. Built-in conversions are permitted. 3410 LOOKUP_DESTRUCTOR means explicit call to destructor. 3411 LOOKUP_NO_TEMP_BIND means temporaries will not be bound to references. 3412 3413 These are used in global lookup to support elaborated types and 3414 qualifiers. 3415 3416 LOOKUP_PREFER_TYPES means not to accept objects, and possibly namespaces. 3417 LOOKUP_PREFER_NAMESPACES means not to accept objects, and possibly types. 3418 LOOKUP_PREFER_BOTH means class-or-namespace-name. 3419 LOOKUP_TEMPLATES_EXPECTED means that class templates also count 3420 as types. */ 3421 3422 #define LOOKUP_PROTECT (1) 3423 #define LOOKUP_COMPLAIN (2) 3424 #define LOOKUP_NORMAL (3) 3425 #define LOOKUP_NONVIRTUAL (8) 3426 #define LOOKUP_GLOBAL (16) 3427 #define LOOKUP_SPECULATIVELY (64) 3428 #define LOOKUP_ONLYCONVERTING (128) 3429 #define DIRECT_BIND (256) 3430 #define LOOKUP_NO_CONVERSION (512) 3431 #define LOOKUP_DESTRUCTOR (512) 3432 #define LOOKUP_NO_TEMP_BIND (1024) 3433 #define LOOKUP_PREFER_TYPES (2048) 3434 #define LOOKUP_PREFER_NAMESPACES (4096) 3435 #define LOOKUP_PREFER_BOTH (6144) 3436 #define LOOKUP_TEMPLATES_EXPECTED (8192) 3437 3438 #define LOOKUP_NAMESPACES_ONLY(F) \ 3439 (((F) & LOOKUP_PREFER_NAMESPACES) && !((F) & LOOKUP_PREFER_TYPES)) 3440 #define LOOKUP_TYPES_ONLY(F) \ 3441 (!((F) & LOOKUP_PREFER_NAMESPACES) && ((F) & LOOKUP_PREFER_TYPES)) 3442 #define LOOKUP_QUALIFIERS_ONLY(F) ((F) & LOOKUP_PREFER_BOTH) 3443 3444 3445 /* These flags are used by the conversion code. 3446 CONV_IMPLICIT : Perform implicit conversions (standard and user-defined). 3447 CONV_STATIC : Perform the explicit conversions for static_cast. 3448 CONV_CONST : Perform the explicit conversions for const_cast. 3449 CONV_REINTERPRET: Perform the explicit conversions for reinterpret_cast. 3450 CONV_PRIVATE : Perform upcasts to private bases. 3451 CONV_FORCE_TEMP : Require a new temporary when converting to the same 3452 aggregate type. */ 3453 3454 #define CONV_IMPLICIT 1 3455 #define CONV_STATIC 2 3456 #define CONV_CONST 4 3457 #define CONV_REINTERPRET 8 3458 #define CONV_PRIVATE 16 3459 /* #define CONV_NONCONVERTING 32 */ 3460 #define CONV_FORCE_TEMP 64 3461 #define CONV_STATIC_CAST (CONV_IMPLICIT | CONV_STATIC | CONV_FORCE_TEMP) 3462 #define CONV_OLD_CONVERT (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \ 3463 | CONV_REINTERPRET) 3464 #define CONV_C_CAST (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \ 3465 | CONV_REINTERPRET | CONV_PRIVATE | CONV_FORCE_TEMP) 3466 3467 /* Used by build_expr_type_conversion to indicate which types are 3468 acceptable as arguments to the expression under consideration. */ 3469 3470 #define WANT_INT 1 /* integer types, including bool */ 3471 #define WANT_FLOAT 2 /* floating point types */ 3472 #define WANT_ENUM 4 /* enumerated types */ 3473 #define WANT_POINTER 8 /* pointer types */ 3474 #define WANT_NULL 16 /* null pointer constant */ 3475 #define WANT_ARITH (WANT_INT | WANT_FLOAT) 3476 3477 /* Used with comptypes, and related functions, to guide type 3478 comparison. */ 3479 3480 #define COMPARE_STRICT 0 /* Just check if the types are the 3481 same. */ 3482 #define COMPARE_BASE 1 /* Check to see if the second type is 3483 derived from the first, or if both 3484 are pointers (or references) and 3485 the types pointed to by the second 3486 type is derived from the pointed to 3487 by the first. */ 3488 #define COMPARE_RELAXED 2 /* Like COMPARE_DERIVED, but in 3489 reverse. Also treat enumeration 3490 types as the same as integer types 3491 of the same width. */ 3492 #define COMPARE_REDECLARATION 4 /* The comparsion is being done when 3493 another declaration of an existing 3494 entity is seen. */ 3495 #define COMPARE_NO_ATTRIBUTES 8 /* The comparison should ignore 3496 extra-linguistic type attributes. */ 3497 3498 /* Used with push_overloaded_decl. */ 3499 #define PUSH_GLOBAL 0 /* Push the DECL into namespace scope, 3500 regardless of the current scope. */ 3501 #define PUSH_LOCAL 1 /* Push the DECL into the current 3502 scope. */ 3503 #define PUSH_USING 2 /* We are pushing this DECL as the 3504 result of a using declaration. */ 3505 3506 /* Used with start function. */ 3507 #define SF_DEFAULT 0 /* No flags. */ 3508 #define SF_PRE_PARSED 1 /* The function declaration has 3509 already been parsed. */ 3510 #define SF_INCLASS_INLINE 2 /* The function is an inline, defined 3511 in the class body. */ 3512 3513 /* Returns nonzero iff TYPE1 and TYPE2 are the same type, or if TYPE2 3514 is derived from TYPE1, or if TYPE2 is a pointer (reference) to a 3515 class derived from the type pointed to (referred to) by TYPE1. */ 3516 #define same_or_base_type_p(TYPE1, TYPE2) \ 3517 comptypes ((TYPE1), (TYPE2), COMPARE_BASE) 3518 3519 /* These macros are used to access a TEMPLATE_PARM_INDEX. */ 3520 #define TEMPLATE_PARM_INDEX_CAST(NODE) \ 3521 ((template_parm_index*)TEMPLATE_PARM_INDEX_CHECK (NODE)) 3522 #define TEMPLATE_PARM_IDX(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->index) 3523 #define TEMPLATE_PARM_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->level) 3524 #define TEMPLATE_PARM_DESCENDANTS(NODE) (TREE_CHAIN (NODE)) 3525 #define TEMPLATE_PARM_ORIG_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->orig_level) 3526 #define TEMPLATE_PARM_DECL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->decl) 3527 3528 /* These macros are for accessing the fields of TEMPLATE_TYPE_PARM, 3529 TEMPLATE_TEMPLATE_PARM and BOUND_TEMPLATE_TEMPLATE_PARM nodes. */ 3530 #define TEMPLATE_TYPE_PARM_INDEX(NODE) (TYPE_FIELDS (NODE)) 3531 #define TEMPLATE_TYPE_IDX(NODE) \ 3532 (TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (NODE))) 3533 #define TEMPLATE_TYPE_LEVEL(NODE) \ 3534 (TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE))) 3535 #define TEMPLATE_TYPE_ORIG_LEVEL(NODE) \ 3536 (TEMPLATE_PARM_ORIG_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE))) 3537 #define TEMPLATE_TYPE_DECL(NODE) \ 3538 (TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (NODE))) 3539 3540 /* These constants can used as bit flags in the process of tree formatting. 3541 3542 TFF_PLAIN_IDENTIFIER: unqualified part of a name. 3543 TFF_SCOPE: include the class and namespace scope of the name. 3544 TFF_CHASE_TYPEDEF: print the original type-id instead of the typedef-name. 3545 TFF_DECL_SPECIFIERS: print decl-specifiers. 3546 TFF_CLASS_KEY_OR_ENUM: precede a class-type name (resp. enum name) with 3547 a class-key (resp. `enum'). 3548 TFF_RETURN_TYPE: include function return type. 3549 TFF_FUNCTION_DEFAULT_ARGUMENTS: include function default parameter values. 3550 TFF_EXCEPTION_SPECIFICATION: show function exception specification. 3551 TFF_TEMPLATE_HEADER: show the template<...> header in a 3552 template-declaration. 3553 TFF_TEMPLATE_NAME: show only template-name. 3554 TFF_EXPR_IN_PARENS: parenthesize expressions. 3555 TFF_NO_FUNCTION_ARGUMENTS: don't show function arguments. */ 3556 3557 #define TFF_PLAIN_IDENTIFIER (0) 3558 #define TFF_SCOPE (1) 3559 #define TFF_CHASE_TYPEDEF (1 << 1) 3560 #define TFF_DECL_SPECIFIERS (1 << 2) 3561 #define TFF_CLASS_KEY_OR_ENUM (1 << 3) 3562 #define TFF_RETURN_TYPE (1 << 4) 3563 #define TFF_FUNCTION_DEFAULT_ARGUMENTS (1 << 5) 3564 #define TFF_EXCEPTION_SPECIFICATION (1 << 6) 3565 #define TFF_TEMPLATE_HEADER (1 << 7) 3566 #define TFF_TEMPLATE_NAME (1 << 8) 3567 #define TFF_EXPR_IN_PARENS (1 << 9) 3568 #define TFF_NO_FUNCTION_ARGUMENTS (1 << 10) 3569 3570 /* Returns the TEMPLATE_DECL associated to a TEMPLATE_TEMPLATE_PARM 3571 node. */ 3572 #define TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL(NODE) \ 3573 ((TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM) \ 3574 ? TYPE_TI_TEMPLATE (NODE) \ 3575 : TYPE_NAME (NODE)) 3576 3577 /* in lex.c */ 3578 3579 extern void init_reswords PARAMS ((void)); 3580 3581 /* Indexed by TREE_CODE, these tables give C-looking names to 3582 operators represented by TREE_CODES. For example, 3583 opname_tab[(int) MINUS_EXPR] == "-". */ 3584 extern const char **opname_tab, **assignop_tab; 3585 3586 typedef struct operator_name_info_t 3587 { 3588 /* The IDENTIFIER_NODE for the operator. */ 3589 tree identifier; 3590 /* The name of the operator. */ 3591 const char *name; 3592 /* The mangled name of the operator. */ 3593 const char *mangled_name; 3594 /* The arity of the operator. */ 3595 int arity; 3596 } operator_name_info_t; 3597 3598 /* A mapping from tree codes to operator name information. */ 3599 extern operator_name_info_t operator_name_info[]; 3600 /* Similar, but for assignment operators. */ 3601 extern operator_name_info_t assignment_operator_name_info[]; 3602 3603 /* in call.c */ 3604 extern int check_dtor_name PARAMS ((tree, tree)); 3605 extern int get_arglist_len_in_bytes PARAMS ((tree)); 3606 3607 extern tree build_vfield_ref PARAMS ((tree, tree)); 3608 extern tree build_scoped_method_call PARAMS ((tree, tree, tree, tree)); 3609 extern tree build_conditional_expr PARAMS ((tree, tree, tree)); 3610 extern tree build_addr_func PARAMS ((tree)); 3611 extern tree build_call PARAMS ((tree, tree)); 3612 extern tree build_method_call PARAMS ((tree, tree, tree, tree, int)); 3613 extern int null_ptr_cst_p PARAMS ((tree)); 3614 extern int sufficient_parms_p PARAMS ((tree)); 3615 extern tree type_decays_to PARAMS ((tree)); 3616 extern tree resolve_scoped_fn_name PARAMS ((tree, tree)); 3617 extern tree build_user_type_conversion PARAMS ((tree, tree, int)); 3618 extern tree build_new_function_call PARAMS ((tree, tree)); 3619 extern tree build_new_method_call (tree, tree, tree, tree, int); 3620 extern tree build_special_member_call (tree, tree, tree, tree, int); 3621 extern tree build_new_op PARAMS ((enum tree_code, int, tree, tree, tree)); 3622 extern tree build_op_delete_call PARAMS ((enum tree_code, tree, tree, int, tree)); 3623 extern int can_convert PARAMS ((tree, tree)); 3624 extern int can_convert_arg PARAMS ((tree, tree, tree)); 3625 extern int can_convert_arg_bad PARAMS ((tree, tree, tree)); 3626 extern int enforce_access PARAMS ((tree, tree)); 3627 extern tree convert_default_arg PARAMS ((tree, tree, tree, int)); 3628 extern tree convert_arg_to_ellipsis PARAMS ((tree)); 3629 extern tree build_x_va_arg PARAMS ((tree, tree)); 3630 extern tree cxx_type_promotes_to PARAMS ((tree)); 3631 extern tree type_passed_as PARAMS ((tree)); 3632 extern tree convert_for_arg_passing PARAMS ((tree, tree)); 3633 extern tree cp_convert_parm_for_inlining PARAMS ((tree, tree, tree)); 3634 extern int is_properly_derived_from PARAMS ((tree, tree)); 3635 extern tree initialize_reference PARAMS ((tree, tree, tree, tree *)); 3636 extern tree make_temporary_var_for_ref_to_temp (tree, tree); 3637 extern tree strip_top_quals PARAMS ((tree)); 3638 extern tree perform_implicit_conversion PARAMS ((tree, tree)); 3639 extern tree perform_direct_initialization_if_possible (tree, tree); 3640 3641 /* in class.c */ 3642 extern tree build_base_path PARAMS ((enum tree_code, tree, tree, int)); 3643 extern tree convert_to_base (tree, tree, bool); 3644 extern tree convert_to_base_statically (tree, tree); 3645 extern tree build_vtbl_ref PARAMS ((tree, tree)); 3646 extern tree build_vfn_ref PARAMS ((tree, tree)); 3647 extern tree get_vtable_decl PARAMS ((tree, int)); 3648 extern void add_method PARAMS ((tree, tree, int)); 3649 extern int currently_open_class PARAMS ((tree)); 3650 extern tree currently_open_derived_class PARAMS ((tree)); 3651 extern void duplicate_tag_error PARAMS ((tree)); 3652 extern tree finish_struct PARAMS ((tree, tree)); 3653 extern void finish_struct_1 PARAMS ((tree)); 3654 extern int resolves_to_fixed_type_p PARAMS ((tree, int *)); 3655 extern void init_class_processing PARAMS ((void)); 3656 extern int is_empty_class PARAMS ((tree)); 3657 extern void pushclass PARAMS ((tree, int)); 3658 extern void popclass PARAMS ((void)); 3659 extern void push_nested_class PARAMS ((tree, int)); 3660 extern void pop_nested_class PARAMS ((void)); 3661 extern int current_lang_depth PARAMS ((void)); 3662 extern void push_lang_context PARAMS ((tree)); 3663 extern void pop_lang_context PARAMS ((void)); 3664 extern tree instantiate_type PARAMS ((tree, tree, tsubst_flags_t)); 3665 extern void print_class_statistics PARAMS ((void)); 3666 extern void cxx_print_statistics PARAMS ((void)); 3667 extern void cxx_print_xnode PARAMS ((FILE *, tree, int)); 3668 extern void cxx_print_decl PARAMS ((FILE *, tree, int)); 3669 extern void cxx_print_type PARAMS ((FILE *, tree, int)); 3670 extern void cxx_print_identifier PARAMS ((FILE *, tree, int)); 3671 extern void cxx_print_error_function PARAMS ((struct diagnostic_context *, 3672 const char *)); 3673 extern void build_self_reference PARAMS ((void)); 3674 extern int same_signature_p PARAMS ((tree, tree)); 3675 extern void warn_hidden PARAMS ((tree)); 3676 extern void maybe_add_class_template_decl_list PARAMS ((tree, tree, int)); 3677 extern tree get_enclosing_class PARAMS ((tree)); 3678 int is_base_of_enclosing_class PARAMS ((tree, tree)); 3679 extern void unreverse_member_declarations PARAMS ((tree)); 3680 extern void invalidate_class_lookup_cache PARAMS ((void)); 3681 extern void maybe_note_name_used_in_class PARAMS ((tree, tree)); 3682 extern void note_name_declared_in_class PARAMS ((tree, tree)); 3683 extern tree get_vtbl_decl_for_binfo PARAMS ((tree)); 3684 extern tree in_charge_arg_for_name PARAMS ((tree)); 3685 extern tree build_cxx_call PARAMS ((tree, tree, tree)); 3686 extern tree get_vtt_name PARAMS ((tree)); 3687 extern tree get_primary_binfo PARAMS ((tree)); 3688 3689 /* in cvt.c */ 3690 extern tree convert_to_reference PARAMS ((tree, tree, int, int, tree)); 3691 extern tree convert_from_reference PARAMS ((tree)); 3692 extern tree convert_lvalue PARAMS ((tree, tree)); 3693 extern tree force_rvalue PARAMS ((tree)); 3694 extern tree ocp_convert PARAMS ((tree, tree, int, int)); 3695 extern tree cp_convert PARAMS ((tree, tree)); 3696 extern tree convert_to_void PARAMS ((tree, const char */*implicit context*/)); 3697 extern tree convert_force PARAMS ((tree, tree, int)); 3698 extern tree build_type_conversion PARAMS ((tree, tree)); 3699 extern tree build_expr_type_conversion PARAMS ((int, tree, int)); 3700 extern tree type_promotes_to PARAMS ((tree)); 3701 extern tree perform_qualification_conversions PARAMS ((tree, tree)); 3702 extern void clone_function_decl PARAMS ((tree, int)); 3703 extern void adjust_clone_args PARAMS ((tree)); 3704 3705 /* decl.c */ 3706 extern int global_bindings_p PARAMS ((void)); 3707 extern int kept_level_p PARAMS ((void)); 3708 extern bool innermost_scope_is_class_p (void); 3709 extern tree getdecls PARAMS ((void)); 3710 extern void pushlevel PARAMS ((int)); 3711 extern tree poplevel PARAMS ((int,int, int)); 3712 extern void insert_block PARAMS ((tree)); 3713 extern void set_block PARAMS ((tree)); 3714 extern tree pushdecl PARAMS ((tree)); 3715 extern void cxx_init_decl_processing PARAMS ((void)); 3716 enum cp_tree_node_structure_enum cp_tree_node_structure 3717 PARAMS ((union lang_tree_node *)); 3718 extern void cxx_insert_default_attributes PARAMS ((tree)); 3719 extern bool cxx_mark_addressable PARAMS ((tree)); 3720 extern void cxx_push_function_context PARAMS ((struct function *)); 3721 extern void cxx_pop_function_context PARAMS ((struct function *)); 3722 extern void cxx_mark_function_context PARAMS ((struct function *)); 3723 extern int toplevel_bindings_p PARAMS ((void)); 3724 extern int namespace_bindings_p PARAMS ((void)); 3725 extern void keep_next_level PARAMS ((int)); 3726 extern int template_parm_scope_p PARAMS ((void)); 3727 extern void set_class_shadows PARAMS ((tree)); 3728 extern void maybe_push_cleanup_level PARAMS ((tree)); 3729 extern void begin_scope PARAMS ((scope_kind)); 3730 extern void finish_scope PARAMS ((void)); 3731 extern void note_level_for_for PARAMS ((void)); 3732 extern void note_level_for_try PARAMS ((void)); 3733 extern void note_level_for_catch PARAMS ((void)); 3734 extern void resume_level PARAMS ((struct cp_binding_level *)); 3735 extern void delete_block PARAMS ((tree)); 3736 extern void add_block_current_level PARAMS ((tree)); 3737 extern void pushlevel_class PARAMS ((void)); 3738 extern void poplevel_class PARAMS ((void)); 3739 extern void print_binding_stack PARAMS ((void)); 3740 extern void print_binding_level PARAMS ((struct cp_binding_level *)); 3741 extern void push_namespace PARAMS ((tree)); 3742 extern void pop_namespace PARAMS ((void)); 3743 extern void push_nested_namespace PARAMS ((tree)); 3744 extern void pop_nested_namespace PARAMS ((tree)); 3745 extern void maybe_push_to_top_level PARAMS ((int)); 3746 extern void push_to_top_level PARAMS ((void)); 3747 extern void pop_from_top_level PARAMS ((void)); 3748 extern void push_switch PARAMS ((tree)); 3749 extern void pop_switch PARAMS ((void)); 3750 extern tree identifier_type_value PARAMS ((tree)); 3751 extern void set_identifier_type_value PARAMS ((tree, tree)); 3752 extern void pop_everything PARAMS ((void)); 3753 extern void pushtag PARAMS ((tree, tree, int)); 3754 extern tree make_anon_name PARAMS ((void)); 3755 extern void clear_anon_tags PARAMS ((void)); 3756 extern int decls_match PARAMS ((tree, tree)); 3757 extern int duplicate_decls PARAMS ((tree, tree)); 3758 extern tree pushdecl_top_level PARAMS ((tree)); 3759 extern tree pushdecl_top_level_and_finish (tree, tree); 3760 extern bool pushdecl_class_level (tree); 3761 extern tree pushdecl_namespace_level PARAMS ((tree)); 3762 extern tree push_using_decl PARAMS ((tree, tree)); 3763 extern tree push_using_directive PARAMS ((tree)); 3764 extern bool push_class_level_binding (tree, tree); 3765 extern tree implicitly_declare PARAMS ((tree)); 3766 extern tree declare_local_label PARAMS ((tree)); 3767 extern tree define_label PARAMS ((const char *, int, tree)); 3768 extern void check_goto PARAMS ((tree)); 3769 extern void define_case_label PARAMS ((void)); 3770 extern cxx_binding *binding_for_name (tree, tree); 3771 extern tree namespace_binding PARAMS ((tree, tree)); 3772 extern void set_namespace_binding PARAMS ((tree, tree, tree)); 3773 extern tree lookup_namespace_name PARAMS ((tree, tree)); 3774 extern tree build_typename_type PARAMS ((tree, tree, tree, tree)); 3775 extern tree make_typename_type PARAMS ((tree, tree, tsubst_flags_t)); 3776 extern tree make_unbound_class_template PARAMS ((tree, tree, tsubst_flags_t)); 3777 extern tree lookup_name_nonclass PARAMS ((tree)); 3778 extern tree lookup_function_nonclass PARAMS ((tree, tree)); 3779 extern tree lookup_name PARAMS ((tree, int)); 3780 extern tree lookup_name_current_level PARAMS ((tree)); 3781 extern tree lookup_type_current_level PARAMS ((tree)); 3782 extern tree lookup_name_namespace_only PARAMS ((tree)); 3783 extern void begin_only_namespace_names PARAMS ((void)); 3784 extern void end_only_namespace_names PARAMS ((void)); 3785 extern tree namespace_ancestor PARAMS ((tree, tree)); 3786 extern bool is_ancestor (tree, tree); 3787 extern tree unqualified_namespace_lookup PARAMS ((tree, int, tree *)); 3788 extern tree check_for_out_of_scope_variable (tree); 3789 extern bool lookup_using_namespace (tree, cxx_binding *, tree, tree, int, tree *); 3790 extern bool qualified_lookup_using_namespace (tree, tree, cxx_binding *, int); 3791 extern tree build_library_fn PARAMS ((tree, tree)); 3792 extern tree build_library_fn_ptr PARAMS ((const char *, tree)); 3793 extern tree build_cp_library_fn_ptr PARAMS ((const char *, tree)); 3794 extern tree push_library_fn PARAMS ((tree, tree)); 3795 extern tree push_void_library_fn PARAMS ((tree, tree)); 3796 extern tree push_throw_library_fn PARAMS ((tree, tree)); 3797 extern int init_type_desc PARAMS ((void)); 3798 extern tree check_tag_decl PARAMS ((tree)); 3799 extern void shadow_tag PARAMS ((tree)); 3800 extern tree groktypename PARAMS ((tree)); 3801 extern tree start_decl PARAMS ((tree, tree, int, tree, tree)); 3802 extern void start_decl_1 PARAMS ((tree)); 3803 extern void cp_finish_decl PARAMS ((tree, tree, tree, int)); 3804 extern void finish_decl PARAMS ((tree, tree, tree)); 3805 extern void maybe_inject_for_scope_var PARAMS ((tree)); 3806 extern tree start_handler_parms PARAMS ((tree, tree)); 3807 extern int complete_array_type PARAMS ((tree, tree, int)); 3808 extern tree build_ptrmemfunc_type PARAMS ((tree)); 3809 extern tree build_ptrmem_type (tree, tree); 3810 /* the grokdeclarator prototype is in decl.h */ 3811 extern int parmlist_is_exprlist PARAMS ((tree)); 3812 extern int copy_fn_p PARAMS ((tree)); 3813 extern void grok_special_member_properties PARAMS ((tree)); 3814 extern int grok_ctor_properties PARAMS ((tree, tree)); 3815 extern void grok_op_properties PARAMS ((tree, int)); 3816 extern tree xref_tag (enum tag_types, tree, tree, bool); 3817 extern tree xref_tag_from_type PARAMS ((tree, tree, int)); 3818 extern void xref_basetypes PARAMS ((tree, tree)); 3819 extern tree start_enum PARAMS ((tree)); 3820 extern void finish_enum PARAMS ((tree)); 3821 extern void build_enumerator PARAMS ((tree, tree, tree)); 3822 extern int start_function PARAMS ((tree, tree, tree, int)); 3823 extern tree begin_function_body PARAMS ((void)); 3824 extern void finish_function_body PARAMS ((tree)); 3825 extern tree finish_function PARAMS ((int)); 3826 extern tree start_method PARAMS ((tree, tree, tree)); 3827 extern tree finish_method PARAMS ((tree)); 3828 extern void maybe_register_incomplete_var PARAMS ((tree)); 3829 extern void complete_vars PARAMS ((tree)); 3830 extern void finish_stmt PARAMS ((void)); 3831 extern void print_other_binding_stack PARAMS ((struct cp_binding_level *)); 3832 extern void revert_static_member_fn PARAMS ((tree)); 3833 extern void fixup_anonymous_aggr PARAMS ((tree)); 3834 extern int check_static_variable_definition PARAMS ((tree, tree)); 3835 extern tree compute_array_index_type PARAMS ((tree, tree)); 3836 extern void push_local_binding PARAMS ((tree, tree, int)); 3837 extern int push_class_binding PARAMS ((tree, tree)); 3838 extern tree check_default_argument PARAMS ((tree, tree)); 3839 extern tree push_overloaded_decl PARAMS ((tree, int)); 3840 extern void clear_identifier_class_values PARAMS ((void)); 3841 extern void storetags PARAMS ((tree)); 3842 extern int vtable_decl_p PARAMS ((tree, void *)); 3843 extern int vtype_decl_p PARAMS ((tree, void *)); 3844 extern int sigtable_decl_p PARAMS ((tree, void *)); 3845 typedef int (*walk_globals_pred) PARAMS ((tree, void *)); 3846 typedef int (*walk_globals_fn) PARAMS ((tree *, void *)); 3847 extern int walk_globals PARAMS ((walk_globals_pred, 3848 walk_globals_fn, 3849 void *)); 3850 extern int walk_vtables PARAMS ((walk_globals_pred, 3851 walk_globals_fn, 3852 void *)); 3853 typedef int (*walk_namespaces_fn) PARAMS ((tree, void *)); 3854 extern int walk_namespaces PARAMS ((walk_namespaces_fn, 3855 void *)); 3856 extern int wrapup_globals_for_namespace PARAMS ((tree, void *)); 3857 extern tree cp_namespace_decls PARAMS ((tree)); 3858 extern tree create_implicit_typedef PARAMS ((tree, tree)); 3859 extern tree maybe_push_decl PARAMS ((tree)); 3860 extern tree build_target_expr_with_type PARAMS ((tree, tree)); 3861 extern int local_variable_p PARAMS ((tree)); 3862 extern int nonstatic_local_decl_p PARAMS ((tree)); 3863 extern tree declare_global_var PARAMS ((tree, tree)); 3864 extern void register_dtor_fn PARAMS ((tree)); 3865 extern tmpl_spec_kind current_tmpl_spec_kind PARAMS ((int)); 3866 extern cxx_binding *cxx_scope_find_binding_for_name (tree, tree); 3867 extern tree cp_fname_init PARAMS ((const char *)); 3868 extern bool have_extern_spec; 3869 3870 /* in decl2.c */ 3871 extern int check_java_method PARAMS ((tree)); 3872 extern int grok_method_quals PARAMS ((tree, tree, tree)); 3873 extern void warn_if_unknown_interface PARAMS ((tree)); 3874 extern void grok_x_components PARAMS ((tree)); 3875 extern void maybe_retrofit_in_chrg PARAMS ((tree)); 3876 extern void maybe_make_one_only PARAMS ((tree)); 3877 extern void grokclassfn PARAMS ((tree, tree, enum overload_flags, tree)); 3878 extern tree grok_array_decl PARAMS ((tree, tree)); 3879 extern tree delete_sanity PARAMS ((tree, tree, int, int)); 3880 extern tree check_classfn PARAMS ((tree, tree)); 3881 extern void check_member_template PARAMS ((tree)); 3882 extern tree grokfield PARAMS ((tree, tree, tree, tree, tree)); 3883 extern tree grokbitfield PARAMS ((tree, tree, tree)); 3884 extern tree groktypefield PARAMS ((tree, tree)); 3885 extern tree grokoptypename PARAMS ((tree, tree, tree)); 3886 extern void cplus_decl_attributes PARAMS ((tree *, tree, int)); 3887 extern tree constructor_name_full PARAMS ((tree)); 3888 extern tree constructor_name PARAMS ((tree)); 3889 extern bool constructor_name_p (tree, tree); 3890 extern void defer_fn PARAMS ((tree)); 3891 extern void finish_anon_union PARAMS ((tree)); 3892 extern tree finish_table PARAMS ((tree, tree, tree, int)); 3893 extern void finish_builtin_type PARAMS ((tree, const char *, 3894 tree *, int, tree)); 3895 extern tree coerce_new_type PARAMS ((tree)); 3896 extern tree coerce_delete_type PARAMS ((tree)); 3897 extern void comdat_linkage PARAMS ((tree)); 3898 extern void import_export_vtable PARAMS ((tree, tree, int)); 3899 extern void import_export_decl PARAMS ((tree)); 3900 extern void import_export_tinfo PARAMS ((tree, tree, int)); 3901 extern tree build_cleanup PARAMS ((tree)); 3902 extern void finish_file PARAMS ((void)); 3903 extern tree reparse_absdcl_as_expr PARAMS ((tree, tree)); 3904 extern tree reparse_absdcl_as_casts PARAMS ((tree, tree)); 3905 extern tree build_expr_from_tree PARAMS ((tree)); 3906 extern tree build_offset_ref_call_from_tree (tree, tree); 3907 extern tree build_call_from_tree (tree, tree, bool); 3908 extern tree reparse_decl_as_expr PARAMS ((tree, tree)); 3909 extern tree finish_decl_parsing PARAMS ((tree)); 3910 extern void set_decl_namespace PARAMS ((tree, tree, int)); 3911 extern tree current_decl_namespace PARAMS ((void)); 3912 extern void push_decl_namespace PARAMS ((tree)); 3913 extern void pop_decl_namespace PARAMS ((void)); 3914 extern void push_scope PARAMS ((tree)); 3915 extern void pop_scope PARAMS ((tree)); 3916 extern void do_namespace_alias PARAMS ((tree, tree)); 3917 extern void do_toplevel_using_decl PARAMS ((tree)); 3918 extern void do_local_using_decl PARAMS ((tree)); 3919 extern tree do_class_using_decl PARAMS ((tree)); 3920 extern void do_using_directive PARAMS ((tree)); 3921 extern void check_default_args PARAMS ((tree)); 3922 extern void mark_used PARAMS ((tree)); 3923 extern tree handle_class_head (enum tag_types, tree, tree, tree, int, int *); 3924 extern tree handle_class_head_apparent_template (tree, int *); 3925 extern tree lookup_arg_dependent PARAMS ((tree, tree, tree)); 3926 extern void finish_static_data_member_decl PARAMS ((tree, tree, tree, int)); 3927 extern tree cp_build_parm_decl PARAMS ((tree, tree)); 3928 extern tree build_artificial_parm PARAMS ((tree, tree)); 3929 extern tree get_guard PARAMS ((tree)); 3930 extern tree get_guard_cond PARAMS ((tree)); 3931 extern tree set_guard PARAMS ((tree)); 3932 3933 extern void cp_error_at PARAMS ((const char *msgid, ...)); 3934 extern void cp_warning_at PARAMS ((const char *msgid, ...)); 3935 extern void cp_pedwarn_at PARAMS ((const char *msgid, ...)); 3936 3937 /* XXX Not i18n clean. */ 3938 #define cp_deprecated(STR) \ 3939 do { \ 3940 if (warn_deprecated) \ 3941 warning ("%s is deprecated, please see the documentation for details", \ 3942 (STR)); \ 3943 } while (0) 3944 3945 /* in error.c */ 3946 extern void init_error PARAMS ((void)); 3947 extern const char *type_as_string PARAMS ((tree, int)); 3948 extern const char *decl_as_string PARAMS ((tree, int)); 3949 extern const char *expr_as_string PARAMS ((tree, int)); 3950 extern const char *context_as_string PARAMS ((tree, int)); 3951 extern const char *lang_decl_name PARAMS ((tree, int)); 3952 extern const char *cp_file_of PARAMS ((tree)); 3953 extern int cp_line_of PARAMS ((tree)); 3954 extern const char *language_to_string PARAMS ((enum languages, int)); 3955 extern void print_instantiation_context PARAMS ((void)); 3956 3957 /* in except.c */ 3958 extern void init_exception_processing PARAMS ((void)); 3959 extern tree expand_start_catch_block PARAMS ((tree)); 3960 extern void expand_end_catch_block PARAMS ((void)); 3961 extern void expand_builtin_throw PARAMS ((void)); 3962 extern void expand_eh_spec_block PARAMS ((tree)); 3963 extern void expand_exception_blocks PARAMS ((void)); 3964 extern tree build_exc_ptr PARAMS ((void)); 3965 extern tree build_throw PARAMS ((tree)); 3966 extern void mark_all_runtime_matches PARAMS ((void)); 3967 extern int nothrow_libfn_p PARAMS ((tree)); 3968 extern void check_handlers PARAMS ((tree)); 3969 extern void choose_personality_routine PARAMS ((enum languages)); 3970 3971 /* in expr.c */ 3972 extern rtx cxx_expand_expr PARAMS ((tree, rtx, 3973 enum machine_mode, 3974 int)); 3975 extern tree cplus_expand_constant PARAMS ((tree)); 3976 3977 /* friend.c */ 3978 extern int is_friend PARAMS ((tree, tree)); 3979 extern void make_friend_class PARAMS ((tree, tree)); 3980 extern void add_friend PARAMS ((tree, tree)); 3981 extern tree do_friend PARAMS ((tree, tree, tree, tree, tree, enum overload_flags, tree, int)); 3982 3983 /* in init.c */ 3984 extern tree expand_member_init (tree); 3985 extern void emit_mem_initializers (tree); 3986 extern tree build_aggr_init PARAMS ((tree, tree, int)); 3987 extern tree build_init PARAMS ((tree, tree, int)); 3988 extern int is_aggr_type PARAMS ((tree, int)); 3989 extern tree get_aggr_from_typedef PARAMS ((tree, int)); 3990 extern tree get_type_value PARAMS ((tree)); 3991 extern tree build_zero_init (tree, tree, bool); 3992 extern tree build_member_call PARAMS ((tree, tree, tree)); 3993 extern tree build_offset_ref PARAMS ((tree, tree)); 3994 extern tree resolve_offset_ref PARAMS ((tree)); 3995 extern tree build_new PARAMS ((tree, tree, tree, int)); 3996 extern tree build_vec_init PARAMS ((tree, tree, tree, int)); 3997 extern tree build_x_delete PARAMS ((tree, int, tree)); 3998 extern tree build_delete PARAMS ((tree, tree, special_function_kind, int, int)); 3999 extern void push_base_cleanups PARAMS ((void)); 4000 extern tree build_vbase_delete PARAMS ((tree, tree)); 4001 extern tree build_vec_delete PARAMS ((tree, tree, special_function_kind, int)); 4002 extern tree create_temporary_var PARAMS ((tree)); 4003 extern void begin_init_stmts PARAMS ((tree *, tree *)); 4004 extern tree finish_init_stmts PARAMS ((tree, tree)); 4005 extern void initialize_vtbl_ptrs PARAMS ((tree)); 4006 extern tree build_java_class_ref PARAMS ((tree)); 4007 4008 /* in input.c */ 4009 4010 /* in lex.c */ 4011 extern void cxx_dup_lang_specific_decl PARAMS ((tree)); 4012 extern tree make_pointer_declarator PARAMS ((tree, tree)); 4013 extern tree make_reference_declarator PARAMS ((tree, tree)); 4014 extern tree make_call_declarator PARAMS ((tree, tree, tree, tree)); 4015 extern void set_quals_and_spec PARAMS ((tree, tree, tree)); 4016 extern void print_parse_statistics PARAMS ((void)); 4017 extern void do_pending_inlines PARAMS ((void)); 4018 extern void process_next_inline PARAMS ((struct unparsed_text *)); 4019 4020 extern void yyungetc PARAMS ((int, int)); 4021 extern void snarf_method PARAMS ((tree)); 4022 4023 extern void check_for_missing_semicolon PARAMS ((tree)); 4024 extern void note_got_semicolon PARAMS ((tree)); 4025 extern void note_list_got_semicolon PARAMS ((tree)); 4026 extern void do_pending_lang_change PARAMS ((void)); 4027 extern void see_typename PARAMS ((void)); 4028 extern void unqualified_name_lookup_error PARAMS ((tree)); 4029 extern tree do_identifier PARAMS ((tree, int, tree)); 4030 extern tree do_scoped_id PARAMS ((tree, tree)); 4031 extern tree identifier_typedecl_value PARAMS ((tree)); 4032 extern tree build_lang_decl PARAMS ((enum tree_code, tree, tree)); 4033 extern void retrofit_lang_decl PARAMS ((tree)); 4034 extern tree copy_decl PARAMS ((tree)); 4035 extern tree copy_type PARAMS ((tree)); 4036 extern tree cxx_make_type PARAMS ((enum tree_code)); 4037 extern tree make_aggr_type PARAMS ((enum tree_code)); 4038 extern void yyerror PARAMS ((const char *)); 4039 extern void yyhook PARAMS ((int)); 4040 extern int cp_type_qual_from_rid PARAMS ((tree)); 4041 extern const char *cxx_init PARAMS ((const char *)); 4042 extern void cxx_finish PARAMS ((void)); 4043 extern void cxx_init_options PARAMS ((void)); 4044 4045 /* in method.c */ 4046 extern void init_method PARAMS ((void)); 4047 extern void set_mangled_name_for_decl PARAMS ((tree)); 4048 extern tree build_opfncall PARAMS ((enum tree_code, int, tree, tree, tree)); 4049 extern tree hack_identifier PARAMS ((tree, tree)); 4050 extern tree make_thunk PARAMS ((tree, tree, tree)); 4051 extern void use_thunk PARAMS ((tree, int)); 4052 extern void synthesize_method PARAMS ((tree)); 4053 extern tree implicitly_declare_fn PARAMS ((special_function_kind, tree, int)); 4054 extern tree skip_artificial_parms_for PARAMS ((tree, tree)); 4055 4056 /* In optimize.c */ 4057 extern void optimize_function PARAMS ((tree)); 4058 extern int calls_setjmp_p PARAMS ((tree)); 4059 extern int maybe_clone_body PARAMS ((tree)); 4060 4061 /* in pt.c */ 4062 extern void check_template_shadow PARAMS ((tree)); 4063 extern tree get_innermost_template_args PARAMS ((tree, int)); 4064 extern tree tsubst PARAMS ((tree, tree, tsubst_flags_t, tree)); 4065 extern tree tsubst_expr PARAMS ((tree, tree, tsubst_flags_t, tree)); 4066 extern tree tsubst_copy PARAMS ((tree, tree, tsubst_flags_t, tree)); 4067 extern void maybe_begin_member_template_processing PARAMS ((tree)); 4068 extern void maybe_end_member_template_processing PARAMS ((void)); 4069 extern tree finish_member_template_decl PARAMS ((tree)); 4070 extern void begin_template_parm_list PARAMS ((void)); 4071 extern void begin_specialization PARAMS ((void)); 4072 extern void reset_specialization PARAMS ((void)); 4073 extern void end_specialization PARAMS ((void)); 4074 extern void begin_explicit_instantiation PARAMS ((void)); 4075 extern void end_explicit_instantiation PARAMS ((void)); 4076 extern tree check_explicit_specialization PARAMS ((tree, tree, int, int)); 4077 extern tree process_template_parm PARAMS ((tree, tree)); 4078 extern tree end_template_parm_list PARAMS ((tree)); 4079 extern void end_template_decl PARAMS ((void)); 4080 extern tree current_template_args PARAMS ((void)); 4081 extern tree push_template_decl PARAMS ((tree)); 4082 extern tree push_template_decl_real PARAMS ((tree, int)); 4083 extern void redeclare_class_template PARAMS ((tree, tree)); 4084 extern tree lookup_template_class PARAMS ((tree, tree, tree, tree, int, tsubst_flags_t)); 4085 extern tree lookup_template_function PARAMS ((tree, tree)); 4086 extern int uses_template_parms PARAMS ((tree)); 4087 extern tree instantiate_class_template PARAMS ((tree)); 4088 extern tree instantiate_template PARAMS ((tree, tree)); 4089 extern int fn_type_unification PARAMS ((tree, tree, tree, tree, tree, unification_kind_t, int)); 4090 extern tree tinst_for_decl PARAMS ((void)); 4091 extern void mark_decl_instantiated PARAMS ((tree, int)); 4092 extern int more_specialized PARAMS ((tree, tree, int, int)); 4093 extern void mark_class_instantiated PARAMS ((tree, int)); 4094 extern void do_decl_instantiation (tree, tree); 4095 extern void do_type_instantiation PARAMS ((tree, tree, tsubst_flags_t)); 4096 extern tree instantiate_decl PARAMS ((tree, int)); 4097 extern tree get_bindings PARAMS ((tree, tree, tree)); 4098 extern int push_tinst_level PARAMS ((tree)); 4099 extern void pop_tinst_level PARAMS ((void)); 4100 extern int more_specialized_class PARAMS ((tree, tree, tree)); 4101 extern int is_member_template PARAMS ((tree)); 4102 extern int comp_template_parms PARAMS ((tree, tree)); 4103 extern int template_class_depth PARAMS ((tree)); 4104 extern int is_specialization_of PARAMS ((tree, tree)); 4105 extern int comp_template_args PARAMS ((tree, tree)); 4106 extern void maybe_process_partial_specialization PARAMS ((tree)); 4107 extern void maybe_check_template_type PARAMS ((tree)); 4108 extern tree most_specialized_instantiation PARAMS ((tree)); 4109 extern void print_candidates PARAMS ((tree)); 4110 extern int instantiate_pending_templates PARAMS ((void)); 4111 extern tree tsubst_default_argument PARAMS ((tree, tree, tree)); 4112 extern tree most_general_template PARAMS ((tree)); 4113 extern tree get_mostly_instantiated_function_type PARAMS ((tree)); 4114 extern int problematic_instantiation_changed PARAMS ((void)); 4115 extern void record_last_problematic_instantiation PARAMS ((void)); 4116 extern tree current_instantiation PARAMS ((void)); 4117 extern int processing_template_parmlist; 4118 4119 /* in repo.c */ 4120 extern void repo_template_used PARAMS ((tree)); 4121 extern void repo_template_instantiated PARAMS ((tree, int)); 4122 extern void init_repo PARAMS ((const char *)); 4123 extern void finish_repo PARAMS ((void)); 4124 4125 /* in rtti.c */ 4126 extern void init_rtti_processing PARAMS((void)); 4127 extern tree build_typeid PARAMS((tree)); 4128 extern tree get_tinfo_decl PARAMS((tree)); 4129 extern tree get_typeid PARAMS((tree)); 4130 extern tree build_dynamic_cast PARAMS((tree, tree)); 4131 extern void emit_support_tinfos PARAMS((void)); 4132 extern int unemitted_tinfo_decl_p PARAMS((tree, void *)); 4133 extern int emit_tinfo_decl PARAMS((tree *, void *)); 4134 4135 /* in search.c */ 4136 extern bool accessible_base_p (tree, tree); 4137 extern tree lookup_base PARAMS ((tree, tree, base_access, base_kind *)); 4138 extern int types_overlap_p PARAMS ((tree, tree)); 4139 extern tree get_vbase PARAMS ((tree, tree)); 4140 extern tree get_dynamic_cast_base_type PARAMS ((tree, tree)); 4141 extern void type_access_control PARAMS ((tree, tree)); 4142 extern int accessible_p PARAMS ((tree, tree)); 4143 extern tree lookup_field_1 (tree, tree, bool); 4144 extern tree lookup_field PARAMS ((tree, tree, int, int)); 4145 extern tree lookup_nested_field PARAMS ((tree, int)); 4146 extern int lookup_fnfields_1 PARAMS ((tree, tree)); 4147 extern tree lookup_fnfields PARAMS ((tree, tree, int)); 4148 extern tree lookup_member PARAMS ((tree, tree, int, int)); 4149 extern int look_for_overrides PARAMS ((tree, tree)); 4150 extern void get_pure_virtuals PARAMS ((tree)); 4151 extern void get_vbase_types PARAMS ((tree)); 4152 extern void maybe_suppress_debug_info PARAMS ((tree)); 4153 extern void note_debug_info_needed PARAMS ((tree)); 4154 extern void push_class_decls PARAMS ((tree)); 4155 extern void pop_class_decls PARAMS ((void)); 4156 extern void unuse_fields PARAMS ((tree)); 4157 extern void print_search_statistics PARAMS ((void)); 4158 extern void init_search_processing PARAMS ((void)); 4159 extern void reinit_search_statistics PARAMS ((void)); 4160 extern tree current_scope PARAMS ((void)); 4161 extern int at_function_scope_p PARAMS ((void)); 4162 extern bool at_class_scope_p (void); 4163 extern tree context_for_name_lookup PARAMS ((tree)); 4164 extern tree lookup_conversions PARAMS ((tree)); 4165 extern tree binfo_for_vtable PARAMS ((tree)); 4166 extern tree binfo_from_vbase PARAMS ((tree)); 4167 extern tree look_for_overrides_here PARAMS ((tree, tree)); 4168 extern int check_final_overrider PARAMS ((tree, tree)); 4169 extern tree dfs_walk PARAMS ((tree, 4170 tree (*) (tree, void *), 4171 tree (*) (tree, void *), 4172 void *)); 4173 extern tree dfs_walk_real PARAMS ((tree, 4174 tree (*) (tree, void *), 4175 tree (*) (tree, void *), 4176 tree (*) (tree, void *), 4177 void *)); 4178 extern tree dfs_unmark PARAMS ((tree, void *)); 4179 extern tree markedp PARAMS ((tree, void *)); 4180 extern tree unmarkedp PARAMS ((tree, void *)); 4181 extern tree dfs_unmarked_real_bases_queue_p PARAMS ((tree, void *)); 4182 extern tree dfs_marked_real_bases_queue_p PARAMS ((tree, void *)); 4183 extern tree dfs_skip_vbases PARAMS ((tree, void *)); 4184 extern tree marked_vtable_pathp PARAMS ((tree, void *)); 4185 extern tree unmarked_vtable_pathp PARAMS ((tree, void *)); 4186 extern tree find_vbase_instance PARAMS ((tree, tree)); 4187 extern tree binfo_for_vbase PARAMS ((tree, tree)); 4188 extern tree binfo_via_virtual PARAMS ((tree, tree)); 4189 extern tree build_baselink (tree, tree, tree, tree); 4190 extern tree adjust_result_of_qualified_name_lookup 4191 (tree, tree, tree); 4192 /* in semantics.c */ 4193 extern void init_cp_semantics PARAMS ((void)); 4194 extern tree finish_expr_stmt PARAMS ((tree)); 4195 extern tree begin_if_stmt PARAMS ((void)); 4196 extern void finish_if_stmt_cond PARAMS ((tree, tree)); 4197 extern tree finish_then_clause PARAMS ((tree)); 4198 extern void begin_else_clause PARAMS ((void)); 4199 extern void finish_else_clause PARAMS ((tree)); 4200 extern void finish_if_stmt PARAMS ((void)); 4201 extern tree begin_while_stmt PARAMS ((void)); 4202 extern void finish_while_stmt_cond PARAMS ((tree, tree)); 4203 extern void finish_while_stmt PARAMS ((tree)); 4204 extern tree begin_do_stmt PARAMS ((void)); 4205 extern void finish_do_body PARAMS ((tree)); 4206 extern void finish_do_stmt PARAMS ((tree, tree)); 4207 extern tree finish_return_stmt PARAMS ((tree)); 4208 extern tree begin_for_stmt PARAMS ((void)); 4209 extern void finish_for_init_stmt PARAMS ((tree)); 4210 extern void finish_for_cond PARAMS ((tree, tree)); 4211 extern void finish_for_expr PARAMS ((tree, tree)); 4212 extern void finish_for_stmt PARAMS ((tree)); 4213 extern tree finish_break_stmt PARAMS ((void)); 4214 extern tree finish_continue_stmt PARAMS ((void)); 4215 extern tree begin_switch_stmt PARAMS ((void)); 4216 extern void finish_switch_cond PARAMS ((tree, tree)); 4217 extern void finish_switch_stmt PARAMS ((tree)); 4218 extern tree finish_case_label PARAMS ((tree, tree)); 4219 extern tree finish_goto_stmt PARAMS ((tree)); 4220 extern tree begin_try_block PARAMS ((void)); 4221 extern void finish_try_block PARAMS ((tree)); 4222 extern tree begin_eh_spec_block PARAMS ((void)); 4223 extern void finish_eh_spec_block PARAMS ((tree, tree)); 4224 extern void finish_handler_sequence PARAMS ((tree)); 4225 extern tree begin_function_try_block PARAMS ((void)); 4226 extern void finish_function_try_block PARAMS ((tree)); 4227 extern void finish_function_handler_sequence PARAMS ((tree)); 4228 extern void finish_cleanup_try_block PARAMS ((tree)); 4229 extern tree begin_handler PARAMS ((void)); 4230 extern void finish_handler_parms PARAMS ((tree, tree)); 4231 extern void begin_catch_block PARAMS ((tree)); 4232 extern void finish_handler PARAMS ((tree)); 4233 extern void finish_cleanup PARAMS ((tree, tree)); 4234 extern tree begin_compound_stmt PARAMS ((int)); 4235 extern tree finish_compound_stmt PARAMS ((int, tree)); 4236 extern tree finish_asm_stmt PARAMS ((tree, tree, tree, tree, tree)); 4237 extern void finish_label_stmt PARAMS ((tree)); 4238 extern void finish_label_decl PARAMS ((tree)); 4239 extern void finish_subobject PARAMS ((tree)); 4240 extern tree finish_parenthesized_expr PARAMS ((tree)); 4241 extern tree begin_stmt_expr PARAMS ((void)); 4242 extern tree finish_stmt_expr PARAMS ((tree)); 4243 extern tree finish_call_expr (tree, tree, bool); 4244 extern tree finish_increment_expr PARAMS ((tree, enum tree_code)); 4245 extern tree finish_this_expr PARAMS ((void)); 4246 extern tree finish_object_call_expr PARAMS ((tree, tree, tree)); 4247 extern tree finish_qualified_object_call_expr PARAMS ((tree, tree, tree)); 4248 extern tree finish_pseudo_destructor_call_expr PARAMS ((tree, tree, tree)); 4249 extern tree finish_unary_op_expr PARAMS ((enum tree_code, tree)); 4250 extern tree finish_id_expr PARAMS ((tree)); 4251 extern tree finish_fname (tree); 4252 extern void save_type_access_control PARAMS ((tree)); 4253 extern void reset_type_access_control PARAMS ((void)); 4254 extern void decl_type_access_control PARAMS ((tree)); 4255 extern int begin_function_definition (tree, tree, tree); 4256 extern tree begin_constructor_declarator PARAMS ((tree, tree)); 4257 extern tree finish_declarator PARAMS ((tree, tree, tree, tree, int)); 4258 extern void finish_translation_unit PARAMS ((void)); 4259 extern tree finish_template_type_parm PARAMS ((tree, tree)); 4260 extern tree finish_template_template_parm PARAMS ((tree, tree)); 4261 extern tree finish_parmlist PARAMS ((tree, int)); 4262 extern tree begin_class_definition PARAMS ((tree)); 4263 extern tree finish_class_definition PARAMS ((tree, tree, int, int)); 4264 extern void finish_default_args PARAMS ((void)); 4265 extern void begin_inline_definitions PARAMS ((void)); 4266 extern tree finish_member_class_template PARAMS ((tree)); 4267 extern void finish_template_decl PARAMS ((tree)); 4268 extern tree finish_template_type PARAMS ((tree, tree, int)); 4269 extern void enter_scope_of PARAMS ((tree)); 4270 extern tree finish_base_specifier PARAMS ((tree, tree)); 4271 extern void finish_member_declaration PARAMS ((tree)); 4272 extern void check_multiple_declarators PARAMS ((void)); 4273 extern tree finish_typeof PARAMS ((tree)); 4274 extern tree finish_sizeof PARAMS ((tree)); 4275 extern tree finish_alignof PARAMS ((tree)); 4276 extern void finish_decl_cleanup PARAMS ((tree, tree)); 4277 extern void finish_eh_cleanup PARAMS ((tree)); 4278 extern void finish_named_return_value PARAMS ((tree, tree)); 4279 extern void expand_body PARAMS ((tree)); 4280 extern tree nullify_returns_r PARAMS ((tree *, int *, void *)); 4281 extern void do_pushlevel PARAMS ((void)); 4282 extern tree do_poplevel PARAMS ((void)); 4283 extern void begin_mem_initializers (void); 4284 extern void finish_mem_initializers PARAMS ((tree)); 4285 extern void setup_vtbl_ptr PARAMS ((tree, tree)); 4286 extern void clear_out_block PARAMS ((void)); 4287 extern tree begin_global_stmt_expr PARAMS ((void)); 4288 extern tree finish_global_stmt_expr PARAMS ((tree)); 4289 extern tree check_template_template_default_arg (tree); 4290 4291 /* in spew.c */ 4292 extern void init_spew PARAMS ((void)); 4293 extern int peekyylex PARAMS ((void)); 4294 extern tree arbitrate_lookup PARAMS ((tree, tree, tree)); 4295 extern tree frob_opname PARAMS ((tree)); 4296 extern void maybe_snarf_defarg PARAMS ((void)); 4297 extern void add_defarg_fn PARAMS ((tree)); 4298 extern void do_pending_defargs PARAMS ((void)); 4299 extern void done_pending_defargs PARAMS ((void)); 4300 extern void unprocessed_defarg_fn PARAMS ((tree)); 4301 extern void replace_defarg PARAMS ((tree, tree)); 4302 extern void end_input PARAMS ((void)); 4303 4304 /* in tree.c */ 4305 extern void lang_check_failed PARAMS ((const char *, int, 4306 const char *)); 4307 extern tree stabilize_expr PARAMS ((tree, tree *)); 4308 extern tree cxx_unsave_expr_now PARAMS ((tree)); 4309 extern tree cxx_maybe_build_cleanup PARAMS ((tree)); 4310 extern void init_tree PARAMS ((void)); 4311 extern int pod_type_p PARAMS ((tree)); 4312 extern int zero_init_p PARAMS ((tree)); 4313 extern tree canonical_type_variant PARAMS ((tree)); 4314 extern void unshare_base_binfos PARAMS ((tree)); 4315 extern int member_p PARAMS ((tree)); 4316 extern cp_lvalue_kind real_lvalue_p PARAMS ((tree)); 4317 extern cp_lvalue_kind real_non_cast_lvalue_p (tree); 4318 extern int non_cast_lvalue_p PARAMS ((tree)); 4319 extern int non_cast_lvalue_or_else PARAMS ((tree, const char *)); 4320 extern tree build_min PARAMS ((enum tree_code, tree, 4321 ...)); 4322 extern tree build_min_nt PARAMS ((enum tree_code, ...)); 4323 extern tree build_cplus_new PARAMS ((tree, tree)); 4324 extern tree get_target_expr PARAMS ((tree)); 4325 extern tree build_cplus_method_type PARAMS ((tree, tree, tree)); 4326 extern tree build_cplus_staticfn_type PARAMS ((tree, tree, tree)); 4327 extern tree build_cplus_array_type PARAMS ((tree, tree)); 4328 extern tree hash_tree_cons PARAMS ((tree, tree, tree)); 4329 extern tree hash_tree_chain PARAMS ((tree, tree)); 4330 extern tree hash_chainon PARAMS ((tree, tree)); 4331 extern tree make_binfo PARAMS ((tree, tree, tree, tree)); 4332 extern tree reverse_path PARAMS ((tree)); 4333 extern int count_functions PARAMS ((tree)); 4334 extern int is_overloaded_fn PARAMS ((tree)); 4335 extern tree get_overloaded_fn PARAMS ((tree)); 4336 extern tree get_first_fn PARAMS ((tree)); 4337 extern int bound_pmf_p PARAMS ((tree)); 4338 extern tree ovl_cons PARAMS ((tree, tree)); 4339 extern tree build_overload PARAMS ((tree, tree)); 4340 extern tree function_arg_chain PARAMS ((tree)); 4341 extern int promotes_to_aggr_type PARAMS ((tree, enum tree_code)); 4342 extern int is_aggr_type_2 PARAMS ((tree, tree)); 4343 extern const char *cxx_printable_name PARAMS ((tree, int)); 4344 extern tree build_exception_variant PARAMS ((tree, tree)); 4345 extern tree bind_template_template_parm PARAMS ((tree, tree)); 4346 extern tree array_type_nelts_total PARAMS ((tree)); 4347 extern tree array_type_nelts_top PARAMS ((tree)); 4348 extern tree break_out_target_exprs PARAMS ((tree)); 4349 extern tree get_type_decl PARAMS ((tree)); 4350 extern tree vec_binfo_member PARAMS ((tree, tree)); 4351 extern tree decl_namespace_context PARAMS ((tree)); 4352 extern tree lvalue_type PARAMS ((tree)); 4353 extern tree error_type PARAMS ((tree)); 4354 extern tree build_zc_wrapper PARAMS ((struct z_candidate *)); 4355 extern tree build_srcloc_here PARAMS ((void)); 4356 extern int varargs_function_p PARAMS ((tree)); 4357 extern int really_overloaded_fn PARAMS ((tree)); 4358 extern int cp_tree_equal PARAMS ((tree, tree)); 4359 extern tree no_linkage_check PARAMS ((tree)); 4360 extern void debug_binfo PARAMS ((tree)); 4361 extern tree build_dummy_object PARAMS ((tree)); 4362 extern tree maybe_dummy_object PARAMS ((tree, tree *)); 4363 extern int is_dummy_object PARAMS ((tree)); 4364 extern const struct attribute_spec cxx_attribute_table[]; 4365 extern tree make_ptrmem_cst PARAMS ((tree, tree)); 4366 extern tree cp_build_qualified_type_real PARAMS ((tree, int, tsubst_flags_t)); 4367 #define cp_build_qualified_type(TYPE, QUALS) \ 4368 cp_build_qualified_type_real ((TYPE), (QUALS), tf_error | tf_warning) 4369 extern tree build_shared_int_cst PARAMS ((int)); 4370 extern special_function_kind special_function_p PARAMS ((tree)); 4371 extern bool name_p (tree); 4372 extern int count_trees PARAMS ((tree)); 4373 extern int char_type_p PARAMS ((tree)); 4374 extern void verify_stmt_tree PARAMS ((tree)); 4375 extern tree find_tree PARAMS ((tree, tree)); 4376 extern linkage_kind decl_linkage PARAMS ((tree)); 4377 extern tree cp_walk_subtrees PARAMS ((tree*, int*, walk_tree_fn, 4378 void*, void*)); 4379 extern int cp_cannot_inline_tree_fn PARAMS ((tree*)); 4380 extern tree cp_add_pending_fn_decls PARAMS ((void*,tree)); 4381 extern int cp_is_overload_p PARAMS ((tree)); 4382 extern int cp_auto_var_in_fn_p PARAMS ((tree,tree)); 4383 extern tree cp_copy_res_decl_for_inlining PARAMS ((tree, tree, tree, void*, 4384 int*, void*)); 4385 4386 /* in typeck.c */ 4387 extern int string_conv_p PARAMS ((tree, tree, int)); 4388 extern tree cp_truthvalue_conversion PARAMS ((tree)); 4389 extern tree condition_conversion PARAMS ((tree)); 4390 extern tree target_type PARAMS ((tree)); 4391 extern tree require_complete_type PARAMS ((tree)); 4392 extern tree complete_type PARAMS ((tree)); 4393 extern tree complete_type_or_diagnostic PARAMS ((tree, tree, int)); 4394 #define complete_type_or_else(T,V) (complete_type_or_diagnostic ((T), (V), 0)) 4395 extern int type_unknown_p PARAMS ((tree)); 4396 extern tree commonparms PARAMS ((tree, tree)); 4397 extern tree original_type PARAMS ((tree)); 4398 extern int comp_except_specs PARAMS ((tree, tree, int)); 4399 extern int comptypes PARAMS ((tree, tree, int)); 4400 extern int comp_target_types PARAMS ((tree, tree, int)); 4401 extern int compparms PARAMS ((tree, tree)); 4402 extern int comp_cv_qualification PARAMS ((tree, tree)); 4403 extern int comp_cv_qual_signature PARAMS ((tree, tree)); 4404 extern tree expr_sizeof PARAMS ((tree)); 4405 extern tree cxx_sizeof_or_alignof_type PARAMS ((tree, enum tree_code, int)); 4406 #define cxx_sizeof_nowarn(T) cxx_sizeof_or_alignof_type (T, SIZEOF_EXPR, false) 4407 extern tree inline_conversion PARAMS ((tree)); 4408 extern tree decay_conversion PARAMS ((tree)); 4409 extern tree build_class_member_access_expr (tree, tree, tree, bool); 4410 extern tree finish_class_member_access_expr (tree, tree); 4411 extern tree build_x_indirect_ref PARAMS ((tree, const char *)); 4412 extern tree build_indirect_ref PARAMS ((tree, const char *)); 4413 extern tree build_array_ref PARAMS ((tree, tree)); 4414 extern tree get_member_function_from_ptrfunc PARAMS ((tree *, tree)); 4415 extern tree build_function_call_real PARAMS ((tree, tree, int)); 4416 extern tree build_function_call_maybe PARAMS ((tree, tree)); 4417 extern tree convert_arguments PARAMS ((tree, tree, tree, int)); 4418 extern tree build_x_binary_op PARAMS ((enum tree_code, tree, tree)); 4419 extern tree build_x_unary_op PARAMS ((enum tree_code, tree)); 4420 extern tree unary_complex_lvalue PARAMS ((enum tree_code, tree)); 4421 extern tree build_x_conditional_expr PARAMS ((tree, tree, tree)); 4422 extern tree build_x_compound_expr PARAMS ((tree)); 4423 extern tree build_compound_expr PARAMS ((tree)); 4424 extern tree build_static_cast PARAMS ((tree, tree)); 4425 extern tree build_reinterpret_cast PARAMS ((tree, tree)); 4426 extern tree build_const_cast PARAMS ((tree, tree)); 4427 extern tree build_c_cast PARAMS ((tree, tree)); 4428 extern tree build_x_modify_expr PARAMS ((tree, enum tree_code, tree)); 4429 extern tree build_modify_expr PARAMS ((tree, enum tree_code, tree)); 4430 extern tree dubious_conversion_warnings PARAMS ((tree, tree, const char *, tree, int)); 4431 extern tree convert_for_initialization PARAMS ((tree, tree, tree, int, const char *, tree, int)); 4432 extern int comp_ptr_ttypes PARAMS ((tree, tree)); 4433 extern int ptr_reasonably_similar PARAMS ((tree, tree)); 4434 extern tree build_ptrmemfunc PARAMS ((tree, tree, int)); 4435 extern int cp_type_quals PARAMS ((tree)); 4436 extern int cp_has_mutable_p PARAMS ((tree)); 4437 extern int at_least_as_qualified_p PARAMS ((tree, tree)); 4438 extern int more_qualified_p PARAMS ((tree, tree)); 4439 extern tree build_ptrmemfunc1 PARAMS ((tree, tree, tree)); 4440 extern void expand_ptrmemfunc_cst PARAMS ((tree, tree *, tree *)); 4441 extern tree pfn_from_ptrmemfunc PARAMS ((tree)); 4442 extern tree type_after_usual_arithmetic_conversions PARAMS ((tree, tree)); 4443 extern tree composite_pointer_type PARAMS ((tree, tree, tree, tree, 4444 const char*)); 4445 extern tree merge_types PARAMS ((tree, tree)); 4446 extern tree check_return_expr PARAMS ((tree)); 4447 #define cp_build_binary_op(code, arg1, arg2) \ 4448 build_binary_op(code, arg1, arg2, 1) 4449 #define cxx_sizeof(T) cxx_sizeof_or_alignof_type (T, SIZEOF_EXPR, true) 4450 #define cxx_alignof(T) cxx_sizeof_or_alignof_type (T, ALIGNOF_EXPR, true) 4451 extern tree build_ptrmemfunc_access_expr (tree, tree); 4452 extern tree build_address (tree); 4453 extern tree build_nop (tree, tree); 4454 4455 /* in typeck2.c */ 4456 extern void require_complete_eh_spec_types PARAMS ((tree, tree)); 4457 extern void cxx_incomplete_type_diagnostic PARAMS ((tree, tree, int)); 4458 #undef cxx_incomplete_type_error 4459 extern void cxx_incomplete_type_error PARAMS ((tree, tree)); 4460 #define cxx_incomplete_type_error(V,T) \ 4461 (cxx_incomplete_type_diagnostic ((V), (T), 0)) 4462 extern tree error_not_base_type PARAMS ((tree, tree)); 4463 extern tree binfo_or_else PARAMS ((tree, tree)); 4464 extern void readonly_error PARAMS ((tree, const char *, int)); 4465 extern int abstract_virtuals_error PARAMS ((tree, tree)); 4466 4467 extern tree store_init_value PARAMS ((tree, tree)); 4468 extern tree digest_init PARAMS ((tree, tree, tree *)); 4469 extern tree build_scoped_ref PARAMS ((tree, tree, tree *)); 4470 extern tree build_x_arrow PARAMS ((tree)); 4471 extern tree build_m_component_ref PARAMS ((tree, tree)); 4472 extern tree build_functional_cast PARAMS ((tree, tree)); 4473 extern void check_for_new_type PARAMS ((const char *, flagged_type_tree)); 4474 extern tree add_exception_specifier PARAMS ((tree, tree, int)); 4475 extern tree merge_exception_specifiers PARAMS ((tree, tree)); 4476 4477 /* in mangle.c */ 4478 extern void init_mangle PARAMS ((void)); 4479 extern void mangle_decl PARAMS ((tree)); 4480 extern const char *mangle_type_string PARAMS ((tree)); 4481 extern tree mangle_type PARAMS ((tree)); 4482 extern tree mangle_typeinfo_for_type PARAMS ((tree)); 4483 extern tree mangle_typeinfo_string_for_type PARAMS ((tree)); 4484 extern tree mangle_vtbl_for_type PARAMS ((tree)); 4485 extern tree mangle_vtt_for_type PARAMS ((tree)); 4486 extern tree mangle_ctor_vtbl_for_type PARAMS ((tree, tree)); 4487 extern tree mangle_thunk PARAMS ((tree, tree, tree)); 4488 extern tree mangle_conv_op_name_for_type PARAMS ((tree)); 4489 extern tree mangle_guard_variable PARAMS ((tree)); 4490 extern tree mangle_ref_init_variable PARAMS ((tree)); 4491 4492 /* in dump.c */ 4493 extern int cp_dump_tree PARAMS ((void *, tree)); 4494 4495 /* -- end of C++ */ 4496 4497 #endif /* ! GCC_CP_TREE_H */ 4498