X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbechordal_main.c;h=3c1fac6641d1bccd028fa63f76b909e8a91284e2;hb=c1fdf770d4d000dd5cf22daead32369342c5f5d1;hp=1d514fdd448cad47835a9fb1c7a21a7fdec841a6;hpb=e069f88894312eeea9e7914da8cf945f1961e0b7;p=libfirm diff --git a/ir/be/bechordal_main.c b/ir/be/bechordal_main.c index 1d514fdd4..3c1fac664 100644 --- a/ir/be/bechordal_main.c +++ b/ir/be/bechordal_main.c @@ -1,16 +1,33 @@ -/** - * @file bechordal_main.c - * @date 29.11.2005 - * @author Sebastian Hack +/* + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. + * + * This file is part of libFirm. + * + * This file may be distributed and/or modified under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation and appearing in the file LICENSE.GPL included in the + * packaging of this file. * - * Copyright (C) 2005 Universitaet Karlsruhe - * Released under the GPL + * Licensees holding valid libFirm Professional Edition licenses may use + * this file in accordance with the libFirm Commercial License. + * Agreement provided with the Software. * - * Driver for the chordal register allocator. + * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE + * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE. + */ + +/** + * @file + * @brief Driver for the chordal register allocator. + * @author Sebastian Hack + * @date 29.11.2005 + * @version $Id$ */ -#ifdef HAVE_CONFIG_H #include "config.h" -#endif + +#include +#include #include "obst.h" #include "pset.h" @@ -18,305 +35,446 @@ #include "bitset.h" #include "iterator.h" -#ifdef WITH_LIBCORE -#include -#include -#endif /* WITH_LIBCORE */ +#include "lc_opts.h" +#include "lc_opts_enum.h" +#include "ircons_t.h" #include "irmode_t.h" #include "irgraph_t.h" #include "irprintf_t.h" #include "irgwalk.h" +#include "ircons.h" #include "irdump.h" #include "irdom.h" +#include "ircons.h" +#include "irbitset.h" +#include "irnode.h" +#include "ircons.h" #include "debug.h" -#include "xmalloc.h" +#include "execfreq.h" +#include "iredges_t.h" #include "bechordal_t.h" +#include "beabi.h" #include "beutil.h" #include "besched.h" -#include "benumb_t.h" #include "besched_t.h" #include "belive_t.h" -#include "bearch.h" +#include "bearch_t.h" #include "beifg_t.h" #include "beifg_impl.h" - -#include "bespillbelady.h" -#include "bespillilp.h" -#include "beconstrperm.h" +#include "benode_t.h" +#include "bestatevent.h" +#include "bestat.h" +#include "bemodule.h" +#include "be_t.h" +#include "bera.h" +#include "beirg_t.h" + +#include "bespillslots.h" +#include "bespilloptions.h" #include "belower.h" -#include "becopyoptmain.h" -#include "bessadestr.h" #include "becopystat.h" - - -void be_ra_chordal_check(be_chordal_env_t *chordal_env) { - firm_dbg_module_t *dbg = chordal_env->dbg; - const arch_env_t *arch_env = chordal_env->main_env->arch_env; - struct obstack ob; - pmap_entry *pme; - ir_node **nodes, *n1, *n2; - int i, o; - - /* Collect all irns */ - obstack_init(&ob); - pmap_foreach(chordal_env->border_heads, pme) { - border_t *curr; - struct list_head *head = pme->value; - list_for_each_entry(border_t, curr, head, list) - if (curr->is_def && curr->is_real) - if (arch_get_irn_reg_class(arch_env, curr->irn, -1) == chordal_env->cls) - obstack_ptr_grow(&ob, curr->irn); - } - obstack_ptr_grow(&ob, NULL); - nodes = (ir_node **) obstack_finish(&ob); - - /* Check them */ - for (i = 0, n1 = nodes[i]; n1; n1 = nodes[++i]) { - const arch_register_t *n1_reg, *n2_reg; - - n1_reg = arch_get_irn_register(arch_env, n1); - if (!arch_reg_is_allocatable(arch_env, n1, -1, n1_reg)) { - DBG((dbg, 0, "Register %s assigned to %+F is not allowed\n", n1_reg->name, n1)); - assert(0 && "Register constraint does not hold"); - } - for (o = i+1, n2 = nodes[o]; n2; n2 = nodes[++o]) { - n2_reg = arch_get_irn_register(arch_env, n2); - if (values_interfere(n1, n2) && n1_reg == n2_reg) { - DBG((dbg, 0, "Values %+F and %+F interfere and have the same register assigned\n", n1, n2)); - assert(0 && "Interfering values have the same color!"); - } - } - } - obstack_free(&ob, NULL); -} - -static void check_pressure_walker(ir_node *bl, void *data) -{ - be_chordal_env_t *env = data; - firm_dbg_module_t *dbg = env->dbg; - int n_regs = arch_register_class_n_regs(env->cls); - - pset *live = pset_new_ptr_default(); - int step = 0; - ir_node *irn; - irn_live_t *li; - - live_foreach(bl, li) { - if(live_is_end(li) && chordal_has_class(env, li->irn)) { - ir_node *irn = (ir_node *) li->irn; - pset_insert_ptr(live, irn); - } - } - - DBG((dbg, LEVEL_1, "end set for %+F\n", bl)); - for(irn = pset_first(live); irn; irn = pset_next(live)) - DBG((dbg, LEVEL_1, "\t%+F\n", irn)); - - sched_foreach_reverse(bl, irn) { - int i, n; - int pressure = pset_count(live); - - DBG((dbg, LEVEL_1, "%+10F@%+10F: pressure %d\n", bl, irn, pressure)); - - if(pressure > n_regs) { - ir_node *x; - ir_printf("%+10F@%+10F: pressure to high: %d\n", bl, irn, pressure); - for(x = pset_first(live); x; x = pset_next(live)) - ir_printf("\t%+10F\n", x); - } - - if(chordal_has_class(env, irn)) - pset_remove_ptr(live, irn); - - for(i = 0, n = get_irn_arity(irn); i < n; i++) { - ir_node *op = get_irn_n(irn, i); - if(chordal_has_class(env, op) && !is_Phi(irn)) - pset_insert_ptr(live, op); - } - step++; - } -} - -void be_check_pressure(const be_chordal_env_t *env) -{ - irg_block_walk_graph(env->irg, check_pressure_walker, NULL, (void *) env); -} - -int nodes_interfere(const be_chordal_env_t *env, const ir_node *a, const ir_node *b) -{ - if(env->ifg) - return be_ifg_connected(env->ifg, a, b); - else - return values_interfere(a, b); -} - +#include "becopyopt.h" +#include "bessadestr.h" +#include "beverify.h" +#include "benode_t.h" static be_ra_chordal_opts_t options = { - BE_CH_DUMP_ALL, - BE_CH_SPILL_BELADY, - BE_CH_COPYMIN_HEUR, - BE_CH_IFG_STD, - BE_CH_LOWER_PERM_SWAP + BE_CH_DUMP_NONE, + BE_CH_LOWER_PERM_SWAP, + BE_CH_VRFY_WARN, + "", + "" }; -#ifdef WITH_LIBCORE -static const lc_opt_enum_int_items_t spill_items[] = { - { "belady", BE_CH_SPILL_BELADY }, - { "ilp", BE_CH_SPILL_ILP }, +typedef struct _post_spill_env_t { + be_chordal_env_t cenv; + be_irg_t *birg; + const arch_register_class_t *cls; + double pre_spill_cost; +} post_spill_env_t; + +static const lc_opt_enum_int_items_t lower_perm_items[] = { + { "copy", BE_CH_LOWER_PERM_COPY }, + { "swap", BE_CH_LOWER_PERM_SWAP }, { NULL, 0 } }; -static const lc_opt_enum_int_items_t copymin_items[] = { - { "heur", BE_CH_COPYMIN_HEUR }, - { "ilp", BE_CH_COPYMIN_ILP }, +static const lc_opt_enum_int_items_t lower_perm_stat_items[] = { { NULL, 0 } }; -static const lc_opt_enum_int_items_t ifg_flavor_items[] = { - { "std", BE_CH_IFG_STD }, - { "fast", BE_CH_IFG_FAST }, +static const lc_opt_enum_int_items_t dump_items[] = { + { "none", BE_CH_DUMP_NONE }, + { "spill", BE_CH_DUMP_SPILL }, + { "live", BE_CH_DUMP_LIVE }, + { "color", BE_CH_DUMP_COLOR }, + { "copymin", BE_CH_DUMP_COPYMIN }, + { "ssadestr", BE_CH_DUMP_SSADESTR }, + { "tree", BE_CH_DUMP_TREE_INTV }, + { "constr", BE_CH_DUMP_CONSTR }, + { "lower", BE_CH_DUMP_LOWER }, + { "spillslots", BE_CH_DUMP_SPILLSLOTS }, + { "appel", BE_CH_DUMP_APPEL }, + { "all", BE_CH_DUMP_ALL }, { NULL, 0 } }; -static const lc_opt_enum_int_items_t lower_perm_items[] = { - { "swap", BE_CH_LOWER_PERM_SWAP }, - { "copy", BE_CH_LOWER_PERM_COPY }, +static const lc_opt_enum_int_items_t be_ch_vrfy_items[] = { + { "off", BE_CH_VRFY_OFF }, + { "warn", BE_CH_VRFY_WARN }, + { "assert", BE_CH_VRFY_ASSERT }, { NULL, 0 } }; -static lc_opt_enum_int_var_t spill_var = { - &options.spill_method, spill_items +static lc_opt_enum_int_var_t lower_perm_var = { + &options.lower_perm_opt, lower_perm_items }; -static lc_opt_enum_int_var_t copymin_var = { - &options.copymin_method, copymin_items +static lc_opt_enum_int_var_t dump_var = { + &options.dump_flags, dump_items }; -static lc_opt_enum_int_var_t ifg_flavor_var = { - &options.spill_method, ifg_flavor_items +static lc_opt_enum_int_var_t be_ch_vrfy_var = { + &options.vrfy_option, be_ch_vrfy_items }; -static lc_opt_enum_int_var_t lower_perm_var = { - &options.lower_perm_method, lower_perm_items +static const lc_opt_table_entry_t be_chordal_options[] = { + LC_OPT_ENT_ENUM_PTR ("perm", "perm lowering options", &lower_perm_var), + LC_OPT_ENT_ENUM_MASK("dump", "select dump phases", &dump_var), + LC_OPT_ENT_ENUM_PTR ("vrfy", "verify options", &be_ch_vrfy_var), + LC_OPT_LAST }; -static void be_ra_chordal_register_options(lc_opt_entry_t *grp) -{ - grp = lc_opt_get_grp(grp, "chordal"); -} -#endif - static void dump(unsigned mask, ir_graph *irg, const arch_register_class_t *cls, const char *suffix, void (*dump_func)(ir_graph *, const char *)) { - if(1 || (options.dump_flags & mask) == mask) { - if(cls) { + if((options.dump_flags & mask) == mask) { + if (cls) { char buf[256]; snprintf(buf, sizeof(buf), "-%s%s", cls->name, suffix); - dump_func(irg, buf); + be_dump(irg, buf, dump_func); } - else - dump_func(irg, suffix); + be_dump(irg, suffix, dump_func); } } -static void be_ra_chordal_main(const be_main_env_t *main_env, ir_graph *irg) +/** + * Checks for every reload if its user can perform the load on itself. + */ +static void memory_operand_walker(ir_node *irn, void *env) { - int j, m; - be_chordal_env_t chordal_env; - const arch_isa_t *isa = arch_env_get_isa(main_env->arch_env); - - compute_doms(irg); - - chordal_env.irg = irg; - chordal_env.dbg = firm_dbg_register("firm.be.chordal"); - chordal_env.main_env = main_env; - chordal_env.dom_front = be_compute_dominance_frontiers(irg); - - obstack_init(&chordal_env.obst); - - /* Perform the following for each register class. */ - for(j = 0, m = arch_isa_get_n_reg_class(isa); j < m; ++j) { - chordal_env.cls = arch_isa_get_reg_class(isa, j); - chordal_env.border_heads = pmap_create(); - chordal_env.constr_irn = pset_new_ptr(32); - - be_liveness(irg); - dump(BE_CH_DUMP_LIVE, irg, chordal_env.cls, "-live", dump_ir_block_graph_sched); - - /* spilling */ - switch(options.spill_method) { - case BE_CH_SPILL_BELADY: - be_spill_belady(&chordal_env); - break; - case BE_CH_SPILL_ILP: - be_spill_ilp(&chordal_env); - break; - default: - fprintf(stderr, "no valid spiller selected. falling back to belady\n"); - be_spill_belady(&chordal_env); + const ir_edge_t *edge, *ne; + ir_node *block; + ir_node *spill; + + (void)env; + + if (! be_is_Reload(irn)) + return; + + /* only use memory operands, if the reload is only used by 1 node */ + if(get_irn_n_edges(irn) > 1) + return; + + spill = be_get_Reload_mem(irn); + block = get_nodes_block(irn); + + foreach_out_edge_safe(irn, edge, ne) { + ir_node *src = get_edge_src_irn(edge); + int pos = get_edge_src_pos(edge); + + assert(src && "outedges broken!"); + + if (get_nodes_block(src) == block && arch_possible_memory_operand(src, pos)) { + arch_perform_memory_operand(src, spill, pos); } - dump(BE_CH_DUMP_SPILL, irg, chordal_env.cls, "-spill", dump_ir_block_graph_sched); - be_liveness(irg); - be_check_pressure(&chordal_env); + } + + /* kill the Reload */ + if (get_irn_n_edges(irn) == 0) { + sched_remove(irn); + set_irn_n(irn, be_pos_Reload_mem, new_Bad()); + set_irn_n(irn, be_pos_Reload_frame, new_Bad()); + } +} + +/** + * Starts a walk for memory operands if supported by the backend. + */ +static INLINE void check_for_memory_operands(ir_graph *irg) +{ + irg_walk_graph(irg, NULL, memory_operand_walker, NULL); +} + + +static be_node_stats_t last_node_stats; + +/** + * Perform things which need to be done per register class before spilling. + */ +static void pre_spill(post_spill_env_t *pse, const arch_register_class_t *cls) +{ + be_chordal_env_t *chordal_env = &pse->cenv; + be_irg_t *birg = pse->birg; + ir_graph *irg = be_get_birg_irg(birg); + + pse->cls = cls; + chordal_env->cls = cls; + chordal_env->border_heads = pmap_create(); + chordal_env->ignore_colors = bitset_malloc(chordal_env->cls->n_regs); + + be_assure_liveness(birg); + be_liveness_assure_chk(be_get_birg_liveness(birg)); -#if 0 - /* Insert perms before reg-constrained instructions */ - be_insert_constr_perms(&chordal_env); - dump(BE_CH_DUMP_CONSTR, irg, chordal_env.cls, "-constr", dump_ir_block_graph_sched); -#endif + stat_ev_do(pse->pre_spill_cost = be_estimate_irg_costs(irg, birg->exec_freq)); - be_liveness(irg); - be_check_pressure(&chordal_env); + /* put all ignore registers into the ignore register set. */ + be_put_ignore_regs(birg, pse->cls, chordal_env->ignore_colors); + + BE_TIMER_PUSH(t_ra_constr); + be_pre_spill_prepare_constr(chordal_env); + BE_TIMER_POP(t_ra_constr); + + dump(BE_CH_DUMP_CONSTR, birg->irg, pse->cls, "-constr-pre", dump_ir_block_graph_sched); +} + +/** + * Perform things which need to be done per register class after spilling. + */ +static void post_spill(post_spill_env_t *pse, int iteration) { + be_chordal_env_t *chordal_env = &pse->cenv; + be_irg_t *birg = pse->birg; + ir_graph *irg = birg->irg; + int colors_n = arch_register_class_n_regs(chordal_env->cls); + int allocatable_regs = colors_n - be_put_ignore_regs(birg, chordal_env->cls, NULL); + + /* some special classes contain only ignore regs, no work to be done */ + if (allocatable_regs > 0) { + stat_ev_dbl("bechordal_spillcosts", be_estimate_irg_costs(irg, birg->exec_freq) - pse->pre_spill_cost); + + /* + If we have a backend provided spiller, post spill is + called in a loop after spilling for each register class. + But we only need to fix stack nodes once in this case. + */ + BE_TIMER_PUSH(t_ra_spill_apply); + check_for_memory_operands(irg); + if (iteration == 0) { + be_abi_fix_stack_nodes(birg->abi); + } + BE_TIMER_POP(t_ra_spill_apply); + + BE_TIMER_PUSH(t_verify); + + /* verify schedule and register pressure */ + if (chordal_env->opts->vrfy_option == BE_CH_VRFY_WARN) { + be_verify_schedule(birg); + be_verify_register_pressure(birg, pse->cls, irg); + } else if (chordal_env->opts->vrfy_option == BE_CH_VRFY_ASSERT) { + assert(be_verify_schedule(birg) && "Schedule verification failed"); + assert(be_verify_register_pressure(birg, pse->cls, irg) + && "Register pressure verification failed"); + } + BE_TIMER_POP(t_verify); /* Color the graph. */ - be_ra_chordal_color(&chordal_env); - dump(BE_CH_DUMP_CONSTR, irg, chordal_env.cls, "-color", dump_ir_block_graph_sched); + BE_TIMER_PUSH(t_ra_color); + be_ra_chordal_color(chordal_env); + BE_TIMER_POP(t_ra_color); + + dump(BE_CH_DUMP_CONSTR, irg, pse->cls, "-color", dump_ir_block_graph_sched); - /* Build the interference graph. */ - chordal_env.ifg = be_ifg_std_new(&chordal_env); - be_ifg_check(chordal_env.ifg); + /* Create the ifg with the selected flavor */ + BE_TIMER_PUSH(t_ra_ifg); + chordal_env->ifg = be_create_ifg(chordal_env); + BE_TIMER_POP(t_ra_ifg); + + stat_ev_if { + be_ifg_stat_t stat; + be_node_stats_t node_stats; + + be_ifg_stat(birg, chordal_env->ifg, &stat); + stat_ev_dbl("bechordal_ifg_nodes", stat.n_nodes); + stat_ev_dbl("bechordal_ifg_edges", stat.n_edges); + stat_ev_dbl("bechordal_ifg_comps", stat.n_comps); + + be_collect_node_stats(&node_stats, birg); + be_subtract_node_stats(&node_stats, &last_node_stats); + + stat_ev_dbl("bechordal_perms_before_coal", + node_stats[BE_STAT_PERMS]); + stat_ev_dbl("bechordal_copies_before_coal", + node_stats[BE_STAT_COPIES]); + } /* copy minimization */ - copystat_collect_cls(&chordal_env); - be_copy_opt(&chordal_env); - dump(BE_CH_DUMP_COPYMIN, irg, chordal_env.cls, "-copymin", dump_ir_block_graph_sched); - be_ra_chordal_check(&chordal_env); + BE_TIMER_PUSH(t_ra_copymin); + co_driver(chordal_env); + BE_TIMER_POP(t_ra_copymin); + + dump(BE_CH_DUMP_COPYMIN, irg, pse->cls, "-copymin", dump_ir_block_graph_sched); + /* ssa destruction */ - be_ssa_destruction(&chordal_env); - dump(BE_CH_DUMP_SSADESTR, irg, chordal_env.cls, "-ssadestr", dump_ir_block_graph_sched); - be_ssa_destruction_check(&chordal_env); - be_ra_chordal_check(&chordal_env); + BE_TIMER_PUSH(t_ra_ssa); + be_ssa_destruction(chordal_env); + BE_TIMER_POP(t_ra_ssa); - copystat_dump(irg); + dump(BE_CH_DUMP_SSADESTR, irg, pse->cls, "-ssadestr", dump_ir_block_graph_sched); - be_ifg_free(chordal_env.ifg); + if (chordal_env->opts->vrfy_option != BE_CH_VRFY_OFF) { + BE_TIMER_PUSH(t_verify); + be_ssa_destruction_check(chordal_env); + BE_TIMER_POP(t_verify); + } - pmap_destroy(chordal_env.border_heads); - del_pset(chordal_env.constr_irn); + /* the ifg exists only if there are allocatable regs */ + be_ifg_free(chordal_env->ifg); } - be_compute_spill_offsets(&chordal_env); + /* free some always allocated data structures */ + pmap_destroy(chordal_env->border_heads); + bitset_free(chordal_env->ignore_colors); +} + +/** + * Performs chordal register allocation for each register class on given irg. + * + * @param birg Backend irg object + * @return Structure containing timer for the single phases or NULL if no timing requested. + */ +static void be_ra_chordal_main(be_irg_t *birg) +{ + const arch_env_t *arch_env = birg->main_env->arch_env; + ir_graph *irg = birg->irg; + int j; + int m; + be_chordal_env_t chordal_env; + struct obstack obst; + + BE_TIMER_PUSH(t_ra_other); + + BE_TIMER_PUSH(t_ra_prolog); + + be_assure_liveness(birg); + + chordal_env.obst = &obst; + chordal_env.opts = &options; + chordal_env.irg = irg; + chordal_env.birg = birg; + chordal_env.border_heads = NULL; + chordal_env.ifg = NULL; + chordal_env.ignore_colors = NULL; - dump(BE_CH_DUMP_LOWER, irg, NULL, "-spilloff", dump_ir_block_graph_sched); + obstack_init(&obst); - lower_nodes_after_ra(&chordal_env, options.lower_perm_method == BE_CH_LOWER_PERM_COPY ? 1 : 0); + BE_TIMER_POP(t_ra_prolog); + + stat_ev_if { + be_collect_node_stats(&last_node_stats, birg); + } + + if (! arch_code_generator_has_spiller(birg->cg)) { + /* use one of the generic spiller */ + + /* Perform the following for each register class. */ + for (j = 0, m = arch_env_get_n_reg_class(arch_env); j < m; ++j) { + post_spill_env_t pse; + const arch_register_class_t *cls + = arch_env_get_reg_class(arch_env, j); + + if(arch_register_class_flags(cls) & arch_register_class_flag_manual_ra) + continue; + + + stat_ev_ctx_push_str("bechordal_cls", cls->name); + + stat_ev_if { + be_do_stat_reg_pressure(birg, cls); + } + + memcpy(&pse.cenv, &chordal_env, sizeof(chordal_env)); + pse.birg = birg; + pre_spill(&pse, cls); + + BE_TIMER_PUSH(t_ra_spill); + be_do_spill(birg, cls); + BE_TIMER_POP(t_ra_spill); + + dump(BE_CH_DUMP_SPILL, irg, pse.cls, "-spill", + dump_ir_block_graph_sched); + + post_spill(&pse, 0); + + stat_ev_if { + be_node_stats_t node_stats; + + be_collect_node_stats(&node_stats, birg); + be_subtract_node_stats(&node_stats, &last_node_stats); + be_emit_node_stats(&node_stats, "bechordal_"); + + be_copy_node_stats(&last_node_stats, &node_stats); + stat_ev_ctx_pop("bechordal_cls"); + } + } + } else { + post_spill_env_t *pse; + + /* the backend has its own spiller */ + m = arch_env_get_n_reg_class(arch_env); + + pse = alloca(m * sizeof(pse[0])); + + for (j = 0; j < m; ++j) { + memcpy(&pse[j].cenv, &chordal_env, sizeof(chordal_env)); + pse[j].birg = birg; + pre_spill(&pse[j], pse[j].cls); + } + + BE_TIMER_PUSH(t_ra_spill); + arch_code_generator_spill(birg->cg, birg); + BE_TIMER_POP(t_ra_spill); + dump(BE_CH_DUMP_SPILL, irg, NULL, "-spill", dump_ir_block_graph_sched); + + for (j = 0; j < m; ++j) { + post_spill(&pse[j], j); + } + } + + BE_TIMER_PUSH(t_verify); + be_verify_register_allocation(birg); + BE_TIMER_POP(t_verify); + + BE_TIMER_PUSH(t_ra_epilog); + lower_nodes_after_ra(birg, options.lower_perm_opt & BE_CH_LOWER_PERM_COPY ? 1 : 0); dump(BE_CH_DUMP_LOWER, irg, NULL, "-belower-after-ra", dump_ir_block_graph_sched); - be_free_dominance_frontiers(chordal_env.dom_front); - obstack_free(&chordal_env.obst, NULL); + obstack_free(&obst, NULL); + be_liveness_invalidate(be_get_birg_liveness(birg)); + BE_TIMER_POP(t_ra_epilog); + + BE_TIMER_POP(t_ra_other); } -const be_ra_t be_ra_chordal_allocator = { -#ifdef WITH_LIBCORE - be_ra_chordal_register_options, -#endif - be_ra_chordal_main +static be_ra_t be_ra_chordal_allocator = { + be_ra_chordal_main, }; + +void be_init_chordal_main(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_add_table(chordal_grp, be_chordal_options); + + be_register_allocator("chordal", &be_ra_chordal_allocator); +} + +BE_REGISTER_MODULE_CONSTRUCTOR(be_init_chordal_main);