tarval_add(ta, tb);
return tarval_carry() ? get_mode_one(m) : get_mode_null(m);
} else {
- if ( (classify_tarval(ta) == TV_CLASSIFY_NULL)
- || (classify_tarval(tb) == TV_CLASSIFY_NULL))
+ if (tarval_is_null(ta) || tarval_is_null(tb))
return get_mode_null(m);
}
return tarval_bad;
if ((ta != tarval_bad) && (tb != tarval_bad)) {
return tarval_cmp(ta, tb) == pn_Cmp_Lt ? get_mode_one(m) : get_mode_null(m);
- } else if (classify_tarval(ta) == TV_CLASSIFY_NULL) {
+ } else if (tarval_is_null(ta)) {
return get_mode_null(m);
}
return tarval_bad;
if ((ta != tarval_bad) && (tb != tarval_bad)) {
return tarval_and (ta, tb);
} else {
- tarval *v;
-
- if ( (classify_tarval ((v = ta)) == TV_CLASSIFY_NULL)
- || (classify_tarval ((v = tb)) == TV_CLASSIFY_NULL)) {
- return v;
- }
+ if (tarval_is_null(ta)) return ta;
+ if (tarval_is_null(tb)) return tb;
}
return tarval_bad;
} /* computed_value_And */
if ((ta != tarval_bad) && (tb != tarval_bad)) {
return tarval_or (ta, tb);
} else {
- tarval *v;
- if ( (classify_tarval ((v = ta)) == TV_CLASSIFY_ALL_ONE)
- || (classify_tarval ((v = tb)) == TV_CLASSIFY_ALL_ONE)) {
- return v;
- }
+ if (tarval_is_all_one(ta)) return ta;
+ if (tarval_is_all_one(tb)) return tb;
}
return tarval_bad;
} /* computed_value_Or */
* which happens in this rare construction: NULL + 3.
* Then, a Conv would be needed which we cannot include here.
*/
- if (classify_tarval (tv) == TV_CLASSIFY_NULL) {
- if (get_irn_mode(on) == get_irn_mode(n)) {
- n = on;
+ if (tarval_is_null(tv) && get_irn_mode(on) == get_irn_mode(n)) {
+ n = on;
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
- }
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
}
return n;
ir_node *a = get_binop_left(n);
ir_node *b = get_binop_right(n);
- if (classify_tarval(value_of(b)) == TV_CLASSIFY_NULL) {
+ if (is_Const(b) && is_Const_null(b)) {
n = a;
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
b = get_Sub_right(n);
/* Beware: modes might be different */
- if (classify_tarval(value_of(b)) == TV_CLASSIFY_NULL) {
+ if (is_Const(b) && is_Const_null(b)) {
ir_node *a = get_Sub_left(n);
if (mode == get_irn_mode(a)) {
n = a;
ir_node *b = get_Mul_right(n);
/* Mul is commutative and has again an other neutral element. */
- if (classify_tarval(value_of(a)) == TV_CLASSIFY_ONE) {
+ if (is_Const(a) && is_Const_one(a)) {
n = b;
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_1);
- } else if (classify_tarval(value_of(b)) == TV_CLASSIFY_ONE) {
+ } else if (is_Const(b) && is_Const_one(b)) {
n = a;
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_1);
}
ir_node *b = get_Div_right(n);
/* Div is not commutative. */
- if (classify_tarval(value_of(b)) == TV_CLASSIFY_ONE) { /* div(x, 1) == x */
+ if (is_Const(b) && is_Const_one(b)) { /* div(x, 1) == x */
/* Turn Div into a tuple (mem, bad, a) */
ir_node *mem = get_Div_mem(n);
ir_node *blk = get_irn_n(n, -1);
ir_node *b = get_Quot_right(n);
/* Div is not commutative. */
- if (classify_tarval(value_of(b)) == TV_CLASSIFY_ONE) { /* Quot(x, 1) == x */
+ if (is_Const(b) && is_Const_one(b)) { /* Quot(x, 1) == x */
/* Turn Quot into a tuple (mem, jmp, bad, a) */
ir_node *mem = get_Quot_mem(n);
ir_node *blk = get_irn_n(n, -1);
ir_node *b = get_DivMod_right(n);
/* Div is not commutative. */
- if (classify_tarval(value_of(b)) == TV_CLASSIFY_ONE) { /* div(x, 1) == x */
+ if (is_Const(b) && is_Const_one(b)) { /* div(x, 1) == x */
/* Turn DivMod into a tuple (mem, jmp, bad, a, 0) */
ir_node *a = get_DivMod_left(n);
ir_node *mem = get_Div_mem(n);
if (a == b) {
n = a; /* Or has it's own neutral element */
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_OR);
- } else if (classify_tarval(value_of(a)) == TV_CLASSIFY_NULL) {
+ } else if (is_Const(a) && is_Const_null(a)) {
n = b;
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_OR);
- } else if (classify_tarval(value_of(b)) == TV_CLASSIFY_NULL) {
+ } else if (is_Const(b) && is_Const_null(b)) {
n = a;
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_OR);
}
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_AND);
return n;
}
- if (classify_tarval(value_of(a)) == TV_CLASSIFY_ALL_ONE) {
+ if (is_Const(a) && is_Const_all_one(a)) {
n = b;
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_AND);
return n;
}
- if (classify_tarval(value_of(b)) == TV_CLASSIFY_ALL_ONE) {
+ if (is_Const(b) && is_Const_all_one(b)) {
n = a;
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_AND);
return n;
* 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) {
+ 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 (get_irn_op(b) == op_Minus && get_Minus_op(b) == a) {
/* Mux(a CMP 0, -a, a) */
n = a;
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_TRANSFORM);
}
- } else if (classify_Const(b) == CNST_NULL) {
+ } 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 */
if (is_Not(a)) {
ir_node *op = get_Not_op(a);
- if (classify_Const(b) == CNST_ONE) {
+ if (is_Const(b) && is_Const_one(b)) {
/* ~x + 1 = -x */
ir_node *blk = get_irn_n(n, -1);
n = new_rd_Minus(get_irn_dbg_info(n), current_ir_graph, blk, op, mode);
}
/* Beware of Sub(P, P) which cannot be optimized into a simple Minus ... */
- if (mode_is_num(mode) && mode == get_irn_mode(a) && (classify_Const(a) == CNST_NULL)) {
+ if (mode_is_num(mode) && mode == get_irn_mode(a) && is_Const(a) && is_Const_null(a)) {
n = new_rd_Minus(
get_irn_dbg_info(n),
current_ir_graph,
} else if ((mode == mode_b)
&& (get_irn_op(a) == op_Proj)
&& (get_irn_mode(a) == mode_b)
- && (classify_tarval (value_of(b)) == TV_CLASSIFY_ONE)
+ && is_Const(b) && is_Const_one(b)
&& (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_irn_n(n, -1), get_Proj_pred(a),
mode_b, get_negated_pnc(get_Proj_proj(a), mode));
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_TO_NOT_BOOL);
- } else if ((mode == mode_b)
- && (classify_tarval (value_of(b)) == TV_CLASSIFY_ONE)) {
+ } else if (mode == mode_b && is_Const(b) && is_Const_one(b)) {
/* The Eor is a Not. Replace it by a Not. */
/* ????!!!Extend to bitfield 1111111. */
n = new_r_Not(current_ir_graph, get_irn_n(n, -1), a, mode_b);
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_NOT_CMP);
return n;
}
- if (op_a == op_Sub && classify_Const(get_Sub_right(a)) == CNST_ONE) {
- /* ~(x-1) = -x */
- ir_node *op = get_Sub_left(a);
- ir_node *blk = get_irn_n(n, -1);
- n = new_rd_Minus(get_irn_dbg_info(n), current_ir_graph, blk, op, get_irn_mode(n));
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_NOT_MINUS_1);
+ if (op_a == op_Sub) {
+ ir_node *sub_r = get_Sub_right(a);
+ if (is_Const(sub_r) && is_Const_one(sub_r)) {
+ /* ~(x-1) = -x */
+ ir_node *op = get_Sub_left(a);
+ ir_node *blk = get_irn_n(n, -1);
+ n = new_rd_Minus(get_irn_dbg_info(n), current_ir_graph, blk, op, get_irn_mode(n));
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_NOT_MINUS_1);
+ }
}
return n;
} /* transform_node_Not */
}
}
+ /* TODO extend to arbitrary constants */
+ if (is_Conv(left) && is_Const(right) && is_Const_null(right)) {
+ ir_mode* mode = get_irn_mode(left);
+ ir_node* op = get_Conv_op(left);
+ ir_mode* op_mode = get_irn_mode(op);
+
+ if (get_mode_size_bits(mode) > get_mode_size_bits(op_mode) &&
+ (mode_is_signed(mode) || !mode_is_signed(op_mode))) {
+ ir_node *null = new_Const(op_mode, get_mode_null(op_mode));
+ set_Cmp_left( n, op);
+ set_Cmp_right(n, null);
+ return proj;
+ }
+ }
+
/* remove Casts */
if (is_Cast(left))
left = get_Cast_op(left);
default:
break;
}
-
}
}
if (proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg) {
/* a-b == 0 ==> a == b, a-b != 0 ==> a != b */
- if (classify_tarval(tv) == TV_CLASSIFY_NULL && is_Sub(left)) {
+ if (tarval_is_null(tv) && is_Sub(left)) {
right =get_Sub_right(left);
left = get_Sub_left(left);
tv2 = get_Const_tarval(c2);
tv = tarval_or(tv1, tv2);
- if (classify_tarval(tv) == TV_CLASSIFY_ALL_ONE) {
- /* the AND does NOT clear a bit with isn't set be the OR */
+ if (tarval_is_all_one(tv)) {
+ /* the AND does NOT clear a bit with isn't set by the OR */
set_Or_left(or, or_l);
set_Or_right(or, c1);
tv4 = get_Const_tarval(c4);
tv = tarval_or(tv4, tv2);
- if (classify_tarval(tv) != TV_CLASSIFY_ALL_ONE) {
+ if (!tarval_is_all_one(tv)) {
/* have at least one 0 at the same bit position */
return or;
}
* However, if +0 and -0 is handled differently, we cannot use the first
* one.
*/
- if (get_irn_op(cmp) == op_Cmp
- && classify_Const(get_Cmp_right(cmp)) == CNST_NULL) {
- ir_node *block = get_irn_n(n, -1);
-
- if(is_negated_value(f, t)) {
- ir_node *cmp_left = get_Cmp_left(cmp);
-
- /* 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)))
- {
- n = new_rd_Abs(get_irn_dbg_info(n), current_ir_graph, block,
- cmp_left, 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)))
- {
- n = new_rd_Abs(get_irn_dbg_info(n), current_ir_graph, block,
- cmp_left, 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 (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);
+
+ if(is_negated_value(f, t)) {
+ ir_node *cmp_left = get_Cmp_left(cmp);
+
+ /* 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)))
+ {
+ n = new_rd_Abs(get_irn_dbg_info(n), current_ir_graph, block,
+ cmp_left, 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)))
+ {
+ n = new_rd_Abs(get_irn_dbg_info(n), current_ir_graph, block,
+ cmp_left, 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) && mode_is_signed(mode) &&
- get_mode_arithmetic(mode) == irma_twos_complement) {
- ir_node *x = get_Cmp_left(cmp);
+ 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 */
+ /* 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 ((pn == pn_Cmp_Lt || pn == pn_Cmp_Le) &&
- classify_Const(t) == CNST_ALL_ONE &&
- classify_Const(f) == CNST_NULL) {
+ if (mode == get_irn_mode(x)) {
/*
- * Mux(x:T </<= 0, 0, -1) -> Shrs(x, sizeof_bits(T) - 1)
- * Conditions:
- * T must be signed.
+ * 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.
*/
- n = new_rd_Shrs(get_irn_dbg_info(n),
- current_ir_graph, block, x,
+ if ((pn == pn_Cmp_Lt || pn == pn_Cmp_Le) &&
+ is_Const(t) && is_Const_all_one(t) &&
+ is_Const(f) && is_Const_null(f)) {
+ /*
+ * 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, FS_OPT_MUX_TO_SHR);
+ return n;
+ } else if ((pn == pn_Cmp_Gt || pn == pn_Cmp_Ge) &&
+ is_Const(t) && is_Const_one(t) &&
+ is_Const(f) && is_Const_null(f)) {
+ /*
+ * 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, FS_OPT_MUX_TO_SHR);
- return n;
- } else if ((pn == pn_Cmp_Gt || pn == 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, FS_OPT_MUX_TO_SHR);
- return n;
+ DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_SHR);
+ return n;
+ }
}
}
}
projects / libfirm / blobdiff