becopyopt: Remove the attribute copy_opt_t* co from struct unit_t.

diff --git a/ir/be/becopyheur.c b/ir/be/becopyheur.c
index dbb638c..7243c8a 100644 (file)
--- a/ir/be/becopyheur.c
+++ b/ir/be/becopyheur.c
@@ -113,7 +113,7 @@ static inline int qnode_are_conflicting(const qnode_t *qn, const ir_node *n1, co
        conflict_t c;
        /* search for live range interference */
        if (n1 != n2) {
-               be_lv_t *const lv = be_get_irg_liveness(qn->ou->co->irg);
+               be_lv_t *const lv = be_get_irg_liveness(get_irn_irg(n1));
                if (be_values_interfere(lv, n1, n2))
                        return 1;
        }
@@ -230,15 +230,10 @@ static inline void qnode_pin_local(const qnode_t *qn, ir_node *irn)
  *         Else the first conflicting ir_node encountered is returned.
  *
  */
-static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const ir_node *trigger)
+static ir_node *qnode_color_irn(qnode_t const *const qn, ir_node *const irn, int const col, ir_node const *const trigger, bitset_t const *const allocatable_regs, be_ifg_t *const ifg)
 {
-       copy_opt_t *co = qn->ou->co;
-       const be_chordal_env_t *chordal_env = co->cenv;
-       const arch_register_class_t *cls = co->cls;
        int irn_col = qnode_get_new_color(qn, irn);
-       be_ifg_t *ifg = chordal_env->ifg;
        neighbours_iter_t iter;
-       const arch_register_req_t *req;
 
        DBG((dbg, LEVEL_3, "\t    %+F \tcaused col(%+F) \t%2d --> %2d\n", trigger, irn, irn_col, col));
 
@@ -254,7 +249,8 @@ static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const
                return irn;
        }
 
-       req = arch_get_irn_register_req(irn);
+       arch_register_req_t   const *const req = arch_get_irn_register_req(irn);
+       arch_register_class_t const *const cls = req->cls;
 #ifdef SEARCH_FREE_COLORS
        /* If we resolve conflicts (recursive calls) we can use any unused color.
         * In case of the first call @p col must be used.
@@ -264,7 +260,7 @@ static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const
                int free_col;
 
                /* Get all possible colors */
