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

diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c
index 724bb0a0e..bd5c5baee 100644
--- a/ir/ir/irdump.c
+++ b/ir/ir/irdump.c
@@ -46,10 +46,11 @@
 #include "array.h"
 #include "pmap.h"
 #include "eset.h"
+#include "pset.h"
 
 #if DO_HEAPANALYSIS
-void dump_chi_term(FILE *FL, ir_node *n);
-void dump_state(FILE *FL, ir_node *n);
+void dump_irn_chi_term(FILE *FL, ir_node *n);
+void dump_irn_state(FILE *FL, ir_node *n);
 int  get_opt_dump_abstvals(void);
 typedef unsigned long SeqNo;
 SeqNo get_Block_seqno(ir_node *n);
@@ -432,8 +433,8 @@ void dump_consts_local(bool b) {
   dump_const_local = b;
 }
 
-void turn_off_constant_entity_values(void) {
-  const_entities = 0;
+void dump_constant_entity_values(bool b) {
+  const_entities = b;
 }
 
 void dump_keepalive_edges(bool b) {
@@ -444,20 +445,16 @@ bool get_opt_dump_keepalive_edges(void) {
   return dump_keepalive;
 }
 
-void dump_out_edges(void) {
-  dump_out_edge_flag = 1;
+void dump_out_edges(bool b) {
+  dump_out_edge_flag = b;
 }
 
-void dump_dominator_information(void) {
-  dump_dominator_information_flag = 1;
+void dump_dominator_information(bool b) {
+  dump_dominator_information_flag = b;
 }
 
-void dump_loop_information(void) {
-  dump_loop_information_flag = 1;
-}
-
-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) {
@@ -614,7 +611,7 @@ static int dump_node_typeinfo(FILE *F, ir_node *n) {
     if (get_irg_typeinfo_state(current_ir_graph) == irg_typeinfo_consistent  ||
         get_irg_typeinfo_state(current_ir_graph) == irg_typeinfo_inconsistent) {
       type *tp = get_irn_typeinfo_type(n);
-      if (tp != none_type)
+      if (tp != firm_none_type)
         fprintf(F, " [%s]", get_type_name_ex(tp, &bad));
       else
         fprintf(F, " []");
@@ -777,9 +774,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;
 
@@ -844,8 +843,8 @@ static void dump_node(FILE *F, ir_node *n)
   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
 }
 
@@ -1013,7 +1012,8 @@ print_edge_vcgattr(FILE *F, ir_node *from, int to) {
 /* dump edges to our inputs */
 static void
 dump_ir_data_edges(FILE *F, ir_node *n)  {
-  int i, visited = get_irn_visited(n);
+  int i;
+  unsigned long visited = get_irn_visited(n);
 
   if ((get_irn_op(n) == op_End) && (!dump_keepalive))
     return;
@@ -1121,7 +1121,7 @@ dump_whole_block(FILE *F, ir_node *block) {
   fprintf(F, "}\n");
   dump_const_node_local(F, block);
 #if DO_HEAPANALYSIS
-  dump_chi_term(F, block);
+  dump_irn_chi_term(F, block);
 #endif
   fprintf(F, "\n");
 }
@@ -1753,7 +1753,7 @@ FILE *vcg_open (ir_graph *irg, const char * suffix1, const char *suffix2) {
  * @param irg     The graph to be dumped
  * @param suffix  filename suffix
  */
-static FILE *vcg_open_name (const char *name, const char *suffix) {
+FILE *vcg_open_name (const char *name, const char *suffix) {
   FILE *F;
   char *fname;  /* filename to put the vcg information in */
   int i, j, len = strlen(name);
@@ -1819,7 +1819,9 @@ dump_ir_graph (ir_graph *irg, const char *suffix )
   char *suffix1;
   rem = current_ir_graph;
 
-  if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0) return;
+  if (strncmp(get_entity_name(get_irg_entity(irg)),
+	      dump_file_filter, strlen(dump_file_filter)) != 0) return;
+
   current_ir_graph = irg;
   if (get_interprocedural_view()) suffix1 = "-pure-ip";
   else                            suffix1 = "-pure";
@@ -2047,6 +2049,38 @@ dump_cfg (ir_graph *irg, const char *suffix)
   current_ir_graph = rem;
 }
 
+
+static void descend_and_dump(FILE *F, ir_node *n, int depth, pset *mark_set) {
+  if (pset_find_ptr(mark_set, n)) return;
+
+  pset_insert_ptr(mark_set, n);
+
+  if (depth > 0) {
+    int i, start = is_Block(n) ? 0 : -1;
+    dump_whole_node(n, F);
+    for (i = start; i < get_irn_arity(n); ++i)
+      descend_and_dump(F, get_irn_n(n, i), depth-1, mark_set);
+  } else {
+    dump_node(F, n);
+    /* Don't dump edges to nodes further out.  These might be edges to
+       nodes we already dumped, if there is a shorter path to these. */
+  }
+}
+
+static int subgraph_counter = 0;
+void dump_subgraph (ir_node *root, int depth, const char *suffix) {
+  FILE *F;
+  char buf[32];
+  pset *mark_set = pset_new_ptr(1);
+  sprintf(buf, "-subg_%03d", subgraph_counter++);
+  F = vcg_open(get_irn_irg(root), suffix, buf);
+  dump_vcg_header(F, get_irg_dump_name(get_irn_irg(root)), NULL);
+  descend_and_dump(F, root, depth, mark_set);
+  vcg_close(F);
+  del_pset(mark_set);
+}
+
+
 static int weight_overall(int rec, int loop) {
   return 2*rec + loop;
 }
@@ -2056,11 +2090,13 @@ static int compute_color (int my, int max) {
   if (!max) {
     color = 0;
   } else {
+    int step;
+
     /* if small, scale to the full color range. */
     if (max < n_colors)
       my = my * (n_colors/max);
 
-    int step = 1 + (max / n_colors);
+    step = 1 + (max / n_colors);
 
     color = my/step;
   }
@@ -2068,22 +2104,24 @@ static int compute_color (int my, int max) {
 }
 
 static int get_entity_color(entity *ent) {
-  assert(get_entity_irg(ent));
   ir_graph *irg = get_entity_irg(ent);
+  assert(irg);
 
-  int rec_depth     = get_irg_recursion_depth(irg);
-  int loop_depth    = get_irg_loop_depth(irg);
-  int overall_depth = weight_overall(rec_depth, loop_depth);
+  {
+    int rec_depth     = get_irg_recursion_depth(irg);
+    int loop_depth    = get_irg_loop_depth(irg);
+    int overall_depth = weight_overall(rec_depth, loop_depth);
 
-  int max_rec_depth     = irp->max_callgraph_recursion_depth;
-  int max_loop_depth    = irp->max_callgraph_loop_depth;
-  int max_overall_depth = weight_overall(max_rec_depth, max_loop_depth);
+    int max_rec_depth     = irp->max_callgraph_recursion_depth;
+    int max_loop_depth    = irp->max_callgraph_loop_depth;
+    int max_overall_depth = weight_overall(max_rec_depth, max_loop_depth);
 
-  /* int my_rec_color     = compute_color(rec_depth, max_rec_depth); */
-  /* int my_loop_color    = compute_color(loop_depth, max_loop_depth); */
-  int my_overall_color = compute_color(overall_depth, max_overall_depth);;
+    /* int my_rec_color     = compute_color(rec_depth, max_rec_depth); */
+    /* int my_loop_color    = compute_color(loop_depth, max_loop_depth); */
+    int my_overall_color = compute_color(overall_depth, max_overall_depth);;
 
-  return my_overall_color;
+    return my_overall_color;
+  }
 }
 
 void dump_callgraph(const char *suffix) {
@@ -2282,9 +2320,11 @@ void dump_loops_standalone(FILE *F, ir_loop *loop) {
       /* 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: \"");
@@ -2294,7 +2334,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); */
     }