projects / libfirm / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fixed some obviously wrong conditions.
[libfirm] / ir / ir / iropt.c
diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c
index 93f7c01..eb23281 100644 (file)
--- a/ir/ir/iropt.c
+++ b/ir/ir/iropt.c
@@ -308,7 +308,7 @@ static tarval *computed_value_Eor(const ir_node *n) {
        tb = value_of(b);
 
        if ((ta != tarval_bad) && (tb != tarval_bad)) {
-               return tarval_eor (ta, tb);
+               return tarval_eor(ta, tb);
        }
        return tarval_bad;
 }  /* computed_value_Eor */
@@ -337,7 +337,7 @@ static tarval *computed_value_Shl(const ir_node *n) {
        tarval *tb = value_of(b);
 
        if ((ta != tarval_bad) && (tb != tarval_bad)) {
-               return tarval_shl (ta, tb);
+               return tarval_shl(ta, tb);
        }
        return tarval_bad;
 }  /* computed_value_Shl */
@@ -353,7 +353,7 @@ static tarval *computed_value_Shr(const ir_node *n) {
        tarval *tb = value_of(b);
 
        if ((ta != tarval_bad) && (tb != tarval_bad)) {
-               return tarval_shr (ta, tb);
+               return tarval_shr(ta, tb);
        }
        return tarval_bad;
 }  /* computed_value_Shr */
@@ -369,7 +369,7 @@ static tarval *computed_value_Shrs(const ir_node *n) {
        tarval *tb = value_of(b);
 
        if ((ta != tarval_bad) && (tb != tarval_bad)) {
-               return tarval_shrs (ta, tb);
+               return tarval_shrs(ta, tb);
        }
        return tarval_bad;
 }  /* computed_value_Shrs */
