X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Fentity.c;h=6000f3999a30faa5f322d0cdeea968cb4c91b1a0;hb=e70c22e8aa4cc93e7d72f58453c03cb9bd797e31;hp=cdf598096423e5d284b161a6148355f6ba3b7426;hpb=20c028dc2eefd23898ecff42a8fdf9e1eef7c90b;p=libfirm

diff --git a/ir/tr/entity.c b/ir/tr/entity.c
index cdf598096..6000f3999 100644
--- a/ir/tr/entity.c
+++ b/ir/tr/entity.c
@@ -28,6 +28,8 @@
 # include "mangle.h"
 # include "typegmod.h"
 # include "array.h"
+# include "irtools.h"
+# include "irhooks.h"
 
 /* All this is needed to build the constant node for methods: */
 # include "irprog_t.h"
@@ -55,7 +57,7 @@ entity *get_unknown_entity(void) { return unknown_entity; }
 /*-----------------------------------------------------------------*/
 
 static INLINE void insert_entity_in_owner (entity *ent) {
-  type *owner = ent->owner;
+  ir_type *owner = ent->owner;
   switch (get_type_tpop_code(owner)) {
   case tpo_class: {
     add_class_member (owner, ent);
@@ -84,7 +86,7 @@ static INLINE void insert_entity_in_owner (entity *ent) {
  * @return the new created entity
  */
 static INLINE entity *
-new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
+new_rd_entity (dbg_info *db, ir_type *owner, ident *name, ir_type *type)
 {
   entity *res;
   ir_graph *rem;
@@ -105,17 +107,25 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
   else
     res->allocation = allocation_automatic;
 
-  res->visibility = visibility_local;
+  res->visibility  = visibility_local;
+  res->volatility  = volatility_non_volatile;
+  res->stickyness  = stickyness_unsticky;
+  res->offset      = -1;
+  res->peculiarity = peculiarity_existent;
+  res->link        = NULL;
+
 
   if (is_Method_type(type)) {
     symconst_symbol sym;
-    sym.entity_p = res;
-    res->variability = variability_constant;
-    rem              = current_ir_graph;
-    current_ir_graph = get_const_code_irg();
-    res->value       = new_SymConst(sym, symconst_addr_ent);
-    current_ir_graph = rem;
-    res->irg_add_properties = 0;
+    sym.entity_p            = res;
+    rem                     = current_ir_graph;
+    current_ir_graph        = get_const_code_irg();
+    res->value              = new_SymConst(sym, symconst_addr_ent);
+    current_ir_graph        = rem;
+    res->variability        = variability_constant;
+    res->irg_add_properties = mtp_property_inherited;
+    res->param_access       = NULL;
+    res->param_weight       = NULL;
   }
   else {
     res->variability = variability_uninitialized;
@@ -124,12 +134,6 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
     res->val_paths   = NULL;
   }
 
-  res->volatility    = volatility_non_volatile;
-  res->stickyness    = stickyness_unsticky;
-  res->offset        = -1;
-  res->link          = NULL;
-  res->peculiarity   = peculiarity_existent;
-
   if (is_Class_type(owner)) {
     res->overwrites    = NEW_ARR_F(entity *, 0);
     res->overwrittenby = NEW_ARR_F(entity *, 0);
@@ -150,7 +154,7 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
 }
 
 entity *
-new_d_entity (type *owner, ident *name, type *type, dbg_info *db) {
+new_d_entity (ir_type *owner, ident *name, ir_type *type, dbg_info *db) {
   entity *res;
 
   assert_legal_owner_of_ent(owner);
@@ -158,11 +162,12 @@ new_d_entity (type *owner, ident *name, type *type, dbg_info *db) {
   /* Remember entity in it's owner. */
   insert_entity_in_owner (res);
 
+  hook_new_entity(res);
   return res;
 }
 
 entity *
-new_entity (type *owner, ident *name, type *type) {
+new_entity (ir_type *owner, ident *name, ir_type *type) {
   return new_d_entity(owner, name, type, NULL);
 }
 
@@ -189,10 +194,19 @@ static void free_entity_attrs(entity *ent) {
   }
   ent->val_paths = NULL;
   ent->values = NULL;
+
+  if (ent->param_access) {
+    DEL_ARR_F(ent->param_access);
+    ent->param_access = NULL;
+  }
+  if (ent->param_weight) {
+    DEL_ARR_F(ent->param_weight);
+    ent->param_weight = NULL;
+  }
 }
 
 entity *
-copy_entity_own (entity *old, type *new_owner) {
+copy_entity_own (entity *old, ir_type *new_owner) {
   entity *newe;
   assert(old && old->kind == k_entity);
   assert_legal_owner_of_ent(new_owner);
@@ -253,7 +267,7 @@ get_entity_nr(entity *ent) {
 #ifdef DEBUG_libfirm
   return ent->nr;
 #else
-  return 0;
+  return (long)PTR_TO_INT(ent);
 #endif
 }
 
@@ -267,25 +281,20 @@ ident *
   return get_entity_ident(ent);
 }
 
-/*
-void   set_entitye_ld_name  (entity *, char *ld_name);
-void   set_entity_ld_ident (entity *, ident *ld_ident);
-*/
-
-type *
+ir_type *
 (get_entity_owner)(entity *ent) {
   return _get_entity_owner(ent);
 }
 
 void
-set_entity_owner (entity *ent, type *owner) {
+set_entity_owner (entity *ent, ir_type *owner) {
   assert(ent && ent->kind == k_entity);
   assert_legal_owner_of_ent(owner);
   ent->owner = owner;
 }
 
 void   /* should this go into type.c? */
-assert_legal_owner_of_ent(type *owner) {
+assert_legal_owner_of_ent(ir_type *owner) {
   assert(get_type_tpop_code(owner) == tpo_class ||
           get_type_tpop_code(owner) == tpo_union ||
           get_type_tpop_code(owner) == tpo_struct ||
@@ -308,13 +317,13 @@ const char *
   return _get_entity_ld_name(ent);
 }
 
-type *
+ir_type *
 (get_entity_type)(entity *ent) {
   return _get_entity_type(ent);
 }
 
 void
-(set_entity_type)(entity *ent, type *type) {
+(set_entity_type)(entity *ent, ir_type *type) {
   _set_entity_type(ent, type);
 }
 
@@ -386,7 +395,7 @@ set_entity_variability (entity *ent, ent_variability var)
 
   if ((is_compound_type(ent->type)) &&
       (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
-    /* Allocate datastructures for constant values */
+    /* Allocate data structures for constant values */
     ent->values    = NEW_ARR_F(ir_node *, 0);
     ent->val_paths = NEW_ARR_F(compound_graph_path *, 0);
   }
@@ -398,7 +407,7 @@ set_entity_variability (entity *ent, ent_variability var)
 
   if ((is_compound_type(ent->type)) &&
       (var == variability_uninitialized) && (ent->variability != variability_uninitialized)) {
-    /* Free datastructures for constant values */
+    /* Free data structures for constant values */
     DEL_ARR_F(ent->values);    ent->values    = NULL;
     DEL_ARR_F(ent->val_paths); ent->val_paths = NULL;
   }
@@ -509,19 +518,21 @@ int is_irn_const_expression(ir_node *n) {
   case iro_Const:
   case iro_SymConst:
   case iro_Unknown:
-    return true; break;
+    return 1;
   case iro_Conv:
   case iro_Cast:
     return is_irn_const_expression(get_irn_n(n, 0));
   default:
-    return false;
     break;
   }
-  return false;
+  return 0;
 }
 
-
-ir_node *copy_const_value(ir_node *n) {
+/*
+ * Copies a firm subgraph that complies to the restrictions for
+ * constant expressions to current_block in current_ir_graph.
+ */
+ir_node *copy_const_value(dbg_info *dbg, ir_node *n) {
   ir_node *nn;
   ir_mode *m;
 
@@ -529,40 +540,38 @@ ir_node *copy_const_value(ir_node *n) {
      dead node elimination/inlineing. */
 
   m = get_irn_mode(n);
-  switch(get_irn_opcode(n)) {
+  switch (get_irn_opcode(n)) {
   case iro_Const:
-    nn = new_Const(m, get_Const_tarval(n));     set_Const_type(nn, get_Const_type(n));
-    //nn = new_rd_Const_type(get_irn_dbg_info(n), current_ir_graph, get_cur_block(),
-    //		   m,  get_Const_tarval(n), get_Const_type(n));
+    nn = new_d_Const_type(dbg, m, get_Const_tarval(n), get_Const_type(n));
     break;
   case iro_SymConst:
-    nn = new_d_SymConst_type(NULL, get_SymConst_symbol(n), get_SymConst_kind(n),
+    nn = new_d_SymConst_type(dbg, get_SymConst_symbol(n), get_SymConst_kind(n),
 			     get_SymConst_value_type(n));
     break;
   case iro_Add:
-    nn = new_Add(copy_const_value(get_Add_left(n)),
-		 copy_const_value(get_Add_right(n)), m); break;
+    nn = new_d_Add(dbg, copy_const_value(dbg, get_Add_left(n)),
+		 copy_const_value(dbg, get_Add_right(n)), m); break;
   case iro_Sub:
-    nn = new_Sub(copy_const_value(get_Sub_left(n)),
-		 copy_const_value(get_Sub_right(n)), m); break;
+    nn = new_d_Sub(dbg, copy_const_value(dbg, get_Sub_left(n)),
+		 copy_const_value(dbg, get_Sub_right(n)), m); break;
   case iro_Mul:
-    nn = new_Mul(copy_const_value(get_Mul_left(n)),
-		 copy_const_value(get_Mul_right(n)), m); break;
+    nn = new_d_Mul(dbg, copy_const_value(dbg, get_Mul_left(n)),
+		 copy_const_value(dbg, get_Mul_right(n)), m); break;
   case iro_And:
-    nn = new_And(copy_const_value(get_And_left(n)),
-		 copy_const_value(get_And_right(n)), m); break;
+    nn = new_d_And(dbg, copy_const_value(dbg, get_And_left(n)),
+		 copy_const_value(dbg, get_And_right(n)), m); break;
   case iro_Or:
-    nn = new_Or(copy_const_value(get_Or_left(n)),
-		copy_const_value(get_Or_right(n)), m); break;
+    nn = new_d_Or(dbg, copy_const_value(dbg, get_Or_left(n)),
+		copy_const_value(dbg, get_Or_right(n)), m); break;
   case iro_Eor:
-    nn = new_Eor(copy_const_value(get_Eor_left(n)),
-		 copy_const_value(get_Eor_right(n)), m); break;
+    nn = new_d_Eor(dbg, copy_const_value(dbg, get_Eor_left(n)),
+		 copy_const_value(dbg, get_Eor_right(n)), m); break;
   case iro_Cast:
-    nn = new_Cast(copy_const_value(get_Cast_op(n)), get_Cast_type(n)); break;
+    nn = new_d_Cast(dbg, copy_const_value(dbg, get_Cast_op(n)), get_Cast_type(n)); break;
   case iro_Conv:
-    nn = new_Conv(copy_const_value(get_Conv_op(n)), m); break;
+    nn = new_d_Conv(dbg, copy_const_value(dbg, get_Conv_op(n)), m); break;
   case iro_Unknown:
-    nn = new_Unknown(m); break;
+    nn = new_d_Unknown(m); break;
   default:
     DDMN(n);
     assert(0 && "opcode invalid or not implemented");
@@ -574,7 +583,7 @@ ir_node *copy_const_value(ir_node *n) {
 
 /* Creates a new compound graph path. */
 compound_graph_path *
-new_compound_graph_path(type *tp, int length) {
+new_compound_graph_path(ir_type *tp, int length) {
   compound_graph_path *res;
 
   assert(is_type(tp) && is_compound_type(tp));
@@ -606,21 +615,21 @@ int is_compound_graph_path(void *thing) {
 int is_proper_compound_graph_path(compound_graph_path *gr, int pos) {
   int i;
   entity *node;
-  type *owner = gr->tp;
+  ir_type *owner = gr->tp;
 
   for (i = 0; i <= pos; i++) {
     node = get_compound_graph_path_node(gr, i);
     if (node == NULL)
       /* Path not yet complete. */
-      return true;
+      return 1;
     if (get_entity_owner(node) != owner)
-      return false;
+      return 0;
     owner = get_entity_type(node);
   }
   if (pos == get_compound_graph_path_length(gr))
     if (!is_atomic_type(owner))
-      return false;
-  return true;
+      return 0;
+  return 1;
 }
 
 /* Returns the length of a graph path */
@@ -701,14 +710,14 @@ static int equal_paths(compound_graph_path *path1, int *visited_indicees, compou
   int len1 = get_compound_graph_path_length(path1);
   int len2 = get_compound_graph_path_length(path2);
 
-  if (len2 > len1) return false;
+  if (len2 > len1) return 0;
 
   for (i = 0; i < len1; i++) {
-    type   *tp;
+    ir_type *tp;
     entity *node1 = get_compound_graph_path_node(path1, i);
     entity *node2 = get_compound_graph_path_node(path2, i);
 
-    if (node1 != node2) return false;
+    if (node1 != node2) return 0;
 
     tp = get_entity_owner(node1);
     if (is_Array_type(tp)) {
@@ -720,13 +729,13 @@ static int equal_paths(compound_graph_path *path1, int *visited_indicees, compou
       low = get_array_lower_bound_int(tp, 0);
       if (low + visited_indicees[i] < get_compound_graph_path_array_index(path2, i)) {
         visited_indicees[i]++;
-        return false;
+        return 0;
       }
       else
         assert(low + visited_indicees[i] == get_compound_graph_path_array_index(path2, i));
     }
   }
-  return true;
+  return 1;
 }
 
 /* Returns the position of a value with the given path.
@@ -786,7 +795,7 @@ remove_compound_ent_value(entity *ent, entity *value_ent) {
 void
 add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
   compound_graph_path *path;
-  type *owner_tp = get_entity_owner(member);
+  ir_type *owner_tp = get_entity_owner(member);
   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
   path = new_compound_graph_path(get_entity_type(ent), 1);
   path->list[0].node = member;
@@ -851,9 +860,9 @@ void
 set_array_entity_values(entity *ent, tarval **values, int num_vals) {
   int i;
   ir_graph *rem = current_ir_graph;
-  type *arrtp = get_entity_type(ent);
+  ir_type *arrtp = get_entity_type(ent);
   ir_node *val;
-  type *elttp = get_array_element_type(arrtp);
+  ir_type *elttp = get_array_element_type(arrtp);
 
   assert(is_Array_type(arrtp));
   assert(get_array_n_dimensions(arrtp) == 1);
@@ -883,8 +892,8 @@ int  get_compound_ent_value_offset_bits(entity *ent, int pos) {
 
   for (i = 0; i < path_len; ++i) {
     entity *node = get_compound_graph_path_node(path, i);
-    type *node_tp = get_entity_type(node);
-    type *owner_tp = get_entity_owner(node);
+    ir_type *node_tp = get_entity_type(node);
+    ir_type *owner_tp = get_entity_owner(node);
     if (is_Array_type(owner_tp)) {
       int size  = get_type_size_bits(node_tp);
       int align = get_type_alignment_bits(node_tp);
@@ -909,7 +918,7 @@ int  get_compound_ent_value_offset_bytes(entity *ent, int pos) {
 }
 
 
-static void init_index(type *arr) {
+static void init_index(ir_type *arr) {
   int init;
   int dim = 0;
 
@@ -920,32 +929,32 @@ static void init_index(type *arr) {
   else
     init = get_array_upper_bound_int(arr, 0) +1;
 
-  set_entity_link(get_array_element_entity(arr), (void *)init);
+  set_entity_link(get_array_element_entity(arr), INT_TO_PTR(init));
 }
 
 
 static int get_next_index(entity *elem_ent) {
-  type *arr = get_entity_owner(elem_ent);
+  ir_type *arr = get_entity_owner(elem_ent);
   int next;
   int dim = 0;
 
   assert(get_array_n_dimensions(arr) == 1);
 
   if (has_array_lower_bound(arr, dim)) {
-    next = (int)get_entity_link(elem_ent) +1;
+    next = PTR_TO_INT(get_entity_link(elem_ent)) + 1;
     if (has_array_upper_bound(arr, dim)) {
       int upper = get_array_upper_bound_int(arr, dim);
       if (next == upper) next = get_array_lower_bound_int(arr, dim);
     }
   } else {
-    next = (int)get_entity_link(elem_ent) -1;
+    next = PTR_TO_INT(get_entity_link(elem_ent)) - 1;
     if (has_array_lower_bound(arr, dim)) {
       int upper = get_array_upper_bound_int(arr, dim);
       if (next == upper) next = get_array_upper_bound_int(arr, dim);
     }
   }
 
-  set_entity_link(elem_ent, (void *)next);
+  set_entity_link(elem_ent, INT_TO_PTR(next));
   return next;
 }
 
@@ -962,7 +971,7 @@ static int get_next_index(entity *elem_ent) {
  *  evaluate the index against the upper bound.)
  */
 void compute_compound_ent_array_indicees(entity *ent) {
-  type *tp = get_entity_type(ent);
+  ir_type *tp = get_entity_type(ent);
   int i, n_vals;
   entity *unknown_bound_entity = NULL;
 
@@ -990,7 +999,7 @@ void compute_compound_ent_array_indicees(entity *ent) {
     int j, path_len =  get_compound_graph_path_length(path);
     for (j = 0; j < path_len; ++j) {
       entity *node = get_compound_graph_path_node(path, j);
-      type *elem_tp = get_entity_type(node);
+      ir_type *elem_tp = get_entity_type(node);
 
       if (is_Array_type(elem_tp)) {
         int dim = 0;
@@ -1011,7 +1020,7 @@ void compute_compound_ent_array_indicees(entity *ent) {
     int j, path_len =  get_compound_graph_path_length(path);
     for (j = 0; j < path_len; ++j) {
       entity *node = get_compound_graph_path_node(path, j);
-      type *owner_tp = get_entity_owner(node);
+      ir_type *owner_tp = get_entity_owner(node);
       if (is_Array_type(owner_tp))
         set_compound_graph_path_array_index (path, j, get_next_index(node));
     }
@@ -1038,7 +1047,7 @@ static int *resize (int *buf, int *size) {
    A second iteration now permutes the actual elements into two
    new arrays. */
 void sort_compound_ent_values(entity *ent) {
-  type *tp;
+  ir_type *tp;
   int i, n_vals;
   int tp_size;
   int size;
@@ -1253,14 +1262,14 @@ int
 }
 
 int is_atomic_entity(entity *ent) {
-  type* t = get_entity_type(ent);
+  ir_type *t = get_entity_type(ent);
   assert(ent && ent->kind == k_entity);
   return (is_Primitive_type(t) || is_Pointer_type(t) ||
       is_Enumeration_type(t) || is_Method_type(t));
 }
 
 int is_compound_entity(entity *ent) {
-  type* t = get_entity_type(ent);
+  ir_type *t = get_entity_type(ent);
   assert(ent && ent->kind == k_entity);
   return (is_Class_type(t) || is_Struct_type(t) ||
       is_Array_type(t) || is_Union_type(t));
@@ -1268,9 +1277,9 @@ int is_compound_entity(entity *ent) {
 
 /**
  * @todo not implemented!!! */
-bool equal_entity(entity *ent1, entity *ent2) {
+int equal_entity(entity *ent1, entity *ent2) {
   fprintf(stderr, " calling unimplemented equal entity!!! \n");
-  return true;
+  return 1;
 }
 
 
@@ -1295,24 +1304,71 @@ int (entity_not_visited)(entity *ent) {
   return _entity_not_visited(ent);
 }
 
-unsigned (get_entity_additional_properties)(const entity *ent) {
-  return _get_entity_additional_properties(ent);
+/* Returns the mask of the additional entity properties. */
+unsigned get_entity_additional_properties(entity *ent) {
+  ir_graph *irg;
+
+  assert(is_Method_type(get_entity_type(ent)));
+
+  /* first check, if the graph has additional properties */
+  irg = get_entity_irg(ent);
+
+  if (irg)
+    return get_irg_additional_properties(irg);
+
+  if (ent->irg_add_properties & mtp_property_inherited)
+    return get_method_additional_properties(get_entity_type(ent));
+
+  return ent->irg_add_properties;
 }
 
-void (set_entity_additional_properties)(entity *ent, unsigned property_mask) {
-  _set_entity_additional_properties(ent, property_mask);
+/* Sets the mask of the additional graph properties. */
+void set_entity_additional_properties(entity *ent, unsigned property_mask)
+{
+  ir_graph *irg;
+
+  assert(is_Method_type(get_entity_type(ent)));
+
+  /* first check, if the graph exists */
+  irg = get_entity_irg(ent);
+  if (irg)
+    set_irg_additional_properties(irg, property_mask);
+  else {
+    /* do not allow to set the mtp_property_inherited flag or
+     * the automatic inheritance of flags will not work */
+    ent->irg_add_properties = property_mask & ~mtp_property_inherited;
+  }
 }
 
-void (set_entity_additional_property)(entity *ent, unsigned flag) {
-  _set_entity_additional_property(ent, (irg_additional_property)flag);
+/* Sets one additional graph property. */
+void set_entity_additional_property(entity *ent, mtp_additional_property flag)
+{
+  ir_graph *irg;
+
+  assert(is_Method_type(get_entity_type(ent)));
+
+  /* first check, if the graph exists */
+  irg = get_entity_irg(ent);
+  if (irg)
+    set_irg_additional_property(irg, flag);
+  else {
+    unsigned mask = ent->irg_add_properties;
+
+    if (mask & mtp_property_inherited)
+      mask = get_method_additional_properties(get_entity_type(ent));
+
+    /* do not allow to set the mtp_property_inherited flag or
+     * the automatic inheritance of flags will not work */
+    ent->irg_add_properties = mask | (flag & ~mtp_property_inherited);
+  }
 }
 
-void init_entity(void)
+void firm_init_entity(void)
 {
   symconst_symbol sym;
 
-  assert(firm_unknown_type && "Call init_type before init_entity!");
-  assert(!unknown_entity && "Call init_entity only once!");
+  assert(firm_unknown_type && "Call init_type() before firm_init_entity()!");
+  assert(!unknown_entity && "Call firm_init_entity() only once!");
   unknown_entity = new_rd_entity(NULL, firm_unknown_type, new_id_from_str(UNKNOWN_ENTITY_NAME), firm_unknown_type);
   set_entity_visibility(unknown_entity, visibility_external_allocated);
   set_entity_ld_ident(unknown_entity, get_entity_ident(unknown_entity));