X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firdump.c;h=bd5c5baeebc6d7e18e1a62f15eb7459d3baa23db;hb=8399216d8aebc713bbda04b6e3e250a1d52b20bf;hp=48b9e4a17df8b55d69612f5688053555b3a379f5;hpb=f36eff5b242be9f055e310b2c960a4e5170b7968;p=libfirm

diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c
index 48b9e4a17..bd5c5baee 100644
--- a/ir/ir/irdump.c
+++ b/ir/ir/irdump.c
@@ -9,10 +9,16 @@
  * Copyright:   (c) 1998-2003 Universität Karlsruhe
  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
 
-
+#ifdef HAVE_STRING_H
 #include <string.h>
+#endif
+#ifdef HAVE_STDLIB_H
 #include <stdlib.h>
+#endif
 #include <stdarg.h>
 
 #include "firm_common_t.h"
@@ -40,10 +46,11 @@
 #include "array.h"
 #include "pmap.h"
 #include "eset.h"
+#include "pset.h"
 
 #if DO_HEAPANALYSIS
-void dump_chi_term(FILE *FL, ir_node *n);
-void dump_state(FILE *FL, ir_node *n);
+void dump_irn_chi_term(FILE *FL, ir_node *n);
+void dump_irn_state(FILE *FL, ir_node *n);
 int  get_opt_dump_abstvals(void);
 typedef unsigned long SeqNo;
 SeqNo get_Block_seqno(ir_node *n);
@@ -59,7 +66,7 @@ static int base_color = 0;
  * returns the name of a mode or <ERROR> if mode is NOT a mode object.
  * in the later case, sets bad
  */
