X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Fentity.c;h=59e4043093a52e6856698c228460da4ca8d17d02;hb=695676572c14ef6620122147115c0e09d068cd95;hp=9a11278fb4e274acacc7884794e4f66126c94f9b;hpb=9f1d937fd2a1fd163618ee9c19eadc20dacabe98;p=libfirm

diff --git a/ir/tr/entity.c b/ir/tr/entity.c
index 9a11278fb..59e404309 100644
--- a/ir/tr/entity.c
+++ b/ir/tr/entity.c
@@ -28,6 +28,7 @@
 # include "mangle.h"
 # include "typegmod.h"
 # include "array.h"
+# include "irtools.h"
 
 /* All this is needed to build the constant node for methods: */
 # include "irprog_t.h"
@@ -44,28 +45,11 @@
 /** 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                                                          */
@@ -91,7 +75,14 @@ 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)
@@ -103,10 +94,12 @@ 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;
@@ -114,25 +107,30 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
     res->allocation = allocation_automatic;
 
   res->visibility = visibility_local;
-  res->offset = -1;
+
   if (is_Method_type(type)) {
     symconst_symbol sym;
     sym.entity_p = res;
     res->variability = variability_constant;
-    rem = current_ir_graph;
+    rem              = current_ir_graph;
     current_ir_graph = get_const_code_irg();
-    res->value = new_SymConst(sym, symconst_addr_ent);
+    res->value       = new_SymConst(sym, symconst_addr_ent);
     current_ir_graph = rem;
-  } else {
+    res->irg_add_properties = 0;
+  }
+  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;
+  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);
@@ -142,8 +140,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 */
@@ -187,10 +183,10 @@ 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;
@@ -264,7 +260,7 @@ get_entity_nr(entity *ent) {
 
 const char *
 (get_entity_name)(const entity *ent) {
-  return __get_entity_name(ent);
+  return _get_entity_name(ent);
 }
 
 ident *
@@ -279,7 +275,7 @@ void   set_entity_ld_ident (entity *, ident *ld_ident);
 
 type *
 (get_entity_owner)(entity *ent) {
-  return __get_entity_owner(ent);
+  return _get_entity_owner(ent);
 }
 
 void
@@ -300,37 +296,37 @@ assert_legal_owner_of_ent(type *owner) {
 
 ident *
 (get_entity_ld_ident)(entity *ent) {
-  return __get_entity_ld_ident(ent);
+  return _get_entity_ld_ident(ent);
 }
 
 void
 (set_entity_ld_ident)(entity *ent, ident *ld_ident) {
-   __set_entity_ld_ident(ent, ld_ident);
+   _set_entity_ld_ident(ent, ld_ident);
 }
 
 const char *
 (get_entity_ld_name)(entity *ent) {
-  return __get_entity_ld_name(ent);
+  return _get_entity_ld_name(ent);
 }
 
 type *
 (get_entity_type)(entity *ent) {
-  return __get_entity_type(ent);
+  return _get_entity_type(ent);
 }
 
 void
 (set_entity_type)(entity *ent, type *type) {
-  __set_entity_type(ent, type);
+  _set_entity_type(ent, type);
 }
 
 ent_allocation
 (get_entity_allocation)(const entity *ent) {
-  return __get_entity_allocation(ent);
+  return _get_entity_allocation(ent);
 }
 
 void
 (set_entity_allocation)(entity *ent, ent_allocation al) {
-  __set_entity_allocation(ent, al);
+  _set_entity_allocation(ent, al);
 }
 
 /* return the name of the visibility */
@@ -348,13 +344,13 @@ const char *get_allocation_name(ent_allocation all)
 }
 
 
-ent_visibility
+visibility
 (get_entity_visibility)(const entity *ent) {
-  return __get_entity_visibility(ent);
+  return _get_entity_visibility(ent);
 }
 
 void
-set_entity_visibility (entity *ent, ent_visibility vis) {
+set_entity_visibility (entity *ent, visibility vis) {
   assert(ent && ent->kind == k_entity);
   if (vis != visibility_local)
     assert((ent->allocation == allocation_static) ||
@@ -365,7 +361,7 @@ set_entity_visibility (entity *ent, ent_visibility vis) {
 }
 
 /* return the name of the visibility */
-const char *get_visibility_name(ent_visibility vis)
+const char *get_visibility_name(visibility vis)
 {
 #define X(a)    case a: return #a
   switch (vis) {
@@ -379,7 +375,7 @@ const char *get_visibility_name(ent_visibility vis)
 
 ent_variability
 (get_entity_variability)(const entity *ent) {
-  return __get_entity_variability(ent);
+  return _get_entity_variability(ent);
 }
 
 void
@@ -426,12 +422,12 @@ const char *get_variability_name(ent_variability var)
 
 ent_volatility
 (get_entity_volatility)(const entity *ent) {
-  return __get_entity_volatility(ent);
+  return _get_entity_volatility(ent);
 }
 
 void
 (set_entity_volatility)(entity *ent, ent_volatility vol) {
-  __set_entity_volatility(ent, vol);
+  _set_entity_volatility(ent, vol);
 }
 
 /* return the name of the volatility */
@@ -448,12 +444,12 @@ const char *get_volatility_name(ent_volatility var)
 
 peculiarity
 (get_entity_peculiarity)(const entity *ent) {
-  return __get_entity_peculiarity(ent);
+  return _get_entity_peculiarity(ent);
 }
 
 void
 (set_entity_peculiarity)(entity *ent, peculiarity pec) {
-  __set_entity_peculiarity(ent, pec);
+  _set_entity_peculiarity(ent, pec);
 }
 
 /* return the name of the peculiarity */
@@ -472,13 +468,13 @@ const char *get_peculiarity_name(peculiarity var)
 /* Get the entity's stickyness */
 ent_stickyness
 (get_entity_stickyness)(const entity *ent) {
-  return __get_entity_stickyness(ent);
+  return _get_entity_stickyness(ent);
 }
 
 /* Set the entity's stickyness */
 void
 (set_entity_stickyness)(entity *ent, ent_stickyness stickyness) {
-  __set_entity_stickyness(ent, stickyness);
+  _set_entity_stickyness(ent, stickyness);
 }
 
 /* Set has no effect for existent entities of type method. */
@@ -577,6 +573,7 @@ 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) {
   compound_graph_path *res;
@@ -584,50 +581,51 @@ new_compound_graph_path(type *tp, int length) {
   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;
+
   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;
+    if (get_entity_owner(node) != owner)
+      return false;
     owner = get_entity_type(node);
   }
   if (pos == get_compound_graph_path_length(gr))
-    if (!is_atomic_type(owner)) return false;
+    if (!is_atomic_type(owner))
+      return false;
   return true;
 }
 
-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 +634,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 +642,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 +650,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
@@ -696,6 +694,9 @@ get_compound_ent_value_path(entity *ent, int pos) {
   return ent->val_paths[pos];
 }
 
+/**
+ * Returns non-zero, if two compound_graph_pathes are equal
+ */
 static int equal_paths(compound_graph_path *path1, int *visited_indicees, compound_graph_path *path2) {
   int i;
   int len1 = get_compound_graph_path_length(path1);
@@ -704,20 +705,26 @@ static int equal_paths(compound_graph_path *path1, int *visited_indicees, compou
   if (len2 > len1) return false;
 
   for (i = 0; i < len1; i++) {
+    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;
-    type *tp = get_entity_owner(node1);
+
+    tp = get_entity_owner(node1);
     if (is_Array_type(tp)) {
+      long low;
+
       /* Compute the index of this node. */
       assert(get_array_n_dimensions(tp) == 1 && "multidim not implemented");
-      long 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;
-      } else {
-	assert(low+visited_indicees[i] == get_compound_graph_path_array_index(path2, i));
+
+      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;
       }
+      else
+        assert(low + visited_indicees[i] == get_compound_graph_path_array_index(path2, i));
     }
   }
   return true;
@@ -732,6 +739,22 @@ int get_compound_ent_pos_by_path(entity *ent, compound_graph_path *path) {
     if (equal_paths(get_compound_ent_value_path(ent, i), visited_indicees, path))
       return i;
   }
+
+#if 0
+  {
+    int j;
+    printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
+      printf("Entity %s : ", get_entity_name(ent));
+      for (j = 0; j < get_compound_graph_path_length(path); ++j) {
+        entity *node = get_compound_graph_path_node(path, j);
+        printf("%s", get_entity_name(node));
+        if (is_Array_type(get_entity_owner(node)))
+          printf("[%d]", get_compound_graph_path_array_index(path, j));
+      }
+    printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
+  }
+#endif
+
   assert(0 && "path not found");
   return -1;
 }
@@ -749,10 +772,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);
@@ -764,10 +787,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);
+  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;
@@ -780,7 +803,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);
 }
@@ -898,7 +921,7 @@ 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));
 }
 
 
