avoid querying End/Anchor for register requirements

[libfirm] / ir / be / bespillslots.c

diff --git a/ir/be/bespillslots.c b/ir/be/bespillslots.c
index 34187f4..ff2df9f 100644 (file)
--- a/ir/be/bespillslots.c
+++ b/ir/be/bespillslots.c
@@ -41,7 +41,7 @@
 #include "bespill.h"
 #include "bespillslots.h"
 #include "bechordal_t.h"
-#include "bestatevent.h"
+#include "statev_t.h"
 #include "bemodule.h"
 #include "beintlive_t.h"
 #include "beirg.h"
@@ -152,7 +152,6 @@ static spill_t *collect_spill(be_fec_env_t *env, ir_node *node,
        DB((dbg, DBG_COALESCING, "Slot %d: %+F\n", spill->spillslot, node));
 
        if (is_Phi(node)) {
-               const ir_exec_freq *exec_freq = be_get_irg_exec_freq(env->irg);
                int                 arity     = get_irn_arity(node);
                int                 i;
                for (i = 0; i < arity; ++i) {
@@ -163,7 +162,7 @@ static spill_t *collect_spill(be_fec_env_t *env, ir_node *node,
 
                        /* add an affinity edge */
                        affinty_edge           = OALLOC(&env->obst, affinity_edge_t);
-                       affinty_edge->affinity = get_block_execfreq(exec_freq, block);
+                       affinty_edge->affinity = get_block_execfreq(block);
                        affinty_edge->slot1    = spill->spillslot;
                        affinty_edge->slot2    = arg_spill->spillslot;
                        ARR_APP1(affinity_edge_t*, env->affinity_edges, affinty_edge);
@@ -219,48 +218,46 @@ static int my_values_interfere2(ir_graph *irg, const ir_node *a,
 {
        be_lv_t *lv = be_get_irg_liveness(irg);
 
-    int a2b = _value_dominates(a, b);
-    int b2a = _value_dominates(b, a);
-
-    /* If there is no dominance relation, they do not interfere. */
-    if ((a2b | b2a) > 0) {
-        const ir_edge_t *edge;
-        ir_node *bb;
-
-        /*
-         * Adjust a and b so, that a dominates b if
-         * a dominates b or vice versa.
-         */
-        if (b2a) {
-            const ir_node *t = a;
-            a = b;
-            b = t;
-        }
-
-        bb = get_nodes_block(b);
-
-        /*
-         * If a is live end in b's block it is
-         * live at b's definition (a dominates b)
-         */
-        if (be_is_live_end(lv, bb, a))
-            return 1;
-
-        /*
-         * Look at all usages of a.
-         * If there's one usage of a in the block of b, then
-         * we check, if this use is dominated by b, if that's true
-         * a and b interfere. Note that b must strictly dominate the user,
-         * since if b is the last user of in the block, b and a do not
-         * interfere.
-         * Uses of a not in b's block can be disobeyed, because the
-         * check for a being live at the end of b's block is already
-         * performed.
-         */
-        foreach_out_edge(a, edge) {
-            const ir_node *user = get_edge_src_irn(edge);
+       int a2b = _value_dominates(a, b);
+       int b2a = _value_dominates(b, a);
+
+       /* If there is no dominance relation, they do not interfere. */
+       if ((a2b | b2a) > 0) {
+               ir_node *bb;
+
+               /*
+                * Adjust a and b so, that a dominates b if
+                * a dominates b or vice versa.
+                */
+               if (b2a) {
+                       const ir_node *t = a;
+                       a = b;
+                       b = t;
+               }
+
+               bb = get_nodes_block(b);
+
+               /*
+                * If a is live end in b's block it is
+                * live at b's definition (a dominates b)
+                */
+               if (be_is_live_end(lv, bb, a))
+                       return 1;
+
+               /*
+                * Look at all usages of a.
+                * If there's one usage of a in the block of b, then
+                * we check, if this use is dominated by b, if that's true
+                * a and b interfere. Note that b must strictly dominate the user,
+                * since if b is the last user of in the block, b and a do not
+                * interfere.
+                * Uses of a not in b's block can be disobeyed, because the
+                * check for a being live at the end of b's block is already
+                * performed.
+                */
+               foreach_out_edge(a, edge) {
+                       const ir_node *user = get_edge_src_irn(edge);
                        if (is_Sync(user)) {
-                               const ir_edge_t *edge2;
                                foreach_out_edge(user, edge2) {
                                        const ir_node *user2 = get_edge_src_irn(edge2);
                                        assert(!is_Sync(user2));
@@ -271,10 +268,10 @@ static int my_values_interfere2(ir_graph *irg, const ir_node *a,
                        } else {
                                if (get_nodes_block(user) == bb && !is_Phi(user) &&
                                                _value_strictly_dominates(b, user))
-                return 1;
+                                       return 1;
                        }
-        }
-    }
+               }
+       }
 
        return 0;
 }
@@ -680,11 +677,9 @@ static unsigned count_spillslots(const be_fec_env_t *env)
 {
        size_t         spillcount = ARR_LEN(env->spills);
        unsigned       slotcount  = 0;
-       unsigned      *counted;
        size_t         s;
 
-       rbitset_alloca(counted, spillcount);
-
+       unsigned *const counted = rbitset_alloca(spillcount);
        for (s = 0; s < spillcount; ++s) {
                spill_t *spill     = env->spills[s];
                int      spillslot = spill->spillslot;