Correct comment: xvcg wants LF, not CR.

[libfirm] / ir / ir / rm_bads.c

diff --git a/ir/ir/rm_bads.c b/ir/ir/rm_bads.c
index bc948fa..25995f6 100644 (file)
--- a/ir/ir/rm_bads.c
+++ b/ir/ir/rm_bads.c
@@ -52,25 +52,20 @@ static int count_non_bads(ir_node *node)
  * Block-walker, remove Bad block predecessors and shorten Phis.
  * Phi links must be uptodate.
  */
-static void block_remove_bads(ir_node *block, void *env)
+static void block_remove_bads(ir_node *block)
 {
-       int *changed = (int *)env;
-       int i, j;
-       ir_node **new_in, *new_block, *phi;
-       ir_node *next;
+       ir_graph  *irg     = get_irn_irg(block);
+       const int  max     = get_irn_arity(block);
+       const int  new_max = count_non_bads(block);
+       ir_node  **new_in  = ALLOCAN(ir_node*, new_max);
+       int        i;
+       int        j;
+       ir_node   *new_block;
+       ir_node   *phi;
+       ir_node   *next;
        ir_entity *block_entity;
-       const int max = get_irn_arity(block);
-       const int new_max = count_non_bads(block);
        assert(max >= new_max);
 
-       if (is_Bad(block) || max == new_max)
-               return;
-
-       new_in = ALLOCAN(ir_node*, new_max);
-       *changed = 1;
-
-       assert(get_Block_dom_depth(block) >= 0);
-
        /* 1. Create a new block without Bad inputs */
        for (i = j = 0; i < max; ++i) {
                ir_node *block_pred = get_irn_n(block, i);
@@ -82,14 +77,14 @@ static void block_remove_bads(ir_node *block, void *env)
 
        /* If the end block is unreachable, it might have zero predecessors. */
        if (new_max == 0) {
-               ir_node *end_block = get_irg_end_block(get_irn_irg(block));
+               ir_node *end_block = get_irg_end_block(irg);
                if (block == end_block) {
                        set_irn_in(block, new_max, new_in);
                        return;
                }
        }
 
-       new_block = new_r_Block(get_irn_irg(block), new_max, new_in);
+       new_block = new_r_Block(irg, new_max, new_in);
        block_entity = get_Block_entity(block);
        if (block_entity)
                set_Block_entity(new_block, block_entity);
@@ -118,26 +113,40 @@ static void block_remove_bads(ir_node *block, void *env)
        exchange(block, new_block);
 }
 
-/* Remove Bad nodes from Phi and Block inputs.
- *
- * This does NOT remove unreachable code.
- *
- * Postcondition: No Bad nodes.
- */
+static void collect(ir_node *node, void *env)
+{
+       firm_collect_block_phis(node, NULL);
+       if (is_Block(node)) {
+               ir_node ***blocks_to_process = (ir_node***)env;
+               int        arity    = get_irn_arity(node);
+               int        non_bads = count_non_bads(node);
+               if (arity != non_bads)
+                       ARR_APP1(ir_node*, *blocks_to_process, node);
+       }
+}
+
 int remove_bads(ir_graph *irg)
 {
-       int changed = 0;
+       size_t i;
+       size_t n_to_process;
+       ir_node **blocks_to_process = NEW_ARR_F(ir_node*, 0);
+
        /* build phi list per block */
-       irg_walk_graph(irg, firm_clear_block_phis, firm_collect_block_phis, NULL);
+       irg_walk_graph(irg, firm_clear_block_phis, collect, &blocks_to_process);
 
-       /* actually remove Bads */
-       irg_block_walk_graph(irg, NULL, block_remove_bads, (void *)&changed);
+       n_to_process = ARR_LEN(blocks_to_process);
+       for (i = 0; i < n_to_process; ++i) {
+               ir_node *block = blocks_to_process[i];
+               block_remove_bads(block);
+       }
+       DEL_ARR_F(blocks_to_process);
 
-       if (changed) {
+       if (n_to_process > 0) {
                edges_deactivate(irg);
                clear_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_OUTS);
                clear_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE);
+               return 1;
        }
 
-       return changed;
+       return 0;
 }