renamed all types 'type' to 'ir_type'

[r7237]

diff --git a/ir/ana2/ecg.c b/ir/ana2/ecg.c
index bb5a277..7195428 100644 (file)
--- a/ir/ana2/ecg.c
+++ b/ir/ana2/ecg.c
@@ -86,7 +86,7 @@ void set_main_ctx (ctx_info_t*);
 /* ====================
    Alloc stuff
    ==================== */
-static void append_alloc (graph_info_t *ginfo, ir_node *alloc, type *tp)
+static void append_alloc (graph_info_t *ginfo, ir_node *alloc, ir_type *tp)
 {
   alloc_info_t *ainfo = xmalloc (sizeof (alloc_info_t));
 
@@ -419,7 +419,7 @@ static void ecg_calls_act (ir_node *node, void *env)
       assert (0 && "Unexpected address expression");
     }
   } else if (op_Alloc == op) {
-    type *tp = get_Alloc_type (node);
+    ir_type *tp = get_Alloc_type (node);
     /* const char *name = get_type_name (tp); */
 
     append_alloc (graph_info, node, tp);
@@ -1267,6 +1267,9 @@ void ecg_ecg (void)
 
 /*
   $Log$
+  Revision 1.22  2006/01/13 22:55:03  beck
+  renamed all types 'type' to 'ir_type'
+
   Revision 1.21  2005/12/31 15:58:57  beck
   added missing includes
 

diff --git a/ir/ana2/pto_name.c b/ir/ana2/pto_name.c
index 1027114..50cfec7 100644 (file)
--- a/ir/ana2/pto_name.c
+++ b/ir/ana2/pto_name.c
@@ -202,7 +202,7 @@ static void pto_name_alloc_colors (void)
 /* See whether the given entity is a field. */
 static int is_field (entity *ent)
 {
-  type *tp = get_entity_type (ent);
+  ir_type *tp = get_entity_type (ent);
 
   if (is_Primitive_type (tp) || is_Pointer_type (tp)) {
     /* actually, we don't get by by restricting ourselves to pointer types */
@@ -212,9 +212,9 @@ static int is_field (entity *ent)
   }
 }
 
-/* Helper to collect_fields(type*): collect all fields of the given
+/* Helper to collect_fields(ir_type*): collect all fields of the given
   clazz and its super classes into the given obstack. */
-static void _collect_fields (type *clazz, struct obstack *obst)
+static void _collect_fields (ir_type *clazz, struct obstack *obst)
 {
   int n_members = get_class_n_members (clazz);
   int n_supers  = get_class_n_supertypes (clazz);
@@ -231,7 +231,7 @@ static void _collect_fields (type *clazz, struct obstack *obst)
   }
 
   for (i = 0; i < n_supers; i ++) {
-    type *s_clazz = get_class_supertype (clazz, i);
+    ir_type *s_clazz = get_class_supertype (clazz, i);
 
     _collect_fields (s_clazz, obst);
   }
@@ -239,7 +239,7 @@ static void _collect_fields (type *clazz, struct obstack *obst)
 
 /* Collect the fields of the given class and its super classes into an array.
   The last entry of the array is written NULL. */
-static entity **collect_fields (type *clazz)
+static entity **collect_fields (ir_type *clazz)
 {
   struct obstack obst;
   int n_fields;
@@ -302,7 +302,7 @@ static void pto_name_dump_finish (FILE *stream)
 /* Write a node for the given descriptor into the given stream */
 static void pto_name_dump_desc (desc_t *desc, FILE *stream)
 {
-  type *tp = desc->tp;
+  ir_type *tp = desc->tp;
   const char *tp_name = get_type_name (tp);
   ir_node *nd;
 
@@ -473,7 +473,7 @@ qset_t *get_entry (desc_t *desc, entity *ent)
 
 
 /* get a new descriptor for the given type at the given node */
-desc_t *new_name (type *tp, ir_node *node, int ctx)
+desc_t *new_name (ir_type *tp, ir_node *node, int ctx)
 {
   desc_t *desc = NULL;
 
@@ -535,7 +535,7 @@ desc_t *new_ent_name (entity *ent)
 {
   int i;
   int missing = TRUE;
-  type *tp = get_entity_type (ent);
+  ir_type *tp = get_entity_type (ent);
 
   assert (is_Pointer_type (tp));
   tp = get_pointer_points_to_type (tp);
@@ -658,6 +658,9 @@ void pto_name_cleanup (void)
 \f
 /*
   $Log$
+  Revision 1.18  2006/01/13 22:56:21  beck
+  renamed all types 'type' to 'ir_type'
+
   Revision 1.17  2005/12/16 16:59:54  grund
   *** empty log message ***
 

diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c
index 085ee13..99e888d 100644 (file)
--- a/ir/ir/ircons.c
+++ b/ir/ir/ircons.c
@@ -150,7 +150,7 @@ new_bd_Phi (dbg_info *db, ir_node *block, int arity, ir_node **in, ir_mode *mode
 }
 
 static ir_node *
-new_bd_Const_type (dbg_info *db, ir_node *block, ir_mode *mode, tarval *con, type *tp)
+new_bd_Const_type (dbg_info *db, ir_node *block, ir_mode *mode, tarval *con, ir_type *tp)
 {
   ir_node  *res;
   ir_graph *irg = current_ir_graph;
@@ -241,7 +241,7 @@ new_bd_Conv (dbg_info *db, ir_node *block, ir_node *op, ir_mode *mode)
 }
 
 static ir_node *
-new_bd_Cast (dbg_info *db, ir_node *block, ir_node *op, type *to_tp)
+new_bd_Cast (dbg_info *db, ir_node *block, ir_node *op, ir_type *to_tp)
 {
   ir_node  *res;
   ir_graph *irg = current_ir_graph;
@@ -596,7 +596,7 @@ new_bd_Cond (dbg_info *db, ir_node *block, ir_node *c)
 
 static ir_node *
 new_bd_Call (dbg_info *db, ir_node *block, ir_node *store,
-        ir_node *callee, int arity, ir_node **in, type *tp)
+        ir_node *callee, int arity, ir_node **in, ir_type *tp)
 {
   ir_node  **r_in;
   ir_node  *res;
@@ -694,7 +694,7 @@ new_bd_Store (dbg_info *db, ir_node *block,
 
 static ir_node *
 new_bd_Alloc (dbg_info *db, ir_node *block, ir_node *store,
-        ir_node *size, type *alloc_type, where_alloc where)
+        ir_node *size, ir_type *alloc_type, where_alloc where)
 {
   ir_node  *in[2];
   ir_node  *res;
@@ -713,7 +713,7 @@ new_bd_Alloc (dbg_info *db, ir_node *block, ir_node *store,
 
 static ir_node *
 new_bd_Free (dbg_info *db, ir_node *block, ir_node *store,
-        ir_node *ptr, ir_node *size, type *free_type, where_alloc where)
+        ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where)
 {
   ir_node  *in[3];
   ir_node  *res;
@@ -758,7 +758,7 @@ new_bd_Sel (dbg_info *db, ir_node *block, ir_node *store, ir_node *objptr,
 
 static ir_node *
 new_bd_InstOf (dbg_info *db, ir_node *block, ir_node *store,
-           ir_node *objptr, type *ent)
+           ir_node *objptr, ir_type *ent)
 {
   ir_node  **r_in;
   ir_node  *res;
@@ -780,7 +780,7 @@ new_bd_InstOf (dbg_info *db, ir_node *block, ir_node *store,
 
 static ir_node *
 new_bd_SymConst_type (dbg_info *db, ir_node *block, symconst_symbol value,
-              symconst_kind symkind, type *tp) {
+              symconst_kind symkind, ir_type *tp) {
   ir_node  *res;
   ir_mode  *mode;
   ir_graph *irg = current_ir_graph;
@@ -945,7 +945,7 @@ new_bd_Mux  (dbg_info *db, ir_node *block,
 
 static ir_node *
 new_bd_CopyB  (dbg_info *db, ir_node *block,
-    ir_node *store, ir_node *dst, ir_node *src, type *data_type)
+    ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type)
 {
   ir_node  *in[3];
   ir_node  *res;
@@ -1047,7 +1047,7 @@ new_rd_Phi (dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node **in
 }
 
 ir_node *
-new_rd_Const_type (dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con, type *tp)
+new_rd_Const_type (dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con, ir_type *tp)
 {
   ir_node  *res;
   ir_graph *rem = current_ir_graph;
@@ -1133,7 +1133,7 @@ new_rd_Conv (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *
 }
 
 ir_node *
-new_rd_Cast (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, type *to_tp)
+new_rd_Cast (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, ir_type *to_tp)
 {
   ir_node  *res;
   ir_graph *rem = current_ir_graph;
@@ -1451,7 +1451,7 @@ new_rd_Cond (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *c)
 
 ir_node *
 new_rd_Call (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
-        ir_node *callee, int arity, ir_node **in, type *tp)
+        ir_node *callee, int arity, ir_node **in, ir_type *tp)
 {
   ir_node  *res;
   ir_graph *rem = current_ir_graph;
@@ -1520,7 +1520,7 @@ new_rd_Store (dbg_info *db, ir_graph *irg, ir_node *block,
 
 ir_node *
 new_rd_Alloc (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
-        ir_node *size, type *alloc_type, where_alloc where)
+        ir_node *size, ir_type *alloc_type, where_alloc where)
 {
   ir_node  *res;
   ir_graph *rem = current_ir_graph;
@@ -1534,7 +1534,7 @@ new_rd_Alloc (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
 
 ir_node *
 new_rd_Free (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
-        ir_node *ptr, ir_node *size, type *free_type, where_alloc where)
+        ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where)
 {
   ir_node  *res;
   ir_graph *rem = current_ir_graph;
@@ -1576,7 +1576,7 @@ new_rd_Sel (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, ir_node
 
 ir_node *
 new_rd_InstOf (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
-           ir_node *objptr, type *ent)
+           ir_node *objptr, ir_type *ent)
 {
   ir_node  *res;
   ir_graph *rem = current_ir_graph;
@@ -1590,7 +1590,7 @@ new_rd_InstOf (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
 
 ir_node *
 new_rd_SymConst_type (dbg_info *db, ir_graph *irg, ir_node *block, symconst_symbol value,
-              symconst_kind symkind, type *tp)
+              symconst_kind symkind, ir_type *tp)
 {
   ir_node  *res;
   ir_graph *rem = current_ir_graph;
@@ -1610,23 +1610,23 @@ new_rd_SymConst (dbg_info *db, ir_graph *irg, ir_node *block, symconst_symbol va
   return res;
 }
 
-ir_node *new_rd_SymConst_addr_ent (dbg_info *db, ir_graph *irg, entity *symbol, type *tp)
+ir_node *new_rd_SymConst_addr_ent (dbg_info *db, ir_graph *irg, entity *symbol, ir_type *tp)
 {
-  symconst_symbol sym = {(type *)symbol};
+  symconst_symbol sym = {(ir_type *)symbol};
   return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_addr_ent, tp);
 }
 
-ir_node *new_rd_SymConst_addr_name (dbg_info *db, ir_graph *irg, ident *symbol, type *tp) {
-  symconst_symbol sym = {(type *)symbol};
+ir_node *new_rd_SymConst_addr_name (dbg_info *db, ir_graph *irg, ident *symbol, ir_type *tp) {
+  symconst_symbol sym = {(ir_type *)symbol};
   return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_addr_name, tp);
 }
 
-ir_node *new_rd_SymConst_type_tag (dbg_info *db, ir_graph *irg, type *symbol, type *tp) {
+ir_node *new_rd_SymConst_type_tag (dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
   symconst_symbol sym = {symbol};
   return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_type_tag, tp);
 }
 
-ir_node *new_rd_SymConst_size (dbg_info *db, ir_graph *irg, type *symbol, type *tp) {
+ir_node *new_rd_SymConst_size (dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) {
   symconst_symbol sym = {symbol};
   return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_size, tp);
 }
@@ -1759,7 +1759,7 @@ new_rd_Mux  (dbg_info *db, ir_graph *irg, ir_node *block,
 }
 
 ir_node *new_rd_CopyB(dbg_info *db, ir_graph *irg, ir_node *block,
-    ir_node *store, ir_node *dst, ir_node *src, type *data_type)
+    ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type)
 {
   ir_node  *res;
   ir_graph *rem = current_ir_graph;
@@ -1821,7 +1821,7 @@ ir_node *new_r_Const_long(ir_graph *irg, ir_node *block,
 }
 
 ir_node *new_r_Const_type(ir_graph *irg, ir_node *block,
-               ir_mode *mode, tarval *con, type *tp) {
+               ir_mode *mode, tarval *con, ir_type *tp) {
   return new_rd_Const_type(NULL, irg, block, mode, con, tp);
 }
 
@@ -1835,12 +1835,12 @@ ir_node *new_r_Sel    (ir_graph *irg, ir_node *block, ir_node *store,
   return new_rd_Sel(NULL, irg, block, store, objptr, n_index, index, ent);
 }
 ir_node *new_r_InstOf (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
-                  type *ent) {
+                  ir_type *ent) {
   return (new_rd_InstOf (NULL, irg, block, store, objptr, ent));
 }
 ir_node *new_r_Call   (ir_graph *irg, ir_node *block, ir_node *store,
                   ir_node *callee, int arity, ir_node **in,
-                  type *tp) {
+                  ir_type *tp) {
   return new_rd_Call(NULL, irg, block, store, callee, arity, in, tp);
 }
 ir_node *new_r_Add    (ir_graph *irg, ir_node *block,
@@ -1919,7 +1919,7 @@ ir_node *new_r_Conv   (ir_graph *irg, ir_node *block,
                ir_node *op, ir_mode *mode) {
   return new_rd_Conv(NULL, irg, block, op, mode);
 }
-ir_node *new_r_Cast   (ir_graph *irg, ir_node *block, ir_node *op, type *to_tp) {
+ir_node *new_r_Cast   (ir_graph *irg, ir_node *block, ir_node *op, ir_type *to_tp) {
   return new_rd_Cast(NULL, irg, block, op, to_tp);
 }
 ir_node *new_r_Phi    (ir_graph *irg, ir_node *block, int arity,
@@ -1935,11 +1935,11 @@ ir_node *new_r_Store  (ir_graph *irg, ir_node *block,
   return new_rd_Store(NULL, irg, block, store, adr, val);
 }
 ir_node *new_r_Alloc  (ir_graph *irg, ir_node *block, ir_node *store,
-               ir_node *size, type *alloc_type, where_alloc where) {
+               ir_node *size, ir_type *alloc_type, where_alloc where) {
   return new_rd_Alloc(NULL, irg, block, store, size, alloc_type, where);
 }
 ir_node *new_r_Free   (ir_graph *irg, ir_node *block, ir_node *store,
-               ir_node *ptr, ir_node *size, type *free_type, where_alloc where) {
+               ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) {
   return new_rd_Free(NULL, irg, block, store, ptr, size, free_type, where);
 }
 ir_node *new_r_Sync   (ir_graph *irg, ir_node *block, int arity, ir_node **in) {
@@ -1994,7 +1994,7 @@ ir_node *new_r_Mux (ir_graph *irg, ir_node *block,
   return new_rd_Mux(NULL, irg, block, sel, ir_false, ir_true, mode);
 }
 ir_node *new_r_CopyB(ir_graph *irg, ir_node *block,
-    ir_node *store, ir_node *dst, ir_node *src, type *data_type) {
+    ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
   return new_rd_CopyB(NULL, irg, block, store, dst, src, data_type);
 }
 ir_node *new_r_Bound(ir_graph *irg, ir_node *block,
@@ -2909,7 +2909,7 @@ new_d_Const_long(dbg_info *db, ir_mode *mode, long value)
 }
 
 ir_node *
-new_d_Const_type (dbg_info *db, ir_mode *mode, tarval *con, type *tp)
+new_d_Const_type (dbg_info *db, ir_mode *mode, tarval *con, ir_type *tp)
 {
   return new_bd_Const_type(db, current_ir_graph->start_block,
                 mode, con, tp);
@@ -2949,7 +2949,7 @@ new_d_Conv (dbg_info *db, ir_node *op, ir_mode *mode)
 }
 
 ir_node *
-new_d_Cast (dbg_info *db, ir_node *op, type *to_tp)
+new_d_Cast (dbg_info *db, ir_node *op, ir_type *to_tp)
 {
   return new_bd_Cast(db, current_ir_graph->current_block, op, to_tp);
 }
@@ -3150,7 +3150,7 @@ new_d_Cond (dbg_info *db, ir_node *c)
 
 ir_node *
 new_d_Call (dbg_info *db, ir_node *store, ir_node *callee, int arity, ir_node **in,
-      type *tp)
+      ir_type *tp)
 {
   ir_node *res;
   res = new_bd_Call (db, current_ir_graph->current_block,
@@ -3203,7 +3203,7 @@ new_d_Store (dbg_info *db, ir_node *store, ir_node *addr, ir_node *val)
 }
 
 ir_node *
-new_d_Alloc (dbg_info *db, ir_node *store, ir_node *size, type *alloc_type,
+new_d_Alloc (dbg_info *db, ir_node *store, ir_node *size, ir_type *alloc_type,
            where_alloc where)
 {
   ir_node *res;
@@ -3218,7 +3218,7 @@ new_d_Alloc (dbg_info *db, ir_node *store, ir_node *size, type *alloc_type,
 
 ir_node *
 new_d_Free (dbg_info *db, ir_node *store, ir_node *ptr,
-    ir_node *size, type *free_type, where_alloc where)
+    ir_node *size, ir_type *free_type, where_alloc where)
 {
   return new_bd_Free (db, current_ir_graph->current_block,
              store, ptr, size, free_type, where);
@@ -3241,14 +3241,14 @@ new_d_Sel (dbg_info *db, ir_node *store, ir_node *objptr, int n_index, ir_node *
 }
 
 ir_node *
-new_d_InstOf (dbg_info *db, ir_node *store, ir_node *objptr, type *ent)
+new_d_InstOf (dbg_info *db, ir_node *store, ir_node *objptr, ir_type *ent)
 {
   return (new_bd_InstOf (db, current_ir_graph->current_block,
                          store, objptr, ent));
 }
 
 ir_node *
-new_d_SymConst_type (dbg_info *db, symconst_symbol value, symconst_kind kind, type *tp)
+new_d_SymConst_type (dbg_info *db, symconst_symbol value, symconst_kind kind, ir_type *tp)
 {
   return new_bd_SymConst_type (db, current_ir_graph->start_block,
                          value, kind, tp);
@@ -3338,7 +3338,7 @@ new_d_Mux (dbg_info *db, ir_node *sel, ir_node *ir_false,
 }
 
 ir_node *new_d_CopyB(dbg_info *db,ir_node *store,
-    ir_node *dst, ir_node *src, type *data_type) {
+    ir_node *dst, ir_node *src, ir_type *data_type) {
   ir_node *res;
   res = new_bd_CopyB(db, current_ir_graph->current_block,
     store, dst, src, data_type);
@@ -3478,7 +3478,7 @@ ir_node *get_cur_block(void) {
 }
 
 /* Returns the frame type of the current graph */
-type *get_cur_frame_type(void) {
+ir_type *get_cur_frame_type(void) {
   return get_irg_frame_type(current_ir_graph);
 }
 
@@ -3544,7 +3544,7 @@ ir_node *new_Const_long(ir_mode *mode, long value)
     return new_d_Const_long(NULL, mode, value);
 }
 
-ir_node *new_Const_type(tarval *con, type *tp) {
+ir_node *new_Const_type(tarval *con, ir_type *tp) {
   return new_d_Const_type(NULL, get_type_mode(tp), con, tp);
 }
 
@@ -3558,11 +3558,11 @@ ir_node *new_Sel    (ir_node *store, ir_node *objptr, int arity, ir_node **in,
                      entity *ent) {
   return new_d_Sel(NULL, store, objptr, arity, in, ent);
 }
-ir_node *new_InstOf (ir_node *store, ir_node *objptr, type *ent) {
+ir_node *new_InstOf (ir_node *store, ir_node *objptr, ir_type *ent) {
   return new_d_InstOf (NULL, store, objptr, ent);
 }
 ir_node *new_Call   (ir_node *store, ir_node *callee, int arity, ir_node **in,
-             type *tp) {
+             ir_type *tp) {
   return new_d_Call(NULL, store, callee, arity, in, tp);
 }
 ir_node *new_Add    (ir_node *op1, ir_node *op2, ir_mode *mode) {
@@ -3622,7 +3622,7 @@ ir_node *new_Cmp    (ir_node *op1, ir_node *op2) {
 ir_node *new_Conv   (ir_node *op, ir_mode *mode) {
   return new_d_Conv(NULL, op, mode);
 }
-ir_node *new_Cast   (ir_node *op, type *to_tp) {
+ir_node *new_Cast   (ir_node *op, ir_type *to_tp) {
   return new_d_Cast(NULL, op, to_tp);
 }
 ir_node *new_Phi    (int arity, ir_node **in, ir_mode *mode) {
@@ -3634,12 +3634,12 @@ ir_node *new_Load   (ir_node *store, ir_node *addr, ir_mode *mode) {
 ir_node *new_Store  (ir_node *store, ir_node *addr, ir_node *val) {
   return new_d_Store(NULL, store, addr, val);
 }
-ir_node *new_Alloc  (ir_node *store, ir_node *size, type *alloc_type,
+ir_node *new_Alloc  (ir_node *store, ir_node *size, ir_type *alloc_type,
                      where_alloc where) {
   return new_d_Alloc(NULL, store, size, alloc_type, where);
 }
 ir_node *new_Free   (ir_node *store, ir_node *ptr, ir_node *size,
-             type *free_type, where_alloc where) {
+             ir_type *free_type, where_alloc where) {
   return new_d_Free(NULL, store, ptr, size, free_type, where);
 }
 ir_node *new_Sync   (int arity, ir_node **in) {
@@ -3687,7 +3687,7 @@ ir_node *new_NoMem  (void) {
 ir_node *new_Mux (ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) {
   return new_d_Mux(NULL, sel, ir_false, ir_true, mode);
 }
-ir_node *new_CopyB(ir_node *store, ir_node *dst, ir_node *src, type *data_type) {
+ir_node *new_CopyB(ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) {
   return new_d_CopyB(NULL, store, dst, src, data_type);
 }
 ir_node *new_Bound(ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper) {

diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c
index 31030bf..8a818c2 100644 (file)
--- a/ir/ir/irdump.c
+++ b/ir/ir/irdump.c
@@ -219,7 +219,7 @@ const char *get_mode_name_ex(ir_mode *mode, int *bad)
  * returns the name of a type or <ERROR> if mode is NOT a mode object.
  * in the later case, sets bad
  */
-const char *get_type_name_ex(type *tp, int *bad)
+const char *get_type_name_ex(ir_type *tp, int *bad)
 {
   if (is_type(tp))
     return get_type_name(tp);
@@ -250,7 +250,7 @@ static void print_vcg_color(FILE *F, dumper_colors color) {
  * prints the edge from a type S to a type T with additional info fmt, ...
  * to the file F
  */
-static void print_type_type_edge(FILE *F, type *S, type *T, const char *fmt, ...)
+static void print_type_type_edge(FILE *F, ir_type *S, ir_type *T, const char *fmt, ...)
 {
   va_list ap;
 
@@ -266,7 +266,7 @@ static void print_type_type_edge(FILE *F, type *S, type *T, const char *fmt, ...
  * 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, type *T, entity *E, const char *fmt, ...)
+static void print_type_ent_edge(FILE *F, ir_type *T, entity *E, const char *fmt, ...)
 {
   va_list ap;
 
@@ -302,7 +302,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, type *T, const char *fmt, ...)
+static void print_ent_type_edge(FILE *F, entity *E, ir_type *T, const char *fmt, ...)
 {
   va_list ap;
 
@@ -318,7 +318,7 @@ static void print_ent_type_edge(FILE *F, entity *E, type *T, const char *fmt, ..
  * prints the edge from a node N to a type T with additional info fmt, ...
  * to the file F
  */
-static void print_node_type_edge(FILE *F, const ir_node *N, type *T, const char *fmt, ...)
+static void print_node_type_edge(FILE *F, const ir_node *N, ir_type *T, const char *fmt, ...)
 {
   va_list ap;
 
@@ -367,7 +367,7 @@ static void print_ent_node_edge(FILE *F, entity *E, const ir_node *N, const char
  * prints the edge from a type E to an enumeration item item with additional info fmt, ...
  * to the file F
  */
-static void print_enum_item_edge(FILE *F, type *E, int item, const char *fmt, ...)
+static void print_enum_item_edge(FILE *F, ir_type *E, int item, const char *fmt, ...)
 {
   va_list ap;
 
@@ -742,7 +742,7 @@ static int dump_node_typeinfo(FILE *F, ir_node *n) {
   if (opt_dump_analysed_type_info) {
     if (get_irg_typeinfo_state(current_ir_graph) == ir_typeinfo_consistent  ||
         get_irg_typeinfo_state(current_ir_graph) == ir_typeinfo_inconsistent) {
-      type *tp = get_irn_typeinfo_type(n);
+      ir_type *tp = get_irn_typeinfo_type(n);
       if (tp != firm_none_type)
         fprintf(F, "[%s] ", get_type_name_ex(tp, &bad));
       else
@@ -1693,7 +1693,7 @@ static void dump_node2type_edges(ir_node *n, void *env)
 }
 
 #if 0
-static int print_type_info(FILE *F, type *tp) {
+static int print_type_info(FILE *F, ir_type *tp) {
   int bad = 0;
 
   if (get_type_state(tp) == layout_undefined) {
@@ -1708,7 +1708,7 @@ static int print_type_info(FILE *F, type *tp) {
   return bad;
 }
 
-static void print_typespecific_info(FILE *F, type *tp) {
+static void print_typespecific_info(FILE *F, ir_type *tp) {
   switch (get_type_tpop_code(tp)) {
   case tpo_class:
     {
@@ -1743,7 +1743,7 @@ static void print_typespecific_info(FILE *F, type *tp) {
 }
 #endif
 
-static void print_typespecific_vcgattr(FILE *F, type *tp) {
+static void print_typespecific_vcgattr(FILE *F, ir_type *tp) {
   switch (get_type_tpop_code(tp)) {
   case tpo_class:
     {
@@ -1779,7 +1779,7 @@ static void print_typespecific_vcgattr(FILE *F, type *tp) {
 }
 
 
-int dump_type_node(FILE *F, type *tp)
+int dump_type_node(FILE *F, ir_type *tp)
 {
   int bad = 0;
 
@@ -1824,7 +1824,7 @@ void dump_entity_node(FILE *F, entity *ent, int color)
 }
 #undef X
 
-static void dump_enum_item(FILE *F, type *tp, int pos)
+static void dump_enum_item(FILE *F, ir_type *tp, int pos)
 {
   char buf[1024];
   ident *id  = get_enumeration_nameid(tp, pos);
@@ -1892,7 +1892,7 @@ dump_type_info(type_or_ent *tore, void *env) {
     } break;
   case k_type:
     {
-      type *tp = (type *)tore;
+      ir_type *tp = (ir_type *)tore;
       dump_type_node(F, tp);
       /* and now the edges */
       switch (get_type_tpop_code(tp)) {
@@ -1991,7 +1991,7 @@ dump_class_hierarchy_node (type_or_ent *tore, void *ctx) {
   } break; /* case k_entity */
   case k_type:
     {
-      type *tp = (type *)tore;
+      ir_type *tp = (ir_type *)tore;
       if (tp == get_glob_type()) break;
       switch (get_type_tpop_code(tp)) {
         case tpo_class: {

diff --git a/ir/ir/irdump.h b/ir/ir/irdump.h
index e1c1117..96a9b6c 100644 (file)
--- a/ir/ir/irdump.h
+++ b/ir/ir/irdump.h
@@ -510,11 +510,11 @@ void    dump_entity (entity *ent);
 
 /** Write the type and all its attributes to the file passed.
  * */
-void    dump_type_to_file (FILE *f, type *tp, dump_verbosity verbosity);
+void    dump_type_to_file (FILE *f, ir_type *tp, dump_verbosity verbosity);
 
 /** Write the type and all its attributes to stdout.
  *  */
-void    dump_type (type *tp);
+void    dump_type (ir_type *tp);
 
 
 /** Dump type information as text.

diff --git a/ir/ir/irdump_t.h b/ir/ir/irdump_t.h
index 17700f5..23eed8b 100644 (file)
--- a/ir/ir/irdump_t.h
+++ b/ir/ir/irdump_t.h
@@ -70,7 +70,7 @@ void vcg_close (FILE *F);
 
 
 const char *get_ent_dump_name(entity *ent);
-const char *get_type_name_ex(type *tp, int *bad);
+const char *get_type_name_ex(ir_type *tp, int *bad);
 const char *get_mode_name_ex(ir_mode *mode, int *bad);
 /**
  * dump the name of a node n to the File F.
@@ -82,6 +82,6 @@ int dump_node_label(FILE *F, ir_node *n);
 
 
 /** Writes vcg representation with title "PRINT_TYPEID(tp)" to file F. */
-int dump_type_node(FILE *F, type *tp);
+int dump_type_node(FILE *F, ir_type *tp);
 
 #endif /* __IRDUMPT_T_H__ */

diff --git a/ir/ir/irdumptxt.c b/ir/ir/irdumptxt.c
index 0f05dbd..44100ae 100644 (file)
--- a/ir/ir/irdumptxt.c
+++ b/ir/ir/irdumptxt.c
@@ -189,7 +189,7 @@ int dump_irnode_to_file(FILE *F, ir_node *n) {
     /* not dumped: mature    */
   }  break;
   case iro_Start: {
-    type *tp = get_entity_type(get_irg_entity(get_irn_irg(n)));
+    ir_type *tp = get_entity_type(get_irg_entity(get_irn_irg(n)));
     fprintf(F, "  start of method of type %s \n", get_type_name_ex(tp, &bad));
     for (i = 0; i < get_method_n_params(tp); ++i)
       fprintf(F, "    param %d type: %s \n", i, get_type_name_ex(get_method_param_type(tp, i), &bad));
@@ -231,7 +231,7 @@ int dump_irnode_to_file(FILE *F, ir_node *n) {
     }
   } break;
   case iro_Call: {
-    type *tp = get_Call_type(n);
+    ir_type *tp = get_Call_type(n);
     fprintf(F, "  calling method of type %s \n", get_type_name_ex(tp, &bad));
     if(get_unknown_type() != tp) {
       for (i = 0; i < get_method_n_params(tp); ++i)
@@ -261,14 +261,14 @@ int dump_irnode_to_file(FILE *F, ir_node *n) {
   } break;
   case iro_Return: {
     if (!get_interprocedural_view()) {
-      type *tp = get_entity_type(get_irg_entity(get_irn_irg(n)));
+      ir_type *tp = get_entity_type(get_irg_entity(get_irn_irg(n)));
       fprintf(F, "  return in method of type %s \n", get_type_name_ex(tp, &bad));
       for (i = 0; i < get_method_n_ress(tp); ++i)
         fprintf(F, "    res %d type: %s \n", i, get_type_name_ex(get_method_res_type(tp, i), &bad));
     }
   } break;
   case iro_Const: {
-    type *tp = get_Const_type(n);
+    ir_type *tp = get_Const_type(n);
     assert(tp != firm_none_type);
     fprintf(F, "  Const of type %s \n", get_type_name_ex(get_Const_type(n), &bad));
   } break;
@@ -438,9 +438,9 @@ static void dump_node_list(FILE *F, firm_kind *k, char *prefix,
  *  "prefix"    node8, ... node15,\n
  *  "prefix"    node16, node17\n
  */
-static void dump_type_list(FILE *F, type *tp, char *prefix,
-                          int (*get_n_types)(type *tp),
-                          type *(*get_type)(type *tp, int pos),
+static void dump_type_list(FILE *F, ir_type *tp, char *prefix,
+                          int (*get_n_types)(ir_type *tp),
+                          ir_type *(*get_type)(ir_type *tp, int pos),
                           char *name) {
   int i, n_nodes = get_n_types(tp);
   char *comma = "";
@@ -461,7 +461,7 @@ static void dump_type_list(FILE *F, type *tp, char *prefix,
 #define X(a)    case a: fprintf(F, #a); break
 void    dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned verbosity) {
   int i, j;
-  type *owner, *type;
+  ir_type *owner, *type;
 
   assert(is_entity(ent));
   owner = get_entity_owner(ent);
@@ -868,7 +868,7 @@ void    dump_entitycsv_to_file_prefix (FILE *F, entity *ent, char *prefix, unsig
 }
 
 /* A fast hack to dump a csv. */
-void dump_typecsv_to_file(FILE *F, type *tp, dump_verbosity verbosity, const char *comma) {
+void dump_typecsv_to_file(FILE *F, ir_type *tp, dump_verbosity verbosity, const char *comma) {
   int i;
   char buf[1024 + 10];
   if (!is_Class_type(tp)) return;   // we also want array types. Stupid, these are classes in java.
@@ -953,7 +953,7 @@ void dump_typecsv_to_file(FILE *F, type *tp, dump_verbosity verbosity, const cha
   }
 }
 
-void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
+void dump_type_to_file (FILE *F, ir_type *tp, dump_verbosity verbosity) {
   int i;
 
   if ((is_Class_type(tp))       && (verbosity & dump_verbosity_noClassTypes)) return;
@@ -986,17 +986,17 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
     if (verbosity & dump_verbosity_typeattrs) {
       fprintf(F, "  supertypes: ");
       for (i = 0; i < get_class_n_supertypes(tp); ++i) {
-        type *stp = get_class_supertype(tp, i);
+        ir_type *stp = get_class_supertype(tp, i);
         fprintf(F, "\n    %s", get_type_name(stp));
       }
       fprintf(F, "\n  subtypes: ");
       for (i = 0; i < get_class_n_subtypes(tp); ++i) {
-        type *stp = get_class_subtype(tp, i);
+        ir_type *stp = get_class_subtype(tp, i);
         fprintf(F, "\n    %s", get_type_name(stp));
       }
 
       if (get_irp_inh_transitive_closure_state() != inh_transitive_closure_none) {
-        type *stp;
+        ir_type *stp;
         fprintf(F, "\n  transitive supertypes: ");
         for (stp = get_class_trans_supertype_first(tp);
                   stp;
@@ -1030,7 +1030,7 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
   case tpo_array:
     if (verbosity & dump_verbosity_typeattrs) {
       int i, n_dim;
-      type *elem_tp = get_array_element_type(tp);
+      ir_type *elem_tp = get_array_element_type(tp);
 
       fprintf(F, "\n  array ");
 
@@ -1074,7 +1074,7 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
 
   case tpo_pointer:
     if (verbosity & dump_verbosity_typeattrs) {
-      type *tt = get_pointer_points_to_type(tp);
+      ir_type *tt = get_pointer_points_to_type(tp);
       fprintf(F, "\n  points to %s (%ld)\n", get_type_name(tt), get_type_nr(tt));
     }
     break;
@@ -1084,13 +1084,13 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
       fprintf(F, "\n  variadicity: %s", get_variadicity_name(get_method_variadicity(tp)));
       fprintf(F, "\n  return types: %d", get_method_n_ress(tp));
       for (i = 0; i < get_method_n_ress(tp); ++i) {
-        type *rtp = get_method_res_type(tp, i);
+        ir_type *rtp = get_method_res_type(tp, i);
         fprintf(F, "\n    %s", get_type_name(rtp));
       }
 
       fprintf(F, "\n  parameter types: %d", get_method_n_params(tp));
       for (i = 0; i < get_method_n_params(tp); ++i) {
-        type *ptp = get_method_param_type(tp, i);
+        ir_type *ptp = get_method_param_type(tp, i);
         fprintf(F, "\n    %s", get_type_name(ptp));
       }
       if (get_method_variadicity(tp)) {
@@ -1183,7 +1183,7 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) {
   fprintf(F, "\n\n");
 }
 
-void dump_type(type *tp) {
+void dump_type(ir_type *tp) {
   dump_type_to_file (stdout, tp, dump_verbosity_max);
 }
 
@@ -1202,7 +1202,7 @@ void dump_types_as_text(unsigned verbosity, const char *suffix) {
   }
 
   for (i = 0; i < n_types; ++i) {
-    type *t = get_irp_type(i);
+    ir_type *t = get_irp_type(i);
 
     //if (is_jack_rts_class(t)) continue;
 
@@ -1220,7 +1220,7 @@ void dump_types_as_text(unsigned verbosity, const char *suffix) {
 void dump_globals_as_text(unsigned verbosity, const char *suffix) {
   const char *basename;
   FILE *F, *CSV = NULL;
-  type *g = get_glob_type();
+  ir_type *g = get_glob_type();
   int i, n_mems = get_class_n_members(g);
 
   basename = irp_prog_name_is_set() ? get_irp_prog_name() : "TextGlobals";

diff --git a/ir/ir/irgopt.c b/ir/ir/irgopt.c
index 8bf933a..48a25f6 100644 (file)
--- a/ir/ir/irgopt.c
+++ b/ir/ir/irgopt.c
@@ -675,7 +675,7 @@ void remove_bad_predecessors(ir_graph *irg) {
 static INLINE void
 copy_node_inline (ir_node *n, void *env) {
   ir_node *new;
-  type *frame_tp = (type *)env;
+  ir_type *frame_tp = (ir_type *)env;
 
   copy_node(n, NULL);
   if (get_irn_op(n) == op_Sel) {
@@ -707,7 +707,7 @@ static void find_addr(ir_node *node, void *env)
  */
 static int can_inline(ir_node *call, ir_graph *called_graph)
 {
-  type *call_type = get_Call_type(call);
+  ir_type *call_type = get_Call_type(call);
   int params, ress, i, res;
   assert(is_Method_type(call_type));
 
@@ -716,7 +716,7 @@ static int can_inline(ir_node *call, ir_graph *called_graph)
 
   /* check params */
   for (i = 0; i < params; ++i) {
-    type *p_type = get_method_param_type(call_type, i);
+    ir_type *p_type = get_method_param_type(call_type, i);
 
     if (is_compound_type(p_type))
       return 0;
@@ -724,7 +724,7 @@ static int can_inline(ir_node *call, ir_graph *called_graph)
 
   /* check res */
   for (i = 0; i < ress; ++i) {
-    type *r_type = get_method_res_type(call_type, i);
+    ir_type *r_type = get_method_res_type(call_type, i);
 
     if (is_compound_type(r_type))
       return 0;
@@ -746,7 +746,7 @@ int inline_method(ir_node *call, ir_graph *called_graph) {
   ir_node *ret, *phi;
   int arity, n_ret, n_exc, n_res, i, j, rem_opt, irn_arity;
   int exc_handling;
-  type *called_frame;
+  ir_type *called_frame;
   irg_inline_property prop = get_irg_inline_property(called_graph);
 
   if ( (prop != irg_inline_forced) &&

diff --git a/ir/ir/irgraph.h b/ir/ir/irgraph.h
index 32905bc..bb612fd 100644 (file)
--- a/ir/ir/irgraph.h
+++ b/ir/ir/irgraph.h
@@ -186,8 +186,8 @@ int      is_ir_graph(const void *thing);
 entity  *get_irg_entity (const ir_graph *irg);
 void     set_irg_entity (ir_graph *irg, entity *ent);
 
-type    *get_irg_frame_type (ir_graph *irg);
-void     set_irg_frame_type (ir_graph *irg, type *ftp);
+ir_type *get_irg_frame_type (ir_graph *irg);
+void     set_irg_frame_type (ir_graph *irg, ir_type *ftp);
 
 ir_node *get_irg_start_block (const ir_graph *irg);
 void     set_irg_start_block (ir_graph *irg, ir_node *node);

diff --git a/ir/ir/irgwalk.c b/ir/ir/irgwalk.c
index c4016f9..2b775b3 100644 (file)
--- a/ir/ir/irgwalk.c
+++ b/ir/ir/irgwalk.c
@@ -551,7 +551,7 @@ void walk_const_code(irg_walk_func *pre, irg_walk_func *post, void *env) {
 
   /* Walk constant array bounds. */
   for (i = 0; i < get_irp_n_types(); i++) {
-    type *tp = get_irp_type(i);
+    ir_type *tp = get_irp_type(i);
     if (is_Array_type(tp)) {
       for (j = 0; j < get_array_n_dimensions(tp); j++) {
         ir_node *n = get_array_lower_bound(tp, j);

diff --git a/ir/ir/irhooks.h b/ir/ir/irhooks.h
index f85bbfc..ae20a4a 100644 (file)
--- a/ir/ir/irhooks.h
+++ b/ir/ir/irhooks.h
@@ -152,7 +152,7 @@ typedef struct hook_entry {
     void (*_hook_new_entity)(void *context, entity *ent);
 
     /** This hook is called after a new type was created. */
-    void (*_hook_new_type)(void *context, type *tp);
+    void (*_hook_new_type)(void *context, ir_type *tp);
   } hook;
 
   /** the context for every hook */

diff --git a/ir/ir/irprog.c b/ir/ir/irprog.c
index f29c527..06d79f4 100644 (file)
--- a/ir/ir/irprog.c
+++ b/ir/ir/irprog.c
@@ -45,7 +45,7 @@ static ir_prog *new_incomplete_ir_prog (void) {
   res->kind          = k_ir_prog;
   res->graphs        = NEW_ARR_F(ir_graph *, 0);
   res->pseudo_graphs = NEW_ARR_F(ir_graph *, 0);
-  res->types         = NEW_ARR_F(type *, 0);
+  res->types         = NEW_ARR_F(ir_type *, 0);
   res->modes         = NEW_ARR_F(ir_mode *, 0);
 
 #ifdef DEBUG_libfirm
@@ -122,7 +122,7 @@ void set_irp_main_irg(ir_graph *main_irg) {
   irp->main_irg = main_irg;
 }
 
-type *(get_glob_type)(void) {
+ir_type *(get_glob_type)(void) {
   return _get_glob_type();
 }
 
@@ -200,14 +200,14 @@ ir_graph *get_irp_allirg(int pos) {
 }
 
 /* Adds type to the list of types in irp. */
-void add_irp_type(type *typ) {
+void add_irp_type(ir_type *typ) {
   assert (typ != NULL);
   assert(irp);
-  ARR_APP1 (type *, irp->types, typ);
+  ARR_APP1 (ir_type *, irp->types, typ);
 }
 
 /* Remove type form the list of types in irp. */
-void remove_irp_type(type *typ) {
+void remove_irp_type(ir_type *typ) {
   int i;
   assert(typ);
 
@@ -216,7 +216,7 @@ void remove_irp_type(type *typ) {
       for(; i < (ARR_LEN(irp->types)) - 1; i++) {
         irp->types[i] = irp->types[i+1];
       }
-      ARR_SETLEN(type *, irp->types, (ARR_LEN(irp->types)) - 1);
+      ARR_SETLEN(ir_type *, irp->types, (ARR_LEN(irp->types)) - 1);
       break;
     }
   }
@@ -226,11 +226,11 @@ int (get_irp_n_types) (void) {
   return _get_irp_n_types();
 }
 
-type *(get_irp_type) (int pos) {
+ir_type *(get_irp_type) (int pos) {
   return _get_irp_type(pos);
 }
 
-void  set_irp_type(int pos, type *typ) {
+void  set_irp_type(int pos, ir_type *typ) {
   assert (irp && typ);
   assert (pos < (ARR_LEN((irp)->types)));
   irp->types[pos] = typ;

diff --git a/ir/ir/irprog.h b/ir/ir/irprog.h
index ba8903f..52f8b4b 100644 (file)
--- a/ir/ir/irprog.h
+++ b/ir/ir/irprog.h
@@ -133,23 +133,23 @@ ir_graph *get_irp_allirg(int pos);
 
 
 /** Returns the "global" type of the irp. */
-type *get_glob_type(void);
+ir_type *get_glob_type(void);
 
 /** Adds type to the list of types in irp. */
-void  add_irp_type(type *typ);
+void  add_irp_type(ir_type *typ);
 
 /** Removes type from the list of types, deallocates it and
     shrinks the list by one. */
-void  remove_irp_type(type *typ);
+void  remove_irp_type(ir_type *typ);
 
 /** Returns the number of all types in the irp. */
 int   get_irp_n_types(void);
 
 /** Returns the type at position pos in the irp. */
-type *get_irp_type(int pos);
+ir_type *get_irp_type(int pos);
 
 /** Overwrites the type at position pos with another type. */
-void  set_irp_type(int pos, type *typ);
+void  set_irp_type(int pos, ir_type *typ);
 
 /** Returns the number of all modes in the irp. */
 int   get_irp_n_modes(void);

diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c
index d366cf6..080e30b 100644 (file)
--- a/ir/ir/irvrfy.c
+++ b/ir/ir/irvrfy.c
@@ -67,7 +67,7 @@ static void show_entity_failure(ir_node *node)
     entity *ent = get_irg_entity(irg);
 
     if (ent) {
-      type *ent_type = get_entity_owner(ent);
+      ir_type *ent_type = get_entity_owner(ent);
 
       if (ent_type) {
         if (ent_type == get_glob_type())
@@ -166,7 +166,7 @@ static void show_proj_failure(ir_node *n)
 /**
  * Prints a failure message for a proj from Start
  */
-static void show_proj_mode_failure(ir_node *n, type *ty)
+static void show_proj_mode_failure(ir_node *n, ir_type *ty)
 {
   long proj  = get_Proj_proj(n);
   ir_mode *m = get_type_mode(ty);
@@ -209,7 +209,7 @@ static void show_node_on_graph(ir_graph *irg, ir_node *n)
 /**
  * Show call parameters
  */
-static void show_call_param(ir_node *n, type *mt)
+static void show_call_param(ir_node *n, ir_type *mt)
 {
   int i;
 
@@ -230,7 +230,7 @@ static void show_call_param(ir_node *n, type *mt)
 /**
  * Show return modes
  */
-static void show_return_modes(ir_graph *irg, ir_node *n, type *mt, int i)
+static void show_return_modes(ir_graph *irg, ir_node *n, ir_type *mt, int i)
 {
   entity *ent = get_irg_entity(irg);
 
@@ -245,7 +245,7 @@ static void show_return_modes(ir_graph *irg, ir_node *n, type *mt, int i)
 /**
  * Show return number of results
  */
-static void show_return_nres(ir_graph *irg, ir_node *n, type *mt)
+static void show_return_nres(ir_graph *irg, ir_node *n, ir_type *mt)
 {
   entity *ent = get_irg_entity(irg);
 
@@ -590,7 +590,7 @@ static int verify_node_Proj_Proj(ir_node *pred, ir_node *p) {
   ir_mode *mode = get_irn_mode(p);
   long proj     = get_Proj_proj(p);
   long nr       = get_Proj_proj(pred);
-  type *mt; /* A method type */
+  ir_type *mt; /* A method type */
 
   pred = skip_Id(get_Proj_pred(pred));
   ASSERT_AND_RET((get_irn_mode(pred) == mode_T), "Proj from something not a tuple", 0);
@@ -868,7 +868,7 @@ static int verify_node_Return(ir_node *n, ir_graph *irg) {
   int i;
   ir_mode *mymode   = get_irn_mode(n);
   ir_mode *mem_mode = get_irn_mode(get_Return_mem(n));
-  type *mt;
+  ir_type *mt;
 
   /* Return: BB x M x data1 x ... x datan --> X */
 
@@ -884,7 +884,7 @@ static int verify_node_Return(ir_node *n, ir_graph *irg) {
     "Number of results for Return doesn't match number of results in type.", 0,
   show_return_nres(irg, n, mt););
   for (i = get_Return_n_ress(n) - 1; i >= 0; --i) {
-    type *res_type = get_method_res_type(mt, i);
+    ir_type *res_type = get_method_res_type(mt, i);
 
     if (is_atomic_type(res_type)) {
       ASSERT_AND_RET_DBG(
@@ -1003,7 +1003,7 @@ static int verify_node_Call(ir_node *n, ir_graph *irg) {
   ir_mode *mymode  = get_irn_mode(n);
   ir_mode *op1mode = get_irn_mode(get_Call_mem(n));
   ir_mode *op2mode = get_irn_mode(get_Call_ptr(n));
-  type *mt;
+  ir_type *mt;
   int i;
 
   /* Call: BB x M x ref x data1 x ... x datan
@@ -1045,7 +1045,7 @@ static int verify_node_Call(ir_node *n, ir_graph *irg) {
   }
 
   for (i = 0; i < get_method_n_params(mt); i++) {
-    type *t = get_method_param_type(mt, i);
+    ir_type *t = get_method_param_type(mt, i);
 
     if (is_atomic_type(t)) {
       ASSERT_AND_RET_DBG(
@@ -1599,7 +1599,7 @@ static int verify_node_CopyB(ir_node *n, ir_graph *irg) {
   ir_mode *op1mode = get_irn_mode(get_CopyB_mem(n));
   ir_mode *op2mode = get_irn_mode(get_CopyB_dst(n));
   ir_mode *op3mode = get_irn_mode(get_CopyB_src(n));
-  type *t = get_CopyB_type(n);
+  ir_type *t = get_CopyB_type(n);
 
   /* CopyB: BB x M x ref x ref --> M x X */
   ASSERT_AND_RET(

diff --git a/ir/opt/opt_polymorphy.c b/ir/opt/opt_polymorphy.c
index 1d31f68..4845a8f 100644 (file)
--- a/ir/opt/opt_polymorphy.c
+++ b/ir/opt/opt_polymorphy.c
@@ -28,7 +28,7 @@
  * If we find a dynamic type this means that the pointer always points
  * to an object of this type during runtime.   We resolved polymorphy.
  */
-static type *get_dynamic_type(ir_node *ptr) {
+static ir_type *get_dynamic_type(ir_node *ptr) {
   ptr = skip_Cast(skip_Proj(ptr));
   if (get_irn_op(ptr) == op_Alloc)
     return get_Alloc_type(ptr);
@@ -41,7 +41,7 @@ static type *get_dynamic_type(ir_node *ptr) {
 ir_node *transform_node_Sel(ir_node *node)
 {
   ir_node *new_node, *ptr;
-  type    *dyn_tp;
+  ir_type *dyn_tp;
   entity  *ent = get_Sel_entity(node);
 
   if (get_irp_phase_state() == phase_building) return node;
@@ -108,7 +108,7 @@ ir_node *transform_node_Load(ir_node *n)
 {
   ir_node *field_ptr, *new_node, *ptr;
   entity  *ent;
-  type    *dyn_tp;
+  ir_type *dyn_tp;
 
   if (!(get_opt_optimize() && get_opt_dyn_meth_dispatch()))
     return n;

diff --git a/ir/opt/proc_cloning.c b/ir/opt/proc_cloning.c
index 35fad98..9f19404 100644 (file)
--- a/ir/opt/proc_cloning.c
+++ b/ir/opt/proc_cloning.c
@@ -115,7 +115,7 @@ static void kill_entry(entry_t *entry) {
  */
 static void process_call(ir_node *call, entity *callee, q_set *hmap)
 {
-  type *mtp;
+  ir_type *mtp;
   entry_t *key, *entry;
   ir_node *call_param;
   int i, n_params;
@@ -384,8 +384,8 @@ static void create_clone_proc_irg(entity *ent, quad_t *q)
  **/
 static void change_entity_type(quad_t *q, entity *ent, unsigned *nr)
 {
-  type *mtp, *new_mtp, *tp;
-  ident *tp_name;
+  ir_type *mtp, *new_mtp, *tp;
+  ident   *tp_name;
   int i, n_params, n_ress, pos = 0;
 
   mtp      = get_entity_type(q->ent);
@@ -473,7 +473,7 @@ static entity *clone_method(quad_t *q)
 static ir_node *new_cl_Call(ir_node *call, entity *new_entity, int pos)
 {
   ir_node **in;
-  type *mtp;
+  ir_type *mtp;
   int i, n_params, new_params = 0;
   ir_node *callee;
   symconst_symbol sym;

diff --git a/ir/opt/scalar_replace.c b/ir/opt/scalar_replace.c
index 7f6ed79..8ffa6da 100644 (file)
--- a/ir/opt/scalar_replace.c
+++ b/ir/opt/scalar_replace.c
@@ -64,7 +64,7 @@ typedef struct _path_t {
 
 typedef struct _scalars_t {
   entity *ent;                 /**< A entity for scalar replacement. */
-  type *ent_owner;             /**< The owner of this entity. */
+  ir_type *ent_owner;          /**< The owner of this entity. */
 } scalars_t;
 
 
@@ -268,7 +268,7 @@ static int find_possible_replacements(ir_graph *irg)
 
     if (get_irn_op(succ) == op_Sel) {
       entity *ent = get_Sel_entity(succ);
-      type *ent_type;
+      ir_type *ent_type;
 
       if (get_entity_link(ent) == ADDRESS_TAKEN)
         continue;
@@ -674,7 +674,7 @@ void scalar_replacement_opt(ir_graph *irg)
   ir_mode   **modes;
   set       *set_ent;
   pset      *sels;
-  type      *ent_type;
+  ir_type   *ent_type;
   ir_graph  *rem;
 
   if (! get_opt_scalar_replacement())