Further spread size_t.

[r28338]

diff --git a/include/libfirm/irloop.h b/include/libfirm/irloop.h
index 5efa631..7c6db43 100644 (file)
--- a/include/libfirm/irloop.h
+++ b/include/libfirm/irloop.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -105,8 +105,10 @@ FIRM_API size_t get_loop_n_elements(const ir_loop *loop);
 kind pointer, an ir_node* or an ir_loop*. */
 FIRM_API loop_element get_loop_element(const ir_loop *loop, size_t pos);
 
+#define INVALID_LOOP_POS ((size_t)-1)
+
 /** Returns the element number of the loop son in loop.
-*  Returns -1 if not found. O(|elements|). */
+*  Returns INVALID_LOOP_POS if not found. O(|elements|). */
 FIRM_API size_t get_loop_element_pos(const ir_loop *loop, void *le);
 
 /** Returns a unique node number for the loop node to make output

diff --git a/ir/ana/callgraph.c b/ir/ana/callgraph.c
index 94d4e2a..8971450 100644 (file)
--- a/ir/ana/callgraph.c
+++ b/ir/ana/callgraph.c
@@ -299,7 +299,7 @@ static int graph_cmp(const void *elt, const void *key)
 /* Construct and destruct the callgraph. */
 void compute_callgraph(void)
 {
-       int i, n_irgs;
+       size_t i, n_irgs;
 
        /* initialize */
        free_callgraph();
@@ -357,7 +357,7 @@ void compute_callgraph(void)
 /* Destruct the callgraph. */
 void free_callgraph(void)
 {
-       int i, n_irgs = get_irp_n_irgs();
+       size_t i, n_irgs = get_irp_n_irgs();
        for (i = 0; i < n_irgs; ++i) {
                ir_graph *irg = get_irp_irg(i);
                if (irg->callees) DEL_ARR_F(irg->callees);
@@ -400,7 +400,7 @@ static void do_walk(ir_graph *irg, callgraph_walk_func *pre, callgraph_walk_func
 
 void callgraph_walk(callgraph_walk_func *pre, callgraph_walk_func *post, void *env)
 {
-       int i, n_irgs = get_irp_n_irgs();
+       size_t i, n_irgs = get_irp_n_irgs();
        ++master_cg_visited;
 
        /* roots are methods which have no callers in the current program */
@@ -663,8 +663,7 @@ static ir_loop *new_loop(void)
 
 static void init_scc(struct obstack *obst)
 {
-       int i;
-       int n_irgs;
+       size_t i, n_irgs;
 
        current_dfn   = 1;
        loop_node_cnt = 0;
@@ -918,7 +917,7 @@ static void cgscc(ir_graph *n)
  */
 static void reset_isbe(void)
 {
-       int i, n_irgs = get_irp_n_irgs();
+       size_t i, n_irgs = get_irp_n_irgs();
 
        for (i = 0; i < n_irgs; ++i) {
                ir_graph *irg = get_irp_irg(i);
@@ -1151,7 +1150,7 @@ static void compute_method_execution_frequency(ir_graph *irg, void *env)
 /* Compute the backedges that represent recursions. */
 void find_callgraph_recursions(void)
 {
-       int i, n_irgs;
+       size_t i, n_irgs;
        struct obstack temp;
 
        reset_isbe();

diff --git a/ir/ana/cgana.c b/ir/ana/cgana.c
index 9f97c3f..ec7aad8 100644 (file)
--- a/ir/ana/cgana.c
+++ b/ir/ana/cgana.c
@@ -227,12 +227,12 @@ static void sel_methods_walker(ir_node *node, void *env)
  */
 static void sel_methods_init(void)
 {
-       int i;
+       size_t i, n;
        pmap *ldname_map = pmap_create();   /* Map entity names to entities: to replace
                                               SymConst(name) by SymConst(ent). */
        assert(entities == NULL);
        entities = eset_create();
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
                ir_entity * ent = get_irg_entity(get_irp_irg(i));
                /* only external visible methods are allowed to call by a SymConst_ptr_name */
                if (entity_is_externally_visible(ent)) {
@@ -507,12 +507,10 @@ static void add_method_address_inititializer(ir_initializer_t *initializer,
  */
 static void add_method_address(ir_entity *ent, eset *set)
 {
-       ir_node *n;
        ir_type *tp;
-       int i;
 
        /* ignore methods: these of course reference it's address
-        * TODO: remove this later once this incorrect self-intialisation is gone
+        * TODO: remove this later once this incorrect self-initialisation is gone
         */
        tp = get_entity_type(ent);
        if (is_Method_type(tp))
@@ -521,12 +519,13 @@ static void add_method_address(ir_entity *ent, eset *set)
        if (ent->initializer != NULL) {
                add_method_address_inititializer(get_entity_initializer(ent), set);
        } else if (entity_has_compound_ent_values(ent)) {
-               for (i = get_compound_ent_n_values(ent) - 1; i >= 0; --i) {
-                       n = get_compound_ent_value(ent, i);
+               size_t i, n;
+               for (i = 0, n = get_compound_ent_n_values(ent); i < n; ++i) {
+                       ir_node *irn = get_compound_ent_value(ent, i);
 
                        /* let's check if it's the address of a function */
-                       if (is_Global(n)) {
-                               ir_entity *ent = get_Global_entity(n);
+                       if (is_Global(irn)) {
+                               ir_entity *ent = get_Global_entity(irn);
 
                                if (is_Method_type(get_entity_type(ent)))
                                        eset_insert(set, ent);
@@ -548,21 +547,21 @@ static void add_method_address(ir_entity *ent, eset *set)
 static size_t get_free_methods(ir_entity ***free_methods)
 {
        eset *free_set = eset_create();
-       int i;
+       size_t i, n;
+       int j;
        ir_entity **arr;
        ir_entity *ent;
        ir_graph *irg;
        ir_type *tp;
        size_t length;
 
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
                ir_linkage linkage;
                irg = get_irp_irg(i);
                ent = get_irg_entity(irg);
                linkage = get_entity_linkage(ent);
 
-               if (entity_is_externally_visible(ent)
-                               || (linkage & IR_LINKAGE_HIDDEN_USER)) {
+               if ((linkage & IR_LINKAGE_HIDDEN_USER) || entity_is_externally_visible(ent)) {
                        eset_insert(free_set, ent);
                }
 
@@ -575,13 +574,13 @@ 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 (i = get_class_n_members(tp) - 1; i >= 0; --i) {
-               ent = get_class_member(tp, i);
+       for (j = get_class_n_members(tp) - 1; j >= 0; --j) {
+               ent = get_class_member(tp, j);
                add_method_address(ent, free_set);
        }
        tp = get_tls_type();
-       for (i = get_class_n_members(tp) - 1; i >= 0; --i) {
-               ent = get_class_member(tp, i);
+       for (j = get_class_n_members(tp) - 1; j >= 0; --j) {
+               ent = get_class_member(tp, j);
                add_method_address(ent, free_set);
        }
 
@@ -776,9 +775,9 @@ static void remove_Tuples(ir_node *proj, void *env)
  */
 static void callee_ana(void)
 {
-       int i;
+       size_t i, n;
        /* analyse all graphs */
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
                ir_graph *irg = get_irp_irg(i);
                irg_walk_graph(irg, callee_walker, remove_Tuples, NULL);
                set_irg_callee_info_state(irg, irg_callee_info_consistent);
@@ -841,8 +840,8 @@ void free_callee_info(ir_graph *irg)
 
 void free_irp_callee_info(void)
 {
-       int i;
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+       size_t i, n;
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
                free_callee_info(get_irp_irg(i));
        }
 }

diff --git a/ir/ana/execution_frequency.c b/ir/ana/execution_frequency.c
index 7a816f8..a005f4d 100644 (file)
--- a/ir/ana/execution_frequency.c
+++ b/ir/ana/execution_frequency.c
@@ -386,7 +386,7 @@ static void compute_frequency(int default_loop_weight)
 
   while (!pdeq_empty(block_worklist)) {
     ir_loop *l = (ir_loop *)pdeq_getl(block_worklist);
-    int i, n_elems = get_loop_n_elements(l);
+    size_t i, n_elems = get_loop_n_elements(l);
 
     /* The header is initialized with the frequency of the full loop times the iteration weight. */
     check_proper_head(l, get_loop_element(l, 0).son);
@@ -433,7 +433,7 @@ void compute_execution_frequency(ir_graph *irg, int default_loop_weight, double
 
 void compute_execution_frequencies(int default_loop_weight, double exception_probability)
 {
-  int i, n_irgs = get_irp_n_irgs();
+  size_t i, n_irgs = get_irp_n_irgs();
   free_intervals();
   for (i = 0; i < n_irgs; ++i) {
     compute_execution_frequency(get_irp_irg(i), default_loop_weight, exception_probability);
@@ -444,7 +444,7 @@ void compute_execution_frequencies(int default_loop_weight, double exception_pro
 /** free occupied memory, reset */
 void free_execution_frequency(void)
 {
-  int i, n_irgs = get_irp_n_irgs();
+  size_t i, n_irgs = get_irp_n_irgs();
   free_intervals();
   del_set(exec_freq_set);
 
@@ -485,13 +485,13 @@ exec_freq_state get_irp_exec_freq_state(void)
 /* Sets irp and all irg exec freq states to inconsistent if it is set to consistent. */
 void            set_irp_exec_freq_state_inconsistent(void)
 {
-  if (get_irp_exec_freq_state() != exec_freq_none) {
-    int i, n_irgs = get_irp_n_irgs();
-    set_irp_exec_freq_state(exec_freq_inconsistent);
-    for (i = 0; i < n_irgs; ++i) {
-      ir_graph *irg = get_irp_irg(i);
-      if (get_irg_exec_freq_state(irg) != exec_freq_none)
-       irg->execfreq_state = exec_freq_inconsistent;
-    }
-  }
+       if (get_irp_exec_freq_state() != exec_freq_none) {
+               size_t i, n_irgs = get_irp_n_irgs();
+               set_irp_exec_freq_state(exec_freq_inconsistent);
+               for (i = 0; i < n_irgs; ++i) {
+                       ir_graph *irg = get_irp_irg(i);
+                       if (get_irg_exec_freq_state(irg) != exec_freq_none)
+                               irg->execfreq_state = exec_freq_inconsistent;
+               }
+       }
 }

diff --git a/ir/ana/interval_analysis.c b/ir/ana/interval_analysis.c
index e5bc705..d52a814 100644 (file)
--- a/ir/ana/interval_analysis.c
+++ b/ir/ana/interval_analysis.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -198,7 +198,7 @@ static int find_outer_loop(ir_loop *inner, ir_loop *outer, ir_node *blk, ir_node
  */
 static int test_loop_nest(ir_node *blk, ir_loop *loop)
 {
-       int i, n_elems = get_loop_n_elements(loop);
+       size_t i, n_elems = get_loop_n_elements(loop);
 
        for (i = 0; i < n_elems; ++i) {
                loop_element e = get_loop_element(loop, i);
@@ -231,7 +231,7 @@ static int test_loop_nest(ir_node *blk, ir_loop *loop)
  */
 static int find_inner_loop(ir_node *blk, ir_loop *l, ir_node *pred, ir_node *cfop)
 {
-       int i, n_elems = get_loop_n_elements(l);
+       size_t i, n_elems = get_loop_n_elements(l);
        int found = 0;
 
        for (i = 0; i < n_elems; ++i) {
@@ -275,14 +275,14 @@ static int find_previous_loop(ir_loop *l, ir_loop *pred_l, ir_node *b,
                               ir_node *pred_b, ir_node *cfop)
 {
        ir_loop *outer = get_loop_outer_loop(l);
-       int found, i;
-       int l_pos = get_loop_element_pos(outer, l);
+       int found;
+       size_t i, l_pos = get_loop_element_pos(outer, l);
        (void) pred_l;
-       assert(l_pos > -1);
+       assert(l_pos != INVALID_LOOP_POS);
        assert(l_pos > 0 && "Is this a necessary condition?  There could be a perfect nest ...");
 
-       for (i = l_pos -1, found = 0; i > -1 && !found; --i) {
-               ir_loop *k = get_loop_element(outer, i).son;
+       for (i = l_pos, found = 0; i > 0;) {
+               ir_loop *k = get_loop_element(outer, --i).son;
                if (is_ir_loop(k)) {
                        found = test_loop_nest(pred_b, k);
                        if (found) {
@@ -291,6 +291,7 @@ static int find_previous_loop(ir_loop *l, ir_loop *pred_l, ir_node *b,
                                add_loop_cfop(l, cfop);
                                /* placeholder: the edge is in the loop region */
                                add_region_in(b, NULL);
+                               break;
                        }
                }
        }
@@ -402,7 +403,7 @@ static void construct_interval_block(ir_node *blk, ir_loop *l)
  */
 static void construct_interval_edges(ir_loop *l)
 {
-       int i, n_elems = get_loop_n_elements(l);
+       size_t i, n_elems = get_loop_n_elements(l);
        for (i = 0; i < n_elems; ++i) {
                loop_element e = get_loop_element(l, i);
                switch (*e.kind) {
@@ -576,7 +577,7 @@ static void dump_interval_block(FILE *F, ir_node *block)
 
 static void dump_interval_loop(FILE *F, ir_loop *l)
 {
-       int i, n_elems = get_loop_n_elements(l);
+       size_t i, n_elems = get_loop_n_elements(l);
 
        fprintf(F, "graph: { title: \"");
        PRINT_LOOPID(l);

diff --git a/ir/ana/ircfscc.c b/ir/ana/ircfscc.c
index 38372a4..57a7ad4 100644 (file)
--- a/ir/ana/ircfscc.c
+++ b/ir/ana/ircfscc.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -217,7 +217,7 @@ static inline void pop_scc_to_loop(ir_node *n)
    can't they have two loops as sons? Does it never get that far? ) */
 static void close_loop(ir_loop *l)
 {
-       int last = get_loop_n_elements(l) - 1;
+       size_t last = get_loop_n_elements(l) - 1;
        loop_element lelement = get_loop_element(l, last);
        ir_loop *last_son = lelement.son;
 

diff --git a/ir/ana/irloop.c b/ir/ana/irloop.c
index a170084..7ac9132 100644 (file)
--- a/ir/ana/irloop.c
+++ b/ir/ana/irloop.c
@@ -76,10 +76,10 @@ void mature_loops(ir_loop *loop, struct obstack *obst)
 
        if (loop->n_sons > 0) {
                /* we have child loops, mature them */
-               int i;
+               size_t i;
 
-               for (i = ARR_LEN(new_children) - 1; i >= 0; --i) {
-                       loop_element child = new_children[i];
+               for (i = ARR_LEN(new_children); i > 0;) {
+                       loop_element child = new_children[--i];
 
                        if (*child.kind == k_ir_loop) {
                                mature_loops(child.son, obst);
@@ -177,7 +177,7 @@ size_t get_loop_element_pos(const ir_loop *loop, void *le)
        for (i = 0; i < n; i++)
                if (get_loop_element(loop, i).node == le)
                        return i;
-       return (size_t)-1;
+       return INVALID_LOOP_POS;
 }
 
 

diff --git a/ir/ana/irmemory.c b/ir/ana/irmemory.c
index b0554d1..6191234 100644 (file)
--- a/ir/ana/irmemory.c
+++ b/ir/ana/irmemory.c
@@ -1115,9 +1115,6 @@ static void check_initializer_nodes(ir_initializer_t *initializer)
  */
 static void check_initializer(ir_entity *ent)
 {
-       ir_node *n;
-       int i;
-
        /* Beware: Methods are always initialized with "themself". This does not
         * count as a taken address.
         * TODO: this initialisation with "themself" is wrong and should be removed
@@ -1128,12 +1125,14 @@ static void check_initializer(ir_entity *ent)
        if (ent->initializer != NULL) {
                check_initializer_nodes(ent->initializer);
        } else if (entity_has_compound_ent_values(ent)) {
-               for (i = get_compound_ent_n_values(ent) - 1; i >= 0; --i) {
-                       n = get_compound_ent_value(ent, i);
+               size_t i, n;
+
+               for (i = 0, n = get_compound_ent_n_values(ent); i < n; ++i) {
+                       ir_node *irn = get_compound_ent_value(ent, i);
 
                        /* let's check if it's an address */
-                       if (is_Global(n)) {
-                               ir_entity *ent = get_Global_entity(n);
+                       if (is_Global(irn)) {
+                               ir_entity *ent = get_Global_entity(irn);
                                set_entity_usage(ent, ir_usage_unknown);
                        }
                }
@@ -1214,7 +1213,7 @@ static void check_global_address(ir_node *irn, void *env)
  */
 static void analyse_irp_globals_entity_usage(void)
 {
-       int i;
+       size_t i, n;
        ir_segment_t s;
 
        for (s = IR_SEGMENT_FIRST; s <= IR_SEGMENT_LAST; ++s) {
@@ -1227,7 +1226,7 @@ static void analyse_irp_globals_entity_usage(void)
                check_initializers(type);
        }
 
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
                ir_graph *irg = get_irp_irg(i);
 
                assure_irg_outs(irg);
@@ -1325,7 +1324,7 @@ static void update_calls_to_private(ir_node *call, void *env)
 /* Mark all private methods, i.e. those of which all call sites are known. */
 void mark_private_methods(void)
 {
-       int i;
+       size_t i, n;
        int changed = 0;
 
        assure_irp_globals_entity_usage_computed();
@@ -1333,13 +1332,12 @@ void mark_private_methods(void)
        mtp_map = pmap_create();
 
        /* first step: change the calling conventions of the local non-escaped entities */
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
                ir_graph        *irg   = get_irp_irg(i);
                ir_entity       *ent   = get_irg_entity(irg);
                ir_entity_usage  flags = get_entity_usage(ent);
 
-               if (!entity_is_externally_visible(ent) &&
-                   !(flags & ir_usage_address_taken)) {
+               if (!(flags & ir_usage_address_taken) && !entity_is_externally_visible(ent)) {
                        ir_type *mtp = get_entity_type(ent);
 
                        add_entity_additional_properties(ent, mtp_property_private);

diff --git a/ir/ana/irouts.c b/ir/ana/irouts.c
index d1555c3..ce7ea21 100644 (file)
--- a/ir/ana/irouts.c
+++ b/ir/ana/irouts.c
@@ -479,15 +479,15 @@ void assure_irg_outs(ir_graph *irg)
 
 void compute_irp_outs(void)
 {
-       int i;
-       for (i = get_irp_n_irgs() -1; i >= 0; --i)
+       size_t i, n;
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i)
                compute_irg_outs(get_irp_irg(i));
 }
 
 void free_irp_outs(void)
 {
-       int i;
-       for (i = get_irp_n_irgs() -1; i >= 0; --i)
+       size_t i, n;
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i)
                free_irg_outs(get_irp_irg(i));
 }
 

diff --git a/ir/ana/irtypeinfo.c b/ir/ana/irtypeinfo.c
index 1b5591f..df31cb4 100644 (file)
--- a/ir/ana/irtypeinfo.c
+++ b/ir/ana/irtypeinfo.c
@@ -69,7 +69,7 @@ ir_type *initial_type = NULL;
  */
 void init_irtypeinfo(void)
 {
-       int i;
+       size_t i, n;
 
        if (initial_type == NULL)
                initial_type = new_type_class(new_id_from_str("initial_type"));
@@ -79,7 +79,7 @@ void init_irtypeinfo(void)
                pmap_destroy(type_node_map);
        type_node_map = pmap_create();
 
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i)
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i)
                set_irg_typeinfo_state(get_irp_irg(i), ir_typeinfo_none);
 }
 

diff --git a/ir/ana/rta.c b/ir/ana/rta.c
index 3cfb2c9..94836db 100644 (file)
--- a/ir/ana/rta.c
+++ b/ir/ana/rta.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -185,7 +185,7 @@ static bool rta_fill_graph(ir_graph* graph)
  */
 static int rta_fill_incremental(void)
 {
-       int  i;
+       size_t i, n;
        int  n_runs = 0;
        bool rerun  = true;
 
@@ -193,15 +193,13 @@ static int rta_fill_incremental(void)
 
        /* Need to take care of graphs that are externally
           visible or sticky. Pretend that they are called: */
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
                ir_graph *graph = get_irp_irg(i);
                ir_entity *ent = get_irg_entity(graph);
                ir_linkage linkage = get_entity_linkage(ent);
 
-               if (entity_is_externally_visible(ent)
-                               || (linkage & IR_LINKAGE_HIDDEN_USER)) {
+               if ((linkage & IR_LINKAGE_HIDDEN_USER) || entity_is_externally_visible(ent))
                        pset_new_insert(_live_graphs, graph);
-               }
        }
 
        while (rerun) {
@@ -237,12 +235,12 @@ static int rta_fill_incremental(void)
 /**
  * Count the number of graphs that we have found to be live.
  */
-static int stats(void)
+static size_t stats(void)
 {
-       int i;
-       int n_live_graphs = 0;
+       size_t i, n;
+       size_t n_live_graphs = 0;
 
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
                ir_graph *graph = get_irp_irg(i);
 
                if (rta_is_alive_graph(graph))
@@ -323,8 +321,8 @@ void rta_init(void)
 
        n_runs = rta_fill_incremental();
 
-       DB((dbg, LEVEL_1, "RTA: n_graphs      = %i\n", get_irp_n_irgs()));
-       DB((dbg, LEVEL_1, "RTA: n_live_graphs = %i\n", stats()));
+       DB((dbg, LEVEL_1, "RTA: n_graphs      = %zu\n", get_irp_n_irgs()));
+       DB((dbg, LEVEL_1, "RTA: n_live_graphs = %zu\n", stats()));
        DB((dbg, LEVEL_1, "RTA: n_runs        = %i\n", n_runs));
 
 # ifdef DEBUG_libfirm

diff --git a/ir/ana/structure.c b/ir/ana/structure.c
index 66479f0..f482a43 100644 (file)
--- a/ir/ana/structure.c
+++ b/ir/ana/structure.c
@@ -1115,7 +1115,7 @@ ir_reg_tree *construct_region_tree(ir_graph *irg)
  */
 static void region_tree_walk2(ir_region *reg, irg_reg_walk_func *pre, irg_reg_walk_func *post, void *env)
 {
-       int i, n;
+       size_t i, n;
 
        if (pre)
                pre(reg, env);

diff --git a/ir/ir/irgwalk.c b/ir/ir/irgwalk.c
index 7f42f88..83ff86f 100644 (file)
--- a/ir/ir/irgwalk.c
+++ b/ir/ir/irgwalk.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -190,7 +190,7 @@ void irg_walk_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void
    current_ir_graph. */
 void all_irg_walk(irg_walk_func *pre, irg_walk_func *post, void *env)
 {
-       int i, n;
+       size_t i, n;
        ir_graph *irg;
 
        for (i = 0, n = get_irp_n_irgs(); i < n; i++) {
@@ -478,7 +478,7 @@ static void walk_entity(ir_entity *ent, void *env)
        if (ent->initializer != NULL) {
                walk_initializer(ent->initializer, my_env);
        } else if (entity_has_compound_ent_values(ent)) {
-               int i, n_vals = get_compound_ent_n_values(ent);
+               size_t i, n_vals = get_compound_ent_n_values(ent);
 
                for (i = 0; i < n_vals; i++)
                        irg_walk(get_compound_ent_value(ent, i), my_env->pre, my_env->post, my_env->env);

diff --git a/ir/ir/irgwalk_blk.c b/ir/ir/irgwalk_blk.c
index 6037124..e001742 100644 (file)
--- a/ir/ir/irgwalk_blk.c
+++ b/ir/ir/irgwalk_blk.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -99,20 +99,20 @@ static block_entry_t *block_find_entry(ir_node *block, blk_collect_data_t *ctx)
  */
 static void traverse_block_pre(ir_node *block, block_entry_t *entry, irg_walk_func *pre, void *env)
 {
-       int j;
+       size_t j;
 
-       for (j = ARR_LEN(entry->cf_list) - 1; j >= 0; --j) {
-               ir_node *node = entry->cf_list[j];
+       for (j = ARR_LEN(entry->cf_list); j > 0;) {
+               ir_node *node = entry->cf_list[--j];
                pre(node, env);
        }
 
-       for (j = ARR_LEN(entry->df_list) - 1; j >= 0; --j) {
-               ir_node *node = entry->df_list[j];
+       for (j = ARR_LEN(entry->df_list); j > 0;) {
+               ir_node *node = entry->df_list[--j];
                pre(node, env);
        }
 
-       for (j = ARR_LEN(entry->phi_list) - 1; j >= 0; --j) {
-               ir_node *node = entry->phi_list[j];
+       for (j = ARR_LEN(entry->phi_list); j > 0;) {
+               ir_node *node = entry->phi_list[--j];
                pre(node, env);
        }
 
@@ -125,7 +125,7 @@ static void traverse_block_pre(ir_node *block, block_entry_t *entry, irg_walk_fu
 static void traverse_block_post(ir_node *block, block_entry_t *entry,
                                 irg_walk_func *post, void *env)
 {
-       int j, n;
+       size_t j, n;
 
        post(block, env);
 
@@ -150,10 +150,10 @@ static void traverse_block_post(ir_node *block, block_entry_t *entry,
  */
 static void traverse_pre(blk_collect_data_t *blks, irg_walk_func *pre, void *env)
 {
-       int i;
+       size_t i;
 
-       for (i = ARR_LEN(blks->blk_list) - 1; i >= 0; --i) {
-               ir_node       *block = blks->blk_list[i];
+       for (i = ARR_LEN(blks->blk_list); i > 0;) {
+               ir_node       *block = blks->blk_list[--i];
                block_entry_t *entry = block_find_entry(block, blks);
 
                traverse_block_pre(block, entry, pre, env);
@@ -170,7 +170,7 @@ static void traverse_pre(blk_collect_data_t *blks, irg_walk_func *pre, void *env
  */
 static void traverse_post(blk_collect_data_t *blks, irg_walk_func *post, void *env)
 {
-       int i, k;
+       size_t i, k;
 
        for (i = 0, k = ARR_LEN(blks->blk_list); i < k; ++i) {
                ir_node       *block = blks->blk_list[i];
@@ -190,10 +190,10 @@ static void traverse_post(blk_collect_data_t *blks, irg_walk_func *post, void *e
  */
 static void traverse_both(blk_collect_data_t *blks, irg_walk_func *pre, irg_walk_func *post, void *env)
 {
-       int i;
+       size_t i;
 
-       for (i = ARR_LEN(blks->blk_list) - 1; i >= 0; --i) {
-               ir_node       *block = blks->blk_list[i];
+       for (i = ARR_LEN(blks->blk_list); i > 0;) {
+               ir_node       *block = blks->blk_list[--i];
                block_entry_t *entry = block_find_entry(block, blks);
 
                traverse_block_pre(block, entry, pre, env);
@@ -389,18 +389,18 @@ static void collect_blks_lists(ir_node *node, ir_node *block,
  */
 static void collect_lists(blk_collect_data_t *env)
 {
-       int             i, j;
+       size_t          i, j;
        ir_node         *block, *node;
        block_entry_t   *entry;
 
        inc_irg_visited(current_ir_graph);
 
-       for (i = ARR_LEN(env->blk_list) - 1; i >= 0; --i) {
-               block = env->blk_list[i];
+       for (i = ARR_LEN(env->blk_list); i > 0;) {
+               block = env->blk_list[--i];
                entry = block_find_entry(block, env);
 
-               for (j = ARR_LEN(entry->entry_list) - 1; j >= 0; --j) {
-                       node = entry->entry_list[j];
+               for (j = ARR_LEN(entry->entry_list); j > 0;) {
+                       node = entry->entry_list[--j];
 
                        /* a entry might already be visited due to Phi loops */
                        if (node->visited < current_ir_graph->visited)
@@ -410,7 +410,7 @@ static void collect_lists(blk_collect_data_t *env)
 }
 
 /**
- * Intraprozedural graph walker over blocks.
+ * Intra procedural graph walker over blocks.
  */
 static void do_irg_walk_blk(ir_graph *irg, irg_walk_func *pre,
        irg_walk_func *post, void *env, unsigned follow_deps,

diff --git a/ir/ir/irprog.c b/ir/ir/irprog.c
index 8f252a9..d9347fa 100644 (file)
--- a/ir/ir/irprog.c
+++ b/ir/ir/irprog.c
@@ -361,9 +361,9 @@ ir_op *(get_irp_opcode)(size_t pos)
 /* Sets the generic function pointer of all opcodes to NULL */
 void clear_irp_opcodes_generic_func(void)
 {
-       int i;
+       size_t i, n;
 
-       for (i = get_irp_n_opcodes() - 1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_opcodes(); i < n; ++i) {
                ir_op *op = get_irp_opcode(i);
                op->ops.generic = (op_func)NULL;
        }
@@ -415,12 +415,12 @@ static int set_irp_phase_state_wrapper(ir_prog *irp, void *context)
 {
        pass_t         *pass  = (pass_t *)context;
        irg_phase_state state = pass->state;
-       int             i;
+       size_t          i, n;
 
        (void)irp;
 
        /* set the phase of all graphs */
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i)
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i)
                set_irg_phase_state(get_irp_irg(i), state);
 
        /* set the irp phase */

diff --git a/ir/lower/lower_calls.c b/ir/lower/lower_calls.c
index f2f8828..0491c49 100644 (file)
--- a/ir/lower/lower_calls.c
+++ b/ir/lower/lower_calls.c
@@ -909,7 +909,7 @@ static void lower_method_types(type_or_ent tore, void *env)
  */
 void lower_calls_with_compounds(const lower_params_t *params)
 {
-       int i;
+       size_t i, n;
        ir_graph *irg;
        lower_params_t param = *params;
 
@@ -920,7 +920,7 @@ void lower_calls_with_compounds(const lower_params_t *params)
                type_map = NULL;
 
        /* first step: Transform all graphs */
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
                irg = get_irp_irg(i);
 
                transform_irg(&param, irg);

diff --git a/ir/lower/lower_dw.c b/ir/lower/lower_dw.c
index 4a6227b..243c593 100644 (file)
--- a/ir/lower/lower_dw.c
+++ b/ir/lower/lower_dw.c
@@ -2067,10 +2067,10 @@ static void setup_modes(lower_env_t *env)
        unsigned           size_bits           = env->params->doubleword_size;
        ir_mode           *doubleword_signed   = NULL;
        ir_mode           *doubleword_unsigned = NULL;
-       int                n_modes             = get_irp_n_modes();
+       size_t             n_modes             = get_irp_n_modes();
        ir_mode_arithmetic arithmetic;
        unsigned           modulo_shift;
-       int                i;
+       size_t             i;
 
        /* search for doubleword modes... */
        for (i = 0; i < n_modes; ++i) {
@@ -2284,7 +2284,7 @@ static void lower_irg(lower_env_t *env, ir_graph *irg)
 void lower_dw_ops(const lwrdw_param_t *param)
 {
        lower_env_t lenv;
-       int         i;
+       size_t      i, n;
 
        assert(param != NULL);
        FIRM_DBG_REGISTER(dbg, "firm.lower.dw");
@@ -2393,7 +2393,7 @@ void lower_dw_ops(const lwrdw_param_t *param)
        lenv.next_id       = new_id_from_chars(param->little_endian ? ".h" : ".l", 2);
 
        /* transform all graphs */
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
                ir_graph *irg = get_irp_irg(i);
                lower_irg(&lenv, irg);
        }

diff --git a/ir/lower/lower_hl.c b/ir/lower/lower_hl.c
index fd508af..b1d5409 100644 (file)
--- a/ir/lower/lower_hl.c
+++ b/ir/lower/lower_hl.c
@@ -638,7 +638,7 @@ ir_prog_pass_t *lower_const_code_pass(const char *name)
  */
 void lower_highlevel(int lower_bitfields)
 {
-       int i, n;
+       size_t i, n;
 
        n = get_irp_n_irgs();
        for (i = 0; i < n; ++i) {

diff --git a/ir/lower/lower_intrinsics.c b/ir/lower/lower_intrinsics.c
index 5e266a9..82b1504 100644 (file)
--- a/ir/lower/lower_intrinsics.c
+++ b/ir/lower/lower_intrinsics.c
@@ -95,8 +95,8 @@ static void call_mapper(ir_node *node, void *env)
 /* Go through all graphs and map calls to intrinsic functions. */
 size_t lower_intrinsics(i_record *list, size_t length, int part_block_used)
 {
-       size_t         i;
-       int            idx, n_ops = get_irp_n_opcodes();
+       size_t         i, n;
+       size_t         n_ops = get_irp_n_opcodes();
        ir_graph       *irg;
        pmap           *c_map = pmap_create_ex(length);
        i_instr_record **i_map;
@@ -123,8 +123,8 @@ size_t lower_intrinsics(i_record *list, size_t length, int part_block_used)
        wenv.c_map = c_map;
        wenv.i_map = i_map;
 
-       for (idx = get_irp_n_irgs() - 1; idx >= 0; --idx) {
-               irg = get_irp_irg(idx);
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
+               irg = get_irp_irg(i);
 
                if (part_block_used) {
                        ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK | IR_RESOURCE_PHI_LIST);
@@ -657,9 +657,7 @@ static ir_node *eval_strlen(ir_graph *irg, ir_entity *ent, ir_type *res_tp)
                return NULL;
 
        if (!has_entity_initializer(ent)) {
-               int len = 0;
-               int n;
-               int i = -1;
+               size_t i, n;
 
                n = get_compound_ent_n_values(ent);
                for (i = 0; i < n; ++i) {
@@ -670,14 +668,10 @@ static ir_node *eval_strlen(ir_graph *irg, ir_entity *ent, ir_type *res_tp)
 
                        if (is_Const_null(irn)) {
                                /* found the length */
-                               len = i;
-                               break;
+                               ir_tarval *tv = new_tarval_from_long(i, get_type_mode(res_tp));
+                               return new_r_Const(irg, tv);
                        }
                }
-               if (len >= 0) {
-                       ir_tarval *tv = new_tarval_from_long(len, get_type_mode(res_tp));
-                       return new_r_Const(irg, tv);
-               }
                return NULL;
        }
 
@@ -739,7 +733,6 @@ static ir_node *eval_strcmp(ir_graph *irg, ir_entity *left, ir_entity *right,
 {
        ir_type *tp;
        ir_mode *mode;
-       int     i, n, n_r, res;
 
        tp = get_entity_type(left);
        if (! is_Array_type(tp))
@@ -767,12 +760,13 @@ static ir_node *eval_strcmp(ir_graph *irg, ir_entity *left, ir_entity *right,
 
        if (!has_entity_initializer(left) && !has_entity_initializer(right)) {
                /* code that uses deprecated compound_graph_path stuff */
+               size_t n   = get_compound_ent_n_values(left);
+               size_t n_r = get_compound_ent_n_values(right);
+               size_t i;
+               int    res = 0;
 
-               n   = get_compound_ent_n_values(left);
-               n_r = get_compound_ent_n_values(right);
                if (n_r < n)
                        n = n_r;
-               res = 0;
                for (i = 0; i < n; ++i) {
                        ir_node *irn;
                        long v_l, v_r;
@@ -845,7 +839,7 @@ static int is_empty_string(ir_entity *ent)
 
        if (!has_entity_initializer(ent)) {
                /* code for deprecated compound_graph_path stuff */
-               int n = get_compound_ent_n_values(ent);
+               size_t n = get_compound_ent_n_values(ent);
                if (n < 1)
                        return 0;
                irn = get_compound_ent_value(ent, 0);

diff --git a/ir/opt/combo.c b/ir/opt/combo.c
index 815822b..47c216a 100644 (file)
--- a/ir/opt/combo.c
+++ b/ir/opt/combo.c
@@ -3519,10 +3519,10 @@ static void apply_end(ir_node *end, environment_t *env)
  */
 static void set_compute_functions(void)
 {
-       int i;
+       size_t i, n;
 
        /* set the default compute function */
-       for (i = get_irp_n_opcodes() - 1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_opcodes(); i < n; ++i) {
                ir_op *op = get_irp_opcode(i);
                op->ops.generic = (op_func)default_compute;
        }

diff --git a/ir/opt/escape_ana.c b/ir/opt/escape_ana.c
index 9b5010b..9d44435 100644 (file)
--- a/ir/opt/escape_ana.c
+++ b/ir/opt/escape_ana.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -537,8 +537,7 @@ void escape_enalysis_irg(ir_graph *irg, check_alloc_entity_func callback)
 /* Do simple and fast escape analysis for all graphs. */
 void escape_analysis(int run_scalar_replace, check_alloc_entity_func callback)
 {
-  ir_graph *irg;
-  int i;
+  size_t i, n;
   struct obstack obst;
   walk_env_t *env, *elist;
   (void) run_scalar_replace;
@@ -564,8 +563,8 @@ void escape_analysis(int run_scalar_replace, check_alloc_entity_func callback)
   env->dead_allocs  = NULL;
   env->callback     = callback;
 
-  for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
-    irg = get_irp_irg(i);
+  for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
+    ir_graph *irg = get_irp_irg(i);
 
     assure_irg_outs(irg);
 

diff --git a/ir/opt/funccall.c b/ir/opt/funccall.c
index 65ef2f8..1a9bfd8 100644 (file)
--- a/ir/opt/funccall.c
+++ b/ir/opt/funccall.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -49,8 +49,8 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg;)
  * The walker environment for updating function calls.
  */
 typedef struct env_t {
-       unsigned n_calls_SymConst;
-       unsigned n_calls_Sel;
+       size_t   n_calls_SymConst;
+       size_t   n_calls_Sel;
        ir_node  *float_const_call_list;    /**< The list of all floating const function calls that will be changed. */
        ir_node  *nonfloat_const_call_list; /**< The list of all non-floating const function calls that will be changed. */
        ir_node  *pure_call_list;           /**< The list of all pure function calls that will be changed. */
@@ -616,13 +616,13 @@ static mtp_additional_properties check_const_or_pure_function(ir_graph *irg, int
  */
 static void handle_const_Calls(env_t *ctx)
 {
-       int i;
+       size_t i, n;
 
        ctx->n_calls_SymConst = 0;
        ctx->n_calls_Sel      = 0;
 
        /* all calls of const functions can be transformed */
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_irgs(); i < 0; ++i) {
                ir_graph *irg  = get_irp_irg(i);
 
                ctx->float_const_call_list    = NULL;
@@ -646,13 +646,13 @@ static void handle_const_Calls(env_t *ctx)
  */
 static void handle_nothrow_Calls(env_t *ctx)
 {
-       int i;
+       size_t i, n;
 
        ctx->n_calls_SymConst = 0;
        ctx->n_calls_Sel      = 0;
 
        /* all calls of const functions can be transformed */
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
                ir_graph *irg  = get_irp_irg(i);
 
                ctx->nothrow_call_list = NULL;
@@ -996,11 +996,12 @@ static void check_for_possible_endless_loops(ir_graph *irg)
  */
 void optimize_funccalls(int force_run, check_alloc_entity_func callback)
 {
-       int i, last_idx;
-       unsigned num_const   = 0;
-       unsigned num_pure    = 0;
-       unsigned num_nothrow = 0;
-       unsigned num_malloc  = 0;
+       size_t i, n;
+       int last_idx;
+       size_t num_const   = 0;
+       size_t num_pure    = 0;
+       size_t num_nothrow = 0;
+       size_t num_malloc  = 0;
 
        is_alloc_entity = callback;
 
@@ -1011,7 +1012,7 @@ void optimize_funccalls(int force_run, check_alloc_entity_func callback)
 
        /* first step: detect, which functions are nothrow or malloc */
        DB((dbg, LEVEL_2, "Detecting nothrow and malloc properties ...\n"));
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
                ir_graph *irg = get_irp_irg(i);
                unsigned prop = check_nothrow_or_malloc(irg, /*top=*/1);
 
@@ -1030,8 +1031,8 @@ void optimize_funccalls(int force_run, check_alloc_entity_func callback)
                env_t ctx;
 
                handle_nothrow_Calls(&ctx);
-               DB((dbg, LEVEL_1, "Detected %u nothrow graphs, %u malloc graphs.\n", num_nothrow, num_malloc));
-               DB((dbg, LEVEL_1, "Optimizes %u(SymConst) + %u(Sel) calls to nothrow functions.\n",
+               DB((dbg, LEVEL_1, "Detected %zu nothrow graphs, %zu malloc graphs.\n", num_nothrow, num_malloc));
+               DB((dbg, LEVEL_1, "Optimizes %zu(SymConst) + %zu(Sel) calls to nothrow functions.\n",
                        ctx.n_calls_SymConst, ctx.n_calls_Sel));
        } else {
                DB((dbg, LEVEL_1, "No graphs without side effects detected\n"));
@@ -1042,7 +1043,7 @@ void optimize_funccalls(int force_run, check_alloc_entity_func callback)
 
        /* third step: detect, which functions are const or pure */
        DB((dbg, LEVEL_2, "Detecting const and pure properties ...\n"));
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
                ir_graph *irg = get_irp_irg(i);
                unsigned prop = check_const_or_pure_function(irg, /*top=*/1);
 
@@ -1060,7 +1061,7 @@ void optimize_funccalls(int force_run, check_alloc_entity_func callback)
                env_t ctx;
 
                handle_const_Calls(&ctx);
-               DB((dbg, LEVEL_1, "Detected %u const graphs, %u pure graphs.\n", num_const, num_pure));
+               DB((dbg, LEVEL_1, "Detected %zu const graphs, %zu pure graphs.\n", num_const, num_pure));
                DB((dbg, LEVEL_1, "Optimizes %u(SymConst) + %u(Sel) calls to const functions.\n",
                       ctx.n_calls_SymConst, ctx.n_calls_Sel));
        } else {

diff --git a/ir/opt/garbage_collect.c b/ir/opt/garbage_collect.c
index 0d5161d..9f32c64 100644 (file)
--- a/ir/opt/garbage_collect.c
+++ b/ir/opt/garbage_collect.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -102,8 +102,8 @@ static void visit_entity(ir_entity *entity)
        if (entity->initializer != NULL) {
                visit_initializer(entity->initializer);
        }  else if (entity_has_compound_ent_values(entity)) {
-               int i;
-               int n_members = get_compound_ent_n_values(entity);
+               size_t i;
+               size_t n_members = get_compound_ent_n_values(entity);
                for (i = 0; i < n_members; ++i) {
                        ir_node *node = get_compound_ent_value(entity, i);
                        start_visit_node(node);
@@ -149,7 +149,7 @@ static void garbage_collect_in_segment(ir_type *segment)
 
 void garbage_collect_entities(void)
 {
-       int          i;
+       size_t       i, n;
        ir_segment_t s;
 
        FIRM_DBG_REGISTER(dbg, "firm.opt.garbagecollect");
@@ -169,7 +169,7 @@ void garbage_collect_entities(void)
        /* remove graphs of non-visited functions
         * (we have to count backwards so we can safely call remove_irp_irg
         *  while iterating) */
-       for (i = get_irp_n_irgs()-1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
                ir_graph  *irg    = get_irp_irg(i);
                ir_entity *entity = get_irg_entity(irg);
 

diff --git a/ir/opt/ircgopt.c b/ir/opt/ircgopt.c
index 095a527..7d35a77 100644 (file)
--- a/ir/opt/ircgopt.c
+++ b/ir/opt/ircgopt.c
@@ -64,7 +64,7 @@ static void collect_call(ir_node *node, void *env)
 void gc_irgs(size_t n_keep, ir_entity ** keep_arr)
 {
        void * MARK = &MARK; /* @@@ gefaehrlich!!! Aber wir markieren hoechstens zu viele ... */
-       int i;
+       size_t i, n;
 
        FIRM_DBG_REGISTER(dbg, "firm.opt.cgopt");
 
@@ -123,7 +123,7 @@ void gc_irgs(size_t n_keep, ir_entity ** keep_arr)
        }
 
        /* clean */
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
                ir_graph  *irg = get_irp_irg(i);
                ir_entity *ent = get_irg_entity(irg);
 

diff --git a/ir/opt/loop.c b/ir/opt/loop.c
index 4f39d09..2635ced 100644 (file)
--- a/ir/opt/loop.c
+++ b/ir/opt/loop.c
@@ -2715,13 +2715,13 @@ static void init_analyze(ir_loop *loop)
 static void find_innermost_loop(ir_loop *loop)
 {
        /* descend into sons */
-       int sons = get_loop_n_sons(loop);
+       size_t sons = get_loop_n_sons(loop);
 
        if (sons == 0) {
                ARR_APP1(ir_loop *, loops, loop);
        } else {
-               int s;
-               for (s=0; s<sons; s++) {
+               size_t s;
+               for (s = 0; s < sons; ++s) {
                        find_innermost_loop(get_loop_son(loop, s));
                }
        }
@@ -2750,7 +2750,7 @@ static void set_loop_params(void)
 void loop_optimization(ir_graph *irg)
 {
        ir_loop *loop;
-       int     sons, nr;
+       size_t  sons, nr;
        size_t  i;
 
        set_loop_params();

diff --git a/ir/opt/opt_inline.c b/ir/opt/opt_inline.c
index 0f13218..a93c1f3 100644 (file)
--- a/ir/opt/opt_inline.c
+++ b/ir/opt/opt_inline.c
@@ -968,7 +968,7 @@ void inline_leave_functions(unsigned maxsize, unsigned leavesize,
 {
        inline_irg_env   *env;
        ir_graph         *irg;
-       int              i, n_irgs;
+       size_t           i, n_irgs;
        ir_graph         *rem;
        int              did_inline;
        wenv_t           wenv;
@@ -1473,16 +1473,18 @@ static int calc_inline_benefice(call_entry *entry, ir_graph *callee)
        return entry->benefice = weight;
 }
 
-static ir_graph **irgs;
-static int      last_irg;
+typedef struct walk_env_t {
+       ir_graph **irgs;
+       size_t   last_irg;
+} walk_env_t;
 
 /**
  * Callgraph walker, collect all visited graphs.
  */
 static void callgraph_walker(ir_graph *irg, void *data)
 {
-       (void) data;
-       irgs[last_irg++] = irg;
+       walk_env_t *env = (walk_env_t *)data;
+       env->irgs[env->last_irg++] = irg;
 }
 
 /**
@@ -1492,21 +1494,22 @@ static void callgraph_walker(ir_graph *irg, void *data)
  */
 static ir_graph **create_irg_list(void)
 {
-       ir_entity **free_methods;
-       int       n_irgs = get_irp_n_irgs();
+       ir_entity  **free_methods;
+       size_t     n_irgs = get_irp_n_irgs();
+       walk_env_t env;
 
        cgana(&free_methods);
        xfree(free_methods);
 
        compute_callgraph();
 
-       last_irg = 0;
-       irgs     = XMALLOCNZ(ir_graph*, n_irgs);
+       env.irgs     = XMALLOCNZ(ir_graph*, n_irgs);
+       env.last_irg = 0;
 
-       callgraph_walk(NULL, callgraph_walker, NULL);
-       assert(n_irgs == last_irg);
+       callgraph_walk(NULL, callgraph_walker, &env);
+       assert(n_irgs == env.last_irg);
 
-       return irgs;
+       return env.irgs;
 }
 
 /**
@@ -1721,7 +1724,7 @@ void inline_functions(unsigned maxsize, int inline_threshold,
                       opt_ptr after_inline_opt)
 {
        inline_irg_env   *env;
-       int              i, n_irgs;
+       size_t           i, n_irgs;
        ir_graph         *rem;
        wenv_t           wenv;
        pmap             *copied_graphs;

diff --git a/ir/opt/proc_cloning.c b/ir/opt/proc_cloning.c
index 355eddf..392fc18 100644 (file)
--- a/ir/opt/proc_cloning.c
+++ b/ir/opt/proc_cloning.c
@@ -595,8 +595,7 @@ restart:
 void proc_cloning(float threshold)
 {
        entry_t *entry = NULL, *p;
-       ir_graph *irg;
-       int i;
+       size_t i, n;
        q_set hmap;
 
        obstack_init(&hmap.obst);
@@ -604,8 +603,8 @@ void proc_cloning(float threshold)
        hmap.heavy_uses = NULL;
 
        /* initially fill our map by visiting all irgs */
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
-               irg = get_irp_irg(i);
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
+               ir_graph *irg = get_irp_irg(i);
                irg_walk_graph(irg, collect_irg_calls, NULL, &hmap);
        }
 

diff --git a/ir/opt/tailrec.c b/ir/opt/tailrec.c
index e1b5223..6c6012a 100644 (file)
--- a/ir/opt/tailrec.c
+++ b/ir/opt/tailrec.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -717,14 +717,13 @@ ir_graph_pass_t *opt_tail_rec_irg_pass(const char *name)
  */
 void opt_tail_recursion(void)
 {
-       int i;
-       int n_opt_applications = 0;
-       ir_graph *irg;
+       size_t i, n;
+       size_t n_opt_applications = 0;
 
        FIRM_DBG_REGISTER(dbg, "firm.opt.tailrec");
 
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
-               irg = get_irp_irg(i);
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
+               ir_graph *irg = get_irp_irg(i);
 
                ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
                if (opt_tail_rec_irg(irg))
@@ -733,7 +732,7 @@ void opt_tail_recursion(void)
                ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
        }
 
-       DB((dbg, LEVEL_1, "Performed tail recursion for %d of %d graphs\n",
+       DB((dbg, LEVEL_1, "Performed tail recursion for %zu of %zu graphs\n",
            n_opt_applications, get_irp_n_irgs()));
 }
 

diff --git a/ir/opt/tropt.c b/ir/opt/tropt.c
index c312470..fc08927 100644 (file)
--- a/ir/opt/tropt.c
+++ b/ir/opt/tropt.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -44,9 +44,9 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg;)
 
 /* - statistics ---------------------------------------------- */
 
-static int n_casts_normalized = 0;
-static int n_casts_removed    = 0;
-static int n_sels_concretized = 0;
+static size_t n_casts_normalized = 0;
+static size_t n_casts_removed    = 0;
+static size_t n_sels_concretized = 0;
 
 /* - Cast normalization. ------------------------------------- */
 
@@ -81,7 +81,7 @@ static ir_type *default_gen_pointer_type_to(ir_type *tp)
 }
 
 /** Return a type that is a depth times pointer to type. */
-static ir_type *pointerize_type(ir_type *tp, int depth)
+static ir_type *pointerize_type(ir_type *tp, size_t depth)
 {
        for (; depth > 0; --depth) {
                tp = gen_pointer_type_to(tp);
@@ -95,14 +95,14 @@ static ir_node *normalize_values_type(ir_type *totype, ir_node *pred)
        ir_type *fromtype = get_irn_typeinfo_type(pred);
        ir_node *new_cast = pred;
        ir_node *block;
-       int ref_depth = 0;
+       size_t  ref_depth = 0;
 
        if (totype == fromtype) return pred;   /* Case for optimization! */
 
        while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
                totype   = get_pointer_points_to_type(totype);
                fromtype = get_pointer_points_to_type(fromtype);
-               ref_depth++;
+               ++ref_depth;
        }
 
        if (!is_Class_type(totype))   return pred;
@@ -133,7 +133,7 @@ static ir_node *normalize_values_type(ir_type *totype, ir_node *pred)
                        new_type = pointerize_type(new_type, ref_depth);
                        new_cast = new_r_Cast(block, pred, new_type);
                        pred = new_cast;
-                       n_casts_normalized ++;
+                       ++n_casts_normalized;
                        set_irn_typeinfo_type(new_cast, new_type);  /* keep type information up to date. */
                        if (get_trouts_state() != outs_none) add_type_cast(new_type, new_cast);
                }
@@ -154,7 +154,7 @@ static ir_node *normalize_values_type(ir_type *totype, ir_node *pred)
                        new_type = pointerize_type(new_type, ref_depth);
                        new_cast = new_r_Cast(block, pred, new_type);
                        pred = new_cast;
-                       n_casts_normalized ++;
+                       ++n_casts_normalized;
                        set_irn_typeinfo_type(new_cast, new_type);  /* keep type information up to date. */
                        if (get_trouts_state() != outs_none) add_type_cast(new_type, new_cast);
                }
@@ -215,7 +215,7 @@ void normalize_irg_class_casts(ir_graph *irg, gen_pointer_type_to_func gppt_fct)
 
 void normalize_irp_class_casts(gen_pointer_type_to_func gppt_fct)
 {
-       int i;
+       size_t i, n;
        if (gppt_fct) gen_pointer_type_to = gppt_fct;
 
 #if 0
@@ -223,14 +223,15 @@ void normalize_irp_class_casts(gen_pointer_type_to_func gppt_fct)
                simple_analyse_types();
 #endif
 
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
-               pure_normalize_irg_class_casts(get_irp_irg(i));
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
+               ir_graph *irg = get_irp_irg(i);
+               pure_normalize_irg_class_casts(irg);
        }
 
        set_irp_class_cast_state(ir_class_casts_normalized);
        gen_pointer_type_to = default_gen_pointer_type_to;
 
-       DB((dbg, SET_LEVEL_1, " Cast normalization: %d Casts inserted.\n", n_casts_normalized));
+       DB((dbg, SET_LEVEL_1, " Cast normalization: %zu Casts inserted.\n", n_casts_normalized));
 }
 
 
@@ -486,14 +487,14 @@ void optimize_class_casts(void)
        all_irg_walk(NULL, irn_optimize_class_cast, &changed);
 
        if (changed) {
-               int i;
+               size_t i, n;
 
                set_trouts_inconsistent();
-               for (i = get_irp_n_irgs() - 1; i >= 0; --i)
+               for (i = 0, n = get_irp_n_irgs(); i < n; ++i)
                        set_irg_outs_inconsistent(get_irp_irg(i));
        }
 
-       DB((dbg, SET_LEVEL_1, " Cast optimization: %d Casts removed, %d Sels concretized.\n",
+       DB((dbg, SET_LEVEL_1, " Cast optimization: %zu Casts removed, %zu Sels concretized.\n",
                n_casts_removed, n_sels_concretized));
 }
 

diff --git a/ir/stat/pattern.c b/ir/stat/pattern.c
index 95d78fc..5f532ba 100644 (file)
--- a/ir/stat/pattern.c
+++ b/ir/stat/pattern.c
@@ -395,16 +395,20 @@ static int addr_cmp(const void *p1, const void *p2, size_t size)
        return e1->addr != e2->addr;
 }  /* addr_cmp */
 
-static unsigned find_mode_index(const ir_mode *mode)
+/**
+ * Return the index of a (existing) mode.
+ */
+static size_t find_mode_index(const ir_mode *mode)
 {
-       int n = get_irp_n_modes();
-       int i;
+       size_t i, n = get_irp_n_modes();
 
        for (i = 0; i < n; ++i) {
                if (get_irp_mode(i) == mode)
                        return i;
        }
-       return -1;
+       /* should really not happen */
+       assert(!"Cound not find index of mode in find_mode_index()");
+       return (size_t)-1;
 }
 
 /**

diff --git a/ir/stat/stat_liveness.c b/ir/stat/stat_liveness.c
index 5393131..f2f1608 100644 (file)
--- a/ir/stat/stat_liveness.c
+++ b/ir/stat/stat_liveness.c
@@ -71,9 +71,10 @@ static block_entry_t *get_block_entry(ir_node *block)
 static void add_entry(ir_node ***arr, ir_node *irn)
 {
        ir_node **list = *arr;
-       int i;
+       size_t i;
 
-       for (i = ARR_LEN(list) - 1; i >= 0; --i) {
+       for (i = ARR_LEN(list); i > 0;) {
+               --i;
                if (list[i] == irn) {
                        /* already there */
                        return;

diff --git a/ir/tr/tr_inheritance.c b/ir/tr/tr_inheritance.c
index 028a484..602836a 100644 (file)
--- a/ir/tr/tr_inheritance.c
+++ b/ir/tr/tr_inheritance.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -347,7 +347,7 @@ static void compute_up_closure(ir_type *tp)
  *  transitive closure.    */
 void compute_inh_transitive_closure(void)
 {
-       int i, n_types = get_irp_n_types();
+       size_t i, n_types = get_irp_n_types();
        free_inh_transitive_closure();
 
        /* The 'down' relation */
@@ -621,8 +621,8 @@ ir_class_cast_state get_irg_class_cast_state(const ir_graph *irg)
 void set_irp_class_cast_state(ir_class_cast_state s)
 {
 #ifndef NDEBUG
-       int i;
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i)
+       size_t i, n;
+       for (i = 0, n = get_irp_n_irgs(); i < n; ++i)
                assert(get_irg_class_cast_state(get_irp_irg(i)) >= s);
 #endif
        irp->class_cast_state = s;

diff --git a/ir/tr/trverify.c b/ir/tr/trverify.c
index 3c535bb..a2ffa00 100644 (file)
--- a/ir/tr/trverify.c
+++ b/ir/tr/trverify.c
@@ -334,8 +334,8 @@ static int constants_on_wrong_irg(ir_entity *ent)
        if (ent->initializer != NULL) {
                return initializer_constant_on_wrong_irg(ent->initializer);
        } else if (entity_has_compound_ent_values(ent)) {
-               int i;
-               for (i = get_compound_ent_n_values(ent) - 1; i >= 0; --i) {
+               size_t i, n;
+               for (i = 0, n = get_compound_ent_n_values(ent); i < n; ++i) {
                        if (constant_on_wrong_irg(get_compound_ent_value(ent, i)))
                                return 1;
                }

diff --git a/ir/tr/type.c b/ir/tr/type.c
index 1ffedf9..2a2283b 100644 (file)
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -1993,7 +1993,7 @@ void set_pointer_mode(ir_type *tp, ir_mode *mode)
 
 ir_type *find_pointer_type_to_type(ir_type *tp)
 {
-       int i, n = get_irp_n_types();
+       size_t i, n = get_irp_n_types();
        for (i = 0; i < n; ++i) {
                ir_type *found = get_irp_type(i);
                if (is_Pointer_type(found) && get_pointer_points_to_type(found) == tp)

diff --git a/ir/tr/typewalk.c b/ir/tr/typewalk.c
index 92d81a3..71b0028 100644 (file)
--- a/ir/tr/typewalk.c
+++ b/ir/tr/typewalk.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -130,7 +130,7 @@ static void do_type_walk(type_or_ent tore,
                if (ent->initializer != NULL) {
                        walk_initializer(ent->initializer, pre, post, env);
                } else if (entity_has_compound_ent_values(ent)) {
-                       n_mem = get_compound_ent_n_values(ent);
+                       size_t i, n_mem = get_compound_ent_n_values(ent);
                        for (i = 0; i < n_mem; ++i) {
                                n = get_compound_ent_value(ent, i);
                                irn_type_walker(n, pre, post, env);
@@ -260,7 +260,7 @@ static void start_type_walk(ir_node *node, void *ctx)
 /* walker: walks over all types */
 void type_walk(type_walk_func *pre, type_walk_func *post, void *env)
 {
-       int         i, n_types = get_irp_n_types();
+       size_t      i, n_types = get_irp_n_types();
        type_or_ent cont;
 
        irp_reserve_resources(irp, IR_RESOURCE_TYPE_VISITED);
@@ -276,7 +276,7 @@ void type_walk(type_walk_func *pre, type_walk_func *post, void *env)
 
 void type_walk_prog(type_walk_func *pre, type_walk_func *post, void *env)
 {
-       int i, n_irgs = get_irp_n_irgs();
+       size_t i, n_irgs = get_irp_n_irgs();
        type_or_ent cont;
 
        type_walk(pre, post, env);
@@ -415,7 +415,7 @@ void type_walk_super2sub(type_walk_func *pre,
                          void *env)
 {
        type_or_ent cont;
-       int         i, n_types = get_irp_n_types();
+       size_t      i, n_types = get_irp_n_types();
 
        irp_reserve_resources(irp, IR_RESOURCE_TYPE_VISITED);
        inc_master_type_visited();
@@ -499,7 +499,7 @@ static void type_walk_super_2(type_or_ent tore, type_walk_func *pre,
 
 void type_walk_super(type_walk_func *pre, type_walk_func *post, void *env)
 {
-       int         i, n_types = get_irp_n_types();
+       size_t      i, n_types = get_irp_n_types();
        type_or_ent cont;
 
        irp_reserve_resources(irp, IR_RESOURCE_TYPE_VISITED);
@@ -551,7 +551,7 @@ void class_walk_super2sub(class_walk_func *pre,
                           class_walk_func *post,
                           void *env)
 {
-       int i, n_types = get_irp_n_types();
+       size_t i, n_types = get_irp_n_types();
        ir_type *tp;
 
        irp_reserve_resources(irp, IR_RESOURCE_TYPE_VISITED);