X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyheur4.c;h=ee97153b601fc6dab49a33b8f2e8b1efd3a93b98;hb=b0e09fe0aada2e5d9dc0299e969b3c93c1092d97;hp=21d54436c05283b834ccbe9d3a1225d71dd5b0e7;hpb=11108f4ca68e22a5f9cebee6cbd0a36b4efbe9dc;p=libfirm

diff --git a/ir/be/becopyheur4.c b/ir/be/becopyheur4.c
index 21d54436c..ee97153b6 100644
--- a/ir/be/becopyheur4.c
+++ b/ir/be/becopyheur4.c
@@ -41,11 +41,12 @@
 #include "raw_bitset.h"
 #include "irphase_t.h"
 #include "pqueue.h"
-#include "pset_new.h"
 #include "xmalloc.h"
 #include "pdeq.h"
+#include "pset.h"
 #include "irprintf.h"
 #include "irbitset.h"
+#include "error.h"
 
 #include "bearch.h"
 #include "beifg.h"
@@ -73,9 +74,12 @@ typedef struct _col_cost_t {
  * An affinity chunk.
  */
 typedef struct _aff_chunk_t {
+	ir_node  **n;                   /**< An ARR_F containing all nodes of the chunk. */
 	bitset_t *nodes;                /**< A bitset containing all nodes inside this chunk. */
+	bitset_t *interfere;            /**< A bitset containing all interfering neighbours of the nodes in this chunk. */
 	int      weight;                /**< Weight of this chunk */
 	unsigned weight_consistent : 1; /**< Set if the weight is consistent. */
+	unsigned deleted           : 1; /**< Set if the was deleted. */
 	int      id;                    /**< For debugging: An id of this chunk. */
 } aff_chunk_t;
 
@@ -93,10 +97,9 @@ typedef struct _co_mst_env_t {
 	int              n_regs;         /**< number of regs in class */
 	int              k;              /**< number of non-ignore registers in class */
 	bitset_t         *ignore_regs;   /**< set containing all global ignore registers */
-	int              *map_regs;      /**< map the available colors to the available registers */
 	ir_phase         ph;             /**< phase object holding data for nodes */
 	pqueue           *chunks;        /**< priority queue for chunks */
-	pset_new_t       chunkset;       /**< set holding all chunks */
+	pset             *chunkset;      /**< set holding all chunks */
 	be_ifg_t         *ifg;           /**< the interference graph */
 	const arch_env_t *aenv;          /**< the arch environment */
 	copy_opt_t       *co;            /**< the copy opt object */
@@ -127,7 +130,7 @@ typedef int decide_func_t(const co_mst_irn_t *node, int col);
  * Write a chunk to stderr for debugging.
  */
 static void dbg_aff_chunk(const co_mst_env_t *env, const aff_chunk_t *c) {
-	int idx;
+	bitset_pos_t idx;
 	if (c->weight_consistent)
 		ir_fprintf(stderr, " $%d ", c->weight);
 	ir_fprintf(stderr, "{");
@@ -142,7 +145,9 @@ static void dbg_aff_chunk(const co_mst_env_t *env, const aff_chunk_t *c) {
  * Dump all admissible colors to stderr.
  */
 static void dbg_admissible_colors(const co_mst_env_t *env, const co_mst_irn_t *node) {
-	int idx;
+	bitset_pos_t idx;
+	(void) env;
+
 	if (bitset_popcnt(node->adm_colors) < 1)
 		fprintf(stderr, "no admissible colors?!?");
 	else {
@@ -188,6 +193,8 @@ static int decider_hasnot_color(const co_mst_irn_t *node, int col) {
  * Always returns true.
  */
 static int decider_always_yes(const co_mst_irn_t *node, int col) {
+	(void) node;
+	(void) col;
 	return 1;
 }
 
@@ -221,9 +228,11 @@ static INLINE aff_chunk_t *new_aff_chunk(co_mst_env_t *env) {
 	aff_chunk_t *c = xmalloc(sizeof(*c));
 	c->weight            = -1;
 	c->weight_consistent = 0;
+	c->n                 = NEW_ARR_F(ir_node *, 0);
 	c->nodes             = bitset_irg_malloc(env->co->irg);
+	c->interfere         = bitset_irg_malloc(env->co->irg);
 	c->id                = last_chunk_id++;
-	pset_new_insert(&env->chunkset, c);
+	pset_insert(env->chunkset, c, c->id);
 	return c;
 }
 
@@ -231,8 +240,11 @@ static INLINE aff_chunk_t *new_aff_chunk(co_mst_env_t *env) {
  * Frees all memory allocated by an affinity chunk.
  */
 static INLINE void delete_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
-	pset_new_remove(&env->chunkset, c);
+	pset_remove(env->chunkset, c, c->id);
 	bitset_free(c->nodes);
+	bitset_free(c->interfere);
+	DEL_ARR_F(c->n);
+	c->deleted = 1;
 	free(c);
 }
 
@@ -240,9 +252,21 @@ static INLINE void delete_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
  * Adds a node to an affinity chunk
  */
 static INLINE void aff_chunk_add_node(aff_chunk_t *c, co_mst_irn_t *node) {
+	int i;
+
+	if (bitset_is_set(c->nodes, get_irn_idx(node->irn)))
+		return;
+
 	c->weight_consistent = 0;
 	node->chunk          = c;
 	bitset_set(c->nodes, get_irn_idx(node->irn));
+
+	ARR_APP1(ir_node *, c->n, node->irn);
+
+	for (i = node->n_neighs - 1; i >= 0; --i) {
+		ir_node *neigh = node->int_neighs[i];
+		bitset_set(c->interfere, get_irn_idx(neigh));
+	}
 }
 
 /**
@@ -289,8 +313,10 @@ static void *co_mst_irn_init(ir_phase *ph, ir_node *irn, void *old) {
 		/* build list of interfering neighbours */
 		len = 0;
 		be_ifg_foreach_neighbour(env->ifg, nodes_it, irn, neigh) {
-			obstack_ptr_grow(phase_obst(ph), neigh);
-			++len;
+			if (! arch_irn_is(env->aenv, neigh, ignore)) {
+				obstack_ptr_grow(phase_obst(ph), neigh);
+				++len;
+			}
 		}
 		res->int_neighs = obstack_finish(phase_obst(ph));
 		res->n_neighs   = len;
@@ -302,17 +328,8 @@ static void *co_mst_irn_init(ir_phase *ph, ir_node *irn, void *old) {
  * Check if affinity chunk @p chunk interferes with node @p irn.
  */
 static INLINE int aff_chunk_interferes(co_mst_env_t *env, const aff_chunk_t *chunk, ir_node *irn) {
-	const co_mst_irn_t *node = get_co_mst_irn(env, irn);
-	const ir_node      *neigh;
-	int                i;
-
-	for (i = 0; i < node->n_neighs; ++i) {
-		neigh = node->int_neighs[i];
-		if (! arch_irn_is(env->aenv, neigh, ignore) && bitset_is_set(chunk->nodes, get_irn_idx(neigh)))
-			return 1;
-	}
-
-	return 0;
+	(void) env;
+	return bitset_is_set(chunk->interfere, get_irn_idx(irn));
 }
 
 /**
@@ -323,20 +340,17 @@ static INLINE int aff_chunk_interferes(co_mst_env_t *env, const aff_chunk_t *chu
  * @return 1 if there are interferences between nodes of c1 and c2, 0 otherwise.
  */
 static INLINE int aff_chunks_interfere(co_mst_env_t *env, const aff_chunk_t *c1, const aff_chunk_t *c2) {
-	int idx;
+	bitset_t *tmp;
 
 	if (c1 == c2)
 		return 0;
 
 	/* check if there is a node in c2 having an interfering neighbor in c1 */
-	bitset_foreach(c2->nodes, idx) {
-		ir_node *n = get_idx_irn(env->co->irg, idx);
-
-		if (aff_chunk_interferes(env, c1, n))
-			return 1;
-	}
+	tmp = bitset_alloca(get_irg_last_idx(env->co->irg));
+	tmp = bitset_copy(tmp, c1->interfere);
+	tmp = bitset_and(tmp, c2->nodes);
 
-	return 0;
+	return bitset_popcnt(tmp) > 0;
 }
 
 /**
@@ -404,17 +418,22 @@ static int aff_chunk_absorb(co_mst_env_t *env, ir_node *src, ir_node *tgt) {
 			goto absorbed;
 		}
 	} else if (c1 != c2 && ! aff_chunks_interfere(env, c1, c2)) {
-		int idx;
+		int idx, len;
 
-		bitset_or(c1->nodes, c2->nodes);
-		c1->weight_consistent = 0;
-
-		bitset_foreach(c2->nodes, idx) {
-			ir_node      *n  = get_idx_irn(env->co->irg, idx);
+		for (idx = 0, len = ARR_LEN(c2->n); idx < len; ++idx) {
+			ir_node      *n  = c2->n[idx];
 			co_mst_irn_t *mn = get_co_mst_irn(env, n);
+
 			mn->chunk = c1;
+
+			if (! bitset_is_set(c1->nodes, get_irn_idx(n)))
+				ARR_APP1(ir_node *, c1->n, n);
 		}
 
+		bitset_or(c1->nodes, c2->nodes);
+		bitset_or(c1->interfere, c2->interfere);
+		c1->weight_consistent = 0;
+
 		delete_aff_chunk(env, c2);
 		goto absorbed;
 	}
@@ -432,17 +451,17 @@ absorbed:
 static void aff_chunk_assure_weight(const co_mst_env_t *env, aff_chunk_t *c) {
 	if (! c->weight_consistent) {
 		int w = 0;
-		int idx;
+		int idx, len;
 
-		bitset_foreach(c->nodes, idx) {
-			ir_node               *n  = get_idx_irn(env->co->irg, idx);
+		for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
+			ir_node               *n  = c->n[idx];
 			const affinity_node_t *an = get_affinity_info(env->co, n);
 
 			if (an != NULL) {
 				neighb_t *neigh;
 				co_gs_foreach_neighb(an, neigh) {
-					const ir_node      *m    = neigh->irn;
-					const int          m_idx = get_irn_idx(m);
+					const ir_node *m    = neigh->irn;
+					const int     m_idx = get_irn_idx(m);
 
 					/* skip ignore nodes */
 					if (arch_irn_is(env->aenv, m, ignore))
@@ -500,7 +519,6 @@ static void build_affinity_chunks(co_mst_env_t *env) {
 	ir_node     *n;
 	int         i, len;
 	aff_chunk_t *curr_chunk;
-	pset_new_iterator_t iter;
 
 	/* at first we create the affinity edge objects */
 	be_ifg_foreach_node(env->ifg, nodes_it, n) {
@@ -520,6 +538,8 @@ static void build_affinity_chunks(co_mst_env_t *env) {
 
 			if (n1->int_aff_neigh < 0)
 				n1->int_aff_neigh = count_interfering_aff_neighs(env, an);
+
+			/* build the affinity edges */
 			co_gs_foreach_neighb(an, neigh) {
 				ir_node *m    = neigh->irn;
 				int     m_idx = get_irn_idx(m);
@@ -558,7 +578,7 @@ static void build_affinity_chunks(co_mst_env_t *env) {
 	}
 
 	/* now insert all chunks into a priority queue */
-	foreach_pset_new(&env->chunkset, curr_chunk, iter) {
+	foreach_pset(env->chunkset, curr_chunk) {
 		aff_chunk_assure_weight(env, curr_chunk);
 
 		DBG((dbg, LEVEL_1, "entry #%d", curr_chunk->id));
@@ -596,7 +616,7 @@ static void expand_chunk_from(co_mst_env_t *env, co_mst_irn_t *node, bitset_t *v
 {
 	waitq *nodes = new_waitq();
 
-	DBG((dbg, LEVEL_1, "\nExpanding new chunk (id %d) from %+F:", chunk->id, node->irn));
+	DBG((dbg, LEVEL_1, "\n\tExpanding new chunk (#%d) from %+F, color %d:", chunk->id, node->irn, col));
 
 	/* init queue and chunk */
 	waitq_put(nodes, node);
@@ -657,29 +677,31 @@ static void expand_chunk_from(co_mst_env_t *env, co_mst_irn_t *node, bitset_t *v
  */
 static aff_chunk_t *fragment_chunk(co_mst_env_t *env, int col, aff_chunk_t *c, waitq *tmp) {
 	bitset_t    *visited = bitset_irg_malloc(env->co->irg);
-	int         idx;
+	int         idx, len;
 	aff_chunk_t *best = NULL;
 
-	bitset_foreach(c->nodes, idx) {
+	for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
 		ir_node       *irn;
 		co_mst_irn_t  *node;
 		aff_chunk_t   *tmp_chunk;
 		decide_func_t *decider;
 		int           check_for_best;
 
-		if (bitset_is_set(visited, idx))
+		irn = c->n[idx];
+		if (bitset_is_set(visited, get_irn_idx(irn)))
 			continue;
 
-		irn  = get_idx_irn(env->co->irg, idx);
 		node = get_co_mst_irn(env, irn);
 
 		if (get_mst_irn_col(node) == col) {
 			decider        = decider_has_color;
 			check_for_best = 1;
+			DBG((dbg, LEVEL_4, "\tcolor %d wanted", col));
 		}
 		else {
 			decider        = decider_hasnot_color;
 			check_for_best = 0;
+			DBG((dbg, LEVEL_4, "\tcolor %d forbidden", col));
 		}
 
 		/* create a new chunk starting at current node */
@@ -732,10 +754,13 @@ static INLINE void col_cost_init_single(co_mst_env_t *env, col_cost_t *cost, int
  * ATTENTION: the queue is empty after calling this function!
  */
 static INLINE void reject_coloring(waitq *nodes) {
+	DB((dbg, LEVEL_4, "\treject coloring for"));
 	while (! waitq_empty(nodes)) {
 		co_mst_irn_t *n = waitq_get(nodes);
+		DB((dbg, LEVEL_4, " %+F", n->irn));
 		n->tmp_fixed = 0;
 	}
+	DB((dbg, LEVEL_4, "\n"));
 }
 
 /**
@@ -744,7 +769,8 @@ static INLINE void reject_coloring(waitq *nodes) {
 static void determine_color_costs(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs) {
 	affinity_node_t *an = get_affinity_info(env->co, node->irn);
 	neighb_t        *aff_neigh;
-	int             idx, i;
+	bitset_pos_t     idx;
+	int              i;
 
 	col_cost_init(env, costs, 0.0);
 
@@ -878,6 +904,7 @@ static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *cost
 		assert(! node->tmp_fixed && "Node must not have been temporary fixed.");
 		node->tmp_fixed = 1;
 		node->tmp_col   = tgt_col;
+		DBG((dbg, LEVEL_4, "\tTemporary setting %+F to color %d\n", node->irn, tgt_col));
 
 		assert(waitq_empty(local_changed) && "Node queue should be empty here.");
 		waitq_put(local_changed, node);
@@ -894,6 +921,8 @@ static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *cost
 				continue;
 
 			nn = get_co_mst_irn(env, neigh);
+			DB((dbg, LEVEL_4, "\tHandling neighbour %+F, at position %d (fixed: %d, tmp_fixed: %d, tmp_col: %d, col: %d)\n",
+				neigh, j, nn->fixed, nn->tmp_fixed, nn->tmp_col, nn->col));
 
 			/*
 				Try to change the color of the neighbor and record all nodes which
@@ -972,7 +1001,7 @@ static int change_node_color(co_mst_env_t *env, co_mst_irn_t *node, int tgt_col,
 		return res;
 	}
 
-	DEBUG_ONLY(
+#ifndef NDEBUG
 		if (firm_dbg_get_mask(dbg) & LEVEL_4) {
 			if (node->fixed || node->tmp_fixed)
 				DB((dbg, LEVEL_4, "\t\tCNC: %+F has already fixed color %d\n", node->irn, col));
@@ -982,7 +1011,7 @@ static int change_node_color(co_mst_env_t *env, co_mst_irn_t *node, int tgt_col,
 				DB((dbg, LEVEL_4, ")\n"));
 			}
 		}
-	)
+#endif
 
 	return 0;
 }
@@ -994,34 +1023,60 @@ static int change_node_color(co_mst_env_t *env, co_mst_irn_t *node, int tgt_col,
 static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 	aff_chunk_t *best_chunk   = NULL;
 	int         best_color    = -1;
+	int         did_all       = 0;
 	waitq       *changed_ones = new_waitq();
 	waitq       *tmp_chunks   = new_waitq();
+	waitq       *best_starts  = NULL;
 	bitset_t    *visited;
-	int         col, idx;
+	int         col, idx, len;
 
 	DB((dbg, LEVEL_2, "fragmentizing chunk #%d", c->id));
 	DBG_AFF_CHUNK(env, LEVEL_2, c);
 	DB((dbg, LEVEL_2, "\n"));
 
 
-	/* check which color is the "best" for the given chunk */
-	for (col = 0; col < env->k; ++col) {
-		int         reg_col = env->map_regs[col];
-		int         one_good = 0;
+	/* check which color is the "best" for the given chunk.
+	 * if we found a color which was ok for all nodes, we take it
+	 * and do not look further. (see did_all flag usage below.)
+	 * If we have many colors which fit all nodes it is hard to decide
+	 * which one to take anyway.
+	 * TODO Sebastian: Perhaps we should at all nodes and figure out
+	 * a suitable color using costs as done above (determine_color_costs).
+	 */
+	for (col = 0; col < env->n_regs && !did_all; ++col) {
+		int         one_good     = 0;
+		waitq       *good_starts = new_waitq();
 		aff_chunk_t *local_best;
 
-		DB((dbg, LEVEL_3, "\ttrying color %d\n", reg_col));
+		/* skip ignore colors */
+		if (bitset_is_set(env->ignore_regs, col))
+			continue;
+
+		DB((dbg, LEVEL_3, "\ttrying color %d\n", col));
+
+		/* suppose we can color all nodes to the same color */
+		did_all = 1;
 
 		/* try to bring all nodes of given chunk to the current color. */
-		bitset_foreach(c->nodes, idx) {
-			ir_node      *irn  = get_idx_irn(env->co->irg, idx);
+		for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
+			ir_node      *irn  = c->n[idx];
 			co_mst_irn_t *node = get_co_mst_irn(env, irn);
+			int          good  = 0;
 
 			assert(! node->fixed && "Node must not have a fixed color.");
+			DB((dbg, LEVEL_4, "\t\tBringing %+F from color %d to color %d ...\n", irn, node->col, col));
 
-			DB((dbg, LEVEL_4, "\t\tBringing %+F from color %d to color %d ...\n", irn, node->col, reg_col));
-			one_good |= change_node_color(env, node, reg_col, changed_ones);
-			DB((dbg, LEVEL_4, "\t\t... %+F attempt from %d to %d %s\n", irn, node->col, reg_col, one_good ? "succeeded" : "failed"));
+			/*
+				The order of the colored nodes is important, so we record the successfully
+				colored ones in the order they appeared.
+			*/
+			good = change_node_color(env, node, col, changed_ones);
+			if (good)
+				waitq_put(good_starts, node);
+			one_good |= good;
+			did_all  &= good;
+
+			DB((dbg, LEVEL_4, "\t\t... %+F attempt from %d to %d %s\n", irn, node->col, col, one_good ? "succeeded" : "failed"));
 		}
 
 		/* try next color when failed */
@@ -1029,24 +1084,31 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 			continue;
 
 		/* fragment the chunk according to the coloring */
-		local_best = fragment_chunk(env, reg_col, c, tmp_chunks);
+		local_best = fragment_chunk(env, col, c, tmp_chunks);
 
 		/* search the best of the good list
 		   and make it the new best if it is better than the current */
 		if (local_best) {
 			aff_chunk_assure_weight(env, local_best);
 
-			DB((dbg, LEVEL_4, "\t\tlocal best chunk (id %d) for color %d: ", local_best->id, reg_col));
+			DB((dbg, LEVEL_4, "\t\tlocal best chunk (id %d) for color %d: ", local_best->id, col));
 			DBG_AFF_CHUNK(env, LEVEL_4, local_best);
 
 			if (! best_chunk || best_chunk->weight < local_best->weight) {
 				best_chunk = local_best;
-				best_color = reg_col;
+				best_color = col;
+				if (best_starts)
+					del_waitq(best_starts);
+				best_starts = good_starts;
 				DB((dbg, LEVEL_4, "\n\t\t... setting global best chunk (id %d), color %d\n", best_chunk->id, best_color));
 			} else {
 				DB((dbg, LEVEL_4, "\n\t\t... omitting, global best is better\n"));
+				del_waitq(good_starts);
 			}
 		}
+		else {
+			del_waitq(good_starts);
+		}
 
 		/* reject the coloring and bring the coloring to the initial state */
 		reject_coloring(changed_ones);
@@ -1063,6 +1125,8 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 	/* return if coloring failed */
 	if (! best_chunk) {
 		del_waitq(changed_ones);
+		if (best_starts)
+			del_waitq(best_starts);
 		return;
 	}
 
@@ -1071,13 +1135,29 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 	DB((dbg, LEVEL_2, "using color %d\n", best_color));
 
 	/* get the best fragment from the best list and color it */
-	bitset_foreach(best_chunk->nodes, idx) {
-		ir_node      *irn  = get_idx_irn(env->co->irg, idx);
+	while (! waitq_empty(best_starts)) {
+		co_mst_irn_t *node = waitq_get(best_starts);
+		int          res;
+
+		if (! bitset_is_set(best_chunk->nodes, get_irn_idx(node->irn)))
+			continue;
+
+		res = change_node_color(env, node, best_color, changed_ones);
+		if (! res)
+			panic("Color manifesting failed for %+F, color %d in chunk %d\n", node->irn, best_color, best_chunk->id);
+		node->fixed = 1;
+		node->chunk = best_chunk;
+	}
+	/* we colored the successful start nodes, now color the rest of the chunk */
+	for (idx = 0, len = ARR_LEN(best_chunk->n); idx < len; ++idx) {
+		ir_node      *irn  = best_chunk->n[idx];
 		co_mst_irn_t *node = get_co_mst_irn(env, irn);
 		int          res;
 
 		res = change_node_color(env, node, best_color, changed_ones);
-		assert(res && "color manifesting failed");
+		if (! res)
+			panic("Color manifesting failed for %+F, color %d in chunk %d\n", irn, best_color, best_chunk->id);
+		DB((dbg, LEVEL_4, "\tManifesting color %d for %+F, chunk #%d\n", best_color, irn, best_chunk->id));
 		node->fixed = 1;
 		node->chunk = best_chunk;
 	}
@@ -1091,10 +1171,21 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 
 	/* remove the nodes in best chunk from original chunk */
 	bitset_andnot(c->nodes, best_chunk->nodes);
+	for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
+		ir_node *irn = c->n[idx];
+
+		if (bitset_is_set(best_chunk->nodes, get_irn_idx(irn))) {
+			int last = ARR_LEN(c->n) - 1;
+
+			c->n[idx] = c->n[last];
+			ARR_SHRINKLEN(c->n, last);
+			len--;
+		}
+	}
 
 	/* we have to get the nodes back into the original chunk because they are scattered over temporary chunks */
-	bitset_foreach(c->nodes, idx) {
-		ir_node      *n  = get_idx_irn(env->co->irg, idx);
+	for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
+		ir_node      *n  = c->n[idx];
 		co_mst_irn_t *nn = get_co_mst_irn(env, n);
 		nn->chunk = c;
 	}
@@ -1102,10 +1193,10 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 	/* fragment the remaining chunk */
 	visited = bitset_irg_malloc(env->co->irg);
 	bitset_or(visited, best_chunk->nodes);
-	bitset_foreach(c->nodes, idx) {
-		if (! bitset_is_set(visited, idx)) {
+	for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
+		ir_node *irn = c->n[idx];
+		if (! bitset_is_set(visited, get_irn_idx(irn))) {
 			aff_chunk_t  *new_chunk = new_aff_chunk(env);
-			ir_node      *irn       = get_idx_irn(env->co->irg, idx);
 			co_mst_irn_t *node      = get_co_mst_irn(env, irn);
 
 			expand_chunk_from(env, node, visited, new_chunk, c, decider_always_yes, 0);
@@ -1118,16 +1209,17 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 	delete_aff_chunk(env, best_chunk);
 	bitset_free(visited);
 	del_waitq(changed_ones);
+	if (best_starts)
+		del_waitq(best_starts);
 }
 
 /**
  * Main driver for mst safe coalescing algorithm.
  */
-int co_solve_heuristic_mst(copy_opt_t *co)
-{
+int co_solve_heuristic_mst(copy_opt_t *co) {
 	unsigned     n_regs       = co->cls->n_regs;
 	bitset_t     *ignore_regs = bitset_alloca(n_regs);
-	unsigned     k, idx, num;
+	unsigned     k;
 	ir_node      *irn;
 	co_mst_env_t mst_env;
 
@@ -1137,16 +1229,6 @@ int co_solve_heuristic_mst(copy_opt_t *co)
 	k = be_put_ignore_regs(co->cenv->birg, co->cls, ignore_regs);
 	k = n_regs - k;
 
-	/* Create a color to register number map. In some architectures registers are ignore "in the middle"
-	   of the register set. */
-	mst_env.map_regs = NEW_ARR_D(int, phase_obst(&mst_env.ph), k);
-	for (idx = num = 0; idx < n_regs; ++idx) {
-		if (bitset_is_set(ignore_regs, idx))
-			continue;
-		mst_env.map_regs[num++] = idx;
-	}
-	assert(num == k);
-
 	mst_env.n_regs      = n_regs;
 	mst_env.k           = k;
 	mst_env.chunks      = new_pqueue();
@@ -1154,7 +1236,7 @@ int co_solve_heuristic_mst(copy_opt_t *co)
 	mst_env.ignore_regs = ignore_regs;
 	mst_env.ifg         = co->cenv->ifg;
 	mst_env.aenv        = co->aenv;
-	pset_new_init(&mst_env.chunkset);
+	mst_env.chunkset    = pset_new_ptr(512);
 
 	DBG((dbg, LEVEL_1, "==== Coloring %+F, class %s ====\n", co->irg, co->cls->name));
 
@@ -1192,7 +1274,7 @@ int co_solve_heuristic_mst(copy_opt_t *co)
 	/* free allocated memory */
 	del_pqueue(mst_env.chunks);
 	phase_free(&mst_env.ph);
-	pset_new_destroy(&mst_env.chunkset);
+	del_pset(mst_env.chunkset);
 
 	return 0;
 }