X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyopt.c;h=ca32b86b779e7ee16bb16c762e4ac13c14c5eb61;hb=bb9f2e36362333c6635b89f5258171b06c786608;hp=4494fb7223a71c0c62c92056145e76732d27bac8;hpb=f6414b3b350e99ef7f9cbabf07386026eb853625;p=libfirm

diff --git a/ir/be/becopyopt.c b/ir/be/becopyopt.c
index 4494fb722..ca32b86b7 100644
--- a/ir/be/becopyopt.c
+++ b/ir/be/becopyopt.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.
  *
@@ -29,9 +29,7 @@
  * - Register-constrained nodes
  * - Two-address code instructions
  */
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
 
 #include "execfreq.h"
 #include "xmalloc.h"
@@ -60,15 +58,12 @@
 #include "belive_t.h"
 #include "beinsn_t.h"
 #include "besched_t.h"
-#include "benodesets.h"
-#include "bejavacoal.h"
 #include "bestatevent.h"
 #include "beirg_t.h"
 #include "error.h"
 
-#include <libcore/lc_timing.h>
-#include <libcore/lc_opts.h>
-#include <libcore/lc_opts_enum.h>
+#include "lc_opts.h"
+#include "lc_opts_enum.h"
 
 #define DUMP_BEFORE 1
 #define DUMP_AFTER  2
@@ -107,13 +102,9 @@ static const lc_opt_enum_mask_items_t algo_items[] = {
 	{ "none",   CO_ALGO_NONE  },
 	{ "heur",   CO_ALGO_HEUR  },
 	{ "heur2",  CO_ALGO_HEUR2 },
-#ifdef WITH_JVM
 	{ "heur3",  CO_ALGO_HEUR3 },
-#endif /* WITH_JVM */
 	{ "heur4",  CO_ALGO_HEUR4 },
-#ifdef WITH_ILP
 	{ "ilp",    CO_ALGO_ILP   },
-#endif /* WITH_ILP */
 	{ NULL,     0 }
 };
 
@@ -201,9 +192,8 @@ copy_opt_t *new_copy_opt(be_chordal_env_t *chordal_env, cost_fct_t get_costs)
 
 	FIRM_DBG_REGISTER(dbg, "ir.be.copyopt");
 
-	co = xcalloc(1, sizeof(*co));
+	co = XMALLOCZ(copy_opt_t);
 	co->cenv      = chordal_env;
-	co->aenv      = chordal_env->birg->main_env->arch_env;
 	co->irg       = chordal_env->irg;
 	co->cls       = chordal_env->cls;
 	co->get_costs = get_costs;
@@ -212,7 +202,7 @@ copy_opt_t *new_copy_opt(be_chordal_env_t *chordal_env, cost_fct_t get_costs)
 	s2 = get_entity_name(get_irg_entity(co->irg));
 	s3 = chordal_env->cls->name;
 	len = strlen(s1) + strlen(s2) + strlen(s3) + 5;
-	co->name = xmalloc(len);
+	co->name = XMALLOCN(char, len);
 	snprintf(co->name, len, "%s__%s__%s", s1, s2, s3);
 
 	return co;
@@ -223,19 +213,24 @@ void free_copy_opt(copy_opt_t *co) {
 	free(co);
 }
 
