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);
-
/*
____ _ _
/ ___|| |_ __ _ _ __| |_
ifg_dump_at_end
};
-
int co_solve_heuristic_new(copy_opt_t *co)
{
char buf[256];
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", ©heur);
+}
+
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur2);
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[] = {
{ 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[] = {
&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_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(©opts, 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 *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",
+ ©opts, (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", ©heur);
}
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copycoal);
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copynone);
#undef QUICK_AND_DIRTY_HACK
(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 }
-};
-
/*
__ __ _ ____ _
| \/ | __ _(_)_ __ | _ \ _ __(_)_ _____ _ __
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));
}
/* 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 */
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));
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 *);
*/
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.
*/
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