refactor mode_b lowerer to have a create_set callback

[libfirm] / ir / be / becopyheur.c

diff --git a/ir/be/becopyheur.c b/ir/be/becopyheur.c
index 6158c31..b9003c7 100644 (file)
--- a/ir/be/becopyheur.c
+++ b/ir/be/becopyheur.c
@@ -59,7 +59,7 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 /**
  * Modeling additional conflicts between nodes. NOT live range interference
  */
-typedef struct _conflict_t {
+typedef struct conflict_t {
        const ir_node *n1, *n2;
 } conflict_t;
 
@@ -67,7 +67,7 @@ typedef struct _conflict_t {
  * If an irn is changed, the changes first get stored in a node_stat_t,
  * to allow undo of changes (=drop new data) in case of conflicts.
  */
-typedef struct _node_stat_t {
+typedef struct node_stat_t {
        ir_node *irn;
        int     new_color;
        int     pinned_local :1;
@@ -76,7 +76,7 @@ typedef struct _node_stat_t {
 /**
  * Represents a node in the optimization queue.
  */
-typedef struct _qnode_t {
+typedef struct qnode_t {
        struct list_head queue;            /**< chaining of unit_t->queue */
        const unit_t     *ou;              /**< the opt unit this node belongs to */
        int              color;            /**< target color */
@@ -93,8 +93,10 @@ static inline int nodes_interfere(const be_chordal_env_t *env, const ir_node *a,
 {
        if (env->ifg)
                return be_ifg_connected(env->ifg, a, b);
-       else
-               return be_values_interfere(env->birg->lv, a, b);
+       else {
+               be_lv_t *lv = be_get_irg_liveness(env->irg);
+               return be_values_interfere(lv, a, b);
+       }
 }
 
 static int set_cmp_conflict_t(const void *x, const void *y, size_t size)
@@ -255,7 +257,7 @@ static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const
        int irn_col = qnode_get_new_color(qn, irn);
        ir_node *sub_res, *curr;
        be_ifg_t *ifg = chordal_env->ifg;
-       void *iter = be_ifg_neighbours_iter_alloca(ifg);
+       neighbours_iter_t iter;
 
 
        DBG((dbg, LEVEL_3, "\t    %+F \tcaused col(%+F) \t%2d --> %2d\n", trigger, irn, irn_col, col));
@@ -298,7 +300,7 @@ static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const
                bitset_clear(free_cols, irn_col);
 
                /* Exclude all colors used by adjacent nodes */
-               be_ifg_foreach_neighbour(ifg, iter, irn, curr)
+               be_ifg_foreach_neighbour(ifg, &iter, irn, curr)
                        bitset_clear(free_cols, qnode_get_new_color(qn, curr));
 
                free_col = bitset_next_set(free_cols, 0);
@@ -320,12 +322,12 @@ static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const
         * If we arrive here changing color may be possible, but there may be conflicts.
         * Try to color all conflicting nodes 'curr' with the color of the irn itself.
         */
-       be_ifg_foreach_neighbour(ifg, iter, irn, curr) {
+       be_ifg_foreach_neighbour(ifg, &iter, irn, curr) {
                DBG((dbg, LEVEL_3, "\t      Confl %+F(%d)\n", curr, qnode_get_new_color(qn, curr)));
                if (qnode_get_new_color(qn, curr) == col && curr != trigger) {
                        sub_res = qnode_color_irn(qn, curr, irn_col, irn);
                        if (sub_res != CHANGE_SAVE) {
-                               be_ifg_neighbours_break(ifg, iter);
+                               be_ifg_neighbours_break(&iter);
                                return sub_res;
                        }
                }
@@ -397,7 +399,7 @@ static inline void qnode_max_ind_set(qnode_t *qn, const unit_t *ou)
        ir_node **safe, **unsafe;
        int i, o, safe_count, safe_costs, unsafe_count, *unsafe_costs;
        bitset_t *curr, *best;
-       bitset_pos_t pos;
+       unsigned pos;
        int next, curr_weight, best_weight = 0;
 
        /* assign the nodes into two groups.
@@ -410,9 +412,9 @@ static inline void qnode_max_ind_set(qnode_t *qn, const unit_t *ou)
        unsafe       = ALLOCAN(ir_node*, ou->node_count - 1);
        unsafe_costs = ALLOCAN(int,      ou->node_count - 1);
        unsafe_count = 0;
-       for(i=1; i<ou->node_count; ++i) {
+       for (i=1; i<ou->node_count; ++i) {
                int is_safe = 1;
-               for(o=1; o<ou->node_count; ++o) {
+               for (o=1; o<ou->node_count; ++o) {
                        if (qnode_are_conflicting(qn, ou->nodes[i], ou->nodes[o])) {
                                if (i!=o) {
                                        unsafe_costs[unsafe_count] = ou->costs[i];
@@ -477,7 +479,7 @@ no_stable_set:
        }
 
        /* transfer the best set into the qn */
-       qn->mis_size = 1+safe_count+bitset_popcnt(best);
+       qn->mis_size = 1+safe_count+bitset_popcount(best);
        qn->mis_costs = safe_costs+best_weight;
        qn->mis[0] = ou->nodes[0]; /* the root is always in a max stable set */
        next = 1;
@@ -552,8 +554,8 @@ static void ou_optimize(unit_t *ou)
        qnode_t                     *tmp;
        const arch_register_req_t   *req;
        bitset_t const*              ignore;
-       bitset_pos_t                 n_regs;
-       bitset_pos_t                 idx;
+       unsigned                     n_regs;
+       unsigned                     idx;
        int                          i;
 
        DBG((dbg, LEVEL_1, "\tOptimizing unit:\n"));
@@ -567,7 +569,7 @@ static void ou_optimize(unit_t *ou)
        ignore  = ou->co->cenv->ignore_colors;
        n_regs  = req->cls->n_regs;
        if (arch_register_req_is(req, limited)) {
-               rawbs_base_t const* limited = req->limited;
+               unsigned const* limited = req->limited;
 
                for (idx = 0; idx != n_regs; ++idx) {
                        if (bitset_is_set(ignore, idx))
@@ -653,6 +655,7 @@ int co_solve_heuristic(copy_opt_t *co)
        return 0;
 }
 
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur);
 void be_init_copyheur(void)
 {
        static co_algo_info copyheur = {
@@ -662,5 +665,3 @@ void be_init_copyheur(void)
        be_register_copyopt("heur1", &copyheur);
        FIRM_DBG_REGISTER(dbg, "ir.be.copyoptheur");
 }
-
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur);