Use @version tag

[libfirm] / ir / ana / irconsconfirm.c

diff --git a/ir/ana/irconsconfirm.c b/ir/ana/irconsconfirm.c
index de47534..1198034 100644 (file)
--- a/ir/ana/irconsconfirm.c
+++ b/ir/ana/irconsconfirm.c
@@ -35,6 +35,7 @@
 #include "irgwalk.h"
 #include "irprintf.h"
 #include "irgopt.h"
+#include "irpass.h"
 #include "irtools.h"
 #include "array_t.h"
 #include "debug.h"
@@ -108,7 +109,7 @@ static void handle_case(ir_node *block, ir_node *irn, long nr, env_t *env) {
                                ir_mode *mode = get_irn_mode(irn);
                                ir_type *tp   = get_irn_type(irn);
                                tarval *tv    = new_tarval_from_long(nr, mode);
-                               c = new_r_Const_type(current_ir_graph, block, mode, tv, tp);
+                               c = new_r_Const_type(current_ir_graph, tv, tp);
                        }
 
                        set_irn_n(succ, pos, c);
@@ -146,7 +147,7 @@ static void handle_modeb(ir_node *block, ir_node *selector, pn_Cond pnc, env_t *
                         * We can replace the input with true/false.
                         */
                        if (con == NULL) {
-                               con = new_Const(mode_b, pnc == pn_Cond_true ? tarval_b_true : tarval_b_false);
+                               con = new_Const(pnc == pn_Cond_true ? tarval_b_true : tarval_b_false);
                        }
                        old = get_irn_n(user, pos);
                        set_irn_n(user, pos, con);
@@ -207,12 +208,15 @@ static void handle_modeb(ir_node *block, ir_node *selector, pn_Cond pnc, env_t *
                                NEW_ARR_A(ir_node *, in, n);
                                /* ok, ALL predecessors are either dominated by block OR other block */
                                if (c_b == NULL) {
-                                       ir_node *c_true  = new_Const(mode_b, tarval_b_true);
-                                       ir_node *c_false = new_Const(mode_b, tarval_b_false);
-                                       c_b = new_r_Confirm(current_ir_graph, cond_block, selector,
-                                               pnc == pn_Cond_true ? c_true : c_false, pn_Cmp_Eq);
-                                       c_o = new_r_Confirm(current_ir_graph, cond_block, selector,
-                                               pnc == pn_Cond_false ? c_true : c_false, pn_Cmp_Eq);
+                                       ir_node *c_true  = new_Const(tarval_b_true);
+                                       ir_node *c_false = new_Const(tarval_b_false);
+                                       if (pnc == pn_Cond_true) {
+                                               c_b = c_true;
+                                               c_o = c_false;
+                                       } else {
+                                               c_b = c_false;
+                                               c_o = c_true;
+                                       }
                                }
                                for (i = n - 1; i >= 0; --i) {
                                        ir_node *pred_blk = get_Block_cfgpred_block(user_blk, i);
@@ -222,7 +226,7 @@ static void handle_modeb(ir_node *block, ir_node *selector, pn_Cond pnc, env_t *
                                        else
                                                in[i] = c_o;
                                }
-                               phi = new_r_Phi(current_ir_graph, user_blk, n, in, mode_b);
+                               phi = new_r_Phi(user_blk, n, in, mode_b);
                                set_irn_n(user, pos, phi);
                        }
                }
@@ -329,12 +333,11 @@ static void handle_if(ir_node *block, ir_node *cmp, pn_Cmp pnc, env_t *env) {
        } else { /* not pn_Cmp_Eq cases */
                ir_node *c = NULL;
 
-               for (edge = get_irn_out_edge_first(left); edge; edge = next) {
+               foreach_out_edge_safe(left, edge, next) {
                        ir_node *succ = get_edge_src_irn(edge);
                        int     pos   = get_edge_src_pos(edge);
                        ir_node *blk  = get_effective_use_block(succ, pos);
 
-                       next = get_irn_out_edge_next(left, edge);
                        if (block_dominates(block, blk)) {
                                /*
                                 * Ok, we found a usage of left in a block
@@ -342,7 +345,7 @@ static void handle_if(ir_node *block, ir_node *cmp, pn_Cmp pnc, env_t *env) {
                                 * We can replace the input with a Confirm(left, pnc, right).
                                 */
                                if (! c)
-                                       c = new_r_Confirm(current_ir_graph, block, left, right, pnc);
+                                       c = new_r_Confirm(block, left, right, pnc);
 
                                pos = get_edge_src_pos(edge);
                                set_irn_n(succ, pos, c);
@@ -351,6 +354,40 @@ static void handle_if(ir_node *block, ir_node *cmp, pn_Cmp pnc, env_t *env) {
                                env->num_confirms += 1;
                        }
                }
+
+               if (! is_Const(right)) {
+                       /* also construct inverse Confirms */
+                       ir_node *rc = NULL;
+
+                       pnc = get_inversed_pnc(pnc);
+                       foreach_out_edge_safe(right, edge, next) {
+                               ir_node *succ = get_edge_src_irn(edge);
+                               int     pos;
+                               ir_node *blk;
+
+                               if (succ == c)
+                                       continue;
+
+                               pos  = get_edge_src_pos(edge);
+                               blk  = get_effective_use_block(succ, pos);
+
+                               if (block_dominates(block, blk)) {
+                                       /*
+                                        * Ok, we found a usage of right in a block
+                                        * dominated by the branch block.
+                                        * We can replace the input with a Confirm(right, pnc^-1, left).
+                                        */
+                                       if (! rc)
+                                               rc = new_r_Confirm(block, right, left, pnc);
+
+                                       pos = get_edge_src_pos(edge);
+                                       set_irn_n(succ, pos, rc);
+                                       DB((dbg, LEVEL_2, "Replacing input %d of node %+F with %+F\n", pos, succ, rc));
+
+                                       env->num_confirms += 1;
+                               }
+                       }
+               }
        }
 }  /* handle_if */
 
@@ -397,6 +434,7 @@ static void insert_Confirm_in_block(ir_node *block, void *env) {
 
                if (get_Proj_proj(proj) != pn_Cond_true) {
                        /* it's the false branch */
+                       mode = get_irn_mode(get_Cmp_left(cmp));
                        pnc = get_negated_pnc(pnc, mode);
                }
                DB((dbg, LEVEL_2, "At %+F using %+F Confirm %=\n", block, cmp, pnc));
@@ -406,7 +444,7 @@ static void insert_Confirm_in_block(ir_node *block, void *env) {
                long proj_nr = get_Proj_proj(proj);
 
                /* this is a CASE, but we cannot handle the default case */
-               if (proj_nr == get_Cond_defaultProj(cond))
+               if (proj_nr == get_Cond_default_proj(cond))
                        return;
 
                handle_case(block, get_Cond_selector(cond), proj_nr, env);
@@ -470,9 +508,9 @@ static void insert_non_null(ir_node *ptr, ir_node *block, env_t *env) {
                         */
                        if (c == NULL) {
                                ir_mode *mode = get_irn_mode(ptr);
-                               c = new_Const(mode, get_mode_null(mode));
+                               c = new_Const(get_mode_null(mode));
 
-                               c = new_r_Confirm(current_ir_graph, block, ptr, c, pn_Cmp_Lg);
+                               c = new_r_Confirm(block, ptr, c, pn_Cmp_Lg);
                        }
 
                        set_irn_n(succ, pos, c);
@@ -563,6 +601,11 @@ void construct_confirms(ir_graph *irg) {
                edges_deactivate(irg);
 }  /* construct_confirms */
 
+/* Construct a pass. */
+ir_graph_pass_t *construct_confirms_pass(const char *name) {
+       return def_graph_pass(name ? name : "confirm", construct_confirms);
+}  /* construct_confirms_pass */
+
 #if 0
 /**
  * Post-walker: Remove Confirm nodes
@@ -594,3 +637,8 @@ void remove_confirms(ir_graph *irg) {
        optimize_graph_df(irg);
        set_opt_remove_confirm(rem);
 }  /* remove_confirms */
+
+/* Construct a pass. */
+ir_graph_pass_t *remove_confirms_pass(const char *name) {
+       return def_graph_pass(name ? name : "rem_confirm", remove_confirms);
+}  /* remove_confirms_pass */