replaced all recursive computed_value calls ba value_of()

[libfirm] / ir / ir / irgwalk.c

diff --git a/ir/ir/irgwalk.c b/ir/ir/irgwalk.c
index 180680b..3661b41 100644 (file)
--- a/ir/ir/irgwalk.c
+++ b/ir/ir/irgwalk.c
@@ -208,16 +208,16 @@ void irg_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env)
 {
   assert(node  && node->kind==k_ir_node);
 
-  if (interprocedural_view) {
+  if (get_interprocedural_view()) {
     eset * irg_set = eset_create();
     int visited;
     ir_graph * irg;
     assert(get_irp_ip_view_state() == ip_view_valid);
 
-    interprocedural_view = false;
+    set_interprocedural_view(false);
     eset_insert(irg_set, current_ir_graph);
     irg_walk(node, (irg_walk_func *) collect_irgs, NULL, irg_set);
-    interprocedural_view = true;
+    set_interprocedural_view(true);
     visited = get_max_irg_visited() + 1;
     for (irg = eset_first(irg_set); irg; irg = eset_next(irg_set)) {
       set_irg_visited(irg, visited);
@@ -266,14 +266,14 @@ static INLINE ir_graph *
 switch_irg (ir_node *n, int index) {
   ir_graph *old_current = current_ir_graph;
 
-  if (interprocedural_view) {
+  if (get_interprocedural_view()) {
     /* Only Filter and Block nodes can have predecessors in other graphs. */
     if (get_irn_op(n) == op_Filter)
       n = get_nodes_block(n);
     if (get_irn_op(n) == op_Block) {
       ir_node *cfop = skip_Proj(get_Block_cfgpred(n, index));
       if (is_ip_cfop(cfop)) {
-    current_ir_graph = get_irn_irg(cfop);
+        current_ir_graph = get_irn_irg(cfop);
       }
     }
   }
@@ -312,9 +312,9 @@ cg_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void * env)
 void cg_walk(irg_walk_func *pre, irg_walk_func *post, void *env) {
   int i;
   ir_graph *rem = current_ir_graph;
-  int rem_view = interprocedural_view;
+  int rem_view = get_interprocedural_view();
 
-  interprocedural_view = true;
+  set_interprocedural_view(true);
 
   inc_max_irg_visited();
   /* Fix all irg_visited flags */
@@ -363,7 +363,7 @@ void cg_walk(irg_walk_func *pre, irg_walk_func *post, void *env) {
     }
   }
 
-  interprocedural_view = rem_view;
+  set_interprocedural_view(rem_view);
   current_ir_graph = rem;
 }
 
@@ -398,11 +398,11 @@ static void irg_block_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *p
       ir_node *pred = get_cf_op(get_Block_cfgpred(node, i));
       pred = get_nodes_block(pred);
       if(get_irn_opcode(pred) == iro_Block) {
-    /* recursion */
-    irg_block_walk_2(pred, pre, post, env);
+        /* recursion */
+        irg_block_walk_2(pred, pre, post, env);
       }
       else {
-    assert(get_irn_opcode(pred) == iro_Bad);
+        assert(get_irn_opcode(pred) == iro_Bad);
       }
     }
 
@@ -422,12 +422,13 @@ void irg_block_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void
   stat_irg_block_walk(current_ir_graph, node, (void *)pre, (void *)post);
 
   assert(node);
-  assert(!interprocedural_view);   /* interprocedural_view not implemented, because it
+  assert(!get_interprocedural_view());   /* interprocedural_view not implemented, because it
                     * interleaves with irg_walk */
   inc_irg_block_visited(current_ir_graph);
   if (is_no_Block(node)) block = get_nodes_block(node); else block = node;
   assert(get_irn_opcode(block)  == iro_Block);
   irg_block_walk_2(block, pre, post, env);
+
   /* keepalive: the endless loops ... */
   if (get_irn_op(node) == op_End) {
     int arity = get_irn_arity(node);
@@ -436,6 +437,17 @@ void irg_block_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void
       if (get_irn_op(pred) == op_Block)
         irg_block_walk_2(pred, pre, post, env);
     }
+    /* Sometimes the blocks died, but are still reachable through Phis.
+     * Make sure the algorithms that try to remove these reach them. */
+    for (i = 0; i < arity; i++) {
+      pred = get_irn_n(node, i);
+      if (get_irn_op(pred) == op_Phi) {
+       ir_node *block = get_nodes_block(pred);
+
+       if (! is_Bad(block))
+          irg_block_walk_2(block, pre, post, env);
+      }
+    }
   }
 
   return;