X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftype.c;h=524ed981fdfcbc94aa2348282a06f406b4a0548d;hb=ec68b2aaadb9504d101e6cbc4a58c69f3897f489;hp=d56140731644abbc090a167e8f6f81b366c8c411;hpb=9e82dd3f9bc8da1876a2817734e8614449cda3dd;p=libfirm

diff --git a/ir/tr/type.c b/ir/tr/type.c
index d56140731..524ed981f 100644
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -36,15 +36,25 @@
  */
 
 #ifdef HAVE_CONFIG_H
-# include <config.h>
+# include "config.h"
+#endif
+
+#ifdef HAVE_ALLOCA_H
+#include <alloca.h>
+#endif
+#ifdef HAVE_MALLOC_H
+#include <malloc.h>
+#endif
+#ifdef HAVE_STRING_H
+# include <string.h>
 #endif
 
 # include <stdlib.h>
 # include <stddef.h>
-# include <string.h>
 
 # include "type_t.h"
 
+# include "xmalloc.h"
 # include "irprog_t.h"
 # include "ircons.h"
 # include "tpop_t.h"
@@ -102,8 +112,8 @@ new_type(tp_op *type_op, ir_mode *mode, ident* name) {
   assert(!id_contains_char(name, ' ') && "type name should not contain spaces");
 
   node_size = offsetof(type, attr) +  type_op->attr_size;
-  res = (type *) xmalloc (node_size);
-  memset((void *)res, 0, node_size);
+  res = xmalloc (node_size);
+  memset(res, 0, node_size);
   add_irp_type(res);   /* Remember the new type global. */
 
   res->kind    = k_type;
@@ -117,8 +127,7 @@ new_type(tp_op *type_op, ir_mode *mode, ident* name) {
   res -> link  = NULL;
 #ifdef DEBUG_libfirm
   res->nr      = get_irp_new_node_nr();
-  res->c_name  = (char*) get_id_str (name);
-#endif
+#endif /* defined DEBUG_libfirm */
 
   return res;
 }
@@ -177,7 +186,7 @@ void (set_type_link)(type *tp, void *l)
   __set_type_link(tp, l);
 }
 
-tp_op *(get_type_tpop)(const type *tp) {
+const tp_op *(get_type_tpop)(const type *tp) {
   return __get_type_tpop(tp);
 }
 
@@ -368,25 +377,25 @@ set_type_state(type *tp, type_state state) {
       } break;
     case tpo_struct:
       {
-    assert(get_type_size_bits(tp) > -1);
-    for (i = 0; i < get_struct_n_members(tp); i++) {
-      assert(get_entity_offset_bits(get_struct_member(tp, i)) > -1);
-      assert((get_entity_allocation(get_struct_member(tp, i)) == allocation_automatic));
-    }
+        assert(get_type_size_bits(tp) > -1);
+        for (i = 0; i < get_struct_n_members(tp); i++) {
+          assert(get_entity_offset_bits(get_struct_member(tp, i)) > -1);
+          assert((get_entity_allocation(get_struct_member(tp, i)) == allocation_automatic));
+        }
       } break;
     case tpo_union:
       { /* ?? */
       } break;
     case tpo_array:
       { /* ??
-     Check order?
-     Assure that only innermost dimension is dynamic? */
+         Check order?
+         Assure that only innermost dimension is dynamic? */
       } break;
     case tpo_enumeration:
       {
-    assert(get_type_mode != NULL);
-    for (i = 0; i < get_enumeration_n_enums(tp); i++)
-      assert(get_enumeration_enum(tp, i) != NULL);
+        assert(get_type_mode != NULL);
+        for (i = 0; i < get_enumeration_n_enums(tp); i++)
+          assert(get_enumeration_enum(tp, i) != NULL);
       } break;
     default: break;
     } /* switch (tp) */
