X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana2%2Fecg.c;h=7195428b0adfd7ec66215b70f683c5e4f678b27c;hb=ff244fb7355c6120cf0f15ba7911b473bb91c64b;hp=7774587edf06b55bb91ecc987a2a348d143f0f10;hpb=41b022e5d3a77bd3743f6a7b4444b13179dbd2e0;p=libfirm

diff --git a/ir/ana2/ecg.c b/ir/ana2/ecg.c
index 7774587ed..7195428b0 100644
--- a/ir/ana2/ecg.c
+++ b/ir/ana2/ecg.c
@@ -7,18 +7,20 @@
  * 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
 
+#include <assert.h>
+
 /**
    Erweiterter Aufrufgraph.
- */
+*/
 
 #include "irnode.h"
 #include "pmap.h"
@@ -28,6 +30,8 @@
 #include "irvrfy.h"
 #include "trvrfy.h"
 #include "xmalloc.h"
+#include "irdump.h"
+#include "irprog_t.h"
 
 # ifndef TRUE
 #  define TRUE 1
@@ -40,21 +44,32 @@
 # 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;
@@ -65,12 +80,15 @@ static int _max_depth = 0;
 static int _max_callEds = 0;
 static entity* _max_callEds_callR = NULL;
 
+/* Protos */
+void set_main_ctx (ctx_info_t*);
+
 /* ====================
-  Alloc stuff
-  ==================== */
-static void append_alloc (graph_info_t *ginfo, ir_node *alloc, type *tp)
+   Alloc stuff
+   ==================== */
+static void append_alloc (graph_info_t *ginfo, ir_node *alloc, ir_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;
@@ -82,14 +100,31 @@ static void append_alloc (graph_info_t *ginfo, ir_node *alloc, type *tp)
 
 
 /* ====================
-  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;
@@ -102,21 +137,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);
   }
+
 }
 
 /**
@@ -124,10 +157,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);
@@ -211,6 +242,10 @@ static void _collect_implementing_graphs (entity *method, lset_t *set)
 */
 static lset_t *get_implementing_graphs (entity *method, ir_node *select)
 {
+  /* const char *name = get_entity_name (method); */
+  /* fprintf (stdout, "%s (ent %s)\n", __FUNCTION__, name); */
+
+  int n_graphs;
   lset_t *set = lset_create ();
   {
     ir_graph *impl = _get_implementing_graph (method);
@@ -231,32 +266,78 @@ 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);
 
+
+  if (visibility_external_allocated != get_entity_visibility (method)) {
+    if (0 == n_graphs) {
+      ir_graph *graph = get_irn_irg (select);
+
+      dump_ir_block_graph (graph, "-typealise");
+
+      /* fprintf (stdout, "no graphs for method %s\n", get_entity_name (method)); */
+      assert (n_graphs && "no graphs for method");
+    }
+  }
   /* typalise select_in */
   if (do_typalise) {
     ir_node *select_in = get_Sel_ptr (select);
     typalise_t *ta = typalise (select_in);
-    assert (ta && "typalise failed (go figure)");
+    /* assert (ta && "typalise failed (go figure)"); */
 
-    /* const char *res = ta_name (ta); */
-
-    /* fprintf (stdout, "typalyse res = %s\n", res); */
+    /*
+    fprintf (stdout, "typalyse res = ");
+
+    if (NULL != ta) {
+      if (type_invalid == ta->kind) {
+        fprintf (stdout, "invalid");
+      } else if (type_exact == ta->kind) {
+        const char *name = get_type_name (ta->res.type);
+
+        fprintf (stdout, "exact [");
+        fprintf (stdout, "%s", name);
+        fprintf (stdout, "]\n");
+      } else if (type_types == ta->kind) {
+        fprintf (stdout, "types [");
+        fprintf (stdout, "...");
+        fprintf (stdout, "]\n");
+      } else if (type_type == ta->kind) {
+        const char *name = get_type_name (ta->res.type);
+        fprintf (stdout, "type [");
+        fprintf (stdout, "%s", name);
+        fprintf (stdout, "]\n");
+      }
+    } else {
+      fprintf (stdout, "(null)\n");
+    }
+    */
 
     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;
     }
+
+    if (visibility_external_allocated != get_entity_visibility (method)) {
+      if (0 == n_graphs) {
+        ir_graph *graph = get_irn_irg (select);
+
+        dump_ir_block_graph (graph, "-ecg");
+        /* fprintf (stdout, "no graphs for method %s\n", get_entity_name (method)); */
+        assert (n_graphs && "no graphs for method");
+      }
+    }
+
   }
 
   if (n_graphs > _max_callEds) {
@@ -265,14 +346,22 @@ static lset_t *get_implementing_graphs (entity *method, ir_node *select)
   }
 
 
-  if (visibility_external_allocated != get_entity_visibility (method)) {
-    if (0 == n_graphs) {
-      /* fprintf (stdout, "no graphs for method %s\n", get_entity_name (method)); */
-      assert (n_graphs && "no graphs for method");
-    }
+  return (set);
+}
+
+/**
+   Determine whether a call is actually a call or if it is being
+   abused for some b/d-ed reason.
+*/
+static int call_is_call (ir_node *call, ir_node *ptr)
+{
+  if (op_SymConst != get_irn_op (ptr)) {
+    return (TRUE);
+  } else if (get_SymConst_kind (ptr) != symconst_addr_name) {
+    return (TRUE);
   }
 
-  return (set);
+  return (FALSE);
 }
 
 /**
@@ -280,23 +369,33 @@ 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);
 
+    if (!call_is_call (node, ptr)) {
+      /*
+      fprintf (stdout, "not a call: %s[%li]\n",
+               get_op_name (get_irn_op (node)),
+               get_irn_node_nr (node)); */
+      return;
+    }
+
     /* 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);
@@ -319,13 +418,13 @@ static void ecg_calls_act (ir_node *node, void *env)
       DDMN (ptr);
       assert (0 && "Unexpected address expression");
     }
-  } else if (iro_Alloc == op) {
-    type *tp = get_Alloc_type (node);
-    const char *name = get_type_name (tp);
+  } else if (op_Alloc == op) {
+    ir_type *tp = get_Alloc_type (node);
+    /* const char *name = get_type_name (tp); */
 
     append_alloc (graph_info, node, tp);
 
