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

diff --git a/ir/tr/entity.c b/ir/tr/entity.c
index c791c24cd..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"
@@ -44,35 +46,18 @@
 /** general                                                       **/
 /*******************************************************************/
 
-entity *unknown_entity = NULL; entity *get_unknown_entity(void) { return unknown_entity; }
-#define UNKNOWN_ENTITY_NAME "unknown_entity"
-
-static INLINE entity *
-new_rd_entity (dbg_info *db, type *owner, ident *name, type *type);
-
-void
-init_entity (void)
-{
-  symconst_symbol sym;
-
-  assert(firm_unknown_type && "Call init_type before init_entity!");
-  assert(!unknown_entity && "Call 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));
+entity *unknown_entity = NULL;
 
-  sym.entity_p = unknown_entity;
-  current_ir_graph = get_const_code_irg();
-  unknown_entity->value = new_SymConst(sym, symconst_addr_ent);
-}
+entity *get_unknown_entity(void) { return unknown_entity; }
 
+#define UNKNOWN_ENTITY_NAME "unknown_entity"
 
 /*-----------------------------------------------------------------*/
 /* 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);
@@ -91,10 +76,17 @@ static INLINE void insert_entity_in_owner (entity *ent) {
 }
 
 /**
- * creates a new entity
+ * Creates a new entity. This entity is NOT inserted in the owner type.
+ *
+ * @param db     debug info for this entity
+ * @param owner  the owner type of the new entity
+ * @param name   the name of the new entity
+ * @param type   the type of the new entity
+ *
+ * @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;
@@ -103,36 +95,45 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
 
   res = xmalloc(sizeof(*res));
   memset(res, 0, sizeof(*res));
-  res->kind = k_entity;
-  res->owner = owner;
-  res->name = name;
-  res->type = type;
+
+  res->kind    = k_entity;
+  res->name    = name;
+  res->ld_name = NULL;
+  res->owner   = owner;
+  res->type    = type;
 
   if (get_type_tpop(type) == type_method)
     res->allocation = allocation_static;
   else
     res->allocation = allocation_automatic;
 
-  res->visibility = visibility_local;
-  res->offset = -1;
+  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;
-  } else {
+    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;
-    res->value  = NULL;
-    res->values = NULL;
-    res->val_paths = NULL;
+    res->value       = NULL;
+    res->values      = NULL;
+    res->val_paths   = NULL;
   }
-  res->peculiarity   = peculiarity_existent;
-  res->volatility    = volatility_non_volatile;
-  res->stickyness    = stickyness_unsticky;
-  res->ld_name       = NULL;
+
   if (is_Class_type(owner)) {
     res->overwrites    = NEW_ARR_F(entity *, 0);
     res->overwrittenby = NEW_ARR_F(entity *, 0);
@@ -142,8 +143,6 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
   }
   res->irg = NULL;
 
-  //res->accesses = NULL;
-
 #ifdef DEBUG_libfirm
   res->nr = get_irp_new_node_nr();
 #endif /* DEBUG_libfirm */
@@ -155,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);
@@ -163,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);
 }
 
@@ -187,17 +187,26 @@ static void free_entity_attrs(entity *ent) {
   if (ent->val_paths) {
     if (is_compound_entity(ent))
       for (i = 0; i < get_compound_ent_n_values(ent); i++)
-    if (ent->val_paths[i]) ;
-    /* free_compound_graph_path(ent->val_paths[i]) ;  * @@@ warum nich? */
-    /* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */
-    /* DEL_ARR_F(ent->val_paths); */
+        if (ent->val_paths[i]) ;
+        /* free_compound_graph_path(ent->val_paths[i]) ;  * @@@ warum nich? */
+        /* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */
+        /* DEL_ARR_F(ent->val_paths); */
   }
   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);
@@ -258,7 +267,7 @@ get_entity_nr(entity *ent) {
 #ifdef DEBUG_libfirm
   return ent->nr;
 #else
-  return 0;
+  return (long)PTR_TO_INT(ent);
 #endif
 }
 
@@ -272,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 ||
@@ -313,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);
 }
 
@@ -391,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);
   }
@@ -403,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;
   }
@@ -514,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;
 
@@ -534,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");
@@ -577,57 +581,59 @@ ir_node *copy_const_value(ir_node *n) {
   return nn;
 }
 
+/* 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));
   assert(length > 0);
 
-  res = xmalloc(sizeof(*res) + (length-1) * sizeof(res->nodes[0]));
-  memset(res, 0, sizeof(*res) + (length-1) * sizeof(res->nodes[0]));
+  res = xmalloc(sizeof(*res) + (length-1) * sizeof(res->list[0]));
+  memset(res, 0, sizeof(*res) + (length-1) * sizeof(res->list[0]));
   res->kind         = k_ir_compound_graph_path;
   res->tp           = tp;
   res->len          = length;
-  res->arr_indicees = xcalloc(length, sizeof(res ->arr_indicees[0]));
 
   return res;
 }
 
-void
-free_compound_graph_path (compound_graph_path *gr) {
+/* Frees an graph path object */
+void free_compound_graph_path (compound_graph_path *gr) {
   assert(gr && is_compound_graph_path(gr));
   gr->kind = k_BAD;
-  free(gr ->arr_indicees);
   free(gr);
 }
 
