allow several odd weak combinations

[libfirm] / ir / be / bespillslots.c

diff --git a/ir/be/bespillslots.c b/ir/be/bespillslots.c
index 9825155..6265111 100644 (file)
--- a/ir/be/bespillslots.c
+++ b/ir/be/bespillslots.c
@@ -24,9 +24,7 @@
  * @date        26.07.2006
  * @version     $Id$
  */
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
 
 #include <stdlib.h>
 
@@ -39,17 +37,16 @@
 #include "unionfind.h"
 #include "irdump_t.h"
 
-#include "benode_t.h"
+#include "benode.h"
 #include "besched.h"
+#include "bespill.h"
 #include "bespillslots.h"
 #include "bechordal_t.h"
-#include "bejavacoal.h"
 #include "bestatevent.h"
-#include "bespilloptions.h"
 #include "bemodule.h"
 #include "beintlive_t.h"
-#include "beirg_t.h"
-#include "bearch_t.h"
+#include "beirg.h"
+#include "bearch.h"
 
 #define DBG_COALESCING         1
 #define DBG_INTERFERENCES      2
@@ -109,7 +106,7 @@ static spill_t *get_spill(be_fec_env_t *env, ir_node *node)
 }
 
 
-static INLINE ir_node *get_memory_edge(const ir_node *node)
+static inline ir_node *get_memory_edge(const ir_node *node)
 {
        int i, arity;
 
@@ -185,7 +182,7 @@ static spill_t *collect_memphi(be_fec_env_t *env, ir_node *node,
                }
 
                /* add an affinity edge */
-               affinty_edge           = obstack_alloc(&env->obst, sizeof(affinty_edge[0]));
+               affinty_edge           = OALLOC(&env->obst, affinity_edge_t);
                affinty_edge->affinity = get_block_execfreq(exec_freq, get_nodes_block(arg));
                affinty_edge->slot1    = res->spillslot;
                affinty_edge->slot2    = arg_spill->spillslot;
@@ -225,7 +222,7 @@ static int merge_interferences(be_fec_env_t *env, bitset_t** interferences,
        /* merge spillslots and interferences */
        res = uf_union(spillslot_unionfind, s1, s2);
        /* we assume that we always merge s2 to s1 so swap s1, s2 if necessary */
-       if(res != 0) {
+       if(res != s1) {
                int t = s1;
                s1 = s2;
                s2 = t;
@@ -358,11 +355,11 @@ static void do_greedy_coalescing(be_fec_env_t *env)
 
        DB((dbg, DBG_COALESCING, "Coalescing %d spillslots\n", spillcount));
 
-       interferences       = alloca(spillcount * sizeof(interferences[0]));
-       spillslot_unionfind = alloca(spillcount * sizeof(spillslot_unionfind[0]));
-       spilllist           = alloca(spillcount * sizeof(spilllist[0]));
+       interferences       = ALLOCAN(bitset_t*, spillcount);
+       spillslot_unionfind = ALLOCAN(int,       spillcount);
+       spilllist           = ALLOCAN(spill_t*,  spillcount);
 
-       uf_init(spillslot_unionfind, 0, spillcount);
+       uf_init(spillslot_unionfind, spillcount);
 
        DEBUG_ONLY(
                memset(spilllist, 0, spillcount * sizeof(spilllist[0]));
@@ -572,7 +569,8 @@ static void assign_spill_entity(ir_node *node, ir_entity *entity)
                return;
        }
 
-       /* beware: we might have Stores with Memory Proj's, ia32 fisttp for instance */
+       /* 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);
@@ -584,15 +582,10 @@ static void assign_spill_entity(ir_node *node, ir_entity *entity)
  */
 static void assign_spillslots(be_fec_env_t *env)
 {
-       int i;
-       int spillcount;
-       spill_t *spill;
-       spill_slot_t* spillslots;
-
-       spillcount = set_count(env->spills);
-       spillslots = alloca(spillcount * sizeof(spillslots[0]));
-
-       memset(spillslots, 0, spillcount * sizeof(spillslots[0]));
+       int           spillcount = set_count(env->spills);
+       spill_slot_t *spillslots = ALLOCANZ(spill_slot_t, spillcount);
+       spill_t      *spill;
+       int           i;
 
        /* construct spillslots */
        for(spill = set_first(env->spills); spill != NULL;
@@ -651,7 +644,7 @@ static void assign_spillslots(be_fec_env_t *env)
 
                                        memperm = get_memperm(env, predblock);
 
-                                       entry = obstack_alloc(&env->obst, sizeof(entry[0]));
+                                       entry = OALLOC(&env->obst, memperm_entry_t);
                                        entry->node = node;
                                        entry->pos = i;
                                        entry->in = argslot->entity;
@@ -708,11 +701,11 @@ static void create_memperms(be_fec_env_t *env)
        memperm_t *memperm;
 
        for(memperm = set_first(env->memperms); memperm != NULL; memperm = set_next(env->memperms)) {
-               int i;
-               memperm_entry_t *entry;
-               ir_node *blockend;
-               ir_node** nodes = alloca(memperm->entrycount * sizeof(nodes[0]));
-               ir_node* mempermnode;
+               ir_node         **nodes = ALLOCAN(ir_node*, memperm->entrycount);
+               memperm_entry_t  *entry;
+               ir_node          *blockend;
+               ir_node          *mempermnode;
+               int               i;
 
                assert(memperm->entrycount > 0);
 
@@ -721,7 +714,7 @@ static void create_memperms(be_fec_env_t *env)
                        nodes[i] = arg;
                }
 
-               mempermnode = be_new_MemPerm(arch_env, irg, memperm->block,
+               mempermnode = be_new_MemPerm(arch_env, memperm->block,
                                             memperm->entrycount, nodes);
 
                /* insert node into schedule */
@@ -815,7 +808,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 +816,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_env_get_reg_class_alignment(arch_env, cls);
+       cls   = arch_get_irn_reg_class_out(node);
+       align = arch_env_get_reg_class_alignment(env->arch_env, cls);
 
        be_node_needs_frame_entity(env, node, mode, align);
 }