X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Freassoc.c;h=4fe6bdc59e7cca173bc5b3cabe497a2c70830ac2;hb=f0f554a0809f95fcd6e354acf7c61ae5c543f8c9;hp=955448f3c76eee86650b4a24f16ee7f303a103f8;hpb=bcb7c71016a3465e0745d6185c357ea104071ea0;p=libfirm diff --git a/ir/opt/reassoc.c b/ir/opt/reassoc.c index 955448f3c..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,10 +90,17 @@ 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 + * generation is currently buggy :-) + */ + if (! mode_is_signed(get_irn_mode(n))) + return 0; + /* handles rule R6: * convert x - c => (-c) + x * @@ -98,21 +108,38 @@ static int reassoc_Sub(ir_node *n) * for non-real constants yet. * */ if (get_const_class(right) == REAL_CONSTANT) { - ir_node *block = get_nodes_block(right); - ir_mode *mode = get_irn_mode(right); - dbg_info *dbg = get_irn_dbg_info(right); + ir_node *left = get_Sub_left(n); + ir_node *block = get_nodes_block(n); + ir_mode *mode = get_irn_mode(n); + dbg_info *dbi = get_irn_dbg_info(n); ir_node *irn, *c; + switch (get_const_class(left)) { + case REAL_CONSTANT: + irn = optimize_in_place(n); + if (irn != n) { + exchange(n, irn); + *in = irn; + return 1; + } + return 0; + case NO_CONSTANT: + break; + default: + /* already constant, nothing to do */ + 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, irn, get_Sub_left(n), get_irn_mode(n)); + irn = new_rd_Add(dbi, current_ir_graph, block, left, irn, get_irn_mode(n)); - printf("Applied: %s - %s => (-%s) + %s\n", - get_irn_opname(get_Sub_left(n)), get_irn_opname(c), - get_irn_opname(c), get_irn_opname(get_Sub_left(n)) ); + DBG((dbg, LEVEL_5, "Applied: %n - %n => %n + (-%n)\n", + get_Sub_left(n), c, get_Sub_left(n), c)); exchange(n, irn); + *in = irn; return 1; } @@ -146,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; @@ -160,6 +188,10 @@ static int reassoc_commutative(ir_node *n) get_comm_Binop_ops(t1, &t2, &c2); + /* do not optimize Bad nodes, will fail later */ + if (is_Bad(t2)) + return 0; + c_c1 = get_const_class(c1); c_c2 = get_const_class(c2); c_t2 = get_const_class(t2); @@ -169,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; } @@ -179,7 +211,27 @@ static int reassoc_commutative(ir_node *n) * convert c1 .OP. (c2 .OP. x) => (c1 .OP. c2) .OP. x */ ir_node *irn, *in[2]; - ir_mode *mode; + ir_mode *mode, *mode_c1 = get_irn_mode(c1), *mode_c2 = get_irn_mode(c2); + + /* It might happen, that c1 and c2 have different modes, for instance Is and Iu. + * Handle this here. + */ + if (mode_c1 != mode_c2) { + if (mode_is_int(mode_c1) && mode_is_int(mode_c2)) { + /* get the bigger one */ + if (get_mode_size_bits(mode_c1) > get_mode_size_bits(mode_c2)) + c2 = new_r_Conv(current_ir_graph, block, c2, mode_c1); + else if (get_mode_size_bits(mode_c1) < get_mode_size_bits(mode_c2)) + c1 = new_r_Conv(current_ir_graph, block, c1, mode_c2); + else { + /* Try to cast the real const */ + if (c_c1 == REAL_CONSTANT) + c1 = new_r_Conv(current_ir_graph, block, c1, mode_c2); + else + c2 = new_r_Conv(current_ir_graph, block, c2, mode_c1); + } + } + } in[0] = c1; in[1] = c2; @@ -191,29 +243,39 @@ 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)); - - exchange(n, irn); - - return 1; + 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. + * So check this. + */ + if (n != irn) { + exchange(n, irn); + *node = irn; + return 1; + } } } return 0; } #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); @@ -234,13 +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; } @@ -255,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); @@ -264,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); } /* @@ -302,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"); }