Use module mechanism to register copy minimization algorithms.

[r26498]

ir/be/becopyheur.c

@@ -43,6 +43,7 @@
 #include "becopystat.h"
 #include "beintlive_t.h"
 #include "beirg.h"
+#include "bemodule.h"
 
 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 
@@ -616,9 +617,12 @@ static void ou_optimize(unit_t *ou) {
 		free_qnode(curr);
 }
 
+/**
+ * Solves the problem using a heuristic approach
+ * Uses the OU data structure
+ */
 int co_solve_heuristic(copy_opt_t *co) {
 	unit_t *curr;
-	FIRM_DBG_REGISTER(dbg, "ir.be.copyoptheur");
 
 	ASSERT_OU_AVAIL(co);
 
@@ -630,3 +634,15 @@ int co_solve_heuristic(copy_opt_t *co) {
 	del_pset(pinned_global);
 	return 0;
 }
+
+void be_init_copyheur(void)
+{
+	static co_algo_info copyheur = {
+		co_solve_heuristic, 0
+	};
+
+	be_register_copyopt("heur1", &copyheur);
+	FIRM_DBG_REGISTER(dbg, "ir.be.copyoptheur");
+}
+
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur);

ir/be/becopyheur2.c

@@ -84,18 +84,6 @@ static const lc_opt_table_entry_t options[] = {
 	LC_OPT_LAST
 };
 
-void be_init_copyheur2(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 *co2_grp = lc_opt_get_grp(chordal_grp, "co2");
-
-	lc_opt_add_table(co2_grp, options);
-}
-
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur2);
-
 /*
   ____  _             _
  / ___|| |_ __ _ _ __| |_
@@ -1236,7 +1224,6 @@ static be_ifg_dump_dot_cb_t ifg_dot_cb = {
 	ifg_dump_at_end
 };
 
-
 int co_solve_heuristic_new(copy_opt_t *co)
 {
 	char  buf[256];
@@ -1277,3 +1264,21 @@ int co_solve_heuristic_new(copy_opt_t *co)
 	phase_free(&env.ph);
 	return 0;
 }
+
+void be_init_copyheur2(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 *co2_grp = lc_opt_get_grp(chordal_grp, "co2");
+
+	lc_opt_add_table(co2_grp, options);
+
+	static co_algo_info copyheur = {
+		co_solve_heuristic_new, 0
+	};
+
+	be_register_copyopt("heur2", &copyheur);
+}
+
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur2);

ir/be/becopyheur4.c

@@ -1381,7 +1381,7 @@ 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;
@@ -1482,8 +1482,14 @@ void be_init_copyheur4(void) {
 	lc_opt_entry_t *heur4_grp = lc_opt_get_grp(co_grp, "heur4");
 
 	lc_opt_add_table(heur4_grp, options);
+
+	static co_algo_info copyheur = {
+		co_solve_heuristic_mst, 0
+	};
+
+	be_register_copyopt("heur4", &copyheur);
+
 	FIRM_DBG_REGISTER(dbg, "firm.be.co.heur4");
 }
 
-
 BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur4);

ir/be/becopyilp2.c

@@ -57,6 +57,7 @@
 #include "becopyilp_t.h"
 #include "beifg_t.h"
 #include "besched.h"
+#include "bemodule.h"
 
 #define DEBUG_LVL 1
 
@@ -539,6 +540,17 @@ static void ilp2_apply(ilp_env_t *ienv) {
 #endif
 }
 
+void be_init_copyilp2(void)
+{
+	static co_algo_info copyheur = {
+		co_solve_ilp2, 1
+	};
+
+	be_register_copyopt("ilp", &copyheur);
+}
+
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyilp2);
+
 int co_solve_ilp2(copy_opt_t *co) {
 	lpp_sol_state_t sol_state;
 	ilp_env_t *ienv;

ir/be/becopyopt.c

@@ -77,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[] = {
@@ -97,18 +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 },
-	{ "heur4",  CO_ALGO_HEUR4 },
-	{ "ilp",    CO_ALGO_ILP   },
-#ifdef FIRM_KAPS
-	{ "pbqp",   CO_ALGO_PBQP  },
-#endif
-	{ NULL,     0 }
-};
-
 typedef int (*opt_funcptr)(void);
 
 static const lc_opt_enum_func_ptr_items_t cost_func_items[] = {
@@ -126,16 +113,11 @@ 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),
@@ -144,6 +126,16 @@ static const lc_opt_table_entry_t options[] = {
 	LC_OPT_LAST
 };
 
+static be_module_list_entry_t *copyopts = NULL;
+static const co_algo_info *selected_copyopt = NULL;
+
+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");
@@ -152,9 +144,28 @@ void be_init_copyopt(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
 
@@ -1079,43 +1090,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 const co_algo_info_t algos[] = {
-	{ void_algo,               "none",  0 },
-	{ co_solve_heuristic,      "heur1", 0 },
-	{ co_solve_heuristic_new,  "heur2", 0 },
-	{ co_solve_heuristic_mst,  "heur4", 0 },
-#ifdef WITH_ILP
-	{ co_solve_ilp2,           "ilp",   1 },
-#else
-	{ NULL,                    "ilp",   1 },
-#endif
-#ifdef FIRM_KAPS
-	{ co_solve_heuristic_pbqp, "pbqp",  0 },
-#endif
-	{ NULL,                    "",      0 }
-};
-
 /*
     __  __       _         ____       _
    |  \/  | __ _(_)_ __   |  _ \ _ __(_)_   _____ _ __
@@ -1155,11 +1129,9 @@ void co_driver(be_chordal_env_t *cenv)
 	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;
 	int                 was_optimal = 0;
 
-	if (algo >= CO_ALGO_LAST)
-		return;
+	assert(selected_copyopt);
 
 	be_liveness_assure_chk(be_get_birg_liveness(cenv->birg));
 
@@ -1185,7 +1157,7 @@ void co_driver(be_chordal_env_t *cenv)
 	}
 
 	/* if the algo can improve results, provide an initial solution with heur1 */
