changed DBG usage

[libfirm] / ir / be / benode.c

diff --git a/ir/be/benode.c b/ir/be/benode.c
index 0f8555f..b4a0dcd 100644 (file)
--- a/ir/be/benode.c
+++ b/ir/be/benode.c
@@ -73,8 +73,7 @@ typedef struct {
 typedef struct {
        be_node_attr_t node_attr;
        ir_node *spill_ctx;  /**< The node in whose context this spill was introduced. */
-       unsigned offset;     /**< The offset of the memory location the spill writes to
-                                                  in the spill area. */
+       entity *ent;     /**< The entity in the stack frame the spill writes to. */
 } be_spill_attr_t;
 
 static ir_op *op_Spill;
@@ -156,7 +155,7 @@ ir_node *be_new_Spill(const arch_register_class_t *cls, ir_graph *irg, ir_node *
        in[0] = to_spill;
        res   = new_ir_node(NULL, irg, bl, op_Spill, mode_M, 1, in);
        a     = init_node_attr(res, cls, irg, 0);
-       a->offset    = BE_SPILL_NO_OFFSET;
+       a->ent    = NULL;
        a->spill_ctx = ctx;
        return res;
 }
@@ -234,11 +233,11 @@ void be_set_Perm_out_req(ir_node *irn, int pos, const arch_register_req_t *req)
        memcpy(&a->reg_data[pos].req, req, sizeof(req[0]));
 }
 
-void be_set_Spill_offset(ir_node *irn, unsigned offset)
+void be_set_Spill_entity(ir_node *irn, entity *ent)
 {
        be_spill_attr_t *a = get_irn_attr(irn);
        assert(be_is_Spill(irn));
-       a->offset = offset;
+       a->ent = ent;
 }
 
 static ir_node *find_a_spill_walker(ir_node *irn, unsigned visited_nr)
@@ -285,23 +284,23 @@ static INLINE ir_node *find_a_spill(ir_node *irn)
 }
 
 
-unsigned be_get_spill_offset(ir_node *irn)
+entity *be_get_spill_entity(ir_node *irn)
 {
        int opc           = get_irn_opcode(irn);
 
        switch(get_irn_be_opcode(irn)) {
        case beo_Reload:
-               return be_get_spill_offset(find_a_spill(irn));
+               return be_get_spill_entity(find_a_spill(irn));
        case beo_Spill:
                {
                        be_spill_attr_t *a = get_irn_attr(irn);
-                       return a->offset;
+                       return a->ent;
                }
        default:
                assert(0 && "Must give spill/reload node");
        }
 
-       return (unsigned) -1;
+       return NULL;
 }
 
 ir_node *be_spill(const arch_env_t *arch_env, ir_node *irn, ir_node *ctx)
@@ -425,7 +424,7 @@ be_node_set_irn_reg(const void *_self, ir_node *irn, const arch_register_t *reg)
        int out_pos;
        be_node_attr_t *a;
 
-       out_pos = redir_proj(&irn, -1);
+       out_pos = redir_proj((const ir_node **) &irn, -1);
        a       = get_irn_attr(irn);
 
        assert(is_be_node(irn));
@@ -439,7 +438,7 @@ be_node_get_irn_reg(const void *_self, const ir_node *irn)
        int out_pos;
        be_node_attr_t *a;
 
-       out_pos = redir_proj(&irn, -1);
+       out_pos = redir_proj((const ir_node **) &irn, -1);
        a       = get_irn_attr(irn);
 
        assert(is_be_node(irn));
