/*
- * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
/* already constant, nothing to do */
return 0;
}
+
mode = get_irn_mode(n);
dbi = get_irn_dbg_info(n);
/* Beware of SubP(P, Is) */
irn = new_rd_Minus(dbi, current_ir_graph, block, right, rmode);
- irn = new_rd_Add(dbi, current_ir_graph, block, left, irn, get_irn_mode(n));
+ irn = new_rd_Add(dbi, current_ir_graph, block, left, irn, mode);
DBG((dbg, LEVEL_5, "Applied: %n - %n => %n + (-%n)\n",
get_Sub_left(n), right, get_Sub_left(n), right));
/**
* Returns the earliest were a,b are available.
- * Note that we know that we know that a, b both dominate
+ * Note that we know that a, b both dominate
* the block of the previous operation, so one must dominate the other.
*
* If the earliest block is the start block, return curr_blk instead
x = get_Shl_right(left);
if (x == get_Shl_right(right)) {
- /* (a << x) +/- (b << x) */
+ /* (a << x) +/- (b << x) ==> (a +/- b) << x */
a = get_Shl_left(left);
b = get_Shl_left(right);
goto transform;
x = get_Mul_left(left);
if (x == get_Mul_left(right)) {
- /* (x * a) +/- (x * b) */
+ /* (x * a) +/- (x * b) ==> (a +/- b) * x */
a = get_Mul_right(left);
b = get_Mul_right(right);
goto transform;
} else if (x == get_Mul_right(right)) {
- /* (x * a) +/- (b * x) */
+ /* (x * a) +/- (b * x) ==> (a +/- b) * x */
a = get_Mul_right(left);
b = get_Mul_left(right);
goto transform;
x = get_Mul_right(left);
if (x == get_Mul_right(right)) {
- /* (a * x) +/- (b * x) */
+ /* (a * x) +/- (b * x) ==> (a +/- b) * x */
a = get_Mul_left(left);
b = get_Mul_left(right);
goto transform;
} else if (x == get_Mul_left(right)) {
- /* (a * x) +/- (x * b) */
+ /* (a * x) +/- (x * b) ==> (a +/- b) * x */
a = get_Mul_left(left);
b = get_Mul_right(right);
goto transform;
dbg = get_irn_dbg_info(n);
op = get_irn_op(n);
if (get_irn_op(l) == op) {
+ /* (a .op. b) .op. r */
a = get_binop_left(l);
b = get_binop_right(l);
if (is_constant_expr(a)) {
+ /* (C .op. b) .op. r ==> (r .op. b) .op. C */
c = a;
a = r;
blk = get_nodes_block(l);
dbg = dbg == get_irn_dbg_info(l) ? dbg : NULL;
goto transform;
} else if (is_constant_expr(b)) {
+ /* (a .op. C) .op. r ==> (a .op. r) .op. C */
c = b;
b = r;
blk = get_nodes_block(l);
goto transform;
}
} else if (get_irn_op(r) == op) {
+ /* l .op. (a .op. b) */
a = get_binop_left(r);
b = get_binop_right(r);
if (is_constant_expr(a)) {
+ /* l .op. (C .op. b) ==> (l .op. b) .op. C */
c = a;
a = l;
blk = get_nodes_block(r);
dbg = dbg == get_irn_dbg_info(r) ? dbg : NULL;
goto transform;
} else if (is_constant_expr(b)) {
+ /* l .op. (a .op. C) ==> (a .op. l) .op. C */
c = b;
b = l;
blk = get_nodes_block(r);
* we implement the second here
*/
ma = get_irn_mode(a);
- mb = get_irn_mode(a);
+ mb = get_irn_mode(b);
if (ma != mb && mode_is_int(ma) && mode_is_int(mb))
return 0;
- /* check if a+b can be calculted in the same block is the old instruction */
+ /* check if (a .op. b) can be calculated in the same block is the old instruction */
if (! block_dominates(get_nodes_block(a), blk))
return 0;
if (! block_dominates(get_nodes_block(b), blk))
in[1] = b;
mode = get_mode_from_ops(a, b);
- in[0] = optimize_node(new_ir_node(dbg, current_ir_graph, blk, op, mode, 2, in));
+ in[0] = irn = optimize_node(new_ir_node(dbg, current_ir_graph, blk, op, mode, 2, in));
- if (op == op_Add || op == op_Sub) {
+ /* beware: optimize_node might have changed the opcode, check again */
+ if (is_Add(irn) || is_Sub(irn)) {
reverse_rule_distributive(&in[0]);
}
in[1] = c;
if (is_op_commutative(op)) {
wenv->changes |= res = move_consts_up(&node);
}
- if (op == op_Add || op == op_Sub) {
+ /* beware: move_consts_up might have changed the opcode, check again */
+ if (is_Add(node) || is_Sub(node)) {
wenv->changes |= res = reverse_rule_distributive(&node);
}
} while (res);
{
walker_t env;
irg_loopinfo_state state;
+ ir_graph *rem;
assert(get_irg_phase_state(irg) != phase_building);
assert(get_irg_pinned(irg) != op_pin_state_floats &&
"Reassociation needs pinned graph to work properly");
- /* reassociation needs constant folding */
- if (!get_opt_reassociation() || !get_opt_constant_folding())
- return;
+ rem = current_ir_graph;
+ current_ir_graph = irg;
/* we use dominance to detect dead blocks */
assure_doms(irg);
env.changes = 0;
env.wq = new_waitq();
- /* now we have collected enough information, optimize */
- irg_walk_graph(irg, NULL, wq_walker, &env);
- do_reassociation(&env);
+ /* disable some optimizations while reassoc is running to prevent endless loops */
+ set_reassoc_running(1);
+ {
+ /* now we have collected enough information, optimize */
+ irg_walk_graph(irg, NULL, wq_walker, &env);
+ do_reassociation(&env);
- /* reverse those rules that do not result in collapsed constants */
- irg_walk_graph(irg, NULL, reverse_rules, &env);
+ /* reverse those rules that do not result in collapsed constants */
+ irg_walk_graph(irg, NULL, reverse_rules, &env);
+ }
+ set_reassoc_running(0);
/* Handle graph state */
if (env.changes) {
}
del_waitq(env.wq);
+ current_ir_graph = rem;
} /* optimize_reassociation */
/* Sets the default reassociation operation for an ir_op_ops. */
projects / libfirm / blobdiff