Let sched_foreach_from() and sched_foreach_reverse_from() declare their iterator...

diff --git a/ir/be/TEMPLATE/TEMPLATE_emitter.c b/ir/be/TEMPLATE/TEMPLATE_emitter.c
index 93e7494..424ec4d 100644 (file)
--- a/ir/be/TEMPLATE/TEMPLATE_emitter.c
+++ b/ir/be/TEMPLATE/TEMPLATE_emitter.c
@@ -212,8 +212,6 @@ static void TEMPLATE_emit_node(const ir_node *node)
  */
 static void TEMPLATE_emit_block(ir_node *block)
 {
-       ir_node *node;
-
        be_gas_begin_block(block, true);
 
        sched_foreach(block, node) {

diff --git a/ir/be/amd64/amd64_emitter.c b/ir/be/amd64/amd64_emitter.c
index 7b2dbdb..55f3aa7 100644 (file)
--- a/ir/be/amd64/amd64_emitter.c
+++ b/ir/be/amd64/amd64_emitter.c
@@ -533,7 +533,6 @@ static void amd64_emit_node(const ir_node *node)
  */
 static void amd64_gen_block(ir_node *block, void *data)
 {
-       ir_node *node;
        (void) data;
 
        if (! is_Block(block))

diff --git a/ir/be/arm/arm_emitter.c b/ir/be/arm/arm_emitter.c
index b18393d..eebb947 100644 (file)
--- a/ir/be/arm/arm_emitter.c
+++ b/ir/be/arm/arm_emitter.c
@@ -875,8 +875,6 @@ static void arm_emit_block_header(ir_node *block, ir_node *prev)
  */
 static void arm_gen_block(ir_node *block, ir_node *prev_block)
 {
-       ir_node *irn;
-
        arm_emit_block_header(block, prev_block);
        be_dwarf_location(get_irn_dbg_info(block));
        sched_foreach(block, irn) {

diff --git a/ir/be/bechordal_common.c b/ir/be/bechordal_common.c
index 2a3e634..c6dce09 100644 (file)
--- a/ir/be/bechordal_common.c
+++ b/ir/be/bechordal_common.c
@@ -112,10 +112,9 @@ void create_borders(ir_node *block, void *env_ptr)
 #define border_use(irn, step, real) \
        border_add(env, head, irn, step, ++pressure, 0, real)
 
-       be_chordal_env_t *env             = (be_chordal_env_t*)env_ptr;
-       bitset_t *live                    = bitset_malloc(get_irg_last_idx(env->irg));
-       ir_node *irn;
-       be_lv_t *lv                       = be_get_irg_liveness(env->irg);
+       be_chordal_env_t *env  = (be_chordal_env_t*)env_ptr;
+       bitset_t         *live = bitset_malloc(get_irg_last_idx(env->irg));
+       be_lv_t          *lv   = be_get_irg_liveness(env->irg);
 
        int i, n;
        size_t elm;

diff --git a/ir/be/beflags.c b/ir/be/beflags.c
index b7c8494..3ffae62 100644 (file)
--- a/ir/be/beflags.c
+++ b/ir/be/beflags.c
@@ -203,19 +203,21 @@ static void rematerialize_or_move(ir_node *flags_needed, ir_node *node,
  */
 static void fix_flags_walker(ir_node *block, void *env)
 {
-       ir_node *node;
        ir_node *flags_needed   = NULL;
        ir_node *flag_consumers = NULL;
        int      pn = -1;
        (void) env;
 
+       ir_node *place = block;
        sched_foreach_reverse(block, node) {
                int i, arity;
                ir_node *new_flags_needed = NULL;
                ir_node *test;
 
-               if (is_Phi(node))
+               if (is_Phi(node)) {
+                       place = node;
                        break;
+               }
 
                if (node == flags_needed) {
                        /* all ok */
@@ -278,7 +280,7 @@ static void fix_flags_walker(ir_node *block, void *env)
 
        if (flags_needed != NULL) {
                assert(get_nodes_block(flags_needed) != block);
-               rematerialize_or_move(flags_needed, node, flag_consumers, pn);
+               rematerialize_or_move(flags_needed, place, flag_consumers, pn);
                flags_needed   = NULL;
                flag_consumers = NULL;
        }

diff --git a/ir/be/beirgmod.c b/ir/be/beirgmod.c
index c63e853..43fa068 100644 (file)
--- a/ir/be/beirgmod.c
+++ b/ir/be/beirgmod.c
@@ -158,7 +158,6 @@ static void remove_empty_block(ir_node *block)
 {
        int        i;
        int        arity;
-       ir_node   *node;
        ir_node   *pred;
        ir_node   *succ_block;
        ir_node   *jump = NULL;
@@ -212,7 +211,7 @@ static void remove_empty_block(ir_node *block)
        /* there can be some non-scheduled Pin nodes left in the block, move them
         * to the succ block (Pin) or pred block (Sync) */
        foreach_out_edge_safe(block, edge) {
-               node = get_edge_src_irn(edge);
+               ir_node *const node = get_edge_src_irn(edge);
 
                if (node == jump)
                        continue;

diff --git a/ir/be/belive.c b/ir/be/belive.c
index bb1f804..643d9fa 100644 (file)
--- a/ir/be/belive.c
+++ b/ir/be/belive.c
@@ -561,7 +561,6 @@ void be_liveness_nodes_live_at(const be_lv_t *lv,
                                const ir_node *pos, ir_nodeset_t *live)
 {
        const ir_node *bl = is_Block(pos) ? pos : get_nodes_block(pos);
-       ir_node *irn;
 
        be_liveness_end_of_block(lv, cls, bl, live);
        sched_foreach_reverse(bl, irn) {

diff --git a/ir/be/beloopana.c b/ir/be/beloopana.c
index 815b190..f83e4c9 100644 (file)
--- a/ir/be/beloopana.c
+++ b/ir/be/beloopana.c
@@ -74,10 +74,9 @@ static unsigned be_compute_block_pressure(const ir_graph *irg,
                                           ir_node *block,
                                           const arch_register_class_t *cls)
 {
-       be_lv_t      *lv = be_get_irg_liveness(irg);
-       ir_nodeset_t  live_nodes;
-       ir_node      *irn;
-       size_t        max_live;
+       be_lv_t     *lv = be_get_irg_liveness(irg);
+       ir_nodeset_t live_nodes;
+       size_t       max_live;
 
        DBG((dbg, LEVEL_1, "Processing Block %+F\n", block));
 

diff --git a/ir/be/belower.c b/ir/be/belower.c
index 9b7c013..3082c80 100644 (file)
--- a/ir/be/belower.c
+++ b/ir/be/belower.c
@@ -619,7 +619,6 @@ static void assure_different_constraints(ir_node *irn, ir_node *skipped_irn, con
  */
 static void assure_constraints_walker(ir_node *block, void *walk_env)
 {
-       ir_node *irn;
        constraint_env_t *env = (constraint_env_t*)walk_env;
 
        sched_foreach_reverse(block, irn) {
@@ -856,7 +855,6 @@ static int push_through_perm(ir_node *perm)
        int n_moved;
        int new_size;
        ir_node *frontier = bl;
-       ir_node *irn;
        int i, n;
 
        /* get some Proj and find out the register class of that Proj. */

diff --git a/ir/be/bepbqpcoloring.c b/ir/be/bepbqpcoloring.c
index a8e671f..f02ba18 100644 (file)
--- a/ir/be/bepbqpcoloring.c
+++ b/ir/be/bepbqpcoloring.c
@@ -319,7 +319,6 @@ static void create_pbqp_coloring_instance(ir_node *block, void *data)
        pbqp_t                      *pbqp_inst          = pbqp_alloc_env->pbqp_inst;
        plist_t                     *temp_list          = plist_new();
        plist_element_t             *el;
-       ir_node                     *irn;
        ir_nodeset_t                 live_nodes;
 #if USE_BIPARTIT_MATCHING
        int                         *assignment         = ALLOCAN(int, cls->n_regs);

diff --git a/ir/be/beprefalloc.c b/ir/be/beprefalloc.c
index 3740ff7..62fbb69 100644 (file)
--- a/ir/be/beprefalloc.c
+++ b/ir/be/beprefalloc.c
@@ -316,9 +316,8 @@ static void check_defs(const ir_nodeset_t *live_nodes, float weight,
  */
 static void analyze_block(ir_node *block, void *data)
 {
-       float         weight = (float)get_block_execfreq(execfreqs, block);
-       ir_nodeset_t  live_nodes;
-       ir_node      *node;
+       float        weight = (float)get_block_execfreq(execfreqs, block);
+       ir_nodeset_t live_nodes;
        (void) data;
 
        ir_nodeset_init(&live_nodes);
@@ -439,8 +438,7 @@ static void congruence_def(ir_nodeset_t *live_nodes, const ir_node *node)
 
 static void create_congruence_class(ir_node *block, void *data)
 {
-       ir_nodeset_t  live_nodes;
-       ir_node      *node;
+       ir_nodeset_t live_nodes;
 
        (void) data;
        ir_nodeset_init(&live_nodes);
@@ -478,7 +476,6 @@ static void create_congruence_class(ir_node *block, void *data)
                        unsigned              r;
                        int                   old_node_idx;
                        ir_node              *live;
-                       ir_node              *phi;
                        allocation_info_t    *head_info;
                        allocation_info_t    *other_info;
                        ir_node              *op     = get_Phi_pred(node, i);
@@ -1604,7 +1601,6 @@ static void assign_phi_registers(ir_node *block)
        int                  n;
        int                  res;
        unsigned            *assignment;
-       ir_node             *node;
        hungarian_problem_t *bp;
 
        /* count phi nodes */
@@ -1692,7 +1688,6 @@ static void allocate_coalesce_block(ir_node *block, void *data)
 {
        int            i;
        ir_nodeset_t   live_nodes;
-       ir_node       *node;
        int            n_preds;
        block_info_t  *block_info;
        block_info_t **pred_block_infos;
@@ -1727,7 +1722,7 @@ static void allocate_coalesce_block(ir_node *block, void *data)
                const arch_register_t     *reg;
                int                        p;
 
-               node = be_lv_get_irn(lv, block, i);
+               ir_node *node = be_lv_get_irn(lv, block, i);
                req  = arch_get_irn_register_req(node);
                if (req->cls != cls)
                        continue;
@@ -1812,7 +1807,8 @@ static void allocate_coalesce_block(ir_node *block, void *data)
        /* all live-ins must have a register */
 #ifdef DEBUG_libfirm
        {
-               ir_nodeset_iterator_t  iter;
+               ir_nodeset_iterator_t iter;
+               ir_node              *node;
                foreach_ir_nodeset(&live_nodes, node, iter) {
                        const arch_register_t *reg = arch_get_irn_register(node);
                        assert(reg != NULL);

diff --git a/ir/be/besched.c b/ir/be/besched.c
index 5f87b70..276a21d 100644 (file)
--- a/ir/be/besched.c
+++ b/ir/be/besched.c
@@ -50,7 +50,6 @@
 
 static void sched_renumber(const ir_node *block)
 {
-       ir_node *irn;
        sched_info_t *inf;
        sched_timestep_t step = SCHED_INITIAL_GRANULARITY;
 

diff --git a/ir/be/besched.h b/ir/be/besched.h
index bec0dc1..f333d22 100644 (file)
--- a/ir/be/besched.h
+++ b/ir/be/besched.h
@@ -199,10 +199,10 @@ static inline bool sched_comes_after(const ir_node *n1, const ir_node *n2)
 }
 
 #define sched_foreach_from(from, irn) \
-  for(irn = from; !sched_is_end(irn); irn = sched_next(irn))
+  for (ir_node *irn = from; !sched_is_end(irn); irn = sched_next(irn))
 
 #define sched_foreach_reverse_from(from, irn) \
-  for(irn = from; !sched_is_begin(irn); irn = sched_prev(irn))
+  for (ir_node *irn = from; !sched_is_begin(irn); irn = sched_prev(irn))
 
 /**
  * A shorthand macro for iterating over a schedule.

diff --git a/ir/be/beschedregpress.c b/ir/be/beschedregpress.c
index 1277f48..b464d09 100644 (file)
--- a/ir/be/beschedregpress.c
+++ b/ir/be/beschedregpress.c
@@ -174,7 +174,6 @@ static void *reg_pressure_graph_init(ir_graph *irg)
 
 static void *reg_pressure_block_init(void *graph_env, ir_node *bl)
 {
-       ir_node *irn;
        reg_pressure_selector_env_t *env = XMALLOC(reg_pressure_selector_env_t);
        (void) graph_env;
 

diff --git a/ir/be/bespill.c b/ir/be/bespill.c
index fa542d9..7dd59cd 100644 (file)
--- a/ir/be/bespill.c
+++ b/ir/be/bespill.c
@@ -221,7 +221,6 @@ static void prepare_constr_insn(be_pre_spill_env_t *env, ir_node *node)
 static void pre_spill_prepare_constr_walker(ir_node *block, void *data)
 {
        be_pre_spill_env_t *env = (be_pre_spill_env_t*)data;
-       ir_node *node;
        sched_foreach(block, node) {
                prepare_constr_insn(env, node);
        }

diff --git a/ir/be/bespillbelady.c b/ir/be/bespillbelady.c
index e14db56..02b9b4e 100644 (file)
--- a/ir/be/bespillbelady.c
+++ b/ir/be/bespillbelady.c
@@ -540,7 +540,6 @@ static void decide_start_workset(const ir_node *block)
 {
        ir_loop    *loop = get_irn_loop(block);
        ir_node    *first;
-       ir_node    *node;
        loc_t       loc;
        loc_t      *starters;
        loc_t      *delayed;
@@ -761,7 +760,6 @@ static void decide_start_workset(const ir_node *block)
 static void process_block(ir_node *block)
 {
        workset_t    *new_vals;
-       ir_node      *irn;
        unsigned      iter;
        block_info_t *block_info;
        int           arity;
@@ -793,9 +791,11 @@ static void process_block(ir_node *block)
        set_block_info(block, block_info);
 
        DB((dbg, DBG_WSETS, "Start workset for %+F:\n", block));
-       workset_foreach(ws, irn, iter) {
-               DB((dbg, DBG_WSETS, "  %+F (%u)\n", irn,
-                    workset_get_time(ws, iter)));
+       {
+               ir_node *irn;
+               workset_foreach(ws, irn, iter) {
+                       DB((dbg, DBG_WSETS, "  %+F (%u)\n", irn, workset_get_time(ws, iter)));
+               }
        }
 
        block_info->start_workset = workset_clone(ws);
@@ -843,8 +843,11 @@ static void process_block(ir_node *block)
        /* Remember end-workset for this block */
        block_info->end_workset = workset_clone(ws);
        DB((dbg, DBG_WSETS, "End workset for %+F:\n", block));
-       workset_foreach(ws, irn, iter)
-               DB((dbg, DBG_WSETS, "  %+F (%u)\n", irn, workset_get_time(ws, iter)));
+       {
+               ir_node *irn;
+               workset_foreach(ws, irn, iter)
+                       DB((dbg, DBG_WSETS, "  %+F (%u)\n", irn, workset_get_time(ws, iter)));
+       }
 }
 
 /**

diff --git a/ir/be/bespilldaemel.c b/ir/be/bespilldaemel.c
index f2e0c51..4dd904f 100644 (file)
--- a/ir/be/bespilldaemel.c
+++ b/ir/be/bespilldaemel.c
@@ -278,13 +278,12 @@ void print_nodeset(ir_nodeset_t *nodeset)
  */
 static void spill_block(ir_node *block, void *data)
 {
-       ir_nodeset_t           live_nodes;
-       ir_nodeset_iterator_t  iter;
-       ir_node               *node;
-       int                    n_phi_values_spilled;
-       int                    regpressure;
-       int                    live_nodes_pressure;
-       int                    phi_spills_needed;
+       ir_nodeset_t          live_nodes;
+       ir_nodeset_iterator_t iter;
+       int                   n_phi_values_spilled;
+       int                   regpressure;
+       int                   live_nodes_pressure;
+       int                   phi_spills_needed;
        (void) data;
 
        DBG((dbg, LEVEL_1, "spilling block %+F\n", block));
@@ -294,13 +293,16 @@ static void spill_block(ir_node *block, void *data)
        be_liveness_end_of_block(lv, cls, block, &live_nodes);
 
        /* remove already spilled nodes from liveset */
-       foreach_ir_nodeset(&live_nodes, node, iter) {
-               DBG((dbg, LEVEL_2, "\t%+F is live-end... ", node));
-               if (bitset_is_set(spilled_nodes, get_irn_idx(node))) {
-                       DBG((dbg, LEVEL_2, "but spilled; removing.\n"));
-                       ir_nodeset_remove_iterator(&live_nodes, &iter);
-               } else {
-                       DBG((dbg, LEVEL_2, "keeping.\n"));
+       {
+               ir_node *node;
+               foreach_ir_nodeset(&live_nodes, node, iter) {
+                       DBG((dbg, LEVEL_2, "\t%+F is live-end... ", node));
+                       if (bitset_is_set(spilled_nodes, get_irn_idx(node))) {
+                               DBG((dbg, LEVEL_2, "but spilled; removing.\n"));
+                               ir_nodeset_remove_iterator(&live_nodes, &iter);
+                       } else {
+                               DBG((dbg, LEVEL_2, "keeping.\n"));
+                       }
                }
        }
 
@@ -329,8 +331,11 @@ static void spill_block(ir_node *block, void *data)
        }
 
        live_nodes_pressure = 0;
-       foreach_ir_nodeset(&live_nodes, node, iter) {
-               live_nodes_pressure += get_value_width(node);
+       {
+               ir_node *node;
+               foreach_ir_nodeset(&live_nodes, node, iter) {
+                       live_nodes_pressure += get_value_width(node);
+               }
        }
 
        /* calculate how many of the phis need to be spilled */

diff --git a/ir/be/bessaconstr.c b/ir/be/bessaconstr.c
index 86943ab..0533cd5 100644 (file)
--- a/ir/be/bessaconstr.c
+++ b/ir/be/bessaconstr.c
@@ -297,7 +297,6 @@ static void set_operands(be_ssa_construction_env_t *env, ir_node *use, ir_node *
  */
 static void process_block(be_ssa_construction_env_t *env, ir_node *block)
 {
-       ir_node     *node;
        ir_node     *def        = NULL;
        constr_info *block_info = get_or_set_info(env, block);
 
@@ -353,22 +352,17 @@ static ir_node *search_def_end_of_block(be_ssa_construction_env_t *env,
                        }
                }
                else {
-                       ir_node *def = NULL;
-
                        /* Search the last definition of the block. */
                        sched_foreach_reverse(block, def) {
                                if (is_definition(env, def)) {
                                        constr_info *info = get_info(env, def);
-                                       def = info->u.definition;
-                                       DBG((dbg, LEVEL_3, "\t...found definition %+F\n", def));
-
+                                       DBG((dbg, LEVEL_3, "\t...found definition %+F\n", info->u.definition));
+                                       block_info->u.last_definition = info->u.definition;
                                        break;
                                }
                        }
 
-                       assert(def && "No definition found");
-
-                       block_info->u.last_definition = def;
+                       assert(block_info->u.last_definition && "No definition found");
                }
 
                return block_info->u.last_definition;

diff --git a/ir/be/bestack.c b/ir/be/bestack.c
index a28b4a4..99a8145 100644 (file)
--- a/ir/be/bestack.c
+++ b/ir/be/bestack.c
@@ -160,7 +160,6 @@ static int process_stack_bias(ir_node *bl, int real_bias)
        be_stack_layout_t *layout      = be_get_irg_stack_layout(irg);
        bool               sp_relative = layout->sp_relative;
        const arch_env_t  *arch_env    = be_get_irg_arch_env(irg);
-       ir_node           *irn;
 
        sched_foreach(bl, irn) {
                int ofs;

diff --git a/ir/be/bestat.c b/ir/be/bestat.c
index b65552a..3d25381 100644 (file)
--- a/ir/be/bestat.c
+++ b/ir/be/bestat.c
@@ -59,10 +59,9 @@ static void check_reg_pressure_class(pressure_walker_env_t *env,
                                      ir_node *block,
                                      const arch_register_class_t *cls)
 {
-       ir_graph     *irg  = env->irg;
-       ir_node      *irn;
-       ir_nodeset_t  live_nodes;
-       size_t        max_live;
+       ir_graph    *irg  = env->irg;
+       ir_nodeset_t live_nodes;
+       size_t       max_live;
 
        ir_nodeset_init(&live_nodes);
        be_liveness_end_of_block(env->lv, cls, block, &live_nodes);
@@ -128,8 +127,7 @@ typedef struct estimate_irg_costs_env_t {
 static void estimate_block_costs(ir_node *block, void *data)
 {
        estimate_irg_costs_env_t *env = (estimate_irg_costs_env_t*)data;
-       ir_node *node;
-       double  costs = 0.0;
+       double costs = 0.0;
 
        sched_foreach(block, node) {
                costs += arch_get_op_estimated_cost(node);

diff --git a/ir/be/bestate.c b/ir/be/bestate.c
index 1a02a06..adf7859 100644 (file)
--- a/ir/be/bestate.c
+++ b/ir/be/bestate.c
@@ -215,7 +215,6 @@ static block_info_t *compute_block_start_state(minibelady_env_t *env, ir_node *b
        be_next_use_t  next_use;
        ir_loop       *loop;
        ir_node       *best_starter, *first;
-       ir_node       *node;
        int            n_cfgpreds;
        unsigned       best_time;
        int            outer_loop_allowed;
@@ -303,7 +302,7 @@ static block_info_t *compute_block_start_state(minibelady_env_t *env, ir_node *b
 
        /* check all Live-Ins */
        be_lv_foreach(env->lv, block, be_lv_state_in, i) {
-               node = be_lv_get_irn(env->lv, block, i);
+               ir_node *const node = be_lv_get_irn(env->lv, block, i);
 
                if (!mode_is_data(get_irn_mode(node)))
                        continue;
@@ -359,7 +358,6 @@ static block_info_t *compute_block_start_state(minibelady_env_t *env, ir_node *b
 static void belady(minibelady_env_t *env, ir_node *block)
 {
        ir_node *current_state;
-       ir_node *node;
        block_info_t *block_info;
 
        /* Don't do a block twice */

diff --git a/ir/be/beuses.c b/ir/be/beuses.c
index 4cb0c5a..69cf44f 100644 (file)
--- a/ir/be/beuses.c
+++ b/ir/be/beuses.c
@@ -143,7 +143,6 @@ static const be_use_t *get_or_set_use_block(be_uses_t *env,
  */
 static int be_is_phi_argument(const ir_node *block, const ir_node *def)
 {
-       ir_node *node;
        ir_node *succ_block = NULL;
        int arity, i;
 
@@ -368,7 +367,6 @@ be_next_use_t be_get_next_use(be_uses_t *env, ir_node *from,
  */
 static void set_sched_step_walker(ir_node *block, void *data)
 {
-       ir_node  *node;
        unsigned step = 0;
        (void) data;
 

diff --git a/ir/be/beverify.c b/ir/be/beverify.c
index bc825f5..04f3de2 100644 (file)
--- a/ir/be/beverify.c
+++ b/ir/be/beverify.c
@@ -85,7 +85,6 @@ static void verify_liveness_walker(ir_node *block, void *data)
 {
        be_verify_register_pressure_env_t *env = (be_verify_register_pressure_env_t *)data;
        ir_nodeset_t live_nodes;
-       ir_node *irn;
        int pressure;
 
        /* collect register pressure info, start with end of a block */
@@ -157,7 +156,6 @@ typedef struct be_verify_schedule_env_t_ {
 static void verify_schedule_walker(ir_node *block, void *data)
 {
        be_verify_schedule_env_t *env = (be_verify_schedule_env_t*) data;
-       ir_node *node;
        ir_node *non_phi_found  = NULL;
        ir_node *cfchange_found = NULL;
        int last_timestep = INT_MIN;
@@ -810,7 +808,6 @@ static void value_def(const ir_node *node)
 static void verify_block_register_allocation(ir_node *block, void *data)
 {
        unsigned i;
-       ir_node *node;
        unsigned n_regs;
        int      idx;
 

diff --git a/ir/be/ia32/ia32_emitter.c b/ir/be/ia32/ia32_emitter.c
index 1e96acf..2385eac 100644 (file)
--- a/ir/be/ia32/ia32_emitter.c
+++ b/ir/be/ia32/ia32_emitter.c
@@ -1789,8 +1789,6 @@ static void ia32_emit_block_header(ir_node *block)
  */
 static void ia32_gen_block(ir_node *block)
 {
-       ir_node *node;
-
        ia32_emit_block_header(block);
 
        if (sp_relative) {
@@ -3834,8 +3832,6 @@ static void ia32_register_binary_emitters(void)
 
 static void gen_binary_block(ir_node *block)
 {
-       ir_node *node;
-
        ia32_emit_block_header(block);
 
        /* emit the contents of the block */

diff --git a/ir/be/ia32/ia32_optimize.c b/ir/be/ia32/ia32_optimize.c
index a91fb45..274e3f8 100644 (file)
--- a/ir/be/ia32/ia32_optimize.c
+++ b/ir/be/ia32/ia32_optimize.c
@@ -361,8 +361,6 @@ static void peephole_ia32_Test(ir_node *node)
  */
 static void peephole_ia32_Return(ir_node *node)
 {
-       ir_node *irn;
-
        if (!ia32_cg_config.use_pad_return)
                return;
 
@@ -575,7 +573,6 @@ static ir_node *create_push(dbg_info *dbgi, ir_node *block,
 static void peephole_store_incsp(ir_node *store)
 {
        dbg_info *dbgi;
-       ir_node  *node;
        ir_node  *block;
        ir_node  *noreg;
        ir_node  *mem;

diff --git a/ir/be/ia32/ia32_x87.c b/ir/be/ia32/ia32_x87.c
index 5723f3d..b02042a 100644 (file)
--- a/ir/be/ia32/ia32_x87.c
+++ b/ir/be/ia32/ia32_x87.c
@@ -821,7 +821,6 @@ static void update_liveness(x87_simulator *sim, ir_node *block)
 {
        vfp_liveness live = vfp_liveness_end_of_block(sim, block);
        unsigned idx;
-       ir_node *irn;
 
        /* now iterate through the block backward and cache the results */
        sched_foreach_reverse(block, irn) {

diff --git a/ir/be/sparc/sparc_emitter.c b/ir/be/sparc/sparc_emitter.c
index 31b1e22..f27d77d 100644 (file)
--- a/ir/be/sparc/sparc_emitter.c
+++ b/ir/be/sparc/sparc_emitter.c
@@ -1298,7 +1298,6 @@ static bool block_needs_label(const ir_node *block, const ir_node *sched_prev)
  */
 static void sparc_emit_block(ir_node *block, ir_node *prev)
 {
-       ir_node *node;
        ir_node *next_delay_slot;
        bool     needs_label = block_needs_label(block, prev);
 

diff --git a/ir/be/sparc/sparc_stackframe.c b/ir/be/sparc/sparc_stackframe.c
index 2d8b455..4a8e803 100644 (file)
--- a/ir/be/sparc/sparc_stackframe.c
+++ b/ir/be/sparc/sparc_stackframe.c
@@ -50,8 +50,6 @@ static void set_irn_sp_bias(ir_node *node, int new_bias)
 static void process_bias(ir_node *block, bool sp_relative, int bias,
                          int free_bytes)
 {
-       ir_node *irn;
-
        mark_Block_block_visited(block);
 
        /* process schedule */