Remove the unused function be_RegParams_append_out_reg().

[libfirm] / ir / be / bespillslots.c

diff --git a/ir/be/bespillslots.c b/ir/be/bespillslots.c
index 43149be..760b656 100644 (file)
--- a/ir/be/bespillslots.c
+++ b/ir/be/bespillslots.c
@@ -43,7 +43,6 @@
 #include "besched.h"
 #include "bespillslots.h"
 #include "bechordal_t.h"
-#include "bejavacoal.h"
 #include "bestatevent.h"
 #include "bespilloptions.h"
 #include "bemodule.h"
@@ -127,12 +126,7 @@ static spill_t *collect_spill(be_fec_env_t *env, ir_node *node,
                                      const ir_mode *mode, int align)
 {
        spill_t spill, *res;
-       int     hash;
-
-       /* beware: although untypical there might be store nodes WITH Proj's,
-          vfisttp in ia32 for instance */
-       node = skip_Proj(node);
-       hash = hash_irn(node);
+       int     hash = hash_irn(node);
 
        /* insert into set of spills if not already there */
        spill.spill = node;
@@ -143,6 +137,7 @@ static spill_t *collect_spill(be_fec_env_t *env, ir_node *node,
                spill.mode      = mode;
                spill.alignment = align;
                res             = set_insert(env->spills, &spill, sizeof(spill), hash);
+               DB((dbg, DBG_COALESCING, "Slot %d: %+F\n", spill.spillslot, node));
        } else {
                assert(res->mode == mode);
                assert(res->alignment == align);
@@ -172,6 +167,7 @@ static spill_t *collect_memphi(be_fec_env_t *env, ir_node *node,
        spill.spillslot = set_count(env->spills);
        spill.mode      = mode;
        spill.alignment = align;
+       DB((dbg, DBG_COALESCING, "Slot %d: %+F\n", spill.spillslot, node));
        res             = set_insert(env->spills, &spill, sizeof(spill), hash);
 
        /* collect attached spills and mem-phis */
@@ -359,7 +355,7 @@ static void do_greedy_coalescing(be_fec_env_t *env)
        if(spillcount == 0)
                return;
 
-       DBG((dbg, DBG_COALESCING, "Coalescing %d spillslots\n", spillcount));
+       DB((dbg, DBG_COALESCING, "Coalescing %d spillslots\n", spillcount));
 
        interferences       = alloca(spillcount * sizeof(interferences[0]));
        spillslot_unionfind = alloca(spillcount * sizeof(spillslot_unionfind[0]));
@@ -395,7 +391,7 @@ static void do_greedy_coalescing(be_fec_env_t *env)
                                continue;
 
                        if (my_values_interfere(env->birg, spill1, spill2)) {
-                               DBG((dbg, DBG_INTERFERENCES,
+                               DB((dbg, DBG_INTERFERENCES,
                                     "Slot %d and %d interfere\n", i, i2));
 
                                bitset_set(interferences[i], i2);
@@ -423,7 +419,7 @@ static void do_greedy_coalescing(be_fec_env_t *env)
                        continue;
                }
 
-               DBG((dbg, DBG_COALESCING,
+               DB((dbg, DBG_COALESCING,
                     "Merging %d and %d because of affinity edge\n", s1, s2));
 
                merge_interferences(env, interferences, spillslot_unionfind, s1, s2);
@@ -449,7 +445,7 @@ static void do_greedy_coalescing(be_fec_env_t *env)
                                continue;
                        }
 
-                       DBG((dbg, DBG_COALESCING,
+                       DB((dbg, DBG_COALESCING,
                             "Merging %d and %d because it is possible\n", s1, s2));
 
                        if(merge_interferences(env, interferences, spillslot_unionfind, s1, s2) != 0) {
@@ -524,7 +520,10 @@ static ir_entity* create_stack_entity(be_fec_env_t *env, spill_slot_t *slot)
 {
        ir_graph *irg = be_get_birg_irg(env->birg);
        ir_type *frame = get_irg_frame_type(irg);
-       ir_entity *res = frame_alloc_area(frame, slot->size, slot->align, 0);
+       /* TODO: backend should be able to specify wether we want spill slots
+        * at begin or end of frame */
+       int        at_start = 1;
+       ir_entity *res = frame_alloc_area(frame, slot->size, slot->align, at_start);
 
        /* adjust size of the entity type... */
        ir_type *enttype = get_entity_type(res);
@@ -555,8 +554,7 @@ static void enlarge_spillslot(spill_slot_t *slot, int otheralign, int othersize)
 }
 
 
-static void assign_spill_entity(const arch_env_t *arch_env, ir_node *node,
-                                ir_entity *entity)
+static void assign_spill_entity(ir_node *node, ir_entity *entity)
 {
        if(is_NoMem(node))
                return;
@@ -568,13 +566,15 @@ static void assign_spill_entity(const arch_env_t *arch_env, ir_node *node,
                        ir_node *in = get_irn_n(node, i);
                        assert(!is_Phi(in));
 
-                       assign_spill_entity(arch_env, in, entity);
+                       assign_spill_entity(in, entity);
                }
                return;
        }
 
-       assert(arch_get_frame_entity(arch_env, node) == NULL);
-       arch_set_frame_entity(arch_env, node, entity);
+       /* beware: we might have Stores with Memory Proj's, ia32 fisttp for instance */
+       node = skip_Proj(node);
+       assert(arch_get_frame_entity(node) == NULL);
+       arch_set_frame_entity(node, entity);
 }
 
 /**
@@ -583,7 +583,6 @@ static void assign_spill_entity(const arch_env_t *arch_env, ir_node *node,
  */
 static void assign_spillslots(be_fec_env_t *env)
 {
-       const arch_env_t *arch_env = env->arch_env;
        int i;
        int spillcount;
        spill_t *spill;
@@ -662,19 +661,19 @@ static void assign_spillslots(be_fec_env_t *env)
                                }
                        }
                } else {
-                       assign_spill_entity(arch_env, node, slot->entity);
+                       assign_spill_entity(node, slot->entity);
                }
        }
 
        for(i = 0; i < ARR_LEN(env->reloads); ++i) {
                ir_node            *reload    = env->reloads[i];
-               ir_node            *spillnode = skip_Proj(get_memory_edge(reload));
+               ir_node            *spillnode = get_memory_edge(reload);
                spill_t            *spill     = get_spill(env, spillnode);
                const spill_slot_t *slot      = & spillslots[spill->spillslot];
 
                assert(slot->entity != NULL);
 
-               arch_set_frame_entity(arch_env, reload, slot->entity);
+               arch_set_frame_entity(reload, slot->entity);
        }
 }
 
@@ -766,8 +765,8 @@ static int count_spillslots(const be_fec_env_t *env)
 
 be_fec_env_t *be_new_frame_entity_coalescer(be_irg_t *birg)
 {
-       const arch_env_t *arch_env = &birg->main_env->arch_env;
-       be_fec_env_t     *env      = xmalloc(sizeof(env[0]));
+       const arch_env_t *arch_env = birg->main_env->arch_env;
+       be_fec_env_t     *env      = XMALLOC(be_fec_env_t);
 
        be_liveness_assure_chk(be_assure_liveness(birg));
 
@@ -815,7 +814,6 @@ void be_assign_entities(be_fec_env_t *env)
 static void collect_spills_walker(ir_node *node, void *data)
 {
        be_fec_env_t *env = data;
-       const arch_env_t *arch_env = env->arch_env;
        const ir_mode *mode;
        const arch_register_class_t *cls;
        int align;
@@ -824,12 +822,12 @@ static void collect_spills_walker(ir_node *node, void *data)
        if (is_Proj(node))
                return;
 
-       if (!arch_irn_class_is(arch_env, node, reload))
+       if (!arch_irn_class_is(node, reload))
                return;
 
        mode  = get_irn_mode(node);
-       cls   = arch_get_irn_reg_class(arch_env, node, -1);
-       align = arch_isa_get_reg_class_alignment(arch_env_get_isa(arch_env), cls);
+       cls   = arch_get_irn_reg_class(node, -1);
+       align = arch_env_get_reg_class_alignment(env->arch_env, cls);
 
        be_node_needs_frame_entity(env, node, mode, align);
 }