X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firdump.c;h=ee522391718af4ecae7b2f614bd7adb3f97fce27;hb=487136c5b024ed2f947800450cfa266bb2c0688d;hp=4f26adb5a6193f3ef8ad3952eeca9bb75291f2f8;hpb=533c124f51682b07a0f527b14e6c8b17f83de632;p=libfirm

diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c
index 4f26adb5a..ee5223917 100644
--- a/ir/ir/irdump.c
+++ b/ir/ir/irdump.c
@@ -23,11 +23,11 @@
 
 #include "firm_common_t.h"
 
-#include "irnode_t.h"
-#include "irgraph_t.h"
+#include "irnode.h"
+#include "irgraph.h"
 #include "irprog_t.h"
 #include "entity_t.h"
-#include "irop_t.h"
+#include "irop.h"
 
 #include "irdump_t.h"
 
@@ -41,6 +41,7 @@
 #include "callgraph.h"
 #include "irextbb_t.h"
 #include "dbginfo_t.h"
+#include "irtools.h"
 
 #include "irvrfy.h"
 
@@ -85,38 +86,50 @@ int dump_dominator_information_flag = 0;
 int dump_loop_information_flag = 0;
 int dump_backedge_information_flag = 1;
 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!! */
+int opt_dump_analysed_type_info = 1;
+int opt_dump_pointer_values_to_info = 0;  /* default off: for test compares!! */
 
-static const char *overrule_nodecolor = NULL;
+static dumper_colors overrule_nodecolor = ird_color_default;
 
 /** An additional edge hook. */
 static DUMP_NODE_EDGE_FUNC dump_node_edge_hook = NULL;
 
 void set_dump_node_edge_hook(DUMP_NODE_EDGE_FUNC func)
 {
-    dump_node_edge_hook = func;
+  dump_node_edge_hook = func;
 }
 
 DUMP_NODE_EDGE_FUNC get_dump_node_edge_hook(void)
 {
-    return dump_node_edge_hook;
+  return dump_node_edge_hook;
 }
 
 
-/** The vcg attribute hook. */
+/** The vcg node attribute hook. */
+static DUMP_IR_GRAPH_FUNC dump_ir_graph_hook = NULL;
+/** The vcg node attribute hook. */
 static DUMP_NODE_VCGATTR_FUNC dump_node_vcgattr_hook = NULL;
+/** The vcg edge attribute hook. */
+static DUMP_EDGE_VCGATTR_FUNC dump_edge_vcgattr_hook = NULL;
 
-/* set the hook */
+/* set the ir graph hook */
+void set_dump_ir_graph_hook(DUMP_IR_GRAPH_FUNC hook) {
+  dump_ir_graph_hook = hook;
+}
+/* set the node attribute hook */
 void set_dump_node_vcgattr_hook(DUMP_NODE_VCGATTR_FUNC hook) {
   dump_node_vcgattr_hook = hook;
 }
+/* set the edge attribute hook */
+void set_dump_edge_vcgattr_hook(DUMP_EDGE_VCGATTR_FUNC hook) {
+  dump_edge_vcgattr_hook = hook;
+}
 