-int co_is_optimizable_root(const copy_opt_t *co, ir_node *irn) {
+/**
+ * Checks if a node is optimizable, viz. has something to do with coalescing
+ * @param irn  The irn to check
+ */
+static int co_is_optimizable_root(ir_node *irn)
+{
 	const arch_register_req_t *req;
 	const arch_register_t *reg;
 
-	if (arch_irn_is(co->aenv, irn, ignore))
+	if (arch_irn_is(irn, ignore))
 		return 0;
 
-	reg = arch_get_irn_register(co->aenv, irn);
+	reg = arch_get_irn_register(irn);
 	if (arch_register_type_is(reg, ignore))
 		return 0;
 
-	req = arch_get_register_req(co->aenv, irn, -1);
-	if (is_Reg_Phi(irn) || is_Perm_Proj(co->aenv, irn) || is_2addr_code(req))
+	req = arch_get_register_req(irn, -1);
+	if (is_Reg_Phi(irn) || is_Perm_Proj(irn) || is_2addr_code(req))
 		return 1;
 
 	return 0;
@@ -387,11 +382,11 @@ static void co_collect_units(ir_node *irn, void *env) {
 
 	if (!is_curr_reg_class(co, irn))
 		return;
-	if (!co_is_optimizable_root(co, irn))
+	if (!co_is_optimizable_root(irn))
 		return;
 
 	/* Init a new unit */
-	unit = xcalloc(1, sizeof(*unit));
+	unit = XMALLOCZ(unit_t);
 	unit->co = co;
 	unit->node_count = 1;
 	INIT_LIST_HEAD(&unit->queue);
@@ -402,8 +397,8 @@ static void co_collect_units(ir_node *irn, void *env) {
 
 		/* init */
 		arity = get_irn_arity(irn);
-		unit->nodes = xmalloc((arity+1) * sizeof(*unit->nodes));
-		unit->costs = xmalloc((arity+1) * sizeof(*unit->costs));
+		unit->nodes = XMALLOCN(ir_node*, arity + 1);
+		unit->costs = XMALLOCN(int,      arity + 1);
 		unit->nodes[0] = irn;
 
 		/* fill */
@@ -422,7 +417,7 @@ static void co_collect_units(ir_node *irn, void *env) {
 			/* Else insert the argument of the phi to the members of this ou */
 			DBG((dbg, LEVEL_1, "\t   Member: %+F\n", arg));
 
-			if (! arch_irn_is(co->aenv, arg, ignore)) {
+			if (!arch_irn_is(arg, ignore)) {
 				/* Check if arg has occurred at a prior position in the arg/list */
 				arg_pos = 0;
 				for (o=1; o<unit->node_count; ++o) {
@@ -437,40 +432,61 @@ static void co_collect_units(ir_node *irn, void *env) {
 					unit->nodes[unit->node_count] = arg;
 					unit->costs[unit->node_count] = co->get_costs(co, irn, arg, i);
 					unit->node_count++;
-				} else { /* arg has occured before in same phi */
+				} else { /* arg has occurred before in same phi */
 					/* increase costs for existing arg */
 					unit->costs[arg_pos] += co->get_costs(co, irn, arg, i);
 				}
 			}
 		}
-		unit->nodes = xrealloc(unit->nodes, unit->node_count * sizeof(*unit->nodes));
-		unit->costs = xrealloc(unit->costs, unit->node_count * sizeof(*unit->costs));
-	} else
-
-	/* Proj of a perm with corresponding arg */
-	if (is_Perm_Proj(co->aenv, irn)) {
+		unit->nodes = XREALLOC(unit->nodes, ir_node*, unit->node_count);
+		unit->costs = XREALLOC(unit->costs, int,      unit->node_count);
+	} else if (is_Perm_Proj(irn)) {
+		/* Proj of a perm with corresponding arg */
 		assert(!nodes_interfere(co->cenv, irn, get_Perm_src(irn)));
-		unit->nodes = xmalloc(2 * sizeof(*unit->nodes));
-		unit->costs = xmalloc(2 * sizeof(*unit->costs));
+		unit->nodes = XMALLOCN(ir_node*, 2);
+		unit->costs = XMALLOCN(int,      2);
 		unit->node_count = 2;
 		unit->nodes[0] = irn;
 		unit->nodes[1] = get_Perm_src(irn);
 		unit->costs[1] = co->get_costs(co, irn, unit->nodes[1], -1);
 	} else {
-		const arch_register_req_t *req =
-			arch_get_register_req(co->aenv, irn, -1);
+		const arch_register_req_t *req = arch_get_register_req(irn, -1);
 
 		/* Src == Tgt of a 2-addr-code instruction */
 		if (is_2addr_code(req)) {
-			ir_node *other = get_irn_n(skip_Proj(irn), req->other_same);
-			if (!arch_irn_is(co->aenv, other, ignore) &&
-					!nodes_interfere(co->cenv, irn, other)) {
-				unit->nodes = xmalloc(2 * sizeof(*unit->nodes));
-				unit->costs = xmalloc(2 * sizeof(*unit->costs));
-				unit->node_count = 2;
-				unit->nodes[0] = irn;
-				unit->nodes[1] = other;
-				unit->costs[1] = co->get_costs(co, irn, other, -1);
+			const unsigned other = req->other_same;
+			int            count = 0;
+			int            i;
+
+			for (i = 0; (1U << i) <= other; ++i) {
+				if (other & (1U << i)) {
+					ir_node *o  = get_irn_n(skip_Proj(irn), i);
+					if (!arch_irn_is(o, ignore) &&
+							!nodes_interfere(co->cenv, irn, o)) {
+						++count;
+					}
+				}
+			}
+
+			if (count != 0) {
+				int k = 0;
+				++count;
+				unit->nodes = XMALLOCN(ir_node*, count);
+				unit->costs = XMALLOCN(int,      count);
+				unit->node_count = count;
+				unit->nodes[k++] = irn;
+
+				for (i = 0; 1U << i <= other; ++i) {
+					if (other & (1U << i)) {
+						ir_node *o  = get_irn_n(skip_Proj(irn), i);
+						if (!arch_irn_is(o, ignore) &&
+								!nodes_interfere(co->cenv, irn, o)) {
+							unit->nodes[k] = o;
+							unit->costs[k] = co->get_costs(co, irn, o, -1);
+							++k;
+						}
+					}
+				}
 			}
 		} else {
 			assert(0 && "This is not an optimizable node!");
@@ -507,12 +523,11 @@ static int compare_ous(const void *k1, const void *k2) {
 	const unit_t *u2 = *((const unit_t **) k2);
 	int i, o, u1_has_constr, u2_has_constr;
 	arch_register_req_t req;
-	const arch_env_t *aenv = u1->co->aenv;
 
 	/* Units with constraints come first */
 	u1_has_constr = 0;
 	for (i=0; i<u1->node_count; ++i) {
-		arch_get_register_req(aenv, &req, u1->nodes[i], -1);
+		arch_get_register_req(&req, u1->nodes[i], -1);
 		if (arch_register_req_is(&req, limited)) {
 			u1_has_constr = 1;
 			break;
@@ -521,7 +536,7 @@ static int compare_ous(const void *k1, const void *k2) {
 
 	u2_has_constr = 0;
 	for (i=0; i<u2->node_count; ++i) {
-		arch_get_register_req(aenv, &req, u2->nodes[i], -1);
+		arch_get_register_req(&req, u2->nodes[i], -1);
 		if (arch_register_req_is(&req, limited)) {
 			u2_has_constr = 1;
 			break;
@@ -637,11 +652,11 @@ int co_get_copy_costs(const copy_opt_t *co) {
 	ASSERT_OU_AVAIL(co);
 
 	list_for_each_entry(unit_t, curr, &co->units, units) {
-		int root_col = get_irn_col(co, curr->nodes[0]);
+		int root_col = get_irn_col(curr->nodes[0]);
 		DBG((dbg, LEVEL_1, "  %3d costs for root %+F color %d\n", curr->inevitable_costs, curr->nodes[0], root_col));
 		res += curr->inevitable_costs;
 		for (i=1; i<curr->node_count; ++i) {
-			int arg_col = get_irn_col(co, curr->nodes[i]);
+			int arg_col = get_irn_col(curr->nodes[i]);
 			if (root_col != arg_col) {
 				DBG((dbg, LEVEL_1, "  %3d for arg %+F color %d\n", curr->costs[i], curr->nodes[i], arg_col));
 				res += curr->costs[i];
@@ -679,7 +694,7 @@ void co_complete_stats(const copy_opt_t *co, co_complete_stats_t *stat)
 				stat->aff_edges += 1;
 				stat->max_costs += neigh->costs;
 
-				if(get_irn_col(co, an->irn) != get_irn_col(co, neigh->irn)) {
+				if (get_irn_col(an->irn) != get_irn_col(neigh->irn)) {
 					stat->costs += neigh->costs;
 					stat->unsatisfied_edges += 1;
 				}
@@ -723,7 +738,7 @@ static void add_edge(copy_opt_t *co, ir_node *n1, ir_node *n2, int costs) {
 	new_node.irn        = n1;
 	new_node.degree     = 0;
 	new_node.neighbours = NULL;
-	node = set_insert(co->nodes, &new_node, sizeof(new_node), nodeset_hash(new_node.irn));
+	node = set_insert(co->nodes, &new_node, sizeof(new_node), hash_irn(new_node.irn));
 
 	for (nbr = node->neighbours; nbr; nbr = nbr->next)
 		if (nbr->irn == n2) {
@@ -746,7 +761,7 @@ static void add_edge(copy_opt_t *co, ir_node *n1, ir_node *n2, int costs) {
 	nbr->costs += costs;
 }
 
-static INLINE void add_edges(copy_opt_t *co, ir_node *n1, ir_node *n2, int costs) {
+static inline void add_edges(copy_opt_t *co, ir_node *n1, ir_node *n2, int costs) {
 	if (! be_ifg_connected(co->cenv->ifg, n1, n2)) {
 		add_edge(co, n1, n2, costs);
 		add_edge(co, n2, n1, costs);
@@ -758,34 +773,35 @@ static void build_graph_walker(ir_node *irn, void *env) {
 	int pos, max;
 	const arch_register_t *reg;
 
-	if (!is_curr_reg_class(co, irn) || arch_irn_is(co->aenv, irn, ignore))
+	if (!is_curr_reg_class(co, irn) || arch_irn_is(irn, ignore))
 		return;
 
-	reg = arch_get_irn_register(co->aenv, irn);
+	reg = arch_get_irn_register(irn);
 	if (arch_register_type_is(reg, ignore))
 		return;
 
-	/* Phis */
-	if (is_Reg_Phi(irn))
+	if (is_Reg_Phi(irn)) { /* Phis */
 		for (pos=0, max=get_irn_arity(irn); pos<max; ++pos) {
 			ir_node *arg = get_irn_n(irn, pos);
 			add_edges(co, irn, arg, co->get_costs(co, irn, arg, pos));
 		}
-
-	/* Perms */
-	else if (is_Perm_Proj(co->aenv, irn)) {
+	} else if (is_Perm_Proj(irn)) { /* Perms */
 		ir_node *arg = get_Perm_src(irn);
 		add_edges(co, irn, arg, co->get_costs(co, irn, arg, 0));
 	}
-
-	/* 2-address code */
-	else {
-		const arch_register_req_t *req =
-			arch_get_register_req(co->aenv, irn, -1);
+	else { /* 2-address code */
+		const arch_register_req_t *req = arch_get_register_req(irn, -1);
 		if (is_2addr_code(req)) {
-			ir_node *other = get_irn_n(skip_Proj(irn), req->other_same);
-			if (! arch_irn_is(co->aenv, other, ignore))
-				add_edges(co, irn, other, co->get_costs(co, irn, other, 0));
+			const unsigned other = req->other_same;
+			int i;
+
+			for (i = 0; 1U << i <= other; ++i) {
+				if (other & (1U << i)) {
+					ir_node *other = get_irn_n(skip_Proj(irn), i);
+					if (!arch_irn_is(other, ignore))
+						add_edges(co, irn, other, co->get_costs(co, irn, other, 0));
+				}
+			}
 		}
 	}
 }
@@ -813,21 +829,45 @@ int co_gs_is_optimizable(copy_opt_t *co, ir_node *irn) {
 	ASSERT_GS_AVAIL(co);
 
 	new_node.irn = irn;
-	n = set_find(co->nodes, &new_node, sizeof(new_node), nodeset_hash(new_node.irn));
+	n = set_find(co->nodes, &new_node, sizeof(new_node), hash_irn(new_node.irn));
 	if (n) {
 		return (n->degree > 0);
 	} else
 		return 0;
 }
 
+static int co_dump_appel_disjoint_constraints(const copy_opt_t *co, ir_node *a, ir_node *b)
+{
+	ir_node *nodes[]  = { a, b };
+	bitset_t *constr[] = { NULL, NULL };
+	const arch_register_req_t *req;
+	int j;
+
+	constr[0] = bitset_alloca(co->cls->n_regs);
+	constr[1] = bitset_alloca(co->cls->n_regs);
+
+	for (j = 0; j < 2; ++j) {
+		req = arch_get_register_req(nodes[j], BE_OUT_POS(0));
+		if(arch_register_req_is(req, limited))
+			rbitset_copy_to_bitset(req->limited, constr[j]);
+		else
+			bitset_set_all(constr[j]);
+
+	}
+
+	return !bitset_intersect(constr[0], constr[1]);
+}
+
 void co_dump_appel_graph(const copy_opt_t *co, FILE *f)
 {
 	be_ifg_t *ifg  = co->cenv->ifg;
 	int *color_map = alloca(co->cls->n_regs * sizeof(color_map[0]));
+	int *node_map  = XMALLOCN(int, get_irg_last_idx(co->irg) + 1);
 
 	ir_node *irn;
 	void *it, *nit;
-	int i, n, n_regs;
+	int n, n_regs;
+	unsigned i;
 
 	n_regs = 0;
 	for(i = 0; i < co->cls->n_regs; ++i) {
@@ -845,21 +885,21 @@ void co_dump_appel_graph(const copy_opt_t *co, FILE *f)
 
 	n = n_regs;
 	be_ifg_foreach_node(ifg, it, irn) {
-		if(!arch_irn_is(co->aenv, irn, ignore))
-			set_irn_link(irn, INT_TO_PTR(n++));
+		if (!arch_irn_is(irn, ignore))
+			node_map[get_irn_idx(irn)] = n++;
 	}
 
 	fprintf(f, "%d %d\n", n, n_regs);
 
 	be_ifg_foreach_node(ifg, it, irn) {
-		if(!arch_irn_is(co->aenv, irn, ignore)) {
-			int idx            = PTR_TO_INT(get_irn_link(irn));
+		if (!arch_irn_is(irn, ignore)) {
+			int idx            = node_map[get_irn_idx(irn)];
 			affinity_node_t *a = get_affinity_info(co, irn);
 
 			const arch_register_req_t *req;
 			ir_node *adj;
 
-			req = arch_get_register_req(co->aenv, irn, BE_OUT_POS(0));
+			req = arch_get_register_req(irn, BE_OUT_POS(0));
 			if(arch_register_req_is(req, limited)) {
 				for(i = 0; i < co->cls->n_regs; ++i) {
 					if(!rbitset_is_set(req->limited, i) && color_map[i] >= 0)
@@ -867,10 +907,10 @@ void co_dump_appel_graph(const copy_opt_t *co, FILE *f)
 				}
 			}
 
-
 			be_ifg_foreach_neighbour(ifg, nit, irn, adj) {
-				if(!arch_irn_is(co->aenv, adj, ignore)) {
-					int adj_idx = PTR_TO_INT(get_irn_link(adj));
+				if (!arch_irn_is(adj, ignore) &&
+						!co_dump_appel_disjoint_constraints(co, irn, adj)) {
+					int adj_idx = node_map[get_irn_idx(adj)];
 					if(idx < adj_idx)
 						fprintf(f, "%d %d -1\n", idx, adj_idx);
 				}
@@ -880,8 +920,8 @@ void co_dump_appel_graph(const copy_opt_t *co, FILE *f)
 				neighb_t *n;
 
 				co_gs_foreach_neighb(a, n) {
-					if(!arch_irn_is(co->aenv, n->irn, ignore)) {
-						int n_idx = PTR_TO_INT(get_irn_link(n->irn));
+					if (!arch_irn_is(n->irn, ignore)) {
+						int n_idx = node_map[get_irn_idx(n->irn)];
 						if(idx < n_idx)
 							fprintf(f, "%d %d %d\n", idx, n_idx, (int) n->costs);
 					}
@@ -889,331 +929,8 @@ void co_dump_appel_graph(const copy_opt_t *co, FILE *f)
 			}
 		}
 	}
-}
-
-typedef struct _appel_clique_walker_t {
-	ir_phase ph;
-	const copy_opt_t *co;
-	int curr_nr;
-	int node_count;
-	FILE *f;
-	int dumb;
-	int *color_map;
-	struct obstack obst;
-} appel_clique_walker_t;
-
-typedef struct _appel_block_info_t {
-	int *live_end_nr;
-	int *live_in_nr;
-	int *phi_nr;
-	ir_node **live_end;
-	ir_node **live_in;
-	ir_node **phi;
-	int n_live_end;
-	int n_live_in;
-	int n_phi;
-} appel_block_info_t;
-
-static int appel_aff_weight(const appel_clique_walker_t *env, ir_node *bl)
-{
-#if 0
-	double freq = get_block_execfreq(env->co->cenv->execfreq, bl);
-	int res = (int) freq;
-	return res == 0 ? 1 : res;
-#else
-	ir_loop *loop = get_irn_loop(bl);
-	(void) env;
-	if(loop) {
-		int d = get_loop_depth(loop);
-		return 1 + d * d;
-	}
-	return 1;
-#endif
-}
-
-static void *appel_clique_walker_irn_init(ir_phase *phase, ir_node *irn, void *old)
-{
-	appel_block_info_t *res = NULL;
-	(void) old;
-
-	if(is_Block(irn)) {
-		appel_clique_walker_t *d = (void *) phase;
-		res = phase_alloc(phase, sizeof(res[0]));
-		res->phi_nr      = phase_alloc(phase, d->co->cls->n_regs * sizeof(res->live_end_nr));
-		res->live_end_nr = phase_alloc(phase, d->co->cls->n_regs * sizeof(res->live_end_nr));
-		res->live_in_nr  = phase_alloc(phase, d->co->cls->n_regs * sizeof(res->live_in_nr));
-		res->live_end    = phase_alloc(phase, d->co->cls->n_regs * sizeof(res->live_end));
-		res->live_in     = phase_alloc(phase, d->co->cls->n_regs * sizeof(res->live_in));
-		res->phi         = phase_alloc(phase, d->co->cls->n_regs * sizeof(res->live_in));
-	}
-
-	return res;
-}
-
-typedef struct _insn_list_t {
-	be_insn_t *insn;
-	struct list_head list;
-} insn_list_t;
-
-static int appel_get_live_end_nr(appel_clique_walker_t *env, ir_node *bl, ir_node *irn)
-{
-	appel_block_info_t *bli = phase_get_irn_data(&env->ph, bl);
-	int i;
-
-	for(i = 0; i < bli->n_live_end; ++i)
-		if(bli->live_end[i] == irn)
-			return bli->live_end_nr[i];
-
-	return -1;
-}
-
-static int appel_dump_clique(appel_clique_walker_t *env, pset *live, ir_node *bl, int curr_nr, int start_nr)
-{
-	ir_node **live_arr = alloca(env->co->cls->n_regs * sizeof(live_arr[0]));
-	ir_node *irn;
-	int n_live;
-	int j;
-
-	n_live = 0;
-	foreach_pset(live, irn)
-		live_arr[n_live++] = irn;
-
-	/* dump the live after clique */
-	if(!env->dumb) {
-		for(j = 0; j < n_live; ++j) {
-			int k;
-
-			for(k = j + 1; k < n_live; ++k) {
-				fprintf(env->f, "%d %d -1 ", curr_nr + j, curr_nr + k);
-			}
-			fprintf(env->f, "\n");
-		}
-	}
-
-	/* dump the affinities */
-	for(j = 0; !env->dumb && j < n_live; ++j) {
-		ir_node *irn = live_arr[j];
-		int old_nr = PTR_TO_INT(get_irn_link(irn));
-
-		/* if the node was already live in the last insn dump the affinity */
-		if(old_nr > start_nr) {
-			int weight = appel_aff_weight(env, bl);
-			fprintf(env->f, "%d %d %d\n", old_nr, curr_nr + j, weight);
-		}
-	}
-
-	/* set the current numbers into the link field. */
-	for(j = 0; j < n_live; ++j) {
-		ir_node *irn = live_arr[j];
-		set_irn_link(irn, INT_TO_PTR(curr_nr + j));
-	}
-
-	return curr_nr + n_live;
-}
-
-static void appel_walker(ir_node *bl, void *data)
-{
-	appel_clique_walker_t *env = data;
-	appel_block_info_t *bli    = phase_get_or_set_irn_data(&env->ph, bl);
-	struct obstack *obst       = &env->obst;
-	void *base                 = obstack_base(obst);
-	pset *live                 = pset_new_ptr_default();
-	be_lv_t *lv                = env->co->cenv->birg->lv;
-
-	int n_insns  = 0;
-	int n_nodes  = 0;
-	int start_nr = env->curr_nr;
-	int curr_nr  = start_nr;
-
-	be_insn_env_t insn_env;
-	int i, j;
-	ir_node *irn;
-	be_insn_t **insns;
-
-	insn_env.aenv = env->co->aenv;
-	insn_env.cls  = env->co->cls;
-	insn_env.obst = obst;
-	insn_env.ignore_colors = env->co->cenv->ignore_colors;
-
-	/* Guess how many insns will be in this block. */
-	sched_foreach(bl, irn)
-		n_nodes++;
-
-	bli->n_phi = 0;
-	insns = xmalloc(n_nodes * sizeof(insns[0]));
-
-	/* Put all insns in an array. */
-	irn = sched_first(bl);
-	while(!sched_is_end(irn)) {
-		be_insn_t *insn;
-		insn = be_scan_insn(&insn_env, irn);
-		insns[n_insns++] = insn;
-		irn = insn->next_insn;
-	}
-
-	DBG((dbg, LEVEL_2, "%+F\n", bl));
-	be_liveness_end_of_block(lv, env->co->aenv, env->co->cls, bl, live);
-
-	/* Generate the bad and ugly. */
-	for(i = n_insns - 1; i >= 0; --i) {
-		be_insn_t *insn = insns[i];
-
-		/* The first live set has to be saved in the block border set. */
-		if(i == n_insns - 1) {
-			j = 0;
-			foreach_pset(live, irn) {
-				bli->live_end[j]    = irn;
-				bli->live_end_nr[j] = curr_nr + j;
-				++j;
-			}
-			bli->n_live_end = j;
-		}
-
-		if(!env->dumb) {
-			for(j = 0; j < insn->use_start; ++j) {
-				ir_node *op   = insn->ops[j].carrier;
-				bitset_t *adm = insn->ops[j].regs;
-				int k;
-				int nr;
-
-				if(!insn->ops[j].has_constraints)
-					continue;
-
-				nr = 0;
-				foreach_pset(live, irn) {
-					if(irn == op) {
-						pset_break(live);
-						break;
-					}
-					++nr;
-				}
-
-				assert(nr < pset_count(live));
-
-				for(k = 0; k < env->co->cls->n_regs; ++k) {
-					int mapped_col = env->color_map[k];
-					if(mapped_col >= 0 && !bitset_is_set(adm, k) && !bitset_is_set(env->co->cenv->ignore_colors, k))
-						fprintf(env->f, "%d %d -1\n", curr_nr + nr, mapped_col);
-				}
-			}
-		}
-
-		/* dump the clique and update the stuff. */
-		curr_nr = appel_dump_clique(env, live, bl, curr_nr, start_nr);
-
-		/* remove all defs. */
-		for(j = 0; j < insn->use_start; ++j)
-			pset_remove_ptr(live, insn->ops[j].carrier);
-
-		if(is_Phi(insn->irn) && arch_irn_consider_in_reg_alloc(env->co->aenv, env->co->cls, insn->irn)) {
-			bli->phi[bli->n_phi]    = insn->irn;
-			bli->phi_nr[bli->n_phi] = PTR_TO_INT(get_irn_link(insn->irn));
-			bli->n_phi++;
-		}
-
-		/* add all uses */
-		else
-			for(j = insn->use_start; j < insn->n_ops; ++j)
-				pset_insert_ptr(live, insn->ops[j].carrier);
-	}
 
-	/* print the start clique. */
-	curr_nr = appel_dump_clique(env, live, bl, curr_nr, start_nr);
-
-	i = 0;
-	foreach_pset(live, irn) {
-		bli->live_in[i]    = irn;
-		bli->live_in_nr[i] = PTR_TO_INT(get_irn_link(irn));
-		++i;
-	}
-	bli->n_live_in = i;
-
-	del_pset(live);
-	free(insns);
-	obstack_free(obst, base);
-	env->curr_nr = curr_nr;
-}
-
-static void appel_inter_block_aff(ir_node *bl, void *data)
-{
-	appel_clique_walker_t *env = data;
-	appel_block_info_t *bli    = phase_get_irn_data(&env->ph, bl);
-
-	int i, j, n;
-
-	for(i = 0; i < bli->n_live_in; ++i) {
-		ir_node *irn = bli->live_in[i];
-
-		for(j = 0, n = get_Block_n_cfgpreds(bl); j < n; ++j) {
-			ir_node *pred  = get_Block_cfgpred_block(bl, j);
-
-			int nr = appel_get_live_end_nr(env, pred, irn);
-			assert(nr >= 0);
-			fprintf(env->f, "%d %d 1\n", bli->live_in_nr[i], nr);
-		}
-	}
-
-	for(i = 0; i < bli->n_phi; ++i) {
-		ir_node *irn = bli->phi[i];
-
-		for(j = 0, n = get_Block_n_cfgpreds(bl); j < n; ++j) {
-			ir_node *pred  = get_Block_cfgpred_block(bl, j);
-			ir_node *op = get_irn_n(irn, j);
-
-			int nr = appel_get_live_end_nr(env, pred, op);
-			assert(nr >= 0);
-			fprintf(env->f, "%d %d 1\n", bli->phi_nr[i], nr);
-		}
-	}
-
-}
-
-void co_dump_appel_graph_cliques(const copy_opt_t *co, FILE *f)
-{
-	int i;
-	int n_colors;
-	appel_clique_walker_t env;
-	bitset_t *adm = bitset_alloca(co->cls->n_regs);
-	be_lv_t *lv = co->cenv->birg->lv;
-
-	be_liveness_recompute(lv);
-	obstack_init(&env.obst);
-	phase_init(&env.ph, "appel_clique_dumper", co->irg, PHASE_DEFAULT_GROWTH, appel_clique_walker_irn_init, NULL);
-	env.curr_nr = co->cls->n_regs;
-	env.co = co;
-	env.f = f;
-
-	bitset_copy(adm, co->cenv->ignore_colors);
-	bitset_flip_all(adm);
-
-	/* Make color map. */
-	env.color_map = alloca(co->cls->n_regs * sizeof(env.color_map[0]));
-	for(i = 0, n_colors = 0; i < co->cls->n_regs; ++i) {
-		const arch_register_t *reg = &co->cls->regs[i];
-		env.color_map[i] = arch_register_type_is(reg, ignore) ? -1 : n_colors++;
-	}
-
-	env.dumb = 1;
-	env.curr_nr = n_colors;
-	irg_block_walk_graph(co->irg, firm_clear_link, NULL, NULL);
-	irg_block_walk_graph(co->irg, appel_walker, NULL, &env);
-
-	fprintf(f, "%d %d\n", env.curr_nr, n_colors);
-
-	/* make the first k nodes interfere */
-	for(i = 0; i < n_colors; ++i) {
-		int j;
-		for(j = i + 1; j < n_colors; ++j)
-			fprintf(f, "%d %d -1 ", i, j);
-		fprintf(f, "\n");
-	}
-
-	env.dumb = 0;
-	env.curr_nr = n_colors;
-	irg_block_walk_graph(co->irg, firm_clear_link, NULL, NULL);
-	irg_block_walk_graph(co->irg, appel_walker, NULL, &env);
-	irg_block_walk_graph(co->irg, appel_inter_block_aff, NULL, &env);
-	obstack_free(&env.obst, NULL);
+	xfree(node_map);
 }
 
 /*
@@ -1277,31 +994,28 @@ static void ifg_dump_graph_attr(FILE *f, void *self)
 
 static int ifg_is_dump_node(void *self, ir_node *irn)
 {
-	co_ifg_dump_t *cod = self;
-	return !arch_irn_is(cod->co->aenv, irn, ignore);
+	(void)self;
+	return !arch_irn_is(irn, ignore);
 }
 
 static void ifg_dump_node_attr(FILE *f, void *self, ir_node *irn)
 {
 	co_ifg_dump_t *env         = self;
-	const arch_register_t *reg = arch_get_irn_register(env->co->aenv, irn);
+	const arch_register_t *reg = arch_get_irn_register(irn);
 	const arch_register_req_t *req;
 	int limited;
 
-	req = arch_get_register_req(env->co->aenv, irn, BE_OUT_POS(0));
+	req = arch_get_register_req(irn, BE_OUT_POS(0));
 	limited = arch_register_req_is(req, limited);
 
 	if(env->flags & CO_IFG_DUMP_LABELS) {
 		ir_fprintf(f, "label=\"%+F", irn);
 
-#if 0
-		// TODO fix this...
 		if((env->flags & CO_IFG_DUMP_CONSTR) && limited) {
 			bitset_t *bs = bitset_alloca(env->co->cls->n_regs);
-			req.limited(req.limited_env, bs);
+			rbitset_copy_to_bitset(req->limited, bs);
 			ir_fprintf(f, "\\n%B", bs);
 		}
-#endif
 		ir_fprintf(f, "\" ");
 	} else {
 		fprintf(f, "label=\"\" shape=point " );
@@ -1320,12 +1034,12 @@ static void ifg_dump_at_end(FILE *file, void *self)
 	affinity_node_t *a;
 
 	co_gs_foreach_aff_node(env->co, a) {
-		const arch_register_t *ar = arch_get_irn_register(env->co->aenv, a->irn);
+		const arch_register_t *ar = arch_get_irn_register(a->irn);
 		unsigned aidx = get_irn_idx(a->irn);
 		neighb_t *n;
 
 		co_gs_foreach_neighb(a, n) {
-			const arch_register_t *nr = arch_get_irn_register(env->co->aenv, n->irn);
+			const arch_register_t *nr = arch_get_irn_register(n->irn);
 			unsigned nidx = get_irn_idx(n->irn);
 
 			if(aidx < nidx) {
@@ -1395,10 +1109,16 @@ static co_algo_info_t algos[] = {
 	{ void_algo,               "none",  0 },
 	{ co_solve_heuristic,      "heur1", 0 },
 	{ co_solve_heuristic_new,  "heur2", 0 },
+#ifdef WITH_JVM
 	{ co_solve_heuristic_java, "heur3", 0 },
+#else
+	{ NULL,                    "heur3", 0 },
+#endif
 	{ co_solve_heuristic_mst,  "heur4", 0 },
 #ifdef WITH_ILP
 	{ co_solve_ilp2,           "ilp",   1 },
+#else
+	{ NULL,                    "ilp",   1 },
 #endif
 	{ NULL,                    "",      0 }
 };
@@ -1416,8 +1136,19 @@ static FILE *my_open(const be_chordal_env_t *env, const char *prefix, const char
 {
 	FILE *result;
 	char buf[1024];
+	size_t i, n;
+	char *tu_name;
+
+	n = strlen(env->birg->main_env->cup_name);
+	tu_name = XMALLOCN(char, n + 1);
+	strcpy(tu_name, env->birg->main_env->cup_name);
+	for (i = 0; i < n; ++i)
+		if (tu_name[i] == '.')
+			tu_name[i] = '_';
 
-	ir_snprintf(buf, sizeof(buf), "%s%F_%s%s", prefix, env->irg, env->cls->name, suffix);
+
+	ir_snprintf(buf, sizeof(buf), "%s%s_%F_%s%s", prefix, tu_name, env->irg, env->cls->name, suffix);
+	xfree(tu_name);
 	result = fopen(buf, "wt");
 	if(result == NULL) {
 		panic("Couldn't open '%s' for writing.", buf);
@@ -1428,7 +1159,7 @@ static FILE *my_open(const be_chordal_env_t *env, const char *prefix, const char
 
 void co_driver(be_chordal_env_t *cenv)
 {
-	lc_timer_t          *timer = lc_timer_register("firm.be.copyopt", "runtime");
+	ir_timer_t          *timer = ir_timer_register("firm.be.copyopt", "runtime");
 	co_complete_stats_t before, after;
 	copy_opt_t          *co;
 	co_algo_t           *algo_func;
@@ -1454,13 +1185,6 @@ void co_driver(be_chordal_env_t *cenv)
 	be_stat_ev_ull("co_init_costs",   before.costs);
 	be_stat_ev_ull("co_init_unsat",   before.unsatisfied_edges);
 
-	/* Dump the interference graph in Appel's format. */
-	if (dump_flags & DUMP_APPEL) {
-		FILE *f = my_open(cenv, "", ".apl");
-		co_dump_appel_graph(co, f);
-		fclose(f);
-	}
-
 	if (dump_flags & DUMP_BEFORE) {
 		FILE *f = my_open(cenv, "", "-before.dot");
 		co_dump_ifg_dot(co, f, style_flags);
@@ -1492,11 +1216,11 @@ void co_driver(be_chordal_env_t *cenv)
 	algo_func = algos[algo].algo;
 
 	/* perform actual copy minimization */
-	lc_timer_reset_and_start(timer);
+	ir_timer_reset_and_start(timer);
 	was_optimal = algo_func(co);
-	lc_timer_stop(timer);
+	ir_timer_stop(timer);
 
-	be_stat_ev("co_time", lc_timer_elapsed_msec(timer));
+	be_stat_ev("co_time", ir_timer_elapsed_msec(timer));
 	be_stat_ev_ull("co_optimal", was_optimal);
 
 	if (dump_flags & DUMP_AFTER) {
@@ -1520,6 +1244,14 @@ void co_driver(be_chordal_env_t *cenv)
 			printf("%10" ULL_FMT " %5s\n", after.costs, "-");
 	}
 
+	/* Dump the interference graph in Appel's format. */
+	if (dump_flags & DUMP_APPEL) {
+		FILE *f = my_open(cenv, "", ".apl");
+		fprintf(f, "# %lld %lld\n", after.costs, after.unsatisfied_edges);
+		co_dump_appel_graph(co, f);
+		fclose(f);
+	}
+
 	be_stat_ev_ull("co_after_costs", after.costs);
 	be_stat_ev_ull("co_after_unsat", after.unsatisfied_edges);