Changed spill offsets to spill entities

diff --git a/ir/be/benode.c b/ir/be/benode.c
index b1c6f59..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)
@@ -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, a->offset);
+//TODO                         ir_fprintf(f, "spill offset: %04x (%u)\n", a->offset, a->offset);
                        }
                        break;
        }

diff --git a/ir/be/benode_t.h b/ir/be/benode_t.h
index c3fb7ba..0bb7490 100644 (file)
--- a/ir/be/benode_t.h
+++ b/ir/be/benode_t.h
@@ -17,6 +17,7 @@
 
 #include "irmode.h"
 #include "irnode.h"
+#include "entity_t.h"
 
 #include "be_t.h"
 #include "bearch.h"
@@ -52,8 +53,8 @@ int be_is_Copy(const ir_node *irn);
 int be_is_Perm(const ir_node *irn);
 int be_is_Keep(const ir_node *irn);
 
-void     be_set_Spill_offset(ir_node *irn, unsigned offset);
-unsigned be_get_spill_offset(ir_node *irn);
+void   be_set_Spill_entity(ir_node *irn, entity *ent);
+entity *be_get_spill_entity(ir_node *irn);
 
 ir_node *be_get_Spill_context(const ir_node *irn);
 

diff --git a/ir/be/bespill.c b/ir/be/bespill.c
index f8df2a8..ee429ac 100644 (file)
--- a/ir/be/bespill.c
+++ b/ir/be/bespill.c
@@ -14,6 +14,9 @@
 #include "irnode_t.h"
 #include "ircons_t.h"
 #include "iredges_t.h"
+#include "ident_t.h"
+#include "type_t.h"
+#include "entity_t.h"
 #include "debug.h"
 #include "irgwalk.h"
 
