used is_final_ent() instead of *_n_overwrites == 0

[libfirm] / ir / opt / data_flow_scalar_replace.c

diff --git a/ir/opt/data_flow_scalar_replace.c b/ir/opt/data_flow_scalar_replace.c
index 8eea836..b49127d 100644 (file)
--- a/ir/opt/data_flow_scalar_replace.c
+++ b/ir/opt/data_flow_scalar_replace.c
@@ -166,10 +166,10 @@ static int sels_cmp(const void *elt, const void *key, size_t size)
  */
 static int leave_cmp(const void *elt, const void *key)
 {
-  const ir_node *c1 = elt;
-  const ir_node *c2 = key;
+  ir_node *c1 = (ir_node *)elt;
+  ir_node *c2 = (ir_node *)key;
 
-  return c1->attr.s.ent != c2->attr.s.ent;
+  return get_Sel_entity(c1) != get_Sel_entity(c2);
 }
 
 /**
@@ -976,7 +976,7 @@ static void split_memory_edge(ir_node *irn, void *ctx) {
  * @param block A block from the current ir graph.
  * @param vnum  The value number, that must be found.
  */
-static ir_node *find_value(ir_node *block, unsigned vnum)
+static ir_node *find_vnum_value(ir_node *block, unsigned vnum)
 {
   value_arr_entry_t *val_arr;
   int               i;
@@ -993,7 +993,7 @@ static ir_node *find_value(ir_node *block, unsigned vnum)
     for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i) {
       ir_node *pred = get_Block_cfgpred(block, i);
 
-      res = find_value(get_nodes_block(pred), vnum);
+      res = find_vnum_value(get_nodes_block(pred), vnum);
       if (res)
         return res;
     }
@@ -1009,7 +1009,7 @@ static ir_node *find_value(ir_node *block, unsigned vnum)
 static void fix_ls(env_t *env)
 {
   fixlist_entry_t *l;
-  ir_node      *irn, *block, *pred, *val;
+  ir_node      *irn, *block, *pred, *val = NULL;
   ir_op        *op;
   int          i;
 
@@ -1023,7 +1023,7 @@ static void fix_ls(env_t *env)
       pred = get_nodes_block(pred);
 
       inc_irg_block_visited(current_ir_graph);
-      val = find_value(pred, l->vnum);
+      val = find_vnum_value(pred, l->vnum);
 
       if (val)
         break;
@@ -1031,12 +1031,12 @@ static void fix_ls(env_t *env)
 
     if(val) {
       if(op == op_Store)
-       set_Store_mem(irn, val);
+        set_Store_mem(irn, val);
       else
-       if(op == op_Load)
-         set_Load_mem(irn, val);
-       else
-         set_Call_mem(irn, val);
+        if(op == op_Load)
+          set_Load_mem(irn, val);
+        else
+          set_Call_mem(irn, val);
     }
   }
 }
@@ -1062,7 +1062,7 @@ static void fix_phis(env_t *env)
       pred = get_nodes_block(pred);
 
       inc_irg_block_visited(current_ir_graph);
-      val = find_value(pred, l->vnum);
+      val = find_vnum_value(pred, l->vnum);
 
       if (val)
         set_irn_n(phi, i, val);
@@ -1096,7 +1096,7 @@ static void fix_syncs(env_t *env)
     /* We first repair the global memory edge at the first position of sync predecessors.*/
     if(get_irn_op(get_irn_n(sync, 0)) == op_Unknown) {
       inc_irg_block_visited(current_ir_graph);
-      val = find_value(pred, env->gl_mem_vnum);
+      val = find_vnum_value(pred, env->gl_mem_vnum);
 
       if(val)
        set_irn_n(sync, 0, val);
@@ -1108,7 +1108,7 @@ static void fix_syncs(env_t *env)
       assert(k <= ARR_LEN(l->accessed_vnum) && "The algorythm for sync repair is wron");
       if(get_irn_op(get_irn_n(sync, i)) == op_Unknown) {
         inc_irg_block_visited(current_ir_graph);
-        val = find_value(pred, l->accessed_vnum[k++]);
+        val = find_vnum_value(pred, l->accessed_vnum[k++]);
 
         if(val)
           set_irn_n(sync, i, val);
@@ -1140,13 +1140,13 @@ static void sync_mem_edges(env_t *env) {
       vnum_state++;
 
   /* We allocate the memory, that we need for the predecessors of the sync.*/
-  in     = malloc(sizeof(ir_node*) *vnum_state);
+  in     = xmalloc(sizeof(ir_node*) *vnum_state);
 
   /* The global memory edge is the first predecessor of this sync node.*/
   if(val_arr[env->gl_mem_vnum].mem_edge_state == NULL) {
     /* We must search through blocks for this memory state.*/
     inc_irg_block_visited(current_ir_graph);
-    in[0] = find_value(Return_blk, env->gl_mem_vnum);
+    in[0] = find_vnum_value(Return_blk, env->gl_mem_vnum);
   }
   else
     in[0] = val_arr[env->gl_mem_vnum].mem_edge_state;
@@ -1160,7 +1160,7 @@ static void sync_mem_edges(env_t *env) {
       if(val_arr[vnum].mem_edge_state == NULL) {
         /* We must search through blocks for this memory state.*/
         inc_irg_block_visited(current_ir_graph);
-        in[i] = find_value(Return_blk, vnum);
+        in[i] = find_vnum_value(Return_blk, vnum);
       }
       else
         in[i] = val_arr[vnum].mem_edge_state;
@@ -1284,21 +1284,6 @@ static void analyse_calls(ir_node *irn, void *ctx) {
   }
 }
 
-static int have_blk_phi_mem(ir_node *blk) {
-
-  int     i;
-  ir_node *out;
-
-  for(i = get_irn_n_outs(blk) - 1; i >= 0; i--) {
-
-    out = get_irn_out(blk, i);
-    if(get_irn_op(out) == op_Phi)
-      return 1;
-  }
-
-  return 0;
-}
-
 static int set_block_dominated_first_access(ir_node *blk, int vnum, unsigned int access) {
 
   ir_node *idom, *succ;