* Author: Florian
* Modified by:
* Created: 14.09.2004
- * CVS-ID: $$
+ * CVS-ID: $Id$
* Copyright: (c) 1999-2004 Universität Karlsruhe
- * Licence: This file is protected by GPL - GNU GENERAL PUBLIC LICENSE.
+ * Licence: This file is protected by the GPL - GNU GENERAL PUBLIC LICENSE.
*/
#ifdef HAVE_CONFIG_H
-# include <config.h>
+# include "config.h"
#endif
/**
Erweiterter Aufrufgraph.
- */
+*/
#include "irnode.h"
#include "pmap.h"
# include "typalise.h"
# include "lset.h"
+# include "gnu_ext.h"
+
+# define HERE(msg) fprintf (stdout, "%s:%i %s\n", __FUNCTION__, __LINE__, msg)
+
/*
- le flag
+ le flag
*/
/* static int verbose = 0; */
static int do_typalise = 0;
/*
- globals
+ globals
*/
+/* Ids for the ctxs */
+static int ctx_id = 0;
+ctx_info_t *main_ctx = NULL;
+
/* mapping from method graphs (callR) to method graphs (lset_ts of callEds) */
/* static pmap *calls; */
static pmap *graph_infos;
-/** Counters for ecg_ecg and friends */
+/* linked list of all graph_infos: */
+static graph_info_t *graph_infos_list = NULL;
+
+/* Counters for ecg_ecg and friends */
static long _graphs = 0;
static long _calls = 0;
static long _allocs = 0;
static int _max_callEds = 0;
static entity* _max_callEds_callR = NULL;
+/* Protos */
+void set_main_ctx (ctx_info_t*);
+
/* ====================
- Alloc stuff
- ==================== */
+ Alloc stuff
+ ==================== */
static void append_alloc (graph_info_t *ginfo, ir_node *alloc, type *tp)
{
- alloc_info_t *ainfo = (alloc_info_t*) xmalloc (sizeof (alloc_info_t));
+ alloc_info_t *ainfo = xmalloc (sizeof (alloc_info_t));
ainfo->graph = ginfo->graph;
ainfo->alloc = alloc;
/* ====================
- CallEd stuff
- ==================== */
+ CallEd stuff
+ ==================== */
+/**
+ Create a new call info struct from the given values.
+*/
+static call_info_t *new_call_info (ir_node *call,
+ callEd_info_t *callEds,
+ call_info_t *prev)
+{
+ call_info_t *cinfo = xmalloc (sizeof (call_info_t));
+ cinfo->call = call;
+ cinfo->callEds = callEds;
+ cinfo->prev = prev;
+
+ return (cinfo);
+}
+
/**
Append the given callEd to the given callEd info.
*/
static callEd_info_t *append_callEd_info (callEd_info_t *ced, ir_graph *callEd)
{
- callEd_info_t *nced = (callEd_info_t*) xmalloc (sizeof (sizeof (callEd_info_t)));
+ callEd_info_t *nced = xmalloc (sizeof (callEd_info_t));
+
+ assert (NULL != callEd);
nced->callEd = callEd;
nced->prev = ced;
*/
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));
+ ir_graph *callEd = NULL;
+ call_info_t *cinfo = new_call_info (call, NULL, info->calls);
- /* setup */
- cinfo->call = call;
- cinfo->prev = info->calls;
info->calls = cinfo;
- cinfo->callEds = NULL;
/* enter */
- ir_graph *callEd = lset_first (callEds);
- while (callEd) {
- cinfo->callEds = append_callEd_info (cinfo->callEds, callEd);
+ callEd = lset_first (callEds);
- callEd = lset_next (callEds);
+ while (NULL != callEd) {
+ 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 = new_call_info (call, NULL, info->calls);
- cinfo->call = call;
- cinfo->prev = info->calls;
info->calls = cinfo;
cinfo->callEds = append_callEd_info (cinfo->callEds, callEd);
*/
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",
- __FUNCTION__,
- n_graphs,
- n_filtered_graphs,
- n_graphs - n_filtered_graphs);
+ fprintf (stdout, "%s: %02d %02d\n",
+ __FUNCTION__,
+ n_graphs,
+ n_filtered_graphs,
+ n_graphs - n_filtered_graphs);
*/
n_graphs = n_filtered_graphs;
}
*/
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); */
*/
static void ecg_fill_graph_calls (ir_graph *graph)
{
- graph_info_t *graph_info = (graph_info_t*) xmalloc (sizeof (graph_info_t));
+ graph_info_t *ginfo = xmalloc (sizeof (graph_info_t));
+
+ /* memset (ginfo, 0x00, sizeof (graph_info_t)); */
+ assert (ginfo != graph_infos_list);
+
+ ginfo->graph = graph;
+ ginfo->calls = NULL;
+ ginfo->allocs = NULL;
+ ginfo->ctxs = NULL;
+ ginfo->n_ctxs = 0;
+ ginfo->ecg_seen = 0;
+ ginfo->allocs_seen = 0;
+ ginfo->prev = NULL;
- graph_info->graph = graph;
- graph_info->calls = NULL;
- graph_info->ecg_seen = 0;
+ /* link up into global list */
+ ginfo->prev = graph_infos_list;
+ graph_infos_list = ginfo;
- /* entity *method = get_irg_entity (graph); */
- /* type *clazz = get_entity_owner (method); */
+ assert (ginfo != ginfo->prev);
- irg_walk_graph (graph, ecg_calls_act, NULL, graph_info);
+ irg_walk_graph (graph, ecg_calls_act, NULL, ginfo);
- pmap_insert (graph_infos, graph, graph_info);
+ pmap_insert (graph_infos, graph, ginfo);
}
/**
}
}
+/**
+ Allocate a new ctx for the given graph and the given enclosing ctx.
+*/
+static ctx_info_t *new_ctx (ir_graph *graph, ir_node *call, ctx_info_t *enc)
+{
+ ctx_info_t *res = xmalloc (sizeof (ctx_info_t));
+
+ res->graph = graph;
+ res->call = call;
+ res->enc = enc;
+ res->id = ctx_id ++;
+
+ return (res);
+}
+
+
+/**
+ Fill in the ctxs parts of the graph_infos
+*/
+static void ecg_fill_ctxs_count (ir_graph *graph)
+{
+ graph_info_t *ginfo = ecg_get_info (graph);
+
+ /* count how many ctxs we have per graph */
+ if (0 == ginfo->ecg_seen) {
+ call_info_t *cinfo = ginfo->calls;
+
+ ginfo->ecg_seen = 1;
+
+ while (NULL != cinfo) {
+ callEd_info_t *ced = cinfo->callEds;
+
+ while (NULL != ced) {
+ ir_graph *callEd_graph = ced->callEd;
+
+ /* first step: we have a new ctx */
+ graph_info_t *callEd_info = ecg_get_info (callEd_graph);
+ callEd_info->n_ctxs ++;
+
+ /* CallR graph -> CallEd_graph */
+ ecg_fill_ctxs_count (callEd_graph);
+
+ ced = ced->prev;
+ } /* end forall callEds (call) */
+
+ cinfo = cinfo->prev;
+ } /* end forall (calls(graph)) */
+
+ ginfo->ecg_seen = 0;
+ }
+}
+
+static void ecg_fill_ctxs_alloc (void)
+{
+ /* allocate the memory needed for the ctxts: */
+ graph_info_t *ginfo = graph_infos_list;
+
+ while (NULL != ginfo) {
+ ginfo->ctxs = xcalloc (ginfo->n_ctxs, sizeof (ctx_info_t *));
+
+ /*
+ fprintf (stdout, "graph of \"%s\": n_ctxs = %i\n",
+ get_entity_name (get_irg_entity (ginfo->graph)), ginfo->n_ctxs);
+ */
+ ginfo->n_ctxs = 0;
+
+ assert (ginfo != ginfo->prev);
+ ginfo = ginfo->prev;
+ }
+}
+
+/**
+ Fill in the ctxs parts of the graph_infos
+*/
+static void ecg_fill_ctxs_write (ir_graph *graph, ctx_info_t *enc_ctx)
+{
+ graph_info_t *ginfo = ecg_get_info (graph);
+
+ /* enter a new ctx for all callEds along the call edges of this graph */
+ if (0 == ginfo->ecg_seen) {
+ call_info_t *cinfo = ginfo->calls;
+ ginfo->ecg_seen = 1;
+
+ while (NULL != cinfo) {
+ callEd_info_t *ced = cinfo->callEds;
+
+ while (NULL != ced) {
+ ctx_info_t *ctx = new_ctx (graph, cinfo->call, enc_ctx);
+
+ ir_graph *callEd_graph = ced->callEd;
+
+ /* write the ctx of this call into the callEd graph */
+ graph_info_t *callEd_info = ecg_get_info (callEd_graph);
+
+ callEd_info->ctxs [callEd_info->n_ctxs] = ctx;
+ callEd_info->n_ctxs ++;
+
+ /* CallR graph -> callEd_graph */
+ ecg_fill_ctxs_write (callEd_graph, ctx);
+
+ ced = ced->prev;
+ } /* end forall callEds (call) */
+
+ cinfo = cinfo->prev;
+ } /* end forall (calls(graph)) */
+
+ ginfo->ecg_seen = 0;
+ }
+}
+
+/**
+ Fill in the ctxs parts of the graph_infos
+*/
+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 ());
+ ecg_fill_ctxs_alloc ();
+
+ 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 ... */
+ ginfo = ecg_get_info (main_irg);
+ ginfo->n_ctxs = 1;
+ ginfo->ctxs = xcalloc (1, sizeof (ctx_info_t *));
+ ginfo->ctxs [0] = main_ctx;
+
+ ecg_fill_ctxs_write (main_irg, main_ctx);
+}
+
/* ====================
- ECG stuff
- ==================== */
+ CTX stuff
+ ==================== */
+/*
+ Nicely print a ctx_info_t to the given output stream
+*/
+void ecg_print_ctx (ctx_info_t *ctx, FILE *stream)
+{
+ entity *ent = get_irg_entity(ctx->graph);
+ ir_node *call = ctx->call;
+ 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,
+ get_op_name (get_irn_op (call)),
+ get_irn_node_nr (call));
+
+ if (NULL != ctx->enc) {
+ fprintf (stream, "->%i", ctx->enc->id);
+ }
+
+ fprintf (stream, "\n");
+}
+
+/*
+ Get a ctx of the given graph info
+*/
+ctx_info_t *get_ctx (graph_info_t *ginfo, int ctx_idx)
+{
+ assert (ginfo->n_ctxs > ctx_idx);
+
+ return (ginfo->ctxs [ctx_idx]);
+}
+
+/*
+ Get the pseudo-ctx of 'main'
+*/
+ctx_info_t *get_main_ctx ()
+{
+ return (main_ctx);
+}
+
+/*
+ Set the pseudo-ctx of 'main'
+*/
+void set_main_ctx (ctx_info_t *ctx)
+{
+ main_ctx = ctx;
+}
+
+
+/* ====================
+ ECG stuff
+ ==================== */
+
+/* ====================
+ Iterator stuff
+ ==================== */
+/*
+ Iterate over all graphs
+*/
+void ecg_iterate_graphs (graph_hnd_t *hnd, void *env)
+{
+ graph_info_t *ginfo = graph_infos_list;
+
+ while (NULL != ginfo) {
+ /* do not visit graphs that have 0 == ginfo->n_ctxs, since they
+ are not called */
+ if (0 != ginfo->n_ctxs) {
+ hnd (ginfo, env);
+ }
+
+ ginfo = ginfo->prev;
+ }
+}
+
+
+/*
+ Iterate of all allocs of a given graph info
+*/
+void ecg_iterate_allocs (graph_info_t *ginfo, alloc_hnd_t *hnd, void *env)
+{
+ alloc_info_t *ainfo = ginfo->allocs;
+
+ while (NULL != ainfo) {
+ hnd (ainfo, env);
+
+ ainfo = ainfo->prev;
+ }
+}
+
+
+/*
+ Iterate over all calls of the given graph info
+*/
+void ecg_iterate_calls (graph_info_t *ginfo, call_hnd_t *hnd, void *env)
+{
+ call_info_t *cinfo = ginfo->calls;
+
+ while (NULL != cinfo) {
+ hnd (cinfo, env);
+
+ cinfo = cinfo->prev;
+ }
+}
+
+
+/*
+ Iterate over all callEds of the given call info
+*/
+void ecg_iterate_callEds (call_info_t *cinfo, callEd_hnd_t *hnd, void *env)
+{
+ callEd_info_t *ced = cinfo->callEds;
+
+ while (NULL != ced) {
+ hnd (ced, env);
+
+ ced = ced->prev;
+ }
+}
+
/*
get the call infos for the given graph
return (ginfo);
}
+/*
+ Get the Alloc Infos for the given graph
+*/
+alloc_info_t *ecg_get_alloc_info (ir_graph *graph)
+{
+ graph_info_t *ginfo = ecg_get_info (graph);
+
+ return (ginfo->allocs);
+}
+
+/*
+ Get the Call Info for the given call
+*/
+callEd_info_t *ecg_get_callEd_info (ir_node *call)
+{
+ ir_graph *graph = get_irn_irg (call);
+ graph_info_t *ginfo = ecg_get_info (graph);
+
+ call_info_t *call_info = ginfo->calls;
+
+ while (NULL != call_info) {
+ if (call == call_info->call) {
+ return (call_info->callEds);
+ }
+
+ call_info = call_info->prev;
+ }
+
+ return (NULL);
+}
/**
*/
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 =
(get_irg_entity (graph)) == stickyness_sticky) ?
"red" : "lightyellow";
- graph_info_t *ginfo = (graph_info_t*) pmap_get (graph_infos, graph);
+ /* graph_info_t *ginfo = (graph_info_t*) pmap_get (graph_infos, graph); */
+ graph_info_t *ginfo = ecg_get_info (graph);
if (0 != ginfo->ecg_seen) {
fprintf (dot, "\t/* recursive call to \"%s\" (%d) */\n",
assert (0L <= _graphs);
- const int graph_no = _graphs ++;
+ graph_no = _graphs ++;
ginfo->ecg_seen = graph_no;
fprintf (dot, "\t/* Graph of \"%s.%s\" */\n",
get_type_name (get_entity_owner (get_irg_entity (graph))),
name);
- fprintf (dot, "\tgraph_%i [label=\"%s\\l%s\", color=\"%s\"];\n",
+ fprintf (dot, "\tgraph_%i [label=\"<HEAD>%s\\l%s\\l|<CTX>n_ctx = %i\\l\", color=\"%s\"];\n",
graph_no,
get_type_name (get_entity_owner (get_irg_entity (graph))),
name,
+ ginfo->n_ctxs,
color);
fprintf (dot, "\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) ? "blue" :
+ (NULL == ced->prev) ? "lightblue" : "blue3";
- fprintf (dot, "\t/* Call 0x%08x */\n", (int) call);
- fprintf (dot, "\tcall_%i [label=\"call\\l0x%08x\"];\n",
- call_no, (int) call);
+ fprintf (dot, "\t/* Call %li */\n", get_irn_node_nr (call));
+ fprintf (dot, "\tcall_%i [label=\"call\\[%li\\]\", color=\"%s\", shape=\"ellipse\"];\n",
+ call_no, get_irn_node_nr (call), call_color);
fprintf (dot, "\tgraph_%i -> call_%i [color=\"black\"];\n", graph_no, call_no);
while (NULL != ced) {
callEd_name);
/* Check for recursive calls */
/* if (callEd_no > graph_no) */ { /* do recursive calls (for now) */
- fprintf (dot, "\tcall_%i -> graph_%i [color=\"%s\", dir=\"%s\"];\n",
+ fprintf (dot, "\tcall_%i -> graph_%i:HEAD [color=\"%s\", dir=\"%s\"];\n",
call_no, callEd_no, callEd_color, direction);
}
} /* done all calls (graph) */
/* now the allocs */
- alloc_info_t *ainfo = ginfo->allocs;
+ ainfo = ecg_get_alloc_info (graph);
if (ainfo) {
fprintf (dot, "\t/* now the allocs */\n");
} else {
const char *name = get_type_name (ainfo->tp);
const char *color = "red1";
- /* if (0 == ginfo->allocs_seen) { */
_allocs ++;
- fprintf (dot, "\talloc_0x%08x_%i [label=\"%s\", color=\"%s\"]\n",
- (int) alloc, graph_no, name, color);
- /* } */
+ fprintf (dot, "\talloc_0x%08x_%i [label=\"%s\", color=\"%s\"];\n",
+ (int) alloc, graph_no, name, color);
- fprintf (dot, "\tgraph_%i -> alloc_0x%08x_%i\n", graph_no, (int) alloc, graph_no);
+ fprintf (dot, "\tgraph_%i -> alloc_0x%08x_%i;\n",
+ graph_no, (int) alloc, graph_no);
ainfo = ainfo->prev;
}
ginfo->allocs_seen = 1;
}
+ /* write table of ctxs */
+ {
+ 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];
+
+ 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, "|");
+ }
+ }
+
+ 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_%i:CTX -> ctx_%i:HEAD [label=\"ctx\", dir=\"none\", style=\"dotted\"];\n",
+ graph_no, graph_no);
+ }
+
fprintf (dot, "\t/* done with graph of \"%s\" */\n\n", name);
fflush (dot);
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;
}
/* ====================
- Public Interface
- ==================== */
+ Public Interface
+ ==================== */
/**
Initialise our data structures.
graph_infos = pmap_create ();
ecg_fill_calls ();
+ ecg_fill_ctxs ();
+ ecg_ecg ();
}
/**
Clean up our mess.
*/
-void ecg_cleanup ()
+void ecg_cleanup (void)
{
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) {
- free (cinfo->callEds);
- cinfo->call = NULL;
-
callEd_info_t *ced = cinfo->callEds;
+ cinfo->call = NULL;
+
while (NULL != ced) {
callEd_info_t *nced = ced->prev;
free (ced);
ced = nced;
}
- /* Todo: delete callEds */
cinfo->callEds = NULL;
free (cinfo);
pmap_destroy (graph_infos);
- /* BEGIN mild paranoia mode */
+ /* paranoia mode */
graph_infos = NULL;
- /* END mild paranoia mode */
}
/**
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\\l0x%08x\"];\n",
- (int) 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);
+
+ ainfo = ainfo->prev;
+ }
+ /* 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>", (int) 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, "|");
+ }
+ }
- while (NULL != ainfo) {
- ir_node *alloc = ainfo->alloc;
- const char *name = get_type_name (ainfo->tp);
- const char *color = "green3";
+ if (0 < ginfo->n_ctxs - max_ctxs) {
+ fprintf (dot, "(%i more)\\l", ginfo->n_ctxs - max_ctxs);
+ }
- 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);
+ fprintf (dot, "\", color=\"green3\"];\n");
- ainfo = ainfo->prev;
- }
+ fprintf (dot,
+ "\tgraph_0x%08x -> ctx_0x%08x:HEAD [label=\"ctx\", dir=\"none\", style=\"dotted\"];\n",
+ (int) graph, (int) graph);
+ }
+ } else {
+ fprintf (dot, "\t/* graph is not called */\n");
+ } /* end all graphs */
}
fprintf (dot, "}\n");
get_entity_name (_max_callEds_callR));
*/
fclose (dot);
-
- ecg_ecg ();
}
/**
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';
+ memset (spaces, '.', BUF_SIZE);
+ spaces [BUF_SIZE-1] = '\0';
- ecg_ecg_count (main_graph);
- fprintf (stdout, "n_graphs: %i\n", _graphs);
- fprintf (stdout, "max_depth = %i\n", _max_depth);
+ ecg_ecg_count (main_graph);
+ fprintf (stdout, "n_graphs: %i\n", _graphs);
+ fprintf (stdout, "max_depth = %i\n", _max_depth);
*/
/* return; */
_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.18 2005/01/14 14:14:43 liekweg
+ fix gnu extension
+
+ Revision 1.17 2005/01/14 13:34:25 liekweg
+ Factor out call_info_t ctor; fix mallocs; fix initialisation
+
+ Revision 1.16 2005/01/10 17:26:34 liekweg
+ fixup printfs, don't put environments on the stack
+
+ Revision 1.15 2004/12/23 15:40:03 beck
+ used new xcalloc
+
+ Revision 1.14 2004/12/22 14:43:14 beck
+ made allocations C-like
+
+ 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
+
+ Revision 1.6 2004/11/24 14:53:55 liekweg
+ Bugfixes
+
+ Revision 1.5 2004/11/20 21:20:29 liekweg
+ Added iterator functions
+
+ Revision 1.4 2004/11/18 16:36:37 liekweg
+ Added unique ids for debugging, added access functions
+
Revision 1.3 2004/11/04 14:54:44 liekweg
Nicer Colors
projects / libfirm / blobdiff