@@ -450,7 +449,7 @@ be_node_get_irn_reg(const void *_self, const ir_node *irn)
 
 arch_irn_class_t be_node_classify(const void *_self, const ir_node *irn)
 {
-       redir_proj(&irn, -1);
+       redir_proj((const ir_node **) &irn, -1);
 
        switch(get_irn_be_opcode(irn)) {
 #define XXX(a,b) case beo_ ## a: return arch_irn_class_ ## b;
@@ -519,7 +518,7 @@ static int dump_node(ir_node *irn, FILE *f, dump_reason_t reason)
                        if(get_irn_be_opcode(irn) == beo_Spill) {
                                be_spill_attr_t *a = (be_spill_attr_t *) at;
                                ir_fprintf(f, "spill context: %+F\n", a->spill_ctx);
-                               ir_fprintf(f, "spill offset: %04x (%u)\n", a->offset);
+//TODO                         ir_fprintf(f, "spill offset: %04x (%u)\n", a->offset, a->offset);
                        }
                        break;
        }
@@ -543,38 +542,29 @@ static const ir_op_ops be_node_op_ops = {
        NULL
 };
 
-ir_node *insert_Perm_after(const arch_env_t *arch_env,
-                                                  const arch_register_class_t *cls,
-                                                  dom_front_info_t *dom_front,
-                                                  ir_node *pos)
+pset *nodes_live_at(const arch_env_t *arch_env, const arch_register_class_t *cls, const ir_node *pos, pset *live)
 {
-       ir_node *bl                 = is_Block(pos) ? pos : get_nodes_block(pos);
-       ir_graph *irg               = get_irn_irg(bl);
-       pset *live                  = pset_new_ptr_default();
-       firm_dbg_module_t *dbg      = firm_dbg_register("be.node");
-
+       firm_dbg_module_t *dbg = firm_dbg_register("firm.be.node");
+       ir_node *bl            = get_nodes_block(pos);
+       ir_node *irn;
        irn_live_t *li;
-       ir_node *curr, *irn, *perm, **nodes;
-       int i, n;
-
-       DBG((dbg, LEVEL_1, "Insert Perm after: %+F\n", pos));
-
 
        live_foreach(bl, li) {
                ir_node *irn = (ir_node *) li->irn;
-               if(live_is_end(li) && arch_irn_has_reg_class(arch_env, irn, -1, cls))
+               if(live_is_end(li) && arch_irn_consider_in_reg_alloc(arch_env, cls, irn))
                        pset_insert_ptr(live, irn);
        }
 
        sched_foreach_reverse(bl, irn) {
+               int i, n;
                ir_node *x;
 
-       /*
-        * If we encounter the node we want to insert the Perm after,
-        * exit immediately, so that this node is still live
-        */
+               /*
+                * If we encounter the node we want to insert the Perm after,
+               * exit immediately, so that this node is still live
+               */
                if(irn == pos)
-                       break;
+                       return live;
 
                DBG((dbg, LEVEL_1, "%+F\n", irn));
                for(x = pset_first(live); x; x = pset_next(live))
@@ -586,11 +576,32 @@ ir_node *insert_Perm_after(const arch_env_t *arch_env,
                for(i = 0, n = get_irn_arity(irn); i < n; ++i) {
                        ir_node *op = get_irn_n(irn, i);
 
-                       if(arch_irn_has_reg_class(arch_env, op, -1, cls))
+                       if(arch_irn_consider_in_reg_alloc(arch_env, cls, op))
                                pset_insert_ptr(live, op);
                }
        }
 
+       return NULL;
+}
+
+ir_node *insert_Perm_after(const arch_env_t *arch_env,
+                                                  const arch_register_class_t *cls,
+                                                  dom_front_info_t *dom_front,
+                                                  ir_node *pos)
+{
+       ir_node *bl                 = is_Block(pos) ? pos : get_nodes_block(pos);
+       ir_graph *irg               = get_irn_irg(bl);
+       pset *live                  = pset_new_ptr_default();
+       firm_dbg_module_t *dbg      = firm_dbg_register("be.node");
+
+       ir_node *curr, *irn, *perm, **nodes;
+       int i, n;
+
+       DBG((dbg, LEVEL_1, "Insert Perm after: %+F\n", pos));
+
+       if(!nodes_live_at(arch_env, cls, pos, live))
+               assert(0 && "position not found");
+
        n = pset_count(live);
 
        if(n == 0)