Bugfix

[libfirm] / ir / tr / type.c

diff --git a/ir/tr/type.c b/ir/tr/type.c
index f30e236..10640e5 100644 (file)
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -236,6 +236,8 @@ set_type_state(type *tp, type_state state) {
        assert(get_type_size(tp) > -1);
        if (tp != get_glob_type())
          for (i = 0; i < get_class_n_members(tp); i++) {
+           if (get_entity_offset(get_class_member(tp, i)) <= -1)
+             { DDMT(tp); DDME(get_class_member(tp, i)); }
            assert(get_entity_offset(get_class_member(tp, i)) > -1);
            assert(is_method_type(get_entity_type(get_class_member(tp, i))) ||
                   (get_entity_allocation(get_class_member(tp, i)) == automatic_allocated));
@@ -835,10 +837,10 @@ build_value_type(ident *name, int len, type **tps) {
    N_param is the number of parameters, n_res the number of results.  */
 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_mach, name);
   res->state = layout_fixed;
-  assert((get_mode_size_bytes(mode_P) != -1) && "unorthodox modes not implemented");
-  res->size = get_mode_size_bytes(mode_P);
+  assert((get_mode_size_bytes(mode_P_mach) != -1) && "unorthodox modes not implemented");
+  res->size = get_mode_size_bytes(mode_P_mach);
   res->attr.ma.n_params     = n_param;
   res->attr.ma.param_type   = (type **) xmalloc (sizeof (type *) * n_param);
   res->attr.ma.value_params = NULL;
@@ -849,16 +851,19 @@ INLINE type *new_type_method (ident *name, int n_param, int 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);
   free(method->attr.ma.res_type);
 }
+
 /* manipulate private fields of method. */
 int   get_method_n_params  (type *method) {
   assert(method && (method->type_op == type_method));
@@ -1045,18 +1050,23 @@ INLINE type *new_type_array         (ident *name, int n_dimensions,
                              type *element_type) {
   type *res;
   int i;
+  ir_graph *rem = current_ir_graph;
   assert(!is_method_type(element_type));
+
   res = new_type(type_array, NULL, name);
   res->attr.aa.n_dimensions = n_dimensions;
   res->attr.aa.lower_bound  = (ir_node **) xmalloc (sizeof (ir_node *) * n_dimensions);
   res->attr.aa.upper_bound  = (ir_node **) xmalloc (sizeof (ir_node *) * n_dimensions);
   res->attr.aa.order  = (int *) xmalloc (sizeof (int) * n_dimensions);
 
+  current_ir_graph = get_const_code_irg();
   for (i = 0; i < n_dimensions; i++) {
-    res->attr.aa.lower_bound[i]  = NULL;
-    res->attr.aa.upper_bound[i]  = NULL;
+    res->attr.aa.lower_bound[i]  = new_Unknown();
+    res->attr.aa.upper_bound[i]  = new_Unknown();
     res->attr.aa.order[i] = i;
   }
+  current_ir_graph = rem;
+
   res->attr.aa.element_type = element_type;
   new_entity(res, mangle_u(name, id_from_str("elem_ent", 8)), element_type);
 
@@ -1085,6 +1095,9 @@ INLINE void
 set_array_bounds (type *array, int dimension, ir_node * lower_bound,
                  ir_node * upper_bound) {
   assert(array && (array->type_op == type_array));
+  assert(lower_bound && "lower_bound node may not be NULL.");
+  assert(upper_bound && "upper_bound node may not be NULL.");
+  assert(dimension < array->attr.aa.n_dimensions && dimension >= 0);
   array->attr.aa.lower_bound[dimension] = lower_bound;
   array->attr.aa.upper_bound[dimension] = upper_bound;
 }
@@ -1101,6 +1114,7 @@ set_array_bounds_int (type *array, int dimension, int lower_bound,
 INLINE void
 set_array_lower_bound  (type *array, int dimension, ir_node * lower_bound) {
   assert(array && (array->type_op == type_array));
+  assert(lower_bound && "lower_bound node may not be NULL.");
   array->attr.aa.lower_bound[dimension] = lower_bound;
 }
 void  set_array_lower_bound_int (type *array, int dimension, int lower_bound) {
@@ -1113,6 +1127,7 @@ void  set_array_lower_bound_int (type *array, int dimension, int lower_bound) {
 INLINE void
 set_array_upper_bound  (type *array, int dimension, ir_node * upper_bound) {
   assert(array && (array->type_op == type_array));
+  assert(upper_bound && "upper_bound node may not be NULL.");
   array->attr.aa.upper_bound[dimension] = upper_bound;
 }
 void  set_array_upper_bound_int (type *array, int dimension, int upper_bound) {
@@ -1122,10 +1137,18 @@ void  set_array_upper_bound_int (type *array, int dimension, int upper_bound) {
                          new_Const(mode_Iu, new_tarval_from_long (upper_bound, mode_Iu)));
   current_ir_graph = rem;
 }
+int       has_array_lower_bound  (type *array, int dimension) {
+  assert(array && (array->type_op == type_array));
+  return (get_irn_op(array->attr.aa.lower_bound[dimension]) != op_Unknown);
+}
 ir_node * get_array_lower_bound  (type *array, int dimension) {
   assert(array && (array->type_op == type_array));
   return array->attr.aa.lower_bound[dimension];
 }
+int       has_array_upper_bound  (type *array, int dimension) {
+  assert(array && (array->type_op == type_array));
+  return (get_irn_op(array->attr.aa.upper_bound[dimension]) != op_Unknown);
+}
 ir_node * get_array_upper_bound  (type *array, int dimension) {
   assert(array && (array->type_op == type_array));
   return array->attr.aa.upper_bound[dimension];
@@ -1239,17 +1262,18 @@ bool    is_enumeration_type     (type *enumeration) {
 /*******************************************************************/
 
 /* Create a new type pointer */
-INLINE type *new_type_pointer           (ident *name, type *points_to) {
+INLINE type *new_type_pointer_mode (ident *name, type *points_to, ir_mode *ptr_mode) {
   type *res;
-  res = new_type(type_pointer, mode_P, name);
+  assert(mode_is_reference(ptr_mode));
+  res = new_type(type_pointer, ptr_mode, name);
   res->attr.pa.points_to = points_to;
   assert((get_mode_size_bytes(res->mode) != -1) && "unorthodox modes not implemented");
   res->size = get_mode_size_bytes(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);
+type *new_d_type_pointer (ident *name, type *points_to, ir_mode *ptr_mode, dbg_info* db) {
+  type *res = new_type_pointer_mode (name, points_to, ptr_mode);
   set_type_dbg_info(res, db);
   return res;
 }
@@ -1280,7 +1304,7 @@ bool  is_pointer_type            (type *pointer) {
 /* create a new type primitive */
 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_is_reference(mode))); */
   res = new_type(type_primitive, mode, name);
   assert((get_mode_size_bytes(mode) != -1) && "unorthodox modes not implemented");
   res->size = get_mode_size_bytes(mode);