Revert r28379.

[libfirm] / ir / opt / scalar_replace.c

diff --git a/ir/opt/scalar_replace.c b/ir/opt/scalar_replace.c
index 1aa7436..99c0a70 100644 (file)
--- a/ir/opt/scalar_replace.c
+++ b/ir/opt/scalar_replace.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.
  *
@@ -57,7 +57,7 @@
  */
 typedef union {
        ir_entity *ent;
-       tarval *tv;
+       ir_tarval *tv;
 } path_elem_t;
 
 /**
@@ -66,7 +66,7 @@ typedef union {
  */
 typedef struct path_t {
        unsigned    vnum;      /**< The value number. */
-       unsigned    path_len;  /**< The length of the access path. */
+       size_t      path_len;  /**< The length of the access path. */
        path_elem_t path[1];   /**< The path. */
 } path_t;
 
@@ -86,8 +86,8 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg;)
  */
 static int path_cmp(const void *elt, const void *key, size_t size)
 {
-       const path_t *p1 = elt;
-       const path_t *p2 = key;
+       const path_t *p1 = (const path_t*)elt;
+       const path_t *p2 = (const path_t*)key;
        (void) size;
 
        /* we can use memcmp here, because identical tarvals should have identical addresses */
@@ -101,8 +101,8 @@ static int path_cmp(const void *elt, const void *key, size_t size)
  */
 static int ent_cmp(const void *elt, const void *key, size_t size)
 {
-       const scalars_t *c1 = elt;
-       const scalars_t *c2 = key;
+       const scalars_t *c1 = (const scalars_t*)elt;
+       const scalars_t *c2 = (const scalars_t*)key;
        (void) size;
 
        return c1->ent != c2->ent;
@@ -436,9 +436,10 @@ static int find_possible_replacements(ir_graph *irg)
  * @param sel  the Sel node
  * @param len  the length of the path so far
  */
-static path_t *find_path(ir_node *sel, unsigned len)
+static path_t *find_path(ir_node *sel, size_t len)
 {
-       int pos, i, n;
+       size_t pos;
+       int i, n;
        path_t *res;
        ir_node *pred = get_Sel_ptr(sel);
 
@@ -453,6 +454,7 @@ static path_t *find_path(ir_node *sel, unsigned len)
        } else
                res = find_path(pred, len);
 
+       assert(len <= res->path_len);
        pos = res->path_len - len;
 
        res->path[pos++].ent = get_Sel_entity(sel);
@@ -485,14 +487,15 @@ static unsigned allocate_value_numbers(pset *sels, ir_entity *ent, unsigned vnum
 
        DB((dbg, SET_LEVEL_3, "  Visiting Sel nodes of entity %+F\n", ent));
        /* visit all Sel nodes in the chain of the entity */
-       for (sel = get_entity_link(ent); sel; sel = next) {
-               next = get_irn_link(sel);
+       for (sel = (ir_node*)get_entity_link(ent); sel != NULL;
+            sel = next) {
+               next = (ir_node*)get_irn_link(sel);
 
                /* we must mark this sel for later */
                pset_insert_ptr(sels, sel);
 
                key  = find_path(sel, 0);
-               path = set_find(pathes, key, PATH_SIZE(key), path_hash(key));
+               path = (path_t*)set_find(pathes, key, PATH_SIZE(key), path_hash(key));
 
                if (path) {
                        SET_VNUM(sel, path->vnum);
@@ -505,7 +508,7 @@ static unsigned allocate_value_numbers(pset *sels, ir_entity *ent, unsigned vnum
                        SET_VNUM(sel, key->vnum);
                        DB((dbg, SET_LEVEL_3, "  %+F represents value %u\n", sel, key->vnum));
 
-                       ARR_EXTO(ir_mode *, *modes, (int)((key->vnum + 15) & ~15));
+                       ARR_EXTO(ir_mode *, *modes, (key->vnum + 15) & ~15);
 
                        (*modes)[key->vnum] = get_type_mode(get_entity_type(get_Sel_entity(sel)));
 
@@ -556,7 +559,7 @@ typedef struct env_t {
  */
 static void topologic_walker(ir_node *node, void *ctx)
 {
-       env_t    *env = ctx;
+       env_t    *env = (env_t*)ctx;
        ir_graph *irg = get_irn_irg(node);
        ir_node  *adr, *block, *mem, *val;
        ir_mode  *mode;
@@ -653,24 +656,25 @@ static void topologic_walker(ir_node *node, void *ctx)
  * @param modes   A flexible array, containing all the modes of
  *                the value numbers.
  */
-static void do_scalar_replacements(pset *sels, int nvals, ir_mode **modes)
+static void do_scalar_replacements(ir_graph *irg, pset *sels, int nvals,
+                                   ir_mode **modes)
 {
        env_t env;
 
-       ssa_cons_start(current_ir_graph, nvals);
+       ssa_cons_start(irg, nvals);
 
-       env.nvals     = nvals;
-       env.modes     = modes;
-       env.sels      = sels;
+       env.nvals = nvals;
+       env.modes = modes;
+       env.sels  = sels;
 
        /*
         * second step: walk over the graph blockwise in topological order
         * and fill the array as much as possible.
         */
-       DB((dbg, SET_LEVEL_3, "Substituting Loads and Stores in %+F\n", current_ir_graph));
-       irg_walk_blkwise_graph(current_ir_graph, NULL, topologic_walker, &env);
+       DB((dbg, SET_LEVEL_3, "Substituting Loads and Stores in %+F\n", irg));
+       irg_walk_blkwise_graph(irg, NULL, topologic_walker, &env);
 
-       ssa_cons_finish(current_ir_graph);
+       ssa_cons_finish(irg);
 }
 
 /*
@@ -688,12 +692,8 @@ int scalar_replacement_opt(ir_graph *irg)
        set       *set_ent;
        pset      *sels;
        ir_type   *ent_type, *frame_tp;
-       ir_graph  *rem;
        int       res = 0;
 
-       rem = current_ir_graph;
-       current_ir_graph = irg;
-
        /* Call algorithm that computes the out edges */
        assure_irg_outs(irg);
 
@@ -752,9 +752,9 @@ int scalar_replacement_opt(ir_graph *irg)
 
                /* If scalars were found. */
                if (nvals > 0) {
-                       do_scalar_replacements(sels, nvals, modes);
+                       do_scalar_replacements(irg, sels, nvals, modes);
 
-                       foreach_set(set_ent, value) {
+                       foreach_set(set_ent, scalars_t*, value) {
                                free_entity(value->ent);
                        }
 
@@ -776,7 +776,6 @@ int scalar_replacement_opt(ir_graph *irg)
        ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
        irp_free_resources(irp, IR_RESOURCE_ENTITY_LINK);
 
-       current_ir_graph = rem;
        return res;
 }