arch_spec: Remove remnants of unused operands.

[libfirm] / ir / debug / debugger.c

diff --git a/ir/debug/debugger.c b/ir/debug/debugger.c
index d5a753e..4c1c126 100644 (file)
--- a/ir/debug/debugger.c
+++ b/ir/debug/debugger.c
@@ -22,7 +22,6 @@
  * @brief     Helper function for integrated debug support
  * @author    Michael Beck
  * @date      2005
  * @brief     Helper function for integrated debug support
  * @author    Michael Beck
  * @date      2005

- * @version   $Id$

  */
 #include "config.h"
 
  */
 #include "config.h"
 


@@ -40,6 +39,7 @@
 #include <signal.h>
 #include <string.h>
 #include <strings.h>
 #include <signal.h>
 #include <string.h>
 #include <strings.h>

+#include <time.h>

 
 #include <ctype.h>
 
 
 #include <ctype.h>
 


@@ -53,6 +53,7 @@
 #include "iredges_t.h"
 #include "debug.h"
 #include "error.h"
 #include "iredges_t.h"
 #include "debug.h"
 #include "error.h"

+#include "util.h"

 
 #ifdef _WIN32
 /* Break into the debugger. The Win32 way. */
 
 #ifdef _WIN32
 /* Break into the debugger. The Win32 way. */


@@ -84,12 +85,11 @@ typedef enum {
  * Reasons for node number breakpoints.
  */
 typedef enum bp_reasons_t {
  * Reasons for node number breakpoints.
  */
 typedef enum bp_reasons_t {

-       BP_ON_NEW_NODE,    /**< break if node with number is created */
+       BP_ON_NEW_THING,   /**< break if node, entity or type with number is created */

        BP_ON_REPLACE,     /**< break if node with number is replaced */
        BP_ON_LOWER,       /**< break if node with number is lowered */
        BP_ON_REMIRG,      /**< break if an IRG is removed */
        BP_ON_NEW_ENT,     /**< break if a new entity is created */
        BP_ON_REPLACE,     /**< break if node with number is replaced */
        BP_ON_LOWER,       /**< break if node with number is lowered */
        BP_ON_REMIRG,      /**< break if an IRG is removed */
        BP_ON_NEW_ENT,     /**< break if a new entity is created */

-       BP_ON_NEW_TYPE,    /**< break if a new type is created */

        BP_MAX_REASON
 } bp_reasons_t;
 
        BP_MAX_REASON
 } bp_reasons_t;
 


@@ -118,7 +118,7 @@ typedef struct {
 } bp_ident_t;
 
 /** Calculate the hash value for an ident breakpoint. */
 } bp_ident_t;
 
 /** Calculate the hash value for an ident breakpoint. */

-#define HASH_IDENT_BP(key) (HASH_PTR((key).id) ^ (key).bp.reason)
+#define HASH_IDENT_BP(key) (hash_ptr((key).id) ^ (key).bp.reason)

 
 /** The set containing the breakpoints on node numbers. */
 static set *bp_numbers;
 
 /** The set containing the breakpoints on node numbers. */
 static set *bp_numbers;


