X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firdump.c;h=337c091a67260c5e4eef05ae2a102dd5d2ffe2c0;hb=30b120caf1fbc6fcb13c6b3bef8f7132ebff72aa;hp=1b6112539cf9391326bdc70dad2f60b7d4926b77;hpb=c5d54a91a48cb8c7ef37d7d19e1e2236ff12a6f4;p=libfirm

diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c
index 1b6112539..337c091a6 100644
--- a/ir/ir/irdump.c
+++ b/ir/ir/irdump.c
@@ -17,6 +17,7 @@
 
 # include <string.h>
 # include <stdlib.h>
+# include <stdarg.h>
 
 # include "irnode_t.h"
 # include "irgraph_t.h"
@@ -34,29 +35,40 @@
 # include "irouts.h"
 # include "irdom.h"
 # include "irloop.h"
+# include "irvrfy.h"
 
 # include "panic.h"
 # include "array.h"
 # include "pmap.h"
-
-# include "exc.h"
-
+# include "eset.h"
+
+#if DO_HEAPANALYSIS
+void dump_chi_term(FILE *FL, ir_node *n);
+void dump_state(FILE *FL, ir_node *n);
+int  get_opt_dump_abstvals(void);
+typedef unsigned long SeqNo;
+SeqNo get_Block_seqno(ir_node *n);
+#endif
 
 /* Attributes of nodes */
 #define PRINT_DEFAULT_NODE_ATTR
 #define DEFAULT_NODE_ATTR " "
 #define DEFAULT_TYPE_ATTRIBUTE " "
+#define DEFAULT_ENUM_ITEM_ATTRIBUTE " "
 
 /* Attributes of edges between Firm nodes */
-#define BLOCK_EDGE_ATTR "class: 2 priority: 2 linestyle: dotted"
-#define CF_EDGE_ATTR    "color: red"
-#define MEM_EDGE_ATTR   "color: blue"
-#define DOMINATOR_EDGE_ATTR "color: red"
+#define INTRA_DATA_EDGE_ATTR "class:1  priority:50"
+#define INTER_DATA_EDGE_ATTR "class:16 priority:10"
+#define BLOCK_EDGE_ATTR      "class:2  priority:50 linestyle:dotted"
+#define CF_EDGE_ATTR         "class:13 priority:60 color:red"
+#define INTRA_MEM_EDGE_ATTR  "class:14 priority:50 color:blue"
+#define INTER_MEM_EDGE_ATTR  "class:17 priority:10 color:blue"
+#define DOMINATOR_EDGE_ATTR  "class:15 color:red"
 
-#define BACK_EDGE_ATTR "linestyle: dashed "
+#define BACK_EDGE_ATTR "linestyle:dashed "
 
 /* Attributes of edges between Firm nodes and type/entity nodes */
-#define NODE2TYPE_EDGE_ATTR "class: 2 priority: 2 linestyle: dotted"
+#define NODE2TYPE_EDGE_ATTR "class:2 priority:2 linestyle:dotted"
 
 /* Attributes of edges in type/entity graphs. */
 #define TYPE_METH_NODE_ATTR  "color: lightyellow"
@@ -76,7 +88,7 @@
 #define ENT_VALUE_EDGE_ATTR "label: \"value %d\""
 #define ENT_CORR_EDGE_ATTR "label: \"value %d corresponds to \" "
 #define TYPE_MEMBER_EDGE_ATTR "class: 12 label: \"member\" color:blue"
-
+#define ENUM_ITEM_NODE_ATTR  "color: green"
 
 #if DEBUG_libfirm && NODEID_AS_LABEL
 #define PRINT_NODEID(X) fprintf(F, "n%ld", get_irn_node_nr(X))
@@ -84,35 +96,146 @@
 #define PRINT_ENTID(X)  fprintf(F, "e%ld", get_entity_nr(X))
 #define PRINT_IRGID(X)  fprintf(F, "g%ld", get_irg_graph_nr(X))
 #define PRINT_CONSTID(X,Y) fprintf(F, "\"n%ldn%ld\"", get_irn_node_nr(X),get_irn_node_nr(Y))
+#define PRINT_LOOPID(X) fprintf(F, "l%d", get_loop_loop_nr(X))
+#define PRINT_ITEMID(X,Y)  fprintf(F, "i%ldT%d", get_type_nr(X), (Y))
 
 #else
-#define PRINT_NODEID(X) fprintf(F, "n%p", (void*) X)
-#define PRINT_TYPEID(X) fprintf(F, "\"t%p\"", (void *) X)
-#define PRINT_ENTID(X)  fprintf(F, "e%p", (void*) X)
-#define PRINT_IRGID(X)  fprintf(F, "g%p",(void*) X)
-#define PRINT_CONSTID(X,Y) fprintf(F, "\"n%pn%p\"", (void*) X, (void*) Y)
+#define PRINT_NODEID(X) fprintf(F, "n%p", (void *)(X))
+#define PRINT_TYPEID(X) fprintf(F, "\"t%p\"", (void *)(X))
+#define PRINT_ENTID(X)  fprintf(F, "e%p", (void *)(X))
+#define PRINT_IRGID(X)  fprintf(F, "g%p",(void *)(X))
+#define PRINT_CONSTID(X,Y) fprintf(F, "\"n%pn%p\"", (void*)(X), (void*)(Y))
+#define PRINT_LOOPID(X) fprintf(F, "l%p", (void *)(X))
+#define PRINT_ITEMID(X,Y)  fprintf(F, "i%pT%d", (void *) (X), (Y))
 #endif
 
-#define PRINT_TYPE_TYPE_EDGE(S,T,...){fprintf (F, "edge: { sourcename: "); PRINT_TYPEID(S); fprintf (F, " targetname: "); PRINT_TYPEID(T); fprintf (F, ##__VA_ARGS__); fprintf(F,"}\n"); }
-#define PRINT_TYPE_ENT_EDGE(S,T,...) {fprintf (F, "edge: { sourcename: "); PRINT_TYPEID(S); fprintf (F, " targetname: \""); PRINT_ENTID(T); fprintf(F, "\"");  fprintf (F, ##__VA_ARGS__); fprintf(F,"}\n"); }
-#define PRINT_ENT_ENT_EDGE(S,T,...)  {fprintf (F, "edge: { sourcename: \""); PRINT_ENTID(S);  fprintf (F, "\" targetname: \""); PRINT_ENTID(T);  fprintf(F, "\""); fprintf (F, ##__VA_ARGS__); fprintf(F,"}\n"); }
-#define PRINT_ENT_TYPE_EDGE(S,T,...) {fprintf (F, "edge: { sourcename: \""); PRINT_ENTID(S);  fprintf (F, "\" targetname: "); PRINT_TYPEID(T); fprintf (F, ##__VA_ARGS__); fprintf(F,"}\n"); }
-#define PRINT_NODE_TYPE_EDGE(S,T,...){fprintf (F, "edge: { sourcename: \""); PRINT_NODEID(S); fprintf (F, "\" targetname: "); PRINT_TYPEID(T); fprintf (F, ##__VA_ARGS__); fprintf(F,"}\n"); }
-#define PRINT_NODE_ENT_EDGE(S,T,...) {fprintf (F, "edge: { sourcename: \""); PRINT_NODEID(S); fprintf (F, "\" targetname: \""); PRINT_ENTID(T);  fprintf(F, "\""); fprintf (F, ##__VA_ARGS__); fprintf(F,"}\n"); }
-#define PRINT_ENT_NODE_EDGE(S,T,...) {fprintf (F, "edge: { sourcename: \""); PRINT_ENTID(S);  fprintf (F, "\" targetname: \""); PRINT_NODEID(T); fprintf(F, "\""); fprintf (F, ##__VA_ARGS__); fprintf(F,"}\n"); }
+static const char *get_mode_name_ex(ir_mode *mode, int *bad)
+{
+  if (is_mode(mode))
+    return get_mode_name(mode);
+  *bad |= 1;
+  return "<ERROR>";
+}
+
+static const char *get_type_name_ex(type *tp, int *bad)
+{
+  if (is_type(tp))
+    return get_type_name(tp);
+  *bad |= 1;
+  return "<ERROR>";
+}
+
+static void print_type_type_edge(FILE *F, type *S, type *T, const char *fmt, ...)
+{
+  va_list ap;
+
+  va_start(ap, fmt);
+  fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(S);
+  fprintf(F, " targetname: "); PRINT_TYPEID(T);
+  vfprintf(F, fmt, ap);
+  fprintf(F,"}\n");
+  va_end(ap);
+}
+
+static void print_type_ent_edge(FILE *F, type *T, entity *E, const char *fmt, ...)
+{
+  va_list ap;
+
+  va_start(ap, fmt);
+  fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(T);
+  fprintf(F, " targetname: \""); PRINT_ENTID(E); fprintf(F, "\"");
+  vfprintf(F, fmt, ap);
+  fprintf(F, "}\n");
+  va_end(ap);
+}
+
+static void print_ent_ent_edge(FILE *F, entity *E, entity *T, const char *fmt, ...)
+{
+  va_list ap;
+
+  va_start(ap, fmt);
+  fprintf(F, "edge: { sourcename: \""); PRINT_ENTID(E);
+  fprintf(F, "\" targetname: \""); PRINT_ENTID(T);  fprintf(F, "\"");
+  vfprintf(F, fmt, ap);
+  fprintf(F, "}\n");
+  va_end(ap);
+}
+
+static void print_ent_type_edge(FILE *F, entity *E, type *T, const char *fmt, ...)
+{
+  va_list ap;
+
+  va_start(ap, fmt);
+  fprintf(F, "edge: { sourcename: \""); PRINT_ENTID(E);
+  fprintf(F, "\" targetname: "); PRINT_TYPEID(T);
+  vfprintf(F, fmt, ap);
+  fprintf(F,"}\n");
+  va_end(ap);
+}
+
+static void print_node_type_edge(FILE *F, const ir_node *N, type *T, const char *fmt, ...)
+{
+  va_list ap;
+
+  va_start(ap, fmt);
+  fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(N);
+  fprintf(F, "\" targetname: "); PRINT_TYPEID(T);
+  vfprintf(F, fmt, ap);
+  fprintf(F,"}\n");
+  va_end(ap);
+}
+
+static void print_node_ent_edge(FILE *F, const ir_node *N, entity *E, const char *fmt, ...)
+{
+  va_list ap;
+
+  va_start(ap, fmt);
+  fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(N);
+  fprintf(F, "\" targetname: \""); PRINT_ENTID(E);
+  fprintf(F, "\"");
+  vfprintf(F, fmt, ap);
+  fprintf(F,"}\n");
+  va_end(ap);
+}
+
+static void print_ent_node_edge(FILE *F, entity *E, const ir_node *N, const char *fmt, ...)
+{
+  va_list ap;
+
+  va_start(ap, fmt);
+  fprintf(F, "edge: { sourcename: \""); PRINT_ENTID(E);
+  fprintf(F, "\" targetname: \""); PRINT_NODEID(N); fprintf(F, "\"");
+  vfprintf(F, fmt, ap);
+  fprintf(F,"}\n");
+  va_end(ap);
+}
+
+static void print_enum_item_edge(FILE *F, type *E, int item, const char *fmt, ...)
+{
+  va_list ap;
+
+  va_start(ap, fmt);
+  fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(E);
+  fprintf(F, " targetname: \""); PRINT_ITEMID(E, item); fprintf(F, "\" ");
+  vfprintf(F, fmt, ap);
+  fprintf(F,"}\n");
+  va_end(ap);
+}
 
 /*******************************************************************/
 /* global and ahead declarations                                   */
 /*******************************************************************/
 
 /* A suffix to manipulate the file name. */
