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