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