X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyopt.c;h=930233ee35e3d2ddf03c2232941dbd5f70bdb98a;hb=fe36fbcb66909a979e16111b8dc8cee19088fede;hp=9ee05e6f91e50e6a688eb8c8ee8bd4e22c88195e;hpb=8cd2221a4b9f6636f627c3d6e9df131bf01d5abc;p=libfirm

diff --git a/ir/be/becopyopt.c b/ir/be/becopyopt.c
index 9ee05e6f9..930233ee3 100644
--- a/ir/be/becopyopt.c
+++ b/ir/be/becopyopt.c
@@ -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"
@@ -44,14 +42,13 @@
 #include "irprog.h"
 #include "irloop_t.h"
 #include "iredges_t.h"
-#include "phiclass.h"
 #include "irbitset.h"
 #include "irphase_t.h"
 #include "irprintf_t.h"
 
 #include "bemodule.h"
-#include "bearch_t.h"
-#include "benode_t.h"
+#include "bearch.h"
+#include "benode.h"
 #include "beutil.h"
 #include "beifg_t.h"
 #include "beintlive_t.h"
@@ -59,9 +56,9 @@
 #include "becopystat.h"
 #include "belive_t.h"
 #include "beinsn_t.h"
-#include "besched_t.h"
+#include "besched.h"
 #include "bestatevent.h"
-#include "beirg_t.h"
+#include "beirg.h"
 #include "error.h"
 
 #include "lc_opts.h"
@@ -80,7 +77,6 @@ static unsigned   dump_flags  = 0;
 static unsigned   style_flags = 0;
 static unsigned   do_stats    = 0;
 static cost_fct_t cost_func   = co_get_costs_exec_freq;
-static unsigned   algo        = CO_ALGO_HEUR4;
 static int        improve     = 1;
 
 static const lc_opt_enum_mask_items_t dump_items[] = {
@@ -100,16 +96,6 @@ static const lc_opt_enum_mask_items_t style_items[] = {
 	{ NULL,      0 }
 };
 
-static const lc_opt_enum_mask_items_t algo_items[] = {
-	{ "none",   CO_ALGO_NONE  },
-	{ "heur",   CO_ALGO_HEUR  },
-	{ "heur2",  CO_ALGO_HEUR2 },
-	{ "heur3",  CO_ALGO_HEUR3 },
-	{ "heur4",  CO_ALGO_HEUR4 },
-	{ "ilp",    CO_ALGO_ILP   },
-	{ NULL,     0 }
-};
-
 typedef int (*opt_funcptr)(void);
 
 static const lc_opt_enum_func_ptr_items_t cost_func_items[] = {
@@ -127,30 +113,30 @@ static lc_opt_enum_mask_var_t style_var = {
 	&style_flags, style_items
 };
 
-static lc_opt_enum_mask_var_t algo_var = {
-	&algo, algo_items
-};
-
 static lc_opt_enum_func_ptr_var_t cost_func_var = {
 	(opt_funcptr*) &cost_func, cost_func_items
 };
 
 static const lc_opt_table_entry_t options[] = {
-	LC_OPT_ENT_ENUM_INT      ("algo",    "select copy optimization algo",                           &algo_var),
 	LC_OPT_ENT_ENUM_FUNC_PTR ("cost",    "select a cost function",                                  &cost_func_var),
 	LC_OPT_ENT_ENUM_MASK     ("dump",    "dump ifg before or after copy optimization",              &dump_var),
 	LC_OPT_ENT_ENUM_MASK     ("style",   "dump style for ifg dumping",                              &style_var),
 	LC_OPT_ENT_BOOL          ("stats",   "dump statistics after each optimization",                 &do_stats),
-	LC_OPT_ENT_BOOL          ("improve", "run heur3 before if algo can exploit start solutions",    &improve),
+	LC_OPT_ENT_BOOL          ("improve", "run heur1 before if algo can exploit start solutions",    &improve),
 	LC_OPT_LAST
 };
 
-/* Insert additional options registration functions here. */
-extern void be_co_ilp_register_options(lc_opt_entry_t *grp);
-extern void be_co2_register_options(lc_opt_entry_t *grp);
-extern void be_co3_register_options(lc_opt_entry_t *grp);
+static be_module_list_entry_t *copyopts = NULL;
+static const co_algo_info *selected_copyopt = NULL;
 
-void be_init_copycoal(void)
+void be_register_copyopt(const char *name, co_algo_info *copyopt)
+{
+	if (selected_copyopt == NULL)
+		selected_copyopt = copyopt;
+	be_add_module_to_list(&copyopts, name, copyopt);
+}
+
+void be_init_copyopt(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");
@@ -158,9 +144,28 @@ void be_init_copycoal(void)
 	lc_opt_entry_t *co_grp = lc_opt_get_grp(chordal_grp, "co");
 
 	lc_opt_add_table(co_grp, options);
+	be_add_module_list_opt(co_grp, "algo", "select copy optimization algo",
+		                       &copyopts, (void**) &selected_copyopt);
+}
+
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyopt);
+
+static int void_algo(copy_opt_t *co)
+{
+	(void) co;
+	return 0;
+}
+
+void be_init_copynone(void)
+{
+	static co_algo_info copyheur = {
+		void_algo, 0
+	};
+
+	be_register_copyopt("none", &copyheur);
 }
 
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copycoal);
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copynone);
 
 #undef QUICK_AND_DIRTY_HACK
 