@@ -429,7 +429,7 @@ static tarval *computed_value_Mux(const ir_node *n) {
 static tarval *computed_value_Confirm(const ir_node *n) {
        /*
         * Beware: we might produce Phi(Confirm(x == true), Confirm(x == false)).
-        * Do NOT optimize them away (CondEval wants them), so wait until
+        * Do NOT optimize them away (jump threading wants them), so wait until
         * remove_confirm is activated.
         */
        if (get_opt_remove_confirm()) {
@@ -1596,7 +1596,6 @@ static ir_node *equivalent_node_Proj_CopyB(ir_node *proj) {
                        DBG_OPT_ALGSIM0(oldn, proj, FS_OPT_NOP);
                        break;
 
-               case pn_CopyB_M_except:
                case pn_CopyB_X_except:
                        DBG_OPT_EXC_REM(proj);
                        proj = get_irg_bad(current_ir_graph);
@@ -1956,11 +1955,18 @@ static int is_const_Phi(ir_node *n) {
 typedef tarval *(*tarval_sub_type)(tarval *a, tarval *b, ir_mode *mode);
 typedef tarval *(*tarval_binop_type)(tarval *a, tarval *b);
 
+/**
+ * in reality eval_func should be tarval (*eval_func)() but incomplete
+ * declarations are bad style and generate noisy warnings
+ */
+typedef void (*eval_func)(void);
+
 /**
  * Wrapper for the tarval binop evaluation, tarval_sub has one more parameter.
  */
-static tarval *do_eval(tarval *(*eval)(), tarval *a, tarval *b, ir_mode *mode) {
-       if (eval == tarval_sub) {
+static tarval *do_eval(eval_func eval, tarval *a, tarval *b, ir_mode *mode)
+{
+       if (eval == (eval_func) tarval_sub) {
                tarval_sub_type func = (tarval_sub_type)eval;
 
                return func(a, b, mode);
@@ -1982,7 +1988,7 @@ static tarval *do_eval(tarval *(*eval)(), tarval *a, tarval *b, ir_mode *mode) {
  *
  * @return a new Phi node if the conversion was successful, NULL else
  */
-static ir_node *apply_binop_on_phi(ir_node *phi, tarval *other, tarval *(*eval)(), ir_mode *mode, int left) {
+static ir_node *apply_binop_on_phi(ir_node *phi, tarval *other, eval_func eval, ir_mode *mode, int left) {
        tarval   *tv;
        void     **res;
        ir_node  *pred;
@@ -2033,7 +2039,7 @@ static ir_node *apply_binop_on_phi(ir_node *phi, tarval *other, tarval *(*eval)(
  *
  * @return a new Phi node if the conversion was successful, NULL else
  */
-static ir_node *apply_binop_on_2_phis(ir_node *a, ir_node *b, tarval *(*eval)(), ir_mode *mode) {
+static ir_node *apply_binop_on_2_phis(ir_node *a, ir_node *b, eval_func eval, ir_mode *mode) {
        tarval   *tv_l, *tv_r, *tv;
        void     **res;
        ir_node  *pred;
@@ -2274,7 +2280,7 @@ static ir_node *transform_node_Add(ir_node *n) {
                }
        }
 
-       HANDLE_BINOP_PHI(tarval_add, a, b, c, mode);
+       HANDLE_BINOP_PHI((eval_func) tarval_add, a, b, c, mode);
 
        /* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
        if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic))
@@ -2406,7 +2412,7 @@ static ir_node *transform_node_Sub(ir_node *n) {
        }
 
 restart:
-       HANDLE_BINOP_PHI(tarval_sub, a, b, c, mode);
+       HANDLE_BINOP_PHI((eval_func) tarval_sub, a, b, c, mode);
 
        /* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
        if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic))
@@ -2723,7 +2729,7 @@ static ir_node *transform_node_Mul(ir_node *n) {
        if (mode != get_irn_mode(a))
                return transform_node_Mul2n(n, mode);
 
-       HANDLE_BINOP_PHI(tarval_mul, a, b, c, mode);
+       HANDLE_BINOP_PHI((eval_func) tarval_mul, a, b, c, mode);
 
        if (mode_is_signed(mode)) {
                ir_node *r = NULL;
@@ -2775,6 +2781,28 @@ static ir_node *transform_node_Mul(ir_node *n) {
                        DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_MUL_MINUS);
                        return n;
                }
+       } else if (is_Shl(a)) {
+               ir_node *const shl_l = get_Shl_left(a);
+               if (is_Const(shl_l) && is_Const_one(shl_l)) {
+                       /* (1 << x) * b -> b << x */
+                       dbg_info *const dbgi  = get_irn_dbg_info(n);
+                       ir_node  *const block = get_nodes_block(n);
+                       ir_node  *const shl_r = get_Shl_right(a);
+                       n = new_rd_Shl(dbgi, block, b, shl_r, mode);
+                       // TODO add me DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_MUL_SHIFT);
+                       return n;
+               }
+       } else if (is_Shl(b)) {
+               ir_node *const shl_l = get_Shl_left(b);
+               if (is_Const(shl_l) && is_Const_one(shl_l)) {
+                       /* a * (1 << x) -> a << x */
+                       dbg_info *const dbgi  = get_irn_dbg_info(n);
+                       ir_node  *const block = get_nodes_block(n);
+                       ir_node  *const shl_r = get_Shl_right(b);
+                       n = new_rd_Shl(dbgi, block, a, shl_r, mode);
+                       // TODO add me DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_MUL_SHIFT);
+                       return n;
+               }
        }
        if (get_mode_arithmetic(mode) == irma_ieee754) {
                if (is_Const(a)) {
@@ -2813,7 +2841,7 @@ static ir_node *transform_node_Div(ir_node *n) {
 
        if (is_Const(b) && is_const_Phi(a)) {
                /* check for Div(Phi, Const) */
-               value = apply_binop_on_phi(a, get_Const_tarval(b), tarval_div, mode, 0);
+               value = apply_binop_on_phi(a, get_Const_tarval(b), (eval_func) tarval_div, mode, 0);
                if (value) {
                        DBG_OPT_ALGSIM0(n, value, FS_OPT_CONST_PHI);
                        goto make_tuple;
@@ -2821,7 +2849,7 @@ static ir_node *transform_node_Div(ir_node *n) {
        }
        else if (is_Const(a) && is_const_Phi(b)) {
                /* check for Div(Const, Phi) */
-               value = apply_binop_on_phi(b, get_Const_tarval(a), tarval_div, mode, 1);
+               value = apply_binop_on_phi(b, get_Const_tarval(a), (eval_func) tarval_div, mode, 1);
                if (value) {
                        DBG_OPT_ALGSIM0(n, value, FS_OPT_CONST_PHI);
                        goto make_tuple;
@@ -2829,7 +2857,7 @@ static ir_node *transform_node_Div(ir_node *n) {
        }
        else if (is_const_Phi(a) && is_const_Phi(b)) {
                /* check for Div(Phi, Phi) */
-               value = apply_binop_on_2_phis(a, b, tarval_div, mode);
+               value = apply_binop_on_2_phis(a, b, (eval_func) tarval_div, mode);
                if (value) {
                        DBG_OPT_ALGSIM0(n, value, FS_OPT_CONST_PHI);
                        goto make_tuple;
@@ -2889,7 +2917,7 @@ static ir_node *transform_node_Mod(ir_node *n) {
 
        if (is_Const(b) && is_const_Phi(a)) {
                /* check for Div(Phi, Const) */
-               value = apply_binop_on_phi(a, get_Const_tarval(b), tarval_mod, mode, 0);
+               value = apply_binop_on_phi(a, get_Const_tarval(b), (eval_func) tarval_mod, mode, 0);
                if (value) {
                        DBG_OPT_ALGSIM0(n, value, FS_OPT_CONST_PHI);
                        goto make_tuple;
@@ -2897,7 +2925,7 @@ static ir_node *transform_node_Mod(ir_node *n) {
        }
        else if (is_Const(a) && is_const_Phi(b)) {
                /* check for Div(Const, Phi) */
-               value = apply_binop_on_phi(b, get_Const_tarval(a), tarval_mod, mode, 1);
+               value = apply_binop_on_phi(b, get_Const_tarval(a), (eval_func) tarval_mod, mode, 1);
                if (value) {
                        DBG_OPT_ALGSIM0(n, value, FS_OPT_CONST_PHI);
                        goto make_tuple;
@@ -2905,7 +2933,7 @@ static ir_node *transform_node_Mod(ir_node *n) {
        }
        else if (is_const_Phi(a) && is_const_Phi(b)) {
                /* check for Div(Phi, Phi) */
-               value = apply_binop_on_2_phis(a, b, tarval_mod, mode);
+               value = apply_binop_on_2_phis(a, b, (eval_func) tarval_mod, mode);
                if (value) {
                        DBG_OPT_ALGSIM0(n, value, FS_OPT_CONST_PHI);
                        goto make_tuple;
@@ -2978,8 +3006,8 @@ static ir_node *transform_node_DivMod(ir_node *n) {
 
        if (is_Const(b) && is_const_Phi(a)) {
                /* check for Div(Phi, Const) */
-               va = apply_binop_on_phi(a, get_Const_tarval(b), tarval_div, mode, 0);
-               vb = apply_binop_on_phi(a, get_Const_tarval(b), tarval_mod, mode, 0);
+               va = apply_binop_on_phi(a, get_Const_tarval(b), (eval_func) tarval_div, mode, 0);
+               vb = apply_binop_on_phi(a, get_Const_tarval(b), (eval_func) tarval_mod, mode, 0);
                if (va && vb) {
                        DBG_OPT_ALGSIM0(n, va, FS_OPT_CONST_PHI);
                        DBG_OPT_ALGSIM0(n, vb, FS_OPT_CONST_PHI);
@@ -2988,8 +3016,8 @@ static ir_node *transform_node_DivMod(ir_node *n) {
        }
        else if (is_Const(a) && is_const_Phi(b)) {
                /* check for Div(Const, Phi) */
-               va = apply_binop_on_phi(b, get_Const_tarval(a), tarval_div, mode, 1);
-               vb = apply_binop_on_phi(b, get_Const_tarval(a), tarval_mod, mode, 1);
+               va = apply_binop_on_phi(b, get_Const_tarval(a), (eval_func) tarval_div, mode, 1);
+               vb = apply_binop_on_phi(b, get_Const_tarval(a), (eval_func) tarval_mod, mode, 1);
                if (va && vb) {
                        DBG_OPT_ALGSIM0(n, va, FS_OPT_CONST_PHI);
                        DBG_OPT_ALGSIM0(n, vb, FS_OPT_CONST_PHI);
@@ -2998,8 +3026,8 @@ static ir_node *transform_node_DivMod(ir_node *n) {
        }
        else if (is_const_Phi(a) && is_const_Phi(b)) {
                /* check for Div(Phi, Phi) */
-               va = apply_binop_on_2_phis(a, b, tarval_div, mode);
-               vb = apply_binop_on_2_phis(a, b, tarval_mod, mode);
+               va = apply_binop_on_2_phis(a, b, (eval_func) tarval_div, mode);
+               vb = apply_binop_on_2_phis(a, b, (eval_func) tarval_mod, mode);
                if (va && vb) {
                        DBG_OPT_ALGSIM0(n, va, FS_OPT_CONST_PHI);
                        DBG_OPT_ALGSIM0(n, vb, FS_OPT_CONST_PHI);
@@ -3273,7 +3301,7 @@ static ir_node *transform_bitwise_distributive(ir_node *n,
                        n = trans_func(n);
                        n = new_r_Conv(blk, n, get_irn_mode(oldn));
 
-                       DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_SHIFT_AND);
+                       DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV);
                        return n;
                }
        }
@@ -3355,7 +3383,7 @@ static ir_node *transform_node_And(ir_node *n) {
        ir_mode *mode;
 
        mode = get_irn_mode(n);
-       HANDLE_BINOP_PHI(tarval_and, a, b, c, mode);
+       HANDLE_BINOP_PHI((eval_func) tarval_and, a, b, c, mode);
 
        /* we can evaluate 2 Projs of the same Cmp */
        if (mode == mode_b && is_Proj(a) && is_Proj(b)) {
@@ -3487,7 +3515,7 @@ static ir_node *transform_node_Eor(ir_node *n) {
        ir_node *b = get_Eor_right(n);
        ir_mode *mode = get_irn_mode(n);
 
-       HANDLE_BINOP_PHI(tarval_eor, a, b, c, mode);
+       HANDLE_BINOP_PHI((eval_func) tarval_eor, a, b, c, mode);
 
        /* we can evaluate 2 Projs of the same Cmp */
        if (mode == mode_b && is_Proj(a) && is_Proj(b)) {
@@ -4632,7 +4660,6 @@ static ir_node *transform_node_Proj_CopyB(ir_node *proj) {
                        DBG_OPT_EXC_REM(proj);
                        proj = new_r_Jmp(get_nodes_block(copyb));
                        break;
-               case pn_CopyB_M_except:
                case pn_CopyB_X_except:
                        DBG_OPT_EXC_REM(proj);
                        proj = get_irg_bad(get_irn_irg(proj));
@@ -5000,7 +5027,7 @@ static ir_node *transform_node_Or(ir_node *n) {
        }
 
        mode = get_irn_mode(n);
-       HANDLE_BINOP_PHI(tarval_or, a, b, c, mode);
+       HANDLE_BINOP_PHI((eval_func) tarval_or, a, b, c, mode);
 
        n = transform_node_Or_bf_store(n);
        n = transform_node_Or_Rotl(n);
@@ -5057,7 +5084,6 @@ static ir_node *transform_node_shift(ir_node *n) {
                        /* shifting too much */
                        if (!(tarval_cmp(res, modulo) & pn_Cmp_Lt)) {
                                if (is_Shrs(n)) {
-                                       ir_graph *irg   = get_irn_irg(n);
                                        ir_node  *block = get_nodes_block(n);
                                        dbg_info *dbgi  = get_irn_dbg_info(n);
                                        ir_mode  *smode  = get_irn_mode(right);
@@ -5278,7 +5304,7 @@ static ir_node *transform_node_Shr(ir_node *n) {
        ir_node *right = get_Shr_right(n);
        ir_mode *mode  = get_irn_mode(n);
 
-       HANDLE_BINOP_PHI(tarval_shr, left, right, c, mode);
+       HANDLE_BINOP_PHI((eval_func) tarval_shr, left, right, c, mode);
        n = transform_node_shift(n);
 
        if (is_Shr(n))
@@ -5298,7 +5324,7 @@ static ir_node *transform_node_Shrs(ir_node *n) {
        ir_node *b    = get_Shrs_right(n);
        ir_mode *mode = get_irn_mode(n);
 
-       HANDLE_BINOP_PHI(tarval_shrs, a, b, c, mode);
+       HANDLE_BINOP_PHI((eval_func) tarval_shrs, a, b, c, mode);
        n = transform_node_shift(n);
 
        if (is_Shrs(n))
@@ -5316,7 +5342,7 @@ static ir_node *transform_node_Shl(ir_node *n) {
        ir_node *b    = get_Shl_right(n);
        ir_mode *mode = get_irn_mode(n);
 
-       HANDLE_BINOP_PHI(tarval_shl, a, b, c, mode);
+       HANDLE_BINOP_PHI((eval_func) tarval_shl, a, b, c, mode);
        n = transform_node_shift(n);
 
        if (is_Shl(n))
@@ -5336,7 +5362,7 @@ static ir_node *transform_node_Rotl(ir_node *n) {
        ir_node *b    = get_Rotl_right(n);
        ir_mode *mode = get_irn_mode(n);
 
-       HANDLE_BINOP_PHI(tarval_rotl, a, b, c, mode);
+       HANDLE_BINOP_PHI((eval_func) tarval_rotl, a, b, c, mode);
        n = transform_node_shift(n);
 
        if (is_Rotl(n))
@@ -5975,7 +6001,10 @@ static int node_cmp_attr_SymConst(ir_node *a, ir_node *b) {
 
 /** Compares the attributes of two Call nodes. */
 static int node_cmp_attr_Call(ir_node *a, ir_node *b) {
-       return get_irn_call_attr(a) != get_irn_call_attr(b);
+       const call_attr *pa = get_irn_call_attr(a);
+       const call_attr *pb = get_irn_call_attr(b);
+       return (pa->type != pb->type)
+               || (pa->tail_call != pb->tail_call);
 }  /* node_cmp_attr_Call */
 
 /** Compares the attributes of two Sel nodes. */
libfirm