X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firdump.c;h=51393706ebddcc3327a4e668067fdf922afa500e;hb=e570f00fb465d212dde403160e97ab45d36d1d7e;hp=0a422e2c939e0568b199aa2f289bcd37420f25ca;hpb=67d0349063ae9ecb5e9a58fcd01fefc9a154bc2d;p=libfirm

diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c
index 0a422e2c9..51393706e 100644
--- a/ir/ir/irdump.c
+++ b/ir/ir/irdump.c
@@ -35,12 +35,14 @@
 # include "irouts.h"
 # include "irdom.h"
 # include "irloop.h"
+# include "irvrfy.h"
 
 # include "panic.h"
 # include "array.h"
 # include "pmap.h"
 # include "eset.h"
 
+/* #undef HEAPANAL  */
 #undef HEAPANAL
 #ifdef HEAPANAL
 void dump_chi_term(FILE *FL, ir_node *n);
@@ -57,15 +59,15 @@ SeqNo get_Block_seqno(ir_node *n);
 #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        "class:13 color: red"
-#define MEM_EDGE_ATTR       "class:14 color: blue"
-#define DOMINATOR_EDGE_ATTR "class:15 color: red"
+#define BLOCK_EDGE_ATTR     "class:2 priority:2 linestyle:dotted"
+#define CF_EDGE_ATTR        "class:13 color:red"
+#define MEM_EDGE_ATTR       "class:14 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"
@@ -94,7 +96,7 @@ SeqNo get_Block_seqno(ir_node *n);
 #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%ld", get_type_nr(X), (Y))
+#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))
@@ -103,9 +105,16 @@ SeqNo get_Block_seqno(ir_node *n);
 #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), (P))
+#define PRINT_ITEMID(X,Y)  fprintf(F, "i%pT%d", (void *) (X), (Y))
 #endif
 
+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, ...)
 {
@@ -198,7 +207,7 @@ static void print_enum_item_edge(FILE *F, type *E, int item, const char *fmt, ..
 
   va_start(ap, fmt);
   fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(E);
-  fprintf(F, " targetname: \""); PRINT_ITEMID(E,item); fprintf(F, "\" ");
+  fprintf(F, " targetname: \""); PRINT_ITEMID(E, item); fprintf(F, "\" ");
   vfprintf(F, fmt, ap);
   fprintf(F,"}\n");
   va_end(ap);
@@ -270,16 +279,18 @@ 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) {
+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 const char *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);
   return get_ent_dump_name(ent);
@@ -408,9 +419,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)) {
 
@@ -429,7 +441,7 @@ dump_node_opcode (ir_node *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)));
+      fprintf (F, "SymC %s ", get_type_name_ex(get_SymConst_type(n), &bad));
       if (get_SymConst_kind(n) == type_tag)
         fprintf (F, "tag");
       else
@@ -454,6 +466,7 @@ dump_node_opcode (ir_node *n)
   }
 
   }  /* end switch */
+  return bad;
 }
 
 static INLINE void
@@ -485,21 +498,27 @@ dump_node_mode (ir_node *n)
   }
 }
 
-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) {
@@ -520,7 +539,7 @@ dump_node_nodeattr (ir_node *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)));
@@ -529,11 +548,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:
@@ -562,11 +586,12 @@ dump_node_vcgattr (ir_node *n)
   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);
@@ -586,40 +611,56 @@ dump_node_info (ir_node *n) {
   }
   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_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)));
-	}
+    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;
@@ -628,54 +669,55 @@ dump_node_info (ir_node *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)));
-	}
+    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));
+    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))));
+    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: ;
   }
 
-
   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, "\"");
+
+  return bad;
 }
 
 
@@ -704,41 +746,56 @@ static void dump_const_node_local(ir_node *n) {
   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)) {
+      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);
+      bad |= dump_node_opcode(F, con);
       dump_node_mode (con);
-      dump_node_typeinfo(con);
+      bad |= dump_node_typeinfo(con);
       fprintf (F, " ");
