Modi umbenannt

[libfirm] / ir / tr / type.c

diff --git a/ir/tr/type.c b/ir/tr/type.c
index b1883b7..9aaab6a 100644 (file)
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -48,6 +48,9 @@
 /*******************************************************************/
 
 unsigned long type_visited;
+INLINE void set_master_type_visited(unsigned long val) { type_visited = val; }
+INLINE unsigned long get_master_type_visited() { return type_visited; }
+INLINE void inc_master_type_visited() { type_visited++; }
 
 void        free_type(type *tp) {
   /* Remove from list of all types */
@@ -512,7 +515,7 @@ bool smaller_type (type *st, type *lt) {
 /*******************************************************************/
 
 /* create a new class type */
-type   *new_type_class (ident *name) {
+INLINE type   *new_type_class (ident *name) {
   type *res;
 
   res = new_type(type_class, NULL, name);
@@ -525,6 +528,11 @@ type   *new_type_class (ident *name) {
 
   return res;
 }
+type   *new_d_type_class (ident *name, dbg_info* db) {
+  type *res = new_type_class (name);
+  set_type_dbg_info(res, db);
+  return res;
+}
 INLINE void free_class_attrs(type *clss) {
   assert(clss && (clss->type_op == type_class));
   DEL_ARR_F(clss->attr.ca.members);
@@ -564,13 +572,14 @@ void    set_class_members  (type *clss, entity **members, int arity) {
 void    remove_class_member(type *clss, entity *member) {
   int i;
   assert(clss && (clss->type_op == type_class));
-  for (i = 1; i < (ARR_LEN (clss->attr.ca.members)); i++)
+  for (i = 1; i < (ARR_LEN (clss->attr.ca.members)); i++) {
     if (clss->attr.ca.members[i] == member) {
       for(; i < (ARR_LEN (clss->attr.ca.members)) - 1; i++)
        clss->attr.ca.members[i] = clss->attr.ca.members[i + 1];
       ARR_SETLEN(entity*, clss->attr.ca.members, ARR_LEN(clss->attr.ca.members) - 1);
       break;
     }
+  }
 }
 
 void    add_class_subtype   (type *clss, type *subtype) {
@@ -691,12 +700,17 @@ bool is_subclass_of(type *low, type *high) {
 /*******************************************************************/
 
 /* create a new type struct */
-type   *new_type_struct (ident *name) {
+INLINE type   *new_type_struct (ident *name) {
   type *res;
   res = new_type(type_struct, NULL, name);
   res->attr.sa.members = NEW_ARR_F (entity *, 1);
   return res;
 }
+type   *new_d_type_struct (ident *name, dbg_info* db) {
+  type *res = new_type_struct (name);
+  set_type_dbg_info(res, db);
+  return res;
+}
 INLINE void free_struct_attrs (type *strct) {
   assert(strct && (strct->type_op == type_struct));
   DEL_ARR_F(strct->attr.sa.members);
@@ -748,17 +762,22 @@ bool    is_struct_type(type *strct) {
 
 /* Create a new method type.
    N_param is the number of parameters, n_res the number of results.  */
-type *new_type_method (ident *name, int n_param, int n_res) {
+INLINE type *new_type_method (ident *name, int n_param, int n_res) {
   type *res;
-  res = new_type(type_method, mode_p, name);
+  res = new_type(type_method, mode_P, name);
   res->state = layout_fixed;
-  res->size = get_mode_size(mode_p);
+  res->size = get_mode_size(mode_P);
   res->attr.ma.n_params   = n_param;
   res->attr.ma.param_type = (type **) xmalloc (sizeof (type *) * n_param);
   res->attr.ma.n_res      = n_res;
   res->attr.ma.res_type   = (type **) xmalloc (sizeof (type *) * n_res);
   return res;
 }
+type *new_d_type_method (ident *name, int n_param, int n_res, dbg_info* db) {
+  type *res = new_type_method (name, n_param, n_res);
+  set_type_dbg_info(res, db);
+  return res;
+}
 INLINE void free_method_attrs(type *method) {
   assert(method && (method->type_op == type_method));
   free(method->attr.ma.param_type);
@@ -774,10 +793,10 @@ type *get_method_param_type(type *method, int pos) {
   assert(pos >= 0 && pos < get_method_n_params(method));
   return method->attr.ma.param_type[pos] = skip_tid(method->attr.ma.param_type[pos]);
 }
-void  set_method_param_type(type *method, int pos, type* type) {
+void  set_method_param_type(type *method, int pos, type* tp) {
   assert(method && (method->type_op == type_method));
   assert(pos >= 0 && pos < get_method_n_params(method));
-  method->attr.ma.param_type[pos] = type;
+  method->attr.ma.param_type[pos] = tp;
 }
 
 int   get_method_n_ress   (type *method) {
@@ -789,10 +808,10 @@ type *get_method_res_type(type *method, int pos) {
   assert(pos >= 0 && pos < get_method_n_ress(method));
   return method->attr.ma.res_type[pos] = skip_tid(method->attr.ma.res_type[pos]);
 }
-void  set_method_res_type(type *method, int pos, type* type) {
+void  set_method_res_type(type *method, int pos, type* tp) {
   assert(method && (method->type_op == type_method));
   assert(pos >= 0 && pos < get_method_n_ress(method));
-  method->attr.ma.res_type[pos] = type;
+  method->attr.ma.res_type[pos] = tp;
 }
 
 /* typecheck */
@@ -807,7 +826,7 @@ bool  is_method_type     (type *method) {
 /*******************************************************************/
 
 /* create a new type uni */
-type  *new_type_uni (ident *name) {
+INLINE type  *new_type_union (ident *name) {
   type *res;
   res = new_type(type_union, NULL, name);
   /*res->attr.ua.unioned_type = (type **)  xmalloc (sizeof (type *)  * n_types);
@@ -815,6 +834,11 @@ type  *new_type_uni (ident *name) {
   res->attr.ua.members = NEW_ARR_F (entity *, 1);
   return res;
 }
+type  *new_d_type_union (ident *name, dbg_info* db) {
+  type *res = new_type_union (name);
+  set_type_dbg_info(res, db);
+  return res;
+}
 INLINE void free_union_attrs (type *uni) {
   assert(uni && (uni->type_op == type_union));
   DEL_ARR_F(uni->attr.ua.members);
@@ -830,10 +854,10 @@ type  *get_union_unioned_type (type *uni, int pos) {
   assert(pos >= 0 && pos < get_union_n_types(uni));
   return uni->attr.ua.unioned_type[pos] = skip_tid(uni->attr.ua.unioned_type[pos]);
 }
-void   set_union_unioned_type (type *uni, int pos, type *type) {
+void   set_union_unioned_type (type *uni, int pos, type *tp) {
   assert(uni && (uni->type_op == type_union));
   assert(pos >= 0 && pos < get_union_n_types(uni));
-  uni->attr.ua.unioned_type[pos] = type;
+  uni->attr.ua.unioned_type[pos] = tp;
 }
 ident *get_union_delim_nameid (type *uni, int pos) {
   assert(uni && (uni->type_op == type_union));
@@ -893,7 +917,7 @@ bool   is_union_type         (type *uni) {
 
 
 /* create a new type array -- set dimension sizes independently */
-type *new_type_array         (ident *name, int n_dimensions,
+INLINE type *new_type_array         (ident *name, int n_dimensions,
                              type *element_type) {
   type *res;
   int i;
@@ -913,6 +937,12 @@ type *new_type_array         (ident *name, int n_dimensions,
   new_entity(res, mangle_u(name, id_from_str("elem_ent", 8)), element_type);
   return res;
 }
+type *new_d_type_array (ident *name, int n_dimensions,
+                       type *element_type, dbg_info* db) {
+  type *res = new_type_array (name, n_dimensions, element_type);
+  set_type_dbg_info(res, db);
+  return res;
+}
 
 INLINE void free_array_attrs (type *array) {
   assert(array && (array->type_op == type_array));
@@ -939,8 +969,8 @@ set_array_bounds_int (type *array, int dimension, int lower_bound,
   ir_graph *rem = current_ir_graph;
   current_ir_graph = get_const_code_irg();
   set_array_bounds (array, dimension,
-                   new_Const(mode_I, tarval_from_long (mode_I, lower_bound)),
-                   new_Const(mode_I, tarval_from_long (mode_I, upper_bound)));
+                   new_Const(mode_Iu, tarval_from_long (mode_Iu, lower_bound)),
+                   new_Const(mode_Iu, tarval_from_long (mode_Iu, upper_bound)));
   current_ir_graph = rem;
 }
 INLINE void
@@ -952,7 +982,7 @@ void  set_array_lower_bound_int (type *array, int dimension, int lower_bound) {
   ir_graph *rem = current_ir_graph;
   current_ir_graph = get_const_code_irg();
   set_array_lower_bound  (array, dimension,
-                         new_Const(mode_I, tarval_from_long (mode_I, lower_bound)));
+                         new_Const(mode_Iu, tarval_from_long (mode_Iu, lower_bound)));
   current_ir_graph = rem;
 }
 INLINE void
@@ -964,7 +994,7 @@ void  set_array_upper_bound_int (type *array, int dimension, int upper_bound) {
   ir_graph *rem = current_ir_graph;
   current_ir_graph = get_const_code_irg();
   set_array_upper_bound  (array, dimension,
-                         new_Const(mode_I, tarval_from_long (mode_I, upper_bound)));
+                         new_Const(mode_Iu, tarval_from_long (mode_Iu, upper_bound)));
   current_ir_graph = rem;
 }
 ir_node * get_array_lower_bound  (type *array, int dimension) {
@@ -985,10 +1015,10 @@ int  get_array_order (type *array, int dimension) {
   return array->attr.aa.order[dimension];
 }
 
-void  set_array_element_type (type *array, type *type) {
+void  set_array_element_type (type *array, type *tp) {
   assert(array && (array->type_op == type_array));
-  assert(!is_method_type(type));
-  array->attr.aa.element_type = type;
+  assert(!is_method_type(tp));
+  array->attr.aa.element_type = tp;
 }
 type *get_array_element_type (type *array) {
   assert(array && (array->type_op == type_array));
@@ -1017,7 +1047,7 @@ bool   is_array_type         (type *array) {
 /*******************************************************************/
 
 /* create a new type enumeration -- set the enumerators independently */
-type   *new_type_enumeration    (ident *name, int n_enums) {
+INLINE type   *new_type_enumeration    (ident *name, int n_enums) {
   type *res;
   int i;
   res = new_type(type_enumeration, NULL, name);
@@ -1030,6 +1060,11 @@ type   *new_type_enumeration    (ident *name, int n_enums) {
   }
   return res;
 }
+type   *new_d_type_enumeration    (ident *name, int n_enums, dbg_info* db) {
+  type *res = new_type_enumeration (name, n_enums);
+  set_type_dbg_info(res, db);
+  return res;
+}
 
 INLINE void free_enumeration_attrs(type *enumeration) {
   assert(enumeration && (enumeration->type_op == type_enumeration));
@@ -1079,21 +1114,26 @@ bool    is_enumeration_type     (type *enumeration) {
 /*******************************************************************/
 
 /* Create a new type pointer */
-type *new_type_pointer           (ident *name, type *points_to) {
+INLINE type *new_type_pointer           (ident *name, type *points_to) {
   type *res;
-  res = new_type(type_pointer, mode_p, name);
+  res = new_type(type_pointer, mode_P, name);
   res->attr.pa.points_to = points_to;
   res->size = get_mode_size(res->mode);
   res->state = layout_fixed;
   return res;
 }
+type *new_d_type_pointer           (ident *name, type *points_to, dbg_info* db) {
+  type *res = new_type_pointer (name, points_to);
+  set_type_dbg_info(res, db);
+  return res;
+}
 INLINE void free_pointer_attrs (type *pointer) {
   assert(pointer && (pointer->type_op == type_pointer));
 }
 /* manipulate fields of type_pointer */
-void  set_pointer_points_to_type (type *pointer, type *type) {
+void  set_pointer_points_to_type (type *pointer, type *tp) {
   assert(pointer && (pointer->type_op == type_pointer));
-  pointer->attr.pa.points_to = type;
+  pointer->attr.pa.points_to = tp;
 }
 type *get_pointer_points_to_type (type *pointer) {
   assert(pointer && (pointer->type_op == type_pointer));
@@ -1112,14 +1152,19 @@ bool  is_pointer_type            (type *pointer) {
 /*******************************************************************/
 
 /* create a new type primitive */
-type *new_type_primitive (ident *name, ir_mode *mode) {
+INLINE type *new_type_primitive (ident *name, ir_mode *mode) {
   type *res;
-  /* @@@ assert( mode_is_data(mode) && (!mode == mode_p)); */
+  /* @@@ assert( mode_is_data(mode) && (!mode == mode_P)); */
   res = new_type(type_primitive, mode, name);
   res->size = get_mode_size(mode);
   res->state = layout_fixed;
   return res;
 }
+type *new_d_type_primitive (ident *name, ir_mode *mode, dbg_info* db) {
+  type *res = new_type_primitive (name, mode);
+  set_type_dbg_info(res, db);
+  return res;
+}
 INLINE void free_primitive_attrs (type *primitive) {
   assert(primitive && (primitive->type_op == type_primitive));
 }