used new FIRM_DBG_REGISTER macro

diff --git a/ir/be/beabi.c b/ir/be/beabi.c
index 9220fce..5dd66e6 100644 (file)
--- a/ir/be/beabi.c
+++ b/ir/be/beabi.c
@@ -1384,9 +1384,9 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
 
        env->dce_survivor     = new_survive_dce();
        env->birg             = birg;
-       env->dbg              = firm_dbg_register("firm.be.abi");
        env->stack_phis       = pset_new_ptr(16);
        env->init_sp = dummy  = new_r_Unknown(irg, env->isa->sp->reg_class->mode);
+       FIRM_DBG_REGISTER(env->dbg, "firm.be.abi");
 
        env->cb = env->call->cb->init(env->call, birg->main_env->arch_env, irg);
 

diff --git a/ir/be/bechordal.c b/ir/be/bechordal.c
index 48196ac..0d4c145 100644 (file)
--- a/ir/be/bechordal.c
+++ b/ir/be/bechordal.c
@@ -665,8 +665,8 @@ end:
 static void constraints(ir_node *bl, void *data)
 {
        be_chordal_alloc_env_t *env = data;
-       firm_dbg_module_t *dbg      = firm_dbg_register("firm.be.chordal.constr");
        arch_env_t *arch_env        = env->chordal_env->birg->main_env->arch_env;
+       FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, "firm.be.chordal.constr");
 
        /*
                Start silent in the start block.
@@ -925,7 +925,7 @@ void be_ra_chordal_color(be_chordal_env_t *chordal_env)
        env.in_colors     = bitset_alloca(colors_n);
        env.ignore_regs   = bitset_alloca(colors_n);
        env.pre_colored   = pset_new_ptr_default();
-       env.constr_dbg    = firm_dbg_register("firm.be.chordal.constr");
+       FIRM_DBG_REGISTER(env.constr_dbg, "firm.be.chordal.constr");
 
        for(i = 0; i < colors_n; ++i)
                if(arch_register_type_is(&chordal_env->cls->regs[i], ignore))

diff --git a/ir/be/bechordal_main.c b/ir/be/bechordal_main.c
index 1dcf11d..b374aff 100644 (file)
--- a/ir/be/bechordal_main.c
+++ b/ir/be/bechordal_main.c
@@ -260,9 +260,9 @@ static void be_ra_chordal_main(const be_irg_t *bi)
 
        chordal_env.opts         = &options;
        chordal_env.irg          = irg;
-       chordal_env.dbg          = firm_dbg_register("firm.be.chordal");
-       chordal_env.birg                 = bi;
+       chordal_env.birg         = bi;
        chordal_env.dom_front    = be_compute_dominance_frontiers(irg);
+       FIRM_DBG_REGISTER(chordal_env.dbg, "firm.be.chordal");
 
        obstack_init(&chordal_env.obst);
 

diff --git a/ir/be/becopyheur.c b/ir/be/becopyheur.c
index a859c58..7b16fe1 100644 (file)
--- a/ir/be/becopyheur.c
+++ b/ir/be/becopyheur.c
@@ -580,7 +580,7 @@ static void ou_optimize(unit_t *ou) {
 
 int co_solve_heuristic(copy_opt_t *co) {
        unit_t *curr;
-       dbg = firm_dbg_register("ir.be.copyoptheur");
+       FIRM_DBG_REGISTER(dbg, "ir.be.copyoptheur");
 
        ASSERT_OU_AVAIL(co);
 

diff --git a/ir/be/becopyilp2.c b/ir/be/becopyilp2.c
index 946322d..3dbc923 100644 (file)
--- a/ir/be/becopyilp2.c
+++ b/ir/be/becopyilp2.c
@@ -511,7 +511,7 @@ int co_solve_ilp2(copy_opt_t *co, double time_limit) {
        my.first_x_var = -1;
        my.last_x_var  = -1;
        my.nr_2_irn    = pmap_create();
-       my.dbg         = firm_dbg_register("ir.be.coilp2");
+       FIRM_DBG_REGISTER(my.dbg, "ir.be.coilp2");
        firm_dbg_set_mask(my.dbg, DEBUG_LVL);
 
        ienv = new_ilp_env(co, ilp2_build, ilp2_apply, &my);

diff --git a/ir/be/becopyopt.c b/ir/be/becopyopt.c
index c613376..1d86d6a 100644 (file)
--- a/ir/be/becopyopt.c
+++ b/ir/be/becopyopt.c
@@ -53,7 +53,7 @@ copy_opt_t *new_copy_opt(be_chordal_env_t *chordal_env, int (*get_costs)(ir_node
        int len;
        copy_opt_t *co;
 
-       dbg = firm_dbg_register("ir.be.copyopt");
+       FIRM_DBG_REGISTER(dbg, "ir.be.copyopt");
 
        co = xcalloc(1, sizeof(*co));
        co->cenv      = chordal_env;

diff --git a/ir/be/becopystat.c b/ir/be/becopystat.c
index 1a4c195..7ee6361 100644 (file)
--- a/ir/be/becopystat.c
+++ b/ir/be/becopystat.c
@@ -100,7 +100,7 @@ static pset *all_copy_nodes;
 static ir_graph *last_irg;
 
 void copystat_init(void) {
-       dbg = firm_dbg_register("ir.be.copystat");
+       FIRM_DBG_REGISTER(dbg, "ir.be.copystat");
        firm_dbg_set_mask(dbg, DEBUG_LVL);
 
        all_phi_nodes = pset_new_ptr_default();

diff --git a/ir/be/beirgmod.c b/ir/be/beirgmod.c
index 1c25d44..77ca783 100644 (file)
--- a/ir/be/beirgmod.c
+++ b/ir/be/beirgmod.c
@@ -36,7 +36,7 @@
 
 #include "beirgmod.h"
 
-#define DBG_MODULE firm_dbg_register("firm.be.irgmod")
+#define DBG_MODULE "firm.be.irgmod"
 #define DBG_LEVEL SET_LEVEL_0
 
 /*
@@ -139,7 +139,7 @@ static void determine_phi_blocks(pset *copies, pset* copy_blocks, pset *phi_bloc
 {
        ir_node *bl;
        pdeq *worklist = new_pdeq();
-       firm_dbg_module_t *dbg = DBG_MODULE;
+       FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE);
 
        /*
        * Fill the worklist queue and the rest of the orig blocks array.
@@ -217,7 +217,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_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE);
 
        curr_bl = get_nodes_block(usage);
 
@@ -297,8 +297,8 @@ static ir_node *search_def(ir_node *usage, int pos, pset *copies, pset *copy_blo
 
 static void fix_usages(pset *copies, pset *copy_blocks, pset *phi_blocks, pset *phis, pset *ignore_uses)
 {
-       firm_dbg_module_t *dbg = DBG_MODULE;
-       int n_outs             = 0;
+       int n_outs = 0;
+       FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE);
 
        struct obstack obst;
        ir_node *irn;
@@ -413,7 +413,7 @@ void be_ssa_constr_set_phis_ignore(dom_front_info_t *df, pset *nodes, pset *phis
        pset *phi_blocks       = pset_new_ptr(n);
        int save_optimize      = get_optimize();
        int save_normalize     = get_opt_normalize();
-       firm_dbg_module_t *dbg = DBG_MODULE;
+       FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE);
 
        ir_node *irn;
 
@@ -486,7 +486,7 @@ ir_node *insert_Perm_after(const arch_env_t *arch_env,
        ir_node *bl                 = is_Block(pos) ? pos : get_nodes_block(pos);
        ir_graph *irg               = get_irn_irg(bl);
        pset *live                  = pset_new_ptr_default();
-       firm_dbg_module_t *dbg      = firm_dbg_register("be.node");
+       FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, "be.node");
 
        ir_node *curr, *irn, *perm, **nodes;
        int i, n;

diff --git a/ir/be/belistsched.c b/ir/be/belistsched.c
index 9a9c690..5510084 100644 (file)
--- a/ir/be/belistsched.c
+++ b/ir/be/belistsched.c
@@ -600,12 +600,12 @@ static void list_sched_block(ir_node *block, void *env_ptr)
        INIT_LIST_HEAD(&info->list);
 
        /* Initialize the block scheduling environment */
