X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeirgmod.c;h=a2b2c1f6e9b9f80834b33502565e8465ba656c56;hb=890fe2773c2fdba09fc899c6f51629f4c380059d;hp=b67f4372f1a9345284a21a5e4a68eaedf532784c;hpb=d5bf5328bae8775d4e24bdb81668d52048aaf9cf;p=libfirm diff --git a/ir/be/beirgmod.c b/ir/be/beirgmod.c index b67f4372f..a2b2c1f6e 100644 --- a/ir/be/beirgmod.c +++ b/ir/be/beirgmod.c @@ -1,5 +1,19 @@ +/** + * This file contains the following IRG modifications for be routines: + * - backend dominance information + * - SSA construction for a set of nodes + * - insertion of Perm nodes + * - empty block elimination + * - a simple dead node elimination (set inputs of unreachable nodes to BAD) + * + * Author: Sebastian Hack, Daniel Grund, Matthias Braun, Christian Wuerdig + * Date: 04.05.2005 + * Copyright: (c) Universitaet Karlsruhe + * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. + * CVS-Id: $Id$ + */ #ifdef HAVE_CONFIG_H -#include "config.h" +#include #endif #include @@ -40,8 +54,8 @@ #include "beirgmod.h" -#define DBG_MODULE "firm.be.irgmod" #define DBG_LEVEL SET_LEVEL_0 +DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;) /* ____ _ @@ -56,9 +70,12 @@ */ - -struct _dom_front_info_t { - pmap *df_map; +/** + * The dominance frontier for a graph. + */ +struct _be_dom_front_info_t { + pmap *df_map; /**< A map, mapping every block to a list of its dominance frontier blocks. */ + struct obstack obst; /**< An obstack holding all the frontier data. */ }; /** @@ -71,101 +88,114 @@ struct _dom_front_info_t { */ static INLINE ir_node *get_idom(ir_node *bl) { - ir_node *idom = get_Block_idom(bl); - return idom == NULL ? bl : idom; + ir_node *idom = get_Block_idom(bl); + return idom == NULL ? bl : idom; } -static void compute_df(ir_node *n, pmap *df_map) +/** + * Compute the dominance frontier for a given block. + * + * @param blk the block where the calculation starts + * + * @return the list of all blocks in the dominance frontier of blk + */ +static ir_node **compute_df(ir_node *blk, be_dom_front_info_t *info) { - ir_node *c; - const ir_edge_t *edge; - pset *df = pset_new_ptr_default(); - - /* Add local dominance frontiers */ - foreach_block_succ(n, edge) { - ir_node *y = edge->src; - - if(get_idom(y) != n) - pset_insert_ptr(df, y); - } - - /* - * Go recursively down the dominance tree and add all blocks - * int the dominance frontiers of the children, which are not - * dominated by the given block. - */ - for(c = get_Block_dominated_first(n); c; c = get_Block_dominated_next(c)) { - pset *df_c; - ir_node *w; - - compute_df(c, df_map); - df_c = pmap_get(df_map, c); - - for(w = pset_first(df_c); w; w = pset_next(df_c)) { - if(get_idom(w) != n) - pset_insert_ptr(df, w); - } - } - - pmap_insert(df_map, n, df); + ir_node *c; + const ir_edge_t *edge; + ir_node **df_list = NEW_ARR_F(ir_node *, 0); + ir_node **df; + int len; + + /* Add local dominance frontiers */ + foreach_block_succ(blk, edge) { + ir_node *y = edge->src; + + if (get_idom(y) != blk) { + ARR_APP1(ir_node *, df_list, y); + } + } + /* + * Go recursively down the dominance tree and add all blocks + * into the dominance frontiers of the children, which are not + * dominated by the given block. + */ + for (c = get_Block_dominated_first(blk); c; c = get_Block_dominated_next(c)) { + int i; + ir_node **df_c_list = compute_df(c, info); + + for (i = ARR_LEN(df_c_list) - 1; i >= 0; --i) { + ir_node *w = df_c_list[i]; + if (get_idom(w) != blk) + ARR_APP1(ir_node *, df_list, w); + } + } + + /* now copy the flexible array to the obstack */ + len = ARR_LEN(df_list); + df = NEW_ARR_D(ir_node *, &info->obst, len); + memcpy(df, df_list, len * sizeof(df[0])); + DEL_ARR_F(df_list); + + pmap_insert(info->df_map, blk, df); + return df; } -dom_front_info_t *be_compute_dominance_frontiers(ir_graph *irg) +be_dom_front_info_t *be_compute_dominance_frontiers(ir_graph *irg) { - dom_front_info_t *info = xmalloc(sizeof(*info)); + be_dom_front_info_t *info = xmalloc(sizeof(*info)); - edges_assure(irg); - info->df_map = pmap_create(); - compute_doms(irg); - compute_df(get_irg_start_block(irg), info->df_map); + edges_assure(irg); + obstack_init(&info->obst); + info->df_map = pmap_create(); + assure_doms(irg); + (void)compute_df(get_irg_start_block(irg), info); - return info; + return info; } -void be_free_dominance_frontiers(dom_front_info_t *info) +void be_free_dominance_frontiers(be_dom_front_info_t *info) { - pmap_entry *ent; - - for(ent = pmap_first(info->df_map); ent; ent = pmap_next(info->df_map)) - del_pset(ent->value); - - pmap_destroy(info->df_map); - free(info); + obstack_free(&info->obst, NULL); + pmap_destroy(info->df_map); + free(info); } -pset *be_get_dominance_frontier(dom_front_info_t *info, ir_node *block) +/* Get the dominance frontier of a block. */ +ir_node **be_get_dominance_frontier(be_dom_front_info_t *info, ir_node *block) { - return pmap_get(info->df_map, 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, be_dom_front_info_t *df_info) { ir_node *bl; - pdeq *worklist = new_pdeq(); - FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE); + waitq *worklist = new_waitq(); /* * 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); + for (bl = pset_first(copy_blocks); bl; bl = pset_next(copy_blocks)) { + waitq_put(worklist, bl); } while (!pdeq_empty(worklist)) { - ir_node *bl = pdeq_getl(worklist); - pset *df = be_get_dominance_frontier(df_info, bl); + ir_node *bl = waitq_get(worklist); + ir_node **df = be_get_dominance_frontier(df_info, bl); + int i; ir_node *y; DBG((dbg, LEVEL_3, "dom front of %+F\n", bl)); DEBUG_ONLY( - for (y = pset_first(df); y; y = pset_next(df)) - DBG((dbg, LEVEL_3, "\t%+F\n", y)) + for (i = ARR_LEN(df) - 1; i >= 0; --i) + DBG((dbg, LEVEL_3, "\t%+F\n", df[i])) ); - for(y = pset_first(df); y; y = pset_next(df)) { - if(!pset_find_ptr(phi_blocks, y)) { + for (i = ARR_LEN(df) - 1; i >= 0; --i) { + y = df[i]; + if (!pset_find_ptr(phi_blocks, y)) { pset_insert_ptr(phi_blocks, y); /* @@ -176,12 +206,12 @@ static void determine_phi_blocks(pset *copies, pset *copy_blocks, pset *phi_bloc set_irn_link(y, NULL); if(!pset_find_ptr(copy_blocks, y)) - pdeq_putr(worklist, y); + waitq_put(worklist, y); } } } - del_pdeq(worklist); + del_waitq(worklist); } /* @@ -222,7 +252,6 @@ 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_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE); curr_bl = get_nodes_block(usage); @@ -243,10 +272,12 @@ static ir_node *search_def(ir_node *usage, int pos, pset *copies, pset *copy_blo * predecessor block of the usage. */ while(curr_bl != NULL) { + ir_node *phim; /* * If this block contains a copy, search the block - * instruction by instruction. + * instruction by instruction. If nothing is found + * search for a not scheduled PhiM. */ if(pset_find_ptr(copy_blocks, curr_bl)) { ir_node *irn; @@ -258,6 +289,16 @@ static ir_node *search_def(ir_node *usage, int pos, pset *copies, pset *copy_blo if(pset_find_ptr(copies, irn)) return irn; } + + for(phim = pset_first(copies); phim; phim = pset_next(copies)) { + if(!is_Phi(phim) || !(get_irn_mode(phim) == mode_M)) + continue; + + if(get_nodes_block(phim) == curr_bl) { + pset_break(copies); + return phim; + } + } } if(pset_find_ptr(phi_blocks, curr_bl)) { @@ -280,6 +321,16 @@ static ir_node *search_def(ir_node *usage, int pos, pset *copies, pset *copy_blo for(i = 0; i < n_preds; ++i) { ir_node *arg = search_def(phi, i, copies, copy_blocks, phis, phi_blocks, mode); + if(arg == NULL) { + ir_node *irn; + + ir_fprintf(stderr, "no definition found for %+F at position %d\nCopies: ", phi, i); + for(irn = pset_first(copies); irn; irn = pset_next(copies)) { + ir_fprintf(stderr, "%+F ", irn); + } + ir_fprintf(stderr, "\n\n"); + assert(arg && "no definition found"); + } DBG((dbg, LEVEL_2, "\t\t%+F(%d) -> %+F\n", phi, i, arg)); set_irn_n(phi, i, arg); } @@ -311,8 +362,6 @@ static void fix_usages(pset *copies, pset *copy_blocks, pset *phi_blocks, pset * int pos; } *outs; - FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE); - obstack_init(&obst); /* @@ -323,9 +372,11 @@ static void fix_usages(pset *copies, pset *copy_blocks, pset *phi_blocks, pset * 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))) { + ir_node *src = get_edge_src_irn(edge); + /* ignore all users from ignore_uses or keep-alives (user is End node) */ + if (! pset_find_ptr(ignore_uses, src) && ! is_End(src)) { struct out tmp; - tmp.irn = get_edge_src_irn(edge); + tmp.irn = src; tmp.pos = get_edge_src_pos(edge); obstack_grow(&obst, &tmp, sizeof(tmp)); n_outs++; @@ -347,8 +398,15 @@ static void fix_usages(pset *copies, pset *copy_blocks, pset *phi_blocks, pset * 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) - set_irn_n(irn, pos, def); + if(def == NULL) { + ir_fprintf(stderr, "no definition found for %+F at position %d\nCopies: ", irn, pos); + for(irn = pset_first(copies); irn; irn = pset_next(copies)) { + ir_fprintf(stderr, "%+F ", irn); + } + ir_fprintf(stderr, "\n\n"); + assert(def && "no definition found"); + } + set_irn_n(irn, pos, def); } obstack_free(&obst, NULL); @@ -392,9 +450,9 @@ static void remove_odd_phis(pset *copies, pset *unused_copies) sched_remove(irn); } } -#endif +#endif /* if 0 */ -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) +void be_ssa_constr_phis_ignore(be_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; @@ -405,18 +463,18 @@ void be_ssa_constr_phis_ignore(dom_front_info_t *info, be_lv_t *lv, int n, ir_no del_pset(irns); } -void be_ssa_constr_ignore(dom_front_info_t *info, be_lv_t *lv, int n, ir_node *nodes[], pset *ignore_uses) +void be_ssa_constr_ignore(be_dom_front_info_t *info, be_lv_t *lv, int n, ir_node *nodes[], pset *ignore_uses) { be_ssa_constr_phis_ignore(info, lv, n, nodes, NULL, ignore_uses); } -void be_ssa_constr(dom_front_info_t *info, be_lv_t *lv, int n, ir_node *nodes[]) +void be_ssa_constr(be_dom_front_info_t *info, be_lv_t *lv, int n, ir_node *nodes[]) { pset *empty_set = be_empty_set(); be_ssa_constr_ignore(info, lv, n, nodes, empty_set); } -void be_ssa_constr_set_phis_ignore(dom_front_info_t *df, be_lv_t *lv, pset *nodes, pset *phis, pset *ignore_uses) +void be_ssa_constr_set_phis_ignore(be_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); @@ -424,7 +482,6 @@ void be_ssa_constr_set_phis_ignore(dom_front_info_t *df, be_lv_t *lv, pset *node int save_optimize = get_optimize(); int save_normalize = get_opt_normalize(); int phis_set_created = 0; - FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE); ir_node *irn; @@ -482,18 +539,18 @@ void be_ssa_constr_set_phis_ignore(dom_front_info_t *df, be_lv_t *lv, pset *node } -void be_ssa_constr_set_phis(dom_front_info_t *df, be_lv_t *lv, pset *nodes, pset *phis) +void be_ssa_constr_set_phis(be_dom_front_info_t *df, be_lv_t *lv, pset *nodes, pset *phis) { pset *empty_set = be_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, be_lv_t *lv, pset *nodes, pset *ignore_uses) +void be_ssa_constr_set_ignore(be_dom_front_info_t *df, be_lv_t *lv, pset *nodes, pset *ignore_uses) { be_ssa_constr_set_phis_ignore(df, lv, nodes, NULL, ignore_uses); } -void be_ssa_constr_set(dom_front_info_t *info, be_lv_t *lv, pset *nodes) +void be_ssa_constr_set(be_dom_front_info_t *info, be_lv_t *lv, pset *nodes) { pset *empty_set = be_empty_set(); be_ssa_constr_set_ignore(info, lv, nodes, empty_set); @@ -511,13 +568,12 @@ void be_ssa_constr_set(dom_front_info_t *info, be_lv_t *lv, 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, + be_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; @@ -547,7 +603,7 @@ ir_node *insert_Perm_after(const arch_env_t *arch_env, free(nodes); curr = perm; - for(i = 0; i < n; ++i) { + 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); @@ -578,6 +634,8 @@ 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_lv_t *lv = cenv->birg->lv; + be_dom_front_info_t *dom_front = cenv->birg->dom_front; be_insn_t *insn; be_insn_env_t ie; @@ -586,18 +644,82 @@ static void elr_split_walker(ir_node *bl, void *data) 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); if(!is_Block(pred) && !is_Phi(insn->irn)) - insert_Perm_after(aenv, cenv->lv, cenv->cls, cenv->dom_front, insn->irn); + insert_Perm_after(aenv, lv, cenv->cls, dom_front, insn->irn); } } void extreme_liverange_splitting(struct _be_chordal_env_t *cenv) { struct _elr_closure_t c; + be_lv_t *lv = cenv->birg->lv; c.cenv = cenv; obstack_init(&c.obst); - be_liveness_recompute(cenv->lv); + be_liveness_recompute(lv); irg_block_walk_graph(cenv->irg, elr_split_walker, NULL, &c); - be_liveness_recompute(cenv->lv); + be_liveness_recompute(lv); obstack_free(&c.obst, NULL); } + +/** + * Post-block-walker: Find blocks containing only one jump and + * remove them. + */ +static void remove_empty_block(ir_node *block, void *data) { + const ir_edge_t *edge, *next; + ir_node *node; + int *changed = data; + ir_node *jump = NULL; + + assert(is_Block(block)); + + if (get_Block_n_cfgpreds(block) != 1) + return; + + sched_foreach(block, node) { + if (! is_Jmp(node)) + return; + if (jump != NULL) { + /* we should never have 2 jumps in a block */ + assert(0 && "We should never have 2 jumps in a block"); + return; + } + jump = node; + } + + if (jump == NULL) + return; + + node = get_Block_cfgpred(block, 0); + foreach_out_edge_safe(jump, edge, next) { + ir_node *block = get_edge_src_irn(edge); + int pos = get_edge_src_pos(edge); + + set_irn_n(block, pos, node); + } + + set_Block_cfgpred(block, 0, new_Bad()); + sched_remove(jump); + *changed = 1; +} + +/* removes basic blocks that just contain a jump instruction */ +int be_remove_empty_blocks(ir_graph *irg) { + int changed = 0; + + irg_block_walk_graph(irg, remove_empty_block, NULL, &changed); + if (changed) { + /* invalidate analysis info */ + set_irg_doms_inconsistent(irg); + set_irg_extblk_inconsistent(irg); + set_irg_outs_inconsistent(irg); + } + return changed; +} + +void be_init_irgmod(void) +{ + FIRM_DBG_REGISTER(dbg, "firm.be.irgmod"); +} + +BE_REGISTER_MODULE_CONSTRUCTOR(be_init_irgmod);