-      dump_node_nodeattr(con);
-      fprintf (F, " %ld", get_irn_node_nr(con));
-      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) {
+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: \"");
+  fprintf(F, "node: {title: \""); PRINT_NODEID(n); fprintf(F, "\" label: \"");
 
-  dump_node_opcode(n);
+  bad = ! irn_vrfy_irg_dump(n, current_ir_graph, &p);
+  bad |= dump_node_opcode(F, n);
   dump_node_mode (n);
-  dump_node_typeinfo(n);
-  fprintf (F, " ");
-  dump_node_nodeattr(n);
-  fprintf (F, " %ld", get_irn_node_nr(n));
-  fprintf (F, "\" ");
-  dump_node_vcgattr(n);
-  dump_node_info(n);
-  fprintf (F, "}\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);
 #ifdef HEAPANAL
   dump_chi_term(F, n);
@@ -755,7 +812,7 @@ 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");
   }
 }
 
@@ -773,9 +830,9 @@ 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, MEM_EDGE_ATTR);
     }
     break;
   case iro_EndReg: break;
@@ -934,14 +991,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));
 #ifdef HEAPANAL
   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);
@@ -964,7 +1021,7 @@ dump_whole_block(ir_node *block) {
 /** 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;
   ir_node **arr = ird_get_irg_link(irg);
@@ -974,7 +1031,7 @@ dump_block_graph (ir_graph *irg) {
     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. */
@@ -996,7 +1053,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_ent_dump_name(get_irg_ent(irg)));
+      get_ent_dump_name(get_irg_ent(irg)));
 
   dump_block_graph (irg);
 
@@ -1019,9 +1076,9 @@ static void dump_node2type_edges (ir_node *n, void *env)
     break;
   case iro_SymConst:
     if (   (get_SymConst_kind(n) == type_tag)
-	   || (get_SymConst_kind(n) == size))
+       || (get_SymConst_kind(n) == size))
       {
-	print_node_type_edge(F,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: {
@@ -1067,6 +1124,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:
     {
@@ -1093,9 +1153,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:
     {
@@ -1123,20 +1183,24 @@ 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);
   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: \"");
@@ -1177,7 +1241,7 @@ void dump_entity_node(entity *ent)
 
   fprintf(F, "\npeculiarity: %s", get_peculiarity_string(get_entity_peculiarity(ent)));
   fprintf(F, "\nname:    %s\nld_name: %s",
-	  get_ent_dump_name(ent), ent->ld_name ? get_entity_ld_name(ent) : "no yet set");
+      get_entity_name(ent), ent->ld_name ? get_entity_ld_name(ent) : "no yet set");
   fprintf(F, "\noffset:  %d", get_entity_offset(ent));
   if (is_method_type(get_entity_type(ent))) {
     if (get_entity_irg(ent))   /* can be null */
@@ -1224,35 +1288,35 @@ dump_type_info (type_or_ent *tore, void *env) {
                 ENT_OWN_EDGE_ATTR "}\n", ent, get_entity_owner(ent));*/
       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(F,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) {
+    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) {
+        /* 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);
-	      */
-	    }
-	  }
-	}
+          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:
@@ -1262,67 +1326,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(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;
+    {
+      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(F,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++)
-	  {
+    {
+      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++)
-	  {
+      }
+      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;
+      }
+    } break;
       case tpo_union:
-	{
-	  for (i = 0; i < get_union_n_members(tp); i++)
-	  {
+    {
+      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;
+      }
+    } break;
       case tpo_array:
-	{
-	  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;
+    {
+      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:
-	{
-	  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;
+    {
+      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(F,tp,get_pointer_points_to_type(tp), PTR_PTS_TO_EDGE_ATTR);
-	} break;
+    } break;
       case tpo_primitive:
-	{
-	} break;
+    {
+    } break;
       default: break;
       } /* switch type */
     }
@@ -1364,12 +1428,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(F,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 */
@@ -1404,7 +1468,7 @@ 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));
+       get_loop_depth(loop), get_loop_n_sons(loop), get_loop_n_nodes(loop));
 }
 
 static INLINE void dump_loop_info(ir_loop *loop) {
@@ -1447,7 +1511,7 @@ dump_loop_son_edge (ir_loop *loop, int i) {
   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)));
