X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fdata_flow_scalar_replace.c;h=7ff3ecfc1eeb520cfc388fb15532076882529b2b;hb=026ec52ac914eee06e7afb961fb754735fb4ad9f;hp=fa3e72b4f87d0381a207883e6a435057a45c3b4f;hpb=f69a170ef2d9bf23b79e1ea5e7be4e8921253b3f;p=libfirm

diff --git a/ir/opt/data_flow_scalar_replace.c b/ir/opt/data_flow_scalar_replace.c
index fa3e72b4f..7ff3ecfc1 100644
--- a/ir/opt/data_flow_scalar_replace.c
+++ b/ir/opt/data_flow_scalar_replace.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.
  *
@@ -23,15 +23,12 @@
  * @author  Beyhan Veliev, Michael Beck
  * @version $Id$
  */
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
 
-#ifdef HAVE_STRING_H
+#include "iroptimize.h"
+
 #include <string.h>
-#endif
 
-#include "data_flow_scalar_replace.h"
 #include "irflag_t.h"
 #include "irouts.h"
 #include "pset.h"
@@ -44,7 +41,6 @@
 #include "irloop.h"
 #include "analyze_irg_args.h"
 #include "irprintf.h"
-#include "compute_loop_info.h"
 #include "irgopt.h"
 #include "xmalloc.h"
 
@@ -136,6 +132,7 @@ static int ent_leaves_t_cmp(const void *elt, const void *key, size_t size)
 {
   const ent_leaves_t *c1 = elt;
   const ent_leaves_t *c2 = key;
+  (void) size;
 
   return c1->ent != c2->ent;
 }
@@ -162,6 +159,7 @@ static int sels_cmp(const void *elt, const void *key, size_t size)
 {
   const sels_t *c1 = elt;
   const sels_t *c2 = key;
+  (void) size;
 
   return c1->sel != c2->sel;
 }
@@ -188,6 +186,7 @@ static int call_cmp(const void *elt, const void *key, size_t size)
 {
   const call_access_t *c1 = elt;
   const call_access_t *c2 = key;
+  (void) size;
 
   return c1->call != c2->call;
 }
