}
else if ((n_preds == 1) &&
(get_irn_op(skip_Proj(get_Block_cfgpred(n, 0))) == op_Cond)) {
- ir_node *predblock = get_nodes_block(get_Block_cfgpred(n, 0));
+ ir_node *predblock = get_Block_cfgpred_block(n, 0);
if (predblock == oldn) {
/* Jmp jumps into the block it is in -- deal self cycle. */
n = set_Block_dead(n);
(get_irn_mode(get_Cond_selector(get_Proj_pred(a))) == mode_b)) {
/* Also a single entry Block following a single exit Block. Phis have
twice the same operand and will be optimized away. */
- n = get_nodes_block(a);
+ n = get_nodes_block(get_Proj_pred(a));
DBG_OPT_IFSIM1(oldn, a, b, n);
}
}
else if (get_opt_unreachable_code() &&
(n != current_ir_graph->start_block) &&
(n != current_ir_graph->end_block) ) {
- int i, n_cfg = get_Block_n_cfgpreds(n);
+ int i;
/* If all inputs are dead, this block is dead too, except if it is
- the start or end block. This is a step of unreachable code
+ the start or end block. This is one step of unreachable code
elimination */
- for (i = 0; i < n_cfg; i++) {
+ for (i = get_Block_n_cfgpreds(n) - 1; i >= 0; --i) {
ir_node *pred = get_Block_cfgpred(n, i);
ir_node *pred_blk;
if (is_Bad(pred)) continue;
- pred_blk = get_nodes_block(pred);
+ pred_blk = get_nodes_block(skip_Proj(pred));
if (is_Block_dead(pred_blk)) continue;
break;
}
}
- if (i == n_cfg)
+ if (i < 0) {
n = set_Block_dead(n);
+ DBG_OPT_DEAD_BLOCK(oldn, n);
+ }
}
return n;
*/
static ir_node *equivalent_node_Jmp(ir_node *n)
{
- /* GL: Why not same for op_Raise?? */
/* unreachable code elimination */
if (is_Block_dead(get_nodes_block(n)))
n = new_Bad();
return n;
}
+/* Same for op_Raise */
+#define equivalent_node_Raise equivalent_node_Jmp
+
+
/* We do not evaluate Cond here as we replace it by a new node, a Jmp.
See transform_node_Proj_Cond(). */
return n;
/* If this predecessors constant value is zero, the operation is
- unnecessary. Remove it: */
+ * unnecessary. Remove it.
+ *
+ * Beware: If n is a Add, the mode of on and n might be different
+ * which happens in this rare construction: NULL + 3.
+ * Then, a Conv would be needed which we cannot include here.
+ */
if (classify_tarval (tv) == TV_CLASSIFY_NULL) {
- n = on;
+ if (get_irn_mode(on) == get_irn_mode(n)) {
+ n = on;
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
+ }
}
return n;
*
* The second one looks strange, but this construct
* is used heavily in the LCC sources :-).
+ *
+ * Beware: The Mode of an Add may be different than the mode of its
+ * predecessors, so we could not return a predecessors in all cases.
*/
static ir_node *equivalent_node_Add(ir_node *n)
{
/* (a - x) + x */
n = get_Sub_left(left);
- DBG_OPT_ALGSIM1(oldn, left, right, n, FS_OPT_ADD_SUB);
-
- return n;
+ if (get_irn_mode(oldn) == get_irn_mode(n)) {
+ DBG_OPT_ALGSIM1(oldn, left, right, n, FS_OPT_ADD_SUB);
+ return n;
+ }
}
}
if (get_irn_op(right) == op_Sub) {
if (get_Sub_right(right) == left) {
/* x + (a - x) */
- n = get_Sub_left(left);
- DBG_OPT_ALGSIM1(oldn, left, right, n, FS_OPT_ADD_SUB);
-
- return n;
+ n = get_Sub_left(right);
+ if (get_irn_mode(oldn) == get_irn_mode(n)) {
+ DBG_OPT_ALGSIM1(oldn, left, right, n, FS_OPT_ADD_SUB);
+ return n;
+ }
}
}
return n;
*
* The second one looks strange, but this construct
* is used heavily in the LCC sources :-).
+ *
+ * Beware: The Mode of a Sub may be different than the mode of its
+ * predecessors, so we could not return a predecessors in all cases.
*/
static ir_node *equivalent_node_Sub(ir_node *n)
{
ir_node *a = get_Sub_left(n);
ir_node *b = get_Sub_right(n);
+ /* Beware: modes might be different */
if (classify_tarval(value_of(b)) == TV_CLASSIFY_NULL) {
- n = a;
+ if (get_irn_mode(n) == get_irn_mode(a)) {
+ n = a;
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
+ }
}
else if (get_irn_op(a) == op_Add) {
ir_mode *mode = get_irn_mode(n);
ir_node *right = get_Add_right(a);
if (left == b) {
- n = right;
-
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
+ if (get_irn_mode(n) == get_irn_mode(right)) {
+ n = right;
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
+ }
}
else if (right == b) {
- n = left;
-
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
+ if (get_irn_mode(n) == get_irn_mode(left)) {
+ n = left;
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
+ }
}
}
}
assert(0); /* This should not happen! */
n = new_Bad();
}
- } else if (get_irn_mode(n) == mode_X &&
- is_Block_dead(get_nodes_block(n))) {
- /* Remove dead control flow -- early gigo(). */
- n = new_Bad();
}
+ else if (get_irn_mode(n) == mode_X) {
+ if (is_Block_dead(get_nodes_block(skip_Proj(n)))) {
+ /* Remove dead control flow -- early gigo(). */
+ n = new_Bad();
+ }
+ }
+
return n;
}
}
}
}
-
return n;
}
/**
* Remove Confirm nodes if setting is on.
+ * Replace Confirms(x, '=', Constlike) by Constlike.
*/
static ir_node *equivalent_node_Confirm(ir_node *n)
{
- if (get_Confirm_cmp(n) == pn_Cmp_Eq) {
+ ir_node *pred = get_Confirm_value(n);
+ pn_Cmp pnc = get_Confirm_cmp(n);
+
+ if (get_irn_op(pred) == op_Confirm && pnc == get_Confirm_cmp(pred)) {
+ /*
+ * rare case: two identical Confirms one after another,
+ * replace the second one with the first.
+ */
+ return pred;
+ }
+ if (pnc == pn_Cmp_Eq) {
ir_node *bound = get_Confirm_bound(n);
- ir_op *op = get_irn_op(bound);
/*
* Optimize a rare case:
- * Confirm(x, '=', Const) ==> Const
+ * Confirm(x, '=', Constlike) ==> Constlike
*/
- if (op == op_Const || op == op_SymConst)
+ if (is_irn_constlike(bound)) {
+ DBG_OPT_CONFIRM(n, bound);
return bound;
+ }
}
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_Call_M_except, new_Bad());
+ }
+ return n;
+}
+
/**
* equivalent_node() returns a node equivalent to input n. It skips all nodes that
* perform no actual computation, as, e.g., the Id nodes. It does not create
switch (op->code) {
CASE(Block);
CASE(Jmp);
+ CASE(Raise);
CASE(Or);
CASE(Add);
CASE(Eor);
CASE(Mux);
CASE(Cmp);
CASE(Confirm);
+ CASE(CopyB);
default:
op->equivalent_node = NULL;
}
ir_node *a = get_Add_left(n);
if (a == get_Add_right(n)) {
- ir_node *block = get_nodes_block(n);
+ ir_node *block = get_irn_n(n, -1);
n = new_rd_Mul(
get_irn_dbg_info(n),
n = new_rd_Sub(
get_irn_dbg_info(n),
current_ir_graph,
- get_nodes_block(n),
+ get_irn_n(n, -1),
b,
get_Minus_op(a),
mode);
n = new_rd_Sub(
get_irn_dbg_info(n),
current_ir_graph,
- get_nodes_block(n),
+ get_irn_n(n, -1),
a,
get_Minus_op(b),
mode);
n = new_rd_Minus(
get_irn_dbg_info(n),
current_ir_graph,
- get_nodes_block(n),
+ get_irn_n(n, -1),
get_Sub_right(n),
mode);
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_SUB_0_A);
else if (value_of(b) == get_mode_minus_one(mode))
r = a;
if (r) {
- n = new_rd_Minus(get_irn_dbg_info(n), current_ir_graph, get_nodes_block(n), r, mode);
+ n = new_rd_Minus(get_irn_dbg_info(n), current_ir_graph, get_irn_n(n, -1), r, mode);
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_MUL_MINUS_1);
return n;
}
/* Turn Div into a tuple (mem, bad, value) */
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());
set_Tuple_pred(n, pn_Div_res, value);
set_Tuple_pred(n, pn_DivMod_X_except, new_Bad()); /* no exception */
set_Tuple_pred(n, pn_DivMod_res_div, a);
set_Tuple_pred(n, pn_DivMod_res_mod, b);
- assert(get_nodes_block(n));
}
return n;
* not run it in the equivalent_node() context.
*/
n = new_rd_Minus(get_irn_dbg_info(n), current_ir_graph,
- get_nodes_block(n), a, mode);
+ get_irn_n(n, -1), a, mode);
DBG_OPT_CONFIRM(oldn, n);
}
ir_node *a = get_Cond_selector(n);
tarval *ta = value_of(a);
+ /* we need block info which is not available in floating irgs */
+ if (get_irg_pinned(current_ir_graph) == op_pin_state_floats)
+ return n;
+
if ((ta != tarval_bad) &&
(get_irn_mode(a) == mode_b) &&
(get_opt_unreachable_code())) {
}
/* We might generate an endless loop, so keep it alive. */
add_End_keepalive(get_irg_end(current_ir_graph), get_nodes_block(n));
- } else if ((ta != tarval_bad) &&
- (get_irn_mode(a) == mode_Iu) &&
- (get_Cond_kind(n) == dense) &&
- (get_opt_unreachable_code())) {
- /* I don't want to allow Tuples smaller than the biggest Proj.
- Also this tuple might get really big...
- I generate the Jmp here, and remember it in link. Link is used
- when optimizing Proj. */
- set_irn_link(n, new_r_Jmp(current_ir_graph, get_nodes_block(n)));
- /* We might generate an endless loop, so keep it alive. */
- add_End_keepalive(get_irg_end(current_ir_graph), get_nodes_block(n));
- } else if ((get_irn_op(a) == op_Eor)
- && (get_irn_mode(a) == mode_b)
- && (classify_tarval(value_of(get_Eor_right(a))) == TV_CLASSIFY_ONE)) {
- /* The Eor is a negate. Generate a new Cond without the negate,
- simulate the negate by exchanging the results. */
- set_irn_link(n, new_r_Cond(current_ir_graph, get_nodes_block(n),
- get_Eor_left(a)));
- } else if ((get_irn_op(a) == op_Not)
- && (get_irn_mode(a) == mode_b)) {
- /* A Not before the Cond. Generate a new Cond without the Not,
- simulate the Not by exchanging the results. */
- set_irn_link(n, new_r_Cond(current_ir_graph, get_nodes_block(n),
- get_Not_op(a)));
}
return n;
}
if (a == b) {
/* a ^ a = 0 */
- n = new_rd_Const(get_irn_dbg_info(n), current_ir_graph, get_nodes_block(n),
+ n = new_rd_Const(get_irn_dbg_info(n), current_ir_graph, get_irn_n(n, -1),
mode, get_mode_null(mode));
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_A_A);
}
&& (classify_tarval (value_of(b)) == TV_CLASSIFY_ONE)
&& (get_irn_op(get_Proj_pred(a)) == op_Cmp)) {
/* The Eor negates a Cmp. The Cmp has the negated result anyways! */
- n = new_r_Proj(current_ir_graph, get_nodes_block(n), get_Proj_pred(a),
+ n = new_r_Proj(current_ir_graph, get_irn_n(n, -1), get_Proj_pred(a),
mode_b, get_negated_pnc(get_Proj_proj(a), mode));
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_TO_NOT_BOOL);
&& (classify_tarval (value_of(b)) == TV_CLASSIFY_ONE)) {
/* The Eor is a Not. Replace it by a Not. */
/* ????!!!Extend to bitfield 1111111. */
- n = new_r_Not(current_ir_graph, get_nodes_block(n), a, mode_b);
+ n = new_r_Not(current_ir_graph, get_irn_n(n, -1), a, mode_b);
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_TO_NOT);
}
&& (get_irn_mode(a) == mode_b)
&& (get_irn_op(get_Proj_pred(a)) == op_Cmp)) {
/* We negate a Cmp. The Cmp has the negated result anyways! */
- n = new_r_Proj(current_ir_graph, get_nodes_block(n), get_Proj_pred(a),
+ n = new_r_Proj(current_ir_graph, get_irn_n(n, -1), get_Proj_pred(a),
mode_b, get_negated_pnc(get_Proj_proj(a), mode_b));
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_NOT_CMP);
}
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_nodes_block(pred), get_irn_mode(pred),
+ n = new_rd_Const_type(NULL, current_ir_graph, get_irn_n(pred, -1), get_irn_mode(pred),
get_Const_tarval(pred), tp);
DBG_OPT_CSTEVAL(oldn, n);
} else if ((get_irn_op(pred) == op_SymConst) && (get_SymConst_value_type(pred) != tp)) {
- n = new_rd_SymConst_type(NULL, current_ir_graph, get_nodes_block(pred), get_SymConst_symbol(pred),
+ n = new_rd_SymConst_type(NULL, current_ir_graph, get_irn_n(pred, -1), get_SymConst_symbol(pred),
get_SymConst_kind(pred), tp);
DBG_OPT_CSTEVAL(oldn, n);
}
if (proj_nr == pn_Div_X_except) {
/* we found an exception handler, remove it */
return new_Bad();
- } else {
+ } else if (proj_nr == pn_Div_M) {
/* the memory Proj can be removed */
ir_node *res = get_Div_mem(n);
set_Div_mem(n, get_irg_no_mem(current_ir_graph));
- if (proj_nr == pn_Div_M)
- return res;
+
+ return res;
}
}
return proj;
if (proj_nr == pn_Mod_X_except) {
/* we found an exception handler, remove it */
return new_Bad();
- } else {
+ } 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));
- if (proj_nr == pn_Mod_M)
- return res;
+
+ return res;
+ }
+ else if (proj_nr == pn_Mod_res && get_Mod_left(n) == b) {
+ /* a % a = 0 if a != 0 */
+ ir_mode *mode = get_irn_mode(proj);
+ ir_node *res = new_Const(mode, get_mode_null(mode));
+
+ DBG_OPT_CSTEVAL(n, res);
+ return res;
}
}
return proj;
/* we found an exception handler, remove it */
return new_Bad();
}
- else {
+ 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));
- if (proj_nr == pn_DivMod_M)
- return res;
+
+ return res;
+ }
+ else if (proj_nr == pn_DivMod_res_mod && get_DivMod_left(n) == b) {
+ /* a % a = 0 if a != 0 */
+ ir_mode *mode = get_irn_mode(proj);
+ ir_node *res = new_Const(mode, get_mode_null(mode));
+
+ DBG_OPT_CSTEVAL(n, res);
+ return res;
}
}
return proj;
if (get_opt_unreachable_code()) {
ir_node *n = get_Proj_pred(proj);
ir_node *b = get_Cond_selector(n);
- tarval *tb = value_of(b);
- if (tb != tarval_bad && mode_is_int(get_tarval_mode(tb))) {
- /* we have a constant switch */
- long num = get_Proj_proj(proj);
+ if (mode_is_int(get_irn_mode(b))) {
+ tarval *tb = value_of(b);
- if (num != get_Cond_defaultProj(n)) { /* we cannot optimize default Proj's yet */
- if (get_tarval_long(tb) == num) {
- /* Do NOT create a jump here, or we will have 2 control flow ops
- * in a block. This case is optimized away in optimize_cf(). */
- return proj;
- }
- else {
- /* this case will NEVER be taken, kill it */
- return new_Bad();
+ if (tb != tarval_bad) {
+ /* we have a constant switch */
+ long num = get_Proj_proj(proj);
+
+ if (num != get_Cond_defaultProj(n)) { /* we cannot optimize default Proj's yet */
+ if (get_tarval_long(tb) == num) {
+ /* Do NOT create a jump here, or we will have 2 control flow ops
+ * in a block. This case is optimized away in optimize_cf(). */
+ return proj;
+ }
+ else {
+ /* this case will NEVER be taken, kill it */
+ return new_Bad();
+ }
}
}
}
if (mode_is_int(mode)) {
/* Ne includes Unordered which is not possible on integers.
* However, frontends often use this wrong, so fix it here */
- if (proj_nr == pn_Cmp_Ne) {
- proj_nr = pn_Cmp_Lg;
+ if (proj_nr & pn_Cmp_Uo) {
+ proj_nr &= ~pn_Cmp_Uo;
set_Proj_proj(proj, proj_nr);
}
}
if (changed) {
- ir_node *block = get_nodes_block(n);
+ ir_node *block = get_irn_n(n, -1); /* Beware of get_nodes_Block() */
if (changed & 2) /* need a new Const */
right = new_Const(mode, tv);
}
/* ok, all conditions met */
- block = get_nodes_block(or);
+ block = get_irn_n(or, -1);
new_and = new_r_And(current_ir_graph, block,
value, new_r_Const(current_ir_graph, block, mode, tarval_and(tv4, tv2)), mode);
return or;
/* yet, condition met */
- block = get_nodes_block(or);
+ block = get_irn_n(or, -1);
n = new_r_Rot(current_ir_graph, block, x, c1, mode);
return or;
/* yet, condition met */
- block = get_nodes_block(or);
+ block = get_irn_n(or, -1);
/* a Rot Left */
n = new_r_Rot(current_ir_graph, block, x, v, mode);
if (flag) {
/* ok, we can replace it */
- ir_node *in[2], *irn, *block = get_nodes_block(n);
+ ir_node *in[2], *irn, *block = get_irn_n(n, -1);
in[0] = get_binop_left(left);
in[1] = new_r_Const(current_ir_graph, block, get_tarval_mode(res), res);
#define transform_node_Shl transform_node_shift
/**
- * Remove dead blocks in keep alive list. We do not generate a new End node.
+ * Remove dead blocks and nodes in dead blocks
+ * in keep alive list. We do not generate a new End node.
*/
static ir_node *transform_node_End(ir_node *n) {
int i, n_keepalives = get_End_n_keepalives(n);
for (i = 0; i < n_keepalives; ++i) {
ir_node *ka = get_End_keepalive(n, i);
- if (is_Block(ka) && is_Block_dead(ka))
+ if (is_Block(ka)) {
+ if (is_Block_dead(ka)) {
+ set_End_keepalive(n, i, new_Bad());
+ }
+ }
+ else if (is_irn_pinned_in_irg(ka) && is_Block_dead(get_nodes_block(ka)))
set_End_keepalive(n, i, new_Bad());
}
return n;
ir_node *t = get_Mux_true(n);
if (get_irn_op(cmp) == op_Cmp && classify_Const(get_Cmp_right(cmp)) == CNST_NULL) {
- ir_node *block = get_nodes_block(n);
+ ir_node *block = get_irn_n(n, -1);
/*
* Note: normalization puts the constant on the right site,
gigo (ir_node *node)
{
int i, irn_arity;
- ir_op* op = get_irn_op(node);
+ ir_op *op = get_irn_op(node);
/* remove garbage blocks by looking at control flow that leaves the block
and replacing the control flow by Bad. */
if (get_irn_mode(node) == mode_X) {
- ir_node *block = get_nodes_block(node);
- if (!get_Block_matured(block)) return node; /* Don't optimize nodes in immature blocks. */
- if (op == op_End) return node; /* Don't optimize End, may have Bads. */
+ ir_node *block = get_nodes_block(skip_Proj(node));
- if (get_irn_op(block) == op_Block && get_Block_matured(block)) {
+ /* Don't optimize nodes in immature blocks. */
+ if (!get_Block_matured(block)) return node;
+ /* Don't optimize End, may have Bads. */
+ if (op == op_End) return node;
+
+ if (is_Block(block)) {
irn_arity = get_irn_arity(block);
for (i = 0; i < irn_arity; i++) {
- if (!is_Bad(get_irn_n(block, i))) break;
+ if (!is_Bad(get_irn_n(block, i)))
+ break;
}
if (i == irn_arity) return new_Bad();
}
if ( op != op_Block && op != op_Phi && op != op_Tuple) {
irn_arity = get_irn_arity(node);
- if (is_Block_dead(get_nodes_block(node)))
+ /*
+ * Beware: we can only read the block of a non-floating node.
+ */
+ if (is_irn_pinned_in_irg(node) &&
+ is_Block_dead(get_nodes_block(node)))
return new_Bad();
for (i = 0; i < irn_arity; i++) {
- if (is_Bad(get_irn_n(node, i))) {
+ ir_node *pred = get_irn_n(node, i);
+
+ if (is_Bad(pred))
return new_Bad();
- }
+ if (is_Unknown(pred) && mode_is_data(get_irn_mode(node)))
+ return new_Unknown(get_irn_mode(node));
}
}
#if 0
* 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.
+ *
+ * current_ir_graph must be set to the graph of the node!
*/
ir_node *
optimize_node(ir_node *n)
Run always for transformation induced Bads. */
n = gigo (n);
- /* Now we have a legal, useful node. Enter it in hash table for cse */
+ /* Now we have a legal, useful node. Enter it in hash table for CSE */
if (get_opt_cse() && (get_irn_opcode(n) != iro_Block)) {
n = identify_remember (current_ir_graph->value_table, n);
}
projects / libfirm / blobdiff