qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-14 17:01:22 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/tools/qfcc/source/dot_flow.c

356 lines
8.7 KiB
C
Raw Normal View History

Bring back dot_flow.c. However, it produces simplified flow graphs (ie, just nodes and edges, no statements, though later on data flow information will be added).
2012-11-01 04:23:16 +00:00
/*
dot_flow.c
"emit" flow graphs to dot (graphvis).
Copyright (C) 2012 Bill Currie <bill@taniwha.org>
Author: Bill Currie <bill@taniwha.org>
Date: 2012/11/01
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#include <stdlib.h>
Move set.c into libQFutil. Also move the ALLOC/FREE macros from qfcc.h to QF/alloc.h (needed to for set.c). Both modules are more generally useful than just for qfcc (eg, set builtins for ruamoko).
2012-12-06 11:52:53 +00:00
#include "QF/dstring.h"
#include "QF/quakeio.h"
#include "QF/set.h"
#include "QF/va.h"
Bring back dot_flow.c. However, it produces simplified flow graphs (ie, just nodes and edges, no statements, though later on data flow information will be added).
2012-11-01 04:23:16 +00:00
#include "dags.h"
#include "flow.h"
Add live variable info to flow graph dumps. Things are a little bogus, but at least the bogosity is visible :)
2012-11-06 09:26:08 +00:00
#include "function.h"
Bring back dot_flow.c. However, it produces simplified flow graphs (ie, just nodes and edges, no statements, though later on data flow information will be added).
2012-11-01 04:23:16 +00:00
#include "expr.h"
Add live variable info to flow graph dumps. Things are a little bogus, but at least the bogosity is visible :)
2012-11-06 09:26:08 +00:00
#include "statements.h"
Bring back dot_flow.c. However, it produces simplified flow graphs (ie, just nodes and edges, no statements, though later on data flow information will be added).
2012-11-01 04:23:16 +00:00
#include "strpool.h"
Clean up flow diagrams. Now information like dags or live variables are dumped separately, and the live variable information replaces the flow node in the diagram (like dags have recently).
2012-11-30 07:52:22 +00:00
typedef struct {
const char *type;
void (*print_node) (dstring_t *, flowgraph_t *, flownode_t *, int);
void (*print_edge) (dstring_t *, flowgraph_t *, flowedge_t *, int);
} flow_dot_t;
Bring back dot_flow.c. However, it produces simplified flow graphs (ie, just nodes and edges, no statements, though later on data flow information will be added).
2012-11-01 04:23:16 +00:00
static void
Add live variable info to flow graph dumps. Things are a little bogus, but at least the bogosity is visible :)
2012-11-06 09:26:08 +00:00
print_flow_node (dstring_t *dstr, flowgraph_t *graph, flownode_t *node,
int level)
Bring back dot_flow.c. However, it produces simplified flow graphs (ie, just nodes and edges, no statements, though later on data flow information will be added).
2012-11-01 04:23:16 +00:00
{
int indent = level * 2 + 2;
Rewrite the flow graph code. The flow graph nodes are now properly separated from the graph, and edge information is stored in the graph struct. This actually made for much cleaner code (partly thanks to the use of sets and set iterators). Flow graph reduction has been (temporarily) ripped out as the entire approach was wrong. There was also a bug in that I didn't really understand the dragon book about selecting nodes and thus messed things up. The depth-first search tree "fixed" the problem, but was really the wrong solution (sledge hammer :P). Also, now that I understand that dot's directed graphs must be acyclic, I now have much better control over the graphs (back edges need to be flipped).
2012-11-02 08:30:29 +00:00
Clean up flow diagrams. Now information like dags or live variables are dumped separately, and the live variable information replaces the flow node in the diagram (like dags have recently).
2012-11-30 07:52:22 +00:00
dasprintf (dstr, "%*s\"fn_%p\" [label=\"%d (%d)\"];\n", indent, "",
node, node->id, node->dfn);
}
Make some minor improvements to flow graph dumps.
2012-11-06 10:18:00 +00:00
Clean up flow diagrams. Now information like dags or live variables are dumped separately, and the live variable information replaces the flow node in the diagram (like dags have recently).
2012-11-30 07:52:22 +00:00
static void
print_flow_edge (dstring_t *dstr, flowgraph_t *graph, flowedge_t *edge,
int level)
{
int indent = level * 2 + 2;
int edge_num = edge - graph->edges;
flownode_t *t, *h;
const char *style;
const char *dir;
int weight;
t = graph->nodes[edge->tail];
h = graph->nodes[edge->head];
if (t->dfn >= h->dfn) {
flownode_t *temp;
temp = h;
h = t;
t = temp;
dir = "dir=back,";
style = "dashed";
weight = 0;
} else if (set_is_member (graph->dfst, edge_num)) {
dir = "";
style = "bold";
weight = 10;
Make flow graphs with dags easier to read. The node contents are now the dag rather than the dag being attached to the node.
2012-11-21 04:43:03 +00:00
} else {
Clean up flow diagrams. Now information like dags or live variables are dumped separately, and the live variable information replaces the flow node in the diagram (like dags have recently).
2012-11-30 07:52:22 +00:00
dir = "";
style = "solid";
weight = 0;
Add live variable info to flow graph dumps. Things are a little bogus, but at least the bogosity is visible :)
2012-11-06 09:26:08 +00:00
}
Clean up flow diagrams. Now information like dags or live variables are dumped separately, and the live variable information replaces the flow node in the diagram (like dags have recently).
2012-11-30 07:52:22 +00:00
dasprintf (dstr, "%*s", indent, "");
dasprintf (dstr, "fn_%p -> ", t);
dasprintf (dstr, "fn_%p [%sstyle=%s,weight=%d", h, dir, style, weight);
dasprintf (dstr, "];\n");
}
static void
print_flow_node_dag (dstring_t *dstr, flowgraph_t *graph, flownode_t *node,
int level)
{
if (node->dag)
print_dag (dstr, node->dag, va ("%d (%d)", node->id, node->dfn));
else
print_flow_node (dstr, graph, node, level);
Mostly satisfactory output of nested regions. It turns out dot does not like cyclic graphs (thus some of the weird layouts), but fixing it by flipping back-edges requires proper recording of edge info (I guess that's what T is for in the dragon book).
2012-11-01 11:19:35 +00:00
}
static void
Clean up flow diagrams. Now information like dags or live variables are dumped separately, and the live variable information replaces the flow node in the diagram (like dags have recently).
2012-11-30 07:52:22 +00:00
print_flow_edge_dag (dstring_t *dstr, flowgraph_t *graph, flowedge_t *edge,
int level)
Mostly satisfactory output of nested regions. It turns out dot does not like cyclic graphs (thus some of the weird layouts), but fixing it by flipping back-edges requires proper recording of edge info (I guess that's what T is for in the dragon book).
2012-11-01 11:19:35 +00:00
{
int indent = level * 2 + 2;
Clean up flow diagrams. Now information like dags or live variables are dumped separately, and the live variable information replaces the flow node in the diagram (like dags have recently).
2012-11-30 07:52:22 +00:00
int edge_num = edge - graph->edges;
Rewrite the flow graph code. The flow graph nodes are now properly separated from the graph, and edge information is stored in the graph struct. This actually made for much cleaner code (partly thanks to the use of sets and set iterators). Flow graph reduction has been (temporarily) ripped out as the entire approach was wrong. There was also a bug in that I didn't really understand the dragon book about selecting nodes and thus messed things up. The depth-first search tree "fixed" the problem, but was really the wrong solution (sledge hammer :P). Also, now that I understand that dot's directed graphs must be acyclic, I now have much better control over the graphs (back edges need to be flipped).
2012-11-02 08:30:29 +00:00
flownode_t *t, *h;
Make flow graphs with dags easier to read. The node contents are now the dag rather than the dag being attached to the node.
2012-11-21 04:43:03 +00:00
const char *tpref;
const char *hpref;
Rewrite the flow graph code. The flow graph nodes are now properly separated from the graph, and edge information is stored in the graph struct. This actually made for much cleaner code (partly thanks to the use of sets and set iterators). Flow graph reduction has been (temporarily) ripped out as the entire approach was wrong. There was also a bug in that I didn't really understand the dragon book about selecting nodes and thus messed things up. The depth-first search tree "fixed" the problem, but was really the wrong solution (sledge hammer :P). Also, now that I understand that dot's directed graphs must be acyclic, I now have much better control over the graphs (back edges need to be flipped).
2012-11-02 08:30:29 +00:00
const char *style;
Make flow graphs with dags easier to read. The node contents are now the dag rather than the dag being attached to the node.
2012-11-21 04:43:03 +00:00
const char *dir;
Rewrite the flow graph code. The flow graph nodes are now properly separated from the graph, and edge information is stored in the graph struct. This actually made for much cleaner code (partly thanks to the use of sets and set iterators). Flow graph reduction has been (temporarily) ripped out as the entire approach was wrong. There was also a bug in that I didn't really understand the dragon book about selecting nodes and thus messed things up. The depth-first search tree "fixed" the problem, but was really the wrong solution (sledge hammer :P). Also, now that I understand that dot's directed graphs must be acyclic, I now have much better control over the graphs (back edges need to be flipped).
2012-11-02 08:30:29 +00:00
int weight;
Clean up flow diagrams. Now information like dags or live variables are dumped separately, and the live variable information replaces the flow node in the diagram (like dags have recently).
2012-11-30 07:52:22 +00:00
t = graph->nodes[edge->tail];
h = graph->nodes[edge->head];
if (t->dfn >= h->dfn) {
flownode_t *temp;
temp = h;
h = t;
t = temp;
tpref = "enter";
hpref = "leave";
dir = "dir=back,";
style = "dashed";
weight = 0;
} else if (set_is_member (graph->dfst, edge_num)) {
tpref = "leave";
hpref = "enter";
dir = "";
style = "bold";
weight = 10;
} else {
tpref = "leave";
hpref = "enter";
dir = "";
style = "solid";
weight = 0;
}
dasprintf (dstr, "%*s", indent, "");
if (t->dag)
dasprintf (dstr, "dag_%s_%p -> ", tpref, t->dag);
else
dasprintf (dstr, "fn_%p -> ", t);
if (h->dag)
dasprintf (dstr, "dag_%s_%p [%sstyle=%s,weight=%d",
hpref, h->dag, dir, style, weight);
else
dasprintf (dstr, "fn_%p [%sstyle=%s,weight=%d",
h, dir, style, weight);
if (t->dag)
dasprintf (dstr, ",ltail=cluster_dag_%p", t->dag);
if (h->dag)
dasprintf (dstr, ",lhead=cluster_dag_%p", h->dag);
dasprintf (dstr, "];\n");
}
static void
print_flow_node_live (dstring_t *dstr, flowgraph_t *graph, flownode_t *node,
int level)
{
int indent = level * 2 + 2;
set_iter_t *var_iter;
flowvar_t *var;
int live;
live = node->live_vars.out && !set_is_empty (node->live_vars.out);
if (live) {
dasprintf (dstr, "%*sfn_%p [shape=none,label=<\n", indent, "", node);
dasprintf (dstr, "%*s<table border=\"0\" cellborder=\"1\" "
"cellspacing=\"0\">\n", indent + 2, "");
dasprintf (dstr, "%*s<tr><td>%d (%d)</td></tr>\n", indent + 4, "",
node->id, node->dfn);
for (var_iter = set_first (node->live_vars.out); var_iter;
var_iter = set_next (var_iter)) {
Rename set_iter_t's member to value. Makes more sense now that the membership of the value depends on the inversion of the set.
2012-12-06 12:11:38 +00:00
var = graph->func->vars[var_iter->value];
Clean up flow diagrams. Now information like dags or live variables are dumped separately, and the live variable information replaces the flow node in the diagram (like dags have recently).
2012-11-30 07:52:22 +00:00
dasprintf (dstr, "%*s<tr><td>(%d) %s</td></tr>\n", indent + 4, "",
var->number, html_string(operand_string (var->op)));
Rewrite the flow graph code. The flow graph nodes are now properly separated from the graph, and edge information is stored in the graph struct. This actually made for much cleaner code (partly thanks to the use of sets and set iterators). Flow graph reduction has been (temporarily) ripped out as the entire approach was wrong. There was also a bug in that I didn't really understand the dragon book about selecting nodes and thus messed things up. The depth-first search tree "fixed" the problem, but was really the wrong solution (sledge hammer :P). Also, now that I understand that dot's directed graphs must be acyclic, I now have much better control over the graphs (back edges need to be flipped).
2012-11-02 08:30:29 +00:00
}
Clean up flow diagrams. Now information like dags or live variables are dumped separately, and the live variable information replaces the flow node in the diagram (like dags have recently).
2012-11-30 07:52:22 +00:00
dasprintf (dstr, "%*s</table>>];\n", indent + 2, "");
} else {
print_flow_node (dstr, graph, node, level);
Mostly satisfactory output of nested regions. It turns out dot does not like cyclic graphs (thus some of the weird layouts), but fixing it by flipping back-edges requires proper recording of edge info (I guess that's what T is for in the dragon book).
2012-11-01 11:19:35 +00:00
}
Bring back dot_flow.c. However, it produces simplified flow graphs (ie, just nodes and edges, no statements, though later on data flow information will be added).
2012-11-01 04:23:16 +00:00
}
Calculate reaching defs.
2012-12-09 13:37:59 +00:00
static void
print_flow_node_reaching (dstring_t *dstr, flowgraph_t *graph,
flownode_t *node, int level)
{
int indent = level * 2 + 2;
int reach;
set_t *gen = node->reaching_defs.gen;
set_t *kill = node->reaching_defs.kill;
set_t *in = node->reaching_defs.in;
set_t *out = node->reaching_defs.out;
reach = gen && kill && in && out;
if (reach) {
dasprintf (dstr, "%*sfn_%p [label=\"", indent, "", node);
dasprintf (dstr, "gen: %s\\n", set_as_string (gen));
dasprintf (dstr, "kill: %s\\n", set_as_string (kill));
dasprintf (dstr, "in: %s\\n", set_as_string (in));
dasprintf (dstr, "out: %s\"];\n", set_as_string (out));
} else {
print_flow_node (dstr, graph, node, level);
}
}
Make it possible to dump statement blocks in a flow graph. Much nicer looking with proper back edges :). Not actually enabled, though.
2012-12-11 02:31:55 +00:00
static void
print_flow_node_statements (dstring_t *dstr, flowgraph_t *graph,
flownode_t *node, int level)
{
if (node->sblock) {
dot_sblock (dstr, node->sblock, node->id);
} else {
print_flow_node (dstr, graph, node, level);
}
}
static void
print_flow_edge_statements (dstring_t *dstr, flowgraph_t *graph,
flowedge_t *edge, int level)
{
int indent = level * 2 + 2;
int edge_num = edge - graph->edges;
flownode_t *h, *t;
const char *hpre = "fn_", *tpre = "fn_";
const char *style;
const char *dir;
int weight;
t = graph->nodes[edge->tail];
h = graph->nodes[edge->head];
if (t->dfn >= h->dfn) {
flownode_t *temp;
temp = h;
h = t;
t = temp;
dir = "dir=back,";
style = "dashed";
weight = 0;
} else if (set_is_member (graph->dfst, edge_num)) {
dir = "";
style = "bold";
weight = 10;
} else {
dir = "";
style = "solid";
weight = 0;
}
if (t->sblock) {
tpre = "sb_";
t = (flownode_t *) t->sblock;
}
if (h->sblock) {
hpre = "sb_";
h = (flownode_t *) h->sblock;
}
dasprintf (dstr, "%*s", indent, "");
dasprintf (dstr, "%s%p -> ", tpre, t);
dasprintf (dstr, "%s%p [%sstyle=%s,weight=%d", hpre, h, dir, style,
weight);
dasprintf (dstr, "];\n");
}
Clean up flow diagrams. Now information like dags or live variables are dumped separately, and the live variable information replaces the flow node in the diagram (like dags have recently).
2012-11-30 07:52:22 +00:00
static flow_dot_t flow_dot_methods[] = {
Make it possible to dump statement blocks in a flow graph. Much nicer looking with proper back edges :). Not actually enabled, though.
2012-12-11 02:31:55 +00:00
{"", print_flow_node, print_flow_edge},
{"dag", print_flow_node_dag, print_flow_edge_dag},
{"live", print_flow_node_live, print_flow_edge},
{"reaching", print_flow_node_reaching, print_flow_edge},
{"statements", print_flow_node_statements, print_flow_edge_statements},
Clean up flow diagrams. Now information like dags or live variables are dumped separately, and the live variable information replaces the flow node in the diagram (like dags have recently).
2012-11-30 07:52:22 +00:00
};
static void
print_flowgraph (flow_dot_t *method, flowgraph_t *graph, const char *filename)
Bring back dot_flow.c. However, it produces simplified flow graphs (ie, just nodes and edges, no statements, though later on data flow information will be added).
2012-11-01 04:23:16 +00:00
{
Rewrite the flow graph code. The flow graph nodes are now properly separated from the graph, and edge information is stored in the graph struct. This actually made for much cleaner code (partly thanks to the use of sets and set iterators). Flow graph reduction has been (temporarily) ripped out as the entire approach was wrong. There was also a bug in that I didn't really understand the dragon book about selecting nodes and thus messed things up. The depth-first search tree "fixed" the problem, but was really the wrong solution (sledge hammer :P). Also, now that I understand that dot's directed graphs must be acyclic, I now have much better control over the graphs (back edges need to be flipped).
2012-11-02 08:30:29 +00:00
int i;
Bring back dot_flow.c. However, it produces simplified flow graphs (ie, just nodes and edges, no statements, though later on data flow information will be added).
2012-11-01 04:23:16 +00:00
dstring_t *dstr = dstring_newstr();
Clean up flow diagrams. Now information like dags or live variables are dumped separately, and the live variable information replaces the flow node in the diagram (like dags have recently).
2012-11-30 07:52:22 +00:00
dasprintf (dstr, "digraph flowgraph_%s_%p {\n", method->type, graph);
Mostly satisfactory output of nested regions. It turns out dot does not like cyclic graphs (thus some of the weird layouts), but fixing it by flipping back-edges requires proper recording of edge info (I guess that's what T is for in the dragon book).
2012-11-01 11:19:35 +00:00
dasprintf (dstr, " layout=dot;\n");
dasprintf (dstr, " clusterrank=local;\n");
Rewrite the flow graph code. The flow graph nodes are now properly separated from the graph, and edge information is stored in the graph struct. This actually made for much cleaner code (partly thanks to the use of sets and set iterators). Flow graph reduction has been (temporarily) ripped out as the entire approach was wrong. There was also a bug in that I didn't really understand the dragon book about selecting nodes and thus messed things up. The depth-first search tree "fixed" the problem, but was really the wrong solution (sledge hammer :P). Also, now that I understand that dot's directed graphs must be acyclic, I now have much better control over the graphs (back edges need to be flipped).
2012-11-02 08:30:29 +00:00
dasprintf (dstr, " rankdir=TB;\n");
Mostly satisfactory output of nested regions. It turns out dot does not like cyclic graphs (thus some of the weird layouts), but fixing it by flipping back-edges requires proper recording of edge info (I guess that's what T is for in the dragon book).
2012-11-01 11:19:35 +00:00
dasprintf (dstr, " compound=true;\n");
Rewrite the flow graph code. The flow graph nodes are now properly separated from the graph, and edge information is stored in the graph struct. This actually made for much cleaner code (partly thanks to the use of sets and set iterators). Flow graph reduction has been (temporarily) ripped out as the entire approach was wrong. There was also a bug in that I didn't really understand the dragon book about selecting nodes and thus messed things up. The depth-first search tree "fixed" the problem, but was really the wrong solution (sledge hammer :P). Also, now that I understand that dot's directed graphs must be acyclic, I now have much better control over the graphs (back edges need to be flipped).
2012-11-02 08:30:29 +00:00
for (i = 0; i < graph->num_nodes; i++) {
Clean up flow diagrams. Now information like dags or live variables are dumped separately, and the live variable information replaces the flow node in the diagram (like dags have recently).
2012-11-30 07:52:22 +00:00
method->print_node (dstr, graph, graph->nodes[i], 0);
}
for (i = 0; i < graph->num_edges; i++) {
Add dummy nodes at the beginning and end of the graph. The dummy nodes are for detectining uninitialized variables (entry dummy) and making globals live at function exit (exit dummy). The reaching defs and live vars code currently seg because neither node has had its sets initialized.
2012-12-10 04:56:26 +00:00
if ((int) graph->edges[i].head >= graph->num_nodes
|| (int) graph->edges[i].tail >= graph->num_nodes)
continue; // dummy node
Clean up flow diagrams. Now information like dags or live variables are dumped separately, and the live variable information replaces the flow node in the diagram (like dags have recently).
2012-11-30 07:52:22 +00:00
method->print_edge (dstr, graph, &graph->edges[i], 0);
Mostly satisfactory output of nested regions. It turns out dot does not like cyclic graphs (thus some of the weird layouts), but fixing it by flipping back-edges requires proper recording of edge info (I guess that's what T is for in the dragon book).
2012-11-01 11:19:35 +00:00
}
Bring back dot_flow.c. However, it produces simplified flow graphs (ie, just nodes and edges, no statements, though later on data flow information will be added).
2012-11-01 04:23:16 +00:00
dasprintf (dstr, "}\n");
if (filename) {
QFile *file;
file = Qopen (filename, "wt");
Qwrite (file, dstr->str, dstr->size - 1);
Qclose (file);
} else {
fputs (dstr->str, stdout);
}
dstring_delete (dstr);
}
Clean up flow diagrams. Now information like dags or live variables are dumped separately, and the live variable information replaces the flow node in the diagram (like dags have recently).
2012-11-30 07:52:22 +00:00
void
dump_dot_flow (void *g, const char *filename)
{
print_flowgraph (&flow_dot_methods[0], (flowgraph_t *) g, filename);
}
void
dump_dot_flow_dags (void *g, const char *filename)
{
print_flowgraph (&flow_dot_methods[1], (flowgraph_t *) g, filename);
}
void
dump_dot_flow_live (void *g, const char *filename)
{
print_flowgraph (&flow_dot_methods[2], (flowgraph_t *) g, filename);
}
Calculate reaching defs.
2012-12-09 13:37:59 +00:00
void
dump_dot_flow_reaching (void *g, const char *filename)
{
print_flowgraph (&flow_dot_methods[3], (flowgraph_t *) g, filename);
}
Make it possible to dump statement blocks in a flow graph. Much nicer looking with proper back edges :). Not actually enabled, though.
2012-12-11 02:31:55 +00:00
void
dump_dot_flow_statements (void *g, const char *filename)
{
print_flowgraph (&flow_dot_methods[4], (flowgraph_t *) g, filename);
}
Reference in a new issue Copy permalink