X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Freassoc.c;h=4fe6bdc59e7cca173bc5b3cabe497a2c70830ac2;hb=6a6c1557afcd038930e649e29d69cb85a5dc372b;hp=e3ee2563d9b73bcfe1fc5ec39046be17bda68b45;hpb=990ddfa72b25a0ff04c6a12c35484a0a3114c015;p=libfirm diff --git a/ir/opt/reassoc.c b/ir/opt/reassoc.c index e3ee2563d..4fe6bdc59 100644 --- a/ir/opt/reassoc.c +++ b/ir/opt/reassoc.c @@ -10,7 +10,7 @@ */ #ifdef HAVE_CONFIG_H -# include +# include "config.h" #endif # include "irnode_t.h" @@ -24,7 +24,10 @@ # 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 */ @@ -32,13 +35,13 @@ typedef struct _walker_t { 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 constnt 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 wheater a node is constant, ie is a constant or + * returns whether a node is constant, ie is a constant or * is loop invariant */ static const_class_t get_const_class(ir_node *n) @@ -57,8 +60,8 @@ static const_class_t get_const_class(ir_node *n) * 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) { @@ -87,8 +90,9 @@ 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 @@ -107,7 +111,7 @@ static int reassoc_Sub(ir_node *n) 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)) { @@ -115,6 +119,7 @@ static int reassoc_Sub(ir_node *n) irn = optimize_in_place(n); if (irn != n) { exchange(n, irn); + *in = irn; return 1; } return 0; @@ -126,16 +131,15 @@ static int reassoc_Sub(ir_node *n) } 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; } @@ -169,8 +173,9 @@ static ir_mode *get_mode_from_ops(ir_node *op1, ir_node *op2) * 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; @@ -196,7 +201,7 @@ static int reassoc_commutative(ir_node *n) /* 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; } @@ -238,11 +243,9 @@ static int reassoc_commutative(ir_node *n) 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. @@ -250,6 +253,7 @@ static int reassoc_commutative(ir_node *n) */ if (n != irn) { exchange(n, irn); + *node = irn; return 1; } } @@ -258,16 +262,20 @@ static int reassoc_commutative(ir_node *n) } #define reassoc_Add reassoc_commutative +#define reassoc_And reassoc_commutative +#define reassoc_Or reassoc_commutative +#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); @@ -288,14 +296,10 @@ static int reassoc_Mul(ir_node *n) 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; } @@ -310,6 +314,8 @@ static void do_reassociation(ir_node *n, void *env) walker_t *wenv = env; int res; + hook_reassociate(1); + /* reassociation must run until fixpoint */ do { ir_op *op = get_irn_op(n); @@ -319,15 +325,13 @@ static void do_reassociation(ir_node *n, void *env) /* 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); + + hook_reassociate(0); } /* @@ -357,12 +361,17 @@ void optimize_reassociation(ir_graph *irg) } } -/* 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(Mul); INIT(Add); INIT(Sub); -#undef CASE + INIT(And); + INIT(Or); + INIT(Eor); +#undef INIT + + dbg = firm_dbg_register("firm.opt.reassoc"); }