added support for unaligned entities

[libfirm] / ir / be / bespillmorgan.c

diff --git a/ir/be/bespillmorgan.c b/ir/be/bespillmorgan.c
index e931929..183ef81 100644 (file)
--- a/ir/be/bespillmorgan.c
+++ b/ir/be/bespillmorgan.c
@@ -33,6 +33,7 @@
 #include "irgraph_t.h"
 #include "irprintf.h"
 #include "obst.h"
+#include "error.h"
 
 #include "bespillmorgan.h"
 #include "bechordal_t.h"
@@ -59,7 +60,7 @@ typedef struct morgan_env {
        const arch_env_t *arch;
        const arch_register_class_t *cls;
        ir_graph *irg;
-       const be_lv_t *lv;
+       be_lv_t *lv;
        struct obstack obst;
        /** maximum safe register pressure */
        int registers_available;
@@ -91,23 +92,26 @@ typedef struct morgan_block_attr {
 
 //---------------------------------------------------------------------------
 
-static int loop_edge_cmp(const void* p1, const void* p2, size_t s) {
+static int loop_edge_cmp(const void* p1, const void* p2, size_t size) {
        loop_edge_t *e1 = (loop_edge_t*) p1;
        loop_edge_t *e2 = (loop_edge_t*) p2;
+       (void) size;
 
        return e1->block != e2->block || e1->pos != e2->pos;
 }
 
-static int loop_attr_cmp(const void *e1, const void *e2, size_t s) {
+static int loop_attr_cmp(const void *e1, const void *e2, size_t size) {
        loop_attr_t *la1 = (loop_attr_t*) e1;
        loop_attr_t *la2 = (loop_attr_t*) e2;
+       (void) size;
 
        return la1->loop != la2->loop;
 }
 
-static int block_attr_cmp(const void *e1, const void *e2, size_t s) {
+static int block_attr_cmp(const void *e1, const void *e2, size_t size) {
        block_attr_t *b1 = (block_attr_t*) e1;
        block_attr_t *b2 = (block_attr_t*) e2;
+       (void) size;
 
        return b1->block != b2->block;
 }
@@ -311,7 +315,10 @@ static void construct_block_livethrough_unused(ir_node *block, void *data) {
        /*
         * All values that are used within the block are not unused (and therefore not
         * livethrough_unused)
+        *
+        * TODO FIXME use block out edges and not schedule to find uses
         */
+       panic("needs fixing");
        sched_foreach(block, node) {
                int i, arity;
 
@@ -420,6 +427,7 @@ static void spill_values(morgan_env_t *env, const loop_attr_t *loop_attr, int sp
        const bitset_t *cand_bitset = loop_attr->livethrough_unused;
        int candidatecount = bitset_popcnt(cand_bitset);
        spillcandidate_t *candidates;
+       bitset_pos_t idx;
        int i, c;
        loop_edge_t *edge;
 
@@ -430,8 +438,8 @@ static void spill_values(morgan_env_t *env, const loop_attr_t *loop_attr, int sp
        DBG((dbg, DBG_CHOOSE, "Candidates for loop %d\n", get_loop_loop_nr(loop_attr->loop)));
        // build candidiatelist
        c = 0;
-       bitset_foreach(cand_bitset, i) {
-               ir_node *node = get_idx_irn(env->irg, i);
+       bitset_foreach(cand_bitset, idx) {
+               ir_node *node = get_idx_irn(env->irg, idx);
                candidates[c].node = node;
                candidates[c].cost = 0;
 
@@ -462,11 +470,13 @@ static int reduce_register_pressure_in_block(morgan_env_t *env, const ir_node* b
        ir_node *node;
        int max_pressure;
        int loop_unused_spills_needed;
-       pset *live_nodes = pset_new_ptr_default();
+       ir_nodeset_t live_nodes;
        const be_lv_t *lv = env->lv;
 
-       be_liveness_end_of_block(lv, env->arch, env->cls, block, live_nodes);
-       max_pressure = pset_count(live_nodes);
+       ir_nodeset_init(&live_nodes);
+
+       be_liveness_end_of_block(lv, env->arch, env->cls, block, &live_nodes);
+       max_pressure = ir_nodeset_size(&live_nodes);
 
        DBG((dbg, DBG_LIVE, "Reduce pressure to %d In Block %+F:\n", env->registers_available, block));
 
@@ -479,12 +489,12 @@ static int reduce_register_pressure_in_block(morgan_env_t *env, const ir_node* b
                if(is_Phi(node))
                        break;
 
-               be_liveness_transfer(env->arch, env->cls, node, live_nodes);
-               pressure = pset_count(live_nodes);
+               be_liveness_transfer(env->arch, env->cls, node, &live_nodes);
+               pressure = ir_nodeset_size(&live_nodes);
                if(pressure > max_pressure)
                        max_pressure = pressure;
        }
-       del_pset(live_nodes);
+       ir_nodeset_destroy(&live_nodes);
 
        loop_unused_spills_needed = max_pressure - env->registers_available;
 
@@ -564,7 +574,7 @@ void be_spill_morgan(be_irg_t *birg, const arch_register_class_t *cls) {
        ir_graph     *irg = be_get_birg_irg(birg);
        morgan_env_t env;
 
-       be_assure_liveness(birg);
+       be_liveness_assure_sets(be_assure_liveness(birg));
 
        env.arch = birg->main_env->arch_env;
        env.irg  = irg;