rename type entity into ir_entity

[r8454]

diff --git a/ir/ir/irargs.c b/ir/ir/irargs.c
index b2e292e..0085968 100644 (file)
--- a/ir/ir/irargs.c
+++ b/ir/ir/irargs.c
@@ -89,7 +89,7 @@ static int firm_emit_dbg(lc_appendable_t *app,
 /**
  * Beware: do not set the entity ld_name
  */
-static const char *get_entity_ld_name_ex(entity *ent) {
+static const char *get_entity_ld_name_ex(ir_entity *ent) {
   if (ent->ld_name)
     return get_entity_ld_name(ent);
   return get_entity_name(ent);
@@ -110,7 +110,7 @@ static int firm_emit(lc_appendable_t *app,
   char add[64];
   char buf[256];
   char tv_buf[256];
-  entity *ent;
+  ir_entity *ent;
 
   buf[0] = '\0';
   add[0] = '\0';

diff --git a/ir/ir/ircgcons.c b/ir/ir/ircgcons.c
index fdd4ba0..dc5dc87 100644 (file)
--- a/ir/ir/ircgcons.c
+++ b/ir/ir/ircgcons.c
@@ -68,7 +68,7 @@ static irg_data_t * irg_data_create(void) {
  *   - are external visible
  *   - are dereferenced somewhere within the program (i.e., the address of the
  *     method is stored somewhere). */
-static void caller_init(int arr_length, entity ** free_methods) {
+static void caller_init(int arr_length, ir_entity ** free_methods) {
   int i, j;
   for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
     set_entity_link(get_irg_entity(get_irp_irg(i)), irg_data_create());
@@ -84,7 +84,7 @@ static void caller_init(int arr_length, entity ** free_methods) {
     for (call = get_irn_link(get_irg_end(irg)); call; call = get_irn_link(call)) {
       if (get_irn_op(call) != op_Call) continue;
       for (j = get_Call_n_callees(call) - 1; j >= 0; --j) {
-        entity * ent = get_Call_callee(call, j);
+        ir_entity * ent = get_Call_callee(call, j);
         if (get_entity_irg(ent)) {
           irg_data_t * data = get_entity_link(ent);
 # ifndef CATE_jni
@@ -397,7 +397,7 @@ static void prepare_irg_end_except(ir_graph * irg, irg_data_t * data) {
 
 /* Zwischengespeicherte Daten wieder freigeben. */
 static void cleanup_irg(ir_graph * irg) {
-  entity * ent = get_irg_entity(irg);
+  ir_entity * ent = get_irg_entity(irg);
   irg_data_t * data = get_entity_link(ent);
   assert(data);
   if (data->res) DEL_ARR_F(data->res);
@@ -447,7 +447,7 @@ static void move_nodes(ir_node * from_block, ir_node * to_block, ir_node * node)
 
 /* Abhängigkeiten vom Start-Block und den Filter-Operationen im
  * Start-Block auf den Aufrufer hinzufügen. */
-static void construct_start(entity * caller, entity * callee,
+static void construct_start(ir_entity * caller, ir_entity * callee,
                            ir_node * call, ir_node * exec) {
   irg_data_t *data  = get_entity_link(callee);
   ir_graph   *irg   = get_entity_irg(callee);
@@ -594,8 +594,8 @@ static void construct_call(ir_node * call) {
   int i, n_callees;
   ir_node *post_block, *pre_block, *except_block, * proj, *jmp, *call_begin;
   ir_node ** in;
-  entity * caller;
-  entity ** callees;
+  ir_entity * caller;
+  ir_entity ** callees;
   ir_graph ** irgs;
   irg_data_t ** data;
 
@@ -611,7 +611,7 @@ static void construct_call(ir_node * call) {
 
   in = NEW_ARR_F(ir_node *, n_callees);
   caller = get_irg_entity(current_ir_graph); /* entity des aktuellen ir_graph */
-  callees = NEW_ARR_F(entity *, n_callees); /* aufgerufene Methoden: entity */
+  callees = NEW_ARR_F(ir_entity *, n_callees); /* aufgerufene Methoden: entity */
   irgs = NEW_ARR_F(ir_graph *, n_callees); /* aufgerufene Methoden: ir_graph */
   data = NEW_ARR_F(irg_data_t *, n_callees); /* aufgerufene Methoden: irg_data_t */
 
@@ -695,7 +695,7 @@ static void construct_call(ir_node * call) {
     set_interprocedural_view(1);
 
     for (i = 0; i < n_callees; ++i) {
-      entity * callee = get_Call_callee(call, i);
+      ir_entity * callee = get_Call_callee(call, i);
       if (data[i]) { /* explicit */
            if (data[i]->except) {
              in[i] = new_r_Proj(get_entity_irg(callee), get_nodes_block(data[i]->except),
@@ -798,7 +798,7 @@ static void construct_call(ir_node * call) {
 }
 
 
-void cg_construct(int arr_len, entity ** free_methods_arr) {
+void cg_construct(int arr_len, ir_entity ** free_methods_arr) {
   int i;
 
   if (get_irp_ip_view_state() == ip_view_valid) return;
@@ -813,7 +813,7 @@ void cg_construct(int arr_len, entity ** free_methods_arr) {
   /* prepare irgs */
   for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
     ir_graph * irg = get_irp_irg(i);
-    entity * ent = get_irg_entity(irg);
+    ir_entity * ent = get_irg_entity(irg);
     irg_data_t * data = get_entity_link(ent);
     if (data->count) {
       prepare_irg(irg, data);

diff --git a/ir/ir/ircgcons.h b/ir/ir/ircgcons.h
index 2aa37d3..2adbb35 100644 (file)
--- a/ir/ir/ircgcons.h
+++ b/ir/ir/ircgcons.h
@@ -42,7 +42,7 @@ void set_irp_ip_view_invalid(void);
  *                        are external visible.  These methods get an 'Unknown'
  *                        caller.
  * @arg arr_len           The number of free methods. */
-void cg_construct(int arr_len, entity *free_methods_arr[]);
+void cg_construct(int arr_len, ir_entity *free_methods_arr[]);
 
 
 /** Deconstruction of the interprocedural view.  Reduces memory consumption of

diff --git a/ir/ir/ircgopt.c b/ir/ir/ircgopt.c
index ac84200..3226798 100644 (file)
--- a/ir/ir/ircgopt.c
+++ b/ir/ir/ircgopt.c
@@ -44,12 +44,12 @@ static void collect_call(ir_node * node, void *env) {
 
 static void make_entity_to_description(type_or_ent *tore, void *env) {
   if (get_kind(tore) == k_entity) {
-    entity *ent = (entity *)tore;
+    ir_entity *ent = (ir_entity *)tore;
 
     if ((is_Method_type(get_entity_type(ent)))                        &&
         (get_entity_peculiarity(ent) != peculiarity_description)      &&
         (get_entity_visibility(ent)  != visibility_external_allocated)   ) {
-      entity *impl = get_SymConst_entity(get_atomic_ent_value(ent));
+      ir_entity *impl = get_SymConst_entity(get_atomic_ent_value(ent));
       if (get_entity_link(impl) != env) {
         set_entity_peculiarity(ent, peculiarity_description);
       }
@@ -58,7 +58,7 @@ static void make_entity_to_description(type_or_ent *tore, void *env) {
 }
 
 /* garbage collect methods: mark and remove */
-void gc_irgs(int n_keep, entity ** keep_arr) {
+void gc_irgs(int n_keep, ir_entity ** keep_arr) {
   void * MARK = &MARK; /* @@@ gefaehrlich!!! Aber wir markieren hoechstens zu viele ... */
   int i;
 
@@ -71,7 +71,7 @@ void gc_irgs(int n_keep, entity ** keep_arr) {
 
   /* Mark entities that are alive.  */
   if (n_keep > 0) {
-    entity ** marked = NEW_ARR_F(entity *, n_keep);
+    ir_entity ** marked = NEW_ARR_F(ir_entity *, n_keep);
     for (i = 0; i < n_keep; ++i) {
       marked[i] = keep_arr[i];
       set_entity_link(marked[i], MARK);
@@ -95,11 +95,11 @@ void gc_irgs(int n_keep, entity ** keep_arr) {
           assert(get_irn_op(node) == op_Call);
 
           for (i = get_Call_n_callees(node) - 1; i >= 0; --i) {
-            entity * ent = get_Call_callee(node, i);
+            ir_entity * ent = get_Call_callee(node, i);
 
             if (get_entity_irg(ent) && get_entity_link(ent) != MARK) {
               set_entity_link(ent, MARK);
-              ARR_APP1(entity *, marked, ent);
+              ARR_APP1(ir_entity *, marked, ent);
               if (get_opt_dead_method_elimination_verbose() && get_firm_verbosity() > 2) {
                 printf("dead method elimination: method %s can be called from Call %ld: kept alive.\n",
                       get_entity_ld_name(ent), get_irn_node_nr(node));
@@ -116,7 +116,7 @@ void gc_irgs(int n_keep, entity ** keep_arr) {
   type_walk(make_entity_to_description, NULL, MARK);
   for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
     ir_graph * irg = get_irp_irg(i);
-    entity * ent = get_irg_entity(irg);
+    ir_entity * ent = get_irg_entity(irg);
     /* Removing any graph invalidates all interprocedural loop trees. */
     if (get_irg_loopinfo_state(irg) == loopinfo_ip_consistent ||
         get_irg_loopinfo_state(irg) == loopinfo_ip_inconsistent) {

diff --git a/ir/ir/ircgopt.h b/ir/ir/ircgopt.h
index e170bf0..aaa50c0 100644 (file)
--- a/ir/ir/ircgopt.h
+++ b/ir/ir/ircgopt.h
@@ -29,6 +29,6 @@
  * ueberschrieben.
  *
  * Frees all interprocedural loop information. */
-void gc_irgs(int n_keep, entity *keep_arr[]);
+void gc_irgs(int n_keep, ir_entity *keep_arr[]);
 
 #endif /* _FIRM_IR_ICGOPT_H_ */

diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c
index 175b2ef..d3f86d6 100644 (file)
--- a/ir/ir/irdump.c
+++ b/ir/ir/irdump.c
@@ -289,7 +289,7 @@ static void print_type_type_edge(FILE *F, ir_type *S, ir_type *T, const char *fm
  * prints the edge from a type T to an entity E with additional info fmt, ...
  * to the file F
  */
-static void print_type_ent_edge(FILE *F, ir_type *T, entity *E, const char *fmt, ...)
+static void print_type_ent_edge(FILE *F, ir_type *T, ir_entity *E, const char *fmt, ...)
 {
   va_list ap;
 
@@ -305,7 +305,7 @@ static void print_type_ent_edge(FILE *F, ir_type *T, entity *E, const char *fmt,
  * prints the edge from an entity E to an entity T with additional info fmt, ...
  * to the file F
  */
-static void print_ent_ent_edge(FILE *F, entity *E, entity *T, int backedge, const char *fmt, ...)
+static void print_ent_ent_edge(FILE *F, ir_entity *E, ir_entity *T, int backedge, const char *fmt, ...)
 {
   va_list ap;
 
@@ -325,7 +325,7 @@ static void print_ent_ent_edge(FILE *F, entity *E, entity *T, int backedge, cons
  * prints the edge from an entity E to a type T with additional info fmt, ...
  * to the file F
  */
-static void print_ent_type_edge(FILE *F, entity *E, ir_type *T, const char *fmt, ...)
+static void print_ent_type_edge(FILE *F, ir_entity *E, ir_type *T, const char *fmt, ...)
 {
   va_list ap;
 
@@ -357,7 +357,7 @@ static void print_node_type_edge(FILE *F, const ir_node *N, ir_type *T, const ch
  * prints the edge from a node N to an entity E with additional info fmt, ...
  * to the file F
  */
-static void print_node_ent_edge(FILE *F, const ir_node *N, entity *E, const char *fmt, ...)
+static void print_node_ent_edge(FILE *F, const ir_node *N, ir_entity *E, const char *fmt, ...)
 {
   va_list ap;
 
@@ -374,7 +374,7 @@ static void print_node_ent_edge(FILE *F, const ir_node *N, entity *E, const char
  * prints the edge from an entity E to a node N with additional info fmt, ...
  * to the file F
  */
-static void print_ent_node_edge(FILE *F, entity *E, const ir_node *N, const char *fmt, ...)
+static void print_ent_node_edge(FILE *F, ir_entity *E, const ir_node *N, const char *fmt, ...)
 {
   va_list ap;
 
@@ -485,7 +485,7 @@ static void clear_link(ir_node * node, void * env) {
  * If the entity has a ld_name, returns it if the dump_ld_name is set,
  * else returns the name of the entity.
  */
-static const char *_get_ent_dump_name(entity *ent, int dump_ld_name) {
+static const char *_get_ent_dump_name(ir_entity *ent, int dump_ld_name) {
   if (!ent)
     return "<NULL entity>";
   if (dump_ld_name) {
@@ -499,7 +499,7 @@ static const char *_get_ent_dump_name(entity *ent, int dump_ld_name) {
  * If the entity has a ld_name, returns it if the option dump_ld_name is set,
  * else returns the name of the entity.
  */
-const char *get_ent_dump_name(entity *ent) {
+const char *get_ent_dump_name(ir_entity *ent) {
   return _get_ent_dump_name(ent, dump_ld_name);
 }
 
@@ -726,7 +726,7 @@ int dump_node_opcode(FILE *F, ir_node *n)
   }
   case iro_CallBegin: {
     ir_node *addr = get_CallBegin_ptr(n);
-    entity *ent = NULL;
+    ir_entity *ent = NULL;
     if (get_irn_op(addr) == op_Sel)
       ent = get_Sel_entity(addr);
     else if ((get_irn_op(addr) == op_SymConst) && (get_SymConst_kind(addr) == symconst_addr_ent))
@@ -1636,7 +1636,7 @@ static void dump_graph_info(FILE *F, ir_graph *irg) {
  *  If interprocedural view edges can point to nodes out of this graph.
  */
 static void dump_graph_from_list(FILE *F, ir_graph *irg) {
-  entity *ent = get_irg_entity(irg);
+  ir_entity *ent = get_irg_entity(irg);
 
   fprintf(F, "graph: { title: \"");
   PRINT_IRGID(irg);
@@ -1846,7 +1846,7 @@ int dump_type_node(FILE *F, ir_type *tp)
 
 
 #define X(a)    case a: fprintf(F, #a); break
-void dump_entity_node(FILE *F, entity *ent, int color)
+void dump_entity_node(FILE *F, ir_entity *ent, int color)
 {
   fprintf (F, "node: {title: \"");
   PRINT_ENTID(ent); fprintf(F, "\"");
@@ -1897,7 +1897,7 @@ dump_type_info(type_or_ent *tore, void *env) {
   switch (get_kind(tore)) {
   case k_entity:
     {
-      entity *ent = (entity *)tore;
+      ir_entity *ent = (ir_entity *)tore;
       ir_node *value;
       /* The node */
       dump_entity_node(F, ent, 0);
@@ -2024,7 +2024,7 @@ dump_class_hierarchy_node (type_or_ent *tore, void *ctx) {
   /* dump this type or entity */
   switch (get_kind(tore)) {
   case k_entity: {
-    entity *ent = (entity *)tore;
+    ir_entity *ent = (ir_entity *)tore;
     if (get_entity_owner(ent) == get_glob_type()) break;
     if (!is_Method_type(get_entity_type(ent))) break;  /* GL */
     if (env->dump_ent && is_Class_type(get_entity_owner(ent))) {
@@ -2429,7 +2429,7 @@ void dump_ir_extblock_graph (ir_graph *irg, const char *suffix)
   FILE *F;
   int i;
   char *suffix1;
-  entity *ent;
+  ir_entity *ent;
 
   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
     return;
@@ -2725,7 +2725,7 @@ static int compute_color (int my, int max) {
   return base_color + n_colors - color;
 }
 
-static int get_entity_color(entity *ent) {
+static int get_entity_color(ir_entity *ent) {
   ir_graph *irg = get_entity_irg(ent);
   assert(irg);
 
@@ -2758,7 +2758,7 @@ void dump_callgraph(const char *suffix) {
 
   for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
     ir_graph *irg = get_irp_irg(i);
-    entity *ent = get_irg_entity(irg);
+    ir_entity *ent = get_irg_entity(irg);
     int j, n_callees = get_irg_n_callees(irg);
 
     /* Do not dump runtime system. */
@@ -2766,7 +2766,7 @@ void dump_callgraph(const char *suffix) {
 
     dump_entity_node(F, ent, get_entity_color(ent));
     for (j = 0; j < n_callees; ++j) {
-      entity *c = get_irg_entity(get_irg_callee(irg, j));
+      ir_entity *c = get_irg_entity(get_irg_callee(irg, j));
       //if (id_is_prefix(prefix, get_entity_ld_ident(c))) continue;
       int be = is_irg_callee_backedge(irg, j);
       char *attr;

diff --git a/ir/ir/irdump.h b/ir/ir/irdump.h
index 40a767f..c5112ee 100644 (file)
--- a/ir/ir/irdump.h
+++ b/ir/ir/irdump.h
@@ -510,12 +510,12 @@ typedef enum {
 
 /** Write the entity and all its attributes to the passed file.
  *  */
-void    dump_entity_to_file (FILE *F, entity *ent, unsigned verbosity);
+void    dump_entity_to_file (FILE *F, ir_entity *ent, unsigned verbosity);
 
 /** Write the entity and all its attributes to the stdout.
  *
  *  Calls dump_entity_to_file().  */
-void    dump_entity (entity *ent);
+void    dump_entity (ir_entity *ent);
 
 /** Write the type and all its attributes to the file passed.
  * */

diff --git a/ir/ir/irdump_t.h b/ir/ir/irdump_t.h
index 0df5f36..8067418 100644 (file)
--- a/ir/ir/irdump_t.h
+++ b/ir/ir/irdump_t.h
@@ -69,7 +69,7 @@ const char *get_irg_dump_name(ir_graph *irg);
 void vcg_close (FILE *F);
 
 
-const char *get_ent_dump_name(entity *ent);
+const char *get_ent_dump_name(ir_entity *ent);
 const char *get_type_name_ex(ir_type *tp, int *bad);
 const char *get_mode_name_ex(ir_mode *mode, int *bad);
 /**

diff --git a/ir/ir/irdumptxt.c b/ir/ir/irdumptxt.c
index 2308b66..e6bd0e7 100644 (file)
--- a/ir/ir/irdumptxt.c
+++ b/ir/ir/irdumptxt.c
@@ -223,7 +223,7 @@ int dump_irnode_to_file(FILE *F, ir_node *n) {
     fprintf(F, "  allocated on: the %s\n", (get_Free_where(n) == stack_alloc) ? "stack" : "heap");
   } break;
   case iro_Sel: {
-    entity *ent = get_Sel_entity(n);
+    ir_entity *ent = get_Sel_entity(n);
     if (ent) {
       fprintf(F, "  Selecting entity %s (%ld)\n", get_entity_name(ent), get_entity_nr(ent));
       fprintf(F, "    of type    %s\n",  get_type_name_ex(get_entity_type(ent),  &bad));
@@ -476,7 +476,7 @@ static void dump_type_list(FILE *F, ir_type *tp, char *prefix,
   fprintf(F, "\n");
 }
 
-void    dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned verbosity) {
+void    dump_entity_to_file_prefix (FILE *F, ir_entity *ent, char *prefix, unsigned verbosity) {
   int i, j;
   ir_type *owner, *type;
 
@@ -498,7 +498,7 @@ void    dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned
       if (get_entity_n_overwrites(ent) > 0) {
         fprintf(F, "%s  overwrites:\n", prefix);
         for (i = 0; i < get_entity_n_overwrites(ent); ++i) {
-               entity *ov = get_entity_overwrites(ent, i);
+               ir_entity *ov = get_entity_overwrites(ent, i);
                fprintf(F, "%s    %d: %s of class %s\n", prefix, i, get_entity_name(ov),
                        get_type_name(get_entity_owner(ov)));
         }
@@ -508,7 +508,7 @@ void    dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned
       if (get_entity_n_overwrittenby(ent) > 0) {
         fprintf(F, "%s  overwritten by:\n", prefix);
         for (i = 0; i < get_entity_n_overwrittenby(ent); ++i) {
-               entity *ov = get_entity_overwrittenby(ent, i);
+               ir_entity *ov = get_entity_overwrittenby(ent, i);
                fprintf(F, "%s    %d: %s of class %s\n", prefix, i, get_entity_name(ov),
                        get_type_name(get_entity_owner(ov)));
         }
@@ -517,7 +517,7 @@ void    dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned
       }
 
       if (get_irp_inh_transitive_closure_state() != inh_transitive_closure_none) {
-        entity *ov;
+        ir_entity *ov;
         fprintf(F, "%s  transitive overwrites:\n", prefix);
         for (ov = get_entity_trans_overwrites_first(ent);
                   ov;
@@ -597,13 +597,13 @@ void    dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned
                compute_compound_ent_array_indices(ent);
         for (i = 0; i < get_compound_ent_n_values(ent); ++i) {
           compound_graph_path *path = get_compound_ent_value_path(ent, i);
-          entity *ent0 = get_compound_graph_path_node(path, 0);
+          ir_entity *ent0 = get_compound_graph_path_node(path, 0);
           fprintf(F, "\n%s    %3d:%d ", prefix, get_entity_offset(ent0), get_entity_offset_bits_remainder(ent0));
           if (get_type_state(type) == layout_fixed)
             fprintf(F, "(%3d:%d) ",   get_compound_ent_value_offset_bytes(ent, i), get_compound_ent_value_offset_bit_remainder(ent, i));
           fprintf(F, "%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);
             fprintf(F, ".%s", get_entity_name(node));
             if (is_Array_type(get_entity_owner(node)))
               fprintf(F, "[%d]", get_compound_graph_path_array_index(path, j));
@@ -759,16 +759,16 @@ void    dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned
 
 }
 
-void    dump_entity_to_file (FILE *F, entity *ent, unsigned verbosity) {
+void    dump_entity_to_file (FILE *F, ir_entity *ent, unsigned verbosity) {
   dump_entity_to_file_prefix (F, ent, "", verbosity);
   fprintf(F, "\n");
 }
 
-void dump_entity (entity *ent) {
+void dump_entity (ir_entity *ent) {
   dump_entity_to_file(stdout, ent, dump_verbosity_max);
 }
 
-void    dump_entitycsv_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned verbosity,
+void    dump_entitycsv_to_file_prefix (FILE *F, ir_entity *ent, char *prefix, unsigned verbosity,
                                       int *max_disp, int disp[], const char *comma) {
 
 #if 0   /* Outputs loop depth of all occurrences. */
@@ -913,7 +913,7 @@ void dump_typecsv_to_file(FILE *F, ir_type *tp, dump_verbosity verbosity, const
     fprintf(F, "\n");
 
     for (i = 0; i < get_class_n_members(tp); ++i) {
-      entity *mem = get_class_member(tp, i);
+      ir_entity *mem = get_class_member(tp, i);
       if (((verbosity & dump_verbosity_methods) &&  is_Method_type(get_entity_type(mem))) ||
                ((verbosity & dump_verbosity_fields)  && !is_Method_type(get_entity_type(mem)))   ) {
         if (!((verbosity & dump_verbosity_nostatic) && (get_entity_allocation(mem) == allocation_static))) {
@@ -943,7 +943,7 @@ void dump_typecsv_to_file(FILE *F, ir_type *tp, dump_verbosity verbosity, const
     }
 
     for (i = 0; i < get_class_n_members(tp); ++i) {
-      entity *mem = get_class_member(tp, i);
+      ir_entity *mem = get_class_member(tp, i);
       if (((verbosity & dump_verbosity_methods) &&  is_Method_type(get_entity_type(mem))) ||
                ((verbosity & dump_verbosity_fields)  && !is_Method_type(get_entity_type(mem)))   ) {
         if (!((verbosity & dump_verbosity_nostatic) && (get_entity_allocation(mem) == allocation_static))) {
@@ -976,7 +976,7 @@ void dump_type_to_file (FILE *F, ir_type *tp, dump_verbosity verbosity) {
       fprintf(F, "\n  members: \n");
     }
     for (i = 0; i < get_class_n_members(tp); ++i) {
-      entity *mem = get_class_member(tp, i);
+      ir_entity *mem = get_class_member(tp, i);
       if (((verbosity & dump_verbosity_methods) &&  is_Method_type(get_entity_type(mem))) ||
                ((verbosity & dump_verbosity_fields)  && !is_Method_type(get_entity_type(mem)))   ) {
         if (!((verbosity & dump_verbosity_nostatic) && (get_entity_allocation(mem) == allocation_static))) {
@@ -1028,7 +1028,7 @@ void dump_type_to_file (FILE *F, ir_type *tp, dump_verbosity verbosity) {
   case tpo_struct:
     if (verbosity & dump_verbosity_fields) fprintf(F, "\n  members: ");
     for (i = 0; i < get_compound_n_members(tp); ++i) {
-      entity *mem = get_compound_member(tp, i);
+      ir_entity *mem = get_compound_member(tp, i);
       if (verbosity & dump_verbosity_fields) {
              dump_entity_to_file_prefix(F, mem, "    ", verbosity);
       }
@@ -1240,7 +1240,7 @@ void dump_globals_as_text(unsigned verbosity, const char *suffix) {
   }
 
   for (i = 0; i < n_mems; ++i) {
-    entity *e = get_class_member(g, i);
+    ir_entity *e = get_class_member(g, i);
 
     dump_entity_to_file(F, e, verbosity);
     if (CSV) {

diff --git a/ir/ir/irgopt.c b/ir/ir/irgopt.c
index 574ac02..4a9305a 100644 (file)
--- a/ir/ir/irgopt.c
+++ b/ir/ir/irgopt.c
@@ -1046,7 +1046,7 @@ int inline_method(ir_node *call, ir_graph *called_graph) {
   /* copy the entities. */
   called_frame = get_irg_frame_type(called_graph);
   for (i = 0; i < get_class_n_members(called_frame); i++) {
-    entity *new_ent, *old_ent;
+    ir_entity *new_ent, *old_ent;
     old_ent = get_class_member(called_frame, i);
     new_ent = copy_entity_own(old_ent, get_cur_frame_type());
     set_entity_link(old_ent, new_ent);
@@ -1410,7 +1410,7 @@ static void collect_calls2(ir_node *call, void *ctx) {
     ir_node *symc = get_Call_ptr(call);
 
     if (is_SymConst(symc) && get_SymConst_kind(symc) == symconst_addr_ent) {
-      entity *ent = get_SymConst_entity(symc);
+      ir_entity *ent = get_SymConst_entity(symc);
 
       if (get_entity_additional_properties(ent) & mtp_property_runtime)
         return;

diff --git a/ir/ir/irgraph.c b/ir/ir/irgraph.c
index 76a0925..f84f4e7 100644 (file)
--- a/ir/ir/irgraph.c
+++ b/ir/ir/irgraph.c
@@ -130,7 +130,7 @@ void free_Phi_in_stack(Phi_in_stack *s);
    and optimization.
 */
 ir_graph *
-new_r_ir_graph (entity *ent, int n_loc)
+new_r_ir_graph (ir_entity *ent, int n_loc)
 {
   ir_graph *res;
   ir_node  *first_block;
@@ -263,7 +263,7 @@ new_r_ir_graph (entity *ent, int n_loc)
 
 
 ir_graph *
-new_ir_graph(entity *ent, int n_loc)
+new_ir_graph(ir_entity *ent, int n_loc)
 {
   ir_graph *res = new_r_ir_graph(ent, n_loc);
   add_irp_irg(res);          /* remember this graph global. */
@@ -564,13 +564,13 @@ void
   _set_irg_current_block(irg, node);
 }
 
-entity *
+ir_entity *
 (get_irg_entity)(const ir_graph *irg) {
   return _get_irg_entity(irg);
 }
 
 void
-(set_irg_entity)(ir_graph *irg, entity *ent) {
+(set_irg_entity)(ir_graph *irg, ir_entity *ent) {
   _set_irg_entity(irg, ent);
 }
 

diff --git a/ir/ir/irgraph.h b/ir/ir/irgraph.h
index 897fac8..ab65fbe 100644 (file)
--- a/ir/ir/irgraph.h
+++ b/ir/ir/irgraph.h
@@ -162,7 +162,7 @@ void set_interprocedural_view(int state);
  *
  * @see new_pseudo_ir_graph()
  */
-ir_graph *new_ir_graph (entity *ent, int n_loc);
+ir_graph *new_ir_graph (ir_entity *ent, int n_loc);
 
 /** Frees the passed irgraph.
  * Deallocates all nodes in this graph and the ir_graph structure.
@@ -188,8 +188,8 @@ int      is_ir_graph(const void *thing);
 
 /* #define get_irg_entity get_irg_ent */
 /* #define set_irg_entity set_irg_ent */
-entity  *get_irg_entity (const ir_graph *irg);
-void     set_irg_entity (ir_graph *irg, entity *ent);
+ir_entity *get_irg_entity (const ir_graph *irg);
+void       set_irg_entity (ir_graph *irg, ir_entity *ent);
 
 ir_type *get_irg_frame_type (ir_graph *irg);
 void     set_irg_frame_type (ir_graph *irg, ir_type *ftp);

diff --git a/ir/ir/irgraph_t.h b/ir/ir/irgraph_t.h
index 9190df0..39ea3a8 100644 (file)
--- a/ir/ir/irgraph_t.h
+++ b/ir/ir/irgraph_t.h
@@ -77,11 +77,11 @@ enum irg_anchors {
 
 /** ir_graph holds all information for a procedure */
 struct ir_graph {
-  firm_kind         kind;            /**<  always set to k_ir_graph*/
+  firm_kind         kind;        /**<  always set to k_ir_graph*/
   /* --  Basics of the representation -- */
-  entity  *ent;           /**< The entity of this procedure, i.e.,
-                    the type of the procedure and the
-                    class it belongs to. */
+  ir_entity  *ent;               /**< The entity of this procedure, i.e.,
+                                      the type of the procedure and the
+                                      class it belongs to. */
   ir_type *frame_type;           /**< A class type representing the stack frame.
                                       Can include "inner" methods. */
   ir_node *anchors[anchor_max];  /**< anchor nodes */
@@ -162,7 +162,7 @@ struct ir_graph {
 void firm_init_irgraph(void);
 
 /* Internal constructor that does not add to irp_irgs or the like. */
-ir_graph *new_r_ir_graph (entity *ent, int n_loc);
+ir_graph *new_r_ir_graph (ir_entity *ent, int n_loc);
 
 /** Make a rudimentary ir graph for the constant code.
    Must look like a correct irg, spare everything else. */
@@ -354,14 +354,14 @@ _set_irg_current_block(ir_graph *irg, ir_node *node) {
   irg->current_block = node;
 }
 
-static INLINE entity *
+static INLINE ir_entity *
 _get_irg_entity(const ir_graph *irg) {
   assert(irg && irg->ent);
   return irg->ent;
 }
 
 static INLINE void
-_set_irg_entity(ir_graph *irg, entity *ent) {
+_set_irg_entity(ir_graph *irg, ir_entity *ent) {
   irg->ent = ent;
 }
 

diff --git a/ir/ir/irgwalk.c b/ir/ir/irgwalk.c
index ef9a79f..439964d 100644 (file)
--- a/ir/ir/irgwalk.c
+++ b/ir/ir/irgwalk.c
@@ -119,7 +119,7 @@ static void collect_irgs(ir_node * node, eset * irg_set) {
   if (is_Call(node)) {
     int i;
     for (i = get_Call_n_callees(node) - 1; i >= 0; --i) {
-      entity * ent = get_Call_callee(node, i);
+      ir_entity * ent = get_Call_callee(node, i);
       ir_graph * irg = get_entity_irg(ent);
       if (irg && !eset_contains(irg_set, irg)) {
         eset_insert(irg_set, irg);
@@ -665,7 +665,7 @@ typedef struct walk_env {
 /**
  * Walk to all constant expressions in this entity.
  */
-static void walk_entity(entity *ent, void *env)
+static void walk_entity(ir_entity *ent, void *env)
 {
   walk_env *my_env = (walk_env *)env;
 

diff --git a/ir/ir/irhooks.h b/ir/ir/irhooks.h
index 4843ee7..bc61bd7 100644 (file)
--- a/ir/ir/irhooks.h
+++ b/ir/ir/irhooks.h
@@ -100,7 +100,7 @@ typedef struct hook_entry {
 
     /** This hook is called, after a new graph was created and before the first block
      *  on this graph is build. */
-    void (*_hook_new_graph)(void *context, ir_graph *irg, entity *ent);
+    void (*_hook_new_graph)(void *context, ir_graph *irg, ir_entity *ent);
 
     /** This hook is called before a graph is freed. */
     void (*_hook_free_graph)(void *context, ir_graph *irg);
@@ -155,7 +155,7 @@ typedef struct hook_entry {
     void (*_hook_new_mode)(void *context, const ir_mode *tmpl, ir_mode *mode);
 
     /** This hook is called after a new entity was created. */
-    void (*_hook_new_entity)(void *context, entity *ent);
+    void (*_hook_new_entity)(void *context, ir_entity *ent);
 
     /** This hook is called after a new type was created. */
     void (*_hook_new_type)(void *context, ir_type *tp);

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index df556c2..cee3933 100644 (file)
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -1114,12 +1114,12 @@ set_SymConst_name (ir_node *node, ident *name) {
 
 
 /* Only to access SymConst of kind symconst_addr_ent.  Else assertion: */
-entity   *get_SymConst_entity (ir_node *node) {
+ir_entity *get_SymConst_entity (ir_node *node) {
   assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
   return node->attr.symc.sym.entity_p;
 }
 
-void     set_SymConst_entity (ir_node *node, entity *ent) {
+void     set_SymConst_entity (ir_node *node, ir_entity *ent) {
   assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
   node->attr.symc.sym.entity_p  = ent;
 }
@@ -1211,14 +1211,14 @@ set_Sel_index (ir_node *node, int pos, ir_node *index) {
   set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
 }
 
-entity *
+ir_entity *
 get_Sel_entity (ir_node *node) {
   assert(node->op == op_Sel);
   return node->attr.sel.ent;
 }
 
 void
-set_Sel_entity (ir_node *node, entity *ent) {
+set_Sel_entity (ir_node *node, ir_entity *ent) {
   assert(node->op == op_Sel);
   node->attr.sel.ent = ent;
 }
@@ -1316,17 +1316,17 @@ int get_Call_n_callees(ir_node * node) {
   return ARR_LEN(node->attr.call.callee_arr);
 }
 
-entity * get_Call_callee(ir_node * node, int pos) {
+ir_entity * get_Call_callee(ir_node * node, int pos) {
   assert(pos >= 0 && pos < get_Call_n_callees(node));
   return node->attr.call.callee_arr[pos];
 }
 
-void set_Call_callee_arr(ir_node * node, const int n, entity ** arr) {
+void set_Call_callee_arr(ir_node * node, const int n, ir_entity ** arr) {
   assert(node->op == op_Call);
   if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
-    node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
+    node->attr.call.callee_arr = NEW_ARR_D(ir_entity *, current_ir_graph->obst, n);
   }
-  memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
+  memcpy(node->attr.call.callee_arr, arr, n * sizeof(ir_entity *));
 }
 
 void remove_Call_callee_arr(ir_node * node) {
@@ -2729,7 +2729,7 @@ ir_type *(get_irn_type_attr)(ir_node *node) {
 }
 
 /* Return the entity attribute of a node n (SymConst, Sel) or NULL. */
-entity *(get_irn_entity_attr)(ir_node *node) {
+ir_entity *(get_irn_entity_attr)(ir_node *node) {
   return _get_irn_entity_attr(node);
 }
 
@@ -2821,7 +2821,7 @@ static ir_type *get_SymConst_attr_type(ir_node *self) {
 }
 
 /** Return the attribute entity of a SymConst node if exists */
-static entity *get_SymConst_attr_entity(ir_node *self) {
+static ir_entity *get_SymConst_attr_entity(ir_node *self) {
   symconst_kind kind = get_SymConst_kind(self);
   if (SYMCONST_HAS_ENT(kind))
     return get_SymConst_entity(self);
@@ -2852,7 +2852,7 @@ ir_op_ops *firm_set_default_get_type_attr(opcode code, ir_op_ops *ops)
 }
 
 /** the get_entity_attr operation must be always implemented */
-static entity *get_Null_ent(ir_node *n) {
+static ir_entity *get_Null_ent(ir_node *n) {
   return NULL;
 }
 

diff --git a/ir/ir/irnode.h b/ir/ir/irnode.h
index 4af34a6..11756cb 100644 (file)
--- a/ir/ir/irnode.h
+++ b/ir/ir/irnode.h
@@ -522,7 +522,7 @@ typedef enum {
 typedef union symconst_symbol {
   ir_type       *type_p;    /**< the type of a symconst */
   ident         *ident_p;   /**< the ident of a symconst */
-  entity        *entity_p;  /**< the entity of a symconst */
+  ir_entity     *entity_p;  /**< the entity of a symconst */
   ir_enum_const *enum_p;    /**< the enumeration constant of a symconst */
 } symconst_symbol;
 
@@ -540,8 +540,8 @@ ident   *get_SymConst_name(ir_node *node);
 void     set_SymConst_name(ir_node *node, ident *name);
 
 /** Only to access SymConst of kind addr_ent.  Else assertion: */
-entity  *get_SymConst_entity(ir_node *node);
-void     set_SymConst_entity(ir_node *node, entity *ent);
+ir_entity *get_SymConst_entity(ir_node *node);
+void       set_SymConst_entity(ir_node *node, ir_entity *ent);
 
 /** Only to access SymConst of kind symconst_enum_const.  Else assertion: */
 ir_enum_const *get_SymConst_enum(ir_node *node);
@@ -560,16 +560,16 @@ void                  set_SymConst_symbol(ir_node *node,
 ir_type *get_SymConst_value_type(ir_node *node);
 void    set_SymConst_value_type(ir_node *node, ir_type *tp);
 
-ir_node *get_Sel_mem(ir_node *node);
-void     set_Sel_mem(ir_node *node, ir_node *mem);
-ir_node *get_Sel_ptr(ir_node *node);  /* ptr to the object to select from */
-void     set_Sel_ptr(ir_node *node, ir_node *ptr);
-ir_node **get_Sel_index_arr(ir_node *node);
-int      get_Sel_n_indexs(ir_node *node);
-ir_node *get_Sel_index(ir_node *node, int pos);
-void     set_Sel_index(ir_node *node, int pos, ir_node *index);
-entity  *get_Sel_entity(ir_node *node); /* entity to select */
-void     set_Sel_entity (ir_node *node, entity *ent);
+ir_node   *get_Sel_mem(ir_node *node);
+void       set_Sel_mem(ir_node *node, ir_node *mem);
+ir_node   *get_Sel_ptr(ir_node *node);  /* ptr to the object to select from */
+void       set_Sel_ptr(ir_node *node, ir_node *ptr);
+ir_node   **get_Sel_index_arr(ir_node *node);
+int        get_Sel_n_indexs(ir_node *node);
+ir_node   *get_Sel_index(ir_node *node, int pos);
+void       set_Sel_index(ir_node *node, int pos, ir_node *index);
+ir_entity *get_Sel_entity(ir_node *node); /* entity to select */
+void       set_Sel_entity (ir_node *node, ir_entity *ent);
 
 /**
  * Projection numbers for result of Call node: use for Proj nodes!
@@ -621,14 +621,14 @@ int      get_Call_arity(ir_node *node);
  *
  *  @param node A Call node.
  */
-int     Call_has_callees(ir_node *node);
-int     get_Call_n_callees(ir_node *node);
-entity *get_Call_callee(ir_node *node, int pos);
+int        Call_has_callees(ir_node *node);
+int        get_Call_n_callees(ir_node *node);
+ir_entity *get_Call_callee(ir_node *node, int pos);
 
 /** Set the full callee array.
  *
  *  The passed array is copied. Assumes current_ir_graph set properly! */
-void    set_Call_callee_arr(ir_node *node, const int n, entity **arr);
+void    set_Call_callee_arr(ir_node *node, const int n, ir_entity **arr);
 void    remove_Call_callee_arr(ir_node *node);
 
 ir_node  *get_CallBegin_ptr(ir_node *node);
@@ -1204,7 +1204,7 @@ ir_type *get_irn_type(ir_node *n);
 ir_type *get_irn_type_attr(ir_node *n);
 
 /** Return the entity attribute of a node n (SymConst, Sel) or NULL. */
-entity *get_irn_entity_attr(ir_node *n);
+ir_entity *get_irn_entity_attr(ir_node *n);
 
 /** Returns non-zero for constant-like nodes. */
 int is_irn_constlike(const ir_node *node);

diff --git a/ir/ir/irnode_t.h b/ir/ir/irnode_t.h
index 77840fb..251e604 100644 (file)
--- a/ir/ir/irnode_t.h
+++ b/ir/ir/irnode_t.h
@@ -93,7 +93,7 @@ typedef struct {
 
 /** Sel attributes. */
 typedef struct {
-  entity *ent;          /**< entity to select */
+  ir_entity *ent;          /**< entity to select */
 } sel_attr;
 
 /** Exception attributes. */
@@ -110,7 +110,7 @@ typedef struct {
 typedef struct {
   except_attr    exc;           /**< the exception attribute. MUST be the first one. */
   ir_type *cld_tp;              /**< type of called procedure */
-  entity ** callee_arr;         /**< result of callee analysis */
+  ir_entity ** callee_arr;      /**< result of callee analysis */
 } call_attr;
 
 /** Alloc attributes. */
@@ -887,7 +887,7 @@ static INLINE ir_type *_get_irn_type_attr(ir_node *node) {
   return _get_irn_op(node)->ops.get_type_attr(node);
 }
 
-static INLINE entity *_get_irn_entity_attr(ir_node *node) {
+static INLINE ir_entity *_get_irn_entity_attr(ir_node *node) {
   return _get_irn_op(node)->ops.get_entity_attr(node);
 }
 

diff --git a/ir/ir/irop.h b/ir/ir/irop.h
index bd6cf7c..9604dbd 100644 (file)
--- a/ir/ir/irop.h
+++ b/ir/ir/irop.h
@@ -281,7 +281,7 @@ typedef ir_type *(*get_type_attr_func)(ir_node *self);
  * accessed from an ir_graph.
  * Return the entity attribute of the node self.
  */
-typedef entity *(*get_entity_attr_func)(ir_node *self);
+typedef ir_entity *(*get_entity_attr_func)(ir_node *self);
 
 /**
  * The verify_node operation.

diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c
index 1711aa0..b3ae4da 100644 (file)
--- a/ir/ir/iropt.c
+++ b/ir/ir/iropt.c
@@ -58,8 +58,8 @@ static tarval *computed_value_Const(ir_node *n) {
  * Return the value of a 'sizeof' or 'alignof' SymConst.
  */
 static tarval *computed_value_SymConst(ir_node *n) {
-  ir_type *type;
-  entity  *ent;
+  ir_type   *type;
+  ir_entity *ent;
 
   switch (get_SymConst_kind(n)) {
   case symconst_type_size:

diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c
index 06825ba..d3edd6b 100644 (file)
--- a/ir/ir/irvrfy.c
+++ b/ir/ir/irvrfy.c
@@ -64,7 +64,7 @@ static void show_entity_failure(ir_node *node)
     fprintf(stderr, "\nFIRM: irn_vrfy_irg() <of CONST_CODE_IRG> failed\n");
   }
   else {
-    entity *ent = get_irg_entity(irg);
+    ir_entity *ent = get_irg_entity(irg);
 
     if (ent) {
       ir_type *ent_type = get_entity_owner(ent);
@@ -183,7 +183,7 @@ static void show_proj_mode_failure(ir_node *n, ir_type *ty)
 /**
  * Prints a failure message for a proj
  */
-static void show_proj_failure_ent(ir_node *n, entity *ent)
+static void show_proj_failure_ent(ir_node *n, ir_entity *ent)
 {
   ir_node *op  = get_Proj_pred(n);
   int proj     = get_Proj_proj(n);
@@ -232,7 +232,7 @@ static void show_call_param(ir_node *n, ir_type *mt)
  */
 static void show_return_modes(ir_graph *irg, ir_node *n, ir_type *mt, int i)
 {
-  entity *ent = get_irg_entity(irg);
+  ir_entity *ent = get_irg_entity(irg);
 
   show_entity_failure(n);
   fprintf(stderr, "  Return node %ld in entity \"%s\" mode %s different from type mode %s\n",
@@ -247,7 +247,7 @@ static void show_return_modes(ir_graph *irg, ir_node *n, ir_type *mt, int i)
  */
 static void show_return_nres(ir_graph *irg, ir_node *n, ir_type *mt)
 {
-  entity *ent = get_irg_entity(irg);
+  ir_entity *ent = get_irg_entity(irg);
 
   show_entity_failure(n);
   fprintf(stderr, "  Return node %ld in entity \"%s\" has %d results different from type %d\n",
@@ -278,7 +278,7 @@ static void show_phi_inputs(ir_node *phi, ir_node *block)
 }
 
 /** If the address is Sel or SymConst, return the entity. */
-static entity *get_ptr_entity(ir_node *ptr) {
+static ir_entity *get_ptr_entity(ir_node *ptr) {
   if (get_irn_op(ptr) == op_Sel) {
     return get_Sel_entity(ptr);
   } else if ((get_irn_op(ptr) == op_SymConst) && (get_SymConst_kind(ptr) == symconst_addr_ent)) {
@@ -512,7 +512,7 @@ static int verify_node_Proj_Load(ir_node *n, ir_node *p) {
 
   if (proj == pn_Load_res) {
     ir_node *ptr = get_Load_ptr(n);
-    entity *ent = get_ptr_entity(ptr);
+    ir_entity *ent = get_ptr_entity(ptr);
 
     if (vrfy_entities && ent && get_irg_phase_state(current_ir_graph) == phase_high) {
       /* do NOT check this for lowered phases, see comment on Store */
@@ -953,7 +953,7 @@ static int verify_node_SymConst(ir_node *n, ir_graph *irg) {
   ir_mode *mymode = get_irn_mode(n);
 
   if (get_SymConst_kind(n) == symconst_addr_ent) {
-    entity *ent = get_SymConst_entity(n);
+    ir_entity *ent = get_SymConst_entity(n);
     if (is_Method_type(get_entity_type(ent)) &&
         get_irn_irg(n) != get_const_code_irg()) {
 #if 1
@@ -979,7 +979,7 @@ static int verify_node_Sel(ir_node *n, ir_graph *irg) {
   ir_mode *mymode  = get_irn_mode(n);
   ir_mode *op1mode = get_irn_mode(get_Sel_mem(n));
   ir_mode *op2mode = get_irn_mode(get_Sel_ptr(n));
-  entity *ent;
+  ir_entity *ent;
 
   ASSERT_AND_RET_DBG(
     /* Sel: BB x M x ref x int^n --> ref */
@@ -1494,7 +1494,7 @@ static int verify_node_Load(ir_node *n, ir_graph *irg) {
    * mode_T
    *
   {
-    entity *ent = hunt_for_entity (get_Load_ptr (n), n);
+    ir_entity *ent = hunt_for_entity (get_Load_ptr (n), n);
     assert ((NULL != ent) || (mymode != mode_T));
   }
   */
@@ -1506,7 +1506,7 @@ static int verify_node_Load(ir_node *n, ir_graph *irg) {
  * verify a Store node
  */
 static int verify_node_Store(ir_node *n, ir_graph *irg) {
-  entity *target;
+  ir_entity *target;
 
   ir_mode *mymode  = get_irn_mode(n);
   ir_mode *op1mode = get_irn_mode(get_Store_mem(n));
@@ -1843,7 +1843,7 @@ int irg_verify(ir_graph *irg, unsigned flags)
   current_ir_graph = rem;
 
   if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT && ! res) {
-    entity *ent = get_irg_entity(current_ir_graph);
+    ir_entity *ent = get_irg_entity(current_ir_graph);
 
     if (ent)
       fprintf(stderr, "irg_verify: Verifying graph %s failed\n", get_entity_name(ent));

diff --git a/ir/ir/pseudo_irg.c b/ir/ir/pseudo_irg.c
index 5ab5fcb..fdc3e2e 100644 (file)
--- a/ir/ir/pseudo_irg.c
+++ b/ir/ir/pseudo_irg.c
@@ -48,7 +48,7 @@ void add_irp_pseudo_irg(ir_graph *irg) {
  *  optimized.  Pseudo graphs are kept in a separate graph list in irprog.
  */
 ir_graph *
-new_pseudo_ir_graph(entity *ent, int n_loc) {
+new_pseudo_ir_graph(ir_entity *ent, int n_loc) {
   ir_graph *res = new_r_ir_graph (ent, n_loc);
   add_irp_pseudo_irg(res);          /* remember this graph global. */
   return res;

diff --git a/ir/ir/pseudo_irg.h b/ir/ir/pseudo_irg.h
index 5c6a3fe..2e7052b 100644 (file)
--- a/ir/ir/pseudo_irg.h
+++ b/ir/ir/pseudo_irg.h
@@ -22,7 +22,7 @@
  *  The pseudo representation can only be used for analyses.  It may not be
  *  optimized.  Pseudo graphs are kept in a separate graph list in irprog.
  */
-ir_graph *new_pseudo_ir_graph(entity *ent, int n_loc);
+ir_graph *new_pseudo_ir_graph(ir_entity *ent, int n_loc);
 
 /** Returns non-zero ir ir_graph is pseudo graph.
  *  Is irg a pseudo graph for analysis? */

diff --git a/ir/lower/lower_calls.c b/ir/lower/lower_calls.c
index f8b5763..9555706 100644 (file)
--- a/ir/lower/lower_calls.c
+++ b/ir/lower/lower_calls.c
@@ -297,7 +297,7 @@ static void fix_args_and_collect_calls(ir_node *n, void *ctx) {
  */
 static int is_compound_address(ir_type *ft, ir_node *adr)
 {
-  entity *ent;
+  ir_entity *ent;
 
   if (! is_Sel(adr))
     return 0;
@@ -309,7 +309,7 @@ static int is_compound_address(ir_type *ft, ir_node *adr)
 
 /** A pair for the copy-return-optimization. */
 typedef struct cr_pair {
-  entity *ent;    /**< the entity than can be removed from the frame */
+  ir_entity *ent; /**< the entity than can be removed from the frame */
   ir_node *arg;   /**< the argument that replaces the entities address */
 } cr_pair;
 
@@ -326,7 +326,7 @@ static void do_copy_return_opt(ir_node *n, void *ctx) {
   int i;
 
   if (is_Sel(n)) {
-    entity *ent = get_Sel_entity(n);
+    ir_entity *ent = get_Sel_entity(n);
 
     for (i = ARR_LEN(arr) - 1; i >= 0; --i) {
       if (ent == arr[i].ent) {
@@ -351,7 +351,7 @@ static void do_copy_return_opt(ir_node *n, void *ctx) {
  */
 static ir_node *get_dummy_sel(ir_graph *irg, ir_node *block, ir_type *tp, wlk_env *env)
 {
-  entity *ent;
+  ir_entity *ent;
   pmap_entry *e;
 
   /* use a map the check if we already create such an entity */
@@ -391,7 +391,7 @@ static ir_node *get_dummy_sel(ir_graph *irg, ir_node *block, ir_type *tp, wlk_en
 static void add_hidden_param(ir_graph *irg, int n_com, ir_node **ins, cl_entry *entry, wlk_env *env)
 {
   ir_node *p, *n, *src, *mem;
-  entity *ent;
+  ir_entity *ent;
   ir_type *owner;
   int idx, n_args;
 
@@ -511,7 +511,7 @@ static void fix_call_list(ir_graph *irg, wlk_env *env) {
  */
 static void transform_irg(const lower_params_t *lp, ir_graph *irg)
 {
-  entity *ent = get_irg_entity(irg);
+  ir_entity *ent = get_irg_entity(irg);
   ir_type *mtp, *lowered_mtp, *tp, *ft;
   int i, j, k, n_ress = 0, n_ret_com = 0, n_cr_opt;
   ir_node **new_in, *ret, *endbl, *bl, *mem, *copy;
@@ -696,7 +696,7 @@ static void lower_method_types(type_or_ent *tore, void *env)
 
   /* fix method entities */
   if (is_entity(tore)) {
-    entity *ent = (entity *)tore;
+    ir_entity *ent = (ir_entity *)tore;
     tp = get_entity_type(ent);
 
     if (must_be_lowered(lp, tp)) {

diff --git a/ir/lower/lower_dw.c b/ir/lower/lower_dw.c
index 73da49b..5d4a967 100644 (file)
--- a/ir/lower/lower_dw.c
+++ b/ir/lower/lower_dw.c
@@ -73,7 +73,7 @@ typedef struct _op_mode_entry {
        const ir_op   *op;    /**< the op */
        const ir_mode *imode; /**< the input mode */
        const ir_mode *omode; /**< the output mode */
-       entity        *ent;   /**< the associated entity of this (op, imode, omode) triple */
+       ir_entity     *ent;   /**< the associated entity of this (op, imode, omode) triple */
 } op_mode_entry_t;
 
 /**
@@ -490,7 +490,7 @@ static ir_node *get_intrinsic_address(ir_type *method, ir_op *op,
                                       ir_mode *imode, ir_mode *omode,
                                       ir_node *block, lower_env_t *env) {
        symconst_symbol sym;
-       entity *ent;
+       ir_entity *ent;
        op_mode_entry_t key, *entry;
 
        key.op    = op;
@@ -1701,12 +1701,12 @@ static ir_type *lower_mtp(ir_type *mtp, lower_env_t *env) {
  * Translate a Return.
  */
 static void lower_Return(ir_node *node, ir_mode *mode, lower_env_t *env) {
-       ir_graph *irg = current_ir_graph;
-       entity   *ent = get_irg_entity(irg);
-       ir_type  *mtp = get_entity_type(ent);
-       ir_node  **in;
-       int      i, j, n, idx;
-       int      need_conv = 0;
+       ir_graph  *irg = current_ir_graph;
+       ir_entity *ent = get_irg_entity(irg);
+       ir_type   *mtp = get_entity_type(ent);
+       ir_node   **in;
+       int       i, j, n, idx;
+       int       need_conv = 0;
 
        /* check if this return must be lowered */
        for (i = 0, n = get_Return_n_ress(node); i < n; ++i) {
@@ -1758,13 +1758,13 @@ static void lower_Return(ir_node *node, ir_mode *mode, lower_env_t *env) {
  * Translate the parameters.
  */
 static void lower_Start(ir_node *node, ir_mode *mode, lower_env_t *env) {
-       ir_graph *irg = current_ir_graph;
-       entity   *ent = get_irg_entity(irg);
-       ir_type  *tp  = get_entity_type(ent);
-       ir_type  *mtp;
-       long     *new_projs;
-       int      i, j, n_params, rem;
-       ir_node  *proj, *args;
+       ir_graph  *irg = current_ir_graph;
+       ir_entity *ent = get_irg_entity(irg);
+       ir_type   *tp  = get_entity_type(ent);
+       ir_type   *mtp;
+       long      *new_projs;
+       int       i, j, n_params, rem;
+       ir_node   *proj, *args;
 
        if (is_lowered_type(tp)) {
                mtp = get_associated_type(tp);
@@ -2459,13 +2459,13 @@ void lower_dw_ops(const lwrdw_param_t *param)
 }  /* lower_dw_ops */
 
 /* Default implementation. */
-entity *def_create_intrinsic_fkt(ir_type *method, const ir_op *op,
-                                 const ir_mode *imode, const ir_mode *omode,
-                                 void *context)
+ir_entity *def_create_intrinsic_fkt(ir_type *method, const ir_op *op,
+                                    const ir_mode *imode, const ir_mode *omode,
+                                    void *context)
 {
        char buf[64];
        ident *id;
-       entity *ent;
+       ir_entity *ent;
 
        if (imode == omode) {
                snprintf(buf, sizeof(buf), "__l%s%s", get_op_name(op), get_mode_name(imode));

diff --git a/ir/lower/lower_dw.h b/ir/lower/lower_dw.h
index f805456..51fae34 100644 (file)
--- a/ir/lower/lower_dw.h
+++ b/ir/lower/lower_dw.h
@@ -21,9 +21,9 @@
  * @param omode    the output mode of the emulated opcode
  * @param context  the context parameter
  */
-typedef entity *(create_intrinsic_fkt)(ir_type *method, const ir_op *op,
-                                       const ir_mode *imode, const ir_mode *omode,
-                                       void *context);
+typedef ir_entity *(create_intrinsic_fkt)(ir_type *method, const ir_op *op,
+                                          const ir_mode *imode, const ir_mode *omode,
+                                          void *context);
 
 /**
  * The lowering parameter description.
@@ -49,8 +49,8 @@ void lower_dw_ops(const lwrdw_param_t *param);
 /**
  * Default implementation. Context is unused.
  */
-entity *def_create_intrinsic_fkt(ir_type *method, const ir_op *op,
-                                 const ir_mode *imode, const ir_mode *omode,
-                                 void *context);
+ir_entity *def_create_intrinsic_fkt(ir_type *method, const ir_op *op,
+                                    const ir_mode *imode, const ir_mode *omode,
+                                    void *context);
 
 #endif /* _FIRM_LOWER_DW_H */

diff --git a/ir/lower/lower_intrinsics.c b/ir/lower/lower_intrinsics.c
index b9f4f47..54abc9d 100644 (file)
--- a/ir/lower/lower_intrinsics.c
+++ b/ir/lower/lower_intrinsics.c
@@ -50,7 +50,7 @@ static void call_mapper(ir_node *node, void *env) {
     ir_node *symconst;
     pmap_entry *p;
     const i_call_record *r;
-    entity *ent;
+    ir_entity *ent;
 
     symconst = get_Call_ptr(node);
     if (get_irn_op(symconst) != op_SymConst ||

diff --git a/ir/lower/lower_intrinsics.h b/ir/lower/lower_intrinsics.h
index 77a6dbe..19670c8 100644 (file)
--- a/ir/lower/lower_intrinsics.h
+++ b/ir/lower/lower_intrinsics.h
@@ -41,7 +41,7 @@ enum ikind {
  */
 typedef struct _i_call_record {
   enum ikind    kind;       /**< must be INTRINSIC_CALL */
-  entity        *i_ent;     /**< the entity representing an intrinsic call */
+  ir_entity     *i_ent;     /**< the entity representing an intrinsic call */
   i_mapper_func i_mapper;   /**< the mapper function to call */
   void          *ctx;       /**< mapper context */
   void          *link;      /**< used in the construction algorithm, must be NULL */
@@ -101,12 +101,12 @@ int i_mapper_Alloca(ir_node *call, void *ctx);
  * A runtime routine description.
  */
 typedef struct _runtime_rt {
-  entity  *ent;            /**< The entity representing the runtime routine. */
-  ir_mode *mode;           /**< The operation mode of the mapped instruction. */
-  long    mem_proj_nr;      /**< if >= 0, create a memory ProjM() */
-  long    exc_proj_nr;      /**< if >= 0, create a exception ProjX() */
-  long    exc_mem_proj_nr;  /**< if >= 0, create a exception memory ProjM() */
-  long    res_proj_nr;      /**< if >= 0, first result projection number */
+  ir_entity *ent;            /**< The entity representing the runtime routine. */
+  ir_mode   *mode;           /**< The operation mode of the mapped instruction. */
+  long      mem_proj_nr;     /**< if >= 0, create a memory ProjM() */
+  long      exc_proj_nr;     /**< if >= 0, create a exception ProjX() */
+  long      exc_mem_proj_nr; /**< if >= 0, create a exception memory ProjM() */
+  long      res_proj_nr;     /**< if >= 0, first result projection number */
 } runtime_rt;
 
 /**

diff --git a/ir/tv/tv_t.h b/ir/tv/tv_t.h
index c28aeba..cba32a0 100644 (file)
--- a/ir/tv/tv_t.h
+++ b/ir/tv/tv_t.h
@@ -70,7 +70,7 @@ struct tarval {
 };
 
 /** remove tarval representing an entity that is about to be destroyed */
-void free_tarval_entity(entity *ent);
+void free_tarval_entity(ir_entity *ent);
 
 /* inline functions */
 /*