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