X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ir%2Fir%2Firopt.c;h=60ad50ea6f9e8a3c4f16b622e5ece73a81238716;hb=3e22a883f6ad7c41ab4972d966db7f12f8a21f89;hp=ea94b75eb7f2322c27f40f4cc92e5714b55ef61a;hpb=309108c29fb40f23adac4f7743d7aa37fd427ad3;p=libfirm diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c index ea94b75eb..60ad50ea6 100644 --- a/ir/ir/iropt.c +++ b/ir/ir/iropt.c @@ -27,10 +27,17 @@ # include "irflag_t.h" # include "firmstat.h" # include "irarch.h" +# include "hashptr.h" /* Make types visible to allow most efficient access */ # include "entity_t.h" +# ifdef DO_HEAPANALYSIS +/* heapanal can't cope with NoMems */ +# else /* if defined DO_HEAPANALYSIS */ +# define USE_NOMEM +# endif /* defined DO_HEAPANALYSIS */ + /** * Trivial INLINEable routine for copy propagation. * Does follow Ids, needed to optimize INLINEd code. @@ -425,7 +432,8 @@ static tarval *computed_value_Proj(ir_node *n) ab = get_Cmp_right(a); proj_nr = get_Proj_proj(n); - if (aa == ab) { /* 1.: */ + if (aa == ab && !mode_is_float(get_irn_mode(aa))) { /* 1.: */ + /* BEWARE: a == a is NOT always True for floating Point!!! */ /* This is a trick with the bits used for encoding the Cmp Proj numbers, the following statement is not the same: return new_tarval_from_long (proj_nr == Eq, mode_b) */ @@ -876,12 +884,12 @@ static ir_node *equivalent_node_Conv(ir_node *n) if (n_mode == b_mode) { if (n_mode == mode_b) { n = b; /* Convb(Conv*(xxxb(...))) == xxxb(...) */ - DBG_OPT_ALGSIM1(oldn, a, b, n); + DBG_OPT_ALGSIM1(oldn, a, b, n); } else if (mode_is_int(n_mode) || mode_is_character(n_mode)) { if (smaller_mode(b_mode, a_mode)){ n = b; /* ConvS(ConvL(xxxS(...))) == xxxS(...) */ - DBG_OPT_ALGSIM1(oldn, a, b, n); + DBG_OPT_ALGSIM1(oldn, a, b, n); } } } @@ -889,6 +897,10 @@ static ir_node *equivalent_node_Conv(ir_node *n) return n; } +/** + * A Cast may be removed if the type of the previous node + * is already to type of the Cast. + */ static ir_node *equivalent_node_Cast(ir_node *n) { ir_node *pred = get_Cast_op(n); if (get_irn_type(pred) == get_Cast_type(n)) @@ -896,14 +908,14 @@ static ir_node *equivalent_node_Cast(ir_node *n) { return n; } +/* Several optimizations: + - no Phi in start block. + - remove Id operators that are inputs to Phi + - fold Phi-nodes, iff they have only one predecessor except + themselves. +*/ static ir_node *equivalent_node_Phi(ir_node *n) { - /* Several optimizations: - - no Phi in start block. - - remove Id operators that are inputs to Phi - - fold Phi-nodes, iff they have only one predecessor except - themselves. - */ int i, n_preds; ir_node *oldn = n; @@ -1117,6 +1129,71 @@ optimize_preds(ir_node *n) { } /* end switch */ } +/** + * Transform AddP(P, ConvIs(Iu)), AddP(P, ConvIu(Is)) and + * SubP(P, ConvIs(Iu)), SubP(P, ConvIu(Is)) if possible. + */ +static ir_node *transform_node_AddSub(ir_node *n) +{ + ir_mode *mode = get_irn_mode(n); + + if (mode_is_reference(mode)) { + ir_node *left = get_binop_left(n); + ir_node *right = get_binop_right(n); + int ref_bits = get_mode_size_bits(mode); + + if (get_irn_op(left) == op_Conv) { + ir_mode *mode = get_irn_mode(left); + int bits = get_mode_size_bits(mode); + + if (ref_bits == bits && + mode_is_int(mode) && + get_mode_arithmetic(mode) == irma_twos_complement) { + ir_node *pre = get_Conv_op(left); + ir_mode *pre_mode = get_irn_mode(pre); + + if (mode_is_int(pre_mode) && + get_mode_size_bits(pre_mode) == bits && + get_mode_arithmetic(pre_mode) == irma_twos_complement) { + /* ok, this conv just changes to sign, moreover the calculation + * is done with same number of bits as our address mode, so + * we can ignore the conv as address calculation can be viewed + * as either signed or unsigned + */ + set_binop_left(n, pre); + } + } + } + + if (get_irn_op(right) == op_Conv) { + ir_mode *mode = get_irn_mode(right); + int bits = get_mode_size_bits(mode); + + if (ref_bits == bits && + mode_is_int(mode) && + get_mode_arithmetic(mode) == irma_twos_complement) { + ir_node *pre = get_Conv_op(right); + ir_mode *pre_mode = get_irn_mode(pre); + + if (mode_is_int(pre_mode) && + get_mode_size_bits(pre_mode) == bits && + get_mode_arithmetic(pre_mode) == irma_twos_complement) { + /* ok, this conv just changes to sign, moreover the calculation + * is done with same number of bits as our address mode, so + * we can ignore the conv as address calculation can be viewed + * as either signed or unsigned + */ + set_binop_right(n, pre); + } + } + } + } + return n; +} + +#define transform_node_Add transform_node_AddSub +#define transform_node_Sub transform_node_AddSub + /** Do architecture dependend optimizations on Mul nodes */ static ir_node *transform_node_Mul(ir_node *n) { return arch_dep_replace_mul_with_shifts(n); @@ -1275,6 +1352,9 @@ static ir_node *transform_node_Cond(ir_node *n) return n; } +/** + * Transform an Eor. + */ static ir_node *transform_node_Eor(ir_node *n) { ir_node *a = get_Eor_left(n); @@ -1324,10 +1404,10 @@ static ir_node *transform_node_Cast(ir_node *n) { if (get_irn_op(pred) == op_Const && get_Const_type(pred) != tp) { n = new_rd_Const_type(NULL, current_ir_graph, get_nodes_block(pred), get_irn_mode(pred), - get_Const_tarval(pred), tp); + get_Const_tarval(pred), tp); } else if ((get_irn_op(pred) == op_SymConst) && (get_SymConst_value_type(pred) != tp)) { n = new_rd_SymConst_type(NULL, current_ir_graph, get_nodes_block(pred), get_SymConst_symbol(pred), - get_SymConst_kind(pred), tp); + get_SymConst_kind(pred), tp); } return n; } @@ -1336,7 +1416,7 @@ static ir_node *transform_node_Cast(ir_node *n) { * Transform a Div/Mod/DivMod with a non-zero constant. Must be * done here instead of equivalent node because it creates new * nodes. - * Removes the exceptions and routes the memory to the initial mem. + * Removes the exceptions and routes the memory to the NoMem node. * * Further, it optimizes jump tables by removing all impossible cases. */ @@ -1361,13 +1441,13 @@ static ir_node *transform_node_Proj(ir_node *proj) if (proj_nr == pn_Div_X_except) { /* we found an exception handler, remove it */ return new_Bad(); - } - else { - /* the memory Proj can be removed */ + } else { + /* the memory Proj can be removed */ ir_node *res = get_Div_mem(n); - set_Div_mem(n, get_irg_initial_mem(current_ir_graph)); - - if (proj_nr == pn_Div_M) +# ifdef USE_NOMEM + set_Div_mem(n, get_irg_no_mem(current_ir_graph)); +# endif /* defined USE_NOMEM */ + if (proj_nr == pn_Div_M) return res; } } @@ -1385,13 +1465,14 @@ static ir_node *transform_node_Proj(ir_node *proj) if (proj_nr == pn_Mod_X_except) { /* we found an exception handler, remove it */ return new_Bad(); - } - else { - /* the memory Proj can be removed */ + } else { + /* the memory Proj can be removed */ ir_node *res = get_Mod_mem(n); - set_Mod_mem(n, get_irg_initial_mem(current_ir_graph)); +# ifdef USE_NOMEM + set_Mod_mem(n, get_irg_no_mem(current_ir_graph)); +# endif /* defined USE_NOMEM */ if (proj_nr == pn_Mod_M) - return res; + return res; } } break; @@ -1410,11 +1491,13 @@ static ir_node *transform_node_Proj(ir_node *proj) return new_Bad(); } else { - /* the memory Proj can be removed */ + /* the memory Proj can be removed */ ir_node *res = get_DivMod_mem(n); - set_DivMod_mem(n, get_irg_initial_mem(current_ir_graph)); +# ifdef USE_NOMEM + set_DivMod_mem(n, get_irg_no_mem(current_ir_graph)); +# endif /* defined USE_NOMEM */ if (proj_nr == pn_DivMod_M) - return res; + return res; } } break; @@ -1638,6 +1721,8 @@ static ir_op *firm_set_default_transform_node(ir_op *op) break switch (op->code) { + CASE(Add); + CASE(Sub); CASE(Mul); CASE(Div); CASE(Mod); @@ -1714,12 +1799,6 @@ static int node_cmp_attr_Call(ir_node *a, ir_node *b) return (get_irn_call_attr(a) != get_irn_call_attr(b)); } -/** Compares the attributes of two FuncCall nodes. */ -static int node_cmp_attr_FuncCall(ir_node *a, ir_node *b) -{ - return (get_irn_funccall_attr(a) != get_irn_funccall_attr(b)); -} - /** Compares the attributes of two Sel nodes. */ static int node_cmp_attr_Sel(ir_node *a, ir_node *b) { @@ -1779,7 +1858,6 @@ static ir_op *firm_set_default_node_cmp_attr(ir_op *op) CASE(Free); CASE(SymConst); CASE(Call); - CASE(FuncCall); CASE(Sel); CASE(Phi); CASE(Cast); @@ -1837,8 +1915,6 @@ vt_cmp (const void *elt, const void *key) return 0; } -#define ADDR_TO_VAL(p) (((unsigned)(p)) >> 3) - /* * Calculate a hash value of a node. */ @@ -1850,12 +1926,12 @@ ir_node_hash (ir_node *node) if (node->op == op_Const) { /* special value for const, as they only differ in their tarval. */ - h = ADDR_TO_VAL(node->attr.con.tv); - h = 9*h + ADDR_TO_VAL(get_irn_mode(node)); + h = HASH_PTR(node->attr.con.tv); + h = 9*h + HASH_PTR(get_irn_mode(node)); } else if (node->op == op_SymConst) { /* special value for const, as they only differ in their symbol. */ - h = ADDR_TO_VAL(node->attr.i.sym.type_p); - h = 9*h + ADDR_TO_VAL(get_irn_mode(node)); + h = HASH_PTR(node->attr.i.sym.type_p); + h = 9*h + HASH_PTR(get_irn_mode(node)); } else { /* hash table value = 9*(9*(9*(9*(9*arity+in[0])+in[1])+ ...)+mode)+code */ @@ -1863,13 +1939,13 @@ ir_node_hash (ir_node *node) /* consider all in nodes... except the block if not a control flow. */ for (i = is_cfop(node) ? -1 : 0; i < irn_arity; i++) { - h = 9*h + ADDR_TO_VAL(get_irn_intra_n(node, i)); + h = 9*h + HASH_PTR(get_irn_intra_n(node, i)); } /* ...mode,... */ - h = 9*h + ADDR_TO_VAL(get_irn_mode(node)); + h = 9*h + HASH_PTR(get_irn_mode(node)); /* ...and code */ - h = 9*h + ADDR_TO_VAL(get_irn_op(node)); + h = 9*h + HASH_PTR(get_irn_op(node)); } return h; @@ -2059,23 +2135,23 @@ optimize_node (ir_node *n) if ((get_irn_mode(n) != mode_T) && (tv != tarval_bad)) { /* * we MUST copy the node here temporary, because it's still needed - * for DBG_OPT_ALGSIM0 + * for DBG_OPT_CSTEVAL */ int node_size = offsetof(ir_node, attr) + n->op->attr_size; oldn = alloca(node_size); memcpy(oldn, n, node_size); - CLONE_ARR_A(ir_node *, oldn->in, n->in); + CLONE_ARR_A(ir_node *, oldn->in, n->in); - /* ARG, copy the in array, we need it for statistics */ - memcpy(oldn->in, n->in, ARR_LEN(n->in) * sizeof(n->in[0])); + /* ARG, copy the in array, we need it for statistics */ + memcpy(oldn->in, n->in, ARR_LEN(n->in) * sizeof(n->in[0])); /* evaluation was successful -- replace the node. */ obstack_free (current_ir_graph->obst, n); n = new_Const (get_tarval_mode (tv), tv); - if (old_tp && get_type_mode(old_tp) == get_tarval_mode (tv)) - set_Const_type(n, old_tp); - DBG_OPT_ALGSIM0(oldn, n); + if (old_tp && get_type_mode(old_tp) == get_tarval_mode (tv)) + set_Const_type(n, old_tp); + DBG_OPT_CSTEVAL(oldn, n); return n; } } @@ -2165,10 +2241,10 @@ optimize_in_place_2 (ir_node *n) /* evaluation was successful -- replace the node. */ n = new_Const (get_tarval_mode (tv), tv); - if (old_tp && get_type_mode(old_tp) == get_tarval_mode (tv)) - set_Const_type(n, old_tp); + if (old_tp && get_type_mode(old_tp) == get_tarval_mode (tv)) + set_Const_type(n, old_tp); - DBG_OPT_ALGSIM0(oldn, n); + DBG_OPT_CSTEVAL(oldn, n); return n; } }