LCOV - code coverage report
Current view: top level - gcc/cp - dump.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 79 219 36.1 %
Date: 2020-03-28 11:57:23 Functions: 3 3 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Tree-dumping functionality for intermediate representation.
       2                 :            :    Copyright (C) 1999-2020 Free Software Foundation, Inc.
       3                 :            :    Written by Mark Mitchell <mark@codesourcery.com>
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify
       8                 :            : it under the terms of the GNU General Public License as published by
       9                 :            : the Free Software Foundation; either version 3, or (at your option)
      10                 :            : any later version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful,
      13                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 :            : GNU General Public License 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 "tree-dump.h"
      26                 :            : 
      27                 :            : /* Dump a representation of the accessibility information associated
      28                 :            :    with T.  */
      29                 :            : 
      30                 :            : static void
      31                 :         96 : dump_access (dump_info_p di, tree t)
      32                 :            : {
      33                 :         96 :   if (TREE_PROTECTED(t))
      34                 :          0 :     dump_string_field (di, "accs", "prot");
      35                 :         96 :   else if (TREE_PRIVATE(t))
      36                 :          0 :     dump_string_field (di, "accs", "priv");
      37                 :            :   else
      38                 :         96 :     dump_string_field (di, "accs", "pub");
      39                 :         96 : }
      40                 :            : 
      41                 :            : /* Dump information common to statements from STMT.  */
      42                 :            : 
      43                 :            : static void
      44                 :          7 : dump_stmt (dump_info_p di, const_tree t)
      45                 :            : {
      46                 :          7 :   if (EXPR_HAS_LOCATION (t))
      47                 :          7 :     dump_int (di, "line", EXPR_LINENO (t));
      48                 :          7 : }
      49                 :            : 
      50                 :            : bool
      51                 :      21041 : cp_dump_tree (void* dump_info, tree t)
      52                 :            : {
      53                 :      21041 :   enum tree_code code;
      54                 :      21041 :   dump_info_p di = (dump_info_p) dump_info;
      55                 :            : 
      56                 :            :   /* Figure out what kind of node this is.  */
      57                 :      21041 :   code = TREE_CODE (t);
      58                 :            : 
      59                 :      21041 :   if (DECL_P (t))
      60                 :            :     {
      61                 :       7862 :       if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus)
      62                 :       7446 :         dump_string_field (di, "lang", language_to_string (DECL_LANGUAGE (t)));
      63                 :            :     }
      64                 :            : 
      65                 :      21041 :   switch (code)
      66                 :            :     {
      67                 :       7785 :     case IDENTIFIER_NODE:
      68                 :       7785 :       if (IDENTIFIER_ANY_OP_P (t))
      69                 :            :         {
      70                 :         16 :           dump_string_field (di, "note", "operator");
      71                 :         16 :           return true;
      72                 :            :         }
      73                 :       7769 :       else if (IDENTIFIER_CONV_OP_P (t))
      74                 :            :         {
      75                 :          0 :           dump_child ("tynm", TREE_TYPE (t));
      76                 :          0 :           return true;
      77                 :            :         }
      78                 :            :       break;
      79                 :            : 
      80                 :          0 :     case OFFSET_TYPE:
      81                 :          0 :       dump_string_field (di, "note", "ptrmem");
      82                 :          0 :       dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
      83                 :          0 :       dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
      84                 :          0 :       return true;
      85                 :            : 
      86                 :         60 :     case RECORD_TYPE:
      87                 :         60 :       if (TYPE_PTRMEMFUNC_P (t))
      88                 :            :         {
      89                 :          0 :           dump_string_field (di, "note", "ptrmem");
      90                 :          0 :           dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
      91                 :          0 :           dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
      92                 :          0 :           return true;
      93                 :            :         }
      94                 :            :       /* Fall through.  */
      95                 :            : 
      96                 :         60 :     case UNION_TYPE:
      97                 :            :       /* Is it a type used as a base? */
      98                 :         92 :       if (TYPE_CONTEXT (t) && TREE_CODE (TYPE_CONTEXT (t)) == TREE_CODE (t)
      99                 :         64 :           && CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t)
     100                 :            :         {
     101                 :          4 :           dump_child ("bfld", TYPE_CONTEXT (t));
     102                 :          4 :           return true;
     103                 :            :         }
     104                 :            : 
     105                 :         56 :       if (! MAYBE_CLASS_TYPE_P (t))
     106                 :            :         break;
     107                 :            : 
     108                 :         52 :       dump_child ("vfld", TYPE_VFIELD (t));
     109                 :         52 :       if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t))
     110                 :          0 :         dump_string(di, "spec");
     111                 :            : 
     112                 :        104 :       if (!dump_flag (di, TDF_SLIM, t) && TYPE_BINFO (t))
     113                 :            :         {
     114                 :         40 :           int i;
     115                 :         40 :           tree binfo;
     116                 :         40 :           tree base_binfo;
     117                 :            : 
     118                 :         48 :           for (binfo = TYPE_BINFO (t), i = 0;
     119                 :         48 :                BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
     120                 :            :             {
     121                 :          8 :               dump_child ("base", BINFO_TYPE (base_binfo));
     122                 :          8 :               if (BINFO_VIRTUAL_P (base_binfo))
     123                 :          0 :                 dump_string_field (di, "spec", "virt");
     124                 :          8 :               dump_access (di, base_binfo);
     125                 :            :             }
     126                 :            :         }
     127                 :            :       break;
     128                 :            : 
     129                 :         48 :     case FIELD_DECL:
     130                 :         48 :       dump_access (di, t);
     131                 :         48 :       if (DECL_MUTABLE_P (t))
     132                 :          0 :         dump_string_field (di, "spec", "mutable");
     133                 :            :       break;
     134                 :            : 
     135                 :         20 :     case VAR_DECL:
     136                 :         20 :       if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE)
     137                 :          8 :         dump_access (di, t);
     138                 :         20 :       if (TREE_STATIC (t) && !TREE_PUBLIC (t))
     139                 :          0 :         dump_string_field (di, "link", "static");
     140                 :            :       break;
     141                 :            : 
     142                 :       7508 :     case FUNCTION_DECL:
     143                 :      15016 :       if (!DECL_THUNK_P (t))
     144                 :            :         {
     145                 :       7508 :           if (DECL_OVERLOADED_OPERATOR_P (t))
     146                 :         34 :             dump_string_field (di, "note", "operator");
     147                 :      14984 :           if (DECL_FUNCTION_MEMBER_P (t))
     148                 :            :             {
     149                 :         32 :               dump_string_field (di, "note", "member");
     150                 :         32 :               dump_access (di, t);
     151                 :            :             }
     152                 :      15016 :           if (DECL_PURE_VIRTUAL_P (t))
     153                 :          0 :             dump_string_field (di, "spec", "pure");
     154                 :       7508 :           if (DECL_VIRTUAL_P (t))
     155                 :         24 :             dump_string_field (di, "spec", "virt");
     156                 :      15016 :           if (DECL_CONSTRUCTOR_P (t))
     157                 :          0 :             dump_string_field (di, "note", "constructor");
     158                 :      15016 :           if (DECL_DESTRUCTOR_P (t))
     159                 :         32 :             dump_string_field (di, "note", "destructor");
     160                 :       7508 :           if (DECL_CONV_FN_P (t))
     161                 :          0 :             dump_string_field (di, "note", "conversion");
     162                 :      15016 :           if (DECL_GLOBAL_CTOR_P (t))
     163                 :          0 :             dump_string_field (di, "note", "global init");
     164                 :      15016 :           if (DECL_GLOBAL_DTOR_P (t))
     165                 :          0 :             dump_string_field (di, "note", "global fini");
     166                 :       7508 :           if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t))
     167                 :          0 :             dump_string_field (di, "note", "pseudo tmpl");
     168                 :            :         }
     169                 :            :       else
     170                 :            :         {
     171                 :          0 :           tree virt = THUNK_VIRTUAL_OFFSET (t);
     172                 :            : 
     173                 :          0 :           dump_string_field (di, "note", "thunk");
     174                 :          0 :           if (DECL_THIS_THUNK_P (t))
     175                 :          0 :             dump_string_field (di, "note", "this adjusting");
     176                 :            :           else
     177                 :            :             {
     178                 :          0 :               dump_string_field (di, "note", "result adjusting");
     179                 :          0 :               if (virt)
     180                 :          0 :                 virt = BINFO_VPTR_FIELD (virt);
     181                 :            :             }
     182                 :          0 :           dump_int (di, "fixd", THUNK_FIXED_OFFSET (t));
     183                 :          0 :           if (virt)
     184                 :          0 :             dump_int (di, "virt", tree_to_shwi (virt));
     185                 :          0 :           dump_child ("fn", DECL_INITIAL (t));
     186                 :            :         }
     187                 :            :       break;
     188                 :            : 
     189                 :         12 :     case NAMESPACE_DECL:
     190                 :         12 :       if (DECL_NAMESPACE_ALIAS (t))
     191                 :          0 :         dump_child ("alis", DECL_NAMESPACE_ALIAS (t));
     192                 :         12 :       else if (!dump_flag (di, TDF_SLIM, t))
     193                 :         12 :         dump_child ("dcls", cp_namespace_decls (t));
     194                 :            :       break;
     195                 :            : 
     196                 :          0 :     case TEMPLATE_DECL:
     197                 :          0 :       dump_child ("rslt", DECL_TEMPLATE_RESULT (t));
     198                 :          0 :       dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t));
     199                 :          0 :       dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t));
     200                 :          0 :       dump_child ("prms", DECL_TEMPLATE_PARMS (t));
     201                 :          0 :       break;
     202                 :            : 
     203                 :            :     case OVERLOAD:
     204                 :          0 :       dump_child ("name", OVL_NAME (t));
     205                 :          0 :       if (!dump_flag (di, TDF_SLIM, t))
     206                 :          0 :         for (lkp_iterator iter (t); iter; ++iter)
     207                 :          0 :           dump_child ("chld", *iter);
     208                 :            :       break;
     209                 :            : 
     210                 :          0 :     case TRY_BLOCK:
     211                 :          0 :       dump_stmt (di, t);
     212                 :          0 :       if (CLEANUP_P (t))
     213                 :          0 :         dump_string_field (di, "note", "cleanup");
     214                 :          0 :       dump_child ("body", TRY_STMTS (t));
     215                 :          0 :       dump_child ("hdlr", TRY_HANDLERS (t));
     216                 :          0 :       break;
     217                 :            : 
     218                 :          0 :     case EH_SPEC_BLOCK:
     219                 :          0 :       dump_stmt (di, t);
     220                 :          0 :       dump_child ("body", EH_SPEC_STMTS (t));
     221                 :          0 :       dump_child ("raises", EH_SPEC_RAISES (t));
     222                 :          0 :       break;
     223                 :            : 
     224                 :          0 :     case PTRMEM_CST:
     225                 :          0 :       dump_child ("clas", PTRMEM_CST_CLASS (t));
     226                 :          0 :       dump_child ("mbr", PTRMEM_CST_MEMBER (t));
     227                 :          0 :       break;
     228                 :            : 
     229                 :          0 :     case THROW_EXPR:
     230                 :            :       /* These nodes are unary, but do not have code class `1'.  */
     231                 :          0 :       dump_child ("op 0", TREE_OPERAND (t, 0));
     232                 :          0 :       break;
     233                 :            : 
     234                 :          0 :     case AGGR_INIT_EXPR:
     235                 :          0 :       {
     236                 :          0 :         int i = 0;
     237                 :          0 :         tree arg;
     238                 :          0 :         aggr_init_expr_arg_iterator iter;
     239                 :          0 :         dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t));
     240                 :          0 :         dump_child ("fn", AGGR_INIT_EXPR_FN (t));
     241                 :          0 :         FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
     242                 :            :           {
     243                 :          0 :             char buffer[32];
     244                 :          0 :             sprintf (buffer, "%u", i);
     245                 :          0 :             dump_child (buffer, arg);
     246                 :          0 :             i++;
     247                 :            :           }
     248                 :          0 :         dump_child ("decl", AGGR_INIT_EXPR_SLOT (t));
     249                 :            :       }
     250                 :          0 :       break;
     251                 :            : 
     252                 :          0 :     case HANDLER:
     253                 :          0 :       dump_stmt (di, t);
     254                 :          0 :       dump_child ("parm", HANDLER_PARMS (t));
     255                 :          0 :       dump_child ("body", HANDLER_BODY (t));
     256                 :          0 :       break;
     257                 :            : 
     258                 :          3 :     case MUST_NOT_THROW_EXPR:
     259                 :          3 :       dump_stmt (di, t);
     260                 :          3 :       dump_child ("body", TREE_OPERAND (t, 0));
     261                 :          3 :       dump_child ("cond", MUST_NOT_THROW_COND (t));
     262                 :          3 :       break;
     263                 :            : 
     264                 :          0 :     case USING_STMT:
     265                 :          0 :       dump_stmt (di, t);
     266                 :          0 :       dump_child ("nmsp", USING_STMT_NAMESPACE (t));
     267                 :          0 :       break;
     268                 :            : 
     269                 :          0 :     case CLEANUP_STMT:
     270                 :          0 :       dump_stmt (di, t);
     271                 :          0 :       dump_child ("decl", CLEANUP_DECL (t));
     272                 :          0 :       dump_child ("expr", CLEANUP_EXPR (t));
     273                 :          0 :       dump_child ("body", CLEANUP_BODY (t));
     274                 :          0 :       break;
     275                 :            : 
     276                 :          0 :     case IF_STMT:
     277                 :          0 :       dump_stmt (di, t);
     278                 :          0 :       dump_child ("cond", IF_COND (t));
     279                 :          0 :       dump_child ("then", THEN_CLAUSE (t));
     280                 :          0 :       dump_child ("else", ELSE_CLAUSE (t));
     281                 :          0 :       break;
     282                 :            : 
     283                 :          0 :     case BREAK_STMT:
     284                 :          0 :     case CONTINUE_STMT:
     285                 :          0 :       dump_stmt (di, t);
     286                 :          0 :       break;
     287                 :            : 
     288                 :          0 :     case DO_STMT:
     289                 :          0 :       dump_stmt (di, t);
     290                 :          0 :       dump_child ("body", DO_BODY (t));
     291                 :          0 :       dump_child ("cond", DO_COND (t));
     292                 :          0 :       break;
     293                 :            : 
     294                 :          0 :     case FOR_STMT:
     295                 :          0 :       dump_stmt (di, t);
     296                 :          0 :       dump_child ("init", FOR_INIT_STMT (t));
     297                 :          0 :       dump_child ("cond", FOR_COND (t));
     298                 :          0 :       dump_child ("expr", FOR_EXPR (t));
     299                 :          0 :       dump_child ("body", FOR_BODY (t));
     300                 :          0 :       break;
     301                 :            : 
     302                 :          0 :     case RANGE_FOR_STMT:
     303                 :          0 :       dump_stmt (di, t);
     304                 :          0 :       dump_child ("init", RANGE_FOR_INIT_STMT (t));
     305                 :          0 :       dump_child ("decl", RANGE_FOR_DECL (t));
     306                 :          0 :       dump_child ("expr", RANGE_FOR_EXPR (t));
     307                 :          0 :       dump_child ("body", RANGE_FOR_BODY (t));
     308                 :          0 :       break;
     309                 :            : 
     310                 :          0 :     case SWITCH_STMT:
     311                 :          0 :       dump_stmt (di, t);
     312                 :          0 :       dump_child ("cond", SWITCH_STMT_COND (t));
     313                 :          0 :       dump_child ("body", SWITCH_STMT_BODY (t));
     314                 :          0 :       break;
     315                 :            : 
     316                 :          0 :     case WHILE_STMT:
     317                 :          0 :       dump_stmt (di, t);
     318                 :          0 :       dump_child ("cond", WHILE_COND (t));
     319                 :          0 :       dump_child ("body", WHILE_BODY (t));
     320                 :          0 :       break;
     321                 :            : 
     322                 :          0 :     case STMT_EXPR:
     323                 :          0 :       dump_child ("stmt", STMT_EXPR_STMT (t));
     324                 :          0 :       break;
     325                 :            : 
     326                 :          4 :     case EXPR_STMT:
     327                 :          4 :       dump_stmt (di, t);
     328                 :          4 :       dump_child ("expr", EXPR_STMT_EXPR (t));
     329                 :          4 :       break;
     330                 :            : 
     331                 :          0 :     case OMP_DEPOBJ:
     332                 :          0 :       dump_stmt (di, t);
     333                 :          0 :       dump_child ("depobj", OMP_DEPOBJ_DEPOBJ (t));
     334                 :          0 :       dump_child ("clauses", OMP_DEPOBJ_CLAUSES (t));
     335                 :          0 :       break;
     336                 :            : 
     337                 :            :     default:
     338                 :            :       break;
     339                 :            :     }
     340                 :            : 
     341                 :      21021 :   return c_dump_tree (di, t);
     342                 :            : }

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.