debug stuff and bugfixes

diff --git a/ir/be/bechordal.c b/ir/be/bechordal.c
index cc41172..2fcb990 100644 (file)
--- a/ir/be/bechordal.c
+++ b/ir/be/bechordal.c
@@ -38,6 +38,7 @@
 #include "bechordal_t.h"
 #include "bechordal_draw.h"
 
+#define DBG_LEVEL 0
 #define NO_COLOR (-1)
 
 #undef DUMP_INTERVALS
@@ -491,7 +492,7 @@ static void assign(ir_node *block, void *env_ptr)
 void be_ra_chordal_init(void)
 {
        dbg = firm_dbg_register(DBG_CHORDAL);
-       firm_dbg_set_mask(dbg, -1);
+       firm_dbg_set_mask(dbg, DBG_LEVEL);
 }
 
 be_chordal_env_t *be_ra_chordal(ir_graph *irg,
@@ -576,11 +577,16 @@ void be_ra_chordal_check(be_chordal_env_t *chordal_env) {
                const arch_register_t *n1_reg, *n2_reg;
 
                n1_reg = arch_get_irn_register(arch_env, n1, 0);
-               assert(arch_reg_is_allocatable(arch_env, n1, arch_pos_make_out(0), n1_reg) && "Register constraint does not hold");
-
+               if (!arch_reg_is_allocatable(arch_env, n1, arch_pos_make_out(0), n1_reg)) {
+                       DBG((dbg, 0, "Register assigned to %+F is not allowed\n", n1));
+                       assert(0 && "Register constraint does not hold");
+               }
                for (o = i+1, n2 = nodes[o]; n2; n2 = nodes[++o]) {
                        n2_reg = arch_get_irn_register(arch_env, n2, 0);
-                       assert(!(nodes_interfere(chordal_env, n1, n2) && n1_reg == n2_reg) && "Interfering values have the same color!");
+                       if (nodes_interfere(chordal_env, n1, n2) && n1_reg == n2_reg) {
+                               DBG((dbg, 0, "Values %+F and %+F interfere and have the same regiseter assigned\n", n1, n2));
+                               assert(0 && "Interfering values have the same color!");
+                       }
                }
        }
        obstack_free(&ob, NULL);

diff --git a/ir/be/becopyheur.c b/ir/be/becopyheur.c
index 34e2e83..f215625 100644 (file)
--- a/ir/be/becopyheur.c
+++ b/ir/be/becopyheur.c
@@ -28,7 +28,6 @@
 #include "becopystat.h"
 #include "bitset.h"
 
-#define DEBUG_LVL 0 //SET_LEVEL_1
 static firm_dbg_module_t *dbg = NULL;
 
 #define SLOTS_PINNED_GLOBAL 256
@@ -84,7 +83,7 @@ static int set_cmp_conflict_t(const void *x, const void *y, size_t size) {
  */
 static INLINE void qnode_add_conflict(const qnode_t *qn, const ir_node *n1, const ir_node *n2) {
        conflict_t c;
-       DBG((dbg, LEVEL_4, "\t      %n -- %n\n", n1, n2));
+       DBG((dbg, LEVEL_4, "\t      %+F -- %+F\n", n1, n2));
 
        if ((int)n1 < (int)n2) {
                c.n1 = n1;
@@ -212,12 +211,14 @@ static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const
        const arch_env_t *arch_env = chordal_env->arch_env;
        const arch_register_class_t *cls = chordal_env->cls;
 
-       DBG((dbg, LEVEL_3, "\t      %n \tcaused col(%n) \t%2d --> %2d\n", trigger, irn, qnode_get_new_color(qn, irn), col));
+       DBG((dbg, LEVEL_3, "\t      %+F \tcaused col(%+F) \t%2d --> %2d\n", trigger, irn, qnode_get_new_color(qn, irn), col));
        obstack_init(&confl_ob);
        irn_col = qnode_get_new_color(qn, irn);
 
-       if (irn_col == col)
+       if (irn_col == col) {
+               DBG((dbg, LEVEL_4, "\t      Already same color.\n"));
                goto ret_save;
+       }
        if (pset_find_ptr(pinned_global, irn) || qnode_is_pinned_local(qn, irn)) {
                res = irn;
                goto ret_confl;
@@ -240,15 +241,17 @@ static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const
                {
                        ir_node *n;
                        pset *live_ins = put_live_in(irn_bl, pset_new_ptr_default());
-                       for (n = pset_first(live_ins); n; n = pset_next(live_ins))
+                       for (n = pset_first(live_ins); n; n = pset_next(live_ins)) {
+                               DBG((dbg, LEVEL_4, "Checking %+F which is live-in at the block\n", n));
                                if (arch_irn_has_reg_class(arch_env, n, arch_pos_make_out(0), cls)
-            && n != trigger && qnode_get_new_color(qn, n) == col
-            && nodes_interfere(chordal_env, irn, n)) {
+                                       && n != trigger && qnode_get_new_color(qn, n) == col
+                                       && nodes_interfere(chordal_env, irn, n)) {
 
-                                       DBG((dbg, LEVEL_4, "\t        %n\ttroubles\n", n));
+                                       DBG((dbg, LEVEL_4, "\t        %+F\ttroubles\n", n));
                                        obstack_ptr_grow(&confl_ob, n);
                                        pset_break(live_ins);
                                        break;
+                               }
                        }
             del_pset(live_ins);
                }
@@ -272,12 +275,12 @@ static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const
                         * the target color and interfere with the irn */
                        for (i = 0, max = get_irn_n_outs(curr_bl); i < max; ++i) {
                                ir_node *n = get_irn_out(curr_bl, i);
+                               DBG((dbg, LEVEL_4, "Checking %+F defined in same block\n", n));
                                if (arch_irn_has_reg_class(arch_env, n, arch_pos_make_out(0), cls)
-            && n != trigger && qnode_get_new_color(qn, n) == col
-            && nodes_interfere(chordal_env, irn, n)) {
-
-                                       DBG((dbg, LEVEL_4, "\t        %n\ttroubles\n", n));
-                                       obstack_ptr_grow(&confl_ob, n);
+                                       && n != trigger && qnode_get_new_color(qn, n) == col
+                                       && nodes_interfere(chordal_env, irn, n)) {
+                                               DBG((dbg, LEVEL_4, "\t        %+F\ttroubles\n", n));
+                                               obstack_ptr_grow(&confl_ob, n);
                                }
                        }
 
@@ -310,18 +313,18 @@ static ir_node *qnode_color_irn(const qnode_t *qn, ir_node *irn, int col, const
        /* if we arrive here all sub changes can be applied, so it's save to change this irn */
 
 ret_save:
-       DBG((dbg, LEVEL_3, "\t      %n save\n", irn));
+       DBG((dbg, LEVEL_3, "\t      %+F save\n", irn));
        obstack_free(&confl_ob, NULL);
        qnode_set_new_color(qn, irn, col);
        return CHANGE_SAVE;
 
 ret_imposs:
-       DBG((dbg, LEVEL_3, "\t      %n impossible\n", irn));
+       DBG((dbg, LEVEL_3, "\t      %+F impossible\n", irn));
        obstack_free(&confl_ob, NULL);
        return CHANGE_IMPOSSIBLE;
 
 ret_confl:
-       DBG((dbg, LEVEL_3, "\t      %n conflicting\n", irn));
+       DBG((dbg, LEVEL_3, "\t      %+F conflicting\n", irn));
        obstack_free(&confl_ob, NULL);
        return res;
 }
@@ -338,7 +341,7 @@ static int qnode_try_color(const qnode_t *qn) {
                ir_node *test_node, *confl_node;
 
                test_node = qn->mis[i];
-               DBG((dbg, LEVEL_3, "\t    Testing %n\n", test_node));
+               DBG((dbg, LEVEL_3, "\t    Testing %+F\n", test_node));
                confl_node = qnode_color_irn(qn, test_node, qn->color, test_node);
 
                if (confl_node == CHANGE_SAVE) {
@@ -423,9 +426,10 @@ static INLINE void qnode_max_ind_set(qnode_t *qn, const unit_t *ou) {
        }
 
        /* transfer the best set into the qn */
-       qn->mis_size = bitset_popcnt(best);
+       qn->mis_size = bitset_popcnt(best)+1;
        qn->mis_costs = best_weight;
        next = 0;
+       qn->mis[next++] = ou->nodes[0]; /* the root is alwazs in a max stable set */
        bitset_foreach(best, pos)
                qn->mis[next++] = ou->nodes[1+pos];
 }
@@ -493,7 +497,7 @@ static void ou_optimize(unit_t *ou) {
 
        DBG((dbg, LEVEL_1, "\tOptimizing unit:\n"));
        for (i=0; i<ou->node_count; ++i)
-               DBG((dbg, LEVEL_1, "\t %n\n", ou->nodes[i]));
+               DBG((dbg, LEVEL_1, "\t %+F\n", ou->nodes[i]));
 
        /* init queue */
        INIT_LIST_HEAD(&ou->queue);
@@ -520,9 +524,8 @@ static void ou_optimize(unit_t *ou) {
        /* apply the best found qnode */
        if (curr->mis_size >= 2) {
                node_stat_t *ns;
-
                DBG((dbg, LEVEL_1, "\t  Best color: %d  Costs: %d/%d\n", curr->color, ou->complete_costs - curr->mis_costs, ou->complete_costs));
-               /* globally pin root and eventually others */
+               /* globally pin root and all args which have the same color */
                pset_insert_ptr(pinned_global, ou->nodes[0]);
                for (i=1; i<ou->node_count; ++i) {
                        ir_node *irn = ou->nodes[i];
@@ -535,10 +538,14 @@ static void ou_optimize(unit_t *ou) {
                for (ns = set_first(curr->changed_nodes); ns; ns = set_next(curr->changed_nodes)) {
                        /* NO_COLOR is possible, if we had an undo */
                        if (ns->new_color != NO_COLOR) {
-                               DBG((dbg, LEVEL_2, "\t    color(%n) := %d\n", ns->irn, ns->new_color));
+                               DBG((dbg, LEVEL_1, "\t    color(%+F) := %d\n", ns->irn, ns->new_color));
                                set_irn_col(ou->co, ns->irn, ns->new_color);
                        }
                }
+               /*
+                * Enable for checking register allocation after each ou
+                * be_ra_chordal_check(ou->co->chordal_env);
+                */
        }
 
        /* free best qnode (curr) and queue */
@@ -550,11 +557,10 @@ static void ou_optimize(unit_t *ou) {
 void co_heur_opt(copy_opt_t *co) {
        unit_t *curr;
        dbg = firm_dbg_register("ir.be.copyoptheur");
-       firm_dbg_set_mask(dbg, DEBUG_LVL);
        if (!strcmp(co->name, DEBUG_IRG))
-               firm_dbg_set_mask(dbg, DEBUG_LVL_HEUR);
+               firm_dbg_set_mask(dbg, DEBUG_IRG_LVL_HEUR);
        else
-               firm_dbg_set_mask(dbg, DEBUG_LVL);
+               firm_dbg_set_mask(dbg, DEBUG_LVL_HEUR);
 
        pinned_global = pset_new_ptr(SLOTS_PINNED_GLOBAL);
        list_for_each_entry(unit_t, curr, &co->units, units)

diff --git a/ir/be/becopyilp.c b/ir/be/becopyilp.c
index 4785b19..ef2a603 100644 (file)
--- a/ir/be/becopyilp.c
+++ b/ir/be/becopyilp.c
@@ -28,7 +28,6 @@
 #define LPP_SOLVER "cplex"
 
 #undef DUMP_MPS
-#define DEBUG_LVL SET_LEVEL_1
 static firm_dbg_module_t *dbg = NULL;
 
 #define MAX(a,b) ((a<b)?(b):(a))
@@ -639,9 +638,9 @@ void co_ilp_opt(copy_opt_t *co) {
 
        dbg = firm_dbg_register("ir.be.copyoptilp");
        if (!strcmp(co->name, DEBUG_IRG))
-               firm_dbg_set_mask(dbg, DEBUG_LVL_ILP);
+               firm_dbg_set_mask(dbg, DEBUG_IRG_LVL_ILP);
        else
-               firm_dbg_set_mask(dbg, DEBUG_LVL);
+               firm_dbg_set_mask(dbg, DEBUG_LVL_ILP);
 
        pi = new_pi(co);
        if (!pi->all_simplicial) {

diff --git a/ir/be/becopyopt.c b/ir/be/becopyopt.c
index 82080f0..8ed83f9 100644 (file)
--- a/ir/be/becopyopt.c
+++ b/ir/be/becopyopt.c
@@ -22,7 +22,6 @@
 #include "becopyopt.h"
 #include "becopystat.h"
 
-#define DEBUG_LVL 0 //SET_LEVEL_1
 static firm_dbg_module_t *dbg = NULL;
 
 #define is_curr_reg_class(irn) (arch_get_irn_reg_class(co->chordal_env->arch_env, irn, arch_pos_make_out(0)) == co->chordal_env->cls)
@@ -194,7 +193,7 @@ copy_opt_t *new_copy_opt(be_chordal_env_t *chordal_env, int (*get_costs)(ir_node
        copy_opt_t *co;
 
        dbg = firm_dbg_register("ir.be.copyopt");
-       firm_dbg_set_mask(dbg, DEBUG_LVL);
+       firm_dbg_set_mask(dbg, DEBUG_LVL_CO);
 
        co = xcalloc(1, sizeof(*co));
        co->chordal_env = chordal_env;
@@ -207,9 +206,9 @@ copy_opt_t *new_copy_opt(be_chordal_env_t *chordal_env, int (*get_costs)(ir_node
        co->name = xmalloc(len);
        snprintf(co->name, len, "%s__%s__%s", s1, s2, s3);
        if (!strcmp(co->name, DEBUG_IRG))
-               firm_dbg_set_mask(dbg, DEBUG_LVL_CO);
+               firm_dbg_set_mask(dbg, DEBUG_IRG_LVL_CO);
        else
-               firm_dbg_set_mask(dbg, DEBUG_LVL);
+               firm_dbg_set_mask(dbg, DEBUG_LVL_CO);
 
        INIT_LIST_HEAD(&co->units);
        co_collect_units(co);
@@ -262,11 +261,14 @@ int co_get_copy_costs(const copy_opt_t *co) {
        unit_t *curr;
        list_for_each_entry(unit_t, curr, &co->units, units) {
                int root_col = get_irn_col(co, curr->nodes[0]);
-               for (i=1; i<curr->node_count; ++i)
-                       if (root_col != get_irn_col(co, curr->nodes[i])) {
-                               DBG((dbg, LEVEL_1, "  %n %N\n", curr->nodes[i], curr->nodes[i]));
+               DBG((dbg, LEVEL_1, "  Adding costs for root %+F color %d\n", curr->nodes[0], root_col));
+               for (i=1; i<curr->node_count; ++i) {
+                       int arg_col = get_irn_col(co, curr->nodes[i]);
+                       if (root_col != arg_col) {
+                               DBG((dbg, LEVEL_1, "  Arg %+F color %d costs %d\n", curr->nodes[i], arg_col, curr->costs[i]));
                                res += curr->costs[i];
                        }
+               }
        }
        return res;
 }

diff --git a/ir/be/becopyopt.h b/ir/be/becopyopt.h
index 5dd61ec..3555169 100644 (file)
--- a/ir/be/becopyopt.h
+++ b/ir/be/becopyopt.h
@@ -29,10 +29,13 @@
 #include "bechordal_t.h"
 #include "bearch.h"
 
-#define DEBUG_IRG "NONE spec.c__main__datab"
-#define DEBUG_LVL_CO   LEVEL_1
-#define DEBUG_LVL_HEUR LEVEL_1
-#define DEBUG_LVL_ILP  LEVEL_1
+#define DEBUG_IRG "MergeSort.c__merge__datab"
+#define DEBUG_IRG_LVL_CO   SET_LEVEL_1
+#define DEBUG_IRG_LVL_HEUR SET_LEVEL_1
+#define DEBUG_IRG_LVL_ILP  SET_LEVEL_1
+#define DEBUG_LVL_CO   SET_LEVEL_0
+#define DEBUG_LVL_HEUR SET_LEVEL_0
+#define DEBUG_LVL_ILP  SET_LEVEL_0
 
 typedef int(*cost_fct_t)(ir_node*, ir_node*, int);
 

diff --git a/ir/be/becopyoptmain.c b/ir/be/becopyoptmain.c
index a648064..df7d574 100644 (file)
--- a/ir/be/becopyoptmain.c
+++ b/ir/be/becopyoptmain.c
@@ -13,6 +13,7 @@
 #endif
 
 #include "debug.h"
+#include "irouts.h"
 #include "becopyopt.h"
 #include "becopystat.h"
 #include "becopyoptmain.h"
@@ -32,6 +33,9 @@ void be_copy_opt(be_chordal_env_t *chordal_env) {
        copy_opt_t *co;
        int lb, copy_costs;
 
+       /* BETTER: You can remove this if you replace all `grep get_irn_out *.c`*/
+       compute_outs(chordal_env->irg);
+
        co = new_copy_opt(chordal_env, get_costs_loop_depth);
        DBG((dbg, LEVEL_1, "===>  %s  <===\n", co->name));
 

diff --git a/ir/be/beirgmod.c b/ir/be/beirgmod.c
index 61063ee..73050d3 100644 (file)
--- a/ir/be/beirgmod.c
+++ b/ir/be/beirgmod.c
@@ -28,6 +28,7 @@
 #include "beirgmod.h"
 
 #define DBG_MODULE firm_dbg_register("firm.be.irgmod")
+#define DBG_LEVEL 0
 
 struct _dom_front_info_t {
   pmap *df_map;
@@ -326,7 +327,7 @@ static ir_node *search_def(ir_node *usage, int pos, pset *copies, pset *copy_blo
   ir_node *curr_bl;
   ir_node *start_irn;
   firm_dbg_module_t *dbg = DBG_MODULE;
-  firm_dbg_set_mask(dbg, -1);
+  firm_dbg_set_mask(dbg, DBG_LEVEL);
 
   curr_bl = get_nodes_block(usage);
 
@@ -458,7 +459,7 @@ void be_introduce_copies(dom_front_info_t *info, ir_node *orig, int n, ir_node *
   firm_dbg_module_t *dbg = DBG_MODULE;
   int i;
 
-  firm_dbg_set_mask(dbg, -1);
+  firm_dbg_set_mask(dbg, DBG_LEVEL);
   DBG((dbg, LEVEL_1, "Introducing following copies of %+F\n", orig));
 
   /* Fill the sets. */

diff --git a/ir/be/bemain.c b/ir/be/bemain.c
index 7763ca7..c42486e 100644 (file)
--- a/ir/be/bemain.c
+++ b/ir/be/bemain.c
@@ -132,7 +132,7 @@ static void be_main_loop(void)
                ir_graph *irg = get_irp_irg(i);
                be_main_session_env_t session;
 
-    DBG((env.dbg, LEVEL_1, "be irg: %F\n", irg));
+               DBG((env.dbg, LEVEL_1, "be irg: %F\n", irg));
 
                /* Init the session. */
                be_init_session_env(&session, &env, irg);
@@ -147,8 +147,8 @@ static void be_main_loop(void)
                /* Verify the schedule */
                sched_verify_irg(irg);
 
-    /* Build liveness information */
-    be_liveness(irg);
+               /* Build liveness information */
+               be_liveness(irg);
 
                /* Remove all cases where a phi and one of its arguments interfere */
                be_eliminate_phi_interferences(&session);
@@ -160,20 +160,20 @@ static void be_main_loop(void)
                copystat_reset();
                copystat_collect_irg(irg, env.arch_env);
 
-    /*
-     * Verifying the schedule once again cannot hurt.
-     */
-    sched_verify_irg(irg);
+               /*
+                * Verifying the schedule once again cannot hurt.
+                */
+               sched_verify_irg(irg);
 
                /* Perform the following for each register class. */
                for(j = 0, m = isa->get_n_reg_class(); j < m; ++j) {
                        be_chordal_env_t *chordal_env;
                        const arch_register_class_t *cls = isa->get_reg_class(j);
 
-      DBG((env.dbg, LEVEL_1, "\treg class: %s\n", cls->name));
+                       DBG((env.dbg, LEVEL_1, "\treg class: %s\n", cls->name));
 
-      be_numbering(irg);
-      be_liveness(irg);
+                       be_numbering(irg);
+                       be_liveness(irg);
 
                        chordal_env = be_ra_chordal(irg, env.arch_env, cls);
 
@@ -188,8 +188,8 @@ static void be_main_loop(void)
                        be_ssa_destruction_check(&session, chordal_env);
                        be_ra_chordal_check(chordal_env);
 
-      be_ra_chordal_done(chordal_env);
-      be_numbering_done(irg);
+                       be_ra_chordal_done(chordal_env);
+                       be_numbering_done(irg);
                }
 
                copystat_dump_pretty(irg);

diff --git a/ir/be/benode.c b/ir/be/benode.c
index 26cef9e..7cd4c13 100644 (file)
--- a/ir/be/benode.c
+++ b/ir/be/benode.c
@@ -32,6 +32,8 @@
 
 #include "beirgmod.h"
 
+#define DBG_LEVEL 0
+
 typedef enum _node_kind_t {
   node_kind_spill,
   node_kind_reload,
@@ -329,7 +331,7 @@ ir_node *insert_Perm_after(const be_main_session_env_t *env,
   firm_dbg_module_t *dbg = firm_dbg_register("firm.be.node");
   int i, n;
 
-  firm_dbg_set_mask(dbg, -1);
+  firm_dbg_set_mask(dbg, DBG_LEVEL);
   DBG((dbg, LEVEL_1, "Insert Perm after: %+F\n", pos));
 
   sched_foreach_reverse(bl, irn) {

diff --git a/ir/be/bera.c b/ir/be/bera.c
index 7055ec6..f3ae848 100644 (file)
--- a/ir/be/bera.c
+++ b/ir/be/bera.c
@@ -92,9 +92,7 @@ int values_interfere(const ir_node *a, const ir_node *b)
           && !is_Phi(user)
           && value_dominates(b, user))
         return 1;
-      }
     }
   }
-
   return 0;
 }