Let foreach_pset() declare its iterator variable.

diff --git a/include/libfirm/adt/pset.h b/include/libfirm/adt/pset.h
index 29d8c14..4a6d50c 100644 (file)
--- a/include/libfirm/adt/pset.h
+++ b/include/libfirm/adt/pset.h
@@ -215,7 +215,7 @@ FIRM_API void pset_break(pset *pset);
  * @param type   type of iterator variable
  * @param entry  the iterator
  */
-#define foreach_pset(pset, type, entry) for (entry = (type)pset_first(pset); entry; entry = (type)pset_next(pset))
+#define foreach_pset(pset, type, entry) for (type entry = (type)pset_first(pset); entry; entry = (type)pset_next(pset))
 
 /**
  * Inserts all elements of the pointer set src into

diff --git a/ir/adt/set.c b/ir/adt/set.c
index dc77b05..9833e63 100644 (file)
--- a/ir/adt/set.c
+++ b/ir/adt/set.c
@@ -437,7 +437,6 @@ void *(pset_insert) (SET *se, const void *key, unsigned hash)
 
 void pset_insert_pset_ptr(pset *target, pset *src)
 {
-       void *elt;
        foreach_pset(src, void*, elt) {
                pset_insert_ptr(target, elt);
        }

diff --git a/ir/ana/callgraph.c b/ir/ana/callgraph.c
index de5f9fb..029521b 100644 (file)
--- a/ir/ana/callgraph.c
+++ b/ir/ana/callgraph.c
@@ -270,8 +270,7 @@ void compute_callgraph(void)
        /* Change the sets to arrays. */
        for (i = 0; i < n_irgs; ++i) {
                size_t j, count;
-               cg_callee_entry *callee;
-               ir_graph *c, *irg = get_irp_irg(i);
+               ir_graph *irg = get_irp_irg(i);
                pset *callee_set, *caller_set;
 
                callee_set = (pset *)irg->callees;

diff --git a/ir/ana/cgana.c b/ir/ana/cgana.c
index 8291fdf..553078f 100644 (file)
--- a/ir/ana/cgana.c
+++ b/ir/ana/cgana.c
@@ -119,7 +119,6 @@ static ir_entity **get_impl_methods(ir_entity *method)
                /* no overwriting methods found */
                arr = NULL;
        } else {
-               ir_entity * ent;
                arr = NEW_ARR_F(ir_entity *, size);
                foreach_pset(set, ir_entity*, ent) {
                        arr[--size] = ent;
@@ -529,7 +528,6 @@ static size_t get_free_methods(ir_entity ***free_methods)
        pset *free_set = pset_new_ptr_default();
        size_t i, n, j, m;
        ir_entity **arr;
-       ir_entity *ent;
        ir_graph *irg;
        ir_type *tp;
        size_t length;
@@ -537,7 +535,7 @@ static size_t get_free_methods(ir_entity ***free_methods)
        for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
                ir_linkage linkage;
                irg = get_irp_irg(i);
-               ent = get_irg_entity(irg);
+               ir_entity *const ent = get_irg_entity(irg);
                linkage = get_entity_linkage(ent);
 
                if ((linkage & IR_LINKAGE_HIDDEN_USER) || entity_is_externally_visible(ent)) {
@@ -554,12 +552,12 @@ static size_t get_free_methods(ir_entity ***free_methods)
        /* insert all methods that are used in global variables initializers */
        tp = get_glob_type();
        for (j = 0, m = get_class_n_members(tp); j < m; ++j) {
-               ent = get_class_member(tp, j);
+               ir_entity *const ent = get_class_member(tp, j);
                add_method_address(ent, free_set);
        }
        tp = get_tls_type();
        for (j = 0, m = get_compound_n_members(tp); j < m; ++j) {
-               ent = get_compound_member(tp, j);
+               ir_entity *const ent = get_compound_member(tp, j);
                add_method_address(ent, free_set);
        }
 
@@ -713,7 +711,6 @@ static void callee_walker(ir_node *call, void *env)
        (void) env;
        if (is_Call(call)) {
                pset *methods = pset_new_ptr_default();
-               ir_entity *ent;
                ir_entity **arr;
                size_t i;
 
@@ -773,7 +770,6 @@ static void callee_ana(void)
 /** Frees intermediate data structures. */
 static void sel_methods_dispose(void)
 {
-       ir_entity * ent;
        assert(entities);
        foreach_pset(entities, ir_entity*, ent) {
                ir_entity **arr = (ir_entity**) get_entity_link(ent);

diff --git a/ir/be/becopyilp2.c b/ir/be/becopyilp2.c
index ee7474a..149fe24 100644 (file)
--- a/ir/be/becopyilp2.c
+++ b/ir/be/becopyilp2.c
@@ -414,7 +414,6 @@ static void build_clique_star_cstr(ilp_env_t *ienv)
                                /* search for a candidate to extend the clique */
                                for (i=0; i<n_nodes; ++i) {
                                        ir_node *cand = nodes[i];
-                                       ir_node *member;
                                        bool     is_cand;
 
                                        /* if its already in the clique try the next */
@@ -447,10 +446,9 @@ static void build_clique_star_cstr(ilp_env_t *ienv)
 
                        /* now the clique is maximal. Finally add the constraint */
                        {
-                               ir_node *member;
-                               int      var_idx;
-                               int      cst_idx;
-                               char     buf[32];
+                               int  var_idx;
+                               int  cst_idx;
+                               char buf[32];
 
                                cst_idx = lpp_add_cst(ienv->lp, NULL, lpp_greater_equal, pset_count(clique)-1);
 

diff --git a/ir/be/beifg.c b/ir/be/beifg.c
index 3a70c32..04f01f4 100644 (file)
--- a/ir/be/beifg.c
+++ b/ir/be/beifg.c
@@ -244,7 +244,6 @@ static inline int get_next_clique(cliques_iter_t *it)
                                /* before shrinking the set, return the current maximal clique */
                                if (output_on_shrink) {
                                        int count = 0;
-                                       ir_node *irn;
 
                                        /* fill the output buffer */
                                        foreach_pset(it->living, ir_node*, irn) {

diff --git a/ir/common/irtools.c b/ir/common/irtools.c
index deecaab..28ea1c8 100644 (file)
--- a/ir/common/irtools.c
+++ b/ir/common/irtools.c
@@ -211,8 +211,6 @@ void irn_rewire_inputs(ir_node *node)
 
 void firm_pset_dump(pset *set)
 {
-       void *obj;
-
        foreach_pset(set, void*, obj) {
                ir_fprintf(stderr, "%+F\n", obj);
        }

diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c
index 0735c68..b5b9a88 100644 (file)
--- a/ir/ir/irdump.c
+++ b/ir/ir/irdump.c
@@ -2284,7 +2284,6 @@ void dump_loop(FILE *F, ir_loop *l)
 {
        pset *loopnodes = pset_new_ptr_default();
        pset *extnodes  = pset_new_ptr_default();
-       ir_node *n, *b;
        char name[50];
 
        snprintf(name, sizeof(name), "loop_%ld", get_loop_loop_nr(l));
@@ -2303,14 +2302,14 @@ void dump_loop(FILE *F, ir_loop *l)
        }
        foreach_pset(loopnodes, ir_node*, n) {
                if (!is_Block(n)) {
-                       b = get_nodes_block(n);
+                       ir_node *const b = get_nodes_block(n);
                        set_irn_link(n, get_irn_link(b));
                        set_irn_link(b, n);
                }
        }
        foreach_pset(extnodes, ir_node*, n) {
                if (!is_Block(n)) {
-                       b = get_nodes_block(n);
+                       ir_node *const b = get_nodes_block(n);
                        set_irn_link(n, get_irn_link(b));
                        set_irn_link(b, n);
                }
@@ -2329,7 +2328,7 @@ void dump_loop(FILE *F, ir_loop *l)
                        dump_ir_data_edges(F, b);
 
                        /* dump the nodes that go into the block */
-                       for (n = (ir_node*)get_irn_link(b); n; n = (ir_node*)get_irn_link(n)) {
+                       for (ir_node *n = (ir_node*)get_irn_link(b); n; n = (ir_node*)get_irn_link(n)) {
                                if (pset_find_ptr(extnodes, n))
                                        overrule_nodecolor = ird_color_block_inout;
                                dump_node(F, n);
@@ -2353,7 +2352,7 @@ void dump_loop(FILE *F, ir_loop *l)
                        fprintf(F, "\" status:clustered color:lightblue\n");
 
                        /* dump the nodes that go into the block */
-                       for (n = (ir_node*)get_irn_link(b); n; n = (ir_node*)get_irn_link(n)) {
+                       for (ir_node *n = (ir_node*)get_irn_link(b); n; n = (ir_node*)get_irn_link(n)) {
                                if (!pset_find_ptr(loopnodes, n))
                                        overrule_nodecolor = ird_color_block_inout;
                                dump_node(F, n);

diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c
index 18a3574..9b9a344 100644 (file)
--- a/ir/ir/iropt.c
+++ b/ir/ir/iropt.c
@@ -6619,7 +6619,6 @@ void add_identities(ir_node *node)
 
 void visit_all_identities(ir_graph *irg, irg_walk_func visit, void *env)
 {
-       ir_node  *node;
        ir_graph *rem = current_ir_graph;
 
        current_ir_graph = irg;

diff --git a/ir/opt/proc_cloning.c b/ir/opt/proc_cloning.c
index 8db2d7e..8424a99 100644 (file)
--- a/ir/opt/proc_cloning.c
+++ b/ir/opt/proc_cloning.c
@@ -585,7 +585,7 @@ restart:
  */
 void proc_cloning(float threshold)
 {
-       entry_t *entry = NULL, *p;
+       entry_t *p;
        size_t i, n;
        q_set hmap;
 
@@ -651,14 +651,14 @@ void proc_cloning(float threshold)
 #ifdef DEBUG_libfirm
                /* Print some information about the list. */
                DB((dbg, LEVEL_2, "-----------------\n"));
-               for (entry = hmap.heavy_uses; entry; entry = entry->next) {
+               for (entry_t *entry = hmap.heavy_uses; entry; entry = entry->next) {
                        DB((dbg, LEVEL_2, "\nweight: is %f\n", entry->weight));
                        DB((dbg, LEVEL_2, "Call for Method %E\n", entry->q.ent));
                        DB((dbg, LEVEL_2, "Position %zu\n", entry->q.pos));
                        DB((dbg, LEVEL_2, "Value %T\n", entry->q.tv));
                }
 #endif
-               entry = hmap.heavy_uses;
+               entry_t *const entry = hmap.heavy_uses;
                if (entry) {
                        quadruple_t *qp = &entry->q;
 

diff --git a/ir/stat/distrib.c b/ir/stat/distrib.c
index 758f85c..2fb4600 100644 (file)
--- a/ir/stat/distrib.c
+++ b/ir/stat/distrib.c
@@ -186,7 +186,6 @@ void stat_insert_int_distrib_tbl(distrib_tbl_t *tbl, int key)
  */
 int stat_get_count_distrib_tbl(distrib_tbl_t *tbl)
 {
-       distrib_entry_t *entry;
        counter_t cnt = ZERO_CNT;
 
        foreach_pset(tbl->hash_map, distrib_entry_t*, entry)
@@ -199,7 +198,6 @@ int stat_get_count_distrib_tbl(distrib_tbl_t *tbl)
  */
 double stat_calc_mean_distrib_tbl(distrib_tbl_t *tbl)
 {
-       distrib_entry_t *entry;
        size_t count;
        double sum;
 
@@ -240,9 +238,8 @@ double stat_calc_mean_distrib_tbl(distrib_tbl_t *tbl)
  */
 double stat_calc_avg_distrib_tbl(distrib_tbl_t *tbl)
 {
-       distrib_entry_t *entry;
-       size_t          count = 0;
-       double          sum   = 0.0;
+       size_t count = 0;
+       double sum   = 0.0;
 
        if (tbl->int_dist) {
                if (pset_count(tbl->hash_map) <= 0)
@@ -267,8 +264,6 @@ double stat_calc_avg_distrib_tbl(distrib_tbl_t *tbl)
  */
 void stat_iterate_distrib_tbl(const distrib_tbl_t *tbl, eval_distrib_entry_fun eval, void *env)
 {
-       distrib_entry_t *entry;
-
        foreach_pset(tbl->hash_map, distrib_entry_t*, entry)
                eval(entry, env);
 }

diff --git a/ir/stat/firmstat.c b/ir/stat/firmstat.c
index 9e22abc..786600c 100644 (file)
--- a/ir/stat/firmstat.c
+++ b/ir/stat/firmstat.c
@@ -1101,7 +1101,6 @@ static void count_adr_ops(ir_node *node, void *env)
  */
 static void update_graph_stat(graph_entry_t *global, graph_entry_t *graph)
 {
-       node_entry_t *entry;
        int i;
 
        /* clear first the alive counter in the graph */
@@ -1253,8 +1252,6 @@ static void stat_dump_registered(graph_entry_t *entry)
 
        for (dumper = status->dumper; dumper; dumper = dumper->next) {
                if (dumper->func_map) {
-                       dump_graph_FUNC func;
-
                        foreach_pset(dumper->func_map, dump_graph_FUNC, func)
                                func(dumper, entry);
                }  /* if */
@@ -2032,7 +2029,6 @@ void stat_dump_snapshot(const char *name, const char *phase)
 
        STAT_ENTER;
        {
-               graph_entry_t *entry;
                graph_entry_t *global = graph_get_entry(NULL, status->irg_hash);
 
                /*
@@ -2090,7 +2086,7 @@ void stat_dump_snapshot(const char *name, const char *phase)
 
                /* some calculations are dependent, we pushed them on the wait_q */
                while (! pdeq_empty(status->wait_q)) {
-                       entry = (graph_entry_t*)pdeq_getr(status->wait_q);
+                       graph_entry_t *const entry = (graph_entry_t*)pdeq_getr(status->wait_q);
 
                        update_graph_stat_2(global, entry);
                }  /* while */
@@ -2132,15 +2128,11 @@ void stat_dump_snapshot(const char *name, const char *phase)
                stat_finish_pattern_history(fname);
 
                /* clear the global counters here */
-               {
-                       node_entry_t *entry;
-
-                       foreach_pset(global->opcode_hash, node_entry_t*, entry) {
-                               opcode_clear_entry(entry);
-                       }  /* for */
-                       /* clear all global counter */
-                       graph_clear_entry(global, /*all=*/1);
-               }
+               foreach_pset(global->opcode_hash, node_entry_t*, entry) {
+                       opcode_clear_entry(entry);
+               }  /* for */
+               /* clear all global counter */
+               graph_clear_entry(global, /*all=*/1);
        }
        STAT_LEAVE;
 }  /* stat_dump_snapshot */

diff --git a/ir/stat/pattern.c b/ir/stat/pattern.c
index 9f0a011..1c48c15 100644 (file)
--- a/ir/stat/pattern.c
+++ b/ir/stat/pattern.c
@@ -745,7 +745,6 @@ static void calc_nodes_pattern(ir_node *node, void *ctx)
 static void store_pattern(const char *fname)
 {
        FILE *f;
-       pattern_entry_t *entry;
        size_t count = pset_count(status->pattern_hash);
 
        if (count <= 0)
@@ -828,7 +827,6 @@ read_error:
  */
 static void pattern_output(const char *fname)
 {
-       pattern_entry_t  *entry;
        pattern_entry_t  **pattern_arr;
        pattern_dumper_t *dump;
        size_t i, count = pset_count(status->pattern_hash);
@@ -853,7 +851,7 @@ static void pattern_output(const char *fname)
        qsort(pattern_arr, count, sizeof(*pattern_arr), pattern_count_cmp);
 
        for (i = 0; i < count; ++i) {
-               entry = pattern_arr[i];
+               pattern_entry_t *const entry = pattern_arr[i];
                if (cnt_to_uint(&entry->count) < status->bound)
                        continue;
 

diff --git a/ir/stat/stat_dmp.c b/ir/stat/stat_dmp.c
index 0a7fb4d..148b87f 100644 (file)
--- a/ir/stat/stat_dmp.c
+++ b/ir/stat/stat_dmp.c
@@ -193,7 +193,6 @@ static const char *if_conv_names[IF_RESULT_LAST] = {
  */
 static void simple_dump_opcode_hash(dumper_t *dmp, pset *set)
 {
-       node_entry_t *entry;
        counter_t f_alive;
        counter_t f_new_node;
        counter_t f_Id;
@@ -244,7 +243,6 @@ static const char *get_opt_name(int index)
 static void simple_dump_opt_hash(dumper_t *dmp, pset *set, int index)
 {
        if (pset_count(set) > 0) {
-               opt_entry_t *entry;
                const char *name = get_opt_name(index);
 
                fprintf(dmp->f, "\n%s:\n", name);
@@ -262,18 +260,16 @@ static void simple_dump_opt_hash(dumper_t *dmp, pset *set, int index)
  */
 static void simple_dump_be_block_reg_pressure(dumper_t *dmp, graph_entry_t *entry)
 {
-       be_block_entry_t     *b_entry = (be_block_entry_t*)pset_first(entry->be_block_hash);
-       reg_pressure_entry_t *rp_entry;
-
        /* return if no be statistic information available */
-       if (! b_entry)
+       be_block_entry_t *const b_first = (be_block_entry_t*)pset_first(entry->be_block_hash);
+       if (!b_first)
                return;
 
        fprintf(dmp->f, "\nREG PRESSURE:\n");
        fprintf(dmp->f, "%12s", "Block Nr");
 
        /* print table head (register class names) */
-       foreach_pset(b_entry->reg_pressure, reg_pressure_entry_t*, rp_entry)
+       foreach_pset(b_first->reg_pressure, reg_pressure_entry_t*, rp_entry)
                fprintf(dmp->f, "%15s", rp_entry->class_name);
        fprintf(dmp->f, "\n");
 
@@ -300,8 +296,7 @@ static void simple_dump_distrib_entry(const distrib_entry_t *entry, void *env)
 static void simple_dump_be_block_sched_ready(dumper_t *dmp, graph_entry_t *entry)
 {
        if (pset_count(entry->be_block_hash) > 0) {
-               be_block_entry_t *b_entry;
-               int              i;
+               int i;
 
                fprintf(dmp->f, "\nSCHEDULING: NUMBER OF READY NODES\n");
                fprintf(dmp->f, "%12s %12s %12s %12s %12s %12s %12s\n",
@@ -335,11 +330,10 @@ static void add_distrib_entry(const distrib_entry_t *entry, void *env)
  */
 static void simple_dump_be_block_permstat_class(dumper_t *dmp, perm_class_entry_t *entry)
 {
-       perm_stat_entry_t *ps_ent;
-       distrib_tbl_t     *sum_chains = stat_new_int_distrib_tbl();
-       distrib_tbl_t     *sum_cycles = stat_new_int_distrib_tbl();
-       char              buf[16];
-       int               i;
+       distrib_tbl_t *sum_chains = stat_new_int_distrib_tbl();
+       distrib_tbl_t *sum_cycles = stat_new_int_distrib_tbl();
+       char           buf[16];
+       int            i;
 
        fprintf(dmp->f, "%12s %12s %12s %12s %12s %12s\n",
                "size",
@@ -405,12 +399,8 @@ static void simple_dump_be_block_permstat_class(dumper_t *dmp, perm_class_entry_
 static void simple_dump_be_block_permstat(dumper_t *dmp, graph_entry_t *entry)
 {
        if (pset_count(entry->be_block_hash) > 0) {
-               be_block_entry_t *b_entry;
-
                fprintf(dmp->f, "\nPERMUTATION STATISTICS BEGIN:\n");
                foreach_pset(entry->be_block_hash, be_block_entry_t*, b_entry) {
-                       perm_class_entry_t *pc_ent;
-
                        fprintf(dmp->f, "BLOCK %ld:\n", b_entry->block_nr);
 
                        if (b_entry->perm_class_stat) {
@@ -470,7 +460,6 @@ static void simple_dump_edges(dumper_t *dmp, counter_t *cnt)
 static void simple_dump_graph(dumper_t *dmp, graph_entry_t *entry)
 {
        int dump_opts = 1;
-       block_entry_t *b_entry;
 
        if (! dmp->f)
                return;
@@ -728,7 +717,6 @@ const dumper_t simple_dumper = {
  */
 static void csv_count_nodes(dumper_t *dmp, graph_entry_t *graph, counter_t cnt[])
 {
-       node_entry_t *entry;
        int i;
 
        for (i = 0; i < 4; ++i)