X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firdump.c;h=c1ee24cd6610e867d17da1710e18db7b292c9703;hb=76a6c3b40390427bc516a943316642bb57daa465;hp=4cb0f136ecc95963fdbcca7408c4a34d67e061d8;hpb=9fe9c20a1570729f1bdd21a6f174ec045d2ff986;p=libfirm

diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c
index 4cb0f136e..c1ee24cd6 100644
--- a/ir/ir/irdump.c
+++ b/ir/ir/irdump.c
@@ -46,19 +46,23 @@
 #include "array.h"
 #include "pmap.h"
 #include "eset.h"
+#include "pset.h"
 
 #if DO_HEAPANALYSIS
-void dump_chi_term(FILE *FL, ir_node *n);
-void dump_state(FILE *FL, ir_node *n);
-int  get_opt_dump_abstvals(void);
+extern void dump_irn_chi_term(FILE *FL, ir_node *n);
+extern void dump_irn_state(FILE *FL, ir_node *n);
+extern int  get_opt_dump_abstvals(void);
 typedef unsigned long SeqNo;
-SeqNo get_Block_seqno(ir_node *n);
+extern SeqNo get_Block_seqno(ir_node *n);
 #endif
 
 /* basis for a color range for vcg */
 static int n_colors   = 0;
 static int base_color = 0;
 
+/** Dump only irgs with names that start with this string */
+static ident *dump_file_filter_id = NULL;
+
 #define ERROR_TXT       "<ERROR>"
 
 /**
@@ -240,8 +244,8 @@ static void init_irdump(void) {
   /* We need a new, empty map. */
   if (irdump_link_map) pmap_destroy(irdump_link_map);
   irdump_link_map = pmap_create();
+  dump_file_filter_id = new_id_from_str("");
 }
-
 /**
  * Returns the private link field.
  */
