X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbespill.c;h=ebb3cc353d21c59a98fd98d453cfc2736b9e2eb7;hb=d300330b1e6df8c8914b8fb70cf38ee1c8ca2634;hp=ff62102c02df4048ae83ec3e1694f19f9616c28d;hpb=1ce363f80e6a204d4011f85813362d9bd1d0e7e4;p=libfirm

diff --git a/ir/be/bespill.c b/ir/be/bespill.c
index ff62102c0..ebb3cc353 100644
--- a/ir/be/bespill.c
+++ b/ir/be/bespill.c
@@ -61,6 +61,7 @@
 #include "beirg_t.h"
 #include "beintlive_t.h"
 #include "bemodule.h"
+#include "be_t.h"
 
 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 
@@ -204,6 +205,9 @@ void be_add_spill(spill_env_t *env, ir_node *to_spill, ir_node *before)
 	assert(! arch_irn_is(env->arch_env, to_spill, dont_spill));
 	DB((dbg, LEVEL_1, "Add spill of %+F before %+F\n", to_spill, before));
 
+	/* Just for safety make sure that we do not insert the spill in front of a phi */
+	for (; is_Phi(before); before = sched_next(before));
+
 	/* spills that are dominated by others are not needed */
 	last = NULL;
 	s    = spill_info->spills;
@@ -435,15 +439,16 @@ static void spill_irn(spill_env_t *env, spill_info_t *spillinfo)
 		return;
 	}
 
-	DBG((dbg, LEVEL_1, "spilling %+F ... ", to_spill));
+	DBG((dbg, LEVEL_1, "spilling %+F ... \n", to_spill));
 	spill = spillinfo->spills;
 	for( ; spill != NULL; spill = spill->next) {
 		ir_node *block  = get_block(spill->before);
 		ir_node *before = spill->before;
 
 		/* place all spills before the reloads (as we can't guarantee the
-		 * same order as the be_add_spill and be_add_reload calls */
-		while(get_irn_idx(sched_prev(before)) > env->new_nodes_idx) {
+		 * same order as the be_add_spill and be_add_reload calls.
+		 * Also make sure that we do not run into Phis when going up. */
+		while(get_irn_idx(sched_prev(before)) > env->new_nodes_idx && !is_Phi(sched_prev(before))) {
 			before = sched_prev(before);
 		}
 
@@ -877,6 +882,40 @@ static void determine_spill_costs(spill_env_t *env, spill_info_t *spillinfo)
 	DB((dbg, LEVEL_1, "spill %+F after definition\n", to_spill));
 }
 
+void make_spill_locations_dominate_irn(spill_env_t *env, ir_node *irn)
+{
+	const spill_info_t *si = get_spillinfo(env, irn);
+	ir_node *start_block   = get_irg_start_block(get_irn_irg(irn));
+	int n_blocks           = get_Block_dom_max_subtree_pre_num(start_block);
+	bitset_t *reloads      = bitset_alloca(n_blocks);
+	reloader_t *r;
+	spill_t *s;
+
+	if (si == NULL)
+		return;
+
+	/* Fill the bitset with the dominance pre-order numbers
+	 * of the blocks the reloads are located in. */
+	for (r = si->reloaders; r != NULL; r = r->next) {
+		ir_node *bl = get_nodes_block(r->reloader);
+		bitset_set(reloads, get_Block_dom_tree_pre_num(bl));
+	}
+
+	/* Now, cancel out all the blocks that are dominated by each spill.
+	 * If the bitset is not empty after that, we have reloads that are
+	 * not dominated by any spill. */
+	for (s = si->spills; s != NULL; s = s->next) {
+		ir_node *bl = get_nodes_block(s->before);
+		int start   = get_Block_dom_tree_pre_num(bl);
+		int end     = get_Block_dom_max_subtree_pre_num(bl);
+
+		bitset_clear_range(reloads, start, end);
+	}
+
+	if (!bitset_is_empty(reloads))
+		be_add_spill(env, si->to_spill, sched_next(si->to_spill));
+}
+
 void be_insert_spills_reloads(spill_env_t *env)
 {
 	ir_graph              *irg       = env->irg;
@@ -886,6 +925,8 @@ void be_insert_spills_reloads(spill_env_t *env)
 	ir_nodeset_iterator_t  iter;
 	ir_node               *node;
 
+	BE_TIMER_PUSH(t_ra_spill_apply);
+
 	env->new_nodes_idx = get_irg_last_idx(irg);
 
 	/* create all phi-ms first, this is needed so, that phis, hanging on
@@ -1056,6 +1097,8 @@ void be_insert_spills_reloads(spill_env_t *env)
 	be_liveness_invalidate(env->birg->lv);
 
 	be_remove_dead_nodes_from_schedule(env->birg);
+
+	BE_TIMER_POP(t_ra_spill_apply);
 }
 
 void be_init_spill(void)