@@ -190,7 +190,7 @@ static const char __attribute__((used)) firm_debug_info_string[] =
 int firm_debug_active(void)
 {
        return is_active;
 int firm_debug_active(void)
 {
        return is_active;

-}  /* firm_debug_active */
+}

 
 /**
  * Reset the debug text buffer.
 
 /**
  * Reset the debug text buffer.


@@ -198,42 +198,34 @@ int firm_debug_active(void)
 static void reset_dbg_buf(void)
 {
        firm_dbg_msg_buf[0] = '\0';
 static void reset_dbg_buf(void)
 {
        firm_dbg_msg_buf[0] = '\0';

-}  /* reset_dbg_buf */
-
-static void add_to_dbg_buf(const char *buf)
-{
-       strncat(firm_dbg_msg_buf, buf, sizeof(firm_dbg_msg_buf));
-}  /* add_to_dbg_buf */
+}

 
 const char *firm_debug_text(void)
 {
        firm_dbg_msg_buf[sizeof(firm_dbg_msg_buf) - 1] = '\0';
        return firm_dbg_msg_buf;
 
 const char *firm_debug_text(void)
 {
        firm_dbg_msg_buf[sizeof(firm_dbg_msg_buf) - 1] = '\0';
        return firm_dbg_msg_buf;

-}  /* firm_debug_text */
+}

 
 /**
  * debug output
  */
 static void dbg_printf(const char *fmt, ...)
 {
 
 /**
  * debug output
  */
 static void dbg_printf(const char *fmt, ...)
 {

-       char buf[1024];
-
-       va_list args;
-       va_start(args, fmt);
-

        if (fmt[0] != '+')
                reset_dbg_buf();
        else
                ++fmt;
 
        if (fmt[0] != '+')
                reset_dbg_buf();
        else
                ++fmt;
 

-       ir_vsnprintf(buf, sizeof(buf), fmt, args);
+       va_list args;
+       va_start(args, fmt);
+       if (redir_output) {
+               size_t const cur = strlen(firm_dbg_msg_buf);
+               ir_vsnprintf(firm_dbg_msg_buf + cur, sizeof(firm_dbg_msg_buf) - cur, fmt, args);
+       } else {
+               ir_vprintf(fmt, args);
+       }

        va_end(args);
        va_end(args);

-
-       if (redir_output)
-               add_to_dbg_buf(buf);
-       else
-               puts(buf);
-}  /* dbg_printf */
+}

 
 /**
  * A new node is created.
 
 /**
  * A new node is created.


@@ -249,14 +241,14 @@ static void dbg_new_node(void *ctx, ir_graph *irg, ir_node *node)
        (void) irg;
 
        key.nr        = get_irn_node_nr(node);
        (void) irg;
 
        key.nr        = get_irn_node_nr(node);

-       key.bp.reason = BP_ON_NEW_NODE;
+       key.bp.reason = BP_ON_NEW_THING;

 
 

-       elem = (bp_nr_t*)set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+       elem = set_find(bp_nr_t, bp_numbers, &key, sizeof(key), HASH_NR_BP(key));

        if (elem && elem->bp.active) {
                dbg_printf("Firm BP %u reached, %+F created\n", elem->bp.bpnr, node);
                firm_debug_break();
        }
        if (elem && elem->bp.active) {
                dbg_printf("Firm BP %u reached, %+F created\n", elem->bp.bpnr, node);
                firm_debug_break();
        }

-}  /* dbg_new_node */
+}

 
 /**
  * A node is replaced.
 
 /**
  * A node is replaced.


@@ -273,12 +265,12 @@ static void dbg_replace(void *ctx, ir_node *old, ir_node *nw)
        key.nr        = get_irn_node_nr(old);
        key.bp.reason = BP_ON_REPLACE;
 
        key.nr        = get_irn_node_nr(old);
        key.bp.reason = BP_ON_REPLACE;
 

-       elem = (bp_nr_t*)set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+       elem = set_find(bp_nr_t, bp_numbers, &key, sizeof(key), HASH_NR_BP(key));

        if (elem && elem->bp.active) {
                dbg_printf("Firm BP %u reached, %+F will be replaced by %+F\n", elem->bp.bpnr, old, nw);
                firm_debug_break();
        }
        if (elem && elem->bp.active) {
                dbg_printf("Firm BP %u reached, %+F will be replaced by %+F\n", elem->bp.bpnr, old, nw);
                firm_debug_break();
        }

-}  /* dbg_replace */
+}

 
 /**
  * A new node is lowered.
 
 /**
  * A new node is lowered.


@@ -294,12 +286,12 @@ static void dbg_lower(void *ctx, ir_node *node)
        key.nr        = get_irn_node_nr(node);
        key.bp.reason = BP_ON_LOWER;
 
        key.nr        = get_irn_node_nr(node);
        key.bp.reason = BP_ON_LOWER;
 

-       elem = (bp_nr_t*)set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+       elem = set_find(bp_nr_t, bp_numbers, &key, sizeof(key), HASH_NR_BP(key));

        if (elem && elem->bp.active) {
                dbg_printf("Firm BP %u reached, %+F will be lowered\n", elem->bp.bpnr, node);
                firm_debug_break();
        }
        if (elem && elem->bp.active) {
                dbg_printf("Firm BP %u reached, %+F will be lowered\n", elem->bp.bpnr, node);
                firm_debug_break();
        }

-}  /* dbg_lower */
+}

 
 /**
  * A graph will be deleted.
 
 /**
  * A graph will be deleted.


@@ -315,7 +307,7 @@ static void dbg_free_graph(void *ctx, ir_graph *irg)
                key.nr        = get_irg_graph_nr(irg);
                key.bp.reason = BP_ON_REMIRG;
 
                key.nr        = get_irg_graph_nr(irg);
                key.bp.reason = BP_ON_REMIRG;
 

-               elem = (bp_nr_t*)set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+               elem = set_find(bp_nr_t, bp_numbers, &key, sizeof(key), HASH_NR_BP(key));

                if (elem && elem->bp.active) {
                        ir_printf("Firm BP %u reached, %+F will be deleted\n", elem->bp.bpnr, irg);
                        firm_debug_break();
                if (elem && elem->bp.active) {
                        ir_printf("Firm BP %u reached, %+F will be deleted\n", elem->bp.bpnr, irg);
                        firm_debug_break();


@@ -331,13 +323,13 @@ static void dbg_free_graph(void *ctx, ir_graph *irg)
                key.id        = get_entity_ident(ent);
                key.bp.reason = BP_ON_REMIRG;
 
                key.id        = get_entity_ident(ent);
                key.bp.reason = BP_ON_REMIRG;
 

-               elem = (bp_ident_t*)set_find(bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
+               elem = set_find(bp_ident_t, bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));

                if (elem && elem->bp.active) {
                        dbg_printf("Firm BP %u reached, %+F will be deleted\n", elem->bp.bpnr, ent);
                        firm_debug_break();
                }
        }
                if (elem && elem->bp.active) {
                        dbg_printf("Firm BP %u reached, %+F will be deleted\n", elem->bp.bpnr, ent);
                        firm_debug_break();
                }
        }

-}  /* dbg_free_graph */
+}

 
 /**
  * An entity was created.
 
 /**
  * An entity was created.


@@ -354,7 +346,7 @@ static void dbg_new_entity(void *ctx, ir_entity *ent)
                key.id        = get_entity_ident(ent);
                key.bp.reason = BP_ON_NEW_ENT;
 
                key.id        = get_entity_ident(ent);
                key.bp.reason = BP_ON_NEW_ENT;
 

-               elem = (bp_ident_t*)set_find(bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
+               elem = set_find(bp_ident_t, bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));

                if (elem && elem->bp.active) {
                        ir_printf("Firm BP %u reached, %+F was created\n", elem->bp.bpnr, ent);
                        firm_debug_break();
                if (elem && elem->bp.active) {
                        ir_printf("Firm BP %u reached, %+F was created\n", elem->bp.bpnr, ent);
                        firm_debug_break();


@@ -364,15 +356,15 @@ static void dbg_new_entity(void *ctx, ir_entity *ent)
                bp_nr_t key, *elem;
 
                key.nr        = get_entity_nr(ent);
                bp_nr_t key, *elem;
 
                key.nr        = get_entity_nr(ent);

-               key.bp.reason = BP_ON_NEW_ENT;
+               key.bp.reason = BP_ON_NEW_THING;

 
 

-               elem = (bp_nr_t*)set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+               elem = set_find(bp_nr_t, bp_numbers, &key, sizeof(key), HASH_NR_BP(key));

                if (elem && elem->bp.active) {
                        dbg_printf("Firm BP %u reached, %+F was created\n", elem->bp.bpnr, ent);
                        firm_debug_break();
                }
        }
                if (elem && elem->bp.active) {
                        dbg_printf("Firm BP %u reached, %+F was created\n", elem->bp.bpnr, ent);
                        firm_debug_break();
                }
        }

-}  /* dbg_new_entity */
+}

 
 /**
  * A type was created.
 
 /**
  * A type was created.


@@ -387,15 +379,15 @@ static void dbg_new_type(void *ctx, ir_type *tp)
                bp_nr_t key, *elem;
 
                key.nr        = get_type_nr(tp);
                bp_nr_t key, *elem;
 
                key.nr        = get_type_nr(tp);

-               key.bp.reason = BP_ON_NEW_TYPE;
+               key.bp.reason = BP_ON_NEW_THING;

 
 

-               elem = (bp_nr_t*)set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+               elem = set_find(bp_nr_t, bp_numbers, &key, sizeof(key), HASH_NR_BP(key));

                if (elem && elem->bp.active) {
                        ir_printf("Firm BP %u reached, %+F was created\n", elem->bp.bpnr, tp);
                        firm_debug_break();
                }
        }
                if (elem && elem->bp.active) {
                        ir_printf("Firm BP %u reached, %+F was created\n", elem->bp.bpnr, tp);
                        firm_debug_break();
                }
        }

-}  /* dbg_new_type */
+}

 
 /**
  * Return the reason string.
 
 /**
  * Return the reason string.


@@ -403,16 +395,15 @@ static void dbg_new_type(void *ctx, ir_type *tp)
 static const char *reason_str(bp_reasons_t reason)
 {
        switch (reason) {
 static const char *reason_str(bp_reasons_t reason)
 {
        switch (reason) {

-       case BP_ON_NEW_NODE: return "node creation";
-       case BP_ON_REPLACE:  return "node replace";
-       case BP_ON_LOWER:    return "node lowering";
-       case BP_ON_REMIRG:   return "removing IRG";
-       case BP_ON_NEW_ENT:  return "entity creation";
-       case BP_ON_NEW_TYPE: return "type creation";
-       case BP_MAX_REASON:  break;
+       case BP_ON_NEW_THING: return "node, entity or type creation";
+       case BP_ON_REPLACE:   return "node replace";
+       case BP_ON_LOWER:     return "node lowering";
+       case BP_ON_REMIRG:    return "removing IRG";
+       case BP_ON_NEW_ENT:   return "entity creation";
+       case BP_MAX_REASON:   break;

        }
        panic("unsupported reason");
        }
        panic("unsupported reason");

-}  /* reason_str */
+}

 
 /**
  * Compare two number breakpoints.
 
 /**
  * Compare two number breakpoints.


@@ -424,7 +415,7 @@ static int cmp_nr_bp(const void *elt, const void *key, size_t size)
        (void) size;
 
        return (e1->nr - e2->nr) | (e1->bp.reason - e2->bp.reason);
        (void) size;
 
        return (e1->nr - e2->nr) | (e1->bp.reason - e2->bp.reason);

-}  /* cmp_nr_bp */
+}

 
 /**
  * Compare two ident breakpoints.
 
 /**
  * Compare two ident breakpoints.


@@ -436,15 +427,15 @@ static int cmp_ident_bp(const void *elt, const void *key, size_t size)
        (void) size;
 
        return (e1->id != e2->id) | (e1->bp.reason - e2->bp.reason);
        (void) size;
 
        return (e1->id != e2->id) | (e1->bp.reason - e2->bp.reason);

-}  /* cmp_ident_bp */
+}

 
 /**
  * Update the hooks.
  */
 static void update_hooks(breakpoint *bp)
 {
 
 /**
  * Update the hooks.
  */
 static void update_hooks(breakpoint *bp)
 {

-#define CASE_ON(a, b)  case a: if (! IS_HOOKED(hook_##b)) HOOK(hook_##b, dbg_##b); break
-#define CASE_OFF(a, b) case a: if (IS_HOOKED(hook_##b)) UNHOOK(hook_##b); break
+#define CASE_ON(a, hook, handler)  case a: if (! IS_HOOKED(hook)) HOOK(hook, handler); break
+#define CASE_OFF(a, hook) case a: if (IS_HOOKED(hook)) UNHOOK(hook); break

 
        if (bp->active)
                ++num_active_bp[bp->reason];
 
        if (bp->active)
                ++num_active_bp[bp->reason];


@@ -454,12 +445,18 @@ static void update_hooks(breakpoint *bp)
        if (num_active_bp[bp->reason] > 0) {
                /* register the hooks on demand */
                switch (bp->reason) {
        if (num_active_bp[bp->reason] > 0) {
                /* register the hooks on demand */
                switch (bp->reason) {

-               CASE_ON(BP_ON_NEW_NODE, new_node);
-               CASE_ON(BP_ON_REPLACE, replace);
-               CASE_ON(BP_ON_LOWER, lower);
-               CASE_ON(BP_ON_REMIRG, free_graph);
-               CASE_ON(BP_ON_NEW_ENT, new_entity);
-               CASE_ON(BP_ON_NEW_TYPE, new_type);
+               CASE_ON(BP_ON_REPLACE, hook_replace,    dbg_replace);
+               CASE_ON(BP_ON_LOWER,   hook_lower,      dbg_lower);
+               CASE_ON(BP_ON_REMIRG,  hook_free_graph, dbg_free_graph);
+               CASE_ON(BP_ON_NEW_ENT, hook_new_entity, dbg_new_entity);
+               case BP_ON_NEW_THING:
+                       if (!IS_HOOKED(hook_new_node))
+                               HOOK(hook_new_node, dbg_new_node);
+                       if (!IS_HOOKED(hook_new_type))
+                               HOOK(hook_new_type, dbg_new_type);
+                       if (!IS_HOOKED(hook_new_entity))
+                               HOOK(hook_new_entity, dbg_new_entity);
+                       break;

                default:
                        break;
                }
                default:
                        break;
                }


@@ -467,19 +464,25 @@ static void update_hooks(breakpoint *bp)
        else {
                /* unregister the hook on demand */
                switch (bp->reason) {
        else {
                /* unregister the hook on demand */
                switch (bp->reason) {

-               CASE_OFF(BP_ON_NEW_NODE, new_node);
-               CASE_OFF(BP_ON_REPLACE, replace);
-               CASE_OFF(BP_ON_LOWER, lower);
-               CASE_OFF(BP_ON_REMIRG, free_graph);
-               CASE_OFF(BP_ON_NEW_ENT, new_entity);
-               CASE_OFF(BP_ON_NEW_TYPE, new_type);
+               CASE_OFF(BP_ON_REPLACE,  hook_replace);
+               CASE_OFF(BP_ON_LOWER,    hook_lower);
+               CASE_OFF(BP_ON_REMIRG,   hook_free_graph);
+               CASE_OFF(BP_ON_NEW_ENT,  hook_new_entity);
+               case BP_ON_NEW_THING:
+                       if (IS_HOOKED(hook_new_node))
+                               UNHOOK(hook_new_node);
+                       if (IS_HOOKED(hook_new_type))
+                               UNHOOK(hook_new_type);
+                       if (IS_HOOKED(hook_new_entity))
+                               UNHOOK(hook_new_entity);
+                       break;

                default:
                        break;
                }
        }
 #undef CASE_ON
 #undef CASE_OFF
                default:
                        break;
                }
        }
 #undef CASE_ON
 #undef CASE_OFF

-}  /* update_hooks */
+}

 
 /**
  * Break if nr is reached.
 
 /**
  * Break if nr is reached.


@@ -494,7 +497,7 @@ static void break_on_nr(long nr, bp_reasons_t reason)
        key.bp.reason = reason;
        key.nr        = nr;
 
        key.bp.reason = reason;
        key.nr        = nr;
 

-       elem = (bp_nr_t*)set_insert(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+       elem = set_insert(bp_nr_t, bp_numbers, &key, sizeof(key), HASH_NR_BP(key));

 
        if (elem->bp.bpnr == 0) {
                /* new break point */
 
        if (elem->bp.bpnr == 0) {
                /* new break point */


@@ -506,7 +509,7 @@ static void break_on_nr(long nr, bp_reasons_t reason)
 
                update_hooks(&elem->bp);
        }
 
                update_hooks(&elem->bp);
        }

-}  /* break_on_nr */
+}

 
 /**
  * Break if ident name is reached.
 
 /**
  * Break if ident name is reached.


@@ -521,7 +524,7 @@ static void break_on_ident(const char *name, bp_reasons_t reason)
        key.bp.reason = reason;
        key.id        = new_id_from_str(name);
 
        key.bp.reason = reason;
        key.id        = new_id_from_str(name);
 

-       elem = (bp_ident_t*)set_insert(bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
+       elem = set_insert(bp_ident_t, bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));

 
        if (elem->bp.bpnr == 0) {
                /* new break point */
 
        if (elem->bp.bpnr == 0) {
                /* new break point */


@@ -533,7 +536,7 @@ static void break_on_ident(const char *name, bp_reasons_t reason)
 
                update_hooks(&elem->bp);
        }
 
                update_hooks(&elem->bp);
        }

