X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Fanalyze_irg_args.c;h=bfed9def0b4975f0835f1d1d64300a77a70ff974;hb=d0d85962ef52c14950db90e5981a7bea36023ab3;hp=e158173dff02e210e4b3242e6bb367b67828d4cf;hpb=0cfd6be49a8ac3dcbd8391b4cc1f1cf369aa848d;p=libfirm

diff --git a/ir/ana/analyze_irg_args.c b/ir/ana/analyze_irg_args.c
index e158173df..bfed9def0 100644
--- a/ir/ana/analyze_irg_args.c
+++ b/ir/ana/analyze_irg_args.c
@@ -83,7 +83,7 @@ static unsigned analyze_arg(ir_node *arg, unsigned bits)
       }
       else {
         ir_op *op = get_irn_op(ptr);
-        entity *meth_ent;
+        ir_entity *meth_ent;
 
         if (op == op_SymConst && get_SymConst_kind(ptr) == symconst_addr_ent) {
           meth_ent = get_SymConst_entity(ptr);
@@ -182,20 +182,20 @@ static unsigned analyze_arg(ir_node *arg, unsigned bits)
  *
  * @param irg   The ir graph to analyze.
  */
-static void analyze_ent_args(entity *ent)
+static void analyze_ent_args(ir_entity *ent)
 {
   ir_graph *irg;
   ir_node *irg_args, *arg;
   ir_mode *arg_mode;
   int nparams, i;
   long proj_nr;
-  type *mtp;
+  ir_type *mtp;
   ptr_access_kind *rw_info;
 
   mtp     = get_entity_type(ent);
   nparams = get_method_n_params(mtp);
 
-  ent->param_access = NEW_ARR_F(ptr_access_kind, nparams);
+  ent->attr.mtd_attr.param_access = NEW_ARR_F(ptr_access_kind, nparams);
 
   /* If the method haven't parameters we have
    * nothing to do.
@@ -207,7 +207,7 @@ static void analyze_ent_args(entity *ent)
 
   /* we have not yet analyzed the graph, set ALL access for pointer args */
   for (i = nparams - 1; i >= 0; --i)
-    ent->param_access[i] =
+    ent->attr.mtd_attr.param_access[i] =
       is_Pointer_type(get_method_param_type(mtp, i)) ? ptr_access_all : ptr_access_none;
 
   if (! irg) {
@@ -215,9 +215,7 @@ static void analyze_ent_args(entity *ent)
     return;
   }
 
-  /* Call algorithm that computes the out edges */
-  if (get_irg_outs_state(irg) != outs_consistent)
-    compute_outs(irg);
+  assure_irg_outs(irg);
 
   irg_args = get_irg_args(irg);
 
@@ -241,22 +239,25 @@ static void analyze_ent_args(entity *ent)
   }
 
   /* copy the temporary info */
-  memcpy(ent->param_access, rw_info, nparams * sizeof(ent->param_access[0]));
+  memcpy(ent->attr.mtd_attr.param_access, rw_info,
+    nparams * sizeof(ent->attr.mtd_attr.param_access[0]));
 
+#if 0
   printf("\n%s:\n", get_entity_name(ent));
   for (i = 0; i < nparams; ++i) {
     if (is_Pointer_type(get_method_param_type(mtp, i)))
-      if (ent->param_access[i] != ptr_access_none) {
+      if (ent->attr.mtd_attr.param_access[i] != ptr_access_none) {
         printf("  Pointer Arg %d access: ", i);
-        if (ent->param_access[i] & ptr_access_read)
+        if (ent->attr.mtd_attr.param_access[i] & ptr_access_read)
           printf("READ ");
-        if (ent->param_access[i] & ptr_access_write)
+        if (ent->attr.mtd_attr.param_access[i] & ptr_access_write)
           printf("WRITE ");
-        if (ent->param_access[i] & ptr_access_store)
+        if (ent->attr.mtd_attr.param_access[i] & ptr_access_store)
           printf("STORE ");
         printf("\n");
       }
   }
+#endif
 }
 
 /**
@@ -267,7 +268,7 @@ static void analyze_ent_args(entity *ent)
  */
 void analyze_irg_args(ir_graph *irg)
 {
-  entity *ent;
+  ir_entity *ent;
 
   if (irg == get_const_code_irg())
     return;
@@ -276,7 +277,7 @@ void analyze_irg_args(ir_graph *irg)
   if (! ent)
     return;
 
-  if (! ent->param_access)
+  if (! ent->attr.mtd_attr.param_access)
     analyze_ent_args(ent);
 }
 
@@ -284,24 +285,24 @@ void analyze_irg_args(ir_graph *irg)
  * Compute for a method with pointer parameter(s)
  * if they will be read or written.
  */
-ptr_access_kind get_method_param_access(entity *ent, int pos)
+ptr_access_kind get_method_param_access(ir_entity *ent, int pos)
 {
-  type *mtp = get_entity_type(ent);
-  int  is_variadic = get_method_variadicity(mtp) == variadicity_variadic;
+  ir_type *mtp = get_entity_type(ent);
+  int    is_variadic = get_method_variadicity(mtp) == variadicity_variadic;
 
   assert(0 <= pos && (is_variadic || pos < get_method_n_params(mtp)));
 
-  if (ent->param_access) {
-    if (pos < ARR_LEN(ent->param_access))
-      return ent->param_access[pos];
+  if (ent->attr.mtd_attr.param_access) {
+    if (pos < ARR_LEN(ent->attr.mtd_attr.param_access))
+      return ent->attr.mtd_attr.param_access[pos];
     else
       return ptr_access_all;
   }
 
   analyze_ent_args(ent);
 
-  if (pos < ARR_LEN(ent->param_access))
-    return ent->param_access[pos];
+  if (pos < ARR_LEN(ent->attr.mtd_attr.param_access))
+    return ent->attr.mtd_attr.param_access[pos];
   else
     return ptr_access_all;
 }
@@ -388,9 +389,9 @@ static float calc_method_param_weight(ir_node *arg)
  *
  * @param ent  The entity of the ir_graph.
  */
-static void analyze_method_params_weight(entity *ent)
+static void analyze_method_params_weight(ir_entity *ent)
 {
-  type *mtp;
+  ir_type *mtp;
   ir_graph *irg;
   int nparams, i, proj_nr;
   ir_node *irg_args, *arg;
@@ -398,18 +399,20 @@ static void analyze_method_params_weight(entity *ent)
   mtp      = get_entity_type(ent);
   nparams  = get_method_n_params(mtp);
 
+  /* allocate a new array. currently used as 'analysed' flag */
+  ent->attr.mtd_attr.param_weight = NEW_ARR_F(float, nparams);
+
   /* If the method haven't parameters we have
    * nothing to do.
    */
   if (nparams <= 0)
     return;
 
-  ent->param_weight = NEW_ARR_F(float, nparams);
-  irg               = get_entity_irg(ent);
+  irg = get_entity_irg(ent);
 
   /* First we initialize the parameter weight with 0. */
   for (i = nparams - 1; i >= 0; i--)
-    ent->param_weight[i] = null_weight;
+    ent->attr.mtd_attr.param_weight[i] = null_weight;
 
   if (! irg) {
     /* no graph, no better info */
@@ -417,15 +420,14 @@ static void analyze_method_params_weight(entity *ent)
   }
 
   /* Call algorithm that computes the out edges */
-  if (get_irg_outs_state(irg) != outs_consistent)
-    compute_outs(irg);
+  assure_irg_outs(irg);
 
   irg_args = get_irg_args(irg);
 
   for (i = get_irn_n_outs(irg_args) - 1; i >= 0; --i) {
-    arg                          = get_irn_out(irg_args, i);
-    proj_nr                      = get_Proj_proj(arg);
-    ent->param_weight[proj_nr]  += calc_method_param_weight(arg);
+    arg     = get_irn_out(irg_args, i);
+    proj_nr = get_Proj_proj(arg);
+    ent->attr.mtd_attr.param_weight[proj_nr]  += calc_method_param_weight(arg);
   }
 
 #if 0
@@ -439,24 +441,24 @@ static void analyze_method_params_weight(entity *ent)
  * Compute for a method with pointer parameter(s)
  * if they will be read or written.
  */
-float get_method_param_weight(entity *ent, int pos)
+float get_method_param_weight(ir_entity *ent, int pos)
 {
-  type *mtp = get_entity_type(ent);
-  int  is_variadic = get_method_variadicity(mtp) == variadicity_variadic;
+  ir_type *mtp = get_entity_type(ent);
+  int     is_variadic = get_method_variadicity(mtp) == variadicity_variadic;
 
   assert(0 <= pos && (is_variadic || pos < get_method_n_params(mtp)));
 
-  if (ent->param_weight) {
-    if (pos < ARR_LEN(ent->param_weight))
-      return ent->param_weight[pos];
+  if (ent->attr.mtd_attr.param_weight) {
+    if (pos < ARR_LEN(ent->attr.mtd_attr.param_weight))
+      return ent->attr.mtd_attr.param_weight[pos];
     else
       return 0.0f;
   }
 
   analyze_method_params_weight(ent);
 
-  if (pos < ARR_LEN(ent->param_weight))
-    return ent->param_weight[pos];
+  if (pos < ARR_LEN(ent->attr.mtd_attr.param_weight))
+    return ent->attr.mtd_attr.param_weight[pos];
   else
     return 0.0f;
 }
@@ -470,12 +472,12 @@ float get_method_param_weight(entity *ent, int pos)
  */
 void analyze_irg_args_weight(ir_graph *irg)
 {
-  entity *ent;
+  ir_entity *ent;
 
   ent = get_irg_entity(irg);
   if (! ent)
     return;
 
-  if (! ent->param_weight)
+  if (! ent->attr.mtd_attr.param_weight)
     analyze_method_params_weight(ent);
 }