* if it has the form Confirm(x, '=', Const).
*/
static tarval *computed_value_Confirm(ir_node *n) {
- return get_Confirm_cmp(n) == pn_Cmp_Eq ?
- value_of(get_Confirm_bound(n)) : tarval_bad;
+ /*
+ * Beware: we might produce Phi(Confirm(x == true), Confirm(x == false)).
+ * Do NOT optimize them away (CondEval wants them), so wait until
+ * remove_confirm is activated.
+ */
+ if (get_opt_remove_confirm()) {
+ return get_Confirm_cmp(n) == pn_Cmp_Eq ?
+ value_of(get_Confirm_bound(n)) : tarval_bad;
+ }
+ return tarval_bad;
} /* computed_value_Confirm */
/**
/**
* Eor is commutative and has neutral 0.
*/
-#define equivalent_node_Eor equivalent_node_neutral_zero
+static ir_node *equivalent_node_Eor(ir_node *n)
+{
+ ir_node *oldn = n;
+ ir_node *a;
+ ir_node *b;
+
+ n = equivalent_node_neutral_zero(n);
+ if (n != oldn) return n;
+
+ a = get_Eor_left(n);
+ b = get_Eor_right(n);
+
+ if (is_Eor(a)) {
+ ir_node *aa = get_Eor_left(a);
+ ir_node *ab = get_Eor_right(a);
+
+ if (aa == b) {
+ /* (a ^ b) ^ a -> b */
+ n = ab;
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_EOR_A_B_A);
+ return n;
+ } else if (ab == b) {
+ /* (a ^ b) ^ b -> a */
+ n = aa;
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_EOR_A_B_A);
+ return n;
+ }
+ }
+ if (is_Eor(b)) {
+ ir_node *ba = get_Eor_left(b);
+ ir_node *bb = get_Eor_right(b);
+
+ if (ba == a) {
+ /* a ^ (a ^ b) -> b */
+ n = bb;
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_EOR_A_B_A);
+ return n;
+ } else if (bb == a) {
+ /* a ^ (b ^ a) -> b */
+ n = ba;
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_EOR_A_B_A);
+ return n;
+ }
+ }
+
+ return n;
+}
/*
* Optimize a - 0 and (a - x) + x (for modes with wrap-around).
set_Conv_op(n, get_Conv_op(a));
return n;
}
- /* else both are strict conv, second is superflous */
+ /* else both are strict conv, second is superfluous */
} else if(is_Proj(a)) {
ir_node *pred = get_Proj_pred(a);
if(is_Load(pred)) {
*/
n = pred;
}
- if (pnc == pn_Cmp_Eq) {
- ir_node *bound = get_Confirm_bound(n);
-
- /*
- * Optimize a rare case:
- * Confirm(x, '=', Constlike) ==> Constlike
- */
- if (is_irn_constlike(bound)) {
- DBG_OPT_CONFIRM(n, bound);
- return bound;
- }
- }
- return get_opt_remove_confirm() ? get_Confirm_value(n) : n;
+ if (get_opt_remove_confirm())
+ return get_Confirm_value(n);
+ return n;
}
/**
}
}
}
+
return n;
} /* transform_node_AddSub */
b = get_Add_right(n);
mode = get_irn_mode(n);
+
+ if (mode_is_reference(mode)) {
+ ir_mode *lmode = get_irn_mode(a);
+
+ if (is_Const(b) && is_Const_null(b) && mode_is_int(lmode)) {
+ /* an Add(a, NULL) is a hidden Conv */
+ dbg_info *dbg = get_irn_dbg_info(n);
+ return new_rd_Conv(dbg, current_ir_graph, get_nodes_block(n), a, mode);
+ }
+ }
+
HANDLE_BINOP_PHI(tarval_add, a, b, c, mode);
/* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
if (mode_is_num(mode)) {
/* the following code leads to endless recursion when Mul are replaced by a simple instruction chain */
if (!is_arch_dep_running() && a == b && mode_is_int(mode)) {
- ir_node *block = get_irn_n(n, -1);
+ ir_node *block = get_nodes_block(n);
n = new_rd_Mul(
get_irn_dbg_info(n),
mode = get_irn_mode(n);
+ if (mode_is_int(mode)) {
+ ir_mode *lmode = get_irn_mode(a);
+
+ if (is_Const(b) && is_Const_null(b) && mode_is_reference(lmode)) {
+ /* a Sub(a, NULL) is a hidden Conv */
+ dbg_info *dbg = get_irn_dbg_info(n);
+ return new_rd_Conv(dbg, current_ir_graph, get_nodes_block(n), a, mode);
+ }
+ }
+
restart:
HANDLE_BINOP_PHI(tarval_sub, a, b, c, mode);
if (is_Const(b)) {
tarval *tv = get_Const_tarval(b);
+ int rem;
+ /*
+ * Floating point constant folding might be disabled here to
+ * prevent rounding.
+ * However, as we check for exact result, doing it is safe.
+ * Switch it on.
+ */
+ rem = tarval_enable_fp_ops(1);
tv = tarval_quo(get_mode_one(mode), tv);
+ (void)tarval_enable_fp_ops(rem);
/* Do the transformation if the result is either exact or we are not
using strict rules. */
static ir_node *transform_node_Mux(ir_node *n) {
ir_node *oldn = n, *sel = get_Mux_sel(n);
ir_mode *mode = get_irn_mode(n);
+ ir_node *t = get_Mux_true(n);
+ ir_node *f = get_Mux_false(n);
+ ir_graph *irg = current_ir_graph;
+ ir_node *conds[1], *vals[2];
+
+ /* first normalization step: move a possible zero to the false case */
+ if (is_Proj(sel)) {
+ ir_node *cmp = get_Proj_pred(sel);
+ if (is_Cmp(cmp)) {
+ if (is_Const(t) && is_Const_null(t)) {
+ /* Psi(x, 0, y) => Psi(x, y, 0) */
+ pn_Cmp pnc = get_Proj_proj(sel);
+ sel = new_r_Proj(irg, get_nodes_block(cmp), cmp, mode_b,
+ get_negated_pnc(pnc, get_irn_mode(get_Cmp_left(cmp))));
+ conds[0] = sel;
+ vals[0] = f;
+ vals[1] = t;
+ n = new_rd_Psi(get_irn_dbg_info(n), irg, get_nodes_block(n), 1, conds, vals, mode);
+ t = vals[0];
+ f = vals[1];
+ }
+ }
+ }
+
+ /* note: after normalization, false can only happen on default */
if (mode == mode_b) {
- ir_node *t = get_Mux_true(n);
- ir_node *f = get_Mux_false(n);
dbg_info *dbg = get_irn_dbg_info(n);
- ir_node *block = get_irn_n(n, -1);
+ ir_node *block = get_nodes_block(n);
ir_graph *irg = current_ir_graph;
if (is_Const(t)) {
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_OR_BOOL);
return n;
}
- } else {
- ir_node* not_sel = new_rd_Not(dbg, irg, block, sel, mode_b);
- assert(tv_t == tarval_b_false);
- if (is_Const(f)) {
- /* Muxb(sel, false, true) = Not(sel) */
- assert(get_Const_tarval(f) == tarval_b_true);
- DBG_OPT_ALGSIM0(oldn, not_sel, FS_OPT_MUX_NOT_BOOL);
- return not_sel;
- } else {
- /* Muxb(sel, false, x) = And(Not(sel), x) */
- n = new_rd_And(dbg, irg, block, not_sel, f, mode_b);
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_ANDNOT_BOOL);
- return n;
- }
}
} else if (is_Const(f)) {
tarval *tv_f = get_Const_tarval(f);
}
}
- if (is_Proj(sel) && !mode_honor_signed_zeros(mode)) {
+ /* more normalization: try to normalize Mux(x, C1, C2) into Mux(x, +1/-1, 0) op C2 */
+ if (is_Const(t) && is_Const(f) && mode_is_int(mode)) {
+ tarval *a = get_Const_tarval(t);
+ tarval *b = get_Const_tarval(f);
+ tarval *null = get_tarval_null(mode);
+ tarval *diff, *min;
+
+ if (tarval_cmp(a, b) & pn_Cmp_Gt) {
+ diff = tarval_sub(a, b);
+ min = b;
+ } else {
+ diff = tarval_sub(b, a);
+ min = a;
+ }
+
+ if (diff == get_tarval_one(mode) && min != null) {
+ dbg_info *dbg = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ ir_graph *irg = current_ir_graph;
+
+
+ conds[0] = sel;
+ vals[0] = new_Const(mode, tarval_sub(a, min));
+ vals[1] = new_Const(mode, tarval_sub(b, min));
+ n = new_rd_Psi(dbg, irg, block, 1, conds, vals, mode);
+ n = new_rd_Add(dbg, irg, block, n, new_Const(mode, min), mode);
+ return n;
+ }
+ }
+
+ if (is_Proj(sel)) {
ir_node *cmp = get_Proj_pred(sel);
long pn = get_Proj_proj(sel);
- ir_node *f = get_Mux_false(n);
- ir_node *t = get_Mux_true(n);
/*
* Note: normalization puts the constant on the right side,
*
* 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.
+ * However, if +0 and -0 is handled differently, we cannot use the Abs/-Abs
+ * transformations.
*/
if (is_Cmp(cmp)) {
ir_node *cmp_r = get_Cmp_right(cmp);
if (is_Const(cmp_r) && is_Const_null(cmp_r)) {
- ir_node *block = get_irn_n(n, -1);
+ ir_node *block = get_nodes_block(n);
+ ir_node *cmp_l = get_Cmp_left(cmp);
- if (is_negated_value(f, t)) {
- ir_node *cmp_left = get_Cmp_left(cmp);
+ if (!mode_honor_signed_zeros(mode) && is_negated_value(f, t)) {
+ /* f = -t */
- /* Psi(a >= 0, a, -a) = Psi(a <= 0, -a, a) ==> Abs(a) */
- if ( (cmp_left == t && (pn == pn_Cmp_Ge || pn == pn_Cmp_Gt))
- || (cmp_left == f && (pn == pn_Cmp_Le || pn == pn_Cmp_Lt)))
+ if ( (cmp_l == t && (pn == pn_Cmp_Ge || pn == pn_Cmp_Gt))
+ || (cmp_l == f && (pn == pn_Cmp_Le || pn == pn_Cmp_Lt)))
{
+ /* Psi(a >/>= 0, a, -a) = Psi(a </<= 0, -a, a) ==> Abs(a) */
n = new_rd_Abs(get_irn_dbg_info(n), current_ir_graph, block,
- cmp_left, mode);
+ cmp_l, mode);
DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_ABS);
return n;
- /* Psi(a <= 0, a, -a) = Psi(a >= 0, -a, a) ==> -Abs(a) */
- } else if ((cmp_left == t && (pn == pn_Cmp_Le || pn == pn_Cmp_Lt))
- || (cmp_left == f && (pn == pn_Cmp_Ge || pn == pn_Cmp_Gt)))
+ } else if ((cmp_l == t && (pn == pn_Cmp_Le || pn == pn_Cmp_Lt))
+ || (cmp_l == f && (pn == pn_Cmp_Ge || pn == pn_Cmp_Gt)))
{
+ /* Psi(a </<= 0, a, -a) = Psi(a >/>= 0, -a, a) ==> -Abs(a) */
n = new_rd_Abs(get_irn_dbg_info(n), current_ir_graph, block,
- cmp_left, mode);
+ cmp_l, mode);
n = new_rd_Minus(get_irn_dbg_info(n), current_ir_graph,
block, n, mode);
DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_ABS);
return n;
}
}
+
+ if (mode_is_int(mode)) {
+ /* integer only */
+ if ((pn == pn_Cmp_Lg || pn == pn_Cmp_Eq) && is_And(cmp_l)) {
+ /* Psi((a & b) != 0, c, 0) */
+ ir_node *and_r = get_And_right(cmp_l);
+ ir_node *and_l;
+
+ if (and_r == t && f == cmp_r) {
+ if (is_Const(t) && tarval_is_single_bit(get_Const_tarval(t))) {
+ if (pn == pn_Cmp_Lg) {
+ /* Psi((a & 2^C) != 0, 2^C, 0) */
+ n = cmp_l;
+ } else {
+ /* Psi((a & 2^C) == 0, 2^C, 0) */
+ n = new_rd_Eor(get_irn_dbg_info(n), current_ir_graph,
+ block, cmp_l, t, mode);
+ }
+ return n;
+ }
+ }
+ if (is_Shl(and_r)) {
+ ir_node *shl_l = get_Shl_left(and_r);
+ if (is_Const(shl_l) && is_Const_one(shl_l)) {
+ if (and_r == t && f == cmp_r) {
+ if (pn == pn_Cmp_Lg) {
+ /* (a & (1 << n)) != 0, (1 << n), 0) */
+ n = cmp_l;
+ } else {
+ /* (a & (1 << n)) == 0, (1 << n), 0) */
+ n = new_rd_Eor(get_irn_dbg_info(n), current_ir_graph,
+ block, cmp_l, t, mode);
+ }
+ return n;
+ }
+ }
+ }
+ and_l = get_And_left(cmp_l);
+ if (is_Shl(and_l)) {
+ ir_node *shl_l = get_Shl_left(and_l);
+ if (is_Const(shl_l) && is_Const_one(shl_l)) {
+ if (and_l == t && f == cmp_r) {
+ if (pn == pn_Cmp_Lg) {
+ /* ((1 << n) & a) != 0, (1 << n), 0) */
+ n = cmp_l;
+ } else {
+ /* ((1 << n) & a) == 0, (1 << n), 0) */
+ n = new_rd_Eor(get_irn_dbg_info(n), current_ir_graph,
+ block, cmp_l, t, mode);
+ }
+ return n;
+ }
+ }
+ }
+ }
+ }
}
}
}