X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firopt.c;h=60ad50ea6f9e8a3c4f16b622e5ece73a81238716;hb=3e22a883f6ad7c41ab4972d966db7f12f8a21f89;hp=03ff12dbdc119b398e13ff66f6c471efe36f81b1;hpb=f8ebd04aadcde3b2b98a43f695698d1de5388ebc;p=libfirm diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c index 03ff12dbd..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. @@ -877,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); } } } @@ -890,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)) @@ -897,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; @@ -1118,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); @@ -1276,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); @@ -1325,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; } @@ -1362,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); +# ifdef USE_NOMEM set_Div_mem(n, get_irg_no_mem(current_ir_graph)); - - if (proj_nr == pn_Div_M) +# endif /* defined USE_NOMEM */ + if (proj_nr == pn_Div_M) return res; } } @@ -1386,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); +# 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; @@ -1411,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); +# 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; @@ -1639,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); @@ -1831,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. */ @@ -1844,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 */ @@ -1857,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,16 +2141,16 @@ optimize_node (ir_node *n) 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); + 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; } @@ -2159,8 +2241,8 @@ 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_CSTEVAL(oldn, n); return n;