X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbespillbelady.c;h=9b3a72b8aeb47500ef2fd301e7bca51095848841;hb=893a9141a398d8a8e9fa4fd6db8b3fbd4e2d55a5;hp=948278f6c42a5a03d2781845136a6fc4442b0f52;hpb=7fea0e8ae1bf276ccce6e1c511d5b78ca098a78b;p=libfirm diff --git a/ir/be/bespillbelady.c b/ir/be/bespillbelady.c index 948278f6c..9b3a72b8a 100644 --- a/ir/be/bespillbelady.c +++ b/ir/be/bespillbelady.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -28,6 +28,8 @@ #include "config.h" #endif +#include + #include "obst.h" #include "irprintf_t.h" #include "irgraph.h" @@ -70,11 +72,9 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;) (see bespill.h be_get_reload_costs_no_weight) */ #define RELOAD_COST_FACTOR 10 -typedef enum { - value_not_reloaded, /* the value has not been reloaded */ - value_partially_reloaded, /* the value has been reloaded on some paths */ - value_reloaded /* the value has been reloaded on all paths */ -} reloaded_state_t; +#define TIME_UNDEFINED 6666 + +#define PLACE_SPILLS /** * An association between a node and a point in time. @@ -82,7 +82,7 @@ typedef enum { typedef struct loc_t { ir_node *node; unsigned time; /**< A use time (see beuses.h). */ - reloaded_state_t reloaded; /**< the value is a reloaded value */ + bool spilled; /**< the value was already spilled on this path */ } loc_t; typedef struct _workset_t { @@ -171,7 +171,7 @@ static void workset_bulk_fill(workset_t *workset, int count, const loc_t *locs) * Inserts the value @p val into the workset, iff it is not * already contained. The workset must not be full. */ -static void workset_insert(workset_t *workset, ir_node *val, int reloaded) +static void workset_insert(workset_t *workset, ir_node *val, bool spilled) { loc_t *loc; int i; @@ -182,8 +182,8 @@ static void workset_insert(workset_t *workset, ir_node *val, int reloaded) for (i = 0; i < workset->len; ++i) { loc = &workset->vals[i]; if (loc->node == val) { - if(!loc->reloaded) { - loc->reloaded = reloaded; + if (spilled) { + loc->spilled = true; } return; } @@ -193,8 +193,8 @@ static void workset_insert(workset_t *workset, ir_node *val, int reloaded) assert(workset->len < n_regs && "Workset already full!"); loc = &workset->vals[workset->len]; loc->node = val; - loc->reloaded = reloaded; - loc->time = 6666; /* undefined yet */ + loc->spilled = spilled; + loc->time = TIME_UNDEFINED; workset->len++; } @@ -220,16 +220,17 @@ static INLINE void workset_remove(workset_t *workset, ir_node *val) } } -static INLINE int workset_contains(const workset_t *ws, const ir_node *val) +static INLINE const loc_t *workset_contains(const workset_t *ws, + const ir_node *val) { int i; - for(i=0; ilen; ++i) { + for (i = 0; i < ws->len; ++i) { if (ws->vals[i].node == val) - return 1; + return &ws->vals[i]; } - return 0; + return NULL; } /** @@ -281,11 +282,11 @@ static INLINE unsigned get_distance(ir_node *from, unsigned from_step, assert(! (flags & arch_irn_flags_ignore)); use = be_get_next_use(uses, from, from_step, def, skip_from_uses); - if(USES_IS_INFINITE(use.time)) + if (USES_IS_INFINITE(use.time)) return USES_INFINITY; /* We have to keep nonspillable nodes in the workingset */ - if(flags & arch_irn_flags_dont_spill) + if (flags & arch_irn_flags_dont_spill) return 0; costs = be_get_reload_costs_no_weight(senv, def, use.before); @@ -307,6 +308,7 @@ 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 *val; int i; int len; @@ -317,24 +319,29 @@ static void displace(workset_t *new_vals, int is_usage) /* 1. Identify the number of needed slots and the values to reload */ demand = 0; workset_foreach(new_vals, val, iter) { + bool reloaded = false; + /* mark value as used */ if (is_usage) ir_nodeset_insert(&used, val); if (! workset_contains(ws, val)) { - DBG((dbg, DBG_DECIDE, " insert %+F\n", val)); + DB((dbg, DBG_DECIDE, " insert %+F\n", val)); if (is_usage) { - DBG((dbg, DBG_SPILL, "Reload %+F before %+F\n", val, instr)); + DB((dbg, DBG_SPILL, "Reload %+F before %+F\n", val, instr)); be_add_reload(senv, val, instr, cls, 1); + reloaded = true; } } else { - DBG((dbg, DBG_DECIDE, " %+F already in workset\n", val)); + DB((dbg, DBG_DECIDE, " %+F already in workset\n", val)); assert(is_usage); /* remove the value from the current workset so it is not accidently * spilled */ workset_remove(ws, val); } - to_insert[demand++] = val; + spilled[demand] = reloaded; + to_insert[demand] = val; + ++demand; } /* 2. Make room for at least 'demand' slots */ @@ -344,10 +351,12 @@ static void displace(workset_t *new_vals, int is_usage) /* Only make more free room if we do not have enough */ if (spills_needed > 0) { +#ifndef PLACE_SPILLS ir_node *curr_bb = get_nodes_block(instr); workset_t *ws_start = get_block_info(curr_bb)->start_workset; +#endif - DBG((dbg, DBG_DECIDE, " disposing %d values\n", spills_needed)); + DB((dbg, DBG_DECIDE, " disposing %d values\n", spills_needed)); /* calculate current next-use distance for live values */ for (i = 0; i < len; ++i) { @@ -359,24 +368,30 @@ static void displace(workset_t *new_vals, int is_usage) /* sort entries by increasing nextuse-distance*/ workset_sort(ws); - /* Logic for not needed live-ins: If a value is disposed - * before its first usage, remove it from start workset - * We don't do this for phis though */ for (i = len - spills_needed; i < len; ++i) { ir_node *val = ws->vals[i].node; - DBG((dbg, DBG_DECIDE, " disposing node %+F (%u)\n", val, + DB((dbg, DBG_DECIDE, " disposing node %+F (%u)\n", val, workset_get_time(ws, i))); - if(!USES_IS_INFINITE(ws->vals[i].time) - && !ws->vals[i].reloaded) { - //be_add_spill(senv, val, instr); +#ifdef PLACE_SPILLS + if (!USES_IS_INFINITE(ws->vals[i].time) && !ws->vals[i].spilled) { + ir_node *after_pos = sched_prev(instr); + DB((dbg, DBG_DECIDE, "Spill %+F after node %+F\n", val, + after_pos)); + be_add_spill(senv, val, after_pos); } +#endif - if (! ir_nodeset_contains(&used, val)) { +#ifndef PLACE_SPILLS + /* Logic for not needed live-ins: If a value is disposed + * before its first use, remove it from start workset + * We don't do this for phis though */ + if (!is_Phi(val) && ! ir_nodeset_contains(&used, val)) { workset_remove(ws_start, val); - DBG((dbg, DBG_DECIDE, " (and removing %+F from start workset)\n", val)); + DB((dbg, DBG_DECIDE, " (and removing %+F from start workset)\n", val)); } +#endif } /* kill the last 'demand' entries in the array */ @@ -387,7 +402,65 @@ static void displace(workset_t *new_vals, int is_usage) for (i = 0; i < demand; ++i) { ir_node *val = to_insert[i]; - workset_insert(ws, val, 1); + workset_insert(ws, val, spilled[i]); + } +} + +enum { + AVAILABLE_EVERYWHERE, + AVAILABLE_NOWHERE, + AVAILABLE_PARTLY, + AVAILABLE_UNKNOWN +}; + +static unsigned available_in_all_preds(workset_t* const* pred_worksets, + size_t n_pred_worksets, + const ir_node *value, bool is_local_phi) +{ + size_t i; + bool avail_everywhere = true; + bool avail_nowhere = true; + + assert(n_pred_worksets > 0); + + /* value available in all preds? */ + for (i = 0; i < n_pred_worksets; ++i) { + bool found = false; + const workset_t *p_workset = pred_worksets[i]; + int p_len = workset_get_length(p_workset); + int p_i; + const ir_node *l_value; + + if (is_local_phi) { + assert(is_Phi(value)); + l_value = get_irn_n(value, i); + } else { + l_value = value; + } + + for (p_i = 0; p_i < p_len; ++p_i) { + const loc_t *p_l = &p_workset->vals[p_i]; + if (p_l->node != l_value) + continue; + + found = true; + break; + } + + if (found) { + avail_nowhere = false; + } else { + avail_everywhere = false; + } + } + + if (avail_everywhere) { + assert(!avail_nowhere); + return AVAILABLE_EVERYWHERE; + } else if (avail_nowhere) { + return AVAILABLE_NOWHERE; + } else { + return AVAILABLE_PARTLY; } } @@ -399,15 +472,14 @@ static void displace(workset_t *new_vals, int is_usage) * @param loop the loop of the node */ static loc_t to_take_or_not_to_take(ir_node* first, ir_node *node, - ir_loop *loop) + ir_loop *loop, unsigned available) { be_next_use_t next_use; loc_t loc; - loc.time = USES_INFINITY; - loc.node = node; - //loc.reloaded = rand() % 2; /* provoke a bug... */ - loc.reloaded = 0; + loc.time = USES_INFINITY; + loc.node = node; + loc.spilled = false; if (!arch_irn_consider_in_reg_alloc(arch_env, cls, node)) { loc.time = USES_INFINITY; @@ -415,31 +487,41 @@ static loc_t to_take_or_not_to_take(ir_node* first, ir_node *node, } /* 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(arch_env, node) & arch_irn_flags_dont_spill) { loc.time = 0; - DBG((dbg, DBG_START, " %+F taken (dontspill node)\n", node, loc.time)); + DB((dbg, DBG_START, " %+F taken (dontspill node)\n", node, loc.time)); return loc; } next_use = be_get_next_use(uses, first, 0, node, 0); - if(USES_IS_INFINITE(next_use.time)) { + if (USES_IS_INFINITE(next_use.time)) { // the nodes marked as live in shouldn't be dead, so it must be a phi assert(is_Phi(node)); loc.time = USES_INFINITY; - DBG((dbg, DBG_START, " %+F not taken (dead)\n", node)); - if(is_Phi(node)) { - be_spill_phi(senv, node); - } + DB((dbg, DBG_START, " %+F not taken (dead)\n", node)); return loc; } loc.time = next_use.time; - if(next_use.outermost_loop >= get_loop_depth(loop)) { - DBG((dbg, DBG_START, " %+F taken (%u, loop %d)\n", node, loc.time, next_use.outermost_loop)); + if (available == AVAILABLE_EVERYWHERE) { + DB((dbg, DBG_START, " %+F taken (%u, live in all preds)\n", node, + loc.time)); + return loc; + } else if(available == AVAILABLE_NOWHERE) { + DB((dbg, DBG_START, " %+F not taken (%u, live in no pred)\n", node, + loc.time)); + loc.time = USES_INFINITY; + return loc; + } + + if (next_use.outermost_loop >= get_loop_depth(loop)) { + DB((dbg, DBG_START, " %+F taken (%u, loop %d)\n", node, loc.time, + next_use.outermost_loop)); } else { loc.time = USES_PENDING; - DBG((dbg, DBG_START, " %+F delayed (outerloopdepth %d < loopdetph %d)\n", node, next_use.outermost_loop, get_loop_depth(loop))); + DB((dbg, DBG_START, " %+F delayed (outerdepth %d < loopdepth %d)\n", + node, next_use.outermost_loop, get_loop_depth(loop))); } return loc; } @@ -450,7 +532,7 @@ static loc_t to_take_or_not_to_take(ir_node* first, ir_node *node, * beginning of a loop. We try to reload as much values as possible now so they * don't get reloaded inside the loop. */ -static void compute_live_ins(const ir_node *block) +static void decide_start_workset(const ir_node *block) { ir_loop *loop = get_irn_loop(block); ir_node *first; @@ -461,37 +543,72 @@ static void compute_live_ins(const ir_node *block) int i, len, ws_count; int free_slots, free_pressure_slots; unsigned pressure; - //int arity; - //int n_pred_worksets; - //workset_t **pred_worksets; + int arity; + workset_t **pred_worksets; + bool all_preds_known; + + /* check predecessors */ + arity = get_irn_arity(block); + pred_worksets = alloca(sizeof(pred_worksets[0]) * arity); + all_preds_known = true; + for(i = 0; i < arity; ++i) { + ir_node *pred_block = get_Block_cfgpred_block(block, i); + block_info_t *pred_info = get_block_info(pred_block); + + if (pred_info == NULL) { + pred_worksets[i] = NULL; + all_preds_known = false; + } else { + pred_worksets[i] = pred_info->end_workset; + } + } /* Collect all values living at start of block */ starters = NEW_ARR_F(loc_t, 0); delayed = NEW_ARR_F(loc_t, 0); - DBG((dbg, DBG_START, "Living at start of %+F:\n", block)); + DB((dbg, DBG_START, "Living at start of %+F:\n", block)); first = sched_first(block); /* check all Phis first */ sched_foreach(block, node) { + unsigned available; + if (! is_Phi(node)) break; + if (!arch_irn_consider_in_reg_alloc(arch_env, cls, node)) + continue; - loc = to_take_or_not_to_take(first, node, loop); + if (all_preds_known) { + available = available_in_all_preds(pred_worksets, arity, node, true); + } else { + available = AVAILABLE_UNKNOWN; + } + + loc = to_take_or_not_to_take(first, node, loop, available); if (! USES_IS_INFINITE(loc.time)) { if (USES_IS_PENDING(loc.time)) ARR_APP1(loc_t, delayed, loc); else ARR_APP1(loc_t, starters, loc); + } else { + be_spill_phi(senv, node); } } /* check all Live-Ins */ be_lv_foreach(lv, block, be_lv_state_in, i) { ir_node *node = be_lv_get_irn(lv, block, i); + unsigned available; - loc = to_take_or_not_to_take(first, node, loop); + if (all_preds_known) { + available = available_in_all_preds(pred_worksets, arity, node, false); + } else { + available = AVAILABLE_UNKNOWN; + } + + loc = to_take_or_not_to_take(first, node, loop, available); if (! USES_IS_INFINITE(loc.time)) { if (USES_IS_PENDING(loc.time)) @@ -510,13 +627,36 @@ static void compute_live_ins(const ir_node *block) /* so far we only put nodes into the starters list that are used inside * the loop. If register pressure in the loop is low then we can take some * values and let them live through the loop */ - if(free_slots > 0) { + if (free_slots > 0) { qsort(delayed, ARR_LEN(delayed), sizeof(delayed[0]), loc_compare); for (i = 0; i < ARR_LEN(delayed) && i < free_slots; ++i) { - DBG((dbg, DBG_START, " delayed %+F taken\n", delayed[i].node)); - ARR_APP1(loc_t, starters, delayed[i]); - delayed[i].node = NULL; + 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; + } + } + + DB((dbg, DBG_START, " delayed %+F taken\n", loc->node)); + ARR_APP1(loc_t, starters, *loc); + loc->node = NULL; + skip_delayed: + ; } } @@ -524,10 +664,10 @@ static void compute_live_ins(const ir_node *block) * but not in the start workset */ for (i = ARR_LEN(delayed) - 1; i >= 0; --i) { ir_node *node = delayed[i].node; - if(node == NULL || !is_Phi(node) || get_nodes_block(node) != block) + if (node == NULL || !is_Phi(node) || get_nodes_block(node) != block) continue; - DBG((dbg, DBG_START, " spilling delayed phi %+F\n", node)); + DB((dbg, DBG_START, " spilling delayed phi %+F\n", node)); be_spill_phi(senv, node); } DEL_ARR_F(delayed); @@ -548,68 +688,128 @@ static void compute_live_ins(const ir_node *block) if (! is_Phi(node) || get_nodes_block(node) != block) continue; - DBG((dbg, DBG_START, " spilling phi %+F\n", node)); + DB((dbg, DBG_START, " spilling phi %+F\n", node)); be_spill_phi(senv, node); } DEL_ARR_F(starters); -#if 0 - /* determine reloaded status of the values: If there's 1 pred block (which - * is no backedge) where the value is reloaded then we must set it to - * reloaded here. We place spills in all pred where the value was not yet - * reloaded to be sure we have a spill on each path */ - n_pred_worksets = 0; - arity = get_irn_arity(block); - pred_worksets = alloca(sizeof(pred_worksets[0]) * arity); - for(i = 0; i < arity; ++i) { - ir_node *pred_block = get_Block_cfgpred_block(block, i); - block_info_t *pred_info = get_block_info(pred_block); - if(pred_info == NULL) - continue; - - pred_worksets[n_pred_worksets] = pred_info->end_workset; - ++n_pred_worksets; - } - + /* determine spill status of the values: If there's 1 pred block (which + * is no backedge) where the value is spilled then we must set it to + * spilled here. */ for(i = 0; i < ws_count; ++i) { - loc_t *loc = &ws->vals[i]; - ir_node *value = loc->node; - int reloaded; + loc_t *loc = &ws->vals[i]; + ir_node *value = loc->node; + bool spilled; int n; - /* phis from this block aren't reloaded */ - if(get_nodes_block(value) == block) { + /* phis from this block aren't spilled */ + if (get_nodes_block(value) == block) { assert(is_Phi(value)); - loc->reloaded = value_not_reloaded; + loc->spilled = false; continue; } - /* was the value reloaded on any of the other inputs */ - reloaded = 0; - arity = get_Block_n_cfgpreds(block); - for(n = 0; n < n_pred_worksets; ++n) { + /* determine if value was spilled on any predecessor */ + spilled = false; + for(n = 0; n < arity; ++n) { workset_t *pred_workset = pred_worksets[n]; - int p_len = workset_get_length(pred_workset); + int p_len; int p; + if (pred_workset == NULL) + continue; + + p_len = workset_get_length(pred_workset); for(p = 0; p < p_len; ++p) { loc_t *l = &pred_workset->vals[p]; - if(l->node == value) { - if(l->reloaded) { - reloaded = 1; - } - break; + + if (l->node != value) + continue; + + if (l->spilled) { + spilled = true; } + break; } - if(p >= p_len) { - reloaded = 1; + } + + loc->spilled = spilled; + } +} + +#if 0 +static void decide_start_workset2(const ir_node *block) +{ + int arity; + workset_t **pred_worksets; + int p; + int i; + int len; + + /* check if all predecessors are known */ + arity = get_irn_arity(block); + pred_worksets = alloca(sizeof(pred_worksets[0]) * arity); + for (i = 0; i < arity; ++i) { + ir_node *pred_block = get_Block_cfgpred_block(block, i); + block_info_t *pred_info = get_block_info(pred_block); + + if (pred_info == NULL) { + /* not all predecessors known, use decide_start_workset */ + decide_start_workset(block); + return; + } + + pred_worksets[i] = pred_info->end_workset; + } + + /* we construct a new workset */ + workset_clear(ws); + + /* take values live in all pred blocks */ + len = workset_get_length(pred_worksets[0]); + for (p = 0; p < len; ++p) { + const loc_t *l = &pred_worksets[0]->vals[p]; + ir_node *value; + bool spilled = false; + + if (USES_IS_INFINITE(l->time)) + continue; + + /* value available in all preds? */ + value = l->node; + for (i = 1; i < arity; ++i) { + bool found = false; + workset_t *p_workset = pred_worksets[i]; + int p_len = workset_get_length(p_workset); + int p_i; + + for (p_i = 0; p_i < p_len; ++p_i) { + const loc_t *p_l = &p_workset->vals[p_i]; + if (p_l->node != value) + continue; + + found = true; + if (p_l->spilled) + spilled = true; break; } + + if (!found) + break; + } + + /* it was available in all preds */ + if (i >= arity) { + workset_insert(ws, value, spilled); } } -#endif + + /* Copy the best ones from starters to start workset */ + ws_count = MIN(ARR_LEN(starters), n_regs); + workset_bulk_fill(ws, ws_count, starters); } +#endif /** * For the given block @p block, decide for each values @@ -628,7 +828,7 @@ static void belady(ir_node *block) const ir_edge_t *edge; /* no need to process a block twice */ - if(get_block_info(block) != NULL) { + if (get_block_info(block) != NULL) { return; } @@ -639,18 +839,18 @@ static void belady(ir_node *block) ir_node *pred_block = get_Block_cfgpred_block(block, i); block_info_t *pred_info = get_block_info(pred_block); - if(pred_info == NULL) { + if (pred_info == NULL) { /* process predecessor first (it will be in the queue already) */ - if(!is_backedge(block, i)) { + if (!is_backedge(block, i)) { return; } has_backedges = 1; } } (void) has_backedges; - if(arity == 0) { + if (arity == 0) { workset_clear(ws); - } else if(arity == 1) { + } else if (arity == 1) { ir_node *pred_block = get_Block_cfgpred_block(block, 0); block_info_t *pred_info = get_block_info(pred_block); @@ -660,25 +860,25 @@ static void belady(ir_node *block) /* we need 2 heuristics here, for the case when all predecessor blocks * are known and when some are backedges (and therefore can't be known * yet) */ - compute_live_ins(block); + decide_start_workset(block); } - DBG((dbg, DBG_DECIDE, "\n")); - DBG((dbg, DBG_DECIDE, "Decide for %+F\n", block)); + DB((dbg, DBG_DECIDE, "\n")); + DB((dbg, DBG_DECIDE, "Decide for %+F\n", block)); block_info = new_block_info(); set_block_info(block, block_info); - DBG((dbg, DBG_WSETS, "Start workset for %+F:\n", block)); + DB((dbg, DBG_WSETS, "Start workset for %+F:\n", block)); workset_foreach(ws, irn, iter) { - DBG((dbg, DBG_WSETS, " %+F (%u)\n", irn, + DB((dbg, DBG_WSETS, " %+F (%u)\n", irn, workset_get_time(ws, iter))); } block_info->start_workset = workset_clone(ws); /* process the block from start to end */ - DBG((dbg, DBG_WSETS, "Processing...\n")); + DB((dbg, DBG_WSETS, "Processing...\n")); ir_nodeset_init(&used); instr_nr = 0; /* TODO: this leaks (into the obstack)... */ @@ -692,7 +892,7 @@ static void belady(ir_node *block) if (is_Phi(irn)) { continue; } - DBG((dbg, DBG_DECIDE, " ...%+F\n", irn)); + DB((dbg, DBG_DECIDE, " ...%+F\n", irn)); /* set instruction in the workset */ instr = irn; @@ -704,8 +904,8 @@ static void belady(ir_node *block) if (!arch_irn_consider_in_reg_alloc(arch_env, cls, in)) continue; - /* (note that reloaded_value is irrelevant here) */ - workset_insert(new_vals, in, 0); + /* (note that "spilled" is irrelevant here) */ + workset_insert(new_vals, in, false); } displace(new_vals, 1); @@ -718,12 +918,12 @@ static void belady(ir_node *block) ir_node *proj = get_edge_src_irn(edge); if (!arch_irn_consider_in_reg_alloc(arch_env, cls, proj)) continue; - workset_insert(new_vals, proj, 0); + workset_insert(new_vals, proj, false); } } else { if (!arch_irn_consider_in_reg_alloc(arch_env, cls, irn)) continue; - workset_insert(new_vals, irn, 0); + workset_insert(new_vals, irn, false); } displace(new_vals, 0); @@ -733,9 +933,9 @@ static void belady(ir_node *block) /* Remember end-workset for this block */ block_info->end_workset = workset_clone(ws); - DBG((dbg, DBG_WSETS, "End workset for %+F:\n", block)); + DB((dbg, DBG_WSETS, "End workset for %+F:\n", block)); workset_foreach(ws, irn, iter) - DBG((dbg, DBG_WSETS, " %+F (%u)\n", irn, + DB((dbg, DBG_WSETS, " %+F (%u)\n", irn, workset_get_time(ws, iter))); /* add successor blocks into worklist */ @@ -758,8 +958,8 @@ static void fix_block_borders(ir_node *block, void *data) int iter; (void) data; - DBG((dbg, DBG_FIX, "\n")); - DBG((dbg, DBG_FIX, "Fixing %+F\n", block)); + DB((dbg, DBG_FIX, "\n")); + DB((dbg, DBG_FIX, "Fixing %+F\n", block)); start_workset = get_block_info(block)->start_workset; @@ -770,16 +970,16 @@ static void fix_block_borders(ir_node *block, void *data) workset_t *pred_end_workset = get_block_info(pred)->end_workset; ir_node *node; - DBG((dbg, DBG_FIX, " Pred %+F\n", pred)); + DB((dbg, DBG_FIX, " Pred %+F\n", pred)); /* spill all values not used anymore */ workset_foreach(pred_end_workset, node, iter) { ir_node *n2; int iter2; - int found = 0; + bool found = false; workset_foreach(start_workset, n2, iter2) { - if(n2 == node) { - found = 1; + if (n2 == node) { + found = true; break; } /* note that we do not look at phi inputs, becuase the values @@ -788,38 +988,62 @@ static void fix_block_borders(ir_node *block, void *data) * workset */ } -#if 0 - if(!found && be_is_live_out(lv, pred, node) - && !pred_end_workset->vals[iter].reloaded) { - ir_node *insert_point - = be_get_end_of_block_insertion_point(pred); - DBG((dbg, DBG_SPILL, "Spill %+F before %+F\n", node, + if (found) + continue; + +#ifdef PLACE_SPILLS + if (be_is_live_in(lv, block, node) + && !pred_end_workset->vals[iter].spilled) { + ir_node *insert_point; + if (arity > 1) { + insert_point = be_get_end_of_block_insertion_point(pred); + insert_point = sched_prev(insert_point); + } else { + insert_point = block; + } + DB((dbg, DBG_SPILL, "Spill %+F after %+F\n", node, insert_point)); be_add_spill(senv, node, insert_point); } #endif } - /* reload missing values in predecessors */ + /* reload missing values in predecessors, add missing spills */ workset_foreach(start_workset, node, iter) { + const loc_t *l = &start_workset->vals[iter]; + const loc_t *pred_loc; + /* if node is a phi of the current block we reload * the corresponding argument, else node itself */ - if(is_Phi(node) && block == get_nodes_block(node)) { + if (is_Phi(node) && get_nodes_block(node) == block) { node = get_irn_n(node, i); + 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(arch_env, cls, node)) continue; } /* check if node is in a register at end of pred */ - if(workset_contains(pred_end_workset, node)) - continue; - - /* node is not in memory at the end of pred -> reload it */ - DBG((dbg, DBG_FIX, " reload %+F\n", node)); - DBG((dbg, DBG_SPILL, "Reload %+F before %+F,%d\n", node, block, i)); - be_add_reload_on_edge(senv, node, block, i, cls, 1); + pred_loc = workset_contains(pred_end_workset, node); + if (pred_loc != NULL) { +#ifdef PLACE_SPILLS + /* we might have to spill value on this path */ + if (!pred_loc->spilled && l->spilled) { + ir_node *insert_point + = be_get_end_of_block_insertion_point(pred); + insert_point = sched_prev(insert_point); + DB((dbg, DBG_SPILL, "Spill %+F after %+F\n", node, + insert_point)); + be_add_spill(senv, node, insert_point); + } +#endif + } else { + /* node is not in register at the end of pred -> reload it */ + DB((dbg, DBG_FIX, " reload %+F\n", node)); + DB((dbg, DBG_SPILL, "Reload %+F before %+F,%d\n", node, block, i)); + be_add_reload_on_edge(senv, node, block, i, cls, 1); + } } } } @@ -831,7 +1055,7 @@ static void be_spill_belady(be_irg_t *birg, const arch_register_class_t *rcls) be_liveness_assure_sets(be_assure_liveness(birg)); /* construct control flow loop tree */ - if(! (get_irg_loopinfo_state(irg) & loopinfo_cf_consistent)) { + if (! (get_irg_loopinfo_state(irg) & loopinfo_cf_consistent)) { construct_cf_backedges(irg); }