Use module mechanism to register copy minimization algorithms.

[libfirm] / ir / be / becopyheur4.c

diff --git a/ir/be/becopyheur4.c b/ir/be/becopyheur4.c
index 4a8cd15..7d05098 100644 (file)
--- a/ir/be/becopyheur4.c
+++ b/ir/be/becopyheur4.c
@@ -396,7 +396,7 @@ static void *co_mst_irn_init(ir_phase *ph, const ir_node *irn, void *old) {
                /* build list of interfering neighbours */
                len = 0;
                be_ifg_foreach_neighbour(env->ifg, nodes_it, irn, neigh) {
-                       if (!arch_irn_is(neigh, ignore)) {
+                       if (!arch_irn_is_ignore(neigh)) {
                                obstack_ptr_grow(phase_obst(ph), neigh);
                                ++len;
                        }
@@ -552,10 +552,9 @@ static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c) {
                        if (an != NULL) {
                                neighb_t *neigh;
                                co_gs_foreach_neighb(an, neigh) {
-                                       const ir_node *m    = neigh->irn;
+                                       const ir_node *m = neigh->irn;
 
-                                       /* skip ignore nodes */
-                                       if (arch_irn_is(m, ignore))
+                                       if (arch_irn_is_ignore(m))
                                                continue;
 
                                        w += node_contains(c->n, m) ? neigh->costs : 0;
@@ -585,8 +584,7 @@ static int count_interfering_aff_neighs(co_mst_env_t *env, const affinity_node_t
                const ir_node *n = neigh->irn;
                int           i;
 
-               /* skip ignore nodes */
-               if (arch_irn_is(n, ignore))
+               if (arch_irn_is_ignore(n))
                        continue;
 
                /* check if the affinity neighbour interfere */
@@ -621,8 +619,7 @@ static void build_affinity_chunks(co_mst_env_t *env) {
                co_mst_irn_t    *n1;
                affinity_node_t *an;
 
-               /* skip ignore nodes */
-               if (arch_irn_is(n, ignore))
+               if (arch_irn_is_ignore(n))
                        continue;
 
                n1 = get_co_mst_irn(env, n);
@@ -645,7 +642,7 @@ static void build_affinity_chunks(co_mst_env_t *env) {
                                        aff_edge_t   edge;
 
                                        /* skip ignore nodes */
-                                       if (arch_irn_is(m, ignore))
+                                       if (arch_irn_is_ignore(m))
                                                continue;
 
                                        edge.src = n;
@@ -721,7 +718,7 @@ static __attribute__((unused)) void chunk_order_nodes(co_mst_env_t *env, aff_chu
                int w = 0;
                neighb_t *neigh;
 
-               if (arch_irn_is(irn, ignore))
+               if (arch_irn_is_ignore(irn))
                        continue;
 
                if (an) {
@@ -747,9 +744,9 @@ static __attribute__((unused)) void chunk_order_nodes(co_mst_env_t *env, aff_chu
                while (!pqueue_empty(grow)) {
                        ir_node *irn = pqueue_pop_front(grow);
                        affinity_node_t *an = get_affinity_info(env->co, irn);
-                       neighb_t *neigh;
+                       neighb_t        *neigh;
 
-                       if (arch_irn_is(irn, ignore))
+                       if (arch_irn_is_ignore(irn))
                                continue;
 
                        assert(i <= ARR_LEN(chunk->n));
@@ -802,8 +799,7 @@ static void expand_chunk_from(co_mst_env_t *env, co_mst_irn_t *node, bitset_t *v
                                int            m_idx = get_irn_idx(m);
                                co_mst_irn_t *n2;
 
-                               /* skip ignore nodes */
-                               if (arch_irn_is(m, ignore))
+                               if (arch_irn_is_ignore(m))
                                        continue;
 
                                n2 = get_co_mst_irn(env, m);
@@ -932,11 +928,12 @@ static inline int is_loose(co_mst_irn_t *node)
 /**
  * Determines the costs for each color if it would be assigned to node @p node.
  */
-static void determine_color_costs(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs) {
-       int *neigh_cols = alloca(env->n_regs * sizeof(*neigh_cols));
-       int n_loose = 0;
+static void determine_color_costs(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs)
+{
+       int   *neigh_cols = ALLOCAN(int, env->n_regs);
+       int    n_loose    = 0;
        real_t coeff;
-       int i;
+       int    i;
 
        for (i = 0; i < env->n_regs; ++i) {
                neigh_cols[i] = 0;
@@ -981,7 +978,7 @@ static int change_node_color_excluded(co_mst_env_t *env, co_mst_irn_t *node, int
 
        /* The node has the color it should not have _and_ has not been visited yet. */
        if (is_loose(node)) {
-               col_cost_t *costs = alloca(env->n_regs * sizeof(costs[0]));
+               col_cost_t *costs = ALLOCAN(col_cost_t, env->n_regs);
 
                /* Get the costs for giving the node a specific color. */
                determine_color_costs(env, node, costs);
@@ -1045,8 +1042,7 @@ static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *cost
 
                        neigh = node->int_neighs[j];
 
-                       /* skip ignore nodes */
-                       if (arch_irn_is(neigh, ignore))
+                       if (arch_irn_is_ignore(neigh))
                                continue;
 
                        nn = get_co_mst_irn(env, neigh);
@@ -1149,7 +1145,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
        int         n_int_chunks  = 0;
        waitq       *tmp_chunks   = new_waitq();
        waitq       *best_starts  = NULL;
-       col_cost_t  *order        = alloca(env->n_regs * sizeof(order[0]));
+       col_cost_t  *order        = ALLOCANZ(col_cost_t, env->n_regs);
        bitset_t    *visited;
        int         idx, len, i, nidx, pos;
        struct list_head changed;
@@ -1163,8 +1159,6 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
        ++env->chunk_visited;
 
        /* compute color preference */
-       memset(order, 0, env->n_regs * sizeof(order[0]));
-
        for (pos = 0, len = ARR_LEN(c->interfere); pos < len; ++pos) {
                const ir_node *n = c->interfere[pos];
                co_mst_irn_t *node = get_co_mst_irn(env, n);
@@ -1387,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;
@@ -1445,10 +1439,10 @@ int co_solve_heuristic_mst(copy_opt_t *co) {
 
        /* apply coloring */
        foreach_phase_irn(&mst_env.ph, irn) {
-               co_mst_irn_t *mirn;
+               co_mst_irn_t          *mirn;
                const arch_register_t *reg;
 
-               if (arch_irn_is(irn, ignore))
+               if (arch_irn_is_ignore(irn))
                        continue;
 
                mirn = get_co_mst_irn(&mst_env, irn);
@@ -1488,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);