becopyheur4: Clean up co_mst_irn_init().

[libfirm] / ir / be / bechordal_common.c

diff --git a/ir/be/bechordal_common.c b/ir/be/bechordal_common.c
index 692154c..5a9c0c7 100644 (file)
--- a/ir/be/bechordal_common.c
+++ b/ir/be/bechordal_common.c
@@ -29,58 +29,19 @@
 #include "bemodule.h"
 #include "belive.h"
 #include "belive_t.h"
-#include "fourcc.h"
 
 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 
-/* Make a fourcc for border checking. */
-#define BORDER_FOURCC   FOURCC('B', 'O', 'R', 'D')
-
-static inline border_t *border_add(be_chordal_env_t *env, struct list_head *head,
-                       ir_node *irn, unsigned step, unsigned pressure,
-                       unsigned is_def, unsigned is_real)
+static inline border_t *border_add(be_chordal_env_t *const env, struct list_head *const head, ir_node *const irn, unsigned const step, unsigned const is_def, unsigned const is_real)
 {
-       border_t *b;
-
-       if (!is_def) {
-               border_t *def;
-
-               b = OALLOC(&env->obst, border_t);
-
-               /* also allocate the def and tie it to the use. */
-               def = OALLOCZ(&env->obst, border_t);
-               b->other_end = def;
-               def->other_end = b;
-
-               /*
-                * Set the link field of the irn to the def.
-                * This strongly relies on the fact, that the use is always
-                * made before the def.
-                */
-               set_irn_link(irn, def);
-
-               DEBUG_ONLY(b->magic = BORDER_FOURCC;)
-               DEBUG_ONLY(def->magic = BORDER_FOURCC;)
-       } else {
-               /*
-                * If the def is encountered, the use was made and so was the
-                * the def node (see the code above). It was placed into the
-                * link field of the irn, so we can get it there.
-                */
-               b = (border_t*)get_irn_link(irn);
-
-               DEBUG_ONLY(assert(b && b->magic == BORDER_FOURCC && "Illegal border encountered");)
-       }
-
-       b->pressure = pressure;
-       b->is_def = is_def;
+       border_t *const b = OALLOC(&env->obst, border_t);
+       b->is_def  = is_def;
        b->is_real = is_real;
-       b->irn = irn;
-       b->step = step;
+       b->irn     = irn;
+       b->step    = step;
        list_add_tail(&b->list, head);
        DBG((dbg, LEVEL_5, "\t\t%s adding %+F, step: %d\n", is_def ? "def" : "use", irn, step));
 
-
        return b;
 }
 
@@ -88,16 +49,15 @@ void create_borders(ir_node *block, void *env_ptr)
 {
 /* Convenience macro for a def */
 #define border_def(irn, step, real) \
-       border_add(env, head, irn, step, pressure--, 1, real)
+       border_add(env, head, irn, step, 1, real)
 
 /* Convenience macro for a use */
 #define border_use(irn, step, real) \
-       border_add(env, head, irn, step, ++pressure, 0, real)
+       border_add(env, head, irn, step, 0, real)
 
        be_chordal_env_t *const env = (be_chordal_env_t*)env_ptr;
 
        unsigned step = 0;
-       unsigned pressure = 0;
        struct list_head *head;
 
        /* Set up the border list in the block info */
@@ -127,10 +87,7 @@ void create_borders(ir_node *block, void *env_ptr)
         * relevant for the interval borders.
         */
        sched_foreach_reverse(block, irn) {
-               if (is_Phi(irn))
-                       break;
-
-               DB((dbg, LEVEL_1, "\tinsn: %+F, pressure: %d\n", irn, pressure));
+               DB((dbg, LEVEL_1, "\tinsn: %+F\n", irn));
 
                be_foreach_definition(irn, env->cls, def, req,
                        /*
@@ -141,23 +98,27 @@ void create_borders(ir_node *block, void *env_ptr)
                        border_def(def, step, 1);
                );
 
-               /* Examine the uses. */
-               be_foreach_use(irn, env->cls, in_req_, op, op_req_,
-                       const char *msg = "-";
+               /* If the node is no phi node we can examine the uses. */
+               if (!is_Phi(irn)) {
+                       be_foreach_use(irn, env->cls, in_req_, op, op_req_,
+                               const char *msg = "-";
 
-                       if (ir_nodeset_insert(&live, op)) {
-                               border_use(op, step, 1);
-                               msg = "X";
-                       }
+                               if (ir_nodeset_insert(&live, op)) {
+                                       border_use(op, step, 1);
+                                       msg = "X";
+                               }
 
-                       DB((dbg, LEVEL_4, "\t\t%s pos: %d, use: %+F\n", msg, i_, op));
-               );
+                               DB((dbg, LEVEL_4, "\t\t%s pos: %d, use: %+F\n", msg, i_, op));
+                       );
+               }
                ++step;
        }
 
+       /* Process live-ins last. In particular all Phis are handled before, so when
+        * iterating the borders the live-ins come before all Phis ("live-start"). */
        foreach_ir_nodeset(&live, irn, iter) {
-               assert(be_is_live_in(lv, block, irn) ^ (is_Phi(irn) && get_nodes_block(irn) == block));
-               border_def(irn, step, get_nodes_block(irn) == block);
+               assert(be_is_live_in(lv, block, irn));
+               border_def(irn, step, 0);
        }
 
        ir_nodeset_destroy(&live);