X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbelower.c;h=c57d713b6106f2b524cb73188c514d0d4552f3aa;hb=792ff7d39c59a18197607c68305a75aefbf00816;hp=d520766ba5083a7022e7660434e2f2ee83e4c753;hpb=0b36498966f340f452da65d7bbd8bd661d699460;p=libfirm

diff --git a/ir/be/belower.c b/ir/be/belower.c
index d520766ba..c57d713b6 100644
--- a/ir/be/belower.c
+++ b/ir/be/belower.c
@@ -20,8 +20,9 @@
 #include "bearch.h"
 #include "belower.h"
 #include "benode_t.h"
-#include "bechordal_t.h"
 #include "besched_t.h"
+#include "bestat.h"
+#include "benodesets.h"
 
 #include "irgmod.h"
 #include "iredges_t.h"
@@ -34,29 +35,28 @@
  #include <alloca.h>
 #endif
 
-#undef is_Perm
-#define is_Perm(arch_env, irn) (arch_irn_classify(arch_env, irn) == arch_irn_class_perm)
-
-/* collect static data about perms */
-typedef struct _perm_stat_t {
-	const arch_register_class_t *cls; /**< the current register class */
-    int  *perm_size_ar;       /**< the sizes of all perms in an irg */
-    int  *real_perm_size_ar;  /**< the sizes of all perms in an irg */
-	int  *chain_len_ar;       /**< the sizes of all chains for all perms */
-	int  *cycle_len_ar;       /**< the siyes of all cycles for all perms */
-	int   num_perms;          /**< number of all perms */
-	int   num_real_perms;     /**< number of all perms */
-	int   num_chains;         /**< the number of all chains */
-	int   num_cycles;         /**< the number of all cycles */
-} perm_stat_t;
+#undef KEEP_ALIVE_COPYKEEP_HACK
+
+/* associates op with it's copy and CopyKeep */
+typedef struct {
+	ir_node *op;         /* an irn which must be different */
+	pset    *copies;     /* all non-spillable copies of this irn */
+	const arch_register_class_t *cls;
+} op_copy_assoc_t;
+
+/* environment for constraints */
+typedef struct {
+	be_irg_t       *birg;
+	pset           *op_set;
+	struct obstack obst;
+	DEBUG_ONLY(firm_dbg_module_t *dbg;)
+} constraint_env_t;
 
 /* lowering walker environment */
 typedef struct _lower_env_t {
-	be_chordal_env_t  *chord_env;
-	unsigned           do_copy:1;
-	unsigned           do_stat:1;
-	unsigned           pstat_n:30;
-	perm_stat_t      **pstat;
+	be_irg_t         *birg;
+	const arch_env_t *arch_env;
+	unsigned          do_copy : 1;
 	DEBUG_ONLY(firm_dbg_module_t *dbg_module;)
 } lower_env_t;
 
@@ -85,6 +85,23 @@ typedef struct _perm_cycle_t {
 	perm_type_t             type;        /**< type (CHAIN or CYCLE) */
 } perm_cycle_t;
 
