gcc/graph.c

   1 /* Output routines for graphical representation.
   2    Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
   3    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
   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 2, 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 COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include <config.h>
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26
  27 #include "rtl.h"
  28 #include "flags.h"
  29 #include "output.h"
  30 #include "function.h"
  31 #include "hard-reg-set.h"
  32 #include "basic-block.h"
  33 #include "toplev.h"
  34 #include "graph.h"
  35
  36 static const char *const graph_ext[] =
  37 {
  38   /* no_graph */ "",
  39   /* vcg */      ".vcg",
  40 };
  41
  42 static void start_fct (FILE *);
  43 static void start_bb (FILE *, int);
  44 static void node_data (FILE *, rtx);
  45 static void draw_edge (FILE *, int, int, int, int);
  46 static void end_fct (FILE *);
  47 static void end_bb (FILE *);
  48
  49 /* Output text for new basic block.  */
  50 static void
  51 start_fct (FILE *fp)
  52 {
  53   switch (graph_dump_format)
  54     {
  55     case vcg:
  56       fprintf (fp, "\
  57 graph: { title: \"%s\"\nfolding: 1\nhidden: 2\nnode: { title: \"%s.0\" }\n",
  58                current_function_name, current_function_name);
  59       break;
  60     case no_graph:
  61       break;
  62     }
  63 }
  64
  65 static void
  66 start_bb (FILE *fp, int bb)
  67 {
  68   switch (graph_dump_format)
  69     {
  70     case vcg:
  71       fprintf (fp, "\
  72 graph: {\ntitle: \"%s.BB%d\"\nfolding: 1\ncolor: lightblue\n\
  73 label: \"basic block %d",
  74                current_function_name, bb, bb);
  75       break;
  76     case no_graph:
  77       break;
  78     }
  79
  80 #if 0
  81   /* FIXME Should this be printed?  It makes the graph significantly larger.  */
  82
  83   /* Print the live-at-start register list.  */
  84   fputc ('\n', fp);
  85   EXECUTE_IF_SET_IN_REG_SET (basic_block_live_at_start[bb], 0, i,
  86                              {
  87                                fprintf (fp, " %d", i);
  88                                if (i < FIRST_PSEUDO_REGISTER)
  89                                  fprintf (fp, " [%s]",
  90                                           reg_names[i]);
  91                              });
  92 #endif
  93
  94   switch (graph_dump_format)
  95     {
  96     case vcg:
  97       fputs ("\"\n\n", fp);
  98       break;
  99     case no_graph:
 100       break;
 101     }
 102 }
 103
 104 static void
 105 node_data (FILE *fp, rtx tmp_rtx)
 106 {
 107   if (PREV_INSN (tmp_rtx) == 0)
 108     {
 109       /* This is the first instruction.  Add an edge from the starting
 110          block.  */
 111       switch (graph_dump_format)
 112         {
 113         case vcg:
 114           fprintf (fp, "\
 115 edge: { sourcename: \"%s.0\" targetname: \"%s.%d\" }\n",
 116                    current_function_name,
 117                    current_function_name, XINT (tmp_rtx, 0));
 118           break;
 119         case no_graph:
 120           break;
 121         }
 122     }
 123
 124   switch (graph_dump_format)
 125     {
 126     case vcg:
 127       fprintf (fp, "node: {\n  title: \"%s.%d\"\n  color: %s\n  \
 128 label: \"%s %d\n",
 129                current_function_name, XINT (tmp_rtx, 0),
 130                GET_CODE (tmp_rtx) == NOTE ? "lightgrey"
 131                : GET_CODE (tmp_rtx) == INSN ? "green"
 132                : GET_CODE (tmp_rtx) == JUMP_INSN ? "darkgreen"
 133                : GET_CODE (tmp_rtx) == CALL_INSN ? "darkgreen"
 134                : GET_CODE (tmp_rtx) == CODE_LABEL ?  "\
 135 darkgrey\n  shape: ellipse" : "white",
 136                GET_RTX_NAME (GET_CODE (tmp_rtx)), XINT (tmp_rtx, 0));
 137       break;
 138     case no_graph:
 139       break;
 140     }
 141
 142   /* Print the RTL.  */
 143   if (GET_CODE (tmp_rtx) == NOTE)
 144     {
 145       const char *name = "";
 146       if (NOTE_LINE_NUMBER (tmp_rtx) < 0)
 147         name =  GET_NOTE_INSN_NAME (NOTE_LINE_NUMBER (tmp_rtx));
 148       fprintf (fp, " %s", name);
 149     }
 150   else if (INSN_P (tmp_rtx))
 151     print_rtl_single (fp, PATTERN (tmp_rtx));
 152   else
 153     print_rtl_single (fp, tmp_rtx);
 154
 155   switch (graph_dump_format)
 156     {
 157     case vcg:
 158       fputs ("\"\n}\n", fp);
 159       break;
 160     case no_graph:
 161       break;
 162     }
 163 }
 164
 165 static void
 166 draw_edge (FILE *fp, int from, int to, int bb_edge, int class)
 167 {
 168   const char * color;
 169   switch (graph_dump_format)
 170     {
 171     case vcg:
 172       color = "";
 173       if (class == 2)
 174         color = "color: red ";
 175       else if (bb_edge)
 176         color = "color: blue ";
 177       else if (class == 3)
 178         color = "color: green ";
 179       fprintf (fp,
 180                "edge: { sourcename: \"%s.%d\" targetname: \"%s.%d\" %s",
 181                current_function_name, from,
 182                current_function_name, to, color);
 183       if (class)
 184         fprintf (fp, "class: %d ", class);
 185       fputs ("}\n", fp);
 186       break;
 187     case no_graph:
 188       break;
 189     }
 190 }
 191
 192 static void
 193 end_bb (FILE *fp)
 194 {
 195   switch (graph_dump_format)
 196     {
 197     case vcg:
 198       fputs ("}\n", fp);
 199       break;
 200     case no_graph:
 201       break;
 202     }
 203 }
 204
 205 static void
 206 end_fct (FILE *fp)
 207 {
 208   switch (graph_dump_format)
 209     {
 210     case vcg:
 211       fprintf (fp, "node: { title: \"%s.999999\" label: \"END\" }\n}\n",
 212                current_function_name);
 213       break;
 214     case no_graph:
 215       break;
 216     }
 217 }
 218 \f
 219 /* Like print_rtl, but also print out live information for the start of each
 220    basic block.  */
 221 void
 222 print_rtl_graph_with_bb (const char *base, const char *suffix, rtx rtx_first)
 223 {
 224   rtx tmp_rtx;
 225   size_t namelen = strlen (base);
 226   size_t suffixlen = strlen (suffix);
 227   size_t extlen = strlen (graph_ext[graph_dump_format]) + 1;
 228   char *buf = alloca (namelen + suffixlen + extlen);
 229   FILE *fp;
 230
 231   if (basic_block_info == NULL)
 232     return;
 233
 234   memcpy (buf, base, namelen);
 235   memcpy (buf + namelen, suffix, suffixlen);
 236   memcpy (buf + namelen + suffixlen, graph_ext[graph_dump_format], extlen);
 237
 238   fp = fopen (buf, "a");
 239   if (fp == NULL)
 240     return;
 241
 242   if (rtx_first == 0)
 243     fprintf (fp, "(nil)\n");
 244   else
 245     {
 246       enum bb_state { NOT_IN_BB, IN_ONE_BB, IN_MULTIPLE_BB };
 247       int max_uid = get_max_uid ();
 248       int *start = xmalloc (max_uid * sizeof (int));
 249       int *end = xmalloc (max_uid * sizeof (int));
 250       enum bb_state *in_bb_p = xmalloc (max_uid * sizeof (enum bb_state));
 251       basic_block bb;
 252       int i;
 253
 254       for (i = 0; i < max_uid; ++i)
 255         {
 256           start[i] = end[i] = -1;
 257           in_bb_p[i] = NOT_IN_BB;
 258         }
 259
 260       FOR_EACH_BB_REVERSE (bb)
 261         {
 262           rtx x;
 263           start[INSN_UID (bb->head)] = bb->index;
 264           end[INSN_UID (bb->end)] = bb->index;
 265           for (x = bb->head; x != NULL_RTX; x = NEXT_INSN (x))
 266             {
 267               in_bb_p[INSN_UID (x)]
 268                 = (in_bb_p[INSN_UID (x)] == NOT_IN_BB)
 269                  ? IN_ONE_BB : IN_MULTIPLE_BB;
 270               if (x == bb->end)
 271                 break;
 272             }
 273         }
 274
 275       /* Tell print-rtl that we want graph output.  */
 276       dump_for_graph = 1;
 277
 278       /* Start new function.  */
 279       start_fct (fp);
 280
 281       for (tmp_rtx = NEXT_INSN (rtx_first); NULL != tmp_rtx;
 282            tmp_rtx = NEXT_INSN (tmp_rtx))
 283         {
 284           int edge_printed = 0;
 285           rtx next_insn;
 286
 287           if (start[INSN_UID (tmp_rtx)] < 0 && end[INSN_UID (tmp_rtx)] < 0)
 288             {
 289               if (GET_CODE (tmp_rtx) == BARRIER)
 290                 continue;
 291               if (GET_CODE (tmp_rtx) == NOTE
 292                   && (1 || in_bb_p[INSN_UID (tmp_rtx)] == NOT_IN_BB))
 293                 continue;
 294             }
 295
 296           if ((i = start[INSN_UID (tmp_rtx)]) >= 0)
 297             {
 298               /* We start a subgraph for each basic block.  */
 299               start_bb (fp, i);
 300
 301               if (i == 0)
 302                 draw_edge (fp, 0, INSN_UID (tmp_rtx), 1, 0);
 303             }
 304
 305           /* Print the data for this node.  */
 306           node_data (fp, tmp_rtx);
 307           next_insn = next_nonnote_insn (tmp_rtx);
 308
 309           if ((i = end[INSN_UID (tmp_rtx)]) >= 0)
 310             {
 311               edge e;
 312
 313               bb = BASIC_BLOCK (i);
 314
 315               /* End of the basic block.  */
 316               end_bb (fp);
 317
 318               /* Now specify the edges to all the successors of this
 319                  basic block.  */
 320               for (e = bb->succ; e ; e = e->succ_next)
 321                 {
 322                   if (e->dest != EXIT_BLOCK_PTR)
 323                     {
 324                       rtx block_head = e->dest->head;
 325
 326                       draw_edge (fp, INSN_UID (tmp_rtx),
 327                                  INSN_UID (block_head),
 328                                  next_insn != block_head,
 329                                  (e->flags & EDGE_ABNORMAL ? 2 : 0));
 330
 331                       if (block_head == next_insn)
 332                         edge_printed = 1;
 333                     }
 334                   else
 335                     {
 336                       draw_edge (fp, INSN_UID (tmp_rtx), 999999,
 337                                  next_insn != 0,
 338                                  (e->flags & EDGE_ABNORMAL ? 2 : 0));
 339
 340                       if (next_insn == 0)
 341                         edge_printed = 1;
 342                     }
 343                 }
 344             }
 345
 346           if (!edge_printed)
 347             {
 348               /* Don't print edges to barriers.  */
 349               if (next_insn == 0
 350                   || GET_CODE (next_insn) != BARRIER)
 351                 draw_edge (fp, XINT (tmp_rtx, 0),
 352                            next_insn ? INSN_UID (next_insn) : 999999, 0, 0);
 353               else
 354                 {
 355                   /* We draw the remaining edges in class 3.  We have
 356                      to skip over the barrier since these nodes are
 357                      not printed at all.  */
 358                   do
 359                     next_insn = NEXT_INSN (next_insn);
 360                   while (next_insn
 361                          && (GET_CODE (next_insn) == NOTE
 362                              || GET_CODE (next_insn) == BARRIER));
 363
 364                   draw_edge (fp, XINT (tmp_rtx, 0),
 365                              next_insn ? INSN_UID (next_insn) : 999999, 0, 3);
 366                 }
 367             }
 368         }
 369
 370       dump_for_graph = 0;
 371
 372       end_fct (fp);
 373
 374       /* Clean up.  */
 375       free (start);
 376       free (end);
 377       free (in_bb_p);
 378     }
 379
 380   fclose (fp);
 381 }
 382
 383
 384 /* Similar as clean_dump_file, but this time for graph output files.  */
 385
 386 void
 387 clean_graph_dump_file (const char *base, const char *suffix)
 388 {
 389   size_t namelen = strlen (base);
 390   size_t suffixlen = strlen (suffix);
 391   size_t extlen = strlen (graph_ext[graph_dump_format]) + 1;
 392   char *buf = alloca (namelen + extlen + suffixlen);
 393   FILE *fp;
 394
 395   memcpy (buf, base, namelen);
 396   memcpy (buf + namelen, suffix, suffixlen);
 397   memcpy (buf + namelen + suffixlen, graph_ext[graph_dump_format], extlen);
 398
 399   fp = fopen (buf, "w");
 400
 401   if (fp == NULL)
 402     fatal_error ("can't open %s: %m", buf);
 403
 404   switch (graph_dump_format)
 405     {
 406     case vcg:
 407       fputs ("graph: {\nport_sharing: no\n", fp);
 408       break;
 409     case no_graph:
 410       abort ();
 411     }
 412
 413   fclose (fp);
 414 }
 415
 416
 417 /* Do final work on the graph output file.  */
 418 void
 419 finish_graph_dump_file (const char *base, const char *suffix)
 420 {
 421   size_t namelen = strlen (base);
 422   size_t suffixlen = strlen (suffix);
 423   size_t extlen = strlen (graph_ext[graph_dump_format]) + 1;
 424   char *buf = alloca (namelen + suffixlen + extlen);
 425   FILE *fp;
 426
 427   memcpy (buf, base, namelen);
 428   memcpy (buf + namelen, suffix, suffixlen);
 429   memcpy (buf + namelen + suffixlen, graph_ext[graph_dump_format], extlen);
 430
 431   fp = fopen (buf, "a");
 432   if (fp != NULL)
 433     {
 434       switch (graph_dump_format)
 435         {
 436         case vcg:
 437           fputs ("}\n", fp);
 438           break;
 439         case no_graph:
 440           abort ();
 441         }
 442
 443       fclose (fp);
 444     }
 445 }