X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana2%2Fecg.c;h=0cfce80cc01af42dab9afa32aa7388c2b807fd7d;hb=eed631acbd6c80303182a0971ba3462632f5f7c9;hp=e71c7e1a67a03a1ce07ad8fe61190a471db7eba8;hpb=f001e5b3cb89f984c977a9f7d4aef02cc3cc56eb;p=libfirm

diff --git a/ir/ana2/ecg.c b/ir/ana2/ecg.c
index e71c7e1a6..0cfce80cc 100644
--- a/ir/ana2/ecg.c
+++ b/ir/ana2/ecg.c
@@ -82,7 +82,7 @@ void set_main_ctx (ctx_info_t*);
    ==================== */
 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;
@@ -96,12 +96,29 @@ static void append_alloc (graph_info_t *ginfo, ir_node *alloc, type *tp)
 /* ====================
    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;
@@ -114,21 +131,19 @@ static callEd_info_t *append_callEd_info (callEd_info_t *ced, ir_graph *callEd)
 */
 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);
   }
+
 }
 
 /**
@@ -136,10 +151,8 @@ static void append_calls (graph_info_t *info, ir_node *call, lset_t *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);
@@ -223,6 +236,7 @@ static void _collect_implementing_graphs (entity *method, lset_t *set)
 */
 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);
@@ -243,7 +257,7 @@ static lset_t *get_implementing_graphs (entity *method, ir_node *select)
   }
 
   /* void *tmp = lset_first (set); */
-  int n_graphs = lset_n_entries (set);
+  n_graphs = lset_n_entries (set);
 
   /* typalise select_in */
   if (do_typalise) {
@@ -256,9 +270,10 @@ static lset_t *get_implementing_graphs (entity *method, ir_node *select)
     /* 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",
@@ -292,23 +307,25 @@ static lset_t *get_implementing_graphs (entity *method, ir_node *select)
 */
 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);
@@ -331,7 +348,7 @@ static void ecg_calls_act (ir_node *node, void *env)
       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); */
 
@@ -346,17 +363,19 @@ static void ecg_calls_act (ir_node *node, void *env)
 */
 static void ecg_fill_graph_calls (ir_graph *graph)
 {
-  graph_info_t *ginfo = (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->ecg_seen = 0;
-  ginfo->ctxs   = NULL;
-  ginfo->n_ctxs = 0;
-  ginfo->prev   = NULL;
+  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;
 
   /* link up into global list */
   ginfo->prev = graph_infos_list;
@@ -408,9 +427,9 @@ static void ecg_fill_ctxs_count (ir_graph *graph)
 
   /* 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;
@@ -422,7 +441,7 @@ static void ecg_fill_ctxs_count (ir_graph *graph)
         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;
@@ -441,7 +460,7 @@ static void ecg_fill_ctxs_alloc (void)
   graph_info_t *ginfo = graph_infos_list;
 
   while (NULL != ginfo) {
-    ginfo->ctxs = (ctx_info_t **) xmalloc (ginfo->n_ctxs * sizeof (ctx_info_t*));
+    ginfo->ctxs = xcalloc (ginfo->n_ctxs, sizeof (ctx_info_t *));
 
     /*
       fprintf (stdout, "graph of \"%s\": n_ctxs = %i\n",
@@ -463,8 +482,8 @@ static void ecg_fill_ctxs_write (ir_graph *graph, ctx_info_t *enc_ctx)
 
   /* 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;
@@ -480,7 +499,7 @@ static void ecg_fill_ctxs_write (ir_graph *graph, ctx_info_t *enc_ctx)
         callEd_info->ctxs [callEd_info->n_ctxs] = ctx;
         callEd_info->n_ctxs ++;
 
-        /* Calling graph -> callEd_graph */
+        /* CallR graph -> callEd_graph */
         ecg_fill_ctxs_write (callEd_graph, ctx);
 
         ced = ced->prev;
@@ -498,18 +517,22 @@ static void ecg_fill_ctxs_write (ir_graph *graph, ctx_info_t *enc_ctx)
 */
 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 ();
 
-  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 = xcalloc (1, sizeof (ctx_info_t *));
   ginfo->ctxs [0] = main_ctx;
 
   ecg_fill_ctxs_write (main_irg, main_ctx);
@@ -523,10 +546,10 @@ static void ecg_fill_ctxs (void)
 */
 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,
@@ -687,6 +710,9 @@ callEd_info_t *ecg_get_callEd_info (ir_node *call)
 */
 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 =
@@ -709,7 +735,7 @@ static int ecg_ecg_graph (FILE *dot, ir_graph *graph)
 
   assert (0L <= _graphs);
 
-  const int graph_no = _graphs ++;
+  graph_no = _graphs ++;
   ginfo->ecg_seen = graph_no;
 
   fprintf (dot, "\t/* Graph of \"%s.%s\" */\n",
@@ -730,12 +756,13 @@ static int ecg_ecg_graph (FILE *dot, ir_graph *graph)
     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",
@@ -767,7 +794,7 @@ static int ecg_ecg_graph (FILE *dot, ir_graph *graph)
   } /* 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 {
@@ -795,12 +822,12 @@ static int ecg_ecg_graph (FILE *dot, ir_graph *graph)
 
   /* 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];
@@ -846,6 +873,8 @@ static char spaces [BUF_SIZE];
 
 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) {
@@ -871,7 +900,7 @@ static void ecg_ecg_count (ir_graph *graph)
     }
   */
 
-  const int graph_no = _graphs ++;
+  graph_no = _graphs ++;
   ginfo->ecg_seen = graph_no;
 
   fprintf (stdout, "%sMethod \"%s.%s\"\n",
@@ -879,7 +908,7 @@ static void ecg_ecg_count (ir_graph *graph)
            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;
@@ -928,12 +957,12 @@ void ecg_init (int typalise)
 /**
    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);
 
@@ -941,10 +970,10 @@ void ecg_cleanup ()
     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);
@@ -980,84 +1009,127 @@ void ecg_report ()
   FILE *dot = fopen ("calls.dot", "w");
 
   fprintf (dot, "digraph \"calls\" {\n");
-  fprintf (dot, "\tgraph [rankdir=\"LR\", ordering=\"out\"];\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, "\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>", (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, "|");
+          }
+        }
 
-      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",
+                 (int) graph, (int) graph);
+      }
+    } else {
+      fprintf (dot, "\t/* graph is not called */\n");
+    } /* end all graphs */
   }
   fprintf (dot, "}\n");
 
@@ -1072,13 +1144,14 @@ void ecg_report ()
 /**
    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';
@@ -1093,16 +1166,13 @@ void ecg_ecg ()
   _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 (); */
@@ -1123,6 +1193,30 @@ void ecg_ecg ()
 
 /*
   $Log$
+  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