+       get_loop_element_pos(loop, get_loop_son(loop, i)));
 }
 
 static
@@ -1497,44 +1561,57 @@ dump_vcg_header(const char *name, const char *orientation) {
 
   /* 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: %s\n"
-	   "classname 1: \"Data\"\n"
-	   "classname 2: \"Block\"\n"
-	   "classname 13:\"Control Flow\"\n"
-	   "classname 14:\"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",
-	   name, label, orientation);
-
-  fprintf (F, "\n");		/* a separator */
+       "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: \"Data\"\n"
+       "classname 2: \"Block\"\n"
+       "classname 13:\"Control Flow\"\n"
+       "classname 14:\"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);
+  int len = strlen(nm), i, j;
   char *fname;  /* filename to put the vcg information in */
 
   if (!suffix1) suffix1 = "";
   if (!suffix2) suffix2 = "";
 
   /** open file for vcg graph */
-  fname = malloc (len + strlen(suffix1) + strlen(suffix2) + 5);
-  strncpy (fname, nm, len);      /* copy the filename */
-  fname[len] = '\0';
+  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 */
@@ -1547,12 +1624,24 @@ static void vcg_open (ir_graph *irg, char * suffix1, char *suffix2) {
 
 static void vcg_open_name (const char *name, char *suffix) {
   char *fname;  /* filename to put the vcg information in */
+  int i, j, len = strlen(name);
 
   if (!suffix) suffix = "";
 
   /** open file for vcg graph */
-  fname = malloc (strlen(name) + 5 + strlen(suffix));
-  strcpy (fname, name);    /* copy the filename */
+  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 */
@@ -1727,12 +1816,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 */
@@ -1884,58 +1973,60 @@ void dump_all_ir_graphs (dump_graph_func *dmp_grph) {
 
 
 void dump_loops_standalone (ir_loop *loop) {
-  int i, loop_node_started = 0, son_number = 0, first = 0;
+  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++) {
-    ir_loop *son;
-
-    le = get_loop_element(loop, i);
 
-    son = le.son;
-    if (get_kind(son) == k_ir_loop) {
+  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;
+      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);
       }
-      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;
-
-      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 {
+        /* We are a loop node -> Collect firm nodes */
+
+        ir_node *n = 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;
+        }
+        else
+          fprintf(F, "\n");
+
+        dump_node_opcode(F, n);
+        dump_node_mode (n);
+        dump_node_typeinfo(n);
+        fprintf (F, " ");
+        dump_node_nodeattr(n);
+        fprintf (F, " %ld", get_irn_node_nr(n));
       }
-      else
-	fprintf(F, "\n");
-
-      dump_node_opcode(n);
-      dump_node_mode (n);
-      dump_node_typeinfo(n);
-      fprintf (F, " ");
-      dump_node_nodeattr(n);
-      fprintf (F, " %ld", get_irn_node_nr(n));
     }
-  }
 
   if (loop_node_started) {
     fprintf(F, "\" }\n");
@@ -2003,14 +2094,14 @@ void collect_nodeloop_external_nodes(ir_loop *loop, eset *loopnodes, eset *extno
     } 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);
+    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);
           }
-	}
+    }
       }
     }
   }
@@ -2053,7 +2144,7 @@ void dump_loop (ir_loop *l, char *suffix) {
       fprintf(F, "graph: { title: \"");
       PRINT_NODEID(b);
       fprintf(F, "\"  label: \"");
-      dump_node_opcode(b);
+      dump_node_opcode(F, b);
       fprintf (F, " %ld", get_irn_node_nr(b));
       fprintf(F, "\" status:clustered color:yellow\n");
 
@@ -2062,10 +2153,10 @@ void dump_loop (ir_loop *l, char *suffix) {
 
       /* 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);
+    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 */
@@ -2078,16 +2169,16 @@ void dump_loop (ir_loop *l, char *suffix) {
       fprintf(F, "graph: { title: \"");
       PRINT_NODEID(b);
       fprintf(F, "\"  label: \"");
-      dump_node_opcode(b);
+      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);
+    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 */