# include "irflag_t.h"
# include "irgwalk.h"
# include "reassoc_t.h"
-# include "firmstat.h"
+# include "irhooks.h"
+# include "debug.h"
+
+static firm_dbg_module_t *dbg;
typedef struct _walker_t {
int changes; /* set, if a reassociation take place */
typedef enum {
NO_CONSTANT = 0, /**< node is not constant */
- REAL_CONSTANT = 1, /**< node is a constnt that is suitable for constant folding */
- CONST_EXPR = 4 /**< node is not constant expression in the current context,
+ REAL_CONSTANT = 1, /**< node is a Const that is suitable for constant folding */
+ CONST_EXPR = 4 /**< node is a constant expression in the current context,
use 4 here to simplify implementation of get_comm_Binop_ops() */
} const_class_t;
* returns the operands of a commutative bin-op, if one operand is
* a constant in the current context, it is returned as the second one.
*
- * Beware: Real constrants must be returned with higher priority than
- * constnt expression, because they might be folded.
+ * Beware: Real constants must be returned with higher priority than
+ * constant expression, because they might be folded.
*/
static void get_comm_Binop_ops(ir_node *binop, ir_node **a, ir_node **c)
{
/**
* reassociate a Sub: x - c = (-c) + x
*/
-static int reassoc_Sub(ir_node *n)
+static int reassoc_Sub(ir_node **in)
{
+ ir_node *n = *in;
ir_node *right = get_Sub_right(n);
/* FIXME: Do not apply this rule for unsigned Sub's because our code
ir_node *left = get_Sub_left(n);
ir_node *block = get_nodes_block(n);
ir_mode *mode = get_irn_mode(n);
- dbg_info *dbg = get_irn_dbg_info(n);
+ dbg_info *dbi = get_irn_dbg_info(n);
ir_node *irn, *c;
switch (get_const_class(left)) {
irn = optimize_in_place(n);
if (irn != n) {
exchange(n, irn);
+ *in = irn;
return 1;
}
return 0;
}
c = new_r_Const(current_ir_graph, block, mode, get_mode_null(mode));
- irn = new_rd_Sub(dbg, current_ir_graph, block, c, right, mode);
+ irn = new_rd_Sub(dbi, current_ir_graph, block, c, right, mode);
- irn = new_rd_Add(dbg, current_ir_graph, block, left, irn, get_irn_mode(n));
+ irn = new_rd_Add(dbi, current_ir_graph, block, left, irn, get_irn_mode(n));
+
+ DBG((dbg, LEVEL_5, "Applied: %n - %n => %n + (-%n)\n",
+ get_Sub_left(n), c, get_Sub_left(n), c));
-/*
- printf("Applied: %s - %s => %s + (-%s)\n",
- get_irn_opname(get_Sub_left(n)), get_irn_opname(c),
- get_irn_opname(get_Sub_left(n)), get_irn_opname(c) );
-*/
exchange(n, irn);
+ *in = irn;
return 1;
}
* all two operands are are constant expressions and the third is a
* constant, so avoid this situation.
*/
-static int reassoc_commutative(ir_node *n)
+static int reassoc_commutative(ir_node **node)
{
+ ir_node *n = *node;
ir_op *op = get_irn_op(n);
ir_node *block = get_nodes_block(n);
ir_node *t1, *c1;
/* all three are constant and either all are constant expressions or two of them are:
* then, applying this rule would lead into a cycle
*
- * Note that if t2 is a onstant so is c2, so we save one test.
+ * Note that if t2 is a constant so is c2, so we save one test.
*/
return 0;
}
mode = get_mode_from_ops(in[0], in[1]);
irn = optimize_node(new_ir_node(NULL, current_ir_graph, block, op, mode, 2, in));
-/*
- printf("Applied: %s .%s. (%s .%s. %s) => (%s .%s. %s) .%s. %s\n",
- get_irn_opname(c1), get_irn_opname(n), get_irn_opname(c2), get_irn_opname(n), get_irn_opname(t2),
- get_irn_opname(c1), get_irn_opname(n), get_irn_opname(c2), get_irn_opname(n), get_irn_opname(t2));
- */
+ DBG((dbg, LEVEL_5, "Applied: %n .%s. (%n .%s. %n) => (%n .%s. %n) .%s. %n\n",
+ c1, get_irn_opname(n), c2, get_irn_opname(n),
+ t2, c1, get_irn_opname(n), c2, get_irn_opname(n), t2));
/*
* in some rare cases it can really happen that we get the same node back.
* This might be happen in dead loops, were the Phi nodes are already gone away.
*/
if (n != irn) {
exchange(n, irn);
+ *node = irn;
return 1;
}
}
#define reassoc_Eor reassoc_commutative
/**
- * reassociate using distibutive law for Mul and Add/Sub
+ * reassociate using distributive law for Mul and Add/Sub
*/
-static int reassoc_Mul(ir_node *n)
+static int reassoc_Mul(ir_node **node)
{
+ ir_node *n = *node;
ir_node *add_sub, *c;
ir_op *op;
- if (reassoc_commutative(n))
+ if (reassoc_commutative(&n))
return 1;
get_comm_Binop_ops(n, &add_sub, &c);
mode = get_mode_from_ops(in[0], in[1]);
irn = optimize_node(new_ir_node(NULL, current_ir_graph, block, op, mode, 2, in));
-/*
- printf("Applied: (%s .%s. %s) %s %s => (%s %s %s) .%s. (%s %s %s)\n",
- get_irn_opname(t1), get_op_name(op), get_irn_opname(t2), get_irn_opname(n), get_irn_opname(c),
- get_irn_opname(t1), get_irn_opname(n), get_irn_opname(c),
- get_op_name(op),
- get_irn_opname(t2), get_irn_opname(n), get_irn_opname(c));
-*/
+ DBG((dbg, LEVEL_5, "Applied: (%n .%s. %n) %n %n => (%n %n %n) .%s. (%n %n %n)\n",
+ t1, get_op_name(op), t2, n, c, t1, n, c, get_op_name(op), t2, n, c));
exchange(n, irn);
+ *node = irn;
return 1;
}
walker_t *wenv = env;
int res;
- stat_reassociate(1);
+ hook_reassociate(1);
/* reassociation must run until fixpoint */
do {
/* reassociation works only for integer or reference modes */
if (op->reassociate && (mode_is_int(mode) || mode_is_reference(mode))) {
- res = op->reassociate(n);
- if (res) {
- wenv->changes = 1;
+ res = op->reassociate(&n);
- /* we need a skip here, or we will see an Id in the next iteration */
- n = skip_Id(n);
- }
+ wenv->changes |= res;
}
} while (res == 1);
- stat_reassociate(0);
+ hook_reassociate(0);
}
/*
}
}
-/* initialise the reassociation by adding operations to some opcodes */
+/* initialize the reassociation by adding operations to some opcodes */
void firm_init_reassociation(void)
{
#define INIT(a) op_##a->reassociate = reassoc_##a;
INIT(And);
INIT(Or);
INIT(Eor);
-#undef CASE
+#undef INIT
+
+ dbg = firm_dbg_register("firm.opt.reassoc");
}