-}  /* break_on_ident */
+}

 
 /**
  * Sets/resets the active flag of breakpoint bp.
 
 /**
  * Sets/resets the active flag of breakpoint bp.


@@ -554,7 +557,7 @@ static void bp_activate(unsigned bp, int active)
                }
        }
        dbg_printf("Error: Firm BP %u not exists.\n", bp);
                }
        }
        dbg_printf("Error: Firm BP %u not exists.\n", bp);

-}  /* bp_activate */
+}

 
 
 /**
 
 
 /**


@@ -562,7 +565,7 @@ static void bp_activate(unsigned bp, int active)
  */
 static void show_commands(void)
 {
  */
 static void show_commands(void)
 {

-       dbg_printf("Internal Firm debugger extension $Revision$ commands:\n"
+       dbg_printf("Internal Firm debugger extension commands:\n"

                "init                  break after initialization\n"
                "create nr             break if node nr was created\n"
                "replace nr            break if node nr is replaced by another node\n"
                "init                  break after initialization\n"
                "create nr             break if node nr was created\n"
                "replace nr            break if node nr is replaced by another node\n"


@@ -580,9 +583,10 @@ static void show_commands(void)
                "setoutfile name file  redirects debug output of module name to file\n"
                "irgname name          prints address and graph number of a method given by its name\n"
                "irgldname ldname      prints address and graph number of a method given by its ldname\n"
                "setoutfile name file  redirects debug output of module name to file\n"
                "irgname name          prints address and graph number of a method given by its name\n"
                "irgldname ldname      prints address and graph number of a method given by its ldname\n"

+               "initialnodenr n|rand  set initial node number to n or random number\n"

                "help                  list all commands\n"
                );
                "help                  list all commands\n"
                );

-}  /* show_commands */
+}

 
 /**
  * Shows all Firm breakpoints.
 
 /**
  * Shows all Firm breakpoints.


@@ -614,7 +618,7 @@ static void show_bp(void)
                dbg_printf(p->active ? "+enabled" : "+disabled");
        }
        dbg_printf(have_one ? "+\n" : "+ NONE\n");
                dbg_printf(p->active ? "+enabled" : "+disabled");
        }
        dbg_printf(have_one ? "+\n" : "+ NONE\n");

-}  /* show_bp */
+}

 
 /**
  * firm_dbg_register() expects that the name is stored persistent.
 
 /**
  * firm_dbg_register() expects that the name is stored persistent.


@@ -625,7 +629,7 @@ static firm_dbg_module_t *dbg_register(const char *name)
        ident *id = new_id_from_str(name);
 
        return firm_dbg_register(get_id_str(id));
        ident *id = new_id_from_str(name);
 
        return firm_dbg_register(get_id_str(id));

-}  /* dbg_register */
+}

 
 /**
  * Sets the debug mask of module name to lvl
 
 /**
  * Sets the debug mask of module name to lvl


@@ -639,7 +643,7 @@ static void set_dbg_level(const char *name, unsigned lvl)
 
                dbg_printf("Setting debug mask of module %s to %u\n", name, lvl);
        }
 
                dbg_printf("Setting debug mask of module %s to %u\n", name, lvl);
        }

-}  /* set_dbg_level */
+}

 
 /**
  * Redirects the debug output of module name to fname
 
 /**
  * Redirects the debug output of module name to fname


@@ -656,7 +660,7 @@ static void set_dbg_outfile(const char *name, const char *fname)
 
        firm_dbg_set_file(module, f);
        dbg_printf("Redirecting debug output of module %s to file %s\n", name, fname);
 
        firm_dbg_set_file(module, f);
        dbg_printf("Redirecting debug output of module %s to file %s\n", name, fname);

-}  /* set_dbg_outfile */
+}

 
 /**
  * Show info about a firm thing.
 
 /**
  * Show info about a firm thing.


@@ -685,15 +689,13 @@ static void show_firm_object(void *firm_thing)
        case k_ir_op:
        case k_tarval:
        case k_ir_loop:
        case k_ir_op:
        case k_tarval:
        case k_ir_loop:

-       case k_ir_compound_graph_path:
-       case k_ir_extblk:

        case k_ir_prog:
                fprintf(f, "NIY\n");
                break;
        default:
                fprintf(f, "Cannot identify thing at (%p).\n", firm_thing);
        }
        case k_ir_prog:
                fprintf(f, "NIY\n");
                break;
        default:
                fprintf(f, "Cannot identify thing at (%p).\n", firm_thing);
        }

-}  /* show_firm_object */
+}

 
 /**
  * Find a firm type by its number.
 
 /**
  * Find a firm type by its number.


@@ -712,7 +714,7 @@ static ir_type *find_type_nr(long nr)
        if (get_type_nr(tp) == nr)
                return tp;
        return NULL;
        if (get_type_nr(tp) == nr)
                return tp;
        return NULL;

-}  /* find_type_nr */
+}

 
 /**
  * Find a firm type by its name.
 
 /**
  * Find a firm type by its name.


@@ -734,7 +736,7 @@ static ir_type *find_type_name(const char *name)
        if (strcmp(get_compound_name(tp), name) == 0)
                return tp;
        return NULL;
        if (strcmp(get_compound_name(tp), name) == 0)
                return tp;
        return NULL;

-}  /* find_type_name */
+}

 
 /** The environment for the entity search functions. */
 typedef struct find_env {
 
 /** The environment for the entity search functions. */
 typedef struct find_env {


@@ -757,7 +759,7 @@ static void check_ent_nr(type_or_ent tore, void *ctx)
                        env->res = tore.ent;
                }
        }
                        env->res = tore.ent;
                }
        }