-int
-is_compound_graph_path(void *thing) {
+/* Returns non-zero if an object is a compound graph path */
+int is_compound_graph_path(void *thing) {
   return (get_kind(thing) == k_ir_compound_graph_path);
 }
 
-/* checks whether nodes 0..pos are correct (all lie on a path.) */
-/* @@@ not implemented */
+/* Checks whether the path up to pos is correct. If the path contains a NULL,
+ *  assumes the path is not complete and returns 'true'. */
 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;
-    if (get_entity_owner(node) != owner) return false;
+      return 1;
+    if (get_entity_owner(node) != owner)
+      return 0;
     owner = get_entity_type(node);
   }
   if (pos == get_compound_graph_path_length(gr))
-    if (!is_atomic_type(owner)) return false;
-  return true;
+    if (!is_atomic_type(owner))
+      return 0;
+  return 1;
 }
 
-int
-get_compound_graph_path_length(compound_graph_path *gr) {
+/* Returns the length of a graph path */
+int get_compound_graph_path_length(compound_graph_path *gr) {
   assert(gr && is_compound_graph_path(gr));
   return gr->len;
 }
@@ -636,7 +642,7 @@ entity *
 get_compound_graph_path_node(compound_graph_path *gr, int pos) {
   assert(gr && is_compound_graph_path(gr));
   assert(pos >= 0 && pos < gr->len);
-  return gr->nodes[pos];
+  return gr->list[pos].node;
 }
 
 void
@@ -644,7 +650,7 @@ set_compound_graph_path_node(compound_graph_path *gr, int pos, entity *node) {
   assert(gr && is_compound_graph_path(gr));
   assert(pos >= 0 && pos < gr->len);
   assert(is_entity(node));
-  gr->nodes[pos] = node;
+  gr->list[pos].node = node;
   assert(is_proper_compound_graph_path(gr, pos));
 }
 
@@ -652,14 +658,14 @@ int
 get_compound_graph_path_array_index(compound_graph_path *gr, int pos) {
   assert(gr && is_compound_graph_path(gr));
   assert(pos >= 0 && pos < gr->len);
-  return gr->arr_indicees[pos];
+  return gr->list[pos].index;
 }
 
 void
 set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index) {
   assert(gr && is_compound_graph_path(gr));
   assert(pos >= 0 && pos < gr->len);
-  gr->arr_indicees[pos] = index;
+  gr->list[pos].index = index;
 }
 
 /* A value of a compound entity is a pair of value and the corresponding path to a member of
@@ -704,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)) {
@@ -723,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.
@@ -774,10 +780,10 @@ remove_compound_ent_value(entity *ent, entity *value_ent) {
   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
   for (i = 0; i < (ARR_LEN (ent->val_paths)); i++) {
     compound_graph_path *path = ent->val_paths[i];
-    if (path->nodes[path->len-1] == value_ent) {
+    if (path->list[path->len-1].node == value_ent) {
       for(; i < (ARR_LEN (ent->val_paths))-1; i++) {
         ent->val_paths[i] = ent->val_paths[i+1];
-        ent->values[i]   = ent->values[i+1];
+        ent->values[i]    = ent->values[i+1];
       }
       ARR_SETLEN(entity*,  ent->val_paths, ARR_LEN(ent->val_paths) - 1);
       ARR_SETLEN(ir_node*, ent->values,    ARR_LEN(ent->values)    - 1);
@@ -789,10 +795,10 @@ 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(ent);
+  ir_type *owner_tp = get_entity_owner(member);
   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
-  path = new_compound_graph_path(owner_tp, 1);
-  path->nodes[0] = member;
+  path = new_compound_graph_path(get_entity_type(ent), 1);
+  path->list[0].node = member;
   if (is_Array_type(owner_tp)) {
     int max;
     int i;
@@ -805,7 +811,7 @@ add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
         max = index;
       }
     }
-    path->arr_indicees[0] = max + 1;
+    path->list[0].index = max + 1;
   }
   add_compound_ent_value_w_path(ent, val, path);
 }
@@ -854,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);
@@ -886,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);
@@ -912,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;
 
@@ -923,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;
 }
 
@@ -965,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;
 
@@ -993,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;
@@ -1014,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));
     }
@@ -1041,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;
@@ -1256,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));
@@ -1271,33 +1277,103 @@ 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;
 }
 
 
-unsigned long get_entity_visited(entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return ent->visit;
+unsigned long (get_entity_visited)(entity *ent) {
+  return _get_entity_visited(ent);
 }
-void        set_entity_visited(entity *ent, unsigned long num) {
-  assert(ent && ent->kind == k_entity);
-  ent->visit = num;
+
+void (set_entity_visited)(entity *ent, unsigned long num) {
+  _set_entity_visited(ent, num);
 }
+
 /* Sets visited field in entity to entity_visited. */
-void        mark_entity_visited(entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  ent->visit = type_visited;
+void (mark_entity_visited)(entity *ent) {
+  _mark_entity_visited(ent);
 }
 
+int (entity_visited)(entity *ent) {
+  return _entity_visited(ent);
+}
 
-bool entity_visited(entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return get_entity_visited(ent) >= type_visited;
+int (entity_not_visited)(entity *ent) {
+  return _entity_not_visited(ent);
 }
 
-bool entity_not_visited(entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return get_entity_visited(ent) < type_visited;
+/* 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;
+}
+
+/* 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;
+  }
+}
+
+/* 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 firm_init_entity(void)
+{
+  symconst_symbol sym;
+
+  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));
+
+  sym.entity_p = unknown_entity;
+  current_ir_graph = get_const_code_irg();
+  unknown_entity->value = new_SymConst(sym, symconst_addr_ent);
 }