fixed warnings (some of them were actual bugs), leave 1 apparent bug in irgmod.c...

[r14556]

diff --git a/ir/ir/irargs.c b/ir/ir/irargs.c
index 44f5c96..b65c8fb 100644 (file)
--- a/ir/ir/irargs.c
+++ b/ir/ir/irargs.c
@@ -45,16 +45,19 @@
  * identify a firm object type
  */
 static int firm_get_arg_type(const lc_arg_occ_t *occ) {
+  (void) occ;
   /* Firm objects are always pointer */
   return lc_arg_type_ptr;
 }
 
 static int firm_get_arg_type_int(const lc_arg_occ_t *occ) {
+  (void) occ;
   return lc_arg_type_int;
 }
 
 
 static int bitset_get_arg_type(const lc_arg_occ_t *occ) {
+  (void) occ;
   return lc_arg_type_ptr;
 }
 
@@ -295,7 +298,7 @@ lc_arg_env_t *firm_get_arg_env(void)
     X("cg_path",   'P'),
   };
 
-  int i;
+  size_t i;
 
   if(env == NULL) {
     env = lc_arg_new_env();

diff --git a/ir/ir/ircgcons.c b/ir/ir/ircgcons.c
index fda541d..74215b9 100644 (file)
--- a/ir/ir/ircgcons.c
+++ b/ir/ir/ircgcons.c
@@ -469,11 +469,13 @@ static void move_nodes(ir_node * from_block, ir_node * to_block, ir_node * node)
 /* Abhängigkeiten vom Start-Block und den Filter-Operationen im
  * Start-Block auf den Aufrufer hinzufügen. */
 static void construct_start(ir_entity * caller, ir_entity * callee,
-                           ir_node * call, ir_node * exec) {
+                            ir_node * call, ir_node * exec)
+{
   irg_data_t *data  = get_entity_link(callee);
   ir_graph   *irg   = get_entity_irg(callee);
   ir_node    *start = get_irg_start(irg);
   ir_node    *filter;
+  (void) caller;
 
   assert(irg);
   assert(get_entity_peculiarity(callee) == peculiarity_existent); /* Else data is not initalized. */
@@ -876,7 +878,9 @@ void cg_construct(int arr_len, ir_entity ** free_methods_arr) {
 
 
 
-static void destruct_walker(ir_node * node, void * env) {
+static void destruct_walker(ir_node * node, void * env)
+{
+  (void) env;
   if (get_irn_op(node) == op_Block) {
     remove_Block_cg_cfgpred_arr(node);
     /* Do not turn Break into Jmp.  Better: merge blocks right away.

diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c
index 2525cd1..feec913 100644 (file)
--- a/ir/ir/ircons.c
+++ b/ir/ir/ircons.c
@@ -270,6 +270,7 @@ static ir_node *
 new_bd_Const_type(dbg_info *db, ir_node *block, ir_mode *mode, tarval *con, ir_type *tp) {
        ir_node  *res;
        ir_graph *irg = current_ir_graph;
+       (void) block;
 
        res = new_ir_node(db, irg, get_irg_start_block(irg), op_Const, mode, 0, NULL);
        res->attr.con.tv = con;
@@ -841,6 +842,7 @@ new_bd_ASM(dbg_info *db, ir_node *block, int arity, ir_node *in[], ir_asm_constr
            int n_outs, ir_asm_constraint *outputs, int n_clobber, ident *clobber[], ident *asm_text) {
        ir_node  *res;
        ir_graph *irg = current_ir_graph;
+       (void) clobber;
 
        res = new_ir_node(db, irg, block, op_ASM, mode_T, arity, in);
        res->attr.assem.pin_state = op_pin_state_pinned;
@@ -893,7 +895,7 @@ new_rd_End(dbg_info *db, ir_graph *irg, ir_node *block) {
        ir_node  *res;
        ir_graph *rem = current_ir_graph;
 
-       current_ir_graph = rem;
+       current_ir_graph = irg;
        res = new_bd_End(db, block);
        current_ir_graph = rem;
 
@@ -2612,6 +2614,7 @@ new_d_Proj(dbg_info *db, ir_node *arg, ir_mode *mode, long proj) {
 ir_node *
 new_d_defaultProj(dbg_info *db, ir_node *arg, long max_proj) {
        ir_node *res;
+       (void) db;
        assert(arg->op == op_Cond);
        arg->attr.cond.kind = fragmentary;
        arg->attr.cond.default_proj = max_proj;
@@ -3031,6 +3034,7 @@ get_d_value(dbg_info *db, int pos, ir_mode *mode) {
        ir_graph *irg = current_ir_graph;
        assert(get_irg_phase_state(irg) == phase_building);
        inc_irg_visited(irg);
+       (void) db;
 
        return get_r_value_internal(irg->current_block, pos + 1, mode);
 }  /* get_d_value */

diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c
index c56bd13..0b6b800 100644 (file)
--- a/ir/ir/irdump.c
+++ b/ir/ir/irdump.c
@@ -492,6 +492,7 @@ static void ird_set_irg_link(ir_graph *irg, void *x) {
  * Walker, clears the private link field.
  */
 static void clear_link(ir_node * node, void * env) {
+       (void) env;
        ird_set_irn_link(node, NULL);
 }
 
@@ -556,6 +557,7 @@ static void ird_walk_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *pos
  * Walker, allocates an array for all blocks and puts it's nodes non-floating nodes into this array.
  */
 static void collect_node(ir_node * node, void *env) {
+       (void) env;
        if (is_Block(node)
            || node_floats(node)
            || get_irn_op(node) == op_Bad
@@ -687,7 +689,7 @@ int dump_node_opcode(FILE *F, ir_node *n)
                int res;
                char buf[1024];
                res = tarval_snprintf(buf, sizeof(buf), get_Const_tarval(n));
-               assert(res < sizeof(buf) && "buffer to small for tarval_snprintf");
+               assert(res < (int) sizeof(buf) && "buffer to small for tarval_snprintf");
                fprintf(F, buf);
        } break;
 

diff --git a/ir/ir/irdumptxt.c b/ir/ir/irdumptxt.c
index 6dd2df6..f536b05 100644 (file)
--- a/ir/ir/irdumptxt.c
+++ b/ir/ir/irdumptxt.c
@@ -808,9 +808,14 @@ void dump_entity(ir_entity *ent) {
   dump_entity_to_file(stdout, ent, dump_verbosity_max);
 }
 
-void dump_entitycsv_to_file_prefix(FILE *F, ir_entity *ent, char *prefix, unsigned verbosity,
-                                    int *max_disp, int disp[], const char *comma) {
-
+void dump_entitycsv_to_file_prefix(FILE *F, ir_entity *ent, char *prefix,
+                                   unsigned verbosity, int *max_disp,
+                                   int disp[], const char *comma)
+{
+       (void) verbosity;
+       (void) max_disp;
+       (void) disp;
+       (void) comma;
 #if 0   /* Outputs loop depth of all occurrences. */
        int n_acc = get_entity_n_accesses(ent);
        int max_L_freq = -1;
@@ -912,6 +917,8 @@ void dump_entitycsv_to_file_prefix(FILE *F, ir_entity *ent, char *prefix, unsign
 void dump_typecsv_to_file(FILE *F, ir_type *tp, dump_verbosity verbosity, const char *comma) {
        int i;
        char buf[1024 + 10];
+       (void) comma;
+
        if (!is_Class_type(tp)) return;   // we also want array types. Stupid, these are classes in java.
 
        if (verbosity & dump_verbosity_accessStats) {

diff --git a/ir/ir/iredges.c b/ir/ir/iredges.c
index 27dd5b3..0195480 100644 (file)
--- a/ir/ir/iredges.c
+++ b/ir/ir/iredges.c
@@ -70,6 +70,7 @@ typedef struct {
 
 static int get_zero(const ir_node *irn)
 {
+       (void) irn;
        return 0;
 }
 
@@ -169,6 +170,7 @@ static int edge_cmp(const void *p1, const void *p2, size_t len)
 {
        const ir_edge_t *e1 = p1;
        const ir_edge_t *e2 = p2;
+       (void) len;
 
        if(e1->src != e2->src)
                return 1;
@@ -261,7 +263,7 @@ static INLINE void vrfy_list_head(ir_node *irn, ir_edge_kind_t kind) {
                        fprintf(stderr, "- at list entry %d\n", num);
                        if (edge->invalid)
                                fprintf(stderr, "- edge(%ld) is invalid\n", edge_get_id(edge));
-                       if (edge->src);
+                       if (edge->src)
                                ir_fprintf(stderr, "- edge(%ld) %+F(%d)\n", edge_get_id(edge), edge->src, edge->pos);
                        err = 1;
                        break;
@@ -652,6 +654,7 @@ static void clear_links(ir_node *irn, void *env) {
 static void count_user(ir_node *irn, void *env) {
        int i;
        int first;
+       (void) env;
 
        first = get_irn_first(irn);
        for (i = get_irn_arity(irn) - 1; i >= first; --i) {

diff --git a/ir/ir/irflag.c b/ir/ir/irflag.c
index 30b98ce..92fd236 100644 (file)
--- a/ir/ir/irflag.c
+++ b/ir/ir/irflag.c
@@ -157,7 +157,7 @@ static const lc_opt_table_entry_t firm_flags[] = {
 #include "irflag_t.def"
 #undef I_FLAG
 #undef E_FLAG
-       { NULL }
+       LC_OPT_ENT_NULL
 };
 #endif
 

diff --git a/ir/ir/irgmod.c b/ir/ir/irgmod.c
index 1abdf7e..753303c 100644 (file)
--- a/ir/ir/irgmod.c
+++ b/ir/ir/irgmod.c
@@ -125,6 +125,7 @@ void exchange(ir_node *old, ir_node *nw) {
  */
 static void collect(ir_node *n, void *env) {
        ir_node *pred;
+       (void) env;
 
        if (is_Phi(n)) {
                set_irn_link(n, get_irn_link(get_nodes_block(n)));
@@ -209,6 +210,8 @@ void part_block(ir_node *node) {
        set_irn_link(new_block, phi);
        set_irn_link(old_block, NULL);
        while (phi) {
+               /* XXX TODO Matze: this looks buggy, but I'm not sure what would be
+                  the correct thing... */
                if(get_nodes_block(phi) == old_block);   /* @@@ inlinening chokes on phis that don't
                                                                                                 obey this condition.  How do they get into
                                                                                                 the list??? Example: InterfaceIII */

diff --git a/ir/ir/irgopt.c b/ir/ir/irgopt.c
index 144fde8..8e306ec 100644 (file)
--- a/ir/ir/irgopt.c
+++ b/ir/ir/irgopt.c
@@ -68,7 +68,11 @@
  */
 static void optimize_in_place_wrapper (ir_node *n, void *env) {
        ir_node *optimized = optimize_in_place_2(n);
-       if (optimized != n) exchange (n, optimized);
+       (void) env;
+
+       if (optimized != n) {
+               exchange (n, optimized);
+       }
 }
 
 /**
@@ -111,6 +115,8 @@ void local_optimize_node(ir_node *n) {
  * Block-Walker: uses dominance depth to mark dead blocks.
  */
 static void kill_dead_blocks(ir_node *block, void *env) {
+       (void) env;
+
        if (get_Block_dom_depth(block) < 0) {
                /*
                 * Note that the new dominance code correctly handles
@@ -361,6 +367,7 @@ void
 copy_preds(ir_node *n, void *env) {
        ir_node *nn, *block;
        int i, j, irn_arity;
+       (void) env;
 
        nn = get_new_node(n);
 
@@ -655,6 +662,7 @@ dead_node_elimination(ir_graph *irg) {
 static void relink_bad_block_predecessors(ir_node *n, void *env) {
        ir_node **new_in, *irn;
        int i, new_irn_n, old_irn_arity, new_irn_arity = 0;
+       (void) env;
 
        /* if link field of block is NULL, look for bad predecessors otherwise
           this is already done */
@@ -775,6 +783,7 @@ typedef struct _survive_dce_list_t {
 
 static void dead_node_hook(void *context, ir_graph *irg, int start) {
        survive_dce_t *sd = context;
+       (void) irg;
 
        /* Create a new map before the dead node elimination is performed. */
        if (start) {
@@ -793,6 +802,7 @@ static void dead_node_hook(void *context, ir_graph *irg, int start) {
 static void dead_node_subst_hook(void *context, ir_graph *irg, ir_node *old, ir_node *nw) {
        survive_dce_t *sd = context;
        survive_dce_list_t *list = pmap_get(sd->places, old);
+       (void) irg;
 
        /* If the node is to be patched back, write the new address to all registered locations. */
        if (list) {

diff --git a/ir/ir/irgraph.c b/ir/ir/irgraph.c
index 52fcfa2..82bd4c2 100644 (file)
--- a/ir/ir/irgraph.c
+++ b/ir/ir/irgraph.c
@@ -854,7 +854,9 @@ void set_irg_fp_model(ir_graph *irg, unsigned model) {
  * @param n    the node
  * @param env  ignored
  */
-static void normalize_proj_walker(ir_node *n, void *env){
+static void normalize_proj_walker(ir_node *n, void *env)
+{
+  (void) env;
   if (is_Proj(n)) {
     ir_node *pred  = get_Proj_pred(n);
     ir_node *block = get_nodes_block(pred);

diff --git a/ir/ir/irmode.c b/ir/ir/irmode.c
index 8d4a1b8..e96d589 100644 (file)
--- a/ir/ir/irmode.c
+++ b/ir/ir/irmode.c
@@ -449,7 +449,7 @@ void
 tarval *
 get_mode_min(ir_mode *mode) {
        assert(mode);
-       assert(get_mode_modecode(mode) < num_modes);
+       assert(get_mode_modecode(mode) < (modecode) num_modes);
        assert(mode_is_data(mode));
 
        return mode->min;
@@ -458,7 +458,7 @@ get_mode_min(ir_mode *mode) {
 tarval *
 get_mode_max(ir_mode *mode) {
        assert(mode);
-       assert(get_mode_modecode(mode) < num_modes);
+       assert(get_mode_modecode(mode) < (modecode) num_modes);
        assert(mode_is_data(mode));
 
        return mode->max;
@@ -467,7 +467,7 @@ get_mode_max(ir_mode *mode) {
 tarval *
 get_mode_null(ir_mode *mode) {
        assert(mode);
-       assert(get_mode_modecode(mode) < num_modes);
+       assert(get_mode_modecode(mode) < (modecode) num_modes);
        assert(mode_is_data(mode));
 
        return mode->null;
@@ -476,7 +476,7 @@ get_mode_null(ir_mode *mode) {
 tarval *
 get_mode_one(ir_mode *mode) {
        assert(mode);
-       assert(get_mode_modecode(mode) < num_modes);
+       assert(get_mode_modecode(mode) < (modecode) num_modes);
        assert(mode_is_data(mode));
 
        return mode->one;
@@ -485,7 +485,7 @@ get_mode_one(ir_mode *mode) {
 tarval *
 get_mode_minus_one(ir_mode *mode) {
        assert(mode);
-       assert(get_mode_modecode(mode) < num_modes);
+       assert(get_mode_modecode(mode) < (modecode) num_modes);
        assert(mode_is_data(mode));
 
        return mode->minus_one;
@@ -494,7 +494,7 @@ get_mode_minus_one(ir_mode *mode) {
 tarval *
 get_mode_infinite(ir_mode *mode) {
        assert(mode);
-       assert(get_mode_modecode(mode) < num_modes);
+       assert(get_mode_modecode(mode) < (modecode) num_modes);
        assert(mode_is_float(mode));
 
        return get_tarval_plus_inf(mode);
@@ -503,7 +503,7 @@ get_mode_infinite(ir_mode *mode) {
 tarval *
 get_mode_NAN(ir_mode *mode) {
        assert(mode);
-       assert(get_mode_modecode(mode) < num_modes);
+       assert(get_mode_modecode(mode) < (modecode) num_modes);
        assert(mode_is_float(mode));
 
        return get_tarval_nan(mode);

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index c2adb89..086a661 100644 (file)
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -64,7 +64,8 @@ static const char *pnc_name_arr [] = {
  * returns the pnc name from an pnc constant
  */
 const char *get_pnc_string(int pnc) {
-       assert(pnc >= 0 && pnc < sizeof(pnc_name_arr)/sizeof(pnc_name_arr[0]));
+       assert(pnc >= 0 && pnc <
+                       (int) (sizeof(pnc_name_arr)/sizeof(pnc_name_arr[0])));
        return pnc_name_arr[pnc];
 }
 
@@ -522,10 +523,22 @@ void firm_set_irn_section(ir_node *n, struct section *s) {
 }
 #else
 /* Dummies needed for firmjni. */
-struct abstval *get_irn_abst_value(ir_node *n) { return NULL; }
-void set_irn_abst_value(ir_node *n, struct abstval *os) {}
-struct section *firm_get_irn_section(ir_node *n) { return NULL; }
-void firm_set_irn_section(ir_node *n, struct section *s) {}
+struct abstval *get_irn_abst_value(ir_node *n) {
+       (void) n;
+       return NULL;
+}
+void set_irn_abst_value(ir_node *n, struct abstval *os) {
+       (void) n;
+       (void) os;
+}
+struct section *firm_get_irn_section(ir_node *n) {
+       (void) n;
+       return NULL;
+}
+void firm_set_irn_section(ir_node *n, struct section *s) {
+       (void) n;
+       (void) s;
+}
 #endif /* DO_HEAPANALYSIS */
 
 
@@ -2866,6 +2879,7 @@ void (set_Cond_jmp_pred)(ir_node *cond, cond_jmp_predicate pred) {
 
 /** the get_type operation must be always implemented and return a firm type */
 static ir_type *get_Default_type(ir_node *n) {
+       (void) n;
        return get_unknown_type();
 }
 
@@ -2903,6 +2917,7 @@ static ir_entity *get_SymConst_attr_entity(ir_node *self) {
 
 /** the get_type_attr operation must be always implemented */
 static ir_type *get_Null_type(ir_node *n) {
+       (void) n;
        return firm_unknown_type;
 }
 
@@ -2925,6 +2940,7 @@ ir_op_ops *firm_set_default_get_type_attr(ir_opcode code, ir_op_ops *ops) {
 
 /** the get_entity_attr operation must be always implemented */
 static ir_entity *get_Null_ent(ir_node *n) {
+       (void) n;
        return NULL;
 }
 

diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c
index fa9f83a..bab927f 100644 (file)
--- a/ir/ir/iropt.c
+++ b/ir/ir/iropt.c
@@ -3586,7 +3586,7 @@ static int node_cmp_attr_ASM(ir_node *a, ir_node *b) {
        const ir_asm_constraint *cb;
        ident **cla, **clb;
 
-       if (get_ASM_text(a) != get_ASM_text(b));
+       if (get_ASM_text(a) != get_ASM_text(b))
                return 1;
 
        /* Should we really check the constraints here? Should be better, but is strange. */

diff --git a/ir/ir/irprintf.c b/ir/ir/irprintf.c
index cffcbb8..42113f9 100644 (file)
--- a/ir/ir/irprintf.c
+++ b/ir/ir/irprintf.c
@@ -62,7 +62,8 @@
  */
 static void str_init(void *object, size_t n)
 {
-  strcpy(object, "");
+       (void) n;
+       strcpy(object, "");
 }
 
 /**
@@ -92,6 +93,8 @@ static void str_append_str(void *object, size_t n, const char *str)
  */
 static void file_init(void *object, size_t n)
 {
+       (void) object;
+       (void) n;
 }
 
 /**
@@ -99,7 +102,8 @@ static void file_init(void *object, size_t n)
  */
 static void file_append_char(void *object, size_t n, char ch)
 {
-  fputc(ch, object);
+       (void) n;
+       fputc(ch, object);
 }
 
 /**
@@ -107,7 +111,8 @@ static void file_append_char(void *object, size_t n, char ch)
  */
 static void file_append_str(void *object, size_t n, const char *str)
 {
-  fputs(str, object);
+       (void) n;
+       fputs(str, object);
 }
 
 /**
@@ -115,6 +120,8 @@ static void file_append_str(void *object, size_t n, const char *str)
  */
 static void obst_init(void *object, size_t n)
 {
+       (void) object;
+       (void) n;
 }
 
 /**
@@ -122,8 +129,9 @@ static void obst_init(void *object, size_t n)
  */
 static void obst_append_char(void *object, size_t n, char ch)
 {
-  struct obstack *obst = object;
-  obstack_1grow(obst, ch);
+       struct obstack *obst = object;
+       (void) n;
+       obstack_1grow(obst, ch);
 }
 
 /**
@@ -131,8 +139,9 @@ static void obst_append_char(void *object, size_t n, char ch)
  */
 static void obst_append_str(void *object, size_t n, const char *str)
 {
-  struct obstack *obst = object;
-  obstack_grow(obst, str, strlen(str));
+       struct obstack *obst = object;
+       (void) n;
+       obstack_grow(obst, str, strlen(str));
 }
 
 

diff --git a/ir/ir/irprog.c b/ir/ir/irprog.c
index 7770a9c..e48f791 100644 (file)
--- a/ir/ir/irprog.c
+++ b/ir/ir/irprog.c
@@ -298,7 +298,7 @@ void add_irp_mode(ir_mode *mode) {
 void add_irp_opcode(ir_op *opcode) {
        assert(opcode != NULL);
        assert(irp);
-       assert(opcode->code == ARR_LEN(irp->opcodes) && "new_ir_op() called in wrong order");
+       assert(opcode->code == (unsigned) ARR_LEN(irp->opcodes) && "new_ir_op() called in wrong order");
        ARR_APP1(ir_op *, irp->opcodes, opcode);
 }
 

diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c
index 5a05ae1..97107cd 100644 (file)
--- a/ir/ir/irvrfy.c
+++ b/ir/ir/irvrfy.c
@@ -256,6 +256,7 @@ static void show_return_nres(ir_graph *irg, ir_node *n, ir_type *mt) {
  * Show Phi input
  */
 static void show_phi_failure(ir_node *phi, ir_node *pred, int pos) {
+       (void) pos;
        show_entity_failure(phi);
        fprintf(stderr, "  Phi node %ld has mode %s different from predeccessor node %ld mode %s\n",
                get_irn_node_nr(phi), get_mode_name_ex(get_irn_mode(phi)),
@@ -288,6 +289,7 @@ static ir_entity *get_ptr_entity(ir_node *ptr) {
 static int verify_node_Proj_Start(ir_node *n, ir_node *p) {
        ir_mode *mode = get_irn_mode(p);
        long proj     = get_Proj_proj(p);
+       (void) n;
 
        ASSERT_AND_RET_DBG(
                (
@@ -331,6 +333,7 @@ static int verify_node_Proj_Cond(ir_node *pred, ir_node *p) {
 static int verify_node_Proj_Raise(ir_node *n, ir_node *p) {
        ir_mode *mode = get_irn_mode(p);
        long proj     = get_Proj_proj(p);
+       (void) n;
 
        ASSERT_AND_RET_DBG(
                ((proj == pn_Raise_X && mode == mode_X) || (proj == pn_Raise_M && mode == mode_M)),
@@ -346,6 +349,7 @@ static int verify_node_Proj_Raise(ir_node *n, ir_node *p) {
 static int verify_node_Proj_InstOf(ir_node *n, ir_node *p) {
        ir_mode *mode = get_irn_mode(p);
        long proj     = get_Proj_proj(p);
+       (void) n;
 
        ASSERT_AND_RET_DBG(
                (
@@ -530,6 +534,7 @@ static int verify_node_Proj_Mod(ir_node *n, ir_node *p) {
 static int verify_node_Proj_Cmp(ir_node *n, ir_node *p) {
        ir_mode *mode = get_irn_mode(p);
        long proj     = get_Proj_proj(p);
+       (void) n;
 
        ASSERT_AND_RET_DBG(
                (proj >= 0 && proj <= 15 && mode == mode_b),
@@ -623,6 +628,7 @@ static int verify_node_Proj_Store(ir_node *n, ir_node *p) {
 static int verify_node_Proj_Alloc(ir_node *n, ir_node *p) {
        ir_mode *mode = get_irn_mode(p);
        long proj     = get_Proj_proj(p);
+       (void) n;
 
        ASSERT_AND_RET_DBG(
                (
@@ -718,6 +724,8 @@ static int verify_node_Proj_Proj(ir_node *pred, ir_node *p) {
  * verify a Proj(Tuple) node
  */
 static int verify_node_Proj_Tuple(ir_node *n, ir_node *p) {
+       (void) n;
+       (void) p;
        /* We don't test */
        return 1;
 }
@@ -726,6 +734,8 @@ static int verify_node_Proj_Tuple(ir_node *n, ir_node *p) {
  * verify a Proj(CallBegin) node
  */
 static int verify_node_Proj_CallBegin(ir_node *n, ir_node *p) {
+       (void) n;
+       (void) p;
        return 1;
 }
 
@@ -733,6 +743,8 @@ static int verify_node_Proj_CallBegin(ir_node *n, ir_node *p) {
  * verify a Proj(EndReg) node
  */
 static int verify_node_Proj_EndReg(ir_node *n, ir_node *p) {
+       (void) n;
+       (void) p;
        ASSERT_AND_RET(
                (get_irp_ip_view_state() != ip_view_no),
                "EndReg may only appear if ip view is constructed.", 0);
@@ -743,6 +755,8 @@ static int verify_node_Proj_EndReg(ir_node *n, ir_node *p) {
  * verify a Proj(EndExcept) node
  */
 static int verify_node_Proj_EndExcept(ir_node *n, ir_node *p) {
+       (void) n;
+       (void) p;
        ASSERT_AND_RET(
                (get_irp_ip_view_state() != ip_view_no),
                "EndExcept may only appear if ip view is constructed.", 0);
@@ -807,6 +821,7 @@ static int
 verify_node_Proj(ir_node *p, ir_graph *irg) {
        ir_node *pred;
        ir_op *op;
+       (void) irg;
 
        pred = skip_Id(get_Proj_pred(p));
        ASSERT_AND_RET(get_irn_mode(pred) == mode_T, "mode of a 'projed' node is not Tuple", 0);
@@ -864,6 +879,7 @@ static int verify_node_Block(ir_node *n, ir_graph *irg) {
  */
 static int verify_node_Start(ir_node *n, ir_graph *irg) {
        ir_mode *mymode = get_irn_mode(n);
+       (void) irg;
 
        ASSERT_AND_RET(
                /* Start: BB --> X x M x ref x data1 x ... x datan x ref */
@@ -877,6 +893,7 @@ static int verify_node_Start(ir_node *n, ir_graph *irg) {
  */
 static int verify_node_Jmp(ir_node *n, ir_graph *irg) {
        ir_mode *mymode = get_irn_mode(n);
+       (void) irg;
 
        ASSERT_AND_RET(
                /* Jmp: BB --> X */
@@ -891,6 +908,7 @@ static int verify_node_Jmp(ir_node *n, ir_graph *irg) {
 static int verify_node_IJmp(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_IJmp_target(n));
+       (void) irg;
 
        ASSERT_AND_RET(
                /* IJmp: BB x ref --> X */
@@ -904,6 +922,7 @@ static int verify_node_IJmp(ir_node *n, ir_graph *irg) {
  */
 static int verify_node_Break(ir_node *n, ir_graph *irg) {
        ir_mode *mymode = get_irn_mode(n);
+       (void) irg;
 
        ASSERT_AND_RET((get_irp_ip_view_state() != ip_view_no),
                "Break may only appear if ip view is constructed.", 0);
@@ -920,6 +939,7 @@ static int verify_node_Break(ir_node *n, ir_graph *irg) {
 static int verify_node_Cond(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_Cond_selector(n));
+       (void) irg;
 
        ASSERT_AND_RET(
                /* Cond: BB x b --> X x X */
@@ -981,6 +1001,7 @@ static int verify_node_Raise(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_Raise_mem(n));
        ir_mode *op2mode = get_irn_mode(get_Raise_exo_ptr(n));
+       (void) irg;
 
        ASSERT_AND_RET(
                /* Sel: BB x M x ref --> X x M */
@@ -995,6 +1016,7 @@ static int verify_node_Raise(ir_node *n, ir_graph *irg) {
  */
 static int verify_node_Const(ir_node *n, ir_graph *irg) {
        ir_mode *mymode = get_irn_mode(n);
+       (void) irg;
 
        ASSERT_AND_RET(
                /* Const: BB --> data */
@@ -1015,6 +1037,7 @@ static int verify_node_Const(ir_node *n, ir_graph *irg) {
  */
 static int verify_node_SymConst(ir_node *n, ir_graph *irg) {
        ir_mode *mymode = get_irn_mode(n);
+       (void) irg;
 
        if (get_SymConst_kind(n) == symconst_addr_ent) {
                ir_entity *ent = get_SymConst_entity(n);
@@ -1044,6 +1067,7 @@ static int verify_node_Sel(ir_node *n, ir_graph *irg) {
        ir_mode *op1mode = get_irn_mode(get_Sel_mem(n));
        ir_mode *op2mode = get_irn_mode(get_Sel_ptr(n));
        ir_entity *ent;
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                /* Sel: BB x M x ref x int^n --> ref */
@@ -1065,6 +1089,7 @@ static int verify_node_Sel(ir_node *n, ir_graph *irg) {
 static int verify_node_InstOf(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_InstOf_obj(n));
+       (void) irg;
 
        ASSERT_AND_RET(mode_T == mymode, "mode of Instof is not a tuple", 0);
        ASSERT_AND_RET(mode_is_data(op1mode), "Instof not on data", 0);
@@ -1080,6 +1105,7 @@ static int verify_node_Call(ir_node *n, ir_graph *irg) {
        ir_mode *op2mode = get_irn_mode(get_Call_ptr(n));
        ir_type *mt;
        int i;
+       (void) irg;
 
        /* Call: BB x M x ref x data1 x ... x datan
        --> M x datan+1 x ... x data n+m */
@@ -1154,6 +1180,7 @@ static int verify_node_Add(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_Add_left(n));
        ir_mode *op2mode = get_irn_mode(get_Add_right(n));
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                (
@@ -1179,6 +1206,7 @@ static int verify_node_Sub(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_Sub_left(n));
        ir_mode *op2mode = get_irn_mode(get_Sub_right(n));
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                (
@@ -1206,6 +1234,7 @@ static int verify_node_Sub(ir_node *n, ir_graph *irg) {
 static int verify_node_Minus(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_Minus_op(n));
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                /* Minus: BB x num --> num */
@@ -1222,6 +1251,7 @@ static int verify_node_Mul(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_Mul_left(n));
        ir_mode *op2mode = get_irn_mode(get_Mul_right(n));
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                (
@@ -1245,6 +1275,7 @@ static int verify_node_Quot(ir_node *n, ir_graph *irg) {
        ir_mode *op1mode = get_irn_mode(get_Quot_mem(n));
        ir_mode *op2mode = get_irn_mode(get_Quot_left(n));
        ir_mode *op3mode = get_irn_mode(get_Quot_right(n));
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                /* Quot: BB x M x float x float --> M x X x float */
@@ -1265,6 +1296,7 @@ static int verify_node_DivMod(ir_node *n, ir_graph *irg) {
        ir_mode *op1mode = get_irn_mode(get_DivMod_mem(n));
        ir_mode *op2mode = get_irn_mode(get_DivMod_left(n));
        ir_mode *op3mode = get_irn_mode(get_DivMod_right(n));
+       (void) irg;
 
        ASSERT_AND_RET(
                /* DivMod: BB x M x int x int --> M x X x int x int */
@@ -1285,6 +1317,7 @@ static int verify_node_Div(ir_node *n, ir_graph *irg) {
        ir_mode *op1mode = get_irn_mode(get_Div_mem(n));
        ir_mode *op2mode = get_irn_mode(get_Div_left(n));
        ir_mode *op3mode = get_irn_mode(get_Div_right(n));
+       (void) irg;
 
        ASSERT_AND_RET(
                /* Div: BB x M x int x int --> M x X x int */
@@ -1305,6 +1338,7 @@ static int verify_node_Mod(ir_node *n, ir_graph *irg) {
        ir_mode *op1mode = get_irn_mode(get_Mod_mem(n));
        ir_mode *op2mode = get_irn_mode(get_Mod_left(n));
        ir_mode *op3mode = get_irn_mode(get_Mod_right(n));
+       (void) irg;
 
        ASSERT_AND_RET(
                /* Mod: BB x M x int x int --> M x X x int */
@@ -1323,6 +1357,7 @@ static int verify_node_Mod(ir_node *n, ir_graph *irg) {
 static int verify_node_Abs(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_Abs_op(n));
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                /* Abs: BB x num --> num */
@@ -1341,6 +1376,7 @@ static int verify_node_Logic(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_binop_left(n));
        ir_mode *op2mode = get_irn_mode(get_binop_right(n));
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                /* And or Or or Eor: BB x int x int --> int */
@@ -1363,6 +1399,7 @@ static int verify_node_Logic(ir_node *n, ir_graph *irg) {
 static int verify_node_Not(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_Not_op(n));
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                /* Not: BB x int --> int */
@@ -1381,6 +1418,7 @@ static int verify_node_Cmp(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_Cmp_left(n));
        ir_mode *op2mode = get_irn_mode(get_Cmp_right(n));
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                /* Cmp: BB x datab x datab --> b16 */
@@ -1400,6 +1438,7 @@ static int verify_node_Shift(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_binop_left(n));
        ir_mode *op2mode = get_irn_mode(get_binop_right(n));
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                /* Shl, Shr or Shrs: BB x int x int_u --> int */
@@ -1424,6 +1463,7 @@ static int verify_node_Rot(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_Rot_left(n));
        ir_mode *op2mode = get_irn_mode(get_Rot_right(n));
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                /* Rot: BB x int x int --> int */
@@ -1442,6 +1482,7 @@ static int verify_node_Rot(ir_node *n, ir_graph *irg) {
 static int verify_node_Conv(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_Conv_op(n));
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                /* Conv: BB x datab1 --> datab2 */
@@ -1458,6 +1499,7 @@ static int verify_node_Conv(ir_node *n, ir_graph *irg) {
 static int verify_node_Cast(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_Cast_op(n));
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                /* Conv: BB x datab1 --> datab2 */
@@ -1475,6 +1517,7 @@ static int verify_node_Phi(ir_node *n, ir_graph *irg) {
        ir_mode *mymode = get_irn_mode(n);
        ir_node *block  = get_nodes_block(n);
        int i;
+       (void) irg;
 
        if (! is_Bad(block) && get_irg_phase_state(get_irn_irg(n)) != phase_building) {
                /* a Phi node MUST have the same number of inputs as its block */
@@ -1530,6 +1573,8 @@ static int verify_node_Phi(ir_node *n, ir_graph *irg) {
  * verify a Filter node
  */
 static int verify_node_Filter(ir_node *n, ir_graph *irg) {
+       (void) n;
+       (void) irg;
        ASSERT_AND_RET((get_irp_ip_view_state() != ip_view_no),
                "Filter may only appear if ip view is constructed.", 0);
        /* We should further do tests as for Proj and Phi. */
@@ -1612,6 +1657,7 @@ static int verify_node_Alloc(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_Alloc_mem(n));
        ir_mode *op2mode = get_irn_mode(get_Alloc_size(n));
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                /* Alloc: BB x M x int_u --> M x X x ref */
@@ -1633,6 +1679,7 @@ static int verify_node_Free(ir_node *n, ir_graph *irg) {
        ir_mode *op1mode = get_irn_mode(get_Free_mem(n));
        ir_mode *op2mode = get_irn_mode(get_Free_ptr(n));
        ir_mode *op3mode = get_irn_mode(get_Free_size(n));
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                /* Free: BB x M x ref x int_u --> M */
@@ -1652,6 +1699,7 @@ static int verify_node_Free(ir_node *n, ir_graph *irg) {
 static int verify_node_Sync(ir_node *n, ir_graph *irg) {
        int i;
        ir_mode *mymode  = get_irn_mode(n);
+       (void) irg;
 
        /* Sync: BB x M^n --> M */
        for (i = get_Sync_n_preds(n) - 1; i >= 0; --i) {
@@ -1668,6 +1716,7 @@ static int verify_node_Confirm(ir_node *n, ir_graph *irg) {
        ir_mode *mymode  = get_irn_mode(n);
        ir_mode *op1mode = get_irn_mode(get_Confirm_value(n));
        ir_mode *op2mode = get_irn_mode(get_Confirm_bound(n));
+       (void) irg;
 
        ASSERT_AND_RET_DBG(
                /* Confirm: BB x T x T --> T */
@@ -1687,6 +1736,7 @@ static int verify_node_Mux(ir_node *n, ir_graph *irg) {
        ir_mode *op1mode = get_irn_mode(get_Mux_sel(n));
        ir_mode *op2mode = get_irn_mode(get_Mux_true(n));
        ir_mode *op3mode = get_irn_mode(get_Mux_false(n));
+       (void) irg;
 
        ASSERT_AND_RET(
                /* Mux: BB x b x numP x numP --> numP */
@@ -1743,6 +1793,7 @@ static int verify_node_Bound(ir_node *n, ir_graph *irg) {
        ir_mode *op2mode = get_irn_mode(get_Bound_index(n));
        ir_mode *op3mode = get_irn_mode(get_Bound_lower(n));
        ir_mode *op4mode = get_irn_mode(get_Bound_upper(n));
+       (void) irg;
 
        /* Bound: BB x M x int x int x int --> M x X */
        ASSERT_AND_RET(