s/keeped/kept/.

[libfirm] / ir / be / bechordal.c

diff --git a/ir/be/bechordal.c b/ir/be/bechordal.c
index 2f56341..e54586a 100644 (file)
--- a/ir/be/bechordal.c
+++ b/ir/be/bechordal.c
@@ -77,9 +77,9 @@ typedef struct be_chordal_alloc_env_t {
        be_chordal_env_t *chordal_env;
 
        pset *pre_colored;     /**< Set of precolored nodes. */
-       bitset_t *live;            /**< A liveness bitset. */
+       bitset_t *live;        /**< A liveness bitset. */
        bitset_t *tmp_colors;  /**< An auxiliary bitset which is as long as the number of colors in the class. */
-       bitset_t *colors;          /**< The color mask. */
+       bitset_t *colors;      /**< The color mask. */
        bitset_t *in_colors;   /**< Colors used by live in values. */
        int colors_n;          /**< The number of colors. */
 } be_chordal_alloc_env_t;
@@ -88,8 +88,9 @@ static int get_next_free_reg(const be_chordal_alloc_env_t *alloc_env, bitset_t *
 {
        bitset_t *tmp = alloc_env->tmp_colors;
        bitset_copy(tmp, colors);
-       bitset_or(tmp, alloc_env->chordal_env->ignore_colors);
-       return bitset_next_clear(tmp, 0);
+       bitset_flip_all(tmp);
+       bitset_and(tmp, alloc_env->chordal_env->allocatable_regs);
+       return bitset_next_set(tmp, 0);
 }
 
 static bitset_t *get_decisive_partner_regs(bitset_t *bs, const be_operand_t *o1, const be_operand_t *o2)
@@ -170,7 +171,7 @@ static void pair_up_operands(const be_chordal_alloc_env_t *alloc_env, be_insn_t
 }
 
 static ir_node *handle_constraints(be_chordal_alloc_env_t *alloc_env,
-                                   ir_node *irn, int *silent)
+                                   ir_node *irn)
 {
        int n_regs;
        bitset_t *bs;
@@ -179,7 +180,7 @@ static ir_node *handle_constraints(be_chordal_alloc_env_t *alloc_env,
        int *assignment;
        pmap *partners;
        int i, n_alloc;
-       unsigned col;
+       size_t col;
        const ir_edge_t *edge;
        ir_node *perm = NULL;
        //int match_res, cost;
@@ -187,7 +188,6 @@ static ir_node *handle_constraints(be_chordal_alloc_env_t *alloc_env,
        void *base             = obstack_base(env->obst);
        be_insn_t *insn        = chordal_scan_insn(env, irn);
        ir_node *res           = insn->next_insn;
-       int be_silent          = *silent;
        bipartite_t *bp;
 
        if (insn->pre_colored) {
@@ -196,19 +196,6 @@ static ir_node *handle_constraints(be_chordal_alloc_env_t *alloc_env,
                        pset_insert_ptr(alloc_env->pre_colored, insn->ops[i].carrier);
        }
 
-       /*
-        * If the current node is a barrier toggle the silent flag.
-        * If we are in the start block, we are ought to be silent at the beginning,
-        * so the toggling activates the constraint handling but skips the barrier.
-        * If we are in the end block we handle the in requirements of the barrier
-        * and set the rest to silent.
-        */
-       if (be_is_Barrier(irn))
-               *silent = !*silent;
-
-       if (be_silent)
-               goto end;
-
        /*
         * Perms inserted before the constraint handling phase are considered to be
         * correctly precolored. These Perms arise during the ABI handling phase.
@@ -315,10 +302,7 @@ static ir_node *handle_constraints(be_chordal_alloc_env_t *alloc_env,
                        alloc_nodes[n_alloc] = proj;
                        pmap_insert(partners, proj, NULL);
 
-                       bitset_clear_all(bs);
-                       arch_put_non_ignore_regs(env->cls, bs);
-                       bitset_andnot(bs, env->ignore_colors);
-                       bitset_foreach(bs, col) {
+                       bitset_foreach(env->allocatable_regs, col) {
                                //hungarian_add(bp, n_alloc, col, 1);
                                bipartite_add(bp, n_alloc, col);
                        }
@@ -344,7 +328,6 @@ static ir_node *handle_constraints(be_chordal_alloc_env_t *alloc_env,
 
                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));
 
                irn = alloc_nodes[i];
                if (irn != NULL) {
@@ -353,7 +336,7 @@ static ir_node *handle_constraints(be_chordal_alloc_env_t *alloc_env,
                        DBG((dbg, LEVEL_2, "\tsetting %+F to register %s\n", irn, reg->name));
                }
 
-               irn = pmap_get(partners, alloc_nodes[i]);
+               irn = (ir_node*)pmap_get(partners, alloc_nodes[i]);
                if (irn != NULL) {
                        arch_set_irn_register(irn, reg);
                        (void) pset_hinsert_ptr(alloc_env->pre_colored, irn);
@@ -410,27 +393,17 @@ end:
  */
 static void constraints(ir_node *bl, void *data)
 {
-       /*
-        * Start silent in the start block.
-        * The silence remains until the first barrier is seen.
-        * Each other block is begun loud.
-        */
-       int                     silent = bl == get_irg_start_block(get_irn_irg(bl));
-       be_chordal_alloc_env_t *env    = data;
+       be_chordal_alloc_env_t *env    = (be_chordal_alloc_env_t*)data;
        ir_node                *irn;
 
-       /*
-        * If the block is the start block search the barrier and
-        * start handling constraints from there.
-        */
        for (irn = sched_first(bl); !sched_is_end(irn);) {
-               irn = handle_constraints(env, irn, &silent);
+               irn = handle_constraints(env, irn);
        }
 }
 
 static void assign(ir_node *block, void *env_ptr)
 {
-       be_chordal_alloc_env_t *alloc_env = env_ptr;
+       be_chordal_alloc_env_t *alloc_env = (be_chordal_alloc_env_t*)env_ptr;
        be_chordal_env_t *env       = alloc_env->chordal_env;
        bitset_t *live              = alloc_env->live;
        bitset_t *colors            = alloc_env->colors;
@@ -504,7 +477,6 @@ static void assign(ir_node *block, void *env_ptr)
                                col = get_next_free_reg(alloc_env, colors);
                                reg = arch_register_for_index(env->cls, col);
                                assert(arch_get_irn_register(irn) == NULL && "This node must not have been assigned a register yet");
-                               assert(!arch_register_type_is(reg, ignore) && "Must not assign ignore register");
                        }
 
                        bitset_set(colors, col);
@@ -522,11 +494,6 @@ static void assign(ir_node *block, void *env_ptr)
                        assert(reg && "Register must have been assigned");
 
                        col = arch_register_get_index(reg);
-#ifndef NDEBUG
-                       if (!arch_register_type_is(reg, ignore)) {
-                               assert(bitset_is_set(live, nr) && "Cannot have a non live use");
-                       }
-#endif
 
                        bitset_clear(colors, col);
                        bitset_clear(live, nr);