-}  /* check_ent_nr */
+}

 
 /**
  * Type-walker: Find an entity with given name.
 
 /**
  * Type-walker: Find an entity with given name.


@@ -770,7 +772,7 @@ static void check_ent_name(type_or_ent tore, void *ctx)
                if (strcmp(get_entity_name(tore.ent), env->u.name) == 0) {
                        env->res = tore.ent;
                }
                if (strcmp(get_entity_name(tore.ent), env->u.name) == 0) {
                        env->res = tore.ent;
                }

-}  /* check_ent_name */
+}

 
 /**
  * Find a firm entity by its number.
 
 /**
  * Find a firm entity by its number.


@@ -783,7 +785,7 @@ static ir_entity *find_entity_nr(long nr)
        env.res  = NULL;
        type_walk(check_ent_nr, NULL, &env);
        return env.res;
        env.res  = NULL;
        type_walk(check_ent_nr, NULL, &env);
        return env.res;

-}  /* find_entity_nr */
+}

 
 /**
  * Find a firm entity by its name.
 
 /**
  * Find a firm entity by its name.


@@ -796,7 +798,7 @@ static ir_entity *find_entity_name(const char *name)
        env.res    = NULL;
        type_walk(check_ent_name, NULL, &env);
        return env.res;
        env.res    = NULL;
        type_walk(check_ent_name, NULL, &env);
        return env.res;

-}  /* find_entity_name */
+}

 
 /**
  * Search methods for a name.
 
 /**
  * Search methods for a name.


@@ -825,7 +827,7 @@ static void show_by_name(type_or_ent tore, void *env)
                        }
                }
        }
                        }
                }
        }

-}  /* show_by_name */
+}

 
 /**
  * Search methods for a ldname.
 
 /**
  * Search methods for a ldname.


@@ -854,7 +856,7 @@ static void show_by_ldname(type_or_ent tore, void *env)
                        }
                }
        }
                        }
                }
        }

-}  /* show_by_ldname */
+}

 
 /**
  * prints the address and graph number of all irgs with given name
 
 /**
  * prints the address and graph number of all irgs with given name


@@ -864,7 +866,7 @@ static void irg_name(const char *name)
        ident *id = new_id_from_str(name);
 
        type_walk(show_by_name, NULL, (void *)id);
        ident *id = new_id_from_str(name);
 
        type_walk(show_by_name, NULL, (void *)id);

-}  /* irg_name */
+}

 
 /**
  * prints the address and graph number of all irgs with given ld_name
 
 /**
  * prints the address and graph number of all irgs with given ld_name


@@ -874,27 +876,29 @@ static void irg_ld_name(const char *name)
        ident *id = new_id_from_str(name);
 
        type_walk(show_by_ldname, NULL, (void *)id);
        ident *id = new_id_from_str(name);
 
        type_walk(show_by_ldname, NULL, (void *)id);

-}  /* irg_ld_name */
+}

 
 enum tokens {
 
 enum tokens {

-       tok_create = 256,
-       tok_replace,
+       first_token = 256,
+       tok_bp = first_token,
+       tok_create,
+       tok_disable,
+       tok_dumpfilter,
+       tok_enable,
+       tok_help,
+       tok_init,
+       tok_irgldname,
+       tok_irgname,

        tok_lower,
        tok_lower,

-       tok_remirg,

        tok_newent,
        tok_newent,

-       tok_newtype,
-       tok_showtype,
-       tok_showent,
-       tok_init,
-       tok_bp,
-       tok_enable,
-       tok_disable,
-       tok_setmask,
+       tok_remirg,
+       tok_replace,

        tok_setlvl,
        tok_setlvl,

+       tok_setmask,

        tok_setoutfile,
        tok_setoutfile,

-       tok_irgname,
-       tok_irgldname,
-       tok_help,
+       tok_showent,
+       tok_showtype,
+       tok_initialnodenr,

        tok_identifier,
        tok_number,
        tok_eof,
        tok_identifier,
        tok_number,
        tok_eof,


@@ -902,24 +906,25 @@ enum tokens {
 };
 
 static const char *reserved[] = {
 };
 
 static const char *reserved[] = {

+       "bp",

        "create",
        "create",

-       "replace",
+       "disable",
+       "dumpfilter",
+       "enable",
+       "help",
+       "init",
+       "irgldname",
+       "irgname",

        "lower",
        "lower",

-       "remirg",

        "newent",
        "newent",

-       "newtype",
-       "showtype",
-       "showent",
-       "init",
-       "bp",
-       "enable",
-       "disable",
-       "setmask",
+       "remirg",
+       "replace",

        "setlvl",
        "setlvl",

+       "setmask",

        "setoutfile",
        "setoutfile",

-       "irgname",
-       "irgldname",
-       "help"
+       "showent",
+       "showtype",
+       "initialnodenr",

 };
 
 /**
 };
 
 /**


@@ -945,7 +950,7 @@ static void init_lexer(const char *input)
        lexer.has_token = 0;
        lexer.curr_pos  = input;
        lexer.end_pos   = input + strlen(input);
        lexer.has_token = 0;
        lexer.curr_pos  = input;
        lexer.end_pos   = input + strlen(input);

-}  /* init_lexer */
+}

 
 
 /**
 
 
 /**


@@ -956,7 +961,7 @@ static char next_char(void)
        if (lexer.curr_pos >= lexer.end_pos)
                return '\0';
        return *lexer.curr_pos++;
        if (lexer.curr_pos >= lexer.end_pos)
                return '\0';
        return *lexer.curr_pos++;

-}  /* next_char */
+}

 
 #define unput()    if (lexer.curr_pos < lexer.end_pos) --lexer.curr_pos
 
 
 #define unput()    if (lexer.curr_pos < lexer.end_pos) --lexer.curr_pos
 


