X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeirgmod.c;h=071571689d96e35d6da76f172205c8a9735c2329;hb=4ed245f5007168dab7850942a7ee6b6b29a19817;hp=fc3462abc3e6b8ef5b5f7fbb7a19687268197c22;hpb=229d71bbf8ca927eae27da9831007e1e2a01846b;p=libfirm diff --git a/ir/be/beirgmod.c b/ir/be/beirgmod.c index fc3462abc..071571689 100644 --- a/ir/be/beirgmod.c +++ b/ir/be/beirgmod.c @@ -4,10 +4,11 @@ #include -#ifdef WIN32 -#include -#else -#include +#ifdef HAVE_MALLOC_H + #include +#endif +#ifdef HAVE_ALLOCA_H + #include #endif #include "hashptr.h" @@ -25,17 +26,21 @@ #include "irdom_t.h" #include "iredges_t.h" #include "irgopt.h" +#include "irprintf_t.h" +#include "irgwalk.h" #include "be_t.h" +#include "bechordal_t.h" #include "bearch.h" #include "besched_t.h" #include "belive_t.h" #include "benode_t.h" #include "beutil.h" +#include "beinsn_t.h" #include "beirgmod.h" -#define DBG_MODULE firm_dbg_register("firm.be.irgmod") +#define DBG_MODULE "firm.be.irgmod" #define DBG_LEVEL SET_LEVEL_0 /* @@ -108,7 +113,7 @@ static void compute_df(ir_node *n, pmap *df_map) dom_front_info_t *be_compute_dominance_frontiers(ir_graph *irg) { - dom_front_info_t *info = malloc(sizeof(*info)); + dom_front_info_t *info = xmalloc(sizeof(*info)); edges_assure(irg); info->df_map = pmap_create(); @@ -134,43 +139,44 @@ pset *be_get_dominance_frontier(dom_front_info_t *info, ir_node *block) return pmap_get(info->df_map, block); } -static void determine_phi_blocks(pset *copies, pset* copy_blocks, pset *phi_blocks, dom_front_info_t *df_info) +static void determine_phi_blocks(pset *copies, pset *copy_blocks, pset *phi_blocks, dom_front_info_t *df_info) { ir_node *bl; pdeq *worklist = new_pdeq(); - firm_dbg_module_t *dbg = DBG_MODULE; + FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE); /* - * Fill the worklist queue and the rest of the orig blocks array. - */ + * Fill the worklist queue and the rest of the orig blocks array. + */ for(bl = pset_first(copy_blocks); bl; bl = pset_next(copy_blocks)) { pdeq_putr(worklist, bl); } - while(!pdeq_empty(worklist)) { + while (!pdeq_empty(worklist)) { ir_node *bl = pdeq_getl(worklist); pset *df = be_get_dominance_frontier(df_info, bl); ir_node *y; DBG((dbg, LEVEL_3, "dom front of %+F\n", bl)); - for(y = pset_first(df); y; y = pset_next(df)) - DBG((dbg, LEVEL_3, "\t%+F\n", y)); + DEBUG_ONLY( + for (y = pset_first(df); y; y = pset_next(df)) + DBG((dbg, LEVEL_3, "\t%+F\n", y)) + ); for(y = pset_first(df); y; y = pset_next(df)) { if(!pset_find_ptr(phi_blocks, y)) { pset_insert_ptr(phi_blocks, y); /* - * Clear the link field of a possible phi block, since - * the possibly created phi will be stored there. See, - * search_def() - */ + * Clear the link field of a possible phi block, since + * the possibly created phi will be stored there. See, + * search_def() + */ set_irn_link(y, NULL); if(!pset_find_ptr(copy_blocks, y)) pdeq_putr(worklist, y); - } } } @@ -198,7 +204,7 @@ static void determine_phi_blocks(pset *copies, pset* copy_blocks, pset *phi_bloc * * The usage is given as a node and a position. Initially, the given operand * points to a node for which copies were introduced. We have to find - * the valid copy for this usage. This is done by travering the + * the valid copy for this usage. This is done by traversing the * dominance tree upwards. If the usage is a phi function, we start * traversing from the predecessor block which corresponds to the phi * usage. @@ -216,15 +222,15 @@ static ir_node *search_def(ir_node *usage, int pos, pset *copies, pset *copy_blo { ir_node *curr_bl; ir_node *start_irn; - firm_dbg_module_t *dbg = DBG_MODULE; + FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE); curr_bl = get_nodes_block(usage); DBG((dbg, LEVEL_1, "Searching valid def for use %+F at pos %d\n", usage, pos)); /* - * If the usage is in a phi node, search the copy in the - * predecessor denoted by pos. - */ + * If the usage is in a phi node, search the copy in the + * predecessor denoted by pos. + */ if(is_Phi(usage)) { curr_bl = get_Block_cfgpred_block(curr_bl, pos); start_irn = sched_last(curr_bl); @@ -263,7 +269,7 @@ static ir_node *search_def(ir_node *usage, int pos, pset *copies, pset *copy_blo ir_node **ins = xmalloc(n_preds * sizeof(ins[0])); for(i = 0; i < n_preds; ++i) - ins[i] = new_r_Unknown(irg, mode); + ins[i] = new_r_Bad(irg); phi = new_r_Phi(irg, curr_bl, n_preds, ins, mode); DBG((dbg, LEVEL_2, "\tcreating phi %+F in %+F\n", phi, curr_bl)); @@ -296,29 +302,28 @@ static ir_node *search_def(ir_node *usage, int pos, pset *copies, pset *copy_blo static void fix_usages(pset *copies, pset *copy_blocks, pset *phi_blocks, pset *phis, pset *ignore_uses) { - firm_dbg_module_t *dbg = DBG_MODULE; - int n_outs = 0; - + int n_outs = 0; struct obstack obst; ir_node *irn; int i; - struct out { ir_node *irn; int pos; } *outs; + FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE); + obstack_init(&obst); /* - * Put all outs into an array. - * This is necessary, since the outs would be modified while - * iterating on them what could bring the outs module in trouble. - */ - for(irn = pset_first(copies); irn; irn = pset_next(copies)) { + * Put all outs into an array. + * This is necessary, since the outs would be modified while + * iterating on them what could bring the outs module in trouble. + */ + for (irn = pset_first(copies); irn; irn = pset_next(copies)) { const ir_edge_t *edge; foreach_out_edge(irn, edge) { - if(!pset_find_ptr(ignore_uses, get_edge_src_irn(edge))) { + if (!pset_find_ptr(ignore_uses, get_edge_src_irn(edge))) { struct out tmp; tmp.irn = get_edge_src_irn(edge); tmp.pos = get_edge_src_pos(edge); @@ -382,41 +387,46 @@ static void remove_odd_phis(pset *copies, pset *unused_copies) } } -void be_ssa_constr_phis_ignore(dom_front_info_t *info, int n, ir_node *nodes[], pset *phis, pset *ignore_uses) +void be_ssa_constr_phis_ignore(dom_front_info_t *info, be_lv_t *lv, int n, ir_node *nodes[], pset *phis, pset *ignore_uses) { pset *irns = pset_new_ptr(n); int i; for(i = 0; i < n; ++i) pset_insert_ptr(irns, nodes[i]); - be_ssa_constr_set_phis_ignore(info, irns, phis, ignore_uses); + be_ssa_constr_set_phis_ignore(info, lv, irns, phis, ignore_uses); del_pset(irns); } -void be_ssa_constr_ignore(dom_front_info_t *info, int n, ir_node *nodes[], pset *ignore_uses) +void be_ssa_constr_ignore(dom_front_info_t *info, be_lv_t *lv, int n, ir_node *nodes[], pset *ignore_uses) { - be_ssa_constr_phis_ignore(info, n, nodes, NULL, ignore_uses); + be_ssa_constr_phis_ignore(info, lv, n, nodes, NULL, ignore_uses); } -void be_ssa_constr(dom_front_info_t *info, int n, ir_node *nodes[]) +void be_ssa_constr(dom_front_info_t *info, be_lv_t *lv, int n, ir_node *nodes[]) { pset *empty_set = be_empty_set(); - assert(pset_count(empty_set) == 0); - be_ssa_constr_ignore(info, n, nodes, empty_set); + be_ssa_constr_ignore(info, lv, n, nodes, empty_set); } -void be_ssa_constr_set_phis_ignore(dom_front_info_t *df, pset *nodes, pset *phis, pset *ignore_uses) +void be_ssa_constr_set_phis_ignore(dom_front_info_t *df, be_lv_t *lv, pset *nodes, pset *phis, pset *ignore_uses) { int n = pset_count(nodes); pset *blocks = pset_new_ptr(n); pset *phi_blocks = pset_new_ptr(n); int save_optimize = get_optimize(); int save_normalize = get_opt_normalize(); - firm_dbg_module_t *dbg = DBG_MODULE; + int phis_set_created = 0; + FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE); ir_node *irn; - firm_dbg_set_mask(dbg, DBG_LEVEL); + /* We need to collect the phi functions to compute their liveness. */ + if(lv && !phis) { + phis_set_created = 1; + phis = pset_new_ptr_default(); + } + DBG((dbg, LEVEL_1, "Introducing following copies for:\n")); /* Fill the sets. */ @@ -427,15 +437,15 @@ void be_ssa_constr_set_phis_ignore(dom_front_info_t *df, pset *nodes, pset *phis } /* - * Disable optimization so that the phi functions do not - * disappear. - */ + * Disable optimization so that the phi functions do not + * disappear. + */ set_optimize(0); set_opt_normalize(0); /* - * Place the phi functions and reroute the usages. - */ + * Place the phi functions and reroute the usages. + */ determine_phi_blocks(nodes, blocks, phi_blocks, df); fix_usages(nodes, blocks, phi_blocks, phis, ignore_uses); @@ -446,26 +456,40 @@ void be_ssa_constr_set_phis_ignore(dom_front_info_t *df, pset *nodes, pset *phis del_pset(phi_blocks); del_pset(blocks); + /* Recompute the liveness (if wanted) of the original nodes, the copies and the inserted phis. */ + if(lv) { +#if 1 + foreach_pset(nodes, irn) + be_liveness_update(lv, irn); + + foreach_pset(phis, irn) + be_liveness_introduce(lv, irn); +#else + be_liveness_recompute(lv); +#endif + } + + /* Free the phi set of we created it. */ + if(phis_set_created) + del_pset(phis); + } -void be_ssa_constr_set_phis(dom_front_info_t *df, pset *nodes, pset *phis) +void be_ssa_constr_set_phis(dom_front_info_t *df, be_lv_t *lv, pset *nodes, pset *phis) { pset *empty_set = be_empty_set(); - assert(pset_count(empty_set) == 0); - - be_ssa_constr_set_phis_ignore(df, nodes,phis, empty_set); + be_ssa_constr_set_phis_ignore(df, lv, nodes, phis, empty_set); } -void be_ssa_constr_set_ignore(dom_front_info_t *df, pset *nodes, pset *ignore_uses) +void be_ssa_constr_set_ignore(dom_front_info_t *df, be_lv_t *lv, pset *nodes, pset *ignore_uses) { - be_ssa_constr_set_phis_ignore(df, nodes, NULL, ignore_uses); + be_ssa_constr_set_phis_ignore(df, lv, nodes, NULL, ignore_uses); } -void be_ssa_constr_set(dom_front_info_t *info, pset *nodes) +void be_ssa_constr_set(dom_front_info_t *info, be_lv_t *lv, pset *nodes) { pset *empty_set = be_empty_set(); - assert(pset_count(empty_set) == 0); - be_ssa_constr_set_ignore(info, nodes, empty_set); + be_ssa_constr_set_ignore(info, lv, nodes, empty_set); } /* @@ -478,34 +502,38 @@ void be_ssa_constr_set(dom_front_info_t *info, pset *nodes) */ ir_node *insert_Perm_after(const arch_env_t *arch_env, + be_lv_t *lv, const arch_register_class_t *cls, dom_front_info_t *dom_front, ir_node *pos) { - ir_node *bl = is_Block(pos) ? pos : get_nodes_block(pos); - ir_graph *irg = get_irn_irg(bl); - pset *live = pset_new_ptr_default(); - firm_dbg_module_t *dbg = firm_dbg_register("be.node"); + ir_node *bl = is_Block(pos) ? pos : get_nodes_block(pos); + ir_graph *irg = get_irn_irg(bl); + pset *live = pset_new_ptr_default(); + FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, "be.node"); ir_node *curr, *irn, *perm, **nodes; int i, n; DBG((dbg, LEVEL_1, "Insert Perm after: %+F\n", pos)); - if(!be_liveness_nodes_live_at(arch_env, cls, pos, live)); + be_liveness_nodes_live_at(lv, arch_env, cls, pos, live); n = pset_count(live); - if(n == 0) + if(n == 0) { + del_pset(live); return NULL; + } - nodes = malloc(n * sizeof(nodes[0])); + nodes = xmalloc(n * sizeof(nodes[0])); DBG((dbg, LEVEL_1, "live:\n")); for(irn = pset_first(live), i = 0; irn; irn = pset_next(live), i++) { DBG((dbg, LEVEL_1, "\t%+F\n", irn)); nodes[i] = irn; } + del_pset(live); perm = be_new_Perm(cls, irg, bl, n, nodes); sched_add_after(pos, perm); @@ -526,7 +554,44 @@ ir_node *insert_Perm_after(const arch_env_t *arch_env, copies[0] = perm_op; copies[1] = proj; - be_ssa_constr(dom_front, 2, copies); + + be_ssa_constr(dom_front, lv, 2, copies); } + return perm; } + +struct _elr_closure_t { + struct obstack obst; + const be_chordal_env_t *cenv; +}; + +static void elr_split_walker(ir_node *bl, void *data) +{ + struct _elr_closure_t *c = data; + const be_chordal_env_t *cenv = c->cenv; + const arch_env_t *aenv = cenv->birg->main_env->arch_env; + be_insn_t *insn; + be_insn_env_t ie; + + be_insn_env_init(&ie, cenv->birg, cenv->cls, &c->obst); + + for(insn = be_scan_insn(&ie, sched_first(bl)); !is_Block(insn->irn); insn = be_scan_insn(&ie, insn->next_insn)) { + ir_node *pred = sched_prev(insn->irn); + ir_printf("curr: %+F next: %+F, prev: %+F\n", insn->irn, insn->next_insn, pred); + if(!is_Block(pred) && !is_Phi(insn->irn)) + insert_Perm_after(aenv, cenv->lv, cenv->cls, cenv->dom_front, insn->irn); + } +} + +void extreme_liverange_splitting(struct _be_chordal_env_t *cenv) +{ + struct _elr_closure_t c; + + c.cenv = cenv; + obstack_init(&c.obst); + be_liveness_recompute(cenv->lv); + irg_block_walk_graph(cenv->irg, elr_split_walker, NULL, &c); + be_liveness_recompute(cenv->lv); + obstack_free(&c.obst, NULL); +}