fix bad input register requirements

[libfirm] / ir / be / becopyheur4.c

diff --git a/ir/be/becopyheur4.c b/ir/be/becopyheur4.c
index 3199538..acda7f9 100644 (file)
--- a/ir/be/becopyheur4.c
+++ b/ir/be/becopyheur4.c
@@ -47,7 +47,7 @@
 #include "irtools.h"
 #include "error.h"
 #include "list.h"
-#include "statev.h"
+#include "statev_t.h"
 
 #include "bearch.h"
 #include "beifg.h"
@@ -201,7 +201,7 @@ static co_mst_irn_t *co_mst_irn_init(co_mst_env_t *env, const ir_node *irn)
 
 static co_mst_irn_t *get_co_mst_irn(co_mst_env_t *env, const ir_node *node)
 {
-       co_mst_irn_t *res = (co_mst_irn_t*)ir_nodemap_get(&env->map, node);
+       co_mst_irn_t *res = ir_nodemap_get(co_mst_irn_t, &env->map, node);
        if (res == NULL) {
                res = co_mst_irn_init(env, node);
                ir_nodemap_insert(&env->map, node, res);
@@ -235,7 +235,6 @@ static void dbg_aff_chunk(const co_mst_env_t *env, const aff_chunk_t *c)
  */
 static void dbg_admissible_colors(const co_mst_env_t *env, const co_mst_irn_t *node)
 {
-       size_t idx;
        (void) env;
 
        if (bitset_popcount(node->adm_colors) < 1)
@@ -312,7 +311,13 @@ static __attribute__((unused)) int cmp_col_cost_lt(const void *a, const void *b)
        const col_cost_t *c1 = (const col_cost_t*)a;
        const col_cost_t *c2 = (const col_cost_t*)b;
        real_t diff = c1->cost - c2->cost;
-       return (diff > 0) - (diff < 0);
+
+       if (diff < 0)
+               return 1;
+       if (diff > 0)
+               return -1;
+
+       return QSORT_CMP(c1->col, c2->col);
 }
 
 static int cmp_col_cost_gt(const void *a, const void *b)
@@ -321,10 +326,12 @@ static int cmp_col_cost_gt(const void *a, const void *b)
        const col_cost_t *c2 = (const col_cost_t*)b;
        real_t diff = c2->cost - c1->cost;
 
-       if (diff == 0.0)
-               return QSORT_CMP(c1->col, c2->col);
+       if (diff > 0)
+               return 1;
+       if (diff < 0)
+               return -1;
 
-       return (diff > 0) - (diff < 0);
+       return QSORT_CMP(c1->col, c2->col);
 }
 
 /**
@@ -575,13 +582,11 @@ static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c)
 
                        node->chunk = c;
                        if (node->constr_factor > REAL(0.0)) {
-                               size_t col;
                                bitset_foreach (node->adm_colors, col)
                                        c->color_affinity[col].cost += node->constr_factor;
                        }
 
                        if (an != NULL) {
-                               neighb_t *neigh;
                                co_gs_foreach_neighb(an, neigh) {
                                        const ir_node *m = neigh->irn;
 
@@ -607,7 +612,6 @@ static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c)
  */
 static int count_interfering_aff_neighs(co_mst_env_t *env, const affinity_node_t *an)
 {
-       const neighb_t     *neigh;
        const ir_node      *irn  = an->irn;
        const co_mst_irn_t *node = get_co_mst_irn(env, irn);
        int                res   = 0;
@@ -644,7 +648,6 @@ static void build_affinity_chunks(co_mst_env_t *env)
        aff_edge_t  *edges    = NEW_ARR_F(aff_edge_t, 0);
        ir_node     *n;
        int         i, len;
-       aff_chunk_t *curr_chunk;
        size_t      pn;
 
        /* at first we create the affinity edge objects */
@@ -660,8 +663,6 @@ static void build_affinity_chunks(co_mst_env_t *env)
                an = get_affinity_info(env->co, n);
 
                if (an != NULL) {
-                       neighb_t *neigh;
-
                        if (n1->int_aff_neigh < 0)
                                n1->int_aff_neigh = count_interfering_aff_neighs(env, an);
 
@@ -719,7 +720,7 @@ static void build_affinity_chunks(co_mst_env_t *env)
        }
 
        for (pn = 0; pn < ARR_LEN(env->map.data); ++pn) {
-               co_mst_irn_t *mirn = env->map.data[pn];
+               co_mst_irn_t *mirn = (co_mst_irn_t*)env->map.data[pn];
                if (mirn == NULL)
                        continue;
                if (mirn->chunk != NULL)
@@ -752,7 +753,6 @@ static __attribute__((unused)) void chunk_order_nodes(co_mst_env_t *env, aff_chu
                const ir_node   *irn = chunk->n[--i];
                affinity_node_t *an  = get_affinity_info(env->co, irn);
                int w = 0;
-               neighb_t *neigh;
 
                if (arch_irn_is_ignore(irn))
                        continue;
@@ -780,7 +780,6 @@ static __attribute__((unused)) void chunk_order_nodes(co_mst_env_t *env, aff_chu
                while (!pqueue_empty(grow)) {
                        ir_node *irn = (ir_node*)pqueue_pop_front(grow);
                        affinity_node_t *an = get_affinity_info(env->co, irn);
-                       neighb_t        *neigh;
 
                        if (arch_irn_is_ignore(irn))
                                continue;
@@ -829,7 +828,6 @@ static void expand_chunk_from(co_mst_env_t *env, co_mst_irn_t *node, bitset_t *v
 
                /* check all affinity neighbors */
                if (an != NULL) {
-                       neighb_t *neigh;
                        co_gs_foreach_neighb(an, neigh) {
                                const ir_node *m    = neigh->irn;
                                int            m_idx = get_irn_idx(m);
@@ -925,7 +923,6 @@ static aff_chunk_t *fragment_chunk(co_mst_env_t *env, int col, aff_chunk_t *c, w
  */
 static inline void reject_coloring(struct list_head *nodes)
 {
-       co_mst_irn_t *n, *temp;
        DB((dbg, LEVEL_4, "\treject coloring for"));
        list_for_each_entry_safe(co_mst_irn_t, n, temp, nodes, list) {
                DB((dbg, LEVEL_4, " %+F", n->irn));
@@ -938,7 +935,6 @@ static inline void reject_coloring(struct list_head *nodes)
 
 static inline void materialize_coloring(struct list_head *nodes)
 {
-       co_mst_irn_t *n, *temp;
        list_for_each_entry_safe(co_mst_irn_t, n, temp, nodes, list) {
                assert(n->tmp_col >= 0);
                n->col     = n->tmp_col;
@@ -1243,7 +1239,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c)
         */
        for (i = 0; i < env->k; ++i) {
                int         col = order[i].col;
-               waitq       *good_starts = new_waitq();
+               waitq       *good_starts;
                aff_chunk_t *local_best;
                int          n_succeeded;
 
@@ -1254,6 +1250,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c)
                DB((dbg, LEVEL_2, "\ttrying color %d\n", col));
 
                n_succeeded = 0;
+               good_starts = new_waitq();
 
                /* try to bring all nodes of given chunk to the current color. */
                for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
@@ -1292,8 +1289,10 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c)
                }
 
                /* try next color when failed */
-               if (n_succeeded == 0)
+               if (n_succeeded == 0) {
+                       del_waitq(good_starts);
                        continue;
+               }
 
                /* fragment the chunk according to the coloring */
                local_best = fragment_chunk(env, col, c, tmp_chunks);
@@ -1490,7 +1489,7 @@ static int co_solve_heuristic_mst(copy_opt_t *co)
 
        /* apply coloring */
        for (pn = 0; pn < ARR_LEN(mst_env.map.data); ++pn) {
-               co_mst_irn_t *mirn = mst_env.map.data[pn];
+               co_mst_irn_t *mirn = (co_mst_irn_t*)mst_env.map.data[pn];
                const arch_register_t *reg;
                if (mirn == NULL)
                        continue;