void **res;
ir_node *pred;
ir_graph *irg;
- int i, n = get_irn_arity(a);
+ 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) {
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_A_MINUS_B);
return n;
}
- if (! is_reassoc_running()) {
- /* do NOT execute this code if reassociation is enabled, it does the inverse! */
- if (is_Mul(a)) {
- 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);
- return n;
- } 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);
- return n;
- }
- }
- if (is_Mul(b)) {
- 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);
- return n;
- }
- 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);
- return n;
- }
- }
- }
if (get_mode_arithmetic(mode) == irma_twos_complement) {
/* Here we rely on constants be on the RIGHT side */
if (is_Not(a)) {
if (mode == get_irn_mode(b)) {
ir_mode *ma, *mb;
-
- a = get_Conv_op(a);
- b = get_Conv_op(b);
+ ir_node *op_a = get_Conv_op(a);
+ ir_node *op_b = get_Conv_op(b);
/* check if it's allowed to skip the conv */
- ma = get_irn_mode(a);
- mb = get_irn_mode(b);
+ ma = get_irn_mode(op_a);
+ mb = get_irn_mode(op_b);
if (mode_is_reference(ma) && mode_is_reference(mb)) {
/* SubInt(ConvInt(aP), ConvInt(bP)) -> SubInt(aP,bP) */
+ a = op_a; b = op_b;
set_Sub_left(n, a);
set_Sub_right(n, b);
else if (is_Const(a) && is_const_Phi(b)) {
/* check for Div(Const, Phi) */
va = apply_binop_on_phi(b, get_Const_tarval(a), tarval_div, mode, 1);
- va = apply_binop_on_phi(b, get_Const_tarval(a), tarval_mod, mode, 1);
+ vb = apply_binop_on_phi(b, get_Const_tarval(a), tarval_mod, mode, 1);
if (va && vb) {
DBG_OPT_ALGSIM0(n, va, FS_OPT_CONST_PHI);
DBG_OPT_ALGSIM0(n, vb, FS_OPT_CONST_PHI);
/**
* Optimize Abs(x) into x if x is Confirmed >= 0
* Optimize Abs(x) into -x if x is Confirmed <= 0
+ * Optimize Abs(-x) int Abs(x)
*/
static ir_node *transform_node_Abs(ir_node *n) {
ir_node *c, *oldn = n;
* not run it in the equivalent_node() context.
*/
n = new_rd_Minus(get_irn_dbg_info(n), current_ir_graph,
- get_irn_n(n, -1), a, mode);
+ get_nodes_block(n), a, mode);
DBG_OPT_CONFIRM(oldn, n);
return n;
DBG_OPT_CONFIRM(oldn, n);
return n;
default:
+ break;
+ }
+ if (is_Minus(a)) {
+ /* Abs(-x) = Abs(x) */
+ mode = get_irn_mode(n);
+ n = new_rd_Abs(get_irn_dbg_info(n), current_ir_graph,
+ get_nodes_block(n), get_Minus_op(a), mode);
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ABS_MINUS_X);
return n;
}
+ return n;
} /* transform_node_Abs */
/**
ir_node *b_left = get_binop_left(b);
ir_node *b_right = get_binop_right(b);
ir_node *c = NULL;
- ir_node *op1, *op2;
+ ir_node *op1 = NULL;
+ ir_node *op2 = NULL;
if (is_op_commutative(op)) {
if (a_left == b_left) {
}
}
- if (!get_opt_reassociation())
- return proj;
-
/*
* First step: normalize the compare op
* by placing the constant on the right side
return c;
}
}
+
+ if (is_Unknown(a)) { /* Conv_A(Unknown_B) -> Unknown_A */
+ ir_mode *mode = get_irn_mode(n);
+ return new_r_Unknown(current_ir_graph, mode);
+ }
+
return n;
} /* transform_node_Conv */
* @param n The node to normalize
*/
static void normalize_node(ir_node *n) {
- if (get_opt_reassociation()) {
- if (is_op_commutative(get_irn_op(n))) {
- ir_node *l = get_binop_left(n);
- ir_node *r = get_binop_right(n);
-
- /* For commutative operators perform a OP b == b OP a but keep
- * constants on the RIGHT side. This helps greatly in some
- * optimizations. Moreover we use the idx number to make the form
- * deterministic. */
- if (!operands_are_normalized(l, r)) {
- set_binop_left(n, r);
- set_binop_right(n, l);
- }
+ if (is_op_commutative(get_irn_op(n))) {
+ ir_node *l = get_binop_left(n);
+ ir_node *r = get_binop_right(n);
+
+ /* For commutative operators perform a OP b == b OP a but keep
+ * constants on the RIGHT side. This helps greatly in some
+ * optimizations. Moreover we use the idx number to make the form
+ * deterministic. */
+ if (!operands_are_normalized(l, r)) {
+ set_binop_left(n, r);
+ set_binop_right(n, l);
}
}
} /* normalize_node */