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

diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c
index 2d85c79c4..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"
@@ -23,7 +29,6 @@
 #include "entity_t.h"
 #include "irop_t.h"
 
-#include "irdump.h"
 #include "irdump_t.h"
 
 #include "irgwalk.h"
@@ -41,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);
@@ -54,22 +60,36 @@ SeqNo get_Block_seqno(ir_node *n);
 static int n_colors   = 0;
 static int base_color = 0;
 
-static const char *get_mode_name_ex(ir_mode *mode, int *bad)
+#define ERROR_TXT       "<ERROR>"
+
+/**
+ * returns the name of a mode or <ERROR> if mode is NOT a mode object.
+ * in the later case, sets bad
+ */
+const char *get_mode_name_ex(ir_mode *mode, int *bad)
 {
   if (is_mode(mode))
     return get_mode_name(mode);
   *bad |= 1;
-  return "<ERROR>";
+  return ERROR_TXT;
 }
 
-static const char *get_type_name_ex(type *tp, int *bad)
+/**
+ * returns the name of a type or <ERROR> if mode is NOT a mode object.
+ * in the later case, sets bad
+ */
+const char *get_type_name_ex(type *tp, int *bad)
 {
   if (is_type(tp))
     return get_type_name(tp);
   *bad |= 1;
-  return "<ERROR>";
+  return ERROR_TXT;
 }
 
