X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Ftailrec.c;h=a9bb3691b33de7ae9e0331343b3b3bc53cc926a7;hb=11b00882d8ddbf207c31565a51030408c8fd646b;hp=230dd6b65538b822129758414262c5d5e8b0268c;hpb=1a3b7d363474ab544c13093a2f0b578718d37c7a;p=libfirm diff --git a/ir/opt/tailrec.c b/ir/opt/tailrec.c index 230dd6b65..a9bb3691b 100644 --- a/ir/opt/tailrec.c +++ b/ir/opt/tailrec.c @@ -22,7 +22,6 @@ * @brief Tail-recursion call optimization. * @date 08.06.2004 * @author Michael Beck - * @version $Id$ */ #include "config.h" @@ -47,7 +46,7 @@ #include "ircons_t.h" #include "irpass.h" -DEBUG_ONLY(static firm_dbg_module_t *dbg); +DEBUG_ONLY(static firm_dbg_module_t *dbg;) /** * the environment for collecting data @@ -73,7 +72,7 @@ static void collect_data(ir_node *node, void *env) case iro_Proj: pred = get_Proj_pred(node); - opcode = get_irn_opcode(pred); + opcode = (ir_opcode)get_irn_opcode(pred); if (opcode == iro_Proj) { ir_node *start = get_Proj_pred(pred); @@ -151,18 +150,8 @@ static void do_opt_tail_rec(ir_graph *irg, tr_env *env) assert(env->n_tail_calls > 0); - /* we add new nodes, so the outs are inconsistent */ - set_irg_outs_inconsistent(irg); - /* we add new blocks and change the control flow */ - set_irg_doms_inconsistent(irg); - set_irg_extblk_inconsistent(irg); - - /* we add a new loop */ - set_irg_loopinfo_inconsistent(irg); - - /* calls are removed */ - set_trouts_inconsistent(); + clear_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE); /* we must build some new nodes WITHOUT CSE */ set_optimize(0); @@ -234,7 +223,6 @@ static void do_opt_tail_rec(ir_graph *irg, tr_env *env) if (n_params > 0) { ir_node *calls; ir_node *args; - ir_node *args_bl; NEW_ARR_A(ir_node **, call_params, env->n_tail_calls); @@ -247,7 +235,6 @@ static void do_opt_tail_rec(ir_graph *irg, tr_env *env) /* build new Proj's and Phi's */ args = get_irg_args(irg); - args_bl = get_nodes_block(args); for (i = 0; i < n_params; ++i) { ir_mode *mode = get_type_mode(get_method_param_type(method_tp, i)); @@ -273,11 +260,8 @@ static void do_opt_tail_rec(ir_graph *irg, tr_env *env) } /* tail recursion was done, all info is invalid */ - set_irg_doms_inconsistent(irg); - set_irg_outs_inconsistent(irg); - set_irg_extblk_inconsistent(irg); - set_irg_loopinfo_state(irg, loopinfo_cf_inconsistent); - set_trouts_inconsistent(); + clear_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE + | IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO); set_irg_callee_info_state(irg, irg_callee_info_inconsistent); set_optimize(rem); @@ -292,7 +276,7 @@ static void do_opt_tail_rec(ir_graph *irg, tr_env *env) } if (n_locs > 0) { - ir_node *bad, *start_block; + ir_node *start_block; ir_node **in; ir_mode **modes; @@ -318,8 +302,6 @@ static void do_opt_tail_rec(ir_graph *irg, tr_env *env) mature_immBlock(start_block); /* no: we can kill all returns */ - bad = get_irg_bad(irg); - for (p = env->rets; p; p = n) { ir_node *block = get_nodes_block(p); ir_node *call, *mem, *jmp, *tuple; @@ -338,20 +320,21 @@ static void do_opt_tail_rec(ir_graph *irg, tr_env *env) set_optimize(rem); for (i = 0; i < env->n_ress; ++i) { + ir_mode *mode = modes[i]; if (env->variants[i] != TR_DIRECT) { - in[i] = get_r_value(irg, i, modes[i]); + in[i] = get_r_value(irg, i, mode); } else { - in[i] = bad; + in[i] = new_r_Bad(irg, mode); } } /* create a new tuple for the return values */ tuple = new_r_Tuple(block, env->n_ress, in); - turn_into_tuple(call, pn_Call_max); - set_Tuple_pred(call, pn_Call_M, mem); - set_Tuple_pred(call, pn_Call_X_regular, jmp); - set_Tuple_pred(call, pn_Call_X_except, bad); - set_Tuple_pred(call, pn_Call_T_result, tuple); + turn_into_tuple(call, pn_Call_max+1); + set_Tuple_pred(call, pn_Call_M, mem); + set_Tuple_pred(call, pn_Call_X_regular, jmp); + set_Tuple_pred(call, pn_Call_X_except, new_r_Bad(irg, mode_X)); + set_Tuple_pred(call, pn_Call_T_result, tuple); for (i = 0; i < env->n_ress; ++i) { ir_node *res = get_Return_res(p, i); @@ -360,7 +343,7 @@ static void do_opt_tail_rec(ir_graph *irg, tr_env *env) } } - exchange(p, bad); + exchange(p, new_r_Bad(irg, mode_X)); } /* finally fix all other returns */ @@ -402,7 +385,7 @@ static void do_opt_tail_rec(ir_graph *irg, tr_env *env) } ssa_cons_finish(irg); } else { - ir_node *bad = get_irg_bad(irg); + ir_node *bad = new_r_Bad(irg, mode_X); /* no: we can kill all returns */ for (p = env->rets; p; p = n) { @@ -575,22 +558,27 @@ static tail_rec_variants find_variant(ir_node *irn, ir_node *call) /* * convert simple tail-calls into loops */ -int opt_tail_rec_irg(ir_graph *irg) +void opt_tail_rec_irg(ir_graph *irg) { - tr_env env; - ir_node *end_block; - int i, n_ress, n_tail_calls = 0; - ir_node *rets = NULL; - ir_type *mtd_type, *call_type; - ir_entity *ent; - ir_graph *rem; + tr_env env; + ir_node *end_block; + int i, n_ress, n_tail_calls = 0; + ir_node *rets = NULL; + ir_type *mtd_type, *call_type; + ir_entity *ent; + ir_graph *rem; + + assure_irg_properties(irg, + IR_GRAPH_PROPERTY_MANY_RETURNS + | IR_GRAPH_PROPERTY_NO_BADS + | IR_GRAPH_PROPERTY_CONSISTENT_OUTS); FIRM_DBG_REGISTER(dbg, "firm.opt.tailrec"); - assure_irg_outs(irg); - - if (! check_lifetime_of_locals(irg)) - return 0; + if (! check_lifetime_of_locals(irg)) { + confirm_irg_properties(irg, IR_GRAPH_PROPERTIES_ALL); + return; + } rem = current_ir_graph; current_ir_graph = irg; @@ -609,12 +597,6 @@ int opt_tail_rec_irg(ir_graph *irg) env.variants[i] = TR_DIRECT; } - /* - * This tail recursion optimization works best - * if the Returns are normalized. - */ - normalize_n_returns(irg); - ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK); end_block = get_irg_end_block(irg); @@ -642,10 +624,10 @@ int opt_tail_rec_irg(ir_graph *irg) /* check if it's a recursive call */ call_ptr = get_Call_ptr(call); - if (! is_Global(call_ptr)) + if (! is_SymConst_addr_ent(call_ptr)) continue; - ent = get_Global_entity(call_ptr); + ent = get_SymConst_entity(call_ptr); if (!ent || get_entity_irg(ent) != irg) continue; @@ -675,10 +657,11 @@ int opt_tail_rec_irg(ir_graph *irg) /* cannot be transformed */ break; } - if (var == TR_DIRECT) + if (var == TR_DIRECT) { var = env.variants[j]; - else if (env.variants[j] == TR_DIRECT) + } else if (env.variants[j] == TR_DIRECT) { env.variants[j] = var; + } if (env.variants[j] != var) { /* not compatible */ DB((dbg, LEVEL_3, " tail recursion fails for %d return value of %+F\n", j, ret)); @@ -708,15 +691,17 @@ int opt_tail_rec_irg(ir_graph *irg) env.n_tail_calls = n_tail_calls; env.rets = rets; do_opt_tail_rec(irg, &env); + confirm_irg_properties(irg, IR_GRAPH_PROPERTIES_NONE); + } else { + confirm_irg_properties(irg, IR_GRAPH_PROPERTIES_ALL); } ir_free_resources(irg, IR_RESOURCE_IRN_LINK); current_ir_graph = rem; - return n_tail_calls; } ir_graph_pass_t *opt_tail_rec_irg_pass(const char *name) { - return def_graph_pass_ret(name ? name : "tailrec", opt_tail_rec_irg); + return def_graph_pass(name ? name : "tailrec", opt_tail_rec_irg); } /* @@ -725,20 +710,14 @@ ir_graph_pass_t *opt_tail_rec_irg_pass(const char *name) void opt_tail_recursion(void) { size_t i, n; - size_t n_opt_applications = 0; FIRM_DBG_REGISTER(dbg, "firm.opt.tailrec"); DB((dbg, LEVEL_1, "Performing tail recursion ...\n")); for (i = 0, n = get_irp_n_irgs(); i < n; ++i) { ir_graph *irg = get_irp_irg(i); - - if (opt_tail_rec_irg(irg)) - ++n_opt_applications; + opt_tail_rec_irg(irg); } - - DB((dbg, LEVEL_1, "Done for %zu of %zu graphs.\n", - n_opt_applications, get_irp_n_irgs())); } ir_prog_pass_t *opt_tail_recursion_pass(const char *name)