LCOV - code coverage report
Current view: top level - gcc/cp - cp-objcp-common.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 97.2 % 290 282
Test Date: 2024-03-23 14:05:01 Functions: 95.8 % 24 23
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Some code common to C++ and ObjC++ front ends.
       2                 :             :    Copyright (C) 2004-2024 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 "c-family/c-common.h"
      27                 :             : #include "dwarf2.h"
      28                 :             : #include "stringpool.h"
      29                 :             : #include "contracts.h"
      30                 :             : 
      31                 :             : /* Class to determine whether a given C++ language feature is available.
      32                 :             :    Used to implement __has_{feature,extension}.  */
      33                 :             : 
      34                 :             : struct cp_feature_selector
      35                 :             : {
      36                 :             :   enum
      37                 :             :   {
      38                 :             :     DIALECT,
      39                 :             :     FLAG
      40                 :             :   } kind;
      41                 :             : 
      42                 :             :   enum class result
      43                 :             :   {
      44                 :             :     NONE,
      45                 :             :     EXT,
      46                 :             :     FEAT
      47                 :             :   };
      48                 :             : 
      49                 :             :   union
      50                 :             :   {
      51                 :             :     const int *enable_flag;
      52                 :             :     struct {
      53                 :             :       enum cxx_dialect feat;
      54                 :             :       enum cxx_dialect ext;
      55                 :             :     } dialect;
      56                 :             :   };
      57                 :             : 
      58                 :             :   constexpr cp_feature_selector (const int *flag)
      59                 :             :     : kind (FLAG), enable_flag (flag) {}
      60                 :             :   constexpr cp_feature_selector (enum cxx_dialect feat,
      61                 :             :                                  enum cxx_dialect ext)
      62                 :             :     : kind (DIALECT), dialect{feat, ext} {}
      63                 :             :   constexpr cp_feature_selector (enum cxx_dialect feat)
      64                 :             :     : cp_feature_selector (feat, feat) {}
      65                 :             : 
      66                 :             :   inline result has_feature () const;
      67                 :             : };
      68                 :             : 
      69                 :             : /* Check whether this language feature is available as a feature,
      70                 :             :    extension, or not at all.  */
      71                 :             : 
      72                 :             : cp_feature_selector::result
      73                 :      988560 : cp_feature_selector::has_feature () const
      74                 :             : {
      75                 :      988560 :   switch (kind)
      76                 :             :     {
      77                 :      926775 :     case DIALECT:
      78                 :      926775 :       if (cxx_dialect >= dialect.feat)
      79                 :             :         return result::FEAT;
      80                 :       54378 :       else if (cxx_dialect >= dialect.ext)
      81                 :             :         return result::EXT;
      82                 :             :       else
      83                 :       47672 :         return result::NONE;
      84                 :       61785 :     case FLAG:
      85                 :       61785 :       return *enable_flag ? result::FEAT : result::NONE;
      86                 :             :     }
      87                 :             : 
      88                 :           0 :   gcc_unreachable ();
      89                 :             : }
      90                 :             : 
      91                 :             : /* Information about a C++ language feature which can be queried
      92                 :             :    through __has_{feature,extension}.  IDENT is the name of the feature,
      93                 :             :    and SELECTOR encodes how to compute whether the feature is available.  */
      94                 :             : 
      95                 :             : struct cp_feature_info
      96                 :             : {
      97                 :             :   const char *ident;
      98                 :             :   cp_feature_selector selector;
      99                 :             : };
     100                 :             : 
     101                 :             : /* Table of features for __has_{feature,extension}.  */
     102                 :             : 
     103                 :             : static constexpr cp_feature_info cp_feature_table[] =
     104                 :             : {
     105                 :             :   { "cxx_exceptions", &flag_exceptions },
     106                 :             :   { "cxx_rtti", &flag_rtti },
     107                 :             :   { "cxx_access_control_sfinae", { cxx11, cxx98 } },
     108                 :             :   { "cxx_alias_templates", cxx11 },
     109                 :             :   { "cxx_alignas", cxx11 },
     110                 :             :   { "cxx_alignof", cxx11 },
     111                 :             :   { "cxx_attributes", cxx11 },
     112                 :             :   { "cxx_constexpr", cxx11 },
     113                 :             :   { "cxx_decltype", cxx11 },
     114                 :             :   { "cxx_decltype_incomplete_return_types", cxx11 },
     115                 :             :   { "cxx_default_function_template_args", cxx11 },
     116                 :             :   { "cxx_defaulted_functions", cxx11 },
     117                 :             :   { "cxx_delegating_constructors", cxx11 },
     118                 :             :   { "cxx_deleted_functions", cxx11 },
     119                 :             :   { "cxx_explicit_conversions", cxx11 },
     120                 :             :   { "cxx_generalized_initializers", cxx11 },
     121                 :             :   { "cxx_implicit_moves", cxx11 },
     122                 :             :   { "cxx_inheriting_constructors", cxx11 },
     123                 :             :   { "cxx_inline_namespaces", { cxx11, cxx98 } },
     124                 :             :   { "cxx_lambdas", cxx11 },
     125                 :             :   { "cxx_local_type_template_args", cxx11 },
     126                 :             :   { "cxx_noexcept", cxx11 },
     127                 :             :   { "cxx_nonstatic_member_init", cxx11 },
     128                 :             :   { "cxx_nullptr", cxx11 },
     129                 :             :   { "cxx_override_control", cxx11 },
     130                 :             :   { "cxx_reference_qualified_functions", cxx11 },
     131                 :             :   { "cxx_range_for", cxx11 },
     132                 :             :   { "cxx_raw_string_literals", cxx11 },
     133                 :             :   { "cxx_rvalue_references", cxx11 },
     134                 :             :   { "cxx_static_assert", cxx11 },
     135                 :             :   { "cxx_thread_local", cxx11 },
     136                 :             :   { "cxx_auto_type", cxx11 },
     137                 :             :   { "cxx_strong_enums", cxx11 },
     138                 :             :   { "cxx_trailing_return", cxx11 },
     139                 :             :   { "cxx_unicode_literals", cxx11 },
     140                 :             :   { "cxx_unrestricted_unions", cxx11 },
     141                 :             :   { "cxx_user_literals", cxx11 },
     142                 :             :   { "cxx_variadic_templates", { cxx11, cxx98 } },
     143                 :             :   { "cxx_binary_literals", { cxx14, cxx98 } },
     144                 :             :   { "cxx_contextual_conversions", { cxx14, cxx98 } },
     145                 :             :   { "cxx_decltype_auto", cxx14 },
     146                 :             :   { "cxx_aggregate_nsdmi", cxx14 },
     147                 :             :   { "cxx_init_captures", { cxx14, cxx11 } },
     148                 :             :   { "cxx_generic_lambdas", cxx14 },
     149                 :             :   { "cxx_relaxed_constexpr", cxx14 },
     150                 :             :   { "cxx_return_type_deduction", cxx14 },
     151                 :             :   { "cxx_variable_templates", cxx14 },
     152                 :             :   { "modules", &flag_modules },
     153                 :             : };
     154                 :             : 
     155                 :             : /* Register C++ language features for __has_{feature,extension}.  */
     156                 :             : 
     157                 :             : void
     158                 :       20595 : cp_register_features ()
     159                 :             : {
     160                 :       20595 :   using result = cp_feature_selector::result;
     161                 :             : 
     162                 :     1009155 :   for (unsigned i = 0; i < ARRAY_SIZE (cp_feature_table); i++)
     163                 :             :     {
     164                 :      988560 :       const cp_feature_info *info = cp_feature_table + i;
     165                 :      988560 :       const auto res = info->selector.has_feature ();
     166                 :      988560 :       if (res == result::NONE)
     167                 :       69565 :         continue;
     168                 :             : 
     169                 :      918995 :       c_common_register_feature (info->ident, res == result::FEAT);
     170                 :             :     }
     171                 :       20595 : }
     172                 :             : 
     173                 :             : /* Special routine to get the alias set for C++.  */
     174                 :             : 
     175                 :             : alias_set_type
     176                 :   301520980 : cxx_get_alias_set (tree t)
     177                 :             : {
     178                 :   301520980 :   if (IS_FAKE_BASE_TYPE (t))
     179                 :             :     /* The base variant of a type must be in the same alias set as the
     180                 :             :        complete type.  */
     181                 :      795096 :     return get_alias_set (TYPE_CONTEXT (t));
     182                 :             : 
     183                 :             :   /* Punt on PMFs until we canonicalize functions properly.  */
     184                 :      582719 :   if (TYPE_PTRMEMFUNC_P (t)
     185                 :   301127374 :       || (INDIRECT_TYPE_P (t)
     186                 :      388010 :           && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))))
     187                 :             :     return 0;
     188                 :             : 
     189                 :   300526847 :   return c_common_get_alias_set (t);
     190                 :             : }
     191                 :             : 
     192                 :             : /* Called from check_global_declaration.  */
     193                 :             : 
     194                 :             : bool
     195                 :        3033 : cxx_warn_unused_global_decl (const_tree decl)
     196                 :             : {
     197                 :        3033 :   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
     198                 :             :     return false;
     199                 :          92 :   if (DECL_IN_SYSTEM_HEADER (decl))
     200                 :             :     return false;
     201                 :             : 
     202                 :             :   return true;
     203                 :             : }
     204                 :             : 
     205                 :             : /* Langhook for tree_size: determine size of our 'x' and 'c' nodes.  */
     206                 :             : size_t
     207                 :  2004069612 : cp_tree_size (enum tree_code code)
     208                 :             : {
     209                 :  2004069612 :   gcc_checking_assert (code >= NUM_TREE_CODES);
     210                 :  2004069612 :   switch (code)
     211                 :             :     {
     212                 :             :     case PTRMEM_CST:            return sizeof (ptrmem_cst);
     213                 :             :     case BASELINK:              return sizeof (tree_baselink);
     214                 :             :     case TEMPLATE_PARM_INDEX:   return sizeof (template_parm_index);
     215                 :             :     case DEFERRED_PARSE:        return sizeof (tree_deferred_parse);
     216                 :             :     case DEFERRED_NOEXCEPT:     return sizeof (tree_deferred_noexcept);
     217                 :             :     case OVERLOAD:              return sizeof (tree_overload);
     218                 :             :     case STATIC_ASSERT:         return sizeof (tree_static_assert);
     219                 :             : #if 0
     220                 :             :       /* This would match cp_common_init_ts, but breaks GC because
     221                 :             :          tree_node_structure_for_code returns TS_TYPE_NON_COMMON for all
     222                 :             :          types.  */
     223                 :             :     case UNBOUND_CLASS_TEMPLATE:
     224                 :             :     case TYPE_ARGUMENT_PACK:    return sizeof (tree_type_common);
     225                 :             : #endif
     226                 :             :     case ARGUMENT_PACK_SELECT:  return sizeof (tree_argument_pack_select);
     227                 :             :     case TRAIT_EXPR:            return sizeof (tree_trait_expr);
     228                 :      671065 :     case LAMBDA_EXPR:           return sizeof (tree_lambda_expr);
     229                 :             :     case TEMPLATE_INFO:         return sizeof (tree_template_info);
     230                 :             :     case CONSTRAINT_INFO:       return sizeof (tree_constraint_info);
     231                 :             :     case USERDEF_LITERAL:       return sizeof (tree_userdef_literal);
     232                 :   185124820 :     case TEMPLATE_DECL:         return sizeof (tree_template_decl);
     233                 :             :     case ASSERTION_STMT:        return sizeof (tree_exp);
     234                 :             :     case PRECONDITION_STMT:     return sizeof (tree_exp);
     235                 :             :     case POSTCONDITION_STMT:    return sizeof (tree_exp);
     236                 :   601955474 :     default:
     237                 :   601955474 :       switch (TREE_CODE_CLASS (code))
     238                 :             :         {
     239                 :             :         case tcc_declaration:   return sizeof (tree_decl_non_common);
     240                 :   574268774 :         case tcc_type:          return sizeof (tree_type_non_common);
     241                 :           0 :         default: gcc_unreachable ();
     242                 :             :         }
     243                 :             :     }
     244                 :             :   /* NOTREACHED */
     245                 :             : }
     246                 :             : 
     247                 :             : /* Returns true if T is a variably modified type, in the sense of C99.
     248                 :             :    FN is as passed to variably_modified_p.
     249                 :             :    This routine needs only check cases that cannot be handled by the
     250                 :             :    language-independent logic in tree.cc.  */
     251                 :             : 
     252                 :             : bool
     253                 :  1374908578 : cp_var_mod_type_p (tree type, tree fn)
     254                 :             : {
     255                 :             :   /* If TYPE is a pointer-to-member, it is variably modified if either
     256                 :             :      the class or the member are variably modified.  */
     257                 :  1374908578 :   if (TYPE_PTRMEM_P (type))
     258                 :     1921819 :     return (variably_modified_type_p (TYPE_PTRMEM_CLASS_TYPE (type), fn)
     259                 :     1921819 :             || variably_modified_type_p (TYPE_PTRMEM_POINTED_TO_TYPE (type),
     260                 :             :                                          fn));
     261                 :             : 
     262                 :             :   /* All other types are not variably modified.  */
     263                 :             :   return false;
     264                 :             : }
     265                 :             : 
     266                 :             : /* This compares two types for equivalence ("compatible" in C-based languages).
     267                 :             :    This routine should only return 1 if it is sure.  It should not be used
     268                 :             :    in contexts where erroneously returning 0 causes problems.  */
     269                 :             : 
     270                 :             : int
     271                 :     1131202 : cxx_types_compatible_p (tree x, tree y)
     272                 :             : {
     273                 :     1131202 :   return same_type_ignoring_top_level_qualifiers_p (x, y);
     274                 :             : }
     275                 :             : 
     276                 :             : static GTY((cache)) type_tree_cache_map *debug_type_map;
     277                 :             : 
     278                 :             : /* Return a type to use in the debug info instead of TYPE, or NULL_TREE to
     279                 :             :    keep TYPE.  */
     280                 :             : 
     281                 :             : tree
     282                 :   950611365 : cp_get_debug_type (const_tree type)
     283                 :             : {
     284                 :   950611365 :   tree dtype = NULL_TREE;
     285                 :             : 
     286                 :   950611365 :   if (TYPE_PTRMEMFUNC_P (type) && !typedef_variant_p (type))
     287                 :      298485 :     dtype = build_offset_type (TYPE_PTRMEMFUNC_OBJECT_TYPE (type),
     288                 :      298485 :                                TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type)));
     289                 :             : 
     290                 :             :   /* We cannot simply return the debug type here because the function uses
     291                 :             :      the type canonicalization hashtable, which is GC-ed, so its behavior
     292                 :             :      depends on the actual collection points.  Since we are building these
     293                 :             :      types on the fly for the debug info only, they would not be attached
     294                 :             :      to any GC root and always be swept, so we would make the contents of
     295                 :             :      the debug info depend on the collection points.  */
     296                 :   950611365 :   if (dtype)
     297                 :             :     {
     298                 :      298485 :       tree ktype = CONST_CAST_TREE (type);
     299                 :      587575 :       if (tree *slot = hash_map_safe_get (debug_type_map, ktype))
     300                 :      268168 :         return *slot;
     301                 :       30317 :       hash_map_safe_put<hm_ggc> (debug_type_map, ktype, dtype);
     302                 :             :     }
     303                 :             : 
     304                 :             :   return dtype;
     305                 :             : }
     306                 :             : 
     307                 :             : /* Return -1 if dwarf ATTR shouldn't be added for DECL, or the attribute
     308                 :             :    value otherwise.  */
     309                 :             : int
     310                 :   435508092 : cp_decl_dwarf_attribute (const_tree decl, int attr)
     311                 :             : {
     312                 :   435508092 :   if (decl == NULL_TREE)
     313                 :             :     return -1;
     314                 :             : 
     315                 :   435508092 :   switch (attr)
     316                 :             :     {
     317                 :    73164557 :     case DW_AT_explicit:
     318                 :    73164557 :       if (TREE_CODE (decl) == FUNCTION_DECL
     319                 :    73164557 :           && DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl))
     320                 :   146329014 :           && DECL_NONCONVERTING_P (decl))
     321                 :     1885313 :         return 1;
     322                 :             :       break;
     323                 :             : 
     324                 :    73164533 :     case DW_AT_deleted:
     325                 :    73164533 :       if (TREE_CODE (decl) == FUNCTION_DECL
     326                 :    73164533 :           && DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl))
     327                 :   146328966 :           && DECL_DELETED_FN (decl))
     328                 :     2173101 :         return 1;
     329                 :             :       break;
     330                 :             : 
     331                 :    74285620 :     case DW_AT_defaulted:
     332                 :    74285620 :       if (TREE_CODE (decl) == FUNCTION_DECL
     333                 :    74285620 :           && DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl))
     334                 :   148571140 :           && DECL_DEFAULTED_FN (decl))
     335                 :             :         {
     336                 :     5301135 :           if (DECL_DEFAULTED_IN_CLASS_P (decl))
     337                 :             :             return DW_DEFAULTED_in_class;
     338                 :             : 
     339                 :      817835 :           if (DECL_DEFAULTED_OUTSIDE_CLASS_P (decl))
     340                 :         595 :             return DW_DEFAULTED_out_of_class;
     341                 :             :         }
     342                 :             :       break;
     343                 :             : 
     344                 :    26870014 :     case DW_AT_const_expr:
     345                 :    26870014 :       if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_DECLARED_CONSTEXPR_P (decl))
     346                 :    22514991 :         return 1;
     347                 :             :       break;
     348                 :             : 
     349                 :    73164533 :     case DW_AT_reference:
     350                 :    73164533 :       if (TREE_CODE (decl) == FUNCTION_DECL
     351                 :    73164533 :           && DECL_IOBJ_MEMBER_FUNCTION_P (decl)
     352                 :    62377062 :           && FUNCTION_REF_QUALIFIED (TREE_TYPE (decl))
     353                 :    73212639 :           && !FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl)))
     354                 :       20919 :         return 1;
     355                 :             :       break;
     356                 :             : 
     357                 :    73164533 :     case DW_AT_rvalue_reference:
     358                 :    73164533 :       if (TREE_CODE (decl) == FUNCTION_DECL
     359                 :    73164533 :           && DECL_IOBJ_MEMBER_FUNCTION_P (decl)
     360                 :    62377062 :           && FUNCTION_REF_QUALIFIED (TREE_TYPE (decl))
     361                 :    73212639 :           && FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl)))
     362                 :       27187 :         return 1;
     363                 :             :       break;
     364                 :             : 
     365                 :    41256505 :     case DW_AT_inline:
     366                 :    41256505 :       if (VAR_P (decl) && DECL_INLINE_VAR_P (decl))
     367                 :             :         {
     368                 :    35458351 :           if (DECL_VAR_DECLARED_INLINE_P (decl))
     369                 :             :             return DW_INL_declared_inlined;
     370                 :             :           else
     371                 :    27595798 :             return DW_INL_inlined;
     372                 :             :         }
     373                 :             :       break;
     374                 :             : 
     375                 :      437797 :     case DW_AT_export_symbols:
     376                 :      437797 :       if (TREE_CODE (decl) == NAMESPACE_DECL
     377                 :      437797 :           && (DECL_NAMESPACE_INLINE_P (decl)
     378                 :      241906 :               || (DECL_NAME (decl) == NULL_TREE && dwarf_version >= 5)))
     379                 :      197027 :         return 1;
     380                 :             :       break;
     381                 :             : 
     382                 :             :     default:
     383                 :             :       break;
     384                 :             :     }
     385                 :             : 
     386                 :             :   return -1;
     387                 :             : }
     388                 :             : 
     389                 :             : /* Return -1 if dwarf ATTR shouldn't be added for TYPE, or the attribute
     390                 :             :    value otherwise.  */
     391                 :             : int
     392                 :      689487 : cp_type_dwarf_attribute (const_tree type, int attr)
     393                 :             : {
     394                 :      689487 :   if (type == NULL_TREE)
     395                 :             :     return -1;
     396                 :             : 
     397                 :      689487 :   switch (attr)
     398                 :             :     {
     399                 :      286794 :     case DW_AT_reference:
     400                 :      286794 :       if (FUNC_OR_METHOD_TYPE_P (type)
     401                 :      286794 :           && FUNCTION_REF_QUALIFIED (type)
     402                 :      286902 :           && !FUNCTION_RVALUE_QUALIFIED (type))
     403                 :          77 :         return 1;
     404                 :             :       break;
     405                 :             : 
     406                 :      286794 :     case DW_AT_rvalue_reference:
     407                 :      286794 :       if (FUNC_OR_METHOD_TYPE_P (type)
     408                 :      286794 :           && FUNCTION_REF_QUALIFIED (type)
     409                 :      286902 :           && FUNCTION_RVALUE_QUALIFIED (type))
     410                 :          31 :         return 1;
     411                 :             :       break;
     412                 :             : 
     413                 :      115899 :     case DW_AT_export_symbols:
     414                 :      115899 :       if (ANON_AGGR_TYPE_P (type))
     415                 :      115899 :         return 1;
     416                 :             :       break;
     417                 :             : 
     418                 :             :     default:
     419                 :             :       break;
     420                 :             :     }
     421                 :             : 
     422                 :             :   return -1;
     423                 :             : }
     424                 :             : 
     425                 :             : /* Return the unit size of TYPE without reusable tail padding.  */
     426                 :             : 
     427                 :             : tree
     428                 :       22598 : cp_unit_size_without_reusable_padding (tree type)
     429                 :             : {
     430                 :       22598 :   if (CLASS_TYPE_P (type))
     431                 :       22598 :     return CLASSTYPE_SIZE_UNIT (type);
     432                 :           0 :   return TYPE_SIZE_UNIT (type);
     433                 :             : }
     434                 :             : 
     435                 :             : /* Returns type corresponding to FIELD's type when FIELD is a C++ base class
     436                 :             :    i.e., type without virtual base classes or tail padding.  Returns
     437                 :             :    NULL_TREE otherwise.  */
     438                 :             : 
     439                 :             : tree
     440                 :        2559 : cp_classtype_as_base (const_tree field)
     441                 :             : {
     442                 :        2559 :   if (DECL_FIELD_IS_BASE (field))
     443                 :             :     {
     444                 :         212 :       tree type = TREE_TYPE (field);
     445                 :         212 :       if (TYPE_LANG_SPECIFIC (type))
     446                 :         205 :         return CLASSTYPE_AS_BASE (type);
     447                 :             :     }
     448                 :             :   return NULL_TREE;
     449                 :             : }
     450                 :             : 
     451                 :             : /* Stubs to keep c-opts.cc happy.  */
     452                 :             : void
     453                 :       98242 : push_file_scope (void)
     454                 :             : {
     455                 :       98242 : }
     456                 :             : 
     457                 :             : void
     458                 :       98112 : pop_file_scope (void)
     459                 :             : {
     460                 :       98112 : }
     461                 :             : 
     462                 :             : /* c-pragma.cc needs to query whether a decl has extern "C" linkage.  */
     463                 :             : bool
     464                 :    43199871 : has_c_linkage (const_tree decl)
     465                 :             : {
     466                 :    43199871 :   return DECL_EXTERN_C_P (decl);
     467                 :             : }
     468                 :             : 
     469                 :             : /* Return true if stmt can fall through.  Used by block_may_fallthru
     470                 :             :    default case.  */
     471                 :             : 
     472                 :             : bool
     473                 :     3404240 : cxx_block_may_fallthru (const_tree stmt)
     474                 :             : {
     475                 :     3404240 :   switch (TREE_CODE (stmt))
     476                 :             :     {
     477                 :     1549242 :     case EXPR_STMT:
     478                 :     1549242 :       return block_may_fallthru (EXPR_STMT_EXPR (stmt));
     479                 :             : 
     480                 :             :     case THROW_EXPR:
     481                 :             :       return false;
     482                 :             : 
     483                 :      433968 :     case IF_STMT:
     484                 :      433968 :       if (IF_STMT_CONSTEXPR_P (stmt))
     485                 :             :         {
     486                 :        3276 :           if (integer_nonzerop (IF_COND (stmt)))
     487                 :          55 :             return block_may_fallthru (THEN_CLAUSE (stmt));
     488                 :        3221 :           if (integer_zerop (IF_COND (stmt)))
     489                 :         236 :             return block_may_fallthru (ELSE_CLAUSE (stmt));
     490                 :             :         }
     491                 :      433677 :       if (block_may_fallthru (THEN_CLAUSE (stmt)))
     492                 :             :         return true;
     493                 :        1209 :       return block_may_fallthru (ELSE_CLAUSE (stmt));
     494                 :             : 
     495                 :          12 :     case CLEANUP_STMT:
     496                 :             :       /* Just handle the try/finally cases.  */
     497                 :          12 :       if (!CLEANUP_EH_ONLY (stmt))
     498                 :             :         {
     499                 :          12 :           return (block_may_fallthru (CLEANUP_BODY (stmt))
     500                 :          20 :                   && block_may_fallthru (CLEANUP_EXPR (stmt)));
     501                 :             :         }
     502                 :             :       return true;
     503                 :             : 
     504                 :     1420994 :     default:
     505                 :     1420994 :       return c_block_may_fallthru (stmt);
     506                 :             :     }
     507                 :             : }
     508                 :             : 
     509                 :             : /* Return the list of decls in the global namespace.  */
     510                 :             : 
     511                 :             : tree
     512                 :           0 : cp_get_global_decls ()
     513                 :             : {
     514                 :           0 :   return NAMESPACE_LEVEL (global_namespace)->names;
     515                 :             : }
     516                 :             : 
     517                 :             : /* Push DECL into the current (namespace) scope.  */
     518                 :             : 
     519                 :             : tree
     520                 :     1985380 : cp_pushdecl (tree decl)
     521                 :             : {
     522                 :     1985380 :   DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
     523                 :     1985380 :   return pushdecl (decl);
     524                 :             : }
     525                 :             : 
     526                 :             : /* Get the global value binding of NAME.  Called directly from
     527                 :             :    c-common.cc, not via a hook. */
     528                 :             : 
     529                 :             : tree
     530                 :     3479963 : identifier_global_value (tree name)
     531                 :             : {
     532                 :     3479963 :   return get_global_binding (name);
     533                 :             : }
     534                 :             : 
     535                 :             : /* Similarly, but return struct/class/union NAME instead.  */
     536                 :             : 
     537                 :             : tree
     538                 :          12 : identifier_global_tag (tree name)
     539                 :             : {
     540                 :          12 :   tree ret = lookup_qualified_name (global_namespace, name, LOOK_want::TYPE,
     541                 :             :                                     /*complain*/false);
     542                 :          12 :   if (ret == error_mark_node)
     543                 :           4 :     return NULL_TREE;
     544                 :             :   return ret;
     545                 :             : }
     546                 :             : 
     547                 :             : /* Returns true if NAME refers to a built-in function or function-like
     548                 :             :    operator.  */
     549                 :             : 
     550                 :             : bool
     551                 :     4449419 : names_builtin_p (const char *name)
     552                 :             : {
     553                 :     4449419 :   tree id = get_identifier (name);
     554                 :     4449419 :   if (tree binding = get_global_binding (id))
     555                 :             :     {
     556                 :     1559123 :       if (TREE_CODE (binding) == FUNCTION_DECL
     557                 :     1559123 :           && DECL_IS_UNDECLARED_BUILTIN (binding))
     558                 :             :         return true;
     559                 :             : 
     560                 :             :       /* Handle the case when an overload for a  built-in name exists.  */
     561                 :          12 :       if (TREE_CODE (binding) != OVERLOAD)
     562                 :             :         return false;
     563                 :             : 
     564                 :          12 :       for (ovl_iterator it (binding); it; ++it)
     565                 :             :         {
     566                 :          12 :           tree decl = *it;
     567                 :          12 :           if (DECL_IS_UNDECLARED_BUILTIN (decl))
     568                 :          12 :             return true;
     569                 :             :         }
     570                 :             :     }
     571                 :             : 
     572                 :             :   /* Check for built-in traits.  */
     573                 :     2890296 :   if (IDENTIFIER_TRAIT_P (id))
     574                 :             :     return true;
     575                 :             : 
     576                 :             :   /* Also detect common reserved C++ words that aren't strictly built-in
     577                 :             :      functions.  */
     578                 :      536879 :   switch (C_RID_CODE (id))
     579                 :             :     {
     580                 :             :     case RID_ADDRESSOF:
     581                 :             :     case RID_BUILTIN_CONVERTVECTOR:
     582                 :             :     case RID_BUILTIN_HAS_ATTRIBUTE:
     583                 :             :     case RID_BUILTIN_SHUFFLE:
     584                 :             :     case RID_BUILTIN_SHUFFLEVECTOR:
     585                 :             :     case RID_BUILTIN_LAUNDER:
     586                 :             :     case RID_BUILTIN_ASSOC_BARRIER:
     587                 :             :     case RID_BUILTIN_BIT_CAST:
     588                 :             :     case RID_OFFSETOF:
     589                 :             :       return true;
     590                 :             :     default:
     591                 :             :       break;
     592                 :             :     }
     593                 :             : 
     594                 :             :   return false;
     595                 :             : }
     596                 :             : 
     597                 :             : /* Register c++-specific dumps.  */
     598                 :             : 
     599                 :             : void
     600                 :       99519 : cp_register_dumps (gcc::dump_manager *dumps)
     601                 :             : {
     602                 :      199038 :   class_dump_id = dumps->dump_register
     603                 :       99519 :     (".class", "lang-class", "lang-class", DK_lang, OPTGROUP_NONE, false);
     604                 :             : 
     605                 :      199038 :   module_dump_id = dumps->dump_register
     606                 :       99519 :     (".module", "lang-module", "lang-module", DK_lang, OPTGROUP_NONE, false);
     607                 :             : 
     608                 :      199038 :   raw_dump_id = dumps->dump_register
     609                 :       99519 :     (".raw", "lang-raw", "lang-raw", DK_lang, OPTGROUP_NONE, false);
     610                 :       99519 : }
     611                 :             : 
     612                 :             : void
     613                 :       99519 : cp_common_init_ts (void)
     614                 :             : {
     615                 :             :   /* With type.  */
     616                 :       99519 :   MARK_TS_TYPED (PTRMEM_CST);
     617                 :       99519 :   MARK_TS_TYPED (LAMBDA_EXPR);
     618                 :       99519 :   MARK_TS_TYPED (TYPE_ARGUMENT_PACK);
     619                 :             : 
     620                 :             :   /* Random new trees.  */
     621                 :       99519 :   MARK_TS_COMMON (BASELINK);
     622                 :       99519 :   MARK_TS_COMMON (OVERLOAD);
     623                 :       99519 :   MARK_TS_COMMON (TEMPLATE_PARM_INDEX);
     624                 :             : 
     625                 :             :   /* New decls.  */
     626                 :       99519 :   MARK_TS_DECL_COMMON (TEMPLATE_DECL);
     627                 :       99519 :   MARK_TS_DECL_COMMON (WILDCARD_DECL);
     628                 :             : 
     629                 :       99519 :   MARK_TS_DECL_NON_COMMON (USING_DECL);
     630                 :             : 
     631                 :             :   /* New Types.  */
     632                 :       99519 :   MARK_TS_TYPE_COMMON (UNBOUND_CLASS_TEMPLATE);
     633                 :       99519 :   MARK_TS_TYPE_COMMON (TYPE_ARGUMENT_PACK);
     634                 :       99519 :   MARK_TS_TYPE_COMMON (DEPENDENT_OPERATOR_TYPE);
     635                 :             : 
     636                 :       99519 :   MARK_TS_TYPE_NON_COMMON (DECLTYPE_TYPE);
     637                 :       99519 :   MARK_TS_TYPE_NON_COMMON (TYPENAME_TYPE);
     638                 :       99519 :   MARK_TS_TYPE_NON_COMMON (TYPEOF_TYPE);
     639                 :       99519 :   MARK_TS_TYPE_NON_COMMON (TRAIT_TYPE);
     640                 :       99519 :   MARK_TS_TYPE_NON_COMMON (BOUND_TEMPLATE_TEMPLATE_PARM);
     641                 :       99519 :   MARK_TS_TYPE_NON_COMMON (TEMPLATE_TEMPLATE_PARM);
     642                 :       99519 :   MARK_TS_TYPE_NON_COMMON (TEMPLATE_TYPE_PARM);
     643                 :       99519 :   MARK_TS_TYPE_NON_COMMON (TYPE_PACK_EXPANSION);
     644                 :             : 
     645                 :             :   /* Statements.  */
     646                 :       99519 :   MARK_TS_EXP (CLEANUP_STMT);
     647                 :       99519 :   MARK_TS_EXP (EH_SPEC_BLOCK);
     648                 :       99519 :   MARK_TS_EXP (HANDLER);
     649                 :       99519 :   MARK_TS_EXP (IF_STMT);
     650                 :       99519 :   MARK_TS_EXP (OMP_DEPOBJ);
     651                 :       99519 :   MARK_TS_EXP (RANGE_FOR_STMT);
     652                 :       99519 :   MARK_TS_EXP (TRY_BLOCK);
     653                 :       99519 :   MARK_TS_EXP (USING_STMT);
     654                 :             : 
     655                 :             :   /* Random expressions.  */
     656                 :       99519 :   MARK_TS_EXP (ADDRESSOF_EXPR);
     657                 :       99519 :   MARK_TS_EXP (AGGR_INIT_EXPR);
     658                 :       99519 :   MARK_TS_EXP (ALIGNOF_EXPR);
     659                 :       99519 :   MARK_TS_EXP (ARROW_EXPR);
     660                 :       99519 :   MARK_TS_EXP (AT_ENCODE_EXPR);
     661                 :       99519 :   MARK_TS_EXP (BIT_CAST_EXPR);
     662                 :       99519 :   MARK_TS_EXP (CAST_EXPR);
     663                 :       99519 :   MARK_TS_EXP (CONST_CAST_EXPR);
     664                 :       99519 :   MARK_TS_EXP (CTOR_INITIALIZER);
     665                 :       99519 :   MARK_TS_EXP (DELETE_EXPR);
     666                 :       99519 :   MARK_TS_EXP (DOTSTAR_EXPR);
     667                 :       99519 :   MARK_TS_EXP (DYNAMIC_CAST_EXPR);
     668                 :       99519 :   MARK_TS_EXP (EMPTY_CLASS_EXPR);
     669                 :       99519 :   MARK_TS_EXP (EXPR_STMT);
     670                 :       99519 :   MARK_TS_EXP (IMPLICIT_CONV_EXPR);
     671                 :       99519 :   MARK_TS_EXP (MEMBER_REF);
     672                 :       99519 :   MARK_TS_EXP (MODOP_EXPR);
     673                 :       99519 :   MARK_TS_EXP (MUST_NOT_THROW_EXPR);
     674                 :       99519 :   MARK_TS_EXP (NEW_EXPR);
     675                 :       99519 :   MARK_TS_EXP (NOEXCEPT_EXPR);
     676                 :       99519 :   MARK_TS_EXP (OFFSETOF_EXPR);
     677                 :       99519 :   MARK_TS_EXP (OFFSET_REF);
     678                 :       99519 :   MARK_TS_EXP (PSEUDO_DTOR_EXPR);
     679                 :       99519 :   MARK_TS_EXP (REINTERPRET_CAST_EXPR);
     680                 :       99519 :   MARK_TS_EXP (SCOPE_REF);
     681                 :       99519 :   MARK_TS_EXP (STATIC_CAST_EXPR);
     682                 :       99519 :   MARK_TS_EXP (STMT_EXPR);
     683                 :       99519 :   MARK_TS_EXP (TAG_DEFN);
     684                 :       99519 :   MARK_TS_EXP (TEMPLATE_ID_EXPR);
     685                 :       99519 :   MARK_TS_EXP (THROW_EXPR);
     686                 :       99519 :   MARK_TS_EXP (TRAIT_EXPR);
     687                 :       99519 :   MARK_TS_EXP (TYPEID_EXPR);
     688                 :       99519 :   MARK_TS_EXP (TYPE_EXPR);
     689                 :       99519 :   MARK_TS_EXP (UNARY_PLUS_EXPR);
     690                 :       99519 :   MARK_TS_EXP (VEC_DELETE_EXPR);
     691                 :       99519 :   MARK_TS_EXP (VEC_INIT_EXPR);
     692                 :       99519 :   MARK_TS_EXP (VEC_NEW_EXPR);
     693                 :       99519 :   MARK_TS_EXP (SPACESHIP_EXPR);
     694                 :             : 
     695                 :             :   /* Fold expressions.  */
     696                 :       99519 :   MARK_TS_EXP (BINARY_LEFT_FOLD_EXPR);
     697                 :       99519 :   MARK_TS_EXP (BINARY_RIGHT_FOLD_EXPR);
     698                 :       99519 :   MARK_TS_EXP (EXPR_PACK_EXPANSION);
     699                 :       99519 :   MARK_TS_EXP (NONTYPE_ARGUMENT_PACK);
     700                 :       99519 :   MARK_TS_EXP (UNARY_LEFT_FOLD_EXPR);
     701                 :       99519 :   MARK_TS_EXP (UNARY_RIGHT_FOLD_EXPR);
     702                 :             : 
     703                 :             :   /* Constraints.  */
     704                 :       99519 :   MARK_TS_EXP (CHECK_CONSTR);
     705                 :       99519 :   MARK_TS_EXP (COMPOUND_REQ);
     706                 :       99519 :   MARK_TS_EXP (CONJ_CONSTR);
     707                 :       99519 :   MARK_TS_EXP (DISJ_CONSTR);
     708                 :       99519 :   MARK_TS_EXP (ATOMIC_CONSTR);
     709                 :       99519 :   MARK_TS_EXP (NESTED_REQ);
     710                 :       99519 :   MARK_TS_EXP (REQUIRES_EXPR);
     711                 :       99519 :   MARK_TS_EXP (SIMPLE_REQ);
     712                 :       99519 :   MARK_TS_EXP (TYPE_REQ);
     713                 :             : 
     714                 :       99519 :   MARK_TS_EXP (CO_AWAIT_EXPR);
     715                 :       99519 :   MARK_TS_EXP (CO_YIELD_EXPR);
     716                 :       99519 :   MARK_TS_EXP (CO_RETURN_EXPR);
     717                 :             : 
     718                 :       99519 :   MARK_TS_EXP (ASSERTION_STMT);
     719                 :       99519 :   MARK_TS_EXP (PRECONDITION_STMT);
     720                 :       99519 :   MARK_TS_EXP (POSTCONDITION_STMT);
     721                 :             : 
     722                 :       99519 :   c_common_init_ts ();
     723                 :       99519 : }
     724                 :             : 
     725                 :             : /* Handle C++-specficic options here.  Punt to c_common otherwise.  */
     726                 :             : 
     727                 :             : bool
     728                 :     1924563 : cp_handle_option (size_t scode, const char *arg, HOST_WIDE_INT value,
     729                 :             :                   int kind, location_t loc,
     730                 :             :                   const struct cl_option_handlers *handlers)
     731                 :             : {
     732                 :     1924563 :   if (handle_module_option (unsigned (scode), arg, value))
     733                 :             :     return true;
     734                 :             : 
     735                 :     1923814 :   enum opt_code code = (enum opt_code) scode;
     736                 :     1923814 :   bool handled_p = true;
     737                 :             : 
     738                 :     1923814 :   switch (code)
     739                 :             :     {
     740                 :           4 :     case OPT_fcontract_build_level_:
     741                 :           4 :       handle_OPT_fcontract_build_level_ (arg);
     742                 :           4 :       break;
     743                 :             : 
     744                 :           0 :     case OPT_fcontract_assumption_mode_:
     745                 :           0 :       handle_OPT_fcontract_assumption_mode_ (arg);
     746                 :           0 :       break;
     747                 :             : 
     748                 :          43 :     case OPT_fcontract_continuation_mode_:
     749                 :          43 :       handle_OPT_fcontract_continuation_mode_ (arg);
     750                 :          43 :       break;
     751                 :             : 
     752                 :          25 :     case OPT_fcontract_role_:
     753                 :          25 :       handle_OPT_fcontract_role_ (arg);
     754                 :          25 :       break;
     755                 :             : 
     756                 :           3 :     case OPT_fcontract_semantic_:
     757                 :           3 :       handle_OPT_fcontract_semantic_ (arg);
     758                 :           3 :       break;
     759                 :             : 
     760                 :             :     default:
     761                 :             :       handled_p = false;
     762                 :             :       break;
     763                 :             :     }
     764                 :          75 :   if (handled_p)
     765                 :          75 :     return handled_p;
     766                 :             : 
     767                 :     1923739 :   return c_common_handle_option (scode, arg, value, kind, loc, handlers);
     768                 :             : }
     769                 :             : 
     770                 :             : #include "gt-cp-cp-objcp-common.h"
        

Generated by: LCOV version 2.0-1

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.