@@ -449,15 +458,15 @@ bool equal_type(type *typ1, type *typ2) {
     for (i = 0; i < get_class_n_members(typ1); i++) {
       entity *e1 = get_class_member(typ1, i);
       for (j = 0; j < get_class_n_members(typ2); j++) {
-    entity *e2 = get_class_member(typ2, j);
-    if (get_entity_name(e1) == get_entity_name(e2))
-      m[i] = e2;
+        entity *e2 = get_class_member(typ2, j);
+        if (get_entity_name(e1) == get_entity_name(e2))
+          m[i] = e2;
       }
     }
     for (i = 0; i < get_class_n_members(typ1); i++) {
       if (!m[i]  ||  /* Found no counterpart */
-      !equal_entity(get_class_member(typ1, i), m[i]))
-    return false;
+          !equal_entity(get_class_member(typ1, i), m[i]))
+        return false;
     }
     /** Compare the supertypes **/
     t = alloca(sizeof(entity *) * get_class_n_supertypes(typ1));
@@ -466,15 +475,15 @@ bool equal_type(type *typ1, type *typ2) {
     for (i = 0; i < get_class_n_supertypes(typ1); i++) {
       type *t1 = get_class_supertype(typ1, i);
       for (j = 0; j < get_class_n_supertypes(typ2); j++) {
-    type *t2 = get_class_supertype(typ2, j);
-    if (get_type_ident(t2) == get_type_ident(t1))
-      t[i] = t2;
+        type *t2 = get_class_supertype(typ2, j);
+        if (get_type_ident(t2) == get_type_ident(t1))
+          t[i] = t2;
       }
     }
     for (i = 0; i < get_class_n_supertypes(typ1); i++) {
       if (!t[i]  ||  /* Found no counterpart */
-      get_class_supertype(typ1, i) != t[i])
-    return false;
+          get_class_supertype(typ1, i) != t[i])
+        return false;
     }
   } break;
   case tpo_struct:      {
@@ -485,15 +494,15 @@ bool equal_type(type *typ1, type *typ2) {
     for (i = 0; i < get_struct_n_members(typ1); i++) {
       entity *e1 = get_struct_member(typ1, i);
       for (j = 0; j < get_struct_n_members(typ2); j++) {
-    entity *e2 = get_struct_member(typ2, j);
-    if (get_entity_name(e1) == get_entity_name(e2))
-      m[i] = e2;
+        entity *e2 = get_struct_member(typ2, j);
+        if (get_entity_name(e1) == get_entity_name(e2))
+          m[i] = e2;
       }
     }
     for (i = 0; i < get_struct_n_members(typ1); i++) {
       if (!m[i]  ||  /* Found no counterpart */
-      !equal_entity(get_struct_member(typ1, i), m[i]))
-    return false;
+          !equal_entity(get_struct_member(typ1, i), m[i]))
+        return false;
     }
   } break;
   case tpo_method:      {
@@ -519,7 +528,7 @@ bool equal_type(type *typ1, type *typ2) {
     }
     for (i = 0; i < get_method_n_ress(typ1); i++) {
       if (!equal_type(get_method_res_type(typ1, i), get_method_res_type(typ2, i)))
-    return false;
+        return false;
     }
   } break;
   case tpo_union:       {
@@ -530,15 +539,15 @@ bool equal_type(type *typ1, type *typ2) {
     for (i = 0; i < get_union_n_members(typ1); i++) {
       entity *e1 = get_union_member(typ1, i);
       for (j = 0; j < get_union_n_members(typ2); j++) {
-    entity *e2 = get_union_member(typ2, j);
-    if (get_entity_name(e1) == get_entity_name(e2))
-      m[i] = e2;
+        entity *e2 = get_union_member(typ2, j);
+        if (get_entity_name(e1) == get_entity_name(e2))
+          m[i] = e2;
       }
     }
     for (i = 0; i < get_union_n_members(typ1); i++) {
       if (!m[i]  ||  /* Found no counterpart */
-      !equal_entity(get_union_member(typ1, i), m[i]))
-    return false;
+          !equal_entity(get_union_member(typ1, i), m[i]))
+        return false;
     }
   } break;
   case tpo_array:       {
@@ -548,10 +557,10 @@ bool equal_type(type *typ1, type *typ2) {
       return false;
     for(i = 0; i < get_array_n_dimensions(typ1); i++) {
       if (get_array_lower_bound(typ1, i) != get_array_lower_bound(typ2, i) ||
-      get_array_upper_bound(typ1, i) != get_array_upper_bound(typ2, i))
-    return false;
+          get_array_upper_bound(typ1, i) != get_array_upper_bound(typ2, i))
+        return false;
       if (get_array_order(typ1, i) != get_array_order(typ2, i))
-    assert(0 && "type compare with different dimension orders not implemented");
+        assert(0 && "type compare with different dimension orders not implemented");
     }
   } break;
   case tpo_enumeration: {
@@ -596,9 +605,9 @@ bool smaller_type (type *st, type *lt) {
     }
     for (i = 0; i < get_struct_n_members(st); i++) {
       if (!m[i]  ||  /* Found no counterpart */
-      !smaller_type(get_entity_type(get_struct_member(st, i)),
-            get_entity_type(m[i])))
-    return false;
+          !smaller_type(get_entity_type(get_struct_member(st, i)),
+                get_entity_type(m[i])))
+        return false;
     }
   } break;
   case tpo_method:      {
@@ -608,11 +617,11 @@ bool smaller_type (type *st, type *lt) {
     if (get_method_n_ress(st) != get_method_n_ress(lt)) return false;
     for (i = 0; i < get_method_n_params(st); i++) {
       if (!smaller_type(get_method_param_type(st, i), get_method_param_type(lt, i)))
-    return false;
+        return false;
     }
     for (i = 0; i < get_method_n_ress(st); i++) {
       if (!smaller_type(get_method_res_type(st, i), get_method_res_type(lt, i)))
-    return false;
+        return false;
     }
   } break;
   case tpo_union:       {
@@ -623,16 +632,16 @@ bool smaller_type (type *st, type *lt) {
     for (i = 0; i < get_union_n_members(st); i++) {
       entity *se = get_union_member(st, i);
       for (j = 0; j < get_union_n_members(lt); j++) {
-    entity *le = get_union_member(lt, j);
-    if (get_entity_name(le) == get_entity_name(se))
-      m[i] = le;
-      }
+        entity *le = get_union_member(lt, j);
+        if (get_entity_name(le) == get_entity_name(se))
+          m[i] = le;
+          }
     }
     for (i = 0; i < get_union_n_members(st); i++) {
       if (!m[i]  ||  /* Found no counterpart */
-      !smaller_type(get_entity_type(get_union_member(st, i)),
-            get_entity_type(m[i])))
-    return false;
+          !smaller_type(get_entity_type(get_union_member(st, i)),
+                get_entity_type(m[i])))
+        return false;
     }
   } break;
   case tpo_array:       {
@@ -643,23 +652,23 @@ bool smaller_type (type *st, type *lt) {
     let = get_array_element_type(lt);
     if (set != let) {
       /* If the elt types are different, set must be convertible
-     to let, and they must have the same size so that address
-     computations work out.  To have a size the layout must
-     be fixed. */
+         to let, and they must have the same size so that address
+         computations work out.  To have a size the layout must
+         be fixed. */
       if ((get_type_state(set) != layout_fixed) ||
-      (get_type_state(let) != layout_fixed))
-    return false;
+          (get_type_state(let) != layout_fixed))
+        return false;
       if (!smaller_type(set, let) ||
-      get_type_size_bits(set) != get_type_size_bits(let))
-    return false;
+          get_type_size_bits(set) != get_type_size_bits(let))
+        return false;
     }
     for(i = 0; i < get_array_n_dimensions(st); i++) {
       if (get_array_lower_bound(lt, i))
-    if(get_array_lower_bound(st, i) != get_array_lower_bound(lt, i))
-      return false;
+        if(get_array_lower_bound(st, i) != get_array_lower_bound(lt, i))
+          return false;
       if (get_array_upper_bound(lt, i))
-    if(get_array_upper_bound(st, i) != get_array_upper_bound(lt, i))
-      return false;
+        if(get_array_upper_bound(st, i) != get_array_upper_bound(lt, i))
+          return false;
     }
   } break;
   case tpo_enumeration: {
@@ -1027,10 +1036,10 @@ type *new_type_method (ident *name, int n_param, int n_res) {
   res->state                        = layout_fixed;
   res->size                         = get_mode_size_bits(mode_P_mach);
   res->attr.ma.n_params             = n_param;
-  res->attr.ma.param_type           = (type **) xmalloc (sizeof (type *) * n_param);
+  res->attr.ma.param_type           = xcalloc(n_param, sizeof(res->attr.ma.param_type[0]));
   res->attr.ma.value_params         = NULL;
   res->attr.ma.n_res                = n_res;
-  res->attr.ma.res_type             = (type **) xmalloc (sizeof (type *) * n_res);
+  res->attr.ma.res_type             = xcalloc(n_res, sizeof(res->attr.ma.res_type[0]));
   res->attr.ma.value_ress           = NULL;
   res->attr.ma.variadicity          = variadicity_non_variadic;
   res->attr.ma.first_variadic_param = -1;
@@ -1231,8 +1240,8 @@ int (is_method_type)(const type *method) {
 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);
-    res->attr.ua.delim_names  = (ident **) xmalloc (sizeof (ident *) * n_types); */
+  /*res->attr.ua.unioned_type = xcalloc(n_types, sizeof(res->attr.ua.unioned_type[0]));
+    res->attr.ua.delim_names  = xcalloc(n_types, sizeof(res->attr.ua.delim_names[0])); */
   res->attr.ua.members = NEW_ARR_F (entity *, 0);
   return res;
 }
@@ -1333,9 +1342,9 @@ type *new_type_array         (ident *name, int n_dimensions,
 
   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);
+  res->attr.aa.lower_bound  = xcalloc(n_dimensions, sizeof(*res->attr.aa.lower_bound));
+  res->attr.aa.upper_bound  = xcalloc(n_dimensions, sizeof(*res->attr.aa.upper_bound));
+  res->attr.aa.order        = xcalloc(n_dimensions, sizeof(*res->attr.aa.order));
 
   current_ir_graph = get_const_code_irg();
   for (i = 0; i < n_dimensions; i++) {
@@ -1495,10 +1504,8 @@ type   *new_type_enumeration    (ident *name, int n_enums) {
   type *res;
   res = new_type(type_enumeration, NULL, name);
   res->attr.ea.n_enums     = n_enums;
-  res->attr.ea.enumer      = (tarval **)xmalloc(sizeof(res->attr.ea.enumer[0]) * n_enums);
-  res->attr.ea.enum_nameid = (ident  **)xmalloc(sizeof(res->attr.ea.enum_nameid[0]) * n_enums);
-  memset(res->attr.ea.enumer,      0, sizeof(res->attr.ea.enumer[0])      * n_enums);
-  memset(res->attr.ea.enum_nameid, 0, sizeof(res->attr.ea.enum_nameid[0]) * n_enums);
+  res->attr.ea.enumer      = xcalloc(n_enums, sizeof(res->attr.ea.enumer[0]));
+  res->attr.ea.enum_nameid = xcalloc(n_enums, sizeof(res->attr.ea.enum_nameid[0]));
   return res;
 }
 type   *new_d_type_enumeration    (ident *name, int n_enums, dbg_info* db) {
@@ -1691,6 +1698,5 @@ entity *get_compound_member(const type *tp, int pos)
 
 int is_compound_type(const type *tp) {
   assert(tp && tp->kind == k_type);
-  return (is_class_type(tp) || is_struct_type(tp) ||
-      is_array_type(tp) || is_union_type(tp));
+  return tp->type_op->flags & TP_OP_FLAG_COMPOUND;
 }