* Modified by: Goetz Lindenmaier
* Created:
* CVS-ID: $Id$
- * Copyright: (c) 1998-2003 Universität Karlsruhe
+ * Copyright: (c) 1998-2005 Universität Karlsruhe
* Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
*/
# include "irhooks.h"
# include "irarch.h"
# include "hashptr.h"
+# include "archop.h"
+# include "opt_polymorphy.h"
/* Make types visible to allow most efficient access */
# include "entity_t.h"
*/
static tarval *computed_value_Const(ir_node *n)
{
- return get_Const_tarval(n);
+ return get_Const_tarval(n);
}
/**
ab = get_Cmp_right(a);
proj_nr = get_Proj_proj(n);
- if (aa == ab && !mode_is_float(get_irn_mode(aa))) { /* 1.: */
+ if (aa == ab && (
+ !mode_is_float(get_irn_mode(aa)) || proj_nr == pn_Cmp_Lt || proj_nr == pn_Cmp_Gt)
+ ) { /* 1.: */
/* BEWARE: a == a is NOT always True for floating Point!!! */
/* This is a trick with the bits used for encoding the Cmp
Proj numbers, the following statement is not the same:
}
#endif
+/**
+ * Returns a equivalent block for another block.
+ * If the block has only one predecessor, this is
+ * the equivalent one. If the only predecessor of a block is
+ * the block itself, this is a dead block.
+ *
+ * If both predecessors of a block are the branches of a binary
+ * Cond, the equivalent block is Cond's block.
+ *
+ * If all predecessors of a block are bad or lies in a dead
+ * block, the current block is dead as well.
+ *
+ * Note, that blocks are NEVER turned into Bad's, instead
+ * the dead_block flag is set. So, never test for is_Bad(block),
+ * always use is_dead_Block(block).
+ */
static ir_node *equivalent_node_Block(ir_node *n)
{
ir_node *oldn = n;
+ int n_preds = get_Block_n_cfgpreds(n);
/* The Block constructor does not call optimize, but mature_immBlock
calls the optimization. */
This should be true, as the block is matured before optimize is called.
But what about Phi-cycles with the Phi0/Id that could not be resolved?
Remaining Phi nodes are just Ids. */
- if ((get_Block_n_cfgpreds(n) == 1) &&
- (get_irn_op(get_Block_cfgpred(n, 0)) == op_Jmp)) {
+ if ((n_preds == 1) && (get_irn_op(get_Block_cfgpred(n, 0)) == op_Jmp)) {
ir_node *predblock = get_nodes_block(get_Block_cfgpred(n, 0));
if (predblock == oldn) {
/* Jmp jumps into the block it is in -- deal self cycle. */
DBG_OPT_STG(oldn, n);
}
}
- else if ((get_Block_n_cfgpreds(n) == 1) &&
+ else if ((n_preds == 1) &&
(get_irn_op(skip_Proj(get_Block_cfgpred(n, 0))) == op_Cond)) {
ir_node *predblock = get_nodes_block(get_Block_cfgpred(n, 0));
if (predblock == oldn) {
DBG_OPT_DEAD(oldn, n);
}
}
- else if ((get_Block_n_cfgpreds(n) == 2) &&
+ else if ((n_preds == 2) &&
(get_opt_control_flow_weak_simplification())) {
/* Test whether Cond jumps twice to this block
@@@ we could do this also with two loops finding two preds from several ones. */
/**
* Er, a "symmetic unop", ie op(op(n)) = n.
+ *
+ * @fixme -(-a) == a, but might overflow two times.
+ * 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_symmetric_unop(ir_node *n)
{
/**
* A Cast may be removed if the type of the previous node
- * is already to type of the Cast.
+ * is already the type of the Cast.
*/
static ir_node *equivalent_node_Cast(ir_node *n) {
ir_node *pred = get_Cast_op(n);
*/
static ir_node *equivalent_node_Mux(ir_node *n)
{
- ir_node *sel = get_Mux_sel(n);
+ ir_node *oldn = n, *sel = get_Mux_sel(n);
tarval *ts = value_of(sel);
- if (ts == get_tarval_b_true())
- return get_Mux_true(n);
- else if (ts == get_tarval_b_false())
- return get_Mux_false(n);
- else if(get_Mux_false(n) == get_Mux_true(n))
- return get_Mux_true(n);
+ /* Mux(true, f, t) == t */
+ if (ts == get_tarval_b_true()) {
+ n = get_Mux_true(n);
+ DBG_OPT_ALGSIM0(oldn, n);
+ }
+ /* Mux(false, f, t) == f */
+ else if (ts == get_tarval_b_false()) {
+ n = get_Mux_false(n);
+ DBG_OPT_ALGSIM0(oldn, n);
+ }
+ /* Mux(v, x, x) == x */
+ else if (get_Mux_false(n) == get_Mux_true(n)) {
+ n = get_Mux_true(n);
+ DBG_OPT_ALGSIM0(oldn, n);
+ }
+ else if (get_irn_op(sel) == op_Proj && !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);
+
+ /*
+ * 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 (get_irn_op(cmp) == op_Cmp && get_Cmp_left(cmp) == a) {
+ if (classify_Const(get_Cmp_right(cmp)) == CNST_NULL) {
+ /* Mux(a CMP 0, X, a) */
+ if (get_irn_op(b) == op_Minus && 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;
+ DBG_OPT_ALGSIM0(oldn, n);
+ }
+ else if (proj_nr == pn_Cmp_Lg || proj_nr == pn_Cmp_Ne) {
+ /* Mux(a != 0, -a, a) ==> a */
+ n = a;
+ DBG_OPT_ALGSIM0(oldn, n);
+ }
+ }
+ else if (classify_Const(b) == CNST_NULL) {
+ /* 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;
+ DBG_OPT_ALGSIM0(oldn, n);
+ }
+ else if (proj_nr == pn_Cmp_Eq) {
+ /* Mux(a == 0, 0, a) ==> 0 */
+ n = b;
+ DBG_OPT_ALGSIM0(oldn, n);
+ }
+ }
+ }
+ }
+ }
+
+ return n;
+}
+
+/**
+ * Optimize -a CMP -b into b CMP a.
+ * This works only for for modes where unary Minus
+ * cannot Overflow.
+ * Note that two-complement integers can Overflow
+ * so it will NOT work.
+ */
+static ir_node *equivalent_node_Cmp(ir_node *n)
+{
+ ir_node *left = get_Cmp_left(n);
+ ir_node *right = get_Cmp_right(n);
+ if (get_irn_op(left) == op_Minus && get_irn_op(right) == op_Minus &&
+ !mode_overflow_on_unary_Minus(get_irn_mode(left))) {
+ left = get_Minus_op(left);
+ right = get_Minus_op(right);
+ set_Cmp_left(n, right);
+ set_Cmp_right(n, left);
+ }
return n;
}
CASE(Proj);
CASE(Id);
CASE(Mux);
+ CASE(Cmp);
default:
op->equivalent_node = NULL;
}
/**
* Transform AddP(P, ConvIs(Iu)), AddP(P, ConvIu(Is)) and
- * SubP(P, ConvIs(Iu)), SubP(P, ConvIu(Is)) if possible.
+ * SubP(P, ConvIs(Iu)), SubP(P, ConvIu(Is)).
+ * If possible, remove the Conv's.
*/
static ir_node *transform_node_AddSub(ir_node *n)
{
return n;
}
-#define transform_node_Add transform_node_AddSub
-
/**
- * Do the AddSub optimization, then Transform Sub(0,a) into Minus(a).
+ * Do the AddSub optimization, then Transform Add(a,a) into Mul(a, 2)
+ * if the mode is integer or float.
+ * Reassociation might fold this further.
*/
-static ir_node *transform_node_Sub(ir_node *n)
+static ir_node *transform_node_Add(ir_node *n)
{
ir_mode *mode;
+ ir_node *oldn = n;
n = transform_node_AddSub(n);
mode = get_irn_mode(n);
if (mode_is_num(mode)) {
- if (classify_Const(get_Sub_left(n)) == CNST_NULL) {
- n = new_rd_Minus(
+ ir_node *a = get_Add_left(n);
+
+ if (a == get_Add_right(n)) {
+ ir_node *block = get_nodes_block(n);
+
+ n = new_rd_Mul(
get_irn_dbg_info(n),
current_ir_graph,
- get_nodes_block(n),
- get_Sub_right(n),
+ block,
+ a,
+ new_r_Const_long(current_ir_graph, block, mode, 2),
mode);
+ DBG_OPT_ALGSIM0(oldn, n);
}
}
+ return n;
+}
+
+/**
+ * Do the AddSub optimization, then Transform Sub(0,a) into Minus(a).
+ */
+static ir_node *transform_node_Sub(ir_node *n)
+{
+ ir_mode *mode;
+ ir_node *oldn = n;
+
+ n = transform_node_AddSub(n);
+
+ mode = get_irn_mode(n);
+ if (mode_is_num(mode) && (classify_Const(get_Sub_left(n)) == CNST_NULL)) {
+ n = new_rd_Minus(
+ get_irn_dbg_info(n),
+ current_ir_graph,
+ get_nodes_block(n),
+ get_Sub_right(n),
+ mode);
+ DBG_OPT_ALGSIM0(oldn, n);
+ }
return n;
}
return arch_dep_replace_mul_with_shifts(n);
}
+/**
+ * transform a Div Node
+ */
static ir_node *transform_node_Div(ir_node *n)
{
tarval *tv = value_of(n);
/* BEWARE: it is NOT possible to optimize a/a to 1, as this may cause a exception */
- if (tv != tarval_bad)
+ if (tv != tarval_bad) {
value = new_Const(get_tarval_mode(tv), tv);
+
+ DBG_OPT_CSTEVAL(n, value);
+ }
else /* Try architecture dependand optimization */
value = arch_dep_replace_div_by_const(n);
return n;
}
+/**
+ * transform a Mod node
+ */
static ir_node *transform_node_Mod(ir_node *n)
{
tarval *tv = value_of(n);
/* BEWARE: it is NOT possible to optimize a%a to 0, as this may cause a exception */
- if (tv != tarval_bad)
+ if (tv != tarval_bad) {
value = new_Const(get_tarval_mode(tv), tv);
+
+ DBG_OPT_CSTEVAL(n, value);
+ }
else /* Try architecture dependand optimization */
value = arch_dep_replace_mod_by_const(n);
return n;
}
+/**
+ * transform a DivMod node
+ */
static ir_node *transform_node_DivMod(ir_node *n)
{
int evaluated = 0;
if (tb == get_mode_one(get_tarval_mode(tb))) {
b = new_Const (mode, get_mode_null(mode));
evaluated = 1;
- } else if (ta != tarval_bad) {
+
+ DBG_OPT_CSTEVAL(n, b);
+ }
+ else if (ta != tarval_bad) {
tarval *resa, *resb;
resa = tarval_div (ta, tb);
if (resa == tarval_bad) return n; /* Causes exception!!! Model by replacing through
a = new_Const (mode, resa);
b = new_Const (mode, resb);
evaluated = 1;
+
+ DBG_OPT_CSTEVAL(n, a);
+ DBG_OPT_CSTEVAL(n, b);
}
else { /* Try architecture dependand optimization */
arch_dep_replace_divmod_by_const(&a, &b, n);
return n;
}
+/**
+ * transform a Cond node
+ */
static ir_node *transform_node_Cond(ir_node *n)
{
/* Replace the Cond by a Jmp if it branches on a constant
*/
static ir_node *transform_node_Eor(ir_node *n)
{
+ ir_node *oldn = n;
ir_node *a = get_Eor_left(n);
ir_node *b = get_Eor_right(n);
&& (get_irn_op(a) == op_Proj)
&& (get_irn_mode(a) == mode_b)
&& (classify_tarval (value_of(b)) == TV_CLASSIFY_ONE)
- && (get_irn_op(get_Proj_pred(a)) == op_Cmp))
+ && (get_irn_op(get_Proj_pred(a)) == op_Cmp)) {
/* The Eor negates a Cmp. The Cmp has the negated result anyways! */
n = new_r_Proj(current_ir_graph, get_nodes_block(n), get_Proj_pred(a),
mode_b, get_negated_pnc(get_Proj_proj(a)));
+
+ DBG_OPT_ALGSIM0(oldn, n);
+ }
else if ((get_irn_mode(n) == mode_b)
- && (classify_tarval (value_of(b)) == TV_CLASSIFY_ONE))
+ && (classify_tarval (value_of(b)) == TV_CLASSIFY_ONE)) {
/* The Eor is a Not. Replace it by a Not. */
/* ????!!!Extend to bitfield 1111111. */
n = new_r_Not(current_ir_graph, get_nodes_block(n), a, mode_b);
+ DBG_OPT_ALGSIM0(oldn, n);
+ }
+
return n;
}
*/
static ir_node *transform_node_Not(ir_node *n)
{
+ ir_node *oldn = n;
ir_node *a = get_Not_op(n);
if ( (get_irn_mode(n) == mode_b)
&& (get_irn_op(a) == op_Proj)
&& (get_irn_mode(a) == mode_b)
- && (get_irn_op(get_Proj_pred(a)) == op_Cmp))
+ && (get_irn_op(get_Proj_pred(a)) == op_Cmp)) {
/* We negate a Cmp. The Cmp has the negated result anyways! */
n = new_r_Proj(current_ir_graph, get_nodes_block(n), get_Proj_pred(a),
mode_b, get_negated_pnc(get_Proj_proj(a)));
+ DBG_OPT_ALGSIM0(oldn, n);
+ }
return n;
}
* Transform a Cast of a Const into a new Const
*/
static ir_node *transform_node_Cast(ir_node *n) {
+ ir_node *oldn = n;
ir_node *pred = get_Cast_op(n);
- type *tp = get_irn_type(pred);
+ type *tp = get_irn_type(n);
if (get_irn_op(pred) == op_Const && get_Const_type(pred) != tp) {
n = new_rd_Const_type(NULL, current_ir_graph, get_nodes_block(pred), get_irn_mode(pred),
get_Const_tarval(pred), tp);
+ DBG_OPT_CSTEVAL(oldn, n);
} else if ((get_irn_op(pred) == op_SymConst) && (get_SymConst_value_type(pred) != tp)) {
n = new_rd_SymConst_type(NULL, current_ir_graph, get_nodes_block(pred), get_SymConst_symbol(pred),
get_SymConst_kind(pred), tp);
+ DBG_OPT_CSTEVAL(oldn, n);
}
+
return n;
}
/**
- * Transform a Div/Mod/DivMod with a non-zero constant. Must be
- * done here instead of equivalent node because it creates new
- * nodes.
+ * Does all optimizations on nodes that must be done on it's Proj's
+ * because of creating new nodes.
+ *
+ * Transform a Div/Mod/DivMod with a non-zero constant.
* Removes the exceptions and routes the memory to the NoMem node.
*
- * Further, it optimizes jump tables by removing all impossible cases.
+ * Optimizes jump tables by removing all impossible cases.
+ *
+ * Normalizes and optimizes Cmp nodes.
*/
static ir_node *transform_node_Proj(ir_node *proj)
{
}
return proj;
+ case iro_Cmp:
+ if (get_opt_reassociation()) {
+ ir_node *left = get_Cmp_left(n);
+ ir_node *right = get_Cmp_right(n);
+ ir_node *c = NULL;
+ tarval *tv = NULL;
+ int changed = 0;
+ ir_mode *mode = NULL;
+
+ proj_nr = get_Proj_proj(proj);
+
+ /*
+ * First step: normalize the compare op
+ * by placing the constant on the right site
+ * or moving the lower address node to the left.
+ * We ignore the case that both are constants, then
+ * this compare should be optimized away.
+ */
+ if (get_irn_op(right) == op_Const)
+ c = right;
+ else if (get_irn_op(left) == op_Const) {
+ c = left;
+ left = right;
+ right = c;
+
+ proj_nr = get_swapped_pnc(proj_nr);
+ changed |= 1;
+ }
+ else if (left > right) {
+ ir_node *t = left;
+
+ left = right;
+ right = t;
+
+ proj_nr = get_swapped_pnc(proj_nr);
+ changed |= 1;
+ }
+
+ /*
+ * Second step: Try to reduce the magnitude
+ * of a constant. This may help to generate better code
+ * later and may help to normalize more compares.
+ * Of course this is only possible for integer values.
+ */
+ if (c) {
+ mode = get_irn_mode(c);
+ tv = get_Const_tarval(c);
+
+ if (tv != tarval_bad) {
+ /* the following optimization is possibe on modes without Overflow
+ * on Unary Minus or on == and !=:
+ * -a CMP c ==> a swap(CMP) -c
+ *
+ * Beware: for two-complement Overflow may occur, so only == and != can
+ * be optimized, see this:
+ * -MININT < 0 =/=> MININT > 0 !!!
+ */
+ if (get_opt_constant_folding() && get_irn_op(left) == op_Minus &&
+ (!mode_overflow_on_unary_Minus(mode) ||
+ (mode_is_int(mode) && (proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg)))) {
+ left = get_Minus_op(left);
+ tv = tarval_sub(get_tarval_null(mode), tv);
+
+ proj_nr = get_swapped_pnc(proj_nr);
+ changed |= 2;
+ }
+
+ /* for integer modes, we have more */
+ if (mode_is_int(mode)) {
+ /* Ne includes Unordered which is not possible on integers.
+ * However, frontends often use this wrong, so fix it here */
+ if (proj_nr == pn_Cmp_Ne) {
+ proj_nr = pn_Cmp_Lg;
+ set_Proj_proj(proj, proj_nr);
+ }
+
+ /* c > 0 : a < c ==> a <= (c-1) a >= c ==> a > (c-1) */
+ if ((proj_nr == pn_Cmp_Lt || proj_nr == pn_Cmp_Ge) &&
+ tarval_cmp(tv, get_tarval_null(mode)) == pn_Cmp_Gt) {
+ tv = tarval_sub(tv, get_tarval_one(mode));
+
+ proj_nr ^= pn_Cmp_Eq;
+ changed |= 2;
+ }
+ /* c < 0 : a > c ==> a >= (c+1) a <= c ==> a < (c+1) */
+ else if ((proj_nr == pn_Cmp_Gt || proj_nr == pn_Cmp_Le) &&
+ tarval_cmp(tv, get_tarval_null(mode)) == pn_Cmp_Lt) {
+ tv = tarval_add(tv, get_tarval_one(mode));
+
+ proj_nr ^= pn_Cmp_Eq;
+ changed |= 2;
+ }
+
+ /* the following reassociations work only for == and != */
+
+ /* a-b == 0 ==> a == b, a-b != 0 ==> a != b */
+ if (classify_tarval(tv) == TV_CLASSIFY_NULL && get_irn_op(left) == op_Sub) {
+ if (proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg) {
+ right = get_Sub_right(left);
+ left = get_Sub_left(left);
+
+ tv = value_of(right);
+ changed = 1;
+ }
+ }
+
+ if ((tv != tarval_bad) && (proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg)) {
+ ir_op *op = get_irn_op(left);
+
+ /* a-c1 == c2 ==> a == c2+c1, a-c1 != c2 ==> a != c2+c1 */
+ if (op == op_Sub) {
+ ir_node *c1 = get_Sub_right(left);
+ tarval *tv2 = value_of(c1);
+
+ if (tv2 != tarval_bad) {
+ tv2 = tarval_add(tv, value_of(c1));
+
+ if (tv2 != tarval_bad) {
+ left = get_Sub_left(left);
+ tv = tv2;
+ changed = 2;
+ }
+ }
+ }
+ /* a+c1 == c2 ==> a == c2-c1, a+c1 != c2 ==> a != c2-c1 */
+ else if (op == op_Add) {
+ ir_node *a_l = get_Add_left(left);
+ ir_node *a_r = get_Add_right(left);
+ ir_node *a;
+ tarval *tv2;
+
+ if (get_irn_op(a_l) == op_Const) {
+ a = a_r;
+ tv2 = value_of(a_l);
+ }
+ else {
+ a = a_l;
+ tv2 = value_of(a_r);
+ }
+
+ if (tv2 != tarval_bad) {
+ tv2 = tarval_sub(tv, tv2);
+
+ if (tv2 != tarval_bad) {
+ left = a;
+ tv = tv2;
+ changed = 2;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (changed) {
+ ir_node *block = get_nodes_block(n);
+
+ if (changed & 2) /* need a new Const */
+ right = new_Const(mode, tv);
+
+ /* create a new compare */
+ n = new_rd_Cmp(get_irn_dbg_info(n), current_ir_graph, block,
+ left, right);
+
+ set_Proj_pred(proj, n);
+ set_Proj_proj(proj, proj_nr);
+ }
+ }
+ return proj;
+
case iro_Tuple:
/* should not happen, but if it does will be optimized away */
break;
{
ir_mode *mode = get_irn_mode(or);
ir_node *shl, *shr, *block;
- ir_node *irn, *x, *c1, *c2, *v, *sub;
+ ir_node *irn, *x, *c1, *c2, *v, *sub, *n;
tarval *tv1, *tv2;
if (! mode_is_int(mode))
/* yet, condition met */
block = get_nodes_block(or);
- return new_r_Rot(current_ir_graph, block, x, c1, mode);
+ n = new_r_Rot(current_ir_graph, block, x, c1, mode);
+
+ DBG_OPT_ALGSIM1(or, shl, shr, n);
+ return n;
}
else if (get_irn_op(c1) == op_Sub) {
v = c2;
block = get_nodes_block(or);
/* a Rot right is not supported, so use a rot left */
- return new_r_Rot(current_ir_graph, block, x, sub, mode);
+ n = new_r_Rot(current_ir_graph, block, x, sub, mode);
+
+ DBG_OPT_ALGSIM0(or, n);
+ return n;
}
else if (get_irn_op(c2) == op_Sub) {
v = c1;
block = get_nodes_block(or);
/* a Rot Left */
- return new_r_Rot(current_ir_graph, block, x, v, mode);
+ n = new_r_Rot(current_ir_graph, block, x, v, mode);
+
+ DBG_OPT_ALGSIM0(or, n);
+ return n;
}
return or;
/**
* Optimize (a >> c1) >> c2), works for Shr, Shrs, Shl
*/
-static ir_node * transform_node_shift(ir_node *n)
+static ir_node *transform_node_shift(ir_node *n)
{
- ir_node *left;
+ ir_node *left, *right;
tarval *tv1, *tv2, *res;
ir_mode *mode;
int modulo_shf, flag;
if (get_irn_op(left) != get_irn_op(n))
return n;
- tv1 = value_of(get_binop_right(n));
+ right = get_binop_right(n);
+ tv1 = value_of(right);
if (tv1 == tarval_bad)
return n;
irn = new_ir_node(NULL, current_ir_graph, block, get_irn_op(n), mode, 2, in);
+ DBG_OPT_ALGSIM0(n, irn);
+
return transform_node(irn);
}
return n;
}
-static ir_node * transform_node_End(ir_node *n) {
+#define transform_node_Shr transform_node_shift
+#define transform_node_Shrs transform_node_shift
+#define transform_node_Shl transform_node_shift
+
+/**
+ * Remove dead blocks in keepalive list. We do not generate a new End node.
+ */
+static ir_node *transform_node_End(ir_node *n) {
int i, n_keepalives = get_End_n_keepalives(n);
- /* Remove dead blocks in keepalive list.
- We do not generate a new End node. */
for (i = 0; i < n_keepalives; ++i) {
ir_node *ka = get_End_keepalive(n, i);
if (is_Block(ka) && is_Block_dead(ka))
return n;
}
+/**
+ * Optimize a Mux into some simplier cases.
+ */
+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);
+
+ if (get_irn_op(sel) == op_Proj && !mode_honor_signed_zeros(mode)) {
+ ir_node *cmp = get_Proj_pred(sel);
+ long proj_nr = get_Proj_proj(sel);
+ ir_node *f = get_Mux_false(n);
+ ir_node *t = get_Mux_true(n);
+
+ if (get_irn_op(cmp) == op_Cmp && classify_Const(get_Cmp_right(cmp)) == CNST_NULL) {
+ ir_node *block = get_nodes_block(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 (get_irn_op(f) == op_Minus &&
+ get_Minus_op(f) == t &&
+ get_Cmp_left(cmp) == t) {
+
+ if (proj_nr == pn_Cmp_Ge || proj_nr == pn_Cmp_Gt) {
+ /* Mux(a >=/> 0, -a, a) ==> Abs(a) */
+ n = new_rd_Abs(get_irn_dbg_info(n),
+ current_ir_graph,
+ block,
+ t, mode);
+ DBG_OPT_ALGSIM1(oldn, cmp, sel, n);
+ return n;
+ }
+ else if (proj_nr == pn_Cmp_Le || proj_nr == pn_Cmp_Lt) {
+ /* Mux(a <=/< 0, -a, a) ==> Minus(Abs(a)) */
+ n = new_rd_Abs(get_irn_dbg_info(n),
+ current_ir_graph,
+ block,
+ t, mode);
+ n = new_rd_Minus(get_irn_dbg_info(n),
+ current_ir_graph,
+ block,
+ n, mode);
+
+ DBG_OPT_ALGSIM1(oldn, cmp, sel, n);
+ return n;
+ }
+ }
+ else if (get_irn_op(t) == op_Minus &&
+ get_Minus_op(t) == f &&
+ get_Cmp_left(cmp) == f) {
+
+ if (proj_nr == pn_Cmp_Le || proj_nr == pn_Cmp_Lt) {
+ /* Mux(a <=/< 0, a, -a) ==> Abs(a) */
+ n = new_rd_Abs(get_irn_dbg_info(n),
+ current_ir_graph,
+ block,
+ f, mode);
+ DBG_OPT_ALGSIM1(oldn, cmp, sel, n);
+ return n;
+ }
+ else if (proj_nr == pn_Cmp_Ge || proj_nr == pn_Cmp_Gt) {
+ /* Mux(a >=/> 0, a, -a) ==> Minus(Abs(a)) */
+ n = new_rd_Abs(get_irn_dbg_info(n),
+ current_ir_graph,
+ block,
+ f, mode);
+ n = new_rd_Minus(get_irn_dbg_info(n),
+ current_ir_graph,
+ block,
+ n, mode);
+
+ DBG_OPT_ALGSIM1(oldn, cmp, sel, n);
+ return n;
+ }
+ }
+
+ if (mode_is_int(mode) && mode_is_signed(mode) &&
+ get_mode_arithmetic(mode) == irma_twos_complement) {
+ ir_node *x = get_Cmp_left(cmp);
+
+ /* the following optimization works only with signed integer two-complement mode */
+
+ if (mode == get_irn_mode(x)) {
+ /*
+ * FIXME: this restriction is two rigid, as it would still
+ * work if mode(x) = Hs and mode == Is, but at least it removes
+ * all wrong cases.
+ */
+ if ((proj_nr == pn_Cmp_Lt || proj_nr == pn_Cmp_Le) &&
+ classify_Const(t) == CNST_ALL_ONE &&
+ classify_Const(f) == CNST_NULL) {
+ /*
+ * Mux(x:T </<= 0, 0, -1) -> Shrs(x, sizeof_bits(T) - 1)
+ * Conditions:
+ * T must be signed.
+ */
+ n = new_rd_Shrs(get_irn_dbg_info(n),
+ current_ir_graph, block, x,
+ new_r_Const_long(current_ir_graph, block, mode_Iu,
+ get_mode_size_bits(mode) - 1),
+ mode);
+ DBG_OPT_ALGSIM1(oldn, cmp, sel, n);
+ return n;
+ }
+ else if ((proj_nr == pn_Cmp_Gt || proj_nr == pn_Cmp_Ge) &&
+ classify_Const(t) == CNST_ONE &&
+ classify_Const(f) == CNST_NULL) {
+ /*
+ * Mux(x:T >/>= 0, 0, 1) -> Shr(-x, sizeof_bits(T) - 1)
+ * Conditions:
+ * T must be signed.
+ */
+ n = new_rd_Shr(get_irn_dbg_info(n),
+ current_ir_graph, block,
+ new_r_Minus(current_ir_graph, block, x, mode),
+ new_r_Const_long(current_ir_graph, block, mode_Iu,
+ get_mode_size_bits(mode) - 1),
+ mode);
+ DBG_OPT_ALGSIM1(oldn, cmp, sel, n);
+ return n;
+ }
+ }
+ }
+ }
+ }
+ return arch_transform_node_Mux(n);
+}
/**
* Tries several [inplace] [optimizing] transformations and returns an
CASE(Not);
CASE(Cast);
CASE(Proj);
+ CASE(Sel);
CASE(Or);
+ CASE(Shr);
+ CASE(Shrs);
+ CASE(Shl);
CASE(End);
- case iro_Shr:
- case iro_Shrs:
- case iro_Shl:
- op->transform_node = transform_node_shift;
- break;
+ CASE(Mux);
default:
- op->transform_node = NULL;
+ op->transform_node = NULL;
}
return op;
free the node. */
iro = get_irn_opcode(n);
if (get_opt_constant_folding() ||
- (iro == iro_Cond) ||
- (iro == iro_Proj)) /* Flags tested local. */
- n = transform_node (n);
+ (iro == iro_Cond) ||
+ (iro == iro_Proj) ||
+ (iro == iro_Sel)) /* Flags tested local. */
+ n = transform_node (n);
/* Remove nodes with dead (Bad) input.
- Run always for transformation induced Bads. */
+ Run always for transformation induced Bads. */
n = gigo (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)) {
- n = identify_remember (current_ir_graph->value_table, n);
+ n = identify_remember (current_ir_graph->value_table, n);
}
return n;
iro = get_irn_opcode(n);
if (get_opt_constant_folding() ||
(iro == iro_Cond) ||
- (iro == iro_Proj)) /* Flags tested local. */
+ (iro == iro_Proj) ||
+ (iro == iro_Sel)) /* Flags tested local. */
n = transform_node (n);
/* Remove nodes with dead (Bad) input.
projects / libfirm / blobdiff