1/* Some code common to C++ and ObjC++ front ends. 2 Copyright (C) 2004-2022 Free Software Foundation, Inc. 3 Contributed by Ziemowit Laski <zlaski@apple.com> 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 3, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING3. If not see 19<http://www.gnu.org/licenses/>. */ 20 21#include "config.h" 22#include "system.h" 23#include "coretypes.h" 24#include "cp-tree.h" 25#include "cp-objcp-common.h" 26#include "dwarf2.h" 27#include "stringpool.h" 28 29/* Special routine to get the alias set for C++. */ 30 31alias_set_type 32cxx_get_alias_set (tree t) 33{ 34 if (IS_FAKE_BASE_TYPE (t)) 35 /* The base variant of a type must be in the same alias set as the 36 complete type. */ 37 return get_alias_set (TYPE_CONTEXT (t)); 38 39 /* Punt on PMFs until we canonicalize functions properly. */ 40 if (TYPE_PTRMEMFUNC_P (t) 41 || (INDIRECT_TYPE_P (t) 42 && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))) 43 return 0; 44 45 return c_common_get_alias_set (t); 46} 47 48/* Called from check_global_declaration. */ 49 50bool 51cxx_warn_unused_global_decl (const_tree decl) 52{ 53 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)) 54 return false; 55 if (DECL_IN_SYSTEM_HEADER (decl)) 56 return false; 57 58 return true; 59} 60 61/* Langhook for tree_size: determine size of our 'x' and 'c' nodes. */ 62size_t 63cp_tree_size (enum tree_code code) 64{ 65 gcc_checking_assert (code >= NUM_TREE_CODES); 66 switch (code) 67 { 68 case PTRMEM_CST: return sizeof (ptrmem_cst); 69 case BASELINK: return sizeof (tree_baselink); 70 case TEMPLATE_PARM_INDEX: return sizeof (template_parm_index); 71 case DEFERRED_PARSE: return sizeof (tree_deferred_parse); 72 case DEFERRED_NOEXCEPT: return sizeof (tree_deferred_noexcept); 73 case OVERLOAD: return sizeof (tree_overload); 74 case STATIC_ASSERT: return sizeof (tree_static_assert); 75#if 0 76 /* This would match cp_common_init_ts, but breaks GC because 77 tree_node_structure_for_code returns TS_TYPE_NON_COMMON for all 78 types. */ 79 case UNBOUND_CLASS_TEMPLATE: 80 case TYPE_ARGUMENT_PACK: return sizeof (tree_type_common); 81#endif 82 case ARGUMENT_PACK_SELECT: return sizeof (tree_argument_pack_select); 83 case TRAIT_EXPR: return sizeof (tree_trait_expr); 84 case LAMBDA_EXPR: return sizeof (tree_lambda_expr); 85 case TEMPLATE_INFO: return sizeof (tree_template_info); 86 case CONSTRAINT_INFO: return sizeof (tree_constraint_info); 87 case USERDEF_LITERAL: return sizeof (tree_userdef_literal); 88 case TEMPLATE_DECL: return sizeof (tree_template_decl); 89 default: 90 switch (TREE_CODE_CLASS (code)) 91 { 92 case tcc_declaration: return sizeof (tree_decl_non_common); 93 case tcc_type: return sizeof (tree_type_non_common); 94 default: gcc_unreachable (); 95 } 96 } 97 /* NOTREACHED */ 98} 99 100/* Returns true if T is a variably modified type, in the sense of C99. 101 FN is as passed to variably_modified_p. 102 This routine needs only check cases that cannot be handled by the 103 language-independent logic in tree.cc. */ 104 105bool 106cp_var_mod_type_p (tree type, tree fn) 107{ 108 /* If TYPE is a pointer-to-member, it is variably modified if either 109 the class or the member are variably modified. */ 110 if (TYPE_PTRMEM_P (type)) 111 return (variably_modified_type_p (TYPE_PTRMEM_CLASS_TYPE (type), fn) 112 || variably_modified_type_p (TYPE_PTRMEM_POINTED_TO_TYPE (type), 113 fn)); 114 115 /* All other types are not variably modified. */ 116 return false; 117} 118 119/* This compares two types for equivalence ("compatible" in C-based languages). 120 This routine should only return 1 if it is sure. It should not be used 121 in contexts where erroneously returning 0 causes problems. */ 122 123int 124cxx_types_compatible_p (tree x, tree y) 125{ 126 return same_type_ignoring_top_level_qualifiers_p (x, y); 127} 128 129static GTY((cache)) type_tree_cache_map *debug_type_map; 130 131/* Return a type to use in the debug info instead of TYPE, or NULL_TREE to 132 keep TYPE. */ 133 134tree 135cp_get_debug_type (const_tree type) 136{ 137 tree dtype = NULL_TREE; 138 139 if (TYPE_PTRMEMFUNC_P (type) && !typedef_variant_p (type)) 140 dtype = build_offset_type (TYPE_PTRMEMFUNC_OBJECT_TYPE (type), 141 TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type))); 142 143 /* We cannot simply return the debug type here because the function uses 144 the type canonicalization hashtable, which is GC-ed, so its behavior 145 depends on the actual collection points. Since we are building these 146 types on the fly for the debug info only, they would not be attached 147 to any GC root and always be swept, so we would make the contents of 148 the debug info depend on the collection points. */ 149 if (dtype) 150 { 151 tree ktype = CONST_CAST_TREE (type); 152 if (tree *slot = hash_map_safe_get (debug_type_map, ktype)) 153 return *slot; 154 hash_map_safe_put<hm_ggc> (debug_type_map, ktype, dtype); 155 } 156 157 return dtype; 158} 159 160/* Return -1 if dwarf ATTR shouldn't be added for DECL, or the attribute 161 value otherwise. */ 162int 163cp_decl_dwarf_attribute (const_tree decl, int attr) 164{ 165 if (decl == NULL_TREE) 166 return -1; 167 168 switch (attr) 169 { 170 case DW_AT_explicit: 171 if (TREE_CODE (decl) == FUNCTION_DECL 172 && DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl)) 173 && DECL_NONCONVERTING_P (decl)) 174 return 1; 175 break; 176 177 case DW_AT_deleted: 178 if (TREE_CODE (decl) == FUNCTION_DECL 179 && DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl)) 180 && DECL_DELETED_FN (decl)) 181 return 1; 182 break; 183 184 case DW_AT_defaulted: 185 if (TREE_CODE (decl) == FUNCTION_DECL 186 && DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl)) 187 && DECL_DEFAULTED_FN (decl)) 188 { 189 if (DECL_DEFAULTED_IN_CLASS_P (decl)) 190 return DW_DEFAULTED_in_class; 191 192 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (decl)) 193 return DW_DEFAULTED_out_of_class; 194 } 195 break; 196 197 case DW_AT_const_expr: 198 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_DECLARED_CONSTEXPR_P (decl)) 199 return 1; 200 break; 201 202 case DW_AT_reference: 203 if (TREE_CODE (decl) == FUNCTION_DECL 204 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl) 205 && FUNCTION_REF_QUALIFIED (TREE_TYPE (decl)) 206 && !FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl))) 207 return 1; 208 break; 209 210 case DW_AT_rvalue_reference: 211 if (TREE_CODE (decl) == FUNCTION_DECL 212 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl) 213 && FUNCTION_REF_QUALIFIED (TREE_TYPE (decl)) 214 && FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl))) 215 return 1; 216 break; 217 218 case DW_AT_inline: 219 if (VAR_P (decl) && DECL_INLINE_VAR_P (decl)) 220 { 221 if (DECL_VAR_DECLARED_INLINE_P (decl)) 222 return DW_INL_declared_inlined; 223 else 224 return DW_INL_inlined; 225 } 226 break; 227 228 case DW_AT_export_symbols: 229 if (TREE_CODE (decl) == NAMESPACE_DECL 230 && (DECL_NAMESPACE_INLINE_P (decl) 231 || (DECL_NAME (decl) == NULL_TREE && dwarf_version >= 5))) 232 return 1; 233 break; 234 235 default: 236 break; 237 } 238 239 return -1; 240} 241 242/* Return -1 if dwarf ATTR shouldn't be added for TYPE, or the attribute 243 value otherwise. */ 244int 245cp_type_dwarf_attribute (const_tree type, int attr) 246{ 247 if (type == NULL_TREE) 248 return -1; 249 250 switch (attr) 251 { 252 case DW_AT_reference: 253 if (FUNC_OR_METHOD_TYPE_P (type) 254 && FUNCTION_REF_QUALIFIED (type) 255 && !FUNCTION_RVALUE_QUALIFIED (type)) 256 return 1; 257 break; 258 259 case DW_AT_rvalue_reference: 260 if (FUNC_OR_METHOD_TYPE_P (type) 261 && FUNCTION_REF_QUALIFIED (type) 262 && FUNCTION_RVALUE_QUALIFIED (type)) 263 return 1; 264 break; 265 266 default: 267 break; 268 } 269 270 return -1; 271} 272 273/* Return the unit size of TYPE without reusable tail padding. */ 274 275tree 276cp_unit_size_without_reusable_padding (tree type) 277{ 278 if (CLASS_TYPE_P (type)) 279 return CLASSTYPE_SIZE_UNIT (type); 280 return TYPE_SIZE_UNIT (type); 281} 282 283/* Returns type corresponding to FIELD's type when FIELD is a C++ base class 284 i.e., type without virtual base classes or tail padding. Returns 285 NULL_TREE otherwise. */ 286 287tree 288cp_classtype_as_base (const_tree field) 289{ 290 if (DECL_FIELD_IS_BASE (field)) 291 { 292 tree type = TREE_TYPE (field); 293 if (TYPE_LANG_SPECIFIC (type)) 294 return CLASSTYPE_AS_BASE (type); 295 } 296 return NULL_TREE; 297} 298 299/* Stubs to keep c-opts.cc happy. */ 300void 301push_file_scope (void) 302{ 303} 304 305void 306pop_file_scope (void) 307{ 308} 309 310/* c-pragma.cc needs to query whether a decl has extern "C" linkage. */ 311bool 312has_c_linkage (const_tree decl) 313{ 314 return DECL_EXTERN_C_P (decl); 315} 316 317/* Return true if stmt can fall through. Used by block_may_fallthru 318 default case. */ 319 320bool 321cxx_block_may_fallthru (const_tree stmt) 322{ 323 switch (TREE_CODE (stmt)) 324 { 325 case EXPR_STMT: 326 return block_may_fallthru (EXPR_STMT_EXPR (stmt)); 327 328 case THROW_EXPR: 329 return false; 330 331 case IF_STMT: 332 if (IF_STMT_CONSTEXPR_P (stmt)) 333 { 334 if (integer_nonzerop (IF_COND (stmt))) 335 return block_may_fallthru (THEN_CLAUSE (stmt)); 336 if (integer_zerop (IF_COND (stmt))) 337 return block_may_fallthru (ELSE_CLAUSE (stmt)); 338 } 339 if (block_may_fallthru (THEN_CLAUSE (stmt))) 340 return true; 341 return block_may_fallthru (ELSE_CLAUSE (stmt)); 342 343 case CLEANUP_STMT: 344 /* Just handle the try/finally cases. */ 345 if (!CLEANUP_EH_ONLY (stmt)) 346 { 347 return (block_may_fallthru (CLEANUP_BODY (stmt)) 348 && block_may_fallthru (CLEANUP_EXPR (stmt))); 349 } 350 return true; 351 352 default: 353 return c_block_may_fallthru (stmt); 354 } 355} 356 357/* Return the list of decls in the global namespace. */ 358 359tree 360cp_get_global_decls () 361{ 362 return NAMESPACE_LEVEL (global_namespace)->names; 363} 364 365/* Push DECL into the current (namespace) scope. */ 366 367tree 368cp_pushdecl (tree decl) 369{ 370 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace); 371 return pushdecl (decl); 372} 373 374/* Get the global value binding of NAME. Called directly from 375 c-common.cc, not via a hook. */ 376 377tree 378identifier_global_value (tree name) 379{ 380 return get_global_binding (name); 381} 382 383/* Similarly, but return struct/class/union NAME instead. */ 384 385tree 386identifier_global_tag (tree name) 387{ 388 tree ret = lookup_qualified_name (global_namespace, name, LOOK_want::TYPE, 389 /*complain*/false); 390 if (ret == error_mark_node) 391 return NULL_TREE; 392 return ret; 393} 394 395/* Returns true if NAME refers to a built-in function or function-like 396 operator. */ 397 398bool 399names_builtin_p (const char *name) 400{ 401 tree id = get_identifier (name); 402 if (tree binding = get_global_binding (id)) 403 { 404 if (TREE_CODE (binding) == FUNCTION_DECL 405 && DECL_IS_UNDECLARED_BUILTIN (binding)) 406 return true; 407 408 /* Handle the case when an overload for a built-in name exists. */ 409 if (TREE_CODE (binding) != OVERLOAD) 410 return false; 411 412 for (ovl_iterator it (binding); it; ++it) 413 { 414 tree decl = *it; 415 if (DECL_IS_UNDECLARED_BUILTIN (decl)) 416 return true; 417 } 418 } 419 420 /* Also detect common reserved C++ words that aren't strictly built-in 421 functions. */ 422 switch (C_RID_CODE (id)) 423 { 424 case RID_ADDRESSOF: 425 case RID_BUILTIN_CONVERTVECTOR: 426 case RID_BUILTIN_HAS_ATTRIBUTE: 427 case RID_BUILTIN_SHUFFLE: 428 case RID_BUILTIN_SHUFFLEVECTOR: 429 case RID_BUILTIN_LAUNDER: 430 case RID_BUILTIN_ASSOC_BARRIER: 431 case RID_BUILTIN_BIT_CAST: 432 case RID_OFFSETOF: 433 case RID_HAS_NOTHROW_ASSIGN: 434 case RID_HAS_NOTHROW_CONSTRUCTOR: 435 case RID_HAS_NOTHROW_COPY: 436 case RID_HAS_TRIVIAL_ASSIGN: 437 case RID_HAS_TRIVIAL_CONSTRUCTOR: 438 case RID_HAS_TRIVIAL_COPY: 439 case RID_HAS_TRIVIAL_DESTRUCTOR: 440 case RID_HAS_UNIQUE_OBJ_REPRESENTATIONS: 441 case RID_HAS_VIRTUAL_DESTRUCTOR: 442 case RID_IS_ABSTRACT: 443 case RID_IS_AGGREGATE: 444 case RID_IS_BASE_OF: 445 case RID_IS_CLASS: 446 case RID_IS_EMPTY: 447 case RID_IS_ENUM: 448 case RID_IS_FINAL: 449 case RID_IS_LAYOUT_COMPATIBLE: 450 case RID_IS_LITERAL_TYPE: 451 case RID_IS_POINTER_INTERCONVERTIBLE_BASE_OF: 452 case RID_IS_POD: 453 case RID_IS_POLYMORPHIC: 454 case RID_IS_SAME_AS: 455 case RID_IS_STD_LAYOUT: 456 case RID_IS_TRIVIAL: 457 case RID_IS_TRIVIALLY_ASSIGNABLE: 458 case RID_IS_TRIVIALLY_CONSTRUCTIBLE: 459 case RID_IS_TRIVIALLY_COPYABLE: 460 case RID_IS_UNION: 461 case RID_IS_ASSIGNABLE: 462 case RID_IS_CONSTRUCTIBLE: 463 case RID_IS_NOTHROW_ASSIGNABLE: 464 case RID_IS_NOTHROW_CONSTRUCTIBLE: 465 case RID_UNDERLYING_TYPE: 466 return true; 467 default: 468 break; 469 } 470 471 return false; 472} 473 474/* Register c++-specific dumps. */ 475 476void 477cp_register_dumps (gcc::dump_manager *dumps) 478{ 479 class_dump_id = dumps->dump_register 480 (".class", "lang-class", "lang-class", DK_lang, OPTGROUP_NONE, false); 481 482 module_dump_id = dumps->dump_register 483 (".module", "lang-module", "lang-module", DK_lang, OPTGROUP_NONE, false); 484 485 raw_dump_id = dumps->dump_register 486 (".raw", "lang-raw", "lang-raw", DK_lang, OPTGROUP_NONE, false); 487} 488 489void 490cp_common_init_ts (void) 491{ 492 /* With type. */ 493 MARK_TS_TYPED (PTRMEM_CST); 494 MARK_TS_TYPED (LAMBDA_EXPR); 495 MARK_TS_TYPED (TYPE_ARGUMENT_PACK); 496 497 /* Random new trees. */ 498 MARK_TS_COMMON (BASELINK); 499 MARK_TS_COMMON (OVERLOAD); 500 MARK_TS_COMMON (TEMPLATE_PARM_INDEX); 501 502 /* New decls. */ 503 MARK_TS_DECL_COMMON (TEMPLATE_DECL); 504 MARK_TS_DECL_COMMON (WILDCARD_DECL); 505 MARK_TS_DECL_COMMON (CONCEPT_DECL); 506 507 MARK_TS_DECL_NON_COMMON (USING_DECL); 508 509 /* New Types. */ 510 MARK_TS_TYPE_COMMON (UNBOUND_CLASS_TEMPLATE); 511 MARK_TS_TYPE_COMMON (TYPE_ARGUMENT_PACK); 512 MARK_TS_TYPE_COMMON (DEPENDENT_OPERATOR_TYPE); 513 514 MARK_TS_TYPE_NON_COMMON (DECLTYPE_TYPE); 515 MARK_TS_TYPE_NON_COMMON (TYPENAME_TYPE); 516 MARK_TS_TYPE_NON_COMMON (TYPEOF_TYPE); 517 MARK_TS_TYPE_NON_COMMON (UNDERLYING_TYPE); 518 MARK_TS_TYPE_NON_COMMON (BOUND_TEMPLATE_TEMPLATE_PARM); 519 MARK_TS_TYPE_NON_COMMON (TEMPLATE_TEMPLATE_PARM); 520 MARK_TS_TYPE_NON_COMMON (TEMPLATE_TYPE_PARM); 521 MARK_TS_TYPE_NON_COMMON (TYPE_PACK_EXPANSION); 522 523 /* Statements. */ 524 MARK_TS_EXP (CLEANUP_STMT); 525 MARK_TS_EXP (EH_SPEC_BLOCK); 526 MARK_TS_EXP (HANDLER); 527 MARK_TS_EXP (IF_STMT); 528 MARK_TS_EXP (OMP_DEPOBJ); 529 MARK_TS_EXP (RANGE_FOR_STMT); 530 MARK_TS_EXP (TRY_BLOCK); 531 MARK_TS_EXP (USING_STMT); 532 533 /* Random expressions. */ 534 MARK_TS_EXP (ADDRESSOF_EXPR); 535 MARK_TS_EXP (AGGR_INIT_EXPR); 536 MARK_TS_EXP (ALIGNOF_EXPR); 537 MARK_TS_EXP (ARROW_EXPR); 538 MARK_TS_EXP (AT_ENCODE_EXPR); 539 MARK_TS_EXP (BIT_CAST_EXPR); 540 MARK_TS_EXP (CAST_EXPR); 541 MARK_TS_EXP (CONST_CAST_EXPR); 542 MARK_TS_EXP (CTOR_INITIALIZER); 543 MARK_TS_EXP (DELETE_EXPR); 544 MARK_TS_EXP (DOTSTAR_EXPR); 545 MARK_TS_EXP (DYNAMIC_CAST_EXPR); 546 MARK_TS_EXP (EMPTY_CLASS_EXPR); 547 MARK_TS_EXP (EXPR_STMT); 548 MARK_TS_EXP (IMPLICIT_CONV_EXPR); 549 MARK_TS_EXP (MEMBER_REF); 550 MARK_TS_EXP (MODOP_EXPR); 551 MARK_TS_EXP (MUST_NOT_THROW_EXPR); 552 MARK_TS_EXP (NEW_EXPR); 553 MARK_TS_EXP (NOEXCEPT_EXPR); 554 MARK_TS_EXP (NON_DEPENDENT_EXPR); 555 MARK_TS_EXP (OFFSETOF_EXPR); 556 MARK_TS_EXP (OFFSET_REF); 557 MARK_TS_EXP (PSEUDO_DTOR_EXPR); 558 MARK_TS_EXP (REINTERPRET_CAST_EXPR); 559 MARK_TS_EXP (SCOPE_REF); 560 MARK_TS_EXP (STATIC_CAST_EXPR); 561 MARK_TS_EXP (STMT_EXPR); 562 MARK_TS_EXP (TAG_DEFN); 563 MARK_TS_EXP (TEMPLATE_ID_EXPR); 564 MARK_TS_EXP (THROW_EXPR); 565 MARK_TS_EXP (TRAIT_EXPR); 566 MARK_TS_EXP (TYPEID_EXPR); 567 MARK_TS_EXP (TYPE_EXPR); 568 MARK_TS_EXP (UNARY_PLUS_EXPR); 569 MARK_TS_EXP (VEC_DELETE_EXPR); 570 MARK_TS_EXP (VEC_INIT_EXPR); 571 MARK_TS_EXP (VEC_NEW_EXPR); 572 MARK_TS_EXP (SPACESHIP_EXPR); 573 574 /* Fold expressions. */ 575 MARK_TS_EXP (BINARY_LEFT_FOLD_EXPR); 576 MARK_TS_EXP (BINARY_RIGHT_FOLD_EXPR); 577 MARK_TS_EXP (EXPR_PACK_EXPANSION); 578 MARK_TS_EXP (NONTYPE_ARGUMENT_PACK); 579 MARK_TS_EXP (UNARY_LEFT_FOLD_EXPR); 580 MARK_TS_EXP (UNARY_RIGHT_FOLD_EXPR); 581 582 /* Constraints. */ 583 MARK_TS_EXP (CHECK_CONSTR); 584 MARK_TS_EXP (COMPOUND_REQ); 585 MARK_TS_EXP (CONJ_CONSTR); 586 MARK_TS_EXP (DISJ_CONSTR); 587 MARK_TS_EXP (ATOMIC_CONSTR); 588 MARK_TS_EXP (NESTED_REQ); 589 MARK_TS_EXP (REQUIRES_EXPR); 590 MARK_TS_EXP (SIMPLE_REQ); 591 MARK_TS_EXP (TYPE_REQ); 592 593 MARK_TS_EXP (CO_AWAIT_EXPR); 594 MARK_TS_EXP (CO_YIELD_EXPR); 595 MARK_TS_EXP (CO_RETURN_EXPR); 596 597 c_common_init_ts (); 598} 599 600/* Handle C++-specficic options here. Punt to c_common otherwise. */ 601 602bool 603cp_handle_option (size_t scode, const char *arg, HOST_WIDE_INT value, 604 int kind, location_t loc, 605 const struct cl_option_handlers *handlers) 606{ 607 if (handle_module_option (unsigned (scode), arg, value)) 608 return true; 609 return c_common_handle_option (scode, arg, value, kind, loc, handlers); 610} 611 612#include "gt-cp-cp-objcp-common.h" 613