gcc/graph.c

   1 /* Output routines for graphical representation.
   2    Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2007
   3    Free Software Foundation, Inc.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include <config.h>
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "rtl.h"
  27 #include "flags.h"
  28 #include "output.h"
  29 #include "function.h"
  30 #include "hard-reg-set.h"
  31 #include "obstack.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 #if 0
  69   reg_set_iterator rsi;
  70 #endif
  71
  72   switch (graph_dump_format)
  73     {
  74     case vcg:
  75       fprintf (fp, "\
  76 graph: {\ntitle: \"%s.BB%d\"\nfolding: 1\ncolor: lightblue\n\
  77 label: \"basic block %d",
  78                current_function_name (), bb, bb);
  79       break;
  80     case no_graph:
  81       break;
  82     }
  83
  84 #if 0
  85   /* FIXME Should this be printed?  It makes the graph significantly larger.  */
  86
  87   /* Print the live-at-start register list.  */
  88   fputc ('\n', fp);
  89   EXECUTE_IF_SET_IN_REG_SET (basic_block_live_at_start[bb], 0, i, rsi)
  90     {
  91       fprintf (fp, " %d", i);
  92       if (i < FIRST_PSEUDO_REGISTER)
  93         fprintf (fp, " [%s]", reg_names[i]);
  94     }
  95 #endif
  96
  97   switch (graph_dump_format)
  98     {
  99     case vcg:
 100       fputs ("\"\n\n", fp);
 101       break;
 102     case no_graph:
 103       break;
 104     }
 105 }
 106
 107 static void
 108 node_data (FILE *fp, rtx tmp_rtx)
 109 {
 110   if (PREV_INSN (tmp_rtx) == 0)
 111     {
 112       /* This is the first instruction.  Add an edge from the starting
 113          block.  */
 114       switch (graph_dump_format)
 115         {
 116         case vcg:
 117           fprintf (fp, "\
 118 edge: { sourcename: \"%s.0\" targetname: \"%s.%d\" }\n",
 119                    current_function_name (),
 120                    current_function_name (), XINT (tmp_rtx, 0));
 121           break;
 122         case no_graph:
 123           break;
 124         }
 125     }
 126
 127   switch (graph_dump_format)
 128     {
 129     case vcg:
 130       fprintf (fp, "node: {\n  title: \"%s.%d\"\n  color: %s\n  \
 131 label: \"%s %d\n",
 132                current_function_name (), XINT (tmp_rtx, 0),
 133                NOTE_P (tmp_rtx) ? "lightgrey"
 134                : NONJUMP_INSN_P (tmp_rtx) ? "green"
 135                : JUMP_P (tmp_rtx) ? "darkgreen"
 136                : CALL_P (tmp_rtx) ? "darkgreen"
 137                : LABEL_P (tmp_rtx) ?  "\
 138 darkgrey\n  shape: ellipse" : "white",
 139                GET_RTX_NAME (GET_CODE (tmp_rtx)), XINT (tmp_rtx, 0));
 140       break;
 141     case no_graph:
 142       break;
 143     }
 144
 145   /* Print the RTL.  */
 146   if (NOTE_P (tmp_rtx))
 147     {
 148       const char *name;
 149       name =  GET_NOTE_INSN_NAME (NOTE_KIND (tmp_rtx));
 150       fprintf (fp, " %s", name);
 151     }
 152   else if (INSN_P (tmp_rtx))
 153     print_rtl_single (fp, PATTERN (tmp_rtx));
 154   else
 155     print_rtl_single (fp, tmp_rtx);
 156
 157   switch (graph_dump_format)
 158     {
 159     case vcg:
 160       fputs ("\"\n}\n", fp);
 161       break;
 162     case no_graph:
 163       break;
 164     }
 165 }
 166
 167 static void
 168 draw_edge (FILE *fp, int from, int to, int bb_edge, int class)
 169 {
 170   const char * color;
 171   switch (graph_dump_format)
 172     {
 173     case vcg:
 174       color = "";
 175       if (class == 2)
 176         color = "color: red ";
 177       else if (bb_edge)
 178         color = "color: blue ";
 179       else if (class == 3)
 180         color = "color: green ";
 181       fprintf (fp,
 182                "edge: { sourcename: \"%s.%d\" targetname: \"%s.%d\" %s",
 183                current_function_name (), from,
 184                current_function_name (), to, color);
 185       if (class)
 186         fprintf (fp, "class: %d ", class);
 187       fputs ("}\n", fp);
 188       break;
 189     case no_graph:
 190       break;
 191     }
 192 }
 193
 194 static void
 195 end_bb (FILE *fp)
 196 {
 197   switch (graph_dump_format)
 198     {
 199     case vcg:
 200       fputs ("}\n", fp);
 201       break;
 202     case no_graph:
 203       break;
 204     }
 205 }
 206
 207 static void
 208 end_fct (FILE *fp)
 209 {
 210   switch (graph_dump_format)
 211     {
 212     case vcg:
 213       fprintf (fp, "node: { title: \"%s.999999\" label: \"END\" }\n}\n",
 214                current_function_name ());
 215       break;
 216     case no_graph:
 217       break;
 218     }
 219 }
 220 \f
 221 /* Like print_rtl, but also print out live information for the start of each
 222    basic block.  */
 223 void
 224 print_rtl_graph_with_bb (const char *base, rtx rtx_first)
 225 {
 226   rtx tmp_rtx;
 227   size_t namelen = strlen (base);
 228   size_t extlen = strlen (graph_ext[graph_dump_format]) + 1;
 229   char *buf = alloca (namelen + extlen);
 230   FILE *fp;
 231
 232   if (basic_block_info == NULL)
 233     return;
 234
 235   memcpy (buf, base, namelen);
 236   memcpy (buf + namelen, 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 = XNEWVEC (int, max_uid);
 249       int *end = XNEWVEC (int, max_uid);
 250       enum bb_state *in_bb_p = XNEWVEC (enum bb_state, max_uid);
 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))] = bb->index;
 264           end[INSN_UID (BB_END (bb))] = bb->index;
 265           for (x = BB_HEAD (bb); 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 (bb))
 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 (BARRIER_P (tmp_rtx))
 290                 continue;
 291               if (NOTE_P (tmp_rtx)
 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               edge_iterator ei;
 313
 314               bb = BASIC_BLOCK (i);
 315
 316               /* End of the basic block.  */
 317               end_bb (fp);
 318
 319               /* Now specify the edges to all the successors of this
 320                  basic block.  */
 321               FOR_EACH_EDGE (e, ei, bb->succs)
 322                 {
 323                   if (e->dest != EXIT_BLOCK_PTR)
 324                     {
 325                       rtx block_head = BB_HEAD (e->dest);
 326
 327                       draw_edge (fp, INSN_UID (tmp_rtx),
 328                                  INSN_UID (block_head),
 329                                  next_insn != block_head,
 330                                  (e->flags & EDGE_ABNORMAL ? 2 : 0));
 331
 332                       if (block_head == next_insn)
 333                         edge_printed = 1;
 334                     }
 335                   else
 336                     {
 337                       draw_edge (fp, INSN_UID (tmp_rtx), 999999,
 338                                  next_insn != 0,
 339                                  (e->flags & EDGE_ABNORMAL ? 2 : 0));
 340
 341                       if (next_insn == 0)
 342                         edge_printed = 1;
 343                     }
 344                 }
 345             }
 346
 347           if (!edge_printed)
 348             {
 349               /* Don't print edges to barriers.  */
 350               if (next_insn == 0
 351                   || !BARRIER_P (next_insn))
 352                 draw_edge (fp, XINT (tmp_rtx, 0),
 353                            next_insn ? INSN_UID (next_insn) : 999999, 0, 0);
 354               else
 355                 {
 356                   /* We draw the remaining edges in class 3.  We have
 357                      to skip over the barrier since these nodes are
 358                      not printed at all.  */
 359                   do
 360                     next_insn = NEXT_INSN (next_insn);
 361                   while (next_insn
 362                          && (NOTE_P (next_insn)
 363                              || BARRIER_P (next_insn)));
 364
 365                   draw_edge (fp, XINT (tmp_rtx, 0),
 366                              next_insn ? INSN_UID (next_insn) : 999999, 0, 3);
 367                 }
 368             }
 369         }
 370
 371       dump_for_graph = 0;
 372
 373       end_fct (fp);
 374
 375       /* Clean up.  */
 376       free (start);
 377       free (end);
 378       free (in_bb_p);
 379     }
 380
 381   fclose (fp);
 382 }
 383
 384
 385 /* Similar as clean_dump_file, but this time for graph output files.  */
 386
 387 void
 388 clean_graph_dump_file (const char *base)
 389 {
 390   size_t namelen = strlen (base);
 391   size_t extlen = strlen (graph_ext[graph_dump_format]) + 1;
 392   char *buf = alloca (namelen + extlen);
 393   FILE *fp;
 394
 395   memcpy (buf, base, namelen);
 396   memcpy (buf + namelen, graph_ext[graph_dump_format], extlen);
 397
 398   fp = fopen (buf, "w");
 399
 400   if (fp == NULL)
 401     fatal_error ("can't open %s: %m", buf);
 402
 403   gcc_assert (graph_dump_format == vcg);
 404   fputs ("graph: {\nport_sharing: no\n", fp);
 405
 406   fclose (fp);
 407 }
 408
 409
 410 /* Do final work on the graph output file.  */
 411 void
 412 finish_graph_dump_file (const char *base)
 413 {
 414   size_t namelen = strlen (base);
 415   size_t extlen = strlen (graph_ext[graph_dump_format]) + 1;
 416   char *buf = alloca (namelen + extlen);
 417   FILE *fp;
 418
 419   memcpy (buf, base, namelen);
 420   memcpy (buf + namelen, graph_ext[graph_dump_format], extlen);
 421
 422   fp = fopen (buf, "a");
 423   if (fp != NULL)
 424     {
 425       gcc_assert (graph_dump_format == vcg);
 426       fputs ("}\n", fp);
 427       fclose (fp);
 428     }
 429 }