+static void kill_node(ir_node *irn, int kill_block) {
+	int      i, arity = get_irn_arity(irn);
+	ir_graph *irg     = get_irn_irg(irn);
+
+	for (i = -1; i < arity; ++i) {
+		set_irn_n(irn, i, new_r_Bad(irg));
+	}
+}
+
+/* Compare the two operands */
+static int cmp_op_copy_assoc(const void *a, const void *b) {
+	const op_copy_assoc_t *op1 = a;
+	const op_copy_assoc_t *op2 = b;
+
+	return op1->op != op2->op;
+}
+
 /* Compare the in registers of two register pairs */
 static int compare_reg_pair(const void *a, const void *b) {
 	const reg_pair_t *pair_a = a;
@@ -263,10 +280,9 @@ static void lower_perm_node(ir_node *irn, void *walk_env) {
 	const arch_register_class_t *reg_class;
 	const arch_env_t            *arch_env;
 	lower_env_t     *env         = walk_env;
-	perm_stat_t    **pstat       = env->pstat;
-	int              pstat_idx   = -1;
-	int              real_size   = 0;
-	int              n, i, pn, do_copy, j, n_ops;
+	int             real_size    = 0;
+	int             keep_perm    = 0;
+	int             n, i, pn, do_copy, j, n_ops;
 	reg_pair_t      *pairs;
 	const ir_edge_t *edge;
 	perm_cycle_t    *cycle;
@@ -275,7 +291,7 @@ static void lower_perm_node(ir_node *irn, void *walk_env) {
 	ir_node         *cpyxchg = NULL;
 	DEBUG_ONLY(firm_dbg_module_t *mod;)
 
-	arch_env = env->chord_env->birg->main_env->arch_env;
+	arch_env = env->arch_env;
 	do_copy  = env->do_copy;
 	DEBUG_ONLY(mod = env->dbg_module;)
 	block    = get_nodes_block(irn);
@@ -296,22 +312,6 @@ static void lower_perm_node(ir_node *irn, void *walk_env) {
 	reg_class = arch_get_irn_register(arch_env, get_irn_n(irn, 0))->reg_class;
 	pairs     = alloca(n * sizeof(pairs[0]));
 
-	if (env->do_stat) {
-		unsigned i;
-
-		/* determine index in statistics */
-		for (i = 0; i < env->pstat_n; i++) {
-			if (strcmp(pstat[i]->cls->name, reg_class->name) == 0) {
-				pstat_idx = i;
-				break;
-			}
-		}
-		assert(pstat_idx >= 0 && "could not determine class index for statistics");
-
-		pstat[pstat_idx]->num_perms++;
-		pstat[pstat_idx]->perm_size_ar[n - 1]++;
-	}
-
 	/* build the list of register pairs (in, out) */
 	i = 0;
 	foreach_out_edge(irn, edge) {
@@ -339,7 +339,7 @@ static void lower_perm_node(ir_node *irn, void *walk_env) {
 			/* We have to check for a special case:
 				The in-node could be a Proj from a Perm. In this case,
 				we need to correct the projnum */
-			if (is_Perm(arch_env, pairs[i].in_node) && is_Proj(pairs[i].in_node)) {
+			if (be_is_Perm(pairs[i].in_node) && is_Proj(pairs[i].in_node)) {
 				set_Proj_proj(pairs[i].out_node, get_Proj_proj(pairs[i].in_node));
 			}
 
@@ -347,7 +347,8 @@ static void lower_perm_node(ir_node *irn, void *walk_env) {
 			sched_remove(pairs[i].out_node);
 
 			/* reroute the edges from the proj to the argument */
-			edges_reroute(pairs[i].out_node, pairs[i].in_node, env->chord_env->irg);
+			edges_reroute(pairs[i].out_node, pairs[i].in_node, env->birg->irg);
+			set_irn_n(pairs[i].out_node, 0, new_Bad());
 
 			pairs[i].checked = 1;
 		}
@@ -358,13 +359,9 @@ static void lower_perm_node(ir_node *irn, void *walk_env) {
 		do_copy = 0;
 	}
 
-	if (env->do_stat && get_n_checked_pairs(pairs, n) < n) {
-		pstat[pstat_idx]->num_real_perms++;
-		pstat[pstat_idx]->real_perm_size_ar[n - 1]++;
-		real_size = n - get_n_checked_pairs(pairs, n);
-	}
+	real_size = n - get_n_checked_pairs(pairs, n);
 
-	hook_be_block_stat_perm(reg_class->name, reg_class->n_regs, irn, block, n, real_size);
+	be_do_stat_perm(reg_class->name, reg_class->n_regs, irn, block, n, real_size);
 
 	/* check for cycles and chains */
 	while (get_n_checked_pairs(pairs, n) < n) {
@@ -381,24 +378,14 @@ static void lower_perm_node(ir_node *irn, void *walk_env) {
 		}
 		DB((mod, LEVEL_1, "\n"));
 
-		/* statistics */
-		if (env->do_stat) {
-			int n_idx = cycle->n_elems - 1;
-			if (cycle->type == PERM_CHAIN) {
-				pstat[pstat_idx]->num_chains++;
-				pstat[pstat_idx]->chain_len_ar[n_idx]++;
-			}
-			else {
-				pstat[pstat_idx]->num_cycles++;
-				pstat[pstat_idx]->cycle_len_ar[n_idx]++;
-			}
-		}
-
-		/* We don't need to do anything if we have a Perm with two
+		/*
+			We don't need to do anything if we have a Perm with two
 			elements which represents a cycle, because those nodes
-			already represent exchange nodes */
+			already represent exchange nodes
+		*/
 		if (n == 2 && cycle->type == PERM_CYCLE) {
 			free(cycle);
+			keep_perm = 1;
 			continue;
 		}
 
@@ -456,7 +443,7 @@ static void lower_perm_node(ir_node *irn, void *walk_env) {
 				DBG((mod, LEVEL_1, "%+F                        (%+F, %s) and (%+F, %s)\n",
 					irn, res1, cycle->elems[i]->name, res2, cycle->elems[i + 1]->name));
 
-				cpyxchg = be_new_Perm(reg_class, env->chord_env->irg, block, 2, in);
+				cpyxchg = be_new_Perm(reg_class, env->birg->irg, block, 2, in);
 				n_ops++;
 
 				if (i > 0) {
@@ -498,7 +485,7 @@ static void lower_perm_node(ir_node *irn, void *walk_env) {
 				DBG((mod, LEVEL_1, "%+F creating copy node (%+F, %s) -> (%+F, %s)\n",
 					irn, arg1, cycle->elems[i]->name, res2, cycle->elems[i + 1]->name));
 
-				cpyxchg = be_new_Copy(reg_class, env->chord_env->irg, block, arg1);
+				cpyxchg = be_new_Copy(reg_class, env->birg->irg, block, arg1);
 				arch_set_irn_register(arch_env, cpyxchg, cycle->elems[i + 1]);
 				n_ops++;
 
@@ -516,19 +503,17 @@ static void lower_perm_node(ir_node *irn, void *walk_env) {
 			}
 		}
 
-		if (env->do_stat) {
-			hook_be_block_stat_permcycle(reg_class->name, irn, block, \
-				cycle->type == PERM_CHAIN, cycle->n_elems, n_ops);
-		}
+		be_do_stat_permcycle(reg_class->name, irn, block, cycle->type == PERM_CHAIN, cycle->n_elems, n_ops);
 
 		free((void *) cycle->elems);
 		free(cycle);
 	}
 
-
-
 	/* remove the perm from schedule */
-	sched_remove(irn);
+	if (! keep_perm) {
+		kill_node(irn, 0);
+		sched_remove(irn);
+	}
 }
 
 
@@ -550,26 +535,31 @@ static ir_node *belower_skip_proj(ir_node *irn) {
 	return irn;
 }
 
-static void fix_in(ir_node *irn, ir_node *old, ir_node *nw) {
-	int i, n;
-
-	irn = belower_skip_proj(irn);
-	n   = get_irn_arity(irn);
-
-	for (i = 0; i < n; i++) {
-		if (get_irn_n(irn, i) == old) {
-			set_irn_n(irn, i, nw);
-			break;
-		}
+static ir_node *find_copy(constraint_env_t *env, ir_node *irn, ir_node *op) {
+	const arch_env_t *arch_env = env->birg->main_env->arch_env;
+	ir_node          *block    = get_nodes_block(irn);
+	ir_node          *cur_node;
+
+	for (cur_node = sched_prev(irn);
+		! is_Block(cur_node) && be_is_Copy(cur_node) && get_nodes_block(cur_node) == block;
+		cur_node = sched_prev(cur_node))
+	{
+		if (be_get_Copy_op(cur_node) == op && arch_irn_is(arch_env, cur_node, dont_spill))
+			return cur_node;
 	}
+
+	return NULL;
 }
 
-static void gen_assure_different_pattern(ir_node *irn, be_irg_t *birg, ir_node *other_different) {
-	const arch_env_t          *arch_env = birg->main_env->arch_env;
-	ir_node                   *in[2], *keep, *cpy, *temp;
-	ir_node                   *block = get_nodes_block(irn);
-	const arch_register_class_t *cls = arch_get_irn_reg_class(arch_env, other_different, -1);
-	FIRM_DBG_REGISTER(firm_dbg_module_t *mod, "firm.be.lower");
+static void gen_assure_different_pattern(ir_node *irn, ir_node *other_different, constraint_env_t *env) {
+	be_irg_t                    *birg     = env->birg;
+	pset                        *op_set   = env->op_set;
+	const arch_env_t            *arch_env = birg->main_env->arch_env;
+	ir_node                     *block    = get_nodes_block(irn);
+	const arch_register_class_t *cls      = arch_get_irn_reg_class(arch_env, other_different, -1);
+	ir_node                     *in[2], *keep, *cpy;
+	op_copy_assoc_t             key, *entry;
+	DEBUG_ONLY(firm_dbg_module_t *mod     = env->dbg;)
 
 	if (arch_irn_is(arch_env, other_different, ignore) || ! mode_is_datab(get_irn_mode(other_different))) {
 		DBG((mod, LEVEL_1, "ignore constraint for %+F because other_irn is ignore or not a datab node\n", irn));
@@ -581,16 +571,20 @@ static void gen_assure_different_pattern(ir_node *irn, be_irg_t *birg, ir_node *
 	/* in block far far away                             */
 	/* The copy is optimized later if not needed         */
 
-	temp = new_rd_Unknown(birg->irg, get_irn_mode(other_different));
-	cpy = be_new_Copy(cls, birg->irg, block, temp);
-	be_node_set_flags(cpy, BE_OUT_POS(0), arch_irn_flags_dont_spill);
+	/* check if already exists such a copy in the schedule immediatly before */
+	cpy = find_copy(env, belower_skip_proj(irn), other_different);
+	if (! cpy) {
+		cpy = be_new_Copy(cls, birg->irg, block, other_different);
+		be_node_set_flags(cpy, BE_OUT_POS(0), arch_irn_flags_dont_spill);
+		DBG((mod, LEVEL_1, "created non-spillable %+F for value %+F\n", cpy, other_different));
+	}
+	else {
+		DBG((mod, LEVEL_1, "using already existing %+F for value %+F\n", cpy, other_different));
+	}
 
 	in[0] = irn;
 	in[1] = cpy;
 
-	/* Let the irn use the copy instead of the old other_different */
-	fix_in(irn, other_different, cpy);
-
 	/* Add the Keep resp. CopyKeep and reroute the users */
 	/* of the other_different irn in case of CopyKeep.   */
 	if (get_n_out_edges(other_different) == 0) {
@@ -599,35 +593,56 @@ static void gen_assure_different_pattern(ir_node *irn, be_irg_t *birg, ir_node *
 	else {
 		keep = be_new_CopyKeep_single(cls, birg->irg, block, cpy, irn, get_irn_mode(other_different));
 		be_node_set_reg_class(keep, 1, cls);
-		edges_reroute(other_different, keep, birg->irg);
 	}
 
-	/* after rerouting: let the copy point to the other_different irn */
-	set_irn_n(cpy, 0, other_different);
+	DBG((mod, LEVEL_1, "created %+F(%+F, %+F)\n\n", keep, irn, cpy));
 
-	DBG((mod, LEVEL_1, "created %+F for %+F to assure should_be_different\n", keep, irn));
+	/* insert copy and keep into schedule */
+	assert(sched_is_scheduled(irn) && "need schedule to assure constraints");
+	if (! sched_is_scheduled(cpy))
+		sched_add_before(belower_skip_proj(irn), cpy);
+	sched_add_after(irn, keep);
+
+	/* insert the other different and it's copies into the set */
+	key.op         = other_different;
+	key.copies     = NULL;
+	entry          = pset_find(op_set, &key, nodeset_hash(other_different));
+
+	if (! entry) {
+		entry         = obstack_alloc(&env->obst, sizeof(*entry));
+		entry->copies = pset_new_ptr_default();
+		entry->op     = other_different;
+		entry->cls    = cls;
+	}
+
+	/* insert copy */
+	pset_insert_ptr(entry->copies, cpy);
+
+	/* insert keep in case of CopyKeep */
+	if (be_is_CopyKeep(keep))
+		pset_insert_ptr(entry->copies, keep);
+
+	pset_insert(op_set, entry, nodeset_hash(other_different));
 }
 
 /**
  * Checks if node has a should_be_different constraint in output
  * and adds a Keep then to assure the constraint.
  */
-static void assure_different_constraints(ir_node *irn, be_irg_t *birg) {
-	const arch_env_t          *arch_env = birg->main_env->arch_env;
+static void assure_different_constraints(ir_node *irn, constraint_env_t *env) {
 	const arch_register_req_t *req;
-	arch_register_req_t        req_temp;
-	int i, n;
+	arch_register_req_t       req_temp;
 
-	req = arch_get_register_req(arch_env, &req_temp, irn, -1);
+	req = arch_get_register_req(env->birg->main_env->arch_env, &req_temp, irn, -1);
 
 	if (req) {
 		if (arch_register_req_is(req, should_be_different)) {
-			gen_assure_different_pattern(irn, birg, req->other_different);
+			gen_assure_different_pattern(irn, req->other_different, env);
 		}
 		else if (arch_register_req_is(req, should_be_different_from_all)) {
-			n = get_irn_arity(belower_skip_proj(irn));
+			int i, n = get_irn_arity(belower_skip_proj(irn));
 			for (i = 0; i < n; i++) {
-				gen_assure_different_pattern(irn, birg, get_irn_n(belower_skip_proj(irn), i));
+				gen_assure_different_pattern(irn, get_irn_n(belower_skip_proj(irn), i), env);
 			}
 		}
 	}
@@ -645,13 +660,131 @@ static void assure_constraints_walker(ir_node *irn, void *walk_env) {
 	if (is_Block(irn))
 		return;
 
-	if (mode_is_datab(get_irn_mode(irn)))
+	if (sched_is_scheduled(irn) && mode_is_datab(get_irn_mode(irn)))
 		assure_different_constraints(irn, walk_env);
 
 	return;
 }
 
+/**
+ * Melt all copykeeps pointing to the same node
+ * (or Projs of the same node), copying the same operand.
+ */
+static void melt_copykeeps(constraint_env_t *cenv) {
+	op_copy_assoc_t *entry;
+
+	/* for all */
+	foreach_pset(cenv->op_set, entry) {
+		int     idx, num_ck;
+		ir_node *cp;
+		struct obstack obst;
+		ir_node **ck_arr, **melt_arr;
+
+		obstack_init(&obst);
+
+		/* collect all copykeeps */
+		num_ck = idx = 0;
+		foreach_pset(entry->copies, cp) {
+			if (be_is_CopyKeep(cp)) {
+				obstack_grow(&obst, &cp, sizeof(cp));
+				++num_ck;
+			}
+#ifdef KEEP_ALIVE_COPYKEEP_HACK
+			else {
+				set_irn_mode(cp, mode_ANY);
+				keep_alive(cp);
+			}
+#endif /* KEEP_ALIVE_COPYKEEP_HACK */
+		}
+
+		/* compare each copykeep with all other copykeeps */
+		ck_arr = (ir_node **)obstack_finish(&obst);
+		for (idx = 0; idx < num_ck; ++idx) {
+			ir_node *ref, *ref_mode_T;
+
+			if (ck_arr[idx]) {
+				int j, n_melt;
+				ir_node **new_ck_in;
+				ir_node *new_ck;
+				ir_node *sched_pt = NULL;
+
+				n_melt     = 1;
+				ref        = ck_arr[idx];
+				ref_mode_T = skip_Proj(get_irn_n(ref, 1));
+				obstack_grow(&obst, &ref, sizeof(ref));
+
+				DBG((cenv->dbg, LEVEL_1, "Trying to melt %+F:\n", ref));
+
+				/* check for copykeeps pointing to the same mode_T node as the reference copykeep */
+				for (j = 0; j < num_ck; ++j) {
+					ir_node *cur_ck = ck_arr[j];
+
+					if (j != idx && cur_ck && skip_Proj(get_irn_n(cur_ck, 1)) == ref_mode_T) {
+						obstack_grow(&obst, &cur_ck, sizeof(cur_ck));
+						pset_remove_ptr(entry->copies, cur_ck);
+						DBG((cenv->dbg, LEVEL_1, "\t%+F\n", cur_ck));
+						ck_arr[j] = NULL;
+						++n_melt;
+						sched_remove(cur_ck);
+					}
+				}
+				ck_arr[idx] = NULL;
+
+				/* check, if we found some candidates for melting */
+				if (n_melt == 1) {
+					DBG((cenv->dbg, LEVEL_1, "\tno candidate found\n"));
+					continue;
+				}
+
+				pset_remove_ptr(entry->copies, ref);
+				sched_remove(ref);
+
+				melt_arr = (ir_node **)obstack_finish(&obst);
+				/* melt all found copykeeps */
+				NEW_ARR_A(ir_node *, new_ck_in, n_melt);
+				for (j = 0; j < n_melt; ++j) {
+					new_ck_in[j] = get_irn_n(melt_arr[j], 1);
+
+					/* now, we can kill the melted keep, except the */
+					/* ref one, we still need some information      */
+					if (melt_arr[j] != ref)
+						kill_node(melt_arr[j], 0);
+				}
+
+#ifdef KEEP_ALIVE_COPYKEEP_HACK
+				new_ck = be_new_CopyKeep(entry->cls, cenv->birg->irg, get_nodes_block(ref), be_get_CopyKeep_op(ref), n_melt, new_ck_in, mode_ANY);
+				keep_alive(new_ck);
+#else
+				new_ck = be_new_CopyKeep(entry->cls, cenv->birg->irg, get_nodes_block(ref), be_get_CopyKeep_op(ref), n_melt, new_ck_in, get_irn_mode(ref));
+#endif /* KEEP_ALIVE_COPYKEEP_HACK */
 
+				/* set register class for all keeped inputs */
+				for (j = 1; j <= n_melt; ++j)
+					be_node_set_reg_class(new_ck, j, entry->cls);
+
+				pset_insert_ptr(entry->copies, new_ck);
+
+				/* find scheduling point */
+				if (get_irn_mode(ref_mode_T) == mode_T) {
+					/* walk along the Projs */
+					for (sched_pt = sched_next(ref_mode_T); is_Proj(sched_pt) || be_is_Keep(sched_pt) || be_is_CopyKeep(sched_pt); sched_pt = sched_next(sched_pt))
+						/* just walk along the schedule until a non-Proj/Keep/CopyKeep node is found*/ ;
+				}
+				else {
+					sched_pt = ref_mode_T;
+				}
+
+				sched_add_before(sched_pt, new_ck);
+				DBG((cenv->dbg, LEVEL_1, "created %+F, scheduled before %+F\n", new_ck, sched_pt));
+
+				/* finally: kill the reference copykeep */
+				kill_node(ref, 0);
+			}
+		}
+
+		obstack_free(&obst, NULL);
+	}
+}
 
 /**
  * Walks over all nodes to assure register constraints.
@@ -659,7 +792,72 @@ static void assure_constraints_walker(ir_node *irn, void *walk_env) {
  * @param birg  The birg structure containing the irg
  */
 void assure_constraints(be_irg_t *birg) {
-	irg_walk_blkwise_graph(birg->irg, NULL, assure_constraints_walker, birg);
+	constraint_env_t cenv;
+	op_copy_assoc_t  *entry;
+	ir_node          **nodes;
+	FIRM_DBG_REGISTER(firm_dbg_module_t *mod, "firm.be.lower.constr");
+
+	be_assure_dom_front(birg);
+
+	DEBUG_ONLY(cenv.dbg = mod;)
+	cenv.birg   = birg;
+	cenv.op_set = new_pset(cmp_op_copy_assoc, 16);
+	obstack_init(&cenv.obst);
+
+	irg_walk_blkwise_graph(birg->irg, NULL, assure_constraints_walker, &cenv);
+
+	/* melt copykeeps, pointing to projs of */
+	/* the same mode_T node and keeping the */
+	/* same operand                         */
+	melt_copykeeps(&cenv);
+
+	/* for all */
+	foreach_pset(cenv.op_set, entry) {
+		int     n;
+		ir_node *cp;
+
+		n     = pset_count(entry->copies);
+		nodes = alloca((n + 1) * sizeof(nodes[0]));
+
+		/* put the node in an array */
+		n          = 0;
+		nodes[n++] = entry->op;
+		DBG((mod, LEVEL_1, "introduce copies for %+F ", entry->op));
+
+		/* collect all copies */
+		foreach_pset(entry->copies, cp) {
+			nodes[n++] = cp;
+			DB((mod, LEVEL_1, ", %+F ", cp));
+		}
+
+		DB((mod, LEVEL_1, "\n"));
+
+		/* introduce the copies for the operand and it's copies */
+		be_ssa_constr(birg->dom_front, NULL, n, nodes);
+
+
+		/* Could be that not all CopyKeeps are really needed, */
+		/* so we transform unnecessary ones into Keeps.       */
+		foreach_pset(entry->copies, cp) {
+			if (be_is_CopyKeep(cp) && get_irn_n_edges(cp) < 1) {
+				ir_node *keep;
+				int     n = get_irn_arity(cp);
+
+				keep = be_new_Keep(arch_get_irn_reg_class(birg->main_env->arch_env, cp, -1),
+					birg->irg, get_nodes_block(cp), n, (ir_node **)&get_irn_in(cp)[1]);
+				sched_add_before(cp, keep);
+
+				/* Set all ins (including the block) of the CopyKeep BAD to keep the verifier happy. */
+				kill_node(cp, 1);
+				sched_remove(cp);
+			}
+		}
+
+		del_pset(entry->copies);
+	}
+
+	del_pset(cenv.op_set);
+	obstack_free(&cenv.obst, NULL);
 }
 
 
@@ -671,11 +869,8 @@ void assure_constraints(be_irg_t *birg) {
  * @param walk_env The walker environment
  */
 static void lower_nodes_after_ra_walker(ir_node *irn, void *walk_env) {
-	lower_env_t      *env      = walk_env;
-	const arch_env_t *arch_env = env->chord_env->birg->main_env->arch_env;
-
-	if (!is_Block(irn) && !is_Proj(irn)) {
-		if (is_Perm(arch_env, irn)) {
+	if (! is_Block(irn) && ! is_Proj(irn)) {
+		if (be_is_Perm(irn)) {
 			lower_perm_node(irn, walk_env);
 		}
 	}
@@ -683,110 +878,20 @@ static void lower_nodes_after_ra_walker(ir_node *irn, void *walk_env) {
 	return;
 }
 
-static void lower_print_perm_stat(lower_env_t *env) {
-	int j, total_len_chain, total_len_cycle, total_size_perm, total_size_real_perm;
-	unsigned i;
-
-	printf("=== IRG: %s ===\n", get_entity_name(get_irg_entity(env->chord_env->irg)));
-	for (i = 0; i < env->pstat_n; i++) {
-		if (env->pstat[i]->num_perms == 0)
-			continue;
-
-		printf("CLASS: %s\n", env->pstat[i]->cls->name);
-		printf("# total perms:      %d (size:num   -> 1:%d", env->pstat[i]->num_perms, env->pstat[i]->perm_size_ar[0]);
-
-		total_size_perm = env->pstat[i]->perm_size_ar[0];
-		for (j = 1; j < env->pstat[i]->cls->n_regs; j++) {
-			total_size_perm += (j + 1) * env->pstat[i]->perm_size_ar[j];
-			printf(", %d:%d", j + 1, env->pstat[i]->perm_size_ar[j]);
-		}
-		printf(")\n");
-		printf("avg perm size:      %.2f\n", env->pstat[i]->num_perms ? (float)total_size_perm / (float)env->pstat[i]->num_perms : 0);
-
-		printf("# real perms:       %d (size:num  -> 1:%d", env->pstat[i]->num_real_perms, env->pstat[i]->real_perm_size_ar[0]);
-
-		total_size_real_perm = env->pstat[i]->real_perm_size_ar[0];
-		for (j = 1; j < env->pstat[i]->cls->n_regs; j++) {
-			total_size_real_perm += (j + 1) * env->pstat[i]->real_perm_size_ar[j];
-			printf(", %d:%d", j + 1, env->pstat[i]->real_perm_size_ar[j]);
-		}
-		printf(")\n");
-		printf("avg real perm size: %.2f\n", env->pstat[i]->num_real_perms ? (float)total_size_real_perm / (float)env->pstat[i]->num_real_perms : 0);
-
-		printf("# total chains:     %d (lenght:num -> 1:%d", env->pstat[i]->num_chains, env->pstat[i]->chain_len_ar[0]);
-
-		total_len_chain = env->pstat[i]->chain_len_ar[0];
-
-		for (j = 1; j < env->pstat[i]->cls->n_regs; j++) {
-			total_len_chain += (j + 1) * env->pstat[i]->chain_len_ar[j];
-			printf(", %d:%d", j + 1, env->pstat[i]->chain_len_ar[j]);
-		}
-		printf(")\n");
-		printf("avg chain length:   %.2f\n", env->pstat[i]->num_chains ? (float)total_len_chain / (float)env->pstat[i]->num_chains : 0);
-		printf("avg chains/perm:    %.2f\n", env->pstat[i]->num_real_perms ? (float)env->pstat[i]->num_chains / (float)env->pstat[i]->num_real_perms : 0);
-
-		printf("# total cycles:     %d (length:num -> 1:%d", env->pstat[i]->num_cycles, env->pstat[i]->cycle_len_ar[0]);
-
-		total_len_cycle = env->pstat[i]->cycle_len_ar[0];
-		for (j = 1; j < env->pstat[i]->cls->n_regs; j++) {
-			total_len_cycle += (j + 1) * env->pstat[i]->cycle_len_ar[j];
-			printf(", %d:%d", j + 1, env->pstat[i]->cycle_len_ar[j]);
-		}
-		printf(")\n");
-		printf("avg cycle length:   %.2f\n", env->pstat[i]->num_cycles ? (float)total_len_cycle / (float)env->pstat[i]->num_cycles : 0);
-		printf("avg cycles/perm:    %.2f\n", env->pstat[i]->num_real_perms ? (float)env->pstat[i]->num_cycles / (float)env->pstat[i]->num_real_perms : 0);
-	}
-}
-
 /**
  * Walks over all blocks in an irg and performs lowering need to be
  * done after register allocation (e.g. perm lowering).
  *
- * @param chord_env The chordal environment containing the irg
+ * @param birg      The birg object
  * @param do_copy   1 == resolve cycles with a free reg if available
  */
-void lower_nodes_after_ra(be_chordal_env_t *chord_env, int do_copy, int do_stat) {
+void lower_nodes_after_ra(be_irg_t *birg, int do_copy) {
 	lower_env_t env;
 
-	env.chord_env  = chord_env;
-	env.do_copy    = do_copy;
-	env.do_stat    = do_stat;
+	env.birg     = birg;
+	env.arch_env = birg->main_env->arch_env;
+	env.do_copy  = do_copy;
 	FIRM_DBG_REGISTER(env.dbg_module, "firm.be.lower");
 
-	/* if we want statistics: allocate memory for the data and initialize with 0 */
-	if (do_stat) {
-		const arch_isa_t *isa = chord_env->birg->main_env->arch_env->isa;
-		int i, n = arch_isa_get_n_reg_class(isa);
-
-		env.pstat   = alloca(n * sizeof(env.pstat[0]));
-		env.pstat_n = n;
-
-		for (i = 0; i < n; i++) {
-			const arch_register_class_t *cls = arch_isa_get_reg_class(isa, i);
-			int                       n_regs = cls->n_regs;
-
-			env.pstat[i] = alloca(sizeof(*(env.pstat[0])));
-			memset(env.pstat[i], 0, sizeof(*(env.pstat[0])));
-
-			env.pstat[i]->perm_size_ar      = alloca(n_regs * sizeof(env.pstat[i]->perm_size_ar[0]));
-			env.pstat[i]->real_perm_size_ar = alloca(n_regs * sizeof(env.pstat[i]->real_perm_size_ar[0]));
-			env.pstat[i]->chain_len_ar      = alloca(n_regs * sizeof(env.pstat[i]->chain_len_ar[0]));
-			env.pstat[i]->cycle_len_ar      = alloca(n_regs * sizeof(env.pstat[i]->cycle_len_ar[0]));
-
-			memset(env.pstat[i]->perm_size_ar, 0, n_regs * sizeof(env.pstat[i]->perm_size_ar[0]));
-			memset(env.pstat[i]->real_perm_size_ar, 0, n_regs * sizeof(env.pstat[i]->real_perm_size_ar[0]));
-			memset(env.pstat[i]->chain_len_ar, 0, n_regs * sizeof(env.pstat[i]->chain_len_ar[0]));
-			memset(env.pstat[i]->cycle_len_ar, 0, n_regs * sizeof(env.pstat[i]->cycle_len_ar[0]));
-
-			env.pstat[i]->cls = cls;
-		}
-	}
-
-	irg_walk_blkwise_graph(chord_env->irg, NULL, lower_nodes_after_ra_walker, &env);
-
-	if (do_stat) {
-		lower_print_perm_stat(&env);
-	}
+	irg_walk_blkwise_graph(birg->irg, NULL, lower_nodes_after_ra_walker, &env);
 }
-
-#undef is_Perm