/*
- * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
* @file
* @brief iropt --- optimizations intertwined with IR construction.
* @author Christian Schaefer, Goetz Lindenmaier, Michael Beck
- * @version $Id$
*/
#include "config.h"
#include <string.h>
+#include <stdbool.h>
#include "irnode_t.h"
#include "irgraph_t.h"
#include "iropt_t.h"
#include "ircons_t.h"
#include "irgmod.h"
-#include "irvrfy.h"
+#include "irverify.h"
+#include "iroptimize.h"
#include "tv_t.h"
#include "dbginfo_t.h"
#include "iropt_dbg.h"
#include "irhooks.h"
#include "irarch.h"
#include "hashptr.h"
-#include "opt_confirms.h"
-#include "opt_polymorphy.h"
#include "irtools.h"
#include "irhooks.h"
#include "array_t.h"
+#include "vrp.h"
+#include "firm_types.h"
+#include "bitfiddle.h"
+#include "be.h"
+#include "error.h"
-/* Make types visible to allow most efficient access */
#include "entity_t.h"
+static bool is_Or_Eor_Add(const ir_node *node)
+{
+ if (is_Or(node) || is_Eor(node) || is_Add(node)) {
+ ir_node *left = get_binop_left(node);
+ ir_node *right = get_binop_right(node);
+ vrp_attr *vrp_left = vrp_get_info(left);
+ vrp_attr *vrp_right = vrp_get_info(right);
+ if (vrp_left != NULL && vrp_right != NULL) {
+ ir_tarval *vrp_val
+ = tarval_and(vrp_left->bits_not_set, vrp_right->bits_not_set);
+ return tarval_is_null(vrp_val);
+ }
+ }
+ return false;
+}
+
/**
* Returns the tarval of a Const node or tarval_bad for all other nodes.
*/
-static tarval *default_value_of(const ir_node *n) {
+static ir_tarval *default_value_of(const ir_node *n)
+{
if (is_Const(n))
return get_Const_tarval(n); /* might return tarval_bad */
else
value_of_func value_of_ptr = default_value_of;
-/* * Set a new value_of function. */
-void set_value_of_func(value_of_func func) {
+void set_value_of_func(value_of_func func)
+{
if (func != NULL)
value_of_ptr = func;
else
/**
* Return the value of a Constant.
*/
-static tarval *computed_value_Const(const ir_node *n) {
+static ir_tarval *computed_value_Const(const ir_node *n)
+{
return get_Const_tarval(n);
-} /* computed_value_Const */
+}
/**
* Return the value of a 'sizeof', 'alignof' or 'offsetof' SymConst.
*/
-static tarval *computed_value_SymConst(const ir_node *n) {
+static ir_tarval *computed_value_SymConst(const ir_node *n)
+{
ir_type *type;
ir_entity *ent;
break;
}
return tarval_bad;
-} /* computed_value_SymConst */
+}
/**
* Return the value of an Add.
*/
-static tarval *computed_value_Add(const ir_node *n) {
+static ir_tarval *computed_value_Add(const ir_node *n)
+{
ir_node *a = get_Add_left(n);
ir_node *b = get_Add_right(n);
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad))
return tarval_add(ta, tb);
+ /* x+~x => -1 */
+ if ((is_Not(a) && get_Not_op(a) == b)
+ || (is_Not(b) && get_Not_op(b) == a)) {
+ return get_mode_all_one(get_irn_mode(n));
+ }
+
return tarval_bad;
-} /* computed_value_Add */
+}
/**
* Return the value of a Sub.
* Special case: a - a
*/
-static tarval *computed_value_Sub(const ir_node *n) {
- ir_mode *mode = get_irn_mode(n);
- ir_node *a = get_Sub_left(n);
- ir_node *b = get_Sub_right(n);
- tarval *ta;
- tarval *tb;
+static ir_tarval *computed_value_Sub(const ir_node *n)
+{
+ ir_mode *mode = get_irn_mode(n);
+ ir_node *a = get_Sub_left(n);
+ ir_node *b = get_Sub_right(n);
+ ir_tarval *ta;
+ ir_tarval *tb;
/* NaN - NaN != 0 */
if (! mode_is_float(mode)) {
return tarval_sub(ta, tb, mode);
return tarval_bad;
-} /* computed_value_Sub */
+}
/**
* Return the value of a Carry.
* Special : a op 0, 0 op b
*/
-static tarval *computed_value_Carry(const ir_node *n) {
- ir_node *a = get_binop_left(n);
- ir_node *b = get_binop_right(n);
- ir_mode *m = get_irn_mode(n);
-
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+static ir_tarval *computed_value_Carry(const ir_node *n)
+{
+ ir_node *a = get_binop_left(n);
+ ir_node *b = get_binop_right(n);
+ ir_mode *m = get_irn_mode(n);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
tarval_add(ta, tb);
return get_mode_null(m);
}
return tarval_bad;
-} /* computed_value_Carry */
+}
/**
* Return the value of a Borrow.
* Special : a op 0
*/
-static tarval *computed_value_Borrow(const ir_node *n) {
- ir_node *a = get_binop_left(n);
- ir_node *b = get_binop_right(n);
- ir_mode *m = get_irn_mode(n);
-
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+static ir_tarval *computed_value_Borrow(const ir_node *n)
+{
+ ir_node *a = get_binop_left(n);
+ ir_node *b = get_binop_right(n);
+ ir_mode *m = get_irn_mode(n);
+ ir_tarval *ta = value_of(a);
+ 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);
}
return tarval_bad;
-} /* computed_value_Borrow */
+}
/**
* Return the value of an unary Minus.
*/
-static tarval *computed_value_Minus(const ir_node *n) {
- ir_node *a = get_Minus_op(n);
- tarval *ta = value_of(a);
+static ir_tarval *computed_value_Minus(const ir_node *n)
+{
+ ir_node *a = get_Minus_op(n);
+ ir_tarval *ta = value_of(a);
if (ta != tarval_bad)
return tarval_neg(ta);
return tarval_bad;
-} /* computed_value_Minus */
+}
/**
* Return the value of a Mul.
*/
-static tarval *computed_value_Mul(const ir_node *n) {
- ir_node *a = get_Mul_left(n);
- ir_node *b = get_Mul_right(n);
- ir_mode *mode;
-
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+static ir_tarval *computed_value_Mul(const ir_node *n)
+{
+ ir_node *a = get_Mul_left(n);
+ ir_node *b = get_Mul_right(n);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
+ ir_mode *mode;
mode = get_irn_mode(n);
if (mode != get_irn_mode(a)) {
}
}
return tarval_bad;
-} /* computed_value_Mul */
-
-/**
- * Return the value of an Abs.
- */
-static tarval *computed_value_Abs(const ir_node *n) {
- ir_node *a = get_Abs_op(n);
- tarval *ta = value_of(a);
-
- if (ta != tarval_bad)
- return tarval_abs(ta);
-
- return tarval_bad;
-} /* computed_value_Abs */
+}
/**
* Return the value of an And.
* Special case: a & 0, 0 & b
*/
-static tarval *computed_value_And(const ir_node *n) {
- ir_node *a = get_And_left(n);
- ir_node *b = get_And_right(n);
-
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+static ir_tarval *computed_value_And(const ir_node *n)
+{
+ ir_node *a = get_And_left(n);
+ ir_node *b = get_And_right(n);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
return tarval_and (ta, tb);
- } else {
- if (tarval_is_null(ta)) return ta;
- if (tarval_is_null(tb)) return tb;
}
+
+ if (tarval_is_null(ta)) return ta;
+ if (tarval_is_null(tb)) return tb;
+
+ /* x&~x => 0 */
+ if ((is_Not(a) && get_Not_op(a) == b)
+ || (is_Not(b) && get_Not_op(b) == a)) {
+ return get_mode_null(get_irn_mode(n));
+ }
+
return tarval_bad;
-} /* computed_value_And */
+}
/**
* Return the value of an Or.
* Special case: a | 1...1, 1...1 | b
*/
-static tarval *computed_value_Or(const ir_node *n) {
- ir_node *a = get_Or_left(n);
- ir_node *b = get_Or_right(n);
-
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+static ir_tarval *computed_value_Or(const ir_node *n)
+{
+ ir_node *a = get_Or_left(n);
+ ir_node *b = get_Or_right(n);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
return tarval_or (ta, tb);
- } else {
- if (tarval_is_all_one(ta)) return ta;
- if (tarval_is_all_one(tb)) return tb;
+ }
+
+ if (tarval_is_all_one(ta)) return ta;
+ if (tarval_is_all_one(tb)) return tb;
+
+ /* x|~x => -1 */
+ if ((is_Not(a) && get_Not_op(a) == b)
+ || (is_Not(b) && get_Not_op(b) == a)) {
+ return get_mode_all_one(get_irn_mode(n));
}
return tarval_bad;
-} /* computed_value_Or */
+}
/**
* Return the value of an Eor.
*/
-static tarval *computed_value_Eor(const ir_node *n) {
+static ir_tarval *computed_value_Eor(const ir_node *n)
+{
ir_node *a = get_Eor_left(n);
ir_node *b = get_Eor_right(n);
- tarval *ta, *tb;
+ ir_tarval *ta, *tb;
if (a == b)
return get_mode_null(get_irn_mode(n));
+ /* x^~x => -1 */
+ if ((is_Not(a) && get_Not_op(a) == b)
+ || (is_Not(b) && get_Not_op(b) == a)) {
+ return get_mode_all_one(get_irn_mode(n));
+ }
ta = value_of(a);
tb = value_of(b);
return tarval_eor(ta, tb);
}
return tarval_bad;
-} /* computed_value_Eor */
+}
/**
* Return the value of a Not.
*/
-static tarval *computed_value_Not(const ir_node *n) {
- ir_node *a = get_Not_op(n);
- tarval *ta = value_of(a);
+static ir_tarval *computed_value_Not(const ir_node *n)
+{
+ ir_node *a = get_Not_op(n);
+ ir_tarval *ta = value_of(a);
if (ta != tarval_bad)
return tarval_not(ta);
return tarval_bad;
-} /* computed_value_Not */
+}
+
+/**
+ * Tests whether a shift shifts more bits than available in the mode
+ */
+static bool is_oversize_shift(const ir_node *n)
+{
+ ir_node *count = get_binop_right(n);
+ ir_mode *mode = get_irn_mode(n);
+ ir_tarval *tv = value_of(count);
+ long modulo_shift;
+ long shiftval;
+ if (tv == tarval_bad)
+ return false;
+ if (!tarval_is_long(tv))
+ return false;
+ shiftval = get_tarval_long(tv);
+ modulo_shift = get_mode_modulo_shift(mode);
+ if (shiftval < 0 || (modulo_shift > 0 && shiftval >= modulo_shift))
+ return false;
+
+ return shiftval >= (long)get_mode_size_bits(mode);
+}
/**
* Return the value of a Shl.
*/
-static tarval *computed_value_Shl(const ir_node *n) {
+static ir_tarval *computed_value_Shl(const ir_node *n)
+{
ir_node *a = get_Shl_left(n);
ir_node *b = get_Shl_right(n);
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
return tarval_shl(ta, tb);
}
+
+ if (is_oversize_shift(n))
+ return get_mode_null(get_irn_mode(n));
+
return tarval_bad;
-} /* computed_value_Shl */
+}
/**
* Return the value of a Shr.
*/
-static tarval *computed_value_Shr(const ir_node *n) {
+static ir_tarval *computed_value_Shr(const ir_node *n)
+{
ir_node *a = get_Shr_left(n);
ir_node *b = get_Shr_right(n);
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
return tarval_shr(ta, tb);
}
+ if (is_oversize_shift(n))
+ return get_mode_null(get_irn_mode(n));
+
return tarval_bad;
-} /* computed_value_Shr */
+}
/**
* Return the value of a Shrs.
*/
-static tarval *computed_value_Shrs(const ir_node *n) {
+static ir_tarval *computed_value_Shrs(const ir_node *n)
+{
ir_node *a = get_Shrs_left(n);
ir_node *b = get_Shrs_right(n);
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
return tarval_shrs(ta, tb);
}
return tarval_bad;
-} /* computed_value_Shrs */
+}
/**
* Return the value of a Rotl.
*/
-static tarval *computed_value_Rotl(const ir_node *n) {
+static ir_tarval *computed_value_Rotl(const ir_node *n)
+{
ir_node *a = get_Rotl_left(n);
ir_node *b = get_Rotl_right(n);
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
return tarval_rotl(ta, tb);
}
return tarval_bad;
-} /* computed_value_Rotl */
+}
+
+bool ir_zero_when_converted(const ir_node *node, ir_mode *dest_mode)
+{
+ ir_mode *mode = get_irn_mode(node);
+ if (get_mode_arithmetic(mode) != irma_twos_complement
+ || get_mode_arithmetic(dest_mode) != irma_twos_complement)
+ return false;
+
+ if (is_Shl(node)) {
+ ir_node *count = get_Shl_right(node);
+ if (is_Const(count)) {
+ ir_tarval *tv = get_Const_tarval(count);
+ if (tarval_is_long(tv)) {
+ long shiftval = get_tarval_long(tv);
+ long destbits = get_mode_size_bits(dest_mode);
+ if (shiftval >= destbits
+ && shiftval < (long)get_mode_modulo_shift(mode))
+ return true;
+ }
+ }
+ }
+ if (is_And(node)) {
+ ir_node *right = get_And_right(node);
+ if (is_Const(right)) {
+ ir_tarval *tv = get_Const_tarval(right);
+ ir_tarval *conved = tarval_convert_to(tv, dest_mode);
+ return tarval_is_null(conved);
+ }
+ }
+ return false;
+}
/**
* Return the value of a Conv.
*/
-static tarval *computed_value_Conv(const ir_node *n) {
- ir_node *a = get_Conv_op(n);
- tarval *ta = value_of(a);
+static ir_tarval *computed_value_Conv(const ir_node *n)
+{
+ ir_node *a = get_Conv_op(n);
+ ir_tarval *ta = value_of(a);
+ ir_mode *mode = get_irn_mode(n);
if (ta != tarval_bad)
return tarval_convert_to(ta, get_irn_mode(n));
+ if (ir_zero_when_converted(a, mode))
+ return get_mode_null(mode);
+
return tarval_bad;
-} /* computed_value_Conv */
+}
/**
* Calculate the value of a Mux: can be evaluated, if the
* sel and the right input are known.
*/
-static tarval *computed_value_Mux(const ir_node *n) {
+static ir_tarval *computed_value_Mux(const ir_node *n)
+{
ir_node *sel = get_Mux_sel(n);
- tarval *ts = value_of(sel);
+ ir_tarval *ts = value_of(sel);
if (ts == get_tarval_b_true()) {
ir_node *v = get_Mux_true(n);
return value_of(v);
}
return tarval_bad;
-} /* computed_value_Mux */
+}
/**
* Calculate the value of a Confirm: can be evaluated,
* if it has the form Confirm(x, '=', Const).
*/
-static tarval *computed_value_Confirm(const ir_node *n) {
- /*
- * Beware: we might produce Phi(Confirm(x == true), Confirm(x == false)).
- * Do NOT optimize them away (jump threading wants them), so wait until
- * remove_confirm is activated.
- */
- if (get_opt_remove_confirm()) {
- if (get_Confirm_cmp(n) == pn_Cmp_Eq) {
- tarval *tv = value_of(get_Confirm_bound(n));
- if (tv != tarval_bad)
- return tv;
- }
+static ir_tarval *computed_value_Confirm(const ir_node *n)
+{
+ if (get_Confirm_relation(n) == ir_relation_equal) {
+ ir_tarval *tv = value_of(get_Confirm_bound(n));
+ if (tv != tarval_bad)
+ return tv;
}
return value_of(get_Confirm_value(n));
-} /* 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 tarval *computed_value_Proj_Cmp(const ir_node *n) {
- ir_node *a = get_Proj_pred(n);
- ir_node *aa = get_Cmp_left(a);
- ir_node *ab = get_Cmp_right(a);
- long proj_nr = get_Proj_proj(n);
-
- /*
- * BEWARE: a == a is NOT always True for floating Point values, as
- * NaN != NaN is defined, so we must check this here.
- */
- if (aa == ab && (
- !mode_is_float(get_irn_mode(aa)) || proj_nr == pn_Cmp_Lt || proj_nr == pn_Cmp_Gt)
- ) { /* 1.: */
+ir_relation ir_get_possible_cmp_relations(const ir_node *left,
+ const ir_node *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)) {
+ 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;
+ /* stuff known through confirm nodes */
+ if (is_Confirm(left) && get_Confirm_bound(left) == right) {
+ possible &= get_Confirm_relation(left);
+ }
+ if (is_Confirm(right) && get_Confirm_bound(right) == left) {
+ ir_relation relation = get_Confirm_relation(right);
+ relation = get_inversed_relation(relation);
+ possible &= relation;
+ }
+
+ return possible;
+}
- /* 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 (proj_nr == pn_Cmp_Eq, mode_b) */
- return new_tarval_from_long (proj_nr & pn_Cmp_Eq, mode_b);
- }
- else {
- tarval *taa = value_of(aa);
- tarval *tab = value_of(ab);
- ir_mode *mode = get_irn_mode(aa);
+static ir_tarval *compute_cmp(const ir_node *cmp)
+{
+ 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);
+
+ /* 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);
+}
- /*
- * The predecessors of Cmp are target values. We can evaluate
- * the Cmp.
- */
- if ((taa != tarval_bad) && (tab != tarval_bad)) {
- /* strange checks... */
- pn_Cmp flags = tarval_cmp(taa, tab);
- if (flags != pn_Cmp_False) {
- return new_tarval_from_long (proj_nr & flags, mode_b);
- }
- }
- /* for integer values, we can check against MIN/MAX */
- else if (mode_is_int(mode)) {
- /* MIN <=/> x. This results in true/false. */
- if (taa == get_mode_min(mode)) {
- /* a compare with the MIN value */
- if (proj_nr == pn_Cmp_Le)
- return get_tarval_b_true();
- else if (proj_nr == pn_Cmp_Gt)
- return get_tarval_b_false();
- }
- /* x >=/< MIN. This results in true/false. */
- else
- if (tab == get_mode_min(mode)) {
- /* a compare with the MIN value */
- if (proj_nr == pn_Cmp_Ge)
- return get_tarval_b_true();
- else if (proj_nr == pn_Cmp_Lt)
- return get_tarval_b_false();
- }
- /* MAX >=/< x. This results in true/false. */
- else if (taa == get_mode_max(mode)) {
- if (proj_nr == pn_Cmp_Ge)
- return get_tarval_b_true();
- else if (proj_nr == pn_Cmp_Lt)
- return get_tarval_b_false();
- }
- /* x <=/> MAX. This results in true/false. */
- else if (tab == get_mode_max(mode)) {
- if (proj_nr == pn_Cmp_Le)
- return get_tarval_b_true();
- else if (proj_nr == pn_Cmp_Gt)
- return get_tarval_b_false();
- }
- }
- /*
- * The predecessors are Allocs or (void*)(0) constants. Allocs never
- * return NULL, they raise an exception. Therefore we can predict
- * the Cmp result.
- */
- else {
- ir_node *aaa = skip_Proj(aa);
- ir_node *aba = skip_Proj(ab);
-
- if ( ( (/* aa is ProjP and aaa is Alloc */
- is_Proj(aa)
- && mode_is_reference(get_irn_mode(aa))
- && is_Alloc(aaa))
- && ( (/* ab is NULL */
- mode_is_reference(get_irn_mode(ab))
- && tarval_is_null(tab))
- || (/* ab is other Alloc */
- is_Proj(ab)
- && mode_is_reference(get_irn_mode(ab))
- && is_Alloc(aba)
- && (aaa != aba))))
- || (/* aa is NULL and aba is Alloc */
- mode_is_reference(get_irn_mode(aa))
- && tarval_is_null(taa)
- && is_Proj(ab)
- && mode_is_reference(get_irn_mode(ab))
- && is_Alloc(aba)))
- /* 3.: */
- return new_tarval_from_long(proj_nr & pn_Cmp_Lg, mode_b);
- }
- }
- return computed_value_Cmp_Confirm(a, aa, ab, proj_nr);
-} /* computed_value_Proj_Cmp */
+/**
+ * some people want to call compute_cmp directly, in this case we have to
+ * test the constant folding flag again
+ */
+static ir_tarval *compute_cmp_ext(const ir_node *cmp)
+{
+ if (!get_opt_constant_folding())
+ return tarval_bad;
+ return compute_cmp(cmp);
+}
/**
- * 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 tarval *do_computed_value_Quot(const ir_node *a, const ir_node *b) {
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+static ir_tarval *computed_value_Cmp(const ir_node *cmp)
+{
+ /* we can't construct Constb after lowering mode_b nodes */
+ if (irg_is_constrained(get_irn_irg(cmp), IR_GRAPH_CONSTRAINT_MODEB_LOWERED))
+ return tarval_bad;
- /* 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 */
+ return compute_cmp(cmp);
+}
/**
- * Calculate the value of an integer Div of two nodes.
+ * Calculate the value of an integer Div.
* Special case: 0 / b
*/
-static tarval *do_computed_value_Div(const ir_node *a, const ir_node *b) {
- tarval *ta = value_of(a);
- tarval *tb;
+static ir_tarval *do_computed_value_Div(const ir_node *div)
+{
+ 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_Div */
+}
/**
* Calculate the value of an integer Mod of two nodes.
* Special case: a % 1
*/
-static tarval *do_computed_value_Mod(const ir_node *a, const ir_node *b) {
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+static ir_tarval *do_computed_value_Mod(const ir_node *a, const ir_node *b)
+{
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
/* Compute a % 1 or c1 % c2 */
if (tarval_is_one(tb))
if (ta != tarval_bad && tb != tarval_bad)
return tarval_mod(ta, tb);
return tarval_bad;
-} /* do_computed_value_Mod */
-
-/**
- * Return the value of a Proj(DivMod).
- */
-static 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 tarval *computed_value_Proj_Div(const ir_node *n) {
+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;
-} /* computed_value_Proj_Div */
+ return do_computed_value_Div(get_Proj_pred(n));
+}
/**
* Return the value of a Proj(Mod).
*/
-static tarval *computed_value_Proj_Mod(const ir_node *n) {
+static ir_tarval *computed_value_Proj_Mod(const ir_node *n)
+{
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));
- }
- return tarval_bad;
-} /* computed_value_Proj_Mod */
-
-/**
- * Return the value of a Proj(Quot).
- */
-static 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));
+ 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_Quot */
+}
/**
* Return the value of a Proj.
*/
-static tarval *computed_value_Proj(const ir_node *proj) {
+static ir_tarval *computed_value_Proj(const ir_node *proj)
+{
ir_node *n = get_Proj_pred(proj);
if (n->op->ops.computed_value_Proj != NULL)
return n->op->ops.computed_value_Proj(proj);
return tarval_bad;
-} /* computed_value_Proj */
+}
/**
* If the parameter n can be computed, return its value, else tarval_bad.
*
* @param n The node this should be evaluated
*/
-tarval *computed_value(const ir_node *n) {
+ir_tarval *computed_value(const ir_node *n)
+{
+ vrp_attr *vrp = vrp_get_info(n);
+ if (vrp != NULL && vrp->bits_set == vrp->bits_not_set)
+ return vrp->bits_set;
+
if (n->op->ops.computed_value)
return n->op->ops.computed_value(n);
return tarval_bad;
-} /* computed_value */
-
-/**
- * Set the default computed_value evaluator in an ir_op_ops.
- *
- * @param code the opcode for the default operation
- * @param ops the operations initialized
- *
- * @return
- * The operations.
- */
-static ir_op_ops *firm_set_default_computed_value(ir_opcode code, ir_op_ops *ops)
-{
-#define CASE(a) \
- case iro_##a: \
- ops->computed_value = computed_value_##a; \
- break
-#define CASE_PROJ(a) \
- case iro_##a: \
- ops->computed_value_Proj = computed_value_Proj_##a; \
- break
-
- switch (code) {
- CASE(Const);
- CASE(SymConst);
- CASE(Add);
- CASE(Sub);
- CASE(Carry);
- CASE(Borrow);
- CASE(Minus);
- CASE(Mul);
- CASE(Abs);
- CASE(And);
- CASE(Or);
- CASE(Eor);
- CASE(Not);
- CASE(Shl);
- CASE(Shr);
- CASE(Shrs);
- CASE(Rotl);
- CASE(Conv);
- CASE(Mux);
- CASE(Confirm);
- CASE_PROJ(Cmp);
- CASE_PROJ(DivMod);
- CASE_PROJ(Div);
- CASE_PROJ(Mod);
- CASE_PROJ(Quot);
- CASE(Proj);
- default:
- /* leave NULL */;
- }
-
- return ops;
-#undef CASE_PROJ
-#undef CASE
-} /* firm_set_default_computed_value */
-
-/**
- * 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;
-
- /* don't optimize dead or labeled blocks */
- if (is_Block_dead(n) || has_Block_entity(n))
- return n;
-
- n_preds = get_Block_n_cfgpreds(n);
-
- /* The Block constructor does not call optimize, but mature_immBlock()
- calls the optimization. */
- assert(get_Block_matured(n));
-
- /* Straightening: a single entry Block following a single exit Block
- can be merged, if it is not the Start block. */
- /* !!! Beware, all Phi-nodes of n must have been optimized away.
- 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 (n_preds == 1) {
- ir_node *pred = skip_Proj(get_Block_cfgpred(n, 0));
-
- if (is_Jmp(pred)) {
- ir_node *predblock = get_nodes_block(pred);
- if (predblock == oldn) {
- /* Jmp jumps into the block it is in -- deal self cycle. */
- n = set_Block_dead(n);
- DBG_OPT_DEAD_BLOCK(oldn, n);
- } else if (get_opt_control_flow_straightening()) {
- n = predblock;
- DBG_OPT_STG(oldn, n);
- }
- } else if (is_Cond(pred)) {
- ir_node *predblock = get_nodes_block(pred);
- if (predblock == oldn) {
- /* Jmp jumps into the block it is in -- deal self cycle. */
- n = set_Block_dead(n);
- DBG_OPT_DEAD_BLOCK(oldn, n);
- }
- }
- } else if ((n_preds == 2) &&
- (get_opt_control_flow_weak_simplification())) {
- /* Test whether Cond jumps twice to this block
- * The more general case which more than 2 predecessors is handles
- * in optimize_cf(), we handle only this special case for speed here.
- */
- ir_node *a = get_Block_cfgpred(n, 0);
- ir_node *b = get_Block_cfgpred(n, 1);
-
- if (is_Proj(a) && is_Proj(b)) {
- ir_node *cond = get_Proj_pred(a);
-
- if (cond == get_Proj_pred(b) && is_Cond(cond) &&
- get_irn_mode(get_Cond_selector(cond)) == mode_b) {
- /* Also a single entry Block following a single exit Block. Phis have
- twice the same operand and will be optimized away. */
- n = get_nodes_block(cond);
- DBG_OPT_IFSIM1(oldn, a, b, n);
- }
- }
- } else if (get_opt_unreachable_code() &&
- (n != get_irg_start_block(current_ir_graph)) &&
- (n != get_irg_end_block(current_ir_graph)) ) {
- int i;
-
- /* If all inputs are dead, this block is dead too, except if it is
- the start or end block. This is one step of unreachable code
- elimination */
- for (i = get_Block_n_cfgpreds(n) - 1; i >= 0; --i) {
- ir_node *pred = get_Block_cfgpred(n, i);
- ir_node *pred_blk;
-
- if (is_Bad(pred)) continue;
- pred_blk = get_nodes_block(skip_Proj(pred));
-
- if (is_Block_dead(pred_blk)) continue;
-
- if (pred_blk != n) {
- /* really found a living input */
- break;
- }
- }
- if (i < 0) {
- n = set_Block_dead(n);
- DBG_OPT_DEAD_BLOCK(oldn, n);
- }
- }
-
- return n;
-} /* equivalent_node_Block */
-
-/**
- * Returns a equivalent node for a Jmp, a Bad :-)
- * Of course this only happens if the Block of the Jmp is dead.
- */
-static ir_node *equivalent_node_Jmp(ir_node *n) {
- ir_node *oldn = n;
-
- /* unreachable code elimination */
- if (is_Block_dead(get_nodes_block(n))) {
- n = get_irg_bad(current_ir_graph);
- DBG_OPT_DEAD_BLOCK(oldn, n);
- }
- return n;
-} /* equivalent_node_Jmp */
-
-/** Raise is handled in the same way as Jmp. */
-#define equivalent_node_Raise equivalent_node_Jmp
-
-
-/* We do not evaluate Cond here as we replace it by a new node, a Jmp.
- See transform_node_Proj_Cond(). */
+}
/**
* Optimize operations that are commutative and have neutral 0,
* so a op 0 = 0 op a = a.
*/
-static ir_node *equivalent_node_neutral_zero(ir_node *n) {
+static ir_node *equivalent_node_neutral_zero(ir_node *n)
+{
ir_node *oldn = n;
ir_node *a = get_binop_left(n);
ir_node *b = get_binop_right(n);
- tarval *tv;
+ ir_tarval *tv;
ir_node *on;
/* After running compute_node there is only one constant predecessor.
}
return n;
-} /* equivalent_node_neutral_zero */
+}
/**
* Eor is commutative and has neutral 0.
*/
-static ir_node *equivalent_node_Eor(ir_node *n) {
+static ir_node *equivalent_node_Eor(ir_node *n)
+{
ir_node *oldn = n;
ir_node *a;
ir_node *b;
a = get_Eor_left(n);
b = get_Eor_right(n);
- if (is_Eor(a)) {
- ir_node *aa = get_Eor_left(a);
- ir_node *ab = get_Eor_right(a);
+ if (is_Eor(a) || is_Or_Eor_Add(a)) {
+ ir_node *aa = get_binop_left(a);
+ ir_node *ab = get_binop_right(a);
if (aa == b) {
/* (a ^ b) ^ a -> b */
return n;
}
}
- if (is_Eor(b)) {
- ir_node *ba = get_Eor_left(b);
- ir_node *bb = get_Eor_right(b);
+ if (is_Eor(b) || is_Or_Eor_Add(b)) {
+ ir_node *ba = get_binop_left(b);
+ ir_node *bb = get_binop_right(b);
if (ba == a) {
/* a ^ (a ^ b) -> b */
* Beware: The Mode of an Add may be different than the mode of its
* predecessors, so we could not return a predecessors in all cases.
*/
-static ir_node *equivalent_node_Add(ir_node *n) {
+static ir_node *equivalent_node_Add(ir_node *n)
+{
ir_node *oldn = n;
ir_node *left, *right;
ir_mode *mode = get_irn_mode(n);
return n;
/* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
- if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic))
- return n;
+ if (mode_is_float(mode)) {
+ ir_graph *irg = get_irn_irg(n);
+ if (get_irg_fp_model(irg) & fp_strict_algebraic)
+ return n;
+ }
left = get_Add_left(n);
right = get_Add_right(n);
}
}
return n;
-} /* equivalent_node_Add */
+}
/**
* optimize operations that are not commutative but have neutral 0 on left,
* so a op 0 = a.
*/
-static ir_node *equivalent_node_left_zero(ir_node *n) {
+static ir_node *equivalent_node_left_zero(ir_node *n)
+{
ir_node *oldn = n;
- ir_node *a = get_binop_left(n);
- ir_node *b = get_binop_right(n);
- tarval *tb = value_of(b);
+ ir_node *a = get_binop_left(n);
+ ir_node *b = get_binop_right(n);
+ ir_tarval *tb = value_of(b);
if (tarval_is_null(tb)) {
n = a;
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
}
return n;
-} /* equivalent_node_left_zero */
-
-#define equivalent_node_Shl equivalent_node_left_zero
-#define equivalent_node_Shr equivalent_node_left_zero
-#define equivalent_node_Shrs equivalent_node_left_zero
-#define equivalent_node_Rotl equivalent_node_left_zero
+}
/**
* Optimize a - 0 and (a + x) - x (for modes with wrap-around).
* Beware: The Mode of a Sub may be different than the mode of its
* predecessors, so we could not return a predecessors in all cases.
*/
-static ir_node *equivalent_node_Sub(ir_node *n) {
- ir_node *oldn = n;
- ir_node *b;
- ir_mode *mode = get_irn_mode(n);
- tarval *tb;
+static ir_node *equivalent_node_Sub(ir_node *n)
+{
+ ir_node *oldn = n;
+ ir_node *b;
+ ir_mode *mode = get_irn_mode(n);
+ ir_tarval *tb;
/* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
- if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic))
- return n;
+ if (mode_is_float(mode)) {
+ ir_graph *irg = get_irn_irg(n);
+ if (get_irg_fp_model(irg) & fp_strict_algebraic)
+ return n;
+ }
b = get_Sub_right(n);
tb = value_of(b);
}
}
return n;
-} /* equivalent_node_Sub */
+}
/**
- * Optimize an "self-inverse unary op", ie op(op(n)) = n.
+ * Optimize an "self-inverse unary op", i.e. op(op(n)) = n.
*
* @todo
* -(-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_idempotent_unop(ir_node *n) {
+static ir_node *equivalent_node_involution(ir_node *n)
+{
ir_node *oldn = n;
ir_node *pred = get_unop_op(n);
-
- /* optimize symmetric unop */
if (get_irn_op(pred) == get_irn_op(n)) {
n = get_unop_op(pred);
- DBG_OPT_ALGSIM2(oldn, pred, n, FS_OPT_IDEM_UNARY);
+ DBG_OPT_ALGSIM2(oldn, pred, n, FS_OPT_INVOLUTION);
}
return n;
-} /* equivalent_node_idempotent_unop */
-
-/** Optimize Not(Not(x)) == x. */
-#define equivalent_node_Not equivalent_node_idempotent_unop
-
-/** -(-x) == x ??? Is this possible or can --x raise an
- out of bounds exception if min =! max? */
-#define equivalent_node_Minus equivalent_node_idempotent_unop
+}
/**
* Optimize a * 1 = 1 * a = a.
*/
-static ir_node *equivalent_node_Mul(ir_node *n) {
+static ir_node *equivalent_node_Mul(ir_node *n)
+{
ir_node *oldn = n;
ir_node *a = get_Mul_left(n);
/* we can handle here only the n * n = n bit cases */
if (get_irn_mode(n) == get_irn_mode(a)) {
- ir_node *b = get_Mul_right(n);
- tarval *tv;
+ ir_node *b = get_Mul_right(n);
+ ir_tarval *tv;
/*
* Mul is commutative and has again an other neutral element.
}
}
return n;
-} /* equivalent_node_Mul */
+}
/**
* Use algebraic simplification a | a = a | 0 = 0 | a = a.
*/
-static ir_node *equivalent_node_Or(ir_node *n) {
+static ir_node *equivalent_node_Or(ir_node *n)
+{
ir_node *oldn = n;
- ir_node *a = get_Or_left(n);
- ir_node *b = get_Or_right(n);
- tarval *tv;
+ ir_node *a = get_Or_left(n);
+ ir_node *b = get_Or_right(n);
+ 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;
}
return n;
-} /* equivalent_node_Or */
+}
/**
* Optimize a & 0b1...1 = 0b1...1 & a = a & a = (a|X) & a = a.
*/
-static ir_node *equivalent_node_And(ir_node *n) {
+static ir_node *equivalent_node_And(ir_node *n)
+{
ir_node *oldn = n;
- ir_node *a = get_And_left(n);
- ir_node *b = get_And_right(n);
- tarval *tv;
+ ir_node *a = get_And_left(n);
+ ir_node *b = get_And_right(n);
+ 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;
ir_node *convop = get_Conv_op(a);
ir_mode *convopmode = get_irn_mode(convop);
if (!mode_is_signed(convopmode)) {
- if (tarval_is_all_one(tarval_convert_to(tv, convopmode))) {
- /* Conv(X) & all_one(mode(X)) = Conv(X) */
+ /* Check Conv(all_one) & Const = all_one */
+ ir_tarval *one = get_mode_all_one(convopmode);
+ ir_tarval *conv = tarval_convert_to(one, mode);
+ ir_tarval *tand = tarval_and(conv, tv);
+
+ if (tarval_is_all_one(tand)) {
+ /* Conv(X) & Const = X */
n = a;
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_AND);
return n;
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_AND);
return n;
}
- if (is_Or(a)) {
- if (b == get_Or_left(a) || b == get_Or_right(a)) {
- /* (a|X) & a */
- n = b;
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_AND);
- return n;
- }
+ /* (a|X) & a => a*/
+ if ((is_Or(a) || is_Or_Eor_Add(a))
+ && (b == get_binop_left(a) || b == get_binop_right(a))) {
+ n = b;
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_AND);
+ return n;
}
- if (is_Or(b)) {
- if (a == get_Or_left(b) || a == get_Or_right(b)) {
- /* a & (a|X) */
- n = a;
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_AND);
- return n;
- }
+ /* a & (a|X) => a*/
+ if ((is_Or(b) || is_Or_Eor_Add(b))
+ && (a == get_binop_left(b) || a == get_binop_right(b))) {
+ n = a;
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_AND);
+ return n;
}
return n;
-} /* equivalent_node_And */
+}
/**
* Try to remove useless Conv's:
*/
-static ir_node *equivalent_node_Conv(ir_node *n) {
+static ir_node *equivalent_node_Conv(ir_node *n)
+{
ir_node *oldn = n;
ir_node *a = get_Conv_op(n);
ir_mode *n_mode = get_irn_mode(n);
ir_mode *a_mode = get_irn_mode(a);
-restart:
if (n_mode == a_mode) { /* No Conv necessary */
- if (get_Conv_strict(n)) {
- ir_node *p = a;
-
- /* neither Minus nor Abs nor Confirm change the precision,
- so we can "look-through" */
- for (;;) {
- if (is_Minus(p)) {
- p = get_Minus_op(p);
- } else if (is_Abs(p)) {
- p = get_Abs_op(p);
- } else if (is_Confirm(p)) {
- p = get_Confirm_value(p);
- } else {
- /* stop here */
- break;
- }
- }
- if (is_Conv(p) && get_Conv_strict(p)) {
- /* we known already, that a_mode == n_mode, and neither
- Abs nor Minus change the mode, so the second Conv
- can be kicked */
- assert(get_irn_mode(p) == n_mode);
- n = a;
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CONV);
- return n;
- }
- if (is_Proj(p)) {
- ir_node *pred = get_Proj_pred(p);
- if (is_Load(pred)) {
- /* Loads always return with the exact precision of n_mode */
- assert(get_Load_mode(pred) == n_mode);
- n = a;
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CONV);
- return n;
- }
- if (is_Proj(pred) && get_Proj_proj(pred) == pn_Start_T_args) {
- pred = get_Proj_pred(pred);
- if (is_Start(pred)) {
- /* Arguments always return with the exact precision,
- as strictConv's are place before Call -- if the
- caller was compiled with the same setting.
- Otherwise, the semantics is probably still right. */
- assert(get_irn_mode(p) == n_mode);
- n = a;
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CONV);
- return n;
- }
- }
- }
- if (is_Conv(a)) {
- /* special case: the immediate predecessor is also a Conv */
- if (! get_Conv_strict(a)) {
- /* first one is not strict, kick it */
- a = get_Conv_op(a);
- a_mode = get_irn_mode(a);
- set_Conv_op(n, a);
- goto restart;
- }
- /* else both are strict conv, second is superfluous */
- n = a;
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CONV);
- return n;
- }
- } else {
- n = a;
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CONV);
- return n;
- }
+ n = a;
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CONV);
+ return n;
} else if (is_Conv(a)) { /* Conv(Conv(b)) */
ir_node *b = get_Conv_op(a);
ir_mode *b_mode = get_irn_mode(b);
- if (get_Conv_strict(n) && get_Conv_strict(a)) {
- /* both are strict conv */
- if (smaller_mode(a_mode, n_mode)) {
- /* both are strict, but the first is smaller, so
- the second cannot remove more precision, remove the
- strict bit */
- set_Conv_strict(n, 0);
- }
- }
- if (n_mode == b_mode) {
- if (! get_Conv_strict(n) && ! get_Conv_strict(a)) {
- if (n_mode == mode_b) {
- n = b; /* Convb(Conv*(xxxb(...))) == xxxb(...) */
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV);
- return n;
- } else if (get_mode_arithmetic(n_mode) == get_mode_arithmetic(a_mode)) {
- if (values_in_mode(b_mode, a_mode)) {
- n = b; /* ConvS(ConvL(xxxS(...))) == xxxS(...) */
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV);
- return n;
- }
- }
- }
- if (mode_is_int(n_mode) && get_mode_arithmetic(a_mode) == irma_ieee754) {
- /* ConvI(ConvF(I)) -> I, iff float mantissa >= int mode */
- unsigned int_mantissa = get_mode_size_bits(n_mode) - (mode_is_signed(n_mode) ? 1 : 0);
- unsigned float_mantissa = tarval_ieee754_get_mantissa_size(a_mode);
-
- if (float_mantissa >= int_mantissa) {
- n = b;
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV);
- return n;
- }
- }
- if (is_Conv(b)) {
- if (smaller_mode(b_mode, a_mode)) {
- if (get_Conv_strict(n))
- set_Conv_strict(b, 1);
- n = b; /* ConvA(ConvB(ConvA(...))) == ConvA(...) */
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV);
- return n;
- }
- }
+ if (n_mode == b_mode && values_in_mode(b_mode, a_mode)) {
+ n = b;
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV);
+ return n;
}
}
return n;
-} /* equivalent_node_Conv */
-
-/**
- * A Cast may be removed if the type of the previous node
- * is already the type of the Cast.
- */
-static ir_node *equivalent_node_Cast(ir_node *n) {
- ir_node *oldn = n;
- ir_node *pred = get_Cast_op(n);
-
- if (get_irn_type(pred) == get_Cast_type(n)) {
- n = pred;
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CAST);
- }
- return n;
-} /* equivalent_node_Cast */
+}
/**
* - fold Phi-nodes, iff they have only one predecessor except
* themselves.
*/
-static ir_node *equivalent_node_Phi(ir_node *n) {
+static ir_node *equivalent_node_Phi(ir_node *n)
+{
int i, n_preds;
ir_node *oldn = n;
- ir_node *block;
ir_node *first_val = NULL; /* to shutup gcc */
- if (!get_opt_normalize()) return n;
+ if (!get_opt_optimize() &&
+ !irg_is_constrained(get_irn_irg(n), IR_GRAPH_CONSTRAINT_CONSTRUCTION))
+ return n;
n_preds = get_Phi_n_preds(n);
- block = get_nodes_block(n);
- if (is_Block_dead(block)) /* Control dead */
- return get_irg_bad(current_ir_graph);
-
- if (n_preds == 0) return n; /* Phi of dead Region without predecessors. */
+ /* Phi of dead Region without predecessors. */
+ if (n_preds == 0)
+ return n;
/* Find first non-self-referencing input */
for (i = 0; i < n_preds; ++i) {
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.
- * This is not that bad as it sounds, optimize_cf() removes bad control flow
- * (and bad Phi predecessors), so live code is optimized later.
- */
- && (! is_Bad(get_Block_cfgpred(block, i)))
-#endif
- ) { /* value not dead */
- break; /* then found first value. */
+ /* not self pointer */
+ if (first_val != n) {
+ /* then found first value. */
+ break;
}
}
- if (i >= n_preds) {
- /* A totally Bad or self-referencing Phi (we didn't break the above loop) */
- return get_irg_bad(current_ir_graph);
- }
-
/* search for rest of inputs, determine if any of these
are non-self-referencing */
while (++i < n_preds) {
ir_node *scnd_val = get_Phi_pred(n, i);
- if ( (scnd_val != n)
- && (scnd_val != first_val)
-#if 0
- /* see above */
- && (! is_Bad(get_Block_cfgpred(block, i)))
-#endif
- ) {
+ if (scnd_val != n && scnd_val != first_val) {
break;
}
}
- if (i >= n_preds) {
+ if (i >= n_preds && !is_Dummy(first_val)) {
/* Fold, if no multiple distinct non-self-referencing inputs */
n = first_val;
DBG_OPT_PHI(oldn, n);
}
return n;
-} /* equivalent_node_Phi */
-
-/**
- * Several optimizations:
- * - fold Sync-nodes, iff they have only one predecessor except
- * themselves.
- */
-static ir_node *equivalent_node_Sync(ir_node *n) {
- int arity = get_Sync_n_preds(n);
- int i;
-
- for (i = 0; i < arity;) {
- ir_node *pred = get_Sync_pred(n, i);
- int j;
-
- /* Remove Bad predecessors */
- if (is_Bad(pred)) {
- del_Sync_n(n, i);
- --arity;
- continue;
- }
-
- /* Remove duplicate predecessors */
- for (j = 0;; ++j) {
- if (j >= i) {
- ++i;
- break;
- }
- if (get_Sync_pred(n, j) == pred) {
- del_Sync_n(n, i);
- --arity;
- break;
- }
- }
- }
-
- if (arity == 0) return get_irg_bad(current_ir_graph);
- if (arity == 1) return get_Sync_pred(n, 0);
- return n;
-} /* equivalent_node_Sync */
+}
/**
* Optimize Proj(Tuple).
*/
-static ir_node *equivalent_node_Proj_Tuple(ir_node *proj) {
+static ir_node *equivalent_node_Proj_Tuple(ir_node *proj)
+{
ir_node *oldn = proj;
ir_node *tuple = get_Proj_pred(proj);
DBG_OPT_TUPLE(oldn, tuple, proj);
return proj;
-} /* equivalent_node_Proj_Tuple */
+}
/**
* Optimize a / 1 = a.
*/
-static ir_node *equivalent_node_Proj_Div(ir_node *proj) {
- ir_node *oldn = proj;
- ir_node *div = get_Proj_pred(proj);
- ir_node *b = get_Div_right(div);
- tarval *tb = value_of(b);
+static ir_node *equivalent_node_Proj_Div(ir_node *proj)
+{
+ ir_node *oldn = proj;
+ ir_node *div = get_Proj_pred(proj);
+ ir_node *b = get_Div_right(div);
+ ir_tarval *tb = value_of(b);
/* Div is not commutative. */
if (tarval_is_one(tb)) { /* div(x, 1) == x */
}
}
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);
- 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);
- 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.
*/
-static ir_node *equivalent_node_Proj_CopyB(ir_node *proj) {
+static ir_node *equivalent_node_Proj_CopyB(ir_node *proj)
+{
ir_node *oldn = proj;
ir_node *copyb = get_Proj_pred(proj);
ir_node *a = get_CopyB_dst(copyb);
if (a == b) {
/* Turn CopyB into a tuple (mem, jmp, bad, bad) */
switch (get_Proj_proj(proj)) {
- case pn_CopyB_M_regular:
+ case pn_CopyB_M:
proj = get_CopyB_mem(copyb);
DBG_OPT_ALGSIM0(oldn, proj, FS_OPT_NOP);
break;
-
- case pn_CopyB_X_except:
- DBG_OPT_EXC_REM(proj);
- proj = get_irg_bad(current_ir_graph);
- break;
}
}
return proj;
-} /* equivalent_node_Proj_CopyB */
+}
/**
* Optimize Bounds(idx, idx, upper) into idx.
*/
-static ir_node *equivalent_node_Proj_Bound(ir_node *proj) {
+static ir_node *equivalent_node_Proj_Bound(ir_node *proj)
+{
ir_node *oldn = proj;
ir_node *bound = get_Proj_pred(proj);
ir_node *idx = get_Bound_index(bound);
ret_tuple = 1;
else if (is_Bound(pred)) {
/*
- * idx was Bounds checked in the same MacroBlock previously,
- * it is still valid if lower <= pred_lower && pred_upper <= upper.
+ * idx was Bounds checked previously, it is still valid if
+ * lower <= pred_lower && pred_upper <= upper.
*/
ir_node *lower = get_Bound_lower(bound);
ir_node *upper = get_Bound_upper(bound);
if (get_Bound_lower(pred) == lower &&
- get_Bound_upper(pred) == upper &&
- get_irn_MacroBlock(bound) == get_irn_MacroBlock(pred)) {
+ get_Bound_upper(pred) == upper) {
/*
* One could expect that we simply return the previous
* Bound here. However, this would be wrong, as we could
DBG_OPT_EXC_REM(proj);
proj = get_Bound_mem(bound);
break;
- case pn_Bound_X_except:
- DBG_OPT_EXC_REM(proj);
- proj = get_irg_bad(current_ir_graph);
- break;
case pn_Bound_res:
proj = idx;
DBG_OPT_ALGSIM0(oldn, proj, FS_OPT_NOP);
break;
default:
/* cannot optimize pn_Bound_X_regular, handled in transform ... */
- ;
- }
- }
- return proj;
-} /* equivalent_node_Proj_Bound */
-
-/**
- * Optimize an Exception Proj(Load) with a non-null address.
- */
-static ir_node *equivalent_node_Proj_Load(ir_node *proj) {
- if (get_opt_ldst_only_null_ptr_exceptions()) {
- if (get_irn_mode(proj) == mode_X) {
- ir_node *load = get_Proj_pred(proj);
-
- /* get the Load address */
- const ir_node *addr = get_Load_ptr(load);
- const ir_node *confirm;
-
- if (value_not_null(addr, &confirm)) {
- if (get_Proj_proj(proj) == pn_Load_X_except) {
- DBG_OPT_EXC_REM(proj);
- return get_irg_bad(current_ir_graph);
- }
- }
- }
- }
- return proj;
-} /* equivalent_node_Proj_Load */
-
-/**
- * Optimize an Exception Proj(Store) with a non-null address.
- */
-static ir_node *equivalent_node_Proj_Store(ir_node *proj) {
- if (get_opt_ldst_only_null_ptr_exceptions()) {
- if (get_irn_mode(proj) == mode_X) {
- ir_node *store = get_Proj_pred(proj);
-
- /* get the load/store address */
- const ir_node *addr = get_Store_ptr(store);
- const ir_node *confirm;
-
- if (value_not_null(addr, &confirm)) {
- if (get_Proj_proj(proj) == pn_Store_X_except) {
- DBG_OPT_EXC_REM(proj);
- return get_irg_bad(current_ir_graph);
- }
- }
+ break;
}
}
return proj;
-} /* 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) {
+static ir_node *equivalent_node_Proj(ir_node *proj)
+{
ir_node *n = get_Proj_pred(proj);
-
- if (get_irn_mode(proj) == mode_X) {
- if (is_Block_dead(get_nodes_block(n))) {
- /* Remove dead control flow -- early gigo(). */
- return get_irg_bad(current_ir_graph);
- }
- }
if (n->op->ops.equivalent_node_Proj)
return n->op->ops.equivalent_node_Proj(proj);
return proj;
-} /* equivalent_node_Proj */
+}
/**
* Remove Id's.
*/
-static ir_node *equivalent_node_Id(ir_node *n) {
+static ir_node *equivalent_node_Id(ir_node *n)
+{
ir_node *oldn = n;
do {
DBG_OPT_ID(oldn, n);
return n;
-} /* equivalent_node_Id */
+}
/**
* Optimize a Mux.
*/
static ir_node *equivalent_node_Mux(ir_node *n)
{
- ir_node *oldn = n, *sel = get_Mux_sel(n);
- ir_node *n_t, *n_f;
- tarval *ts = value_of(sel);
+ ir_node *oldn = n, *sel = get_Mux_sel(n);
+ ir_node *n_t, *n_f;
+ ir_tarval *ts = value_of(sel);
+
+ if (ts == tarval_bad && is_Cmp(sel)) {
+ /* try again with a direct call to compute_cmp, as we don't care
+ * about the MODEB_LOWERED flag here */
+ ts = compute_cmp_ext(sel);
+ }
/* Mux(true, f, t) == t */
if (ts == tarval_b_true) {
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.
* Replace Confirms(x, '=', Constlike) by Constlike.
*/
-static ir_node *equivalent_node_Confirm(ir_node *n) {
- ir_node *pred = get_Confirm_value(n);
- pn_Cmp pnc = get_Confirm_cmp(n);
+static ir_node *equivalent_node_Confirm(ir_node *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);
}
- if (get_opt_remove_confirm())
- return get_Confirm_value(n);
return n;
}
* If a node returns a Tuple we can not just skip it. If the size of the
* in array fits, we transform n into a tuple (e.g., Div).
*/
-ir_node *equivalent_node(ir_node *n) {
+ir_node *equivalent_node(ir_node *n)
+{
if (n->op->ops.equivalent_node)
return n->op->ops.equivalent_node(n);
return n;
-} /* equivalent_node */
-
-/**
- * Sets the default equivalent node operation for an ir_op_ops.
- *
- * @param code the opcode for the default operation
- * @param ops the operations initialized
- *
- * @return
- * The operations.
- */
-static ir_op_ops *firm_set_default_equivalent_node(ir_opcode code, ir_op_ops *ops)
-{
-#define CASE(a) \
- case iro_##a: \
- ops->equivalent_node = equivalent_node_##a; \
- break
-#define CASE_PROJ(a) \
- case iro_##a: \
- ops->equivalent_node_Proj = equivalent_node_Proj_##a; \
- break
-
- switch (code) {
- CASE(Block);
- CASE(Jmp);
- CASE(Raise);
- CASE(Eor);
- CASE(Add);
- CASE(Shl);
- CASE(Shr);
- CASE(Shrs);
- CASE(Rotl);
- CASE(Sub);
- CASE(Not);
- CASE(Minus);
- CASE(Mul);
- CASE(Or);
- CASE(And);
- CASE(Conv);
- CASE(Cast);
- CASE(Phi);
- CASE(Sync);
- CASE_PROJ(Tuple);
- CASE_PROJ(Div);
- CASE_PROJ(Quot);
- CASE_PROJ(DivMod);
- CASE_PROJ(CopyB);
- CASE_PROJ(Bound);
- CASE_PROJ(Load);
- CASE_PROJ(Store);
- CASE(Proj);
- CASE(Id);
- CASE(Mux);
- CASE(Confirm);
- default:
- /* leave NULL */;
- }
-
- return ops;
-#undef CASE
-#undef CASE_PROJ
-} /* firm_set_default_equivalent_node */
+}
/**
* Returns non-zero if a node is a Phi node
* with all predecessors constant.
*/
-static int is_const_Phi(ir_node *n) {
+static int is_const_Phi(ir_node *n)
+{
int i;
if (! is_Phi(n) || get_irn_arity(n) == 0)
return 0;
}
return 1;
-} /* is_const_Phi */
+}
-typedef tarval *(*tarval_sub_type)(tarval *a, tarval *b, ir_mode *mode);
-typedef tarval *(*tarval_binop_type)(tarval *a, tarval *b);
+typedef ir_tarval *(*tarval_sub_type)(ir_tarval *a, ir_tarval *b, ir_mode *mode);
+typedef ir_tarval *(*tarval_binop_type)(ir_tarval *a, ir_tarval *b);
/**
* in reality eval_func should be tarval (*eval_func)() but incomplete
/**
* Wrapper for the tarval binop evaluation, tarval_sub has one more parameter.
*/
-static tarval *do_eval(eval_func eval, tarval *a, tarval *b, ir_mode *mode)
+static ir_tarval *do_eval(eval_func eval, ir_tarval *a, ir_tarval *b, ir_mode *mode)
{
if (eval == (eval_func) tarval_sub) {
tarval_sub_type func = (tarval_sub_type)eval;
*
* @return a new Phi node if the conversion was successful, NULL else
*/
-static ir_node *apply_binop_on_phi(ir_node *phi, tarval *other, eval_func eval, ir_mode *mode, int left) {
- tarval *tv;
- void **res;
- ir_node *pred;
- ir_graph *irg;
- int i, n = get_irn_arity(phi);
-
- NEW_ARR_A(void *, res, n);
+static ir_node *apply_binop_on_phi(ir_node *phi, ir_tarval *other, eval_func eval, ir_mode *mode, int left)
+{
+ int n = get_irn_arity(phi);
+ ir_tarval **tvs = ALLOCAN(ir_tarval*, n);
if (left) {
- for (i = 0; i < n; ++i) {
- pred = get_irn_n(phi, i);
- tv = get_Const_tarval(pred);
- tv = do_eval(eval, other, tv, mode);
+ for (int i = 0; i < n; ++i) {
+ ir_node *pred = get_irn_n(phi, i);
+ ir_tarval *tv = get_Const_tarval(pred);
+ tv = do_eval(eval, other, tv, mode);
if (tv == tarval_bad) {
/* folding failed, bad */
return NULL;
}
- res[i] = tv;
+ tvs[i] = tv;
}
} else {
- for (i = 0; i < n; ++i) {
- pred = get_irn_n(phi, i);
- tv = get_Const_tarval(pred);
- tv = do_eval(eval, tv, other, mode);
+ for (int i = 0; i < n; ++i) {
+ ir_node *pred = get_irn_n(phi, i);
+ ir_tarval *tv = get_Const_tarval(pred);
+ tv = do_eval(eval, tv, other, mode);
if (tv == tarval_bad) {
/* folding failed, bad */
return 0;
}
- res[i] = tv;
+ tvs[i] = tv;
}
}
- irg = current_ir_graph;
- for (i = 0; i < n; ++i) {
- pred = get_irn_n(phi, i);
- res[i] = new_r_Const_type(irg, res[i], get_Const_type(pred));
+ ir_graph *irg = get_irn_irg(phi);
+ ir_node **res = ALLOCAN(ir_node*, n);
+ for (int i = 0; i < n; ++i) {
+ res[i] = new_r_Const(irg, tvs[i]);
}
- return new_r_Phi(get_nodes_block(phi), n, (ir_node **)res, mode);
-} /* apply_binop_on_phi */
+ ir_node *block = get_nodes_block(phi);
+ return new_r_Phi(block, n, res, mode);
+}
/**
* Apply an evaluator on a binop with two constant Phi.
*
* @return a new Phi node if the conversion was successful, NULL else
*/
-static ir_node *apply_binop_on_2_phis(ir_node *a, ir_node *b, eval_func eval, ir_mode *mode) {
- tarval *tv_l, *tv_r, *tv;
- void **res;
- ir_node *pred;
- ir_graph *irg;
- int i, n;
-
+static ir_node *apply_binop_on_2_phis(ir_node *a, ir_node *b, eval_func eval, ir_mode *mode)
+{
if (get_nodes_block(a) != get_nodes_block(b))
return NULL;
- n = get_irn_arity(a);
- NEW_ARR_A(void *, res, n);
-
- for (i = 0; i < n; ++i) {
- pred = get_irn_n(a, i);
- tv_l = get_Const_tarval(pred);
- pred = get_irn_n(b, i);
- tv_r = get_Const_tarval(pred);
- tv = do_eval(eval, tv_l, tv_r, mode);
+ int n = get_irn_arity(a);
+ ir_tarval **tvs = ALLOCAN(ir_tarval*, n);
+ for (int i = 0; i < n; ++i) {
+ ir_node *pred_a = get_irn_n(a, i);
+ ir_tarval *tv_l = get_Const_tarval(pred_a);
+ ir_node *pred_b = get_irn_n(b, i);
+ ir_tarval *tv_r = get_Const_tarval(pred_b);
+ ir_tarval *tv = do_eval(eval, tv_l, tv_r, mode);
if (tv == tarval_bad) {
/* folding failed, bad */
return NULL;
}
- res[i] = tv;
+ tvs[i] = tv;
}
- irg = current_ir_graph;
- for (i = 0; i < n; ++i) {
- pred = get_irn_n(a, i);
- res[i] = new_r_Const_type(irg, res[i], get_Const_type(pred));
+ ir_graph *irg = get_irn_irg(a);
+ ir_node **res = ALLOCAN(ir_node*, n);
+ for (int i = 0; i < n; ++i) {
+ res[i] = new_r_Const(irg, tvs[i]);
}
- return new_r_Phi(get_nodes_block(a), n, (ir_node **)res, mode);
-} /* apply_binop_on_2_phis */
+ ir_node *block = get_nodes_block(a);
+ return new_r_Phi(block, n, res, mode);
+}
/**
* Apply an evaluator on a unop with a constant operator (a Phi).
*
* @return a new Phi node if the conversion was successful, NULL else
*/
-static ir_node *apply_unop_on_phi(ir_node *phi, tarval *(*eval)(tarval *)) {
- tarval *tv;
- void **res;
- ir_node *pred;
- ir_mode *mode;
- ir_graph *irg;
- int i, n = get_irn_arity(phi);
-
- NEW_ARR_A(void *, res, n);
- for (i = 0; i < n; ++i) {
- pred = get_irn_n(phi, i);
- tv = get_Const_tarval(pred);
- tv = eval(tv);
+static ir_node *apply_unop_on_phi(ir_node *phi, ir_tarval *(*eval)(ir_tarval *))
+{
+ int n = get_irn_arity(phi);
+ ir_tarval **tvs = ALLOCAN(ir_tarval*, n);
+ for (int i = 0; i < n; ++i) {
+ ir_node *pred = get_irn_n(phi, i);
+ ir_tarval *tv = get_Const_tarval(pred);
+ tv = eval(tv);
if (tv == tarval_bad) {
/* folding failed, bad */
return 0;
}
- res[i] = tv;
+ tvs[i] = tv;
}
- mode = get_irn_mode(phi);
- irg = current_ir_graph;
- for (i = 0; i < n; ++i) {
- pred = get_irn_n(phi, i);
- res[i] = new_r_Const_type(irg, res[i], get_Const_type(pred));
+ ir_graph *irg = get_irn_irg(phi);
+ ir_node **res = ALLOCAN(ir_node*, n);
+ for (int i = 0; i < n; ++i) {
+ res[i] = new_r_Const(irg, tvs[i]);
}
- return new_r_Phi(get_nodes_block(phi), n, (ir_node **)res, mode);
-} /* apply_unop_on_phi */
+ ir_node *block = get_nodes_block(phi);
+ ir_mode *mode = get_irn_mode(phi);
+ return new_r_Phi(block, n, res, mode);
+}
/**
* Apply a conversion on a constant operator (a Phi).
*
* @return a new Phi node if the conversion was successful, NULL else
*/
-static ir_node *apply_conv_on_phi(ir_node *phi, ir_mode *mode) {
- tarval *tv;
- void **res;
- ir_node *pred;
- ir_graph *irg;
- int i, n = get_irn_arity(phi);
-
- NEW_ARR_A(void *, res, n);
- for (i = 0; i < n; ++i) {
- pred = get_irn_n(phi, i);
- tv = get_Const_tarval(pred);
- tv = tarval_convert_to(tv, mode);
+static ir_node *apply_conv_on_phi(ir_node *phi, ir_mode *mode)
+{
+ int n = get_irn_arity(phi);
+ ir_tarval **tvs = ALLOCAN(ir_tarval*, n);
+ for (int i = 0; i < n; ++i) {
+ ir_node *pred = get_irn_n(phi, i);
+ ir_tarval *tv = get_Const_tarval(pred);
+ tv = tarval_convert_to(tv, mode);
if (tv == tarval_bad) {
/* folding failed, bad */
return 0;
}
- res[i] = tv;
+ tvs[i] = tv;
}
- irg = current_ir_graph;
- for (i = 0; i < n; ++i) {
- pred = get_irn_n(phi, i);
- res[i] = new_r_Const_type(irg, res[i], get_Const_type(pred));
+ ir_graph *irg = get_irn_irg(phi);
+ ir_node **res = ALLOCAN(ir_node*, n);
+ for (int i = 0; i < n; ++i) {
+ res[i] = new_r_Const(irg, tvs[i]);
}
- return new_r_Phi(get_nodes_block(phi), n, (ir_node **)res, mode);
-} /* apply_conv_on_phi */
+ ir_node *block = get_nodes_block(phi);
+ return new_r_Phi(block, n, res, mode);
+}
/**
* Transform AddP(P, ConvIs(Iu)), AddP(P, ConvIu(Is)) and
* SubP(P, ConvIs(Iu)), SubP(P, ConvIu(Is)).
* If possible, remove the Conv's.
*/
-static ir_node *transform_node_AddSub(ir_node *n) {
+static ir_node *transform_node_AddSub(ir_node *n)
+{
ir_mode *mode = get_irn_mode(n);
if (mode_is_reference(mode)) {
}
return n;
-} /* transform_node_AddSub */
+}
#define HANDLE_BINOP_PHI(eval, a, b, c, mode) \
+ do { \
c = NULL; \
if (is_Const(b) && is_const_Phi(a)) { \
/* check for Op(Phi, Const) */ \
if (c) { \
DBG_OPT_ALGSIM0(oldn, c, FS_OPT_CONST_PHI); \
return c; \
- }
+ } \
+ } while(0)
#define HANDLE_UNOP_PHI(eval, a, c) \
+ do { \
c = NULL; \
if (is_const_Phi(a)) { \
/* check for Op(Phi) */ \
DBG_OPT_ALGSIM0(oldn, c, FS_OPT_CONST_PHI); \
return c; \
} \
- }
+ } \
+ } while(0)
/**
- * Do the AddSub optimization, then Transform
- * Constant folding on Phi
- * Add(a,a) -> Mul(a, 2)
- * Add(Mul(a, x), a) -> Mul(a, x+1)
- * if the mode is integer or float.
- * Transform Add(a,-b) into Sub(a,b).
- * Reassociation might fold this further.
+ * Create a 0 constant of given mode.
*/
-static ir_node *transform_node_Add(ir_node *n) {
- ir_mode *mode;
- ir_node *a, *b, *c, *oldn = n;
-
- n = transform_node_AddSub(n);
+static ir_node *create_zero_const(ir_graph *irg, ir_mode *mode)
+{
+ ir_tarval *tv = get_mode_null(mode);
+ ir_node *cnst = new_r_Const(irg, tv);
- a = get_Add_left(n);
- b = get_Add_right(n);
+ return cnst;
+}
- mode = get_irn_mode(n);
+static bool is_shiftop(const ir_node *n)
+{
+ return is_Shl(n) || is_Shr(n) || is_Shrs(n) || is_Rotl(n);
+}
- if (mode_is_reference(mode)) {
- ir_mode *lmode = get_irn_mode(a);
+/* the order of the values is important! */
+typedef enum const_class {
+ const_const = 0,
+ const_like = 1,
+ const_other = 2
+} const_class;
+
+static const_class classify_const(const ir_node* n)
+{
+ if (is_Const(n)) return const_const;
+ if (is_irn_constlike(n)) return const_like;
+ return const_other;
+}
+
+/**
+ * Determines whether r is more constlike or has a larger index (in that order)
+ * than l.
+ */
+static bool operands_are_normalized(const ir_node *l, const ir_node *r)
+{
+ const const_class l_order = classify_const(l);
+ const const_class r_order = classify_const(r);
+ return
+ l_order > r_order ||
+ (l_order == r_order && get_irn_idx(l) <= get_irn_idx(r));
+}
+
+static bool is_cmp_unequal(const ir_node *node)
+{
+ ir_relation relation = get_Cmp_relation(node);
+ ir_node *left = get_Cmp_left(node);
+ ir_node *right = get_Cmp_right(node);
+ ir_mode *mode = get_irn_mode(left);
+
+ if (relation == ir_relation_less_greater)
+ return true;
+
+ if (!mode_is_signed(mode) && is_Const(right) && is_Const_null(right))
+ return relation == ir_relation_greater;
+ return false;
+}
+
+/**
+ * returns true for Cmp(x == 0) or Cmp(x != 0)
+ */
+static bool is_cmp_equality_zero(const ir_node *node)
+{
+ ir_relation relation;
+ ir_node *right = get_Cmp_right(node);
+
+ if (!is_Const(right) || !is_Const_null(right))
+ return false;
+ relation = get_Cmp_relation(node);
+ return relation == ir_relation_equal
+ || relation == ir_relation_less_greater
+ || (!mode_is_signed(get_irn_mode(right))
+ && relation == ir_relation_greater);
+}
+
+/**
+ * Optimize a Or(And(Or(And(v,c4),c3),c2),c1) pattern if possible.
+ * Such pattern may arise in bitfield stores.
+ *
+ * value c4 value c4 & c2
+ * AND c3 AND c1 | c3
+ * OR c2 ===> OR
+ * AND c1
+ * OR
+ *
+ *
+ * value c2 value c1
+ * AND c1 ===> OR if (c1 | c2) == 0x111..11
+ * OR
+ */
+static ir_node *transform_node_Or_bf_store(ir_node *irn_or)
+{
+ ir_node *irn_and, *c1;
+ ir_node *or_l, *c2;
+ ir_node *and_l, *c3;
+ ir_node *value, *c4;
+ ir_node *new_and, *new_const, *block;
+ ir_mode *mode = get_irn_mode(irn_or);
+
+ ir_tarval *tv1, *tv2, *tv3, *tv4, *tv;
+
+ for (;;) {
+ ir_graph *irg;
+ irn_and = get_binop_left(irn_or);
+ c1 = get_binop_right(irn_or);
+ if (!is_Const(c1) || !is_And(irn_and))
+ return irn_or;
+
+ or_l = get_binop_left(irn_and);
+ c2 = get_binop_right(irn_and);
+ if (!is_Const(c2))
+ return irn_or;
+
+ tv1 = get_Const_tarval(c1);
+ tv2 = get_Const_tarval(c2);
+
+ tv = tarval_or(tv1, tv2);
+ if (tarval_is_all_one(tv)) {
+ /* the AND does NOT clear a bit with isn't set by the OR */
+ set_binop_left(irn_or, or_l);
+ set_binop_right(irn_or, c1);
+
+ /* check for more */
+ continue;
+ }
+
+ if (!is_Or(or_l) && !is_Or_Eor_Add(or_l))
+ return irn_or;
+
+ and_l = get_binop_left(or_l);
+ c3 = get_binop_right(or_l);
+ if (!is_Const(c3) || !is_And(and_l))
+ return irn_or;
+
+ value = get_binop_left(and_l);
+ c4 = get_binop_right(and_l);
+ if (!is_Const(c4))
+ return irn_or;
+
+ /* ok, found the pattern, check for conditions */
+ assert(mode == get_irn_mode(irn_and));
+ assert(mode == get_irn_mode(or_l));
+ assert(mode == get_irn_mode(and_l));
+
+ tv3 = get_Const_tarval(c3);
+ tv4 = get_Const_tarval(c4);
+
+ tv = tarval_or(tv4, tv2);
+ if (!tarval_is_all_one(tv)) {
+ /* have at least one 0 at the same bit position */
+ return irn_or;
+ }
+
+ if (tv3 != tarval_andnot(tv3, tv4)) {
+ /* bit in the or_mask is outside the and_mask */
+ return irn_or;
+ }
+
+ if (tv1 != tarval_andnot(tv1, tv2)) {
+ /* bit in the or_mask is outside the and_mask */
+ return irn_or;
+ }
+
+ /* ok, all conditions met */
+ block = get_nodes_block(irn_or);
+ irg = get_irn_irg(block);
+
+ new_and = new_r_And(block, value, new_r_Const(irg, tarval_and(tv4, tv2)), mode);
+
+ new_const = new_r_Const(irg, tarval_or(tv3, tv1));
+
+ set_binop_left(irn_or, new_and);
+ set_binop_right(irn_or, new_const);
+
+ /* check for more */
+ }
+}
+
+/**
+ * Optimize an Or(shl(x, c), shr(x, bits - c)) into a Rotl
+ */
+static ir_node *transform_node_Or_Rotl(ir_node *irn_or)
+{
+ ir_mode *mode = get_irn_mode(irn_or);
+ ir_node *shl, *shr, *block;
+ ir_node *irn, *x, *c1, *c2, *n;
+ ir_tarval *tv1, *tv2;
+
+ /* some backends can't handle rotl */
+ if (!be_get_backend_param()->support_rotl)
+ return irn_or;
+
+ if (! mode_is_int(mode))
+ return irn_or;
+
+ shl = get_binop_left(irn_or);
+ shr = get_binop_right(irn_or);
+
+ if (is_Shr(shl)) {
+ if (!is_Shl(shr))
+ return irn_or;
+
+ irn = shl;
+ shl = shr;
+ shr = irn;
+ } else if (!is_Shl(shl)) {
+ return irn_or;
+ } else if (!is_Shr(shr)) {
+ return irn_or;
+ }
+ x = get_Shl_left(shl);
+ if (x != get_Shr_left(shr))
+ return irn_or;
+
+ c1 = get_Shl_right(shl);
+ c2 = get_Shr_right(shr);
+ if (is_Const(c1) && is_Const(c2)) {
+ tv1 = get_Const_tarval(c1);
+ if (! tarval_is_long(tv1))
+ return irn_or;
+
+ tv2 = get_Const_tarval(c2);
+ if (! tarval_is_long(tv2))
+ return irn_or;
+
+ if (get_tarval_long(tv1) + get_tarval_long(tv2)
+ != (int) get_mode_size_bits(mode))
+ return irn_or;
+
+ /* yet, condition met */
+ block = get_nodes_block(irn_or);
+
+ n = new_r_Rotl(block, x, c1, mode);
+
+ DBG_OPT_ALGSIM1(irn_or, shl, shr, n, FS_OPT_OR_SHFT_TO_ROTL);
+ return n;
+ }
+
+ /* Note: the obvious rot formulation (a << x) | (a >> (32-x)) gets
+ * transformed to (a << x) | (a >> -x) by transform_node_shift_modulo() */
+ if (!ir_is_negated_value(c1, c2)) {
+ return irn_or;
+ }
+
+ /* yet, condition met */
+ block = get_nodes_block(irn_or);
+ n = new_r_Rotl(block, x, c1, mode);
+ DBG_OPT_ALGSIM0(irn_or, n, FS_OPT_OR_SHFT_TO_ROTL);
+ return n;
+}
+
+/**
+ * Prototype of a recursive transform function
+ * for bitwise distributive transformations.
+ */
+typedef ir_node* (*recursive_transform)(ir_node *n);
+
+/**
+ * makes use of distributive laws for and, or, eor
+ * and(a OP c, b OP c) -> and(a, b) OP c
+ * note, might return a different op than n
+ */
+static ir_node *transform_bitwise_distributive(ir_node *n,
+ recursive_transform trans_func)
+{
+ ir_node *oldn = n;
+ ir_node *a = get_binop_left(n);
+ ir_node *b = get_binop_right(n);
+ ir_op *op = get_irn_op(a);
+ ir_op *op_root = get_irn_op(n);
+
+ if (op != get_irn_op(b))
+ return n;
+
+ /* and(conv(a), conv(b)) -> conv(and(a,b)) */
+ if (op == op_Conv) {
+ ir_node *a_op = get_Conv_op(a);
+ ir_node *b_op = get_Conv_op(b);
+ ir_mode *a_mode = get_irn_mode(a_op);
+ ir_mode *b_mode = get_irn_mode(b_op);
+ if (a_mode == b_mode && (mode_is_int(a_mode) || a_mode == mode_b)) {
+ ir_node *blk = get_nodes_block(n);
+
+ n = exact_copy(n);
+ set_binop_left(n, a_op);
+ set_binop_right(n, b_op);
+ set_irn_mode(n, a_mode);
+ n = trans_func(n);
+ n = new_r_Conv(blk, n, get_irn_mode(oldn));
+
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV);
+ return n;
+ }
+ }
+
+ if (op == op_Eor) {
+ /* nothing to gain here */
+ return n;
+ }
+
+ if (op == op_Shrs || op == op_Shr || op == op_Shl
+ || op == op_And || op == op_Or || op == op_Eor) {
+ ir_node *a_left = get_binop_left(a);
+ ir_node *a_right = get_binop_right(a);
+ ir_node *b_left = get_binop_left(b);
+ ir_node *b_right = get_binop_right(b);
+ ir_node *c = NULL;
+ ir_node *op1 = NULL;
+ ir_node *op2 = NULL;
+
+ if (is_op_commutative(op)) {
+ if (a_left == b_left) {
+ c = a_left;
+ op1 = a_right;
+ op2 = b_right;
+ } else if (a_left == b_right) {
+ c = a_left;
+ op1 = a_right;
+ op2 = b_left;
+ } else if (a_right == b_left) {
+ c = a_right;
+ op1 = a_left;
+ op2 = b_right;
+ }
+ }
+ if (a_right == b_right) {
+ c = a_right;
+ op1 = a_left;
+ op2 = b_left;
+ }
+
+ if (c != NULL) {
+ /* (a sop c) & (b sop c) => (a & b) sop c */
+ ir_node *blk = get_nodes_block(n);
+
+ ir_node *new_n = exact_copy(n);
+ set_binop_left(new_n, op1);
+ set_binop_right(new_n, op2);
+ new_n = trans_func(new_n);
+
+ if (op_root == op_Eor && op == op_Or) {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_mode *mode = get_irn_mode(c);
+
+ c = new_rd_Not(dbgi, blk, c, mode);
+ n = new_rd_And(dbgi, blk, new_n, c, mode);
+ } else {
+ n = exact_copy(a);
+ set_nodes_block(n, blk);
+ set_binop_left(n, new_n);
+ set_binop_right(n, c);
+ add_identities(n);
+ }
+
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_SHIFT_AND);
+ return n;
+ }
+ }
+
+ return n;
+}
+
+/**
+ * normalisation: (x >> c1) & c2 to (x & (c2<<c1)) >> c1
+ * (we can use:
+ * - and, or, xor instead of &
+ * - Shl, Shr, Shrs, rotl instead of >>
+ * (with a special case for Or/Xor + Shrs)
+ *
+ * This normalisation is usually good for the backend since << C can often be
+ * matched as address-mode.
+ */
+static ir_node *transform_node_bitop_shift(ir_node *n)
+{
+ ir_graph *irg = get_irn_irg(n);
+ ir_node *left = get_binop_left(n);
+ ir_node *right = get_binop_right(n);
+ ir_mode *mode = get_irn_mode(n);
+ ir_node *shift_left;
+ ir_node *shift_right;
+ ir_node *block;
+ dbg_info *dbg_bitop;
+ dbg_info *dbg_shift;
+ ir_node *new_bitop;
+ ir_node *new_shift;
+ ir_node *new_const;
+ ir_tarval *tv1;
+ ir_tarval *tv2;
+ ir_tarval *tv_bitop;
+
+ if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_NORMALISATION2))
+ return n;
+
+ assert(is_And(n) || is_Or(n) || is_Eor(n) || is_Or_Eor_Add(n));
+ if (!is_Const(right) || !is_shiftop(left))
+ return n;
+
+ shift_left = get_binop_left(left);
+ shift_right = get_binop_right(left);
+ if (!is_Const(shift_right))
+ return n;
+
+ /* doing it with Shrs is not legal if the Or/Eor affects the topmost bit */
+ if (is_Shrs(left)) {
+ /* TODO this could be improved */
+ return n;
+ }
+
+ irg = get_irn_irg(n);
+ block = get_nodes_block(n);
+ dbg_bitop = get_irn_dbg_info(n);
+ dbg_shift = get_irn_dbg_info(left);
+ tv1 = get_Const_tarval(shift_right);
+ tv2 = get_Const_tarval(right);
+ assert(get_tarval_mode(tv2) == mode);
+
+ if (is_Shl(left)) {
+ tv_bitop = tarval_shr(tv2, tv1);
+
+ /* Check whether we have lost some bits during the right shift. */
+ if (!is_And(n)) {
+ ir_tarval *tv_back_again = tarval_shl(tv_bitop, tv1);
+
+ if (tarval_cmp(tv_back_again, tv2) != ir_relation_equal)
+ return n;
+ }
+ } else if (is_Shr(left)) {
+ if (!is_And(n)) {
+ /*
+ * TODO this can be improved by checking whether
+ * the left shift produces an overflow
+ */
+ return n;
+ }
+ tv_bitop = tarval_shl(tv2, tv1);
+ } else {
+ assert(is_Rotl(left));
+ tv_bitop = tarval_rotl(tv2, tarval_neg(tv1));
+ }
+ new_const = new_r_Const(irg, tv_bitop);
+
+ if (is_And(n)) {
+ new_bitop = new_rd_And(dbg_bitop, block, shift_left, new_const, mode);
+ } else if (is_Or(n) || is_Or_Eor_Add(n)) {
+ new_bitop = new_rd_Or(dbg_bitop, block, shift_left, new_const, mode);
+ } else {
+ assert(is_Eor(n));
+ new_bitop = new_rd_Eor(dbg_bitop, block, shift_left, new_const, mode);
+ }
+
+ if (is_Shl(left)) {
+ new_shift = new_rd_Shl(dbg_shift, block, new_bitop, shift_right, mode);
+ } else if (is_Shr(left)) {
+ new_shift = new_rd_Shr(dbg_shift, block, new_bitop, shift_right, mode);
+ } else {
+ assert(is_Rotl(left));
+ new_shift = new_rd_Rotl(dbg_shift, block, new_bitop, shift_right, mode);
+ }
+
+ return new_shift;
+}
+
+static bool complement_values(const ir_node *a, const ir_node *b)
+{
+ if (is_Not(a) && get_Not_op(a) == b)
+ return true;
+ if (is_Not(b) && get_Not_op(b) == a)
+ return true;
+ if (is_Const(a) && is_Const(b)) {
+ ir_tarval *tv_a = get_Const_tarval(a);
+ ir_tarval *tv_b = get_Const_tarval(b);
+ return tarval_not(tv_a) == tv_b;
+ }
+ return false;
+}
+
+typedef ir_tarval *(tv_fold_binop_func)(ir_tarval *a, ir_tarval *b);
+
+/**
+ * for associative operations fold:
+ * op(op(x, c0), c1) to op(x, op(c0, c1)) with constants folded.
+ * This is a "light" version of the reassociation phase
+ */
+static ir_node *fold_constant_associativity(ir_node *node,
+ tv_fold_binop_func fold)
+{
+ ir_graph *irg;
+ ir_op *op;
+ ir_node *left;
+ ir_node *right = get_binop_right(node);
+ ir_node *left_right;
+ ir_node *left_left;
+ ir_tarval *c0;
+ ir_tarval *c1;
+ ir_tarval *new_c;
+ ir_node *new_const;
+ ir_node *new_node;
+ if (!is_Const(right))
+ return node;
+
+ op = get_irn_op(node);
+ left = get_binop_left(node);
+ if (get_irn_op(left) != op)
+ return node;
+
+ left_right = get_binop_right(left);
+ if (!is_Const(left_right))
+ return node;
+
+ left_left = get_binop_left(left);
+ c0 = get_Const_tarval(left_right);
+ c1 = get_Const_tarval(right);
+ irg = get_irn_irg(node);
+ if (get_tarval_mode(c0) != get_tarval_mode(c1))
+ return node;
+ new_c = fold(c0, c1);
+ if (new_c == tarval_bad)
+ return node;
+ new_const = new_r_Const(irg, new_c);
+ new_node = exact_copy(node);
+ set_binop_left(new_node, left_left);
+ set_binop_right(new_node, new_const);
+ return new_node;
+}
+
+/**
+ * Transform an Or.
+ */
+static ir_node *transform_node_Or_(ir_node *n)
+{
+ ir_node *oldn = n;
+ ir_node *a = get_binop_left(n);
+ ir_node *b = get_binop_right(n);
+ ir_node *c;
+ ir_mode *mode;
+
+ n = fold_constant_associativity(n, tarval_or);
+ if (n != oldn)
+ return n;
+
+ if (is_Not(a) && is_Not(b)) {
+ /* ~a | ~b = ~(a&b) */
+ ir_node *block = get_nodes_block(n);
+
+ mode = get_irn_mode(n);
+ a = get_Not_op(a);
+ b = get_Not_op(b);
+ n = new_rd_And(get_irn_dbg_info(n), block, a, b, mode);
+ n = new_rd_Not(get_irn_dbg_info(n), block, n, mode);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_DEMORGAN);
+ return n;
+ }
+
+ /* 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_right(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);
+ }
+ /* Cmp(a!=b) or Cmp(c!=d) => Cmp((a^b)|(c^d) != 0) */
+ if (is_cmp_unequal(a) && is_cmp_unequal(b)
+ && !mode_is_float(get_irn_mode(a_left))
+ && !mode_is_float(get_irn_mode(b_left))) {
+ if (values_in_mode(get_irn_mode(a_left), get_irn_mode(b_left))) {
+ ir_graph *irg = get_irn_irg(n);
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ ir_mode *a_mode = get_irn_mode(a_left);
+ ir_mode *b_mode = get_irn_mode(b_left);
+ ir_node *xora = new_rd_Eor(dbgi, block, a_left, a_right, a_mode);
+ ir_node *xorb = new_rd_Eor(dbgi, block, b_left, b_right, b_mode);
+ ir_node *conv = new_rd_Conv(dbgi, block, xora, b_mode);
+ ir_node *orn = new_rd_Or(dbgi, block, conv, xorb, b_mode);
+ ir_node *zero = create_zero_const(irg, b_mode);
+ return new_rd_Cmp(dbgi, block, orn, zero, ir_relation_less_greater);
+ }
+ if (values_in_mode(get_irn_mode(b_left), get_irn_mode(a_left))) {
+ ir_graph *irg = get_irn_irg(n);
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ ir_mode *a_mode = get_irn_mode(a_left);
+ ir_mode *b_mode = get_irn_mode(b_left);
+ ir_node *xora = new_rd_Eor(dbgi, block, a_left, a_right, a_mode);
+ ir_node *xorb = new_rd_Eor(dbgi, block, b_left, b_right, b_mode);
+ ir_node *conv = new_rd_Conv(dbgi, block, xorb, a_mode);
+ ir_node *orn = new_rd_Or(dbgi, block, xora, conv, a_mode);
+ ir_node *zero = create_zero_const(irg, a_mode);
+ return new_rd_Cmp(dbgi, block, orn, zero, ir_relation_less_greater);
+ }
+ }
+ }
+
+ mode = get_irn_mode(n);
+ HANDLE_BINOP_PHI((eval_func) tarval_or, a, b, c, mode);
+
+ n = transform_node_Or_bf_store(n);
+ if (n != oldn)
+ return n;
+ n = transform_node_Or_Rotl(n);
+ if (n != oldn)
+ return n;
+
+ n = transform_bitwise_distributive(n, transform_node_Or_);
+ if (n != oldn)
+ return n;
+ n = transform_node_bitop_shift(n);
+ if (n != oldn)
+ return n;
+
+ return n;
+}
+
+static ir_node *transform_node_Or(ir_node *n)
+{
+ if (is_Or_Eor_Add(n)) {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ ir_node *left = get_Or_left(n);
+ ir_node *right = get_Or_right(n);
+ ir_mode *mode = get_irn_mode(n);
+ return new_rd_Add(dbgi, block, left, right, mode);
+ }
+ return transform_node_Or_(n);
+}
+
+/**
+ * Transform an Eor.
+ */
+static ir_node *transform_node_Eor_(ir_node *n)
+{
+ ir_node *oldn = n;
+ ir_node *a = get_binop_left(n);
+ ir_node *b = get_binop_right(n);
+ ir_mode *mode = get_irn_mode(n);
+ ir_node *c;
+
+ n = fold_constant_associativity(n, tarval_eor);
+ if (n != oldn)
+ return n;
+
+ /* 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);
+ ir_node *block = get_nodes_block(n);
+ ir_node *new_not = new_rd_Not(dbg, block, b, mode);
+ ir_node *new_left = get_Not_op(a);
+ n = new_rd_Eor(dbg, block, new_left, new_not, mode);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_TO_NOT);
+ return n;
+ } else if (is_Not(b) && !operands_are_normalized(a, get_Not_op(b))) {
+ dbg_info *dbg = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ ir_node *new_not = new_rd_Not(dbg, block, a, mode);
+ ir_node *new_right = get_Not_op(b);
+ n = new_rd_Eor(dbg, block, new_not, new_right, mode);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_TO_NOT);
+ return n;
+ }
+
+ /* x ^ 1...1 -> ~1 */
+ if (is_Const(b) && is_Const_all_one(b)) {
+ n = new_r_Not(get_nodes_block(n), a, mode);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_TO_NOT);
+ return n;
+ }
+
+ n = transform_bitwise_distributive(n, transform_node_Eor_);
+ if (n != oldn)
+ return n;
+ n = transform_node_bitop_shift(n);
+ if (n != oldn)
+ return n;
+
+ return n;
+}
+
+static ir_node *transform_node_Eor(ir_node *n)
+{
+ if (is_Or_Eor_Add(n)) {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ ir_node *left = get_Eor_left(n);
+ ir_node *right = get_Eor_right(n);
+ ir_mode *mode = get_irn_mode(n);
+ return new_rd_Add(dbgi, block, left, right, mode);
+ }
+ return transform_node_Eor_(n);
+}
+
+/**
+ * Do the AddSub optimization, then Transform
+ * Constant folding on Phi
+ * Add(a,a) -> Mul(a, 2)
+ * Add(Mul(a, x), a) -> Mul(a, x+1)
+ * if the mode is integer or float.
+ * Transform Add(a,-b) into Sub(a,b).
+ * Reassociation might fold this further.
+ */
+static ir_node *transform_node_Add(ir_node *n)
+{
+ ir_mode *mode;
+ ir_node *a;
+ ir_node *b;
+ ir_node *c;
+ ir_node *oldn = n;
+
+ n = fold_constant_associativity(n, tarval_add);
+ if (n != oldn)
+ return n;
+
+ n = transform_node_AddSub(n);
+ if (n != oldn)
+ return n;
+
+ a = get_Add_left(n);
+ b = get_Add_right(n);
+ mode = get_irn_mode(n);
+
+ if (mode_is_reference(mode)) {
+ ir_mode *lmode = get_irn_mode(a);
- if (is_Const(b) && is_Const_null(b) && mode_is_int(lmode)) {
+ if (is_Const(b) && is_Const_null(b) && mode_is_int(lmode)) {
/* an Add(a, NULL) is a hidden Conv */
dbg_info *dbg = get_irn_dbg_info(n);
return new_rd_Conv(dbg, get_nodes_block(n), a, mode);
}
}
+ if (is_Const(b) && get_mode_arithmetic(mode) == irma_twos_complement) {
+ ir_tarval *tv = get_Const_tarval(b);
+ ir_tarval *min = get_mode_min(mode);
+ /* if all bits are set, then this has the same effect as a Not.
+ * Note that the following == gives false for different modes which
+ * is exactly what we want */
+ if (tv == min) {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_graph *irg = get_irn_irg(n);
+ ir_node *block = get_nodes_block(n);
+ ir_node *cnst = new_r_Const(irg, min);
+ return new_rd_Eor(dbgi, block, a, cnst, mode);
+ }
+ }
+
HANDLE_BINOP_PHI((eval_func) tarval_add, a, b, c, mode);
- /* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
- if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic))
- return n;
+ /* for FP the following optimizations are only allowed if
+ * fp_strict_algebraic is disabled */
+ if (mode_is_float(mode)) {
+ ir_graph *irg = get_irn_irg(n);
+ if (get_irg_fp_model(irg) & fp_strict_algebraic)
+ return n;
+ }
if (mode_is_num(mode)) {
- /* the following code leads to endless recursion when Mul are replaced by a simple instruction chain */
- if (!is_irg_state(current_ir_graph, IR_GRAPH_STATE_ARCH_DEP)
+ ir_graph *irg = get_irn_irg(n);
+ /* the following code leads to endless recursion when Mul are replaced
+ * by a simple instruction chain */
+ if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_ARCH_DEP)
&& a == b && mode_is_int(mode)) {
ir_node *block = get_nodes_block(n);
get_irn_dbg_info(n),
block,
a,
- new_Const_long(mode, 2),
+ new_r_Const_long(irg, mode, 2),
mode);
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_A_A);
return n;
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_NOT_PLUS_1);
return n;
}
- if (op == b) {
- /* ~x + x = -1 */
- n = new_Const(get_mode_minus_one(mode));
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_X_NOT_X);
- return n;
- }
- }
- if (is_Not(b)) {
- ir_node *op = get_Not_op(b);
-
- if (op == a) {
- /* x + ~x = -1 */
- n = new_Const(get_mode_minus_one(mode));
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_X_NOT_X);
- return n;
- }
}
}
}
+
+ if (is_Or_Eor_Add(n)) {
+ n = transform_node_Or_(n);
+ if (n != oldn)
+ return n;
+ n = transform_node_Eor_(n);
+ if (n != oldn)
+ return n;
+ }
+
return n;
-} /* transform_node_Add */
+}
/**
* returns -cnst or NULL if impossible
*/
-static ir_node *const_negate(ir_node *cnst) {
- tarval *tv = tarval_neg(get_Const_tarval(cnst));
- dbg_info *dbgi = get_irn_dbg_info(cnst);
- ir_graph *irg = get_irn_irg(cnst);
+static ir_node *const_negate(ir_node *cnst)
+{
+ ir_tarval *tv = tarval_neg(get_Const_tarval(cnst));
+ dbg_info *dbgi = get_irn_dbg_info(cnst);
+ ir_graph *irg = get_irn_irg(cnst);
if (tv == tarval_bad) return NULL;
return new_rd_Const(dbgi, irg, tv);
}
* Sub(x, Add(x, a)) -> -a
* Sub(x, Const) -> Add(x, -Const)
*/
-static ir_node *transform_node_Sub(ir_node *n) {
+static ir_node *transform_node_Sub(ir_node *n)
+{
ir_mode *mode;
ir_node *oldn = n;
ir_node *a, *b, *c;
HANDLE_BINOP_PHI((eval_func) tarval_sub, a, b, c, mode);
/* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
- if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic))
- return n;
+ if (mode_is_float(mode)) {
+ ir_graph *irg = get_irn_irg(n);
+ if (get_irg_fp_model(irg) & fp_strict_algebraic)
+ return n;
+ }
if (is_Const(b) && !mode_is_reference(get_irn_mode(b))) {
/* a - C -> a + (-C) */
/* 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);
}
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_SUB_TO_ADD);
return n;
+#if 0
} else if (is_Mul(b)) { /* a - (b * C) -> a + (b * -C) */
ir_node *m_right = get_Mul_right(b);
if (is_Const(m_right)) {
return n;
}
}
+#endif
}
/* Beware of Sub(P, P) which cannot be optimized into a simple Minus ... */
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_SUB_0_A);
return n;
}
- if (is_Add(a)) {
- if (mode_wrap_around(mode)) {
- ir_node *left = get_Add_left(a);
- ir_node *right = get_Add_right(a);
+ if ((is_Add(a) || is_Or_Eor_Add(a)) && mode_wrap_around(mode)) {
+ ir_node *left = get_binop_left(a);
+ ir_node *right = get_binop_right(a);
- /* FIXME: Does the Conv's work only for two complement or generally? */
- if (left == b) {
- if (mode != get_irn_mode(right)) {
- /* This Sub is an effective Cast */
- right = new_r_Conv(get_nodes_block(n), right, mode);
- }
- n = right;
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
- return n;
- } else if (right == b) {
- if (mode != get_irn_mode(left)) {
- /* This Sub is an effective Cast */
- left = new_r_Conv(get_nodes_block(n), left, mode);
- }
- n = left;
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
- return n;
+ /* FIXME: Does the Conv's work only for two complement or generally? */
+ if (left == b) {
+ if (mode != get_irn_mode(right)) {
+ /* This Sub is an effective Cast */
+ right = new_r_Conv(get_nodes_block(n), right, mode);
+ }
+ n = right;
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
+ return n;
+ } else if (right == b) {
+ if (mode != get_irn_mode(left)) {
+ /* This Sub is an effective Cast */
+ left = new_r_Conv(get_nodes_block(n), left, mode);
}
+ n = left;
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
+ return n;
}
}
- if (is_Add(b)) {
- if (mode_wrap_around(mode)) {
- ir_node *left = get_Add_left(b);
- ir_node *right = get_Add_right(b);
+ if ((is_Add(b) || is_Or_Eor_Add(b)) && mode_wrap_around(mode)) {
+ ir_node *left = get_binop_left(b);
+ ir_node *right = get_binop_right(b);
- /* FIXME: Does the Conv's work only for two complement or generally? */
- if (left == a) {
- ir_mode *r_mode = get_irn_mode(right);
+ /* FIXME: Does the Conv's work only for two complement or generally? */
+ if (left == a) {
+ ir_mode *r_mode = get_irn_mode(right);
- n = new_r_Minus(get_nodes_block(n), right, r_mode);
- if (mode != r_mode) {
- /* This Sub is an effective Cast */
- n = new_r_Conv(get_nodes_block(n), n, mode);
- }
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
- return n;
- } else if (right == a) {
- ir_mode *l_mode = get_irn_mode(left);
+ n = new_r_Minus(get_nodes_block(n), right, r_mode);
+ if (mode != r_mode) {
+ /* This Sub is an effective Cast */
+ n = new_r_Conv(get_nodes_block(n), n, mode);
+ }
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
+ return n;
+ } else if (right == a) {
+ ir_mode *l_mode = get_irn_mode(left);
- n = new_r_Minus(get_nodes_block(n), left, l_mode);
- if (mode != l_mode) {
- /* This Sub is an effective Cast */
- n = new_r_Conv(get_nodes_block(n), n, mode);
- }
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
- return n;
+ n = new_r_Minus(get_nodes_block(n), left, l_mode);
+ if (mode != l_mode) {
+ /* This Sub is an effective Cast */
+ n = new_r_Conv(get_nodes_block(n), n, mode);
}
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
+ return n;
}
}
if (mode_is_int(mode) && is_Conv(a) && is_Conv(b)) {
ir_node *mb = get_Mul_right(a);
if (ma == b) {
- ir_node *blk = get_nodes_block(n);
+ ir_node *blk = get_nodes_block(n);
+ ir_graph *irg = get_irn_irg(n);
n = new_rd_Mul(
get_irn_dbg_info(n),
blk,
get_irn_dbg_info(n),
blk,
mb,
- new_Const_long(mode, 1),
+ new_r_Const(irg, get_mode_one(mode)),
mode),
mode);
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_SUB_MUL_A_X_A);
return n;
} else if (mb == b) {
- ir_node *blk = get_nodes_block(n);
+ ir_node *blk = get_nodes_block(n);
+ ir_graph *irg = get_irn_irg(n);
n = new_rd_Mul(
get_irn_dbg_info(n),
blk,
get_irn_dbg_info(n),
blk,
ma,
- new_Const_long(mode, 1),
+ new_r_Const(irg, get_mode_one(mode)),
mode),
mode);
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_SUB_MUL_A_X_A);
}
if (get_mode_arithmetic(mode) == irma_twos_complement) {
+ /* c - ~X = X + (c+1) */
if (is_Const(a) && is_Not(b)) {
- /* c - ~X = X + (c+1) */
- tarval *tv = get_Const_tarval(a);
+ ir_tarval *tv = get_Const_tarval(a);
tv = tarval_add(tv, get_mode_one(mode));
if (tv != tarval_bad) {
- ir_node *blk = get_nodes_block(n);
- ir_node *c = new_Const(tv);
+ ir_node *blk = get_nodes_block(n);
+ ir_graph *irg = get_irn_irg(n);
+ ir_node *c = new_r_Const(irg, tv);
n = new_rd_Add(get_irn_dbg_info(n), blk, get_Not_op(b), c, mode);
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_SUB_C_NOT_X);
return n;
}
}
+ /* x-(x&y) = x & ~y */
+ if (is_And(b)) {
+ ir_node *and_left = get_And_left(b);
+ ir_node *and_right = get_And_right(b);
+ if (and_right == a) {
+ ir_node *tmp = and_left;
+ and_left = and_right;
+ and_right = tmp;
+ }
+ if (and_left == a) {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ ir_mode *mode = get_irn_mode(n);
+ ir_node *notn = new_rd_Not(dbgi, block, and_right, mode);
+ ir_node *andn = new_rd_And(dbgi, block, a, notn, mode);
+ return andn;
+ }
+ }
}
return n;
-} /* transform_node_Sub */
+}
/**
* Several transformation done on n*n=2n bits mul.
* These transformations must be done here because new nodes may be produced.
*/
-static ir_node *transform_node_Mul2n(ir_node *n, ir_mode *mode) {
- ir_node *oldn = n;
- ir_node *a = get_Mul_left(n);
- ir_node *b = get_Mul_right(n);
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
- ir_mode *smode = get_irn_mode(a);
+static ir_node *transform_node_Mul2n(ir_node *n, ir_mode *mode)
+{
+ ir_node *oldn = n;
+ ir_node *a = get_Mul_left(n);
+ ir_node *b = get_Mul_right(n);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
+ ir_mode *smode = get_irn_mode(a);
if (ta == get_mode_one(smode)) {
/* (L)1 * (L)b = (L)b */
}
if (tb == get_mode_one(smode)) {
/* (L)a * (L)1 = (L)a */
- ir_node *blk = get_irn_n(a, -1);
+ ir_node *blk = get_nodes_block(a);
n = new_rd_Conv(get_irn_dbg_info(n), blk, a, mode);
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_1);
return n;
* Do constant evaluation of Phi nodes.
* Do architecture dependent optimizations on Mul nodes
*/
-static ir_node *transform_node_Mul(ir_node *n) {
+static ir_node *transform_node_Mul(ir_node *n)
+{
ir_node *c, *oldn = n;
ir_mode *mode = get_irn_mode(n);
ir_node *a = get_Mul_left(n);
ir_node *b = get_Mul_right(n);
- if (is_Bad(a) || is_Bad(b))
+ n = fold_constant_associativity(n, tarval_mul);
+ if (n != oldn)
return n;
if (mode != get_irn_mode(a))
return n;
}
}
- if (get_mode_arithmetic(mode) == irma_ieee754) {
+ if (get_mode_arithmetic(mode) == irma_ieee754
+ || get_mode_arithmetic(mode) == irma_x86_extended_float) {
if (is_Const(a)) {
- tarval *tv = get_Const_tarval(a);
- if (tarval_ieee754_get_exponent(tv) == 1 && tarval_ieee754_zero_mantissa(tv)
+ ir_tarval *tv = get_Const_tarval(a);
+ if (tarval_get_exponent(tv) == 1 && tarval_zero_mantissa(tv)
&& !tarval_is_negative(tv)) {
/* 2.0 * b = b + b */
n = new_rd_Add(get_irn_dbg_info(n), get_nodes_block(n), b, b, mode);
}
}
else if (is_Const(b)) {
- tarval *tv = get_Const_tarval(b);
- if (tarval_ieee754_get_exponent(tv) == 1 && tarval_ieee754_zero_mantissa(tv)
+ ir_tarval *tv = get_Const_tarval(b);
+ if (tarval_get_exponent(tv) == 1 && tarval_zero_mantissa(tv)
&& !tarval_is_negative(tv)) {
/* a * 2.0 = a + a */
n = new_rd_Add(get_irn_dbg_info(n), get_nodes_block(n), a, a, mode);
}
}
return arch_dep_replace_mul_with_shifts(n);
-} /* transform_node_Mul */
+}
/**
* Transform a Div Node.
*/
-static ir_node *transform_node_Div(ir_node *n) {
+static ir_node *transform_node_Div(ir_node *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)) {
- /* BEWARE: we can optimize a/a to 1 only if this cannot cause a exception */
- value = new_Const(get_mode_one(mode));
- DBG_OPT_CSTEVAL(n, value);
- goto make_tuple;
- } else {
- if (mode_is_signed(mode) && is_Const(b)) {
- 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) {
ir_node *mem, *blk;
+ ir_graph *irg;
make_tuple:
/* Turn Div into a tuple (mem, jmp, bad, value) */
mem = get_Div_mem(n);
blk = get_nodes_block(n);
+ irg = get_irn_irg(blk);
/* skip a potential Pin */
mem = skip_Pin(mem);
- turn_into_tuple(n, pn_Div_max);
+ turn_into_tuple(n, pn_Div_max+1);
set_Tuple_pred(n, pn_Div_M, mem);
set_Tuple_pred(n, pn_Div_X_regular, new_r_Jmp(blk));
- set_Tuple_pred(n, pn_Div_X_except, new_Bad());
+ set_Tuple_pred(n, pn_Div_X_except, new_r_Bad(irg, mode_X));
set_Tuple_pred(n, pn_Div_res, value);
}
return n;
-} /* transform_node_Div */
+}
/**
* Transform a Mod node.
*/
-static ir_node *transform_node_Mod(ir_node *n) {
- ir_mode *mode = get_Mod_resmode(n);
- ir_node *a = get_Mod_left(n);
- ir_node *b = get_Mod_right(n);
- ir_node *value;
- tarval *tv;
+static ir_node *transform_node_Mod(ir_node *n)
+{
+ ir_mode *mode = get_Mod_resmode(n);
+ ir_node *a = get_Mod_left(n);
+ ir_node *b = get_Mod_right(n);
+ ir_graph *irg;
+ ir_node *value;
+ ir_tarval *tv;
if (is_Const(b) && is_const_Phi(a)) {
/* check for Div(Phi, Const) */
value = n;
tv = value_of(n);
+ irg = get_irn_irg(n);
if (tv != tarval_bad) {
- value = new_Const(tv);
+ value = new_r_Const(irg, tv);
DBG_OPT_CSTEVAL(n, value);
goto make_tuple;
if (a == b && value_not_zero(a, &dummy)) {
/* BEWARE: we can optimize a%a to 0 only if this cannot cause a exception */
- value = new_Const(get_mode_null(mode));
+ value = new_r_Const(irg, get_mode_null(mode));
DBG_OPT_CSTEVAL(n, value);
goto make_tuple;
} else {
if (mode_is_signed(mode) && is_Const(b)) {
- tarval *tv = get_Const_tarval(b);
+ ir_tarval *tv = get_Const_tarval(b);
if (tv == get_mode_minus_one(mode)) {
/* a % -1 = 0 */
- value = new_Const(get_mode_null(mode));
+ value = new_r_Const(irg, get_mode_null(mode));
DBG_OPT_CSTEVAL(n, value);
goto make_tuple;
}
if (value != n) {
ir_node *mem, *blk;
+ ir_graph *irg;
make_tuple:
/* Turn Mod into a tuple (mem, jmp, bad, value) */
mem = get_Mod_mem(n);
blk = get_nodes_block(n);
+ irg = get_irn_irg(blk);
/* skip a potential Pin */
mem = skip_Pin(mem);
- turn_into_tuple(n, pn_Mod_max);
+ turn_into_tuple(n, pn_Mod_max+1);
set_Tuple_pred(n, pn_Mod_M, mem);
set_Tuple_pred(n, pn_Mod_X_regular, new_r_Jmp(blk));
- set_Tuple_pred(n, pn_Mod_X_except, new_Bad());
+ set_Tuple_pred(n, pn_Mod_X_except, new_r_Bad(irg, mode_X));
set_Tuple_pred(n, pn_Mod_res, value);
}
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;
- 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_Const(get_mode_null(mode));
- DBG_OPT_CSTEVAL(n, vb);
- goto make_tuple;
- } 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
- Jmp for X result!? */
- resb = tarval_mod(ta, tb);
- if (resb == tarval_bad) return n; /* Causes exception! */
- va = new_Const(resa);
- vb = new_Const(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_Const(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_Const(get_mode_one(mode));
- vb = new_Const(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, new_Bad()); /* 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);
- 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(current_ir_graph) & fp_strict_algebraic) == 0)) {
- ir_node *blk = get_nodes_block(n);
- ir_node *c = new_Const(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, new_Bad());
- 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 Abs(x) into x if x is Confirmed >= 0
- * Optimize Abs(x) into -x if x is Confirmed <= 0
- * Optimize Abs(-x) int Abs(x)
- */
-static ir_node *transform_node_Abs(ir_node *n) {
- ir_node *c, *oldn = n;
- ir_node *a = get_Abs_op(n);
- ir_mode *mode;
-
- HANDLE_UNOP_PHI(tarval_abs, a, c);
-
- switch (classify_value_sign(a)) {
- case value_classified_negative:
- mode = get_irn_mode(n);
-
- /*
- * We can replace the Abs by -x here.
- * We even could add a new Confirm here
- * (if not twos complement)
- *
- * Note that -x would create a new node, so we could
- * not run it in the equivalent_node() context.
- */
- n = new_rd_Minus(get_irn_dbg_info(n), get_nodes_block(n), a, mode);
-
- DBG_OPT_CONFIRM(oldn, n);
- return n;
- case value_classified_positive:
- /* n is positive, Abs is not needed */
- n = a;
-
- DBG_OPT_CONFIRM(oldn, n);
- return n;
- default:
- break;
- }
- if (is_Minus(a)) {
- /* Abs(-x) = Abs(x) */
- mode = get_irn_mode(n);
- n = new_rd_Abs(get_irn_dbg_info(n), get_nodes_block(n), get_Minus_op(a), mode);
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ABS_MINUS_X);
- return n;
- }
- return n;
-} /* transform_node_Abs */
-
-/**
- * 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.
* Replace the Cond by a Jmp if it branches on a constant
* condition.
*/
-static ir_node *transform_node_Cond(ir_node *n) {
-
- ir_node *jmp;
- ir_node *a = get_Cond_selector(n);
- tarval *ta = value_of(a);
+static ir_node *transform_node_Cond(ir_node *n)
+{
+ ir_node *a = get_Cond_selector(n);
+ ir_graph *irg = get_irn_irg(n);
+ ir_tarval *ta;
+ ir_node *jmp;
/* we need block info which is not available in floating irgs */
- if (get_irg_pinned(current_ir_graph) == op_pin_state_floats)
+ if (get_irg_pinned(irg) == op_pin_state_floats)
return n;
- if ((ta != tarval_bad) &&
- (get_irn_mode(a) == mode_b) &&
- (get_opt_unreachable_code())) {
+ ta = value_of(a);
+ if (ta == tarval_bad && is_Cmp(a)) {
+ /* try again with a direct call to compute_cmp, as we don't care
+ * about the MODEB_LOWERED flag here */
+ ta = compute_cmp_ext(a);
+ }
+
+ if (ta != tarval_bad && get_irn_mode(a) == mode_b) {
/* It's a boolean Cond, branching on a boolean constant.
Replace it by a tuple (Bad, Jmp) or (Jmp, Bad) */
ir_node *blk = get_nodes_block(n);
jmp = new_r_Jmp(blk);
- turn_into_tuple(n, pn_Cond_max);
+ turn_into_tuple(n, pn_Cond_max+1);
if (ta == tarval_b_true) {
- set_Tuple_pred(n, pn_Cond_false, new_Bad());
+ set_Tuple_pred(n, pn_Cond_false, new_r_Bad(irg, mode_X));
set_Tuple_pred(n, pn_Cond_true, jmp);
} else {
set_Tuple_pred(n, pn_Cond_false, jmp);
- set_Tuple_pred(n, pn_Cond_true, new_Bad());
+ set_Tuple_pred(n, pn_Cond_true, new_r_Bad(irg, mode_X));
+ }
+ /* We might generate an endless loop, so keep it alive. */
+ add_End_keepalive(get_irg_end(irg), blk);
+ clear_irg_properties(irg, IR_GRAPH_PROPERTY_NO_UNREACHABLE_CODE);
+ }
+ return n;
+}
+
+static ir_node *transform_node_Switch(ir_node *n)
+{
+ ir_node *op = get_Switch_selector(n);
+ ir_tarval *val = value_of(op);
+ if (val != tarval_bad) {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_graph *irg = get_irn_irg(n);
+ unsigned n_outs = get_Switch_n_outs(n);
+ ir_node *block = get_nodes_block(n);
+ ir_node *bad = new_r_Bad(irg, mode_X);
+ ir_node **in = XMALLOCN(ir_node*, n_outs);
+ const ir_switch_table *table = get_Switch_table(n);
+ size_t n_entries = ir_switch_table_get_n_entries(table);
+ long jmp_pn = 0;
+ size_t i;
+ unsigned o;
+ for (i = 0; i < n_entries; ++i) {
+ const ir_switch_table_entry *entry
+ = ir_switch_table_get_entry_const(table, i);
+ ir_tarval *min = entry->min;
+ ir_tarval *max = entry->max;
+ if (entry->pn == 0)
+ continue;
+ if ((min == max && min == val)
+ || (tarval_cmp(val, min) != ir_relation_less
+ && tarval_cmp(val, max) != ir_relation_greater)) {
+ jmp_pn = entry->pn;
+ break;
+ }
+ }
+ for (o = 0; o < n_outs; ++o) {
+ if (o == (unsigned)jmp_pn) {
+ in[o] = new_rd_Jmp(dbgi, block);
+ } else {
+ in[o] = bad;
+ }
}
- /* We might generate an endless loop, so keep it alive. */
- add_End_keepalive(get_irg_end(current_ir_graph), blk);
+ return new_r_Tuple(block, (int)n_outs, in);
}
return n;
-} /* transform_node_Cond */
-
-/**
- * Prototype of a recursive transform function
- * for bitwise distributive transformations.
- */
-typedef ir_node* (*recursive_transform)(ir_node *n);
+}
/**
- * makes use of distributive laws for and, or, eor
- * and(a OP c, b OP c) -> and(a, b) OP c
- * note, might return a different op than n
+ * normalisation: (x & c1) >> c2 to (x >> c2) & (c1 >> c2)
+ * (we can use:
+ * - and, or, xor instead of &
+ * - Shl, Shr, Shrs, rotl instead of >>
+ * (with a special case for Or/Xor + Shrs)
+ *
+ * This normalisation is good for things like x-(x&y) esp. in 186.crafty.
*/
-static ir_node *transform_bitwise_distributive(ir_node *n,
- recursive_transform trans_func)
+static ir_node *transform_node_shift_bitop(ir_node *n)
{
- ir_node *oldn = n;
- ir_node *a = get_binop_left(n);
- ir_node *b = get_binop_right(n);
- ir_op *op = get_irn_op(a);
- ir_op *op_root = get_irn_op(n);
-
- if(op != get_irn_op(b))
+ ir_graph *irg = get_irn_irg(n);
+ ir_node *right = get_binop_right(n);
+ ir_mode *mode = get_irn_mode(n);
+ ir_node *left;
+ ir_node *bitop_left;
+ ir_node *bitop_right;
+ ir_op *op_left;
+ ir_node *block;
+ dbg_info *dbgi;
+ ir_node *new_shift;
+ ir_node *new_bitop;
+ ir_node *new_const;
+ ir_tarval *tv1;
+ ir_tarval *tv2;
+ ir_tarval *tv_shift;
+
+ if (irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_NORMALISATION2))
return n;
- /* and(conv(a), conv(b)) -> conv(and(a,b)) */
- if (op == op_Conv) {
- ir_node *a_op = get_Conv_op(a);
- ir_node *b_op = get_Conv_op(b);
- ir_mode *a_mode = get_irn_mode(a_op);
- ir_mode *b_mode = get_irn_mode(b_op);
- if(a_mode == b_mode && (mode_is_int(a_mode) || a_mode == mode_b)) {
- ir_node *blk = get_nodes_block(n);
+ assert(is_Shrs(n) || is_Shr(n) || is_Shl(n) || is_Rotl(n));
- n = exact_copy(n);
- set_binop_left(n, a_op);
- set_binop_right(n, b_op);
- set_irn_mode(n, a_mode);
- n = trans_func(n);
- n = new_r_Conv(blk, n, get_irn_mode(oldn));
+ if (!is_Const(right))
+ return n;
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV);
- return n;
- }
- }
+ left = get_binop_left(n);
+ op_left = get_irn_op(left);
+ if (op_left != op_And && op_left != op_Or && op_left != op_Eor)
+ return n;
- if (op == op_Eor) {
- /* nothing to gain here */
+ /* doing it with Shrs is not legal if the Or/Eor affects the topmost bit */
+ if (is_Shrs(n) && (op_left == op_Or || op_left == op_Eor)) {
+ /* TODO: test if sign bit is affectes */
return n;
}
- if (op == op_Shrs || op == op_Shr || op == op_Shl
- || op == op_And || op == op_Or || op == op_Eor) {
- ir_node *a_left = get_binop_left(a);
- ir_node *a_right = get_binop_right(a);
- ir_node *b_left = get_binop_left(b);
- ir_node *b_right = get_binop_right(b);
- ir_node *c = NULL;
- ir_node *op1 = NULL;
- ir_node *op2 = NULL;
+ bitop_right = get_binop_right(left);
+ if (!is_Const(bitop_right))
+ return n;
- if (is_op_commutative(op)) {
- if (a_left == b_left) {
- c = a_left;
- op1 = a_right;
- op2 = b_right;
- } else if(a_left == b_right) {
- c = a_left;
- op1 = a_right;
- op2 = b_left;
- } else if(a_right == b_left) {
- c = a_right;
- op1 = a_left;
- op2 = b_right;
- }
- }
- if(a_right == b_right) {
- c = a_right;
- op1 = a_left;
- op2 = b_left;
- }
+ bitop_left = get_binop_left(left);
- if (c != NULL) {
- /* (a sop c) & (b sop c) => (a & b) sop c */
- ir_node *blk = get_nodes_block(n);
+ block = get_nodes_block(n);
+ dbgi = get_irn_dbg_info(n);
+ tv1 = get_Const_tarval(bitop_right);
+ tv2 = get_Const_tarval(right);
- ir_node *new_n = exact_copy(n);
- set_binop_left(new_n, op1);
- set_binop_right(new_n, op2);
- new_n = trans_func(new_n);
+ assert(get_tarval_mode(tv1) == mode);
- if(op_root == op_Eor && op == op_Or) {
- dbg_info *dbgi = get_irn_dbg_info(n);
- ir_mode *mode = get_irn_mode(c);
+ if (is_Shl(n)) {
+ new_shift = new_rd_Shl(dbgi, block, bitop_left, right, mode);
+ tv_shift = tarval_shl(tv1, tv2);
+ } else if (is_Shr(n)) {
+ new_shift = new_rd_Shr(dbgi, block, bitop_left, right, mode);
+ tv_shift = tarval_shr(tv1, tv2);
+ } else if (is_Shrs(n)) {
+ new_shift = new_rd_Shrs(dbgi, block, bitop_left, right, mode);
+ tv_shift = tarval_shrs(tv1, tv2);
+ } else {
+ assert(is_Rotl(n));
+ new_shift = new_rd_Rotl(dbgi, block, bitop_left, right, mode);
+ tv_shift = tarval_rotl(tv1, tv2);
+ }
- c = new_rd_Not(dbgi, blk, c, mode);
- n = new_rd_And(dbgi, blk, new_n, c, mode);
- } else {
- n = exact_copy(a);
- set_nodes_block(n, blk);
- set_binop_left(n, new_n);
- set_binop_right(n, c);
- add_identities(current_ir_graph->value_table, n);
- }
+ assert(get_tarval_mode(tv_shift) == mode);
+ irg = get_irn_irg(n);
+ new_const = new_r_Const(irg, tv_shift);
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_SHIFT_AND);
- return n;
- }
+ if (op_left == op_And) {
+ new_bitop = new_rd_And(dbgi, block, new_shift, new_const, mode);
+ } else if (op_left == op_Or) {
+ new_bitop = new_rd_Or(dbgi, block, new_shift, new_const, mode);
+ } else {
+ assert(op_left == op_Eor);
+ new_bitop = new_rd_Eor(dbgi, block, new_shift, new_const, mode);
}
- return n;
+ return new_bitop;
}
/**
* Transform an And.
*/
-static ir_node *transform_node_And(ir_node *n) {
+static ir_node *transform_node_And(ir_node *n)
+{
ir_node *c, *oldn = n;
ir_node *a = get_And_left(n);
ir_node *b = get_And_right(n);
ir_mode *mode;
- 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);
- ir_node *block = get_nodes_block(pred_a);
- pn_Cmp pn_a = get_Proj_proj(a);
- pn_Cmp pn_b = get_Proj_proj(b);
- /* yes, we can simply calculate with pncs */
- pn_Cmp new_pnc = pn_a & pn_b;
+ n = fold_constant_associativity(n, tarval_and);
+ if (n != oldn)
+ return n;
- return new_rd_Proj(dbgi, block, pred_a, mode_b, new_pnc);
+ if (is_Cmp(a) && is_Cmp(b)) {
+ ir_node *a_left = get_Cmp_left(a);
+ ir_node *a_right = get_Cmp_right(a);
+ ir_node *b_left = get_Cmp_left(b);
+ ir_node *b_right = get_Cmp_right(b);
+ ir_relation a_relation = get_Cmp_relation(a);
+ ir_relation b_relation = get_Cmp_relation(b);
+ /* we can combine the relations of two compares with the same
+ * operands */
+ 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 new_relation = a_relation & b_relation;
+ return new_rd_Cmp(dbgi, block, a_left, a_right, new_relation);
+ }
+ /* Cmp(a==b) and Cmp(c==d) can be optimized to Cmp((a^b)|(c^d)==0) */
+ if (a_relation == b_relation && a_relation == ir_relation_equal
+ && !mode_is_float(get_irn_mode(a_left))
+ && !mode_is_float(get_irn_mode(b_left))) {
+ if (values_in_mode(get_irn_mode(a_left), get_irn_mode(b_left))) {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ ir_mode *a_mode = get_irn_mode(a_left);
+ ir_mode *b_mode = get_irn_mode(b_left);
+ ir_node *xora = new_rd_Eor(dbgi, block, a_left, a_right, a_mode);
+ ir_node *xorb = new_rd_Eor(dbgi, block, b_left, b_right, b_mode);
+ ir_node *conv = new_rd_Conv(dbgi, block, xora, b_mode);
+ ir_node *orn = new_rd_Or(dbgi, block, conv, xorb, b_mode);
+ ir_graph *irg = get_irn_irg(n);
+ ir_node *zero = create_zero_const(irg, b_mode);
+ return new_rd_Cmp(dbgi, block, orn, zero, ir_relation_equal);
+ }
+ if (values_in_mode(get_irn_mode(b_left), get_irn_mode(a_left))) {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ ir_mode *a_mode = get_irn_mode(a_left);
+ ir_mode *b_mode = get_irn_mode(b_left);
+ ir_node *xora = new_rd_Eor(dbgi, block, a_left, a_right, a_mode);
+ ir_node *xorb = new_rd_Eor(dbgi, block, b_left, b_right, b_mode);
+ ir_node *conv = new_rd_Conv(dbgi, block, xorb, a_mode);
+ ir_node *orn = new_rd_Or(dbgi, block, xora, conv, a_mode);
+ ir_graph *irg = get_irn_irg(n);
+ ir_node *zero = create_zero_const(irg, a_mode);
+ return new_rd_Cmp(dbgi, block, orn, zero, ir_relation_equal);
+ }
}
}
- if (is_Or(a)) {
- if (is_Not(b)) {
+
+ mode = get_irn_mode(n);
+ HANDLE_BINOP_PHI((eval_func) tarval_and, a, b, c, mode);
+
+ if (is_Or(a) || is_Or_Eor_Add(a)) {
+ ir_node *or_left = get_binop_left(a);
+ ir_node *or_right = get_binop_right(a);
+ if (complement_values(or_left, b)) {
+ /* (a|b) & ~a => b & ~a */
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ return new_rd_And(dbgi, block, or_right, b, mode);
+ } else if (complement_values(or_right, b)) {
+ /* (a|b) & ~b => a & ~b */
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ return new_rd_And(dbgi, block, or_left, b, mode);
+ } else if (is_Not(b)) {
ir_node *op = get_Not_op(b);
if (is_And(op)) {
ir_node *ba = get_And_left(op);
ir_node *bb = get_And_right(op);
/* it's enough to test the following cases due to normalization! */
- if (get_Or_left(a) == ba && get_Or_right(a) == bb) {
+ if (or_left == ba && or_right == bb) {
/* (a|b) & ~(a&b) = a^b */
ir_node *block = get_nodes_block(n);
}
}
}
- if (is_Or(b)) {
- if (is_Not(a)) {
+ if (is_Or(b) || is_Or_Eor_Add(b)) {
+ ir_node *or_left = get_binop_left(b);
+ ir_node *or_right = get_binop_right(b);
+ if (complement_values(or_left, a)) {
+ /* (a|b) & ~a => b & ~a */
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ return new_rd_And(dbgi, block, or_right, a, mode);
+ } else if (complement_values(or_right, a)) {
+ /* (a|b) & ~b => a & ~b */
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ return new_rd_And(dbgi, block, or_left, a, mode);
+ } else if (is_Not(a)) {
ir_node *op = get_Not_op(a);
if (is_And(op)) {
ir_node *aa = get_And_left(op);
ir_node *ab = get_And_right(op);
/* it's enough to test the following cases due to normalization! */
- if (get_Or_left(b) == aa && get_Or_right(b) == ab) {
+ if (or_left == aa && or_right == ab) {
/* (a|b) & ~(a&b) = a^b */
ir_node *block = get_nodes_block(n);
}
}
}
- if (is_Eor(a)) {
- ir_node *al = get_Eor_left(a);
- ir_node *ar = get_Eor_right(a);
+ if (is_Eor(a) || is_Or_Eor_Add(a)) {
+ ir_node *al = get_binop_left(a);
+ ir_node *ar = get_binop_right(a);
if (al == b) {
/* (b ^ a) & b -> ~a & b */
return n;
}
}
- if (is_Eor(b)) {
- ir_node *bl = get_Eor_left(b);
- ir_node *br = get_Eor_right(b);
+ if (is_Eor(b) || is_Or_Eor_Add(b)) {
+ ir_node *bl = get_binop_left(b);
+ ir_node *br = get_binop_right(b);
if (bl == a) {
/* a & (a ^ b) -> a & ~b */
return n;
}
- n = transform_bitwise_distributive(n, transform_node_And);
-
- return n;
-} /* transform_node_And */
-
-/**
- * Transform an Eor.
- */
-static ir_node *transform_node_Eor(ir_node *n) {
- ir_node *c, *oldn = n;
- ir_node *a = get_Eor_left(n);
- 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);
- ir_node *block = get_nodes_block(pred_a);
- pn_Cmp pn_a = get_Proj_proj(a);
- pn_Cmp pn_b = get_Proj_proj(b);
- /* yes, we can simply calculate with pncs */
- pn_Cmp new_pnc = pn_a ^ pn_b;
-
- return new_rd_Proj(dbgi, block, pred_a, mode_b, new_pnc);
+ if (is_Const(a)) {
+ vrp_attr *b_vrp = vrp_get_info(b);
+ ir_tarval *a_val = get_Const_tarval(a);
+ if (b_vrp != NULL && tarval_or(a_val, b_vrp->bits_not_set) == a_val) {
+ return b;
}
}
- if (a == b) {
- /* a ^ a = 0 */
- n = new_rd_Const(get_irn_dbg_info(n), current_ir_graph,
- get_mode_null(mode));
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_A_A);
- } else if (mode == mode_b &&
- is_Proj(a) &&
- is_Const(b) && is_Const_one(b) &&
- is_Cmp(get_Proj_pred(a))) {
- /* The Eor negates a Cmp. The Cmp has the negated result anyways! */
- n = new_r_Proj(get_nodes_block(n), 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 (is_Const(b)) {
- if (is_Not(a)) { /* ~x ^ const -> x ^ ~const */
- ir_node *cnst = new_Const(tarval_not(get_Const_tarval(b)));
- ir_node *not_op = get_Not_op(a);
- dbg_info *dbg = get_irn_dbg_info(n);
- ir_node *block = get_nodes_block(n);
- ir_mode *mode = get_irn_mode(n);
- n = new_rd_Eor(dbg, block, not_op, cnst, mode);
- return n;
- } else if (is_Const_all_one(b)) { /* x ^ 1...1 -> ~1 */
- n = new_r_Not(get_nodes_block(n), a, mode);
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_TO_NOT);
+ if (is_Const(b)) {
+ vrp_attr *a_vrp = vrp_get_info(a);
+ ir_tarval *b_val = get_Const_tarval(b);
+ if (a_vrp != NULL && tarval_or(b_val, a_vrp->bits_not_set) == b_val) {
+ return a;
}
- } else {
- n = transform_bitwise_distributive(n, transform_node_Eor);
}
+ n = transform_bitwise_distributive(n, transform_node_And);
+ if (is_And(n))
+ n = transform_node_bitop_shift(n);
+
return n;
-} /* transform_node_Eor */
+}
/**
* Transform a Not.
*/
-static ir_node *transform_node_Not(ir_node *n) {
+static ir_node *transform_node_Not(ir_node *n)
+{
ir_node *c, *oldn = n;
ir_node *a = get_Not_op(n);
ir_mode *mode = get_irn_mode(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)) {
- ir_node *cmp_block = get_nodes_block(a_pred);
- /* We negate a Cmp. The Cmp has the negated result anyways! */
- n = new_r_Proj(cmp_block, 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;
}
- if (is_Eor(a)) {
- ir_node *eor_b = get_Eor_right(a);
- if (is_Const(eor_b)) { /* ~(x ^ const) -> x ^ ~const */
- ir_node *cnst = new_Const(tarval_not(get_Const_tarval(eor_b)));
- ir_node *eor_a = get_Eor_left(a);
- dbg_info *dbg = get_irn_dbg_info(n);
- ir_node *block = get_nodes_block(n);
- ir_mode *mode = get_irn_mode(n);
- n = new_rd_Eor(dbg, block, eor_a, cnst, mode);
- return n;
- }
+
+ /* normalize ~(a ^ b) => a ^ ~b */
+ if (is_Eor(a) || is_Or_Eor_Add(a)) {
+ dbg_info *dbg = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ ir_node *eor_right = get_binop_right(a);
+ ir_node *eor_left = get_binop_left(a);
+ eor_right = new_rd_Not(dbg, block, eor_right, mode);
+ n = new_rd_Eor(dbg, block, eor_left, eor_right, mode);
+ return n;
}
+
if (get_mode_arithmetic(mode) == irma_twos_complement) {
if (is_Minus(a)) { /* ~-x -> x + -1 */
dbg_info *dbg = get_irn_dbg_info(n);
- ir_graph *irg = current_ir_graph;
+ ir_graph *irg = get_irn_irg(n);
ir_node *block = get_nodes_block(n);
ir_node *add_l = get_Minus_op(a);
ir_node *add_r = new_rd_Const(dbg, irg, get_mode_minus_one(mode));
n = new_rd_Add(dbg, block, add_l, add_r, mode);
- } else if (is_Add(a)) {
- ir_node *add_r = get_Add_right(a);
+ } else if (is_Add(a) || is_Or_Eor_Add(a)) {
+ ir_node *add_r = get_binop_right(a);
if (is_Const(add_r) && is_Const_all_one(add_r)) {
/* ~(x + -1) = -x */
- ir_node *op = get_Add_left(a);
+ ir_node *op = get_binop_left(a);
ir_node *blk = get_nodes_block(n);
n = new_rd_Minus(get_irn_dbg_info(n), blk, op, get_irn_mode(n));
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_NOT_MINUS_1);
}
}
return n;
-} /* transform_node_Not */
+}
/**
* Transform a Minus.
* -(a >>s (size-1)) = a >>u (size-1)
* -(a * const) -> a * -const
*/
-static ir_node *transform_node_Minus(ir_node *n) {
+static ir_node *transform_node_Minus(ir_node *n)
+{
ir_node *c, *oldn = n;
ir_node *a = get_Minus_op(n);
ir_mode *mode;
/* the following rules are only to twos-complement */
if (is_Not(a)) {
/* -(~x) = x + 1 */
- ir_node *op = get_Not_op(a);
- tarval *tv = get_mode_one(mode);
- ir_node *blk = get_nodes_block(n);
- ir_node *c = new_Const(tv);
+ ir_node *op = get_Not_op(a);
+ ir_tarval *tv = get_mode_one(mode);
+ ir_node *blk = get_nodes_block(n);
+ ir_graph *irg = get_irn_irg(blk);
+ ir_node *c = new_r_Const(irg, tv);
n = new_rd_Add(get_irn_dbg_info(n), blk, op, c, mode);
DBG_OPT_ALGSIM2(oldn, a, n, FS_OPT_MINUS_NOT);
return n;
ir_node *c = get_Shr_right(a);
if (is_Const(c)) {
- tarval *tv = get_Const_tarval(c);
+ ir_tarval *tv = get_Const_tarval(c);
if (tarval_is_long(tv) && get_tarval_long(tv) == (int) get_mode_size_bits(mode) - 1) {
/* -(a >>u (size-1)) = a >>s (size-1) */
ir_node *c = get_Shrs_right(a);
if (is_Const(c)) {
- tarval *tv = get_Const_tarval(c);
+ ir_tarval *tv = get_Const_tarval(c);
if (tarval_is_long(tv) && get_tarval_long(tv) == (int) get_mode_size_bits(mode) - 1) {
/* -(a >>s (size-1)) = a >>u (size-1) */
}
if (is_Mul(a)) { /* -(a * const) -> a * -const */
- ir_node *mul_l = get_Mul_left(a);
- ir_node *mul_r = get_Mul_right(a);
- tarval *tv = value_of(mul_r);
+ ir_node *mul_l = get_Mul_left(a);
+ ir_node *mul_r = get_Mul_right(a);
+ ir_tarval *tv = value_of(mul_r);
if (tv != tarval_bad) {
tv = tarval_neg(tv);
if (tv != tarval_bad) {
- ir_node *cnst = new_Const(tv);
+ ir_graph *irg = get_irn_irg(n);
+ ir_node *cnst = new_r_Const(irg, tv);
dbg_info *dbg = get_irn_dbg_info(a);
ir_node *block = get_nodes_block(a);
n = new_rd_Mul(dbg, block, mul_l, cnst, mode);
}
return n;
-} /* transform_node_Minus */
+}
/**
- * Transform a Cast_type(Const) into a new Const_type
+ * Transform a Proj(Load) with a non-null address.
*/
-static ir_node *transform_node_Cast(ir_node *n) {
- ir_node *oldn = n;
- ir_node *pred = get_Cast_op(n);
- ir_type *tp = get_irn_type(n);
-
- if (is_Const(pred) && get_Const_type(pred) != tp) {
- n = new_rd_Const_type(NULL, current_ir_graph, get_Const_tarval(pred), tp);
- DBG_OPT_CSTEVAL(oldn, n);
- } else if (is_SymConst(pred) && get_SymConst_value_type(pred) != tp) {
- n = new_rd_SymConst_type(NULL, current_ir_graph, get_irn_mode(pred),
- get_SymConst_symbol(pred), get_SymConst_kind(pred), tp);
- DBG_OPT_CSTEVAL(oldn, n);
- }
+static ir_node *transform_node_Proj_Load(ir_node *proj)
+{
+ if (get_irn_mode(proj) == mode_X) {
+ ir_node *load = get_Proj_pred(proj);
- return n;
-} /* transform_node_Cast */
+ /* get the Load address */
+ const ir_node *addr = get_Load_ptr(load);
+ const ir_node *confirm;
-/**
- * Transform a Proj(Load) with a non-null address.
- */
-static ir_node *transform_node_Proj_Load(ir_node *proj) {
- if (get_opt_ldst_only_null_ptr_exceptions()) {
- if (get_irn_mode(proj) == mode_X) {
- ir_node *load = get_Proj_pred(proj);
-
- /* get the Load address */
- const ir_node *addr = get_Load_ptr(load);
- const ir_node *confirm;
-
- if (value_not_null(addr, &confirm)) {
- if (confirm == NULL) {
- /* this node may float if it did not depend on a Confirm */
- set_irn_pinned(load, op_pin_state_floats);
- }
- if (get_Proj_proj(proj) == pn_Load_X_except) {
- DBG_OPT_EXC_REM(proj);
- return get_irg_bad(current_ir_graph);
- } else {
- ir_node *blk = get_nodes_block(load);
- return new_r_Jmp(blk);
- }
+ if (value_not_null(addr, &confirm)) {
+ if (confirm == NULL) {
+ /* this node may float if it did not depend on a Confirm */
+ set_irn_pinned(load, op_pin_state_floats);
+ }
+ if (get_Proj_proj(proj) == pn_Load_X_except) {
+ ir_graph *irg = get_irn_irg(proj);
+ DBG_OPT_EXC_REM(proj);
+ return new_r_Bad(irg, mode_X);
+ } else {
+ ir_node *blk = get_nodes_block(load);
+ return new_r_Jmp(blk);
}
}
}
return proj;
-} /* transform_node_Proj_Load */
+}
/**
* Transform a Proj(Store) with a non-null address.
*/
-static ir_node *transform_node_Proj_Store(ir_node *proj) {
- if (get_opt_ldst_only_null_ptr_exceptions()) {
- if (get_irn_mode(proj) == mode_X) {
- ir_node *store = get_Proj_pred(proj);
-
- /* get the load/store address */
- const ir_node *addr = get_Store_ptr(store);
- const ir_node *confirm;
-
- if (value_not_null(addr, &confirm)) {
- if (confirm == NULL) {
- /* this node may float if it did not depend on a Confirm */
- set_irn_pinned(store, op_pin_state_floats);
- }
- if (get_Proj_proj(proj) == pn_Store_X_except) {
- DBG_OPT_EXC_REM(proj);
- return get_irg_bad(current_ir_graph);
- } else {
- ir_node *blk = get_nodes_block(store);
- return new_r_Jmp(blk);
- }
+static ir_node *transform_node_Proj_Store(ir_node *proj)
+{
+ if (get_irn_mode(proj) == mode_X) {
+ ir_node *store = get_Proj_pred(proj);
+
+ /* get the load/store address */
+ const ir_node *addr = get_Store_ptr(store);
+ const ir_node *confirm;
+
+ if (value_not_null(addr, &confirm)) {
+ if (confirm == NULL) {
+ /* this node may float if it did not depend on a Confirm */
+ set_irn_pinned(store, op_pin_state_floats);
+ }
+ if (get_Proj_proj(proj) == pn_Store_X_except) {
+ ir_graph *irg = get_irn_irg(proj);
+ DBG_OPT_EXC_REM(proj);
+ return new_r_Bad(irg, mode_X);
+ } else {
+ ir_node *blk = get_nodes_block(store);
+ return new_r_Jmp(blk);
}
}
}
return proj;
-} /* transform_node_Proj_Store */
+}
/**
* Transform a Proj(Div) with a non-zero value.
* Removes the exceptions and routes the memory to the NoMem node.
*/
-static ir_node *transform_node_Proj_Div(ir_node *proj) {
+static ir_node *transform_node_Proj_Div(ir_node *proj)
+{
ir_node *div = get_Proj_pred(proj);
ir_node *b = get_Div_right(div);
ir_node *res, *new_mem;
case pn_Div_X_regular:
return new_r_Jmp(get_nodes_block(div));
- case pn_Div_X_except:
+ case pn_Div_X_except: {
+ ir_graph *irg = get_irn_irg(proj);
/* we found an exception handler, remove it */
DBG_OPT_EXC_REM(proj);
- return new_Bad();
+ return new_r_Bad(irg, mode_X);
+ }
- case pn_Div_M:
+ case pn_Div_M: {
+ ir_graph *irg = get_irn_irg(proj);
res = get_Div_mem(div);
- new_mem = get_irg_no_mem(current_ir_graph);
+ new_mem = get_irg_no_mem(irg);
if (confirm) {
/* This node can only float up to the Confirm block */
set_Div_mem(div, new_mem);
return res;
}
+ }
}
return proj;
-} /* transform_node_Proj_Div */
+}
/**
* Transform a Proj(Mod) with a non-zero value.
* Removes the exceptions and routes the memory to the NoMem node.
*/
-static ir_node *transform_node_Proj_Mod(ir_node *proj) {
+static ir_node *transform_node_Proj_Mod(ir_node *proj)
+{
ir_node *mod = get_Proj_pred(proj);
ir_node *b = get_Mod_right(mod);
ir_node *res, *new_mem;
switch (proj_nr) {
case pn_Mod_X_regular:
- return new_r_Jmp(get_irn_n(mod, -1));
+ return new_r_Jmp(get_nodes_block(mod));
- case pn_Mod_X_except:
+ case pn_Mod_X_except: {
+ ir_graph *irg = get_irn_irg(proj);
/* we found an exception handler, remove it */
DBG_OPT_EXC_REM(proj);
- return new_Bad();
-
- case pn_Mod_M:
- res = get_Mod_mem(mod);
- new_mem = get_irg_no_mem(current_ir_graph);
-
- 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 Mod without exception, we can remove the memory edge */
- set_Mod_mem(mod, new_mem);
- return res;
- case pn_Mod_res:
- if (get_Mod_left(mod) == b) {
- /* a % a = 0 if a != 0 */
- ir_mode *mode = get_irn_mode(proj);
- ir_node *res = new_Const(get_mode_null(mode));
-
- DBG_OPT_CSTEVAL(mod, res);
- return res;
- }
- }
- }
- 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);
+ return new_r_Bad(irg, mode_X);
}
- 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 */
- DBG_OPT_EXC_REM(proj);
- return new_Bad();
-
- case pn_DivMod_M:
- res = get_DivMod_mem(divmod);
- new_mem = get_irg_no_mem(current_ir_graph);
+ case pn_Mod_M: {
+ ir_graph *irg = get_irn_irg(proj);
+ res = get_Mod_mem(mod);
+ 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);
+ /* this is a Mod without exception, we can remove the memory edge */
+ set_Mod_mem(mod, new_mem);
return res;
-
- case pn_DivMod_res_mod:
- if (get_DivMod_left(divmod) == b) {
+ }
+ case pn_Mod_res:
+ if (get_Mod_left(mod) == b) {
/* a % a = 0 if a != 0 */
- ir_mode *mode = get_irn_mode(proj);
- ir_node *res = new_Const(get_mode_null(mode));
+ 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);
+ DBG_OPT_CSTEVAL(mod, 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);
-
- if (mode_is_int(get_irn_mode(b))) {
- tarval *tb = value_of(b);
-
- if (tb != tarval_bad) {
- /* we have a constant switch */
- long num = get_Proj_proj(proj);
-
- 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 {
- /* this case will NEVER be taken, kill it */
- return get_irg_bad(current_ir_graph);
- }
- }
- }
- }
- }
- return proj;
-} /* transform_node_Proj_Cond */
+}
/**
- * Create a 0 constant of given mode.
+ * return true if the operation returns a value with exactly 1 bit set
*/
-static ir_node *create_zero_const(ir_mode *mode) {
- tarval *tv = get_mode_null(mode);
- ir_node *cnst = new_Const(tv);
-
- return cnst;
-}
-
-/* the order of the values is important! */
-typedef enum const_class {
- const_const = 0,
- const_like = 1,
- const_other = 2
-} const_class;
-
-static const_class classify_const(const ir_node* n)
+static bool is_single_bit(const ir_node *node)
{
- if (is_Const(n)) return const_const;
- if (is_irn_constlike(n)) return const_like;
- return const_other;
+ /* 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;
}
/**
- * Determines whether r is more constlike or has a larger index (in that order)
- * than l.
+ * checks if node just flips a bit in another node and returns that other node
+ * if so. @p tv should be a value having just 1 bit set
*/
-static int operands_are_normalized(const ir_node *l, const ir_node *r)
+static ir_node *flips_bit(const ir_node *node, ir_tarval *tv)
{
- const const_class l_order = classify_const(l);
- const const_class r_order = classify_const(r);
- return
- l_order > r_order ||
- (l_order == r_order && get_irn_idx(l) <= get_irn_idx(r));
+ if (is_Not(node))
+ return get_Not_op(node);
+ if (is_Eor(node)) {
+ ir_node *right = get_Eor_right(node);
+ if (is_Const(right)) {
+ ir_tarval *right_tv = get_Const_tarval(right);
+ ir_mode *mode = get_irn_mode(node);
+ if (tarval_and(right_tv, tv) != get_mode_null(mode))
+ return get_Eor_left(node);
+ }
+ }
+ return NULL;
}
/**
* 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);
- 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:
- return new_Const(get_tarval_b_false());
- case pn_Cmp_True:
- return new_Const(get_tarval_b_true());
- case pn_Cmp_Leg:
- if (!mode_is_float(get_irn_mode(left)))
- return new_Const(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);
+
+ /* mask out impossible relations */
+ ir_relation new_relation = relation & possible;
+ if (new_relation != relation) {
+ relation = new_relation;
+ changed = true;
}
- /* remove Casts of both sides */
- left = skip_Cast(left);
- right = skip_Cast(right);
-
/* Remove unnecessary conversions */
- /* TODO handle constants */
- 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);
- ir_mode *mode_right = get_irn_mode(op_right);
-
- if (smaller_mode(mode_left, mode) && smaller_mode(mode_right, mode)
- && mode_left != mode_b && mode_right != mode_b) {
- ir_node *block = get_nodes_block(n);
+ if (!mode_is_float(mode)
+ || be_get_backend_param()->mode_float_arithmetic == NULL) {
+ if (is_Conv(left) && is_Conv(right)) {
+ 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);
+ ir_mode *mode_right = get_irn_mode(op_right);
+
+ if (smaller_mode(mode_left, mode) && smaller_mode(mode_right, mode)
+ && mode_left != mode_b && mode_right != mode_b) {
+ ir_node *block = get_nodes_block(n);
- if (mode_left == mode_right) {
- left = op_left;
- right = op_right;
- changed |= 1;
- 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;
- 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;
- DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV);
+ if (mode_left == mode_right) {
+ left = op_left;
+ right = op_right;
+ 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 = 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 = true;
+ DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_CONV);
+ }
+ mode = get_irn_mode(left);
+ }
+ }
+ if (is_Conv(left) && is_Const(right)) {
+ ir_node *op_left = get_Conv_op(left);
+ ir_mode *mode_left = get_irn_mode(op_left);
+ if (smaller_mode(mode_left, mode) && mode_left != mode_b) {
+ ir_tarval *tv = get_Const_tarval(right);
+ tarval_int_overflow_mode_t last_mode
+ = tarval_get_integer_overflow_mode();
+ ir_tarval *new_tv;
+ tarval_set_integer_overflow_mode(TV_OVERFLOW_BAD);
+ new_tv = tarval_convert_to(tv, mode_left);
+ tarval_set_integer_overflow_mode(last_mode);
+ if (new_tv != tarval_bad) {
+ ir_graph *irg = get_irn_irg(n);
+ left = op_left;
+ right = new_r_Const(irg, new_tv);
+ mode = get_irn_mode(left);
+ 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;
}
/* X+A == A, A+X == A, A-X == A -> X == 0 */
- if (is_Add(left) || is_Sub(left)) {
+ if (is_Add(left) || is_Sub(left) || is_Or_Eor_Add(left)) {
ir_node *ll = get_binop_left(left);
ir_node *lr = get_binop_right(left);
- if (lr == right && is_Add(left)) {
+ if (lr == right && (is_Add(left) || is_Or_Eor_Add(left))) {
ir_node *tmp = ll;
ll = lr;
lr = tmp;
}
if (ll == right) {
+ ir_graph *irg = get_irn_irg(n);
left = lr;
- right = create_zero_const(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_Add(right) || is_Sub(right)) {
+ if (is_Add(right) || is_Sub(right) || is_Or_Eor_Add(right)) {
ir_node *rl = get_binop_left(right);
ir_node *rr = get_binop_right(right);
- if (rr == left && is_Add(right)) {
+ if (rr == left && (is_Add(right) || is_Or_Eor_Add(right))) {
ir_node *tmp = rl;
rl = rr;
rr = tmp;
}
if (rl == left) {
+ ir_graph *irg = get_irn_irg(n);
left = rr;
- right = create_zero_const(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);
ir_node *llr = get_Shr_right(ll);
if (is_Const(llr)) {
dbg_info *dbg = get_irn_dbg_info(left);
+ ir_graph *irg = get_irn_irg(left);
+
+ ir_tarval *c1 = get_Const_tarval(llr);
+ ir_tarval *c2 = get_Const_tarval(lr);
+ ir_tarval *c3 = get_Const_tarval(right);
+ ir_tarval *mask = tarval_shl(c2, c1);
+ ir_tarval *value = tarval_shl(c3, c1);
+
+ left = new_rd_And(dbg, block, get_Shr_left(ll), new_r_Const(irg, mask), mode);
+ right = new_r_Const(irg, value);
+ changed = true;
+ }
+ }
+ }
+ /* Cmp(Eor(x, y), 0) <=> Cmp(x, y) at least for the ==0,!=0
+ * cases */
+ if (is_Const(right) && is_Const_null(right) &&
+ (is_Eor(left) || is_Or_Eor_Add(left))) {
+ right = get_Eor_right(left);
+ left = get_Eor_left(left);
+ changed = true;
+ }
+ }
+ }
- tarval *c1 = get_Const_tarval(llr);
- tarval *c2 = get_Const_tarval(lr);
- tarval *c3 = get_Const_tarval(right);
- tarval *mask = tarval_shl(c2, c1);
- tarval *value = tarval_shl(c3, c1);
+ if (mode_is_int(mode) && is_And(left)) {
+ /* a complicated Cmp(And(1bit, val), 1bit) "bit-testing" can be replaced
+ * by the simpler Cmp(And(1bit, val), 0) negated pnc */
+ if (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;
+ goto is_bittest;
+ }
+ }
- left = new_rd_And(dbg, block, get_Shr_left(ll), new_Const(mask), mode);
- right = new_Const(value);
+ if (is_Const(right) && is_Const_null(right) &&
+ (relation == ir_relation_equal
+ || (relation == ir_relation_less_greater)
+ || (!mode_is_signed(mode) && relation == ir_relation_greater))) {
+is_bittest: {
+ /* instead of flipping the bit before the bit-test operation negate
+ * pnc */
+ ir_node *and0 = get_And_left(left);
+ ir_node *and1 = get_And_right(left);
+ if (is_Const(and1)) {
+ ir_tarval *tv = get_Const_tarval(and1);
+ if (tarval_is_single_bit(tv)) {
+ ir_node *flipped = flips_bit(and0, tv);
+ if (flipped != NULL) {
+ dbg_info *dbgi = get_irn_dbg_info(left);
+ ir_node *block = get_nodes_block(left);
+ relation = get_negated_relation(relation);
+ left = new_rd_And(dbgi, block, flipped, and1, mode);
changed |= 1;
}
}
}
- } /* mode_is_int(...) */
- } /* proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg */
+ }
+ }
+ }
/* 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);
+
+ /* cmp(mux(x, cf, ct), c2) can be eliminated:
+ * cmp(ct,c2) | cmp(cf,c2) | result
+ * -----------|------------|--------
+ * true | true | True
+ * false | false | False
+ * true | false | x
+ * false | true | not(x)
+ */
+ if (is_Mux(left)) {
+ ir_node *mux_true = get_Mux_true(left);
+ ir_node *mux_false = get_Mux_false(left);
+ if (is_Const(mux_true) && is_Const(mux_false)) {
+ /* we can fold true/false constant separately */
+ ir_tarval *tv_true = get_Const_tarval(mux_true);
+ ir_tarval *tv_false = get_Const_tarval(mux_false);
+ ir_relation r_true = tarval_cmp(tv_true, tv);
+ ir_relation r_false = tarval_cmp(tv_false, tv);
+ if (r_true != ir_relation_false
+ || r_false != ir_relation_false) {
+ bool rel_true = (r_true & relation) != 0;
+ bool rel_false = (r_false & relation) != 0;
+ ir_node *cond = get_Mux_sel(left);
+ if (rel_true == rel_false) {
+ relation = rel_true ? ir_relation_true
+ : ir_relation_false;
+ } else if (rel_true) {
+ return cond;
+ } else {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ ir_node *notn = new_rd_Not(dbgi, block, cond, mode_b);
+ return notn;
+ }
+ }
+ }
+ }
/* TODO extend to arbitrary constants */
if (is_Conv(left) && tarval_is_null(tv)) {
/*
* UpConv(x) REL 0 ==> x REL 0
+ * Don't do this for float values as it's unclear whether it is a
+ * 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) ||
- mode_is_signed(mode) || !mode_is_signed(op_mode))) {
+ ((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);
- }
-
+ if (mode_is_int(mode) && !is_Const(left)) {
/* 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 0 /* Might be not that good in general */
- /* a-b == 0 ==> a == b, a-b != 0 ==> a != b */
- if (tarval_is_null(tv) && is_Sub(left)) {
- right = get_Sub_right(left);
- left = get_Sub_left(left);
-
- tv = value_of(right);
- changed = 1;
- DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_C);
- }
-#endif
-
+ if (relation == ir_relation_equal || relation == ir_relation_less_greater) {
if (tv != tarval_bad) {
/* a-c1 == c2 ==> a == c2+c1, a-c1 != c2 ==> a != c2+c1 */
if (is_Sub(left)) {
ir_node *c1 = get_Sub_right(left);
- tarval *tv2 = value_of(c1);
+ ir_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;
+ changedc = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_C);
}
}
}
/* a+c1 == c2 ==> a == c2-c1, a+c1 != c2 ==> a != c2-c1 */
- else if (is_Add(left)) {
- ir_node *a_l = get_Add_left(left);
- ir_node *a_r = get_Add_right(left);
+ else if (is_Add(left) || is_Or_Eor_Add(left)) {
+ ir_node *a_l = get_binop_left(left);
+ ir_node *a_r = get_binop_right(left);
ir_node *a;
- tarval *tv2;
+ ir_tarval *tv2;
if (is_Const(a_l)) {
a = a_r;
if (tv2 != tarval_bad) {
left = a;
tv = tv2;
- changed |= 2;
+ changedc = true;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_C);
}
}
}
/* -a == c ==> a == -c, -a != c ==> a != -c */
else if (is_Minus(left)) {
- tarval *tv2 = tarval_sub(get_mode_null(mode), tv, NULL);
+ ir_tarval *tv2 = tarval_sub(get_mode_null(mode), tv, NULL);
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 != */
- /* the following reassociations work only for <= */
- else if (proj_nr == pn_Cmp_Le || proj_nr == pn_Cmp_Lt) {
- if (tv != tarval_bad) {
- /* c >= 0 : Abs(a) <= c ==> (unsigned)(a + c) <= 2*c */
- if (is_Abs(left)) { // TODO something is missing here
- }
- }
}
- } /* 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;
* And(x, C1) == C2 ==> FALSE if C2 & C1 != C2
* And(x, C1) != C2 ==> TRUE if C2 & C1 != C2
*/
- tarval *mask = tarval_and(get_Const_tarval(c1), tv);
+ ir_tarval *mask = tarval_and(get_Const_tarval(c1), tv);
if (mask != tv) {
/* TODO: move to constant evaluation */
- tv = proj_nr == pn_Cmp_Eq ? get_tarval_b_false() : get_tarval_b_true();
- c1 = new_Const(tv);
- DBG_OPT_CSTEVAL(proj, c1);
+ ir_graph *irg = get_irn_irg(n);
+ tv = relation == ir_relation_equal ? get_tarval_b_false() : get_tarval_b_true();
+ c1 = new_r_Const(irg, tv);
+ 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 */
- tv = proj_nr == pn_Cmp_Eq ? get_tarval_b_false() : get_tarval_b_true();
- c1 = new_Const(tv);
- DBG_OPT_CSTEVAL(proj, c1);
+ ir_graph *irg = get_irn_irg(n);
+ tv = relation == ir_relation_equal ? get_tarval_b_false() : get_tarval_b_true();
+ c1 = new_r_Const(irg, tv);
+ DBG_OPT_CSTEVAL(n, c1);
return c1;
}
}
*/
c1 = get_Shl_right(left);
if (is_Const(c1)) {
- tarval *tv1 = get_Const_tarval(c1);
- ir_mode *mode = get_irn_mode(left);
- tarval *minus1 = get_mode_all_one(mode);
- tarval *amask = tarval_shr(minus1, tv1);
- tarval *cmask = tarval_shl(minus1, tv1);
- ir_node *sl, *blk;
+ ir_graph *irg = get_irn_irg(c1);
+ ir_tarval *tv1 = get_Const_tarval(c1);
+ ir_mode *mode = get_irn_mode(left);
+ ir_tarval *minus1 = get_mode_all_one(mode);
+ ir_tarval *amask = tarval_shr(minus1, tv1);
+ ir_tarval *cmask = tarval_shl(minus1, tv1);
+ ir_node *sl, *blk;
if (tarval_and(tv, cmask) != tv) {
/* condition not met */
- tv = proj_nr == pn_Cmp_Eq ? get_tarval_b_false() : get_tarval_b_true();
- c1 = new_Const(tv);
- DBG_OPT_CSTEVAL(proj, c1);
+ tv = relation == ir_relation_equal ? get_tarval_b_false() : get_tarval_b_true();
+ c1 = new_r_Const(irg, tv);
+ 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_Const(amask), mode);
+ 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;
*/
c1 = get_Shr_right(left);
if (is_Const(c1)) {
- tarval *tv1 = get_Const_tarval(c1);
- ir_mode *mode = get_irn_mode(left);
- tarval *minus1 = get_mode_all_one(mode);
- tarval *amask = tarval_shl(minus1, tv1);
- tarval *cmask = tarval_shr(minus1, tv1);
- ir_node *sl, *blk;
+ ir_graph *irg = get_irn_irg(c1);
+ ir_tarval *tv1 = get_Const_tarval(c1);
+ ir_mode *mode = get_irn_mode(left);
+ ir_tarval *minus1 = get_mode_all_one(mode);
+ ir_tarval *amask = tarval_shl(minus1, tv1);
+ ir_tarval *cmask = tarval_shr(minus1, tv1);
+ ir_node *sl, *blk;
if (tarval_and(tv, cmask) != tv) {
/* condition not met */
- tv = proj_nr == pn_Cmp_Eq ? get_tarval_b_false() : get_tarval_b_true();
- c1 = new_Const(tv);
- DBG_OPT_CSTEVAL(proj, c1);
+ tv = relation == ir_relation_equal ? get_tarval_b_false() : get_tarval_b_true();
+ c1 = new_r_Const(irg, tv);
+ 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_Const(amask), mode);
+ 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;
*/
c1 = get_Shrs_right(left);
if (is_Const(c1)) {
- tarval *tv1 = get_Const_tarval(c1);
- ir_mode *mode = get_irn_mode(left);
- tarval *minus1 = get_mode_all_one(mode);
- tarval *amask = tarval_shl(minus1, tv1);
- tarval *cond = new_tarval_from_long(get_mode_size_bits(mode), get_tarval_mode(tv1));
+ ir_graph *irg = get_irn_irg(c1);
+ ir_tarval *tv1 = get_Const_tarval(c1);
+ ir_mode *mode = get_irn_mode(left);
+ ir_tarval *minus1 = get_mode_all_one(mode);
+ ir_tarval *amask = tarval_shl(minus1, tv1);
+ ir_tarval *cond = new_tarval_from_long(get_mode_size_bits(mode), get_tarval_mode(tv1));
ir_node *sl, *blk;
cond = tarval_sub(cond, tv1, NULL);
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();
- c1 = new_Const(tv);
- DBG_OPT_CSTEVAL(proj, c1);
+ tv = relation == ir_relation_equal ? get_tarval_b_false() : get_tarval_b_true();
+ c1 = new_r_Const(irg, tv);
+ 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_Const(amask), mode);
+ 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;
- } /* switch */
+ }
}
- } /* tarval != bad */
+ }
}
- if (changed & 2) /* need a new Const */
- right = new_Const(tv);
+ 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)) {
- tarval *tv = get_Const_tarval(c);
+ ir_tarval *tv = get_Const_tarval(c);
if (tarval_is_single_bit(tv)) {
/* special case: (x % 2^n) CMP 0 ==> x & (2^n-1) CMP 0 */
ir_node *v = get_binop_left(op);
- ir_node *blk = get_irn_n(op, -1);
+ ir_node *blk = get_nodes_block(op);
+ ir_graph *irg = get_irn_irg(op);
ir_mode *mode = get_irn_mode(v);
tv = tarval_sub(tv, get_mode_one(mode), NULL);
- left = new_rd_And(get_irn_dbg_info(op), blk, v, new_Const(tv), mode);
- changed |= 1;
+ left = new_rd_And(get_irn_dbg_info(op), blk, v, new_r_Const(irg, tv), mode);
+ 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), block, 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.
*/
-static ir_node *transform_node_Proj_CopyB(ir_node *proj) {
+static ir_node *transform_node_Proj_CopyB(ir_node *proj)
+{
ir_node *copyb = get_Proj_pred(proj);
ir_node *a = get_CopyB_dst(copyb);
ir_node *b = get_CopyB_src(copyb);
DBG_OPT_EXC_REM(proj);
proj = new_r_Jmp(get_nodes_block(copyb));
break;
- case pn_CopyB_X_except:
+ case pn_CopyB_X_except: {
+ ir_graph *irg = get_irn_irg(proj);
DBG_OPT_EXC_REM(proj);
- proj = get_irg_bad(get_irn_irg(proj));
+ proj = new_r_Bad(irg, mode_X);
break;
+ }
default:
break;
}
}
return proj;
-} /* transform_node_Proj_CopyB */
+}
/**
* Optimize Bounds(idx, idx, upper) into idx.
*/
-static ir_node *transform_node_Proj_Bound(ir_node *proj) {
+static ir_node *transform_node_Proj_Bound(ir_node *proj)
+{
ir_node *oldn = proj;
ir_node *bound = get_Proj_pred(proj);
ir_node *idx = get_Bound_index(bound);
ret_tuple = 1;
else if (is_Bound(pred)) {
/*
- * idx was Bounds checked in the same MacroBlock previously,
- * it is still valid if lower <= pred_lower && pred_upper <= upper.
+ * idx was Bounds checked previously, it is still valid if
+ * lower <= pred_lower && pred_upper <= upper.
*/
ir_node *lower = get_Bound_lower(bound);
ir_node *upper = get_Bound_upper(bound);
if (get_Bound_lower(pred) == lower &&
- get_Bound_upper(pred) == upper &&
- get_irn_MacroBlock(bound) == get_irn_MacroBlock(pred)) {
+ get_Bound_upper(pred) == upper) {
/*
* One could expect that we simply return the previous
- * Bound here. However, this would be wrong, as we could
- * add an exception Proj to a new location then.
- * So, we must turn in into a tuple.
- */
- ret_tuple = 1;
- }
- }
- if (ret_tuple) {
- /* Turn Bound into a tuple (mem, jmp, bad, idx) */
- switch (get_Proj_proj(proj)) {
- case pn_Bound_M:
- DBG_OPT_EXC_REM(proj);
- proj = get_Bound_mem(bound);
- break;
- case pn_Bound_X_except:
- DBG_OPT_EXC_REM(proj);
- proj = get_irg_bad(get_irn_irg(proj));
- break;
- case pn_Bound_res:
- proj = idx;
- DBG_OPT_ALGSIM0(oldn, proj, FS_OPT_NOP);
- break;
- case pn_Bound_X_regular:
- DBG_OPT_EXC_REM(proj);
- proj = new_r_Jmp(get_nodes_block(bound));
- break;
- default:
- break;
- }
- }
- return proj;
-} /* transform_node_Proj_Bound */
-
-/**
- * Does all optimizations on nodes that must be done on it's Proj's
- * because of creating new nodes.
- */
-static ir_node *transform_node_Proj(ir_node *proj) {
- ir_node *n = get_Proj_pred(proj);
-
- if (n->op->ops.transform_node_Proj)
- return n->op->ops.transform_node_Proj(proj);
- return proj;
-} /* transform_node_Proj */
-
-/**
- * Move Confirms down through Phi nodes.
- */
-static ir_node *transform_node_Phi(ir_node *phi) {
- int i, n;
- ir_mode *mode = get_irn_mode(phi);
-
- if (mode_is_reference(mode)) {
- n = get_irn_arity(phi);
-
- /* Beware of Phi0 */
- if (n > 0) {
- ir_node *pred = get_irn_n(phi, 0);
- ir_node *bound, *new_Phi, *block, **in;
- pn_Cmp pnc;
-
- if (! is_Confirm(pred))
- return phi;
-
- bound = get_Confirm_bound(pred);
- pnc = get_Confirm_cmp(pred);
-
- NEW_ARR_A(ir_node *, in, n);
- in[0] = get_Confirm_value(pred);
-
- for (i = 1; i < n; ++i) {
- pred = get_irn_n(phi, i);
-
- if (! is_Confirm(pred) ||
- get_Confirm_bound(pred) != bound ||
- get_Confirm_cmp(pred) != pnc)
- 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 phi;
-} /* transform_node_Phi */
-
-/**
- * Returns the operands of a commutative bin-op, if one operand is
- * a const, it is returned as the second one.
- */
-static void get_comm_Binop_Ops(ir_node *binop, ir_node **a, ir_node **c) {
- ir_node *op_a = get_binop_left(binop);
- ir_node *op_b = get_binop_right(binop);
-
- assert(is_op_commutative(get_irn_op(binop)));
-
- if (is_Const(op_a)) {
- *a = op_b;
- *c = op_a;
- } else {
- *a = op_a;
- *c = op_b;
- }
-} /* get_comm_Binop_Ops */
-
-/**
- * Optimize a Or(And(Or(And(v,c4),c3),c2),c1) pattern if possible.
- * Such pattern may arise in bitfield stores.
- *
- * value c4 value c4 & c2
- * AND c3 AND c1 | c3
- * OR c2 ===> OR
- * AND c1
- * OR
- *
- *
- * value c2 value c1
- * AND c1 ===> OR if (c1 | c2) == 0x111..11
- * OR
- */
-static ir_node *transform_node_Or_bf_store(ir_node *or) {
- ir_node *and, *c1;
- ir_node *or_l, *c2;
- ir_node *and_l, *c3;
- ir_node *value, *c4;
- ir_node *new_and, *new_const, *block;
- ir_mode *mode = get_irn_mode(or);
-
- tarval *tv1, *tv2, *tv3, *tv4, *tv, *n_tv4, *n_tv2;
-
- while (1) {
- get_comm_Binop_Ops(or, &and, &c1);
- if (!is_Const(c1) || !is_And(and))
- return or;
-
- get_comm_Binop_Ops(and, &or_l, &c2);
- if (!is_Const(c2))
- return or;
-
- tv1 = get_Const_tarval(c1);
- tv2 = get_Const_tarval(c2);
-
- tv = tarval_or(tv1, tv2);
- 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);
-
- /* check for more */
- continue;
- }
-
- if (!is_Or(or_l))
- return or;
-
- get_comm_Binop_Ops(or_l, &and_l, &c3);
- if (!is_Const(c3) || !is_And(and_l))
- return or;
-
- get_comm_Binop_Ops(and_l, &value, &c4);
- if (!is_Const(c4))
- return or;
-
- /* ok, found the pattern, check for conditions */
- assert(mode == get_irn_mode(and));
- assert(mode == get_irn_mode(or_l));
- assert(mode == get_irn_mode(and_l));
-
- tv3 = get_Const_tarval(c3);
- tv4 = get_Const_tarval(c4);
-
- tv = tarval_or(tv4, tv2);
- if (!tarval_is_all_one(tv)) {
- /* have at least one 0 at the same bit position */
- return or;
- }
-
- n_tv4 = tarval_not(tv4);
- if (tv3 != tarval_and(tv3, n_tv4)) {
- /* bit in the or_mask is outside the and_mask */
- return or;
+ * Bound here. However, this would be wrong, as we could
+ * add an exception Proj to a new location then.
+ * So, we must turn in into a tuple.
+ */
+ ret_tuple = 1;
}
-
- n_tv2 = tarval_not(tv2);
- if (tv1 != tarval_and(tv1, n_tv2)) {
- /* bit in the or_mask is outside the and_mask */
- return or;
+ }
+ if (ret_tuple) {
+ /* Turn Bound into a tuple (mem, jmp, bad, idx) */
+ switch (get_Proj_proj(proj)) {
+ case pn_Bound_M:
+ DBG_OPT_EXC_REM(proj);
+ proj = get_Bound_mem(bound);
+ break;
+ case pn_Bound_X_except:
+ DBG_OPT_EXC_REM(proj);
+ proj = new_r_Bad(get_irn_irg(proj), mode_X);
+ break;
+ case pn_Bound_res:
+ proj = idx;
+ DBG_OPT_ALGSIM0(oldn, proj, FS_OPT_NOP);
+ break;
+ case pn_Bound_X_regular:
+ DBG_OPT_EXC_REM(proj);
+ proj = new_r_Jmp(get_nodes_block(bound));
+ break;
+ default:
+ break;
}
-
- /* ok, all conditions met */
- block = get_irn_n(or, -1);
-
- new_and = new_r_And(block, value, new_Const(tarval_and(tv4, tv2)), mode);
-
- new_const = new_Const(tarval_or(tv3, tv1));
-
- set_Or_left(or, new_and);
- set_Or_right(or, new_const);
-
- /* check for more */
}
-} /* transform_node_Or_bf_store */
+ return proj;
+}
/**
- * Optimize an Or(shl(x, c), shr(x, bits - c)) into a Rotl
+ * Does all optimizations on nodes that must be done on its Projs
+ * because of creating new nodes.
*/
-static ir_node *transform_node_Or_Rotl(ir_node *or) {
- ir_mode *mode = get_irn_mode(or);
- ir_node *shl, *shr, *block;
- ir_node *irn, *x, *c1, *c2, *v, *sub, *n, *rotval;
- tarval *tv1, *tv2;
-
- if (! mode_is_int(mode))
- return or;
-
- shl = get_binop_left(or);
- shr = get_binop_right(or);
-
- if (is_Shr(shl)) {
- if (!is_Shl(shr))
- return or;
-
- irn = shl;
- shl = shr;
- shr = irn;
- } else if (!is_Shl(shl)) {
- return or;
- } else if (!is_Shr(shr)) {
- return or;
- }
- x = get_Shl_left(shl);
- if (x != get_Shr_left(shr))
- return or;
-
- c1 = get_Shl_right(shl);
- c2 = get_Shr_right(shr);
- if (is_Const(c1) && is_Const(c2)) {
- tv1 = get_Const_tarval(c1);
- if (! tarval_is_long(tv1))
- return or;
+static ir_node *transform_node_Proj(ir_node *proj)
+{
+ ir_node *n = get_Proj_pred(proj);
- tv2 = get_Const_tarval(c2);
- if (! tarval_is_long(tv2))
- return or;
+ if (n->op->ops.transform_node_Proj)
+ return n->op->ops.transform_node_Proj(proj);
+ return proj;
+}
- if (get_tarval_long(tv1) + get_tarval_long(tv2)
- != (int) get_mode_size_bits(mode))
- return or;
+/**
+ * Test whether a block is unreachable
+ * Note: That this only returns true when
+ * IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE is set.
+ * This is important, as you easily end up producing invalid constructs in the
+ * unreachable code when optimizing away edges into the unreachable code.
+ * So only set this flag when you iterate localopts to the fixpoint.
+ * When you reach the fixpoint then all unreachable code is dead
+ * (= can't be reached by firm edges) and you won't see the invalid constructs
+ * anymore.
+ */
+static bool is_block_unreachable(const ir_node *block)
+{
+ const ir_graph *irg = get_irn_irg(block);
+ if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE))
+ return false;
+ return get_Block_dom_depth(block) < 0;
+}
- /* yet, condition met */
- block = get_nodes_block(or);
+static ir_node *transform_node_Block(ir_node *block)
+{
+ ir_graph *irg = get_irn_irg(block);
+ int arity = get_irn_arity(block);
+ ir_node *bad = NULL;
+ int i;
- n = new_r_Rotl(block, x, c1, mode);
+ if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE))
+ return block;
- DBG_OPT_ALGSIM1(or, shl, shr, n, FS_OPT_OR_SHFT_TO_ROTL);
- return n;
+ for (i = 0; i < arity; ++i) {
+ ir_node *const pred = get_Block_cfgpred(block, i);
+ if (is_Bad(pred) || !is_block_unreachable(get_nodes_block(pred)))
+ continue;
+ if (bad == NULL)
+ bad = new_r_Bad(irg, mode_X);
+ set_irn_n(block, i, bad);
}
- if (is_Sub(c1)) {
- v = c2;
- sub = c1;
- rotval = sub; /* a Rot right is not supported, so use a rot left */
- } else if (is_Sub(c2)) {
- v = c1;
- sub = c2;
- rotval = v;
- } else return or;
-
- if (get_Sub_right(sub) != v)
- return or;
-
- c1 = get_Sub_left(sub);
- if (!is_Const(c1))
- return or;
+ return block;
+}
- tv1 = get_Const_tarval(c1);
- if (! tarval_is_long(tv1))
- return or;
+static ir_node *transform_node_Phi(ir_node *phi)
+{
+ int n = get_irn_arity(phi);
+ ir_mode *mode = get_irn_mode(phi);
+ ir_node *block = get_nodes_block(phi);
+ ir_graph *irg = get_irn_irg(phi);
+ ir_node *bad = NULL;
+ int i;
+
+ /* Set phi-operands for bad-block inputs to bad */
+ for (i = 0; i < n; ++i) {
+ if (!is_Bad(get_Phi_pred(phi, i))) {
+ ir_node *pred = get_Block_cfgpred(block, i);
+ if (is_Bad(pred) || is_block_unreachable(get_nodes_block(pred))) {
+ if (bad == NULL)
+ bad = new_r_Bad(irg, mode);
+ set_irn_n(phi, i, bad);
+ }
+ }
+ }
- if (get_tarval_long(tv1) != (int) get_mode_size_bits(mode))
- return or;
+ /* Move Pin nodes down through Phi nodes. */
+ if (mode == mode_M) {
+ n = get_irn_arity(phi);
- /* yet, condition met */
- block = get_nodes_block(or);
+ /* Beware of Phi0 */
+ if (n > 0) {
+ ir_node **in;
+ ir_node *new_phi;
+ bool has_pin = false;
- n = new_r_Rotl(block, x, rotval, mode);
+ NEW_ARR_A(ir_node *, in, n);
- DBG_OPT_ALGSIM0(or, n, FS_OPT_OR_SHFT_TO_ROTL);
- return n;
-} /* transform_node_Or_Rotl */
+ for (i = 0; i < n; ++i) {
+ ir_node *pred = get_irn_n(phi, i);
-/**
- * Transform an Or.
- */
-static ir_node *transform_node_Or(ir_node *n) {
- ir_node *c, *oldn = n;
- ir_node *a = get_Or_left(n);
- ir_node *b = get_Or_right(n);
- ir_mode *mode;
+ if (is_Pin(pred)) {
+ in[i] = get_Pin_op(pred);
+ has_pin = true;
+ } else if (is_Bad(pred)) {
+ in[i] = pred;
+ } else {
+ return phi;
+ }
+ }
- if (is_Not(a) && is_Not(b)) {
- /* ~a | ~b = ~(a&b) */
- ir_node *block = get_nodes_block(n);
+ if (!has_pin)
+ return phi;
- mode = get_irn_mode(n);
- a = get_Not_op(a);
- b = get_Not_op(b);
- n = new_rd_And(get_irn_dbg_info(n), block, a, b, mode);
- n = new_rd_Not(get_irn_dbg_info(n), block, n, mode);
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_DEMORGAN);
- return n;
+ /* Move the Pin nodes "behind" the Phi. */
+ new_phi = new_r_Phi(block, n, in, mode_M);
+ return new_r_Pin(block, new_phi);
+ }
}
+ /* Move Confirms down through Phi nodes. */
+ else if (mode_is_reference(mode)) {
+ n = get_irn_arity(phi);
- /* 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);
- ir_node *block = get_nodes_block(pred_a);
- pn_Cmp pn_a = get_Proj_proj(a);
- pn_Cmp pn_b = get_Proj_proj(b);
- /* yes, we can simply calculate with pncs */
- pn_Cmp new_pnc = pn_a | pn_b;
+ /* Beware of Phi0 */
+ if (n > 0) {
+ ir_node *pred = get_irn_n(phi, 0);
+ ir_node *bound, *new_phi, **in;
+ ir_relation relation;
+ bool has_confirm = false;
- return new_rd_Proj(dbgi, block, pred_a, mode_b, new_pnc);
- }
- }
+ if (! is_Confirm(pred))
+ return phi;
- mode = get_irn_mode(n);
- HANDLE_BINOP_PHI((eval_func) tarval_or, a, b, c, mode);
+ bound = get_Confirm_bound(pred);
+ relation = get_Confirm_relation(pred);
- n = transform_node_Or_bf_store(n);
- n = transform_node_Or_Rotl(n);
- if (n != oldn)
- return n;
+ NEW_ARR_A(ir_node *, in, n);
+ in[0] = get_Confirm_value(pred);
- n = transform_bitwise_distributive(n, transform_node_Or);
+ for (i = 1; i < n; ++i) {
+ pred = get_irn_n(phi, i);
- return n;
-} /* transform_node_Or */
+ if (is_Confirm(pred) &&
+ get_Confirm_bound(pred) == bound &&
+ get_Confirm_relation(pred) == relation) {
+ in[i] = get_Confirm_value(pred);
+ has_confirm = true;
+ } else if (is_Bad(pred)) {
+ in[i] = pred;
+ } else {
+ return phi;
+ }
+ }
+ if (!has_confirm)
+ return phi;
-/* forward */
-static ir_node *transform_node(ir_node *n);
+ /* move the Confirm nodes "behind" the Phi */
+ new_phi = new_r_Phi(block, n, in, get_irn_mode(phi));
+ return new_r_Confirm(block, new_phi, bound, relation);
+ }
+ }
+ return phi;
+}
/**
* Optimize (a >> c1) >> c2), works for Shr, Shrs, Shl, Rotl.
*
* Should be moved to reassociation?
*/
-static ir_node *transform_node_shift(ir_node *n) {
+static ir_node *transform_node_shift(ir_node *n)
+{
ir_node *left, *right;
ir_mode *mode;
- tarval *tv1, *tv2, *res;
+ ir_mode *count_mode;
+ ir_tarval *tv1, *tv2, *res;
ir_node *in[2], *irn, *block;
+ ir_graph *irg;
+ int modulo_shf;
left = get_binop_left(n);
return n;
right = get_binop_right(n);
- tv1 = value_of(right);
+ tv1 = value_of(right);
if (tv1 == tarval_bad)
return n;
if (tv2 == tarval_bad)
return n;
- res = tarval_add(tv1, tv2);
- mode = get_irn_mode(n);
+ count_mode = get_tarval_mode(tv1);
+ if (get_tarval_mode(tv2) != count_mode) {
+ /* TODO: search bigger mode or something and convert... */
+ return n;
+ }
- /* beware: a simple replacement works only, if res < modulo shift */
- if (!is_Rotl(n)) {
- int modulo_shf = get_mode_modulo_shift(mode);
- if (modulo_shf > 0) {
- tarval *modulo = new_tarval_from_long(modulo_shf,
- get_tarval_mode(res));
+ mode = get_irn_mode(n);
+ modulo_shf = get_mode_modulo_shift(mode);
- assert(modulo_shf >= (int) get_mode_size_bits(mode));
+ if (modulo_shf > 0) {
+ ir_tarval *modulo_mask = new_tarval_from_long(modulo_shf-1, count_mode);
- /* shifting too much */
- if (!(tarval_cmp(res, modulo) & pn_Cmp_Lt)) {
- if (is_Shrs(n)) {
- ir_node *block = get_nodes_block(n);
- dbg_info *dbgi = get_irn_dbg_info(n);
- ir_mode *smode = get_irn_mode(right);
- ir_node *cnst = new_Const_long(smode, get_mode_size_bits(mode) - 1);
- return new_rd_Shrs(dbgi, block, get_binop_left(left), cnst, mode);
- }
+ /* I'm not so sure what happens in one complement... */
+ assert(get_mode_arithmetic(count_mode) == irma_twos_complement);
+ /* modulo shifts should always be a power of 2 (otherwise modulo_mask
+ * above will be invalid) */
+ assert(modulo_shf<=0 || is_po2(modulo_shf));
+
+ tv1 = tarval_and(tv1, modulo_mask);
+ tv2 = tarval_and(tv2, modulo_mask);
+ }
+ res = tarval_add(tv1, tv2);
+ irg = get_irn_irg(n);
+
+ /* beware: a simple replacement works only, if res < modulo shift */
+ if (is_Rotl(n)) {
+ int bits = get_mode_size_bits(mode);
+ ir_tarval *modulo = new_tarval_from_long(bits, count_mode);
+ res = tarval_mod(res, modulo);
+ } else {
+ long bits = get_mode_size_bits(mode);
+ ir_tarval *mode_size = new_tarval_from_long(bits, count_mode);
- return new_Const(get_mode_null(mode));
+ /* shifting too much */
+ if (!(tarval_cmp(res, mode_size) & ir_relation_less)) {
+ if (is_Shrs(n)) {
+ ir_node *block = get_nodes_block(n);
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_mode *smode = get_irn_mode(right);
+ ir_node *cnst = new_r_Const_long(irg, smode, get_mode_size_bits(mode) - 1);
+ return new_rd_Shrs(dbgi, block, get_binop_left(left), cnst, mode);
}
+
+ return new_r_Const(irg, get_mode_null(mode));
}
- } else {
- res = tarval_mod(res, new_tarval_from_long(get_mode_size_bits(mode), get_tarval_mode(res)));
}
/* ok, we can replace it */
+ assert(modulo_shf >= (int) get_mode_size_bits(mode));
block = get_nodes_block(n);
in[0] = get_binop_left(left);
- in[1] = new_Const(res);
+ in[1] = new_r_Const(irg, res);
irn = new_ir_node(NULL, get_Block_irg(block), block, get_irn_op(n), mode, 2, in);
DBG_OPT_ALGSIM0(n, irn, FS_OPT_REASSOC_SHIFT);
- return transform_node(irn);
-} /* transform_node_shift */
-
-/**
- * normalisation: (x & c1) >> c2 to (x >> c2) & (c1 >> c2)
- * (we can use:
- * - and, or, xor instead of &
- * - Shl, Shr, Shrs, rotl instead of >>
- * (with a special case for Or/Xor + Shrs)
- */
-static ir_node *transform_node_bitop_shift(ir_node *n) {
- ir_node *left;
- ir_node *right = get_binop_right(n);
- ir_mode *mode = get_irn_mode(n);
- ir_node *bitop_left;
- ir_node *bitop_right;
- ir_op *op_left;
- ir_node *block;
- dbg_info *dbgi;
- ir_node *new_shift;
- ir_node *new_bitop;
- ir_node *new_const;
- tarval *tv1;
- tarval *tv2;
- tarval *tv_shift;
-
- assert(is_Shrs(n) || is_Shr(n) || is_Shl(n) || is_Rotl(n));
-
- if (!is_Const(right))
- return n;
-
- left = get_binop_left(n);
- op_left = get_irn_op(left);
- if (op_left != op_And && op_left != op_Or && op_left != op_Eor)
- return n;
-
- /* doing it with Shrs is not legal if the Or/Eor affects the topmost bit */
- if (is_Shrs(n) && (op_left == op_Or || op_left == op_Eor)) {
- /* TODO: test if sign bit is affectes */
- return n;
- }
-
- bitop_right = get_binop_right(left);
- if (!is_Const(bitop_right))
- return n;
-
- bitop_left = get_binop_left(left);
-
- block = get_nodes_block(n);
- dbgi = get_irn_dbg_info(n);
- tv1 = get_Const_tarval(bitop_right);
- tv2 = get_Const_tarval(right);
-
- assert(get_tarval_mode(tv1) == mode);
-
- if (is_Shl(n)) {
- new_shift = new_rd_Shl(dbgi, block, bitop_left, right, mode);
- tv_shift = tarval_shl(tv1, tv2);
- } else if(is_Shr(n)) {
- new_shift = new_rd_Shr(dbgi, block, bitop_left, right, mode);
- tv_shift = tarval_shr(tv1, tv2);
- } else if(is_Shrs(n)) {
- new_shift = new_rd_Shrs(dbgi, block, bitop_left, right, mode);
- tv_shift = tarval_shrs(tv1, tv2);
- } else {
- assert(is_Rotl(n));
- new_shift = new_rd_Rotl(dbgi, block, bitop_left, right, mode);
- tv_shift = tarval_rotl(tv1, tv2);
- }
-
- assert(get_tarval_mode(tv_shift) == mode);
- new_const = new_Const(tv_shift);
-
- if (op_left == op_And) {
- new_bitop = new_rd_And(dbgi, block, new_shift, new_const, mode);
- } else if(op_left == op_Or) {
- new_bitop = new_rd_Or(dbgi, block, new_shift, new_const, mode);
- } else {
- assert(op_left == op_Eor);
- new_bitop = new_rd_Eor(dbgi, block, new_shift, new_const, mode);
- }
-
- return new_bitop;
+ return irn;
}
/**
* (x >> c1) << c2 <=> x OP (c2-c1) & ((-1 >> c1) << c2)
* (also with x >>s c1 when c1>=c2)
*/
-static ir_node *transform_node_shl_shr(ir_node *n) {
- ir_node *left;
- ir_node *right = get_binop_right(n);
- ir_node *x;
- ir_graph *irg;
- ir_node *block;
- ir_mode *mode;
- dbg_info *dbgi;
- ir_node *new_const;
- ir_node *new_shift;
- ir_node *new_and;
- tarval *tv_shl;
- tarval *tv_shr;
- tarval *tv_shift;
- tarval *tv_mask;
- pn_Cmp pnc;
- int need_shrs = 0;
+static ir_node *transform_node_shl_shr(ir_node *n)
+{
+ ir_node *left;
+ ir_node *right = get_binop_right(n);
+ ir_node *x;
+ ir_node *block;
+ ir_mode *mode;
+ dbg_info *dbgi;
+ ir_node *new_const;
+ ir_node *new_shift;
+ ir_node *new_and;
+ ir_tarval *tv_shl;
+ ir_tarval *tv_shr;
+ ir_tarval *tv_shift;
+ ir_tarval *tv_mask;
+ ir_graph *irg;
+ 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);
tv_mask = tarval_shr(get_mode_all_one(mode), tv_shr);
}
tv_mask = tarval_shl(tv_mask, tv_shl);
- } else if(is_Shr(n) && is_Shl(left)) {
+ } else if (is_Shr(n) && is_Shl(left)) {
ir_node *shl_right = get_Shl_right(left);
if (!is_Const(shl_right))
assert(tv_mask != tarval_bad);
assert(get_tarval_mode(tv_mask) == mode);
- irg = get_irn_irg(n);
block = get_nodes_block(n);
+ 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_Const(tv_shift);
+ new_const = new_r_Const(irg, tv_shift);
if (need_shrs) {
new_shift = new_rd_Shrs(dbgi, block, x, new_const, mode);
} else {
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_Const(tv_shift);
+ new_const = new_r_Const(irg, tv_shift);
new_shift = new_rd_Shl(dbgi, block, x, new_const, mode);
}
- new_const = new_Const(tv_mask);
+ new_const = new_r_Const(irg, tv_mask);
new_and = new_rd_And(dbgi, block, new_shift, new_const, mode);
- return new_and;
+ return new_and;
+}
+
+static ir_tarval *get_modulo_tv_value(ir_tarval *tv, int modulo_val)
+{
+ ir_mode *mode = get_tarval_mode(tv);
+ ir_tarval *modulo_tv = new_tarval_from_long(modulo_val, mode);
+ return tarval_mod(tv, modulo_tv);
+}
+
+typedef ir_node*(*new_shift_func)(dbg_info *dbgi, ir_node *block,
+ ir_node *left, ir_node *right, ir_mode *mode);
+
+/**
+ * Normalisation: if we have a shl/shr with modulo_shift behaviour
+ * then we can use that to minimize the value of Add(x, const) or
+ * Sub(Const, x). In particular this often avoids 1 instruction in some
+ * backends for the Shift(x, Sub(Const, y)) case because it can be replaced
+ * by Shift(x, Minus(y)) which does not need an explicit Const constructed.
+ */
+static ir_node *transform_node_shift_modulo(ir_node *n,
+ new_shift_func new_shift)
+{
+ ir_mode *mode = get_irn_mode(n);
+ int modulo = get_mode_modulo_shift(mode);
+ ir_node *newop = NULL;
+ ir_mode *mode_right;
+ ir_node *block;
+ ir_node *right;
+ ir_graph *irg;
+
+ if (modulo == 0)
+ return n;
+ if (get_mode_arithmetic(mode) != irma_twos_complement)
+ return n;
+ if (!is_po2(modulo))
+ return n;
+
+ irg = get_irn_irg(n);
+ block = get_nodes_block(n);
+ right = get_binop_right(n);
+ mode_right = get_irn_mode(right);
+ if (is_Const(right)) {
+ ir_tarval *tv = get_Const_tarval(right);
+ ir_tarval *tv_mod = get_modulo_tv_value(tv, modulo);
+
+ if (tv_mod == tv)
+ return n;
+
+ newop = new_r_Const(irg, tv_mod);
+ } else if (is_Add(right) || is_Or_Eor_Add(right)) {
+ ir_node *add_right = get_binop_right(right);
+ if (is_Const(add_right)) {
+ ir_tarval *tv = get_Const_tarval(add_right);
+ ir_tarval *tv_mod = get_modulo_tv_value(tv, modulo);
+ ir_node *newconst;
+ if (tv_mod == tv)
+ return n;
+
+ newconst = new_r_Const(irg, tv_mod);
+ newop = new_r_Add(block, get_binop_left(right), newconst,
+ mode_right);
+ }
+ } else if (is_Sub(right)) {
+ ir_node *sub_left = get_Sub_left(right);
+ if (is_Const(sub_left)) {
+ ir_tarval *tv = get_Const_tarval(sub_left);
+ ir_tarval *tv_mod = get_modulo_tv_value(tv, modulo);
+ ir_node *newconst;
+ if (tv_mod == tv)
+ return n;
+
+ newconst = new_r_Const(irg, tv_mod);
+ newop = new_r_Sub(block, newconst, get_Sub_right(right),
+ mode_right);
+ }
+ } else {
+ return n;
+ }
+
+ if (newop != NULL) {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *left = get_binop_left(n);
+ return new_shift(dbgi, block, left, newop, mode);
+ }
+ return n;
}
/**
* Transform a Shr.
*/
-static ir_node *transform_node_Shr(ir_node *n) {
+static ir_node *transform_node_Shr(ir_node *n)
+{
ir_node *c, *oldn = n;
ir_node *left = get_Shr_left(n);
ir_node *right = get_Shr_right(n);
HANDLE_BINOP_PHI((eval_func) tarval_shr, left, right, c, mode);
n = transform_node_shift(n);
+ if (is_Shr(n))
+ n = transform_node_shift_modulo(n, new_rd_Shr);
if (is_Shr(n))
n = transform_node_shl_shr(n);
if (is_Shr(n))
- n = transform_node_bitop_shift(n);
+ n = transform_node_shift_bitop(n);
return n;
-} /* transform_node_Shr */
+}
/**
* Transform a Shrs.
*/
-static ir_node *transform_node_Shrs(ir_node *n) {
- ir_node *c, *oldn = n;
- ir_node *a = get_Shrs_left(n);
- ir_node *b = get_Shrs_right(n);
- ir_mode *mode = get_irn_mode(n);
+static ir_node *transform_node_Shrs(ir_node *n)
+{
+ ir_node *oldn = n;
+ ir_node *a = get_Shrs_left(n);
+ ir_node *b = get_Shrs_right(n);
+ ir_mode *mode = get_irn_mode(n);
+ ir_node *c;
+ vrp_attr *attr;
+
+ if (is_oversize_shift(n)) {
+ ir_node *block = get_nodes_block(n);
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_mode *cmode = get_irn_mode(b);
+ long val = get_mode_size_bits(cmode)-1;
+ ir_graph *irg = get_irn_irg(n);
+ ir_node *cnst = new_r_Const_long(irg, cmode, val);
+ return new_rd_Shrs(dbgi, block, a, cnst, mode);
+ }
HANDLE_BINOP_PHI((eval_func) tarval_shrs, a, b, c, mode);
n = transform_node_shift(n);
+ if (n != oldn)
+ return n;
- if (is_Shrs(n))
- n = transform_node_bitop_shift(n);
+ n = transform_node_shift_modulo(n, new_rd_Shrs);
+ if (n != oldn)
+ return n;
+ n = transform_node_shift_bitop(n);
+ if (n != oldn)
+ return n;
+
+ /* normalisation: use Shr when sign bit is guaranteed to be cleared */
+ attr = vrp_get_info(a);
+ if (attr != NULL) {
+ unsigned bits = get_mode_size_bits(mode);
+ ir_tarval *scount = new_tarval_from_long(bits-1, mode_Iu);
+ ir_tarval *sign = tarval_shl(get_mode_one(mode), scount);
+ if (tarval_is_null(tarval_and(attr->bits_not_set, sign))) {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ return new_rd_Shr(dbgi, block, a, b, mode);
+ }
+ }
return n;
-} /* transform_node_Shrs */
+}
/**
* Transform a Shl.
*/
-static ir_node *transform_node_Shl(ir_node *n) {
+static ir_node *transform_node_Shl(ir_node *n)
+{
ir_node *c, *oldn = n;
ir_node *a = get_Shl_left(n);
ir_node *b = get_Shl_right(n);
HANDLE_BINOP_PHI((eval_func) tarval_shl, a, b, c, mode);
n = transform_node_shift(n);
+ if (is_Shl(n))
+ n = transform_node_shift_modulo(n, new_rd_Shl);
if (is_Shl(n))
n = transform_node_shl_shr(n);
if (is_Shl(n))
- n = transform_node_bitop_shift(n);
+ n = transform_node_shift_bitop(n);
return n;
-} /* transform_node_Shl */
+}
/**
* Transform a Rotl.
*/
-static ir_node *transform_node_Rotl(ir_node *n) {
+static ir_node *transform_node_Rotl(ir_node *n)
+{
ir_node *c, *oldn = n;
ir_node *a = get_Rotl_left(n);
ir_node *b = get_Rotl_right(n);
n = transform_node_shift(n);
if (is_Rotl(n))
- n = transform_node_bitop_shift(n);
+ n = transform_node_shift_bitop(n);
return n;
-} /* transform_node_Rotl */
+}
+
+/**
+ * returns mode size for may_leave_out_middle_mode
+ */
+static unsigned get_significand_size(ir_mode *mode)
+{
+ const ir_mode_arithmetic arithmetic = get_mode_arithmetic(mode);
+ switch (arithmetic) {
+ case irma_ieee754:
+ case irma_x86_extended_float:
+ return get_mode_mantissa_size(mode) + 1;
+ case irma_twos_complement:
+ return get_mode_size_bits(mode);
+ case irma_none:
+ panic("Conv node with irma_none mode?");
+ }
+ panic("unexpected mode_arithmetic in get_significand_size");
+}
+
+/**
+ * Returns true if a conversion from mode @p m0 to @p m1 has the same effect
+ * as converting from @p m0 to @p m1 and then to @p m2.
+ * Classifying the 3 modes as the big(b), middle(m) and small(s) mode this
+ * gives the following truth table:
+ * s -> b -> m : true
+ * s -> m -> b : !signed(s) || signed(m)
+ * m -> b -> s : true
+ * m -> s -> b : false
+ * b -> s -> m : false
+ * b -> m -> s : true
+ *
+ * s -> b -> b : true
+ * s -> s -> b : false
+ *
+ * additional float constraints:
+ * F -> F -> F: fine
+ * F -> I -> I: signedness of Is must match
+ * I -> F -> I: signedness of Is must match
+ * I -> I -> F: signedness of Is must match
+ * F -> I -> F: bad
+ * I -> F -> F: fine
+ * F -> F -> I: fine
+ * at least 1 float involved: signedness must match
+ */
+bool may_leave_out_middle_conv(ir_mode *m0, ir_mode *m1, ir_mode *m2)
+{
+ int n_floats = mode_is_float(m0) + mode_is_float(m1) + mode_is_float(m2);
+ if (n_floats == 1) {
+#if 0
+ int n_signed = mode_is_signed(m0) + mode_is_signed(m1)
+ + mode_is_signed(m2);
+ /* we assume that float modes are always signed */
+ if ((n_signed & 1) != 1)
+ return false;
+#else
+ /* because overflow gives strange results we don't touch this case */
+ return false;
+#endif
+ } else if (n_floats == 2 && !mode_is_float(m1)) {
+ return false;
+ }
+
+ unsigned size0 = get_significand_size(m0);
+ unsigned size1 = get_significand_size(m1);
+ unsigned size2 = get_significand_size(m2);
+ if (size1 < size2 && size0 >= size1)
+ return false;
+ if (size1 >= size2)
+ return true;
+ return !mode_is_signed(m0) || mode_is_signed(m1);
+}
/**
* Transform a Conv.
*/
-static ir_node *transform_node_Conv(ir_node *n) {
+static ir_node *transform_node_Conv(ir_node *n)
+{
ir_node *c, *oldn = n;
ir_mode *mode = get_irn_mode(n);
ir_node *a = get_Conv_op(n);
+ if (is_Conv(a)) {
+ ir_mode *a_mode = get_irn_mode(a);
+ ir_node *b = get_Conv_op(a);
+ ir_mode *b_mode = get_irn_mode(b);
+ if (may_leave_out_middle_conv(b_mode, a_mode, mode)) {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ return new_rd_Conv(dbgi, block, b, mode);
+ }
+ }
+
if (mode != mode_b && is_const_Phi(a)) {
/* Do NOT optimize mode_b Conv's, this leads to remaining
* Phib nodes later, because the conv_b_lower operation
}
if (is_Unknown(a)) { /* Conv_A(Unknown_B) -> Unknown_A */
- return new_r_Unknown(current_ir_graph, mode);
+ ir_graph *irg = get_irn_irg(n);
+ return new_r_Unknown(irg, mode);
}
if (mode_is_reference(mode) &&
ir_node *r = get_Add_right(a);
dbg_info *dbgi = get_irn_dbg_info(a);
ir_node *block = get_nodes_block(n);
- if(is_Conv(l)) {
+ if (is_Conv(l)) {
ir_node *lop = get_Conv_op(l);
- if(get_irn_mode(lop) == mode) {
+ if (get_irn_mode(lop) == mode) {
/* ConvP(AddI(ConvI(P), x)) -> AddP(P, x) */
n = new_rd_Add(dbgi, block, lop, r, mode);
return n;
}
}
- if(is_Conv(r)) {
+ if (is_Conv(r)) {
ir_node *rop = get_Conv_op(r);
- if(get_irn_mode(rop) == mode) {
+ if (get_irn_mode(rop) == mode) {
/* ConvP(AddI(x, ConvI(P))) -> AddP(x, P) */
n = new_rd_Add(dbgi, block, l, rop, mode);
return n;
}
return n;
-} /* transform_node_Conv */
+}
/**
* Remove dead blocks and nodes in dead blocks
* in keep alive list. We do not generate a new End node.
*/
-static ir_node *transform_node_End(ir_node *n) {
+static ir_node *transform_node_End(ir_node *n)
+{
int i, j, n_keepalives = get_End_n_keepalives(n);
ir_node **in;
for (i = j = 0; i < n_keepalives; ++i) {
ir_node *ka = get_End_keepalive(n, i);
- if (is_Block(ka)) {
- if (! is_Block_dead(ka)) {
- in[j++] = ka;
- }
- continue;
- } else if (is_irn_pinned_in_irg(ka) && is_Block_dead(get_nodes_block(ka))) {
+ ir_node *block;
+ /* no need to keep Bad */
+ if (is_Bad(ka))
continue;
- } else if (is_Bad(ka)) {
- /* no need to keep Bad */
+ /* do not keep unreachable code */
+ block = is_Block(ka) ? ka : get_nodes_block(ka);
+ if (is_block_unreachable(block))
continue;
- }
in[j++] = ka;
}
if (j != n_keepalives)
set_End_keepalives(n, j, in);
return n;
-} /* transform_node_End */
+}
-/** returns 1 if a == -b */
-static int 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 1;
+ return true;
if (is_Minus(b) && get_Minus_op(b) == a)
- return 1;
+ return true;
if (is_Sub(a) && is_Sub(b)) {
ir_node *a_left = get_Sub_left(a);
ir_node *a_right = get_Sub_right(a);
ir_node *b_right = get_Sub_right(b);
if (a_left == b_right && a_right == b_left)
+ return true;
+ }
+
+ return false;
+}
+
+static const ir_node *skip_upconv(const ir_node *node)
+{
+ while (is_Conv(node)) {
+ ir_mode *mode = get_irn_mode(node);
+ const ir_node *op = get_Conv_op(node);
+ ir_mode *op_mode = get_irn_mode(op);
+ if (!smaller_mode(op_mode, mode))
+ break;
+ node = op;
+ }
+ return node;
+}
+
+int ir_mux_is_abs(const ir_node *sel, const ir_node *mux_false,
+ const ir_node *mux_true)
+{
+ ir_node *cmp_left;
+ ir_node *cmp_right;
+ ir_mode *mode;
+ ir_relation relation;
+
+ if (!is_Cmp(sel))
+ return 0;
+
+ /**
+ * 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 Abs/-Abs
+ * transformations.
+ */
+ mode = get_irn_mode(mux_true);
+ if (mode_honor_signed_zeros(mode))
+ return 0;
+
+ /* must be <, <=, >=, > */
+ relation = get_Cmp_relation(sel);
+ if ((relation & ir_relation_less_greater) == 0)
+ return 0;
+
+ if (!ir_is_negated_value(mux_true, mux_false))
+ return 0;
+
+ mux_true = skip_upconv(mux_true);
+ mux_false = skip_upconv(mux_false);
+
+ /* must be x cmp 0 */
+ cmp_right = get_Cmp_right(sel);
+ if (!is_Const(cmp_right) || !is_Const_null(cmp_right))
+ return 0;
+
+ cmp_left = get_Cmp_left(sel);
+ if (cmp_left == mux_false) {
+ if (relation & ir_relation_less) {
+ return 1;
+ } else {
+ assert(relation & ir_relation_greater);
+ return -1;
+ }
+ } else if (cmp_left == mux_true) {
+ if (relation & ir_relation_less) {
+ return -1;
+ } else {
+ assert(relation & ir_relation_greater);
return 1;
+ }
}
return 0;
}
+ir_node *ir_get_abs_op(const ir_node *sel, ir_node *mux_false,
+ ir_node *mux_true)
+{
+ ir_node *cmp_left = get_Cmp_left(sel);
+ return cmp_left == skip_upconv(mux_false) ? mux_false : mux_true;
+}
+
+bool ir_is_optimizable_mux(const ir_node *sel, const ir_node *mux_false,
+ const ir_node *mux_true)
+{
+ /* this code should return true each time transform_node_Mux would
+ * optimize the Mux completely away */
+
+ ir_mode *mode = get_irn_mode(mux_false);
+ if (get_mode_arithmetic(mode) == irma_twos_complement
+ && ir_mux_is_abs(sel, mux_false, mux_true))
+ return true;
+
+ if (is_Cmp(sel) && mode_is_int(mode) && is_cmp_equality_zero(sel)) {
+ const ir_node *cmp_r = get_Cmp_right(sel);
+ const ir_node *cmp_l = get_Cmp_left(sel);
+ const ir_node *f = mux_false;
+ const ir_node *t = mux_true;
+
+ if (is_Const(t) && is_Const_null(t)) {
+ t = mux_false;
+ f = mux_true;
+ }
+
+ if (is_And(cmp_l) && f == cmp_r) {
+ ir_node *and_r = get_And_right(cmp_l);
+ ir_node *and_l;
+
+ if (and_r == t && is_single_bit(and_r))
+ return true;
+ and_l = get_And_left(cmp_l);
+ if (and_l == t && is_single_bit(and_l))
+ return true;
+ }
+ }
+
+ return false;
+}
+
/**
- * Optimize a Mux into some simpler cases.
+ * Optimize a Mux(c, 0, 1) node (sometimes called a "set" instruction)
*/
-static ir_node *transform_node_Mux(ir_node *n) {
- ir_node *oldn = n, *sel = get_Mux_sel(n);
- ir_mode *mode = get_irn_mode(n);
- ir_node *t = get_Mux_true(n);
- ir_node *f = get_Mux_false(n);
- ir_graph *irg = current_ir_graph;
-
- if (is_irg_state(irg, IR_GRAPH_STATE_KEEP_MUX))
+static ir_node *transform_Mux_set(ir_node *n)
+{
+ ir_node *cond = get_Mux_sel(n);
+ ir_mode *dest_mode;
+ ir_mode *mode;
+ ir_node *left;
+ ir_node *right;
+ ir_relation relation;
+ bool need_not;
+ dbg_info *dbgi;
+ ir_node *block;
+ ir_graph *irg;
+ ir_node *a;
+ ir_node *b;
+ unsigned bits;
+ ir_tarval *tv;
+ ir_node *shift_cnt;
+ ir_node *res;
+
+ if (!is_Cmp(cond))
+ return n;
+ left = get_Cmp_left(cond);
+ mode = get_irn_mode(left);
+ if (!mode_is_int(mode) && !mode_is_reference(mode))
return n;
+ dest_mode = get_irn_mode(n);
+ if (!mode_is_int(dest_mode) && !mode_is_reference(dest_mode))
+ return n;
+ right = get_Cmp_right(cond);
+ relation = get_Cmp_relation(cond) & ~ir_relation_unordered;
+ if (get_mode_size_bits(mode) >= get_mode_size_bits(dest_mode)
+ && !(mode_is_signed(mode) && is_Const(right) && is_Const_null(right)
+ && relation != ir_relation_greater))
+ return n;
+
+ need_not = false;
+ switch (relation) {
+ case ir_relation_less:
+ /* a < b -> (a - b) >> 31 */
+ a = left;
+ b = right;
+ break;
+ case ir_relation_less_equal:
+ /* a <= b -> ~(a - b) >> 31 */
+ a = right;
+ b = left;
+ need_not = true;
+ break;
+ case ir_relation_greater:
+ /* a > b -> (b - a) >> 31 */
+ a = right;
+ b = left;
+ break;
+ case ir_relation_greater_equal:
+ /* a >= b -> ~(a - b) >> 31 */
+ a = left;
+ b = right;
+ need_not = true;
+ break;
+ default:
+ return n;
+ }
- if (is_Mux(t)) {
- ir_node* block = get_nodes_block(n);
- ir_node* c0 = sel;
- ir_node* c1 = get_Mux_sel(t);
- ir_node* t1 = get_Mux_true(t);
- ir_node* f1 = get_Mux_false(t);
- if (f == f1) {
- /* Mux(cond0, Mux(cond1, x, y), y) -> typical if (cond0 && cond1) x else y */
- ir_node* and_ = new_r_And(block, c0, c1, mode_b);
- ir_node* new_mux = new_r_Mux(block, and_, f1, t1, mode);
- n = new_mux;
- sel = and_;
- f = f1;
- t = t1;
- DBG_OPT_ALGSIM0(oldn, t, FS_OPT_MUX_COMBINE);
- } else if (f == t1) {
- /* Mux(cond0, Mux(cond1, x, y), x) */
- ir_node* not_c1 = new_r_Not(block, c1, mode_b);
- ir_node* and_ = new_r_And(block, c0, not_c1, mode_b);
- ir_node* new_mux = new_r_Mux(block, and_, t1, f1, mode);
- n = new_mux;
- sel = and_;
- f = t1;
- t = f1;
- DBG_OPT_ALGSIM0(oldn, t, FS_OPT_MUX_COMBINE);
- }
- } else if (is_Mux(f)) {
- ir_node* block = get_nodes_block(n);
- ir_node* c0 = sel;
- ir_node* c1 = get_Mux_sel(f);
- ir_node* t1 = get_Mux_true(f);
- ir_node* f1 = get_Mux_false(f);
- if (t == t1) {
- /* Mux(cond0, x, Mux(cond1, x, y)) -> typical if (cond0 || cond1) x else y */
- ir_node* or_ = new_r_Or(block, c0, c1, mode_b);
- ir_node* new_mux = new_r_Mux(block, or_, f1, t1, mode);
- n = new_mux;
- sel = or_;
- f = f1;
- t = t1;
- DBG_OPT_ALGSIM0(oldn, f, FS_OPT_MUX_COMBINE);
- } else if (t == f1) {
- /* Mux(cond0, x, Mux(cond1, y, x)) */
- ir_node* not_c1 = new_r_Not(block, c1, mode_b);
- ir_node* or_ = new_r_Or(block, c0, not_c1, mode_b);
- ir_node* new_mux = new_r_Mux(block, or_, t1, f1, mode);
- n = new_mux;
- sel = or_;
- f = t1;
- t = f1;
- DBG_OPT_ALGSIM0(oldn, f, FS_OPT_MUX_COMBINE);
- }
- }
-
- /* first normalization step: move a possible zero to the false case */
- if (is_Proj(sel)) {
- ir_node *cmp = get_Proj_pred(sel);
-
- if (is_Cmp(cmp)) {
- if (is_Const(t) && is_Const_null(t)) {
- ir_node *tmp;
-
- /* Mux(x, 0, y) => Mux(x, y, 0) */
- pn_Cmp pnc = get_Proj_proj(sel);
- sel = new_r_Proj(get_nodes_block(cmp), 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, t, f, mode);
- tmp = t;
- t = f;
- f = tmp;
- }
- }
+ dbgi = get_irn_dbg_info(n);
+ block = get_nodes_block(n);
+ irg = get_irn_irg(block);
+ bits = get_mode_size_bits(dest_mode);
+ tv = new_tarval_from_long(bits-1, mode_Iu);
+ shift_cnt = new_rd_Const(dbgi, irg, tv);
+
+ if (mode != dest_mode) {
+ a = new_rd_Conv(dbgi, block, a, dest_mode);
+ b = new_rd_Conv(dbgi, block, b, dest_mode);
}
- /* note: after normalization, false can only happen on default */
- if (mode == mode_b) {
- dbg_info *dbg = get_irn_dbg_info(n);
- ir_node *block = get_nodes_block(n);
+ res = new_rd_Sub(dbgi, block, a, b, dest_mode);
+ if (need_not) {
+ res = new_rd_Not(dbgi, block, res, dest_mode);
+ }
+ res = new_rd_Shr(dbgi, block, res, shift_cnt, dest_mode);
+ return res;
+}
- if (is_Const(t)) {
- tarval *tv_t = get_Const_tarval(t);
- if (tv_t == tarval_b_true) {
- if (is_Const(f)) {
- /* Muxb(sel, true, false) = sel */
- assert(get_Const_tarval(f) == tarval_b_false);
- DBG_OPT_ALGSIM0(oldn, sel, FS_OPT_MUX_BOOL);
- return sel;
- } else {
- /* Muxb(sel, true, x) = Or(sel, x) */
- n = new_rd_Or(dbg, block, sel, f, mode_b);
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_OR_BOOL);
- return n;
- }
- }
- } else if (is_Const(f)) {
- tarval *tv_f = get_Const_tarval(f);
- if (tv_f == tarval_b_true) {
- /* Muxb(sel, x, true) = Or(Not(sel), x) */
- ir_node* not_sel = new_rd_Not(dbg, block, sel, mode_b);
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_ORNOT_BOOL);
- n = new_rd_Or(dbg, block, not_sel, t, mode_b);
- return n;
+/**
+ * Optimize a Mux into some simpler cases.
+ */
+static ir_node *transform_node_Mux(ir_node *n)
+{
+ ir_node *oldn = n;
+ ir_node *sel = get_Mux_sel(n);
+ ir_mode *mode = get_irn_mode(n);
+ ir_node *t = get_Mux_true(n);
+ ir_node *f = get_Mux_false(n);
+ ir_graph *irg = get_irn_irg(n);
+
+ /* implement integer abs: abs(x) = x^(x >>s 31) - (x >>s 31) */
+ if (get_mode_arithmetic(mode) == irma_twos_complement) {
+ int abs = ir_mux_is_abs(sel, f, t);
+ if (abs != 0) {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *block = get_nodes_block(n);
+ ir_node *op = ir_get_abs_op(sel, f, t);
+ int bits = get_mode_size_bits(mode);
+ ir_node *shiftconst = new_r_Const_long(irg, mode_Iu, bits-1);
+ ir_node *sext = new_rd_Shrs(dbgi, block, op, shiftconst, mode);
+ ir_node *xorn = new_rd_Eor(dbgi, block, op, sext, mode);
+ ir_node *res;
+ if (abs > 0) {
+ res = new_rd_Sub(dbgi, block, xorn, sext, mode);
} else {
- /* Muxb(sel, x, false) = And(sel, x) */
- assert(tv_f == tarval_b_false);
- n = new_rd_And(dbg, block, sel, t, mode_b);
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_AND_BOOL);
- return n;
+ res = new_rd_Sub(dbgi, block, sext, xorn, mode);
}
+ return res;
}
}
- /* more normalization: try to normalize Mux(x, C1, C2) into Mux(x, +1/-1, 0) op C2 */
- if (is_Const(t) && is_Const(f) && mode_is_int(mode)) {
- tarval *a = get_Const_tarval(t);
- tarval *b = get_Const_tarval(f);
- tarval *diff, *min;
+ /* first normalization step: try to move a constant to the false side,
+ * 0 preferred on false side too */
+ 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;
- if (tarval_is_one(a) && tarval_is_null(b)) {
- ir_node *block = get_nodes_block(n);
- ir_node *conv = new_r_Conv(block, sel, mode);
- n = conv;
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_CONV);
- return n;
- } else if (tarval_is_null(a) && tarval_is_one(b)) {
- ir_node *block = get_nodes_block(n);
- ir_node *not_ = new_r_Not(block, sel, mode_b);
- ir_node *conv = new_r_Conv(block, not_, mode);
- n = conv;
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_CONV);
+ /* 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);
+ return new_rd_Mux(get_irn_dbg_info(n), get_nodes_block(n), sel, f, t, mode);
+ }
+
+ if (is_Const(f) && is_Const_null(f) && is_Const(t) && is_Const_one(t)) {
+ n = transform_Mux_set(n);
+ if (n != oldn)
return n;
- }
- /* TODO: it's not really clear if that helps in general or should be moved
- * to backend, especially with the MUX->Conv transformation above */
- if (tarval_cmp(a, b) & pn_Cmp_Gt) {
- diff = tarval_sub(a, b, NULL);
- min = b;
- } else {
- diff = tarval_sub(b, a, NULL);
- min = a;
+ }
+
+ /* the following optimisations create new mode_b nodes, so only do them
+ * before mode_b lowering */
+ if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_MODEB_LOWERED)) {
+ if (is_Mux(t)) {
+ ir_node* block = get_nodes_block(n);
+ ir_node* c0 = sel;
+ ir_node* c1 = get_Mux_sel(t);
+ ir_node* t1 = get_Mux_true(t);
+ ir_node* f1 = get_Mux_false(t);
+ if (f == f1) {
+ /* Mux(cond0, Mux(cond1, x, y), y) => Mux(cond0 && cond1, x, y) */
+ ir_node* and_ = new_r_And(block, c0, c1, mode_b);
+ DBG_OPT_ALGSIM0(oldn, t1, FS_OPT_MUX_COMBINE);
+ return new_r_Mux(block, and_, f1, t1, mode);
+ } else if (f == t1) {
+ /* Mux(cond0, Mux(cond1, x, y), x) */
+ ir_node* not_c1 = new_r_Not(block, c1, mode_b);
+ ir_node* and_ = new_r_And(block, c0, not_c1, mode_b);
+ DBG_OPT_ALGSIM0(oldn, f1, FS_OPT_MUX_COMBINE);
+ return new_r_Mux(block, and_, t1, f1, mode);
+ }
+ } else if (is_Mux(f)) {
+ ir_node* block = get_nodes_block(n);
+ ir_node* c0 = sel;
+ ir_node* c1 = get_Mux_sel(f);
+ ir_node* t1 = get_Mux_true(f);
+ ir_node* f1 = get_Mux_false(f);
+ if (t == t1) {
+ /* Mux(cond0, x, Mux(cond1, x, y)) -> typical if (cond0 || cond1) x else y */
+ ir_node* or_ = new_r_Or(block, c0, c1, mode_b);
+ DBG_OPT_ALGSIM0(oldn, f1, FS_OPT_MUX_COMBINE);
+ return new_r_Mux(block, or_, f1, t1, mode);
+ } else if (t == f1) {
+ /* Mux(cond0, x, Mux(cond1, y, x)) */
+ ir_node* not_c1 = new_r_Not(block, c1, mode_b);
+ ir_node* or_ = new_r_Or(block, c0, not_c1, mode_b);
+ DBG_OPT_ALGSIM0(oldn, t1, FS_OPT_MUX_COMBINE);
+ return new_r_Mux(block, or_, t1, f1, mode);
+ }
}
- if (diff == get_tarval_one(mode)) {
+ /* note: after normalization, false can only happen on default */
+ if (mode == mode_b) {
dbg_info *dbg = get_irn_dbg_info(n);
ir_node *block = get_nodes_block(n);
- ir_node *t = new_Const(tarval_sub(a, min, NULL));
- ir_node *f = new_Const(tarval_sub(b, min, NULL));
- n = new_rd_Mux(dbg, block, sel, f, t, mode);
- n = new_rd_Add(dbg, block, n, new_Const(min), mode);
- return n;
+
+ if (is_Const(t)) {
+ ir_tarval *tv_t = get_Const_tarval(t);
+ if (tv_t == tarval_b_true) {
+ if (is_Const(f)) {
+ /* Muxb(sel, true, false) = sel */
+ assert(get_Const_tarval(f) == tarval_b_false);
+ DBG_OPT_ALGSIM0(oldn, sel, FS_OPT_MUX_BOOL);
+ return sel;
+ } else {
+ /* Muxb(sel, true, x) = Or(sel, x) */
+ n = new_rd_Or(dbg, block, sel, f, mode_b);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_OR_BOOL);
+ return n;
+ }
+ }
+ } else if (is_Const(f)) {
+ ir_tarval *tv_f = get_Const_tarval(f);
+ if (tv_f == tarval_b_true) {
+ /* Muxb(sel, x, true) = Or(Not(sel), x) */
+ ir_node* not_sel = new_rd_Not(dbg, block, sel, mode_b);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_ORNOT_BOOL);
+ n = new_rd_Or(dbg, block, not_sel, t, mode_b);
+ return n;
+ } else {
+ /* Muxb(sel, x, false) = And(sel, x) */
+ assert(tv_f == tarval_b_false);
+ n = new_rd_And(dbg, block, sel, t, mode_b);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_AND_BOOL);
+ return n;
+ }
+ }
}
}
- if (is_Proj(sel)) {
- ir_node *cmp = get_Proj_pred(sel);
- long pn = get_Proj_proj(sel);
-
- /*
- * Note: normalization puts the constant on the right side,
- * 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 Abs/-Abs
- * transformations.
- */
- if (is_Cmp(cmp)) {
- ir_node *cmp_r = get_Cmp_right(cmp);
- if (is_Const(cmp_r) && is_Const_null(cmp_r)) {
- ir_node *block = get_nodes_block(n);
- ir_node *cmp_l = get_Cmp_left(cmp);
+ if (is_Cmp(sel) && mode_is_int(mode) && is_cmp_equality_zero(sel)) {
+ ir_relation relation = get_Cmp_relation(sel);
+ ir_node *cmp_r = get_Cmp_right(sel);
+ ir_node *cmp_l = get_Cmp_left(sel);
+ ir_node *block = get_nodes_block(n);
- if (!mode_honor_signed_zeros(mode) && is_negated_value(f, t)) {
- /* f = -t */
+ if (is_And(cmp_l) && f == cmp_r) {
+ ir_node *and_r = get_And_right(cmp_l);
+ ir_node *and_l;
- if ( (cmp_l == t && (pn == pn_Cmp_Ge || pn == pn_Cmp_Gt))
- || (cmp_l == f && (pn == pn_Cmp_Le || pn == pn_Cmp_Lt)))
- {
- /* Mux(a >/>= 0, a, -a) = Mux(a </<= 0, -a, a) ==> Abs(a) */
- n = new_rd_Abs(get_irn_dbg_info(n), block, cmp_l, mode);
- DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_ABS);
- return n;
- } else if ((cmp_l == t && (pn == pn_Cmp_Le || pn == pn_Cmp_Lt))
- || (cmp_l == f && (pn == pn_Cmp_Ge || pn == pn_Cmp_Gt)))
- {
- /* Mux(a </<= 0, a, -a) = Mux(a >/>= 0, -a, a) ==> -Abs(a) */
- n = new_rd_Abs(get_irn_dbg_info(n), block, cmp_l, mode);
- n = new_rd_Minus(get_irn_dbg_info(n), block, n, mode);
- DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_ABS);
- return n;
- }
+ if (and_r == t && is_single_bit(and_r)) {
+ if (relation == ir_relation_equal) {
+ /* Mux((a & (1<<n)) == 0, (1<<n), 0) == (a&(1<<n)) xor ((1<<n)) */
+ 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);
+ } else {
+ /* Mux((a & (1<<n)) != 0, (1<<n), 0) == a & (1<<n) */
+ n = cmp_l;
+ DBG_OPT_ALGSIM1(oldn, sel, sel, n, FS_OPT_MUX_TO_BITOP);
}
-
- 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) */
- n = cmp_l;
- DBG_OPT_ALGSIM1(oldn, cmp, 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, cmp, 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;
- }
- }
- }
- }
+ return n;
+ }
+ and_l = get_And_left(cmp_l);
+ if (and_l == t && is_single_bit(and_l)) {
+ if (relation == ir_relation_equal) {
+ /* ((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);
+ } else {
+ /* ((1 << n) & a) != 0, (1 << n), 0) */
+ n = cmp_l;
+ 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
* of the other sync to our own inputs
*/
-static ir_node *transform_node_Sync(ir_node *n) {
+static ir_node *transform_node_Sync(ir_node *n)
+{
int arity = get_Sync_n_preds(n);
int i;
int pred_arity;
int j;
+ /* Remove Bad predecessors */
+ if (is_Bad(pred)) {
+ del_Sync_n(n, i);
+ --arity;
+ continue;
+ }
+
+ /* Remove duplicate predecessors */
+ for (j = 0; j < i; ++j) {
+ if (get_Sync_pred(n, j) == pred) {
+ del_Sync_n(n, i);
+ --arity;
+ break;
+ }
+ }
+ if (j < i)
+ continue;
+
if (!is_Sync(pred)) {
++i;
continue;
++arity;
break;
}
- if (get_Sync_pred(n, k) == pred_pred) break;
+ if (get_Sync_pred(n, k) == pred_pred)
+ break;
}
}
}
+ if (arity == 0) {
+ ir_graph *irg = get_irn_irg(n);
+ return new_r_Bad(irg, mode_M);
+ }
+ if (arity == 1) {
+ return get_Sync_pred(n, 0);
+ }
+
/* rehash the sync node */
- add_identities(current_ir_graph->value_table, n);
+ add_identities(n);
+ return n;
+}
+
+static ir_node *transform_node_Load(ir_node *n)
+{
+ /* don't touch volatile loads */
+ if (get_Load_volatility(n) == volatility_is_volatile)
+ return n;
+
+ ir_node *ptr = get_Load_ptr(n);
+ const ir_node *confirm;
+ if (value_not_zero(ptr, &confirm) && confirm == NULL) {
+ set_irn_pinned(n, op_pin_state_floats);
+ }
+
+ /* if our memory predecessor is a load from the same address, then reuse the
+ * previous result */
+ ir_node *mem = get_Load_mem(n);
+ if (!is_Proj(mem))
+ return n;
+ ir_node *mem_pred = get_Proj_pred(mem);
+ if (is_Load(mem_pred)) {
+ ir_node *pred_load = mem_pred;
+
+ /* conservatively compare the 2 loads. TODO: This could be less strict
+ * with fixup code in some situations (like smaller/bigger modes) */
+ if (get_Load_ptr(pred_load) != ptr)
+ return n;
+ if (get_Load_mode(pred_load) != get_Load_mode(n))
+ return n;
+ /* all combinations of aligned/unaligned pred/n should be fine so we do
+ * not compare the unaligned attribute */
+ {
+ ir_node *block = get_nodes_block(n);
+ ir_node *jmp = new_r_Jmp(block);
+ ir_graph *irg = get_irn_irg(n);
+ ir_node *bad = new_r_Bad(irg, mode_X);
+ ir_mode *mode = get_Load_mode(n);
+ ir_node *res = new_r_Proj(pred_load, mode, pn_Load_res);
+ ir_node *in[] = { mem, res, jmp, bad };
+ ir_node *tuple = new_r_Tuple(block, ARRAY_SIZE(in), in);
+ return tuple;
+ }
+ } else if (is_Store(mem_pred)) {
+ ir_node *pred_store = mem_pred;
+ ir_node *value = get_Store_value(pred_store);
+
+ if (get_Store_ptr(pred_store) != ptr)
+ return n;
+ if (get_irn_mode(value) != get_Load_mode(n))
+ return n;
+ /* all combinations of aligned/unaligned pred/n should be fine so we do
+ * not compare the unaligned attribute */
+ {
+ ir_node *block = get_nodes_block(n);
+ ir_node *jmp = new_r_Jmp(block);
+ ir_graph *irg = get_irn_irg(n);
+ ir_node *bad = new_r_Bad(irg, mode_X);
+ ir_node *res = value;
+ ir_node *in[] = { mem, res, jmp, bad };
+ ir_node *tuple = new_r_Tuple(block, ARRAY_SIZE(in), in);
+ return tuple;
+ }
+ }
+
+ return n;
+}
+
+static ir_node *transform_node_Store(ir_node *n)
+{
+ /* don't touch volatile stores */
+ if (get_Store_volatility(n) == volatility_is_volatile)
+ return n;
+ ir_node *ptr = get_Store_ptr(n);
+ const ir_node *confirm;
+ if (value_not_zero(ptr, &confirm) && confirm == NULL) {
+ set_irn_pinned(n, op_pin_state_floats);
+ }
return n;
-} /* transform_node_Sync */
+}
/**
* optimize a trampoline Call into a direct Call
*/
-static ir_node *transform_node_Call(ir_node *call) {
+static ir_node *transform_node_Call(ir_node *call)
+{
ir_node *callee = get_Call_ptr(call);
ir_node *adr, *mem, *res, *bl, **in;
ir_type *ctp, *mtp, *tp;
- ident *id;
+ 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))
/* build a new call type */
mtp = get_Call_type(call);
- id = get_type_ident(mtp);
- id = id_mangle(new_id_from_chars("T_", 2), id);
- db = get_type_dbg_info(mtp);
+ tdb = get_type_dbg_info(mtp);
n_res = get_method_n_ress(mtp);
n_param = get_method_n_params(mtp);
- ctp = new_d_type_method(id, n_param + 1, n_res, db);
+ ctp = new_d_type_method(n_param + 1, n_res, tdb);
for (i = 0; i < n_res; ++i)
set_method_res_type(ctp, i, get_method_res_type(mtp, i));
NEW_ARR_A(ir_node *, in, n_param + 1);
/* FIXME: we don't need a new pointer type in every step */
- tp = get_irg_frame_type(current_ir_graph);
- id = id_mangle(get_type_ident(tp), new_id_from_chars("_ptr", 4));
- tp = new_type_pointer(id, tp, mode_P_data);
+ irg = get_irn_irg(call);
+ tp = get_irg_frame_type(irg);
+ tp = new_type_pointer(tp);
set_method_param_type(ctp, 0, tp);
in[0] = get_Builtin_param(callee, 2);
}
var = get_method_variadicity(mtp);
set_method_variadicity(ctp, var);
- if (var == variadicity_variadic) {
- set_method_first_variadic_param_index(ctp, get_method_first_variadic_param_index(mtp) + 1);
- }
/* When we resolve a trampoline, the function must be called by a this-call */
set_method_calling_convention(ctp, get_method_calling_convention(mtp) | cc_this_call);
set_method_additional_properties(ctp, get_method_additional_properties(mtp));
if (get_irn_pinned(call) == op_pin_state_floats)
set_irn_pinned(res, op_pin_state_floats);
return res;
-} /* transform_node_Call */
+}
/**
* Tries several [inplace] [optimizing] transformations and returns an
* transformations _do_ generate new nodes, and thus the old node must
* not be freed even if the equivalent node isn't the old one.
*/
-static ir_node *transform_node(ir_node *n) {
- ir_node *oldn;
-
- /*
- * Transform_node is the only "optimizing transformation" that might
- * return a node with a different opcode. We iterate HERE until fixpoint
- * to get the final result.
- */
- do {
- oldn = n;
- if (n->op->ops.transform_node != NULL)
- n = n->op->ops.transform_node(n);
- } while (oldn != n);
-
- return n;
-} /* transform_node */
-
-/**
- * Sets the default transform node operation for an ir_op_ops.
- *
- * @param code the opcode for the default operation
- * @param ops the operations initialized
- *
- * @return
- * The operations.
- */
-static ir_op_ops *firm_set_default_transform_node(ir_opcode code, ir_op_ops *ops)
-{
-#define CASE(a) \
- case iro_##a: \
- ops->transform_node = transform_node_##a; \
- break
-#define CASE_PROJ(a) \
- case iro_##a: \
- ops->transform_node_Proj = transform_node_Proj_##a; \
- break
-#define CASE_PROJ_EX(a) \
- case iro_##a: \
- ops->transform_node = transform_node_##a; \
- ops->transform_node_Proj = transform_node_Proj_##a; \
- break
-
- switch (code) {
- CASE(Add);
- CASE(Sub);
- CASE(Mul);
- CASE_PROJ_EX(Div);
- CASE_PROJ_EX(Mod);
- CASE_PROJ_EX(DivMod);
- CASE(Quot);
- CASE(Abs);
- CASE_PROJ_EX(Cmp);
- CASE_PROJ_EX(Cond);
- CASE(And);
- CASE(Eor);
- CASE(Not);
- CASE(Minus);
- CASE(Cast);
- CASE_PROJ(Load);
- CASE_PROJ(Store);
- CASE_PROJ(Bound);
- CASE_PROJ(CopyB);
- CASE(Proj);
- CASE(Phi);
- CASE(Or);
- CASE(Sel);
- CASE(Shr);
- CASE(Shrs);
- CASE(Shl);
- CASE(Rotl);
- CASE(Conv);
- CASE(End);
- CASE(Mux);
- CASE(Sync);
- CASE(Call);
- default:
- /* leave NULL */;
- }
-
- return ops;
-#undef CASE_PROJ_EX
-#undef CASE_PROJ
-#undef CASE
-} /* firm_set_default_transform_node */
-
-
-/* **************** Common Subexpression Elimination **************** */
+static ir_node *transform_node(ir_node *n)
+{
+ ir_node *old_n;
+ unsigned iro;
+restart:
+ old_n = n;
+ iro = get_irn_opcode_(n);
+ /* constant expression evaluation / constant folding */
+ if (get_opt_constant_folding()) {
+ /* neither constants nor Tuple values can be evaluated */
+ if (iro != iro_Const && get_irn_mode(n) != mode_T) {
+ /* try to evaluate */
+ ir_tarval *tv = computed_value(n);
+ if (tv != tarval_bad) {
+ /* evaluation was successful -- replace the node. */
+ ir_graph *irg = get_irn_irg(n);
-/** The size of the hash table used, should estimate the number of nodes
- in a graph. */
-#define N_IR_NODES 512
+ n = new_r_Const(irg, tv);
-/** Compares the attributes of two Const nodes. */
-static int node_cmp_attr_Const(ir_node *a, ir_node *b) {
- return (get_Const_tarval(a) != get_Const_tarval(b))
- || (get_Const_type(a) != get_Const_type(b));
-} /* node_cmp_attr_Const */
-
-/** Compares the attributes of two Proj nodes. */
-static int node_cmp_attr_Proj(ir_node *a, ir_node *b) {
- return get_irn_proj_attr(a) != get_irn_proj_attr(b);
-} /* node_cmp_attr_Proj */
-
-/** Compares the attributes of two Filter nodes. */
-static int node_cmp_attr_Filter(ir_node *a, ir_node *b) {
- return get_Filter_proj(a) != get_Filter_proj(b);
-} /* node_cmp_attr_Filter */
-
-/** Compares the attributes of two Alloc nodes. */
-static int node_cmp_attr_Alloc(ir_node *a, ir_node *b) {
- const alloc_attr *pa = get_irn_alloc_attr(a);
- const alloc_attr *pb = get_irn_alloc_attr(b);
- 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) {
- const free_attr *pa = get_irn_free_attr(a);
- const free_attr *pb = get_irn_free_attr(b);
- 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) {
- const symconst_attr *pa = get_irn_symconst_attr(a);
- const symconst_attr *pb = get_irn_symconst_attr(b);
- return (pa->kind != pb->kind)
- || (pa->sym.type_p != pb->sym.type_p)
- || (pa->tp != pb->tp);
-} /* node_cmp_attr_SymConst */
-
-/** Compares the attributes of two Call nodes. */
-static int node_cmp_attr_Call(ir_node *a, ir_node *b) {
- const call_attr *pa = get_irn_call_attr(a);
- const call_attr *pb = get_irn_call_attr(b);
- 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) {
- const ir_entity *a_ent = get_Sel_entity(a);
- const ir_entity *b_ent = get_Sel_entity(b);
-#if 0
- return
- (a_ent->kind != b_ent->kind) ||
- (a_ent->name != b_ent->name) ||
- (a_ent->owner != b_ent->owner) ||
- (a_ent->ld_name != b_ent->ld_name) ||
- (a_ent->type != b_ent->type);
-#endif
- /* Matze: inlining of functions can produce 2 entities with same type,
- * name, etc. */
- 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) {
- /* we can only enter this function if both nodes have the same number of inputs,
- hence it is enough to check if one of them is a Phi0 */
- if (is_Phi0(a)) {
- /* check the Phi0 pos attribute */
- return get_irn_phi_attr(a)->u.pos != get_irn_phi_attr(b)->u.pos;
+ DBG_OPT_CSTEVAL(old_n, n);
+ return n;
+ }
+ }
}
- 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) {
- 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) {
- 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) {
- if (get_Load_volatility(a) == volatility_is_volatile ||
- get_Load_volatility(b) == volatility_is_volatile)
- /* NEVER do CSE on volatile Loads */
- return 1;
- /* do not CSE Loads with different alignment. Be conservative. */
- if (get_Load_align(a) != get_Load_align(b))
- return 1;
- return get_Load_mode(a) != get_Load_mode(b);
-} /* node_cmp_attr_Load */
+ /* remove unnecessary nodes */
+ if (get_opt_constant_folding() ||
+ (iro == iro_Phi) || /* always optimize these nodes. */
+ (iro == iro_Id) || /* ... */
+ (iro == iro_Proj) || /* ... */
+ (iro == iro_Block)) { /* Flags tested local. */
+ n = equivalent_node(n);
+ if (n != old_n)
+ goto restart;
+ }
-/** Compares the attributes of two Store nodes. */
-static int node_cmp_attr_Store(ir_node *a, ir_node *b) {
- /* do not CSE Stores with different alignment. Be conservative. */
- if (get_Store_align(a) != get_Store_align(b))
- return 1;
+ /* Some more constant expression evaluation. */
+ if (get_opt_algebraic_simplification() ||
+ (iro == iro_Cond) ||
+ (iro == iro_Proj)) { /* Flags tested local. */
+ if (n->op->ops.transform_node != NULL) {
+ n = n->op->ops.transform_node(n);
+ if (n != old_n) {
+ goto restart;
+ }
+ }
+ }
- /* 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) {
- const except_attr *ea = get_irn_except_attr(a);
- const except_attr *eb = get_irn_except_attr(b);
-
- return ea->pin_state != eb->pin_state;
-}
-
-#define node_cmp_attr_Bound node_cmp_exception
-
-/** Compares the attributes of two Div nodes. */
-static int node_cmp_attr_Div(ir_node *a, ir_node *b) {
- const divmod_attr *ma = get_irn_divmod_attr(a);
- const divmod_attr *mb = get_irn_divmod_attr(b);
- return ma->exc.pin_state != mb->exc.pin_state ||
- ma->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) {
- const divmod_attr *ma = get_irn_divmod_attr(a);
- const divmod_attr *mb = get_irn_divmod_attr(b);
- return ma->exc.pin_state != mb->exc.pin_state ||
- ma->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) {
- const divmod_attr *ma = get_irn_divmod_attr(a);
- const divmod_attr *mb = get_irn_divmod_attr(b);
- return ma->exc.pin_state != mb->exc.pin_state ||
- ma->resmode != mb->resmode;
-} /* node_cmp_attr_Mod */
-
-/** Compares the attributes of two Quot nodes. */
-static int node_cmp_attr_Quot(ir_node *a, ir_node *b) {
- const divmod_attr *ma = get_irn_divmod_attr(a);
- const divmod_attr *mb = get_irn_divmod_attr(b);
- return ma->exc.pin_state != mb->exc.pin_state ||
- ma->resmode != mb->resmode;
-} /* node_cmp_attr_Quot */
-
-/** Compares the attributes of two Confirm nodes. */
-static int node_cmp_attr_Confirm(ir_node *a, 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 */
-
-/** Compares the attributes of two Builtin nodes. */
-static int node_cmp_attr_Builtin(ir_node *a, ir_node *b) {
- const builtin_attr *ma = get_irn_builtin_attr(a);
- const builtin_attr *mb = get_irn_builtin_attr(b);
-
- /* no need to compare the type, equal kind means equal type */
- return ma->kind != mb->kind;
-} /* node_cmp_attr_Builtin */
-
-/** Compares the attributes of two ASM nodes. */
-static int node_cmp_attr_ASM(ir_node *a, ir_node *b) {
- int i, n;
- const ir_asm_constraint *ca;
- const ir_asm_constraint *cb;
- ident **cla, **clb;
-
- if (get_ASM_text(a) != get_ASM_text(b))
- return 1;
+ return n;
+}
- /* Should we really check the constraints here? Should be better, but is strange. */
- n = get_ASM_n_input_constraints(a);
- if (n != get_ASM_n_input_constraints(b))
- return 0;
+static void register_computed_value_func(ir_op *op, computed_value_func func)
+{
+ assert(op->ops.computed_value == NULL || op->ops.computed_value == func);
+ op->ops.computed_value = func;
+}
- ca = get_ASM_input_constraints(a);
- cb = get_ASM_input_constraints(b);
- for (i = 0; i < n; ++i) {
- if (ca[i].pos != cb[i].pos || ca[i].constraint != cb[i].constraint)
- return 1;
- }
+static void register_computed_value_func_proj(ir_op *op,
+ computed_value_func func)
+{
+ assert(op->ops.computed_value_Proj == NULL
+ || op->ops.computed_value_Proj == func);
+ op->ops.computed_value_Proj = func;
+}
- n = get_ASM_n_output_constraints(a);
- if (n != get_ASM_n_output_constraints(b))
- return 0;
+static void register_equivalent_node_func(ir_op *op, equivalent_node_func func)
+{
+ assert(op->ops.equivalent_node == NULL || op->ops.equivalent_node == func);
+ op->ops.equivalent_node = func;
+}
- ca = get_ASM_output_constraints(a);
- cb = get_ASM_output_constraints(b);
- for (i = 0; i < n; ++i) {
- if (ca[i].pos != cb[i].pos || ca[i].constraint != cb[i].constraint)
- return 1;
- }
+static void register_equivalent_node_func_proj(ir_op *op,
+ equivalent_node_func func)
+{
+ assert(op->ops.equivalent_node_Proj == NULL
+ || op->ops.equivalent_node_Proj == func);
+ op->ops.equivalent_node_Proj = func;
+}
- n = get_ASM_n_clobbers(a);
- if (n != get_ASM_n_clobbers(b))
- return 0;
+static void register_transform_node_func(ir_op *op, transform_node_func func)
+{
+ assert(op->ops.transform_node == NULL || op->ops.transform_node == func);
+ op->ops.transform_node = func;
+}
- cla = get_ASM_clobbers(a);
- clb = get_ASM_clobbers(b);
- for (i = 0; i < n; ++i) {
- if (cla[i] != clb[i])
- return 1;
- }
- return 0;
-} /* node_cmp_attr_ASM */
+static void register_transform_node_func_proj(ir_op *op,
+ transform_node_func func)
+{
+ assert(op->ops.transform_node_Proj == NULL
+ || op->ops.transform_node_Proj == func);
+ op->ops.transform_node_Proj = func;
+}
-/** Compares the inexistent attributes of two Dummy nodes. */
-static int node_cmp_attr_Dummy(ir_node *a, ir_node *b)
+void ir_register_opt_node_ops(void)
{
- (void) a;
- (void) b;
- return 1;
+ register_computed_value_func(op_Add, computed_value_Add);
+ register_computed_value_func(op_And, computed_value_And);
+ register_computed_value_func(op_Borrow, computed_value_Borrow);
+ register_computed_value_func(op_Carry, computed_value_Carry);
+ register_computed_value_func(op_Cmp, computed_value_Cmp);
+ register_computed_value_func(op_Confirm, computed_value_Confirm);
+ register_computed_value_func(op_Const, computed_value_Const);
+ register_computed_value_func(op_Conv, computed_value_Conv);
+ register_computed_value_func(op_Eor, computed_value_Eor);
+ register_computed_value_func(op_Minus, computed_value_Minus);
+ register_computed_value_func(op_Mul, computed_value_Mul);
+ register_computed_value_func(op_Mux, computed_value_Mux);
+ register_computed_value_func(op_Not, computed_value_Not);
+ register_computed_value_func(op_Or, computed_value_Or);
+ register_computed_value_func(op_Proj, computed_value_Proj);
+ register_computed_value_func(op_Rotl, computed_value_Rotl);
+ register_computed_value_func(op_Shl, computed_value_Shl);
+ register_computed_value_func(op_Shr, computed_value_Shr);
+ register_computed_value_func(op_Shrs, computed_value_Shrs);
+ register_computed_value_func(op_Sub, computed_value_Sub);
+ register_computed_value_func(op_SymConst, computed_value_SymConst);
+ register_computed_value_func_proj(op_Div, computed_value_Proj_Div);
+ register_computed_value_func_proj(op_Mod, computed_value_Proj_Mod);
+
+ register_equivalent_node_func(op_Add, equivalent_node_Add);
+ register_equivalent_node_func(op_And, equivalent_node_And);
+ register_equivalent_node_func(op_Confirm, equivalent_node_Confirm);
+ register_equivalent_node_func(op_Conv, equivalent_node_Conv);
+ register_equivalent_node_func(op_Eor, equivalent_node_Eor);
+ register_equivalent_node_func(op_Id, equivalent_node_Id);
+ register_equivalent_node_func(op_Minus, equivalent_node_involution);
+ register_equivalent_node_func(op_Mul, equivalent_node_Mul);
+ register_equivalent_node_func(op_Mux, equivalent_node_Mux);
+ register_equivalent_node_func(op_Not, equivalent_node_involution);
+ register_equivalent_node_func(op_Or, equivalent_node_Or);
+ register_equivalent_node_func(op_Phi, equivalent_node_Phi);
+ register_equivalent_node_func(op_Proj, equivalent_node_Proj);
+ register_equivalent_node_func(op_Rotl, equivalent_node_left_zero);
+ register_equivalent_node_func(op_Shl, equivalent_node_left_zero);
+ register_equivalent_node_func(op_Shr, equivalent_node_left_zero);
+ register_equivalent_node_func(op_Shrs, equivalent_node_left_zero);
+ register_equivalent_node_func(op_Sub, equivalent_node_Sub);
+ register_equivalent_node_func_proj(op_Bound, equivalent_node_Proj_Bound);
+ register_equivalent_node_func_proj(op_CopyB, equivalent_node_Proj_CopyB);
+ register_equivalent_node_func_proj(op_Div, equivalent_node_Proj_Div);
+ register_equivalent_node_func_proj(op_Tuple, equivalent_node_Proj_Tuple);
+
+ register_transform_node_func(op_Add, transform_node_Add);
+ register_transform_node_func(op_And, transform_node_And);
+ register_transform_node_func(op_Block, transform_node_Block);
+ register_transform_node_func(op_Call, transform_node_Call);
+ register_transform_node_func(op_Cmp, transform_node_Cmp);
+ register_transform_node_func(op_Cond, transform_node_Cond);
+ register_transform_node_func(op_Conv, transform_node_Conv);
+ register_transform_node_func(op_Div, transform_node_Div);
+ register_transform_node_func(op_End, transform_node_End);
+ register_transform_node_func(op_Eor, transform_node_Eor);
+ register_transform_node_func(op_Load, transform_node_Load);
+ register_transform_node_func(op_Minus, transform_node_Minus);
+ register_transform_node_func(op_Mod, transform_node_Mod);
+ register_transform_node_func(op_Mul, transform_node_Mul);
+ register_transform_node_func(op_Mux, transform_node_Mux);
+ register_transform_node_func(op_Not, transform_node_Not);
+ register_transform_node_func(op_Or, transform_node_Or);
+ register_transform_node_func(op_Phi, transform_node_Phi);
+ register_transform_node_func(op_Proj, transform_node_Proj);
+ register_transform_node_func(op_Rotl, transform_node_Rotl);
+ register_transform_node_func(op_Shl, transform_node_Shl);
+ register_transform_node_func(op_Shrs, transform_node_Shrs);
+ register_transform_node_func(op_Shr, transform_node_Shr);
+ register_transform_node_func(op_Store, transform_node_Store);
+ register_transform_node_func(op_Sub, transform_node_Sub);
+ register_transform_node_func(op_Switch, transform_node_Switch);
+ register_transform_node_func(op_Sync, transform_node_Sync);
+ register_transform_node_func_proj(op_Bound, transform_node_Proj_Bound);
+ register_transform_node_func_proj(op_CopyB, transform_node_Proj_CopyB);
+ register_transform_node_func_proj(op_Div, transform_node_Proj_Div);
+ register_transform_node_func_proj(op_Load, transform_node_Proj_Load);
+ register_transform_node_func_proj(op_Mod, transform_node_Proj_Mod);
+ register_transform_node_func_proj(op_Store, transform_node_Proj_Store);
}
-/**
- * Set the default node attribute compare operation for an ir_op_ops.
- *
- * @param code the opcode for the default operation
- * @param ops the operations initialized
- *
- * @return
- * The operations.
- */
-static ir_op_ops *firm_set_default_node_cmp_attr(ir_opcode code, ir_op_ops *ops)
-{
-#define CASE(a) \
- case iro_##a: \
- ops->node_cmp_attr = node_cmp_attr_##a; \
- break
-
- switch (code) {
- CASE(Const);
- CASE(Proj);
- CASE(Filter);
- CASE(Alloc);
- CASE(Free);
- CASE(SymConst);
- CASE(Call);
- CASE(Sel);
- CASE(Phi);
- CASE(Conv);
- CASE(Cast);
- CASE(Load);
- CASE(Store);
- CASE(Confirm);
- CASE(ASM);
- CASE(Div);
- CASE(DivMod);
- CASE(Mod);
- CASE(Quot);
- CASE(Bound);
- CASE(Builtin);
- CASE(Dummy);
- /* FIXME CopyB */
- default:
- /* leave NULL */;
- }
+/* **************** Common Subexpression Elimination **************** */
- return ops;
-#undef CASE
-} /* firm_set_default_node_cmp_attr */
+/** The size of the hash table used, should estimate the number of nodes
+ in a graph. */
+#define N_IR_NODES 512
-/*
- * Compare function for two nodes in the value table. Gets two
- * nodes as parameters. Returns 0 if the nodes are a Common Sub Expression.
- */
-int identities_cmp(const void *elt, const void *key) {
+int identities_cmp(const void *elt, const void *key)
+{
ir_node *a = (ir_node *)elt;
ir_node *b = (ir_node *)key;
int i, irn_arity_a;
(get_irn_mode(a) != get_irn_mode(b))) return 1;
/* compare if a's in and b's in are of equal length */
- irn_arity_a = get_irn_intra_arity(a);
- if (irn_arity_a != get_irn_intra_arity(b))
+ irn_arity_a = get_irn_arity(a);
+ if (irn_arity_a != get_irn_arity(b))
+ return 1;
+
+ /* blocks are never the same */
+ if (is_Block(a))
return 1;
if (get_irn_pinned(a) == op_pin_state_pinned) {
/* for pinned nodes, the block inputs must be equal */
- if (get_irn_intra_n(a, -1) != get_irn_intra_n(b, -1))
- return 1;
- } else if (! get_opt_global_cse()) {
- /* for block-local CSE both nodes must be in the same MacroBlock */
- if (get_irn_MacroBlock(a) != get_irn_MacroBlock(b))
+ if (get_nodes_block(a) != get_nodes_block(b))
return 1;
+ } else {
+ ir_node *block_a = get_nodes_block(a);
+ ir_node *block_b = get_nodes_block(b);
+ if (! get_opt_global_cse()) {
+ /* for block-local CSE both nodes must be in the same Block */
+ if (block_a != block_b)
+ return 1;
+ } else {
+ /* The optimistic approach would be to do nothing here.
+ * However doing GCSE optimistically produces a lot of partially dead code which appears
+ * to be worse in practice than the missed opportunities.
+ * So we use a very conservative variant here and only CSE if 1 value dominates the
+ * other. */
+ if (!block_dominates(block_a, block_b)
+ && !block_dominates(block_b, block_a))
+ return 1;
+ /* respect the workaround rule: do not move nodes which are only
+ * held by keepalive edges */
+ if (only_used_by_keepalive(a) || only_used_by_keepalive(b))
+ return 1;
+ }
}
/* compare a->in[0..ins] with b->in[0..ins] */
- for (i = 0; i < irn_arity_a; i++)
- if (get_irn_intra_n(a, i) != get_irn_intra_n(b, i))
- return 1;
+ for (i = 0; i < irn_arity_a; ++i) {
+ ir_node *pred_a = get_irn_n(a, i);
+ ir_node *pred_b = get_irn_n(b, i);
+ if (pred_a != pred_b) {
+ /* if both predecessors are CSE neutral they might be different */
+ if (!is_irn_cse_neutral(pred_a) || !is_irn_cse_neutral(pred_b))
+ return 1;
+ }
+ }
/*
* here, we already now that the nodes are identical except their
return a->op->ops.node_cmp_attr(a, b);
return 0;
-} /* identities_cmp */
+}
-/*
- * Calculate a hash value of a node.
- *
- * @param node The IR-node
- */
-unsigned ir_node_hash(const ir_node *node) {
+unsigned ir_node_hash(const ir_node *node)
+{
return node->op->ops.hash(node);
-} /* ir_node_hash */
+}
+void new_identities(ir_graph *irg)
+{
+ if (irg->value_table != NULL)
+ del_pset(irg->value_table);
+ irg->value_table = new_pset(identities_cmp, N_IR_NODES);
+}
-pset *new_identities(void) {
- return new_pset(identities_cmp, N_IR_NODES);
-} /* new_identities */
+void del_identities(ir_graph *irg)
+{
+ if (irg->value_table != NULL)
+ del_pset(irg->value_table);
+}
-void del_identities(pset *value_table) {
- del_pset(value_table);
-} /* del_identities */
+static int cmp_node_nr(const void *a, const void *b)
+{
+ ir_node **p1 = (ir_node**)a;
+ ir_node **p2 = (ir_node**)b;
+ long n1 = get_irn_node_nr(*p1);
+ long n2 = get_irn_node_nr(*p2);
+ return (n1>n2) - (n1<n2);
+}
-/* Normalize a node by putting constants (and operands with larger
- * node index) on the right (operator side). */
-void ir_normalize_node(ir_node *n) {
+void ir_normalize_node(ir_node *n)
+{
if (is_op_commutative(get_irn_op(n))) {
ir_node *l = get_binop_left(n);
ir_node *r = get_binop_right(n);
set_binop_right(n, l);
hook_normalize(n);
}
- }
-} /* ir_normalize_node */
-
-/**
- * Update the nodes after a match in the value table. If both nodes have
- * the same MacroBlock but different Blocks, we must ensure that the node
- * with the dominating Block (the node that is near to the MacroBlock header
- * is stored in the table.
- * Because a MacroBlock has only one "non-exception" flow, we don't need
- * dominance info here: We known, that one block must dominate the other and
- * following the only block input will allow to find it.
- */
-static void update_known_irn(ir_node *known_irn, const ir_node *new_ir_node) {
- ir_node *known_blk, *new_block, *block, *mbh;
-
- if (get_opt_global_cse()) {
- /* Block inputs are meaning less */
- return;
- }
- known_blk = get_irn_n(known_irn, -1);
- new_block = get_irn_n(new_ir_node, -1);
- if (known_blk == new_block) {
- /* already in the same block */
- return;
- }
- /*
- * We expect the typical case when we built the graph. In that case, the
- * known_irn is already the upper one, so checking this should be faster.
- */
- block = new_block;
- mbh = get_Block_MacroBlock(new_block);
- for (;;) {
- if (block == known_blk) {
- /* ok, we have found it: known_block dominates new_block as expected */
- return;
+ } else if (is_Sync(n)) {
+ /* we assume that most of the time the inputs of a Sync node are already
+ * sorted, so check this first as a shortcut */
+ bool ins_sorted = true;
+ int arity = get_irn_arity(n);
+ const ir_node *last = get_irn_n(n, 0);
+ int i;
+ for (i = 1; i < arity; ++i) {
+ const ir_node *node = get_irn_n(n, i);
+ if (get_irn_node_nr(node) < get_irn_node_nr(last)) {
+ ins_sorted = false;
+ break;
+ }
+ last = node;
}
- if (block == mbh) {
- /*
- * We have reached the MacroBlock header NOT founding
- * the known_block. new_block must dominate known_block.
- * Update known_irn.
- */
- set_irn_n(known_irn, -1, new_block);
- return;
+
+ if (!ins_sorted) {
+ ir_node **ins = get_irn_in(n)+1;
+ ir_node **new_ins = XMALLOCN(ir_node*, arity);
+ memcpy(new_ins, ins, arity*sizeof(ins[0]));
+ qsort(new_ins, arity, sizeof(new_ins[0]), cmp_node_nr);
+ set_irn_in(n, arity, new_ins);
+ xfree(new_ins);
}
- assert(get_Block_n_cfgpreds(block) == 1);
- block = get_Block_cfgpred_block(block, 0);
}
-} /* update_value_table */
+}
-/*
- * Return the canonical node computing the same value as n.
- * Looks up the node in a hash table, enters it in the table
- * if it isn't there yet.
- *
- * @param value_table the HashSet containing all nodes in the
- * current IR graph
- * @param n the node to look up
- *
- * @return a node that computes the same value as n or n if no such
- * node could be found
- */
-ir_node *identify_remember(pset *value_table, ir_node *n) {
- ir_node *o = NULL;
+ir_node *identify_remember(ir_node *n)
+{
+ ir_graph *irg = get_irn_irg(n);
+ pset *value_table = irg->value_table;
+ ir_node *nn;
- if (!value_table) return n;
+ if (value_table == NULL)
+ return n;
ir_normalize_node(n);
/* lookup or insert in hash table with given hash key. */
- o = pset_insert(value_table, n, ir_node_hash(n));
+ nn = (ir_node*)pset_insert(value_table, n, ir_node_hash(n));
- if (o != n) {
- update_known_irn(o, n);
+ if (nn != n) {
+ /* n is reachable again */
+ edges_node_revival(nn);
}
- return o;
-} /* identify_remember */
+ return nn;
+}
/**
- * During construction we set the op_pin_state_pinned flag in the graph right when the
- * optimization is performed. The flag turning on procedure global cse could
- * be changed between two allocations. This way we are safe.
+ * During construction we set the op_pin_state_pinned flag in the graph right
+ * when the optimization is performed. The flag turning on procedure global
+ * cse could be changed between two allocations. This way we are safe.
*
- * @param value_table The value table
* @param n The node to lookup
*/
-static inline ir_node *identify_cons(pset *value_table, ir_node *n) {
+static inline ir_node *identify_cons(ir_node *n)
+{
ir_node *old = n;
- n = identify_remember(value_table, n);
- if (n != old && get_irn_MacroBlock(old) != get_irn_MacroBlock(n))
- set_irg_pinned(current_ir_graph, op_pin_state_floats);
+ n = identify_remember(n);
+ if (n != old && get_nodes_block(old) != get_nodes_block(n)) {
+ ir_graph *irg = get_irn_irg(n);
+ set_irg_pinned(irg, op_pin_state_floats);
+ }
return n;
-} /* identify_cons */
+}
+
+void add_identities(ir_node *node)
+{
+ if (!get_opt_cse())
+ return;
+ if (is_Block(node))
+ return;
-/* Add a node to the identities value table. */
-void add_identities(pset *value_table, ir_node *node) {
- if (get_opt_cse() && is_no_Block(node))
- identify_remember(value_table, node);
-} /* add_identities */
+ identify_remember(node);
+}
-/* Visit each node in the value table of a graph. */
-void visit_all_identities(ir_graph *irg, irg_walk_func visit, void *env) {
- ir_node *node;
+void visit_all_identities(ir_graph *irg, irg_walk_func visit, void *env)
+{
ir_graph *rem = current_ir_graph;
current_ir_graph = irg;
- foreach_pset(irg->value_table, node)
+ foreach_pset(irg->value_table, ir_node, node) {
visit(node, env);
- current_ir_graph = rem;
-} /* visit_all_identities */
-
-/**
- * Garbage in, garbage out. If a node has a dead input, i.e., the
- * Bad node is input to the node, return the Bad node.
- */
-static ir_node *gigo(ir_node *node) {
- int i, irn_arity;
- ir_op *op = get_irn_op(node);
-
- /* remove garbage blocks by looking at control flow that leaves the block
- and replacing the control flow by Bad. */
- if (get_irn_mode(node) == mode_X) {
- ir_node *block = get_nodes_block(skip_Proj(node));
-
- /* Don't optimize nodes in immature blocks. */
- if (!get_Block_matured(block))
- return node;
- /* Don't optimize End, may have Bads. */
- if (op == op_End) return node;
-
- if (is_Block(block)) {
- if (is_Block_dead(block)) {
- /* control flow from dead block is dead */
- return new_Bad();
- }
-
- for (i = get_irn_arity(block) - 1; i >= 0; --i) {
- if (!is_Bad(get_irn_n(block, i)))
- break;
- }
- if (i < 0) {
- ir_graph *irg = get_irn_irg(block);
- /* the start block is never dead */
- if (block != get_irg_start_block(irg)
- && block != get_irg_end_block(irg)) {
- /*
- * Do NOT kill control flow without setting
- * the block to dead of bad things can happen:
- * We get a Block that is not reachable be irg_block_walk()
- * but can be found by irg_walk()!
- */
- set_Block_dead(block);
- return new_Bad();
- }
- }
- }
- }
-
- /* Blocks, Phis and Tuples may have dead inputs, e.g., if one of the
- blocks predecessors is dead. */
- if (op != op_Block && op != op_Phi && op != op_Tuple) {
- irn_arity = get_irn_arity(node);
-
- /*
- * Beware: we can only read the block of a non-floating node.
- */
- if (is_irn_pinned_in_irg(node) &&
- is_Block_dead(get_nodes_block(skip_Proj(node))))
- return new_Bad();
-
- for (i = 0; i < irn_arity; i++) {
- ir_node *pred = get_irn_n(node, i);
-
- if (is_Bad(pred))
- return new_Bad();
-#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.
- 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)))
- return new_Unknown(get_irn_mode(node));
-#endif
- }
- }
-#if 0
- /* With this code we violate the agreement that local_optimize
- only leaves Bads in Block, Phi and Tuple nodes. */
- /* If Block has only Bads as predecessors it's garbage. */
- /* If Phi has only Bads as predecessors it's garbage. */
- if ((op == op_Block && get_Block_matured(node)) || op == op_Phi) {
- irn_arity = get_irn_arity(node);
- for (i = 0; i < irn_arity; i++) {
- if (!is_Bad(get_irn_n(node, i))) break;
- }
- if (i == irn_arity) node = new_Bad();
}
-#endif
- return node;
-} /* gigo */
+ current_ir_graph = rem;
+}
-/**
- * These optimizations deallocate nodes from the obstack.
- * It can only be called if it is guaranteed that no other nodes
- * reference this one, i.e., right after construction of a node.
- *
- * @param n The node to optimize
- *
- * current_ir_graph must be set to the graph of the node!
- */
-ir_node *optimize_node(ir_node *n) {
- tarval *tv;
- ir_node *oldn = n;
- ir_opcode iro = get_irn_opcode(n);
+ir_node *optimize_node(ir_node *n)
+{
+ ir_node *oldn = n;
+ ir_graph *irg = get_irn_irg(n);
+ unsigned iro = get_irn_opcode(n);
+ ir_tarval *tv;
/* Always optimize Phi nodes: part of the construction. */
if ((!get_opt_optimize()) && (iro != iro_Phi)) return n;
if (get_opt_constant_folding()) {
/* neither constants nor Tuple values can be evaluated */
if (iro != iro_Const && (get_irn_mode(n) != mode_T)) {
- unsigned fp_model = get_irg_fp_model(current_ir_graph);
- int old_fp_mode = tarval_fp_ops_enabled();
-
- tarval_enable_fp_ops(! (fp_model & fp_no_float_fold));
-
/* try to evaluate */
tv = computed_value(n);
if (tv != tarval_bad) {
ir_node *nw;
- ir_type *old_tp = get_irn_type(n);
- int i, arity = get_irn_arity(n);
- int node_size;
+ size_t node_size;
/*
- * Try to recover the type of the new expression.
- */
- for (i = 0; i < arity && !old_tp; ++i)
- old_tp = get_irn_type(get_irn_n(n, i));
-
- /*
- * we MUST copy the node here temporary, because it's still needed
- * for DBG_OPT_CSTEVAL
+ * 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;
- oldn = alloca(node_size);
+ oldn = (ir_node*)alloca(node_size);
memcpy(oldn, n, node_size);
CLONE_ARR_A(ir_node *, oldn->in, n->in);
memcpy(oldn->in, n->in, ARR_LEN(n->in) * sizeof(n->in[0]));
/* note the inplace edges module */
- edges_node_deleted(n, current_ir_graph);
+ edges_node_deleted(n);
/* evaluation was successful -- replace the node. */
- irg_kill_node(current_ir_graph, n);
- nw = new_Const(tv);
+ irg_kill_node(irg, n);
+ nw = new_r_Const(irg, tv);
- if (old_tp && get_type_mode(old_tp) == get_tarval_mode(tv))
- set_Const_type(nw, old_tp);
DBG_OPT_CSTEVAL(oldn, nw);
- tarval_enable_fp_ops(old_fp_mode);
return nw;
}
- tarval_enable_fp_ops(old_fp_mode);
}
}
* subexpressions within a block.
*/
if (get_opt_cse())
- n = identify_cons(current_ir_graph->value_table, n);
+ n = identify_cons(n);
if (n != oldn) {
- edges_node_deleted(oldn, current_ir_graph);
+ edges_node_deleted(oldn);
/* We found an existing, better node, so we can deallocate the old node. */
- irg_kill_node(current_ir_graph, oldn);
+ irg_kill_node(irg, oldn);
return n;
}
free the node. */
iro = get_irn_opcode(n);
if (get_opt_algebraic_simplification() ||
- (iro == iro_Cond) ||
- (iro == iro_Proj)) /* Flags tested local. */
+ (iro == iro_Cond) ||
+ (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)) {
+ if (get_opt_cse()) {
ir_node *o = n;
- n = identify_remember(current_ir_graph->value_table, o);
+ n = identify_remember(o);
if (o != n)
DBG_OPT_CSE(o, n);
}
return n;
-} /* optimize_node */
-
-
-/**
- * These optimizations never deallocate nodes (in place). This can cause dead
- * nodes lying on the obstack. Remove these by a dead node elimination,
- * i.e., a copying garbage collection.
- */
-ir_node *optimize_in_place_2(ir_node *n) {
- tarval *tv;
- ir_node *oldn = n;
- ir_opcode iro = get_irn_opcode(n);
+}
+ir_node *optimize_in_place_2(ir_node *n)
+{
if (!get_opt_optimize() && !is_Phi(n)) return n;
- /* constant expression evaluation / constant folding */
- if (get_opt_constant_folding()) {
- /* neither constants nor Tuple values can be evaluated */
- if (iro != iro_Const && get_irn_mode(n) != mode_T) {
- unsigned fp_model = get_irg_fp_model(current_ir_graph);
- int old_fp_mode = tarval_fp_ops_enabled();
-
- tarval_enable_fp_ops((fp_model & fp_strict_algebraic) == 0);
- /* try to evaluate */
- tv = computed_value(n);
- if (tv != tarval_bad) {
- /* evaluation was successful -- replace the node. */
- ir_type *old_tp = get_irn_type(n);
- int i, arity = get_irn_arity(n);
-
- /*
- * Try to recover the type of the new expression.
- */
- for (i = 0; i < arity && !old_tp; ++i)
- old_tp = get_irn_type(get_irn_n(n, i));
-
- n = new_Const(tv);
-
- if (old_tp && get_type_mode(old_tp) == get_tarval_mode(tv))
- set_Const_type(n, old_tp);
-
- DBG_OPT_CSTEVAL(oldn, n);
- tarval_enable_fp_ops(old_fp_mode);
- return n;
- }
- tarval_enable_fp_ops(old_fp_mode);
- }
- }
-
- /* remove unnecessary nodes */
- if (get_opt_constant_folding() ||
- (iro == iro_Phi) || /* always optimize these nodes. */
- (iro == iro_Id) || /* ... */
- (iro == iro_Proj) || /* ... */
- (iro == iro_Block) ) /* Flags tested local. */
- n = equivalent_node(n);
+ if (is_Deleted(n))
+ return n;
/** common subexpression elimination **/
/* Checks whether n is already available. */
- /* The block input is used to distinguish different subexpressions. Right
- now all nodes are op_pin_state_pinned to blocks, i.e., the cse only finds common
- subexpressions within a block. */
+ /* The block input is used to distinguish different subexpressions.
+ * Right now all nodes are op_pin_state_pinned to blocks, i.e., the cse
+ * only finds common subexpressions within a block. */
if (get_opt_cse()) {
ir_node *o = n;
- n = identify_remember(current_ir_graph->value_table, o);
- if (o != n)
+ n = identify_remember(n);
+ if (n != o) {
DBG_OPT_CSE(o, n);
+ /* we have another existing node now, we do not optimize it here */
+ return n;
+ }
}
- /* Some more constant expression evaluation. */
- iro = get_irn_opcode(n);
- if (get_opt_constant_folding() ||
- (iro == iro_Cond) ||
- (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);
+ n = transform_node(n);
/* Now we can verify the node, as it has no dead inputs any more. */
- irn_vrfy(n);
+ irn_verify(n);
/* Now we have a legal, useful node. Enter it in hash table for cse.
- Blocks should be unique anyways. (Except the successor of start:
- is cse with the start block!) */
- if (get_opt_cse() && (get_irn_opcode(n) != iro_Block)) {
+ *
+ * Note: This is only necessary because some of the optimisations
+ * operate in-place (set_XXX_bla, turn_into_tuple, ...) which is considered
+ * bad practice and should be fixed sometime.
+ */
+ if (get_opt_cse()) {
ir_node *o = n;
- n = identify_remember(current_ir_graph->value_table, o);
+ n = identify_remember(o);
if (o != n)
DBG_OPT_CSE(o, n);
}
return n;
-} /* optimize_in_place_2 */
+}
-/**
- * Wrapper for external use, set proper status bits after optimization.
- */
-ir_node *optimize_in_place(ir_node *n) {
- /* Handle graph state */
- assert(get_irg_phase_state(current_ir_graph) != phase_building);
+ir_node *optimize_in_place(ir_node *n)
+{
+ ir_graph *irg = get_irn_irg(n);
if (get_opt_global_cse())
- set_irg_pinned(current_ir_graph, op_pin_state_floats);
- if (get_irg_outs_state(current_ir_graph) == outs_consistent)
- set_irg_outs_inconsistent(current_ir_graph);
+ set_irg_pinned(irg, op_pin_state_floats);
/* FIXME: Maybe we could also test whether optimizing the node can
change the control graph. */
- set_irg_doms_inconsistent(current_ir_graph);
+ clear_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE);
return optimize_in_place_2(n);
-} /* optimize_in_place */
-
-/**
- * Calculate a hash value of a Const node.
- */
-static unsigned hash_Const(const ir_node *node) {
- unsigned h;
-
- /* special value for const, as they only differ in their tarval. */
- h = HASH_PTR(node->attr.con.tv);
-
- return h;
-} /* hash_Const */
-
-/**
- * Calculate a hash value of a SymConst node.
- */
-static unsigned hash_SymConst(const ir_node *node) {
- unsigned h;
-
- /* all others are pointers */
- h = HASH_PTR(node->attr.symc.sym.type_p);
-
- return h;
-} /* hash_SymConst */
-
-/**
- * Set the default hash operation in an ir_op_ops.
- *
- * @param code the opcode for the default operation
- * @param ops the operations initialized
- *
- * @return
- * The operations.
- */
-static ir_op_ops *firm_set_default_hash(ir_opcode code, ir_op_ops *ops)
-{
-#define CASE(a) \
- case iro_##a: \
- ops->hash = hash_##a; \
- break
-
- /* hash function already set */
- if (ops->hash != NULL)
- return ops;
-
- switch (code) {
- CASE(Const);
- CASE(SymConst);
- default:
- /* use input/mode default hash if no function was given */
- ops->hash = firm_default_hash;
- }
-
- return ops;
-#undef CASE
}
-
-/*
- * Sets the default operation for an ir_ops.
- */
-ir_op_ops *firm_set_default_operations(ir_opcode code, ir_op_ops *ops) {
- ops = firm_set_default_hash(code, ops);
- ops = firm_set_default_computed_value(code, ops);
- ops = firm_set_default_equivalent_node(code, ops);
- ops = firm_set_default_transform_node(code, ops);
- ops = firm_set_default_node_cmp_attr(code, ops);
- ops = firm_set_default_get_type(code, ops);
- ops = firm_set_default_get_type_attr(code, ops);
- ops = firm_set_default_get_entity_attr(code, ops);
-
- return ops;
-} /* firm_set_default_operations */