no need for no_float_fold hack anymore

[libfirm] / ir / be / bechordal.c

diff --git a/ir/be/bechordal.c b/ir/be/bechordal.c
index 54a9e1f..2f56341 100644 (file)
--- a/ir/be/bechordal.c
+++ b/ir/be/bechordal.c
@@ -73,7 +73,7 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 
 #define DUMP_INTERVALS
 
-typedef struct _be_chordal_alloc_env_t {
+typedef struct be_chordal_alloc_env_t {
        be_chordal_env_t *chordal_env;
 
        pset *pre_colored;     /**< Set of precolored nodes. */
@@ -84,25 +84,6 @@ typedef struct _be_chordal_alloc_env_t {
        int colors_n;          /**< The number of colors. */
 } be_chordal_alloc_env_t;
 
-#if 0
-static void check_border_list(struct list_head *head)
-{
-       border_t *x;
-       list_for_each_entry(border_t, x, head, list) {
-               assert(x->magic == BORDER_FOURCC);
-       }
-}
-
-static void check_heads(be_chordal_env_t *env)
-{
-       pmap_entry *ent;
-       for (ent = pmap_first(env->border_heads); ent; ent = pmap_next(env->border_heads)) {
-               /* ir_printf("checking border list of block %+F\n", ent->key); */
-               check_border_list(ent->value);
-       }
-}
-#endif
-
 static int get_next_free_reg(const be_chordal_alloc_env_t *alloc_env, bitset_t *colors)
 {
        bitset_t *tmp = alloc_env->tmp_colors;
@@ -148,42 +129,42 @@ static void pair_up_operands(const be_chordal_alloc_env_t *alloc_env, be_insn_t
        /*
         * For each out operand, try to find an in operand which can be assigned the
         * same register as the out operand.
-       */
+        */
        for (j = 0; j < insn->use_start; ++j) {
-               int smallest         = -1;
-               int smallest_n_regs  = 2 * env->cls->n_regs + 1;
-               be_operand_t *out_op = &insn->ops[j];
+               be_operand_t *smallest        = NULL;
+               int           smallest_n_regs = env->cls->n_regs + 1;
+               be_operand_t *out_op          = &insn->ops[j];
 
                /* Try to find an in operand which has ... */
                for (i = insn->use_start; i < insn->n_ops; ++i) {
-                       int n_total;
-                       const be_operand_t *op = &insn->ops[i];
+                       int           n_total;
+                       be_operand_t *op = &insn->ops[i];
+                       be_lv_t      *lv;
 
                        if (op->partner != NULL)
                                continue;
-                       if (be_values_interfere(env->birg->lv, op->irn, op->carrier))
+                       lv = be_get_irg_liveness(env->irg);
+                       if (be_values_interfere(lv, op->irn, op->carrier))
                                continue;
 
-                       bitset_clear_all(bs);
                        bitset_copy(bs, op->regs);
                        bitset_and(bs, out_op->regs);
-                       n_total = bitset_popcnt(op->regs) + bitset_popcnt(out_op->regs);
+                       n_total = bitset_popcount(op->regs);
 
                        if (!bitset_is_empty(bs) && n_total < smallest_n_regs) {
-                               smallest = i;
+                               smallest        = op;
                                smallest_n_regs = n_total;
                        }
                }
 
-               if (smallest >= 0) {
-                       be_operand_t *partner = &insn->ops[smallest];
+               if (smallest != NULL) {
                        for (i = insn->use_start; i < insn->n_ops; ++i) {
-                               if (insn->ops[i].carrier == partner->carrier)
+                               if (insn->ops[i].carrier == smallest->carrier)
                                        insn->ops[i].partner = out_op;
                        }
 
-                       out_op->partner  = partner;
-                       partner->partner = out_op;
+                       out_op->partner   = smallest;
+                       smallest->partner = out_op;
                }
        }
 }
@@ -198,7 +179,7 @@ static ir_node *handle_constraints(be_chordal_alloc_env_t *alloc_env,
        int *assignment;
        pmap *partners;
        int i, n_alloc;
-       bitset_pos_t col;
+       unsigned col;
        const ir_edge_t *edge;
        ir_node *perm = NULL;
        //int match_res, cost;
@@ -311,11 +292,12 @@ static ir_node *handle_constraints(be_chordal_alloc_env_t *alloc_env,
                foreach_out_edge(perm, edge) {
                        int i;
                        ir_node *proj = get_edge_src_irn(edge);
+                       be_lv_t *lv   = be_get_irg_liveness(env->irg);
 
                        assert(is_Proj(proj));
 
-                       if (!be_values_interfere(env->birg->lv, proj, irn)
-                                       || pmap_contains(partners, proj))
+                       if (!be_values_interfere(lv, proj, irn)
+                           || pmap_contains(partners, proj))
                                continue;
 
                        /* don't insert a node twice */
@@ -351,6 +333,7 @@ static ir_node *handle_constraints(be_chordal_alloc_env_t *alloc_env,
        match_res = hungarian_solve(bp, assignment, &cost, 1);
        assert(match_res == 0 && "matching failed");
 #else
+       /*bipartite_dump_f(stderr, bp);*/
        bipartite_matching(bp, assignment);
 #endif
 
@@ -359,7 +342,7 @@ static ir_node *handle_constraints(be_chordal_alloc_env_t *alloc_env,
                const arch_register_t *reg;
                ir_node *irn;
 
-               assert(assignment[i] >= 0 && "there must have been a register assigned");
+               assert(assignment[i] >= 0 && "there must have been a register assigned (node not register pressure faithful?)");
                reg = arch_register_for_index(env->cls, assignment[i]);
                assert(! (reg->type & arch_register_type_ignore));
 
@@ -453,7 +436,7 @@ static void assign(ir_node *block, void *env_ptr)
        bitset_t *colors            = alloc_env->colors;
        bitset_t *in_colors         = alloc_env->in_colors;
        struct list_head *head      = get_block_border_head(env, block);
-       be_lv_t *lv                 = env->birg->lv;
+       be_lv_t *lv                 = be_get_irg_liveness(env->irg);
 
        const ir_node *irn;
        border_t *b;
@@ -556,13 +539,12 @@ void be_ra_chordal_color(be_chordal_env_t *chordal_env)
        be_chordal_alloc_env_t env;
        char buf[256];
        be_lv_t *lv;
-       be_irg_t *birg = chordal_env->birg;
        const arch_register_class_t *cls = chordal_env->cls;
 
        int colors_n          = arch_register_class_n_regs(cls);
        ir_graph *irg         = chordal_env->irg;
 
-       lv = be_assure_liveness(birg);
+       lv = be_assure_liveness(irg);
        be_liveness_assure_sets(lv);
        be_liveness_assure_chk(lv);
 
@@ -581,8 +563,8 @@ void be_ra_chordal_color(be_chordal_env_t *chordal_env)
        dom_tree_walk_irg(irg, constraints, NULL, &env);
 
        if (chordal_env->opts->dump_flags & BE_CH_DUMP_CONSTR) {
-               snprintf(buf, sizeof(buf), "-%s-constr", chordal_env->cls->name);
-               be_dump(chordal_env->irg, buf, dump_ir_block_graph_sched);
+               snprintf(buf, sizeof(buf), "%s-constr", chordal_env->cls->name);
+               dump_ir_graph(chordal_env->irg, buf);
        }
 
        be_timer_pop(T_CONSTR);