make firm compilable with a c++ compiler

[libfirm] / ir / ana / irconsconfirm.c

diff --git a/ir/ana/irconsconfirm.c b/ir/ana/irconsconfirm.c
index a6628df..9d2d50e 100644 (file)
--- a/ir/ana/irconsconfirm.c
+++ b/ir/ana/irconsconfirm.c
@@ -46,7 +46,7 @@
 /**
  * Walker environment.
  */
-typedef struct _env_t {
+typedef struct env_t {
        unsigned num_confirms;  /**< Number of inserted Confirm nodes. */
        unsigned num_consts;    /**< Number of constants placed. */
        unsigned num_eq;        /**< Number of equalities placed. */
@@ -110,10 +110,9 @@ static void handle_case(ir_node *block, ir_node *irn, long nr, env_t *env)
                         */
 
                        if (! c) {
-                               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, tv, tp);
+                               ir_mode   *mode = get_irn_mode(irn);
+                               ir_tarval *tv   = new_tarval_from_long(nr, mode);
+                               c = new_r_Const(current_ir_graph, tv);
                        }
 
                        set_irn_n(succ, pos, c);
@@ -152,7 +151,8 @@ 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(pnc == pn_Cond_true ? tarval_b_true : tarval_b_false);
+                               ir_graph *irg = get_irn_irg(block);
+                               con = new_r_Const(irg, pnc == pn_Cond_true ? tarval_b_true : tarval_b_false);
                        }
                        old = get_irn_n(user, pos);
                        set_irn_n(user, pos, con);
@@ -178,7 +178,7 @@ static void handle_modeb(ir_node *block, ir_node *selector, pn_Cond pnc, env_t *
                                }
                                assert(other_blk);
 
-                               /*
+                               /*
                                 * Note the special case here: if block is a then, there might be no else
                                 * block. In that case the other_block is the user_blk itself and pred_block
                                 * is the cond_block ...
@@ -212,8 +212,10 @@ 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(tarval_b_true);
-                                       ir_node *c_false = new_Const(tarval_b_false);
+                                       ir_graph *irg    = get_irn_irg(block);
+                                       ir_node *c_true  = new_r_Const(irg, tarval_b_true);
+                                       ir_node *c_false = new_r_Const(irg, tarval_b_false);
+                                       env->num_consts += 2;
                                        if (pnc == pn_Cond_true) {
                                                c_b = c_true;
                                                c_o = c_false;
@@ -232,6 +234,7 @@ static void handle_modeb(ir_node *block, ir_node *selector, pn_Cond pnc, env_t *
                                }
                                phi = new_r_Phi(user_blk, n, in, mode_b);
                                set_irn_n(user, pos, phi);
+                               env->num_eq += 1;
                        }
                }
        }
@@ -400,10 +403,11 @@ static void handle_if(ir_node *block, ir_node *cmp, pn_Cmp pnc, env_t *env)
 /**
  * Pre-block-walker: Called for every block to insert Confirm nodes
  */
-static void insert_Confirm_in_block(ir_node *block, void *env)
+static void insert_Confirm_in_block(ir_node *block, void *data)
 {
        ir_node *cond, *proj, *selector;
        ir_mode *mode;
+       env_t   *env = (env_t*) data;
 
        /*
         * we can only handle blocks with only ONE control flow
@@ -427,7 +431,7 @@ static void insert_Confirm_in_block(ir_node *block, void *env)
                ir_node *cmp;
                pn_Cmp pnc;
 
-               handle_modeb(block, selector, get_Proj_proj(proj), env);
+               handle_modeb(block, selector, (pn_Cond) get_Proj_proj(proj), env);
 
                /* this should be an IF, check this */
                if (! is_Proj(selector))
@@ -437,7 +441,7 @@ static void insert_Confirm_in_block(ir_node *block, void *env)
                if (! is_Cmp(cmp))
                        return;
 
-               pnc = get_Proj_proj(selector);
+               pnc = (pn_Cmp) get_Proj_proj(selector);
 
                if (get_Proj_proj(proj) != pn_Cond_true) {
                        /* it's the false branch */
@@ -516,9 +520,9 @@ static void insert_non_null(ir_node *ptr, ir_node *block, env_t *env)
                         * We can replace the input with a Confirm(ptr, !=, NULL).
                         */
                        if (c == NULL) {
-                               ir_mode *mode = get_irn_mode(ptr);
-                               c = new_Const(get_mode_null(mode));
-
+                               ir_mode  *mode = get_irn_mode(ptr);
+                               ir_graph *irg  = get_irn_irg(block);
+                               c = new_r_Const(irg, get_mode_null(mode));
                                c = new_r_Confirm(block, ptr, c, pn_Cmp_Lg);
                        }
 
@@ -534,9 +538,10 @@ static void insert_non_null(ir_node *ptr, ir_node *block, env_t *env)
 /**
  * Pre-walker: Called for every node to insert Confirm nodes
  */
-static void insert_Confirm(ir_node *node, void *env)
+static void insert_Confirm(ir_node *node, void *data)
 {
        ir_node *ptr;
+       env_t   *env = (env_t*) data;
 
        switch (get_irn_opcode(node)) {
        case iro_Block:
@@ -617,38 +622,24 @@ 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
- */
-static void rem_Confirm(ir_node *n, void *env)
+static void remove_confirm(ir_node *n, void *env)
 {
+       ir_node *value;
+
        (void) env;
-       if (is_Confirm(n)) {
-               ir_node *value = get_Confirm_value(n);
-               if (value != n)
-                       exchange(n, value);
-               else {
-                       /*
-                        * Strange: a Confirm is its own bound. This can happen
-                        * in dead blocks when Phi nodes are already removed.
-                        */
-                       exchange(n, new_Bad());
-               }
-       }
-}  /* rem_Confirm */
-#endif
+       if (!is_Confirm(n))
+               return;
+
+       value = get_Confirm_value(n);
+       exchange(n, value);
+}
 
 /*
  * Remove all Confirm nodes from a graph.
  */
 void remove_confirms(ir_graph *irg)
 {
-       int rem = get_opt_remove_confirm();
-
-       set_opt_remove_confirm(1);
-       optimize_graph_df(irg);
-       set_opt_remove_confirm(rem);
+       irg_walk_graph(irg, NULL, remove_confirm, NULL);
 }  /* remove_confirms */
 
 /* Construct a pass. */