use tv_t.h instead of tv.h

[libfirm] / ir / tr / type.c

diff --git a/ir/tr/type.c b/ir/tr/type.c
index 5d2e4b3..01c50ed 100644 (file)
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -826,6 +826,14 @@ type   *get_class_subtype   (type *clss, int pos) {
   assert(pos >= 0 && pos < get_class_n_subtypes(clss));
   return clss->attr.ca.subtypes[pos] = skip_tid(clss->attr.ca.subtypes[pos]);
 }
+int     get_class_subtype_index(type *clss, const type *subclass) {
+  int i, n_subtypes = get_class_n_subtypes(clss);
+  assert(is_Class_type(subclass));
+  for (i = 0; i < n_subtypes; ++i) {
+    if (get_class_subtype(clss, i) == subclass) return i;
+  }
+  return -1;
+}
 void    set_class_subtype   (type *clss, type *subtype, int pos) {
   assert(clss && (clss->type_op == type_class));
   assert(pos >= 0 && pos < get_class_n_subtypes(clss));
@@ -859,10 +867,9 @@ int     get_class_n_supertypes (const type *clss) {
   return (ARR_LEN (clss->attr.ca.supertypes));
 }
 int get_class_supertype_index(type *clss, type *super_clss) {
-  int i;
-  assert(clss && (clss->type_op == type_class));
+  int i, n_supertypes = get_class_n_supertypes(clss);
   assert(super_clss && (super_clss->type_op == type_class));
-  for (i = 0; i < get_class_n_supertypes(clss); i++)
+  for (i = 0; i < n_supertypes; i++)
     if (get_class_supertype(clss, i) == super_clss)
       return i;
   return -1;
@@ -890,14 +897,14 @@ void    remove_class_supertype(type *clss, type *supertype) {
 }
 
 const char *get_peculiarity_string(peculiarity p) {
+#define X(a)    case a: return #a
   switch (p) {
-  case peculiarity_description:
-    return "peculiarity_description";
-  case peculiarity_inherited:
-    return "peculiarity_inherited";
-  default:
-    return "peculiarity_existent";
+    X(peculiarity_description);
+    X(peculiarity_inherited);
+    X(peculiarity_existent);
   }
+#undef X
+  return "invalid peculiarity";
 }
 
 peculiarity get_class_peculiarity (const type *clss) {
@@ -926,21 +933,6 @@ int (is_Class_type)(const type *clss) {
   return _is_class_type(clss);
 }
 
-/* Returns true if low is subclass of high. */
-int is_subclass_of(type *low, type *high) {
-  int i;
-  assert(is_Class_type(low) && is_Class_type(high));
-  if (low == high) return 1;
-  /* depth first search from high downwards. */
-  for (i = 0; i < get_class_n_subtypes(high); i++) {
-    if (low == get_class_subtype(high, i))
-      return 1;
-    if (is_subclass_of(low, get_class_subtype(high, i)))
-      return 1;
-  }
-  return 0;
-}
-
 /*----------------------------------------------------------------**/
 /* TYPE_STRUCT                                                     */
 /*----------------------------------------------------------------**/
@@ -1353,8 +1345,7 @@ int (is_Union_type)(const type *uni) {
 
 
 /* create a new type array -- set dimension sizes independently */
-type *new_type_array         (ident *name, int n_dimensions,
-                  type *element_type) {
+type *new_type_array(ident *name, int n_dimensions, type *element_type) {
   type *res;
   int i;
   ir_graph *rem = current_ir_graph;
@@ -1368,9 +1359,9 @@ type *new_type_array         (ident *name, int n_dimensions,
 
   current_ir_graph = get_const_code_irg();
   for (i = 0; i < n_dimensions; i++) {
-    res->attr.aa.lower_bound[i]  = new_Unknown(mode_Iu);
-    res->attr.aa.upper_bound[i]  = new_Unknown(mode_Iu);
-    res->attr.aa.order[i] = i;
+    res->attr.aa.lower_bound[i] = new_Unknown(mode_Iu);
+    res->attr.aa.upper_bound[i] = new_Unknown(mode_Iu);
+    res->attr.aa.order[i]       = i;
   }
   current_ir_graph = rem;
 
@@ -1484,11 +1475,24 @@ void set_array_order (type *array, int dimension, int order) {
   assert(array && (array->type_op == type_array));
   array->attr.aa.order[dimension] = order;
 }
+
 int  get_array_order (const type *array, int dimension) {
   assert(array && (array->type_op == type_array));
   return array->attr.aa.order[dimension];
 }
 
+int find_array_dimension(const type *array, int order) {
+  int dim;
+
+  assert(array && (array->type_op == type_array));
+
+  for (dim = 0; dim < array->attr.aa.n_dimensions; ++dim) {
+    if (array->attr.aa.order[dim] == order)
+      return dim;
+  }
+  return -1;
+}
+
 void  set_array_element_type (type *array, type *tp) {
   assert(array && (array->type_op == type_array));
   assert(!is_Method_type(tp));