Use module mechanism to register copy minimization algorithms.

[r26498]

diff --git a/ir/be/becopyheur.c b/ir/be/becopyheur.c
index ca7fc8b..5e8805f 100644 (file)
--- a/ir/be/becopyheur.c
+++ b/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);

diff --git a/ir/be/becopyheur2.c b/ir/be/becopyheur2.c
index 5b163cd..8764628 100644 (file)
--- a/ir/be/becopyheur2.c
+++ b/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);

diff --git a/ir/be/becopyheur4.c b/ir/be/becopyheur4.c
index 76a1930..7d05098 100644 (file)
--- a/ir/be/becopyheur4.c
+++ b/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);

diff --git a/ir/be/becopyilp2.c b/ir/be/becopyilp2.c
index 2dd2ae5..52a36f6 100644 (file)
--- a/ir/be/becopyilp2.c
+++ b/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;

diff --git a/ir/be/becopyopt.c b/ir/be/becopyopt.c
index b9b1aa2..ce7eed7 100644 (file)
--- a/ir/be/becopyopt.c
+++ b/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));

diff --git a/ir/be/becopyopt.h b/ir/be/becopyopt.h
index 6ef7863..ba94d50 100644 (file)
--- a/ir/be/becopyopt.h
+++ b/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

diff --git a/ir/be/becopypbqp.c b/ir/be/becopypbqp.c
index 0b633dd..609149a 100644 (file)
--- a/ir/be/becopypbqp.c
+++ b/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

diff --git a/ir/be/bemodule.c b/ir/be/bemodule.c
index 0861b7f..4a03568 100644 (file)
--- a/ir/be/bemodule.c
+++ b/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();