* Modified by: Goetz Lindenmaier, Michael Beck
* Created:
* CVS-ID: $Id$
- * Copyright: (c) 1998-2005 Universität Karlsruhe
+ * Copyright: (c) 1998-2006 Universität Karlsruhe
* Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
*/
#include "irtools.h"
/* Make types visible to allow most efficient access */
-# include "entity_t.h"
+#include "entity_t.h"
/**
- * return the value of a Constant
+ * Return the value of a Constant.
*/
-static tarval *computed_value_Const(ir_node *n)
-{
+static tarval *computed_value_Const(ir_node *n) {
return get_Const_tarval(n);
-}
+} /* computed_value_Const */
/**
- * return the value of a 'sizeof' SymConst
+ * Return the value of a 'sizeof' or 'alignof' SymConst.
*/
-static tarval *computed_value_SymConst(ir_node *n)
-{
+static tarval *computed_value_SymConst(ir_node *n) {
ir_type *type;
+ entity *ent;
switch (get_SymConst_kind(n)) {
case symconst_type_size:
if (get_type_state(type) == layout_fixed)
return new_tarval_from_long(get_type_alignment_bytes(type), get_irn_mode(n));
break;
+ case symconst_ofs_ent:
+ ent = get_SymConst_entity(n);
+ type = get_entity_owner(ent);
+ if (get_type_state(type) == layout_fixed)
+ return new_tarval_from_long(get_entity_offset(ent), get_irn_mode(n));
+ break;
default:
break;
}
return tarval_bad;
-}
+} /* computed_value_SymConst */
/**
- * return the value of an Add
+ * Return the value of an Add.
*/
-static tarval *computed_value_Add(ir_node *n)
-{
+static tarval *computed_value_Add(ir_node *n) {
ir_node *a = get_Add_left(n);
ir_node *b = get_Add_right(n);
return tarval_add(ta, tb);
return tarval_bad;
-}
+} /* computed_value_Add */
/**
- * return the value of a Sub
+ * Return the value of a Sub.
* Special case: a - a
*/
-static tarval *computed_value_Sub(ir_node *n)
-{
+static tarval *computed_value_Sub(ir_node *n) {
ir_node *a = get_Sub_left(n);
ir_node *b = get_Sub_right(n);
tarval *ta;
return tarval_sub(ta, tb);
return tarval_bad;
-}
+} /* computed_value_Sub */
/**
- * return the value of a Carry
+ * Return the value of a Carry.
* Special : a op 0, 0 op b
*/
-static tarval *computed_value_Carry(ir_node *n)
-{
+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);
return get_mode_null(m);
}
return tarval_bad;
-}
+} /* computed_value_Carry */
/**
- * return the value of a Borrow
+ * Return the value of a Borrow.
* Special : a op 0
*/
-static tarval *computed_value_Borrow(ir_node *n)
-{
+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);
return get_mode_null(m);
}
return tarval_bad;
-}
+} /* computed_value_Borrow */
/**
- * return the value of an unary Minus
+ * Return the value of an unary Minus.
*/
-static tarval *computed_value_Minus(ir_node *n)
-{
+static tarval *computed_value_Minus(ir_node *n) {
ir_node *a = get_Minus_op(n);
tarval *ta = value_of(a);
return tarval_neg(ta);
return tarval_bad;
-}
+} /* computed_value_Minus */
/**
- * return the value of a Mul
+ * Return the value of a Mul.
*/
-static tarval *computed_value_Mul(ir_node *n)
-{
+static tarval *computed_value_Mul(ir_node *n) {
ir_node *a = get_Mul_left(n);
ir_node *b = get_Mul_right(n);
return tb;
}
return tarval_bad;
-}
+} /* computed_value_Mul */
/**
- * return the value of a floating point Quot
+ * Return the value of a floating point Quot.
*/
-static tarval *computed_value_Quot(ir_node *n)
-{
+static tarval *computed_value_Quot(ir_node *n) {
ir_node *a = get_Quot_left(n);
ir_node *b = get_Quot_right(n);
return tarval_quo(ta, tb);
}
return tarval_bad;
-}
+} /* computed_value_Quot */
/**
- * calculate the value of an integer Div of two nodes
+ * Calculate the value of an integer Div of two nodes.
* Special case: 0 / b
*/
-static tarval *do_computed_value_Div(ir_node *a, ir_node *b)
-{
+static tarval *do_computed_value_Div(ir_node *a, ir_node *b) {
tarval *ta = value_of(a);
tarval *tb = value_of(b);
return ta;
}
return tarval_bad;
-}
+} /* do_computed_value_Div */
/**
- * return the value of an integer Div
+ * Return the value of an integer Div.
*/
-static tarval *computed_value_Div(ir_node *n)
-{
+static tarval *computed_value_Div(ir_node *n) {
return do_computed_value_Div(get_Div_left(n), get_Div_right(n));
-}
+} /* computed_value_Div */
/**
- * calculate the value of an integer Mod of two nodes
+ * Calculate the value of an integer Mod of two nodes.
* Special case: a % 1
*/
-static tarval *do_computed_value_Mod(ir_node *a, ir_node *b)
-{
+static tarval *do_computed_value_Mod(ir_node *a, ir_node *b) {
tarval *ta = value_of(a);
tarval *tb = value_of(b);
else if (tb == get_mode_one(get_tarval_mode(tb))) /* x mod 1 == 0 */
return get_mode_null(get_irn_mode(a));
}
-
return tarval_bad;
-}
+} /* do_computed_value_Mod */
/**
- * return the value of an integer Mod
+ * Return the value of an integer Mod.
*/
-static tarval *computed_value_Mod(ir_node *n)
-{
+static tarval *computed_value_Mod(ir_node *n) {
return do_computed_value_Mod(get_Mod_left(n), get_Mod_right(n));
-}
+} /* computed_value_Mod */
/**
- * return the value of an Abs
+ * Return the value of an Abs.
*/
-static tarval *computed_value_Abs(ir_node *n)
-{
+static tarval *computed_value_Abs(ir_node *n) {
ir_node *a = get_Abs_op(n);
tarval *ta = value_of(a);
return tarval_abs(ta);
return tarval_bad;
-}
+} /* computed_value_Abs */
/**
- * return the value of an And
+ * Return the value of an And.
* Special case: a & 0, 0 & b
*/
-static tarval *computed_value_And(ir_node *n)
-{
+static tarval *computed_value_And(ir_node *n) {
ir_node *a = get_And_left(n);
ir_node *b = get_And_right(n);
}
}
return tarval_bad;
-}
+} /* computed_value_And */
/**
- * return the value of an Or
+ * Return the value of an Or.
* Special case: a | 1...1, 1...1 | b
*/
-static tarval *computed_value_Or(ir_node *n)
-{
+static tarval *computed_value_Or(ir_node *n) {
ir_node *a = get_Or_left(n);
ir_node *b = get_Or_right(n);
}
}
return tarval_bad;
-}
+} /* computed_value_Or */
/**
- * return the value of an Eor
+ * Return the value of an Eor.
*/
-static tarval *computed_value_Eor(ir_node *n)
-{
+static tarval *computed_value_Eor(ir_node *n) {
ir_node *a = get_Eor_left(n);
ir_node *b = get_Eor_right(n);
return tarval_eor (ta, tb);
}
return tarval_bad;
-}
+} /* computed_value_Eor */
/**
- * return the value of a Not
+ * Return the value of a Not.
*/
-static tarval *computed_value_Not(ir_node *n)
-{
+static tarval *computed_value_Not(ir_node *n) {
ir_node *a = get_Not_op(n);
tarval *ta = value_of(a);
return tarval_not(ta);
return tarval_bad;
-}
+} /* computed_value_Not */
/**
- * return the value of a Shl
+ * Return the value of a Shl.
*/
-static tarval *computed_value_Shl(ir_node *n)
-{
+static tarval *computed_value_Shl(ir_node *n) {
ir_node *a = get_Shl_left(n);
ir_node *b = get_Shl_right(n);
return tarval_shl (ta, tb);
}
return tarval_bad;
-}
+} /* computed_value_Shl */
/**
- * return the value of a Shr
+ * Return the value of a Shr.
*/
-static tarval *computed_value_Shr(ir_node *n)
-{
+static tarval *computed_value_Shr(ir_node *n) {
ir_node *a = get_Shr_left(n);
ir_node *b = get_Shr_right(n);
return tarval_shr (ta, tb);
}
return tarval_bad;
-}
+} /* computed_value_Shr */
/**
- * return the value of a Shrs
+ * Return the value of a Shrs.
*/
-static tarval *computed_value_Shrs(ir_node *n)
-{
+static tarval *computed_value_Shrs(ir_node *n) {
ir_node *a = get_Shrs_left(n);
ir_node *b = get_Shrs_right(n);
return tarval_shrs (ta, tb);
}
return tarval_bad;
-}
+} /* computed_value_Shrs */
/**
- * return the value of a Rot
+ * Return the value of a Rot.
*/
static tarval *computed_value_Rot(ir_node *n)
{
return tarval_rot (ta, tb);
}
return tarval_bad;
-}
+} /* computed_value_Rot */
/**
- * return the value of a Conv
+ * Return the value of a Conv.
*/
static tarval *computed_value_Conv(ir_node *n)
{
return tarval_convert_to(ta, get_irn_mode(n));
return tarval_bad;
-}
+} /* computed_value_Conv */
/**
- * return the value of a Proj(Cmp)
+ * Return the value of a Proj(Cmp).
*
* This performs a first step of unreachable code elimination.
* Proj can not be computed, but folding a Cmp above the Proj here is
}
}
return computed_value_Cmp_Confirm(a, aa, ab, proj_nr);
-}
+} /* computed_value_Proj_Cmp */
/**
- * return the value of a Proj, handle Proj(Cmp), Proj(Div), Proj(Mod), Proj(DivMod)
+ * Return the value of a Proj, handle Proj(Cmp), Proj(Div), Proj(Mod),
+ * Proj(DivMod) and Proj(Quot).
*/
-static tarval *computed_value_Proj(ir_node *n)
-{
+static tarval *computed_value_Proj(ir_node *n) {
ir_node *a = get_Proj_pred(n);
long proj_nr;
return computed_value(a);
break;
+ case iro_Quot:
+ if (get_Proj_proj(n) == pn_Quot_res)
+ return computed_value(a);
+ break;
+
default:
return tarval_bad;
}
return tarval_bad;
-}
+} /* computed_value_Proj */
/**
- * calculate the value of a Mux: can be evaluated, if the
- * sel and the right input are known
+ * Calculate the value of a Mux: can be evaluated, if the
+ * sel and the right input are known.
*/
-static tarval *computed_value_Mux(ir_node *n)
-{
+static tarval *computed_value_Mux(ir_node *n) {
ir_node *sel = get_Mux_sel(n);
tarval *ts = value_of(sel);
return value_of(v);
}
return tarval_bad;
-}
+} /* computed_value_Mux */
/**
* 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)
-{
+static tarval *computed_value_Psi(ir_node *n) {
if (is_Mux(n))
return computed_value_Mux(n);
return tarval_bad;
-}
+} /* computed_value_Psi */
/**
- * calculate the value of a Confirm: can be evaluated,
+ * Calculate the value of a Confirm: can be evaluated,
* if it has the form Confirm(x, '=', Const).
*/
-static tarval *computed_value_Confirm(ir_node *n)
-{
+static tarval *computed_value_Confirm(ir_node *n) {
return get_Confirm_cmp(n) == pn_Cmp_Eq ?
value_of(get_Confirm_bound(n)) : tarval_bad;
-}
+} /* computed_value_Confirm */
/**
* If the parameter n can be computed, return its value, else tarval_bad.
*
* @param n The node this should be evaluated
*/
-tarval *computed_value(ir_node *n)
-{
+tarval *computed_value(ir_node *n) {
if (n->op->ops.computed_value)
return n->op->ops.computed_value(n);
return tarval_bad;
-}
+} /* computed_value */
/**
- * set the default computed_value evaluator in an ir_op_ops.
+ * 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 ops;
#undef CASE
-}
+} /* firm_set_default_computed_value */
/**
* Returns a equivalent block for another block.
}
return n;
-}
+} /* equivalent_node_Block */
/**
* Returns a equivalent node for a Jmp, a Bad :-)
* Of course this only happens if the Block of the Jmp is dead.
*/
-static ir_node *equivalent_node_Jmp(ir_node *n)
-{
+static ir_node *equivalent_node_Jmp(ir_node *n) {
/* unreachable code elimination */
if (is_Block_dead(get_nodes_block(n)))
n = new_Bad();
return n;
-}
+} /* equivalent_node_Jmp */
/** Raise is handled in the same way as Jmp. */
#define equivalent_node_Raise equivalent_node_Jmp
See transform_node_Proj_Cond(). */
/**
- * optimize operations that are commutative and have neutral 0,
+ * Optimize operations that are commutative and have neutral 0,
* so a op 0 = 0 op a = a.
*/
static ir_node *equivalent_node_neutral_zero(ir_node *n)
}
return n;
-}
+} /* equivalent_node_neutral_zero */
/**
* Eor is commutative and has neutral 0.
}
}
return n;
-}
+} /* equivalent_node_Add */
/**
* optimize operations that are not commutative but have neutral 0 on left,
* so a op 0 = a.
*/
-static ir_node *equivalent_node_left_zero(ir_node *n)
-{
+static ir_node *equivalent_node_left_zero(ir_node *n) {
ir_node *oldn = n;
ir_node *a = get_binop_left(n);
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
}
-
return n;
-}
+} /* equivalent_node_left_zero */
#define equivalent_node_Shl equivalent_node_left_zero
#define equivalent_node_Shr equivalent_node_left_zero
}
}
return n;
-}
+} /* equivalent_node_Sub */
/**
DBG_OPT_ALGSIM2(oldn, pred, n);
}
return n;
-}
+} /* equivalent_node_idempotent_unop */
-/** Not(Not(x)) == x */
+/** Optimize Not(Not(x)) == x. */
#define equivalent_node_Not equivalent_node_idempotent_unop
/** --x == x ??? Is this possible or can --x raise an
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_1);
}
return n;
-}
+} /* equivalent_node_Mul */
/**
* Optimize a / 1 = a.
*/
-static ir_node *equivalent_node_Div(ir_node *n)
-{
+static ir_node *equivalent_node_Div(ir_node *n) {
ir_node *a = get_Div_left(n);
ir_node *b = get_Div_right(n);
set_Tuple_pred(n, pn_Div_res, a);
}
return n;
-}
+} /* equivalent_node_Div */
/**
* Optimize a / 1.0 = a.
*/
static ir_node *equivalent_node_Quot(ir_node *n) {
- ir_node *a = get_Div_left(n);
- ir_node *b = get_Div_right(n);
+ ir_node *a = get_Quot_left(n);
+ ir_node *b = get_Quot_right(n);
/* Div is not commutative. */
if (classify_tarval(value_of(b)) == TV_CLASSIFY_ONE) { /* Quot(x, 1) == x */
set_Tuple_pred(n, pn_Quot_res, a);
}
return n;
-}
+} /* equivalent_node_Quot */
/**
* Optimize a / 1 = a.
*/
-static ir_node *equivalent_node_DivMod(ir_node *n)
-{
+static ir_node *equivalent_node_DivMod(ir_node *n) {
ir_node *a = get_DivMod_left(n);
ir_node *b = get_DivMod_right(n);
set_Tuple_pred(n, pn_DivMod_res_mod, new_Const(mode, get_mode_null(mode)));
}
return n;
-}
+} /* equivalent_node_DivMod */
/**
* Use algebraic simplification a | a = a | 0 = 0 | a = a.
*/
-static ir_node *equivalent_node_Or(ir_node *n)
-{
+static ir_node *equivalent_node_Or(ir_node *n) {
ir_node *oldn = n;
ir_node *a = get_Or_left(n);
}
return n;
-}
+} /* equivalent_node_Or */
/**
* Optimize a & 0b1...1 = 0b1...1 & a = a & a = a.
*/
-static ir_node *equivalent_node_And(ir_node *n)
-{
+static ir_node *equivalent_node_And(ir_node *n) {
ir_node *oldn = n;
ir_node *a = get_And_left(n);
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_AND);
}
return n;
-}
+} /* equivalent_node_And */
/**
* Try to remove useless Conv's:
*/
-static ir_node *equivalent_node_Conv(ir_node *n)
-{
+static ir_node *equivalent_node_Conv(ir_node *n) {
ir_node *oldn = n;
ir_node *a = get_Conv_op(n);
ir_node *b;
}
}
return n;
-}
+} /* equivalent_node_Conv */
/**
* A Cast may be removed if the type of the previous node
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CAST);
}
return n;
-}
+} /* equivalent_node_Cast */
/**
- 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.
+ * 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)
{
DBG_OPT_PHI(oldn, n);
}
return n;
-}
+} /* equivalent_node_Phi */
/**
- Several optimizations:
- - no Sync in start block.
- - fold Sync-nodes, iff they have only one predecessor except
- themselves.
+ * Several optimizations:
+ * - no Sync in start block.
+ * - fold Sync-nodes, iff they have only one predecessor except
+ * themselves.
*/
static ir_node *equivalent_node_Sync(ir_node *n)
{
DBG_OPT_SYNC(oldn, n);
}
return n;
-}
+} /* equivalent_node_Sync */
/**
- * optimize Proj(Tuple) and gigo() for ProjX in Bad block,
- * ProjX(Load) and ProjX(Store)
+ * Optimize Proj(Tuple) and gigo() for ProjX in Bad block,
+ * ProjX(Load) and ProjX(Store).
*/
static ir_node *equivalent_node_Proj(ir_node *n)
{
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);
+ 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(a, op_pin_state_floats);
+ }
DBG_OPT_EXC_REM(n);
return new_Bad();
}
}
return n;
-}
+} /* equivalent_node_Proj */
/**
* Remove Id's.
*/
-static ir_node *equivalent_node_Id(ir_node *n)
-{
+static ir_node *equivalent_node_Id(ir_node *n) {
ir_node *oldn = n;
do {
DBG_OPT_ID(oldn, n);
return n;
-}
+} /* equivalent_node_Id */
/**
- * optimize a Mux
+ * Optimize a Mux.
*/
static ir_node *equivalent_node_Mux(ir_node *n)
{
}
}
return n;
-}
+} /* equivalent_node_Mux */
/**
* Returns a equivalent node of a Psi: if a condition is true
if (is_Mux(n))
return equivalent_node_Mux(n);
return n;
-}
+} /* equivalent_node_Psi */
/**
* Optimize -a CMP -b into b CMP a.
set_Cmp_right(n, left);
}
return n;
-}
+} /* equivalent_node_Cmp */
/**
* Remove Confirm nodes if setting is on.
* Replace Confirms(x, '=', Constlike) by Constlike.
*/
-static ir_node *equivalent_node_Confirm(ir_node *n)
-{
+static ir_node *equivalent_node_Confirm(ir_node *n) {
ir_node *pred = get_Confirm_value(n);
pn_Cmp pnc = get_Confirm_cmp(n);
}
/**
- * Optimize CopyB(mem, x, x) into a Nop
+ * Optimize CopyB(mem, x, x) into a Nop.
*/
-static ir_node *equivalent_node_CopyB(ir_node *n)
-{
+static ir_node *equivalent_node_CopyB(ir_node *n) {
ir_node *a = get_CopyB_dst(n);
ir_node *b = get_CopyB_src(n);
set_Tuple_pred(n, pn_CopyB_M_except, new_Bad());
}
return n;
-}
+} /* equivalent_node_CopyB */
/**
* Optimize Bounds(idx, idx, upper) into idx.
*/
-static ir_node *equivalent_node_Bound(ir_node *n)
-{
+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;
set_Tuple_pred(n, pn_Bound_res, idx);
}
return n;
-}
+} /* equivalent_node_Bound */
/**
* equivalent_node() returns a node equivalent to input n. It skips all nodes that
* If a node returns a Tuple we can not just skip it. If the size of the
* in array fits, we transform n into a tuple (e.g., Div).
*/
-ir_node *
-equivalent_node(ir_node *n)
-{
+ir_node *equivalent_node(ir_node *n) {
if (n->op->ops.equivalent_node)
return n->op->ops.equivalent_node(n);
return n;
-}
+} /* equivalent_node */
/**
- * sets the default equivalent node operation for an ir_op_ops.
+ * 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 ops;
#undef CASE
-}
+} /* firm_set_default_equivalent_node */
/**
* Do node specific optimizations of nodes predecessors.
*/
-static void
-optimize_preds(ir_node *n) {
+static void optimize_preds(ir_node *n) {
ir_node *a = NULL, *b = NULL;
/* get the operands we will work on for simple cases. */
default: break;
} /* end switch */
-}
+} /* optimize_preds */
/**
* Returns non-zero if a node is a Phi node
if (! is_Const(get_irn_n(n, i)))
return 0;
return 1;
-}
+} /* is_const_Phi */
/**
* Apply an evaluator on a binop with a constant operators (and one Phi).
irg = current_ir_graph;
for (i = 0; i < n; ++i) {
pred = get_irn_n(phi, i);
- res[i] = new_r_Const_type(irg, get_nodes_block(pred),
- mode, res[i], get_Const_type(pred));
+ res[i] = new_r_Const_type(irg, get_irg_start_block(irg),
+ mode, res[i], get_Const_type(pred));
}
return new_r_Phi(irg, get_nodes_block(phi), n, (ir_node **)res, mode);
-}
+} /* apply_binop_on_phi */
/**
* Apply an evaluator on a unop with a constant operator (a Phi).
irg = current_ir_graph;
for (i = 0; i < n; ++i) {
pred = get_irn_n(phi, i);
- res[i] = new_r_Const_type(irg, get_nodes_block(pred),
- mode, res[i], get_Const_type(pred));
+ res[i] = new_r_Const_type(irg, get_irg_start_block(irg),
+ mode, res[i], get_Const_type(pred));
}
return new_r_Phi(irg, get_nodes_block(phi), n, (ir_node **)res, mode);
-}
+} /* apply_unop_on_phi */
/**
* Transform AddP(P, ConvIs(Iu)), AddP(P, ConvIu(Is)) and
}
}
return n;
-}
+} /* transform_node_AddSub */
#define HANDLE_BINOP_PHI(op,a,b,c) \
c = NULL; \
}
}
return n;
-}
+} /* transform_node_Add */
/**
* Do the AddSub optimization, then Transform
if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic))
return n;
- if (mode_is_num(mode) && (classify_Const(a) == CNST_NULL)) {
+ /* Beware of Sub(P, P) which cannot be optimized into a simple Minus ... */
+ if (mode_is_num(mode) && mode == get_irn_mode(a) && (classify_Const(a) == CNST_NULL)) {
n = new_rd_Minus(
get_irn_dbg_info(n),
current_ir_graph,
}
return n;
-}
+} /* transform_node_Sub */
/**
* Transform Mul(a,-1) into -a.
}
}
return arch_dep_replace_mul_with_shifts(n);
-}
+} /* transform_node_Mul */
/**
* Transform a Div Node.
set_Tuple_pred(n, pn_Div_res, value);
}
return n;
-}
+} /* transform_node_Div */
/**
* Transform a Mod node.
set_Tuple_pred(n, pn_Mod_res, value);
}
return n;
-}
+} /* transform_node_Mod */
/**
* Transform a DivMod node.
}
return n;
-}
+} /* transform_node_DivMod */
/**
* Optimize Abs(x) into x if x is Confirmed >= 0
{
ir_node *oldn = n;
ir_node *a = get_Abs_op(n);
- value_classify sign = classify_value_sign(a);
+ value_classify_sign sign = classify_value_sign(a);
- if (sign == VALUE_NEGATIVE) {
+ if (sign == value_classified_negative) {
ir_mode *mode = get_irn_mode(n);
/*
DBG_OPT_CONFIRM(oldn, n);
}
- else if (sign == VALUE_POSITIVE) {
+ else if (sign == value_classified_positive) {
/* n is positive, Abs is not needed */
n = a;
}
return n;
-}
+} /* transform_node_Abs */
/**
* Transform a Cond node.
add_End_keepalive(get_irg_end(current_ir_graph), get_nodes_block(n));
}
return n;
-}
+} /* transform_node_Cond */
/**
* Transform an And.
HANDLE_BINOP_PHI(tarval_and, a,b,c);
return n;
-}
+} /* transform_node_And */
/**
* Transform an Eor.
}
return n;
-}
+} /* transform_node_Eor */
/**
* Transform a Not.
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_NOT_CMP);
}
return n;
-}
+} /* transform_node_Not */
/**
* Transform a Minus.
HANDLE_UNOP_PHI(tarval_neg,a,c);
return n;
-}
+} /* transform_node_Minus */
/**
* Transform a Cast_type(Const) into a new Const_type
}
return n;
-}
+} /* transform_node_Cast */
/**
* Transform a Proj(Div) with a non-zero value.
{
ir_node *n = get_Proj_pred(proj);
ir_node *b = get_Div_right(n);
+ ir_node *confirm;
long proj_nr;
- if (value_not_zero(b)) {
+ if (value_not_zero(b, &confirm)) {
/* div(x, y) && y != 0 */
proj_nr = get_Proj_proj(proj);
-
- /* 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);
}
else if (proj_nr == pn_Div_M) {
ir_node *res = get_Div_mem(n);
- /* 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));
+ ir_node *new_mem = get_irg_no_mem(current_ir_graph);
+
+ if (confirm) {
+ /* This node can only float up to the Confirm block */
+ new_mem = new_r_Pin(current_ir_graph, get_nodes_block(confirm), new_mem);
}
+ set_irn_pinned(n, op_pin_state_floats);
+ /* this is a Div without exception, we can remove the memory edge */
+ set_Div_mem(n, new_mem);
return res;
}
}
return proj;
-}
+} /* transform_node_Proj_Div */
/**
* Transform a Proj(Mod) with a non-zero value.
{
ir_node *n = get_Proj_pred(proj);
ir_node *b = get_Mod_right(n);
+ ir_node *confirm;
long proj_nr;
- if (value_not_zero(b)) {
+ if (value_not_zero(b, &confirm)) {
/* mod(x, y) && y != 0 */
proj_nr = get_Proj_proj(proj);
- /* 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) {
ir_node *res = get_Mod_mem(n);
- /* 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));
+ ir_node *new_mem = get_irg_no_mem(current_ir_graph);
+
+ if (confirm) {
+ /* This node can only float up to the Confirm block */
+ new_mem = new_r_Pin(current_ir_graph, get_nodes_block(confirm), new_mem);
}
+ set_irn_pinned(n, op_pin_state_floats);
+ /* this is a Mod without exception, 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) {
}
}
return proj;
-}
+} /* transform_node_Proj_Mod */
/**
* Transform a Proj(DivMod) with a non-zero value.
{
ir_node *n = get_Proj_pred(proj);
ir_node *b = get_DivMod_right(n);
+ ir_node *confirm;
long proj_nr;
- if (value_not_zero(b)) {
+ if (value_not_zero(b, &confirm)) {
/* DivMod(x, y) && y != 0 */
proj_nr = get_Proj_proj(proj);
- /* 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);
}
else if (proj_nr == pn_DivMod_M) {
ir_node *res = get_DivMod_mem(n);
- /* 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));
+ ir_node *new_mem = get_irg_no_mem(current_ir_graph);
+
+ if (confirm) {
+ /* This node can only float up to the Confirm block */
+ new_mem = new_r_Pin(current_ir_graph, get_nodes_block(confirm), new_mem);
}
+ set_irn_pinned(n, op_pin_state_floats);
+ /* this is a DivMod without exception, 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) {
}
}
return proj;
-}
+} /* transform_node_Proj_DivMod */
/**
* Optimizes jump tables (CondIs or CondIu) by removing all impossible cases.
}
}
return proj;
-}
+} /* transform_node_Proj_Cond */
/**
* Normalizes and optimizes Cmp nodes.
}
}
return proj;
-}
+} /* transform_node_Proj_Cmp */
/**
* Does all optimizations on nodes that must be done on it's Proj's
/* do nothing */
return proj;
}
-}
+} /* transform_node_Proj */
/**
* Move Confirms down through Phi nodes.
}
}
return phi;
-}
+} /* transform_node_Phi */
/**
- * returns the operands of a commutative bin-op, if one operand is
+ * Returns the operands of a commutative bin-op, if one operand is
* a const, it is returned as the second one.
*/
static void get_comm_Binop_Ops(ir_node *binop, ir_node **a, ir_node **c)
*a = op_a;
*c = op_b;
}
-}
+} /* get_comm_Binop_Ops */
/**
* Optimize a Or(And(Or(And(v,c4),c3),c2),c1) pattern if possible.
/* check for more */
return transform_node_Or_bf_store(or);
-}
+} /* transform_node_Or_bf_store */
/**
* Optimize an Or(shl(x, c), shr(x, bits - c)) into a Rot
}
return or;
-}
+} /* transform_node_Or_Rot */
/**
* Transform an Or.
n = transform_node_Or_Rot(n);
return n;
-}
+} /* transform_node_Or */
/* forward */
return transform_node(irn);
}
return n;
-}
+} /* transform_node_shift */
/**
* Transform a Shr.
HANDLE_BINOP_PHI(tarval_shr, a, b, c);
return transform_node_shift(n);
-}
+} /* transform_node_Shr */
/**
* Transform a Shrs.
HANDLE_BINOP_PHI(tarval_shrs, a, b, c);
return transform_node_shift(n);
-}
+} /* transform_node_Shrs */
/**
* Transform a Shl.
HANDLE_BINOP_PHI(tarval_shl, a, b, c);
return transform_node_shift(n);
-}
+} /* transform_node_Shl */
/**
* Remove dead blocks and nodes in dead blocks
set_End_keepalive(n, i, new_Bad());
}
return n;
-}
+} /* transform_node_End */
/**
* Optimize a Mux into some simpler cases.
}
}
return arch_transform_node_Mux(n);
-}
+} /* transform_node_Mux */
/**
* Optimize a Psi into some simpler cases.
return transform_node_Mux(n);
return n;
-}
+} /* transform_node_Psi */
/**
* Tries several [inplace] [optimizing] transformations and returns an
if (n->op->ops.transform_node)
n = n->op->ops.transform_node(n);
return n;
-}
+} /* transform_node */
/**
* sSets the default transform node operation for an ir_op_ops.
return ops;
#undef CASE
-}
+} /* firm_set_default_transform_node */
/* **************** Common Subexpression Elimination **************** */
#define N_IR_NODES 512
/** Compares the attributes of two Const nodes. */
-static int node_cmp_attr_Const(ir_node *a, ir_node *b)
-{
+static int node_cmp_attr_Const(ir_node *a, ir_node *b) {
return (get_Const_tarval(a) != get_Const_tarval(b))
|| (get_Const_type(a) != get_Const_type(b));
-}
+} /* node_cmp_attr_Const */
/** Compares the attributes of two Proj nodes. */
static int node_cmp_attr_Proj(ir_node *a, ir_node *b) {
return get_irn_proj_attr (a) != get_irn_proj_attr (b);
-}
+} /* node_cmp_attr_Proj */
/** Compares the attributes of two Filter nodes. */
-static int node_cmp_attr_Filter(ir_node *a, ir_node *b)
-{
+static int node_cmp_attr_Filter(ir_node *a, ir_node *b) {
return get_Filter_proj(a) != get_Filter_proj(b);
-}
+} /* node_cmp_attr_Filter */
/** Compares the attributes of two Alloc nodes. */
-static int node_cmp_attr_Alloc(ir_node *a, ir_node *b)
-{
+static int node_cmp_attr_Alloc(ir_node *a, ir_node *b) {
return (get_irn_alloc_attr(a).where != get_irn_alloc_attr(b).where)
|| (get_irn_alloc_attr(a).type != get_irn_alloc_attr(b).type);
-}
+} /* node_cmp_attr_Alloc */
/** Compares the attributes of two Free nodes. */
-static int node_cmp_attr_Free(ir_node *a, ir_node *b)
-{
+static int node_cmp_attr_Free(ir_node *a, ir_node *b) {
return (get_irn_free_attr(a).where != get_irn_free_attr(b).where)
|| (get_irn_free_attr(a).type != get_irn_free_attr(b).type);
-}
+} /* node_cmp_attr_Free */
/** Compares the attributes of two SymConst nodes. */
-static int node_cmp_attr_SymConst(ir_node *a, ir_node *b)
-{
+static int node_cmp_attr_SymConst(ir_node *a, ir_node *b) {
return (get_irn_symconst_attr(a).num != get_irn_symconst_attr(b).num)
|| (get_irn_symconst_attr(a).sym.type_p != get_irn_symconst_attr(b).sym.type_p)
|| (get_irn_symconst_attr(a).tp != get_irn_symconst_attr(b).tp);
-}
+} /* node_cmp_attr_SymConst */
/** Compares the attributes of two Call nodes. */
static int node_cmp_attr_Call(ir_node *a, ir_node *b) {
return (get_irn_call_attr(a) != get_irn_call_attr(b));
-}
+} /* node_cmp_attr_Call */
/** Compares the attributes of two Sel nodes. */
-static int node_cmp_attr_Sel(ir_node *a, ir_node *b)
-{
+static int node_cmp_attr_Sel(ir_node *a, ir_node *b) {
return (get_irn_sel_attr(a).ent->kind != get_irn_sel_attr(b).ent->kind)
|| (get_irn_sel_attr(a).ent->name != get_irn_sel_attr(b).ent->name)
|| (get_irn_sel_attr(a).ent->owner != get_irn_sel_attr(b).ent->owner)
|| (get_irn_sel_attr(a).ent->ld_name != get_irn_sel_attr(b).ent->ld_name)
|| (get_irn_sel_attr(a).ent->type != get_irn_sel_attr(b).ent->type);
-}
+} /* node_cmp_attr_Sel */
/** Compares the attributes of two Phi nodes. */
static int node_cmp_attr_Phi(ir_node *a, ir_node *b) {
return get_irn_phi_attr (a) != get_irn_phi_attr (b);
-}
+} /* node_cmp_attr_Phi */
/** Compares the attributes of two Conv nodes. */
static int node_cmp_attr_Conv(ir_node *a, ir_node *b) {
return get_Conv_strict(a) != get_Conv_strict(b);
-}
+} /* node_cmp_attr_Conv */
/** Compares the attributes of two Cast nodes. */
static int node_cmp_attr_Cast(ir_node *a, ir_node *b) {
return get_Cast_type(a) != get_Cast_type(b);
-}
+} /* node_cmp_attr_Cast */
/** Compares the attributes of two Load nodes. */
-static int node_cmp_attr_Load(ir_node *a, ir_node *b)
-{
+static int node_cmp_attr_Load(ir_node *a, ir_node *b) {
if (get_Load_volatility(a) == volatility_is_volatile ||
get_Load_volatility(b) == volatility_is_volatile)
/* NEVER do CSE on volatile Loads */
return 1;
return get_Load_mode(a) != get_Load_mode(b);
-}
+} /* node_cmp_attr_Load */
/** Compares the attributes of two Store nodes. */
-static int node_cmp_attr_Store(ir_node *a, ir_node *b)
-{
+static int node_cmp_attr_Store(ir_node *a, ir_node *b) {
/* NEVER do CSE on volatile Stores */
return (get_Store_volatility(a) == volatility_is_volatile ||
get_Store_volatility(b) == volatility_is_volatile);
-}
+} /* node_cmp_attr_Store */
/** Compares the attributes of two Confirm nodes. */
-static int node_cmp_attr_Confirm(ir_node *a, ir_node *b)
-{
+static int node_cmp_attr_Confirm(ir_node *a, ir_node *b) {
return (get_Confirm_cmp(a) != get_Confirm_cmp(b));
-}
+} /* node_cmp_attr_Confirm */
/**
* Set the default node attribute compare operation for an ir_op_ops.
return ops;
#undef CASE
-}
+} /* firm_set_default_node_cmp_attr */
/*
* Compare function for two nodes in the hash table. Gets two
return a->op->ops.node_cmp_attr(a, b);
return 0;
-}
+} /* identities_cmp */
/*
* Calculate a hash value of a node.
}
return h;
-}
+} /* ir_node_hash */
pset *new_identities(void) {
return new_pset(identities_cmp, N_IR_NODES);
-}
+} /* new_identities */
void del_identities(pset *value_table) {
del_pset(value_table);
-}
+} /* del_identities */
/**
* Return the canonical node computing the same value as n.
+ *
+ * @param value_table The value table
+ * @param n The node to lookup
+ *
* Looks up the node in a hash table.
*
* For Const nodes this is performed in the constructor, too. Const
DBG_OPT_CSE(n, o);
return o;
-}
+} /* identify */
/**
* During construction we set the op_pin_state_pinned flag in the graph right when the
if (get_irn_n(old, -1) != get_irn_n(n, -1))
set_irg_pinned(current_ir_graph, op_pin_state_floats);
return n;
-}
+} /* identify_cons */
/*
* Return the canonical node computing the same value as n.
}
return o;
-}
+} /* identify_remember */
/* Add a node to the identities value table. */
void add_identities(pset *value_table, ir_node *node) {
if (get_opt_cse() && is_no_Block(node))
identify_remember(value_table, node);
-}
+} /* add_identities */
/* Visit each node in the value table of a graph. */
void visit_all_identities(ir_graph *irg, irg_walk_func visit, void *env) {
foreach_pset(irg->value_table, node)
visit(node, env);
current_ir_graph = rem;
-}
+} /* visit_all_identities */
/**
* Garbage in, garbage out. If a node has a dead input, i.e., the
}
#endif
return node;
-}
+} /* gigo */
/**
* These optimizations deallocate nodes from the obstack.
* It can only be called if it is guaranteed that no other nodes
* reference this one, i.e., right after construction of a node.
*
+ * @param n The node to optimize
+ *
* current_ir_graph must be set to the graph of the node!
*/
ir_node *optimize_node(ir_node *n)
(iro == iro_Id) ||
(iro == iro_Proj) ||
(iro == iro_Block) ) /* Flags tested local. */
- n = equivalent_node (n);
+ n = equivalent_node(n);
optimize_preds(n); /* do node specific optimizations of nodes predecessors. */
* subexpressions within a block.
*/
if (get_opt_cse())
- n = identify_cons (current_ir_graph->value_table, n);
+ n = identify_cons(current_ir_graph->value_table, n);
if (n != oldn) {
edges_node_deleted(oldn, current_ir_graph);
iro = get_irn_opcode(n);
if (get_opt_constant_folding() ||
(iro == iro_Cond) ||
- (iro == iro_Proj) ||
- (iro == iro_Sel)) /* Flags tested local. */
- n = transform_node (n);
+ (iro == iro_Proj)) /* Flags tested local. */
+ n = transform_node(n);
/* Remove nodes with dead (Bad) input.
Run always for transformation induced Bads. */
/* 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);
+ n = identify_remember(current_ir_graph->value_table, n);
}
return n;
-}
+} /* optimize_node */
/**
iro = get_irn_opcode(n);
if (get_opt_constant_folding() ||
(iro == iro_Cond) ||
- (iro == iro_Proj) ||
- (iro == iro_Sel)) /* Flags tested local. */
+ (iro == iro_Proj)) /* Flags tested local. */
n = transform_node(n);
/* Remove nodes with dead (Bad) input.
n = identify_remember(current_ir_graph->value_table, n);
return n;
-}
+} /* optimize_in_place_2 */
/**
* Wrapper for external use, set proper status bits after optimization.
*/
-ir_node *optimize_in_place(ir_node *n)
-{
+ir_node *optimize_in_place(ir_node *n) {
/* Handle graph state */
assert(get_irg_phase_state(current_ir_graph) != phase_building);
change the control graph. */
set_irg_doms_inconsistent(current_ir_graph);
return optimize_in_place_2 (n);
-}
+} /* optimize_in_place */
/*
* Sets the default operation for an ir_ops.
*/
-ir_op_ops *firm_set_default_operations(opcode code, ir_op_ops *ops)
-{
+ir_op_ops *firm_set_default_operations(opcode code, ir_op_ops *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_get_entity_attr(code, ops);
return ops;
-}
+} /* firm_set_default_operations */
projects / libfirm / blobdiff