-INLINE bool get_opt_dump_const_local(void) {
+INLINE int get_opt_dump_const_local(void) {
   if (!dump_out_edge_flag && !dump_loop_information_flag)
     return dump_const_local;
   else
-    return false;
+    return 0;
 }
 
 void only_dump_method_with_name(ident *name) {
@@ -127,65 +140,65 @@ ident *get_dump_file_filter_ident(void) {
   return dump_file_filter_id;
 }
 
-/** Returns true if dump file filter is not set, or if it is a
+/** Returns non-zero if dump file filter is not set, or if it is a
  *  prefix of name. */
 int is_filtered_dump_name(ident *name) {
   if (!dump_file_filter_id) return 1;
   return id_is_prefix(dump_file_filter_id, name);
 }
 
-/* To turn off display of edge labels.  Edge labels offen cause xvcg to
+/* To turn off display of edge labels.  Edge labels often cause xvcg to
    abort with a segmentation fault. */
 void turn_off_edge_labels(void) {
   edge_label = 0;
 }
 
-void dump_consts_local(bool b) {
-  dump_const_local = b;
+void dump_consts_local(int flag) {
+  dump_const_local = flag;
 }
 
-void dump_constant_entity_values(bool b) {
-  const_entities = b;
+void dump_constant_entity_values(int flag) {
+  const_entities = flag;
 }
 
-void dump_keepalive_edges(bool b) {
-  dump_keepalive = b;
+void dump_keepalive_edges(int flag) {
+  dump_keepalive = flag;
 }
 
-bool get_opt_dump_keepalive_edges(void) {
+int get_opt_dump_keepalive_edges(void) {
   return dump_keepalive;
 }
 
-void dump_out_edges(bool b) {
-  dump_out_edge_flag = b;
+void dump_out_edges(int flag) {
+  dump_out_edge_flag = flag;
 }
 
-void dump_dominator_information(bool b) {
-  dump_dominator_information_flag = b;
+void dump_dominator_information(int flag) {
+  dump_dominator_information_flag = flag;
 }
 
-void dump_loop_information(bool b) {
-  dump_loop_information_flag = b;
+void dump_loop_information(int flag) {
+  dump_loop_information_flag = flag;
 }
 
-void dump_backedge_information(bool b) {
-  dump_backedge_information_flag = b;
+void dump_backedge_information(int flag) {
+  dump_backedge_information_flag = flag;
 }
 
 /* Dump the information of type field specified in ana/irtypeinfo.h.
  * If the flag is set, the type name is output in [] in the node label,
  * else it is output as info.
  */
-void set_opt_dump_analysed_type_info(bool b) {
-  opt_dump_analysed_type_info = b;
+void set_opt_dump_analysed_type_info(int flag) {
+  opt_dump_analysed_type_info = flag;
 }
 
-void dump_pointer_values_to_info(bool b) {
-  opt_dump_pointer_values_to_info = b;
+void dump_pointer_values_to_info(int flag) {
+  opt_dump_pointer_values_to_info = flag;
 }
 
-void dump_ld_names(bool b) {
-  dump_ld_name = b;
+void dump_ld_names(int flag) {
+  dump_ld_name = flag;
 }
 
 /* -------------- some extended helper functions ----------------- */
@@ -214,6 +227,25 @@ const char *get_type_name_ex(type *tp, int *bad)
   return ERROR_TXT;
 }
 
+/**
+ * printf the VCG color
+ */
+static void print_vcg_color(FILE *F, dumper_colors color) {
+  static const char *color_names[32] = {
+    "white",        "blue",      "red",        "green",
+    "yellow",       "magenta",   "cyan",       "darkgray",
+    "darkblue",     "darkred",   "darkgreen",  "darkyellow",
+    "darkmagenta",  "darkcyan",  "gold",       "lightgray",
+    "lightblue",    "lightred",  "lightgreen", "lightyellow",
+    "lightmagenta", "lightcyan", "lilac",      "turquoise",
+    "aquamarine",   "khaki",     "purple",     "yellowgreen",
+    "pink",         "orange",    "orchid",     "black"
+  };
+
+  if (color != ird_color_default)
+    fprintf(F, "color:%s", color_names[color]);
+}
+
 /**
  * prints the edge from a type S to a type T with additional info fmt, ...
  * to the file F
@@ -394,7 +426,8 @@ static void *ird_get_irn_link(ir_node *n) {
  * Sets the private link field.
  */
 static void ird_set_irn_link(ir_node *n, void *x) {
-  if (!irdump_link_map) init_irdump();
+  if (!irdump_link_map)
+    init_irdump();
   pmap_insert(irdump_link_map, (void *)n, x);
 }
 
@@ -510,7 +543,7 @@ 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. */
-  set_interprocedural_view(false);
+  set_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);
@@ -570,12 +603,17 @@ static list_tuple *construct_extblock_lists(ir_graph *irg) {
 /*
  * dump the name of a node n to the File F.
  */
-int
-dump_node_opcode(FILE *F, ir_node *n)
+int dump_node_opcode(FILE *F, ir_node *n)
 {
   int bad = 0;
+  const ir_op_ops *ops = get_op_ops(get_irn_op(n));
 
-  switch(get_irn_opcode(n)) {
+  /* call the dump_node operation if available */
+  if (ops->dump_node)
+    return ops->dump_node(n, F, dump_node_opcode_txt);
+
+  /* implementation for default nodes */
+  switch (get_irn_opcode(n)) {
 
   case iro_Const: {
     int res;
@@ -645,11 +683,13 @@ dump_node_opcode(FILE *F, ir_node *n)
   case iro_Load:
     fprintf (F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_Load_mode(n), &bad));
     break;
+  case iro_Block:
+    fprintf (F, "%s%s", is_Block_dead(n) ? "Dead " : "", get_irn_opname(n));
+    break;
 
-  default: {
+  default:
 default_case:
     fprintf (F, "%s", get_irn_opname(n));
-  }
 
   }  /* end switch */
   return bad;
@@ -659,12 +699,18 @@ default_case:
  * Dump the mode of a node n to a file F.
  * Ignore modes that are "always known".
  */
-static INLINE int
-dump_node_mode(FILE *F, ir_node *n)
+static int dump_node_mode(FILE *F, ir_node *n)
 {
   int bad = 0;
-  opcode iro = get_irn_opcode(n);
+  const ir_op_ops *ops = get_op_ops(get_irn_op(n));
+  opcode iro;
+
+  /* call the dump_node operation if available */
+  if (ops->dump_node)
+    return ops->dump_node(n, F, dump_node_mode_txt);
 
+  /* default implementation */
+  iro = get_irn_opcode(n);
   switch (iro) {
     case iro_SymConst:
     case iro_Sel:
@@ -832,17 +878,22 @@ static const proj_lookup_t proj_lut[] = {
 /**
  * Dump additional node attributes of some nodes to a file F.
  */
-static INLINE int
+static int
 dump_node_nodeattr(FILE *F, ir_node *n)
 {
   int bad = 0;
   ir_node *pred;
   opcode code;
   long proj_nr;
+  const ir_op_ops *ops = get_op_ops(get_irn_op(n));
+
+  /* call the dump_node operation if available */
+  if (ops->dump_node)
+    return ops->dump_node(n, F, dump_node_nodeattr_txt);
 
   switch (get_irn_opcode(n)) {
   case iro_Start:
-    if (false && get_interprocedural_view()) {
+    if (0 && get_interprocedural_view()) {
       fprintf (F, "%s ", get_ent_dump_name(get_irg_entity(current_ir_graph)));
     }
     break;
@@ -874,6 +925,12 @@ handle_lut:
       }
       if (! f)
         fprintf (F, "%ld ", proj_nr);
+      if (code == iro_Cond && get_Cond_jmp_pred(pred) != COND_JMP_PRED_NONE) {
+        if (proj_nr == pn_Cond_false && get_Cond_jmp_pred(pred) == COND_JMP_PRED_FALSE)
+          fprintf(F, "PRED ");
+        if (proj_nr == pn_Cond_true && get_Cond_jmp_pred(pred) == COND_JMP_PRED_TRUE)
+          fprintf(F, "PRED ");
+      }
     }
     break;
   case iro_Filter:
@@ -895,6 +952,9 @@ handle_lut:
   case iro_Confirm:
     fprintf (F, "%s ", get_pnc_string(get_Confirm_cmp(n)));
     break;
+  case iro_CopyB:
+    fprintf (F, "(%s) ", get_type_name_ex(get_CopyB_type(n), &bad));
+    break;
 
   default:
     ;
@@ -942,7 +1002,7 @@ static void dump_node_vcgattr(FILE *F, ir_node *node, ir_node *local, int bad)
   ir_node *n;
 
   if (bad) {
-    fprintf(F, "color: red");
+    print_vcg_color(F, ird_color_red);
     return;
   }
 
@@ -952,6 +1012,11 @@ static void dump_node_vcgattr(FILE *F, ir_node *node, ir_node *local, int bad)
 
   n = local ? local : node;
 
+  if (overrule_nodecolor != ird_color_default) {
+    print_vcg_color(F, overrule_nodecolor);
+    return;
+  }
+
   switch (get_irn_opcode(n)) {
   case iro_Start:
   case iro_EndReg:
@@ -959,28 +1024,26 @@ static void dump_node_vcgattr(FILE *F, ir_node *node, ir_node *local, int bad)
   case iro_EndExcept:
     /* fall through */
   case iro_End:
-    fprintf (F, "color: blue");
+    print_vcg_color(F, ird_color_blue);
     break;
   case iro_Block:
     if (is_Block_dead(n))
-      fprintf (F, "color: lightred");
+      print_vcg_color(F, ird_color_lightred);
     else
-      fprintf (F, "color: lightyellow");
+      print_vcg_color(F, ird_color_lightyellow);
     break;
   case iro_Phi:
-    fprintf (F, "color: green");
+    print_vcg_color(F, ird_color_green);
     break;
   case iro_Const:
   case iro_Proj:
   case iro_Filter:
   case iro_Tuple:
-    fprintf (F, "color: yellow");
+    print_vcg_color(F, ird_color_yellow);
     break;
   default:
     PRINT_DEFAULT_NODE_ATTR;
   }
-
-  if (overrule_nodecolor) fprintf(F, " color: %s", overrule_nodecolor);
 }
 
 
@@ -988,10 +1051,17 @@ static void dump_node_vcgattr(FILE *F, ir_node *node, ir_node *local, int bad)
  * Dump the node information of a node n to a file F.
  */
 static INLINE int dump_node_info(FILE *F, ir_node *n)
-{ int bad = 0;
+{
+  int bad = 0;
+  const ir_op_ops *ops = get_op_ops(get_irn_op(n));
+
   fprintf (F, " info1: \"");
   bad = dump_irnode_to_file(F, n);
+  /* call the dump_node operation if available */
+  if (ops->dump_node)
+    bad = ops->dump_node(n, F, dump_node_info_txt);
   fprintf(F, "\"\n");
+
   return bad;
 }
 
@@ -999,7 +1069,7 @@ static INLINE int dump_node_info(FILE *F, ir_node *n)
  * checks whether a node is "constant-like" ie can be treated "block-less"
  */
 static INLINE
-bool is_constlike_node(ir_node *n) {
+int is_constlike_node(ir_node *n) {
   ir_op *op = get_irn_op(n);
   return (op == op_Const || op == op_Bad || op == op_NoMem || op == op_SymConst || op == op_Unknown);
 }
@@ -1062,6 +1132,19 @@ static void dump_const_block_local(FILE *F, ir_node *n) {
     fprintf (F, "edge: { sourcename: \"");
     PRINT_NODEID(n);
     fprintf (F, "\" targetname: \""); PRINT_CONSTBLKID(n,blk);
+
+    if (dump_edge_vcgattr_hook) {
+      fprintf (F, "\" ");
+      if (dump_edge_vcgattr_hook(F, n, -1)) {
+        fprintf (F, "}\n");
+        return;
+      }
+      else {
+        fprintf (F, " " BLOCK_EDGE_ATTR "}\n");
+        return;
+      }
+    }
+
     fprintf (F, "\" "   BLOCK_EDGE_ATTR "}\n");
   }
 }
@@ -1080,7 +1163,7 @@ static void INLINE print_node_error(FILE *F, const char *err_msg)
 /**
  * prints debug messages of a node to file F as info3.
  */
-static void print_node_dbg_info(FILE *F, dbg_info *dbg)
+static void print_dbg_info(FILE *F, dbg_info *dbg)
 {
   char buf[1024];
 
@@ -1112,7 +1195,7 @@ static void dump_node(FILE *F, ir_node *n)
   fprintf(F, "\" ");
   bad |= dump_node_info(F, n);
   print_node_error(F, p);
-  print_node_dbg_info(F, get_irn_dbg_info(n));
+  print_dbg_info(F, get_irn_dbg_info(n));
   dump_node_vcgattr(F, n, NULL, bad);
   fprintf(F, "}\n");
   dump_const_node_local(F, n);
@@ -1140,6 +1223,19 @@ dump_ir_block_edge(FILE *F, ir_node *n)  {
       PRINT_NODEID(n);
       fprintf (F, "\" targetname: ");
       fprintf(F, "\""); PRINT_NODEID(block); fprintf(F, "\"");
+
+      if (dump_edge_vcgattr_hook) {
+        fprintf (F, " ");
+        if (dump_edge_vcgattr_hook(F, n, -1)) {
+          fprintf (F, "}\n");
+          return;
+        }
+        else {
+          fprintf (F, " "  BLOCK_EDGE_ATTR "}\n");
+          return;
+        }
+      }
+
       fprintf (F, " "   BLOCK_EDGE_ATTR "}\n");
     }
   }
@@ -1147,10 +1243,10 @@ dump_ir_block_edge(FILE *F, ir_node *n)  {
 
 static void
 print_data_edge_vcgattr(FILE *F, ir_node *from, int to) {
-	/*
-	 * do not use get_nodes_block() here, will fail
-	 * if the irg is not pinned.
-	 */
+  /*
+   * do not use get_nodes_block() here, will fail
+   * if the irg is not pinned.
+   */
   if (get_irn_n(from, -1) == get_irn_n(get_irn_n(from, to), -1))
     fprintf (F, INTRA_DATA_EDGE_ATTR);
   else
@@ -1159,10 +1255,10 @@ print_data_edge_vcgattr(FILE *F, ir_node *from, int to) {
 
 static void
 print_mem_edge_vcgattr(FILE *F, ir_node *from, int to) {
-	/*
-	 * do not use get_nodes_block() here, will fail
-	 * if the irg is not pinned.
-	 */
+  /*
+   * do not use get_nodes_block() here, will fail
+   * if the irg is not pinned.
+   */
   if (get_irn_n(from, -1) == get_irn_n(get_irn_n(from, to), -1))
     fprintf (F, INTRA_MEM_EDGE_ATTR);
   else
@@ -1173,6 +1269,10 @@ static void
 print_edge_vcgattr(FILE *F, ir_node *from, int to) {
   assert(from);
 
+  if (dump_edge_vcgattr_hook)
+    if (dump_edge_vcgattr_hook(F, from, to))
+      return;
+
   if (dump_backedge_information_flag && is_backedge(from, to))
     fprintf (F, BACK_EDGE_ATTR);
 
@@ -1379,6 +1479,8 @@ static void dump_const_expression(FILE *F, ir_node *value) {
 static void
 dump_whole_block(FILE *F, ir_node *block) {
   ir_node *node;
+  dumper_colors color = ird_color_yellow;
+
   assert(is_Block(block));
 
   fprintf(F, "graph: { title: \"");
@@ -1389,8 +1491,20 @@ dump_whole_block(FILE *F, ir_node *block) {
   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");
+
+  /* colorize blocks */
+  if (! get_Block_matured(block))
+    color = ird_color_red;
+  if (is_Block_dead(block))
+    color = ird_color_orange;
+
+  fprintf(F, "\" status:clustered ");
+  print_vcg_color(F, color);
+  fprintf(F, "\n");
+
+  /* yComp can show attributes for blocks, XVCG parses but ignores them */
+  dump_node_info(F, block);
+  print_dbg_info(F, get_irn_dbg_info(block));
 
   /* dump the blocks edges */
   dump_ir_data_edges(F, block);
@@ -1441,15 +1555,29 @@ dump_block_graph(FILE *F, ir_graph *irg) {
   current_ir_graph = rem;
 }
 
+/**
+ * Dump the info for an irg.
+ * Parsed by XVCG but not shown. use yComp.
+ */
+static void dump_graph_info(FILE *F, ir_graph *irg) {
+  fprintf(F, "info1: \"");
+  dump_entity_to_file(F, get_irg_entity(irg), dump_verbosity_entattrs | dump_verbosity_entconsts);
+  fprintf(F, "\"\n");
+}
+
 /** Dumps an irg as a graph clustered by block nodes.
  *  If interprocedural view edges can point to nodes out of this graph.
  */
 static void dump_graph_from_list(FILE *F, ir_graph *irg) {
+  entity *ent = get_irg_entity(irg);
 
   fprintf(F, "graph: { title: \"");
   PRINT_IRGID(irg);
   fprintf(F, "\" label: \"%s\" status:clustered color:white \n",
-      get_ent_dump_name(get_irg_entity(irg)));
+      get_ent_dump_name(ent));
+
+  dump_graph_info(F, irg);
+  print_dbg_info(F, get_entity_dbg_info(ent));
 
   dump_block_graph(F, irg);
 
@@ -1469,7 +1597,7 @@ dump_extblock_graph(FILE *F, ir_graph *irg) {
   compute_extbb(irg);
   for (i = ARR_LEN(arr) - 1; i >= 0; --i) {
     ir_extblk *extbb = arr[i];
-    ir_node *leader = extbb->blks[0];
+    ir_node *leader = get_extbb_leader(extbb);
     int j;
 
     fprintf(F, "graph: { title: \"");
@@ -1646,7 +1774,7 @@ int dump_type_node(FILE *F, type *tp)
   dump_type_to_file(F, tp, dump_verbosity_max);
 #endif
   fprintf (F, "\"\n");
-  print_node_dbg_info(F, get_type_dbg_info(tp));
+  print_dbg_info(F, get_type_dbg_info(tp));
   print_typespecific_vcgattr(F, tp);
   fprintf (F, "}\n");
 
@@ -1663,7 +1791,7 @@ void dump_entity_node(FILE *F, entity *ent, int color)
   fprintf (F, "label: ");
   fprintf (F, "\"ent %s\" ", get_ent_dump_name(ent));
   if (color)
-    fprintf(F, "color: %d", color);
+    fprintf(F, "color:%d", color);
   else
     fprintf (F, ENTITY_NODE_ATTR);
   fprintf (F, "\n info1: \"");
@@ -1671,7 +1799,7 @@ void dump_entity_node(FILE *F, entity *ent, int color)
   dump_entity_to_file(F, ent, dump_verbosity_entattrs | dump_verbosity_entconsts);
 
   fprintf(F, "\"\n");
-  print_node_dbg_info(F, get_entity_dbg_info(ent));
+  print_dbg_info(F, get_entity_dbg_info(ent));
   fprintf(F, "}\n");
 }
 #undef X
@@ -1895,7 +2023,7 @@ static INLINE void dump_loop_info(FILE *F, 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));
+  fprintf (F, "\n The loop was analyzed %d times.", PTR_TO_INT(get_loop_link(loop)));
 #endif
   fprintf (F, "\"");
 }
@@ -2175,6 +2303,11 @@ dump_ir_graph (ir_graph *irg, const char *suffix )
   f = vcg_open(irg, suffix, suffix1);
   dump_vcg_header(f, get_irg_dump_name(irg), NULL);
 
+  /* call the dump graph hook */
+  if (dump_ir_graph_hook)
+    if (dump_ir_graph_hook(f, irg))
+      return;
+
   /* walk over the graph */
   /* dump_whole_node must be called in post visiting predecessors */
   irg_walk(get_irg_end(irg), NULL, dump_whole_node, f);
@@ -2228,6 +2361,7 @@ void dump_ir_extblock_graph (ir_graph *irg, const char *suffix)
   FILE *F;
   int i;
   char *suffix1;
+  entity *ent;
 
   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
     return;
@@ -2236,6 +2370,9 @@ void dump_ir_extblock_graph (ir_graph *irg, const char *suffix)
 
   if (get_interprocedural_view()) suffix1 = "-ip";
   else                            suffix1 = "";
+
+  ent = get_irg_entity(irg);
+
   F = vcg_open(irg, suffix, suffix1);
   dump_vcg_header(F, get_irg_dump_name(irg), NULL);
 
@@ -2243,8 +2380,11 @@ void dump_ir_extblock_graph (ir_graph *irg, const char *suffix)
 
   fprintf(F, "graph: { title: \"");
   PRINT_IRGID(irg);
-  fprintf(F, "\" label: \"%s\" status:clustered color:white \n",
-    get_ent_dump_name(get_irg_entity(irg)));
+  fprintf(F, "\" label: \"%s\" status:clustered color: white \n",
+    get_ent_dump_name(ent));
+
+  dump_graph_info(F, irg);
+  print_dbg_info(F, get_entity_dbg_info(ent));
 
   for (i = 0; i < get_irp_n_irgs(); i++) {
     ir_graph *irg     = get_irp_irg(i);
@@ -2283,12 +2423,16 @@ dump_ir_graph_w_types (ir_graph *irg, const char *suffix)
   FILE *f;
   ir_graph *rem = current_ir_graph;
   char *suffix1;
+  int rem_dump_const_local;
 
   /* if a filter is set, dump only the irg's that match the filter */
   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
     return;
 
   current_ir_graph = irg;
+  rem_dump_const_local = dump_const_local;
+  /* dumping types does not work with local nodes */
+  dump_const_local = 0;
 
   if (get_interprocedural_view()) suffix1 = "-pure-wtypes-ip";
   else                            suffix1 = "-pure-wtypes";
@@ -2304,6 +2448,7 @@ dump_ir_graph_w_types (ir_graph *irg, const char *suffix)
   irg_walk(get_irg_end(irg), dump_node2type_edges, NULL, f);
 
   vcg_close(f);
+  dump_const_local = rem_dump_const_local;
   current_ir_graph = rem;
 }
 
@@ -2314,11 +2459,16 @@ dump_ir_block_graph_w_types (ir_graph *irg, const char *suffix)
   int i;
   char *suffix1;
   ir_graph *rem = current_ir_graph;
+  int rem_dump_const_local;
 
   /* if a filter is set, dump only the irg's that match the filter */
   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
     return;
 
+  rem_dump_const_local = dump_const_local;
+  /* dumping types does not work with local nodes */
+  dump_const_local = 0;
+
   if (get_interprocedural_view()) suffix1 = "-wtypes-ip";
   else                            suffix1 = "-wtypes";
   f = vcg_open(irg, suffix, suffix1);
@@ -2343,8 +2493,9 @@ dump_ir_block_graph_w_types (ir_graph *irg, const char *suffix)
   /* dump edges from graph to type info */
   irg_walk(get_irg_end(irg), dump_node2type_edges, NULL, f);
 
-  current_ir_graph = rem;
   vcg_close(f);
+  dump_const_local = rem_dump_const_local;
+  current_ir_graph = rem;
 }
 
 /*---------------------------------------------------------------------*/
@@ -2452,7 +2603,7 @@ dump_cfg (ir_graph *irg, const char *suffix)
 
   if (ipv) {
     printf("Warning: dumping cfg not in interprocedural view!\n");
-    set_interprocedural_view(false);
+    set_interprocedural_view(0);
   }
 
   if (get_irg_dom_state(irg) != dom_consistent)
@@ -2568,8 +2719,8 @@ void dump_callgraph(const char *suffix) {
       int be = is_irg_callee_backedge(irg, j);
       char *attr;
       attr = (be) ?
-        "label:\"recursion %d\" color: %d" :
-        "label:\"calls %d\" color: %d";
+        "label:\"recursion %d\" color:%d" :
+        "label:\"calls %d\" color:%d";
       print_ent_ent_edge(F, ent, c, be, attr, get_irg_callee_loop_depth(irg, j), get_entity_color(ent));
     }
   }
@@ -2583,7 +2734,7 @@ void dump_all_cg_block_graph(const char *suffix) {
   FILE *f;
   int i;
   int rem_view = get_interprocedural_view();
-  set_interprocedural_view(true);
+  set_interprocedural_view(1);
 
   f = vcg_open_name("All_graphs", suffix);
   dump_vcg_header(f, "All_graphs", NULL);
@@ -2648,17 +2799,14 @@ dump_all_types (const char *suffix)
 }
 
 void
-dump_class_hierarchy (bool entities, const char *suffix)
+dump_class_hierarchy (int entities, const char *suffix)
 {
   FILE *f = vcg_open_name("class_hierarchy", suffix);
   h_env_t env;
 
-  env.f = f;
+  env.f        = f;
+  env.dump_ent = entities;
   dump_vcg_header(f, "class_hierarchy", NULL);
-  if (entities)
-    env.dump_ent = 1;
-  else
-    env.dump_ent = 0;
   type_walk(dump_class_hierarchy_node, NULL, &env);
   vcg_close(f);
 }
@@ -2673,8 +2821,8 @@ dump_class_hierarchy (bool entities, const char *suffix)
 /*---------------------------------------------------------------------*/
 
 void dump_all_ir_graphs(dump_graph_func *dmp_grph, const char *suffix) {
-  int i, n_irgs = get_irp_n_irgs();
-  for (i = 0; i < n_irgs; ++i) {
+  int i;
+  for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
     dmp_grph(get_irp_irg(i), suffix);
   }
 }
@@ -2890,9 +3038,10 @@ void dump_loop(ir_loop *l, const 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";
+        if (eset_contains(extnodes, n))
+          overrule_nodecolor = ird_color_lightblue;
         dump_node(F, n);
-        overrule_nodecolor = NULL;
+        overrule_nodecolor = ird_color_default;
         if (!eset_contains(extnodes, n)) dump_ir_data_edges(F, n);
       }
 
@@ -2912,9 +3061,10 @@ void dump_loop(ir_loop *l, const 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(loopnodes, n)) overrule_nodecolor = "lightblue";
+        if (!eset_contains(loopnodes, n))
+          overrule_nodecolor = ird_color_lightblue;
         dump_node(F, n);
-        overrule_nodecolor = NULL;
+        overrule_nodecolor = ird_color_default;
         if (eset_contains(loopnodes, n)) dump_ir_data_edges(F, n);
       }