LCOV - code coverage report
Current view: top level - gcc/c - c-objc-common.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 167 173 96.5 %
Date: 2020-03-28 11:57:23 Functions: 12 12 100.0 %
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) 2001-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it under
       7                 :            : the terms of the GNU General Public License as published by the Free
       8                 :            : Software Foundation; either version 3, or (at your option) any later
       9                 :            : version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "coretypes.h"
      23                 :            : #include "c-tree.h"
      24                 :            : #include "intl.h"
      25                 :            : #include "c-family/c-pretty-print.h"
      26                 :            : #include "tree-pretty-print.h"
      27                 :            : #include "gimple-pretty-print.h"
      28                 :            : #include "langhooks.h"
      29                 :            : #include "c-objc-common.h"
      30                 :            : #include "gcc-rich-location.h"
      31                 :            : #include "stringpool.h"
      32                 :            : #include "attribs.h"
      33                 :            : 
      34                 :            : static bool c_tree_printer (pretty_printer *, text_info *, const char *,
      35                 :            :                             int, bool, bool, bool, bool *, const char **);
      36                 :            : 
      37                 :            : bool
      38                 :      10977 : c_missing_noreturn_ok_p (tree decl)
      39                 :            : {
      40                 :            :   /* A missing noreturn is not ok for freestanding implementations and
      41                 :            :      ok for the `main' function in hosted implementations.  */
      42                 :      10977 :   return flag_hosted && MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
      43                 :            : }
      44                 :            : 
      45                 :            : /* Called from check_global_declaration.  */
      46                 :            : 
      47                 :            : bool
      48                 :      12230 : c_warn_unused_global_decl (const_tree decl)
      49                 :            : {
      50                 :      12230 :   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
      51                 :            :     return false;
      52                 :         15 :   if (DECL_IN_SYSTEM_HEADER (decl))
      53                 :          0 :     return false;
      54                 :            : 
      55                 :            :   return true;
      56                 :            : }
      57                 :            : 
      58                 :            : /* Initialization common to C and Objective-C front ends.  */
      59                 :            : bool
      60                 :      78603 : c_objc_common_init (void)
      61                 :            : {
      62                 :      78603 :   c_init_decl_processing ();
      63                 :            : 
      64                 :      78603 :   return c_common_init ();
      65                 :            : }
      66                 :            : 
      67                 :            : /* Decide whether it's worth saying that TYPE is also known as some other
      68                 :            :    type.  Return the other type if so, otherwise return TYPE.  */
      69                 :            : 
      70                 :            : static tree
      71                 :      24111 : get_aka_type (tree type)
      72                 :            : {
      73                 :      24111 :   if (type == error_mark_node)
      74                 :            :     return type;
      75                 :            : 
      76                 :      24111 :   tree result;
      77                 :      24111 :   if (typedef_variant_p (type))
      78                 :            :     {
      79                 :            :       /* Saying that "foo" is also known as "struct foo" or
      80                 :            :          "struct <anonymous>" is unlikely to be useful, since users of
      81                 :            :          structure-like types would already know that they're structures.
      82                 :            :          The same applies to unions and enums; in general, printing the
      83                 :            :          tag is only useful if it has a different name.  */
      84                 :       1633 :       tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
      85                 :       1633 :       tree_code code = TREE_CODE (orig_type);
      86                 :       1633 :       tree orig_id = TYPE_IDENTIFIER (orig_type);
      87                 :       1633 :       if ((code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
      88                 :       1633 :           && (!orig_id || TYPE_IDENTIFIER (type) == orig_id))
      89                 :            :         return type;
      90                 :            : 
      91                 :       1311 :       if (!user_facing_original_type_p (type))
      92                 :            :         return type;
      93                 :            : 
      94                 :       1257 :       result = get_aka_type (orig_type);
      95                 :            :     }
      96                 :            :   else
      97                 :            :     {
      98                 :      22478 :       tree canonical = TYPE_CANONICAL (type);
      99                 :      22478 :       if (canonical && TREE_CODE (type) != TREE_CODE (canonical))
     100                 :            :         return canonical;
     101                 :            : 
     102                 :            :       /* Recursive calls might choose a middle ground between TYPE
     103                 :            :          (which has no typedefs stripped) and CANONICAL (which has
     104                 :            :          all typedefs stripped).  So try to reuse TYPE or CANONICAL if
     105                 :            :          convenient, but be prepared to create a new type if necessary.  */
     106                 :      22478 :       switch (TREE_CODE (type))
     107                 :            :         {
     108                 :       5512 :         case POINTER_TYPE:
     109                 :       5512 :         case REFERENCE_TYPE:
     110                 :       5512 :           {
     111                 :       5512 :             tree target_type = get_aka_type (TREE_TYPE (type));
     112                 :            : 
     113                 :       5512 :             if (target_type == TREE_TYPE (type))
     114                 :            :               return type;
     115                 :            : 
     116                 :       1236 :             if (canonical && target_type == TREE_TYPE (canonical))
     117                 :            :               return canonical;
     118                 :            : 
     119                 :        119 :             result = (TREE_CODE (type) == POINTER_TYPE
     120                 :        119 :                       ? build_pointer_type (target_type)
     121                 :          0 :                       : build_reference_type (target_type));
     122                 :            :             break;
     123                 :            :           }
     124                 :            : 
     125                 :       1150 :         case ARRAY_TYPE:
     126                 :       1150 :           {
     127                 :       1150 :             tree element_type = get_aka_type (TREE_TYPE (type));
     128                 :       1150 :             tree index_type = (TYPE_DOMAIN (type)
     129                 :       1150 :                                ? get_aka_type (TYPE_DOMAIN (type))
     130                 :       1150 :                                : NULL_TREE);
     131                 :            : 
     132                 :       1150 :             if (element_type == TREE_TYPE (type)
     133                 :       2260 :                 && index_type == TYPE_DOMAIN (type))
     134                 :            :               return type;
     135                 :            : 
     136                 :         40 :             if (canonical
     137                 :         30 :                 && element_type == TREE_TYPE (canonical)
     138                 :         69 :                 && index_type == TYPE_DOMAIN (canonical))
     139                 :            :               return canonical;
     140                 :            : 
     141                 :         22 :             result = build_array_type (element_type, index_type,
     142                 :         11 :                                        TYPE_TYPELESS_STORAGE (type));
     143                 :         11 :             break;
     144                 :            :           }
     145                 :            : 
     146                 :       1593 :         case FUNCTION_TYPE:
     147                 :       1593 :           {
     148                 :       1593 :             tree return_type = get_aka_type (TREE_TYPE (type));
     149                 :            : 
     150                 :       1593 :             tree args = TYPE_ARG_TYPES (type);
     151                 :       1593 :             if (args == error_mark_node)
     152                 :       1259 :               return type;
     153                 :            : 
     154                 :       1593 :             auto_vec<tree, 32> arg_types;
     155                 :       1593 :             bool type_ok_p = true;
     156                 :       3441 :             while (args && args != void_list_node)
     157                 :            :               {
     158                 :       1848 :                 tree arg_type = get_aka_type (TREE_VALUE (args));
     159                 :       1848 :                 arg_types.safe_push (arg_type);
     160                 :       1848 :                 type_ok_p &= (arg_type == TREE_VALUE (args));
     161                 :       1848 :                 args = TREE_CHAIN (args);
     162                 :            :               }
     163                 :            : 
     164                 :       2924 :             if (type_ok_p && return_type == TREE_TYPE (type))
     165                 :       2518 :               return type;
     166                 :            : 
     167                 :        334 :             unsigned int i;
     168                 :        334 :             tree arg_type;
     169                 :       1258 :             FOR_EACH_VEC_ELT_REVERSE (arg_types, i, arg_type)
     170                 :        590 :               args = tree_cons (NULL_TREE, arg_type, args);
     171                 :        334 :             result = build_function_type (return_type, args);
     172                 :        668 :             break;
     173                 :            :           }
     174                 :            : 
     175                 :      14223 :         default:
     176                 :      14249 :           return canonical ? canonical : type;
     177                 :            :         }
     178                 :            :     }
     179                 :       1721 :   return build_type_attribute_qual_variant (result, TYPE_ATTRIBUTES (type),
     180                 :       1721 :                                             TYPE_QUALS (type));
     181                 :            : }
     182                 :            : 
     183                 :            : /* Print T to CPP.  */
     184                 :            : 
     185                 :            : static void
     186                 :      11783 : print_type (c_pretty_printer *cpp, tree t, bool *quoted)
     187                 :            : {
     188                 :      11783 :   gcc_assert (TYPE_P (t));
     189                 :      11783 :   struct obstack *ob = pp_buffer (cpp)->obstack;
     190                 :      11783 :   char *p = (char *) obstack_base (ob);
     191                 :            :   /* Remember the end of the initial dump.  */
     192                 :      11783 :   int len = obstack_object_size (ob);
     193                 :            : 
     194                 :      11783 :   tree name = TYPE_NAME (t);
     195                 :      17531 :   if (name && TREE_CODE (name) == TYPE_DECL && DECL_NAME (name))
     196                 :       5747 :     pp_identifier (cpp, lang_hooks.decl_printable_name (name, 2));
     197                 :            :   else
     198                 :       6036 :     cpp->type_id (t);
     199                 :            : 
     200                 :            :   /* If we're printing a type that involves typedefs, also print the
     201                 :            :      stripped version.  But sometimes the stripped version looks
     202                 :            :      exactly the same, so we don't want it after all.  To avoid
     203                 :            :      printing it in that case, we play ugly obstack games.  */
     204                 :      11783 :   tree aka_type = get_aka_type (t);
     205                 :      11783 :   if (aka_type != t)
     206                 :            :     {
     207                 :       2024 :       c_pretty_printer cpp2;
     208                 :            :       /* Print the stripped version into a temporary printer.  */
     209                 :       1041 :       cpp2.type_id (aka_type);
     210                 :       1041 :       struct obstack *ob2 = cpp2.buffer->obstack;
     211                 :            :       /* Get the stripped version from the temporary printer.  */
     212                 :       1041 :       const char *aka = (char *) obstack_base (ob2);
     213                 :       1041 :       int aka_len = obstack_object_size (ob2);
     214                 :       1041 :       int type1_len = obstack_object_size (ob) - len;
     215                 :            : 
     216                 :            :       /* If they are identical, bail out.  */
     217                 :       1041 :       if (aka_len == type1_len && memcmp (p + len, aka, aka_len) == 0)
     218                 :         58 :         return;
     219                 :            : 
     220                 :            :       /* They're not, print the stripped version now.  */
     221                 :        983 :       if (*quoted)
     222                 :        980 :         pp_end_quote (cpp, pp_show_color (cpp));
     223                 :        983 :       pp_c_whitespace (cpp);
     224                 :        983 :       pp_left_brace (cpp);
     225                 :        983 :       pp_c_ws_string (cpp, _("aka"));
     226                 :        983 :       pp_c_whitespace (cpp);
     227                 :        983 :       if (*quoted)
     228                 :        980 :         pp_begin_quote (cpp, pp_show_color (cpp));
     229                 :        983 :       cpp->type_id (aka_type);
     230                 :        983 :       if (*quoted)
     231                 :        980 :         pp_end_quote (cpp, pp_show_color (cpp));
     232                 :        983 :       pp_right_brace (cpp);
     233                 :            :       /* No further closing quotes are needed.  */
     234                 :        983 :       *quoted = false;
     235                 :            :     }
     236                 :            : }
     237                 :            : 
     238                 :            : /* Called during diagnostic message formatting process to print a
     239                 :            :    source-level entity onto BUFFER.  The meaning of the format specifiers
     240                 :            :    is as follows:
     241                 :            :    %D: a general decl,
     242                 :            :    %E: an identifier or expression,
     243                 :            :    %F: a function declaration,
     244                 :            :    %G: a Gimple statement,
     245                 :            :    %K: a CALL_EXPR,
     246                 :            :    %T: a type.
     247                 :            :    %V: a list of type qualifiers from a tree.
     248                 :            :    %v: an explicit list of type qualifiers
     249                 :            :    %#v: an explicit list of type qualifiers of a function type.
     250                 :            : 
     251                 :            :    Please notice when called, the `%' part was already skipped by the
     252                 :            :    diagnostic machinery.  */
     253                 :            : static bool
     254                 :      38992 : c_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
     255                 :            :                 int precision, bool wide, bool set_locus, bool hash,
     256                 :            :                 bool *quoted, const char **)
     257                 :            : {
     258                 :      38992 :   tree t = NULL_TREE;
     259                 :            :   // FIXME: the next cast should be a dynamic_cast, when it is permitted.
     260                 :      38992 :   c_pretty_printer *cpp = (c_pretty_printer *) pp;
     261                 :      38992 :   pp->padding = pp_none;
     262                 :            : 
     263                 :      38992 :   if (precision != 0 || wide)
     264                 :            :     return false;
     265                 :            : 
     266                 :      38992 :   if (*spec == 'G')
     267                 :            :     {
     268                 :       1197 :       percent_G_format (text);
     269                 :       1197 :       return true;
     270                 :            :     }
     271                 :            : 
     272                 :      37795 :   if (*spec == 'K')
     273                 :            :     {
     274                 :        775 :       t = va_arg (*text->args_ptr, tree);
     275                 :        775 :       percent_K_format (text, EXPR_LOCATION (t), TREE_BLOCK (t));
     276                 :        775 :       return true;
     277                 :            :     }
     278                 :            : 
     279                 :      37020 :   if (*spec != 'v')
     280                 :            :     {
     281                 :      36897 :       t = va_arg (*text->args_ptr, tree);
     282                 :      36897 :       if (set_locus)
     283                 :       1058 :         text->set_location (0, DECL_SOURCE_LOCATION (t),
     284                 :            :                             SHOW_RANGE_WITH_CARET);
     285                 :            :     }
     286                 :            : 
     287                 :      37020 :   switch (*spec)
     288                 :            :     {
     289                 :      10053 :     case 'D':
     290                 :      10053 :       if (VAR_P (t) && DECL_HAS_DEBUG_EXPR_P (t))
     291                 :            :         {
     292                 :         18 :           t = DECL_DEBUG_EXPR (t);
     293                 :         18 :           if (!DECL_P (t))
     294                 :            :             {
     295                 :         18 :               cpp->expression (t);
     296                 :         18 :               return true;
     297                 :            :             }
     298                 :            :         }
     299                 :            :       /* FALLTHRU */
     300                 :            : 
     301                 :      10078 :     case 'F':
     302                 :      10078 :       if (DECL_NAME (t))
     303                 :            :         {
     304                 :       9537 :           pp_identifier (cpp, lang_hooks.decl_printable_name (t, 2));
     305                 :       9537 :           return true;
     306                 :            :         }
     307                 :        541 :       break;
     308                 :            : 
     309                 :      11484 :     case 'T':
     310                 :      11484 :       print_type (cpp, t, quoted);
     311                 :      11484 :       return true;
     312                 :            : 
     313                 :      15317 :     case 'E':
     314                 :      15317 :       if (TREE_CODE (t) == IDENTIFIER_NODE)
     315                 :       3984 :         pp_identifier (cpp, IDENTIFIER_POINTER (t));
     316                 :            :       else
     317                 :      11333 :         cpp->expression (t);
     318                 :            :       return true;
     319                 :            : 
     320                 :          0 :     case 'V':
     321                 :          0 :       pp_c_type_qualifier_list (cpp, t);
     322                 :          0 :       return true;
     323                 :            : 
     324                 :        123 :     case 'v':
     325                 :        123 :       pp_c_cv_qualifiers (cpp, va_arg (*text->args_ptr, int), hash);
     326                 :        123 :       return true;
     327                 :            : 
     328                 :            :     default:
     329                 :            :       return false;
     330                 :            :     }
     331                 :            : 
     332                 :        541 :   pp_string (cpp, _("({anonymous})"));
     333                 :        541 :   return true;
     334                 :            : }
     335                 :            : 
     336                 :            : /* C-specific implementation of range_label::get_text () vfunc for
     337                 :            :    range_label_for_type_mismatch.  */
     338                 :            : 
     339                 :            : label_text
     340                 :        299 : range_label_for_type_mismatch::get_text (unsigned /*range_idx*/) const
     341                 :            : {
     342                 :        299 :   if (m_labelled_type == NULL_TREE)
     343                 :          0 :     return label_text::borrow (NULL);
     344                 :            : 
     345                 :        299 :   c_pretty_printer cpp;
     346                 :        299 :   bool quoted = false;
     347                 :        299 :   print_type (&cpp, m_labelled_type, &quoted);
     348                 :        299 :   return label_text::take (xstrdup (pp_formatted_text (&cpp)));
     349                 :            : }
     350                 :            : 
     351                 :            : 
     352                 :            : /* In C and ObjC, all decls have "C" linkage.  */
     353                 :            : bool
     354                 :   11256300 : has_c_linkage (const_tree decl ATTRIBUTE_UNUSED)
     355                 :            : {
     356                 :   11256300 :   return true;
     357                 :            : }
     358                 :            : 
     359                 :            : void
     360                 :      78765 : c_initialize_diagnostics (diagnostic_context *context)
     361                 :            : {
     362                 :      78765 :   pretty_printer *base = context->printer;
     363                 :      78765 :   c_pretty_printer *pp = XNEW (c_pretty_printer);
     364                 :      78765 :   context->printer = new (pp) c_pretty_printer ();
     365                 :            : 
     366                 :            :   /* It is safe to free this object because it was previously XNEW()'d.  */
     367                 :      78765 :   base->~pretty_printer ();
     368                 :      78765 :   XDELETE (base);
     369                 :            : 
     370                 :      78765 :   c_common_diagnostics_set_defaults (context);
     371                 :      78765 :   diagnostic_format_decoder (context) = &c_tree_printer;
     372                 :      78765 : }
     373                 :            : 
     374                 :            : int
     375                 :    2677840 : c_types_compatible_p (tree x, tree y)
     376                 :            : {
     377                 :    2677840 :   return comptypes (TYPE_MAIN_VARIANT (x), TYPE_MAIN_VARIANT (y));
     378                 :            : }
     379                 :            : 
     380                 :            : /* Determine if the type is a vla type for the backend.  */
     381                 :            : 
     382                 :            : bool
     383                 :  901669000 : c_vla_unspec_p (tree x, tree fn ATTRIBUTE_UNUSED)
     384                 :            : {
     385                 :  901669000 :   return c_vla_type_p (x);
     386                 :            : }
     387                 :            : 
     388                 :            : /* Special routine to get the alias set of T for C.  */
     389                 :            : 
     390                 :            : alias_set_type
     391                 :  125531000 : c_get_alias_set (tree t)
     392                 :            : {
     393                 :            :   /* Allow aliasing between enumeral types and the underlying
     394                 :            :      integer type.  This is required since those are compatible types.  */
     395                 :  125531000 :   if (TREE_CODE (t) == ENUMERAL_TYPE)
     396                 :            :     {
     397                 :     282861 :       tree t1 = c_common_type_for_size (tree_to_uhwi (TYPE_SIZE (t)),
     398                 :            :                                         /* short-cut commoning to signed
     399                 :            :                                            type.  */
     400                 :            :                                         false);
     401                 :     282861 :       return get_alias_set (t1);
     402                 :            :     }
     403                 :            : 
     404                 :  125248000 :   return c_common_get_alias_set (t);
     405                 :            : }

Generated by: LCOV version 1.0

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 --enable-host-shared. GCC test suite is run with the built compiler.