@@ -169,7 +174,7 @@ static int nodes_interfere(const be_chordal_env_t *env, const ir_node *a, const
 	if (env->ifg)
 		return be_ifg_connected(env->ifg, a, b);
 	else
-		return values_interfere(env->birg, a, b);
+		return be_values_interfere(env->birg->lv, a, b);
 }
 
 
@@ -200,7 +205,7 @@ copy_opt_t *new_copy_opt(be_chordal_env_t *chordal_env, cost_fct_t get_costs)
 	co->cls       = chordal_env->cls;
 	co->get_costs = get_costs;
 
-	s1 = get_irp_prog_name();
+	s1 = get_irp_name();
 	s2 = get_entity_name(get_irg_entity(co->irg));
 	s3 = chordal_env->cls->name;
 	len = strlen(s1) + strlen(s2) + strlen(s3) + 5;
@@ -210,31 +215,40 @@ copy_opt_t *new_copy_opt(be_chordal_env_t *chordal_env, cost_fct_t get_costs)
 	return co;
 }
 
-void free_copy_opt(copy_opt_t *co) {
+void free_copy_opt(copy_opt_t *co)
+{
 	xfree(co->name);
 	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;
-	(void)co; // TODO remove parameter
+	const arch_register_t     *reg;
 
-	if (arch_irn_is(irn, ignore))
+	if (arch_irn_is_ignore(irn))
 		return 0;
 
 	reg = arch_get_irn_register(irn);
 	if (arch_register_type_is(reg, ignore))
 		return 0;
 
-	req = arch_get_register_req(irn, -1);
-	if (is_Reg_Phi(irn) || is_Perm_Proj(irn) || is_2addr_code(req))
+	if (is_Reg_Phi(irn) || is_Perm_Proj(irn))
+		return 1;
+
+	req = arch_get_register_req_out(irn);
+	if (is_2addr_code(req))
 		return 1;
 
 	return 0;
 }
 
-int co_get_costs_loop_depth(const copy_opt_t *co, ir_node *root, ir_node* arg, int pos) {
+int co_get_costs_loop_depth(const copy_opt_t *co, ir_node *root, ir_node* arg, int pos)
+{
 	int cost = 0;
 	ir_loop *loop;
 	ir_node *root_block = get_nodes_block(root);
@@ -255,7 +269,8 @@ int co_get_costs_loop_depth(const copy_opt_t *co, ir_node *root, ir_node* arg, i
 	return 1+cost;
 }
 
-int co_get_costs_exec_freq(const copy_opt_t *co, ir_node *root, ir_node* arg, int pos) {
+int co_get_costs_exec_freq(const copy_opt_t *co, ir_node *root, ir_node* arg, int pos)
+{
 	int res;
 	ir_node *root_bl = get_nodes_block(root);
 	ir_node *copy_bl = is_Phi(root) ? get_Block_cfgpred_block(root_bl, pos) : root_bl;
@@ -267,7 +282,8 @@ int co_get_costs_exec_freq(const copy_opt_t *co, ir_node *root, ir_node* arg, in
 }
 
 
-int co_get_costs_all_one(const copy_opt_t *co, ir_node *root, ir_node *arg, int pos) {
+int co_get_costs_all_one(const copy_opt_t *co, ir_node *root, ir_node *arg, int pos)
+{
 	(void) co;
 	(void) root;
 	(void) arg;
@@ -290,7 +306,8 @@ int co_get_costs_all_one(const copy_opt_t *co, ir_node *root, ir_node *arg, int
  * Determines a maximum weighted independent set with respect to
  * the interference and conflict edges of all nodes in a qnode.
  */
-static int ou_max_ind_set_costs(unit_t *ou) {
+static int ou_max_ind_set_costs(unit_t *ou)
+{
 	be_chordal_env_t *chordal_env = ou->co->cenv;
 	ir_node **safe, **unsafe;
 	int i, o, safe_count, safe_costs, unsafe_count, *unsafe_costs;
@@ -302,15 +319,15 @@ static int ou_max_ind_set_costs(unit_t *ou) {
 	 * safe: node has no interference, hence it is in every max stable set.
 	 * unsafe: node has an interference
 	 */
-	safe = alloca((ou->node_count-1) * sizeof(*safe));
-	safe_costs = 0;
-	safe_count = 0;
-	unsafe = alloca((ou->node_count-1) * sizeof(*unsafe));
-	unsafe_costs = alloca((ou->node_count-1) * sizeof(*unsafe_costs));
+	safe         = ALLOCAN(ir_node*, ou->node_count - 1);
+	safe_costs   = 0;
+	safe_count   = 0;
+	unsafe       = ALLOCAN(ir_node*, ou->node_count - 1);
+	unsafe_costs = ALLOCAN(int,      ou->node_count - 1);
 	unsafe_count = 0;
-	for(i=1; i<ou->node_count; ++i) {
+	for (i=1; i<ou->node_count; ++i) {
 		int is_safe = 1;
-		for(o=1; o<ou->node_count; ++o) {
+		for (o=1; o<ou->node_count; ++o) {
 			if (i==o)
 				continue;
 			if (nodes_interfere(chordal_env, ou->nodes[i], ou->nodes[o])) {
@@ -374,13 +391,15 @@ static int ou_max_ind_set_costs(unit_t *ou) {
 	return safe_costs+best_weight;
 }
 
-static void co_collect_units(ir_node *irn, void *env) {
-	copy_opt_t *co = env;
+static void co_collect_units(ir_node *irn, void *env)
+{
+	const arch_register_req_t *req = arch_get_register_req_out(irn);
+	copy_opt_t                *co  = env;
 	unit_t *unit;
 
-	if (!is_curr_reg_class(co, irn))
+	if (req->cls != co->cls)
 		return;
-	if (!co_is_optimizable_root(co, irn))
+	if (!co_is_optimizable_root(irn))
 		return;
 
 	/* Init a new unit */
@@ -404,7 +423,7 @@ static void co_collect_units(ir_node *irn, void *env) {
 			int o, arg_pos;
 			ir_node *arg = get_irn_n(irn, i);
 
-			assert(is_curr_reg_class(co, arg) && "Argument not in same register class.");
+			assert(arch_get_irn_reg_class_out(arg) == co->cls && "Argument not in same register class.");
 			if (arg == irn)
 				continue;
 			if (nodes_interfere(co->cenv, irn, arg)) {
@@ -415,26 +434,27 @@ 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(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) {
-					if (unit->nodes[o] == arg) {
-						arg_pos = o;
-						break;
-					}
-				}
+			if (arch_irn_is_ignore(arg))
+				continue;
 
-				if (!arg_pos) { /* a new argument */
-					/* insert node, set costs */
-					unit->nodes[unit->node_count] = arg;
-					unit->costs[unit->node_count] = co->get_costs(co, irn, arg, i);
-					unit->node_count++;
-				} else { /* arg has occurred before in same phi */
-					/* increase costs for existing arg */
-					unit->costs[arg_pos] += co->get_costs(co, irn, arg, i);
+			/* Check if arg has occurred at a prior position in the arg/list */
+			arg_pos = 0;
+			for (o=1; o<unit->node_count; ++o) {
+				if (unit->nodes[o] == arg) {
+					arg_pos = o;
+					break;
 				}
 			}
+
+			if (!arg_pos) { /* a new argument */
+				/* insert node, set costs */
+				unit->nodes[unit->node_count] = arg;
+				unit->costs[unit->node_count] = co->get_costs(co, irn, arg, i);
+				unit->node_count++;
+			} 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, ir_node*, unit->node_count);
 		unit->costs = XREALLOC(unit->costs, int,      unit->node_count);
@@ -448,8 +468,6 @@ static void co_collect_units(ir_node *irn, void *env) {
 		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(irn, -1);
-
 		/* Src == Tgt of a 2-addr-code instruction */
 		if (is_2addr_code(req)) {
 			const unsigned other = req->other_same;
@@ -459,10 +477,11 @@ static void co_collect_units(ir_node *irn, void *env) {
 			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 (arch_irn_is_ignore(o))
+						continue;
+					if (nodes_interfere(co->cenv, irn, o))
+						continue;
+					++count;
 				}
 			}
 
@@ -477,7 +496,7 @@ static void co_collect_units(ir_node *irn, void *env) {
 				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) &&
+						if (!arch_irn_is_ignore(o) &&
 								!nodes_interfere(co->cenv, irn, o)) {
 							unit->nodes[k] = o;
 							unit->costs[k] = co->get_costs(co, irn, o, -1);
@@ -497,7 +516,7 @@ static void co_collect_units(ir_node *irn, void *env) {
 		struct list_head *tmp;
 
 		/* Determine the maximum costs this unit can cause: all_nodes_cost */
-		for(i=1; i<unit->node_count; ++i) {
+		for (i=1; i<unit->node_count; ++i) {
 			unit->sort_key = MAX(unit->sort_key, unit->costs[i]);
 			unit->all_nodes_costs += unit->costs[i];
 		}
@@ -516,7 +535,8 @@ static void co_collect_units(ir_node *irn, void *env) {
 
 #ifdef QUICK_AND_DIRTY_HACK
 
-static int compare_ous(const void *k1, const void *k2) {
+static int compare_ous(const void *k1, const void *k2)
+{
 	const unit_t *u1 = *((const unit_t **) k1);
 	const unit_t *u2 = *((const unit_t **) k2);
 	int i, o, u1_has_constr, u2_has_constr;
@@ -525,7 +545,7 @@ static int compare_ous(const void *k1, const void *k2) {
 	/* Units with constraints come first */
 	u1_has_constr = 0;
 	for (i=0; i<u1->node_count; ++i) {
-		arch_get_register_req(&req, u1->nodes[i], -1);
+		arch_get_register_req_out(&req, u1->nodes[i]);
 		if (arch_register_req_is(&req, limited)) {
 			u1_has_constr = 1;
 			break;
@@ -534,7 +554,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(&req, u2->nodes[i], -1);
+		arch_get_register_req_out(&req, u2->nodes[i]);
 		if (arch_register_req_is(&req, limited)) {
 			u2_has_constr = 1;
 			break;
@@ -560,14 +580,15 @@ static int compare_ous(const void *k1, const void *k2) {
 /**
  * Sort the ou's according to constraints and their sort_key
  */
-static void co_sort_units(copy_opt_t *co) {
+static void co_sort_units(copy_opt_t *co)
+{
 	int i, count = 0, costs;
 	unit_t *ou, **ous;
 
 	/* get the number of ous, remove them form the list and fill the array */
 	list_for_each_entry(unit_t, ou, &co->units, units)
 		count++;
-	ous = alloca(count * sizeof(*ous));
+	ous = ALLOCAN(unit_t, count);
 
 	costs = co_get_max_copy_costs(co);
 
@@ -596,7 +617,8 @@ static void co_sort_units(copy_opt_t *co) {
 }
 #endif
 
-void co_build_ou_structure(copy_opt_t *co) {
+void co_build_ou_structure(copy_opt_t *co)
+{
 	DBG((dbg, LEVEL_1, "\tCollecting optimization units\n"));
 	INIT_LIST_HEAD(&co->units);
 	irg_walk_graph(co->irg, co_collect_units, NULL, co);
@@ -605,7 +627,8 @@ void co_build_ou_structure(copy_opt_t *co) {
 #endif
 }
 
-void co_free_ou_structure(copy_opt_t *co) {
+void co_free_ou_structure(copy_opt_t *co)
+{
 	unit_t *curr, *tmp;
 	ASSERT_OU_AVAIL(co);
 	list_for_each_entry_safe(unit_t, curr, tmp, &co->units, units) {
@@ -618,7 +641,8 @@ void co_free_ou_structure(copy_opt_t *co) {
 
 /* co_solve_heuristic() is implemented in becopyheur.c */
 
-int co_get_max_copy_costs(const copy_opt_t *co) {
+int co_get_max_copy_costs(const copy_opt_t *co)
+{
 	int i, res = 0;
 	unit_t *curr;
 
@@ -632,7 +656,8 @@ int co_get_max_copy_costs(const copy_opt_t *co) {
 	return res;
 }
 
-int co_get_inevit_copy_costs(const copy_opt_t *co) {
+int co_get_inevit_copy_costs(const copy_opt_t *co)
+{
 	int res = 0;
 	unit_t *curr;
 
@@ -643,7 +668,8 @@ int co_get_inevit_copy_costs(const copy_opt_t *co) {
 	return res;
 }
 
-int co_get_copy_costs(const copy_opt_t *co) {
+int co_get_copy_costs(const copy_opt_t *co)
+{
 	int i, res = 0;
 	unit_t *curr;
 
@@ -664,7 +690,8 @@ int co_get_copy_costs(const copy_opt_t *co) {
 	return res;
 }
 
-int co_get_lower_bound(const copy_opt_t *co) {
+int co_get_lower_bound(const copy_opt_t *co)
+{
 	int res = 0;
 	unit_t *curr;
 
@@ -688,7 +715,7 @@ void co_complete_stats(const copy_opt_t *co, co_complete_stats_t *stat)
 		stat->aff_nodes += 1;
 		bitset_add_irn(seen, an->irn);
 		co_gs_foreach_neighb(an, neigh) {
-			if(!bitset_contains_irn(seen, neigh->irn)) {
+			if (!bitset_contains_irn(seen, neigh->irn)) {
 				stat->aff_edges += 1;
 				stat->max_costs += neigh->costs;
 
@@ -697,7 +724,7 @@ void co_complete_stats(const copy_opt_t *co, co_complete_stats_t *stat)
 					stat->unsatisfied_edges += 1;
 				}
 
-				if(nodes_interfere(co->cenv, an->irn, neigh->irn)) {
+				if (nodes_interfere(co->cenv, an->irn, neigh->irn)) {
 					stat->aff_int += 1;
 					stat->inevit_costs += neigh->costs;
 				}
@@ -720,7 +747,8 @@ void co_complete_stats(const copy_opt_t *co, co_complete_stats_t *stat)
                   |_|                                      |___/
  ******************************************************************************/
 
-static int compare_affinity_node_t(const void *k1, const void *k2, size_t size) {
+static int compare_affinity_node_t(const void *k1, const void *k2, size_t size)
+{
 	const affinity_node_t *n1 = k1;
 	const affinity_node_t *n2 = k2;
 	(void) size;
@@ -728,7 +756,8 @@ static int compare_affinity_node_t(const void *k1, const void *k2, size_t size)
 	return (n1->irn != n2->irn);
 }
 
-static void add_edge(copy_opt_t *co, ir_node *n1, ir_node *n2, int costs) {
+static void add_edge(copy_opt_t *co, ir_node *n1, ir_node *n2, int costs)
+{
 	affinity_node_t new_node, *node;
 	neighb_t        *nbr;
 	int             allocnew = 1;
@@ -746,7 +775,7 @@ static void add_edge(copy_opt_t *co, ir_node *n1, ir_node *n2, int costs) {
 
 	/* if we did not find n2 in n1's neighbourhood insert it */
 	if (allocnew) {
-		nbr        = obstack_alloc(&co->obst, sizeof(*nbr));
+		nbr        = OALLOC(&co->obst, neighb_t);
 		nbr->irn   = n2;
 		nbr->costs = 0;
 		nbr->next  = node->neighbours;
@@ -759,19 +788,22 @@ 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);
 	}
 }
 
-static void build_graph_walker(ir_node *irn, void *env) {
-	copy_opt_t *co = env;
+static void build_graph_walker(ir_node *irn, void *env)
+{
+	const arch_register_req_t *req = arch_get_register_req_out(irn);
+	copy_opt_t                *co  = env;
 	int pos, max;
 	const arch_register_t *reg;
 
-	if (!is_curr_reg_class(co, irn) || arch_irn_is(irn, ignore))
+	if (req->cls != co->cls || arch_irn_is_ignore(irn))
 		return;
 
 	reg = arch_get_irn_register(irn);
@@ -786,9 +818,7 @@ static void build_graph_walker(ir_node *irn, void *env) {
 	} 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));
-	}
-	else { /* 2-address code */
-		const arch_register_req_t *req = arch_get_register_req(irn, -1);
+	} else { /* 2-address code */
 		if (is_2addr_code(req)) {
 			const unsigned other = req->other_same;
 			int i;
@@ -796,7 +826,7 @@ static void build_graph_walker(ir_node *irn, void *env) {
 			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))
+					if (!arch_irn_is_ignore(other))
 						add_edges(co, irn, other, co->get_costs(co, irn, other, 0));
 				}
 			}
@@ -804,14 +834,16 @@ static void build_graph_walker(ir_node *irn, void *env) {
 	}
 }
 
-void co_build_graph_structure(copy_opt_t *co) {
+void co_build_graph_structure(copy_opt_t *co)
+{
 	obstack_init(&co->obst);
 	co->nodes = new_set(compare_affinity_node_t, 32);
 
 	irg_walk_graph(co->irg, build_graph_walker, NULL, co);
 }
 
-void co_free_graph_structure(copy_opt_t *co) {
+void co_free_graph_structure(copy_opt_t *co)
+{
 	ASSERT_GS_AVAIL(co);
 
 	del_set(co->nodes);
@@ -821,7 +853,8 @@ void co_free_graph_structure(copy_opt_t *co) {
 
 /* co_solve_ilp1() co_solve_ilp2() are implemented in becopyilpX.c */
 
-int co_gs_is_optimizable(copy_opt_t *co, ir_node *irn) {
+int co_gs_is_optimizable(copy_opt_t *co, ir_node *irn)
+{
 	affinity_node_t new_node, *n;
 
 	ASSERT_GS_AVAIL(co);
@@ -838,15 +871,14 @@ static int co_dump_appel_disjoint_constraints(const copy_opt_t *co, ir_node *a,
 {
 	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))
+		const arch_register_req_t *req = arch_get_register_req_out(nodes[j]);
+		if (arch_register_req_is(req, limited))
 			rbitset_copy_to_bitset(req->limited, constr[j]);
 		else
 			bitset_set_all(constr[j]);
@@ -858,9 +890,9 @@ static int co_dump_appel_disjoint_constraints(const copy_opt_t *co, ir_node *a,
 
 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);
+	be_ifg_t *ifg       = co->cenv->ifg;
+	int      *color_map = ALLOCAN(int, co->cls->n_regs);
+	int      *node_map  = XMALLOCN(int, get_irg_last_idx(co->irg) + 1);
 
 	ir_node *irn;
 	void *it, *nit;
@@ -868,7 +900,7 @@ void co_dump_appel_graph(const copy_opt_t *co, FILE *f)
 	unsigned i;
 
 	n_regs = 0;
-	for(i = 0; i < co->cls->n_regs; ++i) {
+	for (i = 0; i < co->cls->n_regs; ++i) {
 		const arch_register_t *reg = &co->cls->regs[i];
 		color_map[i] = arch_register_type_is(reg, ignore) ? -1 : n_regs++;
 	}
@@ -883,44 +915,43 @@ 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(irn, ignore))
-			node_map[get_irn_idx(irn)] = n++;
+		if (arch_irn_is_ignore(irn))
+			continue;
+		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(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(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)
+		if (!arch_irn_is_ignore(irn)) {
+			int idx                        = node_map[get_irn_idx(irn)];
+			affinity_node_t           *a   = get_affinity_info(co, irn);
+			const arch_register_req_t *req = arch_get_register_req_out(irn);
+			ir_node                   *adj;
+
+			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)
 						fprintf(f, "%d %d -1\n", color_map[i], idx);
 				}
 			}
 
 			be_ifg_foreach_neighbour(ifg, nit, irn, adj) {
-				if (!arch_irn_is(adj, ignore) &&
+				if (!arch_irn_is_ignore(adj) &&
 						!co_dump_appel_disjoint_constraints(co, irn, adj)) {
 					int adj_idx = node_map[get_irn_idx(adj)];
-					if(idx < adj_idx)
+					if (idx < adj_idx)
 						fprintf(f, "%d %d -1\n", idx, adj_idx);
 				}
 			}
 
-			if(a) {
+			if (a) {
 				neighb_t *n;
 
 				co_gs_foreach_neighb(a, n) {
-					if (!arch_irn_is(n->irn, ignore)) {
+					if (!arch_irn_is_ignore(n->irn)) {
 						int n_idx = node_map[get_irn_idx(n->irn)];
-						if(idx < n_idx)
+						if (idx < n_idx)
 							fprintf(f, "%d %d %d\n", idx, n_idx, (int) n->costs);
 					}
 				}
@@ -993,23 +1024,20 @@ static void ifg_dump_graph_attr(FILE *f, void *self)
 static int ifg_is_dump_node(void *self, ir_node *irn)
 {
 	(void)self;
-	return !arch_irn_is(irn, ignore);
+	return !arch_irn_is_ignore(irn);
 }
 
 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(irn);
-	const arch_register_req_t *req;
-	int limited;
-
-	req = arch_get_register_req(irn, BE_OUT_POS(0));
-	limited = arch_register_req_is(req, limited);
+	co_ifg_dump_t             *env     = self;
+	const arch_register_t     *reg     = arch_get_irn_register(irn);
+	const arch_register_req_t *req     = arch_get_register_req_out(irn);
+	int                        limited = arch_register_req_is(req, limited);
 
-	if(env->flags & CO_IFG_DUMP_LABELS) {
+	if (env->flags & CO_IFG_DUMP_LABELS) {
 		ir_fprintf(f, "label=\"%+F", irn);
 
-		if((env->flags & CO_IFG_DUMP_CONSTR) && limited) {
+		if ((env->flags & CO_IFG_DUMP_CONSTR) && limited) {
 			bitset_t *bs = bitset_alloca(env->co->cls->n_regs);
 			rbitset_copy_to_bitset(req->limited, bs);
 			ir_fprintf(f, "\\n%B", bs);
@@ -1019,10 +1047,10 @@ static void ifg_dump_node_attr(FILE *f, void *self, ir_node *irn)
 		fprintf(f, "label=\"\" shape=point " );
 	}
 
-	if(env->flags & CO_IFG_DUMP_SHAPE)
+	if (env->flags & CO_IFG_DUMP_SHAPE)
 		fprintf(f, "shape=%s ", limited ? "diamond" : "ellipse");
 
-	if(env->flags & CO_IFG_DUMP_COLORS)
+	if (env->flags & CO_IFG_DUMP_COLORS)
 		fprintf(f, "style=filled color=%s ", get_dot_color_name(reg->index));
 }
 
@@ -1040,12 +1068,12 @@ static void ifg_dump_at_end(FILE *file, void *self)
 			const arch_register_t *nr = arch_get_irn_register(n->irn);
 			unsigned nidx = get_irn_idx(n->irn);
 
-			if(aidx < nidx) {
+			if (aidx < nidx) {
 				const char *color = nr == ar ? "blue" : "red";
 				fprintf(file, "\tn%d -- n%d [weight=0.01 ", aidx, nidx);
-				if(env->flags & CO_IFG_DUMP_LABELS)
+				if (env->flags & CO_IFG_DUMP_LABELS)
 					fprintf(file, "label=\"%d\" ", n->costs);
-				if(env->flags & CO_IFG_DUMP_COLORS)
+				if (env->flags & CO_IFG_DUMP_COLORS)
 					fprintf(file, "color=%s ", color);
 				else
 					fprintf(file, "style=dotted");
@@ -1082,45 +1110,6 @@ void co_solve_park_moon(copy_opt_t *opt)
 	(void) opt;
 }
 
-static int void_algo(copy_opt_t *co)
-{
-	(void) co;
-	return 0;
-}
-
-/*
-		_    _                  _ _   _
-	   / \  | | __ _  ___  _ __(_) |_| |__  _ __ ___  ___
-	  / _ \ | |/ _` |/ _ \| '__| | __| '_ \| '_ ` _ \/ __|
-	 / ___ \| | (_| | (_) | |  | | |_| | | | | | | | \__ \
-	/_/   \_\_|\__, |\___/|_|  |_|\__|_| |_|_| |_| |_|___/
-			   |___/
-*/
-
-typedef struct {
-	co_algo_t  *algo;
-	const char *name;
-	int        can_improve_existing;
-} co_algo_info_t;
-
-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 }
-};
-
 /*
     __  __       _         ____       _
    |  \/  | __ _(_)_ __   |  _ \ _ __(_)_   _____ _ __
@@ -1148,7 +1137,7 @@ static FILE *my_open(const be_chordal_env_t *env, const char *prefix, const char
 	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) {
+	if (result == NULL) {
 		panic("Couldn't open '%s' for writing.", buf);
 	}
 
@@ -1157,13 +1146,15 @@ static FILE *my_open(const be_chordal_env_t *env, const char *prefix, const char
 
 void co_driver(be_chordal_env_t *cenv)
 {
-	ir_timer_t          *timer = ir_timer_register("firm.be.copyopt", "runtime");
+	ir_timer_t          *timer = ir_timer_new();
 	co_complete_stats_t before, after;
 	copy_opt_t          *co;
-	co_algo_t           *algo_func;
 	int                 was_optimal = 0;
 
-	if (algo >= CO_ALGO_LAST)
+	assert(selected_copyopt);
+
+	/* skip copymin if algo is 'none' */
+	if (selected_copyopt->copyopt == void_algo)
 		return;
 
 	be_liveness_assure_chk(be_get_birg_liveness(cenv->birg));
@@ -1189,37 +1180,26 @@ void co_driver(be_chordal_env_t *cenv)
 		fclose(f);
 	}
 
-	/* if the algo can improve results, provide an initial solution with heur3 */
-	if (improve && algos[algo].can_improve_existing) {
+	/* if the algo can improve results, provide an initial solution with heur1 */
+	if (improve && selected_copyopt->can_improve_existing) {
 		co_complete_stats_t stats;
 
 		/* produce a heuristic solution */
-#ifdef WITH_JVM
-		co_solve_heuristic_java(co);
-#else
 		co_solve_heuristic(co);
-#endif /* WITH_JVM */
 
 		/* do the stats and provide the current costs */
 		co_complete_stats(co, &stats);
 		be_stat_ev_ull("co_prepare_costs", stats.costs);
 	}
 
-#ifdef WITH_JVM
-	/* start the JVM here so that it does not tamper the timing. */
-	if (algo == CO_ALGO_HEUR3)
-		be_java_coal_start_jvm();
-#endif /* WITH_JVM */
-
-	algo_func = algos[algo].algo;
-
 	/* perform actual copy minimization */
 	ir_timer_reset_and_start(timer);
-	was_optimal = algo_func(co);
+	was_optimal = selected_copyopt->copyopt(co);
 	ir_timer_stop(timer);
 
 	be_stat_ev("co_time", ir_timer_elapsed_msec(timer));
 	be_stat_ev_ull("co_optimal", was_optimal);
+	ir_timer_free(timer);
 
 	if (dump_flags & DUMP_AFTER) {
 		FILE *f = my_open(cenv, "", "-after.dot");
@@ -1236,7 +1216,7 @@ void co_driver(be_chordal_env_t *cenv)
 		ir_printf("%30F ", cenv->irg);
 		printf("%10s %10" ULL_FMT "%10" ULL_FMT "%10" ULL_FMT, cenv->cls->name, after.max_costs, before.costs, after.inevit_costs);
 
-		if(optimizable_costs > 0)
+		if (optimizable_costs > 0)
 			printf("%10" ULL_FMT " %5.2f\n", after.costs, (evitable * 100.0) / optimizable_costs);
 		else
 			printf("%10" ULL_FMT " %5s\n", after.costs, "-");