@@ -910,20 +933,20 @@ static int get_next_index(entity *elem_ent) {
   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;
 }
 
@@ -1077,22 +1100,22 @@ void sort_compound_ent_values(entity *ent) {
 
 int
 (get_entity_offset_bytes)(const entity *ent) {
-  return __get_entity_offset_bytes(ent);
+  return _get_entity_offset_bytes(ent);
 }
 
 int
 (get_entity_offset_bits)(const entity *ent) {
-  return __get_entity_offset_bits(ent);
+  return _get_entity_offset_bits(ent);
 }
 
 void
 (set_entity_offset_bytes)(entity *ent, int offset) {
-  __set_entity_offset_bytes(ent, offset);
+  _set_entity_offset_bytes(ent, offset);
 }
 
 void
 (set_entity_offset_bits)(entity *ent, int offset) {
-  __set_entity_offset_bits(ent, offset);
+  _set_entity_offset_bits(ent, offset);
 }
 
 void
@@ -1196,17 +1219,17 @@ void    remove_entity_overwrittenby(entity *ent, entity *overwrites) {
 /* A link to store intermediate information */
 void *
 (get_entity_link)(const entity *ent) {
-  return __get_entity_link(ent);
+  return _get_entity_link(ent);
 }
 
 void
 (set_entity_link)(entity *ent, void *l) {
-  __set_entity_link(ent, l);
+  _set_entity_link(ent, l);
 }
 
 ir_graph *
 (get_entity_irg)(const entity *ent) {
-  return __get_entity_irg(ent);
+  return _get_entity_irg(ent);
 }
 
 void
@@ -1227,7 +1250,7 @@ set_entity_irg(entity *ent, ir_graph *irg) {
 
 int
 (is_entity)(const void *thing) {
-  return __is_entity(thing);
+  return _is_entity(thing);
 }
 
 int is_atomic_entity(entity *ent) {
@@ -1252,68 +1275,60 @@ bool equal_entity(entity *ent1, entity *ent2) {
 }
 
 
-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;
+unsigned (get_entity_additional_properties)(const entity *ent) {
+  return _get_entity_additional_properties(ent);
 }
 
-/* Need two routines because I want to assert the result. */
-static entity *resolve_ent_polymorphy2 (type *dynamic_class, entity *static_ent) {
-  int i, n_overwrittenby;
-  entity *res = NULL;
+void (set_entity_additional_properties)(entity *ent, unsigned property_mask) {
+  _set_entity_additional_properties(ent, property_mask);
+}
 
-  if (get_entity_owner(static_ent) == dynamic_class) return static_ent;
+void (set_entity_additional_property)(entity *ent, unsigned flag) {
+  _set_entity_additional_property(ent, (irg_additional_property)flag);
+}
 
-  n_overwrittenby = get_entity_n_overwrittenby(static_ent);
-  for (i = 0; i < n_overwrittenby; ++i) {
-    res = resolve_ent_polymorphy2(dynamic_class, get_entity_overwrittenby(static_ent, i));
-    if (res)
-      break;
-  }
+/* Returns the calling convention of an entities graph. */
+unsigned (get_entity_calling_convention)(const entity *ent) {
+  return _get_entity_calling_convention(ent);
+}
 
-  return res;
+/* Sets the calling convention of an entities graph. */
+void (set_entity_calling_convention)(entity *ent, unsigned cc_mask) {
+  _set_entity_calling_convention(ent, cc_mask);
 }
 
-/** Resolve polymorphy in the inheritance relation.
- *
- * Returns the dynamically referenced entity if the static entity and the
- * dynamic type are given.
- * Search downwards in overwritten tree. */
-entity *resolve_ent_polymorphy(type *dynamic_class, entity *static_ent) {
-  entity *res;
-  assert(static_ent && static_ent->kind == k_entity);
+void firm_init_entity(void)
+{
+  symconst_symbol sym;
 
-  res = resolve_ent_polymorphy2(dynamic_class, static_ent);
-#if DEBUG_libfirm
-  if (!res) {
-    printf(" Could not find entity "); DDME(static_ent);
-    printf("  in "); DDMT(dynamic_class);
-    printf("\n");
-    dump_entity(static_ent);
-    dump_type(get_entity_owner(static_ent));
-    dump_type(dynamic_class);
-  }
-#endif
-  assert(res);
-  return res;
+  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);
 }