-char *dump_file_suffix = NULL;
+char *dump_file_suffix = "";
+
+char *dump_file_filter = "";
 
 /* file to dump to */
 static FILE *F;
 
 static void dump_whole_node(ir_node *n, void* env);
-static INLINE void dump_loop_info(ir_graph *irg);
+static INLINE void dump_loop_nodes_into_graph(ir_graph *irg);
 
 /*******************************************************************/
 /* Helper functions.                                                */
@@ -165,14 +288,21 @@ static void clear_link(ir_node * node, void * env) {
 
 static int node_floats(ir_node *n) {
   return ((get_op_pinned(get_irn_op(n)) == floats) &&
-	  (get_irg_pinned(current_ir_graph) == floats));
+      (get_irg_pinned(current_ir_graph) == floats));
+}
+
+static 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! */
+  if (ent->ld_name) return get_id_str(ent->ld_name);
+  return get_id_str(ent->name);
 }
 
-static ident *get_irg_dump_name (ir_graph *irg) {
+static 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_ent(irg);
-  if (ent->ld_name) return ent->ld_name;
-  return ent->name;
+  return get_ent_dump_name(ent);
 }
 
 static void collect_node(ir_node * node, void *env) {
@@ -199,7 +329,7 @@ static void collect_node(ir_node * node, void *env) {
  * graphs not visited.
  * Free the list with DEL_ARR_F.  */
 static ir_node ** construct_block_lists(ir_graph *irg) {
-  int i;
+  int i, rem_view = interprocedural_view;
   ir_graph *rem = current_ir_graph;
   current_ir_graph = irg;
 
@@ -208,6 +338,14 @@ static ir_node ** construct_block_lists(ir_graph *irg) {
 
   irg_walk_graph(current_ir_graph, clear_link, collect_node, current_ir_graph);
 
+  /* Collect also EndReg and EndExcept. We do not want to change the walker. */
+  interprocedural_view = 0;
+  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);
+  interprocedural_view = rem_view;
+
   current_ir_graph = rem;
   return ird_get_irg_link(irg);
 }
@@ -231,6 +369,8 @@ 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;
+
 INLINE bool get_opt_dump_const_local(void) {
   if (!dump_out_edge_flag && !dump_loop_information_flag)
     return dump_const_local;
@@ -296,9 +436,10 @@ void dump_pointer_values_to_info(bool b) {
 /* Routines to dump information about a single ir node.            */
 /*******************************************************************/
 
-static INLINE void
-dump_node_opcode (ir_node *n)
+INLINE int
+dump_node_opcode(FILE *F, ir_node *n)
 {
+  int bad = 0;
 
   switch(get_irn_opcode(n)) {
 
@@ -311,14 +452,18 @@ dump_node_opcode (ir_node *n)
   } break;
 
   case iro_SymConst: {
-    if (get_SymConst_kind(n) == linkage_ptr_info) {
+    if (get_SymConst_kind(n) == symconst_addr_name) {
       /* don't use get_SymConst_ptr_info as it mangles the name. */
-      fprintf (F, "SymC %s", get_id_str(get_SymConst_ptrinfo(n)));
+      fprintf (F, "SymC %s", get_id_str(get_SymConst_name(n)));
+    } else if (get_SymConst_kind(n) == symconst_addr_ent) {
+      assert(get_SymConst_entity(n));
+      assert(is_entity(get_SymConst_entity(n)));
+      fprintf (F, "SymC &%s", get_entity_name(get_SymConst_entity(n)));
     } else {
       assert(get_kind(get_SymConst_type(n)) == k_type);
       assert(get_type_ident(get_SymConst_type(n)));
-      fprintf (F, "SymC %s ", get_type_name(get_SymConst_type(n)));
-      if (get_SymConst_kind(n) == type_tag)
+      fprintf (F, "SymC %s ", get_type_name_ex(get_SymConst_type(n), &bad));
+      if (get_SymConst_kind(n) == symconst_type_tag)
         fprintf (F, "tag");
       else
         fprintf (F, "size");
@@ -330,9 +475,20 @@ dump_node_opcode (ir_node *n)
     else                       fprintf(F, "%s", get_irn_opname(n));
   } break;
 
+  case iro_Proj: {
+    ir_node *cond = get_Proj_pred(n);
+
+    if (get_irn_opcode(cond) == iro_Cond
+        && get_Proj_proj(n) == get_Cond_defaultProj(cond)
+	&& get_irn_mode(get_Cond_selector(cond)) != mode_b)
+      fprintf (F, "defProj");
+    else
+      fprintf (F, "%s", get_irn_opname(n));
+  } break;
+
   case iro_Start: {
     if (interprocedural_view) {
-      fprintf(F, "%s %s", get_irn_opname(n), get_entity_name(get_irg_ent(get_irn_irg(n))));
+      fprintf(F, "%s %s", get_irn_opname(n), get_ent_dump_name(get_irg_ent(get_irn_irg(n))));
       break;
     }
   } /* fall through */
@@ -342,11 +498,14 @@ dump_node_opcode (ir_node *n)
   }
 
   }  /* end switch */
+  return bad;
 }
 
-static INLINE void
+static INLINE int
 dump_node_mode (ir_node *n)
 {
+  int bad = 0;
+
   switch (get_irn_opcode(n)) {
   case iro_Phi:
   case iro_Const:
@@ -366,32 +525,39 @@ dump_node_mode (ir_node *n)
   case iro_Abs:
   case iro_Cmp:
   case iro_Confirm:
-    fprintf (F, "%s", get_mode_name(get_irn_mode(n)));
+    fprintf (F, "%s", get_mode_name_ex(get_irn_mode(n), &bad));
     break;
   default:
     ;
   }
+  return bad;
 }
 
-static void dump_node_typeinfo(ir_node *n) {
-  if (!opt_dump_analysed_type_info) return;
-  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_type(n);
-    if (tp != none_type)
-      fprintf (F, " [%s]", get_type_name(tp));
-    else
-      fprintf (F, " []");
+static int dump_node_typeinfo(ir_node *n) {
+  int bad = 0;
+
+  if (opt_dump_analysed_type_info) {
+    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_type(n);
+      if (tp != none_type)
+    fprintf(F, " [%s]", get_type_name_ex(tp, &bad));
+      else
+    fprintf(F, " []");
+    }
   }
+  return bad;
 }
 
-static INLINE void
+static INLINE int
 dump_node_nodeattr (ir_node *n)
 {
+  int bad = 0;
+
   switch (get_irn_opcode(n)) {
   case iro_Start:
     if (false && interprocedural_view) {
-      fprintf (F, "%s", get_entity_name(get_irg_ent(current_ir_graph)));
+      fprintf (F, "%s", get_ent_dump_name(get_irg_ent(current_ir_graph)));
     }
     break;
   case iro_Proj:
@@ -405,10 +571,10 @@ dump_node_nodeattr (ir_node *n)
     fprintf (F, "%ld", get_Filter_proj(n));
     break;
   case iro_Sel: {
-    fprintf (F, "%s", get_entity_name(get_Sel_entity(n)));
+    fprintf (F, "%s", get_ent_dump_name(get_Sel_entity(n)));
     } break;
   case iro_Cast: {
-    fprintf (F, "(%s)", get_type_name(get_Cast_type(n)));
+    fprintf (F, "(%s)", get_type_name_ex(get_Cast_type(n), &bad));
     } break;
   case iro_Confirm: {
     fprintf (F, "%s", get_pnc_string(get_Confirm_cmp(n)));
@@ -417,11 +583,16 @@ dump_node_nodeattr (ir_node *n)
   default:
     ;
   } /* end switch */
+
+  return bad;
 }
 
-static INLINE void
-dump_node_vcgattr (ir_node *n)
+static INLINE void dump_node_vcgattr(ir_node *n, int bad)
 {
+  if (bad) {
+    fprintf(F, "color: red");
+    return;
+  }
   switch (get_irn_opcode(n)) {
   case iro_Start:
   case iro_EndReg:
@@ -446,54 +617,131 @@ dump_node_vcgattr (ir_node *n)
   default:
     PRINT_DEFAULT_NODE_ATTR;
   }
+
+  if (overrule_nodecolor) fprintf(F, " color: %s", overrule_nodecolor);
 }
 
-static INLINE void
-dump_node_info (ir_node *n) {
-  int i;
+static INLINE int dump_node_info(ir_node *n)
+{
+  int i, bad = 0;
+  char comma;
+  ir_graph *irg;
+
   fprintf (F, " info1: \"");
   if (opt_dump_pointer_values_to_info)
-    fprintf (F, "addr: %p \n", (void *)n);
+    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)));
+
+  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) && 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)) {
+  switch (get_irn_opcode(n)) {
   case iro_Start: {
     type *tp = get_entity_type(get_irg_ent(get_irn_irg(n)));
-    fprintf(F, "start of method of type %s \n", get_type_name(tp));
+    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(get_method_param_type(tp, i)));
+      fprintf(F, "  param %d type: %s \n", i, get_type_name_ex(get_method_param_type(tp, i), &bad));
   } break;
   case iro_Alloc: {
-    fprintf(F, "allocating entity of type %s \n", get_type_name(get_Alloc_type(n)));
+    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(get_Free_type(n)));
+    fprintf(F, "freeing entity of type %s \n", get_type_name_ex(get_Free_type(n), &bad));
   } break;
   case iro_Sel: {
-    fprintf(F, "Selecting entity of type %s \n", get_type_name(get_entity_type(get_Sel_entity(n))));
-    fprintf(F, "  from entity of type %s \n", get_type_name(get_entity_owner(get_Sel_entity(n))));
+    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(tp));
+    fprintf(F, "calling 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(get_method_param_type(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(get_method_res_type(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++) {
+    if (!get_Call_callee(n, i)) {
+      fprintf(F, "  %d external method\n", i);
+    } else {
+      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);
+    if (Call_has_callees(call)) {
+      fprintf(F, "possible callees: \n");
+      for (i = 0; i < get_Call_n_callees(call); i++) {
+    if (!get_Call_callee(call, i)) {
+      fprintf(F, "  %d external method\n", i);
+    } else {
+      fprintf(F, "  %d: %s\n", i, get_ent_dump_name(get_Call_callee(call, i)));
+    }
+      }
+    }
   } break;
   case iro_Return: {
     if (!interprocedural_view) {
       type *tp = get_entity_type(get_irg_ent(get_irn_irg(n)));
-      fprintf(F, "return in method of type %s \n", get_type_name(tp));
+      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(get_method_res_type(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(get_Const_type(n)));
+    fprintf(F, "Const of type %s \n", get_type_name_ex(get_Const_type(n), &bad));
+  } break;
+  case iro_Filter: {
+    int i;
+    if (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;
   default: ;
   }
@@ -501,17 +749,11 @@ dump_node_info (ir_node *n) {
   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_type(n) != none_type)
-      fprintf (F, "\nAnalysed type: %s", get_type_name(get_irn_type(n)));
+      fprintf (F, "\nAnalysed type: %s", get_type_name_ex(get_irn_type(n), &bad));
 
   fprintf (F, "\"");
-}
-
-/* Returns true if n and pred pos are in different graphs. */
-static bool pred_in_wrong_graph(ir_node *n, int pos) {
-  ir_node *pred = get_irn_n(n, pos);
 
-  if (get_irn_irg(n) != get_irn_irg(pred)) return true;
-  return false;
+  return bad;
 }
 
 
@@ -523,64 +765,78 @@ bool is_constlike_node(ir_node *n) {
 
 
 /* outputs the predecessors of n, that are constants, local.  I.e.,
-   generates a copy of the constant for each node called with. */
+   generates a copy of the constant predecessors for each node called with. */
 static void dump_const_node_local(ir_node *n) {
   int i;
   if (!get_opt_dump_const_local()) return;
+
   /* Use visited flag to avoid outputting nodes twice.
      initialize it first. */
   for (i = 0; i < get_irn_arity(n); i++) {
     ir_node *con = get_irn_n(n, i);
     if (is_constlike_node(con)) {
-      if (pred_in_wrong_graph(n, i)) continue; /* pred not dumped */
       set_irn_visited(con, get_irg_visited(current_ir_graph)-1);
     }
   }
+
   for (i = 0; i < get_irn_arity(n); i++) {
     ir_node *con = get_irn_n(n, i);
     if (is_constlike_node(con) && irn_not_visited(con)) {
-      if (pred_in_wrong_graph(n, i)) continue; /* pred not dumped */
+      int bad = 0;
+
       mark_irn_visited(con);
       /* Generate a new name for the node by appending the names of
-	 n and const. */
-      fprintf (F, "node: {title: "); PRINT_CONSTID(n,con);
+     n and const. */
+      fprintf(F, "node: {title: "); PRINT_CONSTID(n, con);
       fprintf(F, " label: \"");
-      dump_node_opcode(con);
-      dump_node_mode (con);
-      dump_node_typeinfo(con);
+      bad |= dump_node_opcode(F, con);
+      bad |= dump_node_mode (con);
+      bad |= dump_node_typeinfo(con);
       fprintf (F, " ");
-      dump_node_nodeattr(con);
-#ifdef DEBUG_libfirm
-      fprintf (F, " %ld", get_irn_node_nr(con));
-#endif
-      fprintf (F, "\" ");
-      dump_node_vcgattr(con);
-      dump_node_info(con);
-      fprintf (F, "}\n");
+      bad |= dump_node_nodeattr(con);
+      fprintf(F, " %ld", get_irn_node_nr(con));
+      fprintf(F, "\" ");
+      bad |= dump_node_info(con);
+      dump_node_vcgattr(con, bad);
+      fprintf(F, "}\n");
     }
   }
 }
 
-static void
-dump_node (ir_node *n) {
-  if (get_opt_dump_const_local() && is_constlike_node(n)) return;
+static void print_node_error(const char *p)
+{
+  if (! p)
+    return;
 
+  fprintf (F, " info2: \"%s\"", p);
+}
+
+static void dump_node(ir_node *n)
+{
+  int bad = 0;
+  const char *p;
+
+  if (get_opt_dump_const_local() && is_constlike_node(n)) return;
   /* dump this node */
-  fprintf (F, "node: {title: \""); PRINT_NODEID(n); fprintf(F, "\" label: \"");
-
-  dump_node_opcode(n);
-  dump_node_mode (n);
-  dump_node_typeinfo(n);
-  fprintf (F, " ");
-  dump_node_nodeattr(n);
-#ifdef DEBUG_libfirm
-  fprintf (F, " %ld", get_irn_node_nr(n));
-#endif
-  fprintf (F, "\" ");
-  dump_node_vcgattr(n);
-  dump_node_info(n);
-  fprintf (F, "}\n");
+  fprintf(F, "node: {title: \""); PRINT_NODEID(n); fprintf(F, "\" label: \"");
+
+  bad = ! irn_vrfy_irg_dump(n, current_ir_graph, &p);
+  bad |= dump_node_opcode(F, n);
+  bad |= dump_node_mode (n);
+  bad |= dump_node_typeinfo(n);
+  fprintf(F, " ");
+  bad |= dump_node_nodeattr(n);
+  fprintf(F, " %ld", get_irn_node_nr(n));
+  fprintf(F, "\" ");
+  bad |= dump_node_info(n);
+  print_node_error(p);
+  dump_node_vcgattr(n, bad);
+  fprintf(F, "}\n");
   dump_const_node_local(n);
+#if DO_HEAPANALYSIS
+  dump_chi_term(F, n);
+  dump_state(F, n);
+#endif
 }
 
 /* dump the edge to the block this node belongs to */
@@ -592,11 +848,28 @@ dump_ir_block_edge(ir_node *n)  {
     PRINT_NODEID(n);
     fprintf (F, "\" targetname: \"");
     PRINT_NODEID(get_nodes_block(n));
-    fprintf (F, "\" "	BLOCK_EDGE_ATTR "}\n");
+    fprintf (F, "\" "   BLOCK_EDGE_ATTR "}\n");
   }
 }
 
-static void print_edge_vcgattr(ir_node *from, int to) {
+static void
+print_data_edge_vcgattr(FILE *F, ir_node *from, int to) {
+  if (get_nodes_block(from) == get_nodes_block(get_irn_n(from, to)))
+    fprintf (F, INTRA_DATA_EDGE_ATTR);
+  else
+    fprintf (F, INTER_DATA_EDGE_ATTR);
+}
+
+static void
+print_mem_edge_vcgattr(FILE *F, ir_node *from, int to) {
+  if (get_nodes_block(from) == get_nodes_block(get_irn_n(from, to)))
+    fprintf (F, INTRA_MEM_EDGE_ATTR);
+  else
+    fprintf (F, INTER_MEM_EDGE_ATTR);
+}
+
+static void
+print_edge_vcgattr(ir_node *from, int to) {
   assert(from);
 
   if (dump_backedge_information_flag && is_backedge(from, to))
@@ -610,58 +883,81 @@ static void print_edge_vcgattr(ir_node *from, int to) {
   case iro_End:
     if (to >= 0) {
       if (get_irn_mode(get_End_keepalive(from, to)) == mode_BB)
-	fprintf (F, CF_EDGE_ATTR);
+    fprintf (F, CF_EDGE_ATTR);
       if (get_irn_mode(get_End_keepalive(from, to)) == mode_X)
-	fprintf (F, MEM_EDGE_ATTR);
+    fprintf (F, INTER_MEM_EDGE_ATTR);
     }
     break;
-  case iro_EndReg: break;
-  case iro_EndExcept: break;
-  case iro_Jmp:     break;
-  case iro_Break:   break;
-  case iro_Cond:    break;
+  case iro_EndReg:
+  case iro_EndExcept:
+  case iro_Jmp:
+  case iro_Break:
+  case iro_Cond:
+    print_data_edge_vcgattr(F, from, to);
+    break;
   case iro_Return:
   case iro_Raise:
-    if (to == 0) fprintf (F, MEM_EDGE_ATTR);
+    if (to == 0)
+      print_mem_edge_vcgattr(F, from, to);
+    else
+      print_data_edge_vcgattr(F, from, to);
+    break;
+  case iro_Const:
+  case iro_SymConst:
+    print_data_edge_vcgattr(F, from, to);
     break;
-  case iro_Const:   break;
-  case iro_SymConst:break;
   case iro_Sel:
   case iro_Call:
-    if (to == 0) fprintf (F, MEM_EDGE_ATTR);
+    if (to == 0)
+      print_mem_edge_vcgattr(F, from, to);
+    else
+      print_data_edge_vcgattr(F, from, to);
+    break;
+  case iro_CallBegin:
+  case iro_Add:
+  case iro_Sub:
+  case iro_Minus:
+  case iro_Mul:
+    print_data_edge_vcgattr(F, from, to);
     break;
-  case iro_CallBegin: break;
-  case iro_Add:     break;
-  case iro_Sub:     break;
-  case iro_Minus:   break;
-  case iro_Mul:     break;
   case iro_Quot:
   case iro_DivMod:
   case iro_Div:
   case iro_Mod:
-    if (to == 0) fprintf (F, MEM_EDGE_ATTR);
+    if (to == 0)
+      print_mem_edge_vcgattr(F, from, to);
+    else
+      print_data_edge_vcgattr(F, from, to);
+    break;
+  case iro_Abs:
+  case iro_And:
+  case iro_Or:
+  case iro_Eor:
+  case iro_Shl:
+  case iro_Shr:
+  case iro_Shrs:
+  case iro_Rot:
+  case iro_Cmp:
+  case iro_Conv:
+      print_data_edge_vcgattr(F, from, to);
     break;
-  case iro_Abs:    break;
-  case iro_And:    break;
-  case iro_Or:     break;
-  case iro_Eor:    break;
-  case iro_Shl:    break;
-  case iro_Shr:    break;
-  case iro_Shrs:   break;
-  case iro_Rot:    break;
-  case iro_Cmp:    break;
-  case iro_Conv:   break;
   case iro_Phi:
-    if (get_irn_modecode(from) == irm_M) fprintf (F, MEM_EDGE_ATTR);
+    if (get_irn_modecode(from) == irm_M)
+      fprintf (F, INTER_MEM_EDGE_ATTR);
+    else
+      print_data_edge_vcgattr(F, from, to);
     break;
   case iro_Load:
   case iro_Store:
   case iro_Alloc:
   case iro_Free:
-    if (to == 0) fprintf (F, MEM_EDGE_ATTR);
+    if (to == 0)
+      print_mem_edge_vcgattr(F, from, to);
+    else
+      print_data_edge_vcgattr(F, from, to);
     break;
   case iro_Sync:
-    fprintf (F, MEM_EDGE_ATTR);
+    print_mem_edge_vcgattr(F, from, to);
     break;
   case iro_Tuple:  break;
   case iro_Proj:
@@ -671,14 +967,27 @@ static void print_edge_vcgattr(ir_node *from, int to) {
       fprintf (F, CF_EDGE_ATTR);
       break;
     case irm_M:
-      fprintf (F, MEM_EDGE_ATTR);
+      fprintf (F, INTER_MEM_EDGE_ATTR);
+      break;
+    default:
+      print_data_edge_vcgattr(F, from, to);
       break;
-    default: break;
     }
     break;
-  case iro_Bad:    break;
+  case iro_Bad:     break;
   case iro_Unknown: break;
-  case iro_Id:     break;
+  case iro_Id:
+    switch (get_irn_modecode(from)) {
+    case irm_M:
+      fprintf (F, INTRA_MEM_EDGE_ATTR);
+      break;
+    case irm_X:
+      fprintf (F, CF_EDGE_ATTR);
+      break;
+    default:
+      print_data_edge_vcgattr(F, from, to);
+      break;
+    } break;
   default:
     ;
   }
@@ -695,16 +1004,17 @@ dump_ir_data_edges(ir_node *n)  {
   for (i = 0; i < get_irn_arity(n); i++) {
     ir_node * pred = get_irn_n(n, i);
     assert(pred);
+
     if ((interprocedural_view && get_irn_visited(pred) < visited))
       continue; /* pred not dumped */
+
     if (dump_backedge_information_flag && is_backedge(n, i))
       fprintf (F, "backedge: {sourcename: \"");
     else
       fprintf (F, "edge: {sourcename: \"");
     PRINT_NODEID(n);
     fprintf (F, "\" targetname: ");
-    if ((get_opt_dump_const_local()) && is_constlike_node(pred) &&
-	!pred_in_wrong_graph(n, i)) {
+    if ((get_opt_dump_const_local()) && is_constlike_node(pred)) {
       PRINT_CONSTID(n, pred);
     } else {
       fprintf(F, "\""); PRINT_NODEID(pred); fprintf(F, "\"");
@@ -770,11 +1080,14 @@ dump_whole_block(ir_node *block) {
   fprintf(F, "graph: { title: \"");
   PRINT_NODEID(block);
   fprintf(F, "\"  label: \"");
-  dump_node_opcode(block);
+  dump_node_opcode(F, block);
   fprintf (F, " %ld", get_irn_node_nr(block));
-
+#if DO_HEAPANALYSIS
+  if (get_opt_dump_abstvals())
+    fprintf (F, " seqno: %d", (int)get_Block_seqno(block));
+#endif
   fprintf(F, "\" status:clustered color:%s \n",
-	   get_Block_matured(block) ? "yellow" : "red");
+       get_Block_matured(block) ? "yellow" : "red");
 
   /* dump the blocks edges */
   dump_ir_data_edges(block);
@@ -788,23 +1101,26 @@ dump_whole_block(ir_node *block) {
   /* Close the vcg information for the block */
   fprintf(F, "}\n");
   dump_const_node_local(block);
+#if DO_HEAPANALYSIS
+  dump_chi_term(F, block);
+#endif
   fprintf(F, "\n");
 }
 
 /** dumps a graph block-wise. Expects all blockless nodes in arr in irgs link.
  *  The outermost nodes: blocks and nodes not pinned, Bad, Unknown. */
 static void
-dump_block_graph (ir_graph *irg) {
+dump_block_graph(ir_graph *irg) {
   int i;
   ir_graph *rem = current_ir_graph;
-  current_ir_graph = irg;
   ir_node **arr = ird_get_irg_link(irg);
+  current_ir_graph = irg;
 
   for (i = ARR_LEN(arr) - 1; i >= 0; --i) {
     ir_node * node = arr[i];
     if (is_Block(node)) {
       /* Dumps the block and all the nodes in the block, which are to
-	 be found in Block->link. */
+     be found in Block->link. */
       dump_whole_block(node);
     } else {
       /* Nodes that are not in a Block. */
@@ -813,7 +1129,7 @@ dump_block_graph (ir_graph *irg) {
     }
   }
 
-  if (dump_loop_information_flag) dump_loop_info(irg);
+  if (dump_loop_information_flag) dump_loop_nodes_into_graph(irg);
 
   current_ir_graph = rem;
 }
@@ -826,7 +1142,7 @@ static void dump_graph(ir_graph *irg) {
   fprintf(F, "graph: { title: \"");
   PRINT_IRGID(irg);
   fprintf(F, "\" label: \"%s\" status:clustered color:white \n",
-	  get_entity_name(get_irg_ent(irg)));
+      get_ent_dump_name(get_irg_ent(irg)));
 
   dump_block_graph (irg);
 
@@ -848,26 +1164,26 @@ static void dump_node2type_edges (ir_node *n, void *env)
     /* @@@ some consts have an entity */
     break;
   case iro_SymConst:
-    if (   (get_SymConst_kind(n) == type_tag)
-	   || (get_SymConst_kind(n) == size))
+    if (   (get_SymConst_kind(n) ==symconst_type_tag)
+       || (get_SymConst_kind(n) ==symconst_size))
       {
-	PRINT_NODE_TYPE_EDGE(n,get_SymConst_type(n),NODE2TYPE_EDGE_ATTR);
+    print_node_type_edge(F,n,get_SymConst_type(n),NODE2TYPE_EDGE_ATTR);
       }
     break;
   case iro_Sel: {
-      PRINT_NODE_ENT_EDGE(n,get_Sel_entity(n),NODE2TYPE_EDGE_ATTR);
+      print_node_ent_edge(F,n,get_Sel_entity(n),NODE2TYPE_EDGE_ATTR);
     } break;
   case iro_Call: {
-      PRINT_NODE_TYPE_EDGE(n,get_Call_type(n),NODE2TYPE_EDGE_ATTR);
+      print_node_type_edge(F,n,get_Call_type(n),NODE2TYPE_EDGE_ATTR);
     } break;
   case iro_Alloc: {
-      PRINT_NODE_TYPE_EDGE(n,get_Alloc_type(n),NODE2TYPE_EDGE_ATTR);
+      print_node_type_edge(F,n,get_Alloc_type(n),NODE2TYPE_EDGE_ATTR);
     } break;
   case iro_Free: {
-      PRINT_NODE_TYPE_EDGE(n,get_Free_type(n),NODE2TYPE_EDGE_ATTR);
+      print_node_type_edge(F,n,get_Free_type(n),NODE2TYPE_EDGE_ATTR);
     } break;
   case iro_Cast: {
-      PRINT_NODE_TYPE_EDGE(n,get_Cast_type(n),NODE2TYPE_EDGE_ATTR);
+      print_node_type_edge(F,n,get_Cast_type(n),NODE2TYPE_EDGE_ATTR);
     } break;
   default:
     break;
@@ -875,15 +1191,19 @@ static void dump_node2type_edges (ir_node *n, void *env)
 }
 
 
-static void print_type_info(type *tp) {
+static int print_type_info(type *tp) {
+  int bad = 0;
+
   if (get_type_state(tp) == layout_undefined) {
     fprintf(F, "state: layout_undefined\n");
   } else {
     fprintf(F, "state: layout_fixed,\n");
   }
   if (get_type_mode(tp))
-    fprintf(F, "mode: %s,\n", get_mode_name(get_type_mode(tp)));
-  fprintf(F, "size: %dB,\n", get_type_size(tp));
+    fprintf(F, "mode: %s,\n", get_mode_name_ex(get_type_mode(tp), &bad));
+  fprintf(F, "size: %db,\n", get_type_size_bits(tp));
+
+  return bad;
 }
 
 static void print_typespecific_info(type *tp) {
@@ -897,6 +1217,9 @@ static void print_typespecific_info(type *tp) {
     } break;
   case tpo_method:
     {
+      fprintf(F, "variadicity: %s\n", get_variadicity_name(get_method_variadicity(tp)));
+      fprintf(F, "params: %d\n", get_method_n_params(tp));
+      fprintf(F, "results: %d\n", get_method_n_ress(tp));
     } break;
   case tpo_union:
     {
@@ -923,9 +1246,9 @@ static void print_typespecific_vcgattr(type *tp) {
   case tpo_class:
     {
       if (peculiarity_existent == get_class_peculiarity(tp))
-	fprintf (F, " " TYPE_CLASS_NODE_ATTR);
+    fprintf (F, " " TYPE_CLASS_NODE_ATTR);
       else
-	fprintf (F, " " TYPE_DESCRIPTION_NODE_ATTR);
+    fprintf (F, " " TYPE_DESCRIPTION_NODE_ATTR);
     } break;
   case tpo_struct:
     {
@@ -953,27 +1276,31 @@ static void print_typespecific_vcgattr(type *tp) {
   } /* switch type */
 }
 
-static void print_type_node(type *tp)
+static int print_type_node(type *tp)
 {
+  int bad = 0;
+
   fprintf (F, "node: {title: ");
   PRINT_TYPEID(tp);
-  fprintf (F, " label: \"%s %s\"", get_type_tpop_name(tp), get_type_name(tp));
+  fprintf (F, " label: \"%s %s\"", get_type_tpop_name(tp), get_type_name_ex(tp, &bad));
   fprintf (F, " info1: \"");
-  print_type_info(tp);
+  bad |= print_type_info(tp);
   print_typespecific_info(tp);
   fprintf (F, "\"");
   print_typespecific_vcgattr(tp);
   fprintf (F, "}\n");
+
+  return bad;
 }
 
-#define X(a)	case a: fprintf(F, #a); break
+#define X(a)    case a: fprintf(F, #a); break
 void dump_entity_node(entity *ent)
 {
   fprintf (F, "node: {title: \"");
   PRINT_ENTID(ent); fprintf(F, "\"");
   fprintf (F, DEFAULT_TYPE_ATTRIBUTE);
   fprintf (F, "label: ");
-  fprintf (F, "\"ent %s\" " ENTITY_NODE_ATTR , get_entity_name(ent));
+  fprintf (F, "\"ent %s\" " ENTITY_NODE_ATTR , get_ent_dump_name(ent));
   fprintf (F, "\n info1: \"\nid: "); PRINT_ENTID(ent);
 
   fprintf (F, "\nallocation:  ");
@@ -1005,10 +1332,10 @@ void dump_entity_node(entity *ent)
     X(volatility_is_volatile);
   }
 
-  fprintf(F, "\npeculiarity: %s", get_peculiarity_string(get_entity_peculiarity(ent)));
-  fprintf(F, "\nname:    %s\nld_name: %s",
-	  get_entity_name(ent), ent->ld_name ? get_entity_ld_name(ent) : "no yet set");
-  fprintf(F, "\noffset:  %d", get_entity_offset(ent));
+  fprintf(F, "\npeculiarity:  %s", get_peculiarity_string(get_entity_peculiarity(ent)));
+  fprintf(F, "\nname:         %s\nld_name:      %s",
+      get_entity_name(ent), ent->ld_name ? get_entity_ld_name(ent) : "no yet set");
+  fprintf(F, "\noffset(bits): %d", get_entity_offset_bits(ent));
   if (is_method_type(get_entity_type(ent))) {
     if (get_entity_irg(ent))   /* can be null */
       { fprintf (F, "\nirg = "); PRINT_IRGID(get_entity_irg(ent)); }
@@ -1019,6 +1346,21 @@ void dump_entity_node(entity *ent)
 }
 #undef X
 
+static void dump_enum_item(type *tp, int pos)
+{
+  char buf[1024];
+  ident *id  = get_enumeration_nameid(tp, pos);
+  tarval *tv = get_enumeration_enum(tp, pos);
+
+  tarval_snprintf(buf, sizeof(buf), tv);
+  fprintf (F, "node: {title: \"");
+  PRINT_ITEMID(tp, pos); fprintf(F, "\"");
+  fprintf (F, DEFAULT_ENUM_ITEM_ATTRIBUTE);
+  fprintf (F, "label: ");
+  fprintf (F, "\"enum item %s\" " ENUM_ITEM_NODE_ATTR, get_id_str(id));
+  fprintf (F, "\n info1: \"value: %s\"}\n", buf);
+}
+
 /* dumps a type or entity and it's edges. */
 static void
 dump_type_info (type_or_ent *tore, void *env) {
@@ -1037,37 +1379,37 @@ dump_type_info (type_or_ent *tore, void *env) {
       /* skip this to reduce graph.  Member edge of type is parallel to this edge. *
       fprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
                 ENT_OWN_EDGE_ATTR "}\n", ent, get_entity_owner(ent));*/
-      PRINT_ENT_TYPE_EDGE(ent, get_entity_type(ent), ENT_TYPE_EDGE_ATTR);
+      print_ent_type_edge(F,ent, get_entity_type(ent), ENT_TYPE_EDGE_ATTR);
       if(is_class_type(get_entity_owner(ent))) {
-	for(i = 0; i < get_entity_n_overwrites(ent); i++){
-	  PRINT_ENT_ENT_EDGE(ent, get_entity_overwrites(ent, i), ENT_OVERWRITES_EDGE_ATTR);
-	}
+    for(i = 0; i < get_entity_n_overwrites(ent); i++){
+      print_ent_ent_edge(F,ent, get_entity_overwrites(ent, i), ENT_OVERWRITES_EDGE_ATTR);
+    }
       }
       /* attached subgraphs */
       if (const_entities && (get_entity_variability(ent) != variability_uninitialized)) {
-	if (is_atomic_entity(ent)) {
-	  value = get_atomic_ent_value(ent);
-	  if (value) {
-            PRINT_ENT_NODE_EDGE(ent, value, ENT_VALUE_EDGE_ATTR, i);
-	    /* DDMN(value);  $$$ */
-	    dump_const_expression(value);
-	  }
-	}
-	if (is_compound_entity(ent)) {
-	  for (i = 0; i < get_compound_ent_n_values(ent); i++) {
-	    value = get_compound_ent_value(ent, i);
-	    if (value) {
-              PRINT_ENT_NODE_EDGE(ent,value,ENT_VALUE_EDGE_ATTR,i);
-	      dump_const_expression(value);
-	      PRINT_ENT_ENT_EDGE(ent, get_compound_ent_value_member(ent, i), ENT_CORR_EDGE_ATTR, i);
-	      /*
-		fprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
-		ENT_CORR_EDGE_ATTR  "}\n", GET_ENTID(ent),
-		get_compound_ent_value_member(ent, i), i);
-	      */
-	    }
-	  }
-	}
+    if (is_atomic_entity(ent)) {
+      value = get_atomic_ent_value(ent);
+      if (value) {
+            print_ent_node_edge(F,ent, value, ENT_VALUE_EDGE_ATTR, i);
+        /* DDMN(value);  $$$ */
+        dump_const_expression(value);
+      }
+    }
+    if (is_compound_entity(ent)) {
+      for (i = 0; i < get_compound_ent_n_values(ent); i++) {
+        value = get_compound_ent_value(ent, i);
+        if (value) {
+              print_ent_node_edge(F,ent,value,ENT_VALUE_EDGE_ATTR,i);
+          dump_const_expression(value);
+          print_ent_ent_edge(F,ent, get_compound_ent_value_member(ent, i), ENT_CORR_EDGE_ATTR, i);
+          /*
+        fprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
+        ENT_CORR_EDGE_ATTR  "}\n", GET_ENTID(ent),
+        get_compound_ent_value_member(ent, i), i);
+          */
+        }
+      }
+    }
       }
     } break;
   case k_type:
@@ -1077,63 +1419,67 @@ dump_type_info (type_or_ent *tore, void *env) {
       /* and now the edges */
       switch (get_type_tpop_code(tp)) {
       case tpo_class:
-	{
-	  for (i=0; i < get_class_n_supertypes(tp); i++) {
-	    PRINT_TYPE_TYPE_EDGE(tp,get_class_supertype(tp, i),TYPE_SUPER_EDGE_ATTR);
-	  }
-
-	  for (i=0; i < get_class_n_members(tp); i++) {
-	    PRINT_TYPE_ENT_EDGE(tp,get_class_member(tp, i),TYPE_MEMBER_EDGE_ATTR);
-	  }
-	} break;
+    {
+      for (i=0; i < get_class_n_supertypes(tp); i++) {
+        print_type_type_edge(F, tp,get_class_supertype(tp, i),TYPE_SUPER_EDGE_ATTR);
+      }
+
+      for (i=0; i < get_class_n_members(tp); i++) {
+        print_type_ent_edge(F,tp,get_class_member(tp, i),TYPE_MEMBER_EDGE_ATTR);
+      }
+    } break;
       case tpo_struct:
-	{
-	  for (i=0; i < get_struct_n_members(tp); i++) {
-	    PRINT_TYPE_ENT_EDGE(tp,get_struct_member(tp, i),TYPE_MEMBER_EDGE_ATTR);
-	  }
-	} break;
+    {
+      for (i=0; i < get_struct_n_members(tp); i++) {
+        print_type_ent_edge(F,tp,get_struct_member(tp, i),TYPE_MEMBER_EDGE_ATTR);
+      }
+    } break;
       case tpo_method:
-	{
-	  for (i = 0; i < get_method_n_params(tp); i++)
-	  {
-		  PRINT_TYPE_TYPE_EDGE(tp,get_method_param_type(tp, i),METH_PAR_EDGE_ATTR,i);
-	  }
-	  for (i = 0; i < get_method_n_ress(tp); i++)
-	  {
-		  PRINT_TYPE_TYPE_EDGE(tp,get_method_res_type(tp, i),METH_RES_EDGE_ATTR,i);
-	  }
-	} break;
+    {
+      for (i = 0; i < get_method_n_params(tp); i++)
+      {
+             print_type_type_edge(F,tp,get_method_param_type(tp, i),METH_PAR_EDGE_ATTR,i);
+      }
+      for (i = 0; i < get_method_n_ress(tp); i++)
+      {
+             print_type_type_edge(F,tp,get_method_res_type(tp, i),METH_RES_EDGE_ATTR,i);
+      }
+    } break;
       case tpo_union:
-	{
-	  for (i = 0; i < get_union_n_members(tp); i++)
-	  {
-		  PRINT_TYPE_ENT_EDGE(tp,get_union_member(tp, i),UNION_EDGE_ATTR);
-	  }
-	} break;
+    {
+      for (i = 0; i < get_union_n_members(tp); i++)
+      {
+            print_type_ent_edge(F,tp,get_union_member(tp, i),UNION_EDGE_ATTR);
+      }
+    } break;
       case tpo_array:
-	{
-		  PRINT_TYPE_TYPE_EDGE(tp,get_array_element_type(tp),ARR_ELT_TYPE_EDGE_ATTR);
-		  PRINT_TYPE_ENT_EDGE(tp,get_array_element_entity(tp),ARR_ENT_EDGE_ATTR);
-		  for (i = 0; i < get_array_n_dimensions(tp); i++) {
-		    ir_node *upper = get_array_upper_bound(tp, i);
-		    ir_node *lower = get_array_lower_bound(tp, i);
-		    PRINT_NODE_TYPE_EDGE(upper, tp, "label: \"upper %d\"", get_array_order(tp, i));
-		    PRINT_NODE_TYPE_EDGE(lower, tp, "label: \"lower %d\"", get_array_order(tp, i));
-		    dump_const_expression(upper);
-		    dump_const_expression(lower);
-		  }
-
-	} break;
+    {
+      print_type_type_edge(F,tp,get_array_element_type(tp),ARR_ELT_TYPE_EDGE_ATTR);
+      print_type_ent_edge(F,tp,get_array_element_entity(tp),ARR_ENT_EDGE_ATTR);
+      for (i = 0; i < get_array_n_dimensions(tp); i++) {
+        ir_node *upper = get_array_upper_bound(tp, i);
+        ir_node *lower = get_array_lower_bound(tp, i);
+        print_node_type_edge(F,upper, tp, "label: \"upper %d\"", get_array_order(tp, i));
+        print_node_type_edge(F,lower, tp, "label: \"lower %d\"", get_array_order(tp, i));
+        dump_const_expression(upper);
+        dump_const_expression(lower);
+      }
+
+    } break;
       case tpo_enumeration:
-	{
-	} break;
+    {
+      for (i = 0; i < get_enumeration_n_enums(tp); ++i) {
+        dump_enum_item(tp, i);
+        print_enum_item_edge(F, tp, i, "label: \"item %d\"", i);
+      }
+    } break;
       case tpo_pointer:
-	{
-		  PRINT_TYPE_TYPE_EDGE(tp,get_pointer_points_to_type(tp), PTR_PTS_TO_EDGE_ATTR);
-	} break;
+    {
+          print_type_type_edge(F,tp,get_pointer_points_to_type(tp), PTR_PTS_TO_EDGE_ATTR);
+    } break;
       case tpo_primitive:
-	{
-	} break;
+    {
+    } break;
       default: break;
       } /* switch type */
     }
@@ -1162,10 +1508,10 @@ dump_class_hierarchy_node (type_or_ent *tore, void *env) {
       /* The node */
       dump_entity_node(ent);
       /* The edges */
-      PRINT_TYPE_ENT_EDGE(get_entity_owner(ent),ent,TYPE_MEMBER_EDGE_ATTR);
+      print_type_ent_edge(F,get_entity_owner(ent),ent,TYPE_MEMBER_EDGE_ATTR);
       for(i = 0; i < get_entity_n_overwrites(ent); i++)
       {
-      PRINT_ENT_ENT_EDGE(get_entity_overwrites(ent, i),ent, ENT_OVERWRITES_EDGE_ATTR);
+      print_ent_ent_edge(F,get_entity_overwrites(ent, i),ent, ENT_OVERWRITES_EDGE_ATTR);
       }
     }
   } break; /* case k_entity */
@@ -1175,12 +1521,12 @@ dump_class_hierarchy_node (type_or_ent *tore, void *env) {
       if (tp == get_glob_type()) break;
       switch (get_type_tpop_code(tp)) {
         case tpo_class: {
-	  print_type_node(tp);
-	  /* and now the edges */
-	  for (i=0; i < get_class_n_supertypes(tp); i++)
-	  {
-		  PRINT_TYPE_TYPE_EDGE(tp,get_class_supertype(tp, i),TYPE_SUPER_EDGE_ATTR);
-	  }
+      print_type_node(tp);
+      /* and now the edges */
+      for (i=0; i < get_class_n_supertypes(tp); i++)
+      {
+          print_type_type_edge(F,tp,get_class_supertype(tp, i),TYPE_SUPER_EDGE_ATTR);
+      }
         } break;
         default: break;
       } /* switch type */
@@ -1212,10 +1558,39 @@ dump_out_edge (ir_node *n, void* env) {
   }
 }
 
+static INLINE void
+dump_loop_label(ir_loop *loop) {
+  fprintf (F, "loop %d, %d sons, %d nodes",
+       get_loop_depth(loop), get_loop_n_sons(loop), get_loop_n_nodes(loop));
+}
+
+static INLINE void dump_loop_info(ir_loop *loop) {
+  fprintf (F, " info1: \"");
+  fprintf (F, " loop nr: %d", get_loop_loop_nr(loop));
+#if DEBUG_libfirm   /* GL @@@ debug analyses */
+  fprintf (F, "\n The loop was analyzed %d times.", (int)get_loop_link(loop));
+#endif
+  fprintf (F, "\"");
+}
+
+static INLINE void
+dump_loop_node(ir_loop *loop) {
+  fprintf (F, "node: {title: \"");
+  PRINT_LOOPID(loop);
+  fprintf (F, "\" label: \"");
+  dump_loop_label(loop);
+  fprintf (F, "\" ");
+  dump_loop_info(loop);
+  fprintf (F, "}\n");
+
+}
+
 static INLINE void
 dump_loop_node_edge (ir_loop *loop, int i) {
   assert(loop);
-  fprintf (F, "edge: {sourcename: \"%p\" targetname: \"", (void*) loop);
+  fprintf (F, "edge: {sourcename: \"");
+  PRINT_LOOPID(loop);
+  fprintf (F, "\" targetname: \"");
   PRINT_NODEID(get_loop_node(loop, i));
   fprintf (F, "\" color: green");
   fprintf (F, "}\n");
@@ -1224,16 +1599,20 @@ dump_loop_node_edge (ir_loop *loop, int i) {
 static INLINE void
 dump_loop_son_edge (ir_loop *loop, int i) {
   assert(loop);
-  fprintf (F, "edge: {sourcename: \"%p\" targetname: \"%p\" color: darkgreen}\n",
-	   (void *)loop, (void *)get_loop_son(loop, i));
+  fprintf (F, "edge: {sourcename: \"");
+  PRINT_LOOPID(loop);
+  fprintf (F, "\" targetname: \"");
+  PRINT_LOOPID(get_loop_son(loop, i));
+  fprintf (F, "\" color: darkgreen label: \"%d\"}\n",
+       get_loop_element_pos(loop, get_loop_son(loop, i)));
 }
 
 static
 void dump_loops (ir_loop *loop) {
   int i;
   /* dump this loop node */
-  fprintf (F, "node: {title: \"%p\" label: \"loop %d, %d sons, %d nodes\" }\n",
-	    (void*)loop, get_loop_depth(loop), get_loop_n_sons(loop), get_loop_n_nodes(loop));
+  dump_loop_node(loop);
+
   /* dump edges to nodes in loop -- only if it is a real loop */
   if (get_loop_depth(loop) != 0) {
     for (i = 0; i < get_loop_n_nodes(loop); i++) {
@@ -1247,7 +1626,7 @@ void dump_loops (ir_loop *loop) {
 }
 
 static INLINE
-void dump_loop_info(ir_graph *irg) {
+void dump_loop_nodes_into_graph(ir_graph *irg) {
   ir_graph *rem = current_ir_graph;
   current_ir_graph = irg;
 
@@ -1262,90 +1641,118 @@ void dump_loop_info(ir_graph *irg) {
 /************************************************************************/
 
 static INLINE void
-dump_vcg_header(const char *name) {
+dump_vcg_header(const char *name, const char *orientation) {
   char *label;
+
   if (edge_label) {
     label = "yes";
   } else {
     label = "no";
   }
 
+  if (!orientation) orientation = "bottom_to_top";
+
   /* print header */
   fprintf (F,
-	   "graph: { title: \"ir graph of %s\"\n"
-	   "display_edge_labels: %s\n"
-	   "layoutalgorithm: mindepth\n"
-	   "manhattan_edges: yes\n"
-	   "port_sharing: no\n"
-	   "orientation: bottom_to_top\n"
-	   "classname 1: \"Data\"\n"
-	   "classname 2: \"Block\"\n"
-	   "classname 3: \"Entity type\"\n"
-	   "classname 4: \"Entity owner\"\n"
-	   "classname 5: \"Method Param\"\n"
-	   "classname 6: \"Method Res\"\n"
-	   "classname 7: \"Super\"\n"
-	   "classname 8: \"Union\"\n"
-	   "classname 9: \"Points-to\"\n"
-	   "classname 10: \"Array Element Type\"\n"
-	   "classname 11: \"Overwrites\"\n"
-	   "classname 12: \"Member\"\n",
-	   name, label);
-
-  fprintf (F, "\n");		/* a separator */
-}
-
-static void vcg_open (ir_graph *irg, char *suffix) {
+       "graph: { title: \"ir graph of %s\"\n"
+       "display_edge_labels: %s\n"
+       "layoutalgorithm: mindepth\n"
+       "manhattan_edges: yes\n"
+       "port_sharing: no\n"
+       "orientation: %s\n"
+       "classname 1:  \"intrablock Data\"\n"
+       "classname 16: \"interblock Data\"\n"
+       "classname 2:  \"Block\"\n"
+       "classname 13: \"Control Flow\"\n"
+       "classname 14: \"intrablock Memory\"\n"
+       "classname 17: \"interblock Memory\"\n"
+       "classname 15: \"Dominators\"\n"
+       "classname 3:  \"Entity type\"\n"
+       "classname 4:  \"Entity owner\"\n"
+       "classname 5:  \"Method Param\"\n"
+       "classname 6:  \"Method Res\"\n"
+       "classname 7:  \"Super\"\n"
+       "classname 8:  \"Union\"\n"
+       "classname 9:  \"Points-to\"\n"
+       "classname 10: \"Array Element Type\"\n"
+       "classname 11: \"Overwrites\"\n"
+       "classname 12: \"Member\"\n"
+       "infoname 1: \"Attribute\"\n"
+       "infoname 2: \"Verification errors\"\n",
+       name, label, orientation);
+
+  fprintf (F, "\n");        /* a separator */
+}
+
+static void vcg_open (ir_graph *irg, char * suffix1, char *suffix2) {
+  const char *nm = get_irg_dump_name(irg);
+  int len = strlen(nm), i, j;
   char *fname;  /* filename to put the vcg information in */
-  const char *cp;
-  ident *id;
-  int len;
+
+  if (!suffix1) suffix1 = "";
+  if (!suffix2) suffix2 = "";
 
   /** open file for vcg graph */
-  id    = get_irg_dump_name(irg);
-  len   = get_id_strlen (id);
-  cp    = get_id_str (id);
-  if (dump_file_suffix)
-    fname = malloc (len + 5 + strlen(suffix) + strlen(dump_file_suffix));
-  else
-    fname = malloc (len + 5 + strlen(suffix));
-  strncpy (fname, cp, len);      /* copy the filename */
-  fname[len] = '\0';
-  if (dump_file_suffix) strcat (fname, dump_file_suffix);  /* append file suffix */
-  strcat (fname, suffix);  /* append file suffix */
+  fname = malloc (len * 2 + strlen(suffix1) + strlen(suffix2) + 5);
+
+  /* strncpy (fname, nm, len); */     /* copy the filename */
+  j = 0;
+  for (i = 0; i < len; ++i) {  /* replase '/' in the name: escape by @. */
+    if (nm[i] == '/') {
+      fname[j] = '@'; j++; fname[j] = '1'; j++;
+    } else if (nm[i] == '@') {
+      fname[j] = '@'; j++; fname[j] = '2'; j++;
+    } else {
+      fname[j] = nm[i]; j++;
+    }
+  }
+  fname[j] = '\0';
+  strcat (fname, suffix1);  /* append file suffix */
+  strcat (fname, suffix2);  /* append file suffix */
   strcat (fname, ".vcg");   /* append the .vcg suffix */
   F = fopen (fname, "w");   /* open file for writing */
   if (!F) {
     panic ("cannot open %s for writing (%m)", fname);  /* not reached */
   }
-  dump_vcg_header(cp);
+  free(fname);
 }
 
-static void vcg_open_name (const char *name) {
+static void vcg_open_name (const char *name, char *suffix) {
   char *fname;  /* filename to put the vcg information in */
-  int len;
+  int i, j, len = strlen(name);
+
+  if (!suffix) suffix = "";
 
   /** open file for vcg graph */
-  len   = strlen(name);
-  fname = malloc (len + 5);
-  if (dump_file_suffix)
-    fname = malloc (len + 5 + strlen(dump_file_suffix));
-  else
-    fname = malloc (len + 5);
-  strcpy (fname, name);    /* copy the filename */
-  if (dump_file_suffix) strcat (fname, dump_file_suffix);
+  fname = malloc (len * 2 + 5 + strlen(suffix));
+  /* strcpy (fname, name);*/    /* copy the filename */
+  j = 0;
+  for (i = 0; i < len; ++i) {  /* replase '/' in the name: escape by @. */
+    if (name[i] == '/') {
+      fname[j] = '@'; j++; fname[j] = '1'; j++;
+    } else if (name[i] == '@') {
+      fname[j] = '@'; j++; fname[j] = '2'; j++;
+    } else {
+      fname[j] = name[i]; j++;
+    }
+  }
+  fname[j] = '\0';
+  strcat (fname, suffix);
   strcat (fname, ".vcg");  /* append the .vcg suffix */
   F = fopen (fname, "w");  /* open file for writing */
   if (!F) {
     panic ("cannot open %s for writing (%m)", fname);  /* not reached */
   }
+  free(fname);
+}
 
-  dump_vcg_header(name);
+static INLINE void dump_vcg_footer (void) {
+  fprintf (F, "}\n");
 }
 
 static void
 vcg_close (void) {
-  fprintf (F, "}\n");  /* print footer */
+  dump_vcg_footer();    /* print footer */
   fclose (F);           /* close vcg file */
 }
 
@@ -1367,11 +1774,14 @@ dump_ir_graph (ir_graph *irg)
   ir_graph *rem;
   char *suffix;
   rem = current_ir_graph;
-  current_ir_graph = irg;
 
+  if(strncmp(get_entity_name(get_irg_ent(irg)),dump_file_filter,strlen(dump_file_filter))!=0) return;
+
+  current_ir_graph = irg;
   if (interprocedural_view) suffix = "-pure-ip";
   else                      suffix = "-pure";
-  vcg_open (irg, suffix);
+  vcg_open (irg, dump_file_suffix, suffix);
+  dump_vcg_header(get_irg_dump_name(irg), NULL);
 
   /* walk over the graph */
   /* dump_whole_node must be called in post visiting predecessors */
@@ -1394,11 +1804,14 @@ dump_ir_block_graph (ir_graph *irg)
   int i;
   char *suffix;
 
-  construct_block_lists(irg);
+  if(strncmp(get_entity_name(get_irg_ent(irg)),dump_file_filter,strlen(dump_file_filter))!=0) return;
 
   if (interprocedural_view) suffix = "-ip";
   else                      suffix = "";
-  vcg_open (irg, suffix);
+  vcg_open (irg, dump_file_suffix, suffix);
+  dump_vcg_header(get_irg_dump_name(irg), NULL);
+
+  construct_block_lists(irg);
 
   for (i = 0; i < get_irp_n_irgs(); i++) {
     ir_node **arr = ird_get_irg_link(get_irp_irg(i));
@@ -1416,14 +1829,17 @@ dump_ir_block_graph (ir_graph *irg)
 void
 dump_ir_graph_w_types (ir_graph *irg)
 {
-  ir_graph *rem;
-  rem = current_ir_graph;
+  ir_graph *rem = current_ir_graph;
   char *suffix;
+
+  if(strncmp(get_irg_dump_name(irg),dump_file_filter,strlen(dump_file_filter))!=0) return;
+
   current_ir_graph = irg;
 
   if (interprocedural_view) suffix = "-pure-wtypes-ip";
   else                      suffix = "-pure-wtypes";
-  vcg_open (irg, suffix);
+  vcg_open (irg, dump_file_suffix, suffix);
+  dump_vcg_header(get_irg_dump_name(irg), NULL);
 
   /* dump common ir graph */
   irg_walk(get_irg_end(irg), NULL, dump_whole_node, NULL);
@@ -1444,9 +1860,12 @@ dump_ir_block_graph_w_types (ir_graph *irg)
   char *suffix;
   ir_graph *rem = current_ir_graph;
 
+  if(strncmp(get_irg_dump_name(irg),dump_file_filter,strlen(dump_file_filter))!=0) return;
+
   if (interprocedural_view) suffix = "-wtypes-ip";
   else                      suffix = "-wtypes";
-  vcg_open (irg, suffix);
+  vcg_open (irg, dump_file_suffix, suffix);
+  dump_vcg_header(get_irg_dump_name(irg), NULL);
 
   /* dump common blocked ir graph */
   construct_block_lists(irg);
@@ -1492,12 +1911,12 @@ dump_block_to_cfg (ir_node *block, void *env) {
     /* Dump the edges */
     for ( i = 0; i < get_Block_n_cfgpreds(block); i++)
       if (get_irn_op(skip_Proj(get_Block_cfgpred(block, i))) != op_Bad) {
-	pred = get_nodes_block(skip_Proj(get_Block_cfgpred(block, i)));
-	fprintf (F, "edge: { sourcename: \"");
-	PRINT_NODEID(block);
-	fprintf (F, "\" targetname: \"");
-	PRINT_NODEID(pred);
-	fprintf (F, "\"}\n");
+    pred = get_nodes_block(skip_Proj(get_Block_cfgpred(block, i)));
+    fprintf (F, "edge: { sourcename: \"");
+    PRINT_NODEID(block);
+    fprintf (F, "\" targetname: \"");
+    PRINT_NODEID(pred);
+    fprintf (F, "\"}\n");
       }
 
     /* Dump dominator edge */
@@ -1518,8 +1937,13 @@ dump_cfg (ir_graph *irg)
   ir_graph *rem = current_ir_graph;
   int ddif = dump_dominator_information_flag;
   int ipv = interprocedural_view;
+
+  if(strncmp(get_irg_dump_name(irg),dump_file_filter,strlen(dump_file_filter))!=0) return;
+
   current_ir_graph = irg;
-  vcg_open (irg, "-cfg");
+
+  vcg_open (irg, dump_file_suffix, "-cfg");
+  dump_vcg_header(get_irg_dump_name(irg), NULL);
 
   if (interprocedural_view) {
     printf("Warning: dumping cfg not in interprocedural view!\n");
@@ -1546,7 +1970,9 @@ void dump_all_cg_block_graph(void) {
   int i;
   int rem_view = interprocedural_view;
   interprocedural_view = 1;
-  vcg_open_name ("All_graphs");
+
+  vcg_open_name ("All_graphs", dump_file_suffix);
+  dump_vcg_header("All_graphs", NULL);
 
   /* collect nodes in all irgs reachable in call graph*/
   for (i = 0; i < get_irp_n_irgs(); i++)
@@ -1557,6 +1983,7 @@ void dump_all_cg_block_graph(void) {
   /* dump all graphs */
   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(current_ir_graph);
     DEL_ARR_F(ird_get_irg_link(current_ir_graph));
   }
@@ -1574,9 +2001,13 @@ dump_type_graph (ir_graph *irg)
 {
   ir_graph *rem;
   rem = current_ir_graph;
+
+  if(strncmp(get_irg_dump_name(irg),dump_file_filter,strlen(dump_file_filter))!=0) return;
+
   current_ir_graph = irg;
 
-  vcg_open (irg, "-type");
+  vcg_open (irg, dump_file_suffix, "-type");
+  dump_vcg_header(get_irg_dump_name(irg), NULL);
 
   /* walk over the blocks in the graph */
   type_walk_irg(irg, dump_type_info, NULL, NULL);
@@ -1593,7 +2024,8 @@ dump_type_graph (ir_graph *irg)
 void
 dump_all_types (void)
 {
-  vcg_open_name ("All_types");
+  vcg_open_name ("All_types", dump_file_suffix);
+  dump_vcg_header("All_types", NULL);
   type_walk(dump_type_info, NULL, NULL);
   inc_irg_visited(get_const_code_irg());
   vcg_close();
@@ -1602,7 +2034,8 @@ dump_all_types (void)
 void
 dump_class_hierarchy (bool entities)
 {
-  vcg_open_name ("class_hierarchy");
+  vcg_open_name ("class_hierarchy", dump_file_suffix);
+  dump_vcg_header("class_hierarchy", NULL);
   if (entities)
     type_walk(dump_class_hierarchy_node, NULL, (void *)1);
   else
@@ -1625,3 +2058,232 @@ void dump_all_ir_graphs (dump_graph_func *dmp_grph) {
     dmp_grph(get_irp_irg(i));
   }
 }
+
+
+/**********************************************************************************
+ * Dumps a stand alone loop graph with firm nodes which belong to one loop nodes  *
+ * packed together in one subgraph                                                *
+ **********************************************************************************/
+
+
+
+void dump_loops_standalone (ir_loop *loop) {
+  int i = 0, loop_node_started = 0, son_number = 0, first = 0;
+  loop_element le;
+  ir_loop *son = NULL;
+
+  /* Dump a new loop node. */
+  dump_loop_node(loop);
+
+  /* Dump the loop elements. */
+
+  for(i = 0; i < get_loop_n_elements(loop); i++)
+    {
+      le = get_loop_element(loop, i);
+      son = le.son;
+      if (get_kind(son) == k_ir_loop) {
+
+        /* We are a loop son -> Recurse */
+
+        if(loop_node_started) { /* Close the "firm-nodes" node first if we started one. */
+          fprintf(F, "\" }\n");
+          fprintf (F, "edge: {sourcename: \"");
+          PRINT_LOOPID(loop);
+          fprintf (F, "\" targetname: \"");
+          PRINT_LOOPID(loop);
+          fprintf (F, "-%d-nodes\" label:\"%d...%d\"}\n", first, first, i-1);
+          loop_node_started = 0;
+        }
+        dump_loop_son_edge(loop, son_number++);
+        dump_loops_standalone(son);
+      }
+      else {
+        /* We are a loop node -> Collect firm nodes */
+
+        ir_node *n = le.node;
+	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;
+        }
+        else
+          fprintf(F, "\n");
+
+        bad |= dump_node_opcode(F, n);
+        bad |= dump_node_mode (n);
+        bad |= dump_node_typeinfo(n);
+        fprintf (F, " ");
+        bad |= dump_node_nodeattr(n);
+        fprintf (F, " %ld", get_irn_node_nr(n));
+      }
+    }
+
+  if (loop_node_started) {
+    fprintf(F, "\" }\n");
+    fprintf (F, "edge: {sourcename: \"");
+    PRINT_LOOPID(loop);
+    fprintf (F, "\" targetname: \"");
+    PRINT_LOOPID(loop);
+    fprintf (F, "-%d-nodes\" label:\"%d...%d\"}\n", first, first, i-1);
+    loop_node_started = 0;
+  }
+}
+
+void dump_loop_tree(ir_graph *irg, char *suffix)
+{
+  ir_graph *rem = current_ir_graph;
+  int el_rem = edge_label;
+  edge_label = 1;
+
+  /* @@@ AS: What does that do? */
+  if(strncmp(get_irg_dump_name(irg),dump_file_filter,strlen(dump_file_filter))!=0) return;
+
+  current_ir_graph = irg;
+
+  vcg_open(irg, suffix, "-looptree");
+  dump_vcg_header(get_irg_dump_name(irg), "top_to_bottom");
+
+  if (get_irg_loop(irg)) dump_loops_standalone(get_irg_loop(irg));
+
+  vcg_close();
+
+  edge_label = el_rem;
+  current_ir_graph = rem;
+}
+
+
+/*******************************************************************************/
+/* Dumps the firm nodes in the loop tree to a graph along with the loop nodes. */
+/*******************************************************************************/
+
+void collect_nodeloop(ir_loop *loop, eset *loopnodes) {
+  int i, son_number = 0, node_number = 0;
+
+  if (dump_loop_information_flag) dump_loop_node(loop);
+
+  for (i = 0; i < get_loop_n_elements(loop); i++) {
+    loop_element le = get_loop_element(loop, i);
+    if (*(le.kind) == k_ir_loop) {
+      if (dump_loop_information_flag) dump_loop_son_edge(loop, son_number++);
+      /* Recur */
+      collect_nodeloop(le.son, loopnodes);
+    } else {
+      if (dump_loop_information_flag) dump_loop_node_edge(loop, node_number++);
+      eset_insert(loopnodes, le.node);
+    }
+  }
+}
+
+void collect_nodeloop_external_nodes(ir_loop *loop, eset *loopnodes, eset *extnodes) {
+  int i, j, start;
+
+  for(i = 0; i < get_loop_n_elements(loop); i++) {
+    loop_element le = get_loop_element(loop, i);
+    if (*(le.kind) == k_ir_loop) {
+      /* Recur */
+      collect_nodeloop_external_nodes(le.son, loopnodes, extnodes);
+    } else {
+      if (is_Block(le.node)) start = 0; else start = -1;
+      for (j = start; j < get_irn_arity(le.node); j++) {
+    ir_node *pred = get_irn_n(le.node, j);
+    if (!eset_contains(loopnodes, pred)) {
+      eset_insert(extnodes, pred);
+      if (!is_Block(pred)) {
+        pred = get_nodes_block(pred);
+        if (!eset_contains(loopnodes, pred)) eset_insert(extnodes, pred);
+          }
+    }
+      }
+    }
+  }
+}
+
+void dump_loop (ir_loop *l, char *suffix) {
+  char name[50];
+  eset *loopnodes = eset_create();
+  eset *extnodes = eset_create();
+  ir_node *n, *b;
+
+  sprintf(name, "loop_%d", get_loop_loop_nr(l));
+  vcg_open_name (name, suffix);
+  dump_vcg_header(name, NULL);
+
+  /* collect all nodes to dump */
+  collect_nodeloop(l, loopnodes);
+  collect_nodeloop_external_nodes(l, loopnodes, extnodes);
+
+  /* build block lists */
+  for (n = eset_first(loopnodes); n != NULL; n = eset_next(loopnodes))
+    set_irn_link(n, NULL);
+  for (n = eset_first(extnodes); n != NULL; n = eset_next(extnodes))
+    set_irn_link(n, NULL);
+  for (n = eset_first(loopnodes); n != NULL; n = eset_next(loopnodes))
+    if (!is_Block(n)) {
+      b = get_nodes_block(n);
+      set_irn_link(n, get_irn_link(b));
+      set_irn_link(b, n);
+    }
+  for (n = eset_first(extnodes); n != NULL; n = eset_next(extnodes))
+    if (!is_Block(n)) {
+      b = get_nodes_block(n);
+      set_irn_link(n, get_irn_link(b));
+      set_irn_link(b, n);
+    }
+
+  for (b = eset_first(loopnodes); b != NULL; b = eset_next(loopnodes))
+    if (is_Block(b)) {
+      fprintf(F, "graph: { title: \"");
+      PRINT_NODEID(b);
+      fprintf(F, "\"  label: \"");
+      dump_node_opcode(F, b);
+      fprintf (F, " %ld", get_irn_node_nr(b));
+      fprintf(F, "\" status:clustered color:yellow\n");
+
+      /* dump the blocks edges */
+      dump_ir_data_edges(b);
+
+      /* dump the nodes that go into the block */
+      for (n = get_irn_link(b); n; n = get_irn_link(n)) {
+    if (eset_contains(extnodes, n)) overrule_nodecolor = "lightblue";
+    dump_node(n);
+    overrule_nodecolor = NULL;
+    if (!eset_contains(extnodes, n)) dump_ir_data_edges(n);
+      }
+
+      /* Close the vcg information for the block */
+      fprintf(F, "}\n");
+      dump_const_node_local(b);
+      fprintf(F, "\n");
+    }
+  for (b = eset_first(extnodes); b != NULL; b = eset_next(extnodes))
+    if (is_Block(b)) {
+      fprintf(F, "graph: { title: \"");
+      PRINT_NODEID(b);
+      fprintf(F, "\"  label: \"");
+      dump_node_opcode(F, b);
+      fprintf (F, " %ld", get_irn_node_nr(b));
+      fprintf(F, "\" status:clustered color:lightblue\n");
+
+      /* dump the nodes that go into the block */
+      for (n = get_irn_link(b); n; n = get_irn_link(n)) {
+    if (!eset_contains(loopnodes, n)) overrule_nodecolor = "lightblue";
+    dump_node(n);
+    overrule_nodecolor = NULL;
+    if (eset_contains(loopnodes, n)) dump_ir_data_edges(n);
+      }
+
+      /* Close the vcg information for the block */
+      fprintf(F, "}\n");
+      dump_const_node_local(b);
+      fprintf(F, "\n");
+    }
+
+  eset_destroy(loopnodes);
+  eset_destroy(extnodes);
+  vcg_close();
+}