X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyheur4.c;h=07344869b96693775ba4f5bdb7efaf58bcadee54;hb=f46792d0e49d452ef92de2a802ae894c0ce30bbb;hp=c95106b7f907e3efbdd2ee0b075bccbbd6bf8166;hpb=ebd4fd4ac7f950d10225a0a0fe7825e816cd6068;p=libfirm

diff --git a/ir/be/becopyheur4.c b/ir/be/becopyheur4.c
index c95106b7f..07344869b 100644
--- a/ir/be/becopyheur4.c
+++ b/ir/be/becopyheur4.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2010 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -29,9 +29,9 @@
  * (also known as "heur3" :)
  * Performs simple copy minimization.
  */
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif /* HAVE_CONFIG_H */
+
+#define DISABLE_STATEV
 
 #include <float.h>
 
@@ -43,7 +43,6 @@
 #include "pqueue.h"
 #include "xmalloc.h"
 #include "pdeq.h"
-#include "pset.h"
 #include "irprintf.h"
 #include "irbitset.h"
 #include "error.h"
@@ -66,8 +65,8 @@
 
 #ifdef DEBUG_libfirm
 
-#define DBG_AFF_CHUNK(env, level, chunk) do { if (firm_dbg_get_mask(dbg) & (level)) dbg_aff_chunk((env), (chunk)); } while(0)
-#define DBG_COL_COST(env, level, cost)   do { if (firm_dbg_get_mask(dbg) & (level)) dbg_col_cost((env), (cost)); } while(0)
+#define DBG_AFF_CHUNK(env, level, chunk) do { if (firm_dbg_get_mask(dbg) & (level)) dbg_aff_chunk((env), (chunk)); } while (0)
+#define DBG_COL_COST(env, level, cost)   do { if (firm_dbg_get_mask(dbg) & (level)) dbg_col_cost((env), (cost)); } while (0)
 
 static firm_dbg_module_t *dbg = NULL;
 
@@ -81,11 +80,11 @@ static firm_dbg_module_t *dbg = NULL;
 typedef float real_t;
 #define REAL(C)   (C ## f)
 
-static int last_chunk_id        = 0;
-static int recolor_limit        = 4;
+static unsigned last_chunk_id   = 0;
+static int recolor_limit        = 7;
 static real_t dislike_influence = REAL(0.1);
 