@@ -279,8 +282,9 @@ void be_add_reload_on_edge(spill_env_t *senv, ir_node *to_spill, ir_node *bl, in
 
 typedef struct _spill_slot_t {
        unsigned size;
-       unsigned offset;
+       unsigned align;
        pset *members;
+       ir_mode *largest_mode;  /* the mode of all members with largest size */
 } spill_slot_t;
 
 typedef struct _ss_env_t {
@@ -308,13 +312,15 @@ static void compute_spill_slots_walker(ir_node *spill, void *env) {
                /* this is a new spill context */
                ss = obstack_alloc(&ssenv->ob, sizeof(*ss));
                ss->members = pset_new_ptr(8);
-               ss->size = get_mode_size_bytes(get_irn_mode(get_irn_n(spill, 0)));
+               ss->largest_mode = get_irn_mode(get_irn_n(spill, 0));
+               ss->size = get_mode_size_bytes(ss->largest_mode);
+               ss->align = ss->size; /* TODO Assumed for now */
                pmap_insert(ssenv->slots, ctx, ss);
        } else {
                ir_node *irn;
                /* values with the same spill_ctx must go into the same spill slot */
                ss = entry->value;
-               assert(ss->size == (unsigned)get_mode_size_bytes(get_irn_mode(get_irn_n(spill, 0))) && "Different sizes for the same spill slot");
+               assert(ss->size == (unsigned)get_mode_size_bytes(get_irn_mode(get_irn_n(spill, 0))) && "Different sizes for the same spill slot are not allowed yet.");
                for (irn = pset_first(ss->members); irn; irn = pset_next(ss->members)) {
                        /* use values_interfere here, because it uses the dominance check,
                           which does work for values in memory */
@@ -332,19 +338,20 @@ static int ss_sorter(const void *v1, const void *v2) {
 }
 
 
-/* NOTE/TODO: This function assumes, that all spill slot sizes are a power of 2.
-   Further it assumes, that the alignment is equal to the size and the
-   baseaddr of the spill area is aligned sufficiently for all possible aligments.
-*/
-static void coalesce_slots(ss_env_t *ssenv) {
+/**
+ * This function should optimize the spill slots.
+ *  - Coalescing of multiple slots
+ *  - Ordering the slots
+ *
+ * Input slots are in @p ssenv->slots
+ * @p size The count of initial spill slots in @p ssenv->slots
+ *         This also is the size of the preallocated array @p ass
+ *
+ * @return An array of spill slots @p ass in specific order
+ **/
+static void optimize_slots(ss_env_t *ssenv, int size, spill_slot_t **ass) {
        int i, o, used_slots;
-       unsigned curr_offset;
        pmap_entry *entr;
-       spill_slot_t **ass;
-
-       /* Build an array of all spill slots */
-       int count = pmap_count(ssenv->slots);
-       ass = obstack_alloc(&ssenv->ob, count * sizeof(*ass));
 
        i=0;
        pmap_foreach(ssenv->slots, entr)
@@ -352,14 +359,13 @@ static void coalesce_slots(ss_env_t *ssenv) {
 
        /* Sort the array to minimize fragmentation and cache footprint.
           Large slots come first */
-       qsort(ass, count, sizeof(ass[0]), ss_sorter);
+       qsort(ass, size, sizeof(ass[0]), ss_sorter);
 
        /* For each spill slot:
                - assign a new offset to this slot
            - xor find another slot to coalesce with */
-       curr_offset = 0;
        used_slots = 0;
-       for (i=0; i<count; ++i) { /* for each spill slot */
+       for (i=0; i<size; ++i) { /* for each spill slot */
                ir_node *n1;
                int tgt_slot = -1;
 
@@ -393,9 +399,6 @@ interf_detected: /*nothing*/ ;
                        tgt_slot = used_slots;
                        used_slots++;
 
-                       ass[tgt_slot]->offset = curr_offset;
-                       curr_offset += ass[i]->size;
-
                        /* init slot */
                        if (tgt_slot != i) {
                                ass[tgt_slot]->size = ass[i]->size;
@@ -405,33 +408,80 @@ interf_detected: /*nothing*/ ;
                }
 
                /* copy the members to the target pset */
-               for(n1 = pset_first(ass[i]->members); n1; n1 = pset_next(ass[i]->members)) {
-                       /* NOTE: If src and tgt pset are the same, inserting while iterating is not allowed */
-                       if (tgt_slot != i)
-                               pset_insert_ptr(ass[tgt_slot]->members, n1);
-
-                       be_set_Spill_offset(n1, ass[tgt_slot]->offset);
-                       DBG((ssenv->dbg, LEVEL_1, "    Offset %+F  %d\n", n1, ass[tgt_slot]->offset));
-               }
+               /* NOTE: If src and tgt pset are the same, inserting while iterating is not allowed */
+               if (tgt_slot != i)
+                       for(n1 = pset_first(ass[i]->members); n1; n1 = pset_next(ass[i]->members))
+                                       pset_insert_ptr(ass[tgt_slot]->members, n1);
        }
+}
+
+#define ALIGN_SPILL_AREA 16
+#define pset_foreach(pset, elm)  for(elm=pset_first(pset); elm; elm=pset_next(pset))
+
+static void assign_entities(ss_env_t *ssenv, int n, spill_slot_t **ss) {
+       int i, offset;
+       ir_type *frame = get_irg_frame_type(ssenv->cenv->irg);
 
-       /* free all used psets, all other stuff is on the ssenv-obstack */
-       for (i=0; i<count; ++i)
-               del_pset(ass[i]->members);
+       /* aligning by increasing frame size */
+       offset = get_type_size_bits(frame) / 8;
+       offset = round_up2(offset, ALIGN_SPILL_AREA);
+       set_type_size_bytes(frame, -1);
 
+       /* create entities and assign offsets according to size and alignment*/
+       for (i=0; i<n; ++i) {
+               char buf[64];
+               ident *name, *type_id;
+               entity *spill_ent;
+               ir_node *irn;
+
+               /* build entity */
+               snprintf(buf, sizeof(buf), "spill_slot_%d", i);
+               name = new_id_from_str(buf);
+               snprintf(buf, sizeof(buf), "spill_slot_type_%d", i);
+               type_id = new_id_from_str(buf);
+
+               spill_ent = new_entity(frame, name, new_type_primitive(type_id, ss[i]->largest_mode));
+
+               /* align */
+               offset = round_up2(offset, ss[i]->align);
+               /* set */
+               set_entity_offset_bytes(spill_ent, offset);
+               /* next possible offset */
+               offset += ss[i]->size;
+
+               pset_foreach(ss[i]->members, irn)
+                       be_set_Spill_entity(irn, spill_ent);
+       }
+
+       /* set final size of stack frame */
+       set_type_size_bytes(frame, offset);
 }
 
 void be_compute_spill_offsets(be_chordal_env_t *cenv) {
        ss_env_t ssenv;
+       spill_slot_t **ss;
+       int ss_size;
+       pmap_entry *pme;
 
        obstack_init(&ssenv.ob);
        ssenv.cenv  = cenv;
        ssenv.slots = pmap_create();
        ssenv.dbg   = firm_dbg_register("ir.be.spillslots");
 
+       /* Get initial spill slots */
        irg_walk_graph(cenv->irg, NULL, compute_spill_slots_walker, &ssenv);
-       coalesce_slots(&ssenv);
 
+       /* Build an empty array for optimized spill slots */
+       ss_size = pmap_count(ssenv.slots);
+       ss = obstack_alloc(&ssenv.ob, ss_size * sizeof(*ss));
+       optimize_slots(&ssenv, ss_size, ss);
+
+       /* Integrate slots into the stack frame entity */
+       assign_entities(&ssenv, ss_size, ss);
+
+       /* Clean up */
+       pmap_foreach(ssenv.slots, pme)
+               del_pset(((spill_slot_t *)pme->value)->members);
        pmap_destroy(ssenv.slots);
        obstack_free(&ssenv.ob, NULL);
 }