*/
#ifdef HAVE_CONFIG_H
-# include <config.h>
+# include "config.h"
#endif
/**
*/
static void append_calls (graph_info_t *info, ir_node *call, lset_t *callEds)
{
- call_info_t *cinfo = (call_info_t*) xmalloc (sizeof (call_info_t));
+ call_info_t *cinfo = xmalloc (sizeof(*cinfo));
+ ir_graph *callEd;
/* setup */
cinfo->call = call;
cinfo->callEds = NULL;
/* enter */
- ir_graph *callEd = lset_first (callEds);
- while (callEd) {
+ for (callEd = lset_first (callEds); callEd; callEd = lset_next(callEds))
cinfo->callEds = append_callEd_info (cinfo->callEds, callEd);
-
- callEd = lset_next (callEds);
- }
}
/**
*/
static void append_call (graph_info_t *info, ir_node *call, ir_graph *callEd)
{
- call_info_t *cinfo = (call_info_t*) xmalloc (sizeof (call_info_t));
+ call_info_t *cinfo = xmalloc (sizeof(*cinfo));
cinfo->call = call;
cinfo->prev = info->calls;
*/
static lset_t *get_implementing_graphs (entity *method, ir_node *select)
{
+ int n_graphs;
lset_t *set = lset_create ();
{
ir_graph *impl = _get_implementing_graph (method);
}
/* void *tmp = lset_first (set); */
- int n_graphs = lset_n_entries (set);
+ n_graphs = lset_n_entries (set);
/* typalise select_in */
if (do_typalise) {
/* fprintf (stdout, "typalyse res = %s\n", res); */
if (1 != n_graphs) {
- set = filter_for_ta (set, ta);
+ int n_filtered_graphs;
- int n_filtered_graphs = lset_n_entries (set);
+ set = filter_for_ta (set, ta);
+ n_filtered_graphs = lset_n_entries (set);
/*
fprintf (stdout, "%s: %02d %02d\n",
*/
static void ecg_calls_act (ir_node *node, void *env)
{
- opcode op = get_irn_opcode (node);
+ ir_op *op = get_irn_op(node);
graph_info_t *graph_info = (graph_info_t*) env;
- if (iro_Call == op) { /* CALL */
+ if (op_Call == op) { /* CALL */
entity *ent = NULL;
ir_node *ptr = get_Call_ptr (node);
/* CALL SEL */
- if (iro_Sel == get_irn_opcode (ptr)) {
+ if (op_Sel == get_irn_op(ptr)) {
+ lset_t *graphs;
ent = get_Sel_entity (ptr);
- lset_t *graphs = get_implementing_graphs (ent, ptr);
+ graphs = get_implementing_graphs (ent, ptr);
append_calls (graph_info, node, graphs);
- } else if (iro_SymConst == get_irn_opcode (ptr)) {
+ } else if (op_SymConst == get_irn_op(ptr)) {
if (get_SymConst_kind (ptr) == symconst_addr_ent) {
+ ir_graph *graph;
ent = get_SymConst_entity (ptr);
- ir_graph *graph = get_entity_irg (ent);
+ graph = get_entity_irg (ent);
if (graph) {
append_call (graph_info, node, graph);
DDMN (ptr);
assert (0 && "Unexpected address expression");
}
- } else if (iro_Alloc == op) {
+ } else if (op_Alloc == op) {
type *tp = get_Alloc_type (node);
/* const char *name = get_type_name (tp); */
/* count how many ctxs we have per graph */
if (0 == ginfo->ecg_seen) {
+ call_info_t *cinfo = ginfo->calls;
ginfo->ecg_seen = 1;
- call_info_t *cinfo = ginfo->calls;
while (NULL != cinfo) {
callEd_info_t *ced = cinfo->callEds;
graph_info_t *callEd_info = ecg_get_info (callEd_graph);
callEd_info->n_ctxs ++;
- /* Calling graph -> callEd_graph */
+ /* CallR graph -> CallEd_graph */
ecg_fill_ctxs_count (callEd_graph);
ced = ced->prev;
/* allocate the memory needed for the ctxts: */
graph_info_t *ginfo = graph_infos_list;
- HERE ("start");
while (NULL != ginfo) {
ginfo->ctxs = (ctx_info_t **) xmalloc (ginfo->n_ctxs * sizeof (ctx_info_t*));
assert (ginfo != ginfo->prev);
ginfo = ginfo->prev;
}
- HERE ("end");
}
/**
/* enter a new ctx for all callEds along the call edges of this graph */
if (0 == ginfo->ecg_seen) {
- ginfo->ecg_seen = 1;
call_info_t *cinfo = ginfo->calls;
+ ginfo->ecg_seen = 1;
while (NULL != cinfo) {
callEd_info_t *ced = cinfo->callEds;
*/
static void ecg_fill_ctxs (void)
{
+ ctx_info_t *main_ctx;
+ ir_graph *main_irg;
+ graph_info_t *ginfo;
+
ecg_fill_ctxs_count (get_irp_main_irg ());
- HERE ("start");
ecg_fill_ctxs_alloc ();
- HERE ("start");
- ctx_info_t *main_ctx = new_ctx (get_irp_main_irg (), NULL, NULL);
- ir_graph *main_irg = get_irp_main_irg ();
+ main_ctx = new_ctx (get_irp_main_irg (), NULL, NULL);
+ main_irg = get_irp_main_irg ();
set_main_ctx (main_ctx);
/* Grrr, have to add this ctx manually to main.ginfo ... */
- graph_info_t *ginfo = ecg_get_info (main_irg);
+ ginfo = ecg_get_info (main_irg);
ginfo->n_ctxs = 1;
- ginfo->ctxs = (ctx_info_t **) xmalloc (1 * sizeof (ctx_info_t*));
+ ginfo->ctxs = xmalloc (1 * sizeof (ctx_info_t*));
ginfo->ctxs [0] = main_ctx;
ecg_fill_ctxs_write (main_irg, main_ctx);
*/
void ecg_print_ctx (ctx_info_t *ctx, FILE *stream)
{
- entity *ent = get_irg_ent (ctx->graph);
+ entity *ent = get_irg_entity(ctx->graph);
ir_node *call = ctx->call;
- const char *ent_name = (char*) get_entity_name (ent);
- const char *own_name = (char*) get_type_name (get_entity_owner (ent));
+ const char *ent_name = get_entity_name (ent);
+ const char *own_name = get_type_name (get_entity_owner (ent));
fprintf (stream, "CTX[%i](%s.%s->%s[%li])",
ctx->id, own_name, ent_name,
*/
static int ecg_ecg_graph (FILE *dot, ir_graph *graph)
{
+ int graph_no;
+ call_info_t *cinfo;
+ alloc_info_t *ainfo;
const char *name = get_irg_entity (graph) ?
get_entity_name (get_irg_entity (graph)) : "noEntity";
const char *color =
assert (0L <= _graphs);
- const int graph_no = _graphs ++;
+ graph_no = _graphs ++;
ginfo->ecg_seen = graph_no;
fprintf (dot, "\t/* Graph of \"%s.%s\" */\n",
return (graph_no);
}
- call_info_t *cinfo = ginfo->calls;
+ cinfo = ginfo->calls;
while (NULL != cinfo) {
ir_node *call = cinfo->call;
callEd_info_t *ced = cinfo->callEds;
const int call_no = _calls ++;
- const char *call_color = (NULL == ced->prev) ? "lightblue" : "blue3";
+ const char *call_color = (NULL == ced) ? "blue" :
+ (NULL == ced->prev) ? "lightblue" : "blue3";
fprintf (dot, "\t/* Call %li */\n", get_irn_node_nr (call));
fprintf (dot, "\tcall_%i [label=\"call\\[%li\\]\", color=\"%s\", shape=\"ellipse\"];\n",
} /* done all calls (graph) */
/* now the allocs */
- alloc_info_t *ainfo = ecg_get_alloc_info (graph);
+ ainfo = ecg_get_alloc_info (graph);
if (ainfo) {
fprintf (dot, "\t/* now the allocs */\n");
} else {
/* write table of ctxs */
{
- fprintf (dot, "\tctx_%i [label=\"<HEAD>", graph_no);
-
int i;
const int max_ctxs = 30;
const int n_ctxs = (ginfo->n_ctxs > max_ctxs) ? max_ctxs : ginfo->n_ctxs;
+ fprintf (dot, "\tctx_%i [label=\"<HEAD>", graph_no);
+
assert (ginfo->ctxs && "no ctx");
for (i = 0; i < n_ctxs; i ++) {
ctx_info_t *ctx_info = ginfo->ctxs [i];
static void ecg_ecg_count (ir_graph *graph)
{
+ int graph_no;
+ call_info_t *cinfo;
graph_info_t *ginfo = (graph_info_t*) pmap_get (graph_infos, graph);
if (0 != ginfo->ecg_seen) {
}
*/
- const int graph_no = _graphs ++;
+ graph_no = _graphs ++;
ginfo->ecg_seen = graph_no;
fprintf (stdout, "%sMethod \"%s.%s\"\n",
get_type_name (get_entity_owner (get_irg_entity (graph))),
get_entity_name (get_irg_entity (graph)));
- call_info_t *cinfo = ginfo->calls;
+ cinfo = ginfo->calls;
while (NULL != cinfo) {
callEd_info_t *ced = cinfo->callEds;
graph_infos = pmap_create ();
ecg_fill_calls ();
- HERE ("start");
ecg_fill_ctxs ();
ecg_ecg ();
}
/**
Clean up our mess.
*/
-void ecg_cleanup ()
+void ecg_cleanup (void)
{
- return;
-
int i;
+ return;
+
for (i = 0; i < get_irp_n_irgs (); i++) {
ir_graph *graph = get_irp_irg (i);
call_info_t *cinfo = info->calls;
while (NULL != cinfo) {
- cinfo->call = NULL;
-
callEd_info_t *ced = cinfo->callEds;
+ cinfo->call = NULL;
+
while (NULL != ced) {
callEd_info_t *nced = ced->prev;
free (ced);
FILE *dot = fopen ("calls.dot", "w");
fprintf (dot, "digraph \"calls\" {\n");
- fprintf (dot, "\tnode [shape = \"record\", style = \"filled\"];\n");
- fprintf (dot, "\tedge [color = \"black\"];\n");
- fprintf (dot, "\n");
- fprintf (dot, "\tsize = \"11, 7\";\n");
- fprintf (dot, "\trotate = \"90\";\n");
- fprintf (dot, "\tratio = \"fill\";\n");
- fprintf (dot, "\trankdir = \"LR\";\n");
+ fprintf (dot, "\tgraph [rankdir=\"LR\", ordering=\"out\", size=\"11, 7\", rotate=\"90\", ratio=\"fill\"];\n");
+ fprintf (dot, "\tnode [shape=\"record\", style=\"filled\"];\n");
+ fprintf (dot, "\tedge [color=\"black\"];\n");
fprintf (dot, "\n");
for (i = 0; i < get_irp_n_irgs (); i++) {
ir_graph *graph = get_irp_irg (i);
- graph_info_t *info = (graph_info_t*) pmap_get (graph_infos, graph);
+ graph_info_t *ginfo = (graph_info_t*) pmap_get (graph_infos, graph);
- const char *name = get_irg_entity (graph) ?
- get_entity_name (get_irg_entity (graph)) : "noEntity";
+ if (0 != ginfo->n_ctxs) {
+ call_info_t *cinfo;
+ alloc_info_t *ainfo;
- const char *oname = get_type_name
- (get_entity_owner (get_irg_entity (graph)));
+ const char *name = get_irg_entity (graph) ?
+ get_entity_name (get_irg_entity (graph)) : "noEntity";
- const char *color =
- (get_entity_stickyness
- (get_irg_entity (graph)) == stickyness_sticky) ?
- "red3" : "lightyellow";
+ const char *oname = get_type_name
+ (get_entity_owner (get_irg_entity (graph)));
- fprintf (dot, "\t/* graph_0x%08x (\"%s\") */\n", (int) graph, name);
- fprintf (dot,
- "\tgraph_0x%08x [label=\"%s\\l%s\", color=\"%s\"];\n",
- (int) graph, oname, name, color);
- fprintf (dot, "\n");
+ const char *color =
+ (get_entity_stickyness
+ (get_irg_entity (graph)) == stickyness_sticky) ?
+ "red3" : "lightyellow";
- call_info_t *cinfo = info->calls;
- if (cinfo) {
- fprintf (dot, "\t/* now the calls */\n");
- } else {
- fprintf (dot, "\t/* no calls, nothing to see, move along! */\n");
- }
+ fprintf (dot, "\t/* graph_0x%08x (\"%s\") */\n", (int) graph, name);
+ fprintf (dot,
+ "\tgraph_0x%08x [label=\"%s\\l%s\", color=\"%s\"];\n",
+ (int) graph, oname, name, color);
+ fprintf (dot, "\n");
- while (NULL != cinfo) {
- ir_node *call = cinfo->call;
+ cinfo = ginfo->calls;
+ if (cinfo) {
+ fprintf (dot, "\t/* now the calls */\n");
+ } else {
+ fprintf (dot, "\t/* no calls, nothing to see, move along! */\n");
+ }
- fprintf (dot, "\t/* call_0x%08x */\n", (int) call);
- fprintf (dot, "\tcall_0x%08x [label=\"call\\[%li\\]\\l0x%08x\"];\n",
- (int) call, get_irn_node_nr (call), (int) call);
- fprintf (dot, "\tgraph_0x%08x -> call_0x%08x;\n",
- (int) graph, (int) call);
+ while (NULL != cinfo) {
+ callEd_info_t *ced;
+ ir_node *call = cinfo->call;
+
+ fprintf (dot, "\t/* call_0x%08x */\n", (int) call);
+ fprintf (dot, "\tcall_0x%08x [label=\"call\\[%li\\]\", shape=\"ellipse\", color=\"lightblue\"];\n",
+ (int) call, get_irn_node_nr (call));
+ fprintf (dot, "\tgraph_0x%08x -> call_0x%08x;\n",
+ (int) graph, (int) call);
+
+ ced = cinfo->callEds;
+ while (NULL != ced) {
+ fprintf (dot, "\tcall_0x%08x -> graph_0x%08x;\n",
+ (int) call, (int) ced->callEd);
+ ced = ced->prev;
+ }
+ fprintf (dot, "\n");
- callEd_info_t *ced = cinfo->callEds;
- while (NULL != ced) {
- fprintf (dot, "\tcall_0x%08x -> graph_0x%08x;\n",
- (int) call, (int) ced->callEd);
- ced = ced->prev;
+ cinfo = cinfo->prev;
}
fprintf (dot, "\n");
- cinfo = cinfo->prev;
- }
- fprintf (dot, "\n");
+ ainfo = ginfo->allocs;
+ if (ainfo) {
+ fprintf (dot, "\t/* now the allocs */\n");
+ } else {
+ fprintf (dot, "\t/* no allocs */\n");
+ }
- alloc_info_t *ainfo = info->allocs;
- if (ainfo) {
- fprintf (dot, "\t/* now the allocs */\n");
- } else {
- fprintf (dot, "\t/* no allocs */\n");
- }
+ /* allocs */
+ while (NULL != ainfo) {
+ ir_node *alloc = ainfo->alloc;
+ const char *name = get_type_name (ainfo->tp);
+ const char *color = "red1";
+ fprintf (dot, "\talloc_0x%08x [label=\"%s\", color=\"%s\"];\n",
+ (int) alloc, name, color);
+ fprintf (dot, "\tgraph_0x%08x -> alloc_0x%08x;\n",
+ (int) graph, (int) alloc);
- while (NULL != ainfo) {
- ir_node *alloc = ainfo->alloc;
- const char *name = get_type_name (ainfo->tp);
- const char *color = "green3";
+ ainfo = ainfo->prev;
+ }
- fprintf (dot, "\talloc_0x%08x [label=\"%s\", color=\"%s\"];\n",
- (int) alloc, name, color);
- fprintf (dot, "\tgraph_0x%08x -> alloc_0x%08x;\n",
- (int) graph, (int) alloc);
+ /* ctxs */
+ {
+ int i;
+ const int max_ctxs = 30;
+ const int n_ctxs = (ginfo->n_ctxs > max_ctxs) ? max_ctxs : ginfo->n_ctxs;
+
+ fprintf (dot, "\t/* now the ctxs */\n");
+ fprintf (dot, "\tctx_0x%08x [label=\"<HEAD>", (void*) graph);
+
+ assert (ginfo->ctxs && "no ctx");
+ for (i = 0; i < n_ctxs; i ++) {
+ ctx_info_t *ctx_info = ginfo->ctxs [i];
+
+ if (NULL != ctx_info->enc) {
+ fprintf (dot, "ctx_info \\[%i\\] = ctx\\[%i\\-\\>%i\\]\\l",
+ i,
+ ctx_info->id,
+ ctx_info->enc->id);
+ } else {
+ fprintf (dot, "ctx_info \\[%i\\] = ctx\\[%i\\]\\l",
+ i, ctx_info->id);
+ }
+
+ if (i+1 != n_ctxs) {
+ fprintf (dot, "|");
+ }
+ }
- ainfo = ainfo->prev;
- }
+ if (0 < ginfo->n_ctxs - max_ctxs) {
+ fprintf (dot, "(%i more)\\l", ginfo->n_ctxs - max_ctxs);
+ }
+
+ fprintf (dot, "\", color=\"green3\"];\n");
+
+ fprintf (dot,
+ "\tgraph_0x%08x -> ctx_0x%08x:HEAD [label=\"ctx\", dir=\"none\", style=\"dotted\"];\n",
+ (void*) graph, (void*) graph);
+ }
+ } else {
+ fprintf (dot, "\t/* graph is not called */\n");
+ } /* end all graphs */
}
fprintf (dot, "}\n");
/**
Experimental: Print the ecg
*/
-void ecg_ecg ()
+void ecg_ecg (void)
{
+ FILE *dot;
+ ir_graph *main_graph = get_irp_main_irg ();
+
_graphs = 0;
_calls = 0;
- ir_graph *main_graph = get_irp_main_irg ();
-
/*
memset (spaces, '.', BUF_SIZE);
spaces [BUF_SIZE-1] = '\0';
_graphs = 0;
_calls = 0;
- FILE *dot = fopen ("ecg.dot", "w");
+ dot = fopen ("ecg.dot", "w");
fprintf (dot, "digraph \"ecg\" {\n");
- fprintf (dot, "\tnode [shape = \"record\", style = \"filled\"];\n");
- fprintf (dot, "\tedge [color = \"black\"];\n");
+ fprintf (dot, "\tgraph [rankdir=\"LR\", ordering=\"out\", size=\"11, 7\", rotate=\"90\", ratio=\"fill\"];\n");
+ fprintf (dot, "\tnode [shape=\"record\", style=\"filled\"];\n");
+ fprintf (dot, "\tedge [color=\"black\"];\n");
fprintf (dot, "\n");
- fprintf (dot, "\tsize = \"11, 7\";\n");
- fprintf (dot, "\trotate = \"90\";\n");
- fprintf (dot, "\tratio = \"fill\";\n");
- fprintf (dot, "\trankdir = \"LR\";\n");
fprintf (dot, "\n");
/* ir_graph *main_graph = get_irp_main_irg (); */
/*
$Log$
+ Revision 1.13 2004/12/21 14:21:16 beck
+ removed C99 constructs
+
+ Revision 1.12 2004/12/20 17:34:34 liekweg
+ fix recursion handling
+
+ Revision 1.11 2004/12/15 09:18:18 liekweg
+ pto_name.c
+
+ Revision 1.10 2004/12/06 12:55:06 liekweg
+ actually iterate
+
+ Revision 1.9 2004/12/02 16:17:50 beck
+ fixed config.h include
+
+ Revision 1.8 2004/11/30 14:45:44 liekweg
+ fix graph dumping, remove 'HERE's
+
Revision 1.7 2004/11/26 16:01:56 liekweg
debugging annotations