-    fprintf (stdout, "NEW \"%s\"\n", name);
+    /* fprintf (stdout, "NEW \"%s\"\n", name); */
   }
 }
 
@@ -334,18 +433,29 @@ static void ecg_calls_act (ir_node *node, void *env)
 */
 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);
 }
 
 /**
@@ -362,9 +472,264 @@ static void ecg_fill_calls (void)
   }
 }
 
+/**
+   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);
+}
+
+/* ====================
+   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
+   ==================== */
+
 /* ====================
-  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
@@ -378,6 +743,36 @@ graph_info_t *ecg_get_info (ir_graph *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);
+}
 
 
 /**
@@ -385,6 +780,9 @@ graph_info_t *ecg_get_info (ir_graph *graph)
 */
 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 =
@@ -392,7 +790,8 @@ static int ecg_ecg_graph (FILE *dot, ir_graph *graph)
      (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",
@@ -406,16 +805,17 @@ 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",
            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");
 
@@ -426,15 +826,17 @@ 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) ? "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) {
@@ -450,7 +852,7 @@ static int ecg_ecg_graph (FILE *dot, ir_graph *graph)
                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);
       }
 
@@ -462,7 +864,7 @@ static int ecg_ecg_graph (FILE *dot, ir_graph *graph)
   } /* 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 {
@@ -474,13 +876,12 @@ static int ecg_ecg_graph (FILE *dot, ir_graph *graph)
     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;
   }
@@ -489,6 +890,44 @@ static int ecg_ecg_graph (FILE *dot, ir_graph *graph)
     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);
@@ -504,6 +943,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) {
@@ -529,7 +970,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",
@@ -537,7 +978,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;
@@ -566,8 +1007,8 @@ static void ecg_ecg_count (ir_graph *graph)
 }
 
 /* ====================
-  Public Interface
-  ==================== */
+   Public Interface
+   ==================== */
 
 /**
    Initialise our data structures.
@@ -576,18 +1017,26 @@ void ecg_init (int typalise)
 {
   do_typalise = typalise;
 
+  if (typalise) {
+    typalise_init ();
+  }
+
   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);
 
@@ -595,11 +1044,10 @@ void ecg_cleanup ()
     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);
@@ -608,7 +1056,6 @@ void ecg_cleanup ()
         ced = nced;
       }
 
-      /* Todo: delete callEds */
       cinfo->callEds = NULL;
 
       free (cinfo);
@@ -622,9 +1069,8 @@ void ecg_cleanup ()
 
   pmap_destroy (graph_infos);
 
-  /* BEGIN mild paranoia mode */
+  /*  paranoia mode */
   graph_infos = NULL;
-  /* END mild paranoia mode */
 }
 
 /**
@@ -637,84 +1083,127 @@ void ecg_report ()
   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 = "red1";
+        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");
 
@@ -724,27 +1213,26 @@ void ecg_report ()
     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; */
@@ -752,16 +1240,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 (); */
@@ -782,6 +1267,66 @@ void ecg_ecg ()
 
 /*
   $Log$
+  Revision 1.22  2006/01/13 22:55:03  beck
+  renamed all types 'type' to 'ir_type'
+
+  Revision 1.21  2005/12/31 15:58:57  beck
+  added missing includes
+
+  Revision 1.20  2005/12/05 12:01:06  beck
+  needed include added
+
+  Revision 1.19  2005/03/22 13:55:51  liekweg
+  Need to initialise typalise now
+
+  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
+
   Revision 1.2  2004/10/21 11:09:37  liekweg
   Moved memwalk stuf into irmemwalk
   Moved lset stuff into lset