@@ -381,9 +385,6 @@ static ir_node ** construct_block_lists(ir_graph *irg) {
 /* flags to steer output                                           */
 /*******************************************************************/
 
-/** Dump only irgs with names start with this string */
-const char *dump_file_filter = "";
-
 /** A compiler option to turn off edge labels */
 static int edge_label = 1;
 /** A compiler option to turn off dumping values of constant entities */
@@ -418,9 +419,19 @@ INLINE bool get_opt_dump_const_local(void) {
 }
 
 void only_dump_method_with_name(ident *name) {
-  dump_file_filter = get_id_str(name);
+  dump_file_filter_id = name;
+}
+
+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
+ *  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
    abort with a segmentation fault. */
@@ -432,8 +443,8 @@ void dump_consts_local(bool b) {
   dump_const_local = b;
 }
 
-void turn_off_constant_entity_values(void) {
-  const_entities = 0;
+void dump_constant_entity_values(bool b) {
+  const_entities = b;
 }
 
 void dump_keepalive_edges(bool b) {
@@ -444,20 +455,16 @@ bool get_opt_dump_keepalive_edges(void) {
   return dump_keepalive;
 }
 
-void dump_out_edges(void) {
-  dump_out_edge_flag = 1;
-}
-
-void dump_dominator_information(void) {
-  dump_dominator_information_flag = 1;
+void dump_out_edges(bool b) {
+  dump_out_edge_flag = b;
 }
 
-void dump_loop_information(void) {
-  dump_loop_information_flag = 1;
+void dump_dominator_information(bool b) {
+  dump_dominator_information_flag = b;
 }
 
-void dont_dump_loop_information(void) {
-  dump_loop_information_flag = 0;
+void dump_loop_information(bool b) {
+  dump_loop_information_flag = b;
 }
 
 void dump_backedge_information(bool b) {
@@ -468,7 +475,7 @@ void dump_backedge_information(bool b) {
  * If the flag is set, the type name is output in [] in the node label,
  * else it is output as info.
  */
-void dump_analysed_type_info(bool b) {
+void set_opt_dump_analysed_type_info(bool b) {
   opt_dump_analysed_type_info = b;
 }
 
@@ -611,13 +618,13 @@ static int dump_node_typeinfo(FILE *F, 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) {
+    if (get_irg_typeinfo_state(current_ir_graph) == ir_typeinfo_consistent  ||
+        get_irg_typeinfo_state(current_ir_graph) == ir_typeinfo_inconsistent) {
       type *tp = get_irn_typeinfo_type(n);
-      if (tp != none_type)
-        fprintf(F, " [%s]", get_type_name_ex(tp, &bad));
+      if (tp != firm_none_type)
+        fprintf(F, "[%s] ", get_type_name_ex(tp, &bad));
       else
-        fprintf(F, " []");
+        fprintf(F, "[] ");
     }
   }
   return bad;
@@ -634,27 +641,27 @@ dump_node_nodeattr(FILE *F, ir_node *n)
   switch (get_irn_opcode(n)) {
   case iro_Start:
     if (false && get_interprocedural_view()) {
-      fprintf (F, "%s", get_ent_dump_name(get_irg_entity(current_ir_graph)));
+      fprintf (F, "%s ", get_ent_dump_name(get_irg_entity(current_ir_graph)));
     }
     break;
   case iro_Proj:
     if (get_irn_opcode(get_Proj_pred(n)) == iro_Cmp) {
-      fprintf (F, "%s", get_pnc_string(get_Proj_proj(n)));
+      fprintf (F, "%s ", get_pnc_string(get_Proj_proj(n)));
     } else {
-      fprintf (F, "%ld", get_Proj_proj(n));
+      fprintf (F, "%ld ", get_Proj_proj(n));
     }
     break;
   case iro_Filter:
-    fprintf (F, "%ld", get_Filter_proj(n));
+    fprintf (F, "%ld ", get_Filter_proj(n));
     break;
   case iro_Sel:
-    fprintf (F, "%s", get_ent_dump_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_ex(get_Cast_type(n), &bad));
+    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)));
+    fprintf (F, "%s ", get_pnc_string(get_Confirm_cmp(n)));
     break;
 
   default:
@@ -664,21 +671,41 @@ dump_node_nodeattr(FILE *F, ir_node *n)
   return bad;
 }
 
+
+/** Dumps a node label without the enclosing ". */
+static int dump_node_label(FILE *F, ir_node *n) {
+  int bad = 0;
+
+  bad |= dump_node_opcode(F, n);
+  bad |= dump_node_mode(F, n);
+  fprintf (F, " ");
+  bad |= dump_node_typeinfo(F, n);
+  bad |= dump_node_nodeattr(F, n);
+  fprintf(F, "%ld", get_irn_node_nr(n));
+
+  return bad;
+}
+
+
 /**
- * dumps the attributes of a node n into the file F.
+ * Dumps the attributes of a node n into the file F.
  * Currently this is only the color of a node.
  */
-static void dump_node_vcgattr(FILE *F, ir_node *n, int bad)
+static void dump_node_vcgattr(FILE *F, ir_node *node, ir_node *local, int bad)
 {
+  ir_node *n;
+
   if (bad) {
     fprintf(F, "color: red");
     return;
   }
 
   if (dump_node_vcgattr_hook)
-    if (dump_node_vcgattr_hook(F, n))
+    if (dump_node_vcgattr_hook(F, node, local))
       return;
 
+  n = local ? local : node;
+
   switch (get_irn_opcode(n)) {
   case iro_Start:
   case iro_EndReg:
@@ -711,8 +738,6 @@ static void dump_node_vcgattr(FILE *F, ir_node *n, int bad)
 }
 
 
-/* Replace this once I can do a reference.  */
-#if 0
 /**
  * Dump the node information of a node n to a file F.
  */
@@ -723,197 +748,6 @@ static INLINE int dump_node_info(FILE *F, ir_node *n)
   fprintf(F, "\"\n");
   return bad;
 }
-#else
-/**
- * Dump the node information of a node n to a file F.
- */
-static INLINE int dump_node_info(FILE *F, ir_node *n)
-{
-  int i, bad = 0;
-  char comma;
-  ir_graph *irg;
-
-  fprintf (F, " info1: \"");
-  if (opt_dump_pointer_values_to_info)
-    fprintf (F, "addr:    %p\n", (void *)n);
-  fprintf (F, "mode:    %s\n", get_mode_name(get_irn_mode(n)));
-  fprintf (F, "visited: %ld\n", get_irn_visited(n));
-  irg = get_irn_irg(n);
-  if (irg != get_const_code_irg())
-    fprintf (F, "irg:     %s\n", get_ent_dump_name(get_irg_entity(irg)));
-
-  if (get_irn_pinned(n) == op_pin_state_floats &&
-      get_irg_pinned(get_irn_irg(n)) == op_pin_state_floats) {
-    fprintf(F, "node was pinned in ");
-    dump_node_opcode(F, get_nodes_block(n));
-    fprintf(F, " %ld\n", get_irn_node_nr(get_nodes_block(n)));
-  }
-
-#if 0
-  /* show all predecessor nodes */
-  fprintf(F, "pred nodes: \n");
-  if (!is_Block(n)) {
-    fprintf(F, "  -1: ");
-    dump_node_opcode(F, get_nodes_block(n));
-    fprintf(F, " %ld\n", get_irn_node_nr(get_nodes_block(n)));
-  }
-  for ( i = 0; i < get_irn_arity(n); ++i) {
-    fprintf(F, "   %d: ", i);
-    dump_node_opcode(F, get_irn_n(n, i));
-    fprintf(F, " %ld\n", get_irn_node_nr(get_irn_n(n, i)));
-  }
-#endif
-
-  fprintf(F, "arity: %d", get_irn_arity(n));
-  if ((get_irn_op(n) == op_Block) ||
-      (get_irn_op(n) == op_Phi) ||
-      ((get_irn_op(n) == op_Filter) && get_interprocedural_view())) {
-    fprintf(F, " backedges:");
-    comma = ' ';
-    for (i = 0; i < get_irn_arity(n); i++)
-      if (is_backedge(n, i)) { fprintf(F, "%c %d", comma, i); comma = ','; }
-  }
-  fprintf(F, "\n");
-
-  /* Loop node   Someone else please tell me what's wrong ...
-  if (get_irn_loop(n)) {
-    ir_loop *loop = get_irn_loop(n);
-    assert(loop);
-    fprintf(F, " in loop %d with depth %d\n",
-        get_loop_loop_nr(loop), get_loop_depth(loop));
-  }
-  */
-
-  /* Source types */
-  switch (get_irn_opcode(n)) {
-  case iro_Start: {
-    type *tp = get_entity_type(get_irg_entity(get_irn_irg(n)));
-    fprintf(F, "start of method of type %s\n", get_type_name_ex(tp, &bad));
-    for (i = 0; i < get_method_n_params(tp); ++i)
-      fprintf(F, "  param %d type: %s \n", i, get_type_name_ex(get_method_param_type(tp, i), &bad));
-    if ((get_irp_ip_view_state() == ip_view_valid) && !get_interprocedural_view()) {
-      ir_node *sbl = get_nodes_block(n);
-      int i, n_cfgpreds = get_Block_cg_n_cfgpreds(sbl);
-      fprintf(F, "graph has %d interprocedural predecessors:\n", n_cfgpreds);
-      for (i = 0; i < n_cfgpreds; ++i) {
-        ir_node *cfgpred = get_Block_cg_cfgpred(sbl, i);
-        fprintf(F, "  %d: Call %ld in graph %s\n", i, get_irn_node_nr(cfgpred),
-                get_irg_dump_name(get_irn_irg(cfgpred)));
-      }
-    }
-  } break;
-  case iro_Alloc: {
-    fprintf(F, "allocating entity of type %s\n", get_type_name_ex(get_Alloc_type(n), &bad));
-  } break;
-  case iro_Free: {
-    fprintf(F, "freeing entity of type %s\n", get_type_name_ex(get_Free_type(n), &bad));
-  } break;
-  case iro_Sel: {
-    entity *ent = get_Sel_entity(n);
-
-    if (ent) {
-      fprintf(F, "Selecting entity of type %s\n", get_type_name_ex(get_entity_type(ent), &bad));
-      fprintf(F, "  from entity of type %s\n", get_type_name_ex(get_entity_owner(ent), &bad));
-    }
-    else {
-      fprintf(F, "<NULL entity>\n");
-      bad = 1;
-    }
-  } break;
-  case iro_Call: {
-    type *tp = get_Call_type(n);
-    fprintf(F, "calling method of type %s\n", get_type_name_ex(tp, &bad));
-    if(get_unknown_type() != tp) {
-      for (i = 0; i < get_method_n_params(tp); ++i)
-	fprintf(F, "  param %d type: %s\n", i, get_type_name_ex(get_method_param_type(tp, i), &bad));
-      for (i = 0; i < get_method_n_ress(tp); ++i)
-	fprintf(F, "  resul %d type: %s\n", i, get_type_name_ex(get_method_res_type(tp, i), &bad));
-    }
-    if (Call_has_callees(n)) {
-      fprintf(F, "possible callees:\n");
-      for (i = 0; i < get_Call_n_callees(n); i++) {
-	fprintf(F, "  %d: %s\n", i, get_ent_dump_name(get_Call_callee(n, i)));
-      }
-    }
-  } break;
-  case iro_CallBegin: {
-    ir_node *call = get_CallBegin_call(n);
-    fprintf(F, "Call: %ld\n", get_irn_node_nr(call));
-    if (Call_has_callees(call)) {
-      fprintf(F, "possible callees: \n");
-      for (i = 0; i < get_Call_n_callees(call); i++) {
-	fprintf(F, "  %d: %s\n", i, get_ent_dump_name(get_Call_callee(call, i)));
-      }
-    }
-  } break;
-  case iro_Return: {
-    if (!get_interprocedural_view()) {
-      type *tp = get_entity_type(get_irg_entity(get_irn_irg(n)));
-      fprintf(F, "return in method of type %s\n", get_type_name_ex(tp, &bad));
-      for (i = 0; i < get_method_n_ress(tp); ++i)
-        fprintf(F, "  res %d type: %s\n", i, get_type_name_ex(get_method_res_type(tp, i), &bad));
-    }
-  } break;
-  case iro_Const: {
-    type *tp = get_Const_type(n);
-    assert(tp != none_type);
-    fprintf(F, "Const of type %s\n", get_type_name_ex(get_Const_type(n), &bad));
-  } break;
-  case iro_SymConst: {
-    switch(get_SymConst_kind(n)) {
-    case symconst_addr_name:
-      fprintf(F, "kind: addr_name\n");
-      break;
-    case symconst_addr_ent:
-      fprintf(F, "kind: addr_ent\n");
-      dump_entity_to_file(F, get_SymConst_entity(n), dump_verbosity_onlynames);
-      break;
-    case symconst_type_tag:
-      fprintf(F, "kind: type_tag\n");
-      break;
-    case symconst_size:
-      fprintf(F, "kind: size\n");
-      break;
-    }
-    fprintf(F, "SymConst of type: %s\n", get_type_name_ex(get_SymConst_value_type(n), &bad));
-  } break;
-  case iro_Filter: {
-    int i;
-    if (get_interprocedural_view()) {
-      fprintf(F, "intra predecessor nodes:\n");
-      for (i = 0; i < get_irn_intra_arity(n); i++) {
-        ir_node *pred = get_irn_intra_n(n, i);
-        fprintf(F, "  %s%s %ld\n", get_irn_opname(pred), get_irn_modename(pred), get_irn_node_nr(pred));
-      }
-    } else {
-      fprintf(F, "inter predecessor nodes:\n");
-      for (i = 0; i < get_irn_inter_arity(n); i++) {
-        ir_node *pred = get_irn_inter_n(n, i);
-        fprintf(F, "  %s%s %ld \tin graph %s\n", get_irn_opname(pred), get_irn_modename(pred),
-        get_irn_node_nr(pred), get_ent_dump_name(get_irg_entity(get_irn_irg(pred))));
-      }
-    }
-  } break;
-  case iro_Load:
-    fprintf(F, "volatility: %s\n", get_volatility_name(get_Load_volatility(n)));
-    break;
-  case iro_Store:
-    fprintf(F, "volatility: %s\n", get_volatility_name(get_Store_volatility(n)));
-    break;
-
-  default: ;
-  }
-
-  if (get_irg_typeinfo_state(get_irn_irg(n)) == irg_typeinfo_consistent  ||
-      get_irg_typeinfo_state(get_irn_irg(n)) == irg_typeinfo_inconsistent  )
-    if (get_irn_typeinfo_type(n) != none_type)
-      fprintf (F, "Analysed type: %s\n", get_type_name_ex(get_irn_typeinfo_type(n), &bad));
-
-  fprintf (F, "\"");
-
-  return bad;
-}
-#endif
 
 /**
  * checks wheater a node is "constant-like", ie can be treated "block-less"
@@ -950,15 +784,10 @@ static void dump_const_node_local(FILE *F, ir_node *n) {
          n and const. */
       fprintf(F, "node: {title: "); PRINT_CONSTID(n, con);
       fprintf(F, " label: \"");
-      bad |= dump_node_opcode(F, con);
-      bad |= dump_node_mode(F, con);
-      bad |= dump_node_typeinfo(F, con);
-      fprintf (F, " ");
-      bad |= dump_node_nodeattr(F, con);
-      fprintf(F, " %ld", get_irn_node_nr(con));
+      bad |= dump_node_label(F, con);
       fprintf(F, "\" ");
       bad |= dump_node_info(F, con);
-      dump_node_vcgattr(F, con, bad);
+      dump_node_vcgattr(F, n, con, bad);
       fprintf(F, "}\n");
     }
   }
@@ -966,9 +795,11 @@ static void dump_const_node_local(FILE *F, ir_node *n) {
 
 /** If the block of an edge is a const_like node, dump it local with an edge */
 static void dump_const_block_local(FILE *F, ir_node *n) {
+  ir_node *blk;
+
   if (!get_opt_dump_const_local()) return;
 
-  ir_node *blk = get_nodes_block(n);
+  blk = get_nodes_block(n);
   if (is_constlike_node(blk)) {
     int bad = 0;
 
@@ -976,15 +807,10 @@ static void dump_const_block_local(FILE *F, ir_node *n) {
        n and blk. */
     fprintf(F, "node: {title: \""); PRINT_CONSTBLKID(n, blk);
     fprintf(F, "\" label: \"");
-    bad |= dump_node_opcode(F, blk);
-    bad |= dump_node_mode(F, blk);
-    bad |= dump_node_typeinfo(F, blk);
-    fprintf (F, " ");
-    bad |= dump_node_nodeattr(F, blk);
-    fprintf(F, " %ld", get_irn_node_nr(blk));
+    bad |= dump_node_label(F, blk);
     fprintf(F, "\" ");
     bad |= dump_node_info(F, blk);
-    dump_node_vcgattr(F, blk, bad);
+    dump_node_vcgattr(F, n, blk, bad);
     fprintf(F, "}\n");
 
     fprintf (F, "edge: { sourcename: \"");
@@ -1020,21 +846,17 @@ static void dump_node(FILE *F, ir_node *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(F, n);
-  bad |= dump_node_typeinfo(F, n);
-  fprintf(F, " ");
-  bad |= dump_node_nodeattr(F, n);
-  fprintf(F, " %ld", get_irn_node_nr(n));
+  bad |= dump_node_label(F, n);
+  //dump_node_ana_info(F, n);
   fprintf(F, "\" ");
   bad |= dump_node_info(F, n);
   print_node_error(F, p);
-  dump_node_vcgattr(F, n, bad);
+  dump_node_vcgattr(F, n, NULL, bad);
   fprintf(F, "}\n");
   dump_const_node_local(F, n);
 #if DO_HEAPANALYSIS
-  dump_chi_term(F, n);
-  dump_state(F, n);
+  dump_irn_chi_term(F, n);
+  dump_irn_state(F, n);
 #endif
 }
 
@@ -1202,7 +1024,8 @@ print_edge_vcgattr(FILE *F, ir_node *from, int to) {
 /* dump edges to our inputs */
 static void
 dump_ir_data_edges(FILE *F, ir_node *n)  {
-  int i, visited = get_irn_visited(n);
+  int i;
+  unsigned long visited = get_irn_visited(n);
 
   if ((get_irn_op(n) == op_End) && (!dump_keepalive))
     return;
@@ -1288,8 +1111,7 @@ dump_whole_block(FILE *F, ir_node *block) {
   fprintf(F, "graph: { title: \"");
   PRINT_NODEID(block);
   fprintf(F, "\"  label: \"");
-  dump_node_opcode(F, block);
-  fprintf (F, " %ld", get_irn_node_nr(block));
+  dump_node_label(F, block);
 #if DO_HEAPANALYSIS
   if (get_opt_dump_abstvals())
     fprintf (F, " seqno: %d", (int)get_Block_seqno(block));
@@ -1310,7 +1132,7 @@ dump_whole_block(FILE *F, ir_node *block) {
   fprintf(F, "}\n");
   dump_const_node_local(F, block);
 #if DO_HEAPANALYSIS
-  dump_chi_term(F, block);
+  dump_irn_chi_term(F, block);
 #endif
   fprintf(F, "\n");
 }
@@ -1561,7 +1383,7 @@ dump_type_info(type_or_ent *tore, void *env) {
       fprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
                 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))) {
+      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), 0, ENT_OVERWRITES_EDGE_ATTR);
       }
@@ -1681,8 +1503,8 @@ dump_class_hierarchy_node (type_or_ent *tore, void *ctx) {
   case k_entity: {
     entity *ent = (entity *)tore;
     if (get_entity_owner(ent) == get_glob_type()) break;
-    if (!is_method_type(get_entity_type(ent))) break;  /* GL */
-    if (env->dump_ent && is_class_type(get_entity_owner(ent))) {
+    if (!is_Method_type(get_entity_type(ent))) break;  /* GL */
+    if (env->dump_ent && is_Class_type(get_entity_owner(ent))) {
       /* The node */
       dump_entity_node(F, ent, 0);
       /* The edges */
@@ -1914,7 +1736,7 @@ FILE *vcg_open (ir_graph *irg, const char * suffix1, const char *suffix2) {
 
   /* strncpy (fname, nm, len); */     /* copy the filename */
   j = 0;
-  for (i = 0; i < len; ++i) {  /* replase '/' in the name: escape by @. */
+  for (i = 0; i < len; ++i) {  /* replace '/' in the name: escape by @. */
     if (nm[i] == '/') {
       fname[j] = '@'; j++; fname[j] = '1'; j++;
     } else if (nm[i] == '@') {
@@ -1927,7 +1749,11 @@ FILE *vcg_open (ir_graph *irg, const char * suffix1, const char *suffix2) {
   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 */
+
+  /* vcg really expect only a <CR> at end of line, so
+   * the "b"inary mode is what you mean (and even needed for Win32)
+   */
+  F = fopen (fname, "wb");  /* open file for writing */
   if (!F) {
     panic("cannot open %s for writing (%m)", fname);  /* not reached */
   }
@@ -1942,7 +1768,7 @@ FILE *vcg_open (ir_graph *irg, const char * suffix1, const char *suffix2) {
  * @param irg     The graph to be dumped
  * @param suffix  filename suffix
  */
-static FILE *vcg_open_name (const char *name, const char *suffix) {
+FILE *vcg_open_name (const char *name, const char *suffix) {
   FILE *F;
   char *fname;  /* filename to put the vcg information in */
   int i, j, len = strlen(name);
@@ -1953,7 +1779,7 @@ static FILE *vcg_open_name (const char *name, const char *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 @. */
+  for (i = 0; i < len; ++i) {  /* replace '/' in the name: escape by @. */
     if (name[i] == '/') {
       fname[j] = '@'; j++; fname[j] = '1'; j++;
     } else if (name[i] == '@') {
@@ -1965,7 +1791,11 @@ static FILE *vcg_open_name (const char *name, const char *suffix) {
   fname[j] = '\0';
   strcat (fname, suffix);
   strcat (fname, ".vcg");  /* append the .vcg suffix */
-  F = fopen (fname, "w");  /* open file for writing */
+
+  /* vcg really expect only a <CR> at end of line, so
+   * the "b"inary mode is what you mean (and even needed for Win32)
+   */
+  F = fopen (fname, "wb");  /* open file for writing */
   if (!F) {
     panic ("cannot open %s for writing (%m)", fname);  /* not reached */
   }
@@ -1996,7 +1826,7 @@ void vcg_close (FILE *F) {
 /************************************************************************/
 
 /************************************************************************/
-/* Dump ir graphs, differnt formats and additional information.         */
+/* Dump ir graphs, different formats and additional information.        */
 /************************************************************************/
 
 /** Routine to dump a graph, blocks as conventional nodes.  */
@@ -2008,7 +1838,8 @@ dump_ir_graph (ir_graph *irg, const char *suffix )
   char *suffix1;
   rem = current_ir_graph;
 
-  if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0) return;
+  if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg)))) return;
+
   current_ir_graph = irg;
   if (get_interprocedural_view()) suffix1 = "-pure-ip";
   else                            suffix1 = "-pure";
@@ -2037,7 +1868,7 @@ dump_ir_block_graph (ir_graph *irg, const char *suffix)
   int i;
   char *suffix1;
 
-  if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0)
+  if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
     return;
 
   if (get_interprocedural_view()) suffix1 = "-ip";
@@ -2067,7 +1898,7 @@ dump_ir_graph_w_types (ir_graph *irg, const char *suffix)
   char *suffix1;
 
   /* if a filter is set, dump only the irg's that match the filter */
-  if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0)
+  if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
     return;
 
   current_ir_graph = irg;
@@ -2098,7 +1929,7 @@ dump_ir_block_graph_w_types (ir_graph *irg, const char *suffix)
   ir_graph *rem = current_ir_graph;
 
   /* if a filter is set, dump only the irg's that match the filter */
-  if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0)
+  if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
     return;
 
   if (get_interprocedural_view()) suffix1 = "-wtypes-ip";
@@ -2152,8 +1983,11 @@ dump_block_to_cfg(ir_node *block, void *env) {
     PRINT_NODEID(block);
     fprintf (F, "\" ");
     fprintf(F, "info1:\"");
-    if (dump_dominator_information_flag)
+    if (dump_dominator_information_flag) {
       fprintf(F, "dom depth %d\n", get_Block_dom_depth(block));
+      fprintf(F, "tree pre num %d\n", get_Block_dom_tree_pre_num(block));
+      fprintf(F, "max subtree pre num %d\n", get_Block_dom_max_subtree_pre_num(block));
+		}
 
     /* show arity and possible Bad predecessors of the block */
     fprintf(F, "arity: %d\n", get_Block_n_cfgpreds(block));
@@ -2210,7 +2044,7 @@ dump_cfg (ir_graph *irg, const char *suffix)
   int ipv = get_interprocedural_view();
 
   /* if a filter is set, dump only the irg's that match the filter */
-  if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0)
+  if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
     return;
 
   current_ir_graph = irg;
@@ -2236,6 +2070,38 @@ dump_cfg (ir_graph *irg, const char *suffix)
   current_ir_graph = rem;
 }
 
+
+static void descend_and_dump(FILE *F, ir_node *n, int depth, pset *mark_set) {
+  if (pset_find_ptr(mark_set, n)) return;
+
+  pset_insert_ptr(mark_set, n);
+
+  if (depth > 0) {
+    int i, start = is_Block(n) ? 0 : -1;
+    dump_whole_node(n, F);
+    for (i = start; i < get_irn_arity(n); ++i)
+      descend_and_dump(F, get_irn_n(n, i), depth-1, mark_set);
+  } else {
+    dump_node(F, n);
+    /* Don't dump edges to nodes further out.  These might be edges to
+       nodes we already dumped, if there is a shorter path to these. */
+  }
+}
+
+static int subgraph_counter = 0;
+void dump_subgraph (ir_node *root, int depth, const char *suffix) {
+  FILE *F;
+  char buf[32];
+  pset *mark_set = pset_new_ptr(1);
+  sprintf(buf, "-subg_%03d", subgraph_counter++);
+  F = vcg_open(get_irn_irg(root), suffix, buf);
+  dump_vcg_header(F, get_irg_dump_name(get_irn_irg(root)), NULL);
+  descend_and_dump(F, root, depth, mark_set);
+  vcg_close(F);
+  del_pset(mark_set);
+}
+
+
 static int weight_overall(int rec, int loop) {
   return 2*rec + loop;
 }
@@ -2245,11 +2111,13 @@ static int compute_color (int my, int max) {
   if (!max) {
     color = 0;
   } else {
+    int step;
+
     /* if small, scale to the full color range. */
     if (max < n_colors)
       my = my * (n_colors/max);
 
-    int step = 1 + (max / n_colors);
+    step = 1 + (max / n_colors);
 
     color = my/step;
   }
@@ -2257,22 +2125,24 @@ static int compute_color (int my, int max) {
 }
 
 static int get_entity_color(entity *ent) {
-  assert(get_entity_irg(ent));
   ir_graph *irg = get_entity_irg(ent);
+  assert(irg);
 
-  int rec_depth     = get_irg_recursion_depth(irg);
-  int loop_depth    = get_irg_loop_depth(irg);
-  int overall_depth = weight_overall(rec_depth, loop_depth);
+  {
+    int rec_depth     = get_irg_recursion_depth(irg);
+    int loop_depth    = get_irg_loop_depth(irg);
+    int overall_depth = weight_overall(rec_depth, loop_depth);
 
-  int max_rec_depth     = irp->max_callgraph_recursion_depth;
-  int max_loop_depth    = irp->max_callgraph_loop_depth;
-  int max_overall_depth = weight_overall(max_rec_depth, max_loop_depth);
+    int max_rec_depth     = irp->max_callgraph_recursion_depth;
+    int max_loop_depth    = irp->max_callgraph_loop_depth;
+    int max_overall_depth = weight_overall(max_rec_depth, max_loop_depth);
 
-  /* int my_rec_color     = compute_color(rec_depth, max_rec_depth); */
-  /* int my_loop_color    = compute_color(loop_depth, max_loop_depth); */
-  int my_overall_color = compute_color(overall_depth, max_overall_depth);;
+    /* int my_rec_color     = compute_color(rec_depth, max_rec_depth); */
+    /* int my_loop_color    = compute_color(loop_depth, max_loop_depth); */
+    int my_overall_color = compute_color(overall_depth, max_overall_depth);;
 
-  return my_overall_color;
+    return my_overall_color;
+  }
 }
 
 void dump_callgraph(const char *suffix) {
@@ -2350,7 +2220,7 @@ dump_type_graph (ir_graph *irg, const char *suffix)
   rem = current_ir_graph;
 
   /* if a filter is set, dump only the irg's that match the filter */
-  if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0) return;
+  if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg)))) return;
 
   current_ir_graph = irg;
 
@@ -2360,7 +2230,7 @@ dump_type_graph (ir_graph *irg, const char *suffix)
   /* walk over the blocks in the graph */
   type_walk_irg(irg, dump_type_info, NULL, f);
   /* The walker for the const code can be called several times for the
-     same (sub) experssion.  So that no nodes are dumped several times
+     same (sub) expression.  So that no nodes are dumped several times
      we decrease the visited flag of the corresponding graph after each
      walk.  So now increase it finally. */
   inc_irg_visited(get_const_code_irg());
@@ -2462,18 +2332,15 @@ void dump_loops_standalone(FILE *F, ir_loop *loop) {
       else
         fprintf(F, "\n");
 
-      bad |= dump_node_opcode(F, n);
-      bad |= dump_node_mode(F, n);
-      bad |= dump_node_typeinfo(F, n);
-      fprintf (F, " ");
-      bad |= dump_node_nodeattr(F, n);
-      fprintf (F, " %ld", get_irn_node_nr(n));
+      bad |= dump_node_label(F, n);
       /* Causes indeterministic output: if (is_Block(n)) fprintf (F, "\t ->%d", (int)get_irn_link(n)); */
       if (has_backedges(n)) fprintf(F, "\t loop head!");
     } else { /* for callgraph loop tree */
+      ir_graph *n;
       assert(get_kind(son) == k_ir_graph);
+
       /* We are a loop node -> Collect firm graphs */
-      ir_graph *n = (ir_graph *)le.node;
+      n = (ir_graph *)le.node;
       if (!loop_node_started) {
         /* Start a new node which contains all firm nodes of the current loop */
         fprintf (F, "node: { title: \"");
@@ -2483,7 +2350,7 @@ void dump_loops_standalone(FILE *F, ir_loop *loop) {
         first = i;
       }
       else
-    fprintf(F, "\n");
+        fprintf(F, "\n");
       fprintf (F, " %s", get_irg_dump_name(n));
       /* fprintf (F, " %s (depth %d)", get_irg_dump_name(n), n->callgraph_weighted_loop_depth); */
     }
@@ -2508,8 +2375,7 @@ void dump_loop_tree(ir_graph *irg, const char *suffix)
   edge_label = 1;
 
   /* if a filter is set, dump only the irg's that match the filter */
-  if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0)
-    return;
+  if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg)))) return;
 
   current_ir_graph = irg;