-       be.dbg               = firm_dbg_register("firm.be.sched");
        be.block             = block;
        be.curr_time         = 0;
        be.ready_set         = new_pset(node_cmp_func, get_irn_n_edges(block));
        be.already_scheduled = new_pset(node_cmp_func, get_irn_n_edges(block));
        be.selector          = selector;
+       FIRM_DBG_REGISTER(be.dbg, "firm.be.sched");
 
        if(selector->init_block)
                be.selector_block_env = selector->init_block(env->selector_env, block);

diff --git a/ir/be/belive.c b/ir/be/belive.c
index 2e6c821..74dcf43 100644 (file)
--- a/ir/be/belive.c
+++ b/ir/be/belive.c
@@ -296,9 +296,9 @@ void be_check_dominance(ir_graph *irg)
 
 pset *be_liveness_transfer(const arch_env_t *arch_env, const arch_register_class_t *cls, ir_node *irn, pset *live)
 {
-       firm_dbg_module_t *dbg = firm_dbg_register(DBG_MODULE);
        int i, n;
        ir_node *x;
+       FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, DBG_MODULE);
 
        DBG((dbg, LEVEL_1, "%+F\n", irn));
        for(x = pset_first(live); x; x = pset_next(live))
@@ -332,12 +332,10 @@ pset *be_liveness_end_of_block(const arch_env_t *arch_env, const arch_register_c
 
 pset *be_liveness_nodes_live_at(const arch_env_t *arch_env, const arch_register_class_t *cls, const ir_node *pos, pset *live)
 {
-       firm_dbg_module_t *dbg = firm_dbg_register(DBG_MODULE);
-       const ir_node *bl      = is_Block(pos) ? pos : get_nodes_block(pos);
+       const ir_node *bl = is_Block(pos) ? pos : get_nodes_block(pos);
        ir_node *irn;
 
        be_liveness_end_of_block(arch_env, cls, bl, live);
-
        sched_foreach_reverse(bl, irn) {
                /*
                 * If we encounter the node we want to insert the Perm after,

diff --git a/ir/be/belower.c b/ir/be/belower.c
index b26d4ab..4378dc7 100644 (file)
--- a/ir/be/belower.c
+++ b/ir/be/belower.c
@@ -506,8 +506,8 @@ static void gen_assure_different_pattern(ir_node *irn, be_irg_t *birg, ir_node *
        const arch_env_t          *arch_env = birg->main_env->arch_env;
        ir_node                   *in[2], *keep, *cpy, *temp;
        ir_node                   *block = get_nodes_block(irn);
-       firm_dbg_module_t         *mod   = firm_dbg_register("firm.be.lower");
        const arch_register_class_t *cls = arch_get_irn_reg_class(arch_env, other_different, -1);
+       FIRM_DBG_REGISTER(firm_dbg_module_t *mod, "firm.be.lower");
 
        if (arch_irn_is(arch_env, other_different, ignore) || ! mode_is_datab(get_irn_mode(other_different))) {
                DBG((mod, LEVEL_1, "ignore constraint for %+F because other_irn is ignore or not a datab node\n", irn));
@@ -635,7 +635,7 @@ void lower_nodes_after_ra(be_chordal_env_t *chord_env, int do_copy) {
 
        env.chord_env  = chord_env;
        env.do_copy    = do_copy;
-       env.dbg_module = firm_dbg_register("firm.be.lower");
+       FIRM_DBG_REGISTER(env.dbg_module, "firm.be.lower");
 
        irg_walk_blkwise_graph(chord_env->irg, NULL, lower_nodes_after_ra_walker, &env);
 }

diff --git a/ir/be/bemain.c b/ir/be/bemain.c
index ce88671..80dcde1 100644 (file)
--- a/ir/be/bemain.c
+++ b/ir/be/bemain.c
@@ -31,6 +31,9 @@
 #include "bearch.h"
 #include "firm/bearch_firm.h"
 #include "ia32/bearch_ia32.h"
+#include "arm/bearch_arm.h"
+#include "ppc32/bearch_ppc32.h"
+#include "mips/bearch_mips.h"
 
 #include "be_t.h"
 #include "benumb_t.h"
@@ -53,12 +56,12 @@
 #include "beabi.h"
 #include "belower.h"
 
-#define DUMP_INITIAL           (1 << 0)
-#define DUMP_ABI               (1 << 1)
-#define DUMP_SCHED                     (1 << 2)
-#define DUMP_PREPARED          (1 << 3)
-#define DUMP_RA                                (1 << 4)
-#define DUMP_FINAL                     (1 << 5)
+#define DUMP_INITIAL    (1 << 0)
+#define DUMP_ABI        (1 << 1)
+#define DUMP_SCHED      (1 << 2)
+#define DUMP_PREPARED   (1 << 3)
+#define DUMP_RA         (1 << 4)
+#define DUMP_FINAL      (1 << 5)
 
 /* options visible for anyone */
 static be_options_t be_options = {
@@ -105,6 +108,9 @@ static const lc_opt_enum_const_ptr_items_t ra_items[] = {
 static const lc_opt_enum_const_ptr_items_t isa_items[] = {
        { "firm",    &firm_isa },
        { "ia32",    &ia32_isa_if },
+       { "arm",     &arm_isa_if },
+       { "ppc",     &ppc32_isa_if },
+       { "mips",    &mips_isa_if },
        { NULL,      NULL }
 };
 
@@ -176,9 +182,9 @@ static be_main_env_t *be_init_env(be_main_env_t *env)
 {
        memset(env, 0, sizeof(*env));
        obstack_init(&env->obst);
-       env->dbg      = firm_dbg_register("be.main");
        env->arch_env = obstack_alloc(&env->obst, sizeof(env->arch_env[0]));
        env->options  = &be_options;
+       FIRM_DBG_REGISTER(env->dbg, "be.main");
 
        arch_env_init(env->arch_env, isa_if);
 

diff --git a/ir/be/beraextern.c b/ir/be/beraextern.c
index d8ce8df..9acc040 100644 (file)
--- a/ir/be/beraextern.c
+++ b/ir/be/beraextern.c
@@ -939,7 +939,7 @@ static void be_ra_extern_main(const be_irg_t *bi) {
        raenv.aenv     = env->arch_env;
        raenv.dom_info = be_compute_dominance_frontiers(irg);
        raenv.vars     = new_set(compare_var_infos, 64);
-       raenv.dbg      = firm_dbg_register("ir.be.raextern");
+       FIRM_DBG_REGISTER(raenv.dbg, "ir.be.raextern");
        firm_dbg_set_mask(raenv.dbg, DBG_LEVEL);
 
        /* Insert copies for constraints */

diff --git a/ir/be/besched.c b/ir/be/besched.c
index a3c0e02..8b731d3 100644 (file)
--- a/ir/be/besched.c
+++ b/ir/be/besched.c
@@ -53,8 +53,8 @@ void be_sched_dump(FILE *f, ir_graph *irg)
 /* Init the scheduling stuff. */
 void be_sched_init(void)
 {
+       FIRM_DBG_REGISTER(firm_dbg_module_t *dbg, "be.sched");
        sched_irn_data_offset = register_additional_node_data(sizeof(sched_info_t));
-       firm_dbg_register("be.sched");
 }
 
 void sched_renumber(const ir_node *block)
@@ -73,7 +73,6 @@ void sched_renumber(const ir_node *block)
 /* Verify a schedule. */
 int sched_verify(const ir_node *block)
 {
-  firm_dbg_module_t *dbg_sched = firm_dbg_register("be.sched");
   int res = 1;
   const ir_node *irn;
   int i, n;
@@ -81,6 +80,7 @@ int sched_verify(const ir_node *block)
   const ir_node **save_nodes;
   const ir_edge_t *edge;
   pset *scheduled_nodes = pset_new_ptr_default();
+  FIRM_DBG_REGISTER(firm_dbg_module_t *dbg_sched, "be.sched");
 
   firm_dbg_set_mask(dbg_sched, -1);
 

diff --git a/ir/be/bespill.c b/ir/be/bespill.c
index 4d691c9..23d2a0a 100644 (file)
--- a/ir/be/bespill.c
+++ b/ir/be/bespill.c
@@ -583,7 +583,7 @@ void be_compute_spill_offsets(be_chordal_env_t *cenv) {
        ssenv.cenv  = cenv;
        ssenv.slots = pmap_create();
        ssenv.types = pmap_create();
-       ssenv.dbg   = firm_dbg_register("ir.be.spillslots");
+       FIRM_DBG_REGISTER(ssenv.dbg, "ir.be.spillslots");
 
        /* Get initial spill slots */
        irg_walk_graph(cenv->irg, NULL, compute_spill_slots_walker, &ssenv);

diff --git a/ir/be/bespillbelady.c b/ir/be/bespillbelady.c
index b54008a..237ef77 100644 (file)
--- a/ir/be/bespillbelady.c
+++ b/ir/be/bespillbelady.c
@@ -635,7 +635,7 @@ static void remove_unused_reloads(ir_graph *irg, belady_env_t *bel) {
 void be_spill_belady(const be_chordal_env_t *chordal_env) {
        belady_env_t bel;
 
-       dbg = firm_dbg_register("ir.be.spillbelady");
+       FIRM_DBG_REGISTER(dbg, "ir.be.spillbelady");
 
        /* init belady env */
        obstack_init(&bel.ob);

diff --git a/ir/be/bespillilp.c b/ir/be/bespillilp.c
index 9ebbee6..457a52d 100644 (file)
--- a/ir/be/bespillilp.c
+++ b/ir/be/bespillilp.c
@@ -635,7 +635,6 @@ void be_spill_ilp(const be_chordal_env_t *chordal_env)
        memset(&si.stats, 0, sizeof(si.stats));
        si.chordal_env     = chordal_env;
        si.obst            = &obst;
-       si.dbg             = firm_dbg_register("be.ra.spillilp");
        si.senv            = be_new_spill_env(si.dbg, chordal_env, is_mem_phi, &si);
        si.cls             = chordal_env->cls;
        si.lpp             = new_lpp(problem_name, lpp_minimize);
@@ -645,6 +644,7 @@ void be_spill_ilp(const be_chordal_env_t *chordal_env)
        si.edges           = NULL;
        si.enable_remat    = 0;
        si.enable_store    = 1;
+       FIRM_DBG_REGISTER(si.dbg, "be.ra.spillilp");
 
        firm_dbg_set_mask(si.dbg, DBG_LEVEL);
        irg_block_walk_graph(chordal_env->irg, process_block, NULL, &si);

diff --git a/ir/be/bessadestr.c b/ir/be/bessadestr.c
index 45a0149..ded0b43 100644 (file)
--- a/ir/be/bessadestr.c
+++ b/ir/be/bessadestr.c
@@ -296,7 +296,7 @@ void be_ssa_destruction(be_chordal_env_t *chordal_env) {
        pmap *perm_map = pmap_create();
        ir_graph *irg = chordal_env->irg;
 
-       dbg = firm_dbg_register("ir.be.ssadestr");
+       FIRM_DBG_REGISTER(dbg, "ir.be.ssadestr");
 
        /* create a map for fast lookup of perms: block --> perm */
        chordal_env->data = perm_map;

diff --git a/ir/be/beuses.c b/ir/be/beuses.c
index e8d5b70..722f83d 100644 (file)
--- a/ir/be/beuses.c
+++ b/ir/be/beuses.c
@@ -160,8 +160,8 @@ be_uses_t *be_begin_uses(ir_graph *irg, const arch_env_t *arch_env, const arch_r
 
   uses->arch_env = arch_env;
   uses->uses     = new_set(cmp_use, 512);
-  uses->dbg      = firm_dbg_register("be.uses");
   uses->irg      = irg;
+  FIRM_DBG_REGISTER(uses->dbg, "be.uses");
   firm_dbg_set_mask(uses->dbg, DBG_LEVEL);
 
   return uses;