-	if (improve && algos[algo].can_improve_existing) {
+	if (improve && selected_copyopt->can_improve_existing) {
 		co_complete_stats_t stats;
 
 		/* produce a heuristic solution */
@@ -1196,11 +1168,9 @@ void co_driver(be_chordal_env_t *cenv)
 		be_stat_ev_ull("co_prepare_costs", stats.costs);
 	}
 
-	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));

ir/be/becopyopt.h

@@ -63,13 +63,28 @@ enum {
 	CO_ALGO_LAST
 };
 
-/** The driver for copy minimization. */
-void co_driver(be_chordal_env_t *cenv);
-
 typedef struct _copy_opt_t copy_opt_t;
 
 typedef int(*cost_fct_t)(const copy_opt_t *, ir_node *, ir_node *, int);
 
+typedef struct {
+	int (*copyopt)(copy_opt_t *co); /**< function ptr to run copyopt */
+	int        can_improve_existing;
+} co_algo_info;
+
+
+/**
+ * Register a new copy optimazation algorithm.
+ *
+ * @param name     the name of the copy optimazation algorithm,
+ *                 used to select it
+ * @param spiller  a copy optimazation entry
+ */
+void be_register_copyopt(const char *name, co_algo_info *copyopt);
+
+/** The driver for copy minimization. */
+void co_driver(be_chordal_env_t *cenv);
+
 /** A coalescing algorithm. */
 typedef int (co_algo_t)(copy_opt_t *);
 
@@ -157,11 +172,6 @@ void co_solve_park_moon(copy_opt_t *co);
  */
 int co_solve_heuristic_new(copy_opt_t *co);
 
-/**
- * This is the pure C implementation of co_solve_heuristic_java().
- */
-int co_solve_heuristic_mst(copy_opt_t *co);
-
 /**
  * Returns the maximal costs possible, i.e. the costs if all
  * pairs would be assigned different registers.
@@ -241,8 +251,6 @@ int co_solve_ilp1(copy_opt_t *co, double time_limit);
  */
 int co_solve_ilp2(copy_opt_t *co);
 
-int co_solve_heuristic_pbqp(copy_opt_t *co);
-
 /**
  * Checks if a node is optimizable, viz has something to do with coalescing.
  * Uses the GRAPH data structure

ir/be/becopypbqp.c

@@ -19,6 +19,7 @@
 #include "becopyopt_t.h"
 #include "beifg.h"
 #include "beifg_t.h"
+#include "bemodule.h"
 #include "irprintf_t.h"
 
 #include "error.h"
@@ -49,7 +50,7 @@ static FILE *my_open(const be_chordal_env_t *env, const char *prefix, const char
 	return result;
 }
 
-int co_solve_heuristic_pbqp(copy_opt_t *co) {
+static int co_solve_heuristic_pbqp(copy_opt_t *co) {
 	void *nodes_it  = be_ifg_nodes_iter_alloca(co->cenv->ifg);
 	void *neigh_it  = be_ifg_neighbours_iter_alloca(co->cenv->ifg);
 	ir_node *ifg_node, *if_neighb_node;
@@ -217,4 +218,15 @@ int co_solve_heuristic_pbqp(copy_opt_t *co) {
 	return 0;
 }
 
+void be_init_copypbqp(void)
+{
+	static co_algo_info copyheur = {
+		co_solve_heuristic_pbqp, 0
+	};
+
+	be_register_copyopt("pbqp", &copyheur);
+}
+
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copypbqp);
+
 #endif

ir/be/bemodule.c

@@ -40,9 +40,11 @@ void be_init_schedrss(void);
 void be_init_chordal(void);
 void be_init_chordal_main(void);
 void be_init_copyopt(void);
+void be_init_copyheur(void);
 void be_init_copyheur2(void);
 void be_init_copyheur4(void);
-void be_init_copyheur5(void);
+void be_init_copyilp2(void);
+void be_init_copypbqp(void);
 void be_init_copystat(void);
 void be_init_daemelspill(void);
 void be_init_dbgout(void);
@@ -99,9 +101,16 @@ void be_init_modules(void)
 	be_init_chordal_main();
 	be_init_chordal();
 	be_init_copyopt();
-	be_init_copyheur2();
 	be_init_copyheur4();
-//	be_init_copyheur5();
+	be_init_copyheur();
+	be_init_copyheur2();
+#ifdef WITH_ILP
+	be_init_copyilp2();
+#endif
+#ifdef FIRM_KAPS
+	be_init_copypbqp();
+#endif
+	be_init_copynone();
 	be_init_copystat();
 	be_init_peephole();
 	be_init_ra();