* @file
* @brief iropt --- optimizations intertwined with IR construction.
* @author Christian Schaefer, Goetz Lindenmaier, Michael Beck
- * @version $Id$
*/
#include "config.h"
#include "irhooks.h"
#include "irarch.h"
#include "hashptr.h"
-#include "opt_polymorphy.h"
#include "irtools.h"
#include "irhooks.h"
#include "array_t.h"
#include "firm_types.h"
#include "bitfiddle.h"
#include "be.h"
+#include "error.h"
+#include "firmstat_t.h"
-/* Make types visible to allow most efficient access */
#include "entity_t.h"
static bool is_Or_Eor_Add(const ir_node *node)
value_of_func value_of_ptr = default_value_of;
-/* * Set a new value_of function. */
void set_value_of_func(value_of_func func)
{
if (func != NULL)
/* 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;
}
return computed_value_Cmp_Confirm(cmp, left, right, relation);
}
+/**
+ * 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 Cmp.
*
static ir_tarval *computed_value_Cmp(const ir_node *cmp)
{
/* we can't construct Constb after lowering mode_b nodes */
- if (is_irg_state(get_irn_irg(cmp), IR_GRAPH_STATE_MODEB_LOWERED))
+ if (irg_is_constrained(get_irn_irg(cmp), IR_GRAPH_CONSTRAINT_MODEB_LOWERED))
return tarval_bad;
return compute_cmp(cmp);
return tarval_bad;
}
-/**
- * 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(Add);
- CASE(And);
- CASE(Borrow);
- CASE(Carry);
- CASE(Cmp);
- CASE(Confirm);
- CASE(Const);
- CASE(Conv);
- CASE(Eor);
- CASE(Minus);
- CASE(Mul);
- CASE(Mux);
- CASE(Not);
- CASE(Or);
- CASE(Proj);
- CASE(Rotl);
- CASE(Shl);
- CASE(Shr);
- CASE(Shrs);
- CASE(Sub);
- CASE(SymConst);
- CASE_PROJ(Div);
- CASE_PROJ(Mod);
- default:
- /* leave NULL */
- break;
- }
-
- return ops;
-#undef CASE_PROJ
-#undef CASE
-}
-
/**
* Optimize operations that are commutative and have neutral 0,
* so a op 0 = 0 op a = a.
return n;
}
-#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).
*
* 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;
}
-/** 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.
*/
/* 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 *and = tarval_and(conv, tv);
+ ir_tarval *tand = tarval_and(conv, tv);
- if (tarval_is_all_one(and)) {
+ if (tarval_is_all_one(tand)) {
/* Conv(X) & Const = X */
n = a;
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_AND);
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 Confirm change the precision,
- so we can "look-through" */
- for (;;) {
- if (is_Minus(p)) {
- p = get_Minus_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
- 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;
ir_node *first_val = NULL; /* to shutup gcc */
if (!get_opt_optimize() &&
- get_irg_phase_state(get_irn_irg(n)) != phase_building)
+ !irg_is_constrained(get_irn_irg(n), IR_GRAPH_CONSTRAINT_CONSTRUCTION))
return n;
n_preds = get_Phi_n_preds(n);
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(sel);
+ ts = compute_cmp_ext(sel);
}
/* Mux(true, f, t) == t */
return n;
}
-/**
- * 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(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(Phi);
- CASE_PROJ(Tuple);
- CASE_PROJ(Div);
- CASE_PROJ(CopyB);
- CASE_PROJ(Bound);
- CASE(Proj);
- CASE(Id);
- CASE(Mux);
- CASE(Confirm);
- default:
- /* leave NULL */
- break;
- }
-
- return ops;
-#undef CASE
-#undef CASE_PROJ
-}
-
/**
* Returns non-zero if a node is a Phi node
* with all predecessors constant.
*/
static ir_node *apply_binop_on_phi(ir_node *phi, ir_tarval *other, eval_func eval, ir_mode *mode, int left)
{
- ir_tarval *tv;
- void **res;
- ir_node *pred;
- ir_graph *irg;
- int i, n = get_irn_arity(phi);
-
- NEW_ARR_A(void *, res, n);
+ 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 = get_irn_irg(phi);
- for (i = 0; i < n; ++i) {
- pred = get_irn_n(phi, i);
- res[i] = new_r_Const(irg, (ir_tarval*)res[i]);
+ 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);
+ ir_node *block = get_nodes_block(phi);
+ return new_r_Phi(block, n, res, mode);
}
/**
*/
static ir_node *apply_binop_on_2_phis(ir_node *a, ir_node *b, eval_func eval, ir_mode *mode)
{
- ir_tarval *tv_l, *tv_r, *tv;
- void **res;
- ir_node *pred;
- ir_graph *irg;
- int i, n;
-
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 = get_irn_irg(a);
- for (i = 0; i < n; ++i) {
- pred = get_irn_n(a, i);
- res[i] = new_r_Const(irg, (ir_tarval*)res[i]);
+ 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);
+ ir_node *block = get_nodes_block(a);
+ return new_r_Phi(block, n, res, mode);
}
/**
*/
static ir_node *apply_unop_on_phi(ir_node *phi, ir_tarval *(*eval)(ir_tarval *))
{
- ir_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);
+ 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 = get_irn_irg(phi);
- for (i = 0; i < n; ++i) {
- pred = get_irn_n(phi, i);
- res[i] = new_r_Const(irg, (ir_tarval*)res[i]);
+ 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);
+ ir_node *block = get_nodes_block(phi);
+ ir_mode *mode = get_irn_mode(phi);
+ return new_r_Phi(block, n, res, mode);
}
/**
*/
static ir_node *apply_conv_on_phi(ir_node *phi, ir_mode *mode)
{
- ir_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);
+ 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 = get_irn_irg(phi);
- for (i = 0; i < n; ++i) {
- pred = get_irn_n(phi, i);
- res[i] = new_r_Const(irg, (ir_tarval*)res[i]);
+ 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);
+ ir_node *block = get_nodes_block(phi);
+ return new_r_Phi(block, n, res, mode);
}
/**
}
/* ok, all conditions met */
- block = get_irn_n(irn_or, -1);
+ 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);
ir_tarval *tv2;
ir_tarval *tv_bitop;
- if (!is_irg_state(irg, IR_GRAPH_STATE_NORMALISATION2))
+ 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));
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.
*/
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);
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 *or = new_rd_Or(dbgi, block, conv, xorb, 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, or, zero, ir_relation_less_greater);
+ 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);
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 *or = new_rd_Or(dbgi, block, xora, conv, 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, or, zero, ir_relation_less_greater);
+ return new_rd_Cmp(dbgi, block, orn, zero, ir_relation_less_greater);
}
}
}
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);
return transform_node_Eor_(n);
}
-
-
/**
* Do the AddSub optimization, then Transform
* Constant folding on Phi
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;
}
}
+ 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 the following optimizations are only allowed if
ir_graph *irg = get_irn_irg(n);
/* the following code leads to endless recursion when Mul are replaced
* by a simple instruction chain */
- if (!is_irg_state(irg, IR_GRAPH_STATE_ARCH_DEP)
+ if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_ARCH_DEP)
&& a == b && mode_is_int(mode)) {
ir_node *block = get_nodes_block(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 *and = new_rd_And(dbgi, block, a, notn, mode);
- return and;
+ ir_node *andn = new_rd_And(dbgi, block, a, notn, mode);
+ return andn;
}
}
}
}
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;
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)) {
ir_tarval *tv = get_Const_tarval(a);
- if (tarval_ieee754_get_exponent(tv) == 1 && tarval_ieee754_zero_mantissa(tv)
+ 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)) {
ir_tarval *tv = get_Const_tarval(b);
- if (tarval_ieee754_get_exponent(tv) == 1 && tarval_ieee754_zero_mantissa(tv)
+ 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);
*/
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;
if (get_irg_pinned(irg) == op_pin_state_floats)
return n;
- /* we do not handle switches here */
- if (get_irn_mode(a) != mode_b)
- return n;
-
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(a);
+ ta = compute_cmp_ext(a);
}
if (ta != tarval_bad && get_irn_mode(a) == mode_b) {
set_Tuple_pred(n, pn_Cond_false, jmp);
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_state(irg, IR_GRAPH_STATE_NO_UNREACHABLE_CODE);
+ 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;
+ }
+ }
+ return new_r_Tuple(block, (int)n_outs, in);
}
return n;
}
ir_tarval *tv2;
ir_tarval *tv_shift;
- if (is_irg_state(irg, IR_GRAPH_STATE_NORMALISATION2))
+ if (irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_NORMALISATION2))
return n;
assert(is_Shrs(n) || is_Shr(n) || is_Shl(n) || is_Rotl(n));
ir_node *b = get_And_right(n);
ir_mode *mode;
+ n = fold_constant_associativity(n, tarval_and);
+ if (n != oldn)
+ return n;
+
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 *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 *or = new_rd_Or(dbgi, block, conv, xorb, 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, or, zero, ir_relation_equal);
+ 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 *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 *or = new_rd_Or(dbgi, block, xora, conv, 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, or, zero, ir_relation_equal);
+ return new_rd_Cmp(dbgi, block, orn, zero, ir_relation_equal);
}
}
}
*/
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);
+ 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;
+ /* 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) {
- 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);
- }
+ 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);
}
}
}
*/
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);
+ 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;
+ /* 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);
- }
+ 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);
}
}
}
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: {
ir_graph *irg = get_irn_irg(proj);
return proj;
}
-/**
- * Optimizes jump tables (CondIs or CondIu) by removing all impossible cases.
- */
-static ir_node *transform_node_Proj_Cond(ir_node *proj)
-{
- ir_node *n = get_Proj_pred(proj);
- ir_node *b = get_Cond_selector(n);
-
- if (mode_is_int(get_irn_mode(b))) {
- ir_tarval *tb = value_of(b);
-
- if (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 {
- ir_graph *irg = get_irn_irg(proj);
- /* this case will NEVER be taken, kill it */
- clear_irg_state(irg, IR_GRAPH_STATE_NO_UNREACHABLE_CODE);
- return new_r_Bad(irg, mode_X);
- }
- }
- } else {
- long num = get_Proj_proj(proj);
- vrp_attr *b_vrp = vrp_get_info(b);
- if (num != get_Cond_default_proj(n) && b_vrp) {
- /* Try handling with vrp data. We only remove dead parts. */
- ir_tarval *tp = new_tarval_from_long(num, get_irn_mode(b));
-
- if (b_vrp->range_type == VRP_RANGE) {
- ir_relation cmp_result = tarval_cmp(b_vrp->range_bottom, tp);
- ir_relation cmp_result2 = tarval_cmp(b_vrp->range_top, tp);
-
- if ((cmp_result & ir_relation_greater) == cmp_result
- && (cmp_result2 & ir_relation_less) == cmp_result2) {
- ir_graph *irg = get_irn_irg(proj);
- clear_irg_state(irg, IR_GRAPH_STATE_NO_UNREACHABLE_CODE);
- return new_r_Bad(irg, mode_X);
- }
- } else if (b_vrp->range_type == VRP_ANTIRANGE) {
- ir_relation cmp_result = tarval_cmp(b_vrp->range_bottom, tp);
- ir_relation cmp_result2 = tarval_cmp(b_vrp->range_top, tp);
-
- if ((cmp_result & ir_relation_less_equal) == cmp_result
- && (cmp_result2 & ir_relation_greater_equal) == cmp_result2) {
- ir_graph *irg = get_irn_irg(proj);
- clear_irg_state(irg, IR_GRAPH_STATE_NO_UNREACHABLE_CODE);
- return new_r_Bad(irg, mode_X);
- }
- }
-
- if (!(tarval_cmp(
- tarval_and( b_vrp->bits_set, tp),
- b_vrp->bits_set
- ) == ir_relation_equal)) {
- ir_graph *irg = get_irn_irg(proj);
- clear_irg_state(irg, IR_GRAPH_STATE_NO_UNREACHABLE_CODE);
- return new_r_Bad(irg, mode_X);
- }
-
- if (!(tarval_cmp(
- tarval_and(
- tarval_not(tp),
- tarval_not(b_vrp->bits_not_set)),
- tarval_not(b_vrp->bits_not_set))
- == ir_relation_equal)) {
- ir_graph *irg = get_irn_irg(proj);
- clear_irg_state(irg, IR_GRAPH_STATE_NO_UNREACHABLE_CODE);
- return new_r_Bad(irg, mode_X);
- }
- }
- }
- }
- return proj;
-}
-
/**
* return true if the operation returns a value with exactly 1 bit set
*/
return false;
}
+/**
+ * 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 ir_node *flips_bit(const ir_node *node, ir_tarval *tv)
+{
+ 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.
*/
}
/* Remove unnecessary conversions */
- 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_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 = 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);
+ 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);
}
- 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);
+ }
+ 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);
+ }
}
}
}
}
}
- /* Cmp(And(1bit, val), 1bit) "bit-testing" can be replaced
- * by the simpler Cmp(And(1bit), val), 0) negated pnc */
- if (mode_is_int(mode) && is_And(left)
- && (relation == ir_relation_equal
+ 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;
+ || (!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;
+ }
+ }
+
+ 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;
+ }
+ }
+ }
+ }
}
}
if (tv != tarval_bad) {
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)) {
ir_node *op = get_Conv_op(left);
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);
/**
* Test whether a block is unreachable
* Note: That this only returns true when
- * IR_GRAPH_STATE_OPTIMIZE_UNREACHABLE_CODE is set.
+ * 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.
static bool is_block_unreachable(const ir_node *block)
{
const ir_graph *irg = get_irn_irg(block);
- if (!is_irg_state(irg, IR_GRAPH_STATE_OPTIMIZE_UNREACHABLE_CODE))
+ if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE))
return false;
return get_Block_dom_depth(block) < 0;
}
ir_node *bad = NULL;
int i;
- if (!is_irg_state(irg, IR_GRAPH_STATE_OPTIMIZE_UNREACHABLE_CODE))
+ if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE))
return block;
for (i = 0; i < arity; ++i) {
return phi;
/* Move the Pin nodes "behind" the Phi. */
- block = get_irn_n(phi, -1);
new_phi = new_r_Phi(block, n, in, mode_M);
return new_r_Pin(block, new_phi);
}
/* Beware of Phi0 */
if (n > 0) {
ir_node *pred = get_irn_n(phi, 0);
- ir_node *bound, *new_phi, *block, **in;
+ ir_node *bound, *new_phi, **in;
ir_relation relation;
bool has_confirm = false;
return phi;
/* 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, relation);
}
return phi;
}
-/* forward */
-static ir_node *transform_node(ir_node *n);
-
/**
* Optimize (a >> c1) >> c2), works for Shr, Shrs, Shl, Rotl.
*
DBG_OPT_ALGSIM0(n, irn, FS_OPT_REASSOC_SHIFT);
- return transform_node(irn);
+ return irn;
}
/**
return n;
}
+/**
+ * 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.
*/
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
}
/**
- * 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)
+static ir_node *transform_Mux_set(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 *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;
+ }
+
+ 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);
+ }
+
+ 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;
+}
+
+/**
+ * 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);
relation = get_negated_relation(relation);
sel = new_rd_Cmp(seldbgi, block, get_Cmp_left(sel),
get_Cmp_right(sel), relation);
- n = new_rd_Mux(get_irn_dbg_info(n), get_nodes_block(n), sel, f, t, mode);
+ 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;
}
/* the following optimisations create new mode_b nodes, so only do them
* before mode_b lowering */
- if (!is_irg_state(irg, IR_GRAPH_STATE_MODEB_LOWERED)) {
+ 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* 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);
- 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);
+ 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);
- 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);
+ 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* 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);
+ 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);
- 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);
+ DBG_OPT_ALGSIM0(oldn, t1, FS_OPT_MUX_COMBINE);
+ return new_r_Mux(block, or_, t1, f1, mode);
}
}
}
}
}
-
- /* more normalization: Mux(sel, 0, 1) is simply a conv from the mode_b
- * value to integer. */
- if (is_Const(t) && is_Const(f) && mode_is_int(mode)) {
- ir_tarval *a = get_Const_tarval(t);
- ir_tarval *b = get_Const_tarval(f);
-
- 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);
- return n;
- }
- }
}
if (is_Cmp(sel) && mode_is_int(mode) && is_cmp_equality_zero(sel)) {
++arity;
break;
}
- if (get_Sync_pred(n, k) == pred_pred) break;
+ if (get_Sync_pred(n, k) == pred_pred)
+ break;
}
}
}
return n;
}
+static ir_node *create_load_replacement_tuple(ir_node *n, ir_node *mem,
+ ir_node *res)
+{
+ ir_node *block = get_nodes_block(n);
+ ir_graph *irg = get_irn_irg(n);
+ ir_node *in[pn_Load_max+1];
+ size_t n_in = 2;
+ in[pn_Load_M] = mem;
+ in[pn_Load_res] = res;
+ if (ir_throws_exception(n)) {
+ in[pn_Load_X_regular] = new_r_Jmp(block);
+ in[pn_Load_X_except] = new_r_Bad(irg, mode_X);
+ n_in = 4;
+ assert(pn_Load_max == 4);
+ }
+ ir_node *tuple = new_r_Tuple(block, n_in, in);
+ return tuple;
+}
+
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);
- ir_node *mem_pred;
-
if (!is_Proj(mem))
return n;
- /* don't touch volatile loads */
- if (get_Load_volatility(n) == volatility_is_volatile)
- return n;
- mem_pred = get_Proj_pred(mem);
+ 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) != get_Load_ptr(n))
+ 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;
- }
+ ir_mode *mode = get_Load_mode(n);
+ ir_node *res = new_r_Proj(pred_load, mode, pn_Load_res);
+ return create_load_replacement_tuple(n, mem, res);
} 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) != get_Load_ptr(n))
+ 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 create_load_replacement_tuple(n, mem, value);
}
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;
+}
+
/**
* optimize a trampoline Call into a direct Call
*/
*/
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;
-}
-
-/**
- * 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(And);
- CASE(Block);
- CASE(Call);
- CASE(Cmp);
- CASE(Conv);
- CASE(End);
- CASE(Eor);
- CASE(Minus);
- CASE(Mul);
- CASE(Mux);
- CASE(Not);
- CASE(Or);
- CASE(Phi);
- CASE(Proj);
- CASE(Rotl);
- CASE(Sel);
- CASE(Shl);
- CASE(Shr);
- CASE(Shrs);
- CASE(Sub);
- CASE(Sync);
- CASE_PROJ(Bound);
- CASE_PROJ(CopyB);
- CASE_PROJ(Store);
- CASE_PROJ_EX(Cond);
- CASE_PROJ_EX(Div);
- CASE_PROJ_EX(Load);
- CASE_PROJ_EX(Mod);
- default:
- break;
- }
-
- return ops;
-#undef CASE_PROJ_EX
-#undef CASE_PROJ
-#undef CASE
-}
-
-
-/* **************** Common Subexpression Elimination **************** */
-
-/** The size of the hash table used, should estimate the number of nodes
- in a graph. */
-#define N_IR_NODES 512
-
-/** Compares two exception attributes */
-static int node_cmp_exception(const ir_node *a, const ir_node *b)
-{
- const except_attr *ea = &a->attr.except;
- const except_attr *eb = &b->attr.except;
- return ea->pin_state != eb->pin_state;
-}
-
-/** Compares the attributes of two Const nodes. */
-static int node_cmp_attr_Const(const ir_node *a, const ir_node *b)
-{
- return get_Const_tarval(a) != get_Const_tarval(b);
-}
-
-/** Compares the attributes of two Proj nodes. */
-static int node_cmp_attr_Proj(const ir_node *a, const ir_node *b)
-{
- return a->attr.proj.proj != b->attr.proj.proj;
-}
-
-/** Compares the attributes of two Alloc nodes. */
-static int node_cmp_attr_Alloc(const ir_node *a, const ir_node *b)
-{
- const alloc_attr *pa = &a->attr.alloc;
- const alloc_attr *pb = &b->attr.alloc;
- if (pa->where != pb->where || pa->type != pb->type)
- return 1;
- return node_cmp_exception(a, b);
-}
-
-/** Compares the attributes of two Free nodes. */
-static int node_cmp_attr_Free(const ir_node *a, const ir_node *b)
-{
- const free_attr *pa = &a->attr.free;
- const free_attr *pb = &b->attr.free;
- return (pa->where != pb->where) || (pa->type != pb->type);
-}
-
-/** Compares the attributes of two SymConst nodes. */
-static int node_cmp_attr_SymConst(const ir_node *a, const ir_node *b)
-{
- const symconst_attr *pa = &a->attr.symc;
- const symconst_attr *pb = &b->attr.symc;
- return (pa->kind != pb->kind)
- || (pa->sym.type_p != pb->sym.type_p);
-}
-
-/** Compares the attributes of two Call nodes. */
-static int node_cmp_attr_Call(const ir_node *a, const ir_node *b)
-{
- const call_attr *pa = &a->attr.call;
- const call_attr *pb = &b->attr.call;
- if (pa->type != pb->type || pa->tail_call != pb->tail_call)
- return 1;
- return node_cmp_exception(a, b);
-}
-
-/** Compares the attributes of two Sel nodes. */
-static int node_cmp_attr_Sel(const ir_node *a, const ir_node *b)
-{
- const ir_entity *a_ent = get_Sel_entity(a);
- const ir_entity *b_ent = get_Sel_entity(b);
- return a_ent != b_ent;
-}
-
-/** Compares the attributes of two Phi nodes. */
-static int node_cmp_attr_Phi(const ir_node *a, const ir_node *b)
-{
- /* we can only enter this function if both nodes have the same number of inputs,
- hence it is enough to check if one of them is a Phi0 */
- if (is_Phi0(a)) {
- /* check the Phi0 pos attribute */
- return a->attr.phi.u.pos != b->attr.phi.u.pos;
- }
- return 0;
-}
-
-/** Compares the attributes of two Conv nodes. */
-static int node_cmp_attr_Conv(const ir_node *a, const ir_node *b)
-{
- return get_Conv_strict(a) != get_Conv_strict(b);
-}
-
-/** Compares the attributes of two Cast nodes. */
-static int node_cmp_attr_Cast(const ir_node *a, const ir_node *b)
-{
- return get_Cast_type(a) != get_Cast_type(b);
-}
-
-/** Compares the attributes of two Load nodes. */
-static int node_cmp_attr_Load(const ir_node *a, const ir_node *b)
-{
- if (get_Load_volatility(a) == volatility_is_volatile ||
- get_Load_volatility(b) == volatility_is_volatile)
- /* NEVER do CSE on volatile Loads */
- return 1;
- /* do not CSE Loads with different alignment. Be conservative. */
- if (get_Load_unaligned(a) != get_Load_unaligned(b))
- return 1;
- if (get_Load_mode(a) != get_Load_mode(b))
- return 1;
- return node_cmp_exception(a, b);
-}
-
-/** Compares the attributes of two Store nodes. */
-static int node_cmp_attr_Store(const ir_node *a, const ir_node *b)
-{
- /* do not CSE Stores with different alignment. Be conservative. */
- if (get_Store_unaligned(a) != get_Store_unaligned(b))
- return 1;
- /* NEVER do CSE on volatile Stores */
- if (get_Store_volatility(a) == volatility_is_volatile ||
- get_Store_volatility(b) == volatility_is_volatile)
- return 1;
- return node_cmp_exception(a, b);
-}
-
-static int node_cmp_attr_CopyB(const ir_node *a, const ir_node *b)
-{
- if (get_CopyB_type(a) != get_CopyB_type(b))
- return 1;
-
- return node_cmp_exception(a, b);
-}
-
-static int node_cmp_attr_Bound(const ir_node *a, const ir_node *b)
-{
- return node_cmp_exception(a, b);
-}
-
-/** Compares the attributes of two Div nodes. */
-static int node_cmp_attr_Div(const ir_node *a, const ir_node *b)
-{
- const div_attr *ma = &a->attr.div;
- const div_attr *mb = &b->attr.div;
- if (ma->resmode != mb->resmode || ma->no_remainder != mb->no_remainder)
- return 1;
- return node_cmp_exception(a, b);
-}
-
-/** Compares the attributes of two Mod nodes. */
-static int node_cmp_attr_Mod(const ir_node *a, const ir_node *b)
-{
- const mod_attr *ma = &a->attr.mod;
- const mod_attr *mb = &b->attr.mod;
- if (ma->resmode != mb->resmode)
- return 1;
- return node_cmp_exception(a, b);
-}
-
-static int node_cmp_attr_Cmp(const ir_node *a, const ir_node *b)
-{
- const cmp_attr *ma = &a->attr.cmp;
- const cmp_attr *mb = &b->attr.cmp;
- return ma->relation != mb->relation;
-}
-
-/** Compares the attributes of two Confirm nodes. */
-static int node_cmp_attr_Confirm(const ir_node *a, const ir_node *b)
-{
- const confirm_attr *ma = &a->attr.confirm;
- const confirm_attr *mb = &b->attr.confirm;
- return ma->relation != mb->relation;
-}
-
-/** Compares the attributes of two Builtin nodes. */
-static int node_cmp_attr_Builtin(const ir_node *a, const ir_node *b)
-{
- if (get_Builtin_kind(a) != get_Builtin_kind(b))
- return 1;
- if (get_Builtin_type(a) != get_Builtin_type(b))
- return 1;
- return node_cmp_exception(a, b);
-}
-
-/** Compares the attributes of two ASM nodes. */
-static int node_cmp_attr_ASM(const ir_node *a, const 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;
+ 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);
- /* 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 1;
+ n = new_r_Const(irg, tv);
- 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
- || ca[i].mode != cb[i].mode)
- return 1;
+ DBG_OPT_CSTEVAL(old_n, n);
+ return n;
+ }
+ }
}
- n = get_ASM_n_output_constraints(a);
- if (n != get_ASM_n_output_constraints(b))
- return 1;
-
- 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
- || ca[i].mode != cb[i].mode)
- return 1;
+ /* 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;
}
- n = get_ASM_n_clobbers(a);
- if (n != get_ASM_n_clobbers(b))
- return 1;
-
- cla = get_ASM_clobbers(a);
- clb = get_ASM_clobbers(b);
- for (i = 0; i < n; ++i) {
- if (cla[i] != clb[i])
- 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;
+ }
+ }
}
- return node_cmp_exception(a, b);
+ return n;
}
-/** Compares the inexistent attributes of two Dummy nodes. */
-static int node_cmp_attr_Dummy(const ir_node *a, const ir_node *b)
-{
- (void) a;
- (void) b;
- /* Dummy nodes never equal by definition */
- return 1;
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+void ir_register_opt_node_ops(void)
+{
+ 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);
}
-static int node_cmp_attr_InstOf(const ir_node *a, const ir_node *b)
-{
- if (get_InstOf_type(a) != get_InstOf_type(b))
- return 1;
- return node_cmp_exception(a, b);
-}
-
-/**
- * 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(ASM);
- CASE(Alloc);
- CASE(Bound);
- CASE(Builtin);
- CASE(Call);
- CASE(Cast);
- CASE(Cmp);
- CASE(Confirm);
- CASE(Const);
- CASE(Conv);
- CASE(CopyB);
- CASE(Div);
- CASE(Dummy);
- CASE(Free);
- CASE(InstOf);
- CASE(Load);
- CASE(Mod);
- CASE(Phi);
- CASE(Proj);
- CASE(Sel);
- CASE(Store);
- CASE(SymConst);
- default:
- /* leave NULL */
- break;
- }
+/* **************** Common Subexpression Elimination **************** */
- return ops;
-#undef CASE
-}
+/** 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)
{
ir_node *a = (ir_node *)elt;
if (get_irn_pinned(a) == op_pin_state_pinned) {
/* for pinned nodes, the block inputs must be equal */
- if (get_irn_n(a, -1) != get_irn_n(b, -1))
+ if (get_nodes_block(a) != get_nodes_block(b))
return 1;
} else {
ir_node *block_a = get_nodes_block(a);
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;
}
}
return 0;
}
-/*
- * Calculate a hash value of a node.
- *
- * @param node The IR-node
- */
unsigned ir_node_hash(const ir_node *node)
{
return node->op->ops.hash(node);
}
-
void new_identities(ir_graph *irg)
{
if (irg->value_table != NULL)
del_pset(irg->value_table);
}
-/* Normalize a node by putting constants (and operands with larger
- * node index) on the right (operator side). */
+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);
+}
+
void ir_normalize_node(ir_node *n)
{
if (is_op_commutative(get_irn_op(n))) {
set_binop_right(n, l);
hook_normalize(n);
}
+ } 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 (!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);
+ }
}
}
-/*
- * 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 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(ir_node *n)
{
ir_graph *irg = get_irn_irg(n);
return n;
}
-/* Add a node to the identities value table. */
void add_identities(ir_node *node)
{
if (!get_opt_cse())
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;
ir_graph *rem = current_ir_graph;
current_ir_graph = irg;
- foreach_pset(irg->value_table, ir_node*, node) {
+ foreach_pset(irg->value_table, ir_node, node) {
visit(node, env);
}
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
- */
ir_node *optimize_node(ir_node *n)
{
ir_node *oldn = 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);
+ }
/* 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(o);
if (o != n)
return n;
}
-
-/**
- * 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)
{
- ir_tarval *tv;
- ir_node *oldn = n;
- unsigned iro = get_irn_opcode(n);
-
if (!get_opt_optimize() && !is_Phi(n)) return n;
- if (iro == iro_Deleted)
+ if (is_Deleted(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) {
- /* try to evaluate */
- tv = computed_value(n);
- if (tv != tarval_bad) {
- /* evaluation was successful -- replace the node. */
- ir_graph *irg = get_irn_irg(n);
-
- n = new_r_Const(irg, tv);
-
- DBG_OPT_CSTEVAL(oldn, n);
- return n;
- }
- }
- }
-
- /* 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);
-
/** 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(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);
+ n = transform_node(n);
/* Now we can verify the node, as it has no dead inputs any more. */
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(o);
if (o != n)
return n;
}
-/**
- * Wrapper for external use, set proper status bits after optimization.
- */
ir_node *optimize_in_place(ir_node *n)
{
ir_graph *irg = get_irn_irg(n);
- /* Handle graph state */
- assert(get_irg_phase_state(irg) != phase_building);
if (get_opt_global_cse())
set_irg_pinned(irg, op_pin_state_floats);
/* FIXME: Maybe we could also test whether optimizing the node can
change the control graph. */
- clear_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE);
+ clear_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE);
return optimize_in_place_2(n);
}
-
-/**
- * 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.tarval);
-
- return h;
-}
-
-/**
- * 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;
-}
-
-/**
- * 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(unsigned 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(unsigned 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_attr(code, ops);
- ops = firm_set_default_get_entity_attr(code, ops);
-
- return ops;
-}