gcc/cp/cp-objcp-common.c

   1 /* Some code common to C++ and ObjC++ front ends.
   2    Copyright (C) 2004-2021 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.c.  */
 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 /* Stubs to keep c-opts.c happy.  */
 284 void
 285 push_file_scope (void)
 286 {
 287 }
 288
 289 void
 290 pop_file_scope (void)
 291 {
 292 }
 293
 294 /* c-pragma.c needs to query whether a decl has extern "C" linkage.  */
 295 bool
 296 has_c_linkage (const_tree decl)
 297 {
 298   return DECL_EXTERN_C_P (decl);
 299 }
 300
 301 /* Return true if stmt can fall through.  Used by block_may_fallthru
 302    default case.  */
 303
 304 bool
 305 cxx_block_may_fallthru (const_tree stmt)
 306 {
 307   switch (TREE_CODE (stmt))
 308     {
 309     case EXPR_STMT:
 310       return block_may_fallthru (EXPR_STMT_EXPR (stmt));
 311
 312     case THROW_EXPR:
 313       return false;
 314
 315     case IF_STMT:
 316       if (block_may_fallthru (THEN_CLAUSE (stmt)))
 317         return true;
 318       return block_may_fallthru (ELSE_CLAUSE (stmt));
 319
 320     case CLEANUP_STMT:
 321       /* Just handle the try/finally cases.  */
 322       if (!CLEANUP_EH_ONLY (stmt))
 323         {
 324           return (block_may_fallthru (CLEANUP_BODY (stmt))
 325                   && block_may_fallthru (CLEANUP_EXPR (stmt)));
 326         }
 327       return true;
 328
 329     default:
 330       return c_block_may_fallthru (stmt);
 331     }
 332 }
 333
 334 /* Return the list of decls in the global namespace.  */
 335
 336 tree
 337 cp_get_global_decls ()
 338 {
 339   return NAMESPACE_LEVEL (global_namespace)->names;
 340 }
 341
 342 /* Push DECL into the current (namespace) scope.  */
 343
 344 tree
 345 cp_pushdecl (tree decl)
 346 {
 347   DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
 348   return pushdecl (decl);
 349 }
 350
 351 /* Get the global value binding of NAME.  Called directly from
 352    c-common.c, not via a hook. */
 353
 354 tree
 355 identifier_global_value (tree name)
 356 {
 357   return get_global_binding (name);
 358 }
 359
 360 /* Similarly, but return struct/class/union NAME instead.  */
 361
 362 tree
 363 identifier_global_tag (tree name)
 364 {
 365   tree ret = lookup_qualified_name (global_namespace, name, LOOK_want::TYPE,
 366                                     /*complain*/false);
 367   if (ret == error_mark_node)
 368     return NULL_TREE;
 369   return ret;
 370 }
 371
 372 /* Returns true if NAME refers to a built-in function or function-like
 373    operator.  */
 374
 375 bool
 376 names_builtin_p (const char *name)
 377 {
 378   tree id = get_identifier (name);
 379   if (tree binding = get_global_binding (id))
 380     {
 381       if (TREE_CODE (binding) == FUNCTION_DECL
 382           && DECL_IS_UNDECLARED_BUILTIN (binding))
 383         return true;
 384
 385       /* Handle the case when an overload for a  built-in name exists.  */
 386       if (TREE_CODE (binding) != OVERLOAD)
 387         return false;
 388
 389       for (ovl_iterator it (binding); it; ++it)
 390         {
 391           tree decl = *it;
 392           if (DECL_IS_UNDECLARED_BUILTIN (decl))
 393             return true;
 394         }
 395     }
 396
 397   /* Also detect common reserved C++ words that aren't strictly built-in
 398      functions.  */
 399   switch (C_RID_CODE (id))
 400     {
 401     case RID_ADDRESSOF:
 402     case RID_BUILTIN_CONVERTVECTOR:
 403     case RID_BUILTIN_HAS_ATTRIBUTE:
 404     case RID_BUILTIN_SHUFFLE:
 405     case RID_BUILTIN_SHUFFLEVECTOR:
 406     case RID_BUILTIN_LAUNDER:
 407     case RID_BUILTIN_BIT_CAST:
 408     case RID_OFFSETOF:
 409     case RID_HAS_NOTHROW_ASSIGN:
 410     case RID_HAS_NOTHROW_CONSTRUCTOR:
 411     case RID_HAS_NOTHROW_COPY:
 412     case RID_HAS_TRIVIAL_ASSIGN:
 413     case RID_HAS_TRIVIAL_CONSTRUCTOR:
 414     case RID_HAS_TRIVIAL_COPY:
 415     case RID_HAS_TRIVIAL_DESTRUCTOR:
 416     case RID_HAS_UNIQUE_OBJ_REPRESENTATIONS:
 417     case RID_HAS_VIRTUAL_DESTRUCTOR:
 418     case RID_IS_ABSTRACT:
 419     case RID_IS_AGGREGATE:
 420     case RID_IS_BASE_OF:
 421     case RID_IS_CLASS:
 422     case RID_IS_EMPTY:
 423     case RID_IS_ENUM:
 424     case RID_IS_FINAL:
 425     case RID_IS_LAYOUT_COMPATIBLE:
 426     case RID_IS_LITERAL_TYPE:
 427     case RID_IS_POINTER_INTERCONVERTIBLE_BASE_OF:
 428     case RID_IS_POD:
 429     case RID_IS_POLYMORPHIC:
 430     case RID_IS_SAME_AS:
 431     case RID_IS_STD_LAYOUT:
 432     case RID_IS_TRIVIAL:
 433     case RID_IS_TRIVIALLY_ASSIGNABLE:
 434     case RID_IS_TRIVIALLY_CONSTRUCTIBLE:
 435     case RID_IS_TRIVIALLY_COPYABLE:
 436     case RID_IS_UNION:
 437     case RID_IS_ASSIGNABLE:
 438     case RID_IS_CONSTRUCTIBLE:
 439     case RID_UNDERLYING_TYPE:
 440       return true;
 441     default:
 442       break;
 443     }
 444
 445   return false;
 446 }
 447
 448 /* Register c++-specific dumps.  */
 449
 450 void
 451 cp_register_dumps (gcc::dump_manager *dumps)
 452 {
 453   class_dump_id = dumps->dump_register
 454     (".class", "lang-class", "lang-class", DK_lang, OPTGROUP_NONE, false);
 455
 456   module_dump_id = dumps->dump_register
 457     (".module", "lang-module", "lang-module", DK_lang, OPTGROUP_NONE, false);
 458
 459   raw_dump_id = dumps->dump_register
 460     (".raw", "lang-raw", "lang-raw", DK_lang, OPTGROUP_NONE, false);
 461 }
 462
 463 void
 464 cp_common_init_ts (void)
 465 {
 466   /* With type.  */
 467   MARK_TS_TYPED (PTRMEM_CST);
 468   MARK_TS_TYPED (LAMBDA_EXPR);
 469   MARK_TS_TYPED (TYPE_ARGUMENT_PACK);
 470
 471   /* Random new trees.  */
 472   MARK_TS_COMMON (BASELINK);
 473   MARK_TS_COMMON (OVERLOAD);
 474   MARK_TS_COMMON (TEMPLATE_PARM_INDEX);
 475
 476   /* New decls.  */
 477   MARK_TS_DECL_COMMON (TEMPLATE_DECL);
 478   MARK_TS_DECL_COMMON (WILDCARD_DECL);
 479   MARK_TS_DECL_COMMON (CONCEPT_DECL);
 480
 481   MARK_TS_DECL_NON_COMMON (USING_DECL);
 482
 483   /* New Types.  */
 484   MARK_TS_TYPE_COMMON (UNBOUND_CLASS_TEMPLATE);
 485   MARK_TS_TYPE_COMMON (TYPE_ARGUMENT_PACK);
 486
 487   MARK_TS_TYPE_NON_COMMON (DECLTYPE_TYPE);
 488   MARK_TS_TYPE_NON_COMMON (TYPENAME_TYPE);
 489   MARK_TS_TYPE_NON_COMMON (TYPEOF_TYPE);
 490   MARK_TS_TYPE_NON_COMMON (UNDERLYING_TYPE);
 491   MARK_TS_TYPE_NON_COMMON (BOUND_TEMPLATE_TEMPLATE_PARM);
 492   MARK_TS_TYPE_NON_COMMON (TEMPLATE_TEMPLATE_PARM);
 493   MARK_TS_TYPE_NON_COMMON (TEMPLATE_TYPE_PARM);
 494   MARK_TS_TYPE_NON_COMMON (TYPE_PACK_EXPANSION);
 495
 496   /* Statements.  */
 497   MARK_TS_EXP (CLEANUP_STMT);
 498   MARK_TS_EXP (EH_SPEC_BLOCK);
 499   MARK_TS_EXP (HANDLER);
 500   MARK_TS_EXP (IF_STMT);
 501   MARK_TS_EXP (OMP_DEPOBJ);
 502   MARK_TS_EXP (RANGE_FOR_STMT);
 503   MARK_TS_EXP (TRY_BLOCK);
 504   MARK_TS_EXP (USING_STMT);
 505
 506   /* Random expressions.  */
 507   MARK_TS_EXP (ADDRESSOF_EXPR);
 508   MARK_TS_EXP (AGGR_INIT_EXPR);
 509   MARK_TS_EXP (ALIGNOF_EXPR);
 510   MARK_TS_EXP (ARROW_EXPR);
 511   MARK_TS_EXP (AT_ENCODE_EXPR);
 512   MARK_TS_EXP (BIT_CAST_EXPR);
 513   MARK_TS_EXP (CAST_EXPR);
 514   MARK_TS_EXP (CONST_CAST_EXPR);
 515   MARK_TS_EXP (CTOR_INITIALIZER);
 516   MARK_TS_EXP (DELETE_EXPR);
 517   MARK_TS_EXP (DOTSTAR_EXPR);
 518   MARK_TS_EXP (DYNAMIC_CAST_EXPR);
 519   MARK_TS_EXP (EMPTY_CLASS_EXPR);
 520   MARK_TS_EXP (EXPR_STMT);
 521   MARK_TS_EXP (IMPLICIT_CONV_EXPR);
 522   MARK_TS_EXP (MEMBER_REF);
 523   MARK_TS_EXP (MODOP_EXPR);
 524   MARK_TS_EXP (MUST_NOT_THROW_EXPR);
 525   MARK_TS_EXP (NEW_EXPR);
 526   MARK_TS_EXP (NOEXCEPT_EXPR);
 527   MARK_TS_EXP (NON_DEPENDENT_EXPR);
 528   MARK_TS_EXP (OFFSETOF_EXPR);
 529   MARK_TS_EXP (OFFSET_REF);
 530   MARK_TS_EXP (PSEUDO_DTOR_EXPR);
 531   MARK_TS_EXP (REINTERPRET_CAST_EXPR);
 532   MARK_TS_EXP (SCOPE_REF);
 533   MARK_TS_EXP (STATIC_CAST_EXPR);
 534   MARK_TS_EXP (STMT_EXPR);
 535   MARK_TS_EXP (TAG_DEFN);
 536   MARK_TS_EXP (TEMPLATE_ID_EXPR);
 537   MARK_TS_EXP (THROW_EXPR);
 538   MARK_TS_EXP (TRAIT_EXPR);
 539   MARK_TS_EXP (TYPEID_EXPR);
 540   MARK_TS_EXP (TYPE_EXPR);
 541   MARK_TS_EXP (UNARY_PLUS_EXPR);
 542   MARK_TS_EXP (VEC_DELETE_EXPR);
 543   MARK_TS_EXP (VEC_INIT_EXPR);
 544   MARK_TS_EXP (VEC_NEW_EXPR);
 545   MARK_TS_EXP (SPACESHIP_EXPR);
 546
 547   /* Fold expressions.  */
 548   MARK_TS_EXP (BINARY_LEFT_FOLD_EXPR);
 549   MARK_TS_EXP (BINARY_RIGHT_FOLD_EXPR);
 550   MARK_TS_EXP (EXPR_PACK_EXPANSION);
 551   MARK_TS_EXP (NONTYPE_ARGUMENT_PACK);
 552   MARK_TS_EXP (UNARY_LEFT_FOLD_EXPR);
 553   MARK_TS_EXP (UNARY_RIGHT_FOLD_EXPR);
 554
 555   /* Constraints.  */
 556   MARK_TS_EXP (CHECK_CONSTR);
 557   MARK_TS_EXP (COMPOUND_REQ);
 558   MARK_TS_EXP (CONJ_CONSTR);
 559   MARK_TS_EXP (DISJ_CONSTR);
 560   MARK_TS_EXP (ATOMIC_CONSTR);
 561   MARK_TS_EXP (NESTED_REQ);
 562   MARK_TS_EXP (REQUIRES_EXPR);
 563   MARK_TS_EXP (SIMPLE_REQ);
 564   MARK_TS_EXP (TYPE_REQ);
 565
 566   MARK_TS_EXP (CO_AWAIT_EXPR);
 567   MARK_TS_EXP (CO_YIELD_EXPR);
 568   MARK_TS_EXP (CO_RETURN_EXPR);
 569
 570   c_common_init_ts ();
 571 }
 572
 573 /* Handle C++-specficic options here.  Punt to c_common otherwise.  */
 574
 575 bool
 576 cp_handle_option (size_t scode, const char *arg, HOST_WIDE_INT value,
 577                   int kind, location_t loc,
 578                   const struct cl_option_handlers *handlers)
 579 {
 580   if (handle_module_option (unsigned (scode), arg, value))
 581     return true;
 582   return c_common_handle_option (scode, arg, value, kind, loc, handlers);
 583 }
 584
 585 #include "gt-cp-cp-objcp-common.h"