X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firopt.c;h=698ba038408c4d5ca7608fe6c96943052094b0b4;hb=df144e685b61ac41bf4d82f172515aa81bb1a2f3;hp=f5ff04caaac62ae1039088acd995e144a5b9c24e;hpb=df09677ac039a128dd31f201063c665857dca089;p=libfirm diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c index f5ff04caa..698ba0384 100644 --- a/ir/ir/iropt.c +++ b/ir/ir/iropt.c @@ -1912,7 +1912,7 @@ static ir_node *transform_node_Add(ir_node *n) { return n; if (mode_is_num(mode)) { - if (a == b) { + if (a == b && mode_is_int(mode)) { ir_node *block = get_irn_n(n, -1); n = new_rd_Mul( @@ -2218,22 +2218,51 @@ static ir_node *transform_node_Mul(ir_node *n) { */ static ir_node *transform_node_Div(ir_node *n) { tarval *tv = value_of(n); + ir_mode *mode = get_Div_resmode(n); ir_node *value = n; - /* BEWARE: it is NOT possible to optimize a/a to 1, as this may cause a exception */ - if (tv != tarval_bad) { value = new_Const(get_tarval_mode(tv), tv); DBG_OPT_CSTEVAL(n, value); - } else /* Try architecture dependent optimization */ - value = arch_dep_replace_div_by_const(n); + goto make_tuple; + } else { + ir_node *a = get_Div_left(n); + ir_node *b = get_Div_right(n); + ir_node *dummy; + + if (a == b && value_not_zero(a, &dummy)) { + /* BEWARE: we can optimize a/a to 1 only if this cannot cause a exception */ + value = new_Const(mode, get_mode_one(mode)); + DBG_OPT_CSTEVAL(n, value); + goto make_tuple; + } else { + if (mode_is_signed(mode) && is_Const(b)) { + tarval *tv = get_Const_tarval(b); + + if (tv == get_mode_minus_one(mode)) { + /* a / -1 */ + value = new_rd_Minus(get_irn_dbg_info(n), current_ir_graph, get_irn_n(n, -1), a, mode); + DBG_OPT_CSTEVAL(n, value); + goto make_tuple; + } + } + /* Try architecture dependent optimization */ + value = arch_dep_replace_div_by_const(n); + } + } if (value != n) { + ir_node *mem, *blk; + +make_tuple: /* Turn Div into a tuple (mem, jmp, bad, value) */ - ir_node *mem = get_Div_mem(n); - ir_node *blk = get_irn_n(n, -1); + mem = get_Div_mem(n); + blk = get_irn_n(n, -1); + /* skip a potential Pin */ + if (is_Pin(mem)) + mem = get_Pin_op(mem); turn_into_tuple(n, pn_Div_max); set_Tuple_pred(n, pn_Div_M, mem); set_Tuple_pred(n, pn_Div_X_regular, new_r_Jmp(current_ir_graph, blk)); @@ -2248,22 +2277,51 @@ static ir_node *transform_node_Div(ir_node *n) { */ static ir_node *transform_node_Mod(ir_node *n) { tarval *tv = value_of(n); + ir_mode *mode = get_Mod_resmode(n); ir_node *value = n; - /* BEWARE: it is NOT possible to optimize a%a to 0, as this may cause a exception */ - if (tv != tarval_bad) { value = new_Const(get_tarval_mode(tv), tv); DBG_OPT_CSTEVAL(n, value); - } else /* Try architecture dependent optimization */ - value = arch_dep_replace_mod_by_const(n); + goto make_tuple; + } else { + ir_node *a = get_Mod_left(n); + ir_node *b = get_Mod_right(n); + ir_node *dummy; + + if (a == b && value_not_zero(a, &dummy)) { + /* BEWARE: we can optimize a%a to 0 only if this cannot cause a exception */ + value = new_Const(mode, get_mode_null(mode)); + DBG_OPT_CSTEVAL(n, value); + goto make_tuple; + } else { + if (mode_is_signed(mode) && is_Const(b)) { + tarval *tv = get_Const_tarval(b); + + if (tv == get_mode_minus_one(mode)) { + /* a % -1 = 0 */ + value = new_Const(mode, get_mode_null(mode)); + DBG_OPT_CSTEVAL(n, value); + goto make_tuple; + } + } + /* Try architecture dependent optimization */ + value = arch_dep_replace_mod_by_const(n); + } + } if (value != n) { + ir_node *mem, *blk; + +make_tuple: /* Turn Mod into a tuple (mem, jmp, bad, value) */ - ir_node *mem = get_Mod_mem(n); - ir_node *blk = get_irn_n(n, -1); + mem = get_Mod_mem(n); + blk = get_irn_n(n, -1); + /* skip a potential Pin */ + if (is_Pin(mem)) + mem = get_Pin_op(mem); turn_into_tuple(n, pn_Mod_max); set_Tuple_pred(n, pn_Mod_M, mem); set_Tuple_pred(n, pn_Mod_X_regular, new_r_Jmp(current_ir_graph, blk)); @@ -2277,51 +2335,69 @@ static ir_node *transform_node_Mod(ir_node *n) { * Transform a DivMod node. */ static ir_node *transform_node_DivMod(ir_node *n) { - int evaluated = 0; - + ir_node *dummy; ir_node *a = get_DivMod_left(n); ir_node *b = get_DivMod_right(n); - ir_mode *mode = get_irn_mode(a); + ir_mode *mode = get_DivMod_resmode(n); tarval *ta = value_of(a); tarval *tb = value_of(b); - - if (!(mode_is_int(mode) && mode_is_int(get_irn_mode(b)))) - return n; - - /* BEWARE: it is NOT possible to optimize a/a to 1, as this may cause a exception */ + int evaluated = 0; if (tb != tarval_bad) { if (tb == get_mode_one(get_tarval_mode(tb))) { - b = new_Const (mode, get_mode_null(mode)); - evaluated = 1; - + b = new_Const(mode, get_mode_null(mode)); DBG_OPT_CSTEVAL(n, b); + goto make_tuple; } else if (ta != tarval_bad) { tarval *resa, *resb; - resa = tarval_div (ta, tb); + resa = tarval_div(ta, tb); if (resa == tarval_bad) return n; /* Causes exception!!! Model by replacing through Jmp for X result!? */ - resb = tarval_mod (ta, tb); + resb = tarval_mod(ta, tb); if (resb == tarval_bad) return n; /* Causes exception! */ - a = new_Const (mode, resa); - b = new_Const (mode, resb); - evaluated = 1; - + a = new_Const(mode, resa); + b = new_Const(mode, resb); + DBG_OPT_CSTEVAL(n, a); + DBG_OPT_CSTEVAL(n, b); + goto make_tuple; + } else if (mode_is_signed(mode) && tb == get_mode_minus_one(mode)) { + a = new_rd_Minus(get_irn_dbg_info(n), current_ir_graph, get_irn_n(n, -1), a, mode); + b = new_Const(mode, get_mode_null(mode)); DBG_OPT_CSTEVAL(n, a); DBG_OPT_CSTEVAL(n, b); + goto make_tuple; } else { /* Try architecture dependent optimization */ arch_dep_replace_divmod_by_const(&a, &b, n); evaluated = a != NULL; } - } else if (ta == get_mode_null(mode)) { + } else if (a == b) { + if (value_not_zero(a, &dummy)) { + /* a/a && a != 0 */ + a = new_Const(mode, get_mode_one(mode)); + b = new_Const(mode, get_mode_null(mode)); + DBG_OPT_CSTEVAL(n, a); + DBG_OPT_CSTEVAL(n, b); + goto make_tuple; + } else { + /* BEWARE: it is NOT possible to optimize a/a to 1, as this may cause a exception */ + return n; + } + } else if (ta == get_mode_null(mode) && value_not_zero(b, &dummy)) { /* 0 / non-Const = 0 */ b = a; - evaluated = 1; + goto make_tuple; } if (evaluated) { /* replace by tuple */ - ir_node *mem = get_DivMod_mem(n); - ir_node *blk = get_irn_n(n, -1); + ir_node *mem, *blk; + +make_tuple: + mem = get_DivMod_mem(n); + /* skip a potential Pin */ + if (is_Pin(mem)) + mem = get_Pin_op(mem); + + blk = get_irn_n(n, -1); turn_into_tuple(n, pn_DivMod_max); set_Tuple_pred(n, pn_DivMod_M, mem); set_Tuple_pred(n, pn_DivMod_X_regular, new_r_Jmp(current_ir_graph, blk)); @@ -2358,6 +2434,9 @@ static ir_node *transform_node_Quot(ir_node *n) { ir_node *m = new_rd_Mul(get_irn_dbg_info(n), current_ir_graph, blk, a, c, mode); ir_node *mem = get_Quot_mem(n); + /* skip a potential Pin */ + if (is_Pin(mem)) + mem = get_Pin_op(mem); turn_into_tuple(n, pn_Quot_max); set_Tuple_pred(n, pn_Quot_M, mem); set_Tuple_pred(n, pn_Quot_X_regular, new_r_Jmp(current_ir_graph, blk)); @@ -3178,6 +3257,11 @@ static void get_comm_Binop_Ops(ir_node *binop, ir_node **a, ir_node **c) { * OR c2 ===> OR * AND c1 * OR + * + * + * value c2 value c1 + * AND c1 ===> OR if (c1 | c2) == 0x111..11 + * OR */ static ir_node *transform_node_Or_bf_store(ir_node *or) { ir_node *and, *c1; @@ -3189,63 +3273,78 @@ static ir_node *transform_node_Or_bf_store(ir_node *or) { tarval *tv1, *tv2, *tv3, *tv4, *tv, *n_tv4, *n_tv2; - get_comm_Binop_Ops(or, &and, &c1); - if ((get_irn_op(c1) != op_Const) || (get_irn_op(and) != op_And)) - return or; + while (1) { + get_comm_Binop_Ops(or, &and, &c1); + if (!is_Const(c1) || !is_And(and)) + return or; - get_comm_Binop_Ops(and, &or_l, &c2); - if ((get_irn_op(c2) != op_Const) || (get_irn_op(or_l) != op_Or)) - return or; + get_comm_Binop_Ops(and, &or_l, &c2); + if (!is_Const(c2)) + return or; - get_comm_Binop_Ops(or_l, &and_l, &c3); - if ((get_irn_op(c3) != op_Const) || (get_irn_op(and_l) != op_And)) - return or; + tv1 = get_Const_tarval(c1); + tv2 = get_Const_tarval(c2); - get_comm_Binop_Ops(and_l, &value, &c4); - if (get_irn_op(c4) != op_Const) - return or; + tv = tarval_or(tv1, tv2); + if (classify_tarval(tv) == TV_CLASSIFY_ALL_ONE) { + /* the AND does NOT clear a bit with isn't set be the OR */ + set_Or_left(or, or_l); + set_Or_right(or, c1); - /* ok, found the pattern, check for conditions */ - assert(mode == get_irn_mode(and)); - assert(mode == get_irn_mode(or_l)); - assert(mode == get_irn_mode(and_l)); + /* check for more */ + continue; + } - tv1 = get_Const_tarval(c1); - tv2 = get_Const_tarval(c2); - tv3 = get_Const_tarval(c3); - tv4 = get_Const_tarval(c4); + if (!is_Or(or_l)) + return or; - tv = tarval_or(tv4, tv2); - if (classify_tarval(tv) != TV_CLASSIFY_ALL_ONE) { - /* have at least one 0 at the same bit position */ - return or; - } + get_comm_Binop_Ops(or_l, &and_l, &c3); + if (!is_Const(c3) || !is_And(and_l)) + return or; - n_tv4 = tarval_not(tv4); - if (tv3 != tarval_and(tv3, n_tv4)) { - /* bit in the or_mask is outside the and_mask */ - return or; - } + get_comm_Binop_Ops(and_l, &value, &c4); + if (!is_Const(c4)) + return or; - n_tv2 = tarval_not(tv2); - if (tv1 != tarval_and(tv1, n_tv2)) { - /* bit in the or_mask is outside the and_mask */ - return or; - } + /* ok, found the pattern, check for conditions */ + assert(mode == get_irn_mode(and)); + assert(mode == get_irn_mode(or_l)); + assert(mode == get_irn_mode(and_l)); + + tv3 = get_Const_tarval(c3); + tv4 = get_Const_tarval(c4); + + tv = tarval_or(tv4, tv2); + if (classify_tarval(tv) != TV_CLASSIFY_ALL_ONE) { + /* have at least one 0 at the same bit position */ + return or; + } + + n_tv4 = tarval_not(tv4); + if (tv3 != tarval_and(tv3, n_tv4)) { + /* bit in the or_mask is outside the and_mask */ + return or; + } - /* ok, all conditions met */ - block = get_irn_n(or, -1); + n_tv2 = tarval_not(tv2); + if (tv1 != tarval_and(tv1, n_tv2)) { + /* bit in the or_mask is outside the and_mask */ + return or; + } + + /* ok, all conditions met */ + block = get_irn_n(or, -1); - new_and = new_r_And(current_ir_graph, block, - value, new_r_Const(current_ir_graph, block, mode, tarval_and(tv4, tv2)), mode); + new_and = new_r_And(current_ir_graph, block, + value, new_r_Const(current_ir_graph, block, mode, tarval_and(tv4, tv2)), mode); - new_const = new_r_Const(current_ir_graph, block, mode, tarval_or(tv3, tv1)); + new_const = new_r_Const(current_ir_graph, block, mode, tarval_or(tv3, tv1)); - set_Or_left(or, new_and); - set_Or_right(or, new_const); + set_Or_left(or, new_and); + set_Or_right(or, new_const); - /* check for more */ - return transform_node_Or_bf_store(or); + /* check for more */ + } } /* transform_node_Or_bf_store */ /** @@ -3841,12 +3940,19 @@ static int node_cmp_attr_Load(ir_node *a, ir_node *b) { get_Load_volatility(b) == volatility_is_volatile) /* NEVER do CSE on volatile Loads */ return 1; + /* do not CSE Loads with different alignment. Be conservative. */ + if (get_Load_align(a) != get_Load_align(b)) + return 1; return get_Load_mode(a) != get_Load_mode(b); } /* node_cmp_attr_Load */ /** Compares the attributes of two Store nodes. */ static int node_cmp_attr_Store(ir_node *a, ir_node *b) { + /* do not CSE Stores with different alignment. Be conservative. */ + if (get_Store_align(a) != get_Store_align(b)) + return 1; + /* NEVER do CSE on volatile Stores */ return (get_Store_volatility(a) == volatility_is_volatile || get_Store_volatility(b) == volatility_is_volatile);