From: Michael Beck <beck@ipd.info.uni-karlsruhe.de>
Date: Tue, 12 Dec 2006 14:24:17 +0000 (+0000)
Subject: used the new ir_entity type
X-Git-Url: http://nsz.repo.hu/git/?a=commitdiff_plain;ds=sidebyside;h=a748501db974593cc1ddd3955c1663340c5af353;p=libfirm

used the new ir_entity type

[r8435]
---

diff --git a/ir/tr/entity.c b/ir/tr/entity.c
index 6d9d1d459..89bab5801 100644
--- a/ir/tr/entity.c
+++ b/ir/tr/entity.c
@@ -52,9 +52,9 @@
 /** general                                                       **/
 /*******************************************************************/
 
-entity *unknown_entity = NULL;
+ir_entity *unknown_entity = NULL;
 
-entity *get_unknown_entity(void) { return unknown_entity; }
+ir_entity *get_unknown_entity(void) { return unknown_entity; }
 
 #define UNKNOWN_ENTITY_NAME "unknown_entity"
 
@@ -62,7 +62,7 @@ entity *get_unknown_entity(void) { return unknown_entity; }
 /* ENTITY                                                          */
 /*-----------------------------------------------------------------*/
 
-static INLINE void insert_entity_in_owner(entity *ent) {
+static INLINE void insert_entity_in_owner(ir_entity *ent) {
   ir_type *owner = ent->owner;
   switch (get_type_tpop_code(owner)) {
   case tpo_class: {
@@ -91,10 +91,10 @@ static INLINE void insert_entity_in_owner(entity *ent) {
  *
  * @return the new created entity
  */
-static INLINE entity *
+static INLINE ir_entity *
 new_rd_entity(dbg_info *db, ir_type *owner, ident *name, ir_type *type)
 {
-  entity *res;
+  ir_entity *res;
   ir_graph *rem;
 
   assert(!id_contains_char(name, ' ') && "entity name should not contain spaces");
@@ -147,8 +147,8 @@ new_rd_entity(dbg_info *db, ir_type *owner, ident *name, ir_type *type)
   }
 
   if (is_Class_type(owner)) {
-    res->overwrites    = NEW_ARR_F(entity *, 0);
-    res->overwrittenby = NEW_ARR_F(entity *, 0);
+    res->overwrites    = NEW_ARR_F(ir_entity *, 0);
+    res->overwrittenby = NEW_ARR_F(ir_entity *, 0);
   } else {
     res->overwrites    = NULL;
     res->overwrittenby = NULL;
@@ -164,9 +164,9 @@ new_rd_entity(dbg_info *db, ir_type *owner, ident *name, ir_type *type)
   return res;
 }
 
-entity *
+ir_entity *
 new_d_entity(ir_type *owner, ident *name, ir_type *type, dbg_info *db) {
-  entity *res;
+  ir_entity *res;
 
   assert(is_compound_type(owner));
   res = new_rd_entity(db, owner, name, type);
@@ -177,7 +177,7 @@ new_d_entity(ir_type *owner, ident *name, ir_type *type, dbg_info *db) {
   return res;
 }
 
-entity *
+ir_entity *
 new_entity(ir_type *owner, ident *name, ir_type *type) {
   return new_d_entity(owner, name, type, NULL);
 }
@@ -187,7 +187,7 @@ new_entity(ir_type *owner, ident *name, ir_type *type) {
  *
  * @param ent  the entity
  */
-static void free_entity_attrs(entity *ent) {
+static void free_entity_attrs(ir_entity *ent) {
   int i;
   if (get_type_tpop(get_entity_owner(ent)) == type_class) {
     DEL_ARR_F(ent->overwrites);    ent->overwrites = NULL;
@@ -221,9 +221,9 @@ static void free_entity_attrs(entity *ent) {
   }
 }
 
-entity *
-copy_entity_own(entity *old, ir_type *new_owner) {
-  entity *newe;
+ir_entity *
+copy_entity_own(ir_entity *old, ir_type *new_owner) {
+  ir_entity *newe;
   assert(is_entity(old));
   assert(is_compound_type(new_owner));
 
@@ -232,8 +232,8 @@ copy_entity_own(entity *old, ir_type *new_owner) {
   memcpy(newe, old, sizeof(*newe));
   newe->owner = new_owner;
   if (is_Class_type(new_owner)) {
-    newe->overwrites    = NEW_ARR_F(entity *, 0);
-    newe->overwrittenby = NEW_ARR_F(entity *, 0);
+    newe->overwrites    = NEW_ARR_F(ir_entity *, 0);
+    newe->overwrittenby = NEW_ARR_F(ir_entity *, 0);
   }
 #ifdef DEBUG_libfirm
   newe->nr = get_irp_new_node_nr();
@@ -244,9 +244,9 @@ copy_entity_own(entity *old, ir_type *new_owner) {
   return newe;
 }
 
-entity *
-copy_entity_name(entity *old, ident *new_name) {
-  entity *newe;
+ir_entity *
+copy_entity_name(ir_entity *old, ident *new_name) {
+  ir_entity *newe;
   assert(old && old->kind == k_entity);
 
   if (old->name == new_name) return old;
@@ -255,8 +255,8 @@ copy_entity_name(entity *old, ident *new_name) {
   newe->name = new_name;
   newe->ld_name = NULL;
   if (is_Class_type(newe->owner)) {
-    newe->overwrites    = DUP_ARR_F(entity *, old->overwrites);
-    newe->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby);
+    newe->overwrites    = DUP_ARR_F(ir_entity *, old->overwrites);
+    newe->overwrittenby = DUP_ARR_F(ir_entity *, old->overwrittenby);
   }
 #ifdef DEBUG_libfirm
   newe->nr = get_irp_new_node_nr();
@@ -269,7 +269,7 @@ copy_entity_name(entity *old, ident *new_name) {
 
 
 void
-free_entity (entity *ent) {
+free_entity (ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   free_entity_attrs(ent);
   ent->kind = k_BAD;
@@ -278,7 +278,7 @@ free_entity (entity *ent) {
 
 /* Outputs a unique number for this node */
 long
-get_entity_nr(entity *ent) {
+get_entity_nr(ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
 #ifdef DEBUG_libfirm
   return ent->nr;
@@ -288,64 +288,64 @@ get_entity_nr(entity *ent) {
 }
 
 const char *
-(get_entity_name)(const entity *ent) {
+(get_entity_name)(const ir_entity *ent) {
   return _get_entity_name(ent);
 }
 
 ident *
-(get_entity_ident)(const entity *ent) {
+(get_entity_ident)(const ir_entity *ent) {
   return _get_entity_ident(ent);
 }
 
 void
-(set_entity_ident)(entity *ent, ident *id) {
+(set_entity_ident)(ir_entity *ent, ident *id) {
   _set_entity_ident(ent, id);
 }
 
 ir_type *
-(get_entity_owner)(entity *ent) {
+(get_entity_owner)(ir_entity *ent) {
   return _get_entity_owner(ent);
 }
 
 void
-set_entity_owner(entity *ent, ir_type *owner) {
+set_entity_owner(ir_entity *ent, ir_type *owner) {
   assert(is_entity(ent));
   assert(is_compound_type(owner));
   ent->owner = owner;
 }
 
 ident *
-(get_entity_ld_ident)(entity *ent) {
+(get_entity_ld_ident)(ir_entity *ent) {
   return _get_entity_ld_ident(ent);
 }
 
 void
-(set_entity_ld_ident)(entity *ent, ident *ld_ident) {
+(set_entity_ld_ident)(ir_entity *ent, ident *ld_ident) {
    _set_entity_ld_ident(ent, ld_ident);
 }
 
 const char *
-(get_entity_ld_name)(entity *ent) {
+(get_entity_ld_name)(ir_entity *ent) {
   return _get_entity_ld_name(ent);
 }
 
 ir_type *
-(get_entity_type)(entity *ent) {
+(get_entity_type)(ir_entity *ent) {
   return _get_entity_type(ent);
 }
 
 void
-(set_entity_type)(entity *ent, ir_type *type) {
+(set_entity_type)(ir_entity *ent, ir_type *type) {
   _set_entity_type(ent, type);
 }
 
 ir_allocation
-(get_entity_allocation)(const entity *ent) {
+(get_entity_allocation)(const ir_entity *ent) {
   return _get_entity_allocation(ent);
 }
 
 void
-(set_entity_allocation)(entity *ent, ir_allocation al) {
+(set_entity_allocation)(ir_entity *ent, ir_allocation al) {
   _set_entity_allocation(ent, al);
 }
 
@@ -365,12 +365,12 @@ const char *get_allocation_name(ir_allocation all)
 
 
 ir_visibility
-(get_entity_visibility)(const entity *ent) {
+(get_entity_visibility)(const ir_entity *ent) {
   return _get_entity_visibility(ent);
 }
 
 void
-set_entity_visibility(entity *ent, ir_visibility vis) {
+set_entity_visibility(ir_entity *ent, ir_visibility vis) {
   assert(ent && ent->kind == k_entity);
   if (vis != visibility_local)
     assert((ent->allocation == allocation_static) ||
@@ -394,12 +394,12 @@ const char *get_visibility_name(ir_visibility vis)
 }
 
 ir_variability
-(get_entity_variability)(const entity *ent) {
+(get_entity_variability)(const ir_entity *ent) {
   return _get_entity_variability(ent);
 }
 
 void
-set_entity_variability (entity *ent, ir_variability var)
+set_entity_variability (ir_entity *ent, ir_variability var)
 {
   assert(ent && ent->kind == k_entity);
   if (var == variability_part_constant)
@@ -441,12 +441,12 @@ const char *get_variability_name(ir_variability var)
 }
 
 ir_volatility
-(get_entity_volatility)(const entity *ent) {
+(get_entity_volatility)(const ir_entity *ent) {
   return _get_entity_volatility(ent);
 }
 
 void
-(set_entity_volatility)(entity *ent, ir_volatility vol) {
+(set_entity_volatility)(ir_entity *ent, ir_volatility vol) {
   _set_entity_volatility(ent, vol);
 }
 
@@ -463,52 +463,52 @@ const char *get_volatility_name(ir_volatility var)
 }
 
 ir_peculiarity
-(get_entity_peculiarity)(const entity *ent) {
+(get_entity_peculiarity)(const ir_entity *ent) {
   return _get_entity_peculiarity(ent);
 }
 
 void
-(set_entity_peculiarity)(entity *ent, ir_peculiarity pec) {
+(set_entity_peculiarity)(ir_entity *ent, ir_peculiarity pec) {
   _set_entity_peculiarity(ent, pec);
 }
 
 /* Checks if an entity cannot be overridden anymore. */
-int (get_entity_final)(const entity *ent) {
+int (get_entity_final)(const ir_entity *ent) {
   return _get_entity_final(ent);
 }
 
 /* Sets/resets the final flag of an entity. */
-void (set_entity_final)(entity *ent, int final) {
+void (set_entity_final)(ir_entity *ent, int final) {
   _set_entity_final(ent, final);
 }
 
 /* Checks if an entity is compiler generated */
-int is_entity_compiler_generated(const entity *ent) {
+int is_entity_compiler_generated(const ir_entity *ent) {
   assert(is_entity(ent));
   return ent->compiler_gen;
 }
 
 /* Sets/resets the compiler generated flag */
-void set_entity_compiler_generated(entity *ent, int flag) {
+void set_entity_compiler_generated(ir_entity *ent, int flag) {
   assert(is_entity(ent));
   ent->compiler_gen = flag ? 1 : 0;
 }
 
 /* Get the entity's stickyness */
 ir_stickyness
-(get_entity_stickyness)(const entity *ent) {
+(get_entity_stickyness)(const ir_entity *ent) {
   return _get_entity_stickyness(ent);
 }
 
 /* Set the entity's stickyness */
 void
-(set_entity_stickyness)(entity *ent, ir_stickyness stickyness) {
+(set_entity_stickyness)(ir_entity *ent, ir_stickyness stickyness) {
   _set_entity_stickyness(ent, stickyness);
 }
 
 /* Set has no effect for existent entities of type method. */
 ir_node *
-get_atomic_ent_value(entity *ent)
+get_atomic_ent_value(ir_entity *ent)
 {
   assert(ent && is_atomic_entity(ent));
   assert(ent->variability != variability_uninitialized);
@@ -516,7 +516,7 @@ get_atomic_ent_value(entity *ent)
 }
 
 void
-set_atomic_ent_value(entity *ent, ir_node *val) {
+set_atomic_ent_value(ir_entity *ent, ir_node *val) {
   assert(is_atomic_entity(ent) && (ent->variability != variability_uninitialized));
   if (is_Method_type(ent->type) && (ent->peculiarity == peculiarity_existent))
     return;
@@ -635,7 +635,7 @@ int is_compound_graph_path(const void *thing) {
  *  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;
+  ir_entity *node;
   ir_type *owner = gr->tp;
 
   for (i = 0; i <= pos; i++) {
@@ -659,7 +659,7 @@ int get_compound_graph_path_length(const compound_graph_path *gr) {
   return gr->len;
 }
 
-entity *
+ir_entity *
 get_compound_graph_path_node(const compound_graph_path *gr, int pos) {
   assert(gr && is_compound_graph_path(gr));
   assert(pos >= 0 && pos < gr->len);
@@ -667,7 +667,7 @@ get_compound_graph_path_node(const compound_graph_path *gr, int pos) {
 }
 
 void
-set_compound_graph_path_node(compound_graph_path *gr, int pos, entity *node) {
+set_compound_graph_path_node(compound_graph_path *gr, int pos, ir_entity *node) {
   assert(gr && is_compound_graph_path(gr));
   assert(pos >= 0 && pos < gr->len);
   assert(is_entity(node));
@@ -692,7 +692,7 @@ set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index)
 /* A value of a compound entity is a pair of value and the corresponding path to a member of
    the compound. */
 void
-add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path) {
+add_compound_ent_value_w_path(ir_entity *ent, ir_node *val, compound_graph_path *path) {
   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
   assert(is_compound_graph_path(path));
   ARR_APP1(ir_node *, ent->attr.cmpd_attr.values, val);
@@ -700,7 +700,7 @@ add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *pa
 }
 
 void
-set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path, int pos) {
+set_compound_ent_value_w_path(ir_entity *ent, ir_node *val, compound_graph_path *path, int pos) {
   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
   assert(is_compound_graph_path(path));
   assert(0 <= pos && pos < ARR_LEN(ent->attr.cmpd_attr.values));
@@ -709,20 +709,20 @@ set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *pa
 }
 
 int
-get_compound_ent_n_values(entity *ent) {
+get_compound_ent_n_values(ir_entity *ent) {
   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
   return ARR_LEN(ent->attr.cmpd_attr.values);
 }
 
 ir_node *
-get_compound_ent_value(entity *ent, int pos) {
+get_compound_ent_value(ir_entity *ent, int pos) {
   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
   assert(0 <= pos && pos < ARR_LEN(ent->attr.cmpd_attr.values));
   return ent->attr.cmpd_attr.values[pos];
 }
 
 compound_graph_path *
-get_compound_ent_value_path(entity *ent, int pos) {
+get_compound_ent_value_path(ir_entity *ent, int pos) {
   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
   assert(0 <= pos && pos < ARR_LEN(ent->attr.cmpd_attr.val_paths));
   return ent->attr.cmpd_attr.val_paths[pos];
@@ -740,8 +740,8 @@ static int equal_paths(compound_graph_path *path1, int *visited_indices, compoun
 
   for (i = 0; i < len1; i++) {
     ir_type *tp;
-    entity *node1 = get_compound_graph_path_node(path1, i);
-    entity *node2 = get_compound_graph_path_node(path2, i);
+    ir_entity *node1 = get_compound_graph_path_node(path1, i);
+    ir_entity *node2 = get_compound_graph_path_node(path2, i);
 
     if (node1 != node2) return 0;
 
@@ -766,7 +766,7 @@ static int equal_paths(compound_graph_path *path1, int *visited_indices, compoun
 
 /* Returns the position of a value with the given path.
  *  The path must contain array indices for all array element entities. */
-int get_compound_ent_pos_by_path(entity *ent, compound_graph_path *path) {
+int get_compound_ent_pos_by_path(ir_entity *ent, compound_graph_path *path) {
   int i, n_paths = get_compound_ent_n_values(ent);
   int *visited_indices;
   int path_len = get_compound_graph_path_length(path);
@@ -784,7 +784,7 @@ int get_compound_ent_pos_by_path(entity *ent, compound_graph_path *path) {
     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);
+        ir_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));
@@ -799,13 +799,13 @@ int get_compound_ent_pos_by_path(entity *ent, compound_graph_path *path) {
 
 /* Returns a constant value given the access path.
  *  The path must contain array indices for all array element entities. */
-ir_node *get_compound_ent_value_by_path(entity *ent, compound_graph_path *path) {
+ir_node *get_compound_ent_value_by_path(ir_entity *ent, compound_graph_path *path) {
   return get_compound_ent_value(ent, get_compound_ent_pos_by_path(ent, path));
 }
 
 
 void
-remove_compound_ent_value(entity *ent, entity *value_ent) {
+remove_compound_ent_value(ir_entity *ent, ir_entity *value_ent) {
   int i;
   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
   for (i = 0; i < (ARR_LEN(ent->attr.cmpd_attr.val_paths)); ++i) {
@@ -815,7 +815,7 @@ remove_compound_ent_value(entity *ent, entity *value_ent) {
         ent->attr.cmpd_attr.val_paths[i] = ent->attr.cmpd_attr.val_paths[i+1];
         ent->attr.cmpd_attr.values[i]    = ent->attr.cmpd_attr.values[i+1];
       }
-      ARR_SETLEN(entity*,  ent->attr.cmpd_attr.val_paths, ARR_LEN(ent->attr.cmpd_attr.val_paths) - 1);
+      ARR_SETLEN(ir_entity*,  ent->attr.cmpd_attr.val_paths, ARR_LEN(ent->attr.cmpd_attr.val_paths) - 1);
       ARR_SETLEN(ir_node*, ent->attr.cmpd_attr.values,    ARR_LEN(ent->attr.cmpd_attr.values)    - 1);
       break;
     }
@@ -823,7 +823,7 @@ remove_compound_ent_value(entity *ent, entity *value_ent) {
 }
 
 void
-add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
+add_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member) {
   compound_graph_path *path;
   ir_type *owner_tp = get_entity_owner(member);
   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
@@ -850,7 +850,7 @@ add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
    the node as constant initialization to ent.
    The subgraph may not contain control flow operations.
 void
-copy_and_add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
+copy_and_add_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member) {
   ir_graph *rem = current_ir_graph;
 
   assert(get_entity_variability(ent) != variability_uninitialized);
@@ -863,13 +863,13 @@ copy_and_add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
 
 /* Copies the value i of the entity to current_block in current_ir_graph.
 ir_node *
-copy_compound_ent_value(entity *ent, int pos) {
+copy_compound_ent_value(ir_entity *ent, int pos) {
   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
   return copy_const_value(ent->values[pos+1]);
   }*/
 
-entity   *
-get_compound_ent_value_member(entity *ent, int pos) {
+ir_entity   *
+get_compound_ent_value_member(ir_entity *ent, int pos) {
   compound_graph_path *path;
   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
   path = get_compound_ent_value_path(ent, pos);
@@ -878,7 +878,7 @@ get_compound_ent_value_member(entity *ent, int pos) {
 }
 
 void
-set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos) {
+set_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member, int pos) {
   compound_graph_path *path;
   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
   path = get_compound_ent_value_path(ent, pos);
@@ -887,7 +887,7 @@ set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos) {
 }
 
 void
-set_array_entity_values(entity *ent, tarval **values, int num_vals) {
+set_array_entity_values(ir_entity *ent, tarval **values, int num_vals) {
   int i;
   ir_graph *rem = current_ir_graph;
   ir_type *arrtp = get_entity_type(ent);
@@ -910,7 +910,7 @@ set_array_entity_values(entity *ent, tarval **values, int num_vals) {
   current_ir_graph = rem;
 }
 
-int get_compound_ent_value_offset_bytes(entity *ent, int pos) {
+int get_compound_ent_value_offset_bytes(ir_entity *ent, int pos) {
 	compound_graph_path *path;
 	int path_len, i;
 	int offset = 0;
@@ -921,7 +921,7 @@ int get_compound_ent_value_offset_bytes(entity *ent, int pos) {
 	path_len = get_compound_graph_path_length(path);
 
 	for (i = 0; i < path_len; ++i) {
-		entity *node = get_compound_graph_path_node(path, i);
+		ir_entity *node = get_compound_graph_path_node(path, i);
 		ir_type *node_tp = get_entity_type(node);
 		ir_type *owner_tp = get_entity_owner(node);
 
@@ -947,11 +947,11 @@ int get_compound_ent_value_offset_bytes(entity *ent, int pos) {
 	return offset;
 }
 
-int get_compound_ent_value_offset_bit_part(entity *ent, int pos) {
+int get_compound_ent_value_offset_bit_part(ir_entity *ent, int pos) {
 	compound_graph_path *path;
 	int path_len;
 	int offset = 0;
-	entity *last_node;
+	ir_entity *last_node;
 
 	assert(get_type_state(get_entity_type(ent)) == layout_fixed);
 
@@ -971,7 +971,7 @@ typedef struct {
 	int n_elems;
 	/** current array index */
 	int current_elem;
-	entity *ent;
+	ir_entity *ent;
 } array_info;
 
 /* Compute the array indices in compound graph paths of initialized entities.
@@ -990,7 +990,7 @@ typedef struct {
  *  the indices as firm nodes.  But still we must be able to
  *  evaluate the index against the upper bound.)
  */
-int compute_compound_ent_array_indices(entity *ent) {
+int compute_compound_ent_array_indices(ir_entity *ent) {
 	ir_type *tp = get_entity_type(ent);
 	int i, n_vals;
 	int max_len = 0;
@@ -1018,12 +1018,12 @@ int compute_compound_ent_array_indices(entity *ent) {
 		int path_len = get_compound_graph_path_length(path);
 		int j;
 		int needadd = 0;
-		entity *prev_node = NULL;
+		ir_entity *prev_node = NULL;
 
 		for(j = path_len-1; j >= 0; --j) {
 			int dim, dims;
 			int n_elems;
-			entity *node = get_compound_graph_path_node(path, j);
+			ir_entity *node = get_compound_graph_path_node(path, j);
 			const ir_type *node_type = get_entity_type(node);
 			array_info *info = &array_infos[j];
 
@@ -1034,7 +1034,7 @@ int compute_compound_ent_array_indices(entity *ent) {
 				continue;
 			} else if(is_compound_type(node_type) && !is_Array_type(node_type)) {
 				int n_members = get_compound_n_members(node_type);
-				entity *last = get_compound_member(node_type, n_members - 1);
+				ir_entity *last = get_compound_member(node_type, n_members - 1);
 				if(needadd && last == prev_node) {
 					needadd = 1;
 				} else {
@@ -1090,27 +1090,27 @@ int compute_compound_ent_array_indices(entity *ent) {
 }
 
 int
-(get_entity_offset_bytes)(const entity *ent) {
+(get_entity_offset_bytes)(const ir_entity *ent) {
   return _get_entity_offset_bytes(ent);
 }
 
 int
-(get_entity_offset_bits)(const entity *ent) {
+(get_entity_offset_bits)(const ir_entity *ent) {
   return _get_entity_offset_bits(ent);
 }
 
 void
-(set_entity_offset_bytes)(entity *ent, int offset) {
+(set_entity_offset_bytes)(ir_entity *ent, int offset) {
   _set_entity_offset_bytes(ent, offset);
 }
 
 void
-(set_entity_offset_bits)(entity *ent, int offset) {
+(set_entity_offset_bits)(ir_entity *ent, int offset) {
   _set_entity_offset_bits(ent, offset);
 }
 
 void
-add_entity_overwrites(entity *ent, entity *overwritten) {
+add_entity_overwrites(ir_entity *ent, ir_entity *overwritten) {
 #ifndef NDEBUG
   ir_type *owner     = get_entity_owner(ent);
   ir_type *ovw_ovner = get_entity_owner(overwritten);
@@ -1118,18 +1118,18 @@ add_entity_overwrites(entity *ent, entity *overwritten) {
   assert(is_Class_type(ovw_ovner));
   assert(! is_class_final(ovw_ovner));
 #endif /* NDEBUG */
-  ARR_APP1(entity *, ent->overwrites, overwritten);
-  ARR_APP1(entity *, overwritten->overwrittenby, ent);
+  ARR_APP1(ir_entity *, ent->overwrites, overwritten);
+  ARR_APP1(ir_entity *, overwritten->overwrittenby, ent);
 }
 
 int
-get_entity_n_overwrites(entity *ent) {
+get_entity_n_overwrites(ir_entity *ent) {
   assert(is_Class_type(get_entity_owner(ent)));
   return (ARR_LEN(ent->overwrites));
 }
 
 int
-get_entity_overwrites_index(entity *ent, entity *overwritten) {
+get_entity_overwrites_index(ir_entity *ent, ir_entity *overwritten) {
   int i;
   assert(is_Class_type(get_entity_owner(ent)));
   for (i = 0; i < get_entity_n_overwrites(ent); i++)
@@ -1138,46 +1138,46 @@ get_entity_overwrites_index(entity *ent, entity *overwritten) {
   return -1;
 }
 
-entity *
-get_entity_overwrites   (entity *ent, int pos) {
+ir_entity *
+get_entity_overwrites   (ir_entity *ent, int pos) {
   assert(is_Class_type(get_entity_owner(ent)));
   assert(pos < get_entity_n_overwrites(ent));
   return ent->overwrites[pos];
 }
 
 void
-set_entity_overwrites   (entity *ent, int pos, entity *overwritten) {
+set_entity_overwrites   (ir_entity *ent, int pos, ir_entity *overwritten) {
   assert(is_Class_type(get_entity_owner(ent)));
   assert(pos < get_entity_n_overwrites(ent));
   ent->overwrites[pos] = overwritten;
 }
 
 void
-remove_entity_overwrites(entity *ent, entity *overwritten) {
+remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten) {
   int i;
   assert(is_Class_type(get_entity_owner(ent)));
   for (i = 0; i < (ARR_LEN (ent->overwrites)); i++)
     if (ent->overwrites[i] == overwritten) {
       for(; i < (ARR_LEN (ent->overwrites))-1; i++)
     ent->overwrites[i] = ent->overwrites[i+1];
-      ARR_SETLEN(entity*, ent->overwrites, ARR_LEN(ent->overwrites) - 1);
+      ARR_SETLEN(ir_entity*, ent->overwrites, ARR_LEN(ent->overwrites) - 1);
       break;
     }
 }
 
 void
-add_entity_overwrittenby   (entity *ent, entity *overwrites) {
+add_entity_overwrittenby   (ir_entity *ent, ir_entity *overwrites) {
   add_entity_overwrites(overwrites, ent);
 }
 
 int
-get_entity_n_overwrittenby (entity *ent) {
+get_entity_n_overwrittenby (ir_entity *ent) {
   assert(is_Class_type(get_entity_owner(ent)));
   return (ARR_LEN (ent->overwrittenby));
 }
 
 int
-get_entity_overwrittenby_index(entity *ent, entity *overwrites) {
+get_entity_overwrittenby_index(ir_entity *ent, ir_entity *overwrites) {
   int i;
   assert(is_Class_type(get_entity_owner(ent)));
   for (i = 0; i < get_entity_n_overwrittenby(ent); i++)
@@ -1186,50 +1186,50 @@ get_entity_overwrittenby_index(entity *ent, entity *overwrites) {
   return -1;
 }
 
-entity *
-get_entity_overwrittenby   (entity *ent, int pos) {
+ir_entity *
+get_entity_overwrittenby   (ir_entity *ent, int pos) {
   assert(is_Class_type(get_entity_owner(ent)));
   assert(pos < get_entity_n_overwrittenby(ent));
   return ent->overwrittenby[pos];
 }
 
 void
-set_entity_overwrittenby   (entity *ent, int pos, entity *overwrites) {
+set_entity_overwrittenby   (ir_entity *ent, int pos, ir_entity *overwrites) {
   assert(is_Class_type(get_entity_owner(ent)));
   assert(pos < get_entity_n_overwrittenby(ent));
   ent->overwrittenby[pos] = overwrites;
 }
 
-void    remove_entity_overwrittenby(entity *ent, entity *overwrites) {
+void    remove_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites) {
   int i;
   assert(is_Class_type(get_entity_owner(ent)));
   for (i = 0; i < (ARR_LEN (ent->overwrittenby)); i++)
     if (ent->overwrittenby[i] == overwrites) {
       for(; i < (ARR_LEN (ent->overwrittenby))-1; i++)
     ent->overwrittenby[i] = ent->overwrittenby[i+1];
-      ARR_SETLEN(entity*, ent->overwrittenby, ARR_LEN(ent->overwrittenby) - 1);
+      ARR_SETLEN(ir_entity*, ent->overwrittenby, ARR_LEN(ent->overwrittenby) - 1);
       break;
     }
 }
 
 /* A link to store intermediate information */
 void *
-(get_entity_link)(const entity *ent) {
+(get_entity_link)(const ir_entity *ent) {
   return _get_entity_link(ent);
 }
 
 void
-(set_entity_link)(entity *ent, void *l) {
+(set_entity_link)(ir_entity *ent, void *l) {
   _set_entity_link(ent, l);
 }
 
 ir_graph *
-(get_entity_irg)(const entity *ent) {
+(get_entity_irg)(const ir_entity *ent) {
   return _get_entity_irg(ent);
 }
 
 void
-set_entity_irg(entity *ent, ir_graph *irg) {
+set_entity_irg(ir_entity *ent, ir_graph *irg) {
   assert(is_method_entity(ent));
   /* Wie kann man die Referenz auf einen IRG löschen, z.B. wenn die
    * Methode selbst nicht mehr aufgerufen werden kann, die Entität
@@ -1244,24 +1244,24 @@ set_entity_irg(entity *ent, ir_graph *irg) {
   ent->attr.mtd_attr.irg = irg;
 }
 
-unsigned get_entity_vtable_number(entity *ent) {
+unsigned get_entity_vtable_number(ir_entity *ent) {
   assert(is_method_entity(ent));
   return ent->attr.mtd_attr.vtable_number;
 }
 
-void set_entity_vtable_number(entity *ent, unsigned vtable_number) {
+void set_entity_vtable_number(ir_entity *ent, unsigned vtable_number) {
   assert(is_method_entity(ent));
   ent->attr.mtd_attr.vtable_number = vtable_number;
 }
 
 /* Returns the section of a method. */
-ir_img_section get_method_img_section(const entity *ent) {
+ir_img_section get_method_img_section(const ir_entity *ent) {
   assert(is_method_entity(ent));
   return ent->attr.mtd_attr.section;
 }
 
 /* Sets the section of a method. */
-void set_method_img_section(entity *ent, ir_img_section section) {
+void set_method_img_section(ir_entity *ent, ir_img_section section) {
   assert(is_method_entity(ent));
   ent->attr.mtd_attr.section = section;
 }
@@ -1271,56 +1271,56 @@ int
   return _is_entity(thing);
 }
 
-int is_atomic_entity(entity *ent) {
+int is_atomic_entity(ir_entity *ent) {
   ir_type *t      = get_entity_type(ent);
   const tp_op *op = get_type_tpop(t);
   return (op == type_primitive || op == type_pointer ||
       op == type_enumeration || op == type_method);
 }
 
-int is_compound_entity(entity *ent) {
+int is_compound_entity(ir_entity *ent) {
   ir_type     *t  = get_entity_type(ent);
   const tp_op *op = get_type_tpop(t);
   return (op == type_class || op == type_struct ||
       op == type_array || op == type_union);
 }
 
-int is_method_entity(entity *ent) {
+int is_method_entity(ir_entity *ent) {
   ir_type *t = get_entity_type(ent);
   return is_Method_type(t);
 }
 
 /**
  * @todo not implemented!!! */
-int equal_entity(entity *ent1, entity *ent2) {
+int equal_entity(ir_entity *ent1, ir_entity *ent2) {
   fprintf(stderr, " calling unimplemented equal entity!!! \n");
   return 1;
 }
 
 
-unsigned long (get_entity_visited)(entity *ent) {
+unsigned long (get_entity_visited)(ir_entity *ent) {
   return _get_entity_visited(ent);
 }
 
-void (set_entity_visited)(entity *ent, unsigned long num) {
+void (set_entity_visited)(ir_entity *ent, unsigned long num) {
   _set_entity_visited(ent, num);
 }
 
-/* Sets visited field in entity to entity_visited. */
-void (mark_entity_visited)(entity *ent) {
+/* Sets visited field in ir_entity to entity_visited. */
+void (mark_entity_visited)(ir_entity *ent) {
   _mark_entity_visited(ent);
 }
 
-int (entity_visited)(entity *ent) {
+int (entity_visited)(ir_entity *ent) {
   return _entity_visited(ent);
 }
 
-int (entity_not_visited)(entity *ent) {
+int (entity_not_visited)(ir_entity *ent) {
   return _entity_not_visited(ent);
 }
 
 /* Returns the mask of the additional entity properties. */
-unsigned get_entity_additional_properties(entity *ent) {
+unsigned get_entity_additional_properties(ir_entity *ent) {
   ir_graph *irg;
 
   assert(is_method_entity(ent));
@@ -1338,7 +1338,7 @@ unsigned get_entity_additional_properties(entity *ent) {
 }
 
 /* Sets the mask of the additional graph properties. */
-void set_entity_additional_properties(entity *ent, unsigned property_mask)
+void set_entity_additional_properties(ir_entity *ent, unsigned property_mask)
 {
   ir_graph *irg;
 
@@ -1356,7 +1356,7 @@ void set_entity_additional_properties(entity *ent, unsigned property_mask)
 }
 
 /* Sets one additional graph property. */
-void set_entity_additional_property(entity *ent, mtp_additional_property flag)
+void set_entity_additional_property(ir_entity *ent, mtp_additional_property flag)
 {
   ir_graph *irg;
 
@@ -1380,7 +1380,7 @@ void set_entity_additional_property(entity *ent, mtp_additional_property flag)
 
 /* Returns the class type that this type info entity represents or NULL
    if ent is no type info entity. */
-ir_type *(get_entity_repr_class)(const entity *ent) {
+ir_type *(get_entity_repr_class)(const ir_entity *ent) {
   return _get_entity_repr_class(ent);
 }
 
diff --git a/ir/tr/entity.h b/ir/tr/entity.h
index dbb7435dd..7fce7601e 100644
--- a/ir/tr/entity.h
+++ b/ir/tr/entity.h
@@ -35,7 +35,7 @@
  * of procedures defined in the scope of an other procedure is the
  * enclosing procedure.
  *
- * In detail the datastructure entity has the following fields:
+ * In detail the datastructure ir_entity has the following fields:
  *
  * - ident *name:    Name of this entity as specified in the source code.
  *                   Only unequivocal in conjuction with scope.
@@ -115,7 +115,7 @@
 /** the type of an entity */
 #ifndef _ENTITY_TYPEDEF_
 #define _ENTITY_TYPEDEF_
-typedef struct entity entity;
+typedef struct ir_entity ir_entity, entity;
 #endif
 
 /**
@@ -127,7 +127,7 @@ typedef struct entity entity;
  * value is a pointer to the method.
  * Visibility is local, offset -1, and it is not volatile.
  */
-entity     *new_entity(ir_type *owner, ident *name, ir_type *tp);
+ir_entity     *new_entity(ir_type *owner, ident *name, ir_type *tp);
 
 /**
  * Creates a new entity.
@@ -138,7 +138,7 @@ entity     *new_entity(ir_type *owner, ident *name, ir_type *tp);
  * value is a pointer to the method.
  * Visibility is local, offset -1, and it is not volatile.
  */
-entity     *new_d_entity(ir_type *owner, ident *name, ir_type *tp, dbg_info *db);
+ir_entity     *new_d_entity(ir_type *owner, ident *name, ir_type *tp, dbg_info *db);
 
 /**
  * Copies the entity if the new_owner is different from the
@@ -152,7 +152,7 @@ entity     *new_d_entity(ir_type *owner, ident *name, ir_type *tp, dbg_info *db)
  *       itself and not to the origin.  Right now we have to change
  *       the peculiarity and then set a new atomic value by hand.
  */
-entity     *copy_entity_own(entity *old, ir_type *new_owner);
+ir_entity     *copy_entity_own(ir_entity *old, ir_type *new_owner);
 
 /**
  * Copies the entity if the new_name is different from the
@@ -162,7 +162,7 @@ entity     *copy_entity_own(entity *old, ir_type *new_owner);
  * The mangled name ld_name is set to NULL.
  * Overwrites relation is copied from old.
  */
-entity     *copy_entity_name(entity *old, ident *new_name);
+ir_entity     *copy_entity_name(ir_entity *old, ident *new_name);
 
 /**
  * Frees the entity.
@@ -170,16 +170,16 @@ entity     *copy_entity_name(entity *old, ident *new_name);
  * The owner will still contain the pointer to this
  * entity, as well as all other references!
  */
-void        free_entity(entity *ent);
+void        free_entity(ir_entity *ent);
 
 /** Returns the name of an entity. */
-const char *get_entity_name(const entity *ent);
+const char *get_entity_name(const ir_entity *ent);
 
 /** Returns the ident of an entity. */
-ident      *get_entity_ident(const entity *ent);
+ident      *get_entity_ident(const ir_entity *ent);
 
 /** Sets the ident of the entity. */
-void        set_entity_ident(entity *ent, ident *id);
+void        set_entity_ident(ir_entity *ent, ident *id);
 
 /** Returns the mangled name of the entity.
  *
@@ -187,26 +187,26 @@ void        set_entity_ident(entity *ent, ident *id);
  * Else it generates a name with mangle_entity()
  * and remembers this new name internally.
  */
-ident      *get_entity_ld_ident(entity *ent);
+ident      *get_entity_ld_ident(ir_entity *ent);
 
 /** Sets the mangled name of the entity. */
-void        set_entity_ld_ident(entity *ent, ident *ld_ident);
+void        set_entity_ld_ident(ir_entity *ent, ident *ld_ident);
 
 /** Returns the mangled name of the entity as a string. */
-const char *get_entity_ld_name(entity *ent);
+const char *get_entity_ld_name(ir_entity *ent);
 
 /** Returns the owner of the entity. */
-ir_type    *get_entity_owner(entity *ent);
+ir_type    *get_entity_owner(ir_entity *ent);
 
 /** Sets the owner field in entity to owner.  Don't forget to add
    ent to owner!! */
-void        set_entity_owner(entity *ent, ir_type *owner);
+void        set_entity_owner(ir_entity *ent, ir_type *owner);
 
 /** Returns the type of an entity. */
-ir_type  *get_entity_type(entity *ent);
+ir_type  *get_entity_type(ir_entity *ent);
 
 /** Sets the type of an entity. */
-void      set_entity_type(entity *ent, ir_type *tp);
+void      set_entity_type(ir_entity *ent, ir_type *tp);
 
 /** The allocation type. */
 typedef enum {
@@ -223,19 +223,19 @@ typedef enum {
 } ir_allocation;
 
 /** Returns the allocation type of an entity. */
-ir_allocation get_entity_allocation(const entity *ent);
+ir_allocation get_entity_allocation(const ir_entity *ent);
 
 /** Sets the allocation type of an entity. */
-void           set_entity_allocation(entity *ent, ir_allocation al);
+void           set_entity_allocation(ir_entity *ent, ir_allocation al);
 
 /** Return the name of the allocation type. */
 const char *get_allocation_name(ir_allocation vis);
 
 /** Returns the visibility of an entity. */
-ir_visibility get_entity_visibility(const entity *ent);
+ir_visibility get_entity_visibility(const ir_entity *ent);
 
 /** Sets the visibility of an entity. */
-void       set_entity_visibility(entity *ent, ir_visibility vis);
+void       set_entity_visibility(ir_entity *ent, ir_visibility vis);
 
 /** Return the name of the visibility */
 const char *get_visibility_name(ir_visibility vis);
@@ -252,10 +252,10 @@ typedef enum {
 } ir_variability;
 
 /** Returns the variability of an entity. */
-ir_variability get_entity_variability(const entity *ent);
+ir_variability get_entity_variability(const ir_entity *ent);
 
 /** Sets the variability of an entity. */
-void           set_entity_variability(entity *ent, ir_variability var);
+void           set_entity_variability(ir_entity *ent, ir_variability var);
 
 /** Return the name of the variability. */
 const char *get_variability_name(ir_variability var);
@@ -267,10 +267,10 @@ typedef enum {
 } ir_volatility;
 
 /** Returns the volatility of an entity. */
-ir_volatility get_entity_volatility(const entity *ent);
+ir_volatility get_entity_volatility(const ir_entity *ent);
 
 /** Sets the volatility of an entity. */
-void          set_entity_volatility(entity *ent, ir_volatility vol);
+void          set_entity_volatility(ir_entity *ent, ir_volatility vol);
 
 /** Return the name of the volatility. */
 const char *get_volatility_name(ir_volatility var);
@@ -285,60 +285,60 @@ typedef enum {
 } ir_stickyness;
 
 /** Get the entity's stickyness. */
-ir_stickyness get_entity_stickyness(const entity *ent);
+ir_stickyness get_entity_stickyness(const ir_entity *ent);
 
 /** Set the entity's stickyness. */
-void          set_entity_stickyness(entity *ent, ir_stickyness stickyness);
+void          set_entity_stickyness(ir_entity *ent, ir_stickyness stickyness);
 
 /** Returns the offset of an entity (in a compound) in bytes. Only set if layout = fixed. */
-int       get_entity_offset_bytes(const entity *ent);
+int       get_entity_offset_bytes(const ir_entity *ent);
 
 /** Returns the offset of an entity (in a compound) in bits. Only set if layout = fixed. */
-int       get_entity_offset_bits(const entity *ent);
+int       get_entity_offset_bits(const ir_entity *ent);
 
 /** Sets the offset of an entity (in a compound) in bytes. */
-void      set_entity_offset_bytes(entity *ent, int offset);
+void      set_entity_offset_bytes(ir_entity *ent, int offset);
 
 /** Sets the offset of an entity (in a compound) in bits. */
-void      set_entity_offset_bits(entity *ent, int offset);
+void      set_entity_offset_bits(ir_entity *ent, int offset);
 
 /** Returns the stored intermediate information. */
-void *get_entity_link(const entity *ent);
+void *get_entity_link(const ir_entity *ent);
 
 /** Stores new intermediate information. */
-void set_entity_link(entity *ent, void *l);
+void set_entity_link(ir_entity *ent, void *l);
 
 /* -- Fields of method entities -- */
 /** The entity knows the corresponding irg if the entity is a method.
    This allows to get from a Call to the called irg.
    Only entities of peculiarity "existent" can have a corresponding irg,
    else the field is fixed to NULL.  (Get returns NULL, set asserts.) */
-ir_graph *get_entity_irg(const entity *ent);
-void      set_entity_irg(entity *ent, ir_graph *irg);
+ir_graph *get_entity_irg(const ir_entity *ent);
+void      set_entity_irg(ir_entity *ent, ir_graph *irg);
 
 /** Gets the entity vtable number. */
-unsigned get_entity_vtable_number(entity *ent);
+unsigned get_entity_vtable_number(ir_entity *ent);
 
 /** Sets the entity vtable number. */
-void     set_entity_vtable_number(entity *ent, unsigned vtable_number);
+void     set_entity_vtable_number(ir_entity *ent, unsigned vtable_number);
 
 /** Return the peculiarity of an entity. */
-ir_peculiarity get_entity_peculiarity(const entity *ent);
+ir_peculiarity get_entity_peculiarity(const ir_entity *ent);
 
 /** Sets the peculiarity of an entity. */
-void           set_entity_peculiarity(entity *ent, ir_peculiarity pec);
+void           set_entity_peculiarity(ir_entity *ent, ir_peculiarity pec);
 
 /** Checks if an entity cannot be overridden anymore. */
-int       get_entity_final(const entity *ent);
+int       get_entity_final(const ir_entity *ent);
 
 /** Sets/resets the final flag of an entity. */
-void      set_entity_final(entity *ent, int final);
+void      set_entity_final(ir_entity *ent, int final);
 
 /** Checks if an entity is compiler generated. */
-int is_entity_compiler_generated(const entity *ent);
+int is_entity_compiler_generated(const ir_entity *ent);
 
 /** Sets/resets the compiler generated flag. */
-void set_entity_compiler_generated(entity *ent, int flag);
+void set_entity_compiler_generated(ir_entity *ent, int flag);
 
 /* -- Representation of constant values of entities -- */
 /** Returns true if the the node is representable as code on
@@ -354,8 +354,8 @@ int      is_irn_const_expression(ir_node *n);
 ir_node *copy_const_value(dbg_info *dbg, ir_node *n);
 
 /* Set has no effect for existent entities of type method. */
-ir_node *get_atomic_ent_value(entity *ent);
-void     set_atomic_ent_value(entity *ent, ir_node *val);
+ir_node *get_atomic_ent_value(ir_entity *ent);
+void     set_atomic_ent_value(ir_entity *ent, ir_node *val);
 
 /**
  * The following type describes a path to a leave in the compound graph.
@@ -380,8 +380,8 @@ void    free_compound_graph_path (compound_graph_path *gr);
 /** Returns the length of a graph path */
 int     get_compound_graph_path_length(const compound_graph_path *gr);
 
-entity *get_compound_graph_path_node(const compound_graph_path *gr, int pos);
-void    set_compound_graph_path_node(compound_graph_path *gr, int pos, entity *node);
+ir_entity *get_compound_graph_path_node(const compound_graph_path *gr, int pos);
+void    set_compound_graph_path_node(compound_graph_path *gr, int pos, ir_entity *node);
 int     get_compound_graph_path_array_index(const compound_graph_path *gr, int pos);
 void    set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index);
 
@@ -391,28 +391,28 @@ int is_proper_compound_graph_path(compound_graph_path *gr, int pos);
 
 /* A value of a compound entity is a pair of a value and the description of the
    corresponding access path to the member of the compound.  */
-void     add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path);
-void     set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path, int pos);
+void     add_compound_ent_value_w_path(ir_entity *ent, ir_node *val, compound_graph_path *path);
+void     set_compound_ent_value_w_path(ir_entity *ent, ir_node *val, compound_graph_path *path, int pos);
 /** Returns the number of constant values needed to initialize the entity.
  *
  *  Asserts if the entity has variability_uninitialized.
  * */
-int      get_compound_ent_n_values(entity *ent);
+int      get_compound_ent_n_values(ir_entity *ent);
 /** Returns a constant value given the position. */
-ir_node *get_compound_ent_value(entity *ent, int pos);
+ir_node *get_compound_ent_value(ir_entity *ent, int pos);
 /** Returns the access path for value at position pos. */
-compound_graph_path *get_compound_ent_value_path(entity *ent, int pos);
+compound_graph_path *get_compound_ent_value_path(ir_entity *ent, int pos);
 /** Returns the position of a value with the given path.
  *  The path must contain array indices for all array element entities. */
-int get_compound_ent_pos_by_path(entity *ent, compound_graph_path *path);
+int get_compound_ent_pos_by_path(ir_entity *ent, compound_graph_path *path);
 /** Returns a constant value given the access path.
  *  The path must contain array indices for all array element entities. */
-ir_node *get_compound_ent_value_by_path(entity *ent, compound_graph_path *path);
+ir_node *get_compound_ent_value_by_path(ir_entity *ent, compound_graph_path *path);
 
 /** Removes all constant entries where the path ends at value_ent. Does not
    free the memory of the paths.  (The same path might be used for several
    constant entities. */
-void     remove_compound_ent_value(entity *ent, entity *value_ent);
+void     remove_compound_ent_value(ir_entity *ent, ir_entity *value_ent);
 
 /* Some languages support only trivial access paths, i.e., the member is a
    direct, atomic member of the constant entities type. In this case the
@@ -423,13 +423,13 @@ void     remove_compound_ent_value(entity *ent, entity *value_ent);
     Beware: Has a bad runtime for array elements (O(|array|) and should be
     avoided there. Use add_compound_ent_value_w_path() instead and create
     the path manually. */
-void     add_compound_ent_value(entity *ent, ir_node *val, entity *member);
+void     add_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member);
 
 /** Returns the last member in the path */
-entity  *get_compound_ent_value_member(entity *ent, int pos);
+ir_entity  *get_compound_ent_value_member(ir_entity *ent, int pos);
 
 /** Sets the path at pos 0 */
-void     set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos);
+void     set_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member, int pos);
 
 /** Initializes the entity ent which must be of a one dimensional
    array type with the values given in the values array.
@@ -437,7 +437,7 @@ void     set_compound_ent_value(entity *ent, ir_node *val, entity *member, int p
    order of values. Does not test whether the number of values
    fits into the given array size.  Does not test whether the
    values have the proper mode for the array. */
-void set_array_entity_values(entity *ent, tarval **values, int num_vals);
+void set_array_entity_values(ir_entity *ent, tarval **values, int num_vals);
 
 /**
  * Return the offset in bits from the last byte (result is in [0,7])
@@ -447,7 +447,7 @@ void set_array_entity_values(entity *ent, tarval **values, int num_vals);
  * @param ent Any entity of compound type with at least pos initialization values.
  * @param pos The position of the value for which the offset is requested.
  */
-int get_compound_ent_value_offset_bit_part(entity *ent, int pos);
+int get_compound_ent_value_offset_bit_part(ir_entity *ent, int pos);
 
 /** Return the overall offset of value at position pos in bytes.
  *
@@ -457,7 +457,7 @@ int get_compound_ent_value_offset_bit_part(entity *ent, int pos);
  * @param ent Any entity of compound type with at least pos initialization values.
  * @param pos The position of the value for which the offset is requested.
  */
-int  get_compound_ent_value_offset_bytes(entity *ent, int pos);
+int  get_compound_ent_value_offset_bytes(ir_entity *ent, int pos);
 
 /** Compute the array indices in compound graph paths of initialized entities.
  *
@@ -470,7 +470,7 @@ int  get_compound_ent_value_offset_bytes(entity *ent, int pos);
  * @param ent Any entity.
  * @return 0 in case of an error, 1 otherwise
  */
-int compute_compound_ent_array_indices(entity *ent);
+int compute_compound_ent_array_indices(ir_entity *ent);
 
 /* --- Fields of entities with a class type as owner --- */
 /* Overwrites is a field that specifies that an access to the overwritten
@@ -482,19 +482,19 @@ int compute_compound_ent_array_indices(entity *ent);
    that is passed to it.  Lowering of the Sel node must assure this.
    Overwrittenby is the inverse of overwrites.  Both add routines add
    both relations, they only differ in the order of arguments. */
-void    add_entity_overwrites   (entity *ent, entity *overwritten);
-int     get_entity_n_overwrites (entity *ent);
-int     get_entity_overwrites_index(entity *ent, entity *overwritten);
-entity *get_entity_overwrites   (entity *ent, int pos);
-void    set_entity_overwrites   (entity *ent, int pos, entity *overwritten);
-void    remove_entity_overwrites(entity *ent, entity *overwritten);
-
-void    add_entity_overwrittenby   (entity *ent, entity *overwrites);
-int     get_entity_n_overwrittenby (entity *ent);
-int     get_entity_overwrittenby_index(entity *ent, entity *overwrites);
-entity *get_entity_overwrittenby   (entity *ent, int pos);
-void    set_entity_overwrittenby   (entity *ent, int pos, entity *overwrites);
-void    remove_entity_overwrittenby(entity *ent, entity *overwrites);
+void    add_entity_overwrites   (ir_entity *ent, ir_entity *overwritten);
+int     get_entity_n_overwrites (ir_entity *ent);
+int     get_entity_overwrites_index(ir_entity *ent, ir_entity *overwritten);
+ir_entity *get_entity_overwrites   (ir_entity *ent, int pos);
+void    set_entity_overwrites   (ir_entity *ent, int pos, ir_entity *overwritten);
+void    remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten);
+
+void    add_entity_overwrittenby   (ir_entity *ent, ir_entity *overwrites);
+int     get_entity_n_overwrittenby (ir_entity *ent);
+int     get_entity_overwrittenby_index(ir_entity *ent, ir_entity *overwrites);
+ir_entity *get_entity_overwrittenby   (ir_entity *ent, int pos);
+void    set_entity_overwrittenby   (ir_entity *ent, int pos, ir_entity *overwrites);
+void    remove_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites);
 
 /**
  *   Checks whether a pointer points to an entity.
@@ -508,40 +508,40 @@ int is_entity (const void *thing);
 
 /** Returns true if the type of the entity is a primitive, pointer
    enumeration or method type. */
-int is_atomic_entity(entity *ent);
+int is_atomic_entity(ir_entity *ent);
 /** Returns true if the type of the entity is a class, structure,
    array or union type. */
-int is_compound_entity(entity *ent);
+int is_compound_entity(ir_entity *ent);
 /** Returns true if the type of the entity is a Method type. */
-int is_method_entity(entity *ent);
+int is_method_entity(ir_entity *ent);
 
 /** Returns non-zero if ent1 and ent2 have are equal except for their owner.
    Two entities are equal if
     - they have the same type (the same C-struct)
     - ...?
 */
-int equal_entity(entity *ent1, entity *ent2);
+int equal_entity(ir_entity *ent1, ir_entity *ent2);
 
 /** Outputs a unique number for this entity if libfirm is compiled for
  *  debugging, (configure with --enable-debug) else returns the address
  *  of the type cast to long.
  */
-long get_entity_nr(entity *ent);
+long get_entity_nr(ir_entity *ent);
 
 /** Returns the entities visited count. */
-unsigned long get_entity_visited(entity *ent);
+unsigned long get_entity_visited(ir_entity *ent);
 
 /** Sets the entities visited count. */
-void        set_entity_visited(entity *ent, unsigned long num);
+void        set_entity_visited(ir_entity *ent, unsigned long num);
 
 /** Sets visited field in entity to entity_visited. */
-void        mark_entity_visited(entity *ent);
+void        mark_entity_visited(ir_entity *ent);
 
 /** Returns true if this entity was visited. */
-int        entity_visited(entity *ent);
+int        entity_visited(ir_entity *ent);
 
 /** Returns true if this entity was not visited. */
-int        entity_not_visited(entity *ent);
+int        entity_not_visited(ir_entity *ent);
 
 /**
  * Returns the mask of the additional entity properties.
@@ -550,17 +550,17 @@ int        entity_not_visited(entity *ent);
  * set_entity_additional_properties() or
  * set_entity_additional_property().
  */
-unsigned get_entity_additional_properties(entity *ent);
+unsigned get_entity_additional_properties(ir_entity *ent);
 
 /** Sets the mask of the additional graph properties. */
-void set_entity_additional_properties(entity *ent, unsigned property_mask);
+void set_entity_additional_properties(ir_entity *ent, unsigned property_mask);
 
 /** Sets one additional graph property. */
-void set_entity_additional_property(entity *ent, mtp_additional_property flag);
+void set_entity_additional_property(ir_entity *ent, mtp_additional_property flag);
 
 /** Returns the class type that this type info entity represents or NULL
     if ent is no type info entity. */
-ir_type *get_entity_repr_class(const entity *ent);
+ir_type *get_entity_repr_class(const ir_entity *ent);
 
 /**
  * @page unknown_entity
@@ -598,7 +598,7 @@ ir_type *get_entity_repr_class(const entity *ent);
  *    link          = NULL
  */
 /* A variable that contains the only unknown entity. */
-extern entity *unknown_entity;
+extern ir_entity *unknown_entity;
 
 /** Returns the unknown entity */
 entity *get_unknown_entity(void);
@@ -627,9 +627,9 @@ typedef enum {
 } ir_img_section;
 
 /** Returns the section of a method. */
-ir_img_section get_method_img_section(const entity *method);
+ir_img_section get_method_img_section(const ir_entity *method);
 
 /** Sets the section of a method. */
-void set_method_img_section(entity *method, ir_img_section section);
+void set_method_img_section(ir_entity *method, ir_img_section section);
 
 #endif /* _FIRM_TR_ENTITY_H_ */
diff --git a/ir/tr/entity_t.h b/ir/tr/entity_t.h
index dc5f12c42..51c78a480 100644
--- a/ir/tr/entity_t.h
+++ b/ir/tr/entity_t.h
@@ -49,12 +49,12 @@
 
 /** A path in a compound graph. */
 struct compound_graph_path {
-  firm_kind kind;       /**< dynamic type tag for compound graph path. */
+  firm_kind kind;       /**< The dynamic type tag for compound graph path. */
   ir_type *tp;          /**< The type this path belongs to. */
-  int len;              /**< length of the path */
+  int len;              /**< The length of the path. */
   struct tuple {
-    int    index;       /**< Array index.  To compute position of array elements */
-    entity *node;       /**< entity */
+    int       index;    /**< Array index.  To compute position of array elements */
+    ir_entity *node;    /**< The accessed entity. */
   } list[1];            /**< List of entity/index tuple of length len to express the
                              access path. */
 };
@@ -94,7 +94,7 @@ typedef struct method_ent_attr {
 
 
 /** The type of an entity. */
-struct entity {
+struct ir_entity {
   firm_kind kind;       /**< The dynamic type tag for entity. */
   ident *name;          /**< The name of this entity. */
   ident *ld_name;       /**< Unique name of this entity, i.e., the mangled
@@ -125,8 +125,8 @@ struct entity {
 
   /* ------------- fields for entities owned by a class type ---------------*/
 
-  entity **overwrites;     /**< A list of entities this entity overwrites. */
-  entity **overwrittenby;  /**< A list of entities that overwrite this entity.  */
+  ir_entity **overwrites;     /**< A list of entities this entity overwrites. */
+  ir_entity **overwrittenby;  /**< A list of entities that overwrite this entity.  */
 
   /* ------------- fields for atomic entities  --------------- */
   ir_node *value;          /**< value if entity is not of variability uninitialized.
@@ -157,31 +157,31 @@ _is_entity(const void *thing) {
 }
 
 static INLINE const char *
-_get_entity_name(const entity *ent) {
+_get_entity_name(const ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   return get_id_str(get_entity_ident(ent));
 }
 
 static INLINE ident *
-_get_entity_ident(const entity *ent) {
+_get_entity_ident(const ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   return ent->name;
 }
 
 static INLINE void
-_set_entity_ident(entity *ent, ident *id) {
+_set_entity_ident(ir_entity *ent, ident *id) {
   assert(ent && ent->kind == k_entity);
   ent->name = id;
 }
 
 static INLINE ir_type *
-_get_entity_owner(entity *ent) {
+_get_entity_owner(ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   return ent->owner = skip_tid(ent->owner);
 }
 
 static INLINE ident *
-_get_entity_ld_ident(entity *ent)
+_get_entity_ld_ident(ir_entity *ent)
 {
   assert(ent && ent->kind == k_entity);
   if (ent->ld_name == NULL)
@@ -190,67 +190,67 @@ _get_entity_ld_ident(entity *ent)
 }
 
 static INLINE void
-_set_entity_ld_ident(entity *ent, ident *ld_ident) {
+_set_entity_ld_ident(ir_entity *ent, ident *ld_ident) {
   assert(ent && ent->kind == k_entity);
   ent->ld_name = ld_ident;
 }
 
 static INLINE const char *
-_get_entity_ld_name(entity *ent) {
+_get_entity_ld_name(ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   return get_id_str(get_entity_ld_ident(ent));
 }
 
 static INLINE ir_type *
-_get_entity_type(entity *ent) {
+_get_entity_type(ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   return ent->type = skip_tid(ent->type);
 }
 
 static INLINE void
-_set_entity_type(entity *ent, ir_type *type) {
+_set_entity_type(ir_entity *ent, ir_type *type) {
   assert(ent && ent->kind == k_entity);
   ent->type = type;
 }
 
 static INLINE ir_allocation
-_get_entity_allocation(const entity *ent) {
+_get_entity_allocation(const ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   return ent->allocation;
 }
 
 static INLINE void
-_set_entity_allocation(entity *ent, ir_allocation al) {
+_set_entity_allocation(ir_entity *ent, ir_allocation al) {
   assert(ent && ent->kind == k_entity);
   ent->allocation = al;
 }
 
 static INLINE ir_visibility
-_get_entity_visibility(const entity *ent) {
+_get_entity_visibility(const ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   return ent->visibility;
 }
 
 static INLINE ir_variability
-_get_entity_variability(const entity *ent) {
+_get_entity_variability(const ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   return ent->variability;
 }
 
 static INLINE ir_volatility
-_get_entity_volatility(const entity *ent) {
+_get_entity_volatility(const ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   return ent->volatility;
 }
 
 static INLINE void
-_set_entity_volatility(entity *ent, ir_volatility vol) {
+_set_entity_volatility(ir_entity *ent, ir_volatility vol) {
   assert(ent && ent->kind == k_entity);
   ent->volatility = vol;
 }
 
 static INLINE ir_peculiarity
-_get_entity_peculiarity(const entity *ent) {
+_get_entity_peculiarity(const ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   return ent->peculiarity;
 }
@@ -263,7 +263,7 @@ _get_entity_peculiarity(const entity *ent) {
  *       I removed the assertion.  GL, 28.2.05
  */
 static INLINE void
-_set_entity_peculiarity(entity *ent, ir_peculiarity pec) {
+_set_entity_peculiarity(ir_entity *ent, ir_peculiarity pec) {
   assert(ent && ent->kind == k_entity);
   /* @@@ why peculiarity only for methods? */
   //assert(is_Method_type(ent->type));
@@ -272,37 +272,37 @@ _set_entity_peculiarity(entity *ent, ir_peculiarity pec) {
 }
 
 static INLINE ir_stickyness
-_get_entity_stickyness(const entity *ent) {
+_get_entity_stickyness(const ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   return ent->stickyness;
 }
 
 static INLINE void
-_set_entity_stickyness(entity *ent, ir_stickyness stickyness) {
+_set_entity_stickyness(ir_entity *ent, ir_stickyness stickyness) {
   assert(ent && ent->kind == k_entity);
   ent->stickyness = stickyness;
 }
 
 static INLINE int
-_get_entity_final(const entity *ent) {
+_get_entity_final(const ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   return (int)ent->final;
 }
 
 static INLINE void
-_set_entity_final(entity *ent, int final) {
+_set_entity_final(ir_entity *ent, int final) {
   assert(ent && ent->kind == k_entity);
   ent->final = final ? 1 : 0;
 }
 
 static INLINE int
-_get_entity_offset_bits(const entity *ent) {
+_get_entity_offset_bits(const ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   return ent->offset;
 }
 
 static INLINE int
-_get_entity_offset_bytes(const entity *ent) {
+_get_entity_offset_bytes(const ir_entity *ent) {
   int bits = _get_entity_offset_bits(ent);
 
   if (bits & 7) return -1;
@@ -310,30 +310,30 @@ _get_entity_offset_bytes(const entity *ent) {
 }
 
 static INLINE void
-_set_entity_offset_bits(entity *ent, int offset) {
+_set_entity_offset_bits(ir_entity *ent, int offset) {
   assert(ent && ent->kind == k_entity);
   ent->offset = offset;
 }
 
 static INLINE void
-_set_entity_offset_bytes(entity *ent, int offset) {
+_set_entity_offset_bytes(ir_entity *ent, int offset) {
   _set_entity_offset_bits(ent, offset * 8);
 }
 
 static INLINE void *
-_get_entity_link(const entity *ent) {
+_get_entity_link(const ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   return ent->link;
 }
 
 static INLINE void
-_set_entity_link(entity *ent, void *l) {
+_set_entity_link(ir_entity *ent, void *l) {
   assert(ent && ent->kind == k_entity);
   ent->link = l;
 }
 
 static INLINE ir_graph *
-_get_entity_irg(const entity *ent) {
+_get_entity_irg(const ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   assert(ent == unknown_entity || is_Method_type(ent->type));
   if (!get_visit_pseudo_irgs() && ent->attr.mtd_attr.irg
@@ -343,35 +343,35 @@ _get_entity_irg(const entity *ent) {
 }
 
 static INLINE unsigned long
-_get_entity_visited(entity *ent) {
+_get_entity_visited(ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   return ent->visit;
 }
 
 static INLINE void
-_set_entity_visited(entity *ent, unsigned long num) {
+_set_entity_visited(ir_entity *ent, unsigned long num) {
   assert(ent && ent->kind == k_entity);
   ent->visit = num;
 }
 
 static INLINE void
-_mark_entity_visited(entity *ent) {
+_mark_entity_visited(ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   ent->visit = firm_type_visited;
 }
 
 static INLINE int
-_entity_visited(entity *ent) {
+_entity_visited(ir_entity *ent) {
   return _get_entity_visited(ent) >= firm_type_visited;
 }
 
 static INLINE int
-_entity_not_visited(entity *ent) {
+_entity_not_visited(ir_entity *ent) {
   return _get_entity_visited(ent) < firm_type_visited;
 }
 
 static INLINE ir_type *
-_get_entity_repr_class(const entity *ent) {
+_get_entity_repr_class(const ir_entity *ent) {
   assert(ent && ent->kind == k_entity);
   return ent->repr_class;
 }