#include <string.h>
#endif
-# include "irnode_t.h"
-# include "irgraph_t.h"
-# include "iredges_t.h"
-# include "irmode_t.h"
-# include "iropt_t.h"
-# include "ircons_t.h"
-# include "irgmod.h"
-# include "irvrfy.h"
-# include "tv_t.h"
-# include "dbginfo_t.h"
-# include "iropt_dbg.h"
-# include "irflag_t.h"
-# include "irhooks.h"
-# include "irarch.h"
-# include "hashptr.h"
-# include "archop.h"
-# include "opt_polymorphy.h"
-# include "opt_confirms.h"
+#include "irnode_t.h"
+#include "irgraph_t.h"
+#include "iredges_t.h"
+#include "irmode_t.h"
+#include "iropt_t.h"
+#include "ircons_t.h"
+#include "irgmod.h"
+#include "irvrfy.h"
+#include "tv_t.h"
+#include "dbginfo_t.h"
+#include "iropt_dbg.h"
+#include "irflag_t.h"
+#include "irhooks.h"
+#include "irarch.h"
+#include "hashptr.h"
+#include "archop.h"
+#include "opt_polymorphy.h"
+#include "opt_confirms.h"
/* Make types visible to allow most efficient access */
# include "entity_t.h"
return tarval_bad;
}
+/**
+ * return the value of a Carry
+ * Special : a op 0, 0 op b
+ */
+static tarval *computed_value_Carry(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);
+
+ if ((ta != tarval_bad) && (tb != tarval_bad)) {
+ tarval_add(ta, tb);
+ return tarval_carry() ? get_mode_one(m) : get_mode_null(m);
+ } else {
+ if ( (classify_tarval(ta) == TV_CLASSIFY_NULL)
+ || (classify_tarval(tb) == TV_CLASSIFY_NULL))
+ return get_mode_null(m);
+ }
+ return tarval_bad;
+}
+
+/**
+ * return the value of a Borrow
+ * Special : a op 0
+ */
+static tarval *computed_value_Borrow(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);
+
+ if ((ta != tarval_bad) && (tb != tarval_bad)) {
+ return tarval_cmp(ta, tb) == pn_Cmp_Lt ? get_mode_one(m) : get_mode_null(m);
+ } else if (classify_tarval(ta) == TV_CLASSIFY_NULL) {
+ return get_mode_null(m);
+ }
+ return tarval_bad;
+}
+
/**
* return the value of an unary Minus
*/
return new_tarval_from_long(proj_nr & pn_Cmp_Ne, mode_b);
}
}
-
return computed_value_Cmp_Confirm(a, aa, ab, proj_nr);
}
return tarval_bad;
}
+/**
+ * Calculate the value of a Psi: can be evaluated, if a condition is true
+ * and all previous conditions are false. If all conditions are false
+ * we evaluate to the default one.
+ */
+static tarval *computed_value_Psi(ir_node *n)
+{
+ if (is_Mux(n))
+ return computed_value_Mux(n);
+ return tarval_bad;
+}
+
/**
* calculate the value of a Confirm: can be evaluated,
* if it has the form Confirm(x, '=', Const).
*/
tarval *computed_value(ir_node *n)
{
- if (n->op->computed_value)
- return n->op->computed_value(n);
+ if (n->op->ops.computed_value)
+ return n->op->ops.computed_value(n);
return tarval_bad;
}
/**
- * set the default computed_value evaluator
+ * 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 *firm_set_default_computed_value(ir_op *op)
+static ir_op_ops *firm_set_default_computed_value(opcode code, ir_op_ops *ops)
{
#define CASE(a) \
case iro_##a: \
- op->computed_value = computed_value_##a; \
+ ops->computed_value = computed_value_##a; \
break
- switch (op->code) {
+ switch (code) {
CASE(Const);
CASE(SymConst);
CASE(Add);
CASE(Shr);
CASE(Shrs);
CASE(Rot);
+ CASE(Carry);
+ CASE(Borrow);
CASE(Conv);
CASE(Proj);
CASE(Mux);
+ CASE(Psi);
CASE(Confirm);
default:
- op->computed_value = NULL;
+ /* leave NULL */;
}
- return op;
+ return ops;
#undef CASE
}
-#if 0
-/* returns 1 if the a and b are pointers to different locations. */
-static bool
-different_identity (ir_node *a, ir_node *b)
-{
- assert (mode_is_reference(get_irn_mode (a))
- && mode_is_reference(get_irn_mode (b)));
-
- if (get_irn_op (a) == op_Proj && get_irn_op(b) == op_Proj) {
- ir_node *a1 = get_Proj_pred (a);
- ir_node *b1 = get_Proj_pred (b);
- if (a1 != b1 && get_irn_op (a1) == op_Alloc
- && get_irn_op (b1) == op_Alloc)
- return 1;
- }
- return 0;
-}
-#endif
-
/**
* Returns a equivalent block for another block.
* If the block has only one predecessor, this is
}
}
else if (get_opt_unreachable_code() &&
- (n != current_ir_graph->start_block) &&
- (n != current_ir_graph->end_block) ) {
+ (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
break;
}
}
- if (i < 0)
+ if (i < 0) {
n = set_Block_dead(n);
+ DBG_OPT_DEAD_BLOCK(oldn, n);
+ }
}
return n;
/**
* Returns a equivalent node for a Jmp, a Bad :-)
- * Of course this only happens if the Block of the Jmp is Bad.
+ * Of course this only happens if the Block of the Jmp is dead.
*/
static ir_node *equivalent_node_Jmp(ir_node *n)
{
return n;
}
-/* Same for op_Raise */
+/** Raise is handled in the same way as Jmp. */
#define equivalent_node_Raise equivalent_node_Jmp
return n;
}
+/**
+ * Eor is commutative and has neutral 0.
+ */
#define equivalent_node_Eor equivalent_node_neutral_zero
/*
/**
* Optimize an "idempotent unary op", ie op(op(n)) = n.
*
- * @fixme -(-a) == a, but might overflow two times.
- * We handle it anyway here but the better way would be a
- * flag. This would be needed for Pascal for instance.
+ * @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)
{
return n;
}
-/* Not(Not(x)) == x */
+/** Not(Not(x)) == x */
#define equivalent_node_Not equivalent_node_idempotent_unop
-/* --x == x */ /* ??? Is this possible or can --x raise an
+/** --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
if (classify_tarval(value_of(b)) == TV_CLASSIFY_ONE) { /* div(x, 1) == x */
/* Turn Div into a tuple (mem, bad, a) */
ir_node *mem = get_Div_mem(n);
- turn_into_tuple(n, 3);
+ turn_into_tuple(n, pn_Div_max);
set_Tuple_pred(n, pn_Div_M, mem);
set_Tuple_pred(n, pn_Div_X_except, new_Bad()); /* no exception */
set_Tuple_pred(n, pn_Div_res, a);
ir_node *mem = get_Div_mem(n);
ir_mode *mode = get_irn_mode(b);
- turn_into_tuple(n, 4);
+ turn_into_tuple(n, pn_DivMod_max);
set_Tuple_pred(n, pn_DivMod_M, mem);
set_Tuple_pred(n, pn_DivMod_X_except, new_Bad()); /* no exception */
set_Tuple_pred(n, pn_DivMod_res_div, a);
return n;
}
-/* Several optimizations:
+/**
+ Several optimizations:
- no Phi in start block.
- remove Id operators that are inputs to Phi
- fold Phi-nodes, iff they have only one predecessor except
themselves.
-*/
+ */
static ir_node *equivalent_node_Phi(ir_node *n)
{
int i, n_preds;
ir_node *oldn = n;
ir_node *block = NULL; /* to shutup gcc */
ir_node *first_val = NULL; /* to shutup gcc */
- ir_node *scnd_val = NULL; /* to shutup gcc */
if (!get_opt_normalize()) return n;
/* @@@ fliegt 'raus, sollte aber doch immer wahr sein!!!
assert(get_irn_arity(block) == n_preds && "phi in wrong block!"); */
if ((is_Block_dead(block)) || /* Control dead */
- (block == current_ir_graph->start_block)) /* There should be no Phi nodes */
- return new_Bad(); /* in the Start Block. */
+ (block == get_irg_start_block(current_ir_graph))) /* There should be no Phi nodes */
+ return new_Bad(); /* in the Start Block. */
if (n_preds == 0) return n; /* Phi of dead Region without predecessors. */
return new_Bad();
}
- scnd_val = NULL;
-
- /* follow_Id () for rest of inputs, determine if any of these
+ /* search for rest of inputs, determine if any of these
are non-self-referencing */
while (++i < n_preds) {
- scnd_val = get_Phi_pred(n, i);
+ ir_node *scnd_val = get_Phi_pred(n, i);
if ( (scnd_val != n)
&& (scnd_val != first_val)
#if 1
/* Fold, if no multiple distinct non-self-referencing inputs */
n = first_val;
DBG_OPT_PHI(oldn, n);
- } else {
- /* skip the remaining Ids (done in get_Phi_pred). */
- /* superfluous, since we walk all to propagate Block's Bads.
- while (++i < n_preds) get_Phi_pred(n, i); */
}
return n;
}
/**
- * optimize Proj(Tuple) and gigo() for ProjX in Bad block
+ Several optimizations:
+ - no Sync in start block.
+ - fold Sync-nodes, iff they have only one predecessor except
+ themselves.
+ @fixme: are there loop's in Sync's
+ */
+static ir_node *equivalent_node_Sync(ir_node *n)
+{
+ int i, n_preds;
+
+ ir_node *oldn = n;
+ ir_node *first_val = NULL; /* to shutup gcc */
+
+ if (!get_opt_normalize()) return n;
+
+ n_preds = get_Sync_n_preds(n);
+
+ /* Find first non-self-referencing input */
+ for (i = 0; i < n_preds; ++i) {
+ first_val = get_Sync_pred(n, i);
+ if ((first_val != n) /* not self pointer */ &&
+ (! is_Bad(first_val))
+ ) { /* value not dead */
+ break; /* then found first value. */
+ }
+ }
+
+ if (i >= n_preds)
+ /* A totally Bad or self-referencing Sync (we didn't break the above loop) */
+ return new_Bad();
+
+ /* search the rest of inputs, determine if any of these
+ are non-self-referencing */
+ while (++i < n_preds) {
+ ir_node *scnd_val = get_Sync_pred(n, i);
+ if ((scnd_val != n) &&
+ (scnd_val != first_val) &&
+ (! is_Bad(scnd_val))
+ )
+ break;
+ }
+
+ if (i >= n_preds) {
+ /* Fold, if no multiple distinct non-self-referencing inputs */
+ n = first_val;
+ DBG_OPT_SYNC(oldn, n);
+ }
+ return n;
+}
+
+/**
+ * optimize Proj(Tuple) and gigo() for ProjX in Bad block,
+ * ProjX(Load) and ProjX(Store)
*/
static ir_node *equivalent_node_Proj(ir_node *n)
{
/* Remove dead control flow -- early gigo(). */
n = new_Bad();
}
+ else if (get_opt_ldst_only_null_ptr_exceptions()) {
+ ir_op *op = get_irn_op(a);
+
+ if (op == op_Load || op == op_Store) {
+ /* get the load/store address */
+ ir_node *addr = get_irn_n(a, 1);
+ if (value_not_null(addr)) {
+ /* this node may float if it did not depend on a Confirm */
+ set_irn_pinned(a, op_pin_state_floats);
+ DBG_OPT_EXC_REM(n);
+ return new_Bad();
+ }
+ }
+ }
}
return n;
return n;
}
+/**
+ * Returns a equivalent node of a Psi: if a condition is true
+ * and all previous conditions are false we know its value.
+ * If all conditions are false its value is the default one.
+ */
+static ir_node *equivalent_node_Psi(ir_node *n) {
+ if (is_Mux(n))
+ return equivalent_node_Mux(n);
+ return n;
+}
+
/**
* Optimize -a CMP -b into b CMP a.
* This works only for for modes where unary Minus
* rare case: two identical Confirms one after another,
* replace the second one with the first.
*/
- return pred;
+ n = pred;
}
if (pnc == pn_Cmp_Eq) {
ir_node *bound = get_Confirm_bound(n);
return bound;
}
}
- return get_opt_remove_Confirm() ? get_Confirm_value(n) : n;
+ return get_opt_remove_confirm() ? get_Confirm_value(n) : n;
+}
+
+/**
+ * Optimize CopyB(mem, x, x) into a Nop
+ */
+static ir_node *equivalent_node_CopyB(ir_node *n)
+{
+ ir_node *a = get_CopyB_dst(n);
+ ir_node *b = get_CopyB_src(n);
+
+ if (a == b) {
+ /* Turn CopyB into a tuple (mem, bad, bad) */
+ ir_node *mem = get_CopyB_mem(n);
+ turn_into_tuple(n, pn_CopyB_max);
+ set_Tuple_pred(n, pn_CopyB_M, mem);
+ set_Tuple_pred(n, pn_CopyB_X_except, new_Bad()); /* no exception */
+ set_Tuple_pred(n, pn_CopyB_M_except, new_Bad());
+ }
+ return n;
+}
+
+/**
+ * Optimize Bounds(idx, idx, upper) into idx.
+ */
+static ir_node *equivalent_node_Bound(ir_node *n)
+{
+ ir_node *idx = get_Bound_index(n);
+ ir_node *lower = get_Bound_lower(n);
+ int ret_tuple = 0;
+
+ /* By definition lower < upper, so if idx == lower -->
+ lower <= idx && idx < upper */
+ if (idx == lower) {
+ /* Turn Bound into a tuple (mem, bad, idx) */
+ ret_tuple = 1;
+ }
+ else {
+ ir_node *pred = skip_Proj(idx);
+
+ if (get_irn_op(pred) == op_Bound) {
+ /*
+ * idx was Bounds_check previously, it is still valid if
+ * lower <= pred_lower && pred_upper <= upper.
+ */
+ ir_node *upper = get_Bound_upper(n);
+ if (get_Bound_lower(pred) == lower &&
+ 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 than.
+ * So, we must turn in into a tuple
+ */
+ ret_tuple = 1;
+ }
+ }
+ }
+ if (ret_tuple) {
+ /* Turn Bound into a tuple (mem, bad, idx) */
+ ir_node *mem = get_Bound_mem(n);
+ turn_into_tuple(n, pn_Bound_max);
+ set_Tuple_pred(n, pn_Bound_M_regular, mem);
+ set_Tuple_pred(n, pn_Bound_X_except, new_Bad()); /* no exception */
+ set_Tuple_pred(n, pn_Bound_res, idx);
+ set_Tuple_pred(n, pn_Bound_M_except, mem);
+ }
+ return n;
}
/**
ir_node *
equivalent_node(ir_node *n)
{
- if (n->op->equivalent_node)
- return n->op->equivalent_node(n);
+ if (n->op->ops.equivalent_node)
+ return n->op->ops.equivalent_node(n);
return n;
}
/**
- * set the default equivalent node operation
+ * 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 *firm_set_default_equivalent_node(ir_op *op)
+static ir_op_ops *firm_set_default_equivalent_node(opcode code, ir_op_ops *ops)
{
#define CASE(a) \
case iro_##a: \
- op->equivalent_node = equivalent_node_##a; \
+ ops->equivalent_node = equivalent_node_##a; \
break
- switch (op->code) {
+ switch (code) {
CASE(Block);
CASE(Jmp);
CASE(Raise);
CASE(Conv);
CASE(Cast);
CASE(Phi);
+ CASE(Sync);
CASE(Proj);
CASE(Id);
CASE(Mux);
+ CASE(Psi);
CASE(Cmp);
CASE(Confirm);
+ CASE(CopyB);
+ CASE(Bound);
default:
- op->equivalent_node = NULL;
+ /* leave NULL */;
}
- return op;
+ return ops;
#undef CASE
}
}
/**
- * Do the AddSub optimization, then Transform Add(a,a) into Mul(a, 2)
+ * Do the AddSub optimization, then Transform
+ * 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.
mode = get_irn_mode(n);
if (mode_is_num(mode)) {
ir_node *a = get_Add_left(n);
+ ir_node *b = get_Add_right(n);
- if (a == get_Add_right(n)) {
+ if (a == b) {
ir_node *block = get_irn_n(n, -1);
n = new_rd_Mul(
mode);
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_A_A);
}
- else {
- ir_node *b = get_Add_right(n);
-
- if (get_irn_op(a) == op_Minus) {
- n = new_rd_Sub(
- get_irn_dbg_info(n),
- current_ir_graph,
- get_irn_n(n, -1),
- b,
- get_Minus_op(a),
- mode);
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_A_MINUS_B);
+ else if (get_irn_op(a) == op_Minus) {
+ n = new_rd_Sub(
+ get_irn_dbg_info(n),
+ current_ir_graph,
+ get_irn_n(n, -1),
+ b,
+ get_Minus_op(a),
+ mode);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_A_MINUS_B);
+ }
+ else if (get_irn_op(b) == op_Minus) {
+ n = new_rd_Sub(
+ get_irn_dbg_info(n),
+ current_ir_graph,
+ get_irn_n(n, -1),
+ a,
+ get_Minus_op(b),
+ mode);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_A_MINUS_B);
+ }
+ /* do NOT execute this code if reassociation is enabled, it does the inverse! */
+ else if (!get_opt_reassociation() && get_irn_op(a) == op_Mul) {
+ ir_node *ma = get_Mul_left(a);
+ ir_node *mb = get_Mul_right(a);
+
+ if (b == ma) {
+ ir_node *blk = get_irn_n(n, -1);
+ n = new_rd_Mul(
+ get_irn_dbg_info(n), current_ir_graph, blk,
+ ma,
+ new_rd_Add(
+ get_irn_dbg_info(n), current_ir_graph, blk,
+ mb,
+ new_r_Const_long(current_ir_graph, blk, mode, 1),
+ mode),
+ mode);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_MUL_A_X_A);
}
- else if (get_irn_op(b) == op_Minus) {
- n = new_rd_Sub(
- get_irn_dbg_info(n),
- current_ir_graph,
- get_irn_n(n, -1),
- a,
- get_Minus_op(b),
- mode);
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_A_MINUS_B);
+ else if (b == mb) {
+ ir_node *blk = get_irn_n(n, -1);
+ n = new_rd_Mul(
+ get_irn_dbg_info(n), current_ir_graph, blk,
+ mb,
+ new_rd_Add(
+ get_irn_dbg_info(n), current_ir_graph, blk,
+ ma,
+ new_r_Const_long(current_ir_graph, blk, mode, 1),
+ mode),
+ mode);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_MUL_A_X_A);
+ }
+ }
+ /* do NOT execute this code if reassociation is enabled, it does the inverse! */
+ else if (!get_opt_reassociation() && get_irn_op(b) == op_Mul) {
+ ir_node *ma = get_Mul_left(b);
+ ir_node *mb = get_Mul_right(b);
+
+ if (a == ma) {
+ ir_node *blk = get_irn_n(n, -1);
+ n = new_rd_Mul(
+ get_irn_dbg_info(n), current_ir_graph, blk,
+ ma,
+ new_rd_Add(
+ get_irn_dbg_info(n), current_ir_graph, blk,
+ mb,
+ new_r_Const_long(current_ir_graph, blk, mode, 1),
+ mode),
+ mode);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_MUL_A_X_A);
+ }
+ else if (a == mb) {
+ ir_node *blk = get_irn_n(n, -1);
+ n = new_rd_Mul(
+ get_irn_dbg_info(n), current_ir_graph, blk,
+ mb,
+ new_rd_Add(
+ get_irn_dbg_info(n), current_ir_graph, blk,
+ ma,
+ new_r_Const_long(current_ir_graph, blk, mode, 1),
+ mode),
+ mode);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_MUL_A_X_A);
}
}
}
}
/**
- * Do the AddSub optimization, then Transform Sub(0,a) into Minus(a).
+ * Do the AddSub optimization, then Transform
+ * Sub(0,a) -> Minus(a)
+ * Sub(Mul(a, x), a) -> Mul(a, x-1)
*/
static ir_node *transform_node_Sub(ir_node *n)
{
ir_mode *mode;
ir_node *oldn = n;
+ ir_node *a, *b;
n = transform_node_AddSub(n);
mode = get_irn_mode(n);
- if (mode_is_num(mode) && (classify_Const(get_Sub_left(n)) == CNST_NULL)) {
+ a = get_Sub_left(n);
+ b = get_Sub_right(n);
+ if (mode_is_num(mode) && (classify_Const(a) == CNST_NULL)) {
n = new_rd_Minus(
get_irn_dbg_info(n),
current_ir_graph,
get_irn_n(n, -1),
- get_Sub_right(n),
+ b,
mode);
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_SUB_0_A);
}
+ /* do NOT execute this code if reassociation is enabled, it does the inverse! */
+ else if (get_opt_reassociation() && get_irn_op(a) == op_Mul) {
+ ir_node *ma = get_Mul_left(a);
+ ir_node *mb = get_Mul_right(a);
+
+ if (ma == b) {
+ ir_node *blk = get_irn_n(n, -1);
+ n = new_rd_Mul(
+ get_irn_dbg_info(n),
+ current_ir_graph, blk,
+ ma,
+ new_rd_Sub(
+ get_irn_dbg_info(n),
+ current_ir_graph, blk,
+ mb,
+ new_r_Const_long(current_ir_graph, blk, mode, 1),
+ mode),
+ mode);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_SUB_MUL_A_X_A);
+ }
+ else if (mb == b) {
+ ir_node *blk = get_irn_n(n, -1);
+ n = new_rd_Mul(
+ get_irn_dbg_info(n),
+ current_ir_graph, blk,
+ mb,
+ new_rd_Sub(
+ get_irn_dbg_info(n),
+ current_ir_graph, blk,
+ ma,
+ new_r_Const_long(current_ir_graph, blk, mode, 1),
+ mode),
+ mode);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_SUB_MUL_A_X_A);
+ }
+ }
return n;
}
/* Turn Mod into a tuple (mem, bad, value) */
ir_node *mem = get_Mod_mem(n);
- turn_into_tuple(n, 3);
+ turn_into_tuple(n, pn_Mod_max);
set_Tuple_pred(n, pn_Mod_M, mem);
set_Tuple_pred(n, pn_Mod_X_except, new_Bad());
set_Tuple_pred(n, pn_Mod_res, value);
if (evaluated) { /* replace by tuple */
ir_node *mem = get_DivMod_mem(n);
- turn_into_tuple(n, 4);
+ turn_into_tuple(n, pn_DivMod_max);
set_Tuple_pred(n, pn_DivMod_M, mem);
set_Tuple_pred(n, pn_DivMod_X_except, new_Bad()); /* no exception */
set_Tuple_pred(n, pn_DivMod_res_div, a);
/* It's a boolean Cond, branching on a boolean constant.
Replace it by a tuple (Bad, Jmp) or (Jmp, Bad) */
jmp = new_r_Jmp(current_ir_graph, get_nodes_block(n));
- turn_into_tuple(n, 2);
+ turn_into_tuple(n, pn_Cond_max);
if (ta == tarval_b_true) {
set_Tuple_pred(n, pn_Cond_false, new_Bad());
set_Tuple_pred(n, pn_Cond_true, jmp);
static ir_node *transform_node_Cast(ir_node *n) {
ir_node *oldn = n;
ir_node *pred = get_Cast_op(n);
- type *tp = get_irn_type(n);
+ ir_type *tp = get_irn_type(n);
if (get_irn_op(pred) == op_Const && get_Const_type(pred) != tp) {
n = new_rd_Const_type(NULL, current_ir_graph, get_irn_n(pred, -1), get_irn_mode(pred),
/* div(x, y) && y != 0 */
proj_nr = get_Proj_proj(proj);
- /* this node may float */
+ /* this node may float if it did not depend on a Confirm */
set_irn_pinned(n, op_pin_state_floats);
if (proj_nr == pn_Div_X_except) {
/* we found an exception handler, remove it */
+ DBG_OPT_EXC_REM(proj);
return new_Bad();
- } else if (proj_nr == pn_Div_M) {
- /* the memory Proj can be removed */
+ }
+ else if (proj_nr == pn_Div_M) {
ir_node *res = get_Div_mem(n);
- set_Div_mem(n, get_irg_no_mem(current_ir_graph));
-
+ /* the memory Proj can only be removed if we divide by a
+ real constant, but the node never produce a new memory */
+ if (value_of(b) != tarval_bad) {
+ /* this is a Div by a const, we can remove the memory edge */
+ set_Div_mem(n, get_irg_no_mem(current_ir_graph));
+ }
return res;
}
}
/* mod(x, y) && y != 0 */
proj_nr = get_Proj_proj(proj);
- /* this node may float */
+ /* this node may float if it did not depend on a Confirm */
set_irn_pinned(n, op_pin_state_floats);
if (proj_nr == pn_Mod_X_except) {
/* we found an exception handler, remove it */
+ DBG_OPT_EXC_REM(proj);
return new_Bad();
} else if (proj_nr == pn_Mod_M) {
- /* the memory Proj can be removed */
ir_node *res = get_Mod_mem(n);
- set_Mod_mem(n, get_irg_no_mem(current_ir_graph));
-
+ /* the memory Proj can only be removed if we divide by a
+ real constant, but the node never produce a new memory */
+ if (value_of(b) != tarval_bad) {
+ /* this is a Mod by a const, we can remove the memory edge */
+ set_Mod_mem(n, get_irg_no_mem(current_ir_graph));
+ }
return res;
}
else if (proj_nr == pn_Mod_res && get_Mod_left(n) == b) {
/* DivMod(x, y) && y != 0 */
proj_nr = get_Proj_proj(proj);
- /* this node may float */
+ /* this node may float if it did not depend on a Confirm */
set_irn_pinned(n, op_pin_state_floats);
if (proj_nr == pn_DivMod_X_except) {
/* we found an exception handler, remove it */
+ DBG_OPT_EXC_REM(proj);
return new_Bad();
}
else if (proj_nr == pn_DivMod_M) {
- /* the memory Proj can be removed */
ir_node *res = get_DivMod_mem(n);
- set_DivMod_mem(n, get_irg_no_mem(current_ir_graph));
-
+ /* the memory Proj can only be removed if we divide by a
+ real constant, but the node never produce a new memory */
+ if (value_of(b) != tarval_bad) {
+ /* this is a DivMod by a const, we can remove the memory edge */
+ set_DivMod_mem(n, get_irg_no_mem(current_ir_graph));
+ }
return res;
}
else if (proj_nr == pn_DivMod_res_mod && get_DivMod_left(n) == b) {
proj_nr = get_inversed_pnc(proj_nr);
changed |= 1;
}
- else if (left > right) {
+ else if (get_irn_idx(left) > get_irn_idx(right)) {
ir_node *t = left;
left = right;
}
}
} /* mode_is_int */
- }
+
+ /*
+ * optimization for AND:
+ * Optimize:
+ * And(x, C) == C ==> And(x, C) != 0
+ * And(x, C) != C ==> And(X, C) == 0
+ *
+ * if C is a single Bit constant.
+ */
+ if ((proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg) &&
+ (get_irn_op(left) == op_And)) {
+ if (is_single_bit_tarval(tv)) {
+ /* check for Constant's match. We have check hare the tarvals,
+ because our const might be changed */
+ ir_node *la = get_And_left(left);
+ ir_node *ra = get_And_right(left);
+ if ((is_Const(la) && get_Const_tarval(la) == tv) ||
+ (is_Const(ra) && get_Const_tarval(ra) == tv)) {
+ /* fine: do the transformation */
+ tv = get_mode_null(get_tarval_mode(tv));
+ proj_nr ^= pn_Cmp_Leg;
+ changed |= 2;
+ }
+ }
+ }
+ } /* tarval != bad */
}
if (changed) {
return arch_transform_node_Mux(n);
}
+/**
+ * Optimize a Psi into some simpler cases.
+ */
+static ir_node *transform_node_Psi(ir_node *n) {
+ if (is_Mux(n))
+ return transform_node_Mux(n);
+
+ return n;
+}
+
/**
* Tries several [inplace] [optimizing] transformations and returns an
* equivalent node. The difference to equivalent_node() is that these
*/
static ir_node *transform_node(ir_node *n)
{
- if (n->op->transform_node)
- n = n->op->transform_node(n);
+ if (n->op->ops.transform_node)
+ n = n->op->ops.transform_node(n);
return n;
}
/**
- * set the default transform node operation
+ * sSets 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 *firm_set_default_transform_node(ir_op *op)
+static ir_op_ops *firm_set_default_transform_node(opcode code, ir_op_ops *ops)
{
#define CASE(a) \
case iro_##a: \
- op->transform_node = transform_node_##a; \
+ ops->transform_node = transform_node_##a; \
break
- switch (op->code) {
+ switch (code) {
CASE(Add);
CASE(Sub);
CASE(Mul);
CASE(Shl);
CASE(End);
CASE(Mux);
+ CASE(Psi);
default:
- op->transform_node = NULL;
+ /* leave NULL */;
}
- return op;
+ return ops;
#undef CASE
}
}
/**
- * set the default node attribute compare operation
+ * 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 *firm_set_default_node_cmp_attr(ir_op *op)
+static ir_op_ops *firm_set_default_node_cmp_attr(opcode code, ir_op_ops *ops)
{
-#define CASE(a) \
- case iro_##a: \
- op->node_cmp_attr = node_cmp_attr_##a; \
+#define CASE(a) \
+ case iro_##a: \
+ ops->node_cmp_attr = node_cmp_attr_##a; \
break
- switch (op->code) {
+ switch (code) {
CASE(Const);
CASE(Proj);
CASE(Filter);
CASE(Store);
CASE(Confirm);
default:
- op->node_cmp_attr = NULL;
+ /* leave NULL */;
}
- return op;
+ return ops;
#undef CASE
}
-/**
+/*
* Compare function for two nodes in the hash table. Gets two
* nodes as parameters. Returns 0 if the nodes are a cse.
*/
-static int
-vt_cmp (const void *elt, const void *key)
+int identities_cmp(const void *elt, const void *key)
{
ir_node *a, *b;
int i, irn_arity_a;
* here, we already now that the nodes are identical except their
* attributes
*/
- if (a->op->node_cmp_attr)
- return a->op->node_cmp_attr(a, b);
+ if (a->op->ops.node_cmp_attr)
+ return a->op->ops.node_cmp_attr(a, b);
return 0;
}
pset *
new_identities(void) {
- return new_pset(vt_cmp, N_IR_NODES);
+ return new_pset(identities_cmp, N_IR_NODES);
}
void
* nodes are extremely time critical because of their frequent use in
* constant string arrays.
*/
-static INLINE ir_node *
-identify (pset *value_table, ir_node *n)
+static INLINE ir_node *identify(pset *value_table, ir_node *n)
{
ir_node *o = NULL;
ir_node *r = get_binop_right(n);
/* for commutative operators perform a OP b == b OP a */
- if (l > r) {
+ if (get_irn_idx(l) > get_irn_idx(r)) {
set_binop_left(n, r);
set_binop_right(n, l);
}
}
}
- o = pset_find (value_table, n, ir_node_hash (n));
+ o = pset_find(value_table, n, ir_node_hash (n));
if (!o) return n;
DBG_OPT_CSE(n, o);
* optimization is performed. The flag turning on procedure global cse could
* be changed between two allocations. This way we are safe.
*/
-static INLINE ir_node *
-identify_cons (pset *value_table, ir_node *n) {
+static INLINE ir_node *identify_cons(pset *value_table, ir_node *n) {
ir_node *old = n;
n = identify(value_table, n);
return n;
}
-/**
+/*
* 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.
*/
-static ir_node *
-identify_remember (pset *value_table, ir_node *n)
+ir_node *identify_remember(pset *value_table, ir_node *n)
{
ir_node *o = NULL;
return o;
}
-void
-add_identities (pset *value_table, ir_node *node) {
- if (get_opt_cse() && (get_irn_opcode(node) != iro_Block))
- identify_remember (value_table, node);
+/* 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);
+}
+
+/* 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, node)
+ visit(node, env);
+ current_ir_graph = rem;
}
/**
* 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 INLINE ir_node *
-gigo (ir_node *node)
+static INLINE ir_node *gigo(ir_node *node)
{
int i, irn_arity;
ir_op *op = get_irn_op(node);
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, i might be useful to move this into a later phase
+ (it you thing 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
return node;
}
-
/**
* These optimizations deallocate nodes from the obstack.
* It can only be called if it is guaranteed that no other nodes
*
* current_ir_graph must be set to the graph of the node!
*/
-ir_node *
-optimize_node(ir_node *n)
+ir_node *optimize_node(ir_node *n)
{
tarval *tv;
ir_node *oldn = n;
tv = computed_value(n);
if (tv != tarval_bad) {
ir_node *nw;
- type *old_tp = get_irn_type(n);
+ ir_type *old_tp = get_irn_type(n);
int i, arity = get_irn_arity(n);
int node_size;
edges_node_deleted(n, current_ir_graph);
/* evaluation was successful -- replace the node. */
- obstack_free(current_ir_graph->obst, n);
+ irg_kill_node(current_ir_graph, n);
nw = new_Const(get_tarval_mode (tv), tv);
if (old_tp && get_type_mode(old_tp) == get_tarval_mode (tv))
edges_node_deleted(oldn, current_ir_graph);
/* We found an existing, better node, so we can deallocate the old node. */
- obstack_free (current_ir_graph->obst, oldn);
-
+ irg_kill_node(current_ir_graph, oldn);
return n;
}
* 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_node *optimize_in_place_2(ir_node *n)
{
tarval *tv;
ir_node *oldn = n;
tv = computed_value(n);
if (tv != tarval_bad) {
/* evaluation was successful -- replace the node. */
- type *old_tp = get_irn_type(n);
+ ir_type *old_tp = get_irn_type(n);
int i, arity = get_irn_arity(n);
/*
/**
* Wrapper for external use, set proper status bits after optimization.
*/
-ir_node *
-optimize_in_place (ir_node *n)
+ir_node *optimize_in_place(ir_node *n)
{
/* Handle graph state */
assert(get_irg_phase_state(current_ir_graph) != phase_building);
if (get_irg_outs_state(current_ir_graph) == outs_consistent)
set_irg_outs_inconsistent(current_ir_graph);
- /* Maybe we could also test whether optimizing the node can
+ /* FIXME: Maybe we could also test whether optimizing the node can
change the control graph. */
- if (get_irg_dom_state(current_ir_graph) == dom_consistent)
- set_irg_dom_inconsistent(current_ir_graph);
+ set_irg_doms_inconsistent(current_ir_graph);
return optimize_in_place_2 (n);
}
-/**
- * set the default ir op operations
+/*
+ * Sets the default operation for an ir_ops.
*/
-ir_op *firm_set_default_operations(ir_op *op)
+ir_op_ops *firm_set_default_operations(opcode code, ir_op_ops *ops)
{
- op = firm_set_default_computed_value(op);
- op = firm_set_default_equivalent_node(op);
- op = firm_set_default_transform_node(op);
- op = firm_set_default_node_cmp_attr(op);
- op = firm_set_default_get_type(op);
+ 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 op;
+ return ops;
}