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

276 lines
6.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>
#include <QF/dstring.h>
#include <QF/quakeio.h>
#include <QF/va.h>
#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"
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
#include "set.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)) {
var = graph->func->vars[var_iter->member];
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
}
Add flow analysis to determin the type of .return. It doesn't quite work yet, but... It has proven necessary to know what type .return has at any point in the function. The segfault in ctf is caused by the return statement added to the end of the void function messing with the expr pointer stored in the daglabel for .return. While this is actually by design (though the statement really should have a valid expr pointer rather than), it actually highlights a bigger problem: there's no stable knowledge of the current type of .return. This is not a problem in expression statements as the dagnodes for expression statements store the desired types of all operands. However, when assigning from .return to attached variables in a leaf node, the type of .return is not stored anywhere but the expression last accessing .return.
2012-11-30 08:04:18 +00:00
static void
print_flow_node_return (dstring_t *dstr, flowgraph_t *graph, flownode_t *node,
int level)
{
int indent = level * 2 + 2;
dasprintf (dstr, "%*s\"fn_%p\" [label=\"%d (%d)\\n%s\\n%s\"];\n",
indent, "", node, node->id, node->dfn,
pr_type_name[node->return_type.in],
pr_type_name[node->return_type.out]);
}
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[] = {
{"", print_flow_node, print_flow_edge},
{"dag", print_flow_node_dag, print_flow_edge_dag},
{"live", print_flow_node_live, print_flow_edge},
Add flow analysis to determin the type of .return. It doesn't quite work yet, but... It has proven necessary to know what type .return has at any point in the function. The segfault in ctf is caused by the return statement added to the end of the void function messing with the expr pointer stored in the daglabel for .return. While this is actually by design (though the statement really should have a valid expr pointer rather than), it actually highlights a bigger problem: there's no stable knowledge of the current type of .return. This is not a problem in expression statements as the dagnodes for expression statements store the desired types of all operands. However, when assigning from .return to attached variables in a leaf node, the type of .return is not stored anywhere but the expression last accessing .return.
2012-11-30 08:04:18 +00:00
{"return", print_flow_node_return, print_flow_edge},
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++) {
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);
}
Add flow analysis to determin the type of .return. It doesn't quite work yet, but... It has proven necessary to know what type .return has at any point in the function. The segfault in ctf is caused by the return statement added to the end of the void function messing with the expr pointer stored in the daglabel for .return. While this is actually by design (though the statement really should have a valid expr pointer rather than), it actually highlights a bigger problem: there's no stable knowledge of the current type of .return. This is not a problem in expression statements as the dagnodes for expression statements store the desired types of all operands. However, when assigning from .return to attached variables in a leaf node, the type of .return is not stored anywhere but the expression last accessing .return.
2012-11-30 08:04:18 +00:00
void
dump_dot_flow_return (void *g, const char *filename)
{
print_flowgraph (&flow_dot_methods[3], (flowgraph_t *) g, filename);
}
Reference in a new issue Copy permalink