X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Ftailrec.c;h=4ae0c528cc5a620345f9366ee96834c3b5efc208;hb=f274dcf35aa0d3f4748387dbddfe50e8d7d44951;hp=5e1cd646211a6f7a88a3c84115aedd61a3d324c0;hpb=83650bafeee321f588a82d64ff0d3e1e6a4192d1;p=libfirm diff --git a/ir/opt/tailrec.c b/ir/opt/tailrec.c index 5e1cd6462..4ae0c528c 100644 --- a/ir/opt/tailrec.c +++ b/ir/opt/tailrec.c @@ -26,7 +26,7 @@ #include #include "tailrec.h" #include "array.h" -#include "irprog.h" +#include "irprog_t.h" #include "irgwalk.h" #include "irgmod.h" #include "irop.h" @@ -98,7 +98,7 @@ static void collect_data(ir_node *node, void *env) /* * the first block has the initial exec as cfg predecessor */ - if (node != current_ir_graph->start_block) { + if (node != get_irg_start_block(current_ir_graph)) { for (i = 0; i < n_pred; ++i) { if (get_Block_cfgpred(node, i) == data->proj_X) { data->block = node; @@ -131,17 +131,18 @@ static void do_opt_tail_rec(ir_graph *irg, ir_node *rets, int n_tail_calls) ir_node *p; int i, j, n_params; collect_t data; - int rem = get_optimize(); - entity *ent = get_irg_entity(irg); - type *method_tp = get_entity_type(ent); + int rem = get_optimize(); + entity *ent = get_irg_entity(irg); + ir_type *method_tp = get_entity_type(ent); assert(n_tail_calls); - /* we add new nodes, so the outs are inconsistant */ + /* 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_dom_inconsistent(irg); + set_irg_doms_inconsistent(irg); + set_irg_extblk_inconsistent(irg); /* we add a new loop */ set_irg_loopinfo_inconsistent(irg); @@ -212,9 +213,10 @@ static void do_opt_tail_rec(ir_graph *irg, ir_node *rets, int n_tail_calls) phis[0] = new_r_Phi(irg, block, n_tail_calls + 1, in, mode_M); - /* build the data phi's */ + /* build the data Phi's */ if (n_params > 0) { ir_node *calls; + ir_node *args; NEW_ARR_A(ir_node **, call_params, n_tail_calls); @@ -224,11 +226,12 @@ static void do_opt_tail_rec(ir_graph *irg, ir_node *rets, int n_tail_calls) ++i; } - /* build new projs and Phi's */ + /* build new Proj's and Phi's */ + args = get_irg_args(irg); for (i = 0; i < n_params; ++i) { ir_mode *mode = get_type_mode(get_method_param_type(method_tp, i)); - in[0] = new_r_Proj(irg, block, irg->args, mode, i); + in[0] = new_r_Proj(irg, block, args, mode, i); for (j = 0; j < n_tail_calls; ++j) in[j + 1] = call_params[j][i]; @@ -251,8 +254,9 @@ static void do_opt_tail_rec(ir_graph *irg, ir_node *rets, int n_tail_calls) } /* tail recursion was done, all info is invalid */ - set_irg_dom_inconsistent(irg); + set_irg_doms_inconsistent(irg); set_irg_outs_inconsistent(irg); + set_irg_extblk_inconsistent(irg); set_irg_loopinfo_state(current_ir_graph, loopinfo_cf_inconsistent); set_trouts_inconsistent(); set_irg_callee_info_state(irg, irg_callee_info_inconsistent); @@ -266,6 +270,8 @@ static void do_opt_tail_rec(ir_graph *irg, ir_node *rets, int n_tail_calls) * the lifetime of locals end with the recursive call. * We do this by checking that no address of a local variable is * stored or transmitted as an argument to a call. + * + * @return non-zero if it's ok to do tail recursion */ static int check_lifetime_of_locals(ir_graph *irg) { @@ -278,7 +284,7 @@ static int check_lifetime_of_locals(ir_graph *irg) for (i = get_irn_n_outs(irg_frame) - 1; i >= 0; --i) { ir_node *succ = get_irn_out(irg_frame, i); - if (get_irn_op(succ) == op_Sel && is_address_taken(succ)) + if (is_Sel(succ) && is_address_taken(succ)) return 0; } return 1; @@ -290,10 +296,9 @@ static int check_lifetime_of_locals(ir_graph *irg) int opt_tail_rec_irg(ir_graph *irg) { ir_node *end_block; - int n_preds; int i, n_tail_calls = 0; ir_node *rets = NULL; - type *mtd_type, *call_type; + ir_type *mtd_type, *call_type; if (! get_opt_tail_recursion() || ! get_opt_optimize()) return 0; @@ -310,21 +315,20 @@ int opt_tail_rec_irg(ir_graph *irg) end_block = get_irg_end_block(irg); set_irn_link(end_block, NULL); - n_preds = get_Block_n_cfgpreds(end_block); - for (i = 0; i < n_preds; ++i) { + for (i = get_Block_n_cfgpreds(end_block) - 1; i >= 0; --i) { ir_node *ret = get_Block_cfgpred(end_block, i); ir_node *call, *call_ptr; entity *ent; - int j, n_ress; + int j; ir_node **ress; - /* search all returns of a block */ - if (get_irn_op(ret) != op_Return) + /* search all Returns of a block */ + if (! is_Return(ret)) continue; /* check, if it's a Return self() */ call = skip_Proj(get_Return_mem(ret)); - if (get_irn_op(call) != op_Call) + if (! is_Call(call)) continue; /* check if it's a recursive call */ @@ -341,18 +345,16 @@ int opt_tail_rec_irg(ir_graph *irg) continue; /* ok, mem is routed to a recursive call, check return args */ - n_ress = get_Return_n_ress(ret); ress = get_Return_res_arr(ret); - - for (j = 0; j < n_ress; ++j) { + for (j = get_Return_n_ress(ret) - 1; j >= 0; --j) { ir_node *irn = skip_Proj(skip_Proj(ress[j])); if (irn != call) { - /* not routed to a call */ - break; + /* not routed to a call */ + break; } } - if (j < n_ress) + if (j >= 0) continue; /* @@ -365,7 +367,7 @@ int opt_tail_rec_irg(ir_graph *irg) if (mtd_type != call_type) { /* * Hmm, the types did not match, bad. - * This can happen in C when no prototyp is given + * This can happen in C when no prototype is given * or K&R style is used. */ #if 0 @@ -407,14 +409,15 @@ void opt_tail_recursion(void) { int i; int n_opt_applications = 0; + ir_graph *irg; if (! get_opt_tail_recursion() || ! get_opt_optimize()) return; - for (i = 0; i < get_irp_n_irgs(); i++) { - current_ir_graph = get_irp_irg(i); + for (i = get_irp_n_irgs() - 1; i >= 0; --i) { + irg = get_irp_irg(i); - if (opt_tail_rec_irg(current_ir_graph)) + if (opt_tail_rec_irg(irg)) ++n_opt_applications; }