Amend combo fix.

[libfirm] / ir / opt / combo.c

diff --git a/ir/opt/combo.c b/ir/opt/combo.c
index 94c116b..ad3d385 100644 (file)
--- a/ir/opt/combo.c
+++ b/ir/opt/combo.c
@@ -780,7 +780,8 @@ static void init_block_phis(ir_node *irn, void *ctx)
        (void) ctx;
 
        if (is_Phi(irn)) {
-               add_Block_phi(get_nodes_block(irn), irn);
+               ir_node *block = get_nodes_block(irn);
+               add_Block_phi(block, irn);
        }
 }  /* init_block_phis */
 
@@ -2257,11 +2258,13 @@ static void compute_Cmp(node_t *node)
        } else if (r->part == l->part && !mode_is_float(get_irn_mode(l->node))) {
                tv = relation & ir_relation_equal ? tarval_b_true : tarval_b_false;
 
-               /* if the node was ONCE evaluated by all constants, but now
+               /* if the node was ONCE evaluated to a constant, but now
                   this breaks AND we get from the argument partitions a different
-                  result, switch to bottom.
+                  result, ensure monotony by fall to bottom.
                   This happens because initially all nodes are in the same partition ... */
-               if (node->type.tv != tv)
+               if (node->type.tv == tarval_bottom)
+                       tv = tarval_bottom;
+               else if (node->type.tv != tv && is_constant_type(node->type))
                        tv = tarval_bottom;
                node->type.tv = tv;
        } else {
@@ -3001,18 +3004,21 @@ static void apply_cf(ir_node *block, void *ctx)
                        ir_node *pred = get_Block_cfgpred(block, i);
 
                        if (! is_Bad(pred)) {
-                               node_t *pred_bl = get_irn_node(get_nodes_block(skip_Proj(pred)));
-
-                               if (pred_bl->flagged == 0) {
-                                       pred_bl->flagged = 3;
-
-                                       if (pred_bl->type.tv == tarval_reachable) {
-                                               /*
-                                                * We will remove an edge from block to its pred.
-                                                * This might leave the pred block as an endless loop
-                                                */
-                                               if (! is_backedge(block, i))
-                                                       keep_alive(pred_bl->node);
+                               ir_node *pred_block = get_nodes_block(skip_Proj(pred));
+                               if (!is_Bad(pred_block)) {
+                                       node_t *pred_bl = get_irn_node(pred_block);
+
+                                       if (pred_bl->flagged == 0) {
+                                               pred_bl->flagged = 3;
+
+                                               if (pred_bl->type.tv == tarval_reachable) {
+                                                       /*
+                                                        * We will remove an edge from block to its pred.
+                                                        * This might leave the pred block as an endless loop
+                                                        */
+                                                       if (! is_backedge(block, i))
+                                                               keep_alive(pred_bl->node);
+                                               }
                                        }
                                }
                        }
@@ -3022,7 +3028,9 @@ static void apply_cf(ir_node *block, void *ctx)
                   finds out the opposite :-) */
                if (block != get_irg_end_block(current_ir_graph)) {
                        /* mark dead blocks */
-                       set_Block_dead(block);
+                       //set_Block_dead(block);
+                       //ir_graph *irg = get_irn_irg(block);
+                       //exchange(block, get_irg_bad(irg));
                        DB((dbg, LEVEL_1, "Removing dead %+F\n", block));
                } else {
                        /* the endblock is unreachable */
@@ -3057,18 +3065,21 @@ static void apply_cf(ir_node *block, void *ctx)
                } else {
                        DB((dbg, LEVEL_1, "Removing dead input %d from %+F (%+F)\n", i, block, pred));
                        if (! is_Bad(pred)) {
-                               node_t *pred_bl = get_irn_node(get_nodes_block(skip_Proj(pred)));
-
-                               if (pred_bl->flagged == 0) {
-                                       pred_bl->flagged = 3;
-
-                                       if (pred_bl->type.tv == tarval_reachable) {
-                                               /*
-                                                * We will remove an edge from block to its pred.
-                                                * This might leave the pred block as an endless loop
-                                                */
-                                               if (! is_backedge(block, i))
-                                                       keep_alive(pred_bl->node);
+                               ir_node *pred_block = get_nodes_block(skip_Proj(pred));
+                               if (!is_Bad(pred_block)) {
+                                       node_t *pred_bl = get_irn_node(pred_block);
+
+                                       if (!is_Bad(pred_bl->node) && pred_bl->flagged == 0) {
+                                               pred_bl->flagged = 3;
+
+                                               if (pred_bl->type.tv == tarval_reachable) {
+                                                       /*
+                                                        * We will remove an edge from block to its pred.
+                                                        * This might leave the pred block as an endless loop
+                                                        */
+                                                       if (! is_backedge(block, i))
+                                                               keep_alive(pred_bl->node);
+                                               }
                                        }
                                }
                        }
@@ -3397,13 +3408,22 @@ static void apply_end(ir_node *end, environment_t *env)
 
        /* fix the keep alive */
        for (i = j = 0; i < n; i++) {
-               ir_node *ka   = get_End_keepalive(end, i);
-               node_t  *node = get_irn_node(ka);
+               ir_node *ka = get_End_keepalive(end, i);
+               ir_node *block;
+               node_t  *node;
 
-               if (! is_Block(ka))
-                       node = get_irn_node(get_nodes_block(ka));
+               if (is_Bad(ka))
+                       continue;
+               if (!is_Block(ka)) {
+                       block = get_nodes_block(ka);
+                       if (is_Bad(block))
+                               continue;
+               } else {
+                       block = ka;
+               }
 
-               if (node->type.tv != tarval_unreachable && !is_Bad(ka))
+               node = get_irn_node(block);
+               if (node->type.tv != tarval_unreachable)
                        in[j++] = ka;
        }
        if (j != n) {