gcc/cp/cp-objcp-common.cc

   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
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along 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
  31 alias_set_type
  32 cxx_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
  50 bool
  51 cxx_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.  */
  62 size_t
  63 cp_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
 105 bool
 106 cp_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
 123 int
 124 cxx_types_compatible_p (tree x, tree y)
 125 {
 126   return same_type_ignoring_top_level_qualifiers_p (x, y);
 127 }
 128
 129 static 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
 134 tree
 135 cp_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.  */
 162 int
 163 cp_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.  */
 244 int
 245 cp_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
 275 tree
 276 cp_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
 287 tree
 288 cp_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.  */
 300 void
 301 push_file_scope (void)
 302 {
 303 }
 304
 305 void
 306 pop_file_scope (void)
 307 {
 308 }
 309
 310 /* c-pragma.cc needs to query whether a decl has extern "C" linkage.  */
 311 bool
 312 has_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
 320 bool
 321 cxx_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
 359 tree
 360 cp_get_global_decls ()
 361 {
 362   return NAMESPACE_LEVEL (global_namespace)->names;
 363 }
 364
 365 /* Push DECL into the current (namespace) scope.  */
 366
 367 tree
 368 cp_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
 377 tree
 378 identifier_global_value (tree name)
 379 {
 380   return get_global_binding (name);
 381 }
 382
 383 /* Similarly, but return struct/class/union NAME instead.  */
 384
 385 tree
 386 identifier_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
 398 bool
 399 names_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 #define DEFTRAIT(TCC, CODE, NAME, ARITY) \
 434     case RID_##CODE:
 435 #include "cp-trait.def"
 436 #undef DEFTRAIT
 437       return true;
 438     default:
 439       break;
 440     }
 441
 442   return false;
 443 }
 444
 445 /* Register c++-specific dumps.  */
 446
 447 void
 448 cp_register_dumps (gcc::dump_manager *dumps)
 449 {
 450   class_dump_id = dumps->dump_register
 451     (".class", "lang-class", "lang-class", DK_lang, OPTGROUP_NONE, false);
 452
 453   module_dump_id = dumps->dump_register
 454     (".module", "lang-module", "lang-module", DK_lang, OPTGROUP_NONE, false);
 455
 456   raw_dump_id = dumps->dump_register
 457     (".raw", "lang-raw", "lang-raw", DK_lang, OPTGROUP_NONE, false);
 458 }
 459
 460 void
 461 cp_common_init_ts (void)
 462 {
 463   /* With type.  */
 464   MARK_TS_TYPED (PTRMEM_CST);
 465   MARK_TS_TYPED (LAMBDA_EXPR);
 466   MARK_TS_TYPED (TYPE_ARGUMENT_PACK);
 467
 468   /* Random new trees.  */
 469   MARK_TS_COMMON (BASELINK);
 470   MARK_TS_COMMON (OVERLOAD);
 471   MARK_TS_COMMON (TEMPLATE_PARM_INDEX);
 472
 473   /* New decls.  */
 474   MARK_TS_DECL_COMMON (TEMPLATE_DECL);
 475   MARK_TS_DECL_COMMON (WILDCARD_DECL);
 476   MARK_TS_DECL_COMMON (CONCEPT_DECL);
 477
 478   MARK_TS_DECL_NON_COMMON (USING_DECL);
 479
 480   /* New Types.  */
 481   MARK_TS_TYPE_COMMON (UNBOUND_CLASS_TEMPLATE);
 482   MARK_TS_TYPE_COMMON (TYPE_ARGUMENT_PACK);
 483   MARK_TS_TYPE_COMMON (DEPENDENT_OPERATOR_TYPE);
 484
 485   MARK_TS_TYPE_NON_COMMON (DECLTYPE_TYPE);
 486   MARK_TS_TYPE_NON_COMMON (TYPENAME_TYPE);
 487   MARK_TS_TYPE_NON_COMMON (TYPEOF_TYPE);
 488   MARK_TS_TYPE_NON_COMMON (TRAIT_TYPE);
 489   MARK_TS_TYPE_NON_COMMON (BOUND_TEMPLATE_TEMPLATE_PARM);
 490   MARK_TS_TYPE_NON_COMMON (TEMPLATE_TEMPLATE_PARM);
 491   MARK_TS_TYPE_NON_COMMON (TEMPLATE_TYPE_PARM);
 492   MARK_TS_TYPE_NON_COMMON (TYPE_PACK_EXPANSION);
 493
 494   /* Statements.  */
 495   MARK_TS_EXP (CLEANUP_STMT);
 496   MARK_TS_EXP (EH_SPEC_BLOCK);
 497   MARK_TS_EXP (HANDLER);
 498   MARK_TS_EXP (IF_STMT);
 499   MARK_TS_EXP (OMP_DEPOBJ);
 500   MARK_TS_EXP (RANGE_FOR_STMT);
 501   MARK_TS_EXP (TRY_BLOCK);
 502   MARK_TS_EXP (USING_STMT);
 503
 504   /* Random expressions.  */
 505   MARK_TS_EXP (ADDRESSOF_EXPR);
 506   MARK_TS_EXP (AGGR_INIT_EXPR);
 507   MARK_TS_EXP (ALIGNOF_EXPR);
 508   MARK_TS_EXP (ARROW_EXPR);
 509   MARK_TS_EXP (AT_ENCODE_EXPR);
 510   MARK_TS_EXP (BIT_CAST_EXPR);
 511   MARK_TS_EXP (CAST_EXPR);
 512   MARK_TS_EXP (CONST_CAST_EXPR);
 513   MARK_TS_EXP (CTOR_INITIALIZER);
 514   MARK_TS_EXP (DELETE_EXPR);
 515   MARK_TS_EXP (DOTSTAR_EXPR);
 516   MARK_TS_EXP (DYNAMIC_CAST_EXPR);
 517   MARK_TS_EXP (EMPTY_CLASS_EXPR);
 518   MARK_TS_EXP (EXPR_STMT);
 519   MARK_TS_EXP (IMPLICIT_CONV_EXPR);
 520   MARK_TS_EXP (MEMBER_REF);
 521   MARK_TS_EXP (MODOP_EXPR);
 522   MARK_TS_EXP (MUST_NOT_THROW_EXPR);
 523   MARK_TS_EXP (NEW_EXPR);
 524   MARK_TS_EXP (NOEXCEPT_EXPR);
 525   MARK_TS_EXP (NON_DEPENDENT_EXPR);
 526   MARK_TS_EXP (OFFSETOF_EXPR);
 527   MARK_TS_EXP (OFFSET_REF);
 528   MARK_TS_EXP (PSEUDO_DTOR_EXPR);
 529   MARK_TS_EXP (REINTERPRET_CAST_EXPR);
 530   MARK_TS_EXP (SCOPE_REF);
 531   MARK_TS_EXP (STATIC_CAST_EXPR);
 532   MARK_TS_EXP (STMT_EXPR);
 533   MARK_TS_EXP (TAG_DEFN);
 534   MARK_TS_EXP (TEMPLATE_ID_EXPR);
 535   MARK_TS_EXP (THROW_EXPR);
 536   MARK_TS_EXP (TRAIT_EXPR);
 537   MARK_TS_EXP (TYPEID_EXPR);
 538   MARK_TS_EXP (TYPE_EXPR);
 539   MARK_TS_EXP (UNARY_PLUS_EXPR);
 540   MARK_TS_EXP (VEC_DELETE_EXPR);
 541   MARK_TS_EXP (VEC_INIT_EXPR);
 542   MARK_TS_EXP (VEC_NEW_EXPR);
 543   MARK_TS_EXP (SPACESHIP_EXPR);
 544
 545   /* Fold expressions.  */
 546   MARK_TS_EXP (BINARY_LEFT_FOLD_EXPR);
 547   MARK_TS_EXP (BINARY_RIGHT_FOLD_EXPR);
 548   MARK_TS_EXP (EXPR_PACK_EXPANSION);
 549   MARK_TS_EXP (NONTYPE_ARGUMENT_PACK);
 550   MARK_TS_EXP (UNARY_LEFT_FOLD_EXPR);
 551   MARK_TS_EXP (UNARY_RIGHT_FOLD_EXPR);
 552
 553   /* Constraints.  */
 554   MARK_TS_EXP (CHECK_CONSTR);
 555   MARK_TS_EXP (COMPOUND_REQ);
 556   MARK_TS_EXP (CONJ_CONSTR);
 557   MARK_TS_EXP (DISJ_CONSTR);
 558   MARK_TS_EXP (ATOMIC_CONSTR);
 559   MARK_TS_EXP (NESTED_REQ);
 560   MARK_TS_EXP (REQUIRES_EXPR);
 561   MARK_TS_EXP (SIMPLE_REQ);
 562   MARK_TS_EXP (TYPE_REQ);
 563
 564   MARK_TS_EXP (CO_AWAIT_EXPR);
 565   MARK_TS_EXP (CO_YIELD_EXPR);
 566   MARK_TS_EXP (CO_RETURN_EXPR);
 567
 568   c_common_init_ts ();
 569 }
 570
 571 /* Handle C++-specficic options here.  Punt to c_common otherwise.  */
 572
 573 bool
 574 cp_handle_option (size_t scode, const char *arg, HOST_WIDE_INT value,
 575                   int kind, location_t loc,
 576                   const struct cl_option_handlers *handlers)
 577 {
 578   if (handle_module_option (unsigned (scode), arg, value))
 579     return true;
 580   return c_common_handle_option (scode, arg, value, kind, loc, handlers);
 581 }
 582
 583 #include "gt-cp-cp-objcp-common.h"