@@ -969,7 +974,7 @@ static char next_char(void)
 static unsigned get_token(void)
 {
        char c;
 static unsigned get_token(void)
 {
        char c;

-       int i;
+       size_t i;

 
        /* skip white space */
        do {
 
        /* skip white space */
        do {


@@ -993,9 +998,9 @@ static unsigned get_token(void)
                        ++tok_start;
                        --len;
                }
                        ++tok_start;
                        --len;
                }

-               for (i = sizeof(reserved)/sizeof(reserved[0]) - 1; i >= 0; --i) {
+               for (i = ARRAY_SIZE(reserved); i-- != 0;) {

                        if (strncasecmp(tok_start, reserved[i], len) == 0 && reserved[i][len] == '\0')
                        if (strncasecmp(tok_start, reserved[i], len) == 0 && reserved[i][len] == '\0')

-                               return 256 + i;
+                               return first_token + i;

                }
 
                /* identifier */
                }
 
                /* identifier */


@@ -1044,7 +1049,7 @@ static unsigned get_token(void)
        else if (c == '\0')
                return tok_eof;
        return c;
        else if (c == '\0')
                return tok_eof;
        return c;

-}  /* get_token */
+}

 
 void firm_debug(const char *cmd)
 {
 
 void firm_debug(const char *cmd)
 {


@@ -1066,7 +1071,7 @@ void firm_debug(const char *cmd)
                        token = get_token();
                        if (token != tok_number)
                                goto error;
                        token = get_token();
                        if (token != tok_number)
                                goto error;

-                       break_on_nr(lexer.number, BP_ON_NEW_NODE);
+                       break_on_nr(lexer.number, BP_ON_NEW_THING);

                        break;
 
                case tok_replace:
                        break;
 
                case tok_replace:


@@ -1101,7 +1106,7 @@ void firm_debug(const char *cmd)
                        token = get_token();
 
                        if (token == tok_number)
                        token = get_token();
 
                        if (token == tok_number)

-                               break_on_nr(lexer.number, BP_ON_NEW_ENT);
+                               break_on_nr(lexer.number, BP_ON_NEW_THING);

                        else if (token == tok_identifier) {
                                len = MIN(lexer.len, 1023);
                                strncpy(name, lexer.s, len);
                        else if (token == tok_identifier) {
                                len = MIN(lexer.len, 1023);
                                strncpy(name, lexer.s, len);


@@ -1111,20 +1116,6 @@ void firm_debug(const char *cmd)
                                goto error;
                        break;
 
                                goto error;
                        break;
 

-               case tok_newtype:
-                       token = get_token();
-
-                       if (token == tok_number)
-                               break_on_nr(lexer.number, BP_ON_NEW_TYPE);
-                       else if (token == tok_identifier) {
-                               len = MIN(lexer.len, 1023);
-                               strncpy(name, lexer.s, len);
-                               name[len] = '\0';
-                               break_on_ident(name, BP_ON_NEW_TYPE);
-                       } else
-                               goto error;
-                       break;
-

                case tok_showtype:
                        token = get_token();
 
                case tok_showtype:
                        token = get_token();
 


@@ -1218,6 +1209,7 @@ void firm_debug(const char *cmd)
                        strncpy(fname, lexer.s, len);
                        fname[len] = '\0';
                        set_dbg_outfile(name, fname);
                        strncpy(fname, lexer.s, len);
                        fname[len] = '\0';
                        set_dbg_outfile(name, fname);

+                       break;

 
                case tok_irgname:
                        token = get_token();
 
                case tok_irgname:
                        token = get_token();


@@ -1227,6 +1219,20 @@ void firm_debug(const char *cmd)
                        strncpy(name, lexer.s, len);
                        name[len] = '\0';
                        irg_name(name);
                        strncpy(name, lexer.s, len);
                        name[len] = '\0';
                        irg_name(name);

+                       break;
+
+               case tok_initialnodenr:
+                       token = get_token();
+                       if (token == tok_number) {
+                               dbg_printf("Setting initial node number to %u\n", lexer.number);
+                               irp->max_node_nr = lexer.number;
+                       } else if (token == tok_identifier && !strcmp(lexer.s, "rand")) {
+                               dbg_printf("Randomizing initial node number\n");
+                               srand(time(0));
+                               irp->max_node_nr += rand() % 6666;
+                       } else
+                               goto error;
+                       break;

 
                case tok_irgldname:
                        token = get_token();
 
                case tok_irgldname:
                        token = get_token();


@@ -1238,6 +1244,16 @@ void firm_debug(const char *cmd)
                        irg_ld_name(name);
                        break;
 
                        irg_ld_name(name);
                        break;
 

+               case tok_dumpfilter:
+                       token = get_token();
+                       if (token != tok_identifier)
+                               goto error;
+                       len = MIN(lexer.len, 1023);
+                       strncpy(name, lexer.s, len);
+                       name[len] = '\0';
+                       ir_set_dump_filter(name);
+                       break;
+

                case tok_help:
                        show_commands();
                        break;
                case tok_help:
                        show_commands();
                        break;


@@ -1258,7 +1274,7 @@ error:
        }
 leave:
        ;
        }
 leave:
        ;

-}  /* firm_debug */
+}

 
 void firm_init_debugger(void)
 {
 
 void firm_init_debugger(void)
 {


@@ -1276,7 +1292,13 @@ void firm_init_debugger(void)
 
        if (break_on_init)
                firm_debug_break();
 
        if (break_on_init)
                firm_debug_break();

-}  /* firm_init_debugger */
+}
+
+void firm_finish_debugger(void)
+{
+       del_set(bp_numbers);
+       del_set(bp_idents);
+}

 
 /**
  * A gdb helper function to print firm objects.
 
 /**
  * A gdb helper function to print firm objects.


@@ -1301,7 +1323,6 @@ const char *gdb_out_edge_helper(const ir_node *node)
        char *b = buf;
        size_t l;
        size_t len = sizeof(buf);
        char *b = buf;
        size_t l;
        size_t len = sizeof(buf);

-       const ir_edge_t *edge;

        foreach_out_edge(node, edge) {
                ir_node *n = get_edge_src_irn(edge);
 
        foreach_out_edge(node, edge) {
                ir_node *n = get_edge_src_irn(edge);