X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firopt.c;h=5ff0f84fff18853000835ddf9e5056da3483a5df;hb=04d455ab69c9d1549305ccbd6f97eb802db91ff4;hp=35efeeb20874f39867937e80a5c3b2e41e7f55bb;hpb=86fe6a80cc0328c4b034946a77b8355d1c151b96;p=libfirm diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c index 35efeeb20..5ff0f84ff 100644 --- a/ir/ir/iropt.c +++ b/ir/ir/iropt.c @@ -634,7 +634,7 @@ static ir_tarval *compute_cmp_ext(const ir_node *cmp) static ir_tarval *computed_value_Cmp(const ir_node *cmp) { /* we can't construct Constb after lowering mode_b nodes */ - if (is_irg_state(get_irn_irg(cmp), IR_GRAPH_STATE_MODEB_LOWERED)) + if (irg_is_constrained(get_irn_irg(cmp), IR_GRAPH_CONSTRAINT_MODEB_LOWERED)) return tarval_bad; return compute_cmp(cmp); @@ -736,49 +736,6 @@ ir_tarval *computed_value(const ir_node *n) return tarval_bad; } -void firm_set_default_computed_value(ir_opcode code, ir_op_ops *ops) -{ -#define CASE(a) \ - case iro_##a: \ - ops->computed_value = computed_value_##a; \ - break -#define CASE_PROJ(a) \ - case iro_##a: \ - ops->computed_value_Proj = computed_value_Proj_##a; \ - break - - switch (code) { - CASE(Add); - CASE(And); - CASE(Borrow); - CASE(Carry); - CASE(Cmp); - CASE(Confirm); - CASE(Const); - CASE(Conv); - CASE(Eor); - CASE(Minus); - CASE(Mul); - CASE(Mux); - CASE(Not); - CASE(Or); - CASE(Proj); - CASE(Rotl); - CASE(Shl); - CASE(Shr); - CASE(Shrs); - CASE(Sub); - CASE(SymConst); - CASE_PROJ(Div); - CASE_PROJ(Mod); - default: - /* leave NULL */ - break; - } -#undef CASE_PROJ -#undef CASE -} - /** * Optimize operations that are commutative and have neutral 0, * so a op 0 = 0 op a = a. @@ -942,11 +899,6 @@ static ir_node *equivalent_node_left_zero(ir_node *n) return n; } -#define equivalent_node_Shl equivalent_node_left_zero -#define equivalent_node_Shr equivalent_node_left_zero -#define equivalent_node_Shrs equivalent_node_left_zero -#define equivalent_node_Rotl equivalent_node_left_zero - /** * Optimize a - 0 and (a + x) - x (for modes with wrap-around). * @@ -1007,13 +959,6 @@ static ir_node *equivalent_node_idempotent_unop(ir_node *n) return n; } -/** Optimize Not(Not(x)) == x. */ -#define equivalent_node_Not equivalent_node_idempotent_unop - -/** -(-x) == x ??? Is this possible or can --x raise an - out of bounds exception if min =! max? */ -#define equivalent_node_Minus equivalent_node_idempotent_unop - /** * Optimize a * 1 = 1 * a = a. */ @@ -1111,9 +1056,9 @@ static ir_node *equivalent_node_And(ir_node *n) /* Check Conv(all_one) & Const = all_one */ ir_tarval *one = get_mode_all_one(convopmode); ir_tarval *conv = tarval_convert_to(one, mode); - ir_tarval *and = tarval_and(conv, tv); + ir_tarval *tand = tarval_and(conv, tv); - if (tarval_is_all_one(and)) { + if (tarval_is_all_one(tand)) { /* Conv(X) & Const = X */ n = a; DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_AND); @@ -1613,48 +1558,6 @@ ir_node *equivalent_node(ir_node *n) return n; } -void firm_set_default_equivalent_node(ir_opcode code, ir_op_ops *ops) -{ -#define CASE(a) \ - case iro_##a: \ - ops->equivalent_node = equivalent_node_##a; \ - break -#define CASE_PROJ(a) \ - case iro_##a: \ - ops->equivalent_node_Proj = equivalent_node_Proj_##a; \ - break - - switch (code) { - CASE(Eor); - CASE(Add); - CASE(Shl); - CASE(Shr); - CASE(Shrs); - CASE(Rotl); - CASE(Sub); - CASE(Not); - CASE(Minus); - CASE(Mul); - CASE(Or); - CASE(And); - CASE(Conv); - CASE(Phi); - CASE_PROJ(Tuple); - CASE_PROJ(Div); - CASE_PROJ(CopyB); - CASE_PROJ(Bound); - CASE(Proj); - CASE(Id); - CASE(Mux); - CASE(Confirm); - default: - /* leave NULL */ - break; - } -#undef CASE -#undef CASE_PROJ -} - /** * Returns non-zero if a node is a Phi node * with all predecessors constant. @@ -2143,7 +2046,7 @@ static ir_node *transform_node_Or_bf_store(ir_node *irn_or) } /* ok, all conditions met */ - block = get_irn_n(irn_or, -1); + block = get_nodes_block(irn_or); irg = get_irn_irg(block); new_and = new_r_And(block, value, new_r_Const(irg, tarval_and(tv4, tv2)), mode); @@ -2369,7 +2272,7 @@ static ir_node *transform_node_bitop_shift(ir_node *n) ir_tarval *tv2; ir_tarval *tv_bitop; - if (!is_irg_state(irg, IR_GRAPH_STATE_NORMALISATION2)) + if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_NORMALISATION2)) return n; assert(is_And(n) || is_Or(n) || is_Eor(n) || is_Or_Eor_Add(n)); @@ -2559,9 +2462,9 @@ static ir_node *transform_node_Or_(ir_node *n) ir_node *xora = new_rd_Eor(dbgi, block, a_left, a_right, a_mode); ir_node *xorb = new_rd_Eor(dbgi, block, b_left, b_right, b_mode); ir_node *conv = new_rd_Conv(dbgi, block, xora, b_mode); - ir_node *or = new_rd_Or(dbgi, block, conv, xorb, b_mode); + ir_node *orn = new_rd_Or(dbgi, block, conv, xorb, b_mode); ir_node *zero = create_zero_const(irg, b_mode); - return new_rd_Cmp(dbgi, block, or, zero, ir_relation_less_greater); + return new_rd_Cmp(dbgi, block, orn, zero, ir_relation_less_greater); } if (values_in_mode(get_irn_mode(b_left), get_irn_mode(a_left))) { ir_graph *irg = get_irn_irg(n); @@ -2572,9 +2475,9 @@ static ir_node *transform_node_Or_(ir_node *n) ir_node *xora = new_rd_Eor(dbgi, block, a_left, a_right, a_mode); ir_node *xorb = new_rd_Eor(dbgi, block, b_left, b_right, b_mode); ir_node *conv = new_rd_Conv(dbgi, block, xorb, a_mode); - ir_node *or = new_rd_Or(dbgi, block, xora, conv, a_mode); + ir_node *orn = new_rd_Or(dbgi, block, xora, conv, a_mode); ir_node *zero = create_zero_const(irg, a_mode); - return new_rd_Cmp(dbgi, block, or, zero, ir_relation_less_greater); + return new_rd_Cmp(dbgi, block, orn, zero, ir_relation_less_greater); } } } @@ -2762,7 +2665,7 @@ static ir_node *transform_node_Add(ir_node *n) ir_graph *irg = get_irn_irg(n); /* the following code leads to endless recursion when Mul are replaced * by a simple instruction chain */ - if (!is_irg_state(irg, IR_GRAPH_STATE_ARCH_DEP) + if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_ARCH_DEP) && a == b && mode_is_int(mode)) { ir_node *block = get_nodes_block(n); @@ -3151,8 +3054,8 @@ restart: ir_node *block = get_nodes_block(n); ir_mode *mode = get_irn_mode(n); ir_node *notn = new_rd_Not(dbgi, block, and_right, mode); - ir_node *and = new_rd_And(dbgi, block, a, notn, mode); - return and; + ir_node *andn = new_rd_And(dbgi, block, a, notn, mode); + return andn; } } } @@ -3189,7 +3092,7 @@ static ir_node *transform_node_Mul2n(ir_node *n, ir_mode *mode) } if (tb == get_mode_one(smode)) { /* (L)a * (L)1 = (L)a */ - ir_node *blk = get_irn_n(a, -1); + ir_node *blk = get_nodes_block(a); n = new_rd_Conv(get_irn_dbg_info(n), blk, a, mode); DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_1); return n; @@ -3568,7 +3471,7 @@ static ir_node *transform_node_Cond(ir_node *n) } /* We might generate an endless loop, so keep it alive. */ add_End_keepalive(get_irg_end(irg), blk); - clear_irg_state(irg, IR_GRAPH_STATE_NO_UNREACHABLE_CODE); + clear_irg_properties(irg, IR_GRAPH_PROPERTY_NO_UNREACHABLE_CODE); } return n; } @@ -3642,7 +3545,7 @@ static ir_node *transform_node_shift_bitop(ir_node *n) ir_tarval *tv2; ir_tarval *tv_shift; - if (is_irg_state(irg, IR_GRAPH_STATE_NORMALISATION2)) + if (irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_NORMALISATION2)) return n; assert(is_Shrs(n) || is_Shr(n) || is_Shl(n) || is_Rotl(n)); @@ -3746,10 +3649,10 @@ static ir_node *transform_node_And(ir_node *n) ir_node *xora = new_rd_Eor(dbgi, block, a_left, a_right, a_mode); ir_node *xorb = new_rd_Eor(dbgi, block, b_left, b_right, b_mode); ir_node *conv = new_rd_Conv(dbgi, block, xora, b_mode); - ir_node *or = new_rd_Or(dbgi, block, conv, xorb, b_mode); + ir_node *orn = new_rd_Or(dbgi, block, conv, xorb, b_mode); ir_graph *irg = get_irn_irg(n); ir_node *zero = create_zero_const(irg, b_mode); - return new_rd_Cmp(dbgi, block, or, zero, ir_relation_equal); + return new_rd_Cmp(dbgi, block, orn, zero, ir_relation_equal); } if (values_in_mode(get_irn_mode(b_left), get_irn_mode(a_left))) { dbg_info *dbgi = get_irn_dbg_info(n); @@ -3759,10 +3662,10 @@ static ir_node *transform_node_And(ir_node *n) ir_node *xora = new_rd_Eor(dbgi, block, a_left, a_right, a_mode); ir_node *xorb = new_rd_Eor(dbgi, block, b_left, b_right, b_mode); ir_node *conv = new_rd_Conv(dbgi, block, xorb, a_mode); - ir_node *or = new_rd_Or(dbgi, block, xora, conv, a_mode); + ir_node *orn = new_rd_Or(dbgi, block, xora, conv, a_mode); ir_graph *irg = get_irn_irg(n); ir_node *zero = create_zero_const(irg, a_mode); - return new_rd_Cmp(dbgi, block, or, zero, ir_relation_equal); + return new_rd_Cmp(dbgi, block, orn, zero, ir_relation_equal); } } } @@ -4209,7 +4112,7 @@ static ir_node *transform_node_Proj_Mod(ir_node *proj) switch (proj_nr) { case pn_Mod_X_regular: - return new_r_Jmp(get_irn_n(mod, -1)); + return new_r_Jmp(get_nodes_block(mod)); case pn_Mod_X_except: { ir_graph *irg = get_irn_irg(proj); @@ -5002,7 +4905,7 @@ is_bittest: { if (tarval_is_single_bit(tv)) { /* special case: (x % 2^n) CMP 0 ==> x & (2^n-1) CMP 0 */ ir_node *v = get_binop_left(op); - ir_node *blk = get_irn_n(op, -1); + ir_node *blk = get_nodes_block(op); ir_graph *irg = get_irn_irg(op); ir_mode *mode = get_irn_mode(v); @@ -5128,7 +5031,7 @@ static ir_node *transform_node_Proj(ir_node *proj) /** * Test whether a block is unreachable * Note: That this only returns true when - * IR_GRAPH_STATE_OPTIMIZE_UNREACHABLE_CODE is set. + * IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE is set. * This is important, as you easily end up producing invalid constructs in the * unreachable code when optimizing away edges into the unreachable code. * So only set this flag when you iterate localopts to the fixpoint. @@ -5139,7 +5042,7 @@ static ir_node *transform_node_Proj(ir_node *proj) static bool is_block_unreachable(const ir_node *block) { const ir_graph *irg = get_irn_irg(block); - if (!is_irg_state(irg, IR_GRAPH_STATE_OPTIMIZE_UNREACHABLE_CODE)) + if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE)) return false; return get_Block_dom_depth(block) < 0; } @@ -5151,7 +5054,7 @@ static ir_node *transform_node_Block(ir_node *block) ir_node *bad = NULL; int i; - if (!is_irg_state(irg, IR_GRAPH_STATE_OPTIMIZE_UNREACHABLE_CODE)) + if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE)) return block; for (i = 0; i < arity; ++i) { @@ -5216,7 +5119,6 @@ static ir_node *transform_node_Phi(ir_node *phi) return phi; /* Move the Pin nodes "behind" the Phi. */ - block = get_irn_n(phi, -1); new_phi = new_r_Phi(block, n, in, mode_M); return new_r_Pin(block, new_phi); } @@ -5228,7 +5130,7 @@ static ir_node *transform_node_Phi(ir_node *phi) /* Beware of Phi0 */ if (n > 0) { ir_node *pred = get_irn_n(phi, 0); - ir_node *bound, *new_phi, *block, **in; + ir_node *bound, *new_phi, **in; ir_relation relation; bool has_confirm = false; @@ -5260,7 +5162,6 @@ static ir_node *transform_node_Phi(ir_node *phi) return phi; /* move the Confirm nodes "behind" the Phi */ - block = get_irn_n(phi, -1); new_phi = new_r_Phi(block, n, in, get_irn_mode(phi)); return new_r_Confirm(block, new_phi, bound, relation); } @@ -6022,7 +5923,7 @@ static ir_node *transform_node_Mux(ir_node *n) /* the following optimisations create new mode_b nodes, so only do them * before mode_b lowering */ - if (!is_irg_state(irg, IR_GRAPH_STATE_MODEB_LOWERED)) { + if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_MODEB_LOWERED)) { if (is_Mux(t)) { ir_node* block = get_nodes_block(n); ir_node* c0 = sel; @@ -6194,7 +6095,8 @@ static ir_node *transform_node_Sync(ir_node *n) ++arity; break; } - if (get_Sync_pred(n, k) == pred_pred) break; + if (get_Sync_pred(n, k) == pred_pred) + break; } } } @@ -6342,60 +6244,6 @@ static ir_node *transform_node_Call(ir_node *call) return res; } -void firm_set_default_transform_node(ir_opcode code, ir_op_ops *ops) -{ -#define CASE(a) \ - case iro_##a: \ - ops->transform_node = transform_node_##a; \ - break -#define CASE_PROJ(a) \ - case iro_##a: \ - ops->transform_node_Proj = transform_node_Proj_##a; \ - break -#define CASE_PROJ_EX(a) \ - case iro_##a: \ - ops->transform_node = transform_node_##a; \ - ops->transform_node_Proj = transform_node_Proj_##a; \ - break - - switch (code) { - CASE(Add); - CASE(And); - CASE(Block); - CASE(Call); - CASE(Cmp); - CASE(Cond); - CASE(Conv); - CASE(End); - CASE(Eor); - CASE(Minus); - CASE(Mul); - CASE(Mux); - CASE(Not); - CASE(Or); - CASE(Phi); - CASE(Proj); - CASE(Rotl); - CASE(Shl); - CASE(Shr); - CASE(Shrs); - CASE(Sub); - CASE(Switch); - CASE(Sync); - CASE_PROJ(Bound); - CASE_PROJ(CopyB); - CASE_PROJ(Store); - CASE_PROJ_EX(Div); - CASE_PROJ_EX(Load); - CASE_PROJ_EX(Mod); - default: - break; - } -#undef CASE_PROJ_EX -#undef CASE_PROJ -#undef CASE -} - /** * Tries several [inplace] [optimizing] transformations and returns an * equivalent node. The difference to equivalent_node() is that these @@ -6453,291 +6301,137 @@ restart: return n; } +static void register_computed_value_func(ir_op *op, computed_value_func func) +{ + assert(op->ops.computed_value == NULL || op->ops.computed_value == func); + op->ops.computed_value = func; +} + +static void register_computed_value_func_proj(ir_op *op, + computed_value_func func) +{ + assert(op->ops.computed_value_Proj == NULL + || op->ops.computed_value_Proj == func); + op->ops.computed_value_Proj = func; +} + +static void register_equivalent_node_func(ir_op *op, equivalent_node_func func) +{ + assert(op->ops.equivalent_node == NULL || op->ops.equivalent_node == func); + op->ops.equivalent_node = func; +} + +static void register_equivalent_node_func_proj(ir_op *op, + equivalent_node_func func) +{ + assert(op->ops.equivalent_node_Proj == NULL + || op->ops.equivalent_node_Proj == func); + op->ops.equivalent_node_Proj = func; +} + +static void register_transform_node_func(ir_op *op, transform_node_func func) +{ + assert(op->ops.transform_node == NULL || op->ops.transform_node == func); + op->ops.transform_node = func; +} + +static void register_transform_node_func_proj(ir_op *op, + transform_node_func func) +{ + assert(op->ops.transform_node_Proj == NULL + || op->ops.transform_node_Proj == func); + op->ops.transform_node_Proj = func; +} + +void ir_register_opt_node_ops(void) +{ + register_computed_value_func(op_Add, computed_value_Add); + register_computed_value_func(op_And, computed_value_And); + register_computed_value_func(op_Borrow, computed_value_Borrow); + register_computed_value_func(op_Carry, computed_value_Carry); + register_computed_value_func(op_Cmp, computed_value_Cmp); + register_computed_value_func(op_Confirm, computed_value_Confirm); + register_computed_value_func(op_Const, computed_value_Const); + register_computed_value_func(op_Conv, computed_value_Conv); + register_computed_value_func(op_Eor, computed_value_Eor); + register_computed_value_func(op_Minus, computed_value_Minus); + register_computed_value_func(op_Mul, computed_value_Mul); + register_computed_value_func(op_Mux, computed_value_Mux); + register_computed_value_func(op_Not, computed_value_Not); + register_computed_value_func(op_Or, computed_value_Or); + register_computed_value_func(op_Proj, computed_value_Proj); + register_computed_value_func(op_Rotl, computed_value_Rotl); + register_computed_value_func(op_Shl, computed_value_Shl); + register_computed_value_func(op_Shr, computed_value_Shr); + register_computed_value_func(op_Shrs, computed_value_Shrs); + register_computed_value_func(op_Sub, computed_value_Sub); + register_computed_value_func(op_SymConst, computed_value_SymConst); + register_computed_value_func_proj(op_Div, computed_value_Proj_Div); + register_computed_value_func_proj(op_Mod, computed_value_Proj_Mod); + + register_equivalent_node_func(op_Add, equivalent_node_Add); + register_equivalent_node_func(op_And, equivalent_node_And); + register_equivalent_node_func(op_Confirm, equivalent_node_Confirm); + register_equivalent_node_func(op_Conv, equivalent_node_Conv); + register_equivalent_node_func(op_Eor, equivalent_node_Eor); + register_equivalent_node_func(op_Id, equivalent_node_Id); + register_equivalent_node_func(op_Minus, equivalent_node_idempotent_unop); + register_equivalent_node_func(op_Mul, equivalent_node_Mul); + register_equivalent_node_func(op_Mux, equivalent_node_Mux); + register_equivalent_node_func(op_Not, equivalent_node_idempotent_unop); + register_equivalent_node_func(op_Or, equivalent_node_Or); + register_equivalent_node_func(op_Phi, equivalent_node_Phi); + register_equivalent_node_func(op_Proj, equivalent_node_Proj); + register_equivalent_node_func(op_Rotl, equivalent_node_left_zero); + register_equivalent_node_func(op_Shl, equivalent_node_left_zero); + register_equivalent_node_func(op_Shr, equivalent_node_left_zero); + register_equivalent_node_func(op_Shrs, equivalent_node_left_zero); + register_equivalent_node_func(op_Sub, equivalent_node_Sub); + register_equivalent_node_func_proj(op_Bound, equivalent_node_Proj_Bound); + register_equivalent_node_func_proj(op_CopyB, equivalent_node_Proj_CopyB); + register_equivalent_node_func_proj(op_Div, equivalent_node_Proj_Div); + register_equivalent_node_func_proj(op_Tuple, equivalent_node_Proj_Tuple); + + register_transform_node_func(op_Add, transform_node_Add); + register_transform_node_func(op_And, transform_node_And); + register_transform_node_func(op_Block, transform_node_Block); + register_transform_node_func(op_Call, transform_node_Call); + register_transform_node_func(op_Cmp, transform_node_Cmp); + register_transform_node_func(op_Cond, transform_node_Cond); + register_transform_node_func(op_Conv, transform_node_Conv); + register_transform_node_func(op_Div, transform_node_Div); + register_transform_node_func(op_End, transform_node_End); + register_transform_node_func(op_Eor, transform_node_Eor); + register_transform_node_func(op_Load, transform_node_Load); + register_transform_node_func(op_Minus, transform_node_Minus); + register_transform_node_func(op_Mod, transform_node_Mod); + register_transform_node_func(op_Mul, transform_node_Mul); + register_transform_node_func(op_Mux, transform_node_Mux); + register_transform_node_func(op_Not, transform_node_Not); + register_transform_node_func(op_Or, transform_node_Or); + register_transform_node_func(op_Phi, transform_node_Phi); + register_transform_node_func(op_Proj, transform_node_Proj); + register_transform_node_func(op_Rotl, transform_node_Rotl); + register_transform_node_func(op_Shl, transform_node_Shl); + register_transform_node_func(op_Shrs, transform_node_Shrs); + register_transform_node_func(op_Shr, transform_node_Shr); + register_transform_node_func(op_Sub, transform_node_Sub); + register_transform_node_func(op_Switch, transform_node_Switch); + register_transform_node_func(op_Sync, transform_node_Sync); + register_transform_node_func_proj(op_Bound, transform_node_Proj_Bound); + register_transform_node_func_proj(op_CopyB, transform_node_Proj_CopyB); + register_transform_node_func_proj(op_Div, transform_node_Proj_Div); + register_transform_node_func_proj(op_Load, transform_node_Proj_Load); + register_transform_node_func_proj(op_Mod, transform_node_Proj_Mod); + register_transform_node_func_proj(op_Store, transform_node_Proj_Store); +} + /* **************** Common Subexpression Elimination **************** */ /** The size of the hash table used, should estimate the number of nodes in a graph. */ #define N_IR_NODES 512 -/** Compares two exception attributes */ -static int node_cmp_exception(const ir_node *a, const ir_node *b) -{ - const except_attr *ea = &a->attr.except; - const except_attr *eb = &b->attr.except; - return ea->pin_state != eb->pin_state; -} - -/** Compares the attributes of two Const nodes. */ -static int node_cmp_attr_Const(const ir_node *a, const ir_node *b) -{ - return get_Const_tarval(a) != get_Const_tarval(b); -} - -/** Compares the attributes of two Proj nodes. */ -static int node_cmp_attr_Proj(const ir_node *a, const ir_node *b) -{ - return a->attr.proj.proj != b->attr.proj.proj; -} - -/** Compares the attributes of two Alloc nodes. */ -static int node_cmp_attr_Alloc(const ir_node *a, const ir_node *b) -{ - const alloc_attr *pa = &a->attr.alloc; - const alloc_attr *pb = &b->attr.alloc; - if (pa->where != pb->where || pa->type != pb->type) - return 1; - return node_cmp_exception(a, b); -} - -/** Compares the attributes of two Free nodes. */ -static int node_cmp_attr_Free(const ir_node *a, const ir_node *b) -{ - const free_attr *pa = &a->attr.free; - const free_attr *pb = &b->attr.free; - return (pa->where != pb->where) || (pa->type != pb->type); -} - -/** Compares the attributes of two SymConst nodes. */ -static int node_cmp_attr_SymConst(const ir_node *a, const ir_node *b) -{ - const symconst_attr *pa = &a->attr.symc; - const symconst_attr *pb = &b->attr.symc; - return (pa->kind != pb->kind) - || (pa->sym.type_p != pb->sym.type_p); -} - -/** Compares the attributes of two Call nodes. */ -static int node_cmp_attr_Call(const ir_node *a, const ir_node *b) -{ - const call_attr *pa = &a->attr.call; - const call_attr *pb = &b->attr.call; - if (pa->type != pb->type) - return 1; - return node_cmp_exception(a, b); -} - -/** Compares the attributes of two Sel nodes. */ -static int node_cmp_attr_Sel(const ir_node *a, const ir_node *b) -{ - const ir_entity *a_ent = get_Sel_entity(a); - const ir_entity *b_ent = get_Sel_entity(b); - return a_ent != b_ent; -} - -/** Compares the attributes of two Phi nodes. */ -static int node_cmp_attr_Phi(const ir_node *a, const ir_node *b) -{ - (void) b; - /* do not CSE Phi-nodes without any inputs when building new graphs */ - if (get_irn_arity(a) == 0 && - get_irg_phase_state(get_irn_irg(a)) == phase_building) { - return 1; - } - return 0; -} - -/** Compares the attributes of two Conv nodes. */ -static int node_cmp_attr_Conv(const ir_node *a, const ir_node *b) -{ - return get_Conv_strict(a) != get_Conv_strict(b); -} - -/** Compares the attributes of two Cast nodes. */ -static int node_cmp_attr_Cast(const ir_node *a, const ir_node *b) -{ - return get_Cast_type(a) != get_Cast_type(b); -} - -/** Compares the attributes of two Load nodes. */ -static int node_cmp_attr_Load(const ir_node *a, const ir_node *b) -{ - if (get_Load_volatility(a) == volatility_is_volatile || - get_Load_volatility(b) == volatility_is_volatile) - /* NEVER do CSE on volatile Loads */ - return 1; - /* do not CSE Loads with different alignment. Be conservative. */ - if (get_Load_unaligned(a) != get_Load_unaligned(b)) - return 1; - if (get_Load_mode(a) != get_Load_mode(b)) - return 1; - return node_cmp_exception(a, b); -} - -/** Compares the attributes of two Store nodes. */ -static int node_cmp_attr_Store(const ir_node *a, const ir_node *b) -{ - /* do not CSE Stores with different alignment. Be conservative. */ - if (get_Store_unaligned(a) != get_Store_unaligned(b)) - return 1; - /* NEVER do CSE on volatile Stores */ - if (get_Store_volatility(a) == volatility_is_volatile || - get_Store_volatility(b) == volatility_is_volatile) - return 1; - return node_cmp_exception(a, b); -} - -static int node_cmp_attr_CopyB(const ir_node *a, const ir_node *b) -{ - if (get_CopyB_type(a) != get_CopyB_type(b)) - return 1; - - return node_cmp_exception(a, b); -} - -static int node_cmp_attr_Bound(const ir_node *a, const ir_node *b) -{ - return node_cmp_exception(a, b); -} - -/** Compares the attributes of two Div nodes. */ -static int node_cmp_attr_Div(const ir_node *a, const ir_node *b) -{ - const div_attr *ma = &a->attr.div; - const div_attr *mb = &b->attr.div; - if (ma->resmode != mb->resmode || ma->no_remainder != mb->no_remainder) - return 1; - return node_cmp_exception(a, b); -} - -/** Compares the attributes of two Mod nodes. */ -static int node_cmp_attr_Mod(const ir_node *a, const ir_node *b) -{ - const mod_attr *ma = &a->attr.mod; - const mod_attr *mb = &b->attr.mod; - if (ma->resmode != mb->resmode) - return 1; - return node_cmp_exception(a, b); -} - -static int node_cmp_attr_Cmp(const ir_node *a, const ir_node *b) -{ - const cmp_attr *ma = &a->attr.cmp; - const cmp_attr *mb = &b->attr.cmp; - return ma->relation != mb->relation; -} - -/** Compares the attributes of two Confirm nodes. */ -static int node_cmp_attr_Confirm(const ir_node *a, const ir_node *b) -{ - const confirm_attr *ma = &a->attr.confirm; - const confirm_attr *mb = &b->attr.confirm; - return ma->relation != mb->relation; -} - -/** Compares the attributes of two Builtin nodes. */ -static int node_cmp_attr_Builtin(const ir_node *a, const ir_node *b) -{ - if (get_Builtin_kind(a) != get_Builtin_kind(b)) - return 1; - if (get_Builtin_type(a) != get_Builtin_type(b)) - return 1; - return node_cmp_exception(a, b); -} - -/** Compares the attributes of two ASM nodes. */ -static int node_cmp_attr_ASM(const ir_node *a, const ir_node *b) -{ - size_t n; - size_t i; - const ir_asm_constraint *ca; - const ir_asm_constraint *cb; - ident **cla, **clb; - - if (get_ASM_text(a) != get_ASM_text(b)) - return 1; - - /* Should we really check the constraints here? Should be better, but is strange. */ - n = get_ASM_n_input_constraints(a); - if (n != get_ASM_n_input_constraints(b)) - return 1; - - ca = get_ASM_input_constraints(a); - cb = get_ASM_input_constraints(b); - for (i = 0; i < n; ++i) { - if (ca[i].pos != cb[i].pos || ca[i].constraint != cb[i].constraint - || ca[i].mode != cb[i].mode) - return 1; - } - - n = get_ASM_n_output_constraints(a); - if (n != get_ASM_n_output_constraints(b)) - return 1; - - ca = get_ASM_output_constraints(a); - cb = get_ASM_output_constraints(b); - for (i = 0; i < n; ++i) { - if (ca[i].pos != cb[i].pos || ca[i].constraint != cb[i].constraint - || ca[i].mode != cb[i].mode) - return 1; - } - - n = get_ASM_n_clobbers(a); - if (n != get_ASM_n_clobbers(b)) - return 1; - - cla = get_ASM_clobbers(a); - clb = get_ASM_clobbers(b); - for (i = 0; i < n; ++i) { - if (cla[i] != clb[i]) - return 1; - } - - return node_cmp_exception(a, b); -} - -/** Compares the inexistent attributes of two Dummy nodes. */ -static int node_cmp_attr_Dummy(const ir_node *a, const ir_node *b) -{ - (void) a; - (void) b; - /* Dummy nodes never equal by definition */ - return 1; -} - -static int node_cmp_attr_InstOf(const ir_node *a, const ir_node *b) -{ - if (get_InstOf_type(a) != get_InstOf_type(b)) - return 1; - return node_cmp_exception(a, b); -} - -void firm_set_default_node_cmp_attr(ir_opcode code, ir_op_ops *ops) -{ -#define CASE(a) \ - case iro_##a: \ - ops->node_cmp_attr = node_cmp_attr_##a; \ - break - - switch (code) { - CASE(ASM); - CASE(Alloc); - CASE(Bound); - CASE(Builtin); - CASE(Call); - CASE(Cast); - CASE(Cmp); - CASE(Confirm); - CASE(Const); - CASE(Conv); - CASE(CopyB); - CASE(Div); - CASE(Dummy); - CASE(Free); - CASE(InstOf); - CASE(Load); - CASE(Mod); - CASE(Phi); - CASE(Proj); - CASE(Sel); - CASE(Store); - CASE(SymConst); - default: - /* leave NULL */ - break; - } -#undef CASE -} - int identities_cmp(const void *elt, const void *key) { ir_node *a = (ir_node *)elt; @@ -6760,7 +6454,7 @@ int identities_cmp(const void *elt, const void *key) if (get_irn_pinned(a) == op_pin_state_pinned) { /* for pinned nodes, the block inputs must be equal */ - if (get_irn_n(a, -1) != get_irn_n(b, -1)) + if (get_nodes_block(a) != get_nodes_block(b)) return 1; } else { ir_node *block_a = get_nodes_block(a); @@ -6820,6 +6514,15 @@ void del_identities(ir_graph *irg) del_pset(irg->value_table); } +static int cmp_node_nr(const void *a, const void *b) +{ + ir_node **p1 = (ir_node**)a; + ir_node **p2 = (ir_node**)b; + long n1 = get_irn_node_nr(*p1); + long n2 = get_irn_node_nr(*p2); + return (n1>n2) - (n1value_table, ir_node*, node) { + foreach_pset(irg->value_table, ir_node, node) { visit(node, env); } current_ir_graph = rem; @@ -7046,53 +6772,6 @@ ir_node *optimize_in_place(ir_node *n) /* FIXME: Maybe we could also test whether optimizing the node can change the control graph. */ - clear_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE); + clear_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE); return optimize_in_place_2(n); } - -/** - * Calculate a hash value of a Const node. - */ -static unsigned hash_Const(const ir_node *node) -{ - unsigned h; - - /* special value for const, as they only differ in their tarval. */ - h = hash_ptr(node->attr.con.tarval); - - return h; -} - -/** - * Calculate a hash value of a SymConst node. - */ -static unsigned hash_SymConst(const ir_node *node) -{ - unsigned h; - - /* all others are pointers */ - h = hash_ptr(node->attr.symc.sym.type_p); - - return h; -} - -void firm_set_default_hash(unsigned code, ir_op_ops *ops) -{ -#define CASE(a) \ - case iro_##a: \ - ops->hash = hash_##a; \ - break - - /* hash function already set */ - if (ops->hash != NULL) - return; - - switch (code) { - CASE(Const); - CASE(SymConst); - default: - /* use input/mode default hash if no function was given */ - ops->hash = firm_default_hash; - } -#undef CASE -}