X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeirgmod.c;h=77ca78312d40309f1f779e9bc35ed44a5d633d90;hb=6e3e499d6c68aee0c6a9ada6a99f16c4f6f8445b;hp=220312ba7a2155213aa87f1ae9680be44f68f26e;hpb=5e1f95efc1491481487ba22482422b6d6f42bcdb;p=libfirm diff --git a/ir/be/beirgmod.c b/ir/be/beirgmod.c index 220312ba7..77ca78312 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" @@ -35,9 +36,23 @@ #include "beirgmod.h" -#define DBG_MODULE firm_dbg_register("firm.be.irgmod") +#define DBG_MODULE "firm.be.irgmod" #define DBG_LEVEL SET_LEVEL_0 +/* + ____ _ + | _ \ ___ _ __ ___ (_)_ __ __ _ _ __ ___ ___ + | | | |/ _ \| '_ ` _ \| | '_ \ / _` | '_ \ / __/ _ \ + | |_| | (_) | | | | | | | | | | (_| | | | | (_| __/ + |____/ \___/|_| |_| |_|_|_| |_|\__,_|_| |_|\___\___| + | ___| __ ___ _ __ | |_(_) ___ _ __ ___ + | |_ | '__/ _ \| '_ \| __| |/ _ \ '__/ __| + | _|| | | (_) | | | | |_| | __/ | \__ \ + |_| |_| \___/|_| |_|\__|_|\___|_| |___/ + +*/ + + struct _dom_front_info_t { pmap *df_map; }; @@ -94,7 +109,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(); @@ -124,7 +139,7 @@ static void determine_phi_blocks(pset *copies, pset* copy_blocks, pset *phi_bloc { 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. @@ -164,6 +179,20 @@ static void determine_phi_blocks(pset *copies, pset* copy_blocks, pset *phi_bloc del_pdeq(worklist); } +/* + ____ ____ _ + / ___/ ___| / \ + \___ \___ \ / _ \ + ___) |__) / ___ \ + |____/____/_/ \_\ + ____ _ _ _ + / ___|___ _ __ ___| |_ _ __ _ _ ___| |_(_) ___ _ __ + | | / _ \| '_ \/ __| __| '__| | | |/ __| __| |/ _ \| '_ \ + | |__| (_) | | | \__ \ |_| | | |_| | (__| |_| | (_) | | | | + \____\___/|_| |_|___/\__|_| \__,_|\___|\__|_|\___/|_| |_| + +*/ + /** * Find the copy of the given original node whose value is 'active' * at a usage. @@ -175,20 +204,20 @@ static void determine_phi_blocks(pset *copies, pset* copy_blocks, pset *phi_bloc * traversing from the predecessor block which corresponds to the phi * usage. * - * @param usage The node which uses the original node. - * @param pos The number of the argument which corresponds to the - * original node. - * @param copy_blocks A set containing all basic block in which copies - * of the original node are located. - * @param copies A set containing all node which are copies from the - * original node. - * @return The valid copy for usage. + * @param usage The node which uses the original node. + * @param pos The position of the argument which corresponds to the original node. + * @param copies A set containing all node which are copies from the original node. + * @param copy_blocks A set containing all basic block in which copies of the original node are located. + * @param phis A set where all created phis are recorded. + * @param phi_blocks A set of all blocks where Phis shall be inserted (iterated dominance frontier). + * @param mode The mode for the Phi if one has to be created. + * @return The valid copy for usage. */ -static ir_node *search_def(ir_node *usage, int pos, pset *copies, pset *copy_blocks, pset *phi_blocks, ir_mode *mode) +static ir_node *search_def(ir_node *usage, int pos, pset *copies, pset *copy_blocks, pset *phis, pset *phi_blocks, ir_mode *mode) { 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); @@ -232,10 +261,10 @@ static ir_node *search_def(ir_node *usage, int pos, pset *copies, pset *copy_blo if(!phi) { int i, n_preds = get_irn_arity(curr_bl); ir_graph *irg = get_irn_irg(curr_bl); - ir_node **ins = malloc(n_preds * sizeof(ins[0])); + 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)); @@ -245,10 +274,13 @@ static ir_node *search_def(ir_node *usage, int pos, pset *copies, pset *copy_blo free(ins); for(i = 0; i < n_preds; ++i) { - ir_node *arg = search_def(phi, i, copies, copy_blocks, phi_blocks, mode); + ir_node *arg = search_def(phi, i, copies, copy_blocks, phis, phi_blocks, mode); DBG((dbg, LEVEL_2, "\t\t%+F(%d) -> %+F\n", phi, i, arg)); set_irn_n(phi, i, arg); } + + if(phis) + pset_insert_ptr(phis, phi); } return phi; @@ -263,10 +295,10 @@ static ir_node *search_def(ir_node *usage, int pos, pset *copies, pset *copy_blo return NULL; } -static void fix_usages(pset *copies, pset *copy_blocks, pset *phi_blocks, pset *ignore_uses) +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; + FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE); struct obstack obst; ir_node *irn; @@ -308,7 +340,7 @@ static void fix_usages(pset *copies, pset *copy_blocks, pset *phi_blocks, pset * ir_node *def; - def = search_def(irn, pos, copies, copy_blocks, phi_blocks, mode); + def = search_def(irn, pos, copies, copy_blocks, phis, phi_blocks, mode); DBG((dbg, LEVEL_2, "\t%+F(%d) -> %+F\n", irn, pos, def)); if(def != NULL) @@ -351,17 +383,22 @@ static void remove_odd_phis(pset *copies, pset *unused_copies) } } -void be_ssa_constr_ignore(dom_front_info_t *info, int n, ir_node *nodes[], pset *ignore_uses) +void be_ssa_constr_phis_ignore(dom_front_info_t *info, 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_ignore(info, irns, ignore_uses); + be_ssa_constr_set_phis_ignore(info, 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) +{ + be_ssa_constr_phis_ignore(info, n, nodes, NULL, ignore_uses); +} + void be_ssa_constr(dom_front_info_t *info, int n, ir_node *nodes[]) { pset *empty_set = be_empty_set(); @@ -369,14 +406,14 @@ void be_ssa_constr(dom_front_info_t *info, int n, ir_node *nodes[]) be_ssa_constr_ignore(info, n, nodes, empty_set); } -void be_ssa_constr_set_ignore(dom_front_info_t *df, pset *nodes, pset *ignore_uses) +void be_ssa_constr_set_phis_ignore(dom_front_info_t *df, 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; + FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE); ir_node *irn; @@ -401,7 +438,7 @@ void be_ssa_constr_set_ignore(dom_front_info_t *df, pset *nodes, pset *ignore_us * Place the phi functions and reroute the usages. */ determine_phi_blocks(nodes, blocks, phi_blocks, df); - fix_usages(nodes, blocks, phi_blocks, ignore_uses); + fix_usages(nodes, blocks, phi_blocks, phis, ignore_uses); /* reset the optimizations */ set_optimize(save_optimize); @@ -412,10 +449,88 @@ void be_ssa_constr_set_ignore(dom_front_info_t *df, pset *nodes, pset *ignore_us } -void be_ssa_constr_set(dom_front_info_t *info, pset *nodes) +void be_ssa_constr_set_phis(dom_front_info_t *df, 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); +} +void be_ssa_constr_set_ignore(dom_front_info_t *df, pset *nodes, pset *ignore_uses) +{ + be_ssa_constr_set_phis_ignore(df, nodes, NULL, ignore_uses); +} + +void be_ssa_constr_set(dom_front_info_t *info, pset *nodes) +{ + pset *empty_set = be_empty_set(); assert(pset_count(empty_set) == 0); be_ssa_constr_set_ignore(info, nodes, empty_set); } + +/* + ___ _ ____ + |_ _|_ __ ___ ___ _ __| |_ | _ \ ___ _ __ _ __ ___ + | || '_ \/ __|/ _ \ '__| __| | |_) / _ \ '__| '_ ` _ \ + | || | | \__ \ __/ | | |_ | __/ __/ | | | | | | | + |___|_| |_|___/\___|_| \__| |_| \___|_| |_| |_| |_| + +*/ + +ir_node *insert_Perm_after(const arch_env_t *arch_env, + 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_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)); + + n = pset_count(live); + + if(n == 0) { + del_pset(live); + return NULL; + } + + 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); + free(nodes); + + curr = perm; + for(i = 0; i < n; ++i) { + ir_node *copies[2]; + ir_node *perm_op = get_irn_n(perm, i); + const arch_register_t *reg = arch_get_irn_register(arch_env, perm_op); + + ir_mode *mode = get_irn_mode(perm_op); + ir_node *proj = new_r_Proj(irg, bl, perm, mode, i); + arch_set_irn_register(arch_env, proj, reg); + + sched_add_after(curr, proj); + curr = proj; + + copies[0] = perm_op; + copies[1] = proj; + be_ssa_constr(dom_front, 2, copies); + } + return perm; +}