X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firopt.c;h=3469253225fe70bfe1f74f006920ea1183e1c4d4;hb=0e5195711161c7a5d6b841cb614c10f58b216fa8;hp=67da26ed796fb40ba4417bf4e833984a2130c0a6;hpb=d729c062320cea997eb464950d8e0e8205facefa;p=libfirm diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c index 67da26ed7..346925322 100644 --- a/ir/ir/iropt.c +++ b/ir/ir/iropt.c @@ -21,7 +21,6 @@ * @file * @brief iropt --- optimizations intertwined with IR construction. * @author Christian Schaefer, Goetz Lindenmaier, Michael Beck - * @version $Id$ */ #include "config.h" @@ -44,7 +43,6 @@ #include "irhooks.h" #include "irarch.h" #include "hashptr.h" -#include "opt_polymorphy.h" #include "irtools.h" #include "irhooks.h" #include "array_t.h" @@ -52,8 +50,8 @@ #include "firm_types.h" #include "bitfiddle.h" #include "be.h" +#include "error.h" -/* Make types visible to allow most efficient access */ #include "entity_t.h" static bool is_Or_Eor_Add(const ir_node *node) @@ -85,7 +83,6 @@ static ir_tarval *default_value_of(const ir_node *n) value_of_func value_of_ptr = default_value_of; -/* * Set a new value_of function. */ void set_value_of_func(value_of_func func) { if (func != NULL) @@ -588,6 +585,15 @@ ir_relation ir_get_possible_cmp_relations(const ir_node *left, /* Alloc nodes never return null (but throw an exception) */ if (is_Alloc(left) && tarval_is_null(tv_r)) possible &= ~ir_relation_equal; + /* stuff known through confirm nodes */ + if (is_Confirm(left) && get_Confirm_bound(left) == right) { + possible &= get_Confirm_relation(left); + } + if (is_Confirm(right) && get_Confirm_bound(right) == left) { + ir_relation relation = get_Confirm_relation(right); + relation = get_inversed_relation(relation); + possible &= relation; + } return possible; } @@ -609,6 +615,17 @@ static ir_tarval *compute_cmp(const ir_node *cmp) return computed_value_Cmp_Confirm(cmp, left, right, relation); } +/** + * some people want to call compute_cmp directly, in this case we have to + * test the constant folding flag again + */ +static ir_tarval *compute_cmp_ext(const ir_node *cmp) +{ + if (!get_opt_constant_folding()) + return tarval_bad; + return compute_cmp(cmp); +} + /** * Return the value of a Cmp. * @@ -618,7 +635,7 @@ static ir_tarval *compute_cmp(const ir_node *cmp) static ir_tarval *computed_value_Cmp(const ir_node *cmp) { /* we can't construct Constb after lowering mode_b nodes */ - if (is_irg_state(get_irn_irg(cmp), IR_GRAPH_STATE_MODEB_LOWERED)) + if (irg_is_constrained(get_irn_irg(cmp), IR_GRAPH_CONSTRAINT_MODEB_LOWERED)) return tarval_bad; return compute_cmp(cmp); @@ -720,60 +737,6 @@ ir_tarval *computed_value(const ir_node *n) return tarval_bad; } -/** - * Set the default computed_value evaluator in an ir_op_ops. - * - * @param code the opcode for the default operation - * @param ops the operations initialized - * - * @return - * The operations. - */ -static ir_op_ops *firm_set_default_computed_value(ir_opcode code, ir_op_ops *ops) -{ -#define CASE(a) \ - case iro_##a: \ - ops->computed_value = computed_value_##a; \ - break -#define CASE_PROJ(a) \ - case iro_##a: \ - ops->computed_value_Proj = computed_value_Proj_##a; \ - break - - switch (code) { - CASE(Add); - CASE(And); - CASE(Borrow); - CASE(Carry); - CASE(Cmp); - CASE(Confirm); - CASE(Const); - CASE(Conv); - CASE(Eor); - CASE(Minus); - CASE(Mul); - CASE(Mux); - CASE(Not); - CASE(Or); - CASE(Proj); - CASE(Rotl); - CASE(Shl); - CASE(Shr); - CASE(Shrs); - CASE(Sub); - CASE(SymConst); - CASE_PROJ(Div); - CASE_PROJ(Mod); - default: - /* leave NULL */ - break; - } - - return ops; -#undef CASE_PROJ -#undef CASE -} - /** * Optimize operations that are commutative and have neutral 0, * so a op 0 = 0 op a = a. @@ -937,11 +900,6 @@ static ir_node *equivalent_node_left_zero(ir_node *n) return n; } -#define equivalent_node_Shl equivalent_node_left_zero -#define equivalent_node_Shr equivalent_node_left_zero -#define equivalent_node_Shrs equivalent_node_left_zero -#define equivalent_node_Rotl equivalent_node_left_zero - /** * Optimize a - 0 and (a + x) - x (for modes with wrap-around). * @@ -989,26 +947,17 @@ static ir_node *equivalent_node_Sub(ir_node *n) * We handle it anyway here but the better way would be a * flag. This would be needed for Pascal for instance. */ -static ir_node *equivalent_node_idempotent_unop(ir_node *n) +static ir_node *equivalent_node_involution(ir_node *n) { ir_node *oldn = n; ir_node *pred = get_unop_op(n); - - /* optimize symmetric unop */ if (get_irn_op(pred) == get_irn_op(n)) { n = get_unop_op(pred); - DBG_OPT_ALGSIM2(oldn, pred, n, FS_OPT_IDEM_UNARY); + DBG_OPT_ALGSIM2(oldn, pred, n, FS_OPT_INVOLUTION); } return n; } -/** Optimize Not(Not(x)) == x. */ -#define equivalent_node_Not equivalent_node_idempotent_unop - -/** -(-x) == x ??? Is this possible or can --x raise an - out of bounds exception if min =! max? */ -#define equivalent_node_Minus equivalent_node_idempotent_unop - /** * Optimize a * 1 = 1 * a = a. */ @@ -1106,9 +1055,9 @@ static ir_node *equivalent_node_And(ir_node *n) /* Check Conv(all_one) & Const = all_one */ ir_tarval *one = get_mode_all_one(convopmode); ir_tarval *conv = tarval_convert_to(one, mode); - ir_tarval *and = tarval_and(conv, tv); + ir_tarval *tand = tarval_and(conv, tv); - if (tarval_is_all_one(and)) { + if (tarval_is_all_one(tand)) { /* Conv(X) & Const = X */ n = a; DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_AND); @@ -1151,121 +1100,18 @@ static ir_node *equivalent_node_Conv(ir_node *n) ir_mode *n_mode = get_irn_mode(n); ir_mode *a_mode = get_irn_mode(a); -restart: if (n_mode == a_mode) { /* No Conv necessary */ - if (get_Conv_strict(n)) { - ir_node *p = a; - - /* neither Minus nor Confirm change the precision, - so we can "look-through" */ - for (;;) { - if (is_Minus(p)) { - p = get_Minus_op(p); - } else if (is_Confirm(p)) { - p = get_Confirm_value(p); - } else { - /* stop here */ - break; - } - } - if (is_Conv(p) && get_Conv_strict(p)) { - /* we known already, that a_mode == n_mode, and neither - Minus change the mode, so the second Conv - can be kicked */ - assert(get_irn_mode(p) == n_mode); - n = a; - DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CONV); - return n; - } - if (is_Proj(p)) { - ir_node *pred = get_Proj_pred(p); - if (is_Load(pred)) { - /* Loads always return with the exact precision of n_mode */ - assert(get_Load_mode(pred) == n_mode); - n = a; - DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CONV); - return n; - } - if (is_Proj(pred) && get_Proj_proj(pred) == pn_Start_T_args) { - pred = get_Proj_pred(pred); - if (is_Start(pred)) { - /* Arguments always return with the exact precision, - as strictConv's are place before Call -- if the - caller was compiled with the same setting. - Otherwise, the semantics is probably still right. */ - assert(get_irn_mode(p) == n_mode); - n = a; - DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CONV); - return n; - } - } - } - if (is_Conv(a)) { - /* special case: the immediate predecessor is also a Conv */ - if (! get_Conv_strict(a)) { - /* first one is not strict, kick it */ - a = get_Conv_op(a); - a_mode = get_irn_mode(a); - set_Conv_op(n, a); - goto restart; - } - /* else both are strict conv, second is superfluous */ - n = a; - DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CONV); - return n; - } - } else { - n = a; - DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CONV); - return n; - } + n = a; + DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CONV); + return n; } else if (is_Conv(a)) { /* Conv(Conv(b)) */ ir_node *b = get_Conv_op(a); ir_mode *b_mode = get_irn_mode(b); - if (get_Conv_strict(n) && get_Conv_strict(a)) { - /* both are strict conv */ - if (smaller_mode(a_mode, n_mode)) { - /* both are strict, but the first is smaller, so - the second cannot remove more precision, remove the - strict bit */ - set_Conv_strict(n, 0); - } - } - if (n_mode == b_mode) { - if (! get_Conv_strict(n) && ! get_Conv_strict(a)) { - if (n_mode == mode_b) { - n = b; /* Convb(Conv*(xxxb(...))) == xxxb(...) */ - DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV); - return n; - } else if (get_mode_arithmetic(n_mode) == get_mode_arithmetic(a_mode)) { - if (values_in_mode(b_mode, a_mode)) { - n = b; /* ConvS(ConvL(xxxS(...))) == xxxS(...) */ - DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV); - return n; - } - } - } - if (mode_is_int(n_mode) && get_mode_arithmetic(a_mode) == irma_ieee754) { - /* ConvI(ConvF(I)) -> I, iff float mantissa >= int mode */ - unsigned int_mantissa = get_mode_size_bits(n_mode) - (mode_is_signed(n_mode) ? 1 : 0); - unsigned float_mantissa = get_mode_mantissa_size(a_mode); - - if (float_mantissa >= int_mantissa) { - n = b; - DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV); - return n; - } - } - if (is_Conv(b)) { - if (smaller_mode(b_mode, a_mode)) { - if (get_Conv_strict(n)) - set_Conv_strict(b, 1); - n = b; /* ConvA(ConvB(ConvA(...))) == ConvA(...) */ - DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV); - return n; - } - } + if (n_mode == b_mode && values_in_mode(b_mode, a_mode)) { + n = b; + DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV); + return n; } } return n; @@ -1283,7 +1129,7 @@ static ir_node *equivalent_node_Phi(ir_node *n) ir_node *first_val = NULL; /* to shutup gcc */ if (!get_opt_optimize() && - get_irg_phase_state(get_irn_irg(n)) != phase_building) + !irg_is_constrained(get_irn_irg(n), IR_GRAPH_CONSTRAINT_CONSTRUCTION)) return n; n_preds = get_Phi_n_preds(n); @@ -1477,7 +1323,7 @@ static ir_node *equivalent_node_Mux(ir_node *n) if (ts == tarval_bad && is_Cmp(sel)) { /* try again with a direct call to compute_cmp, as we don't care * about the MODEB_LOWERED flag here */ - ts = compute_cmp(sel); + ts = compute_cmp_ext(sel); } /* Mux(true, f, t) == t */ @@ -1608,59 +1454,6 @@ ir_node *equivalent_node(ir_node *n) return n; } -/** - * Sets the default equivalent node operation for an ir_op_ops. - * - * @param code the opcode for the default operation - * @param ops the operations initialized - * - * @return - * The operations. - */ -static ir_op_ops *firm_set_default_equivalent_node(ir_opcode code, ir_op_ops *ops) -{ -#define CASE(a) \ - case iro_##a: \ - ops->equivalent_node = equivalent_node_##a; \ - break -#define CASE_PROJ(a) \ - case iro_##a: \ - ops->equivalent_node_Proj = equivalent_node_Proj_##a; \ - break - - switch (code) { - CASE(Eor); - CASE(Add); - CASE(Shl); - CASE(Shr); - CASE(Shrs); - CASE(Rotl); - CASE(Sub); - CASE(Not); - CASE(Minus); - CASE(Mul); - CASE(Or); - CASE(And); - CASE(Conv); - CASE(Phi); - CASE_PROJ(Tuple); - CASE_PROJ(Div); - CASE_PROJ(CopyB); - CASE_PROJ(Bound); - CASE(Proj); - CASE(Id); - CASE(Mux); - CASE(Confirm); - default: - /* leave NULL */ - break; - } - - return ops; -#undef CASE -#undef CASE_PROJ -} - /** * Returns non-zero if a node is a Phi node * with all predecessors constant. @@ -1716,44 +1509,40 @@ static ir_tarval *do_eval(eval_func eval, ir_tarval *a, ir_tarval *b, ir_mode *m */ static ir_node *apply_binop_on_phi(ir_node *phi, ir_tarval *other, eval_func eval, ir_mode *mode, int left) { - ir_tarval *tv; - void **res; - ir_node *pred; - ir_graph *irg; - int i, n = get_irn_arity(phi); - - NEW_ARR_A(void *, res, n); + int n = get_irn_arity(phi); + ir_tarval **tvs = ALLOCAN(ir_tarval*, n); if (left) { - for (i = 0; i < n; ++i) { - pred = get_irn_n(phi, i); - tv = get_Const_tarval(pred); - tv = do_eval(eval, other, tv, mode); + for (int i = 0; i < n; ++i) { + ir_node *pred = get_irn_n(phi, i); + ir_tarval *tv = get_Const_tarval(pred); + tv = do_eval(eval, other, tv, mode); if (tv == tarval_bad) { /* folding failed, bad */ return NULL; } - res[i] = tv; + tvs[i] = tv; } } else { - for (i = 0; i < n; ++i) { - pred = get_irn_n(phi, i); - tv = get_Const_tarval(pred); - tv = do_eval(eval, tv, other, mode); + for (int i = 0; i < n; ++i) { + ir_node *pred = get_irn_n(phi, i); + ir_tarval *tv = get_Const_tarval(pred); + tv = do_eval(eval, tv, other, mode); if (tv == tarval_bad) { /* folding failed, bad */ return 0; } - res[i] = tv; + tvs[i] = tv; } } - irg = get_irn_irg(phi); - for (i = 0; i < n; ++i) { - pred = get_irn_n(phi, i); - res[i] = new_r_Const(irg, (ir_tarval*)res[i]); + ir_graph *irg = get_irn_irg(phi); + ir_node **res = ALLOCAN(ir_node*, n); + for (int i = 0; i < n; ++i) { + res[i] = new_r_Const(irg, tvs[i]); } - return new_r_Phi(get_nodes_block(phi), n, (ir_node **)res, mode); + ir_node *block = get_nodes_block(phi); + return new_r_Phi(block, n, res, mode); } /** @@ -1768,37 +1557,31 @@ static ir_node *apply_binop_on_phi(ir_node *phi, ir_tarval *other, eval_func eva */ static ir_node *apply_binop_on_2_phis(ir_node *a, ir_node *b, eval_func eval, ir_mode *mode) { - ir_tarval *tv_l, *tv_r, *tv; - void **res; - ir_node *pred; - ir_graph *irg; - int i, n; - if (get_nodes_block(a) != get_nodes_block(b)) return NULL; - n = get_irn_arity(a); - NEW_ARR_A(void *, res, n); - - for (i = 0; i < n; ++i) { - pred = get_irn_n(a, i); - tv_l = get_Const_tarval(pred); - pred = get_irn_n(b, i); - tv_r = get_Const_tarval(pred); - tv = do_eval(eval, tv_l, tv_r, mode); + int n = get_irn_arity(a); + ir_tarval **tvs = ALLOCAN(ir_tarval*, n); + for (int i = 0; i < n; ++i) { + ir_node *pred_a = get_irn_n(a, i); + ir_tarval *tv_l = get_Const_tarval(pred_a); + ir_node *pred_b = get_irn_n(b, i); + ir_tarval *tv_r = get_Const_tarval(pred_b); + ir_tarval *tv = do_eval(eval, tv_l, tv_r, mode); if (tv == tarval_bad) { /* folding failed, bad */ return NULL; } - res[i] = tv; + tvs[i] = tv; } - irg = get_irn_irg(a); - for (i = 0; i < n; ++i) { - pred = get_irn_n(a, i); - res[i] = new_r_Const(irg, (ir_tarval*)res[i]); + ir_graph *irg = get_irn_irg(a); + ir_node **res = ALLOCAN(ir_node*, n); + for (int i = 0; i < n; ++i) { + res[i] = new_r_Const(irg, tvs[i]); } - return new_r_Phi(get_nodes_block(a), n, (ir_node **)res, mode); + ir_node *block = get_nodes_block(a); + return new_r_Phi(block, n, res, mode); } /** @@ -1811,32 +1594,27 @@ static ir_node *apply_binop_on_2_phis(ir_node *a, ir_node *b, eval_func eval, ir */ static ir_node *apply_unop_on_phi(ir_node *phi, ir_tarval *(*eval)(ir_tarval *)) { - ir_tarval *tv; - void **res; - ir_node *pred; - ir_mode *mode; - ir_graph *irg; - int i, n = get_irn_arity(phi); - - NEW_ARR_A(void *, res, n); - for (i = 0; i < n; ++i) { - pred = get_irn_n(phi, i); - tv = get_Const_tarval(pred); - tv = eval(tv); + int n = get_irn_arity(phi); + ir_tarval **tvs = ALLOCAN(ir_tarval*, n); + for (int i = 0; i < n; ++i) { + ir_node *pred = get_irn_n(phi, i); + ir_tarval *tv = get_Const_tarval(pred); + tv = eval(tv); if (tv == tarval_bad) { /* folding failed, bad */ return 0; } - res[i] = tv; + tvs[i] = tv; } - mode = get_irn_mode(phi); - irg = get_irn_irg(phi); - for (i = 0; i < n; ++i) { - pred = get_irn_n(phi, i); - res[i] = new_r_Const(irg, (ir_tarval*)res[i]); + ir_graph *irg = get_irn_irg(phi); + ir_node **res = ALLOCAN(ir_node*, n); + for (int i = 0; i < n; ++i) { + res[i] = new_r_Const(irg, tvs[i]); } - return new_r_Phi(get_nodes_block(phi), n, (ir_node **)res, mode); + ir_node *block = get_nodes_block(phi); + ir_mode *mode = get_irn_mode(phi); + return new_r_Phi(block, n, res, mode); } /** @@ -1848,30 +1626,26 @@ static ir_node *apply_unop_on_phi(ir_node *phi, ir_tarval *(*eval)(ir_tarval *)) */ static ir_node *apply_conv_on_phi(ir_node *phi, ir_mode *mode) { - ir_tarval *tv; - void **res; - ir_node *pred; - ir_graph *irg; - int i, n = get_irn_arity(phi); - - NEW_ARR_A(void *, res, n); - for (i = 0; i < n; ++i) { - pred = get_irn_n(phi, i); - tv = get_Const_tarval(pred); - tv = tarval_convert_to(tv, mode); + int n = get_irn_arity(phi); + ir_tarval **tvs = ALLOCAN(ir_tarval*, n); + for (int i = 0; i < n; ++i) { + ir_node *pred = get_irn_n(phi, i); + ir_tarval *tv = get_Const_tarval(pred); + tv = tarval_convert_to(tv, mode); if (tv == tarval_bad) { /* folding failed, bad */ return 0; } - res[i] = tv; + tvs[i] = tv; } - irg = get_irn_irg(phi); - for (i = 0; i < n; ++i) { - pred = get_irn_n(phi, i); - res[i] = new_r_Const(irg, (ir_tarval*)res[i]); + ir_graph *irg = get_irn_irg(phi); + ir_node **res = ALLOCAN(ir_node*, n); + for (int i = 0; i < n; ++i) { + res[i] = new_r_Const(irg, tvs[i]); } - return new_r_Phi(get_nodes_block(phi), n, (ir_node **)res, mode); + ir_node *block = get_nodes_block(phi); + return new_r_Phi(block, n, res, mode); } /** @@ -2149,7 +1923,7 @@ static ir_node *transform_node_Or_bf_store(ir_node *irn_or) } /* ok, all conditions met */ - block = get_irn_n(irn_or, -1); + block = get_nodes_block(irn_or); irg = get_irn_irg(block); new_and = new_r_And(block, value, new_r_Const(irg, tarval_and(tv4, tv2)), mode); @@ -2375,7 +2149,7 @@ static ir_node *transform_node_bitop_shift(ir_node *n) ir_tarval *tv2; ir_tarval *tv_bitop; - if (!is_irg_state(irg, IR_GRAPH_STATE_NORMALISATION2)) + if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_NORMALISATION2)) return n; assert(is_And(n) || is_Or(n) || is_Eor(n) || is_Or_Eor_Add(n)); @@ -2565,9 +2339,9 @@ static ir_node *transform_node_Or_(ir_node *n) ir_node *xora = new_rd_Eor(dbgi, block, a_left, a_right, a_mode); ir_node *xorb = new_rd_Eor(dbgi, block, b_left, b_right, b_mode); ir_node *conv = new_rd_Conv(dbgi, block, xora, b_mode); - ir_node *or = new_rd_Or(dbgi, block, conv, xorb, b_mode); + ir_node *orn = new_rd_Or(dbgi, block, conv, xorb, b_mode); ir_node *zero = create_zero_const(irg, b_mode); - return new_rd_Cmp(dbgi, block, or, zero, ir_relation_less_greater); + return new_rd_Cmp(dbgi, block, orn, zero, ir_relation_less_greater); } if (values_in_mode(get_irn_mode(b_left), get_irn_mode(a_left))) { ir_graph *irg = get_irn_irg(n); @@ -2578,9 +2352,9 @@ static ir_node *transform_node_Or_(ir_node *n) ir_node *xora = new_rd_Eor(dbgi, block, a_left, a_right, a_mode); ir_node *xorb = new_rd_Eor(dbgi, block, b_left, b_right, b_mode); ir_node *conv = new_rd_Conv(dbgi, block, xorb, a_mode); - ir_node *or = new_rd_Or(dbgi, block, xora, conv, a_mode); + ir_node *orn = new_rd_Or(dbgi, block, xora, conv, a_mode); ir_node *zero = create_zero_const(irg, a_mode); - return new_rd_Cmp(dbgi, block, or, zero, ir_relation_less_greater); + return new_rd_Cmp(dbgi, block, orn, zero, ir_relation_less_greater); } } } @@ -2768,7 +2542,7 @@ static ir_node *transform_node_Add(ir_node *n) ir_graph *irg = get_irn_irg(n); /* the following code leads to endless recursion when Mul are replaced * by a simple instruction chain */ - if (!is_irg_state(irg, IR_GRAPH_STATE_ARCH_DEP) + if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_ARCH_DEP) && a == b && mode_is_int(mode)) { ir_node *block = get_nodes_block(n); @@ -3157,8 +2931,8 @@ restart: ir_node *block = get_nodes_block(n); ir_mode *mode = get_irn_mode(n); ir_node *notn = new_rd_Not(dbgi, block, and_right, mode); - ir_node *and = new_rd_And(dbgi, block, a, notn, mode); - return and; + ir_node *andn = new_rd_And(dbgi, block, a, notn, mode); + return andn; } } } @@ -3195,7 +2969,7 @@ static ir_node *transform_node_Mul2n(ir_node *n, ir_mode *mode) } if (tb == get_mode_one(smode)) { /* (L)a * (L)1 = (L)a */ - ir_node *blk = get_irn_n(a, -1); + ir_node *blk = get_nodes_block(a); n = new_rd_Conv(get_irn_dbg_info(n), blk, a, mode); DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_1); return n; @@ -3556,7 +3330,7 @@ static ir_node *transform_node_Cond(ir_node *n) if (ta == tarval_bad && is_Cmp(a)) { /* try again with a direct call to compute_cmp, as we don't care * about the MODEB_LOWERED flag here */ - ta = compute_cmp(a); + ta = compute_cmp_ext(a); } if (ta != tarval_bad && get_irn_mode(a) == mode_b) { @@ -3572,9 +3346,7 @@ static ir_node *transform_node_Cond(ir_node *n) set_Tuple_pred(n, pn_Cond_false, jmp); set_Tuple_pred(n, pn_Cond_true, new_r_Bad(irg, mode_X)); } - /* We might generate an endless loop, so keep it alive. */ - add_End_keepalive(get_irg_end(irg), blk); - clear_irg_state(irg, IR_GRAPH_STATE_NO_UNREACHABLE_CODE); + clear_irg_properties(irg, IR_GRAPH_PROPERTY_NO_UNREACHABLE_CODE); } return n; } @@ -3648,7 +3420,7 @@ static ir_node *transform_node_shift_bitop(ir_node *n) ir_tarval *tv2; ir_tarval *tv_shift; - if (is_irg_state(irg, IR_GRAPH_STATE_NORMALISATION2)) + if (irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_NORMALISATION2)) return n; assert(is_Shrs(n) || is_Shr(n) || is_Shl(n) || is_Rotl(n)); @@ -3752,10 +3524,10 @@ static ir_node *transform_node_And(ir_node *n) ir_node *xora = new_rd_Eor(dbgi, block, a_left, a_right, a_mode); ir_node *xorb = new_rd_Eor(dbgi, block, b_left, b_right, b_mode); ir_node *conv = new_rd_Conv(dbgi, block, xora, b_mode); - ir_node *or = new_rd_Or(dbgi, block, conv, xorb, b_mode); + ir_node *orn = new_rd_Or(dbgi, block, conv, xorb, b_mode); ir_graph *irg = get_irn_irg(n); ir_node *zero = create_zero_const(irg, b_mode); - return new_rd_Cmp(dbgi, block, or, zero, ir_relation_equal); + return new_rd_Cmp(dbgi, block, orn, zero, ir_relation_equal); } if (values_in_mode(get_irn_mode(b_left), get_irn_mode(a_left))) { dbg_info *dbgi = get_irn_dbg_info(n); @@ -3765,10 +3537,10 @@ static ir_node *transform_node_And(ir_node *n) ir_node *xora = new_rd_Eor(dbgi, block, a_left, a_right, a_mode); ir_node *xorb = new_rd_Eor(dbgi, block, b_left, b_right, b_mode); ir_node *conv = new_rd_Conv(dbgi, block, xorb, a_mode); - ir_node *or = new_rd_Or(dbgi, block, xora, conv, a_mode); + ir_node *orn = new_rd_Or(dbgi, block, xora, conv, a_mode); ir_graph *irg = get_irn_irg(n); ir_node *zero = create_zero_const(irg, a_mode); - return new_rd_Cmp(dbgi, block, or, zero, ir_relation_equal); + return new_rd_Cmp(dbgi, block, orn, zero, ir_relation_equal); } } } @@ -4080,27 +3852,25 @@ static ir_node *transform_node_Minus(ir_node *n) */ static ir_node *transform_node_Proj_Load(ir_node *proj) { - if (get_opt_ldst_only_null_ptr_exceptions()) { - if (get_irn_mode(proj) == mode_X) { - ir_node *load = get_Proj_pred(proj); + if (get_irn_mode(proj) == mode_X) { + ir_node *load = get_Proj_pred(proj); - /* get the Load address */ - const ir_node *addr = get_Load_ptr(load); - const ir_node *confirm; + /* get the Load address */ + const ir_node *addr = get_Load_ptr(load); + const ir_node *confirm; - if (value_not_null(addr, &confirm)) { - if (confirm == NULL) { - /* this node may float if it did not depend on a Confirm */ - set_irn_pinned(load, op_pin_state_floats); - } - if (get_Proj_proj(proj) == pn_Load_X_except) { - ir_graph *irg = get_irn_irg(proj); - DBG_OPT_EXC_REM(proj); - return new_r_Bad(irg, mode_X); - } else { - ir_node *blk = get_nodes_block(load); - return new_r_Jmp(blk); - } + if (value_not_null(addr, &confirm)) { + if (confirm == NULL) { + /* this node may float if it did not depend on a Confirm */ + set_irn_pinned(load, op_pin_state_floats); + } + if (get_Proj_proj(proj) == pn_Load_X_except) { + ir_graph *irg = get_irn_irg(proj); + DBG_OPT_EXC_REM(proj); + return new_r_Bad(irg, mode_X); + } else { + ir_node *blk = get_nodes_block(load); + return new_r_Jmp(blk); } } } @@ -4112,27 +3882,25 @@ static ir_node *transform_node_Proj_Load(ir_node *proj) */ static ir_node *transform_node_Proj_Store(ir_node *proj) { - if (get_opt_ldst_only_null_ptr_exceptions()) { - if (get_irn_mode(proj) == mode_X) { - ir_node *store = get_Proj_pred(proj); + if (get_irn_mode(proj) == mode_X) { + ir_node *store = get_Proj_pred(proj); - /* get the load/store address */ - const ir_node *addr = get_Store_ptr(store); - const ir_node *confirm; + /* get the load/store address */ + const ir_node *addr = get_Store_ptr(store); + const ir_node *confirm; - if (value_not_null(addr, &confirm)) { - if (confirm == NULL) { - /* this node may float if it did not depend on a Confirm */ - set_irn_pinned(store, op_pin_state_floats); - } - if (get_Proj_proj(proj) == pn_Store_X_except) { - ir_graph *irg = get_irn_irg(proj); - DBG_OPT_EXC_REM(proj); - return new_r_Bad(irg, mode_X); - } else { - ir_node *blk = get_nodes_block(store); - return new_r_Jmp(blk); - } + if (value_not_null(addr, &confirm)) { + if (confirm == NULL) { + /* this node may float if it did not depend on a Confirm */ + set_irn_pinned(store, op_pin_state_floats); + } + if (get_Proj_proj(proj) == pn_Store_X_except) { + ir_graph *irg = get_irn_irg(proj); + DBG_OPT_EXC_REM(proj); + return new_r_Bad(irg, mode_X); + } else { + ir_node *blk = get_nodes_block(store); + return new_r_Jmp(blk); } } } @@ -4219,7 +3987,7 @@ static ir_node *transform_node_Proj_Mod(ir_node *proj) switch (proj_nr) { case pn_Mod_X_regular: - return new_r_Jmp(get_irn_n(mod, -1)); + return new_r_Jmp(get_nodes_block(mod)); case pn_Mod_X_except: { ir_graph *irg = get_irn_irg(proj); @@ -4320,53 +4088,56 @@ static ir_node *transform_node_Cmp(ir_node *n) } /* Remove unnecessary conversions */ - if (is_Conv(left) && is_Conv(right)) { - ir_node *op_left = get_Conv_op(left); - ir_node *op_right = get_Conv_op(right); - ir_mode *mode_left = get_irn_mode(op_left); - ir_mode *mode_right = get_irn_mode(op_right); - - if (smaller_mode(mode_left, mode) && smaller_mode(mode_right, mode) - && mode_left != mode_b && mode_right != mode_b) { - ir_node *block = get_nodes_block(n); - - if (mode_left == mode_right) { - left = op_left; - right = op_right; - changed = true; - DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV_CONV); - } else if (smaller_mode(mode_left, mode_right)) { - left = new_r_Conv(block, op_left, mode_right); - right = op_right; - changed = true; - DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV); - } else if (smaller_mode(mode_right, mode_left)) { - left = op_left; - right = new_r_Conv(block, op_right, mode_left); - changed = true; - DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV); + if (!mode_is_float(mode) + || be_get_backend_param()->mode_float_arithmetic == NULL) { + if (is_Conv(left) && is_Conv(right)) { + ir_node *op_left = get_Conv_op(left); + ir_node *op_right = get_Conv_op(right); + ir_mode *mode_left = get_irn_mode(op_left); + ir_mode *mode_right = get_irn_mode(op_right); + + if (smaller_mode(mode_left, mode) && smaller_mode(mode_right, mode) + && mode_left != mode_b && mode_right != mode_b) { + ir_node *block = get_nodes_block(n); + + if (mode_left == mode_right) { + left = op_left; + right = op_right; + changed = true; + DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV_CONV); + } else if (smaller_mode(mode_left, mode_right)) { + left = new_r_Conv(block, op_left, mode_right); + right = op_right; + changed = true; + DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV); + } else if (smaller_mode(mode_right, mode_left)) { + left = op_left; + right = new_r_Conv(block, op_right, mode_left); + changed = true; + DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV); + } + mode = get_irn_mode(left); } - mode = get_irn_mode(left); - } - } - if (is_Conv(left) && is_Const(right)) { - ir_node *op_left = get_Conv_op(left); - ir_mode *mode_left = get_irn_mode(op_left); - if (smaller_mode(mode_left, mode) && mode_left != mode_b) { - ir_tarval *tv = get_Const_tarval(right); - tarval_int_overflow_mode_t last_mode - = tarval_get_integer_overflow_mode(); - ir_tarval *new_tv; - tarval_set_integer_overflow_mode(TV_OVERFLOW_BAD); - new_tv = tarval_convert_to(tv, mode_left); - tarval_set_integer_overflow_mode(last_mode); - if (new_tv != tarval_bad) { - ir_graph *irg = get_irn_irg(n); - left = op_left; - right = new_r_Const(irg, new_tv); - mode = get_irn_mode(left); - changed = true; - DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV); + } + if (is_Conv(left) && is_Const(right)) { + ir_node *op_left = get_Conv_op(left); + ir_mode *mode_left = get_irn_mode(op_left); + if (smaller_mode(mode_left, mode) && mode_left != mode_b) { + ir_tarval *tv = get_Const_tarval(right); + tarval_int_overflow_mode_t last_mode + = tarval_get_integer_overflow_mode(); + ir_tarval *new_tv; + tarval_set_integer_overflow_mode(TV_OVERFLOW_BAD); + new_tv = tarval_convert_to(tv, mode_left); + tarval_set_integer_overflow_mode(last_mode); + if (new_tv != tarval_bad) { + ir_graph *irg = get_irn_irg(n); + left = op_left; + right = new_r_Const(irg, new_tv); + mode = get_irn_mode(left); + changed = true; + DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV); + } } } } @@ -5012,7 +4783,7 @@ is_bittest: { if (tarval_is_single_bit(tv)) { /* special case: (x % 2^n) CMP 0 ==> x & (2^n-1) CMP 0 */ ir_node *v = get_binop_left(op); - ir_node *blk = get_irn_n(op, -1); + ir_node *blk = get_nodes_block(op); ir_graph *irg = get_irn_irg(op); ir_mode *mode = get_irn_mode(v); @@ -5138,7 +4909,7 @@ static ir_node *transform_node_Proj(ir_node *proj) /** * Test whether a block is unreachable * Note: That this only returns true when - * IR_GRAPH_STATE_OPTIMIZE_UNREACHABLE_CODE is set. + * IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE is set. * This is important, as you easily end up producing invalid constructs in the * unreachable code when optimizing away edges into the unreachable code. * So only set this flag when you iterate localopts to the fixpoint. @@ -5149,7 +4920,7 @@ static ir_node *transform_node_Proj(ir_node *proj) static bool is_block_unreachable(const ir_node *block) { const ir_graph *irg = get_irn_irg(block); - if (!is_irg_state(irg, IR_GRAPH_STATE_OPTIMIZE_UNREACHABLE_CODE)) + if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE)) return false; return get_Block_dom_depth(block) < 0; } @@ -5161,7 +4932,7 @@ static ir_node *transform_node_Block(ir_node *block) ir_node *bad = NULL; int i; - if (!is_irg_state(irg, IR_GRAPH_STATE_OPTIMIZE_UNREACHABLE_CODE)) + if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE)) return block; for (i = 0; i < arity; ++i) { @@ -5226,7 +4997,6 @@ static ir_node *transform_node_Phi(ir_node *phi) return phi; /* Move the Pin nodes "behind" the Phi. */ - block = get_irn_n(phi, -1); new_phi = new_r_Phi(block, n, in, mode_M); return new_r_Pin(block, new_phi); } @@ -5238,7 +5008,7 @@ static ir_node *transform_node_Phi(ir_node *phi) /* Beware of Phi0 */ if (n > 0) { ir_node *pred = get_irn_n(phi, 0); - ir_node *bound, *new_phi, *block, **in; + ir_node *bound, *new_phi, **in; ir_relation relation; bool has_confirm = false; @@ -5270,7 +5040,6 @@ static ir_node *transform_node_Phi(ir_node *phi) return phi; /* move the Confirm nodes "behind" the Phi */ - block = get_irn_n(phi, -1); new_phi = new_r_Phi(block, n, in, get_irn_mode(phi)); return new_r_Confirm(block, new_phi, bound, relation); } @@ -5278,9 +5047,6 @@ static ir_node *transform_node_Phi(ir_node *phi) return phi; } -/* forward */ -static ir_node *transform_node(ir_node *n); - /** * Optimize (a >> c1) >> c2), works for Shr, Shrs, Shl, Rotl. * @@ -5369,7 +5135,7 @@ static ir_node *transform_node_shift(ir_node *n) DBG_OPT_ALGSIM0(n, irn, FS_OPT_REASSOC_SHIFT); - return transform_node(irn); + return irn; } /** @@ -5675,6 +5441,77 @@ static ir_node *transform_node_Rotl(ir_node *n) return n; } +/** + * returns mode size for may_leave_out_middle_mode + */ +static unsigned get_significand_size(ir_mode *mode) +{ + const ir_mode_arithmetic arithmetic = get_mode_arithmetic(mode); + switch (arithmetic) { + case irma_ieee754: + case irma_x86_extended_float: + return get_mode_mantissa_size(mode) + 1; + case irma_twos_complement: + return get_mode_size_bits(mode); + case irma_none: + panic("Conv node with irma_none mode?"); + } + panic("unexpected mode_arithmetic in get_significand_size"); +} + +/** + * Returns true if a conversion from mode @p m0 to @p m1 has the same effect + * as converting from @p m0 to @p m1 and then to @p m2. + * Classifying the 3 modes as the big(b), middle(m) and small(s) mode this + * gives the following truth table: + * s -> b -> m : true + * s -> m -> b : !signed(s) || signed(m) + * m -> b -> s : true + * m -> s -> b : false + * b -> s -> m : false + * b -> m -> s : true + * + * s -> b -> b : true + * s -> s -> b : false + * + * additional float constraints: + * F -> F -> F: fine + * F -> I -> I: signedness of Is must match + * I -> F -> I: signedness of Is must match + * I -> I -> F: signedness of Is must match + * F -> I -> F: bad + * I -> F -> F: fine + * F -> F -> I: fine + * at least 1 float involved: signedness must match + */ +bool may_leave_out_middle_conv(ir_mode *m0, ir_mode *m1, ir_mode *m2) +{ + int n_floats = mode_is_float(m0) + mode_is_float(m1) + mode_is_float(m2); + if (n_floats == 1) { +#if 0 + int n_signed = mode_is_signed(m0) + mode_is_signed(m1) + + mode_is_signed(m2); + /* we assume that float modes are always signed */ + if ((n_signed & 1) != 1) + return false; +#else + /* because overflow gives strange results we don't touch this case */ + return false; +#endif + } else if (n_floats == 2 && !mode_is_float(m1)) { + return false; + } + + unsigned size0 = get_significand_size(m0); + unsigned size1 = get_significand_size(m1); + unsigned size2 = get_significand_size(m2); + if (size1 < size2 && size0 >= size1) + return false; + if (size1 >= size2) + return true; + return !mode_is_signed(m0) || mode_is_signed(m1); +} + /** * Transform a Conv. */ @@ -5684,6 +5521,17 @@ static ir_node *transform_node_Conv(ir_node *n) ir_mode *mode = get_irn_mode(n); ir_node *a = get_Conv_op(n); + if (is_Conv(a)) { + ir_mode *a_mode = get_irn_mode(a); + ir_node *b = get_Conv_op(a); + ir_mode *b_mode = get_irn_mode(b); + if (may_leave_out_middle_conv(b_mode, a_mode, mode)) { + dbg_info *dbgi = get_irn_dbg_info(n); + ir_node *block = get_nodes_block(n); + return new_rd_Conv(dbgi, block, b, mode); + } + } + if (mode != mode_b && is_const_Phi(a)) { /* Do NOT optimize mode_b Conv's, this leads to remaining * Phib nodes later, because the conv_b_lower operation @@ -5919,10 +5767,13 @@ static ir_node *transform_Mux_set(ir_node *n) if (!mode_is_int(mode) && !mode_is_reference(mode)) return n; dest_mode = get_irn_mode(n); + if (!mode_is_int(dest_mode) && !mode_is_reference(dest_mode)) + return n; right = get_Cmp_right(cond); relation = get_Cmp_relation(cond) & ~ir_relation_unordered; if (get_mode_size_bits(mode) >= get_mode_size_bits(dest_mode) - && (!mode_is_signed(mode) || !is_Const(right) || !is_Const_null(right))) + && !(mode_is_signed(mode) && is_Const(right) && is_Const_null(right) + && relation != ir_relation_greater)) return n; need_not = false; @@ -6021,7 +5872,7 @@ static ir_node *transform_node_Mux(ir_node *n) relation = get_negated_relation(relation); sel = new_rd_Cmp(seldbgi, block, get_Cmp_left(sel), get_Cmp_right(sel), relation); - n = new_rd_Mux(get_irn_dbg_info(n), get_nodes_block(n), sel, f, t, mode); + return new_rd_Mux(get_irn_dbg_info(n), get_nodes_block(n), sel, f, t, mode); } if (is_Const(f) && is_Const_null(f) && is_Const(t) && is_Const_one(t)) { @@ -6032,7 +5883,7 @@ static ir_node *transform_node_Mux(ir_node *n) /* the following optimisations create new mode_b nodes, so only do them * before mode_b lowering */ - if (!is_irg_state(irg, IR_GRAPH_STATE_MODEB_LOWERED)) { + if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_MODEB_LOWERED)) { if (is_Mux(t)) { ir_node* block = get_nodes_block(n); ir_node* c0 = sel; @@ -6041,23 +5892,15 @@ static ir_node *transform_node_Mux(ir_node *n) ir_node* f1 = get_Mux_false(t); if (f == f1) { /* Mux(cond0, Mux(cond1, x, y), y) => Mux(cond0 && cond1, x, y) */ - ir_node* and_ = new_r_And(block, c0, c1, mode_b); - ir_node* new_mux = new_r_Mux(block, and_, f1, t1, mode); - n = new_mux; - sel = and_; - f = f1; - t = t1; - DBG_OPT_ALGSIM0(oldn, t, FS_OPT_MUX_COMBINE); + ir_node* and_ = new_r_And(block, c0, c1, mode_b); + DBG_OPT_ALGSIM0(oldn, t1, FS_OPT_MUX_COMBINE); + return new_r_Mux(block, and_, f1, t1, mode); } else if (f == t1) { /* Mux(cond0, Mux(cond1, x, y), x) */ ir_node* not_c1 = new_r_Not(block, c1, mode_b); ir_node* and_ = new_r_And(block, c0, not_c1, mode_b); - ir_node* new_mux = new_r_Mux(block, and_, t1, f1, mode); - n = new_mux; - sel = and_; - f = t1; - t = f1; - DBG_OPT_ALGSIM0(oldn, t, FS_OPT_MUX_COMBINE); + DBG_OPT_ALGSIM0(oldn, f1, FS_OPT_MUX_COMBINE); + return new_r_Mux(block, and_, t1, f1, mode); } } else if (is_Mux(f)) { ir_node* block = get_nodes_block(n); @@ -6067,23 +5910,15 @@ static ir_node *transform_node_Mux(ir_node *n) ir_node* f1 = get_Mux_false(f); if (t == t1) { /* Mux(cond0, x, Mux(cond1, x, y)) -> typical if (cond0 || cond1) x else y */ - ir_node* or_ = new_r_Or(block, c0, c1, mode_b); - ir_node* new_mux = new_r_Mux(block, or_, f1, t1, mode); - n = new_mux; - sel = or_; - f = f1; - t = t1; - DBG_OPT_ALGSIM0(oldn, f, FS_OPT_MUX_COMBINE); + ir_node* or_ = new_r_Or(block, c0, c1, mode_b); + DBG_OPT_ALGSIM0(oldn, f1, FS_OPT_MUX_COMBINE); + return new_r_Mux(block, or_, f1, t1, mode); } else if (t == f1) { /* Mux(cond0, x, Mux(cond1, y, x)) */ ir_node* not_c1 = new_r_Not(block, c1, mode_b); ir_node* or_ = new_r_Or(block, c0, not_c1, mode_b); - ir_node* new_mux = new_r_Mux(block, or_, t1, f1, mode); - n = new_mux; - sel = or_; - f = t1; - t = f1; - DBG_OPT_ALGSIM0(oldn, f, FS_OPT_MUX_COMBINE); + DBG_OPT_ALGSIM0(oldn, t1, FS_OPT_MUX_COMBINE); + return new_r_Mux(block, or_, t1, f1, mode); } } @@ -6220,7 +6055,8 @@ static ir_node *transform_node_Sync(ir_node *n) ++arity; break; } - if (get_Sync_pred(n, k) == pred_pred) break; + if (get_Sync_pred(n, k) == pred_pred) + break; } } } @@ -6238,66 +6074,87 @@ static ir_node *transform_node_Sync(ir_node *n) return n; } +static ir_node *create_load_replacement_tuple(ir_node *n, ir_node *mem, + ir_node *res) +{ + ir_node *block = get_nodes_block(n); + ir_graph *irg = get_irn_irg(n); + ir_node *in[pn_Load_max+1]; + size_t n_in = 2; + in[pn_Load_M] = mem; + in[pn_Load_res] = res; + if (ir_throws_exception(n)) { + in[pn_Load_X_regular] = new_r_Jmp(block); + in[pn_Load_X_except] = new_r_Bad(irg, mode_X); + n_in = 4; + assert(pn_Load_max == 4); + } + ir_node *tuple = new_r_Tuple(block, n_in, in); + return tuple; +} + static ir_node *transform_node_Load(ir_node *n) { + /* don't touch volatile loads */ + if (get_Load_volatility(n) == volatility_is_volatile) + return n; + + ir_node *ptr = get_Load_ptr(n); + const ir_node *confirm; + if (value_not_zero(ptr, &confirm) && confirm == NULL) { + set_irn_pinned(n, op_pin_state_floats); + } + /* if our memory predecessor is a load from the same address, then reuse the * previous result */ ir_node *mem = get_Load_mem(n); - ir_node *mem_pred; - if (!is_Proj(mem)) return n; - /* don't touch volatile loads */ - if (get_Load_volatility(n) == volatility_is_volatile) - return n; - mem_pred = get_Proj_pred(mem); + ir_node *mem_pred = get_Proj_pred(mem); if (is_Load(mem_pred)) { ir_node *pred_load = mem_pred; /* conservatively compare the 2 loads. TODO: This could be less strict * with fixup code in some situations (like smaller/bigger modes) */ - if (get_Load_ptr(pred_load) != get_Load_ptr(n)) + if (get_Load_ptr(pred_load) != ptr) return n; if (get_Load_mode(pred_load) != get_Load_mode(n)) return n; /* all combinations of aligned/unaligned pred/n should be fine so we do * not compare the unaligned attribute */ - { - ir_node *block = get_nodes_block(n); - ir_node *jmp = new_r_Jmp(block); - ir_graph *irg = get_irn_irg(n); - ir_node *bad = new_r_Bad(irg, mode_X); - ir_mode *mode = get_Load_mode(n); - ir_node *res = new_r_Proj(pred_load, mode, pn_Load_res); - ir_node *in[] = { mem, res, jmp, bad }; - ir_node *tuple = new_r_Tuple(block, ARRAY_SIZE(in), in); - return tuple; - } + ir_mode *mode = get_Load_mode(n); + ir_node *res = new_r_Proj(pred_load, mode, pn_Load_res); + return create_load_replacement_tuple(n, mem, res); } else if (is_Store(mem_pred)) { ir_node *pred_store = mem_pred; ir_node *value = get_Store_value(pred_store); - if (get_Store_ptr(pred_store) != get_Load_ptr(n)) + if (get_Store_ptr(pred_store) != ptr) return n; if (get_irn_mode(value) != get_Load_mode(n)) return n; /* all combinations of aligned/unaligned pred/n should be fine so we do * not compare the unaligned attribute */ - { - ir_node *block = get_nodes_block(n); - ir_node *jmp = new_r_Jmp(block); - ir_graph *irg = get_irn_irg(n); - ir_node *bad = new_r_Bad(irg, mode_X); - ir_node *res = value; - ir_node *in[] = { mem, res, jmp, bad }; - ir_node *tuple = new_r_Tuple(block, ARRAY_SIZE(in), in); - return tuple; - } + return create_load_replacement_tuple(n, mem, value); } return n; } +static ir_node *transform_node_Store(ir_node *n) +{ + /* don't touch volatile stores */ + if (get_Store_volatility(n) == volatility_is_volatile) + return n; + + ir_node *ptr = get_Store_ptr(n); + const ir_node *confirm; + if (value_not_zero(ptr, &confirm) && confirm == NULL) { + set_irn_pinned(n, op_pin_state_floats); + } + return n; +} + /** * optimize a trampoline Call into a direct Call */ @@ -6376,388 +6233,187 @@ static ir_node *transform_node_Call(ir_node *call) */ static ir_node *transform_node(ir_node *n) { - ir_node *oldn; - - /* - * Transform_node is the only "optimizing transformation" that might - * return a node with a different opcode. We iterate HERE until fixpoint - * to get the final result. - */ - do { - oldn = n; - if (n->op->ops.transform_node != NULL) - n = n->op->ops.transform_node(n); - } while (oldn != n); - - return n; -} - -/** - * Sets the default transform node operation for an ir_op_ops. - * - * @param code the opcode for the default operation - * @param ops the operations initialized - * - * @return - * The operations. - */ -static ir_op_ops *firm_set_default_transform_node(ir_opcode code, ir_op_ops *ops) -{ -#define CASE(a) \ - case iro_##a: \ - ops->transform_node = transform_node_##a; \ - break -#define CASE_PROJ(a) \ - case iro_##a: \ - ops->transform_node_Proj = transform_node_Proj_##a; \ - break -#define CASE_PROJ_EX(a) \ - case iro_##a: \ - ops->transform_node = transform_node_##a; \ - ops->transform_node_Proj = transform_node_Proj_##a; \ - break - - switch (code) { - CASE(Add); - CASE(And); - CASE(Block); - CASE(Call); - CASE(Cmp); - CASE(Cond); - CASE(Conv); - CASE(End); - CASE(Eor); - CASE(Minus); - CASE(Mul); - CASE(Mux); - CASE(Not); - CASE(Or); - CASE(Phi); - CASE(Proj); - CASE(Rotl); - CASE(Sel); - CASE(Shl); - CASE(Shr); - CASE(Shrs); - CASE(Sub); - CASE(Switch); - CASE(Sync); - CASE_PROJ(Bound); - CASE_PROJ(CopyB); - CASE_PROJ(Store); - CASE_PROJ_EX(Div); - CASE_PROJ_EX(Load); - CASE_PROJ_EX(Mod); - default: - break; - } - - return ops; -#undef CASE_PROJ_EX -#undef CASE_PROJ -#undef CASE -} - - -/* **************** Common Subexpression Elimination **************** */ - -/** The size of the hash table used, should estimate the number of nodes - in a graph. */ -#define N_IR_NODES 512 - -/** Compares two exception attributes */ -static int node_cmp_exception(const ir_node *a, const ir_node *b) -{ - const except_attr *ea = &a->attr.except; - const except_attr *eb = &b->attr.except; - return ea->pin_state != eb->pin_state; -} - -/** Compares the attributes of two Const nodes. */ -static int node_cmp_attr_Const(const ir_node *a, const ir_node *b) -{ - return get_Const_tarval(a) != get_Const_tarval(b); -} - -/** Compares the attributes of two Proj nodes. */ -static int node_cmp_attr_Proj(const ir_node *a, const ir_node *b) -{ - return a->attr.proj.proj != b->attr.proj.proj; -} - -/** Compares the attributes of two Alloc nodes. */ -static int node_cmp_attr_Alloc(const ir_node *a, const ir_node *b) -{ - const alloc_attr *pa = &a->attr.alloc; - const alloc_attr *pb = &b->attr.alloc; - if (pa->where != pb->where || pa->type != pb->type) - return 1; - return node_cmp_exception(a, b); -} - -/** Compares the attributes of two Free nodes. */ -static int node_cmp_attr_Free(const ir_node *a, const ir_node *b) -{ - const free_attr *pa = &a->attr.free; - const free_attr *pb = &b->attr.free; - return (pa->where != pb->where) || (pa->type != pb->type); -} - -/** Compares the attributes of two SymConst nodes. */ -static int node_cmp_attr_SymConst(const ir_node *a, const ir_node *b) -{ - const symconst_attr *pa = &a->attr.symc; - const symconst_attr *pb = &b->attr.symc; - return (pa->kind != pb->kind) - || (pa->sym.type_p != pb->sym.type_p); -} - -/** Compares the attributes of two Call nodes. */ -static int node_cmp_attr_Call(const ir_node *a, const ir_node *b) -{ - const call_attr *pa = &a->attr.call; - const call_attr *pb = &b->attr.call; - if (pa->type != pb->type || pa->tail_call != pb->tail_call) - return 1; - return node_cmp_exception(a, b); -} - -/** Compares the attributes of two Sel nodes. */ -static int node_cmp_attr_Sel(const ir_node *a, const ir_node *b) -{ - const ir_entity *a_ent = get_Sel_entity(a); - const ir_entity *b_ent = get_Sel_entity(b); - return a_ent != b_ent; -} - -/** Compares the attributes of two Phi nodes. */ -static int node_cmp_attr_Phi(const ir_node *a, const ir_node *b) -{ - /* we can only enter this function if both nodes have the same number of inputs, - hence it is enough to check if one of them is a Phi0 */ - if (is_Phi0(a)) { - /* check the Phi0 pos attribute */ - return a->attr.phi.u.pos != b->attr.phi.u.pos; - } - return 0; -} - -/** Compares the attributes of two Conv nodes. */ -static int node_cmp_attr_Conv(const ir_node *a, const ir_node *b) -{ - return get_Conv_strict(a) != get_Conv_strict(b); -} - -/** Compares the attributes of two Cast nodes. */ -static int node_cmp_attr_Cast(const ir_node *a, const ir_node *b) -{ - return get_Cast_type(a) != get_Cast_type(b); -} - -/** Compares the attributes of two Load nodes. */ -static int node_cmp_attr_Load(const ir_node *a, const ir_node *b) -{ - if (get_Load_volatility(a) == volatility_is_volatile || - 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_unaligned(a) != get_Load_unaligned(b)) - return 1; - if (get_Load_mode(a) != get_Load_mode(b)) - return 1; - return node_cmp_exception(a, b); -} - -/** Compares the attributes of two Store nodes. */ -static int node_cmp_attr_Store(const ir_node *a, const ir_node *b) -{ - /* do not CSE Stores with different alignment. Be conservative. */ - if (get_Store_unaligned(a) != get_Store_unaligned(b)) - return 1; - /* NEVER do CSE on volatile Stores */ - if (get_Store_volatility(a) == volatility_is_volatile || - get_Store_volatility(b) == volatility_is_volatile) - return 1; - return node_cmp_exception(a, b); -} - -static int node_cmp_attr_CopyB(const ir_node *a, const ir_node *b) -{ - if (get_CopyB_type(a) != get_CopyB_type(b)) - return 1; - - return node_cmp_exception(a, b); -} - -static int node_cmp_attr_Bound(const ir_node *a, const ir_node *b) -{ - return node_cmp_exception(a, b); -} - -/** Compares the attributes of two Div nodes. */ -static int node_cmp_attr_Div(const ir_node *a, const ir_node *b) -{ - const div_attr *ma = &a->attr.div; - const div_attr *mb = &b->attr.div; - if (ma->resmode != mb->resmode || ma->no_remainder != mb->no_remainder) - return 1; - return node_cmp_exception(a, b); -} - -/** Compares the attributes of two Mod nodes. */ -static int node_cmp_attr_Mod(const ir_node *a, const ir_node *b) -{ - const mod_attr *ma = &a->attr.mod; - const mod_attr *mb = &b->attr.mod; - if (ma->resmode != mb->resmode) - return 1; - return node_cmp_exception(a, b); -} - -static int node_cmp_attr_Cmp(const ir_node *a, const ir_node *b) -{ - const cmp_attr *ma = &a->attr.cmp; - const cmp_attr *mb = &b->attr.cmp; - return ma->relation != mb->relation; -} - -/** Compares the attributes of two Confirm nodes. */ -static int node_cmp_attr_Confirm(const ir_node *a, const ir_node *b) -{ - const confirm_attr *ma = &a->attr.confirm; - const confirm_attr *mb = &b->attr.confirm; - return ma->relation != mb->relation; -} - -/** Compares the attributes of two Builtin nodes. */ -static int node_cmp_attr_Builtin(const ir_node *a, const ir_node *b) -{ - if (get_Builtin_kind(a) != get_Builtin_kind(b)) - return 1; - if (get_Builtin_type(a) != get_Builtin_type(b)) - return 1; - return node_cmp_exception(a, b); -} - -/** Compares the attributes of two ASM nodes. */ -static int node_cmp_attr_ASM(const ir_node *a, const ir_node *b) -{ - int i, n; - const ir_asm_constraint *ca; - const ir_asm_constraint *cb; - ident **cla, **clb; - - if (get_ASM_text(a) != get_ASM_text(b)) - return 1; + ir_node *old_n; + unsigned iro; +restart: + old_n = n; + iro = get_irn_opcode_(n); + /* constant expression evaluation / constant folding */ + if (get_opt_constant_folding()) { + /* neither constants nor Tuple values can be evaluated */ + if (iro != iro_Const && get_irn_mode(n) != mode_T) { + /* try to evaluate */ + ir_tarval *tv = computed_value(n); + if (tv != tarval_bad) { + /* evaluation was successful -- replace the node. */ + ir_graph *irg = get_irn_irg(n); - /* Should we really check the constraints here? Should be better, but is strange. */ - n = get_ASM_n_input_constraints(a); - if (n != get_ASM_n_input_constraints(b)) - return 1; + n = new_r_Const(irg, tv); - ca = get_ASM_input_constraints(a); - cb = get_ASM_input_constraints(b); - for (i = 0; i < n; ++i) { - if (ca[i].pos != cb[i].pos || ca[i].constraint != cb[i].constraint - || ca[i].mode != cb[i].mode) - return 1; + DBG_OPT_CSTEVAL(old_n, n); + return n; + } + } } - n = get_ASM_n_output_constraints(a); - if (n != get_ASM_n_output_constraints(b)) - return 1; - - ca = get_ASM_output_constraints(a); - cb = get_ASM_output_constraints(b); - for (i = 0; i < n; ++i) { - if (ca[i].pos != cb[i].pos || ca[i].constraint != cb[i].constraint - || ca[i].mode != cb[i].mode) - return 1; + /* remove unnecessary nodes */ + if (get_opt_constant_folding() || + (iro == iro_Phi) || /* always optimize these nodes. */ + (iro == iro_Id) || /* ... */ + (iro == iro_Proj) || /* ... */ + (iro == iro_Block)) { /* Flags tested local. */ + n = equivalent_node(n); + if (n != old_n) + goto restart; } - n = get_ASM_n_clobbers(a); - if (n != get_ASM_n_clobbers(b)) - return 1; - - cla = get_ASM_clobbers(a); - clb = get_ASM_clobbers(b); - for (i = 0; i < n; ++i) { - if (cla[i] != clb[i]) - return 1; + /* Some more constant expression evaluation. */ + if (get_opt_algebraic_simplification() || + (iro == iro_Cond) || + (iro == iro_Proj)) { /* Flags tested local. */ + if (n->op->ops.transform_node != NULL) { + n = n->op->ops.transform_node(n); + if (n != old_n) { + goto restart; + } + } } - return node_cmp_exception(a, b); + return n; } -/** Compares the inexistent attributes of two Dummy nodes. */ -static int node_cmp_attr_Dummy(const ir_node *a, const ir_node *b) -{ - (void) a; - (void) b; - /* Dummy nodes never equal by definition */ - return 1; +static void register_computed_value_func(ir_op *op, computed_value_func func) +{ + assert(op->ops.computed_value == NULL || op->ops.computed_value == func); + op->ops.computed_value = func; +} + +static void register_computed_value_func_proj(ir_op *op, + computed_value_func func) +{ + assert(op->ops.computed_value_Proj == NULL + || op->ops.computed_value_Proj == func); + op->ops.computed_value_Proj = func; +} + +static void register_equivalent_node_func(ir_op *op, equivalent_node_func func) +{ + assert(op->ops.equivalent_node == NULL || op->ops.equivalent_node == func); + op->ops.equivalent_node = func; +} + +static void register_equivalent_node_func_proj(ir_op *op, + equivalent_node_func func) +{ + assert(op->ops.equivalent_node_Proj == NULL + || op->ops.equivalent_node_Proj == func); + op->ops.equivalent_node_Proj = func; +} + +static void register_transform_node_func(ir_op *op, transform_node_func func) +{ + assert(op->ops.transform_node == NULL || op->ops.transform_node == func); + op->ops.transform_node = func; +} + +static void register_transform_node_func_proj(ir_op *op, + transform_node_func func) +{ + assert(op->ops.transform_node_Proj == NULL + || op->ops.transform_node_Proj == func); + op->ops.transform_node_Proj = func; +} + +void ir_register_opt_node_ops(void) +{ + register_computed_value_func(op_Add, computed_value_Add); + register_computed_value_func(op_And, computed_value_And); + register_computed_value_func(op_Borrow, computed_value_Borrow); + register_computed_value_func(op_Carry, computed_value_Carry); + register_computed_value_func(op_Cmp, computed_value_Cmp); + register_computed_value_func(op_Confirm, computed_value_Confirm); + register_computed_value_func(op_Const, computed_value_Const); + register_computed_value_func(op_Conv, computed_value_Conv); + register_computed_value_func(op_Eor, computed_value_Eor); + register_computed_value_func(op_Minus, computed_value_Minus); + register_computed_value_func(op_Mul, computed_value_Mul); + register_computed_value_func(op_Mux, computed_value_Mux); + register_computed_value_func(op_Not, computed_value_Not); + register_computed_value_func(op_Or, computed_value_Or); + register_computed_value_func(op_Proj, computed_value_Proj); + register_computed_value_func(op_Rotl, computed_value_Rotl); + register_computed_value_func(op_Shl, computed_value_Shl); + register_computed_value_func(op_Shr, computed_value_Shr); + register_computed_value_func(op_Shrs, computed_value_Shrs); + register_computed_value_func(op_Sub, computed_value_Sub); + register_computed_value_func(op_SymConst, computed_value_SymConst); + register_computed_value_func_proj(op_Div, computed_value_Proj_Div); + register_computed_value_func_proj(op_Mod, computed_value_Proj_Mod); + + register_equivalent_node_func(op_Add, equivalent_node_Add); + register_equivalent_node_func(op_And, equivalent_node_And); + register_equivalent_node_func(op_Confirm, equivalent_node_Confirm); + register_equivalent_node_func(op_Conv, equivalent_node_Conv); + register_equivalent_node_func(op_Eor, equivalent_node_Eor); + register_equivalent_node_func(op_Id, equivalent_node_Id); + register_equivalent_node_func(op_Minus, equivalent_node_involution); + register_equivalent_node_func(op_Mul, equivalent_node_Mul); + register_equivalent_node_func(op_Mux, equivalent_node_Mux); + register_equivalent_node_func(op_Not, equivalent_node_involution); + register_equivalent_node_func(op_Or, equivalent_node_Or); + register_equivalent_node_func(op_Phi, equivalent_node_Phi); + register_equivalent_node_func(op_Proj, equivalent_node_Proj); + register_equivalent_node_func(op_Rotl, equivalent_node_left_zero); + register_equivalent_node_func(op_Shl, equivalent_node_left_zero); + register_equivalent_node_func(op_Shr, equivalent_node_left_zero); + register_equivalent_node_func(op_Shrs, equivalent_node_left_zero); + register_equivalent_node_func(op_Sub, equivalent_node_Sub); + register_equivalent_node_func_proj(op_Bound, equivalent_node_Proj_Bound); + register_equivalent_node_func_proj(op_CopyB, equivalent_node_Proj_CopyB); + register_equivalent_node_func_proj(op_Div, equivalent_node_Proj_Div); + register_equivalent_node_func_proj(op_Tuple, equivalent_node_Proj_Tuple); + + register_transform_node_func(op_Add, transform_node_Add); + register_transform_node_func(op_And, transform_node_And); + register_transform_node_func(op_Block, transform_node_Block); + register_transform_node_func(op_Call, transform_node_Call); + register_transform_node_func(op_Cmp, transform_node_Cmp); + register_transform_node_func(op_Cond, transform_node_Cond); + register_transform_node_func(op_Conv, transform_node_Conv); + register_transform_node_func(op_Div, transform_node_Div); + register_transform_node_func(op_End, transform_node_End); + register_transform_node_func(op_Eor, transform_node_Eor); + register_transform_node_func(op_Load, transform_node_Load); + register_transform_node_func(op_Minus, transform_node_Minus); + register_transform_node_func(op_Mod, transform_node_Mod); + register_transform_node_func(op_Mul, transform_node_Mul); + register_transform_node_func(op_Mux, transform_node_Mux); + register_transform_node_func(op_Not, transform_node_Not); + register_transform_node_func(op_Or, transform_node_Or); + register_transform_node_func(op_Phi, transform_node_Phi); + register_transform_node_func(op_Proj, transform_node_Proj); + register_transform_node_func(op_Rotl, transform_node_Rotl); + register_transform_node_func(op_Shl, transform_node_Shl); + register_transform_node_func(op_Shrs, transform_node_Shrs); + register_transform_node_func(op_Shr, transform_node_Shr); + register_transform_node_func(op_Store, transform_node_Store); + register_transform_node_func(op_Sub, transform_node_Sub); + register_transform_node_func(op_Switch, transform_node_Switch); + register_transform_node_func(op_Sync, transform_node_Sync); + register_transform_node_func_proj(op_Bound, transform_node_Proj_Bound); + register_transform_node_func_proj(op_CopyB, transform_node_Proj_CopyB); + register_transform_node_func_proj(op_Div, transform_node_Proj_Div); + register_transform_node_func_proj(op_Load, transform_node_Proj_Load); + register_transform_node_func_proj(op_Mod, transform_node_Proj_Mod); + register_transform_node_func_proj(op_Store, transform_node_Proj_Store); } -static int node_cmp_attr_InstOf(const ir_node *a, const ir_node *b) -{ - if (get_InstOf_type(a) != get_InstOf_type(b)) - return 1; - return node_cmp_exception(a, b); -} - -/** - * Set the default node attribute compare operation for an ir_op_ops. - * - * @param code the opcode for the default operation - * @param ops the operations initialized - * - * @return - * The operations. - */ -static ir_op_ops *firm_set_default_node_cmp_attr(ir_opcode code, ir_op_ops *ops) -{ -#define CASE(a) \ - case iro_##a: \ - ops->node_cmp_attr = node_cmp_attr_##a; \ - break - - switch (code) { - CASE(ASM); - CASE(Alloc); - CASE(Bound); - CASE(Builtin); - CASE(Call); - CASE(Cast); - CASE(Cmp); - CASE(Confirm); - CASE(Const); - CASE(Conv); - CASE(CopyB); - CASE(Div); - CASE(Dummy); - CASE(Free); - CASE(InstOf); - CASE(Load); - CASE(Mod); - CASE(Phi); - CASE(Proj); - CASE(Sel); - CASE(Store); - CASE(SymConst); - default: - /* leave NULL */ - break; - } +/* **************** Common Subexpression Elimination **************** */ - return ops; -#undef CASE -} +/** The size of the hash table used, should estimate the number of nodes + in a graph. */ +#define N_IR_NODES 512 -/* - * Compare function for two nodes in the value table. Gets two - * nodes as parameters. Returns 0 if the nodes are a Common Sub Expression. - */ int identities_cmp(const void *elt, const void *key) { ir_node *a = (ir_node *)elt; @@ -6780,7 +6436,7 @@ int identities_cmp(const void *elt, const void *key) if (get_irn_pinned(a) == op_pin_state_pinned) { /* for pinned nodes, the block inputs must be equal */ - if (get_irn_n(a, -1) != get_irn_n(b, -1)) + if (get_nodes_block(a) != get_nodes_block(b)) return 1; } else { ir_node *block_a = get_nodes_block(a); @@ -6798,6 +6454,10 @@ int identities_cmp(const void *elt, const void *key) if (!block_dominates(block_a, block_b) && !block_dominates(block_b, block_a)) return 1; + /* respect the workaround rule: do not move nodes which are only + * held by keepalive edges */ + if (only_used_by_keepalive(a) || only_used_by_keepalive(b)) + return 1; } } @@ -6822,17 +6482,11 @@ int identities_cmp(const void *elt, const void *key) return 0; } -/* - * Calculate a hash value of a node. - * - * @param node The IR-node - */ unsigned ir_node_hash(const ir_node *node) { return node->op->ops.hash(node); } - void new_identities(ir_graph *irg) { if (irg->value_table != NULL) @@ -6846,8 +6500,15 @@ void del_identities(ir_graph *irg) del_pset(irg->value_table); } -/* Normalize a node by putting constants (and operands with larger - * node index) on the right (operator side). */ +static int cmp_node_nr(const void *a, const void *b) +{ + ir_node **p1 = (ir_node**)a; + ir_node **p2 = (ir_node**)b; + long n1 = get_irn_node_nr(*p1); + long n2 = get_irn_node_nr(*p2); + return (n1>n2) - (n1value_table, ir_node*, node) { + foreach_pset(irg->value_table, ir_node, node) { visit(node, env); } current_ir_graph = rem; } -/** - * These optimizations deallocate nodes from the obstack. - * It can only be called if it is guaranteed that no other nodes - * reference this one, i.e., right after construction of a node. - * - * @param n The node to optimize - */ ir_node *optimize_node(ir_node *n) { ir_node *oldn = n; @@ -7023,12 +6688,13 @@ ir_node *optimize_node(ir_node *n) free the node. */ iro = get_irn_opcode(n); if (get_opt_algebraic_simplification() || - (iro == iro_Cond) || - (iro == iro_Proj)) /* Flags tested local. */ + (iro == iro_Cond) || + (iro == iro_Proj)) { /* Flags tested local. */ n = transform_node(n); + } /* Now we have a legal, useful node. Enter it in hash table for CSE */ - if (get_opt_cse() && (get_irn_opcode(n) != iro_Block)) { + if (get_opt_cse()) { ir_node *o = n; n = identify_remember(o); if (o != n) @@ -7038,75 +6704,40 @@ ir_node *optimize_node(ir_node *n) return n; } - -/** - * These optimizations never deallocate nodes (in place). This can cause dead - * nodes lying on the obstack. Remove these by a dead node elimination, - * i.e., a copying garbage collection. - */ ir_node *optimize_in_place_2(ir_node *n) { - ir_tarval *tv; - ir_node *oldn = n; - unsigned iro = get_irn_opcode(n); - if (!get_opt_optimize() && !is_Phi(n)) return n; - if (iro == iro_Deleted) + if (is_Deleted(n)) return n; - /* constant expression evaluation / constant folding */ - if (get_opt_constant_folding()) { - /* neither constants nor Tuple values can be evaluated */ - if (iro != iro_Const && get_irn_mode(n) != mode_T) { - /* try to evaluate */ - tv = computed_value(n); - if (tv != tarval_bad) { - /* evaluation was successful -- replace the node. */ - ir_graph *irg = get_irn_irg(n); - - n = new_r_Const(irg, tv); - - DBG_OPT_CSTEVAL(oldn, n); - return n; - } - } - } - - /* remove unnecessary nodes */ - if (get_opt_constant_folding() || - (iro == iro_Phi) || /* always optimize these nodes. */ - (iro == iro_Id) || /* ... */ - (iro == iro_Proj) || /* ... */ - (iro == iro_Block) ) /* Flags tested local. */ - n = equivalent_node(n); - /** common subexpression elimination **/ /* Checks whether n is already available. */ - /* The block input is used to distinguish different subexpressions. Right - now all nodes are op_pin_state_pinned to blocks, i.e., the cse only finds common - subexpressions within a block. */ + /* The block input is used to distinguish different subexpressions. + * Right now all nodes are op_pin_state_pinned to blocks, i.e., the cse + * only finds common subexpressions within a block. */ if (get_opt_cse()) { ir_node *o = n; - n = identify_remember(o); - if (o != n) + n = identify_remember(n); + if (n != o) { DBG_OPT_CSE(o, n); + /* we have another existing node now, we do not optimize it here */ + return n; + } } - /* Some more constant expression evaluation. */ - iro = get_irn_opcode(n); - if (get_opt_constant_folding() || - (iro == iro_Cond) || - (iro == iro_Proj)) /* Flags tested local. */ - n = transform_node(n); + n = transform_node(n); /* Now we can verify the node, as it has no dead inputs any more. */ irn_verify(n); /* Now we have a legal, useful node. Enter it in hash table for cse. - Blocks should be unique anyways. (Except the successor of start: - is cse with the start block!) */ - if (get_opt_cse() && (get_irn_opcode(n) != iro_Block)) { + * + * Note: This is only necessary because some of the optimisations + * operate in-place (set_XXX_bla, turn_into_tuple, ...) which is considered + * bad practice and should be fixed sometime. + */ + if (get_opt_cse()) { ir_node *o = n; n = identify_remember(o); if (o != n) @@ -7116,94 +6747,15 @@ ir_node *optimize_in_place_2(ir_node *n) return n; } -/** - * Wrapper for external use, set proper status bits after optimization. - */ ir_node *optimize_in_place(ir_node *n) { ir_graph *irg = get_irn_irg(n); - /* Handle graph state */ - assert(get_irg_phase_state(irg) != phase_building); if (get_opt_global_cse()) set_irg_pinned(irg, op_pin_state_floats); /* FIXME: Maybe we could also test whether optimizing the node can change the control graph. */ - clear_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE); + clear_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE); return optimize_in_place_2(n); } - -/** - * Calculate a hash value of a Const node. - */ -static unsigned hash_Const(const ir_node *node) -{ - unsigned h; - - /* special value for const, as they only differ in their tarval. */ - h = HASH_PTR(node->attr.con.tarval); - - return h; -} - -/** - * Calculate a hash value of a SymConst node. - */ -static unsigned hash_SymConst(const ir_node *node) -{ - unsigned h; - - /* all others are pointers */ - h = HASH_PTR(node->attr.symc.sym.type_p); - - return h; -} - -/** - * Set the default hash operation in an ir_op_ops. - * - * @param code the opcode for the default operation - * @param ops the operations initialized - * - * @return - * The operations. - */ -static ir_op_ops *firm_set_default_hash(unsigned code, ir_op_ops *ops) -{ -#define CASE(a) \ - case iro_##a: \ - ops->hash = hash_##a; \ - break - - /* hash function already set */ - if (ops->hash != NULL) - return ops; - - switch (code) { - CASE(Const); - CASE(SymConst); - default: - /* use input/mode default hash if no function was given */ - ops->hash = firm_default_hash; - } - - return ops; -#undef CASE -} - -/* - * Sets the default operation for an ir_ops. - */ -ir_op_ops *firm_set_default_operations(unsigned code, ir_op_ops *ops) -{ - ops = firm_set_default_hash(code, ops); - ops = firm_set_default_computed_value(code, ops); - ops = firm_set_default_equivalent_node(code, ops); - ops = firm_set_default_transform_node(code, ops); - ops = firm_set_default_node_cmp_attr(code, ops); - ops = firm_set_default_get_type_attr(code, ops); - ops = firm_set_default_get_entity_attr(code, ops); - - return ops; -}