LCOV - code coverage report
Current view: top level - gcc - tree-dump.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 325 427 76.1 %
Date: 2020-04-04 11:58:09 Functions: 9 15 60.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 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 "tree.h"
      25                 :            : #include "tree-pretty-print.h"
      26                 :            : #include "tree-dump.h"
      27                 :            : #include "langhooks.h"
      28                 :            : #include "tree-iterator.h"
      29                 :            : 
      30                 :            : static unsigned int queue (dump_info_p, const_tree, int);
      31                 :            : static void dump_index (dump_info_p, unsigned int);
      32                 :            : static void dequeue_and_dump (dump_info_p);
      33                 :            : static void dump_new_line (dump_info_p);
      34                 :            : static void dump_maybe_newline (dump_info_p);
      35                 :            : 
      36                 :            : /* Add T to the end of the queue of nodes to dump.  Returns the index
      37                 :            :    assigned to T.  */
      38                 :            : 
      39                 :            : static unsigned int
      40                 :      21092 : queue (dump_info_p di, const_tree t, int flags)
      41                 :            : {
      42                 :      21092 :   dump_queue_p dq;
      43                 :      21092 :   dump_node_info_p dni;
      44                 :      21092 :   unsigned int index;
      45                 :            : 
      46                 :            :   /* Assign the next available index to T.  */
      47                 :      21092 :   index = ++di->index;
      48                 :            : 
      49                 :            :   /* Obtain a new queue node.  */
      50                 :      21092 :   if (di->free_list)
      51                 :            :     {
      52                 :      20963 :       dq = di->free_list;
      53                 :      20963 :       di->free_list = dq->next;
      54                 :            :     }
      55                 :            :   else
      56                 :        129 :     dq = XNEW (struct dump_queue);
      57                 :            : 
      58                 :            :   /* Create a new entry in the splay-tree.  */
      59                 :      21092 :   dni = XNEW (struct dump_node_info);
      60                 :      21092 :   dni->index = index;
      61                 :      21092 :   dni->binfo_p = ((flags & DUMP_BINFO) != 0);
      62                 :      21092 :   dq->node = splay_tree_insert (di->nodes, (splay_tree_key) t,
      63                 :            :                                 (splay_tree_value) dni);
      64                 :            : 
      65                 :            :   /* Add it to the end of the queue.  */
      66                 :      21092 :   dq->next = 0;
      67                 :      21092 :   if (!di->queue_end)
      68                 :       2790 :     di->queue = dq;
      69                 :            :   else
      70                 :      18302 :     di->queue_end->next = dq;
      71                 :      21092 :   di->queue_end = dq;
      72                 :            : 
      73                 :            :   /* Return the index.  */
      74                 :      21092 :   return index;
      75                 :            : }
      76                 :            : 
      77                 :            : static void
      78                 :      67113 : dump_index (dump_info_p di, unsigned int index)
      79                 :            : {
      80                 :          0 :   fprintf (di->stream, "@%-6u ", index);
      81                 :      67113 :   di->column += 8;
      82                 :      46021 : }
      83                 :            : 
      84                 :            : /* If T has not already been output, queue it for subsequent output.
      85                 :            :    FIELD is a string to print before printing the index.  Then, the
      86                 :            :    index of T is printed.  */
      87                 :            : 
      88                 :            : void
      89                 :      58857 : queue_and_dump_index (dump_info_p di, const char *field, const_tree t, int flags)
      90                 :            : {
      91                 :      58857 :   unsigned int index;
      92                 :      58857 :   splay_tree_node n;
      93                 :            : 
      94                 :            :   /* If there's no node, just return.  This makes for fewer checks in
      95                 :            :      our callers.  */
      96                 :      58857 :   if (!t)
      97                 :            :     return;
      98                 :            : 
      99                 :            :   /* See if we've already queued or dumped this node.  */
     100                 :      46021 :   n = splay_tree_lookup (di->nodes, (splay_tree_key) t);
     101                 :      46021 :   if (n)
     102                 :      24934 :     index = ((dump_node_info_p) n->value)->index;
     103                 :            :   else
     104                 :            :     /* If we haven't, add it to the queue.  */
     105                 :      21087 :     index = queue (di, t, flags);
     106                 :            : 
     107                 :            :   /* Print the index of the node.  */
     108                 :      46021 :   dump_maybe_newline (di);
     109                 :      46021 :   fprintf (di->stream, "%-4s: ", field);
     110                 :      46021 :   di->column += 6;
     111                 :      46021 :   dump_index (di, index);
     112                 :            : }
     113                 :            : 
     114                 :            : /* Dump the type of T.  */
     115                 :            : 
     116                 :            : void
     117                 :       8217 : queue_and_dump_type (dump_info_p di, const_tree t)
     118                 :            : {
     119                 :       8217 :   queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE);
     120                 :       8217 : }
     121                 :            : 
     122                 :            : /* Dump column control */
     123                 :            : #define SOL_COLUMN 25           /* Start of line column.  */
     124                 :            : #define EOL_COLUMN 55           /* End of line column.  */
     125                 :            : #define COLUMN_ALIGNMENT 15     /* Alignment.  */
     126                 :            : 
     127                 :            : /* Insert a new line in the dump output, and indent to an appropriate
     128                 :            :    place to start printing more fields.  */
     129                 :            : 
     130                 :            : static void
     131                 :      27980 : dump_new_line (dump_info_p di)
     132                 :            : {
     133                 :          0 :   fprintf (di->stream, "\n%*s", SOL_COLUMN, "");
     134                 :      27980 :   di->column = SOL_COLUMN;
     135                 :      27980 : }
     136                 :            : 
     137                 :            : /* If necessary, insert a new line.  */
     138                 :            : 
     139                 :            : static void
     140                 :     102337 : dump_maybe_newline (dump_info_p di)
     141                 :            : {
     142                 :     102337 :   int extra;
     143                 :            : 
     144                 :            :   /* See if we need a new line.  */
     145                 :     102337 :   if (di->column > EOL_COLUMN)
     146                 :      27980 :     dump_new_line (di);
     147                 :            :   /* See if we need any padding.  */
     148                 :      74357 :   else if ((extra = (di->column - SOL_COLUMN) % COLUMN_ALIGNMENT) != 0)
     149                 :            :     {
     150                 :      52456 :       fprintf (di->stream, "%*s", COLUMN_ALIGNMENT - extra, "");
     151                 :      52456 :       di->column += COLUMN_ALIGNMENT - extra;
     152                 :            :     }
     153                 :     102337 : }
     154                 :            : 
     155                 :            : /* Dump pointer PTR using FIELD to identify it.  */
     156                 :            : 
     157                 :            : void
     158                 :          0 : dump_pointer (dump_info_p di, const char *field, void *ptr)
     159                 :            : {
     160                 :          0 :   dump_maybe_newline (di);
     161                 :          0 :   fprintf (di->stream, "%-4s: %-8" HOST_WIDE_INT_PRINT "x ", field,
     162                 :            :            (unsigned HOST_WIDE_INT) (uintptr_t) ptr);
     163                 :          0 :   di->column += 15;
     164                 :          0 : }
     165                 :            : 
     166                 :            : /* Dump integer I using FIELD to identify it.  */
     167                 :            : 
     168                 :            : void
     169                 :      10279 : dump_int (dump_info_p di, const char *field, int i)
     170                 :            : {
     171                 :      10279 :   dump_maybe_newline (di);
     172                 :      10279 :   fprintf (di->stream, "%-4s: %-7d ", field, i);
     173                 :      10279 :   di->column += 14;
     174                 :      10279 : }
     175                 :            : 
     176                 :            : /* Dump the floating point value R, using FIELD to identify it.  */
     177                 :            : 
     178                 :            : static void
     179                 :          0 : dump_real (dump_info_p di, const char *field, const REAL_VALUE_TYPE *r)
     180                 :            : {
     181                 :          0 :   char buf[32];
     182                 :          0 :   real_to_decimal (buf, r, sizeof (buf), 0, true);
     183                 :          0 :   dump_maybe_newline (di);
     184                 :          0 :   fprintf (di->stream, "%-4s: %s ", field, buf);
     185                 :          0 :   di->column += strlen (buf) + 7;
     186                 :          0 : }
     187                 :            : 
     188                 :            : /* Dump the fixed-point value F, using FIELD to identify it.  */
     189                 :            : 
     190                 :            : static void
     191                 :          0 : dump_fixed (dump_info_p di, const char *field, const FIXED_VALUE_TYPE *f)
     192                 :            : {
     193                 :          0 :   char buf[32];
     194                 :          0 :   fixed_to_decimal (buf, f, sizeof (buf));
     195                 :          0 :   dump_maybe_newline (di);
     196                 :          0 :   fprintf (di->stream, "%-4s: %s ", field, buf);
     197                 :          0 :   di->column += strlen (buf) + 7;
     198                 :          0 : }
     199                 :            : 
     200                 :            : 
     201                 :            : /* Dump the string S.  */
     202                 :            : 
     203                 :            : void
     204                 :          0 : dump_string (dump_info_p di, const char *string)
     205                 :            : {
     206                 :          0 :   dump_maybe_newline (di);
     207                 :          0 :   fprintf (di->stream, "%-13s ", string);
     208                 :          0 :   if (strlen (string) > 13)
     209                 :          0 :     di->column += strlen (string) + 1;
     210                 :            :   else
     211                 :          0 :     di->column += 14;
     212                 :          0 : }
     213                 :            : 
     214                 :            : /* Dump the string field S.  */
     215                 :            : 
     216                 :            : void
     217                 :      38273 : dump_string_field (dump_info_p di, const char *field, const char *string)
     218                 :            : {
     219                 :      38273 :   dump_maybe_newline (di);
     220                 :      38273 :   fprintf (di->stream, "%-4s: %-7s ", field, string);
     221                 :      38273 :   if (strlen (string) > 7)
     222                 :      21442 :     di->column += 6 + strlen (string) + 1;
     223                 :            :   else
     224                 :      16831 :     di->column += 14;
     225                 :      38273 : }
     226                 :            : 
     227                 :            : /* Dump the next node in the queue.  */
     228                 :            : 
     229                 :            : static void
     230                 :      21092 : dequeue_and_dump (dump_info_p di)
     231                 :            : {
     232                 :      21092 :   dump_queue_p dq;
     233                 :      21092 :   splay_tree_node stn;
     234                 :      21092 :   dump_node_info_p dni;
     235                 :      21092 :   tree t;
     236                 :      21092 :   unsigned int index;
     237                 :      21092 :   enum tree_code code;
     238                 :      21092 :   enum tree_code_class code_class;
     239                 :      21092 :   const char* code_name;
     240                 :            : 
     241                 :            :   /* Get the next node from the queue.  */
     242                 :      21092 :   dq = di->queue;
     243                 :      21092 :   stn = dq->node;
     244                 :      21092 :   t = (tree) stn->key;
     245                 :      21092 :   dni = (dump_node_info_p) stn->value;
     246                 :      21092 :   index = dni->index;
     247                 :            : 
     248                 :            :   /* Remove the node from the queue, and put it on the free list.  */
     249                 :      21092 :   di->queue = dq->next;
     250                 :      21092 :   if (!di->queue)
     251                 :       2790 :     di->queue_end = 0;
     252                 :      21092 :   dq->next = di->free_list;
     253                 :      21092 :   di->free_list = dq;
     254                 :            : 
     255                 :            :   /* Print the node index.  */
     256                 :      21092 :   dump_index (di, index);
     257                 :            :   /* And the type of node this is.  */
     258                 :      21092 :   if (dni->binfo_p)
     259                 :            :     code_name = "binfo";
     260                 :            :   else
     261                 :      21068 :     code_name = get_tree_code_name (TREE_CODE (t));
     262                 :      21092 :   fprintf (di->stream, "%-16s ", code_name);
     263                 :      21092 :   di->column = 25;
     264                 :            : 
     265                 :            :   /* Figure out what kind of node this is.  */
     266                 :      21092 :   code = TREE_CODE (t);
     267                 :      21092 :   code_class = TREE_CODE_CLASS (code);
     268                 :            : 
     269                 :            :   /* Although BINFOs are TREE_VECs, we dump them specially so as to be
     270                 :            :      more informative.  */
     271                 :      21092 :   if (dni->binfo_p)
     272                 :            :     {
     273                 :         24 :       unsigned ix;
     274                 :         24 :       tree base;
     275                 :         24 :       vec<tree, va_gc> *accesses = BINFO_BASE_ACCESSES (t);
     276                 :            : 
     277                 :         24 :       dump_child ("type", BINFO_TYPE (t));
     278                 :            : 
     279                 :         24 :       if (BINFO_VIRTUAL_P (t))
     280                 :          0 :         dump_string_field (di, "spec", "virt");
     281                 :            : 
     282                 :         24 :       dump_int (di, "bases", BINFO_N_BASE_BINFOS (t));
     283                 :         28 :       for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++)
     284                 :            :         {
     285                 :          8 :           tree access = (accesses ? (*accesses)[ix] : access_public_node);
     286                 :          4 :           const char *string = NULL;
     287                 :            : 
     288                 :          4 :           if (access == access_public_node)
     289                 :            :             string = "pub";
     290                 :          0 :           else if (access == access_protected_node)
     291                 :            :             string = "prot";
     292                 :          0 :           else if (access == access_private_node)
     293                 :            :             string = "priv";
     294                 :            :           else
     295                 :          0 :             gcc_unreachable ();
     296                 :            : 
     297                 :          4 :           dump_string_field (di, "accs", string);
     298                 :          4 :           queue_and_dump_index (di, "binf", base, DUMP_BINFO);
     299                 :            :         }
     300                 :            : 
     301                 :         24 :       goto done;
     302                 :            :     }
     303                 :            : 
     304                 :            :   /* We can knock off a bunch of expression nodes in exactly the same
     305                 :            :      way.  */
     306                 :      21068 :   if (IS_EXPR_CODE_CLASS (code_class))
     307                 :            :     {
     308                 :            :       /* If we're dumping children, dump them now.  */
     309                 :        152 :       queue_and_dump_type (di, t);
     310                 :            : 
     311                 :        152 :       switch (code_class)
     312                 :            :         {
     313                 :         40 :         case tcc_unary:
     314                 :         40 :           dump_child ("op 0", TREE_OPERAND (t, 0));
     315                 :         40 :           break;
     316                 :            : 
     317                 :         12 :         case tcc_binary:
     318                 :         12 :         case tcc_comparison:
     319                 :         12 :           dump_child ("op 0", TREE_OPERAND (t, 0));
     320                 :         12 :           dump_child ("op 1", TREE_OPERAND (t, 1));
     321                 :         12 :           break;
     322                 :            : 
     323                 :            :         case tcc_expression:
     324                 :            :         case tcc_reference:
     325                 :            :         case tcc_statement:
     326                 :            :         case tcc_vl_exp:
     327                 :            :           /* These nodes are handled explicitly below.  */
     328                 :            :           break;
     329                 :            : 
     330                 :            :         default:
     331                 :            :           gcc_unreachable ();
     332                 :            :         }
     333                 :            :     }
     334                 :      20916 :   else if (DECL_P (t))
     335                 :            :     {
     336                 :       7866 :       expanded_location xloc;
     337                 :            :       /* All declarations have names.  */
     338                 :       7866 :       if (DECL_NAME (t))
     339                 :       7797 :         dump_child ("name", DECL_NAME (t));
     340                 :       7866 :       if (HAS_DECL_ASSEMBLER_NAME_P (t)
     341                 :       7757 :           && DECL_ASSEMBLER_NAME_SET_P (t)
     342                 :      10170 :           && DECL_ASSEMBLER_NAME (t) != DECL_NAME (t))
     343                 :       2180 :         dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
     344                 :       7866 :       if (DECL_ABSTRACT_ORIGIN (t))
     345                 :         40 :         dump_child ("orig", DECL_ABSTRACT_ORIGIN (t));
     346                 :            :       /* And types.  */
     347                 :       7866 :       queue_and_dump_type (di, t);
     348                 :       7866 :       dump_child ("scpe", DECL_CONTEXT (t));
     349                 :            :       /* And a source position.  */
     350                 :       7866 :       xloc = expand_location (DECL_SOURCE_LOCATION (t));
     351                 :       7866 :       if (xloc.file)
     352                 :            :         {
     353                 :       7764 :           const char *filename = lbasename (xloc.file);
     354                 :            : 
     355                 :       7764 :           dump_maybe_newline (di);
     356                 :       7764 :           fprintf (di->stream, "srcp: %s:%-6d ", filename,
     357                 :            :                    xloc.line);
     358                 :       7764 :           di->column += 6 + strlen (filename) + 8;
     359                 :            :         }
     360                 :            :       /* And any declaration can be compiler-generated.  */
     361                 :       7866 :       if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_COMMON)
     362                 :       7866 :           && DECL_ARTIFICIAL (t))
     363                 :       7679 :         dump_string_field (di, "note", "artificial");
     364                 :       7866 :       if (DECL_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL))
     365                 :       7666 :         dump_child ("chain", DECL_CHAIN (t));
     366                 :            :     }
     367                 :      13050 :   else if (code_class == tcc_type)
     368                 :            :     {
     369                 :            :       /* All types have qualifiers.  */
     370                 :       2138 :       int quals = lang_hooks.tree_dump.type_quals (t);
     371                 :            : 
     372                 :       2138 :       if (quals != TYPE_UNQUALIFIED)
     373                 :            :         {
     374                 :         68 :           fprintf (di->stream, "qual: %c%c%c     ",
     375                 :         68 :                    (quals & TYPE_QUAL_CONST) ? 'c' : ' ',
     376                 :         68 :                    (quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
     377                 :         68 :                    (quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
     378                 :         68 :           di->column += 14;
     379                 :            :         }
     380                 :            : 
     381                 :            :       /* All types have associated declarations.  */
     382                 :       2138 :       dump_child ("name", TYPE_NAME (t));
     383                 :            : 
     384                 :            :       /* All types have a main variant.  */
     385                 :       2138 :       if (TYPE_MAIN_VARIANT (t) != t)
     386                 :        140 :         dump_child ("unql", TYPE_MAIN_VARIANT (t));
     387                 :            : 
     388                 :            :       /* And sizes.  */
     389                 :       2138 :       dump_child ("size", TYPE_SIZE (t));
     390                 :            : 
     391                 :            :       /* All types have alignments.  */
     392                 :       2138 :       dump_int (di, "algn", TYPE_ALIGN (t));
     393                 :            :     }
     394                 :      10912 :   else if (code_class == tcc_constant)
     395                 :            :     /* All constants can have types.  */
     396                 :        199 :     queue_and_dump_type (di, t);
     397                 :            : 
     398                 :            :   /* Give the language-specific code a chance to print something.  If
     399                 :            :      it's completely taken care of things, don't bother printing
     400                 :            :      anything more ourselves.  */
     401                 :      21068 :   if (lang_hooks.tree_dump.dump_tree (di, t))
     402                 :         20 :     goto done;
     403                 :            : 
     404                 :            :   /* Now handle the various kinds of nodes.  */
     405                 :      21048 :   switch (code)
     406                 :            :     {
     407                 :       7773 :       int i;
     408                 :            : 
     409                 :       7773 :     case IDENTIFIER_NODE:
     410                 :       7773 :       dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
     411                 :       7773 :       dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
     412                 :       7773 :       break;
     413                 :            : 
     414                 :       2895 :     case TREE_LIST:
     415                 :       2895 :       dump_child ("purp", TREE_PURPOSE (t));
     416                 :       2895 :       dump_child ("valu", TREE_VALUE (t));
     417                 :       2895 :       dump_child ("chan", TREE_CHAIN (t));
     418                 :       2895 :       break;
     419                 :            : 
     420                 :         13 :     case STATEMENT_LIST:
     421                 :         13 :       {
     422                 :         13 :         tree_stmt_iterator it;
     423                 :         31 :         for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++)
     424                 :            :           {
     425                 :         18 :             char buffer[32];
     426                 :         18 :             sprintf (buffer, "%u", i);
     427                 :         18 :             dump_child (buffer, tsi_stmt (it));
     428                 :            :           }
     429                 :            :       }
     430                 :         13 :       break;
     431                 :            : 
     432                 :          0 :     case TREE_VEC:
     433                 :          0 :       dump_int (di, "lngt", TREE_VEC_LENGTH (t));
     434                 :          0 :       for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
     435                 :            :         {
     436                 :          0 :           char buffer[32];
     437                 :          0 :           sprintf (buffer, "%u", i);
     438                 :          0 :           dump_child (buffer, TREE_VEC_ELT (t, i));
     439                 :            :         }
     440                 :            :       break;
     441                 :            : 
     442                 :         84 :     case INTEGER_TYPE:
     443                 :         84 :     case ENUMERAL_TYPE:
     444                 :         84 :       dump_int (di, "prec", TYPE_PRECISION (t));
     445                 :        133 :       dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
     446                 :         84 :       dump_child ("min", TYPE_MIN_VALUE (t));
     447                 :         84 :       dump_child ("max", TYPE_MAX_VALUE (t));
     448                 :            : 
     449                 :         84 :       if (code == ENUMERAL_TYPE)
     450                 :          2 :         dump_child ("csts", TYPE_VALUES (t));
     451                 :            :       break;
     452                 :            : 
     453                 :         52 :     case REAL_TYPE:
     454                 :         52 :       dump_int (di, "prec", TYPE_PRECISION (t));
     455                 :         52 :       break;
     456                 :            : 
     457                 :          0 :     case FIXED_POINT_TYPE:
     458                 :          0 :       dump_int (di, "prec", TYPE_PRECISION (t));
     459                 :          0 :       dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
     460                 :          0 :       dump_string_field (di, "saturating",
     461                 :          0 :                          TYPE_SATURATING (t) ? "saturating": "non-saturating");
     462                 :          0 :       break;
     463                 :            : 
     464                 :        183 :     case POINTER_TYPE:
     465                 :        183 :       dump_child ("ptd", TREE_TYPE (t));
     466                 :        183 :       break;
     467                 :            : 
     468                 :          8 :     case REFERENCE_TYPE:
     469                 :          8 :       dump_child ("refd", TREE_TYPE (t));
     470                 :          8 :       break;
     471                 :            : 
     472                 :         31 :     case METHOD_TYPE:
     473                 :         62 :       dump_child ("clas", TYPE_METHOD_BASETYPE (t));
     474                 :            :       /* Fall through.  */
     475                 :            : 
     476                 :       1614 :     case FUNCTION_TYPE:
     477                 :       1614 :       dump_child ("retn", TREE_TYPE (t));
     478                 :       1614 :       dump_child ("prms", TYPE_ARG_TYPES (t));
     479                 :       1614 :       break;
     480                 :            : 
     481                 :         32 :     case ARRAY_TYPE:
     482                 :         32 :       dump_child ("elts", TREE_TYPE (t));
     483                 :         32 :       dump_child ("domn", TYPE_DOMAIN (t));
     484                 :         32 :       break;
     485                 :            : 
     486                 :         56 :     case RECORD_TYPE:
     487                 :         56 :     case UNION_TYPE:
     488                 :         56 :       if (TREE_CODE (t) == RECORD_TYPE)
     489                 :         56 :         dump_string_field (di, "tag", "struct");
     490                 :            :       else
     491                 :          0 :         dump_string_field (di, "tag", "union");
     492                 :            : 
     493                 :         56 :       dump_child ("flds", TYPE_FIELDS (t));
     494                 :         56 :       queue_and_dump_index (di, "binf", TYPE_BINFO (t),
     495                 :            :                             DUMP_BINFO);
     496                 :         56 :       break;
     497                 :            : 
     498                 :          0 :     case CONST_DECL:
     499                 :          0 :       dump_child ("cnst", DECL_INITIAL (t));
     500                 :          0 :       break;
     501                 :            : 
     502                 :          0 :     case DEBUG_EXPR_DECL:
     503                 :          0 :       dump_int (di, "-uid", DEBUG_TEMP_UID (t));
     504                 :            :       /* Fall through.  */
     505                 :            : 
     506                 :        117 :     case VAR_DECL:
     507                 :        117 :     case PARM_DECL:
     508                 :        117 :     case FIELD_DECL:
     509                 :        117 :     case RESULT_DECL:
     510                 :        117 :       if (TREE_CODE (t) == PARM_DECL)
     511                 :         44 :         dump_child ("argt", DECL_ARG_TYPE (t));
     512                 :            :       else
     513                 :         73 :         dump_child ("init", DECL_INITIAL (t));
     514                 :        117 :       dump_child ("size", DECL_SIZE (t));
     515                 :        117 :       dump_int (di, "algn", DECL_ALIGN (t));
     516                 :            : 
     517                 :        117 :       if (TREE_CODE (t) == FIELD_DECL)
     518                 :            :         {
     519                 :         48 :           if (DECL_FIELD_OFFSET (t))
     520                 :         48 :             dump_child ("bpos", bit_position (t));
     521                 :            :         }
     522                 :         69 :       else if (VAR_P (t) || TREE_CODE (t) == PARM_DECL)
     523                 :            :         {
     524                 :         64 :           dump_int (di, "used", TREE_USED (t));
     525                 :         64 :           if (DECL_REGISTER (t))
     526                 :          0 :             dump_string_field (di, "spec", "register");
     527                 :            :         }
     528                 :            :       break;
     529                 :            : 
     530                 :       7509 :     case FUNCTION_DECL:
     531                 :       7509 :       dump_child ("args", DECL_ARGUMENTS (t));
     532                 :       7509 :       if (DECL_EXTERNAL (t))
     533                 :       7488 :         dump_string_field (di, "body", "undefined");
     534                 :       7509 :       if (TREE_PUBLIC (t))
     535                 :       7509 :         dump_string_field (di, "link", "extern");
     536                 :            :       else
     537                 :          0 :         dump_string_field (di, "link", "static");
     538                 :       7509 :       if (DECL_SAVED_TREE (t) && !dump_flag (di, TDF_SLIM, t))
     539                 :         12 :         dump_child ("body", DECL_SAVED_TREE (t));
     540                 :            :       break;
     541                 :            : 
     542                 :        195 :     case INTEGER_CST:
     543                 :        195 :       fprintf (di->stream, "int: ");
     544                 :        195 :       print_decs (wi::to_wide (t), di->stream);
     545                 :        195 :       break;
     546                 :            : 
     547                 :          4 :     case STRING_CST:
     548                 :          4 :       fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
     549                 :          4 :       dump_int (di, "lngt", TREE_STRING_LENGTH (t));
     550                 :          4 :       break;
     551                 :            : 
     552                 :          0 :     case REAL_CST:
     553                 :          0 :       dump_real (di, "valu", TREE_REAL_CST_PTR (t));
     554                 :          0 :       break;
     555                 :            : 
     556                 :          0 :     case FIXED_CST:
     557                 :          0 :       dump_fixed (di, "valu", TREE_FIXED_CST_PTR (t));
     558                 :          0 :       break;
     559                 :            : 
     560                 :         44 :     case TRUTH_NOT_EXPR:
     561                 :         44 :     case ADDR_EXPR:
     562                 :         44 :     case INDIRECT_REF:
     563                 :         44 :     case CLEANUP_POINT_EXPR:
     564                 :         44 :     case VIEW_CONVERT_EXPR:
     565                 :         44 :     case SAVE_EXPR:
     566                 :         44 :     case REALPART_EXPR:
     567                 :         44 :     case IMAGPART_EXPR:
     568                 :            :       /* These nodes are unary, but do not have code class `1'.  */
     569                 :         44 :       dump_child ("op 0", TREE_OPERAND (t, 0));
     570                 :         44 :       break;
     571                 :            : 
     572                 :         14 :     case TRUTH_ANDIF_EXPR:
     573                 :         14 :     case TRUTH_ORIF_EXPR:
     574                 :         14 :     case INIT_EXPR:
     575                 :         14 :     case MODIFY_EXPR:
     576                 :         14 :     case COMPOUND_EXPR:
     577                 :         14 :     case PREDECREMENT_EXPR:
     578                 :         14 :     case PREINCREMENT_EXPR:
     579                 :         14 :     case POSTDECREMENT_EXPR:
     580                 :         14 :     case POSTINCREMENT_EXPR:
     581                 :            :       /* These nodes are binary, but do not have code class `2'.  */
     582                 :         14 :       dump_child ("op 0", TREE_OPERAND (t, 0));
     583                 :         14 :       dump_child ("op 1", TREE_OPERAND (t, 1));
     584                 :         14 :       break;
     585                 :            : 
     586                 :          4 :     case COMPONENT_REF:
     587                 :          4 :     case BIT_FIELD_REF:
     588                 :          4 :       dump_child ("op 0", TREE_OPERAND (t, 0));
     589                 :          4 :       dump_child ("op 1", TREE_OPERAND (t, 1));
     590                 :          4 :       dump_child ("op 2", TREE_OPERAND (t, 2));
     591                 :          4 :       break;
     592                 :            : 
     593                 :          0 :     case ARRAY_REF:
     594                 :          0 :     case ARRAY_RANGE_REF:
     595                 :          0 :       dump_child ("op 0", TREE_OPERAND (t, 0));
     596                 :          0 :       dump_child ("op 1", TREE_OPERAND (t, 1));
     597                 :          0 :       dump_child ("op 2", TREE_OPERAND (t, 2));
     598                 :          0 :       dump_child ("op 3", TREE_OPERAND (t, 3));
     599                 :          0 :       break;
     600                 :            : 
     601                 :          0 :     case COND_EXPR:
     602                 :          0 :       dump_child ("op 0", TREE_OPERAND (t, 0));
     603                 :          0 :       dump_child ("op 1", TREE_OPERAND (t, 1));
     604                 :          0 :       dump_child ("op 2", TREE_OPERAND (t, 2));
     605                 :          0 :       break;
     606                 :            : 
     607                 :          8 :     case TRY_FINALLY_EXPR:
     608                 :          8 :     case EH_ELSE_EXPR:
     609                 :          8 :       dump_child ("op 0", TREE_OPERAND (t, 0));
     610                 :          8 :       dump_child ("op 1", TREE_OPERAND (t, 1));
     611                 :          8 :       break;
     612                 :            : 
     613                 :          8 :     case CALL_EXPR:
     614                 :          8 :       {
     615                 :          8 :         int i = 0;
     616                 :          8 :         tree arg;
     617                 :          8 :         call_expr_arg_iterator iter;
     618                 :          8 :         dump_child ("fn", CALL_EXPR_FN (t));
     619                 :         19 :         FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
     620                 :            :           {
     621                 :         11 :             char buffer[32];
     622                 :         11 :             sprintf (buffer, "%u", i);
     623                 :         11 :             dump_child (buffer, arg);
     624                 :         11 :             i++;
     625                 :            :           }
     626                 :            :       }
     627                 :          8 :       break;
     628                 :            : 
     629                 :         16 :     case CONSTRUCTOR:
     630                 :         16 :       {
     631                 :         16 :         unsigned HOST_WIDE_INT cnt;
     632                 :         16 :         tree index, value;
     633                 :         16 :         dump_int (di, "lngt", CONSTRUCTOR_NELTS (t));
     634                 :         84 :         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value)
     635                 :            :           {
     636                 :         28 :             dump_child ("idx", index);
     637                 :         28 :             dump_child ("val", value);
     638                 :            :           }
     639                 :            :       }
     640                 :            :       break;
     641                 :            : 
     642                 :          5 :     case BIND_EXPR:
     643                 :          5 :       dump_child ("vars", TREE_OPERAND (t, 0));
     644                 :          5 :       dump_child ("body", TREE_OPERAND (t, 1));
     645                 :          5 :       break;
     646                 :            : 
     647                 :          0 :     case LOOP_EXPR:
     648                 :          0 :       dump_child ("body", TREE_OPERAND (t, 0));
     649                 :          0 :       break;
     650                 :            : 
     651                 :          0 :     case EXIT_EXPR:
     652                 :          0 :       dump_child ("cond", TREE_OPERAND (t, 0));
     653                 :          0 :       break;
     654                 :            : 
     655                 :          6 :     case RETURN_EXPR:
     656                 :          6 :       dump_child ("expr", TREE_OPERAND (t, 0));
     657                 :          6 :       break;
     658                 :            : 
     659                 :          0 :     case TARGET_EXPR:
     660                 :          0 :       dump_child ("decl", TREE_OPERAND (t, 0));
     661                 :          0 :       dump_child ("init", TREE_OPERAND (t, 1));
     662                 :          0 :       dump_child ("clnp", TREE_OPERAND (t, 2));
     663                 :            :       /* There really are two possible places the initializer can be.
     664                 :            :          After RTL expansion, the second operand is moved to the
     665                 :            :          position of the fourth operand, and the second operand
     666                 :            :          becomes NULL.  */
     667                 :          0 :       dump_child ("init", TREE_OPERAND (t, 3));
     668                 :          0 :       break;
     669                 :            : 
     670                 :          0 :     case CASE_LABEL_EXPR:
     671                 :          0 :       dump_child ("name", CASE_LABEL (t));
     672                 :          0 :       if (CASE_LOW (t))
     673                 :            :         {
     674                 :          0 :           dump_child ("low ", CASE_LOW (t));
     675                 :          0 :           if (CASE_HIGH (t))
     676                 :          0 :             dump_child ("high", CASE_HIGH (t));
     677                 :            :         }
     678                 :            :       break;
     679                 :          4 :     case LABEL_EXPR:
     680                 :          4 :       dump_child ("name", TREE_OPERAND (t,0));
     681                 :          4 :       break;
     682                 :          0 :     case GOTO_EXPR:
     683                 :          0 :       dump_child ("labl", TREE_OPERAND (t, 0));
     684                 :          0 :       break;
     685                 :          0 :     case SWITCH_EXPR:
     686                 :          0 :       dump_child ("cond", TREE_OPERAND (t, 0));
     687                 :          0 :       dump_child ("body", TREE_OPERAND (t, 1));
     688                 :          0 :       break;
     689                 :          0 :     case OMP_CLAUSE:
     690                 :          0 :       {
     691                 :          0 :         int i;
     692                 :          0 :         fprintf (di->stream, "%s\n", omp_clause_code_name[OMP_CLAUSE_CODE (t)]);
     693                 :          0 :         for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++)
     694                 :          0 :           dump_child ("op: ", OMP_CLAUSE_OPERAND (t, i));
     695                 :            :       }
     696                 :            :       break;
     697                 :            :     default:
     698                 :            :       /* There are no additional fields to print.  */
     699                 :            :       break;
     700                 :            :     }
     701                 :            : 
     702                 :      21092 :  done:
     703                 :      21092 :   if (dump_flag (di, TDF_ADDRESS, NULL))
     704                 :          0 :     dump_pointer (di, "addr", (void *)t);
     705                 :            : 
     706                 :            :   /* Terminate the line.  */
     707                 :      21092 :   fprintf (di->stream, "\n");
     708                 :      21092 : }
     709                 :            : 
     710                 :            : /* Return nonzero if FLAG has been specified for the dump, and NODE
     711                 :            :    is not the root node of the dump.  */
     712                 :            : 
     713                 :      28835 : int dump_flag (dump_info_p di, dump_flags_t flag, const_tree node)
     714                 :            : {
     715                 :      28835 :   return (di->flags & flag) && (node != di->node);
     716                 :            : }
     717                 :            : 
     718                 :            : /* Dump T, and all its children, on STREAM.  */
     719                 :            : 
     720                 :            : void
     721                 :          5 : dump_node (const_tree t, dump_flags_t flags, FILE *stream)
     722                 :            : {
     723                 :          5 :   struct dump_info di;
     724                 :          5 :   dump_queue_p dq;
     725                 :          5 :   dump_queue_p next_dq;
     726                 :            : 
     727                 :            :   /* Initialize the dump-information structure.  */
     728                 :          5 :   di.stream = stream;
     729                 :          5 :   di.index = 0;
     730                 :          5 :   di.column = 0;
     731                 :          5 :   di.queue = 0;
     732                 :          5 :   di.queue_end = 0;
     733                 :          5 :   di.free_list = 0;
     734                 :          5 :   di.flags = flags;
     735                 :          5 :   di.node = t;
     736                 :          5 :   di.nodes = splay_tree_new (splay_tree_compare_pointers, 0,
     737                 :            :                              splay_tree_delete_pointers);
     738                 :            : 
     739                 :            :   /* Queue up the first node.  */
     740                 :          5 :   queue (&di, t, DUMP_NONE);
     741                 :            : 
     742                 :            :   /* Until the queue is empty, keep dumping nodes.  */
     743                 :      21097 :   while (di.queue)
     744                 :      21092 :     dequeue_and_dump (&di);
     745                 :            : 
     746                 :            :   /* Now, clean up.  */
     747                 :        134 :   for (dq = di.free_list; dq; dq = next_dq)
     748                 :            :     {
     749                 :        129 :       next_dq = dq->next;
     750                 :        129 :       free (dq);
     751                 :            :     }
     752                 :          5 :   splay_tree_delete (di.nodes);
     753                 :          5 : }

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.