X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Flower%2Flower_dw.c;h=936e07c5f319c3e3fe6b56f4d9097834b4d89ffa;hb=b486451c68bbaec983ad0b2f919645ba0ee941e4;hp=7f04f7d0c493768dda628c393c688a9f9571e363;hpb=d9ec75963ce563880933460c5cdba520ae22f3e1;p=libfirm diff --git a/ir/lower/lower_dw.c b/ir/lower/lower_dw.c index 7f04f7d0c..936e07c5f 100644 --- a/ir/lower/lower_dw.c +++ b/ir/lower/lower_dw.c @@ -138,6 +138,9 @@ struct lower_env_t { ir_type *value_param_tp; /**< the old value param type */ }; +static void lower_node(lower_env_t *env, ir_node *node); +static bool mtp_must_be_lowered(lower_env_t *env, ir_type *mtp); + /** * Create a method type for a Conv emulation from imode to omode. */ @@ -980,6 +983,27 @@ static void lower_Not(ir_node *node, ir_mode *mode, lower_env_t *env) set_lowered(env, node, res_low, res_high); } +static bool is_equality_cmp_0(const ir_node *node) +{ + ir_relation relation = get_Cmp_relation(node); + ir_node *left = get_Cmp_left(node); + ir_node *right = get_Cmp_right(node); + ir_mode *mode = get_irn_mode(left); + + /* this probably makes no sense if unordered is involved */ + assert(!mode_is_float(mode)); + + if (!is_Const(right) || !is_Const_null(right)) + return false; + if (relation == ir_relation_equal) + return true; + if (mode_is_signed(mode)) { + return relation == ir_relation_less_greater; + } else { + return relation == ir_relation_greater; + } +} + /** * Translate a Cond. */ @@ -1005,18 +1029,25 @@ static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env) /* bad we can't really handle Switch with 64bit offsets */ panic("Cond with 64bit jumptable not supported"); } + lower_node(env, sel); return; } - if (!is_Cmp(sel)) + if (!is_Cmp(sel)) { + lower_node(env, sel); return; + } left = get_Cmp_left(sel); cmp_mode = get_irn_mode(left); - if (cmp_mode != env->high_signed && cmp_mode != env->high_unsigned) + if (cmp_mode != env->high_signed && cmp_mode != env->high_unsigned) { + lower_node(env, sel); return; + } right = get_Cmp_right(sel); + lower_node(env, left); + lower_node(env, right); lentry = get_node_entry(env, left); rentry = get_node_entry(env, right); @@ -1043,17 +1074,15 @@ static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env) dbg = get_irn_dbg_info(sel); relation = get_Cmp_relation(sel); - if (is_Const(right) && is_Const_null(right)) { - if (relation == ir_relation_equal || relation == ir_relation_less_greater) { - /* x ==/!= 0 ==> or(low,high) ==/!= 0 */ - ir_mode *mode = env->low_unsigned; - ir_node *low = new_r_Conv(block, lentry->low_word, mode); - ir_node *high = new_r_Conv(block, lentry->high_word, mode); - ir_node *ornode = new_rd_Or(dbg, block, low, high, mode); - ir_node *cmp = new_rd_Cmp(dbg, block, ornode, new_r_Const_long(irg, mode, 0), relation); - set_Cond_selector(node, cmp); - return; - } + if (is_equality_cmp_0(sel)) { + /* x ==/!= 0 ==> or(low,high) ==/!= 0 */ + ir_mode *mode = env->low_unsigned; + ir_node *low = new_r_Conv(block, lentry->low_word, mode); + ir_node *high = new_r_Conv(block, lentry->high_word, mode); + ir_node *ornode = new_rd_Or(dbg, block, low, high, mode); + ir_node *cmp = new_rd_Cmp(dbg, block, ornode, new_r_Const_long(irg, mode, 0), relation); + set_Cond_selector(node, cmp); + return; } if (relation == ir_relation_equal) { @@ -1296,47 +1325,58 @@ static void lower_Cmp(ir_node *cmp, ir_mode *m, lower_env_t *env) ir_mode *mode = get_irn_mode(l); ir_node *r, *low, *high, *t, *res; ir_relation relation; - ir_node *blk; - dbg_info *db; + ir_node *block; + dbg_info *dbg; const node_entry_t *lentry; const node_entry_t *rentry; (void) m; - if (mode != env->high_signed && mode != env->high_unsigned) { + if (mode != env->high_signed && mode != env->high_unsigned) return; - } r = get_Cmp_right(cmp); lentry = get_node_entry(env, l); rentry = get_node_entry(env, r); relation = get_Cmp_relation(cmp); - blk = get_nodes_block(cmp); - db = get_irn_dbg_info(cmp); + block = get_nodes_block(cmp); + dbg = get_irn_dbg_info(cmp); + + /* easy case for x ==/!= 0 (see lower_Cond for details) */ + if (is_equality_cmp_0(cmp)) { + ir_graph *irg = get_irn_irg(cmp); + ir_mode *mode = env->low_unsigned; + ir_node *low = new_r_Conv(block, lentry->low_word, mode); + ir_node *high = new_r_Conv(block, lentry->high_word, mode); + ir_node *ornode = new_rd_Or(dbg, block, low, high, mode); + ir_node *new_cmp = new_rd_Cmp(dbg, block, ornode, new_r_Const_long(irg, mode, 0), relation); + exchange(cmp, new_cmp); + return; + } if (relation == ir_relation_equal) { /* simple case:a == b <==> a_h == b_h && a_l == b_l */ - low = new_rd_Cmp(db, blk, lentry->low_word, rentry->low_word, + low = new_rd_Cmp(dbg, block, lentry->low_word, rentry->low_word, relation); - high = new_rd_Cmp(db, blk, lentry->high_word, rentry->high_word, + high = new_rd_Cmp(dbg, block, lentry->high_word, rentry->high_word, relation); - res = new_rd_And(db, blk, low, high, mode_b); + res = new_rd_And(dbg, block, low, high, mode_b); } else if (relation == ir_relation_less_greater) { /* simple case:a != b <==> a_h != b_h || a_l != b_l */ - low = new_rd_Cmp(db, blk, lentry->low_word, rentry->low_word, + low = new_rd_Cmp(dbg, block, lentry->low_word, rentry->low_word, relation); - high = new_rd_Cmp(db, blk, lentry->high_word, rentry->high_word, + high = new_rd_Cmp(dbg, block, lentry->high_word, rentry->high_word, relation); - res = new_rd_Or(db, blk, low, high, mode_b); + res = new_rd_Or(dbg, block, low, high, mode_b); } else { /* a rel b <==> a_h REL b_h || (a_h == b_h && a_l rel b_l) */ - ir_node *high1 = new_rd_Cmp(db, blk, lentry->high_word, + ir_node *high1 = new_rd_Cmp(dbg, block, lentry->high_word, rentry->high_word, relation & ~ir_relation_equal); - low = new_rd_Cmp(db, blk, lentry->low_word, rentry->low_word, + low = new_rd_Cmp(dbg, block, lentry->low_word, rentry->low_word, relation); - high = new_rd_Cmp(db, blk, lentry->high_word, rentry->high_word, + high = new_rd_Cmp(dbg, block, lentry->high_word, rentry->high_word, ir_relation_equal); - t = new_rd_And(db, blk, low, high, mode_b); - res = new_rd_Or(db, blk, high1, t, mode_b); + t = new_rd_And(dbg, block, low, high, mode_b); + res = new_rd_Or(dbg, block, high1, t, mode_b); } exchange(cmp, res); } @@ -1366,7 +1406,7 @@ static void lower_Conv(ir_node *node, ir_mode *mode, lower_env_t *env) * @param ent the entity * @param pos the argument index of this entity */ -static inline void set_entity_arg_idx(ir_entity *ent, int pos) +static inline void set_entity_arg_idx(ir_entity *ent, size_t pos) { set_entity_link(ent, INT_TO_PTR(pos)); } @@ -1376,8 +1416,8 @@ static inline void set_entity_arg_idx(ir_entity *ent, int pos) * * @param ent the entity */ -static int get_entity_arg_idx(const ir_entity *ent) { - return (int)PTR_TO_INT(get_entity_link(ent)); +static size_t get_entity_arg_idx(const ir_entity *ent) { + return PTR_TO_INT(get_entity_link(ent)); } /** @@ -1391,20 +1431,16 @@ static int get_entity_arg_idx(const ir_entity *ent) { static ir_type *lower_mtp(lower_env_t *env, ir_type *mtp) { pmap_entry *entry; - ident *lid; ir_type *res, *value_type; - if (is_lowered_type(mtp)) - return mtp; - entry = pmap_find(lowered_type, mtp); if (! entry) { - int i, orig_n_params, orig_n_res, n_param, n_res; + size_t i, orig_n_params, orig_n_res, n_param, n_res; /* count new number of params */ n_param = orig_n_params = get_method_n_params(mtp); - for (i = orig_n_params - 1; i >= 0; --i) { - ir_type *tp = get_method_param_type(mtp, i); + for (i = orig_n_params; i > 0;) { + ir_type *tp = get_method_param_type(mtp, --i); if (is_Primitive_type(tp)) { ir_mode *mode = get_type_mode(tp); @@ -1417,8 +1453,8 @@ static ir_type *lower_mtp(lower_env_t *env, ir_type *mtp) /* count new number of results */ n_res = orig_n_res = get_method_n_ress(mtp); - for (i = orig_n_res - 1; i >= 0; --i) { - ir_type *tp = get_method_res_type(mtp, i); + for (i = orig_n_res; i > 0;) { + ir_type *tp = get_method_res_type(mtp, --i); if (is_Primitive_type(tp)) { ir_mode *mode = get_type_mode(tp); @@ -1481,7 +1517,6 @@ static ir_type *lower_mtp(lower_env_t *env, ir_type *mtp) /* set new param positions for all entities of the value type */ for (i = n_param = 0; i < orig_n_params; ++i) { ir_type *tp = get_method_param_type(mtp, i); - ident *id = get_method_param_ident(mtp, i); ir_entity *ent = get_method_value_param_ent(mtp, i); set_entity_arg_idx(ent, n_param); @@ -1489,22 +1524,10 @@ static ir_type *lower_mtp(lower_env_t *env, ir_type *mtp) ir_mode *mode = get_type_mode(tp); if (mode == env->high_signed || mode == env->high_unsigned) { - if (id != NULL) { - lid = id_mangle(id, env->first_id); - set_method_param_ident(res, n_param, lid); - set_entity_ident(get_method_value_param_ent(res, n_param), lid); - lid = id_mangle(id, env->next_id); - set_method_param_ident(res, n_param + 1, lid); - set_entity_ident(get_method_value_param_ent(res, n_param + 1), lid); - } n_param += 2; continue; } } - if (id != NULL) { - set_method_param_ident(res, n_param, id); - set_entity_ident(get_method_value_param_ent(res, n_param), id); - } ++n_param; } @@ -1525,7 +1548,7 @@ static void lower_Return(ir_node *node, ir_mode *mode, lower_env_t *env) ir_entity *ent = get_irg_entity(irg); ir_type *mtp = get_entity_type(ent); ir_node **in; - int i, j, n; + size_t i, j, n; int need_conv = 0; (void) mode; @@ -1574,50 +1597,42 @@ static void lower_Start(ir_node *node, ir_mode *mode, lower_env_t *env) ir_graph *irg = get_irn_irg(node); ir_entity *ent = get_irg_entity(irg); ir_type *tp = get_entity_type(ent); - ir_type *mtp; long *new_projs; - int i, j, n_params, rem; + size_t i, j, n_params; + int rem; ir_node *proj, *args; (void) mode; - if (is_lowered_type(tp)) { - mtp = get_associated_type(tp); - } else { - mtp = tp; - } - assert(! is_lowered_type(mtp)); + if (!mtp_must_be_lowered(env, tp)) return; - n_params = get_method_n_params(mtp); - if (n_params <= 0) - return; + n_params = get_method_n_params(tp); NEW_ARR_A(long, new_projs, n_params); - /* first check if we have parameters that must be fixed */ + /* Calculate mapping of proj numbers in new_projs */ for (i = j = 0; i < n_params; ++i, ++j) { - ir_type *tp = get_method_param_type(mtp, i); + ir_type *ptp = get_method_param_type(tp, i); new_projs[i] = j; - if (is_Primitive_type(tp)) { - ir_mode *mode = get_type_mode(tp); + if (is_Primitive_type(ptp)) { + ir_mode *mode = get_type_mode(ptp); if (mode == env->high_signed || mode == env->high_unsigned) ++j; } } - if (i == j) - return; - mtp = lower_mtp(env, mtp); - set_entity_type(ent, mtp); + /* lower method type */ + tp = lower_mtp(env, tp); + set_entity_type(ent, tp); /* switch off optimization for new Proj nodes or they might be CSE'ed with not patched one's */ rem = get_optimize(); set_optimize(0); - /* ok, fix all Proj's and create new ones */ + /* fix all Proj's and create new ones */ args = get_irg_args(irg); for (proj = (ir_node*)get_irn_link(node); proj; proj = (ir_node*)get_irn_link(proj)) { @@ -1663,28 +1678,20 @@ static void lower_Start(ir_node *node, ir_mode *mode, lower_env_t *env) static void lower_Call(ir_node *node, ir_mode *mode, lower_env_t *env) { ir_type *tp = get_Call_type(node); - ir_type *call_tp; ir_node **in, *proj, *results; - int n_params, n_res; + size_t n_params, n_res; bool need_lower = false; - int i, j; + size_t i, j; + size_t p; long *res_numbers = NULL; (void) mode; - if (is_lowered_type(tp)) { - call_tp = get_associated_type(tp); - } else { - call_tp = tp; - } - - assert(! is_lowered_type(call_tp)); + n_params = get_method_n_params(tp); + for (p = 0; p < n_params; ++p) { + ir_type *ptp = get_method_param_type(tp, p); - n_params = get_method_n_params(call_tp); - for (i = 0; i < n_params; ++i) { - ir_type *tp = get_method_param_type(call_tp, i); - - if (is_Primitive_type(tp)) { - ir_mode *mode = get_type_mode(tp); + if (is_Primitive_type(ptp)) { + ir_mode *mode = get_type_mode(ptp); if (mode == env->high_signed || mode == env->high_unsigned) { need_lower = true; @@ -1692,16 +1699,16 @@ static void lower_Call(ir_node *node, ir_mode *mode, lower_env_t *env) } } } - n_res = get_method_n_ress(call_tp); + n_res = get_method_n_ress(tp); if (n_res > 0) { NEW_ARR_A(long, res_numbers, n_res); for (i = j = 0; i < n_res; ++i, ++j) { - ir_type *tp = get_method_res_type(call_tp, i); + ir_type *ptp = get_method_res_type(tp, i); res_numbers[i] = j; - if (is_Primitive_type(tp)) { - ir_mode *mode = get_type_mode(tp); + if (is_Primitive_type(ptp)) { + ir_mode *mode = get_type_mode(ptp); if (mode == env->high_signed || mode == env->high_unsigned) { need_lower = true; @@ -1715,10 +1722,10 @@ static void lower_Call(ir_node *node, ir_mode *mode, lower_env_t *env) return; /* let's lower it */ - call_tp = lower_mtp(env, call_tp); - set_Call_type(node, call_tp); + tp = lower_mtp(env, tp); + set_Call_type(node, tp); - NEW_ARR_A(ir_node *, in, get_method_n_params(call_tp) + 2); + NEW_ARR_A(ir_node *, in, get_method_n_params(tp) + 2); in[0] = get_Call_mem(node); in[1] = get_Call_ptr(node); @@ -1757,8 +1764,7 @@ static void lower_Call(ir_node *node, ir_mode *mode, lower_env_t *env) /* switch off optimization for new Proj nodes or they might be CSE'ed with not patched one's */ set_optimize(0); - for (i = j = 0, proj = (ir_node*)get_irn_link(results); proj; - proj = (ir_node*)get_irn_link(proj), ++i, ++j) { + for (proj = (ir_node*)get_irn_link(results); proj; proj = (ir_node*)get_irn_link(proj)) { if (get_Proj_pred(proj) == results) { long proj_nr = get_Proj_proj(proj); ir_mode *proj_mode = get_irn_mode(proj); @@ -1913,30 +1919,106 @@ static void lower_Mux(ir_node *mux, ir_mode *mode, lower_env_t *env) */ static void lower_ASM(ir_node *asmn, ir_mode *mode, lower_env_t *env) { - ir_mode *his = env->high_signed; - ir_mode *hiu = env->high_unsigned; + ir_mode *high_signed = env->high_signed; + ir_mode *high_unsigned = env->high_unsigned; + int n_outs = get_ASM_n_output_constraints(asmn); + ir_asm_constraint *output_constraints = get_ASM_output_constraints(asmn); + ir_asm_constraint *input_constraints = get_ASM_input_constraints(asmn); + unsigned n_64bit_outs = 0; int i; ir_node *n; (void)mode; for (i = get_irn_arity(asmn) - 1; i >= 0; --i) { - ir_mode *op_mode = get_irn_mode(get_irn_n(asmn, i)); - if (op_mode == his || op_mode == hiu) { - panic("lowering ASM unimplemented"); + ir_node *op = get_irn_n(asmn, i); + ir_mode *op_mode = get_irn_mode(op); + if (op_mode == high_signed || op_mode == high_unsigned) { + panic("lowering ASM 64bit input unimplemented"); } } - for (n = asmn;;) { - ir_mode *proj_mode; + for (i = 0; i < n_outs; ++i) { + const ir_asm_constraint *constraint = &output_constraints[i]; + if (constraint->mode == high_signed || constraint->mode == high_unsigned) { + const char *constr = get_id_str(constraint->constraint); + ++n_64bit_outs; + /* TODO: How to do this architecture neutral? This is very + * i386 specific... */ + if (constr[0] != '=' || constr[1] != 'A') { + panic("lowering ASM 64bit output only supports '=A' currently"); + } + } + } - n = (ir_node*)get_irn_link(n); - if (n == NULL) - break; + if (n_64bit_outs == 0) + return; - proj_mode = get_irn_mode(n); - if (proj_mode == his || proj_mode == hiu) { - panic("lowering ASM unimplemented"); + { + dbg_info *dbgi = get_irn_dbg_info(asmn); + ir_node *block = get_nodes_block(asmn); + int arity = get_irn_arity(asmn); + ir_node **in = get_irn_in(asmn) + 1; + int n_outs = get_ASM_n_output_constraints(asmn); + int new_n_outs = 0; + int n_clobber = get_ASM_n_clobbers(asmn); + long *proj_map = ALLOCAN(long, n_outs); + ident **clobbers = get_ASM_clobbers(asmn); + ident *asm_text = get_ASM_text(asmn); + ir_asm_constraint *new_outputs + = ALLOCAN(ir_asm_constraint, n_outs+n_64bit_outs); + ir_node *new_asm; + + for (i = 0; i < n_outs; ++i) { + const ir_asm_constraint *constraint = &output_constraints[i]; + if (constraint->mode == high_signed || constraint->mode == high_unsigned) { + new_outputs[new_n_outs].pos = constraint->pos; + new_outputs[new_n_outs].constraint = new_id_from_str("=a"); + new_outputs[new_n_outs].mode = env->low_unsigned; + proj_map[i] = new_n_outs; + ++new_n_outs; + new_outputs[new_n_outs].pos = constraint->pos; + new_outputs[new_n_outs].constraint = new_id_from_str("=d"); + if (constraint->mode == high_signed) + new_outputs[new_n_outs].mode = env->low_signed; + else + new_outputs[new_n_outs].mode = env->low_unsigned; + ++new_n_outs; + } else { + new_outputs[new_n_outs] = *constraint; + proj_map[i] = new_n_outs; + ++new_n_outs; + } + } + assert(new_n_outs == n_outs+(int)n_64bit_outs); + + new_asm = new_rd_ASM(dbgi, block, arity, in, input_constraints, + new_n_outs, new_outputs, n_clobber, clobbers, + asm_text); + + for (n = asmn;;) { + long pn; + ir_mode *proj_mode; + n = (ir_node*)get_irn_link(n); + if (n == NULL) + break; + proj_mode = get_irn_mode(n); + pn = get_Proj_proj(n); + if (pn < n_outs) + pn = proj_map[pn]; + else + pn = new_n_outs + pn - n_outs; + + if (proj_mode == high_signed || proj_mode == high_unsigned) { + ir_mode *high_mode + = proj_mode == high_signed ? env->low_signed : env->low_unsigned; + ir_node *np_low = new_r_Proj(new_asm, env->low_unsigned, pn); + ir_node *np_high = new_r_Proj(new_asm, high_mode, pn+1); + set_lowered(env, n, np_low, np_high); + } else { + ir_node *np = new_r_Proj(new_asm, proj_mode, pn); + exchange(n, np); + } } } } @@ -1953,7 +2035,7 @@ static void lower_Sel(ir_node *sel, ir_mode *mode, lower_env_t *env) if (env->value_param_tp != NULL) { ir_entity *ent = get_Sel_entity(sel); if (get_entity_owner(ent) == env->value_param_tp) { - int pos = get_entity_arg_idx(ent); + size_t pos = get_entity_arg_idx(ent); ent = get_method_value_param_ent(env->l_mtp, pos); set_Sel_entity(sel, ent); @@ -2020,8 +2102,7 @@ static void enter_lower_func(ir_op *op, lower_func func) */ static bool mtp_must_be_lowered(lower_env_t *env, ir_type *mtp) { - int n_params = get_method_n_params(mtp); - int i; + size_t i, n_params = get_method_n_params(mtp); /* first check if we have parameters that must be fixed */ for (i = 0; i < n_params; ++i) { @@ -2132,9 +2213,8 @@ static void lower_node(lower_env_t *env, ir_node *node) unsigned idx; node_entry_t *entry; - if (irn_visited(node)) + if (irn_visited_else_mark(node)) return; - mark_irn_visited(node); /* cycles are always broken at Phi and Block nodes. So we don't need special * magic in all the other lower functions */ @@ -2152,10 +2232,12 @@ static void lower_node(lower_env_t *env, ir_node *node) lower_node(env, block); } - arity = get_irn_arity(node); - for (i = 0; i < arity; ++i) { - ir_node *pred = get_irn_n(node, i); - lower_node(env, pred); + if (!is_Cond(node)) { + arity = get_irn_arity(node); + for (i = 0; i < arity; ++i) { + ir_node *pred = get_irn_n(node, i); + lower_node(env, pred); + } } op = get_irn_op(node); @@ -2202,8 +2284,8 @@ static void lower_irg(lower_env_t *env, ir_graph *irg) if (mtp_must_be_lowered(env, mtp)) { ir_type *ltp = lower_mtp(env, mtp); + /* Do not update the entity type yet, this will be done by lower_Start! */ env->flags |= MUST_BE_LOWERED; - set_entity_type(ent, ltp); env->l_mtp = ltp; env->value_param_tp = get_method_value_param_type(mtp); }