s/\<\(LC_\)\?INLINE\>/inline/.

[libfirm] / ir / be / beuses.c

diff --git a/ir/be/beuses.c b/ir/be/beuses.c
index eb9b536..7da6b4f 100644 (file)
--- a/ir/be/beuses.c
+++ b/ir/be/beuses.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -24,9 +24,7 @@
  * @date        27.06.2005
  * @version     $Id$
  */
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
 
 #include <limits.h>
 #include <stdlib.h>
@@ -51,7 +49,6 @@
 #include "beirgmod.h"
 #include "bearch_t.h"
 #include "beuses.h"
-#include "benodesets.h"
 
 #define SCAN_INTERBLOCK_USES
 
@@ -75,6 +72,8 @@ static int cmp_use(const void *a, const void *b, size_t n)
 {
        const be_use_t *p = a;
        const be_use_t *q = b;
+       (void) n;
+
        return !(p->block == q->block && p->node == q->node);
 }
 
@@ -86,7 +85,7 @@ static const be_use_t *get_or_set_use_block(be_uses_t *env,
                                             const ir_node *block,
                                             const ir_node *def)
 {
-       unsigned hash = HASH_COMBINE(nodeset_hash(block), nodeset_hash(def));
+       unsigned hash = HASH_COMBINE(hash_irn(block), hash_irn(def));
        be_use_t temp;
        be_use_t* result;
 
@@ -118,17 +117,19 @@ static const be_use_t *get_or_set_use_block(be_uses_t *env,
        return result;
 }
 
-static int be_is_phi_argument(const be_lv_t *lv, const ir_node *block, const ir_node *def)
+static int be_is_phi_argument(const ir_node *block, const ir_node *def)
 {
        ir_node *node;
        ir_node *succ_block = NULL;
        const ir_edge_t *edge;
        int arity, i;
 
-#if 0
-       if(get_irn_n_edges_kind(block, EDGE_KIND_BLOCK) > 1)
-               return 0;
+#if 1
+       if (get_irn_n_edges_kind(block, EDGE_KIND_BLOCK) < 1)
+#else
+       if (get_irn_n_edges_kind(block, EDGE_KIND_BLOCK) != 1)
 #endif
+               return 0;
 
        foreach_block_succ(block, edge) {
                succ_block = get_edge_src_irn(edge);
@@ -169,12 +170,12 @@ static be_next_use_t get_next_use(be_uses_t *env, ir_node *from,
                                                                  unsigned from_step, const ir_node *def,
                                                                  int skip_from_uses)
 {
-       unsigned  step = from_step;
+       unsigned  step  = from_step;
        ir_node  *block = get_nodes_block(from);
        ir_node  *next_use;
        ir_node  *node;
        unsigned  timestep;
-       int      next_use_step;
+       unsigned  next_use_step;
        const ir_edge_t *edge;
 
 #if 1
@@ -190,6 +191,8 @@ static be_next_use_t get_next_use(be_uses_t *env, ir_node *from,
                ir_node  *node = get_edge_src_irn(edge);
                unsigned  node_step;
 
+               if(is_Anchor(node))
+                       continue;
                if(get_nodes_block(node) != block)
                        continue;
                if(is_Phi(node))
@@ -208,6 +211,7 @@ static be_next_use_t get_next_use(be_uses_t *env, ir_node *from,
                be_next_use_t result;
                result.time           = next_use_step - timestep + skip_from_uses;
                result.outermost_loop = get_loop_depth(get_irn_loop(block));
+               result.before         = next_use;
                return result;
        }
 
@@ -245,8 +249,9 @@ static be_next_use_t get_next_use(be_uses_t *env, ir_node *from,
                                        return be_get_next_use(env, node, step, node, 1);
                                }
 
-                               result.time = step;
+                               result.time           = step;
                                result.outermost_loop = get_loop_depth(get_irn_loop(block));
+                               result.before         = node;
                                return result;
                        }
                }
@@ -255,7 +260,7 @@ static be_next_use_t get_next_use(be_uses_t *env, ir_node *from,
        }
 #endif
 
-       if(be_is_phi_argument(env->lv, block, def)) {
+       if(be_is_phi_argument(block, def)) {
                // TODO we really should continue searching the uses of the phi,
                // as a phi isn't a real use that implies a reload (because we could
                // easily spill the whole phi)
@@ -263,6 +268,7 @@ static be_next_use_t get_next_use(be_uses_t *env, ir_node *from,
                be_next_use_t result;
                result.time           = step;
                result.outermost_loop = get_loop_depth(get_irn_loop(block));
+               result.before         = block;
                return result;
        }
 
@@ -278,6 +284,7 @@ static be_next_use_t get_next_use(be_uses_t *env, ir_node *from,
        ir_graph *irg       = get_irn_irg(block);
        ir_node *startblock = get_irg_start_block(irg);
 
+       result.before  = NULL;
        outermost_loop = loopdepth;
        foreach_block_succ(block, edge) {
                const be_use_t *use;
@@ -317,15 +324,16 @@ static be_next_use_t get_next_use(be_uses_t *env, ir_node *from,
                }
 
                if(use_dist < next_use) {
-                       next_use = use_dist;
+                       next_use       = use_dist;
                        outermost_loop = use->outermost_loop;
+                       result.before  = use->node;
                }
        }
 
        if(loopdepth < outermost_loop)
                outermost_loop = loopdepth;
 
-       result.time = next_use + step;
+       result.time           = next_use + step;
        result.outermost_loop = outermost_loop;
 
        if(!found_use && found_visited) {
@@ -354,20 +362,19 @@ void set_sched_step_walker(ir_node *block, void *data)
 {
        ir_node  *node;
        unsigned step = 0;
+       (void) data;
 
        sched_foreach(block, node) {
                set_irn_link(node, INT_TO_PTR(step));
                if(is_Phi(node))
                        continue;
-               if(is_Proj(node))
-                       continue;
                ++step;
        }
 }
 
 be_uses_t *be_begin_uses(ir_graph *irg, const be_lv_t *lv)
 {
-       be_uses_t *env = xmalloc(sizeof(env[0]));
+       be_uses_t *env = XMALLOC(be_uses_t);
 
        edges_assure(irg);