/*
- * Copyright (C) 1995-2010 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
- return tarval_cmp(ta, tb) == pn_Cmp_Lt ? get_mode_one(m) : get_mode_null(m);
+ return tarval_cmp(ta, tb) == ir_relation_less ? get_mode_one(m) : get_mode_null(m);
} else if (tarval_is_null(ta)) {
return get_mode_null(m);
}
*/
static ir_tarval *computed_value_Confirm(const ir_node *n)
{
- if (get_Confirm_cmp(n) == pn_Cmp_Eq) {
+ if (get_Confirm_relation(n) == ir_relation_equal) {
ir_tarval *tv = value_of(get_Confirm_bound(n));
if (tv != tarval_bad)
return tv;
} /* computed_value_Confirm */
/**
- * Return the value of a Proj(Cmp).
- *
- * This performs a first step of unreachable code elimination.
- * Proj can not be computed, but folding a Cmp above the Proj here is
- * not as wasteful as folding a Cmp into a Tuple of 16 Consts of which
- * only 1 is used.
- * There are several case where we can evaluate a Cmp node, see later.
+ * gives a (conservative) estimation of possible relation when comparing
+ * left+right
*/
-static ir_tarval *computed_value_Proj_Cmp(const ir_node *n)
+ir_relation ir_get_possible_cmp_relations(const ir_node *left,
+ const ir_node *right)
{
- ir_node *cmp = get_Proj_pred(n);
- ir_node *left = get_Cmp_left(cmp);
- ir_node *right = get_Cmp_right(cmp);
- pn_Cmp pn_cmp = get_Proj_pn_cmp(n);
- ir_mode *mode = get_irn_mode(left);
- ir_tarval *tv_l, *tv_r;
-
- /*
- * BEWARE: a == a is NOT always True for floating Point values, as
- * NaN != NaN is defined, so we must check this here.
- */
- if (left == right && (!mode_is_float(mode) || pn_cmp == pn_Cmp_Lt || pn_cmp == pn_Cmp_Gt)) {
- /* This is a trick with the bits used for encoding the Cmp
- Proj numbers, the following statement is not the same:
- return new_tarval_from_long(pn_cmp == pn_Cmp_Eq, mode_b) */
- return new_tarval_from_long(pn_cmp & pn_Cmp_Eq, mode_b);
- }
- tv_l = value_of(left);
- tv_r = value_of(right);
+ ir_relation possible = ir_relation_true;
+ ir_tarval *tv_l = value_of(left);
+ ir_tarval *tv_r = value_of(right);
+ ir_mode *mode = get_irn_mode(left);
+ ir_tarval *min = mode == mode_b ? tarval_b_false : get_mode_min(mode);
+ ir_tarval *max = mode == mode_b ? tarval_b_true : get_mode_max(mode);
+ /* both values known - evaluate them */
if ((tv_l != tarval_bad) && (tv_r != tarval_bad)) {
- /*
- * The predecessors of Cmp are target values. We can evaluate
- * the Cmp.
- */
- pn_Cmp flags = tarval_cmp(tv_l, tv_r);
- if (flags != pn_Cmp_False) {
- return new_tarval_from_long (pn_cmp & flags, mode_b);
- }
- } else if (mode_is_int(mode)) {
- /* for integer values, we can check against MIN/MAX */
- pn_Cmp cmp_result;
-
- if (tv_l == get_mode_min(mode)) {
- /* MIN <=/> x. This results in true/false. */
- if (pn_cmp == pn_Cmp_Le)
- return tarval_b_true;
- else if (pn_cmp == pn_Cmp_Gt)
- return tarval_b_false;
- } else if (tv_r == get_mode_min(mode)) {
- /* x >=/< MIN. This results in true/false. */
- if (pn_cmp == pn_Cmp_Ge)
- return tarval_b_true;
- else if (pn_cmp == pn_Cmp_Lt)
- return tarval_b_false;
- } else if (tv_l == get_mode_max(mode)) {
- /* MAX >=/< x. This results in true/false. */
- if (pn_cmp == pn_Cmp_Ge)
- return tarval_b_true;
- else if (pn_cmp == pn_Cmp_Lt)
- return tarval_b_false;
- } else if (tv_r == get_mode_max(mode)) {
- /* x <=/> MAX. This results in true/false. */
- if (pn_cmp == pn_Cmp_Le)
- return tarval_b_true;
- else if (pn_cmp == pn_Cmp_Gt)
- return tarval_b_false;
- }
-
- cmp_result = vrp_cmp(left, right);
- if (cmp_result != pn_Cmp_False) {
- if (cmp_result == pn_Cmp_Lg) {
- if (pn_cmp == pn_Cmp_Eq) {
- return tarval_b_false;
- } else if (pn_cmp == pn_Cmp_Lg) {
- return tarval_b_true;
- }
- } else {
- return new_tarval_from_long(cmp_result & pn_cmp, mode_b);
- }
- }
- } else if (mode_is_reference(mode)) {
- /* pointer compare */
- ir_node *s_l = skip_Proj(left);
- ir_node *s_r = skip_Proj(right);
-
- if ((is_Alloc(s_l) && tarval_is_null(tv_r)) ||
- (tarval_is_null(tv_l) && is_Alloc(s_r))) {
- /*
- * The predecessors are Allocs and (void*)(0) constants. In Firm Allocs never
- * return NULL, they raise an exception. Therefore we can predict
- * the Cmp result.
- */
- return new_tarval_from_long(pn_cmp & pn_Cmp_Lg, mode_b);
- }
- }
- return computed_value_Cmp_Confirm(cmp, left, right, pn_cmp);
-} /* computed_value_Proj_Cmp */
+ possible = tarval_cmp(tv_l, tv_r);
+ /* we can return now, won't get any better */
+ return possible;
+ }
+ /* a == a is never less or greater (but might be equal or unordered) */
+ if (left == right)
+ possible &= ~ir_relation_less_greater;
+ /* unordered results only happen for float compares */
+ if (!mode_is_float(mode))
+ possible &= ~ir_relation_unordered;
+ /* values can never be less than the least representable number or
+ * greater than the greatest representable number */
+ if (tv_l == min)
+ possible &= ~ir_relation_greater;
+ if (tv_l == max)
+ possible &= ~ir_relation_less;
+ if (tv_r == max)
+ possible &= ~ir_relation_greater;
+ if (tv_r == min)
+ possible &= ~ir_relation_less;
+ /* maybe vrp can tell us more */
+ possible &= vrp_cmp(left, right);
+ /* Alloc nodes never return null (but throw an exception) */
+ if (is_Alloc(left) && tarval_is_null(tv_r))
+ possible &= ~ir_relation_equal;
+
+ return possible;
+}
/**
- * Return the value of a floating point Quot.
+ * Return the value of a Cmp.
+ *
+ * The basic idea here is to determine which relations are possible and which
+ * one are definitely impossible.
*/
-static ir_tarval *do_computed_value_Quot(const ir_node *a, const ir_node *b)
+static ir_tarval *computed_value_Cmp(const ir_node *cmp)
{
- ir_tarval *ta = value_of(a);
- ir_tarval *tb = value_of(b);
+ ir_node *left = get_Cmp_left(cmp);
+ ir_node *right = get_Cmp_right(cmp);
+ ir_relation possible = ir_get_possible_cmp_relations(left, right);
+ ir_relation relation = get_Cmp_relation(cmp);
- /* cannot optimize 0 / b = 0 because of NaN */
- if (ta != tarval_bad && tb != tarval_bad)
- return tarval_quo(ta, tb);
- return tarval_bad;
-} /* do_computed_value_Quot */
+ /* if none of the requested relations is possible, return false */
+ if ((possible & relation) == ir_relation_false)
+ return tarval_b_false;
+ /* if possible relations are a subset of the requested ones return true */
+ if ((possible & ~relation) == ir_relation_false)
+ return tarval_b_true;
+
+ return computed_value_Cmp_Confirm(cmp, left, right, relation);
+}
/**
- * Calculate the value of an integer Div of two nodes.
+ * Calculate the value of an integer Div.
* Special case: 0 / b
*/
-static ir_tarval *do_computed_value_Div(const ir_node *a, const ir_node *b)
+static ir_tarval *do_computed_value_Div(const ir_node *div)
{
- ir_tarval *ta = value_of(a);
+ const ir_node *a = get_Div_left(div);
+ const ir_node *b = get_Div_right(div);
+ const ir_mode *mode = get_Div_resmode(div);
+ ir_tarval *ta = value_of(a);
ir_tarval *tb;
const ir_node *dummy;
- /* Compute c1 / c2 or 0 / a, a != 0 */
- if (tarval_is_null(ta) && value_not_zero(b, &dummy))
- return ta; /* 0 / b == 0 */
+ /* cannot optimize 0 / b = 0 because of NaN */
+ if (!mode_is_float(mode)) {
+ if (tarval_is_null(ta) && value_not_zero(b, &dummy))
+ return ta; /* 0 / b == 0 if b != 0 */
+ }
tb = value_of(b);
if (ta != tarval_bad && tb != tarval_bad)
return tarval_div(ta, tb);
return tarval_bad;
} /* do_computed_value_Mod */
-/**
- * Return the value of a Proj(DivMod).
- */
-static ir_tarval *computed_value_Proj_DivMod(const ir_node *n)
-{
- long proj_nr = get_Proj_proj(n);
-
- /* compute either the Div or the Mod part */
- if (proj_nr == pn_DivMod_res_div) {
- const ir_node *a = get_Proj_pred(n);
- return do_computed_value_Div(get_DivMod_left(a), get_DivMod_right(a));
- } else if (proj_nr == pn_DivMod_res_mod) {
- const ir_node *a = get_Proj_pred(n);
- return do_computed_value_Mod(get_DivMod_left(a), get_DivMod_right(a));
- }
- return tarval_bad;
-} /* computed_value_Proj_DivMod */
-
/**
* Return the value of a Proj(Div).
*/
static ir_tarval *computed_value_Proj_Div(const ir_node *n)
{
long proj_nr = get_Proj_proj(n);
+ if (proj_nr != pn_Div_res)
+ return tarval_bad;
- if (proj_nr == pn_Div_res) {
- const ir_node *a = get_Proj_pred(n);
- return do_computed_value_Div(get_Div_left(a), get_Div_right(a));
- }
- return tarval_bad;
+ return do_computed_value_Div(get_Proj_pred(n));
} /* computed_value_Proj_Div */
/**
long proj_nr = get_Proj_proj(n);
if (proj_nr == pn_Mod_res) {
- const ir_node *a = get_Proj_pred(n);
- return do_computed_value_Mod(get_Mod_left(a), get_Mod_right(a));
+ const ir_node *mod = get_Proj_pred(n);
+ return do_computed_value_Mod(get_Mod_left(mod), get_Mod_right(mod));
}
return tarval_bad;
} /* computed_value_Proj_Mod */
-/**
- * Return the value of a Proj(Quot).
- */
-static ir_tarval *computed_value_Proj_Quot(const ir_node *n)
-{
- long proj_nr = get_Proj_proj(n);
-
- if (proj_nr == pn_Quot_res) {
- const ir_node *a = get_Proj_pred(n);
- return do_computed_value_Quot(get_Quot_left(a), get_Quot_right(a));
- }
- return tarval_bad;
-} /* computed_value_Proj_Quot */
-
/**
* Return the value of a Proj.
*/
ir_tarval *computed_value(const ir_node *n)
{
vrp_attr *vrp = vrp_get_info(n);
- if (vrp && vrp->valid && tarval_cmp(vrp->bits_set, vrp->bits_not_set) == pn_Cmp_Eq) {
+ if (vrp && vrp->valid && tarval_cmp(vrp->bits_set, vrp->bits_not_set) == ir_relation_equal) {
return vrp->bits_set;
}
if (n->op->ops.computed_value)
break
switch (code) {
- CASE(Const);
- CASE(SymConst);
CASE(Add);
- CASE(Sub);
- CASE(Carry);
+ CASE(And);
CASE(Borrow);
+ CASE(Carry);
+ CASE(Cmp);
+ CASE(Confirm);
+ CASE(Const);
+ CASE(Conv);
+ CASE(Eor);
CASE(Minus);
CASE(Mul);
- CASE(And);
- CASE(Or);
- CASE(Eor);
+ CASE(Mux);
CASE(Not);
+ CASE(Or);
+ CASE(Proj);
+ CASE(Rotl);
CASE(Shl);
CASE(Shr);
CASE(Shrs);
- CASE(Rotl);
- CASE(Conv);
- CASE(Mux);
- CASE(Confirm);
- CASE_PROJ(Cmp);
- CASE_PROJ(DivMod);
+ CASE(Sub);
+ CASE(SymConst);
CASE_PROJ(Div);
CASE_PROJ(Mod);
- CASE_PROJ(Quot);
- CASE(Proj);
default:
/* leave NULL */
break;
ir_tarval *tv;
if (a == b) {
- n = a; /* Or has it's own neutral element */
+ n = a; /* idempotence */
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_OR);
return n;
}
- /* constants are cormalized to right, check this site first */
+ /* constants are normalized to right, check this side first */
tv = value_of(b);
if (tarval_is_null(tv)) {
n = a;
ir_tarval *tv;
if (a == b) {
- n = a; /* And has it's own neutral element */
+ n = a; /* idempotence */
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_AND);
return n;
}
- /* constants are normalized to right, check this site first */
+ /* constants are normalized to right, check this side first */
tv = value_of(b);
if (tarval_is_all_one(tv)) {
n = a;
first_val = get_Phi_pred(n, i);
if ( (first_val != n) /* not self pointer */
#if 0
- /* BEWARE: when the if is changed to 1, Phi's will ignore it's Bad
- * predecessors. Then, Phi nodes in dead code might be removed, causing
- * nodes pointing to themself (Add's for instance).
- * This is really bad and causes endless recursions in several
- * code pathes, so we do NOT optimize such a code.
+ /* BEWARE: when the if is changed to 1, Phis will ignore their Bad
+ * predecessors. Then, Phi nodes in unreachable code might be removed,
+ * causing nodes pointing to themselev (Adds for instance).
+ * This is really bad and causes endless recursion on several
+ * code pathes, so we do NOT optimize such code.
* This is not that bad as it sounds, optimize_cf() removes bad control flow
* (and bad Phi predecessors), so live code is optimized later.
*/
return proj;
} /* equivalent_node_Proj_Div */
-/**
- * Optimize a / 1.0 = a.
- */
-static ir_node *equivalent_node_Proj_Quot(ir_node *proj)
-{
- ir_node *oldn = proj;
- ir_node *quot = get_Proj_pred(proj);
- ir_node *b = get_Quot_right(quot);
- ir_tarval *tb = value_of(b);
-
- /* Div is not commutative. */
- if (tarval_is_one(tb)) { /* Quot(x, 1) == x */
- switch (get_Proj_proj(proj)) {
- case pn_Quot_M:
- proj = get_Quot_mem(quot);
- DBG_OPT_ALGSIM0(oldn, proj, FS_OPT_NEUTRAL_1);
- return proj;
-
- case pn_Quot_res:
- proj = get_Quot_left(quot);
- DBG_OPT_ALGSIM0(oldn, proj, FS_OPT_NEUTRAL_1);
- return proj;
-
- default:
- /* we cannot replace the exception Proj's here, this is done in
- transform_node_Proj_Quot() */
- return proj;
- }
- }
- return proj;
-} /* equivalent_node_Proj_Quot */
-
-/**
- * Optimize a / 1 = a.
- */
-static ir_node *equivalent_node_Proj_DivMod(ir_node *proj)
-{
- ir_node *oldn = proj;
- ir_node *divmod = get_Proj_pred(proj);
- ir_node *b = get_DivMod_right(divmod);
- ir_tarval *tb = value_of(b);
-
- /* Div is not commutative. */
- if (tarval_is_one(tb)) { /* div(x, 1) == x */
- switch (get_Proj_proj(proj)) {
- case pn_DivMod_M:
- proj = get_DivMod_mem(divmod);
- DBG_OPT_ALGSIM0(oldn, proj, FS_OPT_NEUTRAL_1);
- return proj;
-
- case pn_DivMod_res_div:
- proj = get_DivMod_left(divmod);
- DBG_OPT_ALGSIM0(oldn, proj, FS_OPT_NEUTRAL_1);
- return proj;
-
- default:
- /* we cannot replace the exception Proj's here, this is done in
- transform_node_Proj_DivMod().
- Note further that the pn_DivMod_res_div case is handled in
- computed_value_Proj(). */
- return proj;
- }
- }
- return proj;
-} /* equivalent_node_Proj_DivMod */
-
/**
* Optimize CopyB(mem, x, x) into a Nop.
*/
} /* equivalent_node_Proj_Store */
/**
- * Does all optimizations on nodes that must be done on it's Proj's
+ * Does all optimizations on nodes that must be done on its Projs
* because of creating new nodes.
*/
static ir_node *equivalent_node_Proj(ir_node *proj)
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_EQ);
return n;
}
- 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 *f = get_Mux_false(n);
- ir_node *t = get_Mux_true(n);
+ if (is_Cmp(sel) && !mode_honor_signed_zeros(get_irn_mode(n))) {
+ ir_relation relation = get_Cmp_relation(sel);
+ ir_node *f = get_Mux_false(n);
+ ir_node *t = get_Mux_true(n);
/*
* 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)) {
- 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) || /* Mux(t == f, t, f) -> f */
- (cmp_l == f && cmp_r == t)) { /* Mux(f == t, t, f) -> f */
- n = f;
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_TRANSFORM);
- return n;
- }
- break;
+ ir_node *const cmp_l = get_Cmp_left(sel);
+ ir_node *const cmp_r = get_Cmp_right(sel);
+
+ switch (relation) {
+ case ir_relation_equal:
+ if ((cmp_l == t && cmp_r == f) || /* Mux(t == f, t, f) -> f */
+ (cmp_l == f && cmp_r == t)) { /* Mux(f == t, t, f) -> f */
+ n = f;
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_TRANSFORM);
+ return n;
+ }
+ break;
- case pn_Cmp_Lg:
- case pn_Cmp_Ne:
- if ((cmp_l == t && cmp_r == f) || /* Mux(t != f, t, f) -> t */
- (cmp_l == f && cmp_r == t)) { /* Mux(f != t, t, f) -> t */
- n = t;
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_TRANSFORM);
- return n;
- }
- break;
+ case ir_relation_less_greater:
+ case ir_relation_unordered_less_greater:
+ if ((cmp_l == t && cmp_r == f) || /* Mux(t != f, t, f) -> t */
+ (cmp_l == f && cmp_r == t)) { /* Mux(f != t, t, f) -> t */
+ n = t;
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_TRANSFORM);
+ return n;
}
+ break;
+ default:
+ break;
+ }
- /*
- * Note: normalization puts the constant on the right side,
- * so we check only one case.
- */
- if (cmp_l == t && tarval_is_null(value_of(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_Lg || proj_nr == pn_Cmp_Ne) {
- /* Mux(t != 0, -t, t) ==> t */
- n = t;
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_TRANSFORM);
- }
+ /*
+ * Note: normalization puts the constant on the right side,
+ * so we check only one case.
+ */
+ if (cmp_l == t && tarval_is_null(value_of(cmp_r))) {
+ /* Mux(t CMP 0, X, t) */
+ if (is_Minus(f) && get_Minus_op(f) == t) {
+ /* Mux(t CMP 0, -t, t) */
+ if (relation == ir_relation_equal) {
+ /* Mux(t == 0, -t, t) ==> -t */
+ n = f;
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_TRANSFORM);
+ } else if (relation == ir_relation_less_greater || relation == ir_relation_unordered_less_greater) {
+ /* Mux(t != 0, -t, t) ==> t */
+ n = t;
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_TRANSFORM);
}
}
}
}
+
return n;
-} /* equivalent_node_Mux */
+}
/**
* Remove Confirm nodes if setting is on.
*/
static ir_node *equivalent_node_Confirm(ir_node *n)
{
- ir_node *pred = get_Confirm_value(n);
- pn_Cmp pnc = get_Confirm_cmp(n);
+ ir_node *pred = get_Confirm_value(n);
+ ir_relation relation = get_Confirm_relation(n);
- while (is_Confirm(pred) && pnc == get_Confirm_cmp(pred)) {
+ while (is_Confirm(pred) && relation == get_Confirm_relation(pred)) {
/*
* rare case: two identical Confirms one after another,
* replace the second one with the first.
*/
n = pred;
pred = get_Confirm_value(n);
- pnc = get_Confirm_cmp(n);
}
return n;
}
CASE(Sync);
CASE_PROJ(Tuple);
CASE_PROJ(Div);
- CASE_PROJ(Quot);
- CASE_PROJ(DivMod);
CASE_PROJ(CopyB);
CASE_PROJ(Bound);
CASE_PROJ(Load);
/* a - (b - c) -> a + (c - b)
* -> (a - b) + c iff (b - c) is a pointer */
dbg_info *s_dbg = get_irn_dbg_info(b);
- ir_node *s_block = get_nodes_block(b);
ir_node *s_left = get_Sub_left(b);
ir_node *s_right = get_Sub_right(b);
ir_mode *s_mode = get_irn_mode(b);
if (mode_is_reference(s_mode)) {
- ir_node *sub = new_rd_Sub(s_dbg, s_block, a, s_left, mode);
+ ir_node *lowest_block = get_nodes_block(n); /* a and b are live here */
+ ir_node *sub = new_rd_Sub(s_dbg, lowest_block, a, s_left, mode);
dbg_info *a_dbg = get_irn_dbg_info(n);
- ir_node *a_block = get_nodes_block(n);
if (s_mode != mode)
- s_right = new_r_Conv(a_block, s_right, mode);
- n = new_rd_Add(a_dbg, a_block, sub, s_right, mode);
+ s_right = new_r_Conv(lowest_block, s_right, mode);
+ n = new_rd_Add(a_dbg, lowest_block, sub, s_right, mode);
} else {
+ ir_node *s_block = get_nodes_block(b);
ir_node *sub = new_rd_Sub(s_dbg, s_block, s_right, s_left, s_mode);
dbg_info *a_dbg = get_irn_dbg_info(n);
ir_node *a_block = get_nodes_block(n);
ir_mode *mode = get_Div_resmode(n);
ir_node *a = get_Div_left(n);
ir_node *b = get_Div_right(n);
- ir_node *value;
+ ir_node *value = n;
const ir_node *dummy;
- if (is_Const(b) && is_const_Phi(a)) {
- /* check for Div(Phi, Const) */
- value = apply_binop_on_phi(a, get_Const_tarval(b), (eval_func) tarval_div, mode, 0);
- if (value) {
- DBG_OPT_ALGSIM0(n, value, FS_OPT_CONST_PHI);
- goto make_tuple;
- }
- }
- else if (is_Const(a) && is_const_Phi(b)) {
- /* check for Div(Const, Phi) */
- value = apply_binop_on_phi(b, get_Const_tarval(a), (eval_func) tarval_div, mode, 1);
- if (value) {
- DBG_OPT_ALGSIM0(n, value, FS_OPT_CONST_PHI);
- goto make_tuple;
+ if (mode_is_int(mode)) {
+ if (is_Const(b) && is_const_Phi(a)) {
+ /* check for Div(Phi, Const) */
+ value = apply_binop_on_phi(a, get_Const_tarval(b), (eval_func) tarval_div, mode, 0);
+ if (value) {
+ DBG_OPT_ALGSIM0(n, value, FS_OPT_CONST_PHI);
+ goto make_tuple;
+ }
+ } else if (is_Const(a) && is_const_Phi(b)) {
+ /* check for Div(Const, Phi) */
+ value = apply_binop_on_phi(b, get_Const_tarval(a), (eval_func) tarval_div, mode, 1);
+ if (value) {
+ DBG_OPT_ALGSIM0(n, value, FS_OPT_CONST_PHI);
+ goto make_tuple;
+ }
+ } else if (is_const_Phi(a) && is_const_Phi(b)) {
+ /* check for Div(Phi, Phi) */
+ value = apply_binop_on_2_phis(a, b, (eval_func) tarval_div, mode);
+ if (value) {
+ DBG_OPT_ALGSIM0(n, value, FS_OPT_CONST_PHI);
+ goto make_tuple;
+ }
}
- }
- else if (is_const_Phi(a) && is_const_Phi(b)) {
- /* check for Div(Phi, Phi) */
- value = apply_binop_on_2_phis(a, b, (eval_func) tarval_div, mode);
- if (value) {
- DBG_OPT_ALGSIM0(n, value, FS_OPT_CONST_PHI);
+
+ if (a == b && value_not_zero(a, &dummy)) {
+ ir_graph *irg = get_irn_irg(n);
+ /* BEWARE: we can optimize a/a to 1 only if this cannot cause a exception */
+ value = new_r_Const(irg, get_mode_one(mode));
+ DBG_OPT_CSTEVAL(n, value);
goto make_tuple;
+ } else {
+ if (mode_is_signed(mode) && is_Const(b)) {
+ ir_tarval *tv = get_Const_tarval(b);
+
+ if (tv == get_mode_minus_one(mode)) {
+ /* a / -1 */
+ value = new_rd_Minus(get_irn_dbg_info(n), get_nodes_block(n), a, mode);
+ DBG_OPT_CSTEVAL(n, value);
+ goto make_tuple;
+ }
+ }
+ /* Try architecture dependent optimization */
+ value = arch_dep_replace_div_by_const(n);
}
- }
+ } else {
+ assert(mode_is_float(mode));
- value = n;
+ /* Optimize x/c to x*(1/c) */
+ if (get_mode_arithmetic(mode) == irma_ieee754) {
+ ir_tarval *tv = value_of(b);
- if (a == b && value_not_zero(a, &dummy)) {
- ir_graph *irg = get_irn_irg(n);
- /* BEWARE: we can optimize a/a to 1 only if this cannot cause a exception */
- value = new_r_Const(irg, get_mode_one(mode));
- DBG_OPT_CSTEVAL(n, value);
- goto make_tuple;
- } else {
- if (mode_is_signed(mode) && is_Const(b)) {
- ir_tarval *tv = get_Const_tarval(b);
+ if (tv != tarval_bad) {
+ int rem = tarval_fp_ops_enabled();
- if (tv == get_mode_minus_one(mode)) {
- /* a / -1 */
- value = new_rd_Minus(get_irn_dbg_info(n), get_nodes_block(n), a, mode);
- DBG_OPT_CSTEVAL(n, value);
- goto make_tuple;
+ /*
+ * 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.
+ */
+ tarval_enable_fp_ops(1);
+ tv = tarval_div(get_mode_one(mode), tv);
+ tarval_enable_fp_ops(rem);
+
+ /* Do the transformation if the result is either exact or we are
+ not using strict rules. */
+ if (tv != tarval_bad &&
+ (tarval_ieee754_get_exact() || (get_irg_fp_model(get_irn_irg(n)) & fp_strict_algebraic) == 0)) {
+ ir_node *block = get_nodes_block(n);
+ ir_graph *irg = get_irn_irg(block);
+ ir_node *c = new_r_Const(irg, tv);
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ value = new_rd_Mul(dbgi, block, a, c, mode);
+
+ goto make_tuple;
+ }
}
}
- /* Try architecture dependent optimization */
- value = arch_dep_replace_div_by_const(n);
}
if (value != n) {
return n;
} /* transform_node_Mod */
-/**
- * Transform a DivMod node.
- */
-static ir_node *transform_node_DivMod(ir_node *n)
-{
- const ir_node *dummy;
- ir_node *a = get_DivMod_left(n);
- ir_node *b = get_DivMod_right(n);
- ir_mode *mode = get_DivMod_resmode(n);
- ir_node *va, *vb;
- ir_graph *irg = get_irn_irg(n);
- ir_tarval *ta, *tb;
- int evaluated = 0;
-
- if (is_Const(b) && is_const_Phi(a)) {
- /* check for Div(Phi, Const) */
- va = apply_binop_on_phi(a, get_Const_tarval(b), (eval_func) tarval_div, mode, 0);
- vb = apply_binop_on_phi(a, get_Const_tarval(b), (eval_func) tarval_mod, mode, 0);
- if (va && vb) {
- DBG_OPT_ALGSIM0(n, va, FS_OPT_CONST_PHI);
- DBG_OPT_ALGSIM0(n, vb, FS_OPT_CONST_PHI);
- goto make_tuple;
- }
- }
- else if (is_Const(a) && is_const_Phi(b)) {
- /* check for Div(Const, Phi) */
- va = apply_binop_on_phi(b, get_Const_tarval(a), (eval_func) tarval_div, mode, 1);
- vb = apply_binop_on_phi(b, get_Const_tarval(a), (eval_func) tarval_mod, mode, 1);
- if (va && vb) {
- DBG_OPT_ALGSIM0(n, va, FS_OPT_CONST_PHI);
- DBG_OPT_ALGSIM0(n, vb, FS_OPT_CONST_PHI);
- goto make_tuple;
- }
- }
- else if (is_const_Phi(a) && is_const_Phi(b)) {
- /* check for Div(Phi, Phi) */
- va = apply_binop_on_2_phis(a, b, (eval_func) tarval_div, mode);
- vb = apply_binop_on_2_phis(a, b, (eval_func) tarval_mod, mode);
- if (va && vb) {
- DBG_OPT_ALGSIM0(n, va, FS_OPT_CONST_PHI);
- DBG_OPT_ALGSIM0(n, vb, FS_OPT_CONST_PHI);
- goto make_tuple;
- }
- }
-
- ta = value_of(a);
- tb = value_of(b);
- if (tb != tarval_bad) {
- if (tb == get_mode_one(get_tarval_mode(tb))) {
- va = a;
- vb = new_r_Const(irg, get_mode_null(mode));
- DBG_OPT_CSTEVAL(n, vb);
- goto make_tuple;
- } else if (ta != tarval_bad) {
- ir_tarval *resa, *resb;
- resa = tarval_div(ta, tb);
- if (resa == tarval_bad) return n; /* Causes exception!!! Model by replacing through
- Jmp for X result!? */
- resb = tarval_mod(ta, tb);
- if (resb == tarval_bad) return n; /* Causes exception! */
- va = new_r_Const(irg, resa);
- vb = new_r_Const(irg, resb);
- DBG_OPT_CSTEVAL(n, va);
- DBG_OPT_CSTEVAL(n, vb);
- goto make_tuple;
- } else if (mode_is_signed(mode) && tb == get_mode_minus_one(mode)) {
- va = new_rd_Minus(get_irn_dbg_info(n), get_nodes_block(n), a, mode);
- vb = new_r_Const(irg, get_mode_null(mode));
- DBG_OPT_CSTEVAL(n, va);
- DBG_OPT_CSTEVAL(n, vb);
- goto make_tuple;
- } else { /* Try architecture dependent optimization */
- va = a;
- vb = b;
- arch_dep_replace_divmod_by_const(&va, &vb, n);
- evaluated = va != NULL;
- }
- } else if (a == b) {
- if (value_not_zero(a, &dummy)) {
- /* a/a && a != 0 */
- va = new_r_Const(irg, get_mode_one(mode));
- vb = new_r_Const(irg, get_mode_null(mode));
- DBG_OPT_CSTEVAL(n, va);
- DBG_OPT_CSTEVAL(n, vb);
- goto make_tuple;
- } else {
- /* BEWARE: it is NOT possible to optimize a/a to 1, as this may cause a exception */
- return n;
- }
- } else if (ta == get_mode_null(mode) && value_not_zero(b, &dummy)) {
- /* 0 / non-Const = 0 */
- vb = va = a;
- goto make_tuple;
- }
-
- if (evaluated) { /* replace by tuple */
- ir_node *mem, *blk;
-
-make_tuple:
- mem = get_DivMod_mem(n);
- /* skip a potential Pin */
- mem = skip_Pin(mem);
-
- blk = get_nodes_block(n);
- turn_into_tuple(n, pn_DivMod_max);
- set_Tuple_pred(n, pn_DivMod_M, mem);
- set_Tuple_pred(n, pn_DivMod_X_regular, new_r_Jmp(blk));
- set_Tuple_pred(n, pn_DivMod_X_except, get_irg_bad(irg)); /*no exception*/
- set_Tuple_pred(n, pn_DivMod_res_div, va);
- set_Tuple_pred(n, pn_DivMod_res_mod, vb);
- }
-
- return n;
-} /* transform_node_DivMod */
-
-/**
- * Optimize x / c to x * (1/c)
- */
-static ir_node *transform_node_Quot(ir_node *n)
-{
- ir_mode *mode = get_Quot_resmode(n);
- ir_node *oldn = n;
-
- if (get_mode_arithmetic(mode) == irma_ieee754) {
- ir_node *b = get_Quot_right(n);
- ir_tarval *tv = value_of(b);
-
- if (tv != tarval_bad) {
- int rem = tarval_fp_ops_enabled();
-
- /*
- * 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.
- */
- tarval_enable_fp_ops(1);
- tv = tarval_quo(get_mode_one(mode), tv);
- tarval_enable_fp_ops(rem);
-
- /* Do the transformation if the result is either exact or we are not
- using strict rules. */
- if (tv != tarval_bad &&
- (tarval_ieee754_get_exact() || (get_irg_fp_model(get_irn_irg(n)) & fp_strict_algebraic) == 0)) {
- ir_node *blk = get_nodes_block(n);
- ir_graph *irg = get_irn_irg(blk);
- ir_node *c = new_r_Const(irg, tv);
- ir_node *a = get_Quot_left(n);
- ir_node *m = new_rd_Mul(get_irn_dbg_info(n), blk, a, c, mode);
- ir_node *mem = get_Quot_mem(n);
-
- /* skip a potential Pin */
- mem = skip_Pin(mem);
- turn_into_tuple(n, pn_Quot_max);
- set_Tuple_pred(n, pn_Quot_M, mem);
- set_Tuple_pred(n, pn_Quot_X_regular, new_r_Jmp(blk));
- set_Tuple_pred(n, pn_Quot_X_except, get_irg_bad(irg));
- set_Tuple_pred(n, pn_Quot_res, m);
- DBG_OPT_ALGSIM1(oldn, a, b, m, FS_OPT_FP_INV_MUL);
- }
- }
- }
- return n;
-} /* transform_node_Quot */
-
-/**
- * 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.
- *
- * For == and != can be handled in Proj(Cmp)
- */
-static ir_node *transform_node_Cmp(ir_node *n)
-{
- ir_node *oldn = n;
- ir_node *left = get_Cmp_left(n);
- ir_node *right = get_Cmp_right(n);
-
- if (is_Minus(left) && is_Minus(right) &&
- !mode_overflow_on_unary_Minus(get_irn_mode(left))) {
- ir_node *const new_left = get_Minus_op(right);
- ir_node *const new_right = get_Minus_op(left);
- n = new_rd_Cmp(get_irn_dbg_info(n), get_nodes_block(n), new_left, new_right);
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CMP_OP_OP);
- }
- return n;
-} /* transform_node_Cmp */
-
-
/**
* Transform a Cond node.
*
ir_mode *mode;
vrp_attr *a_vrp, *b_vrp;
+ /* we can combine the relations of two compares with the same operands */
+ if (is_Cmp(a) && is_Cmp(b)) {
+ ir_node *a_left = get_Cmp_left(a);
+ ir_node *a_right = get_Cmp_left(a);
+ ir_node *b_left = get_Cmp_left(b);
+ ir_node *b_right = get_Cmp_right(b);
+ if (a_left == b_left && b_left == b_right) {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ ir_relation a_relation = get_Cmp_relation(a);
+ ir_relation b_relation = get_Cmp_relation(b);
+ ir_relation new_relation = a_relation & b_relation;
+ return new_rd_Cmp(dbgi, block, a_left, a_right, new_relation);
+ }
+ }
+
mode = get_irn_mode(n);
HANDLE_BINOP_PHI((eval_func) tarval_and, a, b, c, mode);
- /* we can evaluate 2 Projs of the same Cmp */
- if (mode == mode_b && is_Proj(a) && is_Proj(b)) {
- ir_node *pred_a = get_Proj_pred(a);
- ir_node *pred_b = get_Proj_pred(b);
- if (pred_a == pred_b) {
- dbg_info *dbgi = get_irn_dbg_info(n);
- pn_Cmp pn_a = get_Proj_pn_cmp(a);
- pn_Cmp pn_b = get_Proj_pn_cmp(b);
- /* yes, we can simply calculate with pncs */
- pn_Cmp new_pnc = pn_a & pn_b;
-
- return new_rd_Proj(dbgi, pred_a, mode_b, new_pnc);
- }
- }
if (is_Or(a)) {
if (is_Not(b)) {
ir_node *op = get_Not_op(b);
b_vrp = vrp_get_info(b);
if (is_Const(a) && b_vrp && (tarval_cmp(tarval_or(get_Const_tarval(a),
- b_vrp->bits_not_set), get_Const_tarval(a)) == pn_Cmp_Eq)) {
+ b_vrp->bits_not_set), get_Const_tarval(a)) == ir_relation_equal)) {
return b;
a_vrp = vrp_get_info(a);
if (is_Const(b) && a_vrp && (tarval_cmp(tarval_or(get_Const_tarval(b),
- a_vrp->bits_not_set), get_Const_tarval(b)) == pn_Cmp_Eq)) {
+ a_vrp->bits_not_set), get_Const_tarval(b)) == ir_relation_equal)) {
return a;
}
ir_node *b = get_Eor_right(n);
ir_mode *mode = get_irn_mode(n);
- HANDLE_BINOP_PHI((eval_func) tarval_eor, a, b, c, mode);
-
- /* we can evaluate 2 Projs of the same Cmp */
- if (mode == mode_b && is_Proj(a) && is_Proj(b)) {
- ir_node *pred_a = get_Proj_pred(a);
- ir_node *pred_b = get_Proj_pred(b);
- if (pred_a == pred_b) {
- dbg_info *dbgi = get_irn_dbg_info(n);
- pn_Cmp pn_a = get_Proj_pn_cmp(a);
- pn_Cmp pn_b = get_Proj_pn_cmp(b);
- /* yes, we can simply calculate with pncs */
- pn_Cmp new_pnc = pn_a ^ pn_b;
-
- return new_rd_Proj(dbgi, pred_a, mode_b, new_pnc);
+ /* we can combine the relations of two compares with the same operands */
+ if (is_Cmp(a) && is_Cmp(b)) {
+ ir_node *a_left = get_Cmp_left(a);
+ ir_node *a_right = get_Cmp_left(a);
+ ir_node *b_left = get_Cmp_left(b);
+ ir_node *b_right = get_Cmp_right(b);
+ if (a_left == b_left && b_left == b_right) {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ ir_relation a_relation = get_Cmp_relation(a);
+ ir_relation b_relation = get_Cmp_relation(b);
+ ir_relation new_relation = a_relation ^ b_relation;
+ return new_rd_Cmp(dbgi, block, a_left, a_right, new_relation);
}
}
+ HANDLE_BINOP_PHI((eval_func) tarval_eor, a, b, c, mode);
+
/* normalize not nodes... ~a ^ b <=> a ^ ~b */
if (is_Not(a) && operands_are_normalized(get_Not_op(a), b)) {
dbg_info *dbg = get_irn_dbg_info(n);
HANDLE_UNOP_PHI(tarval_not,a,c);
/* check for a boolean Not */
- if (mode == mode_b && is_Proj(a)) {
- ir_node *a_pred = get_Proj_pred(a);
- if (is_Cmp(a_pred)) {
- /* We negate a Cmp. The Cmp has the negated result anyways! */
- n = new_r_Proj(get_Proj_pred(a),
- mode_b, get_negated_pnc(get_Proj_proj(a), mode_b));
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_NOT_CMP);
- return n;
- }
+ if (is_Cmp(a)) {
+ dbg_info *dbgi = get_irn_dbg_info(a);
+ ir_node *block = get_nodes_block(a);
+ ir_relation relation = get_Cmp_relation(a);
+ relation = get_negated_relation(relation);
+ n = new_rd_Cmp(dbgi, block, get_Cmp_left(a), get_Cmp_right(a), relation);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_NOT_CMP);
+ return n;
}
/* normalize ~(a ^ b) => a ^ ~b */
}
}
return n;
-} /* transform_node_Not */
+}
/**
* Transform a Minus.
return proj;
} /* transform_node_Proj_Mod */
-/**
- * Transform a Proj(DivMod) with a non-zero value.
- * Removes the exceptions and routes the memory to the NoMem node.
- */
-static ir_node *transform_node_Proj_DivMod(ir_node *proj)
-{
- ir_node *divmod = get_Proj_pred(proj);
- ir_node *b = get_DivMod_right(divmod);
- ir_node *res, *new_mem;
- const ir_node *confirm;
- long proj_nr;
-
- if (value_not_zero(b, &confirm)) {
- /* DivMod(x, y) && y != 0 */
- proj_nr = get_Proj_proj(proj);
-
- if (confirm == NULL) {
- /* we are sure we have a Const != 0 */
- new_mem = get_DivMod_mem(divmod);
- new_mem = skip_Pin(new_mem);
- set_DivMod_mem(divmod, new_mem);
- set_irn_pinned(divmod, op_pin_state_floats);
- }
-
- switch (proj_nr) {
-
- case pn_DivMod_X_regular:
- return new_r_Jmp(get_nodes_block(divmod));
-
- case pn_DivMod_X_except: {
- /* we found an exception handler, remove it */
- ir_graph *irg = get_irn_irg(proj);
- DBG_OPT_EXC_REM(proj);
- return get_irg_bad(irg);
- }
-
- case pn_DivMod_M: {
- ir_graph *irg = get_irn_irg(proj);
- res = get_DivMod_mem(divmod);
- new_mem = get_irg_no_mem(irg);
-
- if (confirm) {
- /* This node can only float up to the Confirm block */
- new_mem = new_r_Pin(get_nodes_block(confirm), new_mem);
- }
- /* this is a DivMod without exception, we can remove the memory edge */
- set_DivMod_mem(divmod, new_mem);
- return res;
- }
-
- case pn_DivMod_res_mod:
- if (get_DivMod_left(divmod) == b) {
- /* a % a = 0 if a != 0 */
- ir_graph *irg = get_irn_irg(proj);
- ir_mode *mode = get_irn_mode(proj);
- ir_node *res = new_r_Const(irg, get_mode_null(mode));
-
- DBG_OPT_CSTEVAL(divmod, res);
- return res;
- }
- }
- }
- return proj;
-} /* transform_node_Proj_DivMod */
-
/**
* Optimizes jump tables (CondIs or CondIu) by removing all impossible cases.
*/
static ir_node *transform_node_Proj_Cond(ir_node *proj)
{
- if (get_opt_unreachable_code()) {
- ir_node *n = get_Proj_pred(proj);
- ir_node *b = get_Cond_selector(n);
+ ir_node *n = get_Proj_pred(proj);
+ ir_node *b = get_Cond_selector(n);
- if (mode_is_int(get_irn_mode(b))) {
- ir_tarval *tb = value_of(b);
+ if (!get_opt_unreachable_code())
+ return n;
- if (tb != tarval_bad) {
- /* we have a constant switch */
- long num = get_Proj_proj(proj);
+ if (mode_is_int(get_irn_mode(b))) {
+ ir_tarval *tb = value_of(b);
- if (num != get_Cond_default_proj(n)) { /* we cannot optimize default Proj's yet */
- if (get_tarval_long(tb) == num) {
- /* Do NOT create a jump here, or we will have 2 control flow ops
- * in a block. This case is optimized away in optimize_cf(). */
- return proj;
- } else {
- ir_graph *irg = get_irn_irg(proj);
- /* this case will NEVER be taken, kill it */
- return get_irg_bad(irg);
- }
- }
- } else {
- long num = get_Proj_proj(proj);
- vrp_attr *b_vrp = vrp_get_info(b);
- if (num != get_Cond_default_proj(n) && b_vrp) {
- /* Try handling with vrp data. We only remove dead parts. */
- ir_tarval *tp = new_tarval_from_long(num, get_irn_mode(b));
-
- if (b_vrp->range_type == VRP_RANGE) {
- pn_Cmp cmp_result = tarval_cmp(b_vrp->range_bottom, tp);
- pn_Cmp cmp_result2 = tarval_cmp(b_vrp->range_top, tp);
-
- if ((cmp_result & pn_Cmp_Gt) == cmp_result && (cmp_result2
- & pn_Cmp_Lt) == cmp_result2) {
- ir_graph *irg = get_irn_irg(proj);
- return get_irg_bad(irg);
- }
- } else if (b_vrp->range_type == VRP_ANTIRANGE) {
- pn_Cmp cmp_result = tarval_cmp(b_vrp->range_bottom, tp);
- pn_Cmp cmp_result2 = tarval_cmp(b_vrp->range_top, tp);
-
- if ((cmp_result & pn_Cmp_Le) == cmp_result && (cmp_result2
- & pn_Cmp_Ge) == cmp_result2) {
- ir_graph *irg = get_irn_irg(proj);
- return get_irg_bad(irg);
- }
- }
+ if (tb != tarval_bad) {
+ /* we have a constant switch */
+ long num = get_Proj_proj(proj);
- if (!(tarval_cmp(
- tarval_and( b_vrp->bits_set, tp),
- b_vrp->bits_set
- ) == pn_Cmp_Eq)) {
+ if (num != get_Cond_default_proj(n)) { /* we cannot optimize default Proj's yet */
+ if (get_tarval_long(tb) == num) {
+ /* Do NOT create a jump here, or we will have 2 control flow ops
+ * in a block. This case is optimized away in optimize_cf(). */
+ return proj;
+ } else {
+ ir_graph *irg = get_irn_irg(proj);
+ /* this case will NEVER be taken, kill it */
+ return get_irg_bad(irg);
+ }
+ }
+ } else {
+ long num = get_Proj_proj(proj);
+ vrp_attr *b_vrp = vrp_get_info(b);
+ if (num != get_Cond_default_proj(n) && b_vrp) {
+ /* Try handling with vrp data. We only remove dead parts. */
+ ir_tarval *tp = new_tarval_from_long(num, get_irn_mode(b));
+
+ if (b_vrp->range_type == VRP_RANGE) {
+ ir_relation cmp_result = tarval_cmp(b_vrp->range_bottom, tp);
+ ir_relation cmp_result2 = tarval_cmp(b_vrp->range_top, tp);
+
+ if ((cmp_result & ir_relation_greater) == cmp_result && (cmp_result2
+ & ir_relation_less) == cmp_result2) {
ir_graph *irg = get_irn_irg(proj);
return get_irg_bad(irg);
}
+ } else if (b_vrp->range_type == VRP_ANTIRANGE) {
+ ir_relation cmp_result = tarval_cmp(b_vrp->range_bottom, tp);
+ ir_relation cmp_result2 = tarval_cmp(b_vrp->range_top, tp);
- if (!(tarval_cmp(
- tarval_and(
- tarval_not(tp),
- tarval_not(b_vrp->bits_not_set)),
- tarval_not(b_vrp->bits_not_set))
- == pn_Cmp_Eq)) {
+ if ((cmp_result & ir_relation_less_equal) == cmp_result && (cmp_result2
+ & ir_relation_greater_equal) == cmp_result2) {
ir_graph *irg = get_irn_irg(proj);
return get_irg_bad(irg);
}
+ }
+ if (!(tarval_cmp(
+ tarval_and( b_vrp->bits_set, tp),
+ b_vrp->bits_set
+ ) == ir_relation_equal)) {
+ ir_graph *irg = get_irn_irg(proj);
+ return get_irg_bad(irg);
+ }
+ if (!(tarval_cmp(
+ tarval_and(
+ tarval_not(tp),
+ tarval_not(b_vrp->bits_not_set)),
+ tarval_not(b_vrp->bits_not_set))
+ == ir_relation_equal)) {
+ ir_graph *irg = get_irn_irg(proj);
+ return get_irg_bad(irg);
}
+
+
}
}
}
return proj;
-} /* transform_node_Proj_Cond */
+}
+
+/**
+ * return true if the operation returns a value with exactly 1 bit set
+ */
+static bool is_single_bit(const ir_node *node)
+{
+ /* a first implementation, could be extended with vrp and others... */
+ if (is_Shl(node)) {
+ ir_node *shl_l = get_Shl_left(node);
+ ir_mode *mode = get_irn_mode(node);
+ int modulo = get_mode_modulo_shift(mode);
+ /* this works if we shift a 1 and we have modulo shift */
+ if (is_Const(shl_l) && is_Const_one(shl_l)
+ && 0 < modulo && modulo <= (int)get_mode_size_bits(mode)) {
+ return true;
+ }
+ } else if (is_Const(node)) {
+ ir_tarval *tv = get_Const_tarval(node);
+ return tarval_is_single_bit(tv);
+ }
+ return false;
+}
/**
* Create a 0 constant of given mode.
/**
* Normalizes and optimizes Cmp nodes.
*/
-static ir_node *transform_node_Proj_Cmp(ir_node *proj)
-{
- ir_node *n = get_Proj_pred(proj);
- ir_node *left = get_Cmp_left(n);
- ir_node *right = get_Cmp_right(n);
- ir_tarval *tv = NULL;
- int changed = 0;
- ir_mode *mode = NULL;
- long proj_nr = get_Proj_proj(proj);
-
- /* we can evaluate some cases directly */
- switch (proj_nr) {
- case pn_Cmp_False: {
- ir_graph *irg = get_irn_irg(proj);
- return new_r_Const(irg, get_tarval_b_false());
- }
- case pn_Cmp_True: {
- ir_graph *irg = get_irn_irg(proj);
- return new_r_Const(irg, get_tarval_b_true());
- }
- case pn_Cmp_Leg:
- if (!mode_is_float(get_irn_mode(left))) {
- ir_graph *irg = get_irn_irg(proj);
- return new_r_Const(irg, get_tarval_b_true());
- }
- break;
- default:
- break;
- }
+static ir_node *transform_node_Cmp(ir_node *n)
+{
+ ir_node *left = get_Cmp_left(n);
+ ir_node *right = get_Cmp_right(n);
+ ir_mode *mode = get_irn_mode(left);
+ ir_tarval *tv = NULL;
+ bool changed = false;
+ bool changedc = false;
+ ir_relation relation = get_Cmp_relation(n);
+ ir_relation possible = ir_get_possible_cmp_relations(left, right);
- /* remove Casts of both sides */
- left = skip_Cast(left);
- right = skip_Cast(right);
+ /* mask out impossible relations */
+ ir_relation new_relation = relation & possible;
+ if (new_relation != relation) {
+ relation = new_relation;
+ changed = true;
+ }
/* Remove unnecessary conversions */
- /* TODO handle constants */
+ /* TODO handle conv+constant */
if (is_Conv(left) && is_Conv(right)) {
- ir_mode *mode = get_irn_mode(left);
ir_node *op_left = get_Conv_op(left);
ir_node *op_right = get_Conv_op(right);
ir_mode *mode_left = get_irn_mode(op_left);
if (mode_left == mode_right) {
left = op_left;
right = op_right;
- changed |= 1;
+ changed = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV_CONV);
} else if (smaller_mode(mode_left, mode_right)) {
left = new_r_Conv(block, op_left, mode_right);
right = op_right;
- changed |= 1;
+ changed = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV);
} else if (smaller_mode(mode_right, mode_left)) {
left = op_left;
right = new_r_Conv(block, op_right, mode_left);
- changed |= 1;
+ changed = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV);
}
}
}
+ /*
+ * Optimize -a CMP -b into b CMP a.
+ * This works only for modes where unary Minus cannot Overflow.
+ * Note that two-complement integers can Overflow so it will NOT work.
+ */
+ if (!mode_overflow_on_unary_Minus(mode) &&
+ is_Minus(left) && is_Minus(right)) {
+ left = get_Minus_op(left);
+ right = get_Minus_op(right);
+ relation = get_inversed_relation(relation);
+ changed = true;
+ DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
+ }
+
/* remove operation on both sides if possible */
- if (proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg) {
+ if (relation == ir_relation_equal || relation == ir_relation_less_greater) {
/*
* The following operations are NOT safe for floating point operations, for instance
* 1.0 + inf == 2.0 + inf, =/=> x == y
*/
- if (mode_is_int(get_irn_mode(left))) {
+ if (mode_is_int(mode)) {
unsigned lop = get_irn_opcode(left);
if (lop == get_irn_opcode(right)) {
/* ~a CMP ~b => a CMP b, -a CMP -b ==> a CMP b */
left = get_unop_op(left);
right = get_unop_op(right);
- changed |= 1;
+ changed = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
break;
case iro_Add:
/* X + a CMP X + b ==> a CMP b */
left = lr;
right = rr;
- changed |= 1;
+ changed = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
} else if (ll == rr) {
/* X + a CMP b + X ==> a CMP b */
left = lr;
right = rl;
- changed |= 1;
+ changed = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
} else if (lr == rl) {
/* a + X CMP X + b ==> a CMP b */
left = ll;
right = rr;
- changed |= 1;
+ changed = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
} else if (lr == rr) {
/* a + X CMP b + X ==> a CMP b */
left = ll;
right = rl;
- changed |= 1;
+ changed = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
}
break;
/* X - a CMP X - b ==> a CMP b */
left = lr;
right = rr;
- changed |= 1;
+ changed = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
} else if (lr == rr) {
/* a - X CMP b - X ==> a CMP b */
left = ll;
right = rl;
- changed |= 1;
+ changed = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
}
break;
/* a ROTL X CMP b ROTL X ==> a CMP b */
left = get_Rotl_left(left);
right = get_Rotl_left(right);
- changed |= 1;
+ changed = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
}
break;
if (ll == right) {
ir_graph *irg = get_irn_irg(n);
left = lr;
- right = create_zero_const(irg, get_irn_mode(left));
- changed |= 1;
+ right = create_zero_const(irg, mode);
+ changed = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
}
}
if (rl == left) {
ir_graph *irg = get_irn_irg(n);
left = rr;
- right = create_zero_const(irg, get_irn_mode(left));
- changed |= 1;
+ right = create_zero_const(irg, mode);
+ changed = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
}
}
+
if (is_And(left) && is_Const(right)) {
ir_node *ll = get_binop_left(left);
ir_node *lr = get_binop_right(left);
left = new_rd_And(dbg, block, get_Shr_left(ll), new_r_Const(irg, mask), mode);
right = new_r_Const(irg, value);
- changed |= 1;
+ changed = true;
}
}
}
if (is_Const(right) && is_Const_null(right) && is_Eor(left)) {
right = get_Eor_right(left);
left = get_Eor_left(left);
- changed |= 1;
+ changed = true;
}
} /* mode_is_int(...) */
- } /* proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg */
+ }
+
+ /* Cmp(And(1bit, val), 1bit) "bit-testing" can be replaced
+ * by the simpler Cmp(And(1bit), val), 0) negated pnc */
+ if (mode_is_int(mode) && is_And(left)
+ && (relation == ir_relation_equal
+ || (mode_is_signed(mode) && relation == ir_relation_less_greater)
+ || (!mode_is_signed(mode) && (relation & ir_relation_less_equal) == ir_relation_less))) {
+ ir_node *and0 = get_And_left(left);
+ ir_node *and1 = get_And_right(left);
+ if (and1 == right) {
+ ir_node *tmp = and0;
+ and0 = and1;
+ and1 = tmp;
+ }
+ if (and0 == right && is_single_bit(and0)) {
+ ir_graph *irg = get_irn_irg(n);
+ relation =
+ relation == ir_relation_equal ? ir_relation_less_greater : ir_relation_equal;
+ right = create_zero_const(irg, mode);
+ changed |= 1;
+ }
+ }
/* replace mode_b compares with ands/ors */
- if (get_irn_mode(left) == mode_b) {
+ if (mode == mode_b) {
ir_node *block = get_nodes_block(n);
ir_node *bres;
- switch (proj_nr) {
- case pn_Cmp_Le: bres = new_r_Or( block, new_r_Not(block, left, mode_b), right, mode_b); break;
- case pn_Cmp_Lt: bres = new_r_And(block, new_r_Not(block, left, mode_b), right, mode_b); break;
- case pn_Cmp_Ge: bres = new_r_Or( block, left, new_r_Not(block, right, mode_b), mode_b); break;
- case pn_Cmp_Gt: bres = new_r_And(block, left, new_r_Not(block, right, mode_b), mode_b); break;
- case pn_Cmp_Lg: bres = new_r_Eor(block, left, right, mode_b); break;
- case pn_Cmp_Eq: bres = new_r_Not(block, new_r_Eor(block, left, right, mode_b), mode_b); break;
- default: bres = NULL;
- }
- if (bres) {
+ switch (relation) {
+ case ir_relation_less_equal:
+ bres = new_r_Or(block, new_r_Not(block, left, mode_b), right, mode_b);
+ break;
+ case ir_relation_less:
+ bres = new_r_And(block, new_r_Not(block, left, mode_b), right, mode_b);
+ break;
+ case ir_relation_greater_equal:
+ bres = new_r_Or(block, left, new_r_Not(block, right, mode_b), mode_b);
+ break;
+ case ir_relation_greater:
+ bres = new_r_And(block, left, new_r_Not(block, right, mode_b), mode_b);
+ break;
+ case ir_relation_less_greater:
+ bres = new_r_Eor(block, left, right, mode_b);
+ break;
+ case ir_relation_equal:
+ bres = new_r_Not(block, new_r_Eor(block, left, right, mode_b), mode_b);
+ break;
+ default:
+#ifdef DEBUG_libfirm
+ ir_fprintf(stderr, "Optimisation warning, unexpected mode_b Cmp %+F\n", n);
+#endif
+ bres = NULL;
+ }
+ if (bres != NULL) {
DBG_OPT_ALGSIM0(n, bres, FS_OPT_CMP_TO_BOOL);
return bres;
}
*/
if (!operands_are_normalized(left, right)) {
ir_node *t = left;
-
left = right;
right = t;
- proj_nr = get_inversed_pnc(proj_nr);
- changed |= 1;
+ relation = get_inversed_relation(relation);
+ changed = true;
}
/*
*/
tv = value_of(right);
if (tv != tarval_bad) {
- mode = get_irn_mode(right);
+ ir_mode *mode = get_irn_mode(right);
/* TODO extend to arbitrary constants */
if (is_Conv(left) && tarval_is_null(tv)) {
* win. (on the other side it makes detection/creation of fabs hard)
*/
if (get_mode_size_bits(mode) > get_mode_size_bits(op_mode) &&
- ((proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg) ||
+ ((relation == ir_relation_equal || relation == ir_relation_less_greater) ||
mode_is_signed(mode) || !mode_is_signed(op_mode)) &&
!mode_is_float(mode)) {
tv = get_mode_null(op_mode);
left = op;
mode = op_mode;
- changed |= 2;
+ changedc = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV);
}
}
*/
if (is_Minus(left) &&
(!mode_overflow_on_unary_Minus(mode) ||
- (mode_is_int(mode) && (proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg)))) {
+ (mode_is_int(mode) && (relation == ir_relation_equal || relation == ir_relation_less_greater)))) {
tv = tarval_neg(tv);
if (tv != tarval_bad) {
left = get_Minus_op(left);
- proj_nr = get_inversed_pnc(proj_nr);
- changed |= 2;
+ relation = get_inversed_relation(relation);
+ changedc = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_C);
}
- } else if (is_Not(left) && (proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg)) {
+ } else if (is_Not(left) && (relation == ir_relation_equal || relation == ir_relation_less_greater)) {
/* Not(a) ==/!= c ==> a ==/!= Not(c) */
tv = tarval_not(tv);
if (tv != tarval_bad) {
left = get_Not_op(left);
- changed |= 2;
+ changedc = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_C);
}
}
/* 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_Uo) {
- proj_nr &= ~pn_Cmp_Uo;
- 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_mode_null(mode)) == pn_Cmp_Gt) {
+ if ((relation == ir_relation_less || relation == ir_relation_greater_equal) &&
+ tarval_cmp(tv, get_mode_null(mode)) == ir_relation_greater) {
tv = tarval_sub(tv, get_mode_one(mode), NULL);
if (tv != tarval_bad) {
- proj_nr ^= pn_Cmp_Eq;
- changed |= 2;
+ relation ^= ir_relation_equal;
+ changedc = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CNST_MAGN);
}
}
/* 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_mode_null(mode)) == pn_Cmp_Lt) {
+ else if ((relation == ir_relation_greater || relation == ir_relation_less_equal) &&
+ tarval_cmp(tv, get_mode_null(mode)) == ir_relation_less) {
tv = tarval_add(tv, get_mode_one(mode));
if (tv != tarval_bad) {
- proj_nr ^= pn_Cmp_Eq;
- changed |= 2;
+ relation ^= ir_relation_equal;
+ changedc = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CNST_MAGN);
}
}
/* the following reassociations work only for == and != */
- if (proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg) {
+ if (relation == ir_relation_equal || relation == ir_relation_less_greater) {
#if 0 /* Might be not that good in general */
/* a-b == 0 ==> a == b, a-b != 0 ==> a != b */
if (tv2 != tarval_bad) {
left = get_Sub_left(left);
tv = tv2;
- changed |= 2;
+ changedc = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_C);
}
}
if (tv2 != tarval_bad) {
left = a;
tv = tv2;
- changed |= 2;
+ changedc = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_C);
}
}
if (tv2 != tarval_bad) {
left = get_Minus_op(left);
tv = tv2;
- changed |= 2;
+ changedc = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_C);
}
}
} /* == or != */
} /* mode_is_int */
- if (proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg) {
+ if (relation == ir_relation_equal || relation == ir_relation_less_greater) {
switch (get_irn_opcode(left)) {
ir_node *c1;
if (mask != tv) {
/* TODO: move to constant evaluation */
ir_graph *irg = get_irn_irg(n);
- tv = proj_nr == pn_Cmp_Eq ? get_tarval_b_false() : get_tarval_b_true();
+ tv = relation == ir_relation_equal ? get_tarval_b_false() : get_tarval_b_true();
c1 = new_r_Const(irg, tv);
- DBG_OPT_CSTEVAL(proj, c1);
+ DBG_OPT_CSTEVAL(n, c1);
return c1;
}
if (get_Const_tarval(c1) == tv) {
/* fine: do the transformation */
tv = get_mode_null(get_tarval_mode(tv));
- proj_nr ^= pn_Cmp_Leg;
- changed |= 2;
+ relation ^= ir_relation_less_equal_greater;
+ changedc = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CNST_MAGN);
}
}
if (! tarval_is_null(get_Const_tarval(c1))) {
/* TODO: move to constant evaluation */
ir_graph *irg = get_irn_irg(n);
- tv = proj_nr == pn_Cmp_Eq ? get_tarval_b_false() : get_tarval_b_true();
+ tv = relation == ir_relation_equal ? get_tarval_b_false() : get_tarval_b_true();
c1 = new_r_Const(irg, tv);
- DBG_OPT_CSTEVAL(proj, c1);
+ DBG_OPT_CSTEVAL(n, c1);
return c1;
}
}
if (tarval_and(tv, cmask) != tv) {
/* condition not met */
- tv = proj_nr == pn_Cmp_Eq ? get_tarval_b_false() : get_tarval_b_true();
+ tv = relation == ir_relation_equal ? get_tarval_b_false() : get_tarval_b_true();
c1 = new_r_Const(irg, tv);
- DBG_OPT_CSTEVAL(proj, c1);
+ DBG_OPT_CSTEVAL(n, c1);
return c1;
}
sl = get_Shl_left(left);
blk = get_nodes_block(n);
left = new_rd_And(get_irn_dbg_info(left), blk, sl, new_r_Const(irg, amask), mode);
tv = tarval_shr(tv, tv1);
- changed |= 2;
+ changedc = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_SHF_TO_AND);
}
break;
if (tarval_and(tv, cmask) != tv) {
/* condition not met */
- tv = proj_nr == pn_Cmp_Eq ? get_tarval_b_false() : get_tarval_b_true();
+ tv = relation == ir_relation_equal ? get_tarval_b_false() : get_tarval_b_true();
c1 = new_r_Const(irg, tv);
- DBG_OPT_CSTEVAL(proj, c1);
+ DBG_OPT_CSTEVAL(n, c1);
return c1;
}
sl = get_Shr_left(left);
blk = get_nodes_block(n);
left = new_rd_And(get_irn_dbg_info(left), blk, sl, new_r_Const(irg, amask), mode);
tv = tarval_shl(tv, tv1);
- changed |= 2;
+ changedc = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_SHF_TO_AND);
}
break;
if (!tarval_is_all_one(cond) && !tarval_is_null(cond)) {
/* condition not met */
- tv = proj_nr == pn_Cmp_Eq ? get_tarval_b_false() : get_tarval_b_true();
+ tv = relation == ir_relation_equal ? get_tarval_b_false() : get_tarval_b_true();
c1 = new_r_Const(irg, tv);
- DBG_OPT_CSTEVAL(proj, c1);
+ DBG_OPT_CSTEVAL(n, c1);
return c1;
}
sl = get_Shrs_left(left);
blk = get_nodes_block(n);
left = new_rd_And(get_irn_dbg_info(left), blk, sl, new_r_Const(irg, amask), mode);
tv = tarval_shl(tv, tv1);
- changed |= 2;
+ changedc = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_SHF_TO_AND);
}
break;
} /* tarval != bad */
}
- if (changed & 2) { /* need a new Const */
+ if (changedc) { /* need a new Const */
ir_graph *irg = get_irn_irg(n);
right = new_r_Const(irg, tv);
+ changed = true;
}
- if ((proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg) && is_Const(right) && is_Const_null(right) && is_Proj(left)) {
+ if ((relation == ir_relation_equal || relation == ir_relation_less_greater) && is_Const(right) && is_Const_null(right) && is_Proj(left)) {
ir_node *op = get_Proj_pred(left);
- if ((is_Mod(op) && get_Proj_proj(left) == pn_Mod_res) ||
- (is_DivMod(op) && get_Proj_proj(left) == pn_DivMod_res_mod)) {
+ if (is_Mod(op) && get_Proj_proj(left) == pn_Mod_res) {
ir_node *c = get_binop_right(op);
if (is_Const(c)) {
tv = tarval_sub(tv, get_mode_one(mode), NULL);
left = new_rd_And(get_irn_dbg_info(op), blk, v, new_r_Const(irg, tv), mode);
- changed |= 1;
+ changed = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_MOD_TO_AND);
}
}
}
if (changed) {
- ir_node *block = get_nodes_block(n);
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
/* create a new compare */
- n = new_rd_Cmp(get_irn_dbg_info(n), block, left, right);
- proj = new_rd_Proj(get_irn_dbg_info(proj), n, get_irn_mode(proj), proj_nr);
+ n = new_rd_Cmp(dbgi, block, left, right, relation);
}
- return proj;
-} /* transform_node_Proj_Cmp */
+ return n;
+}
/**
* Optimize CopyB(mem, x, x) into a Nop.
} /* transform_node_Proj_Bound */
/**
- * Does all optimizations on nodes that must be done on it's Proj's
+ * Does all optimizations on nodes that must be done on its Projs
* because of creating new nodes.
*/
static ir_node *transform_node_Proj(ir_node *proj)
/* Beware of Phi0 */
if (n > 0) {
- ir_node *pred = get_irn_n(phi, 0);
- ir_node *bound, *new_phi, *block, **in;
- pn_Cmp pnc;
+ ir_node *pred = get_irn_n(phi, 0);
+ ir_node *bound, *new_phi, *block, **in;
+ ir_relation relation;
if (! is_Confirm(pred))
return phi;
- bound = get_Confirm_bound(pred);
- pnc = get_Confirm_cmp(pred);
+ bound = get_Confirm_bound(pred);
+ relation = get_Confirm_relation(pred);
NEW_ARR_A(ir_node *, in, n);
in[0] = get_Confirm_value(pred);
if (! is_Confirm(pred) ||
get_Confirm_bound(pred) != bound ||
- get_Confirm_cmp(pred) != pnc)
+ get_Confirm_relation(pred) != relation)
return phi;
in[i] = get_Confirm_value(pred);
}
/* move the Confirm nodes "behind" the Phi */
block = get_irn_n(phi, -1);
new_phi = new_r_Phi(block, n, in, get_irn_mode(phi));
- return new_r_Confirm(block, new_phi, bound, pnc);
+ return new_r_Confirm(block, new_phi, bound, relation);
}
}
return phi;
-} /* transform_node_Phi */
+}
/**
* Returns the operands of a commutative bin-op, if one operand is
/* Note: the obvious rot formulation (a << x) | (a >> (32-x)) gets
* transformed to (a << x) | (a >> -x) by transform_node_shift_modulo() */
- if (!is_negated_value(c1, c2)) {
+ if (!ir_is_negated_value(c1, c2)) {
return irn_or;
}
return n;
}
- /* we can evaluate 2 Projs of the same Cmp */
- if (get_irn_mode(n) == mode_b && is_Proj(a) && is_Proj(b)) {
- ir_node *pred_a = get_Proj_pred(a);
- ir_node *pred_b = get_Proj_pred(b);
- if (pred_a == pred_b) {
- dbg_info *dbgi = get_irn_dbg_info(n);
- pn_Cmp pn_a = get_Proj_pn_cmp(a);
- pn_Cmp pn_b = get_Proj_pn_cmp(b);
- /* yes, we can simply calculate with pncs */
- pn_Cmp new_pnc = pn_a | pn_b;
-
- return new_rd_Proj(dbgi, pred_a, mode_b, new_pnc);
+ /* we can combine the relations of two compares with the same operands */
+ if (is_Cmp(a) && is_Cmp(b)) {
+ ir_node *a_left = get_Cmp_left(a);
+ ir_node *a_right = get_Cmp_left(a);
+ ir_node *b_left = get_Cmp_left(b);
+ ir_node *b_right = get_Cmp_right(b);
+ if (a_left == b_left && b_left == b_right) {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ ir_relation a_relation = get_Cmp_relation(a);
+ ir_relation b_relation = get_Cmp_relation(b);
+ ir_relation new_relation = a_relation | b_relation;
+ return new_rd_Cmp(dbgi, block, a_left, a_right, new_relation);
}
}
assert(modulo_shf >= (int) get_mode_size_bits(mode));
/* shifting too much */
- if (!(tarval_cmp(res, modulo) & pn_Cmp_Lt)) {
+ if (!(tarval_cmp(res, modulo) & ir_relation_less)) {
if (is_Shrs(n)) {
ir_node *block = get_nodes_block(n);
dbg_info *dbgi = get_irn_dbg_info(n);
ir_tarval *tv_shift;
ir_tarval *tv_mask;
ir_graph *irg;
- pn_Cmp pnc;
+ ir_relation relation;
int need_shrs = 0;
assert(is_Shl(n) || is_Shr(n) || is_Shrs(n));
if (is_Shrs(left)) {
/* shrs variant only allowed if c1 >= c2 */
- if (! (tarval_cmp(tv_shl, tv_shr) & pn_Cmp_Ge))
+ if (! (tarval_cmp(tv_shl, tv_shr) & ir_relation_greater_equal))
return n;
tv_mask = tarval_shrs(get_mode_all_one(mode), tv_shr);
irg = get_irn_irg(block);
dbgi = get_irn_dbg_info(n);
- pnc = tarval_cmp(tv_shl, tv_shr);
- if (pnc == pn_Cmp_Lt || pnc == pn_Cmp_Eq) {
+ relation = tarval_cmp(tv_shl, tv_shr);
+ if (relation == ir_relation_less || relation == ir_relation_equal) {
tv_shift = tarval_sub(tv_shr, tv_shl, NULL);
new_const = new_r_Const(irg, tv_shift);
if (need_shrs) {
new_shift = new_rd_Shr(dbgi, block, x, new_const, mode);
}
} else {
- assert(pnc == pn_Cmp_Gt);
+ assert(relation == ir_relation_greater);
tv_shift = tarval_sub(tv_shl, tv_shr, NULL);
new_const = new_r_Const(irg, tv_shift);
new_shift = new_rd_Shl(dbgi, block, x, new_const, mode);
return n;
} /* transform_node_End */
-bool is_negated_value(ir_node *a, ir_node *b)
+int ir_is_negated_value(const ir_node *a, const ir_node *b)
{
if (is_Minus(a) && get_Minus_op(a) == b)
return true;
/* first normalization step: try to move a constant to the false side,
* 0 preferred on false side too */
- if (is_Proj(sel)) {
- ir_node *cmp = get_Proj_pred(sel);
-
- if (is_Cmp(cmp) && is_Const(t) &&
- (!is_Const(f) || (is_Const_null(t) && !is_Const_null(f)))) {
- pn_Cmp pnc = get_Proj_pn_cmp(sel);
- ir_node *tmp = t;
- t = f;
- f = tmp;
-
- /* Mux(x, a, b) => Mux(not(x), b, a) */
- sel = new_r_Proj(cmp, mode_b,
- get_negated_pnc(pnc, get_irn_mode(get_Cmp_left(cmp))));
- n = new_rd_Mux(get_irn_dbg_info(n), get_nodes_block(n), sel, f, t, mode);
- }
+ if (is_Cmp(sel) && is_Const(t) &&
+ (!is_Const(f) || (is_Const_null(t) && !is_Const_null(f)))) {
+ dbg_info *seldbgi = get_irn_dbg_info(sel);
+ ir_node *block = get_nodes_block(sel);
+ ir_relation relation = get_Cmp_relation(sel);
+ ir_node *tmp = t;
+ t = f;
+ f = tmp;
+
+ /* Mux(x, a, b) => Mux(not(x), b, a) */
+ relation = get_negated_relation(relation);
+ sel = new_rd_Cmp(seldbgi, block, get_Cmp_left(sel),
+ get_Cmp_right(sel), relation);
+ n = new_rd_Mux(get_irn_dbg_info(n), get_nodes_block(n), sel, f, t, mode);
}
/* note: after normalization, false can only happen on default */
}
}
- if (is_Proj(sel)) {
- ir_node *cmp = get_Proj_pred(sel);
- long pn = get_Proj_proj(sel);
+ if (is_Cmp(sel)) {
+ ir_node *cmp_r = get_Cmp_right(sel);
+ if (is_Const(cmp_r) && is_Const_null(cmp_r)) {
+ ir_node *block = get_nodes_block(n);
+ ir_node *cmp_l = get_Cmp_left(sel);
- /*
- * Note: normalization puts the constant on the right side,
- * so we check only one case.
- */
- 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_nodes_block(n);
- ir_node *cmp_l = get_Cmp_left(cmp);
-
- if (mode_is_int(mode)) {
- /* integer only */
- if ((pn == pn_Cmp_Lg || pn == pn_Cmp_Eq) && is_And(cmp_l)) {
- /* Mux((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) {
- /* Mux((a & 2^C) != 0, 2^C, 0) */
+ if (mode_is_int(mode)) {
+ ir_relation relation = get_Cmp_relation(sel);
+ /* integer only */
+ if ((relation == ir_relation_less_greater || relation == ir_relation_equal) && is_And(cmp_l)) {
+ /* Mux((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 (relation == ir_relation_less_greater) {
+ /* Mux((a & 2^C) != 0, 2^C, 0) */
+ n = cmp_l;
+ DBG_OPT_ALGSIM1(oldn, sel, sel, n, FS_OPT_MUX_TO_BITOP);
+ } else {
+ /* Mux((a & 2^C) == 0, 2^C, 0) */
+ n = new_rd_Eor(get_irn_dbg_info(n),
+ block, cmp_l, t, mode);
+ DBG_OPT_ALGSIM1(oldn, sel, sel, n, FS_OPT_MUX_TO_BITOP);
+ }
+ 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 (relation == ir_relation_less_greater) {
+ /* (a & (1 << n)) != 0, (1 << n), 0) */
n = cmp_l;
- DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_BITOP);
+ DBG_OPT_ALGSIM1(oldn, sel, sel, n, FS_OPT_MUX_TO_BITOP);
} else {
- /* Mux((a & 2^C) == 0, 2^C, 0) */
+ /* (a & (1 << n)) == 0, (1 << n), 0) */
n = new_rd_Eor(get_irn_dbg_info(n),
block, cmp_l, t, mode);
- DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_BITOP);
+ DBG_OPT_ALGSIM1(oldn, sel, sel, n, FS_OPT_MUX_TO_BITOP);
}
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;
- DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_BITOP);
- } else {
- /* (a & (1 << n)) == 0, (1 << n), 0) */
- n = new_rd_Eor(get_irn_dbg_info(n),
- block, cmp_l, t, mode);
- DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_BITOP);
- }
- 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;
- DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_BITOP);
- } else {
- /* ((1 << n) & a) == 0, (1 << n), 0) */
- n = new_rd_Eor(get_irn_dbg_info(n),
- block, cmp_l, t, mode);
- DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_BITOP);
- }
- 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 (relation == ir_relation_less_greater) {
+ /* ((1 << n) & a) != 0, (1 << n), 0) */
+ n = cmp_l;
+ DBG_OPT_ALGSIM1(oldn, sel, sel, n, FS_OPT_MUX_TO_BITOP);
+ } else {
+ /* ((1 << n) & a) == 0, (1 << n), 0) */
+ n = new_rd_Eor(get_irn_dbg_info(n),
+ block, cmp_l, t, mode);
+ DBG_OPT_ALGSIM1(oldn, sel, sel, n, FS_OPT_MUX_TO_BITOP);
}
+ return n;
}
}
}
}
return n;
-} /* transform_node_Mux */
+}
/**
* optimize Sync nodes that have other syncs as input we simply add the inputs
ir_graph *irg;
type_dbg_info *tdb;
dbg_info *db;
- int i, n_res, n_param;
+ size_t i, n_res, n_param;
ir_variadicity var;
if (! is_Proj(callee))
switch (code) {
CASE(Add);
- CASE(Sub);
- CASE(Mul);
- CASE_PROJ_EX(Div);
- CASE_PROJ_EX(Mod);
- CASE_PROJ_EX(DivMod);
- CASE(Quot);
- CASE_PROJ_EX(Cmp);
- CASE_PROJ_EX(Cond);
CASE(And);
+ CASE(Call);
+ CASE(Cmp);
+ CASE(Conv);
+ CASE(End);
CASE(Eor);
- CASE(Not);
CASE(Minus);
- CASE_PROJ(Load);
- CASE_PROJ(Store);
- CASE_PROJ(Bound);
- CASE_PROJ(CopyB);
- CASE(Proj);
- CASE(Phi);
+ CASE(Mul);
+ CASE(Mux);
+ CASE(Not);
CASE(Or);
+ CASE(Phi);
+ CASE(Proj);
+ CASE(Rotl);
CASE(Sel);
+ CASE(Shl);
CASE(Shr);
CASE(Shrs);
- CASE(Shl);
- CASE(Rotl);
- CASE(Conv);
- CASE(End);
- CASE(Mux);
+ CASE(Sub);
CASE(Sync);
- CASE(Call);
+ CASE_PROJ(Bound);
+ CASE_PROJ(CopyB);
+ CASE_PROJ(Load);
+ CASE_PROJ(Store);
+ CASE_PROJ_EX(Cond);
+ CASE_PROJ_EX(Div);
+ CASE_PROJ_EX(Mod);
default:
/* leave NULL */;
}
#define N_IR_NODES 512
/** Compares the attributes of two Const nodes. */
-static int node_cmp_attr_Const(ir_node *a, ir_node *b)
+static int node_cmp_attr_Const(const ir_node *a, const ir_node *b)
{
return get_Const_tarval(a) != get_Const_tarval(b);
}
/** Compares the attributes of two Proj nodes. */
-static int node_cmp_attr_Proj(ir_node *a, ir_node *b)
+static int node_cmp_attr_Proj(const ir_node *a, const ir_node *b)
{
return a->attr.proj.proj != b->attr.proj.proj;
-} /* node_cmp_attr_Proj */
+}
/** Compares the attributes of two Alloc nodes. */
-static int node_cmp_attr_Alloc(ir_node *a, ir_node *b)
+static int node_cmp_attr_Alloc(const ir_node *a, const ir_node *b)
{
const alloc_attr *pa = &a->attr.alloc;
const alloc_attr *pb = &b->attr.alloc;
return (pa->where != pb->where) || (pa->type != pb->type);
-} /* node_cmp_attr_Alloc */
+}
/** Compares the attributes of two Free nodes. */
-static int node_cmp_attr_Free(ir_node *a, ir_node *b)
+static int node_cmp_attr_Free(const ir_node *a, const ir_node *b)
{
const free_attr *pa = &a->attr.free;
const free_attr *pb = &b->attr.free;
return (pa->where != pb->where) || (pa->type != pb->type);
-} /* node_cmp_attr_Free */
+}
/** Compares the attributes of two SymConst nodes. */
-static int node_cmp_attr_SymConst(ir_node *a, ir_node *b)
+static int node_cmp_attr_SymConst(const ir_node *a, const ir_node *b)
{
const symconst_attr *pa = &a->attr.symc;
const symconst_attr *pb = &b->attr.symc;
}
/** Compares the attributes of two Call nodes. */
-static int node_cmp_attr_Call(ir_node *a, ir_node *b)
+static int node_cmp_attr_Call(const ir_node *a, const ir_node *b)
{
const call_attr *pa = &a->attr.call;
const call_attr *pb = &b->attr.call;
return (pa->type != pb->type)
|| (pa->tail_call != pb->tail_call);
-} /* node_cmp_attr_Call */
+}
/** Compares the attributes of two Sel nodes. */
-static int node_cmp_attr_Sel(ir_node *a, ir_node *b)
+static int node_cmp_attr_Sel(const ir_node *a, const ir_node *b)
{
const ir_entity *a_ent = get_Sel_entity(a);
const ir_entity *b_ent = get_Sel_entity(b);
return a_ent != b_ent;
-} /* node_cmp_attr_Sel */
+}
/** Compares the attributes of two Phi nodes. */
-static int node_cmp_attr_Phi(ir_node *a, ir_node *b)
+static int node_cmp_attr_Phi(const ir_node *a, const ir_node *b)
{
/* 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 */
return a->attr.phi.u.pos != b->attr.phi.u.pos;
}
return 0;
-} /* node_cmp_attr_Phi */
+}
/** Compares the attributes of two Conv nodes. */
-static int node_cmp_attr_Conv(ir_node *a, ir_node *b)
+static int node_cmp_attr_Conv(const ir_node *a, const ir_node *b)
{
return get_Conv_strict(a) != get_Conv_strict(b);
-} /* node_cmp_attr_Conv */
+}
/** Compares the attributes of two Cast nodes. */
-static int node_cmp_attr_Cast(ir_node *a, ir_node *b)
+static int node_cmp_attr_Cast(const ir_node *a, const ir_node *b)
{
return get_Cast_type(a) != get_Cast_type(b);
-} /* node_cmp_attr_Cast */
+}
/** Compares the attributes of two Load nodes. */
-static int node_cmp_attr_Load(ir_node *a, ir_node *b)
+static int node_cmp_attr_Load(const ir_node *a, const ir_node *b)
{
if (get_Load_volatility(a) == volatility_is_volatile ||
get_Load_volatility(b) == volatility_is_volatile)
return 1;
return get_Load_mode(a) != get_Load_mode(b);
-} /* node_cmp_attr_Load */
+}
/** Compares the attributes of two Store nodes. */
-static int node_cmp_attr_Store(ir_node *a, ir_node *b)
+static int node_cmp_attr_Store(const ir_node *a, const ir_node *b)
{
/* do not CSE Stores with different alignment. Be conservative. */
if (get_Store_align(a) != get_Store_align(b))
/* NEVER do CSE on volatile Stores */
return (get_Store_volatility(a) == volatility_is_volatile ||
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)
+static int node_cmp_exception(const ir_node *a, const ir_node *b)
{
const except_attr *ea = &a->attr.except;
const except_attr *eb = &b->attr.except;
#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)
+static int node_cmp_attr_Div(const ir_node *a, const ir_node *b)
{
- const divmod_attr *ma = &a->attr.divmod;
- const divmod_attr *mb = &b->attr.divmod;
+ const div_attr *ma = &a->attr.div;
+ const div_attr *mb = &b->attr.div;
return ma->exc.pin_state != mb->exc.pin_state ||
ma->resmode != mb->resmode ||
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)
+/** Compares the attributes of two Mod nodes. */
+static int node_cmp_attr_Mod(const ir_node *a, const ir_node *b)
{
- const divmod_attr *ma = &a->attr.divmod;
- const divmod_attr *mb = &b->attr.divmod;
+ const mod_attr *ma = &a->attr.mod;
+ const mod_attr *mb = &b->attr.mod;
return ma->exc.pin_state != mb->exc.pin_state ||
ma->resmode != mb->resmode;
-} /* node_cmp_attr_DivMod */
-
-/** Compares the attributes of two Mod nodes. */
-static int node_cmp_attr_Mod(ir_node *a, ir_node *b)
-{
- return node_cmp_attr_DivMod(a, b);
-} /* node_cmp_attr_Mod */
+}
-/** Compares the attributes of two Quot nodes. */
-static int node_cmp_attr_Quot(ir_node *a, ir_node *b)
+static int node_cmp_attr_Cmp(const ir_node *a, const ir_node *b)
{
- return node_cmp_attr_DivMod(a, b);
-} /* node_cmp_attr_Quot */
+ const cmp_attr *ma = &a->attr.cmp;
+ const cmp_attr *mb = &b->attr.cmp;
+ return ma->relation != mb->relation;
+}
/** Compares the attributes of two Confirm nodes. */
-static int node_cmp_attr_Confirm(ir_node *a, ir_node *b)
+static int node_cmp_attr_Confirm(const ir_node *a, const ir_node *b)
{
- /* no need to compare the bound, as this is a input */
- return (get_Confirm_cmp(a) != get_Confirm_cmp(b));
-} /* node_cmp_attr_Confirm */
+ const confirm_attr *ma = &a->attr.confirm;
+ const confirm_attr *mb = &b->attr.confirm;
+ return ma->relation != mb->relation;
+}
/** Compares the attributes of two Builtin nodes. */
-static int node_cmp_attr_Builtin(ir_node *a, ir_node *b)
+static int node_cmp_attr_Builtin(const ir_node *a, const ir_node *b)
{
/* no need to compare the type, equal kind means equal type */
return get_Builtin_kind(a) != get_Builtin_kind(b);
-} /* node_cmp_attr_Builtin */
+}
/** Compares the attributes of two ASM nodes. */
-static int node_cmp_attr_ASM(ir_node *a, ir_node *b)
+static int node_cmp_attr_ASM(const ir_node *a, const ir_node *b)
{
int i, n;
const ir_asm_constraint *ca;
return 1;
}
return 0;
-} /* node_cmp_attr_ASM */
+}
/** Compares the inexistent attributes of two Dummy nodes. */
-static int node_cmp_attr_Dummy(ir_node *a, ir_node *b)
+static int node_cmp_attr_Dummy(const ir_node *a, const ir_node *b)
{
(void) a;
(void) b;
CASE(Call);
CASE(Sel);
CASE(Phi);
+ CASE(Cmp);
CASE(Conv);
CASE(Cast);
CASE(Load);
CASE(Confirm);
CASE(ASM);
CASE(Div);
- CASE(DivMod);
CASE(Mod);
- CASE(Quot);
CASE(Bound);
CASE(Builtin);
CASE(Dummy);
#if 0
/* Propagating Unknowns here seems to be a bad idea, because
sometimes we need a node as a input and did not want that
- it kills it's user.
+ it kills its user.
However, it might be useful to move this into a later phase
(if you think that optimizing such code is useful). */
if (is_Unknown(pred) && mode_is_data(get_irn_mode(node)))
/* Always optimize Phi nodes: part of the construction. */
if ((!get_opt_optimize()) && (iro != iro_Phi)) return n;
+ /* Remove nodes with dead (Bad) input.
+ Run always for transformation induced Bads. */
+ n = gigo(n);
+ if (n != oldn) {
+ edges_node_deleted(oldn, irg);
+
+ /* We found an existing, better node, so we can deallocate the old node. */
+ irg_kill_node(irg, oldn);
+ return n;
+ }
+
/* constant expression evaluation / constant folding */
if (get_opt_constant_folding()) {
/* neither constants nor Tuple values can be evaluated */
tv = computed_value(n);
if (tv != tarval_bad) {
ir_node *nw;
- int node_size;
+ size_t node_size;
/*
- * we MUST copy the node here temporary, because it's still
+ * we MUST copy the node here temporarily, because it's still
* needed for DBG_OPT_CSTEVAL
*/
node_size = offsetof(ir_node, attr) + n->op->attr_size;
(iro == iro_Proj)) /* Flags tested local. */
n = transform_node(n);
- /* Remove nodes with dead (Bad) input.
- 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)) {
ir_node *o = n;
if (iro == iro_Deleted)
return n;
+ /* Remove nodes with dead (Bad) input.
+ Run always for transformation induced Bads. */
+ n = gigo(n);
+ if (is_Bad(n))
+ return n;
+
/* constant expression evaluation / constant folding */
if (get_opt_constant_folding()) {
/* neither constants nor Tuple values can be evaluated */
(iro == iro_Proj)) /* Flags tested local. */
n = transform_node(n);
- /* Remove nodes with dead (Bad) input.
- Run always for transformation induced Bads. */
- n = gigo(n);
-
/* Now we can verify the node, as it has no dead inputs any more. */
irn_verify(n);
projects / libfirm / blobdiff