-typedef struct _col_cost_t {
+typedef struct col_cost_t {
 	int     col;
 	real_t  cost;
 } col_cost_t;
@@ -93,43 +92,43 @@ typedef struct _col_cost_t {
 /**
  * An affinity chunk.
  */
-typedef struct _aff_chunk_t {
-	const ir_node    **n;                   /**< An ARR_F containing all nodes of the chunk. */
+typedef struct aff_chunk_t {
+	const ir_node  **n;                     /**< An ARR_F containing all nodes of the chunk. */
 	const ir_node  **interfere;             /**< An ARR_F containing all inference. */
 	int              weight;                /**< Weight of this chunk */
 	unsigned         weight_consistent : 1; /**< Set if the weight is consistent. */
 	unsigned         deleted           : 1; /**< For debugging: Set if the was deleted. */
-	int              id;                    /**< An id of this chunk. */
-	int              visited;
+	unsigned         id;                    /**< An id of this chunk. */
+	unsigned         visited;
+	list_head        list;
 	col_cost_t       color_affinity[1];
 } aff_chunk_t;
 
 /**
  * An affinity edge.
  */
-typedef struct _aff_edge_t {
+typedef struct aff_edge_t {
 	const ir_node *src;                   /**< Source node. */
 	const ir_node *tgt;                   /**< Target node. */
-	double  weight;                 /**< The weight of this edge. */
+	int           weight;                 /**< The weight of this edge. */
 } aff_edge_t;
 
 /* main coalescing environment */
-typedef struct _co_mst_env_t {
+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 */
 	ir_phase         ph;             /**< phase object holding data for nodes */
-	pqueue           *chunks;        /**< priority queue for chunks */
-	pset             *chunkset;      /**< set holding all chunks */
+	pqueue_t         *chunks;        /**< priority queue for chunks */
+	list_head         chunklist;     /**< list 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 */
-	int               chunk_visited;
+	unsigned         chunk_visited;
 	col_cost_t      **single_cols;
 } co_mst_env_t;
 
 /* stores coalescing related information for a node */
-typedef struct _co_mst_irn_t {
+typedef struct co_mst_irn_t {
 	const ir_node    *irn;              /**< the irn this information belongs to */
 	aff_chunk_t      *chunk;            /**< the chunk this irn belongs to */
 	bitset_t         *adm_colors;       /**< set of admissible colors for this irn */
@@ -153,7 +152,8 @@ 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) {
+static void dbg_aff_chunk(const co_mst_env_t *env, const aff_chunk_t *c)
+{
 	int i, l;
 	(void) env;
 	if (c->weight_consistent)
@@ -169,11 +169,12 @@ 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) {
-	bitset_pos_t idx;
+static void dbg_admissible_colors(const co_mst_env_t *env, const co_mst_irn_t *node)
+{
+	unsigned idx;
 	(void) env;
 
-	if (bitset_popcnt(node->adm_colors) < 1)
+	if (bitset_popcount(node->adm_colors) < 1)
 		fprintf(stderr, "no admissible colors?!?");
 	else {
 		bitset_foreach(node->adm_colors, idx) {
@@ -185,7 +186,8 @@ static void dbg_admissible_colors(const co_mst_env_t *env, const co_mst_irn_t *n
 /**
  * Dump color-cost pairs to stderr.
  */
-static void dbg_col_cost(const co_mst_env_t *env, const col_cost_t *cost) {
+static void dbg_col_cost(const co_mst_env_t *env, const col_cost_t *cost)
+{
 	int i;
 	for (i = 0; i < env->n_regs; ++i)
 		fprintf(stderr, " (%d, %.4f)", cost[i].col, cost[i].cost);
@@ -193,35 +195,40 @@ static void dbg_col_cost(const co_mst_env_t *env, const col_cost_t *cost) {
 
 #endif /* DEBUG_libfirm */
 
-static INLINE int get_mst_irn_col(const co_mst_irn_t *node) {
+static inline int get_mst_irn_col(const co_mst_irn_t *node)
+{
 	return node->tmp_col >= 0 ? node->tmp_col : node->col;
 }
 
 /**
  * @return 1 if node @p node has color @p col, 0 otherwise.
  */
-static int decider_has_color(const co_mst_irn_t *node, int col) {
+static int decider_has_color(const co_mst_irn_t *node, int col)
+{
 	return get_mst_irn_col(node) == col;
 }
 
 /**
  * @return 1 if node @p node has not color @p col, 0 otherwise.
  */
-static int decider_hasnot_color(const co_mst_irn_t *node, int col) {
+static int decider_hasnot_color(const co_mst_irn_t *node, int col)
+{
 	return get_mst_irn_col(node) != col;
 }
 
 /**
  * Always returns true.
  */
-static int decider_always_yes(const co_mst_irn_t *node, int col) {
+static int decider_always_yes(const co_mst_irn_t *node, int col)
+{
 	(void) node;
 	(void) col;
 	return 1;
 }
 
 /** compares two affinity edges by its weight */
-static int cmp_aff_edge(const void *a, const void *b) {
+static int cmp_aff_edge(const void *a, const void *b)
+{
 	const aff_edge_t *e1 = a;
 	const aff_edge_t *e2 = b;
 
@@ -236,25 +243,32 @@ static int cmp_aff_edge(const void *a, const void *b) {
 }
 
 /** compares to color-cost pairs */
-static __attribute__((unused)) int cmp_col_cost_lt(const void *a, const void *b) {
+static __attribute__((unused)) int cmp_col_cost_lt(const void *a, const void *b)
+{
 	const col_cost_t *c1 = a;
 	const col_cost_t *c2 = b;
 	real_t diff = c1->cost - c2->cost;
 	return (diff > 0) - (diff < 0);
 }
 
-static int cmp_col_cost_gt(const void *a, const void *b) {
+static int cmp_col_cost_gt(const void *a, const void *b)
+{
 	const col_cost_t *c1 = a;
 	const col_cost_t *c2 = b;
 	real_t diff = c2->cost - c1->cost;
+
+	if (diff == 0.0)
+		return QSORT_CMP(c1->col, c2->col);
+
 	return (diff > 0) - (diff < 0);
 }
 
 /**
  * Creates a new affinity chunk
  */
-static INLINE aff_chunk_t *new_aff_chunk(co_mst_env_t *env) {
-	aff_chunk_t *c = xmalloc(sizeof(*c) + (env->n_regs - 1) * sizeof(c->color_affinity[0]));
+static inline aff_chunk_t *new_aff_chunk(co_mst_env_t *env)
+{
+	aff_chunk_t *c = XMALLOCF(aff_chunk_t, color_affinity, env->n_regs);
 	c->n                 = NEW_ARR_F(const ir_node *, 0);
 	c->interfere         = NEW_ARR_F(const ir_node *, 0);
 	c->weight            = -1;
@@ -262,15 +276,16 @@ static INLINE aff_chunk_t *new_aff_chunk(co_mst_env_t *env) {
 	c->deleted           = 0;
 	c->id                = ++last_chunk_id;
 	c->visited           = 0;
-	pset_insert(env->chunkset, c, c->id);
+	list_add(&c->list, &env->chunklist);
 	return c;
 }
 
 /**
  * Frees all memory allocated by an affinity chunk.
  */
-static INLINE void delete_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
-	pset_remove(env->chunkset, c, c->id);
+static inline void delete_aff_chunk(aff_chunk_t *c)
+{
+	list_del(&c->list);
 	DEL_ARR_F(c->interfere);
 	DEL_ARR_F(c->n);
 	c->deleted = 1;
@@ -283,7 +298,8 @@ static INLINE void delete_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
  * @return the position where n is found in the array arr or ~pos
  * if the nodes is not here.
  */
-static INLINE int nodes_bsearch(const ir_node **arr, const ir_node *n) {
+static inline int nodes_bsearch(const ir_node **arr, const ir_node *n)
+{
 	int hi = ARR_LEN(arr);
 	int lo = 0;
 
@@ -302,7 +318,8 @@ static INLINE int nodes_bsearch(const ir_node **arr, const ir_node *n) {
 }
 
 /** Check if a node n can be found inside arr. */
-static int node_contains(const ir_node **arr, const ir_node *n) {
+static int node_contains(const ir_node **arr, const ir_node *n)
+{
 	int i = nodes_bsearch(arr, n);
 	return i >= 0;
 }
@@ -312,7 +329,8 @@ static int node_contains(const ir_node **arr, const ir_node *n) {
  *
  * @return 1 if the node was inserted, 0 else
  */
-static int nodes_insert(const ir_node ***arr, const ir_node *irn) {
+static int nodes_insert(const ir_node ***arr, const ir_node *irn)
+{
 	int idx = nodes_bsearch(*arr, irn);
 
 	if (idx < 0) {
@@ -335,7 +353,8 @@ static int nodes_insert(const ir_node ***arr, const ir_node *irn) {
 /**
  * Adds a node to an affinity chunk
  */
-static INLINE void aff_chunk_add_node(aff_chunk_t *c, co_mst_irn_t *node) {
+static inline void aff_chunk_add_node(aff_chunk_t *c, co_mst_irn_t *node)
+{
 	int i;
 
 	if (! nodes_insert(&c->n, node->irn))
@@ -353,65 +372,65 @@ static INLINE void aff_chunk_add_node(aff_chunk_t *c, co_mst_irn_t *node) {
 /**
  * In case there is no phase information for irn, initialize it.
  */
-static void *co_mst_irn_init(ir_phase *ph, const ir_node *irn, void *old) {
-	co_mst_irn_t *res = old ? old : phase_alloc(ph, sizeof(res[0]));
+static void *co_mst_irn_init(ir_phase *ph, const ir_node *irn)
+{
+	co_mst_irn_t *res = phase_alloc(ph, sizeof(res[0]));
 	co_mst_env_t *env = ph->priv;
 
-	if (!old) {
-		const arch_register_req_t *req;
-		void     *nodes_it = be_ifg_nodes_iter_alloca(env->ifg);
-		ir_node  *neigh;
-		unsigned len;
-
-		res->irn           = irn;
-		res->chunk         = NULL;
-		res->fixed         = 0;
-		res->tmp_col       = -1;
-		res->int_neighs    = NULL;
-		res->int_aff_neigh = 0;
-		res->col           = arch_register_get_index(arch_get_irn_register(env->aenv, irn));
-		res->init_col      = res->col;
-		INIT_LIST_HEAD(&res->list);
-
-		DB((dbg, LEVEL_4, "Creating phase info for %+F\n", irn));
-
-		/* set admissible registers */
-		res->adm_colors = bitset_obstack_alloc(phase_obst(ph), env->n_regs);
-
-		/* Exclude colors not assignable to the irn */
-		req = arch_get_register_req(env->aenv, irn, -1);
-		if (arch_register_req_is(req, limited))
-			rbitset_copy_to_bitset(req->limited, res->adm_colors);
-		else
-			bitset_set_all(res->adm_colors);
-
-		/* exclude global ignore registers as well */
-		bitset_andnot(res->adm_colors, env->ignore_regs);
-
-		/* compute the constraint factor */
-		res->constr_factor = (real_t) (1 + env->n_regs - bitset_popcnt(res->adm_colors)) / env->n_regs;
-
-		/* set the number of interfering affinity neighbours to -1, they are calculated later */
-		res->int_aff_neigh = -1;
-
-		/* build list of interfering neighbours */
-		len = 0;
-		be_ifg_foreach_neighbour(env->ifg, nodes_it, irn, neigh) {
-			if (! arch_irn_is(env->aenv, neigh, ignore)) {
-				obstack_ptr_grow(phase_obst(ph), neigh);
-				++len;
-			}
+	const arch_register_req_t *req;
+	neighbours_iter_t nodes_it;
+	ir_node  *neigh;
+	unsigned len;
+
+	res->irn           = irn;
+	res->chunk         = NULL;
+	res->fixed         = 0;
+	res->tmp_col       = -1;
+	res->int_neighs    = NULL;
+	res->int_aff_neigh = 0;
+	res->col           = arch_register_get_index(arch_get_irn_register(irn));
+	res->init_col      = res->col;
+	INIT_LIST_HEAD(&res->list);
+
+	DB((dbg, LEVEL_4, "Creating phase info for %+F\n", irn));
+
+	/* set admissible registers */
+	res->adm_colors = bitset_obstack_alloc(phase_obst(ph), env->n_regs);
+
+	/* Exclude colors not assignable to the irn */
+	req = arch_get_register_req_out(irn);
+	if (arch_register_req_is(req, limited))
+		rbitset_copy_to_bitset(req->limited, res->adm_colors);
+	else
+		bitset_set_all(res->adm_colors);
+
+	/* exclude global ignore registers as well */
+	bitset_andnot(res->adm_colors, env->ignore_regs);
+
+	/* compute the constraint factor */
+	res->constr_factor = (real_t) (1 + env->n_regs - bitset_popcount(res->adm_colors)) / env->n_regs;
+
+	/* set the number of interfering affinity neighbours to -1, they are calculated later */
+	res->int_aff_neigh = -1;
+
+	/* build list of interfering neighbours */
+	len = 0;
+	be_ifg_foreach_neighbour(env->ifg, &nodes_it, irn, neigh) {
+		if (!arch_irn_is_ignore(neigh)) {
+			obstack_ptr_grow(phase_obst(ph), neigh);
+			++len;
 		}
-		res->int_neighs = obstack_finish(phase_obst(ph));
-		res->n_neighs   = len;
 	}
+	res->int_neighs = obstack_finish(phase_obst(ph));
+	res->n_neighs   = len;
 	return res;
 }
 
 /**
  * Check if affinity chunk @p chunk interferes with node @p irn.
  */
-static INLINE int aff_chunk_interferes(const aff_chunk_t *chunk, const ir_node *irn) {
+static inline int aff_chunk_interferes(const aff_chunk_t *chunk, const ir_node *irn)
+{
 	return node_contains(chunk->interfere, irn);
 }
 
@@ -421,7 +440,8 @@ static INLINE int aff_chunk_interferes(const aff_chunk_t *chunk, const ir_node *
  * @param c2    Another chunk
  * @return 1 if there are interferences between nodes of c1 and c2, 0 otherwise.
  */
-static INLINE int aff_chunks_interfere(const aff_chunk_t *c1, const aff_chunk_t *c2) {
+static inline int aff_chunks_interfere(const aff_chunk_t *c1, const aff_chunk_t *c2)
+{
 	int i;
 
 	if (c1 == c2)
@@ -441,7 +461,8 @@ static INLINE int aff_chunks_interfere(const aff_chunk_t *c1, const aff_chunk_t
  * Returns the affinity chunk of @p irn or creates a new
  * one with @p irn as element if there is none assigned.
  */
-static INLINE aff_chunk_t *get_aff_chunk(co_mst_env_t *env, const ir_node *irn) {
+static inline aff_chunk_t *get_aff_chunk(co_mst_env_t *env, const ir_node *irn)
+{
 	co_mst_irn_t *node = get_co_mst_irn(env, irn);
 	return node->chunk;
 }
@@ -451,18 +472,19 @@ static INLINE aff_chunk_t *get_aff_chunk(co_mst_env_t *env, const ir_node *irn)
  * are no interference edges from chunk(src) to chunk(tgt)).
  * @return 1 if successful, 0 if not possible
  */
-static int aff_chunk_absorb(co_mst_env_t *env, const ir_node *src, const ir_node *tgt) {
+static int aff_chunk_absorb(co_mst_env_t *env, const ir_node *src, const ir_node *tgt)
+{
 	aff_chunk_t *c1 = get_aff_chunk(env, src);
 	aff_chunk_t *c2 = get_aff_chunk(env, tgt);
 
 #ifdef DEBUG_libfirm
-		DB((dbg, LEVEL_4, "Attempt to let c1 (id %d): ", c1 ? c1->id : -1));
+		DB((dbg, LEVEL_4, "Attempt to let c1 (id %u): ", c1 ? c1->id : 0));
 		if (c1) {
 			DBG_AFF_CHUNK(env, LEVEL_4, c1);
 		} else {
 			DB((dbg, LEVEL_4, "{%+F}", src));
 		}
-		DB((dbg, LEVEL_4, "\n\tabsorb c2 (id %d): ", c2 ? c2->id : -1));
+		DB((dbg, LEVEL_4, "\n\tabsorb c2 (id %u): ", c2 ? c2->id : 0));
 		if (c2) {
 			DBG_AFF_CHUNK(env, LEVEL_4, c2);
 		} else {
@@ -514,7 +536,7 @@ static int aff_chunk_absorb(co_mst_env_t *env, const ir_node *src, const ir_node
 
 		c1->weight_consistent = 0;
 
-		delete_aff_chunk(env, c2);
+		delete_aff_chunk(c2);
 		goto absorbed;
 	}
 	DB((dbg, LEVEL_4, " ... c1 interferes with c2, skipped\n"));
@@ -528,7 +550,8 @@ absorbed:
 /**
  * Assures that the weight of the given chunk is consistent.
  */
-static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c) {
+static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c)
+{
 	if (! c->weight_consistent) {
 		int w = 0;
 		int idx, len, i;
@@ -545,7 +568,7 @@ static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c) {
 
 			node->chunk = c;
 			if (node->constr_factor > REAL(0.0)) {
-				bitset_pos_t col;
+				unsigned col;
 				bitset_foreach (node->adm_colors, col)
 					c->color_affinity[col].cost += node->constr_factor;
 			}
@@ -553,10 +576,9 @@ static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c) {
 			if (an != NULL) {
 				neighb_t *neigh;
 				co_gs_foreach_neighb(an, neigh) {
-					const ir_node *m    = neigh->irn;
+					const ir_node *m = neigh->irn;
 
-					/* skip ignore nodes */
-					if (arch_irn_is(env->aenv, m, ignore))
+					if (arch_irn_is_ignore(m))
 						continue;
 
 					w += node_contains(c->n, m) ? neigh->costs : 0;
@@ -568,7 +590,7 @@ static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c) {
 			c->color_affinity[i].cost *= (REAL(1.0) / ARR_LEN(c->n));
 
 		c->weight            = w;
-		// c->weight            = bitset_popcnt(c->nodes);
+		// c->weight            = bitset_popcount(c->nodes);
 		c->weight_consistent = 1;
 	}
 }
@@ -576,7 +598,8 @@ static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c) {
 /**
  * Count the number of interfering affinity neighbours
  */
-static int count_interfering_aff_neighs(co_mst_env_t *env, const affinity_node_t *an) {
+static int count_interfering_aff_neighs(co_mst_env_t *env, const affinity_node_t *an)
+{
 	const neighb_t     *neigh;
 	const ir_node      *irn  = an->irn;
 	const co_mst_irn_t *node = get_co_mst_irn(env, irn);
@@ -586,8 +609,7 @@ static int count_interfering_aff_neighs(co_mst_env_t *env, const affinity_node_t
 		const ir_node *n = neigh->irn;
 		int           i;
 
-		/* skip ignore nodes */
-		if (arch_irn_is(env->aenv, n, ignore))
+		if (arch_irn_is_ignore(n))
 			continue;
 
 		/* check if the affinity neighbour interfere */
@@ -609,21 +631,21 @@ static int count_interfering_aff_neighs(co_mst_env_t *env, const affinity_node_t
  * merged if there are no interference edges from one
  * chunk to the other.
  */
-static void build_affinity_chunks(co_mst_env_t *env) {
-	void        *nodes_it = be_ifg_nodes_iter_alloca(env->ifg);
+static void build_affinity_chunks(co_mst_env_t *env)
+{
+	nodes_iter_t nodes_it;
 	aff_edge_t  *edges    = NEW_ARR_F(aff_edge_t, 0);
 	ir_node     *n;
 	int         i, len;
 	aff_chunk_t *curr_chunk;
 
 	/* at first we create the affinity edge objects */
-	be_ifg_foreach_node(env->ifg, nodes_it, n) {
+	be_ifg_foreach_node(env->ifg, &nodes_it, n) {
 		int             n_idx = get_irn_idx(n);
 		co_mst_irn_t    *n1;
 		affinity_node_t *an;
 
-		/* skip ignore nodes */
-		if (arch_irn_is(env->aenv, n, ignore))
+		if (arch_irn_is_ignore(n))
 			continue;
 
 		n1 = get_co_mst_irn(env, n);
@@ -646,7 +668,7 @@ static void build_affinity_chunks(co_mst_env_t *env) {
 					aff_edge_t   edge;
 
 					/* skip ignore nodes */
-					if (arch_irn_is(env->aenv, m, ignore))
+					if (arch_irn_is_ignore(m))
 						continue;
 
 					edge.src = n;
@@ -678,10 +700,10 @@ static void build_affinity_chunks(co_mst_env_t *env) {
 	}
 
 	/* now insert all chunks into a priority queue */
-	foreach_pset(env->chunkset, curr_chunk) {
+	list_for_each_entry(aff_chunk_t, curr_chunk, &env->chunklist, list) {
 		aff_chunk_assure_weight(env, curr_chunk);
 
-		DBG((dbg, LEVEL_1, "entry #%d", curr_chunk->id));
+		DBG((dbg, LEVEL_1, "entry #%u", curr_chunk->id));
 		DBG_AFF_CHUNK(env, LEVEL_1, curr_chunk);
 		DBG((dbg, LEVEL_1, "\n"));
 
@@ -698,7 +720,7 @@ static void build_affinity_chunks(co_mst_env_t *env) {
 
 			aff_chunk_assure_weight(env, curr_chunk);
 
-			DBG((dbg, LEVEL_1, "entry #%d", curr_chunk->id));
+			DBG((dbg, LEVEL_1, "entry #%u", curr_chunk->id));
 			DBG_AFF_CHUNK(env, LEVEL_1, curr_chunk);
 			DBG((dbg, LEVEL_1, "\n"));
 
@@ -711,7 +733,7 @@ static void build_affinity_chunks(co_mst_env_t *env) {
 
 static __attribute__((unused)) void chunk_order_nodes(co_mst_env_t *env, aff_chunk_t *chunk)
 {
-	pqueue *grow = new_pqueue();
+	pqueue_t *grow = new_pqueue();
 	const ir_node *max_node = NULL;
 	int max_weight = 0;
 	int i;
@@ -722,7 +744,7 @@ static __attribute__((unused)) void chunk_order_nodes(co_mst_env_t *env, aff_chu
 		int w = 0;
 		neighb_t *neigh;
 
-		if (arch_irn_is(env->aenv, irn, ignore))
+		if (arch_irn_is_ignore(irn))
 			continue;
 
 		if (an) {
@@ -746,11 +768,11 @@ static __attribute__((unused)) void chunk_order_nodes(co_mst_env_t *env, aff_chu
 		bitset_remv_irn(visited, max_node);
 		i = 0;
 		while (!pqueue_empty(grow)) {
-			ir_node *irn = pqueue_get(grow);
+			ir_node *irn = pqueue_pop_front(grow);
 			affinity_node_t *an = get_affinity_info(env->co, irn);
-			neighb_t *neigh;
+			neighb_t        *neigh;
 
-			if (arch_irn_is(env->aenv, irn, ignore))
+			if (arch_irn_is_ignore(irn))
 				continue;
 
 			assert(i <= ARR_LEN(chunk->n));
@@ -782,7 +804,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, "\n\tExpanding new chunk (#%d) from %+F, color %d:", chunk->id, node->irn, col));
+	DBG((dbg, LEVEL_1, "\n\tExpanding new chunk (#%u) from %+F, color %d:", chunk->id, node->irn, col));
 
 	/* init queue and chunk */
 	waitq_put(nodes, node);
@@ -803,8 +825,7 @@ static void expand_chunk_from(co_mst_env_t *env, co_mst_irn_t *node, bitset_t *v
 				int            m_idx = get_irn_idx(m);
 				co_mst_irn_t *n2;
 
-				/* skip ignore nodes */
-				if (arch_irn_is(env->aenv, m, ignore))
+				if (arch_irn_is_ignore(m))
 					continue;
 
 				n2 = get_co_mst_irn(env, m);
@@ -841,7 +862,8 @@ static void expand_chunk_from(co_mst_env_t *env, co_mst_irn_t *node, bitset_t *v
 /**
  * Fragment the given chunk into chunks having given color and not having given color.
  */
-static aff_chunk_t *fragment_chunk(co_mst_env_t *env, int col, aff_chunk_t *c, waitq *tmp) {
+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, len;
 	aff_chunk_t *best = NULL;
@@ -862,12 +884,12 @@ static aff_chunk_t *fragment_chunk(co_mst_env_t *env, int col, aff_chunk_t *c, w
 		if (get_mst_irn_col(node) == col) {
 			decider        = decider_has_color;
 			check_for_best = 1;
-			DBG((dbg, LEVEL_4, "\tcolor %d wanted", col));
+			DBG((dbg, LEVEL_4, "\tcolor %d wanted\n", col));
 		}
 		else {
 			decider        = decider_hasnot_color;
 			check_for_best = 0;
-			DBG((dbg, LEVEL_4, "\tcolor %d forbidden", col));
+			DBG((dbg, LEVEL_4, "\tcolor %d forbidden\n", col));
 		}
 
 		/* create a new chunk starting at current node */
@@ -891,7 +913,8 @@ static aff_chunk_t *fragment_chunk(co_mst_env_t *env, int col, aff_chunk_t *c, w
  * Resets the temporary fixed color of all nodes within wait queue @p nodes.
  * ATTENTION: the queue is empty after calling this function!
  */
-static INLINE void reject_coloring(struct list_head *nodes) {
+static inline void reject_coloring(struct list_head *nodes)
+{
 	co_mst_irn_t *n, *temp;
 	DB((dbg, LEVEL_4, "\treject coloring for"));
 	list_for_each_entry_safe(co_mst_irn_t, n, temp, nodes, list) {
@@ -903,7 +926,8 @@ static INLINE void reject_coloring(struct list_head *nodes) {
 	DB((dbg, LEVEL_4, "\n"));
 }
 
-static INLINE void materialize_coloring(struct list_head *nodes) {
+static inline void materialize_coloring(struct list_head *nodes)
+{
 	co_mst_irn_t *n, *temp;
 	list_for_each_entry_safe(co_mst_irn_t, n, temp, nodes, list) {
 		assert(n->tmp_col >= 0);
@@ -913,7 +937,7 @@ static INLINE void materialize_coloring(struct list_head *nodes) {
 	}
 }
 
-static INLINE void set_temp_color(co_mst_irn_t *node, int col, struct list_head *changed)
+static inline void set_temp_color(co_mst_irn_t *node, int col, struct list_head *changed)
 {
 	assert(col >= 0);
 	assert(!node->fixed);
@@ -925,7 +949,7 @@ static INLINE void set_temp_color(co_mst_irn_t *node, int col, struct list_head
 	node->tmp_col = col;
 }
 
-static INLINE int is_loose(co_mst_irn_t *node)
+static inline int is_loose(co_mst_irn_t *node)
 {
 	return !node->fixed && node->tmp_col < 0;
 }
@@ -933,11 +957,12 @@ static INLINE int is_loose(co_mst_irn_t *node)
 /**
  * Determines the costs for each color if it would be assigned to node @p node.
  */
-static void determine_color_costs(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs) {
-	int *neigh_cols = alloca(env->n_regs * sizeof(*neigh_cols));
-	int n_loose = 0;
+static void determine_color_costs(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs)
+{
+	int   *neigh_cols = ALLOCAN(int, env->n_regs);
+	int    n_loose    = 0;
 	real_t coeff;
-	int i;
+	int    i;
 
 	for (i = 0; i < env->n_regs; ++i) {
 		neigh_cols[i] = 0;
@@ -969,7 +994,8 @@ static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *cost
  * Tries to change node to a color but @p explude_col.
  * @return 1 if succeeded, 0 otherwise.
  */
-static int change_node_color_excluded(co_mst_env_t *env, co_mst_irn_t *node, int exclude_col, struct list_head *changed, int depth, int *max_depth, int *trip) {
+static int change_node_color_excluded(co_mst_env_t *env, co_mst_irn_t *node, int exclude_col, struct list_head *changed, int depth, int *max_depth, int *trip)
+{
 	int col = get_mst_irn_col(node);
 	int res = 0;
 
@@ -982,7 +1008,7 @@ static int change_node_color_excluded(co_mst_env_t *env, co_mst_irn_t *node, int
 
 	/* The node has the color it should not have _and_ has not been visited yet. */
 	if (is_loose(node)) {
-		col_cost_t *costs = alloca(env->n_regs * sizeof(costs[0]));
+		col_cost_t *costs = ALLOCAN(col_cost_t, env->n_regs);
 
 		/* Get the costs for giving the node a specific color. */
 		determine_color_costs(env, node, costs);
@@ -1005,7 +1031,8 @@ static int change_node_color_excluded(co_mst_env_t *env, co_mst_irn_t *node, int
  * ATTENTION: Expect @p costs already sorted by increasing costs.
  * @return 1 if coloring could be applied, 0 otherwise.
  */
-static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs, struct list_head *changed, int depth, int *max_depth, int *trip) {
+static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs, struct list_head *changed, int depth, int *max_depth, int *trip)
+{
 	int   i;
 	struct list_head local_changed;
 
@@ -1013,21 +1040,25 @@ static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *cost
 	if (depth > *max_depth)
 		*max_depth = depth;
 
-	if (depth >= recolor_limit)
-		return 0;
-
 	DBG((dbg, LEVEL_4, "\tRecoloring %+F with color-costs", node->irn));
 	DBG_COL_COST(env, LEVEL_4, costs);
 	DB((dbg, LEVEL_4, "\n"));
 
+	if (depth >= recolor_limit) {
+		DBG((dbg, LEVEL_4, "\tHit recolor limit\n"));
+		return 0;
+	}
+
 	for (i = 0; i < env->n_regs; ++i) {
 		int tgt_col  = costs[i].col;
 		int neigh_ok = 1;
 		int j;
 
 		/* If the costs for that color (and all successive) are infinite, bail out we won't make it anyway. */
-		if (costs[i].cost == REAL(0.0))
+		if (costs[i].cost == REAL(0.0)) {
+			DBG((dbg, LEVEL_4, "\tAll further colors forbidden\n"));
 			return 0;
+		}
 
 		/* Set the new color of the node and mark the node as temporarily fixed. */
 		assert(node->tmp_col < 0 && "Node must not have been temporary fixed.");
@@ -1042,8 +1073,7 @@ static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *cost
 
 			neigh = node->int_neighs[j];
 
-			/* skip ignore nodes */
-			if (arch_irn_is(env->aenv, neigh, ignore))
+			if (arch_irn_is_ignore(neigh))
 				continue;
 
 			nn = get_co_mst_irn(env, neigh);
@@ -1080,6 +1110,7 @@ static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *cost
 		}
 	}
 
+	DBG((dbg, LEVEL_4, "\tAll colors failed\n"));
 	return 0;
 }
 
@@ -1087,7 +1118,8 @@ static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *cost
  * Tries to bring node @p node and all it's neighbours to color @p tgt_col.
  * @return 1 if color @p col could be applied, 0 otherwise
  */
-static int change_node_color(co_mst_env_t *env, co_mst_irn_t *node, int tgt_col, struct list_head *changed) {
+static int change_node_color(co_mst_env_t *env, co_mst_irn_t *node, int tgt_col, struct list_head *changed)
+{
 	int col = get_mst_irn_col(node);
 
 	/* if node already has the target color -> good, temporary fix it */
@@ -1138,29 +1170,28 @@ static int change_node_color(co_mst_env_t *env, co_mst_irn_t *node, int tgt_col,
  * Tries to color an affinity chunk (or at least a part of it).
  * Inserts uncolored parts of the chunk as a new chunk into the priority queue.
  */
-static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
+static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c)
+{
 	aff_chunk_t *best_chunk   = NULL;
 	int         n_nodes       = ARR_LEN(c->n);
 	int         best_color    = -1;
 	int         n_int_chunks  = 0;
 	waitq       *tmp_chunks   = new_waitq();
 	waitq       *best_starts  = NULL;
-	col_cost_t  *order        = alloca(env->n_regs * sizeof(order[0]));
+	col_cost_t  *order        = ALLOCANZ(col_cost_t, env->n_regs);
 	bitset_t    *visited;
 	int         idx, len, i, nidx, pos;
 	struct list_head changed;
 
-	DB((dbg, LEVEL_2, "fragmentizing chunk #%d", c->id));
+	DB((dbg, LEVEL_2, "fragmentizing chunk #%u", c->id));
 	DBG_AFF_CHUNK(env, LEVEL_2, c);
 	DB((dbg, LEVEL_2, "\n"));
 
-	stat_ev_ctx_push_fmt("heur4_color_chunk", "%d", c->id);
+	stat_ev_ctx_push_fmt("heur4_color_chunk", "%u", c->id);
 
 	++env->chunk_visited;
 
 	/* compute color preference */
-	memset(order, 0, env->n_regs * sizeof(order[0]));
-
 	for (pos = 0, len = ARR_LEN(c->interfere); pos < len; ++pos) {
 		const ir_node *n = c->interfere[pos];
 		co_mst_irn_t *node = get_co_mst_irn(env, n);
@@ -1258,7 +1289,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 		if (local_best) {
 			aff_chunk_assure_weight(env, local_best);
 
-			DB((dbg, LEVEL_3, "\t\tlocal best chunk (id %d) for color %d: ", local_best->id, col));
+			DB((dbg, LEVEL_3, "\t\tlocal best chunk (id %u) for color %d: ", local_best->id, col));
 			DBG_AFF_CHUNK(env, LEVEL_3, local_best);
 
 			if (! best_chunk || best_chunk->weight < local_best->weight) {
@@ -1267,7 +1298,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 				if (best_starts)
 					del_waitq(best_starts);
 				best_starts = good_starts;
-				DB((dbg, LEVEL_3, "\n\t\t... setting global best chunk (id %d), color %d\n", best_chunk->id, best_color));
+				DB((dbg, LEVEL_3, "\n\t\t... setting global best chunk (id %u), color %d\n", best_chunk->id, best_color));
 			} else {
 				DB((dbg, LEVEL_3, "\n\t\t... omitting, global best is better\n"));
 				del_waitq(good_starts);
@@ -1288,7 +1319,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 	while (! waitq_empty(tmp_chunks)) {
 		aff_chunk_t *tmp = waitq_get(tmp_chunks);
 		if (tmp != best_chunk)
-			delete_aff_chunk(env, tmp);
+			delete_aff_chunk(tmp);
 	}
 	del_waitq(tmp_chunks);
 
@@ -1299,7 +1330,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 		return;
 	}
 
-	DB((dbg, LEVEL_2, "\tbest chunk #%d ", best_chunk->id));
+	DB((dbg, LEVEL_2, "\tbest chunk #%u ", best_chunk->id));
 	DBG_AFF_CHUNK(env, LEVEL_2, best_chunk);
 	DB((dbg, LEVEL_2, "using color %d\n", best_color));
 
@@ -1309,7 +1340,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 		int res;
 
 		/* bring the node to the color. */
-		DB((dbg, LEVEL_4, "\tManifesting color %d for %+F, chunk #%d\n", best_color, node->irn, best_chunk->id));
+		DB((dbg, LEVEL_4, "\tManifesting color %d for %+F, chunk #%u\n", best_color, node->irn, best_chunk->id));
 		INIT_LIST_HEAD(&changed);
 		stat_ev_tim_push();
 		res = change_node_color(env, node, best_color, &changed);
@@ -1372,7 +1403,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 	}
 
 	/* clear obsolete chunks and free some memory */
-	delete_aff_chunk(env, best_chunk);
+	delete_aff_chunk(best_chunk);
 	bitset_free(visited);
 	if (best_starts)
 		del_waitq(best_starts);
@@ -1383,19 +1414,23 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
 /**
  * Main driver for mst safe coalescing algorithm.
  */
-int co_solve_heuristic_mst(copy_opt_t *co) {
+static 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     i, j, k;
 	ir_node      *irn;
 	co_mst_env_t mst_env;
 
+	last_chunk_id = 0;
+
 	stat_ev_tim_push();
 
 	/* init phase */
-	phase_init(&mst_env.ph, "co_mst", co->irg, PHASE_DEFAULT_GROWTH, co_mst_irn_init, &mst_env);
+	phase_init(&mst_env.ph, co->irg, co_mst_irn_init);
+	phase_set_private(&mst_env.ph, &mst_env);
 
-	k = be_put_ignore_regs(co->cenv->birg, co->cls, ignore_regs);
+	k = be_put_ignore_regs(co->cenv->irg, co->cls, ignore_regs);
 	k = n_regs - k;
 
 	mst_env.n_regs        = n_regs;
@@ -1404,8 +1439,7 @@ int co_solve_heuristic_mst(copy_opt_t *co) {
 	mst_env.co            = co;
 	mst_env.ignore_regs   = ignore_regs;
 	mst_env.ifg           = co->cenv->ifg;
-	mst_env.aenv          = co->aenv;
-	mst_env.chunkset      = pset_new_ptr(512);
+	INIT_LIST_HEAD(&mst_env.chunklist);
 	mst_env.chunk_visited = 0;
 	mst_env.single_cols   = phase_alloc(&mst_env.ph, sizeof(*mst_env.single_cols) * n_regs);
 
@@ -1431,19 +1465,19 @@ int co_solve_heuristic_mst(copy_opt_t *co) {
 
 	/* color chunks as long as there are some */
 	while (! pqueue_empty(mst_env.chunks)) {
-		aff_chunk_t *chunk = pqueue_get(mst_env.chunks);
+		aff_chunk_t *chunk = pqueue_pop_front(mst_env.chunks);
 
 		color_aff_chunk(&mst_env, chunk);
-		DB((dbg, LEVEL_4, "<<<====== Coloring chunk (%d) done\n", chunk->id));
-		delete_aff_chunk(&mst_env, chunk);
+		DB((dbg, LEVEL_4, "<<<====== Coloring chunk (%u) done\n", chunk->id));
+		delete_aff_chunk(chunk);
 	}
 
 	/* apply coloring */
 	foreach_phase_irn(&mst_env.ph, irn) {
-		co_mst_irn_t *mirn;
+		co_mst_irn_t          *mirn;
 		const arch_register_t *reg;
 
-		if (arch_irn_is(mst_env.aenv, irn, ignore))
+		if (arch_irn_is_ignore(irn))
 			continue;
 
 		mirn = get_co_mst_irn(&mst_env, irn);
@@ -1454,14 +1488,13 @@ int co_solve_heuristic_mst(copy_opt_t *co) {
 			continue;
 
 		reg = arch_register_for_index(co->cls, mirn->col);
-		arch_set_irn_register(co->aenv, irn, reg);
+		arch_set_irn_register(irn, reg);
 		DB((dbg, LEVEL_1, "%+F set color from %d to %d\n", irn, mirn->init_col, mirn->col));
 	}
 
 	/* free allocated memory */
 	del_pqueue(mst_env.chunks);
-	phase_free(&mst_env.ph);
-	del_pset(mst_env.chunkset);
+	phase_deinit(&mst_env.ph);
 
 	stat_ev_tim_pop("heur4_total");
 
@@ -1474,17 +1507,21 @@ static const lc_opt_table_entry_t options[] = {
 	LC_OPT_LAST
 };
 
-
-void be_init_copyheur4(void) {
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur4);
+void be_init_copyheur4(void)
+{
 	lc_opt_entry_t *be_grp = lc_opt_get_grp(firm_opt_get_root(), "be");
 	lc_opt_entry_t *ra_grp = lc_opt_get_grp(be_grp, "ra");
 	lc_opt_entry_t *chordal_grp = lc_opt_get_grp(ra_grp, "chordal");
 	lc_opt_entry_t *co_grp = lc_opt_get_grp(chordal_grp, "co");
 	lc_opt_entry_t *heur4_grp = lc_opt_get_grp(co_grp, "heur4");
 
+	static co_algo_info copyheur = {
+		co_solve_heuristic_mst, 0
+	};
+
 	lc_opt_add_table(heur4_grp, options);
+	be_register_copyopt("heur4", &copyheur);
+
 	FIRM_DBG_REGISTER(dbg, "firm.be.co.heur4");
 }
-
-
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur4);