-static const char *get_mode_name_ex(ir_mode *mode, int *bad)
+const char *get_mode_name_ex(ir_mode *mode, int *bad)
 {
   if (is_mode(mode))
     return get_mode_name(mode);
@@ -71,7 +78,7 @@ static const char *get_mode_name_ex(ir_mode *mode, int *bad)
  * returns the name of a type or <ERROR> if mode is NOT a mode object.
  * in the later case, sets bad
  */
-static const char *get_type_name_ex(type *tp, int *bad)
+const char *get_type_name_ex(type *tp, int *bad)
 {
   if (is_type(tp))
     return get_type_name(tp);
@@ -283,18 +290,10 @@ static void clear_link(ir_node * node, void * env) {
   ird_set_irn_link(node, NULL);
 }
 
-/**
- * Returns non-zero if a node is in floating state.
- */
-static int node_floats(ir_node *n) {
-  return ((get_irn_pinned(n) == op_pin_state_floats) &&
-      (get_irg_pinned(current_ir_graph) == op_pin_state_floats));
-}
-
 /**
  * If the entity has a ld_name, returns it, else returns the name of the entity.
  */
-static const char *get_ent_dump_name(entity *ent) {
+const char *get_ent_dump_name(entity *ent) {
   if (!ent)
     return "<NULL entity>";
   /* Don't use get_entity_ld_ident (ent) as it computes the mangled name! */
@@ -309,6 +308,14 @@ const char *get_irg_dump_name(ir_graph *irg) {
   return get_ent_dump_name(ent);
 }
 
+/**
+ * Returns non-zero if a node is in floating state.
+ */
+static int node_floats(ir_node *n) {
+  return ((get_irn_pinned(n) == op_pin_state_floats) &&
+      (get_irg_pinned(current_ir_graph) == op_pin_state_floats));
+}
+
 /**
  * Walker, allocates an array for all blocks and puts it's nodes non-floating nodes into this array.
  */
@@ -324,8 +331,18 @@ static void collect_node(ir_node * node, void *env) {
     ird_set_irg_link(get_irn_irg(node), arr);    /* arr is an l-value, APP_ARR might change it! */
   } else {
     ir_node * block = get_nodes_block(node);
-    ird_set_irn_link(node, ird_get_irn_link(block));
-    ird_set_irn_link(block, node);
+
+    if (is_Bad(block)) {
+      /* this node is in a Bad block, so we must place it into the graph's list */
+      ir_node ** arr = (ir_node **) ird_get_irg_link(get_irn_irg(node));
+      if (!arr) arr = NEW_ARR_F(ir_node *, 0);
+      ARR_APP1(ir_node *, arr, node);
+      ird_set_irg_link(get_irn_irg(node), arr);    /* arr is an l-value, APP_ARR might change it! */
+    }
+    else {
+      ird_set_irn_link(node, ird_get_irn_link(block));
+      ird_set_irn_link(block, node);
+    }
   }
 }
 
@@ -349,10 +366,12 @@ static ir_node ** construct_block_lists(ir_graph *irg) {
 
   /* Collect also EndReg and EndExcept. We do not want to change the walker. */
   set_interprocedural_view(false);
+
   set_irg_visited(current_ir_graph, get_irg_visited(current_ir_graph)-1);
   irg_walk(get_irg_end_reg(current_ir_graph), clear_link, collect_node, current_ir_graph);
   set_irg_visited(current_ir_graph, get_irg_visited(current_ir_graph)-1);
   irg_walk(get_irg_end_except(current_ir_graph), clear_link, collect_node, current_ir_graph);
+
   set_interprocedural_view(rem_view);
 
   current_ir_graph = rem;
@@ -414,8 +433,8 @@ void dump_consts_local(bool b) {
   dump_const_local = b;
 }
 
-void turn_off_constant_entity_values(void) {
-  const_entities = 0;
+void dump_constant_entity_values(bool b) {
+  const_entities = b;
 }
 
 void dump_keepalive_edges(bool b) {
@@ -426,20 +445,16 @@ bool get_opt_dump_keepalive_edges(void) {
   return dump_keepalive;
 }
 
-void dump_out_edges(void) {
-  dump_out_edge_flag = 1;
+void dump_out_edges(bool b) {
+  dump_out_edge_flag = b;
 }
 
-void dump_dominator_information(void) {
-  dump_dominator_information_flag = 1;
+void dump_dominator_information(bool b) {
+  dump_dominator_information_flag = b;
 }
 
-void dump_loop_information(void) {
-  dump_loop_information_flag = 1;
-}
-
-void dont_dump_loop_information(void) {
-  dump_loop_information_flag = 0;
+void dump_loop_information(bool b) {
+  dump_loop_information_flag = b;
 }
 
 void dump_backedge_information(bool b) {
@@ -596,7 +611,7 @@ static int dump_node_typeinfo(FILE *F, ir_node *n) {
     if (get_irg_typeinfo_state(current_ir_graph) == irg_typeinfo_consistent  ||
         get_irg_typeinfo_state(current_ir_graph) == irg_typeinfo_inconsistent) {
       type *tp = get_irn_typeinfo_type(n);
-      if (tp != none_type)
+      if (tp != firm_none_type)
         fprintf(F, " [%s]", get_type_name_ex(tp, &bad));
       else
         fprintf(F, " []");
@@ -650,17 +665,21 @@ dump_node_nodeattr(FILE *F, ir_node *n)
  * dumps the attributes of a node n into the file F.
  * Currently this is only the color of a node.
  */
-static void dump_node_vcgattr(FILE *F, ir_node *n, int bad)
+static void dump_node_vcgattr(FILE *F, ir_node *node, ir_node *local, int bad)
 {
+  ir_node *n;
+
   if (bad) {
     fprintf(F, "color: red");
     return;
   }
 
   if (dump_node_vcgattr_hook)
-    if (dump_node_vcgattr_hook(F, n))
+    if (dump_node_vcgattr_hook(F, node, local))
       return;
 
+  n = local ? local : node;
+
   switch (get_irn_opcode(n)) {
   case iro_Start:
   case iro_EndReg:
@@ -671,7 +690,10 @@ static void dump_node_vcgattr(FILE *F, ir_node *n, int bad)
     fprintf (F, "color: blue");
     break;
   case iro_Block:
-    fprintf (F, "color: lightyellow");
+    if (is_Block_dead(n))
+      fprintf (F, "color: lightred");
+    else
+      fprintf (F, "color: lightyellow");
     break;
   case iro_Phi:
     fprintf (F, "color: green");
@@ -689,193 +711,15 @@ static void dump_node_vcgattr(FILE *F, ir_node *n, int bad)
   if (overrule_nodecolor) fprintf(F, " color: %s", overrule_nodecolor);
 }
 
+
 /**
  * Dump the node information of a node n to a file F.
  */
 static INLINE int dump_node_info(FILE *F, ir_node *n)
-{
-  int i, bad = 0;
-  char comma;
-  ir_graph *irg;
-
+{ int bad = 0;
   fprintf (F, " info1: \"");
-  if (opt_dump_pointer_values_to_info)
-    fprintf (F, "addr:    %p \n", (void *)n);
-  fprintf (F, "mode:    %s\n", get_mode_name(get_irn_mode(n)));
-  fprintf (F, "visited: %ld \n", get_irn_visited(n));
-  irg = get_irn_irg(n);
-  if (irg != get_const_code_irg())
-    fprintf (F, "irg:     %s\n", get_ent_dump_name(get_irg_entity(irg)));
-
-  if (get_irn_pinned(n) == op_pin_state_floats &&
-      get_irg_pinned(get_irn_irg(n)) == op_pin_state_floats) {
-    fprintf(F, "node was pinned in ");
-    dump_node_opcode(F, get_nodes_block(n));
-    fprintf(F, " %ld\n", get_irn_node_nr(get_nodes_block(n)));
-  }
-
-#if 0
-  /* show all predecessor nodes */
-  fprintf(F, "pred nodes: \n");
-  if (!is_Block(n)) {
-    fprintf(F, "  -1: ");
-    dump_node_opcode(F, get_nodes_block(n));
-    fprintf(F, " %ld\n", get_irn_node_nr(get_nodes_block(n)));
-  }
-  for ( i = 0; i < get_irn_arity(n); ++i) {
-    fprintf(F, "   %d: ", i);
-    dump_node_opcode(F, get_irn_n(n, i));
-    fprintf(F, " %ld\n", get_irn_node_nr(get_irn_n(n, i)));
-  }
-#endif
-
-  fprintf(F, "arity: %d", get_irn_arity(n));
-  if ((get_irn_op(n) == op_Block) ||
-      (get_irn_op(n) == op_Phi) ||
-      ((get_irn_op(n) == op_Filter) && get_interprocedural_view())) {
-    fprintf(F, " backedges:");
-    comma = ' ';
-    for (i = 0; i < get_irn_arity(n); i++)
-      if (is_backedge(n, i)) { fprintf(F, "%c %d", comma, i); comma = ','; }
-  }
-  fprintf(F, "\n");
-
-  /* Loop node   Someone else please tell me what's wrong ...
-  if (get_irn_loop(n)) {
-    ir_loop *loop = get_irn_loop(n);
-    assert(loop);
-    fprintf(F, " in loop %d with depth %d\n",
-        get_loop_loop_nr(loop), get_loop_depth(loop));
-  }
-  */
-
-  /* Source types */
-  switch (get_irn_opcode(n)) {
-  case iro_Start: {
-    type *tp = get_entity_type(get_irg_entity(get_irn_irg(n)));
-    fprintf(F, "start of method of type %s \n", get_type_name_ex(tp, &bad));
-    for (i = 0; i < get_method_n_params(tp); ++i)
-      fprintf(F, "  param %d type: %s \n", i, get_type_name_ex(get_method_param_type(tp, i), &bad));
-    if ((get_irp_ip_view_state() == ip_view_valid) && !get_interprocedural_view()) {
-      ir_node *sbl = get_nodes_block(n);
-      int i, n_cfgpreds = get_Block_cg_n_cfgpreds(sbl);
-      fprintf(F, "graph has %d interprocedural predecessors:\n", n_cfgpreds);
-      for (i = 0; i < n_cfgpreds; ++i) {
-        ir_node *cfgpred = get_Block_cg_cfgpred(sbl, i);
-        fprintf(F, "  %d: Call %ld in graph %s\n", i, get_irn_node_nr(cfgpred),
-                get_irg_dump_name(get_irn_irg(cfgpred)));
-      }
-    }
-  } break;
-  case iro_Alloc: {
-    fprintf(F, "allocating entity of type %s \n", get_type_name_ex(get_Alloc_type(n), &bad));
-  } break;
-  case iro_Free: {
-    fprintf(F, "freeing entity of type %s \n", get_type_name_ex(get_Free_type(n), &bad));
-  } break;
-  case iro_Sel: {
-    entity *ent = get_Sel_entity(n);
-
-    if (ent) {
-      fprintf(F, "Selecting entity of type %s\n", get_type_name_ex(get_entity_type(ent), &bad));
-      fprintf(F, "  from entity of type %s\n", get_type_name_ex(get_entity_owner(ent), &bad));
-    }
-    else {
-      fprintf(F, "<NULL entity>\n");
-      bad = 1;
-    }
-  } break;
-  case iro_Call: {
-    type *tp = get_Call_type(n);
-    fprintf(F, "calling method of type %s \n", get_type_name_ex(tp, &bad));
-    if(get_unknown_type() != tp) {
-      for (i = 0; i < get_method_n_params(tp); ++i)
-	fprintf(F, "  param %d type: %s \n", i, get_type_name_ex(get_method_param_type(tp, i), &bad));
-      for (i = 0; i < get_method_n_ress(tp); ++i)
-	fprintf(F, "  resul %d type: %s \n", i, get_type_name_ex(get_method_res_type(tp, i), &bad));
-    }
-    if (Call_has_callees(n)) {
-      fprintf(F, "possible callees: \n");
-      for (i = 0; i < get_Call_n_callees(n); i++) {
-	fprintf(F, "  %d: %s\n", i, get_ent_dump_name(get_Call_callee(n, i)));
-      }
-    }
-  } break;
-  case iro_CallBegin: {
-    ir_node *call = get_CallBegin_call(n);
-    fprintf(F, "Call: %ld\n", get_irn_node_nr(call));
-    if (Call_has_callees(call)) {
-      fprintf(F, "possible callees: \n");
-      for (i = 0; i < get_Call_n_callees(call); i++) {
-	fprintf(F, "  %d: %s\n", i, get_ent_dump_name(get_Call_callee(call, i)));
-      }
-    }
-  } break;
-  case iro_Return: {
-    if (!get_interprocedural_view()) {
-      type *tp = get_entity_type(get_irg_entity(get_irn_irg(n)));
-      fprintf(F, "return in method of type %s \n", get_type_name_ex(tp, &bad));
-      for (i = 0; i < get_method_n_ress(tp); ++i)
-        fprintf(F, "  res %d type: %s \n", i, get_type_name_ex(get_method_res_type(tp, i), &bad));
-    }
-  } break;
-  case iro_Const: {
-    type *tp = get_Const_type(n);
-    assert(tp != none_type);
-    fprintf(F, "Const of type %s \n", get_type_name_ex(get_Const_type(n), &bad));
-  } break;
-  case iro_SymConst: {
-    switch(get_SymConst_kind(n)) {
-    case symconst_addr_name:
-      fprintf(F, "kind addr_name\n");
-      break;
-    case symconst_addr_ent:
-      fprintf(F, "kind addr_ent\n");
-      dump_entity_to_file(F, get_SymConst_entity(n), dump_verbosity_onlynames);
-      break;
-    case symconst_type_tag:
-      fprintf(F, "kind type_tag\n");
-      break;
-    case symconst_size:
-      fprintf(F, "kind size\n");
-      break;
-    }
-    fprintf(F, "SymConst of type %s \n", get_type_name_ex(get_SymConst_value_type(n), &bad));
-  } break;
-  case iro_Filter: {
-    int i;
-    if (get_interprocedural_view()) {
-      fprintf(F, "intra predecessor nodes:\n");
-      for (i = 0; i < get_irn_intra_arity(n); i++) {
-        ir_node *pred = get_irn_intra_n(n, i);
-        fprintf(F, "  %s%s %ld\n", get_irn_opname(pred), get_irn_modename(pred), get_irn_node_nr(pred));
-      }
-    } else {
-      fprintf(F, "inter predecessor nodes:\n");
-      for (i = 0; i < get_irn_inter_arity(n); i++) {
-        ir_node *pred = get_irn_inter_n(n, i);
-        fprintf(F, "  %s%s %ld \tin graph %s\n", get_irn_opname(pred), get_irn_modename(pred),
-        get_irn_node_nr(pred), get_ent_dump_name(get_irg_entity(get_irn_irg(pred))));
-      }
-    }
-  } break;
-  case iro_Load:
-    fprintf(F, "volatility: %s\n", get_volatility_name(get_Load_volatility(n)));
-    break;
-  case iro_Store:
-    fprintf(F, "volatility: %s\n", get_volatility_name(get_Store_volatility(n)));
-    break;
-
-  default: ;
-  }
-
-  if (get_irg_typeinfo_state(get_irn_irg(n)) == irg_typeinfo_consistent  ||
-      get_irg_typeinfo_state(get_irn_irg(n)) == irg_typeinfo_inconsistent  )
-    if (get_irn_typeinfo_type(n) != none_type)
-      fprintf (F, "\nAnalysed type: %s", get_type_name_ex(get_irn_typeinfo_type(n), &bad));
-
-  fprintf (F, "\"");
-
+  bad = dump_irnode_to_file(F, n);
+  fprintf(F, "\"\n");
   return bad;
 }
 
@@ -922,12 +766,44 @@ static void dump_const_node_local(FILE *F, ir_node *n) {
       fprintf(F, " %ld", get_irn_node_nr(con));
       fprintf(F, "\" ");
       bad |= dump_node_info(F, con);
-      dump_node_vcgattr(F, con, bad);
+      dump_node_vcgattr(F, n, con, bad);
       fprintf(F, "}\n");
     }
   }
 }
 
+/** If the block of an edge is a const_like node, dump it local with an edge */
+static void dump_const_block_local(FILE *F, ir_node *n) {
+  ir_node *blk;
+
+  if (!get_opt_dump_const_local()) return;
+
+  blk = get_nodes_block(n);
+  if (is_constlike_node(blk)) {
+    int bad = 0;
+
+    /* Generate a new name for the node by appending the names of
+       n and blk. */
+    fprintf(F, "node: {title: \""); PRINT_CONSTBLKID(n, blk);
+    fprintf(F, "\" label: \"");
+    bad |= dump_node_opcode(F, blk);
+    bad |= dump_node_mode(F, blk);
+    bad |= dump_node_typeinfo(F, blk);
+    fprintf (F, " ");
+    bad |= dump_node_nodeattr(F, blk);
+    fprintf(F, " %ld", get_irn_node_nr(blk));
+    fprintf(F, "\" ");
+    bad |= dump_node_info(F, blk);
+    dump_node_vcgattr(F, n, blk, bad);
+    fprintf(F, "}\n");
+
+    fprintf (F, "edge: { sourcename: \"");
+    PRINT_NODEID(n);
+    fprintf (F, "\" targetname: \""); PRINT_CONSTBLKID(n,blk);
+    fprintf (F, "\" "   BLOCK_EDGE_ATTR "}\n");
+  }
+}
+
 /**
  * prints the error message of a node to a file F as info2.
  */
@@ -947,7 +823,9 @@ static void dump_node(FILE *F, ir_node *n)
   int bad = 0;
   const char *p;
 
-  if (get_opt_dump_const_local() && is_constlike_node(n)) return;
+  if (get_opt_dump_const_local() && is_constlike_node(n))
+    return;
+
   /* dump this node */
   fprintf(F, "node: {title: \""); PRINT_NODEID(n); fprintf(F, "\" label: \"");
 
@@ -961,12 +839,12 @@ static void dump_node(FILE *F, ir_node *n)
   fprintf(F, "\" ");
   bad |= dump_node_info(F, n);
   print_node_error(F, p);
-  dump_node_vcgattr(F, n, bad);
+  dump_node_vcgattr(F, n, NULL, bad);
   fprintf(F, "}\n");
   dump_const_node_local(F, n);
 #if DO_HEAPANALYSIS
-  dump_chi_term(F, n);
-  dump_state(F, n);
+  dump_irn_chi_term(F, n);
+  dump_irn_state(F, n);
 #endif
 }
 
@@ -977,11 +855,16 @@ dump_ir_block_edge(FILE *F, ir_node *n)  {
   if (is_no_Block(n)) {
     ir_node *block = get_nodes_block(n);
 
-    fprintf (F, "edge: { sourcename: \"");
-    PRINT_NODEID(n);
-    fprintf (F, "\" targetname: ");
-    fprintf(F, "\""); PRINT_NODEID(block); fprintf(F, "\"");
-    fprintf (F, " "   BLOCK_EDGE_ATTR "}\n");
+    if (get_opt_dump_const_local() && is_constlike_node(block)) {
+      dump_const_block_local(F, n);
+    }
+    else {
+      fprintf (F, "edge: { sourcename: \"");
+      PRINT_NODEID(n);
+      fprintf (F, "\" targetname: ");
+      fprintf(F, "\""); PRINT_NODEID(block); fprintf(F, "\"");
+      fprintf (F, " "   BLOCK_EDGE_ATTR "}\n");
+    }
   }
 }
 
@@ -1129,7 +1012,8 @@ print_edge_vcgattr(FILE *F, ir_node *from, int to) {
 /* dump edges to our inputs */
 static void
 dump_ir_data_edges(FILE *F, ir_node *n)  {
-  int i, visited = get_irn_visited(n);
+  int i;
+  unsigned long visited = get_irn_visited(n);
 
   if ((get_irn_op(n) == op_End) && (!dump_keepalive))
     return;
@@ -1237,7 +1121,7 @@ dump_whole_block(FILE *F, ir_node *block) {
   fprintf(F, "}\n");
   dump_const_node_local(F, block);
 #if DO_HEAPANALYSIS
-  dump_chi_term(F, block);
+  dump_irn_chi_term(F, block);
 #endif
   fprintf(F, "\n");
 }
@@ -1260,6 +1144,9 @@ dump_block_graph(FILE *F, ir_graph *irg) {
     } else {
       /* Nodes that are not in a Block. */
       dump_node(F, node);
+      if (is_Bad(get_nodes_block(node)) && !node_floats(node)) {
+        dump_const_block_local(F, node);
+      }
       dump_ir_data_edges(F, node);
     }
   }
@@ -1273,7 +1160,7 @@ dump_block_graph(FILE *F, ir_graph *irg) {
 /** Dumps an irg as a graph.
  *  If interprocedural view edges can point to nodes out of this graph.
  */
-static void dump_graph(FILE *F, ir_graph *irg) {
+static void dump_graph_from_list(FILE *F, ir_graph *irg) {
 
   fprintf(F, "graph: { title: \"");
   PRINT_IRGID(irg);
@@ -1866,7 +1753,7 @@ FILE *vcg_open (ir_graph *irg, const char * suffix1, const char *suffix2) {
  * @param irg     The graph to be dumped
  * @param suffix  filename suffix
  */
-static FILE *vcg_open_name (const char *name, const char *suffix) {
+FILE *vcg_open_name (const char *name, const char *suffix) {
   FILE *F;
   char *fname;  /* filename to put the vcg information in */
   int i, j, len = strlen(name);
@@ -1923,8 +1810,7 @@ void vcg_close (FILE *F) {
 /* Dump ir graphs, differnt formats and additional information.         */
 /************************************************************************/
 
-/** Routine to dump a graph, blocks as conventional nodes.
- */
+/** Routine to dump a graph, blocks as conventional nodes.  */
 void
 dump_ir_graph (ir_graph *irg, const char *suffix )
 {
@@ -1933,7 +1819,9 @@ dump_ir_graph (ir_graph *irg, const char *suffix )
   char *suffix1;
   rem = current_ir_graph;
 
-  if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0) return;
+  if (strncmp(get_entity_name(get_irg_entity(irg)),
+	      dump_file_filter, strlen(dump_file_filter)) != 0) return;
+
   current_ir_graph = irg;
   if (get_interprocedural_view()) suffix1 = "-pure-ip";
   else                            suffix1 = "-pure";
@@ -1946,7 +1834,7 @@ dump_ir_graph (ir_graph *irg, const char *suffix )
 
   /* dump the out edges in a separate walk */
   if ((dump_out_edge_flag) && (get_irg_outs_state(irg) != outs_none)) {
-    irg_out_walk(get_irg_start(irg), dump_out_edge, NULL, NULL);
+    irg_out_walk(get_irg_start(irg), dump_out_edge, NULL, f);
   }
 
   vcg_close(f);
@@ -1975,7 +1863,7 @@ dump_ir_block_graph (ir_graph *irg, const char *suffix)
   for (i = 0; i < get_irp_n_irgs(); i++) {
     ir_node **arr = ird_get_irg_link(get_irp_irg(i));
     if (arr) {
-      dump_graph(f, get_irp_irg(i));
+      dump_graph_from_list(f, get_irp_irg(i));
       DEL_ARR_F(arr);
     }
   }
@@ -1983,8 +1871,7 @@ dump_ir_block_graph (ir_graph *irg, const char *suffix)
   vcg_close(f);
 }
 
-/** dumps a graph with type information
- */
+/** dumps a graph with type information */
 void
 dump_ir_graph_w_types (ir_graph *irg, const char *suffix)
 {
@@ -2038,7 +1925,7 @@ dump_ir_block_graph_w_types (ir_graph *irg, const char *suffix)
   for (i = 0; i < get_irp_n_irgs(); i++) {
     ir_node **arr = ird_get_irg_link(get_irp_irg(i));
     if (arr) {
-      dump_graph(f, get_irp_irg(i));
+      dump_graph_from_list(f, get_irp_irg(i));
       DEL_ARR_F(arr);
     }
   }
@@ -2162,6 +2049,38 @@ dump_cfg (ir_graph *irg, const char *suffix)
   current_ir_graph = rem;
 }
 
+
+static void descend_and_dump(FILE *F, ir_node *n, int depth, pset *mark_set) {
+  if (pset_find_ptr(mark_set, n)) return;
+
+  pset_insert_ptr(mark_set, n);
+
+  if (depth > 0) {
+    int i, start = is_Block(n) ? 0 : -1;
+    dump_whole_node(n, F);
+    for (i = start; i < get_irn_arity(n); ++i)
+      descend_and_dump(F, get_irn_n(n, i), depth-1, mark_set);
+  } else {
+    dump_node(F, n);
+    /* Don't dump edges to nodes further out.  These might be edges to
+       nodes we already dumped, if there is a shorter path to these. */
+  }
+}
+
+static int subgraph_counter = 0;
+void dump_subgraph (ir_node *root, int depth, const char *suffix) {
+  FILE *F;
+  char buf[32];
+  pset *mark_set = pset_new_ptr(1);
+  sprintf(buf, "-subg_%03d", subgraph_counter++);
+  F = vcg_open(get_irn_irg(root), suffix, buf);
+  dump_vcg_header(F, get_irg_dump_name(get_irn_irg(root)), NULL);
+  descend_and_dump(F, root, depth, mark_set);
+  vcg_close(F);
+  del_pset(mark_set);
+}
+
+
 static int weight_overall(int rec, int loop) {
   return 2*rec + loop;
 }
@@ -2171,11 +2090,13 @@ static int compute_color (int my, int max) {
   if (!max) {
     color = 0;
   } else {
+    int step;
+
     /* if small, scale to the full color range. */
     if (max < n_colors)
       my = my * (n_colors/max);
 
-    int step = 1 + (max / n_colors);
+    step = 1 + (max / n_colors);
 
     color = my/step;
   }
@@ -2183,22 +2104,24 @@ static int compute_color (int my, int max) {
 }
 
 static int get_entity_color(entity *ent) {
-  assert(get_entity_irg(ent));
   ir_graph *irg = get_entity_irg(ent);
+  assert(irg);
 
-  int rec_depth     = get_irg_recursion_depth(irg);
-  int loop_depth    = get_irg_loop_depth(irg);
-  int overall_depth = weight_overall(rec_depth, loop_depth);
+  {
+    int rec_depth     = get_irg_recursion_depth(irg);
+    int loop_depth    = get_irg_loop_depth(irg);
+    int overall_depth = weight_overall(rec_depth, loop_depth);
 
-  int max_rec_depth     = irp->max_callgraph_recursion_depth;
-  int max_loop_depth    = irp->max_callgraph_loop_depth;
-  int max_overall_depth = weight_overall(max_rec_depth, max_loop_depth);
+    int max_rec_depth     = irp->max_callgraph_recursion_depth;
+    int max_loop_depth    = irp->max_callgraph_loop_depth;
+    int max_overall_depth = weight_overall(max_rec_depth, max_loop_depth);
 
-  /* int my_rec_color     = compute_color(rec_depth, max_rec_depth); */
-  /* int my_loop_color    = compute_color(loop_depth, max_loop_depth); */
-  int my_overall_color = compute_color(overall_depth, max_overall_depth);;
+    /* int my_rec_color     = compute_color(rec_depth, max_rec_depth); */
+    /* int my_loop_color    = compute_color(loop_depth, max_loop_depth); */
+    int my_overall_color = compute_color(overall_depth, max_overall_depth);;
 
-  return my_overall_color;
+    return my_overall_color;
+  }
 }
 
 void dump_callgraph(const char *suffix) {
@@ -2256,7 +2179,7 @@ void dump_all_cg_block_graph(const char *suffix) {
   for (i = 0; i < get_irp_n_irgs(); i++) {
     current_ir_graph = get_irp_irg(i);
     assert(ird_get_irg_link(current_ir_graph));
-    dump_graph(f, current_ir_graph);
+    dump_graph_from_list(f, current_ir_graph);
     DEL_ARR_F(ird_get_irg_link(current_ir_graph));
   }
 
@@ -2397,9 +2320,11 @@ void dump_loops_standalone(FILE *F, ir_loop *loop) {
       /* Causes indeterministic output: if (is_Block(n)) fprintf (F, "\t ->%d", (int)get_irn_link(n)); */
       if (has_backedges(n)) fprintf(F, "\t loop head!");
     } else { /* for callgraph loop tree */
+      ir_graph *n;
       assert(get_kind(son) == k_ir_graph);
+
       /* We are a loop node -> Collect firm graphs */
-      ir_graph *n = (ir_graph *)le.node;
+      n = (ir_graph *)le.node;
       if (!loop_node_started) {
         /* Start a new node which contains all firm nodes of the current loop */
         fprintf (F, "node: { title: \"");
@@ -2409,7 +2334,7 @@ void dump_loops_standalone(FILE *F, ir_loop *loop) {
         first = i;
       }
       else
-    fprintf(F, "\n");
+        fprintf(F, "\n");
       fprintf (F, " %s", get_irg_dump_name(n));
       /* fprintf (F, " %s (depth %d)", get_irg_dump_name(n), n->callgraph_weighted_loop_depth); */
     }