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
/**
- * 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.
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;
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. */
* 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 */
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);
}
}
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);
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);
}
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);
}
}
}
+
+ /* 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 */
/*
* 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.
(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());
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
n = new_rd_And(dbgi, irg, blk, new_n, c, mode);
} else {
n = exact_copy(a);
- set_irn_n(n, -1, blk);
+ set_nodes_block(n, blk);
set_binop_left(n, new_n);
set_binop_right(n, c);
add_identities(current_ir_graph->value_table, n);
ir_node *mul_r = get_Mul_right(a);
if (is_Const(mul_r)) {
tarval *tv = tarval_neg(get_Const_tarval(mul_r));
- ir_node *cnst = new_Const(mode, tv);
- dbg_info *dbg = get_irn_dbg_info(a);
- ir_graph *irg = current_ir_graph;
- ir_node *block = get_nodes_block(a);
- n = new_rd_Mul(dbg, irg, block, mul_l, cnst, mode);
- DBG_OPT_ALGSIM2(oldn, a, n, FS_OPT_MINUS_MUL_C);
- return n;
+ if(tv != tarval_bad) {
+ ir_node *cnst = new_Const(mode, tv);
+ dbg_info *dbg = get_irn_dbg_info(a);
+ ir_graph *irg = current_ir_graph;
+ ir_node *block = get_nodes_block(a);
+ n = new_rd_Mul(dbg, irg, block, mul_l, cnst, mode);
+ DBG_OPT_ALGSIM2(oldn, a, n, FS_OPT_MINUS_MUL_C);
+ return n;
+ }
}
}
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 */
}
}
- /* 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
* 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;
+ }
}
}
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 */
/** 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));
+ return get_irn_call_attr(a) != get_irn_call_attr(b);
} /* node_cmp_attr_Call */
/** Compares the attributes of two Sel nodes. */
/* 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 attribute */
- return get_irn_phi0_attr(a) != get_irn_phi0_attr(b);
+ /* check the Phi0 pos attribute */
+ return get_irn_phi_attr(a)->u.pos != get_irn_phi_attr(b)->u.pos;
}
return 0;
} /* node_cmp_attr_Phi */
get_Store_volatility(b) == volatility_is_volatile);
} /* node_cmp_attr_Store */
+/** Compares two exception attributes */
+static int node_cmp_exception(ir_node *a, ir_node *b) {
+ const except_attr *ea = get_irn_except_attr(a);
+ const except_attr *eb = get_irn_except_attr(b);
+
+ return ea->pin_state != eb->pin_state;
+}
+
+#define node_cmp_attr_Bound node_cmp_exception
+
+/** Compares the attributes of two Div nodes. */
+static int node_cmp_attr_Div(ir_node *a, ir_node *b) {
+ const divmod_attr *ma = get_irn_divmod_attr(a);
+ const divmod_attr *mb = get_irn_divmod_attr(b);
+ return ma->exc.pin_state != mb->exc.pin_state ||
+ ma->res_mode != mb->res_mode ||
+ ma->no_remainder != mb->no_remainder;
+} /* node_cmp_attr_Div */
+
+/** Compares the attributes of two DivMod nodes. */
+static int node_cmp_attr_DivMod(ir_node *a, ir_node *b) {
+ const divmod_attr *ma = get_irn_divmod_attr(a);
+ const divmod_attr *mb = get_irn_divmod_attr(b);
+ return ma->exc.pin_state != mb->exc.pin_state ||
+ ma->res_mode != mb->res_mode;
+} /* node_cmp_attr_DivMod */
+
+/** Compares the attributes of two Mod nodes. */
+static int node_cmp_attr_Mod(ir_node *a, ir_node *b) {
+ const divmod_attr *ma = get_irn_divmod_attr(a);
+ const divmod_attr *mb = get_irn_divmod_attr(b);
+ return ma->exc.pin_state != mb->exc.pin_state ||
+ ma->res_mode != mb->res_mode;
+} /* node_cmp_attr_Mod */
+
+/** Compares the attributes of two Quot nodes. */
+static int node_cmp_attr_Quot(ir_node *a, ir_node *b) {
+ const divmod_attr *ma = get_irn_divmod_attr(a);
+ const divmod_attr *mb = get_irn_divmod_attr(b);
+ return ma->exc.pin_state != mb->exc.pin_state ||
+ ma->res_mode != mb->res_mode;
+} /* node_cmp_attr_Quot */
+
/** Compares the attributes of two Confirm nodes. */
static int node_cmp_attr_Confirm(ir_node *a, ir_node *b) {
return (get_Confirm_cmp(a) != get_Confirm_cmp(b));
CASE(Store);
CASE(Confirm);
CASE(ASM);
+ CASE(Div);
+ CASE(DivMod);
+ CASE(Mod);
+ CASE(Quot);
+ CASE(Bound);
+ /* FIXME CopyB */
default:
/* leave NULL */;
}
projects / libfirm / blobdiff