-               bitset_copy(free_cols, co->cenv->allocatable_regs);
+               bitset_copy(free_cols, allocatable_regs);
 
                /* Exclude colors not assignable to the irn */
                if (arch_register_req_is(req, limited)) {
@@ -302,7 +298,7 @@ static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const
        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) {
-                       ir_node *const sub_res = qnode_color_irn(qn, curr, irn_col, irn);
+                       ir_node *const sub_res = qnode_color_irn(qn, curr, irn_col, irn, allocatable_regs, ifg);
                        if (sub_res != CHANGE_SAVE) {
                                be_ifg_neighbours_break(&iter);
                                return sub_res;
@@ -325,7 +321,7 @@ static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const
  * @returns 1 iff all members colors could be set
  *          0 else
  */
-static int qnode_try_color(const qnode_t *qn)
+static int qnode_try_color(qnode_t const *const qn, bitset_t const *const allocatable_regs, be_ifg_t *const ifg)
 {
        int i;
        for (i=0; i<qn->mis_size; ++i) {
@@ -333,7 +329,7 @@ static int qnode_try_color(const qnode_t *qn)
 
                test_node = qn->mis[i];
                DBG((dbg, LEVEL_3, "\t    Testing %+F\n", test_node));
-               confl_node = qnode_color_irn(qn, test_node, qn->color, test_node);
+               confl_node = qnode_color_irn(qn, test_node, qn->color, test_node, allocatable_regs, ifg);
 
                if (confl_node == CHANGE_SAVE) {
                        DBG((dbg, LEVEL_3, "\t    Save --> pin local\n"));
@@ -524,29 +520,21 @@ static inline void ou_insert_qnode(unit_t *ou, qnode_t *qn)
  * case for approximately 80% of all phi classes and 100% of register constrained
  * nodes. (All other phi classes are reduced to this case.)
  */
-static void ou_optimize(unit_t *ou)
+static void ou_optimize(unit_t *ou, bitset_t const *const allocatable_regs, be_ifg_t *const ifg)
 {
-       qnode_t                   *curr = NULL;
-       const arch_register_req_t *req;
-       bitset_t const*            allocatable_regs;
-       unsigned                   n_regs;
-       unsigned                   idx;
-       int                        i;
-
        DBG((dbg, LEVEL_1, "\tOptimizing unit:\n"));
-       for (i=0; i<ou->node_count; ++i)
+       for (int i = 0; i < ou->node_count; ++i)
                DBG((dbg, LEVEL_1, "\t %+F\n", ou->nodes[i]));
 
        /* init queue */
        INIT_LIST_HEAD(&ou->queue);
 
-       req              = arch_get_irn_register_req(ou->nodes[0]);
-       allocatable_regs = ou->co->cenv->allocatable_regs;
-       n_regs           = req->cls->n_regs;
+       arch_register_req_t const *const req    = arch_get_irn_register_req(ou->nodes[0]);
+       unsigned                   const n_regs = req->cls->n_regs;
        if (arch_register_req_is(req, limited)) {
                unsigned const* limited = req->limited;
 
-               for (idx = 0; idx != n_regs; ++idx) {
+               for (unsigned idx = 0; idx != n_regs; ++idx) {
                        if (!bitset_is_set(allocatable_regs, idx))
                                continue;
                        if (!rbitset_is_set(limited, idx))
@@ -555,7 +543,7 @@ static void ou_optimize(unit_t *ou)
                        ou_insert_qnode(ou, new_qnode(ou, idx));
                }
        } else {
-               for (idx = 0; idx != n_regs; ++idx) {
+               for (unsigned idx = 0; idx != n_regs; ++idx) {
                        if (!bitset_is_set(allocatable_regs, idx))
                                continue;
 
@@ -564,6 +552,7 @@ static void ou_optimize(unit_t *ou)
        }
 
        /* search best */
+       qnode_t *curr;
        for (;;) {
                assert(!list_empty(&ou->queue));
                /* get head of queue */
@@ -572,7 +561,7 @@ static void ou_optimize(unit_t *ou)
                DBG((dbg, LEVEL_2, "\t  Examine qnode color %d with cost %d\n", curr->color, curr->mis_costs));
 
                /* try */
-               if (qnode_try_color(curr))
+               if (qnode_try_color(curr, allocatable_regs, ifg))
                        break;
 
                /* no success, so re-insert */
@@ -587,7 +576,7 @@ static void ou_optimize(unit_t *ou)
                DBG((dbg, LEVEL_1, "\t  Best color: %d  Costs: %d << %d << %d\n", curr->color, ou->min_nodes_costs, ou->all_nodes_costs - curr->mis_costs, ou->all_nodes_costs));
                /* globally pin root and all args which have the same color */
                pset_insert_ptr(pinned_global, ou->nodes[0]);
-               for (i=1; i<ou->node_count; ++i) {
+               for (int i = 1; i < ou->node_count; ++i) {
                        ir_node *irn = ou->nodes[i];
                        int nc = qnode_get_new_color(curr, irn);
                        if (nc != NO_COLOR && nc == root_col)
@@ -599,7 +588,7 @@ static void ou_optimize(unit_t *ou)
                        /* NO_COLOR is possible, if we had an undo */
                        if (ns->new_color != NO_COLOR) {
                                DBG((dbg, LEVEL_1, "\t    color(%+F) := %d\n", ns->irn, ns->new_color));
-                               set_irn_col(ou->co->cls, ns->irn, ns->new_color);
+                               set_irn_col(req->cls, ns->irn, ns->new_color);
                        }
                }
        }
@@ -619,9 +608,12 @@ int co_solve_heuristic(copy_opt_t *co)
        ASSERT_OU_AVAIL(co);
 
        pinned_global = pset_new_ptr(SLOTS_PINNED_GLOBAL);
-       list_for_each_entry(unit_t, curr, &co->units, units)
+       bitset_t const *const allocatable_regs = co->cenv->allocatable_regs;
+       be_ifg_t       *const ifg              = co->cenv->ifg;
+       list_for_each_entry(unit_t, curr, &co->units, units) {
                if (curr->node_count > 1)
-                       ou_optimize(curr);
+                       ou_optimize(curr, allocatable_regs, ifg);
+       }
 
        del_pset(pinned_global);
        return 0;

diff --git a/ir/be/becopyopt.c b/ir/be/becopyopt.c
index c944345..e5a58ac 100644 (file)
--- a/ir/be/becopyopt.c
+++ b/ir/be/becopyopt.c
@@ -285,9 +285,8 @@ static int co_get_costs_all_one(const ir_node *root, int pos)
  * Determines a maximum weighted independent set with respect to
  * the interference and conflict edges of all nodes in a qnode.
  */
-static int ou_max_ind_set_costs(unit_t *ou)
+static int ou_max_ind_set_costs(unit_t *const ou, be_lv_t const *const lv)
 {
-       be_lv_t *const lv = be_get_irg_liveness(ou->co->irg);
        ir_node **safe, **unsafe;
        int i, o, safe_count, safe_costs, unsafe_count, *unsafe_costs;
        bitset_t *curr;
@@ -385,7 +384,6 @@ static void co_collect_units(ir_node *irn, void *env)
 
        /* Init a new unit */
        unit = XMALLOCZ(unit_t);
-       unit->co = co;
        unit->node_count = 1;
        INIT_LIST_HEAD(&unit->queue);
 
@@ -502,7 +500,7 @@ static void co_collect_units(ir_node *irn, void *env)
                }
 
                /* Determine the minimal costs this unit will cause: min_nodes_costs */
-               unit->min_nodes_costs += unit->all_nodes_costs - ou_max_ind_set_costs(unit);
+               unit->min_nodes_costs += unit->all_nodes_costs - ou_max_ind_set_costs(unit, lv);
                /* Insert the new ou according to its sort_key */
                tmp = &co->units;
                while (tmp->next != &co->units && list_entry_units(tmp->next)->sort_key > unit->sort_key)

diff --git a/ir/be/becopyopt_t.h b/ir/be/becopyopt_t.h
index ab135c1..8ca18fd 100644 (file)
--- a/ir/be/becopyopt_t.h
+++ b/ir/be/becopyopt_t.h
@@ -76,7 +76,6 @@ static inline void set_irn_col(const arch_register_class_t *cls, ir_node *node,
 
 typedef struct unit_t {
        struct list_head units;              /**< chain for all units */
-       copy_opt_t       *co;                /**< the copy opt this unit belongs to */
        int              node_count;         /**< size of the nodes array */
        ir_node          **nodes;            /**< [0] is the root-node, others are non interfering args of it. */
        int              *costs;             /**< costs[i] are incurred, if nodes[i] has a different color */