+/**
+ * prints the edge from a type S to a type T with additional info fmt, ...
+ * to the file F
+ */
 static void print_type_type_edge(FILE *F, type *S, type *T, const char *fmt, ...)
 {
   va_list ap;
@@ -82,6 +102,10 @@ static void print_type_type_edge(FILE *F, type *S, type *T, const char *fmt, ...
   va_end(ap);
 }
 
+/**
+ * prints the edge from a type T to an entity E with additional info fmt, ...
+ * to the file F
+ */
 static void print_type_ent_edge(FILE *F, type *T, entity *E, const char *fmt, ...)
 {
   va_list ap;
@@ -94,6 +118,10 @@ static void print_type_ent_edge(FILE *F, type *T, entity *E, const char *fmt, ..
   va_end(ap);
 }
 
+/**
+ * prints the edge from an entity E to an entity T with additional info fmt, ...
+ * to the file F
+ */
 static void print_ent_ent_edge(FILE *F, entity *E, entity *T, int backedge, const char *fmt, ...)
 {
   va_list ap;
@@ -110,6 +138,10 @@ static void print_ent_ent_edge(FILE *F, entity *E, entity *T, int backedge, cons
   va_end(ap);
 }
 
+/**
+ * prints the edge from an entity E to a type T with additional info fmt, ...
+ * to the file F
+ */
 static void print_ent_type_edge(FILE *F, entity *E, type *T, const char *fmt, ...)
 {
   va_list ap;
@@ -122,6 +154,10 @@ static void print_ent_type_edge(FILE *F, entity *E, type *T, const char *fmt, ..
   va_end(ap);
 }
 
+/**
+ * prints the edge from a node N to a type T with additional info fmt, ...
+ * to the file F
+ */
 static void print_node_type_edge(FILE *F, const ir_node *N, type *T, const char *fmt, ...)
 {
   va_list ap;
@@ -134,6 +170,10 @@ static void print_node_type_edge(FILE *F, const ir_node *N, type *T, const char
   va_end(ap);
 }
 
+/**
+ * prints the edge from a node N to an entity E with additional info fmt, ...
+ * to the file F
+ */
 static void print_node_ent_edge(FILE *F, const ir_node *N, entity *E, const char *fmt, ...)
 {
   va_list ap;
@@ -147,6 +187,10 @@ static void print_node_ent_edge(FILE *F, const ir_node *N, entity *E, const char
   va_end(ap);
 }
 
+/**
+ * prints the edge from an entity E to a node N with additional info fmt, ...
+ * to the file F
+ */
 static void print_ent_node_edge(FILE *F, entity *E, const ir_node *N, const char *fmt, ...)
 {
   va_list ap;
@@ -159,6 +203,10 @@ static void print_ent_node_edge(FILE *F, entity *E, const ir_node *N, const char
   va_end(ap);
 }
 
+/**
+ * prints the edge from a type E to an enumeration item item with additional info fmt, ...
+ * to the file F
+ */
 static void print_enum_item_edge(FILE *F, type *E, int item, const char *fmt, ...)
 {
   va_list ap;
@@ -171,30 +219,34 @@ static void print_enum_item_edge(FILE *F, type *E, int item, const char *fmt, ..
   va_end(ap);
 }
 
-/*******************************************************************/
+/*-----------------------------------------------------------------*/
 /* global and ahead declarations                                   */
-/*******************************************************************/
+/*-----------------------------------------------------------------*/
 
 static void dump_whole_node(ir_node *n, void *env);
 static INLINE void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg);
 
-/*******************************************************************/
+/*-----------------------------------------------------------------*/
 /* Helper functions.                                                */
-/*******************************************************************/
-
-/* Use private link attr to be able to call dumper anywhere without
-   destroying link fields. */
+/*-----------------------------------------------------------------*/
 
+/**
+ * This map is used as a private link attr to be able to call dumper
+ * anywhere without destroying link fields.
+ */
 static pmap *irdump_link_map = NULL;
 
+/** Creates the link attribut map. */
 static void init_irdump(void) {
   /* We need a new, empty map. */
   if (irdump_link_map) pmap_destroy(irdump_link_map);
   irdump_link_map = pmap_create();
 }
 
-
-void *ird_get_irn_link(ir_node *n) {
+/**
+ * Returns the private link field.
+ */
+static void *ird_get_irn_link(ir_node *n) {
   void *res = NULL;
   if (!irdump_link_map) return NULL;
 
@@ -203,12 +255,18 @@ void *ird_get_irn_link(ir_node *n) {
   return res;
 }
 
-void ird_set_irn_link(ir_node *n, void *x) {
+/**
+ * Sets the private link field.
+ */
+static void ird_set_irn_link(ir_node *n, void *x) {
   if (!irdump_link_map) init_irdump();
   pmap_insert(irdump_link_map, (void *)n, x);
 }
 
-void *ird_get_irg_link(ir_graph *irg) {
+/**
+ * Gets the private link field of an irg.
+ */
+static void *ird_get_irg_link(ir_graph *irg) {
   void *res = NULL;
   if (!irdump_link_map) return NULL;
 
@@ -217,21 +275,24 @@ void *ird_get_irg_link(ir_graph *irg) {
   return res;
 }
 
-void ird_set_irg_link(ir_graph *irg, void *x) {
+/**
+ * Sets the private link field of an irg.
+ */
+static void ird_set_irg_link(ir_graph *irg, void *x) {
   if (!irdump_link_map) init_irdump();
   pmap_insert(irdump_link_map, (void *)irg, x);
 }
 
+/**
+ * Walker, clears tzhe private link field
+ */
 static void clear_link(ir_node * node, void * env) {
   ird_set_irn_link(node, NULL);
 }
 
-
-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.
+ */
 const char *get_ent_dump_name(entity *ent) {
   if (!ent)
     return "<NULL entity>";
@@ -240,12 +301,24 @@ const char *get_ent_dump_name(entity *ent) {
   return get_id_str(ent->name);
 }
 
+/* Returns the name of an IRG. */
 const char *get_irg_dump_name(ir_graph *irg) {
   /* Don't use get_entity_ld_ident (ent) as it computes the mangled name! */
   entity *ent = get_irg_entity(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.
+ */
 static void collect_node(ir_node * node, void *env) {
   if (is_Block(node)
       || node_floats(node)
@@ -258,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);
+    }
   }
 }
 
@@ -269,7 +352,8 @@ static void collect_node(ir_node * node, void *env) {
  * Bad, NoMem and Unknown into a flexible array in link field of
  * irg they belong to.  Sets the irg link field to NULL in all
  * graphs not visited.
- * Free the list with DEL_ARR_F.  */
+ * Free the list with DEL_ARR_F().
+ */
 static ir_node ** construct_block_lists(ir_graph *irg) {
   int i, rem_view = get_interprocedural_view();
   ir_graph *rem = current_ir_graph;
@@ -282,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;
@@ -296,15 +382,16 @@ static ir_node ** construct_block_lists(ir_graph *irg) {
 /* flags to steer output                                           */
 /*******************************************************************/
 
+/** Dump only irgs with names start with this string */
 const char *dump_file_filter = "";
 
-/* A compiler option to turn off edge labels */
-int edge_label = 1;
-/* A compiler option to turn off dumping values of constant entities */
-int const_entities = 1;
-/* A compiler option to dump the keep alive edges */
-int dump_keepalive = 0;
-/* Compiler options to dump analysis information in dump_ir_graph */
+/** A compiler option to turn off edge labels */
+static int edge_label = 1;
+/** A compiler option to turn off dumping values of constant entities */
+static int const_entities = 1;
+/** A compiler option to dump the keep alive edges */
+static int dump_keepalive = 0;
+/** Compiler options to dump analysis information in dump_ir_graph */
 int dump_out_edge_flag = 0;
 int dump_dominator_information_flag = 0;
 int dump_loop_information_flag = 0;
@@ -313,7 +400,16 @@ int dump_const_local = 0;
 bool opt_dump_analysed_type_info = 1;
 bool opt_dump_pointer_values_to_info = 0;  /* default off: for test compares!! */
 
-char* overrule_nodecolor = NULL;
+static const char *overrule_nodecolor = NULL;
+
+/** The vcg attribute hook. */
+static DUMP_NODE_VCGATTR_FUNC dump_node_vcgattr_hook = NULL;
+
+/* set the hook */
+void set_dump_node_vcgattr_hook(DUMP_NODE_VCGATTR_FUNC hook)
+{
+  dump_node_vcgattr_hook = hook;
+}
 
 INLINE bool get_opt_dump_const_local(void) {
   if (!dump_out_edge_flag && !dump_loop_information_flag)
@@ -337,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) {
@@ -349,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_dominator_information(void) {
-  dump_dominator_information_flag = 1;
+void dump_out_edges(bool b) {
+  dump_out_edge_flag = b;
 }
 
-void dump_loop_information(void) {
-  dump_loop_information_flag = 1;
+void dump_dominator_information(bool b) {
+  dump_dominator_information_flag = b;
 }
 
-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) {
@@ -385,7 +477,10 @@ void dump_pointer_values_to_info(bool b) {
 /* Routines to dump information about a single ir node.            */
 /*-----------------------------------------------------------------*/
 
-INLINE int
+/*
+ * dump the name of a node n to the File F.
+ */
+int
 dump_node_opcode(FILE *F, ir_node *n)
 {
   int bad = 0;
@@ -474,6 +569,10 @@ default_case:
   return bad;
 }
 
+/**
+ * Dump the mode of a node n to a file F.
+ * Ignore modes that are "always known".
+ */
 static INLINE int
 dump_node_mode(FILE *F, ir_node *n)
 {
@@ -502,6 +601,9 @@ dump_node_mode(FILE *F, ir_node *n)
   return bad;
 }
 
+/**
+ * Dump the tpe of a node n to a file F if it's known.
+ */
 static int dump_node_typeinfo(FILE *F, ir_node *n) {
   int bad = 0;
 
@@ -509,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, " []");
@@ -518,6 +620,9 @@ static int dump_node_typeinfo(FILE *F, ir_node *n) {
   return bad;
 }
 
+/**
+ * Dump addinional node attributes of some nodes to a file F.
+ */
 static INLINE int
 dump_node_nodeattr(FILE *F, ir_node *n)
 {
@@ -539,15 +644,15 @@ dump_node_nodeattr(FILE *F, ir_node *n)
   case iro_Filter:
     fprintf (F, "%ld", get_Filter_proj(n));
     break;
-  case iro_Sel: {
+  case iro_Sel:
     fprintf (F, "%s", get_ent_dump_name(get_Sel_entity(n)));
-    } break;
-  case iro_Cast: {
+    break;
+  case iro_Cast:
     fprintf (F, "(%s)", get_type_name_ex(get_Cast_type(n), &bad));
-    } break;
-  case iro_Confirm: {
+    break;
+  case iro_Confirm:
     fprintf (F, "%s", get_pnc_string(get_Confirm_cmp(n)));
-    } break;
+    break;
 
   default:
     ;
@@ -556,12 +661,25 @@ dump_node_nodeattr(FILE *F, ir_node *n)
   return bad;
 }
 
-static INLINE void dump_node_vcgattr(FILE *F, ir_node *n, int bad)
+/**
+ * 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 *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, node, local))
+      return;
+
+  n = local ? local : node;
+
   switch (get_irn_opcode(n)) {
   case iro_Start:
   case iro_EndReg:
@@ -572,7 +690,10 @@ static INLINE 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");
@@ -590,190 +711,15 @@ static INLINE void dump_node_vcgattr(FILE *F, ir_node *n, int bad)
   if (overrule_nodecolor) fprintf(F, " color: %s", overrule_nodecolor);
 }
 
-static INLINE int dump_node_info(FILE *F, ir_node *n)
-{
-  int i, bad = 0;
-  char comma;
-  ir_graph *irg;
 
+/**
+ * Dump the node information of a node n to a file F.
+ */
+static INLINE int dump_node_info(FILE *F, ir_node *n)
+{ 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;
 }
 
@@ -787,7 +733,7 @@ bool is_constlike_node(ir_node *n) {
 }
 
 
-/* outputs the predecessors of n, that are constants, local.  I.e.,
+/** outputs the predecessors of n, that are constants, local.  I.e.,
    generates a copy of the constant predecessors for each node called with. */
 static void dump_const_node_local(FILE *F, ir_node *n) {
   int i;
@@ -820,26 +766,66 @@ 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");
     }
   }
 }
 
-static void INLINE print_node_error(FILE *F, const char *p)
+/** 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.
+ */
+static void INLINE print_node_error(FILE *F, const char *err_msg)
 {
-  if (! p)
+  if (! err_msg)
     return;
 
-  fprintf (F, " info2: \"%s\"", p);
+  fprintf (F, " info2: \"%s\"", err_msg);
 }
 
+/**
+ * Dump a node
+ */
 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: \"");
 
@@ -853,27 +839,32 @@ 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
 }
 
-/* dump the edge to the block this node belongs to */
+/** dump the edge to the block this node belongs to */
 static void
 dump_ir_block_edge(FILE *F, ir_node *n)  {
   if (get_opt_dump_const_local() && is_constlike_node(n)) return;
   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");
+    }
   }
 }
 
@@ -1021,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;
@@ -1129,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");
 }
@@ -1152,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);
     }
   }
@@ -1165,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);
@@ -1758,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);
@@ -1815,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 )
 {
@@ -1825,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";
@@ -1838,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);
@@ -1867,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);
     }
   }
@@ -1875,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)
 {
@@ -1930,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);
     }
   }
@@ -2054,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;
 }
@@ -2063,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;
   }
