X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbespillbelady.c;h=dc0f872b918da39dcff1fd4f41af2161d853f355;hb=22b354ac921664032c93e5f0176fa668c95dfc60;hp=30814dc97859de473b58dbe8a342cc6ec07d7163;hpb=e07b61c6ed5d198a484761f8a40a4f26520d964d;p=libfirm diff --git a/ir/be/bespillbelady.c b/ir/be/bespillbelady.c index 30814dc97..dc0f872b9 100644 --- a/ir/be/bespillbelady.c +++ b/ir/be/bespillbelady.c @@ -24,9 +24,7 @@ * @date 20.09.2005 * @version $Id$ */ -#ifdef HAVE_CONFIG_H #include "config.h" -#endif #include @@ -43,17 +41,17 @@ #include "irnodeset.h" #include "beutil.h" -#include "bearch_t.h" +#include "bearch.h" #include "beuses.h" -#include "besched_t.h" +#include "besched.h" #include "beirgmod.h" #include "belive_t.h" -#include "benode_t.h" +#include "benode.h" #include "bechordal_t.h" -#include "bespilloptions.h" -#include "beloopana.h" -#include "beirg_t.h" #include "bespill.h" +#include "beloopana.h" +#include "beirg.h" +#include "bespillutil.h" #include "bemodule.h" #define DBG_SPILL 1 @@ -85,7 +83,6 @@ typedef struct _workset_t { } workset_t; static struct obstack obst; -static const arch_env_t *arch_env; static const arch_register_class_t *cls; static const be_lv_t *lv; static be_loopana_t *loop_ana; @@ -99,9 +96,9 @@ static unsigned instr_nr; /**< current instruction number static spill_env_t *senv; /**< see bespill.h */ static ir_node **blocklist; -static bool move_spills = true; -static bool respectloopdepth = true; -static bool improve_known_preds = true; +static int move_spills = true; +static int respectloopdepth = true; +static int improve_known_preds = true; /* factor to weight the different costs of reloading/rematerializing a node (see bespill.h be_get_reload_costs_no_weight) */ static int remat_bonus = 10; @@ -135,12 +132,7 @@ void workset_print(const workset_t *w) */ static workset_t *new_workset(void) { - workset_t *res; - size_t size = sizeof(*res) + n_regs * sizeof(res->vals[0]); - - res = obstack_alloc(&obst, size); - memset(res, 0, size); - return res; + return OALLOCFZ(&obst, workset_t, vals, n_regs); } /** @@ -148,10 +140,8 @@ static workset_t *new_workset(void) */ static workset_t *workset_clone(workset_t *workset) { - workset_t *res; - size_t size = sizeof(*res) + n_regs * sizeof(res->vals[0]); - res = obstack_alloc(&obst, size); - memcpy(res, workset, size); + workset_t *res = OALLOCF(&obst, workset_t, vals, n_regs); + memcpy(res, workset, sizeof(*res) + n_regs * sizeof(res->vals[0])); return res; } @@ -184,7 +174,7 @@ static void workset_insert(workset_t *workset, ir_node *val, bool spilled) loc_t *loc; int i; /* check for current regclass */ - assert(arch_irn_consider_in_reg_alloc(arch_env, cls, val)); + assert(arch_irn_consider_in_reg_alloc(cls, val)); /* check if val is already contained */ for (i = 0; i < workset->len; ++i) { @@ -217,7 +207,7 @@ static void workset_clear(workset_t *workset) /** * Removes the value @p val from the workset if present. */ -static INLINE void workset_remove(workset_t *workset, ir_node *val) +static inline void workset_remove(workset_t *workset, ir_node *val) { int i; for(i = 0; i < workset->len; ++i) { @@ -228,7 +218,7 @@ static INLINE void workset_remove(workset_t *workset, ir_node *val) } } -static INLINE const loc_t *workset_contains(const workset_t *ws, +static inline const loc_t *workset_contains(const workset_t *ws, const ir_node *val) { int i; @@ -265,12 +255,9 @@ typedef struct _block_info_t } block_info_t; -static void *new_block_info(void) +static block_info_t *new_block_info(void) { - block_info_t *res = obstack_alloc(&obst, sizeof(res[0])); - memset(res, 0, sizeof(res[0])); - - return res; + return OALLOCZ(&obst, block_info_t); } #define get_block_info(block) ((block_info_t *)get_irn_link(block)) @@ -279,15 +266,14 @@ static void *new_block_info(void) /** * @return The distance to the next use or 0 if irn has dont_spill flag set */ -static INLINE unsigned get_distance(ir_node *from, unsigned from_step, +static inline unsigned get_distance(ir_node *from, unsigned from_step, const ir_node *def, int skip_from_uses) { be_next_use_t use; - int flags = arch_irn_get_flags(arch_env, def); unsigned costs; unsigned time; - assert(! (flags & arch_irn_flags_ignore)); + assert(!arch_irn_is_ignore(def)); use = be_get_next_use(uses, from, from_step, def, skip_from_uses); time = use.time; @@ -295,7 +281,7 @@ static INLINE unsigned get_distance(ir_node *from, unsigned from_step, return USES_INFINITY; /* We have to keep nonspillable nodes in the workingset */ - if (flags & arch_irn_flags_dont_spill) + if (arch_irn_get_flags(skip_Proj_const(def)) & arch_irn_flags_dont_spill) return 0; /* give some bonus to rematerialisable nodes */ @@ -319,8 +305,8 @@ static INLINE unsigned get_distance(ir_node *from, unsigned from_step, */ static void displace(workset_t *new_vals, int is_usage) { - ir_node **to_insert = alloca(n_regs * sizeof(to_insert[0])); - bool *spilled = alloca(n_regs * sizeof(spilled[0])); + ir_node **to_insert = ALLOCAN(ir_node*, n_regs); + bool *spilled = ALLOCAN(bool, n_regs); ir_node *val; int i; int len; @@ -483,13 +469,13 @@ static loc_t to_take_or_not_to_take(ir_node* first, ir_node *node, loc.node = node; loc.spilled = false; - if (!arch_irn_consider_in_reg_alloc(arch_env, cls, node)) { + if (!arch_irn_consider_in_reg_alloc(cls, node)) { loc.time = USES_INFINITY; return loc; } /* We have to keep nonspillable nodes in the workingset */ - if (arch_irn_get_flags(arch_env, node) & arch_irn_flags_dont_spill) { + if (arch_irn_get_flags(skip_Proj_const(node)) & arch_irn_flags_dont_spill) { loc.time = 0; DB((dbg, DBG_START, " %+F taken (dontspill node)\n", node, loc.time)); return loc; @@ -554,7 +540,7 @@ static void decide_start_workset(const ir_node *block) /* check predecessors */ arity = get_irn_arity(block); - pred_worksets = alloca(sizeof(pred_worksets[0]) * arity); + pred_worksets = ALLOCAN(workset_t*, arity); all_preds_known = true; for(i = 0; i < arity; ++i) { ir_node *pred_block = get_Block_cfgpred_block(block, i); @@ -581,7 +567,7 @@ static void decide_start_workset(const ir_node *block) if (! is_Phi(node)) break; - if (!arch_irn_consider_in_reg_alloc(arch_env, cls, node)) + if (!arch_irn_consider_in_reg_alloc(cls, node)) continue; if (all_preds_known) { @@ -641,21 +627,23 @@ static void decide_start_workset(const ir_node *block) int p, arity; loc_t *loc = & delayed[i]; - /* don't use values which are dead in a known predecessors - * to not induce unnecessary reloads */ - arity = get_irn_arity(block); - for (p = 0; p < arity; ++p) { - ir_node *pred_block = get_Block_cfgpred_block(block, p); - block_info_t *pred_info = get_block_info(pred_block); - - if (pred_info == NULL) - continue; - - if (!workset_contains(pred_info->end_workset, loc->node)) { - DB((dbg, DBG_START, - " delayed %+F not live at pred %+F\n", loc->node, - pred_block)); - goto skip_delayed; + if (!is_Phi(loc->node)) { + /* don't use values which are dead in a known predecessors + * to not induce unnecessary reloads */ + arity = get_irn_arity(block); + for (p = 0; p < arity; ++p) { + ir_node *pred_block = get_Block_cfgpred_block(block, p); + block_info_t *pred_info = get_block_info(pred_block); + + if (pred_info == NULL) + continue; + + if (!workset_contains(pred_info->end_workset, loc->node)) { + DB((dbg, DBG_START, + " delayed %+F not live at pred %+F\n", loc->node, + pred_block)); + goto skip_delayed; + } } } @@ -816,7 +804,7 @@ static void process_block(ir_node *block) workset_clear(new_vals); for(i = 0, arity = get_irn_arity(irn); i < arity; ++i) { ir_node *in = get_irn_n(irn, i); - if (!arch_irn_consider_in_reg_alloc(arch_env, cls, in)) + if (!arch_irn_consider_in_reg_alloc(cls, in)) continue; /* (note that "spilled" is irrelevant here) */ @@ -831,12 +819,12 @@ static void process_block(ir_node *block) foreach_out_edge(irn, edge) { ir_node *proj = get_edge_src_irn(edge); - if (!arch_irn_consider_in_reg_alloc(arch_env, cls, proj)) + if (!arch_irn_consider_in_reg_alloc(cls, proj)) continue; workset_insert(new_vals, proj, false); } } else { - if (!arch_irn_consider_in_reg_alloc(arch_env, cls, irn)) + if (!arch_irn_consider_in_reg_alloc(cls, irn)) continue; workset_insert(new_vals, irn, false); } @@ -930,7 +918,7 @@ static void fix_block_borders(ir_node *block, void *data) assert(!l->spilled); /* we might have unknowns as argument for the phi */ - if (!arch_irn_consider_in_reg_alloc(arch_env, cls, node)) + if (!arch_irn_consider_in_reg_alloc(cls, node)) continue; } @@ -956,12 +944,6 @@ static void fix_block_borders(ir_node *block, void *data) } } -static void add_block(ir_node *block, void *data) -{ - (void) data; - ARR_APP1(ir_node*, blocklist, block); -} - static void be_spill_belady(be_irg_t *birg, const arch_register_class_t *rcls) { int i; @@ -985,7 +967,6 @@ static void be_spill_belady(be_irg_t *birg, const arch_register_class_t *rcls) /* init belady env */ stat_ev_tim_push(); obstack_init(&obst); - arch_env = birg->main_env->arch_env; cls = rcls; lv = be_get_birg_liveness(birg); n_regs = cls->n_regs - be_put_ignore_regs(birg, cls, NULL); @@ -993,8 +974,7 @@ static void be_spill_belady(be_irg_t *birg, const arch_register_class_t *rcls) uses = be_begin_uses(irg, lv); loop_ana = be_new_loop_pressure(birg, cls); senv = be_new_spill_env(birg); - blocklist = NEW_ARR_F(ir_node*, 0); - irg_block_edges_walk(get_irg_start_block(irg), NULL, add_block, NULL); + blocklist = be_get_cfgpostorder(irg); stat_ev_tim_pop("belady_time_init"); stat_ev_tim_push();