@@ -201,6 +200,7 @@ static int path_cmp(const void *elt, const void *key, size_t size)
 {
   const path_t *p1 = elt;
   const path_t *p2 = key;
+  (void) size;
 
   /* we can use memcmp here, because identical tarvals should have identical addresses */
   return memcmp(p1->path, p2->path, p1->path_len * sizeof(p1->path[0]));
@@ -231,7 +231,7 @@ static int is_const_sel(ir_node *sel) {
   for (i = 0; i < n; ++i) {
     ir_node *idx = get_Sel_index(sel, i);
 
-    if (get_irn_op(idx) != op_Const)
+    if (!is_Const(idx))
       return 0;
   }
   return 1;
@@ -241,7 +241,7 @@ static int is_const_sel(ir_node *sel) {
  * Returns non-zero, if the address of an entity
  * represented by a Sel node (or it's successor Sels) is taken.
  */
-static int is_address_taken(ir_node *sel)
+static int is_address_taken_2(ir_node *sel)
 {
   int i;
 
@@ -264,7 +264,7 @@ static int is_address_taken(ir_node *sel)
 
     case iro_Sel: {
       /* Check the Sel successor of Sel */
-      int res = is_address_taken(succ);
+      int res = is_address_taken_2(succ);
 
       if (res)
         return 1;
@@ -300,16 +300,15 @@ static void link_all_leave_sels(ir_entity *ent, ir_node *sel)
   for (i = 0; i < n; ++i) {
     ir_node *succ = get_irn_out(sel, i);
 
-    if (get_irn_op(succ) == op_Sel)
+    if (is_Sel(succ))
       link_all_leave_sels(ent, succ);
-
   }
 
    /* if Sel nodes with memory inputs are used, a entity can be
     * visited more than once causing a ring here, so we use the
     * node flag to mark linked nodes
     */
-   if (irn_visited(sel))
+   if (irn_visited_else_mark(sel))
     return;
 
   /*
@@ -317,8 +316,6 @@ static void link_all_leave_sels(ir_entity *ent, ir_node *sel)
    */
   set_irn_link(sel, get_entity_link(ent));
   set_entity_link(ent, sel);
-
-  mark_irn_visited(sel);
 }
 
 /* we need a special address that serves as an address taken marker */
@@ -359,7 +356,7 @@ static int find_possible_replacements(ir_graph *irg)
   for (i = 0; i < n; ++i) {
     ir_node *succ = get_irn_out(irg_frame, i);
 
-    if (get_irn_op(succ) == op_Sel) {
+    if (is_Sel(succ)) {
       ir_entity *ent = get_Sel_entity(succ);
       set_entity_link(ent, NULL);
     }
@@ -373,7 +370,7 @@ static int find_possible_replacements(ir_graph *irg)
   for (i = 0; i < n; ++i) {
     ir_node *succ = get_irn_out(irg_frame, i);
 
-    if (get_irn_op(succ) == op_Sel) {
+    if (is_Sel(succ)) {
       ir_entity *ent = get_Sel_entity(succ);
       ir_type *ent_type;
 
@@ -395,7 +392,7 @@ static int find_possible_replacements(ir_graph *irg)
 
       /* we can handle arrays, structs and atomic types yet */
       if (is_Array_type(ent_type) || is_Struct_type(ent_type) || is_atomic_type(ent_type)) {
-        if (is_address_taken(succ)) {
+        if (is_address_taken_2(succ)) {
           if (get_entity_link(ent)) /* killing one */
             --res;
           set_entity_link(ent, ADDRESS_TAKEN);
@@ -419,7 +416,7 @@ static int is_leave_sel(ir_node *sel) {
 
   for(i = get_irn_n_outs(sel) - 1; i >= 0; i--) {
     succ = get_irn_out(sel, i);
-    if(get_irn_op(succ) == op_Sel)
+    if (is_Sel(succ))
       return 0;
   }
 
@@ -442,10 +439,9 @@ static path_t *find_path(ir_node *sel, unsigned len)
   n    = get_Sel_n_indexs(sel);
   len += n + 1;
 
-  if (get_irn_op(pred) != op_Sel) {
+  if (!is_Sel(pred)) {
     /* we found the root */
-
-    res = xmalloc(sizeof(*res) + (len - 1) * sizeof(res->path));
+    res = XMALLOCF(path_t, path, len);
     res->path_len = len;
   }
   else
@@ -457,7 +453,7 @@ static path_t *find_path(ir_node *sel, unsigned len)
   for (i = 0; i < n; ++i) {
     ir_node *index = get_Sel_index(sel, i);
 
-    if(get_irn_op(index) == op_Const)
+    if (is_Const(index))
       res->path[pos++].tv = get_Const_tarval(index);
   }
   return res;
@@ -656,7 +652,7 @@ static void sync_stored_scalars(ir_node *blk, env_t *env) {
 	/* We must check this, why it is possible to get a Bad node
 	 * form new_r_Sync(), when the node can be optimized.
 	 * In this case we must do nothing.*/
-	if(get_irn_op(sync) == op_Sync)  {
+	if (is_Sync(sync))  {
 	  val_arr[env->gl_mem_vnum].mem_edge_state = sync;
 	  /* We add this sync node to the sync's fix list.*/
 	  add_sync_to_fixlist(val_arr[env->gl_mem_vnum].mem_edge_state, unk_vnum, env);
@@ -804,9 +800,6 @@ static void split_call_mem_edge(env_t *env, ir_node *call, pset *accessed_entiti
   int                     *accessed_leaves_vnum = NULL; /**< An arraw, where are saved the value number, that
                                                              are synced from call's sync node, if we need it.*/
 
-  if(get_irn_node_nr(call) == 2763)
-    printf("\nHi\n");
-
   call_blk = get_nodes_block(call);
   val_arr  = get_irn_link(call_blk);
   /* An array to save the memory edges, that must be
@@ -886,8 +879,7 @@ static void split_call_mem_edge(env_t *env, ir_node *call, pset *accessed_entiti
       /* We must check this, why it is possible to get a Bad node
        * form new_r_Sync(), when the node can be optimized.
        * In this case we must do nothing.*/
-      if(get_irn_op(sync) == op_Sync) {
-
+      if (is_Sync(sync)) {
 	set_Call_mem(call, sync);
 	if(ARR_LEN(accessed_leaves_vnum))
 	  /* We add this sync node to the sync's fix list.*/
@@ -922,7 +914,7 @@ static void split_memory_edge(ir_node *irn, void *ctx) {
    else
      irn_blk = get_nodes_block(irn);
 
-   if (Block_not_block_visited(irn_blk)) {
+   if (!Block_block_visited(irn_blk)) {
     /* We sync first the stored scalar address in this block.*/
     mark_Block_block_visited(irn_blk);
     sync_stored_scalars(irn_blk, env);
@@ -944,7 +936,7 @@ static void split_memory_edge(ir_node *irn, void *ctx) {
 
 	  /* Calls that have a NoMem input do neither read nor write memory.
 	     We can completely ignore them here. */
-	  if (get_irn_op(get_Call_mem(irn)) == op_NoMem)
+	  if (is_NoMem(get_Call_mem(irn)))
 	    return;
 
           /* We save in this set all entities,
@@ -956,7 +948,7 @@ static void split_memory_edge(ir_node *irn, void *ctx) {
 
             sel = get_Call_param(irn, i);
 	    value_sels = NULL;
-            if(get_irn_op(sel) == op_Sel) {
+            if (is_Sel(sel)) {
               key_sels.sel = sel;
               value_sels   = set_find(env->set_sels, &key_sels, sizeof(key_sels), HASH_PTR(key_sels.sel));
 
@@ -989,7 +981,7 @@ static ir_node *find_vnum_value(ir_node *block, unsigned vnum)
   int               i;
   ir_node           *res;
 
-  if (Block_not_block_visited(block)) {
+  if (!Block_block_visited(block)) {
     mark_Block_block_visited(block);
 
     val_arr = get_irn_link(block);
@@ -1101,7 +1093,7 @@ static void fix_syncs(env_t *env)
     pred  = get_nodes_block(pred);
 
     /* 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) {
+    if (is_Unknown(get_irn_n(sync, 0))) {
       inc_irg_block_visited(current_ir_graph);
       val = find_vnum_value(pred, env->gl_mem_vnum);
 
@@ -1113,7 +1105,7 @@ static void fix_syncs(env_t *env)
       /* We repair the leaves*/
 
       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) {
+      if (is_Unknown(get_irn_n(sync, i))) {
         inc_irg_block_visited(current_ir_graph);
         val = find_vnum_value(pred, l->accessed_vnum[k++]);
 
@@ -1147,7 +1139,7 @@ static void sync_mem_edges(env_t *env) {
       vnum_state++;
 
   /* We allocate the memory, that we need for the predecessors of the sync.*/
-  in     = xmalloc(sizeof(ir_node*) *vnum_state);
+  in = XMALLOCN(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) {
@@ -1219,7 +1211,6 @@ static void analyse_calls(ir_node *irn, void *ctx) {
   int                 i, vnum;
   unsigned int        acces_type;
   ir_node             *param, *call_ptr, *blk;
-  ir_op               *op;
   ir_entity           *meth_ent;
   sels_t              key_sels, *value_sels;
   call_access_t       key_call, *value_call;
@@ -1227,18 +1218,18 @@ static void analyse_calls(ir_node *irn, void *ctx) {
   env_t               *env;
 
   env = ctx;
-  if(get_irn_op(irn) != op_Call)
+  if (!is_Call(irn))
     return;
 
   /* Calls that have a NoMem input do neither read nor write memory.
      We can completely ignore them here. */
-  if (get_irn_op(get_Call_mem(irn)) == op_NoMem)
+  if (is_NoMem(get_Call_mem(irn)))
     return;
 
   /* We iterate over the parameters of this call nodes.*/
   for ( i = get_Call_n_params(irn) - 1; i >= 0; i--) {
     param = get_Call_param(irn, i);
-    if(get_irn_op(param) == op_Sel) {
+    if (is_Sel(param)) {
       /* We have found a parameter with operation sel.*/
       key_sels.sel = param;
       value_sels   = set_find(env->set_sels, &key_sels, sizeof(key_sels), HASH_PTR(key_sels.sel));
@@ -1246,9 +1237,8 @@ static void analyse_calls(ir_node *irn, void *ctx) {
 
         /* We have found a call, that have as parameter a sel from our set_sels.*/
         call_ptr = get_Call_ptr(irn);
-        op = get_irn_op(call_ptr);
 
-        if(op == op_SymConst && get_SymConst_kind(call_ptr) == symconst_addr_ent) {
+        if (is_SymConst(call_ptr) && get_SymConst_kind(call_ptr) == symconst_addr_ent) {
           meth_ent = get_SymConst_entity(call_ptr);
 	  /* we get the access type for our sel.*/
 	  acces_type = get_method_param_access(meth_ent, i);
@@ -1500,13 +1490,13 @@ void data_flow_scalar_replacement_opt(ir_graph *irg) {
   remove_critical_cf_edges(irg);
 
   /* Call algorithm that computes the out edges.*/
-  if (get_irg_outs_state(irg) != outs_consistent)
-    compute_irg_outs(irg);
+  assure_irg_outs(irg);
 
   /* Call algorithm that computes the loop information.*/
-  compute_loop_info(irg);
+  construct_cf_backedges(irg);
+
   /* Call algorithm that computes the dominance information.*/
-  compute_doms(irg);
+  assure_doms(irg);
 
   /* Find possible scalar replacements */
   if (find_possible_replacements(irg)) {
@@ -1517,7 +1507,7 @@ void data_flow_scalar_replacement_opt(ir_graph *irg) {
     for (i = 0 ; i < get_irn_n_outs(irg_frame); i++) {
       ir_node *succ = get_irn_out(irg_frame, i);
 
-      if (get_irn_op(succ) == op_Sel) {
+      if (is_Sel(succ)) {
         ir_entity *ent = get_Sel_entity(succ);
 
         if (get_entity_link(ent) == NULL || get_entity_link(ent) == ADDRESS_TAKEN)
@@ -1532,9 +1522,6 @@ void data_flow_scalar_replacement_opt(ir_graph *irg) {
       }
     }
 
-    if(get_firm_verbosity())
-      printf("vnumber in data flow= %i\n", vnum);
-
     /* Allocate value number for the globule memory edge.
      * and a value number for the value numbers state.*/
     vnum = vnum + 2;