X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firopt.c;h=c2cecb135541755428bf95090f081897abbfa566;hb=7498ed3766f3f98604d96d1b75978a3a9e6768ed;hp=60ec67fd9545f6be2b279491428a9919d517b53b;hpb=7b4f11388ac53c360634ad08030730e6779ccbfb;p=libfirm diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c index 60ec67fd9..c2cecb135 100644 --- a/ir/ir/iropt.c +++ b/ir/ir/iropt.c @@ -722,10 +722,16 @@ static ir_op_ops *firm_set_default_computed_value(ir_opcode code, ir_op_ops *ops static ir_node *equivalent_node_Block(ir_node *n) { ir_node *oldn = n; - int n_preds = get_Block_n_cfgpreds(n); + int n_preds; - /* The Block constructor does not call optimize, but mature_immBlock - calls the optimization. */ + /* don't optimize dead blocks */ + if (is_Block_dead(n)) + return n; + + n_preds = get_Block_n_cfgpreds(n); + + /* The Block constructor does not call optimize, but mature_immBlock() + calls the optimization. */ assert(get_Block_matured(n)); /* Straightening: a single entry Block following a single exit Block @@ -971,7 +977,7 @@ static ir_node *equivalent_node_Sub(ir_node *n) { /** - * Optimize an "idempotent unary op", ie op(op(n)) = n. + * Optimize an "self-inverse unary op", ie op(op(n)) = n. * * @todo * -(-a) == a, but might overflow two times. @@ -1232,7 +1238,7 @@ static ir_node *equivalent_node_Phi(ir_node *n) { int i, n_preds; ir_node *oldn = n; - ir_node *block = NULL; /* to shutup gcc */ + ir_node *block; ir_node *first_val = NULL; /* to shutup gcc */ if (!get_opt_normalize()) return n; @@ -1240,8 +1246,6 @@ static ir_node *equivalent_node_Phi(ir_node *n) { n_preds = get_Phi_n_preds(n); block = get_nodes_block(n); - /* @@@ fliegt 'raus, sollte aber doch immer wahr sein!!! - assert(get_irn_arity(block) == n_preds && "phi in wrong block!"); */ if ((is_Block_dead(block)) || /* Control dead */ (block == get_irg_start_block(current_ir_graph))) /* There should be no Phi nodes */ return new_Bad(); /* in the Start Block. */ @@ -1299,45 +1303,36 @@ static ir_node *equivalent_node_Phi(ir_node *n) { * themselves. */ static ir_node *equivalent_node_Sync(ir_node *n) { - int i, n_preds; - - ir_node *oldn = n; - ir_node *first_val = NULL; /* to shutup gcc */ - - if (!get_opt_normalize()) return n; + int arity = get_Sync_n_preds(n); + int i; - n_preds = get_Sync_n_preds(n); + for (i = 0; i < arity;) { + ir_node *pred = get_Sync_pred(n, i); + int j; - /* Find first non-self-referencing input */ - for (i = 0; i < n_preds; ++i) { - first_val = get_Sync_pred(n, i); - if ((first_val != n) /* not self pointer */ && - (! is_Bad(first_val)) - ) { /* value not dead */ - break; /* then found first value. */ + /* Remove Bad predecessors */ + if (is_Bad(pred)) { + del_Sync_n(n, i); + --arity; + continue; } - } - - if (i >= n_preds) - /* A totally Bad or self-referencing Sync (we didn't break the above loop) */ - return new_Bad(); - /* search the rest of inputs, determine if any of these - are non-self-referencing */ - while (++i < n_preds) { - ir_node *scnd_val = get_Sync_pred(n, i); - if ((scnd_val != n) && - (scnd_val != first_val) && - (! is_Bad(scnd_val)) - ) - break; + /* Remove duplicate predecessors */ + for (j = 0;; ++j) { + if (j >= i) { + ++i; + break; + } + if (get_Sync_pred(n, j) == pred) { + del_Sync_n(n, i); + --arity; + break; + } + } } - if (i >= n_preds) { - /* Fold, if no multiple distinct non-self-referencing inputs */ - n = first_val; - DBG_OPT_SYNC(oldn, n); - } + if (arity == 0) return new_Bad(); + if (arity == 1) return get_Sync_pred(n, 0); return n; } /* equivalent_node_Sync */ @@ -1445,41 +1440,54 @@ static ir_node *equivalent_node_Mux(ir_node *n) else if (is_Proj(sel) && !mode_honor_signed_zeros(get_irn_mode(n))) { ir_node *cmp = get_Proj_pred(sel); long proj_nr = get_Proj_proj(sel); - ir_node *b = get_Mux_false(n); - ir_node *a = get_Mux_true(n); + ir_node *f = get_Mux_false(n); + ir_node *t = get_Mux_true(n); /* - * Note: normalization puts the constant on the right site, - * so we check only one case. - * * Note further that these optimization work even for floating point * with NaN's because -NaN == NaN. * However, if +0 and -0 is handled differently, we cannot use the first one. */ - if (is_Cmp(cmp) && get_Cmp_left(cmp) == a) { - ir_node *cmp_r = get_Cmp_right(cmp); - if (is_Const(cmp_r) && is_Const_null(cmp_r)) { - /* Mux(a CMP 0, X, a) */ - if (is_Minus(b) && get_Minus_op(b) == a) { - /* Mux(a CMP 0, -a, a) */ - if (proj_nr == pn_Cmp_Eq) { - /* Mux(a == 0, -a, a) ==> -a */ - n = b; + if (is_Cmp(cmp)) { + ir_node *const cmp_l = get_Cmp_left(cmp); + ir_node *const cmp_r = get_Cmp_right(cmp); + + switch (proj_nr) { + case pn_Cmp_Eq: + if ((cmp_l == t && cmp_r == f) || /* Psi(t == f, t, f) -> f */ + (cmp_l == f && cmp_r == t)) { /* Psi(f == t, t, f) -> f */ + n = f; DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_TRANSFORM); - } else if (proj_nr == pn_Cmp_Lg || proj_nr == pn_Cmp_Ne) { - /* Mux(a != 0, -a, a) ==> a */ - n = a; + return n; + } + break; + + case pn_Cmp_Lg: + case pn_Cmp_Ne: + if ((cmp_l == t && cmp_r == f) || /* Psi(t != f, t, f) -> t */ + (cmp_l == f && cmp_r == t)) { /* Psi(f != t, t, f) -> t */ + n = t; DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_TRANSFORM); + return n; } - } else if (is_Const(b) && is_Const_null(b)) { - /* Mux(a CMP 0, 0, a) */ - if (proj_nr == pn_Cmp_Lg || proj_nr == pn_Cmp_Ne) { - /* Mux(a != 0, 0, a) ==> a */ - n = a; + break; + } + + /* + * Note: normalization puts the constant on the right side, + * so we check only one case. + */ + if (cmp_l == t && is_Const(cmp_r) && is_Const_null(cmp_r)) { + /* Mux(t CMP 0, X, t) */ + if (is_Minus(f) && get_Minus_op(f) == t) { + /* Mux(t CMP 0, -t, t) */ + if (proj_nr == pn_Cmp_Eq) { + /* Mux(t == 0, -t, t) ==> -t */ + n = f; DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_TRANSFORM); - } else if (proj_nr == pn_Cmp_Eq) { - /* Mux(a == 0, 0, a) ==> 0 */ - n = b; + } else if (proj_nr == pn_Cmp_Lg || proj_nr == pn_Cmp_Ne) { + /* Mux(t != 0, -t, t) ==> t */ + n = t; DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_TRANSFORM); } } @@ -1767,7 +1775,7 @@ static ir_node *apply_binop_on_2_phis(ir_node *a, ir_node *b, tarval *(*eval)(ta int i, n; if (get_nodes_block(a) != get_nodes_block(b)) - return NULL; + return NULL; n = get_irn_arity(a); NEW_ARR_A(void *, res, n); @@ -1880,12 +1888,12 @@ static ir_node *transform_node_AddSub(ir_node *n) { unsigned ref_bits = get_mode_size_bits(mode); if (is_Conv(left)) { - ir_mode *mode = get_irn_mode(left); - unsigned bits = get_mode_size_bits(mode); + ir_mode *lmode = get_irn_mode(left); + unsigned bits = get_mode_size_bits(lmode); if (ref_bits == bits && - mode_is_int(mode) && - get_mode_arithmetic(mode) == irma_twos_complement) { + mode_is_int(lmode) && + get_mode_arithmetic(lmode) == irma_twos_complement) { ir_node *pre = get_Conv_op(left); ir_mode *pre_mode = get_irn_mode(pre); @@ -1903,12 +1911,12 @@ static ir_node *transform_node_AddSub(ir_node *n) { } if (is_Conv(right)) { - ir_mode *mode = get_irn_mode(right); - unsigned bits = get_mode_size_bits(mode); + ir_mode *rmode = get_irn_mode(right); + unsigned bits = get_mode_size_bits(rmode); if (ref_bits == bits && - mode_is_int(mode) && - get_mode_arithmetic(mode) == irma_twos_complement) { + mode_is_int(rmode) && + get_mode_arithmetic(rmode) == irma_twos_complement) { ir_node *pre = get_Conv_op(right); ir_mode *pre_mode = get_irn_mode(pre); @@ -1924,6 +1932,19 @@ static ir_node *transform_node_AddSub(ir_node *n) { } } } + + /* let address arithmetic use unsigned modes */ + if (is_Const(right)) { + ir_mode *rmode = get_irn_mode(right); + + if (mode_is_signed(rmode) && get_mode_arithmetic(rmode) == irma_twos_complement) { + /* convert a AddP(P, *s) into AddP(P, *u) */ + ir_mode *nm = get_reference_mode_unsigned_eq(mode); + + ir_node *pre = new_r_Conv(current_ir_graph, get_nodes_block(n), right, nm); + set_binop_right(n, pre); + } + } } return n; } /* transform_node_AddSub */ @@ -2829,7 +2850,8 @@ static ir_node *transform_node_Abs(ir_node *n) { /* * We can replace the Abs by -x here. - * We even could add a new Confirm here. + * We even could add a new Confirm here + * (if not twos complement) * * Note that -x would create a new node, so we could * not run it in the equivalent_node() context. @@ -2880,7 +2902,8 @@ static ir_node *transform_node_Cond(ir_node *n) { (get_opt_unreachable_code())) { /* It's a boolean Cond, branching on a boolean constant. Replace it by a tuple (Bad, Jmp) or (Jmp, Bad) */ - jmp = new_r_Jmp(current_ir_graph, get_nodes_block(n)); + ir_node *blk = get_nodes_block(n); + jmp = new_r_Jmp(current_ir_graph, blk); turn_into_tuple(n, pn_Cond_max); if (ta == tarval_b_true) { set_Tuple_pred(n, pn_Cond_false, new_Bad()); @@ -2890,12 +2913,16 @@ static ir_node *transform_node_Cond(ir_node *n) { set_Tuple_pred(n, pn_Cond_true, new_Bad()); } /* We might generate an endless loop, so keep it alive. */ - add_End_keepalive(get_irg_end(current_ir_graph), get_nodes_block(n)); + add_End_keepalive(get_irg_end(current_ir_graph), blk); } return n; } /* transform_node_Cond */ -typedef ir_node* (*recursive_transform) (ir_node *n); +/** + * Prototype of a recursive transform function + * for bitwise distributive transformations. + */ +typedef ir_node* (*recursive_transform)(ir_node *n); /** * makes use of distributive laws for and, or, eor @@ -3626,11 +3653,9 @@ static ir_node *transform_node_Proj_Cmp(ir_node *proj) { break; } - /* remove Casts */ - if (is_Cast(left)) - left = get_Cast_op(left); - if (is_Cast(right)) - right = get_Cast_op(right); + /* remove Casts of both sides */ + left = skip_Cast(left); + right = skip_Cast(right); /* Remove unnecessary conversions */ /* TODO handle constants */ @@ -3665,7 +3690,7 @@ static ir_node *transform_node_Proj_Cmp(ir_node *proj) { } } - /* remove operation of both sides if possible */ + /* remove operation on both sides if possible */ if (proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg) { /* * The following operations are NOT safe for floating point operations, for instance @@ -4843,28 +4868,35 @@ static ir_node *transform_node_Psi(ir_node *n) { * of the other sync to our own inputs */ static ir_node *transform_node_Sync(ir_node *n) { - int i, arity; + int arity = get_Sync_n_preds(n); + int i; + + for (i = 0; i < arity;) { + ir_node *pred = get_Sync_pred(n, i); + int pred_arity; + int j; - arity = get_irn_arity(n); - for(i = 0; i < get_irn_arity(n); /*empty*/) { - int i2, arity2; - ir_node *in = get_irn_n(n, i); - if(!is_Sync(in)) { + if (!is_Sync(pred)) { ++i; continue; } - /* set sync input 0 instead of the sync */ - set_irn_n(n, i, get_irn_n(in, 0)); - /* so we check this input again for syncs */ - - /* append all other inputs of the sync to our sync */ - arity2 = get_irn_arity(in); - for(i2 = 1; i2 < arity2; ++i2) { - ir_node *in_in = get_irn_n(in, i2); - add_irn_n(n, in_in); - /* increase arity so we also check the new inputs for syncs */ - arity++; + del_Sync_n(n, i); + --arity; + + pred_arity = get_Sync_n_preds(pred); + for (j = 0; j < pred_arity; ++j) { + ir_node *pred_pred = get_Sync_pred(pred, j); + int k; + + for (k = 0;; ++k) { + if (k >= arity) { + add_irn_n(n, pred_pred); + ++arity; + break; + } + if (get_Sync_pred(n, k) == pred_pred) break; + } } } @@ -4990,7 +5022,7 @@ static int node_cmp_attr_Free(ir_node *a, ir_node *b) { static int node_cmp_attr_SymConst(ir_node *a, ir_node *b) { const symconst_attr *pa = get_irn_symconst_attr(a); const symconst_attr *pb = get_irn_symconst_attr(b); - return (pa->num != pb->num) + return (pa->kind != pb->kind) || (pa->sym.type_p != pb->sym.type_p) || (pa->tp != pb->tp); } /* node_cmp_attr_SymConst */