sparc: implement 64bit lowering

[libfirm] / ir / debug / debugger.c

diff --git a/ir/debug/debugger.c b/ir/debug/debugger.c
index a12597b..b2cafc0 100644 (file)
--- a/ir/debug/debugger.c
+++ b/ir/debug/debugger.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2010 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -39,10 +39,7 @@
 #include <stdio.h>
 #include <signal.h>
 #include <string.h>
-
-#ifdef HAVE_STRINGS_H
 #include <strings.h>
-#endif
 
 #include <ctype.h>
 
@@ -86,7 +83,7 @@ typedef enum {
 /**
  * Reasons for node number breakpoints.
  */
-typedef enum _bp_reasons_t {
+typedef enum bp_reasons_t {
        BP_ON_NEW_NODE,    /**< break if node with number is created */
        BP_ON_REPLACE,     /**< break if node with number is replaced */
        BP_ON_LOWER,       /**< break if node with number is lowered */
@@ -97,12 +94,12 @@ typedef enum _bp_reasons_t {
 } bp_reasons_t;
 
 /** A breakpoint. */
-typedef struct _breakpoint {
+typedef struct breakpoint {
        bp_kind      kind;        /**< the kind of this break point */
        unsigned     bpnr;        /**< break point number */
        int          active;      /**< non-zero, if this break point is active */
        bp_reasons_t reason;      /**< reason for the breakpoint */
-       struct _breakpoint *next; /**< link to the next one */
+       struct breakpoint *next; /**< link to the next one */
 } breakpoint;
 
 /** A number breakpoint. */
@@ -187,7 +184,7 @@ do {                                        \
 #define FIRM_DBG_MINOR  0
 
 /** for automatic detection of the debug extension */
-static const char firm_debug_info_string[] =
+static const char __attribute__((used)) firm_debug_info_string[] =
        API_VERSION(FIRM_DBG_MAJOR, FIRM_DBG_MINOR);
 
 int firm_debug_active(void)
@@ -254,7 +251,7 @@ static void dbg_new_node(void *ctx, ir_graph *irg, ir_node *node)
        key.nr        = get_irn_node_nr(node);
        key.bp.reason = BP_ON_NEW_NODE;
 
-       elem = set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+       elem = (bp_nr_t*)set_find(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();
@@ -276,7 +273,7 @@ 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;
 
-       elem = set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+       elem = (bp_nr_t*)set_find(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();
@@ -297,7 +294,7 @@ static void dbg_lower(void *ctx, ir_node *node)
        key.nr        = get_irn_node_nr(node);
        key.bp.reason = BP_ON_LOWER;
 
-       elem = set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+       elem = (bp_nr_t*)set_find(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();
@@ -318,7 +315,7 @@ static void dbg_free_graph(void *ctx, ir_graph *irg)
                key.nr        = get_irg_graph_nr(irg);
                key.bp.reason = BP_ON_REMIRG;
 
-               elem = set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+               elem = (bp_nr_t*)set_find(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();
@@ -334,7 +331,7 @@ static void dbg_free_graph(void *ctx, ir_graph *irg)
                key.id        = get_entity_ident(ent);
                key.bp.reason = BP_ON_REMIRG;
 
-               elem = set_find(bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
+               elem = (bp_ident_t*)set_find(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();
@@ -357,7 +354,7 @@ static void dbg_new_entity(void *ctx, ir_entity *ent)
                key.id        = get_entity_ident(ent);
                key.bp.reason = BP_ON_NEW_ENT;
 
-               elem = set_find(bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
+               elem = (bp_ident_t*)set_find(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();
@@ -369,7 +366,7 @@ static void dbg_new_entity(void *ctx, ir_entity *ent)
                key.nr        = get_entity_nr(ent);
                key.bp.reason = BP_ON_NEW_ENT;
 
-               elem = set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+               elem = (bp_nr_t*)set_find(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();
@@ -392,7 +389,7 @@ static void dbg_new_type(void *ctx, ir_type *tp)
                key.nr        = get_type_nr(tp);
                key.bp.reason = BP_ON_NEW_TYPE;
 
-               elem = set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+               elem = (bp_nr_t*)set_find(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();
@@ -422,8 +419,8 @@ static const char *reason_str(bp_reasons_t reason)
  */
 static int cmp_nr_bp(const void *elt, const void *key, size_t size)
 {
-       const bp_nr_t *e1 = elt;
-       const bp_nr_t *e2 = key;
+       const bp_nr_t *e1 = (const bp_nr_t*)elt;
+       const bp_nr_t *e2 = (const bp_nr_t*)key;
        (void) size;
 
        return (e1->nr - e2->nr) | (e1->bp.reason - e2->bp.reason);
@@ -434,8 +431,8 @@ static int cmp_nr_bp(const void *elt, const void *key, size_t size)
  */
 static int cmp_ident_bp(const void *elt, const void *key, size_t size)
 {
-       const bp_ident_t *e1 = elt;
-       const bp_ident_t *e2 = key;
+       const bp_ident_t *e1 = (const bp_ident_t*)elt;
+       const bp_ident_t *e2 = (const bp_ident_t*)key;
        (void) size;
 
        return (e1->id != e2->id) | (e1->bp.reason - e2->bp.reason);
@@ -464,7 +461,7 @@ static void update_hooks(breakpoint *bp)
                CASE_ON(BP_ON_NEW_ENT, new_entity);
                CASE_ON(BP_ON_NEW_TYPE, new_type);
                default:
-                       ;
+                       break;
                }
        }
        else {
@@ -477,7 +474,7 @@ static void update_hooks(breakpoint *bp)
                CASE_OFF(BP_ON_NEW_ENT, new_entity);
                CASE_OFF(BP_ON_NEW_TYPE, new_type);
                default:
-                       ;
+                       break;
                }
        }
 #undef CASE_ON
@@ -497,7 +494,7 @@ static void break_on_nr(long nr, bp_reasons_t reason)
        key.bp.reason = reason;
        key.nr        = nr;
 
-       elem = set_insert(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+       elem = (bp_nr_t*)set_insert(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
 
        if (elem->bp.bpnr == 0) {
                /* new break point */
@@ -524,7 +521,7 @@ static void break_on_ident(const char *name, bp_reasons_t reason)
        key.bp.reason = reason;
        key.id        = new_id_from_str(name);
 
-       elem = set_insert(bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
+       elem = (bp_ident_t*)set_insert(bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
 
        if (elem->bp.bpnr == 0) {
                /* new break point */
@@ -677,10 +674,10 @@ static void show_firm_object(void *firm_thing)
                fprintf(f, "BAD: (%p)\n", firm_thing);
                break;
        case k_entity:
-               dump_entity_to_file(f, firm_thing, dump_verbosity_max);
+               dump_entity_to_file(f, (ir_entity*)firm_thing);
                break;
        case k_type:
-               dump_type_to_file(f, firm_thing, dump_verbosity_max);
+               dump_type_to_file(f, (ir_type*)firm_thing);
                break;
        case k_ir_graph:
        case k_ir_node:
@@ -753,7 +750,7 @@ typedef struct find_env {
  */
 static void check_ent_nr(type_or_ent tore, void *ctx)
 {
-       find_env_t *env = ctx;
+       find_env_t *env = (find_env_t*)ctx;
 
        if (is_entity(tore.ent)) {
                if (get_entity_nr(tore.ent) == env->u.nr) {
@@ -767,7 +764,7 @@ static void check_ent_nr(type_or_ent tore, void *ctx)
  */
 static void check_ent_name(type_or_ent tore, void *ctx)
 {
-       find_env_t *env = ctx;
+       find_env_t *env = (find_env_t*)ctx;
 
        if (is_entity(tore.ent))
                if (strcmp(get_entity_name(tore.ent), env->u.name) == 0) {
@@ -933,7 +930,7 @@ static struct lexer {
        unsigned cur_token;   /**< current token. */
        unsigned number;      /**< current token attribute. */
        const char *s;        /**< current token attribute. */
-       unsigned len;         /**< current token attribute. */
+       size_t len;           /**< current token attribute. */
 
        const char *curr_pos;
        const char *end_pos;
@@ -961,7 +958,7 @@ static char next_char(void)
        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
 
 #undef MIN
 #define MIN(a, b) (a) < (b) ? (a) : (b)
@@ -1052,7 +1049,7 @@ static unsigned get_token(void)
 void firm_debug(const char *cmd)
 {
        char name[1024], fname[1024];
-       int len;
+       size_t len;
 
        init_lexer(cmd);