@@ -2075,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) {
@@ -2148,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));
   }
 
@@ -2156,9 +2187,9 @@ void dump_all_cg_block_graph(const char *suffix) {
   set_interprocedural_view(rem_view);
 }
 
-/***********************************************************************/
+/*---------------------------------------------------------------------*/
 /* the following routines dumps type information without any ir nodes. */
-/***********************************************************************/
+/*---------------------------------------------------------------------*/
 
 void
 dump_type_graph (ir_graph *irg, const char *suffix)
@@ -2213,14 +2244,14 @@ dump_class_hierarchy (bool entities, const char *suffix)
   vcg_close(f);
 }
 
-/***********************************************************************/
+/*---------------------------------------------------------------------*/
 /* dumps all graphs with the graph-dumper passed. Possible dumpers:    */
 /*  dump_ir_graph                                                      */
 /*  dump_ir_block_graph                                                */
 /*  dump_cfg                                                           */
 /*  dump_type_graph                                                    */
 /*  dump_ir_graph_w_types                                              */
-/***********************************************************************/
+/*---------------------------------------------------------------------*/
 
 void dump_all_ir_graphs(dump_graph_func *dmp_grph, const char *suffix) {
   int i, n_irgs = get_irp_n_irgs();
@@ -2230,10 +2261,10 @@ void dump_all_ir_graphs(dump_graph_func *dmp_grph, const char *suffix) {
 }
 
 
-/**********************************************************************************
+/*--------------------------------------------------------------------------------*
  * Dumps a stand alone loop graph with firm nodes which belong to one loop node   *
  * packed together in one subgraph/box                                            *
- **********************************************************************************/
+ *--------------------------------------------------------------------------------*/
 
 void dump_loops_standalone(FILE *F, ir_loop *loop) {
   int i = 0, loop_node_started = 0, son_number = 0, first = 0;
@@ -2270,15 +2301,15 @@ void dump_loops_standalone(FILE *F, ir_loop *loop) {
       int bad = 0;
 
       if (!loop_node_started) {
-    /* Start a new node which contains all firm nodes of the current loop */
-    fprintf (F, "node: { title: \"");
-    PRINT_LOOPID(loop);
-    fprintf (F, "-%d-nodes\" color: lightyellow label: \"", i);
-    loop_node_started = 1;
-    first = i;
+        /* Start a new node which contains all firm nodes of the current loop */
+        fprintf (F, "node: { title: \"");
+        PRINT_LOOPID(loop);
+        fprintf (F, "-%d-nodes\" color: lightyellow label: \"", i);
+        loop_node_started = 1;
+        first = i;
       }
       else
-    fprintf(F, "\n");
+        fprintf(F, "\n");
 
       bad |= dump_node_opcode(F, n);
       bad |= dump_node_mode(F, n);
@@ -2286,22 +2317,24 @@ void dump_loops_standalone(FILE *F, ir_loop *loop) {
       fprintf (F, " ");
       bad |= dump_node_nodeattr(F, n);
       fprintf (F, " %ld", get_irn_node_nr(n));
-      if (is_Block(n)) fprintf (F, "\t ->%d", (int)get_irn_link(n));
+      /* 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: \"");
-    PRINT_LOOPID(loop);
-    fprintf (F, "-%d-nodes\" color: lightyellow label: \"", i);
-    loop_node_started = 1;
-    first = i;
+        /* Start a new node which contains all firm nodes of the current loop */
+        fprintf (F, "node: { title: \"");
+        PRINT_LOOPID(loop);
+        fprintf (F, "-%d-nodes\" color: lightyellow label: \"", i);
+        loop_node_started = 1;
+        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); */
     }
@@ -2351,9 +2384,9 @@ void dump_callgraph_loop_tree(const char *suffix) {
 }
 
 
-/*******************************************************************************/
+/*-----------------------------------------------------------------------------*/
 /* Dumps the firm nodes in the loop tree to a graph along with the loop nodes. */
-/*******************************************************************************/
+/*-----------------------------------------------------------------------------*/
 
 void collect_nodeloop(FILE *F, ir_loop *loop, eset *loopnodes) {
   int i, son_number = 0, node_number = 0;